blob: 091932bf03bc97c2d71d80281a5af5cd1061aef2 [file] [log] [blame]
Brian Paul6ef84ac1999-12-16 17:33:43 +00001/* $Id: glapi.c,v 1.16 1999/12/16 17:33:43 brianp Exp $ */
Brian Paulfbd8f211999-11-11 01:22:25 +00002
3/*
4 * Mesa 3-D graphics library
5 * Version: 3.3
6 *
7 * Copyright (C) 1999 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
Brian Paul7e1161b1999-11-25 18:17:04 +000028/*
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
37
38
Brian Paulfbd8f211999-11-11 01:22:25 +000039#include <assert.h>
Brian Pauleb1f2821999-11-11 15:26:45 +000040#include <stdlib.h> /* to get NULL */
Brian Paul7fb54ae1999-11-19 22:33:50 +000041#include <string.h>
Brian Paulfbd8f211999-11-11 01:22:25 +000042#include "glapi.h"
43#include "glapinoop.h"
Brian Paul0c239fc1999-12-16 12:38:11 +000044#include "glapioffsets.h"
45#include "glapitable.h"
46
Brian Paulbb72d321999-12-16 17:31:59 +000047#include <stdio.h>
48
Brian Paulfbd8f211999-11-11 01:22:25 +000049
50
Brian Paul0f710251999-12-15 15:02:30 +000051/* Flag to indicate whether thread-safe dispatch is enabled */
Brian Paulbb72d321999-12-16 17:31:59 +000052static GLboolean ThreadSafe = GL_FALSE;
Brian Paulfbd8f211999-11-11 01:22:25 +000053
Brian Paul0f710251999-12-15 15:02:30 +000054/* This is used when thread safety is disabled */
55static struct _glapi_table *Dispatch = &__glapi_noop_table;
56
57
Brian Paul7fb54ae1999-11-19 22:33:50 +000058#if defined(THREADS)
Brian Paulbb72d321999-12-16 17:31:59 +000059
60#include "glthread.h"
61
62static _glthread_TSD DispatchTSD;
63
64static void dispatch_thread_init()
65{
66 _glthread_InitTSD(&DispatchTSD);
Brian Paul7fb54ae1999-11-19 22:33:50 +000067}
Brian Paulbb72d321999-12-16 17:31:59 +000068
Brian Paul0f710251999-12-15 15:02:30 +000069#endif
70
71
72
Brian Paulbb72d321999-12-16 17:31:59 +000073static GLuint MaxDispatchOffset = sizeof(struct _glapi_table) / sizeof(void *) - 1;
Brian Paul0f710251999-12-15 15:02:30 +000074static GLboolean GetSizeCalled = GL_FALSE;
Brian Paulfbd8f211999-11-11 01:22:25 +000075
Brian Paul7fb54ae1999-11-19 22:33:50 +000076
Brian Paulbb72d321999-12-16 17:31:59 +000077
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 */
83void
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/*
Brian Paul7fb54ae1999-11-19 22:33:50 +0000110 * Set the global or per-thread dispatch table pointer.
111 */
112void
113_glapi_set_dispatch(struct _glapi_table *dispatch)
114{
115 if (!dispatch) {
116 /* use the no-op functions */
117 dispatch = &__glapi_noop_table;
118 }
119#ifdef DEBUG
120 else {
121 _glapi_check_table(dispatch);
122 }
123#endif
124
125#if defined(THREADS)
Brian Paulbb72d321999-12-16 17:31:59 +0000126 _glthread_SetTSD(&DispatchTSD, (void*) dispatch, dispatch_thread_init);
Brian Paul7fb54ae1999-11-19 22:33:50 +0000127#else
128 Dispatch = dispatch;
129#endif
130}
131
132
Brian Paulbb72d321999-12-16 17:31:59 +0000133
Brian Paul7fb54ae1999-11-19 22:33:50 +0000134/*
Brian Paulbb72d321999-12-16 17:31:59 +0000135 * Return pointer to current dispatch table for calling thread.
Brian Paul7fb54ae1999-11-19 22:33:50 +0000136 */
137struct _glapi_table *
138_glapi_get_dispatch(void)
139{
140#if defined(THREADS)
Brian Paulbb72d321999-12-16 17:31:59 +0000141 if (ThreadSafe) {
142 return (struct _glapi_table *) _glthread_GetTSD(&DispatchTSD);
143 }
144 else
145 return Dispatch;
Brian Paul7fb54ae1999-11-19 22:33:50 +0000146#else
147 return Dispatch;
148#endif
149}
150
151
Brian Paul91bcefa1999-11-27 21:30:40 +0000152
153/*
154 * Return size of dispatch table struct as number of functions (or
155 * slots).
156 */
157GLuint
158_glapi_get_dispatch_table_size(void)
159{
Brian Paul0f710251999-12-15 15:02:30 +0000160 /* return sizeof(struct _glapi_table) / sizeof(void *);*/
161 GetSizeCalled = GL_TRUE;
162 return MaxDispatchOffset + 1;
Brian Paul91bcefa1999-11-27 21:30:40 +0000163}
164
165
166
Brian Paul7fb54ae1999-11-19 22:33:50 +0000167/*
168 * Get API dispatcher version string.
169 * XXX this isn't well defined yet.
170 */
171const char *
172_glapi_get_version(void)
173{
174 return "1.2";
175}
176
177
Brian Paul91bcefa1999-11-27 21:30:40 +0000178struct name_address_pair {
Brian Paul7fb54ae1999-11-19 22:33:50 +0000179 const char *Name;
Brian Paul91bcefa1999-11-27 21:30:40 +0000180 GLvoid *Address;
Brian Paul7fb54ae1999-11-19 22:33:50 +0000181};
182
Brian Paul0c239fc1999-12-16 12:38:11 +0000183static struct name_address_pair static_functions[1000];
184
185
186
187/*
188 * Return dispatch table offset of the named static (built-in) function.
189 * Return -1 if function not found.
190 */
191static GLint
192get_static_proc_offset(const char *funcName)
193{
194 GLuint i;
195 for (i = 0; static_functions[i].Name; i++) {
196 if (strcmp(static_functions[i].Name, funcName) == 0) {
197 return i;
198 }
199 }
200 return -1;
201}
202
203
204/*
205 * Return dispatch function address the named static (built-in) function.
206 * Return NULL if function not found.
207 */
208static GLvoid *
209get_static_proc_address(const char *funcName)
210{
211 GLuint i = get_static_proc_offset(funcName);
212 if (i >= 0)
213 return static_functions[i].Address;
214 else
215 return NULL;
216}
217
218
219
220/**********************************************************************
221 * Extension function management.
Brian Paulbb72d321999-12-16 17:31:59 +0000222 */
Brian Paul0c239fc1999-12-16 12:38:11 +0000223
224
225struct _glapi_ext_entrypoint {
226 const char *Name; /* the extension function's name */
227 GLuint Offset; /* relative to start of dispatch table */
228 GLvoid *Address; /* address of dispatch function */
229};
230
231static struct _glapi_ext_entrypoint ExtEntryTable[_GLAPI_EXTRA_SLOTS];
232static GLuint NumExtEntryPoints = 0;
233
234
235
236/*
237 * Generate a dispatch function (entrypoint) which jumps through
238 * the given slot number (offset) in the current dispatch table.
239 */
240static void *
241generate_entrypoint(GLuint offset)
242{
243 /* XXX need to generate some assembly code here */
244
245 return NULL;
246}
247
248
249
250/*
251 * Add a new extension function entrypoint.
252 * Return: GL_TRUE = success or GL_FALSE = failure
253 */
254GLboolean
255_glapi_add_entrypoint(const char *funcName, GLuint offset)
256{
257 GLint index;
258
259 /* Make sure we don't try to add a new entrypoint after someone
260 * has already called _glapi_get_dispatch_table_size()! If that's
261 * happened the caller's information will now be out of date.
262 */
263 assert(!GetSizeCalled);
264
265 /* first check if the named function is already statically present */
266 index = get_static_proc_offset(funcName);
267
268 if (index >= 0) {
269 assert(index == offset);
270 return GL_TRUE;
271 }
272 /* else if (offset < _glapi_get_dispatch_table_size()) { */
273 else {
274 /* be sure index and name match known data */
275 GLuint i;
276 for (i = 0; i < NumExtEntryPoints; i++) {
277 if (strcmp(ExtEntryTable[i].Name, funcName) == 0) {
278 /* function already registered with api */
279 if (ExtEntryTable[i].Offset == offset) {
280 return GL_TRUE; /* offsets match */
281 }
282 else {
283 return GL_FALSE; /* bad offset! */
284 }
285 }
286 }
287 assert(NumExtEntryPoints < _GLAPI_EXTRA_SLOTS);
288 ExtEntryTable[NumExtEntryPoints].Name = strdup(funcName);
289 ExtEntryTable[NumExtEntryPoints].Offset = offset;
290 ExtEntryTable[NumExtEntryPoints].Address = generate_entrypoint(offset);
291 NumExtEntryPoints++;
292
293 if (offset > MaxDispatchOffset)
294 MaxDispatchOffset = offset;
295
296 return GL_TRUE;
297 }
298/*
299 else {
300 return GL_FALSE;
301 }
302*/
303}
304
305
306
307/*
308 * Return offset of entrypoint for named function within dispatch table.
309 */
310GLint
311_glapi_get_proc_offset(const char *funcName)
312{
313 /* search extension functions first */
314 GLint i;
315 for (i = 0; i < NumExtEntryPoints; i++) {
316 if (strcmp(ExtEntryTable[i].Name, funcName) == 0) {
317 return ExtEntryTable[i].Offset;
318 }
319 }
320
321 /* search static functions */
322 return get_static_proc_offset(funcName);
323}
324
325
326
327/*
328 * Return entrypoint for named function.
329 */
330const GLvoid *
331_glapi_get_proc_address(const char *funcName)
332{
333 /* search extension functions first */
334 GLint i;
335 for (i = 0; i < NumExtEntryPoints; i++) {
336 if (strcmp(ExtEntryTable[i].Name, funcName) == 0) {
337 return ExtEntryTable[i].Address;
338 }
339 }
340
341 /* search static functions */
342 return get_static_proc_address(funcName);
343}
344
345
346
347
348/*
349 * Return the name of the function at the given dispatch offset.
350 * This is only intended for debugging.
351 */
352const char *
353_glapi_get_proc_name(GLuint offset)
354{
355 GLuint n = sizeof(static_functions) / sizeof(struct name_address_pair);
356 if (offset < n) {
357 return static_functions[offset].Name;
358 }
359 else {
360 /* search added extension functions */
361 GLuint i;
362 for (i = 0; i < NumExtEntryPoints; i++) {
363 if (ExtEntryTable[i].Offset == offset) {
364 return ExtEntryTable[i].Name;
365 }
366 }
367 return NULL;
368 }
369}
370
371
372
373/*
374 * Make sure there are no NULL pointers in the given dispatch table.
375 * Intented for debugging purposes.
376 */
377void
378_glapi_check_table(const struct _glapi_table *table)
379{
380 const GLuint entries = _glapi_get_dispatch_table_size();
381 const void **tab = (const void **) table;
382 GLuint i;
383 for (i = 1; i < entries; i++) {
384 assert(tab[i]);
385 }
386
387 /* Do some spot checks to be sure that the dispatch table
388 * slots are assigned correctly.
389 */
390 {
391 GLuint BeginOffset = _glapi_get_proc_offset("glBegin");
392 char *BeginFunc = (char*) &table->Begin;
393 GLuint offset = (BeginFunc - (char *) table) / sizeof(void *);
394 assert(BeginOffset == _gloffset_Begin);
395 assert(BeginOffset == offset);
396 }
397 {
398 GLuint viewportOffset = _glapi_get_proc_offset("glViewport");
399 char *viewportFunc = (char*) &table->Viewport;
400 GLuint offset = (viewportFunc - (char *) table) / sizeof(void *);
401 assert(viewportOffset == _gloffset_Viewport);
402 assert(viewportOffset == offset);
403 }
404 {
405 GLuint VertexPointerOffset = _glapi_get_proc_offset("glVertexPointer");
406 char *VertexPointerFunc = (char*) &table->VertexPointer;
407 GLuint offset = (VertexPointerFunc - (char *) table) / sizeof(void *);
408 assert(VertexPointerOffset == _gloffset_VertexPointer);
409 assert(VertexPointerOffset == offset);
410 }
411 {
412 GLuint ResetMinMaxOffset = _glapi_get_proc_offset("glResetMinmax");
413 char *ResetMinMaxFunc = (char*) &table->ResetMinmax;
414 GLuint offset = (ResetMinMaxFunc - (char *) table) / sizeof(void *);
415 assert(ResetMinMaxOffset == _gloffset_ResetMinmax);
416 assert(ResetMinMaxOffset == offset);
417 }
418 {
419 GLuint blendColorOffset = _glapi_get_proc_offset("glBlendColorEXT");
420 char *blendColorFunc = (char*) &table->BlendColorEXT;
421 GLuint offset = (blendColorFunc - (char *) table) / sizeof(void *);
422 assert(blendColorOffset == _gloffset_BlendColorEXT);
423 assert(blendColorOffset == offset);
424 }
425 {
426 GLuint istextureOffset = _glapi_get_proc_offset("glIsTextureEXT");
427 char *istextureFunc = (char*) &table->IsTextureEXT;
428 GLuint offset = (istextureFunc - (char *) table) / sizeof(void *);
429 assert(istextureOffset == _gloffset_IsTextureEXT);
430 assert(istextureOffset == offset);
431 }
432}
433
434
435
Brian Paulbb72d321999-12-16 17:31:59 +0000436/**********************************************************************
Brian Paul0c239fc1999-12-16 12:38:11 +0000437 * Generate the GL entrypoint functions here.
438 */
439
440#define KEYWORD1
441#define KEYWORD2 GLAPIENTRY
442#ifdef USE_MGL_NAMESPACE
443#define NAME(func) mgl##func
444#else
445#define NAME(func) gl##func
446#endif
447
Brian Paulbb72d321999-12-16 17:31:59 +0000448#define DISPATCH_SETUP \
449 const struct _glapi_table *dispatch; \
450 if (ThreadSafe) { \
451 dispatch = _glapi_get_dispatch(); \
452 assert(dispatch); \
453 } \
454 else { \
455 dispatch = Dispatch; \
456 }
457
458#define DISPATCH(FUNC, ARGS) (dispatch->FUNC) ARGS
459
460
461
462
Brian Paul0c239fc1999-12-16 12:38:11 +0000463#include "glapitemp.h"
464
465
466
467/*
468 * For each entry in static_functions[] which use this function
469 * we should implement a dispatch function in glapitemp.h and
470 * in glapinoop.c
471 */
472static void NotImplemented(void)
473{
474}
475
476
477
Brian Paul91bcefa1999-11-27 21:30:40 +0000478static struct name_address_pair static_functions[] = {
Brian Paul0c239fc1999-12-16 12:38:11 +0000479 { "NotImplemented", (GLvoid *) NotImplemented },
480
481 /* GL 1.1 */
Brian Paul91bcefa1999-11-27 21:30:40 +0000482 { "glAccum", (GLvoid *) glAccum },
483 { "glAlphaFunc", (GLvoid *) glAlphaFunc },
484 { "glBegin", (GLvoid *) glBegin },
485 { "glBitmap", (GLvoid *) glBitmap },
486 { "glBlendFunc", (GLvoid *) glBlendFunc },
487 { "glCallList", (GLvoid *) glCallList },
488 { "glCallLists", (GLvoid *) glCallLists },
489 { "glClear", (GLvoid *) glClear },
490 { "glClearAccum", (GLvoid *) glClearAccum },
491 { "glClearColor", (GLvoid *) glClearColor },
492 { "glClearDepth", (GLvoid *) glClearDepth },
493 { "glClearIndex", (GLvoid *) glClearIndex },
494 { "glClearStencil", (GLvoid *) glClearStencil },
495 { "glClipPlane", (GLvoid *) glClipPlane },
496 { "glColor3b", (GLvoid *) glColor3b },
497 { "glColor3bv", (GLvoid *) glColor3bv },
498 { "glColor3d", (GLvoid *) glColor3d },
499 { "glColor3dv", (GLvoid *) glColor3dv },
500 { "glColor3f", (GLvoid *) glColor3f },
501 { "glColor3fv", (GLvoid *) glColor3fv },
502 { "glColor3i", (GLvoid *) glColor3i },
503 { "glColor3iv", (GLvoid *) glColor3iv },
504 { "glColor3s", (GLvoid *) glColor3s },
505 { "glColor3sv", (GLvoid *) glColor3sv },
506 { "glColor3ub", (GLvoid *) glColor3ub },
507 { "glColor3ubv", (GLvoid *) glColor3ubv },
508 { "glColor3ui", (GLvoid *) glColor3ui },
509 { "glColor3uiv", (GLvoid *) glColor3uiv },
510 { "glColor3us", (GLvoid *) glColor3us },
511 { "glColor3usv", (GLvoid *) glColor3usv },
512 { "glColor4b", (GLvoid *) glColor4b },
513 { "glColor4bv", (GLvoid *) glColor4bv },
514 { "glColor4d", (GLvoid *) glColor4d },
515 { "glColor4dv", (GLvoid *) glColor4dv },
516 { "glColor4f", (GLvoid *) glColor4f },
517 { "glColor4fv", (GLvoid *) glColor4fv },
518 { "glColor4i", (GLvoid *) glColor4i },
519 { "glColor4iv", (GLvoid *) glColor4iv },
520 { "glColor4s", (GLvoid *) glColor4s },
521 { "glColor4sv", (GLvoid *) glColor4sv },
522 { "glColor4ub", (GLvoid *) glColor4ub },
523 { "glColor4ubv", (GLvoid *) glColor4ubv },
524 { "glColor4ui", (GLvoid *) glColor4ui },
525 { "glColor4uiv", (GLvoid *) glColor4uiv },
526 { "glColor4us", (GLvoid *) glColor4us },
527 { "glColor4usv", (GLvoid *) glColor4usv },
528 { "glColorMask", (GLvoid *) glColorMask },
529 { "glColorMaterial", (GLvoid *) glColorMaterial },
530 { "glCopyPixels", (GLvoid *) glCopyPixels },
531 { "glCullFace", (GLvoid *) glCullFace },
532 { "glDeleteLists", (GLvoid *) glDeleteLists },
533 { "glDepthFunc", (GLvoid *) glDepthFunc },
534 { "glDepthMask", (GLvoid *) glDepthMask },
535 { "glDepthRange", (GLvoid *) glDepthRange },
536 { "glDisable", (GLvoid *) glDisable },
537 { "glDrawBuffer", (GLvoid *) glDrawBuffer },
538 { "glDrawPixels", (GLvoid *) glDrawPixels },
539 { "glEdgeFlag", (GLvoid *) glEdgeFlag },
540 { "glEdgeFlagv", (GLvoid *) glEdgeFlagv },
541 { "glEnable", (GLvoid *) glEnable },
542 { "glEnd", (GLvoid *) glEnd },
543 { "glEndList", (GLvoid *) glEndList },
544 { "glEvalCoord1d", (GLvoid *) glEvalCoord1d },
545 { "glEvalCoord1dv", (GLvoid *) glEvalCoord1dv },
546 { "glEvalCoord1f", (GLvoid *) glEvalCoord1f },
547 { "glEvalCoord1fv", (GLvoid *) glEvalCoord1fv },
548 { "glEvalCoord2d", (GLvoid *) glEvalCoord2d },
549 { "glEvalCoord2dv", (GLvoid *) glEvalCoord2dv },
550 { "glEvalCoord2f", (GLvoid *) glEvalCoord2f },
551 { "glEvalCoord2fv", (GLvoid *) glEvalCoord2fv },
552 { "glEvalMesh1", (GLvoid *) glEvalMesh1 },
553 { "glEvalMesh2", (GLvoid *) glEvalMesh2 },
554 { "glEvalPoint1", (GLvoid *) glEvalPoint1 },
555 { "glEvalPoint2", (GLvoid *) glEvalPoint2 },
556 { "glFeedbackBuffer", (GLvoid *) glFeedbackBuffer },
557 { "glFinish", (GLvoid *) glFinish },
558 { "glFlush", (GLvoid *) glFlush },
559 { "glFogf", (GLvoid *) glFogf },
560 { "glFogfv", (GLvoid *) glFogfv },
561 { "glFogi", (GLvoid *) glFogi },
562 { "glFogiv", (GLvoid *) glFogiv },
563 { "glFrontFace", (GLvoid *) glFrontFace },
564 { "glFrustum", (GLvoid *) glFrustum },
565 { "glGenLists", (GLvoid *) glGenLists },
566 { "glGetBooleanv", (GLvoid *) glGetBooleanv },
567 { "glGetClipPlane", (GLvoid *) glGetClipPlane },
568 { "glGetDoublev", (GLvoid *) glGetDoublev },
569 { "glGetError", (GLvoid *) glGetError },
570 { "glGetFloatv", (GLvoid *) glGetFloatv },
571 { "glGetIntegerv", (GLvoid *) glGetIntegerv },
572 { "glGetLightfv", (GLvoid *) glGetLightfv },
573 { "glGetLightiv", (GLvoid *) glGetLightiv },
574 { "glGetMapdv", (GLvoid *) glGetMapdv },
575 { "glGetMapfv", (GLvoid *) glGetMapfv },
576 { "glGetMapiv", (GLvoid *) glGetMapiv },
577 { "glGetMaterialfv", (GLvoid *) glGetMaterialfv },
578 { "glGetMaterialiv", (GLvoid *) glGetMaterialiv },
579 { "glGetPixelMapfv", (GLvoid *) glGetPixelMapfv },
580 { "glGetPixelMapuiv", (GLvoid *) glGetPixelMapuiv },
581 { "glGetPixelMapusv", (GLvoid *) glGetPixelMapusv },
582 { "glGetPolygonStipple", (GLvoid *) glGetPolygonStipple },
583 { "glGetString", (GLvoid *) glGetString },
584 { "glGetTexEnvfv", (GLvoid *) glGetTexEnvfv },
585 { "glGetTexEnviv", (GLvoid *) glGetTexEnviv },
586 { "glGetTexGendv", (GLvoid *) glGetTexGendv },
587 { "glGetTexGenfv", (GLvoid *) glGetTexGenfv },
588 { "glGetTexGeniv", (GLvoid *) glGetTexGeniv },
589 { "glGetTexImage", (GLvoid *) glGetTexImage },
590 { "glGetTexLevelParameterfv", (GLvoid *) glGetTexLevelParameterfv },
591 { "glGetTexLevelParameteriv", (GLvoid *) glGetTexLevelParameteriv },
592 { "glGetTexParameterfv", (GLvoid *) glGetTexParameterfv },
593 { "glGetTexParameteriv", (GLvoid *) glGetTexParameteriv },
594 { "glHint", (GLvoid *) glHint },
595 { "glIndexMask", (GLvoid *) glIndexMask },
596 { "glIndexd", (GLvoid *) glIndexd },
597 { "glIndexdv", (GLvoid *) glIndexdv },
598 { "glIndexf", (GLvoid *) glIndexf },
599 { "glIndexfv", (GLvoid *) glIndexfv },
600 { "glIndexi", (GLvoid *) glIndexi },
601 { "glIndexiv", (GLvoid *) glIndexiv },
602 { "glIndexs", (GLvoid *) glIndexs },
603 { "glIndexsv", (GLvoid *) glIndexsv },
604 { "glInitNames", (GLvoid *) glInitNames },
605 { "glIsEnabled", (GLvoid *) glIsEnabled },
606 { "glIsList", (GLvoid *) glIsList },
607 { "glLightModelf", (GLvoid *) glLightModelf },
608 { "glLightModelfv", (GLvoid *) glLightModelfv },
609 { "glLightModeli", (GLvoid *) glLightModeli },
610 { "glLightModeliv", (GLvoid *) glLightModeliv },
611 { "glLightf", (GLvoid *) glLightf },
612 { "glLightfv", (GLvoid *) glLightfv },
613 { "glLighti", (GLvoid *) glLighti },
614 { "glLightiv", (GLvoid *) glLightiv },
615 { "glLineStipple", (GLvoid *) glLineStipple },
616 { "glLineWidth", (GLvoid *) glLineWidth },
617 { "glListBase", (GLvoid *) glListBase },
618 { "glLoadIdentity", (GLvoid *) glLoadIdentity },
619 { "glLoadMatrixd", (GLvoid *) glLoadMatrixd },
620 { "glLoadMatrixf", (GLvoid *) glLoadMatrixf },
621 { "glLoadName", (GLvoid *) glLoadName },
622 { "glLogicOp", (GLvoid *) glLogicOp },
623 { "glMap1d", (GLvoid *) glMap1d },
624 { "glMap1f", (GLvoid *) glMap1f },
625 { "glMap2d", (GLvoid *) glMap2d },
626 { "glMap2f", (GLvoid *) glMap2f },
627 { "glMapGrid1d", (GLvoid *) glMapGrid1d },
628 { "glMapGrid1f", (GLvoid *) glMapGrid1f },
629 { "glMapGrid2d", (GLvoid *) glMapGrid2d },
630 { "glMapGrid2f", (GLvoid *) glMapGrid2f },
631 { "glMaterialf", (GLvoid *) glMaterialf },
632 { "glMaterialfv", (GLvoid *) glMaterialfv },
633 { "glMateriali", (GLvoid *) glMateriali },
634 { "glMaterialiv", (GLvoid *) glMaterialiv },
635 { "glMatrixMode", (GLvoid *) glMatrixMode },
636 { "glMultMatrixd", (GLvoid *) glMultMatrixd },
637 { "glMultMatrixf", (GLvoid *) glMultMatrixf },
638 { "glNewList", (GLvoid *) glNewList },
639 { "glNormal3b", (GLvoid *) glNormal3b },
640 { "glNormal3bv", (GLvoid *) glNormal3bv },
641 { "glNormal3d", (GLvoid *) glNormal3d },
642 { "glNormal3dv", (GLvoid *) glNormal3dv },
643 { "glNormal3f", (GLvoid *) glNormal3f },
644 { "glNormal3fv", (GLvoid *) glNormal3fv },
645 { "glNormal3i", (GLvoid *) glNormal3i },
646 { "glNormal3iv", (GLvoid *) glNormal3iv },
647 { "glNormal3s", (GLvoid *) glNormal3s },
648 { "glNormal3sv", (GLvoid *) glNormal3sv },
649 { "glOrtho", (GLvoid *) glOrtho },
650 { "glPassThrough", (GLvoid *) glPassThrough },
651 { "glPixelMapfv", (GLvoid *) glPixelMapfv },
652 { "glPixelMapuiv", (GLvoid *) glPixelMapuiv },
653 { "glPixelMapusv", (GLvoid *) glPixelMapusv },
654 { "glPixelStoref", (GLvoid *) glPixelStoref },
655 { "glPixelStorei", (GLvoid *) glPixelStorei },
656 { "glPixelTransferf", (GLvoid *) glPixelTransferf },
657 { "glPixelTransferi", (GLvoid *) glPixelTransferi },
658 { "glPixelZoom", (GLvoid *) glPixelZoom },
659 { "glPointSize", (GLvoid *) glPointSize },
660 { "glPolygonMode", (GLvoid *) glPolygonMode },
661 { "glPolygonOffset", (GLvoid *) glPolygonOffset },
662 { "glPolygonStipple", (GLvoid *) glPolygonStipple },
663 { "glPopAttrib", (GLvoid *) glPopAttrib },
664 { "glPopMatrix", (GLvoid *) glPopMatrix },
665 { "glPopName", (GLvoid *) glPopName },
666 { "glPushAttrib", (GLvoid *) glPushAttrib },
667 { "glPushMatrix", (GLvoid *) glPushMatrix },
668 { "glPushName", (GLvoid *) glPushName },
669 { "glRasterPos2d", (GLvoid *) glRasterPos2d },
670 { "glRasterPos2dv", (GLvoid *) glRasterPos2dv },
671 { "glRasterPos2f", (GLvoid *) glRasterPos2f },
672 { "glRasterPos2fv", (GLvoid *) glRasterPos2fv },
673 { "glRasterPos2i", (GLvoid *) glRasterPos2i },
674 { "glRasterPos2iv", (GLvoid *) glRasterPos2iv },
675 { "glRasterPos2s", (GLvoid *) glRasterPos2s },
676 { "glRasterPos2sv", (GLvoid *) glRasterPos2sv },
677 { "glRasterPos3d", (GLvoid *) glRasterPos3d },
678 { "glRasterPos3dv", (GLvoid *) glRasterPos3dv },
679 { "glRasterPos3f", (GLvoid *) glRasterPos3f },
680 { "glRasterPos3fv", (GLvoid *) glRasterPos3fv },
681 { "glRasterPos3i", (GLvoid *) glRasterPos3i },
682 { "glRasterPos3iv", (GLvoid *) glRasterPos3iv },
683 { "glRasterPos3s", (GLvoid *) glRasterPos3s },
684 { "glRasterPos3sv", (GLvoid *) glRasterPos3sv },
685 { "glRasterPos4d", (GLvoid *) glRasterPos4d },
686 { "glRasterPos4dv", (GLvoid *) glRasterPos4dv },
687 { "glRasterPos4f", (GLvoid *) glRasterPos4f },
688 { "glRasterPos4fv", (GLvoid *) glRasterPos4fv },
689 { "glRasterPos4i", (GLvoid *) glRasterPos4i },
690 { "glRasterPos4iv", (GLvoid *) glRasterPos4iv },
691 { "glRasterPos4s", (GLvoid *) glRasterPos4s },
692 { "glRasterPos4sv", (GLvoid *) glRasterPos4sv },
693 { "glReadBuffer", (GLvoid *) glReadBuffer },
694 { "glReadPixels", (GLvoid *) glReadPixels },
695 { "glRectd", (GLvoid *) glRectd },
696 { "glRectdv", (GLvoid *) glRectdv },
697 { "glRectf", (GLvoid *) glRectf },
698 { "glRectfv", (GLvoid *) glRectfv },
699 { "glRecti", (GLvoid *) glRecti },
700 { "glRectiv", (GLvoid *) glRectiv },
701 { "glRects", (GLvoid *) glRects },
702 { "glRectsv", (GLvoid *) glRectsv },
703 { "glRenderMode", (GLvoid *) glRenderMode },
704 { "glRotated", (GLvoid *) glRotated },
705 { "glRotatef", (GLvoid *) glRotatef },
706 { "glScaled", (GLvoid *) glScaled },
707 { "glScalef", (GLvoid *) glScalef },
708 { "glScissor", (GLvoid *) glScissor },
709 { "glSelectBuffer", (GLvoid *) glSelectBuffer },
710 { "glShadeModel", (GLvoid *) glShadeModel },
711 { "glStencilFunc", (GLvoid *) glStencilFunc },
712 { "glStencilMask", (GLvoid *) glStencilMask },
713 { "glStencilOp", (GLvoid *) glStencilOp },
714 { "glTexCoord1d", (GLvoid *) glTexCoord1d },
715 { "glTexCoord1dv", (GLvoid *) glTexCoord1dv },
716 { "glTexCoord1f", (GLvoid *) glTexCoord1f },
717 { "glTexCoord1fv", (GLvoid *) glTexCoord1fv },
718 { "glTexCoord1i", (GLvoid *) glTexCoord1i },
719 { "glTexCoord1iv", (GLvoid *) glTexCoord1iv },
720 { "glTexCoord1s", (GLvoid *) glTexCoord1s },
721 { "glTexCoord1sv", (GLvoid *) glTexCoord1sv },
722 { "glTexCoord2d", (GLvoid *) glTexCoord2d },
723 { "glTexCoord2dv", (GLvoid *) glTexCoord2dv },
724 { "glTexCoord2f", (GLvoid *) glTexCoord2f },
725 { "glTexCoord2fv", (GLvoid *) glTexCoord2fv },
726 { "glTexCoord2i", (GLvoid *) glTexCoord2i },
727 { "glTexCoord2iv", (GLvoid *) glTexCoord2iv },
728 { "glTexCoord2s", (GLvoid *) glTexCoord2s },
729 { "glTexCoord2sv", (GLvoid *) glTexCoord2sv },
730 { "glTexCoord3d", (GLvoid *) glTexCoord3d },
731 { "glTexCoord3dv", (GLvoid *) glTexCoord3dv },
732 { "glTexCoord3f", (GLvoid *) glTexCoord3f },
733 { "glTexCoord3fv", (GLvoid *) glTexCoord3fv },
734 { "glTexCoord3i", (GLvoid *) glTexCoord3i },
735 { "glTexCoord3iv", (GLvoid *) glTexCoord3iv },
736 { "glTexCoord3s", (GLvoid *) glTexCoord3s },
737 { "glTexCoord3sv", (GLvoid *) glTexCoord3sv },
738 { "glTexCoord4d", (GLvoid *) glTexCoord4d },
739 { "glTexCoord4dv", (GLvoid *) glTexCoord4dv },
740 { "glTexCoord4f", (GLvoid *) glTexCoord4f },
741 { "glTexCoord4fv", (GLvoid *) glTexCoord4fv },
742 { "glTexCoord4i", (GLvoid *) glTexCoord4i },
743 { "glTexCoord4iv", (GLvoid *) glTexCoord4iv },
744 { "glTexCoord4s", (GLvoid *) glTexCoord4s },
745 { "glTexCoord4sv", (GLvoid *) glTexCoord4sv },
746 { "glTexEnvf", (GLvoid *) glTexEnvf },
747 { "glTexEnvfv", (GLvoid *) glTexEnvfv },
748 { "glTexEnvi", (GLvoid *) glTexEnvi },
749 { "glTexEnviv", (GLvoid *) glTexEnviv },
750 { "glTexGend", (GLvoid *) glTexGend },
751 { "glTexGendv", (GLvoid *) glTexGendv },
752 { "glTexGenf", (GLvoid *) glTexGenf },
753 { "glTexGenfv", (GLvoid *) glTexGenfv },
754 { "glTexGeni", (GLvoid *) glTexGeni },
755 { "glTexGeniv", (GLvoid *) glTexGeniv },
756 { "glTexImage1D", (GLvoid *) glTexImage1D },
757 { "glTexImage2D", (GLvoid *) glTexImage2D },
758 { "glTexParameterf", (GLvoid *) glTexParameterf },
759 { "glTexParameterfv", (GLvoid *) glTexParameterfv },
760 { "glTexParameteri", (GLvoid *) glTexParameteri },
761 { "glTexParameteriv", (GLvoid *) glTexParameteriv },
762 { "glTranslated", (GLvoid *) glTranslated },
763 { "glTranslatef", (GLvoid *) glTranslatef },
764 { "glVertex2d", (GLvoid *) glVertex2d },
765 { "glVertex2dv", (GLvoid *) glVertex2dv },
766 { "glVertex2f", (GLvoid *) glVertex2f },
767 { "glVertex2fv", (GLvoid *) glVertex2fv },
768 { "glVertex2i", (GLvoid *) glVertex2i },
769 { "glVertex2iv", (GLvoid *) glVertex2iv },
770 { "glVertex2s", (GLvoid *) glVertex2s },
771 { "glVertex2sv", (GLvoid *) glVertex2sv },
772 { "glVertex3d", (GLvoid *) glVertex3d },
773 { "glVertex3dv", (GLvoid *) glVertex3dv },
774 { "glVertex3f", (GLvoid *) glVertex3f },
775 { "glVertex3fv", (GLvoid *) glVertex3fv },
776 { "glVertex3i", (GLvoid *) glVertex3i },
777 { "glVertex3iv", (GLvoid *) glVertex3iv },
778 { "glVertex3s", (GLvoid *) glVertex3s },
779 { "glVertex3sv", (GLvoid *) glVertex3sv },
780 { "glVertex4d", (GLvoid *) glVertex4d },
781 { "glVertex4dv", (GLvoid *) glVertex4dv },
782 { "glVertex4f", (GLvoid *) glVertex4f },
783 { "glVertex4fv", (GLvoid *) glVertex4fv },
784 { "glVertex4i", (GLvoid *) glVertex4i },
785 { "glVertex4iv", (GLvoid *) glVertex4iv },
786 { "glVertex4s", (GLvoid *) glVertex4s },
787 { "glVertex4sv", (GLvoid *) glVertex4sv },
788 { "glViewport", (GLvoid *) glViewport },
Brian Paul7fb54ae1999-11-19 22:33:50 +0000789
Brian Paul0c239fc1999-12-16 12:38:11 +0000790 /* GL 1.1 */
Brian Paul91bcefa1999-11-27 21:30:40 +0000791 { "glAreTexturesResident", (GLvoid *) glAreTexturesResident },
792 { "glArrayElement", (GLvoid *) glArrayElement },
793 { "glBindTexture", (GLvoid *) glBindTexture },
794 { "glColorPointer", (GLvoid *) glColorPointer },
795 { "glCopyTexImage1D", (GLvoid *) glCopyTexImage1D },
796 { "glCopyTexImage2D", (GLvoid *) glCopyTexImage2D },
797 { "glCopyTexSubImage1D", (GLvoid *) glCopyTexSubImage1D },
798 { "glCopyTexSubImage2D", (GLvoid *) glCopyTexSubImage2D },
799 { "glDeleteTextures", (GLvoid *) glDeleteTextures },
800 { "glDisableClientState", (GLvoid *) glDisableClientState },
801 { "glDrawArrays", (GLvoid *) glDrawArrays },
802 { "glDrawElements", (GLvoid *) glDrawElements },
803 { "glEdgeFlagPointer", (GLvoid *) glEdgeFlagPointer },
804 { "glEnableClientState", (GLvoid *) glEnableClientState },
805 { "glGenTextures", (GLvoid *) glGenTextures },
806 { "glGetPointerv", (GLvoid *) glGetPointerv },
807 { "glIndexPointer", (GLvoid *) glIndexPointer },
808 { "glIndexub", (GLvoid *) glIndexub },
809 { "glIndexubv", (GLvoid *) glIndexubv },
810 { "glInterleavedArrays", (GLvoid *) glInterleavedArrays },
811 { "glIsTexture", (GLvoid *) glIsTexture },
812 { "glNormalPointer", (GLvoid *) glNormalPointer },
813 { "glPopClientAttrib", (GLvoid *) glPopClientAttrib },
814 { "glPrioritizeTextures", (GLvoid *) glPrioritizeTextures },
815 { "glPushClientAttrib", (GLvoid *) glPushClientAttrib },
816 { "glTexCoordPointer", (GLvoid *) glTexCoordPointer },
817 { "glTexSubImage1D", (GLvoid *) glTexSubImage1D },
818 { "glTexSubImage2D", (GLvoid *) glTexSubImage2D },
819 { "glVertexPointer", (GLvoid *) glVertexPointer },
Brian Paul91bcefa1999-11-27 21:30:40 +0000820
Brian Paul0c239fc1999-12-16 12:38:11 +0000821 /* GL 1.2 */
Brian Paul91bcefa1999-11-27 21:30:40 +0000822 { "glCopyTexSubImage3D", (GLvoid *) glCopyTexSubImage3D },
823 { "glDrawRangeElements", (GLvoid *) glDrawRangeElements },
824 { "glTexImage3D", (GLvoid *) glTexImage3D },
825 { "glTexSubImage3D", (GLvoid *) glTexSubImage3D },
826
Brian Paul0c239fc1999-12-16 12:38:11 +0000827 /* GL_ARB_imaging */
Brian Paul91bcefa1999-11-27 21:30:40 +0000828 { "glBlendColor", (GLvoid *) glBlendColor },
829 { "glBlendEquation", (GLvoid *) glBlendEquation },
830 { "glColorSubTable", (GLvoid *) glColorSubTable },
831 { "glColorTable", (GLvoid *) glColorTable },
832 { "glColorTableParameterfv", (GLvoid *) glColorTableParameterfv },
833 { "glColorTableParameteriv", (GLvoid *) glColorTableParameteriv },
834 { "glConvolutionFilter1D", (GLvoid *) glConvolutionFilter1D },
835 { "glConvolutionFilter2D", (GLvoid *) glConvolutionFilter2D },
836 { "glConvolutionParameterf", (GLvoid *) glConvolutionParameterf },
837 { "glConvolutionParameterfv", (GLvoid *) glConvolutionParameterfv },
838 { "glConvolutionParameteri", (GLvoid *) glConvolutionParameteri },
839 { "glConvolutionParameteriv", (GLvoid *) glConvolutionParameteriv },
840 { "glCopyColorSubTable", (GLvoid *) glCopyColorSubTable },
841 { "glCopyColorTable", (GLvoid *) glCopyColorTable },
842 { "glCopyConvolutionFilter1D", (GLvoid *) glCopyConvolutionFilter1D },
843 { "glCopyConvolutionFilter2D", (GLvoid *) glCopyConvolutionFilter2D },
844 { "glGetColorTable", (GLvoid *) glGetColorTable },
845 { "glGetColorTableParameterfv", (GLvoid *) glGetColorTableParameterfv },
846 { "glGetColorTableParameteriv", (GLvoid *) glGetColorTableParameteriv },
847 { "glGetConvolutionFilter", (GLvoid *) glGetConvolutionFilter },
848 { "glGetConvolutionParameterfv", (GLvoid *) glGetConvolutionParameterfv },
849 { "glGetConvolutionParameteriv", (GLvoid *) glGetConvolutionParameteriv },
850 { "glGetHistogram", (GLvoid *) glGetHistogram },
851 { "glGetHistogramParameterfv", (GLvoid *) glGetHistogramParameterfv },
852 { "glGetHistogramParameteriv", (GLvoid *) glGetHistogramParameteriv },
853 { "glGetMinmax", (GLvoid *) glGetMinmax },
854 { "glGetMinmaxParameterfv", (GLvoid *) glGetMinmaxParameterfv },
855 { "glGetMinmaxParameteriv", (GLvoid *) glGetMinmaxParameteriv },
856 { "glGetSeparableFilter", (GLvoid *) glGetSeparableFilter },
857 { "glHistogram", (GLvoid *) glHistogram },
858 { "glMinmax", (GLvoid *) glMinmax },
859 { "glResetHistogram", (GLvoid *) glResetHistogram },
860 { "glResetMinmax", (GLvoid *) glResetMinmax },
861 { "glSeparableFilter2D", (GLvoid *) glSeparableFilter2D },
Brian Paul91bcefa1999-11-27 21:30:40 +0000862
Brian Paul67661b01999-12-15 12:52:31 +0000863 /* GL_ARB_multitexture */
Brian Paul91bcefa1999-11-27 21:30:40 +0000864 { "glActiveTextureARB", (GLvoid *) glActiveTextureARB },
865 { "glClientActiveTextureARB", (GLvoid *) glClientActiveTextureARB },
866 { "glMultiTexCoord1dARB", (GLvoid *) glMultiTexCoord1dARB },
867 { "glMultiTexCoord1dvARB", (GLvoid *) glMultiTexCoord1dvARB },
868 { "glMultiTexCoord1fARB", (GLvoid *) glMultiTexCoord1fARB },
869 { "glMultiTexCoord1fvARB", (GLvoid *) glMultiTexCoord1fvARB },
870 { "glMultiTexCoord1iARB", (GLvoid *) glMultiTexCoord1iARB },
871 { "glMultiTexCoord1ivARB", (GLvoid *) glMultiTexCoord1ivARB },
872 { "glMultiTexCoord1sARB", (GLvoid *) glMultiTexCoord1sARB },
873 { "glMultiTexCoord1svARB", (GLvoid *) glMultiTexCoord1svARB },
874 { "glMultiTexCoord2dARB", (GLvoid *) glMultiTexCoord2dARB },
875 { "glMultiTexCoord2dvARB", (GLvoid *) glMultiTexCoord2dvARB },
876 { "glMultiTexCoord2fARB", (GLvoid *) glMultiTexCoord2fARB },
877 { "glMultiTexCoord2fvARB", (GLvoid *) glMultiTexCoord2fvARB },
878 { "glMultiTexCoord2iARB", (GLvoid *) glMultiTexCoord2iARB },
879 { "glMultiTexCoord2ivARB", (GLvoid *) glMultiTexCoord2ivARB },
880 { "glMultiTexCoord2sARB", (GLvoid *) glMultiTexCoord2sARB },
881 { "glMultiTexCoord2svARB", (GLvoid *) glMultiTexCoord2svARB },
882 { "glMultiTexCoord3dARB", (GLvoid *) glMultiTexCoord3dARB },
883 { "glMultiTexCoord3dvARB", (GLvoid *) glMultiTexCoord3dvARB },
884 { "glMultiTexCoord3fARB", (GLvoid *) glMultiTexCoord3fARB },
885 { "glMultiTexCoord3fvARB", (GLvoid *) glMultiTexCoord3fvARB },
886 { "glMultiTexCoord3iARB", (GLvoid *) glMultiTexCoord3iARB },
887 { "glMultiTexCoord3ivARB", (GLvoid *) glMultiTexCoord3ivARB },
888 { "glMultiTexCoord3sARB", (GLvoid *) glMultiTexCoord3sARB },
889 { "glMultiTexCoord3svARB", (GLvoid *) glMultiTexCoord3svARB },
890 { "glMultiTexCoord4dARB", (GLvoid *) glMultiTexCoord4dARB },
891 { "glMultiTexCoord4dvARB", (GLvoid *) glMultiTexCoord4dvARB },
892 { "glMultiTexCoord4fARB", (GLvoid *) glMultiTexCoord4fARB },
893 { "glMultiTexCoord4fvARB", (GLvoid *) glMultiTexCoord4fvARB },
894 { "glMultiTexCoord4iARB", (GLvoid *) glMultiTexCoord4iARB },
895 { "glMultiTexCoord4ivARB", (GLvoid *) glMultiTexCoord4ivARB },
896 { "glMultiTexCoord4sARB", (GLvoid *) glMultiTexCoord4sARB },
897 { "glMultiTexCoord4svARB", (GLvoid *) glMultiTexCoord4svARB },
Brian Paul91bcefa1999-11-27 21:30:40 +0000898
Brian Paul67661b01999-12-15 12:52:31 +0000899 /* 2. GL_EXT_blend_color */
900 { "glBlendColorEXT", (GLvoid *) glBlendColorEXT },
901
902 /* 3. GL_EXT_polygon_offset */
903 { "glPolygonOffsetEXT", (GLvoid *) glPolygonOffsetEXT },
904
Brian Paul0c239fc1999-12-16 12:38:11 +0000905 /* 6. GL_EXT_texture3D */
906 { "glCopyTexSubImage3DEXT", (GLvoid *) glCopyTexSubImage3DEXT },
907 { "glTexImage3DEXT", (GLvoid *) glTexImage3DEXT },
908 { "glTexSubImage3DEXT", (GLvoid *) glTexSubImage3DEXT },
909
910 /* 7. GL_SGI_texture_filter4 */
911 { "glGetTexFilterFuncSGIS", (GLvoid *) glGetTexFilterFuncSGIS },
912 { "glTexFilterFuncSGIS", (GLvoid *) glTexFilterFuncSGIS },
913
914 /* 9. GL_EXT_subtexture */
915 { "glTexSubImage1DEXT", (GLvoid *) glTexSubImage1DEXT },
916 { "glTexSubImage2DEXT", (GLvoid *) glTexSubImage2DEXT },
917
918 /* 10. GL_EXT_copy_texture */
919 { "glCopyTexImage1DEXT", (GLvoid *) glCopyTexImage1DEXT },
920 { "glCopyTexImage2DEXT", (GLvoid *) glCopyTexImage2DEXT },
921 { "glCopyTexSubImage1DEXT", (GLvoid *) glCopyTexSubImage1DEXT },
922 { "glCopyTexSubImage2DEXT", (GLvoid *) glCopyTexSubImage2DEXT },
923
924 /* 11. GL_EXT_histogram */
925 { "glGetHistogramEXT", (GLvoid *) glGetHistogramEXT },
926 { "glGetHistogramParameterfvEXT", (GLvoid *) glGetHistogramParameterfvEXT },
927 { "glGetHistogramParameterivEXT", (GLvoid *) glGetHistogramParameterivEXT },
928 { "glGetMinmaxEXT", (GLvoid *) glGetMinmaxEXT },
929 { "glGetMinmaxParameterfvEXT", (GLvoid *) glGetMinmaxParameterfvEXT },
930 { "glGetMinmaxParameterivEXT", (GLvoid *) glGetMinmaxParameterivEXT },
931 { "glHistogramEXT", (GLvoid *) glHistogramEXT },
932 { "glMinmaxEXT", (GLvoid *) glMinmaxEXT },
933 { "glResetHistogramEXT", (GLvoid *) glResetHistogramEXT },
934 { "glResetMinmaxEXT", (GLvoid *) glResetMinmaxEXT },
935
936 /* 12. GL_EXT_convolution */
937 { "glConvolutionFilter1DEXT", (GLvoid *) glConvolutionFilter1DEXT },
938 { "glConvolutionFilter2DEXT", (GLvoid *) glConvolutionFilter2DEXT },
939 { "glConvolutionParameterfEXT", (GLvoid *) glConvolutionParameterfEXT },
940 { "glConvolutionParameterfvEXT", (GLvoid *) glConvolutionParameterfvEXT },
941 { "glConvolutionParameteriEXT", (GLvoid *) glConvolutionParameteriEXT },
942 { "glConvolutionParameterivEXT", (GLvoid *) glConvolutionParameterivEXT },
943 { "glCopyConvolutionFilter1DEXT", (GLvoid *) glCopyConvolutionFilter1DEXT },
944 { "glCopyConvolutionFilter2DEXT", (GLvoid *) glCopyConvolutionFilter2DEXT },
945 { "glGetConvolutionFilterEXT", (GLvoid *) glGetConvolutionFilterEXT },
946 { "glGetConvolutionParameterivEXT", (GLvoid *) glGetConvolutionParameterivEXT },
947 { "glGetConvolutionParameterfvEXT", (GLvoid *) glGetConvolutionParameterfvEXT },
948 { "glGetSeparableFilterEXT", (GLvoid *) glGetSeparableFilterEXT },
949 { "glSeparableFilter2DEXT", (GLvoid *) glSeparableFilter2DEXT },
950
951 /* 14. GL_SGI_color_table */
952 { "glColorTableSGI", (GLvoid *) NotImplemented },
953 { "glColorTableParameterfvSGI", (GLvoid *) NotImplemented },
954 { "glColorTableParameterivSGI", (GLvoid *) NotImplemented },
955 { "glCopyColorTableSGI", (GLvoid *) NotImplemented },
956 { "glGetColorTableSGI", (GLvoid *) NotImplemented },
957 { "glGetColorTableParameterfvSGI", (GLvoid *) NotImplemented },
958 { "glGetColorTableParameterivSGI", (GLvoid *) NotImplemented },
959
960 /* 15. GL_SGIS_pixel_texture */
961 { "glPixelTexGenParameterfSGIS", (GLvoid *) NotImplemented },
962 { "glPixelTexGenParameteriSGIS", (GLvoid *) NotImplemented },
963 { "glGetPixelTexGenParameterfvSGIS", (GLvoid *) NotImplemented },
964 { "glGetPixelTexGenParameterivSGIS", (GLvoid *) NotImplemented },
965
966 /* 16. GL_SGIS_texture4D */
967 { "glTexImage4DSGIS", (GLvoid *) NotImplemented },
968 { "glTexSubImage4DSGIS", (GLvoid *) NotImplemented },
969
970 /* 20. GL_EXT_texture_object */
971 { "glAreTexturesResidentEXT", (GLvoid *) glAreTexturesResidentEXT },
972 { "glBindTextureEXT", (GLvoid *) glBindTextureEXT },
973 { "glDeleteTexturesEXT", (GLvoid *) glDeleteTexturesEXT },
974 { "glGenTexturesEXT", (GLvoid *) glGenTexturesEXT },
975 { "glIsTextureEXT", (GLvoid *) glIsTextureEXT },
976 { "glPrioritizeTexturesEXT", (GLvoid *) glPrioritizeTexturesEXT },
977
978 /* 21. GL_SGIS_detail_texture */
979 { "glDetailTexFuncSGIS", (GLvoid *) NotImplemented },
980 { "glGetDetailTexFuncSGIS", (GLvoid *) NotImplemented },
981
982 /* 22. GL_SGIS_sharpen_texture */
983 { "glGetSharpenTexFuncSGIS", (GLvoid *) NotImplemented },
984 { "glSharpenTexFuncSGIS", (GLvoid *) NotImplemented },
985
986 /* 25. GL_SGIS_multisample */
987 { "glSampleMaskSGIS", (GLvoid *) NotImplemented },
988 { "glSamplePatternSGIS", (GLvoid *) NotImplemented },
989
990 /* 30. GL_EXT_vertex_array */
991 { "glArrayElementEXT", (GLvoid *) glArrayElementEXT },
992 { "glColorPointerEXT", (GLvoid *) glColorPointerEXT },
993 { "glDrawArraysEXT", (GLvoid *) glDrawArraysEXT },
994 { "glEdgeFlagPointerEXT", (GLvoid *) glEdgeFlagPointerEXT },
995 { "glGetPointervEXT", (GLvoid *) glGetPointervEXT },
996 { "glIndexPointerEXT", (GLvoid *) glIndexPointerEXT },
997 { "glNormalPointerEXT", (GLvoid *) glNormalPointerEXT },
998 { "glTexCoordPointerEXT", (GLvoid *) glTexCoordPointerEXT },
999 { "glVertexPointerEXT", (GLvoid *) glVertexPointerEXT },
1000
1001 /* 37. GL_EXT_blend_minmax */
1002 { "glBlendEquationEXT", (GLvoid *) glBlendEquationEXT },
1003
1004 /* 52. GL_SGIX_sprite */
1005 { "glSpriteParameterfSGIX", (GLvoid *) NotImplemented },
1006 { "glSpriteParameterfvSGIX", (GLvoid *) NotImplemented },
1007 { "glSpriteParameteriSGIX", (GLvoid *) NotImplemented },
1008 { "glSpriteParameterivSGIX", (GLvoid *) NotImplemented },
1009
Brian Paul67661b01999-12-15 12:52:31 +00001010 /* 54. GL_EXT_point_parameters */
Brian Paul0c239fc1999-12-16 12:38:11 +00001011 { "glPointParameterfEXT", (GLvoid *) NotImplemented },
1012 { "glPointParameterfvEXT", (GLvoid *) NotImplemented },
1013
1014 /* 55. GL_SGIX_instruments */
1015 { "glInstrumentsBufferSGIX", (GLvoid *) NotImplemented },
1016 { "glStartInstrumentsSGIX", (GLvoid *) NotImplemented },
1017 { "glStopInstrumentsSGIX", (GLvoid *) NotImplemented },
1018 { "glReadInstrumentsSGIX", (GLvoid *) NotImplemented },
1019 { "glPollInstrumentsSGIX", (GLvoid *) NotImplemented },
1020 { "glGetInstrumentsSGIX", (GLvoid *) NotImplemented },
1021
1022 /* 57. GL_SGIX_framezoom */
1023 { "glFrameZoomSGIX", (GLvoid *) NotImplemented },
1024
1025 /* 60. GL_SGIX_reference_plane */
1026 { "glReferencePlaneSGIX", (GLvoid *) NotImplemented },
1027
1028 /* 61. GL_SGIX_flush_raster */
1029 { "glFlushRasterSGIX", (GLvoid *) NotImplemented },
1030
1031 /* 66. GL_HP_image_transform */
1032 { "glGetImageTransformParameterfvHP", (GLvoid *) NotImplemented },
1033 { "glGetImageTransformParameterivHP", (GLvoid *) NotImplemented },
1034 { "glImageTransformParameterfHP", (GLvoid *) NotImplemented },
1035 { "glImageTransformParameterfvHP", (GLvoid *) NotImplemented },
1036 { "glImageTransformParameteriHP", (GLvoid *) NotImplemented },
1037 { "glImageTransformParameterivHP", (GLvoid *) NotImplemented },
1038
1039 /* 74. GL_EXT_color_subtable */
1040 { "glColorSubTableEXT", (GLvoid *) NotImplemented },
1041 { "glCopyColorSubTableEXT", (GLvoid *) NotImplemented },
1042
1043 /* 77. GL_PGI_misc_hints */
1044 { "glHintPGI", (GLvoid *) NotImplemented },
Brian Paul67661b01999-12-15 12:52:31 +00001045
1046 /* 78. GL_EXT_paletted_texture */
1047 { "glColorTableEXT", (GLvoid *) glColorTableEXT },
Brian Paul67661b01999-12-15 12:52:31 +00001048 { "glGetColorTableEXT", (GLvoid *) glGetColorTableEXT },
1049 { "glGetColorTableParameterfvEXT", (GLvoid *) glGetColorTableParameterfvEXT },
1050 { "glGetColorTableParameterivEXT", (GLvoid *) glGetColorTableParameterivEXT },
1051
Brian Paul0c239fc1999-12-16 12:38:11 +00001052 /* 80. GL_SGIX_list_priority */
1053 { "glGetListParameterfvSGIX", (GLvoid *) NotImplemented },
1054 { "glGetListParameterivSGIX", (GLvoid *) NotImplemented },
1055 { "glListParameterfSGIX", (GLvoid *) NotImplemented },
1056 { "glListParameterfvSGIX", (GLvoid *) NotImplemented },
1057 { "glListParameteriSGIX", (GLvoid *) NotImplemented },
1058 { "glListParameterivSGIX", (GLvoid *) NotImplemented },
1059
1060 /* 94. GL_EXT_index_material */
1061 { "glIndexMaterialEXT", (GLvoid *) NotImplemented },
1062
1063 /* 95. GL_EXT_index_func */
1064 { "glIndexFuncEXT", (GLvoid *) NotImplemented },
1065
Brian Paul67661b01999-12-15 12:52:31 +00001066 /* 97. GL_EXT_compiled_vertex_array */
1067 { "glLockArraysEXT", (GLvoid *) glLockArraysEXT },
1068 { "glUnlockArraysEXT", (GLvoid *) glUnlockArraysEXT },
1069
Brian Paul0c239fc1999-12-16 12:38:11 +00001070 /* 98. GL_EXT_cull_vertex */
1071 { "glCullParameterfvEXT", (GLvoid *) NotImplemented },
1072 { "glCullParameterdvEXT", (GLvoid *) NotImplemented },
Brian Paul67661b01999-12-15 12:52:31 +00001073
1074 /* 173. GL_EXT/INGR_blend_func_separate */
Brian Paul91bcefa1999-11-27 21:30:40 +00001075 { "glBlendFuncSeparateINGR", (GLvoid *) glBlendFuncSeparateINGR },
Brian Paul91bcefa1999-11-27 21:30:40 +00001076
Brian Paul67661b01999-12-15 12:52:31 +00001077 /* GL_MESA_window_pos */
Brian Paul91bcefa1999-11-27 21:30:40 +00001078 { "glWindowPos4fMESA", (GLvoid *) glWindowPos4fMESA },
Brian Paul91bcefa1999-11-27 21:30:40 +00001079
Brian Paul67661b01999-12-15 12:52:31 +00001080 /* GL_MESA_resize_buffers */
Brian Paul91bcefa1999-11-27 21:30:40 +00001081 { "glResizeBuffersMESA", (GLvoid *) glResizeBuffersMESA },
Brian Paul91bcefa1999-11-27 21:30:40 +00001082
Brian Paul67661b01999-12-15 12:52:31 +00001083 /* GL_ARB_transpose_matrix */
1084 { "glLoadTransposeMatrixdARB", (GLvoid *) glLoadTransposeMatrixdARB },
1085 { "glLoadTransposeMatrixfARB", (GLvoid *) glLoadTransposeMatrixfARB },
1086 { "glMultTransposeMatrixdARB", (GLvoid *) glMultTransposeMatrixdARB },
1087 { "glMultTransposeMatrixfARB", (GLvoid *) glMultTransposeMatrixfARB },
Brian Paulcd963881999-12-10 20:01:06 +00001088
Brian Paul67661b01999-12-15 12:52:31 +00001089 { NULL, NULL } /* end of list marker */
Brian Paul91bcefa1999-11-27 21:30:40 +00001090};
Brian Paul7fb54ae1999-11-19 22:33:50 +00001091