universal definition files, still not merged win and linux

but pretty close

packages/opengl/build2/gl.def

@@ -0,0 +1,1037 @@
+# This is the definition file for all GL functions and types.
+
+%COPY_INTERFACE
+// ===================================================================
+//   GL consts, types and functions
+// ===================================================================
+
+
+// -------------------------------------------------------------------
+//   GL types
+// -------------------------------------------------------------------
+
+type
+
+  PSingle = ^Single;
+  PDouble = ^Double;
+
+  GLclampf = Single;    // single precision float in [0,1]
+  GLclampd = Double;    // double precision float in [0,1]
+
+  GLenum = Integer;
+
+type
+  GLbitfield = set of (GL_CURRENT_BIT, GL_POINT_BIT, GL_LINE_BIT,
+    GL_POLYGON_BIT, GL_POLYGON_STIPPLE_BIT, GL_PIXEL_MODE_BIT,
+    GL_LIGHTING_BIT, GL_FOG_BIT, GL_DEPTH_BUFFER_BIT, GL_ACCUM_BUFFER_BIT,
+    GL_STENCIL_BUFFER_BIT, GL_VIEWPORT_BIT, GL_TRANSFORM_BIT, GL_ENABLE_BIT,
+    GL_COLOR_BUFFER_BIT, GL_HINT_BIT, GL_EVAL_BIT, GL_LIST_BIT, GL_TEXTURE_BIT,
+    GL_SCISSOR_BIT);
+
+const
+  GL_ALL_ATTRIB_BITS = [Low(GLbitfield)..High(GLbitfield)];
+
+
+// -------------------------------------------------------------------
+//   GL constants
+// -------------------------------------------------------------------
+
+const
+  GL_NO_ERROR                           = 0;
+
+  // Boolean values
+  GL_FALSE                              = 0;
+  GL_TRUE                               = 1;
+
+  // Data types
+  GL_BYTE                               = $1400;
+  GL_UNSIGNED_BYTE                      = $1401;
+  GL_SHORT                              = $1402;
+  GL_UNSIGNED_SHORT                     = $1403;
+  GL_INT                                = $1404;
+  GL_UNSIGNED_INT                       = $1405;
+  GL_FLOAT                              = $1406;
+  GL_DOUBLE                             = $140A;
+  GL_2_BYTES                            = $1407;
+  GL_3_BYTES                            = $1408;
+  GL_4_BYTES                            = $1409;
+
+  // Primitives
+  GL_LINES                              = $0001;
+  GL_POINTS                             = $0000;
+  GL_LINE_STRIP                         = $0003;
+  GL_LINE_LOOP                          = $0002;
+  GL_TRIANGLES                          = $0004;
+  GL_TRIANGLE_STRIP                     = $0005;
+  GL_TRIANGLE_FAN                       = $0006;
+  GL_QUADS                              = $0007;
+  GL_QUAD_STRIP                         = $0008;
+  GL_POLYGON                            = $0009;
+  GL_EDGE_FLAG                          = $0B43;
+
+  // Vertex arrays
+  GL_VERTEX_ARRAY                       = $8074;
+  GL_NORMAL_ARRAY                       = $8075;
+  GL_COLOR_ARRAY                        = $8076;
+  GL_INDEX_ARRAY                        = $8077;
+  GL_TEXTURE_COORD_ARRAY                = $8078;
+  GL_EDGE_FLAG_ARRAY                    = $8079;
+  GL_VERTEX_ARRAY_SIZE                  = $807A;
+  GL_VERTEX_ARRAY_TYPE                  = $807B;
+  GL_VERTEX_ARRAY_STRIDE                = $807C;
+  GL_NORMAL_ARRAY_TYPE                  = $807E;
+  GL_NORMAL_ARRAY_STRIDE                = $807F;
+  GL_COLOR_ARRAY_SIZE                   = $8081;
+  GL_COLOR_ARRAY_TYPE                   = $8082;
+  GL_COLOR_ARRAY_STRIDE                 = $8083;
+  GL_INDEX_ARRAY_TYPE                   = $8085;
+  GL_INDEX_ARRAY_STRIDE                 = $8086;
+  GL_TEXTURE_COORD_ARRAY_SIZE           = $8088;
+  GL_TEXTURE_COORD_ARRAY_TYPE           = $8089;
+  GL_TEXTURE_COORD_ARRAY_STRIDE         = $808A;
+  GL_EDGE_FLAG_ARRAY_STRIDE             = $808C;
+  GL_VERTEX_ARRAY_POINTER               = $808E;
+  GL_NORMAL_ARRAY_POINTER               = $808F;
+  GL_COLOR_ARRAY_POINTER                = $8090;
+  GL_INDEX_ARRAY_POINTER                = $8091;
+  GL_TEXTURE_COORD_ARRAY_POINTER        = $8092;
+  GL_EDGE_FLAG_ARRAY_POINTER            = $8093;
+  GL_V2F                                = $2A20;
+  GL_V3F                                = $2A21;
+  GL_C4UB_V2F                           = $2A22;
+  GL_C4UB_V3F                           = $2A23;
+  GL_C3F_V3F                            = $2A24;
+  GL_N3F_V3F                            = $2A25;
+  GL_C4F_N3F_V3F                        = $2A26;
+  GL_T2F_V3F                            = $2A27;
+  GL_T4F_V4F                            = $2A28;
+  GL_T2F_C4UB_V3F                       = $2A29;
+  GL_T2F_C3F_V3F                        = $2A2A;
+  GL_T2F_N3F_V3F                        = $2A2B;
+  GL_T2F_C4F_N3F_V3F                    = $2A2C;
+  GL_T4F_C4F_N3F_V4F                    = $2A2D;
+
+  // Matrix Mode
+  GL_MATRIX_MODE                        = $0BA0;
+  GL_MODELVIEW                          = $1700;
+  GL_PROJECTION                         = $1701;
+  GL_TEXTURE                            = $1702;
+
+  // Points
+  GL_POINT_SMOOTH                       = $0B10;
+  GL_POINT_SIZE                         = $0B11;
+  GL_POINT_SIZE_GRANULARITY             = $0B13;
+  GL_POINT_SIZE_RANGE                   = $0B12;
+
+  // Lines
+  GL_LINE_SMOOTH                        = $0B20;
+  GL_LINE_STIPPLE                       = $0B24;
+  GL_LINE_STIPPLE_PATTERN               = $0B25;
+  GL_LINE_STIPPLE_REPEAT                = $0B26;
+  GL_LINE_WIDTH                         = $0B21;
+  GL_LINE_WIDTH_GRANULARITY             = $0B23;
+  GL_LINE_WIDTH_RANGE                   = $0B22;
+
+  // Polygons
+  GL_POINT                              = $1B00;
+  GL_LINE                               = $1B01;
+  GL_FILL                               = $1B02;
+  GL_CCW                                = $0901;
+  GL_CW                                 = $0900;
+  GL_FRONT                              = $0404;
+  GL_BACK                               = $0405;
+  GL_CULL_FACE                          = $0B44;
+  GL_CULL_FACE_MODE                     = $0B45;
+  GL_POLYGON_SMOOTH                     = $0B41;
+  GL_POLYGON_STIPPLE                    = $0B42;
+  GL_FRONT_FACE                         = $0B46;
+  GL_POLYGON_MODE                       = $0B40;
+  GL_POLYGON_OFFSET_FACTOR              = $8038;
+  GL_POLYGON_OFFSET_UNITS               = $2A00;
+  GL_POLYGON_OFFSET_POINT               = $2A01;
+  GL_POLYGON_OFFSET_LINE                = $2A02;
+  GL_POLYGON_OFFSET_FILL                = $8037;
+
+  // Display lists
+  GL_COMPILE                            = $1300;
+  GL_COMPILE_AND_EXECUTE                = $1301;
+  GL_LIST_BASE                          = $0B32;
+  GL_LIST_INDEX                         = $0B33;
+  GL_LIST_MODE                          = $0B30;
+
+  // Depth buffer
+  GL_NEVER                              = $0200;
+  GL_LESS                               = $0201;
+  GL_GEQUAL                             = $0206;
+  GL_LEQUAL                             = $0203;
+  GL_GREATER                            = $0204;
+  GL_NOTEQUAL                           = $0205;
+  GL_EQUAL                              = $0202;
+  GL_ALWAYS                             = $0207;
+  GL_DEPTH_TEST                         = $0B71;
+  GL_DEPTH_BITS                         = $0D56;
+  GL_DEPTH_CLEAR_VALUE                  = $0B73;
+  GL_DEPTH_FUNC                         = $0B74;
+  GL_DEPTH_RANGE                        = $0B70;
+  GL_DEPTH_WRITEMASK                    = $0B72;
+  GL_DEPTH_COMPONENT                    = $1902;
+
+  // Lighting
+  GL_LIGHTING                           = $0B50;
+  GL_LIGHT0                             = $4000;
+  GL_LIGHT1                             = $4001;
+  GL_LIGHT2                             = $4002;
+  GL_LIGHT3                             = $4003;
+  GL_LIGHT4                             = $4004;
+  GL_LIGHT5                             = $4005;
+  GL_LIGHT6                             = $4006;
+  GL_LIGHT7                             = $4007;
+  GL_SPOT_EXPONENT                      = $1205;
+  GL_SPOT_CUTOFF                        = $1206;
+  GL_CONSTANT_ATTENUATION               = $1207;
+  GL_LINEAR_ATTENUATION                 = $1208;
+  GL_QUADRATIC_ATTENUATION              = $1209;
+  GL_AMBIENT                            = $1200;
+  GL_DIFFUSE                            = $1201;
+  GL_SPECULAR                           = $1202;
+  GL_SHININESS                          = $1601;
+  GL_EMISSION                           = $1600;
+  GL_POSITION                           = $1203;
+  GL_SPOT_DIRECTION                     = $1204;
+  GL_AMBIENT_AND_DIFFUSE                = $1602;
+  GL_COLOR_INDEXES                      = $1603;
+  GL_LIGHT_MODEL_TWO_SIDE               = $0B52;
+  GL_LIGHT_MODEL_LOCAL_VIEWER           = $0B51;
+  GL_LIGHT_MODEL_AMBIENT                = $0B53;
+  GL_FRONT_AND_BACK                     = $0408;
+  GL_SHADE_MODEL                        = $0B54;
+  GL_FLAT                               = $1D00;
+  GL_SMOOTH                             = $1D01;
+  GL_COLOR_MATERIAL                     = $0B57;
+  GL_COLOR_MATERIAL_FACE                = $0B55;
+  GL_COLOR_MATERIAL_PARAMETER           = $0B56;
+  GL_NORMALIZE                          = $0BA1;
+
+  // User clipping planes
+  GL_CLIP_PLANE0                        = $3000;
+  GL_CLIP_PLANE1                        = $3001;
+  GL_CLIP_PLANE2                        = $3002;
+  GL_CLIP_PLANE3                        = $3003;
+  GL_CLIP_PLANE4                        = $3004;
+  GL_CLIP_PLANE5                        = $3005;
+
+  // Accumulation buffer
+  GL_ACCUM_RED_BITS                     = $0D58;
+  GL_ACCUM_GREEN_BITS                   = $0D59;
+  GL_ACCUM_BLUE_BITS                    = $0D5A;
+  GL_ACCUM_ALPHA_BITS                   = $0D5B;
+  GL_ACCUM_CLEAR_VALUE                  = $0B80;
+  GL_ACCUM                              = $0100;
+  GL_ADD                                = $0104;
+  GL_LOAD                               = $0101;
+  GL_MULT                               = $0103;
+  GL_RETURN                             = $0102;
+
+  // Alpha testing
+  GL_ALPHA_TEST                         = $0BC0;
+  GL_ALPHA_TEST_REF                     = $0BC2;
+  GL_ALPHA_TEST_FUNC                    = $0BC1;
+
+  // Blending
+  GL_BLEND                              = $0BE2;
+  GL_BLEND_SRC                          = $0BE1;
+  GL_BLEND_DST                          = $0BE0;
+  GL_ZERO                               = 0;
+  GL_ONE                                = 1;
+  GL_SRC_COLOR                          = $0300;
+  GL_ONE_MINUS_SRC_COLOR                = $0301;
+  GL_DST_COLOR                          = $0306;
+  GL_ONE_MINUS_DST_COLOR                = $0307;
+  GL_SRC_ALPHA                          = $0302;
+  GL_ONE_MINUS_SRC_ALPHA                = $0303;
+  GL_DST_ALPHA                          = $0304;
+  GL_ONE_MINUS_DST_ALPHA                = $0305;
+  GL_SRC_ALPHA_SATURATE                 = $0308;
+  GL_CONSTANT_COLOR                     = $8001;
+  GL_ONE_MINUS_CONSTANT_COLOR           = $8002;
+  GL_CONSTANT_ALPHA                     = $8003;
+  GL_ONE_MINUS_CONSTANT_ALPHA           = $8004;
+
+  // Render mode
+  GL_FEEDBACK                           = $1C01;
+  GL_RENDER                             = $1C00;
+  GL_SELECT                             = $1C02;
+
+  // Feedback
+  GL_2D                                 = $0600;
+  GL_3D                                 = $0601;
+  GL_3D_COLOR                           = $0602;
+  GL_3D_COLOR_TEXTURE                   = $0603;
+  GL_4D_COLOR_TEXTURE                   = $0604;
+  GL_POINT_TOKEN                        = $0701;
+  GL_LINE_TOKEN                         = $0702;
+  GL_LINE_RESET_TOKEN                   = $0707;
+  GL_POLYGON_TOKEN                      = $0703;
+  GL_BITMAP_TOKEN                       = $0704;
+  GL_DRAW_PIXEL_TOKEN                   = $0705;
+  GL_COPY_PIXEL_TOKEN                   = $0706;
+  GL_PASS_THROUGH_TOKEN                 = $0700;
+  GL_FEEDBACK_BUFFER_POINTER            = $0DF0;
+  GL_FEEDBACK_BUFFER_SIZE               = $0DF1;
+  GL_FEEDBACK_BUFFER_TYPE               = $0DF2;
+
+  // Selection
+  GL_SELECTION_BUFFER_POINTER           = $0DF3;
+  GL_SELECTION_BUFFER_SIZE              = $0DF4;
+
+  // Fog
+  GL_FOG                                = $0B60;
+  GL_FOG_MODE                           = $0B65;
+  GL_FOG_DENSITY                        = $0B62;
+  GL_FOG_COLOR                          = $0B66;
+  GL_FOG_INDEX                          = $0B61;
+  GL_FOG_START                          = $0B63;
+  GL_FOG_END                            = $0B64;
+  GL_LINEAR                             = $2601;
+  GL_EXP                                = $0800;
+  GL_EXP2                               = $0801;
+
+  // Logic ops
+  GL_LOGIC_OP                           = $0BF1;
+  GL_INDEX_LOGIC_OP                     = $0BF1;
+  GL_COLOR_LOGIC_OP                     = $0BF2;
+  GL_LOGIC_OP_MODE                      = $0BF0;
+  GL_CLEAR                              = $1500;
+  GL_SET                                = $150F;
+  GL_COPY                               = $1503;
+  GL_COPY_INVERTED                      = $150C;
+  GL_NOOP                               = $1505;
+  GL_INVERT                             = $150A;
+  GL_AND                                = $1501;
+  GL_NAND                               = $150E;
+  GL_OR                                 = $1507;
+  GL_NOR                                = $1508;
+  GL_XOR                                = $1506;
+  GL_EQUIV                              = $1509;
+  GL_AND_REVERSE                        = $1502;
+  GL_AND_INVERTED                       = $1504;
+  GL_OR_REVERSE                         = $150B;
+  GL_OR_INVERTED                        = $150D;
+
+  // Stencil
+  GL_STENCIL_TEST                       = $0B90;
+  GL_STENCIL_WRITEMASK                  = $0B98;
+  GL_STENCIL_BITS                       = $0D57;
+  GL_STENCIL_FUNC                       = $0B92;
+  GL_STENCIL_VALUE_MASK                 = $0B93;
+  GL_STENCIL_REF                        = $0B97;
+  GL_STENCIL_FAIL                       = $0B94;
+  GL_STENCIL_PASS_DEPTH_PASS            = $0B96;
+  GL_STENCIL_PASS_DEPTH_FAIL            = $0B95;
+  GL_STENCIL_CLEAR_VALUE                = $0B91;
+  GL_STENCIL_INDEX                      = $1901;
+  GL_KEEP                               = $1E00;
+  GL_REPLACE                            = $1E01;
+  GL_INCR                               = $1E02;
+  GL_DECR                               = $1E03;
+
+  // Buffers, Pixel Drawing/Reading
+  GL_NONE                               = 0;
+  GL_LEFT                               = $0406;
+  GL_RIGHT                              = $0407;
+  //GL_FRONT                            = $0404;
+  //GL_BACK                             = $0405;
+  //GL_FRONT_AND_BACK                   = $0408;
+  GL_FRONT_LEFT                         = $0400;
+  GL_FRONT_RIGHT                        = $0401;
+  GL_BACK_LEFT                          = $0402;
+  GL_BACK_RIGHT                         = $0403;
+  GL_AUX0                               = $0409;
+  GL_AUX1                               = $040A;
+  GL_AUX2                               = $040B;
+  GL_AUX3                               = $040C;
+  GL_COLOR_INDEX                        = $1900;
+  GL_RED                                = $1903;
+  GL_GREEN                              = $1904;
+  GL_BLUE                               = $1905;
+  GL_ALPHA                              = $1906;
+  GL_LUMINANCE                          = $1909;
+  GL_LUMINANCE_ALPHA                    = $190A;
+  GL_ALPHA_BITS                         = $0D55;
+  GL_RED_BITS                           = $0D52;
+  GL_GREEN_BITS                         = $0D53;
+  GL_BLUE_BITS                          = $0D54;
+  GL_INDEX_BITS                         = $0D51;
+  GL_SUBPIXEL_BITS                      = $0D50;
+  GL_AUX_BUFFERS                        = $0C00;
+  GL_READ_BUFFER                        = $0C02;
+  GL_DRAW_BUFFER                        = $0C01;
+  GL_DOUBLEBUFFER                       = $0C32;
+  GL_STEREO                             = $0C33;
+  GL_BITMAP                             = $1A00;
+  GL_COLOR                              = $1800;
+  GL_DEPTH                              = $1801;
+  GL_STENCIL                            = $1802;
+  GL_DITHER                             = $0BD0;
+  GL_RGB                                = $1907;
+  GL_RGBA                               = $1908;
+
+  // Implementation limits
+  GL_MAX_LIST_NESTING                   = $0B31;
+  GL_MAX_ATTRIB_STACK_DEPTH             = $0D35;
+  GL_MAX_MODELVIEW_STACK_DEPTH          = $0D36;
+  GL_MAX_NAME_STACK_DEPTH               = $0D37;
+  GL_MAX_PROJECTION_STACK_DEPTH         = $0D38;
+  GL_MAX_TEXTURE_STACK_DEPTH            = $0D39;
+  GL_MAX_EVAL_ORDER                     = $0D30;
+  GL_MAX_LIGHTS                         = $0D31;
+  GL_MAX_CLIP_PLANES                    = $0D32;
+  GL_MAX_TEXTURE_SIZE                   = $0D33;
+  GL_MAX_PIXEL_MAP_TABLE                = $0D34;
+  GL_MAX_VIEWPORT_DIMS                  = $0D3A;
+  GL_MAX_CLIENT_ATTRIB_STACK_DEPTH      = $0D3B;
+
+  // Gets
+  GL_ATTRIB_STACK_DEPTH                 = $0BB0;
+  GL_CLIENT_ATTRIB_STACK_DEPTH          = $0BB1;
+  GL_COLOR_CLEAR_VALUE                  = $0C22;
+  GL_COLOR_WRITEMASK                    = $0C23;
+  GL_CURRENT_INDEX                      = $0B01;
+  GL_CURRENT_COLOR                      = $0B00;
+  GL_CURRENT_NORMAL                     = $0B02;
+  GL_CURRENT_RASTER_COLOR               = $0B04;
+  GL_CURRENT_RASTER_DISTANCE            = $0B09;
+  GL_CURRENT_RASTER_INDEX               = $0B05;
+  GL_CURRENT_RASTER_POSITION            = $0B07;
+  GL_CURRENT_RASTER_TEXTURE_COORDS      = $0B06;
+  GL_CURRENT_RASTER_POSITION_VALID      = $0B08;
+  GL_CURRENT_TEXTURE_COORDS             = $0B03;
+  GL_INDEX_CLEAR_VALUE                  = $0C20;
+  GL_INDEX_MODE                         = $0C30;
+  GL_INDEX_WRITEMASK                    = $0C21;
+  GL_MODELVIEW_MATRIX                   = $0BA6;
+  GL_MODELVIEW_STACK_DEPTH              = $0BA3;
+  GL_NAME_STACK_DEPTH                   = $0D70;
+  GL_PROJECTION_MATRIX                  = $0BA7;
+  GL_PROJECTION_STACK_DEPTH             = $0BA4;
+  GL_RENDER_MODE                        = $0C40;
+  GL_RGBA_MODE                          = $0C31;
+  GL_TEXTURE_MATRIX                     = $0BA8;
+  GL_TEXTURE_STACK_DEPTH                = $0BA5;
+  GL_VIEWPORT                           = $0BA2;
+
+  // Evaluators
+  GL_AUTO_NORMAL                        = $0D80;
+  GL_MAP1_COLOR_4                       = $0D90;
+  GL_MAP1_GRID_DOMAIN                   = $0DD0;
+  GL_MAP1_GRID_SEGMENTS                 = $0DD1;
+  GL_MAP1_INDEX                         = $0D91;
+  GL_MAP1_NORMAL                        = $0D92;
+  GL_MAP1_TEXTURE_COORD_1               = $0D93;
+  GL_MAP1_TEXTURE_COORD_2               = $0D94;
+  GL_MAP1_TEXTURE_COORD_3               = $0D95;
+  GL_MAP1_TEXTURE_COORD_4               = $0D96;
+  GL_MAP1_VERTEX_3                      = $0D97;
+  GL_MAP1_VERTEX_4                      = $0D98;
+  GL_MAP2_COLOR_4                       = $0DB0;
+  GL_MAP2_GRID_DOMAIN                   = $0DD2;
+  GL_MAP2_GRID_SEGMENTS                 = $0DD3;
+  GL_MAP2_INDEX                         = $0DB1;
+  GL_MAP2_NORMAL                        = $0DB2;
+  GL_MAP2_TEXTURE_COORD_1               = $0DB3;
+  GL_MAP2_TEXTURE_COORD_2               = $0DB4;
+  GL_MAP2_TEXTURE_COORD_3               = $0DB5;
+  GL_MAP2_TEXTURE_COORD_4               = $0DB6;
+  GL_MAP2_VERTEX_3                      = $0DB7;
+  GL_MAP2_VERTEX_4                      = $0DB8;
+  GL_COEFF                              = $0A00;
+  GL_DOMAIN                             = $0A02;
+  GL_ORDER                              = $0A01;
+
+  // Hints
+  GL_FOG_HINT                           = $0C54;
+  GL_LINE_SMOOTH_HINT                   = $0C52;
+  GL_PERSPECTIVE_CORRECTION_HINT        = $0C50;
+  GL_POINT_SMOOTH_HINT                  = $0C51;
+  GL_POLYGON_SMOOTH_HINT                = $0C53;
+  GL_DONT_CARE                          = $1100;
+  GL_FASTEST                            = $1101;
+  GL_NICEST                             = $1102;
+
+  // Scissor box
+  GL_SCISSOR_TEST                       = $0C11;
+  GL_SCISSOR_BOX                        = $0C10;
+
+  // Pixel Mode / Transfer
+  GL_MAP_COLOR                          = $0D10;
+  GL_MAP_STENCIL                        = $0D11;
+  GL_INDEX_SHIFT                        = $0D12;
+  GL_INDEX_OFFSET                       = $0D13;
+  GL_RED_SCALE                          = $0D14;
+  GL_RED_BIAS                           = $0D15;
+  GL_GREEN_SCALE                        = $0D18;
+  GL_GREEN_BIAS                         = $0D19;
+  GL_BLUE_SCALE                         = $0D1A;
+  GL_BLUE_BIAS                          = $0D1B;
+  GL_ALPHA_SCALE                        = $0D1C;
+  GL_ALPHA_BIAS                         = $0D1D;
+  GL_DEPTH_SCALE                        = $0D1E;
+  GL_DEPTH_BIAS                         = $0D1F;
+  GL_PIXEL_MAP_S_TO_S_SIZE              = $0CB1;
+  GL_PIXEL_MAP_I_TO_I_SIZE              = $0CB0;
+  GL_PIXEL_MAP_I_TO_R_SIZE              = $0CB2;
+  GL_PIXEL_MAP_I_TO_G_SIZE              = $0CB3;
+  GL_PIXEL_MAP_I_TO_B_SIZE              = $0CB4;
+  GL_PIXEL_MAP_I_TO_A_SIZE              = $0CB5;
+  GL_PIXEL_MAP_R_TO_R_SIZE              = $0CB6;
+  GL_PIXEL_MAP_G_TO_G_SIZE              = $0CB7;
+  GL_PIXEL_MAP_B_TO_B_SIZE              = $0CB8;
+  GL_PIXEL_MAP_A_TO_A_SIZE              = $0CB9;
+  GL_PIXEL_MAP_S_TO_S                   = $0C71;
+  GL_PIXEL_MAP_I_TO_I                   = $0C70;
+  GL_PIXEL_MAP_I_TO_R                   = $0C72;
+  GL_PIXEL_MAP_I_TO_G                   = $0C73;
+  GL_PIXEL_MAP_I_TO_B                   = $0C74;
+  GL_PIXEL_MAP_I_TO_A                   = $0C75;
+  GL_PIXEL_MAP_R_TO_R                   = $0C76;
+  GL_PIXEL_MAP_G_TO_G                   = $0C77;
+  GL_PIXEL_MAP_B_TO_B                   = $0C78;
+  GL_PIXEL_MAP_A_TO_A                   = $0C79;
+  GL_PACK_ALIGNMENT                     = $0D05;
+  GL_PACK_LSB_FIRST                     = $0D01;
+  GL_PACK_ROW_LENGTH                    = $0D02;
+  GL_PACK_SKIP_PIXELS                   = $0D04;
+  GL_PACK_SKIP_ROWS                     = $0D03;
+  GL_PACK_SWAP_BYTES                    = $0D00;
+  GL_UNPACK_ALIGNMENT                   = $0CF5;
+  GL_UNPACK_LSB_FIRST                   = $0CF1;
+  GL_UNPACK_ROW_LENGTH                  = $0CF2;
+  GL_UNPACK_SKIP_PIXELS                 = $0CF4;
+  GL_UNPACK_SKIP_ROWS                   = $0CF3;
+  GL_UNPACK_SWAP_BYTES                  = $0CF0;
+  GL_ZOOM_X                             = $0D16;
+  GL_ZOOM_Y                             = $0D17;
+
+  // Texture mapping
+  GL_TEXTURE_ENV                        = $2300;
+  GL_TEXTURE_ENV_MODE                   = $2200;
+  GL_TEXTURE_1D                         = $0DE0;
+  GL_TEXTURE_2D                         = $0DE1;
+  GL_TEXTURE_WRAP_S                     = $2802;
+  GL_TEXTURE_WRAP_T                     = $2803;
+  GL_TEXTURE_MAG_FILTER                 = $2800;
+  GL_TEXTURE_MIN_FILTER                 = $2801;
+  GL_TEXTURE_ENV_COLOR                  = $2201;
+  GL_TEXTURE_GEN_S                      = $0C60;
+  GL_TEXTURE_GEN_T                      = $0C61;
+  GL_TEXTURE_GEN_MODE                   = $2500;
+  GL_TEXTURE_BORDER_COLOR               = $1004;
+  GL_TEXTURE_WIDTH                      = $1000;
+  GL_TEXTURE_HEIGHT                     = $1001;
+  GL_TEXTURE_BORDER                     = $1005;
+  GL_TEXTURE_COMPONENTS                 = $1003;
+  GL_TEXTURE_RED_SIZE                   = $805C;
+  GL_TEXTURE_GREEN_SIZE                 = $805D;
+  GL_TEXTURE_BLUE_SIZE                  = $805E;
+  GL_TEXTURE_ALPHA_SIZE                 = $805F;
+  GL_TEXTURE_LUMINANCE_SIZE             = $8060;
+  GL_TEXTURE_INTENSITY_SIZE             = $8061;
+  GL_NEAREST_MIPMAP_NEAREST             = $2700;
+  GL_NEAREST_MIPMAP_LINEAR              = $2702;
+  GL_LINEAR_MIPMAP_NEAREST              = $2701;
+  GL_LINEAR_MIPMAP_LINEAR               = $2703;
+  GL_OBJECT_LINEAR                      = $2401;
+  GL_OBJECT_PLANE                       = $2501;
+  GL_EYE_LINEAR                         = $2400;
+  GL_EYE_PLANE                          = $2502;
+  GL_SPHERE_MAP                         = $2402;
+  GL_DECAL                              = $2101;
+  GL_MODULATE                           = $2100;
+  GL_NEAREST                            = $2600;
+  GL_REPEAT                             = $2901;
+  GL_CLAMP                              = $2900;
+  GL_S                                  = $2000;
+  GL_T                                  = $2001;
+  GL_R                                  = $2002;
+  GL_Q                                  = $2003;
+  GL_TEXTURE_GEN_R                      = $0C62;
+  GL_TEXTURE_GEN_Q                      = $0C63;
+
+  // GL 1.1 texturing
+  GL_PROXY_TEXTURE_1D                   = $8063;
+  GL_PROXY_TEXTURE_2D                   = $8064;
+  GL_TEXTURE_PRIORITY                   = $8066;
+  GL_TEXTURE_RESIDENT                   = $8067;
+  GL_TEXTURE_BINDING_1D                 = $8068;
+  GL_TEXTURE_BINDING_2D                 = $8069;
+  GL_TEXTURE_INTERNAL_FORMAT            = $1003;
+
+
+  // GL 1.2 texturing
+  GL_PACK_SKIP_IMAGES                   = $806B;
+  GL_PACK_IMAGE_HEIGHT                  = $806C;
+  GL_UNPACK_SKIP_IMAGES                 = $806D;
+  GL_UNPACK_IMAGE_HEIGHT                = $806E;
+  GL_TEXTURE_3D                         = $806F;
+  GL_PROXY_TEXTURE_3D                   = $8070;
+  GL_TEXTURE_DEPTH                      = $8071;
+  GL_TEXTURE_WRAP_R                     = $8072;
+  GL_MAX_3D_TEXTURE_SIZE                = $8073;
+  GL_TEXTURE_BINDING_3D                 = $806A;
+
+  // Internal texture formats (GL 1.1)
+  GL_ALPHA4                             = $803B;
+  GL_ALPHA8                             = $803C;
+  GL_ALPHA12                            = $803D;
+  GL_ALPHA16                            = $803E;
+  GL_LUMINANCE4                         = $803F;
+  GL_LUMINANCE8                         = $8040;
+  GL_LUMINANCE12                        = $8041;
+  GL_LUMINANCE16                        = $8042;
+  GL_LUMINANCE4_ALPHA4                  = $8043;
+  GL_LUMINANCE6_ALPHA2                  = $8044;
+  GL_LUMINANCE8_ALPHA8                  = $8045;
+  GL_LUMINANCE12_ALPHA4                 = $8046;
+  GL_LUMINANCE12_ALPHA12                = $8047;
+  GL_LUMINANCE16_ALPHA16                = $8048;
+  GL_INTENSITY                          = $8049;
+  GL_INTENSITY4                         = $804A;
+  GL_INTENSITY8                         = $804B;
+  GL_INTENSITY12                        = $804C;
+  GL_INTENSITY16                        = $804D;
+  GL_R3_G3_B2                           = $2A10;
+  GL_RGB4                               = $804F;
+  GL_RGB5                               = $8050;
+  GL_RGB8                               = $8051;
+  GL_RGB10                              = $8052;
+  GL_RGB12                              = $8053;
+  GL_RGB16                              = $8054;
+  GL_RGBA2                              = $8055;
+  GL_RGBA4                              = $8056;
+  GL_RGB5_A1                            = $8057;
+  GL_RGBA8                              = $8058;
+  GL_RGB10_A2                           = $8059;
+  GL_RGBA12                             = $805A;
+  GL_RGBA16                             = $805B;
+
+  // Utility
+  GL_VENDOR                             = $1F00;
+  GL_RENDERER                           = $1F01;
+  GL_VERSION                            = $1F02;
+  GL_EXTENSIONS                         = $1F03;
+
+  // Errors
+  GL_INVALID_VALUE                      = $0501;
+  GL_INVALID_ENUM                       = $0500;
+  GL_INVALID_OPERATION                  = $0502;
+  GL_STACK_OVERFLOW                     = $0503;
+  GL_STACK_UNDERFLOW                    = $0504;
+  GL_OUT_OF_MEMORY                      = $0505;
+
+  // OpenGL 1.2
+  GL_RESCALE_NORMAL                     = $803A;
+  GL_CLAMP_TO_EDGE                      = $812F;
+  GL_MAX_ELEMENTS_VERTICES              = $F0E8;
+  GL_MAX_ELEMENTS_INDICES               = $F0E9;
+  GL_BGR                                = $80E0;
+  GL_BGRA                               = $80E1;
+  GL_UNSIGNED_BYTE_3_3_2                = $8032;
+  GL_UNSIGNED_BYTE_2_3_3_REV            = $8362;
+  GL_UNSIGNED_SHORT_5_6_5               = $8363;
+  GL_UNSIGNED_SHORT_5_6_5_REV           = $8364;
+  GL_UNSIGNED_SHORT_4_4_4_4             = $8033;
+  GL_UNSIGNED_SHORT_4_4_4_4_REV         = $8365;
+  GL_UNSIGNED_SHORT_5_5_5_1             = $8034;
+  GL_UNSIGNED_SHORT_1_5_5_5_REV         = $8366;
+  GL_UNSIGNED_INT_8_8_8_8               = $8035;
+  GL_UNSIGNED_INT_8_8_8_8_REV           = $8367;
+  GL_UNSIGNED_INT_10_10_10_2            = $8036;
+  GL_UNSIGNED_INT_2_10_10_10_REV        = $8368;
+  GL_LIGHT_MODEL_COLOR_CONTROL          = $81F8;
+  GL_SINGLE_COLOR                       = $81F9;
+  GL_SEPARATE_SPECULAR_COLOR            = $81FA;
+  GL_TEXTURE_MIN_LOD                    = $813A;
+  GL_TEXTURE_MAX_LOD                    = $813B;
+  GL_TEXTURE_BASE_LEVEL                 = $813C;
+  GL_TEXTURE_MAX_LEVEL                  = $813D;
+
+
+// -------------------------------------------------------------------
+//   GL procedures and functions
+// -------------------------------------------------------------------
+
+var
+%END
+
+
+#=====================================================================
+# Procedures and functions
+#=====================================================================
+
+%PROCS
+  // Miscellaneous
+  glClearIndex: procedure(c: Single);
+  glClearColor: procedure(red, green, blue, alpha: GLclampf);
+  glClear: procedure(mask: GLbitfield);
+  glIndexMask: procedure(mask: LongWord);
+  glColorMask: procedure(red, green, blue, alpha: Boolean);
+  glAlphaFunc: procedure(func: GLenum; ref: GLclampf);
+  glBlendFunc: procedure(sfactor, dfactor: GLenum);
+  glLogicOp: procedure(opcode: GLenum);
+  glCullFace: procedure(mode: GLenum);
+  glFrontFace: procedure(mode: GLenum);
+  glPointSize: procedure(size: Single);
+  glLineWidth: procedure(width: Single);
+  glLineStipple: procedure(factor: LongInt; pattern: Word);
+  glPolygonMode: procedure(face, mode: GLenum);
+  glPolygonOffset: procedure(factor, units: Single);
+  glPolygonStipple: procedure(var mask: Byte);
+  glGetPolygonStipple: procedure(var mask: Byte);
+  glEdgeFlag: procedure(flag: Boolean);
+  glEdgeFlagv: procedure(var flag: Boolean);
+  glScissor: procedure(x, y, width, height: LongInt);
+  glClipPlane: procedure(plane: GLenum; var equation: Double);
+  glGetClipPlane: procedure(plane: GLenum; var equation: Double);
+  glDrawBuffer: procedure(mode: GLenum);
+  glReadBuffer: procedure(mode: GLenum);
+  glEnable: procedure(cap: LongInt);
+  glDisable: procedure(cap: LongInt);
+  glIsEnabled: function(cap: GLenum): Boolean;
+  glEnableClientState: procedure(cap: GLenum);  // 1.1
+  glDisableClientState: procedure(cap: GLenum);  // 1.1
+  glGetBooleanv: procedure(pname: GLenum; var params: Boolean);
+  glGetDoublev: procedure(pname: GLenum; var params: Double);
+  glGetFloatv: procedure(pname: GLenum; var params: Single);
+  glGetIntegerv: procedure(pname: GLenum; var params: LongInt);
+  glPushAttrib: procedure(mask: GLbitfield);
+  glPopAttrib: procedure;
+  glPushClientAttrib: procedure(mask: GLbitfield);  // 1.1
+  glPopClientAttrib: procedure;  // 1.1
+  glRenderMode: function(mode: GLenum): LongInt;
+  glGetError: function: GLenum;
+  glGetString: function(name: GLenum): PChar;
+  glFinish: procedure;
+  glFlush: procedure;
+  glHint: procedure(target, mode: GLenum);
+
+
+  // Depth Buffer
+  glClearDepth: procedure(depth: GLclampd);
+  glDepthFunc: procedure(func: LongInt);
+  glDepthMask: procedure(flag: Boolean);
+  glDepthRange: procedure(near_val, far_val: GLclampd);
+
+  // Accumulation Buffer
+  glClearAccum: procedure(red, green, blue, alpha: Single);
+  glAccum: procedure(op: GLenum; value: Single);
+
+  // Tranformation
+  glMatrixMode: procedure(mode: GLenum);
+  glOrtho: procedure(left, right, bottom, top, near_val, far_val: Double);
+  glFrustum: procedure(left, right, bottom, top, near_val, far_val: Double);
+  glViewport: procedure(x, y, width, height: LongInt);
+  glPushMatrix: procedure;
+  glPopMatrix: procedure;
+  glLoadIdentity: procedure;
+  glLoadMatrixd: procedure(var m: Double);
+  glLoadMatrixf: procedure(var m: PSingle);
+  glMultMatrixd: procedure(var m: Double);
+  glMultMatrixf: procedure(var m: Single);
+  glRotated: procedure(angle, x, y, z: Double);
+  glRotatef: procedure(angle, x, y, z: Single);
+  glScaled: procedure(x, y, z: Double);
+  glScalef: procedure(x, y, z: Single);
+  glTranslated: procedure(x, y, z: Double);
+  glTranslatef: procedure(x, y, z: Single);
+
+  // Display Lists
+  glIsList: function(list: LongWord): Boolean;
+  glDeleteLists: procedure(list: LongWord; range: LongInt);
+  glGenLists: function(range: LongInt): LongWord;
+  glNewList: procedure(list: LongWord; mode: GLenum);
+  glEndList: procedure;
+  glCallList: procedure(list: LongWord);
+  glCallLists: procedure(n: LongInt; AType: GLenum; var lists);
+  glListBase: procedure(base: LongWord);
+
+  // Drawing Functions
+  glBegin: procedure(mode: GLenum);
+  glEnd: procedure;
+  glVertex2d: procedure(x, y: Double);
+  glVertex2f: procedure(x, y: Single);
+  glVertex2i: procedure(x, y: LongInt);
+  glVertex2s: procedure(x, y: SmallInt);
+  glVertex3d: procedure(x, y, z: Double);
+  glVertex3f: procedure(x, y, z: Single);
+  glVertex3i: procedure(x, y, z: LongInt);
+  glVertex3s: procedure(x, y, z: SmallInt);
+  glVertex4d: procedure(x, y, z, w: Double);
+  glVertex4f: procedure(x, y, z, w: Single);
+  glVertex4i: procedure(x, y, z, w: LongInt);
+  glVertex4s: procedure(x, y, z, w: SmallInt);
+  glVertex2dv: procedure(var v: Double);
+  glVertex2fv: procedure(var v: Single);
+  glVertex2iv: procedure(var v: LongInt);
+  glVertex2sv: procedure(var v: SmallInt);
+  glVertex3dv: procedure(var v: Double);
+  glVertex3fv: procedure(var v: Single);
+  glVertex3iv: procedure(var v: LongInt);
+  glVertex3sv: procedure(var v: SmallInt);
+  glVertex4dv: procedure(var v: Double);
+  glVertex4fv: procedure(var v: Single);
+  glVertex4iv: procedure(var v: LongInt);
+  glVertex4sv: procedure(var v: SmallInt);
+  glNormal3b: procedure(nx, ny, nz: Byte);
+  glNormal3d: procedure(nx, ny, nz: Double);
+  glNormal3f: procedure(nx, ny, nz: Single);
+  glNormal3i: procedure(nx, ny, nz: LongInt);
+  glNormal3s: procedure(nx, ny, nz: SmallInt);
+  glNormal3bv: procedure(var v: ShortInt);
+  glNormal3dv: procedure(var v: Double);
+  glNormal3fv: procedure(var v: Single);
+  glNormal3iv: procedure(var v: LongInt);
+  glNormal3sv: procedure(var v: SmallInt);
+  glIndexd: procedure(c: Double);
+  glIndexf: procedure(c: Single);
+  glIndexi: procedure(c: LongInt);
+  glIndexs: procedure(c: SmallInt);
+  glIndexub: procedure(c: Byte);  // 1.1
+  glIndexdv: procedure(var c: Double);
+  glIndexfv: procedure(var c: Single);
+  glIndexiv: procedure(var c: LongInt);
+  glIndexsv: procedure(var c: SmallInt);
+  glIndexubv: procedure(var c: Byte);  // 1.1
+  glColor3b : procedure(red, green, blue: ShortInt);
+  glColor3d : procedure(red, green, blue: Double);
+  glColor3f : procedure(red, green, blue: Single);
+  glColor3i : procedure(red, green, blue: LongInt);
+  glColor3s : procedure(red, green, blue: SmallInt);
+  glColor3ub: procedure(red, green, blue: Byte);
+  glColor3ui: procedure(red, green, blue: LongWord);
+  glColor3us: procedure(red, green, blue: Word);
+  glColor4b : procedure(red, green, blue, alpha: ShortInt);
+  glColor4d : procedure(red, green, blue, alpha: Double);
+  glColor4f : procedure(red, green, blue, alpha: Single);
+  glColor4i : procedure(red, green, blue, alpha: LongInt);
+  glColor4s : procedure(red, green, blue, alpha: SmallInt);
+  glColor4ub: procedure(red, green, blue, alpha: Byte);
+  glColor4ui: procedure(red, green, blue, alpha: LongWord);
+  glColor4us: procedure(red, green, blue, alpha: Word);
+  glColor3bv : procedure(var v: ShortInt);
+  glColor3dv : procedure(var v: Double);
+  glColor3fv : procedure(var v: Single);
+  glColor3iv : procedure(var v: LongInt);
+  glColor3sv : procedure(var v: SmallInt);
+  glColor3ubv: procedure(var v: Byte);
+  glColor3uiv: procedure(var v: LongWord);
+  glColor3usv: procedure(var v: Word);
+  glColor4bv : procedure(var v: ShortInt);
+  glColor4dv : procedure(var v: Double);
+  glColor4fv : procedure(var v: Single);
+  glColor4iv : procedure(var v: LongInt);
+  glColor4sv : procedure(var v: SmallInt);
+  glColor4ubv: procedure(var v: Byte);
+  glColor4uiv: procedure(var v: LongWord);
+  glColor4usv: procedure(var v: Word);
+  glTexCoord1d: procedure(s: Double);
+  glTexCoord1f: procedure(s: Single);
+  glTexCoord1i: procedure(s: LongInt);
+  glTexCoord1s: procedure(s: SmallInt);
+  glTexCoord2d: procedure(s, t: Double);
+  glTexCoord2f: procedure(s, t: Single);
+  glTexCoord2i: procedure(s, t: LongInt);
+  glTexCoord2s: procedure(s, t: SmallInt);
+  glTexCoord3d: procedure(s, t, r: Double);
+  glTexCoord3f: procedure(s, t, r: Single);
+  glTexCoord3i: procedure(s, t, r: LongInt);
+  glTexCoord3s: procedure(s, t, r: SmallInt);
+  glTexCoord4d: procedure(s, t, r, q: Double);
+  glTexCoord4f: procedure(s, t, r, q: Single);
+  glTexCoord4i: procedure(s, t, r, q: LongInt);
+  glTexCoord4s: procedure(s, t, r, q: SmallInt);
+  glTexCoord1dv: procedure(var v: Double);
+  glTexCoord1fv: procedure(var v: Single);
+  glTexCoord1iv: procedure(var v: LongInt);
+  glTexCoord1sv: procedure(var v: SmallInt);
+  glTexCoord2dv: procedure(var v: Double);
+  glTexCoord2fv: procedure(var v: Single);
+  glTexCoord2iv: procedure(var v: LongInt);
+  glTexCoord2sv: procedure(var v: SmallInt);
+  glTexCoord3dv: procedure(var v: Double);
+  glTexCoord3fv: procedure(var v: Single);
+  glTexCoord3iv: procedure(var v: LongInt);
+  glTexCoord3sv: procedure(var v: SmallInt);
+  glTexCoord4dv: procedure(var v: Double);
+  glTexCoord4fv: procedure(var v: Single);
+  glTexCoord4iv: procedure(var v: LongInt);
+  glTexCoord4sv: procedure(var v: SmallInt);
+  glRasterPos2d: procedure(x, y: Double);
+  glRasterPos2f: procedure(x, y: Single);
+  glRasterPos2i: procedure(x, y: LongInt);
+  glRasterPos2s: procedure(x, y: SmallInt);
+  glRasterPos3d: procedure(x, y, z: Double);
+  glRasterPos3f: procedure(x, y, z: Single);
+  glRasterPos3i: procedure(x, y, z: LongInt);
+  glRasterPos3s: procedure(x, y, z: SmallInt);
+  glRasterPos4d: procedure(x, y, z, w: Double);
+  glRasterPos4f: procedure(x, y, z, w: Single);
+  glRasterPos4i: procedure(x, y, z, w: LongInt);
+  glRasterPos4s: procedure(x, y, z, w: SmallInt);
+  glRasterPos2dv: procedure(var v: Double);
+  glRasterPos2fv: procedure(var v: Single);
+  glRasterPos2iv: procedure(var v: LongInt);
+  glRasterPos2sv: procedure(var v: SmallInt);
+  glRasterPos3dv: procedure(var v: Double);
+  glRasterPos3fv: procedure(var v: Single);
+  glRasterPos3iv: procedure(var v: LongInt);
+  glRasterPos3sv: procedure(var v: SmallInt);
+  glRasterPos4dv: procedure(var v: Double);
+  glRasterPos4fv: procedure(var v: Single);
+  glRasterPos4iv: procedure(var v: LongInt);
+  glRasterPos4sv: procedure(var v: SmallInt);
+  glRectd: procedure(x1, y1, x2, y2: Double);
+  glRectf: procedure(x1, y1, x2, y2: Single);
+  glRecti: procedure(x1, y1, x2, y2: LongInt);
+  glRects: procedure(x1, y1, x2, y2: SmallInt);
+  glRectdv: procedure(var v1, v2: Double);
+  glRectfv: procedure(var v1, v2: Single);
+  glRectiv: procedure(var v1, v2: LongInt);
+  glRectsv: procedure(var v1, v2: SmallInt);
+
+  // Vertex Arrays (1.1)
+  glVertexPointer: procedure(size: LongInt; AType: GLenum; stride: LongInt; var ptr);
+  glNormalPointer: procedure(AType: GLenum; stride: LongInt; var ptr);
+  glColorPointer: procedure(size: LongInt; AType: GLenum; stride: LongInt; var ptr);
+  glIndexPointer: procedure(AType: GLenum; stride: LongInt; var ptr);
+  glTexCoordPointer: procedure(size: LongInt; AType: GLenum; stride: LongInt; var ptr);
+  glEdgeFlagPointer: procedure(stride: LongInt; var ptr);
+  glGetPointerv: procedure(pname: GLenum; var params: Pointer);
+  glArrayElement: procedure(i: LongInt);
+  glDrawArrays: procedure(mode: GLenum; first, count: LongInt);
+  glDrawElements: procedure(mode: GLenum; count: Integer; AType: GLenum; var indices);
+  glInterleavedArrays: procedure(format: GLenum; stride: LongInt; var pointer);
+
+  // Lighting
+  glShadeModel: procedure(mode: GLenum);
+  glLightf: procedure(light, pname: GLenum; param: Single);
+  glLighti: procedure(light, pname: GLenum; param: LongInt);
+  glLightfv: procedure(light, pname: GLenum; var params: Single);
+  glLightiv: procedure(light, pname: GLenum; var params: LongInt);
+  glGetLightfv: procedure(light, pname: GLenum; var params: Single);
+  glGetLightiv: procedure(light, pname: GLenum; var params: LongInt);
+  glLightModelf: procedure(pname: GLenum; param: Single);
+  glLightModeli: procedure(pname: GLenum; param: LongInt);
+  glLightModelfv: procedure(pname: GLenum; var params: Single);
+  glLightModeliv: procedure(pname: GLenum; var param: LongInt);
+  glMaterialf: procedure(face, pname: GLenum; param: Single);
+  glMateriali: procedure(face, pname: GLenum; param: LongInt);
+  glMaterialfv: procedure(face, pname: GLenum; var params: Single);
+  glMaterialiv: procedure(face, pname: GLenum; var params: LongInt);
+  glGetMaterialfv: procedure(face, pname: GLenum; var params: Single);
+  glGetMaterialiv: procedure(face, pname: GLenum; var params: LongInt);
+  glColorMaterial: procedure(face, mode: GLenum);
+
+  // Raster Functions
+  glPixelZoom: procedure(xfactor, yfactor: Single);
+  glPixelStoref: procedure(pname: GLenum; param: Single);
+  glPixelStorei: procedure(pname: GLenum; param: LongInt);
+  glPixelTransferf: procedure(pname: GLenum; param: Single);
+  glPixelTransferi: procedure(pname: GLenum; param: LongInt);
+  glPixelMapfv: procedure(map: GLenum; mapsize: LongInt; var values: Single);
+  glPixelMapuiv: procedure(map: GLenum; mapsize: LongInt; var values: LongWord);
+  glPixelMapusv: procedure(map: GLenum; mapsize: LongInt; var values: Word);
+  glGetPixelMapfv: procedure(map: GLenum; var values: Single);
+  glGetPixelMapuiv: procedure(map: GLenum; var values: LongWord);
+  glGetPixelMapusv: procedure(map: GLenum; var values: Word);
+  glBitmap: procedure(width, height: LongInt; xorig, yorig, xmove, ymove: Single; var bitmap);
+  glReadPixels: procedure(x, y, width, height: LongInt; format, AType: GLenum; var pixels);
+  glDrawPixels: procedure(width, height: LongInt; format, AType: GLenum; var pixels);
+  glCopyPixels: procedure(x, y, width, height: LongInt; AType: GLenum);
+
+  // Stenciling
+  glStencilFunc: procedure(func: GLenum; ref: LongInt; mask: LongWord);
+  glStencilMask: procedure(mask: LongWord);
+  glStencilOp: procedure(fail, zfail, zpass: GLenum);
+  glClearStencil: procedure(s: LongInt);
+
+  // Texture Mapping
+  glTexGend: procedure(cord, pname: GLenum; param: Double);
+  glTexGenf: procedure(cord, pname: GLenum; param: Single);
+  glTexGeni: procedure(cord, pname: GLenum; param: LongInt);
+  glTexGendv: procedure(cord, pname: GLenum; var params: Double);
+  glTexGenfv: procedure(cord, pname: GLenum; var params: Single);
+  glTexGeniv: procedure(cord, pname: GLenum; var params: LongInt);
+  glGetTexGendv: procedure(cord, pname: GLenum; var params: Double);
+  glGetTexGenfv: procedure(cord, pname: GLenum; var params: Single);
+  glGetTexGeniv: procedure(cord, pname: GLenum; var params: LongInt);
+  glTexEnvf: procedure(target, pname: GLenum; param: Single);
+  glTexEnvi: procedure(target, pname: GLenum; param: LongInt);
+  glTexEnvfv: procedure(target, pname: GLenum; var params: Single);
+  glTexEnviv: procedure(target, pname: GLenum; var params: LongInt);
+  glGetTexEnvfv: procedure(target, pname: GLenum; var params: Single);
+  glGetTexEnviv: procedure(target, pname: GLenum; var params: LongInt);
+  glTexParameterf: procedure(target, pname: GLenum; param: Single);
+  glTexParameteri: procedure(target, pname: GLenum; param: LongInt);
+  glTexParameterfv: procedure(target, pname: GLenum; var params: Single);
+  glTexParameteriv: procedure(target, pname: GLenum; var params: LongInt);
+  glGetTexParameterfv: procedure(target, pname: GLenum; var params: Single);
+  glGetTexParameteriv: procedure(target, pname: GLenum; var params: LongInt);
+  glGetTexLevelParameterfv: procedure(target: GLenum; level: LongInt; pname: GLenum; var params: Single);
+  glGetTexLevelParameteriv: procedure(target: GLenum; level: LongInt; pname: GLenum; var params: LongInt);
+  glTexImage1D: procedure(target: GLenum; level, internalFormat, width, border: LongInt; format, AType: GLenum; var pixels);
+  glTexImage2D: procedure(target: GLenum; level, internalFormat, width, height, border: LongInt; format, AType: GLenum; var pixels);
+  glGetTexImage: procedure(target: GLenum; level: LongInt; format, AType: GLenum; var pixels);
+  // 1.1 functions:
+  glGenTextures: procedure(n: LongInt; var textures: LongWord);
+  glDeleteTextures: procedure(n: LongInt; var textures: LongWord);
+  glBindTexture: procedure(target: GLenum; texture: LongWord);
+  glPrioritizeTextures: procedure(n: LongInt; var textures: LongWord; var priorities: GLclampf);
+  glAreTexturesResident: function(n: LongInt; var textures: LongWord; var residences: Boolean): Boolean;
+  glIsTexture: function(texture: LongWord): Boolean;
+  glTexSubImage1D: procedure(target: GLenum; level, xoffset, width: LongInt; format, AType: GLenum; var pixels);
+  glTexSubImage2D: procedure(target: GLenum; level, xoffset, yoffset, width, height: LongInt; format, AType: GLenum; var pixels);
+  glCopyTexImage1D: procedure(target: GLenum; level: LongInt; format: GLenum; x, y, width, border: LongInt);
+  glCopyTexImage2D: procedure(target: GLenum; level: LongInt; format: GLenum; x, y, width, height, border: LongInt);
+  glCopyTexSubImage1D: procedure(target: GLenum; level, xoffset, x, y, width: LongInt);
+  glCopyTexSubImage2D: procedure(target: GLenum; level, xoffset, yoffset, x, y, width, height: LongInt);
+
+  // Evaluators
+  glMap1d: procedure(target: GLenum; u1, u2: Double; stride, order: LongInt; var points: Double);
+  glMap1f: procedure(target: GLenum; u1, u2: Single; stride, order: LongInt; var points: Single);
+  glMap2d: procedure(target: GLenum; u1, u2: Double; ustride, uorder: LongInt; v1, v2: Double; vstride, vorder: LongInt; var points: Double);
+  glMap2f: procedure(target: GLenum; u1, u2: Single; ustride, uorder: LongInt; v1, v2: Single; vstride, vorder: LongInt; var points: Single);
+  glGetMapdv: procedure(target, query: GLenum; var v: Double);
+  glGetMapfv: procedure(target, query: GLenum; var v: Single);
+  glGetMapiv: procedure(target, query: GLenum; var v: LongInt);
+  glEvalCoord1d: procedure(u: Double);
+  glEvalCoord1f: procedure(u: Single);
+  glEvalCoord1dv: procedure(var u: Double);
+  glEvalCoord1fv: procedure(var u: Single);
+  glEvalCoord2d: procedure(u, v: Double);
+  glEvalCoord2f: procedure(u, v: Single);
+  glEvalCoord2dv: procedure(var u, v: Double);
+  glEvalCoord2fv: procedure(var u, v: Single);
+  glMapGrid1d: procedure(un: LongInt; u1, u2: Double);
+  glMapGrid1f: procedure(un: LongInt; u1, u2: Single);
+  glMapGrid2d: procedure(un: LongInt; u1, u2: Double; vn: LongInt; v1, v2: Double);
+  glMapGrid2f: procedure(un: LongInt; u1, u2: Single; vn: LongInt; v1, v2: Single);
+  glEvalPoint1: procedure(i: LongInt);
+  glEvalPoint2: procedure(i, j: LongInt);
+  glEvalMesh1: procedure(mode: GLenum; i1, i2: LongInt);
+  glEvalMesh2: procedure(mode: GLenum; i1, i2, j1, j2: LongInt);
+
+  // Fog
+  glFogf: procedure(pname: GLenum; param: Single);
+  glFogi: procedure(pname: GLenum; param: LongInt);
+  glFogfv: procedure(pname: GLenum; var params: Single);
+  glFogiv: procedure(pname: GLenum; var params: LongInt);
+
+  // Selection and Feedback
+  glFeedbackBuffer: procedure(size: LongInt; AType: GLenum; var buffer: Single);
+  glPassThrough: procedure(token: Single);
+  glSelectBuffer: procedure(size: LongInt; var buffer: LongWord);
+  glInitNames: procedure;
+  glLoadName: procedure(name: LongWord);
+  glPushName: procedure(name: LongWord);
+  glPopName: procedure;
+%END

packages/opengl/build2/gl10.def

@@ -0,0 +1,866 @@
+# This is the definition file for all GL 1.0 stuff
+
+%COPY_INTERFACE
+
+const
+  GL_NO_ERROR				= 0;
+
+  // Boolean values
+  GL_FALSE 				= 0;
+  GL_TRUE  				= 1;
+
+  // Data types
+  GL_BYTE           			= $1400;
+  GL_UNSIGNED_BYTE  			= $1401;
+  GL_SHORT          			= $1402;
+  GL_UNSIGNED_SHORT 			= $1403;
+  GL_INT            			= $1404;
+  GL_UNSIGNED_INT  			= $1405;
+  GL_FLOAT          			= $1406;
+  GL_DOUBLE         			= $140A;
+  GL_2_BYTES       			= $1407;
+  GL_3_BYTES        			= $1408;
+  GL_4_BYTES        			= $1409;
+
+  // Primitives
+  GL_LINES          			= $0001;
+  GL_POINTS         			= $0000;
+  GL_LINE_STRIP     			= $0003;
+  GL_LINE_LOOP      			= $0002;
+  GL_TRIANGLES      			= $0004;
+  GL_TRIANGLE_STRIP 			= $0005;
+  GL_TRIANGLE_FAN   			= $0006;
+  GL_QUADS          			= $0007;
+  GL_QUAD_STRIP     			= $0008;
+  GL_POLYGON        			= $0009;
+  GL_EDGE_FLAG      			= $0B43;
+
+  // Vertex arrays
+  GL_VERTEX_ARRAY			= $8074;
+  GL_NORMAL_ARRAY			= $8075;
+  GL_COLOR_ARRAY			= $8076;
+  GL_INDEX_ARRAY			= $8077;
+  GL_TEXTURE_COORD_ARRAY		= $8078;
+  GL_EDGE_FLAG_ARRAY			= $8079;
+  GL_VERTEX_ARRAY_SIZE			= $807A;
+  GL_VERTEX_ARRAY_TYPE			= $807B;
+  GL_VERTEX_ARRAY_STRIDE		= $807C;
+  GL_NORMAL_ARRAY_TYPE			= $807E;
+  GL_NORMAL_ARRAY_STRIDE		= $807F;
+  GL_COLOR_ARRAY_SIZE			= $8081;
+  GL_COLOR_ARRAY_TYPE			= $8082;
+  GL_COLOR_ARRAY_STRIDE			= $8083;
+  GL_INDEX_ARRAY_TYPE			= $8085;
+  GL_INDEX_ARRAY_STRIDE			= $8086;
+  GL_TEXTURE_COORD_ARRAY_SIZE		= $8088;
+  GL_TEXTURE_COORD_ARRAY_TYPE		= $8089;
+  GL_TEXTURE_COORD_ARRAY_STRIDE		= $808A;
+  GL_EDGE_FLAG_ARRAY_STRIDE		= $808C;
+  GL_VERTEX_ARRAY_POINTER		= $808E;
+  GL_NORMAL_ARRAY_POINTER		= $808F;
+  GL_COLOR_ARRAY_POINTER		= $8090;
+  GL_INDEX_ARRAY_POINTER		= $8091;
+  GL_TEXTURE_COORD_ARRAY_POINTER	= $8092;
+  GL_EDGE_FLAG_ARRAY_POINTER		= $8093;
+  GL_V2F				= $2A20;
+  GL_V3F				= $2A21;
+  GL_C4UB_V2F				= $2A22;
+  GL_C4UB_V3F				= $2A23;
+  GL_C3F_V3F				= $2A24;
+  GL_N3F_V3F				= $2A25;
+  GL_C4F_N3F_V3F			= $2A26;
+  GL_T2F_V3F				= $2A27;
+  GL_T4F_V4F				= $2A28;
+  GL_T2F_C4UB_V3F			= $2A29;
+  GL_T2F_C3F_V3F			= $2A2A;
+  GL_T2F_N3F_V3F			= $2A2B;
+  GL_T2F_C4F_N3F_V3F			= $2A2C;
+  GL_T4F_C4F_N3F_V4F			= $2A2D;
+
+  // Matrix Mode
+  GL_MATRIX_MODE			= $0BA0;
+  GL_MODELVIEW  			= $1700;
+  GL_PROJECTION 			= $1701;
+  GL_TEXTURE    			= $1702;
+
+  // Points
+  GL_POINT_SMOOTH			= $0B10;
+  GL_POINT_SIZE				= $0B11;
+  GL_POINT_SIZE_GRANULARITY 		= $0B13;
+  GL_POINT_SIZE_RANGE			= $0B12;
+
+  // Lines
+  GL_LINE_SMOOTH			= $0B20;
+  GL_LINE_STIPPLE			= $0B24;
+  GL_LINE_STIPPLE_PATTERN		= $0B25;
+  GL_LINE_STIPPLE_REPEAT		= $0B26;
+  GL_LINE_WIDTH				= $0B21;
+  GL_LINE_WIDTH_GRANULARITY		= $0B23;
+  GL_LINE_WIDTH_RANGE			= $0B22;
+
+  // Polygons
+  GL_POINT                 		= $1B00;
+  GL_LINE                  		= $1B01;
+  GL_FILL                  		= $1B02;
+  GL_CCW                   		= $0901;
+  GL_CW                    		= $0900;
+  GL_FRONT                 		= $0404;
+  GL_BACK                  		= $0405;
+  GL_CULL_FACE             		= $0B44;
+  GL_CULL_FACE_MODE        		= $0B45;
+  GL_POLYGON_SMOOTH        		= $0B41;
+  GL_POLYGON_STIPPLE       		= $0B42;
+  GL_FRONT_FACE            		= $0B46;
+  GL_POLYGON_MODE          		= $0B40;
+  GL_POLYGON_OFFSET_FACTOR 		= $8038;
+  GL_POLYGON_OFFSET_UNITS  		= $2A00;
+  GL_POLYGON_OFFSET_POINT  		= $2A01;
+  GL_POLYGON_OFFSET_LINE   		= $2A02;
+  GL_POLYGON_OFFSET_FILL   		= $8037;
+
+  // Display lists
+  GL_COMPILE				= $1300;
+  GL_COMPILE_AND_EXECUTE		= $1301;
+  GL_LIST_BASE				= $0B32;
+  GL_LIST_INDEX				= $0B33;
+  GL_LIST_MODE				= $0B30;
+
+  // Depth buffer
+  GL_NEVER             			= $0200;
+  GL_LESS              			= $0201;
+  GL_GEQUAL            			= $0206;
+  GL_LEQUAL            			= $0203;
+  GL_GREATER           			= $0204;
+  GL_NOTEQUAL          			= $0205;
+  GL_EQUAL             			= $0202;
+  GL_ALWAYS            			= $0207;
+  GL_DEPTH_TEST        			= $0B71;
+  GL_DEPTH_BITS        			= $0D56;
+  GL_DEPTH_CLEAR_VALUE 			= $0B73;
+  GL_DEPTH_FUNC        			= $0B74;
+  GL_DEPTH_RANGE       			= $0B70;
+  GL_DEPTH_WRITEMASK   			= $0B72;
+  GL_DEPTH_COMPONENT   			= $1902;
+
+  // Lighting
+  GL_LIGHTING				= $0B50;
+  GL_LIGHT0				= $4000;
+  GL_LIGHT1				= $4001;
+  GL_LIGHT2				= $4002;
+  GL_LIGHT3				= $4003;
+  GL_LIGHT4				= $4004;
+  GL_LIGHT5				= $4005;
+  GL_LIGHT6				= $4006;
+  GL_LIGHT7				= $4007;
+  GL_SPOT_EXPONENT			= $1205;
+  GL_SPOT_CUTOFF			= $1206;
+  GL_CONSTANT_ATTENUATION		= $1207;
+  GL_LINEAR_ATTENUATION			= $1208;
+  GL_QUADRATIC_ATTENUATION		= $1209;
+  GL_AMBIENT				= $1200;
+  GL_DIFFUSE				= $1201;
+  GL_SPECULAR				= $1202;
+  GL_SHININESS				= $1601;
+  GL_EMISSION				= $1600;
+  GL_POSITION				= $1203;
+  GL_SPOT_DIRECTION			= $1204;
+  GL_AMBIENT_AND_DIFFUSE		= $1602;
+  GL_COLOR_INDEXES			= $1603;
+  GL_LIGHT_MODEL_TWO_SIDE		= $0B52;
+  GL_LIGHT_MODEL_LOCAL_VIEWER		= $0B51;
+  GL_LIGHT_MODEL_AMBIENT		= $0B53;
+  GL_FRONT_AND_BACK			= $0408;
+  GL_SHADE_MODEL			= $0B54;
+  GL_FLAT				= $1D00;
+  GL_SMOOTH				= $1D01;
+  GL_COLOR_MATERIAL			= $0B57;
+  GL_COLOR_MATERIAL_FACE		= $0B55;
+  GL_COLOR_MATERIAL_PARAMETER		= $0B56;
+  GL_NORMALIZE				= $0BA1;
+
+  // User clipping planes
+  GL_CLIP_PLANE0			= $3000;
+  GL_CLIP_PLANE1			= $3001;
+  GL_CLIP_PLANE2			= $3002;
+  GL_CLIP_PLANE3			= $3003;
+  GL_CLIP_PLANE4			= $3004;
+  GL_CLIP_PLANE5			= $3005;
+
+  // Accumulation buffer
+  GL_ACCUM_RED_BITS			= $0D58;
+  GL_ACCUM_GREEN_BITS			= $0D59;
+  GL_ACCUM_BLUE_BITS			= $0D5A;
+  GL_ACCUM_ALPHA_BITS			= $0D5B;
+  GL_ACCUM_CLEAR_VALUE			= $0B80;
+  GL_ACCUM				= $0100;
+  GL_ADD				= $0104;
+  GL_LOAD				= $0101;
+  GL_MULT				= $0103;
+  GL_RETURN				= $0102;
+
+  // Alpha testing
+  GL_ALPHA_TEST				= $0BC0;
+  GL_ALPHA_TEST_REF			= $0BC2;
+  GL_ALPHA_TEST_FUNC			= $0BC1;
+
+  // Blending
+  GL_BLEND				= $0BE2;
+  GL_BLEND_SRC				= $0BE1;
+  GL_BLEND_DST				= $0BE0;
+  GL_ZERO				= 0;
+  GL_ONE				= 1;
+  GL_SRC_COLOR				= $0300;
+  GL_ONE_MINUS_SRC_COLOR		= $0301;
+  GL_DST_COLOR				= $0306;
+  GL_ONE_MINUS_DST_COLOR		= $0307;
+  GL_SRC_ALPHA				= $0302;
+  GL_ONE_MINUS_SRC_ALPHA		= $0303;
+  GL_DST_ALPHA				= $0304;
+  GL_ONE_MINUS_DST_ALPHA		= $0305;
+  GL_SRC_ALPHA_SATURATE			= $0308;
+  GL_CONSTANT_COLOR			= $8001;
+  GL_ONE_MINUS_CONSTANT_COLOR		= $8002;
+  GL_CONSTANT_ALPHA			= $8003;
+  GL_ONE_MINUS_CONSTANT_ALPHA		= $8004;
+
+  // Render mode
+  GL_FEEDBACK				= $1C01;
+  GL_RENDER				= $1C00;
+  GL_SELECT				= $1C02;
+
+  // Feedback
+  GL_2D					= $0600;
+  GL_3D					= $0601;
+  GL_3D_COLOR				= $0602;
+  GL_3D_COLOR_TEXTURE			= $0603;
+  GL_4D_COLOR_TEXTURE			= $0604;
+  GL_POINT_TOKEN			= $0701;
+  GL_LINE_TOKEN				= $0702;
+  GL_LINE_RESET_TOKEN			= $0707;
+  GL_POLYGON_TOKEN			= $0703;
+  GL_BITMAP_TOKEN			= $0704;
+  GL_DRAW_PIXEL_TOKEN			= $0705;
+  GL_COPY_PIXEL_TOKEN			= $0706;
+  GL_PASS_THROUGH_TOKEN			= $0700;
+  GL_FEEDBACK_BUFFER_POINTER		= $0DF0;
+  GL_FEEDBACK_BUFFER_SIZE		= $0DF1;
+  GL_FEEDBACK_BUFFER_TYPE		= $0DF2;
+
+  // Selection
+  GL_SELECTION_BUFFER_POINTER		= $0DF3;
+  GL_SELECTION_BUFFER_SIZE		= $0DF4;
+
+  // Fog
+  GL_FOG				= $0B60;
+  GL_FOG_MODE				= $0B65;
+  GL_FOG_DENSITY			= $0B62;
+  GL_FOG_COLOR				= $0B66;
+  GL_FOG_INDEX				= $0B61;
+  GL_FOG_START				= $0B63;
+  GL_FOG_END				= $0B64;
+  GL_LINEAR				= $2601;
+  GL_EXP				= $0800;
+  GL_EXP2				= $0801;
+
+  // Logic ops
+  GL_LOGIC_OP				= $0BF1;
+  GL_INDEX_LOGIC_OP			= $0BF1;
+  GL_COLOR_LOGIC_OP			= $0BF2;
+  GL_LOGIC_OP_MODE			= $0BF0;
+  GL_CLEAR				= $1500;
+  GL_SET				= $150F;
+  GL_COPY				= $1503;
+  GL_COPY_INVERTED			= $150C;
+  GL_NOOP				= $1505;
+  GL_INVERT				= $150A;
+  GL_AND				= $1501;
+  GL_NAND				= $150E;
+  GL_OR					= $1507;
+  GL_NOR				= $1508;
+  GL_XOR				= $1506;
+  GL_EQUIV				= $1509;
+  GL_AND_REVERSE			= $1502;
+  GL_AND_INVERTED			= $1504;
+  GL_OR_REVERSE				= $150B;
+  GL_OR_INVERTED			= $150D;
+
+  // Stencil
+  GL_STENCIL_TEST			= $0B90;
+  GL_STENCIL_WRITEMASK			= $0B98;
+  GL_STENCIL_BITS			= $0D57;
+  GL_STENCIL_FUNC			= $0B92;
+  GL_STENCIL_VALUE_MASK			= $0B93;
+  GL_STENCIL_REF			= $0B97;
+  GL_STENCIL_FAIL			= $0B94;
+  GL_STENCIL_PASS_DEPTH_PASS		= $0B96;
+  GL_STENCIL_PASS_DEPTH_FAIL		= $0B95;
+  GL_STENCIL_CLEAR_VALUE		= $0B91;
+  GL_STENCIL_INDEX			= $1901;
+  GL_KEEP				= $1E00;
+  GL_REPLACE				= $1E01;
+  GL_INCR				= $1E02;
+  GL_DECR				= $1E03;
+
+  // Buffers, Pixel Drawing/Reading
+  GL_NONE				= 0;
+  GL_LEFT				= $0406;
+  GL_RIGHT				= $0407;
+  //GL_FRONT				= $0404;
+  //GL_BACK				= $0405;
+  //GL_FRONT_AND_BACK			= $0408;
+  GL_FRONT_LEFT				= $0400;
+  GL_FRONT_RIGHT			= $0401;
+  GL_BACK_LEFT				= $0402;
+  GL_BACK_RIGHT				= $0403;
+  GL_AUX0				= $0409;
+  GL_AUX1				= $040A;
+  GL_AUX2				= $040B;
+  GL_AUX3				= $040C;
+  GL_COLOR_INDEX			= $1900;
+  GL_RED				= $1903;
+  GL_GREEN				= $1904;
+  GL_BLUE				= $1905;
+  GL_ALPHA				= $1906;
+  GL_LUMINANCE				= $1909;
+  GL_LUMINANCE_ALPHA			= $190A;
+  GL_ALPHA_BITS				= $0D55;
+  GL_RED_BITS				= $0D52;
+  GL_GREEN_BITS				= $0D53;
+  GL_BLUE_BITS				= $0D54;
+  GL_INDEX_BITS				= $0D51;
+  GL_SUBPIXEL_BITS			= $0D50;
+  GL_AUX_BUFFERS			= $0C00;
+  GL_READ_BUFFER			= $0C02;
+  GL_DRAW_BUFFER			= $0C01;
+  GL_DOUBLEBUFFER			= $0C32;
+  GL_STEREO				= $0C33;
+  GL_BITMAP				= $1A00;
+  GL_COLOR				= $1800;
+  GL_DEPTH				= $1801;
+  GL_STENCIL				= $1802;
+  GL_DITHER				= $0BD0;
+  GL_RGB				= $1907;
+  GL_RGBA				= $1908;
+
+  // Implementation limits
+  GL_MAX_LIST_NESTING			= $0B31;
+  GL_MAX_ATTRIB_STACK_DEPTH		= $0D35;
+  GL_MAX_MODELVIEW_STACK_DEPTH		= $0D36;
+  GL_MAX_NAME_STACK_DEPTH		= $0D37;
+  GL_MAX_PROJECTION_STACK_DEPTH		= $0D38;
+  GL_MAX_TEXTURE_STACK_DEPTH		= $0D39;
+  GL_MAX_EVAL_ORDER			= $0D30;
+  GL_MAX_LIGHTS				= $0D31;
+  GL_MAX_CLIP_PLANES			= $0D32;
+  GL_MAX_TEXTURE_SIZE			= $0D33;
+  GL_MAX_PIXEL_MAP_TABLE		= $0D34;
+  GL_MAX_VIEWPORT_DIMS			= $0D3A;
+  GL_MAX_CLIENT_ATTRIB_STACK_DEPTH	= $0D3B;
+
+  // Gets
+  GL_ATTRIB_STACK_DEPTH			= $0BB0;
+  GL_CLIENT_ATTRIB_STACK_DEPTH		= $0BB1;
+  GL_COLOR_CLEAR_VALUE			= $0C22;
+  GL_COLOR_WRITEMASK			= $0C23;
+  GL_CURRENT_INDEX			= $0B01;
+  GL_CURRENT_COLOR			= $0B00;
+  GL_CURRENT_NORMAL			= $0B02;
+  GL_CURRENT_RASTER_COLOR		= $0B04;
+  GL_CURRENT_RASTER_DISTANCE		= $0B09;
+  GL_CURRENT_RASTER_INDEX		= $0B05;
+  GL_CURRENT_RASTER_POSITION		= $0B07;
+  GL_CURRENT_RASTER_TEXTURE_COORDS 	= $0B06;
+  GL_CURRENT_RASTER_POSITION_VALID 	= $0B08;
+  GL_CURRENT_TEXTURE_COORDS		= $0B03;
+  GL_INDEX_CLEAR_VALUE			= $0C20;
+  GL_INDEX_MODE				= $0C30;
+  GL_INDEX_WRITEMASK			= $0C21;
+  GL_MODELVIEW_MATRIX			= $0BA6;
+  GL_MODELVIEW_STACK_DEPTH		= $0BA3;
+  GL_NAME_STACK_DEPTH			= $0D70;
+  GL_PROJECTION_MATRIX			= $0BA7;
+  GL_PROJECTION_STACK_DEPTH		= $0BA4;
+  GL_RENDER_MODE			= $0C40;
+  GL_RGBA_MODE				= $0C31;
+  GL_TEXTURE_MATRIX			= $0BA8;
+  GL_TEXTURE_STACK_DEPTH		= $0BA5;
+  GL_VIEWPORT				= $0BA2;
+
+  // Evaluators
+  GL_AUTO_NORMAL			= $0D80;
+  GL_MAP1_COLOR_4			= $0D90;
+  GL_MAP1_GRID_DOMAIN			= $0DD0;
+  GL_MAP1_GRID_SEGMENTS			= $0DD1;
+  GL_MAP1_INDEX				= $0D91;
+  GL_MAP1_NORMAL			= $0D92;
+  GL_MAP1_TEXTURE_COORD_1		= $0D93;
+  GL_MAP1_TEXTURE_COORD_2		= $0D94;
+  GL_MAP1_TEXTURE_COORD_3		= $0D95;
+  GL_MAP1_TEXTURE_COORD_4		= $0D96;
+  GL_MAP1_VERTEX_3			= $0D97;
+  GL_MAP1_VERTEX_4			= $0D98;
+  GL_MAP2_COLOR_4			= $0DB0;
+  GL_MAP2_GRID_DOMAIN			= $0DD2;
+  GL_MAP2_GRID_SEGMENTS			= $0DD3;
+  GL_MAP2_INDEX				= $0DB1;
+  GL_MAP2_NORMAL			= $0DB2;
+  GL_MAP2_TEXTURE_COORD_1		= $0DB3;
+  GL_MAP2_TEXTURE_COORD_2		= $0DB4;
+  GL_MAP2_TEXTURE_COORD_3		= $0DB5;
+  GL_MAP2_TEXTURE_COORD_4		= $0DB6;
+  GL_MAP2_VERTEX_3			= $0DB7;
+  GL_MAP2_VERTEX_4			= $0DB8;
+  GL_COEFF				= $0A00;
+  GL_DOMAIN				= $0A02;
+  GL_ORDER				= $0A01;
+
+  // Hints
+  GL_FOG_HINT				= $0C54;
+  GL_LINE_SMOOTH_HINT			= $0C52;
+  GL_PERSPECTIVE_CORRECTION_HINT	= $0C50;
+  GL_POINT_SMOOTH_HINT			= $0C51;
+  GL_POLYGON_SMOOTH_HINT		= $0C53;
+  GL_DONT_CARE				= $1100;
+  GL_FASTEST				= $1101;
+  GL_NICEST				= $1102;
+
+  // Scissor box
+  GL_SCISSOR_TEST			= $0C11;
+  GL_SCISSOR_BOX			= $0C10;
+
+  // Pixel Mode / Transfer
+  GL_MAP_COLOR				= $0D10;
+  GL_MAP_STENCIL			= $0D11;
+  GL_INDEX_SHIFT			= $0D12;
+  GL_INDEX_OFFSET			= $0D13;
+  GL_RED_SCALE				= $0D14;
+  GL_RED_BIAS				= $0D15;
+  GL_GREEN_SCALE			= $0D18;
+  GL_GREEN_BIAS				= $0D19;
+  GL_BLUE_SCALE				= $0D1A;
+  GL_BLUE_BIAS				= $0D1B;
+  GL_ALPHA_SCALE			= $0D1C;
+  GL_ALPHA_BIAS				= $0D1D;
+  GL_DEPTH_SCALE			= $0D1E;
+  GL_DEPTH_BIAS				= $0D1F;
+  GL_PIXEL_MAP_S_TO_S_SIZE		= $0CB1;
+  GL_PIXEL_MAP_I_TO_I_SIZE		= $0CB0;
+  GL_PIXEL_MAP_I_TO_R_SIZE		= $0CB2;
+  GL_PIXEL_MAP_I_TO_G_SIZE		= $0CB3;
+  GL_PIXEL_MAP_I_TO_B_SIZE		= $0CB4;
+  GL_PIXEL_MAP_I_TO_A_SIZE		= $0CB5;
+  GL_PIXEL_MAP_R_TO_R_SIZE		= $0CB6;
+  GL_PIXEL_MAP_G_TO_G_SIZE		= $0CB7;
+  GL_PIXEL_MAP_B_TO_B_SIZE		= $0CB8;
+  GL_PIXEL_MAP_A_TO_A_SIZE		= $0CB9;
+  GL_PIXEL_MAP_S_TO_S			= $0C71;
+  GL_PIXEL_MAP_I_TO_I			= $0C70;
+  GL_PIXEL_MAP_I_TO_R			= $0C72;
+  GL_PIXEL_MAP_I_TO_G			= $0C73;
+  GL_PIXEL_MAP_I_TO_B			= $0C74;
+  GL_PIXEL_MAP_I_TO_A			= $0C75;
+  GL_PIXEL_MAP_R_TO_R			= $0C76;
+  GL_PIXEL_MAP_G_TO_G			= $0C77;
+  GL_PIXEL_MAP_B_TO_B			= $0C78;
+  GL_PIXEL_MAP_A_TO_A			= $0C79;
+  GL_PACK_ALIGNMENT			= $0D05;
+  GL_PACK_LSB_FIRST			= $0D01;
+  GL_PACK_ROW_LENGTH			= $0D02;
+  GL_PACK_SKIP_PIXELS			= $0D04;
+  GL_PACK_SKIP_ROWS			= $0D03;
+  GL_PACK_SWAP_BYTES			= $0D00;
+  GL_UNPACK_ALIGNMENT			= $0CF5;
+  GL_UNPACK_LSB_FIRST			= $0CF1;
+  GL_UNPACK_ROW_LENGTH			= $0CF2;
+  GL_UNPACK_SKIP_PIXELS			= $0CF4;
+  GL_UNPACK_SKIP_ROWS			= $0CF3;
+  GL_UNPACK_SWAP_BYTES			= $0CF0;
+  GL_ZOOM_X				= $0D16;
+  GL_ZOOM_Y				= $0D17;
+
+  // Texture mapping
+  GL_TEXTURE_ENV                  	= $2300;
+  GL_TEXTURE_ENV_MODE             	= $2200;
+  GL_TEXTURE_1D                   	= $0DE0;
+  GL_TEXTURE_2D                   	= $0DE1;
+  GL_TEXTURE_WRAP_S			= $2802;
+  GL_TEXTURE_WRAP_T			= $2803;
+  GL_TEXTURE_MAG_FILTER			= $2800;
+  GL_TEXTURE_MIN_FILTER			= $2801;
+  GL_TEXTURE_ENV_COLOR			= $2201;
+  GL_TEXTURE_GEN_S			= $0C60;
+  GL_TEXTURE_GEN_T			= $0C61;
+  GL_TEXTURE_GEN_MODE			= $2500;
+  GL_TEXTURE_BORDER_COLOR		= $1004;
+  GL_TEXTURE_WIDTH			= $1000;
+  GL_TEXTURE_HEIGHT			= $1001;
+  GL_TEXTURE_BORDER			= $1005;
+  GL_TEXTURE_COMPONENTS			= $1003;
+  GL_TEXTURE_RED_SIZE			= $805C;
+  GL_TEXTURE_GREEN_SIZE			= $805D;
+  GL_TEXTURE_BLUE_SIZE			= $805E;
+  GL_TEXTURE_ALPHA_SIZE			= $805F;
+  GL_TEXTURE_LUMINANCE_SIZE		= $8060;
+  GL_TEXTURE_INTENSITY_SIZE		= $8061;
+  GL_NEAREST_MIPMAP_NEAREST		= $2700;
+  GL_NEAREST_MIPMAP_LINEAR		= $2702;
+  GL_LINEAR_MIPMAP_NEAREST		= $2701;
+  GL_LINEAR_MIPMAP_LINEAR		= $2703;
+  GL_OBJECT_LINEAR			= $2401;
+  GL_OBJECT_PLANE			= $2501;
+  GL_EYE_LINEAR				= $2400;
+  GL_EYE_PLANE				= $2502;
+  GL_SPHERE_MAP				= $2402;
+  GL_DECAL				= $2101;
+  GL_MODULATE				= $2100;
+  GL_NEAREST				= $2600;
+  GL_REPEAT				= $2901;
+  GL_CLAMP				= $2900;
+  GL_S					= $2000;
+  GL_T					= $2001;
+  GL_R					= $2002;
+  GL_Q					= $2003;
+  GL_TEXTURE_GEN_R			= $0C62;
+  GL_TEXTURE_GEN_Q			= $0C63;
+%END
+
+
+#=====================================================================
+# Procedures and functions
+#=====================================================================
+
+%PROCS
+// Miscellaneous
+glClearIndex: procedure(c: Single); 
+glClearColor: procedure(red, green, blue, alpha: GLclampf); 
+glClear: procedure(mask: GLbitfield); 
+glIndexMask: procedure(mask: LongWord); 
+glColorMask: procedure(red, green, blue, alpha: GLboolean); 
+glAlphaFunc: procedure(func: GLenum; ref: GLclampf); 
+glBlendFunc: procedure(sfactor, dfactor: GLenum); 
+glLogicOp: procedure(opcode: GLenum); 
+glCullFace: procedure(mode: GLenum); 
+glFrontFace: procedure(mode: GLenum); 
+glPointSize: procedure(size: Single); 
+glLineWidth: procedure(width: Single); 
+glLineStipple: procedure(factor: LongInt; pattern: Word); 
+glPolygonMode: procedure(face, mode: GLenum); 
+glPolygonOffset: procedure(factor, units: Single); 
+glPolygonStipple: procedure(var mask: Byte); 
+glGetPolygonStipple: procedure(var mask: Byte); 
+glEdgeFlag: procedure(flag: Boolean); 
+glEdgeFlagv: procedure(var flag: Boolean); 
+glScissor: procedure(x, y, width, height: LongInt); 
+glClipPlane: procedure(plane: GLenum; var equation: Double); 
+glGetClipPlane: procedure(plane: GLenum; var equation: Double); 
+glDrawBuffer: procedure(mode: GLenum); 
+glReadBuffer: procedure(mode: GLenum); 
+glEnable: procedure(cap: LongInt); 
+glDisable: procedure(cap: LongInt); 
+glIsEnabled: function(cap: GLenum): Boolean; 
+glGetBooleanv: procedure(pname: GLenum; var params: Boolean); 
+glGetDoublev: procedure(pname: GLenum; var params: Double); 
+glGetFloatv: procedure(pname: GLenum; var params: Single); 
+glGetIntegerv: procedure(pname: GLenum; var params: LongInt); 
+glPushAttrib: procedure(mask: GLbitfield); 
+glPopAttrib: procedure; 
+glRenderMode: function(mode: GLenum): LongInt; 
+glGetError: function: GLenum; 
+glGetString: function(name: GLenum): PChar; 
+glFinish: procedure; 
+glFlush: procedure; 
+glHint: procedure(target, mode: GLenum); 
+
+// Depth Buffer
+glClearDepth: procedure(depth: GLclampd); 
+glDepthFunc: procedure(func: LongInt); 
+glDepthMask: procedure(flag: Boolean); 
+glDepthRange: procedure(near_val, far_val: GLclampd); 
+
+// Accumulation Buffer
+glClearAccum: procedure(red, green, blue, alpha: Single); 
+glAccum: procedure(op: GLenum; value: Single); 
+
+// Tranformation
+glMatrixMode: procedure(mode: GLenum); 
+glOrtho: procedure(left, right, bottom, top, near_val, far_val: Double); 
+glFrustum: procedure(left, right, bottom, top, near_val, far_val: Double); 
+glViewport: procedure(x, y, width, height: LongInt); 
+glPushMatrix: procedure; 
+glPopMatrix: procedure; 
+glLoadIdentity: procedure; 
+glLoadMatrixd: procedure(var m: Double); 
+glLoadMatrixf: procedure(var m: PSingle); 
+glMultMatrixd: procedure(var m: Double); 
+glMultMatrixf: procedure(var m: Single); 
+glRotated: procedure(angle, x, y, z: Double); 
+glRotatef: procedure(angle, x, y, z: Single); 
+glScaled: procedure(x, y, z: Double); 
+glScalef: procedure(x, y, z: Single); 
+glTranslated: procedure(x, y, z: Double); 
+glTranslatef: procedure(x, y, z: Single); 
+
+// Display Lists
+glIsList: function(list: LongWord): Boolean; 
+glDeleteLists: procedure(list: LongWord; range: LongInt); 
+glGenLists: function(range: LongInt): LongWord; 
+glNewList: procedure(list: LongWord; mode: GLenum); 
+glEndList: procedure; 
+glCallList: procedure(list: LongWord); 
+glCallLists: procedure(n: LongInt; AType: GLenum; var lists); 
+glListBase: procedure(base: LongWord); 
+
+// Drawing Functions
+glBegin: procedure(mode: GLenum); 
+glEnd: procedure; 
+glVertex2d: procedure(x, y: Double); 
+glVertex2f: procedure(x, y: Single); 
+glVertex2i: procedure(x, y: LongInt); 
+glVertex2s: procedure(x, y: SmallInt); 
+glVertex3d: procedure(x, y, z: Double); 
+glVertex3f: procedure(x, y, z: Single); 
+glVertex3i: procedure(x, y, z: LongInt); 
+glVertex3s: procedure(x, y, z: SmallInt); 
+glVertex4d: procedure(x, y, z, w: Double); 
+glVertex4f: procedure(x, y, z, w: Single); 
+glVertex4i: procedure(x, y, z, w: LongInt); 
+glVertex4s: procedure(x, y, z, w: SmallInt); 
+glVertex2dv: procedure(var v: Double); 
+glVertex2fv: procedure(var v: Single); 
+glVertex2iv: procedure(var v: LongInt); 
+glVertex2sv: procedure(var v: SmallInt); 
+glVertex3dv: procedure(var v: Double); 
+glVertex3fv: procedure(var v: Single); 
+glVertex3iv: procedure(var v: LongInt); 
+glVertex3sv: procedure(var v: SmallInt); 
+glVertex4dv: procedure(var v: Double); 
+glVertex4fv: procedure(var v: Single); 
+glVertex4iv: procedure(var v: LongInt); 
+glVertex4sv: procedure(var v: SmallInt); 
+glNormal3b: procedure(nx, ny, nz: Byte); 
+glNormal3d: procedure(nx, ny, nz: Double); 
+glNormal3f: procedure(nx, ny, nz: Single); 
+glNormal3i: procedure(nx, ny, nz: LongInt); 
+glNormal3s: procedure(nx, ny, nz: SmallInt); 
+glNormal3bv: procedure(var v: ShortInt); 
+glNormal3dv: procedure(var v: Double); 
+glNormal3fv: procedure(var v: Single); 
+glNormal3iv: procedure(var v: LongInt); 
+glNormal3sv: procedure(var v: SmallInt); 
+glIndexd: procedure(c: Double); 
+glIndexf: procedure(c: Single); 
+glIndexi: procedure(c: LongInt); 
+glIndexs: procedure(c: SmallInt); 
+glIndexdv: procedure(var c: Double); 
+glIndexfv: procedure(var c: Single); 
+glIndexiv: procedure(var c: LongInt); 
+glIndexsv: procedure(var c: SmallInt); 
+glColor3b: procedure (red, green, blue: ShortInt); 
+glColor3d: procedure (red, green, blue: Double); 
+glColor3f: procedure (red, green, blue: Single); 
+glColor3i: procedure (red, green, blue: LongInt); 
+glColor3s: procedure (red, green, blue: SmallInt); 
+glColor3ub: procedure(red, green, blue: Byte); 
+glColor3ui: procedure(red, green, blue: LongWord); 
+glColor3us: procedure(red, green, blue: Word); 
+glColor4b: procedure (red, green, blue, alpha: ShortInt); 
+glColor4d: procedure (red, green, blue, alpha: Double); 
+glColor4f: procedure (red, green, blue, alpha: Single); 
+glColor4i: procedure (red, green, blue, alpha: LongInt); 
+glColor4s: procedure (red, green, blue, alpha: SmallInt); 
+glColor4ub: procedure(red, green, blue, alpha: Byte); 
+glColor4ui: procedure(red, green, blue, alpha: LongWord); 
+glColor4us: procedure(red, green, blue, alpha: Word); 
+glColor3bv: procedure (var v: ShortInt); 
+glColor3dv: procedure (var v: Double); 
+glColor3fv: procedure (var v: Single); 
+glColor3iv: procedure (var v: LongInt); 
+glColor3sv: procedure (var v: SmallInt); 
+glColor3ubv: procedure(var v: Byte); 
+glColor3uiv: procedure(var v: LongWord); 
+glColor3usv: procedure(var v: Word); 
+glColor4bv: procedure (var v: ShortInt); 
+glColor4dv: procedure (var v: Double); 
+glColor4fv: procedure (var v: Single); 
+glColor4iv: procedure (var v: LongInt); 
+glColor4sv: procedure (var v: SmallInt); 
+glColor4ubv: procedure(var v: Byte); 
+glColor4uiv: procedure(var v: LongWord); 
+glColor4usv: procedure(var v: Word); 
+glTexCoord1d: procedure(s: Double); 
+glTexCoord1f: procedure(s: Single); 
+glTexCoord1i: procedure(s: LongInt); 
+glTexCoord1s: procedure(s: SmallInt); 
+glTexCoord2d: procedure(s, t: Double); 
+glTexCoord2f: procedure(s, t: Single); 
+glTexCoord2i: procedure(s, t: LongInt); 
+glTexCoord2s: procedure(s, t: SmallInt); 
+glTexCoord3d: procedure(s, t, r: Double); 
+glTexCoord3f: procedure(s, t, r: Single); 
+glTexCoord3i: procedure(s, t, r: LongInt); 
+glTexCoord3s: procedure(s, t, r: SmallInt); 
+glTexCoord4d: procedure(s, t, r, q: Double); 
+glTexCoord4f: procedure(s, t, r, q: Single); 
+glTexCoord4i: procedure(s, t, r, q: LongInt); 
+glTexCoord4s: procedure(s, t, r, q: SmallInt); 
+glTexCoord1dv: procedure(var v: Double); 
+glTexCoord1fv: procedure(var v: Single); 
+glTexCoord1iv: procedure(var v: LongInt); 
+glTexCoord1sv: procedure(var v: SmallInt); 
+glTexCoord2dv: procedure(var v: Double); 
+glTexCoord2fv: procedure(var v: Single); 
+glTexCoord2iv: procedure(var v: LongInt); 
+glTexCoord2sv: procedure(var v: SmallInt); 
+glTexCoord3dv: procedure(var v: Double); 
+glTexCoord3fv: procedure(var v: Single); 
+glTexCoord3iv: procedure(var v: LongInt); 
+glTexCoord3sv: procedure(var v: SmallInt); 
+glTexCoord4dv: procedure(var v: Double); 
+glTexCoord4fv: procedure(var v: Single); 
+glTexCoord4iv: procedure(var v: LongInt); 
+glTexCoord4sv: procedure(var v: SmallInt); 
+glRasterPos2d: procedure(x, y: Double); 
+glRasterPos2f: procedure(x, y: Single); 
+glRasterPos2i: procedure(x, y: LongInt); 
+glRasterPos2s: procedure(x, y: SmallInt); 
+glRasterPos3d: procedure(x, y, z: Double); 
+glRasterPos3f: procedure(x, y, z: Single); 
+glRasterPos3i: procedure(x, y, z: LongInt); 
+glRasterPos3s: procedure(x, y, z: SmallInt); 
+glRasterPos4d: procedure(x, y, z, w: Double); 
+glRasterPos4f: procedure(x, y, z, w: Single); 
+glRasterPos4i: procedure(x, y, z, w: LongInt); 
+glRasterPos4s: procedure(x, y, z, w: SmallInt); 
+glRasterPos2dv: procedure(var v: Double); 
+glRasterPos2fv: procedure(var v: Single); 
+glRasterPos2iv: procedure(var v: LongInt); 
+glRasterPos2sv: procedure(var v: SmallInt); 
+glRasterPos3dv: procedure(var v: Double); 
+glRasterPos3fv: procedure(var v: Single); 
+glRasterPos3iv: procedure(var v: LongInt); 
+glRasterPos3sv: procedure(var v: SmallInt); 
+glRasterPos4dv: procedure(var v: Double); 
+glRasterPos4fv: procedure(var v: Single); 
+glRasterPos4iv: procedure(var v: LongInt); 
+glRasterPos4sv: procedure(var v: SmallInt); 
+glRectd: procedure(x1, y1, x2, y2: Double); 
+glRectf: procedure(x1, y1, x2, y2: Single); 
+glRecti: procedure(x1, y1, x2, y2: LongInt); 
+glRects: procedure(x1, y1, x2, y2: SmallInt); 
+glRectdv: procedure(var v1, v2: Double); 
+glRectfv: procedure(var v1, v2: Single); 
+glRectiv: procedure(var v1, v2: LongInt); 
+glRectsv: procedure(var v1, v2: SmallInt); 
+
+// Lighting
+glShadeModel: procedure(mode: GLenum); 
+glLightf: procedure(light, pname: GLenum; param: Single); 
+glLighti: procedure(light, pname: GLenum; param: LongInt); 
+glLightfv: procedure(light, pname: GLenum; var params: Single); 
+glLightiv: procedure(light, pname: GLenum; var params: LongInt); 
+glGetLightfv: procedure(light, pname: GLenum; var params: Single); 
+glGetLightiv: procedure(light, pname: GLenum; var params: LongInt); 
+glLightModelf: procedure(pname: GLenum; param: Single); 
+glLightModeli: procedure(pname: GLenum; param: LongInt); 
+glLightModelfv: procedure(pname: GLenum; var params: Single); 
+glLightModeliv: procedure(pname: GLenum; var param: LongInt); 
+glMaterialf: procedure(face, pname: GLenum; param: Single); 
+glMateriali: procedure(face, pname: GLenum; param: LongInt); 
+glMaterialfv: procedure(face, pname: GLenum; var params: Single); 
+glMaterialiv: procedure(face, pname: GLenum; var params: LongInt); 
+glGetMaterialfv: procedure(face, pname: GLenum; var params: Single); 
+glGetMaterialiv: procedure(face, pname: GLenum; var params: LongInt); 
+glColorMaterial: procedure(face, mode: GLenum); 
+
+// Raster Functions
+glPixelZoom: procedure(xfactor, yfactor: Single); 
+glPixelStoref: procedure(pname: GLenum; param: Single); 
+glPixelStorei: procedure(pname: GLenum; param: LongInt); 
+glPixelTransferf: procedure(pname: GLenum; param: Single); 
+glPixelTransferi: procedure(pname: GLenum; param: LongInt); 
+glPixelMapfv: procedure(map: GLenum; mapsize: LongInt; var values: Single); 
+glPixelMapuiv: procedure(map: GLenum; mapsize: LongInt; var values: LongWord); 
+glPixelMapusv: procedure(map: GLenum; mapsize: LongInt; var values: Word); 
+glGetPixelMapfv: procedure(map: GLenum; var values: Single); 
+glGetPixelMapuiv: procedure(map: GLenum; var values: LongWord); 
+glGetPixelMapusv: procedure(map: GLenum; var values: Word); 
+glBitmap: procedure(width, height: LongInt; xorig, yorig, xmove, ymove: Single; var bitmap); 
+glReadPixels: procedure(x, y, width, height: LongInt; format, AType: GLenum; var pixels); 
+glDrawPixels: procedure(width, height: LongInt; format, AType: GLenum; var pixels); 
+glCopyPixels: procedure(x, y, width, height: LongInt; AType: GLenum); 
+
+// Stenciling
+glStencilFunc: procedure(func: GLenum; ref: LongInt; mask: LongWord); 
+glStencilMask: procedure(mask: LongWord); 
+glStencilOp: procedure(fail, zfail, zpass: GLenum); 
+glClearStencil: procedure(s: LongInt); 
+
+// Texture Mapping
+glTexGend: procedure(cord, pname: GLenum; param: Double); 
+glTexGenf: procedure(cord, pname: GLenum; param: Single); 
+glTexGeni: procedure(cord, pname: GLenum; param: LongInt); 
+glTexGendv: procedure(cord, pname: GLenum; var params: Double); 
+glTexGenfv: procedure(cord, pname: GLenum; var params: Single); 
+glTexGeniv: procedure(cord, pname: GLenum; var params: LongInt); 
+glGetTexGendv: procedure(cord, pname: GLenum; var params: Double); 
+glGetTexGenfv: procedure(cord, pname: GLenum; var params: Single); 
+glGetTexGeniv: procedure(cord, pname: GLenum; var params: LongInt); 
+glTexEnvf: procedure(target, pname: GLenum; param: Single); 
+glTexEnvi: procedure(target, pname: GLenum; param: LongInt); 
+glTexEnvfv: procedure(target, pname: GLenum; var params: Single); 
+glTexEnviv: procedure(target, pname: GLenum; var params: LongInt); 
+glGetTexEnvfv: procedure(target, pname: GLenum; var params: Single); 
+glGetTexEnviv: procedure(target, pname: GLenum; var params: LongInt); 
+glTexParameterf: procedure(target, pname: GLenum; param: Single); 
+glTexParameteri: procedure(target, pname: GLenum; param: LongInt); 
+glTexParameterfv: procedure(target, pname: GLenum; var params: Single); 
+glTexParameteriv: procedure(target, pname: GLenum; var params: LongInt); 
+glGetTexParameterfv: procedure(target, pname: GLenum; var params: Single); 
+glGetTexParameteriv: procedure(target, pname: GLenum; var params: LongInt); 
+glGetTexLevelParameterfv: procedure(target: GLenum; level: LongInt; pname: GLenum; var params: Single); 
+glGetTexLevelParameteriv: procedure(target: GLenum; level: LongInt; pname: GLenum; var params: LongInt); 
+glTexImage1D: procedure(target: GLenum; level, internalFormat, width, border: LongInt; format, AType: GLenum; var pixels); 
+glTexImage2D: procedure(target: GLenum; level, internalFormat, width, height, border: LongInt; format, AType: GLenum; var pixels); 
+glGetTexImage: procedure(target: GLenum; level: LongInt; format, AType: GLenum; var pixels); 
+
+// Evaluators
+glMap1d: procedure(target: GLenum; u1, u2: Double; stride, order: LongInt; var points: Double); 
+glMap1f: procedure(target: GLenum; u1, u2: Single; stride, order: LongInt; var points: Single); 
+glMap2d: procedure(target: GLenum; u1, u2: Double; ustride, uorder: LongInt; v1, v2: Double; vstride, vorder: LongInt; var points: Double); 
+glMap2f: procedure(target: GLenum; u1, u2: Single; ustride, uorder: LongInt; v1, v2: Single; vstride, vorder: LongInt; var points: Single); 
+glGetMapdv: procedure(target, query: GLenum; var v: Double); 
+glGetMapfv: procedure(target, query: GLenum; var v: Single); 
+glGetMapiv: procedure(target, query: GLenum; var v: LongInt); 
+glEvalCoord1d: procedure(u: Double); 
+glEvalCoord1f: procedure(u: Single); 
+glEvalCoord1dv: procedure(var u: Double); 
+glEvalCoord1fv: procedure(var u: Single); 
+glEvalCoord2d: procedure(u, v: Double); 
+glEvalCoord2f: procedure(u, v: Single); 
+glEvalCoord2dv: procedure(var u, v: Double); 
+glEvalCoord2fv: procedure(var u, v: Single); 
+glMapGrid1d: procedure(un: LongInt; u1, u2: Double); 
+glMapGrid1f: procedure(un: LongInt; u1, u2: Single); 
+glMapGrid2d: procedure(un: LongInt; u1, u2: Double; vn: LongInt; v1, v2: Double); 
+glMapGrid2f: procedure(un: LongInt; u1, u2: Single; vn: LongInt; v1, v2: Single); 
+glEvalPoint1: procedure(i: LongInt); 
+glEvalPoint2: procedure(i, j: LongInt); 
+glEvalMesh1: procedure(mode: GLenum; i1, i2: LongInt); 
+glEvalMesh2: procedure(mode: GLenum; i1, i2, j1, j2: LongInt); 
+
+// Fog
+glFogf: procedure(pname: GLenum; param: Single); 
+glFogi: procedure(pname: GLenum; param: LongInt); 
+glFogfv: procedure(pname: GLenum; var params: Single); 
+glFogiv: procedure(pname: GLenum; var params: LongInt); 
+
+// Selection and Feedback
+glFeedbackBuffer: procedure(size: LongInt; AType: GLenum; var buffer: Single); 
+glPassThrough: procedure(token: Single); 
+glSelectBuffer: procedure(size: LongInt; var buffer: LongWord); 
+glInitNames: procedure; 
+glLoadName: procedure(name: LongWord); 
+glPushName: procedure(name: LongWord); 
+glPopName: procedure; 
+
+%END

packages/opengl/build2/gl10ext.def

@@ -0,0 +1,176 @@
+# This is the definition file for all GL 1.0 Extensions stuff
+
+%COPY_INTERFACE
+
+const
+  // GL_EXT_blend_minmax and GL_EXT_blend_color
+  GL_CONSTANT_COLOR_EXT			= $8001;
+  GL_ONE_MINUS_CONSTANT_COLOR_EXT	= $8002;
+  GL_CONSTANT_ALPHA_EXT			= $8003;
+  GL_ONE_MINUS_CONSTANT_ALPHA_EXT	= $8004;
+  GL_BLEND_EQUATION_EXT			= $8009;
+  GL_MIN_EXT				= $8007;
+  GL_MAX_EXT				= $8008;
+  GL_FUNC_ADD_EXT			= $8006;
+  GL_FUNC_SUBTRACT_EXT			= $800A;
+  GL_FUNC_REVERSE_SUBTRACT_EXT		= $800B;
+  GL_BLEND_COLOR_EXT			= $8005;
+
+  // GL_EXT_polygon_offset
+  GL_POLYGON_OFFSET_EXT			= $8037;
+  GL_POLYGON_OFFSET_FACTOR_EXT		= $8038;
+  GL_POLYGON_OFFSET_BIAS_EXT		= $8039;
+
+  // GL_EXT_vertex_array
+  GL_VERTEX_ARRAY_EXT			= $8074;
+  GL_NORMAL_ARRAY_EXT			= $8075;
+  GL_COLOR_ARRAY_EXT			= $8076;
+  GL_INDEX_ARRAY_EXT			= $8077;
+  GL_TEXTURE_COORD_ARRAY_EXT		= $8078;
+  GL_EDGE_FLAG_ARRAY_EXT		= $8079;
+  GL_VERTEX_ARRAY_SIZE_EXT		= $807A;
+  GL_VERTEX_ARRAY_TYPE_EXT		= $807B;
+  GL_VERTEX_ARRAY_STRIDE_EXT		= $807C;
+  GL_VERTEX_ARRAY_COUNT_EXT		= $807D;
+  GL_NORMAL_ARRAY_TYPE_EXT		= $807E;
+  GL_NORMAL_ARRAY_STRIDE_EXT		= $807F;
+  GL_NORMAL_ARRAY_COUNT_EXT		= $8080;
+  GL_COLOR_ARRAY_SIZE_EXT		= $8081;
+  GL_COLOR_ARRAY_TYPE_EXT		= $8082;
+  GL_COLOR_ARRAY_STRIDE_EXT		= $8083;
+  GL_COLOR_ARRAY_COUNT_EXT		= $8084;
+  GL_INDEX_ARRAY_TYPE_EXT		= $8085;
+  GL_INDEX_ARRAY_STRIDE_EXT		= $8086;
+  GL_INDEX_ARRAY_COUNT_EXT		= $8087;
+  GL_TEXTURE_COORD_ARRAY_SIZE_EXT	= $8088;
+  GL_TEXTURE_COORD_ARRAY_TYPE_EXT	= $8089;
+  GL_TEXTURE_COORD_ARRAY_STRIDE_EXT	= $808A;
+  GL_TEXTURE_COORD_ARRAY_COUNT_EXT	= $808B;
+  GL_EDGE_FLAG_ARRAY_STRIDE_EXT		= $808C;
+  GL_EDGE_FLAG_ARRAY_COUNT_EXT		= $808D;
+  GL_VERTEX_ARRAY_POINTER_EXT		= $808E;
+  GL_NORMAL_ARRAY_POINTER_EXT		= $808F;
+  GL_COLOR_ARRAY_POINTER_EXT		= $8090;
+  GL_INDEX_ARRAY_POINTER_EXT		= $8091;
+  GL_TEXTURE_COORD_ARRAY_POINTER_EXT	= $8092;
+  GL_EDGE_FLAG_ARRAY_POINTER_EXT	= $8093;
+
+  // GL_EXT_texture_object
+  GL_TEXTURE_PRIORITY_EXT		= $8066;
+  GL_TEXTURE_RESIDENT_EXT		= $8067;
+  GL_TEXTURE_1D_BINDING_EXT		= $8068;
+  GL_TEXTURE_2D_BINDING_EXT		= $8069;
+
+  // GL_EXT_texture3D
+  GL_PACK_SKIP_IMAGES_EXT		= $806B;
+  GL_PACK_IMAGE_HEIGHT_EXT		= $806C;
+  GL_UNPACK_SKIP_IMAGES_EXT		= $806D;
+  GL_UNPACK_IMAGE_HEIGHT_EXT		= $806E;
+  GL_TEXTURE_3D_EXT			= $806F;
+  GL_PROXY_TEXTURE_3D_EXT		= $8070;
+  GL_TEXTURE_DEPTH_EXT			= $8071;
+  GL_TEXTURE_WRAP_R_EXT			= $8072;
+  GL_MAX_3D_TEXTURE_SIZE_EXT		= $8073;
+  GL_TEXTURE_3D_BINDING_EXT		= $806A;
+
+  // GL_EXT_paletted_texture
+  GL_TABLE_TOO_LARGE_EXT		= $8031;
+  GL_COLOR_TABLE_FORMAT_EXT		= $80D8;
+  GL_COLOR_TABLE_WIDTH_EXT		= $80D9;
+  GL_COLOR_TABLE_RED_SIZE_EXT		= $80DA;
+  GL_COLOR_TABLE_GREEN_SIZE_EXT		= $80DB;
+  GL_COLOR_TABLE_BLUE_SIZE_EXT		= $80DC;
+  GL_COLOR_TABLE_ALPHA_SIZE_EXT	 	= $80DD;
+  GL_COLOR_TABLE_LUMINANCE_SIZE_EXT	= $80DE;
+  GL_COLOR_TABLE_INTENSITY_SIZE_EXT	= $80DF;
+  GL_TEXTURE_INDEX_SIZE_EXT		= $80ED;
+  GL_COLOR_INDEX1_EXT			= $80E2;
+  GL_COLOR_INDEX2_EXT			= $80E3;
+  GL_COLOR_INDEX4_EXT			= $80E4;
+  GL_COLOR_INDEX8_EXT			= $80E5;
+  GL_COLOR_INDEX12_EXT			= $80E6;
+  GL_COLOR_INDEX16_EXT			= $80E7;
+
+  // GL_EXT_shared_texture_palette
+  GL_SHARED_TEXTURE_PALETTE_EXT		= $81FB;
+
+  // GL_EXT_point_parameters
+  GL_POINT_SIZE_MIN_EXT			= $8126;
+  GL_POINT_SIZE_MAX_EXT			= $8127;
+  GL_POINT_FADE_THRESHOLD_SIZE_EXT	= $8128;
+  GL_DISTANCE_ATTENUATION_EXT		= $8129;
+
+  // GL_EXT_rescale_normal
+  GL_RESCALE_NORMAL_EXT			= $803A;
+
+  // GL_EXT_abgr
+  GL_ABGR_EXT				= $8000;
+
+const
+  // GL_EXT_multitexture
+  GL_SELECTED_TEXTURE_EXT		= $83C0;
+  GL_SELECTED_TEXTURE_COORD_SET_EXT	= $83C1;
+  GL_SELECTED_TEXTURE_TRANSFORM_EXT	= $83C2;
+  GL_MAX_TEXTURES_EXT			= $83C3;
+  GL_MAX_TEXTURE_COORD_SETS_EXT		= $83C4;
+  GL_TEXTURE_ENV_COORD_SET_EXT		= $83C5;
+  GL_TEXTURE0_EXT			= $83C6;
+  GL_TEXTURE1_EXT			= $83C7;
+  GL_TEXTURE2_EXT			= $83C8;
+  GL_TEXTURE3_EXT			= $83C9;
+
+%END
+
+
+#=====================================================================
+# Procedures and functions
+#=====================================================================
+
+%PROCS
+
+// === 1.0 Extensions ===
+
+// GL_EXT_blend_minmax
+glBlendEquationEXT: procedure(mode: GLenum); ogl_dll;
+
+// GL_EXT_blend_color
+glBlendColorEXT: procedure(red, green, blue, alpha: GLclampf); ogl_dll;
+
+// GL_EXT_polygon_offset
+glPolygonOffsetEXT: procedure(factor, bias: Single); ogl_dll;
+
+// GL_EXT_vertex_array
+glVertexPointerEXT: procedure(size: LongInt; AType: GLenum; stride, count: LongInt; var ptr); ogl_dll;
+glNormalPointerEXT: procedure(AType: GLenum; stride, count: LongInt; var ptr); ogl_dll;
+glColorPointerEXT: procedure(size: LongInt; AType: GLenum; stride, count: LongInt; var ptr); ogl_dll;
+glIndexPointerEXT: procedure(AType: GLenum; stride, count: LongInt; var ptr); ogl_dll;
+glTexCoordPointerEXT: procedure(size: LongInt; AType: GLenum; stride, count: LongInt; var ptr); ogl_dll;
+glEdgeFlagPointerEXT: procedure(stride, count: LongInt; var ptr: Boolean); ogl_dll;
+glGetPointervEXT: procedure(pname: GLenum; var params: Pointer); ogl_dll;
+glArrayElementEXT: procedure(i: LongInt); ogl_dll;
+glDrawArraysEXT: procedure(mode: GLEnum; first, count: LongInt); ogl_dll;
+
+// GL_EXT_texture_object
+glGenTexturesEXT: procedure(n: LongInt; var textures: LongWord); ogl_dll;
+glDeleteTexturesEXT: procedure(n: LongInt; var textures: LongWord); ogl_dll;
+glBindTextureEXT: procedure(target: GLenum; texture: LongWord); ogl_dll;
+glPrioritizeTexturesEXT: procedure(n: LongInt; var textures: LongWord; var priorities: GLClampf); ogl_dll;
+glAreTexturesResidentEXT: function(n: LongInt; var textures: LongWord; var residences: Boolean): Boolean; ogl_dll;
+glIsTextureEXT: function(texture: LongWord): Boolean; ogl_dll;
+
+// GL_EXT_texture3D
+glTexImage3DEXT: procedure(target: GLenum; level: LongInt; internalFormat: GLenum; width, height, depth, border: LongInt; format, AType: GLenum; var pixels); ogl_dll;
+glTexSubImage3DEXT: procedure(target: GLenum; level, xoffset, yoffset, zoffset, width, height, depth: LongInt; format, AType: GLenum; var pixels); ogl_dll;
+glCopyTexSubImage3DEXT: procedure(target: GLenum; level, xoffset, yoffset, zoffset, x, y, width, height: LongInt); ogl_dll;
+
+// GL_EXT_color_table
+glColorTableEXT: procedure(target, internalformat: GLenum; width: LongInt; format, AType: GLenum; var table); ogl_dll;
+glColorSubTableEXT: procedure(target: GLenum; start, count: LongInt; format, AType: GLEnum; var data); ogl_dll;
+glGetColorTableEXT: procedure(target, format, AType: GLenum; var table); ogl_dll;
+glGetColorTableParameterfvEXT: procedure(target, pname: GLenum; var params: Single); ogl_dll;
+glGetColorTableParameterivEXT: procedure(target, pname: GLenum; var params: LongInt); ogl_dll;
+
+%END
+
+
+

packages/opengl/build2/gl10mesa.def

@@ -0,0 +1,40 @@
+# This is the definition file for all GL mesa stuff
+
+%COPY_INTERFACE
+%END
+
+
+#=====================================================================
+# Procedures and functions
+#=====================================================================
+
+%PROCS
+// GL_MESA_window_pos
+glWindowPos2iMESA: procedure(x, y: LongInt); ogl_dll;
+glWindowPos2sMESA: procedure(x, y: ShortInt); ogl_dll;
+glWindowPos2fMESA: procedure(x, y: Single); ogl_dll;
+glWindowPos2dMESA: procedure(x, y: Double); ogl_dll;
+glWindowPos2ivMESA: procedure(var p: LongInt); ogl_dll;
+glWindowPos2svMESA: procedure(var p: ShortInt); ogl_dll;
+glWindowPos2fvMESA: procedure(var p: Single); ogl_dll;
+glWindowPos2dvMESA: procedure(var p: Double); ogl_dll;
+glWindowPos3iMESA: procedure(x, y, z: LongInt); ogl_dll;
+glWindowPos3sMESA: procedure(x, y, z: ShortInt); ogl_dll;
+glWindowPos3fMESA: procedure(x, y, z: Single); ogl_dll;
+glWindowPos3dMESA: procedure(x, y, z: Double); ogl_dll;
+glWindowPos3ivMESA: procedure(var p: LongInt); ogl_dll;
+glWindowPos3svMESA: procedure(var p: ShortInt); ogl_dll;
+glWindowPos3fvMESA: procedure(var p: Single); ogl_dll;
+glWindowPos3dvMESA: procedure(var p: Double); ogl_dll;
+glWindowPos4iMESA: procedure(x, y, z, w: LongInt); ogl_dll;
+glWindowPos4sMESA: procedure(x, y, z, w: ShortInt); ogl_dll;
+glWindowPos4fMESA: procedure(x, y, z, w: Single); ogl_dll;
+glWindowPos4dMESA: procedure(x, y, z, w: Double); ogl_dll;
+glWindowPos4ivMESA: procedure(var p: LongInt); ogl_dll;
+glWindowPos4svMESA: procedure(var p: ShortInt); ogl_dll;
+glWindowPos4fvMESA: procedure(var p: Single); ogl_dll;
+glWindowPos4dvMESA: procedure(var p: Double); ogl_dll;
+
+// GL_MESA_resize_buffers
+glResizeBuffersMESA: procedure; ogl_dll;
+%END

packages/opengl/build2/gl10sgi.def

@@ -0,0 +1,109 @@
+# This is the definition file for all GL 1.0 SGI stuff
+
+%COPY_INTERFACE
+
+const
+  // GL_SGIS_multitexture
+  GL_SELECTED_TEXTURE_SGIS		= $835C;
+  GL_SELECTED_TEXTURE_COORD_SET_SGIS	= $835D;
+  GL_MAX_TEXTURES_SGIS			= $835E;
+  GL_TEXTURE0_SGIS			= $835F;
+  GL_TEXTURE1_SGIS			= $8360;
+  GL_TEXTURE2_SGIS			= $8361;
+  GL_TEXTURE3_SGIS			= $8362;
+  GL_TEXTURE_COORD_SET_SOURCE_SGIS	= $8363;
+
+const
+  // GL_SGIS_texture_edge_clamp
+  GL_CLAMP_TO_EDGE_SGIS			= $812F;
+
+%END
+
+
+#=====================================================================
+# Procedures and functions
+#=====================================================================
+
+%PROCS
+
+// GL_SGIS_multitexture
+glMultiTexCoord1dSGIS: procedure(target: GLenum; s: Double); ogl_dll;
+glMultiTexCoord1dvSGIS: procedure(target: GLenum; var v: Double); ogl_dll;
+glMultiTexCoord1fSGIS: procedure(target: GLenum; s: Single); ogl_dll;
+glMultiTexCoord1fvSGIS: procedure(target: GLenum; var v: Single); ogl_dll;
+glMultiTexCoord1iSGIS: procedure(target: GLenum; s: LongInt); ogl_dll;
+glMultiTexCoord1ivSGIS: procedure(target: GLenum; var v: LongInt); ogl_dll;
+glMultiTexCoord1sSGIS: procedure(target: GLenum; s: ShortInt); ogl_dll;
+glMultiTexCoord1svSGIS: procedure(target: GLenum; var v: ShortInt); ogl_dll;
+glMultiTexCoord2dSGIS: procedure(target: GLenum; s, t: Double); ogl_dll;
+glMultiTexCoord2dvSGIS: procedure(target: GLenum; var v: Double); ogl_dll;
+glMultiTexCoord2fSGIS: procedure(target: GLenum; s, t: Single); ogl_dll;
+glMultiTexCoord2fvSGIS: procedure(target: GLenum; var v: Single); ogl_dll;
+glMultiTexCoord2iSGIS: procedure(target: GLenum; s, t: LongInt); ogl_dll;
+glMultiTexCoord2ivSGIS: procedure(target: GLenum; var v: LongInt); ogl_dll;
+glMultiTexCoord2sSGIS: procedure(target: GLenum; s, t: ShortInt); ogl_dll;
+glMultiTexCoord2svSGIS: procedure(target: GLenum; var v: ShortInt); ogl_dll;
+glMultiTexCoord3dSGIS: procedure(target: GLenum; s, t, r: Double); ogl_dll;
+glMultiTexCoord3dvSGIS: procedure(target: GLenum; var v: Double); ogl_dll;
+glMultiTexCoord3fSGIS: procedure(target: GLenum; s, t, r: Single); ogl_dll;
+glMultiTexCoord3fvSGIS: procedure(target: GLenum; var v: Single); ogl_dll;
+glMultiTexCoord3iSGIS: procedure(target: GLenum; s, t, r: LongInt); ogl_dll;
+glMultiTexCoord3ivSGIS: procedure(target: GLenum; var v: LongInt); ogl_dll;
+glMultiTexCoord3sSGIS: procedure(target: GLenum; s, t, r: ShortInt); ogl_dll;
+glMultiTexCoord3svSGIS: procedure(target: GLenum; var v: ShortInt); ogl_dll;
+glMultiTexCoord4dSGIS: procedure(target: GLenum; s, t, r, q: Double); ogl_dll;
+glMultiTexCoord4dvSGIS: procedure(target: GLenum; var v: Double); ogl_dll;
+glMultiTexCoord4fSGIS: procedure(target: GLenum; s, t, r, q: Single); ogl_dll;
+glMultiTexCoord4fvSGIS: procedure(target: GLenum; var v: Single); ogl_dll;
+glMultiTexCoord4iSGIS: procedure(target: GLenum; s, t, r, q: LongInt); ogl_dll;
+glMultiTexCoord4ivSGIS: procedure(target: GLenum; var v: LongInt); ogl_dll;
+glMultiTexCoord4sSGIS: procedure(target: GLenum; s, t, r, q: ShortInt); ogl_dll;
+glMultiTexCoord4svSGIS: procedure(target: GLenum; var v: ShortInt); ogl_dll;
+glMultiTexCoordPointerSGIS: procedure(target: GLenum; size: LongInt; AType: GLEnum; stride: LongInt; var APointer); ogl_dll;
+glSelectTextureSGIS: procedure(target: GLenum); ogl_dll;
+glSelectTextureCoordSetSGIS: procedure(target: GLenum); ogl_dll;
+
+// GL_EXT_multitexture
+glMultiTexCoord1dEXT: procedure(target: GLenum; s: Double); ogl_dll;
+glMultiTexCoord1dvEXT: procedure(target: GLenum; var v: Double); ogl_dll;
+glMultiTexCoord1fEXT: procedure(target: GLenum; s: Single); ogl_dll;
+glMultiTexCoord1fvEXT: procedure(target: GLenum; var v: Single); ogl_dll;
+glMultiTexCoord1iEXT: procedure(target: GLenum; s: LongInt); ogl_dll;
+glMultiTexCoord1ivEXT: procedure(target: GLenum; var v: LongInt); ogl_dll;
+glMultiTexCoord1sEXT: procedure(target: GLenum; s: ShortInt); ogl_dll;
+glMultiTexCoord1svEXT: procedure(target: GLenum; var v: ShortInt); ogl_dll;
+glMultiTexCoord2dEXT: procedure(target: GLenum; s, t: Double); ogl_dll;
+glMultiTexCoord2dvEXT: procedure(target: GLenum; var v: Double); ogl_dll;
+glMultiTexCoord2fEXT: procedure(target: GLenum; s, t: Single); ogl_dll;
+glMultiTexCoord2fvEXT: procedure(target: GLenum; var v: Single); ogl_dll;
+glMultiTexCoord2iEXT: procedure(target: GLenum; s, t: LongInt); ogl_dll;
+glMultiTexCoord2ivEXT: procedure(target: GLenum; var v: LongInt); ogl_dll;
+glMultiTexCoord2sEXT: procedure(target: GLenum; s, t: ShortInt); ogl_dll;
+glMultiTexCoord2svEXT: procedure(target: GLenum; var v: ShortInt); ogl_dll;
+glMultiTexCoord3dEXT: procedure(target: GLenum; s, t, r: Double); ogl_dll;
+glMultiTexCoord3dvEXT: procedure(target: GLenum; var v: Double); ogl_dll;
+glMultiTexCoord3fEXT: procedure(target: GLenum; s, t, r: Single); ogl_dll;
+glMultiTexCoord3fvEXT: procedure(target: GLenum; var v: Single); ogl_dll;
+glMultiTexCoord3iEXT: procedure(target: GLenum; s, t, r: LongInt); ogl_dll;
+glMultiTexCoord3ivEXT: procedure(target: GLenum; var v: LongInt); ogl_dll;
+glMultiTexCoord3sEXT: procedure(target: GLenum; s, t, r: ShortInt); ogl_dll;
+glMultiTexCoord3svEXT: procedure(target: GLenum; var v: ShortInt); ogl_dll;
+glMultiTexCoord4dEXT: procedure(target: GLenum; s, t, r, q: Double); ogl_dll;
+glMultiTexCoord4dvEXT: procedure(target: GLenum; var v: Double); ogl_dll;
+glMultiTexCoord4fEXT: procedure(target: GLenum; s, t, r, q: Single); ogl_dll;
+glMultiTexCoord4fvEXT: procedure(target: GLenum; var v: Single); ogl_dll;
+glMultiTexCoord4iEXT: procedure(target: GLenum; s, t, r, q: LongInt); ogl_dll;
+glMultiTexCoord4ivEXT: procedure(target: GLenum; var v: LongInt); ogl_dll;
+glMultiTexCoord4sEXT: procedure(target: GLenum; s, t, r, q: ShortInt); ogl_dll;
+glMultiTexCoord4svEXT: procedure(target: GLenum; var v: ShortInt); ogl_dll;
+glInterleavedTextureCoordSetsEXT: procedure(factor: LongInt); ogl_dll;
+glSelectTextureEXT: procedure(target: GLenum); ogl_dll;
+glSelectTextureCoordSetEXT: procedure(target: GLenum); ogl_dll;
+glSelectTextureTransformEXT: procedure(target: GLenum); ogl_dll;
+
+// GL_EXT_point_parameters
+glPointParameterfEXT: procedure(pname: GLenum; param: Single); ogl_dll;
+glPointParameterfvEXT: procedure(pname: GLenum; var params: Single); ogl_dll;
+
+%END
+

packages/opengl/build2/gl11.def

@@ -0,0 +1,96 @@
+# This is the definition file for all GL 1.1 stuff
+
+%COPY_INTERFACE
+
+const
+  // GL 1.1 texturing
+  GL_PROXY_TEXTURE_1D			= $8063;
+  GL_PROXY_TEXTURE_2D			= $8064;
+  GL_TEXTURE_PRIORITY			= $8066;
+  GL_TEXTURE_RESIDENT			= $8067;
+  GL_TEXTURE_BINDING_1D			= $8068;
+  GL_TEXTURE_BINDING_2D			= $8069;
+  GL_TEXTURE_INTERNAL_FORMAT		= $1003;
+
+  // Internal texture formats (GL 1.1)
+  GL_ALPHA4				= $803B;
+  GL_ALPHA8				= $803C;
+  GL_ALPHA12				= $803D;
+  GL_ALPHA16				= $803E;
+  GL_LUMINANCE4				= $803F;
+  GL_LUMINANCE8				= $8040;
+  GL_LUMINANCE12			= $8041;
+  GL_LUMINANCE16			= $8042;
+  GL_LUMINANCE4_ALPHA4			= $8043;
+  GL_LUMINANCE6_ALPHA2			= $8044;
+  GL_LUMINANCE8_ALPHA8			= $8045;
+  GL_LUMINANCE12_ALPHA4			= $8046;
+  GL_LUMINANCE12_ALPHA12		= $8047;
+  GL_LUMINANCE16_ALPHA16		= $8048;
+  GL_INTENSITY				= $8049;
+  GL_INTENSITY4				= $804A;
+  GL_INTENSITY8				= $804B;
+  GL_INTENSITY12			= $804C;
+  GL_INTENSITY16			= $804D;
+  GL_R3_G3_B2				= $2A10;
+  GL_RGB4				= $804F;
+  GL_RGB5				= $8050;
+  GL_RGB8				= $8051;
+  GL_RGB10				= $8052;
+  GL_RGB12				= $8053;
+  GL_RGB16				= $8054;
+  GL_RGBA2				= $8055;
+  GL_RGBA4				= $8056;
+  GL_RGB5_A1				= $8057;
+  GL_RGBA8				= $8058;
+  GL_RGB10_A2				= $8059;
+  GL_RGBA12				= $805A;
+  GL_RGBA16				= $805B;
+
+%END
+
+
+#=====================================================================
+# Procedures and functions
+#=====================================================================
+
+%PROCS
+
+// Miscellaneous
+glEnableClientState: procedure(cap: GLenum);
+glDisableClientState: procedure(cap: GLenum);
+glPushClientAttrib: procedure(mask: GLbitfield);
+glPopClientAttrib: procedure;
+
+// Drawing Functions
+glIndexub: procedure(c: Byte);
+glIndexubv: procedure(var c: Byte);
+
+// Vertex Arrays
+glVertexPointer: procedure(size: LongInt; AType: GLenum; stride: LongInt; var ptr); 
+glNormalPointer: procedure(AType: GLenum; stride: LongInt; var ptr); 
+glColorPointer: procedure(size: LongInt; AType: GLenum; stride: LongInt; var ptr); 
+glIndexPointer: procedure(AType: GLenum; stride: LongInt; var ptr); 
+glTexCoordPointer: procedure(size: LongInt; AType: GLenum; stride: LongInt; var ptr); 
+glEdgeFlagPointer: procedure(stride: LongInt; var ptr); 
+glGetPointerv: procedure(pname: GLenum; var params: Pointer); 
+glArrayElement: procedure(i: LongInt); 
+glDrawArrays: procedure(mode: GLenum; first, count: LongInt); 
+glDrawElements: procedure(mode: GLenum; count: Integer; AType: GLenum; var indices); 
+glInterleavedArrays: procedure(format: GLenum; stride: LongInt; var pointer); 
+
+// Texture Mapping
+glGenTextures: procedure(n: LongInt; var textures: LongWord); 
+glDeleteTextures: procedure(n: LongInt; var textures: LongWord); 
+glBindTexture: procedure(target: GLenum; texture: LongWord); 
+glPrioritizeTextures: procedure(n: LongInt; var textures: LongWord; var priorities: GLclampf); 
+glAreTexturesResident: function(n: LongInt; var textures: LongWord; var residences: Boolean): Boolean; 
+glIsTexture: function(texture: LongWord): Boolean; 
+glTexSubImage1D: procedure(target: GLenum; level, xoffset, width: LongInt; format, AType: GLenum; var pixels); 
+glTexSubImage2D: procedure(target: GLenum; level, xoffset, yoffset, width, height: LongInt; format, AType: GLenum; var pixels); 
+glCopyTexImage1D: procedure(target: GLenum; level: LongInt; format: GLenum; x, y, width, border: LongInt); 
+glCopyTexImage2D: procedure(target: GLenum; level: LongInt; format: GLenum; x, y, width, height, border: LongInt); 
+glCopyTexSubImage1D: procedure(target: GLenum; level, xoffset, x, y, width: LongInt); 
+glCopyTexSubImage2D: procedure(target: GLenum; level, xoffset, yoffset, x, y, width, height: LongInt); 
+
+%END

packages/opengl/build2/gl12.def

@@ -0,0 +1,58 @@
+# This is the definition file for all GL 1.2 stuff
+
+%COPY_INTERFACE
+
+const
+  // GL 1.2 texturing
+  GL_PACK_SKIP_IMAGES			= $806B;
+  GL_PACK_IMAGE_HEIGHT			= $806C;
+  GL_UNPACK_SKIP_IMAGES			= $806D;
+  GL_UNPACK_IMAGE_HEIGHT		= $806E;
+  GL_TEXTURE_3D				= $806F;
+  GL_PROXY_TEXTURE_3D			= $8070;
+  GL_TEXTURE_DEPTH			= $8071;
+  GL_TEXTURE_WRAP_R			= $8072;
+  GL_MAX_3D_TEXTURE_SIZE		= $8073;
+  GL_TEXTURE_BINDING_3D			= $806A;
+
+const
+  GL_RESCALE_NORMAL			= $803A;
+  GL_CLAMP_TO_EDGE			= $812F;
+  GL_MAX_ELEMENTS_VERTICES		= $F0E8;
+  GL_MAX_ELEMENTS_INDICES		= $F0E9;
+  GL_BGR				= $80E0;
+  GL_BGRA				= $80E1;
+  GL_UNSIGNED_BYTE_3_3_2		= $8032;
+  GL_UNSIGNED_BYTE_2_3_3_REV		= $8362;
+  GL_UNSIGNED_SHORT_5_6_5		= $8363;
+  GL_UNSIGNED_SHORT_5_6_5_REV		= $8364;
+  GL_UNSIGNED_SHORT_4_4_4_4		= $8033;
+  GL_UNSIGNED_SHORT_4_4_4_4_REV		= $8365;
+  GL_UNSIGNED_SHORT_5_5_5_1		= $8034;
+  GL_UNSIGNED_SHORT_1_5_5_5_REV		= $8366;
+  GL_UNSIGNED_INT_8_8_8_8		= $8035;
+  GL_UNSIGNED_INT_8_8_8_8_REV		= $8367;
+  GL_UNSIGNED_INT_10_10_10_2		= $8036;
+  GL_UNSIGNED_INT_2_10_10_10_REV	= $8368;
+  GL_LIGHT_MODEL_COLOR_CONTROL		= $81F8;
+  GL_SINGLE_COLOR			= $81F9;
+  GL_SEPARATE_SPECULAR_COLOR		= $81FA;
+  GL_TEXTURE_MIN_LOD			= $813A;
+  GL_TEXTURE_MAX_LOD			= $813B;
+  GL_TEXTURE_BASE_LEVEL			= $813C;
+  GL_TEXTURE_MAX_LEVEL			= $813D;
+
+%END
+
+
+#=====================================================================
+# Procedures and functions
+#=====================================================================
+
+%PROCS
+glDrawRangeElements: procedure(mode: GLenum; AStart, AEnd: LongWord; count: LongInt; AType: GLenum; var indices); ogl_dll;
+glTexImage3D: procedure(target: GLenum; level: LongInt; internalFormat: GLenum; width, height, depth, border: LongInt; format, AType: GLEnum; var pixels); ogl_dll;
+glTexSubImage3D: procedure(target: GLenum; level: LongInt; xoffset, yoffset, zoffset, width, height, depth: LongInt; format, AType: GLEnum; var pixels); ogl_dll;
+glCopyTexSubImage3D: procedure(target: GLenum; level: LongInt; xoffset, yoffset, zoffset, x, y, width, height: LongInt); ogl_dll;
+%END
+

packages/opengl/build2/glaux.def

@@ -0,0 +1,12 @@
+# This is the definition file for all GLAUX stuff
+
+%COPY_INTERFACE
+%END
+
+
+#=====================================================================
+# Procedures and functions
+#=====================================================================
+
+%PROCS
+%END

packages/opengl/build2/glext.def

@@ -0,0 +1,300 @@
+# This is the definition file for all GL extension stuff
+
+%COPY_INTERFACE
+// -------------------------------------------------------
+//   GL extensions constants
+// -------------------------------------------------------
+
+const
+  // GL_EXT_blend_minmax and GL_EXT_blend_color
+  GL_CONSTANT_COLOR_EXT                 = $8001;
+  GL_ONE_MINUS_CONSTANT_COLOR_EXT       = $8002;
+  GL_CONSTANT_ALPHA_EXT                 = $8003;
+  GL_ONE_MINUS_CONSTANT_ALPHA_EXT       = $8004;
+  GL_BLEND_EQUATION_EXT                 = $8009;
+  GL_MIN_EXT                            = $8007;
+  GL_MAX_EXT                            = $8008;
+  GL_FUNC_ADD_EXT                       = $8006;
+  GL_FUNC_SUBTRACT_EXT                  = $800A;
+  GL_FUNC_REVERSE_SUBTRACT_EXT          = $800B;
+  GL_BLEND_COLOR_EXT                    = $8005;
+
+  // GL_EXT_polygon_offset
+  GL_POLYGON_OFFSET_EXT                 = $8037;
+  GL_POLYGON_OFFSET_FACTOR_EXT          = $8038;
+  GL_POLYGON_OFFSET_BIAS_EXT            = $8039;
+
+  // GL_EXT_vertex_array
+  GL_VERTEX_ARRAY_EXT                   = $8074;
+  GL_NORMAL_ARRAY_EXT                   = $8075;
+  GL_COLOR_ARRAY_EXT                    = $8076;
+  GL_INDEX_ARRAY_EXT                    = $8077;
+  GL_TEXTURE_COORD_ARRAY_EXT            = $8078;
+  GL_EDGE_FLAG_ARRAY_EXT                = $8079;
+  GL_VERTEX_ARRAY_SIZE_EXT              = $807A;
+  GL_VERTEX_ARRAY_TYPE_EXT              = $807B;
+  GL_VERTEX_ARRAY_STRIDE_EXT            = $807C;
+  GL_VERTEX_ARRAY_COUNT_EXT             = $807D;
+  GL_NORMAL_ARRAY_TYPE_EXT              = $807E;
+  GL_NORMAL_ARRAY_STRIDE_EXT            = $807F;
+  GL_NORMAL_ARRAY_COUNT_EXT             = $8080;
+  GL_COLOR_ARRAY_SIZE_EXT               = $8081;
+  GL_COLOR_ARRAY_TYPE_EXT               = $8082;
+  GL_COLOR_ARRAY_STRIDE_EXT             = $8083;
+  GL_COLOR_ARRAY_COUNT_EXT              = $8084;
+  GL_INDEX_ARRAY_TYPE_EXT               = $8085;
+  GL_INDEX_ARRAY_STRIDE_EXT             = $8086;
+  GL_INDEX_ARRAY_COUNT_EXT              = $8087;
+  GL_TEXTURE_COORD_ARRAY_SIZE_EXT       = $8088;
+  GL_TEXTURE_COORD_ARRAY_TYPE_EXT       = $8089;
+  GL_TEXTURE_COORD_ARRAY_STRIDE_EXT     = $808A;
+  GL_TEXTURE_COORD_ARRAY_COUNT_EXT      = $808B;
+  GL_EDGE_FLAG_ARRAY_STRIDE_EXT         = $808C;
+  GL_EDGE_FLAG_ARRAY_COUNT_EXT          = $808D;
+  GL_VERTEX_ARRAY_POINTER_EXT           = $808E;
+  GL_NORMAL_ARRAY_POINTER_EXT           = $808F;
+  GL_COLOR_ARRAY_POINTER_EXT            = $8090;
+  GL_INDEX_ARRAY_POINTER_EXT            = $8091;
+  GL_TEXTURE_COORD_ARRAY_POINTER_EXT    = $8092;
+  GL_EDGE_FLAG_ARRAY_POINTER_EXT        = $8093;
+
+  // GL_EXT_texture_object
+  GL_TEXTURE_PRIORITY_EXT               = $8066;
+  GL_TEXTURE_RESIDENT_EXT               = $8067;
+  GL_TEXTURE_1D_BINDING_EXT             = $8068;
+  GL_TEXTURE_2D_BINDING_EXT             = $8069;
+
+  // GL_EXT_texture3D
+  GL_PACK_SKIP_IMAGES_EXT               = $806B;
+  GL_PACK_IMAGE_HEIGHT_EXT              = $806C;
+  GL_UNPACK_SKIP_IMAGES_EXT             = $806D;
+  GL_UNPACK_IMAGE_HEIGHT_EXT            = $806E;
+  GL_TEXTURE_3D_EXT                     = $806F;
+  GL_PROXY_TEXTURE_3D_EXT               = $8070;
+  GL_TEXTURE_DEPTH_EXT                  = $8071;
+  GL_TEXTURE_WRAP_R_EXT                 = $8072;
+  GL_MAX_3D_TEXTURE_SIZE_EXT            = $8073;
+  GL_TEXTURE_3D_BINDING_EXT             = $806A;
+
+  // GL_EXT_paletted_texture
+  GL_TABLE_TOO_LARGE_EXT                = $8031;
+  GL_COLOR_TABLE_FORMAT_EXT             = $80D8;
+  GL_COLOR_TABLE_WIDTH_EXT              = $80D9;
+  GL_COLOR_TABLE_RED_SIZE_EXT           = $80DA;
+  GL_COLOR_TABLE_GREEN_SIZE_EXT         = $80DB;
+  GL_COLOR_TABLE_BLUE_SIZE_EXT          = $80DC;
+  GL_COLOR_TABLE_ALPHA_SIZE_EXT         = $80DD;
+  GL_COLOR_TABLE_LUMINANCE_SIZE_EXT     = $80DE;
+  GL_COLOR_TABLE_INTENSITY_SIZE_EXT     = $80DF;
+  GL_TEXTURE_INDEX_SIZE_EXT             = $80ED;
+  GL_COLOR_INDEX1_EXT                   = $80E2;
+  GL_COLOR_INDEX2_EXT                   = $80E3;
+  GL_COLOR_INDEX4_EXT                   = $80E4;
+  GL_COLOR_INDEX8_EXT                   = $80E5;
+  GL_COLOR_INDEX12_EXT                  = $80E6;
+  GL_COLOR_INDEX16_EXT                  = $80E7;
+
+  // GL_EXT_shared_texture_palette
+  GL_SHARED_TEXTURE_PALETTE_EXT         = $81FB;
+
+  // GL_EXT_point_parameters
+  GL_POINT_SIZE_MIN_EXT                 = $8126;
+  GL_POINT_SIZE_MAX_EXT                 = $8127;
+  GL_POINT_FADE_THRESHOLD_SIZE_EXT      = $8128;
+  GL_DISTANCE_ATTENUATION_EXT           = $8129;
+
+  // GL_EXT_rescale_normal
+  GL_RESCALE_NORMAL_EXT                 = $803A;
+
+  // GL_EXT_abgr
+  GL_ABGR_EXT                           = $8000;
+
+  // GL_SGIS_multitexture
+  GL_SELECTED_TEXTURE_SGIS              = $835C;
+  GL_SELECTED_TEXTURE_COORD_SET_SGIS    = $835D;
+  GL_MAX_TEXTURES_SGIS                  = $835E;
+  GL_TEXTURE0_SGIS                      = $835F;
+  GL_TEXTURE1_SGIS                      = $8360;
+  GL_TEXTURE2_SGIS                      = $8361;
+  GL_TEXTURE3_SGIS                      = $8362;
+  GL_TEXTURE_COORD_SET_SOURCE_SGIS      = $8363;
+
+  // GL_EXT_multitexture
+  GL_SELECTED_TEXTURE_EXT               = $83C0;
+  GL_SELECTED_TEXTURE_COORD_SET_EXT     = $83C1;
+  GL_SELECTED_TEXTURE_TRANSFORM_EXT     = $83C2;
+  GL_MAX_TEXTURES_EXT                   = $83C3;
+  GL_MAX_TEXTURE_COORD_SETS_EXT         = $83C4;
+  GL_TEXTURE_ENV_COORD_SET_EXT          = $83C5;
+  GL_TEXTURE0_EXT                       = $83C6;
+  GL_TEXTURE1_EXT                       = $83C7;
+  GL_TEXTURE2_EXT                       = $83C8;
+  GL_TEXTURE3_EXT                       = $83C9;
+
+  // GL_SGIS_texture_edge_clamp
+  GL_CLAMP_TO_EDGE_SGIS                 = $812F;
+
+
+// -------------------------------------------------------
+//   GL Extension Procedures
+// -------------------------------------------------------
+
+var
+%END
+
+
+#=====================================================================
+# Procedures and functions
+#=====================================================================
+
+%PROCS
+  // === 1.0 Extensions ===
+
+  // GL_EXT_blend_minmax
+  glBlendEquationEXT: procedure(mode: GLenum);
+
+  // GL_EXT_blend_color
+  glBlendColorEXT: procedure(red, green, blue, alpha: GLclampf);
+
+  // GL_EXT_polygon_offset
+  glPolygonOffsetEXT: procedure(factor, bias: Single);
+
+  // GL_EXT_vertex_array
+  glVertexPointerEXT: procedure(size: LongInt; AType: GLenum; stride, count: LongInt; var ptr);
+  glNormalPointerEXT: procedure(AType: GLenum; stride, count: LongInt; var ptr);
+  glColorPointerEXT: procedure(size: LongInt; AType: GLenum; stride, count: LongInt; var ptr);
+  glIndexPointerEXT: procedure(AType: GLenum; stride, count: LongInt; var ptr);
+  glTexCoordPointerEXT: procedure(size: LongInt; AType: GLenum; stride, count: LongInt; var ptr);
+  glEdgeFlagPointerEXT: procedure(stride, count: LongInt; var ptr: Boolean);
+  glGetPointervEXT: procedure(pname: GLenum; var params: Pointer);
+  glArrayElementEXT: procedure(i: LongInt);
+  glDrawArraysEXT: procedure(mode: GLEnum; first, count: LongInt);
+
+  // GL_EXT_texture_object
+  glGenTexturesEXT: procedure(n: LongInt; var textures: LongWord);
+  glDeleteTexturesEXT: procedure(n: LongInt; var textures: LongWord);
+  glBindTextureEXT: procedure(target: GLenum; texture: LongWord);
+  glPrioritizeTexturesEXT: procedure(n: LongInt; var textures: LongWord; var priorities: GLClampf);
+  glAreTexturesResidentEXT: function(n: LongInt; var textures: LongWord; var residences: Boolean): Boolean;
+  glIsTextureEXT: function(texture: LongWord): Boolean;
+
+  // GL_EXT_texture3D
+  glTexImage3DEXT: procedure(target: GLenum; level: LongInt; internalFormat: GLenum; width, height, depth, border: LongInt; format, AType: GLenum; var pixels);
+  glTexSubImage3DEXT: procedure(target: GLenum; level, xoffset, yoffset, zoffset, width, height, depth: LongInt; format, AType: GLenum; var pixels);
+  glCopyTexSubImage3DEXT: procedure(target: GLenum; level, xoffset, yoffset, zoffset, x, y, width, height: LongInt);
+
+  // GL_EXT_color_table
+  glColorTableEXT: procedure(target, internalformat: GLenum; width: LongInt; format, AType: GLenum; var table);
+  glColorSubTableEXT: procedure(target: GLenum; start, count: LongInt; format, AType: GLEnum; var data);
+  glGetColorTableEXT: procedure(target, format, AType: GLenum; var table);
+  glGetColorTableParameterfvEXT: procedure(target, pname: GLenum; var params: Single);
+  glGetColorTableParameterivEXT: procedure(target, pname: GLenum; var params: LongInt);
+
+  // GL_SGIS_multitexture
+  glMultiTexCoord1dSGIS: procedure(target: GLenum; s: Double);
+  glMultiTexCoord1dvSGIS: procedure(target: GLenum; var v: Double);
+  glMultiTexCoord1fSGIS: procedure(target: GLenum; s: Single);
+  glMultiTexCoord1fvSGIS: procedure(target: GLenum; var v: Single);
+  glMultiTexCoord1iSGIS: procedure(target: GLenum; s: LongInt);
+  glMultiTexCoord1ivSGIS: procedure(target: GLenum; var v: LongInt);
+  glMultiTexCoord1sSGIS: procedure(target: GLenum; s: ShortInt);
+  glMultiTexCoord1svSGIS: procedure(target: GLenum; var v: ShortInt);
+  glMultiTexCoord2dSGIS: procedure(target: GLenum; s, t: Double);
+  glMultiTexCoord2dvSGIS: procedure(target: GLenum; var v: Double);
+  glMultiTexCoord2fSGIS: procedure(target: GLenum; s, t: Single);
+  glMultiTexCoord2fvSGIS: procedure(target: GLenum; var v: Single);
+  glMultiTexCoord2iSGIS: procedure(target: GLenum; s, t: LongInt);
+  glMultiTexCoord2ivSGIS: procedure(target: GLenum; var v: LongInt);
+  glMultiTexCoord2sSGIS: procedure(target: GLenum; s, t: ShortInt);
+  glMultiTexCoord2svSGIS: procedure(target: GLenum; var v: ShortInt);
+  glMultiTexCoord3dSGIS: procedure(target: GLenum; s, t, r: Double);
+  glMultiTexCoord3dvSGIS: procedure(target: GLenum; var v: Double);
+  glMultiTexCoord3fSGIS: procedure(target: GLenum; s, t, r: Single);
+  glMultiTexCoord3fvSGIS: procedure(target: GLenum; var v: Single);
+  glMultiTexCoord3iSGIS: procedure(target: GLenum; s, t, r: LongInt);
+  glMultiTexCoord3ivSGIS: procedure(target: GLenum; var v: LongInt);
+  glMultiTexCoord3sSGIS: procedure(target: GLenum; s, t, r: ShortInt);
+  glMultiTexCoord3svSGIS: procedure(target: GLenum; var v: ShortInt);
+  glMultiTexCoord4dSGIS: procedure(target: GLenum; s, t, r, q: Double);
+  glMultiTexCoord4dvSGIS: procedure(target: GLenum; var v: Double);
+  glMultiTexCoord4fSGIS: procedure(target: GLenum; s, t, r, q: Single);
+  glMultiTexCoord4fvSGIS: procedure(target: GLenum; var v: Single);
+  glMultiTexCoord4iSGIS: procedure(target: GLenum; s, t, r, q: LongInt);
+  glMultiTexCoord4ivSGIS: procedure(target: GLenum; var v: LongInt);
+  glMultiTexCoord4sSGIS: procedure(target: GLenum; s, t, r, q: ShortInt);
+  glMultiTexCoord4svSGIS: procedure(target: GLenum; var v: ShortInt);
+  glMultiTexCoordPointerSGIS: procedure(target: GLenum; size: LongInt; AType: GLEnum; stride: LongInt; var APointer);
+  glSelectTextureSGIS: procedure(target: GLenum);
+  glSelectTextureCoordSetSGIS: procedure(target: GLenum);
+
+  // GL_EXT_multitexture
+  glMultiTexCoord1dEXT: procedure(target: GLenum; s: Double);
+  glMultiTexCoord1dvEXT: procedure(target: GLenum; var v: Double);
+  glMultiTexCoord1fEXT: procedure(target: GLenum; s: Single);
+  glMultiTexCoord1fvEXT: procedure(target: GLenum; var v: Single);
+  glMultiTexCoord1iEXT: procedure(target: GLenum; s: LongInt);
+  glMultiTexCoord1ivEXT: procedure(target: GLenum; var v: LongInt);
+  glMultiTexCoord1sEXT: procedure(target: GLenum; s: ShortInt);
+  glMultiTexCoord1svEXT: procedure(target: GLenum; var v: ShortInt);
+  glMultiTexCoord2dEXT: procedure(target: GLenum; s, t: Double);
+  glMultiTexCoord2dvEXT: procedure(target: GLenum; var v: Double);
+  glMultiTexCoord2fEXT: procedure(target: GLenum; s, t: Single);
+  glMultiTexCoord2fvEXT: procedure(target: GLenum; var v: Single);
+  glMultiTexCoord2iEXT: procedure(target: GLenum; s, t: LongInt);
+  glMultiTexCoord2ivEXT: procedure(target: GLenum; var v: LongInt);
+  glMultiTexCoord2sEXT: procedure(target: GLenum; s, t: ShortInt);
+  glMultiTexCoord2svEXT: procedure(target: GLenum; var v: ShortInt);
+  glMultiTexCoord3dEXT: procedure(target: GLenum; s, t, r: Double);
+  glMultiTexCoord3dvEXT: procedure(target: GLenum; var v: Double);
+  glMultiTexCoord3fEXT: procedure(target: GLenum; s, t, r: Single);
+  glMultiTexCoord3fvEXT: procedure(target: GLenum; var v: Single);
+  glMultiTexCoord3iEXT: procedure(target: GLenum; s, t, r: LongInt);
+  glMultiTexCoord3ivEXT: procedure(target: GLenum; var v: LongInt);
+  glMultiTexCoord3sEXT: procedure(target: GLenum; s, t, r: ShortInt);
+  glMultiTexCoord3svEXT: procedure(target: GLenum; var v: ShortInt);
+  glMultiTexCoord4dEXT: procedure(target: GLenum; s, t, r, q: Double);
+  glMultiTexCoord4dvEXT: procedure(target: GLenum; var v: Double);
+  glMultiTexCoord4fEXT: procedure(target: GLenum; s, t, r, q: Single);
+  glMultiTexCoord4fvEXT: procedure(target: GLenum; var v: Single);
+  glMultiTexCoord4iEXT: procedure(target: GLenum; s, t, r, q: LongInt);
+  glMultiTexCoord4ivEXT: procedure(target: GLenum; var v: LongInt);
+  glMultiTexCoord4sEXT: procedure(target: GLenum; s, t, r, q: ShortInt);
+  glMultiTexCoord4svEXT: procedure(target: GLenum; var v: ShortInt);
+  glInterleavedTextureCoordSetsEXT: procedure(factor: LongInt);
+  glSelectTextureEXT: procedure(target: GLenum);
+  glSelectTextureCoordSetEXT: procedure(target: GLenum);
+  glSelectTextureTransformEXT: procedure(target: GLenum);
+
+  // GL_EXT_point_parameters
+  glPointParameterfEXT: procedure(pname: GLenum; param: Single);
+  glPointParameterfvEXT: procedure(pname: GLenum; var params: Single);
+
+  // GL_MESA_window_pos
+  glWindowPos2iMESA: procedure(x, y: LongInt);
+  glWindowPos2sMESA: procedure(x, y: ShortInt);
+  glWindowPos2fMESA: procedure(x, y: Single);
+  glWindowPos2dMESA: procedure(x, y: Double);
+  glWindowPos2ivMESA: procedure(var p: LongInt);
+  glWindowPos2svMESA: procedure(var p: ShortInt);
+  glWindowPos2fvMESA: procedure(var p: Single);
+  glWindowPos2dvMESA: procedure(var p: Double);
+  glWindowPos3iMESA: procedure(x, y, z: LongInt);
+  glWindowPos3sMESA: procedure(x, y, z: ShortInt);
+  glWindowPos3fMESA: procedure(x, y, z: Single);
+  glWindowPos3dMESA: procedure(x, y, z: Double);
+  glWindowPos3ivMESA: procedure(var p: LongInt);
+  glWindowPos3svMESA: procedure(var p: ShortInt);
+  glWindowPos3fvMESA: procedure(var p: Single);
+  glWindowPos3dvMESA: procedure(var p: Double);
+  glWindowPos4iMESA: procedure(x, y, z, w: LongInt);
+  glWindowPos4sMESA: procedure(x, y, z, w: ShortInt);
+  glWindowPos4fMESA: procedure(x, y, z, w: Single);
+  glWindowPos4dMESA: procedure(x, y, z, w: Double);
+  glWindowPos4ivMESA: procedure(var p: LongInt);
+  glWindowPos4svMESA: procedure(var p: ShortInt);
+  glWindowPos4fvMESA: procedure(var p: Single);
+  glWindowPos4dvMESA: procedure(var p: Double);
+
+  // GL_MESA_resize_buffers
+  glResizeBuffersMESA: procedure;
+%END

packages/opengl/build2/glu.def

@@ -0,0 +1,196 @@
+# This is the definition file for all GLU stuff
+
+%COPY_INTERFACE
+const
+  GLU_TRUE                              = GL_TRUE;
+  GLU_FALSE                             = GL_FALSE;
+
+  // Normal vectors
+  GLU_SMOOTH                            = 100000;
+  GLU_FLAT                              = 100001;
+  GLU_NONE                              = 100002;
+
+  // Quadric draw styles
+  GLU_POINT                             = 100010;
+  GLU_LINE                              = 100011;
+  GLU_FILL                              = 100012;
+  GLU_SILHOUETTE                        = 100013;
+
+  // Quadric orientation
+  GLU_OUTSIDE                           = 100020;
+  GLU_INSIDE                            = 100021;
+
+  // Tesselator
+  GLU_BEGIN                             = 100100;
+  GLU_VERTEX                            = 100101;
+  GLU_END                               = 100102;
+  GLU_ERROR                             = 100103;
+  GLU_EDGE_FLAG                         = 100104;
+
+  // Contour types
+  GLU_CW                                = 100120;
+  GLU_CCW                               = 100121;
+  GLU_INTERIOR                          = 100122;
+  GLU_EXTERIOR                          = 100123;
+  GLU_UNKNOWN                           = 100124;
+
+  // Tesselation errors
+  GLU_TESS_ERROR1                       = 100151;  // missing gluEndPolygon
+  GLU_TESS_ERROR2                       = 100152;  // missing gluBeginPolygon
+  GLU_TESS_ERROR3                       = 100153;  // misoriented contour
+  GLU_TESS_ERROR4                       = 100154;  // vertex/edge intersection
+  GLU_TESS_ERROR5                       = 100155;  // misoriented or self-intersecting loops
+  GLU_TESS_ERROR6                       = 100156;  // coincident vertices
+  GLU_TESS_ERROR7                       = 100157;  // all vertices collinear
+  GLU_TESS_ERROR8                       = 100158;  // intersecting edges
+  GLU_TESS_ERROR9                       = 100159;  // not coplanar contours
+
+  // NURBS
+  GLU_AUTO_LOAD_MATRIX                  = 100200;
+  GLU_CULLING                           = 100201;
+  GLU_PARAMETRIC_TOLERANCE              = 100202;
+  GLU_SAMPLING_TOLERANCE                = 100203;
+  GLU_DISPLAY_MODE                      = 100204;
+  GLU_SAMPLING_METHOD                   = 100205;
+  GLU_U_STEP                            = 100206;
+  GLU_V_STEP                            = 100207;
+
+  GLU_PATH_LENGTH                       = 100215;
+  GLU_PARAMETRIC_ERROR                  = 100216;
+  GLU_DOMAIN_DISTANCE                   = 100217;
+
+  GLU_MAP1_TRIM_2                       = 100210;
+  GLU_MAP1_TRIM_3                       = 100211;
+
+  GLU_OUTLINE_POLYGON                   = 100240;
+  GLU_OUTLINE_PATCH                     = 100241;
+
+  GLU_NURBS_ERROR1                      = 100251;   // spline order un-supported
+  GLU_NURBS_ERROR2                      = 100252;   // too few knots
+  GLU_NURBS_ERROR3                      = 100253;   // valid knot range is empty
+  GLU_NURBS_ERROR4                      = 100254;   // decreasing knot sequence
+  GLU_NURBS_ERROR5                      = 100255;   // knot multiplicity > spline order
+  GLU_NURBS_ERROR6                      = 100256;   // endcurve() must follow bgncurve()
+  GLU_NURBS_ERROR7                      = 100257;   // bgncurve() must precede endcurve()
+  GLU_NURBS_ERROR8                      = 100258;   // ctrlarray or knot vector is NULL
+  GLU_NURBS_ERROR9                      = 100259;   // cannot draw pwlcurves
+  GLU_NURBS_ERROR10                     = 100260;   // missing gluNurbsCurve()
+  GLU_NURBS_ERROR11                     = 100261;   // missing gluNurbsSurface()
+  GLU_NURBS_ERROR12                     = 100262;   // endtrim() must precede endsurface()
+  GLU_NURBS_ERROR13                     = 100263;   // bgnsurface() must precede endsurface()
+  GLU_NURBS_ERROR14                     = 100264;   // curve of improper type passed as trim curve
+  GLU_NURBS_ERROR15                     = 100265;   // bgnsurface() must precede bgntrim()
+  GLU_NURBS_ERROR16                     = 100266;   // endtrim() must follow bgntrim()
+  GLU_NURBS_ERROR17                     = 100267;   // bgntrim() must precede endtrim()*/
+  GLU_NURBS_ERROR18                     = 100268;   // invalid or missing trim curve*/
+  GLU_NURBS_ERROR19                     = 100269;   // bgntrim() must precede pwlcurve()
+  GLU_NURBS_ERROR20                     = 100270;   // pwlcurve referenced twice*/
+  GLU_NURBS_ERROR21                     = 100271;   // pwlcurve and nurbscurve mixed
+  GLU_NURBS_ERROR22                     = 100272;   // improper usage of trim data type
+  GLU_NURBS_ERROR23                     = 100273;   // nurbscurve referenced twice
+  GLU_NURBS_ERROR24                     = 100274;   // nurbscurve and pwlcurve mixed
+  GLU_NURBS_ERROR25                     = 100275;   // nurbssurface referenced twice
+  GLU_NURBS_ERROR26                     = 100276;   // invalid property
+  GLU_NURBS_ERROR27                     = 100277;   // endsurface() must follow bgnsurface()
+  GLU_NURBS_ERROR28                     = 100278;   // intersecting or misoriented trim curves
+  GLU_NURBS_ERROR29                     = 100279;   // intersecting trim curves
+  GLU_NURBS_ERROR30                     = 100280;   // UNUSED
+  GLU_NURBS_ERROR31                     = 100281;   // unconnected trim curves
+  GLU_NURBS_ERROR32                     = 100282;   // unknown knot error
+  GLU_NURBS_ERROR33                     = 100283;   // negative vertex count encountered
+  GLU_NURBS_ERROR34                     = 100284;   // negative byte-stride
+  GLU_NURBS_ERROR35                     = 100285;   // unknown type descriptor
+  GLU_NURBS_ERROR36                     = 100286;   // null control point reference
+  GLU_NURBS_ERROR37                     = 100287;   // duplicate point on pwlcurve
+
+  // Errors
+  GLU_INVALID_ENUM                      = 100900;
+  GLU_INVALID_VALUE                     = 100901;
+  GLU_OUT_OF_MEMORY                     = 100902;
+  GLU_INCOMPATIBLE_GL_VERSION           = 100903;
+
+  // New in GLU 1.1
+  GLU_VERSION                           = 100800;
+  GLU_EXTENSIONS                        = 100801;
+
+type
+  PGLUquadricObj = ^TGLUquadricObj;
+  TGLUquadricObj = record end;
+  PGLUtriangulatorObj = ^TGLUtriangulatorObj;
+  TGLUtriangulatorObj = record end;
+  PGLUnurbsObj = ^TGLUnurbsObj;
+  TGLUnurbsObj = record end;
+
+  TGLUQuadricCallback = procedure; cdecl;
+  TGLUNurbsCallback = procedure; cdecl;
+  TGLUTessCallback = procedure; cdecl;
+
+  TGLUViewport = array[0..3] of LongInt;
+  TGLUMatrixd = array[0..15] of Double;
+  TGLUMatrixf = array[0..15] of Single;
+  TGLUVectord = array[0..2] of Double;
+%END
+
+
+#=====================================================================
+# Procedures and functions
+#=====================================================================
+
+%PROCS
+  // Miscellaneous functions
+  gluLookAt: procedure(eye, eyey, eyez, centerx, centery, centerz, upx, upy, upz: Double);
+  gluOrtho2D: procedure(left, right, bottom, top: Double);
+  gluPerspective: procedure(fovy, aspect, zNear, zFar: Double);
+  gluPickMatrix: procedure(x, y, width, height: Double; const viewport: TGLUViewport);
+  gluProject: procedure(objx, objy, objz: Double; const modelMatrix, projMatrix: TGLUMatrixd; const viewport: TGLUViewport; winx, winy, winz: Double);
+  gluUnProject: procedure(winx, winy, winz: Double; const modelMatrix, projMatrix: TGLUMatrixd; const viewport: TGLUViewport; objx, objy, objz: Double);
+  gluErrorString: procedure(errorCode: GLenum);
+
+  // Mipmapping and image scaling
+  gluScaleImage: procedure(format: GLenum; within, heightin: LongInt; typein: GLenum; var datain; widthout, heightout: LongInt; typeout: GLenum; var dataout);
+  gluBuild1DMipmaps: procedure(target: GLenum; components, width: LongInt; format, AType: GLEnum; var data);
+  gluBuild2DMipmaps: procedure(target: GLenum; components, width, height: LongInt; format, AType: GLEnum; var data);
+
+  // Quadrics
+  gluNewQuadric: function: PGLUquadricObj;
+  gluDeleteQuadric: procedure(state: PGLUquadricObj);
+  gluQuadricDrawStyle: procedure(quadObject: PGLUquadricObj; drawStyle: GLenum);
+  gluQuadricOrientation: procedure(quadObject: PGLUquadricObj; orientation: GLenum);
+  gluQuadricNormals: procedure(quadObject: PGLUquadricObj; normals: GLenum);
+  gluQuadricTexture: procedure(quadObject: PGLUquadricObj; textureCoords: Boolean);
+  gluQuadricCallback: procedure(quadObject: PGLUquadricObj; which: GLenum; fn: TGLUQuadricCallback);
+  gluCylinder: procedure(qobj: PGLUquadricObj; baseRadius, topRadius, height: Double; slices, stacks: LongInt);
+  gluSphere: procedure(qobj: PGLUquadricObj; radius: Double; slices, stacks: LongInt);
+  gluDisk: procedure(qobj: PGLUquadricObj; innerRadius, outerRadius: Double; slices, loops: LongInt);
+  gluPartialDisk: procedure(qobj: PGLUquadricObj; innerRadius, outerRadius: Double; slices, loops: LongInt; startAngle, sweepAngle: Double);
+
+  // Nurbs
+  gluNewNurbsRenderer: function: PGLUnurbsObj;
+  gluDeleteNurbsRenderer: procedure(nobj: PGLUnurbsObj);
+  gluLoadSamplingMatrices: procedure(nobj: PGLUnurbsObj; const modelMatrix, projMatrix: TGLUMatrixf; const viewport: TGLUViewport);
+  gluNurbsProperty: procedure(nobj: PGLUnurbsObj; AProperty: GLenum; value: Single);
+  gluGetNurbsProperty: procedure(nobj: PGLUnurbsObj; AProperty: GLEnum; var value: Single);
+  gluBeginCurve: procedure(nobj: PGLUnurbsObj);
+  gluEndCurve: procedure(nobj: PGLUnurbsObj);
+  gluNurbsCurve: procedure(nobj: PGLUnurbsObj; nknots: LongInt; var know: Single; stride: LongInt; var ctlarray: Single; order: LongInt; AType: GLenum);
+  gluBeginSurface: procedure(nobj: PGLUnurbsObj);
+  gluEndSurface: procedure(nobj: PGLUnurbsObj);
+  gluNurbsSurface: procedure(nobj: PGLUnurbsObj; sknot_count: LongInt; var sknot: Single; tknot_count: LongInt; var tknot: Single; s_stride, t_stride: LongInt; var ctlarray: Single; sorder, torder: LongInt; AType: GLenum);
+  gluBeginTrim: procedure(nobj: PGLUnurbsObj);
+  gluEndTrim: procedure(nobj: PGLUnurbsObj);
+  gluPwlCurve: procedure(nobj: PGLUnurbsObj; count: LongInt; var AArray: Single; stride: LongInt; AType: GLenum);
+  gluNurbsCallback: procedure(nobj: PGLUnurbsObj; which: GLenum; fn: TGLUNurbsCallback);
+
+  // Polygon tesselation
+  gluNewTess: function: PGLUtriangulatorObj;
+  gluTessCallback: procedure(tobj: PGLUtriangulatorObj; which: GLenum; fn: TGLUTessCallback);
+
+  gluDeleteTess: procedure(tobj: PGLUtriangulatorObj);
+  gluBeginPolygon: procedure(tobj: PGLUtriangulatorObj);
+  gluEndPolygon: procedure(tobj: PGLUtriangulatorObj);
+  gluNextContour: procedure(tobj: PGLUtriangulatorObj; AType: GLenum);
+  gluTessVertex: procedure(tobj: PGLUtriangulatorObj; v: TGLUVectord; var data);
+
+  // New functions in GLU 1.1
+  gluGetString: function(name: GLenum): PChar;
+%END

packages/opengl/build2/glut.def

@@ -0,0 +1,268 @@
+# This is the definition file for all GLUT stuff
+
+%COPY_INTERFACE
+const
+  // Display mode bit masks
+  GLUT_RGB                      = 0;
+  GLUT_RGBA                     = GLUT_RGB;
+  GLUT_INDEX                    = 1;
+  GLUT_SINGLE                   = 0;
+  GLUT_DOUBLE                   = 2;
+  GLUT_ACCUM                    = 4;
+  GLUT_ALPHA                    = 8;
+  GLUT_DEPTH                    = 16;
+  GLUT_STENCIL                  = 32;
+  GLUT_MULTISAMPLE              = 128;
+  GLUT_STEREO                   = 256;
+  GLUT_LUMINANCE                = 512;
+
+  // Mouse buttons
+  GLUT_LEFT_BUTTON              = 0;
+  GLUT_MIDDLE_BUTTON            = 1;
+  GLUT_RIGHT_BUTTON             = 2;
+
+  // Mouse button state
+  GLUT_DOWN                     = 0;
+  GLUT_UP                       = 1;
+
+  // Keys ###
+
+  // Enter / exit state
+  GLUT_LEFT                     = 0;
+  GLUT_ENTERED                  = 1;
+
+  // Menu usage state
+  GLUT_MENU_NOT_IN_USE          = 0;
+  GLUT_MENU_IN_USE              = 1;
+
+  // Visibility state
+  GLUT_NOT_VISIBLE              = 0;
+  GLUT_VISIBLE                  = 1;
+
+  // Window status state
+  GLUT_HIDDEN                   = 0;
+  GLUT_FULLY_RETAINED           = 1;
+  GLUT_PARTIALLY_RETAINED       = 2;
+  GLUT_FULLY_COVERED            = 3;
+
+  // Color index component selection values
+  GLUT_RED                      = 0;
+  GLUT_GREEN                    = 1;
+  GLUT_BLUE                     = 2;
+
+  // Layers for use
+  GLUT_NORMAL                   = 0;
+  GLUT_OVERLAY                  = 1;
+
+  // Bitmap stuff###
+
+
+  // glutGet parameters
+  GLUT_WINDOW_X                 = 100;
+  GLUT_WINDOW_Y                 = 101;
+  GLUT_WINDOW_WIDTH             = 102;
+  GLUT_WINDOW_HEIGHT            = 103;
+  GLUT_WINDOW_BUFFER_SIZE       = 104;
+  GLUT_WINDOW_STENCIL_SIZE      = 105;
+  GLUT_WINDOW_DEPTH_SIZE        = 106;
+  GLUT_WINDOW_RED_SIZE          = 107;
+  GLUT_WINDOW_GREEN_SIZE        = 108;
+  GLUT_WINDOW_BLUE_SIZE         = 109;
+  GLUT_WINDOW_ALPHA_SIZE        = 110;
+  GLUT_WINDOW_ACCUM_RED_SIZE    = 111;
+  GLUT_WINDOW_ACCUM_GREEN_SIZE  = 112;
+  GLUT_WINDOW_ACCUM_BLUE_SIZE   = 113;
+  GLUT_WINDOW_ACCUM_ALPHA_SIZE  = 114;
+  GLUT_WINDOW_DOUBLEBUFFER      = 115;
+  GLUT_WINDOW_RGBA              = 116;
+  GLUT_WINDOW_PARENT            = 117;
+  GLUT_WINDOW_NUM_CHILDREN      = 118;
+  GLUT_WINDOW_COLORMAP_SIZE     = 119;
+  GLUT_WINDOW_NUM_SAMPLES       = 120;
+  GLUT_WINDOW_STEREO            = 121;
+  GLUT_WINDOW_CURSOR            = 122;
+  GLUT_SCREEN_WIDTH             = 200;
+  GLUT_SCREEN_HEIGHT            = 201;
+  GLUT_SCREEN_WIDTH_MM          = 202;
+  GLUT_SCREEN_HEIGHT_MM         = 203;
+  GLUT_MENU_NUM_ITEMS           = 300;
+  GLUT_DISPLAY_MODE_POSSIBLE    = 400;
+  GLUT_INIT_WINDOW_X            = 500;
+  GLUT_INIT_WINDOW_Y            = 501;
+  GLUT_INIT_WINDOW_WIDTH        = 502;
+  GLUT_INIT_WINDOW_HEIGHT       = 503;
+  GLUT_INIT_DISPLAY_MODE        = 504;
+  GLUT_ELAPSED_TIME             = 700;
+  GLUT_WINDOW_FORMAT_ID         = 123;
+
+  // glutDeviceGet parameters
+  GLUT_HAS_KEYBOARD             = 600;
+  GLUT_HAS_MOUSE                = 601;
+  GLUT_HAS_SPACEBALL            = 602;
+  GLUT_HAS_DIAL_AND_BUTTON_BOX  = 603;
+  GLUT_HAS_TABLET               = 604;
+  GLUT_NUM_MOUSE_BUTTONS        = 605;
+  GLUT_NUM_SPACEBALL_BUTTONS    = 606;
+  GLUT_NUM_BUTTON_BOX_BUTTONS   = 607;
+  GLUT_NUM_DIALS                = 608;
+  GLUT_NUM_TABLET_BUTTONS       = 609;
+  GLUT_DEVICE_IGNORE_KEY_REPEAT = 610;
+  GLUT_DEVICE_KEY_REPEAT        = 611;
+  GLUT_HAS_JOYSTICK             = 612;
+  GLUT_OWNS_JOYSTICK            = 613;
+  GLUT_JOYSTICK_BUTTONS         = 614;
+  GLUT_JOYSTICK_AXES            = 615;
+  GLUT_JOYSTICK_POLL_RATE       = 616;
+
+  // glutLayerGet parameters
+  GLUT_OVERLAY_POSSIBLE         = 800;
+  GLUT_LAYER_IN_USE             = 801;
+  GLUT_HAS_OVERLAY              = 802;
+  GLUT_TRANSPARENT_INDEX        = 803;
+  GLUT_NORMAL_DAMAGED           = 804;
+  GLUT_OVERLAY_DAMAGED          = 805;
+
+  // glutVideoResizeGet parameters
+  GLUT_VIDEO_RESIZE_POSSIBLE    = 900;
+  GLUT_VIDEO_RESIZE_IN_USE      = 901;
+  GLUT_VIDEO_RESIZE_X_DELTA     = 902;
+  GLUT_VIDEO_RESIZE_Y_DELTA     = 903;
+  GLUT_VIDEO_RESIZE_WIDTH_DELTA = 904;
+  GLUT_VIDEO_RESIZE_HEIGHT_DELTA= 905;
+  GLUT_VIDEO_RESIZE_X           = 906;
+  GLUT_VIDEO_RESIZE_Y           = 907;
+  GLUT_VIDEO_RESIZE_WIDTH       = 908;
+  GLUT_VIDEO_RESIZE_HEIGHT      = 909;
+
+  // glutGetModifiers return mask
+  GLUT_ACTIVE_SHIFT             = 1;
+  GLUT_ACTIVE_CTRL              = 2;
+  GLUT_ACTIVE_ALT               = 4;
+
+  // Cursor stuff ###
+
+// GLUT window callback sub-API
+type
+  TGlutDisplayFunc = procedure; extdecl
+  TGlutReshapeFunc = procedure(width, height: Integer); extdecl
+
+  TGlutTimerFunc = procedure(value: Integer); extdecl
+
+// GLUT game mode sub-API
+{$ifdef GLUT_GAME}
+// glutGameModeGet
+const
+  GLUT_GAME_MODE_ACTIVE         = 0;
+  GLUT_GAME_MODE_POSSIBLE       = 1;
+  GLUT_GAME_MODE_WIDTH          = 2;
+  GLUT_GAME_MODE_HEIGHT         = 3;
+  GLUT_GAME_MODE_PIXEL_DEPTH    = 4;
+  GLUT_GAME_MODE_REFRESH_RATE   = 5;
+  GLUT_GAME_MODE_DISPLAY_CHANGED= 6;
+{$endif GLUT_GAME}
+%END
+
+
+#=====================================================================
+# Procedures and functions
+#=====================================================================
+
+%PROCS
+// GLUT initialization sub-API
+  glutInit: procedure(var argcp: Integer; var argv: PChar);
+  glutInitDisplayMode: procedure(mode: LongWord);
+  glutInitDisplayString: procedure(AString: PChar);
+  glutInitWindowPosition: procedure(x, y: Integer);
+  glutInitWindowSize: procedure(width, height: Integer);
+  glutMainLoop: procedure;
+
+// GLUT window sub-API
+  glutCreateWindow: function(title: PChar): Integer;
+  glutCreateSubWindow: function(win, x, y, width, height: Integer): Integer;
+  glutDestroyWindow: procedure(win: Integer);
+  glutPostRedisplay: procedure;
+  glutPostWindowRedisplay: procedure(win: Integer);
+  glutSwapBuffers: procedure;
+  glutGetWindow: function: Integer;
+  glutSetWindow: procedure(win: Integer);
+  glutSetWindowTitle: procedure(title: PChar);
+  glutSetIconTitle: procedure(title: PChar);
+  glutPositionWindow: procedure(x, y: Integer);
+  glutReshapeWindow: procedure(width, height: Integer);
+  glutPopWindow: procedure;
+  glutPushWindow: procedure;
+  glutIconifyWindow: procedure;
+  glutShowWindow: procedure;
+  glutHideWindow: procedure;
+  glutFullScreen: procedure;
+  glutSetCursor: procedure(cursor: Integer);
+  glutWarpPointer: procedure(x, y: Integer);
+
+//overlays ###
+
+//menus ###
+
+// GLUT window callback sub-API
+  glutDisplayFunc: procedure(func: TGlutDisplayFunc);
+  glutReshapeFunc: procedure(func: TGlutReshapeFunc);
+
+  glutTimerFunc: procedure(millis: LongWord; func: TGlutTimerFunc; value: Integer);
+
+
+// GLUTAPI void APIENTRY glutDisplayFunc(void (GLUTCALLBACK * func)(void));
+// GLUTAPI void APIENTRY glutReshapeFunc(void (GLUTCALLBACK * func)(int width, int height));
+// GLUTAPI void APIENTRY glutKeyboardFunc(void (GLUTCALLBACK * func)(unsigned char key, int x, int y));
+// GLUTAPI void APIENTRY glutMouseFunc(void (GLUTCALLBACK * func)(int button, int state, int x, int y));
+// GLUTAPI void APIENTRY glutMotionFunc(void (GLUTCALLBACK * func)(int x, int y));
+// GLUTAPI void APIENTRY glutPassiveMotionFunc(void (GLUTCALLBACK * func)(int x, int y));
+// GLUTAPI void APIENTRY glutEntryFunc(void (GLUTCALLBACK * func)(int state));
+// GLUTAPI void APIENTRY glutVisibilityFunc(void (GLUTCALLBACK * func)(int state));
+// GLUTAPI void APIENTRY glutIdleFunc(void (GLUTCALLBACK * func)(void));
+// GLUTAPI void APIENTRY glutTimerFunc(unsigned int millis, void (GLUTCALLBACK * func)(int value), int value);
+// GLUTAPI void APIENTRY glutMenuStateFunc(void (GLUTCALLBACK * func)(int state));
+// GLUTAPI void APIENTRY glutSpecialFunc(void (GLUTCALLBACK * func)(int key, int x, int y));
+// GLUTAPI void APIENTRY glutSpaceballMotionFunc(void (GLUTCALLBACK * func)(int x, int y, int z));
+// GLUTAPI void APIENTRY glutSpaceballRotateFunc(void (GLUTCALLBACK * func)(int x, int y, int z));
+// GLUTAPI void APIENTRY glutSpaceballButtonFunc(void (GLUTCALLBACK * func)(int button, int state));
+// GLUTAPI void APIENTRY glutButtonBoxFunc(void (GLUTCALLBACK * func)(int button, int state));
+// GLUTAPI void APIENTRY glutDialsFunc(void (GLUTCALLBACK * func)(int dial, int value));
+// GLUTAPI void APIENTRY glutTabletMotionFunc(void (GLUTCALLBACK * func)(int x, int y));
+// GLUTAPI void APIENTRY glutTabletButtonFunc(void (GLUTCALLBACK * func)(int button, int state, int x, int y));
+// GLUTAPI void APIENTRY glutMenuStatusFunc(void (GLUTCALLBACK * func)(int status, int x, int y));
+// GLUTAPI void APIENTRY glutOverlayDisplayFunc(void (GLUTCALLBACK * func)(void));
+// GLUTAPI void APIENTRY glutWindowStatusFunc(void (GLUTCALLBACK * func)(int state));
+// GLUTAPI void APIENTRY glutKeyboardUpFunc(void (GLUTCALLBACK * func)(unsigned char key, int x, int y));
+// GLUTAPI void APIENTRY glutSpecialUpFunc(void (GLUTCALLBACK * func)(int key, int x, int y));
+// GLUTAPI void APIENTRY glutJoystickFunc(void (GLUTCALLBACK * func)(unsigned int buttonMask, int x, int y, int z), int pollInterval)
+
+// GLUT color index sub-API
+  glutSetColor: procedure(index: Integer; red, green, blue: Single);
+  glutGetColor: function(ndx, component: Integer): Single;
+  glutCopyColormap: procedure(win: Integer);
+
+// GLUT state retrieval sub-API
+  glutGet: function(AType: GLEnum): Integer;
+  glutDeviceGet: function(AType: GLEnum): Integer;
+  glutExtensionSupported: function(name: PChar): Integer;
+  glutGetModifiers: function: Integer;
+  glutLayerGet: function(AType: GLEnum): Integer;
+
+// fonts ###
+
+// pre-built models ###
+
+// video resize ###
+
+// debugging ###
+
+// device control ###
+
+
+// GLUT game mode sub-API
+{$ifdef GLUT_GAME}
+  glutGameModeString: procedure(AString: PChar);
+  glutEnterGameMode: function: Integer;
+  glutLeaveGameMode: procedure;
+  glutGameModeGet: function(mode: GLEnum): Integer;
+{$endif GLUT_GAME}
+%END

packages/opengl/build2/glx.def

@@ -0,0 +1,108 @@
+# This is the definition file for all GLX stuff
+
+%COPY_INTERFACE
+// Tokens for glXChooseVisual and glXGetConfig:
+const
+  GLX_USE_GL                            = 1;
+  GLX_BUFFER_SIZE                       = 2;
+  GLX_LEVEL                             = 3;
+  GLX_RGBA                              = 4;
+  GLX_DOUBLEBUFFER                      = 5;
+  GLX_STEREO                            = 6;
+  GLX_AUX_BUFFERS                       = 7;
+  GLX_RED_SIZE                          = 8;
+  GLX_GREEN_SIZE                        = 9;
+  GLX_BLUE_SIZE                         = 10;
+  GLX_ALPHA_SIZE                        = 11;
+  GLX_DEPTH_SIZE                        = 12;
+  GLX_STENCIL_SIZE                      = 13;
+  GLX_ACCUM_RED_SIZE                    = 14;
+  GLX_ACCUM_GREEN_SIZE                  = 15;
+  GLX_ACCUM_BLUE_SIZE                   = 16;
+  GLX_ACCUM_ALPHA_SIZE                  = 17;
+
+  // GLX_EXT_visual_info extension
+  GLX_X_VISUAL_TYPE_EXT                 = $22;
+  GLX_TRANSPARENT_TYPE_EXT              = $23;
+  GLX_TRANSPARENT_INDEX_VALUE_EXT       = $24;
+  GLX_TRANSPARENT_RED_VALUE_EXT         = $25;
+  GLX_TRANSPARENT_GREEN_VALUE_EXT       = $26;
+  GLX_TRANSPARENT_BLUE_VALUE_EXT        = $27;
+  GLX_TRANSPARENT_ALPHA_VALUE_EXT       = $28;
+
+
+  // Error codes returned by glXGetConfig:
+  GLX_BAD_SCREEN                        = 1;
+  GLX_BAD_ATTRIBUTE                     = 2;
+  GLX_NO_EXTENSION                      = 3;
+  GLX_BAD_VISUAL                        = 4;
+  GLX_BAD_CONTEXT                       = 5;
+  GLX_BAD_VALUE                         = 6;
+  GLX_BAD_ENUM                          = 7;
+
+  // GLX 1.1 and later:
+  GLX_VENDOR                            = 1;
+  GLX_VERSION                           = 2;
+  GLX_EXTENSIONS                        = 3;
+
+  // GLX_visual_info extension
+  GLX_TRUE_COLOR_EXT                    = $8002;
+  GLX_DIRECT_COLOR_EXT                  = $8003;
+  GLX_PSEUDO_COLOR_EXT                  = $8004;
+  GLX_STATIC_COLOR_EXT                  = $8005;
+  GLX_GRAY_SCALE_EXT                    = $8006;
+  GLX_STATIC_GRAY_EXT                   = $8007;
+  GLX_NONE_EXT                          = $8000;
+  GLX_TRANSPARENT_RGB_EXT               = $8008;
+  GLX_TRANSPARENT_INDEX_EXT             = $8009;
+
+type
+  // From XLib:
+  XPixmap = TXID;
+  XFont = TXID;
+  XColormap = TXID;
+
+  GLXContext = Pointer;
+  GLXPixmap = TXID;
+  GLXDrawable = TXID;
+  GLXContextID = TXID;
+
+var
+%END
+
+
+#=====================================================================
+# Procedures and functions
+#=====================================================================
+
+%PROCS
+  glXChooseVisual: function(dpy: PDisplay; screen: Integer; var attribList: Integer): PXVisualInfo; cdecl;
+  glXCreateContext: function(dpy: PDisplay; vis: PXVisualInfo; shareList: GLXContext; direct: Boolean): GLXContext; cdecl;
+  glXDestroyContext: procedure(dpy: PDisplay; ctx: GLXContext); cdecl;
+  glXMakeCurrent: function(dpy: PDisplay; drawable: GLXDrawable; ctx: GLXContext): Boolean; cdecl;
+  glXCopyContext: procedure(dpy: PDisplay; src, dst: GLXContext; mask: LongWord); cdecl;
+  glXSwapBuffers: procedure(dpy: PDisplay; drawable: GLXDrawable); cdecl;
+  glXCreateGLXPixmap: function(dpy: PDisplay; visual: PXVisualInfo; pixmap: XPixmap): GLXPixmap; cdecl;
+  glXDestroyGLXPixmap: procedure(dpy: PDisplay; pixmap: GLXPixmap); cdecl;
+  glXQueryExtension: function(dpy: PDisplay; var errorb, event: Integer): Boolean; cdecl;
+  glXQueryVersion: function(dpy: PDisplay; var maj, min: Integer): Boolean; cdecl;
+  glXIsDirect: function(dpy: PDisplay; ctx: GLXContext): Boolean; cdecl;
+  glXGetConfig: function(dpy: PDisplay; visual: PXVisualInfo; attrib: Integer; var value: Integer): Integer; cdecl;
+  glXGetCurrentContext: function: GLXContext; cdecl;
+  glXGetCurrentDrawable: function: GLXDrawable; cdecl;
+  glXWaitGL: procedure; cdecl;
+  glXWaitX: procedure; cdecl;
+  glXUseXFont: procedure(font: XFont; first, count, list: Integer); cdecl;
+
+  // GLX 1.1 and later
+  glXQueryExtensionsString: function(dpy: PDisplay; screen: Integer): PChar; cdecl;
+  glXQueryServerString: function(dpy: PDisplay; screen, name: Integer): PChar; cdecl;
+  glXGetClientString: function(dpy: PDisplay; name: Integer): PChar; cdecl;
+
+  // Mesa GLX Extensions
+  glXCreateGLXPixmapMESA: function(dpy: PDisplay; visual: PXVisualInfo; pixmap: XPixmap; cmap: XColormap): GLXPixmap; cdecl;
+  glXReleaseBufferMESA: function(dpy: PDisplay; d: GLXDrawable): Boolean; cdecl;
+  glXCopySubBufferMESA: procedure(dpy: PDisplay; drawbale: GLXDrawable; x, y, width, height: Integer); cdecl;
+  glXGetVideoSyncSGI: function(var counter: LongWord): Integer; cdecl;
+  glXWaitVideoSyncSGI: function(divisor, remainder: Integer; var count: LongWord): Integer; cdecl;
+%END