WebSVN – Kolibri OS – Diff – /programs/bcc32/include/l_tinygl.h


#ifndef __L_TINYGL_H_INCLUDED_
#define __L_TINYGL_H_INCLUDED_
//
// tinygl.obj
//
 
enum {
	/* Boolean values */
	GL_FALSE			= 0, 
	GL_TRUE				= 1, 
 
	/* Data types */
	GL_BYTE				= 0x1400, 
	GL_UNSIGNED_BYTE		= 0x1401, 
	GL_SHORT			= 0x1402, 
	GL_UNSIGNED_SHORT		= 0x1403, 
	GL_INT				= 0x1404, 
	GL_UNSIGNED_INT			= 0x1405, 
	GL_FLOAT			= 0x1406, 
	GL_DOUBLE			= 0x140A, 
	GL_2_BYTES			= 0x1407, 
	GL_3_BYTES			= 0x1408, 
	GL_4_BYTES			= 0x1409, 
 
	/* Primitives */
	GL_LINES			= 0x0001, 
	GL_POINTS			= 0x0000, 
	GL_LINE_STRIP			= 0x0003, 
	GL_LINE_LOOP			= 0x0002, 
	GL_TRIANGLES			= 0x0004, 
	GL_TRIANGLE_STRIP		= 0x0005, 
	GL_TRIANGLE_FAN			= 0x0006, 
	GL_QUADS			= 0x0007, 
	GL_QUAD_STRIP			= 0x0008, 
	GL_POLYGON			= 0x0009, 
	GL_EDGE_FLAG			= 0x0B43, 
 
	/* Vertex Arrays */
	GL_VERTEX_ARRAY			= 0x8074, 
	GL_NORMAL_ARRAY			= 0x8075, 
	GL_COLOR_ARRAY			= 0x8076, 
	GL_INDEX_ARRAY			= 0x8077, 
	GL_TEXTURE_COORD_ARRAY		= 0x8078, 
	GL_EDGE_FLAG_ARRAY		= 0x8079, 
	GL_VERTEX_ARRAY_SIZE		= 0x807A, 
	GL_VERTEX_ARRAY_TYPE		= 0x807B, 
	GL_VERTEX_ARRAY_STRIDE		= 0x807C, 
	GL_VERTEX_ARRAY_COUNT		= 0x807D, 
	GL_NORMAL_ARRAY_TYPE		= 0x807E, 
	GL_NORMAL_ARRAY_STRIDE		= 0x807F, 
	GL_NORMAL_ARRAY_COUNT		= 0x8080, 
	GL_COLOR_ARRAY_SIZE		= 0x8081, 
	GL_COLOR_ARRAY_TYPE		= 0x8082, 
	GL_COLOR_ARRAY_STRIDE		= 0x8083, 
	GL_COLOR_ARRAY_COUNT		= 0x8084, 
	GL_INDEX_ARRAY_TYPE		= 0x8085, 
	GL_INDEX_ARRAY_STRIDE		= 0x8086, 
	GL_INDEX_ARRAY_COUNT		= 0x8087, 
	GL_TEXTURE_COORD_ARRAY_SIZE	= 0x8088, 
	GL_TEXTURE_COORD_ARRAY_TYPE	= 0x8089, 
	GL_TEXTURE_COORD_ARRAY_STRIDE	= 0x808A, 
	GL_TEXTURE_COORD_ARRAY_COUNT	= 0x808B, 
	GL_EDGE_FLAG_ARRAY_STRIDE	= 0x808C, 
	GL_EDGE_FLAG_ARRAY_COUNT	= 0x808D, 
	GL_VERTEX_ARRAY_POINTER		= 0x808E, 
	GL_NORMAL_ARRAY_POINTER		= 0x808F, 
	GL_COLOR_ARRAY_POINTER		= 0x8090, 
	GL_INDEX_ARRAY_POINTER		= 0x8091, 
	GL_TEXTURE_COORD_ARRAY_POINTER	= 0x8092, 
	GL_EDGE_FLAG_ARRAY_POINTER	= 0x8093, 
	GL_V2F				= 0x2A20, 
	GL_V3F				= 0x2A21, 
	GL_C4UB_V2F			= 0x2A22, 
	GL_C4UB_V3F			= 0x2A23, 
	GL_C3F_V3F			= 0x2A24, 
	GL_N3F_V3F			= 0x2A25, 
	GL_C4F_N3F_V3F			= 0x2A26, 
	GL_T2F_V3F			= 0x2A27, 
	GL_T4F_V4F			= 0x2A28, 
	GL_T2F_C4UB_V3F			= 0x2A29, 
	GL_T2F_C3F_V3F			= 0x2A2A, 
	GL_T2F_N3F_V3F			= 0x2A2B, 
	GL_T2F_C4F_N3F_V3F		= 0x2A2C, 
	GL_T4F_C4F_N3F_V4F		= 0x2A2D, 
 
	/* Matrix Mode */
	GL_MATRIX_MODE			= 0x0BA0, 
	GL_MODELVIEW			= 0x1700, 
	GL_PROJECTION			= 0x1701, 
	GL_TEXTURE			= 0x1702, 
 
	/* Points */
	GL_POINT_SMOOTH			= 0x0B10, 
	GL_POINT_SIZE			= 0x0B11, 
	GL_POINT_SIZE_GRANULARITY 	= 0x0B13, 
	GL_POINT_SIZE_RANGE		= 0x0B12, 
 
	/* Lines */
	GL_LINE_SMOOTH			= 0x0B20, 
	GL_LINE_STIPPLE			= 0x0B24, 
	GL_LINE_STIPPLE_PATTERN		= 0x0B25, 
	GL_LINE_STIPPLE_REPEAT		= 0x0B26, 
	GL_LINE_WIDTH			= 0x0B21, 
	GL_LINE_WIDTH_GRANULARITY	= 0x0B23, 
	GL_LINE_WIDTH_RANGE		= 0x0B22, 
 
	/* Polygons */
	GL_POINT			= 0x1B00, 
	GL_LINE				= 0x1B01, 
	GL_FILL				= 0x1B02, 
	GL_CCW				= 0x0901, 
	GL_CW				= 0x0900, 
	GL_FRONT			= 0x0404, 
	GL_BACK				= 0x0405, 
	GL_CULL_FACE			= 0x0B44, 
	GL_CULL_FACE_MODE		= 0x0B45, 
	GL_POLYGON_SMOOTH		= 0x0B41, 
	GL_POLYGON_STIPPLE		= 0x0B42, 
	GL_FRONT_FACE			= 0x0B46, 
	GL_POLYGON_MODE			= 0x0B40, 
	GL_POLYGON_OFFSET_FACTOR	= 0x3038, 
	GL_POLYGON_OFFSET_UNITS		= 0x2A00, 
	GL_POLYGON_OFFSET_POINT		= 0x2A01, 
	GL_POLYGON_OFFSET_LINE		= 0x2A02, 
	GL_POLYGON_OFFSET_FILL		= 0x8037, 
 
	/* Display Lists */
	GL_COMPILE			= 0x1300, 
	GL_COMPILE_AND_EXECUTE		= 0x1301, 
	GL_LIST_BASE			= 0x0B32, 
	GL_LIST_INDEX			= 0x0B33, 
	GL_LIST_MODE			= 0x0B30, 
 
	/* Depth buffer */
	GL_NEVER			= 0x0200, 
	GL_LESS				= 0x0201, 
	GL_GEQUAL			= 0x0206, 
	GL_LEQUAL			= 0x0203, 
	GL_GREATER			= 0x0204, 
	GL_NOTEQUAL			= 0x0205, 
	GL_EQUAL			= 0x0202, 
	GL_ALWAYS			= 0x0207, 
	GL_DEPTH_TEST			= 0x0B71, 
	GL_DEPTH_BITS			= 0x0D56, 
	GL_DEPTH_CLEAR_VALUE		= 0x0B73, 
	GL_DEPTH_FUNC			= 0x0B74, 
	GL_DEPTH_RANGE			= 0x0B70, 
	GL_DEPTH_WRITEMASK		= 0x0B72, 
	GL_DEPTH_COMPONENT		= 0x1902, 
 
	/* Lighting */
	GL_LIGHTING			= 0x0B50, 
	GL_LIGHT0			= 0x4000, 
	GL_LIGHT1			= 0x4001, 
	GL_LIGHT2			= 0x4002, 
	GL_LIGHT3			= 0x4003, 
	GL_LIGHT4			= 0x4004, 
	GL_LIGHT5			= 0x4005, 
	GL_LIGHT6			= 0x4006, 
	GL_LIGHT7			= 0x4007, 
	GL_SPOT_EXPONENT		= 0x1205, 
	GL_SPOT_CUTOFF			= 0x1206, 
	GL_CONSTANT_ATTENUATION		= 0x1207, 
	GL_LINEAR_ATTENUATION		= 0x1208, 
	GL_QUADRATIC_ATTENUATION	= 0x1209, 
	GL_AMBIENT			= 0x1200, 
	GL_DIFFUSE			= 0x1201, 
	GL_SPECULAR			= 0x1202, 
	GL_SHININESS			= 0x1601, 
	GL_EMISSION			= 0x1600, 
	GL_POSITION			= 0x1203, 
	GL_SPOT_DIRECTION		= 0x1204, 
	GL_AMBIENT_AND_DIFFUSE		= 0x1602, 
	GL_COLOR_INDEXES		= 0x1603, 
	GL_LIGHT_MODEL_TWO_SIDE		= 0x0B52, 
	GL_LIGHT_MODEL_LOCAL_VIEWER	= 0x0B51, 
	GL_LIGHT_MODEL_AMBIENT		= 0x0B53, 
	GL_FRONT_AND_BACK		= 0x0408, 
	GL_SHADE_MODEL			= 0x0B54, 
	GL_FLAT				= 0x1D00, 
	GL_SMOOTH			= 0x1D01, 
	GL_COLOR_MATERIAL		= 0x0B57, 
	GL_COLOR_MATERIAL_FACE		= 0x0B55, 
	GL_COLOR_MATERIAL_PARAMETER	= 0x0B56, 
	GL_NORMALIZE			= 0x0BA1, 
 
	/* User clipping planes */
	GL_CLIP_PLANE0			= 0x3000, 
	GL_CLIP_PLANE1			= 0x3001, 
	GL_CLIP_PLANE2			= 0x3002, 
	GL_CLIP_PLANE3			= 0x3003, 
	GL_CLIP_PLANE4			= 0x3004, 
	GL_CLIP_PLANE5			= 0x3005, 
 
	/* Accumulation buffer */
	GL_ACCUM_RED_BITS		= 0x0D58, 
	GL_ACCUM_GREEN_BITS		= 0x0D59, 
	GL_ACCUM_BLUE_BITS		= 0x0D5A, 
	GL_ACCUM_ALPHA_BITS		= 0x0D5B, 
	GL_ACCUM_CLEAR_VALUE		= 0x0B80, 
	GL_ACCUM			= 0x0100, 
	GL_ADD				= 0x0104, 
	GL_LOAD				= 0x0101, 
	GL_MULT				= 0x0103, 
	GL_RETURN			= 0x0102, 
 
	/* Alpha testing */
	GL_ALPHA_TEST			= 0x0BC0, 
	GL_ALPHA_TEST_REF		= 0x0BC2, 
	GL_ALPHA_TEST_FUNC		= 0x0BC1, 
 
	/* Blending */
	GL_BLEND			= 0x0BE2, 
	GL_BLEND_SRC			= 0x0BE1, 
	GL_BLEND_DST			= 0x0BE0, 
	GL_ZERO				= 0, 
	GL_ONE				= 1, 
	GL_SRC_COLOR			= 0x0300, 
	GL_ONE_MINUS_SRC_COLOR		= 0x0301, 
	GL_DST_COLOR			= 0x0306, 
	GL_ONE_MINUS_DST_COLOR		= 0x0307, 
	GL_SRC_ALPHA			= 0x0302, 
	GL_ONE_MINUS_SRC_ALPHA		= 0x0303, 
	GL_DST_ALPHA			= 0x0304, 
	GL_ONE_MINUS_DST_ALPHA		= 0x0305, 
	GL_SRC_ALPHA_SATURATE		= 0x0308, 
	GL_CONSTANT_COLOR		= 0x8001, 
	GL_ONE_MINUS_CONSTANT_COLOR	= 0x8002, 
	GL_CONSTANT_ALPHA		= 0x8003, 
	GL_ONE_MINUS_CONSTANT_ALPHA	= 0x8004, 
 
	/* Render Mode */
	GL_FEEDBACK			= 0x1C01, 
	GL_RENDER			= 0x1C00, 
	GL_SELECT			= 0x1C02, 
 
	/* Feedback */
	GL_2D				= 0x0600, 
	GL_3D				= 0x0601, 
	GL_3D_COLOR			= 0x0602, 
	GL_3D_COLOR_TEXTURE		= 0x0603, 
	GL_4D_COLOR_TEXTURE		= 0x0604, 
	GL_POINT_TOKEN			= 0x0701, 
	GL_LINE_TOKEN			= 0x0702, 
	GL_LINE_RESET_TOKEN		= 0x0707, 
	GL_POLYGON_TOKEN		= 0x0703, 
	GL_BITMAP_TOKEN			= 0x0704, 
	GL_DRAW_PIXEL_TOKEN		= 0x0705, 
	GL_COPY_PIXEL_TOKEN		= 0x0706, 
	GL_PASS_THROUGH_TOKEN		= 0x0700, 
 
	/* Fog */
	GL_FOG				= 0x0B60, 
	GL_FOG_MODE			= 0x0B65, 
	GL_FOG_DENSITY			= 0x0B62, 
	GL_FOG_COLOR			= 0x0B66, 
	GL_FOG_INDEX			= 0x0B61, 
	GL_FOG_START			= 0x0B63, 
	GL_FOG_END			= 0x0B64, 
	GL_LINEAR			= 0x2601, 
	GL_EXP				= 0x0800, 
	GL_EXP2				= 0x0801, 
 
	/* Logic Ops */
	GL_LOGIC_OP			= 0x0BF1, 
	GL_LOGIC_OP_MODE		= 0x0BF0, 
	GL_CLEAR			= 0x1500, 
	GL_SET				= 0x150F, 
	GL_COPY				= 0x1503, 
	GL_COPY_INVERTED		= 0x150C, 
	GL_NOOP				= 0x1505, 
	GL_INVERT			= 0x150A, 
	GL_AND				= 0x1501, 
	GL_NAND				= 0x150E, 
	GL_OR				= 0x1507, 
	GL_NOR				= 0x1508, 
	GL_XOR				= 0x1506, 
	GL_EQUIV			= 0x1509, 
	GL_AND_REVERSE			= 0x1502, 
	GL_AND_INVERTED			= 0x1504, 
	GL_OR_REVERSE			= 0x150B, 
	GL_OR_INVERTED			= 0x150D, 
 
	/* Stencil */
	GL_STENCIL_TEST			= 0x0B90, 
	GL_STENCIL_WRITEMASK		= 0x0B98, 
	GL_STENCIL_BITS			= 0x0D57, 
	GL_STENCIL_FUNC			= 0x0B92, 
	GL_STENCIL_VALUE_MASK		= 0x0B93, 
	GL_STENCIL_REF			= 0x0B97, 
	GL_STENCIL_FAIL			= 0x0B94, 
	GL_STENCIL_PASS_DEPTH_PASS	= 0x0B96, 
	GL_STENCIL_PASS_DEPTH_FAIL	= 0x0B95, 
	GL_STENCIL_CLEAR_VALUE		= 0x0B91, 
	GL_STENCIL_INDEX		= 0x1901, 
	GL_KEEP				= 0x1E00, 
	GL_REPLACE			= 0x1E01, 
	GL_INCR				= 0x1E02, 
	GL_DECR				= 0x1E03, 
 
	/* Buffers, Pixel Drawing/Reading */
	GL_NONE				= 0, 
	GL_LEFT				= 0x0406, 
	GL_RIGHT			= 0x0407, 
	/*GL_FRONT			= 0x0404, */
	/*GL_BACK			= 0x0405, */
	/*GL_FRONT_AND_BACK		= 0x0408, */
	GL_FRONT_LEFT			= 0x0400, 
	GL_FRONT_RIGHT			= 0x0401, 
	GL_BACK_LEFT			= 0x0402, 
	GL_BACK_RIGHT			= 0x0403, 
	GL_AUX0				= 0x0409, 
	GL_AUX1				= 0x040A, 
	GL_AUX2				= 0x040B, 
	GL_AUX3				= 0x040C, 
	GL_COLOR_INDEX			= 0x1900, 
	GL_RED				= 0x1903, 
	GL_GREEN			= 0x1904, 
	GL_BLUE				= 0x1905, 
	GL_ALPHA			= 0x1906, 
	GL_LUMINANCE			= 0x1909, 
	GL_LUMINANCE_ALPHA		= 0x190A, 
	GL_ALPHA_BITS			= 0x0D55, 
	GL_RED_BITS			= 0x0D52, 
	GL_GREEN_BITS			= 0x0D53, 
	GL_BLUE_BITS			= 0x0D54, 
	GL_INDEX_BITS			= 0x0D51, 
	GL_SUBPIXEL_BITS		= 0x0D50, 
	GL_AUX_BUFFERS			= 0x0C00, 
	GL_READ_BUFFER			= 0x0C02, 
	GL_DRAW_BUFFER			= 0x0C01, 
	GL_DOUBLEBUFFER			= 0x0C32, 
	GL_STEREO			= 0x0C33, 
	GL_BITMAP			= 0x1A00, 
	GL_COLOR			= 0x1800, 
	GL_DEPTH			= 0x1801, 
	GL_STENCIL			= 0x1802, 
	GL_DITHER			= 0x0BD0, 
	GL_RGB				= 0x1907, 
	GL_RGBA				= 0x1908, 
 
	/* Implementation limits */
	GL_MAX_LIST_NESTING		= 0x0B31, 
	GL_MAX_ATTRIB_STACK_DEPTH	= 0x0D35, 
	GL_MAX_MODELVIEW_STACK_DEPTH	= 0x0D36, 
	GL_MAX_NAME_STACK_DEPTH		= 0x0D37, 
	GL_MAX_PROJECTION_STACK_DEPTH	= 0x0D38, 
	GL_MAX_TEXTURE_STACK_DEPTH	= 0x0D39, 
	GL_MAX_EVAL_ORDER		= 0x0D30, 
	GL_MAX_LIGHTS			= 0x0D31, 
	GL_MAX_CLIP_PLANES		= 0x0D32, 
	GL_MAX_TEXTURE_SIZE		= 0x0D33, 
	GL_MAX_PIXEL_MAP_TABLE		= 0x0D34, 
	GL_MAX_VIEWPORT_DIMS		= 0x0D3A, 
	GL_MAX_CLIENT_ATTRIB_STACK_DEPTH= 0x0D3B, 
 
	/* Gets */
	GL_ATTRIB_STACK_DEPTH		= 0x0BB0, 
	GL_COLOR_CLEAR_VALUE		= 0x0C22, 
	GL_COLOR_WRITEMASK		= 0x0C23, 
	GL_CURRENT_INDEX		= 0x0B01, 
	GL_CURRENT_COLOR		= 0x0B00, 
	GL_CURRENT_NORMAL		= 0x0B02, 
	GL_CURRENT_RASTER_COLOR		= 0x0B04, 
	GL_CURRENT_RASTER_DISTANCE	= 0x0B09, 
	GL_CURRENT_RASTER_INDEX		= 0x0B05, 
	GL_CURRENT_RASTER_POSITION	= 0x0B07, 
	GL_CURRENT_RASTER_TEXTURE_COORDS = 0x0B06, 
	GL_CURRENT_RASTER_POSITION_VALID = 0x0B08, 
	GL_CURRENT_TEXTURE_COORDS	= 0x0B03, 
	GL_INDEX_CLEAR_VALUE		= 0x0C20, 
	GL_INDEX_MODE			= 0x0C30, 
	GL_INDEX_WRITEMASK		= 0x0C21, 
	GL_MODELVIEW_MATRIX		= 0x0BA6, 
	GL_MODELVIEW_STACK_DEPTH	= 0x0BA3, 
	GL_NAME_STACK_DEPTH		= 0x0D70, 
	GL_PROJECTION_MATRIX		= 0x0BA7, 
	GL_PROJECTION_STACK_DEPTH	= 0x0BA4, 
	GL_RENDER_MODE			= 0x0C40, 
	GL_RGBA_MODE			= 0x0C31, 
	GL_TEXTURE_MATRIX		= 0x0BA8, 
	GL_TEXTURE_STACK_DEPTH		= 0x0BA5, 
	GL_VIEWPORT			= 0x0BA2, 
 
 
	/* Evaluators */
	GL_AUTO_NORMAL			= 0x0D80, 
	GL_MAP1_COLOR_4			= 0x0D90, 
	GL_MAP1_GRID_DOMAIN		= 0x0DD0, 
	GL_MAP1_GRID_SEGMENTS		= 0x0DD1, 
	GL_MAP1_INDEX			= 0x0D91, 
	GL_MAP1_NORMAL			= 0x0D92, 
	GL_MAP1_TEXTURE_COORD_1		= 0x0D93, 
	GL_MAP1_TEXTURE_COORD_2		= 0x0D94, 
	GL_MAP1_TEXTURE_COORD_3		= 0x0D95, 
	GL_MAP1_TEXTURE_COORD_4		= 0x0D96, 
	GL_MAP1_VERTEX_3		= 0x0D97, 
	GL_MAP1_VERTEX_4		= 0x0D98, 
	GL_MAP2_COLOR_4			= 0x0DB0, 
	GL_MAP2_GRID_DOMAIN		= 0x0DD2, 
	GL_MAP2_GRID_SEGMENTS		= 0x0DD3, 
	GL_MAP2_INDEX			= 0x0DB1, 
	GL_MAP2_NORMAL			= 0x0DB2, 
	GL_MAP2_TEXTURE_COORD_1		= 0x0DB3, 
	GL_MAP2_TEXTURE_COORD_2		= 0x0DB4, 
	GL_MAP2_TEXTURE_COORD_3		= 0x0DB5, 
	GL_MAP2_TEXTURE_COORD_4		= 0x0DB6, 
	GL_MAP2_VERTEX_3		= 0x0DB7, 
	GL_MAP2_VERTEX_4		= 0x0DB8, 
	GL_COEFF			= 0x0A00, 
	GL_DOMAIN			= 0x0A02, 
	GL_ORDER			= 0x0A01, 
 
	/* Hints */
	GL_FOG_HINT			= 0x0C54, 
	GL_LINE_SMOOTH_HINT		= 0x0C52, 
	GL_PERSPECTIVE_CORRECTION_HINT	= 0x0C50, 
	GL_POINT_SMOOTH_HINT		= 0x0C51, 
	GL_POLYGON_SMOOTH_HINT		= 0x0C53, 
	GL_DONT_CARE			= 0x1100, 
	GL_FASTEST			= 0x1101, 
	GL_NICEST			= 0x1102, 
 
	/* Scissor box */
	GL_SCISSOR_TEST			= 0x0C11, 
	GL_SCISSOR_BOX			= 0x0C10, 
 
	/* Pixel Mode / Transfer */
	GL_MAP_COLOR			= 0x0D10, 
	GL_MAP_STENCIL			= 0x0D11, 
	GL_INDEX_SHIFT			= 0x0D12, 
	GL_INDEX_OFFSET			= 0x0D13, 
	GL_RED_SCALE			= 0x0D14, 
	GL_RED_BIAS			= 0x0D15, 
	GL_GREEN_SCALE			= 0x0D18, 
	GL_GREEN_BIAS			= 0x0D19, 
	GL_BLUE_SCALE			= 0x0D1A, 
	GL_BLUE_BIAS			= 0x0D1B, 
	GL_ALPHA_SCALE			= 0x0D1C, 
	GL_ALPHA_BIAS			= 0x0D1D, 
	GL_DEPTH_SCALE			= 0x0D1E, 
	GL_DEPTH_BIAS			= 0x0D1F, 
	GL_PIXEL_MAP_S_TO_S_SIZE	= 0x0CB1, 
	GL_PIXEL_MAP_I_TO_I_SIZE	= 0x0CB0, 
	GL_PIXEL_MAP_I_TO_R_SIZE	= 0x0CB2, 
	GL_PIXEL_MAP_I_TO_G_SIZE	= 0x0CB3, 
	GL_PIXEL_MAP_I_TO_B_SIZE	= 0x0CB4, 
	GL_PIXEL_MAP_I_TO_A_SIZE	= 0x0CB5, 
	GL_PIXEL_MAP_R_TO_R_SIZE	= 0x0CB6, 
	GL_PIXEL_MAP_G_TO_G_SIZE	= 0x0CB7, 
	GL_PIXEL_MAP_B_TO_B_SIZE	= 0x0CB8, 
	GL_PIXEL_MAP_A_TO_A_SIZE	= 0x0CB9, 
	GL_PIXEL_MAP_S_TO_S		= 0x0C71, 
	GL_PIXEL_MAP_I_TO_I		= 0x0C70, 
	GL_PIXEL_MAP_I_TO_R		= 0x0C72, 
	GL_PIXEL_MAP_I_TO_G		= 0x0C73, 
	GL_PIXEL_MAP_I_TO_B		= 0x0C74, 
	GL_PIXEL_MAP_I_TO_A		= 0x0C75, 
	GL_PIXEL_MAP_R_TO_R		= 0x0C76, 
	GL_PIXEL_MAP_G_TO_G		= 0x0C77, 
	GL_PIXEL_MAP_B_TO_B		= 0x0C78, 
	GL_PIXEL_MAP_A_TO_A		= 0x0C79, 
	GL_PACK_ALIGNMENT		= 0x0D05, 
	GL_PACK_LSB_FIRST		= 0x0D01, 
	GL_PACK_ROW_LENGTH		= 0x0D02, 
	GL_PACK_SKIP_PIXELS		= 0x0D04, 
	GL_PACK_SKIP_ROWS		= 0x0D03, 
	GL_PACK_SWAP_BYTES		= 0x0D00, 
	GL_UNPACK_ALIGNMENT		= 0x0CF5, 
	GL_UNPACK_LSB_FIRST		= 0x0CF1, 
	GL_UNPACK_ROW_LENGTH		= 0x0CF2, 
	GL_UNPACK_SKIP_PIXELS		= 0x0CF4, 
	GL_UNPACK_SKIP_ROWS		= 0x0CF3, 
	GL_UNPACK_SWAP_BYTES		= 0x0CF0, 
	GL_ZOOM_X			= 0x0D16, 
	GL_ZOOM_Y			= 0x0D17, 
 
	/* Texture mapping */
	GL_TEXTURE_ENV			= 0x2300, 
	GL_TEXTURE_ENV_MODE		= 0x2200, 
	GL_TEXTURE_1D			= 0x0DE0, 
	GL_TEXTURE_2D			= 0x0DE1, 
	GL_TEXTURE_WRAP_S		= 0x2802, 
	GL_TEXTURE_WRAP_T		= 0x2803, 
	GL_TEXTURE_MAG_FILTER		= 0x2800, 
	GL_TEXTURE_MIN_FILTER		= 0x2801, 
	GL_TEXTURE_ENV_COLOR		= 0x2201, 
	GL_TEXTURE_GEN_S		= 0x0C60, 
	GL_TEXTURE_GEN_T		= 0x0C61, 
	GL_TEXTURE_GEN_MODE		= 0x2500, 
	GL_TEXTURE_BORDER_COLOR		= 0x1004, 
	GL_TEXTURE_WIDTH		= 0x1000, 
	GL_TEXTURE_HEIGHT		= 0x1001, 
	GL_TEXTURE_BORDER		= 0x1005, 
	GL_TEXTURE_COMPONENTS		= 0x1003, 
	GL_NEAREST_MIPMAP_NEAREST	= 0x2700, 
	GL_NEAREST_MIPMAP_LINEAR	= 0x2702, 
	GL_LINEAR_MIPMAP_NEAREST	= 0x2701, 
	GL_LINEAR_MIPMAP_LINEAR		= 0x2703, 
	GL_OBJECT_LINEAR		= 0x2401, 
	GL_OBJECT_PLANE			= 0x2501, 
	GL_EYE_LINEAR			= 0x2400, 
	GL_EYE_PLANE			= 0x2502, 
	GL_SPHERE_MAP			= 0x2402, 
	GL_DECAL			= 0x2101, 
	GL_MODULATE			= 0x2100, 
	GL_NEAREST			= 0x2600, 
	GL_REPEAT			= 0x2901, 
	GL_CLAMP			= 0x2900, 
	GL_S				= 0x2000, 
	GL_T				= 0x2001, 
	GL_R				= 0x2002, 
	GL_Q				= 0x2003, 
	GL_TEXTURE_GEN_R		= 0x0C62, 
	GL_TEXTURE_GEN_Q		= 0x0C63, 
 
	GL_PROXY_TEXTURE_1D		= 0x8063, 
	GL_PROXY_TEXTURE_2D		= 0x8064, 
	GL_TEXTURE_PRIORITY		= 0x8066, 
	GL_TEXTURE_RESIDENT		= 0x8067, 
	GL_TEXTURE_1D_BINDING		= 0x8068, 
	GL_TEXTURE_2D_BINDING		= 0x8069, 
 
	/* Internal texture formats */
	GL_ALPHA4			= 0x803B, 
	GL_ALPHA8			= 0x803C, 
	GL_ALPHA12			= 0x803D, 
	GL_ALPHA16			= 0x803E, 
	GL_LUMINANCE4			= 0x803F, 
	GL_LUMINANCE8			= 0x8040, 
	GL_LUMINANCE12			= 0x8041, 
	GL_LUMINANCE16			= 0x8042, 
	GL_LUMINANCE4_ALPHA4		= 0x8043, 
	GL_LUMINANCE6_ALPHA2		= 0x8044, 
	GL_LUMINANCE8_ALPHA8		= 0x8045, 
	GL_LUMINANCE12_ALPHA4		= 0x8046, 
	GL_LUMINANCE12_ALPHA12		= 0x8047, 
	GL_LUMINANCE16_ALPHA16		= 0x8048, 
	GL_INTENSITY			= 0x8049, 
	GL_INTENSITY4			= 0x804A, 
	GL_INTENSITY8			= 0x804B, 
	GL_INTENSITY12			= 0x804C, 
	GL_INTENSITY16			= 0x804D, 
	GL_R3_G3_B2			= 0x2A10, 
	GL_RGB4				= 0x804F, 
	GL_RGB5				= 0x8050, 
	GL_RGB8				= 0x8051, 
	GL_RGB10			= 0x8052, 
	GL_RGB12			= 0x8053, 
	GL_RGB16			= 0x8054, 
	GL_RGBA2			= 0x8055, 
	GL_RGBA4			= 0x8056, 
	GL_RGB5_A1			= 0x8057, 
	GL_RGBA8			= 0x8058, 
	GL_RGB10_A2			= 0x8059, 
	GL_RGBA12			= 0x805A, 
	GL_RGBA16			= 0x805B, 
 
	/* Utility */
	GL_VENDOR			= 0x1F00, 
	GL_RENDERER			= 0x1F01, 
	GL_VERSION			= 0x1F02, 
	GL_EXTENSIONS			= 0x1F03, 
 
	/* Errors */
	GL_INVALID_VALUE		= 0x0501, 
	GL_INVALID_ENUM			= 0x0500, 
	GL_INVALID_OPERATION		= 0x0502, 
	GL_STACK_OVERFLOW		= 0x0503, 
	GL_STACK_UNDERFLOW		= 0x0504, 
	GL_OUT_OF_MEMORY		= 0x0505, 
 
	/*
	 * 1.0 Extensions
	 */
 /* GL_EXT_blend_minmax and GL_EXT_blend_color */
	GL_CONSTANT_COLOR_EXT		= 0x8001, 
	GL_ONE_MINUS_CONSTANT_COLOR_EXT	= 0x8002, 
	GL_CONSTANT_ALPHA_EXT		= 0x8003, 
	GL_ONE_MINUS_CONSTANT_ALPHA_EXT	= 0x8004, 
	GL_BLEND_EQUATION_EXT		= 0x8009, 
	GL_MIN_EXT			= 0x8007, 
	GL_MAX_EXT			= 0x8008, 
	GL_FUNC_ADD_EXT			= 0x8006, 
	GL_FUNC_SUBTRACT_EXT		= 0x800A, 
	GL_FUNC_REVERSE_SUBTRACT_EXT	= 0x800B, 
	GL_BLEND_COLOR_EXT		= 0x8005, 
 
	/* GL_EXT_polygon_offset */
 GL_POLYGON_OFFSET_EXT = 0x8037, 
 GL_POLYGON_OFFSET_FACTOR_EXT = 0x8038, 
 GL_POLYGON_OFFSET_BIAS_EXT = 0x8039, 
 
	/* GL_EXT_vertex_array */
	GL_VERTEX_ARRAY_EXT		= 0x8074, 
	GL_NORMAL_ARRAY_EXT		= 0x8075, 
	GL_COLOR_ARRAY_EXT		= 0x8076, 
	GL_INDEX_ARRAY_EXT		= 0x8077, 
	GL_TEXTURE_COORD_ARRAY_EXT	= 0x8078, 
	GL_EDGE_FLAG_ARRAY_EXT		= 0x8079, 
	GL_VERTEX_ARRAY_SIZE_EXT	= 0x807A, 
	GL_VERTEX_ARRAY_TYPE_EXT	= 0x807B, 
	GL_VERTEX_ARRAY_STRIDE_EXT	= 0x807C, 
	GL_VERTEX_ARRAY_COUNT_EXT	= 0x807D, 
	GL_NORMAL_ARRAY_TYPE_EXT	= 0x807E, 
	GL_NORMAL_ARRAY_STRIDE_EXT	= 0x807F, 
	GL_NORMAL_ARRAY_COUNT_EXT	= 0x8080, 
	GL_COLOR_ARRAY_SIZE_EXT		= 0x8081, 
	GL_COLOR_ARRAY_TYPE_EXT		= 0x8082, 
	GL_COLOR_ARRAY_STRIDE_EXT	= 0x8083, 
	GL_COLOR_ARRAY_COUNT_EXT	= 0x8084, 
	GL_INDEX_ARRAY_TYPE_EXT		= 0x8085, 
	GL_INDEX_ARRAY_STRIDE_EXT	= 0x8086, 
	GL_INDEX_ARRAY_COUNT_EXT	= 0x8087, 
	GL_TEXTURE_COORD_ARRAY_SIZE_EXT	= 0x8088, 
	GL_TEXTURE_COORD_ARRAY_TYPE_EXT	= 0x8089, 
	GL_TEXTURE_COORD_ARRAY_STRIDE_EXT= 0x808A, 
	GL_TEXTURE_COORD_ARRAY_COUNT_EXT= 0x808B, 
	GL_EDGE_FLAG_ARRAY_STRIDE_EXT	= 0x808C, 
	GL_EDGE_FLAG_ARRAY_COUNT_EXT	= 0x808D, 
	GL_VERTEX_ARRAY_POINTER_EXT	= 0x808E, 
	GL_NORMAL_ARRAY_POINTER_EXT	= 0x808F, 
	GL_COLOR_ARRAY_POINTER_EXT	= 0x8090, 
	GL_INDEX_ARRAY_POINTER_EXT	= 0x8091, 
	GL_TEXTURE_COORD_ARRAY_POINTER_EXT= 0x8092, 
	GL_EDGE_FLAG_ARRAY_POINTER_EXT	= 0x8093
 
};
 
enum {
	GL_CURRENT_BIT		= 0x00000001, 
	GL_POINT_BIT		= 0x00000002, 
	GL_LINE_BIT		= 0x00000004, 
	GL_POLYGON_BIT		= 0x00000008, 
	GL_POLYGON_STIPPLE_BIT	= 0x00000010, 
	GL_PIXEL_MODE_BIT	= 0x00000020, 
	GL_LIGHTING_BIT		= 0x00000040, 
	GL_FOG_BIT		= 0x00000080, 
	GL_DEPTH_BUFFER_BIT	= 0x00000100, 
	GL_ACCUM_BUFFER_BIT	= 0x00000200, 
	GL_STENCIL_BUFFER_BIT	= 0x00000400, 
	GL_VIEWPORT_BIT		= 0x00000800, 
	GL_TRANSFORM_BIT	= 0x00001000, 
	GL_ENABLE_BIT		= 0x00002000, 
	GL_COLOR_BUFFER_BIT	= 0x00004000, 
	GL_HINT_BIT		= 0x00008000, 
	GL_EVAL_BIT		= 0x00010000, 
	GL_LIST_BIT		= 0x00020000, 
	GL_TEXTURE_BIT		= 0x00040000, 
	GL_SCISSOR_BIT		= 0x00080000, 
	GL_ALL_ATTRIB_BITS	= 0x000fffff
};
 
/* some types */
 
typedef int  GLenum;
typedef void GLvoid;
typedef unsigned char GLboolean;
typedef signed char	GLbyte;    /* 1-byte signed */
typedef short int   GLshort;   /* 2-byte signed */
typedef long int    GLint;     /* 4-byte signed */
typedef unsigned char GLubyte; /* 1-byte unsigned */
typedef unsigned short int GLushort; /* 2-byte unsigned */
typedef unsigned long int GLuint;    /* 4-byte unsigned */
typedef float  GLfloat;  /* single precision float */
typedef double GLdouble; /* double precision float */
typedef int    GLsizei;
 
struct ZBuffer
{
	long int xsize, ysize;
	int linesize; //line size, in bytes
	int mode;
 
	unsigned short int* zbuf;
	unsigned char* pbuf; //PIXEL
	int frame_buffer_allocated;
 
	int nb_colors;
	unsigned char* dctable;
	int* ctable;
	unsigned char* current_texture; //PIXEL
	unsigned int s_log2;
	unsigned int s_bound;
	unsigned int t_bound;
};
 
struct TinyGLContext
{
	ZBuffer* gl_context;
	long int xsize, ysize;
	long int dx, dy, x, y;
};
 
//
// tinygl - import table
//
#define import_tinygl glEnable
void (__stdcall* glEnable)(int code) = (void (__stdcall*)(int))&"glEnable";
void (__stdcall* glDisable)(int code) = (void (__stdcall*)(int))&"glDisable";
void (__stdcall* glShadeModel)(int mode) = (void (__stdcall*)(int))&"glShadeModel";
void (__stdcall* glCullFace)(int mode) = (void (__stdcall*)(int))&"glCullFace";
void (__stdcall* glPolygonMode)(int face, int mode) = (void (__stdcall*)(int, int))&"glPolygonMode";
void (__stdcall* glBegin)(int type) = (void (__stdcall*)(int))&"glBegin";
void (__stdcall* glEnd)() = (void (__stdcall*)())&"glEnd";
void (__stdcall* glVertex2f)(float x, float y) = (void (__stdcall*)(float, float))&"glVertex2f";
void (__stdcall* glVertex2d)(double x, double y) = (void (__stdcall*)(double, double))&"glVertex2d";
void (__stdcall* glVertex2fv)(float* v) = (void (__stdcall*)(float*))&"glVertex2fv";
void (__stdcall* glVertex2dv)(double* v) = (void (__stdcall*)(double*))&"glVertex2dv";
void (__stdcall* glVertex3f)(float x, float y, float z) = (void (__stdcall*)(float, float, float))&"glVertex3f";
void (__stdcall* glVertex3d)(double x, double y, double z) = (void (__stdcall*)(double, double, double))&"glVertex3d";
void (__stdcall* glVertex3fv)(float* v) = (void (__stdcall*)(float*))&"glVertex3fv";
void (__stdcall* glVertex3dv)(double* v) = (void (__stdcall*)(double*))&"glVertex3dv";
void (__stdcall* glVertex4f)(float x, float y, float z, float w) = (void (__stdcall*)(float, float, float, float))&"glVertex4f";
void (__stdcall* glVertex4d)(double x, double y, double z, double w) = (void (__stdcall*)(double, double, double, double))&"glVertex4d";
void (__stdcall* glVertex4fv)(float* v) = (void (__stdcall*)(float*))&"glVertex4fv";
void (__stdcall* glVertex4dv)(double* v) = (void (__stdcall*)(double*))&"glVertex4dv";
void (__stdcall* glColor3f)(float r, float g, float b) = (void (__stdcall*)(float, float, float))&"glColor3f";
void (__stdcall* glColor3d)(double r, double g, double b) = (void (__stdcall*)(double, double, double))&"glColor3d";
void (__stdcall* glColor3fv)(float* v) = (void (__stdcall*)(float*))&"glColor3fv";
void (__stdcall* glColor3dv)(double* v) = (void (__stdcall*)(double*))&"glColor3dv";
void (__stdcall* glColor3ub)(unsigned char r, unsigned char g, unsigned char b) = (void (__stdcall*)(unsigned char, unsigned char, unsigned char))&"glColor3ub";
void (__stdcall* glColor4f)(float r, float g, float b, float a) = (void (__stdcall*)(float, float, float, float))&"glColor4f";
void (__stdcall* glColor4d)(double r, double g, double b, double a) = (void (__stdcall*)(double, double, double, double))&"glColor4d";
void (__stdcall* glColor4fv)(float* v) = (void (__stdcall*)(float*))&"glColor4fv";
void (__stdcall* glColor4dv)(double* v) = (void (__stdcall*)(double*))&"glColor4dv";
void (__stdcall* glNormal3f)(float x, float y, float z) = (void (__stdcall*)(float, float, float))&"glNormal3f";
void (__stdcall* glNormal3d)(double x, double y, double z) = (void (__stdcall*)(double, double, double))&"glNormal3d";
void (__stdcall* glNormal3fv)(float* v) = (void (__stdcall*)(float*))&"glNormal3fv";
void (__stdcall* glNormal3dv)(double* v) = (void (__stdcall*)(double*))&"glNormal3dv";
void (__stdcall* glTexCoord1f)(float s) = (void (__stdcall*)(float))&"glTexCoord1f";
void (__stdcall* glTexCoord1d)(double s) = (void (__stdcall*)(double))&"glTexCoord1d";
void (__stdcall* glTexCoord1fv)(float* v) = (void (__stdcall*)(float*))&"glTexCoord1fv";
void (__stdcall* glTexCoord1dv)(double* v) = (void (__stdcall*)(double*))&"glTexCoord1dv";
void (__stdcall* glTexCoord2f)(float s, float t) = (void (__stdcall*)(float, float))&"glTexCoord2f";
void (__stdcall* glTexCoord2d)(double s, double t) = (void (__stdcall*)(double, double))&"glTexCoord2d";
void (__stdcall* glTexCoord2fv)(float* v) = (void (__stdcall*)(float*))&"glTexCoord2fv";
void (__stdcall* glTexCoord2dv)(double* v) = (void (__stdcall*)(double*))&"glTexCoord2dv";
void (__stdcall* glTexCoord3f)(float s, float t, float r) = (void (__stdcall*)(float, float, float))&"glTexCoord3f";
void (__stdcall* glTexCoord3d)(double s, double t, double r) = (void (__stdcall*)(double, double, double))&"glTexCoord3d";
void (__stdcall* glTexCoord3fv)(float* v) = (void (__stdcall*)(float*))&"glTexCoord3fv";
void (__stdcall* glTexCoord3dv)(double* v) = (void (__stdcall*)(double*))&"glTexCoord3dv";
void (__stdcall* glTexCoord4f)(float s, float t, float r, float q) = (void (__stdcall*)(float, float, float, float))&"glTexCoord4f";
void (__stdcall* glTexCoord4d)(double s, double t, double r, double q) = (void (__stdcall*)(double, double, double, double))&"glTexCoord4d";
void (__stdcall* glTexCoord4fv)(float* v) = (void (__stdcall*)(float*))&"glTexCoord4fv";
void (__stdcall* glTexCoord4dv)(double* v) = (void (__stdcall*)(double*))&"glTexCoord4dv";
void (__stdcall* glEdgeFlag)(int flag) = (void (__stdcall*)(int))&"glEdgeFlag";
void (__stdcall* glMatrixMode)(int mode) = (void (__stdcall*)(int))&"glMatrixMode";
void (__stdcall* glLoadMatrixf)(const float* m) = (void (__stdcall*)(const float*))&"glLoadMatrixf";
void (__stdcall* glLoadIdentity)() = (void (__stdcall*)())&"glLoadIdentity";
//void (__stdcall* glMultMatrixf)(...) = (void (__stdcall*)(...))&"glMultMatrixf";
void (__stdcall* glPushMatrix)() = (void (__stdcall*)())&"glPushMatrix";
void (__stdcall* glPopMatrix)() = (void (__stdcall*)())&"glPopMatrix";
void (__stdcall* glRotatef)(float angle, float x, float y, float z) = (void (__stdcall*)(float, float, float, float))&"glRotatef";
void (__stdcall* glTranslatef)(float x, float y, float z) = (void (__stdcall*)(float, float, float))&"glTranslatef";
void (__stdcall* glScalef)(float x, float y, float z) = (void (__stdcall*)(float, float, float))&"glScalef";
void (__stdcall* glViewport)(int x, int y, int width, int height) = (void (__stdcall*)(int, int, int, int))&"glViewport";
void (__stdcall* glFrustum)(double l, double r, double b, double t, double n, double f) = (void (__stdcall*)(double, double, double, double, double, double))&"glFrustum";
int (__stdcall* glGenLists)(int range) = (int (__stdcall*)(int))&"glGenLists";
//void (__stdcall* glIsList)(...) = (void (__stdcall*)(...))&"glIsList";
void (__stdcall* glNewList)(unsigned int list, int mode) = (void (__stdcall*)(unsigned int, int))&"glNewList";
void (__stdcall* glEndList)() = (void (__stdcall*)())&"glEndList";
void (__stdcall* glCallList)(unsigned int list) = (void (__stdcall*)(unsigned int))&"glCallList";
void (__stdcall* glClear)(int mask) = (void (__stdcall*)(int))&"glClear";
void (__stdcall* glClearColor)(float r, float g, float b, float a) = (void (__stdcall*)(float, float, float, float))&"glClearColor";
//void (__stdcall* glClearDepth)(...) = (void (__stdcall*)(...))&"glClearDepth";
void (__stdcall* glRenderMode)(int mode) = (void (__stdcall*)(int))&"glRenderMode";
//void (__stdcall* glSelectBuffer)(...) = (void (__stdcall*)(...))&"glSelectBuffer";
//void (__stdcall* glInitNames)(...) = (void (__stdcall*)(...))&"glInitNames";
//void (__stdcall* glPushName)(...) = (void (__stdcall*)(...))&"glPushName";
//void (__stdcall* glPopName)(...) = (void (__stdcall*)(...))&"glPopName";
//void (__stdcall* glLoadName)(...) = (void (__stdcall*)(...))&"glLoadName";
void (__stdcall* glGenTextures)(int n, unsigned int* textures) = (void (__stdcall*)(int, unsigned int *))&"glGenTextures";
//void (__stdcall* glDeleteTextures)(...) = (void (__stdcall*)(...))&"glDeleteTextures";
void (__stdcall* glBindTexture)(int target, int texture) = (void (__stdcall*)(int, int))&"glBindTexture";
void (__stdcall* glTexImage2D)(int target, int level, int components, int width, int height, int border, int format, int type, void *pixels) = (void (__stdcall*)(int, int, int, int, int, int, int, int, void*))&"glTexImage2D";
void (__stdcall* glTexEnvi)(int target, int pname, int param) = (void (__stdcall*)(int, int, int))&"glTexEnvi";
void (__stdcall* glTexParameteri)(int target, int pname, int param) = (void (__stdcall*)(int, int, int))&"glTexParameteri";
void (__stdcall* glPixelStorei)(int pname, int param) = (void (__stdcall*)(int, int))&"glPixelStorei";
void (__stdcall* glMaterialfv)(int mode, int type, float* v) = (void (__stdcall*)(int, int, float*))&"glMaterialfv";
void (__stdcall* glMaterialf)(int mode, int type, float v) = (void (__stdcall*)(int, int, float))&"glMaterialf";
void (__stdcall* glColorMaterial)(int mode, int type) = (void (__stdcall*)(int, int))&"glColorMaterial";
void (__stdcall* glLightfv)(int light, int type, float* v) = (void (__stdcall*)(int, int, float*))&"glLightfv";
void (__stdcall* glLightf)(int light, int type, float v) = (void (__stdcall*)(int, int, float))&"glLightf";
void (__stdcall* glLightModeli)(int pname, int param) = (void (__stdcall*)(int, int))&"glLightModeli";
void (__stdcall* glLightModelfv)(int pname, float* param) = (void (__stdcall*)(int, float*))&"glLightModelfv";
void (__stdcall* glFlush)() = (void (__stdcall*)())&"glFlush";
void (__stdcall* glHint)(int target, int mode) = (void (__stdcall*)(int, int))&"glHint";
void (__stdcall* glGetIntegerv)(int pname, int *params) = (void (__stdcall*)(int, int*))&"glGetIntegerv";
//void (__stdcall* glGetFloatv)(...) = (void (__stdcall*)(...))&"glGetFloatv";
void (__stdcall* glFrontFace)(int mode) = (void (__stdcall*)(int))&"glFrontFace";
void (__stdcall* glEnableClientState)(GLenum array) = (void (__stdcall*)(GLenum))&"glEnableClientState";
void (__stdcall* glDisableClientState)(GLenum array) = (void (__stdcall*)(GLenum))&"glDisableClientState";
void (__stdcall* glArrayElement)(GLint index) = (void (__stdcall*)(GLint))&"glArrayElement";
void (__stdcall* glDrawArrays)(GLenum mode, GLint first, GLsizei count) = (void (__stdcall*)(GLenum, GLint, GLsizei))&"glDrawArrays";
void (__stdcall* glDrawElements)(GLenum  mode, GLsizei count, GLenum type, const GLvoid *indices) = (void (__stdcall*)(GLenum, GLsizei, GLenum, const GLvoid*))&"glDrawElements";
void (__stdcall* glVertexPointer)(GLint size, GLenum type, GLsizei stride, const GLvoid* pointer) = (void (__stdcall*)(GLint, GLenum, GLsizei, const GLvoid*))&"glVertexPointer";
void (__stdcall* glColorPointer)(GLint size, GLenum type, GLsizei stride, const GLvoid* pointer) = (void (__stdcall*)(GLint, GLenum, GLsizei, const GLvoid*))&"glColorPointer";
void (__stdcall* glNormalPointer)(GLenum type, GLsizei stride, const GLvoid* pointer) = (void (__stdcall*)(GLenum, GLsizei, const GLvoid*))&"glNormalPointer";
void (__stdcall* glTexCoordPointer)(GLint size, GLenum type, GLsizei stride, const GLvoid* pointer) = (void (__stdcall*)(GLint, GLenum, GLsizei, const GLvoid*))&"glTexCoordPointer";
//void (__stdcall* glPolygonOffset)(...) = (void (__stdcall*)(...))&"glPolygonOffset";
//void (__stdcall* glOrtho)(...) = (void (__stdcall*)(...))&"glOrtho";
//void (__stdcall* glDebug)(...) = (void (__stdcall*)(...))&"glDebug";
//void (__stdcall* glInit)(...) = (void (__stdcall*)(...))&"glInit";
//void (__stdcall* glClose)(...) = (void (__stdcall*)(...))&"glClose";
//void (__stdcall* gluPerspective)(...) = (void (__stdcall*)(...))&"gluPerspective";
//void (__stdcall* gluNewQuadric)(...) = (void (__stdcall*)(...))&"gluNewQuadric";
//void (__stdcall* gluDeleteQuadric)(...) = (void (__stdcall*)(...))&"gluDeleteQuadric";
//void (__stdcall* gluQuadricDrawStyle)(...) = (void (__stdcall*)(...))&"gluQuadricDrawStyle";
//void (__stdcall* gluQuadricOrientation)(...) = (void (__stdcall*)(...))&"gluQuadricOrientation";
//void (__stdcall* gluQuadricTexture)(...) = (void (__stdcall*)(...))&"gluQuadricTexture";
//void (__stdcall* gluCylinder)(...) = (void (__stdcall*)(...))&"gluCylinder";
//void (__stdcall* gluSphere)(...) = (void (__stdcall*)(...))&"gluSphere";
void (__stdcall* kosglMakeCurrent)(long l, long t, long w, long h, TinyGLContext*) = (void (__stdcall*)(long, long, long, long, TinyGLContext*))&"kosglMakeCurrent";
void (__stdcall* kosglSwapBuffers)() = (void (__stdcall*)())&"kosglSwapBuffers";
asm{
	dd 0, 0
}
#endif

Rev 8442	Rev 8824
1	#ifndef __L_TINYGL_H_INCLUDED_	1	#ifndef __L_TINYGL_H_INCLUDED_
2	#define __L_TINYGL_H_INCLUDED_	2	#define __L_TINYGL_H_INCLUDED_
3	//	3	//
4	// tinygl.obj	4	// tinygl.obj
5	//	5	//
6		6
7	enum {	7	enum {
8	/* Boolean values */	8	/* Boolean values */
9	GL_FALSE = 0,	9	GL_FALSE = 0,
10	GL_TRUE = 1,	10	GL_TRUE = 1,
11		11
12	/* Data types */	12	/* Data types */
13	GL_BYTE = 0x1400,	13	GL_BYTE = 0x1400,
14	GL_UNSIGNED_BYTE = 0x1401,	14	GL_UNSIGNED_BYTE = 0x1401,
15	GL_SHORT = 0x1402,	15	GL_SHORT = 0x1402,
16	GL_UNSIGNED_SHORT = 0x1403,	16	GL_UNSIGNED_SHORT = 0x1403,
17	GL_INT = 0x1404,	17	GL_INT = 0x1404,
18	GL_UNSIGNED_INT = 0x1405,	18	GL_UNSIGNED_INT = 0x1405,
19	GL_FLOAT = 0x1406,	19	GL_FLOAT = 0x1406,
20	GL_DOUBLE = 0x140A,	20	GL_DOUBLE = 0x140A,
21	GL_2_BYTES = 0x1407,	21	GL_2_BYTES = 0x1407,
22	GL_3_BYTES = 0x1408,	22	GL_3_BYTES = 0x1408,
23	GL_4_BYTES = 0x1409,	23	GL_4_BYTES = 0x1409,
24		24
25	/* Primitives */	25	/* Primitives */
26	GL_LINES = 0x0001,	26	GL_LINES = 0x0001,
27	GL_POINTS = 0x0000,	27	GL_POINTS = 0x0000,
28	GL_LINE_STRIP = 0x0003,	28	GL_LINE_STRIP = 0x0003,
29	GL_LINE_LOOP = 0x0002,	29	GL_LINE_LOOP = 0x0002,
30	GL_TRIANGLES = 0x0004,	30	GL_TRIANGLES = 0x0004,
31	GL_TRIANGLE_STRIP = 0x0005,	31	GL_TRIANGLE_STRIP = 0x0005,
32	GL_TRIANGLE_FAN = 0x0006,	32	GL_TRIANGLE_FAN = 0x0006,
33	GL_QUADS = 0x0007,	33	GL_QUADS = 0x0007,
34	GL_QUAD_STRIP = 0x0008,	34	GL_QUAD_STRIP = 0x0008,
35	GL_POLYGON = 0x0009,	35	GL_POLYGON = 0x0009,
36	GL_EDGE_FLAG = 0x0B43,	36	GL_EDGE_FLAG = 0x0B43,
37		37
38	/* Vertex Arrays */	38	/* Vertex Arrays */
39	GL_VERTEX_ARRAY = 0x8074,	39	GL_VERTEX_ARRAY = 0x8074,
40	GL_NORMAL_ARRAY = 0x8075,	40	GL_NORMAL_ARRAY = 0x8075,
41	GL_COLOR_ARRAY = 0x8076,	41	GL_COLOR_ARRAY = 0x8076,
42	GL_INDEX_ARRAY = 0x8077,	42	GL_INDEX_ARRAY = 0x8077,
43	GL_TEXTURE_COORD_ARRAY = 0x8078,	43	GL_TEXTURE_COORD_ARRAY = 0x8078,
44	GL_EDGE_FLAG_ARRAY = 0x8079,	44	GL_EDGE_FLAG_ARRAY = 0x8079,
45	GL_VERTEX_ARRAY_SIZE = 0x807A,	45	GL_VERTEX_ARRAY_SIZE = 0x807A,
46	GL_VERTEX_ARRAY_TYPE = 0x807B,	46	GL_VERTEX_ARRAY_TYPE = 0x807B,
47	GL_VERTEX_ARRAY_STRIDE = 0x807C,	47	GL_VERTEX_ARRAY_STRIDE = 0x807C,
48	GL_VERTEX_ARRAY_COUNT = 0x807D,	48	GL_VERTEX_ARRAY_COUNT = 0x807D,
49	GL_NORMAL_ARRAY_TYPE = 0x807E,	49	GL_NORMAL_ARRAY_TYPE = 0x807E,
50	GL_NORMAL_ARRAY_STRIDE = 0x807F,	50	GL_NORMAL_ARRAY_STRIDE = 0x807F,
51	GL_NORMAL_ARRAY_COUNT = 0x8080,	51	GL_NORMAL_ARRAY_COUNT = 0x8080,
52	GL_COLOR_ARRAY_SIZE = 0x8081,	52	GL_COLOR_ARRAY_SIZE = 0x8081,
53	GL_COLOR_ARRAY_TYPE = 0x8082,	53	GL_COLOR_ARRAY_TYPE = 0x8082,
54	GL_COLOR_ARRAY_STRIDE = 0x8083,	54	GL_COLOR_ARRAY_STRIDE = 0x8083,
55	GL_COLOR_ARRAY_COUNT = 0x8084,	55	GL_COLOR_ARRAY_COUNT = 0x8084,
56	GL_INDEX_ARRAY_TYPE = 0x8085,	56	GL_INDEX_ARRAY_TYPE = 0x8085,
57	GL_INDEX_ARRAY_STRIDE = 0x8086,	57	GL_INDEX_ARRAY_STRIDE = 0x8086,
58	GL_INDEX_ARRAY_COUNT = 0x8087,	58	GL_INDEX_ARRAY_COUNT = 0x8087,
59	GL_TEXTURE_COORD_ARRAY_SIZE = 0x8088,	59	GL_TEXTURE_COORD_ARRAY_SIZE = 0x8088,
60	GL_TEXTURE_COORD_ARRAY_TYPE = 0x8089,	60	GL_TEXTURE_COORD_ARRAY_TYPE = 0x8089,
61	GL_TEXTURE_COORD_ARRAY_STRIDE = 0x808A,	61	GL_TEXTURE_COORD_ARRAY_STRIDE = 0x808A,
62	GL_TEXTURE_COORD_ARRAY_COUNT = 0x808B,	62	GL_TEXTURE_COORD_ARRAY_COUNT = 0x808B,
63	GL_EDGE_FLAG_ARRAY_STRIDE = 0x808C,	63	GL_EDGE_FLAG_ARRAY_STRIDE = 0x808C,
64	GL_EDGE_FLAG_ARRAY_COUNT = 0x808D,	64	GL_EDGE_FLAG_ARRAY_COUNT = 0x808D,
65	GL_VERTEX_ARRAY_POINTER = 0x808E,	65	GL_VERTEX_ARRAY_POINTER = 0x808E,
66	GL_NORMAL_ARRAY_POINTER = 0x808F,	66	GL_NORMAL_ARRAY_POINTER = 0x808F,
67	GL_COLOR_ARRAY_POINTER = 0x8090,	67	GL_COLOR_ARRAY_POINTER = 0x8090,
68	GL_INDEX_ARRAY_POINTER = 0x8091,	68	GL_INDEX_ARRAY_POINTER = 0x8091,
69	GL_TEXTURE_COORD_ARRAY_POINTER = 0x8092,	69	GL_TEXTURE_COORD_ARRAY_POINTER = 0x8092,
70	GL_EDGE_FLAG_ARRAY_POINTER = 0x8093,	70	GL_EDGE_FLAG_ARRAY_POINTER = 0x8093,
71	GL_V2F = 0x2A20,	71	GL_V2F = 0x2A20,
72	GL_V3F = 0x2A21,	72	GL_V3F = 0x2A21,
73	GL_C4UB_V2F = 0x2A22,	73	GL_C4UB_V2F = 0x2A22,
74	GL_C4UB_V3F = 0x2A23,	74	GL_C4UB_V3F = 0x2A23,
75	GL_C3F_V3F = 0x2A24,	75	GL_C3F_V3F = 0x2A24,
76	GL_N3F_V3F = 0x2A25,	76	GL_N3F_V3F = 0x2A25,
77	GL_C4F_N3F_V3F = 0x2A26,	77	GL_C4F_N3F_V3F = 0x2A26,
78	GL_T2F_V3F = 0x2A27,	78	GL_T2F_V3F = 0x2A27,
79	GL_T4F_V4F = 0x2A28,	79	GL_T4F_V4F = 0x2A28,
80	GL_T2F_C4UB_V3F = 0x2A29,	80	GL_T2F_C4UB_V3F = 0x2A29,
81	GL_T2F_C3F_V3F = 0x2A2A,	81	GL_T2F_C3F_V3F = 0x2A2A,
82	GL_T2F_N3F_V3F = 0x2A2B,	82	GL_T2F_N3F_V3F = 0x2A2B,
83	GL_T2F_C4F_N3F_V3F = 0x2A2C,	83	GL_T2F_C4F_N3F_V3F = 0x2A2C,
84	GL_T4F_C4F_N3F_V4F = 0x2A2D,	84	GL_T4F_C4F_N3F_V4F = 0x2A2D,
85		85
86	/* Matrix Mode */	86	/* Matrix Mode */
87	GL_MATRIX_MODE = 0x0BA0,	87	GL_MATRIX_MODE = 0x0BA0,
88	GL_MODELVIEW = 0x1700,	88	GL_MODELVIEW = 0x1700,
89	GL_PROJECTION = 0x1701,	89	GL_PROJECTION = 0x1701,
90	GL_TEXTURE = 0x1702,	90	GL_TEXTURE = 0x1702,
91		91
92	/* Points */	92	/* Points */
93	GL_POINT_SMOOTH = 0x0B10,	93	GL_POINT_SMOOTH = 0x0B10,
94	GL_POINT_SIZE = 0x0B11,	94	GL_POINT_SIZE = 0x0B11,
95	GL_POINT_SIZE_GRANULARITY = 0x0B13,	95	GL_POINT_SIZE_GRANULARITY = 0x0B13,
96	GL_POINT_SIZE_RANGE = 0x0B12,	96	GL_POINT_SIZE_RANGE = 0x0B12,
97		97
98	/* Lines */	98	/* Lines */
99	GL_LINE_SMOOTH = 0x0B20,	99	GL_LINE_SMOOTH = 0x0B20,
100	GL_LINE_STIPPLE = 0x0B24,	100	GL_LINE_STIPPLE = 0x0B24,
101	GL_LINE_STIPPLE_PATTERN = 0x0B25,	101	GL_LINE_STIPPLE_PATTERN = 0x0B25,
102	GL_LINE_STIPPLE_REPEAT = 0x0B26,	102	GL_LINE_STIPPLE_REPEAT = 0x0B26,
103	GL_LINE_WIDTH = 0x0B21,	103	GL_LINE_WIDTH = 0x0B21,
104	GL_LINE_WIDTH_GRANULARITY = 0x0B23,	104	GL_LINE_WIDTH_GRANULARITY = 0x0B23,
105	GL_LINE_WIDTH_RANGE = 0x0B22,	105	GL_LINE_WIDTH_RANGE = 0x0B22,
106		106
107	/* Polygons */	107	/* Polygons */
108	GL_POINT = 0x1B00,	108	GL_POINT = 0x1B00,
109	GL_LINE = 0x1B01,	109	GL_LINE = 0x1B01,
110	GL_FILL = 0x1B02,	110	GL_FILL = 0x1B02,
111	GL_CCW = 0x0901,	111	GL_CCW = 0x0901,
112	GL_CW = 0x0900,	112	GL_CW = 0x0900,
113	GL_FRONT = 0x0404,	113	GL_FRONT = 0x0404,
114	GL_BACK = 0x0405,	114	GL_BACK = 0x0405,
115	GL_CULL_FACE = 0x0B44,	115	GL_CULL_FACE = 0x0B44,
116	GL_CULL_FACE_MODE = 0x0B45,	116	GL_CULL_FACE_MODE = 0x0B45,
117	GL_POLYGON_SMOOTH = 0x0B41,	117	GL_POLYGON_SMOOTH = 0x0B41,
118	GL_POLYGON_STIPPLE = 0x0B42,	118	GL_POLYGON_STIPPLE = 0x0B42,
119	GL_FRONT_FACE = 0x0B46,	119	GL_FRONT_FACE = 0x0B46,
120	GL_POLYGON_MODE = 0x0B40,	120	GL_POLYGON_MODE = 0x0B40,
121	GL_POLYGON_OFFSET_FACTOR = 0x3038,	121	GL_POLYGON_OFFSET_FACTOR = 0x3038,
122	GL_POLYGON_OFFSET_UNITS = 0x2A00,	122	GL_POLYGON_OFFSET_UNITS = 0x2A00,
123	GL_POLYGON_OFFSET_POINT = 0x2A01,	123	GL_POLYGON_OFFSET_POINT = 0x2A01,
124	GL_POLYGON_OFFSET_LINE = 0x2A02,	124	GL_POLYGON_OFFSET_LINE = 0x2A02,
125	GL_POLYGON_OFFSET_FILL = 0x8037,	125	GL_POLYGON_OFFSET_FILL = 0x8037,
126		126
127	/* Display Lists */	127	/* Display Lists */
128	GL_COMPILE = 0x1300,	128	GL_COMPILE = 0x1300,
129	GL_COMPILE_AND_EXECUTE = 0x1301,	129	GL_COMPILE_AND_EXECUTE = 0x1301,
130	GL_LIST_BASE = 0x0B32,	130	GL_LIST_BASE = 0x0B32,
131	GL_LIST_INDEX = 0x0B33,	131	GL_LIST_INDEX = 0x0B33,
132	GL_LIST_MODE = 0x0B30,	132	GL_LIST_MODE = 0x0B30,
133		133
134	/* Depth buffer */	134	/* Depth buffer */
135	GL_NEVER = 0x0200,	135	GL_NEVER = 0x0200,
136	GL_LESS = 0x0201,	136	GL_LESS = 0x0201,
137	GL_GEQUAL = 0x0206,	137	GL_GEQUAL = 0x0206,
138	GL_LEQUAL = 0x0203,	138	GL_LEQUAL = 0x0203,
139	GL_GREATER = 0x0204,	139	GL_GREATER = 0x0204,
140	GL_NOTEQUAL = 0x0205,	140	GL_NOTEQUAL = 0x0205,
141	GL_EQUAL = 0x0202,	141	GL_EQUAL = 0x0202,
142	GL_ALWAYS = 0x0207,	142	GL_ALWAYS = 0x0207,
143	GL_DEPTH_TEST = 0x0B71,	143	GL_DEPTH_TEST = 0x0B71,
144	GL_DEPTH_BITS = 0x0D56,	144	GL_DEPTH_BITS = 0x0D56,
145	GL_DEPTH_CLEAR_VALUE = 0x0B73,	145	GL_DEPTH_CLEAR_VALUE = 0x0B73,
146	GL_DEPTH_FUNC = 0x0B74,	146	GL_DEPTH_FUNC = 0x0B74,
147	GL_DEPTH_RANGE = 0x0B70,	147	GL_DEPTH_RANGE = 0x0B70,
148	GL_DEPTH_WRITEMASK = 0x0B72,	148	GL_DEPTH_WRITEMASK = 0x0B72,
149	GL_DEPTH_COMPONENT = 0x1902,	149	GL_DEPTH_COMPONENT = 0x1902,
150		150
151	/* Lighting */	151	/* Lighting */
152	GL_LIGHTING = 0x0B50,	152	GL_LIGHTING = 0x0B50,
153	GL_LIGHT0 = 0x4000,	153	GL_LIGHT0 = 0x4000,
154	GL_LIGHT1 = 0x4001,	154	GL_LIGHT1 = 0x4001,
155	GL_LIGHT2 = 0x4002,	155	GL_LIGHT2 = 0x4002,
156	GL_LIGHT3 = 0x4003,	156	GL_LIGHT3 = 0x4003,
157	GL_LIGHT4 = 0x4004,	157	GL_LIGHT4 = 0x4004,
158	GL_LIGHT5 = 0x4005,	158	GL_LIGHT5 = 0x4005,
159	GL_LIGHT6 = 0x4006,	159	GL_LIGHT6 = 0x4006,
160	GL_LIGHT7 = 0x4007,	160	GL_LIGHT7 = 0x4007,
161	GL_SPOT_EXPONENT = 0x1205,	161	GL_SPOT_EXPONENT = 0x1205,
162	GL_SPOT_CUTOFF = 0x1206,	162	GL_SPOT_CUTOFF = 0x1206,
163	GL_CONSTANT_ATTENUATION = 0x1207,	163	GL_CONSTANT_ATTENUATION = 0x1207,
164	GL_LINEAR_ATTENUATION = 0x1208,	164	GL_LINEAR_ATTENUATION = 0x1208,
165	GL_QUADRATIC_ATTENUATION = 0x1209,	165	GL_QUADRATIC_ATTENUATION = 0x1209,
166	GL_AMBIENT = 0x1200,	166	GL_AMBIENT = 0x1200,
167	GL_DIFFUSE = 0x1201,	167	GL_DIFFUSE = 0x1201,
168	GL_SPECULAR = 0x1202,	168	GL_SPECULAR = 0x1202,
169	GL_SHININESS = 0x1601,	169	GL_SHININESS = 0x1601,
170	GL_EMISSION = 0x1600,	170	GL_EMISSION = 0x1600,
171	GL_POSITION = 0x1203,	171	GL_POSITION = 0x1203,
172	GL_SPOT_DIRECTION = 0x1204,	172	GL_SPOT_DIRECTION = 0x1204,
173	GL_AMBIENT_AND_DIFFUSE = 0x1602,	173	GL_AMBIENT_AND_DIFFUSE = 0x1602,
174	GL_COLOR_INDEXES = 0x1603,	174	GL_COLOR_INDEXES = 0x1603,
175	GL_LIGHT_MODEL_TWO_SIDE = 0x0B52,	175	GL_LIGHT_MODEL_TWO_SIDE = 0x0B52,
176	GL_LIGHT_MODEL_LOCAL_VIEWER = 0x0B51,	176	GL_LIGHT_MODEL_LOCAL_VIEWER = 0x0B51,
177	GL_LIGHT_MODEL_AMBIENT = 0x0B53,	177	GL_LIGHT_MODEL_AMBIENT = 0x0B53,
178	GL_FRONT_AND_BACK = 0x0408,	178	GL_FRONT_AND_BACK = 0x0408,
179	GL_SHADE_MODEL = 0x0B54,	179	GL_SHADE_MODEL = 0x0B54,
180	GL_FLAT = 0x1D00,	180	GL_FLAT = 0x1D00,
181	GL_SMOOTH = 0x1D01,	181	GL_SMOOTH = 0x1D01,
182	GL_COLOR_MATERIAL = 0x0B57,	182	GL_COLOR_MATERIAL = 0x0B57,
183	GL_COLOR_MATERIAL_FACE = 0x0B55,	183	GL_COLOR_MATERIAL_FACE = 0x0B55,
184	GL_COLOR_MATERIAL_PARAMETER = 0x0B56,	184	GL_COLOR_MATERIAL_PARAMETER = 0x0B56,
185	GL_NORMALIZE = 0x0BA1,	185	GL_NORMALIZE = 0x0BA1,
186		186
187	/* User clipping planes */	187	/* User clipping planes */
188	GL_CLIP_PLANE0 = 0x3000,	188	GL_CLIP_PLANE0 = 0x3000,
189	GL_CLIP_PLANE1 = 0x3001,	189	GL_CLIP_PLANE1 = 0x3001,
190	GL_CLIP_PLANE2 = 0x3002,	190	GL_CLIP_PLANE2 = 0x3002,
191	GL_CLIP_PLANE3 = 0x3003,	191	GL_CLIP_PLANE3 = 0x3003,
192	GL_CLIP_PLANE4 = 0x3004,	192	GL_CLIP_PLANE4 = 0x3004,
193	GL_CLIP_PLANE5 = 0x3005,	193	GL_CLIP_PLANE5 = 0x3005,
194		194
195	/* Accumulation buffer */	195	/* Accumulation buffer */
196	GL_ACCUM_RED_BITS = 0x0D58,	196	GL_ACCUM_RED_BITS = 0x0D58,
197	GL_ACCUM_GREEN_BITS = 0x0D59,	197	GL_ACCUM_GREEN_BITS = 0x0D59,
198	GL_ACCUM_BLUE_BITS = 0x0D5A,	198	GL_ACCUM_BLUE_BITS = 0x0D5A,
199	GL_ACCUM_ALPHA_BITS = 0x0D5B,	199	GL_ACCUM_ALPHA_BITS = 0x0D5B,
200	GL_ACCUM_CLEAR_VALUE = 0x0B80,	200	GL_ACCUM_CLEAR_VALUE = 0x0B80,
201	GL_ACCUM = 0x0100,	201	GL_ACCUM = 0x0100,
202	GL_ADD = 0x0104,	202	GL_ADD = 0x0104,
203	GL_LOAD = 0x0101,	203	GL_LOAD = 0x0101,
204	GL_MULT = 0x0103,	204	GL_MULT = 0x0103,
205	GL_RETURN = 0x0102,	205	GL_RETURN = 0x0102,
206		206
207	/* Alpha testing */	207	/* Alpha testing */
208	GL_ALPHA_TEST = 0x0BC0,	208	GL_ALPHA_TEST = 0x0BC0,
209	GL_ALPHA_TEST_REF = 0x0BC2,	209	GL_ALPHA_TEST_REF = 0x0BC2,
210	GL_ALPHA_TEST_FUNC = 0x0BC1,	210	GL_ALPHA_TEST_FUNC = 0x0BC1,
211		211
212	/* Blending */	212	/* Blending */
213	GL_BLEND = 0x0BE2,	213	GL_BLEND = 0x0BE2,
214	GL_BLEND_SRC = 0x0BE1,	214	GL_BLEND_SRC = 0x0BE1,
215	GL_BLEND_DST = 0x0BE0,	215	GL_BLEND_DST = 0x0BE0,
216	GL_ZERO = 0,	216	GL_ZERO = 0,
217	GL_ONE = 1,	217	GL_ONE = 1,
218	GL_SRC_COLOR = 0x0300,	218	GL_SRC_COLOR = 0x0300,
219	GL_ONE_MINUS_SRC_COLOR = 0x0301,	219	GL_ONE_MINUS_SRC_COLOR = 0x0301,
220	GL_DST_COLOR = 0x0306,	220	GL_DST_COLOR = 0x0306,
221	GL_ONE_MINUS_DST_COLOR = 0x0307,	221	GL_ONE_MINUS_DST_COLOR = 0x0307,
222	GL_SRC_ALPHA = 0x0302,	222	GL_SRC_ALPHA = 0x0302,
223	GL_ONE_MINUS_SRC_ALPHA = 0x0303,	223	GL_ONE_MINUS_SRC_ALPHA = 0x0303,
224	GL_DST_ALPHA = 0x0304,	224	GL_DST_ALPHA = 0x0304,
225	GL_ONE_MINUS_DST_ALPHA = 0x0305,	225	GL_ONE_MINUS_DST_ALPHA = 0x0305,
226	GL_SRC_ALPHA_SATURATE = 0x0308,	226	GL_SRC_ALPHA_SATURATE = 0x0308,
227	GL_CONSTANT_COLOR = 0x8001,	227	GL_CONSTANT_COLOR = 0x8001,
228	GL_ONE_MINUS_CONSTANT_COLOR = 0x8002,	228	GL_ONE_MINUS_CONSTANT_COLOR = 0x8002,
229	GL_CONSTANT_ALPHA = 0x8003,	229	GL_CONSTANT_ALPHA = 0x8003,
230	GL_ONE_MINUS_CONSTANT_ALPHA = 0x8004,	230	GL_ONE_MINUS_CONSTANT_ALPHA = 0x8004,
231		231
232	/* Render Mode */	232	/* Render Mode */
233	GL_FEEDBACK = 0x1C01,	233	GL_FEEDBACK = 0x1C01,
234	GL_RENDER = 0x1C00,	234	GL_RENDER = 0x1C00,
235	GL_SELECT = 0x1C02,	235	GL_SELECT = 0x1C02,
236		236
237	/* Feedback */	237	/* Feedback */
238	GL_2D = 0x0600,	238	GL_2D = 0x0600,
239	GL_3D = 0x0601,	239	GL_3D = 0x0601,
240	GL_3D_COLOR = 0x0602,	240	GL_3D_COLOR = 0x0602,
241	GL_3D_COLOR_TEXTURE = 0x0603,	241	GL_3D_COLOR_TEXTURE = 0x0603,
242	GL_4D_COLOR_TEXTURE = 0x0604,	242	GL_4D_COLOR_TEXTURE = 0x0604,
243	GL_POINT_TOKEN = 0x0701,	243	GL_POINT_TOKEN = 0x0701,
244	GL_LINE_TOKEN = 0x0702,	244	GL_LINE_TOKEN = 0x0702,
245	GL_LINE_RESET_TOKEN = 0x0707,	245	GL_LINE_RESET_TOKEN = 0x0707,
246	GL_POLYGON_TOKEN = 0x0703,	246	GL_POLYGON_TOKEN = 0x0703,
247	GL_BITMAP_TOKEN = 0x0704,	247	GL_BITMAP_TOKEN = 0x0704,
248	GL_DRAW_PIXEL_TOKEN = 0x0705,	248	GL_DRAW_PIXEL_TOKEN = 0x0705,
249	GL_COPY_PIXEL_TOKEN = 0x0706,	249	GL_COPY_PIXEL_TOKEN = 0x0706,
250	GL_PASS_THROUGH_TOKEN = 0x0700,	250	GL_PASS_THROUGH_TOKEN = 0x0700,
251		251
252	/* Fog */	252	/* Fog */
253	GL_FOG = 0x0B60,	253	GL_FOG = 0x0B60,
254	GL_FOG_MODE = 0x0B65,	254	GL_FOG_MODE = 0x0B65,
255	GL_FOG_DENSITY = 0x0B62,	255	GL_FOG_DENSITY = 0x0B62,
256	GL_FOG_COLOR = 0x0B66,	256	GL_FOG_COLOR = 0x0B66,
257	GL_FOG_INDEX = 0x0B61,	257	GL_FOG_INDEX = 0x0B61,
258	GL_FOG_START = 0x0B63,	258	GL_FOG_START = 0x0B63,
259	GL_FOG_END = 0x0B64,	259	GL_FOG_END = 0x0B64,
260	GL_LINEAR = 0x2601,	260	GL_LINEAR = 0x2601,
261	GL_EXP = 0x0800,	261	GL_EXP = 0x0800,
262	GL_EXP2 = 0x0801,	262	GL_EXP2 = 0x0801,
263		263
264	/* Logic Ops */	264	/* Logic Ops */
265	GL_LOGIC_OP = 0x0BF1,	265	GL_LOGIC_OP = 0x0BF1,
266	GL_LOGIC_OP_MODE = 0x0BF0,	266	GL_LOGIC_OP_MODE = 0x0BF0,
267	GL_CLEAR = 0x1500,	267	GL_CLEAR = 0x1500,
268	GL_SET = 0x150F,	268	GL_SET = 0x150F,
269	GL_COPY = 0x1503,	269	GL_COPY = 0x1503,
270	GL_COPY_INVERTED = 0x150C,	270	GL_COPY_INVERTED = 0x150C,
271	GL_NOOP = 0x1505,	271	GL_NOOP = 0x1505,
272	GL_INVERT = 0x150A,	272	GL_INVERT = 0x150A,
273	GL_AND = 0x1501,	273	GL_AND = 0x1501,
274	GL_NAND = 0x150E,	274	GL_NAND = 0x150E,
275	GL_OR = 0x1507,	275	GL_OR = 0x1507,
276	GL_NOR = 0x1508,	276	GL_NOR = 0x1508,
277	GL_XOR = 0x1506,	277	GL_XOR = 0x1506,
278	GL_EQUIV = 0x1509,	278	GL_EQUIV = 0x1509,
279	GL_AND_REVERSE = 0x1502,	279	GL_AND_REVERSE = 0x1502,
280	GL_AND_INVERTED = 0x1504,	280	GL_AND_INVERTED = 0x1504,
281	GL_OR_REVERSE = 0x150B,	281	GL_OR_REVERSE = 0x150B,
282	GL_OR_INVERTED = 0x150D,	282	GL_OR_INVERTED = 0x150D,
283		283
284	/* Stencil */	284	/* Stencil */
285	GL_STENCIL_TEST = 0x0B90,	285	GL_STENCIL_TEST = 0x0B90,
286	GL_STENCIL_WRITEMASK = 0x0B98,	286	GL_STENCIL_WRITEMASK = 0x0B98,
287	GL_STENCIL_BITS = 0x0D57,	287	GL_STENCIL_BITS = 0x0D57,
288	GL_STENCIL_FUNC = 0x0B92,	288	GL_STENCIL_FUNC = 0x0B92,
289	GL_STENCIL_VALUE_MASK = 0x0B93,	289	GL_STENCIL_VALUE_MASK = 0x0B93,
290	GL_STENCIL_REF = 0x0B97,	290	GL_STENCIL_REF = 0x0B97,
291	GL_STENCIL_FAIL = 0x0B94,	291	GL_STENCIL_FAIL = 0x0B94,
292	GL_STENCIL_PASS_DEPTH_PASS = 0x0B96,	292	GL_STENCIL_PASS_DEPTH_PASS = 0x0B96,
293	GL_STENCIL_PASS_DEPTH_FAIL = 0x0B95,	293	GL_STENCIL_PASS_DEPTH_FAIL = 0x0B95,
294	GL_STENCIL_CLEAR_VALUE = 0x0B91,	294	GL_STENCIL_CLEAR_VALUE = 0x0B91,
295	GL_STENCIL_INDEX = 0x1901,	295	GL_STENCIL_INDEX = 0x1901,
296	GL_KEEP = 0x1E00,	296	GL_KEEP = 0x1E00,
297	GL_REPLACE = 0x1E01,	297	GL_REPLACE = 0x1E01,
298	GL_INCR = 0x1E02,	298	GL_INCR = 0x1E02,
299	GL_DECR = 0x1E03,	299	GL_DECR = 0x1E03,
300		300
301	/* Buffers, Pixel Drawing/Reading */	301	/* Buffers, Pixel Drawing/Reading */
302	GL_NONE = 0,	302	GL_NONE = 0,
303	GL_LEFT = 0x0406,	303	GL_LEFT = 0x0406,
304	GL_RIGHT = 0x0407,	304	GL_RIGHT = 0x0407,
305	/GL_FRONT = 0x0404, /	305	/GL_FRONT = 0x0404, /
306	/GL_BACK = 0x0405, /	306	/GL_BACK = 0x0405, /
307	/GL_FRONT_AND_BACK = 0x0408, /	307	/GL_FRONT_AND_BACK = 0x0408, /
308	GL_FRONT_LEFT = 0x0400,	308	GL_FRONT_LEFT = 0x0400,
309	GL_FRONT_RIGHT = 0x0401,	309	GL_FRONT_RIGHT = 0x0401,
310	GL_BACK_LEFT = 0x0402,	310	GL_BACK_LEFT = 0x0402,
311	GL_BACK_RIGHT = 0x0403,	311	GL_BACK_RIGHT = 0x0403,
312	GL_AUX0 = 0x0409,	312	GL_AUX0 = 0x0409,
313	GL_AUX1 = 0x040A,	313	GL_AUX1 = 0x040A,
314	GL_AUX2 = 0x040B,	314	GL_AUX2 = 0x040B,
315	GL_AUX3 = 0x040C,	315	GL_AUX3 = 0x040C,
316	GL_COLOR_INDEX = 0x1900,	316	GL_COLOR_INDEX = 0x1900,
317	GL_RED = 0x1903,	317	GL_RED = 0x1903,
318	GL_GREEN = 0x1904,	318	GL_GREEN = 0x1904,
319	GL_BLUE = 0x1905,	319	GL_BLUE = 0x1905,
320	GL_ALPHA = 0x1906,	320	GL_ALPHA = 0x1906,
321	GL_LUMINANCE = 0x1909,	321	GL_LUMINANCE = 0x1909,
322	GL_LUMINANCE_ALPHA = 0x190A,	322	GL_LUMINANCE_ALPHA = 0x190A,
323	GL_ALPHA_BITS = 0x0D55,	323	GL_ALPHA_BITS = 0x0D55,
324	GL_RED_BITS = 0x0D52,	324	GL_RED_BITS = 0x0D52,
325	GL_GREEN_BITS = 0x0D53,	325	GL_GREEN_BITS = 0x0D53,
326	GL_BLUE_BITS = 0x0D54,	326	GL_BLUE_BITS = 0x0D54,
327	GL_INDEX_BITS = 0x0D51,	327	GL_INDEX_BITS = 0x0D51,
328	GL_SUBPIXEL_BITS = 0x0D50,	328	GL_SUBPIXEL_BITS = 0x0D50,
329	GL_AUX_BUFFERS = 0x0C00,	329	GL_AUX_BUFFERS = 0x0C00,
330	GL_READ_BUFFER = 0x0C02,	330	GL_READ_BUFFER = 0x0C02,
331	GL_DRAW_BUFFER = 0x0C01,	331	GL_DRAW_BUFFER = 0x0C01,
332	GL_DOUBLEBUFFER = 0x0C32,	332	GL_DOUBLEBUFFER = 0x0C32,
333	GL_STEREO = 0x0C33,	333	GL_STEREO = 0x0C33,
334	GL_BITMAP = 0x1A00,	334	GL_BITMAP = 0x1A00,
335	GL_COLOR = 0x1800,	335	GL_COLOR = 0x1800,
336	GL_DEPTH = 0x1801,	336	GL_DEPTH = 0x1801,
337	GL_STENCIL = 0x1802,	337	GL_STENCIL = 0x1802,
338	GL_DITHER = 0x0BD0,	338	GL_DITHER = 0x0BD0,
339	GL_RGB = 0x1907,	339	GL_RGB = 0x1907,
340	GL_RGBA = 0x1908,	340	GL_RGBA = 0x1908,
341		341
342	/* Implementation limits */	342	/* Implementation limits */
343	GL_MAX_LIST_NESTING = 0x0B31,	343	GL_MAX_LIST_NESTING = 0x0B31,
344	GL_MAX_ATTRIB_STACK_DEPTH = 0x0D35,	344	GL_MAX_ATTRIB_STACK_DEPTH = 0x0D35,
345	GL_MAX_MODELVIEW_STACK_DEPTH = 0x0D36,	345	GL_MAX_MODELVIEW_STACK_DEPTH = 0x0D36,
346	GL_MAX_NAME_STACK_DEPTH = 0x0D37,	346	GL_MAX_NAME_STACK_DEPTH = 0x0D37,
347	GL_MAX_PROJECTION_STACK_DEPTH = 0x0D38,	347	GL_MAX_PROJECTION_STACK_DEPTH = 0x0D38,
348	GL_MAX_TEXTURE_STACK_DEPTH = 0x0D39,	348	GL_MAX_TEXTURE_STACK_DEPTH = 0x0D39,
349	GL_MAX_EVAL_ORDER = 0x0D30,	349	GL_MAX_EVAL_ORDER = 0x0D30,
350	GL_MAX_LIGHTS = 0x0D31,	350	GL_MAX_LIGHTS = 0x0D31,
351	GL_MAX_CLIP_PLANES = 0x0D32,	351	GL_MAX_CLIP_PLANES = 0x0D32,
352	GL_MAX_TEXTURE_SIZE = 0x0D33,	352	GL_MAX_TEXTURE_SIZE = 0x0D33,
353	GL_MAX_PIXEL_MAP_TABLE = 0x0D34,	353	GL_MAX_PIXEL_MAP_TABLE = 0x0D34,
354	GL_MAX_VIEWPORT_DIMS = 0x0D3A,	354	GL_MAX_VIEWPORT_DIMS = 0x0D3A,
355	GL_MAX_CLIENT_ATTRIB_STACK_DEPTH= 0x0D3B,	355	GL_MAX_CLIENT_ATTRIB_STACK_DEPTH= 0x0D3B,
356		356
357	/* Gets */	357	/* Gets */
358	GL_ATTRIB_STACK_DEPTH = 0x0BB0,	358	GL_ATTRIB_STACK_DEPTH = 0x0BB0,
359	GL_COLOR_CLEAR_VALUE = 0x0C22,	359	GL_COLOR_CLEAR_VALUE = 0x0C22,
360	GL_COLOR_WRITEMASK = 0x0C23,	360	GL_COLOR_WRITEMASK = 0x0C23,
361	GL_CURRENT_INDEX = 0x0B01,	361	GL_CURRENT_INDEX = 0x0B01,
362	GL_CURRENT_COLOR = 0x0B00,	362	GL_CURRENT_COLOR = 0x0B00,
363	GL_CURRENT_NORMAL = 0x0B02,	363	GL_CURRENT_NORMAL = 0x0B02,
364	GL_CURRENT_RASTER_COLOR = 0x0B04,	364	GL_CURRENT_RASTER_COLOR = 0x0B04,
365	GL_CURRENT_RASTER_DISTANCE = 0x0B09,	365	GL_CURRENT_RASTER_DISTANCE = 0x0B09,
366	GL_CURRENT_RASTER_INDEX = 0x0B05,	366	GL_CURRENT_RASTER_INDEX = 0x0B05,
367	GL_CURRENT_RASTER_POSITION = 0x0B07,	367	GL_CURRENT_RASTER_POSITION = 0x0B07,
368	GL_CURRENT_RASTER_TEXTURE_COORDS = 0x0B06,	368	GL_CURRENT_RASTER_TEXTURE_COORDS = 0x0B06,
369	GL_CURRENT_RASTER_POSITION_VALID = 0x0B08,	369	GL_CURRENT_RASTER_POSITION_VALID = 0x0B08,
370	GL_CURRENT_TEXTURE_COORDS = 0x0B03,	370	GL_CURRENT_TEXTURE_COORDS = 0x0B03,
371	GL_INDEX_CLEAR_VALUE = 0x0C20,	371	GL_INDEX_CLEAR_VALUE = 0x0C20,
372	GL_INDEX_MODE = 0x0C30,	372	GL_INDEX_MODE = 0x0C30,
373	GL_INDEX_WRITEMASK = 0x0C21,	373	GL_INDEX_WRITEMASK = 0x0C21,
374	GL_MODELVIEW_MATRIX = 0x0BA6,	374	GL_MODELVIEW_MATRIX = 0x0BA6,
375	GL_MODELVIEW_STACK_DEPTH = 0x0BA3,	375	GL_MODELVIEW_STACK_DEPTH = 0x0BA3,
376	GL_NAME_STACK_DEPTH = 0x0D70,	376	GL_NAME_STACK_DEPTH = 0x0D70,
377	GL_PROJECTION_MATRIX = 0x0BA7,	377	GL_PROJECTION_MATRIX = 0x0BA7,
378	GL_PROJECTION_STACK_DEPTH = 0x0BA4,	378	GL_PROJECTION_STACK_DEPTH = 0x0BA4,
379	GL_RENDER_MODE = 0x0C40,	379	GL_RENDER_MODE = 0x0C40,
380	GL_RGBA_MODE = 0x0C31,	380	GL_RGBA_MODE = 0x0C31,
381	GL_TEXTURE_MATRIX = 0x0BA8,	381	GL_TEXTURE_MATRIX = 0x0BA8,
382	GL_TEXTURE_STACK_DEPTH = 0x0BA5,	382	GL_TEXTURE_STACK_DEPTH = 0x0BA5,
383	GL_VIEWPORT = 0x0BA2,	383	GL_VIEWPORT = 0x0BA2,
384		384
385		385
386	/* Evaluators */	386	/* Evaluators */
387	GL_AUTO_NORMAL = 0x0D80,	387	GL_AUTO_NORMAL = 0x0D80,
388	GL_MAP1_COLOR_4 = 0x0D90,	388	GL_MAP1_COLOR_4 = 0x0D90,
389	GL_MAP1_GRID_DOMAIN = 0x0DD0,	389	GL_MAP1_GRID_DOMAIN = 0x0DD0,
390	GL_MAP1_GRID_SEGMENTS = 0x0DD1,	390	GL_MAP1_GRID_SEGMENTS = 0x0DD1,
391	GL_MAP1_INDEX = 0x0D91,	391	GL_MAP1_INDEX = 0x0D91,
392	GL_MAP1_NORMAL = 0x0D92,	392	GL_MAP1_NORMAL = 0x0D92,
393	GL_MAP1_TEXTURE_COORD_1 = 0x0D93,	393	GL_MAP1_TEXTURE_COORD_1 = 0x0D93,
394	GL_MAP1_TEXTURE_COORD_2 = 0x0D94,	394	GL_MAP1_TEXTURE_COORD_2 = 0x0D94,
395	GL_MAP1_TEXTURE_COORD_3 = 0x0D95,	395	GL_MAP1_TEXTURE_COORD_3 = 0x0D95,
396	GL_MAP1_TEXTURE_COORD_4 = 0x0D96,	396	GL_MAP1_TEXTURE_COORD_4 = 0x0D96,
397	GL_MAP1_VERTEX_3 = 0x0D97,	397	GL_MAP1_VERTEX_3 = 0x0D97,
398	GL_MAP1_VERTEX_4 = 0x0D98,	398	GL_MAP1_VERTEX_4 = 0x0D98,
399	GL_MAP2_COLOR_4 = 0x0DB0,	399	GL_MAP2_COLOR_4 = 0x0DB0,
400	GL_MAP2_GRID_DOMAIN = 0x0DD2,	400	GL_MAP2_GRID_DOMAIN = 0x0DD2,
401	GL_MAP2_GRID_SEGMENTS = 0x0DD3,	401	GL_MAP2_GRID_SEGMENTS = 0x0DD3,
402	GL_MAP2_INDEX = 0x0DB1,	402	GL_MAP2_INDEX = 0x0DB1,
403	GL_MAP2_NORMAL = 0x0DB2,	403	GL_MAP2_NORMAL = 0x0DB2,
404	GL_MAP2_TEXTURE_COORD_1 = 0x0DB3,	404	GL_MAP2_TEXTURE_COORD_1 = 0x0DB3,
405	GL_MAP2_TEXTURE_COORD_2 = 0x0DB4,	405	GL_MAP2_TEXTURE_COORD_2 = 0x0DB4,
406	GL_MAP2_TEXTURE_COORD_3 = 0x0DB5,	406	GL_MAP2_TEXTURE_COORD_3 = 0x0DB5,
407	GL_MAP2_TEXTURE_COORD_4 = 0x0DB6,	407	GL_MAP2_TEXTURE_COORD_4 = 0x0DB6,
408	GL_MAP2_VERTEX_3 = 0x0DB7,	408	GL_MAP2_VERTEX_3 = 0x0DB7,
409	GL_MAP2_VERTEX_4 = 0x0DB8,	409	GL_MAP2_VERTEX_4 = 0x0DB8,
410	GL_COEFF = 0x0A00,	410	GL_COEFF = 0x0A00,
411	GL_DOMAIN = 0x0A02,	411	GL_DOMAIN = 0x0A02,
412	GL_ORDER = 0x0A01,	412	GL_ORDER = 0x0A01,
413		413
414	/* Hints */	414	/* Hints */
415	GL_FOG_HINT = 0x0C54,	415	GL_FOG_HINT = 0x0C54,
416	GL_LINE_SMOOTH_HINT = 0x0C52,	416	GL_LINE_SMOOTH_HINT = 0x0C52,
417	GL_PERSPECTIVE_CORRECTION_HINT = 0x0C50,	417	GL_PERSPECTIVE_CORRECTION_HINT = 0x0C50,
418	GL_POINT_SMOOTH_HINT = 0x0C51,	418	GL_POINT_SMOOTH_HINT = 0x0C51,
419	GL_POLYGON_SMOOTH_HINT = 0x0C53,	419	GL_POLYGON_SMOOTH_HINT = 0x0C53,
420	GL_DONT_CARE = 0x1100,	420	GL_DONT_CARE = 0x1100,
421	GL_FASTEST = 0x1101,	421	GL_FASTEST = 0x1101,
422	GL_NICEST = 0x1102,	422	GL_NICEST = 0x1102,
423		423
424	/* Scissor box */	424	/* Scissor box */
425	GL_SCISSOR_TEST = 0x0C11,	425	GL_SCISSOR_TEST = 0x0C11,
426	GL_SCISSOR_BOX = 0x0C10,	426	GL_SCISSOR_BOX = 0x0C10,
427		427
428	/* Pixel Mode / Transfer */	428	/* Pixel Mode / Transfer */
429	GL_MAP_COLOR = 0x0D10,	429	GL_MAP_COLOR = 0x0D10,
430	GL_MAP_STENCIL = 0x0D11,	430	GL_MAP_STENCIL = 0x0D11,
431	GL_INDEX_SHIFT = 0x0D12,	431	GL_INDEX_SHIFT = 0x0D12,
432	GL_INDEX_OFFSET = 0x0D13,	432	GL_INDEX_OFFSET = 0x0D13,
433	GL_RED_SCALE = 0x0D14,	433	GL_RED_SCALE = 0x0D14,
434	GL_RED_BIAS = 0x0D15,	434	GL_RED_BIAS = 0x0D15,
435	GL_GREEN_SCALE = 0x0D18,	435	GL_GREEN_SCALE = 0x0D18,
436	GL_GREEN_BIAS = 0x0D19,	436	GL_GREEN_BIAS = 0x0D19,
437	GL_BLUE_SCALE = 0x0D1A,	437	GL_BLUE_SCALE = 0x0D1A,
438	GL_BLUE_BIAS = 0x0D1B,	438	GL_BLUE_BIAS = 0x0D1B,
439	GL_ALPHA_SCALE = 0x0D1C,	439	GL_ALPHA_SCALE = 0x0D1C,
440	GL_ALPHA_BIAS = 0x0D1D,	440	GL_ALPHA_BIAS = 0x0D1D,
441	GL_DEPTH_SCALE = 0x0D1E,	441	GL_DEPTH_SCALE = 0x0D1E,
442	GL_DEPTH_BIAS = 0x0D1F,	442	GL_DEPTH_BIAS = 0x0D1F,
443	GL_PIXEL_MAP_S_TO_S_SIZE = 0x0CB1,	443	GL_PIXEL_MAP_S_TO_S_SIZE = 0x0CB1,
444	GL_PIXEL_MAP_I_TO_I_SIZE = 0x0CB0,	444	GL_PIXEL_MAP_I_TO_I_SIZE = 0x0CB0,
445	GL_PIXEL_MAP_I_TO_R_SIZE = 0x0CB2,	445	GL_PIXEL_MAP_I_TO_R_SIZE = 0x0CB2,
446	GL_PIXEL_MAP_I_TO_G_SIZE = 0x0CB3,	446	GL_PIXEL_MAP_I_TO_G_SIZE = 0x0CB3,
447	GL_PIXEL_MAP_I_TO_B_SIZE = 0x0CB4,	447	GL_PIXEL_MAP_I_TO_B_SIZE = 0x0CB4,
448	GL_PIXEL_MAP_I_TO_A_SIZE = 0x0CB5,	448	GL_PIXEL_MAP_I_TO_A_SIZE = 0x0CB5,
449	GL_PIXEL_MAP_R_TO_R_SIZE = 0x0CB6,	449	GL_PIXEL_MAP_R_TO_R_SIZE = 0x0CB6,
450	GL_PIXEL_MAP_G_TO_G_SIZE = 0x0CB7,	450	GL_PIXEL_MAP_G_TO_G_SIZE = 0x0CB7,
451	GL_PIXEL_MAP_B_TO_B_SIZE = 0x0CB8,	451	GL_PIXEL_MAP_B_TO_B_SIZE = 0x0CB8,
452	GL_PIXEL_MAP_A_TO_A_SIZE = 0x0CB9,	452	GL_PIXEL_MAP_A_TO_A_SIZE = 0x0CB9,
453	GL_PIXEL_MAP_S_TO_S = 0x0C71,	453	GL_PIXEL_MAP_S_TO_S = 0x0C71,
454	GL_PIXEL_MAP_I_TO_I = 0x0C70,	454	GL_PIXEL_MAP_I_TO_I = 0x0C70,
455	GL_PIXEL_MAP_I_TO_R = 0x0C72,	455	GL_PIXEL_MAP_I_TO_R = 0x0C72,
456	GL_PIXEL_MAP_I_TO_G = 0x0C73,	456	GL_PIXEL_MAP_I_TO_G = 0x0C73,
457	GL_PIXEL_MAP_I_TO_B = 0x0C74,	457	GL_PIXEL_MAP_I_TO_B = 0x0C74,
458	GL_PIXEL_MAP_I_TO_A = 0x0C75,	458	GL_PIXEL_MAP_I_TO_A = 0x0C75,
459	GL_PIXEL_MAP_R_TO_R = 0x0C76,	459	GL_PIXEL_MAP_R_TO_R = 0x0C76,
460	GL_PIXEL_MAP_G_TO_G = 0x0C77,	460	GL_PIXEL_MAP_G_TO_G = 0x0C77,
461	GL_PIXEL_MAP_B_TO_B = 0x0C78,	461	GL_PIXEL_MAP_B_TO_B = 0x0C78,
462	GL_PIXEL_MAP_A_TO_A = 0x0C79,	462	GL_PIXEL_MAP_A_TO_A = 0x0C79,
463	GL_PACK_ALIGNMENT = 0x0D05,	463	GL_PACK_ALIGNMENT = 0x0D05,
464	GL_PACK_LSB_FIRST = 0x0D01,	464	GL_PACK_LSB_FIRST = 0x0D01,
465	GL_PACK_ROW_LENGTH = 0x0D02,	465	GL_PACK_ROW_LENGTH = 0x0D02,
466	GL_PACK_SKIP_PIXELS = 0x0D04,	466	GL_PACK_SKIP_PIXELS = 0x0D04,
467	GL_PACK_SKIP_ROWS = 0x0D03,	467	GL_PACK_SKIP_ROWS = 0x0D03,
468	GL_PACK_SWAP_BYTES = 0x0D00,	468	GL_PACK_SWAP_BYTES = 0x0D00,
469	GL_UNPACK_ALIGNMENT = 0x0CF5,	469	GL_UNPACK_ALIGNMENT = 0x0CF5,
470	GL_UNPACK_LSB_FIRST = 0x0CF1,	470	GL_UNPACK_LSB_FIRST = 0x0CF1,
471	GL_UNPACK_ROW_LENGTH = 0x0CF2,	471	GL_UNPACK_ROW_LENGTH = 0x0CF2,
472	GL_UNPACK_SKIP_PIXELS = 0x0CF4,	472	GL_UNPACK_SKIP_PIXELS = 0x0CF4,
473	GL_UNPACK_SKIP_ROWS = 0x0CF3,	473	GL_UNPACK_SKIP_ROWS = 0x0CF3,
474	GL_UNPACK_SWAP_BYTES = 0x0CF0,	474	GL_UNPACK_SWAP_BYTES = 0x0CF0,
475	GL_ZOOM_X = 0x0D16,	475	GL_ZOOM_X = 0x0D16,
476	GL_ZOOM_Y = 0x0D17,	476	GL_ZOOM_Y = 0x0D17,
477		477
478	/* Texture mapping */	478	/* Texture mapping */
479	GL_TEXTURE_ENV = 0x2300,	479	GL_TEXTURE_ENV = 0x2300,
480	GL_TEXTURE_ENV_MODE = 0x2200,	480	GL_TEXTURE_ENV_MODE = 0x2200,
481	GL_TEXTURE_1D = 0x0DE0,	481	GL_TEXTURE_1D = 0x0DE0,
482	GL_TEXTURE_2D = 0x0DE1,	482	GL_TEXTURE_2D = 0x0DE1,
483	GL_TEXTURE_WRAP_S = 0x2802,	483	GL_TEXTURE_WRAP_S = 0x2802,
484	GL_TEXTURE_WRAP_T = 0x2803,	484	GL_TEXTURE_WRAP_T = 0x2803,
485	GL_TEXTURE_MAG_FILTER = 0x2800,	485	GL_TEXTURE_MAG_FILTER = 0x2800,
486	GL_TEXTURE_MIN_FILTER = 0x2801,	486	GL_TEXTURE_MIN_FILTER = 0x2801,
487	GL_TEXTURE_ENV_COLOR = 0x2201,	487	GL_TEXTURE_ENV_COLOR = 0x2201,
488	GL_TEXTURE_GEN_S = 0x0C60,	488	GL_TEXTURE_GEN_S = 0x0C60,
489	GL_TEXTURE_GEN_T = 0x0C61,	489	GL_TEXTURE_GEN_T = 0x0C61,
490	GL_TEXTURE_GEN_MODE = 0x2500,	490	GL_TEXTURE_GEN_MODE = 0x2500,
491	GL_TEXTURE_BORDER_COLOR = 0x1004,	491	GL_TEXTURE_BORDER_COLOR = 0x1004,
492	GL_TEXTURE_WIDTH = 0x1000,	492	GL_TEXTURE_WIDTH = 0x1000,
493	GL_TEXTURE_HEIGHT = 0x1001,	493	GL_TEXTURE_HEIGHT = 0x1001,
494	GL_TEXTURE_BORDER = 0x1005,	494	GL_TEXTURE_BORDER = 0x1005,
495	GL_TEXTURE_COMPONENTS = 0x1003,	495	GL_TEXTURE_COMPONENTS = 0x1003,
496	GL_NEAREST_MIPMAP_NEAREST = 0x2700,	496	GL_NEAREST_MIPMAP_NEAREST = 0x2700,
497	GL_NEAREST_MIPMAP_LINEAR = 0x2702,	497	GL_NEAREST_MIPMAP_LINEAR = 0x2702,
498	GL_LINEAR_MIPMAP_NEAREST = 0x2701,	498	GL_LINEAR_MIPMAP_NEAREST = 0x2701,
499	GL_LINEAR_MIPMAP_LINEAR = 0x2703,	499	GL_LINEAR_MIPMAP_LINEAR = 0x2703,
500	GL_OBJECT_LINEAR = 0x2401,	500	GL_OBJECT_LINEAR = 0x2401,

Subversion Repositories Kolibri OS

(root)/programs/bcc32/include/l_tinygl.h – Rev 8442 → 8824