source: trunk/src/opengl/mesa/glapi.c@ 3993

Last change on this file since 3993 was 3598, checked in by jeroen, 25 years ago

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