lots of work on extension management
diff --git a/src/mesa/glapi/glapi.c b/src/mesa/glapi/glapi.c
index e8fdef2..2ca689e 100644
--- a/src/mesa/glapi/glapi.c
+++ b/src/mesa/glapi/glapi.c
@@ -1,4 +1,4 @@
-/* $Id: glapi.c,v 1.9 1999/11/25 18:17:04 brianp Exp $ */
+/* $Id: glapi.c,v 1.10 1999/11/27 21:30:40 brianp Exp $ */
/*
* Mesa 3-D graphics library
@@ -110,6 +110,19 @@
}
+
+/*
+ * Return size of dispatch table struct as number of functions (or
+ * slots).
+ */
+GLuint
+_glapi_get_dispatch_table_size(void)
+{
+ return sizeof(struct _glapi_table) / sizeof(void *);
+}
+
+
+
/*
* Get API dispatcher version string.
* XXX this isn't well defined yet.
@@ -122,114 +135,667 @@
/*
- * Return list of hard-coded extension entrypoints in the dispatch table.
- * XXX this isn't well defined yet.
+ * Return list of the hard-coded extension entrypoints in the dispatch table.
*/
-const char *
+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";
+ static const char *extensions[] = {
+#ifdef _GLAPI_EXT_paletted_texture
+ "GL_EXT_paletted_texture",
+#endif
+#ifdef _GLAPI_EXT_compiled_vertex_array
+ "GL_EXT_compiled_vertex_array",
+#endif
+#ifdef _GLAPI_EXT_point_parameters
+ "GL_EXT_point_parameters",
+#endif
+#ifdef _GLAPI_EXT_polygon_offset
+ "GL_EXT_polygon_offset",
+#endif
+#ifdef _GLAPI_EXT_blend_minmax
+ "GL_EXT_blend_minmax",
+#endif
+#ifdef _GLAPI_EXT_blend_color
+ "GL_EXT_blend_color",
+#endif
+#ifdef _GLAPI_ARB_multitexture
+ "GL_ARB_multitexture",
+#endif
+#ifdef _GLAPI_INGR_blend_func_separate
+ "GL_INGR_blend_func_separate",
+#endif
+#ifdef _GLAPI_MESA_window_pos
+ "GL_MESA_window_pos",
+#endif
+#ifdef _GLAPI_MESA_resize_buffers
+ "GL_MESA_resize_buffers",
+#endif
+ NULL
+ };
+
+ return extensions;
}
-/*
- * XXX the following dynamic extension code is just a prototype and
- * not used yet.
- */
-struct _glapi_ext_entrypoint {
+struct name_address_pair {
const char *Name;
- GLuint Offset;
+ GLvoid *Address;
};
-#define MAX_EXT_ENTRYPOINTS 100
+static struct name_address_pair static_functions[] = {
+ { "glAccum", (GLvoid *) glAccum },
+ { "glAlphaFunc", (GLvoid *) glAlphaFunc },
+ { "glBegin", (GLvoid *) glBegin },
+ { "glBitmap", (GLvoid *) glBitmap },
+ { "glAccum", (GLvoid *) glAccum },
+ { "glAlphaFunc", (GLvoid *) glAlphaFunc },
+ { "glBegin", (GLvoid *) glBegin },
+ { "glBitmap", (GLvoid *) glBitmap },
+ { "glBlendFunc", (GLvoid *) glBlendFunc },
+ { "glCallList", (GLvoid *) glCallList },
+ { "glCallLists", (GLvoid *) glCallLists },
+ { "glClear", (GLvoid *) glClear },
+ { "glClearAccum", (GLvoid *) glClearAccum },
+ { "glClearColor", (GLvoid *) glClearColor },
+ { "glClearDepth", (GLvoid *) glClearDepth },
+ { "glClearIndex", (GLvoid *) glClearIndex },
+ { "glClearStencil", (GLvoid *) glClearStencil },
+ { "glClipPlane", (GLvoid *) glClipPlane },
+ { "glColor3b", (GLvoid *) glColor3b },
+ { "glColor3bv", (GLvoid *) glColor3bv },
+ { "glColor3d", (GLvoid *) glColor3d },
+ { "glColor3dv", (GLvoid *) glColor3dv },
+ { "glColor3f", (GLvoid *) glColor3f },
+ { "glColor3fv", (GLvoid *) glColor3fv },
+ { "glColor3i", (GLvoid *) glColor3i },
+ { "glColor3iv", (GLvoid *) glColor3iv },
+ { "glColor3s", (GLvoid *) glColor3s },
+ { "glColor3sv", (GLvoid *) glColor3sv },
+ { "glColor3ub", (GLvoid *) glColor3ub },
+ { "glColor3ubv", (GLvoid *) glColor3ubv },
+ { "glColor3ui", (GLvoid *) glColor3ui },
+ { "glColor3uiv", (GLvoid *) glColor3uiv },
+ { "glColor3us", (GLvoid *) glColor3us },
+ { "glColor3usv", (GLvoid *) glColor3usv },
+ { "glColor4b", (GLvoid *) glColor4b },
+ { "glColor4bv", (GLvoid *) glColor4bv },
+ { "glColor4d", (GLvoid *) glColor4d },
+ { "glColor4dv", (GLvoid *) glColor4dv },
+ { "glColor4f", (GLvoid *) glColor4f },
+ { "glColor4fv", (GLvoid *) glColor4fv },
+ { "glColor4i", (GLvoid *) glColor4i },
+ { "glColor4iv", (GLvoid *) glColor4iv },
+ { "glColor4s", (GLvoid *) glColor4s },
+ { "glColor4sv", (GLvoid *) glColor4sv },
+ { "glColor4ub", (GLvoid *) glColor4ub },
+ { "glColor4ubv", (GLvoid *) glColor4ubv },
+ { "glColor4ui", (GLvoid *) glColor4ui },
+ { "glColor4uiv", (GLvoid *) glColor4uiv },
+ { "glColor4us", (GLvoid *) glColor4us },
+ { "glColor4usv", (GLvoid *) glColor4usv },
+ { "glColorMask", (GLvoid *) glColorMask },
+ { "glColorMaterial", (GLvoid *) glColorMaterial },
+ { "glCopyPixels", (GLvoid *) glCopyPixels },
+ { "glCullFace", (GLvoid *) glCullFace },
+ { "glDeleteLists", (GLvoid *) glDeleteLists },
+ { "glDepthFunc", (GLvoid *) glDepthFunc },
+ { "glDepthMask", (GLvoid *) glDepthMask },
+ { "glDepthRange", (GLvoid *) glDepthRange },
+ { "glDisable", (GLvoid *) glDisable },
+ { "glDrawBuffer", (GLvoid *) glDrawBuffer },
+ { "glDrawPixels", (GLvoid *) glDrawPixels },
+ { "glEdgeFlag", (GLvoid *) glEdgeFlag },
+ { "glEdgeFlagv", (GLvoid *) glEdgeFlagv },
+ { "glEnable", (GLvoid *) glEnable },
+ { "glEnd", (GLvoid *) glEnd },
+ { "glEndList", (GLvoid *) glEndList },
+ { "glEvalCoord1d", (GLvoid *) glEvalCoord1d },
+ { "glEvalCoord1dv", (GLvoid *) glEvalCoord1dv },
+ { "glEvalCoord1f", (GLvoid *) glEvalCoord1f },
+ { "glEvalCoord1fv", (GLvoid *) glEvalCoord1fv },
+ { "glEvalCoord2d", (GLvoid *) glEvalCoord2d },
+ { "glEvalCoord2dv", (GLvoid *) glEvalCoord2dv },
+ { "glEvalCoord2f", (GLvoid *) glEvalCoord2f },
+ { "glEvalCoord2fv", (GLvoid *) glEvalCoord2fv },
+ { "glEvalMesh1", (GLvoid *) glEvalMesh1 },
+ { "glEvalMesh2", (GLvoid *) glEvalMesh2 },
+ { "glEvalPoint1", (GLvoid *) glEvalPoint1 },
+ { "glEvalPoint2", (GLvoid *) glEvalPoint2 },
+ { "glFeedbackBuffer", (GLvoid *) glFeedbackBuffer },
+ { "glFinish", (GLvoid *) glFinish },
+ { "glFlush", (GLvoid *) glFlush },
+ { "glFogf", (GLvoid *) glFogf },
+ { "glFogfv", (GLvoid *) glFogfv },
+ { "glFogi", (GLvoid *) glFogi },
+ { "glFogiv", (GLvoid *) glFogiv },
+ { "glFrontFace", (GLvoid *) glFrontFace },
+ { "glFrustum", (GLvoid *) glFrustum },
+ { "glGenLists", (GLvoid *) glGenLists },
+ { "glGetBooleanv", (GLvoid *) glGetBooleanv },
+ { "glGetClipPlane", (GLvoid *) glGetClipPlane },
+ { "glGetDoublev", (GLvoid *) glGetDoublev },
+ { "glGetError", (GLvoid *) glGetError },
+ { "glGetFloatv", (GLvoid *) glGetFloatv },
+ { "glGetIntegerv", (GLvoid *) glGetIntegerv },
+ { "glGetLightfv", (GLvoid *) glGetLightfv },
+ { "glGetLightiv", (GLvoid *) glGetLightiv },
+ { "glGetMapdv", (GLvoid *) glGetMapdv },
+ { "glGetMapfv", (GLvoid *) glGetMapfv },
+ { "glGetMapiv", (GLvoid *) glGetMapiv },
+ { "glGetMaterialfv", (GLvoid *) glGetMaterialfv },
+ { "glGetMaterialiv", (GLvoid *) glGetMaterialiv },
+ { "glGetPixelMapfv", (GLvoid *) glGetPixelMapfv },
+ { "glGetPixelMapuiv", (GLvoid *) glGetPixelMapuiv },
+ { "glGetPixelMapusv", (GLvoid *) glGetPixelMapusv },
+ { "glGetPolygonStipple", (GLvoid *) glGetPolygonStipple },
+ { "glGetString", (GLvoid *) glGetString },
+ { "glGetTexEnvfv", (GLvoid *) glGetTexEnvfv },
+ { "glGetTexEnviv", (GLvoid *) glGetTexEnviv },
+ { "glGetTexGendv", (GLvoid *) glGetTexGendv },
+ { "glGetTexGenfv", (GLvoid *) glGetTexGenfv },
+ { "glGetTexGeniv", (GLvoid *) glGetTexGeniv },
+ { "glGetTexImage", (GLvoid *) glGetTexImage },
+ { "glGetTexLevelParameterfv", (GLvoid *) glGetTexLevelParameterfv },
+ { "glGetTexLevelParameteriv", (GLvoid *) glGetTexLevelParameteriv },
+ { "glGetTexParameterfv", (GLvoid *) glGetTexParameterfv },
+ { "glGetTexParameteriv", (GLvoid *) glGetTexParameteriv },
+ { "glHint", (GLvoid *) glHint },
+ { "glIndexMask", (GLvoid *) glIndexMask },
+ { "glIndexd", (GLvoid *) glIndexd },
+ { "glIndexdv", (GLvoid *) glIndexdv },
+ { "glIndexf", (GLvoid *) glIndexf },
+ { "glIndexfv", (GLvoid *) glIndexfv },
+ { "glIndexi", (GLvoid *) glIndexi },
+ { "glIndexiv", (GLvoid *) glIndexiv },
+ { "glIndexs", (GLvoid *) glIndexs },
+ { "glIndexsv", (GLvoid *) glIndexsv },
+ { "glInitNames", (GLvoid *) glInitNames },
+ { "glIsEnabled", (GLvoid *) glIsEnabled },
+ { "glIsList", (GLvoid *) glIsList },
+ { "glLightModelf", (GLvoid *) glLightModelf },
+ { "glLightModelfv", (GLvoid *) glLightModelfv },
+ { "glLightModeli", (GLvoid *) glLightModeli },
+ { "glLightModeliv", (GLvoid *) glLightModeliv },
+ { "glLightf", (GLvoid *) glLightf },
+ { "glLightfv", (GLvoid *) glLightfv },
+ { "glLighti", (GLvoid *) glLighti },
+ { "glLightiv", (GLvoid *) glLightiv },
+ { "glLineStipple", (GLvoid *) glLineStipple },
+ { "glLineWidth", (GLvoid *) glLineWidth },
+ { "glListBase", (GLvoid *) glListBase },
+ { "glLoadIdentity", (GLvoid *) glLoadIdentity },
+ { "glLoadMatrixd", (GLvoid *) glLoadMatrixd },
+ { "glLoadMatrixf", (GLvoid *) glLoadMatrixf },
+ { "glLoadName", (GLvoid *) glLoadName },
+ { "glLogicOp", (GLvoid *) glLogicOp },
+ { "glMap1d", (GLvoid *) glMap1d },
+ { "glMap1f", (GLvoid *) glMap1f },
+ { "glMap2d", (GLvoid *) glMap2d },
+ { "glMap2f", (GLvoid *) glMap2f },
+ { "glMapGrid1d", (GLvoid *) glMapGrid1d },
+ { "glMapGrid1f", (GLvoid *) glMapGrid1f },
+ { "glMapGrid2d", (GLvoid *) glMapGrid2d },
+ { "glMapGrid2f", (GLvoid *) glMapGrid2f },
+ { "glMaterialf", (GLvoid *) glMaterialf },
+ { "glMaterialfv", (GLvoid *) glMaterialfv },
+ { "glMateriali", (GLvoid *) glMateriali },
+ { "glMaterialiv", (GLvoid *) glMaterialiv },
+ { "glMatrixMode", (GLvoid *) glMatrixMode },
+ { "glMultMatrixd", (GLvoid *) glMultMatrixd },
+ { "glMultMatrixf", (GLvoid *) glMultMatrixf },
+ { "glNewList", (GLvoid *) glNewList },
+ { "glNormal3b", (GLvoid *) glNormal3b },
+ { "glNormal3bv", (GLvoid *) glNormal3bv },
+ { "glNormal3d", (GLvoid *) glNormal3d },
+ { "glNormal3dv", (GLvoid *) glNormal3dv },
+ { "glNormal3f", (GLvoid *) glNormal3f },
+ { "glNormal3fv", (GLvoid *) glNormal3fv },
+ { "glNormal3i", (GLvoid *) glNormal3i },
+ { "glNormal3iv", (GLvoid *) glNormal3iv },
+ { "glNormal3s", (GLvoid *) glNormal3s },
+ { "glNormal3sv", (GLvoid *) glNormal3sv },
+ { "glOrtho", (GLvoid *) glOrtho },
+ { "glPassThrough", (GLvoid *) glPassThrough },
+ { "glPixelMapfv", (GLvoid *) glPixelMapfv },
+ { "glPixelMapuiv", (GLvoid *) glPixelMapuiv },
+ { "glPixelMapusv", (GLvoid *) glPixelMapusv },
+ { "glPixelStoref", (GLvoid *) glPixelStoref },
+ { "glPixelStorei", (GLvoid *) glPixelStorei },
+ { "glPixelTransferf", (GLvoid *) glPixelTransferf },
+ { "glPixelTransferi", (GLvoid *) glPixelTransferi },
+ { "glPixelZoom", (GLvoid *) glPixelZoom },
+ { "glPointSize", (GLvoid *) glPointSize },
+ { "glPolygonMode", (GLvoid *) glPolygonMode },
+ { "glPolygonOffset", (GLvoid *) glPolygonOffset },
+ { "glPolygonStipple", (GLvoid *) glPolygonStipple },
+ { "glPopAttrib", (GLvoid *) glPopAttrib },
+ { "glPopMatrix", (GLvoid *) glPopMatrix },
+ { "glPopName", (GLvoid *) glPopName },
+ { "glPushAttrib", (GLvoid *) glPushAttrib },
+ { "glPushMatrix", (GLvoid *) glPushMatrix },
+ { "glPushName", (GLvoid *) glPushName },
+ { "glRasterPos2d", (GLvoid *) glRasterPos2d },
+ { "glRasterPos2dv", (GLvoid *) glRasterPos2dv },
+ { "glRasterPos2f", (GLvoid *) glRasterPos2f },
+ { "glRasterPos2fv", (GLvoid *) glRasterPos2fv },
+ { "glRasterPos2i", (GLvoid *) glRasterPos2i },
+ { "glRasterPos2iv", (GLvoid *) glRasterPos2iv },
+ { "glRasterPos2s", (GLvoid *) glRasterPos2s },
+ { "glRasterPos2sv", (GLvoid *) glRasterPos2sv },
+ { "glRasterPos3d", (GLvoid *) glRasterPos3d },
+ { "glRasterPos3dv", (GLvoid *) glRasterPos3dv },
+ { "glRasterPos3f", (GLvoid *) glRasterPos3f },
+ { "glRasterPos3fv", (GLvoid *) glRasterPos3fv },
+ { "glRasterPos3i", (GLvoid *) glRasterPos3i },
+ { "glRasterPos3iv", (GLvoid *) glRasterPos3iv },
+ { "glRasterPos3s", (GLvoid *) glRasterPos3s },
+ { "glRasterPos3sv", (GLvoid *) glRasterPos3sv },
+ { "glRasterPos4d", (GLvoid *) glRasterPos4d },
+ { "glRasterPos4dv", (GLvoid *) glRasterPos4dv },
+ { "glRasterPos4f", (GLvoid *) glRasterPos4f },
+ { "glRasterPos4fv", (GLvoid *) glRasterPos4fv },
+ { "glRasterPos4i", (GLvoid *) glRasterPos4i },
+ { "glRasterPos4iv", (GLvoid *) glRasterPos4iv },
+ { "glRasterPos4s", (GLvoid *) glRasterPos4s },
+ { "glRasterPos4sv", (GLvoid *) glRasterPos4sv },
+ { "glReadBuffer", (GLvoid *) glReadBuffer },
+ { "glReadPixels", (GLvoid *) glReadPixels },
+ { "glRectd", (GLvoid *) glRectd },
+ { "glRectdv", (GLvoid *) glRectdv },
+ { "glRectf", (GLvoid *) glRectf },
+ { "glRectfv", (GLvoid *) glRectfv },
+ { "glRecti", (GLvoid *) glRecti },
+ { "glRectiv", (GLvoid *) glRectiv },
+ { "glRects", (GLvoid *) glRects },
+ { "glRectsv", (GLvoid *) glRectsv },
+ { "glRenderMode", (GLvoid *) glRenderMode },
+ { "glRotated", (GLvoid *) glRotated },
+ { "glRotatef", (GLvoid *) glRotatef },
+ { "glScaled", (GLvoid *) glScaled },
+ { "glScalef", (GLvoid *) glScalef },
+ { "glScissor", (GLvoid *) glScissor },
+ { "glSelectBuffer", (GLvoid *) glSelectBuffer },
+ { "glShadeModel", (GLvoid *) glShadeModel },
+ { "glStencilFunc", (GLvoid *) glStencilFunc },
+ { "glStencilMask", (GLvoid *) glStencilMask },
+ { "glStencilOp", (GLvoid *) glStencilOp },
+ { "glTexCoord1d", (GLvoid *) glTexCoord1d },
+ { "glTexCoord1dv", (GLvoid *) glTexCoord1dv },
+ { "glTexCoord1f", (GLvoid *) glTexCoord1f },
+ { "glTexCoord1fv", (GLvoid *) glTexCoord1fv },
+ { "glTexCoord1i", (GLvoid *) glTexCoord1i },
+ { "glTexCoord1iv", (GLvoid *) glTexCoord1iv },
+ { "glTexCoord1s", (GLvoid *) glTexCoord1s },
+ { "glTexCoord1sv", (GLvoid *) glTexCoord1sv },
+ { "glTexCoord2d", (GLvoid *) glTexCoord2d },
+ { "glTexCoord2dv", (GLvoid *) glTexCoord2dv },
+ { "glTexCoord2f", (GLvoid *) glTexCoord2f },
+ { "glTexCoord2fv", (GLvoid *) glTexCoord2fv },
+ { "glTexCoord2i", (GLvoid *) glTexCoord2i },
+ { "glTexCoord2iv", (GLvoid *) glTexCoord2iv },
+ { "glTexCoord2s", (GLvoid *) glTexCoord2s },
+ { "glTexCoord2sv", (GLvoid *) glTexCoord2sv },
+ { "glTexCoord3d", (GLvoid *) glTexCoord3d },
+ { "glTexCoord3dv", (GLvoid *) glTexCoord3dv },
+ { "glTexCoord3f", (GLvoid *) glTexCoord3f },
+ { "glTexCoord3fv", (GLvoid *) glTexCoord3fv },
+ { "glTexCoord3i", (GLvoid *) glTexCoord3i },
+ { "glTexCoord3iv", (GLvoid *) glTexCoord3iv },
+ { "glTexCoord3s", (GLvoid *) glTexCoord3s },
+ { "glTexCoord3sv", (GLvoid *) glTexCoord3sv },
+ { "glTexCoord4d", (GLvoid *) glTexCoord4d },
+ { "glTexCoord4dv", (GLvoid *) glTexCoord4dv },
+ { "glTexCoord4f", (GLvoid *) glTexCoord4f },
+ { "glTexCoord4fv", (GLvoid *) glTexCoord4fv },
+ { "glTexCoord4i", (GLvoid *) glTexCoord4i },
+ { "glTexCoord4iv", (GLvoid *) glTexCoord4iv },
+ { "glTexCoord4s", (GLvoid *) glTexCoord4s },
+ { "glTexCoord4sv", (GLvoid *) glTexCoord4sv },
+ { "glTexEnvf", (GLvoid *) glTexEnvf },
+ { "glTexEnvfv", (GLvoid *) glTexEnvfv },
+ { "glTexEnvi", (GLvoid *) glTexEnvi },
+ { "glTexEnviv", (GLvoid *) glTexEnviv },
+ { "glTexGend", (GLvoid *) glTexGend },
+ { "glTexGendv", (GLvoid *) glTexGendv },
+ { "glTexGenf", (GLvoid *) glTexGenf },
+ { "glTexGenfv", (GLvoid *) glTexGenfv },
+ { "glTexGeni", (GLvoid *) glTexGeni },
+ { "glTexGeniv", (GLvoid *) glTexGeniv },
+ { "glTexImage1D", (GLvoid *) glTexImage1D },
+ { "glTexImage2D", (GLvoid *) glTexImage2D },
+ { "glTexParameterf", (GLvoid *) glTexParameterf },
+ { "glTexParameterfv", (GLvoid *) glTexParameterfv },
+ { "glTexParameteri", (GLvoid *) glTexParameteri },
+ { "glTexParameteriv", (GLvoid *) glTexParameteriv },
+ { "glTranslated", (GLvoid *) glTranslated },
+ { "glTranslatef", (GLvoid *) glTranslatef },
+ { "glVertex2d", (GLvoid *) glVertex2d },
+ { "glVertex2dv", (GLvoid *) glVertex2dv },
+ { "glVertex2f", (GLvoid *) glVertex2f },
+ { "glVertex2fv", (GLvoid *) glVertex2fv },
+ { "glVertex2i", (GLvoid *) glVertex2i },
+ { "glVertex2iv", (GLvoid *) glVertex2iv },
+ { "glVertex2s", (GLvoid *) glVertex2s },
+ { "glVertex2sv", (GLvoid *) glVertex2sv },
+ { "glVertex3d", (GLvoid *) glVertex3d },
+ { "glVertex3dv", (GLvoid *) glVertex3dv },
+ { "glVertex3f", (GLvoid *) glVertex3f },
+ { "glVertex3fv", (GLvoid *) glVertex3fv },
+ { "glVertex3i", (GLvoid *) glVertex3i },
+ { "glVertex3iv", (GLvoid *) glVertex3iv },
+ { "glVertex3s", (GLvoid *) glVertex3s },
+ { "glVertex3sv", (GLvoid *) glVertex3sv },
+ { "glVertex4d", (GLvoid *) glVertex4d },
+ { "glVertex4dv", (GLvoid *) glVertex4dv },
+ { "glVertex4f", (GLvoid *) glVertex4f },
+ { "glVertex4fv", (GLvoid *) glVertex4fv },
+ { "glVertex4i", (GLvoid *) glVertex4i },
+ { "glVertex4iv", (GLvoid *) glVertex4iv },
+ { "glVertex4s", (GLvoid *) glVertex4s },
+ { "glVertex4sv", (GLvoid *) glVertex4sv },
+ { "glViewport", (GLvoid *) glViewport },
-static struct _glapi_ext_entrypoint ExtEntryTable[MAX_EXT_ENTRYPOINTS];
-static GLuint NumExtEntryPoints;
+#ifdef _GLAPI_VERSION_1_1
+ { "glAreTexturesResident", (GLvoid *) glAreTexturesResident },
+ { "glArrayElement", (GLvoid *) glArrayElement },
+ { "glBindTexture", (GLvoid *) glBindTexture },
+ { "glColorPointer", (GLvoid *) glColorPointer },
+ { "glCopyTexImage1D", (GLvoid *) glCopyTexImage1D },
+ { "glCopyTexImage2D", (GLvoid *) glCopyTexImage2D },
+ { "glCopyTexSubImage1D", (GLvoid *) glCopyTexSubImage1D },
+ { "glCopyTexSubImage2D", (GLvoid *) glCopyTexSubImage2D },
+ { "glDeleteTextures", (GLvoid *) glDeleteTextures },
+ { "glDisableClientState", (GLvoid *) glDisableClientState },
+ { "glDrawArrays", (GLvoid *) glDrawArrays },
+ { "glDrawElements", (GLvoid *) glDrawElements },
+ { "glEdgeFlagPointer", (GLvoid *) glEdgeFlagPointer },
+ { "glEnableClientState", (GLvoid *) glEnableClientState },
+ { "glGenTextures", (GLvoid *) glGenTextures },
+ { "glGetPointerv", (GLvoid *) glGetPointerv },
+ { "glIndexPointer", (GLvoid *) glIndexPointer },
+ { "glIndexub", (GLvoid *) glIndexub },
+ { "glIndexubv", (GLvoid *) glIndexubv },
+ { "glInterleavedArrays", (GLvoid *) glInterleavedArrays },
+ { "glIsTexture", (GLvoid *) glIsTexture },
+ { "glNormalPointer", (GLvoid *) glNormalPointer },
+ { "glPopClientAttrib", (GLvoid *) glPopClientAttrib },
+ { "glPrioritizeTextures", (GLvoid *) glPrioritizeTextures },
+ { "glPushClientAttrib", (GLvoid *) glPushClientAttrib },
+ { "glTexCoordPointer", (GLvoid *) glTexCoordPointer },
+ { "glTexSubImage1D", (GLvoid *) glTexSubImage1D },
+ { "glTexSubImage2D", (GLvoid *) glTexSubImage2D },
+ { "glVertexPointer", (GLvoid *) glVertexPointer },
+#endif
+
+#ifdef _GLAPI_VERSION_1_2
+ { "glCopyTexSubImage3D", (GLvoid *) glCopyTexSubImage3D },
+ { "glDrawRangeElements", (GLvoid *) glDrawRangeElements },
+ { "glTexImage3D", (GLvoid *) glTexImage3D },
+ { "glTexSubImage3D", (GLvoid *) glTexSubImage3D },
+
+#ifdef _GLAPI_ARB_imaging
+ { "glBlendColor", (GLvoid *) glBlendColor },
+ { "glBlendEquation", (GLvoid *) glBlendEquation },
+ { "glColorSubTable", (GLvoid *) glColorSubTable },
+ { "glColorTable", (GLvoid *) glColorTable },
+ { "glColorTableParameterfv", (GLvoid *) glColorTableParameterfv },
+ { "glColorTableParameteriv", (GLvoid *) glColorTableParameteriv },
+ { "glConvolutionFilter1D", (GLvoid *) glConvolutionFilter1D },
+ { "glConvolutionFilter2D", (GLvoid *) glConvolutionFilter2D },
+ { "glConvolutionParameterf", (GLvoid *) glConvolutionParameterf },
+ { "glConvolutionParameterfv", (GLvoid *) glConvolutionParameterfv },
+ { "glConvolutionParameteri", (GLvoid *) glConvolutionParameteri },
+ { "glConvolutionParameteriv", (GLvoid *) glConvolutionParameteriv },
+ { "glCopyColorSubTable", (GLvoid *) glCopyColorSubTable },
+ { "glCopyColorTable", (GLvoid *) glCopyColorTable },
+ { "glCopyConvolutionFilter1D", (GLvoid *) glCopyConvolutionFilter1D },
+ { "glCopyConvolutionFilter2D", (GLvoid *) glCopyConvolutionFilter2D },
+ { "glGetColorTable", (GLvoid *) glGetColorTable },
+ { "glGetColorTableParameterfv", (GLvoid *) glGetColorTableParameterfv },
+ { "glGetColorTableParameteriv", (GLvoid *) glGetColorTableParameteriv },
+ { "glGetConvolutionFilter", (GLvoid *) glGetConvolutionFilter },
+ { "glGetConvolutionParameterfv", (GLvoid *) glGetConvolutionParameterfv },
+ { "glGetConvolutionParameteriv", (GLvoid *) glGetConvolutionParameteriv },
+ { "glGetHistogram", (GLvoid *) glGetHistogram },
+ { "glGetHistogramParameterfv", (GLvoid *) glGetHistogramParameterfv },
+ { "glGetHistogramParameteriv", (GLvoid *) glGetHistogramParameteriv },
+ { "glGetMinmax", (GLvoid *) glGetMinmax },
+ { "glGetMinmaxParameterfv", (GLvoid *) glGetMinmaxParameterfv },
+ { "glGetMinmaxParameteriv", (GLvoid *) glGetMinmaxParameteriv },
+ { "glGetSeparableFilter", (GLvoid *) glGetSeparableFilter },
+ { "glHistogram", (GLvoid *) glHistogram },
+ { "glMinmax", (GLvoid *) glMinmax },
+ { "glResetHistogram", (GLvoid *) glResetHistogram },
+ { "glResetMinmax", (GLvoid *) glResetMinmax },
+ { "glSeparableFilter2D", (GLvoid *) glSeparableFilter2D },
+#endif
+#endif
+
+#ifdef _GLAPI_EXT_paletted_texture
+ { "glColorTableEXT", (GLvoid *) glColorTableEXT },
+ { "glColorSubTableEXT", (GLvoid *) glColorSubTableEXT },
+ { "glGetColorTableEXT", (GLvoid *) glGetColorTableEXT },
+ { "glGetColorTableParameterfvEXT", (GLvoid *) glGetColorTableParameterfvEXT },
+ { "glGetColorTableParameterivEXT", (GLvoid *) glGetColorTableParameterivEXT },
+#endif
+
+#ifdef _GLAPI_EXT_compiled_vertex_array
+ { "glLockArraysEXT", (GLvoid *) glLockArraysEXT },
+ { "glUnlockArraysEXT", (GLvoid *) glUnlockArraysEXT },
+#endif
+
+#ifdef _GLAPI_EXT_point_parameters
+ { "glPointParameterfEXT", (GLvoid *) glPointParameterfEXT },
+ { "glPointParameterfvEXT", (GLvoid *) glPointParameterfvEXT },
+#endif
+
+#ifdef _GLAPI_EXT_polygon_offset
+ { "glPolygonOffsetEXT", (GLvoid *) glPolygonOffsetEXT },
+#endif
+
+#ifdef _GLAPI_EXT_blend_minmax
+ { "glBlendEquationEXT", (GLvoid *) glBlendEquationEXT },
+#endif
+
+#ifdef _GLAPI_EXT_blend_color
+ { "glBlendColorEXT", (GLvoid *) glBlendColorEXT },
+#endif
+
+#ifdef _GLAPI_ARB_multitexture
+ { "glActiveTextureARB", (GLvoid *) glActiveTextureARB },
+ { "glClientActiveTextureARB", (GLvoid *) glClientActiveTextureARB },
+ { "glMultiTexCoord1dARB", (GLvoid *) glMultiTexCoord1dARB },
+ { "glMultiTexCoord1dvARB", (GLvoid *) glMultiTexCoord1dvARB },
+ { "glMultiTexCoord1fARB", (GLvoid *) glMultiTexCoord1fARB },
+ { "glMultiTexCoord1fvARB", (GLvoid *) glMultiTexCoord1fvARB },
+ { "glMultiTexCoord1iARB", (GLvoid *) glMultiTexCoord1iARB },
+ { "glMultiTexCoord1ivARB", (GLvoid *) glMultiTexCoord1ivARB },
+ { "glMultiTexCoord1sARB", (GLvoid *) glMultiTexCoord1sARB },
+ { "glMultiTexCoord1svARB", (GLvoid *) glMultiTexCoord1svARB },
+ { "glMultiTexCoord2dARB", (GLvoid *) glMultiTexCoord2dARB },
+ { "glMultiTexCoord2dvARB", (GLvoid *) glMultiTexCoord2dvARB },
+ { "glMultiTexCoord2fARB", (GLvoid *) glMultiTexCoord2fARB },
+ { "glMultiTexCoord2fvARB", (GLvoid *) glMultiTexCoord2fvARB },
+ { "glMultiTexCoord2iARB", (GLvoid *) glMultiTexCoord2iARB },
+ { "glMultiTexCoord2ivARB", (GLvoid *) glMultiTexCoord2ivARB },
+ { "glMultiTexCoord2sARB", (GLvoid *) glMultiTexCoord2sARB },
+ { "glMultiTexCoord2svARB", (GLvoid *) glMultiTexCoord2svARB },
+ { "glMultiTexCoord3dARB", (GLvoid *) glMultiTexCoord3dARB },
+ { "glMultiTexCoord3dvARB", (GLvoid *) glMultiTexCoord3dvARB },
+ { "glMultiTexCoord3fARB", (GLvoid *) glMultiTexCoord3fARB },
+ { "glMultiTexCoord3fvARB", (GLvoid *) glMultiTexCoord3fvARB },
+ { "glMultiTexCoord3iARB", (GLvoid *) glMultiTexCoord3iARB },
+ { "glMultiTexCoord3ivARB", (GLvoid *) glMultiTexCoord3ivARB },
+ { "glMultiTexCoord3sARB", (GLvoid *) glMultiTexCoord3sARB },
+ { "glMultiTexCoord3svARB", (GLvoid *) glMultiTexCoord3svARB },
+ { "glMultiTexCoord4dARB", (GLvoid *) glMultiTexCoord4dARB },
+ { "glMultiTexCoord4dvARB", (GLvoid *) glMultiTexCoord4dvARB },
+ { "glMultiTexCoord4fARB", (GLvoid *) glMultiTexCoord4fARB },
+ { "glMultiTexCoord4fvARB", (GLvoid *) glMultiTexCoord4fvARB },
+ { "glMultiTexCoord4iARB", (GLvoid *) glMultiTexCoord4iARB },
+ { "glMultiTexCoord4ivARB", (GLvoid *) glMultiTexCoord4ivARB },
+ { "glMultiTexCoord4sARB", (GLvoid *) glMultiTexCoord4sARB },
+ { "glMultiTexCoord4svARB", (GLvoid *) glMultiTexCoord4svARB },
+#endif
+
+#ifdef _GLAPI_INGR_blend_func_separate
+ { "glBlendFuncSeparateINGR", (GLvoid *) glBlendFuncSeparateINGR },
+#endif
+
+#ifdef _GLAPI_MESA_window_pos
+ { "glWindowPos4fMESA", (GLvoid *) glWindowPos4fMESA },
+#endif
+
+#ifdef _GLAPI_MESA_resize_buffers
+ { "glResizeBuffersMESA", (GLvoid *) glResizeBuffersMESA },
+#endif
+
+ { NULL, NULL } /* end of list marker */
+};
/*
- * Dynamically allocate an extension entry point.
- * Return a slot number or -1 if table is full.
+ * Return dispatch table offset of the named static (built-in) function.
+ * Return -1 if function not found.
*/
-GLint
-_glapi_alloc_entrypoint(const char *funcName)
+static GLint
+get_static_proc_offset(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;
+ for (i = 0; static_functions[i].Name; i++) {
+ if (strcmp(static_functions[i].Name, funcName) == 0) {
+ return i;
}
}
- 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.
+ * Return dispatch function address the named static (built-in) function.
+ * Return NULL if function 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;
- }
- }
+ GLuint i = get_static_proc_offset(funcName);
+ if (i >= 0)
+ return static_functions[i].Address;
+ else
+ return NULL;
+}
+
+
+
+/**********************************************************************
+ * Extension function management.
+ **********************************************************************/
+
+
+struct _glapi_ext_entrypoint {
+ const char *Name; /* the extension function's name */
+ GLuint Offset; /* relative to start of dispatch table */
+ GLvoid *Address; /* address of dispatch function */
+};
+
+static struct _glapi_ext_entrypoint ExtEntryTable[_GLAPI_EXTRA_SLOTS];
+static GLuint NumExtEntryPoints = 0;
+
+
+
+/*
+ * Generate a dispatch function (entrypoint) which jumps through
+ * the given slot number (offset) in the current dispatch table.
+ */
+static void *
+generate_entrypoint(GLuint offset)
+{
+ /* XXX need to generate some assembly code here */
+
return NULL;
}
+
+/*
+ * Add a new extension function entrypoint.
+ * Return: GL_TRUE = success or GL_FALSE = failure
+ */
+GLboolean
+_glapi_add_entrypoint(const char *funcName, GLuint offset)
+{
+ /* first check if the named function is already statically present */
+ GLint index = get_static_proc_offset(funcName);
+ if (index >= 0) {
+ assert(index == offset);
+ return GL_TRUE;
+ }
+ else if (offset < _glapi_get_dispatch_table_size()) {
+ /* be sure index and name match known data */
+ GLuint i;
+ for (i = 0; i < NumExtEntryPoints; i++) {
+ if (strcmp(ExtEntryTable[i].Name, funcName) == 0) {
+ /* function already registered with api */
+ if (ExtEntryTable[i].Offset == offset) {
+ return GL_TRUE; /* offsets match */
+ }
+ else {
+ return GL_FALSE; /* bad offset! */
+ }
+ }
+ }
+ assert(NumExtEntryPoints < _GLAPI_EXTRA_SLOTS);
+ ExtEntryTable[NumExtEntryPoints].Name = strdup(funcName);
+ ExtEntryTable[NumExtEntryPoints].Offset = offset;
+ ExtEntryTable[NumExtEntryPoints].Address = generate_entrypoint(offset);
+ NumExtEntryPoints++;
+ return GL_TRUE;
+ }
+ else {
+ return GL_FALSE;
+ }
+}
+
+
+
+/*
+ * Return offset of entrypoint for named function within dispatch table.
+ */
+GLint
+_glapi_get_proc_offset(const char *funcName)
+{
+ /* search extension functions first */
+ GLint i;
+ for (i = 0; i < NumExtEntryPoints; i++) {
+ if (strcmp(ExtEntryTable[i].Name, funcName) == 0) {
+ return ExtEntryTable[i].Offset;
+ }
+ }
+
+ /* search static functions */
+ return get_static_proc_offset(funcName);
+}
+
+
+
/*
* Return entrypoint for named function.
*/
const GLvoid *
_glapi_get_proc_address(const char *funcName)
{
- /* look for dynamic extension entry point */
+ /* search extension functions first */
+ GLint i;
+ for (i = 0; i < NumExtEntryPoints; i++) {
+ if (strcmp(ExtEntryTable[i].Name, funcName) == 0) {
+ return ExtEntryTable[i].Address;
+ }
+ }
- /* look for static entry point */
+ /* search static functions */
return get_static_proc_address(funcName);
}
@@ -713,481 +1279,3 @@
#include "glapitemp.h"
-
-
-#ifdef DEBUG
-/*
- * This struct is just used to be sure we've defined all the API functions.
- */
-static struct _glapi_table completeness_test = {
- glAccum,
- glAlphaFunc,
- glBegin,
- glBitmap,
- glBlendFunc,
- glCallList,
- glCallLists,
- glClear,
- glClearAccum,
- glClearColor,
- glClearDepth,
- glClearIndex,
- glClearStencil,
- glClipPlane,
- glColor3b,
- glColor3bv,
- glColor3d,
- glColor3dv,
- glColor3f,
- glColor3fv,
- glColor3i,
- glColor3iv,
- glColor3s,
- glColor3sv,
- glColor3ub,
- glColor3ubv,
- glColor3ui,
- glColor3uiv,
- glColor3us,
- glColor3usv,
- glColor4b,
- glColor4bv,
- glColor4d,
- glColor4dv,
- glColor4f,
- glColor4fv,
- glColor4i,
- glColor4iv,
- glColor4s,
- glColor4sv,
- glColor4ub,
- glColor4ubv,
- glColor4ui,
- glColor4uiv,
- glColor4us,
- glColor4usv,
- glColorMask,
- glColorMaterial,
- glCopyPixels,
- glCullFace,
- glDeleteLists,
- glDepthFunc,
- glDepthMask,
- glDepthRange,
- glDisable,
- glDrawBuffer,
- glDrawPixels,
- glEdgeFlag,
- glEdgeFlagv,
- glEnable,
- glEnd,
- glEndList,
- glEvalCoord1d,
- glEvalCoord1dv,
- glEvalCoord1f,
- glEvalCoord1fv,
- glEvalCoord2d,
- glEvalCoord2dv,
- glEvalCoord2f,
- glEvalCoord2fv,
- glEvalMesh1,
- glEvalMesh2,
- glEvalPoint1,
- glEvalPoint2,
- glFeedbackBuffer,
- glFinish,
- glFlush,
- glFogf,
- glFogfv,
- glFogi,
- glFogiv,
- glFrontFace,
- glFrustum,
- glGenLists,
- glGetBooleanv,
- glGetClipPlane,
- glGetDoublev,
- glGetError,
- glGetFloatv,
- glGetIntegerv,
- glGetLightfv,
- glGetLightiv,
- glGetMapdv,
- glGetMapfv,
- glGetMapiv,
- glGetMaterialfv,
- glGetMaterialiv,
- glGetPixelMapfv,
- glGetPixelMapuiv,
- glGetPixelMapusv,
- glGetPolygonStipple,
- glGetString,
- glGetTexEnvfv,
- glGetTexEnviv,
- glGetTexGendv,
- glGetTexGenfv,
- glGetTexGeniv,
- glGetTexImage,
- glGetTexLevelParameterfv,
- glGetTexLevelParameteriv,
- glGetTexParameterfv,
- glGetTexParameteriv,
- glHint,
- glIndexMask,
- glIndexd,
- glIndexdv,
- glIndexf,
- glIndexfv,
- glIndexi,
- glIndexiv,
- glIndexs,
- glIndexsv,
- glInitNames,
- glIsEnabled,
- glIsList,
- glLightModelf,
- glLightModelfv,
- glLightModeli,
- glLightModeliv,
- glLightf,
- glLightfv,
- glLighti,
- glLightiv,
- glLineStipple,
- glLineWidth,
- glListBase,
- glLoadIdentity,
- glLoadMatrixd,
- glLoadMatrixf,
- glLoadName,
- glLogicOp,
- glMap1d,
- glMap1f,
- glMap2d,
- glMap2f,
- glMapGrid1d,
- glMapGrid1f,
- glMapGrid2d,
- glMapGrid2f,
- glMaterialf,
- glMaterialfv,
- glMateriali,
- glMaterialiv,
- glMatrixMode,
- glMultMatrixd,
- glMultMatrixf,
- glNewList,
- glNormal3b,
- glNormal3bv,
- glNormal3d,
- glNormal3dv,
- glNormal3f,
- glNormal3fv,
- glNormal3i,
- glNormal3iv,
- glNormal3s,
- glNormal3sv,
- glOrtho,
- glPassThrough,
- glPixelMapfv,
- glPixelMapuiv,
- glPixelMapusv,
- glPixelStoref,
- glPixelStorei,
- glPixelTransferf,
- glPixelTransferi,
- glPixelZoom,
- glPointSize,
- glPolygonMode,
- glPolygonOffset,
- glPolygonStipple,
- glPopAttrib,
- glPopMatrix,
- glPopName,
- glPushAttrib,
- glPushMatrix,
- glPushName,
- glRasterPos2d,
- glRasterPos2dv,
- glRasterPos2f,
- glRasterPos2fv,
- glRasterPos2i,
- glRasterPos2iv,
- glRasterPos2s,
- glRasterPos2sv,
- glRasterPos3d,
- glRasterPos3dv,
- glRasterPos3f,
- glRasterPos3fv,
- glRasterPos3i,
- glRasterPos3iv,
- glRasterPos3s,
- glRasterPos3sv,
- glRasterPos4d,
- glRasterPos4dv,
- glRasterPos4f,
- glRasterPos4fv,
- glRasterPos4i,
- glRasterPos4iv,
- glRasterPos4s,
- glRasterPos4sv,
- glReadBuffer,
- glReadPixels,
- glRectd,
- glRectdv,
- glRectf,
- glRectfv,
- glRecti,
- glRectiv,
- glRects,
- glRectsv,
- glRenderMode,
- glRotated,
- glRotatef,
- glScaled,
- glScalef,
- glScissor,
- glSelectBuffer,
- glShadeModel,
- glStencilFunc,
- glStencilMask,
- glStencilOp,
- glTexCoord1d,
- glTexCoord1dv,
- glTexCoord1f,
- glTexCoord1fv,
- glTexCoord1i,
- glTexCoord1iv,
- glTexCoord1s,
- glTexCoord1sv,
- glTexCoord2d,
- glTexCoord2dv,
- glTexCoord2f,
- glTexCoord2fv,
- glTexCoord2i,
- glTexCoord2iv,
- glTexCoord2s,
- glTexCoord2sv,
- glTexCoord3d,
- glTexCoord3dv,
- glTexCoord3f,
- glTexCoord3fv,
- glTexCoord3i,
- glTexCoord3iv,
- glTexCoord3s,
- glTexCoord3sv,
- glTexCoord4d,
- glTexCoord4dv,
- glTexCoord4f,
- glTexCoord4fv,
- glTexCoord4i,
- glTexCoord4iv,
- glTexCoord4s,
- glTexCoord4sv,
- glTexEnvf,
- glTexEnvfv,
- glTexEnvi,
- glTexEnviv,
- glTexGend,
- glTexGendv,
- glTexGenf,
- glTexGenfv,
- glTexGeni,
- glTexGeniv,
- glTexImage1D,
- glTexImage2D,
- glTexParameterf,
- glTexParameterfv,
- glTexParameteri,
- glTexParameteriv,
- glTranslated,
- glTranslatef,
- glVertex2d,
- glVertex2dv,
- glVertex2f,
- glVertex2fv,
- glVertex2i,
- glVertex2iv,
- glVertex2s,
- glVertex2sv,
- glVertex3d,
- glVertex3dv,
- glVertex3f,
- glVertex3fv,
- glVertex3i,
- glVertex3iv,
- glVertex3s,
- glVertex3sv,
- glVertex4d,
- glVertex4dv,
- glVertex4f,
- glVertex4fv,
- glVertex4i,
- glVertex4iv,
- glVertex4s,
- glVertex4sv,
- glViewport,
-
-#ifdef _GLAPI_VERSION_1_1
- glAreTexturesResident,
- glArrayElement,
- glBindTexture,
- glColorPointer,
- glCopyTexImage1D,
- glCopyTexImage2D,
- glCopyTexSubImage1D,
- glCopyTexSubImage2D,
- glDeleteTextures,
- glDisableClientState,
- glDrawArrays,
- glDrawElements,
- glEdgeFlagPointer,
- glEnableClientState,
- glGenTextures,
- glGetPointerv,
- glIndexPointer,
- glIndexub,
- glIndexubv,
- glInterleavedArrays,
- glIsTexture,
- glNormalPointer,
- glPopClientAttrib,
- glPrioritizeTextures,
- glPushClientAttrib,
- glTexCoordPointer,
- glTexSubImage1D,
- glTexSubImage2D,
- glVertexPointer,
-#endif
-
-#ifdef _GLAPI_VERSION_1_2
- glCopyTexSubImage3D,
- glDrawRangeElements,
- glTexImage3D,
- glTexSubImage3D,
-
-#ifdef _GLAPI_ARB_imaging
- glBlendColor,
- glBlendEquation,
- glColorSubTable,
- glColorTable,
- glColorTableParameterfv,
- glColorTableParameteriv,
- glConvolutionFilter1D,
- glConvolutionFilter2D,
- glConvolutionParameterf,
- glConvolutionParameterfv,
- glConvolutionParameteri,
- glConvolutionParameteriv,
- glCopyColorSubTable,
- glCopyColorTable,
- glCopyConvolutionFilter1D,
- glCopyConvolutionFilter2D,
- glGetColorTable,
- glGetColorTableParameterfv,
- glGetColorTableParameteriv,
- glGetConvolutionFilter,
- glGetConvolutionParameterfv,
- glGetConvolutionParameteriv,
- glGetHistogram,
- glGetHistogramParameterfv,
- glGetHistogramParameteriv,
- glGetMinmax,
- glGetMinmaxParameterfv,
- glGetMinmaxParameteriv,
- glGetSeparableFilter,
- glHistogram,
- glMinmax,
- glResetHistogram,
- glResetMinmax,
- glSeparableFilter2D,
-#endif
-#endif
-
-
- /*
- * Extensions
- */
-
-#ifdef _GLAPI_EXT_paletted_texture
- glColorTableEXT,
- glColorSubTableEXT,
- glGetColorTableEXT,
- glGetColorTableParameterfvEXT,
- glGetColorTableParameterivEXT,
-#endif
-
-#ifdef _GLAPI_EXT_compiled_vertex_array
- glLockArraysEXT,
- glUnlockArraysEXT,
-#endif
-
-#ifdef _GLAPI_EXT_point_parameters
- glPointParameterfEXT,
- glPointParameterfvEXT,
-#endif
-
-#ifdef _GLAPI_EXT_polygon_offset
- glPolygonOffsetEXT,
-#endif
-
-#ifdef _GLAPI_EXT_blend_minmax
- glBlendEquationEXT,
-#endif
-
-#ifdef _GLAPI_EXT_blend_color
- glBlendColorEXT,
-#endif
-
-#ifdef _GLAPI_ARB_multitexture
- glActiveTextureARB,
- glClientActiveTextureARB,
- glMultiTexCoord1dARB,
- glMultiTexCoord1dvARB,
- glMultiTexCoord1fARB,
- glMultiTexCoord1fvARB,
- glMultiTexCoord1iARB,
- glMultiTexCoord1ivARB,
- glMultiTexCoord1sARB,
- glMultiTexCoord1svARB,
- glMultiTexCoord2dARB,
- glMultiTexCoord2dvARB,
- glMultiTexCoord2fARB,
- glMultiTexCoord2fvARB,
- glMultiTexCoord2iARB,
- glMultiTexCoord2ivARB,
- glMultiTexCoord2sARB,
- glMultiTexCoord2svARB,
- glMultiTexCoord3dARB,
- glMultiTexCoord3dvARB,
- glMultiTexCoord3fARB,
- glMultiTexCoord3fvARB,
- glMultiTexCoord3iARB,
- glMultiTexCoord3ivARB,
- glMultiTexCoord3sARB,
- glMultiTexCoord3svARB,
- glMultiTexCoord4dARB,
- glMultiTexCoord4dvARB,
- glMultiTexCoord4fARB,
- glMultiTexCoord4fvARB,
- glMultiTexCoord4iARB,
- glMultiTexCoord4ivARB,
- glMultiTexCoord4sARB,
- glMultiTexCoord4svARB,
-#endif
-
-#ifdef _GLAPI_INGR_blend_func_separate
- glBlendFuncSeparateINGR,
-#endif
-
-#ifdef _GLAPI_MESA_window_pos
- glWindowPos4fMESA,
-#endif
-
-#ifdef _GLAPI_MESA_resize_buffers
- glResizeBuffersMESA
-#endif
-
-};
-
-#endif /*DEBUG*/