projects / mesa.git / blob
? search:


1c16366509117b9d88b4c7f170f9bbe33b79e9ba
[mesa.git] / src / mesa / glapi / glapi.c
1 /* $Id: glapi.c,v 1.37 2000/02/24 22:14:04 brianp Exp $ */
2
3 /*
4 * Mesa 3-D graphics library
5 * Version: 3.3
6 *
7 * Copyright (C) 1999-2000 Brian Paul All Rights Reserved.
8 *
9 * Permission is hereby granted, free of charge, to any person obtaining a
10 * copy of this software and associated documentation files (the "Software"),
11 * to deal in the Software without restriction, including without limitation
12 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
13 * and/or sell copies of the Software, and to permit persons to whom the
14 * Software is furnished to do so, subject to the following conditions:
15 *
16 * The above copyright notice and this permission notice shall be included
17 * in all copies or substantial portions of the Software.
18 *
19 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
20 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
21 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
22 * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
23 * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
24 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
25 */
26
27
28 /*
29 * This file manages the OpenGL API dispatch layer.
30 * The dispatch table (struct _glapi_table) is basically just a list
31 * of function pointers.
32 * There are functions to set/get the current dispatch table for the
33 * current thread and to manage registration/dispatch of dynamically
34 * added extension functions.
35 *
36 * It's intended that this file and the other glapi*.[ch] files are
37 * flexible enough to be reused in several places: XFree86, DRI-
38 * based libGL.so, and perhaps the SGI SI.
39 *
40 * There are no dependencies on Mesa in this code.
41 */
42
43
44
45 #include "glheader.h"
46 #include "glapi.h"
47 #include "glapinoop.h"
48 #include "glapioffsets.h"
49 #include "glapitable.h"
50 #include "glthread.h"
51
52
53 /* This is used when thread safety is disabled */
54 struct _glapi_table *_glapi_Dispatch = (struct _glapi_table *) __glapi_noop_table;
55
56 /* Used when thread safety disabled */
57 void *_glapi_Context = NULL;
58
59
60 #if defined(THREADS)
61
62 /* Flag to indicate whether thread-safe dispatch is enabled */
63 static GLboolean ThreadSafe = GL_FALSE;
64
65 static _glthread_TSD DispatchTSD;
66
67 static _glthread_TSD ContextTSD;
68
69 #endif
70
71
72
73 static GLuint MaxDispatchOffset = sizeof(struct _glapi_table) / sizeof(void *) - 1;
74 static GLboolean GetSizeCalled = GL_FALSE;
75
76
77
78 /*
79 * We should call this periodically from a function such as glXMakeCurrent
80 * in order to test if multiple threads are being used. When we detect
81 * that situation we should then call _glapi_enable_thread_safety()
82 */
83 void
84 _glapi_check_multithread(void)
85 {
86 #if defined(THREADS)
87 if (!ThreadSafe) {
88 static unsigned long knownID;
89 static GLboolean firstCall = GL_TRUE;
90 if (firstCall) {
91 knownID = _glthread_GetID();
92 firstCall = GL_FALSE;
93 }
94 else if (knownID != _glthread_GetID()) {
95 ThreadSafe = GL_TRUE;
96 }
97 }
98 if (ThreadSafe) {
99 /* make sure that this thread's dispatch pointer isn't null */
100 if (!_glapi_get_dispatch()) {
101 _glapi_set_dispatch(NULL);
102 }
103 }
104 #endif
105 }
106
107
108
109 /*
110 * Set the current context pointer for this thread.
111 * The context pointer is an opaque type which should be cast to
112 * void from the real context pointer type.
113 */
114 void
115 _glapi_set_context(void *context)
116 {
117 #if defined(THREADS)
118 _glthread_SetTSD(&ContextTSD, context);
119 if (ThreadSafe)
120 _glapi_Context = NULL;
121 else
122 _glapi_Context = context;
123 #else
124 _glapi_Context = context;
125 #endif
126 }
127
128
129
130 /*
131 * Get the current context pointer for this thread.
132 * The context pointer is an opaque type which should be cast from
133 * void to the real context pointer type.
134 */
135 void *
136 _glapi_get_context(void)
137 {
138 #if defined(THREADS)
139 if (ThreadSafe) {
140 return _glthread_GetTSD(&ContextTSD);
141 }
142 else {
143 return _glapi_Context;
144 }
145 #else
146 return _glapi_Context;
147 #endif
148 }
149
150
151
152 /*
153 * Set the global or per-thread dispatch table pointer.
154 */
155 void
156 _glapi_set_dispatch(struct _glapi_table *dispatch)
157 {
158 if (!dispatch) {
159 /* use the no-op functions */
160 dispatch = (struct _glapi_table *) __glapi_noop_table;
161 }
162 #ifdef DEBUG
163 else {
164 _glapi_check_table(dispatch);
165 }
166 #endif
167
168 #if defined(THREADS)
169 _glthread_SetTSD(&DispatchTSD, (void*) dispatch);
170 if (ThreadSafe)
171 _glapi_Dispatch = NULL;
172 else
173 _glapi_Dispatch = dispatch;
174 #else
175 _glapi_Dispatch = dispatch;
176 #endif
177 }
178
179
180
181 /*
182 * Return pointer to current dispatch table for calling thread.
183 */
184 struct _glapi_table *
185 _glapi_get_dispatch(void)
186 {
187 #if defined(THREADS)
188 if (ThreadSafe) {
189 return (struct _glapi_table *) _glthread_GetTSD(&DispatchTSD);
190 }
191 else {
192 assert(_glapi_Dispatch);
193 return _glapi_Dispatch;
194 }
195 #else
196 return _glapi_Dispatch;
197 #endif
198 }
199
200
201
202 /*
203 * Return size of dispatch table struct as number of functions (or
204 * slots).
205 */
206 GLuint
207 _glapi_get_dispatch_table_size(void)
208 {
209 /* return sizeof(struct _glapi_table) / sizeof(void *);*/
210 GetSizeCalled = GL_TRUE;
211 return MaxDispatchOffset + 1;
212 }
213
214
215
216 /*
217 * Get API dispatcher version string.
218 */
219 const char *
220 _glapi_get_version(void)
221 {
222 return "20000223"; /* YYYYMMDD */
223 }
224
225
226 struct name_address_offset {
227 const char *Name;
228 GLvoid *Address;
229 GLuint Offset;
230 };
231
232 static struct name_address_offset static_functions[1000];
233
234
235
236 /*
237 * Return dispatch table offset of the named static (built-in) function.
238 * Return -1 if function not found.
239 */
240 static GLint
241 get_static_proc_offset(const char *funcName)
242 {
243 GLuint i;
244 for (i = 0; static_functions[i].Name; i++) {
245 if (strcmp(static_functions[i].Name, funcName) == 0) {
246 return static_functions[i].Offset;
247 }
248 }
249 return -1;
250 }
251
252
253 /*
254 * Return dispatch function address the named static (built-in) function.
255 * Return NULL if function not found.
256 */
257 static GLvoid *
258 get_static_proc_address(const char *funcName)
259 {
260 GLint i = get_static_proc_offset(funcName);
261 if (i >= 0)
262 return static_functions[i].Address;
263 else
264 return NULL;
265 }
266
267
268
269 /**********************************************************************
270 * Extension function management.
271 */
272
273
274 #define MAX_EXTENSION_FUNCS 1000
275
276 static struct name_address_offset ExtEntryTable[MAX_EXTENSION_FUNCS];
277 static GLuint NumExtEntryPoints = 0;
278
279
280
281 /*
282 * Generate a dispatch function (entrypoint) which jumps through
283 * the given slot number (offset) in the current dispatch table.
284 * We need assembly language in order to accomplish this.
285 */
286 static void *
287 generate_entrypoint(GLuint functionOffset)
288 {
289 #if defined(USE_X86_ASM)
290 /*
291 * This x86 code contributed by Josh Vanderhoof.
292 *
293 * 0: a1 10 32 54 76 movl __glapi_Dispatch,%eax
294 * 00 01 02 03 04
295 * 5: 85 c0 testl %eax,%eax
296 * 05 06
297 * 7: 74 06 je f <entrypoint+0xf>
298 * 07 08
299 * 9: ff a0 10 32 54 76 jmp *0x76543210(%eax)
300 * 09 0a 0b 0c 0d 0e
301 * f: e8 fc ff ff ff call __glapi_get_dispatch
302 * 0f 10 11 12 13
303 * 14: ff a0 10 32 54 76 jmp *0x76543210(%eax)
304 * 14 15 16 17 18 19
305 */
306 static const unsigned char temp[] = {
307 0xa1, 0x00, 0x00, 0x00, 0x00,
308 0x85, 0xc0,
309 0x74, 0x06,
310 0xff, 0xa0, 0x00, 0x00, 0x00, 0x00,
311 0xe8, 0x00, 0x00, 0x00, 0x00,
312 0xff, 0xa0, 0x00, 0x00, 0x00, 0x00
313 };
314 unsigned char *code = malloc(sizeof(temp));
315 unsigned int next_insn;
316 if (code) {
317 memcpy(code, temp, sizeof(temp));
318
319 *(unsigned int *)(code + 0x01) = (unsigned int)&_glapi_Dispatch;
320 *(unsigned int *)(code + 0x0b) = (unsigned int)functionOffset * 4;
321 next_insn = (unsigned int)(code + 0x14);
322 *(unsigned int *)(code + 0x10) = (unsigned int)_glapi_get_dispatch - next_insn;
323 *(unsigned int *)(code + 0x16) = (unsigned int)functionOffset * 4;
324 }
325 return code;
326 #else
327 return NULL;
328 #endif
329 }
330
331
332
333 /*
334 * Add a new extension function entrypoint.
335 * Return: GL_TRUE = success or GL_FALSE = failure
336 */
337 GLboolean
338 _glapi_add_entrypoint(const char *funcName, GLuint offset)
339 {
340 /* Make sure we don't try to add a new entrypoint after someone
341 * has already called _glapi_get_dispatch_table_size()! If that's
342 * happened the caller's information will now be out of date.
343 */
344 assert(!GetSizeCalled);
345
346 /* first check if the named function is already statically present */
347 {
348 GLint index = get_static_proc_offset(funcName);
349 if (index >= 0) {
350 return (GLboolean) (index == offset); /* bad offset! */
351 }
352 }
353
354 {
355 /* make sure this offset/name pair is legal */
356 const char *name = _glapi_get_proc_name(offset);
357 if (name && strcmp(name, funcName) != 0)
358 return GL_FALSE; /* bad name! */
359 }
360
361 {
362 /* be sure index and name match known data */
363 GLuint i;
364 for (i = 0; i < NumExtEntryPoints; i++) {
365 if (strcmp(ExtEntryTable[i].Name, funcName) == 0) {
366 /* function already registered with api */
367 if (ExtEntryTable[i].Offset == offset) {
368 return GL_TRUE; /* offsets match */
369 }
370 else {
371 return GL_FALSE; /* bad offset! */
372 }
373 }
374 }
375
376 /* make sure we have space */
377 if (NumExtEntryPoints >= MAX_EXTENSION_FUNCS) {
378 return GL_FALSE;
379 }
380 else {
381 void *entrypoint = generate_entrypoint(offset);
382 if (!entrypoint)
383 return GL_FALSE;
384
385 ExtEntryTable[NumExtEntryPoints].Name = strdup(funcName);
386 ExtEntryTable[NumExtEntryPoints].Offset = offset;
387 ExtEntryTable[NumExtEntryPoints].Address = entrypoint;
388 NumExtEntryPoints++;
389
390 if (offset > MaxDispatchOffset)
391 MaxDispatchOffset = offset;
392
393 return GL_TRUE; /* success */
394 }
395 }
396
397 /* should never get here, but play it safe */
398 return GL_FALSE;
399 }
400
401
402
403 #if 0000 /* prototype code for dynamic extension slot allocation */
404
405 static int NextFreeOffset = 409; /*XXX*/
406 #define MAX_DISPATCH_TABLE_SIZE 1000
407
408 /*
409 * Dynamically allocate a dispatch slot for an extension entrypoint
410 * and generate the assembly language dispatch stub.
411 * Return the dispatch offset for the function or -1 if no room or error.
412 */
413 GLint
414 _glapi_add_entrypoint2(const char *funcName)
415 {
416 int offset;
417
418 /* first see if extension func is already known */
419 offset = _glapi_get_proc_offset(funcName);
420 if (offset >= 0)
421 return offset;
422
423 if (NumExtEntryPoints < MAX_EXTENSION_FUNCS
424 && NextFreeOffset < MAX_DISPATCH_TABLE_SIZE) {
425 void *entryPoint;
426 offset = NextFreeOffset;
427 entryPoint = generate_entrypoint(offset);
428 if (entryPoint) {
429 NextFreeOffset++;
430 ExtEntryTable[NumExtEntryPoints].Name = strdup(funcName);
431 ExtEntryTable[NumExtEntryPoints].Offset = offset;
432 ExtEntryTable[NumExtEntryPoints].Address = entryPoint;
433 NumExtEntryPoints++;
434 return offset;
435 }
436 }
437 return -1;
438 }
439
440 #endif
441
442
443
444 /*
445 * Return offset of entrypoint for named function within dispatch table.
446 */
447 GLint
448 _glapi_get_proc_offset(const char *funcName)
449 {
450 /* search extension functions first */
451 GLint i;
452 for (i = 0; i < NumExtEntryPoints; i++) {
453 if (strcmp(ExtEntryTable[i].Name, funcName) == 0) {
454 return ExtEntryTable[i].Offset;
455 }
456 }
457
458 /* search static functions */
459 return get_static_proc_offset(funcName);
460 }
461
462
463
464 /*
465 * Return entrypoint for named function.
466 */
467 const GLvoid *
468 _glapi_get_proc_address(const char *funcName)
469 {
470 /* search extension functions first */
471 GLint i;
472 for (i = 0; i < NumExtEntryPoints; i++) {
473 if (strcmp(ExtEntryTable[i].Name, funcName) == 0) {
474 return ExtEntryTable[i].Address;
475 }
476 }
477
478 /* search static functions */
479 return get_static_proc_address(funcName);
480 }
481
482
483
484
485 /*
486 * Return the name of the function at the given dispatch offset.
487 * This is only intended for debugging.
488 */
489 const char *
490 _glapi_get_proc_name(GLuint offset)
491 {
492 const GLuint n = sizeof(static_functions) / sizeof(struct name_address_offset);
493 GLuint i;
494 for (i = 0; i < n; i++) {
495 if (static_functions[i].Offset == offset)
496 return static_functions[i].Name;
497 }
498
499 /* search added extension functions */
500 for (i = 0; i < NumExtEntryPoints; i++) {
501 if (ExtEntryTable[i].Offset == offset) {
502 return ExtEntryTable[i].Name;
503 }
504 }
505 return NULL;
506 }
507
508
509
510 /*
511 * Make sure there are no NULL pointers in the given dispatch table.
512 * Intented for debugging purposes.
513 */
514 void
515 _glapi_check_table(const struct _glapi_table *table)
516 {
517 const GLuint entries = _glapi_get_dispatch_table_size();
518 const void **tab = (const void **) table;
519 GLuint i;
520 for (i = 1; i < entries; i++) {
521 assert(tab[i]);
522 }
523
524 #ifdef DEBUG
525 /* Do some spot checks to be sure that the dispatch table
526 * slots are assigned correctly.
527 */
528 {
529 GLuint BeginOffset = _glapi_get_proc_offset("glBegin");
530 char *BeginFunc = (char*) &table->Begin;
531 GLuint offset = (BeginFunc - (char *) table) / sizeof(void *);
532 assert(BeginOffset == _gloffset_Begin);
533 assert(BeginOffset == offset);
534 }
535 {
536 GLuint viewportOffset = _glapi_get_proc_offset("glViewport");
537 char *viewportFunc = (char*) &table->Viewport;
538 GLuint offset = (viewportFunc - (char *) table) / sizeof(void *);
539 assert(viewportOffset == _gloffset_Viewport);
540 assert(viewportOffset == offset);
541 }
542 {
543 GLuint VertexPointerOffset = _glapi_get_proc_offset("glVertexPointer");
544 char *VertexPointerFunc = (char*) &table->VertexPointer;
545 GLuint offset = (VertexPointerFunc - (char *) table) / sizeof(void *);
546 assert(VertexPointerOffset == _gloffset_VertexPointer);
547 assert(VertexPointerOffset == offset);
548 }
549 {
550 GLuint ResetMinMaxOffset = _glapi_get_proc_offset("glResetMinmax");
551 char *ResetMinMaxFunc = (char*) &table->ResetMinmax;
552 GLuint offset = (ResetMinMaxFunc - (char *) table) / sizeof(void *);
553 assert(ResetMinMaxOffset == _gloffset_ResetMinmax);
554 assert(ResetMinMaxOffset == offset);
555 }
556 {
557 GLuint blendColorOffset = _glapi_get_proc_offset("glBlendColor");
558 char *blendColorFunc = (char*) &table->BlendColor;
559 GLuint offset = (blendColorFunc - (char *) table) / sizeof(void *);
560 assert(blendColorOffset == _gloffset_BlendColor);
561 assert(blendColorOffset == offset);
562 }
563 {
564 GLuint istextureOffset = _glapi_get_proc_offset("glIsTextureEXT");
565 char *istextureFunc = (char*) &table->IsTextureEXT;
566 GLuint offset = (istextureFunc - (char *) table) / sizeof(void *);
567 assert(istextureOffset == _gloffset_IsTextureEXT);
568 assert(istextureOffset == offset);
569 }
570 #endif
571 }
572
573
574 /*
575 * For each entry in static_functions[] which use this function
576 * we should implement a dispatch function in glapitemp.h and
577 * in glapinoop.c
578 */
579 static int NotImplemented(void)
580 {
581 return 0;
582 }
583
584
585
586 static struct name_address_offset static_functions[] = {
587 /* GL 1.1 */
588 { "glNewList", (GLvoid *) glNewList, _gloffset_NewList },
589 { "glEndList", (GLvoid *) glEndList, _gloffset_EndList },
590 { "glCallList", (GLvoid *) glCallList, _gloffset_CallList },
591 { "glCallLists", (GLvoid *) glCallLists, _gloffset_CallLists },
592 { "glDeleteLists", (GLvoid *) glDeleteLists, _gloffset_DeleteLists },
593 { "glGenLists", (GLvoid *) glGenLists, _gloffset_GenLists },
594 { "glListBase", (GLvoid *) glListBase, _gloffset_ListBase },
595 { "glBegin", (GLvoid *) glBegin, _gloffset_Begin },
596 { "glBitmap", (GLvoid *) glBitmap, _gloffset_Bitmap },
597 { "glColor3b", (GLvoid *) glColor3b, _gloffset_Color3b },
598 { "glColor3bv", (GLvoid *) glColor3bv, _gloffset_Color3bv },
599 { "glColor3d", (GLvoid *) glColor3d, _gloffset_Color3d },
600 { "glColor3dv", (GLvoid *) glColor3dv, _gloffset_Color3dv },
601 { "glColor3f", (GLvoid *) glColor3f, _gloffset_Color3f },
602 { "glColor3fv", (GLvoid *) glColor3fv, _gloffset_Color3fv },
603 { "glColor3i", (GLvoid *) glColor3i, _gloffset_Color3i },
604 { "glColor3iv", (GLvoid *) glColor3iv, _gloffset_Color3iv },
605 { "glColor3s", (GLvoid *) glColor3s, _gloffset_Color3s },
606 { "glColor3sv", (GLvoid *) glColor3sv, _gloffset_Color3sv },
607 { "glColor3ub", (GLvoid *) glColor3ub, _gloffset_Color3ub },
608 { "glColor3ubv", (GLvoid *) glColor3ubv, _gloffset_Color3ubv },
609 { "glColor3ui", (GLvoid *) glColor3ui, _gloffset_Color3ui },
610 { "glColor3uiv", (GLvoid *) glColor3uiv, _gloffset_Color3uiv },
611 { "glColor3us", (GLvoid *) glColor3us, _gloffset_Color3us },
612 { "glColor3usv", (GLvoid *) glColor3usv, _gloffset_Color3usv },
613 { "glColor4b", (GLvoid *) glColor4b, _gloffset_Color4b },
614 { "glColor4bv", (GLvoid *) glColor4bv, _gloffset_Color4bv },
615 { "glColor4d", (GLvoid *) glColor4d, _gloffset_Color4d },
616 { "glColor4dv", (GLvoid *) glColor4dv, _gloffset_Color4dv },
617 { "glColor4f", (GLvoid *) glColor4f, _gloffset_Color4f },
618 { "glColor4fv", (GLvoid *) glColor4fv, _gloffset_Color4fv },
619 { "glColor4i", (GLvoid *) glColor4i, _gloffset_Color4i },
620 { "glColor4iv", (GLvoid *) glColor4iv, _gloffset_Color4iv },
621 { "glColor4s", (GLvoid *) glColor4s, _gloffset_Color4s },
622 { "glColor4sv", (GLvoid *) glColor4sv, _gloffset_Color4sv },
623 { "glColor4ub", (GLvoid *) glColor4ub, _gloffset_Color4ub },
624 { "glColor4ubv", (GLvoid *) glColor4ubv, _gloffset_Color4ubv },
625 { "glColor4ui", (GLvoid *) glColor4ui, _gloffset_Color4ui },
626 { "glColor4uiv", (GLvoid *) glColor4uiv, _gloffset_Color4uiv },
627 { "glColor4us", (GLvoid *) glColor4us, _gloffset_Color4us },
628 { "glColor4usv", (GLvoid *) glColor4usv, _gloffset_Color4usv },
629 { "glEdgeFlag", (GLvoid *) glEdgeFlag, _gloffset_EdgeFlag },
630 { "glEdgeFlagv", (GLvoid *) glEdgeFlagv, _gloffset_EdgeFlagv },
631 { "glEnd", (GLvoid *) glEnd, _gloffset_End },
632 { "glIndexd", (GLvoid *) glIndexd, _gloffset_Indexd },
633 { "glIndexdv", (GLvoid *) glIndexdv, _gloffset_Indexdv },
634 { "glIndexf", (GLvoid *) glIndexf, _gloffset_Indexf },
635 { "glIndexfv", (GLvoid *) glIndexfv, _gloffset_Indexfv },
636 { "glIndexi", (GLvoid *) glIndexi, _gloffset_Indexi },
637 { "glIndexiv", (GLvoid *) glIndexiv, _gloffset_Indexiv },
638 { "glIndexs", (GLvoid *) glIndexs, _gloffset_Indexs },
639 { "glIndexsv", (GLvoid *) glIndexsv, _gloffset_Indexsv },
640 { "glNormal3b", (GLvoid *) glNormal3b, _gloffset_Normal3b },
641 { "glNormal3bv", (GLvoid *) glNormal3bv, _gloffset_Normal3bv },
642 { "glNormal3d", (GLvoid *) glNormal3d, _gloffset_Normal3d },
643 { "glNormal3dv", (GLvoid *) glNormal3dv, _gloffset_Normal3dv },
644 { "glNormal3f", (GLvoid *) glNormal3f, _gloffset_Normal3f },
645 { "glNormal3fv", (GLvoid *) glNormal3fv, _gloffset_Normal3fv },
646 { "glNormal3i", (GLvoid *) glNormal3i, _gloffset_Normal3i },
647 { "glNormal3iv", (GLvoid *) glNormal3iv, _gloffset_Normal3iv },
648 { "glNormal3s", (GLvoid *) glNormal3s, _gloffset_Normal3s },
649 { "glNormal3sv", (GLvoid *) glNormal3sv, _gloffset_Normal3sv },
650 { "glRasterPos2d", (GLvoid *) glRasterPos2d, _gloffset_RasterPos2d },
651 { "glRasterPos2dv", (GLvoid *) glRasterPos2dv, _gloffset_RasterPos2dv },
652 { "glRasterPos2f", (GLvoid *) glRasterPos2f, _gloffset_RasterPos2f },
653 { "glRasterPos2fv", (GLvoid *) glRasterPos2fv, _gloffset_RasterPos2fv },
654 { "glRasterPos2i", (GLvoid *) glRasterPos2i, _gloffset_RasterPos2i },
655 { "glRasterPos2iv", (GLvoid *) glRasterPos2iv, _gloffset_RasterPos2iv },
656 { "glRasterPos2s", (GLvoid *) glRasterPos2s, _gloffset_RasterPos2s },
657 { "glRasterPos2sv", (GLvoid *) glRasterPos2sv, _gloffset_RasterPos2sv },
658 { "glRasterPos3d", (GLvoid *) glRasterPos3d, _gloffset_RasterPos3d },
659 { "glRasterPos3dv", (GLvoid *) glRasterPos3dv, _gloffset_RasterPos3dv },
660 { "glRasterPos3f", (GLvoid *) glRasterPos3f, _gloffset_RasterPos3f },
661 { "glRasterPos3fv", (GLvoid *) glRasterPos3fv, _gloffset_RasterPos3fv },
662 { "glRasterPos3i", (GLvoid *) glRasterPos3i, _gloffset_RasterPos3i },
663 { "glRasterPos3iv", (GLvoid *) glRasterPos3iv, _gloffset_RasterPos3iv },
664 { "glRasterPos3s", (GLvoid *) glRasterPos3s, _gloffset_RasterPos3s },
665 { "glRasterPos3sv", (GLvoid *) glRasterPos3sv, _gloffset_RasterPos3sv },
666 { "glRasterPos4d", (GLvoid *) glRasterPos4d, _gloffset_RasterPos4d },
667 { "glRasterPos4dv", (GLvoid *) glRasterPos4dv, _gloffset_RasterPos4dv },
668 { "glRasterPos4f", (GLvoid *) glRasterPos4f, _gloffset_RasterPos4f },
669 { "glRasterPos4fv", (GLvoid *) glRasterPos4fv, _gloffset_RasterPos4fv },
670 { "glRasterPos4i", (GLvoid *) glRasterPos4i, _gloffset_RasterPos4i },
671 { "glRasterPos4iv", (GLvoid *) glRasterPos4iv, _gloffset_RasterPos4iv },
672 { "glRasterPos4s", (GLvoid *) glRasterPos4s, _gloffset_RasterPos4s },
673 { "glRasterPos4sv", (GLvoid *) glRasterPos4sv, _gloffset_RasterPos4sv },
674 { "glRectd", (GLvoid *) glRectd, _gloffset_Rectd },
675 { "glRectdv", (GLvoid *) glRectdv, _gloffset_Rectdv },
676 { "glRectf", (GLvoid *) glRectf, _gloffset_Rectf },
677 { "glRectfv", (GLvoid *) glRectfv, _gloffset_Rectfv },
678 { "glRecti", (GLvoid *) glRecti, _gloffset_Recti },
679 { "glRectiv", (GLvoid *) glRectiv, _gloffset_Rectiv },
680 { "glRects", (GLvoid *) glRects, _gloffset_Rects },
681 { "glRectsv", (GLvoid *) glRectsv, _gloffset_Rectsv },
682 { "glTexCoord1d", (GLvoid *) glTexCoord1d, _gloffset_TexCoord1d },
683 { "glTexCoord1dv", (GLvoid *) glTexCoord1dv, _gloffset_TexCoord1dv },
684 { "glTexCoord1f", (GLvoid *) glTexCoord1f, _gloffset_TexCoord1f },
685 { "glTexCoord1fv", (GLvoid *) glTexCoord1fv, _gloffset_TexCoord1fv },
686 { "glTexCoord1i", (GLvoid *) glTexCoord1i, _gloffset_TexCoord1i },
687 { "glTexCoord1iv", (GLvoid *) glTexCoord1iv, _gloffset_TexCoord1iv },
688 { "glTexCoord1s", (GLvoid *) glTexCoord1s, _gloffset_TexCoord1s },
689 { "glTexCoord1sv", (GLvoid *) glTexCoord1sv, _gloffset_TexCoord1sv },
690 { "glTexCoord2d", (GLvoid *) glTexCoord2d, _gloffset_TexCoord2d },
691 { "glTexCoord2dv", (GLvoid *) glTexCoord2dv, _gloffset_TexCoord2dv },
692 { "glTexCoord2f", (GLvoid *) glTexCoord2f, _gloffset_TexCoord2f },
693 { "glTexCoord2fv", (GLvoid *) glTexCoord2fv, _gloffset_TexCoord2fv },
694 { "glTexCoord2i", (GLvoid *) glTexCoord2i, _gloffset_TexCoord2i },
695 { "glTexCoord2iv", (GLvoid *) glTexCoord2iv, _gloffset_TexCoord2iv },
696 { "glTexCoord2s", (GLvoid *) glTexCoord2s, _gloffset_TexCoord2s },
697 { "glTexCoord2sv", (GLvoid *) glTexCoord2sv, _gloffset_TexCoord2sv },
698 { "glTexCoord3d", (GLvoid *) glTexCoord3d, _gloffset_TexCoord3d },
699 { "glTexCoord3dv", (GLvoid *) glTexCoord3dv, _gloffset_TexCoord3dv },
700 { "glTexCoord3f", (GLvoid *) glTexCoord3f, _gloffset_TexCoord3f },
701 { "glTexCoord3fv", (GLvoid *) glTexCoord3fv, _gloffset_TexCoord3fv },
702 { "glTexCoord3i", (GLvoid *) glTexCoord3i, _gloffset_TexCoord3i },
703 { "glTexCoord3iv", (GLvoid *) glTexCoord3iv, _gloffset_TexCoord3iv },
704 { "glTexCoord3s", (GLvoid *) glTexCoord3s, _gloffset_TexCoord3s },
705 { "glTexCoord3sv", (GLvoid *) glTexCoord3sv, _gloffset_TexCoord3sv },
706 { "glTexCoord4d", (GLvoid *) glTexCoord4d, _gloffset_TexCoord4d },
707 { "glTexCoord4dv", (GLvoid *) glTexCoord4dv, _gloffset_TexCoord4dv },
708 { "glTexCoord4f", (GLvoid *) glTexCoord4f, _gloffset_TexCoord4f },
709 { "glTexCoord4fv", (GLvoid *) glTexCoord4fv, _gloffset_TexCoord4fv },
710 { "glTexCoord4i", (GLvoid *) glTexCoord4i, _gloffset_TexCoord4i },
711 { "glTexCoord4iv", (GLvoid *) glTexCoord4iv, _gloffset_TexCoord4iv },
712 { "glTexCoord4s", (GLvoid *) glTexCoord4s, _gloffset_TexCoord4s },
713 { "glTexCoord4sv", (GLvoid *) glTexCoord4sv, _gloffset_TexCoord4sv },
714 { "glVertex2d", (GLvoid *) glVertex2d, _gloffset_Vertex2d },
715 { "glVertex2dv", (GLvoid *) glVertex2dv, _gloffset_Vertex2dv },
716 { "glVertex2f", (GLvoid *) glVertex2f, _gloffset_Vertex2f },
717 { "glVertex2fv", (GLvoid *) glVertex2fv, _gloffset_Vertex2fv },
718 { "glVertex2i", (GLvoid *) glVertex2i, _gloffset_Vertex2i },
719 { "glVertex2iv", (GLvoid *) glVertex2iv, _gloffset_Vertex2iv },
720 { "glVertex2s", (GLvoid *) glVertex2s, _gloffset_Vertex2s },
721 { "glVertex2sv", (GLvoid *) glVertex2sv, _gloffset_Vertex2sv },
722 { "glVertex3d", (GLvoid *) glVertex3d, _gloffset_Vertex3d },
723 { "glVertex3dv", (GLvoid *) glVertex3dv, _gloffset_Vertex3dv },
724 { "glVertex3f", (GLvoid *) glVertex3f, _gloffset_Vertex3f },
725 { "glVertex3fv", (GLvoid *) glVertex3fv, _gloffset_Vertex3fv },
726 { "glVertex3i", (GLvoid *) glVertex3i, _gloffset_Vertex3i },
727 { "glVertex3iv", (GLvoid *) glVertex3iv, _gloffset_Vertex3iv },
728 { "glVertex3s", (GLvoid *) glVertex3s, _gloffset_Vertex3s },
729 { "glVertex3sv", (GLvoid *) glVertex3sv, _gloffset_Vertex3sv },
730 { "glVertex4d", (GLvoid *) glVertex4d, _gloffset_Vertex4d },
731 { "glVertex4dv", (GLvoid *) glVertex4dv, _gloffset_Vertex4dv },
732 { "glVertex4f", (GLvoid *) glVertex4f, _gloffset_Vertex4f },
733 { "glVertex4fv", (GLvoid *) glVertex4fv, _gloffset_Vertex4fv },
734 { "glVertex4i", (GLvoid *) glVertex4i, _gloffset_Vertex4i },
735 { "glVertex4iv", (GLvoid *) glVertex4iv, _gloffset_Vertex4iv },
736 { "glVertex4s", (GLvoid *) glVertex4s, _gloffset_Vertex4s },
737 { "glVertex4sv", (GLvoid *) glVertex4sv, _gloffset_Vertex4sv },
738 { "glClipPlane", (GLvoid *) glClipPlane, _gloffset_ClipPlane },
739 { "glColorMaterial", (GLvoid *) glColorMaterial, _gloffset_ColorMaterial },
740 { "glCullFace", (GLvoid *) glCullFace, _gloffset_CullFace },
741 { "glFogf", (GLvoid *) glFogf, _gloffset_Fogf },
742 { "glFogfv", (GLvoid *) glFogfv, _gloffset_Fogfv },
743 { "glFogi", (GLvoid *) glFogi, _gloffset_Fogi },
744 { "glFogiv", (GLvoid *) glFogiv, _gloffset_Fogiv },
745 { "glFrontFace", (GLvoid *) glFrontFace, _gloffset_FrontFace },
746 { "glHint", (GLvoid *) glHint, _gloffset_Hint },
747 { "glLightf", (GLvoid *) glLightf, _gloffset_Lightf },
748 { "glLightfv", (GLvoid *) glLightfv, _gloffset_Lightfv },
749 { "glLighti", (GLvoid *) glLighti, _gloffset_Lighti },
750 { "glLightiv", (GLvoid *) glLightiv, _gloffset_Lightiv },
751 { "glLightModelf", (GLvoid *) glLightModelf, _gloffset_LightModelf },
752 { "glLightModelfv", (GLvoid *) glLightModelfv, _gloffset_LightModelfv },
753 { "glLightModeli", (GLvoid *) glLightModeli, _gloffset_LightModeli },
754 { "glLightModeliv", (GLvoid *) glLightModeliv, _gloffset_LightModeliv },
755 { "glLineStipple", (GLvoid *) glLineStipple, _gloffset_LineStipple },
756 { "glLineWidth", (GLvoid *) glLineWidth, _gloffset_LineWidth },
757 { "glMaterialf", (GLvoid *) glMaterialf, _gloffset_Materialf },
758 { "glMaterialfv", (GLvoid *) glMaterialfv, _gloffset_Materialfv },
759 { "glMateriali", (GLvoid *) glMateriali, _gloffset_Materiali },
760 { "glMaterialiv", (GLvoid *) glMaterialiv, _gloffset_Materialiv },
761 { "glPointSize", (GLvoid *) glPointSize, _gloffset_PointSize },
762 { "glPolygonMode", (GLvoid *) glPolygonMode, _gloffset_PolygonMode },
763 { "glPolygonStipple", (GLvoid *) glPolygonStipple, _gloffset_PolygonStipple },
764 { "glScissor", (GLvoid *) glScissor, _gloffset_Scissor },
765 { "glShadeModel", (GLvoid *) glShadeModel, _gloffset_ShadeModel },
766 { "glTexParameterf", (GLvoid *) glTexParameterf, _gloffset_TexParameterf },
767 { "glTexParameterfv", (GLvoid *) glTexParameterfv, _gloffset_TexParameterfv },
768 { "glTexParameteri", (GLvoid *) glTexParameteri, _gloffset_TexParameteri },
769 { "glTexParameteriv", (GLvoid *) glTexParameteriv, _gloffset_TexParameteriv },
770 { "glTexImage1D", (GLvoid *) glTexImage1D, _gloffset_TexImage1D },
771 { "glTexImage2D", (GLvoid *) glTexImage2D, _gloffset_TexImage2D },
772 { "glTexEnvf", (GLvoid *) glTexEnvf, _gloffset_TexEnvf },
773 { "glTexEnvfv", (GLvoid *) glTexEnvfv, _gloffset_TexEnvfv },
774 { "glTexEnvi", (GLvoid *) glTexEnvi, _gloffset_TexEnvi },
775 { "glTexEnviv", (GLvoid *) glTexEnviv, _gloffset_TexEnviv },
776 { "glTexGend", (GLvoid *) glTexGend, _gloffset_TexGend },
777 { "glTexGendv", (GLvoid *) glTexGendv, _gloffset_TexGendv },
778 { "glTexGenf", (GLvoid *) glTexGenf, _gloffset_TexGenf },
779 { "glTexGenfv", (GLvoid *) glTexGenfv, _gloffset_TexGenfv },
780 { "glTexGeni", (GLvoid *) glTexGeni, _gloffset_TexGeni },
781 { "glTexGeniv", (GLvoid *) glTexGeniv, _gloffset_TexGeniv },
782 { "glFeedbackBuffer", (GLvoid *) glFeedbackBuffer, _gloffset_FeedbackBuffer },
783 { "glSelectBuffer", (GLvoid *) glSelectBuffer, _gloffset_SelectBuffer },
784 { "glRenderMode", (GLvoid *) glRenderMode, _gloffset_RenderMode },
785 { "glInitNames", (GLvoid *) glInitNames, _gloffset_InitNames },
786 { "glLoadName", (GLvoid *) glLoadName, _gloffset_LoadName },
787 { "glPassThrough", (GLvoid *) glPassThrough, _gloffset_PassThrough },
788 { "glPopName", (GLvoid *) glPopName, _gloffset_PopName },
789 { "glPushName", (GLvoid *) glPushName, _gloffset_PushName },
790 { "glDrawBuffer", (GLvoid *) glDrawBuffer, _gloffset_DrawBuffer },
791 { "glClear", (GLvoid *) glClear, _gloffset_Clear },
792 { "glClearAccum", (GLvoid *) glClearAccum, _gloffset_ClearAccum },
793 { "glClearIndex", (GLvoid *) glClearIndex, _gloffset_ClearIndex },
794 { "glClearColor", (GLvoid *) glClearColor, _gloffset_ClearColor },
795 { "glClearStencil", (GLvoid *) glClearStencil, _gloffset_ClearStencil },
796 { "glClearDepth", (GLvoid *) glClearDepth, _gloffset_ClearDepth },
797 { "glStencilMask", (GLvoid *) glStencilMask, _gloffset_StencilMask },
798 { "glColorMask", (GLvoid *) glColorMask, _gloffset_ColorMask },
799 { "glDepthMask", (GLvoid *) glDepthMask, _gloffset_DepthMask },
800 { "glIndexMask", (GLvoid *) glIndexMask, _gloffset_IndexMask },
801 { "glAccum", (GLvoid *) glAccum, _gloffset_Accum },
802 { "glDisable", (GLvoid *) glDisable, _gloffset_Disable },
803 { "glEnable", (GLvoid *) glEnable, _gloffset_Enable },
804 { "glFinish", (GLvoid *) glFinish, _gloffset_Finish },
805 { "glFlush", (GLvoid *) glFlush, _gloffset_Flush },
806 { "glPopAttrib", (GLvoid *) glPopAttrib, _gloffset_PopAttrib },
807 { "glPushAttrib", (GLvoid *) glPushAttrib, _gloffset_PushAttrib },
808 { "glMap1d", (GLvoid *) glMap1d, _gloffset_Map1d },
809 { "glMap1f", (GLvoid *) glMap1f, _gloffset_Map1f },
810 { "glMap2d", (GLvoid *) glMap2d, _gloffset_Map2d },
811 { "glMap2f", (GLvoid *) glMap2f, _gloffset_Map2f },
812 { "glMapGrid1d", (GLvoid *) glMapGrid1d, _gloffset_MapGrid1d },
813 { "glMapGrid1f", (GLvoid *) glMapGrid1f, _gloffset_MapGrid1f },
814 { "glMapGrid2d", (GLvoid *) glMapGrid2d, _gloffset_MapGrid2d },
815 { "glMapGrid2f", (GLvoid *) glMapGrid2f, _gloffset_MapGrid2f },
816 { "glEvalCoord1d", (GLvoid *) glEvalCoord1d, _gloffset_EvalCoord1d },
817 { "glEvalCoord1dv", (GLvoid *) glEvalCoord1dv, _gloffset_EvalCoord1dv },
818 { "glEvalCoord1f", (GLvoid *) glEvalCoord1f, _gloffset_EvalCoord1f },
819 { "glEvalCoord1fv", (GLvoid *) glEvalCoord1fv, _gloffset_EvalCoord1fv },
820 { "glEvalCoord2d", (GLvoid *) glEvalCoord2d, _gloffset_EvalCoord2d },
821 { "glEvalCoord2dv", (GLvoid *) glEvalCoord2dv, _gloffset_EvalCoord2dv },
822 { "glEvalCoord2f", (GLvoid *) glEvalCoord2f, _gloffset_EvalCoord2f },
823 { "glEvalCoord2fv", (GLvoid *) glEvalCoord2fv, _gloffset_EvalCoord2fv },
824 { "glEvalMesh1", (GLvoid *) glEvalMesh1, _gloffset_EvalMesh1 },
825 { "glEvalPoint1", (GLvoid *) glEvalPoint1, _gloffset_EvalPoint1 },
826 { "glEvalMesh2", (GLvoid *) glEvalMesh2, _gloffset_EvalMesh2 },
827 { "glEvalPoint2", (GLvoid *) glEvalPoint2, _gloffset_EvalPoint2 },
828 { "glAlphaFunc", (GLvoid *) glAlphaFunc, _gloffset_AlphaFunc },
829 { "glBlendFunc", (GLvoid *) glBlendFunc, _gloffset_BlendFunc },
830 { "glLogicOp", (GLvoid *) glLogicOp, _gloffset_LogicOp },
831 { "glStencilFunc", (GLvoid *) glStencilFunc, _gloffset_StencilFunc },
832 { "glStencilOp", (GLvoid *) glStencilOp, _gloffset_StencilOp },
833 { "glDepthFunc", (GLvoid *) glDepthFunc, _gloffset_DepthFunc },
834 { "glPixelZoom", (GLvoid *) glPixelZoom, _gloffset_PixelZoom },
835 { "glPixelTransferf", (GLvoid *) glPixelTransferf, _gloffset_PixelTransferf },
836 { "glPixelTransferi", (GLvoid *) glPixelTransferi, _gloffset_PixelTransferi },
837 { "glPixelStoref", (GLvoid *) glPixelStoref, _gloffset_PixelStoref },
838 { "glPixelStorei", (GLvoid *) glPixelStorei, _gloffset_PixelStorei },
839 { "glPixelMapfv", (GLvoid *) glPixelMapfv, _gloffset_PixelMapfv },
840 { "glPixelMapuiv", (GLvoid *) glPixelMapuiv, _gloffset_PixelMapuiv },
841 { "glPixelMapusv", (GLvoid *) glPixelMapusv, _gloffset_PixelMapusv },
842 { "glReadBuffer", (GLvoid *) glReadBuffer, _gloffset_ReadBuffer },
843 { "glCopyPixels", (GLvoid *) glCopyPixels, _gloffset_CopyPixels },
844 { "glReadPixels", (GLvoid *) glReadPixels, _gloffset_ReadPixels },
845 { "glDrawPixels", (GLvoid *) glDrawPixels, _gloffset_DrawPixels },
846 { "glGetBooleanv", (GLvoid *) glGetBooleanv, _gloffset_GetBooleanv },
847 { "glGetClipPlane", (GLvoid *) glGetClipPlane, _gloffset_GetClipPlane },
848 { "glGetDoublev", (GLvoid *) glGetDoublev, _gloffset_GetDoublev },
849 { "glGetError", (GLvoid *) glGetError, _gloffset_GetError },
850 { "glGetFloatv", (GLvoid *) glGetFloatv, _gloffset_GetFloatv },
851 { "glGetIntegerv", (GLvoid *) glGetIntegerv, _gloffset_GetIntegerv },
852 { "glGetLightfv", (GLvoid *) glGetLightfv, _gloffset_GetLightfv },
853 { "glGetLightiv", (GLvoid *) glGetLightiv, _gloffset_GetLightiv },
854 { "glGetMapdv", (GLvoid *) glGetMapdv, _gloffset_GetMapdv },
855 { "glGetMapfv", (GLvoid *) glGetMapfv, _gloffset_GetMapfv },
856 { "glGetMapiv", (GLvoid *) glGetMapiv, _gloffset_GetMapiv },
857 { "glGetMaterialfv", (GLvoid *) glGetMaterialfv, _gloffset_GetMaterialfv },
858 { "glGetMaterialiv", (GLvoid *) glGetMaterialiv, _gloffset_GetMaterialiv },
859 { "glGetPixelMapfv", (GLvoid *) glGetPixelMapfv, _gloffset_GetPixelMapfv },
860 { "glGetPixelMapuiv", (GLvoid *) glGetPixelMapuiv, _gloffset_GetPixelMapuiv },
861 { "glGetPixelMapusv", (GLvoid *) glGetPixelMapusv, _gloffset_GetPixelMapusv },
862 { "glGetPolygonStipple", (GLvoid *) glGetPolygonStipple, _gloffset_GetPolygonStipple },
863 { "glGetString", (GLvoid *) glGetString, _gloffset_GetString },
864 { "glGetTexEnvfv", (GLvoid *) glGetTexEnvfv, _gloffset_GetTexEnvfv },
865 { "glGetTexEnviv", (GLvoid *) glGetTexEnviv, _gloffset_GetTexEnviv },
866 { "glGetTexGendv", (GLvoid *) glGetTexGendv, _gloffset_GetTexGendv },
867 { "glGetTexGenfv", (GLvoid *) glGetTexGenfv, _gloffset_GetTexGenfv },
868 { "glGetTexGeniv", (GLvoid *) glGetTexGeniv, _gloffset_GetTexGeniv },
869 { "glGetTexImage", (GLvoid *) glGetTexImage, _gloffset_GetTexImage },
870 { "glGetTexParameterfv", (GLvoid *) glGetTexParameterfv, _gloffset_GetTexParameterfv },
871 { "glGetTexParameteriv", (GLvoid *) glGetTexParameteriv, _gloffset_GetTexParameteriv },
872 { "glGetTexLevelParameterfv", (GLvoid *) glGetTexLevelParameterfv, _gloffset_GetTexLevelParameterfv },
873 { "glGetTexLevelParameteriv", (GLvoid *) glGetTexLevelParameteriv, _gloffset_GetTexLevelParameteriv },
874 { "glIsEnabled", (GLvoid *) glIsEnabled, _gloffset_IsEnabled },
875 { "glIsList", (GLvoid *) glIsList, _gloffset_IsList },
876 { "glDepthRange", (GLvoid *) glDepthRange, _gloffset_DepthRange },
877 { "glFrustum", (GLvoid *) glFrustum, _gloffset_Frustum },
878 { "glLoadIdentity", (GLvoid *) glLoadIdentity, _gloffset_LoadIdentity },
879 { "glLoadMatrixf", (GLvoid *) glLoadMatrixf, _gloffset_LoadMatrixf },
880 { "glLoadMatrixd", (GLvoid *) glLoadMatrixd, _gloffset_LoadMatrixd },
881 { "glMatrixMode", (GLvoid *) glMatrixMode, _gloffset_MatrixMode },
882 { "glMultMatrixf", (GLvoid *) glMultMatrixf, _gloffset_MultMatrixf },
883 { "glMultMatrixd", (GLvoid *) glMultMatrixd, _gloffset_MultMatrixd },
884 { "glOrtho", (GLvoid *) glOrtho, _gloffset_Ortho },
885 { "glPopMatrix", (GLvoid *) glPopMatrix, _gloffset_PopMatrix },
886 { "glPushMatrix", (GLvoid *) glPushMatrix, _gloffset_PushMatrix },
887 { "glRotated", (GLvoid *) glRotated, _gloffset_Rotated },
888 { "glRotatef", (GLvoid *) glRotatef, _gloffset_Rotatef },
889 { "glScaled", (GLvoid *) glScaled, _gloffset_Scaled },
890 { "glScalef", (GLvoid *) glScalef, _gloffset_Scalef },
891 { "glTranslated", (GLvoid *) glTranslated, _gloffset_Translated },
892 { "glTranslatef", (GLvoid *) glTranslatef, _gloffset_Translatef },
893 { "glViewport", (GLvoid *) glViewport, _gloffset_Viewport },
894 /* 1.1 */
895 { "glArrayElement", (GLvoid *) glArrayElement, _gloffset_ArrayElement },
896 { "glColorPointer", (GLvoid *) glColorPointer, _gloffset_ColorPointer },
897 { "glDisableClientState", (GLvoid *) glDisableClientState, _gloffset_DisableClientState },
898 { "glDrawArrays", (GLvoid *) glDrawArrays, _gloffset_DrawArrays },
899 { "glDrawElements", (GLvoid *) glDrawElements, _gloffset_DrawElements },
900 { "glEdgeFlagPointer", (GLvoid *) glEdgeFlagPointer, _gloffset_EdgeFlagPointer },
901 { "glEnableClientState", (GLvoid *) glEnableClientState, _gloffset_EnableClientState },
902 { "glGetPointerv", (GLvoid *) glGetPointerv, _gloffset_GetPointerv },
903 { "glIndexPointer", (GLvoid *) glIndexPointer, _gloffset_IndexPointer },
904 { "glInterleavedArrays", (GLvoid *) glInterleavedArrays, _gloffset_InterleavedArrays },
905 { "glNormalPointer", (GLvoid *) glNormalPointer, _gloffset_NormalPointer },
906 { "glTexCoordPointer", (GLvoid *) glTexCoordPointer, _gloffset_TexCoordPointer },
907 { "glVertexPointer", (GLvoid *) glVertexPointer, _gloffset_VertexPointer },
908 { "glPolygonOffset", (GLvoid *) glPolygonOffset, _gloffset_PolygonOffset },
909 { "glCopyTexImage1D", (GLvoid *) glCopyTexImage1D, _gloffset_CopyTexImage1D },
910 { "glCopyTexImage2D", (GLvoid *) glCopyTexImage2D, _gloffset_CopyTexImage2D },
911 { "glCopyTexSubImage1D", (GLvoid *) glCopyTexSubImage1D, _gloffset_CopyTexSubImage1D },
912 { "glCopyTexSubImage2D", (GLvoid *) glCopyTexSubImage2D, _gloffset_CopyTexSubImage2D },
913 { "glTexSubImage1D", (GLvoid *) glTexSubImage1D, _gloffset_TexSubImage1D },
914 { "glTexSubImage2D", (GLvoid *) glTexSubImage2D, _gloffset_TexSubImage2D },
915 { "glAreTexturesResident", (GLvoid *) glAreTexturesResident, _gloffset_AreTexturesResident },
916 { "glBindTexture", (GLvoid *) glBindTexture, _gloffset_BindTexture },
917 { "glDeleteTextures", (GLvoid *) glDeleteTextures, _gloffset_DeleteTextures },
918 { "glGenTextures", (GLvoid *) glGenTextures, _gloffset_GenTextures },
919 { "glIsTexture", (GLvoid *) glIsTexture, _gloffset_IsTexture },
920 { "glPrioritizeTextures", (GLvoid *) glPrioritizeTextures, _gloffset_PrioritizeTextures },
921 { "glIndexub", (GLvoid *) glIndexub, _gloffset_Indexub },
922 { "glIndexubv", (GLvoid *) glIndexubv, _gloffset_Indexubv },
923 { "glPopClientAttrib", (GLvoid *) glPopClientAttrib, _gloffset_PopClientAttrib },
924 { "glPushClientAttrib", (GLvoid *) glPushClientAttrib, _gloffset_PushClientAttrib },
925 /* 1.2 */
926 #ifdef GL_VERSION_1_2
927 #define NAME(X) X
928 #else
929 #define NAME(X) NotImplemented
930 #endif
931 { "glBlendColor", (GLvoid *) NAME(glBlendColor), _gloffset_BlendColor },
932 { "glBlendEquation", (GLvoid *) NAME(glBlendEquation), _gloffset_BlendEquation },
933 { "glDrawRangeElements", (GLvoid *) NAME(glDrawRangeElements), _gloffset_DrawRangeElements },
934 { "glColorTable", (GLvoid *) NAME(glColorTable), _gloffset_ColorTable },
935 { "glColorTableParameterfv", (GLvoid *) NAME(glColorTableParameterfv), _gloffset_ColorTableParameterfv },
936 { "glColorTableParameteriv", (GLvoid *) NAME(glColorTableParameteriv), _gloffset_ColorTableParameteriv },
937 { "glCopyColorTable", (GLvoid *) NAME(glCopyColorTable), _gloffset_CopyColorTable },
938 { "glGetColorTable", (GLvoid *) NAME(glGetColorTable), _gloffset_GetColorTable },
939 { "glGetColorTableParameterfv", (GLvoid *) NAME(glGetColorTableParameterfv), _gloffset_GetColorTableParameterfv },
940 { "glGetColorTableParameteriv", (GLvoid *) NAME(glGetColorTableParameteriv), _gloffset_GetColorTableParameteriv },
941 { "glColorSubTable", (GLvoid *) NAME(glColorSubTable), _gloffset_ColorSubTable },
942 { "glCopyColorSubTable", (GLvoid *) NAME(glCopyColorSubTable), _gloffset_CopyColorSubTable },
943 { "glConvolutionFilter1D", (GLvoid *) NAME(glConvolutionFilter1D), _gloffset_ConvolutionFilter1D },
944 { "glConvolutionFilter2D", (GLvoid *) NAME(glConvolutionFilter2D), _gloffset_ConvolutionFilter2D },
945 { "glConvolutionParameterf", (GLvoid *) NAME(glConvolutionParameterf), _gloffset_ConvolutionParameterf },
946 { "glConvolutionParameterfv", (GLvoid *) NAME(glConvolutionParameterfv), _gloffset_ConvolutionParameterfv },
947 { "glConvolutionParameteri", (GLvoid *) NAME(glConvolutionParameteri), _gloffset_ConvolutionParameteri },
948 { "glConvolutionParameteriv", (GLvoid *) NAME(glConvolutionParameteriv), _gloffset_ConvolutionParameteriv },
949 { "glCopyConvolutionFilter1D", (GLvoid *) NAME(glCopyConvolutionFilter1D), _gloffset_CopyConvolutionFilter1D },
950 { "glCopyConvolutionFilter2D", (GLvoid *) NAME(glCopyConvolutionFilter2D), _gloffset_CopyConvolutionFilter2D },
951 { "glGetConvolutionFilter", (GLvoid *) NAME(glGetConvolutionFilter), _gloffset_GetConvolutionFilter },
952 { "glGetConvolutionParameterfv", (GLvoid *) NAME(glGetConvolutionParameterfv), _gloffset_GetConvolutionParameterfv },
953 { "glGetConvolutionParameteriv", (GLvoid *) NAME(glGetConvolutionParameteriv), _gloffset_GetConvolutionParameteriv },
954 { "glGetSeparableFilter", (GLvoid *) NAME(glGetSeparableFilter), _gloffset_GetSeparableFilter },
955 { "glSeparableFilter2D", (GLvoid *) NAME(glSeparableFilter2D), _gloffset_SeparableFilter2D },
956 { "glGetHistogram", (GLvoid *) NAME(glGetHistogram), _gloffset_GetHistogram },
957 { "glGetHistogramParameterfv", (GLvoid *) NAME(glGetHistogramParameterfv), _gloffset_GetHistogramParameterfv },
958 { "glGetHistogramParameteriv", (GLvoid *) NAME(glGetHistogramParameteriv), _gloffset_GetHistogramParameteriv },
959 { "glGetMinmax", (GLvoid *) NAME(glGetMinmax), _gloffset_GetMinmax },
960 { "glGetMinmaxParameterfv", (GLvoid *) NAME(glGetMinmaxParameterfv), _gloffset_GetMinmaxParameterfv },
961 { "glGetMinmaxParameteriv", (GLvoid *) NAME(glGetMinmaxParameteriv), _gloffset_GetMinmaxParameteriv },
962 { "glHistogram", (GLvoid *) NAME(glHistogram), _gloffset_Histogram },
963 { "glMinmax", (GLvoid *) NAME(glMinmax), _gloffset_Minmax },
964 { "glResetHistogram", (GLvoid *) NAME(glResetHistogram), _gloffset_ResetHistogram },
965 { "glResetMinmax", (GLvoid *) NAME(glResetMinmax), _gloffset_ResetMinmax },
966 { "glTexImage3D", (GLvoid *) NAME(glTexImage3D), _gloffset_TexImage3D },
967 { "glTexSubImage3D", (GLvoid *) NAME(glTexSubImage3D), _gloffset_TexSubImage3D },
968 { "glCopyTexSubImage3D", (GLvoid *) NAME(glCopyTexSubImage3D), _gloffset_CopyTexSubImage3D },
969 #undef NAME
970
971 /* GL_ARB_multitexture */
972 #ifdef GL_ARB_multitexture
973 #define NAME(X) X
974 #else
975 #define NAME(X) NotImplemented
976 #endif
977 { "glActiveTextureARB", (GLvoid *) NAME(glActiveTextureARB), _gloffset_ActiveTextureARB },
978 { "glClientActiveTextureARB", (GLvoid *) NAME(glClientActiveTextureARB), _gloffset_ClientActiveTextureARB },
979 { "glMultiTexCoord1dARB", (GLvoid *) NAME(glMultiTexCoord1dARB), _gloffset_MultiTexCoord1dARB },
980 { "glMultiTexCoord1dvARB", (GLvoid *) NAME(glMultiTexCoord1dvARB), _gloffset_MultiTexCoord1dvARB },
981 { "glMultiTexCoord1fARB", (GLvoid *) NAME(glMultiTexCoord1fARB), _gloffset_MultiTexCoord1fARB },
982 { "glMultiTexCoord1fvARB", (GLvoid *) NAME(glMultiTexCoord1fvARB), _gloffset_MultiTexCoord1fvARB },
983 { "glMultiTexCoord1iARB", (GLvoid *) NAME(glMultiTexCoord1iARB), _gloffset_MultiTexCoord1iARB },
984 { "glMultiTexCoord1ivARB", (GLvoid *) NAME(glMultiTexCoord1ivARB), _gloffset_MultiTexCoord1ivARB },
985 { "glMultiTexCoord1sARB", (GLvoid *) NAME(glMultiTexCoord1sARB), _gloffset_MultiTexCoord1sARB },
986 { "glMultiTexCoord1svARB", (GLvoid *) NAME(glMultiTexCoord1svARB), _gloffset_MultiTexCoord1svARB },
987 { "glMultiTexCoord2dARB", (GLvoid *) NAME(glMultiTexCoord2dARB), _gloffset_MultiTexCoord2dARB },
988 { "glMultiTexCoord2dvARB", (GLvoid *) NAME(glMultiTexCoord2dvARB), _gloffset_MultiTexCoord2dvARB },
989 { "glMultiTexCoord2fARB", (GLvoid *) NAME(glMultiTexCoord2fARB), _gloffset_MultiTexCoord2fARB },
990 { "glMultiTexCoord2fvARB", (GLvoid *) NAME(glMultiTexCoord2fvARB), _gloffset_MultiTexCoord2fvARB },
991 { "glMultiTexCoord2iARB", (GLvoid *) NAME(glMultiTexCoord2iARB), _gloffset_MultiTexCoord2iARB },
992 { "glMultiTexCoord2ivARB", (GLvoid *) NAME(glMultiTexCoord2ivARB), _gloffset_MultiTexCoord2ivARB },
993 { "glMultiTexCoord2sARB", (GLvoid *) NAME(glMultiTexCoord2sARB), _gloffset_MultiTexCoord2sARB },
994 { "glMultiTexCoord2svARB", (GLvoid *) NAME(glMultiTexCoord2svARB), _gloffset_MultiTexCoord2svARB },
995 { "glMultiTexCoord3dARB", (GLvoid *) NAME(glMultiTexCoord3dARB), _gloffset_MultiTexCoord3dARB },
996 { "glMultiTexCoord3dvARB", (GLvoid *) NAME(glMultiTexCoord3dvARB), _gloffset_MultiTexCoord3dvARB },
997 { "glMultiTexCoord3fARB", (GLvoid *) NAME(glMultiTexCoord3fARB), _gloffset_MultiTexCoord3fARB },
998 { "glMultiTexCoord3fvARB", (GLvoid *) NAME(glMultiTexCoord3fvARB), _gloffset_MultiTexCoord3fvARB },
999 { "glMultiTexCoord3iARB", (GLvoid *) NAME(glMultiTexCoord3iARB), _gloffset_MultiTexCoord3iARB },
1000 { "glMultiTexCoord3ivARB", (GLvoid *) NAME(glMultiTexCoord3ivARB), _gloffset_MultiTexCoord3ivARB },
1001 { "glMultiTexCoord3sARB", (GLvoid *) NAME(glMultiTexCoord3sARB), _gloffset_MultiTexCoord3sARB },
1002 { "glMultiTexCoord3svARB", (GLvoid *) NAME(glMultiTexCoord3svARB), _gloffset_MultiTexCoord3svARB },
1003 { "glMultiTexCoord4dARB", (GLvoid *) NAME(glMultiTexCoord4dARB), _gloffset_MultiTexCoord4dARB },
1004 { "glMultiTexCoord4dvARB", (GLvoid *) NAME(glMultiTexCoord4dvARB), _gloffset_MultiTexCoord4dvARB },
1005 { "glMultiTexCoord4fARB", (GLvoid *) NAME(glMultiTexCoord4fARB), _gloffset_MultiTexCoord4fARB },
1006 { "glMultiTexCoord4fvARB", (GLvoid *) NAME(glMultiTexCoord4fvARB), _gloffset_MultiTexCoord4fvARB },
1007 { "glMultiTexCoord4iARB", (GLvoid *) NAME(glMultiTexCoord4iARB), _gloffset_MultiTexCoord4iARB },
1008 { "glMultiTexCoord4ivARB", (GLvoid *) NAME(glMultiTexCoord4ivARB), _gloffset_MultiTexCoord4ivARB },
1009 { "glMultiTexCoord4sARB", (GLvoid *) NAME(glMultiTexCoord4sARB), _gloffset_MultiTexCoord4sARB },
1010 { "glMultiTexCoord4svARB", (GLvoid *) NAME(glMultiTexCoord4svARB), _gloffset_MultiTexCoord4svARB },
1011 #undef NAME
1012
1013 /* GL_ARB_transpose_matrix */
1014 #ifdef GL_ARB_transpose_matrix
1015 #define NAME(X) X
1016 #else
1017 #define NAME(X) NotImplemented
1018 #endif
1019 { "glLoadTransposeMatrixdARB", (GLvoid *) NAME(glLoadTransposeMatrixdARB), _gloffset_LoadTransposeMatrixdARB },
1020 { "glLoadTransposeMatrixfARB", (GLvoid *) NAME(glLoadTransposeMatrixfARB), _gloffset_LoadTransposeMatrixfARB },
1021 { "glMultTransposeMatrixdARB", (GLvoid *) NAME(glMultTransposeMatrixdARB), _gloffset_MultTransposeMatrixdARB },
1022 { "glMultTransposeMatrixfARB", (GLvoid *) NAME(glMultTransposeMatrixfARB), _gloffset_MultTransposeMatrixfARB },
1023 #undef NAME
1024
1025 /* GL_ARB_multisample */
1026 #ifdef GL_ARB_multisample
1027 #define NAME(X) X
1028 #else
1029 #define NAME(X) NotImplemented
1030 #endif
1031 { "glSampleCoverageARB", (GLvoid *) NAME(glSampleCoverageARB), _gloffset_SampleCoverageARB },
1032 { "glSamplePassARB", (GLvoid *) NAME(glSamplePassARB), _gloffset_SamplePassARB },
1033 #undef NAME
1034
1035 /* 2. GL_EXT_blend_color */
1036 #ifdef GL_EXT_blend_color
1037 #define NAME(X) X
1038 #else
1039 #define NAME(X) NotImplemented
1040 #endif
1041 { "glBlendColorEXT", (GLvoid *) NAME(glBlendColorEXT), _gloffset_BlendColor },
1042 #undef NAME
1043
1044 /* 3. GL_EXT_polygon_offset */
1045 #ifdef GL_EXT_polygon_offset
1046 #define NAME(X) X
1047 #else
1048 #define NAME(X) NotImplemented
1049 #endif
1050 { "glPolygonOffsetEXT", (GLvoid *) NAME(glPolygonOffsetEXT), _gloffset_PolygonOffsetEXT },
1051 #undef NAME
1052
1053 /* 6. GL_EXT_texture3D */
1054 #ifdef GL_EXT_texture3D
1055 #define NAME(X) X
1056 #else
1057 #define NAME(X) NotImplemented
1058 #endif
1059 { "glCopyTexSubImage3DEXT", (GLvoid *) NAME(glCopyTexSubImage3DEXT), _gloffset_CopyTexSubImage3D },
1060 { "glTexImage3DEXT", (GLvoid *) NAME(glTexImage3DEXT), _gloffset_TexImage3D },
1061 { "glTexSubImage3DEXT", (GLvoid *) NAME(glTexSubImage3DEXT), _gloffset_TexSubImage3D },
1062 #undef NAME
1063
1064 /* 7. GL_SGI_texture_filter4 */
1065 #ifdef GL_SGI_texture_filter4
1066 #define NAME(X) X
1067 #else
1068 #define NAME(X) NotImplemented
1069 #endif
1070 { "glGetTexFilterFuncSGIS", (GLvoid *) NAME(glGetTexFilterFuncSGIS), _gloffset_GetTexFilterFuncSGIS },
1071 { "glTexFilterFuncSGIS", (GLvoid *) NAME(glTexFilterFuncSGIS), _gloffset_TexFilterFuncSGIS },
1072 #undef NAME
1073
1074 /* 9. GL_EXT_subtexture */
1075 #ifdef GL_EXT_subtexture
1076 #define NAME(X) X
1077 #else
1078 #define NAME(X) NotImplemented
1079 #endif
1080 { "glTexSubImage1DEXT", (GLvoid *) NAME(glTexSubImage1DEXT), _gloffset_TexSubImage1D },
1081 { "glTexSubImage2DEXT", (GLvoid *) NAME(glTexSubImage2DEXT), _gloffset_TexSubImage2D },
1082 #undef NAME
1083
1084 /* 10. GL_EXT_copy_texture */
1085 #ifdef GL_EXT_copy_texture
1086 #define NAME(X) X
1087 #else
1088 #define NAME(X) NotImplemented
1089 #endif
1090 { "glCopyTexImage1DEXT", (GLvoid *) NAME(glCopyTexImage1DEXT), _gloffset_CopyTexImage1D },
1091 { "glCopyTexImage2DEXT", (GLvoid *) NAME(glCopyTexImage2DEXT), _gloffset_CopyTexImage2D },
1092 { "glCopyTexSubImage1DEXT", (GLvoid *) NAME(glCopyTexSubImage1DEXT), _gloffset_CopyTexSubImage1D },
1093 { "glCopyTexSubImage2DEXT", (GLvoid *) NAME(glCopyTexSubImage2DEXT), _gloffset_CopyTexSubImage2D },
1094 #undef NAME
1095
1096 /* 11. GL_EXT_histogram */
1097 #ifdef GL_EXT_histogram
1098 #define NAME(X) X
1099 #else
1100 #define NAME(X) NotImplemented
1101 #endif
1102 { "glGetHistogramEXT", (GLvoid *) NAME(glGetHistogramEXT), _gloffset_GetHistogramEXT },
1103 { "glGetHistogramParameterfvEXT", (GLvoid *) NAME(glGetHistogramParameterfvEXT), _gloffset_GetHistogramParameterfvEXT },
1104 { "glGetHistogramParameterivEXT", (GLvoid *) NAME(glGetHistogramParameterivEXT), _gloffset_GetHistogramParameterivEXT },
1105 { "glGetMinmaxEXT", (GLvoid *) NAME(glGetMinmaxEXT), _gloffset_GetMinmaxEXT },
1106 { "glGetMinmaxParameterfvEXT", (GLvoid *) NAME(glGetMinmaxParameterfvEXT), _gloffset_GetMinmaxParameterfvEXT },
1107 { "glGetMinmaxParameterivEXT", (GLvoid *) NAME(glGetMinmaxParameterivEXT), _gloffset_GetMinmaxParameterivEXT },
1108 { "glHistogramEXT", (GLvoid *) NAME(glHistogramEXT), _gloffset_Histogram },
1109 { "glMinmaxEXT", (GLvoid *) NAME(glMinmaxEXT), _gloffset_Minmax },
1110 { "glResetHistogramEXT", (GLvoid *) NAME(glResetHistogramEXT), _gloffset_ResetHistogram },
1111 { "glResetMinmaxEXT", (GLvoid *) NAME(glResetMinmaxEXT), _gloffset_ResetMinmax },
1112 #undef NAME
1113
1114 /* 12. GL_EXT_convolution */
1115 #ifdef GL_EXT_convolution
1116 #define NAME(X) X
1117 #else
1118 #define NAME(X) NotImplemented
1119 #endif
1120 { "glConvolutionFilter1DEXT", (GLvoid *) NAME(glConvolutionFilter1DEXT), _gloffset_ConvolutionFilter1D },
1121 { "glConvolutionFilter2DEXT", (GLvoid *) NAME(glConvolutionFilter2DEXT), _gloffset_ConvolutionFilter2D },
1122 { "glConvolutionParameterfEXT", (GLvoid *) NAME(glConvolutionParameterfEXT), _gloffset_ConvolutionParameterf },
1123 { "glConvolutionParameterfvEXT", (GLvoid *) NAME(glConvolutionParameterfvEXT), _gloffset_ConvolutionParameterfv },
1124 { "glConvolutionParameteriEXT", (GLvoid *) NAME(glConvolutionParameteriEXT), _gloffset_ConvolutionParameteri },
1125 { "glConvolutionParameterivEXT", (GLvoid *) NAME(glConvolutionParameterivEXT), _gloffset_ConvolutionParameteriv },
1126 { "glCopyConvolutionFilter1DEXT", (GLvoid *) NAME(glCopyConvolutionFilter1DEXT), _gloffset_CopyConvolutionFilter1D },
1127 { "glCopyConvolutionFilter2DEXT", (GLvoid *) NAME(glCopyConvolutionFilter2DEXT), _gloffset_CopyConvolutionFilter2D },
1128 { "glGetConvolutionFilterEXT", (GLvoid *) NAME(glGetConvolutionFilterEXT), _gloffset_GetConvolutionFilterEXT },
1129 { "glGetConvolutionParameterivEXT", (GLvoid *) NAME(glGetConvolutionParameterivEXT), _gloffset_GetConvolutionParameterivEXT },
1130 { "glGetConvolutionParameterfvEXT", (GLvoid *) NAME(glGetConvolutionParameterfvEXT), _gloffset_GetConvolutionParameterfvEXT },
1131 { "glGetSeparableFilterEXT", (GLvoid *) NAME(glGetSeparableFilterEXT), _gloffset_GetSeparableFilterEXT },
1132 { "glSeparableFilter2DEXT", (GLvoid *) NAME(glSeparableFilter2DEXT), _gloffset_SeparableFilter2D },
1133 #undef NAME
1134
1135 /* 14. GL_SGI_color_table */
1136 #ifdef GL_SGI_color_table
1137 #define NAME(X) X
1138 #else
1139 #define NAME(X) NotImplemented
1140 #endif
1141 { "glColorTableSGI", (GLvoid *) NAME(glColorTableSGI), _gloffset_ColorTable },
1142 { "glColorTableParameterfvSGI", (GLvoid *) NAME(glColorTableParameterfvSGI), _gloffset_ColorTableParameterfv },
1143 { "glColorTableParameterivSGI", (GLvoid *) NAME(glColorTableParameterivSGI), _gloffset_ColorTableParameteriv },
1144 { "glCopyColorTableSGI", (GLvoid *) NAME(glCopyColorTableSGI), _gloffset_CopyColorTable },
1145 { "glGetColorTableSGI", (GLvoid *) NAME(glGetColorTableSGI), _gloffset_GetColorTableSGI },
1146 { "glGetColorTableParameterfvSGI", (GLvoid *) NAME(glGetColorTableParameterfvSGI), _gloffset_GetColorTableParameterfvSGI },
1147 { "glGetColorTableParameterivSGI", (GLvoid *) NAME(glGetColorTableParameterivSGI), _gloffset_GetColorTableParameterivSGI },
1148 #undef NAME
1149
1150 /* 15. GL_SGIS_pixel_texture */
1151 #ifdef GL_SGIS_pixel_texture
1152 #define NAME(X) X
1153 #else
1154 #define NAME(X) NotImplemented
1155 #endif
1156 { "glPixelTexGenParameterfSGIS", (GLvoid *) NAME(glPixelTexGenParameterfSGIS), _gloffset_PixelTexGenParameterfSGIS },
1157 { "glPixelTexGenParameteriSGIS", (GLvoid *) NAME(glPixelTexGenParameteriSGIS), _gloffset_PixelTexGenParameteriSGIS },
1158 { "glGetPixelTexGenParameterfvSGIS", (GLvoid *) NAME(glGetPixelTexGenParameterfvSGIS), _gloffset_GetPixelTexGenParameterfvSGIS },
1159 { "glGetPixelTexGenParameterivSGIS", (GLvoid *) NAME(glGetPixelTexGenParameterivSGIS), _gloffset_GetPixelTexGenParameterivSGIS },
1160 #undef NAME
1161
1162 /* 16. GL_SGIS_texture4D */
1163 #ifdef GL_SGIS_texture4D
1164 #define NAME(X) X
1165 #else
1166 #define NAME(X) NotImplemented
1167 #endif
1168 { "glTexImage4DSGIS", (GLvoid *) NAME(glTexImage4DSGIS), _gloffset_TexImage4DSGIS },
1169 { "glTexSubImage4DSGIS", (GLvoid *) NAME(glTexSubImage4DSGIS), _gloffset_TexSubImage4DSGIS },
1170 #undef NAME
1171
1172 /* 20. GL_EXT_texture_object */
1173 #ifdef GL_EXT_texture_object
1174 #define NAME(X) X
1175 #else
1176 #define NAME(X) NotImplemented
1177 #endif
1178 { "glAreTexturesResidentEXT", (GLvoid *) NAME(glAreTexturesResidentEXT), _gloffset_AreTexturesResidentEXT },
1179 { "glBindTextureEXT", (GLvoid *) NAME(glBindTextureEXT), _gloffset_BindTexture },
1180 { "glDeleteTexturesEXT", (GLvoid *) NAME(glDeleteTexturesEXT), _gloffset_DeleteTextures },
1181 { "glGenTexturesEXT", (GLvoid *) NAME(glGenTexturesEXT), _gloffset_GenTexturesEXT },
1182 { "glIsTextureEXT", (GLvoid *) NAME(glIsTextureEXT), _gloffset_IsTextureEXT },
1183 { "glPrioritizeTexturesEXT", (GLvoid *) NAME(glPrioritizeTexturesEXT), _gloffset_PrioritizeTextures },
1184 #undef NAME
1185
1186 /* 21. GL_SGIS_detail_texture */
1187 #ifdef GL_SGIS_detail_texture
1188 #define NAME(X) X
1189 #else
1190 #define NAME(X) NotImplemented
1191 #endif
1192 { "glDetailTexFuncSGIS", (GLvoid *) NAME(glDetailTexFuncSGIS), _gloffset_DetailTexFuncSGIS },
1193 { "glGetDetailTexFuncSGIS", (GLvoid *) NAME(glGetDetailTexFuncSGIS), _gloffset_GetDetailTexFuncSGIS },
1194 #undef NAME
1195
1196 /* 22. GL_SGIS_sharpen_texture */
1197 #ifdef GL_SGIS_sharpen_texture
1198 #define NAME(X) X
1199 #else
1200 #define NAME(X) NotImplemented
1201 #endif
1202 { "glGetSharpenTexFuncSGIS", (GLvoid *) NAME(glGetSharpenTexFuncSGIS), _gloffset_GetSharpenTexFuncSGIS },
1203 { "glSharpenTexFuncSGIS", (GLvoid *) NAME(glSharpenTexFuncSGIS), _gloffset_SharpenTexFuncSGIS },
1204 #undef NAME
1205
1206 /* 25. GL_SGIS_multisample */
1207 #ifdef GL_SGIS_multisample
1208 #define NAME(X) X
1209 #else
1210 #define NAME(X) NotImplemented
1211 #endif
1212 { "glSampleMaskSGIS", (GLvoid *) NAME(glSampleMaskSGIS), _gloffset_SampleMaskSGIS },
1213 { "glSamplePatternSGIS", (GLvoid *) NAME(glSamplePatternSGIS), _gloffset_SamplePatternSGIS },
1214 #undef NAME
1215
1216 /* 30. GL_EXT_vertex_array */
1217 #ifdef GL_EXT_vertex_array
1218 #define NAME(X) X
1219 #else
1220 #define NAME(X) NotImplemented
1221 #endif
1222 { "glArrayElementEXT", (GLvoid *) NAME(glArrayElementEXT), _gloffset_ArrayElement },
1223 { "glColorPointerEXT", (GLvoid *) NAME(glColorPointerEXT), _gloffset_ColorPointerEXT },
1224 { "glDrawArraysEXT", (GLvoid *) NAME(glDrawArraysEXT), _gloffset_DrawArrays },
1225 { "glEdgeFlagPointerEXT", (GLvoid *) NAME(glEdgeFlagPointerEXT), _gloffset_EdgeFlagPointerEXT },
1226 { "glGetPointervEXT", (GLvoid *) NAME(glGetPointervEXT), _gloffset_GetPointerv },
1227 { "glIndexPointerEXT", (GLvoid *) NAME(glIndexPointerEXT), _gloffset_IndexPointerEXT },
1228 { "glNormalPointerEXT", (GLvoid *) NAME(glNormalPointerEXT), _gloffset_NormalPointerEXT },
1229 { "glTexCoordPointerEXT", (GLvoid *) NAME(glTexCoordPointerEXT), _gloffset_TexCoordPointerEXT },
1230 { "glVertexPointerEXT", (GLvoid *) NAME(glVertexPointerEXT), _gloffset_VertexPointerEXT },
1231 #undef NAME
1232
1233 /* 37. GL_EXT_blend_minmax */
1234 #ifdef GL_EXT_blend_minmax
1235 #define NAME(X) X
1236 #else
1237 #define NAME(X) NotImplemented
1238 #endif
1239 { "glBlendEquationEXT", (GLvoid *) NAME(glBlendEquationEXT), _gloffset_BlendEquation },
1240 #undef NAME
1241
1242 /* 52. GL_SGIX_sprite */
1243 #ifdef GL_SGIX_sprite
1244 #define NAME(X) X
1245 #else
1246 #define NAME(X) NotImplemented
1247 #endif
1248 { "glSpriteParameterfSGIX", (GLvoid *) NAME(glSpriteParameterfSGIX), _gloffset_SpriteParameterfSGIX },
1249 { "glSpriteParameterfvSGIX", (GLvoid *) NAME(glSpriteParameterfvSGIX), _gloffset_SpriteParameterfvSGIX },
1250 { "glSpriteParameteriSGIX", (GLvoid *) NAME(glSpriteParameteriSGIX), _gloffset_SpriteParameteriSGIX },
1251 { "glSpriteParameterivSGIX", (GLvoid *) NAME(glSpriteParameterivSGIX), _gloffset_SpriteParameterivSGIX },
1252 #undef NAME
1253
1254 /* 54. GL_EXT_point_parameters */
1255 #ifdef GL_EXT_point_parameters
1256 #define NAME(X) X
1257 #else
1258 #define NAME(X) NotImplemented
1259 #endif
1260 { "glPointParameterfEXT", (GLvoid *) NAME(glPointParameterfEXT), _gloffset_PointParameterfEXT },
1261 { "glPointParameterfvEXT", (GLvoid *) NAME(glPointParameterfvEXT), _gloffset_PointParameterfvEXT },
1262 #undef NAME
1263
1264 /* 55. GL_SGIX_instruments */
1265 #ifdef GL_SGIX_instruments
1266 #define NAME(X) X
1267 #else
1268 #define NAME(X) NotImplemented
1269 #endif
1270 { "glInstrumentsBufferSGIX", (GLvoid *) NAME(glInstrumentsBufferSGIX), _gloffset_InstrumentsBufferSGIX },
1271 { "glStartInstrumentsSGIX", (GLvoid *) NAME(glStartInstrumentsSGIX), _gloffset_StartInstrumentsSGIX },
1272 { "glStopInstrumentsSGIX", (GLvoid *) NAME(glStopInstrumentsSGIX), _gloffset_StopInstrumentsSGIX },
1273 { "glReadInstrumentsSGIX", (GLvoid *) NAME(glReadInstrumentsSGIX), _gloffset_ReadInstrumentsSGIX },
1274 { "glPollInstrumentsSGIX", (GLvoid *) NAME(glPollInstrumentsSGIX), _gloffset_PollInstrumentsSGIX },
1275 { "glGetInstrumentsSGIX", (GLvoid *) NAME(glGetInstrumentsSGIX), _gloffset_GetInstrumentsSGIX },
1276 #undef NAME
1277
1278 /* 57. GL_SGIX_framezoom */
1279 #ifdef GL_SGIX_framezoom
1280 #define NAME(X) X
1281 #else
1282 #define NAME(X) NotImplemented
1283 #endif
1284 { "glFrameZoomSGIX", (GLvoid *) NAME(glFrameZoomSGIX), _gloffset_FrameZoomSGIX },
1285 #undef NAME
1286
1287 /* 58. GL_SGIX_tag_sample_buffer */
1288 #ifdef GL_SGIX_tag_sample_buffer
1289 #define NAME(X) X
1290 #else
1291 #define NAME(X) NotImplemented
1292 #endif
1293 { "glTagSampleBufferSGIX", (GLvoid *) NAME(glTagSampleBufferSGIX), _gloffset_TagSampleBufferSGIX },
1294 #undef NAME
1295
1296 /* 60. GL_SGIX_reference_plane */
1297 #ifdef GL_SGIX_reference_plane
1298 #define NAME(X) X
1299 #else
1300 #define NAME(X) NotImplemented
1301 #endif
1302 { "glReferencePlaneSGIX", (GLvoid *) NAME(glReferencePlaneSGIX), _gloffset_ReferencePlaneSGIX },
1303 #undef NAME
1304
1305 /* 61. GL_SGIX_flush_raster */
1306 #ifdef GL_SGIX_flush_raster
1307 #define NAME(X) X
1308 #else
1309 #define NAME(X) NotImplemented
1310 #endif
1311 { "glFlushRasterSGIX", (GLvoid *) NAME(glFlushRasterSGIX), _gloffset_FlushRasterSGIX },
1312 #undef NAME
1313
1314 /* 66. GL_HP_image_transform */
1315 #if 0
1316 #ifdef GL_HP_image_transform
1317 #define NAME(X) X
1318 #else
1319 #define NAME(X) NotImplemented
1320 #endif
1321 { "glGetImageTransformParameterfvHP", (GLvoid *) NAME(glGetImageTransformParameterfvHP), _gloffset_GetImageTransformParameterfvHP },
1322 { "glGetImageTransformParameterivHP", (GLvoid *) NAME(glGetImageTransformParameterivHP), _gloffset_GetImageTransformParameterivHP },
1323 { "glImageTransformParameterfHP", (GLvoid *) NAME(glImageTransformParameterfHP), _gloffset_ImageTransformParameterfHP },
1324 { "glImageTransformParameterfvHP", (GLvoid *) NAME(glImageTransformParameterfvHP), _gloffset_ImageTransformParameterfvHP },
1325 { "glImageTransformParameteriHP", (GLvoid *) NAME(glImageTransformParameteriHP), _gloffset_ImageTransformParameteriHP },
1326 { "glImageTransformParameterivHP", (GLvoid *) NAME(glImageTransformParameterivHP), _gloffset_ImageTransformParameterivHP },
1327 #undef NAME
1328 #endif
1329
1330 /* 74. GL_EXT_color_subtable */
1331 #ifdef GL_EXT_color_subtable
1332 #define NAME(X) X
1333 #else
1334 #define NAME(X) NotImplemented
1335 #endif
1336 { "glColorSubTableEXT", (GLvoid *) NAME(glColorSubTableEXT), _gloffset_ColorSubTable },
1337 { "glCopyColorSubTableEXT", (GLvoid *) NAME(glCopyColorSubTableEXT), _gloffset_CopyColorSubTable },
1338 #undef NAME
1339
1340 /* 77. GL_PGI_misc_hints */
1341 #ifdef GL_PGI_misc_hints
1342 #define NAME(X) X
1343 #else
1344 #define NAME(X) NotImplemented
1345 #endif
1346 { "glHintPGI", (GLvoid *) NAME(glHintPGI), _gloffset_HintPGI },
1347 #undef NAME
1348
1349 /* 78. GL_EXT_paletted_texture */
1350 #ifdef GL_EXT_paletted_texture
1351 #define NAME(X) X
1352 #else
1353 #define NAME(X) NotImplemented
1354 #endif
1355 { "glColorTableEXT", (GLvoid *) NAME(glColorTableEXT), _gloffset_ColorTable },
1356 { "glGetColorTableEXT", (GLvoid *) NAME(glGetColorTableEXT), _gloffset_GetColorTable },
1357 { "glGetColorTableParameterfvEXT", (GLvoid *) NAME(glGetColorTableParameterfvEXT), _gloffset_GetColorTableParameterfv },
1358 { "glGetColorTableParameterivEXT", (GLvoid *) NAME(glGetColorTableParameterivEXT), _gloffset_GetColorTableParameteriv },
1359 #undef NAME
1360
1361 /* 80. GL_SGIX_list_priority */
1362 #ifdef GL_SGIX_list_priority
1363 #define NAME(X) X
1364 #else
1365 #define NAME(X) NotImplemented
1366 #endif
1367 { "glGetListParameterfvSGIX", (GLvoid *) NAME(glGetListParameterfvSGIX), _gloffset_GetListParameterfvSGIX },
1368 { "glGetListParameterivSGIX", (GLvoid *) NAME(glGetListParameterivSGIX), _gloffset_GetListParameterivSGIX },
1369 { "glListParameterfSGIX", (GLvoid *) NAME(glListParameterfSGIX), _gloffset_ListParameterfSGIX },
1370 { "glListParameterfvSGIX", (GLvoid *) NAME(glListParameterfvSGIX), _gloffset_ListParameterfvSGIX },
1371 { "glListParameteriSGIX", (GLvoid *) NAME(glListParameteriSGIX), _gloffset_ListParameteriSGIX },
1372 { "glListParameterivSGIX", (GLvoid *) NAME(glListParameterivSGIX), _gloffset_ListParameterivSGIX },
1373 #undef NAME
1374
1375 /* 94. GL_EXT_index_material */
1376 #ifdef GL_EXT_index_material
1377 #define NAME(X) X
1378 #else
1379 #define NAME(X) NotImplemented
1380 #endif
1381 { "glIndexMaterialEXT", (GLvoid *) NAME(glIndexMaterialEXT), _gloffset_IndexMaterialEXT },
1382 #undef NAME
1383
1384 /* 95. GL_EXT_index_func */
1385 #ifdef GL_EXT_index_func
1386 #define NAME(X) X
1387 #else
1388 #define NAME(X) NotImplemented
1389 #endif
1390 { "glIndexFuncEXT", (GLvoid *) NAME(glIndexFuncEXT), _gloffset_IndexFuncEXT },
1391 #undef NAME
1392
1393 /* 97. GL_EXT_compiled_vertex_array */
1394 #ifdef GL_EXT_compiled_vertex_array
1395 #define NAME(X) X
1396 #else
1397 #define NAME(X) NotImplemented
1398 #endif
1399 { "glLockArraysEXT", (GLvoid *) NAME(glLockArraysEXT), _gloffset_LockArraysEXT },
1400 { "glUnlockArraysEXT", (GLvoid *) NAME(glUnlockArraysEXT), _gloffset_UnlockArraysEXT },
1401 #undef NAME
1402
1403 /* 98. GL_EXT_cull_vertex */
1404 #ifdef GL_EXT_cull_vertex
1405 #define NAME(X) X
1406 #else
1407 #define NAME(X) NotImplemented
1408 #endif
1409 { "glCullParameterfvEXT", (GLvoid *) NAME(glCullParameterfvEXT), _gloffset_CullParameterfvEXT },
1410 { "glCullParameterdvEXT", (GLvoid *) NAME(glCullParameterdvEXT), _gloffset_CullParameterdvEXT },
1411 #undef NAME
1412
1413 /* 102. GL_SGIX_fragment_lighting */
1414 #ifdef GL_SGIX_fragment_lighting
1415 #define NAME(X) X
1416 #else
1417 #define NAME(X) NotImplemented
1418 #endif
1419 { "glFragmentColorMaterialSGIX", (GLvoid *) NAME(glFragmentColorMaterialSGIX), _gloffset_FragmentColorMaterialSGIX },
1420 { "glFragmentLightfSGIX", (GLvoid *) NAME(glFragmentLightfSGIX), _gloffset_FragmentLightfSGIX },
1421 { "glFragmentLightfvSGIX", (GLvoid *) NAME(glFragmentLightfvSGIX), _gloffset_FragmentLightfvSGIX },
1422 { "glFragmentLightiSGIX", (GLvoid *) NAME(glFragmentLightiSGIX), _gloffset_FragmentLightiSGIX },
1423 { "glFragmentLightivSGIX", (GLvoid *) NAME(glFragmentLightivSGIX), _gloffset_FragmentLightivSGIX },
1424 { "glFragmentLightModelfSGIX", (GLvoid *) NAME(glFragmentLightModelfSGIX), _gloffset_FragmentLightModelfSGIX },
1425 { "glFragmentLightModelfvSGIX", (GLvoid *) NAME(glFragmentLightModelfvSGIX), _gloffset_FragmentLightModelfvSGIX },
1426 { "glFragmentLightModeliSGIX", (GLvoid *) NAME(glFragmentLightModeliSGIX), _gloffset_FragmentLightModeliSGIX },
1427 { "glFragmentLightModelivSGIX", (GLvoid *) NAME(glFragmentLightModelivSGIX), _gloffset_FragmentLightModelivSGIX },
1428 { "glFragmentMaterialfSGIX", (GLvoid *) NAME(glFragmentMaterialfSGIX), _gloffset_FragmentMaterialfSGIX },
1429 { "glFragmentMaterialfvSGIX", (GLvoid *) NAME(glFragmentMaterialfvSGIX), _gloffset_FragmentMaterialfvSGIX },
1430 { "glFragmentMaterialiSGIX", (GLvoid *) NAME(glFragmentMaterialiSGIX), _gloffset_FragmentMaterialiSGIX },
1431 { "glFragmentMaterialivSGIX", (GLvoid *) NAME(glFragmentMaterialivSGIX), _gloffset_FragmentMaterialivSGIX },
1432 { "glGetFragmentLightfvSGIX", (GLvoid *) NAME(glGetFragmentLightfvSGIX), _gloffset_GetFragmentLightfvSGIX },
1433 { "glGetFragmentLightivSGIX", (GLvoid *) NAME(glGetFragmentLightivSGIX), _gloffset_GetFragmentLightivSGIX },
1434 { "glGetFragmentMaterialfvSGIX", (GLvoid *) NAME(glGetFragmentMaterialfvSGIX), _gloffset_GetFragmentMaterialfvSGIX },
1435 { "glGetFragmentMaterialivSGIX", (GLvoid *) NAME(glGetFragmentMaterialivSGIX), _gloffset_GetFragmentMaterialivSGIX },
1436 { "glLightEnviSGIX", (GLvoid *) NAME(glLightEnviSGIX), _gloffset_LightEnviSGIX },
1437 #undef NAME
1438
1439 /* 149. GL_EXT_fog_coord */
1440 #ifdef GL_EXT_fog_coord
1441 #define NAME(X) X
1442 #else
1443 #define NAME(X) NotImplemented
1444 #endif
1445 { "glFogCoordfEXT", (GLvoid *) NAME(glFogCoordfEXT), _gloffset_FogCoordfEXT },
1446 { "glFogCoordfvEXT", (GLvoid *) NAME(glFogCoordfvEXT), _gloffset_FogCoordfvEXT },
1447 { "glFogCoorddEXT", (GLvoid *) NAME(glFogCoorddEXT), _gloffset_FogCoorddEXT },
1448 { "glFogCoorddEXT", (GLvoid *) NAME(glFogCoorddEXT), _gloffset_FogCoorddEXT },
1449 { "glFogCoordPointerEXT", (GLvoid *) NAME(glFogCoordPointerEXT), _gloffset_FogCoordPointerEXT },
1450 #undef NAME
1451
1452 /* 173. GL_EXT/INGR_blend_func_separate */
1453 #ifdef GL_EXT_blend_func_separate
1454 #define NAME(X) X
1455 #else
1456 #define NAME(X) NotImplemented
1457 #endif
1458 { "glBlendFuncSeparateEXT", (GLvoid *) NAME(glBlendFuncSeparateEXT), _gloffset_BlendFuncSeparateEXT },
1459 { "glBlendFuncSeparateINGR", (GLvoid *) NAME(glBlendFuncSeparateEXT), _gloffset_BlendFuncSeparateEXT },
1460 #undef NAME
1461
1462 /* 188. GL_EXT_vertex_weighting */
1463 #ifdef GL_EXT_vertex_weighting
1464 #define NAME(X) X
1465 #else
1466 #define NAME(X) NotImplemented
1467 #endif
1468 { "glVertexWeightfEXT", (GLvoid *) NAME(glVertexWeightfEXT), _gloffset_VertexWeightfEXT },
1469 { "glVertexWeightfvEXT", (GLvoid *) NAME(glVertexWeightfvEXT), _gloffset_VertexWeightfvEXT },
1470 { "glVertexWeightPointerEXT", (GLvoid *) NAME(glVertexWeightPointerEXT), _gloffset_VertexWeightPointerEXT },
1471 #undef NAME
1472
1473 /* 190. GL_NV_vertex_array_range */
1474 #ifdef GL_NV_vertex_array_range
1475 #define NAME(X) X
1476 #else
1477 #define NAME(X) NotImplemented
1478 #endif
1479 { "glFlushVertexArrayRangeNV", (GLvoid *) NAME(glFlushVertexArrayRangeNV), _gloffset_FlushVertexArrayRangeNV },
1480 { "glVertexArrayRangeNV", (GLvoid *) NAME(glVertexArrayRangeNV), _gloffset_VertexArrayRangeNV },
1481 #undef NAME
1482
1483 /* 191. GL_NV_register_combiners */
1484 #ifdef GL_NV_register_combiners
1485 #define NAME(X) X
1486 #else
1487 #define NAME(X) NotImplemented
1488 #endif
1489 { "glCombinerParameterfvNV", (GLvoid *) NAME(glCombinerParameterfvNV), _gloffset_CombinerParameterfvNV },
1490 { "glCombinerParameterfNV", (GLvoid *) NAME(glCombinerParameterfNV), _gloffset_CombinerParameterfNV },
1491 { "glCombinerParameterivNV", (GLvoid *) NAME(glCombinerParameterivNV), _gloffset_CombinerParameterivNV },
1492 { "glCombinerParameteriNV", (GLvoid *) NAME(glCombinerParameteriNV), _gloffset_CombinerParameteriNV },
1493 { "glCombinerInputNV", (GLvoid *) NAME(glCombinerInputNV), _gloffset_CombinerInputNV },
1494 { "glCombinerOutputNV", (GLvoid *) NAME(glCombinerOutputNV), _gloffset_CombinerOutputNV },
1495 { "glFinalCombinerInputNV", (GLvoid *) NAME(glFinalCombinerInputNV), _gloffset_FinalCombinerInputNV },
1496 { "glGetCombinerInputParameterfvNV", (GLvoid *) NAME(glGetCombinerInputParameterfvNV), _gloffset_GetCombinerInputParameterfvNV },
1497 { "glGetCombinerInputParameterivNV", (GLvoid *) NAME(glGetCombinerInputParameterivNV), _gloffset_GetCombinerInputParameterivNV },
1498 { "glGetCombinerOutputParameterfvNV", (GLvoid *) NAME(glGetCombinerOutputParameterfvNV), _gloffset_GetCombinerOutputParameterfvNV },
1499 { "glGetCombinerOutputParameterivNV", (GLvoid *) NAME(glGetCombinerOutputParameterivNV), _gloffset_GetCombinerOutputParameterivNV },
1500 { "glGetFinalCombinerInputParameterfvNV", (GLvoid *) NAME(glGetFinalCombinerInputParameterfvNV), _gloffset_GetFinalCombinerInputParameterfvNV },
1501 { "glGetFinalCombinerInputParameterivNV", (GLvoid *) NAME(glGetFinalCombinerInputParameterivNV), _gloffset_GetFinalCombinerInputParameterivNV },
1502 #undef NAME
1503
1504 /* 196. GL_MESA_resize_buffers */
1505 #ifdef MESA_resize_buffers
1506 #define NAME(X) X
1507 #else
1508 #define NAME(X) NotImplemented
1509 #endif
1510 { "glResizeBuffersMESA", (GLvoid *) NAME(glResizeBuffersMESA), _gloffset_ResizeBuffersMESA },
1511 #undef NAME
1512
1513 /* 197. GL_MESA_window_pos */
1514 #ifdef MESA_window_pos
1515 #define NAME(X) X
1516 #else
1517 #define NAME(X) NotImplemented
1518 #endif
1519 { "glWindowPos4fMESA", (GLvoid *) NAME(glWindowPos4fMESA), _gloffset_WindowPos4fMESA },
1520 #undef NAME
1521
1522
1523 { NULL, NULL } /* end of list marker */
1524 };
1525