1 /* $Id: glapi.c,v 1.11 1999/12/10 20:01:06 brianp Exp $ */
4 * Mesa 3-D graphics library
7 * Copyright (C) 1999 Brian Paul All Rights Reserved.
9 * Permission is hereby granted, free of charge, to any person obtaining a
10 * copy of this software and associated documentation files (the "Software"),
11 * to deal in the Software without restriction, including without limitation
12 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
13 * and/or sell copies of the Software, and to permit persons to whom the
14 * Software is furnished to do so, subject to the following conditions:
16 * The above copyright notice and this permission notice shall be included
17 * in all copies or substantial portions of the Software.
19 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
20 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
21 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
22 * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
23 * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
24 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
29 * This file manages the OpenGL API dispatch layer.
30 * The dispatch table (struct _glapi_table) is basically just a list
31 * of function pointers.
32 * There are functions to set/get the current dispatch table for the
33 * current thread and to manage registration/dispatch of dynamically
34 * added extension functions.
40 #include <stdlib.h> /* to get NULL */
43 #include "glapinoop.h"
48 * Define the DISPATCH_SETUP and DISPATCH macros here dependant on
49 * whether or not threading is enabled.
53 /*** Thread-safe API dispatch ***/
55 static MesaTSD mesa_dispatch_tsd
;
56 static void mesa_dispatch_thread_init() {
57 MesaInitTSD(&mesa_dispatch_tsd
);
59 #define DISPATCH_SETUP struct _glapi_table *dispatch = (struct _glapi_table *) MesaGetTSD(&mesa_dispatch_tsd)
60 #define DISPATCH(FUNC, ARGS) (dispatch->FUNC) ARGS
65 /*** Non-threaded API dispatch ***/
66 static struct _glapi_table
*Dispatch
= &__glapi_noop_table
;
67 #define DISPATCH_SETUP
68 #define DISPATCH(FUNC, ARGS) (Dispatch->FUNC) ARGS
75 * Set the global or per-thread dispatch table pointer.
78 _glapi_set_dispatch(struct _glapi_table
*dispatch
)
81 /* use the no-op functions */
82 dispatch
= &__glapi_noop_table
;
86 _glapi_check_table(dispatch
);
91 MesaSetTSD(&mesa_dispatch_tsd
, (void*) dispatch
, mesa_dispatch_thread_init
);
99 * Get the global or per-thread dispatch table pointer.
101 struct _glapi_table
*
102 _glapi_get_dispatch(void)
105 /* return this thread's dispatch pointer */
106 return (struct _glapi_table
*) MesaGetTSD(&mesa_dispatch_tsd
);
115 * Return size of dispatch table struct as number of functions (or
119 _glapi_get_dispatch_table_size(void)
121 return sizeof(struct _glapi_table
) / sizeof(void *);
127 * Get API dispatcher version string.
128 * XXX this isn't well defined yet.
131 _glapi_get_version(void)
138 * Return list of the hard-coded extension entrypoints in the dispatch table.
141 _glapi_get_extensions(void)
143 static const char *extensions
[] = {
144 #ifdef _GLAPI_EXT_paletted_texture
145 "GL_EXT_paletted_texture",
147 #ifdef _GLAPI_EXT_compiled_vertex_array
148 "GL_EXT_compiled_vertex_array",
150 #ifdef _GLAPI_EXT_point_parameters
151 "GL_EXT_point_parameters",
153 #ifdef _GLAPI_EXT_polygon_offset
154 "GL_EXT_polygon_offset",
156 #ifdef _GLAPI_EXT_blend_minmax
157 "GL_EXT_blend_minmax",
159 #ifdef _GLAPI_EXT_blend_color
160 "GL_EXT_blend_color",
162 #ifdef _GLAPI_ARB_multitexture
163 "GL_ARB_multitexture",
165 #ifdef _GLAPI_INGR_blend_func_separate
166 "GL_INGR_blend_func_separate",
168 #ifdef _GLAPI_MESA_window_pos
169 "GL_MESA_window_pos",
171 #ifdef _GLAPI_MESA_resize_buffers
172 "GL_MESA_resize_buffers",
182 struct name_address_pair
{
187 static struct name_address_pair static_functions
[] = {
188 { "glAccum", (GLvoid
*) glAccum
},
189 { "glAlphaFunc", (GLvoid
*) glAlphaFunc
},
190 { "glBegin", (GLvoid
*) glBegin
},
191 { "glBitmap", (GLvoid
*) glBitmap
},
192 { "glAccum", (GLvoid
*) glAccum
},
193 { "glAlphaFunc", (GLvoid
*) glAlphaFunc
},
194 { "glBegin", (GLvoid
*) glBegin
},
195 { "glBitmap", (GLvoid
*) glBitmap
},
196 { "glBlendFunc", (GLvoid
*) glBlendFunc
},
197 { "glCallList", (GLvoid
*) glCallList
},
198 { "glCallLists", (GLvoid
*) glCallLists
},
199 { "glClear", (GLvoid
*) glClear
},
200 { "glClearAccum", (GLvoid
*) glClearAccum
},
201 { "glClearColor", (GLvoid
*) glClearColor
},
202 { "glClearDepth", (GLvoid
*) glClearDepth
},
203 { "glClearIndex", (GLvoid
*) glClearIndex
},
204 { "glClearStencil", (GLvoid
*) glClearStencil
},
205 { "glClipPlane", (GLvoid
*) glClipPlane
},
206 { "glColor3b", (GLvoid
*) glColor3b
},
207 { "glColor3bv", (GLvoid
*) glColor3bv
},
208 { "glColor3d", (GLvoid
*) glColor3d
},
209 { "glColor3dv", (GLvoid
*) glColor3dv
},
210 { "glColor3f", (GLvoid
*) glColor3f
},
211 { "glColor3fv", (GLvoid
*) glColor3fv
},
212 { "glColor3i", (GLvoid
*) glColor3i
},
213 { "glColor3iv", (GLvoid
*) glColor3iv
},
214 { "glColor3s", (GLvoid
*) glColor3s
},
215 { "glColor3sv", (GLvoid
*) glColor3sv
},
216 { "glColor3ub", (GLvoid
*) glColor3ub
},
217 { "glColor3ubv", (GLvoid
*) glColor3ubv
},
218 { "glColor3ui", (GLvoid
*) glColor3ui
},
219 { "glColor3uiv", (GLvoid
*) glColor3uiv
},
220 { "glColor3us", (GLvoid
*) glColor3us
},
221 { "glColor3usv", (GLvoid
*) glColor3usv
},
222 { "glColor4b", (GLvoid
*) glColor4b
},
223 { "glColor4bv", (GLvoid
*) glColor4bv
},
224 { "glColor4d", (GLvoid
*) glColor4d
},
225 { "glColor4dv", (GLvoid
*) glColor4dv
},
226 { "glColor4f", (GLvoid
*) glColor4f
},
227 { "glColor4fv", (GLvoid
*) glColor4fv
},
228 { "glColor4i", (GLvoid
*) glColor4i
},
229 { "glColor4iv", (GLvoid
*) glColor4iv
},
230 { "glColor4s", (GLvoid
*) glColor4s
},
231 { "glColor4sv", (GLvoid
*) glColor4sv
},
232 { "glColor4ub", (GLvoid
*) glColor4ub
},
233 { "glColor4ubv", (GLvoid
*) glColor4ubv
},
234 { "glColor4ui", (GLvoid
*) glColor4ui
},
235 { "glColor4uiv", (GLvoid
*) glColor4uiv
},
236 { "glColor4us", (GLvoid
*) glColor4us
},
237 { "glColor4usv", (GLvoid
*) glColor4usv
},
238 { "glColorMask", (GLvoid
*) glColorMask
},
239 { "glColorMaterial", (GLvoid
*) glColorMaterial
},
240 { "glCopyPixels", (GLvoid
*) glCopyPixels
},
241 { "glCullFace", (GLvoid
*) glCullFace
},
242 { "glDeleteLists", (GLvoid
*) glDeleteLists
},
243 { "glDepthFunc", (GLvoid
*) glDepthFunc
},
244 { "glDepthMask", (GLvoid
*) glDepthMask
},
245 { "glDepthRange", (GLvoid
*) glDepthRange
},
246 { "glDisable", (GLvoid
*) glDisable
},
247 { "glDrawBuffer", (GLvoid
*) glDrawBuffer
},
248 { "glDrawPixels", (GLvoid
*) glDrawPixels
},
249 { "glEdgeFlag", (GLvoid
*) glEdgeFlag
},
250 { "glEdgeFlagv", (GLvoid
*) glEdgeFlagv
},
251 { "glEnable", (GLvoid
*) glEnable
},
252 { "glEnd", (GLvoid
*) glEnd
},
253 { "glEndList", (GLvoid
*) glEndList
},
254 { "glEvalCoord1d", (GLvoid
*) glEvalCoord1d
},
255 { "glEvalCoord1dv", (GLvoid
*) glEvalCoord1dv
},
256 { "glEvalCoord1f", (GLvoid
*) glEvalCoord1f
},
257 { "glEvalCoord1fv", (GLvoid
*) glEvalCoord1fv
},
258 { "glEvalCoord2d", (GLvoid
*) glEvalCoord2d
},
259 { "glEvalCoord2dv", (GLvoid
*) glEvalCoord2dv
},
260 { "glEvalCoord2f", (GLvoid
*) glEvalCoord2f
},
261 { "glEvalCoord2fv", (GLvoid
*) glEvalCoord2fv
},
262 { "glEvalMesh1", (GLvoid
*) glEvalMesh1
},
263 { "glEvalMesh2", (GLvoid
*) glEvalMesh2
},
264 { "glEvalPoint1", (GLvoid
*) glEvalPoint1
},
265 { "glEvalPoint2", (GLvoid
*) glEvalPoint2
},
266 { "glFeedbackBuffer", (GLvoid
*) glFeedbackBuffer
},
267 { "glFinish", (GLvoid
*) glFinish
},
268 { "glFlush", (GLvoid
*) glFlush
},
269 { "glFogf", (GLvoid
*) glFogf
},
270 { "glFogfv", (GLvoid
*) glFogfv
},
271 { "glFogi", (GLvoid
*) glFogi
},
272 { "glFogiv", (GLvoid
*) glFogiv
},
273 { "glFrontFace", (GLvoid
*) glFrontFace
},
274 { "glFrustum", (GLvoid
*) glFrustum
},
275 { "glGenLists", (GLvoid
*) glGenLists
},
276 { "glGetBooleanv", (GLvoid
*) glGetBooleanv
},
277 { "glGetClipPlane", (GLvoid
*) glGetClipPlane
},
278 { "glGetDoublev", (GLvoid
*) glGetDoublev
},
279 { "glGetError", (GLvoid
*) glGetError
},
280 { "glGetFloatv", (GLvoid
*) glGetFloatv
},
281 { "glGetIntegerv", (GLvoid
*) glGetIntegerv
},
282 { "glGetLightfv", (GLvoid
*) glGetLightfv
},
283 { "glGetLightiv", (GLvoid
*) glGetLightiv
},
284 { "glGetMapdv", (GLvoid
*) glGetMapdv
},
285 { "glGetMapfv", (GLvoid
*) glGetMapfv
},
286 { "glGetMapiv", (GLvoid
*) glGetMapiv
},
287 { "glGetMaterialfv", (GLvoid
*) glGetMaterialfv
},
288 { "glGetMaterialiv", (GLvoid
*) glGetMaterialiv
},
289 { "glGetPixelMapfv", (GLvoid
*) glGetPixelMapfv
},
290 { "glGetPixelMapuiv", (GLvoid
*) glGetPixelMapuiv
},
291 { "glGetPixelMapusv", (GLvoid
*) glGetPixelMapusv
},
292 { "glGetPolygonStipple", (GLvoid
*) glGetPolygonStipple
},
293 { "glGetString", (GLvoid
*) glGetString
},
294 { "glGetTexEnvfv", (GLvoid
*) glGetTexEnvfv
},
295 { "glGetTexEnviv", (GLvoid
*) glGetTexEnviv
},
296 { "glGetTexGendv", (GLvoid
*) glGetTexGendv
},
297 { "glGetTexGenfv", (GLvoid
*) glGetTexGenfv
},
298 { "glGetTexGeniv", (GLvoid
*) glGetTexGeniv
},
299 { "glGetTexImage", (GLvoid
*) glGetTexImage
},
300 { "glGetTexLevelParameterfv", (GLvoid
*) glGetTexLevelParameterfv
},
301 { "glGetTexLevelParameteriv", (GLvoid
*) glGetTexLevelParameteriv
},
302 { "glGetTexParameterfv", (GLvoid
*) glGetTexParameterfv
},
303 { "glGetTexParameteriv", (GLvoid
*) glGetTexParameteriv
},
304 { "glHint", (GLvoid
*) glHint
},
305 { "glIndexMask", (GLvoid
*) glIndexMask
},
306 { "glIndexd", (GLvoid
*) glIndexd
},
307 { "glIndexdv", (GLvoid
*) glIndexdv
},
308 { "glIndexf", (GLvoid
*) glIndexf
},
309 { "glIndexfv", (GLvoid
*) glIndexfv
},
310 { "glIndexi", (GLvoid
*) glIndexi
},
311 { "glIndexiv", (GLvoid
*) glIndexiv
},
312 { "glIndexs", (GLvoid
*) glIndexs
},
313 { "glIndexsv", (GLvoid
*) glIndexsv
},
314 { "glInitNames", (GLvoid
*) glInitNames
},
315 { "glIsEnabled", (GLvoid
*) glIsEnabled
},
316 { "glIsList", (GLvoid
*) glIsList
},
317 { "glLightModelf", (GLvoid
*) glLightModelf
},
318 { "glLightModelfv", (GLvoid
*) glLightModelfv
},
319 { "glLightModeli", (GLvoid
*) glLightModeli
},
320 { "glLightModeliv", (GLvoid
*) glLightModeliv
},
321 { "glLightf", (GLvoid
*) glLightf
},
322 { "glLightfv", (GLvoid
*) glLightfv
},
323 { "glLighti", (GLvoid
*) glLighti
},
324 { "glLightiv", (GLvoid
*) glLightiv
},
325 { "glLineStipple", (GLvoid
*) glLineStipple
},
326 { "glLineWidth", (GLvoid
*) glLineWidth
},
327 { "glListBase", (GLvoid
*) glListBase
},
328 { "glLoadIdentity", (GLvoid
*) glLoadIdentity
},
329 { "glLoadMatrixd", (GLvoid
*) glLoadMatrixd
},
330 { "glLoadMatrixf", (GLvoid
*) glLoadMatrixf
},
331 { "glLoadName", (GLvoid
*) glLoadName
},
332 { "glLogicOp", (GLvoid
*) glLogicOp
},
333 { "glMap1d", (GLvoid
*) glMap1d
},
334 { "glMap1f", (GLvoid
*) glMap1f
},
335 { "glMap2d", (GLvoid
*) glMap2d
},
336 { "glMap2f", (GLvoid
*) glMap2f
},
337 { "glMapGrid1d", (GLvoid
*) glMapGrid1d
},
338 { "glMapGrid1f", (GLvoid
*) glMapGrid1f
},
339 { "glMapGrid2d", (GLvoid
*) glMapGrid2d
},
340 { "glMapGrid2f", (GLvoid
*) glMapGrid2f
},
341 { "glMaterialf", (GLvoid
*) glMaterialf
},
342 { "glMaterialfv", (GLvoid
*) glMaterialfv
},
343 { "glMateriali", (GLvoid
*) glMateriali
},
344 { "glMaterialiv", (GLvoid
*) glMaterialiv
},
345 { "glMatrixMode", (GLvoid
*) glMatrixMode
},
346 { "glMultMatrixd", (GLvoid
*) glMultMatrixd
},
347 { "glMultMatrixf", (GLvoid
*) glMultMatrixf
},
348 { "glNewList", (GLvoid
*) glNewList
},
349 { "glNormal3b", (GLvoid
*) glNormal3b
},
350 { "glNormal3bv", (GLvoid
*) glNormal3bv
},
351 { "glNormal3d", (GLvoid
*) glNormal3d
},
352 { "glNormal3dv", (GLvoid
*) glNormal3dv
},
353 { "glNormal3f", (GLvoid
*) glNormal3f
},
354 { "glNormal3fv", (GLvoid
*) glNormal3fv
},
355 { "glNormal3i", (GLvoid
*) glNormal3i
},
356 { "glNormal3iv", (GLvoid
*) glNormal3iv
},
357 { "glNormal3s", (GLvoid
*) glNormal3s
},
358 { "glNormal3sv", (GLvoid
*) glNormal3sv
},
359 { "glOrtho", (GLvoid
*) glOrtho
},
360 { "glPassThrough", (GLvoid
*) glPassThrough
},
361 { "glPixelMapfv", (GLvoid
*) glPixelMapfv
},
362 { "glPixelMapuiv", (GLvoid
*) glPixelMapuiv
},
363 { "glPixelMapusv", (GLvoid
*) glPixelMapusv
},
364 { "glPixelStoref", (GLvoid
*) glPixelStoref
},
365 { "glPixelStorei", (GLvoid
*) glPixelStorei
},
366 { "glPixelTransferf", (GLvoid
*) glPixelTransferf
},
367 { "glPixelTransferi", (GLvoid
*) glPixelTransferi
},
368 { "glPixelZoom", (GLvoid
*) glPixelZoom
},
369 { "glPointSize", (GLvoid
*) glPointSize
},
370 { "glPolygonMode", (GLvoid
*) glPolygonMode
},
371 { "glPolygonOffset", (GLvoid
*) glPolygonOffset
},
372 { "glPolygonStipple", (GLvoid
*) glPolygonStipple
},
373 { "glPopAttrib", (GLvoid
*) glPopAttrib
},
374 { "glPopMatrix", (GLvoid
*) glPopMatrix
},
375 { "glPopName", (GLvoid
*) glPopName
},
376 { "glPushAttrib", (GLvoid
*) glPushAttrib
},
377 { "glPushMatrix", (GLvoid
*) glPushMatrix
},
378 { "glPushName", (GLvoid
*) glPushName
},
379 { "glRasterPos2d", (GLvoid
*) glRasterPos2d
},
380 { "glRasterPos2dv", (GLvoid
*) glRasterPos2dv
},
381 { "glRasterPos2f", (GLvoid
*) glRasterPos2f
},
382 { "glRasterPos2fv", (GLvoid
*) glRasterPos2fv
},
383 { "glRasterPos2i", (GLvoid
*) glRasterPos2i
},
384 { "glRasterPos2iv", (GLvoid
*) glRasterPos2iv
},
385 { "glRasterPos2s", (GLvoid
*) glRasterPos2s
},
386 { "glRasterPos2sv", (GLvoid
*) glRasterPos2sv
},
387 { "glRasterPos3d", (GLvoid
*) glRasterPos3d
},
388 { "glRasterPos3dv", (GLvoid
*) glRasterPos3dv
},
389 { "glRasterPos3f", (GLvoid
*) glRasterPos3f
},
390 { "glRasterPos3fv", (GLvoid
*) glRasterPos3fv
},
391 { "glRasterPos3i", (GLvoid
*) glRasterPos3i
},
392 { "glRasterPos3iv", (GLvoid
*) glRasterPos3iv
},
393 { "glRasterPos3s", (GLvoid
*) glRasterPos3s
},
394 { "glRasterPos3sv", (GLvoid
*) glRasterPos3sv
},
395 { "glRasterPos4d", (GLvoid
*) glRasterPos4d
},
396 { "glRasterPos4dv", (GLvoid
*) glRasterPos4dv
},
397 { "glRasterPos4f", (GLvoid
*) glRasterPos4f
},
398 { "glRasterPos4fv", (GLvoid
*) glRasterPos4fv
},
399 { "glRasterPos4i", (GLvoid
*) glRasterPos4i
},
400 { "glRasterPos4iv", (GLvoid
*) glRasterPos4iv
},
401 { "glRasterPos4s", (GLvoid
*) glRasterPos4s
},
402 { "glRasterPos4sv", (GLvoid
*) glRasterPos4sv
},
403 { "glReadBuffer", (GLvoid
*) glReadBuffer
},
404 { "glReadPixels", (GLvoid
*) glReadPixels
},
405 { "glRectd", (GLvoid
*) glRectd
},
406 { "glRectdv", (GLvoid
*) glRectdv
},
407 { "glRectf", (GLvoid
*) glRectf
},
408 { "glRectfv", (GLvoid
*) glRectfv
},
409 { "glRecti", (GLvoid
*) glRecti
},
410 { "glRectiv", (GLvoid
*) glRectiv
},
411 { "glRects", (GLvoid
*) glRects
},
412 { "glRectsv", (GLvoid
*) glRectsv
},
413 { "glRenderMode", (GLvoid
*) glRenderMode
},
414 { "glRotated", (GLvoid
*) glRotated
},
415 { "glRotatef", (GLvoid
*) glRotatef
},
416 { "glScaled", (GLvoid
*) glScaled
},
417 { "glScalef", (GLvoid
*) glScalef
},
418 { "glScissor", (GLvoid
*) glScissor
},
419 { "glSelectBuffer", (GLvoid
*) glSelectBuffer
},
420 { "glShadeModel", (GLvoid
*) glShadeModel
},
421 { "glStencilFunc", (GLvoid
*) glStencilFunc
},
422 { "glStencilMask", (GLvoid
*) glStencilMask
},
423 { "glStencilOp", (GLvoid
*) glStencilOp
},
424 { "glTexCoord1d", (GLvoid
*) glTexCoord1d
},
425 { "glTexCoord1dv", (GLvoid
*) glTexCoord1dv
},
426 { "glTexCoord1f", (GLvoid
*) glTexCoord1f
},
427 { "glTexCoord1fv", (GLvoid
*) glTexCoord1fv
},
428 { "glTexCoord1i", (GLvoid
*) glTexCoord1i
},
429 { "glTexCoord1iv", (GLvoid
*) glTexCoord1iv
},
430 { "glTexCoord1s", (GLvoid
*) glTexCoord1s
},
431 { "glTexCoord1sv", (GLvoid
*) glTexCoord1sv
},
432 { "glTexCoord2d", (GLvoid
*) glTexCoord2d
},
433 { "glTexCoord2dv", (GLvoid
*) glTexCoord2dv
},
434 { "glTexCoord2f", (GLvoid
*) glTexCoord2f
},
435 { "glTexCoord2fv", (GLvoid
*) glTexCoord2fv
},
436 { "glTexCoord2i", (GLvoid
*) glTexCoord2i
},
437 { "glTexCoord2iv", (GLvoid
*) glTexCoord2iv
},
438 { "glTexCoord2s", (GLvoid
*) glTexCoord2s
},
439 { "glTexCoord2sv", (GLvoid
*) glTexCoord2sv
},
440 { "glTexCoord3d", (GLvoid
*) glTexCoord3d
},
441 { "glTexCoord3dv", (GLvoid
*) glTexCoord3dv
},
442 { "glTexCoord3f", (GLvoid
*) glTexCoord3f
},
443 { "glTexCoord3fv", (GLvoid
*) glTexCoord3fv
},
444 { "glTexCoord3i", (GLvoid
*) glTexCoord3i
},
445 { "glTexCoord3iv", (GLvoid
*) glTexCoord3iv
},
446 { "glTexCoord3s", (GLvoid
*) glTexCoord3s
},
447 { "glTexCoord3sv", (GLvoid
*) glTexCoord3sv
},
448 { "glTexCoord4d", (GLvoid
*) glTexCoord4d
},
449 { "glTexCoord4dv", (GLvoid
*) glTexCoord4dv
},
450 { "glTexCoord4f", (GLvoid
*) glTexCoord4f
},
451 { "glTexCoord4fv", (GLvoid
*) glTexCoord4fv
},
452 { "glTexCoord4i", (GLvoid
*) glTexCoord4i
},
453 { "glTexCoord4iv", (GLvoid
*) glTexCoord4iv
},
454 { "glTexCoord4s", (GLvoid
*) glTexCoord4s
},
455 { "glTexCoord4sv", (GLvoid
*) glTexCoord4sv
},
456 { "glTexEnvf", (GLvoid
*) glTexEnvf
},
457 { "glTexEnvfv", (GLvoid
*) glTexEnvfv
},
458 { "glTexEnvi", (GLvoid
*) glTexEnvi
},
459 { "glTexEnviv", (GLvoid
*) glTexEnviv
},
460 { "glTexGend", (GLvoid
*) glTexGend
},
461 { "glTexGendv", (GLvoid
*) glTexGendv
},
462 { "glTexGenf", (GLvoid
*) glTexGenf
},
463 { "glTexGenfv", (GLvoid
*) glTexGenfv
},
464 { "glTexGeni", (GLvoid
*) glTexGeni
},
465 { "glTexGeniv", (GLvoid
*) glTexGeniv
},
466 { "glTexImage1D", (GLvoid
*) glTexImage1D
},
467 { "glTexImage2D", (GLvoid
*) glTexImage2D
},
468 { "glTexParameterf", (GLvoid
*) glTexParameterf
},
469 { "glTexParameterfv", (GLvoid
*) glTexParameterfv
},
470 { "glTexParameteri", (GLvoid
*) glTexParameteri
},
471 { "glTexParameteriv", (GLvoid
*) glTexParameteriv
},
472 { "glTranslated", (GLvoid
*) glTranslated
},
473 { "glTranslatef", (GLvoid
*) glTranslatef
},
474 { "glVertex2d", (GLvoid
*) glVertex2d
},
475 { "glVertex2dv", (GLvoid
*) glVertex2dv
},
476 { "glVertex2f", (GLvoid
*) glVertex2f
},
477 { "glVertex2fv", (GLvoid
*) glVertex2fv
},
478 { "glVertex2i", (GLvoid
*) glVertex2i
},
479 { "glVertex2iv", (GLvoid
*) glVertex2iv
},
480 { "glVertex2s", (GLvoid
*) glVertex2s
},
481 { "glVertex2sv", (GLvoid
*) glVertex2sv
},
482 { "glVertex3d", (GLvoid
*) glVertex3d
},
483 { "glVertex3dv", (GLvoid
*) glVertex3dv
},
484 { "glVertex3f", (GLvoid
*) glVertex3f
},
485 { "glVertex3fv", (GLvoid
*) glVertex3fv
},
486 { "glVertex3i", (GLvoid
*) glVertex3i
},
487 { "glVertex3iv", (GLvoid
*) glVertex3iv
},
488 { "glVertex3s", (GLvoid
*) glVertex3s
},
489 { "glVertex3sv", (GLvoid
*) glVertex3sv
},
490 { "glVertex4d", (GLvoid
*) glVertex4d
},
491 { "glVertex4dv", (GLvoid
*) glVertex4dv
},
492 { "glVertex4f", (GLvoid
*) glVertex4f
},
493 { "glVertex4fv", (GLvoid
*) glVertex4fv
},
494 { "glVertex4i", (GLvoid
*) glVertex4i
},
495 { "glVertex4iv", (GLvoid
*) glVertex4iv
},
496 { "glVertex4s", (GLvoid
*) glVertex4s
},
497 { "glVertex4sv", (GLvoid
*) glVertex4sv
},
498 { "glViewport", (GLvoid
*) glViewport
},
500 #ifdef _GLAPI_VERSION_1_1
501 { "glAreTexturesResident", (GLvoid
*) glAreTexturesResident
},
502 { "glArrayElement", (GLvoid
*) glArrayElement
},
503 { "glBindTexture", (GLvoid
*) glBindTexture
},
504 { "glColorPointer", (GLvoid
*) glColorPointer
},
505 { "glCopyTexImage1D", (GLvoid
*) glCopyTexImage1D
},
506 { "glCopyTexImage2D", (GLvoid
*) glCopyTexImage2D
},
507 { "glCopyTexSubImage1D", (GLvoid
*) glCopyTexSubImage1D
},
508 { "glCopyTexSubImage2D", (GLvoid
*) glCopyTexSubImage2D
},
509 { "glDeleteTextures", (GLvoid
*) glDeleteTextures
},
510 { "glDisableClientState", (GLvoid
*) glDisableClientState
},
511 { "glDrawArrays", (GLvoid
*) glDrawArrays
},
512 { "glDrawElements", (GLvoid
*) glDrawElements
},
513 { "glEdgeFlagPointer", (GLvoid
*) glEdgeFlagPointer
},
514 { "glEnableClientState", (GLvoid
*) glEnableClientState
},
515 { "glGenTextures", (GLvoid
*) glGenTextures
},
516 { "glGetPointerv", (GLvoid
*) glGetPointerv
},
517 { "glIndexPointer", (GLvoid
*) glIndexPointer
},
518 { "glIndexub", (GLvoid
*) glIndexub
},
519 { "glIndexubv", (GLvoid
*) glIndexubv
},
520 { "glInterleavedArrays", (GLvoid
*) glInterleavedArrays
},
521 { "glIsTexture", (GLvoid
*) glIsTexture
},
522 { "glNormalPointer", (GLvoid
*) glNormalPointer
},
523 { "glPopClientAttrib", (GLvoid
*) glPopClientAttrib
},
524 { "glPrioritizeTextures", (GLvoid
*) glPrioritizeTextures
},
525 { "glPushClientAttrib", (GLvoid
*) glPushClientAttrib
},
526 { "glTexCoordPointer", (GLvoid
*) glTexCoordPointer
},
527 { "glTexSubImage1D", (GLvoid
*) glTexSubImage1D
},
528 { "glTexSubImage2D", (GLvoid
*) glTexSubImage2D
},
529 { "glVertexPointer", (GLvoid
*) glVertexPointer
},
532 #ifdef _GLAPI_VERSION_1_2
533 { "glCopyTexSubImage3D", (GLvoid
*) glCopyTexSubImage3D
},
534 { "glDrawRangeElements", (GLvoid
*) glDrawRangeElements
},
535 { "glTexImage3D", (GLvoid
*) glTexImage3D
},
536 { "glTexSubImage3D", (GLvoid
*) glTexSubImage3D
},
538 #ifdef _GLAPI_ARB_imaging
539 { "glBlendColor", (GLvoid
*) glBlendColor
},
540 { "glBlendEquation", (GLvoid
*) glBlendEquation
},
541 { "glColorSubTable", (GLvoid
*) glColorSubTable
},
542 { "glColorTable", (GLvoid
*) glColorTable
},
543 { "glColorTableParameterfv", (GLvoid
*) glColorTableParameterfv
},
544 { "glColorTableParameteriv", (GLvoid
*) glColorTableParameteriv
},
545 { "glConvolutionFilter1D", (GLvoid
*) glConvolutionFilter1D
},
546 { "glConvolutionFilter2D", (GLvoid
*) glConvolutionFilter2D
},
547 { "glConvolutionParameterf", (GLvoid
*) glConvolutionParameterf
},
548 { "glConvolutionParameterfv", (GLvoid
*) glConvolutionParameterfv
},
549 { "glConvolutionParameteri", (GLvoid
*) glConvolutionParameteri
},
550 { "glConvolutionParameteriv", (GLvoid
*) glConvolutionParameteriv
},
551 { "glCopyColorSubTable", (GLvoid
*) glCopyColorSubTable
},
552 { "glCopyColorTable", (GLvoid
*) glCopyColorTable
},
553 { "glCopyConvolutionFilter1D", (GLvoid
*) glCopyConvolutionFilter1D
},
554 { "glCopyConvolutionFilter2D", (GLvoid
*) glCopyConvolutionFilter2D
},
555 { "glGetColorTable", (GLvoid
*) glGetColorTable
},
556 { "glGetColorTableParameterfv", (GLvoid
*) glGetColorTableParameterfv
},
557 { "glGetColorTableParameteriv", (GLvoid
*) glGetColorTableParameteriv
},
558 { "glGetConvolutionFilter", (GLvoid
*) glGetConvolutionFilter
},
559 { "glGetConvolutionParameterfv", (GLvoid
*) glGetConvolutionParameterfv
},
560 { "glGetConvolutionParameteriv", (GLvoid
*) glGetConvolutionParameteriv
},
561 { "glGetHistogram", (GLvoid
*) glGetHistogram
},
562 { "glGetHistogramParameterfv", (GLvoid
*) glGetHistogramParameterfv
},
563 { "glGetHistogramParameteriv", (GLvoid
*) glGetHistogramParameteriv
},
564 { "glGetMinmax", (GLvoid
*) glGetMinmax
},
565 { "glGetMinmaxParameterfv", (GLvoid
*) glGetMinmaxParameterfv
},
566 { "glGetMinmaxParameteriv", (GLvoid
*) glGetMinmaxParameteriv
},
567 { "glGetSeparableFilter", (GLvoid
*) glGetSeparableFilter
},
568 { "glHistogram", (GLvoid
*) glHistogram
},
569 { "glMinmax", (GLvoid
*) glMinmax
},
570 { "glResetHistogram", (GLvoid
*) glResetHistogram
},
571 { "glResetMinmax", (GLvoid
*) glResetMinmax
},
572 { "glSeparableFilter2D", (GLvoid
*) glSeparableFilter2D
},
576 #ifdef _GLAPI_EXT_paletted_texture
577 { "glColorTableEXT", (GLvoid
*) glColorTableEXT
},
578 { "glColorSubTableEXT", (GLvoid
*) glColorSubTableEXT
},
579 { "glGetColorTableEXT", (GLvoid
*) glGetColorTableEXT
},
580 { "glGetColorTableParameterfvEXT", (GLvoid
*) glGetColorTableParameterfvEXT
},
581 { "glGetColorTableParameterivEXT", (GLvoid
*) glGetColorTableParameterivEXT
},
584 #ifdef _GLAPI_EXT_compiled_vertex_array
585 { "glLockArraysEXT", (GLvoid
*) glLockArraysEXT
},
586 { "glUnlockArraysEXT", (GLvoid
*) glUnlockArraysEXT
},
589 #ifdef _GLAPI_EXT_point_parameters
590 { "glPointParameterfEXT", (GLvoid
*) glPointParameterfEXT
},
591 { "glPointParameterfvEXT", (GLvoid
*) glPointParameterfvEXT
},
594 #ifdef _GLAPI_EXT_polygon_offset
595 { "glPolygonOffsetEXT", (GLvoid
*) glPolygonOffsetEXT
},
598 #ifdef _GLAPI_EXT_blend_minmax
599 { "glBlendEquationEXT", (GLvoid
*) glBlendEquationEXT
},
602 #ifdef _GLAPI_EXT_blend_color
603 { "glBlendColorEXT", (GLvoid
*) glBlendColorEXT
},
606 #ifdef _GLAPI_ARB_multitexture
607 { "glActiveTextureARB", (GLvoid
*) glActiveTextureARB
},
608 { "glClientActiveTextureARB", (GLvoid
*) glClientActiveTextureARB
},
609 { "glMultiTexCoord1dARB", (GLvoid
*) glMultiTexCoord1dARB
},
610 { "glMultiTexCoord1dvARB", (GLvoid
*) glMultiTexCoord1dvARB
},
611 { "glMultiTexCoord1fARB", (GLvoid
*) glMultiTexCoord1fARB
},
612 { "glMultiTexCoord1fvARB", (GLvoid
*) glMultiTexCoord1fvARB
},
613 { "glMultiTexCoord1iARB", (GLvoid
*) glMultiTexCoord1iARB
},
614 { "glMultiTexCoord1ivARB", (GLvoid
*) glMultiTexCoord1ivARB
},
615 { "glMultiTexCoord1sARB", (GLvoid
*) glMultiTexCoord1sARB
},
616 { "glMultiTexCoord1svARB", (GLvoid
*) glMultiTexCoord1svARB
},
617 { "glMultiTexCoord2dARB", (GLvoid
*) glMultiTexCoord2dARB
},
618 { "glMultiTexCoord2dvARB", (GLvoid
*) glMultiTexCoord2dvARB
},
619 { "glMultiTexCoord2fARB", (GLvoid
*) glMultiTexCoord2fARB
},
620 { "glMultiTexCoord2fvARB", (GLvoid
*) glMultiTexCoord2fvARB
},
621 { "glMultiTexCoord2iARB", (GLvoid
*) glMultiTexCoord2iARB
},
622 { "glMultiTexCoord2ivARB", (GLvoid
*) glMultiTexCoord2ivARB
},
623 { "glMultiTexCoord2sARB", (GLvoid
*) glMultiTexCoord2sARB
},
624 { "glMultiTexCoord2svARB", (GLvoid
*) glMultiTexCoord2svARB
},
625 { "glMultiTexCoord3dARB", (GLvoid
*) glMultiTexCoord3dARB
},
626 { "glMultiTexCoord3dvARB", (GLvoid
*) glMultiTexCoord3dvARB
},
627 { "glMultiTexCoord3fARB", (GLvoid
*) glMultiTexCoord3fARB
},
628 { "glMultiTexCoord3fvARB", (GLvoid
*) glMultiTexCoord3fvARB
},
629 { "glMultiTexCoord3iARB", (GLvoid
*) glMultiTexCoord3iARB
},
630 { "glMultiTexCoord3ivARB", (GLvoid
*) glMultiTexCoord3ivARB
},
631 { "glMultiTexCoord3sARB", (GLvoid
*) glMultiTexCoord3sARB
},
632 { "glMultiTexCoord3svARB", (GLvoid
*) glMultiTexCoord3svARB
},
633 { "glMultiTexCoord4dARB", (GLvoid
*) glMultiTexCoord4dARB
},
634 { "glMultiTexCoord4dvARB", (GLvoid
*) glMultiTexCoord4dvARB
},
635 { "glMultiTexCoord4fARB", (GLvoid
*) glMultiTexCoord4fARB
},
636 { "glMultiTexCoord4fvARB", (GLvoid
*) glMultiTexCoord4fvARB
},
637 { "glMultiTexCoord4iARB", (GLvoid
*) glMultiTexCoord4iARB
},
638 { "glMultiTexCoord4ivARB", (GLvoid
*) glMultiTexCoord4ivARB
},
639 { "glMultiTexCoord4sARB", (GLvoid
*) glMultiTexCoord4sARB
},
640 { "glMultiTexCoord4svARB", (GLvoid
*) glMultiTexCoord4svARB
},
643 #ifdef _GLAPI_INGR_blend_func_separate
644 { "glBlendFuncSeparateINGR", (GLvoid
*) glBlendFuncSeparateINGR
},
647 #ifdef _GLAPI_MESA_window_pos
648 { "glWindowPos4fMESA", (GLvoid
*) glWindowPos4fMESA
},
651 #ifdef _GLAPI_MESA_resize_buffers
652 { "glResizeBuffersMESA", (GLvoid
*) glResizeBuffersMESA
},
655 #ifdef _GLAPI_ARB_transpose_matrix
656 { "glLoadTransposeMatrixdARB", (GLvoid
*) glLoadTransposeMatrixdARB
},
657 { "glLoadTransposeMatrixfARB", (GLvoid
*) glLoadTransposeMatrixfARB
},
658 { "glMultTransposeMatrixdARB", (GLvoid
*) glMultTransposeMatrixdARB
},
659 { "glMultTransposeMatrixfARB", (GLvoid
*) glMultTransposeMatrixfARB
},
662 { NULL
, NULL
} /* end of list marker */
668 * Return dispatch table offset of the named static (built-in) function.
669 * Return -1 if function not found.
672 get_static_proc_offset(const char *funcName
)
675 for (i
= 0; static_functions
[i
].Name
; i
++) {
676 if (strcmp(static_functions
[i
].Name
, funcName
) == 0) {
685 * Return dispatch function address the named static (built-in) function.
686 * Return NULL if function not found.
689 get_static_proc_address(const char *funcName
)
691 GLuint i
= get_static_proc_offset(funcName
);
693 return static_functions
[i
].Address
;
700 /**********************************************************************
701 * Extension function management.
702 **********************************************************************/
705 struct _glapi_ext_entrypoint
{
706 const char *Name
; /* the extension function's name */
707 GLuint Offset
; /* relative to start of dispatch table */
708 GLvoid
*Address
; /* address of dispatch function */
711 static struct _glapi_ext_entrypoint ExtEntryTable
[_GLAPI_EXTRA_SLOTS
];
712 static GLuint NumExtEntryPoints
= 0;
717 * Generate a dispatch function (entrypoint) which jumps through
718 * the given slot number (offset) in the current dispatch table.
721 generate_entrypoint(GLuint offset
)
723 /* XXX need to generate some assembly code here */
731 * Add a new extension function entrypoint.
732 * Return: GL_TRUE = success or GL_FALSE = failure
735 _glapi_add_entrypoint(const char *funcName
, GLuint offset
)
737 /* first check if the named function is already statically present */
738 GLint index
= get_static_proc_offset(funcName
);
740 assert(index
== offset
);
743 else if (offset
< _glapi_get_dispatch_table_size()) {
744 /* be sure index and name match known data */
746 for (i
= 0; i
< NumExtEntryPoints
; i
++) {
747 if (strcmp(ExtEntryTable
[i
].Name
, funcName
) == 0) {
748 /* function already registered with api */
749 if (ExtEntryTable
[i
].Offset
== offset
) {
750 return GL_TRUE
; /* offsets match */
753 return GL_FALSE
; /* bad offset! */
757 assert(NumExtEntryPoints
< _GLAPI_EXTRA_SLOTS
);
758 ExtEntryTable
[NumExtEntryPoints
].Name
= strdup(funcName
);
759 ExtEntryTable
[NumExtEntryPoints
].Offset
= offset
;
760 ExtEntryTable
[NumExtEntryPoints
].Address
= generate_entrypoint(offset
);
772 * Return offset of entrypoint for named function within dispatch table.
775 _glapi_get_proc_offset(const char *funcName
)
777 /* search extension functions first */
779 for (i
= 0; i
< NumExtEntryPoints
; i
++) {
780 if (strcmp(ExtEntryTable
[i
].Name
, funcName
) == 0) {
781 return ExtEntryTable
[i
].Offset
;
785 /* search static functions */
786 return get_static_proc_offset(funcName
);
792 * Return entrypoint for named function.
795 _glapi_get_proc_address(const char *funcName
)
797 /* search extension functions first */
799 for (i
= 0; i
< NumExtEntryPoints
; i
++) {
800 if (strcmp(ExtEntryTable
[i
].Name
, funcName
) == 0) {
801 return ExtEntryTable
[i
].Address
;
805 /* search static functions */
806 return get_static_proc_address(funcName
);
812 * Make sure there are no NULL pointers in the given dispatch table.
813 * Intented for debugging purposes.
816 _glapi_check_table(const struct _glapi_table
*table
)
818 assert(table
->Accum
);
819 assert(table
->AlphaFunc
);
820 assert(table
->Begin
);
821 assert(table
->Bitmap
);
822 assert(table
->BlendFunc
);
823 assert(table
->CallList
);
824 assert(table
->CallLists
);
825 assert(table
->Clear
);
826 assert(table
->ClearAccum
);
827 assert(table
->ClearColor
);
828 assert(table
->ClearDepth
);
829 assert(table
->ClearIndex
);
830 assert(table
->ClearStencil
);
831 assert(table
->ClipPlane
);
832 assert(table
->Color3b
);
833 assert(table
->Color3bv
);
834 assert(table
->Color3d
);
835 assert(table
->Color3dv
);
836 assert(table
->Color3f
);
837 assert(table
->Color3fv
);
838 assert(table
->Color3i
);
839 assert(table
->Color3iv
);
840 assert(table
->Color3s
);
841 assert(table
->Color3sv
);
842 assert(table
->Color3ub
);
843 assert(table
->Color3ubv
);
844 assert(table
->Color3ui
);
845 assert(table
->Color3uiv
);
846 assert(table
->Color3us
);
847 assert(table
->Color3usv
);
848 assert(table
->Color4b
);
849 assert(table
->Color4bv
);
850 assert(table
->Color4d
);
851 assert(table
->Color4dv
);
852 assert(table
->Color4f
);
853 assert(table
->Color4fv
);
854 assert(table
->Color4i
);
855 assert(table
->Color4iv
);
856 assert(table
->Color4s
);
857 assert(table
->Color4sv
);
858 assert(table
->Color4ub
);
859 assert(table
->Color4ubv
);
860 assert(table
->Color4ui
);
861 assert(table
->Color4uiv
);
862 assert(table
->Color4us
);
863 assert(table
->Color4usv
);
864 assert(table
->ColorMask
);
865 assert(table
->ColorMaterial
);
866 assert(table
->CopyPixels
);
867 assert(table
->CullFace
);
868 assert(table
->DeleteLists
);
869 assert(table
->DepthFunc
);
870 assert(table
->DepthMask
);
871 assert(table
->DepthRange
);
872 assert(table
->Disable
);
873 assert(table
->DrawBuffer
);
874 assert(table
->DrawElements
);
875 assert(table
->DrawPixels
);
876 assert(table
->EdgeFlag
);
877 assert(table
->EdgeFlagv
);
878 assert(table
->Enable
);
880 assert(table
->EndList
);
881 assert(table
->EvalCoord1d
);
882 assert(table
->EvalCoord1dv
);
883 assert(table
->EvalCoord1f
);
884 assert(table
->EvalCoord1fv
);
885 assert(table
->EvalCoord2d
);
886 assert(table
->EvalCoord2dv
);
887 assert(table
->EvalCoord2f
);
888 assert(table
->EvalCoord2fv
);
889 assert(table
->EvalMesh1
);
890 assert(table
->EvalMesh2
);
891 assert(table
->EvalPoint1
);
892 assert(table
->EvalPoint2
);
893 assert(table
->FeedbackBuffer
);
894 assert(table
->Finish
);
895 assert(table
->Flush
);
897 assert(table
->Fogfv
);
899 assert(table
->Fogiv
);
900 assert(table
->FrontFace
);
901 assert(table
->Frustum
);
902 assert(table
->GenLists
);
903 assert(table
->GetBooleanv
);
904 assert(table
->GetClipPlane
);
905 assert(table
->GetDoublev
);
906 assert(table
->GetError
);
907 assert(table
->GetFloatv
);
908 assert(table
->GetIntegerv
);
909 assert(table
->GetLightfv
);
910 assert(table
->GetLightiv
);
911 assert(table
->GetMapdv
);
912 assert(table
->GetMapfv
);
913 assert(table
->GetMapiv
);
914 assert(table
->GetMaterialfv
);
915 assert(table
->GetMaterialiv
);
916 assert(table
->GetPixelMapfv
);
917 assert(table
->GetPixelMapuiv
);
918 assert(table
->GetPixelMapusv
);
919 assert(table
->GetPolygonStipple
);
920 assert(table
->GetString
);
921 assert(table
->GetTexEnvfv
);
922 assert(table
->GetTexEnviv
);
923 assert(table
->GetTexGendv
);
924 assert(table
->GetTexGenfv
);
925 assert(table
->GetTexGeniv
);
926 assert(table
->GetTexImage
);
927 assert(table
->GetTexLevelParameterfv
);
928 assert(table
->GetTexLevelParameteriv
);
929 assert(table
->GetTexParameterfv
);
930 assert(table
->GetTexParameteriv
);
932 assert(table
->IndexMask
);
933 assert(table
->Indexd
);
934 assert(table
->Indexdv
);
935 assert(table
->Indexf
);
936 assert(table
->Indexfv
);
937 assert(table
->Indexi
);
938 assert(table
->Indexiv
);
939 assert(table
->Indexs
);
940 assert(table
->Indexsv
);
941 assert(table
->InitNames
);
942 assert(table
->IsEnabled
);
943 assert(table
->IsList
);
944 assert(table
->LightModelf
);
945 assert(table
->LightModelfv
);
946 assert(table
->LightModeli
);
947 assert(table
->LightModeliv
);
948 assert(table
->Lightf
);
949 assert(table
->Lightfv
);
950 assert(table
->Lighti
);
951 assert(table
->Lightiv
);
952 assert(table
->LineStipple
);
953 assert(table
->LineWidth
);
954 assert(table
->ListBase
);
955 assert(table
->LoadIdentity
);
956 assert(table
->LoadMatrixd
);
957 assert(table
->LoadMatrixf
);
958 assert(table
->LoadName
);
959 assert(table
->LogicOp
);
960 assert(table
->Map1d
);
961 assert(table
->Map1f
);
962 assert(table
->Map2d
);
963 assert(table
->Map2f
);
964 assert(table
->MapGrid1d
);
965 assert(table
->MapGrid1f
);
966 assert(table
->MapGrid2d
);
967 assert(table
->MapGrid2f
);
968 assert(table
->Materialf
);
969 assert(table
->Materialfv
);
970 assert(table
->Materiali
);
971 assert(table
->Materialiv
);
972 assert(table
->MatrixMode
);
973 assert(table
->MultMatrixd
);
974 assert(table
->MultMatrixf
);
975 assert(table
->NewList
);
976 assert(table
->Normal3b
);
977 assert(table
->Normal3bv
);
978 assert(table
->Normal3d
);
979 assert(table
->Normal3dv
);
980 assert(table
->Normal3f
);
981 assert(table
->Normal3fv
);
982 assert(table
->Normal3i
);
983 assert(table
->Normal3iv
);
984 assert(table
->Normal3s
);
985 assert(table
->Normal3sv
);
986 assert(table
->Ortho
);
987 assert(table
->PassThrough
);
988 assert(table
->PixelMapfv
);
989 assert(table
->PixelMapuiv
);
990 assert(table
->PixelMapusv
);
991 assert(table
->PixelStoref
);
992 assert(table
->PixelStorei
);
993 assert(table
->PixelTransferf
);
994 assert(table
->PixelTransferi
);
995 assert(table
->PixelZoom
);
996 assert(table
->PointSize
);
997 assert(table
->PolygonMode
);
998 assert(table
->PolygonOffset
);
999 assert(table
->PolygonStipple
);
1000 assert(table
->PopAttrib
);
1001 assert(table
->PopMatrix
);
1002 assert(table
->PopName
);
1003 assert(table
->PushAttrib
);
1004 assert(table
->PushMatrix
);
1005 assert(table
->PushName
);
1006 assert(table
->RasterPos2d
);
1007 assert(table
->RasterPos2dv
);
1008 assert(table
->RasterPos2f
);
1009 assert(table
->RasterPos2fv
);
1010 assert(table
->RasterPos2i
);
1011 assert(table
->RasterPos2iv
);
1012 assert(table
->RasterPos2s
);
1013 assert(table
->RasterPos2sv
);
1014 assert(table
->RasterPos3d
);
1015 assert(table
->RasterPos3dv
);
1016 assert(table
->RasterPos3f
);
1017 assert(table
->RasterPos3fv
);
1018 assert(table
->RasterPos3i
);
1019 assert(table
->RasterPos3iv
);
1020 assert(table
->RasterPos3s
);
1021 assert(table
->RasterPos3sv
);
1022 assert(table
->RasterPos4d
);
1023 assert(table
->RasterPos4dv
);
1024 assert(table
->RasterPos4f
);
1025 assert(table
->RasterPos4fv
);
1026 assert(table
->RasterPos4i
);
1027 assert(table
->RasterPos4iv
);
1028 assert(table
->RasterPos4s
);
1029 assert(table
->RasterPos4sv
);
1030 assert(table
->ReadBuffer
);
1031 assert(table
->ReadPixels
);
1032 assert(table
->Rectd
);
1033 assert(table
->Rectdv
);
1034 assert(table
->Rectf
);
1035 assert(table
->Rectfv
);
1036 assert(table
->Recti
);
1037 assert(table
->Rectiv
);
1038 assert(table
->Rects
);
1039 assert(table
->Rectsv
);
1040 assert(table
->RenderMode
);
1041 assert(table
->Rotated
);
1042 assert(table
->Rotatef
);
1043 assert(table
->Scaled
);
1044 assert(table
->Scalef
);
1045 assert(table
->Scissor
);
1046 assert(table
->SelectBuffer
);
1047 assert(table
->ShadeModel
);
1048 assert(table
->StencilFunc
);
1049 assert(table
->StencilMask
);
1050 assert(table
->StencilOp
);
1051 assert(table
->TexCoord1d
);
1052 assert(table
->TexCoord1dv
);
1053 assert(table
->TexCoord1f
);
1054 assert(table
->TexCoord1fv
);
1055 assert(table
->TexCoord1i
);
1056 assert(table
->TexCoord1iv
);
1057 assert(table
->TexCoord1s
);
1058 assert(table
->TexCoord1sv
);
1059 assert(table
->TexCoord2d
);
1060 assert(table
->TexCoord2dv
);
1061 assert(table
->TexCoord2f
);
1062 assert(table
->TexCoord2fv
);
1063 assert(table
->TexCoord2i
);
1064 assert(table
->TexCoord2iv
);
1065 assert(table
->TexCoord2s
);
1066 assert(table
->TexCoord2sv
);
1067 assert(table
->TexCoord3d
);
1068 assert(table
->TexCoord3dv
);
1069 assert(table
->TexCoord3f
);
1070 assert(table
->TexCoord3fv
);
1071 assert(table
->TexCoord3i
);
1072 assert(table
->TexCoord3iv
);
1073 assert(table
->TexCoord3s
);
1074 assert(table
->TexCoord3sv
);
1075 assert(table
->TexCoord4d
);
1076 assert(table
->TexCoord4dv
);
1077 assert(table
->TexCoord4f
);
1078 assert(table
->TexCoord4fv
);
1079 assert(table
->TexCoord4i
);
1080 assert(table
->TexCoord4iv
);
1081 assert(table
->TexCoord4s
);
1082 assert(table
->TexCoord4sv
);
1083 assert(table
->TexEnvf
);
1084 assert(table
->TexEnvfv
);
1085 assert(table
->TexEnvi
);
1086 assert(table
->TexEnviv
);
1087 assert(table
->TexGend
);
1088 assert(table
->TexGendv
);
1089 assert(table
->TexGenf
);
1090 assert(table
->TexGenfv
);
1091 assert(table
->TexGeni
);
1092 assert(table
->TexGeniv
);
1093 assert(table
->TexImage1D
);
1094 assert(table
->TexImage2D
);
1095 assert(table
->TexParameterf
);
1096 assert(table
->TexParameterfv
);
1097 assert(table
->TexParameteri
);
1098 assert(table
->TexParameteriv
);
1099 assert(table
->Translated
);
1100 assert(table
->Translatef
);
1101 assert(table
->Vertex2d
);
1102 assert(table
->Vertex2dv
);
1103 assert(table
->Vertex2f
);
1104 assert(table
->Vertex2fv
);
1105 assert(table
->Vertex2i
);
1106 assert(table
->Vertex2iv
);
1107 assert(table
->Vertex2s
);
1108 assert(table
->Vertex2sv
);
1109 assert(table
->Vertex3d
);
1110 assert(table
->Vertex3dv
);
1111 assert(table
->Vertex3f
);
1112 assert(table
->Vertex3fv
);
1113 assert(table
->Vertex3i
);
1114 assert(table
->Vertex3iv
);
1115 assert(table
->Vertex3s
);
1116 assert(table
->Vertex3sv
);
1117 assert(table
->Vertex4d
);
1118 assert(table
->Vertex4dv
);
1119 assert(table
->Vertex4f
);
1120 assert(table
->Vertex4fv
);
1121 assert(table
->Vertex4i
);
1122 assert(table
->Vertex4iv
);
1123 assert(table
->Vertex4s
);
1124 assert(table
->Vertex4sv
);
1125 assert(table
->Viewport
);
1127 #ifdef _GLAPI_VERSION_1_1
1128 assert(table
->AreTexturesResident
);
1129 assert(table
->ArrayElement
);
1130 assert(table
->BindTexture
);
1131 assert(table
->ColorPointer
);
1132 assert(table
->CopyTexImage1D
);
1133 assert(table
->CopyTexImage2D
);
1134 assert(table
->CopyTexSubImage1D
);
1135 assert(table
->CopyTexSubImage2D
);
1136 assert(table
->DeleteTextures
);
1137 assert(table
->DisableClientState
);
1138 assert(table
->DrawArrays
);
1139 assert(table
->EdgeFlagPointer
);
1140 assert(table
->EnableClientState
);
1141 assert(table
->GenTextures
);
1142 assert(table
->GetPointerv
);
1143 assert(table
->IndexPointer
);
1144 assert(table
->Indexub
);
1145 assert(table
->Indexubv
);
1146 assert(table
->InterleavedArrays
);
1147 assert(table
->IsTexture
);
1148 assert(table
->NormalPointer
);
1149 assert(table
->PopClientAttrib
);
1150 assert(table
->PrioritizeTextures
);
1151 assert(table
->PushClientAttrib
);
1152 assert(table
->TexCoordPointer
);
1153 assert(table
->TexSubImage1D
);
1154 assert(table
->TexSubImage2D
);
1155 assert(table
->VertexPointer
);
1158 #ifdef _GLAPI_VERSION_1_2
1159 assert(table
->CopyTexSubImage3D
);
1160 assert(table
->DrawRangeElements
);
1161 assert(table
->TexImage3D
);
1162 assert(table
->TexSubImage3D
);
1163 #ifdef _GLAPI_ARB_imaging
1164 assert(table
->BlendColor
);
1165 assert(table
->BlendEquation
);
1166 assert(table
->ColorSubTable
);
1167 assert(table
->ColorTable
);
1168 assert(table
->ColorTableParameterfv
);
1169 assert(table
->ColorTableParameteriv
);
1170 assert(table
->ConvolutionFilter1D
);
1171 assert(table
->ConvolutionFilter2D
);
1172 assert(table
->ConvolutionParameterf
);
1173 assert(table
->ConvolutionParameterfv
);
1174 assert(table
->ConvolutionParameteri
);
1175 assert(table
->ConvolutionParameteriv
);
1176 assert(table
->CopyColorSubTable
);
1177 assert(table
->CopyColorTable
);
1178 assert(table
->CopyConvolutionFilter1D
);
1179 assert(table
->CopyConvolutionFilter2D
);
1180 assert(table
->GetColorTable
);
1181 assert(table
->GetColorTableParameterfv
);
1182 assert(table
->GetColorTableParameteriv
);
1183 assert(table
->GetConvolutionFilter
);
1184 assert(table
->GetConvolutionParameterfv
);
1185 assert(table
->GetConvolutionParameteriv
);
1186 assert(table
->GetHistogram
);
1187 assert(table
->GetHistogramParameterfv
);
1188 assert(table
->GetHistogramParameteriv
);
1189 assert(table
->GetMinmax
);
1190 assert(table
->GetMinmaxParameterfv
);
1191 assert(table
->GetMinmaxParameteriv
);
1192 assert(table
->Histogram
);
1193 assert(table
->Minmax
);
1194 assert(table
->ResetHistogram
);
1195 assert(table
->ResetMinmax
);
1196 assert(table
->SeparableFilter2D
);
1201 #ifdef _GLAPI_EXT_paletted_texture
1202 assert(table
->ColorTableEXT
);
1203 assert(table
->ColorSubTableEXT
);
1204 assert(table
->GetColorTableEXT
);
1205 assert(table
->GetColorTableParameterfvEXT
);
1206 assert(table
->GetColorTableParameterivEXT
);
1209 #ifdef _GLAPI_EXT_compiled_vertex_array
1210 assert(table
->LockArraysEXT
);
1211 assert(table
->UnlockArraysEXT
);
1214 #ifdef _GLAPI_EXT_point_parameter
1215 assert(table
->PointParameterfEXT
);
1216 assert(table
->PointParameterfvEXT
);
1219 #ifdef _GLAPI_EXT_polygon_offset
1220 assert(table
->PolygonOffsetEXT
);
1223 #ifdef _GLAPI_ARB_multitexture
1224 assert(table
->ActiveTextureARB
);
1225 assert(table
->ClientActiveTextureARB
);
1226 assert(table
->MultiTexCoord1dARB
);
1227 assert(table
->MultiTexCoord1dvARB
);
1228 assert(table
->MultiTexCoord1fARB
);
1229 assert(table
->MultiTexCoord1fvARB
);
1230 assert(table
->MultiTexCoord1iARB
);
1231 assert(table
->MultiTexCoord1ivARB
);
1232 assert(table
->MultiTexCoord1sARB
);
1233 assert(table
->MultiTexCoord1svARB
);
1234 assert(table
->MultiTexCoord2dARB
);
1235 assert(table
->MultiTexCoord2dvARB
);
1236 assert(table
->MultiTexCoord2fARB
);
1237 assert(table
->MultiTexCoord2fvARB
);
1238 assert(table
->MultiTexCoord2iARB
);
1239 assert(table
->MultiTexCoord2ivARB
);
1240 assert(table
->MultiTexCoord2sARB
);
1241 assert(table
->MultiTexCoord2svARB
);
1242 assert(table
->MultiTexCoord3dARB
);
1243 assert(table
->MultiTexCoord3dvARB
);
1244 assert(table
->MultiTexCoord3fARB
);
1245 assert(table
->MultiTexCoord3fvARB
);
1246 assert(table
->MultiTexCoord3iARB
);
1247 assert(table
->MultiTexCoord3ivARB
);
1248 assert(table
->MultiTexCoord3sARB
);
1249 assert(table
->MultiTexCoord3svARB
);
1250 assert(table
->MultiTexCoord4dARB
);
1251 assert(table
->MultiTexCoord4dvARB
);
1252 assert(table
->MultiTexCoord4fARB
);
1253 assert(table
->MultiTexCoord4fvARB
);
1254 assert(table
->MultiTexCoord4iARB
);
1255 assert(table
->MultiTexCoord4ivARB
);
1256 assert(table
->MultiTexCoord4sARB
);
1257 assert(table
->MultiTexCoord4svARB
);
1260 #ifdef _GLAPI_INGR_blend_func_separate
1261 assert(table
->BlendFuncSeparateINGR
);
1264 #ifdef _GLAPI_MESA_window_pos
1265 assert(table
->WindowPos4fMESA
);
1268 #ifdef _GLAPI_MESA_resize_buffers
1269 assert(table
->ResizeBuffersMESA
);
1272 #ifdef _GLAPI_ARB_transpose_matrix
1273 assert(table
->LoadTransposeMatrixdARB
);
1274 assert(table
->LoadTransposeMatrixfARB
);
1275 assert(table
->MultTransposeMatrixdARB
);
1276 assert(table
->MultTransposeMatrixfARB
);
1283 * Generate the GL entrypoint functions here.
1287 #define KEYWORD2 GLAPIENTRY
1288 #ifdef USE_MGL_NAMESPACE
1289 #define NAME(func) mgl##func
1291 #define NAME(func) gl##func
1294 #include "glapitemp.h"