paweld/fpc
1
0
Fork 0
mirror of https://gitlab.com/freepascal.org/fpc/source.git synced 2025-04-09 19:08:15 +02:00
Code Issues Packages Projects Releases Wiki Activity

universal definition files, still not merged win and linux

Browse Source 
but pretty close
This commit is contained in:
alex 2000-05-31 00:39:54 +00:00
parent 51a3c70ada
commit 8c995ce56e
12 changed files with 3266 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1037
packages/opengl/build2/gl.def Normal file
View File

File diff suppressed because it is too large Load Diff

866
packages/opengl/build2/gl10.def Normal file
View File

@ -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

176
packages/opengl/build2/gl10ext.def Normal file
View File

@ -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

40
packages/opengl/build2/gl10mesa.def Normal file
View File

@ -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

109
packages/opengl/build2/gl10sgi.def Normal file
View File

@ -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

96
packages/opengl/build2/gl11.def Normal file
View File

@ -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

58
packages/opengl/build2/gl12.def Normal file
View File

@ -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

12
packages/opengl/build2/glaux.def Normal file
View File

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

300
packages/opengl/build2/glext.def Normal file
View File

@ -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

196
packages/opengl/build2/glu.def Normal file
View File

@ -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

268
packages/opengl/build2/glut.def Normal file
View File

@ -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

108
packages/opengl/build2/glx.def Normal file
View File

@ -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