diff options
Diffstat (limited to 'src')
| -rw-r--r-- | src/mesa/glapi/glapi.c | 1685 |
1 files changed, 1113 insertions, 572 deletions
diff --git a/src/mesa/glapi/glapi.c b/src/mesa/glapi/glapi.c index f8a8d111fe..cc1b2a8149 100644 --- a/src/mesa/glapi/glapi.c +++ b/src/mesa/glapi/glapi.c @@ -1,4 +1,4 @@ -/* $Id: glapi.c,v 1.7 1999/11/12 18:57:50 brianp Exp $ */ +/* $Id: glapi.c,v 1.8 1999/11/19 22:33:50 brianp Exp $ */ /* * Mesa 3-D graphics library @@ -27,1575 +27,2530 @@ #include <assert.h> #include <stdlib.h> /* to get NULL */ +#include <string.h> #include "glapi.h" #include "glapinoop.h" -#if defined(MULTI_THREAD) +/* + * Define the DISPATCH_SETUP and DISPATCH macros here dependant on + * whether or not threading is enabled. + */ +#if defined(THREADS) + +/*** Thread-safe API dispatch ***/ +#include "mthreads.h" +static MesaTSD mesa_dispatch_tsd; +static void mesa_dispatch_thread_init() { + MesaInitTSD(&mesa_dispatch_tsd); +} +#define DISPATCH_SETUP struct _glapi_table *dispatch = (struct _glapi_table *) MesaGetTSD(&mesa_dispatch_tsd) +#define DISPATCH(FUNC) (dispatch->FUNC) -/* XXX to do */ #else +/*** Non-threaded API dispatch ***/ static struct _glapi_table *Dispatch = &__glapi_noop_table; +#define DISPATCH_SETUP #define DISPATCH(FUNC) (Dispatch->FUNC) #endif + +/* + * Set the global or per-thread dispatch table pointer. + */ +void +_glapi_set_dispatch(struct _glapi_table *dispatch) +{ + if (!dispatch) { + /* use the no-op functions */ + dispatch = &__glapi_noop_table; + } +#ifdef DEBUG + else { + _glapi_check_table(dispatch); + } +#endif + +#if defined(THREADS) + MesaSetTSD(&mesa_dispatch_tsd, (void*) dispatch, mesa_dispatch_thread_init); +#else + Dispatch = dispatch; +#endif +} + + +/* + * Get the global or per-thread dispatch table pointer. + */ +struct _glapi_table * +_glapi_get_dispatch(void) +{ +#if defined(THREADS) + /* return this thread's dispatch pointer */ + return (struct _glapi_table *) MesaGetTSD(&mesa_dispatch_tsd); +#else + return Dispatch; +#endif +} + + +/* + * Get API dispatcher version string. + * XXX this isn't well defined yet. + */ +const char * +_glapi_get_version(void) +{ + return "1.2"; +} + + +/* + * Return list of hard-coded extension entrypoints in the dispatch table. + * XXX this isn't well defined yet. + */ +const char * +_glapi_get_extensions(void) +{ + return "GL_EXT_paletted_texture GL_EXT_compiled_vertex_array GL_EXT_point_parameters GL_EXT_polygon_offset GL_EXT_blend_minmax GL_EXT_blend_color GL_ARB_multitexture GL_INGR_blend_func_separate GL_MESA_window_pos GL_MESA_resize_buffers"; +} + + + +/* + * XXX the following dynamic extension code is just a prototype and + * not used yet. + */ +struct _glapi_ext_entrypoint { + const char *Name; + GLuint Offset; +}; + +#define MAX_EXT_ENTRYPOINTS 100 + +static struct _glapi_ext_entrypoint ExtEntryTable[MAX_EXT_ENTRYPOINTS]; +static GLuint NumExtEntryPoints; + + + +/* + * Dynamically allocate an extension entry point. + * Return a slot number or -1 if table is full. + */ +GLint +_glapi_alloc_entrypoint(const char *funcName) +{ + GLuint i; + for (i = 0; i < NumExtEntryPoints; i++) { + if (strcmp(ExtEntryTable[i].Name, funcName) == 0) { + /* found it */ + return (GLint) ExtEntryTable[i].Offset; + } + } + if (NumExtEntryPoints < MAX_EXT_ENTRYPOINTS) { + /* add it */ + ExtEntryTable[NumExtEntryPoints].Name = strdup(funcName); + ExtEntryTable[NumExtEntryPoints].Offset = NumExtEntryPoints; /* OK? */ + NumExtEntryPoints++; + return (GLint) (NumExtEntryPoints - 1); + } + /* no more room in the table */ + return -1; +} + + + +/* + * Find the dynamic entry point for the named function. + * Return a slot number or -1 if not found. + */ +GLint +_glapi_get_entrypoint(const char *funcName) +{ + GLuint i; + for (i = 0; i < NumExtEntryPoints; i++) { + if (strcmp(ExtEntryTable[i].Name, funcName) == 0) { + /* found it */ + return (GLint) ExtEntryTable[i].Offset; + } + } + /* not in table */ + return -1; +} + + + +static GLvoid * +get_static_proc_address(const char *funcName) +{ + struct name_address { + const char *Name; + GLvoid *Address; + }; + static struct name_address apitable[] = { + { "glAccum", (GLvoid *) glAccum }, + { "glAlphaFunc", (GLvoid *) glAlphaFunc }, + { "glBegin", (GLvoid *) glBegin }, + { "glBitmap", (GLvoid *) glBitmap }, + /* ... many more ... */ + { NULL, NULL } /* end of list marker */ + }; + GLuint i; + for (i = 0; apitable[i].Name; i++) { + if (strcmp(apitable[i].Name, funcName) == 0) { + return apitable[i].Address; + } + } + return NULL; +} + + +/* + * Return entrypoint for named function. + */ +const GLvoid * +_glapi_get_proc_address(const char *funcName) +{ + /* look for dynamic extension entry point */ + + /* look for static entry point */ + return get_static_proc_address(funcName); +} + + + +/* + * Make sure there are no NULL pointers in the given dispatch table. + * Intented for debugging purposes. + */ +void +_glapi_check_table(const struct _glapi_table *table) +{ + assert(table->Accum); + assert(table->AlphaFunc); + assert(table->Begin); + assert(table->Bitmap); + assert(table->BlendFunc); + assert(table->CallList); + assert(table->CallLists); + assert(table->Clear); + assert(table->ClearAccum); + assert(table->ClearColor); + assert(table->ClearDepth); + assert(table->ClearIndex); + assert(table->ClearStencil); + assert(table->ClipPlane); + assert(table->Color3b); + assert(table->Color3bv); + assert(table->Color3d); + assert(table->Color3dv); + assert(table->Color3f); + assert(table->Color3fv); + assert(table->Color3i); + assert(table->Color3iv); + assert(table->Color3s); + assert(table->Color3sv); + assert(table->Color3ub); + assert(table->Color3ubv); + assert(table->Color3ui); + assert(table->Color3uiv); + assert(table->Color3us); + assert(table->Color3usv); + assert(table->Color4b); + assert(table->Color4bv); + assert(table->Color4d); + assert(table->Color4dv); + assert(table->Color4f); + assert(table->Color4fv); + assert(table->Color4i); + assert(table->Color4iv); + assert(table->Color4s); + assert(table->Color4sv); + assert(table->Color4ub); + assert(table->Color4ubv); + assert(table->Color4ui); + assert(table->Color4uiv); + assert(table->Color4us); + assert(table->Color4usv); + assert(table->ColorMask); + assert(table->ColorMaterial); + assert(table->CopyPixels); + assert(table->CullFace); + assert(table->DeleteLists); + assert(table->DepthFunc); + assert(table->DepthMask); + assert(table->DepthRange); + assert(table->Disable); + assert(table->DrawBuffer); + assert(table->DrawElements); + assert(table->DrawPixels); + assert(table->EdgeFlag); + assert(table->EdgeFlagv); + assert(table->Enable); + assert(table->End); + assert(table->EndList); + assert(table->EvalCoord1d); + assert(table->EvalCoord1dv); + assert(table->EvalCoord1f); + assert(table->EvalCoord1fv); + assert(table->EvalCoord2d); + assert(table->EvalCoord2dv); + assert(table->EvalCoord2f); + assert(table->EvalCoord2fv); + assert(table->EvalMesh1); + assert(table->EvalMesh2); + assert(table->EvalPoint1); + assert(table->EvalPoint2); + assert(table->FeedbackBuffer); + assert(table->Finish); + assert(table->Flush); + assert(table->Fogf); + assert(table->Fogfv); + assert(table->Fogi); + assert(table->Fogiv); + assert(table->FrontFace); + assert(table->Frustum); + assert(table->GenLists); + assert(table->GetBooleanv); + assert(table->GetClipPlane); + assert(table->GetDoublev); + assert(table->GetError); + assert(table->GetFloatv); + assert(table->GetIntegerv); + assert(table->GetLightfv); + assert(table->GetLightiv); + assert(table->GetMapdv); + assert(table->GetMapfv); + assert(table->GetMapiv); + assert(table->GetMaterialfv); + assert(table->GetMaterialiv); + assert(table->GetPixelMapfv); + assert(table->GetPixelMapuiv); + assert(table->GetPixelMapusv); + assert(table->GetPolygonStipple); + assert(table->GetString); + assert(table->GetTexEnvfv); + assert(table->GetTexEnviv); + assert(table->GetTexGendv); + assert(table->GetTexGenfv); + assert(table->GetTexGeniv); + assert(table->GetTexImage); + assert(table->GetTexLevelParameterfv); + assert(table->GetTexLevelParameteriv); + assert(table->GetTexParameterfv); + assert(table->GetTexParameteriv); + assert(table->Hint); + assert(table->IndexMask); + assert(table->Indexd); + assert(table->Indexdv); + assert(table->Indexf); + assert(table->Indexfv); + assert(table->Indexi); + assert(table->Indexiv); + assert(table->Indexs); + assert(table->Indexsv); + assert(table->InitNames); + assert(table->IsEnabled); + assert(table->IsList); + assert(table->LightModelf); + assert(table->LightModelfv); + assert(table->LightModeli); + assert(table->LightModeliv); + assert(table->Lightf); + assert(table->Lightfv); + assert(table->Lighti); + assert(table->Lightiv); + assert(table->LineStipple); + assert(table->LineWidth); + assert(table->ListBase); + assert(table->LoadIdentity); + assert(table->LoadMatrixd); + assert(table->LoadMatrixf); + assert(table->LoadName); + assert(table->LogicOp); + assert(table->Map1d); + assert(table->Map1f); + assert(table->Map2d); + assert(table->Map2f); + assert(table->MapGrid1d); + assert(table->MapGrid1f); + assert(table->MapGrid2d); + assert(table->MapGrid2f); + assert(table->Materialf); + assert(table->Materialfv); + assert(table->Materiali); + assert(table->Materialiv); + assert(table->MatrixMode); + assert(table->MultMatrixd); + assert(table->MultMatrixf); + assert(table->NewList); + assert(table->Normal3b); + assert(table->Normal3bv); + assert(table->Normal3d); + assert(table->Normal3dv); + assert(table->Normal3f); + assert(table->Normal3fv); + assert(table->Normal3i); + assert(table->Normal3iv); + assert(table->Normal3s); + assert(table->Normal3sv); + assert(table->Ortho); + assert(table->PassThrough); + assert(table->PixelMapfv); + assert(table->PixelMapuiv); + assert(table->PixelMapusv); + assert(table->PixelStoref); + assert(table->PixelStorei); + assert(table->PixelTransferf); + assert(table->PixelTransferi); + assert(table->PixelZoom); + assert(table->PointSize); + assert(table->PolygonMode); + assert(table->PolygonOffset); + assert(table->PolygonStipple); + assert(table->PopAttrib); + assert(table->PopMatrix); + assert(table->PopName); + assert(table->PushAttrib); + assert(table->PushMatrix); + assert(table->PushName); + assert(table->RasterPos2d); + assert(table->RasterPos2dv); + assert(table->RasterPos2f); + assert(table->RasterPos2fv); + assert(table->RasterPos2i); + assert(table->RasterPos2iv); + assert(table->RasterPos2s); + assert(table->RasterPos2sv); + assert(table->RasterPos3d); + assert(table->RasterPos3dv); + assert(table->RasterPos3f); + assert(table->RasterPos3fv); + assert(table->RasterPos3i); + assert(table->RasterPos3iv); + assert(table->RasterPos3s); + assert(table->RasterPos3sv); + assert(table->RasterPos4d); + assert(table->RasterPos4dv); + assert(table->RasterPos4f); + assert(table->RasterPos4fv); + assert(table->RasterPos4i); + assert(table->RasterPos4iv); + assert(table->RasterPos4s); + assert(table->RasterPos4sv); + assert(table->ReadBuffer); + assert(table->ReadPixels); + assert(table->Rectd); + assert(table->Rectdv); + assert(table->Rectf); + assert(table->Rectfv); + assert(table->Recti); + assert(table->Rectiv); + assert(table->Rects); + assert(table->Rectsv); + assert(table->RenderMode); + assert(table->Rotated); + assert(table->Rotatef); + assert(table->Scaled); + assert(table->Scalef); + assert(table->Scissor); + assert(table->SelectBuffer); + assert(table->ShadeModel); + assert(table->StencilFunc); + assert(table->StencilMask); + assert(table->StencilOp); + assert(table->TexCoord1d); + assert(table->TexCoord1dv); + assert(table->TexCoord1f); + assert(table->TexCoord1fv); + assert(table->TexCoord1i); + assert(table->TexCoord1iv); + assert(table->TexCoord1s); + assert(table->TexCoord1sv); + assert(table->TexCoord2d); + assert(table->TexCoord2dv); + assert(table->TexCoord2f); + assert(table->TexCoord2fv); + assert(table->TexCoord2i); + assert(table->TexCoord2iv); + assert(table->TexCoord2s); + assert(table->TexCoord2sv); + assert(table->TexCoord3d); + assert(table->TexCoord3dv); + assert(table->TexCoord3f); + assert(table->TexCoord3fv); + assert(table->TexCoord3i); + assert(table->TexCoord3iv); + assert(table->TexCoord3s); + assert(table->TexCoord3sv); + assert(table->TexCoord4d); + assert(table->TexCoord4dv); + assert(table->TexCoord4f); + assert(table->TexCoord4fv); + assert(table->TexCoord4i); + assert(table->TexCoord4iv); + assert(table->TexCoord4s); + assert(table->TexCoord4sv); + assert(table->TexEnvf); + assert(table->TexEnvfv); + assert(table->TexEnvi); + assert(table->TexEnviv); + assert(table->TexGend); + assert(table->TexGendv); + assert(table->TexGenf); + assert(table->TexGenfv); + assert(table->TexGeni); + assert(table->TexGeniv); + assert(table->TexImage1D); + assert(table->TexImage2D); + assert(table->TexParameterf); + assert(table->TexParameterfv); + assert(table->TexParameteri); + assert(table->TexParameteriv); + assert(table->Translated); + assert(table->Translatef); + assert(table->Vertex2d); + assert(table->Vertex2dv); + assert(table->Vertex2f); + assert(table->Vertex2fv); + assert(table->Vertex2i); + assert(table->Vertex2iv); + assert(table->Vertex2s); + assert(table->Vertex2sv); + assert(table->Vertex3d); + assert(table->Vertex3dv); + assert(table->Vertex3f); + assert(table->Vertex3fv); + assert(table->Vertex3i); + assert(table->Vertex3iv); + assert(table->Vertex3s); + assert(table->Vertex3sv); + assert(table->Vertex4d); + assert(table->Vertex4dv); + assert(table->Vertex4f); + assert(table->Vertex4fv); + assert(table->Vertex4i); + assert(table->Vertex4iv); + assert(table->Vertex4s); + assert(table->Vertex4sv); + assert(table->Viewport); + +#ifdef _GLAPI_VERSION_1_1 + assert(table->AreTexturesResident); + assert(table->ArrayElement); + assert(table->BindTexture); + assert(table->ColorPointer); + assert(table->CopyTexImage1D); + assert(table->CopyTexImage2D); + assert(table->CopyTexSubImage1D); + assert(table->CopyTexSubImage2D); + assert(table->DeleteTextures); + assert(table->DisableClientState); + assert(table->DrawArrays); + assert(table->EdgeFlagPointer); + assert(table->EnableClientState); + assert(table->GenTextures); + assert(table->GetPointerv); + assert(table->IndexPointer); + assert(table->Indexub); + assert(table->Indexubv); + assert(table->InterleavedArrays); + assert(table->IsTexture); + assert(table->NormalPointer); + assert(table->PopClientAttrib); + assert(table->PrioritizeTextures); + assert(table->PushClientAttrib); + assert(table->TexCoordPointer); + assert(table->TexSubImage1D); + assert(table->TexSubImage2D); + assert(table->VertexPointer); +#endif + +#ifdef _GLAPI_VERSION_1_2 + assert(table->CopyTexSubImage3D); + assert(table->DrawRangeElements); + assert(table->TexImage3D); + assert(table->TexSubImage3D); +#ifdef _GLAPI_ARB_imaging + assert(table->BlendColor); + assert(table->BlendEquation); + assert(table->ColorSubTable); + assert(table->ColorTable); + assert(table->ColorTableParameterfv); + assert(table->ColorTableParameteriv); + assert(table->ConvolutionFilter1D); + assert(table->ConvolutionFilter2D); + assert(table->ConvolutionParameterf); + assert(table->ConvolutionParameterfv); + assert(table->ConvolutionParameteri); + assert(table->ConvolutionParameteriv); + assert(table->CopyColorSubTable); + assert(table->CopyColorTable); + assert(table->CopyConvolutionFilter1D); + assert(table->CopyConvolutionFilter2D); + assert(table->GetColorTable); + assert(table->GetColorTableParameterfv); + assert(table->GetColorTableParameteriv); + assert(table->GetConvolutionFilter); + assert(table->GetConvolutionParameterfv); + assert(table->GetConvolutionParameteriv); + assert(table->GetHistogram); + assert(table->GetHistogramParameterfv); + assert(table->GetHistogramParameteriv); + assert(table->GetMinmax); + assert(table->GetMinmaxParameterfv); + assert(table->GetMinmaxParameteriv); + assert(table->Histogram); + assert(table->Minmax); + assert(table->ResetHistogram); + assert(table->ResetMinmax); + assert(table->SeparableFilter2D); +#endif +#endif + + +#ifdef _GLAPI_EXT_paletted_texture + assert(table->ColorTableEXT); + assert(table->ColorSubTableEXT); + assert(table->GetColorTableEXT); + assert(table->GetColorTableParameterfvEXT); + assert(table->GetColorTableParameterivEXT); +#endif + +#ifdef _GLAPI_EXT_compiled_vertex_array + assert(table->LockArraysEXT); + assert(table->UnlockArraysEXT); +#endif + +#ifdef _GLAPI_EXT_point_parameter + assert(table->PointParameterfEXT); + assert(table->PointParameterfvEXT); +#endif + +#ifdef _GLAPI_EXT_polygon_offset + assert(table->PolygonOffsetEXT); +#endif + +#ifdef _GLAPI_ARB_multitexture + assert(table->ActiveTextureARB); + assert(table->ClientActiveTextureARB); + assert(table->MultiTexCoord1dARB); + assert(table->MultiTexCoord1dvARB); + assert(table->MultiTexCoord1fARB); + assert(table->MultiTexCoord1fvARB); + assert(table->MultiTexCoord1iARB); + assert(table->MultiTexCoord1ivARB); + assert(table->MultiTexCoord1sARB); + assert(table->MultiTexCoord1svARB); + assert(table->MultiTexCoord2dARB); + assert(table->MultiTexCoord2dvARB); + assert(table->MultiTexCoord2fARB); + assert(table->MultiTexCoord2fvARB); + assert(table->MultiTexCoord2iARB); + assert(table->MultiTexCoord2ivARB); + assert(table->MultiTexCoord2sARB); + assert(table->MultiTexCoord2svARB); + assert(table->MultiTexCoord3dARB); + assert(table->MultiTexCoord3dvARB); + assert(table->MultiTexCoord3fARB); + assert(table->MultiTexCoord3fvARB); + assert(table->MultiTexCoord3iARB); + assert(table->MultiTexCoord3ivARB); + assert(table->MultiTexCoord3sARB); + assert(table->MultiTexCoord3svARB); + assert(table->MultiTexCoord4dARB); + assert(table->MultiTexCoord4dvARB); + assert(table->MultiTexCoord4fARB); + assert(table->MultiTexCoord4fvARB); + assert(table->MultiTexCoord4iARB); + assert(table->MultiTexCoord4ivARB); + assert(table->MultiTexCoord4sARB); + assert(table->MultiTexCoord4svARB); +#endif + +#ifdef _GLAPI_INGR_blend_func_separate + assert(table->BlendFuncSeparateINGR); +#endif + +#ifdef _GLAPI_MESA_window_pos + assert(table->WindowPos4fMESA); +#endif + +#ifdef _GLAPI_MESA_resize_buffers + assert(table->ResizeBuffersMESA); +#endif +} + + + void GLAPIENTRY glAccum(GLenum op, GLfloat value) { + DISPATCH_SETUP; DISPATCH(Accum)(op, value); } void GLAPIENTRY glAlphaFunc(GLenum func, GLclampf ref) { + DISPATCH_SETUP; DISPATCH(AlphaFunc)(func, ref); } void GLAPIENTRY glBegin(GLenum mode) { + DISPATCH_SETUP; DISPATCH(Begin)(mode); } void GLAPIENTRY glBitmap(GLsizei width, GLsizei height, GLfloat xorig, GLfloat yorig, GLfloat xmove, GLfloat ymove, const GLubyte *bitmap) { + DISPATCH_SETUP; DISPATCH(Bitmap)(width, height, xorig, yorig, xmove, ymove, bitmap); } void GLAPIENTRY glBlendFunc(GLenum sfactor, GLenum dfactor) { + DISPATCH_SETUP; DISPATCH(BlendFunc)(sfactor, dfactor); } void GLAPIENTRY glCallList(GLuint list) { + DISPATCH_SETUP; DISPATCH(CallList)(list); } void GLAPIENTRY glCallLists(GLsizei n, GLenum type, const GLvoid *lists) { + DISPATCH_SETUP; DISPATCH(CallLists)(n, type, lists); } void GLAPIENTRY glClear(GLbitfield mask) { + DISPATCH_SETUP; DISPATCH(Clear)(mask); } void GLAPIENTRY glClearAccum(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha) { + DISPATCH_SETUP; DISPATCH(ClearAccum)(red, green, blue, alpha); } void GLAPIENTRY glClearColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha) { + DISPATCH_SETUP; DISPATCH(ClearColor)(red, green, blue, alpha); } void GLAPIENTRY glClearDepth(GLclampd depth) { + DISPATCH_SETUP; DISPATCH(ClearDepth)(depth); } void GLAPIENTRY glClearIndex(GLfloat c) { + DISPATCH_SETUP; DISPATCH(ClearIndex)(c); } void GLAPIENTRY glClearStencil(GLint s) { + DISPATCH_SETUP; DISPATCH(ClearStencil)(s); } void GLAPIENTRY glClipPlane(GLenum plane, const GLdouble *equation) { + DISPATCH_SETUP; DISPATCH(ClipPlane)(plane, equation); } void GLAPIENTRY glColor3b(GLbyte red, GLbyte green, GLbyte blue) { + DISPATCH_SETUP; DISPATCH(Color3b)(red, green, blue); } void GLAPIENTRY glColor3d(GLdouble red, GLdouble green, GLdouble blue) { + DISPATCH_SETUP; DISPATCH(Color3d)(red, green, blue); } void GLAPIENTRY glColor3f(GLfloat red, GLfloat green, GLfloat blue) { + DISPATCH_SETUP; DISPATCH(Color3f)(red, green, blue); } void GLAPIENTRY glColor3i(GLint red, GLint green, GLint blue) { + DISPATCH_SETUP; DISPATCH(Color3i)(red, green, blue); } void GLAPIENTRY glColor3s(GLshort red, GLshort green, GLshort blue) { + DISPATCH_SETUP; DISPATCH(Color3s)(red, green, blue); } void GLAPIENTRY glColor3ub(GLubyte red, GLubyte green, GLubyte blue) { + DISPATCH_SETUP; DISPATCH(Color3ub)(red, green, blue); } void GLAPIENTRY glColor3ui(GLuint red, GLuint green, GLuint blue) { + DISPATCH_SETUP; DISPATCH(Color3ui)(red, green, blue); } void GLAPIENTRY glColor3us(GLushort red, GLushort green, GLushort blue) { + DISPATCH_SETUP; DISPATCH(Color3us)(red, green, blue); } void GLAPIENTRY glColor4b(GLbyte red, GLbyte green, GLbyte blue, GLbyte alpha) { + DISPATCH_SETUP; DISPATCH(Color4b)(red, green, blue, alpha); } void GLAPIENTRY glColor4d(GLdouble red, GLdouble green, GLdouble blue, GLdouble alpha) { + DISPATCH_SETUP; DISPATCH(Color4d)(red, green, blue, alpha); } void GLAPIENTRY glColor4f(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha) { + DISPATCH_SETUP; DISPATCH(Color4f)(red, green, blue, alpha); } void GLAPIENTRY glColor4i(GLint red, GLint green, GLint blue, GLint alpha) { + DISPATCH_SETUP; DISPATCH(Color4i)(red, green, blue, alpha); } void GLAPIENTRY glColor4s(GLshort red, GLshort green, GLshort blue, GLshort alpha) { + DISPATCH_SETUP; DISPATCH(Color4s)(red, green, blue, alpha); } void GLAPIENTRY glColor4ub(GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha) { + DISPATCH_SETUP; DISPATCH(Color4ub)(red, green, blue, alpha); } void GLAPIENTRY glColor4ui(GLuint red, GLuint green, GLuint blue, GLuint alpha) { + DISPATCH_SETUP; DISPATCH(Color4ui)(red, green, blue, alpha); } void GLAPIENTRY glColor4us(GLushort red, GLushort green, GLushort blue, GLushort alpha) { + DISPATCH_SETUP; DISPATCH(Color4us)(red, green, blue, alpha); } void GLAPIENTRY glColor3bv(const GLbyte *v) { + DISPATCH_SETUP; DISPATCH(Color3bv)(v); } void GLAPIENTRY glColor3dv(const GLdouble *v) { + DISPATCH_SETUP; DISPATCH(Color3dv)(v); } void GLAPIENTRY glColor3fv(const GLfloat *v) { + DISPATCH_SETUP; DISPATCH(Color3fv)(v); } void GLAPIENTRY glColor3iv(const GLint *v) { + DISPATCH_SETUP; DISPATCH(Color3iv)(v); } void GLAPIENTRY glColor3sv(const GLshort *v) { + DISPATCH_SETUP; DISPATCH(Color3sv)(v); } void GLAPIENTRY glColor3ubv(const GLubyte *v) { + DISPATCH_SETUP; DISPATCH(Color3ubv)(v); } void GLAPIENTRY glColor3uiv(const GLuint *v) { + DISPATCH_SETUP; DISPATCH(Color3uiv)(v); } void GLAPIENTRY glColor3usv(const GLushort *v) { + DISPATCH_SETUP; DISPATCH(Color3usv)(v); } void GLAPIENTRY glColor4bv(const GLbyte *v) { + DISPATCH_SETUP; DISPATCH(Color4bv)(v); } void GLAPIENTRY glColor4dv(const GLdouble *v) { + DISPATCH_SETUP; DISPATCH(Color4dv)(v); } void GLAPIENTRY glColor4fv(const GLfloat *v) { + DISPATCH_SETUP; DISPATCH(Color4fv)(v); } void GLAPIENTRY glColor4iv(const GLint *v) { + DISPATCH_SETUP; DISPATCH(Color4iv)(v); } void GLAPIENTRY glColor4sv(const GLshort *v) { + DISPATCH_SETUP; DISPATCH(Color4sv)(v); } void GLAPIENTRY glColor4ubv(const GLubyte *v) { + DISPATCH_SETUP; DISPATCH(Color4ubv)(v); } void GLAPIENTRY glColor4uiv(const GLuint *v) { + DISPATCH_SETUP; DISPATCH(Color4uiv)(v); } void GLAPIENTRY glColor4usv(const GLushort *v) { + DISPATCH_SETUP; DISPATCH(Color4usv)(v); } void GLAPIENTRY glColorMask(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha) { + DISPATCH_SETUP; DISPATCH(ColorMask)(red, green, blue, alpha); } void GLAPIENTRY glColorMaterial(GLenum face, GLenum mode) { + DISPATCH_SETUP; DISPATCH(ColorMaterial)(face, mode); } void GLAPIENTRY glCopyPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum type) { + DISPATCH_SETUP; DISPATCH(CopyPixels)(x, y, width, height, type); } void GLAPIENTRY glCullFace(GLenum mode) { + DISPATCH_SETUP; DISPATCH(CullFace)(mode); } void GLAPIENTRY glDepthFunc(GLenum func) { + DISPATCH_SETUP; DISPATCH(DepthFunc)(func); } void GLAPIENTRY glDepthMask(GLboolean flag) { + DISPATCH_SETUP; DISPATCH(DepthMask)(flag); } void GLAPIENTRY glDepthRange(GLclampd nearVal, GLclampd farVal) { + DISPATCH_SETUP; DISPATCH(DepthRange)(nearVal, farVal); } void GLAPIENTRY glDeleteLists(GLuint list, GLsizei range) { + DISPATCH_SETUP; DISPATCH(DeleteLists)(list, range); } void GLAPIENTRY glDisable(GLenum cap) { + DISPATCH_SETUP; DISPATCH(Disable)(cap); } void GLAPIENTRY glDrawBuffer(GLenum mode) { + DISPATCH_SETUP; DISPATCH(DrawBuffer)(mode); } void GLAPIENTRY glDrawElements(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices) { + DISPATCH_SETUP; DISPATCH(DrawElements)(mode, count, type, indices); } void GLAPIENTRY glDrawPixels(GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels) { + DISPATCH_SETUP; DISPATCH(DrawPixels)(width, height, format, type, pixels); } void GLAPIENTRY glEnable(GLenum mode) { + DISPATCH_SETUP; DISPATCH(Enable)(mode); } void GLAPIENTRY glEnd(void) { + DISPATCH_SETUP; DISPATCH(End)(); } void GLAPIENTRY glEndList(void) { + DISPATCH_SETUP; DISPATCH(EndList)(); } void GLAPIENTRY glEvalCoord1d(GLdouble u) { + DISPATCH_SETUP; DISPATCH(EvalCoord1d)(u); } void GLAPIENTRY glEvalCoord1f(GLfloat u) { + DISPATCH_SETUP; DISPATCH(EvalCoord1f)(u); } void GLAPIENTRY glEvalCoord1dv(const GLdouble *u) { + DISPATCH_SETUP; DISPATCH(EvalCoord1dv)(u); } void GLAPIENTRY glEvalCoord1fv(const GLfloat *u) { + DISPATCH_SETUP; DISPATCH(EvalCoord1fv)(u); } void GLAPIENTRY glEvalCoord2d(GLdouble u, GLdouble v) { + DISPATCH_SETUP; DISPATCH(EvalCoord2d)(u, v); } void GLAPIENTRY glEvalCoord2f(GLfloat u, GLfloat v) { + DISPATCH_SETUP; DISPATCH(EvalCoord2f)(u, v); } void GLAPIENTRY glEvalCoord2dv(const GLdouble *u) { + DISPATCH_SETUP; DISPATCH(EvalCoord2dv)(u); } void GLAPIENTRY glEvalCoord2fv(const GLfloat *u) { + DISPATCH_SETUP; DISPATCH(EvalCoord2fv)(u); } void GLAPIENTRY glEvalPoint1(GLint i) { + DISPATCH_SETUP; DISPATCH(EvalPoint1)(i); } void GLAPIENTRY glEvalPoint2(GLint i, GLint j) { + DISPATCH_SETUP; DISPATCH(EvalPoint2)(i, j); } void GLAPIENTRY glEvalMesh1(GLenum mode, GLint i1, GLint i2) { + DISPATCH_SETUP; DISPATCH(EvalMesh1)(mode, i1, i2); } void GLAPIENTRY glEdgeFlag(GLboolean flag) { + DISPATCH_SETUP; DISPATCH(EdgeFlag)(flag); } void GLAPIENTRY glEdgeFlagv(const GLboolean *flag) { + DISPATCH_SETUP; DISPATCH(EdgeFlagv)(flag); } void GLAPIENTRY glEvalMesh2(GLenum mode, GLint i1, GLint i2, GLint j1, GLint j2) { + DISPATCH_SETUP; DISPATCH(EvalMesh2)(mode, i1, i2, j1, j2); } void GLAPIENTRY glFeedbackBuffer(GLsizei size, GLenum type, GLfloat *buffer) { + DISPATCH_SETUP; DISPATCH(FeedbackBuffer)(size, type, buffer); } void GLAPIENTRY glFinish(void) { + DISPATCH_SETUP; DISPATCH(Finish)(); } void GLAPIENTRY glFlush(void) { + DISPATCH_SETUP; DISPATCH(Flush)(); } void GLAPIENTRY glFogf(GLenum pname, GLfloat param) { + DISPATCH_SETUP; DISPATCH(Fogf)(pname, param); } void GLAPIENTRY glFogi(GLenum pname, GLint param) { + DISPATCH_SETUP; DISPATCH(Fogi)(pname, param); } void GLAPIENTRY glFogfv(GLenum pname, const GLfloat *params) { + DISPATCH_SETUP; DISPATCH(Fogfv)(pname, params); } void GLAPIENTRY glFogiv(GLenum pname, const GLint *params) { + DISPATCH_SETUP; DISPATCH(Fogiv)(pname, params); } void GLAPIENTRY glFrontFace(GLenum mode) { + DISPATCH_SETUP; DISPATCH(FrontFace)(mode); } void GLAPIENTRY glFrustum(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble nearval, GLdouble farval) { + DISPATCH_SETUP; DISPATCH(Frustum)(left, right, bottom, top, nearval, farval); } GLuint GLAPIENTRY glGenLists(GLsizei range) { + DISPATCH_SETUP; return DISPATCH(GenLists)(range); } void GLAPIENTRY glGetBooleanv(GLenum pname, GLboolean *params) { + DISPATCH_SETUP; DISPATCH(GetBooleanv)(pname, params); } void GLAPIENTRY glGetClipPlane(GLenum plane, GLdouble *equation) { + DISPATCH_SETUP; DISPATCH(GetClipPlane)(plane, equation); } void GLAPIENTRY glGetDoublev(GLenum pname, GLdouble *params) { + DISPATCH_SETUP; DISPATCH(GetDoublev)(pname, params); } GLenum GLAPIENTRY glGetError(void) { + DISPATCH_SETUP; return DISPATCH(GetError)(); } void GLAPIENTRY glGetFloatv(GLenum pname, GLfloat *params) { + DISPATCH_SETUP; DISPATCH(GetFloatv)(pname, params); } void GLAPIENTRY glGetIntegerv(GLenum pname, GLint *params) { + DISPATCH_SETUP; DISPATCH(GetIntegerv)(pname, params); } void GLAPIENTRY glGetLightfv(GLenum light, GLenum pname, GLfloat *params) { + DISPATCH_SETUP; DISPATCH(GetLightfv)(light, pname, params); } void GLAPIENTRY glGetLightiv(GLenum light, GLenum pname, GLint *params) { + DISPATCH_SETUP; DISPATCH(GetLightiv)(light, pname, params); } void GLAPIENTRY glGetMapdv(GLenum target, GLenum query, GLdouble *v) { + DISPATCH_SETUP; DISPATCH(GetMapdv)(target, query, v); } void GLAPIENTRY glGetMapfv(GLenum target, GLenum query, GLfloat *v) { + DISPATCH_SETUP; DISPATCH(GetMapfv)(target, query, v); } void GLAPIENTRY glGetMapiv(GLenum target, GLenum query, GLint *v) { + DISPATCH_SETUP; DISPATCH(GetMapiv)(target, query, v); } void GLAPIENTRY glGetMaterialfv(GLenum face, GLenum pname, GLfloat *params) { + DISPATCH_SETUP; DISPATCH(GetMaterialfv)(face, pname, params); } void GLAPIENTRY glGetMaterialiv(GLenum face, GLenum pname, GLint *params) { + DISPATCH_SETUP; DISPATCH(GetMaterialiv)(face, pname, params); } void GLAPIENTRY glGetPixelMapfv(GLenum map, GLfloat *values) { + DISPATCH_SETUP; DISPATCH(GetPixelMapfv)(map, values); } void GLAPIENTRY glGetPixelMapuiv(GLenum map, GLuint *values) { + DISPATCH_SETUP; DISPATCH(GetPixelMapuiv)(map, values); } void GLAPIENTRY glGetPixelMapusv(GLenum map, GLushort *values) { + DISPATCH_SETUP; DISPATCH(GetPixelMapusv)(map, values); } void GLAPIENTRY glGetPolygonStipple(GLubyte *mask) { + DISPATCH_SETUP; DISPATCH(GetPolygonStipple)(mask); } const GLubyte * GLAPIENTRY glGetString(GLenum name) { + DISPATCH_SETUP; return DISPATCH(GetString)(name); } void GLAPIENTRY glGetTexEnvfv(GLenum target, GLenum pname, GLfloat *params) { + DISPATCH_SETUP; DISPATCH(GetTexEnvfv)(target, pname, params); } void GLAPIENTRY glGetTexEnviv(GLenum target, GLenum pname, GLint *params) { + DISPATCH_SETUP; DISPATCH(GetTexEnviv)(target, pname, params); } void GLAPIENTRY glGetTexGeniv(GLenum target, GLenum pname, GLint *params) { + DISPATCH_SETUP; DISPATCH(GetTexGeniv)(target, pname, params); } void GLAPIENTRY glGetTexGendv(GLenum target, GLenum pname, GLdouble *params) { + DISPATCH_SETUP; DISPATCH(GetTexGendv)(target, pname, params); } void GLAPIENTRY glGetTexGenfv(GLenum target, GLenum pname, GLfloat *params) { + DISPATCH_SETUP; DISPATCH(GetTexGenfv)(target, pname, params); } void GLAPIENTRY glGetTexImage(GLenum target, GLint level, GLenum format, GLenum type, GLvoid *pixels) { + DISPATCH_SETUP; DISPATCH(GetTexImage)(target, level, format, type, pixels); } void GLAPIENTRY glGetTexLevelParameterfv(GLenum target, GLint level, GLenum pname, GLfloat *params) { + DISPATCH_SETUP; DISPATCH(GetTexLevelParameterfv)(target, level, pname, params); } void GLAPIENTRY glGetTexLevelParameteriv(GLenum target, GLint level, GLenum pname, GLint *params) { + DISPATCH_SETUP; DISPATCH(GetTexLevelParameteriv)(target, level, pname, params); } void GLAPIENTRY glGetTexParameterfv(GLenum target, GLenum pname, GLfloat *params) { + DISPATCH_SETUP; DISPATCH(GetTexParameterfv)(target, pname, params); } void GLAPIENTRY glGetTexParameteriv(GLenum target, GLenum pname, GLint *params) { + DISPATCH_SETUP; DISPATCH(GetTexParameteriv)(target, pname, params); } void GLAPIENTRY glHint(GLenum target, GLenum mode) { + DISPATCH_SETUP; DISPATCH(Hint)(target, mode); } void GLAPIENTRY glIndexd(GLdouble c) { + DISPATCH_SETUP; DISPATCH(Indexd)(c); } void GLAPIENTRY glIndexdv(const GLdouble *c) { + DISPATCH_SETUP; DISPATCH(Indexdv)(c); } void GLAPIENTRY glIndexf(GLfloat c) { + DISPATCH_SETUP; DISPATCH(Indexf)(c); } void GLAPIENTRY glIndexfv(const GLfloat *c) { + DISPATCH_SETUP; DISPATCH(Indexfv)(c); } void GLAPIENTRY glIndexi(GLint c) { + DISPATCH_SETUP; DISPATCH(Indexi)(c); } void GLAPIENTRY glIndexiv(const GLint *c) { + DISPATCH_SETUP; DISPATCH(Indexiv)(c); } void GLAPIENTRY glIndexs(GLshort c) { + DISPATCH_SETUP; DISPATCH(Indexs)(c); } void GLAPIENTRY glIndexsv(const GLshort *c) { + DISPATCH_SETUP; DISPATCH(Indexsv)(c); } void GLAPIENTRY glIndexub(GLubyte c) { + DISPATCH_SETUP; DISPATCH(Indexub)(c); } void GLAPIENTRY glIndexubv(const GLubyte *c) { + DISPATCH_SETUP; DISPATCH(Indexubv)(c); } void GLAPIENTRY glIndexMask(GLuint mask) { + DISPATCH_SETUP; DISPATCH(IndexMask)(mask); } void GLAPIENTRY glInitNames(void) { + DISPATCH_SETUP; DISPATCH(InitNames)(); } void GLAPIENTRY glInterleavedArrays(GLenum format, GLsizei stride, const GLvoid *pointer) { + DISPATCH_SETUP; DISPATCH(InterleavedArrays)(format, stride, pointer); } GLboolean GLAPIENTRY glIsEnabled(GLenum cap) { + DISPATCH_SETUP; return DISPATCH(IsEnabled)(cap); } GLboolean GLAPIENTRY glIsList(GLuint list) { + DISPATCH_SETUP; return DISPATCH(IsList)(list); } GLboolean GLAPIENTRY glIsTexture(GLuint texture) { + DISPATCH_SETUP; return DISPATCH(IsTexture)(texture); } void GLAPIENTRY glLightf(GLenum light, GLenum pname, GLfloat param) { + DISPATCH_SETUP; DISPATCH(Lightf)(light, pname, param); } void GLAPIENTRY glLighti(GLenum light, GLenum pname, GLint param) { + DISPATCH_SETUP; DISPATCH(Lighti)(light, pname, param); } void GLAPIENTRY glLightfv(GLenum light, GLenum pname, const GLfloat *params) { + DISPATCH_SETUP; DISPATCH(Lightfv)(light, pname, params); } void GLAPIENTRY glLightiv(GLenum light, GLenum pname, const GLint *params) { + DISPATCH_SETUP; DISPATCH(Lightiv)(light, pname, params); } void GLAPIENTRY glLightModelf(GLenum pname, GLfloat param) { + DISPATCH_SETUP; DISPATCH(LightModelf)(pname, param); } void GLAPIENTRY glLightModeli(GLenum pname, GLint param) { + DISPATCH_SETUP; DISPATCH(LightModeli)(pname, param); } void GLAPIENTRY glLightModelfv(GLenum pname, const GLfloat *params) { + DISPATCH_SETUP; DISPATCH(LightModelfv)(pname, params); } void GLAPIENTRY glLightModeliv(GLenum pname, const GLint *params) { + DISPATCH_SETUP; DISPATCH(LightModeliv)(pname, params); } void GLAPIENTRY glLineWidth(GLfloat width) { + DISPATCH_SETUP; DISPATCH(LineWidth)(width); } void GLAPIENTRY glLineStipple(GLint factor, GLushort pattern) { + DISPATCH_SETUP; DISPATCH(LineStipple)(factor, pattern); } void GLAPIENTRY glListBase(GLuint base) { + DISPATCH_SETUP; DISPATCH(ListBase)(base); } void GLAPIENTRY glLoadIdentity(void) { + DISPATCH_SETUP; DISPATCH(LoadIdentity)(); } void GLAPIENTRY glLoadMatrixd(const GLdouble *m) { + DISPATCH_SETUP; DISPATCH(LoadMatrixd)(m); } void GLAPIENTRY glLoadMatrixf(const GLfloat *m) { + DISPATCH_SETUP; DISPATCH(LoadMatrixf)(m); } void GLAPIENTRY glLoadName(GLuint name) { + DISPATCH_SETUP; DISPATCH(LoadName)(name); } void GLAPIENTRY glLogicOp(GLenum opcode) { + DISPATCH_SETUP; DISPATCH(LogicOp)(opcode); } void GLAPIENTRY glMap1d(GLenum target, GLdouble u1, GLdouble u2, GLint stride, GLint order, const GLdouble *points) { + DISPATCH_SETUP; DISPATCH(Map1d)(target, u1, u2, stride, order, points); } void GLAPIENTRY glMap1f(GLenum target, GLfloat u1, GLfloat u2, GLint stride, GLint order, const GLfloat *points) { + DISPATCH_SETUP; DISPATCH(Map1f)(target, u1, u2, stride, order, points); } void GLAPIENTRY glMap2d(GLenum target, GLdouble u1, GLdouble u2, GLint ustride, GLint uorder, GLdouble v1, GLdouble v2, GLint vstride, GLint vorder, const GLdouble *points) { + DISPATCH_SETUP; DISPATCH(Map2d)(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points); } void GLAPIENTRY glMap2f(GLenum target, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder, GLfloat v1, GLfloat v2, GLint vstride, GLint vorder, const GLfloat *points) { + DISPATCH_SETUP; DISPATCH(Map2f)(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points); } void GLAPIENTRY glMapGrid1d(GLint un, GLdouble u1, GLdouble u2) { + DISPATCH_SETUP; DISPATCH(MapGrid1d)(un, u1, u2); } void GLAPIENTRY glMapGrid1f(GLint un, GLfloat u1, GLfloat u2) { + DISPATCH_SETUP; DISPATCH(MapGrid1f)(un, u1, u2); } void GLAPIENTRY glMapGrid2d(GLint un, GLdouble u1, GLdouble u2, GLint vn, GLdouble v1, GLdouble v2) { + DISPATCH_SETUP; DISPATCH(MapGrid2d)(un, u1, u2, vn, v1, v2); } void GLAPIENTRY glMapGrid2f(GLint un, GLfloat u1, GLfloat u2, GLint vn, GLfloat v1, GLfloat v2) { + DISPATCH_SETUP; DISPATCH(MapGrid2f)(un, u1, u2, vn, v1, v2); } void GLAPIENTRY glMaterialf(GLenum face, GLenum pname, GLfloat param) { + DISPATCH_SETUP; DISPATCH(Materialf)(face, pname, param); } void GLAPIENTRY glMateriali(GLenum face, GLenum pname, GLint param) { + DISPATCH_SETUP; DISPATCH(Materiali)(face, pname, param); } void GLAPIENTRY glMaterialfv(GLenum face, GLenum pname, const GLfloat *params) { + DISPATCH_SETUP; DISPATCH(Materialfv)(face, pname, params); } void GLAPIENTRY glMaterialiv(GLenum face, GLenum pname, const GLint *params) { + DISPATCH_SETUP; DISPATCH(Materialiv)(face, pname, params); } void GLAPIENTRY glMatrixMode(GLenum mode) { + DISPATCH_SETUP; DISPATCH(MatrixMode)(mode); } void GLAPIENTRY glMultMatrixd(const GLdouble *m) { + DISPATCH_SETUP; DISPATCH(MultMatrixd)(m); } void GLAPIENTRY glMultMatrixf(const GLfloat *m) { + DISPATCH_SETUP; DISPATCH(MultMatrixf)(m); } void GLAPIENTRY glNewList(GLuint list, GLenum mode) { + DISPATCH_SETUP; DISPATCH(NewList)(list, mode); } void GLAPIENTRY glNormal3b(GLbyte nx, GLbyte ny, GLbyte nz) { + DISPATCH_SETUP; DISPATCH(Normal3b)(nx, ny, nz); } void GLAPIENTRY glNormal3bv(const GLbyte *v) { + DISPATCH_SETUP; DISPATCH(Normal3bv)(v); } void GLAPIENTRY glNormal3d(GLdouble nx, GLdouble ny, GLdouble nz) { + DISPATCH_SETUP; DISPATCH(Normal3d)(nx, ny, nz); } void GLAPIENTRY glNormal3dv(const GLdouble *v) { + DISPATCH_SETUP; DISPATCH(Normal3dv)(v); } void GLAPIENTRY glNormal3f(GLfloat nx, GLfloat ny, GLfloat nz) { + DISPATCH_SETUP; DISPATCH(Normal3f)(nx, ny, nz); } void GLAPIENTRY glNormal3fv(const GLfloat *v) { + DISPATCH_SETUP; DISPATCH(Normal3fv)(v); } void GLAPIENTRY glNormal3i(GLint nx, GLint ny, GLint nz) { + DISPATCH_SETUP; DISPATCH(Normal3i)(nx, ny, nz); } void GLAPIENTRY glNormal3iv(const GLint *v) { + DISPATCH_SETUP; DISPATCH(Normal3iv)(v); } void GLAPIENTRY glNormal3s(GLshort nx, GLshort ny, GLshort nz) { + DISPATCH_SETUP; DISPATCH(Normal3s)(nx, ny, nz); } void GLAPIENTRY glNormal3sv(const GLshort *v) { + DISPATCH_SETUP; DISPATCH(Normal3sv)(v); } void GLAPIENTRY glOrtho(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble nearval, GLdouble farval) { + DISPATCH_SETUP; DISPATCH(Ortho)(left, right, bottom, top, nearval, farval); } void GLAPIENTRY glPassThrough(GLfloat token) { + DISPATCH_SETUP; DISPATCH(PassThrough)(token); } void GLAPIENTRY glPixelMapfv(GLenum map, GLint mapsize, const GLfloat *values) { + DISPATCH_SETUP; DISPATCH(PixelMapfv)(map, mapsize, values); } void GLAPIENTRY glPixelMapuiv(GLenum map, GLint mapsize, const GLuint *values) { + DISPATCH_SETUP; DISPATCH(PixelMapuiv)(map, mapsize, values); } void GLAPIENTRY glPixelMapusv(GLenum map, GLint mapsize, const GLushort *values) { + DISPATCH_SETUP; DISPATCH(PixelMapusv)(map, mapsize, values); } void GLAPIENTRY glPixelStoref(GLenum pname, GLfloat param) { + DISPATCH_SETUP; DISPATCH(PixelStoref)(pname, param); } void GLAPIENTRY glPixelStorei(GLenum pname, GLint param) { + DISPATCH_SETUP; DISPATCH(PixelStorei)(pname, param); } void GLAPIENTRY glPixelTransferf(GLenum pname, GLfloat param) { + DISPATCH_SETUP; DISPATCH(PixelTransferf)(pname, param); } void GLAPIENTRY glPixelTransferi(GLenum pname, GLint param) { + DISPATCH_SETUP; DISPATCH(PixelTransferi)(pname, param); } void GLAPIENTRY glPixelZoom(GLfloat xfactor, GLfloat yfactor) { + DISPATCH_SETUP; DISPATCH(PixelZoom)(xfactor, yfactor); } void GLAPIENTRY glPointSize(GLfloat size) { + DISPATCH_SETUP; DISPATCH(PointSize)(size); } void GLAPIENTRY glPolygonMode(GLenum face, GLenum mode) { + DISPATCH_SETUP; DISPATCH(PolygonMode)(face, mode); } void GLAPIENTRY glPolygonStipple(const GLubyte *pattern) { + DISPATCH_SETUP; DISPATCH(PolygonStipple)(pattern); } void GLAPIENTRY glPopAttrib(void) { + DISPATCH_SETUP; DISPATCH(PopAttrib)(); } void GLAPIENTRY glPopMatrix(void) { + DISPATCH_SETUP; DISPATCH(PopMatrix)(); } void GLAPIENTRY glPopName(void) { + DISPATCH_SETUP; DISPATCH(PopName)(); } void GLAPIENTRY glPushAttrib(GLbitfield mask) { + DISPATCH_SETUP; DISPATCH(PushAttrib)(mask); } void GLAPIENTRY glPushMatrix(void) { + DISPATCH_SETUP; DISPATCH(PushMatrix)(); } void GLAPIENTRY glPushName(GLuint name) { + DISPATCH_SETUP; DISPATCH(PushName)(name); } void GLAPIENTRY glRasterPos2d(GLdouble x, GLdouble y) { + DISPATCH_SETUP; DISPATCH(RasterPos2d)(x, y); } void GLAPIENTRY glRasterPos2f(GLfloat x, GLfloat y) { + DISPATCH_SETUP; DISPATCH(RasterPos2f)(x, y); } void GLAPIENTRY glRasterPos2i(GLint x, GLint y) { + DISPATCH_SETUP; DISPATCH(RasterPos2i)(x, y); } void GLAPIENTRY glRasterPos2s(GLshort x, GLshort y) { + DISPATCH_SETUP; DISPATCH(RasterPos2s)(x, y); } void GLAPIENTRY glRasterPos3d(GLdouble x, GLdouble y, GLdouble z) { + DISPATCH_SETUP; DISPATCH(RasterPos3d)(x, y, z); } void GLAPIENTRY glRasterPos3f(GLfloat x, GLfloat y, GLfloat z) { + DISPATCH_SETUP; DISPATCH(RasterPos3f)(x, y, z); } void GLAPIENTRY glRasterPos3i(GLint x, GLint y, GLint z) { + DISPATCH_SETUP; DISPATCH(RasterPos3i)(x, y, z); } void GLAPIENTRY glRasterPos3s(GLshort x, GLshort y, GLshort z) { + DISPATCH_SETUP; DISPATCH(RasterPos3s)(x, y, z); } void GLAPIENTRY glRasterPos4d(GLdouble x, GLdouble y, GLdouble z, GLdouble w) { + DISPATCH_SETUP; DISPATCH(RasterPos4d)(x, y, z, w); } void GLAPIENTRY glRasterPos4f(GLfloat x, GLfloat y, GLfloat z, GLfloat w) { + DISPATCH_SETUP; DISPATCH(RasterPos4f)(x, y, z, w); } void GLAPIENTRY glRasterPos4i(GLint x, GLint y, GLint z, GLint w) { + DISPATCH_SETUP; DISPATCH(RasterPos4i)(x, y, z, w); } void GLAPIENTRY glRasterPos4s(GLshort x, GLshort y, GLshort z, GLshort w) { + DISPATCH_SETUP; DISPATCH(RasterPos4s)(x, y, z, w); } void GLAPIENTRY glRasterPos2dv(const GLdouble *v) { + DISPATCH_SETUP; DISPATCH(RasterPos2dv)(v); } void GLAPIENTRY glRasterPos2fv(const GLfloat *v) { + DISPATCH_SETUP; DISPATCH(RasterPos2fv)(v); } void GLAPIENTRY glRasterPos2iv(const GLint *v) { + DISPATCH_SETUP; DISPATCH(RasterPos2iv)(v); } void GLAPIENTRY glRasterPos2sv(const GLshort *v) { + DISPATCH_SETUP; DISPATCH(RasterPos2sv)(v); } void GLAPIENTRY glRasterPos3dv(const GLdouble *v) { + DISPATCH_SETUP; DISPATCH(RasterPos3dv)(v); } void GLAPIENTRY glRasterPos3fv(const GLfloat *v) { + DISPATCH_SETUP; DISPATCH(RasterPos3fv)(v); } void GLAPIENTRY glRasterPos3iv(const GLint *v) { + DISPATCH_SETUP; DISPATCH(RasterPos3iv)(v); } void GLAPIENTRY glRasterPos3sv(const GLshort *v) { + DISPATCH_SETUP; DISPATCH(RasterPos3sv)(v); } void GLAPIENTRY glRasterPos4dv(const GLdouble *v) { + DISPATCH_SETUP; DISPATCH(RasterPos4dv)(v); } void GLAPIENTRY glRasterPos4fv(const GLfloat *v) { + DISPATCH_SETUP; DISPATCH(RasterPos4fv)(v); } void GLAPIENTRY glRasterPos4iv(const GLint *v) { + DISPATCH_SETUP; DISPATCH(RasterPos4iv)(v); } void GLAPIENTRY glRasterPos4sv(const GLshort *v) { + DISPATCH_SETUP; DISPATCH(RasterPos4sv)(v); } void GLAPIENTRY glReadBuffer(GLenum mode) { + DISPATCH_SETUP; DISPATCH(ReadBuffer)(mode); } void GLAPIENTRY glReadPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid *pixels) { + DISPATCH_SETUP; DISPATCH(ReadPixels)(x, y, width, height, format, type, pixels); } void GLAPIENTRY glRectd(GLdouble x1, GLdouble y1, GLdouble x2, GLdouble y2) { + DISPATCH_SETUP; DISPATCH(Rectd)(x1, y1, x2, y2); } void GLAPIENTRY glRectdv(const GLdouble *v1, const GLdouble *v2) { + DISPATCH_SETUP; DISPATCH(Rectdv)(v1, v2); } void GLAPIENTRY glRectf(GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2) { + DISPATCH_SETUP; DISPATCH(Rectf)(x1, y1, x2, y2); } void GLAPIENTRY glRectfv(const GLfloat *v1, const GLfloat *v2) { + DISPATCH_SETUP; DISPATCH(Rectfv)(v1, v2); } void GLAPIENTRY glRecti(GLint x1, GLint y1, GLint x2, GLint y2) { + DISPATCH_SETUP; DISPATCH(Recti)(x1, y1, x2, y2); } void GLAPIENTRY glRectiv(const GLint *v1, const GLint *v2) { + DISPATCH_SETUP; DISPATCH(Rectiv)(v1, v2); } void GLAPIENTRY glRects(GLshort x1, GLshort y1, GLshort x2, GLshort y2) { + DISPATCH_SETUP; DISPATCH(Rects)(x1, y1, x2, y2); } void GLAPIENTRY glRectsv(const GLshort *v1, const GLshort *v2) { + DISPATCH_SETUP; DISPATCH(Rectsv)(v1, v2); } GLint GLAPIENTRY glRenderMode(GLenum mode) { + DISPATCH_SETUP; return DISPATCH(RenderMode)(mode); } void GLAPIENTRY glRotated(GLdouble angle, GLdouble x, GLdouble y, GLdouble z) { + DISPATCH_SETUP; DISPATCH(Rotated)(angle, x, y, z); } void GLAPIENTRY glRotatef(GLfloat angle, GLfloat x, GLfloat y, GLfloat z) { + DISPATCH_SETUP; DISPATCH(Rotatef)(angle, x, y, z); } void GLAPIENTRY glSelectBuffer(GLsizei size, GLuint *buffer) { + DISPATCH_SETUP; DISPATCH(SelectBuffer)(size, buffer); } void GLAPIENTRY glScaled(GLdouble x, GLdouble y, GLdouble z) { + DISPATCH_SETUP; DISPATCH(Scaled)(x, y, z); } void GLAPIENTRY glScalef(GLfloat x, GLfloat y, GLfloat z) { + DISPATCH_SETUP; DISPATCH(Scalef)(x, y, z); } void GLAPIENTRY glScissor(GLint x, GLint y, GLsizei width, GLsizei height) { + DISPATCH_SETUP; DISPATCH(Scissor)(x, y, width, height); } void GLAPIENTRY glShadeModel(GLenum mode) { + DISPATCH_SETUP; DISPATCH(ShadeModel)(mode); } void GLAPIENTRY glStencilFunc(GLenum func, GLint ref, GLuint mask) { + DISPATCH_SETUP; DISPATCH(StencilFunc)(func, ref, mask); } void GLAPIENTRY glStencilMask(GLuint mask) { + DISPATCH_SETUP; DISPATCH(StencilMask)(mask); } void GLAPIENTRY glStencilOp(GLenum fail, GLenum zfail, GLenum zpass) { + DISPATCH_SETUP; DISPATCH(StencilOp)(fail, zfail, zpass); } void GLAPIENTRY glTexCoord1d(GLdouble s) { + DISPATCH_SETUP; DISPATCH(TexCoord1d)(s); } void GLAPIENTRY glTexCoord1f(GLfloat s) { + DISPATCH_SETUP; DISPATCH(TexCoord1f)(s); } void GLAPIENTRY glTexCoord1i(GLint s) { + DISPATCH_SETUP; DISPATCH(TexCoord1i)(s); } void GLAPIENTRY glTexCoord1s(GLshort s) { + DISPATCH_SETUP; DISPATCH(TexCoord1s)(s); } void GLAPIENTRY glTexCoord2d(GLdouble s, GLdouble t) { + DISPATCH_SETUP; DISPATCH(TexCoord2d)(s, t); } void GLAPIENTRY glTexCoord2f(GLfloat s, GLfloat t) { + DISPATCH_SETUP; DISPATCH(TexCoord2f)(s, t); } void GLAPIENTRY glTexCoord2s(GLshort s, GLshort t) { + DISPATCH_SETUP; DISPATCH(TexCoord2s)(s, t); } void GLAPIENTRY glTexCoord2i(GLint s, GLint t) { + DISPATCH_SETUP; DISPATCH(TexCoord2i)(s, t); } void GLAPIENTRY glTexCoord3d(GLdouble s, GLdouble t, GLdouble r) { + DISPATCH_SETUP; DISPATCH(TexCoord3d)(s, t, r); } void GLAPIENTRY glTexCoord3f(GLfloat s, GLfloat t, GLfloat r) { + DISPATCH_SETUP; DISPATCH(TexCoord3f)(s, t, r); } void GLAPIENTRY glTexCoord3i(GLint s, GLint t, GLint r) { + DISPATCH_SETUP; DISPATCH(TexCoord3i)(s, t, r); } void GLAPIENTRY glTexCoord3s(GLshort s, GLshort t, GLshort r) { + DISPATCH_SETUP; DISPATCH(TexCoord3s)(s, t, r); } void GLAPIENTRY glTexCoord4d(GLdouble s, GLdouble t, GLdouble r, GLdouble q) { + DISPATCH_SETUP; DISPATCH(TexCoord4d)(s, t, r, q); } void GLAPIENTRY glTexCoord4f(GLfloat s, GLfloat t, GLfloat r, GLfloat q) { + DISPATCH_SETUP; DISPATCH(TexCoord4f)(s, t, r, q); } void GLAPIENTRY glTexCoord4i(GLint s, GLint t, GLint r, GLint q) { + DISPATCH_SETUP; DISPATCH(TexCoord4i)(s, t, r, q); } void GLAPIENTRY glTexCoord4s(GLshort s, GLshort t, GLshort r, GLshort q) { + DISPATCH_SETUP; DISPATCH(TexCoord4s)(s, t, r, q); } void GLAPIENTRY glTexCoord1dv(const GLdouble *v) { + DISPATCH_SETUP; DISPATCH(TexCoord1dv)(v); } void GLAPIENTRY glTexCoord1fv(const GLfloat *v) { + DISPATCH_SETUP; DISPATCH(TexCoord1fv)(v); } void GLAPIENTRY glTexCoord1iv(const GLint *v) { + DISPATCH_SETUP; DISPATCH(TexCoord1iv)(v); } void GLAPIENTRY glTexCoord1sv(const GLshort *v) { + DISPATCH_SETUP; DISPATCH(TexCoord1sv)(v); } void GLAPIENTRY glTexCoord2dv(const GLdouble *v) { + DISPATCH_SETUP; DISPATCH(TexCoord2dv)(v); } void GLAPIENTRY glTexCoord2fv(const GLfloat *v) { + DISPATCH_SETUP; DISPATCH(TexCoord2fv)(v); } void GLAPIENTRY glTexCoord2iv(const GLint *v) { + DISPATCH_SETUP; DISPATCH(TexCoord2iv)(v); } void GLAPIENTRY glTexCoord2sv(const GLshort *v) { + DISPATCH_SETUP; DISPATCH(TexCoord2sv)(v); } void GLAPIENTRY glTexCoord3dv(const GLdouble *v) { + DISPATCH_SETUP; DISPATCH(TexCoord3dv)(v); } void GLAPIENTRY glTexCoord3fv(const GLfloat *v) { + DISPATCH_SETUP; DISPATCH(TexCoord3fv)(v); } void GLAPIENTRY glTexCoord3iv(const GLint *v) { + DISPATCH_SETUP; DISPATCH(TexCoord3iv)(v); } void GLAPIENTRY glTexCoord3sv(const GLshort *v) { + DISPATCH_SETUP; DISPATCH(TexCoord3sv)(v); } void GLAPIENTRY glTexCoord4dv(const GLdouble *v) { + DISPATCH_SETUP; DISPATCH(TexCoord4dv)(v); } void GLAPIENTRY glTexCoord4fv(const GLfloat *v) { + DISPATCH_SETUP; DISPATCH(TexCoord4fv)(v); } void GLAPIENTRY glTexCoord4iv(const GLint *v) { + DISPATCH_SETUP; DISPATCH(TexCoord4iv)(v); } void GLAPIENTRY glTexCoord4sv(const GLshort *v) { + DISPATCH_SETUP; DISPATCH(TexCoord4sv)(v); } void GLAPIENTRY glTexGend(GLenum coord, GLenum pname, GLdouble param) { + DISPATCH_SETUP; DISPATCH(TexGend)(coord, pname, param); } void GLAPIENTRY glTexGendv(GLenum coord, GLenum pname, const GLdouble *params) { + DISPATCH_SETUP; DISPATCH(TexGendv)(coord, pname, params); } void GLAPIENTRY glTexGenf(GLenum coord, GLenum pname, GLfloat param) { + DISPATCH_SETUP; DISPATCH(TexGenf)(coord, pname, param); } void GLAPIENTRY glTexGenfv(GLenum coord, GLenum pname, const GLfloat *params) { + DISPATCH_SETUP; DISPATCH(TexGenfv)(coord, pname, params); } void GLAPIENTRY glTexGeni(GLenum coord, GLenum pname, GLint param) { + DISPATCH_SETUP; DISPATCH(TexGeni)(coord, pname, param); } void GLAPIENTRY glTexGeniv(GLenum coord, GLenum pname, const GLint *params) { + DISPATCH_SETUP; DISPATCH(TexGeniv)(coord, pname, params); } void GLAPIENTRY glTexEnvf(GLenum target, GLenum pname, GLfloat param) { + DISPATCH_SETUP; DISPATCH(TexEnvf)(target, pname, param); } void GLAPIENTRY glTexEnvfv(GLenum target, GLenum pname, const GLfloat *param) { + DISPATCH_SETUP; DISPATCH(TexEnvfv)(target, pname, param); } void GLAPIENTRY glTexEnvi(GLenum target, GLenum pname, GLint param) { + DISPATCH_SETUP; DISPATCH(TexEnvi)(target, pname, param); } void GLAPIENTRY glTexEnviv(GLenum target, GLenum pname, const GLint *param) { + DISPATCH_SETUP; DISPATCH(TexEnviv)(target, pname, param); } void GLAPIENTRY glTexImage1D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const GLvoid *pixels) { + DISPATCH_SETUP; DISPATCH(TexImage1D)(target, level, internalformat, width, border, format, type, pixels); } void GLAPIENTRY glTexImage2D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid *pixels) { + DISPATCH_SETUP; DISPATCH(TexImage2D)(target, level, internalformat, width, height, border, format, type, pixels); } void GLAPIENTRY glTexParameterf(GLenum target, GLenum pname, GLfloat param) { + DISPATCH_SETUP; DISPATCH(TexParameterf)(target, pname, param); } void GLAPIENTRY glTexParameterfv(GLenum target, GLenum pname, const GLfloat *params) { + DISPATCH_SETUP; DISPATCH(TexParameterfv)(target, pname, params); } void GLAPIENTRY glTexParameteri(GLenum target, GLenum pname, GLint param) { + DISPATCH_SETUP; DISPATCH(TexParameteri)(target, pname, param); } void GLAPIENTRY glTexParameteriv(GLenum target, GLenum pname, const GLint *params) { + DISPATCH_SETUP; DISPATCH(TexParameteriv)(target, pname, params); } void GLAPIENTRY glTranslated(GLdouble x, GLdouble y, GLdouble z) { + DISPATCH_SETUP; DISPATCH(Translated)(x, y, z); } void GLAPIENTRY glTranslatef(GLfloat x, GLfloat y, GLfloat z) { + DISPATCH_SETUP; DISPATCH(Translatef)(x, y, z); } void GLAPIENTRY glVertex2d(GLdouble x, GLdouble y) { + DISPATCH_SETUP; DISPATCH(Vertex2d)(x, y); } void GLAPIENTRY glVertex2dv(const GLdouble *v) { + DISPATCH_SETUP; DISPATCH(Vertex2dv)(v); } void GLAPIENTRY glVertex2f(GLfloat x, GLfloat y) { + DISPATCH_SETUP; DISPATCH(Vertex2f)(x, y); } void GLAPIENTRY glVertex2fv(const GLfloat *v) { + DISPATCH_SETUP; DISPATCH(Vertex2fv)(v); } void GLAPIENTRY glVertex2i(GLint x, GLint y) { + DISPATCH_SETUP; DISPATCH(Vertex2i)(x, y); } void GLAPIENTRY glVertex2iv(const GLint *v) { + DISPATCH_SETUP; DISPATCH(Vertex2iv)(v); } void GLAPIENTRY glVertex2s(GLshort x, GLshort y) { + DISPATCH_SETUP; DISPATCH(Vertex2s)(x, y); } void GLAPIENTRY glVertex2sv(const GLshort *v) { + DISPATCH_SETUP; DISPATCH(Vertex2sv)(v); } void GLAPIENTRY glVertex3d(GLdouble x, GLdouble y, GLdouble z) { + DISPATCH_SETUP; DISPATCH(Vertex3d)(x, y, z); } void GLAPIENTRY glVertex3dv(const GLdouble *v) { + DISPATCH_SETUP; DISPATCH(Vertex3dv)(v); } void GLAPIENTRY glVertex3f(GLfloat x, GLfloat y, GLfloat z) { + DISPATCH_SETUP; DISPATCH(Vertex3f)(x, y, z); } void GLAPIENTRY glVertex3fv(const GLfloat *v) { + DISPATCH_SETUP; DISPATCH(Vertex3fv)(v); } void GLAPIENTRY glVertex3i(GLint x, GLint y, GLint z) { + DISPATCH_SETUP; DISPATCH(Vertex3i)(x, y, z); } void GLAPIENTRY glVertex3iv(const GLint *v) { + DISPATCH_SETUP; DISPATCH(Vertex3iv)(v); } void GLAPIENTRY glVertex3s(GLshort x, GLshort y, GLshort z) { + DISPATCH_SETUP; DISPATCH(Vertex3s)(x, y, z); } void GLAPIENTRY glVertex3sv(const GLshort *v) { + DISPATCH_SETUP; DISPATCH(Vertex3sv)(v); } void GLAPIENTRY glVertex4d(GLdouble x, GLdouble y, GLdouble z, GLdouble w) { + DISPATCH_SETUP; DISPATCH(Vertex4d)(x, y, z, w); } void GLAPIENTRY glVertex4dv(const GLdouble *v) { + DISPATCH_SETUP; DISPATCH(Vertex4dv)(v); } void GLAPIENTRY glVertex4f(GLfloat x, GLfloat y, GLfloat z, GLfloat w) { + DISPATCH_SETUP; DISPATCH(Vertex4f)(x, y, z, w); } void GLAPIENTRY glVertex4fv(const GLfloat *v) { + DISPATCH_SETUP; DISPATCH(Vertex4fv)(v); } void GLAPIENTRY glVertex4i(GLint x, GLint y, GLint z, GLint w) { + DISPATCH_SETUP; DISPATCH(Vertex4i)(x, y, z, w); } void GLAPIENTRY glVertex4iv(const GLint *v) { + DISPATCH_SETUP; DISPATCH(Vertex4iv)(v); } void GLAPIENTRY glVertex4s(GLshort x, GLshort y, GLshort z, GLshort w) { + DISPATCH_SETUP; DISPATCH(Vertex4s)(x, y, z, w); } void GLAPIENTRY glVertex4sv(const GLshort *v) { + DISPATCH_SETUP; DISPATCH(Vertex4sv)(v); } void GLAPIENTRY glViewport(GLint x, GLint y, GLsizei width, GLsizei height) { + DISPATCH_SETUP; DISPATCH(Viewport)(x, y, width, height); } @@ -1606,126 +2561,151 @@ void GLAPIENTRY glViewport(GLint x, GLint y, GLsizei width, GLsizei height) GLboolean GLAPIENTRY glAreTexturesResident(GLsizei n, const GLuint *textures, GLboolean *residences) { + DISPATCH_SETUP; return DISPATCH(AreTexturesResident)(n, textures, residences); } void GLAPIENTRY glArrayElement(GLint i) { + DISPATCH_SETUP; DISPATCH(ArrayElement)(i); } void GLAPIENTRY glBindTexture(GLenum target, GLuint texture) { + DISPATCH_SETUP; DISPATCH(BindTexture)(target, texture); } void GLAPIENTRY glColorPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *ptr) { + DISPATCH_SETUP; DISPATCH(ColorPointer)(size, type, stride, ptr); } void GLAPIENTRY glCopyTexImage1D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLint border) { + DISPATCH_SETUP; DISPATCH(CopyTexImage1D)(target, level, internalformat, x, y, width, border); } void GLAPIENTRY glCopyTexImage2D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border) { + DISPATCH_SETUP; DISPATCH(CopyTexImage2D)(target, level, internalformat, x, y, width, height, border); } void GLAPIENTRY glCopyTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width) { + DISPATCH_SETUP; DISPATCH(CopyTexSubImage1D)(target, level, xoffset, x, y, width); } void GLAPIENTRY glCopyTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height) { + DISPATCH_SETUP; DISPATCH(CopyTexSubImage2D)(target, level, xoffset, yoffset, x, y, width, height); } void GLAPIENTRY glDeleteTextures(GLsizei n, const GLuint *textures) { + DISPATCH_SETUP; DISPATCH(DeleteTextures)(n, textures); } void GLAPIENTRY glDisableClientState(GLenum cap) { + DISPATCH_SETUP; DISPATCH(DisableClientState)(cap); } void GLAPIENTRY glDrawArrays(GLenum mode, GLint first, GLsizei count) { + DISPATCH_SETUP; DISPATCH(DrawArrays)(mode, first, count); } void GLAPIENTRY glEdgeFlagPointer(GLsizei stride, const GLvoid *ptr) { + DISPATCH_SETUP; DISPATCH(EdgeFlagPointer)(stride, ptr); } void GLAPIENTRY glEnableClientState(GLenum cap) { + DISPATCH_SETUP; DISPATCH(EnableClientState)(cap); } void GLAPIENTRY glGenTextures(GLsizei n, GLuint *textures) { + DISPATCH_SETUP; DISPATCH(GenTextures)(n, textures); } void GLAPIENTRY glGetPointerv(GLenum pname, GLvoid **params) { + DISPATCH_SETUP; DISPATCH(GetPointerv)(pname, params); } void GLAPIENTRY glIndexPointer(GLenum type, GLsizei stride, const GLvoid *ptr) { + DISPATCH_SETUP; DISPATCH(IndexPointer)(type, stride, ptr); } void GLAPIENTRY glNormalPointer(GLenum type, GLsizei stride, const GLvoid *ptr) { + DISPATCH_SETUP; DISPATCH(NormalPointer)(type, stride, ptr); } void GLAPIENTRY glPolygonOffset(GLfloat factor, GLfloat units) { + DISPATCH_SETUP; DISPATCH(PolygonOffset)(factor, units); } void GLAPIENTRY glPopClientAttrib(void) { + DISPATCH_SETUP; DISPATCH(PopClientAttrib)(); } void GLAPIENTRY glPrioritizeTextures(GLsizei n, const GLuint *textures, const GLclampf *priorities) { + DISPATCH_SETUP; DISPATCH(PrioritizeTextures)(n, textures, priorities); } void GLAPIENTRY glPushClientAttrib(GLbitfield mask) { + DISPATCH_SETUP; DISPATCH(PushClientAttrib)(mask); } void GLAPIENTRY glTexCoordPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *ptr) { + DISPATCH_SETUP; DISPATCH(TexCoordPointer)(size, type, stride, ptr); } void GLAPIENTRY glTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const GLvoid *pixels) { + DISPATCH_SETUP; DISPATCH(TexSubImage1D)(target, level, xoffset, width, format, type, pixels); } void GLAPIENTRY glTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels) { + DISPATCH_SETUP; DISPATCH(TexSubImage2D)(target, level, xoffset, yoffset, width, height, format, type, pixels); } void GLAPIENTRY glVertexPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *ptr) { + DISPATCH_SETUP; DISPATCH(VertexPointer)(size, type, stride, ptr); } @@ -1737,21 +2717,25 @@ void GLAPIENTRY glVertexPointer(GLint size, GLenum type, GLsizei stride, const G void GLAPIENTRY glCopyTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height) { + DISPATCH_SETUP; DISPATCH(CopyTexSubImage3D)(target, level, xoffset, yoffset, zoffset, x, y, width, height); } void GLAPIENTRY glDrawRangeElements(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid *indices) { + DISPATCH_SETUP; DISPATCH(DrawRangeElements)(mode, start, end, count, type, indices); } void GLAPIENTRY glTexImage3D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const GLvoid *pixels) { + DISPATCH_SETUP; DISPATCH(TexImage3D)(target, level, internalformat, width, height, depth, border, format, type, pixels); } void GLAPIENTRY glTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const GLvoid *pixels) { + DISPATCH_SETUP; DISPATCH(TexSubImage3D)(target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels); } @@ -1760,171 +2744,205 @@ void GLAPIENTRY glTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint void GLAPIENTRY glBlendColor(GLclampf r, GLclampf g, GLclampf b, GLclampf a) { + DISPATCH_SETUP; DISPATCH(BlendColor)(r, g, b, a); } void GLAPIENTRY glBlendEquation(GLenum mode) { + DISPATCH_SETUP; DISPATCH(BlendEquation)(mode); } void GLAPIENTRY glColorSubTable(GLenum target, GLsizei start, GLsizei count, GLenum format, GLenum type, const GLvoid *data) { + DISPATCH_SETUP; DISPATCH(ColorSubTable)(target, start, count, format, type, data); } void GLAPIENTRY glColorTable(GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const GLvoid *table) { + DISPATCH_SETUP; DISPATCH(ColorTable)(target, internalformat, width, format, type, table); } void GLAPIENTRY glColorTableParameterfv(GLenum target, GLenum pname, const GLfloat *params) { + DISPATCH_SETUP; DISPATCH(ColorTableParameterfv)(target, pname, params); } void GLAPIENTRY glColorTableParameteriv(GLenum target, GLenum pname, const GLint *params) { + DISPATCH_SETUP; DISPATCH(ColorTableParameteriv)(target, pname, params); } void GLAPIENTRY glConvolutionFilter1D(GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const GLvoid *image) { + DISPATCH_SETUP; DISPATCH(ConvolutionFilter1D)(target, internalformat, width, format, type, image); } void GLAPIENTRY glConvolutionFilter2D(GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *image) { + DISPATCH_SETUP; DISPATCH(ConvolutionFilter2D)(target, internalformat, width, height, format, type, image); } void GLAPIENTRY glConvolutionParameterf(GLenum target, GLenum pname, GLfloat params) { + DISPATCH_SETUP; DISPATCH(ConvolutionParameterf)(target, pname, params); } void GLAPIENTRY glConvolutionParameterfv(GLenum target, GLenum pname, const GLfloat *params) { + DISPATCH_SETUP; DISPATCH(ConvolutionParameterfv)(target, pname, params); } void GLAPIENTRY glConvolutionParameteri(GLenum target, GLenum pname, GLint params) { + DISPATCH_SETUP; DISPATCH(ConvolutionParameteri)(target, pname, params); } void GLAPIENTRY glConvolutionParameteriv(GLenum target, GLenum pname, const GLint *params) { + DISPATCH_SETUP; DISPATCH(ConvolutionParameteriv)(target, pname, params); } void GLAPIENTRY glCopyColorSubTable(GLenum target, GLsizei start, GLint x, GLint y, GLsizei width) { + DISPATCH_SETUP; DISPATCH(CopyColorSubTable)(target, start, x, y, width); } void GLAPIENTRY glCopyColorTable(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width) { + DISPATCH_SETUP; DISPATCH(CopyColorTable)(target, internalformat, x, y, width); } void GLAPIENTRY glCopyConvolutionFilter1D(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width) { + DISPATCH_SETUP; DISPATCH(CopyConvolutionFilter1D)(target, internalformat, x, y, width); } void GLAPIENTRY glCopyConvolutionFilter2D(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height) { + DISPATCH_SETUP; DISPATCH(CopyConvolutionFilter2D)(target, internalformat, x, y, width, height); } void GLAPIENTRY glGetColorTable(GLenum target, GLenum format, GLenum type, GLvoid *table) { + DISPATCH_SETUP; DISPATCH(GetColorTable)(target, format, type, table); } void GLAPIENTRY glGetColorTableParameterfv(GLenum target, GLenum pname, GLfloat *params) { + DISPATCH_SETUP; DISPATCH(GetColorTableParameterfv)(target, pname, params); } void GLAPIENTRY glGetColorTableParameteriv(GLenum target, GLenum pname, GLint *params) { + DISPATCH_SETUP; DISPATCH(GetColorTableParameteriv)(target, pname, params); } void GLAPIENTRY glGetConvolutionFilter(GLenum target, GLenum format, GLenum type, GLvoid *image) { + DISPATCH_SETUP; DISPATCH(GetConvolutionFilter)(target, format, type, image); } void GLAPIENTRY glGetConvolutionParameterfv(GLenum target, GLenum pname, GLfloat *params) { + DISPATCH_SETUP; DISPATCH(GetConvolutionParameterfv)(target, pname, params); } void GLAPIENTRY glGetConvolutionParameteriv(GLenum target, GLenum pname, GLint *params) { + DISPATCH_SETUP; DISPATCH(GetConvolutionParameteriv)(target, pname, params); } void GLAPIENTRY glGetHistogram(GLenum target, GLboolean reset, GLenum format, GLenum type, GLvoid *values) { + DISPATCH_SETUP; DISPATCH(GetHistogram)(target, reset, format, type, values); } void GLAPIENTRY glGetHistogramParameterfv(GLenum target, GLenum pname, GLfloat *params) { + DISPATCH_SETUP; DISPATCH(GetHistogramParameterfv)(target, pname, params); } void GLAPIENTRY glGetHistogramParameteriv(GLenum target, GLenum pname, GLint *params) { + DISPATCH_SETUP; DISPATCH(GetHistogramParameteriv)(target, pname, params); } void GLAPIENTRY glGetMinmax(GLenum target, GLboolean reset, GLenum format, GLenum types, GLvoid *values) { + DISPATCH_SETUP; DISPATCH(GetMinmax)(target, reset, format, types, values); } void GLAPIENTRY glGetMinmaxParameterfv(GLenum target, GLenum pname, GLfloat *params) { + DISPATCH_SETUP; DISPATCH(GetMinmaxParameterfv)(target, pname, params); } void GLAPIENTRY glGetMinmaxParameteriv(GLenum target, GLenum pname, GLint *params) { + DISPATCH_SETUP; DISPATCH(GetMinmaxParameteriv)(target, pname, params); } void GLAPIENTRY glGetSeparableFilter(GLenum target, GLenum format, GLenum type, GLvoid *row, GLvoid *column, GLvoid *span) { + DISPATCH_SETUP; DISPATCH(GetSeparableFilter)(target, format, type, row, column, span); } void GLAPIENTRY glHistogram(GLenum target, GLsizei width, GLenum internalformat, GLboolean sink) { + DISPATCH_SETUP; DISPATCH(Histogram)(target, width, internalformat, sink); } void GLAPIENTRY glMinmax(GLenum target, GLenum internalformat, GLboolean sink) { + DISPATCH_SETUP; DISPATCH(Minmax)(target, internalformat, sink); } void GLAPIENTRY glResetMinmax(GLenum target) { + DISPATCH_SETUP; DISPATCH(ResetMinmax)(target); } void GLAPIENTRY glResetHistogram(GLenum target) { + DISPATCH_SETUP; DISPATCH(ResetHistogram)(target); } void GLAPIENTRY glSeparableFilter2D(GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *row, const GLvoid *column) { + DISPATCH_SETUP; DISPATCH(SeparableFilter2D)(target, internalformat, width, height, format, type, row, column); } @@ -1941,6 +2959,7 @@ void GLAPIENTRY glSeparableFilter2D(GLenum target, GLenum internalformat, GLsize #ifdef _GLAPI_EXT_blend_minmax void GLAPIENTRY glBlendEquationEXT(GLenum mode) { + DISPATCH_SETUP; DISPATCH(BlendEquationEXT)(mode); } #endif @@ -1949,6 +2968,7 @@ void GLAPIENTRY glBlendEquationEXT(GLenum mode) #ifdef _GLAPI_EXT_blend_color void GLAPIENTRY glBlendColorEXT(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha) { + DISPATCH_SETUP; DISPATCH(BlendColorEXT)(red, green, blue, alpha); } #endif @@ -1957,6 +2977,7 @@ void GLAPIENTRY glBlendColorEXT(GLclampf red, GLclampf green, GLclampf blue, GLc #ifdef _GLAPI_EXT_polygon_offset void GLAPIENTRY glPolygonOffsetEXT(GLfloat factor, GLfloat bias) { + DISPATCH_SETUP; DISPATCH(PolygonOffsetEXT)(factor, bias); } #endif @@ -1967,52 +2988,61 @@ void GLAPIENTRY glPolygonOffsetEXT(GLfloat factor, GLfloat bias) void GLAPIENTRY glVertexPointerEXT(GLint size, GLenum type, GLsizei stride, GLsizei count, const GLvoid *ptr) { + DISPATCH_SETUP; (void) count; DISPATCH(VertexPointer)(size, type, stride, ptr); } void GLAPIENTRY glNormalPointerEXT(GLenum type, GLsizei stride, GLsizei count, const GLvoid *ptr) { + DISPATCH_SETUP; (void) count; DISPATCH(NormalPointer)(type, stride, ptr); } void GLAPIENTRY glColorPointerEXT(GLint size, GLenum type, GLsizei stride, GLsizei count, const GLvoid *ptr) { + DISPATCH_SETUP; (void) count; DISPATCH(ColorPointer)(size, type, stride, ptr); } void GLAPIENTRY glIndexPointerEXT(GLenum type, GLsizei stride, GLsizei count, const GLvoid *ptr) { + DISPATCH_SETUP; (void) count; DISPATCH(IndexPointer)(type, stride, ptr); } void GLAPIENTRY glTexCoordPointerEXT(GLint size, GLenum type, GLsizei stride, GLsizei count, const GLvoid *ptr) { + DISPATCH_SETUP; (void) count; DISPATCH(ColorPointer)(size, type, stride, ptr); } void GLAPIENTRY glEdgeFlagPointerEXT(GLsizei stride, GLsizei count, const GLboolean *ptr) { + DISPATCH_SETUP; (void) count; DISPATCH(EdgeFlagPointer)(stride, ptr); } void GLAPIENTRY glGetPointervEXT(GLenum pname, void **params) { + DISPATCH_SETUP; DISPATCH(GetPointerv)(pname, params); } void GLAPIENTRY glArrayElementEXT(GLint i) { + DISPATCH_SETUP; DISPATCH(ArrayElement)(i); } void GLAPIENTRY glDrawArraysEXT(GLenum mode, GLint first, GLsizei count) { + DISPATCH_SETUP; DISPATCH(DrawArrays)(mode, first, count); } @@ -2024,32 +3054,38 @@ void GLAPIENTRY glDrawArraysEXT(GLenum mode, GLint first, GLsizei count) void GLAPIENTRY glGenTexturesEXT(GLsizei n, GLuint *textures) { + DISPATCH_SETUP; DISPATCH(GenTextures)(n, textures); } void GLAPIENTRY glDeleteTexturesEXT(GLsizei n, const GLuint *texture) { + DISPATCH_SETUP; DISPATCH(DeleteTextures)(n, texture); } void GLAPIENTRY glBindTextureEXT(GLenum target, GLuint texture) { + DISPATCH_SETUP; DISPATCH(BindTexture)(target, texture); } void GLAPIENTRY glPrioritizeTexturesEXT(GLsizei n, const GLuint *textures, const GLclampf *priorities) { + DISPATCH_SETUP; DISPATCH(PrioritizeTextures)(n, textures, priorities); } GLboolean GLAPIENTRY glAreTexturesResidentEXT(GLsizei n, const GLuint *textures, GLboolean *residences) { + DISPATCH_SETUP; DISPATCH(AreTexturesResident)(n, textures, residences); return GL_FALSE; } GLboolean GLAPIENTRY glIsTextureEXT(GLuint texture) { + DISPATCH_SETUP; DISPATCH(IsTexture)(texture); return GL_FALSE; } @@ -2061,16 +3097,19 @@ GLboolean GLAPIENTRY glIsTextureEXT(GLuint texture) void GLAPIENTRY glTexImage3DEXT(GLenum target, GLint level, GLenum internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const GLvoid *pixels) { + DISPATCH_SETUP; DISPATCH(TexImage3D)(target, level, internalFormat, width, height, depth, border, format, type, pixels); } void GLAPIENTRY glTexSubImage3DEXT(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const GLvoid *pixels) { + DISPATCH_SETUP; DISPATCH(TexSubImage3D)(target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels); } void GLAPIENTRY glCopyTexSubImage3DEXT(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height) { + DISPATCH_SETUP; DISPATCH(CopyTexSubImage3D)(target, level, xoffset, yoffset, zoffset, x, y, width, height); } @@ -2082,26 +3121,31 @@ void GLAPIENTRY glCopyTexSubImage3DEXT(GLenum target, GLint level, GLint xoffset void GLAPIENTRY glColorTableEXT(GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const GLvoid *table) { + DISPATCH_SETUP; DISPATCH(ColorTableEXT)(target, internalformat, width, format, type, table); } void GLAPIENTRY glColorSubTableEXT(GLenum target, GLsizei start, GLsizei count, GLenum format, GLenum type, const GLvoid *data) { + DISPATCH_SETUP; DISPATCH(ColorSubTableEXT)(target, start, count, format, type, data); } void GLAPIENTRY glGetColorTableEXT(GLenum target, GLenum format, GLenum type, GLvoid *table) { + DISPATCH_SETUP; DISPATCH(GetColorTableEXT)(target, format, type, table); } void GLAPIENTRY glGetColorTableParameterfvEXT(GLenum target, GLenum pname, GLfloat *params) { + DISPATCH_SETUP; DISPATCH(GetColorTableParameterfvEXT)(target, pname, params); } void GLAPIENTRY glGetColorTableParameterivEXT(GLenum target, GLenum pname, GLint *params) { + DISPATCH_SETUP; DISPATCH(GetColorTableParameterivEXT)(target, pname, params); } @@ -2113,11 +3157,13 @@ void GLAPIENTRY glGetColorTableParameterivEXT(GLenum target, GLenum pname, GLint void GLAPIENTRY glLockArraysEXT(GLint first, GLsizei count) { + DISPATCH_SETUP; DISPATCH(LockArraysEXT)(first, count); } void GLAPIENTRY glUnlockArraysEXT(void) { + DISPATCH_SETUP; DISPATCH(UnlockArraysEXT)(); } @@ -2129,11 +3175,13 @@ void GLAPIENTRY glUnlockArraysEXT(void) void GLAPIENTRY glPointParameterfEXT(GLenum target, GLfloat param) { + DISPATCH_SETUP; DISPATCH(PointParameterfEXT)(target, param); } void GLAPIENTRY glPointParameterfvEXT(GLenum target, const GLfloat *param) { + DISPATCH_SETUP; DISPATCH(PointParameterfvEXT)(target, param); } @@ -2145,171 +3193,205 @@ void GLAPIENTRY glPointParameterfvEXT(GLenum target, const GLfloat *param) void GLAPIENTRY glActiveTextureARB(GLenum texture) { + DISPATCH_SETUP; DISPATCH(ActiveTextureARB)(texture); } void GLAPIENTRY glClientActiveTextureARB(GLenum texture) { + DISPATCH_SETUP; DISPATCH(ClientActiveTextureARB)(texture); } void GLAPIENTRY glMultiTexCoord1dARB(GLenum target, GLdouble s) { + DISPATCH_SETUP; DISPATCH(MultiTexCoord1dARB)(target, s); } void GLAPIENTRY glMultiTexCoord1dvARB(GLenum target, const GLdouble *v) { + DISPATCH_SETUP; DISPATCH(MultiTexCoord1dvARB)(target, v); } void GLAPIENTRY glMultiTexCoord1fARB(GLenum target, GLfloat s) { + DISPATCH_SETUP; DISPATCH(MultiTexCoord1fARB)(target, s); } void GLAPIENTRY glMultiTexCoord1fvARB(GLenum target, const GLfloat *v) { + DISPATCH_SETUP; DISPATCH(MultiTexCoord1fvARB)(target, v); } void GLAPIENTRY glMultiTexCoord1iARB(GLenum target, GLint s) { + DISPATCH_SETUP; DISPATCH(MultiTexCoord1iARB)(target, s); } void GLAPIENTRY glMultiTexCoord1ivARB(GLenum target, const GLint *v) { + DISPATCH_SETUP; DISPATCH(MultiTexCoord1ivARB)(target, v); } void GLAPIENTRY glMultiTexCoord1sARB(GLenum target, GLshort s) { + DISPATCH_SETUP; DISPATCH(MultiTexCoord1sARB)(target, s); } void GLAPIENTRY glMultiTexCoord1svARB(GLenum target, const GLshort *v) { + DISPATCH_SETUP; DISPATCH(MultiTexCoord1svARB)(target, v); } void GLAPIENTRY glMultiTexCoord2dARB(GLenum target, GLdouble s, GLdouble t) { + DISPATCH_SETUP; DISPATCH(MultiTexCoord2dARB)(target, s, t); } void GLAPIENTRY glMultiTexCoord2dvARB(GLenum target, const GLdouble *v) { + DISPATCH_SETUP; DISPATCH(MultiTexCoord2dvARB)(target, v); } void GLAPIENTRY glMultiTexCoord2fARB(GLenum target, GLfloat s, GLfloat t) { + DISPATCH_SETUP; DISPATCH(MultiTexCoord2fARB)(target, s, t); } void GLAPIENTRY glMultiTexCoord2fvARB(GLenum target, const GLfloat *v) { + DISPATCH_SETUP; DISPATCH(MultiTexCoord2fvARB)(target, v); } void GLAPIENTRY glMultiTexCoord2iARB(GLenum target, GLint s, GLint t) { + DISPATCH_SETUP; DISPATCH(MultiTexCoord2iARB)(target, s, t); } void GLAPIENTRY glMultiTexCoord2ivARB(GLenum target, const GLint *v) { + DISPATCH_SETUP; DISPATCH(MultiTexCoord2ivARB)(target, v); } void GLAPIENTRY glMultiTexCoord2sARB(GLenum target, GLshort s, GLshort t) { + DISPATCH_SETUP; DISPATCH(MultiTexCoord2sARB)(target, s, t); } void GLAPIENTRY glMultiTexCoord2svARB(GLenum target, const GLshort *v) { + DISPATCH_SETUP; DISPATCH(MultiTexCoord2svARB)(target, v); } void GLAPIENTRY glMultiTexCoord3dARB(GLenum target, GLdouble s, GLdouble t, GLdouble r) { + DISPATCH_SETUP; DISPATCH(MultiTexCoord3dARB)(target, s, t, r); } void GLAPIENTRY glMultiTexCoord3dvARB(GLenum target, const GLdouble *v) { + DISPATCH_SETUP; DISPATCH(MultiTexCoord3dvARB)(target, v); } void GLAPIENTRY glMultiTexCoord3fARB(GLenum target, GLfloat s, GLfloat t, GLfloat r) { + DISPATCH_SETUP; DISPATCH(MultiTexCoord3fARB)(target, s, t, r); } void GLAPIENTRY glMultiTexCoord3fvARB(GLenum target, const GLfloat *v) { + DISPATCH_SETUP; DISPATCH(MultiTexCoord3fvARB)(target, v); } void GLAPIENTRY glMultiTexCoord3iARB(GLenum target, GLint s, GLint t, GLint r) { + DISPATCH_SETUP; DISPATCH(MultiTexCoord3iARB)(target, s, t, r); } void GLAPIENTRY glMultiTexCoord3ivARB(GLenum target, const GLint *v) { + DISPATCH_SETUP; DISPATCH(MultiTexCoord3ivARB)(target, v); } void GLAPIENTRY glMultiTexCoord3sARB(GLenum target, GLshort s, GLshort t, GLshort r) { + DISPATCH_SETUP; DISPATCH(MultiTexCoord3sARB)(target, s, t, r); } void GLAPIENTRY glMultiTexCoord3svARB(GLenum target, const GLshort *v) { + DISPATCH_SETUP; DISPATCH(MultiTexCoord3svARB)(target, v); } void GLAPIENTRY glMultiTexCoord4dARB(GLenum target, GLdouble s, GLdouble t, GLdouble r, GLdouble q) { + DISPATCH_SETUP; DISPATCH(MultiTexCoord4dARB)(target, s, t, r, q); } void GLAPIENTRY glMultiTexCoord4dvARB(GLenum target, const GLdouble *v) { + DISPATCH_SETUP; DISPATCH(MultiTexCoord4dvARB)(target, v); } void GLAPIENTRY glMultiTexCoord4fARB(GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q) { + DISPATCH_SETUP; DISPATCH(MultiTexCoord4fARB)(target, s, t, r, q); } void GLAPIENTRY glMultiTexCoord4fvARB(GLenum target, const GLfloat *v) { + DISPATCH_SETUP; DISPATCH(MultiTexCoord4fvARB)(target, v); } void GLAPIENTRY glMultiTexCoord4iARB(GLenum target, GLint s, GLint t, GLint r, GLint q) { + DISPATCH_SETUP; DISPATCH(MultiTexCoord4iARB)(target, s, t, r, q); } void GLAPIENTRY glMultiTexCoord4ivARB(GLenum target, const GLint *v) { + DISPATCH_SETUP; DISPATCH(MultiTexCoord4ivARB)(target, v); } void GLAPIENTRY glMultiTexCoord4sARB(GLenum target, GLshort s, GLshort t, GLshort r, GLshort q) { + DISPATCH_SETUP; DISPATCH(MultiTexCoord4sARB)(target, s, t, r, q); } void GLAPIENTRY glMultiTexCoord4svARB(GLenum target, const GLshort *v) { + DISPATCH_SETUP; DISPATCH(MultiTexCoord4svARB)(target, v); } @@ -2320,6 +3402,7 @@ void GLAPIENTRY glMultiTexCoord4svARB(GLenum target, const GLshort *v) #ifdef _GLAPI_INGR_blend_func_separate void GLAPIENTRY glBlendFuncSeparateINGR(GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha) { + DISPATCH_SETUP; DISPATCH(BlendFuncSeparateINGR)(sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha); } #endif /* GL_INGR_blend_func_separate */ @@ -2330,121 +3413,145 @@ void GLAPIENTRY glBlendFuncSeparateINGR(GLenum sfactorRGB, GLenum dfactorRGB, GL void GLAPIENTRY glWindowPos2iMESA(GLint x, GLint y) { + DISPATCH_SETUP; DISPATCH(WindowPos4fMESA)(x, y, 0, 1); } void GLAPIENTRY glWindowPos2sMESA(GLshort x, GLshort y) { + DISPATCH_SETUP; DISPATCH(WindowPos4fMESA)(x, y, 0, 1); } void GLAPIENTRY glWindowPos2fMESA(GLfloat x, GLfloat y) { + DISPATCH_SETUP; DISPATCH(WindowPos4fMESA)(x, y, 0, 1); } void GLAPIENTRY glWindowPos2dMESA(GLdouble x, GLdouble y) { + DISPATCH_SETUP; DISPATCH(WindowPos4fMESA)(x, y, 0, 1); } void GLAPIENTRY glWindowPos2ivMESA(const GLint *p) { + DISPATCH_SETUP; DISPATCH(WindowPos4fMESA)(p[0], p[1], 0, 1); } void GLAPIENTRY glWindowPos2svMESA(const GLshort *p) { + DISPATCH_SETUP; DISPATCH(WindowPos4fMESA)(p[0], p[1], 0, 1); } void GLAPIENTRY glWindowPos2fvMESA(const GLfloat *p) { + DISPATCH_SETUP; DISPATCH(WindowPos4fMESA)(p[0], p[1], 0, 1); } void GLAPIENTRY glWindowPos2dvMESA(const GLdouble *p) { + DISPATCH_SETUP; DISPATCH(WindowPos4fMESA)(p[0], p[1], 0, 1); } void GLAPIENTRY glWindowPos3iMESA(GLint x, GLint y, GLint z) { + DISPATCH_SETUP; DISPATCH(WindowPos4fMESA)(x, y, z, 1); } void GLAPIENTRY glWindowPos3sMESA(GLshort x, GLshort y, GLshort z) { + DISPATCH_SETUP; DISPATCH(WindowPos4fMESA)(x, y, z, 1); } void GLAPIENTRY glWindowPos3fMESA(GLfloat x, GLfloat y, GLfloat z) { + DISPATCH_SETUP; DISPATCH(WindowPos4fMESA)(x, y, z, 1); } void GLAPIENTRY glWindowPos3dMESA(GLdouble x, GLdouble y, GLdouble z) { + DISPATCH_SETUP; DISPATCH(WindowPos4fMESA)(x, y, z, 1); } void GLAPIENTRY glWindowPos3ivMESA(const GLint *p) { + DISPATCH_SETUP; DISPATCH(WindowPos4fMESA)(p[0], p[1], p[2], 1.0); } void GLAPIENTRY glWindowPos3svMESA(const GLshort *p) { + DISPATCH_SETUP; DISPATCH(WindowPos4fMESA)(p[0], p[1], p[2], 1.0); } void GLAPIENTRY glWindowPos3fvMESA(const GLfloat *p) { + DISPATCH_SETUP; DISPATCH(WindowPos4fMESA)(p[0], p[1], p[2], 1.0); } void GLAPIENTRY glWindowPos3dvMESA(const GLdouble *p) { + DISPATCH_SETUP; DISPATCH(WindowPos4fMESA)(p[0], p[1], p[2], 1.0); } void GLAPIENTRY glWindowPos4iMESA(GLint x, GLint y, GLint z, GLint w) { + DISPATCH_SETUP; DISPATCH(WindowPos4fMESA)(x, y, z, w); } void GLAPIENTRY glWindowPos4sMESA(GLshort x, GLshort y, GLshort z, GLshort w) { + DISPATCH_SETUP; DISPATCH(WindowPos4fMESA)(x, y, z, w); } void GLAPIENTRY glWindowPos4fMESA(GLfloat x, GLfloat y, GLfloat z, GLfloat w) { + DISPATCH_SETUP; DISPATCH(WindowPos4fMESA)(x, y, z, w); } void GLAPIENTRY glWindowPos4dMESA(GLdouble x, GLdouble y, GLdouble z, GLdouble w) { + DISPATCH_SETUP; DISPATCH(WindowPos4fMESA)(x, y, z, w); } void GLAPIENTRY glWindowPos4ivMESA(const GLint *p) { + DISPATCH_SETUP; DISPATCH(WindowPos4fMESA)(p[0], p[1], p[2], p[3]); } void GLAPIENTRY glWindowPos4svMESA(const GLshort *p) { + DISPATCH_SETUP; DISPATCH(WindowPos4fMESA)(p[0], p[1], p[2], p[3]); } void GLAPIENTRY glWindowPos4fvMESA(const GLfloat *p) { + DISPATCH_SETUP; DISPATCH(WindowPos4fMESA)(p[0], p[1], p[2], p[3]); } void GLAPIENTRY glWindowPos4dvMESA(const GLdouble *p) { + DISPATCH_SETUP; DISPATCH(WindowPos4fMESA)(p[0], p[1], p[2], p[3]); } @@ -2455,11 +3562,14 @@ void GLAPIENTRY glWindowPos4dvMESA(const GLdouble *p) #ifdef _GLAPI_MESA_resize_buffers void GLAPIENTRY glResizeBuffersMESA(void) { + DISPATCH_SETUP; DISPATCH(ResizeBuffersMESA)(); } #endif /* GL_MESA_resize_buffers */ + + #ifdef DEBUG /* * This struct is just used to be sure we've defined all the API functions. @@ -2936,572 +4046,3 @@ static struct _glapi_table completeness_test = { }; #endif /*DEBUG*/ - - - - -/* - * Set the global or per-thread dispatch table pointer. - */ -void -_glapi_set_dispatch(struct _glapi_table *dispatch) -{ -#ifdef DEBUG - (void) completeness_test; /* to silence compiler warnings */ -#endif - - if (dispatch) { -#ifdef DEBUG - _glapi_check_table(dispatch); -#endif -#if defined(MULTI_THREAD) - /* set this thread's dispatch pointer */ - /* XXX To Do */ -#else - Dispatch = dispatch; -#endif - } - else { - /* no current context, each function is a no-op */ -#if defined(MULTI_THREAD) - /* XXX To Do */ -#else - Dispatch = &__glapi_noop_table; -#endif - } -} - - -/* - * Get the global or per-thread dispatch table pointer. - */ -struct _glapi_table * -_glapi_get_dispatch(void) -{ -#if defined(MULTI_THREAD) - /* return this thread's dispatch pointer */ - return NULL; -#else - return Dispatch; -#endif -} - - -/* - * Get API dispatcher version string. - */ -const char * -_glapi_get_version(void) -{ - return "1.2"; /* XXX this isn't well defined yet */ -} - - -/* - * Return list of hard-coded extension entrypoints in the dispatch table. - */ -const char * -_glapi_get_extensions(void) -{ - return "GL_EXT_paletted_texture GL_EXT_compiled_vertex_array GL_EXT_point_parameters GL_EXT_polygon_offset GL_EXT_blend_minmax GL_EXT_blend_color GL_ARB_multitexture GL_INGR_blend_func_separate GL_MESA_window_pos GL_MESA_resize_buffers"; -} - - - -/* - * Dynamically allocate an extension entry point. Return a slot number. - */ -GLint -_glapi_alloc_entrypoint(const char *funcName) -{ - /* XXX To Do */ - return -1; -} - - - -/* - * Find the dynamic entry point for the named function. - */ -GLint -_glapi_get_entrypoint(const char *funcName) -{ - /* XXX To Do */ - return -1; -} - - -/* - * Return entrypoint for named function. - */ -const GLvoid * -_glapi_get_proc_address(const char *funcName) -{ - /* XXX To Do */ - return NULL; -} - - - -/* - * Make sure there are no NULL pointers in the given dispatch table. - * Intented for debugging purposes. - */ -void -_glapi_check_table(const struct _glapi_table *table) -{ - assert(table->Accum); - assert(table->AlphaFunc); - assert(table->Begin); - assert(table->Bitmap); - assert(table->BlendFunc); - assert(table->CallList); - assert(table->CallLists); - assert(table->Clear); - assert(table->ClearAccum); - assert(table->ClearColor); - assert(table->ClearDepth); - assert(table->ClearIndex); - assert(table->ClearStencil); - assert(table->ClipPlane); - assert(table->Color3b); - assert(table->Color3bv); - assert(table->Color3d); - assert(table->Color3dv); - assert(table->Color3f); - assert(table->Color3fv); - assert(table->Color3i); - assert(table->Color3iv); - assert(table->Color3s); - assert(table->Color3sv); - assert(table->Color3ub); - assert(table->Color3ubv); - assert(table->Color3ui); - assert(table->Color3uiv); - assert(table->Color3us); - assert(table->Color3usv); - assert(table->Color4b); - assert(table->Color4bv); - assert(table->Color4d); - assert(table->Color4dv); - assert(table->Color4f); - assert(table->Color4fv); - assert(table->Color4i); - assert(table->Color4iv); - assert(table->Color4s); - assert(table->Color4sv); - assert(table->Color4ub); - assert(table->Color4ubv); - assert(table->Color4ui); - assert(table->Color4uiv); - assert(table->Color4us); - assert(table->Color4usv); - assert(table->ColorMask); - assert(table->ColorMaterial); - assert(table->CopyPixels); - assert(table->CullFace); - assert(table->DeleteLists); - assert(table->DepthFunc); - assert(table->DepthMask); - assert(table->DepthRange); - assert(table->Disable); - assert(table->DrawBuffer); - assert(table->DrawElements); - assert(table->DrawPixels); - assert(table->EdgeFlag); - assert(table->EdgeFlagv); - assert(table->Enable); - assert(table->End); - assert(table->EndList); - assert(table->EvalCoord1d); - assert(table->EvalCoord1dv); - assert(table->EvalCoord1f); - assert(table->EvalCoord1fv); - assert(table->EvalCoord2d); - assert(table->EvalCoord2dv); - assert(table->EvalCoord2f); - assert(table->EvalCoord2fv); - assert(table->EvalMesh1); - assert(table->EvalMesh2); - assert(table->EvalPoint1); - assert(table->EvalPoint2); - assert(table->FeedbackBuffer); - assert(table->Finish); - assert(table->Flush); - assert(table->Fogf); - assert(table->Fogfv); - assert(table->Fogi); - assert(table->Fogiv); - assert(table->FrontFace); - assert(table->Frustum); - assert(table->GenLists); - assert(table->GetBooleanv); - assert(table->GetClipPlane); - assert(table->GetDoublev); - assert(table->GetError); - assert(table->GetFloatv); - assert(table->GetIntegerv); - assert(table->GetLightfv); - assert(table->GetLightiv); - assert(table->GetMapdv); - assert(table->GetMapfv); - assert(table->GetMapiv); - assert(table->GetMaterialfv); - assert(table->GetMaterialiv); - assert(table->GetPixelMapfv); - assert(table->GetPixelMapuiv); - assert(table->GetPixelMapusv); - assert(table->GetPolygonStipple); - assert(table->GetString); - assert(table->GetTexEnvfv); - assert(table->GetTexEnviv); - assert(table->GetTexGendv); - assert(table->GetTexGenfv); - assert(table->GetTexGeniv); - assert(table->GetTexImage); - assert(table->GetTexLevelParameterfv); - assert(table->GetTexLevelParameteriv); - assert(table->GetTexParameterfv); - assert(table->GetTexParameteriv); - assert(table->Hint); - assert(table->IndexMask); - assert(table->Indexd); - assert(table->Indexdv); - assert(table->Indexf); - assert(table->Indexfv); - assert(table->Indexi); - assert(table->Indexiv); - assert(table->Indexs); - assert(table->Indexsv); - assert(table->InitNames); - assert(table->IsEnabled); - assert(table->IsList); - assert(table->LightModelf); - assert(table->LightModelfv); - assert(table->LightModeli); - assert(table->LightModeliv); - assert(table->Lightf); - assert(table->Lightfv); - assert(table->Lighti); - assert(table->Lightiv); - assert(table->LineStipple); - assert(table->LineWidth); - assert(table->ListBase); - assert(table->LoadIdentity); - assert(table->LoadMatrixd); - assert(table->LoadMatrixf); - assert(table->LoadName); - assert(table->LogicOp); - assert(table->Map1d); - assert(table->Map1f); - assert(table->Map2d); - assert(table->Map2f); - assert(table->MapGrid1d); - assert(table->MapGrid1f); - assert(table->MapGrid2d); - assert(table->MapGrid2f); - assert(table->Materialf); - assert(table->Materialfv); - assert(table->Materiali); - assert(table->Materialiv); - assert(table->MatrixMode); - assert(table->MultMatrixd); - assert(table->MultMatrixf); - assert(table->NewList); - assert(table->Normal3b); - assert(table->Normal3bv); - assert(table->Normal3d); - assert(table->Normal3dv); - assert(table->Normal3f); - assert(table->Normal3fv); - assert(table->Normal3i); - assert(table->Normal3iv); - assert(table->Normal3s); - assert(table->Normal3sv); - assert(table->Ortho); - assert(table->PassThrough); - assert(table->PixelMapfv); - assert(table->PixelMapuiv); - assert(table->PixelMapusv); - assert(table->PixelStoref); - assert(table->PixelStorei); - assert(table->PixelTransferf); - assert(table->PixelTransferi); - assert(table->PixelZoom); - assert(table->PointSize); - assert(table->PolygonMode); - assert(table->PolygonOffset); - assert(table->PolygonStipple); - assert(table->PopAttrib); - assert(table->PopMatrix); - assert(table->PopName); - assert(table->PushAttrib); - assert(table->PushMatrix); - assert(table->PushName); - assert(table->RasterPos2d); - assert(table->RasterPos2dv); - assert(table->RasterPos2f); - assert(table->RasterPos2fv); - assert(table->RasterPos2i); - assert(table->RasterPos2iv); - assert(table->RasterPos2s); - assert(table->RasterPos2sv); - assert(table->RasterPos3d); - assert(table->RasterPos3dv); - assert(table->RasterPos3f); - assert(table->RasterPos3fv); - assert(table->RasterPos3i); - assert(table->RasterPos3iv); - assert(table->RasterPos3s); - assert(table->RasterPos3sv); - assert(table->RasterPos4d); - assert(table->RasterPos4dv); - assert(table->RasterPos4f); - assert(table->RasterPos4fv); - assert(table->RasterPos4i); - assert(table->RasterPos4iv); - assert(table->RasterPos4s); - assert(table->RasterPos4sv); - assert(table->ReadBuffer); - assert(table->ReadPixels); - assert(table->Rectd); - assert(table->Rectdv); - assert(table->Rectf); - assert(table->Rectfv); - assert(table->Recti); - assert(table->Rectiv); - assert(table->Rects); - assert(table->Rectsv); - assert(table->RenderMode); - assert(table->Rotated); - assert(table->Rotatef); - assert(table->Scaled); - assert(table->Scalef); - assert(table->Scissor); - assert(table->SelectBuffer); - assert(table->ShadeModel); - assert(table->StencilFunc); - assert(table->StencilMask); - assert(table->StencilOp); - assert(table->TexCoord1d); - assert(table->TexCoord1dv); - assert(table->TexCoord1f); - assert(table->TexCoord1fv); - assert(table->TexCoord1i); - assert(table->TexCoord1iv); - assert(table->TexCoord1s); - assert(table->TexCoord1sv); - assert(table->TexCoord2d); - assert(table->TexCoord2dv); - assert(table->TexCoord2f); - assert(table->TexCoord2fv); - assert(table->TexCoord2i); - assert(table->TexCoord2iv); - assert(table->TexCoord2s); - assert(table->TexCoord2sv); - assert(table->TexCoord3d); - assert(table->TexCoord3dv); - assert(table->TexCoord3f); - assert(table->TexCoord3fv); - assert(table->TexCoord3i); - assert(table->TexCoord3iv); - assert(table->TexCoord3s); - assert(table->TexCoord3sv); - assert(table->TexCoord4d); - assert(table->TexCoord4dv); - assert(table->TexCoord4f); - assert(table->TexCoord4fv); - assert(table->TexCoord4i); - assert(table->TexCoord4iv); - assert(table->TexCoord4s); - assert(table->TexCoord4sv); - assert(table->TexEnvf); - assert(table->TexEnvfv); - assert(table->TexEnvi); - assert(table->TexEnviv); - assert(table->TexGend); - assert(table->TexGendv); - assert(table->TexGenf); - assert(table->TexGenfv); - assert(table->TexGeni); - assert(table->TexGeniv); - assert(table->TexImage1D); - assert(table->TexImage2D); - assert(table->TexParameterf); - assert(table->TexParameterfv); - assert(table->TexParameteri); - assert(table->TexParameteriv); - assert(table->Translated); - assert(table->Translatef); - assert(table->Vertex2d); - assert(table->Vertex2dv); - assert(table->Vertex2f); - assert(table->Vertex2fv); - assert(table->Vertex2i); - assert(table->Vertex2iv); - assert(table->Vertex2s); - assert(table->Vertex2sv); - assert(table->Vertex3d); - assert(table->Vertex3dv); - assert(table->Vertex3f); - assert(table->Vertex3fv); - assert(table->Vertex3i); - assert(table->Vertex3iv); - assert(table->Vertex3s); - assert(table->Vertex3sv); - assert(table->Vertex4d); - assert(table->Vertex4dv); - assert(table->Vertex4f); - assert(table->Vertex4fv); - assert(table->Vertex4i); - assert(table->Vertex4iv); - assert(table->Vertex4s); - assert(table->Vertex4sv); - assert(table->Viewport); - -#ifdef _GLAPI_VERSION_1_1 - assert(table->AreTexturesResident); - assert(table->ArrayElement); - assert(table->BindTexture); - assert(table->ColorPointer); - assert(table->CopyTexImage1D); - assert(table->CopyTexImage2D); - assert(table->CopyTexSubImage1D); - assert(table->CopyTexSubImage2D); - assert(table->DeleteTextures); - assert(table->DisableClientState); - assert(table->DrawArrays); - assert(table->EdgeFlagPointer); - assert(table->EnableClientState); - assert(table->GenTextures); - assert(table->GetPointerv); - assert(table->IndexPointer); - assert(table->Indexub); - assert(table->Indexubv); - assert(table->InterleavedArrays); - assert(table->IsTexture); - assert(table->NormalPointer); - assert(table->PopClientAttrib); - assert(table->PrioritizeTextures); - assert(table->PushClientAttrib); - assert(table->TexCoordPointer); - assert(table->TexSubImage1D); - assert(table->TexSubImage2D); - assert(table->VertexPointer); -#endif - -#ifdef _GLAPI_VERSION_1_2 - assert(table->CopyTexSubImage3D); - assert(table->DrawRangeElements); - assert(table->TexImage3D); - assert(table->TexSubImage3D); -#ifdef _GLAPI_ARB_imaging - assert(table->BlendColor); - assert(table->BlendEquation); - assert(table->ColorSubTable); - assert(table->ColorTable); - assert(table->ColorTableParameterfv); - assert(table->ColorTableParameteriv); - assert(table->ConvolutionFilter1D); - assert(table->ConvolutionFilter2D); - assert(table->ConvolutionParameterf); - assert(table->ConvolutionParameterfv); - assert(table->ConvolutionParameteri); - assert(table->ConvolutionParameteriv); - assert(table->CopyColorSubTable); - assert(table->CopyColorTable); - assert(table->CopyConvolutionFilter1D); - assert(table->CopyConvolutionFilter2D); - assert(table->GetColorTable); - assert(table->GetColorTableParameterfv); - assert(table->GetColorTableParameteriv); - assert(table->GetConvolutionFilter); - assert(table->GetConvolutionParameterfv); - assert(table->GetConvolutionParameteriv); - assert(table->GetHistogram); - assert(table->GetHistogramParameterfv); - assert(table->GetHistogramParameteriv); - assert(table->GetMinmax); - assert(table->GetMinmaxParameterfv); - assert(table->GetMinmaxParameteriv); - assert(table->Histogram); - assert(table->Minmax); - assert(table->ResetHistogram); - assert(table->ResetMinmax); - assert(table->SeparableFilter2D); -#endif -#endif - - -#ifdef _GLAPI_EXT_paletted_texture - assert(table->ColorTableEXT); - assert(table->ColorSubTableEXT); - assert(table->GetColorTableEXT); - assert(table->GetColorTableParameterfvEXT); - assert(table->GetColorTableParameterivEXT); -#endif - -#ifdef _GLAPI_EXT_compiled_vertex_array - assert(table->LockArraysEXT); - assert(table->UnlockArraysEXT); -#endif - -#ifdef _GLAPI_EXT_point_parameter - assert(table->PointParameterfEXT); - assert(table->PointParameterfvEXT); -#endif - -#ifdef _GLAPI_EXT_polygon_offset - assert(table->PolygonOffsetEXT); -#endif - -#ifdef _GLAPI_ARB_multitexture - assert(table->ActiveTextureARB); - assert(table->ClientActiveTextureARB); - assert(table->MultiTexCoord1dARB); - assert(table->MultiTexCoord1dvARB); - assert(table->MultiTexCoord1fARB); - assert(table->MultiTexCoord1fvARB); - assert(table->MultiTexCoord1iARB); - assert(table->MultiTexCoord1ivARB); - assert(table->MultiTexCoord1sARB); - assert(table->MultiTexCoord1svARB); - assert(table->MultiTexCoord2dARB); - assert(table->MultiTexCoord2dvARB); - assert(table->MultiTexCoord2fARB); - assert(table->MultiTexCoord2fvARB); - assert(table->MultiTexCoord2iARB); - assert(table->MultiTexCoord2ivARB); - assert(table->MultiTexCoord2sARB); - assert(table->MultiTexCoord2svARB); - assert(table->MultiTexCoord3dARB); - assert(table->MultiTexCoord3dvARB); - assert(table->MultiTexCoord3fARB); - assert(table->MultiTexCoord3fvARB); - assert(table->MultiTexCoord3iARB); - assert(table->MultiTexCoord3ivARB); - assert(table->MultiTexCoord3sARB); - assert(table->MultiTexCoord3svARB); - assert(table->MultiTexCoord4dARB); - assert(table->MultiTexCoord4dvARB); - assert(table->MultiTexCoord4fARB); - assert(table->MultiTexCoord4fvARB); - assert(table->MultiTexCoord4iARB); - assert(table->MultiTexCoord4ivARB); - assert(table->MultiTexCoord4sARB); - assert(table->MultiTexCoord4svARB); -#endif - -#ifdef _GLAPI_INGR_blend_func_separate - assert(table->BlendFuncSeparateINGR); -#endif - -#ifdef _GLAPI_MESA_window_pos - assert(table->WindowPos4fMESA); -#endif - -#ifdef _GLAPI_MESA_resize_buffers - assert(table->ResizeBuffersMESA); -#endif -} - |