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