1 /* $Id: glapi.c,v 1.14 1999/12/16 12:38:11 brianp Exp $ */
4 * Mesa 3-D graphics library
7 * Copyright (C) 1999 Brian Paul All Rights Reserved.
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:
16 * The above copyright notice and this permission notice shall be included
17 * in all copies or substantial portions of the Software.
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.
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.
40 #include <stdlib.h> /* to get NULL */
43 #include "glapinoop.h"
44 #include "glapioffsets.h"
45 #include "glapitable.h"
49 /* Flag to indicate whether thread-safe dispatch is enabled */
50 static GLboolean ThreadSafe
= GL_TRUE
;
52 /* This is used when thread safety is disabled */
53 static struct _glapi_table
*Dispatch
= &__glapi_noop_table
;
58 static MesaTSD mesa_dispatch_tsd
;
59 static void mesa_dispatch_thread_init() {
60 MesaInitTSD(&mesa_dispatch_tsd
);
66 #define DISPATCH_SETUP \
67 const struct _glapi_table *dispatch; \
69 dispatch = _glapi_get_dispatch(); \
72 dispatch = Dispatch; \
75 #define DISPATCH(FUNC, ARGS) (dispatch->FUNC) ARGS
78 static GLuint MaxDispatchOffset
= sizeof(struct _glapi_table
) / sizeof(void *);
79 static GLboolean GetSizeCalled
= GL_FALSE
;
83 * Set the global or per-thread dispatch table pointer.
86 _glapi_set_dispatch(struct _glapi_table
*dispatch
)
89 /* use the no-op functions */
90 dispatch
= &__glapi_noop_table
;
94 _glapi_check_table(dispatch
);
99 MesaSetTSD(&mesa_dispatch_tsd
, (void*) dispatch
, mesa_dispatch_thread_init
);
107 * Get the global or per-thread dispatch table pointer.
109 struct _glapi_table
*
110 _glapi_get_dispatch(void)
113 /* return this thread's dispatch pointer */
114 return (struct _glapi_table
*) MesaGetTSD(&mesa_dispatch_tsd
);
123 _glapi_enable_thread_safety(void)
125 ThreadSafe
= GL_TRUE
;
131 * Return size of dispatch table struct as number of functions (or
135 _glapi_get_dispatch_table_size(void)
137 /* return sizeof(struct _glapi_table) / sizeof(void *);*/
138 GetSizeCalled
= GL_TRUE
;
139 return MaxDispatchOffset
+ 1;
145 * Get API dispatcher version string.
146 * XXX this isn't well defined yet.
149 _glapi_get_version(void)
155 struct name_address_pair
{
160 static struct name_address_pair static_functions
[1000];
165 * Return dispatch table offset of the named static (built-in) function.
166 * Return -1 if function not found.
169 get_static_proc_offset(const char *funcName
)
172 for (i
= 0; static_functions
[i
].Name
; i
++) {
173 if (strcmp(static_functions
[i
].Name
, funcName
) == 0) {
182 * Return dispatch function address the named static (built-in) function.
183 * Return NULL if function not found.
186 get_static_proc_address(const char *funcName
)
188 GLuint i
= get_static_proc_offset(funcName
);
190 return static_functions
[i
].Address
;
197 /**********************************************************************
198 * Extension function management.
199 **********************************************************************/
202 struct _glapi_ext_entrypoint
{
203 const char *Name
; /* the extension function's name */
204 GLuint Offset
; /* relative to start of dispatch table */
205 GLvoid
*Address
; /* address of dispatch function */
208 static struct _glapi_ext_entrypoint ExtEntryTable
[_GLAPI_EXTRA_SLOTS
];
209 static GLuint NumExtEntryPoints
= 0;
214 * Generate a dispatch function (entrypoint) which jumps through
215 * the given slot number (offset) in the current dispatch table.
218 generate_entrypoint(GLuint offset
)
220 /* XXX need to generate some assembly code here */
228 * Add a new extension function entrypoint.
229 * Return: GL_TRUE = success or GL_FALSE = failure
232 _glapi_add_entrypoint(const char *funcName
, GLuint offset
)
236 /* Make sure we don't try to add a new entrypoint after someone
237 * has already called _glapi_get_dispatch_table_size()! If that's
238 * happened the caller's information will now be out of date.
240 assert(!GetSizeCalled
);
242 /* first check if the named function is already statically present */
243 index
= get_static_proc_offset(funcName
);
246 assert(index
== offset
);
249 /* else if (offset < _glapi_get_dispatch_table_size()) { */
251 /* be sure index and name match known data */
253 for (i
= 0; i
< NumExtEntryPoints
; i
++) {
254 if (strcmp(ExtEntryTable
[i
].Name
, funcName
) == 0) {
255 /* function already registered with api */
256 if (ExtEntryTable
[i
].Offset
== offset
) {
257 return GL_TRUE
; /* offsets match */
260 return GL_FALSE
; /* bad offset! */
264 assert(NumExtEntryPoints
< _GLAPI_EXTRA_SLOTS
);
265 ExtEntryTable
[NumExtEntryPoints
].Name
= strdup(funcName
);
266 ExtEntryTable
[NumExtEntryPoints
].Offset
= offset
;
267 ExtEntryTable
[NumExtEntryPoints
].Address
= generate_entrypoint(offset
);
270 if (offset
> MaxDispatchOffset
)
271 MaxDispatchOffset
= offset
;
285 * Return offset of entrypoint for named function within dispatch table.
288 _glapi_get_proc_offset(const char *funcName
)
290 /* search extension functions first */
292 for (i
= 0; i
< NumExtEntryPoints
; i
++) {
293 if (strcmp(ExtEntryTable
[i
].Name
, funcName
) == 0) {
294 return ExtEntryTable
[i
].Offset
;
298 /* search static functions */
299 return get_static_proc_offset(funcName
);
305 * Return entrypoint for named function.
308 _glapi_get_proc_address(const char *funcName
)
310 /* search extension functions first */
312 for (i
= 0; i
< NumExtEntryPoints
; i
++) {
313 if (strcmp(ExtEntryTable
[i
].Name
, funcName
) == 0) {
314 return ExtEntryTable
[i
].Address
;
318 /* search static functions */
319 return get_static_proc_address(funcName
);
326 * Return the name of the function at the given dispatch offset.
327 * This is only intended for debugging.
330 _glapi_get_proc_name(GLuint offset
)
332 GLuint n
= sizeof(static_functions
) / sizeof(struct name_address_pair
);
334 return static_functions
[offset
].Name
;
337 /* search added extension functions */
339 for (i
= 0; i
< NumExtEntryPoints
; i
++) {
340 if (ExtEntryTable
[i
].Offset
== offset
) {
341 return ExtEntryTable
[i
].Name
;
351 * Make sure there are no NULL pointers in the given dispatch table.
352 * Intented for debugging purposes.
355 _glapi_check_table(const struct _glapi_table
*table
)
357 const GLuint entries
= _glapi_get_dispatch_table_size();
358 const void **tab
= (const void **) table
;
360 for (i
= 1; i
< entries
; i
++) {
364 /* Do some spot checks to be sure that the dispatch table
365 * slots are assigned correctly.
368 GLuint BeginOffset
= _glapi_get_proc_offset("glBegin");
369 char *BeginFunc
= (char*) &table
->Begin
;
370 GLuint offset
= (BeginFunc
- (char *) table
) / sizeof(void *);
371 assert(BeginOffset
== _gloffset_Begin
);
372 assert(BeginOffset
== offset
);
375 GLuint viewportOffset
= _glapi_get_proc_offset("glViewport");
376 char *viewportFunc
= (char*) &table
->Viewport
;
377 GLuint offset
= (viewportFunc
- (char *) table
) / sizeof(void *);
378 assert(viewportOffset
== _gloffset_Viewport
);
379 assert(viewportOffset
== offset
);
382 GLuint VertexPointerOffset
= _glapi_get_proc_offset("glVertexPointer");
383 char *VertexPointerFunc
= (char*) &table
->VertexPointer
;
384 GLuint offset
= (VertexPointerFunc
- (char *) table
) / sizeof(void *);
385 assert(VertexPointerOffset
== _gloffset_VertexPointer
);
386 assert(VertexPointerOffset
== offset
);
389 GLuint ResetMinMaxOffset
= _glapi_get_proc_offset("glResetMinmax");
390 char *ResetMinMaxFunc
= (char*) &table
->ResetMinmax
;
391 GLuint offset
= (ResetMinMaxFunc
- (char *) table
) / sizeof(void *);
392 assert(ResetMinMaxOffset
== _gloffset_ResetMinmax
);
393 assert(ResetMinMaxOffset
== offset
);
396 GLuint blendColorOffset
= _glapi_get_proc_offset("glBlendColorEXT");
397 char *blendColorFunc
= (char*) &table
->BlendColorEXT
;
398 GLuint offset
= (blendColorFunc
- (char *) table
) / sizeof(void *);
399 assert(blendColorOffset
== _gloffset_BlendColorEXT
);
400 assert(blendColorOffset
== offset
);
403 GLuint istextureOffset
= _glapi_get_proc_offset("glIsTextureEXT");
404 char *istextureFunc
= (char*) &table
->IsTextureEXT
;
405 GLuint offset
= (istextureFunc
- (char *) table
) / sizeof(void *);
406 assert(istextureOffset
== _gloffset_IsTextureEXT
);
407 assert(istextureOffset
== offset
);
414 * Generate the GL entrypoint functions here.
418 #define KEYWORD2 GLAPIENTRY
419 #ifdef USE_MGL_NAMESPACE
420 #define NAME(func) mgl##func
422 #define NAME(func) gl##func
425 #include "glapitemp.h"
430 * For each entry in static_functions[] which use this function
431 * we should implement a dispatch function in glapitemp.h and
434 static void NotImplemented(void)
440 static struct name_address_pair static_functions
[] = {
441 { "NotImplemented", (GLvoid
*) NotImplemented
},
444 { "glAccum", (GLvoid
*) glAccum
},
445 { "glAlphaFunc", (GLvoid
*) glAlphaFunc
},
446 { "glBegin", (GLvoid
*) glBegin
},
447 { "glBitmap", (GLvoid
*) glBitmap
},
448 { "glBlendFunc", (GLvoid
*) glBlendFunc
},
449 { "glCallList", (GLvoid
*) glCallList
},
450 { "glCallLists", (GLvoid
*) glCallLists
},
451 { "glClear", (GLvoid
*) glClear
},
452 { "glClearAccum", (GLvoid
*) glClearAccum
},
453 { "glClearColor", (GLvoid
*) glClearColor
},
454 { "glClearDepth", (GLvoid
*) glClearDepth
},
455 { "glClearIndex", (GLvoid
*) glClearIndex
},
456 { "glClearStencil", (GLvoid
*) glClearStencil
},
457 { "glClipPlane", (GLvoid
*) glClipPlane
},
458 { "glColor3b", (GLvoid
*) glColor3b
},
459 { "glColor3bv", (GLvoid
*) glColor3bv
},
460 { "glColor3d", (GLvoid
*) glColor3d
},
461 { "glColor3dv", (GLvoid
*) glColor3dv
},
462 { "glColor3f", (GLvoid
*) glColor3f
},
463 { "glColor3fv", (GLvoid
*) glColor3fv
},
464 { "glColor3i", (GLvoid
*) glColor3i
},
465 { "glColor3iv", (GLvoid
*) glColor3iv
},
466 { "glColor3s", (GLvoid
*) glColor3s
},
467 { "glColor3sv", (GLvoid
*) glColor3sv
},
468 { "glColor3ub", (GLvoid
*) glColor3ub
},
469 { "glColor3ubv", (GLvoid
*) glColor3ubv
},
470 { "glColor3ui", (GLvoid
*) glColor3ui
},
471 { "glColor3uiv", (GLvoid
*) glColor3uiv
},
472 { "glColor3us", (GLvoid
*) glColor3us
},
473 { "glColor3usv", (GLvoid
*) glColor3usv
},
474 { "glColor4b", (GLvoid
*) glColor4b
},
475 { "glColor4bv", (GLvoid
*) glColor4bv
},
476 { "glColor4d", (GLvoid
*) glColor4d
},
477 { "glColor4dv", (GLvoid
*) glColor4dv
},
478 { "glColor4f", (GLvoid
*) glColor4f
},
479 { "glColor4fv", (GLvoid
*) glColor4fv
},
480 { "glColor4i", (GLvoid
*) glColor4i
},
481 { "glColor4iv", (GLvoid
*) glColor4iv
},
482 { "glColor4s", (GLvoid
*) glColor4s
},
483 { "glColor4sv", (GLvoid
*) glColor4sv
},
484 { "glColor4ub", (GLvoid
*) glColor4ub
},
485 { "glColor4ubv", (GLvoid
*) glColor4ubv
},
486 { "glColor4ui", (GLvoid
*) glColor4ui
},
487 { "glColor4uiv", (GLvoid
*) glColor4uiv
},
488 { "glColor4us", (GLvoid
*) glColor4us
},
489 { "glColor4usv", (GLvoid
*) glColor4usv
},
490 { "glColorMask", (GLvoid
*) glColorMask
},
491 { "glColorMaterial", (GLvoid
*) glColorMaterial
},
492 { "glCopyPixels", (GLvoid
*) glCopyPixels
},
493 { "glCullFace", (GLvoid
*) glCullFace
},
494 { "glDeleteLists", (GLvoid
*) glDeleteLists
},
495 { "glDepthFunc", (GLvoid
*) glDepthFunc
},
496 { "glDepthMask", (GLvoid
*) glDepthMask
},
497 { "glDepthRange", (GLvoid
*) glDepthRange
},
498 { "glDisable", (GLvoid
*) glDisable
},
499 { "glDrawBuffer", (GLvoid
*) glDrawBuffer
},
500 { "glDrawPixels", (GLvoid
*) glDrawPixels
},
501 { "glEdgeFlag", (GLvoid
*) glEdgeFlag
},
502 { "glEdgeFlagv", (GLvoid
*) glEdgeFlagv
},
503 { "glEnable", (GLvoid
*) glEnable
},
504 { "glEnd", (GLvoid
*) glEnd
},
505 { "glEndList", (GLvoid
*) glEndList
},
506 { "glEvalCoord1d", (GLvoid
*) glEvalCoord1d
},
507 { "glEvalCoord1dv", (GLvoid
*) glEvalCoord1dv
},
508 { "glEvalCoord1f", (GLvoid
*) glEvalCoord1f
},
509 { "glEvalCoord1fv", (GLvoid
*) glEvalCoord1fv
},
510 { "glEvalCoord2d", (GLvoid
*) glEvalCoord2d
},
511 { "glEvalCoord2dv", (GLvoid
*) glEvalCoord2dv
},
512 { "glEvalCoord2f", (GLvoid
*) glEvalCoord2f
},
513 { "glEvalCoord2fv", (GLvoid
*) glEvalCoord2fv
},
514 { "glEvalMesh1", (GLvoid
*) glEvalMesh1
},
515 { "glEvalMesh2", (GLvoid
*) glEvalMesh2
},
516 { "glEvalPoint1", (GLvoid
*) glEvalPoint1
},
517 { "glEvalPoint2", (GLvoid
*) glEvalPoint2
},
518 { "glFeedbackBuffer", (GLvoid
*) glFeedbackBuffer
},
519 { "glFinish", (GLvoid
*) glFinish
},
520 { "glFlush", (GLvoid
*) glFlush
},
521 { "glFogf", (GLvoid
*) glFogf
},
522 { "glFogfv", (GLvoid
*) glFogfv
},
523 { "glFogi", (GLvoid
*) glFogi
},
524 { "glFogiv", (GLvoid
*) glFogiv
},
525 { "glFrontFace", (GLvoid
*) glFrontFace
},
526 { "glFrustum", (GLvoid
*) glFrustum
},
527 { "glGenLists", (GLvoid
*) glGenLists
},
528 { "glGetBooleanv", (GLvoid
*) glGetBooleanv
},
529 { "glGetClipPlane", (GLvoid
*) glGetClipPlane
},
530 { "glGetDoublev", (GLvoid
*) glGetDoublev
},
531 { "glGetError", (GLvoid
*) glGetError
},
532 { "glGetFloatv", (GLvoid
*) glGetFloatv
},
533 { "glGetIntegerv", (GLvoid
*) glGetIntegerv
},
534 { "glGetLightfv", (GLvoid
*) glGetLightfv
},
535 { "glGetLightiv", (GLvoid
*) glGetLightiv
},
536 { "glGetMapdv", (GLvoid
*) glGetMapdv
},
537 { "glGetMapfv", (GLvoid
*) glGetMapfv
},
538 { "glGetMapiv", (GLvoid
*) glGetMapiv
},
539 { "glGetMaterialfv", (GLvoid
*) glGetMaterialfv
},
540 { "glGetMaterialiv", (GLvoid
*) glGetMaterialiv
},
541 { "glGetPixelMapfv", (GLvoid
*) glGetPixelMapfv
},
542 { "glGetPixelMapuiv", (GLvoid
*) glGetPixelMapuiv
},
543 { "glGetPixelMapusv", (GLvoid
*) glGetPixelMapusv
},
544 { "glGetPolygonStipple", (GLvoid
*) glGetPolygonStipple
},
545 { "glGetString", (GLvoid
*) glGetString
},
546 { "glGetTexEnvfv", (GLvoid
*) glGetTexEnvfv
},
547 { "glGetTexEnviv", (GLvoid
*) glGetTexEnviv
},
548 { "glGetTexGendv", (GLvoid
*) glGetTexGendv
},
549 { "glGetTexGenfv", (GLvoid
*) glGetTexGenfv
},
550 { "glGetTexGeniv", (GLvoid
*) glGetTexGeniv
},
551 { "glGetTexImage", (GLvoid
*) glGetTexImage
},
552 { "glGetTexLevelParameterfv", (GLvoid
*) glGetTexLevelParameterfv
},
553 { "glGetTexLevelParameteriv", (GLvoid
*) glGetTexLevelParameteriv
},
554 { "glGetTexParameterfv", (GLvoid
*) glGetTexParameterfv
},
555 { "glGetTexParameteriv", (GLvoid
*) glGetTexParameteriv
},
556 { "glHint", (GLvoid
*) glHint
},
557 { "glIndexMask", (GLvoid
*) glIndexMask
},
558 { "glIndexd", (GLvoid
*) glIndexd
},
559 { "glIndexdv", (GLvoid
*) glIndexdv
},
560 { "glIndexf", (GLvoid
*) glIndexf
},
561 { "glIndexfv", (GLvoid
*) glIndexfv
},
562 { "glIndexi", (GLvoid
*) glIndexi
},
563 { "glIndexiv", (GLvoid
*) glIndexiv
},
564 { "glIndexs", (GLvoid
*) glIndexs
},
565 { "glIndexsv", (GLvoid
*) glIndexsv
},
566 { "glInitNames", (GLvoid
*) glInitNames
},
567 { "glIsEnabled", (GLvoid
*) glIsEnabled
},
568 { "glIsList", (GLvoid
*) glIsList
},
569 { "glLightModelf", (GLvoid
*) glLightModelf
},
570 { "glLightModelfv", (GLvoid
*) glLightModelfv
},
571 { "glLightModeli", (GLvoid
*) glLightModeli
},
572 { "glLightModeliv", (GLvoid
*) glLightModeliv
},
573 { "glLightf", (GLvoid
*) glLightf
},
574 { "glLightfv", (GLvoid
*) glLightfv
},
575 { "glLighti", (GLvoid
*) glLighti
},
576 { "glLightiv", (GLvoid
*) glLightiv
},
577 { "glLineStipple", (GLvoid
*) glLineStipple
},
578 { "glLineWidth", (GLvoid
*) glLineWidth
},
579 { "glListBase", (GLvoid
*) glListBase
},
580 { "glLoadIdentity", (GLvoid
*) glLoadIdentity
},
581 { "glLoadMatrixd", (GLvoid
*) glLoadMatrixd
},
582 { "glLoadMatrixf", (GLvoid
*) glLoadMatrixf
},
583 { "glLoadName", (GLvoid
*) glLoadName
},
584 { "glLogicOp", (GLvoid
*) glLogicOp
},
585 { "glMap1d", (GLvoid
*) glMap1d
},
586 { "glMap1f", (GLvoid
*) glMap1f
},
587 { "glMap2d", (GLvoid
*) glMap2d
},
588 { "glMap2f", (GLvoid
*) glMap2f
},
589 { "glMapGrid1d", (GLvoid
*) glMapGrid1d
},
590 { "glMapGrid1f", (GLvoid
*) glMapGrid1f
},
591 { "glMapGrid2d", (GLvoid
*) glMapGrid2d
},
592 { "glMapGrid2f", (GLvoid
*) glMapGrid2f
},
593 { "glMaterialf", (GLvoid
*) glMaterialf
},
594 { "glMaterialfv", (GLvoid
*) glMaterialfv
},
595 { "glMateriali", (GLvoid
*) glMateriali
},
596 { "glMaterialiv", (GLvoid
*) glMaterialiv
},
597 { "glMatrixMode", (GLvoid
*) glMatrixMode
},
598 { "glMultMatrixd", (GLvoid
*) glMultMatrixd
},
599 { "glMultMatrixf", (GLvoid
*) glMultMatrixf
},
600 { "glNewList", (GLvoid
*) glNewList
},
601 { "glNormal3b", (GLvoid
*) glNormal3b
},
602 { "glNormal3bv", (GLvoid
*) glNormal3bv
},
603 { "glNormal3d", (GLvoid
*) glNormal3d
},
604 { "glNormal3dv", (GLvoid
*) glNormal3dv
},
605 { "glNormal3f", (GLvoid
*) glNormal3f
},
606 { "glNormal3fv", (GLvoid
*) glNormal3fv
},
607 { "glNormal3i", (GLvoid
*) glNormal3i
},
608 { "glNormal3iv", (GLvoid
*) glNormal3iv
},
609 { "glNormal3s", (GLvoid
*) glNormal3s
},
610 { "glNormal3sv", (GLvoid
*) glNormal3sv
},
611 { "glOrtho", (GLvoid
*) glOrtho
},
612 { "glPassThrough", (GLvoid
*) glPassThrough
},
613 { "glPixelMapfv", (GLvoid
*) glPixelMapfv
},
614 { "glPixelMapuiv", (GLvoid
*) glPixelMapuiv
},
615 { "glPixelMapusv", (GLvoid
*) glPixelMapusv
},
616 { "glPixelStoref", (GLvoid
*) glPixelStoref
},
617 { "glPixelStorei", (GLvoid
*) glPixelStorei
},
618 { "glPixelTransferf", (GLvoid
*) glPixelTransferf
},
619 { "glPixelTransferi", (GLvoid
*) glPixelTransferi
},
620 { "glPixelZoom", (GLvoid
*) glPixelZoom
},
621 { "glPointSize", (GLvoid
*) glPointSize
},
622 { "glPolygonMode", (GLvoid
*) glPolygonMode
},
623 { "glPolygonOffset", (GLvoid
*) glPolygonOffset
},
624 { "glPolygonStipple", (GLvoid
*) glPolygonStipple
},
625 { "glPopAttrib", (GLvoid
*) glPopAttrib
},
626 { "glPopMatrix", (GLvoid
*) glPopMatrix
},
627 { "glPopName", (GLvoid
*) glPopName
},
628 { "glPushAttrib", (GLvoid
*) glPushAttrib
},
629 { "glPushMatrix", (GLvoid
*) glPushMatrix
},
630 { "glPushName", (GLvoid
*) glPushName
},
631 { "glRasterPos2d", (GLvoid
*) glRasterPos2d
},
632 { "glRasterPos2dv", (GLvoid
*) glRasterPos2dv
},
633 { "glRasterPos2f", (GLvoid
*) glRasterPos2f
},
634 { "glRasterPos2fv", (GLvoid
*) glRasterPos2fv
},
635 { "glRasterPos2i", (GLvoid
*) glRasterPos2i
},
636 { "glRasterPos2iv", (GLvoid
*) glRasterPos2iv
},
637 { "glRasterPos2s", (GLvoid
*) glRasterPos2s
},
638 { "glRasterPos2sv", (GLvoid
*) glRasterPos2sv
},
639 { "glRasterPos3d", (GLvoid
*) glRasterPos3d
},
640 { "glRasterPos3dv", (GLvoid
*) glRasterPos3dv
},
641 { "glRasterPos3f", (GLvoid
*) glRasterPos3f
},
642 { "glRasterPos3fv", (GLvoid
*) glRasterPos3fv
},
643 { "glRasterPos3i", (GLvoid
*) glRasterPos3i
},
644 { "glRasterPos3iv", (GLvoid
*) glRasterPos3iv
},
645 { "glRasterPos3s", (GLvoid
*) glRasterPos3s
},
646 { "glRasterPos3sv", (GLvoid
*) glRasterPos3sv
},
647 { "glRasterPos4d", (GLvoid
*) glRasterPos4d
},
648 { "glRasterPos4dv", (GLvoid
*) glRasterPos4dv
},
649 { "glRasterPos4f", (GLvoid
*) glRasterPos4f
},
650 { "glRasterPos4fv", (GLvoid
*) glRasterPos4fv
},
651 { "glRasterPos4i", (GLvoid
*) glRasterPos4i
},
652 { "glRasterPos4iv", (GLvoid
*) glRasterPos4iv
},
653 { "glRasterPos4s", (GLvoid
*) glRasterPos4s
},
654 { "glRasterPos4sv", (GLvoid
*) glRasterPos4sv
},
655 { "glReadBuffer", (GLvoid
*) glReadBuffer
},
656 { "glReadPixels", (GLvoid
*) glReadPixels
},
657 { "glRectd", (GLvoid
*) glRectd
},
658 { "glRectdv", (GLvoid
*) glRectdv
},
659 { "glRectf", (GLvoid
*) glRectf
},
660 { "glRectfv", (GLvoid
*) glRectfv
},
661 { "glRecti", (GLvoid
*) glRecti
},
662 { "glRectiv", (GLvoid
*) glRectiv
},
663 { "glRects", (GLvoid
*) glRects
},
664 { "glRectsv", (GLvoid
*) glRectsv
},
665 { "glRenderMode", (GLvoid
*) glRenderMode
},
666 { "glRotated", (GLvoid
*) glRotated
},
667 { "glRotatef", (GLvoid
*) glRotatef
},
668 { "glScaled", (GLvoid
*) glScaled
},
669 { "glScalef", (GLvoid
*) glScalef
},
670 { "glScissor", (GLvoid
*) glScissor
},
671 { "glSelectBuffer", (GLvoid
*) glSelectBuffer
},
672 { "glShadeModel", (GLvoid
*) glShadeModel
},
673 { "glStencilFunc", (GLvoid
*) glStencilFunc
},
674 { "glStencilMask", (GLvoid
*) glStencilMask
},
675 { "glStencilOp", (GLvoid
*) glStencilOp
},
676 { "glTexCoord1d", (GLvoid
*) glTexCoord1d
},
677 { "glTexCoord1dv", (GLvoid
*) glTexCoord1dv
},
678 { "glTexCoord1f", (GLvoid
*) glTexCoord1f
},
679 { "glTexCoord1fv", (GLvoid
*) glTexCoord1fv
},
680 { "glTexCoord1i", (GLvoid
*) glTexCoord1i
},
681 { "glTexCoord1iv", (GLvoid
*) glTexCoord1iv
},
682 { "glTexCoord1s", (GLvoid
*) glTexCoord1s
},
683 { "glTexCoord1sv", (GLvoid
*) glTexCoord1sv
},
684 { "glTexCoord2d", (GLvoid
*) glTexCoord2d
},
685 { "glTexCoord2dv", (GLvoid
*) glTexCoord2dv
},
686 { "glTexCoord2f", (GLvoid
*) glTexCoord2f
},
687 { "glTexCoord2fv", (GLvoid
*) glTexCoord2fv
},
688 { "glTexCoord2i", (GLvoid
*) glTexCoord2i
},
689 { "glTexCoord2iv", (GLvoid
*) glTexCoord2iv
},
690 { "glTexCoord2s", (GLvoid
*) glTexCoord2s
},
691 { "glTexCoord2sv", (GLvoid
*) glTexCoord2sv
},
692 { "glTexCoord3d", (GLvoid
*) glTexCoord3d
},
693 { "glTexCoord3dv", (GLvoid
*) glTexCoord3dv
},
694 { "glTexCoord3f", (GLvoid
*) glTexCoord3f
},
695 { "glTexCoord3fv", (GLvoid
*) glTexCoord3fv
},
696 { "glTexCoord3i", (GLvoid
*) glTexCoord3i
},
697 { "glTexCoord3iv", (GLvoid
*) glTexCoord3iv
},
698 { "glTexCoord3s", (GLvoid
*) glTexCoord3s
},
699 { "glTexCoord3sv", (GLvoid
*) glTexCoord3sv
},
700 { "glTexCoord4d", (GLvoid
*) glTexCoord4d
},
701 { "glTexCoord4dv", (GLvoid
*) glTexCoord4dv
},
702 { "glTexCoord4f", (GLvoid
*) glTexCoord4f
},
703 { "glTexCoord4fv", (GLvoid
*) glTexCoord4fv
},
704 { "glTexCoord4i", (GLvoid
*) glTexCoord4i
},
705 { "glTexCoord4iv", (GLvoid
*) glTexCoord4iv
},
706 { "glTexCoord4s", (GLvoid
*) glTexCoord4s
},
707 { "glTexCoord4sv", (GLvoid
*) glTexCoord4sv
},
708 { "glTexEnvf", (GLvoid
*) glTexEnvf
},
709 { "glTexEnvfv", (GLvoid
*) glTexEnvfv
},
710 { "glTexEnvi", (GLvoid
*) glTexEnvi
},
711 { "glTexEnviv", (GLvoid
*) glTexEnviv
},
712 { "glTexGend", (GLvoid
*) glTexGend
},
713 { "glTexGendv", (GLvoid
*) glTexGendv
},
714 { "glTexGenf", (GLvoid
*) glTexGenf
},
715 { "glTexGenfv", (GLvoid
*) glTexGenfv
},
716 { "glTexGeni", (GLvoid
*) glTexGeni
},
717 { "glTexGeniv", (GLvoid
*) glTexGeniv
},
718 { "glTexImage1D", (GLvoid
*) glTexImage1D
},
719 { "glTexImage2D", (GLvoid
*) glTexImage2D
},
720 { "glTexParameterf", (GLvoid
*) glTexParameterf
},
721 { "glTexParameterfv", (GLvoid
*) glTexParameterfv
},
722 { "glTexParameteri", (GLvoid
*) glTexParameteri
},
723 { "glTexParameteriv", (GLvoid
*) glTexParameteriv
},
724 { "glTranslated", (GLvoid
*) glTranslated
},
725 { "glTranslatef", (GLvoid
*) glTranslatef
},
726 { "glVertex2d", (GLvoid
*) glVertex2d
},
727 { "glVertex2dv", (GLvoid
*) glVertex2dv
},
728 { "glVertex2f", (GLvoid
*) glVertex2f
},
729 { "glVertex2fv", (GLvoid
*) glVertex2fv
},
730 { "glVertex2i", (GLvoid
*) glVertex2i
},
731 { "glVertex2iv", (GLvoid
*) glVertex2iv
},
732 { "glVertex2s", (GLvoid
*) glVertex2s
},
733 { "glVertex2sv", (GLvoid
*) glVertex2sv
},
734 { "glVertex3d", (GLvoid
*) glVertex3d
},
735 { "glVertex3dv", (GLvoid
*) glVertex3dv
},
736 { "glVertex3f", (GLvoid
*) glVertex3f
},
737 { "glVertex3fv", (GLvoid
*) glVertex3fv
},
738 { "glVertex3i", (GLvoid
*) glVertex3i
},
739 { "glVertex3iv", (GLvoid
*) glVertex3iv
},
740 { "glVertex3s", (GLvoid
*) glVertex3s
},
741 { "glVertex3sv", (GLvoid
*) glVertex3sv
},
742 { "glVertex4d", (GLvoid
*) glVertex4d
},
743 { "glVertex4dv", (GLvoid
*) glVertex4dv
},
744 { "glVertex4f", (GLvoid
*) glVertex4f
},
745 { "glVertex4fv", (GLvoid
*) glVertex4fv
},
746 { "glVertex4i", (GLvoid
*) glVertex4i
},
747 { "glVertex4iv", (GLvoid
*) glVertex4iv
},
748 { "glVertex4s", (GLvoid
*) glVertex4s
},
749 { "glVertex4sv", (GLvoid
*) glVertex4sv
},
750 { "glViewport", (GLvoid
*) glViewport
},
753 { "glAreTexturesResident", (GLvoid
*) glAreTexturesResident
},
754 { "glArrayElement", (GLvoid
*) glArrayElement
},
755 { "glBindTexture", (GLvoid
*) glBindTexture
},
756 { "glColorPointer", (GLvoid
*) glColorPointer
},
757 { "glCopyTexImage1D", (GLvoid
*) glCopyTexImage1D
},
758 { "glCopyTexImage2D", (GLvoid
*) glCopyTexImage2D
},
759 { "glCopyTexSubImage1D", (GLvoid
*) glCopyTexSubImage1D
},
760 { "glCopyTexSubImage2D", (GLvoid
*) glCopyTexSubImage2D
},
761 { "glDeleteTextures", (GLvoid
*) glDeleteTextures
},
762 { "glDisableClientState", (GLvoid
*) glDisableClientState
},
763 { "glDrawArrays", (GLvoid
*) glDrawArrays
},
764 { "glDrawElements", (GLvoid
*) glDrawElements
},
765 { "glEdgeFlagPointer", (GLvoid
*) glEdgeFlagPointer
},
766 { "glEnableClientState", (GLvoid
*) glEnableClientState
},
767 { "glGenTextures", (GLvoid
*) glGenTextures
},
768 { "glGetPointerv", (GLvoid
*) glGetPointerv
},
769 { "glIndexPointer", (GLvoid
*) glIndexPointer
},
770 { "glIndexub", (GLvoid
*) glIndexub
},
771 { "glIndexubv", (GLvoid
*) glIndexubv
},
772 { "glInterleavedArrays", (GLvoid
*) glInterleavedArrays
},
773 { "glIsTexture", (GLvoid
*) glIsTexture
},
774 { "glNormalPointer", (GLvoid
*) glNormalPointer
},
775 { "glPopClientAttrib", (GLvoid
*) glPopClientAttrib
},
776 { "glPrioritizeTextures", (GLvoid
*) glPrioritizeTextures
},
777 { "glPushClientAttrib", (GLvoid
*) glPushClientAttrib
},
778 { "glTexCoordPointer", (GLvoid
*) glTexCoordPointer
},
779 { "glTexSubImage1D", (GLvoid
*) glTexSubImage1D
},
780 { "glTexSubImage2D", (GLvoid
*) glTexSubImage2D
},
781 { "glVertexPointer", (GLvoid
*) glVertexPointer
},
784 { "glCopyTexSubImage3D", (GLvoid
*) glCopyTexSubImage3D
},
785 { "glDrawRangeElements", (GLvoid
*) glDrawRangeElements
},
786 { "glTexImage3D", (GLvoid
*) glTexImage3D
},
787 { "glTexSubImage3D", (GLvoid
*) glTexSubImage3D
},
790 { "glBlendColor", (GLvoid
*) glBlendColor
},
791 { "glBlendEquation", (GLvoid
*) glBlendEquation
},
792 { "glColorSubTable", (GLvoid
*) glColorSubTable
},
793 { "glColorTable", (GLvoid
*) glColorTable
},
794 { "glColorTableParameterfv", (GLvoid
*) glColorTableParameterfv
},
795 { "glColorTableParameteriv", (GLvoid
*) glColorTableParameteriv
},
796 { "glConvolutionFilter1D", (GLvoid
*) glConvolutionFilter1D
},
797 { "glConvolutionFilter2D", (GLvoid
*) glConvolutionFilter2D
},
798 { "glConvolutionParameterf", (GLvoid
*) glConvolutionParameterf
},
799 { "glConvolutionParameterfv", (GLvoid
*) glConvolutionParameterfv
},
800 { "glConvolutionParameteri", (GLvoid
*) glConvolutionParameteri
},
801 { "glConvolutionParameteriv", (GLvoid
*) glConvolutionParameteriv
},
802 { "glCopyColorSubTable", (GLvoid
*) glCopyColorSubTable
},
803 { "glCopyColorTable", (GLvoid
*) glCopyColorTable
},
804 { "glCopyConvolutionFilter1D", (GLvoid
*) glCopyConvolutionFilter1D
},
805 { "glCopyConvolutionFilter2D", (GLvoid
*) glCopyConvolutionFilter2D
},
806 { "glGetColorTable", (GLvoid
*) glGetColorTable
},
807 { "glGetColorTableParameterfv", (GLvoid
*) glGetColorTableParameterfv
},
808 { "glGetColorTableParameteriv", (GLvoid
*) glGetColorTableParameteriv
},
809 { "glGetConvolutionFilter", (GLvoid
*) glGetConvolutionFilter
},
810 { "glGetConvolutionParameterfv", (GLvoid
*) glGetConvolutionParameterfv
},
811 { "glGetConvolutionParameteriv", (GLvoid
*) glGetConvolutionParameteriv
},
812 { "glGetHistogram", (GLvoid
*) glGetHistogram
},
813 { "glGetHistogramParameterfv", (GLvoid
*) glGetHistogramParameterfv
},
814 { "glGetHistogramParameteriv", (GLvoid
*) glGetHistogramParameteriv
},
815 { "glGetMinmax", (GLvoid
*) glGetMinmax
},
816 { "glGetMinmaxParameterfv", (GLvoid
*) glGetMinmaxParameterfv
},
817 { "glGetMinmaxParameteriv", (GLvoid
*) glGetMinmaxParameteriv
},
818 { "glGetSeparableFilter", (GLvoid
*) glGetSeparableFilter
},
819 { "glHistogram", (GLvoid
*) glHistogram
},
820 { "glMinmax", (GLvoid
*) glMinmax
},
821 { "glResetHistogram", (GLvoid
*) glResetHistogram
},
822 { "glResetMinmax", (GLvoid
*) glResetMinmax
},
823 { "glSeparableFilter2D", (GLvoid
*) glSeparableFilter2D
},
825 /* GL_ARB_multitexture */
826 { "glActiveTextureARB", (GLvoid
*) glActiveTextureARB
},
827 { "glClientActiveTextureARB", (GLvoid
*) glClientActiveTextureARB
},
828 { "glMultiTexCoord1dARB", (GLvoid
*) glMultiTexCoord1dARB
},
829 { "glMultiTexCoord1dvARB", (GLvoid
*) glMultiTexCoord1dvARB
},
830 { "glMultiTexCoord1fARB", (GLvoid
*) glMultiTexCoord1fARB
},
831 { "glMultiTexCoord1fvARB", (GLvoid
*) glMultiTexCoord1fvARB
},
832 { "glMultiTexCoord1iARB", (GLvoid
*) glMultiTexCoord1iARB
},
833 { "glMultiTexCoord1ivARB", (GLvoid
*) glMultiTexCoord1ivARB
},
834 { "glMultiTexCoord1sARB", (GLvoid
*) glMultiTexCoord1sARB
},
835 { "glMultiTexCoord1svARB", (GLvoid
*) glMultiTexCoord1svARB
},
836 { "glMultiTexCoord2dARB", (GLvoid
*) glMultiTexCoord2dARB
},
837 { "glMultiTexCoord2dvARB", (GLvoid
*) glMultiTexCoord2dvARB
},
838 { "glMultiTexCoord2fARB", (GLvoid
*) glMultiTexCoord2fARB
},
839 { "glMultiTexCoord2fvARB", (GLvoid
*) glMultiTexCoord2fvARB
},
840 { "glMultiTexCoord2iARB", (GLvoid
*) glMultiTexCoord2iARB
},
841 { "glMultiTexCoord2ivARB", (GLvoid
*) glMultiTexCoord2ivARB
},
842 { "glMultiTexCoord2sARB", (GLvoid
*) glMultiTexCoord2sARB
},
843 { "glMultiTexCoord2svARB", (GLvoid
*) glMultiTexCoord2svARB
},
844 { "glMultiTexCoord3dARB", (GLvoid
*) glMultiTexCoord3dARB
},
845 { "glMultiTexCoord3dvARB", (GLvoid
*) glMultiTexCoord3dvARB
},
846 { "glMultiTexCoord3fARB", (GLvoid
*) glMultiTexCoord3fARB
},
847 { "glMultiTexCoord3fvARB", (GLvoid
*) glMultiTexCoord3fvARB
},
848 { "glMultiTexCoord3iARB", (GLvoid
*) glMultiTexCoord3iARB
},
849 { "glMultiTexCoord3ivARB", (GLvoid
*) glMultiTexCoord3ivARB
},
850 { "glMultiTexCoord3sARB", (GLvoid
*) glMultiTexCoord3sARB
},
851 { "glMultiTexCoord3svARB", (GLvoid
*) glMultiTexCoord3svARB
},
852 { "glMultiTexCoord4dARB", (GLvoid
*) glMultiTexCoord4dARB
},
853 { "glMultiTexCoord4dvARB", (GLvoid
*) glMultiTexCoord4dvARB
},
854 { "glMultiTexCoord4fARB", (GLvoid
*) glMultiTexCoord4fARB
},
855 { "glMultiTexCoord4fvARB", (GLvoid
*) glMultiTexCoord4fvARB
},
856 { "glMultiTexCoord4iARB", (GLvoid
*) glMultiTexCoord4iARB
},
857 { "glMultiTexCoord4ivARB", (GLvoid
*) glMultiTexCoord4ivARB
},
858 { "glMultiTexCoord4sARB", (GLvoid
*) glMultiTexCoord4sARB
},
859 { "glMultiTexCoord4svARB", (GLvoid
*) glMultiTexCoord4svARB
},
861 /* 2. GL_EXT_blend_color */
862 { "glBlendColorEXT", (GLvoid
*) glBlendColorEXT
},
864 /* 3. GL_EXT_polygon_offset */
865 { "glPolygonOffsetEXT", (GLvoid
*) glPolygonOffsetEXT
},
867 /* 6. GL_EXT_texture3D */
868 { "glCopyTexSubImage3DEXT", (GLvoid
*) glCopyTexSubImage3DEXT
},
869 { "glTexImage3DEXT", (GLvoid
*) glTexImage3DEXT
},
870 { "glTexSubImage3DEXT", (GLvoid
*) glTexSubImage3DEXT
},
872 /* 7. GL_SGI_texture_filter4 */
873 { "glGetTexFilterFuncSGIS", (GLvoid
*) glGetTexFilterFuncSGIS
},
874 { "glTexFilterFuncSGIS", (GLvoid
*) glTexFilterFuncSGIS
},
876 /* 9. GL_EXT_subtexture */
877 { "glTexSubImage1DEXT", (GLvoid
*) glTexSubImage1DEXT
},
878 { "glTexSubImage2DEXT", (GLvoid
*) glTexSubImage2DEXT
},
880 /* 10. GL_EXT_copy_texture */
881 { "glCopyTexImage1DEXT", (GLvoid
*) glCopyTexImage1DEXT
},
882 { "glCopyTexImage2DEXT", (GLvoid
*) glCopyTexImage2DEXT
},
883 { "glCopyTexSubImage1DEXT", (GLvoid
*) glCopyTexSubImage1DEXT
},
884 { "glCopyTexSubImage2DEXT", (GLvoid
*) glCopyTexSubImage2DEXT
},
886 /* 11. GL_EXT_histogram */
887 { "glGetHistogramEXT", (GLvoid
*) glGetHistogramEXT
},
888 { "glGetHistogramParameterfvEXT", (GLvoid
*) glGetHistogramParameterfvEXT
},
889 { "glGetHistogramParameterivEXT", (GLvoid
*) glGetHistogramParameterivEXT
},
890 { "glGetMinmaxEXT", (GLvoid
*) glGetMinmaxEXT
},
891 { "glGetMinmaxParameterfvEXT", (GLvoid
*) glGetMinmaxParameterfvEXT
},
892 { "glGetMinmaxParameterivEXT", (GLvoid
*) glGetMinmaxParameterivEXT
},
893 { "glHistogramEXT", (GLvoid
*) glHistogramEXT
},
894 { "glMinmaxEXT", (GLvoid
*) glMinmaxEXT
},
895 { "glResetHistogramEXT", (GLvoid
*) glResetHistogramEXT
},
896 { "glResetMinmaxEXT", (GLvoid
*) glResetMinmaxEXT
},
898 /* 12. GL_EXT_convolution */
899 { "glConvolutionFilter1DEXT", (GLvoid
*) glConvolutionFilter1DEXT
},
900 { "glConvolutionFilter2DEXT", (GLvoid
*) glConvolutionFilter2DEXT
},
901 { "glConvolutionParameterfEXT", (GLvoid
*) glConvolutionParameterfEXT
},
902 { "glConvolutionParameterfvEXT", (GLvoid
*) glConvolutionParameterfvEXT
},
903 { "glConvolutionParameteriEXT", (GLvoid
*) glConvolutionParameteriEXT
},
904 { "glConvolutionParameterivEXT", (GLvoid
*) glConvolutionParameterivEXT
},
905 { "glCopyConvolutionFilter1DEXT", (GLvoid
*) glCopyConvolutionFilter1DEXT
},
906 { "glCopyConvolutionFilter2DEXT", (GLvoid
*) glCopyConvolutionFilter2DEXT
},
907 { "glGetConvolutionFilterEXT", (GLvoid
*) glGetConvolutionFilterEXT
},
908 { "glGetConvolutionParameterivEXT", (GLvoid
*) glGetConvolutionParameterivEXT
},
909 { "glGetConvolutionParameterfvEXT", (GLvoid
*) glGetConvolutionParameterfvEXT
},
910 { "glGetSeparableFilterEXT", (GLvoid
*) glGetSeparableFilterEXT
},
911 { "glSeparableFilter2DEXT", (GLvoid
*) glSeparableFilter2DEXT
},
913 /* 14. GL_SGI_color_table */
914 { "glColorTableSGI", (GLvoid
*) NotImplemented
},
915 { "glColorTableParameterfvSGI", (GLvoid
*) NotImplemented
},
916 { "glColorTableParameterivSGI", (GLvoid
*) NotImplemented
},
917 { "glCopyColorTableSGI", (GLvoid
*) NotImplemented
},
918 { "glGetColorTableSGI", (GLvoid
*) NotImplemented
},
919 { "glGetColorTableParameterfvSGI", (GLvoid
*) NotImplemented
},
920 { "glGetColorTableParameterivSGI", (GLvoid
*) NotImplemented
},
922 /* 15. GL_SGIS_pixel_texture */
923 { "glPixelTexGenParameterfSGIS", (GLvoid
*) NotImplemented
},
924 { "glPixelTexGenParameteriSGIS", (GLvoid
*) NotImplemented
},
925 { "glGetPixelTexGenParameterfvSGIS", (GLvoid
*) NotImplemented
},
926 { "glGetPixelTexGenParameterivSGIS", (GLvoid
*) NotImplemented
},
928 /* 16. GL_SGIS_texture4D */
929 { "glTexImage4DSGIS", (GLvoid
*) NotImplemented
},
930 { "glTexSubImage4DSGIS", (GLvoid
*) NotImplemented
},
932 /* 20. GL_EXT_texture_object */
933 { "glAreTexturesResidentEXT", (GLvoid
*) glAreTexturesResidentEXT
},
934 { "glBindTextureEXT", (GLvoid
*) glBindTextureEXT
},
935 { "glDeleteTexturesEXT", (GLvoid
*) glDeleteTexturesEXT
},
936 { "glGenTexturesEXT", (GLvoid
*) glGenTexturesEXT
},
937 { "glIsTextureEXT", (GLvoid
*) glIsTextureEXT
},
938 { "glPrioritizeTexturesEXT", (GLvoid
*) glPrioritizeTexturesEXT
},
940 /* 21. GL_SGIS_detail_texture */
941 { "glDetailTexFuncSGIS", (GLvoid
*) NotImplemented
},
942 { "glGetDetailTexFuncSGIS", (GLvoid
*) NotImplemented
},
944 /* 22. GL_SGIS_sharpen_texture */
945 { "glGetSharpenTexFuncSGIS", (GLvoid
*) NotImplemented
},
946 { "glSharpenTexFuncSGIS", (GLvoid
*) NotImplemented
},
948 /* 25. GL_SGIS_multisample */
949 { "glSampleMaskSGIS", (GLvoid
*) NotImplemented
},
950 { "glSamplePatternSGIS", (GLvoid
*) NotImplemented
},
952 /* 30. GL_EXT_vertex_array */
953 { "glArrayElementEXT", (GLvoid
*) glArrayElementEXT
},
954 { "glColorPointerEXT", (GLvoid
*) glColorPointerEXT
},
955 { "glDrawArraysEXT", (GLvoid
*) glDrawArraysEXT
},
956 { "glEdgeFlagPointerEXT", (GLvoid
*) glEdgeFlagPointerEXT
},
957 { "glGetPointervEXT", (GLvoid
*) glGetPointervEXT
},
958 { "glIndexPointerEXT", (GLvoid
*) glIndexPointerEXT
},
959 { "glNormalPointerEXT", (GLvoid
*) glNormalPointerEXT
},
960 { "glTexCoordPointerEXT", (GLvoid
*) glTexCoordPointerEXT
},
961 { "glVertexPointerEXT", (GLvoid
*) glVertexPointerEXT
},
963 /* 37. GL_EXT_blend_minmax */
964 { "glBlendEquationEXT", (GLvoid
*) glBlendEquationEXT
},
966 /* 52. GL_SGIX_sprite */
967 { "glSpriteParameterfSGIX", (GLvoid
*) NotImplemented
},
968 { "glSpriteParameterfvSGIX", (GLvoid
*) NotImplemented
},
969 { "glSpriteParameteriSGIX", (GLvoid
*) NotImplemented
},
970 { "glSpriteParameterivSGIX", (GLvoid
*) NotImplemented
},
972 /* 54. GL_EXT_point_parameters */
973 { "glPointParameterfEXT", (GLvoid
*) NotImplemented
},
974 { "glPointParameterfvEXT", (GLvoid
*) NotImplemented
},
976 /* 55. GL_SGIX_instruments */
977 { "glInstrumentsBufferSGIX", (GLvoid
*) NotImplemented
},
978 { "glStartInstrumentsSGIX", (GLvoid
*) NotImplemented
},
979 { "glStopInstrumentsSGIX", (GLvoid
*) NotImplemented
},
980 { "glReadInstrumentsSGIX", (GLvoid
*) NotImplemented
},
981 { "glPollInstrumentsSGIX", (GLvoid
*) NotImplemented
},
982 { "glGetInstrumentsSGIX", (GLvoid
*) NotImplemented
},
984 /* 57. GL_SGIX_framezoom */
985 { "glFrameZoomSGIX", (GLvoid
*) NotImplemented
},
987 /* 60. GL_SGIX_reference_plane */
988 { "glReferencePlaneSGIX", (GLvoid
*) NotImplemented
},
990 /* 61. GL_SGIX_flush_raster */
991 { "glFlushRasterSGIX", (GLvoid
*) NotImplemented
},
993 /* 66. GL_HP_image_transform */
994 { "glGetImageTransformParameterfvHP", (GLvoid
*) NotImplemented
},
995 { "glGetImageTransformParameterivHP", (GLvoid
*) NotImplemented
},
996 { "glImageTransformParameterfHP", (GLvoid
*) NotImplemented
},
997 { "glImageTransformParameterfvHP", (GLvoid
*) NotImplemented
},
998 { "glImageTransformParameteriHP", (GLvoid
*) NotImplemented
},
999 { "glImageTransformParameterivHP", (GLvoid
*) NotImplemented
},
1001 /* 74. GL_EXT_color_subtable */
1002 { "glColorSubTableEXT", (GLvoid
*) NotImplemented
},
1003 { "glCopyColorSubTableEXT", (GLvoid
*) NotImplemented
},
1005 /* 77. GL_PGI_misc_hints */
1006 { "glHintPGI", (GLvoid
*) NotImplemented
},
1008 /* 78. GL_EXT_paletted_texture */
1009 { "glColorTableEXT", (GLvoid
*) glColorTableEXT
},
1010 { "glGetColorTableEXT", (GLvoid
*) glGetColorTableEXT
},
1011 { "glGetColorTableParameterfvEXT", (GLvoid
*) glGetColorTableParameterfvEXT
},
1012 { "glGetColorTableParameterivEXT", (GLvoid
*) glGetColorTableParameterivEXT
},
1014 /* 80. GL_SGIX_list_priority */
1015 { "glGetListParameterfvSGIX", (GLvoid
*) NotImplemented
},
1016 { "glGetListParameterivSGIX", (GLvoid
*) NotImplemented
},
1017 { "glListParameterfSGIX", (GLvoid
*) NotImplemented
},
1018 { "glListParameterfvSGIX", (GLvoid
*) NotImplemented
},
1019 { "glListParameteriSGIX", (GLvoid
*) NotImplemented
},
1020 { "glListParameterivSGIX", (GLvoid
*) NotImplemented
},
1022 /* 94. GL_EXT_index_material */
1023 { "glIndexMaterialEXT", (GLvoid
*) NotImplemented
},
1025 /* 95. GL_EXT_index_func */
1026 { "glIndexFuncEXT", (GLvoid
*) NotImplemented
},
1028 /* 97. GL_EXT_compiled_vertex_array */
1029 { "glLockArraysEXT", (GLvoid
*) glLockArraysEXT
},
1030 { "glUnlockArraysEXT", (GLvoid
*) glUnlockArraysEXT
},
1032 /* 98. GL_EXT_cull_vertex */
1033 { "glCullParameterfvEXT", (GLvoid
*) NotImplemented
},
1034 { "glCullParameterdvEXT", (GLvoid
*) NotImplemented
},
1036 /* 173. GL_EXT/INGR_blend_func_separate */
1037 { "glBlendFuncSeparateINGR", (GLvoid
*) glBlendFuncSeparateINGR
},
1039 /* GL_MESA_window_pos */
1040 { "glWindowPos4fMESA", (GLvoid
*) glWindowPos4fMESA
},
1042 /* GL_MESA_resize_buffers */
1043 { "glResizeBuffersMESA", (GLvoid
*) glResizeBuffersMESA
},
1045 /* GL_ARB_transpose_matrix */
1046 { "glLoadTransposeMatrixdARB", (GLvoid
*) glLoadTransposeMatrixdARB
},
1047 { "glLoadTransposeMatrixfARB", (GLvoid
*) glLoadTransposeMatrixfARB
},
1048 { "glMultTransposeMatrixdARB", (GLvoid
*) glMultTransposeMatrixdARB
},
1049 { "glMultTransposeMatrixfARB", (GLvoid
*) glMultTransposeMatrixfARB
},
1051 { NULL
, NULL
} /* end of list marker */