ScummVM API documentation
•All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Modules Pages
gl.h
1 /* ScummVM - Graphic Adventure Engine
2  *
3  * ScummVM is the legal property of its developers, whose names
4  * are too numerous to list here. Please refer to the COPYRIGHT
5  * file distributed with this source distribution.
6  *
7  * This program is free software: you can redistribute it and/or modify
8  * it under the terms of the GNU General Public License as published by
9  * the Free Software Foundation, either version 3 of the License, or
10  * (at your option) any later version.
11  *
12  * This program is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15  * GNU General Public License for more details.
16  *
17  * You should have received a copy of the GNU General Public License
18  * along with this program. If not, see <http://www.gnu.org/licenses/>.
19  *
20  */
21 
22 /*
23  * This file is based on, or a modified version of code from TinyGL (C) 1997-2022 Fabrice Bellard,
24  * which is licensed under the MIT license (see LICENSE).
25  * It also has modifications by the ResidualVM-team, which are covered under the GPLv2 (or later).
26  */
27 
28 // The following constants come from Mesa
29 
30 #ifndef GRAPHICS_TGL_H
31 #define GRAPHICS_TGL_H
32 
33 #define TGL_VERSION_1_1 1
34 #define TGL_VERSION_1_2 1
35 
36 enum {
37  // --- GL 1.0 ---
38 
39  // Data types
40  TGL_BYTE = 0x1400,
41  TGL_UNSIGNED_BYTE = 0x1401,
42  TGL_SHORT = 0x1402,
43  TGL_UNSIGNED_SHORT = 0x1403,
44  TGL_INT = 0x1404,
45  TGL_UNSIGNED_INT = 0x1405,
46  TGL_FLOAT = 0x1406,
47  TGL_2_BYTES = 0x1407,
48  TGL_3_BYTES = 0x1408,
49  TGL_4_BYTES = 0x1409,
50 
51  // Primitives
52  TGL_LINES = 0x0001,
53  TGL_POINTS = 0x0000,
54  TGL_LINE_STRIP = 0x0003,
55  TGL_LINE_LOOP = 0x0002,
56  TGL_TRIANGLES = 0x0004,
57  TGL_TRIANGLE_STRIP = 0x0005,
58  TGL_TRIANGLE_FAN = 0x0006,
59  TGL_QUADS = 0x0007,
60  TGL_QUAD_STRIP = 0x0008,
61  TGL_POLYGON = 0x0009,
62  TGL_EDGE_FLAG = 0x0B43,
63 
64  // Matrix Mode
65  TGL_MATRIX_MODE = 0x0BA0,
66  TGL_MODELVIEW = 0x1700,
67  TGL_PROJECTION = 0x1701,
68  TGL_TEXTURE = 0x1702,
69 
70  // Points
71  TGL_POINT_SMOOTH = 0x0B10,
72  TGL_POINT_SIZE = 0x0B11,
73  TGL_POINT_SIZE_GRANULARITY = 0x0B13,
74  TGL_POINT_SIZE_RANGE = 0x0B12,
75 
76  // Lines
77  TGL_LINE_SMOOTH = 0x0B20,
78  TGL_LINE_STIPPLE = 0x0B24,
79  TGL_LINE_STIPPLE_PATTERN = 0x0B25,
80  TGL_LINE_STIPPLE_REPEAT = 0x0B26,
81  TGL_LINE_WIDTH = 0x0B21,
82  TGL_LINE_WIDTH_GRANULARITY = 0x0B23,
83  TGL_LINE_WIDTH_RANGE = 0x0B22,
84 
85  // Polygons
86  TGL_POINT = 0x1B00,
87  TGL_LINE = 0x1B01,
88  TGL_FILL = 0x1B02,
89  TGL_CCW = 0x0901,
90  TGL_CW = 0x0900,
91  TGL_FRONT = 0x0404,
92  TGL_BACK = 0x0405,
93  TGL_CULL_FACE = 0x0B44,
94  TGL_CULL_FACE_MODE = 0x0B45,
95  TGL_POLYGON_SMOOTH = 0x0B41,
96  TGL_POLYGON_STIPPLE = 0x0B42,
97  TGL_FRONT_FACE = 0x0B46,
98  TGL_POLYGON_MODE = 0x0B40,
99 
100  // Display Lists
101  TGL_COMPILE = 0x1300,
102  TGL_COMPILE_AND_EXECUTE = 0x1301,
103  TGL_LIST_BASE = 0x0B32,
104  TGL_LIST_INDEX = 0x0B33,
105  TGL_LIST_MODE = 0x0B30,
106 
107  // Depth buffer
108  TGL_NEVER = 0x0200,
109  TGL_LESS = 0x0201,
110  TGL_GEQUAL = 0x0206,
111  TGL_LEQUAL = 0x0203,
112  TGL_GREATER = 0x0204,
113  TGL_NOTEQUAL = 0x0205,
114  TGL_EQUAL = 0x0202,
115  TGL_ALWAYS = 0x0207,
116  TGL_DEPTH_TEST = 0x0B71,
117  TGL_DEPTH_BITS = 0x0D56,
118  TGL_DEPTH_CLEAR_VALUE = 0x0B73,
119  TGL_DEPTH_FUNC = 0x0B74,
120  TGL_DEPTH_RANGE = 0x0B70,
121  TGL_DEPTH_WRITEMASK = 0x0B72,
122  TGL_DEPTH_COMPONENT = 0x1902,
123 
124  // Lighting
125  TGL_LIGHTING = 0x0B50,
126  TGL_LIGHT0 = 0x4000,
127  TGL_LIGHT1 = 0x4001,
128  TGL_LIGHT2 = 0x4002,
129  TGL_LIGHT3 = 0x4003,
130  TGL_LIGHT4 = 0x4004,
131  TGL_LIGHT5 = 0x4005,
132  TGL_LIGHT6 = 0x4006,
133  TGL_LIGHT7 = 0x4007,
134  TGL_SPOT_EXPONENT = 0x1205,
135  TGL_SPOT_CUTOFF = 0x1206,
136  TGL_CONSTANT_ATTENUATION = 0x1207,
137  TGL_LINEAR_ATTENUATION = 0x1208,
138  TGL_QUADRATIC_ATTENUATION = 0x1209,
139  TGL_AMBIENT = 0x1200,
140  TGL_DIFFUSE = 0x1201,
141  TGL_SPECULAR = 0x1202,
142  TGL_SHININESS = 0x1601,
143  TGL_EMISSION = 0x1600,
144  TGL_POSITION = 0x1203,
145  TGL_SPOT_DIRECTION = 0x1204,
146  TGL_AMBIENT_AND_DIFFUSE = 0x1602,
147  TGL_COLOR_INDEXES = 0x1603,
148  TGL_LIGHT_MODEL_TWO_SIDE = 0x0B52,
149  TGL_LIGHT_MODEL_LOCAL_VIEWER = 0x0B51,
150  TGL_LIGHT_MODEL_AMBIENT = 0x0B53,
151  TGL_FRONT_AND_BACK = 0x0408,
152  TGL_SHADE_MODEL = 0x0B54,
153  TGL_FLAT = 0x1D00,
154  TGL_SMOOTH = 0x1D01,
155  TGL_COLOR_MATERIAL = 0x0B57,
156  TGL_COLOR_MATERIAL_FACE = 0x0B55,
157  TGL_COLOR_MATERIAL_PARAMETER = 0x0B56,
158  TGL_NORMALIZE = 0x0BA1,
159 
160  // User clipping planes
161  TGL_CLIP_PLANE0 = 0x3000,
162  TGL_CLIP_PLANE1 = 0x3001,
163  TGL_CLIP_PLANE2 = 0x3002,
164  TGL_CLIP_PLANE3 = 0x3003,
165  TGL_CLIP_PLANE4 = 0x3004,
166  TGL_CLIP_PLANE5 = 0x3005,
167 
168  // Accumulation buffer
169  TGL_ACCUM_RED_BITS = 0x0D58,
170  TGL_ACCUM_GREEN_BITS = 0x0D59,
171  TGL_ACCUM_BLUE_BITS = 0x0D5A,
172  TGL_ACCUM_ALPHA_BITS = 0x0D5B,
173  TGL_ACCUM_CLEAR_VALUE = 0x0B80,
174  TGL_ACCUM = 0x0100,
175  TGL_ADD = 0x0104,
176  TGL_LOAD = 0x0101,
177  TGL_MULT = 0x0103,
178  TGL_RETURN = 0x0102,
179 
180  // Alpha testing
181  TGL_ALPHA_TEST = 0x0BC0,
182  TGL_ALPHA_TEST_REF = 0x0BC2,
183  TGL_ALPHA_TEST_FUNC = 0x0BC1,
184 
185  // Blending
186  TGL_BLEND = 0x0BE2,
187  TGL_BLEND_SRC = 0x0BE1,
188  TGL_BLEND_DST = 0x0BE0,
189  //TGL_ZERO = 0,
190  //TGL_ONE = 1,
191  TGL_SRC_COLOR = 0x0300,
192  TGL_ONE_MINUS_SRC_COLOR = 0x0301,
193  TGL_DST_COLOR = 0x0306,
194  TGL_ONE_MINUS_DST_COLOR = 0x0307,
195  TGL_SRC_ALPHA = 0x0302,
196  TGL_ONE_MINUS_SRC_ALPHA = 0x0303,
197  TGL_DST_ALPHA = 0x0304,
198  TGL_ONE_MINUS_DST_ALPHA = 0x0305,
199  TGL_SRC_ALPHA_SATURATE = 0x0308,
200 
201  // Render Mode
202  TGL_FEEDBACK = 0x1C01,
203  TGL_RENDER = 0x1C00,
204  TGL_SELECT = 0x1C02,
205 
206  // Feedback
207  TGL_2D = 0x0600,
208  TGL_3D = 0x0601,
209  TGL_3D_COLOR = 0x0602,
210  TGL_3D_COLOR_TEXTURE = 0x0603,
211  TGL_4D_COLOR_TEXTURE = 0x0604,
212  TGL_POINT_TOKEN = 0x0701,
213  TGL_LINE_TOKEN = 0x0702,
214  TGL_LINE_RESET_TOKEN = 0x0707,
215  TGL_POLYGON_TOKEN = 0x0703,
216  TGL_BITMAP_TOKEN = 0x0704,
217  TGL_DRAW_PIXEL_TOKEN = 0x0705,
218  TGL_COPY_PIXEL_TOKEN = 0x0706,
219  TGL_PASS_THROUGH_TOKEN = 0x0700,
220 
221  // Fog
222  TGL_FOG = 0x0B60,
223  TGL_FOG_MODE = 0x0B65,
224  TGL_FOG_DENSITY = 0x0B62,
225  TGL_FOG_COLOR = 0x0B66,
226  TGL_FOG_INDEX = 0x0B61,
227  TGL_FOG_START = 0x0B63,
228  TGL_FOG_END = 0x0B64,
229  TGL_LINEAR = 0x2601,
230  TGL_EXP = 0x0800,
231  TGL_EXP2 = 0x0801,
232 
233  // Logic Ops
234  TGL_LOGIC_OP = 0x0BF1,
235  TGL_LOGIC_OP_MODE = 0x0BF0,
236  TGL_CLEAR = 0x1500,
237  TGL_SET = 0x150F,
238  TGL_COPY = 0x1503,
239  TGL_COPY_INVERTED = 0x150C,
240  TGL_NOOP = 0x1505,
241  TGL_INVERT = 0x150A,
242  TGL_AND = 0x1501,
243  TGL_NAND = 0x150E,
244  TGL_OR = 0x1507,
245  TGL_NOR = 0x1508,
246  TGL_XOR = 0x1506,
247  TGL_EQUIV = 0x1509,
248  TGL_AND_REVERSE = 0x1502,
249  TGL_AND_INVERTED = 0x1504,
250  TGL_OR_REVERSE = 0x150B,
251  TGL_OR_INVERTED = 0x150D,
252 
253  // Stencil
254  TGL_STENCIL_TEST = 0x0B90,
255  TGL_STENCIL_WRITEMASK = 0x0B98,
256  TGL_STENCIL_BITS = 0x0D57,
257  TGL_STENCIL_FUNC = 0x0B92,
258  TGL_STENCIL_VALUE_MASK = 0x0B93,
259  TGL_STENCIL_REF = 0x0B97,
260  TGL_STENCIL_FAIL = 0x0B94,
261  TGL_STENCIL_PASS_DEPTH_PASS = 0x0B96,
262  TGL_STENCIL_PASS_DEPTH_FAIL = 0x0B95,
263  TGL_STENCIL_CLEAR_VALUE = 0x0B91,
264  TGL_STENCIL_INDEX = 0x1901,
265  TGL_KEEP = 0x1E00,
266  TGL_REPLACE = 0x1E01,
267  TGL_INCR = 0x1E02,
268  TGL_DECR = 0x1E03,
269 
270  // Buffers, Pixel Drawing / Reading
271  //TGL_NONE = 0,
272  TGL_LEFT = 0x0406,
273  TGL_RIGHT = 0x0407,
274  //TGL_FRONT = 0x0404,
275  //TGL_BACK = 0x0405,
276  //TGL_FRONT_AND_BACK = 0x0408,
277  TGL_FRONT_LEFT = 0x0400,
278  TGL_FRONT_RIGHT = 0x0401,
279  TGL_BACK_LEFT = 0x0402,
280  TGL_BACK_RIGHT = 0x0403,
281  TGL_AUX0 = 0x0409,
282  TGL_AUX1 = 0x040A,
283  TGL_AUX2 = 0x040B,
284  TGL_AUX3 = 0x040C,
285  TGL_COLOR_INDEX = 0x1900,
286  TGL_RED = 0x1903,
287  TGL_GREEN = 0x1904,
288  TGL_BLUE = 0x1905,
289  TGL_ALPHA = 0x1906,
290  TGL_LUMINANCE = 0x1909,
291  TGL_LUMINANCE_ALPHA = 0x190A,
292  TGL_ALPHA_BITS = 0x0D55,
293  TGL_RED_BITS = 0x0D52,
294  TGL_GREEN_BITS = 0x0D53,
295  TGL_BLUE_BITS = 0x0D54,
296  TGL_INDEX_BITS = 0x0D51,
297  TGL_SUBPIXEL_BITS = 0x0D50,
298  TGL_AUX_BUFFERS = 0x0C00,
299  TGL_READ_BUFFER = 0x0C02,
300  TGL_DRAW_BUFFER = 0x0C01,
301  TGL_DOUBLEBUFFER = 0x0C32,
302  TGL_STEREO = 0x0C33,
303  TGL_BITMAP = 0x1A00,
304  TGL_COLOR = 0x1800,
305  TGL_DEPTH = 0x1801,
306  TGL_STENCIL = 0x1802,
307  TGL_DITHER = 0x0BD0,
308  TGL_RGB = 0x1907,
309  TGL_RGBA = 0x1908,
310 
311  // Implementation limits
312  TGL_MAX_LIST_NESTING = 0x0B31,
313  TGL_MAX_ATTRIB_STACK_DEPTH = 0x0D35,
314  TGL_MAX_MODELVIEW_STACK_DEPTH = 0x0D36,
315  TGL_MAX_NAME_STACK_DEPTH = 0x0D37,
316  TGL_MAX_PROJECTION_STACK_DEPTH = 0x0D38,
317  TGL_MAX_TEXTURE_STACK_DEPTH = 0x0D39,
318  TGL_MAX_EVAL_ORDER = 0x0D30,
319  TGL_MAX_LIGHTS = 0x0D31,
320  TGL_MAX_CLIP_PLANES = 0x0D32,
321  TGL_MAX_TEXTURE_SIZE = 0x0D33,
322  TGL_MAX_PIXEL_MAP_TABLE = 0x0D34,
323  TGL_MAX_VIEWPORT_DIMS = 0x0D3A,
324 
325  // Gets
326  TGL_ATTRIB_STACK_DEPTH = 0x0BB0,
327  TGL_COLOR_CLEAR_VALUE = 0x0C22,
328  TGL_COLOR_WRITEMASK = 0x0C23,
329  TGL_CURRENT_INDEX = 0x0B01,
330  TGL_CURRENT_COLOR = 0x0B00,
331  TGL_CURRENT_NORMAL = 0x0B02,
332  TGL_CURRENT_RASTER_COLOR = 0x0B04,
333  TGL_CURRENT_RASTER_DISTANCE = 0x0B09,
334  TGL_CURRENT_RASTER_INDEX = 0x0B05,
335  TGL_CURRENT_RASTER_POSITION = 0x0B07,
336  TGL_CURRENT_RASTER_TEXTURE_COORDS = 0x0B06,
337  TGL_CURRENT_RASTER_POSITION_VALID = 0x0B08,
338  TGL_CURRENT_TEXTURE_COORDS = 0x0B03,
339  TGL_INDEX_CLEAR_VALUE = 0x0C20,
340  TGL_INDEX_MODE = 0x0C30,
341  TGL_INDEX_WRITEMASK = 0x0C21,
342  TGL_MODELVIEW_MATRIX = 0x0BA6,
343  TGL_MODELVIEW_STACK_DEPTH = 0x0BA3,
344  TGL_NAME_STACK_DEPTH = 0x0D70,
345  TGL_PROJECTION_MATRIX = 0x0BA7,
346  TGL_PROJECTION_STACK_DEPTH = 0x0BA4,
347  TGL_RENDER_MODE = 0x0C40,
348  TGL_RGBA_MODE = 0x0C31,
349  TGL_TEXTURE_MATRIX = 0x0BA8,
350  TGL_TEXTURE_STACK_DEPTH = 0x0BA5,
351  TGL_VIEWPORT = 0x0BA2,
352 
353  // Evaluators
354  TGL_AUTO_NORMAL = 0x0D80,
355  TGL_MAP1_COLOR_4 = 0x0D90,
356  TGL_MAP1_GRID_DOMAIN = 0x0DD0,
357  TGL_MAP1_GRID_SEGMENTS = 0x0DD1,
358  TGL_MAP1_INDEX = 0x0D91,
359  TGL_MAP1_NORMAL = 0x0D92,
360  TGL_MAP1_TEXTURE_COORD_1 = 0x0D93,
361  TGL_MAP1_TEXTURE_COORD_2 = 0x0D94,
362  TGL_MAP1_TEXTURE_COORD_3 = 0x0D95,
363  TGL_MAP1_TEXTURE_COORD_4 = 0x0D96,
364  TGL_MAP1_VERTEX_3 = 0x0D97,
365  TGL_MAP1_VERTEX_4 = 0x0D98,
366  TGL_MAP2_COLOR_4 = 0x0DB0,
367  TGL_MAP2_GRID_DOMAIN = 0x0DD2,
368  TGL_MAP2_GRID_SEGMENTS = 0x0DD3,
369  TGL_MAP2_INDEX = 0x0DB1,
370  TGL_MAP2_NORMAL = 0x0DB2,
371  TGL_MAP2_TEXTURE_COORD_1 = 0x0DB3,
372  TGL_MAP2_TEXTURE_COORD_2 = 0x0DB4,
373  TGL_MAP2_TEXTURE_COORD_3 = 0x0DB5,
374  TGL_MAP2_TEXTURE_COORD_4 = 0x0DB6,
375  TGL_MAP2_VERTEX_3 = 0x0DB7,
376  TGL_MAP2_VERTEX_4 = 0x0DB8,
377  TGL_COEFF = 0x0A00,
378  TGL_DOMAIN = 0x0A02,
379  TGL_ORDER = 0x0A01,
380 
381  // Hints
382  TGL_FOG_HINT = 0x0C54,
383  TGL_LINE_SMOOTH_HINT = 0x0C52,
384  TGL_PERSPECTIVE_CORRECTION_HINT = 0x0C50,
385  TGL_POINT_SMOOTH_HINT = 0x0C51,
386  TGL_POLYGON_SMOOTH_HINT = 0x0C53,
387  TGL_DONT_CARE = 0x1100,
388  TGL_FASTEST = 0x1101,
389  TGL_NICEST = 0x1102,
390 
391  // Scissor box
392  TGL_SCISSOR_TEST = 0x0C11,
393  TGL_SCISSOR_BOX = 0x0C10,
394 
395  // Pixel Mode / Transfer
396  TGL_MAP_COLOR = 0x0D10,
397  TGL_MAP_STENCIL = 0x0D11,
398  TGL_INDEX_SHIFT = 0x0D12,
399  TGL_INDEX_OFFSET = 0x0D13,
400  TGL_RED_SCALE = 0x0D14,
401  TGL_RED_BIAS = 0x0D15,
402  TGL_GREEN_SCALE = 0x0D18,
403  TGL_GREEN_BIAS = 0x0D19,
404  TGL_BLUE_SCALE = 0x0D1A,
405  TGL_BLUE_BIAS = 0x0D1B,
406  TGL_ALPHA_SCALE = 0x0D1C,
407  TGL_ALPHA_BIAS = 0x0D1D,
408  TGL_DEPTH_SCALE = 0x0D1E,
409  TGL_DEPTH_BIAS = 0x0D1F,
410  TGL_PIXEL_MAP_S_TO_S_SIZE = 0x0CB1,
411  TGL_PIXEL_MAP_I_TO_I_SIZE = 0x0CB0,
412  TGL_PIXEL_MAP_I_TO_R_SIZE = 0x0CB2,
413  TGL_PIXEL_MAP_I_TO_G_SIZE = 0x0CB3,
414  TGL_PIXEL_MAP_I_TO_B_SIZE = 0x0CB4,
415  TGL_PIXEL_MAP_I_TO_A_SIZE = 0x0CB5,
416  TGL_PIXEL_MAP_R_TO_R_SIZE = 0x0CB6,
417  TGL_PIXEL_MAP_G_TO_G_SIZE = 0x0CB7,
418  TGL_PIXEL_MAP_B_TO_B_SIZE = 0x0CB8,
419  TGL_PIXEL_MAP_A_TO_A_SIZE = 0x0CB9,
420  TGL_PIXEL_MAP_S_TO_S = 0x0C71,
421  TGL_PIXEL_MAP_I_TO_I = 0x0C70,
422  TGL_PIXEL_MAP_I_TO_R = 0x0C72,
423  TGL_PIXEL_MAP_I_TO_G = 0x0C73,
424  TGL_PIXEL_MAP_I_TO_B = 0x0C74,
425  TGL_PIXEL_MAP_I_TO_A = 0x0C75,
426  TGL_PIXEL_MAP_R_TO_R = 0x0C76,
427  TGL_PIXEL_MAP_G_TO_G = 0x0C77,
428  TGL_PIXEL_MAP_B_TO_B = 0x0C78,
429  TGL_PIXEL_MAP_A_TO_A = 0x0C79,
430  TGL_PACK_ALIGNMENT = 0x0D05,
431  TGL_PACK_LSB_FIRST = 0x0D01,
432  TGL_PACK_ROW_LENGTH = 0x0D02,
433  TGL_PACK_SKIP_PIXELS = 0x0D04,
434  TGL_PACK_SKIP_ROWS = 0x0D03,
435  TGL_PACK_SWAP_BYTES = 0x0D00,
436  TGL_UNPACK_ALIGNMENT = 0x0CF5,
437  TGL_UNPACK_LSB_FIRST = 0x0CF1,
438  TGL_UNPACK_ROW_LENGTH = 0x0CF2,
439  TGL_UNPACK_SKIP_PIXELS = 0x0CF4,
440  TGL_UNPACK_SKIP_ROWS = 0x0CF3,
441  TGL_UNPACK_SWAP_BYTES = 0x0CF0,
442  TGL_ZOOM_X = 0x0D16,
443  TGL_ZOOM_Y = 0x0D17,
444 
445  // Texture mapping
446  TGL_TEXTURE_ENV = 0x2300,
447  TGL_TEXTURE_ENV_MODE = 0x2200,
448  TGL_TEXTURE_1D = 0x0DE0,
449  TGL_TEXTURE_2D = 0x0DE1,
450  TGL_TEXTURE_WRAP_S = 0x2802,
451  TGL_TEXTURE_WRAP_T = 0x2803,
452  TGL_TEXTURE_MAG_FILTER = 0x2800,
453  TGL_TEXTURE_MIN_FILTER = 0x2801,
454  TGL_TEXTURE_ENV_COLOR = 0x2201,
455  TGL_TEXTURE_GEN_S = 0x0C60,
456  TGL_TEXTURE_GEN_T = 0x0C61,
457  TGL_TEXTURE_GEN_MODE = 0x2500,
458  TGL_TEXTURE_BORDER_COLOR = 0x1004,
459  TGL_TEXTURE_WIDTH = 0x1000,
460  TGL_TEXTURE_HEIGHT = 0x1001,
461  TGL_TEXTURE_BORDER = 0x1005,
462  TGL_TEXTURE_COMPONENTS = 0x1003,
463  TGL_NEAREST_MIPMAP_NEAREST = 0x2700,
464  TGL_NEAREST_MIPMAP_LINEAR = 0x2702,
465  TGL_LINEAR_MIPMAP_NEAREST = 0x2701,
466  TGL_LINEAR_MIPMAP_LINEAR = 0x2703,
467  TGL_OBJECT_LINEAR = 0x2401,
468  TGL_OBJECT_PLANE = 0x2501,
469  TGL_EYE_LINEAR = 0x2400,
470  TGL_EYE_PLANE = 0x2502,
471  TGL_SPHERE_MAP = 0x2402,
472  TGL_DECAL = 0x2101,
473  TGL_MODULATE = 0x2100,
474  TGL_NEAREST = 0x2600,
475  TGL_REPEAT = 0x2901,
476  TGL_CLAMP = 0x2900,
477  TGL_S = 0x2000,
478  TGL_T = 0x2001,
479  TGL_R = 0x2002,
480  TGL_Q = 0x2003,
481  TGL_TEXTURE_GEN_R = 0x0C62,
482  TGL_TEXTURE_GEN_Q = 0x0C63,
483 
484  // Utility
485  TGL_VENDOR = 0x1F00,
486  TGL_RENDERER = 0x1F01,
487  TGL_VERSION = 0x1F02,
488  TGL_EXTENSIONS = 0x1F03,
489 
490 
491  // --- GL 1.1 ---
492 
493  // Gets
494  TGL_CLIENT_ATTRIB_STACK_DEPTH = 0x0BB1,
495  TGL_INDEX_LOGIC_OP = 0x0BF1,
496  TGL_COLOR_LOGIC_OP = 0x0BF2,
497 
498  // Texture mapping
499  TGL_PROXY_TEXTURE_1D = 0x8063,
500  TGL_PROXY_TEXTURE_2D = 0x8064,
501  TGL_TEXTURE_PRIORITY = 0x8066,
502  TGL_TEXTURE_RESIDENT = 0x8067,
503  TGL_TEXTURE_BINDING_1D = 0x8068,
504  TGL_TEXTURE_BINDING_2D = 0x8069,
505  TGL_TEXTURE_INTERNAL_FORMAT = 0x1003,
506  TGL_TEXTURE_RED_SIZE = 0x805C,
507  TGL_TEXTURE_GREEN_SIZE = 0x805D,
508  TGL_TEXTURE_BLUE_SIZE = 0x805E,
509  TGL_TEXTURE_ALPHA_SIZE = 0x805F,
510  TGL_TEXTURE_LUMINANCE_SIZE = 0x8060,
511  TGL_TEXTURE_INTENSITY_SIZE = 0x8061,
512 
513  // Data types
514  TGL_DOUBLE = 0x140A,
515 
516  // Polygons
517  TGL_POLYGON_OFFSET_FACTOR = 0x3038,
518  TGL_POLYGON_OFFSET_UNITS = 0x2A00,
519  TGL_POLYGON_OFFSET_POINT = 0x2A01,
520  TGL_POLYGON_OFFSET_LINE = 0x2A02,
521  TGL_POLYGON_OFFSET_FILL = 0x8037,
522 
523  // Vertex Arrays
524  TGL_VERTEX_ARRAY = 0x8074,
525  TGL_NORMAL_ARRAY = 0x8075,
526  TGL_COLOR_ARRAY = 0x8076,
527  TGL_INDEX_ARRAY = 0x8077,
528  TGL_TEXTURE_COORD_ARRAY = 0x8078,
529  TGL_EDGE_FLAG_ARRAY = 0x8079,
530  TGL_VERTEX_ARRAY_SIZE = 0x807A,
531  TGL_VERTEX_ARRAY_TYPE = 0x807B,
532  TGL_VERTEX_ARRAY_STRIDE = 0x807C,
533  TGL_NORMAL_ARRAY_TYPE = 0x807E,
534  TGL_NORMAL_ARRAY_STRIDE = 0x807F,
535  TGL_COLOR_ARRAY_SIZE = 0x8081,
536  TGL_COLOR_ARRAY_TYPE = 0x8082,
537  TGL_COLOR_ARRAY_STRIDE = 0x8083,
538  TGL_INDEX_ARRAY_TYPE = 0x8085,
539  TGL_INDEX_ARRAY_STRIDE = 0x8086,
540  TGL_TEXTURE_COORD_ARRAY_SIZE = 0x8088,
541  TGL_TEXTURE_COORD_ARRAY_TYPE = 0x8089,
542  TGL_TEXTURE_COORD_ARRAY_STRIDE = 0x808A,
543  TGL_EDGE_FLAG_ARRAY_STRIDE = 0x808C,
544  TGL_VERTEX_ARRAY_POINTER = 0x808E,
545  TGL_NORMAL_ARRAY_POINTER = 0x808F,
546  TGL_COLOR_ARRAY_POINTER = 0x8090,
547  TGL_INDEX_ARRAY_POINTER = 0x8091,
548  TGL_TEXTURE_COORD_ARRAY_POINTER = 0x8092,
549  TGL_EDGE_FLAG_ARRAY_POINTER = 0x8093,
550  TGL_FEEDBACK_BUFFER_POINTER = 0x0DF0,
551  TGL_FEEDBACK_BUFFER_SIZE = 0x0DF1,
552  TGL_FEEDBACK_BUFFER_TYPE = 0x0DF2,
553  TGL_SELECTION_BUFFER_POINTER = 0x0DF3,
554  TGL_SELECTION_BUFFER_SIZE = 0x0DF4,
555  TGL_V2F = 0x2A20,
556  TGL_V3F = 0x2A21,
557  TGL_C4UB_V2F = 0x2A22,
558  TGL_C4UB_V3F = 0x2A23,
559  TGL_C3F_V3F = 0x2A24,
560  TGL_N3F_V3F = 0x2A25,
561  TGL_C4F_N3F_V3F = 0x2A26,
562  TGL_T2F_V3F = 0x2A27,
563  TGL_T4F_V4F = 0x2A28,
564  TGL_T2F_C4UB_V3F = 0x2A29,
565  TGL_T2F_C3F_V3F = 0x2A2A,
566  TGL_T2F_N3F_V3F = 0x2A2B,
567  TGL_T2F_C4F_N3F_V3F = 0x2A2C,
568  TGL_T4F_C4F_N3F_V4F = 0x2A2D,
569 
570  // Internal texture formats
571  TGL_ALPHA4 = 0x803B,
572  TGL_ALPHA8 = 0x803C,
573  TGL_ALPHA12 = 0x803D,
574  TGL_ALPHA16 = 0x803E,
575  TGL_LUMINANCE4 = 0x803F,
576  TGL_LUMINANCE8 = 0x8040,
577  TGL_LUMINANCE12 = 0x8041,
578  TGL_LUMINANCE16 = 0x8042,
579  TGL_LUMINANCE4_ALPHA4 = 0x8043,
580  TGL_LUMINANCE6_ALPHA2 = 0x8044,
581  TGL_LUMINANCE8_ALPHA8 = 0x8045,
582  TGL_LUMINANCE12_ALPHA4 = 0x8046,
583  TGL_LUMINANCE12_ALPHA12 = 0x8047,
584  TGL_LUMINANCE16_ALPHA16 = 0x8048,
585  TGL_INTENSITY = 0x8049,
586  TGL_INTENSITY4 = 0x804A,
587  TGL_INTENSITY8 = 0x804B,
588  TGL_INTENSITY12 = 0x804C,
589  TGL_INTENSITY16 = 0x804D,
590  TGL_R3_G3_B2 = 0x2A10,
591  TGL_RGB4 = 0x804F,
592  TGL_RGB5 = 0x8050,
593  TGL_RGB8 = 0x8051,
594  TGL_RGB10 = 0x8052,
595  TGL_RGB12 = 0x8053,
596  TGL_RGB16 = 0x8054,
597  TGL_RGBA2 = 0x8055,
598  TGL_RGBA4 = 0x8056,
599  TGL_RGB5_A1 = 0x8057,
600  TGL_RGBA8 = 0x8058,
601  TGL_RGB10_A2 = 0x8059,
602  TGL_RGBA12 = 0x805A,
603  TGL_RGBA16 = 0x805B,
604 
605  // Implementation limits
606  TGL_MAX_CLIENT_ATTRIB_STACK_DEPTH = 0x0D3B,
607 
608 
609  // --- GL 1.2 ---
610 
611  // Texture mapping
612  TGL_TEXTURE_BINDING_3D = 0x806A,
613  TGL_TEXTURE_3D = 0x806F,
614  TGL_PROXY_TEXTURE_3D = 0x8070,
615  TGL_TEXTURE_DEPTH = 0x8071,
616  TGL_TEXTURE_WRAP_R = 0x8072,
617  TGL_CLAMP_TO_EDGE = 0x812F,
618  TGL_TEXTURE_MIN_LOD = 0x813A,
619  TGL_TEXTURE_MAX_LOD = 0x813B,
620  TGL_TEXTURE_BASE_LEVEL = 0x813C,
621  TGL_TEXTURE_MAX_LEVEL = 0x813D,
622 
623  // Pixel Mode / Transfer
624  TGL_PACK_SKIP_IMAGES = 0x806B,
625  TGL_PACK_IMAGE_HEIGHT = 0x806C,
626  TGL_UNPACK_SKIP_IMAGES = 0x806D,
627  TGL_UNPACK_IMAGE_HEIGHT = 0x806E,
628 
629  // Implementation limits
630  TGL_MAX_3D_TEXTURE_SIZE = 0x8073,
631  TGL_MAX_ELEMENTS_VERTICES = 0x80E8,
632  TGL_MAX_ELEMENTS_INDICES = 0x80E9,
633 
634  // Internal texture formats
635  TGL_UNSIGNED_BYTE_3_3_2 = 0x8032,
636  TGL_UNSIGNED_BYTE_2_3_3_REV = 0x8362,
637  TGL_UNSIGNED_INT_10_10_10_2 = 0x8036,
638  TGL_UNSIGNED_INT_2_10_10_10_REV = 0x8368,
639  TGL_UNSIGNED_SHORT_5_6_5 = 0x8363,
640  TGL_UNSIGNED_SHORT_5_6_5_REV = 0x8364,
641  TGL_UNSIGNED_INT_8_8_8_8 = 0x8035,
642  TGL_UNSIGNED_INT_8_8_8_8_REV = 0x8367,
643  TGL_UNSIGNED_SHORT_5_5_5_1 = 0x8034,
644  TGL_UNSIGNED_SHORT_1_5_5_5_REV = 0x8366,
645  TGL_UNSIGNED_SHORT_4_4_4_4 = 0x8033,
646  TGL_UNSIGNED_SHORT_4_4_4_4_REV = 0x8365,
647  TGL_BGR = 0x80E0,
648  TGL_BGRA = 0x80E1,
649 
650  // Gets
651  TGL_SMOOTH_POINT_SIZE_RANGE = 0x0B12,
652  TGL_SMOOTH_POINT_SIZE_GRANULARITY = 0x0B13,
653  TGL_SMOOTH_LINE_WIDTH_RANGE = 0x0B22,
654  TGL_SMOOTH_LINE_WIDTH_GRANULARITY = 0x0B23,
655  TGL_ALIASED_LINE_WIDTH_RANGE = 0x846E,
656  TGL_RESCALE_NORMAL = 0x803A,
657  TGL_LIGHT_MODEL_COLOR_CONTROL = 0x81F8,
658  TGL_SINGLE_COLOR = 0x81F9,
659  TGL_SEPARATE_SPECULAR_COLOR = 0x81FA,
660  TGL_ALIASED_POINT_SIZE_RANGE = 0x846D,
661 
662 
663  // --- GL 1.4 --- selected
664 
665  // Texture mapping
666  TGL_MIRRORED_REPEAT = 0x8370,
667 
668  // Stencil
669  TGL_INCR_WRAP = 0x8507,
670  TGL_DECR_WRAP = 0x8508,
671 };
672 
673 enum {
674  // Errors
675  TGL_NO_ERROR = 0,
676  TGL_INVALID_VALUE = 0x0501,
677  TGL_INVALID_ENUM = 0x0500,
678  TGL_INVALID_OPERATION = 0x0502,
679  TGL_STACK_OVERFLOW = 0x0503,
680  TGL_STACK_UNDERFLOW = 0x0504,
681  TGL_OUT_OF_MEMORY = 0x0505,
682 };
683 
684 enum {
685  // Attrib Mask
686  TGL_CURRENT_BIT = 0x00000001,
687  TGL_POINT_BIT = 0x00000002,
688  TGL_LINE_BIT = 0x00000004,
689  TGL_POLYGON_BIT = 0x00000008,
690  TGL_POLYGON_STIPPLE_BIT = 0x00000010,
691  TGL_PIXEL_MODE_BIT = 0x00000020,
692  TGL_LIGHTING_BIT = 0x00000040,
693  TGL_FOG_BIT = 0x00000080,
694  TGL_DEPTH_BUFFER_BIT = 0x00000100,
695  TGL_ACCUM_BUFFER_BIT = 0x00000200,
696  TGL_STENCIL_BUFFER_BIT = 0x00000400,
697  TGL_VIEWPORT_BIT = 0x00000800,
698  TGL_TRANSFORM_BIT = 0x00001000,
699  TGL_ENABLE_BIT = 0x00002000,
700  TGL_COLOR_BUFFER_BIT = 0x00004000,
701  TGL_HINT_BIT = 0x00008000,
702  TGL_EVAL_BIT = 0x00010000,
703  TGL_LIST_BIT = 0x00020000,
704  TGL_TEXTURE_BIT = 0x00040000,
705  TGL_SCISSOR_BIT = 0x00080000,
706  TGL_ALL_ATTRIB_BITS = 0x000fffff
707 };
708 
709 enum : unsigned int {
710  // Client Attrib Mask
711  TGL_CLIENT_PIXEL_STORE_BIT = 1,
712  TGL_CLIENT_VERTEX_ARRAY_BIT = 2,
713  TGL_CLIENT_ALL_ATTRIB_BITS = 0xFFFFFFFF,
714 };
715 
716 enum {
717  // Special numbers
718  TGL_FALSE = 0,
719  TGL_TRUE = 1,
720  TGL_NONE = 0,
721  TGL_ZERO = 0,
722  TGL_ONE = 1,
723 };
724 
725 // basic types
726 
727 typedef int TGLenum;
728 typedef void TGLvoid;
729 typedef unsigned char TGLboolean;
730 typedef signed char TGLbyte; // 1-byte signed
731 typedef short TGLshort; // 2-byte signed
732 typedef int TGLint; // 4-byte signed
733 typedef unsigned char TGLubyte; // 1-byte unsigned
734 typedef unsigned short TGLushort; // 2-byte unsigned
735 typedef unsigned int TGLuint; // 4-byte unsigned
736 typedef float TGLfloat; // single precision float
737 typedef double TGLdouble; // double precision float
738 typedef int TGLsizei;
739 typedef unsigned int TGLbitfield;
740 typedef float TGLclampf;
741 typedef double TGLclampd;
742 
743 // functions
744 
745 void tglEnable(TGLenum code);
746 void tglDisable(TGLenum code);
747 TGLboolean tglIsEnabled(TGLenum cap);
748 
749 void tglShadeModel(TGLenum mode);
750 void tglCullFace(TGLenum mode);
751 void tglPolygonMode(TGLenum face, TGLenum mode);
752 
753 void tglLineStipple(TGLint factor, TGLushort pattern);
754 void tglPolygonStipple(const TGLubyte *mask);
755 void tglGetPolygonStipple(TGLubyte *mask);
756 
757 void tglLineWidth(TGLfloat width);
758 void tglPointSize(TGLfloat size);
759 
760 void tglEdgeFlag(TGLboolean flag);
761 void tglEdgeFlagv(const TGLboolean *flag);
762 
763 void tglBegin(TGLenum type);
764 void tglEnd();
765 
766 // rects
767 void tglRects(TGLshort x1, TGLshort y1, TGLshort x2, TGLshort y2);
768 void tglRecti(TGLint x1, TGLint y1, TGLint x2, TGLint y2);
769 void tglRectf(TGLfloat x1, TGLfloat y1, TGLfloat x2, TGLfloat y2);
770 void tglRectd(TGLdouble x1, TGLdouble y1, TGLdouble x2, TGLdouble y2);
771 void tglRectsv(const TGLshort *v1, const TGLshort *v2);
772 void tglRectiv(const TGLint *v1, const TGLint *v2);
773 void tglRectfv(const TGLfloat *v1, const TGLfloat *v2);
774 void tglRectdv(const TGLdouble *v1, const TGLdouble *v2);
775 
776 // vertexs
777 void tglVertex2s(TGLshort x, TGLshort y);
778 void tglVertex2i(TGLint x, TGLint y);
779 void tglVertex2f(TGLfloat x, TGLfloat y);
780 void tglVertex2d(TGLdouble x, TGLdouble y);
781 void tglVertex2sv(const TGLshort *v);
782 void tglVertex2iv(const TGLint *v);
783 void tglVertex2fv(const TGLfloat *v);
784 void tglVertex2dv(const TGLdouble *v);
785 void tglVertex3s(TGLshort x, TGLshort y, TGLshort z);
786 void tglVertex3i(TGLint x, TGLint y, TGLint z);
787 void tglVertex3f(TGLfloat x, TGLfloat y, TGLfloat z);
788 void tglVertex3d(TGLdouble x, TGLdouble y, TGLdouble z);
789 void tglVertex3sv(const TGLshort *v);
790 void tglVertex3dv(const TGLint *v);
791 void tglVertex3fv(const TGLfloat *v);
792 void tglVertex3dv(const TGLdouble *v);
793 void tglVertex4s(TGLshort x, TGLshort y, TGLshort z, TGLshort w);
794 void tglVertex4i(TGLint x, TGLint y, TGLint z, TGLint w);
795 void tglVertex4f(TGLfloat x, TGLfloat y, TGLfloat z, TGLfloat w);
796 void tglVertex4d(TGLdouble x, TGLdouble y, TGLdouble z, TGLdouble w);
797 void tglVertex4sv(const TGLshort *v);
798 void tglVertex4iv(const TGLint *v);
799 void tglVertex4fv(const TGLfloat *v);
800 void tglVertex4dv(const TGLdouble *v);
801 
802 // normals
803 void tglNormal3s(TGLshort nx, TGLshort ny, TGLshort nz);
804 void tglNormal3i(TGLint nx, TGLint ny, TGLint nz);
805 void tglNormal3f(TGLfloat nx, TGLfloat ny, TGLfloat nz);
806 void tglNormal3d(TGLdouble nx, TGLdouble ny, TGLdouble nz);
807 void tglNormal3sv(const TGLshort *v);
808 void tglNormal3dv(const TGLint *v);
809 void tglNormal3fv(const TGLfloat *v);
810 void tglNormal3dv(const TGLdouble *v);
811 
812 // colors
813 void tglColor3s(TGLshort red, TGLshort green, TGLshort blue);
814 void tglColor3i(TGLint red, TGLint green, TGLint blue);
815 void tglColor3f(TGLfloat red, TGLfloat green, TGLfloat blue);
816 void tglColor3d(TGLdouble red, TGLdouble green, TGLdouble blue);
817 void tglColor3sv(const TGLshort *v);
818 void tglColor3dv(const TGLint *v);
819 void tglColor3fv(const TGLfloat *v);
820 void tglColor3dv(const TGLdouble *v);
821 void tglColor3b(TGLbyte red, TGLbyte green, TGLbyte blue);
822 void tglColor3ub(TGLubyte red, TGLubyte green, TGLubyte blue);
823 void tglColor3us(TGLushort red, TGLushort green, TGLushort blue);
824 void tglColor3ui(TGLuint red, TGLuint green, TGLuint blue);
825 void tglColor3bv(const TGLbyte *v);
826 void tglColor3ubv(const TGLubyte *v);
827 void tglColor3usv(const TGLushort *v);
828 void tglColor3uiv(const TGLuint *v);
829 void tglColor4s(TGLshort red, TGLshort green, TGLshort blue, TGLshort alpha);
830 void tglColor4i(TGLint red, TGLint green, TGLint b, TGLint alpha);
831 void tglColor4f(TGLfloat red, TGLfloat green, TGLfloat blue, TGLfloat alpha);
832 void tglColor4d(TGLdouble red, TGLdouble green, TGLdouble blue, TGLdouble alpha);
833 void tglColor4sv(const TGLshort *v);
834 void tglColor4iv(const TGLint *v);
835 void tglColor4fv(const TGLfloat *v);
836 void tglColor4dv(const TGLdouble *v);
837 void tglColor4b(TGLbyte red, TGLbyte green, TGLbyte blue, TGLbyte alpha);
838 void tglColor4ub(TGLubyte red, TGLubyte green, TGLubyte blue, TGLubyte alpha);
839 void tglColor4us(TGLushort red, TGLushort green, TGLushort blue, TGLushort alpha);
840 void tglColor4ui(TGLuint red, TGLuint green, TGLuint blue, TGLuint alpha);
841 void tglColor4bv(const TGLbyte *v);
842 void tglColor4ubv(const TGLubyte *v);
843 void tglColor4usv(const TGLushort *v);
844 void tglColor4uiv(const TGLuint *v);
845 void tglIndexs(TGLshort c);
846 void tglIndexi(TGLint c);
847 void tglIndexf(TGLfloat c);
848 void tglIndexd(TGLdouble c);
849 void tglIndexsv(const TGLshort *c);
850 void tglIndexiv(const TGLint *c);
851 void tglIndexfv(const TGLfloat *c);
852 void tglIndexdv(const TGLdouble *c);
853 
854 // matrix
855 void tglMatrixMode(TGLenum mode);
856 void tglLoadMatrixf(const TGLfloat *m);
857 void tglLoadMatrixd(const TGLdouble *m);
858 void tglLoadIdentity();
859 void tglMultMatrixf(const TGLfloat *m);
860 void tglMultMatrixd(const TGLdouble *m);
861 void tglPushMatrix();
862 void tglPopMatrix();
863 void tglRotatef(TGLfloat angle, TGLfloat x, TGLfloat y, TGLfloat z);
864 void tglRotated(TGLdouble angle, TGLdouble x, TGLdouble y, TGLdouble z);
865 void tglTranslatef(TGLfloat x, TGLfloat y, TGLfloat z);
866 void tglTranslated(TGLdouble x, TGLdouble y, TGLdouble z);
867 void tglScalef(TGLfloat x, TGLfloat y, TGLfloat z);
868 void tglScaled(TGLdouble x, TGLdouble y, TGLdouble z);
869 void tglViewport(TGLint x, TGLint y, TGLsizei width, TGLsizei height);
870 void tglFrustum(TGLdouble left, TGLdouble right, TGLdouble bottom, TGLdouble top,
871  TGLdouble nearv, TGLdouble farv);
872 void tglOrtho(TGLdouble left, TGLdouble right, TGLdouble bottom, TGLdouble top,
873  TGLdouble zNear, TGLdouble zFar);
874 
875 // lists
876 TGLuint tglGenLists(TGLsizei range);
877 TGLboolean tglIsList(TGLuint list);
878 void tglNewList(TGLuint list, TGLenum mode);
879 void tglEndList();
880 void tglCallList(TGLuint list);
881 void tglCallLists(TGLsizei n, TGLenum type, const TGLvoid *lists);
882 void tglDeleteLists(TGLuint list, TGLsizei range);
883 void tglListBase(TGLuint base);
884 
885 // clear
886 void tglClear(TGLbitfield mask);
887 void tglClearColor(TGLfloat red, TGLfloat green, TGLfloat blue, TGLfloat alpha);
888 void tglClearDepth(TGLdouble depth);
889 void tglClearStencil(TGLint s);
890 void tglClearAccum(TGLfloat red, TGLfloat green, TGLfloat blue, TGLfloat alpha);
891 void tglClearIndex(TGLfloat c);
892 
893 // buffer
894 void tglPixelStorei(TGLenum pname, TGLint param);
895 void tglPixelStoref(TGLenum pname, TGLfloat param);
896 void tglPixelZoom(TGLfloat xfactor, TGLfloat yfactor);
897 void tglPixelTransferf(TGLenum pname, TGLfloat param);
898 void tglPixelTransferi(TGLenum pname, TGLint param);
899 void tglPixelMapfv(TGLenum map, TGLsizei mapsize, const TGLfloat *values);
900 void tglPixelMapuiv(TGLenum map, TGLsizei mapsize, const TGLuint *values);
901 void tglPixelMapusv(TGLenum map, TGLsizei mapsize, const TGLushort *values);
902 void tglCopyPixels(TGLint x, TGLint y, TGLsizei width, TGLsizei height, TGLenum type);
903 void tglDrawPixels(TGLsizei width, TGLsizei height, TGLenum format, TGLenum type, const TGLvoid *pixels);
904 void tglGetPixelMapfv(TGLenum map, TGLfloat *values);
905 void tglGetPixelMapuiv(TGLenum map, TGLuint *values);
906 void tglGetPixelMapusv(TGLenum map, TGLushort *values);
907 void tglDrawBuffer(TGLenum mode);
908 void tglReadBuffer(TGLenum mode);
909 void tglReadPixels(TGLint x, TGLint y, TGLsizei width, TGLsizei height,
910  TGLenum format, TGLenum type, TGLvoid *pixels);
911 void tglRasterPos2s(TGLshort x, TGLshort y);
912 void tglRasterPos2i(TGLint x, TGLint y);
913 void tglRasterPos2f(TGLfloat x, TGLfloat y);
914 void tglRasterPos2d(TGLdouble x, TGLdouble y);
915 void tglRasterPos2sv(const TGLshort *v);
916 void tglRasterPos2iv(const TGLint *v);
917 void tglRasterPos2fv(const TGLfloat *v);
918 void tglRasterPos2dv(const TGLdouble *v);
919 void tglRasterPos3s(TGLshort x, TGLshort y, TGLshort z);
920 void tglRasterPos3i(TGLint x, TGLint y, TGLint z);
921 void tglRasterPos3f(TGLfloat x, TGLfloat y, TGLfloat z);
922 void tglRasterPos3d(TGLdouble x, TGLdouble y, TGLdouble z);
923 void tglRasterPos3sv(const TGLshort *v);
924 void tglRasterPos3dv(const TGLint *v);
925 void tglRasterPos3fv(const TGLfloat *v);
926 void tglRasterPos3dv(const TGLdouble *v);
927 void tglRasterPos4s(TGLshort x, TGLshort y, TGLshort z, TGLshort w);
928 void tglRasterPos4i(TGLint x, TGLint y, TGLint z, TGLint w);
929 void tglRasterPos4f(TGLfloat x, TGLfloat y, TGLfloat z, TGLfloat w);
930 void tglRasterPos4d(TGLdouble x, TGLdouble y, TGLdouble z, TGLdouble w);
931 void tglRasterPos4sv(const TGLshort *v);
932 void tglRasterPos4iv(const TGLint *v);
933 void tglRasterPos4fv(const TGLfloat *v);
934 void tglRasterPos4dv(const TGLdouble *v);
935 
936 // stencil buffer
937 void tglStencilFunc(TGLenum func, TGLint ref, TGLuint mask);
938 void tglStencilOp(TGLenum sfail, TGLenum dpfail, TGLenum dppass);
939 void tglStencilMask(TGLuint mask);
940 
941 // accum buffer
942 void tglAccum(TGLenum op, TGLfloat value);
943 
944 // selection
945 int tglRenderMode(TGLenum mode);
946 void tglSelectBuffer(TGLsizei size, TGLuint *buffer);
947 
948 // feedback
949 void tglFeedbackBuffer(TGLsizei size, TGLenum type, TGLfloat *buffer);
950 void tglPassThrough(TGLfloat token);
951 
952 void tglInitNames();
953 void tglPushName(TGLuint name);
954 void tglPopName();
955 void tglLoadName(TGLuint name);
956 
957 // textures
958 void tglTexImage1D(TGLenum target, TGLint level, TGLint internalformat,
959  TGLsizei width, TGLint border, TGLint format,
960  TGLenum type, const TGLvoid *pixels);
961 void tglTexImage2D(TGLenum target, TGLint level, TGLint internalformat,
962  TGLsizei width, TGLsizei height, TGLint border,
963  TGLenum format, TGLenum type, const void *pixels);
964 void tglTexEnvf(TGLenum target, TGLenum pname, TGLfloat param);
965 void tglTexEnvfv(TGLenum target, TGLenum pname, const TGLfloat *params);
966 void tglTexEnvi(TGLenum target, TGLenum pname, TGLint param);
967 void tglTexEnviv(TGLenum target, TGLenum pname, const TGLint *params);
968 void tglTexGend(TGLenum coord, TGLenum pname, TGLdouble param);
969 void tglTexGendv(TGLenum coord, TGLenum pname, const TGLdouble *params);
970 void tglTexGenf(TGLenum coord, TGLenum pname, TGLfloat param);
971 void tglTexGenfv(TGLenum coord, TGLenum pname, const TGLfloat *params);
972 void tglTexGeni(TGLenum coord, TGLenum pname, TGLint param);
973 void tglTexGeniv(TGLenum coord, TGLenum pname, const TGLint *params);
974 void tglTexParameterf(TGLenum target, TGLenum pname, TGLfloat param);
975 void tglTexParameterfv(TGLenum target, TGLenum pname, const TGLfloat *params);
976 void tglTexParameteri(TGLenum target, TGLenum pname, TGLint param);
977 void tglTexParameteriv(TGLenum target, TGLenum pname, const TGLint *params);
978 void tglGetTexEnvfv(TGLenum target, TGLenum pname, TGLfloat *params);
979 void tglGetTexEnviv(TGLenum target, TGLenum pname, TGLint *params);
980 void tglGetTexImage(TGLenum target, TGLint level, TGLenum format, TGLenum type, TGLvoid *pixels);
981 void tglGetTexParameterfv(TGLenum target, TGLenum pname, TGLfloat *params);
982 void tglGetTexParameteriv(TGLenum target, TGLenum pname, TGLint *params);
983 void tglGetTexLevelParameterfv(TGLenum target, TGLint level, TGLenum pname, TGLfloat *params);
984 void tglGetTexLevelParameteriv(TGLenum target, TGLint level, TGLenum pname, TGLint *params);
985 void tglGetTexGenfv(TGLenum coord, TGLenum pname, TGLfloat *params);
986 void tglGetTexGeniv(TGLenum coord, TGLenum pname, TGLint *params);
987 void tglTexCoord1s(TGLshort s);
988 void tglTexCoord1i(TGLint s);
989 void tglTexCoord1f(TGLfloat s);
990 void tglTexCoord1d(TGLdouble s);
991 void tglTexCoord1sv(const TGLshort *v);
992 void tglTexCoord1iv(const TGLint *v);
993 void tglTexCoord1fv(const TGLfloat *v);
994 void tglTexCoord1dv(const TGLdouble *v);
995 void tglTexCoord2s(TGLshort s, TGLshort t);
996 void tglTexCoord2i(TGLint s, TGLint t);
997 void tglTexCoord2f(TGLfloat s, TGLfloat t);
998 void tglTexCoord2d(TGLdouble s, TGLdouble t);
999 void tglTexCoord2sv(const TGLshort *v);
1000 void tglTexCoord2iv(const TGLint *v);
1001 void tglTexCoord2fv(const TGLfloat *v);
1002 void tglTexCoord2dv(const TGLdouble *v);
1003 void tglTexCoord3s(TGLshort s, TGLshort t, TGLshort r);
1004 void tglTexCoord3i(TGLint s, TGLint t, TGLint r);
1005 void tglTexCoord3f(TGLfloat s, TGLfloat t, TGLfloat r);
1006 void tglTexCoord3d(TGLdouble s, TGLdouble t, TGLdouble r);
1007 void tglTexCoord3sv(const TGLshort *v);
1008 void tglTexCoord3dv(const TGLint *v);
1009 void tglTexCoord3fv(const TGLfloat *v);
1010 void tglTexCoord3dv(const TGLdouble *v);
1011 void tglTexCoord4s(TGLshort s, TGLshort t, TGLshort r, TGLshort q);
1012 void tglTexCoord4i(TGLint s, TGLint t, TGLint r, TGLint q);
1013 void tglTexCoord4f(TGLfloat s, TGLfloat t, TGLfloat r, TGLfloat q);
1014 void tglTexCoord4d(TGLdouble s, TGLdouble t, TGLdouble r, TGLdouble q);
1015 void tglTexCoord4sv(const TGLshort *v);
1016 void tglTexCoord4iv(const TGLint *v);
1017 void tglTexCoord4fv(const TGLfloat *v);
1018 void tglTexCoord4dv(const TGLdouble *v);
1019 
1020 // material
1021 void tglMaterialfv(TGLenum face, TGLenum pname, const TGLfloat *params);
1022 void tglMaterialf(TGLenum face, TGLenum pname, TGLfloat param);
1023 void tglMaterialiv(TGLenum face, TGLenum pname, const TGLint *params);
1024 void tglMateriali(TGLenum face, TGLenum pname, TGLint param);
1025 void tglColorMaterial(TGLenum face, TGLenum mode);
1026 void tglGetMaterialfv(TGLenum face, TGLenum pname, TGLfloat *params);
1027 void tglGetMaterialiv(TGLenum face, TGLenum pname, TGLint *params);
1028 
1029 // lighting
1030 void tglLightfv(TGLenum light, TGLenum pname, const TGLfloat *params);
1031 void tglLightf(TGLenum light, TGLenum pname, const TGLfloat param);
1032 void tglLightiv(TGLenum light, TGLenum pname, const TGLint *params);
1033 void tglLighti(TGLenum light, TGLenum pname, const TGLint param);
1034 void tglLightModelf(TGLenum pname, TGLfloat param);
1035 void tglLightModeli(TGLenum pname, TGLint param);
1036 void tglLightModelfv(TGLenum pname, const TGLfloat *params);
1037 void tglLightModeliv(TGLenum pname, const TGLfloat *params);
1038 void tglGetLightfv(TGLenum light, TGLenum pname, TGLfloat *params);
1039 void tglGetLightiv(TGLenum light, TGLenum pname, TGLint *params);
1040 
1041 // fog
1042 void tglFogfv(TGLenum pname, const TGLfloat *params);
1043 void tglFogf(TGLenum pname, TGLfloat param);
1044 void tglFogiv(TGLenum pname, const TGLint *params);
1045 void tglFogi(TGLenum pname, TGLint param);
1046 
1047 
1048 // gets
1049 TGLenum tglGetError();
1050 const TGLubyte *tglGetString(TGLenum name);
1051 void tglGetIntegerv(TGLenum pname, TGLint *data);
1052 void tglGetFloatv(TGLenum pname, TGLfloat *data);
1053 void tglGetDoublev(TGLenum pname, TGLdouble *data);
1054 void tglGetBooleanv(TGLenum pname, TGLboolean *params);
1055 void tglGetClipPlane(TGLenum plane, TGLdouble *equation);
1056 void tglGetMapdv(TGLenum target, TGLenum query, TGLdouble *v);
1057 void tglGetMapfv(TGLenum target, TGLenum query, TGLfloat *v);
1058 void tglGetMapiv(TGLenum target, TGLenum query, TGLint *v);
1059 
1060 // misc
1061 void tglFlush();
1062 void tglFinish();
1063 void tglHint(TGLenum target, TGLenum mode);
1064 void tglLogicOp(TGLenum opcode);
1065 void tglScissor(TGLint x, TGLint y, TGLsizei width, TGLsizei height);
1066 void tglFrontFace(TGLenum mode);
1067 void tglColorMask(TGLboolean red, TGLboolean green, TGLboolean blue, TGLboolean alpha);
1068 void tglDepthMask(TGLboolean flag);
1069 void tglIndexMask(TGLuint mask);
1070 void tglBlendFunc(TGLenum sfactor, TGLenum dfactor);
1071 void tglAlphaFunc(TGLenum func, TGLclampf ref);
1072 void tglDepthFunc(TGLenum func);
1073 void tglDepthRange(TGLclampd zNear, TGLclampd zFar);
1074 void tglPopAttrib();
1075 void tglPushAttrib(TGLbitfield mask);
1076 void tglMap1d(TGLenum target, TGLdouble u1, TGLdouble u2, TGLint stride, TGLint order, const TGLdouble *points);
1077 void tglMap1f(TGLenum target, TGLfloat u1, TGLfloat u2, TGLint stride, TGLint order, const TGLfloat *points);
1078 void tglMap2d(TGLenum target, TGLdouble u1, TGLdouble u2, TGLint ustride, TGLint uorder,
1079  TGLdouble v1, TGLdouble v2, TGLint vstride, TGLint vorder, const TGLdouble *points);
1080 void tglMap2f(TGLenum target, TGLfloat u1, TGLfloat u2, TGLint ustride, TGLint uorder,
1081  TGLfloat v1, TGLfloat v2, TGLint vstride, TGLint vorder, const TGLfloat *points);
1082 void tglMapGrid1d(TGLint un, TGLdouble u1, TGLdouble u2);
1083 void tglMapGrid1f(TGLint un, TGLfloat u1, TGLfloat u2);
1084 void tglMapGrid2d(TGLint un, TGLdouble u1, TGLdouble u2, TGLint vn, TGLdouble v1, TGLdouble v2);
1085 void tglMapGrid2f(TGLint un, TGLfloat u1, TGLfloat u2, TGLint vn, TGLfloat v1, TGLfloat v2);
1086 void tglEvalCoord1d(TGLdouble u);
1087 void tglEvalCoord1dv(const TGLdouble *u);
1088 void tglEvalCoord1f(TGLfloat u);
1089 void tglEvalCoord1fv(const TGLfloat *u);
1090 void tglEvalCoord2d(TGLint un, TGLdouble u1, TGLdouble u2, TGLint vn, TGLdouble v1, TGLdouble v2);
1091 void tglEvalCoord2dv(const TGLdouble *u);
1092 void tglEvalCoord2f(TGLint un, TGLfloat u1, TGLfloat u2, TGLint vn, TGLfloat v1, TGLfloat v2);
1093 void tglEvalCoord2fv(const TGLfloat *u);
1094 void tglEvalMesh1(TGLenum mode, TGLint i1, TGLint i2);
1095 void tglEvalMesh2(TGLenum mode, TGLint i1, TGLint i2, TGLint j1, TGLint j2);
1096 void tglEvalPoint1(TGLint i);
1097 void tglEvalPoint2(TGLint i, TGLint j);
1098 
1099 
1100 // --- GL 1.1 ---
1101 
1102 // textures
1103 void tglBindTexture(TGLenum target, TGLuint texture);
1104 void tglGenTextures(TGLsizei n, TGLuint *textures);
1105 void tglDeleteTextures(TGLsizei n, const TGLuint *textures);
1106 void tglCopyTexImage1D(TGLenum target, TGLint level, TGLenum internalFormat,
1107  TGLint x, TGLint y, TGLsizei width, TGLint border);
1108 void tglCopyTexImage2D(TGLenum target, TGLint level, TGLenum internalFormat,
1109  TGLint x, TGLint y, TGLsizei width, TGLsizei height,
1110  TGLint border);
1111 void tglCopyTexSubImage1D(TGLenum target, TGLint level, TGLint xoffset,
1112  TGLint x, TGLint y, TGLsizei width);
1113 void tglCopyTexSubImage2D(TGLenum target, TGLint level, TGLint xoffset,
1114  TGLint yoffset, TGLint x, TGLint y,
1115  TGLsizei width, TGLsizei height);
1116 void tglTexSubImage1D(TGLenum target, TGLint level, TGLint xoffset,
1117  TGLsizei width, TGLenum format, TGLenum type,
1118  const TGLvoid *pixels);
1119 void tglTexSubImage2D(TGLenum target, TGLint level, TGLint xoffset,
1120  TGLint yoffset, TGLsizei width, TGLsizei height,
1121  TGLenum format, TGLenum type, const TGLvoid *pixels);
1122 TGLboolean tglIsTexture(TGLuint texture);
1123 TGLboolean tglAreTexturesResident(TGLsizei n, const TGLuint *textures, TGLboolean *residences);
1124 void tglPrioritizeTextures(TGLsizei n, const TGLuint *textures, const TGLclampf *priorities);
1125 
1126 // arrays
1127 void tglEnableClientState(TGLenum array);
1128 void tglDisableClientState(TGLenum array);
1129 void tglArrayElement(TGLint index);
1130 void tglInterleavedArrays(TGLenum format, TGLsizei stride, const TGLvoid *pointer);
1131 void tglDrawArrays(TGLenum mode, TGLint first, TGLsizei count);
1132 void tglDrawElements(TGLenum mode, TGLsizei count, TGLenum type, const TGLvoid *indices);
1133 void tglVertexPointer(TGLint size, TGLenum type, TGLsizei stride, const TGLvoid *pointer);
1134 void tglColorPointer(TGLint size, TGLenum type, TGLsizei stride, const TGLvoid *pointer);
1135 void tglNormalPointer(TGLenum type, TGLsizei stride, const TGLvoid *pointer);
1136 void tglTexCoordPointer(TGLint size, TGLenum type, TGLsizei stride, const TGLvoid *pointer);
1137 void tglIndexPointer(TGLenum type, TGLsizei stride, const TGLvoid *pointer);
1138 void tglGetPointerv(TGLenum pname, TGLvoid **params);
1139 void tglEdgeFlagPointer(TGLsizei stride, const TGLvoid *pointer);
1140 
1141 // polygon offset
1142 void tglPolygonOffset(TGLfloat factor, TGLfloat units);
1143 
1144 // colors
1145 void tglIndexub(TGLubyte c);
1146 void tglIndexubv(const TGLubyte *c);
1147 
1148 // misc
1149 void tglPopClientAttrib();
1150 void tglPushClientAttrib(TGLbitfield mask);
1151 
1152 
1153 // --- GL 1.2 ---
1154 
1155 // arrays
1156 void tglDrawRangeElements(TGLenum mode, TGLuint start, TGLuint end,
1157  TGLsizei count, TGLenum type, const void *indices);
1158 
1159 // textures
1160 void tglTexImage3D(TGLenum target, TGLint level, TGLint internalformat,
1161  TGLsizei width, TGLsizei height, TGLsizei depth,
1162  TGLint border, TGLenum format, TGLenum type,
1163  const void *data);
1164 void tglTexSubImage3D(TGLenum target, TGLint level, TGLint xoffset, TGLint yoffset,
1165  TGLint zoffset, TGLsizei width, TGLsizei height, TGLsizei depth,
1166  TGLenum format, TGLenum type, const void *pixels);
1167 void tglCopyTexSubImage3D(TGLenum target, TGLint level, TGLint xoffset, TGLint yoffset,
1168  TGLint zoffset, TGLint x, TGLint y, TGLsizei width, TGLsizei height);
1169 
1170 
1171 // --- GL ES 1.0 / GL_OES_single_precision ---
1172 
1173 // matrix
1174 void tglFrustumf(TGLfloat left, TGLfloat right, TGLfloat bottom, TGLfloat top,
1175  TGLfloat nearv, TGLfloat farv);
1176 void tglOrthof(TGLfloat left, TGLfloat right, TGLfloat bottom, TGLfloat top,
1177  TGLfloat zNear, TGLfloat zFar);
1178 
1179 // clear
1180 void tglClearDepthf(TGLfloat depth);
1181 
1182 // gets
1183 void tglGetClipPlanef(TGLenum plane, TGLfloat *equation);
1184 
1185 // misc
1186 void tglDepthRangef(TGLclampf zNear, TGLclampf zFar);
1187 void tglClipPlanef(TGLenum plane, const TGLfloat *equation);
1188 
1189 #endif