diff options
| author | brianp <brianp> | 2000-02-26 01:36:48 +0000 |
|---|---|---|
| committer | brianp <brianp> | 2000-02-26 01:36:48 +0000 |
| commit | 023c5bb28c6ff479a464a2dcfde8d305deafd322 (patch) | |
| tree | 9783d0b4ed7794dc6f348fcaa3513bcb700c9276 | |
| parent | 89c78477478cb7a9077de97a3f6d383230102873 (diff) | |
Merged dispatch-0-0-3dispatch-0-0-3-20000225-merge
60 files changed, 6346 insertions, 3705 deletions
diff --git a/xc/doc/specs/GL/libGL.txt b/xc/doc/specs/GL/libGL.txt new file mode 100644 index 000000000..57ecc590b --- /dev/null +++ b/xc/doc/specs/GL/libGL.txt @@ -0,0 +1,192 @@ + + + +Introduction +------------ + +This document describes the implementation of the XFree86 4.0 libGL.so +library defined by the Linux/OpenGL Base specification found at +http://reality.sgi.com/opengl/linux/linuxbase.html. + +The documentation is divided into two sections: + User's Guide + Driver Developer's Guide + +Author: Brian Paul (brian@precisioninsight.com) +Date: February 2000 + + + +User's Guide +------------ + +Using libGL.so + +The libGL.so library defines the gl- and glX-prefixed functions needed to +run OpenGL programs. OpenGL client applications should link with the +-lGL option to use it. + +libGL.so serves two primary functions: GLX protocol generation for indirect +rendering and loading/management of hardware drivers for direct rendering. + +When libGL.so initializes itself it uses the DRI to determine the +appropriate hardware driver for each screen on the local X display. +The hardware drivers are expected to be in the /usr/X11R6/lib/modules/dri/ +directory. Drivers are named with the convention <name>_dri.so where +<name> is a driver such as "tdfx", "i810", "gamma", etc. + +The LIBGL_DRIVERS_DIR environment variable may be used to specify a +different DRI modules directory, overriding /usr/X11R6/lib/modules/dri/. +This environment variable is ignored in setuid programs for security +reasons. + +When libGL.so is unable to locate appropriate hardware drivers it will +fall back to using indirect GLX rendering. + +To aid in solving problems, libGL.so will print diagnostic messages to +stderr if the LIBGL_DEBUG environment variable is defined. + +libGL.so is thread safe. The overhead of thread safety for common, +single-thread clients is negligible. However, the overhead of thread +safety for multi-threaded clients is significant. Each GL API call +requires two calls to pthread_get_specific() which can noticably +impact performance. Warning: libGL.so is thread safe but individual +DRI drivers may not be. Please consult the documentation for a driver +to learn if it is thread safe. + + + +Indirect Rendering + +You can force indirect rendering mode by setting the LIBGL_ALWAYS_INDIRECT +environment variable. Hardware acceleration will not be used. + + + +libGL.so Extensibility + +libGL.so is designed to be extended without upgrading. That is, +drivers may install new OpenGL extension functions into libGL.so +without requiring libGL.so to be replaced. Clients of libGL.so should +use the glXGetProcAddressEXT() function to obtain the address of +functions by name. For more details of GLX_ARB_get_proc_address see +http://oss.sgi.com/projects/ogl-sample/registry/ARB/get_proc_address.spec + +libGL.so is also designed with flexibility such that it may be used +with many generations of hardware drivers to come. + + + + +Driver Developer's Guide +------------------------ + +This section describes the requirements to make an XFree86 4.0 +libGL.so-compatible hardware driver. It is not intended for end +users of libGL.so. + + +XFree86 source files + +libGL.so is built inside XFree86 with sources found in xc/lib/GL/. +Specifically, libGL.so is built from: + + xc/lib/GL/glx/*.c + xc/lib/dri/XF86dri.c + xc/lib/dri/dri_glx.c + xc/lib/GL/mesa/src/glapi.c + xc/lib/GL/mesa/src/glapitemp.h + xc/lib/GL/mesa/src/glapitable.h + xc/lib/GL/mesa/src/glapioffsets.h + xc/lib/GL/mesa/src/glapinoop.c + xc/lib/GL/mesa/src/glheader.h + xc/lib/GL/mesa/src/glthread.c + xc/lib/GL/mesa/src/glthread.h + xc/lib/GL/mesa/src/X86/glapi_x86.S + xc/lib/GL/mesa/src/X86/assyntax.h + +Understand that the mesa/src/gl*.[ch] files are not tied to Mesa. They +have no dependencies on the rest of Mesa and are designed to be reusable +in a number of projects. + +The glapi_x86.X and assyntax.h files implement x86-optimized dispatch +of GL functions. They are not required; C-based dispatch can be used +instead, with a slight performance penalty. + + + +Driver loading and binding + +When libGL.so initializes itself (via the __glXInitialize function) a +call is made to driCreateDisplay(). This function uses DRI facilities +to determine the driver file appropriate for each screen on the local +display. Each screen's driver is then opened with dlopen() and asked +for its __driCreateScreen() function. The pointers to the __driCreateScreen() +functions are kept in an array, indexed by screen number, in the +__DRIdisplayRec struct. + +When a driver's __driCreateScreen() function is called, it must initialize +a __DRIscreenRec struct. This struct acts as the root of a tree of +function pointers which are called to create and destroy contexts and +drawables and perform all the operations needed by the GLX interface. +See the xc/lib/GL/glx/glxclient.h file for details. + + + +Dynamic Extension Function Registration + +In order to provide forward compatibility with future drivers, libGL.so +allows drivers to register new OpenGL extension functions which weren't +known when libGL.so was built. + +After libGL obtains the __driCreateScreen() function pointer, it looks +for __driRegisterExtensions() in the driver. If __driRegisterExtensions() +is found it will immediately be called. Inside the driver, this +function should call: + + GLboolean _glapi_add_entrypoint(const char *funcName, GLuint offset) + +in order to register each extension function with libGL. The parameters +are the name of the function (such as "glFoobarEXT") and the offset of the +dispatch slot in the API dispatch table. The return value indicates +success (GL_TRUE) or failure (GL_FALSE). + +_glapi_add_entrypoint() will synthesize entrypoint code in assembly +language. Assembly languages is required since parameter passing +can't be handled correctly using a C-based solution. + +The address of the new entrypoint is obtained by calling the +glXGetProcAddressARB() function. + +The dispatch offset number MUST be a number allocated by SGI in the same +manner in which new GL_* constants are allocated. Using an arbitrary +offset number will result in many problems. + + + +Dispatch Management + +When a GL context is made current, the driver must install its dispatch +table as the current dispatch table. This is done by calling + + void _glapi_set_dispatch(struct _glapi_table *dispatch); + +This will install the named dispatch table for the calling thread. +The current dispatch table for a thread can be obtained by calling + + struct _glapi_table *_glapi_get_dispatch(void); + +For higher performance in the common single-thread case, the global +variable _glapi_Dispatch will point to the current dispatch table. +This variable will be NULL when in multi-thread mode. + + + +Context Management + +libGL.so uses the XFree86 xthreads package to manage a thread-specific +current context pointer. See __glXGet/SetCurrentContext() in glext.c + +Drivers may use the _glapi_set/get_context() functions to maintain +a private thread-specific context pointer. + diff --git a/xc/extras/Mesa/include/GL/gl.h b/xc/extras/Mesa/include/GL/gl.h index 564ea3ef7..03988f43b 100644 --- a/xc/extras/Mesa/include/GL/gl.h +++ b/xc/extras/Mesa/include/GL/gl.h @@ -56,38 +56,44 @@ # pragma warning( disable : 4710 ) /* function 'foo' not inlined */ # pragma warning( disable : 4711 ) /* function 'foo' selected for automatic inline expansion */ # pragma warning( disable : 4127 ) /* conditional expression is constant */ -# if defined(MESA_MINWARN) -# pragma warning( disable : 4244 ) /* '=' : conversion from 'const double ' to 'float ', possible loss of data */ -# pragma warning( disable : 4018 ) /* '<' : signed/unsigned mismatch */ -# pragma warning( disable : 4305 ) /* '=' : truncation from 'const double ' to 'float ' */ -# pragma warning( disable : 4550 ) /* 'function' undefined; assuming extern returning int */ -# pragma warning( disable : 4761 ) /* integral size mismatch in argument; conversion supplied */ +# if defined(MESA_MINWARN) +# pragma warning( disable : 4244 ) /* '=' : conversion from 'const double ' to 'float ', possible loss of data */ +# pragma warning( disable : 4018 ) /* '<' : signed/unsigned mismatch */ +# pragma warning( disable : 4305 ) /* '=' : truncation from 'const double ' to 'float ' */ +# pragma warning( disable : 4550 ) /* 'function' undefined; assuming extern returning int */ +# pragma warning( disable : 4761 ) /* integral size mismatch in argument; conversion supplied */ # endif -# if defined(_MSC_VER) && defined(BUILD_GL32) /* tag specify we're building mesa as a DLL */ -# define GLAPI __declspec(dllexport) -# define WGLAPI __declspec(dllexport) -# elif defined(_MSC_VER) && defined(_DLL) /* tag specifying we're building for DLL runtime support */ -# define GLAPI __declspec(dllimport) -# define WGLAPI __declspec(dllimport) -# else /* for use with static link lib build of Win32 edition only */ -# define GLAPI extern -# define WGLAPI __declspec(dllimport) -# endif /* _STATIC_MESA support */ -# define GLAPIENTRY __stdcall -# define GLAPIENTRYP __stdcall * -# define GLCALLBACK __stdcall -# define GLCALLBACKP __stdcall * -# define GLWINAPI __stdcall -# define GLWINAPIV __cdecl +# if defined(_MSC_VER) && defined(BUILD_GL32) /* tag specify we're building mesa as a DLL */ +# define GLAPI __declspec(dllexport) +# define WGLAPI __declspec(dllexport) +# elif defined(_MSC_VER) && defined(_DLL) /* tag specifying we're building for DLL runtime support */ +# define GLAPI __declspec(dllimport) +# define WGLAPI __declspec(dllimport) +# else /* for use with static link lib build of Win32 edition only */ +# define GLAPI extern +# define WGLAPI __declspec(dllimport) +# endif /* _STATIC_MESA support */ +# define GLAPIENTRY __stdcall +# define GLAPIENTRYP __stdcall * +# define GLCALLBACK __stdcall +# define GLCALLBACKP __stdcall * +# if defined(__CYGWIN32__) +# define GLCALLBACKPCAST * +# else +# define GLCALLBACKPCAST __stdcall * +# endif +# define GLWINAPI __stdcall +# define GLWINAPIV __cdecl #else /* non-Windows compilation */ -# define GLAPI extern -# define GLAPIENTRY -# define GLAPIENTRYP * -# define GLCALLBACK -# define GLCALLBACKP * -# define GLWINAPI -# define GLWINAPIV +# define GLAPI extern +# define GLAPIENTRY +# define GLAPIENTRYP * +# define GLCALLBACK +# define GLCALLBACKP * +# define GLCALLBACKPCAST * +# define GLWINAPI +# define GLWINAPIV #endif /* WIN32 / CYGWIN32 bracket */ /* compatability guard so we don't need to change client code */ @@ -130,18 +136,9 @@ extern "C" { -/* - * Apps can test for this symbol to do conditional compilation if needed. - */ -/* XXX these Mesa symbols are going away -#define MESA -#define MESA_MAJOR_VERSION 3 -#define MESA_MINOR_VERSION 1 -*/ - - #define GL_VERSION_1_1 1 #define GL_VERSION_1_2 1 +#define GL_HAS_GLEXT 1 @@ -1783,7 +1780,7 @@ GLAPI void GLAPIENTRY glGetSeparableFilter( GLenum target, GLenum format, /* - * XXX these extensions may eventually be moved into a new glext.h file + * XXX these extensions may eventually be moved into glext.h */ @@ -2157,19 +2154,19 @@ GLAPI void GLAPIENTRY glUnlockArraysEXT( void ); /* - * GL_INGR_blend_func_separate (EXT number 173) + * GL_EXT_blend_func_separate (EXT number 173) (aka GL_INGR_blend_func_separate) */ -#ifndef GL_INGR_blend_func_separate -#define GL_INGR_blend_func_separate 1 +#ifndef GL_EXT_blend_func_separate +#define GL_EXT_blend_func_separate 1 -#define GL_BLEND_DST_RGB_INGR 0x80C8 -#define GL_BLEND_SRC_RGB_INGR 0x80C9 -#define GL_BLEND_DST_ALPHA_INGR 0x80CA -#define GL_BLEND_SRC_ALPHA_INGR 0x80CB +#define GL_BLEND_DST_RGB_EXT 0x80C8 +#define GL_BLEND_SRC_RGB_EXT 0x80C9 +#define GL_BLEND_DST_ALPHA_EXT 0x80CA +#define GL_BLEND_SRC_ALPHA_EXT 0x80CB -GLAPI void GLAPIENTRY glBlendFuncSeparateINGR( GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha ); +GLAPI void GLAPIENTRY glBlendFuncSeparateEXT( GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha ); -#endif /* GL_INGR_blend_func_separate */ +#endif /* GL_EXT_blend_func_separate */ @@ -2199,7 +2196,7 @@ GLAPI void GLAPIENTRY glBlendFuncSeparateINGR( GLenum sfactorRGB, GLenum dfactor /* - * GL_ARB_multitexture (no number) + * GL_ARB_multitexture (ARB 0) */ #ifndef GL_ARB_multitexture #define GL_ARB_multitexture 1 @@ -2280,7 +2277,7 @@ GLAPI void GLAPIENTRY glMultiTexCoord4svARB(GLenum target, const GLshort *v); /* - * GL_MESA_window_pos (no number) + * GL_MESA_window_pos (197) */ #ifndef GL_MESA_window_pos #define GL_MESA_window_pos 1 @@ -2315,7 +2312,7 @@ GLAPI void GLAPIENTRY glWindowPos4dvMESA( const GLdouble *p ); /* - * GL_MESA_resize_bufffers (no number) + * GL_MESA_resize_bufffers (196) */ #ifndef GL_MESA_resize_bufffers #define GL_MESA_resize_buffers 1 @@ -2327,7 +2324,7 @@ GLAPI void GLAPIENTRY glResizeBuffersMESA( void ); /* - * GL_ARB_tranpose_matrix (number ?) + * GL_ARB_tranpose_matrix (ARB 2) */ #ifndef GL_ARB_transpose_matrix #define GL_ARB_transpose_matrix 1 @@ -2342,7 +2339,21 @@ GLAPI void GLAPIENTRY glLoadTransposeMatrixfARB( const GLfloat m[16] ); GLAPI void GLAPIENTRY glMultTransposeMatrixdARB( const GLdouble m[16] ); GLAPI void GLAPIENTRY glMultTransposeMatrixfARB( const GLfloat m[16] ); -#endif +#endif /* GL_ARB_tranpose_matrix */ + + + +/* + * GL_ARB_multisample (ARB 4) + */ +#ifndef GL_ARB_multisample +#define GL_ARB_multisample 1 + +GLAPI void GLAPIENTRY glSampleCoverageARB(GLclampf value, GLboolean invert); + +GLAPI void GLAPIENTRY glSamplePassARB(GLenum pass); + +#endif /* GL_ARB_multisample */ diff --git a/xc/extras/Mesa/include/GL/glext.h b/xc/extras/Mesa/include/GL/glext.h new file mode 100644 index 000000000..9e9d764ee --- /dev/null +++ b/xc/extras/Mesa/include/GL/glext.h @@ -0,0 +1,1478 @@ +#ifndef __glext_h_ +#define __glext_h_ + + +/* + * XXX Many extensions need to be added yet. + * XXX Some token values aren't known (grep for ?) + * XXX This file may be automatically generated in the future. + */ + + +#ifdef __cplusplus +extern "C" { +#endif + + +#ifdef _WIN32 +#define WIN32_LEAN_AND_MEAN 1 +#include <windows.h> +#endif + +#ifndef GLAPI +#define GLAPI extern +#endif + +#ifndef APIENTRY +#define APIENTRY +#endif + + + +/* + * 1. GL_EXT_abgr + */ +#ifndef GL_EXT_abgr +#define GL_EXT_abgr 1 + +#define GL_ABGR_EXT 0x8000 + +#endif /* GL_EXT_abgr */ + + + +/* + * 2. GL_EXT_blend_color + */ +#ifndef GL_EXT_blend_color +#define GL_EXT_blend_color 1 + +#define GL_CONSTANT_COLOR_EXT 0x8001 +#define GL_ONE_MINUS_CONSTANT_COLOR_EXT 0x8002 +#define GL_CONSTANT_ALPHA_EXT 0x8003 +#define GL_ONE_MINUS_CONSTANT_ALPHA_EXT 0x8004 +#define GL_BLEND_COLOR_EXT 0x8005 + +GLAPI void APIENTRY glBlendColorEXT(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha); + +#endif /* GL_EXT_blend_color */ + + + +/* + * 3. GL_EXT_polygon_offset + */ +#ifndef GL_EXT_polygon_offset +#define GL_EXT_polygon_offset 1 + +#define GL_POLYGON_OFFSET_EXT 0x8037 +#define GL_POLYGON_OFFSET_FACTOR_EXT 0x8038 +#define GL_POLYGON_OFFSET_BIAS_EXT 0x8039 + +GLAPI void APIENTRY glPolygonOffsetEXT(GLfloat factor, GLfloat bias); + +#endif /* GL_EXT_polygon_offset */ + + + +/* + * 6. GL_EXT_texture3D + */ +#ifndef GL_EXT_texture3D +#define GL_EXT_texture3D 1 + +#define GL_PACK_SKIP_IMAGES_EXT 0x806B +#define GL_PACK_IMAGE_HEIGHT_EXT 0x806C +#define GL_UNPACK_SKIP_IMAGES_EXT 0x806D +#define GL_UNPACK_IMAGE_HEIGHT_EXT 0x806E +#define GL_TEXTURE_3D_EXT 0x806F +#define GL_PROXY_TEXTURE_3D_EXT 0x8070 +#define GL_TEXTURE_DEPTH_EXT 0x8071 +#define GL_TEXTURE_WRAP_R_EXT 0x8072 +#define GL_MAX_3D_TEXTURE_SIZE_EXT 0x8073 +#define GL_TEXTURE_3D_BINDING_EXT 0x806A + +GLAPI void APIENTRY glTexImage3DEXT(GLenum target, GLint level, GLenum internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const GLvoid *pixels); + +GLAPI void APIENTRY glTexSubImage3DEXT(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const GLvoid *pixels); + +GLAPI void APIENTRY glCopyTexSubImage3DEXT(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height); + +#endif /* GL_EXT_texture3D */ + + + +/* + * 7. GL_SGI_texture_filter4 + */ +#ifndef GL_SGI_texture_filter4 +#define GL_SGI_texture_filter4 1 + +#define GL_FILTER4_SGIS ? +#define GL_TEXTURE_FILTER4_SIZE_SGIS ? + +GLAPI void APIENTRY glGetTexFilterFuncSGIS(GLenum target, GLenum filter, GLfloat *weights); + +GLAPI void APIENTRY glTexFilterFuncSGIS(GLenum target, GLenum filter, GLsizei n, const GLfloat *weights); + +#endif /* GL_SGI_texture_filter4 */ + + + +/* + * 9. GL_EXT_subtexture + */ +#ifndef GL_EXT_subtexture +#define GL_EXT_subtexture 1 + +GLAPI void APIENTRY glCopyTexSubImage1DEXT(GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width); + +GLAPI void APIENTRY glTexSubImage1DEXT(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const GLvoid *pixels); + +GLAPI void APIENTRY glTexSubImage2DEXT(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels); + +#endif /* GL_EXT_subtexture */ + + + +/* + * 10. GL_EXT_copy_texture + */ +#ifndef GL_EXT_copy_texture +#define GL_EXT_copy_texture 1 + +GLAPI void APIENTRY glCopyTexImage1DEXT(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLint border); + +GLAPI void APIENTRY glCopyTexImage2DEXT(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border); + +GLAPI void APIENTRY glCopyTexSubImage2DEXT(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height); + +#endif /* GL_EXT_copy_texture */ + + + +/* + * 11. GL_EXT_histogram + */ +#ifndef GL_EXT_histogram +#define GL_EXT_histogram 1 + + +#define GL_HISTOGRAM_EXT 0x8024 +#define GL_PROXY_HISTOGRAM_EXT 0x8025 +#define GL_HISTOGRAM_WIDTH_EXT 0x8026 +#define GL_HISTOGRAM_FORMAT_EXT 0x8027 +#define GL_HISTOGRAM_RED_SIZE_EXT 0x8028 +#define GL_HISTOGRAM_GREEN_SIZE_EXT 0x8029 +#define GL_HISTOGRAM_BLUE_SIZE_EXT 0x802A +#define GL_HISTOGRAM_ALPHA_SIZE_EXT 0x802B +#define GL_HISTOGRAM_LUMINANCE_SIZE_EXT 0x802C +#define GL_HISTOGRAM_SINK_EXT 0x802D + +GLAPI void APIENTRY glGetHistogramEXT(GLenum target, GLboolean reset, GLenum format, GLenum type, GLvoid *values); + +GLAPI void APIENTRY glGetHistogramParameterfvEXT(GLenum target, GLenum pname, GLfloat *params); + +GLAPI void APIENTRY glGetHistogramParameterivEXT(GLenum target, GLenum pname, GLint *params); + +GLAPI void APIENTRY glGetMinmaxEXT(GLenum target, GLboolean reset, GLenum format, GLenum types, GLvoid *values); + +GLAPI void APIENTRY glGetMinmaxParameterfvEXT(GLenum target, GLenum pname, GLfloat *params); + +GLAPI void APIENTRY glGetMinmaxParameterivEXT(GLenum target, GLenum pname, GLint *params); + +GLAPI void APIENTRY glHistogramEXT(GLenum target, GLsizei width, GLenum internalformat, GLboolean sink); + +GLAPI void APIENTRY glMinmaxEXT(GLenum target, GLenum internalformat, GLboolean sink); + +GLAPI void APIENTRY glResetHistogramEXT(GLenum target); + +GLAPI void APIENTRY glResetMinmaxEXT(GLenum target); + +#endif /* GL_EXT_histogram */ + + + +/* + * 12. GL_EXT_convolution + */ +#ifndef GL_EXT_convolution +#define GL_EXT_convolution 1 + +#define GL_CONVOLUTION_1D_EXT 0x8010 +#define GL_CONVOLUTION_2D_EXT 0x8011 +#define GL_SEPARABLE_2D_EXT 0x8012 +#define GL_CONVOLUTION_BORDER_MODE_EXT 0x8013 +#define GL_CONVOLUTION_FILTER_SCALE_EXT 0x8014 +#define GL_CONVOLUTION_FILTER_BIAS_EXT 0x8015 +#define GL_REDUCE_EXT 0x8016 +#define GL_CONVOLUTION_FORMAT_EXT 0x8017 +#define GL_CONVOLUTION_WIDTH_EXT 0x8018 +#define GL_CONVOLUTION_HEIGHT_EXT 0x8019 +#define GL_MAX_CONVOLUTION_WIDTH_EXT 0x801A +#define GL_MAX_CONVOLUTION_HEIGHT_EXT 0x801B +#define GL_POST_CONVOLUTION_RED_SCALE_EXT 0x801C +#define GL_POST_CONVOLUTION_GREEN_SCALE_EXT 0x801D +#define GL_POST_CONVOLUTION_BLUE_SCALE_EXT 0x801E +#define GL_POST_CONVOLUTION_ALPHA_SCALE_EXT 0x801F +#define GL_POST_CONVOLUTION_RED_BIAS_EXT 0x8020 +#define GL_POST_CONVOLUTION_GREEN_BIAS_EXT 0x8021 +#define GL_POST_CONVOLUTION_BLUE_BIAS_EXT 0x8022 +#define GL_POST_CONVOLUTION_ALPHA_BIAS_EXT 0x8023 + +GLAPI void APIENTRY glConvolutionFilter1DEXT(GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const GLvoid *image); + +GLAPI void APIENTRY glConvolutionFilter2DEXT(GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *image); + +GLAPI void APIENTRY glConvolutionParameterfEXT(GLenum target, GLenum pname, GLfloat params); + +GLAPI void APIENTRY glConvolutionParameterfvEXT(GLenum target, GLenum pname, const GLfloat *params); + +GLAPI void APIENTRY glConvolutionParameteriEXT(GLenum target, GLenum pname, GLint params); + +GLAPI void APIENTRY glConvolutionParameterivEXT(GLenum target, GLenum pname, const GLint *params); + +GLAPI void APIENTRY glCopyConvolutionFilter1DEXT(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width); + +GLAPI void APIENTRY glCopyConvolutionFilter2DEXT(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height); + +GLAPI void APIENTRY glGetConvolutionFilterEXT(GLenum target, GLenum format, GLenum type, GLvoid *image); + +GLAPI void APIENTRY glGetConvolutionParameterfvEXT(GLenum target, GLenum pname, GLfloat *params); + +GLAPI void APIENTRY glGetConvolutionParameterivEXT(GLenum target, GLenum pname, GLint *params); + +GLAPI void APIENTRY glGetSeparableFilterEXT(GLenum target, GLenum format, GLenum type, GLvoid *row, GLvoid *column, GLvoid *span); + +GLAPI void APIENTRY glSeparableFilter2DEXT(GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *row, const GLvoid *column); + +#endif /* GL_EXT_convolution */ + + + +/* + * 13. GL_SGI_color_matrix + */ +#ifndef GL_SGI_color_matrix +#define GL_SGI_color_matrix 1 + +#define GL_COLOR_MATRIX_SGI 0x80B1 +#define GL_COLOR_MATRIX_STACK_DEPTH_SGI 0x80B2 +#define GL_MAX_COLOR_MATRIX_STACK_DEPTH_SGI 0x80B3 +#define GL_POST_COLOR_MATRIX_RED_SCALE_SGI 0x80B4 +#define GL_POST_COLOR_MATRIX_GREEN_SCALE_SGI 0x80B5 +#define GL_POST_COLOR_MATRIX_BLUE_SCALE_SGI 0x80B6 +#define GL_POST_COLOR_MATRIX_ALPHA_SCALE_SGI 0x80B7 +#define GL_POST_COLOR_MATRIX_RED_BIAS_SGI 0x80B8 +#define GL_POST_COLOR_MATRIX_GREEN_BIAS_SGI 0x80B9 +#define GL_POST_COLOR_MATRIX_BLUE_BIAS_SGI 0x80BA +#define GL_POST_COLOR_MATRIX_ALPHA_BIAS_SGI 0x80BB + +#endif /* GL_SGI_color_matrix */ + + + +/* + * 14. GL_SGI_color_table + */ +#ifndef GL_SGI_color_table +#define GL_SGI_color_table 1 + +#define COLOR_TABLE_SGI 0x80D0 +#define POST_CONVOLUTION_COLOR_TABLE_SGI 0x80D1 +#define POST_COLOR_MATRIX_COLOR_TABLE_SGI 0x80D2 +#define PROXY_COLOR_TABLE_SGI 0x80D3 +#define PROXY_POST_CONVOLUTION_COLOR_TABLE_SGI 0x80D4 +#define PROXY_POST_COLOR_MATRIX_COLOR_TABLE_SGI 0x80D5 +#define COLOR_TABLE_SCALE_SGI 0x80D6 +#define COLOR_TABLE_BIAS_SGI 0x80D7 +#define COLOR_TABLE_FORMAT_SGI 0x80D8 +#define COLOR_TABLE_WIDTH_SGI 0x80D9 +#define COLOR_TABLE_RED_SIZE_SGI 0x80DA +#define COLOR_TABLE_GREEN_SIZE_SGI 0x80DB +#define COLOR_TABLE_BLUE_SIZE_SGI 0x80DC +#define COLOR_TABLE_ALPHA_SIZE_SGI 0x80DD +#define COLOR_TABLE_LUMINANCE_SIZE_SGI 0x80DE +#define COLOR_TABLE_INTENSITY_SIZE_SGI 0x80DF + +GLAPI void APIENTRY glColorTableParameterfvSGI(GLenum target, GLenum pname, const GLfloat *params); + +GLAPI void APIENTRY glColorTableParameterivSGI(GLenum target, GLenum pname, const GLint *params); + +GLAPI void APIENTRY glColorTableSGI(GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const GLvoid *table); + +GLAPI void APIENTRY glCopyColorTableSGI(GLenum target, GLenum internalFormat, GLint x, GLint y, GLsizei width); + +GLAPI void APIENTRY glGetColorTableParameterfvSGI(GLenum target, GLenum pname, GLfloat *params); + +GLAPI void APIENTRY glGetColorTableParameterivSGI(GLenum target, GLenum pname, GLint *params); + +GLAPI void APIENTRY glGetColorTableSGI(GLenum target, GLenum format, GLenum type, GLvoid *table); + +#endif /* GL_SGI_color_table */ + + + +/* + * ?. GL_SGIX_pixel_texture + */ +#ifndef GL_SGIX_pixel_texture +#define GL_SGIX_pixel_texture 1 + +GLAPI void APIENTRY glPixelTexGenSGIX(GLenum mode); + +#endif /* GL_SGIX_pixel_texture */ + + + +/* + * 15. GL_SGIS_pixel_texture + */ +#ifndef GL_SGIS_pixel_texture +#define GL_SGIS_pixel_texture 1 + +#define GL_PIXEL_TEXTURE_SGIS ? +#define GL_PIXEL_FRAGMENT_RGB_SOURCE_SGIS ? +#define GL_PIXEL_FRAGMENT_ALPHA_SOURCE_SGIS ? +#define GL_PIXEL_GROUP_COLOR_SGIS ? + +GLAPI void APIENTRY glPixelTexGenParameterfSGIS(GLenum target, GLfloat value); + +GLAPI void APIENTRY glPixelTexGenParameterfvSGIS(GLenum target, const GLfloat *value); + +GLAPI void APIENTRY glPixelTexGenParameteriSGIS(GLenum target, GLint value); + +GLAPI void APIENTRY glPixelTexGenParameterivSGIS(GLenum target, const GLint *value); + +GLAPI void APIENTRY glGetPixelTexGenParameterfvSGIS(GLenum target, GLfloat *value); + +GLAPI void APIENTRY glGetPixelTexGenParameterivSGIS(GLenum target, GLint *value); + +#endif /* GL_SGIS_pixel_texture */ + + + +/* + * 16. GL_SGIS_texture4D + */ +#ifndef GL_SGIS_texture4D +#define GL_SGIS_texture4D 1 + +#define GL_PACK_SKIP_VOLUMES_SGIS ? +#define GL_PACK_IMAGE_DEPTH_SGIS ? +#define GL_UNPACK_SKIP_VOLUMES_SGIS ? +#define GL_UNPACK_IMAGE_DEPTH_SGIS ? +#define GL_TEXTURE_4D_SGIS ? +#define GL_PROXY_TEXTURE_4D_SGIS ? +#define GL_TEXTURE_4DSIZE_SGIS ? +#define GL_TEXTURE_WRAP_Q_SGIS ? +#define GL_MAX_4D_TEXTURE_SIZE_SGIS ? +#define GL_TEXTURE_4D_BINDING_SGIS ? + +GLAPI void APIENTRY glTexImage4DSGIS(GLenum target, GLint level, GLint internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLsizei extent, GLint border, GLenum format, GLenum type, const void *pixels); + +GLAPI void APIENTRY glTexSubImage4DSGIS(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint woffset, GLsizei width, GLsizei height, GLsizei depth, GLsizei extent, GLenum format, GLenum type, const void *pixels); + +#endif /* GL_SGIS_texture4D */ + + + +/* + * 20. GL_EXT_texture_object + */ +#ifndef GL_EXT_texture_object +#define GL_EXT_texture_object 1 + +#define GL_TEXTURE_PRIORITY_EXT 0x8066 +#define GL_TEXTURE_RESIDENT_EXT 0x8067 +#define GL_TEXTURE_1D_BINDING_EXT 0x8068 +#define GL_TEXTURE_2D_BINDING_EXT 0x8069 + +GLAPI void APIENTRY glGenTexturesEXT(GLsizei n, GLuint *textures); + +GLAPI void APIENTRY glDeleteTexturesEXT(GLsizei n, const GLuint *textures); + +GLAPI void APIENTRY glBindTextureEXT(GLenum target, GLuint texture); + +GLAPI void APIENTRY glPrioritizeTexturesEXT(GLsizei n, const GLuint *textures, const GLclampf *priorities); + +GLAPI GLboolean APIENTRY glAreTexturesResidentEXT(GLsizei n, const GLuint *textures, GLboolean *residences); + +GLAPI GLboolean APIENTRY glIsTextureEXT(GLuint texture); + +#endif /* GL_EXT_texture_object */ + + + +/* + * 21. GL_SGIS_detail_texture + */ +#ifndef GL_SGIS_detail_texture +#define GL_SGIS_detail_texture + +#define GL_DETAIL_TEXTURE_2D_SGIS 0x8095 +#define GL_DETAIL_TEXTURE_2D_BINDING_SGIS 0x8096 +#define GL_LINEAR_DETAIL_SGIS 0x8097 +#define GL_LINEAR_DETAIL_ALPHA_SGIS 0x8098 +#define GL_LINEAR_DETAIL_COLOR_SGIS 0x8099 +#define GL_DETAIL_TEXTURE_LEVEL_SGIS 0x809A +#define GL_DETAIL_TEXTURE_MODE_SGIS 0x809B + +GLAPI void APIENTRY glDetailTexFuncSGIS(GLenum target, GLsizei n, const GLfloat *points); + +GLAPI void APIENTRY glGetDetailTexFuncSGIS(GLenum target, GLfloat *points); + +#endif /* GL_SGIS_detail_texture */ + + + +/* + * 22. GL_SGIS_sharpen_texture + */ +#ifndef GL_SGIS_sharpen_texture +#define GL_SGIS_sharpen_texture 1 + +#define GL_LINEAR_SHARPEN_SGIS 0x80AD +#define GL_LINEAR_SHARPEN_ALPHA_SGIS 0x80AE +#define GL_LINEAR_SHARPEN_COLOR_SGIS 0x80AF +#define GL_SHARPEN_TEXTURE_FUNC_POINTS_SGIS 0x80B0 + +GLAPI void APIENTRY glGetSharpenTexFuncSGIS(GLenum target, GLfloat *points); + +GLAPI void APIENTRY glSharpenTexFuncSGIS(GLenum target, GLsizei n, const GLfloat *points); + +#endif /* GL_SGIS_sharpen_texture */ + + + +/* + * 23. GL_EXT_packed_pixels + */ +#ifndef GL_EXT_packed_pixels +#define GL_EXT_packed_pixels 1 + +#define GL_UNSIGNED_BYTE_3_3_2_EXT 0x8032 +#define GL_UNSIGNED_SHORT_4_4_4_4_EXT 0x8033 +#define GL_UNSIGNED_SHORT_5_5_5_1_EXT 0x8034 +#define GL_UNSIGNED_INT_8_8_8_8_EXT 0x8035 +#define GL_UNSIGNED_INT_10_10_10_2_EXT 0x8036 + +#endif /* GL_EXT_packed_pixels */ + + + +/* + * 25. GL_SGIS_multisample + */ + +#ifndef GL_SGIS_multisample +#define GL_SGIS_multisample 1 + +#define GL_MULTISAMPLE_SGIS 0x809D +#define GL_SAMPLE_ALPHA_TO_MASK_SGIS 0x809E +#define GL_SAMPLE_ALPHA_TO_ONE_SGIS 0x809F +#define GL_SAMPLE_MASK_SGIS 0x80A0 +#define GL_MULTISAMPLE_BIT_EXT 0x20000000 +#define GL_1PASS_SGIS 0x80A1 +#define GL_2PASS_0_SGIS 0x80A2 +#define GL_2PASS_1_SGIS 0x80A3 +#define GL_4PASS_0_SGIS 0x80A4 +#define GL_4PASS_1_SGIS 0x80A5 +#define GL_4PASS_2_SGIS 0x80A6 +#define GL_4PASS_3_SGIS 0x80A7 +#define GL_SAMPLE_BUFFERS_SGIS 0x80A8 +#define GL_SAMPLES_SGIS 0x80A9 +#define GL_SAMPLE_MASK_VALUE_SGIS 0x80AA +#define GL_SAMPLE_MASK_INVERT_SGIS 0x80AB +#define GL_SAMPLE_PATTERN_SGIS 0x80AC + +GLAPI void APIENTRY glSampleMaskSGIS(GLclampf value, GLboolean invert); + +GLAPI void APIENTRY glSamplePatternSGIS(GLenum pattern); + +#endif /* GL_SGIS_multisample */ + + + +/* + * 27. GL_EXT_rescale_normal + */ +#ifndef GL_EXT_rescale_normal +#define GL_EXT_rescale_normal 1 + +#define GL_RESCALE_NORMAL_EXT 0x803A + +#endif /* GL_EXT_rescale_normal */ + + + +/* + * 30. GL_EXT_vertex_array + */ +#ifndef GL_EXT_vertex_array +#define GL_EXT_vertex_array 1 + +#define GL_VERTEX_ARRAY_EXT 0x8074 +#define GL_NORMAL_ARRAY_EXT 0x8075 +#define GL_COLOR_ARRAY_EXT 0x8076 +#define GL_INDEX_ARRAY_EXT 0x8077 +#define GL_TEXTURE_COORD_ARRAY_EXT 0x8078 +#define GL_EDGE_FLAG_ARRAY_EXT 0x8079 +#define GL_VERTEX_ARRAY_SIZE_EXT 0x807A +#define GL_VERTEX_ARRAY_TYPE_EXT 0x807B +#define GL_VERTEX_ARRAY_STRIDE_EXT 0x807C +#define GL_VERTEX_ARRAY_COUNT_EXT 0x807D +#define GL_NORMAL_ARRAY_TYPE_EXT 0x807E +#define GL_NORMAL_ARRAY_STRIDE_EXT 0x807F +#define GL_NORMAL_ARRAY_COUNT_EXT 0x8080 +#define GL_COLOR_ARRAY_SIZE_EXT 0x8081 +#define GL_COLOR_ARRAY_TYPE_EXT 0x8082 +#define GL_COLOR_ARRAY_STRIDE_EXT 0x8083 +#define GL_COLOR_ARRAY_COUNT_EXT 0x8084 +#define GL_INDEX_ARRAY_TYPE_EXT 0x8085 +#define GL_INDEX_ARRAY_STRIDE_EXT 0x8086 +#define GL_INDEX_ARRAY_COUNT_EXT 0x8087 +#define GL_TEXTURE_COORD_ARRAY_SIZE_EXT 0x8088 +#define GL_TEXTURE_COORD_ARRAY_TYPE_EXT 0x8089 +#define GL_TEXTURE_COORD_ARRAY_STRIDE_EXT 0x808A +#define GL_TEXTURE_COORD_ARRAY_COUNT_EXT 0x808B +#define GL_EDGE_FLAG_ARRAY_STRIDE_EXT 0x808C +#define GL_EDGE_FLAG_ARRAY_COUNT_EXT 0x808D +#define GL_VERTEX_ARRAY_POINTER_EXT 0x808E +#define GL_NORMAL_ARRAY_POINTER_EXT 0x808F +#define GL_COLOR_ARRAY_POINTER_EXT 0x8090 +#define GL_INDEX_ARRAY_POINTER_EXT 0x8091 +#define GL_TEXTURE_COORD_ARRAY_POINTER_EXT 0x8092 +#define GL_EDGE_FLAG_ARRAY_POINTER_EXT 0x8093 + +GLAPI void APIENTRY glVertexPointerEXT(GLint size, GLenum type, GLsizei stride, GLsizei count, const GLvoid *ptr); + +GLAPI void APIENTRY glNormalPointerEXT(GLenum type, GLsizei stride, GLsizei count, const GLvoid *ptr); + +GLAPI void APIENTRY glColorPointerEXT(GLint size, GLenum type, GLsizei stride, GLsizei count, const GLvoid *ptr); + +GLAPI void APIENTRY glIndexPointerEXT(GLenum type, GLsizei stride, GLsizei count, const GLvoid *ptr); + +GLAPI void APIENTRY glTexCoordPointerEXT(GLint size, GLenum type, GLsizei stride, GLsizei count, const GLvoid *ptr); + +GLAPI void APIENTRY glEdgeFlagPointerEXT(GLsizei stride, GLsizei count, const GLboolean *ptr); + +GLAPI void APIENTRY glGetPointervEXT(GLenum pname, void **params); + +GLAPI void APIENTRY glArrayElementEXT(GLint i); + +GLAPI void APIENTRY glDrawArraysEXT(GLenum mode, GLint first, GLsizei count); + +typedef void (APIENTRY * PFNGLARRAYELEMENTEXTPROC) (GLint i); +typedef void (APIENTRY * PFNGLCOLORPOINTEREXTPROC) (GLint size, GLenum type, GLsizei stride, GLsizei count, const GLvoid *pointer); +typedef void (APIENTRY * PFNGLDRAWARRAYSEXTPROC) (GLenum mode, GLint first, GLsizei count); +typedef void (APIENTRY * PFNGLEDGEFLAGPOINTEREXTPROC) (GLsizei stride, GLsizei count, const GLboolean *pointer); +typedef void (APIENTRY * PFNGLGETPOINTERVEXTPROC) (GLenum pname, GLvoid* *params); +typedef void (APIENTRY * PFNGLINDEXPOINTEREXTPROC) (GLenum type, GLsizei stride, GLsizei count, const GLvoid *pointer); +typedef void (APIENTRY * PFNGLNORMALPOINTEREXTPROC) (GLenum type, GLsizei stride, GLsizei count, const GLvoid *pointer); +typedef void (APIENTRY * PFNGLTEXCOORDPOINTEREXTPROC) (GLint size, GLenum type, GLsizei stride, GLsizei count, const GLvoid *pointer); +typedef void (APIENTRY * PFNGLVERTEXPOINTEREXTPROC) (GLint size, GLenum type, GLsizei stride, GLsizei count, const GLvoid *pointer); + +#endif /* GL_EXT_vertex_array */ + + + +/* + * 35. GL_SGIS_texture_edge_clamp + */ +#ifndef GL_SGIS_texture_edge_clamp +#define GL_SGIS_texture_edge_clamp 1 + +#define GL_CLAMP_TO_EDGE_SGIS 0x812F + +#endif /* GL_SGIS_texture_edge_clamp */ + + + +/* + * 37. GL_EXT_blend_minmax + */ +#ifndef GL_EXT_blend_minmax +#define GL_EXT_blend_minmax 1 + +#define GL_FUNC_ADD_EXT 0x8006 +#define GL_MIN_EXT 0x8007 +#define GL_MAX_EXT 0x8008 +#define GL_BLEND_EQUATION_EXT 0x8009 + +GLAPI void APIENTRY glBlendEquationEXT(GLenum mode); + +#endif /* GL_EXT_blend_minmax */ + + + +/* + * 38. GL_EXT_blend_subtract (requires GL_EXT_blend_max) + */ +#ifndef GL_EXT_blend_subtract +#define GL_EXT_blend_subtract 1 + +#define GL_FUNC_SUBTRACT_EXT 0x800A +#define GL_FUNC_REVERSE_SUBTRACT_EXT 0x800B + +#endif /* GL_EXT_blend_subtract */ + + + +/* + * 39. GL_EXT_blend_logic_op + */ +#ifndef GL_EXT_blend_logic_op +#define GL_EXT_blend_logic_op 1 + +/* No new tokens or functions */ + +#endif /* GL_EXT_blend_logic_op */ + + + +/* + * 52. GL_SGIX_sprite + */ +#ifndef GL_SGIX_sprite +#define GL_SGIX_sprite 1 + +#define GL_SPRITE_SGIX 0x8148 +#define GL_SPRITE_MODE_SGIX 0x8149 +#define GL_SPRITE_AXIS_SGIX 0x814A +#define GL_SPRITE_TRANSLATION_SGIX 0x814B +#define GL_SPRITE_AXIAL_SGIX 0x814C +#define GL_SPRITE_OBJECT_ALIGNED_SGIX 0x814D +#define GL_SPRITE_EYE_ALIGNED_SGIX 0x814E + +GLAPI void APIENTRY glSpriteParameterfSGIX(GLenum pname, GLfloat param); + +GLAPI void APIENTRY glSpriteParameterfvSGIX(GLenum pname, const GLfloat *param); + +GLAPI void APIENTRY glSpriteParameteriSGIX(GLenum pname, GLint param); + +GLAPI void APIENTRY glSpriteParameterivSGIX(GLenum pname, const GLint *param); + +#endif /* GL_SGIX_sprite */ + + + +/* + * 54. GL_EXT_point_parameters + */ +#ifndef GL_EXT_point_parameters +#define GL_EXT_point_parameters 1 + +#define GL_POINT_SIZE_MIN_EXT 0x8126 +#define GL_POINT_SIZE_MAX_EXT 0x8127 +#define GL_POINT_FADE_THRESHOLD_SIZE_EXT 0x8128 +#define GL_DISTANCE_ATTENUATION_EXT 0x8129 + +GLAPI void APIENTRY glPointParameterfEXT(GLenum pname, GLfloat param); +GLAPI void APIENTRY glPointParameterfvEXT(GLenum pname, const GLfloat *params); + +typedef void (APIENTRY * PFNGLPOINTPARAMETERFEXTPROC) (GLenum pname, GLfloat param); +typedef void (APIENTRY * PFNGLPOINTPARAMETERFVEXTPROC) (GLenum pname, const GLfloat *params); + +#endif /* GL_EXT_point_parameters */ + + + +/* + * 55. GL_SGIX_instruments + */ +#ifndef GL_SGIX_instruments +#define GL_SGIX_instruments 1 + +#define GL_INSTRUMENT_BUFFER_POINTER_SGIX 0x8180 +#define GL_INSTRUMENT_MEASUREMENTS_SGIX 0x8181 + +GLAPI GLint APIENTRY glGetInstrumentsSGIX(void); + +GLAPI void APIENTRY glInstrumentsBufferSGIX(GLsizei size, GLint *buf); + +GLAPI GLint APIENTRY glPollInstrumentsSGIX(GLint *markerp); + +GLAPI void APIENTRY glReadInstrumentsSGIX(GLint marker); + +GLAPI void APIENTRY glStartInstrumentsSGIX(void); + +GLAPI void APIENTRY glStopInstrumentsSGIX(GLint marker); + +#endif + + +/* + * 57. GL_SGIX_framezoom + */ +#ifndef GL_SGIX_framezoom +#define GL_SGIX_framezoom 1 + +#define GL_FRAMEZOOM_SGIX 0x818B +#define GL_FRAMEZOOM_FACTOR_SGIX 0x818C +#define GL_MAX_FRAMEZOOM_FACTOR_SGIX 0x818D + +GLAPI void APIENTRY glFrameZoomSGIX(GLint factor); + +#endif /* GL_SGIX_framezoom */ + + + +/* + * 58. GL_SGIX_tag_sample_buffer + */ +#ifndef GL_SGIX_tag_sample_buffer +#define GL_SGIX_tag_sample_buffer 1 + +GLAPI void APIENTRY glTagSampleBufferSGIX(void); + +#endif /* GL_SGIX_tag_sample_buffer */ + + + +/* + * 60. GL_SGIX_reference_plane + */ +#ifndef GL_SGIX_reference_plane +#define GL_SGIX_reference_plane 1 + +#define GL_REFERENCE_PLANE_SGIX 0x817D +#define GL_REFERENCE_PLANE_EQUATION_SGIX 0x817E + +GLAPI void APIENTRY glReferencePlaneSGIX(const GLdouble *plane); + +#endif /* GL_SGIX_reference_plane */ + + + +/* + * 61. GL_SGIX_flush_raster + */ +#ifndef GL_SGIX_flush_raster +#define GL_SGIX_flush_raster 1 + +GLAPI void APIENTRY glFlushRasterSGIX(void); + +#endif /* GL_SGIX_flush_raster */ + + + +/* + * 74. GL_EXT_color_subtable + */ + +#ifndef GL_EXT_color_subtable +#define GL_EXT_color_subtable 1 + +#ifndef GL_EXT_paletted_texture +GLAPI void APIENTRY glColorSubTableEXT(GLenum target, GLsizei start, GLsizei count, GLenum format, GLenum type, const void *data); +#endif + +GLAPI void APIENTRY glCopyColorSubTableEXT(GLenum target, GLsizei start, GLint x, GLint y, GLsizei width); + +#endif + + +/* + * 77. GL_PGI_misc_hints + */ +#ifndef GL_PGI_misc_hints +#define GL_PGI_misc_hints 1 + +#define GL_PREFER_DOUBLEBUFFER_HINT_PGI 107000 +#define GL_STRICT_DEPTHFUNC_HINT_PGI 107030 +#define GL_STRICT_LIGHTING_HINT_PGI 107031 +#define GL_STRICT_SCISSOR_HINT_PGI 107032 +#define GL_FULL_STIPPLE_HINT_PGI 107033 +#define GL_NATIVE_GRAPHICS_BEGIN_HINT_PGI 107011 +#define GL_NATIVE_GRAPHICS_END_HINT_PGI 107012 +#define GL_CONSERVE_MEMORY_HINT_PGI 107005 +#define GL_RECLAIM_MEMORY_HINT_PGI 107006 +#define GL_ALWAYS_FAST_HINT_PGI 107020 +#define GL_ALWAYS_SOFT_HINT_PGI 107021 +#define GL_ALLOW_DRAW_OBJ_HINT_PGI 107022 +#define GL_ALLOW_DRAW_WIN_HINT_PGI 107023 +#define GL_ALLOW_DRAW_FRG_HINT_PGI 107024 +#define GL_ALLOW_DRAW_SPN_HINT_PGI 107024 +#define GL_ALLOW_DRAW_MEM_HINT_PGI 107025 +#define GL_CLIP_NEAR_HINT_PGI 107040 +#define GL_CLIP_FAR_HINT_PGI 107041 +#define GL_WIDE_LINE_HINT_PGI 107042 +#define GL_BACK_NORMALS_HINT_PGI 107043 +#define GL_NATIVE_GRAPHICS_HANDLE_PGI 107010 + +GLAPI void APIENTRY glHintPGI(GLenum target, GLint mode); + +#endif /* GL_PGI_misc_hints */ + + + +/* + * 78. GL_EXT_paletted_texture + */ +#ifndef GL_EXT_paletted_texture +#define GL_EXT_paletted_texture 1 + +#define GL_TABLE_TOO_LARGE_EXT 0x8031 +#define GL_COLOR_TABLE_FORMAT_EXT 0x80D8 +#define GL_COLOR_TABLE_WIDTH_EXT 0x80D9 +#define GL_COLOR_TABLE_RED_SIZE_EXT 0x80DA +#define GL_COLOR_TABLE_GREEN_SIZE_EXT 0x80DB +#define GL_COLOR_TABLE_BLUE_SIZE_EXT 0x80DC +#define GL_COLOR_TABLE_ALPHA_SIZE_EXT 0x80DD +#define GL_COLOR_TABLE_LUMINANCE_SIZE_EXT 0x80DE +#define GL_COLOR_TABLE_INTENSITY_SIZE_EXT 0x80DF +#define GL_TEXTURE_INDEX_SIZE_EXT 0x80ED +#define GL_COLOR_INDEX1_EXT 0x80E2 +#define GL_COLOR_INDEX2_EXT 0x80E3 +#define GL_COLOR_INDEX4_EXT 0x80E4 +#define GL_COLOR_INDEX8_EXT 0x80E5 +#define GL_COLOR_INDEX12_EXT 0x80E6 +#define GL_COLOR_INDEX16_EXT 0x80E7 + +GLAPI void APIENTRY glColorTableEXT(GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const GLvoid *table); + +/* Already prototyped by extension 74: +GLAPI void APIENTRY glColorSubTableEXT(GLenum target, GLsizei start, GLsizei count, GLenum format, GLenum type, const GLvoid *data); +*/ + +GLAPI void APIENTRY glGetColorTableEXT(GLenum target, GLenum format, GLenum type, GLvoid *table); + +GLAPI void APIENTRY glGetColorTableParameterfvEXT(GLenum target, GLenum pname, GLfloat *params); + +GLAPI void APIENTRY glGetColorTableParameterivEXT(GLenum target, GLenum pname, GLint *params); + +#endif /* GL_EXT_paletted_texture */ + + + +/* + * 79. GL_EXT_clip_volume_hint + */ +#ifndef GL_EXT_clip_volume_hint +#define GL_EXT_clip_volume_hint 1 + +#define GL_CLIP_VOLUME_CLIPPING_HINT_EXT 0x80F + +#endif /* GL_EXT_clip_volume_hint */ + + + +/* + * 80. GL_SGIX_list_priority + */ +#ifndef GL_SGIX_list_priority +#define GL_SGIX_list_priority 1 + +#define GL_LIST_PRIORITY_SGIX 0x8182 + +GLAPI void APIENTRY glGetListParameterfvSGIX(GLuint list, GLenum name, GLfloat *param); + +GLAPI void APIENTRY glGetListParameterivSGIX(GLuint list, GLenum name, GLint *param); + +GLAPI void APIENTRY glListParameterfSGIX(GLuint list, GLenum name, GLfloat param); + +GLAPI void APIENTRY glListParameterfvSGIX(GLuint list, GLenum name, const GLfloat *param); + +GLAPI void APIENTRY glListParameteriSGIX(GLuint list, GLenum name, GLint param); + +GLAPI void APIENTRY glListParameterivSGIX(GLuint list, GLenum name, const GLint *param); + +#endif /* GL_SGIX_list_priority */ + + + +/* + * 94. GL_EXT_index_material + */ +#ifndef GL_EXT_index_material +#define GL_EXT_index_material 1 + +#define GL_INDEX_MATERIAL_EXT ? +#define GL_INDEX_MATERIAL_PARAMETER_EXT ? +#define GL_INDEX_MATERIAL_FACE_EXT ? + +GLAPI void APIENTRY glIndexMaterialEXT(GLenum face, GLenum mode); + +#endif /* GL_EXT_index_material */ + + + +/* + * 95. GL_EXT_index_func + */ +#ifndef GL_EXT_index_func +#define GL_EXT_index_func 1 + +#define GL_INDEX_TEST_EXT ? +#define GL_INDEX_TEST_FUNC_EXT ? +#define GL_INDEX_TEST_REF_EXT ? + +GLAPI void APIENTRY glIndexFuncEXT(GLenum func, GLfloat ref); + +#endif /* GL_EXT_index_func */ + + + +/* + * 97. GL_EXT_compiled_vertex_array + */ +#ifndef GL_EXT_compiled_vertex_array +#define GL_EXT_compiled_vertex_array 1 + +#define GL_ARRAY_ELEMENT_LOCK_FIRST_EXT 0x81A8 +#define GL_ARRAY_ELEMENT_LOCK_COUNT_EXT 0x81A9 + +GLAPI void APIENTRY glLockArraysEXT(GLint first, GLsizei count); +GLAPI void APIENTRY glUnlockArraysEXT(void); + +typedef void (APIENTRY * PFNGLLOCKARRAYSEXTPROC) (GLint first, GLsizei count); +typedef void (APIENTRY * PFNGLUNLOCKARRAYSEXTPROC) (void); + +#endif /* GL_EXT_compiled_vertex_array */ + + + +/* + * 98. GL_EXT_cull_vertex + */ +#ifndef GL_EXT_cull_vertex +#define GL_EXT_cull_vertex 1 + +#define GL_CULL_VERTEX_EXT 0x81AA +#define GL_CULL_VERTEX_EYE_POSITION_EXT 0x81AB +#define GL_CULL_VERTEX_OBJECT_POSITION_EXT 0x81AC + +GLAPI void APIENTRY glCullParameterdvEXT(GLenum pname, const GLdouble *params); +GLAPI void APIENTRY glCullParameterfvEXT(GLenum pname, const GLfloat *params); + +typedef void (APIENTRY * PFNGLCULLPARAMETERDVEXTPROC) (GLenum pname, GLdouble* params); +typedef void (APIENTRY * PFNGLCULLPARAMETERFVEXTPROC) (GLenum pname, GLfloat* params); + +#endif /* GL_EXT_cull_vertex */ + + + +/* + * 102. GL_SGIX_fragment_lighting + */ +#ifndef GL_SGIX_fragment_lighting +#define GL_SGIX_fragment_lighting 1 + +GLAPI void APIENTRY glFragmentColorMaterialSGIX(GLenum face, GLenum mode); + +GLAPI void APIENTRY glFragmentLightfSGIX(GLenum light, GLenum pname, GLfloat param); + +GLAPI void APIENTRY glFragmentLightfvSGIX(GLenum light, GLenum pname, const GLfloat * params); + +GLAPI void APIENTRY glFragmentLightiSGIX(GLenum light, GLenum pname, GLint param); + +GLAPI void APIENTRY glFragmentLightivSGIX(GLenum light, GLenum pname, const GLint * params); + +GLAPI void APIENTRY glFragmentLightModelfSGIX(GLenum pname, GLfloat param); + +GLAPI void APIENTRY glFragmentLightModelfvSGIX(GLenum pname, const GLfloat * params); + +GLAPI void APIENTRY glFragmentLightModeliSGIX(GLenum pname, GLint param); + +GLAPI void APIENTRY glFragmentLightModelivSGIX(GLenum pname, const GLint * params); + +GLAPI void APIENTRY glFragmentMaterialfSGIX(GLenum face, GLenum pname, GLfloat param); + +GLAPI void APIENTRY glFragmentMaterialfvSGIX(GLenum face, GLenum pname, const GLfloat * params); + +GLAPI void APIENTRY glFragmentMaterialiSGIX(GLenum face, GLenum pname, GLint param); + +GLAPI void APIENTRY glFragmentMaterialivSGIX(GLenum face, GLenum pname, const GLint * params); + +GLAPI void APIENTRY glGetFragmentLightfvSGIX(GLenum light, GLenum pname, GLfloat * params); + +GLAPI void APIENTRY glGetFragmentLightivSGIX(GLenum light, GLenum pname, GLint * params); + +GLAPI void APIENTRY glGetFragmentMaterialfvSGIX(GLenum face, GLenum pname, GLfloat * params); + +GLAPI void APIENTRY glGetFragmentMaterialivSGIX(GLenum face, GLenum pname, GLint * params); + +GLAPI void APIENTRY glLightEnviSGIX(GLenum pname, GLint param); + +#endif /* GL_SGIX_fragment_lighting */ + + + +/* + * 129. GL_EXT_bgra + */ +#ifndef GL_EXT_bgra +#define GL_EXT_bgra 1 + +#define GL_BGR_EXT 0x80E0 +#define GL_BGRA_EXT 0x80E1 + +#endif /* GL_EXT_bgra */ + + + +/* + * 141. GL_EXT_shared_texture_palette (req's GL_EXT_paletted_texture) + */ +#ifndef GL_EXT_shared_texture_palette +#define GL_EXT_shared_texture_palette 1 + +#define GL_SHARED_TEXTURE_PALETTE_EXT 0x81FB + +#endif /* GL_EXT_shared_texture_palette */ + + + +/* + * 149. GL_EXT_fog_coord + */ +#ifndef GL_EXT_fog_coord +#define GL_EXT_fog_coord 1 + +#define GL_FOG_COORDINATE_SOURCE_EXT 0x8450 +#define GL_FOG_COORDINATE_EXT 0x8451 +#define GL_FRAGMENT_DEPTH_EXT 0x8452 +#define GL_CURRENT_FOG_COORDINATE_EXT 0x8453 +#define GL_FOG_COORDINATE_ARRAY_TYPE_EXT 0x8454 +#define GL_FOG_COORDINATE_ARRAY_STRIDE_EXT 0x8455 +#define GL_FOG_COORDINATE_ARRAY_POINTER_EXT 0x8456 +#define GL_FOG_COORDINATE_ARRAY_EXT 0x8457 + +GLAPI void APIENTRY glFogCoordfEXT(GLfloat coord); + +GLAPI void APIENTRY glFogCoordfvEXT(const GLfloat * coord); + +GLAPI void APIENTRY glFogCoorddEXT(GLdouble coord); + +GLAPI void APIENTRY glFogCoorddvEXT(const GLdouble * coord); + +GLAPI void APIENTRY glFogCoordPointerEXT(GLenum type, GLsizei stride, const GLvoid * pointer); + +#endif + + + +/* + * 158. GL_EXT_texture_env_combine + */ +#ifndef GL_EXT_texture_env_combine +#define GL_EXT_texture_env_combine 1 + +#define GL_COMBINE_EXT 0x8570 +#define GL_COMBINE_RGB_EXT 0x8571 +#define GL_COMBINE_ALPHA_EXT 0x8572 +#define GL_RGB_SCALE_EXT 0x8573 +#define GL_ADD_SIGNED_EXT 0x8574 +#define GL_INTERPOLATE_EXT 0x8575 +#define GL_CONSTANT_EXT 0x8576 +#define GL_PRIMARY_COLOR_EXT 0x8577 +#define GL_PREVIOUS_EXT 0x8578 +#define GL_SOURCE0_RGB_EXT 0x8580 +#define GL_SOURCE1_RGB_EXT 0x8581 +#define GL_SOURCE2_RGB_EXT 0x8582 +#define GL_SOURCE0_ALPHA_EXT 0x8588 +#define GL_SOURCE1_ALPHA_EXT 0x8589 +#define GL_SOURCE2_ALPHA_EXT 0x858A +#define GL_OPERAND0_RGB_EXT 0x8590 +#define GL_OPERAND1_RGB_EXT 0x8591 +#define GL_OPERAND2_RGB_EXT 0x8592 +#define GL_OPERAND0_ALPHA_EXT 0x8598 +#define GL_OPERAND1_ALPHA_EXT 0x8599 +#define GL_OPERAND2_ALPHA_EXT 0x859A + +#endif /* GL_EXT_texture_env_combine */ + + + +/* + * 173. GL_EXT_blend_func_separate + */ +#ifndef GL_EXT_blend_func_separate +#define GL_EXT_blend_func_separate 1 + +#define GL_BLEND_DST_RGB_EXT 0x80C8 +#define GL_BLEND_SRC_RGB_EXT 0x80C9 +#define GL_BLEND_DST_ALPHA_EXT 0x80CA +#define GL_BLEND_SRC_ALPHA_EXT 0x80CB + +GLAPI void APIENTRY glBlendFuncSeparateEXT(GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha); + +#endif /* GL_EXT_blend_func_separate */ + + + +/* + * 173. GL_INGR_blend_func_separate + */ +#ifndef GL_INGR_blend_func_separate +#define GL_INGR_blend_func_separate 1 + +#define GL_BLEND_DST_RGB_INGR 0x80C8 +#define GL_BLEND_SRC_RGB_INGR 0x80C9 +#define GL_BLEND_DST_ALPHA_INGR 0x80CA +#define GL_BLEND_SRC_ALPHA_INGR 0x80CB + +GLAPI void APIENTRY glBlendFuncSeparateINGR(GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha); + +#endif /* GL_INGR_blend_func_separate */ + + + +/* + * 176. GL_EXT_stencil_wrap + */ +#ifndef GL_EXT_stencil_wrap +#define GL_EXT_stencil_wrap 1 + +#define GL_INCR_WRAP_EXT 0x8507 +#define GL_DECR_WRAP_EXT 0x8508 + +#endif /* GL_EXT_stencil_wrap */ + + + +/* + * 179. GL_NV_texgen_reflection + */ +#ifndef GL_NV_texgen_reflection +#define GL_NV_texgen_reflection 1 + +#define GL_NORMAL_MAP_NV 0x8511 +#define GL_REFLECTION_MAP_NV 0x8512 + +#endif /* GL_NV_texgen_reflection */ + + + +/* + * 185. GL_EXT_texture_env_add + */ +#ifndef GL_EXT_texture_env_add +#define GL_EXT_texture_env_add 1 + +/* No new tokens or functions */ + +#endif /* GL_EXT_texture_env_add */ + + + +/* + * ??. GL_WIN_swap_hint + */ +#ifndef GL_WIN_swap_hint +#define GL_WIN_swap_hint 1 + +GLAPI void APIENTRY glAddSwapHintRectWIN(GLint x, GLint y, GLsizei width, GLsizei height); + +typedef void (APIENTRY * PFNGLADDSWAPHINTRECTWINPROC) (GLint x, GLint y, GLsizei width, GLsizei height); + +#endif /* GL_WIN_swap_hint */ + + + +/* + * 188. GL_EXT_vertex_weighting + */ +#ifndef GL_EXT_vertex_weighting +#define GL_EXT_vertex_weighting 1 + +#define GL_VERTEX_WEIGHTING_EXT 0x8509 +#define GL_MODELVIEW0_EXT 0x1700 +#define GL_MODELVIEW1_EXT 0x850a +#define GL_CURRENT_VERTEX_WEIGHT_EXT 0x850b +#define GL_VERTEX_WEIGHT_ARRAY_EXT 0x850c +#define GL_VERTEX_WEIGHT_ARRAY_SIZE_EXT 0x850d +#define GL_VERTEX_WEIGHT_ARRAY_TYPE_EXT 0x850e +#define GL_VERTEX_WEIGHT_ARRAY_STRIDE_EXT 0x850f +#define GL_MODELVIEW0_STACK_DEPTH_EXT 0x0BA3 +#define GL_MODELVIEW1_STACK_DEPTH_EXT 0x8502 +#define GL_VERTEX_WEIGHT_ARRAY_POINTER_EXT 0x8510 + +GLAPI void APIENTRY glVertexWeightfEXT(GLfloat weight); + +GLAPI void APIENTRY glVertexWeightfvEXT(const GLfloat *weight); + +GLAPI void APIENTRY glVertexWeightPointerEXT(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer); + +#endif + + + +/* + * 189. GL_NV_light_max_exponent + */ +#ifndef GL_NV_light_max_exponent +#define GL_NV_light_max_exponent 1 + +#define GL_MAX_SHININESS_NV 0x8507 +#define GL_MAX_SPOT_EXPONENT_NV 0x8508 + +#endif + + + +/* + * 190. GL_NV_vertex_array_range + */ +#ifndef GL_NV_vertex_array_range +#define GL_NV_vertex_array_range 1 + +/* TOKENS? */ + +GLAPI void APIENTRY glFlushVertexArrayRangeNV(void); + +GLAPI void APIENTRY glVertexArrayRangeNV(GLsizei size, const GLvoid * pointer); + +#endif + + + +/* + * 191. GL_NV_register_combiners + */ +#ifndef GL_NV_register_combiners +#define GL_NV_register_combiners 1 + +/* TOKENS? */ + +GLAPI void APIENTRY glCombinerParameterfvNV(GLenum pname, const GLfloat * params); + +GLAPI void APIENTRY glCombinerParameterfNV(GLenum pname, GLfloat param); + +GLAPI void APIENTRY glCombinerParameterivNV(GLenum pname, const GLint * params); + +GLAPI void APIENTRY glCombinerParameteriNV(GLenum pname, GLint param); + +GLAPI void APIENTRY glCombinerInputNV(GLenum stage, GLenum portion, GLenum variable, GLenum input, GLenum mapping, GLenum componentUsage); + +GLAPI void APIENTRY glCombinerOutputNV(GLenum stage, GLenum portion, GLenum abOutput, GLenum cdOutput, GLenum sumOutput, GLenum scale, GLenum bias, GLboolean abDotProduct, GLboolean cdDotProduct, GLboolean muxSum); + +GLAPI void APIENTRY glFinalCombinerInputNV(GLenum variable, GLenum input, GLenum mapping, GLenum componentUsage); + +GLAPI void APIENTRY glGetCombinerInputParameterfvNV(GLenum stage, GLenum portion, GLenum variable, GLenum pname, GLfloat * params); + +GLAPI void APIENTRY glGetCombinerInputParameterivNV(GLenum stage, GLenum portion, GLenum variable, GLenum pname, GLint * params); + +GLAPI void APIENTRY glGetCombinerOutputParameterfvNV(GLenum stage, GLenum portion, GLenum pname, GLfloat * params); + +GLAPI void APIENTRY glGetCombinerOutputParameterivNV(GLenum stage, GLenum portion, GLenum pname, GLint * params); + +GLAPI void APIENTRY glGetFinalCombinerInputParameterfvNV(GLenum variable, GLenum pname, GLfloat * params); + +GLAPI void APIENTRY glGetFinalCombinerInputParameterivNV(GLenum variable, GLenum pname, GLint * params); + +#endif /* GL_NV_register_combiners */ + + + +/* + * 192. GL_NV_fog_distance + */ +#ifndef GL_NV_fog_distance +#define GL_NV_fog_distance 1 + +#define GL_FOG_DISTANCE_MODE_NV 0x855a +#define GL_EYE_RADIAL_NV 0x855b +#define GL_EYE_PLANE_ABSOLUTE_NV 0x855c + +#endif /* GL_NV_fog_distance*/ + + + +/* + * 194. GL_NV_blend_square + */ +#ifndef GL_NV_blend_square +#define GL_NV_blend_square 1 + +/* no tokens or functions */ + +#endif /* GL_NV_blend_square */ + + + +/* + * 195. GL_NV_texture_env_combine4 + */ +#ifndef GL_NV_texture_env_combine4 +#define GL_NV_texture_env_combine4 1 + +#define GL_COMBINE4_NV 0x8503 +#define GL_SOURCE3_RGB_NV 0x8583 +#define GL_SOURCE3_ALPHA_NV 0x858B +#define GL_OPERAND3_RGB_NV 0x8593 +#define GL_OPERAND3_ALPHA_NV 0x859B + +#endif /* GL_NV_texture_env_combine4 */ + + + +/* + * 196. GL_MESA_resize_bufffers + */ +#ifndef GL_MESA_resize_buffers +#define GL_MESA_resize_buffers 1 + +GLAPI void APIENTRY glResizeBuffersMESA(void); + +#endif /* GL_MESA_resize_bufffers */ + + + +/* + * 197. GL_MESA_window_pos + */ +#ifndef GL_MESA_window_pos +#define GL_MESA_window_pos 1 + +GLAPI void APIENTRY glWindowPos2iMESA(GLint x, GLint y); +GLAPI void APIENTRY glWindowPos2sMESA(GLshort x, GLshort y); +GLAPI void APIENTRY glWindowPos2fMESA(GLfloat x, GLfloat y); +GLAPI void APIENTRY glWindowPos2dMESA(GLdouble x, GLdouble y); +GLAPI void APIENTRY glWindowPos2ivMESA(const GLint *p); +GLAPI void APIENTRY glWindowPos2svMESA(const GLshort *p); +GLAPI void APIENTRY glWindowPos2fvMESA(const GLfloat *p); +GLAPI void APIENTRY glWindowPos2dvMESA(const GLdouble *p); +GLAPI void APIENTRY glWindowPos3iMESA(GLint x, GLint y, GLint z); +GLAPI void APIENTRY glWindowPos3sMESA(GLshort x, GLshort y, GLshort z); +GLAPI void APIENTRY glWindowPos3fMESA(GLfloat x, GLfloat y, GLfloat z); +GLAPI void APIENTRY glWindowPos3dMESA(GLdouble x, GLdouble y, GLdouble z); +GLAPI void APIENTRY glWindowPos3ivMESA(const GLint *p); +GLAPI void APIENTRY glWindowPos3svMESA(const GLshort *p); +GLAPI void APIENTRY glWindowPos3fvMESA(const GLfloat *p); +GLAPI void APIENTRY glWindowPos3dvMESA(const GLdouble *p); +GLAPI void APIENTRY glWindowPos4iMESA(GLint x, GLint y, GLint z, GLint w); +GLAPI void APIENTRY glWindowPos4sMESA(GLshort x, GLshort y, GLshort z, GLshort w); +GLAPI void APIENTRY glWindowPos4fMESA(GLfloat x, GLfloat y, GLfloat z, GLfloat w); +GLAPI void APIENTRY glWindowPos4dMESA(GLdouble x, GLdouble y, GLdouble z, GLdouble w); +GLAPI void APIENTRY glWindowPos4ivMESA(const GLint *p); +GLAPI void APIENTRY glWindowPos4svMESA(const GLshort *p); +GLAPI void APIENTRY glWindowPos4fvMESA(const GLfloat *p); +GLAPI void APIENTRY glWindowPos4dvMESA(const GLdouble *p); + +#endif /* GL_MESA_window_pos */ + + + +/* + * ARB 0. GL_ARB_multitexture + */ +#ifndef GL_ARB_multitexture +#define GL_ARB_multitexture 1 + +#define GL_TEXTURE0_ARB 0x84C0 +#define GL_TEXTURE1_ARB 0x84C1 +#define GL_TEXTURE2_ARB 0x84C2 +#define GL_TEXTURE3_ARB 0x84C3 +#define GL_TEXTURE4_ARB 0x84C4 +#define GL_TEXTURE5_ARB 0x84C5 +#define GL_TEXTURE6_ARB 0x84C6 +#define GL_TEXTURE7_ARB 0x84C7 +#define GL_TEXTURE8_ARB 0x84C8 +#define GL_TEXTURE9_ARB 0x84C9 +#define GL_TEXTURE10_ARB 0x84CA +#define GL_TEXTURE11_ARB 0x84CB +#define GL_TEXTURE12_ARB 0x84CC +#define GL_TEXTURE13_ARB 0x84CD +#define GL_TEXTURE14_ARB 0x84CE +#define GL_TEXTURE15_ARB 0x84CF +#define GL_TEXTURE16_ARB 0x84D0 +#define GL_TEXTURE17_ARB 0x84D1 +#define GL_TEXTURE18_ARB 0x84D2 +#define GL_TEXTURE19_ARB 0x84D3 +#define GL_TEXTURE20_ARB 0x84D4 +#define GL_TEXTURE21_ARB 0x84D5 +#define GL_TEXTURE22_ARB 0x84D6 +#define GL_TEXTURE23_ARB 0x84D7 +#define GL_TEXTURE24_ARB 0x84D8 +#define GL_TEXTURE25_ARB 0x84D9 +#define GL_TEXTURE26_ARB 0x84DA +#define GL_TEXTURE27_ARB 0x84DB +#define GL_TEXTURE28_ARB 0x84DC +#define GL_TEXTURE29_ARB 0x84DD +#define GL_TEXTURE30_ARB 0x84DE +#define GL_TEXTURE31_ARB 0x84DF +#define GL_ACTIVE_TEXTURE_ARB 0x84E0 +#define GL_CLIENT_ACTIVE_TEXTURE_ARB 0x84E1 +#define GL_MAX_TEXTURE_UNITS_ARB 0x84E2 + +GLAPI void GLAPIENTRY glActiveTextureARB(GLenum texture); +GLAPI void GLAPIENTRY glClientActiveTextureARB(GLenum texture); +GLAPI void GLAPIENTRY glMultiTexCoord1dARB(GLenum target, GLdouble s); +GLAPI void GLAPIENTRY glMultiTexCoord1dvARB(GLenum target, const GLdouble *v); +GLAPI void GLAPIENTRY glMultiTexCoord1fARB(GLenum target, GLfloat s); +GLAPI void GLAPIENTRY glMultiTexCoord1fvARB(GLenum target, const GLfloat *v); +GLAPI void GLAPIENTRY glMultiTexCoord1iARB(GLenum target, GLint s); +GLAPI void GLAPIENTRY glMultiTexCoord1ivARB(GLenum target, const GLint *v); +GLAPI void GLAPIENTRY glMultiTexCoord1sARB(GLenum target, GLshort s); +GLAPI void GLAPIENTRY glMultiTexCoord1svARB(GLenum target, const GLshort *v); +GLAPI void GLAPIENTRY glMultiTexCoord2dARB(GLenum target, GLdouble s, GLdouble t); +GLAPI void GLAPIENTRY glMultiTexCoord2dvARB(GLenum target, const GLdouble *v); +GLAPI void GLAPIENTRY glMultiTexCoord2fARB(GLenum target, GLfloat s, GLfloat t); +GLAPI void GLAPIENTRY glMultiTexCoord2fvARB(GLenum target, const GLfloat *v); +GLAPI void GLAPIENTRY glMultiTexCoord2iARB(GLenum target, GLint s, GLint t); +GLAPI void GLAPIENTRY glMultiTexCoord2ivARB(GLenum target, const GLint *v); +GLAPI void GLAPIENTRY glMultiTexCoord2sARB(GLenum target, GLshort s, GLshort t); +GLAPI void GLAPIENTRY glMultiTexCoord2svARB(GLenum target, const GLshort *v); +GLAPI void GLAPIENTRY glMultiTexCoord3dARB(GLenum target, GLdouble s, GLdouble t, GLdouble r); +GLAPI void GLAPIENTRY glMultiTexCoord3dvARB(GLenum target, const GLdouble *v); +GLAPI void GLAPIENTRY glMultiTexCoord3fARB(GLenum target, GLfloat s, GLfloat t, GLfloat r); +GLAPI void GLAPIENTRY glMultiTexCoord3fvARB(GLenum target, const GLfloat *v); +GLAPI void GLAPIENTRY glMultiTexCoord3iARB(GLenum target, GLint s, GLint t, GLint r); +GLAPI void GLAPIENTRY glMultiTexCoord3ivARB(GLenum target, const GLint *v); +GLAPI void GLAPIENTRY glMultiTexCoord3sARB(GLenum target, GLshort s, GLshort t, GLshort r); +GLAPI void GLAPIENTRY glMultiTexCoord3svARB(GLenum target, const GLshort *v); +GLAPI void GLAPIENTRY glMultiTexCoord4dARB(GLenum target, GLdouble s, GLdouble t, GLdouble r, GLdouble q); +GLAPI void GLAPIENTRY glMultiTexCoord4dvARB(GLenum target, const GLdouble *v); +GLAPI void GLAPIENTRY glMultiTexCoord4fARB(GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q); +GLAPI void GLAPIENTRY glMultiTexCoord4fvARB(GLenum target, const GLfloat *v); +GLAPI void GLAPIENTRY glMultiTexCoord4iARB(GLenum target, GLint s, GLint t, GLint r, GLint q); +GLAPI void GLAPIENTRY glMultiTexCoord4ivARB(GLenum target, const GLint *v); +GLAPI void GLAPIENTRY glMultiTexCoord4sARB(GLenum target, GLshort s, GLshort t, GLshort r, GLshort q); +GLAPI void GLAPIENTRY glMultiTexCoord4svARB(GLenum target, const GLshort *v); + +#endif /* GL_ARB_multitexture */ + + + +/* + * ARB 2. GL_ARB_tranpose_matrix + */ +#ifndef GL_ARB_transpose_matrix +#define GL_ARB_transpose_matrix 1 + +#define GL_TRANSPOSE_MODELVIEW_MATRIX_ARB 0x84E3 +#define GL_TRANSPOSE_PROJECTION_MATRIX_ARB 0x84E4 +#define GL_TRANSPOSE_TEXTURE_MATRIX_ARB 0x84E5 +#define GL_TRANSPOSE_COLOR_MATRIX_ARB 0x84E6 + +GLAPI void GLAPIENTRY glLoadTransposeMatrixdARB( const GLdouble m[16] ); +GLAPI void GLAPIENTRY glLoadTransposeMatrixfARB( const GLfloat m[16] ); +GLAPI void GLAPIENTRY glMultTransposeMatrixdARB( const GLdouble m[16] ); +GLAPI void GLAPIENTRY glMultTransposeMatrixfARB( const GLfloat m[16] ); + +#endif /* GL_ARB_tranpose_matrix */ + + + +/* + * ARB 4. GL_ARB_multisample + */ +#ifndef GL_ARB_multisample +#define GL_ARB_multisample 1 + +GLAPI void GLAPIENTRY glSampleCoverageARB(GLclampf value, GLboolean invert); + +GLAPI void GLAPIENTRY glSamplePassARB(GLenum pass); + +#endif /* GL_ARB_multisample */ + + + +#ifdef __cplusplus +} +#endif + + +#endif /* __glext_h_ */ diff --git a/xc/extras/Mesa/include/GL/glx.h b/xc/extras/Mesa/include/GL/glx.h index edb04af94..89c3fe438 100644 --- a/xc/extras/Mesa/include/GL/glx.h +++ b/xc/extras/Mesa/include/GL/glx.h @@ -3,7 +3,7 @@ * Mesa 3-D graphics library * Version: 3.3 * - * Copyright (C) 1999 Brian Paul All Rights Reserved. + * Copyright (C) 1999-2000 Brian Paul All Rights Reserved. * * Permission is hereby granted, free of charge, to any person obtaining a * copy of this software and associated documentation files (the "Software"), @@ -224,7 +224,7 @@ extern Bool glXMakeCurrent( Display *dpy, GLXDrawable drawable, GLXContext ctx); extern void glXCopyContext( Display *dpy, GLXContext src, GLXContext dst, - GLuint mask ); + unsigned long mask ); extern void glXSwapBuffers( Display *dpy, GLXDrawable drawable ); diff --git a/xc/extras/Mesa/include/GL/xmesa_x.h b/xc/extras/Mesa/include/GL/xmesa_x.h index b0344d0d6..b33435d92 100644 --- a/xc/extras/Mesa/include/GL/xmesa_x.h +++ b/xc/extras/Mesa/include/GL/xmesa_x.h @@ -30,7 +30,7 @@ SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. * Authors: * Kevin E. Martin <kevin@precisioninsight.com> * - * $Header: /home/ajax/dri-backup/xc/xc/extras/Mesa/include/GL/Attic/xmesa_x.h,v 1.2 2000/01/30 00:27:01 brianp Exp $ + * $Header: /home/ajax/dri-backup/xc/xc/extras/Mesa/include/GL/Attic/xmesa_x.h,v 1.3 2000/02/26 01:36:49 brianp Exp $ */ #ifndef _XMESA_X_H_ @@ -78,7 +78,6 @@ typedef XColor XMesaColor; #define GET_REDMASK(__v) __v->visinfo->red_mask #define GET_GREENMASK(__v) __v->visinfo->green_mask #define GET_BLUEMASK(__v) __v->visinfo->blue_mask -#define GET_BITS_PER_PIXEL(__v) bits_per_pixel(__v->display, __v->visinfo) #if defined(__cplusplus) || defined(c_plusplus) #define GET_VISUAL_CLASS(__v) __v->visinfo->c_class #else diff --git a/xc/extras/Mesa/include/GL/xmesa_xf86.h b/xc/extras/Mesa/include/GL/xmesa_xf86.h index f0c98b168..8d383731a 100644 --- a/xc/extras/Mesa/include/GL/xmesa_xf86.h +++ b/xc/extras/Mesa/include/GL/xmesa_xf86.h @@ -30,7 +30,7 @@ SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. * Authors: * Kevin E. Martin <kevin@precisioninsight.com> * - * $Header: /home/ajax/dri-backup/xc/xc/extras/Mesa/include/GL/Attic/xmesa_xf86.h,v 1.2 2000/01/30 00:27:01 brianp Exp $ + * $Header: /home/ajax/dri-backup/xc/xc/extras/Mesa/include/GL/Attic/xmesa_xf86.h,v 1.3 2000/02/26 01:36:49 brianp Exp $ */ #ifndef _XMESA_XF86_H_ @@ -179,13 +179,6 @@ do { \ #define GET_REDMASK(__v) __v->visinfo->redMask #define GET_GREENMASK(__v) __v->visinfo->greenMask #define GET_BLUEMASK(__v) __v->visinfo->blueMask - -/*XXX this was wrong. However, using nplanes instead may fail when - * we have overlay planes in the future! - */ -/*#define GET_BITS_PER_PIXEL(__v) __v->visinfo->bitsPerRGBValue*/ -#define GET_BITS_PER_PIXEL(__v) __v->visinfo->nplanes - #define GET_VISUAL_CLASS(__v) __v->visinfo->class #define GET_VISUAL_DEPTH(__v) __v->visinfo->nplanes #define GET_BLACK_PIXEL(__v) __v->display->blackPixel diff --git a/xc/extras/Mesa/src/FX/fxdd.c b/xc/extras/Mesa/src/FX/fxdd.c index ca5ff9448..bc1e55a5f 100644 --- a/xc/extras/Mesa/src/FX/fxdd.c +++ b/xc/extras/Mesa/src/FX/fxdd.c @@ -52,6 +52,7 @@ #if defined(FX) +#include "image.h" #include "types.h" #include "fxdrv.h" #include "enums.h" @@ -169,95 +170,110 @@ static void fxDDClearColor(GLcontext *ctx, GLubyte red, GLubyte green, fxMesa->clearA=alpha; } + /* Clear the color and/or depth buffers */ static GLbitfield fxDDClear(GLcontext *ctx, GLbitfield mask, GLboolean all, GLint x, GLint y, GLint width, GLint height ) { fxMesaContext fxMesa=(fxMesaContext)ctx->DriverCtx; const GLuint colorMask = *((GLuint *) &ctx->Color.ColorMask); + const FxU16 clearD = (FxU16) (ctx->Depth.Clear * 0xffff); GLbitfield softwareMask = mask & (DD_STENCIL_BIT | DD_ACCUM_BIT); - GLbitfield newMask = mask & ~(DD_STENCIL_BIT | DD_ACCUM_BIT); - if (MESA_VERBOSE&VERBOSE_DRIVER) { + if (MESA_VERBOSE & VERBOSE_DRIVER) { fprintf(stderr,"fxmesa: fxDDClear(%d,%d,%d,%d)\n", (int) x, (int) y, (int) width, (int) height); } - if (mask == (DD_BACK_LEFT_BIT | DD_DEPTH_BIT) - && colorMask == 0xffffffff) { - /* common case: clear back color buffer and depth buffer */ - FX_grRenderBuffer(GR_BUFFER_BACKBUFFER); - FX_grBufferClear(fxMesa->clearC, fxMesa->clearA, - (FxU16)(ctx->Depth.Clear*0xffff)); - return 0; - } - - /* depth masking */ - if (newMask & DD_DEPTH_BIT) { - FX_grDepthMask(FXTRUE); - CLEAR_BITS(newMask, DD_DEPTH_BIT); - } - else { - FX_grDepthMask(FXFALSE); - } - if (colorMask != 0xffffffff) { - /* do masked color clear in software */ - softwareMask |= (newMask & (DD_FRONT_LEFT_BIT | DD_BACK_LEFT_BIT)); - CLEAR_BITS(newMask, (DD_FRONT_LEFT_BIT | DD_BACK_LEFT_BIT)); + /* do color buffer clears in software */ + softwareMask |= (mask & (DD_FRONT_LEFT_BIT | DD_BACK_LEFT_BIT)); + mask &= ~(DD_FRONT_LEFT_BIT | DD_BACK_LEFT_BIT); } - if (newMask & (DD_FRONT_LEFT_BIT | DD_BACK_LEFT_BIT)) { - if (newMask & DD_FRONT_LEFT_BIT) { - if (mask & DD_DEPTH_BIT) { - /* XXX it appears that the depth buffer isn't cleared when - * glRenderBuffer(GR_BUFFER_FRONTBUFFER) is set. - * This is a work-around/ - */ - FX_grRenderBuffer(GR_BUFFER_BACKBUFFER); - FX_grColorMask(FXFALSE,FXFALSE); - FX_grBufferClear(fxMesa->clearC, fxMesa->clearA, - (FxU16)(ctx->Depth.Clear*0xffff)); - FX_grColorMask(ctx->Color.ColorMask[RCOMP] || - ctx->Color.ColorMask[GCOMP] || - ctx->Color.ColorMask[BCOMP], - ctx->Color.ColorMask[ACOMP] && fxMesa->haveAlphaBuffer); + /* + * This could probably be done fancier but doing each possible case + * explicitly is less error prone. + */ + switch (mask) { + case DD_BACK_LEFT_BIT | DD_DEPTH_BIT: + /* back buffer & depth */ + FX_grDepthMask(FXTRUE); + FX_grRenderBuffer(GR_BUFFER_BACKBUFFER); + FX_grBufferClear(fxMesa->clearC, fxMesa->clearA, clearD); + if (!ctx->Depth.Mask) { + FX_grDepthMask(FXFALSE); + } + break; + case DD_FRONT_LEFT_BIT | DD_DEPTH_BIT: + /* XXX it appears that the depth buffer isn't cleared when + * glRenderBuffer(GR_BUFFER_FRONTBUFFER) is set. + * This is a work-around/ + */ + /* clear depth */ + FX_grRenderBuffer(GR_BUFFER_BACKBUFFER); + FX_grColorMask(FXFALSE,FXFALSE); + FX_grBufferClear(fxMesa->clearC, fxMesa->clearA, clearD); + /* clear front */ + FX_grColorMask(FXTRUE, ctx->Color.ColorMask[ACOMP] && fxMesa->haveAlphaBuffer); + FX_grRenderBuffer(GR_BUFFER_FRONTBUFFER); + FX_grBufferClear(fxMesa->clearC, fxMesa->clearA, clearD); + break; + case DD_BACK_LEFT_BIT: + /* back buffer only */ + FX_grDepthMask(FXFALSE); + FX_grRenderBuffer(GR_BUFFER_BACKBUFFER); + FX_grBufferClear(fxMesa->clearC, fxMesa->clearA, clearD); + if (!ctx->Depth.Mask) { + FX_grDepthMask(FXFALSE); } + break; + case DD_FRONT_LEFT_BIT: + /* front buffer only */ + FX_grDepthMask(FXFALSE); FX_grRenderBuffer(GR_BUFFER_FRONTBUFFER); - FX_grBufferClear(fxMesa->clearC, fxMesa->clearA, - (FxU16)(ctx->Depth.Clear*0xffff)); - } - - if (newMask & DD_BACK_LEFT_BIT) { + FX_grBufferClear(fxMesa->clearC, fxMesa->clearA, clearD); + if (!ctx->Depth.Mask) { + FX_grDepthMask(FXFALSE); + } + break; + case DD_FRONT_LEFT_BIT | DD_BACK_LEFT_BIT: + /* front and back */ + FX_grDepthMask(FXFALSE); FX_grRenderBuffer(GR_BUFFER_BACKBUFFER); + FX_grBufferClear(fxMesa->clearC, fxMesa->clearA, clearD); + FX_grRenderBuffer(GR_BUFFER_FRONTBUFFER); + FX_grBufferClear(fxMesa->clearC, fxMesa->clearA, clearD); + if (!ctx->Depth.Mask) { + FX_grDepthMask(FXFALSE); + } + break; + case DD_FRONT_LEFT_BIT | DD_BACK_LEFT_BIT | DD_DEPTH_BIT: + /* clear front */ + FX_grDepthMask(FXFALSE); + FX_grRenderBuffer(GR_BUFFER_FRONTBUFFER); + FX_grBufferClear(fxMesa->clearC, fxMesa->clearA, clearD); + /* clear back and depth */ + FX_grDepthMask(FXTRUE); + FX_grRenderBuffer(GR_BUFFER_BACKBUFFER); + FX_grBufferClear(fxMesa->clearC, fxMesa->clearA, clearD); + if (!ctx->Depth.Mask) { + FX_grDepthMask(FXFALSE); + } + break; + case DD_DEPTH_BIT: + /* just the depth buffer */ + FX_grColorMask(FXFALSE,FXFALSE); FX_grBufferClear(fxMesa->clearC, fxMesa->clearA, (FxU16)(ctx->Depth.Clear*0xffff)); - } - - CLEAR_BITS(newMask, (DD_FRONT_LEFT_BIT | DD_BACK_LEFT_BIT)); - } - else if (mask & DD_DEPTH_BIT) { - /* clear depth but not color */ - FX_grColorMask(FXFALSE,FXFALSE); - FX_grBufferClear(fxMesa->clearC, fxMesa->clearA, - (FxU16)(ctx->Depth.Clear*0xffff)); - FX_grColorMask(ctx->Color.ColorMask[RCOMP] || - ctx->Color.ColorMask[GCOMP] || - ctx->Color.ColorMask[BCOMP], - ctx->Color.ColorMask[ACOMP] && fxMesa->haveAlphaBuffer); - } - - /* Restore depth mask state */ - if (mask & DD_DEPTH_BIT) { - if (ctx->Depth.Mask) { - FX_grDepthMask(FXTRUE); - } - else { - FX_grDepthMask(FXFALSE); - } + FX_grColorMask(FXTRUE, ctx->Color.ColorMask[ACOMP] && fxMesa->haveAlphaBuffer); + break; + default: + /* error */ + ; } - return newMask | softwareMask; + return softwareMask; } @@ -311,11 +327,10 @@ static void fxDDSetReadBuffer(GLcontext *ctx, GLframebuffer *buffer, #ifdef XF86DRI +/* test if window coord (px,py) is visible */ static GLboolean inClipRects(fxMesaContext fxMesa, int px, int py) { int i; - - py=fxMesa->height+fxMesa->y_offset-py; for (i=0; i<fxMesa->numClipRects; i++) { if ((px>=fxMesa->pClipRects[i].x1) && (px<fxMesa->pClipRects[i].x2) && @@ -333,127 +348,170 @@ static GLboolean fxDDDrawBitMap(GLcontext *ctx, GLint px, GLint py, const GLubyte *bitmap) { fxMesaContext fxMesa=(fxMesaContext)ctx->DriverCtx; - FxU16 *p; GrLfbInfo_t info; - const GLubyte *pb; - int x,y,xmin,xmax,ymin,ymax; - GLint r,g,b,a,scrwidth,scrheight,stride; FxU16 color; - - /* TODO: with a little work, these bitmap unpacking parameter restrictions - * could be removed. - */ - if((unpack->Alignment!=1) || - (unpack->RowLength!=0) || - (unpack->SkipPixels!=0) || - (unpack->SkipRows!=0) || - (unpack->SwapBytes) || - (unpack->LsbFirst)) + const struct gl_pixelstore_attrib *finalUnpack; + struct gl_pixelstore_attrib scissoredUnpack; + + /* check if there's any raster operations enabled which we can't handle */ + if (ctx->RasterMask & (ALPHATEST_BIT | + BLEND_BIT | + DEPTH_BIT | + FOG_BIT | + LOGIC_OP_BIT | + SCISSOR_BIT | + STENCIL_BIT | + MASKING_BIT | + ALPHABUF_BIT | + MULTI_DRAW_BIT)) return GL_FALSE; if (ctx->Scissor.Enabled) { - xmin=ctx->Scissor.X; - xmax=ctx->Scissor.X+ctx->Scissor.Width; - ymin=ctx->Scissor.Y; - ymax=ctx->Scissor.Y+ctx->Scissor.Height; - } else { - xmin=0; - xmax=fxMesa->width; - ymin=0; - ymax=fxMesa->height; - } - - xmin+=fxMesa->x_offset; - xmax+=fxMesa->x_offset; - -#ifdef XF86DRI -#define ISCLIPPED(rx, ry) ( ((rx)<xmin) || ((rx)>=xmax) || !inClipRects(fxMesa, rx, ry)) -#else -#define ISCLIPPED(rx, ry) ( ((rx)<xmin) || ((rx)>=xmax) ) -#endif -#define DRAWBIT(i) { \ - if(!ISCLIPPED(x+px, y)) \ - if( (*pb) & (1<<(i)) ) \ - (*p)=color; \ - p++; \ - x++; \ - if(x>=width) { \ - pb++; \ - break; \ - } \ -} - - scrwidth=fxMesa->width; - scrheight=fxMesa->height; - - if ((px>=scrwidth) || (px+width<=0) || (py>=scrheight) || (py+height<=0)) - return GL_TRUE; + /* This is a bit tricky, but by carefully adjusting the px, py, + * width, height, skipPixels and skipRows values we can do + * scissoring without special code in the rendering loop. + */ - pb=bitmap; + /* we'll construct a new pixelstore struct */ + finalUnpack = &scissoredUnpack; + scissoredUnpack = *unpack; + if (scissoredUnpack.RowLength == 0) + scissoredUnpack.RowLength = width; + + /* clip left */ + if (px < ctx->Scissor.X) { + scissoredUnpack.SkipPixels += (ctx->Scissor.X - px); + width -= (ctx->Scissor.X - px); + px = ctx->Scissor.X; + } + /* clip right */ + if (px + width >= ctx->Scissor.X + ctx->Scissor.Width) { + width -= (px + width - (ctx->Scissor.X + ctx->Scissor.Width)); + } + /* clip bottom */ + if (py < ctx->Scissor.Y) { + scissoredUnpack.SkipRows += (ctx->Scissor.Y - py); + height -= (ctx->Scissor.Y - py); + py = ctx->Scissor.Y; + } + /* clip top */ + if (py + height >= ctx->Scissor.Y + ctx->Scissor.Height) { + height -= (py + height - (ctx->Scissor.Y + ctx->Scissor.Height)); + } - if(py<0) { - pb+=(height*(-py)) >> (3+1); - height+=py; - py=0; + if (width <= 0 || height <= 0) + return GL_TRUE; /* totally scissored away */ + } + else { + finalUnpack = unpack; } - if (py+height>=scrheight) - height-=(py+height)-scrheight; + /* compute pixel value */ + { + GLint r = (GLint) (ctx->Current.RasterColor[0] * 255.0f); + GLint g = (GLint) (ctx->Current.RasterColor[1] * 255.0f); + GLint b = (GLint) (ctx->Current.RasterColor[2] * 255.0f); + /*GLint a = (GLint)(ctx->Current.RasterColor[3]*255.0f);*/ + if (fxMesa->bgrOrder) + color = (FxU16) + ( ((FxU16)0xf8 & b) << (11-3)) | + ( ((FxU16)0xfc & g) << (5-3+1)) | + ( ((FxU16)0xf8 & r) >> 3); + else + color = (FxU16) + ( ((FxU16)0xf8 & r) << (11-3)) | + ( ((FxU16)0xfc & g) << (5-3+1)) | + ( ((FxU16)0xf8 & b) >> 3); + } - info.size=sizeof(info); - if(!FX_grLfbLock(GR_LFB_WRITE_ONLY, - fxMesa->currentFB, - GR_LFBWRITEMODE_565, - GR_ORIGIN_UPPER_LEFT, - FXFALSE, - &info)) { + info.size = sizeof(info); + if (!FX_grLfbLock(GR_LFB_WRITE_ONLY, + fxMesa->currentFB, + GR_LFBWRITEMODE_565, + GR_ORIGIN_UPPER_LEFT, + FXFALSE, + &info)) { #ifndef FX_SILENT fprintf(stderr,"fx Driver: error locking the linear frame buffer\n"); #endif return GL_TRUE; } - r=(GLint)(ctx->Current.RasterColor[0]*255.0f); - g=(GLint)(ctx->Current.RasterColor[1]*255.0f); - b=(GLint)(ctx->Current.RasterColor[2]*255.0f); - a=(GLint)(ctx->Current.RasterColor[3]*255.0f); - if (fxMesa->bgrOrder) - color=(FxU16) - ( ((FxU16)0xf8 & b) <<(11-3)) | - ( ((FxU16)0xfc & g) <<(5-3+1)) | - ( ((FxU16)0xf8 & r) >> 3); - else - color=(FxU16) - ( ((FxU16)0xf8 & r) <<(11-3)) | - ( ((FxU16)0xfc & g) <<(5-3+1)) | - ( ((FxU16)0xf8 & b) >> 3); - - stride=info.strideInBytes>>1; - - /* This code is a bit slow... */ - - if (py>ymin) ymin=py; - if (py+height<ymax) ymax=py+height; - - px+=fxMesa->x_offset; - scrheight=fxMesa->height+fxMesa->y_offset; - - for(y=ymin; y<ymax; y++) { - - p=((FxU16 *)info.lfbPtr)+px+((scrheight-y)*stride); +#ifdef XF86DRI +#define INSIDE(c, x, y) inClipRects((c), (x), (y)) +#else +#define INSIDE(c, x, y) (1) +#endif - for(x=0;;) { - DRAWBIT(7); DRAWBIT(6); DRAWBIT(5); DRAWBIT(4); - DRAWBIT(3); DRAWBIT(2); DRAWBIT(1); DRAWBIT(0); - pb++; + { + const GLint winX = fxMesa->x_offset; + const GLint winY = fxMesa->y_offset + fxMesa->height - 1; + /* The dest stride depends on the hardware and whether we're drawing + * to the front or back buffer. This compile-time test seems to do + * the job for now. + */ +#ifdef XF86DRI + const GLint dstStride = (fxMesa->glCtx->Color.DrawBuffer == GL_FRONT) + ? (fxMesa->screen_width) : (info.strideInBytes / 2); +#else + const GLint dstStride = info.strideInBytes / 2; /* stride in GLushorts */ +#endif + GLint row; + /* compute dest address of bottom-left pixel in bitmap */ + GLushort *dst = (GLushort *) info.lfbPtr + + (winY - py) * dstStride + + (winX + px); + + for (row = 0; row < height; row++) { + const GLubyte *src = (const GLubyte *) gl_pixel_addr_in_image( finalUnpack, + bitmap, width, height, GL_COLOR_INDEX, GL_BITMAP, 0, row, 0 ); + if (finalUnpack->LsbFirst) { + /* least significan bit first */ + GLubyte mask = 1U << (finalUnpack->SkipPixels & 0x7); + GLint col; + for (col=0; col<width; col++) { + if (*src & mask) { + if (INSIDE(fxMesa, winX + px + col, winY - py - row)) + dst[col] = color; + } + if (mask == 128U) { + src++; + mask = 1U; + } + else { + mask = mask << 1; + } + } + if (mask != 1) + src++; + } + else { + /* most significan bit first */ + GLubyte mask = 128U >> (finalUnpack->SkipPixels & 0x7); + GLint col; + for (col=0; col<width; col++) { + if (*src & mask) { + if (INSIDE(fxMesa, winX + px + col, winY - py - row)) + dst[col] = color; + } + if (mask == 1U) { + src++; + mask = 128U; + } + else { + mask = mask >> 1; + } + } + if (mask != 128) + src++; + } + dst -= dstStride; } } - FX_grLfbUnlock(GR_LFB_WRITE_ONLY,fxMesa->currentFB); - -#undef ISCLIPPED -#undef DRAWBIT +#undef INSIDE + FX_grLfbUnlock(GR_LFB_WRITE_ONLY,fxMesa->currentFB); return GL_TRUE; } @@ -510,7 +568,7 @@ static const GLubyte *fxDDGetString(GLcontext *ctx, GLenum name) } } /* now make the GL_RENDERER string */ - sprintf(buffer, "Mesa DRI %s 20000208", hardware); + sprintf(buffer, "Mesa DRI %s 20000224", hardware); return buffer; } case GL_VENDOR: @@ -692,28 +750,55 @@ int fxDDInitFxMesaContext( fxMesaContext fxMesa ) } - +#if 0 +/* Example extension function */ +static void fxFooBarEXT(GLint i) +{ + printf("You called glFooBarEXT(%d)\n", i); +} +#endif void fxDDInitExtensions( GLcontext *ctx ) { fxMesaContext fxMesa=(fxMesaContext)ctx->DriverCtx; - gl_extensions_add( ctx, DEFAULT_ON, "3DFX_set_global_palette", 0 ); - gl_extensions_add( ctx, DEFAULT_ON, "GL_FXMESA_global_texture_lod_bias", 0); + gl_extensions_disable(ctx, "GL_EXT_blend_logic_op"); + gl_extensions_disable(ctx, "GL_EXT_blend_minmax"); + gl_extensions_disable(ctx, "GL_EXT_blend_subtract"); + gl_extensions_disable(ctx, "GL_EXT_blend_color"); + gl_extensions_disable(ctx, "GL_EXT_paletted_texture"); + + gl_extensions_add(ctx, DEFAULT_ON, "3DFX_set_global_palette", 0); + gl_extensions_add(ctx, DEFAULT_ON, "GL_FXMESA_global_texture_lod_bias", 0); - if(fxMesa->haveTwoTMUs) - gl_extensions_add( ctx, DEFAULT_ON, "GL_EXT_texture_env_add", 0); + if (!fxMesa->haveTwoTMUs) + gl_extensions_disable(ctx, "GL_EXT_texture_env_add"); if (!fxMesa->emulateTwoTMUs) - gl_extensions_disable( ctx, "GL_ARB_multitexture" ); + gl_extensions_disable(ctx, "GL_ARB_multitexture"); + + + /* Example of hooking in an extension function. + * For DRI-based drivers, also see __driRegisterExtensions in the + * tdfx_xmesa.c file. + */ +#if 0 + { + void **dispatchTable = (void **) ctx->Exec; + const int _gloffset_FooBarEXT = 555; /* just an example number! */ + const int tabSize = _glapi_get_dispatch_table_size(); + assert(_gloffset_FooBarEXT < tabSize); + dispatchTable[_gloffset_FooBarEXT] = (void *) fxFooBarEXT; + /* XXX You would also need to hook into the display list dispatch + * table. Really, the implementation of extensions might as well + * be in the core of Mesa since core Mesa and the device driver + * is one big shared lib. + */ + } +#endif } -/* - This driver may need to move the drawing operations to a different sub - window. This modifies the viewport command to add our X,Y offset to all - drawn objects that go through the viewport transformation. -*/ /************************************************************************/ /************************************************************************/ diff --git a/xc/extras/Mesa/src/FX/fxdrv.h b/xc/extras/Mesa/src/FX/fxdrv.h index 208801e87..1c6e3f063 100644 --- a/xc/extras/Mesa/src/FX/fxdrv.h +++ b/xc/extras/Mesa/src/FX/fxdrv.h @@ -478,6 +478,7 @@ struct tfxMesaContext { GLenum fogTableMode; GLfloat fogDensity; + GLfloat fogStart, fogEnd; GrFog_t *fogTable; /* Acc. functions */ diff --git a/xc/extras/Mesa/src/FX/fxsetup.c b/xc/extras/Mesa/src/FX/fxsetup.c index 6ebd037fd..8707aed1d 100644 --- a/xc/extras/Mesa/src/FX/fxsetup.c +++ b/xc/extras/Mesa/src/FX/fxsetup.c @@ -66,8 +66,6 @@ static void fxSetupTexture_NoLock(GLcontext *ctx); static void fxSetupTexture(GLcontext *ctx); static void fxSetupBlend(GLcontext *ctx); static void fxSetupDepthTest(GLcontext *ctx); -static void fxFogTableGenerate(GLcontext *ctx); -static void fxSetupFog(GLcontext *ctx, GLboolean forceTableRebuild); static void fxSetupScissor(GLcontext *ctx); static void fxSetupCull(GLcontext *ctx); static void gl_print_fx_state_flags( const char *msg, GLuint flags); @@ -1424,67 +1422,58 @@ static void fxSetupColorMask(GLcontext *ctx) /**************************** Fog Mode SetUp ****************************/ /************************************************************************/ -static void fxFogTableGenerate(GLcontext *ctx) +/* + * This is called during state update in order to update the Glide fog state. + */ +static void fxSetupFog(GLcontext *ctx) { - int i; - float f,eyez; - fxMesaContext fxMesa=(fxMesaContext)ctx->DriverCtx; - - for(i=0;i<FX_grGetInteger(FX_FOG_TABLE_ENTRIES);i++) { - eyez=guFogTableIndexToW(i); - - switch(ctx->Fog.Mode) { - case GL_LINEAR: - f=(ctx->Fog.End-eyez)/(ctx->Fog.End-ctx->Fog.Start); - break; - case GL_EXP: - f=exp(-ctx->Fog.Density*eyez); - break; - case GL_EXP2: - f=exp(-ctx->Fog.Density*ctx->Fog.Density*eyez*eyez); - break; - default: /* That should never happen */ - f=0.0f; - break; - } + if (ctx->Fog.Enabled && ctx->FogMode==FOG_FRAGMENT) { + fxMesaContext fxMesa = FX_CONTEXT(ctx); - fxMesa->fogTable[i]=(GrFog_t)((1.0f-CLAMP(f,0.0f,1.0f))*255.0f); - } -} - -static void fxSetupFog(GLcontext *ctx, GLboolean forceTableRebuild) -{ - fxMesaContext fxMesa=(fxMesaContext)ctx->DriverCtx; - - if(ctx->Fog.Enabled && ctx->FogMode==FOG_FRAGMENT) { + /* update fog color */ GLubyte col[4]; - FX_grFogMode(GR_FOG_WITH_TABLE); - col[0]=(unsigned int)(255*ctx->Fog.Color[0]); col[1]=(unsigned int)(255*ctx->Fog.Color[1]); col[2]=(unsigned int)(255*ctx->Fog.Color[2]); col[3]=(unsigned int)(255*ctx->Fog.Color[3]); - FX_grFogColorValue(FXCOLOR4(col)); - if(forceTableRebuild || - (fxMesa->fogTableMode!=ctx->Fog.Mode) || - (fxMesa->fogDensity!=ctx->Fog.Density)) { - fxFogTableGenerate(ctx); - - fxMesa->fogTableMode=ctx->Fog.Mode; - fxMesa->fogDensity=ctx->Fog.Density; + if(fxMesa->fogTableMode != ctx->Fog.Mode || + fxMesa->fogDensity != ctx->Fog.Density || + fxMesa->fogStart != ctx->Fog.Start || + fxMesa->fogEnd != ctx->Fog.End) { + /* reload the fog table */ + switch (ctx->Fog.Mode) { + case GL_LINEAR: + guFogGenerateLinear(fxMesa->fogTable, ctx->Fog.Start, ctx->Fog.End); + break; + case GL_EXP: + guFogGenerateExp(fxMesa->fogTable, ctx->Fog.Density); + break; + case GL_EXP2: + guFogGenerateExp2(fxMesa->fogTable, ctx->Fog.Density); + break; + default: + ; + } + fxMesa->fogTableMode = ctx->Fog.Mode; + fxMesa->fogDensity = ctx->Fog.Density; + fxMesa->fogStart = ctx->Fog.Start; + fxMesa->fogEnd = ctx->Fog.End; } - + FX_grFogTable(fxMesa->fogTable); - } else + FX_grFogMode(GR_FOG_WITH_TABLE); + } + else { FX_grFogMode(GR_FOG_DISABLE); + } } void fxDDFogfv( GLcontext *ctx, GLenum pname, const GLfloat *params ) { FX_CONTEXT(ctx)->new_state |= FX_NEW_FOG; - ctx->Driver.RenderStart = fxSetupFXUnits; + ctx->Driver.RenderStart = fxSetupFXUnits; /* XXX why is this here? */ } /************************************************************************/ @@ -1823,7 +1812,7 @@ void fxSetupFXUnits( GLcontext *ctx ) fxSetupDepthTest(ctx); if (newstate & FX_NEW_FOG) - fxSetupFog(ctx,GL_FALSE); + fxSetupFog(ctx); if (newstate & FX_NEW_SCISSOR) fxSetupScissor(ctx); diff --git a/xc/extras/Mesa/src/X/fakeglx.c b/xc/extras/Mesa/src/X/fakeglx.c index 76ae81c64..16fb2f622 100644 --- a/xc/extras/Mesa/src/X/fakeglx.c +++ b/xc/extras/Mesa/src/X/fakeglx.c @@ -1206,12 +1206,12 @@ Fake_glXDestroyGLXPixmap( Display *dpy, GLXPixmap pixmap ) static void Fake_glXCopyContext( Display *dpy, GLXContext src, GLXContext dst, - GLuint mask ) + unsigned long mask ) { XMesaContext xm_src = (XMesaContext) src; XMesaContext xm_dst = (XMesaContext) dst; (void) dpy; - gl_copy_context( xm_src->gl_ctx, xm_dst->gl_ctx, mask ); + gl_copy_context( xm_src->gl_ctx, xm_dst->gl_ctx, (GLuint) mask ); } diff --git a/xc/extras/Mesa/src/X/glxapi.c b/xc/extras/Mesa/src/X/glxapi.c index e7620a544..5ee5d7419 100644 --- a/xc/extras/Mesa/src/X/glxapi.c +++ b/xc/extras/Mesa/src/X/glxapi.c @@ -168,7 +168,8 @@ XVisualInfo *glXChooseVisual(Display *dpy, int screen, int *list) } -void glXCopyContext(Display *dpy, GLXContext src, GLXContext dst, GLuint mask) +void glXCopyContext(Display *dpy, GLXContext src, GLXContext dst, + unsigned long mask) { struct _glxapi_table *t = get_dispatch(dpy); if (!t) diff --git a/xc/extras/Mesa/src/X/glxapi.h b/xc/extras/Mesa/src/X/glxapi.h index f0771bfd5..ae8433987 100644 --- a/xc/extras/Mesa/src/X/glxapi.h +++ b/xc/extras/Mesa/src/X/glxapi.h @@ -55,7 +55,7 @@ struct _glxapi_table { /* GLX 1.0 functions */ XVisualInfo *(*ChooseVisual)(Display *dpy, int screen, int *list); - void (*CopyContext)(Display *dpy, GLXContext src, GLXContext dst, GLuint mask); + void (*CopyContext)(Display *dpy, GLXContext src, GLXContext dst, unsigned long mask); GLXContext (*CreateContext)(Display *dpy, XVisualInfo *visinfo, GLXContext shareList, Bool direct); GLXPixmap (*CreateGLXPixmap)(Display *dpy, XVisualInfo *visinfo, Pixmap pixmap); void (*DestroyContext)(Display *dpy, GLXContext ctx); diff --git a/xc/extras/Mesa/src/X/xmesa1.c b/xc/extras/Mesa/src/X/xmesa1.c index 79a4c9e76..56e6fcad7 100644 --- a/xc/extras/Mesa/src/X/xmesa1.c +++ b/xc/extras/Mesa/src/X/xmesa1.c @@ -255,15 +255,34 @@ static GLint gamma_adjust( GLfloat gamma, GLint value, GLint max ) /* * Return the true number of bits per pixel for XImages. - * For example, if we request a 24-bit deep visual we may actually - * get a 32-bit per pixel XImage. This function gives us this information. + * For example, if we request a 24-bit deep visual we may actually need/get + * 32bpp XImages. This function returns the appropriate bpp. * Input: dpy - the X display * visinfo - desribes the visual to be used for XImages * Return: true number of bits per pixel for XImages */ -#ifndef XFree86Server -static int bits_per_pixel( XMesaDisplay *dpy, XVisualInfo *visinfo ) +#define GET_BITS_PER_PIXEL(xmv) bits_per_pixel(xmv) + +#ifdef XFree86Server + +static int bits_per_pixel( XMesaVisual xmv ) +{ + XMesaVisualInfo visinfo = xmv->visinfo; + const int depth = visinfo->nplanes; + int i; + for (i = 0; i < screenInfo.numPixmapFormats; i++) { + if (screenInfo.formats[i].depth == depth) + return screenInfo.formats[i].bitsPerPixel; + } + return depth; /* should never get here, but this should be safe */ +} + +#else + +static int bits_per_pixel( XMesaVisual xmv ) { + XMesaDisplay *dpy = xmv->display; + XMesaVisualInfo visinfo = xmv->visinfo; XMesaImage *img; int bitsPerPixel; /* Create a temporary XImage */ @@ -527,6 +546,26 @@ static GLboolean alloc_shm_back_buffer( XMesaBuffer b ) return GL_FALSE; } + if (b->backimage) { + int height = b->backimage->height; + /* Needed by PIXELADDR1 macro */ + b->ximage_width1 = b->backimage->bytes_per_line; + b->ximage_origin1 = (GLubyte *) b->backimage->data + + b->ximage_width1 * (height-1); + /* Needed by PIXELADDR2 macro */ + b->ximage_width2 = b->backimage->bytes_per_line / 2; + b->ximage_origin2 = (GLushort *) b->backimage->data + + b->ximage_width2 * (height-1); + /* Needed by PIXELADDR3 macro */ + b->ximage_width3 = b->backimage->bytes_per_line; + b->ximage_origin3 = (GLubyte *) b->backimage->data + + b->ximage_width3 * (height-1); + /* Needed by PIXELADDR4 macro */ + b->ximage_width4 = b->backimage->width; + b->ximage_origin4 = (GLuint *) b->backimage->data + + b->ximage_width4 * (height-1); + } + return GL_TRUE; #else /* Can't compile XSHM support */ @@ -560,9 +599,9 @@ void xmesa_alloc_back_buffer( XMesaBuffer b ) /* Allocate new back buffer */ #ifdef XFree86Server - { + { /* Allocate a regular XImage for the back buffer. */ - b->backimage = XMesaCreateImage(GET_VISUAL_DEPTH(b->xm_visual), + b->backimage = XMesaCreateImage(b->xm_visual->BitsPerPixel, b->width, b->height, NULL); #else if (b->shm==0 @@ -971,7 +1010,6 @@ static void setup_truecolor( XMesaVisual v, XMesaBuffer buffer, XMesaWindow window, XMesaColormap cmap ) { unsigned long rmask, gmask, bmask; - int bitsPerPixel; (void) buffer; (void) window; (void) cmap; @@ -1056,14 +1094,11 @@ static void setup_truecolor( XMesaVisual v, XMesaBuffer buffer, /* * Now check for TrueColor visuals which we can optimize. */ - - bitsPerPixel = GET_BITS_PER_PIXEL(v); - if ( GET_REDMASK(v) ==0x0000ff && GET_GREENMASK(v)==0x00ff00 && GET_BLUEMASK(v) ==0xff0000 && CHECK_BYTE_ORDER(v) - && bitsPerPixel==32 + && v->BitsPerPixel==32 && sizeof(GLuint)==4 && v->RedGamma==1.0 && v->GreenGamma==1.0 && v->BlueGamma==1.0) { /* common 32 bpp config used on SGI, Sun */ @@ -1073,7 +1108,7 @@ static void setup_truecolor( XMesaVisual v, XMesaBuffer buffer, && GET_GREENMASK(v)==0x00ff00 && GET_BLUEMASK(v) ==0x0000ff && CHECK_BYTE_ORDER(v) - && bitsPerPixel==32 + && v->BitsPerPixel==32 && sizeof(GLuint)==4 && v->RedGamma==1.0 && v->GreenGamma==1.0 && v->BlueGamma==1.0) { /* common 32 bpp config used on Linux, HP, IBM */ @@ -1083,7 +1118,7 @@ static void setup_truecolor( XMesaVisual v, XMesaBuffer buffer, && GET_GREENMASK(v)==0x00ff00 && GET_BLUEMASK(v) ==0x0000ff && CHECK_BYTE_ORDER(v) - && bitsPerPixel==24 + && v->BitsPerPixel==24 && sizeof(GLuint)==4 && v->RedGamma==1.0 && v->GreenGamma==1.0 && v->BlueGamma==1.0) { /* common packed 24 bpp config used on Linux */ @@ -1093,7 +1128,7 @@ static void setup_truecolor( XMesaVisual v, XMesaBuffer buffer, && GET_GREENMASK(v)==0x07e0 && GET_BLUEMASK(v) ==0x001f && CHECK_BYTE_ORDER(v) - && bitsPerPixel==16 + && v->BitsPerPixel==16 && sizeof(GLushort)==2 && v->RedGamma==1.0 && v->GreenGamma==1.0 && v->BlueGamma==1.0) { /* 5-6-5 color weight on common PC VGA boards */ @@ -1149,6 +1184,11 @@ static GLboolean initialize_visual_and_buffer( int client, assert(b->xm_visual == v); } + /* Save true bits/pixel */ + v->BitsPerPixel = GET_BITS_PER_PIXEL(v); + assert(v->BitsPerPixel > 0); + + if (rgb_flag==GL_FALSE) { /* COLOR-INDEXED WINDOW: * Even if the visual is TrueColor or DirectColor we treat it as @@ -1192,10 +1232,6 @@ static GLboolean initialize_visual_and_buffer( int client, } - /* Save true bits/pixel */ - v->BitsPerPixel = GET_BITS_PER_PIXEL(v); - assert(v->BitsPerPixel > 0); - /* * If MESA_INFO env var is set print out some debugging info * which can help Brian figure out what's going on when a user @@ -1207,7 +1243,7 @@ static GLboolean initialize_visual_and_buffer( int client, fprintf(stderr, "X/Mesa undithered pf = %u\n", v->undithered_pf); fprintf(stderr, "X/Mesa level = %d\n", v->level); fprintf(stderr, "X/Mesa depth = %d\n", GET_VISUAL_DEPTH(v)); - fprintf(stderr, "X/Mesa bits per pixel = %d\n", GET_BITS_PER_PIXEL(v)); + fprintf(stderr, "X/Mesa bits per pixel = %d\n", v->BitsPerPixel); } if (b && window) { @@ -1665,7 +1701,7 @@ XMesaBuffer XMesaCreateWindowBuffer2( XMesaVisual v, assert(v); #ifdef XFree86Server - if (GET_VISUAL_DEPTH(v) != ((XMesaDrawable)w)->bitsPerPixel) { + if (GET_VISUAL_DEPTH(v) != ((XMesaDrawable)w)->depth) { #else XGetWindowAttributes( v->display, w, &attr ); @@ -1780,14 +1816,18 @@ XMesaBuffer XMesaCreateWindowBuffer2( XMesaVisual v, b->FXisHackUsable = GL_FALSE; b->FXwindowHack = GL_FALSE; } - fprintf(stderr, "voodoo %d, wid %d height %d hack: usable %d active %d\n", - hw, b->width, b->height, b->FXisHackUsable, b->FXwindowHack); + /* + fprintf(stderr, + "voodoo %d, wid %d height %d hack: usable %d active %d\n", + hw, b->width, b->height, b->FXisHackUsable, b->FXwindowHack); + */ } - } else { - fprintf(stderr,"WARNING: This Mesa Library includes the Glide driver but\n"); - fprintf(stderr," you have not defined the MESA_GLX_FX env. var.\n"); - fprintf(stderr," (check the README.3DFX file for more information).\n\n"); - fprintf(stderr," you can disable this message with a 'export MESA_GLX_FX=disable'.\n"); + } + else { + fprintf(stderr,"WARNING: This Mesa Library includes the Glide driver but\n"); + fprintf(stderr," you have not defined the MESA_GLX_FX env. var.\n"); + fprintf(stderr," (check the README.3DFX file for more information).\n\n"); + fprintf(stderr," you can disable this message with a 'export MESA_GLX_FX=disable'.\n"); } #endif @@ -2028,7 +2068,8 @@ GLboolean XMesaMakeCurrent2( XMesaContext c, XMesaBuffer drawBuffer, */ GLboolean XMesaUnbindContext( XMesaContext c ) { - return GL_TRUE; + /* A no-op for XFree86 integration purposes */ + return GL_TRUE; } @@ -2096,11 +2137,11 @@ GLboolean XMesaSetFXmode( GLint mode ) if (fx && fx[0] != 'd') { GrHwConfiguration hw; if (!grSstQueryHardware(&hw)) { - fprintf(stderr, "!grSstQueryHardware\n"); + /*fprintf(stderr, "!grSstQueryHardware\n");*/ return GL_FALSE; } if (hw.num_sst < 1) { - fprintf(stderr, "hw.num_sst < 1\n"); + /*fprintf(stderr, "hw.num_sst < 1\n");*/ return GL_FALSE; } if (XMesa) { @@ -2121,7 +2162,7 @@ GLboolean XMesaSetFXmode( GLint mode ) } } } - fprintf(stderr, "fallthrough\n"); + /*fprintf(stderr, "fallthrough\n");*/ #else (void) mode; #endif diff --git a/xc/extras/Mesa/src/X/xmesa2.c b/xc/extras/Mesa/src/X/xmesa2.c index 7688c0ff0..75340eb43 100644 --- a/xc/extras/Mesa/src/X/xmesa2.c +++ b/xc/extras/Mesa/src/X/xmesa2.c @@ -184,9 +184,9 @@ static void get_buffer_size( GLcontext *ctx, GLuint *width, GLuint *height ) /* Needed by PIXELADDR3 macro */ xmesa->xm_buffer->ximage_width3 - = xmesa->xm_buffer->backimage->bytes_per_line / 3; + = xmesa->xm_buffer->backimage->bytes_per_line; xmesa->xm_buffer->ximage_origin3 - = (bgr_t *) xmesa->xm_buffer->backimage->data + = (GLubyte *) xmesa->xm_buffer->backimage->data + xmesa->xm_buffer->ximage_width3 * (winheight-1); /* Needed by PIXELADDR4 macro */ @@ -550,21 +550,41 @@ static void dither( GLcontext *ctx, GLboolean enable ) /**********************************************************************/ -/* Clear a pixmap color buffer, may be the front or back buffer */ static void -clear_pixmap( GLcontext *ctx, GLboolean all, - GLint x, GLint y, GLint width, GLint height ) +clear_front_pixmap( GLcontext *ctx, GLboolean all, + GLint x, GLint y, GLint width, GLint height ) +{ + const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx; + if (all) { + XMesaFillRectangle( xmesa->display, xmesa->xm_buffer->frontbuffer, + xmesa->xm_buffer->cleargc, + 0, 0, + xmesa->xm_buffer->width+1, + xmesa->xm_buffer->height+1 ); + } + else { + XMesaFillRectangle( xmesa->display, xmesa->xm_buffer->frontbuffer, + xmesa->xm_buffer->cleargc, + x, xmesa->xm_buffer->height - y - height, + width, height ); + } +} + + +static void +clear_back_pixmap( GLcontext *ctx, GLboolean all, + GLint x, GLint y, GLint width, GLint height ) { const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx; if (all) { - XMesaFillRectangle( xmesa->display, xmesa->xm_buffer->buffer, + XMesaFillRectangle( xmesa->display, xmesa->xm_buffer->backpixmap, xmesa->xm_buffer->cleargc, 0, 0, xmesa->xm_buffer->width+1, xmesa->xm_buffer->height+1 ); } else { - XMesaFillRectangle( xmesa->display, xmesa->xm_buffer->buffer, + XMesaFillRectangle( xmesa->display, xmesa->xm_buffer->backpixmap, xmesa->xm_buffer->cleargc, x, xmesa->xm_buffer->height - y - height, width, height ); @@ -4473,7 +4493,6 @@ static void read_color_span( const GLcontext *ctx, rgba[i][GCOMP] = ptr3[i].g; rgba[i][BCOMP] = ptr3[i].b; rgba[i][ACOMP] = 255; - ptr3++; } } break; @@ -5219,8 +5238,12 @@ void xmesa_update_state( GLcontext *ctx ) /* setup pointers to front and back buffer clear functions */ /* XXX this bit of code could be moved to a one-time init */ - xmesa->xm_buffer->front_clear_func = clear_pixmap; - if (sizeof(GLushort)!=2 || sizeof(GLuint)!=4) { + xmesa->xm_buffer->front_clear_func = clear_front_pixmap; + if (xmesa->xm_buffer->backpixmap != XIMAGE) { + /* back buffer is a pixmap */ + xmesa->xm_buffer->back_clear_func = clear_back_pixmap; + } + else if (sizeof(GLushort)!=2 || sizeof(GLuint)!=4) { /* Do this on Crays */ xmesa->xm_buffer->back_clear_func = clear_nbit_ximage; } diff --git a/xc/extras/Mesa/src/X/xmesaP.h b/xc/extras/Mesa/src/X/xmesaP.h index 29d7ce51b..9b79f4314 100644 --- a/xc/extras/Mesa/src/X/xmesaP.h +++ b/xc/extras/Mesa/src/X/xmesaP.h @@ -77,7 +77,7 @@ struct xmesa_visual { GLvisual *gl_visual; /* Device independent visual parameters */ XMesaDisplay *display; /* The X11 display */ #ifdef XFree86Server - GLint screen_depth; /* The depth of the screen */ + GLint screen_depth; /* The depth of the screen */ #else XVisualInfo *vishandle; /* The pointer returned by glXChooseVisual */ #endif @@ -196,7 +196,7 @@ struct xmesa_buffer { GLint ximage_width1; GLushort *ximage_origin2; /* used for PIXELADDR2 macro */ GLint ximage_width2; - bgr_t *ximage_origin3; /* used for PIXELADDR3 macro */ + GLubyte *ximage_origin3; /* used for PIXELADDR3 macro */ GLint ximage_width3; GLuint *ximage_origin4; /* used for PIXELADDR4 macro */ GLint ximage_width4; @@ -499,7 +499,7 @@ static int const kernel1[16] = { ( (BUFFER)->ximage_origin2 - (Y) * (BUFFER)->ximage_width2 + (X) ) #define PIXELADDR3( BUFFER, X, Y ) \ - ( (BUFFER)->ximage_origin3 - (Y) * (BUFFER)->ximage_width3 + (X) ) + ( (bgr_t *) ( (BUFFER)->ximage_origin3 - (Y) * (BUFFER)->ximage_width3 + 3 * (X) )) #define PIXELADDR4( BUFFER, X, Y ) \ ( (BUFFER)->ximage_origin4 - (Y) * (BUFFER)->ximage_width4 + (X) ) diff --git a/xc/extras/Mesa/src/X86/glapi_x86.S b/xc/extras/Mesa/src/X86/glapi_x86.S index 7429c0f42..a9566ea46 100644 --- a/xc/extras/Mesa/src/X86/glapi_x86.S +++ b/xc/extras/Mesa/src/X86/glapi_x86.S @@ -26,6 +26,9 @@ /* * X86-optimized dispatch code contibuted by Josh Vanderhoof + * + * This file will be machine-generated from the gl.spec file at some point + * in the future. */ @@ -3317,8 +3320,8 @@ GLOBL_FN(GL_PREFIX(BlendColorEXT)) GL_PREFIX(BlendColorEXT): MOV_L(GLNAME(_glapi_Dispatch), EAX) TEST_L(EAX, EAX) - JZ(GLNAME(_glapi_fallback_BlendColorEXT)) - JMP(GL_OFFSET(_gloffset_BlendColorEXT)) + JZ(GLNAME(_glapi_fallback_BlendColor)) + JMP(GL_OFFSET(_gloffset_BlendColor)) ALIGNTEXT16 GLOBL_FN(GL_PREFIX(PolygonOffsetEXT)) @@ -3333,24 +3336,24 @@ GLOBL_FN(GL_PREFIX(TexImage3DEXT)) GL_PREFIX(TexImage3DEXT): MOV_L(GLNAME(_glapi_Dispatch), EAX) TEST_L(EAX, EAX) - JZ(GLNAME(_glapi_fallback_TexImage3DEXT)) - JMP(GL_OFFSET(_gloffset_TexImage3DEXT)) + JZ(GLNAME(_glapi_fallback_TexImage3D)) + JMP(GL_OFFSET(_gloffset_TexImage3D)) ALIGNTEXT16 GLOBL_FN(GL_PREFIX(TexSubImage3DEXT)) GL_PREFIX(TexSubImage3DEXT): MOV_L(GLNAME(_glapi_Dispatch), EAX) TEST_L(EAX, EAX) - JZ(GLNAME(_glapi_fallback_TexSubImage3DEXT)) - JMP(GL_OFFSET(_gloffset_TexSubImage3DEXT)) + JZ(GLNAME(_glapi_fallback_TexSubImage3D)) + JMP(GL_OFFSET(_gloffset_TexSubImage3D)) ALIGNTEXT16 GLOBL_FN(GL_PREFIX(CopyTexSubImage3DEXT)) GL_PREFIX(CopyTexSubImage3DEXT): MOV_L(GLNAME(_glapi_Dispatch), EAX) TEST_L(EAX, EAX) - JZ(GLNAME(_glapi_fallback_CopyTexSubImage3DEXT)) - JMP(GL_OFFSET(_gloffset_CopyTexSubImage3DEXT)) + JZ(GLNAME(_glapi_fallback_CopyTexSubImage3D)) + JMP(GL_OFFSET(_gloffset_CopyTexSubImage3D)) ALIGNTEXT16 GLOBL_FN(GL_PREFIX(GetTexFilterFuncSGIS)) @@ -3373,48 +3376,48 @@ GLOBL_FN(GL_PREFIX(CopyTexSubImage1DEXT)) GL_PREFIX(CopyTexSubImage1DEXT): MOV_L(GLNAME(_glapi_Dispatch), EAX) TEST_L(EAX, EAX) - JZ(GLNAME(_glapi_fallback_CopyTexSubImage1DEXT)) - JMP(GL_OFFSET(_gloffset_CopyTexSubImage1DEXT)) + JZ(GLNAME(_glapi_fallback_CopyTexSubImage1D)) + JMP(GL_OFFSET(_gloffset_CopyTexSubImage1D)) ALIGNTEXT16 GLOBL_FN(GL_PREFIX(TexSubImage1DEXT)) GL_PREFIX(TexSubImage1DEXT): MOV_L(GLNAME(_glapi_Dispatch), EAX) TEST_L(EAX, EAX) - JZ(GLNAME(_glapi_fallback_TexSubImage1DEXT)) - JMP(GL_OFFSET(_gloffset_TexSubImage1DEXT)) + JZ(GLNAME(_glapi_fallback_TexSubImage1D)) + JMP(GL_OFFSET(_gloffset_TexSubImage1D)) ALIGNTEXT16 GLOBL_FN(GL_PREFIX(TexSubImage2DEXT)) GL_PREFIX(TexSubImage2DEXT): MOV_L(GLNAME(_glapi_Dispatch), EAX) TEST_L(EAX, EAX) - JZ(GLNAME(_glapi_fallback_TexSubImage2DEXT)) - JMP(GL_OFFSET(_gloffset_TexSubImage2DEXT)) + JZ(GLNAME(_glapi_fallback_TexSubImage2D)) + JMP(GL_OFFSET(_gloffset_TexSubImage2D)) ALIGNTEXT16 GLOBL_FN(GL_PREFIX(CopyTexImage1DEXT)) GL_PREFIX(CopyTexImage1DEXT): MOV_L(GLNAME(_glapi_Dispatch), EAX) TEST_L(EAX, EAX) - JZ(GLNAME(_glapi_fallback_CopyTexImage1DEXT)) - JMP(GL_OFFSET(_gloffset_CopyTexImage1DEXT)) + JZ(GLNAME(_glapi_fallback_CopyTexImage1D)) + JMP(GL_OFFSET(_gloffset_CopyTexImage1D)) ALIGNTEXT16 GLOBL_FN(GL_PREFIX(CopyTexImage2DEXT)) GL_PREFIX(CopyTexImage2DEXT): MOV_L(GLNAME(_glapi_Dispatch), EAX) TEST_L(EAX, EAX) - JZ(GLNAME(_glapi_fallback_CopyTexImage2DEXT)) - JMP(GL_OFFSET(_gloffset_CopyTexImage2DEXT)) + JZ(GLNAME(_glapi_fallback_CopyTexImage2D)) + JMP(GL_OFFSET(_gloffset_CopyTexImage2D)) ALIGNTEXT16 GLOBL_FN(GL_PREFIX(CopyTexSubImage2DEXT)) GL_PREFIX(CopyTexSubImage2DEXT): MOV_L(GLNAME(_glapi_Dispatch), EAX) TEST_L(EAX, EAX) - JZ(GLNAME(_glapi_fallback_CopyTexSubImage2DEXT)) - JMP(GL_OFFSET(_gloffset_CopyTexSubImage2DEXT)) + JZ(GLNAME(_glapi_fallback_CopyTexSubImage2D)) + JMP(GL_OFFSET(_gloffset_CopyTexSubImage2D)) ALIGNTEXT16 GLOBL_FN(GL_PREFIX(GetHistogramEXT)) @@ -3469,96 +3472,96 @@ GLOBL_FN(GL_PREFIX(HistogramEXT)) GL_PREFIX(HistogramEXT): MOV_L(GLNAME(_glapi_Dispatch), EAX) TEST_L(EAX, EAX) - JZ(GLNAME(_glapi_fallback_HistogramEXT)) - JMP(GL_OFFSET(_gloffset_HistogramEXT)) + JZ(GLNAME(_glapi_fallback_Histogram)) + JMP(GL_OFFSET(_gloffset_Histogram)) ALIGNTEXT16 GLOBL_FN(GL_PREFIX(MinmaxEXT)) GL_PREFIX(MinmaxEXT): MOV_L(GLNAME(_glapi_Dispatch), EAX) TEST_L(EAX, EAX) - JZ(GLNAME(_glapi_fallback_MinmaxEXT)) - JMP(GL_OFFSET(_gloffset_MinmaxEXT)) + JZ(GLNAME(_glapi_fallback_Minmax)) + JMP(GL_OFFSET(_gloffset_Minmax)) ALIGNTEXT16 GLOBL_FN(GL_PREFIX(ResetHistogramEXT)) GL_PREFIX(ResetHistogramEXT): MOV_L(GLNAME(_glapi_Dispatch), EAX) TEST_L(EAX, EAX) - JZ(GLNAME(_glapi_fallback_ResetHistogramEXT)) - JMP(GL_OFFSET(_gloffset_ResetHistogramEXT)) + JZ(GLNAME(_glapi_fallback_ResetHistogram)) + JMP(GL_OFFSET(_gloffset_ResetHistogram)) ALIGNTEXT16 GLOBL_FN(GL_PREFIX(ResetMinmaxEXT)) GL_PREFIX(ResetMinmaxEXT): MOV_L(GLNAME(_glapi_Dispatch), EAX) TEST_L(EAX, EAX) - JZ(GLNAME(_glapi_fallback_ResetMinmaxEXT)) - JMP(GL_OFFSET(_gloffset_ResetMinmaxEXT)) + JZ(GLNAME(_glapi_fallback_ResetMinmax)) + JMP(GL_OFFSET(_gloffset_ResetMinmax)) ALIGNTEXT16 GLOBL_FN(GL_PREFIX(ConvolutionFilter1DEXT)) GL_PREFIX(ConvolutionFilter1DEXT): MOV_L(GLNAME(_glapi_Dispatch), EAX) TEST_L(EAX, EAX) - JZ(GLNAME(_glapi_fallback_ConvolutionFilter1DEXT)) - JMP(GL_OFFSET(_gloffset_ConvolutionFilter1DEXT)) + JZ(GLNAME(_glapi_fallback_ConvolutionFilter1D)) + JMP(GL_OFFSET(_gloffset_ConvolutionFilter1D)) ALIGNTEXT16 GLOBL_FN(GL_PREFIX(ConvolutionFilter2DEXT)) GL_PREFIX(ConvolutionFilter2DEXT): MOV_L(GLNAME(_glapi_Dispatch), EAX) TEST_L(EAX, EAX) - JZ(GLNAME(_glapi_fallback_ConvolutionFilter2DEXT)) - JMP(GL_OFFSET(_gloffset_ConvolutionFilter2DEXT)) + JZ(GLNAME(_glapi_fallback_ConvolutionFilter2D)) + JMP(GL_OFFSET(_gloffset_ConvolutionFilter2D)) ALIGNTEXT16 GLOBL_FN(GL_PREFIX(ConvolutionParameterfEXT)) GL_PREFIX(ConvolutionParameterfEXT): MOV_L(GLNAME(_glapi_Dispatch), EAX) TEST_L(EAX, EAX) - JZ(GLNAME(_glapi_fallback_ConvolutionParameterfEXT)) - JMP(GL_OFFSET(_gloffset_ConvolutionParameterfEXT)) + JZ(GLNAME(_glapi_fallback_ConvolutionParameterf)) + JMP(GL_OFFSET(_gloffset_ConvolutionParameterf)) ALIGNTEXT16 GLOBL_FN(GL_PREFIX(ConvolutionParameterfvEXT)) GL_PREFIX(ConvolutionParameterfvEXT): MOV_L(GLNAME(_glapi_Dispatch), EAX) TEST_L(EAX, EAX) - JZ(GLNAME(_glapi_fallback_ConvolutionParameterfvEXT)) - JMP(GL_OFFSET(_gloffset_ConvolutionParameterfvEXT)) + JZ(GLNAME(_glapi_fallback_ConvolutionParameterfv)) + JMP(GL_OFFSET(_gloffset_ConvolutionParameterfv)) ALIGNTEXT16 GLOBL_FN(GL_PREFIX(ConvolutionParameteriEXT)) GL_PREFIX(ConvolutionParameteriEXT): MOV_L(GLNAME(_glapi_Dispatch), EAX) TEST_L(EAX, EAX) - JZ(GLNAME(_glapi_fallback_ConvolutionParameteriEXT)) - JMP(GL_OFFSET(_gloffset_ConvolutionParameteriEXT)) + JZ(GLNAME(_glapi_fallback_ConvolutionParameteri)) + JMP(GL_OFFSET(_gloffset_ConvolutionParameteri)) ALIGNTEXT16 GLOBL_FN(GL_PREFIX(ConvolutionParameterivEXT)) GL_PREFIX(ConvolutionParameterivEXT): MOV_L(GLNAME(_glapi_Dispatch), EAX) TEST_L(EAX, EAX) - JZ(GLNAME(_glapi_fallback_ConvolutionParameterivEXT)) - JMP(GL_OFFSET(_gloffset_ConvolutionParameterivEXT)) + JZ(GLNAME(_glapi_fallback_ConvolutionParameteriv)) + JMP(GL_OFFSET(_gloffset_ConvolutionParameteriv)) ALIGNTEXT16 GLOBL_FN(GL_PREFIX(CopyConvolutionFilter1DEXT)) GL_PREFIX(CopyConvolutionFilter1DEXT): MOV_L(GLNAME(_glapi_Dispatch), EAX) TEST_L(EAX, EAX) - JZ(GLNAME(_glapi_fallback_CopyConvolutionFilter1DEXT)) - JMP(GL_OFFSET(_gloffset_CopyConvolutionFilter1DEXT)) + JZ(GLNAME(_glapi_fallback_CopyConvolutionFilter1D)) + JMP(GL_OFFSET(_gloffset_CopyConvolutionFilter1D)) ALIGNTEXT16 GLOBL_FN(GL_PREFIX(CopyConvolutionFilter2DEXT)) GL_PREFIX(CopyConvolutionFilter2DEXT): MOV_L(GLNAME(_glapi_Dispatch), EAX) TEST_L(EAX, EAX) - JZ(GLNAME(_glapi_fallback_CopyConvolutionFilter2DEXT)) - JMP(GL_OFFSET(_gloffset_CopyConvolutionFilter2DEXT)) + JZ(GLNAME(_glapi_fallback_CopyConvolutionFilter2D)) + JMP(GL_OFFSET(_gloffset_CopyConvolutionFilter2D)) ALIGNTEXT16 GLOBL_FN(GL_PREFIX(GetConvolutionFilterEXT)) @@ -3597,40 +3600,40 @@ GLOBL_FN(GL_PREFIX(SeparableFilter2DEXT)) GL_PREFIX(SeparableFilter2DEXT): MOV_L(GLNAME(_glapi_Dispatch), EAX) TEST_L(EAX, EAX) - JZ(GLNAME(_glapi_fallback_SeparableFilter2DEXT)) - JMP(GL_OFFSET(_gloffset_SeparableFilter2DEXT)) + JZ(GLNAME(_glapi_fallback_SeparableFilter2D)) + JMP(GL_OFFSET(_gloffset_SeparableFilter2D)) ALIGNTEXT16 GLOBL_FN(GL_PREFIX(ColorTableParameterfvSGI)) GL_PREFIX(ColorTableParameterfvSGI): MOV_L(GLNAME(_glapi_Dispatch), EAX) TEST_L(EAX, EAX) - JZ(GLNAME(_glapi_fallback_ColorTableParameterfvSGI)) - JMP(GL_OFFSET(_gloffset_ColorTableParameterfvSGI)) + JZ(GLNAME(_glapi_fallback_ColorTableParameterfv)) + JMP(GL_OFFSET(_gloffset_ColorTableParameterfv)) ALIGNTEXT16 GLOBL_FN(GL_PREFIX(ColorTableParameterivSGI)) GL_PREFIX(ColorTableParameterivSGI): MOV_L(GLNAME(_glapi_Dispatch), EAX) TEST_L(EAX, EAX) - JZ(GLNAME(_glapi_fallback_ColorTableParameterivSGI)) - JMP(GL_OFFSET(_gloffset_ColorTableParameterivSGI)) + JZ(GLNAME(_glapi_fallback_ColorTableParameteriv)) + JMP(GL_OFFSET(_gloffset_ColorTableParameteriv)) ALIGNTEXT16 GLOBL_FN(GL_PREFIX(ColorTableSGI)) GL_PREFIX(ColorTableSGI): MOV_L(GLNAME(_glapi_Dispatch), EAX) TEST_L(EAX, EAX) - JZ(GLNAME(_glapi_fallback_ColorTableSGI)) - JMP(GL_OFFSET(_gloffset_ColorTableSGI)) + JZ(GLNAME(_glapi_fallback_ColorTable)) + JMP(GL_OFFSET(_gloffset_ColorTable)) ALIGNTEXT16 GLOBL_FN(GL_PREFIX(CopyColorTableSGI)) GL_PREFIX(CopyColorTableSGI): MOV_L(GLNAME(_glapi_Dispatch), EAX) TEST_L(EAX, EAX) - JZ(GLNAME(_glapi_fallback_CopyColorTableSGI)) - JMP(GL_OFFSET(_gloffset_CopyColorTableSGI)) + JZ(GLNAME(_glapi_fallback_CopyColorTable)) + JMP(GL_OFFSET(_gloffset_CopyColorTable)) ALIGNTEXT16 GLOBL_FN(GL_PREFIX(GetColorTableSGI)) @@ -3669,24 +3672,24 @@ GLOBL_FN(GL_PREFIX(DeleteTexturesEXT)) GL_PREFIX(DeleteTexturesEXT): MOV_L(GLNAME(_glapi_Dispatch), EAX) TEST_L(EAX, EAX) - JZ(GLNAME(_glapi_fallback_DeleteTexturesEXT)) - JMP(GL_OFFSET(_gloffset_DeleteTexturesEXT)) + JZ(GLNAME(_glapi_fallback_DeleteTextures)) + JMP(GL_OFFSET(_gloffset_DeleteTextures)) ALIGNTEXT16 GLOBL_FN(GL_PREFIX(BindTextureEXT)) GL_PREFIX(BindTextureEXT): MOV_L(GLNAME(_glapi_Dispatch), EAX) TEST_L(EAX, EAX) - JZ(GLNAME(_glapi_fallback_BindTextureEXT)) - JMP(GL_OFFSET(_gloffset_BindTextureEXT)) + JZ(GLNAME(_glapi_fallback_BindTexture)) + JMP(GL_OFFSET(_gloffset_BindTexture)) ALIGNTEXT16 GLOBL_FN(GL_PREFIX(PrioritizeTexturesEXT)) GL_PREFIX(PrioritizeTexturesEXT): MOV_L(GLNAME(_glapi_Dispatch), EAX) TEST_L(EAX, EAX) - JZ(GLNAME(_glapi_fallback_PrioritizeTexturesEXT)) - JMP(GL_OFFSET(_gloffset_PrioritizeTexturesEXT)) + JZ(GLNAME(_glapi_fallback_PrioritizeTextures)) + JMP(GL_OFFSET(_gloffset_PrioritizeTextures)) ALIGNTEXT16 GLOBL_FN(GL_PREFIX(AreTexturesResidentEXT)) @@ -3709,8 +3712,8 @@ GLOBL_FN(GL_PREFIX(BlendEquationEXT)) GL_PREFIX(BlendEquationEXT): MOV_L(GLNAME(_glapi_Dispatch), EAX) TEST_L(EAX, EAX) - JZ(GLNAME(_glapi_fallback_BlendEquationEXT)) - JMP(GL_OFFSET(_gloffset_BlendEquationEXT)) + JZ(GLNAME(_glapi_fallback_BlendEquation)) + JMP(GL_OFFSET(_gloffset_BlendEquation)) ALIGNTEXT16 GLOBL_FN(GL_PREFIX(VertexPointerEXT)) @@ -3747,24 +3750,24 @@ GLOBL_FN(GL_PREFIX(GetPointervEXT)) GL_PREFIX(GetPointervEXT): MOV_L(GLNAME(_glapi_Dispatch), EAX) TEST_L(EAX, EAX) - JZ(GLNAME(_glapi_fallback_GetPointervEXT)) - JMP(GL_OFFSET(_gloffset_GetPointervEXT)) + JZ(GLNAME(_glapi_fallback_GetPointerv)) + JMP(GL_OFFSET(_gloffset_GetPointerv)) ALIGNTEXT16 GLOBL_FN(GL_PREFIX(ArrayElementEXT)) GL_PREFIX(ArrayElementEXT): MOV_L(GLNAME(_glapi_Dispatch), EAX) TEST_L(EAX, EAX) - JZ(GLNAME(_glapi_fallback_ArrayElementEXT)) - JMP(GL_OFFSET(_gloffset_ArrayElementEXT)) + JZ(GLNAME(_glapi_fallback_ArrayElement)) + JMP(GL_OFFSET(_gloffset_ArrayElement)) ALIGNTEXT16 GLOBL_FN(GL_PREFIX(DrawArraysEXT)) GL_PREFIX(DrawArraysEXT): MOV_L(GLNAME(_glapi_Dispatch), EAX) TEST_L(EAX, EAX) - JZ(GLNAME(_glapi_fallback_DrawArraysEXT)) - JMP(GL_OFFSET(_gloffset_DrawArraysEXT)) + JZ(GLNAME(_glapi_fallback_DrawArrays)) + JMP(GL_OFFSET(_gloffset_DrawArrays)) ALIGNTEXT16 GLOBL_FN(GL_PREFIX(PointParameterfEXT)) @@ -3795,16 +3798,16 @@ GLOBL_FN(GL_PREFIX(ColorTableEXT)) GL_PREFIX(ColorTableEXT): MOV_L(GLNAME(_glapi_Dispatch), EAX) TEST_L(EAX, EAX) - JZ(GLNAME(_glapi_fallback_ColorTableEXT)) - JMP(GL_OFFSET(_gloffset_ColorTableEXT)) + JZ(GLNAME(_glapi_fallback_ColorTable)) + JMP(GL_OFFSET(_gloffset_ColorTable)) ALIGNTEXT16 GLOBL_FN(GL_PREFIX(ColorSubTableEXT)) GL_PREFIX(ColorSubTableEXT): MOV_L(GLNAME(_glapi_Dispatch), EAX) TEST_L(EAX, EAX) - JZ(GLNAME(_glapi_fallback_ColorSubTableEXT)) - JMP(GL_OFFSET(_gloffset_ColorSubTableEXT)) + JZ(GLNAME(_glapi_fallback_ColorSubTable)) + JMP(GL_OFFSET(_gloffset_ColorSubTable)) ALIGNTEXT16 GLOBL_FN(GL_PREFIX(GetColorTableEXT)) @@ -3851,8 +3854,8 @@ GLOBL_FN(GL_PREFIX(BlendFuncSeparateINGR)) GL_PREFIX(BlendFuncSeparateINGR): MOV_L(GLNAME(_glapi_Dispatch), EAX) TEST_L(EAX, EAX) - JZ(GLNAME(_glapi_fallback_BlendFuncSeparateINGR)) - JMP(GL_OFFSET(_gloffset_BlendFuncSeparateINGR)) + JZ(GLNAME(_glapi_fallback_BlendFuncSeparateEXT)) + JMP(GL_OFFSET(_gloffset_BlendFuncSeparateEXT)) ALIGNTEXT16 GLOBL_FN(GL_PREFIX(WindowPos2iMESA)) @@ -4017,4 +4020,652 @@ GL_PREFIX(MultTransposeMatrixfARB): JZ(GLNAME(_glapi_fallback_MultTransposeMatrixfARB)) JMP(GL_OFFSET(_gloffset_MultTransposeMatrixfARB)) +ALIGNTEXT16 +GLOBL_FN(GL_PREFIX(PixelTexGenParameterfSGIS)) +GL_PREFIX(PixelTexGenParameterfSGIS): + MOV_L(GLNAME(_glapi_Dispatch), EAX) + TEST_L(EAX, EAX) + JZ(GLNAME(_glapi_fallback_PixelTexGenParameterfSGIS)) + JMP(GL_OFFSET(_gloffset_PixelTexGenParameterfSGIS)) + +ALIGNTEXT16 +GLOBL_FN(GL_PREFIX(PixelTexGenParameteriSGIS)) +GL_PREFIX(PixelTexGenParameteriSGIS): + MOV_L(GLNAME(_glapi_Dispatch), EAX) + TEST_L(EAX, EAX) + JZ(GLNAME(_glapi_fallback_PixelTexGenParameteriSGIS)) + JMP(GL_OFFSET(_gloffset_PixelTexGenParameteriSGIS)) + +ALIGNTEXT16 +GLOBL_FN(GL_PREFIX(GetPixelTexGenParameterfvSGIS)) +GL_PREFIX(GetPixelTexGenParameterfvSGIS): + MOV_L(GLNAME(_glapi_Dispatch), EAX) + TEST_L(EAX, EAX) + JZ(GLNAME(_glapi_fallback_GetPixelTexGenParameterfvSGIS)) + JMP(GL_OFFSET(_gloffset_GetPixelTexGenParameterfvSGIS)) + +ALIGNTEXT16 +GLOBL_FN(GL_PREFIX(GetPixelTexGenParameterivSGIS)) +GL_PREFIX(GetPixelTexGenParameterivSGIS): + MOV_L(GLNAME(_glapi_Dispatch), EAX) + TEST_L(EAX, EAX) + JZ(GLNAME(_glapi_fallback_GetPixelTexGenParameterivSGIS)) + JMP(GL_OFFSET(_gloffset_GetPixelTexGenParameterivSGIS)) + +ALIGNTEXT16 +GLOBL_FN(GL_PREFIX(TexImage4DSGIS)) +GL_PREFIX(TexImage4DSGIS): + MOV_L(GLNAME(_glapi_Dispatch), EAX) + TEST_L(EAX, EAX) + JZ(GLNAME(_glapi_fallback_TexImage4DSGIS)) + JMP(GL_OFFSET(_gloffset_TexImage4DSGIS)) + +ALIGNTEXT16 +GLOBL_FN(GL_PREFIX(TexSubImage4DSGIS)) +GL_PREFIX(TexSubImage4DSGIS): + MOV_L(GLNAME(_glapi_Dispatch), EAX) + TEST_L(EAX, EAX) + JZ(GLNAME(_glapi_fallback_TexSubImage4DSGIS)) + JMP(GL_OFFSET(_gloffset_TexSubImage4DSGIS)) + +ALIGNTEXT16 +GLOBL_FN(GL_PREFIX(DetailTexFuncSGIS)) +GL_PREFIX(DetailTexFuncSGIS): + MOV_L(GLNAME(_glapi_Dispatch), EAX) + TEST_L(EAX, EAX) + JZ(GLNAME(_glapi_fallback_DetailTexFuncSGIS)) + JMP(GL_OFFSET(_gloffset_DetailTexFuncSGIS)) + +ALIGNTEXT16 +GLOBL_FN(GL_PREFIX(GetDetailTexFuncSGIS)) +GL_PREFIX(GetDetailTexFuncSGIS): + MOV_L(GLNAME(_glapi_Dispatch), EAX) + TEST_L(EAX, EAX) + JZ(GLNAME(_glapi_fallback_GetDetailTexFuncSGIS)) + JMP(GL_OFFSET(_gloffset_GetDetailTexFuncSGIS)) + +ALIGNTEXT16 +GLOBL_FN(GL_PREFIX(GetSharpenTexFuncSGIS)) +GL_PREFIX(GetSharpenTexFuncSGIS): + MOV_L(GLNAME(_glapi_Dispatch), EAX) + TEST_L(EAX, EAX) + JZ(GLNAME(_glapi_fallback_GetSharpenTexFuncSGIS)) + JMP(GL_OFFSET(_gloffset_GetSharpenTexFuncSGIS)) + +ALIGNTEXT16 +GLOBL_FN(GL_PREFIX(SharpenTexFuncSGIS)) +GL_PREFIX(SharpenTexFuncSGIS): + MOV_L(GLNAME(_glapi_Dispatch), EAX) + TEST_L(EAX, EAX) + JZ(GLNAME(_glapi_fallback_SharpenTexFuncSGIS)) + JMP(GL_OFFSET(_gloffset_SharpenTexFuncSGIS)) + +ALIGNTEXT16 +GLOBL_FN(GL_PREFIX(SampleMaskSGIS)) +GL_PREFIX(SampleMaskSGIS): + MOV_L(GLNAME(_glapi_Dispatch), EAX) + TEST_L(EAX, EAX) + JZ(GLNAME(_glapi_fallback_SampleMaskSGIS)) + JMP(GL_OFFSET(_gloffset_SampleMaskSGIS)) + +ALIGNTEXT16 +GLOBL_FN(GL_PREFIX(SamplePatternSGIS)) +GL_PREFIX(SamplePatternSGIS): + MOV_L(GLNAME(_glapi_Dispatch), EAX) + TEST_L(EAX, EAX) + JZ(GLNAME(_glapi_fallback_SamplePatternSGIS)) + JMP(GL_OFFSET(_gloffset_SamplePatternSGIS)) + +ALIGNTEXT16 +GLOBL_FN(GL_PREFIX(SpriteParameterfSGIX)) +GL_PREFIX(SpriteParameterfSGIX): + MOV_L(GLNAME(_glapi_Dispatch), EAX) + TEST_L(EAX, EAX) + JZ(GLNAME(_glapi_fallback_SpriteParameterfSGIX)) + JMP(GL_OFFSET(_gloffset_SpriteParameterfSGIX)) + +ALIGNTEXT16 +GLOBL_FN(GL_PREFIX(SpriteParameteriSGIX)) +GL_PREFIX(SpriteParameteriSGIX): + MOV_L(GLNAME(_glapi_Dispatch), EAX) + TEST_L(EAX, EAX) + JZ(GLNAME(_glapi_fallback_SpriteParameteriSGIX)) + JMP(GL_OFFSET(_gloffset_SpriteParameteriSGIX)) + +ALIGNTEXT16 +GLOBL_FN(GL_PREFIX(SpriteParameterfvSGIX)) +GL_PREFIX(SpriteParameterfvSGIX): + MOV_L(GLNAME(_glapi_Dispatch), EAX) + TEST_L(EAX, EAX) + JZ(GLNAME(_glapi_fallback_SpriteParameterfvSGIX)) + JMP(GL_OFFSET(_gloffset_SpriteParameterfvSGIX)) + +ALIGNTEXT16 +GLOBL_FN(GL_PREFIX(SpriteParameterivSGIX)) +GL_PREFIX(SpriteParameterivSGIX): + MOV_L(GLNAME(_glapi_Dispatch), EAX) + TEST_L(EAX, EAX) + JZ(GLNAME(_glapi_fallback_SpriteParameterivSGIX)) + JMP(GL_OFFSET(_gloffset_SpriteParameterivSGIX)) + +ALIGNTEXT16 +GLOBL_FN(GL_PREFIX(InstrumentsBufferSGIX)) +GL_PREFIX(InstrumentsBufferSGIX): + MOV_L(GLNAME(_glapi_Dispatch), EAX) + TEST_L(EAX, EAX) + JZ(GLNAME(_glapi_fallback_InstrumentsBufferSGIX)) + JMP(GL_OFFSET(_gloffset_InstrumentsBufferSGIX)) + +ALIGNTEXT16 +GLOBL_FN(GL_PREFIX(StartInstrumentsSGIX)) +GL_PREFIX(StartInstrumentsSGIX): + MOV_L(GLNAME(_glapi_Dispatch), EAX) + TEST_L(EAX, EAX) + JZ(GLNAME(_glapi_fallback_StartInstrumentsSGIX)) + JMP(GL_OFFSET(_gloffset_StartInstrumentsSGIX)) + +ALIGNTEXT16 +GLOBL_FN(GL_PREFIX(StopInstrumentsSGIX)) +GL_PREFIX(StopInstrumentsSGIX): + MOV_L(GLNAME(_glapi_Dispatch), EAX) + TEST_L(EAX, EAX) + JZ(GLNAME(_glapi_fallback_StopInstrumentsSGIX)) + JMP(GL_OFFSET(_gloffset_StopInstrumentsSGIX)) + +ALIGNTEXT16 +GLOBL_FN(GL_PREFIX(ReadInstrumentsSGIX)) +GL_PREFIX(ReadInstrumentsSGIX): + MOV_L(GLNAME(_glapi_Dispatch), EAX) + TEST_L(EAX, EAX) + JZ(GLNAME(_glapi_fallback_ReadInstrumentsSGIX)) + JMP(GL_OFFSET(_gloffset_ReadInstrumentsSGIX)) + +ALIGNTEXT16 +GLOBL_FN(GL_PREFIX(PollInstrumentsSGIX)) +GL_PREFIX(PollInstrumentsSGIX): + MOV_L(GLNAME(_glapi_Dispatch), EAX) + TEST_L(EAX, EAX) + JZ(GLNAME(_glapi_fallback_PollInstrumentsSGIX)) + JMP(GL_OFFSET(_gloffset_PollInstrumentsSGIX)) + +ALIGNTEXT16 +GLOBL_FN(GL_PREFIX(GetInstrumentsSGIX)) +GL_PREFIX(GetInstrumentsSGIX): + MOV_L(GLNAME(_glapi_Dispatch), EAX) + TEST_L(EAX, EAX) + JZ(GLNAME(_glapi_fallback_GetInstrumentsSGIX)) + JMP(GL_OFFSET(_gloffset_GetInstrumentsSGIX)) + +ALIGNTEXT16 +GLOBL_FN(GL_PREFIX(FrameZoomSGIX)) +GL_PREFIX(FrameZoomSGIX): + MOV_L(GLNAME(_glapi_Dispatch), EAX) + TEST_L(EAX, EAX) + JZ(GLNAME(_glapi_fallback_FrameZoomSGIX)) + JMP(GL_OFFSET(_gloffset_FrameZoomSGIX)) + +ALIGNTEXT16 +GLOBL_FN(GL_PREFIX(ReferencePlaneSGIX)) +GL_PREFIX(ReferencePlaneSGIX): + MOV_L(GLNAME(_glapi_Dispatch), EAX) + TEST_L(EAX, EAX) + JZ(GLNAME(_glapi_fallback_ReferencePlaneSGIX)) + JMP(GL_OFFSET(_gloffset_ReferencePlaneSGIX)) + +ALIGNTEXT16 +GLOBL_FN(GL_PREFIX(FlushRasterSGIX)) +GL_PREFIX(FlushRasterSGIX): + MOV_L(GLNAME(_glapi_Dispatch), EAX) + TEST_L(EAX, EAX) + JZ(GLNAME(_glapi_fallback_FlushRasterSGIX)) + JMP(GL_OFFSET(_gloffset_FlushRasterSGIX)) + +ALIGNTEXT16 +GLOBL_FN(GL_PREFIX(CopyColorSubTableEXT)) +GL_PREFIX(CopyColorSubTableEXT): + MOV_L(GLNAME(_glapi_Dispatch), EAX) + TEST_L(EAX, EAX) + JZ(GLNAME(_glapi_fallback_CopyColorSubTable)) + JMP(GL_OFFSET(_gloffset_CopyColorSubTable)) + +ALIGNTEXT16 +GLOBL_FN(GL_PREFIX(GetListParameterfvSGIX)) +GL_PREFIX(GetListParameterfvSGIX): + MOV_L(GLNAME(_glapi_Dispatch), EAX) + TEST_L(EAX, EAX) + JZ(GLNAME(_glapi_fallback_GetListParameterfvSGIX)) + JMP(GL_OFFSET(_gloffset_GetListParameterfvSGIX)) + +ALIGNTEXT16 +GLOBL_FN(GL_PREFIX(GetListParameterivSGIX)) +GL_PREFIX(GetListParameterivSGIX): + MOV_L(GLNAME(_glapi_Dispatch), EAX) + TEST_L(EAX, EAX) + JZ(GLNAME(_glapi_fallback_GetListParameterivSGIX)) + JMP(GL_OFFSET(_gloffset_GetListParameterivSGIX)) + +ALIGNTEXT16 +GLOBL_FN(GL_PREFIX(ListParameterfSGIX)) +GL_PREFIX(ListParameterfSGIX): + MOV_L(GLNAME(_glapi_Dispatch), EAX) + TEST_L(EAX, EAX) + JZ(GLNAME(_glapi_fallback_ListParameterfSGIX)) + JMP(GL_OFFSET(_gloffset_ListParameterfSGIX)) + +ALIGNTEXT16 +GLOBL_FN(GL_PREFIX(ListParameterfvSGIX)) +GL_PREFIX(ListParameterfvSGIX): + MOV_L(GLNAME(_glapi_Dispatch), EAX) + TEST_L(EAX, EAX) + JZ(GLNAME(_glapi_fallback_ListParameterfvSGIX)) + JMP(GL_OFFSET(_gloffset_ListParameterfvSGIX)) + +ALIGNTEXT16 +GLOBL_FN(GL_PREFIX(ListParameteriSGIX)) +GL_PREFIX(ListParameteriSGIX): + MOV_L(GLNAME(_glapi_Dispatch), EAX) + TEST_L(EAX, EAX) + JZ(GLNAME(_glapi_fallback_ListParameteriSGIX)) + JMP(GL_OFFSET(_gloffset_ListParameteriSGIX)) + +ALIGNTEXT16 +GLOBL_FN(GL_PREFIX(ListParameterivSGIX)) +GL_PREFIX(ListParameterivSGIX): + MOV_L(GLNAME(_glapi_Dispatch), EAX) + TEST_L(EAX, EAX) + JZ(GLNAME(_glapi_fallback_ListParameterivSGIX)) + JMP(GL_OFFSET(_gloffset_ListParameterivSGIX)) + +ALIGNTEXT16 +GLOBL_FN(GL_PREFIX(IndexMaterialEXT)) +GL_PREFIX(IndexMaterialEXT): + MOV_L(GLNAME(_glapi_Dispatch), EAX) + TEST_L(EAX, EAX) + JZ(GLNAME(_glapi_fallback_IndexMaterialEXT)) + JMP(GL_OFFSET(_gloffset_IndexMaterialEXT)) + +ALIGNTEXT16 +GLOBL_FN(GL_PREFIX(IndexFuncEXT)) +GL_PREFIX(IndexFuncEXT): + MOV_L(GLNAME(_glapi_Dispatch), EAX) + TEST_L(EAX, EAX) + JZ(GLNAME(_glapi_fallback_IndexFuncEXT)) + JMP(GL_OFFSET(_gloffset_IndexFuncEXT)) + +ALIGNTEXT16 +GLOBL_FN(GL_PREFIX(CullParameterdvEXT)) +GL_PREFIX(CullParameterdvEXT): + MOV_L(GLNAME(_glapi_Dispatch), EAX) + TEST_L(EAX, EAX) + JZ(GLNAME(_glapi_fallback_CullParameterdvEXT)) + JMP(GL_OFFSET(_gloffset_CullParameterdvEXT)) + +ALIGNTEXT16 +GLOBL_FN(GL_PREFIX(CullParameterfvEXT)) +GL_PREFIX(CullParameterfvEXT): + MOV_L(GLNAME(_glapi_Dispatch), EAX) + TEST_L(EAX, EAX) + JZ(GLNAME(_glapi_fallback_CullParameterfvEXT)) + JMP(GL_OFFSET(_gloffset_CullParameterfvEXT)) + +ALIGNTEXT16 +GLOBL_FN(GL_PREFIX(SampleCoverageARB)) +GL_PREFIX(SampleCoverageARB): + MOV_L(GLNAME(_glapi_Dispatch), EAX) + TEST_L(EAX, EAX) + JZ(GLNAME(_glapi_fallback_SampleCoverageARB)) + JMP(GL_OFFSET(_gloffset_SampleCoverageARB)) + +ALIGNTEXT16 +GLOBL_FN(GL_PREFIX(SamplePassARB)) +GL_PREFIX(SamplePassARB): + MOV_L(GLNAME(_glapi_Dispatch), EAX) + TEST_L(EAX, EAX) + JZ(GLNAME(_glapi_fallback_SamplePassARB)) + JMP(GL_OFFSET(_gloffset_SamplePassARB)) + +ALIGNTEXT16 +GLOBL_FN(GL_PREFIX(TagSampleBufferSGIX)) +GL_PREFIX(TagSampleBufferSGIX): + MOV_L(GLNAME(_glapi_Dispatch), EAX) + TEST_L(EAX, EAX) + JZ(GLNAME(_glapi_fallback_TagSampleBufferSGIX)) + JMP(GL_OFFSET(_gloffset_TagSampleBufferSGIX)) + +ALIGNTEXT16 +GLOBL_FN(GL_PREFIX(FragmentColorMaterialSGIX)) +GL_PREFIX(FragmentColorMaterialSGIX): + MOV_L(GLNAME(_glapi_Dispatch), EAX) + TEST_L(EAX, EAX) + JZ(GLNAME(_glapi_fallback_FragmentColorMaterialSGIX)) + JMP(GL_OFFSET(_gloffset_FragmentColorMaterialSGIX)) + +ALIGNTEXT16 +GLOBL_FN(GL_PREFIX(FragmentLightfSGIX)) +GL_PREFIX(FragmentLightfSGIX): + MOV_L(GLNAME(_glapi_Dispatch), EAX) + TEST_L(EAX, EAX) + JZ(GLNAME(_glapi_fallback_FragmentLightfSGIX)) + JMP(GL_OFFSET(_gloffset_FragmentLightfSGIX)) + +ALIGNTEXT16 +GLOBL_FN(GL_PREFIX(FragmentLightfvSGIX)) +GL_PREFIX(FragmentLightfvSGIX): + MOV_L(GLNAME(_glapi_Dispatch), EAX) + TEST_L(EAX, EAX) + JZ(GLNAME(_glapi_fallback_FragmentLightfvSGIX)) + JMP(GL_OFFSET(_gloffset_FragmentLightfvSGIX)) + +ALIGNTEXT16 +GLOBL_FN(GL_PREFIX(FragmentLightiSGIX)) +GL_PREFIX(FragmentLightiSGIX): + MOV_L(GLNAME(_glapi_Dispatch), EAX) + TEST_L(EAX, EAX) + JZ(GLNAME(_glapi_fallback_FragmentLightiSGIX)) + JMP(GL_OFFSET(_gloffset_FragmentLightiSGIX)) + +ALIGNTEXT16 +GLOBL_FN(GL_PREFIX(FragmentLightivSGIX)) +GL_PREFIX(FragmentLightivSGIX): + MOV_L(GLNAME(_glapi_Dispatch), EAX) + TEST_L(EAX, EAX) + JZ(GLNAME(_glapi_fallback_FragmentLightivSGIX)) + JMP(GL_OFFSET(_gloffset_FragmentLightivSGIX)) + +ALIGNTEXT16 +GLOBL_FN(GL_PREFIX(FragmentLightModelfSGIX)) +GL_PREFIX(FragmentLightModelfSGIX): + MOV_L(GLNAME(_glapi_Dispatch), EAX) + TEST_L(EAX, EAX) + JZ(GLNAME(_glapi_fallback_FragmentLightModelfSGIX)) + JMP(GL_OFFSET(_gloffset_FragmentLightModelfSGIX)) + +ALIGNTEXT16 +GLOBL_FN(GL_PREFIX(FragmentLightModelfvSGIX)) +GL_PREFIX(FragmentLightModelfvSGIX): + MOV_L(GLNAME(_glapi_Dispatch), EAX) + TEST_L(EAX, EAX) + JZ(GLNAME(_glapi_fallback_FragmentLightModelfvSGIX)) + JMP(GL_OFFSET(_gloffset_FragmentLightModelfvSGIX)) + +ALIGNTEXT16 +GLOBL_FN(GL_PREFIX(FragmentLightModeliSGIX)) +GL_PREFIX(FragmentLightModeliSGIX): + MOV_L(GLNAME(_glapi_Dispatch), EAX) + TEST_L(EAX, EAX) + JZ(GLNAME(_glapi_fallback_FragmentLightModeliSGIX)) + JMP(GL_OFFSET(_gloffset_FragmentLightModeliSGIX)) + +ALIGNTEXT16 +GLOBL_FN(GL_PREFIX(FragmentLightModelivSGIX)) +GL_PREFIX(FragmentLightModelivSGIX): + MOV_L(GLNAME(_glapi_Dispatch), EAX) + TEST_L(EAX, EAX) + JZ(GLNAME(_glapi_fallback_FragmentLightModelivSGIX)) + JMP(GL_OFFSET(_gloffset_FragmentLightModelivSGIX)) + +ALIGNTEXT16 +GLOBL_FN(GL_PREFIX(FragmentMaterialfSGIX)) +GL_PREFIX(FragmentMaterialfSGIX): + MOV_L(GLNAME(_glapi_Dispatch), EAX) + TEST_L(EAX, EAX) + JZ(GLNAME(_glapi_fallback_FragmentMaterialfSGIX)) + JMP(GL_OFFSET(_gloffset_FragmentMaterialfSGIX)) + +ALIGNTEXT16 +GLOBL_FN(GL_PREFIX(FragmentMaterialfvSGIX)) +GL_PREFIX(FragmentMaterialfvSGIX): + MOV_L(GLNAME(_glapi_Dispatch), EAX) + TEST_L(EAX, EAX) + JZ(GLNAME(_glapi_fallback_FragmentMaterialfvSGIX)) + JMP(GL_OFFSET(_gloffset_FragmentMaterialfvSGIX)) + +ALIGNTEXT16 +GLOBL_FN(GL_PREFIX(FragmentMaterialiSGIX)) +GL_PREFIX(FragmentMaterialiSGIX): + MOV_L(GLNAME(_glapi_Dispatch), EAX) + TEST_L(EAX, EAX) + JZ(GLNAME(_glapi_fallback_FragmentMaterialiSGIX)) + JMP(GL_OFFSET(_gloffset_FragmentMaterialiSGIX)) + +ALIGNTEXT16 +GLOBL_FN(GL_PREFIX(FragmentMaterialivSGIX)) +GL_PREFIX(FragmentMaterialivSGIX): + MOV_L(GLNAME(_glapi_Dispatch), EAX) + TEST_L(EAX, EAX) + JZ(GLNAME(_glapi_fallback_FragmentMaterialivSGIX)) + JMP(GL_OFFSET(_gloffset_FragmentMaterialivSGIX)) + +ALIGNTEXT16 +GLOBL_FN(GL_PREFIX(GetFragmentLightfvSGIX)) +GL_PREFIX(GetFragmentLightfvSGIX): + MOV_L(GLNAME(_glapi_Dispatch), EAX) + TEST_L(EAX, EAX) + JZ(GLNAME(_glapi_fallback_GetFragmentLightfvSGIX)) + JMP(GL_OFFSET(_gloffset_GetFragmentLightfvSGIX)) + +ALIGNTEXT16 +GLOBL_FN(GL_PREFIX(GetFragmentLightivSGIX)) +GL_PREFIX(GetFragmentLightivSGIX): + MOV_L(GLNAME(_glapi_Dispatch), EAX) + TEST_L(EAX, EAX) + JZ(GLNAME(_glapi_fallback_GetFragmentLightivSGIX)) + JMP(GL_OFFSET(_gloffset_GetFragmentLightivSGIX)) + +ALIGNTEXT16 +GLOBL_FN(GL_PREFIX(GetFragmentMaterialfvSGIX)) +GL_PREFIX(GetFragmentMaterialfvSGIX): + MOV_L(GLNAME(_glapi_Dispatch), EAX) + TEST_L(EAX, EAX) + JZ(GLNAME(_glapi_fallback_GetFragmentMaterialfvSGIX)) + JMP(GL_OFFSET(_gloffset_GetFragmentMaterialfvSGIX)) + +ALIGNTEXT16 +GLOBL_FN(GL_PREFIX(GetFragmentMaterialivSGIX)) +GL_PREFIX(GetFragmentMaterialivSGIX): + MOV_L(GLNAME(_glapi_Dispatch), EAX) + TEST_L(EAX, EAX) + JZ(GLNAME(_glapi_fallback_GetFragmentMaterialivSGIX)) + JMP(GL_OFFSET(_gloffset_GetFragmentMaterialivSGIX)) + +ALIGNTEXT16 +GLOBL_FN(GL_PREFIX(LightEnviSGIX)) +GL_PREFIX(LightEnviSGIX): + MOV_L(GLNAME(_glapi_Dispatch), EAX) + TEST_L(EAX, EAX) + JZ(GLNAME(_glapi_fallback_LightEnviSGIX)) + JMP(GL_OFFSET(_gloffset_LightEnviSGIX)) + +ALIGNTEXT16 +GLOBL_FN(GL_PREFIX(FogCoordfEXT)) +GL_PREFIX(FogCoordfEXT): + MOV_L(GLNAME(_glapi_Dispatch), EAX) + TEST_L(EAX, EAX) + JZ(GLNAME(_glapi_fallback_FogCoordfEXT)) + JMP(GL_OFFSET(_gloffset_FogCoordfEXT)) + +ALIGNTEXT16 +GLOBL_FN(GL_PREFIX(FogCoordfvEXT)) +GL_PREFIX(FogCoordfvEXT): + MOV_L(GLNAME(_glapi_Dispatch), EAX) + TEST_L(EAX, EAX) + JZ(GLNAME(_glapi_fallback_FogCoordfvEXT)) + JMP(GL_OFFSET(_gloffset_FogCoordfvEXT)) + +ALIGNTEXT16 +GLOBL_FN(GL_PREFIX(FogCoorddEXT)) +GL_PREFIX(FogCoorddEXT): + MOV_L(GLNAME(_glapi_Dispatch), EAX) + TEST_L(EAX, EAX) + JZ(GLNAME(_glapi_fallback_FogCoorddEXT)) + JMP(GL_OFFSET(_gloffset_FogCoorddEXT)) + +ALIGNTEXT16 +GLOBL_FN(GL_PREFIX(FogCoorddvEXT)) +GL_PREFIX(FogCoorddvEXT): + MOV_L(GLNAME(_glapi_Dispatch), EAX) + TEST_L(EAX, EAX) + JZ(GLNAME(_glapi_fallback_FogCoorddvEXT)) + JMP(GL_OFFSET(_gloffset_FogCoorddvEXT)) + +ALIGNTEXT16 +GLOBL_FN(GL_PREFIX(FogCoordPointerEXT)) +GL_PREFIX(FogCoordPointerEXT): + MOV_L(GLNAME(_glapi_Dispatch), EAX) + TEST_L(EAX, EAX) + JZ(GLNAME(_glapi_fallback_FogCoordPointerEXT)) + JMP(GL_OFFSET(_gloffset_FogCoordPointerEXT)) + +ALIGNTEXT16 +GLOBL_FN(GL_PREFIX(BlendFuncSeparateEXT)) +GL_PREFIX(BlendFuncSeparateEXT): + MOV_L(GLNAME(_glapi_Dispatch), EAX) + TEST_L(EAX, EAX) + JZ(GLNAME(_glapi_fallback_BlendFuncSeparateEXT)) + JMP(GL_OFFSET(_gloffset_BlendFuncSeparateEXT)) + +ALIGNTEXT16 +GLOBL_FN(GL_PREFIX(VertexWeightfEXT)) +GL_PREFIX(VertexWeightfEXT): + MOV_L(GLNAME(_glapi_Dispatch), EAX) + TEST_L(EAX, EAX) + JZ(GLNAME(_glapi_fallback_VertexWeightfEXT)) + JMP(GL_OFFSET(_gloffset_VertexWeightfEXT)) + +ALIGNTEXT16 +GLOBL_FN(GL_PREFIX(VertexWeightfvEXT)) +GL_PREFIX(VertexWeightfvEXT): + MOV_L(GLNAME(_glapi_Dispatch), EAX) + TEST_L(EAX, EAX) + JZ(GLNAME(_glapi_fallback_VertexWeightfvEXT)) + JMP(GL_OFFSET(_gloffset_VertexWeightfvEXT)) + +ALIGNTEXT16 +GLOBL_FN(GL_PREFIX(VertexWeightPointerEXT)) +GL_PREFIX(VertexWeightPointerEXT): + MOV_L(GLNAME(_glapi_Dispatch), EAX) + TEST_L(EAX, EAX) + JZ(GLNAME(_glapi_fallback_VertexWeightPointerEXT)) + JMP(GL_OFFSET(_gloffset_VertexWeightPointerEXT)) + +ALIGNTEXT16 +GLOBL_FN(GL_PREFIX(VertexArrayRangeNV)) +GL_PREFIX(VertexArrayRangeNV): + MOV_L(GLNAME(_glapi_Dispatch), EAX) + TEST_L(EAX, EAX) + JZ(GLNAME(_glapi_fallback_VertexArrayRangeNV)) + JMP(GL_OFFSET(_gloffset_VertexArrayRangeNV)) + +ALIGNTEXT16 +GLOBL_FN(GL_PREFIX(FlushVertexArrayRangeNV)) +GL_PREFIX(FlushVertexArrayRangeNV): + MOV_L(GLNAME(_glapi_Dispatch), EAX) + TEST_L(EAX, EAX) + JZ(GLNAME(_glapi_fallback_FlushVertexArrayRangeNV)) + JMP(GL_OFFSET(_gloffset_FlushVertexArrayRangeNV)) + +ALIGNTEXT16 +GLOBL_FN(GL_PREFIX(CombinerParameterfvNV)) +GL_PREFIX(CombinerParameterfvNV): + MOV_L(GLNAME(_glapi_Dispatch), EAX) + TEST_L(EAX, EAX) + JZ(GLNAME(_glapi_fallback_CombinerParameterfvNV)) + JMP(GL_OFFSET(_gloffset_CombinerParameterfvNV)) + +ALIGNTEXT16 +GLOBL_FN(GL_PREFIX(CombinerParameterfNV)) +GL_PREFIX(CombinerParameterfNV): + MOV_L(GLNAME(_glapi_Dispatch), EAX) + TEST_L(EAX, EAX) + JZ(GLNAME(_glapi_fallback_CombinerParameterfNV)) + JMP(GL_OFFSET(_gloffset_CombinerParameterfNV)) + +ALIGNTEXT16 +GLOBL_FN(GL_PREFIX(CombinerParameterivNV)) +GL_PREFIX(CombinerParameterivNV): + MOV_L(GLNAME(_glapi_Dispatch), EAX) + TEST_L(EAX, EAX) + JZ(GLNAME(_glapi_fallback_CombinerParameterivNV)) + JMP(GL_OFFSET(_gloffset_CombinerParameterivNV)) + +ALIGNTEXT16 +GLOBL_FN(GL_PREFIX(CombinerParameteriNV)) +GL_PREFIX(CombinerParameteriNV): + MOV_L(GLNAME(_glapi_Dispatch), EAX) + TEST_L(EAX, EAX) + JZ(GLNAME(_glapi_fallback_CombinerParameteriNV)) + JMP(GL_OFFSET(_gloffset_CombinerParameteriNV)) + +ALIGNTEXT16 +GLOBL_FN(GL_PREFIX(CombinerInputNV)) +GL_PREFIX(CombinerInputNV): + MOV_L(GLNAME(_glapi_Dispatch), EAX) + TEST_L(EAX, EAX) + JZ(GLNAME(_glapi_fallback_CombinerInputNV)) + JMP(GL_OFFSET(_gloffset_CombinerInputNV)) + +ALIGNTEXT16 +GLOBL_FN(GL_PREFIX(CombinerOutputNV)) +GL_PREFIX(CombinerOutputNV): + MOV_L(GLNAME(_glapi_Dispatch), EAX) + TEST_L(EAX, EAX) + JZ(GLNAME(_glapi_fallback_CombinerOutputNV)) + JMP(GL_OFFSET(_gloffset_CombinerOutputNV)) + +ALIGNTEXT16 +GLOBL_FN(GL_PREFIX(FinalCombinerInputNV)) +GL_PREFIX(FinalCombinerInputNV): + MOV_L(GLNAME(_glapi_Dispatch), EAX) + TEST_L(EAX, EAX) + JZ(GLNAME(_glapi_fallback_FinalCombinerInputNV)) + JMP(GL_OFFSET(_gloffset_FinalCombinerInputNV)) + +ALIGNTEXT16 +GLOBL_FN(GL_PREFIX(GetCombinerInputParameterfvNV)) +GL_PREFIX(GetCombinerInputParameterfvNV): + MOV_L(GLNAME(_glapi_Dispatch), EAX) + TEST_L(EAX, EAX) + JZ(GLNAME(_glapi_fallback_GetCombinerInputParameterfvNV)) + JMP(GL_OFFSET(_gloffset_GetCombinerInputParameterfvNV)) + +ALIGNTEXT16 +GLOBL_FN(GL_PREFIX(GetCombinerInputParameterivNV)) +GL_PREFIX(GetCombinerInputParameterivNV): + MOV_L(GLNAME(_glapi_Dispatch), EAX) + TEST_L(EAX, EAX) + JZ(GLNAME(_glapi_fallback_GetCombinerInputParameterivNV)) + JMP(GL_OFFSET(_gloffset_GetCombinerInputParameterivNV)) + +ALIGNTEXT16 +GLOBL_FN(GL_PREFIX(GetCombinerOutputParameterfvNV)) +GL_PREFIX(GetCombinerOutputParameterfvNV): + MOV_L(GLNAME(_glapi_Dispatch), EAX) + TEST_L(EAX, EAX) + JZ(GLNAME(_glapi_fallback_GetCombinerOutputParameterfvNV)) + JMP(GL_OFFSET(_gloffset_GetCombinerOutputParameterfvNV)) + +ALIGNTEXT16 +GLOBL_FN(GL_PREFIX(GetCombinerOutputParameterivNV)) +GL_PREFIX(GetCombinerOutputParameterivNV): + MOV_L(GLNAME(_glapi_Dispatch), EAX) + TEST_L(EAX, EAX) + JZ(GLNAME(_glapi_fallback_GetCombinerOutputParameterivNV)) + JMP(GL_OFFSET(_gloffset_GetCombinerOutputParameterivNV)) + +ALIGNTEXT16 +GLOBL_FN(GL_PREFIX(GetFinalCombinerInputParameterfvNV)) +GL_PREFIX(GetFinalCombinerInputParameterfvNV): + MOV_L(GLNAME(_glapi_Dispatch), EAX) + TEST_L(EAX, EAX) + JZ(GLNAME(_glapi_fallback_GetFinalCombinerInputParameterfvNV)) + JMP(GL_OFFSET(_gloffset_GetFinalCombinerInputParameterfvNV)) + +ALIGNTEXT16 +GLOBL_FN(GL_PREFIX(GetFinalCombinerInputParameterivNV)) +GL_PREFIX(GetFinalCombinerInputParameterivNV): + MOV_L(GLNAME(_glapi_Dispatch), EAX) + TEST_L(EAX, EAX) + JZ(GLNAME(_glapi_fallback_GetFinalCombinerInputParameterivNV)) + JMP(GL_OFFSET(_gloffset_GetFinalCombinerInputParameterivNV)) + #endif /* __WIN32__ */ diff --git a/xc/extras/Mesa/src/bitmap.c b/xc/extras/Mesa/src/bitmap.c index 38ca9e0b0..563dff9af 100644 --- a/xc/extras/Mesa/src/bitmap.c +++ b/xc/extras/Mesa/src/bitmap.c @@ -61,15 +61,6 @@ render_bitmap( GLcontext *ctx, GLint px, GLint py, return; /* NULL bitmap is legal, a no-op */ } - if (ctx->NewState) { - gl_update_state(ctx); - gl_reduced_prim_change( ctx, GL_BITMAP ); - } - - if (ctx->PB->primitive!=GL_BITMAP) { /* A.W. 1.1.2000 */ - gl_reduced_prim_change( ctx, GL_BITMAP ); - } - /* Set bitmap drawing color */ if (ctx->Visual->RGBAflag) { GLint r, g, b, a; @@ -166,6 +157,16 @@ _mesa_Bitmap( GLsizei width, GLsizei height, GLint x = (GLint) ( (ctx->Current.RasterPos[0] - xorig) + 0.0F ); GLint y = (GLint) ( (ctx->Current.RasterPos[1] - yorig) + 0.0F ); GLboolean completed = GL_FALSE; + + if (ctx->NewState) { + gl_update_state(ctx); + gl_reduced_prim_change( ctx, GL_BITMAP ); + } + + if (ctx->PB->primitive!=GL_BITMAP) { /* A.W. 1.1.2000 */ + gl_reduced_prim_change( ctx, GL_BITMAP ); + } + if (ctx->Driver.Bitmap) { /* let device driver try to render the bitmap */ completed = (*ctx->Driver.Bitmap)( ctx, x, y, width, height, diff --git a/xc/extras/Mesa/src/blend.c b/xc/extras/Mesa/src/blend.c index adf4006ed..ab06b695b 100644 --- a/xc/extras/Mesa/src/blend.c +++ b/xc/extras/Mesa/src/blend.c @@ -101,10 +101,10 @@ _mesa_BlendFunc( GLenum sfactor, GLenum dfactor ) } -/* GL_INGR_blend_func_separate */ +/* GL_EXT_blend_func_separate */ void -_mesa_BlendFuncSeparateINGR( GLenum sfactorRGB, GLenum dfactorRGB, - GLenum sfactorA, GLenum dfactorA ) +_mesa_BlendFuncSeparateEXT( GLenum sfactorRGB, GLenum dfactorRGB, + GLenum sfactorA, GLenum dfactorA ) { GET_CURRENT_CONTEXT(ctx); ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx, "glBlendFuncSeparate"); @@ -211,7 +211,7 @@ _mesa_BlendFuncSeparateINGR( GLenum sfactorRGB, GLenum dfactorRGB, /* This is really an extension function! */ void -_mesa_BlendEquationEXT( GLenum mode ) +_mesa_BlendEquation( GLenum mode ) { GET_CURRENT_CONTEXT(ctx); ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx, "glBlendEquation"); @@ -255,7 +255,7 @@ _mesa_BlendEquationEXT( GLenum mode ) void -_mesa_BlendColorEXT( GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha ) +_mesa_BlendColor( GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha ) { GET_CURRENT_CONTEXT(ctx); ctx->Color.BlendColor[0] = CLAMP( red, 0.0F, 1.0F ); @@ -285,26 +285,27 @@ blend_transparency( GLcontext *ctx, GLuint n, const GLubyte mask[], for (i=0;i<n;i++) { if (mask[i]) { - GLint t = rgba[i][ACOMP]; /* t in [0,255] */ + const GLint t = rgba[i][ACOMP]; /* t in [0,255] */ if (t == 0) { + /* 0% alpha */ rgba[i][RCOMP] = dest[i][RCOMP]; rgba[i][GCOMP] = dest[i][GCOMP]; rgba[i][BCOMP] = dest[i][BCOMP]; rgba[i][ACOMP] = dest[i][ACOMP]; } - else if (t == 255) { - /* no-op */ + else if (t == CHAN_MAX) { + /* 100% alpha, no-op */ } else { - GLint s = 255 - t; - GLint r = (rgba[i][RCOMP] * t + dest[i][RCOMP] * s) >> 8; - GLint g = (rgba[i][GCOMP] * t + dest[i][GCOMP] * s) >> 8; - GLint b = (rgba[i][BCOMP] * t + dest[i][BCOMP] * s) >> 8; - GLint a = (rgba[i][ACOMP] * t + dest[i][ACOMP] * s) >> 8; - ASSERT(r <= 255); - ASSERT(g <= 255); - ASSERT(b <= 255); - ASSERT(a <= 255); + const GLint s = CHAN_MAX - t; + const GLint r = (rgba[i][RCOMP] * t + dest[i][RCOMP] * s) >> 8; + const GLint g = (rgba[i][GCOMP] * t + dest[i][GCOMP] * s) >> 8; + const GLint b = (rgba[i][BCOMP] * t + dest[i][BCOMP] * s) >> 8; + const GLint a = (rgba[i][ACOMP] * t + dest[i][ACOMP] * s) >> 8; + ASSERT(r <= CHAN_MAX); + ASSERT(g <= CHAN_MAX); + ASSERT(b <= CHAN_MAX); + ASSERT(a <= CHAN_MAX); rgba[i][RCOMP] = (GLubyte) r; rgba[i][GCOMP] = (GLubyte) g; rgba[i][BCOMP] = (GLubyte) b; @@ -335,10 +336,10 @@ blend_add( GLcontext *ctx, GLuint n, const GLubyte mask[], GLint g = rgba[i][GCOMP] + dest[i][GCOMP]; GLint b = rgba[i][BCOMP] + dest[i][BCOMP]; GLint a = rgba[i][ACOMP] + dest[i][ACOMP]; - rgba[i][RCOMP] = (GLubyte) MIN2( r, 255 ); - rgba[i][GCOMP] = (GLubyte) MIN2( g, 255 ); - rgba[i][BCOMP] = (GLubyte) MIN2( b, 255 ); - rgba[i][ACOMP] = (GLubyte) MIN2( a, 255 ); + rgba[i][RCOMP] = (GLubyte) MIN2( r, CHAN_MAX ); + rgba[i][GCOMP] = (GLubyte) MIN2( g, CHAN_MAX ); + rgba[i][BCOMP] = (GLubyte) MIN2( b, CHAN_MAX ); + rgba[i][ACOMP] = (GLubyte) MIN2( a, CHAN_MAX ); } } } @@ -428,10 +429,10 @@ static void _BLENDAPI blend_general( GLcontext *ctx, GLuint n, const GLubyte mask[], GLubyte rgba[][4], CONST GLubyte dest[][4] ) { - GLfloat rscale = 1.0F / 255.0F; - GLfloat gscale = 1.0F / 255.0F; - GLfloat bscale = 1.0F / 255.0F; - GLfloat ascale = 1.0F / 255.0F; + GLfloat rscale = 1.0F / CHAN_MAXF; + GLfloat gscale = 1.0F / CHAN_MAXF; + GLfloat bscale = 1.0F / CHAN_MAXF; + GLfloat ascale = 1.0F / CHAN_MAXF; GLuint i; for (i=0;i<n;i++) { @@ -485,7 +486,7 @@ blend_general( GLcontext *ctx, GLuint n, const GLubyte mask[], sR = sG = sB = 1.0F - (GLfloat) Ad * ascale; break; case GL_SRC_ALPHA_SATURATE: - if (As < 1.0F - (GLfloat) Ad * ascale) { + if (As < CHAN_MAX - Ad) { sR = sG = sB = (GLfloat) As * ascale; } else { @@ -704,10 +705,10 @@ blend_general( GLcontext *ctx, GLuint n, const GLubyte mask[], } /* final clamping */ - rgba[i][RCOMP] = (GLubyte) (GLint) CLAMP( r, 0.0F, 255.0F ); - rgba[i][GCOMP] = (GLubyte) (GLint) CLAMP( g, 0.0F, 255.0F ); - rgba[i][BCOMP] = (GLubyte) (GLint) CLAMP( b, 0.0F, 255.0F ); - rgba[i][ACOMP] = (GLubyte) (GLint) CLAMP( a, 0.0F, 255.0F ); + rgba[i][RCOMP] = (GLubyte) (GLint) CLAMP( r, 0.0F, CHAN_MAXF ); + rgba[i][GCOMP] = (GLubyte) (GLint) CLAMP( g, 0.0F, CHAN_MAXF ); + rgba[i][BCOMP] = (GLubyte) (GLint) CLAMP( b, 0.0F, CHAN_MAXF ); + rgba[i][ACOMP] = (GLubyte) (GLint) CLAMP( a, 0.0F, CHAN_MAXF ); } } } diff --git a/xc/extras/Mesa/src/blend.h b/xc/extras/Mesa/src/blend.h index c0056b9fa..4a4997282 100644 --- a/xc/extras/Mesa/src/blend.h +++ b/xc/extras/Mesa/src/blend.h @@ -48,16 +48,16 @@ _mesa_BlendFunc( GLenum sfactor, GLenum dfactor ); extern void -_mesa_BlendFuncSeparateINGR( GLenum sfactorRGB, GLenum dfactorRGB, - GLenum sfactorA, GLenum dfactorA ); +_mesa_BlendFuncSeparateEXT( GLenum sfactorRGB, GLenum dfactorRGB, + GLenum sfactorA, GLenum dfactorA ); extern void -_mesa_BlendEquationEXT( GLenum mode ); +_mesa_BlendEquation( GLenum mode ); extern void -_mesa_BlendColorEXT(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha); +_mesa_BlendColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha); #endif diff --git a/xc/extras/Mesa/src/colortab.c b/xc/extras/Mesa/src/colortab.c index ea071e7e0..63b93435a 100644 --- a/xc/extras/Mesa/src/colortab.c +++ b/xc/extras/Mesa/src/colortab.c @@ -3,7 +3,7 @@ * Mesa 3-D graphics library * Version: 3.3 * - * Copyright (C) 1999 Brian Paul All Rights Reserved. + * Copyright (C) 1999-2000 Brian Paul All Rights Reserved. * * Permission is hereby granted, free of charge, to any person obtaining a * copy of this software and associated documentation files (the "Software"), @@ -111,9 +111,9 @@ decode_internal_format( GLint format ) void -_mesa_ColorTableEXT( GLenum target, GLenum internalFormat, - GLsizei width, GLenum format, GLenum type, - const GLvoid *table ) +_mesa_ColorTable( GLenum target, GLenum internalFormat, + GLsizei width, GLenum format, GLenum type, + const GLvoid *table ) { GET_CURRENT_CONTEXT(ctx); struct gl_texture_unit *texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit]; @@ -121,7 +121,7 @@ _mesa_ColorTableEXT( GLenum target, GLenum internalFormat, struct gl_color_table *palette; GLboolean proxy = GL_FALSE; - ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx, "glColorTableEXT"); + ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx, "glColorTable"); switch (target) { case GL_TEXTURE_1D: @@ -156,24 +156,24 @@ _mesa_ColorTableEXT( GLenum target, GLenum internalFormat, palette = &ctx->Texture.Palette; break; default: - gl_error(ctx, GL_INVALID_ENUM, "glColorTableEXT(target)"); + gl_error(ctx, GL_INVALID_ENUM, "glColorTable(target)"); return; } assert(palette); if (!gl_is_legal_format_and_type(format, type)) { - gl_error(ctx, GL_INVALID_ENUM, "glColorTableEXT(format or type)"); + gl_error(ctx, GL_INVALID_ENUM, "glColorTable(format or type)"); return; } if (decode_internal_format(internalFormat) < 0) { - gl_error( ctx, GL_INVALID_ENUM, "glColorTableEXT(internalFormat)" ); + gl_error( ctx, GL_INVALID_ENUM, "glColorTable(internalFormat)" ); return; } if (width < 1 || width > MAX_TEXTURE_PALETTE_SIZE || !power_of_two(width)) { - gl_error(ctx, GL_INVALID_VALUE, "glColorTableEXT(width)"); + gl_error(ctx, GL_INVALID_VALUE, "glColorTable(width)"); if (proxy) { palette->Size = 0; palette->IntFormat = (GLenum) 0; @@ -208,9 +208,9 @@ _mesa_ColorTableEXT( GLenum target, GLenum internalFormat, void -_mesa_ColorSubTableEXT( GLenum target, GLsizei start, - GLsizei count, GLenum format, GLenum type, - const GLvoid *table ) +_mesa_ColorSubTable( GLenum target, GLsizei start, + GLsizei count, GLenum format, GLenum type, + const GLvoid *table ) { GET_CURRENT_CONTEXT(ctx); struct gl_texture_unit *texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit]; @@ -219,7 +219,7 @@ _mesa_ColorSubTableEXT( GLenum target, GLsizei start, GLint comps; GLubyte *dest; - ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx, "glColorSubTableEXT"); + ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx, "glColorSubTable"); switch (target) { case GL_TEXTURE_1D: @@ -239,19 +239,19 @@ _mesa_ColorSubTableEXT( GLenum target, GLsizei start, palette = &ctx->Texture.Palette; break; default: - gl_error(ctx, GL_INVALID_ENUM, "glColorSubTableEXT(target)"); + gl_error(ctx, GL_INVALID_ENUM, "glColorSubTable(target)"); return; } assert(palette); if (!gl_is_legal_format_and_type(format, type)) { - gl_error(ctx, GL_INVALID_ENUM, "glColorSubTableEXT(format or type)"); + gl_error(ctx, GL_INVALID_ENUM, "glColorSubTable(format or type)"); return; } if (count < 1) { - gl_error(ctx, GL_INVALID_VALUE, "glColorSubTableEXT(count)"); + gl_error(ctx, GL_INVALID_VALUE, "glColorSubTable(count)"); return; } @@ -259,7 +259,7 @@ _mesa_ColorSubTableEXT( GLenum target, GLsizei start, assert(comps > 0); /* error should be caught sooner */ if (start + count > palette->Size) { - gl_error(ctx, GL_INVALID_VALUE, "glColorSubTableEXT(count)"); + gl_error(ctx, GL_INVALID_VALUE, "glColorSubTable(count)"); return; } dest = palette->Table + start * comps * sizeof(GLubyte); @@ -284,8 +284,8 @@ _mesa_ColorSubTableEXT( GLenum target, GLsizei start, void -_mesa_GetColorTableEXT( GLenum target, GLenum format, - GLenum type, GLvoid *table ) +_mesa_GetColorTable( GLenum target, GLenum format, + GLenum type, GLvoid *table ) { GET_CURRENT_CONTEXT(ctx); struct gl_texture_unit *texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit]; @@ -293,7 +293,7 @@ _mesa_GetColorTableEXT( GLenum target, GLenum format, GLubyte rgba[MAX_TEXTURE_PALETTE_SIZE][4]; GLint i; - ASSERT_OUTSIDE_BEGIN_END(ctx, "glGetColorTableEXT"); + ASSERT_OUTSIDE_BEGIN_END(ctx, "glGetColorTable"); switch (target) { case GL_TEXTURE_1D: @@ -309,7 +309,7 @@ _mesa_GetColorTableEXT( GLenum target, GLenum format, palette = &ctx->Texture.Palette; break; default: - gl_error(ctx, GL_INVALID_ENUM, "glGetColorTableEXT(target)"); + gl_error(ctx, GL_INVALID_ENUM, "glGetColorTable(target)"); return; } @@ -365,7 +365,7 @@ _mesa_GetColorTableEXT( GLenum target, GLenum format, } break; default: - gl_problem(ctx, "bad palette format in glGetColorTableEXT"); + gl_problem(ctx, "bad palette format in glGetColorTable"); return; } @@ -380,23 +380,23 @@ _mesa_GetColorTableEXT( GLenum target, GLenum format, void -_mesa_GetColorTableParameterfvEXT( GLenum target, GLenum pname, GLfloat *params ) +_mesa_GetColorTableParameterfv( GLenum target, GLenum pname, GLfloat *params ) { GLint iparams[10]; - _mesa_GetColorTableParameterivEXT( target, pname, iparams ); + _mesa_GetColorTableParameteriv( target, pname, iparams ); *params = (GLfloat) iparams[0]; } void -_mesa_GetColorTableParameterivEXT( GLenum target, GLenum pname, GLint *params ) +_mesa_GetColorTableParameteriv( GLenum target, GLenum pname, GLint *params ) { GET_CURRENT_CONTEXT(ctx); struct gl_texture_unit *texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit]; struct gl_color_table *palette; - ASSERT_OUTSIDE_BEGIN_END(ctx, "glGetColorTableParameterEXT"); + ASSERT_OUTSIDE_BEGIN_END(ctx, "glGetColorTableParameter"); switch (target) { case GL_TEXTURE_1D: @@ -412,7 +412,7 @@ _mesa_GetColorTableParameterivEXT( GLenum target, GLenum pname, GLint *params ) palette = &ctx->Texture.Palette; break; default: - gl_error(ctx, GL_INVALID_ENUM, "glGetColorTableParameterEXT(target)"); + gl_error(ctx, GL_INVALID_ENUM, "glGetColorTableParameter(target)"); return; } @@ -442,7 +442,7 @@ _mesa_GetColorTableParameterivEXT( GLenum target, GLenum pname, GLint *params ) *params = 8; break; default: - gl_error(ctx, GL_INVALID_ENUM, "glGetColorTableParameterEXT" ); + gl_error(ctx, GL_INVALID_ENUM, "glGetColorTableParameter" ); return; } } diff --git a/xc/extras/Mesa/src/colortab.h b/xc/extras/Mesa/src/colortab.h index 08cae6866..bdcf5fa71 100644 --- a/xc/extras/Mesa/src/colortab.h +++ b/xc/extras/Mesa/src/colortab.h @@ -3,7 +3,7 @@ * Mesa 3-D graphics library * Version: 3.3 * - * Copyright (C) 1999 Brian Paul All Rights Reserved. + * Copyright (C) 1999-2000 Brian Paul All Rights Reserved. * * Permission is hereby granted, free of charge, to any person obtaining a * copy of this software and associated documentation files (the "Software"), @@ -32,29 +32,24 @@ extern void -_mesa_ColorTableEXT( GLenum target, GLenum internalformat, - GLsizei width, GLenum format, GLenum type, - const GLvoid *table ); +_mesa_ColorTable( GLenum target, GLenum internalformat, + GLsizei width, GLenum format, GLenum type, + const GLvoid *table ); extern void -_mesa_ColorSubTableEXT( GLenum target, GLsizei start, - GLsizei count, GLenum format, GLenum type, - const GLvoid *table ); +_mesa_ColorSubTable( GLenum target, GLsizei start, + GLsizei count, GLenum format, GLenum type, + const GLvoid *table ); extern void -_mesa_GetColorTableEXT( GLenum target, GLenum format, - GLenum type, GLvoid *table ); -#ifdef VMS -/* VMS does not support externals longer than 32 characters. */ -#define _mesa_GetColorTableParameterfvEXT VMS_GCTParameterfvEXT -#define _mesa_GetColorTableParameterivEXT VMS_GCTParameterivEXT -#endif +_mesa_GetColorTable( GLenum target, GLenum format, + GLenum type, GLvoid *table ); extern void -_mesa_GetColorTableParameterfvEXT( GLenum target, GLenum pname, GLfloat *params ); +_mesa_GetColorTableParameterfv( GLenum target, GLenum pname, GLfloat *params ); extern void -_mesa_GetColorTableParameterivEXT( GLenum target, GLenum pname, GLint *params ); +_mesa_GetColorTableParameteriv( GLenum target, GLenum pname, GLint *params ); #endif diff --git a/xc/extras/Mesa/src/config.c b/xc/extras/Mesa/src/config.c index 33233df2a..575ec7219 100644 --- a/xc/extras/Mesa/src/config.c +++ b/xc/extras/Mesa/src/config.c @@ -217,7 +217,6 @@ static void default_hint( GLcontext *ctx, struct cnode *args ) { struct cnode *hint, *tail, *value; const char *hname, *vname; - GLenum h, v; if (is_list(args, &hint, &tail) && is_list(tail, &value, &tail) && @@ -225,11 +224,12 @@ static void default_hint( GLcontext *ctx, struct cnode *args ) is_word(hint, &hname) && is_word(value, &vname)) { - if ((h = (GLenum) gl_lookup_enum_by_name(hname)) != -1 && - (v = (GLenum) gl_lookup_enum_by_name(vname)) != -1) + GLint h = gl_lookup_enum_by_name(hname); + GLint v = gl_lookup_enum_by_name(vname); + if (h != -1 && v != -1) { printf("calling glHint(%s=%d, %s=%d)\n", hname, h, vname, v); - if (!_mesa_try_Hint( ctx, h, v )) + if (!_mesa_try_Hint( ctx, (GLenum) h, (GLenum) v )) error( hint, "glHint failed"); printf("allow draw mem: %d\n", ctx->Hint.AllowDrawMem); return; diff --git a/xc/extras/Mesa/src/config.h b/xc/extras/Mesa/src/config.h index c28fecab0..595f02830 100644 --- a/xc/extras/Mesa/src/config.h +++ b/xc/extras/Mesa/src/config.h @@ -157,7 +157,8 @@ * Bits per color channel (must be 8 at this time!) */ #define CHAN_BITS 8 - +#define CHAN_MAX ((1 << CHAN_BITS) - 1) +#define CHAN_MAXF ((GLfloat) CHAN_MAX) /* diff --git a/xc/extras/Mesa/src/dd.h b/xc/extras/Mesa/src/dd.h index 44f8ec3c6..25a82a546 100644 --- a/xc/extras/Mesa/src/dd.h +++ b/xc/extras/Mesa/src/dd.h @@ -138,12 +138,10 @@ struct dd_function_table { *** every device driver. *** **********************************************************************/ - const char * (*RendererString)(void); - /* - * Return a string which uniquely identifies this device driver. - * The string should contain no whitespace. Examples: "X11", "OffScreen", - * "MSWindows", "SVGA". - * NOTE: This function will be obsolete in favor of GetString in the future! + const GLubyte * (*GetString)( GLcontext *ctx, GLenum name ); + /* Return a string as needed by glGetString(). + * Only the GL_RENDERER token must be implemented. Otherwise, + * NULL can be returned. */ void (*UpdateState)( GLcontext *ctx ); @@ -327,17 +325,6 @@ struct dd_function_table { *** fall-back function. *** **********************************************************************/ - const char * (*ExtensionString)( GLcontext *ctx ); - /* Return a space-separated list of extensions for this driver. - * NOTE: This function will be obsolete in favor of GetString in the future! - */ - - const GLubyte * (*GetString)( GLcontext *ctx, GLenum name ); - /* Return a string as needed by glGetString(). - * NOTE: This will replace the ExtensionString and RendererString - * functions in the future! - */ - void (*Finish)( GLcontext *ctx ); /* * This is called whenever glFinish() is called. diff --git a/xc/extras/Mesa/src/dlist.c b/xc/extras/Mesa/src/dlist.c index 0b7de60e6..d491db47c 100644 --- a/xc/extras/Mesa/src/dlist.c +++ b/xc/extras/Mesa/src/dlist.c @@ -32,6 +32,7 @@ #include "attrib.h" #include "bitmap.h" #include "bbox.h" +#include "blend.h" #include "buffers.h" #include "clip.h" #include "colortab.h" @@ -691,7 +692,7 @@ static void save_BlendEquation( GLenum mode ) n[1].e = mode; } if (ctx->ExecuteFlag) { - (*ctx->Exec->BlendEquationEXT)( mode ); + (*ctx->Exec->BlendEquation)( mode ); } } @@ -712,8 +713,8 @@ static void save_BlendFunc( GLenum sfactor, GLenum dfactor ) } -static void save_BlendFuncSeparateINGR(GLenum sfactorRGB, GLenum dfactorRGB, - GLenum sfactorA, GLenum dfactorA) +static void save_BlendFuncSeparateEXT(GLenum sfactorRGB, GLenum dfactorRGB, + GLenum sfactorA, GLenum dfactorA) { GET_CURRENT_CONTEXT(ctx); Node *n; @@ -726,7 +727,7 @@ static void save_BlendFuncSeparateINGR(GLenum sfactorRGB, GLenum dfactorRGB, n[4].e = dfactorA; } if (ctx->ExecuteFlag) { - (*ctx->Exec->BlendFuncSeparateINGR)( sfactorRGB, dfactorRGB, + (*ctx->Exec->BlendFuncSeparateEXT)( sfactorRGB, dfactorRGB, sfactorA, dfactorA); } } @@ -746,7 +747,7 @@ static void save_BlendColor( GLfloat red, GLfloat green, n[4].f = alpha; } if (ctx->ExecuteFlag) { - (*ctx->Exec->BlendColorEXT)( red, green, blue, alpha ); + (*ctx->Exec->BlendColor)( red, green, blue, alpha ); } } @@ -938,17 +939,17 @@ static void save_ColorMaterial( GLenum face, GLenum mode ) } -static void save_ColorTableEXT( GLenum target, GLenum internalFormat, - GLsizei width, GLenum format, GLenum type, - const GLvoid *table ) +static void save_ColorTable( GLenum target, GLenum internalFormat, + GLsizei width, GLenum format, GLenum type, + const GLvoid *table ) { GET_CURRENT_CONTEXT(ctx); if (target == GL_PROXY_TEXTURE_1D || target == GL_PROXY_TEXTURE_2D || target == GL_PROXY_TEXTURE_3D) { /* execute immediately */ - (*ctx->Exec->ColorTableEXT)( target, internalFormat, width, - format, type, table ); + (*ctx->Exec->ColorTable)( target, internalFormat, width, + format, type, table ); } else { GLvoid *image = _mesa_unpack_image(width, 1, 1, format, type, table, @@ -968,16 +969,16 @@ static void save_ColorTableEXT( GLenum target, GLenum internalFormat, FREE(image); } if (ctx->ExecuteFlag) { - (*ctx->Exec->ColorTableEXT)( target, internalFormat, width, - format, type, table ); + (*ctx->Exec->ColorTable)( target, internalFormat, width, + format, type, table ); } } } -static void save_ColorSubTableEXT( GLenum target, GLsizei start, GLsizei count, - GLenum format, GLenum type, - const GLvoid *table) +static void save_ColorSubTable( GLenum target, GLsizei start, GLsizei count, + GLenum format, GLenum type, + const GLvoid *table) { GET_CURRENT_CONTEXT(ctx); GLvoid *image = _mesa_unpack_image(count, 1, 1, format, type, table, @@ -997,7 +998,7 @@ static void save_ColorSubTableEXT( GLenum target, GLsizei start, GLsizei count, FREE(image); } if (ctx->ExecuteFlag) { - (*ctx->Exec->ColorSubTableEXT)(target, start, count, format, type, table); + (*ctx->Exec->ColorSubTable)(target, start, count, format, type, table); } } @@ -2882,17 +2883,6 @@ static void save_TexImage3D( GLenum target, } -static void save_TexImage3DEXT( GLenum target, - GLint level, GLenum components, - GLsizei width, GLsizei height, GLsizei depth, - GLint border, GLenum format, GLenum type, - const GLvoid *pixels ) -{ - save_TexImage3D(target, level, (GLint) components, width, height, - depth, border, format, type, pixels); -} - - static void save_TexSubImage1D( GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const GLvoid *pixels ) @@ -3402,16 +3392,16 @@ static void execute_list( GLcontext *ctx, GLuint list ) } break; case OPCODE_BLEND_COLOR: - (*ctx->Exec->BlendColorEXT)( n[1].f, n[2].f, n[3].f, n[4].f ); + (*ctx->Exec->BlendColor)( n[1].f, n[2].f, n[3].f, n[4].f ); break; case OPCODE_BLEND_EQUATION: - (*ctx->Exec->BlendEquationEXT)( n[1].e ); + (*ctx->Exec->BlendEquation)( n[1].e ); break; case OPCODE_BLEND_FUNC: (*ctx->Exec->BlendFunc)( n[1].e, n[2].e ); break; case OPCODE_BLEND_FUNC_SEPARATE: - (*ctx->Exec->BlendFuncSeparateINGR)(n[1].e, n[2].e, n[3].e, n[4].e); + (*ctx->Exec->BlendFuncSeparateEXT)(n[1].e, n[2].e, n[3].e, n[4].e); break; case OPCODE_CALL_LIST: /* Generated by glCallList(), don't add ListBase */ @@ -3463,8 +3453,8 @@ static void execute_list( GLcontext *ctx, GLuint list ) { struct gl_pixelstore_attrib save = ctx->Unpack; ctx->Unpack = _mesa_native_packing; - (*ctx->Exec->ColorTableEXT)( n[1].e, n[2].e, n[3].i, n[4].e, - n[5].e, n[6].data ); + (*ctx->Exec->ColorTable)( n[1].e, n[2].e, n[3].i, n[4].e, + n[5].e, n[6].data ); ctx->Unpack = save; /* restore */ } break; @@ -3472,8 +3462,8 @@ static void execute_list( GLcontext *ctx, GLuint list ) { struct gl_pixelstore_attrib save = ctx->Unpack; ctx->Unpack = _mesa_native_packing; - (*ctx->Exec->ColorSubTableEXT)( n[1].e, n[2].i, n[3].i, - n[4].e, n[5].e, n[6].data ); + (*ctx->Exec->ColorSubTable)( n[1].e, n[2].i, n[3].i, + n[4].e, n[5].e, n[6].data ); ctx->Unpack = save; /* restore */ } break; @@ -4514,9 +4504,9 @@ _mesa_init_dlist_table( struct _glapi_table *table ) table->TexSubImage3D = save_TexSubImage3D; /* GL_ARB_imaging */ - /* NOT supported, just call stub functions */ - table->BlendColor = _mesa_BlendColor; - table->BlendEquation = _mesa_BlendEquation; + /* Not all are supported */ + table->BlendColor = save_BlendColor; + table->BlendEquation = save_BlendEquation; table->ColorSubTable = _mesa_ColorSubTable; table->ColorTable = _mesa_ColorTable; table->ColorTableParameterfv = _mesa_ColorTableParameterfv; @@ -4550,17 +4540,21 @@ _mesa_init_dlist_table( struct _glapi_table *table ) table->ResetMinmax = _mesa_ResetMinmax; table->SeparableFilter2D = _mesa_SeparableFilter2D; - /* 6. GL_EXT_texture3d */ + /* GL_EXT_texture3d */ +#if 0 table->CopyTexSubImage3DEXT = save_CopyTexSubImage3D; table->TexImage3DEXT = save_TexImage3DEXT; table->TexSubImage3DEXT = save_TexSubImage3D; +#endif /* GL_EXT_paletted_texture */ - table->ColorTableEXT = save_ColorTableEXT; - table->ColorSubTableEXT = save_ColorSubTableEXT; - table->GetColorTableEXT = _mesa_GetColorTableEXT; - table->GetColorTableParameterfvEXT = _mesa_GetColorTableParameterfvEXT; - table->GetColorTableParameterivEXT = _mesa_GetColorTableParameterivEXT; +#if 0 + table->ColorTableEXT = save_ColorTable; + table->ColorSubTableEXT = save_ColorSubTable; +#endif + table->GetColorTableEXT = _mesa_GetColorTable; + table->GetColorTableParameterfvEXT = _mesa_GetColorTableParameterfv; + table->GetColorTableParameterivEXT = _mesa_GetColorTableParameteriv; /* GL_EXT_compiled_vertex_array */ table->LockArraysEXT = _mesa_LockArraysEXT; @@ -4577,10 +4571,14 @@ _mesa_init_dlist_table( struct _glapi_table *table ) table->PolygonOffsetEXT = save_PolygonOffsetEXT; /* GL_EXT_blend_minmax */ - table->BlendEquationEXT = save_BlendEquation; +#if 0 + table->BlendEquationEXT = save_BlendEquationEXT; +#endif /* GL_EXT_blend_color */ - table->BlendColorEXT = save_BlendColor; +#if 0 + table->BlendColorEXT = save_BlendColorEXT; +#endif /* GL_ARB_multitexture */ table->ActiveTextureARB = save_ActiveTextureARB; @@ -4618,8 +4616,8 @@ _mesa_init_dlist_table( struct _glapi_table *table ) table->MultiTexCoord4sARB = _mesa_MultiTexCoord4sARB; table->MultiTexCoord4svARB = _mesa_MultiTexCoord4svARB; - /* GL_INGR_blend_func_separate */ - table->BlendFuncSeparateINGR = save_BlendFuncSeparateINGR; + /* GL_EXT_blend_func_separate */ + table->BlendFuncSeparateEXT = save_BlendFuncSeparateEXT; /* GL_MESA_window_pos */ table->WindowPos2dMESA = save_WindowPos2dMESA; diff --git a/xc/extras/Mesa/src/extensions.c b/xc/extras/Mesa/src/extensions.c index df79e5b46..82ad25208 100644 --- a/xc/extras/Mesa/src/extensions.c +++ b/xc/extras/Mesa/src/extensions.c @@ -48,7 +48,7 @@ struct extension { static struct { int enabled; const char *name; } default_extensions[] = { - { ALWAYS_ENABLED, "GL_EXT_blend_color" }, + { DEFAULT_ON, "GL_EXT_blend_color" }, { DEFAULT_OFF, "ARB_imaging" }, { DEFAULT_ON, "GL_EXT_blend_minmax" }, { DEFAULT_ON, "GL_EXT_blend_logic_op" }, diff --git a/xc/extras/Mesa/src/get.c b/xc/extras/Mesa/src/get.c index 12c8d3da1..6c5f3ef9f 100644 --- a/xc/extras/Mesa/src/get.c +++ b/xc/extras/Mesa/src/get.c @@ -121,16 +121,16 @@ _mesa_GetBooleanv( GLenum pname, GLboolean *params ) case GL_BLEND_SRC: *params = ENUM_TO_BOOL(ctx->Color.BlendSrcRGB); break; - case GL_BLEND_SRC_RGB_INGR: + case GL_BLEND_SRC_RGB_EXT: *params = ENUM_TO_BOOL(ctx->Color.BlendSrcRGB); break; - case GL_BLEND_DST_RGB_INGR: + case GL_BLEND_DST_RGB_EXT: *params = ENUM_TO_BOOL(ctx->Color.BlendDstRGB); break; - case GL_BLEND_SRC_ALPHA_INGR: + case GL_BLEND_SRC_ALPHA_EXT: *params = ENUM_TO_BOOL(ctx->Color.BlendSrcA); break; - case GL_BLEND_DST_ALPHA_INGR: + case GL_BLEND_DST_ALPHA_EXT: *params = ENUM_TO_BOOL(ctx->Color.BlendDstA); break; case GL_BLEND_EQUATION_EXT: @@ -1083,16 +1083,16 @@ _mesa_GetDoublev( GLenum pname, GLdouble *params ) case GL_BLEND_SRC: *params = ENUM_TO_DOUBLE(ctx->Color.BlendSrcRGB); break; - case GL_BLEND_SRC_RGB_INGR: + case GL_BLEND_SRC_RGB_EXT: *params = ENUM_TO_DOUBLE(ctx->Color.BlendSrcRGB); break; - case GL_BLEND_DST_RGB_INGR: + case GL_BLEND_DST_RGB_EXT: *params = ENUM_TO_DOUBLE(ctx->Color.BlendDstRGB); break; - case GL_BLEND_SRC_ALPHA_INGR: + case GL_BLEND_SRC_ALPHA_EXT: *params = ENUM_TO_DOUBLE(ctx->Color.BlendSrcA); break; - case GL_BLEND_DST_ALPHA_INGR: + case GL_BLEND_DST_ALPHA_EXT: *params = ENUM_TO_DOUBLE(ctx->Color.BlendDstA); break; case GL_BLEND_EQUATION_EXT: @@ -2046,16 +2046,16 @@ _mesa_GetFloatv( GLenum pname, GLfloat *params ) case GL_BLEND_SRC: *params = ENUM_TO_FLOAT(ctx->Color.BlendSrcRGB); break; - case GL_BLEND_SRC_RGB_INGR: + case GL_BLEND_SRC_RGB_EXT: *params = ENUM_TO_FLOAT(ctx->Color.BlendSrcRGB); break; - case GL_BLEND_DST_RGB_INGR: + case GL_BLEND_DST_RGB_EXT: *params = ENUM_TO_FLOAT(ctx->Color.BlendDstRGB); break; - case GL_BLEND_SRC_ALPHA_INGR: + case GL_BLEND_SRC_ALPHA_EXT: *params = ENUM_TO_FLOAT(ctx->Color.BlendSrcA); break; - case GL_BLEND_DST_ALPHA_INGR: + case GL_BLEND_DST_ALPHA_EXT: *params = ENUM_TO_FLOAT(ctx->Color.BlendDstA); break; case GL_BLEND_EQUATION_EXT: @@ -2986,16 +2986,16 @@ _mesa_GetIntegerv( GLenum pname, GLint *params ) case GL_BLEND_SRC: *params = (GLint) ctx->Color.BlendSrcRGB; break; - case GL_BLEND_SRC_RGB_INGR: + case GL_BLEND_SRC_RGB_EXT: *params = (GLint) ctx->Color.BlendSrcRGB; break; - case GL_BLEND_DST_RGB_INGR: + case GL_BLEND_DST_RGB_EXT: *params = (GLint) ctx->Color.BlendDstRGB; break; - case GL_BLEND_SRC_ALPHA_INGR: + case GL_BLEND_SRC_ALPHA_EXT: *params = (GLint) ctx->Color.BlendSrcA; break; - case GL_BLEND_DST_ALPHA_INGR: + case GL_BLEND_DST_ALPHA_EXT: *params = (GLint) ctx->Color.BlendDstA; break; case GL_BLEND_EQUATION_EXT: @@ -3932,47 +3932,32 @@ const GLubyte * _mesa_GetString( GLenum name ) { GET_CURRENT_CONTEXT(ctx); - static char result[1000]; static char *vendor = "Brian Paul"; + static char *renderer = "Mesa"; static char *version = "1.2 Mesa 3.3 beta"; ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH_WITH_RETVAL(ctx, "glGetString", 0); - /* First see if device driver can satisfy this call */ - switch (name) { - case GL_VENDOR: - case GL_RENDERER: - case GL_VERSION: - if (ctx->Driver.GetString) { - const GLubyte *str = (*ctx->Driver.GetString)(ctx, name); - if (str && str[0]) - return str; - } - break; - /* Extensions always handled by extensions.c */ - case GL_EXTENSIONS: - return (GLubyte *) gl_extensions_get_string( ctx ); - default: - gl_error( ctx, GL_INVALID_ENUM, "glGetString" ); - return (GLubyte *) 0; - } - - /* If we get here, device driver didn't return a string */ - switch (name) { - case GL_VENDOR: - return (GLubyte *) vendor; - case GL_RENDERER: - strcpy(result, "Mesa"); - if (ctx->Driver.RendererString) { - strcat(result, " "); - strcat(result, (*ctx->Driver.RendererString)()); - } - return (GLubyte *) result; - case GL_VERSION: - return (GLubyte *) version; - default: - /* caught above */ - return NULL; + /* this is a required driver function */ + assert(ctx->Driver.GetString); + { + const GLubyte *str = (*ctx->Driver.GetString)(ctx, name); + if (str) + return str; + + switch (name) { + case GL_VENDOR: + return (const GLubyte *) vendor; + case GL_RENDERER: + return (const GLubyte *) renderer; + case GL_VERSION: + return (const GLubyte *) version; + case GL_EXTENSIONS: + return (GLubyte *) gl_extensions_get_string( ctx ); + default: + gl_error( ctx, GL_INVALID_ENUM, "glGetString" ); + return (GLubyte *) 0; + } } } diff --git a/xc/extras/Mesa/src/glapi.c b/xc/extras/Mesa/src/glapi.c index 4e21f5b81..5f5fc6de1 100644 --- a/xc/extras/Mesa/src/glapi.c +++ b/xc/extras/Mesa/src/glapi.c @@ -50,7 +50,7 @@ /* This is used when thread safety is disabled */ -struct _glapi_table *_glapi_Dispatch = &__glapi_noop_table; +struct _glapi_table *_glapi_Dispatch = (struct _glapi_table *) __glapi_noop_table; /* Used when thread safety disabled */ void *_glapi_Context = NULL; @@ -156,7 +156,7 @@ _glapi_set_dispatch(struct _glapi_table *dispatch) { if (!dispatch) { /* use the no-op functions */ - dispatch = &__glapi_noop_table; + dispatch = (struct _glapi_table *) __glapi_noop_table; } #ifdef DEBUG else { @@ -218,16 +218,17 @@ _glapi_get_dispatch_table_size(void) const char * _glapi_get_version(void) { - return "20000128"; /* YYYYMMDD */ + return "20000223"; /* YYYYMMDD */ } -struct name_address_pair { +struct name_address_offset { const char *Name; GLvoid *Address; + GLuint Offset; }; -static struct name_address_pair static_functions[1000]; +static struct name_address_offset static_functions[1000]; @@ -241,7 +242,7 @@ get_static_proc_offset(const char *funcName) GLuint i; for (i = 0; static_functions[i].Name; i++) { if (strcmp(static_functions[i].Name, funcName) == 0) { - return i; + return static_functions[i].Offset; } } return -1; @@ -255,7 +256,7 @@ get_static_proc_offset(const char *funcName) static GLvoid * get_static_proc_address(const char *funcName) { - GLuint i = get_static_proc_offset(funcName); + GLint i = get_static_proc_offset(funcName); if (i >= 0) return static_functions[i].Address; else @@ -271,14 +272,7 @@ get_static_proc_address(const char *funcName) #define MAX_EXTENSION_FUNCS 1000 - -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[MAX_EXTENSION_FUNCS]; +static struct name_address_offset ExtEntryTable[MAX_EXTENSION_FUNCS]; static GLuint NumExtEntryPoints = 0; @@ -494,20 +488,20 @@ _glapi_get_proc_address(const char *funcName) const char * _glapi_get_proc_name(GLuint offset) { - GLuint n = sizeof(static_functions) / sizeof(struct name_address_pair); - if (offset < n) { - return static_functions[offset].Name; + const GLuint n = sizeof(static_functions) / sizeof(struct name_address_offset); + GLuint i; + for (i = 0; i < n; i++) { + if (static_functions[i].Offset == offset) + return static_functions[i].Name; } - else { - /* search added extension functions */ - GLuint i; - for (i = 0; i < NumExtEntryPoints; i++) { - if (ExtEntryTable[i].Offset == offset) { - return ExtEntryTable[i].Name; - } + + /* search added extension functions */ + for (i = 0; i < NumExtEntryPoints; i++) { + if (ExtEntryTable[i].Offset == offset) { + return ExtEntryTable[i].Name; } - return NULL; } + return NULL; } @@ -559,10 +553,10 @@ _glapi_check_table(const struct _glapi_table *table) assert(ResetMinMaxOffset == offset); } { - GLuint blendColorOffset = _glapi_get_proc_offset("glBlendColorEXT"); - char *blendColorFunc = (char*) &table->BlendColorEXT; + GLuint blendColorOffset = _glapi_get_proc_offset("glBlendColor"); + char *blendColorFunc = (char*) &table->BlendColor; GLuint offset = (blendColorFunc - (char *) table) / sizeof(void *); - assert(blendColorOffset == _gloffset_BlendColorEXT); + assert(blendColorOffset == _gloffset_BlendColor); assert(blendColorOffset == offset); } { @@ -588,449 +582,453 @@ static int NotImplemented(void) -static struct name_address_pair static_functions[] = { - { "NotImplemented", (GLvoid *) NotImplemented }, - - /* GL 1.1 */ - { "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 name_address_offset static_functions[] = { /* GL 1.1 */ -#ifdef GL_VERSION_1_1 + { "glNewList", (GLvoid *) glNewList, _gloffset_NewList }, + { "glEndList", (GLvoid *) glEndList, _gloffset_EndList }, + { "glCallList", (GLvoid *) glCallList, _gloffset_CallList }, + { "glCallLists", (GLvoid *) glCallLists, _gloffset_CallLists }, + { "glDeleteLists", (GLvoid *) glDeleteLists, _gloffset_DeleteLists }, + { "glGenLists", (GLvoid *) glGenLists, _gloffset_GenLists }, + { "glListBase", (GLvoid *) glListBase, _gloffset_ListBase }, + { "glBegin", (GLvoid *) glBegin, _gloffset_Begin }, + { "glBitmap", (GLvoid *) glBitmap, _gloffset_Bitmap }, + { "glColor3b", (GLvoid *) glColor3b, _gloffset_Color3b }, + { "glColor3bv", (GLvoid *) glColor3bv, _gloffset_Color3bv }, + { "glColor3d", (GLvoid *) glColor3d, _gloffset_Color3d }, + { "glColor3dv", (GLvoid *) glColor3dv, _gloffset_Color3dv }, + { "glColor3f", (GLvoid *) glColor3f, _gloffset_Color3f }, + { "glColor3fv", (GLvoid *) glColor3fv, _gloffset_Color3fv }, + { "glColor3i", (GLvoid *) glColor3i, _gloffset_Color3i }, + { "glColor3iv", (GLvoid *) glColor3iv, _gloffset_Color3iv }, + { "glColor3s", (GLvoid *) glColor3s, _gloffset_Color3s }, + { "glColor3sv", (GLvoid *) glColor3sv, _gloffset_Color3sv }, + { "glColor3ub", (GLvoid *) glColor3ub, _gloffset_Color3ub }, + { "glColor3ubv", (GLvoid *) glColor3ubv, _gloffset_Color3ubv }, + { "glColor3ui", (GLvoid *) glColor3ui, _gloffset_Color3ui }, + { "glColor3uiv", (GLvoid *) glColor3uiv, _gloffset_Color3uiv }, + { "glColor3us", (GLvoid *) glColor3us, _gloffset_Color3us }, + { "glColor3usv", (GLvoid *) glColor3usv, _gloffset_Color3usv }, + { "glColor4b", (GLvoid *) glColor4b, _gloffset_Color4b }, + { "glColor4bv", (GLvoid *) glColor4bv, _gloffset_Color4bv }, + { "glColor4d", (GLvoid *) glColor4d, _gloffset_Color4d }, + { "glColor4dv", (GLvoid *) glColor4dv, _gloffset_Color4dv }, + { "glColor4f", (GLvoid *) glColor4f, _gloffset_Color4f }, + { "glColor4fv", (GLvoid *) glColor4fv, _gloffset_Color4fv }, + { "glColor4i", (GLvoid *) glColor4i, _gloffset_Color4i }, + { "glColor4iv", (GLvoid *) glColor4iv, _gloffset_Color4iv }, + { "glColor4s", (GLvoid *) glColor4s, _gloffset_Color4s }, + { "glColor4sv", (GLvoid *) glColor4sv, _gloffset_Color4sv }, + { "glColor4ub", (GLvoid *) glColor4ub, _gloffset_Color4ub }, + { "glColor4ubv", (GLvoid *) glColor4ubv, _gloffset_Color4ubv }, + { "glColor4ui", (GLvoid *) glColor4ui, _gloffset_Color4ui }, + { "glColor4uiv", (GLvoid *) glColor4uiv, _gloffset_Color4uiv }, + { "glColor4us", (GLvoid *) glColor4us, _gloffset_Color4us }, + { "glColor4usv", (GLvoid *) glColor4usv, _gloffset_Color4usv }, + { "glEdgeFlag", (GLvoid *) glEdgeFlag, _gloffset_EdgeFlag }, + { "glEdgeFlagv", (GLvoid *) glEdgeFlagv, _gloffset_EdgeFlagv }, + { "glEnd", (GLvoid *) glEnd, _gloffset_End }, + { "glIndexd", (GLvoid *) glIndexd, _gloffset_Indexd }, + { "glIndexdv", (GLvoid *) glIndexdv, _gloffset_Indexdv }, + { "glIndexf", (GLvoid *) glIndexf, _gloffset_Indexf }, + { "glIndexfv", (GLvoid *) glIndexfv, _gloffset_Indexfv }, + { "glIndexi", (GLvoid *) glIndexi, _gloffset_Indexi }, + { "glIndexiv", (GLvoid *) glIndexiv, _gloffset_Indexiv }, + { "glIndexs", (GLvoid *) glIndexs, _gloffset_Indexs }, + { "glIndexsv", (GLvoid *) glIndexsv, _gloffset_Indexsv }, + { "glNormal3b", (GLvoid *) glNormal3b, _gloffset_Normal3b }, + { "glNormal3bv", (GLvoid *) glNormal3bv, _gloffset_Normal3bv }, + { "glNormal3d", (GLvoid *) glNormal3d, _gloffset_Normal3d }, + { "glNormal3dv", (GLvoid *) glNormal3dv, _gloffset_Normal3dv }, + { "glNormal3f", (GLvoid *) glNormal3f, _gloffset_Normal3f }, + { "glNormal3fv", (GLvoid *) glNormal3fv, _gloffset_Normal3fv }, + { "glNormal3i", (GLvoid *) glNormal3i, _gloffset_Normal3i }, + { "glNormal3iv", (GLvoid *) glNormal3iv, _gloffset_Normal3iv }, + { "glNormal3s", (GLvoid *) glNormal3s, _gloffset_Normal3s }, + { "glNormal3sv", (GLvoid *) glNormal3sv, _gloffset_Normal3sv }, + { "glRasterPos2d", (GLvoid *) glRasterPos2d, _gloffset_RasterPos2d }, + { "glRasterPos2dv", (GLvoid *) glRasterPos2dv, _gloffset_RasterPos2dv }, + { "glRasterPos2f", (GLvoid *) glRasterPos2f, _gloffset_RasterPos2f }, + { "glRasterPos2fv", (GLvoid *) glRasterPos2fv, _gloffset_RasterPos2fv }, + { "glRasterPos2i", (GLvoid *) glRasterPos2i, _gloffset_RasterPos2i }, + { "glRasterPos2iv", (GLvoid *) glRasterPos2iv, _gloffset_RasterPos2iv }, + { "glRasterPos2s", (GLvoid *) glRasterPos2s, _gloffset_RasterPos2s }, + { "glRasterPos2sv", (GLvoid *) glRasterPos2sv, _gloffset_RasterPos2sv }, + { "glRasterPos3d", (GLvoid *) glRasterPos3d, _gloffset_RasterPos3d }, + { "glRasterPos3dv", (GLvoid *) glRasterPos3dv, _gloffset_RasterPos3dv }, + { "glRasterPos3f", (GLvoid *) glRasterPos3f, _gloffset_RasterPos3f }, + { "glRasterPos3fv", (GLvoid *) glRasterPos3fv, _gloffset_RasterPos3fv }, + { "glRasterPos3i", (GLvoid *) glRasterPos3i, _gloffset_RasterPos3i }, + { "glRasterPos3iv", (GLvoid *) glRasterPos3iv, _gloffset_RasterPos3iv }, + { "glRasterPos3s", (GLvoid *) glRasterPos3s, _gloffset_RasterPos3s }, + { "glRasterPos3sv", (GLvoid *) glRasterPos3sv, _gloffset_RasterPos3sv }, + { "glRasterPos4d", (GLvoid *) glRasterPos4d, _gloffset_RasterPos4d }, + { "glRasterPos4dv", (GLvoid *) glRasterPos4dv, _gloffset_RasterPos4dv }, + { "glRasterPos4f", (GLvoid *) glRasterPos4f, _gloffset_RasterPos4f }, + { "glRasterPos4fv", (GLvoid *) glRasterPos4fv, _gloffset_RasterPos4fv }, + { "glRasterPos4i", (GLvoid *) glRasterPos4i, _gloffset_RasterPos4i }, + { "glRasterPos4iv", (GLvoid *) glRasterPos4iv, _gloffset_RasterPos4iv }, + { "glRasterPos4s", (GLvoid *) glRasterPos4s, _gloffset_RasterPos4s }, + { "glRasterPos4sv", (GLvoid *) glRasterPos4sv, _gloffset_RasterPos4sv }, + { "glRectd", (GLvoid *) glRectd, _gloffset_Rectd }, + { "glRectdv", (GLvoid *) glRectdv, _gloffset_Rectdv }, + { "glRectf", (GLvoid *) glRectf, _gloffset_Rectf }, + { "glRectfv", (GLvoid *) glRectfv, _gloffset_Rectfv }, + { "glRecti", (GLvoid *) glRecti, _gloffset_Recti }, + { "glRectiv", (GLvoid *) glRectiv, _gloffset_Rectiv }, + { "glRects", (GLvoid *) glRects, _gloffset_Rects }, + { "glRectsv", (GLvoid *) glRectsv, _gloffset_Rectsv }, + { "glTexCoord1d", (GLvoid *) glTexCoord1d, _gloffset_TexCoord1d }, + { "glTexCoord1dv", (GLvoid *) glTexCoord1dv, _gloffset_TexCoord1dv }, + { "glTexCoord1f", (GLvoid *) glTexCoord1f, _gloffset_TexCoord1f }, + { "glTexCoord1fv", (GLvoid *) glTexCoord1fv, _gloffset_TexCoord1fv }, + { "glTexCoord1i", (GLvoid *) glTexCoord1i, _gloffset_TexCoord1i }, + { "glTexCoord1iv", (GLvoid *) glTexCoord1iv, _gloffset_TexCoord1iv }, + { "glTexCoord1s", (GLvoid *) glTexCoord1s, _gloffset_TexCoord1s }, + { "glTexCoord1sv", (GLvoid *) glTexCoord1sv, _gloffset_TexCoord1sv }, + { "glTexCoord2d", (GLvoid *) glTexCoord2d, _gloffset_TexCoord2d }, + { "glTexCoord2dv", (GLvoid *) glTexCoord2dv, _gloffset_TexCoord2dv }, + { "glTexCoord2f", (GLvoid *) glTexCoord2f, _gloffset_TexCoord2f }, + { "glTexCoord2fv", (GLvoid *) glTexCoord2fv, _gloffset_TexCoord2fv }, + { "glTexCoord2i", (GLvoid *) glTexCoord2i, _gloffset_TexCoord2i }, + { "glTexCoord2iv", (GLvoid *) glTexCoord2iv, _gloffset_TexCoord2iv }, + { "glTexCoord2s", (GLvoid *) glTexCoord2s, _gloffset_TexCoord2s }, + { "glTexCoord2sv", (GLvoid *) glTexCoord2sv, _gloffset_TexCoord2sv }, + { "glTexCoord3d", (GLvoid *) glTexCoord3d, _gloffset_TexCoord3d }, + { "glTexCoord3dv", (GLvoid *) glTexCoord3dv, _gloffset_TexCoord3dv }, + { "glTexCoord3f", (GLvoid *) glTexCoord3f, _gloffset_TexCoord3f }, + { "glTexCoord3fv", (GLvoid *) glTexCoord3fv, _gloffset_TexCoord3fv }, + { "glTexCoord3i", (GLvoid *) glTexCoord3i, _gloffset_TexCoord3i }, + { "glTexCoord3iv", (GLvoid *) glTexCoord3iv, _gloffset_TexCoord3iv }, + { "glTexCoord3s", (GLvoid *) glTexCoord3s, _gloffset_TexCoord3s }, + { "glTexCoord3sv", (GLvoid *) glTexCoord3sv, _gloffset_TexCoord3sv }, + { "glTexCoord4d", (GLvoid *) glTexCoord4d, _gloffset_TexCoord4d }, + { "glTexCoord4dv", (GLvoid *) glTexCoord4dv, _gloffset_TexCoord4dv }, + { "glTexCoord4f", (GLvoid *) glTexCoord4f, _gloffset_TexCoord4f }, + { "glTexCoord4fv", (GLvoid *) glTexCoord4fv, _gloffset_TexCoord4fv }, + { "glTexCoord4i", (GLvoid *) glTexCoord4i, _gloffset_TexCoord4i }, + { "glTexCoord4iv", (GLvoid *) glTexCoord4iv, _gloffset_TexCoord4iv }, + { "glTexCoord4s", (GLvoid *) glTexCoord4s, _gloffset_TexCoord4s }, + { "glTexCoord4sv", (GLvoid *) glTexCoord4sv, _gloffset_TexCoord4sv }, + { "glVertex2d", (GLvoid *) glVertex2d, _gloffset_Vertex2d }, + { "glVertex2dv", (GLvoid *) glVertex2dv, _gloffset_Vertex2dv }, + { "glVertex2f", (GLvoid *) glVertex2f, _gloffset_Vertex2f }, + { "glVertex2fv", (GLvoid *) glVertex2fv, _gloffset_Vertex2fv }, + { "glVertex2i", (GLvoid *) glVertex2i, _gloffset_Vertex2i }, + { "glVertex2iv", (GLvoid *) glVertex2iv, _gloffset_Vertex2iv }, + { "glVertex2s", (GLvoid *) glVertex2s, _gloffset_Vertex2s }, + { "glVertex2sv", (GLvoid *) glVertex2sv, _gloffset_Vertex2sv }, + { "glVertex3d", (GLvoid *) glVertex3d, _gloffset_Vertex3d }, + { "glVertex3dv", (GLvoid *) glVertex3dv, _gloffset_Vertex3dv }, + { "glVertex3f", (GLvoid *) glVertex3f, _gloffset_Vertex3f }, + { "glVertex3fv", (GLvoid *) glVertex3fv, _gloffset_Vertex3fv }, + { "glVertex3i", (GLvoid *) glVertex3i, _gloffset_Vertex3i }, + { "glVertex3iv", (GLvoid *) glVertex3iv, _gloffset_Vertex3iv }, + { "glVertex3s", (GLvoid *) glVertex3s, _gloffset_Vertex3s }, + { "glVertex3sv", (GLvoid *) glVertex3sv, _gloffset_Vertex3sv }, + { "glVertex4d", (GLvoid *) glVertex4d, _gloffset_Vertex4d }, + { "glVertex4dv", (GLvoid *) glVertex4dv, _gloffset_Vertex4dv }, + { "glVertex4f", (GLvoid *) glVertex4f, _gloffset_Vertex4f }, + { "glVertex4fv", (GLvoid *) glVertex4fv, _gloffset_Vertex4fv }, + { "glVertex4i", (GLvoid *) glVertex4i, _gloffset_Vertex4i }, + { "glVertex4iv", (GLvoid *) glVertex4iv, _gloffset_Vertex4iv }, + { "glVertex4s", (GLvoid *) glVertex4s, _gloffset_Vertex4s }, + { "glVertex4sv", (GLvoid *) glVertex4sv, _gloffset_Vertex4sv }, + { "glClipPlane", (GLvoid *) glClipPlane, _gloffset_ClipPlane }, + { "glColorMaterial", (GLvoid *) glColorMaterial, _gloffset_ColorMaterial }, + { "glCullFace", (GLvoid *) glCullFace, _gloffset_CullFace }, + { "glFogf", (GLvoid *) glFogf, _gloffset_Fogf }, + { "glFogfv", (GLvoid *) glFogfv, _gloffset_Fogfv }, + { "glFogi", (GLvoid *) glFogi, _gloffset_Fogi }, + { "glFogiv", (GLvoid *) glFogiv, _gloffset_Fogiv }, + { "glFrontFace", (GLvoid *) glFrontFace, _gloffset_FrontFace }, + { "glHint", (GLvoid *) glHint, _gloffset_Hint }, + { "glLightf", (GLvoid *) glLightf, _gloffset_Lightf }, + { "glLightfv", (GLvoid *) glLightfv, _gloffset_Lightfv }, + { "glLighti", (GLvoid *) glLighti, _gloffset_Lighti }, + { "glLightiv", (GLvoid *) glLightiv, _gloffset_Lightiv }, + { "glLightModelf", (GLvoid *) glLightModelf, _gloffset_LightModelf }, + { "glLightModelfv", (GLvoid *) glLightModelfv, _gloffset_LightModelfv }, + { "glLightModeli", (GLvoid *) glLightModeli, _gloffset_LightModeli }, + { "glLightModeliv", (GLvoid *) glLightModeliv, _gloffset_LightModeliv }, + { "glLineStipple", (GLvoid *) glLineStipple, _gloffset_LineStipple }, + { "glLineWidth", (GLvoid *) glLineWidth, _gloffset_LineWidth }, + { "glMaterialf", (GLvoid *) glMaterialf, _gloffset_Materialf }, + { "glMaterialfv", (GLvoid *) glMaterialfv, _gloffset_Materialfv }, + { "glMateriali", (GLvoid *) glMateriali, _gloffset_Materiali }, + { "glMaterialiv", (GLvoid *) glMaterialiv, _gloffset_Materialiv }, + { "glPointSize", (GLvoid *) glPointSize, _gloffset_PointSize }, + { "glPolygonMode", (GLvoid *) glPolygonMode, _gloffset_PolygonMode }, + { "glPolygonStipple", (GLvoid *) glPolygonStipple, _gloffset_PolygonStipple }, + { "glScissor", (GLvoid *) glScissor, _gloffset_Scissor }, + { "glShadeModel", (GLvoid *) glShadeModel, _gloffset_ShadeModel }, + { "glTexParameterf", (GLvoid *) glTexParameterf, _gloffset_TexParameterf }, + { "glTexParameterfv", (GLvoid *) glTexParameterfv, _gloffset_TexParameterfv }, + { "glTexParameteri", (GLvoid *) glTexParameteri, _gloffset_TexParameteri }, + { "glTexParameteriv", (GLvoid *) glTexParameteriv, _gloffset_TexParameteriv }, + { "glTexImage1D", (GLvoid *) glTexImage1D, _gloffset_TexImage1D }, + { "glTexImage2D", (GLvoid *) glTexImage2D, _gloffset_TexImage2D }, + { "glTexEnvf", (GLvoid *) glTexEnvf, _gloffset_TexEnvf }, + { "glTexEnvfv", (GLvoid *) glTexEnvfv, _gloffset_TexEnvfv }, + { "glTexEnvi", (GLvoid *) glTexEnvi, _gloffset_TexEnvi }, + { "glTexEnviv", (GLvoid *) glTexEnviv, _gloffset_TexEnviv }, + { "glTexGend", (GLvoid *) glTexGend, _gloffset_TexGend }, + { "glTexGendv", (GLvoid *) glTexGendv, _gloffset_TexGendv }, + { "glTexGenf", (GLvoid *) glTexGenf, _gloffset_TexGenf }, + { "glTexGenfv", (GLvoid *) glTexGenfv, _gloffset_TexGenfv }, + { "glTexGeni", (GLvoid *) glTexGeni, _gloffset_TexGeni }, + { "glTexGeniv", (GLvoid *) glTexGeniv, _gloffset_TexGeniv }, + { "glFeedbackBuffer", (GLvoid *) glFeedbackBuffer, _gloffset_FeedbackBuffer }, + { "glSelectBuffer", (GLvoid *) glSelectBuffer, _gloffset_SelectBuffer }, + { "glRenderMode", (GLvoid *) glRenderMode, _gloffset_RenderMode }, + { "glInitNames", (GLvoid *) glInitNames, _gloffset_InitNames }, + { "glLoadName", (GLvoid *) glLoadName, _gloffset_LoadName }, + { "glPassThrough", (GLvoid *) glPassThrough, _gloffset_PassThrough }, + { "glPopName", (GLvoid *) glPopName, _gloffset_PopName }, + { "glPushName", (GLvoid *) glPushName, _gloffset_PushName }, + { "glDrawBuffer", (GLvoid *) glDrawBuffer, _gloffset_DrawBuffer }, + { "glClear", (GLvoid *) glClear, _gloffset_Clear }, + { "glClearAccum", (GLvoid *) glClearAccum, _gloffset_ClearAccum }, + { "glClearIndex", (GLvoid *) glClearIndex, _gloffset_ClearIndex }, + { "glClearColor", (GLvoid *) glClearColor, _gloffset_ClearColor }, + { "glClearStencil", (GLvoid *) glClearStencil, _gloffset_ClearStencil }, + { "glClearDepth", (GLvoid *) glClearDepth, _gloffset_ClearDepth }, + { "glStencilMask", (GLvoid *) glStencilMask, _gloffset_StencilMask }, + { "glColorMask", (GLvoid *) glColorMask, _gloffset_ColorMask }, + { "glDepthMask", (GLvoid *) glDepthMask, _gloffset_DepthMask }, + { "glIndexMask", (GLvoid *) glIndexMask, _gloffset_IndexMask }, + { "glAccum", (GLvoid *) glAccum, _gloffset_Accum }, + { "glDisable", (GLvoid *) glDisable, _gloffset_Disable }, + { "glEnable", (GLvoid *) glEnable, _gloffset_Enable }, + { "glFinish", (GLvoid *) glFinish, _gloffset_Finish }, + { "glFlush", (GLvoid *) glFlush, _gloffset_Flush }, + { "glPopAttrib", (GLvoid *) glPopAttrib, _gloffset_PopAttrib }, + { "glPushAttrib", (GLvoid *) glPushAttrib, _gloffset_PushAttrib }, + { "glMap1d", (GLvoid *) glMap1d, _gloffset_Map1d }, + { "glMap1f", (GLvoid *) glMap1f, _gloffset_Map1f }, + { "glMap2d", (GLvoid *) glMap2d, _gloffset_Map2d }, + { "glMap2f", (GLvoid *) glMap2f, _gloffset_Map2f }, + { "glMapGrid1d", (GLvoid *) glMapGrid1d, _gloffset_MapGrid1d }, + { "glMapGrid1f", (GLvoid *) glMapGrid1f, _gloffset_MapGrid1f }, + { "glMapGrid2d", (GLvoid *) glMapGrid2d, _gloffset_MapGrid2d }, + { "glMapGrid2f", (GLvoid *) glMapGrid2f, _gloffset_MapGrid2f }, + { "glEvalCoord1d", (GLvoid *) glEvalCoord1d, _gloffset_EvalCoord1d }, + { "glEvalCoord1dv", (GLvoid *) glEvalCoord1dv, _gloffset_EvalCoord1dv }, + { "glEvalCoord1f", (GLvoid *) glEvalCoord1f, _gloffset_EvalCoord1f }, + { "glEvalCoord1fv", (GLvoid *) glEvalCoord1fv, _gloffset_EvalCoord1fv }, + { "glEvalCoord2d", (GLvoid *) glEvalCoord2d, _gloffset_EvalCoord2d }, + { "glEvalCoord2dv", (GLvoid *) glEvalCoord2dv, _gloffset_EvalCoord2dv }, + { "glEvalCoord2f", (GLvoid *) glEvalCoord2f, _gloffset_EvalCoord2f }, + { "glEvalCoord2fv", (GLvoid *) glEvalCoord2fv, _gloffset_EvalCoord2fv }, + { "glEvalMesh1", (GLvoid *) glEvalMesh1, _gloffset_EvalMesh1 }, + { "glEvalPoint1", (GLvoid *) glEvalPoint1, _gloffset_EvalPoint1 }, + { "glEvalMesh2", (GLvoid *) glEvalMesh2, _gloffset_EvalMesh2 }, + { "glEvalPoint2", (GLvoid *) glEvalPoint2, _gloffset_EvalPoint2 }, + { "glAlphaFunc", (GLvoid *) glAlphaFunc, _gloffset_AlphaFunc }, + { "glBlendFunc", (GLvoid *) glBlendFunc, _gloffset_BlendFunc }, + { "glLogicOp", (GLvoid *) glLogicOp, _gloffset_LogicOp }, + { "glStencilFunc", (GLvoid *) glStencilFunc, _gloffset_StencilFunc }, + { "glStencilOp", (GLvoid *) glStencilOp, _gloffset_StencilOp }, + { "glDepthFunc", (GLvoid *) glDepthFunc, _gloffset_DepthFunc }, + { "glPixelZoom", (GLvoid *) glPixelZoom, _gloffset_PixelZoom }, + { "glPixelTransferf", (GLvoid *) glPixelTransferf, _gloffset_PixelTransferf }, + { "glPixelTransferi", (GLvoid *) glPixelTransferi, _gloffset_PixelTransferi }, + { "glPixelStoref", (GLvoid *) glPixelStoref, _gloffset_PixelStoref }, + { "glPixelStorei", (GLvoid *) glPixelStorei, _gloffset_PixelStorei }, + { "glPixelMapfv", (GLvoid *) glPixelMapfv, _gloffset_PixelMapfv }, + { "glPixelMapuiv", (GLvoid *) glPixelMapuiv, _gloffset_PixelMapuiv }, + { "glPixelMapusv", (GLvoid *) glPixelMapusv, _gloffset_PixelMapusv }, + { "glReadBuffer", (GLvoid *) glReadBuffer, _gloffset_ReadBuffer }, + { "glCopyPixels", (GLvoid *) glCopyPixels, _gloffset_CopyPixels }, + { "glReadPixels", (GLvoid *) glReadPixels, _gloffset_ReadPixels }, + { "glDrawPixels", (GLvoid *) glDrawPixels, _gloffset_DrawPixels }, + { "glGetBooleanv", (GLvoid *) glGetBooleanv, _gloffset_GetBooleanv }, + { "glGetClipPlane", (GLvoid *) glGetClipPlane, _gloffset_GetClipPlane }, + { "glGetDoublev", (GLvoid *) glGetDoublev, _gloffset_GetDoublev }, + { "glGetError", (GLvoid *) glGetError, _gloffset_GetError }, + { "glGetFloatv", (GLvoid *) glGetFloatv, _gloffset_GetFloatv }, + { "glGetIntegerv", (GLvoid *) glGetIntegerv, _gloffset_GetIntegerv }, + { "glGetLightfv", (GLvoid *) glGetLightfv, _gloffset_GetLightfv }, + { "glGetLightiv", (GLvoid *) glGetLightiv, _gloffset_GetLightiv }, + { "glGetMapdv", (GLvoid *) glGetMapdv, _gloffset_GetMapdv }, + { "glGetMapfv", (GLvoid *) glGetMapfv, _gloffset_GetMapfv }, + { "glGetMapiv", (GLvoid *) glGetMapiv, _gloffset_GetMapiv }, + { "glGetMaterialfv", (GLvoid *) glGetMaterialfv, _gloffset_GetMaterialfv }, + { "glGetMaterialiv", (GLvoid *) glGetMaterialiv, _gloffset_GetMaterialiv }, + { "glGetPixelMapfv", (GLvoid *) glGetPixelMapfv, _gloffset_GetPixelMapfv }, + { "glGetPixelMapuiv", (GLvoid *) glGetPixelMapuiv, _gloffset_GetPixelMapuiv }, + { "glGetPixelMapusv", (GLvoid *) glGetPixelMapusv, _gloffset_GetPixelMapusv }, + { "glGetPolygonStipple", (GLvoid *) glGetPolygonStipple, _gloffset_GetPolygonStipple }, + { "glGetString", (GLvoid *) glGetString, _gloffset_GetString }, + { "glGetTexEnvfv", (GLvoid *) glGetTexEnvfv, _gloffset_GetTexEnvfv }, + { "glGetTexEnviv", (GLvoid *) glGetTexEnviv, _gloffset_GetTexEnviv }, + { "glGetTexGendv", (GLvoid *) glGetTexGendv, _gloffset_GetTexGendv }, + { "glGetTexGenfv", (GLvoid *) glGetTexGenfv, _gloffset_GetTexGenfv }, + { "glGetTexGeniv", (GLvoid *) glGetTexGeniv, _gloffset_GetTexGeniv }, + { "glGetTexImage", (GLvoid *) glGetTexImage, _gloffset_GetTexImage }, + { "glGetTexParameterfv", (GLvoid *) glGetTexParameterfv, _gloffset_GetTexParameterfv }, + { "glGetTexParameteriv", (GLvoid *) glGetTexParameteriv, _gloffset_GetTexParameteriv }, + { "glGetTexLevelParameterfv", (GLvoid *) glGetTexLevelParameterfv, _gloffset_GetTexLevelParameterfv }, + { "glGetTexLevelParameteriv", (GLvoid *) glGetTexLevelParameteriv, _gloffset_GetTexLevelParameteriv }, + { "glIsEnabled", (GLvoid *) glIsEnabled, _gloffset_IsEnabled }, + { "glIsList", (GLvoid *) glIsList, _gloffset_IsList }, + { "glDepthRange", (GLvoid *) glDepthRange, _gloffset_DepthRange }, + { "glFrustum", (GLvoid *) glFrustum, _gloffset_Frustum }, + { "glLoadIdentity", (GLvoid *) glLoadIdentity, _gloffset_LoadIdentity }, + { "glLoadMatrixf", (GLvoid *) glLoadMatrixf, _gloffset_LoadMatrixf }, + { "glLoadMatrixd", (GLvoid *) glLoadMatrixd, _gloffset_LoadMatrixd }, + { "glMatrixMode", (GLvoid *) glMatrixMode, _gloffset_MatrixMode }, + { "glMultMatrixf", (GLvoid *) glMultMatrixf, _gloffset_MultMatrixf }, + { "glMultMatrixd", (GLvoid *) glMultMatrixd, _gloffset_MultMatrixd }, + { "glOrtho", (GLvoid *) glOrtho, _gloffset_Ortho }, + { "glPopMatrix", (GLvoid *) glPopMatrix, _gloffset_PopMatrix }, + { "glPushMatrix", (GLvoid *) glPushMatrix, _gloffset_PushMatrix }, + { "glRotated", (GLvoid *) glRotated, _gloffset_Rotated }, + { "glRotatef", (GLvoid *) glRotatef, _gloffset_Rotatef }, + { "glScaled", (GLvoid *) glScaled, _gloffset_Scaled }, + { "glScalef", (GLvoid *) glScalef, _gloffset_Scalef }, + { "glTranslated", (GLvoid *) glTranslated, _gloffset_Translated }, + { "glTranslatef", (GLvoid *) glTranslatef, _gloffset_Translatef }, + { "glViewport", (GLvoid *) glViewport, _gloffset_Viewport }, + /* 1.1 */ + { "glArrayElement", (GLvoid *) glArrayElement, _gloffset_ArrayElement }, + { "glColorPointer", (GLvoid *) glColorPointer, _gloffset_ColorPointer }, + { "glDisableClientState", (GLvoid *) glDisableClientState, _gloffset_DisableClientState }, + { "glDrawArrays", (GLvoid *) glDrawArrays, _gloffset_DrawArrays }, + { "glDrawElements", (GLvoid *) glDrawElements, _gloffset_DrawElements }, + { "glEdgeFlagPointer", (GLvoid *) glEdgeFlagPointer, _gloffset_EdgeFlagPointer }, + { "glEnableClientState", (GLvoid *) glEnableClientState, _gloffset_EnableClientState }, + { "glGetPointerv", (GLvoid *) glGetPointerv, _gloffset_GetPointerv }, + { "glIndexPointer", (GLvoid *) glIndexPointer, _gloffset_IndexPointer }, + { "glInterleavedArrays", (GLvoid *) glInterleavedArrays, _gloffset_InterleavedArrays }, + { "glNormalPointer", (GLvoid *) glNormalPointer, _gloffset_NormalPointer }, + { "glTexCoordPointer", (GLvoid *) glTexCoordPointer, _gloffset_TexCoordPointer }, + { "glVertexPointer", (GLvoid *) glVertexPointer, _gloffset_VertexPointer }, + { "glPolygonOffset", (GLvoid *) glPolygonOffset, _gloffset_PolygonOffset }, + { "glCopyTexImage1D", (GLvoid *) glCopyTexImage1D, _gloffset_CopyTexImage1D }, + { "glCopyTexImage2D", (GLvoid *) glCopyTexImage2D, _gloffset_CopyTexImage2D }, + { "glCopyTexSubImage1D", (GLvoid *) glCopyTexSubImage1D, _gloffset_CopyTexSubImage1D }, + { "glCopyTexSubImage2D", (GLvoid *) glCopyTexSubImage2D, _gloffset_CopyTexSubImage2D }, + { "glTexSubImage1D", (GLvoid *) glTexSubImage1D, _gloffset_TexSubImage1D }, + { "glTexSubImage2D", (GLvoid *) glTexSubImage2D, _gloffset_TexSubImage2D }, + { "glAreTexturesResident", (GLvoid *) glAreTexturesResident, _gloffset_AreTexturesResident }, + { "glBindTexture", (GLvoid *) glBindTexture, _gloffset_BindTexture }, + { "glDeleteTextures", (GLvoid *) glDeleteTextures, _gloffset_DeleteTextures }, + { "glGenTextures", (GLvoid *) glGenTextures, _gloffset_GenTextures }, + { "glIsTexture", (GLvoid *) glIsTexture, _gloffset_IsTexture }, + { "glPrioritizeTextures", (GLvoid *) glPrioritizeTextures, _gloffset_PrioritizeTextures }, + { "glIndexub", (GLvoid *) glIndexub, _gloffset_Indexub }, + { "glIndexubv", (GLvoid *) glIndexubv, _gloffset_Indexubv }, + { "glPopClientAttrib", (GLvoid *) glPopClientAttrib, _gloffset_PopClientAttrib }, + { "glPushClientAttrib", (GLvoid *) glPushClientAttrib, _gloffset_PushClientAttrib }, + /* 1.2 */ +#ifdef GL_VERSION_1_2 #define NAME(X) X #else #define NAME(X) NotImplemented #endif - { "glAreTexturesResident", (GLvoid *) NAME(glAreTexturesResident) }, - { "glArrayElement", (GLvoid *) NAME(glArrayElement) }, - { "glBindTexture", (GLvoid *) NAME(glBindTexture) }, - { "glColorPointer", (GLvoid *) NAME(glColorPointer) }, - { "glCopyTexImage1D", (GLvoid *) NAME(glCopyTexImage1D) }, - { "glCopyTexImage2D", (GLvoid *) NAME(glCopyTexImage2D) }, - { "glCopyTexSubImage1D", (GLvoid *) NAME(glCopyTexSubImage1D) }, - { "glCopyTexSubImage2D", (GLvoid *) NAME(glCopyTexSubImage2D) }, - { "glDeleteTextures", (GLvoid *) NAME(glDeleteTextures) }, - { "glDisableClientState", (GLvoid *) NAME(glDisableClientState) }, - { "glDrawArrays", (GLvoid *) NAME(glDrawArrays) }, - { "glDrawElements", (GLvoid *) NAME(glDrawElements) }, - { "glEdgeFlagPointer", (GLvoid *) NAME(glEdgeFlagPointer) }, - { "glEnableClientState", (GLvoid *) NAME(glEnableClientState) }, - { "glGenTextures", (GLvoid *) NAME(glGenTextures) }, - { "glGetPointerv", (GLvoid *) NAME(glGetPointerv) }, - { "glIndexPointer", (GLvoid *) NAME(glIndexPointer) }, - { "glIndexub", (GLvoid *) NAME(glIndexub) }, - { "glIndexubv", (GLvoid *) NAME(glIndexubv) }, - { "glInterleavedArrays", (GLvoid *) NAME(glInterleavedArrays) }, - { "glIsTexture", (GLvoid *) NAME(glIsTexture) }, - { "glNormalPointer", (GLvoid *) NAME(glNormalPointer) }, - { "glPopClientAttrib", (GLvoid *) NAME(glPopClientAttrib) }, - { "glPrioritizeTextures", (GLvoid *) NAME(glPrioritizeTextures) }, - { "glPushClientAttrib", (GLvoid *) NAME(glPushClientAttrib) }, - { "glTexCoordPointer", (GLvoid *) NAME(glTexCoordPointer) }, - { "glTexSubImage1D", (GLvoid *) NAME(glTexSubImage1D) }, - { "glTexSubImage2D", (GLvoid *) NAME(glTexSubImage2D) }, - { "glVertexPointer", (GLvoid *) NAME(glVertexPointer) }, + { "glBlendColor", (GLvoid *) NAME(glBlendColor), _gloffset_BlendColor }, + { "glBlendEquation", (GLvoid *) NAME(glBlendEquation), _gloffset_BlendEquation }, + { "glDrawRangeElements", (GLvoid *) NAME(glDrawRangeElements), _gloffset_DrawRangeElements }, + { "glColorTable", (GLvoid *) NAME(glColorTable), _gloffset_ColorTable }, + { "glColorTableParameterfv", (GLvoid *) NAME(glColorTableParameterfv), _gloffset_ColorTableParameterfv }, + { "glColorTableParameteriv", (GLvoid *) NAME(glColorTableParameteriv), _gloffset_ColorTableParameteriv }, + { "glCopyColorTable", (GLvoid *) NAME(glCopyColorTable), _gloffset_CopyColorTable }, + { "glGetColorTable", (GLvoid *) NAME(glGetColorTable), _gloffset_GetColorTable }, + { "glGetColorTableParameterfv", (GLvoid *) NAME(glGetColorTableParameterfv), _gloffset_GetColorTableParameterfv }, + { "glGetColorTableParameteriv", (GLvoid *) NAME(glGetColorTableParameteriv), _gloffset_GetColorTableParameteriv }, + { "glColorSubTable", (GLvoid *) NAME(glColorSubTable), _gloffset_ColorSubTable }, + { "glCopyColorSubTable", (GLvoid *) NAME(glCopyColorSubTable), _gloffset_CopyColorSubTable }, + { "glConvolutionFilter1D", (GLvoid *) NAME(glConvolutionFilter1D), _gloffset_ConvolutionFilter1D }, + { "glConvolutionFilter2D", (GLvoid *) NAME(glConvolutionFilter2D), _gloffset_ConvolutionFilter2D }, + { "glConvolutionParameterf", (GLvoid *) NAME(glConvolutionParameterf), _gloffset_ConvolutionParameterf }, + { "glConvolutionParameterfv", (GLvoid *) NAME(glConvolutionParameterfv), _gloffset_ConvolutionParameterfv }, + { "glConvolutionParameteri", (GLvoid *) NAME(glConvolutionParameteri), _gloffset_ConvolutionParameteri }, + { "glConvolutionParameteriv", (GLvoid *) NAME(glConvolutionParameteriv), _gloffset_ConvolutionParameteriv }, + { "glCopyConvolutionFilter1D", (GLvoid *) NAME(glCopyConvolutionFilter1D), _gloffset_CopyConvolutionFilter1D }, + { "glCopyConvolutionFilter2D", (GLvoid *) NAME(glCopyConvolutionFilter2D), _gloffset_CopyConvolutionFilter2D }, + { "glGetConvolutionFilter", (GLvoid *) NAME(glGetConvolutionFilter), _gloffset_GetConvolutionFilter }, + { "glGetConvolutionParameterfv", (GLvoid *) NAME(glGetConvolutionParameterfv), _gloffset_GetConvolutionParameterfv }, + { "glGetConvolutionParameteriv", (GLvoid *) NAME(glGetConvolutionParameteriv), _gloffset_GetConvolutionParameteriv }, + { "glGetSeparableFilter", (GLvoid *) NAME(glGetSeparableFilter), _gloffset_GetSeparableFilter }, + { "glSeparableFilter2D", (GLvoid *) NAME(glSeparableFilter2D), _gloffset_SeparableFilter2D }, + { "glGetHistogram", (GLvoid *) NAME(glGetHistogram), _gloffset_GetHistogram }, + { "glGetHistogramParameterfv", (GLvoid *) NAME(glGetHistogramParameterfv), _gloffset_GetHistogramParameterfv }, + { "glGetHistogramParameteriv", (GLvoid *) NAME(glGetHistogramParameteriv), _gloffset_GetHistogramParameteriv }, + { "glGetMinmax", (GLvoid *) NAME(glGetMinmax), _gloffset_GetMinmax }, + { "glGetMinmaxParameterfv", (GLvoid *) NAME(glGetMinmaxParameterfv), _gloffset_GetMinmaxParameterfv }, + { "glGetMinmaxParameteriv", (GLvoid *) NAME(glGetMinmaxParameteriv), _gloffset_GetMinmaxParameteriv }, + { "glHistogram", (GLvoid *) NAME(glHistogram), _gloffset_Histogram }, + { "glMinmax", (GLvoid *) NAME(glMinmax), _gloffset_Minmax }, + { "glResetHistogram", (GLvoid *) NAME(glResetHistogram), _gloffset_ResetHistogram }, + { "glResetMinmax", (GLvoid *) NAME(glResetMinmax), _gloffset_ResetMinmax }, + { "glTexImage3D", (GLvoid *) NAME(glTexImage3D), _gloffset_TexImage3D }, + { "glTexSubImage3D", (GLvoid *) NAME(glTexSubImage3D), _gloffset_TexSubImage3D }, + { "glCopyTexSubImage3D", (GLvoid *) NAME(glCopyTexSubImage3D), _gloffset_CopyTexSubImage3D }, #undef NAME - /* GL 1.2 */ -#ifdef GL_VERSION_1_2 + /* GL_ARB_multitexture */ +#ifdef GL_ARB_multitexture #define NAME(X) X #else #define NAME(X) NotImplemented #endif - { "glCopyTexSubImage3D", (GLvoid *) NAME(glCopyTexSubImage3D) }, - { "glDrawRangeElements", (GLvoid *) NAME(glDrawRangeElements) }, - { "glTexImage3D", (GLvoid *) NAME(glTexImage3D) }, - { "glTexSubImage3D", (GLvoid *) NAME(glTexSubImage3D) }, + { "glActiveTextureARB", (GLvoid *) NAME(glActiveTextureARB), _gloffset_ActiveTextureARB }, + { "glClientActiveTextureARB", (GLvoid *) NAME(glClientActiveTextureARB), _gloffset_ClientActiveTextureARB }, + { "glMultiTexCoord1dARB", (GLvoid *) NAME(glMultiTexCoord1dARB), _gloffset_MultiTexCoord1dARB }, + { "glMultiTexCoord1dvARB", (GLvoid *) NAME(glMultiTexCoord1dvARB), _gloffset_MultiTexCoord1dvARB }, + { "glMultiTexCoord1fARB", (GLvoid *) NAME(glMultiTexCoord1fARB), _gloffset_MultiTexCoord1fARB }, + { "glMultiTexCoord1fvARB", (GLvoid *) NAME(glMultiTexCoord1fvARB), _gloffset_MultiTexCoord1fvARB }, + { "glMultiTexCoord1iARB", (GLvoid *) NAME(glMultiTexCoord1iARB), _gloffset_MultiTexCoord1iARB }, + { "glMultiTexCoord1ivARB", (GLvoid *) NAME(glMultiTexCoord1ivARB), _gloffset_MultiTexCoord1ivARB }, + { "glMultiTexCoord1sARB", (GLvoid *) NAME(glMultiTexCoord1sARB), _gloffset_MultiTexCoord1sARB }, + { "glMultiTexCoord1svARB", (GLvoid *) NAME(glMultiTexCoord1svARB), _gloffset_MultiTexCoord1svARB }, + { "glMultiTexCoord2dARB", (GLvoid *) NAME(glMultiTexCoord2dARB), _gloffset_MultiTexCoord2dARB }, + { "glMultiTexCoord2dvARB", (GLvoid *) NAME(glMultiTexCoord2dvARB), _gloffset_MultiTexCoord2dvARB }, + { "glMultiTexCoord2fARB", (GLvoid *) NAME(glMultiTexCoord2fARB), _gloffset_MultiTexCoord2fARB }, + { "glMultiTexCoord2fvARB", (GLvoid *) NAME(glMultiTexCoord2fvARB), _gloffset_MultiTexCoord2fvARB }, + { "glMultiTexCoord2iARB", (GLvoid *) NAME(glMultiTexCoord2iARB), _gloffset_MultiTexCoord2iARB }, + { "glMultiTexCoord2ivARB", (GLvoid *) NAME(glMultiTexCoord2ivARB), _gloffset_MultiTexCoord2ivARB }, + { "glMultiTexCoord2sARB", (GLvoid *) NAME(glMultiTexCoord2sARB), _gloffset_MultiTexCoord2sARB }, + { "glMultiTexCoord2svARB", (GLvoid *) NAME(glMultiTexCoord2svARB), _gloffset_MultiTexCoord2svARB }, + { "glMultiTexCoord3dARB", (GLvoid *) NAME(glMultiTexCoord3dARB), _gloffset_MultiTexCoord3dARB }, + { "glMultiTexCoord3dvARB", (GLvoid *) NAME(glMultiTexCoord3dvARB), _gloffset_MultiTexCoord3dvARB }, + { "glMultiTexCoord3fARB", (GLvoid *) NAME(glMultiTexCoord3fARB), _gloffset_MultiTexCoord3fARB }, + { "glMultiTexCoord3fvARB", (GLvoid *) NAME(glMultiTexCoord3fvARB), _gloffset_MultiTexCoord3fvARB }, + { "glMultiTexCoord3iARB", (GLvoid *) NAME(glMultiTexCoord3iARB), _gloffset_MultiTexCoord3iARB }, + { "glMultiTexCoord3ivARB", (GLvoid *) NAME(glMultiTexCoord3ivARB), _gloffset_MultiTexCoord3ivARB }, + { "glMultiTexCoord3sARB", (GLvoid *) NAME(glMultiTexCoord3sARB), _gloffset_MultiTexCoord3sARB }, + { "glMultiTexCoord3svARB", (GLvoid *) NAME(glMultiTexCoord3svARB), _gloffset_MultiTexCoord3svARB }, + { "glMultiTexCoord4dARB", (GLvoid *) NAME(glMultiTexCoord4dARB), _gloffset_MultiTexCoord4dARB }, + { "glMultiTexCoord4dvARB", (GLvoid *) NAME(glMultiTexCoord4dvARB), _gloffset_MultiTexCoord4dvARB }, + { "glMultiTexCoord4fARB", (GLvoid *) NAME(glMultiTexCoord4fARB), _gloffset_MultiTexCoord4fARB }, + { "glMultiTexCoord4fvARB", (GLvoid *) NAME(glMultiTexCoord4fvARB), _gloffset_MultiTexCoord4fvARB }, + { "glMultiTexCoord4iARB", (GLvoid *) NAME(glMultiTexCoord4iARB), _gloffset_MultiTexCoord4iARB }, + { "glMultiTexCoord4ivARB", (GLvoid *) NAME(glMultiTexCoord4ivARB), _gloffset_MultiTexCoord4ivARB }, + { "glMultiTexCoord4sARB", (GLvoid *) NAME(glMultiTexCoord4sARB), _gloffset_MultiTexCoord4sARB }, + { "glMultiTexCoord4svARB", (GLvoid *) NAME(glMultiTexCoord4svARB), _gloffset_MultiTexCoord4svARB }, #undef NAME - /* GL_ARB_imaging */ -#ifdef GL_ARB_imaging + /* GL_ARB_transpose_matrix */ +#ifdef GL_ARB_transpose_matrix #define NAME(X) X #else #define NAME(X) NotImplemented #endif - { "glBlendColor", (GLvoid *) NAME(glBlendColor) }, - { "glBlendEquation", (GLvoid *) NAME(glBlendEquation) }, - { "glColorSubTable", (GLvoid *) NAME(glColorSubTable) }, - { "glColorTable", (GLvoid *) NAME(glColorTable) }, - { "glColorTableParameterfv", (GLvoid *) NAME(glColorTableParameterfv) }, - { "glColorTableParameteriv", (GLvoid *) NAME(glColorTableParameteriv) }, - { "glConvolutionFilter1D", (GLvoid *) NAME(glConvolutionFilter1D) }, - { "glConvolutionFilter2D", (GLvoid *) NAME(glConvolutionFilter2D) }, - { "glConvolutionParameterf", (GLvoid *) NAME(glConvolutionParameterf) }, - { "glConvolutionParameterfv", (GLvoid *) NAME(glConvolutionParameterfv) }, - { "glConvolutionParameteri", (GLvoid *) NAME(glConvolutionParameteri) }, - { "glConvolutionParameteriv", (GLvoid *) NAME(glConvolutionParameteriv) }, - { "glCopyColorSubTable", (GLvoid *) NAME(glCopyColorSubTable) }, - { "glCopyColorTable", (GLvoid *) NAME(glCopyColorTable) }, - { "glCopyConvolutionFilter1D", (GLvoid *) NAME(glCopyConvolutionFilter1D) }, - { "glCopyConvolutionFilter2D", (GLvoid *) NAME(glCopyConvolutionFilter2D) }, - { "glGetColorTable", (GLvoid *) NAME(glGetColorTable) }, - { "glGetColorTableParameterfv", (GLvoid *) NAME(glGetColorTableParameterfv) }, - { "glGetColorTableParameteriv", (GLvoid *) NAME(glGetColorTableParameteriv) }, - { "glGetConvolutionFilter", (GLvoid *) NAME(glGetConvolutionFilter) }, - { "glGetConvolutionParameterfv", (GLvoid *) NAME(glGetConvolutionParameterfv) }, - { "glGetConvolutionParameteriv", (GLvoid *) NAME(glGetConvolutionParameteriv) }, - { "glGetHistogram", (GLvoid *) NAME(glGetHistogram) }, - { "glGetHistogramParameterfv", (GLvoid *) NAME(glGetHistogramParameterfv) }, - { "glGetHistogramParameteriv", (GLvoid *) NAME(glGetHistogramParameteriv) }, - { "glGetMinmax", (GLvoid *) NAME(glGetMinmax) }, - { "glGetMinmaxParameterfv", (GLvoid *) NAME(glGetMinmaxParameterfv) }, - { "glGetMinmaxParameteriv", (GLvoid *) NAME(glGetMinmaxParameteriv) }, - { "glGetSeparableFilter", (GLvoid *) NAME(glGetSeparableFilter) }, - { "glHistogram", (GLvoid *) NAME(glHistogram) }, - { "glMinmax", (GLvoid *) NAME(glMinmax) }, - { "glResetHistogram", (GLvoid *) NAME(glResetHistogram) }, - { "glResetMinmax", (GLvoid *) NAME(glResetMinmax) }, - { "glSeparableFilter2D", (GLvoid *) NAME(glSeparableFilter2D) }, + { "glLoadTransposeMatrixdARB", (GLvoid *) NAME(glLoadTransposeMatrixdARB), _gloffset_LoadTransposeMatrixdARB }, + { "glLoadTransposeMatrixfARB", (GLvoid *) NAME(glLoadTransposeMatrixfARB), _gloffset_LoadTransposeMatrixfARB }, + { "glMultTransposeMatrixdARB", (GLvoid *) NAME(glMultTransposeMatrixdARB), _gloffset_MultTransposeMatrixdARB }, + { "glMultTransposeMatrixfARB", (GLvoid *) NAME(glMultTransposeMatrixfARB), _gloffset_MultTransposeMatrixfARB }, #undef NAME - /* GL_ARB_multitexture */ -#ifdef GL_ARB_multitexture + /* GL_ARB_multisample */ +#ifdef GL_ARB_multisample #define NAME(X) X #else #define NAME(X) NotImplemented #endif - { "glActiveTextureARB", (GLvoid *) NAME(glActiveTextureARB) }, - { "glClientActiveTextureARB", (GLvoid *) NAME(glClientActiveTextureARB) }, - { "glMultiTexCoord1dARB", (GLvoid *) NAME(glMultiTexCoord1dARB) }, - { "glMultiTexCoord1dvARB", (GLvoid *) NAME(glMultiTexCoord1dvARB) }, - { "glMultiTexCoord1fARB", (GLvoid *) NAME(glMultiTexCoord1fARB) }, - { "glMultiTexCoord1fvARB", (GLvoid *) NAME(glMultiTexCoord1fvARB) }, - { "glMultiTexCoord1iARB", (GLvoid *) NAME(glMultiTexCoord1iARB) }, - { "glMultiTexCoord1ivARB", (GLvoid *) NAME(glMultiTexCoord1ivARB) }, - { "glMultiTexCoord1sARB", (GLvoid *) NAME(glMultiTexCoord1sARB) }, - { "glMultiTexCoord1svARB", (GLvoid *) NAME(glMultiTexCoord1svARB) }, - { "glMultiTexCoord2dARB", (GLvoid *) NAME(glMultiTexCoord2dARB) }, - { "glMultiTexCoord2dvARB", (GLvoid *) NAME(glMultiTexCoord2dvARB) }, - { "glMultiTexCoord2fARB", (GLvoid *) NAME(glMultiTexCoord2fARB) }, - { "glMultiTexCoord2fvARB", (GLvoid *) NAME(glMultiTexCoord2fvARB) }, - { "glMultiTexCoord2iARB", (GLvoid *) NAME(glMultiTexCoord2iARB) }, - { "glMultiTexCoord2ivARB", (GLvoid *) NAME(glMultiTexCoord2ivARB) }, - { "glMultiTexCoord2sARB", (GLvoid *) NAME(glMultiTexCoord2sARB) }, - { "glMultiTexCoord2svARB", (GLvoid *) NAME(glMultiTexCoord2svARB) }, - { "glMultiTexCoord3dARB", (GLvoid *) NAME(glMultiTexCoord3dARB) }, - { "glMultiTexCoord3dvARB", (GLvoid *) NAME(glMultiTexCoord3dvARB) }, - { "glMultiTexCoord3fARB", (GLvoid *) NAME(glMultiTexCoord3fARB) }, - { "glMultiTexCoord3fvARB", (GLvoid *) NAME(glMultiTexCoord3fvARB) }, - { "glMultiTexCoord3iARB", (GLvoid *) NAME(glMultiTexCoord3iARB) }, - { "glMultiTexCoord3ivARB", (GLvoid *) NAME(glMultiTexCoord3ivARB) }, - { "glMultiTexCoord3sARB", (GLvoid *) NAME(glMultiTexCoord3sARB) }, - { "glMultiTexCoord3svARB", (GLvoid *) NAME(glMultiTexCoord3svARB) }, - { "glMultiTexCoord4dARB", (GLvoid *) NAME(glMultiTexCoord4dARB) }, - { "glMultiTexCoord4dvARB", (GLvoid *) NAME(glMultiTexCoord4dvARB) }, - { "glMultiTexCoord4fARB", (GLvoid *) NAME(glMultiTexCoord4fARB) }, - { "glMultiTexCoord4fvARB", (GLvoid *) NAME(glMultiTexCoord4fvARB) }, - { "glMultiTexCoord4iARB", (GLvoid *) NAME(glMultiTexCoord4iARB) }, - { "glMultiTexCoord4ivARB", (GLvoid *) NAME(glMultiTexCoord4ivARB) }, - { "glMultiTexCoord4sARB", (GLvoid *) NAME(glMultiTexCoord4sARB) }, - { "glMultiTexCoord4svARB", (GLvoid *) NAME(glMultiTexCoord4svARB) }, + { "glSampleCoverageARB", (GLvoid *) NAME(glSampleCoverageARB), _gloffset_SampleCoverageARB }, + { "glSamplePassARB", (GLvoid *) NAME(glSamplePassARB), _gloffset_SamplePassARB }, #undef NAME /* 2. GL_EXT_blend_color */ @@ -1039,7 +1037,7 @@ static struct name_address_pair static_functions[] = { #else #define NAME(X) NotImplemented #endif - { "glBlendColorEXT", (GLvoid *) NAME(glBlendColorEXT) }, + { "glBlendColorEXT", (GLvoid *) NAME(glBlendColorEXT), _gloffset_BlendColor }, #undef NAME /* 3. GL_EXT_polygon_offset */ @@ -1048,7 +1046,7 @@ static struct name_address_pair static_functions[] = { #else #define NAME(X) NotImplemented #endif - { "glPolygonOffsetEXT", (GLvoid *) NAME(glPolygonOffsetEXT) }, + { "glPolygonOffsetEXT", (GLvoid *) NAME(glPolygonOffsetEXT), _gloffset_PolygonOffsetEXT }, #undef NAME /* 6. GL_EXT_texture3D */ @@ -1057,9 +1055,9 @@ static struct name_address_pair static_functions[] = { #else #define NAME(X) NotImplemented #endif - { "glCopyTexSubImage3DEXT", (GLvoid *) NAME(glCopyTexSubImage3DEXT) }, - { "glTexImage3DEXT", (GLvoid *) NAME(glTexImage3DEXT) }, - { "glTexSubImage3DEXT", (GLvoid *) NAME(glTexSubImage3DEXT) }, + { "glCopyTexSubImage3DEXT", (GLvoid *) NAME(glCopyTexSubImage3DEXT), _gloffset_CopyTexSubImage3D }, + { "glTexImage3DEXT", (GLvoid *) NAME(glTexImage3DEXT), _gloffset_TexImage3D }, + { "glTexSubImage3DEXT", (GLvoid *) NAME(glTexSubImage3DEXT), _gloffset_TexSubImage3D }, #undef NAME /* 7. GL_SGI_texture_filter4 */ @@ -1068,8 +1066,8 @@ static struct name_address_pair static_functions[] = { #else #define NAME(X) NotImplemented #endif - { "glGetTexFilterFuncSGIS", (GLvoid *) NAME(glGetTexFilterFuncSGIS) }, - { "glTexFilterFuncSGIS", (GLvoid *) NAME(glTexFilterFuncSGIS) }, + { "glGetTexFilterFuncSGIS", (GLvoid *) NAME(glGetTexFilterFuncSGIS), _gloffset_GetTexFilterFuncSGIS }, + { "glTexFilterFuncSGIS", (GLvoid *) NAME(glTexFilterFuncSGIS), _gloffset_TexFilterFuncSGIS }, #undef NAME /* 9. GL_EXT_subtexture */ @@ -1078,8 +1076,8 @@ static struct name_address_pair static_functions[] = { #else #define NAME(X) NotImplemented #endif - { "glTexSubImage1DEXT", (GLvoid *) NAME(glTexSubImage1DEXT) }, - { "glTexSubImage2DEXT", (GLvoid *) NAME(glTexSubImage2DEXT) }, + { "glTexSubImage1DEXT", (GLvoid *) NAME(glTexSubImage1DEXT), _gloffset_TexSubImage1D }, + { "glTexSubImage2DEXT", (GLvoid *) NAME(glTexSubImage2DEXT), _gloffset_TexSubImage2D }, #undef NAME /* 10. GL_EXT_copy_texture */ @@ -1088,10 +1086,10 @@ static struct name_address_pair static_functions[] = { #else #define NAME(X) NotImplemented #endif - { "glCopyTexImage1DEXT", (GLvoid *) NAME(glCopyTexImage1DEXT) }, - { "glCopyTexImage2DEXT", (GLvoid *) NAME(glCopyTexImage2DEXT) }, - { "glCopyTexSubImage1DEXT", (GLvoid *) NAME(glCopyTexSubImage1DEXT) }, - { "glCopyTexSubImage2DEXT", (GLvoid *) NAME(glCopyTexSubImage2DEXT) }, + { "glCopyTexImage1DEXT", (GLvoid *) NAME(glCopyTexImage1DEXT), _gloffset_CopyTexImage1D }, + { "glCopyTexImage2DEXT", (GLvoid *) NAME(glCopyTexImage2DEXT), _gloffset_CopyTexImage2D }, + { "glCopyTexSubImage1DEXT", (GLvoid *) NAME(glCopyTexSubImage1DEXT), _gloffset_CopyTexSubImage1D }, + { "glCopyTexSubImage2DEXT", (GLvoid *) NAME(glCopyTexSubImage2DEXT), _gloffset_CopyTexSubImage2D }, #undef NAME /* 11. GL_EXT_histogram */ @@ -1100,16 +1098,16 @@ static struct name_address_pair static_functions[] = { #else #define NAME(X) NotImplemented #endif - { "glGetHistogramEXT", (GLvoid *) NAME(glGetHistogramEXT) }, - { "glGetHistogramParameterfvEXT", (GLvoid *) NAME(glGetHistogramParameterfvEXT) }, - { "glGetHistogramParameterivEXT", (GLvoid *) NAME(glGetHistogramParameterivEXT) }, - { "glGetMinmaxEXT", (GLvoid *) NAME(glGetMinmaxEXT) }, - { "glGetMinmaxParameterfvEXT", (GLvoid *) NAME(glGetMinmaxParameterfvEXT) }, - { "glGetMinmaxParameterivEXT", (GLvoid *) NAME(glGetMinmaxParameterivEXT) }, - { "glHistogramEXT", (GLvoid *) NAME(glHistogramEXT) }, - { "glMinmaxEXT", (GLvoid *) NAME(glMinmaxEXT) }, - { "glResetHistogramEXT", (GLvoid *) NAME(glResetHistogramEXT) }, - { "glResetMinmaxEXT", (GLvoid *) NAME(glResetMinmaxEXT) }, + { "glGetHistogramEXT", (GLvoid *) NAME(glGetHistogramEXT), _gloffset_GetHistogramEXT }, + { "glGetHistogramParameterfvEXT", (GLvoid *) NAME(glGetHistogramParameterfvEXT), _gloffset_GetHistogramParameterfvEXT }, + { "glGetHistogramParameterivEXT", (GLvoid *) NAME(glGetHistogramParameterivEXT), _gloffset_GetHistogramParameterivEXT }, + { "glGetMinmaxEXT", (GLvoid *) NAME(glGetMinmaxEXT), _gloffset_GetMinmaxEXT }, + { "glGetMinmaxParameterfvEXT", (GLvoid *) NAME(glGetMinmaxParameterfvEXT), _gloffset_GetMinmaxParameterfvEXT }, + { "glGetMinmaxParameterivEXT", (GLvoid *) NAME(glGetMinmaxParameterivEXT), _gloffset_GetMinmaxParameterivEXT }, + { "glHistogramEXT", (GLvoid *) NAME(glHistogramEXT), _gloffset_Histogram }, + { "glMinmaxEXT", (GLvoid *) NAME(glMinmaxEXT), _gloffset_Minmax }, + { "glResetHistogramEXT", (GLvoid *) NAME(glResetHistogramEXT), _gloffset_ResetHistogram }, + { "glResetMinmaxEXT", (GLvoid *) NAME(glResetMinmaxEXT), _gloffset_ResetMinmax }, #undef NAME /* 12. GL_EXT_convolution */ @@ -1118,19 +1116,19 @@ static struct name_address_pair static_functions[] = { #else #define NAME(X) NotImplemented #endif - { "glConvolutionFilter1DEXT", (GLvoid *) NAME(glConvolutionFilter1DEXT) }, - { "glConvolutionFilter2DEXT", (GLvoid *) NAME(glConvolutionFilter2DEXT) }, - { "glConvolutionParameterfEXT", (GLvoid *) NAME(glConvolutionParameterfEXT) }, - { "glConvolutionParameterfvEXT", (GLvoid *) NAME(glConvolutionParameterfvEXT) }, - { "glConvolutionParameteriEXT", (GLvoid *) NAME(glConvolutionParameteriEXT) }, - { "glConvolutionParameterivEXT", (GLvoid *) NAME(glConvolutionParameterivEXT) }, - { "glCopyConvolutionFilter1DEXT", (GLvoid *) NAME(glCopyConvolutionFilter1DEXT) }, - { "glCopyConvolutionFilter2DEXT", (GLvoid *) NAME(glCopyConvolutionFilter2DEXT) }, - { "glGetConvolutionFilterEXT", (GLvoid *) NAME(glGetConvolutionFilterEXT) }, - { "glGetConvolutionParameterivEXT", (GLvoid *) NAME(glGetConvolutionParameterivEXT) }, - { "glGetConvolutionParameterfvEXT", (GLvoid *) NAME(glGetConvolutionParameterfvEXT) }, - { "glGetSeparableFilterEXT", (GLvoid *) NAME(glGetSeparableFilterEXT) }, - { "glSeparableFilter2DEXT", (GLvoid *) NAME(glSeparableFilter2DEXT) }, + { "glConvolutionFilter1DEXT", (GLvoid *) NAME(glConvolutionFilter1DEXT), _gloffset_ConvolutionFilter1D }, + { "glConvolutionFilter2DEXT", (GLvoid *) NAME(glConvolutionFilter2DEXT), _gloffset_ConvolutionFilter2D }, + { "glConvolutionParameterfEXT", (GLvoid *) NAME(glConvolutionParameterfEXT), _gloffset_ConvolutionParameterf }, + { "glConvolutionParameterfvEXT", (GLvoid *) NAME(glConvolutionParameterfvEXT), _gloffset_ConvolutionParameterfv }, + { "glConvolutionParameteriEXT", (GLvoid *) NAME(glConvolutionParameteriEXT), _gloffset_ConvolutionParameteri }, + { "glConvolutionParameterivEXT", (GLvoid *) NAME(glConvolutionParameterivEXT), _gloffset_ConvolutionParameteriv }, + { "glCopyConvolutionFilter1DEXT", (GLvoid *) NAME(glCopyConvolutionFilter1DEXT), _gloffset_CopyConvolutionFilter1D }, + { "glCopyConvolutionFilter2DEXT", (GLvoid *) NAME(glCopyConvolutionFilter2DEXT), _gloffset_CopyConvolutionFilter2D }, + { "glGetConvolutionFilterEXT", (GLvoid *) NAME(glGetConvolutionFilterEXT), _gloffset_GetConvolutionFilterEXT }, + { "glGetConvolutionParameterivEXT", (GLvoid *) NAME(glGetConvolutionParameterivEXT), _gloffset_GetConvolutionParameterivEXT }, + { "glGetConvolutionParameterfvEXT", (GLvoid *) NAME(glGetConvolutionParameterfvEXT), _gloffset_GetConvolutionParameterfvEXT }, + { "glGetSeparableFilterEXT", (GLvoid *) NAME(glGetSeparableFilterEXT), _gloffset_GetSeparableFilterEXT }, + { "glSeparableFilter2DEXT", (GLvoid *) NAME(glSeparableFilter2DEXT), _gloffset_SeparableFilter2D }, #undef NAME /* 14. GL_SGI_color_table */ @@ -1139,13 +1137,13 @@ static struct name_address_pair static_functions[] = { #else #define NAME(X) NotImplemented #endif - { "glColorTableSGI", (GLvoid *) NAME(glColorTableSGI) }, - { "glColorTableParameterfvSGI", (GLvoid *) NAME(glColorTableParameterfvSGI) }, - { "glColorTableParameterivSGI", (GLvoid *) NAME(glColorTableParameterivSGI) }, - { "glCopyColorTableSGI", (GLvoid *) NAME(glCopyColorTableSGI) }, - { "glGetColorTableSGI", (GLvoid *) NAME(glGetColorTableSGI) }, - { "glGetColorTableParameterfvSGI", (GLvoid *) NAME(glGetColorTableParameterfvSGI) }, - { "glGetColorTableParameterivSGI", (GLvoid *) NAME(glGetColorTableParameterivSGI) }, + { "glColorTableSGI", (GLvoid *) NAME(glColorTableSGI), _gloffset_ColorTable }, + { "glColorTableParameterfvSGI", (GLvoid *) NAME(glColorTableParameterfvSGI), _gloffset_ColorTableParameterfv }, + { "glColorTableParameterivSGI", (GLvoid *) NAME(glColorTableParameterivSGI), _gloffset_ColorTableParameteriv }, + { "glCopyColorTableSGI", (GLvoid *) NAME(glCopyColorTableSGI), _gloffset_CopyColorTable }, + { "glGetColorTableSGI", (GLvoid *) NAME(glGetColorTableSGI), _gloffset_GetColorTableSGI }, + { "glGetColorTableParameterfvSGI", (GLvoid *) NAME(glGetColorTableParameterfvSGI), _gloffset_GetColorTableParameterfvSGI }, + { "glGetColorTableParameterivSGI", (GLvoid *) NAME(glGetColorTableParameterivSGI), _gloffset_GetColorTableParameterivSGI }, #undef NAME /* 15. GL_SGIS_pixel_texture */ @@ -1154,10 +1152,10 @@ static struct name_address_pair static_functions[] = { #else #define NAME(X) NotImplemented #endif - { "glPixelTexGenParameterfSGIS", (GLvoid *) NAME(glPixelTexGenParameterfSGIS) }, - { "glPixelTexGenParameteriSGIS", (GLvoid *) NAME(glPixelTexGenParameteriSGIS) }, - { "glGetPixelTexGenParameterfvSGIS", (GLvoid *) NAME(glGetPixelTexGenParameterfvSGIS) }, - { "glGetPixelTexGenParameterivSGIS", (GLvoid *) NAME(glGetPixelTexGenParameterivSGIS) }, + { "glPixelTexGenParameterfSGIS", (GLvoid *) NAME(glPixelTexGenParameterfSGIS), _gloffset_PixelTexGenParameterfSGIS }, + { "glPixelTexGenParameteriSGIS", (GLvoid *) NAME(glPixelTexGenParameteriSGIS), _gloffset_PixelTexGenParameteriSGIS }, + { "glGetPixelTexGenParameterfvSGIS", (GLvoid *) NAME(glGetPixelTexGenParameterfvSGIS), _gloffset_GetPixelTexGenParameterfvSGIS }, + { "glGetPixelTexGenParameterivSGIS", (GLvoid *) NAME(glGetPixelTexGenParameterivSGIS), _gloffset_GetPixelTexGenParameterivSGIS }, #undef NAME /* 16. GL_SGIS_texture4D */ @@ -1166,8 +1164,8 @@ static struct name_address_pair static_functions[] = { #else #define NAME(X) NotImplemented #endif - { "glTexImage4DSGIS", (GLvoid *) NAME(glTexImage4DSGIS) }, - { "glTexSubImage4DSGIS", (GLvoid *) NAME(glTexSubImage4DSGIS) }, + { "glTexImage4DSGIS", (GLvoid *) NAME(glTexImage4DSGIS), _gloffset_TexImage4DSGIS }, + { "glTexSubImage4DSGIS", (GLvoid *) NAME(glTexSubImage4DSGIS), _gloffset_TexSubImage4DSGIS }, #undef NAME /* 20. GL_EXT_texture_object */ @@ -1176,12 +1174,12 @@ static struct name_address_pair static_functions[] = { #else #define NAME(X) NotImplemented #endif - { "glAreTexturesResidentEXT", (GLvoid *) NAME(glAreTexturesResidentEXT) }, - { "glBindTextureEXT", (GLvoid *) NAME(glBindTextureEXT) }, - { "glDeleteTexturesEXT", (GLvoid *) NAME(glDeleteTexturesEXT) }, - { "glGenTexturesEXT", (GLvoid *) NAME(glGenTexturesEXT) }, - { "glIsTextureEXT", (GLvoid *) NAME(glIsTextureEXT) }, - { "glPrioritizeTexturesEXT", (GLvoid *) NAME(glPrioritizeTexturesEXT) }, + { "glAreTexturesResidentEXT", (GLvoid *) NAME(glAreTexturesResidentEXT), _gloffset_AreTexturesResidentEXT }, + { "glBindTextureEXT", (GLvoid *) NAME(glBindTextureEXT), _gloffset_BindTexture }, + { "glDeleteTexturesEXT", (GLvoid *) NAME(glDeleteTexturesEXT), _gloffset_DeleteTextures }, + { "glGenTexturesEXT", (GLvoid *) NAME(glGenTexturesEXT), _gloffset_GenTexturesEXT }, + { "glIsTextureEXT", (GLvoid *) NAME(glIsTextureEXT), _gloffset_IsTextureEXT }, + { "glPrioritizeTexturesEXT", (GLvoid *) NAME(glPrioritizeTexturesEXT), _gloffset_PrioritizeTextures }, #undef NAME /* 21. GL_SGIS_detail_texture */ @@ -1190,8 +1188,8 @@ static struct name_address_pair static_functions[] = { #else #define NAME(X) NotImplemented #endif - { "glDetailTexFuncSGIS", (GLvoid *) NAME(glDetailTexFuncSGIS) }, - { "glGetDetailTexFuncSGIS", (GLvoid *) NAME(glGetDetailTexFuncSGIS) }, + { "glDetailTexFuncSGIS", (GLvoid *) NAME(glDetailTexFuncSGIS), _gloffset_DetailTexFuncSGIS }, + { "glGetDetailTexFuncSGIS", (GLvoid *) NAME(glGetDetailTexFuncSGIS), _gloffset_GetDetailTexFuncSGIS }, #undef NAME /* 22. GL_SGIS_sharpen_texture */ @@ -1200,8 +1198,8 @@ static struct name_address_pair static_functions[] = { #else #define NAME(X) NotImplemented #endif - { "glGetSharpenTexFuncSGIS", (GLvoid *) NAME(glGetSharpenTexFuncSGIS) }, - { "glSharpenTexFuncSGIS", (GLvoid *) NAME(glSharpenTexFuncSGIS) }, + { "glGetSharpenTexFuncSGIS", (GLvoid *) NAME(glGetSharpenTexFuncSGIS), _gloffset_GetSharpenTexFuncSGIS }, + { "glSharpenTexFuncSGIS", (GLvoid *) NAME(glSharpenTexFuncSGIS), _gloffset_SharpenTexFuncSGIS }, #undef NAME /* 25. GL_SGIS_multisample */ @@ -1210,8 +1208,8 @@ static struct name_address_pair static_functions[] = { #else #define NAME(X) NotImplemented #endif - { "glSampleMaskSGIS", (GLvoid *) NAME(glSampleMaskSGIS) }, - { "glSamplePatternSGIS", (GLvoid *) NAME(glSamplePatternSGIS) }, + { "glSampleMaskSGIS", (GLvoid *) NAME(glSampleMaskSGIS), _gloffset_SampleMaskSGIS }, + { "glSamplePatternSGIS", (GLvoid *) NAME(glSamplePatternSGIS), _gloffset_SamplePatternSGIS }, #undef NAME /* 30. GL_EXT_vertex_array */ @@ -1220,15 +1218,15 @@ static struct name_address_pair static_functions[] = { #else #define NAME(X) NotImplemented #endif - { "glArrayElementEXT", (GLvoid *) NAME(glArrayElementEXT) }, - { "glColorPointerEXT", (GLvoid *) NAME(glColorPointerEXT) }, - { "glDrawArraysEXT", (GLvoid *) NAME(glDrawArraysEXT) }, - { "glEdgeFlagPointerEXT", (GLvoid *) NAME(glEdgeFlagPointerEXT) }, - { "glGetPointervEXT", (GLvoid *) NAME(glGetPointervEXT) }, - { "glIndexPointerEXT", (GLvoid *) NAME(glIndexPointerEXT) }, - { "glNormalPointerEXT", (GLvoid *) NAME(glNormalPointerEXT) }, - { "glTexCoordPointerEXT", (GLvoid *) NAME(glTexCoordPointerEXT) }, - { "glVertexPointerEXT", (GLvoid *) NAME(glVertexPointerEXT) }, + { "glArrayElementEXT", (GLvoid *) NAME(glArrayElementEXT), _gloffset_ArrayElement }, + { "glColorPointerEXT", (GLvoid *) NAME(glColorPointerEXT), _gloffset_ColorPointerEXT }, + { "glDrawArraysEXT", (GLvoid *) NAME(glDrawArraysEXT), _gloffset_DrawArrays }, + { "glEdgeFlagPointerEXT", (GLvoid *) NAME(glEdgeFlagPointerEXT), _gloffset_EdgeFlagPointerEXT }, + { "glGetPointervEXT", (GLvoid *) NAME(glGetPointervEXT), _gloffset_GetPointerv }, + { "glIndexPointerEXT", (GLvoid *) NAME(glIndexPointerEXT), _gloffset_IndexPointerEXT }, + { "glNormalPointerEXT", (GLvoid *) NAME(glNormalPointerEXT), _gloffset_NormalPointerEXT }, + { "glTexCoordPointerEXT", (GLvoid *) NAME(glTexCoordPointerEXT), _gloffset_TexCoordPointerEXT }, + { "glVertexPointerEXT", (GLvoid *) NAME(glVertexPointerEXT), _gloffset_VertexPointerEXT }, #undef NAME /* 37. GL_EXT_blend_minmax */ @@ -1237,7 +1235,7 @@ static struct name_address_pair static_functions[] = { #else #define NAME(X) NotImplemented #endif - { "glBlendEquationEXT", (GLvoid *) NAME(glBlendEquationEXT) }, + { "glBlendEquationEXT", (GLvoid *) NAME(glBlendEquationEXT), _gloffset_BlendEquation }, #undef NAME /* 52. GL_SGIX_sprite */ @@ -1246,10 +1244,10 @@ static struct name_address_pair static_functions[] = { #else #define NAME(X) NotImplemented #endif - { "glSpriteParameterfSGIX", (GLvoid *) NAME(glSpriteParameterfSGIX) }, - { "glSpriteParameterfvSGIX", (GLvoid *) NAME(glSpriteParameterfvSGIX) }, - { "glSpriteParameteriSGIX", (GLvoid *) NAME(glSpriteParameteriSGIX) }, - { "glSpriteParameterivSGIX", (GLvoid *) NAME(glSpriteParameterivSGIX) }, + { "glSpriteParameterfSGIX", (GLvoid *) NAME(glSpriteParameterfSGIX), _gloffset_SpriteParameterfSGIX }, + { "glSpriteParameterfvSGIX", (GLvoid *) NAME(glSpriteParameterfvSGIX), _gloffset_SpriteParameterfvSGIX }, + { "glSpriteParameteriSGIX", (GLvoid *) NAME(glSpriteParameteriSGIX), _gloffset_SpriteParameteriSGIX }, + { "glSpriteParameterivSGIX", (GLvoid *) NAME(glSpriteParameterivSGIX), _gloffset_SpriteParameterivSGIX }, #undef NAME /* 54. GL_EXT_point_parameters */ @@ -1258,8 +1256,8 @@ static struct name_address_pair static_functions[] = { #else #define NAME(X) NotImplemented #endif - { "glPointParameterfEXT", (GLvoid *) NAME(glPointParameterfEXT) }, - { "glPointParameterfvEXT", (GLvoid *) NAME(glPointParameterfvEXT) }, + { "glPointParameterfEXT", (GLvoid *) NAME(glPointParameterfEXT), _gloffset_PointParameterfEXT }, + { "glPointParameterfvEXT", (GLvoid *) NAME(glPointParameterfvEXT), _gloffset_PointParameterfvEXT }, #undef NAME /* 55. GL_SGIX_instruments */ @@ -1268,12 +1266,12 @@ static struct name_address_pair static_functions[] = { #else #define NAME(X) NotImplemented #endif - { "glInstrumentsBufferSGIX", (GLvoid *) NAME(glInstrumentsBufferSGIX) }, - { "glStartInstrumentsSGIX", (GLvoid *) NAME(glStartInstrumentsSGIX) }, - { "glStopInstrumentsSGIX", (GLvoid *) NAME(glStopInstrumentsSGIX) }, - { "glReadInstrumentsSGIX", (GLvoid *) NAME(glReadInstrumentsSGIX) }, - { "glPollInstrumentsSGIX", (GLvoid *) NAME(glPollInstrumentsSGIX) }, - { "glGetInstrumentsSGIX", (GLvoid *) NAME(glGetInstrumentsSGIX) }, + { "glInstrumentsBufferSGIX", (GLvoid *) NAME(glInstrumentsBufferSGIX), _gloffset_InstrumentsBufferSGIX }, + { "glStartInstrumentsSGIX", (GLvoid *) NAME(glStartInstrumentsSGIX), _gloffset_StartInstrumentsSGIX }, + { "glStopInstrumentsSGIX", (GLvoid *) NAME(glStopInstrumentsSGIX), _gloffset_StopInstrumentsSGIX }, + { "glReadInstrumentsSGIX", (GLvoid *) NAME(glReadInstrumentsSGIX), _gloffset_ReadInstrumentsSGIX }, + { "glPollInstrumentsSGIX", (GLvoid *) NAME(glPollInstrumentsSGIX), _gloffset_PollInstrumentsSGIX }, + { "glGetInstrumentsSGIX", (GLvoid *) NAME(glGetInstrumentsSGIX), _gloffset_GetInstrumentsSGIX }, #undef NAME /* 57. GL_SGIX_framezoom */ @@ -1282,7 +1280,16 @@ static struct name_address_pair static_functions[] = { #else #define NAME(X) NotImplemented #endif - { "glFrameZoomSGIX", (GLvoid *) NAME(glFrameZoomSGIX) }, + { "glFrameZoomSGIX", (GLvoid *) NAME(glFrameZoomSGIX), _gloffset_FrameZoomSGIX }, +#undef NAME + + /* 58. GL_SGIX_tag_sample_buffer */ +#ifdef GL_SGIX_tag_sample_buffer +#define NAME(X) X +#else +#define NAME(X) NotImplemented +#endif + { "glTagSampleBufferSGIX", (GLvoid *) NAME(glTagSampleBufferSGIX), _gloffset_TagSampleBufferSGIX }, #undef NAME /* 60. GL_SGIX_reference_plane */ @@ -1291,7 +1298,7 @@ static struct name_address_pair static_functions[] = { #else #define NAME(X) NotImplemented #endif - { "glReferencePlaneSGIX", (GLvoid *) NAME(glReferencePlaneSGIX) }, + { "glReferencePlaneSGIX", (GLvoid *) NAME(glReferencePlaneSGIX), _gloffset_ReferencePlaneSGIX }, #undef NAME /* 61. GL_SGIX_flush_raster */ @@ -1300,22 +1307,24 @@ static struct name_address_pair static_functions[] = { #else #define NAME(X) NotImplemented #endif - { "glFlushRasterSGIX", (GLvoid *) NAME(glFlushRasterSGIX) }, + { "glFlushRasterSGIX", (GLvoid *) NAME(glFlushRasterSGIX), _gloffset_FlushRasterSGIX }, #undef NAME /* 66. GL_HP_image_transform */ +#if 0 #ifdef GL_HP_image_transform #define NAME(X) X #else #define NAME(X) NotImplemented #endif - { "glGetImageTransformParameterfvHP", (GLvoid *) NAME(glGetImageTransformParameterfvHP) }, - { "glGetImageTransformParameterivHP", (GLvoid *) NAME(glGetImageTransformParameterivHP) }, - { "glImageTransformParameterfHP", (GLvoid *) NAME(glImageTransformParameterfHP) }, - { "glImageTransformParameterfvHP", (GLvoid *) NAME(glImageTransformParameterfvHP) }, - { "glImageTransformParameteriHP", (GLvoid *) NAME(glImageTransformParameteriHP) }, - { "glImageTransformParameterivHP", (GLvoid *) NAME(glImageTransformParameterivHP) }, + { "glGetImageTransformParameterfvHP", (GLvoid *) NAME(glGetImageTransformParameterfvHP), _gloffset_GetImageTransformParameterfvHP }, + { "glGetImageTransformParameterivHP", (GLvoid *) NAME(glGetImageTransformParameterivHP), _gloffset_GetImageTransformParameterivHP }, + { "glImageTransformParameterfHP", (GLvoid *) NAME(glImageTransformParameterfHP), _gloffset_ImageTransformParameterfHP }, + { "glImageTransformParameterfvHP", (GLvoid *) NAME(glImageTransformParameterfvHP), _gloffset_ImageTransformParameterfvHP }, + { "glImageTransformParameteriHP", (GLvoid *) NAME(glImageTransformParameteriHP), _gloffset_ImageTransformParameteriHP }, + { "glImageTransformParameterivHP", (GLvoid *) NAME(glImageTransformParameterivHP), _gloffset_ImageTransformParameterivHP }, #undef NAME +#endif /* 74. GL_EXT_color_subtable */ #ifdef GL_EXT_color_subtable @@ -1323,8 +1332,8 @@ static struct name_address_pair static_functions[] = { #else #define NAME(X) NotImplemented #endif - { "glColorSubTableEXT", (GLvoid *) NAME(glColorSubTableEXT) }, - { "glCopyColorSubTableEXT", (GLvoid *) NAME(glCopyColorSubTableEXT) }, + { "glColorSubTableEXT", (GLvoid *) NAME(glColorSubTableEXT), _gloffset_ColorSubTable }, + { "glCopyColorSubTableEXT", (GLvoid *) NAME(glCopyColorSubTableEXT), _gloffset_CopyColorSubTable }, #undef NAME /* 77. GL_PGI_misc_hints */ @@ -1333,7 +1342,7 @@ static struct name_address_pair static_functions[] = { #else #define NAME(X) NotImplemented #endif - { "glHintPGI", (GLvoid *) NAME(glHintPGI) }, + { "glHintPGI", (GLvoid *) NAME(glHintPGI), _gloffset_HintPGI }, #undef NAME /* 78. GL_EXT_paletted_texture */ @@ -1342,10 +1351,10 @@ static struct name_address_pair static_functions[] = { #else #define NAME(X) NotImplemented #endif - { "glColorTableEXT", (GLvoid *) NAME(glColorTableEXT) }, - { "glGetColorTableEXT", (GLvoid *) NAME(glGetColorTableEXT) }, - { "glGetColorTableParameterfvEXT", (GLvoid *) NAME(glGetColorTableParameterfvEXT) }, - { "glGetColorTableParameterivEXT", (GLvoid *) NAME(glGetColorTableParameterivEXT) }, + { "glColorTableEXT", (GLvoid *) NAME(glColorTableEXT), _gloffset_ColorTable }, + { "glGetColorTableEXT", (GLvoid *) NAME(glGetColorTableEXT), _gloffset_GetColorTable }, + { "glGetColorTableParameterfvEXT", (GLvoid *) NAME(glGetColorTableParameterfvEXT), _gloffset_GetColorTableParameterfv }, + { "glGetColorTableParameterivEXT", (GLvoid *) NAME(glGetColorTableParameterivEXT), _gloffset_GetColorTableParameteriv }, #undef NAME /* 80. GL_SGIX_list_priority */ @@ -1354,12 +1363,12 @@ static struct name_address_pair static_functions[] = { #else #define NAME(X) NotImplemented #endif - { "glGetListParameterfvSGIX", (GLvoid *) NAME(glGetListParameterfvSGIX) }, - { "glGetListParameterivSGIX", (GLvoid *) NAME(glGetListParameterivSGIX) }, - { "glListParameterfSGIX", (GLvoid *) NAME(glListParameterfSGIX) }, - { "glListParameterfvSGIX", (GLvoid *) NAME(glListParameterfvSGIX) }, - { "glListParameteriSGIX", (GLvoid *) NAME(glListParameteriSGIX) }, - { "glListParameterivSGIX", (GLvoid *) NAME(glListParameterivSGIX) }, + { "glGetListParameterfvSGIX", (GLvoid *) NAME(glGetListParameterfvSGIX), _gloffset_GetListParameterfvSGIX }, + { "glGetListParameterivSGIX", (GLvoid *) NAME(glGetListParameterivSGIX), _gloffset_GetListParameterivSGIX }, + { "glListParameterfSGIX", (GLvoid *) NAME(glListParameterfSGIX), _gloffset_ListParameterfSGIX }, + { "glListParameterfvSGIX", (GLvoid *) NAME(glListParameterfvSGIX), _gloffset_ListParameterfvSGIX }, + { "glListParameteriSGIX", (GLvoid *) NAME(glListParameteriSGIX), _gloffset_ListParameteriSGIX }, + { "glListParameterivSGIX", (GLvoid *) NAME(glListParameterivSGIX), _gloffset_ListParameterivSGIX }, #undef NAME /* 94. GL_EXT_index_material */ @@ -1368,7 +1377,7 @@ static struct name_address_pair static_functions[] = { #else #define NAME(X) NotImplemented #endif - { "glIndexMaterialEXT", (GLvoid *) NAME(glIndexMaterialEXT) }, + { "glIndexMaterialEXT", (GLvoid *) NAME(glIndexMaterialEXT), _gloffset_IndexMaterialEXT }, #undef NAME /* 95. GL_EXT_index_func */ @@ -1377,7 +1386,7 @@ static struct name_address_pair static_functions[] = { #else #define NAME(X) NotImplemented #endif - { "glIndexFuncEXT", (GLvoid *) NAME(glIndexFuncEXT) }, + { "glIndexFuncEXT", (GLvoid *) NAME(glIndexFuncEXT), _gloffset_IndexFuncEXT }, #undef NAME /* 97. GL_EXT_compiled_vertex_array */ @@ -1386,8 +1395,8 @@ static struct name_address_pair static_functions[] = { #else #define NAME(X) NotImplemented #endif - { "glLockArraysEXT", (GLvoid *) NAME(glLockArraysEXT) }, - { "glUnlockArraysEXT", (GLvoid *) NAME(glUnlockArraysEXT) }, + { "glLockArraysEXT", (GLvoid *) NAME(glLockArraysEXT), _gloffset_LockArraysEXT }, + { "glUnlockArraysEXT", (GLvoid *) NAME(glUnlockArraysEXT), _gloffset_UnlockArraysEXT }, #undef NAME /* 98. GL_EXT_cull_vertex */ @@ -1396,52 +1405,119 @@ static struct name_address_pair static_functions[] = { #else #define NAME(X) NotImplemented #endif - { "glCullParameterfvEXT", (GLvoid *) NAME(glCullParameterfvEXT) }, - { "glCullParameterdvEXT", (GLvoid *) NAME(glCullParameterdvEXT) }, + { "glCullParameterfvEXT", (GLvoid *) NAME(glCullParameterfvEXT), _gloffset_CullParameterfvEXT }, + { "glCullParameterdvEXT", (GLvoid *) NAME(glCullParameterdvEXT), _gloffset_CullParameterdvEXT }, +#undef NAME + + /* 102. GL_SGIX_fragment_lighting */ +#ifdef GL_SGIX_fragment_lighting +#define NAME(X) X +#else +#define NAME(X) NotImplemented +#endif + { "glFragmentColorMaterialSGIX", (GLvoid *) NAME(glFragmentColorMaterialSGIX), _gloffset_FragmentColorMaterialSGIX }, + { "glFragmentLightfSGIX", (GLvoid *) NAME(glFragmentLightfSGIX), _gloffset_FragmentLightfSGIX }, + { "glFragmentLightfvSGIX", (GLvoid *) NAME(glFragmentLightfvSGIX), _gloffset_FragmentLightfvSGIX }, + { "glFragmentLightiSGIX", (GLvoid *) NAME(glFragmentLightiSGIX), _gloffset_FragmentLightiSGIX }, + { "glFragmentLightivSGIX", (GLvoid *) NAME(glFragmentLightivSGIX), _gloffset_FragmentLightivSGIX }, + { "glFragmentLightModelfSGIX", (GLvoid *) NAME(glFragmentLightModelfSGIX), _gloffset_FragmentLightModelfSGIX }, + { "glFragmentLightModelfvSGIX", (GLvoid *) NAME(glFragmentLightModelfvSGIX), _gloffset_FragmentLightModelfvSGIX }, + { "glFragmentLightModeliSGIX", (GLvoid *) NAME(glFragmentLightModeliSGIX), _gloffset_FragmentLightModeliSGIX }, + { "glFragmentLightModelivSGIX", (GLvoid *) NAME(glFragmentLightModelivSGIX), _gloffset_FragmentLightModelivSGIX }, + { "glFragmentMaterialfSGIX", (GLvoid *) NAME(glFragmentMaterialfSGIX), _gloffset_FragmentMaterialfSGIX }, + { "glFragmentMaterialfvSGIX", (GLvoid *) NAME(glFragmentMaterialfvSGIX), _gloffset_FragmentMaterialfvSGIX }, + { "glFragmentMaterialiSGIX", (GLvoid *) NAME(glFragmentMaterialiSGIX), _gloffset_FragmentMaterialiSGIX }, + { "glFragmentMaterialivSGIX", (GLvoid *) NAME(glFragmentMaterialivSGIX), _gloffset_FragmentMaterialivSGIX }, + { "glGetFragmentLightfvSGIX", (GLvoid *) NAME(glGetFragmentLightfvSGIX), _gloffset_GetFragmentLightfvSGIX }, + { "glGetFragmentLightivSGIX", (GLvoid *) NAME(glGetFragmentLightivSGIX), _gloffset_GetFragmentLightivSGIX }, + { "glGetFragmentMaterialfvSGIX", (GLvoid *) NAME(glGetFragmentMaterialfvSGIX), _gloffset_GetFragmentMaterialfvSGIX }, + { "glGetFragmentMaterialivSGIX", (GLvoid *) NAME(glGetFragmentMaterialivSGIX), _gloffset_GetFragmentMaterialivSGIX }, + { "glLightEnviSGIX", (GLvoid *) NAME(glLightEnviSGIX), _gloffset_LightEnviSGIX }, +#undef NAME + + /* 149. GL_EXT_fog_coord */ +#ifdef GL_EXT_fog_coord +#define NAME(X) X +#else +#define NAME(X) NotImplemented +#endif + { "glFogCoordfEXT", (GLvoid *) NAME(glFogCoordfEXT), _gloffset_FogCoordfEXT }, + { "glFogCoordfvEXT", (GLvoid *) NAME(glFogCoordfvEXT), _gloffset_FogCoordfvEXT }, + { "glFogCoorddEXT", (GLvoid *) NAME(glFogCoorddEXT), _gloffset_FogCoorddEXT }, + { "glFogCoorddEXT", (GLvoid *) NAME(glFogCoorddEXT), _gloffset_FogCoorddEXT }, + { "glFogCoordPointerEXT", (GLvoid *) NAME(glFogCoordPointerEXT), _gloffset_FogCoordPointerEXT }, #undef NAME /* 173. GL_EXT/INGR_blend_func_separate */ -#ifdef GL_INGR_blend_func_separate +#ifdef GL_EXT_blend_func_separate #define NAME(X) X #else #define NAME(X) NotImplemented #endif - { "glBlendFuncSeparateINGR", (GLvoid *) NAME(glBlendFuncSeparateINGR) }, + { "glBlendFuncSeparateEXT", (GLvoid *) NAME(glBlendFuncSeparateEXT), _gloffset_BlendFuncSeparateEXT }, + { "glBlendFuncSeparateINGR", (GLvoid *) NAME(glBlendFuncSeparateEXT), _gloffset_BlendFuncSeparateEXT }, #undef NAME - /* GL_MESA_window_pos */ -#ifdef MESA_window_pos + /* 188. GL_EXT_vertex_weighting */ +#ifdef GL_EXT_vertex_weighting #define NAME(X) X #else #define NAME(X) NotImplemented #endif - { "glWindowPos4fMESA", (GLvoid *) NAME(glWindowPos4fMESA) }, + { "glVertexWeightfEXT", (GLvoid *) NAME(glVertexWeightfEXT), _gloffset_VertexWeightfEXT }, + { "glVertexWeightfvEXT", (GLvoid *) NAME(glVertexWeightfvEXT), _gloffset_VertexWeightfvEXT }, + { "glVertexWeightPointerEXT", (GLvoid *) NAME(glVertexWeightPointerEXT), _gloffset_VertexWeightPointerEXT }, #undef NAME - /* GL_MESA_resize_buffers */ + /* 190. GL_NV_vertex_array_range */ +#ifdef GL_NV_vertex_array_range +#define NAME(X) X +#else +#define NAME(X) NotImplemented +#endif + { "glFlushVertexArrayRangeNV", (GLvoid *) NAME(glFlushVertexArrayRangeNV), _gloffset_FlushVertexArrayRangeNV }, + { "glVertexArrayRangeNV", (GLvoid *) NAME(glVertexArrayRangeNV), _gloffset_VertexArrayRangeNV }, +#undef NAME + + /* 191. GL_NV_register_combiners */ +#ifdef GL_NV_register_combiners +#define NAME(X) X +#else +#define NAME(X) NotImplemented +#endif + { "glCombinerParameterfvNV", (GLvoid *) NAME(glCombinerParameterfvNV), _gloffset_CombinerParameterfvNV }, + { "glCombinerParameterfNV", (GLvoid *) NAME(glCombinerParameterfNV), _gloffset_CombinerParameterfNV }, + { "glCombinerParameterivNV", (GLvoid *) NAME(glCombinerParameterivNV), _gloffset_CombinerParameterivNV }, + { "glCombinerParameteriNV", (GLvoid *) NAME(glCombinerParameteriNV), _gloffset_CombinerParameteriNV }, + { "glCombinerInputNV", (GLvoid *) NAME(glCombinerInputNV), _gloffset_CombinerInputNV }, + { "glCombinerOutputNV", (GLvoid *) NAME(glCombinerOutputNV), _gloffset_CombinerOutputNV }, + { "glFinalCombinerInputNV", (GLvoid *) NAME(glFinalCombinerInputNV), _gloffset_FinalCombinerInputNV }, + { "glGetCombinerInputParameterfvNV", (GLvoid *) NAME(glGetCombinerInputParameterfvNV), _gloffset_GetCombinerInputParameterfvNV }, + { "glGetCombinerInputParameterivNV", (GLvoid *) NAME(glGetCombinerInputParameterivNV), _gloffset_GetCombinerInputParameterivNV }, + { "glGetCombinerOutputParameterfvNV", (GLvoid *) NAME(glGetCombinerOutputParameterfvNV), _gloffset_GetCombinerOutputParameterfvNV }, + { "glGetCombinerOutputParameterivNV", (GLvoid *) NAME(glGetCombinerOutputParameterivNV), _gloffset_GetCombinerOutputParameterivNV }, + { "glGetFinalCombinerInputParameterfvNV", (GLvoid *) NAME(glGetFinalCombinerInputParameterfvNV), _gloffset_GetFinalCombinerInputParameterfvNV }, + { "glGetFinalCombinerInputParameterivNV", (GLvoid *) NAME(glGetFinalCombinerInputParameterivNV), _gloffset_GetFinalCombinerInputParameterivNV }, +#undef NAME + + /* 196. GL_MESA_resize_buffers */ #ifdef MESA_resize_buffers #define NAME(X) X #else #define NAME(X) NotImplemented #endif - { "glResizeBuffersMESA", (GLvoid *) NAME(glResizeBuffersMESA) }, + { "glResizeBuffersMESA", (GLvoid *) NAME(glResizeBuffersMESA), _gloffset_ResizeBuffersMESA }, #undef NAME - /* GL_ARB_transpose_matrix */ -#ifdef GL_ARB_transpose_matrix + /* 197. GL_MESA_window_pos */ +#ifdef MESA_window_pos #define NAME(X) X #else #define NAME(X) NotImplemented #endif - { "glLoadTransposeMatrixdARB", (GLvoid *) NAME(glLoadTransposeMatrixdARB) }, - { "glLoadTransposeMatrixfARB", (GLvoid *) NAME(glLoadTransposeMatrixfARB) }, - { "glMultTransposeMatrixdARB", (GLvoid *) NAME(glMultTransposeMatrixdARB) }, - { "glMultTransposeMatrixfARB", (GLvoid *) NAME(glMultTransposeMatrixfARB) }, + { "glWindowPos4fMESA", (GLvoid *) NAME(glWindowPos4fMESA), _gloffset_WindowPos4fMESA }, #undef NAME - /* - * XXX many more extenstion functions to add. - */ { NULL, NULL } /* end of list marker */ }; diff --git a/xc/extras/Mesa/src/glapinoop.c b/xc/extras/Mesa/src/glapinoop.c index c22c1c933..a522e193e 100644 --- a/xc/extras/Mesa/src/glapinoop.c +++ b/xc/extras/Mesa/src/glapinoop.c @@ -80,648 +80,780 @@ warn(void) -static void Dummy(void) +static int +NoOpGeneric(void) { + if (warn()) { + fprintf(stderr, "GL User Error: calling extension function without a current context\n"); + } + return 0; } -struct _glapi_table __glapi_noop_table = { - Dummy, - NoOpAccum, - NoOpAlphaFunc, - NoOpBegin, - NoOpBitmap, - NoOpBlendFunc, - NoOpCallList, - NoOpCallLists, - NoOpClear, - NoOpClearAccum, - NoOpClearColor, - NoOpClearDepth, - NoOpClearIndex, - NoOpClearStencil, - NoOpClipPlane, - NoOpColor3b, - NoOpColor3bv, - NoOpColor3d, - NoOpColor3dv, - NoOpColor3f, - NoOpColor3fv, - NoOpColor3i, - NoOpColor3iv, - NoOpColor3s, - NoOpColor3sv, - NoOpColor3ub, - NoOpColor3ubv, - NoOpColor3ui, - NoOpColor3uiv, - NoOpColor3us, - NoOpColor3usv, - NoOpColor4b, - NoOpColor4bv, - NoOpColor4d, - NoOpColor4dv, - NoOpColor4f, - NoOpColor4fv, - NoOpColor4i, - NoOpColor4iv, - NoOpColor4s, - NoOpColor4sv, - NoOpColor4ub, - NoOpColor4ubv, - NoOpColor4ui, - NoOpColor4uiv, - NoOpColor4us, - NoOpColor4usv, - NoOpColorMask, - NoOpColorMaterial, - NoOpCopyPixels, - NoOpCullFace, - NoOpDeleteLists, - NoOpDepthFunc, - NoOpDepthMask, - NoOpDepthRange, - NoOpDisable, - NoOpDrawBuffer, - NoOpDrawPixels, - NoOpEdgeFlag, - NoOpEdgeFlagv, - NoOpEnable, - NoOpEnd, - NoOpEndList, - NoOpEvalCoord1d, - NoOpEvalCoord1dv, - NoOpEvalCoord1f, - NoOpEvalCoord1fv, - NoOpEvalCoord2d, - NoOpEvalCoord2dv, - NoOpEvalCoord2f, - NoOpEvalCoord2fv, - NoOpEvalMesh1, - NoOpEvalMesh2, - NoOpEvalPoint1, - NoOpEvalPoint2, - NoOpFeedbackBuffer, - NoOpFinish, - NoOpFlush, - NoOpFogf, - NoOpFogfv, - NoOpFogi, - NoOpFogiv, - NoOpFrontFace, - NoOpFrustum, - NoOpGenLists, - NoOpGetBooleanv, - NoOpGetClipPlane, - NoOpGetDoublev, - NoOpGetError, - NoOpGetFloatv, - NoOpGetIntegerv, - NoOpGetLightfv, - NoOpGetLightiv, - NoOpGetMapdv, - NoOpGetMapfv, - NoOpGetMapiv, - NoOpGetMaterialfv, - NoOpGetMaterialiv, - NoOpGetPixelMapfv, - NoOpGetPixelMapuiv, - NoOpGetPixelMapusv, - NoOpGetPolygonStipple, - NoOpGetString, - NoOpGetTexEnvfv, - NoOpGetTexEnviv, - NoOpGetTexGendv, - NoOpGetTexGenfv, - NoOpGetTexGeniv, - NoOpGetTexImage, - NoOpGetTexLevelParameterfv, - NoOpGetTexLevelParameteriv, - NoOpGetTexParameterfv, - NoOpGetTexParameteriv, - NoOpHint, - NoOpIndexMask, - NoOpIndexd, - NoOpIndexdv, - NoOpIndexf, - NoOpIndexfv, - NoOpIndexi, - NoOpIndexiv, - NoOpIndexs, - NoOpIndexsv, - NoOpInitNames, - NoOpIsEnabled, - NoOpIsList, - NoOpLightModelf, - NoOpLightModelfv, - NoOpLightModeli, - NoOpLightModeliv, - NoOpLightf, - NoOpLightfv, - NoOpLighti, - NoOpLightiv, - NoOpLineStipple, - NoOpLineWidth, - NoOpListBase, - NoOpLoadIdentity, - NoOpLoadMatrixd, - NoOpLoadMatrixf, - NoOpLoadName, - NoOpLogicOp, - NoOpMap1d, - NoOpMap1f, - NoOpMap2d, - NoOpMap2f, - NoOpMapGrid1d, - NoOpMapGrid1f, - NoOpMapGrid2d, - NoOpMapGrid2f, - NoOpMaterialf, - NoOpMaterialfv, - NoOpMateriali, - NoOpMaterialiv, - NoOpMatrixMode, - NoOpMultMatrixd, - NoOpMultMatrixf, - NoOpNewList, - NoOpNormal3b, - NoOpNormal3bv, - NoOpNormal3d, - NoOpNormal3dv, - NoOpNormal3f, - NoOpNormal3fv, - NoOpNormal3i, - NoOpNormal3iv, - NoOpNormal3s, - NoOpNormal3sv, - NoOpOrtho, - NoOpPassThrough, - NoOpPixelMapfv, - NoOpPixelMapuiv, - NoOpPixelMapusv, - NoOpPixelStoref, - NoOpPixelStorei, - NoOpPixelTransferf, - NoOpPixelTransferi, - NoOpPixelZoom, - NoOpPointSize, - NoOpPolygonMode, - NoOpPolygonOffset, - NoOpPolygonStipple, - NoOpPopAttrib, - NoOpPopMatrix, - NoOpPopName, - NoOpPushAttrib, - NoOpPushMatrix, - NoOpPushName, - NoOpRasterPos2d, - NoOpRasterPos2dv, - NoOpRasterPos2f, - NoOpRasterPos2fv, - NoOpRasterPos2i, - NoOpRasterPos2iv, - NoOpRasterPos2s, - NoOpRasterPos2sv, - NoOpRasterPos3d, - NoOpRasterPos3dv, - NoOpRasterPos3f, - NoOpRasterPos3fv, - NoOpRasterPos3i, - NoOpRasterPos3iv, - NoOpRasterPos3s, - NoOpRasterPos3sv, - NoOpRasterPos4d, - NoOpRasterPos4dv, - NoOpRasterPos4f, - NoOpRasterPos4fv, - NoOpRasterPos4i, - NoOpRasterPos4iv, - NoOpRasterPos4s, - NoOpRasterPos4sv, - NoOpReadBuffer, - NoOpReadPixels, - NoOpRectd, - NoOpRectdv, - NoOpRectf, - NoOpRectfv, - NoOpRecti, - NoOpRectiv, - NoOpRects, - NoOpRectsv, - NoOpRenderMode, - NoOpRotated, - NoOpRotatef, - NoOpScaled, - NoOpScalef, - NoOpScissor, - NoOpSelectBuffer, - NoOpShadeModel, - NoOpStencilFunc, - NoOpStencilMask, - NoOpStencilOp, - NoOpTexCoord1d, - NoOpTexCoord1dv, - NoOpTexCoord1f, - NoOpTexCoord1fv, - NoOpTexCoord1i, - NoOpTexCoord1iv, - NoOpTexCoord1s, - NoOpTexCoord1sv, - NoOpTexCoord2d, - NoOpTexCoord2dv, - NoOpTexCoord2f, - NoOpTexCoord2fv, - NoOpTexCoord2i, - NoOpTexCoord2iv, - NoOpTexCoord2s, - NoOpTexCoord2sv, - NoOpTexCoord3d, - NoOpTexCoord3dv, - NoOpTexCoord3f, - NoOpTexCoord3fv, - NoOpTexCoord3i, - NoOpTexCoord3iv, - NoOpTexCoord3s, - NoOpTexCoord3sv, - NoOpTexCoord4d, - NoOpTexCoord4dv, - NoOpTexCoord4f, - NoOpTexCoord4fv, - NoOpTexCoord4i, - NoOpTexCoord4iv, - NoOpTexCoord4s, - NoOpTexCoord4sv, - NoOpTexEnvf, - NoOpTexEnvfv, - NoOpTexEnvi, - NoOpTexEnviv, - NoOpTexGend, - NoOpTexGendv, - NoOpTexGenf, - NoOpTexGenfv, - NoOpTexGeni, - NoOpTexGeniv, - NoOpTexImage1D, - NoOpTexImage2D, - NoOpTexParameterf, - NoOpTexParameterfv, - NoOpTexParameteri, - NoOpTexParameteriv, - NoOpTranslated, - NoOpTranslatef, - NoOpVertex2d, - NoOpVertex2dv, - NoOpVertex2f, - NoOpVertex2fv, - NoOpVertex2i, - NoOpVertex2iv, - NoOpVertex2s, - NoOpVertex2sv, - NoOpVertex3d, - NoOpVertex3dv, - NoOpVertex3f, - NoOpVertex3fv, - NoOpVertex3i, - NoOpVertex3iv, - NoOpVertex3s, - NoOpVertex3sv, - NoOpVertex4d, - NoOpVertex4dv, - NoOpVertex4f, - NoOpVertex4fv, - NoOpVertex4i, - NoOpVertex4iv, - NoOpVertex4s, - NoOpVertex4sv, - NoOpViewport, - - /* GL 1.1 */ - NoOpAreTexturesResident, - NoOpArrayElement, - NoOpBindTexture, - NoOpColorPointer, - NoOpCopyTexImage1D, - NoOpCopyTexImage2D, - NoOpCopyTexSubImage1D, - NoOpCopyTexSubImage2D, - NoOpDeleteTextures, - NoOpDisableClientState, - NoOpDrawArrays, - NoOpDrawElements, - NoOpEdgeFlagPointer, - NoOpEnableClientState, - NoOpGenTextures, - NoOpGetPointerv, - NoOpIndexPointer, - NoOpIndexub, - NoOpIndexubv, - NoOpInterleavedArrays, - NoOpIsTexture, - NoOpNormalPointer, - NoOpPopClientAttrib, - NoOpPrioritizeTextures, - NoOpPushClientAttrib, - NoOpTexCoordPointer, - NoOpTexSubImage1D, - NoOpTexSubImage2D, - NoOpVertexPointer, - - /* GL 1.2 */ - NoOpCopyTexSubImage3D, - NoOpDrawRangeElements, - NoOpTexImage3D, - NoOpTexSubImage3D, - - /* GL_ARB_imaging */ - NoOpBlendColor, - NoOpBlendEquation, - NoOpColorSubTable, - NoOpColorTable, - NoOpColorTableParameterfv, - NoOpColorTableParameteriv, - NoOpConvolutionFilter1D, - NoOpConvolutionFilter2D, - NoOpConvolutionParameterf, - NoOpConvolutionParameterfv, - NoOpConvolutionParameteri, - NoOpConvolutionParameteriv, - NoOpCopyColorSubTable, - NoOpCopyColorTable, - NoOpCopyConvolutionFilter1D, - NoOpCopyConvolutionFilter2D, - NoOpGetColorTable, - NoOpGetColorTableParameterfv, - NoOpGetColorTableParameteriv, - NoOpGetConvolutionFilter, - NoOpGetConvolutionParameterfv, - NoOpGetConvolutionParameteriv, - NoOpGetHistogram, - NoOpGetHistogramParameterfv, - NoOpGetHistogramParameteriv, - NoOpGetMinmax, - NoOpGetMinmaxParameterfv, - NoOpGetMinmaxParameteriv, - NoOpGetSeparableFilter, - NoOpHistogram, - NoOpMinmax, - NoOpResetHistogram, - NoOpResetMinmax, - NoOpSeparableFilter2D, - +void *__glapi_noop_table[] = { + (void *) NoOpNewList, + (void *) NoOpEndList, + (void *) NoOpCallList, + (void *) NoOpCallLists, + (void *) NoOpDeleteLists, + (void *) NoOpGenLists, + (void *) NoOpListBase, + (void *) NoOpBegin, + (void *) NoOpBitmap, + (void *) NoOpColor3b, + (void *) NoOpColor3bv, + (void *) NoOpColor3d, + (void *) NoOpColor3dv, + (void *) NoOpColor3f, + (void *) NoOpColor3fv, + (void *) NoOpColor3i, + (void *) NoOpColor3iv, + (void *) NoOpColor3s, + (void *) NoOpColor3sv, + (void *) NoOpColor3ub, + (void *) NoOpColor3ubv, + (void *) NoOpColor3ui, + (void *) NoOpColor3uiv, + (void *) NoOpColor3us, + (void *) NoOpColor3usv, + (void *) NoOpColor4b, + (void *) NoOpColor4bv, + (void *) NoOpColor4d, + (void *) NoOpColor4dv, + (void *) NoOpColor4f, + (void *) NoOpColor4fv, + (void *) NoOpColor4i, + (void *) NoOpColor4iv, + (void *) NoOpColor4s, + (void *) NoOpColor4sv, + (void *) NoOpColor4ub, + (void *) NoOpColor4ubv, + (void *) NoOpColor4ui, + (void *) NoOpColor4uiv, + (void *) NoOpColor4us, + (void *) NoOpColor4usv, + (void *) NoOpEdgeFlag, + (void *) NoOpEdgeFlagv, + (void *) NoOpEnd, + (void *) NoOpIndexd, + (void *) NoOpIndexdv, + (void *) NoOpIndexf, + (void *) NoOpIndexfv, + (void *) NoOpIndexi, + (void *) NoOpIndexiv, + (void *) NoOpIndexs, + (void *) NoOpIndexsv, + (void *) NoOpNormal3b, + (void *) NoOpNormal3bv, + (void *) NoOpNormal3d, + (void *) NoOpNormal3dv, + (void *) NoOpNormal3f, + (void *) NoOpNormal3fv, + (void *) NoOpNormal3i, + (void *) NoOpNormal3iv, + (void *) NoOpNormal3s, + (void *) NoOpNormal3sv, + (void *) NoOpRasterPos2d, + (void *) NoOpRasterPos2dv, + (void *) NoOpRasterPos2f, + (void *) NoOpRasterPos2fv, + (void *) NoOpRasterPos2i, + (void *) NoOpRasterPos2iv, + (void *) NoOpRasterPos2s, + (void *) NoOpRasterPos2sv, + (void *) NoOpRasterPos3d, + (void *) NoOpRasterPos3dv, + (void *) NoOpRasterPos3f, + (void *) NoOpRasterPos3fv, + (void *) NoOpRasterPos3i, + (void *) NoOpRasterPos3iv, + (void *) NoOpRasterPos3s, + (void *) NoOpRasterPos3sv, + (void *) NoOpRasterPos4d, + (void *) NoOpRasterPos4dv, + (void *) NoOpRasterPos4f, + (void *) NoOpRasterPos4fv, + (void *) NoOpRasterPos4i, + (void *) NoOpRasterPos4iv, + (void *) NoOpRasterPos4s, + (void *) NoOpRasterPos4sv, + (void *) NoOpRectd, + (void *) NoOpRectdv, + (void *) NoOpRectf, + (void *) NoOpRectfv, + (void *) NoOpRecti, + (void *) NoOpRectiv, + (void *) NoOpRects, + (void *) NoOpRectsv, + (void *) NoOpTexCoord1d, + (void *) NoOpTexCoord1dv, + (void *) NoOpTexCoord1f, + (void *) NoOpTexCoord1fv, + (void *) NoOpTexCoord1i, + (void *) NoOpTexCoord1iv, + (void *) NoOpTexCoord1s, + (void *) NoOpTexCoord1sv, + (void *) NoOpTexCoord2d, + (void *) NoOpTexCoord2dv, + (void *) NoOpTexCoord2f, + (void *) NoOpTexCoord2fv, + (void *) NoOpTexCoord2i, + (void *) NoOpTexCoord2iv, + (void *) NoOpTexCoord2s, + (void *) NoOpTexCoord2sv, + (void *) NoOpTexCoord3d, + (void *) NoOpTexCoord3dv, + (void *) NoOpTexCoord3f, + (void *) NoOpTexCoord3fv, + (void *) NoOpTexCoord3i, + (void *) NoOpTexCoord3iv, + (void *) NoOpTexCoord3s, + (void *) NoOpTexCoord3sv, + (void *) NoOpTexCoord4d, + (void *) NoOpTexCoord4dv, + (void *) NoOpTexCoord4f, + (void *) NoOpTexCoord4fv, + (void *) NoOpTexCoord4i, + (void *) NoOpTexCoord4iv, + (void *) NoOpTexCoord4s, + (void *) NoOpTexCoord4sv, + (void *) NoOpVertex2d, + (void *) NoOpVertex2dv, + (void *) NoOpVertex2f, + (void *) NoOpVertex2fv, + (void *) NoOpVertex2i, + (void *) NoOpVertex2iv, + (void *) NoOpVertex2s, + (void *) NoOpVertex2sv, + (void *) NoOpVertex3d, + (void *) NoOpVertex3dv, + (void *) NoOpVertex3f, + (void *) NoOpVertex3fv, + (void *) NoOpVertex3i, + (void *) NoOpVertex3iv, + (void *) NoOpVertex3s, + (void *) NoOpVertex3sv, + (void *) NoOpVertex4d, + (void *) NoOpVertex4dv, + (void *) NoOpVertex4f, + (void *) NoOpVertex4fv, + (void *) NoOpVertex4i, + (void *) NoOpVertex4iv, + (void *) NoOpVertex4s, + (void *) NoOpVertex4sv, + (void *) NoOpClipPlane, + (void *) NoOpColorMaterial, + (void *) NoOpCullFace, + (void *) NoOpFogf, + (void *) NoOpFogfv, + (void *) NoOpFogi, + (void *) NoOpFogiv, + (void *) NoOpFrontFace, + (void *) NoOpHint, + (void *) NoOpLightf, + (void *) NoOpLightfv, + (void *) NoOpLighti, + (void *) NoOpLightiv, + (void *) NoOpLightModelf, + (void *) NoOpLightModelfv, + (void *) NoOpLightModeli, + (void *) NoOpLightModeliv, + (void *) NoOpLineStipple, + (void *) NoOpLineWidth, + (void *) NoOpMaterialf, + (void *) NoOpMaterialfv, + (void *) NoOpMateriali, + (void *) NoOpMaterialiv, + (void *) NoOpPointSize, + (void *) NoOpPolygonMode, + (void *) NoOpPolygonStipple, + (void *) NoOpScissor, + (void *) NoOpShadeModel, + (void *) NoOpTexParameterf, + (void *) NoOpTexParameterfv, + (void *) NoOpTexParameteri, + (void *) NoOpTexParameteriv, + (void *) NoOpTexImage1D, + (void *) NoOpTexImage2D, + (void *) NoOpTexEnvf, + (void *) NoOpTexEnvfv, + (void *) NoOpTexEnvi, + (void *) NoOpTexEnviv, + (void *) NoOpTexGend, + (void *) NoOpTexGendv, + (void *) NoOpTexGenf, + (void *) NoOpTexGenfv, + (void *) NoOpTexGeni, + (void *) NoOpTexGeniv, + (void *) NoOpFeedbackBuffer, + (void *) NoOpSelectBuffer, + (void *) NoOpRenderMode, + (void *) NoOpInitNames, + (void *) NoOpLoadName, + (void *) NoOpPassThrough, + (void *) NoOpPopName, + (void *) NoOpPushName, + (void *) NoOpDrawBuffer, + (void *) NoOpClear, + (void *) NoOpClearAccum, + (void *) NoOpClearIndex, + (void *) NoOpClearColor, + (void *) NoOpClearStencil, + (void *) NoOpClearDepth, + (void *) NoOpStencilMask, + (void *) NoOpColorMask, + (void *) NoOpDepthMask, + (void *) NoOpIndexMask, + (void *) NoOpAccum, + (void *) NoOpDisable, + (void *) NoOpEnable, + (void *) NoOpFinish, + (void *) NoOpFlush, + (void *) NoOpPopAttrib, + (void *) NoOpPushAttrib, + (void *) NoOpMap1d, + (void *) NoOpMap1f, + (void *) NoOpMap2d, + (void *) NoOpMap2f, + (void *) NoOpMapGrid1d, + (void *) NoOpMapGrid1f, + (void *) NoOpMapGrid2d, + (void *) NoOpMapGrid2f, + (void *) NoOpEvalCoord1d, + (void *) NoOpEvalCoord1dv, + (void *) NoOpEvalCoord1f, + (void *) NoOpEvalCoord1fv, + (void *) NoOpEvalCoord2d, + (void *) NoOpEvalCoord2dv, + (void *) NoOpEvalCoord2f, + (void *) NoOpEvalCoord2fv, + (void *) NoOpEvalMesh1, + (void *) NoOpEvalPoint1, + (void *) NoOpEvalMesh2, + (void *) NoOpEvalPoint2, + (void *) NoOpAlphaFunc, + (void *) NoOpBlendFunc, + (void *) NoOpLogicOp, + (void *) NoOpStencilFunc, + (void *) NoOpStencilOp, + (void *) NoOpDepthFunc, + (void *) NoOpPixelZoom, + (void *) NoOpPixelTransferf, + (void *) NoOpPixelTransferi, + (void *) NoOpPixelStoref, + (void *) NoOpPixelStorei, + (void *) NoOpPixelMapfv, + (void *) NoOpPixelMapuiv, + (void *) NoOpPixelMapusv, + (void *) NoOpReadBuffer, + (void *) NoOpCopyPixels, + (void *) NoOpReadPixels, + (void *) NoOpDrawPixels, + (void *) NoOpGetBooleanv, + (void *) NoOpGetClipPlane, + (void *) NoOpGetDoublev, + (void *) NoOpGetError, + (void *) NoOpGetFloatv, + (void *) NoOpGetIntegerv, + (void *) NoOpGetLightfv, + (void *) NoOpGetLightiv, + (void *) NoOpGetMapdv, + (void *) NoOpGetMapfv, + (void *) NoOpGetMapiv, + (void *) NoOpGetMaterialfv, + (void *) NoOpGetMaterialiv, + (void *) NoOpGetPixelMapfv, + (void *) NoOpGetPixelMapuiv, + (void *) NoOpGetPixelMapusv, + (void *) NoOpGetPolygonStipple, + (void *) NoOpGetString, + (void *) NoOpGetTexEnvfv, + (void *) NoOpGetTexEnviv, + (void *) NoOpGetTexGendv, + (void *) NoOpGetTexGenfv, + (void *) NoOpGetTexGeniv, + (void *) NoOpGetTexImage, + (void *) NoOpGetTexParameterfv, + (void *) NoOpGetTexParameteriv, + (void *) NoOpGetTexLevelParameterfv, + (void *) NoOpGetTexLevelParameteriv, + (void *) NoOpIsEnabled, + (void *) NoOpIsList, + (void *) NoOpDepthRange, + (void *) NoOpFrustum, + (void *) NoOpLoadIdentity, + (void *) NoOpLoadMatrixf, + (void *) NoOpLoadMatrixd, + (void *) NoOpMatrixMode, + (void *) NoOpMultMatrixf, + (void *) NoOpMultMatrixd, + (void *) NoOpOrtho, + (void *) NoOpPopMatrix, + (void *) NoOpPushMatrix, + (void *) NoOpRotated, + (void *) NoOpRotatef, + (void *) NoOpScaled, + (void *) NoOpScalef, + (void *) NoOpTranslated, + (void *) NoOpTranslatef, + (void *) NoOpViewport, + /* 1.1 */ + (void *) NoOpArrayElement, + (void *) NoOpBindTexture, + (void *) NoOpColorPointer, + (void *) NoOpDisableClientState, + (void *) NoOpDrawArrays, + (void *) NoOpDrawElements, + (void *) NoOpEdgeFlagPointer, + (void *) NoOpEnableClientState, + (void *) NoOpIndexPointer, + (void *) NoOpIndexub, + (void *) NoOpIndexubv, + (void *) NoOpInterleavedArrays, + (void *) NoOpNormalPointer, + (void *) NoOpPolygonOffset, + (void *) NoOpTexCoordPointer, + (void *) NoOpVertexPointer, + (void *) NoOpAreTexturesResident, + (void *) NoOpCopyTexImage1D, + (void *) NoOpCopyTexImage2D, + (void *) NoOpCopyTexSubImage1D, + (void *) NoOpCopyTexSubImage2D, + (void *) NoOpDeleteTextures, + (void *) NoOpGenTextures, + (void *) NoOpGetPointerv, + (void *) NoOpIsTexture, + (void *) NoOpPrioritizeTextures, + (void *) NoOpTexSubImage1D, + (void *) NoOpTexSubImage2D, + (void *) NoOpPopClientAttrib, + (void *) NoOpPushClientAttrib, + /* 1.2 */ + (void *) NoOpBlendColor, + (void *) NoOpBlendEquation, + (void *) NoOpDrawRangeElements, + (void *) NoOpColorTable, + (void *) NoOpColorTableParameterfv, + (void *) NoOpColorTableParameteriv, + (void *) NoOpCopyColorTable, + (void *) NoOpGetColorTable, + (void *) NoOpGetColorTableParameterfv, + (void *) NoOpGetColorTableParameteriv, + (void *) NoOpColorSubTable, + (void *) NoOpCopyColorSubTable, + (void *) NoOpConvolutionFilter1D, + (void *) NoOpConvolutionFilter2D, + (void *) NoOpConvolutionParameterf, + (void *) NoOpConvolutionParameterfv, + (void *) NoOpConvolutionParameteri, + (void *) NoOpConvolutionParameteriv, + (void *) NoOpCopyConvolutionFilter1D, + (void *) NoOpCopyConvolutionFilter2D, + (void *) NoOpGetConvolutionFilter, + (void *) NoOpGetConvolutionParameterfv, + (void *) NoOpGetConvolutionParameteriv, + (void *) NoOpGetSeparableFilter, + (void *) NoOpSeparableFilter2D, + (void *) NoOpGetHistogram, + (void *) NoOpGetHistogramParameterfv, + (void *) NoOpGetHistogramParameteriv, + (void *) NoOpGetMinmax, + (void *) NoOpGetMinmaxParameterfv, + (void *) NoOpGetMinmaxParameteriv, + (void *) NoOpHistogram, + (void *) NoOpMinmax, + (void *) NoOpResetHistogram, + (void *) NoOpResetMinmax, + (void *) NoOpTexImage3D, + (void *) NoOpTexSubImage3D, + (void *) NoOpCopyTexSubImage3D, /* GL_ARB_multitexture */ - NoOpActiveTextureARB, - NoOpClientActiveTextureARB, - NoOpMultiTexCoord1dARB, - NoOpMultiTexCoord1dvARB, - NoOpMultiTexCoord1fARB, - NoOpMultiTexCoord1fvARB, - NoOpMultiTexCoord1iARB, - NoOpMultiTexCoord1ivARB, - NoOpMultiTexCoord1sARB, - NoOpMultiTexCoord1svARB, - NoOpMultiTexCoord2dARB, - NoOpMultiTexCoord2dvARB, - NoOpMultiTexCoord2fARB, - NoOpMultiTexCoord2fvARB, - NoOpMultiTexCoord2iARB, - NoOpMultiTexCoord2ivARB, - NoOpMultiTexCoord2sARB, - NoOpMultiTexCoord2svARB, - NoOpMultiTexCoord3dARB, - NoOpMultiTexCoord3dvARB, - NoOpMultiTexCoord3fARB, - NoOpMultiTexCoord3fvARB, - NoOpMultiTexCoord3iARB, - NoOpMultiTexCoord3ivARB, - NoOpMultiTexCoord3sARB, - NoOpMultiTexCoord3svARB, - NoOpMultiTexCoord4dARB, - NoOpMultiTexCoord4dvARB, - NoOpMultiTexCoord4fARB, - NoOpMultiTexCoord4fvARB, - NoOpMultiTexCoord4iARB, - NoOpMultiTexCoord4ivARB, - NoOpMultiTexCoord4sARB, - NoOpMultiTexCoord4svARB, - - /* - * Extensions - */ - - /* 2. GL_EXT_blend_color */ - NoOpBlendColorEXT, - - /* 3. GL_EXT_polygon_offset */ - NoOpPolygonOffsetEXT, - - /* 6. GL_EXT_texture3d */ - NoOpCopyTexSubImage3DEXT, - NoOpTexImage3DEXT, - NoOpTexSubImage3DEXT, - - /* 7. GL_SGI_texture_filter4 */ - NoOpGetTexFilterFuncSGIS, - NoOpTexFilterFuncSGIS, - - /* 9. GL_EXT_subtexture */ - NoOpTexSubImage1DEXT, - NoOpTexSubImage2DEXT, - - /* 10. GL_EXT_copy_texture */ - NoOpCopyTexImage1DEXT, - NoOpCopyTexImage2DEXT, - NoOpCopyTexSubImage1DEXT, - NoOpCopyTexSubImage2DEXT, - - /* 11. GL_EXT_histogram */ - NoOpGetHistogramEXT, - NoOpGetHistogramParameterfvEXT, - NoOpGetHistogramParameterivEXT, - NoOpGetMinmaxEXT, - NoOpGetMinmaxParameterfvEXT, - NoOpGetMinmaxParameterivEXT, - NoOpHistogramEXT, - NoOpMinmaxEXT, - NoOpResetHistogramEXT, - NoOpResetMinmaxEXT, - - /* 12. GL_EXT_convolution */ - NoOpConvolutionFilter1DEXT, - NoOpConvolutionFilter2DEXT, - NoOpConvolutionParameterfEXT, - NoOpConvolutionParameterfvEXT, - NoOpConvolutionParameteriEXT, - NoOpConvolutionParameterivEXT, - NoOpCopyConvolutionFilter1DEXT, - NoOpCopyConvolutionFilter2DEXT, - NoOpGetConvolutionFilterEXT, - NoOpGetConvolutionParameterfvEXT, - NoOpGetConvolutionParameterivEXT, - NoOpGetSeparableFilterEXT, - NoOpSeparableFilter2DEXT, - - /* 14. GL_SGI_color_table */ - NoOpColorTableSGI, - NoOpColorTableParameterfvSGI, - NoOpColorTableParameterivSGI, - NoOpCopyColorTableSGI, - NoOpGetColorTableSGI, - NoOpGetColorTableParameterfvSGI, - NoOpGetColorTableParameterivSGI, - - /* 15. GL_SGIS_pixel_texture */ - NoOpPixelTexGenParameterfSGIS, - NoOpPixelTexGenParameteriSGIS, - NoOpGetPixelTexGenParameterfvSGIS, - NoOpGetPixelTexGenParameterivSGIS, - - /* 16. GL_SGIS_texture4D */ - NoOpTexImage4DSGIS, - NoOpTexSubImage4DSGIS, - - /* 20. GL_EXT_texture_object */ - NoOpAreTexturesResidentEXT, - NoOpBindTextureEXT, - NoOpDeleteTexturesEXT, - NoOpGenTexturesEXT, - NoOpIsTextureEXT, - NoOpPrioritizeTexturesEXT, - - /* 21. GL_SGIS_detail_texture */ - NoOpDetailTexFuncSGIS, - NoOpGetDetailTexFuncSGIS, - - /* 22. GL_SGIS_sharpen_texture */ - NoOpGetSharpenTexFuncSGIS, - NoOpSharpenTexFuncSGIS, - - /* 25. GL_SGIS_multisample */ - NoOpSampleMaskSGIS, - NoOpSamplePatternSGIS, - - /* 30. GL_EXT_vertex_array */ - NoOpArrayElementEXT, - NoOpColorPointerEXT, - NoOpDrawArraysEXT, - NoOpEdgeFlagPointerEXT, - NoOpGetPointervEXT, - NoOpIndexPointerEXT, - NoOpNormalPointerEXT, - NoOpTexCoordPointerEXT, - NoOpVertexPointerEXT, - - /* 37. GL_EXT_blend_minmax */ - NoOpBlendEquationEXT, - - /* 52. GL_SGIX_sprite */ - NoOpSpriteParameterfSGIX, - NoOpSpriteParameterfvSGIX, - NoOpSpriteParameteriSGIX, - NoOpSpriteParameterivSGIX, - - /* 54. GL_EXT_point_parameters */ - NoOpPointParameterfEXT, - NoOpPointParameterfvEXT, - - /* 55. GL_SGIX_instruments */ - NoOpGetInstrumentsSGIX, - NoOpInstrumentsBufferSGIX, - NoOpPollInstrumentsSGIX, - NoOpReadInstrumentsSGIX, - NoOpStartInstrumentsSGIX, - NoOpStopInstrumentsSGIX, - - /* 57. GL_SGIX_framezoom */ - NoOpFrameZoomSGIX, - - /* 60. GL_SGIX_reference_plane */ - NoOpReferencePlaneSGIX, - - /* 61. GL_SGIX_flush_raster */ - NoOpFlushRasterSGIX, - - /* 66. GL_HP_image_transform */ - NoOpGetImageTransformParameterfvHP, - NoOpGetImageTransformParameterivHP, - NoOpImageTransformParameterfHP, - NoOpImageTransformParameterfvHP, - NoOpImageTransformParameteriHP, - NoOpImageTransformParameterivHP, - - /* 74. GL_EXT_color_subtable */ - NoOpColorSubTableEXT, - NoOpCopyColorSubTableEXT, - - /* 77. GL_PGI_misc_hints */ - NoOpHintPGI, - - /* 78. GL_EXT_paletted_texture */ - NoOpColorTableEXT, - NoOpGetColorTableEXT, - NoOpGetColorTableParameterfvEXT, - NoOpGetColorTableParameterivEXT, - - /* 80. GL_SGIX_list_priority */ - NoOpGetListParameterfvSGIX, - NoOpGetListParameterivSGIX, - NoOpListParameterfSGIX, - NoOpListParameterfvSGIX, - NoOpListParameteriSGIX, - NoOpListParameterivSGIX, - - /* 94. GL_EXT_index_material */ - NoOpIndexMaterialEXT, - - /* 95. GL_EXT_index_func */ - NoOpIndexFuncEXT, - - /* 96. GL_EXT_index_array_formats - no functions */ - - /* 97. GL_EXT_compiled_vertex_array */ - NoOpLockArraysEXT, - NoOpUnlockArraysEXT, - - /* 98. GL_EXT_cull_vertex */ - NoOpCullParameterfvEXT, - NoOpCullParameterdvEXT, - - /* 173. GL_EXT/INGR_blend_func_separate */ - NoOpBlendFuncSeparateINGR, - - /* GL_MESA_window_pos */ - NoOpWindowPos2dMESA, - NoOpWindowPos2dvMESA, - NoOpWindowPos2fMESA, - NoOpWindowPos2fvMESA, - NoOpWindowPos2iMESA, - NoOpWindowPos2ivMESA, - NoOpWindowPos2sMESA, - NoOpWindowPos2svMESA, - NoOpWindowPos3dMESA, - NoOpWindowPos3dvMESA, - NoOpWindowPos3fMESA, - NoOpWindowPos3fvMESA, - NoOpWindowPos3iMESA, - NoOpWindowPos3ivMESA, - NoOpWindowPos3sMESA, - NoOpWindowPos3svMESA, - NoOpWindowPos4dMESA, - NoOpWindowPos4dvMESA, - NoOpWindowPos4fMESA, - NoOpWindowPos4fvMESA, - NoOpWindowPos4iMESA, - NoOpWindowPos4ivMESA, - NoOpWindowPos4sMESA, - NoOpWindowPos4svMESA, - - /* GL_MESA_resize_buffers */ - NoOpResizeBuffersMESA, - + (void *) NoOpActiveTextureARB, + (void *) NoOpClientActiveTextureARB, + (void *) NoOpMultiTexCoord1dARB, + (void *) NoOpMultiTexCoord1dvARB, + (void *) NoOpMultiTexCoord1fARB, + (void *) NoOpMultiTexCoord1fvARB, + (void *) NoOpMultiTexCoord1iARB, + (void *) NoOpMultiTexCoord1ivARB, + (void *) NoOpMultiTexCoord1sARB, + (void *) NoOpMultiTexCoord1svARB, + (void *) NoOpMultiTexCoord2dARB, + (void *) NoOpMultiTexCoord2dvARB, + (void *) NoOpMultiTexCoord2fARB, + (void *) NoOpMultiTexCoord2fvARB, + (void *) NoOpMultiTexCoord2iARB, + (void *) NoOpMultiTexCoord2ivARB, + (void *) NoOpMultiTexCoord2sARB, + (void *) NoOpMultiTexCoord2svARB, + (void *) NoOpMultiTexCoord3dARB, + (void *) NoOpMultiTexCoord3dvARB, + (void *) NoOpMultiTexCoord3fARB, + (void *) NoOpMultiTexCoord3fvARB, + (void *) NoOpMultiTexCoord3iARB, + (void *) NoOpMultiTexCoord3ivARB, + (void *) NoOpMultiTexCoord3sARB, + (void *) NoOpMultiTexCoord3svARB, + (void *) NoOpMultiTexCoord4dARB, + (void *) NoOpMultiTexCoord4dvARB, + (void *) NoOpMultiTexCoord4fARB, + (void *) NoOpMultiTexCoord4fvARB, + (void *) NoOpMultiTexCoord4iARB, + (void *) NoOpMultiTexCoord4ivARB, + (void *) NoOpMultiTexCoord4sARB, + (void *) NoOpMultiTexCoord4svARB, /* GL_ARB_transpose_matrix */ - NoOpLoadTransposeMatrixdARB, - NoOpLoadTransposeMatrixfARB, - NoOpMultTransposeMatrixdARB, - NoOpMultTransposeMatrixfARB, - + (void *) NoOpLoadTransposeMatrixfARB, + (void *) NoOpLoadTransposeMatrixdARB, + (void *) NoOpMultTransposeMatrixfARB, + (void *) NoOpMultTransposeMatrixdARB, + /* GL_ARB_multisample */ + (void *) NoOpSampleCoverageARB, + (void *) NoOpSamplePassARB, + /* GL_EXT_blend_color */ + /* GL_EXT_polygon_offset */ + (void *) NoOpPolygonOffsetEXT, + /* GL_EXT_texture3D */ + /* GL_EXT_subtexture */ + /* GL_SGIS_texture_filter4 */ + (void *) NoOpGetTexFilterFuncSGIS, + (void *) NoOpTexFilterFuncSGIS, + /* GL_EXT_subtexture */ + /* GL_EXT_copy_texture */ + /* GL_EXT_histogram */ + (void *) NoOpGetHistogramEXT, + (void *) NoOpGetHistogramParameterfvEXT, + (void *) NoOpGetHistogramParameterivEXT, + (void *) NoOpGetMinmaxEXT, + (void *) NoOpGetMinmaxParameterfvEXT, + (void *) NoOpGetMinmaxParameterivEXT, + /* GL_EXT_convolution */ + (void *) NoOpGetConvolutionFilterEXT, + (void *) NoOpGetConvolutionParameterfvEXT, + (void *) NoOpGetConvolutionParameterivEXT, + (void *) NoOpGetSeparableFilterEXT, + /* GL_SGI_color_table */ + (void *) NoOpGetColorTableSGI, + (void *) NoOpGetColorTableParameterfvSGI, + (void *) NoOpGetColorTableParameterivSGI, + /* GL_SGIX_pixel_texture */ + (void *) NoOpPixelTexGenSGIX, + /* GL_SGIS_pixel_texture */ + (void *) NoOpPixelTexGenParameteriSGIS, + (void *) NoOpPixelTexGenParameterivSGIS, + (void *) NoOpPixelTexGenParameterfSGIS, + (void *) NoOpPixelTexGenParameterfvSGIS, + (void *) NoOpGetPixelTexGenParameterivSGIS, + (void *) NoOpGetPixelTexGenParameterfvSGIS, + /* GL_SGIS_texture4D */ + (void *) NoOpTexImage4DSGIS, + (void *) NoOpTexSubImage4DSGIS, + /* GL_EXT_texture_object */ + (void *) NoOpAreTexturesResidentEXT, + (void *) NoOpGenTexturesEXT, + (void *) NoOpIsTextureEXT, + /* GL_SGIS_detail_texture */ + (void *) NoOpDetailTexFuncSGIS, + (void *) NoOpGetDetailTexFuncSGIS, + /* GL_SGIS_sharpen_texture */ + (void *) NoOpSharpenTexFuncSGIS, + (void *) NoOpGetSharpenTexFuncSGIS, + /* GL_SGIS_multisample */ + (void *) NoOpSampleMaskSGIS, + (void *) NoOpSamplePatternSGIS, + /* GL_EXT_vertex_array */ + (void *) NoOpColorPointerEXT, + (void *) NoOpEdgeFlagPointerEXT, + (void *) NoOpIndexPointerEXT, + (void *) NoOpNormalPointerEXT, + (void *) NoOpTexCoordPointerEXT, + (void *) NoOpVertexPointerEXT, + /* GL_EXT_blend_minmax */ + /* GL_SGIX_sprite */ + (void *) NoOpSpriteParameterfSGIX, + (void *) NoOpSpriteParameterfvSGIX, + (void *) NoOpSpriteParameteriSGIX, + (void *) NoOpSpriteParameterivSGIX, + /* GL_EXT_point_parameters */ + (void *) NoOpPointParameterfEXT, + (void *) NoOpPointParameterfvEXT, + /* GL_SGIX_instruments */ + (void *) NoOpGetInstrumentsSGIX, + (void *) NoOpInstrumentsBufferSGIX, + (void *) NoOpPollInstrumentsSGIX, + (void *) NoOpReadInstrumentsSGIX, + (void *) NoOpStartInstrumentsSGIX, + (void *) NoOpStopInstrumentsSGIX, + /* GL_SGIX_framezoom */ + (void *) NoOpFrameZoomSGIX, + /* GL_SGIX_tag_sample_buffer */ + (void *) NoOpTagSampleBufferSGIX, + /* GL_SGIX_reference_plane */ + (void *) NoOpReferencePlaneSGIX, + /* GL_SGIX_flush_raster */ + (void *) NoOpFlushRasterSGIX, + /* GL_SGIX_list_priority */ + (void *) NoOpGetListParameterfvSGIX, + (void *) NoOpGetListParameterivSGIX, + (void *) NoOpListParameterfSGIX, + (void *) NoOpListParameterfvSGIX, + (void *) NoOpListParameteriSGIX, + (void *) NoOpListParameterivSGIX, + /* GL_SGIX_fragment_lighting */ + (void *) NoOpFragmentColorMaterialSGIX, + (void *) NoOpFragmentLightfSGIX, + (void *) NoOpFragmentLightfvSGIX, + (void *) NoOpFragmentLightiSGIX, + (void *) NoOpFragmentLightivSGIX, + (void *) NoOpFragmentLightModelfSGIX, + (void *) NoOpFragmentLightModelfvSGIX, + (void *) NoOpFragmentLightModeliSGIX, + (void *) NoOpFragmentLightModelivSGIX, + (void *) NoOpFragmentMaterialfSGIX, + (void *) NoOpFragmentMaterialfvSGIX, + (void *) NoOpFragmentMaterialiSGIX, + (void *) NoOpFragmentMaterialivSGIX, + (void *) NoOpGetFragmentLightfvSGIX, + (void *) NoOpGetFragmentLightivSGIX, + (void *) NoOpGetFragmentMaterialfvSGIX, + (void *) NoOpGetFragmentMaterialivSGIX, + (void *) NoOpLightEnviSGIX, + /* GL_EXT_vertex_weighting */ + (void *) NoOpVertexWeightfEXT, + (void *) NoOpVertexWeightfvEXT, + (void *) NoOpVertexWeightPointerEXT, + /* GL_NV_vertex_array_range */ + (void *) NoOpFlushVertexArrayRangeNV, + (void *) NoOpVertexArrayRangeNV, + /* GL_NV_register_combiners */ + (void *) NoOpCombinerParameterfvNV, + (void *) NoOpCombinerParameterfNV, + (void *) NoOpCombinerParameterivNV, + (void *) NoOpCombinerParameteriNV, + (void *) NoOpCombinerInputNV, + (void *) NoOpCombinerOutputNV, + (void *) NoOpFinalCombinerInputNV, + (void *) NoOpGetCombinerInputParameterfvNV, + (void *) NoOpGetCombinerInputParameterivNV, + (void *) NoOpGetCombinerOutputParameterfvNV, + (void *) NoOpGetCombinerOutputParameterivNV, + (void *) NoOpGetFinalCombinerInputParameterfvNV, + (void *) NoOpGetFinalCombinerInputParameterivNV, + /* GL_MESA_resize_buffers */ + (void *) NoOpResizeBuffersMESA, + /* GL_MESA_window_pos */ + (void *) NoOpWindowPos2dMESA, + (void *) NoOpWindowPos2dvMESA, + (void *) NoOpWindowPos2fMESA, + (void *) NoOpWindowPos2fvMESA, + (void *) NoOpWindowPos2iMESA, + (void *) NoOpWindowPos2ivMESA, + (void *) NoOpWindowPos2sMESA, + (void *) NoOpWindowPos2svMESA, + (void *) NoOpWindowPos3dMESA, + (void *) NoOpWindowPos3dvMESA, + (void *) NoOpWindowPos3fMESA, + (void *) NoOpWindowPos3fvMESA, + (void *) NoOpWindowPos3iMESA, + (void *) NoOpWindowPos3ivMESA, + (void *) NoOpWindowPos3sMESA, + (void *) NoOpWindowPos3svMESA, + (void *) NoOpWindowPos4dMESA, + (void *) NoOpWindowPos4dvMESA, + (void *) NoOpWindowPos4fMESA, + (void *) NoOpWindowPos4fvMESA, + (void *) NoOpWindowPos4iMESA, + (void *) NoOpWindowPos4ivMESA, + (void *) NoOpWindowPos4sMESA, + (void *) NoOpWindowPos4svMESA, + /* GL_EXT_draw_range_elements */ + (void *) NoOpBlendFuncSeparateEXT, + /* GL_EXT_index_material */ + (void *) NoOpIndexMaterialEXT, + /* GL_EXT_index_func */ + (void *) NoOpIndexFuncEXT, + /* GL_EXT_compiled_vertex_array */ + (void *) NoOpLockArraysEXT, + (void *) NoOpUnlockArraysEXT, + /* GL_EXT_cull_vertex */ + (void *) NoOpCullParameterdvEXT, + (void *) NoOpCullParameterfvEXT, + /* GL_PGI_misc_hints */ + (void *) NoOpHintPGI, + /* GL_EXT_fog_coord */ + (void *) NoOpFogCoordfEXT, + (void *) NoOpFogCoordfvEXT, + (void *) NoOpFogCoorddEXT, + (void *) NoOpFogCoorddEXT, + (void *) NoOpFogCoordPointerEXT, + /* GL_EXT_color_table */ + (void *) NoOpGetColorTableEXT, + (void *) NoOpGetColorTableParameterivEXT, + (void *) NoOpGetColorTableParameterfvEXT, + + /* A whole bunch of no-op functions. These might be called + * when someone tries to call a dynamically-registered extension + * function without a current rendering context. + */ + (void *) NoOpGeneric, + (void *) NoOpGeneric, + (void *) NoOpGeneric, + (void *) NoOpGeneric, + (void *) NoOpGeneric, + (void *) NoOpGeneric, + (void *) NoOpGeneric, + (void *) NoOpGeneric, + (void *) NoOpGeneric, + (void *) NoOpGeneric, + (void *) NoOpGeneric, + (void *) NoOpGeneric, + (void *) NoOpGeneric, + (void *) NoOpGeneric, + (void *) NoOpGeneric, + (void *) NoOpGeneric, + (void *) NoOpGeneric, + (void *) NoOpGeneric, + (void *) NoOpGeneric, + (void *) NoOpGeneric, + (void *) NoOpGeneric, + (void *) NoOpGeneric, + (void *) NoOpGeneric, + (void *) NoOpGeneric, + (void *) NoOpGeneric, + (void *) NoOpGeneric, + (void *) NoOpGeneric, + (void *) NoOpGeneric, + (void *) NoOpGeneric, + (void *) NoOpGeneric, + (void *) NoOpGeneric, + (void *) NoOpGeneric, + (void *) NoOpGeneric, + (void *) NoOpGeneric, + (void *) NoOpGeneric, + (void *) NoOpGeneric, + (void *) NoOpGeneric, + (void *) NoOpGeneric, + (void *) NoOpGeneric, + (void *) NoOpGeneric, + (void *) NoOpGeneric, + (void *) NoOpGeneric, + (void *) NoOpGeneric, + (void *) NoOpGeneric, + (void *) NoOpGeneric, + (void *) NoOpGeneric, + (void *) NoOpGeneric, + (void *) NoOpGeneric, + (void *) NoOpGeneric, + (void *) NoOpGeneric, + (void *) NoOpGeneric, + (void *) NoOpGeneric, + (void *) NoOpGeneric, + (void *) NoOpGeneric, + (void *) NoOpGeneric, + (void *) NoOpGeneric, + (void *) NoOpGeneric, + (void *) NoOpGeneric, + (void *) NoOpGeneric, + (void *) NoOpGeneric, + (void *) NoOpGeneric, + (void *) NoOpGeneric, + (void *) NoOpGeneric, + (void *) NoOpGeneric, + (void *) NoOpGeneric, + (void *) NoOpGeneric, + (void *) NoOpGeneric, + (void *) NoOpGeneric, + (void *) NoOpGeneric, + (void *) NoOpGeneric, + (void *) NoOpGeneric, + (void *) NoOpGeneric, + (void *) NoOpGeneric, + (void *) NoOpGeneric, + (void *) NoOpGeneric, + (void *) NoOpGeneric, + (void *) NoOpGeneric, + (void *) NoOpGeneric, + (void *) NoOpGeneric, + (void *) NoOpGeneric, + (void *) NoOpGeneric, + (void *) NoOpGeneric, + (void *) NoOpGeneric, + (void *) NoOpGeneric, + (void *) NoOpGeneric, + (void *) NoOpGeneric, + (void *) NoOpGeneric, + (void *) NoOpGeneric, + (void *) NoOpGeneric, + (void *) NoOpGeneric, + (void *) NoOpGeneric, + (void *) NoOpGeneric, + (void *) NoOpGeneric, + (void *) NoOpGeneric, + (void *) NoOpGeneric, + (void *) NoOpGeneric, + (void *) NoOpGeneric, + (void *) NoOpGeneric, + (void *) NoOpGeneric, + (void *) NoOpGeneric, + (void *) NoOpGeneric, + (void *) NoOpGeneric, + (void *) NoOpGeneric, + (void *) NoOpGeneric, + (void *) NoOpGeneric, + (void *) NoOpGeneric, + (void *) NoOpGeneric, + (void *) NoOpGeneric, + (void *) NoOpGeneric, + (void *) NoOpGeneric, + (void *) NoOpGeneric, + (void *) NoOpGeneric, + (void *) NoOpGeneric, + (void *) NoOpGeneric, + (void *) NoOpGeneric, + (void *) NoOpGeneric, + (void *) NoOpGeneric, + (void *) NoOpGeneric, + (void *) NoOpGeneric, + (void *) NoOpGeneric, + (void *) NoOpGeneric, + (void *) NoOpGeneric, + (void *) NoOpGeneric, + (void *) NoOpGeneric, + (void *) NoOpGeneric, + (void *) NoOpGeneric, + (void *) NoOpGeneric, + (void *) NoOpGeneric, + (void *) NoOpGeneric, + (void *) NoOpGeneric, + (void *) NoOpGeneric, + (void *) NoOpGeneric, + (void *) NoOpGeneric, + (void *) NoOpGeneric, + (void *) NoOpGeneric, + (void *) NoOpGeneric, + (void *) NoOpGeneric, + (void *) NoOpGeneric, + (void *) NoOpGeneric, + (void *) NoOpGeneric, + (void *) NoOpGeneric, + (void *) NoOpGeneric, + (void *) NoOpGeneric, + (void *) NoOpGeneric, + (void *) NoOpGeneric, + (void *) NoOpGeneric, + (void *) NoOpGeneric, + (void *) NoOpGeneric, + (void *) NoOpGeneric, + (void *) NoOpGeneric, + (void *) NoOpGeneric, + (void *) NoOpGeneric, + (void *) NoOpGeneric, + (void *) NoOpGeneric, + (void *) NoOpGeneric, + (void *) NoOpGeneric, + (void *) NoOpGeneric, + (void *) NoOpGeneric, + (void *) NoOpGeneric, + (void *) NoOpGeneric, + (void *) NoOpGeneric }; - diff --git a/xc/extras/Mesa/src/glapinoop.h b/xc/extras/Mesa/src/glapinoop.h index 61922d30b..a3ac9c6ca 100644 --- a/xc/extras/Mesa/src/glapinoop.h +++ b/xc/extras/Mesa/src/glapinoop.h @@ -34,7 +34,7 @@ extern void _glapi_noop_enable_warnings(GLboolean enable); -extern struct _glapi_table __glapi_noop_table; +extern void *__glapi_noop_table[]; #endif diff --git a/xc/extras/Mesa/src/glapioffsets.h b/xc/extras/Mesa/src/glapioffsets.h index 38b1da62d..67481c8e0 100644 --- a/xc/extras/Mesa/src/glapioffsets.h +++ b/xc/extras/Mesa/src/glapioffsets.h @@ -1,823 +1,559 @@ - -/* - * Mesa 3-D graphics library - * Version: 3.3 - * - * Copyright (C) 1999 Brian Paul All Rights Reserved. - * - * Permission is hereby granted, free of charge, to any person obtaining a - * copy of this software and associated documentation files (the "Software"), - * to deal in the Software without restriction, including without limitation - * the rights to use, copy, modify, merge, publish, distribute, sublicense, - * and/or sell copies of the Software, and to permit persons to whom the - * Software is furnished to do so, subject to the following conditions: - * - * The above copyright notice and this permission notice shall be included - * in all copies or substantial portions of the Software. - * - * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS - * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, - * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL - * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN - * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN - * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. - */ - - -/* - * This file defines a static offset for all GL functions within the - * dispatch table. - * - * Eventually a replacement for this file will be available from SGI - * or the ARB so all vendors have the same info. - * - * XXX this file is incomplete - many more extension functions left to add - */ - - - -#ifndef _glextfunc_h_ -#define _glextfunc_h_ - -#define _BASE 0 - - -/* GL 1.1 */ -#define _gloffset_Accum (_BASE + 1) -#define _gloffset_AlphaFunc (_BASE + 2) -#define _gloffset_Begin (_BASE + 3) -#define _gloffset_Bitmap (_BASE + 4) -#define _gloffset_BlendFunc (_BASE + 5) -#define _gloffset_CallList (_BASE + 6) -#define _gloffset_CallLists (_BASE + 7) -#define _gloffset_Clear (_BASE + 8) -#define _gloffset_ClearAccum (_BASE + 9) -#define _gloffset_ClearColor (_BASE + 10) -#define _gloffset_ClearDepth (_BASE + 11) -#define _gloffset_ClearIndex (_BASE + 12) -#define _gloffset_ClearStencil (_BASE + 13) -#define _gloffset_ClipPlane (_BASE + 14) -#define _gloffset_Color3b (_BASE + 15) -#define _gloffset_Color3bv (_BASE + 16) -#define _gloffset_Color3d (_BASE + 17) -#define _gloffset_Color3dv (_BASE + 18) -#define _gloffset_Color3f (_BASE + 19) -#define _gloffset_Color3fv (_BASE + 20) -#define _gloffset_Color3i (_BASE + 21) -#define _gloffset_Color3iv (_BASE + 22) -#define _gloffset_Color3s (_BASE + 23) -#define _gloffset_Color3sv (_BASE + 24) -#define _gloffset_Color3ub (_BASE + 25) -#define _gloffset_Color3ubv (_BASE + 26) -#define _gloffset_Color3ui (_BASE + 27) -#define _gloffset_Color3uiv (_BASE + 28) -#define _gloffset_Color3us (_BASE + 29) -#define _gloffset_Color3usv (_BASE + 30) -#define _gloffset_Color4b (_BASE + 31) -#define _gloffset_Color4bv (_BASE + 32) -#define _gloffset_Color4d (_BASE + 33) -#define _gloffset_Color4dv (_BASE + 34) -#define _gloffset_Color4f (_BASE + 35) -#define _gloffset_Color4fv (_BASE + 36) -#define _gloffset_Color4i (_BASE + 37) -#define _gloffset_Color4iv (_BASE + 38) -#define _gloffset_Color4s (_BASE + 39) -#define _gloffset_Color4sv (_BASE + 40) -#define _gloffset_Color4ub (_BASE + 41) -#define _gloffset_Color4ubv (_BASE + 42) -#define _gloffset_Color4ui (_BASE + 43) -#define _gloffset_Color4uiv (_BASE + 44) -#define _gloffset_Color4us (_BASE + 45) -#define _gloffset_Color4usv (_BASE + 46) -#define _gloffset_ColorMask (_BASE + 47) -#define _gloffset_ColorMaterial (_BASE + 48) -#define _gloffset_CopyPixels (_BASE + 49) -#define _gloffset_CullFace (_BASE + 50) -#define _gloffset_DeleteLists (_BASE + 51) -#define _gloffset_DepthFunc (_BASE + 52) -#define _gloffset_DepthMask (_BASE + 53) -#define _gloffset_DepthRange (_BASE + 54) -#define _gloffset_Disable (_BASE + 55) -#define _gloffset_DrawBuffer (_BASE + 56) -#define _gloffset_DrawPixels (_BASE + 57) -#define _gloffset_EdgeFlag (_BASE + 58) -#define _gloffset_EdgeFlagv (_BASE + 59) -#define _gloffset_Enable (_BASE + 60) -#define _gloffset_End (_BASE + 61) -#define _gloffset_EndList (_BASE + 62) -#define _gloffset_EvalCoord1d (_BASE + 63) -#define _gloffset_EvalCoord1dv (_BASE + 64) -#define _gloffset_EvalCoord1f (_BASE + 65) -#define _gloffset_EvalCoord1fv (_BASE + 66) -#define _gloffset_EvalCoord2d (_BASE + 67) -#define _gloffset_EvalCoord2dv (_BASE + 68) -#define _gloffset_EvalCoord2f (_BASE + 69) -#define _gloffset_EvalCoord2fv (_BASE + 70) -#define _gloffset_EvalMesh1 (_BASE + 71) -#define _gloffset_EvalMesh2 (_BASE + 72) -#define _gloffset_EvalPoint1 (_BASE + 73) -#define _gloffset_EvalPoint2 (_BASE + 74) -#define _gloffset_FeedbackBuffer (_BASE + 75) -#define _gloffset_Finish (_BASE + 76) -#define _gloffset_Flush (_BASE + 77) -#define _gloffset_Fogf (_BASE + 78) -#define _gloffset_Fogfv (_BASE + 79) -#define _gloffset_Fogi (_BASE + 80) -#define _gloffset_Fogiv (_BASE + 81) -#define _gloffset_FrontFace (_BASE + 82) -#define _gloffset_Frustum (_BASE + 83) -#define _gloffset_GenLists (_BASE + 84) -#define _gloffset_GetBooleanv (_BASE + 85) -#define _gloffset_GetClipPlane (_BASE + 86) -#define _gloffset_GetDoublev (_BASE + 87) -#define _gloffset_GetError (_BASE + 88) -#define _gloffset_GetFloatv (_BASE + 89) -#define _gloffset_GetIntegerv (_BASE + 90) -#define _gloffset_GetLightfv (_BASE + 91) -#define _gloffset_GetLightiv (_BASE + 92) -#define _gloffset_GetMapdv (_BASE + 93) -#define _gloffset_GetMapfv (_BASE + 94) -#define _gloffset_GetMapiv (_BASE + 95) -#define _gloffset_GetMaterialfv (_BASE + 96) -#define _gloffset_GetMaterialiv (_BASE + 97) -#define _gloffset_GetPixelMapfv (_BASE + 98) -#define _gloffset_GetPixelMapuiv (_BASE + 99) -#define _gloffset_GetPixelMapusv (_BASE + 100) -#define _gloffset_GetPolygonStipple (_BASE + 101) -#define _gloffset_GetString (_BASE + 102) -#define _gloffset_GetTexEnvfv (_BASE + 103) -#define _gloffset_GetTexEnviv (_BASE + 104) -#define _gloffset_GetTexGendv (_BASE + 105) -#define _gloffset_GetTexGenfv (_BASE + 106) -#define _gloffset_GetTexGeniv (_BASE + 107) -#define _gloffset_GetTexImage (_BASE + 108) -#define _gloffset_GetTexLevelParameterfv (_BASE + 109) -#define _gloffset_GetTexLevelParameteriv (_BASE + 110) -#define _gloffset_GetTexParameterfv (_BASE + 111) -#define _gloffset_GetTexParameteriv (_BASE + 112) -#define _gloffset_Hint (_BASE + 113) -#define _gloffset_IndexMask (_BASE + 114) -#define _gloffset_Indexd (_BASE + 115) -#define _gloffset_Indexdv (_BASE + 116) -#define _gloffset_Indexf (_BASE + 117) -#define _gloffset_Indexfv (_BASE + 118) -#define _gloffset_Indexi (_BASE + 119) -#define _gloffset_Indexiv (_BASE + 120) -#define _gloffset_Indexs (_BASE + 121) -#define _gloffset_Indexsv (_BASE + 122) -#define _gloffset_InitNames (_BASE + 123) -#define _gloffset_IsEnabled (_BASE + 124) -#define _gloffset_IsList (_BASE + 125) -#define _gloffset_LightModelf (_BASE + 126) -#define _gloffset_LightModelfv (_BASE + 127) -#define _gloffset_LightModeli (_BASE + 128) -#define _gloffset_LightModeliv (_BASE + 129) -#define _gloffset_Lightf (_BASE + 130) -#define _gloffset_Lightfv (_BASE + 131) -#define _gloffset_Lighti (_BASE + 132) -#define _gloffset_Lightiv (_BASE + 133) -#define _gloffset_LineStipple (_BASE + 134) -#define _gloffset_LineWidth (_BASE + 135) -#define _gloffset_ListBase (_BASE + 136) -#define _gloffset_LoadIdentity (_BASE + 137) -#define _gloffset_LoadMatrixd (_BASE + 138) -#define _gloffset_LoadMatrixf (_BASE + 139) -#define _gloffset_LoadName (_BASE + 140) -#define _gloffset_LogicOp (_BASE + 141) -#define _gloffset_Map1d (_BASE + 142) -#define _gloffset_Map1f (_BASE + 143) -#define _gloffset_Map2d (_BASE + 144) -#define _gloffset_Map2f (_BASE + 145) -#define _gloffset_MapGrid1d (_BASE + 146) -#define _gloffset_MapGrid1f (_BASE + 147) -#define _gloffset_MapGrid2d (_BASE + 148) -#define _gloffset_MapGrid2f (_BASE + 149) -#define _gloffset_Materialf (_BASE + 150) -#define _gloffset_Materialfv (_BASE + 151) -#define _gloffset_Materiali (_BASE + 152) -#define _gloffset_Materialiv (_BASE + 153) -#define _gloffset_MatrixMode (_BASE + 154) -#define _gloffset_MultMatrixd (_BASE + 155) -#define _gloffset_MultMatrixf (_BASE + 156) -#define _gloffset_NewList (_BASE + 157) -#define _gloffset_Normal3b (_BASE + 158) -#define _gloffset_Normal3bv (_BASE + 159) -#define _gloffset_Normal3d (_BASE + 160) -#define _gloffset_Normal3dv (_BASE + 161) -#define _gloffset_Normal3f (_BASE + 162) -#define _gloffset_Normal3fv (_BASE + 163) -#define _gloffset_Normal3i (_BASE + 164) -#define _gloffset_Normal3iv (_BASE + 165) -#define _gloffset_Normal3s (_BASE + 166) -#define _gloffset_Normal3sv (_BASE + 167) -#define _gloffset_Ortho (_BASE + 168) -#define _gloffset_PassThrough (_BASE + 169) -#define _gloffset_PixelMapfv (_BASE + 170) -#define _gloffset_PixelMapuiv (_BASE + 171) -#define _gloffset_PixelMapusv (_BASE + 172) -#define _gloffset_PixelStoref (_BASE + 173) -#define _gloffset_PixelStorei (_BASE + 174) -#define _gloffset_PixelTransferf (_BASE + 175) -#define _gloffset_PixelTransferi (_BASE + 176) -#define _gloffset_PixelZoom (_BASE + 177) -#define _gloffset_PointSize (_BASE + 178) -#define _gloffset_PolygonMode (_BASE + 179) -#define _gloffset_PolygonOffset (_BASE + 180) -#define _gloffset_PolygonStipple (_BASE + 181) -#define _gloffset_PopAttrib (_BASE + 182) -#define _gloffset_PopMatrix (_BASE + 183) -#define _gloffset_PopName (_BASE + 184) -#define _gloffset_PushAttrib (_BASE + 185) -#define _gloffset_PushMatrix (_BASE + 186) -#define _gloffset_PushName (_BASE + 187) -#define _gloffset_RasterPos2d (_BASE + 188) -#define _gloffset_RasterPos2dv (_BASE + 189) -#define _gloffset_RasterPos2f (_BASE + 190) -#define _gloffset_RasterPos2fv (_BASE + 191) -#define _gloffset_RasterPos2i (_BASE + 192) -#define _gloffset_RasterPos2iv (_BASE + 193) -#define _gloffset_RasterPos2s (_BASE + 194) -#define _gloffset_RasterPos2sv (_BASE + 195) -#define _gloffset_RasterPos3d (_BASE + 196) -#define _gloffset_RasterPos3dv (_BASE + 197) -#define _gloffset_RasterPos3f (_BASE + 198) -#define _gloffset_RasterPos3fv (_BASE + 199) -#define _gloffset_RasterPos3i (_BASE + 200) -#define _gloffset_RasterPos3iv (_BASE + 201) -#define _gloffset_RasterPos3s (_BASE + 202) -#define _gloffset_RasterPos3sv (_BASE + 203) -#define _gloffset_RasterPos4d (_BASE + 204) -#define _gloffset_RasterPos4dv (_BASE + 205) -#define _gloffset_RasterPos4f (_BASE + 206) -#define _gloffset_RasterPos4fv (_BASE + 207) -#define _gloffset_RasterPos4i (_BASE + 208) -#define _gloffset_RasterPos4iv (_BASE + 209) -#define _gloffset_RasterPos4s (_BASE + 210) -#define _gloffset_RasterPos4sv (_BASE + 211) -#define _gloffset_ReadBuffer (_BASE + 212) -#define _gloffset_ReadPixels (_BASE + 213) -#define _gloffset_Rectd (_BASE + 214) -#define _gloffset_Rectdv (_BASE + 215) -#define _gloffset_Rectf (_BASE + 216) -#define _gloffset_Rectfv (_BASE + 217) -#define _gloffset_Recti (_BASE + 218) -#define _gloffset_Rectiv (_BASE + 219) -#define _gloffset_Rects (_BASE + 220) -#define _gloffset_Rectsv (_BASE + 221) -#define _gloffset_RenderMode (_BASE + 222) -#define _gloffset_Rotated (_BASE + 223) -#define _gloffset_Rotatef (_BASE + 224) -#define _gloffset_Scaled (_BASE + 225) -#define _gloffset_Scalef (_BASE + 226) -#define _gloffset_Scissor (_BASE + 227) -#define _gloffset_SelectBuffer (_BASE + 228) -#define _gloffset_ShadeModel (_BASE + 229) -#define _gloffset_StencilFunc (_BASE + 230) -#define _gloffset_StencilMask (_BASE + 231) -#define _gloffset_StencilOp (_BASE + 232) -#define _gloffset_TexCoord1d (_BASE + 233) -#define _gloffset_TexCoord1dv (_BASE + 234) -#define _gloffset_TexCoord1f (_BASE + 235) -#define _gloffset_TexCoord1fv (_BASE + 236) -#define _gloffset_TexCoord1i (_BASE + 237) -#define _gloffset_TexCoord1iv (_BASE + 238) -#define _gloffset_TexCoord1s (_BASE + 239) -#define _gloffset_TexCoord1sv (_BASE + 240) -#define _gloffset_TexCoord2d (_BASE + 241) -#define _gloffset_TexCoord2dv (_BASE + 242) -#define _gloffset_TexCoord2f (_BASE + 243) -#define _gloffset_TexCoord2fv (_BASE + 244) -#define _gloffset_TexCoord2i (_BASE + 245) -#define _gloffset_TexCoord2iv (_BASE + 246) -#define _gloffset_TexCoord2s (_BASE + 247) -#define _gloffset_TexCoord2sv (_BASE + 248) -#define _gloffset_TexCoord3d (_BASE + 249) -#define _gloffset_TexCoord3dv (_BASE + 250) -#define _gloffset_TexCoord3f (_BASE + 251) -#define _gloffset_TexCoord3fv (_BASE + 252) -#define _gloffset_TexCoord3i (_BASE + 253) -#define _gloffset_TexCoord3iv (_BASE + 254) -#define _gloffset_TexCoord3s (_BASE + 255) -#define _gloffset_TexCoord3sv (_BASE + 256) -#define _gloffset_TexCoord4d (_BASE + 257) -#define _gloffset_TexCoord4dv (_BASE + 258) -#define _gloffset_TexCoord4f (_BASE + 259) -#define _gloffset_TexCoord4fv (_BASE + 260) -#define _gloffset_TexCoord4i (_BASE + 261) -#define _gloffset_TexCoord4iv (_BASE + 262) -#define _gloffset_TexCoord4s (_BASE + 263) -#define _gloffset_TexCoord4sv (_BASE + 264) -#define _gloffset_TexEnvf (_BASE + 265) -#define _gloffset_TexEnvfv (_BASE + 266) -#define _gloffset_TexEnvi (_BASE + 267) -#define _gloffset_TexEnviv (_BASE + 268) -#define _gloffset_TexGend (_BASE + 269) -#define _gloffset_TexGendv (_BASE + 270) -#define _gloffset_TexGenf (_BASE + 271) -#define _gloffset_TexGenfv (_BASE + 272) -#define _gloffset_TexGeni (_BASE + 273) -#define _gloffset_TexGeniv (_BASE + 274) -#define _gloffset_TexImage1D (_BASE + 275) -#define _gloffset_TexImage2D (_BASE + 276) -#define _gloffset_TexParameterf (_BASE + 277) -#define _gloffset_TexParameterfv (_BASE + 278) -#define _gloffset_TexParameteri (_BASE + 279) -#define _gloffset_TexParameteriv (_BASE + 280) -#define _gloffset_Translated (_BASE + 281) -#define _gloffset_Translatef (_BASE + 282) -#define _gloffset_Vertex2d (_BASE + 283) -#define _gloffset_Vertex2dv (_BASE + 284) -#define _gloffset_Vertex2f (_BASE + 285) -#define _gloffset_Vertex2fv (_BASE + 286) -#define _gloffset_Vertex2i (_BASE + 287) -#define _gloffset_Vertex2iv (_BASE + 288) -#define _gloffset_Vertex2s (_BASE + 289) -#define _gloffset_Vertex2sv (_BASE + 290) -#define _gloffset_Vertex3d (_BASE + 291) -#define _gloffset_Vertex3dv (_BASE + 292) -#define _gloffset_Vertex3f (_BASE + 293) -#define _gloffset_Vertex3fv (_BASE + 294) -#define _gloffset_Vertex3i (_BASE + 295) -#define _gloffset_Vertex3iv (_BASE + 296) -#define _gloffset_Vertex3s (_BASE + 297) -#define _gloffset_Vertex3sv (_BASE + 298) -#define _gloffset_Vertex4d (_BASE + 299) -#define _gloffset_Vertex4dv (_BASE + 300) -#define _gloffset_Vertex4f (_BASE + 301) -#define _gloffset_Vertex4fv (_BASE + 302) -#define _gloffset_Vertex4i (_BASE + 303) -#define _gloffset_Vertex4iv (_BASE + 304) -#define _gloffset_Vertex4s (_BASE + 305) -#define _gloffset_Vertex4sv (_BASE + 306) -#define _gloffset_Viewport (_BASE + 307) - -/* GL 1.1 */ -#define _gloffset_AreTexturesResident (_BASE + 308) -#define _gloffset_ArrayElement (_BASE + 309) -#define _gloffset_BindTexture (_BASE + 310) -#define _gloffset_ColorPointer (_BASE + 311) -#define _gloffset_CopyTexImage1D (_BASE + 312) -#define _gloffset_CopyTexImage2D (_BASE + 313) -#define _gloffset_CopyTexSubImage1D (_BASE + 314) -#define _gloffset_CopyTexSubImage2D (_BASE + 315) -#define _gloffset_DeleteTextures (_BASE + 316) -#define _gloffset_DisableClientState (_BASE + 317) -#define _gloffset_DrawArrays (_BASE + 318) -#define _gloffset_DrawElements (_BASE + 319) -#define _gloffset_EdgeFlagPointer (_BASE + 320) -#define _gloffset_EnableClientState (_BASE + 321) -#define _gloffset_GenTextures (_BASE + 322) -#define _gloffset_GetPointerv (_BASE + 323) -#define _gloffset_IndexPointer (_BASE + 324) -#define _gloffset_Indexub (_BASE + 325) -#define _gloffset_Indexubv (_BASE + 326) -#define _gloffset_InterleavedArrays (_BASE + 327) -#define _gloffset_IsTexture (_BASE + 328) -#define _gloffset_NormalPointer (_BASE + 329) -#define _gloffset_PopClientAttrib (_BASE + 330) -#define _gloffset_PrioritizeTextures (_BASE + 331) -#define _gloffset_PushClientAttrib (_BASE + 332) -#define _gloffset_TexCoordPointer (_BASE + 333) -#define _gloffset_TexSubImage1D (_BASE + 334) -#define _gloffset_TexSubImage2D (_BASE + 335) -#define _gloffset_VertexPointer (_BASE + 336) - -/* GL 1.2 */ -#define _gloffset_CopyTexSubImage3D (_BASE + 337) -#define _gloffset_DrawRangeElements (_BASE + 338) -#define _gloffset_TexImage3D (_BASE + 339) -#define _gloffset_TexSubImage3D (_BASE + 340) - -/* GL_ARB_imaging */ -#define _gloffset_BlendColor (_BASE + 341) -#define _gloffset_BlendEquation (_BASE + 342) -#define _gloffset_ColorSubTable (_BASE + 343) -#define _gloffset_ColorTable (_BASE + 344) -#define _gloffset_ColorTableParameterfv (_BASE + 345) -#define _gloffset_ColorTableParameteriv (_BASE + 346) -#define _gloffset_ConvolutionFilter1D (_BASE + 347) -#define _gloffset_ConvolutionFilter2D (_BASE + 348) -#define _gloffset_ConvolutionParameterf (_BASE + 349) -#define _gloffset_ConvolutionParameterfv (_BASE + 350) -#define _gloffset_ConvolutionParameteri (_BASE + 351) -#define _gloffset_ConvolutionParameteriv (_BASE + 352) -#define _gloffset_CopyColorSubTable (_BASE + 353) -#define _gloffset_CopyColorTable (_BASE + 354) -#define _gloffset_CopyConvolutionFilter1D (_BASE + 355) -#define _gloffset_CopyConvolutionFilter2D (_BASE + 356) -#define _gloffset_GetColorTable (_BASE + 357) -#define _gloffset_GetColorTableParameterfv (_BASE + 358) -#define _gloffset_GetColorTableParameteriv (_BASE + 359) -#define _gloffset_GetConvolutionFilter (_BASE + 360) -#define _gloffset_GetConvolutionParameterfv (_BASE + 361) -#define _gloffset_GetConvolutionParameteriv (_BASE + 362) -#define _gloffset_GetHistogram (_BASE + 363) -#define _gloffset_GetHistogramParameterfv (_BASE + 364) -#define _gloffset_GetHistogramParameteriv (_BASE + 365) -#define _gloffset_GetMinmax (_BASE + 366) -#define _gloffset_GetMinmaxParameterfv (_BASE + 367) -#define _gloffset_GetMinmaxParameteriv (_BASE + 368) -#define _gloffset_GetSeparableFilter (_BASE + 369) -#define _gloffset_Histogram (_BASE + 370) -#define _gloffset_Minmax (_BASE + 371) -#define _gloffset_ResetHistogram (_BASE + 372) -#define _gloffset_ResetMinmax (_BASE + 373) -#define _gloffset_SeparableFilter2D (_BASE + 374) - -/* GL_ARB_multitexture */ -#define _gloffset_ActiveTextureARB (_BASE + 375) -#define _gloffset_ClientActiveTextureARB (_BASE + 376) -#define _gloffset_MultiTexCoord1dARB (_BASE + 377) -#define _gloffset_MultiTexCoord1dvARB (_BASE + 378) -#define _gloffset_MultiTexCoord1fARB (_BASE + 379) -#define _gloffset_MultiTexCoord1fvARB (_BASE + 380) -#define _gloffset_MultiTexCoord1iARB (_BASE + 381) -#define _gloffset_MultiTexCoord1ivARB (_BASE + 382) -#define _gloffset_MultiTexCoord1sARB (_BASE + 383) -#define _gloffset_MultiTexCoord1svARB (_BASE + 384) -#define _gloffset_MultiTexCoord2dARB (_BASE + 385) -#define _gloffset_MultiTexCoord2dvARB (_BASE + 386) -#define _gloffset_MultiTexCoord2fARB (_BASE + 387) -#define _gloffset_MultiTexCoord2fvARB (_BASE + 388) -#define _gloffset_MultiTexCoord2iARB (_BASE + 389) -#define _gloffset_MultiTexCoord2ivARB (_BASE + 390) -#define _gloffset_MultiTexCoord2sARB (_BASE + 391) -#define _gloffset_MultiTexCoord2svARB (_BASE + 392) -#define _gloffset_MultiTexCoord3dARB (_BASE + 393) -#define _gloffset_MultiTexCoord3dvARB (_BASE + 394) -#define _gloffset_MultiTexCoord3fARB (_BASE + 395) -#define _gloffset_MultiTexCoord3fvARB (_BASE + 396) -#define _gloffset_MultiTexCoord3iARB (_BASE + 397) -#define _gloffset_MultiTexCoord3ivARB (_BASE + 398) -#define _gloffset_MultiTexCoord3sARB (_BASE + 399) -#define _gloffset_MultiTexCoord3svARB (_BASE + 400) -#define _gloffset_MultiTexCoord4dARB (_BASE + 401) -#define _gloffset_MultiTexCoord4dvARB (_BASE + 402) -#define _gloffset_MultiTexCoord4fARB (_BASE + 403) -#define _gloffset_MultiTexCoord4fvARB (_BASE + 404) -#define _gloffset_MultiTexCoord4iARB (_BASE + 405) -#define _gloffset_MultiTexCoord4ivARB (_BASE + 406) -#define _gloffset_MultiTexCoord4sARB (_BASE + 407) -#define _gloffset_MultiTexCoord4svARB (_BASE + 408) - - - -#define _EXTBASE (_BASE + 409) - - -/* 1. GL_EXT_abgr - no functions */ - -/* 2. GL_EXT_blend_color */ -#define _gloffset_BlendColorEXT (_EXTBASE + 0) - -/* 3. GL_EXT_polygon_offset */ -#define _gloffset_PolygonOffsetEXT (_EXTBASE + 1) - -/* 4. GL_EXT_texture - no functions */ - -/* 5. ??? */ - -/* 6. GL_EXT_texture3D */ -#define _gloffset_CopyTexSubImage3DEXT (_EXTBASE + 2) -#define _gloffset_TexImage3DEXT (_EXTBASE + 3) -#define _gloffset_TexSubImage3DEXT (_EXTBASE + 4) - -/* 7. GL_SGI_texture_filter4 */ -#define _gloffset_GetTexFilterFuncSGIS (_EXTBASE + 5) -#define _gloffset_TexFilterFuncSGIS (_EXTBASE + 6) - -/* 8. ??? */ - -/* 9. GL_EXT_subtexture */ -#define _gloffset_TexSubImage1DEXT (_EXTBASE + 7) -#define _gloffset_TexSubImage2DEXT (_EXTBASE + 8) -/*#define _gloffset_TexSubImage3DEXT*/ - -/* 10. GL_EXT_copy_texture */ -#define _gloffset_CopyTexImage1DEXT (_EXTBASE + 9) -#define _gloffset_CopyTexImage2DEXT (_EXTBASE + 10) -#define _gloffset_CopyTexSubImage1DEXT (_EXTBASE + 11) -#define _gloffset_CopyTexSubImage2DEXT (_EXTBASE + 12) -/*#define _gloffset_CopyTexSubImage3DEXT*/ - -/* 11. GL_EXT_histogram */ -#define _gloffset_GetHistogramEXT (_EXTBASE + 13) -#define _gloffset_GetHistogramParameterfvEXT (_EXTBASE + 15) -#define _gloffset_GetHistogramParameterivEXT (_EXTBASE + 14) -#define _gloffset_GetMinmaxEXT (_EXTBASE + 16) -#define _gloffset_GetMinmaxParameterfvEXT (_EXTBASE + 18) -#define _gloffset_GetMinmaxParameterivEXT (_EXTBASE + 17) -#define _gloffset_HistogramEXT (_EXTBASE + 19) -#define _gloffset_MinmaxEXT (_EXTBASE + 20) -#define _gloffset_ResetHistogramEXT (_EXTBASE + 21) -#define _gloffset_ResetMinmaxEXT (_EXTBASE + 22) - -/* 12. GL_EXT_convolution */ -#define _gloffset_ConvolutionFilter1DEXT (_EXTBASE + 23) -#define _gloffset_ConvolutionFilter2DEXT (_EXTBASE + 24) -#define _gloffset_ConvolutionParameterfEXT (_EXTBASE + 25) -#define _gloffset_ConvolutionParameterfvEXT (_EXTBASE + 26) -#define _gloffset_ConvolutionParameteriEXT (_EXTBASE + 27) -#define _gloffset_ConvolutionParameterivEXT (_EXTBASE + 28) -#define _gloffset_CopyConvolutionFilter1DEXT (_EXTBASE + 29) -#define _gloffset_CopyConvolutionFilter2DEXT (_EXTBASE + 30) -#define _gloffset_GetConvolutionFilterEXT (_EXTBASE + 31) -#define _gloffset_GetConvolutionParameterivEXT (_EXTBASE + 32) -#define _gloffset_GetConvolutionParameterfvEXT (_EXTBASE + 33) -#define _gloffset_GetSeparableFilterEXT (_EXTBASE + 34) -#define _gloffset_SeparableFilter2DEXT (_EXTBASE + 35) - -/* 13. GL_SGI_color_matrix - no functions */ - -/* 14. GL_SGI_color_table */ -#define _gloffset_ColorTableSGI (_EXTBASE + 36) -#define _gloffset_ColorTableParameterfvSGI (_EXTBASE + 37) -#define _gloffset_ColorTableParameterivSGI (_EXTBASE + 38) -#define _gloffset_CopyColorTableSGI (_EXTBASE + 39) -#define _gloffset_GetColorTableSGI (_EXTBASE + 40) -#define _gloffset_GetColorTableParameterfvSGI (_EXTBASE + 41) -#define _gloffset_GetColorTableParameterivSGI (_EXTBASE + 42) - -/* 15. GL_SGIS_pixel_texture */ -#define _gloffset_PixelTexGenParameterfSGIS (_EXTBASE + 43) -#define _gloffset_PixelTexGenParameteriSGIS (_EXTBASE + 44) -#define _gloffset_GetPixelTexGenParameterfvSGIS (_EXTBASE + 45) -#define _gloffset_GetPixelTexGenParameterivSGIS (_EXTBASE + 46) - -/* 16. GL_SGIS_texture4D */ -#define _gloffset_TexImage4DSGIS (_EXTBASE + 47) -#define _gloffset_TexSubImage4DSGIS (_EXTBASE + 48) - -/* 17. GL_SGI_texture_color_table - no functions */ - -/* 18. GL_EXT_cmyka - no functions */ - -/* 19. ??? */ - -/* 20. GL_EXT_texture_object */ -#define _gloffset_AreTexturesResidentEXT (_EXTBASE + 49) -#define _gloffset_BindTextureEXT (_EXTBASE + 50) -#define _gloffset_DeleteTexturesEXT (_EXTBASE + 51) -#define _gloffset_GenTexturesEXT (_EXTBASE + 52) -#define _gloffset_IsTextureEXT (_EXTBASE + 53) -#define _gloffset_PrioritizeTexturesEXT (_EXTBASE + 54) - -/* 21. GL_SGIS_detail_texture */ -#define _gloffset_DetailTexFuncSGIS (_EXTBASE + 55) -#define _gloffset_GetDetailTexFuncSGIS (_EXTBASE + 56) - -/* 22. GL_SGIS_sharpen_texture */ -#define _gloffset_GetSharpenTexFuncSGIS (_EXTBASE + 57) -#define _gloffset_SharpenTexFuncSGIS (_EXTBASE + 58) - -/* 23. GL_EXT_packed_pixels - no functions */ - -/* 24. GL_SGIS_texture_lod - no functions */ - -/* 25. GL_SGIS_multisample */ -#define _gloffset_SampleMaskSGIS (_EXTBASE + 54) -#define _gloffset_SamplePatternSGIS (_EXTBASE + 55) - -/* 26. ??? */ - -/* 27. GL_EXT_rescale_normal - no functions */ - -/* 28. GLX_EXT_visual_info - no functions */ - -/* 29. ??? */ - -/* 30. GL_EXT_vertex_array */ -#define _gloffset_ArrayElementEXT (_EXTBASE + 56) -#define _gloffset_ColorPointerEXT (_EXTBASE + 57) -#define _gloffset_DrawArraysEXT (_EXTBASE + 58) -#define _gloffset_EdgeFlagPointerEXT (_EXTBASE + 59) -#define _gloffset_GetPointervEXT (_EXTBASE + 60) -#define _gloffset_IndexPointerEXT (_EXTBASE + 61) -#define _gloffset_NormalPointerEXT (_EXTBASE + 62) -#define _gloffset_TexCoordPointerEXT (_EXTBASE + 63) -#define _gloffset_VertexPointerEXT (_EXTBASE + 64) - -/* 31. GL_EXT_misc_attribute - no functions */ - -/* 32. GL_SGIS_generate_mipmap - no functions */ - -/* 33. GL_SGIX_clipmap - no functions */ - -/* 34. GL_SGIX_shadow - no functions */ - -/* 35. GL_SGIS_texture_edge_clamp - no functions */ - -/* 36. GL_SGIS_texture_border_clamp - no functions */ - -/* 37. GL_EXT_blend_minmax */ -#define _gloffset_BlendEquationEXT (_EXTBASE + 65) - -/* 38. GL_EXT_blend_subtract - no functions */ - -/* 39. GL_EXT_blend_logic_op - no functions */ - -/* 40. GLX_SGI_swap_control - GLX functions */ - -/* 41. GLX_SGI_video_sync - GLX functions */ - -/* 42. GLX_SGI_make_current_read - GLX functions */ - -/* 43. GLX_SGIX_video_source - GLX functions */ - -/* 44. GLX_EXT_visual_rating - no functions */ - -/* 45. GL_SGIX_interlace - no functions */ - -/* 46. ??? */ - -/* 47. GLX_EXT_import_context - GLX functions */ - -/* 48. ??? */ - -/* 49. GLX_SGIX_fbconfig - some GLX functions */ - -/* 50. GLX_SGIX_pbuffer - GLX functions */ - -/* 51. GL_SGIS_texture_select - no functions */ - -/* 52. GL_SGIX_sprite */ -#define _gloffset_SpriteParameterfSGIX (_EXTBASE + 66) -#define _gloffset_SpriteParameterfvSGIX (_EXTBASE + 67) -#define _gloffset_SpriteParameteriSGIX (_EXTBASE + 68) -#define _gloffset_SpriteParameterivSGIX (_EXTBASE + 69) - -/* 53. ??? */ - -/* 54. GL_EXT_point_parameters */ -#define _gloffset_PointParameterfEXT (_EXTBASE + 70) -#define _gloffset_PointParameterfvEXT (_EXTBASE + 71) - -/* 55. GL_SGIX_instruments */ -#define _gloffset_InstrumentsBufferSGIX (_EXTBASE + 72) -#define _gloffset_StartInstrumentsSGIX (_EXTBASE + 73) -#define _gloffset_StopInstrumentsSGIX (_EXTBASE + 74) -#define _gloffset_ReadInstrumentsSGIX (_EXTBASE + 75) -#define _gloffset_PollInstrumentsSGIX (_EXTBASE + 76) -#define _gloffset_GetInstrumentsSGIX (_EXTBASE + 77) - -/* 56. GL_SGIX_texture_scale_bias - no functions */ - -/* 57. GL_SGIX_framezoom */ -#define _gloffset_FrameZoomSGIX (_EXTBASE + 78) - -/* 58. GL_SGIX_tag_sample_buffer - no functions */ - -/* 59. ??? */ - -/* 60. GL_SGIX_reference_plane */ -#define _gloffset_ReferencePlaneSGIX (_EXTBASE + 79) - -/* 61. GL_SGIX_flush_raster */ -#define _gloffset_FlushRasterSGIX (_EXTBASE + 80) - -/* 62. GLX_SGI_cushion - GLX functions */ - -/* 63. GL_SGIX_depth_texture - no functions */ - -/* 64. ??? */ - -/* 65. GL_SGIX_fog_offset - no functions */ - -/* 66. GL_HP_image_transform */ -#define _gloffset_GetImageTransformParameterfvHP (_EXTBASE + 81) -#define _gloffset_GetImageTransformParameterivHP (_EXTBASE + 82) -#define _gloffset_ImageTransformParameterfHP (_EXTBASE + 83) -#define _gloffset_ImageTransformParameterfvHP (_EXTBASE + 84) -#define _gloffset_ImageTransformParameteriHP (_EXTBASE + 85) -#define _gloffset_ImageTransformParameterivHP (_EXTBASE + 86) - -/* 67. GL_HP_convolution_border_modes - no functions */ - -/* 68. ??? */ - -/* 69. GL_SGIX_texture_add_env - no functions */ - -/* 70. ??? */ - -/* 71. ??? */ - -/* 72. ??? */ - -/* 73. ??? */ - -/* 74. GL_EXT_color_subtable */ -#define _gloffset_ColorSubTableEXT (_EXTBASE + 87) -#define _gloffset_CopyColorSubTableEXT (_EXTBASE + 88) - -/* 75. GLU_EXT_object_space_tess - GLU functions */ - -/* 76. GL_PGI_vertex_hints - no functions */ - -/* 77. GL_PGI_misc_hints */ -#define _gloffset_HintPGI (_EXTBASE + 89) - -/* 78. GL_EXT_paletted_texture */ -/* ColorSubTableEXT already defined */ -#define _gloffset_ColorTableEXT (_EXTBASE + 91) -#define _gloffset_GetColorTableEXT (_EXTBASE + 92) -#define _gloffset_GetColorTableParameterfvEXT (_EXTBASE + 93) -#define _gloffset_GetColorTableParameterivEXT (_EXTBASE + 94) - -/* 79. GL_EXT_clip_volume_hint - no functions */ - -/* 80. GL_SGIX_list_priority */ -#define _gloffset_GetListParameterfvSGIX (_EXTBASE + 95) -#define _gloffset_GetListParameterivSGIX (_EXTBASE + 96) -#define _gloffset_ListParameterfSGIX (_EXTBASE + 97) -#define _gloffset_ListParameterfvSGIX (_EXTBASE + 98) -#define _gloffset_ListParameteriSGIX (_EXTBASE + 99) -#define _gloffset_ListParameterivSGIX (_EXTBASE + 100) - -/* 81. GL_SGIX_ir_instrument1 - no functions */ - -/* 82. ??? */ - -/* 83. GLX_SGIX_video_resize - GLX functions */ - -/* 84. GL_SGIX_texture_lod_bias - no functions */ - -/* 85. GLU_SGI_filter4_parameters - GLU functions */ - -/* 86. GLX_SGIX_dm_buffer - GLX functions */ - -/* 87. ??? */ - -/* 88. ??? */ - -/* 89. ??? */ - -/* 90. ??? */ - -/* 91. GLX_SGIX_swap_group - GLX functions */ - -/* 92. GLX_SGIX_swap_barrier - GLX functions */ - -/* 93. GL_EXT_index_texture - no functions */ - -/* 94. GL_EXT_index_material */ -#define _gloffset_IndexMaterialEXT (_EXTBASE + 101) - -/* 95. GL_EXT_index_func */ -#define _gloffset_IndexFuncEXT (_EXTBASE + 102) - -/* 96. GL_EXT_index_array_formats - no functions */ - -/* 97. GL_EXT_compiled_vertex_array */ -#define _gloffset_LockArraysEXT (_EXTBASE + 103) -#define _gloffset_UnlockArraysEXT (_EXTBASE + 104) - -/* 98. GL_EXT_cull_vertex */ -#define _gloffset_CullParameterfvEXT (_EXTBASE + 105) -#define _gloffset_CullParameterdvEXT (_EXTBASE + 106) - -/* 99. ??? */ - -/* 100. GLU_EXT_nurbs_tessellator - GLU functions */ - -/* 173. GL_EXT/INGR_blend_func_separate */ -#define _gloffset_BlendFuncSeparateINGR (_EXTBASE + 107) - -/* GL_MESA_window_pos */ -#define _gloffset_WindowPos2dMESA (_EXTBASE + 108) -#define _gloffset_WindowPos2dvMESA (_EXTBASE + 109) -#define _gloffset_WindowPos2fMESA (_EXTBASE + 110) -#define _gloffset_WindowPos2fvMESA (_EXTBASE + 111) -#define _gloffset_WindowPos2iMESA (_EXTBASE + 112) -#define _gloffset_WindowPos2ivMESA (_EXTBASE + 113) -#define _gloffset_WindowPos2sMESA (_EXTBASE + 114) -#define _gloffset_WindowPos2svMESA (_EXTBASE + 115) -#define _gloffset_WindowPos3dMESA (_EXTBASE + 116) -#define _gloffset_WindowPos3dvMESA (_EXTBASE + 117) -#define _gloffset_WindowPos3fMESA (_EXTBASE + 118) -#define _gloffset_WindowPos3fvMESA (_EXTBASE + 119) -#define _gloffset_WindowPos3iMESA (_EXTBASE + 120) -#define _gloffset_WindowPos3ivMESA (_EXTBASE + 121) -#define _gloffset_WindowPos3sMESA (_EXTBASE + 122) -#define _gloffset_WindowPos3svMESA (_EXTBASE + 123) -#define _gloffset_WindowPos4dMESA (_EXTBASE + 124) -#define _gloffset_WindowPos4dvMESA (_EXTBASE + 125) -#define _gloffset_WindowPos4fMESA (_EXTBASE + 126) -#define _gloffset_WindowPos4fvMESA (_EXTBASE + 127) -#define _gloffset_WindowPos4iMESA (_EXTBASE + 128) -#define _gloffset_WindowPos4ivMESA (_EXTBASE + 129) -#define _gloffset_WindowPos4sMESA (_EXTBASE + 130) -#define _gloffset_WindowPos4svMESA (_EXTBASE + 131) - -/* GL_MESA_resize_buffers */ -#define _gloffset_ResizeBuffersMESA (_EXTBASE + 132) - -/* GL_ARB_transpose_matrix */ -#define _gloffset_LoadTransposeMatrixdARB (_EXTBASE + 133) -#define _gloffset_LoadTransposeMatrixfARB (_EXTBASE + 134) -#define _gloffset_MultTransposeMatrixdARB (_EXTBASE + 135) -#define _gloffset_MultTransposeMatrixfARB (_EXTBASE + 136) - - +/* DO NOT EDIT - This file generated automatically */ +#ifndef _GLAPI_OFFSETS_H_ +#define _GLAPI_OFFSETS_H_ + +#define _gloffset_NewList 0 +#define _gloffset_EndList 1 +#define _gloffset_CallList 2 +#define _gloffset_CallLists 3 +#define _gloffset_DeleteLists 4 +#define _gloffset_GenLists 5 +#define _gloffset_ListBase 6 +#define _gloffset_Begin 7 +#define _gloffset_Bitmap 8 +#define _gloffset_Color3b 9 +#define _gloffset_Color3bv 10 +#define _gloffset_Color3d 11 +#define _gloffset_Color3dv 12 +#define _gloffset_Color3f 13 +#define _gloffset_Color3fv 14 +#define _gloffset_Color3i 15 +#define _gloffset_Color3iv 16 +#define _gloffset_Color3s 17 +#define _gloffset_Color3sv 18 +#define _gloffset_Color3ub 19 +#define _gloffset_Color3ubv 20 +#define _gloffset_Color3ui 21 +#define _gloffset_Color3uiv 22 +#define _gloffset_Color3us 23 +#define _gloffset_Color3usv 24 +#define _gloffset_Color4b 25 +#define _gloffset_Color4bv 26 +#define _gloffset_Color4d 27 +#define _gloffset_Color4dv 28 +#define _gloffset_Color4f 29 +#define _gloffset_Color4fv 30 +#define _gloffset_Color4i 31 +#define _gloffset_Color4iv 32 +#define _gloffset_Color4s 33 +#define _gloffset_Color4sv 34 +#define _gloffset_Color4ub 35 +#define _gloffset_Color4ubv 36 +#define _gloffset_Color4ui 37 +#define _gloffset_Color4uiv 38 +#define _gloffset_Color4us 39 +#define _gloffset_Color4usv 40 +#define _gloffset_EdgeFlag 41 +#define _gloffset_EdgeFlagv 42 +#define _gloffset_End 43 +#define _gloffset_Indexd 44 +#define _gloffset_Indexdv 45 +#define _gloffset_Indexf 46 +#define _gloffset_Indexfv 47 +#define _gloffset_Indexi 48 +#define _gloffset_Indexiv 49 +#define _gloffset_Indexs 50 +#define _gloffset_Indexsv 51 +#define _gloffset_Normal3b 52 +#define _gloffset_Normal3bv 53 +#define _gloffset_Normal3d 54 +#define _gloffset_Normal3dv 55 +#define _gloffset_Normal3f 56 +#define _gloffset_Normal3fv 57 +#define _gloffset_Normal3i 58 +#define _gloffset_Normal3iv 59 +#define _gloffset_Normal3s 60 +#define _gloffset_Normal3sv 61 +#define _gloffset_RasterPos2d 62 +#define _gloffset_RasterPos2dv 63 +#define _gloffset_RasterPos2f 64 +#define _gloffset_RasterPos2fv 65 +#define _gloffset_RasterPos2i 66 +#define _gloffset_RasterPos2iv 67 +#define _gloffset_RasterPos2s 68 +#define _gloffset_RasterPos2sv 69 +#define _gloffset_RasterPos3d 70 +#define _gloffset_RasterPos3dv 71 +#define _gloffset_RasterPos3f 72 +#define _gloffset_RasterPos3fv 73 +#define _gloffset_RasterPos3i 74 +#define _gloffset_RasterPos3iv 75 +#define _gloffset_RasterPos3s 76 +#define _gloffset_RasterPos3sv 77 +#define _gloffset_RasterPos4d 78 +#define _gloffset_RasterPos4dv 79 +#define _gloffset_RasterPos4f 80 +#define _gloffset_RasterPos4fv 81 +#define _gloffset_RasterPos4i 82 +#define _gloffset_RasterPos4iv 83 +#define _gloffset_RasterPos4s 84 +#define _gloffset_RasterPos4sv 85 +#define _gloffset_Rectd 86 +#define _gloffset_Rectdv 87 +#define _gloffset_Rectf 88 +#define _gloffset_Rectfv 89 +#define _gloffset_Recti 90 +#define _gloffset_Rectiv 91 +#define _gloffset_Rects 92 +#define _gloffset_Rectsv 93 +#define _gloffset_TexCoord1d 94 +#define _gloffset_TexCoord1dv 95 +#define _gloffset_TexCoord1f 96 +#define _gloffset_TexCoord1fv 97 +#define _gloffset_TexCoord1i 98 +#define _gloffset_TexCoord1iv 99 +#define _gloffset_TexCoord1s 100 +#define _gloffset_TexCoord1sv 101 +#define _gloffset_TexCoord2d 102 +#define _gloffset_TexCoord2dv 103 +#define _gloffset_TexCoord2f 104 +#define _gloffset_TexCoord2fv 105 +#define _gloffset_TexCoord2i 106 +#define _gloffset_TexCoord2iv 107 +#define _gloffset_TexCoord2s 108 +#define _gloffset_TexCoord2sv 109 +#define _gloffset_TexCoord3d 110 +#define _gloffset_TexCoord3dv 111 +#define _gloffset_TexCoord3f 112 +#define _gloffset_TexCoord3fv 113 +#define _gloffset_TexCoord3i 114 +#define _gloffset_TexCoord3iv 115 +#define _gloffset_TexCoord3s 116 +#define _gloffset_TexCoord3sv 117 +#define _gloffset_TexCoord4d 118 +#define _gloffset_TexCoord4dv 119 +#define _gloffset_TexCoord4f 120 +#define _gloffset_TexCoord4fv 121 +#define _gloffset_TexCoord4i 122 +#define _gloffset_TexCoord4iv 123 +#define _gloffset_TexCoord4s 124 +#define _gloffset_TexCoord4sv 125 +#define _gloffset_Vertex2d 126 +#define _gloffset_Vertex2dv 127 +#define _gloffset_Vertex2f 128 +#define _gloffset_Vertex2fv 129 +#define _gloffset_Vertex2i 130 +#define _gloffset_Vertex2iv 131 +#define _gloffset_Vertex2s 132 +#define _gloffset_Vertex2sv 133 +#define _gloffset_Vertex3d 134 +#define _gloffset_Vertex3dv 135 +#define _gloffset_Vertex3f 136 +#define _gloffset_Vertex3fv 137 +#define _gloffset_Vertex3i 138 +#define _gloffset_Vertex3iv 139 +#define _gloffset_Vertex3s 140 +#define _gloffset_Vertex3sv 141 +#define _gloffset_Vertex4d 142 +#define _gloffset_Vertex4dv 143 +#define _gloffset_Vertex4f 144 +#define _gloffset_Vertex4fv 145 +#define _gloffset_Vertex4i 146 +#define _gloffset_Vertex4iv 147 +#define _gloffset_Vertex4s 148 +#define _gloffset_Vertex4sv 149 +#define _gloffset_ClipPlane 150 +#define _gloffset_ColorMaterial 151 +#define _gloffset_CullFace 152 +#define _gloffset_Fogf 153 +#define _gloffset_Fogfv 154 +#define _gloffset_Fogi 155 +#define _gloffset_Fogiv 156 +#define _gloffset_FrontFace 157 +#define _gloffset_Hint 158 +#define _gloffset_Lightf 159 +#define _gloffset_Lightfv 160 +#define _gloffset_Lighti 161 +#define _gloffset_Lightiv 162 +#define _gloffset_LightModelf 163 +#define _gloffset_LightModelfv 164 +#define _gloffset_LightModeli 165 +#define _gloffset_LightModeliv 166 +#define _gloffset_LineStipple 167 +#define _gloffset_LineWidth 168 +#define _gloffset_Materialf 169 +#define _gloffset_Materialfv 170 +#define _gloffset_Materiali 171 +#define _gloffset_Materialiv 172 +#define _gloffset_PointSize 173 +#define _gloffset_PolygonMode 174 +#define _gloffset_PolygonStipple 175 +#define _gloffset_Scissor 176 +#define _gloffset_ShadeModel 177 +#define _gloffset_TexParameterf 178 +#define _gloffset_TexParameterfv 179 +#define _gloffset_TexParameteri 180 +#define _gloffset_TexParameteriv 181 +#define _gloffset_TexImage1D 182 +#define _gloffset_TexImage2D 183 +#define _gloffset_TexEnvf 184 +#define _gloffset_TexEnvfv 185 +#define _gloffset_TexEnvi 186 +#define _gloffset_TexEnviv 187 +#define _gloffset_TexGend 188 +#define _gloffset_TexGendv 189 +#define _gloffset_TexGenf 190 +#define _gloffset_TexGenfv 191 +#define _gloffset_TexGeni 192 +#define _gloffset_TexGeniv 193 +#define _gloffset_FeedbackBuffer 194 +#define _gloffset_SelectBuffer 195 +#define _gloffset_RenderMode 196 +#define _gloffset_InitNames 197 +#define _gloffset_LoadName 198 +#define _gloffset_PassThrough 199 +#define _gloffset_PopName 200 +#define _gloffset_PushName 201 +#define _gloffset_DrawBuffer 202 +#define _gloffset_Clear 203 +#define _gloffset_ClearAccum 204 +#define _gloffset_ClearIndex 205 +#define _gloffset_ClearColor 206 +#define _gloffset_ClearStencil 207 +#define _gloffset_ClearDepth 208 +#define _gloffset_StencilMask 209 +#define _gloffset_ColorMask 210 +#define _gloffset_DepthMask 211 +#define _gloffset_IndexMask 212 +#define _gloffset_Accum 213 +#define _gloffset_Disable 214 +#define _gloffset_Enable 215 +#define _gloffset_Finish 216 +#define _gloffset_Flush 217 +#define _gloffset_PopAttrib 218 +#define _gloffset_PushAttrib 219 +#define _gloffset_Map1d 220 +#define _gloffset_Map1f 221 +#define _gloffset_Map2d 222 +#define _gloffset_Map2f 223 +#define _gloffset_MapGrid1d 224 +#define _gloffset_MapGrid1f 225 +#define _gloffset_MapGrid2d 226 +#define _gloffset_MapGrid2f 227 +#define _gloffset_EvalCoord1d 228 +#define _gloffset_EvalCoord1dv 229 +#define _gloffset_EvalCoord1f 230 +#define _gloffset_EvalCoord1fv 231 +#define _gloffset_EvalCoord2d 232 +#define _gloffset_EvalCoord2dv 233 +#define _gloffset_EvalCoord2f 234 +#define _gloffset_EvalCoord2fv 235 +#define _gloffset_EvalMesh1 236 +#define _gloffset_EvalPoint1 237 +#define _gloffset_EvalMesh2 238 +#define _gloffset_EvalPoint2 239 +#define _gloffset_AlphaFunc 240 +#define _gloffset_BlendFunc 241 +#define _gloffset_LogicOp 242 +#define _gloffset_StencilFunc 243 +#define _gloffset_StencilOp 244 +#define _gloffset_DepthFunc 245 +#define _gloffset_PixelZoom 246 +#define _gloffset_PixelTransferf 247 +#define _gloffset_PixelTransferi 248 +#define _gloffset_PixelStoref 249 +#define _gloffset_PixelStorei 250 +#define _gloffset_PixelMapfv 251 +#define _gloffset_PixelMapuiv 252 +#define _gloffset_PixelMapusv 253 +#define _gloffset_ReadBuffer 254 +#define _gloffset_CopyPixels 255 +#define _gloffset_ReadPixels 256 +#define _gloffset_DrawPixels 257 +#define _gloffset_GetBooleanv 258 +#define _gloffset_GetClipPlane 259 +#define _gloffset_GetDoublev 260 +#define _gloffset_GetError 261 +#define _gloffset_GetFloatv 262 +#define _gloffset_GetIntegerv 263 +#define _gloffset_GetLightfv 264 +#define _gloffset_GetLightiv 265 +#define _gloffset_GetMapdv 266 +#define _gloffset_GetMapfv 267 +#define _gloffset_GetMapiv 268 +#define _gloffset_GetMaterialfv 269 +#define _gloffset_GetMaterialiv 270 +#define _gloffset_GetPixelMapfv 271 +#define _gloffset_GetPixelMapuiv 272 +#define _gloffset_GetPixelMapusv 273 +#define _gloffset_GetPolygonStipple 274 +#define _gloffset_GetString 275 +#define _gloffset_GetTexEnvfv 276 +#define _gloffset_GetTexEnviv 277 +#define _gloffset_GetTexGendv 278 +#define _gloffset_GetTexGenfv 279 +#define _gloffset_GetTexGeniv 280 +#define _gloffset_GetTexImage 281 +#define _gloffset_GetTexParameterfv 282 +#define _gloffset_GetTexParameteriv 283 +#define _gloffset_GetTexLevelParameterfv 284 +#define _gloffset_GetTexLevelParameteriv 285 +#define _gloffset_IsEnabled 286 +#define _gloffset_IsList 287 +#define _gloffset_DepthRange 288 +#define _gloffset_Frustum 289 +#define _gloffset_LoadIdentity 290 +#define _gloffset_LoadMatrixf 291 +#define _gloffset_LoadMatrixd 292 +#define _gloffset_MatrixMode 293 +#define _gloffset_MultMatrixf 294 +#define _gloffset_MultMatrixd 295 +#define _gloffset_Ortho 296 +#define _gloffset_PopMatrix 297 +#define _gloffset_PushMatrix 298 +#define _gloffset_Rotated 299 +#define _gloffset_Rotatef 300 +#define _gloffset_Scaled 301 +#define _gloffset_Scalef 302 +#define _gloffset_Translated 303 +#define _gloffset_Translatef 304 +#define _gloffset_Viewport 305 +#define _gloffset_ArrayElement 306 +#define _gloffset_BindTexture 307 +#define _gloffset_ColorPointer 308 +#define _gloffset_DisableClientState 309 +#define _gloffset_DrawArrays 310 +#define _gloffset_DrawElements 311 +#define _gloffset_EdgeFlagPointer 312 +#define _gloffset_EnableClientState 313 +#define _gloffset_IndexPointer 314 +#define _gloffset_Indexub 315 +#define _gloffset_Indexubv 316 +#define _gloffset_InterleavedArrays 317 +#define _gloffset_NormalPointer 318 +#define _gloffset_PolygonOffset 319 +#define _gloffset_TexCoordPointer 320 +#define _gloffset_VertexPointer 321 +#define _gloffset_AreTexturesResident 322 +#define _gloffset_CopyTexImage1D 323 +#define _gloffset_CopyTexImage2D 324 +#define _gloffset_CopyTexSubImage1D 325 +#define _gloffset_CopyTexSubImage2D 326 +#define _gloffset_DeleteTextures 327 +#define _gloffset_GenTextures 328 +#define _gloffset_GetPointerv 329 +#define _gloffset_IsTexture 330 +#define _gloffset_PrioritizeTextures 331 +#define _gloffset_TexSubImage1D 332 +#define _gloffset_TexSubImage2D 333 +#define _gloffset_PopClientAttrib 334 +#define _gloffset_PushClientAttrib 335 +#define _gloffset_BlendColor 336 +#define _gloffset_BlendEquation 337 +#define _gloffset_DrawRangeElements 338 +#define _gloffset_ColorTable 339 +#define _gloffset_ColorTableParameterfv 340 +#define _gloffset_ColorTableParameteriv 341 +#define _gloffset_CopyColorTable 342 +#define _gloffset_GetColorTable 343 +#define _gloffset_GetColorTableParameterfv 344 +#define _gloffset_GetColorTableParameteriv 345 +#define _gloffset_ColorSubTable 346 +#define _gloffset_CopyColorSubTable 347 +#define _gloffset_ConvolutionFilter1D 348 +#define _gloffset_ConvolutionFilter2D 349 +#define _gloffset_ConvolutionParameterf 350 +#define _gloffset_ConvolutionParameterfv 351 +#define _gloffset_ConvolutionParameteri 352 +#define _gloffset_ConvolutionParameteriv 353 +#define _gloffset_CopyConvolutionFilter1D 354 +#define _gloffset_CopyConvolutionFilter2D 355 +#define _gloffset_GetConvolutionFilter 356 +#define _gloffset_GetConvolutionParameterfv 357 +#define _gloffset_GetConvolutionParameteriv 358 +#define _gloffset_GetSeparableFilter 359 +#define _gloffset_SeparableFilter2D 360 +#define _gloffset_GetHistogram 361 +#define _gloffset_GetHistogramParameterfv 362 +#define _gloffset_GetHistogramParameteriv 363 +#define _gloffset_GetMinmax 364 +#define _gloffset_GetMinmaxParameterfv 365 +#define _gloffset_GetMinmaxParameteriv 366 +#define _gloffset_Histogram 367 +#define _gloffset_Minmax 368 +#define _gloffset_ResetHistogram 369 +#define _gloffset_ResetMinmax 370 +#define _gloffset_TexImage3D 371 +#define _gloffset_TexSubImage3D 372 +#define _gloffset_CopyTexSubImage3D 373 +#define _gloffset_ActiveTextureARB 374 +#define _gloffset_ClientActiveTextureARB 375 +#define _gloffset_MultiTexCoord1dARB 376 +#define _gloffset_MultiTexCoord1dvARB 377 +#define _gloffset_MultiTexCoord1fARB 378 +#define _gloffset_MultiTexCoord1fvARB 379 +#define _gloffset_MultiTexCoord1iARB 380 +#define _gloffset_MultiTexCoord1ivARB 381 +#define _gloffset_MultiTexCoord1sARB 382 +#define _gloffset_MultiTexCoord1svARB 383 +#define _gloffset_MultiTexCoord2dARB 384 +#define _gloffset_MultiTexCoord2dvARB 385 +#define _gloffset_MultiTexCoord2fARB 386 +#define _gloffset_MultiTexCoord2fvARB 387 +#define _gloffset_MultiTexCoord2iARB 388 +#define _gloffset_MultiTexCoord2ivARB 389 +#define _gloffset_MultiTexCoord2sARB 390 +#define _gloffset_MultiTexCoord2svARB 391 +#define _gloffset_MultiTexCoord3dARB 392 +#define _gloffset_MultiTexCoord3dvARB 393 +#define _gloffset_MultiTexCoord3fARB 394 +#define _gloffset_MultiTexCoord3fvARB 395 +#define _gloffset_MultiTexCoord3iARB 396 +#define _gloffset_MultiTexCoord3ivARB 397 +#define _gloffset_MultiTexCoord3sARB 398 +#define _gloffset_MultiTexCoord3svARB 399 +#define _gloffset_MultiTexCoord4dARB 400 +#define _gloffset_MultiTexCoord4dvARB 401 +#define _gloffset_MultiTexCoord4fARB 402 +#define _gloffset_MultiTexCoord4fvARB 403 +#define _gloffset_MultiTexCoord4iARB 404 +#define _gloffset_MultiTexCoord4ivARB 405 +#define _gloffset_MultiTexCoord4sARB 406 +#define _gloffset_MultiTexCoord4svARB 407 +#define _gloffset_LoadTransposeMatrixfARB 408 +#define _gloffset_LoadTransposeMatrixdARB 409 +#define _gloffset_MultTransposeMatrixfARB 410 +#define _gloffset_MultTransposeMatrixdARB 411 +#define _gloffset_SampleCoverageARB 412 +#define _gloffset_SamplePassARB 413 +#define _gloffset_PolygonOffsetEXT 414 +#define _gloffset_GetTexFilterFuncSGIS 415 +#define _gloffset_TexFilterFuncSGIS 416 +#define _gloffset_GetHistogramEXT 417 +#define _gloffset_GetHistogramParameterfvEXT 418 +#define _gloffset_GetHistogramParameterivEXT 419 +#define _gloffset_GetMinmaxEXT 420 +#define _gloffset_GetMinmaxParameterfvEXT 421 +#define _gloffset_GetMinmaxParameterivEXT 422 +#define _gloffset_GetConvolutionFilterEXT 423 +#define _gloffset_GetConvolutionParameterfvEXT 424 +#define _gloffset_GetConvolutionParameterivEXT 425 +#define _gloffset_GetSeparableFilterEXT 426 +#define _gloffset_GetColorTableSGI 427 +#define _gloffset_GetColorTableParameterfvSGI 428 +#define _gloffset_GetColorTableParameterivSGI 429 +#define _gloffset_PixelTexGenSGIX 430 +#define _gloffset_PixelTexGenParameteriSGIS 431 +#define _gloffset_PixelTexGenParameterivSGIS 432 +#define _gloffset_PixelTexGenParameterfSGIS 433 +#define _gloffset_PixelTexGenParameterfvSGIS 434 +#define _gloffset_GetPixelTexGenParameterivSGIS 435 +#define _gloffset_GetPixelTexGenParameterfvSGIS 436 +#define _gloffset_TexImage4DSGIS 437 +#define _gloffset_TexSubImage4DSGIS 438 +#define _gloffset_AreTexturesResidentEXT 439 +#define _gloffset_GenTexturesEXT 440 +#define _gloffset_IsTextureEXT 441 +#define _gloffset_DetailTexFuncSGIS 442 +#define _gloffset_GetDetailTexFuncSGIS 443 +#define _gloffset_SharpenTexFuncSGIS 444 +#define _gloffset_GetSharpenTexFuncSGIS 445 +#define _gloffset_SampleMaskSGIS 446 +#define _gloffset_SamplePatternSGIS 447 +#define _gloffset_ColorPointerEXT 448 +#define _gloffset_EdgeFlagPointerEXT 449 +#define _gloffset_IndexPointerEXT 450 +#define _gloffset_NormalPointerEXT 451 +#define _gloffset_TexCoordPointerEXT 452 +#define _gloffset_VertexPointerEXT 453 +#define _gloffset_SpriteParameterfSGIX 454 +#define _gloffset_SpriteParameterfvSGIX 455 +#define _gloffset_SpriteParameteriSGIX 456 +#define _gloffset_SpriteParameterivSGIX 457 +#define _gloffset_PointParameterfEXT 458 +#define _gloffset_PointParameterfvEXT 459 +#define _gloffset_GetInstrumentsSGIX 460 +#define _gloffset_InstrumentsBufferSGIX 461 +#define _gloffset_PollInstrumentsSGIX 462 +#define _gloffset_ReadInstrumentsSGIX 463 +#define _gloffset_StartInstrumentsSGIX 464 +#define _gloffset_StopInstrumentsSGIX 465 +#define _gloffset_FrameZoomSGIX 466 +#define _gloffset_TagSampleBufferSGIX 467 +#define _gloffset_ReferencePlaneSGIX 468 +#define _gloffset_FlushRasterSGIX 469 +#define _gloffset_GetListParameterfvSGIX 470 +#define _gloffset_GetListParameterivSGIX 471 +#define _gloffset_ListParameterfSGIX 472 +#define _gloffset_ListParameterfvSGIX 473 +#define _gloffset_ListParameteriSGIX 474 +#define _gloffset_ListParameterivSGIX 475 +#define _gloffset_FragmentColorMaterialSGIX 476 +#define _gloffset_FragmentLightfSGIX 477 +#define _gloffset_FragmentLightfvSGIX 478 +#define _gloffset_FragmentLightiSGIX 479 +#define _gloffset_FragmentLightivSGIX 480 +#define _gloffset_FragmentLightModelfSGIX 481 +#define _gloffset_FragmentLightModelfvSGIX 482 +#define _gloffset_FragmentLightModeliSGIX 483 +#define _gloffset_FragmentLightModelivSGIX 484 +#define _gloffset_FragmentMaterialfSGIX 485 +#define _gloffset_FragmentMaterialfvSGIX 486 +#define _gloffset_FragmentMaterialiSGIX 487 +#define _gloffset_FragmentMaterialivSGIX 488 +#define _gloffset_GetFragmentLightfvSGIX 489 +#define _gloffset_GetFragmentLightivSGIX 490 +#define _gloffset_GetFragmentMaterialfvSGIX 491 +#define _gloffset_GetFragmentMaterialivSGIX 492 +#define _gloffset_LightEnviSGIX 493 +#define _gloffset_VertexWeightfEXT 494 +#define _gloffset_VertexWeightfvEXT 495 +#define _gloffset_VertexWeightPointerEXT 496 +#define _gloffset_FlushVertexArrayRangeNV 497 +#define _gloffset_VertexArrayRangeNV 498 +#define _gloffset_CombinerParameterfvNV 499 +#define _gloffset_CombinerParameterfNV 500 +#define _gloffset_CombinerParameterivNV 501 +#define _gloffset_CombinerParameteriNV 502 +#define _gloffset_CombinerInputNV 503 +#define _gloffset_CombinerOutputNV 504 +#define _gloffset_FinalCombinerInputNV 505 +#define _gloffset_GetCombinerInputParameterfvNV 506 +#define _gloffset_GetCombinerInputParameterivNV 507 +#define _gloffset_GetCombinerOutputParameterfvNV 508 +#define _gloffset_GetCombinerOutputParameterivNV 509 +#define _gloffset_GetFinalCombinerInputParameterfvNV 510 +#define _gloffset_GetFinalCombinerInputParameterivNV 511 +#define _gloffset_ResizeBuffersMESA 512 +#define _gloffset_WindowPos2dMESA 513 +#define _gloffset_WindowPos2dvMESA 514 +#define _gloffset_WindowPos2fMESA 515 +#define _gloffset_WindowPos2fvMESA 516 +#define _gloffset_WindowPos2iMESA 517 +#define _gloffset_WindowPos2ivMESA 518 +#define _gloffset_WindowPos2sMESA 519 +#define _gloffset_WindowPos2svMESA 520 +#define _gloffset_WindowPos3dMESA 521 +#define _gloffset_WindowPos3dvMESA 522 +#define _gloffset_WindowPos3fMESA 523 +#define _gloffset_WindowPos3fvMESA 524 +#define _gloffset_WindowPos3iMESA 525 +#define _gloffset_WindowPos3ivMESA 526 +#define _gloffset_WindowPos3sMESA 527 +#define _gloffset_WindowPos3svMESA 528 +#define _gloffset_WindowPos4dMESA 529 +#define _gloffset_WindowPos4dvMESA 530 +#define _gloffset_WindowPos4fMESA 531 +#define _gloffset_WindowPos4fvMESA 532 +#define _gloffset_WindowPos4iMESA 533 +#define _gloffset_WindowPos4ivMESA 534 +#define _gloffset_WindowPos4sMESA 535 +#define _gloffset_WindowPos4svMESA 536 +#define _gloffset_BlendFuncSeparateEXT 537 +#define _gloffset_IndexMaterialEXT 538 +#define _gloffset_IndexFuncEXT 539 +#define _gloffset_LockArraysEXT 540 +#define _gloffset_UnlockArraysEXT 541 +#define _gloffset_CullParameterdvEXT 542 +#define _gloffset_CullParameterfvEXT 543 +#define _gloffset_HintPGI 544 +#define _gloffset_FogCoordfEXT 545 +#define _gloffset_FogCoordfvEXT 546 +#define _gloffset_FogCoorddEXT 547 +#define _gloffset_FogCoorddvEXT 548 +#define _gloffset_FogCoordPointerEXT 549 +#define _gloffset_GetColorTableEXT 550 +#define _gloffset_GetColorTableParameterivEXT 551 +#define _gloffset_GetColorTableParameterfvEXT 552 #endif - diff --git a/xc/extras/Mesa/src/glapitable.h b/xc/extras/Mesa/src/glapitable.h index bb49545b8..9e5d121dd 100644 --- a/xc/extras/Mesa/src/glapitable.h +++ b/xc/extras/Mesa/src/glapitable.h @@ -1,853 +1,564 @@ +/* DO NOT EDIT - This file generated automatically */ +#ifndef _GLAPI_TABLE_H_ +#define _GLAPI_TABLE_H_ -/* - * Mesa 3-D graphics library - * Version: 3.3 - * - * Copyright (C) 1999-2000 Brian Paul All Rights Reserved. - * - * Permission is hereby granted, free of charge, to any person obtaining a - * copy of this software and associated documentation files (the "Software"), - * to deal in the Software without restriction, including without limitation - * the rights to use, copy, modify, merge, publish, distribute, sublicense, - * and/or sell copies of the Software, and to permit persons to whom the - * Software is furnished to do so, subject to the following conditions: - * - * The above copyright notice and this permission notice shall be included - * in all copies or substantial portions of the Software. - * - * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS - * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, - * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL - * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN - * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN - * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. - */ +#include <GL/gl.h> - -/* - * This file is not specific to Mesa. It defines a dispatch table - * which could be used by any number of OpenGL implementations. - * It's designed to be gl.h-independent as well. That is, it does - * not depend on any particular extensions being defined in the gl.h - * header. We #define extension symbols (like _GLAPI_EXT_blend_color) - * to determine which entry points to compile. Clients of this dispatcher - * (like Mesa) can #ifdef test these symbols to know how to fill in the - * table. - */ - - -#ifndef _GLAPI_TABLE_H -#define _GLAPI_TABLE_H - - -#include "GL/gl.h" - - -/* - * This struct contains pointers for all the GL API entrypoints - * plus some reserved slots for dynamic extensions. - * - * Strictly speaking, this struct isn't needed if we have assembly - * language entrypoint functions since no knowledge of function - * arguments is needed. - * - * This struct may be replaced by an automatically-generated struct - * using the spec files in the OpenGL SI. - */ struct _glapi_table { - void (*Dummy)(void); - - /* - * OpenGL 1.0 - */ - void (*Accum)(GLenum, GLfloat); - void (*AlphaFunc)(GLenum, GLclampf); - void (*Begin)(GLenum); - void (*Bitmap)(GLsizei, GLsizei, GLfloat, GLfloat, GLfloat, GLfloat, const GLubyte *); - void (*BlendFunc)(GLenum, GLenum); - void (*CallList)(GLuint list); - void (*CallLists)(GLsizei, GLenum, const GLvoid *); - void (*Clear)(GLbitfield); - void (*ClearAccum)(GLfloat, GLfloat, GLfloat, GLfloat); - void (*ClearColor)(GLclampf, GLclampf, GLclampf, GLclampf); - void (*ClearDepth)(GLclampd); - void (*ClearIndex)(GLfloat); - void (*ClearStencil)(GLint); - void (*ClipPlane)(GLenum, const GLdouble *); - void (*Color3b)(GLbyte, GLbyte, GLbyte); - void (*Color3bv)(const GLbyte *); - void (*Color3d)(GLdouble, GLdouble, GLdouble); - void (*Color3dv)(const GLdouble *); - void (*Color3f)(GLfloat, GLfloat, GLfloat); - void (*Color3fv)(const GLfloat *); - void (*Color3i)(GLint, GLint, GLint); - void (*Color3iv)(const GLint *); - void (*Color3s)(GLshort, GLshort, GLshort); - void (*Color3sv)(const GLshort *); - void (*Color3ub)(GLubyte, GLubyte, GLubyte); - void (*Color3ubv)(const GLubyte *); - void (*Color3ui)(GLuint, GLuint, GLuint); - void (*Color3uiv)(const GLuint *); - void (*Color3us)(GLushort, GLushort, GLushort); - void (*Color3usv)(const GLushort *); - void (*Color4b)(GLbyte, GLbyte, GLbyte, GLbyte); - void (*Color4bv)(const GLbyte *); - void (*Color4d)(GLdouble, GLdouble, GLdouble, GLdouble); - void (*Color4dv)(const GLdouble *); - void (*Color4f)(GLfloat, GLfloat, GLfloat, GLfloat); - void (*Color4fv)(const GLfloat *); - void (*Color4i)(GLint, GLint, GLint, GLint); - void (*Color4iv)(const GLint *); - void (*Color4s)(GLshort, GLshort, GLshort, GLshort); - void (*Color4sv)(const GLshort *); - void (*Color4ub)(GLubyte, GLubyte, GLubyte, GLubyte); - void (*Color4ubv)(const GLubyte *); - void (*Color4ui)(GLuint, GLuint, GLuint, GLuint); - void (*Color4uiv)(const GLuint *); - void (*Color4us)(GLushort, GLushort, GLushort, GLushort); - void (*Color4usv)(const GLushort *); - void (*ColorMask)(GLboolean, GLboolean, GLboolean, GLboolean); - void (*ColorMaterial)(GLenum, GLenum); - void (*CopyPixels)(GLint, GLint, GLsizei, GLsizei, GLenum); - void (*CullFace)(GLenum); - void (*DeleteLists)(GLuint, GLsizei); - void (*DepthFunc)(GLenum); - void (*DepthMask)(GLboolean); - void (*DepthRange)(GLclampd, GLclampd); - void (*Disable)(GLenum); - void (*DrawBuffer)(GLenum); - void (*DrawPixels)(GLsizei, GLsizei, GLenum, GLenum, const GLvoid *); - void (*EdgeFlag)(GLboolean); - void (*EdgeFlagv)(const GLboolean *); - void (*Enable)(GLenum); - void (*End)(void); - void (*EndList)(void); - void (*EvalCoord1d)(GLdouble); - void (*EvalCoord1dv)(const GLdouble *); - void (*EvalCoord1f)(GLfloat); - void (*EvalCoord1fv)(const GLfloat *); - void (*EvalCoord2d)(GLdouble u, GLdouble); - void (*EvalCoord2dv)(const GLdouble *); - void (*EvalCoord2f)(GLfloat u, GLfloat); - void (*EvalCoord2fv)(const GLfloat *); - void (*EvalMesh1)(GLenum, GLint, GLint); - void (*EvalMesh2)(GLenum, GLint, GLint, GLint, GLint); - void (*EvalPoint1)(GLint); - void (*EvalPoint2)(GLint, GLint); - void (*FeedbackBuffer)(GLsizei, GLenum, GLfloat *); - void (*Finish)(void); - void (*Flush)(void); - void (*Fogf)(GLenum, GLfloat); - void (*Fogfv)(GLenum, const GLfloat *); - void (*Fogi)(GLenum, GLint); - void (*Fogiv)(GLenum, const GLint *); - void (*FrontFace)(GLenum); - void (*Frustum)(GLdouble, GLdouble, GLdouble, GLdouble, GLdouble, GLdouble); - GLuint (*GenLists)(GLsizei); - void (*GetBooleanv)(GLenum, GLboolean *); - void (*GetClipPlane)(GLenum, GLdouble *); - void (*GetDoublev)(GLenum, GLdouble *); - GLenum (*GetError)(void); - void (*GetFloatv)(GLenum, GLfloat *); - void (*GetIntegerv)(GLenum, GLint *); - void (*GetLightfv)(GLenum light, GLenum, GLfloat *); - void (*GetLightiv)(GLenum light, GLenum, GLint *); - void (*GetMapdv)(GLenum, GLenum, GLdouble *); - void (*GetMapfv)(GLenum, GLenum, GLfloat *); - void (*GetMapiv)(GLenum, GLenum, GLint *); - void (*GetMaterialfv)(GLenum, GLenum, GLfloat *); - void (*GetMaterialiv)(GLenum, GLenum, GLint *); - void (*GetPixelMapfv)(GLenum, GLfloat *); - void (*GetPixelMapuiv)(GLenum, GLuint *); - void (*GetPixelMapusv)(GLenum, GLushort *); - void (*GetPolygonStipple)(GLubyte *); - const GLubyte* (*GetString)(GLenum name); - void (*GetTexEnvfv)(GLenum, GLenum, GLfloat *); - void (*GetTexEnviv)(GLenum, GLenum, GLint *); - void (*GetTexGendv)(GLenum coord, GLenum, GLdouble *); - void (*GetTexGenfv)(GLenum coord, GLenum, GLfloat *); - void (*GetTexGeniv)(GLenum coord, GLenum, GLint *); - void (*GetTexImage)(GLenum, GLint level, GLenum, GLenum, GLvoid *); - void (*GetTexLevelParameterfv)(GLenum, GLint, GLenum, GLfloat *); - void (*GetTexLevelParameteriv)(GLenum, GLint, GLenum, GLint *); - void (*GetTexParameterfv)(GLenum, GLenum, GLfloat *); - void (*GetTexParameteriv)(GLenum, GLenum, GLint *); - void (*Hint)(GLenum, GLenum); - void (*IndexMask)(GLuint); - void (*Indexd)(GLdouble); - void (*Indexdv)(const GLdouble *); - void (*Indexf)(GLfloat); - void (*Indexfv)(const GLfloat *); - void (*Indexi)(GLint); - void (*Indexiv)(const GLint *); - void (*Indexs)(GLshort); - void (*Indexsv)(const GLshort *); - void (*InitNames)(void); - GLboolean (*IsEnabled)(GLenum); - GLboolean (*IsList)(GLuint); - void (*LightModelf)(GLenum, GLfloat); - void (*LightModelfv)(GLenum, const GLfloat *); - void (*LightModeli)(GLenum, GLint); - void (*LightModeliv)(GLenum, const GLint *); - void (*Lightf)(GLenum light, GLenum, GLfloat); - void (*Lightfv)(GLenum light, GLenum, const GLfloat *); - void (*Lighti)(GLenum light, GLenum, GLint); - void (*Lightiv)(GLenum light, GLenum, const GLint *); - void (*LineStipple)(GLint factor, GLushort); - void (*LineWidth)(GLfloat); - void (*ListBase)(GLuint); - void (*LoadIdentity)(void); - void (*LoadMatrixd)(const GLdouble *); - void (*LoadMatrixf)(const GLfloat *); - void (*LoadName)(GLuint); - void (*LogicOp)(GLenum); - void (*Map1d)(GLenum, GLdouble, GLdouble, GLint, GLint, const GLdouble *); - void (*Map1f)(GLenum, GLfloat, GLfloat, GLint, GLint, const GLfloat *); - void (*Map2d)(GLenum, GLdouble, GLdouble, GLint, GLint, GLdouble, GLdouble, GLint, GLint, const GLdouble *); - void (*Map2f)(GLenum, GLfloat, GLfloat, GLint, GLint, GLfloat, GLfloat, GLint, GLint, const GLfloat *); - void (*MapGrid1d)(GLint, GLdouble, GLdouble); - void (*MapGrid1f)(GLint, GLfloat, GLfloat); - void (*MapGrid2d)(GLint, GLdouble, GLdouble, GLint, GLdouble, GLdouble); - void (*MapGrid2f)(GLint, GLfloat, GLfloat, GLint, GLfloat, GLfloat); - void (*Materialf)(GLenum, GLenum, GLfloat); - void (*Materialfv)(GLenum, GLenum, const GLfloat *); - void (*Materiali)(GLenum, GLenum, GLint); - void (*Materialiv)(GLenum, GLenum, const GLint *); - void (*MatrixMode)(GLenum); - void (*MultMatrixd)(const GLdouble *); - void (*MultMatrixf)(const GLfloat *); - void (*NewList)(GLuint list, GLenum); - void (*Normal3b)(GLbyte, GLbyte, GLbyte); - void (*Normal3bv)(const GLbyte *); - void (*Normal3d)(GLdouble, GLdouble, GLdouble); - void (*Normal3dv)(const GLdouble *); - void (*Normal3f)(GLfloat, GLfloat, GLfloat); - void (*Normal3fv)(const GLfloat *); - void (*Normal3i)(GLint, GLint, GLint); - void (*Normal3iv)(const GLint *); - void (*Normal3s)(GLshort, GLshort, GLshort); - void (*Normal3sv)(const GLshort *); - void (*Ortho)(GLdouble, GLdouble, GLdouble, GLdouble, GLdouble, GLdouble); - void (*PassThrough)(GLfloat); - void (*PixelMapfv)(GLenum, GLint, const GLfloat *); - void (*PixelMapuiv)(GLenum, GLint, const GLuint *); - void (*PixelMapusv)(GLenum, GLint, const GLushort *); - void (*PixelStoref)(GLenum, GLfloat); - void (*PixelStorei)(GLenum, GLint); - void (*PixelTransferf)(GLenum, GLfloat); - void (*PixelTransferi)(GLenum, GLint); - void (*PixelZoom)(GLfloat, GLfloat); - void (*PointSize)(GLfloat); - void (*PolygonMode)(GLenum, GLenum); - void (*PolygonOffset)(GLfloat, GLfloat); - void (*PolygonStipple)(const GLubyte *); - void (*PopAttrib)(void); - void (*PopMatrix)(void); - void (*PopName)(void); - void (*PushAttrib)(GLbitfield); - void (*PushMatrix)(void); - void (*PushName)(GLuint); - void (*RasterPos2d)(GLdouble, GLdouble); - void (*RasterPos2dv)(const GLdouble *); - void (*RasterPos2f)(GLfloat, GLfloat); - void (*RasterPos2fv)(const GLfloat *); - void (*RasterPos2i)(GLint, GLint); - void (*RasterPos2iv)(const GLint *); - void (*RasterPos2s)(GLshort, GLshort); - void (*RasterPos2sv)(const GLshort *); - void (*RasterPos3d)(GLdouble, GLdouble, GLdouble); - void (*RasterPos3dv)(const GLdouble *); - void (*RasterPos3f)(GLfloat, GLfloat, GLfloat); - void (*RasterPos3fv)(const GLfloat *); - void (*RasterPos3i)(GLint, GLint, GLint); - void (*RasterPos3iv)(const GLint *); - void (*RasterPos3s)(GLshort, GLshort, GLshort); - void (*RasterPos3sv)(const GLshort *); - void (*RasterPos4d)(GLdouble, GLdouble, GLdouble, GLdouble); - void (*RasterPos4dv)(const GLdouble *); - void (*RasterPos4f)(GLfloat, GLfloat, GLfloat, GLfloat); - void (*RasterPos4fv)(const GLfloat *); - void (*RasterPos4i)(GLint, GLint, GLint, GLint); - void (*RasterPos4iv)(const GLint *); - void (*RasterPos4s)(GLshort, GLshort, GLshort, GLshort); - void (*RasterPos4sv)(const GLshort *); - void (*ReadBuffer)(GLenum); - void (*ReadPixels)(GLint, GLint, GLsizei, GLsizei, GLenum, GLenum, GLvoid *); - void (*Rectd)(GLdouble, GLdouble, GLdouble, GLdouble); - void (*Rectdv)(const GLdouble *, const GLdouble *); - void (*Rectf)(GLfloat, GLfloat, GLfloat, GLfloat); - void (*Rectfv)(const GLfloat *, const GLfloat *); - void (*Recti)(GLint, GLint, GLint, GLint); - void (*Rectiv)(const GLint *, const GLint *); - void (*Rects)(GLshort, GLshort, GLshort, GLshort); - void (*Rectsv)(const GLshort *, const GLshort *); - GLint (*RenderMode)(GLenum); - void (*Rotated)(GLdouble, GLdouble, GLdouble, GLdouble); - void (*Rotatef)(GLfloat, GLfloat, GLfloat, GLfloat); - void (*Scaled)(GLdouble, GLdouble, GLdouble); - void (*Scalef)(GLfloat, GLfloat, GLfloat); - void (*Scissor)(GLint, GLint, GLsizei, GLsizei); - void (*SelectBuffer)(GLsizei, GLuint *); - void (*ShadeModel)(GLenum); - void (*StencilFunc)(GLenum, GLint, GLuint); - void (*StencilMask)(GLuint); - void (*StencilOp)(GLenum, GLenum, GLenum); - void (*TexCoord1d)(GLdouble); - void (*TexCoord1dv)(const GLdouble *); - void (*TexCoord1f)(GLfloat); - void (*TexCoord1fv)(const GLfloat *); - void (*TexCoord1i)(GLint); - void (*TexCoord1iv)(const GLint *); - void (*TexCoord1s)(GLshort); - void (*TexCoord1sv)(const GLshort *); - void (*TexCoord2d)(GLdouble, GLdouble); - void (*TexCoord2dv)(const GLdouble *); - void (*TexCoord2f)(GLfloat, GLfloat); - void (*TexCoord2fv)(const GLfloat *); - void (*TexCoord2i)(GLint, GLint); - void (*TexCoord2iv)(const GLint *); - void (*TexCoord2s)(GLshort, GLshort); - void (*TexCoord2sv)(const GLshort *); - void (*TexCoord3d)(GLdouble, GLdouble, GLdouble); - void (*TexCoord3dv)(const GLdouble *); - void (*TexCoord3f)(GLfloat, GLfloat, GLfloat); - void (*TexCoord3fv)(const GLfloat *); - void (*TexCoord3i)(GLint, GLint, GLint); - void (*TexCoord3iv)(const GLint *); - void (*TexCoord3s)(GLshort, GLshort, GLshort); - void (*TexCoord3sv)(const GLshort *); - void (*TexCoord4d)(GLdouble, GLdouble, GLdouble, GLdouble); - void (*TexCoord4dv)(const GLdouble *); - void (*TexCoord4f)(GLfloat, GLfloat, GLfloat, GLfloat); - void (*TexCoord4fv)(const GLfloat *); - void (*TexCoord4i)(GLint, GLint, GLint, GLint); - void (*TexCoord4iv)(const GLint *); - void (*TexCoord4s)(GLshort, GLshort, GLshort, GLshort); - void (*TexCoord4sv)(const GLshort *); - void (*TexEnvf)(GLenum, GLenum, GLfloat); - void (*TexEnvfv)(GLenum, GLenum, const GLfloat *); - void (*TexEnvi)(GLenum, GLenum, GLint); - void (*TexEnviv)(GLenum, GLenum, const GLint *); - void (*TexGend)(GLenum, GLenum, GLdouble); - void (*TexGendv)(GLenum, GLenum, const GLdouble *); - void (*TexGenf)(GLenum, GLenum, GLfloat); - void (*TexGenfv)(GLenum, GLenum, const GLfloat *); - void (*TexGeni)(GLenum, GLenum, GLint); - void (*TexGeniv)(GLenum, GLenum, const GLint *); - void (*TexImage1D)(GLenum, GLint, GLint, GLsizei, GLint, GLenum, GLenum, const GLvoid *); - void (*TexImage2D)(GLenum, GLint, GLint, GLsizei, GLsizei, GLint, GLenum, GLenum, const GLvoid *); - void (*TexParameterf)(GLenum, GLenum, GLfloat); - void (*TexParameterfv)(GLenum, GLenum, const GLfloat *); - void (*TexParameteri)(GLenum, GLenum, GLint); - void (*TexParameteriv)(GLenum, GLenum, const GLint *); - void (*Translated)(GLdouble, GLdouble, GLdouble); - void (*Translatef)(GLfloat, GLfloat, GLfloat); - void (*Vertex2d)(GLdouble, GLdouble); - void (*Vertex2dv)(const GLdouble *); - void (*Vertex2f)(GLfloat, GLfloat); - void (*Vertex2fv)(const GLfloat *); - void (*Vertex2i)(GLint, GLint); - void (*Vertex2iv)(const GLint *); - void (*Vertex2s)(GLshort, GLshort); - void (*Vertex2sv)(const GLshort *); - void (*Vertex3d)(GLdouble, GLdouble, GLdouble); - void (*Vertex3dv)(const GLdouble *); - void (*Vertex3f)(GLfloat, GLfloat, GLfloat); - void (*Vertex3fv)(const GLfloat *); - void (*Vertex3i)(GLint, GLint, GLint); - void (*Vertex3iv)(const GLint *); - void (*Vertex3s)(GLshort, GLshort, GLshort); - void (*Vertex3sv)(const GLshort *); - void (*Vertex4d)(GLdouble, GLdouble, GLdouble, GLdouble); - void (*Vertex4dv)(const GLdouble *); - void (*Vertex4f)(GLfloat, GLfloat, GLfloat, GLfloat); - void (*Vertex4fv)(const GLfloat *); - void (*Vertex4i)(GLint, GLint, GLint, GLint); - void (*Vertex4iv)(const GLint *); - void (*Vertex4s)(GLshort, GLshort, GLshort, GLshort); - void (*Vertex4sv)(const GLshort *); - void (*Viewport)(GLint, GLint, GLsizei, GLsizei); - - /* - * OpenGL 1.1 - */ - GLboolean (*AreTexturesResident)(GLsizei, const GLuint *, GLboolean *); - void (*ArrayElement)(GLint); - void (*BindTexture)(GLenum, GLuint); - void (*ColorPointer)(GLint, GLenum, GLsizei, const GLvoid *); - void (*CopyTexImage1D)(GLenum, GLint, GLenum, GLint, GLint, GLsizei, GLint); - void (*CopyTexImage2D)(GLenum, GLint, GLenum, GLint, GLint, GLsizei, GLsizei, GLint); - void (*CopyTexSubImage1D)(GLenum, GLint, GLint, GLint, GLint, GLsizei); - void (*CopyTexSubImage2D)(GLenum, GLint, GLint, GLint, GLint, GLint, GLsizei, GLsizei); - void (*DeleteTextures)(GLsizei, const GLuint *); - void (*DisableClientState)(GLenum); - void (*DrawArrays)(GLenum, GLint, GLsizei); - void (*DrawElements)(GLenum, GLsizei, GLenum, const GLvoid *); - void (*EdgeFlagPointer)(GLsizei, const GLvoid *); - void (*EnableClientState)(GLenum); - void (*GenTextures)(GLsizei, GLuint *); - void (*GetPointerv)(GLenum, GLvoid **); - void (*IndexPointer)(GLenum, GLsizei, const GLvoid *); - void (*Indexub)(GLubyte); - void (*Indexubv)(const GLubyte *); - void (*InterleavedArrays)(GLenum, GLsizei, const GLvoid *); - GLboolean (*IsTexture)(GLuint); - void (*NormalPointer)(GLenum, GLsizei, const GLvoid *); - void (*PopClientAttrib)(void); - void (*PrioritizeTextures)(GLsizei, const GLuint *, const GLclampf *); - void (*PushClientAttrib)(GLbitfield); - void (*TexCoordPointer)(GLint, GLenum, GLsizei, const GLvoid *); - void (*TexSubImage1D)(GLenum, GLint, GLint, GLsizei, GLenum, GLenum, const GLvoid *); - void (*TexSubImage2D)(GLenum, GLint, GLint, GLint, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *); - void (*VertexPointer)(GLint, GLenum, GLsizei, const GLvoid *); - - - /* - * OpenGL 1.2 - */ - void (*CopyTexSubImage3D)(GLenum, GLint, GLint, GLint, GLint, GLint, GLint, GLsizei, GLsizei); - void (*DrawRangeElements)(GLenum, GLuint, GLuint, GLsizei, GLenum, const GLvoid *); - void (*TexImage3D)(GLenum, GLint, GLint, GLsizei, GLsizei, GLsizei, GLint, GLenum, GLenum, const GLvoid *); - void (*TexSubImage3D)(GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *); - - - /* - * GL_ARB_imaging - */ - void (*BlendColor)(GLclampf, GLclampf, GLclampf, GLclampf); - void (*BlendEquation)(GLenum); - void (*ColorSubTable)(GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *); - void (*ColorTable)(GLenum, GLenum, GLsizei, GLenum, GLenum, const GLvoid *); - void (*ColorTableParameterfv)(GLenum, GLenum, const GLfloat *); - void (*ColorTableParameteriv)(GLenum, GLenum, const GLint *); - void (*ConvolutionFilter1D)(GLenum, GLenum, GLsizei, GLenum, GLenum, const GLvoid *); - void (*ConvolutionFilter2D)(GLenum, GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *); - void (*ConvolutionParameterf)(GLenum, GLenum, GLfloat); - void (*ConvolutionParameterfv)(GLenum, GLenum, const GLfloat *); - void (*ConvolutionParameteri)(GLenum, GLenum, GLint); - void (*ConvolutionParameteriv)(GLenum, GLenum, const GLint *); - void (*CopyColorSubTable)(GLenum, GLsizei, GLint, GLint, GLsizei); - void (*CopyColorTable)(GLenum, GLenum, GLint, GLint, GLsizei); - void (*CopyConvolutionFilter1D)(GLenum, GLenum, GLint x, GLint y, GLsizei); - void (*CopyConvolutionFilter2D)(GLenum, GLenum, GLint x, GLint y, GLsizei, GLsizei); - void (*GetColorTable)(GLenum, GLenum, GLenum, GLvoid *); - void (*GetColorTableParameterfv)(GLenum, GLenum, GLfloat *); - void (*GetColorTableParameteriv)(GLenum, GLenum, GLint *); - void (*GetConvolutionFilter)(GLenum, GLenum, GLenum, GLvoid *); - void (*GetConvolutionParameterfv)(GLenum, GLenum, GLfloat *); - void (*GetConvolutionParameteriv)(GLenum, GLenum, GLint *); - void (*GetHistogram)(GLenum, GLboolean, GLenum, GLenum, GLvoid *); - void (*GetHistogramParameterfv)(GLenum, GLenum, GLfloat *); - void (*GetHistogramParameteriv)(GLenum, GLenum, GLint *); - void (*GetMinmax)(GLenum, GLboolean, GLenum, GLenum, GLvoid *); - void (*GetMinmaxParameterfv)(GLenum, GLenum, GLfloat *); - void (*GetMinmaxParameteriv)(GLenum, GLenum, GLint *); - void (*GetSeparableFilter)(GLenum, GLenum, GLenum, GLvoid *, GLvoid *, GLvoid *); - void (*Histogram)(GLenum, GLsizei, GLenum, GLboolean); - void (*Minmax)(GLenum, GLenum, GLboolean); - void (*ResetHistogram)(GLenum); - void (*ResetMinmax)(GLenum); - void (*SeparableFilter2D)(GLenum, GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *, const GLvoid *); - - /* - * GL_ARB_multitexture - */ - void (*ActiveTextureARB)(GLenum); - void (*ClientActiveTextureARB)(GLenum); - void (*MultiTexCoord1dARB)(GLenum, GLdouble); - void (*MultiTexCoord1dvARB)(GLenum, const GLdouble *); - void (*MultiTexCoord1fARB)(GLenum, GLfloat); - void (*MultiTexCoord1fvARB)(GLenum, const GLfloat *); - void (*MultiTexCoord1iARB)(GLenum, GLint); - void (*MultiTexCoord1ivARB)(GLenum, const GLint *); - void (*MultiTexCoord1sARB)(GLenum, GLshort); - void (*MultiTexCoord1svARB)(GLenum, const GLshort *); - void (*MultiTexCoord2dARB)(GLenum, GLdouble, GLdouble); - void (*MultiTexCoord2dvARB)(GLenum, const GLdouble *); - void (*MultiTexCoord2fARB)(GLenum, GLfloat, GLfloat); - void (*MultiTexCoord2fvARB)(GLenum, const GLfloat *); - void (*MultiTexCoord2iARB)(GLenum, GLint, GLint); - void (*MultiTexCoord2ivARB)(GLenum, const GLint *); - void (*MultiTexCoord2sARB)(GLenum, GLshort, GLshort); - void (*MultiTexCoord2svARB)(GLenum, const GLshort *); - void (*MultiTexCoord3dARB)(GLenum, GLdouble, GLdouble, GLdouble); - void (*MultiTexCoord3dvARB)(GLenum, const GLdouble *); - void (*MultiTexCoord3fARB)(GLenum, GLfloat, GLfloat, GLfloat); - void (*MultiTexCoord3fvARB)(GLenum, const GLfloat *); - void (*MultiTexCoord3iARB)(GLenum, GLint, GLint, GLint); - void (*MultiTexCoord3ivARB)(GLenum, const GLint *); - void (*MultiTexCoord3sARB)(GLenum, GLshort, GLshort, GLshort); - void (*MultiTexCoord3svARB)(GLenum, const GLshort *); - void (*MultiTexCoord4dARB)(GLenum, GLdouble, GLdouble, GLdouble, GLdouble); - void (*MultiTexCoord4dvARB)(GLenum, const GLdouble *); - void (*MultiTexCoord4fARB)(GLenum, GLfloat, GLfloat, GLfloat, GLfloat); - void (*MultiTexCoord4fvARB)(GLenum, const GLfloat *); - void (*MultiTexCoord4iARB)(GLenum, GLint, GLint, GLint, GLint); - void (*MultiTexCoord4ivARB)(GLenum, const GLint *); - void (*MultiTexCoord4sARB)(GLenum, GLshort, GLshort, GLshort, GLshort); - void (*MultiTexCoord4svARB)(GLenum, const GLshort *); - - - /* - * Extensions - */ - - /* 1. GL_EXT_abgr - no functions */ - - /* 2. GL_EXT_blend_color */ - void (*BlendColorEXT)(GLclampf, GLclampf, GLclampf, GLclampf); - - /* 3. GL_EXT_polygon_offset */ - void (*PolygonOffsetEXT)(GLfloat, GLfloat); - - /* 4. GL_EXT_texture - no functions */ - - /* 5. ??? */ - - /* 6. GL_EXT_texture3D */ - void (*CopyTexSubImage3DEXT)(GLenum, GLint, GLint, GLint, GLint, GLint, GLint, GLsizei, GLsizei); - void (*TexImage3DEXT)(GLenum, GLint, GLenum, GLsizei, GLsizei, GLsizei, GLint, GLenum, GLenum, const GLvoid *); - void (*TexSubImage3DEXT)(GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *); - - /* 7. GL_SGI_texture_filter4 */ - void (*GetTexFilterFuncSGIS)(GLenum, GLenum, GLsizei, const GLfloat *); - void (*TexFilterFuncSGIS)(GLenum, GLenum, GLfloat *); - - /* 8. ??? */ - - /* 9. GL_EXT_subtexture */ - void (*TexSubImage1DEXT)(GLenum, GLint, GLint, GLsizei, GLenum, GLenum, const GLvoid *); - void (*TexSubImage2DEXT)(GLenum, GLint, GLint, GLint, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *); - - /* 10. GL_EXT_copy_texture */ - void (*CopyTexImage1DEXT)(GLenum, GLint, GLenum, GLint, GLint, GLsizei, GLint); - void (*CopyTexImage2DEXT)(GLenum, GLint, GLenum, GLint, GLint, GLsizei, GLsizei, GLint); - void (*CopyTexSubImage1DEXT)(GLenum, GLint, GLint, GLint, GLint, GLsizei); - void (*CopyTexSubImage2DEXT)(GLenum, GLint, GLint, GLint, GLint, GLint, GLsizei, GLsizei); - - /* 11. GL_EXT_histogram */ - void (*GetHistogramEXT)(GLenum, GLboolean, GLenum, GLenum, GLvoid *); - void (*GetHistogramParameterfvEXT)(GLenum, GLenum, GLfloat *); - void (*GetHistogramParameterivEXT)(GLenum, GLenum, GLint *); - void (*GetMinmaxEXT)(GLenum, GLboolean, GLenum, GLenum, GLvoid *); - void (*GetMinmaxParameterfvEXT)(GLenum, GLenum, GLfloat *); - void (*GetMinmaxParameterivEXT)(GLenum, GLenum, GLint *); - void (*HistogramEXT)(GLenum, GLsizei, GLenum, GLboolean); - void (*MinmaxEXT)(GLenum, GLenum, GLboolean); - void (*ResetHistogramEXT)(GLenum); - void (*ResetMinmaxEXT)(GLenum); - - /* 12. GL_EXT_convolution */ - void (*ConvolutionFilter1DEXT)(GLenum, GLenum, GLsizei, GLenum, GLenum, const GLvoid *); - void (*ConvolutionFilter2DEXT)(GLenum, GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *); - void (*ConvolutionParameterfEXT)(GLenum, GLenum, GLfloat); - void (*ConvolutionParameterfvEXT)(GLenum, GLenum, const GLfloat *); - void (*ConvolutionParameteriEXT)(GLenum, GLenum, GLint); - void (*ConvolutionParameterivEXT)(GLenum, GLenum, const GLint *); - void (*CopyConvolutionFilter1DEXT)(GLenum, GLenum, GLint x, GLint y, GLsizei); - void (*CopyConvolutionFilter2DEXT)(GLenum, GLenum, GLint x, GLint y, GLsizei, GLsizei); - void (*GetConvolutionFilterEXT)(GLenum, GLenum, GLenum, GLvoid *); - void (*GetConvolutionParameterfvEXT)(GLenum, GLenum, GLfloat *); - void (*GetConvolutionParameterivEXT)(GLenum, GLenum, GLint *); - void (*GetSeparableFilterEXT)(GLenum, GLenum, GLenum, GLvoid *, GLvoid *, GLvoid *); - void (*SeparableFilter2DEXT)(GLenum, GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *, const GLvoid *); - - /* 13. GL_SGI_color_matrix - no functions */ - - /* 14. GL_SGI_color_table */ - void (*ColorTableSGI)(GLenum, GLenum, GLsizei, GLenum, GLenum, const GLvoid *); - void (*ColorTableParameterfvSGI)(GLenum, GLenum, const GLfloat *); - void (*ColorTableParameterivSGI)(GLenum, GLenum, const GLint *); - void (*CopyColorTableSGI)(GLenum, GLenum, GLint, GLint, GLsizei); - void (*GetColorTableSGI)(GLenum, GLenum, GLenum, GLvoid *); - void (*GetColorTableParameterfvSGI)(GLenum, GLenum, GLfloat *); - void (*GetColorTableParameterivSGI)(GLenum, GLenum, GLint *); - - /* 15. GL_SGIS_pixel_texture */ - void (*PixelTexGenParameterfSGIS)(GLenum, GLfloat); - void (*PixelTexGenParameteriSGIS)(GLenum, GLint); - void (*GetPixelTexGenParameterfvSGIS)(GLenum, GLfloat *); - void (*GetPixelTexGenParameterivSGIS)(GLenum, GLint *); - - /* 16. GL_SGIS_texture4D */ - void (*TexImage4DSGIS)(GLenum, GLint, GLenum, GLsizei, GLsizei, GLsizei, GLsizei, GLint, GLenum, GLenum, const void *); - void (*TexSubImage4DSGIS)(GLenum, GLint, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLsizei, GLenum, GLenum, const void *); - - /* 17. GL_SGI_texture_color_table - no functions */ - - /* 18. GL_EXT_cmyka - no functions */ - - /* 19. ??? */ - - /* 20. GL_EXT_texture_object */ - GLboolean (*AreTexturesResidentEXT)(GLsizei, const GLuint *, GLboolean *); - void (*BindTextureEXT)(GLenum, GLuint); - void (*DeleteTexturesEXT)(GLsizei, const GLuint *); - void (*GenTexturesEXT)(GLsizei, GLuint *); - GLboolean (*IsTextureEXT)(GLuint); - void (*PrioritizeTexturesEXT)(GLsizei, const GLuint *, const GLclampf *); - - /* 21. GL_SGIS_detail_texture */ - void (*DetailTexFuncSGIS)(GLenum, GLsizei, const GLfloat *); - void (*GetDetailTexFuncSGIS)(GLenum, GLfloat *); - - /* 22. GL_SGIS_sharpen_texture */ - void (*GetSharpenTexFuncSGIS)(GLenum, GLfloat *); - void (*SharpenTexFuncSGIS)(GLenum, GLsizei, const GLfloat *); - - /* 23. GL_EXT_packed_pixels - no functions */ - - /* 24. GL_SGIS_texture_lod - no functions */ - - /* 25. GL_SGIS_multisample */ - void (*SampleMaskSGIS)(GLclampf, GLboolean); - void (*SamplePatternSGIS)(GLenum); - - /* 26. ??? */ - - /* 27. GL_EXT_rescale_normal - no functions */ - - /* 28. GLX_EXT_visual_info - no functions */ - - /* 29. ??? */ - - /* 30. GL_EXT_vertex_array */ - void (*ArrayElementEXT)(GLint); - void (*ColorPointerEXT)(GLint, GLenum, GLsizei, GLsizei, const void *); - void (*DrawArraysEXT)(GLenum, GLint, GLsizei); - void (*EdgeFlagPointerEXT)(GLsizei, GLsizei, const GLboolean *); - void (*GetPointervEXT)(GLenum, void **); - void (*IndexPointerEXT)(GLenum, GLsizei, GLsizei, const void *); - void (*NormalPointerEXT)(GLenum, GLsizei, GLsizei, const void *); - void (*TexCoordPointerEXT)(GLint, GLenum, GLsizei, GLsizei, const void *); - void (*VertexPointerEXT)(GLint, GLenum, GLsizei, GLsizei, const void *); - - /* 31. GL_EXT_misc_attribute - no functions */ - - /* 32. GL_SGIS_generate_mipmap - no functions */ - - /* 33. GL_SGIX_clipmap - no functions */ - - /* 34. GL_SGIX_shadow - no functions */ - - /* 35. GL_SGIS_texture_edge_clamp - no functions */ - - /* 36. GL_SGIS_texture_border_clamp - no functions */ - - /* 37. GL_EXT_blend_minmax */ - void (*BlendEquationEXT)(GLenum); - - /* 38. GL_EXT_blend_subtract - no functions */ - - /* 39. GL_EXT_blend_logic_op - no functions */ - - /* 40. GLX_SGI_swap_control - GLX functions */ - - /* 41. GLX_SGI_video_sync - GLX functions */ - - /* 42. GLX_SGI_make_current_read - GLX functions */ - - /* 43. GLX_SGIX_video_source - GLX functions */ - - /* 44. GLX_EXT_visual_rating - no functions */ - - /* 45. GL_SGIX_interlace - no functions */ - - /* 46. ??? */ - - /* 47. GLX_EXT_import_context - GLX functions */ - - /* 48. ??? */ - - /* 49. GLX_SGIX_fbconfig - GLX functions */ - - /* 50. GLX_SGIX_pbuffer - GLX functions */ - - /* 51. GL_SGIS_texture_select - no functions */ - - /* 52. GL_SGIX_sprite */ - void (*SpriteParameterfSGIX)(GLenum, GLfloat); - void (*SpriteParameterfvSGIX)(GLenum, const GLfloat *); - void (*SpriteParameteriSGIX)(GLenum, GLint); - void (*SpriteParameterivSGIX)(GLenum, const GLint *); - - /* 53. ??? */ - - /* 54. GL_EXT_point_parameters */ - void (*PointParameterfEXT)(GLenum, GLfloat); - void (*PointParameterfvEXT)(GLenum, const GLfloat *); - - /* 55. GL_SGIX_instruments */ - GLint (*GetInstrumentsSGIX)(void); - void (*InstrumentsBufferSGIX)(GLsizei, GLint *); - GLint (*PollInstrumentsSGIX)(GLint *); - void (*ReadInstrumentsSGIX)(GLint); - void (*StartInstrumentsSGIX)(void); - void (*StopInstrumentsSGIX)(GLint); - - /* 56. GL_SGIX_texture_scale_bias - no functions */ - - /* 57. GL_SGIX_framezoom */ - void (*FrameZoomSGIX)(GLint); - - /* 58. GL_SGIX_tag_sample_buffer - no functions */ - - /* 59. ??? */ - - /* 60. GL_SGIX_reference_plane */ - void (*ReferencePlaneSGIX)(const GLdouble *); - - /* 61. GL_SGIX_flush_raster */ - void (*FlushRasterSGIX)(void); - - /* 62. GLX_SGI_cushion - GLX functions */ - - /* 63. GL_SGIX_depth_texture - no functions */ - - /* 64. ??? */ - - /* 65. GL_SGIX_fog_offset - no functions */ - - /* 66. GL_HP_image_transform */ -#ifdef VMS -#define glGetImageTransformParameterfvHP glGetImageTransformParameterfvH -#define glGetImageTransformParameterivHP glGetImageTransformParameterivH -#endif - void (*GetImageTransformParameterfvHP)(GLenum, GLenum, GLfloat *); - void (*GetImageTransformParameterivHP)(GLenum, GLenum, GLint *); - void (*ImageTransformParameterfHP)(GLenum, GLenum, const GLfloat); - void (*ImageTransformParameterfvHP)(GLenum, GLenum, const GLfloat *); - void (*ImageTransformParameteriHP)(GLenum, GLenum, const GLint); - void (*ImageTransformParameterivHP)(GLenum, GLenum, const GLint *); - - /* 67. GL_HP_convolution_border_modes - no functions */ - - /* 68. ??? */ - - /* 69. GL_SGIX_texture_add_env - no functions */ - - /* 70. ??? */ - - /* 71. ??? */ - - /* 72. ??? */ - - /* 73. ??? */ - - /* 74. GL_EXT_color_subtable */ - void (*ColorSubTableEXT)(GLenum, GLsizei, GLsizei, GLenum, GLenum, const void *); - void (*CopyColorSubTableEXT)(GLenum, GLsizei, GLint, GLint, GLsizei); - - /* 75. GLU_EXT_object_space_tess - GLU functions */ - - /* 76. GL_PGI_vertex_hints - no functions */ - - /* 77. GL_PGI_misc_hints */ - void (*HintPGI)(GLenum, GLint); - - /* 78. GL_EXT_paletted_texture */ - /* ColorSubTableEXT already defined */ - void (*ColorTableEXT)(GLenum, GLenum, GLsizei, GLenum, GLenum, const GLvoid *); - void (*GetColorTableEXT)(GLenum, GLenum, GLenum, GLvoid *); - void (*GetColorTableParameterfvEXT)(GLenum, GLenum, GLfloat *); - void (*GetColorTableParameterivEXT)(GLenum, GLenum, GLint *); - - /* 79. GL_EXT_clip_volume_hint - no functions */ - - /* 80. GL_SGIX_list_priority */ - void (*GetListParameterfvSGIX)(GLuint, GLenum, GLfloat *); - void (*GetListParameterivSGIX)(GLuint, GLenum, GLint *); - void (*ListParameterfSGIX)(GLuint, GLenum, GLfloat); - void (*ListParameterfvSGIX)(GLuint, GLenum, const GLfloat *); - void (*ListParameteriSGIX)(GLuint, GLenum, GLint); - void (*ListParameterivSGIX)(GLuint, GLenum, const GLint *); - - /* 81. GL_SGIX_ir_instrument1 - no functions */ - - /* 82. ??? */ - - /* 83. GLX_SGIX_video_resize - GLX functions */ - - /* 84. GL_SGIX_texture_lod_bias - no functions */ - - /* 85. GLU_SGI_filter4_parameters - GLU functions */ - - /* 86. GLX_SGIX_dm_buffer - GLX functions */ - - /* 87. ??? */ - - /* 88. ??? */ - - /* 89. ??? */ - - /* 90. ??? */ - - /* 91. GLX_SGIX_swap_group - GLX functions */ - - /* 92. GLX_SGIX_swap_barrier - GLX functions */ - - /* 93. GL_EXT_index_texture - no functions */ - - /* 94. GL_EXT_index_material */ - void (*IndexMaterialEXT)(GLenum, GLenum); - - /* 95. GL_EXT_index_func */ - void (*IndexFuncEXT)(GLenum, GLfloat); - - /* 96. GL_EXT_index_array_formats - no functions */ - - /* 97. GL_EXT_compiled_vertex_array */ - void (*LockArraysEXT)(GLint, GLsizei); - void (*UnlockArraysEXT)(void); - - /* 98. GL_EXT_cull_vertex */ - void (*CullParameterfvEXT)(GLenum, const GLfloat *); - void (*CullParameterdvEXT)(GLenum, const GLdouble *); - - /* 99. ??? */ - - /* 100. GLU_EXT_nurbs_tessellator - GLU functions */ - - /* 173. GL_EXT/INGR_blend_func_separate */ - void (*BlendFuncSeparateINGR)(GLenum, GLenum, GLenum, GLenum); - - /* GL_MESA_window_pos */ - void (*WindowPos2dMESA)(GLdouble, GLdouble); - void (*WindowPos2dvMESA)(const GLdouble *); - void (*WindowPos2fMESA)(GLfloat, GLfloat); - void (*WindowPos2fvMESA)(const GLfloat *); - void (*WindowPos2iMESA)(GLint, GLint); - void (*WindowPos2ivMESA)(const GLint *); - void (*WindowPos2sMESA)(GLshort, GLshort); - void (*WindowPos2svMESA)(const GLshort *); - void (*WindowPos3dMESA)(GLdouble, GLdouble, GLdouble); - void (*WindowPos3dvMESA)(const GLdouble *); - void (*WindowPos3fMESA)(GLfloat, GLfloat, GLfloat); - void (*WindowPos3fvMESA)(const GLfloat *); - void (*WindowPos3iMESA)(GLint, GLint, GLint); - void (*WindowPos3ivMESA)(const GLint *); - void (*WindowPos3sMESA)(GLshort, GLshort, GLshort); - void (*WindowPos3svMESA)(const GLshort *); - void (*WindowPos4dMESA)(GLdouble, GLdouble, GLdouble, GLdouble); - void (*WindowPos4dvMESA)(const GLdouble *); - void (*WindowPos4fMESA)(GLfloat, GLfloat, GLfloat, GLfloat); - void (*WindowPos4fvMESA)(const GLfloat *); - void (*WindowPos4iMESA)(GLint, GLint, GLint, GLint); - void (*WindowPos4ivMESA)(const GLint *); - void (*WindowPos4sMESA)(GLshort, GLshort, GLshort, GLshort); - void (*WindowPos4svMESA)(const GLshort *); - - /* GL_MESA_resize_buffers */ - void (*ResizeBuffersMESA)(void); - - /* GL_ARB_transpose_matrix */ - void (*LoadTransposeMatrixdARB)(const GLdouble m[16]); - void (*LoadTransposeMatrixfARB)(const GLfloat m[16]); - void (*MultTransposeMatrixdARB)(const GLdouble m[16]); - void (*MultTransposeMatrixfARB)(const GLfloat m[16]); - + void (*NewList)(GLuint list, GLenum mode); /* 0 */ + void (*EndList)(void); /* 1 */ + void (*CallList)(GLuint list); /* 2 */ + void (*CallLists)(GLsizei n, GLenum type, const GLvoid * lists); /* 3 */ + void (*DeleteLists)(GLuint list, GLsizei range); /* 4 */ + GLuint (*GenLists)(GLsizei range); /* 5 */ + void (*ListBase)(GLuint base); /* 6 */ + void (*Begin)(GLenum mode); /* 7 */ + void (*Bitmap)(GLsizei width, GLsizei height, GLfloat xorig, GLfloat yorig, GLfloat xmove, GLfloat ymove, const GLubyte * bitmap); /* 8 */ + void (*Color3b)(GLbyte red, GLbyte green, GLbyte blue); /* 9 */ + void (*Color3bv)(const GLbyte * v); /* 10 */ + void (*Color3d)(GLdouble red, GLdouble green, GLdouble blue); /* 11 */ + void (*Color3dv)(const GLdouble * v); /* 12 */ + void (*Color3f)(GLfloat red, GLfloat green, GLfloat blue); /* 13 */ + void (*Color3fv)(const GLfloat * v); /* 14 */ + void (*Color3i)(GLint red, GLint green, GLint blue); /* 15 */ + void (*Color3iv)(const GLint * v); /* 16 */ + void (*Color3s)(GLshort red, GLshort green, GLshort blue); /* 17 */ + void (*Color3sv)(const GLshort * v); /* 18 */ + void (*Color3ub)(GLubyte red, GLubyte green, GLubyte blue); /* 19 */ + void (*Color3ubv)(const GLubyte * v); /* 20 */ + void (*Color3ui)(GLuint red, GLuint green, GLuint blue); /* 21 */ + void (*Color3uiv)(const GLuint * v); /* 22 */ + void (*Color3us)(GLushort red, GLushort green, GLushort blue); /* 23 */ + void (*Color3usv)(const GLushort * v); /* 24 */ + void (*Color4b)(GLbyte red, GLbyte green, GLbyte blue, GLbyte alpha); /* 25 */ + void (*Color4bv)(const GLbyte * v); /* 26 */ + void (*Color4d)(GLdouble red, GLdouble green, GLdouble blue, GLdouble alpha); /* 27 */ + void (*Color4dv)(const GLdouble * v); /* 28 */ + void (*Color4f)(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha); /* 29 */ + void (*Color4fv)(const GLfloat * v); /* 30 */ + void (*Color4i)(GLint red, GLint green, GLint blue, GLint alpha); /* 31 */ + void (*Color4iv)(const GLint * v); /* 32 */ + void (*Color4s)(GLshort red, GLshort green, GLshort blue, GLshort alpha); /* 33 */ + void (*Color4sv)(const GLshort * v); /* 34 */ + void (*Color4ub)(GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha); /* 35 */ + void (*Color4ubv)(const GLubyte * v); /* 36 */ + void (*Color4ui)(GLuint red, GLuint green, GLuint blue, GLuint alpha); /* 37 */ + void (*Color4uiv)(const GLuint * v); /* 38 */ + void (*Color4us)(GLushort red, GLushort green, GLushort blue, GLushort alpha); /* 39 */ + void (*Color4usv)(const GLushort * v); /* 40 */ + void (*EdgeFlag)(GLboolean flag); /* 41 */ + void (*EdgeFlagv)(const GLboolean * flag); /* 42 */ + void (*End)(void); /* 43 */ + void (*Indexd)(GLdouble c); /* 44 */ + void (*Indexdv)(const GLdouble * c); /* 45 */ + void (*Indexf)(GLfloat c); /* 46 */ + void (*Indexfv)(const GLfloat * c); /* 47 */ + void (*Indexi)(GLint c); /* 48 */ + void (*Indexiv)(const GLint * c); /* 49 */ + void (*Indexs)(GLshort c); /* 50 */ + void (*Indexsv)(const GLshort * c); /* 51 */ + void (*Normal3b)(GLbyte nx, GLbyte ny, GLbyte nz); /* 52 */ + void (*Normal3bv)(const GLbyte * v); /* 53 */ + void (*Normal3d)(GLdouble nx, GLdouble ny, GLdouble nz); /* 54 */ + void (*Normal3dv)(const GLdouble * v); /* 55 */ + void (*Normal3f)(GLfloat nx, GLfloat ny, GLfloat nz); /* 56 */ + void (*Normal3fv)(const GLfloat * v); /* 57 */ + void (*Normal3i)(GLint nx, GLint ny, GLint nz); /* 58 */ + void (*Normal3iv)(const GLint * v); /* 59 */ + void (*Normal3s)(GLshort nx, GLshort ny, GLshort nz); /* 60 */ + void (*Normal3sv)(const GLshort * v); /* 61 */ + void (*RasterPos2d)(GLdouble x, GLdouble y); /* 62 */ + void (*RasterPos2dv)(const GLdouble * v); /* 63 */ + void (*RasterPos2f)(GLfloat x, GLfloat y); /* 64 */ + void (*RasterPos2fv)(const GLfloat * v); /* 65 */ + void (*RasterPos2i)(GLint x, GLint y); /* 66 */ + void (*RasterPos2iv)(const GLint * v); /* 67 */ + void (*RasterPos2s)(GLshort x, GLshort y); /* 68 */ + void (*RasterPos2sv)(const GLshort * v); /* 69 */ + void (*RasterPos3d)(GLdouble x, GLdouble y, GLdouble z); /* 70 */ + void (*RasterPos3dv)(const GLdouble * v); /* 71 */ + void (*RasterPos3f)(GLfloat x, GLfloat y, GLfloat z); /* 72 */ + void (*RasterPos3fv)(const GLfloat * v); /* 73 */ + void (*RasterPos3i)(GLint x, GLint y, GLint z); /* 74 */ + void (*RasterPos3iv)(const GLint * v); /* 75 */ + void (*RasterPos3s)(GLshort x, GLshort y, GLshort z); /* 76 */ + void (*RasterPos3sv)(const GLshort * v); /* 77 */ + void (*RasterPos4d)(GLdouble x, GLdouble y, GLdouble z, GLdouble w); /* 78 */ + void (*RasterPos4dv)(const GLdouble * v); /* 79 */ + void (*RasterPos4f)(GLfloat x, GLfloat y, GLfloat z, GLfloat w); /* 80 */ + void (*RasterPos4fv)(const GLfloat * v); /* 81 */ + void (*RasterPos4i)(GLint x, GLint y, GLint z, GLint w); /* 82 */ + void (*RasterPos4iv)(const GLint * v); /* 83 */ + void (*RasterPos4s)(GLshort x, GLshort y, GLshort z, GLshort w); /* 84 */ + void (*RasterPos4sv)(const GLshort * v); /* 85 */ + void (*Rectd)(GLdouble x1, GLdouble y1, GLdouble x2, GLdouble y2); /* 86 */ + void (*Rectdv)(const GLdouble * v1, const GLdouble * v2); /* 87 */ + void (*Rectf)(GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2); /* 88 */ + void (*Rectfv)(const GLfloat * v1, const GLfloat * v2); /* 89 */ + void (*Recti)(GLint x1, GLint y1, GLint x2, GLint y2); /* 90 */ + void (*Rectiv)(const GLint * v1, const GLint * v2); /* 91 */ + void (*Rects)(GLshort x1, GLshort y1, GLshort x2, GLshort y2); /* 92 */ + void (*Rectsv)(const GLshort * v1, const GLshort * v2); /* 93 */ + void (*TexCoord1d)(GLdouble s); /* 94 */ + void (*TexCoord1dv)(const GLdouble * v); /* 95 */ + void (*TexCoord1f)(GLfloat s); /* 96 */ + void (*TexCoord1fv)(const GLfloat * v); /* 97 */ + void (*TexCoord1i)(GLint s); /* 98 */ + void (*TexCoord1iv)(const GLint * v); /* 99 */ + void (*TexCoord1s)(GLshort s); /* 100 */ + void (*TexCoord1sv)(const GLshort * v); /* 101 */ + void (*TexCoord2d)(GLdouble s, GLdouble t); /* 102 */ + void (*TexCoord2dv)(const GLdouble * v); /* 103 */ + void (*TexCoord2f)(GLfloat s, GLfloat t); /* 104 */ + void (*TexCoord2fv)(const GLfloat * v); /* 105 */ + void (*TexCoord2i)(GLint s, GLint t); /* 106 */ + void (*TexCoord2iv)(const GLint * v); /* 107 */ + void (*TexCoord2s)(GLshort s, GLshort t); /* 108 */ + void (*TexCoord2sv)(const GLshort * v); /* 109 */ + void (*TexCoord3d)(GLdouble s, GLdouble t, GLdouble r); /* 110 */ + void (*TexCoord3dv)(const GLdouble * v); /* 111 */ + void (*TexCoord3f)(GLfloat s, GLfloat t, GLfloat r); /* 112 */ + void (*TexCoord3fv)(const GLfloat * v); /* 113 */ + void (*TexCoord3i)(GLint s, GLint t, GLint r); /* 114 */ + void (*TexCoord3iv)(const GLint * v); /* 115 */ + void (*TexCoord3s)(GLshort s, GLshort t, GLshort r); /* 116 */ + void (*TexCoord3sv)(const GLshort * v); /* 117 */ + void (*TexCoord4d)(GLdouble s, GLdouble t, GLdouble r, GLdouble q); /* 118 */ + void (*TexCoord4dv)(const GLdouble * v); /* 119 */ + void (*TexCoord4f)(GLfloat s, GLfloat t, GLfloat r, GLfloat q); /* 120 */ + void (*TexCoord4fv)(const GLfloat * v); /* 121 */ + void (*TexCoord4i)(GLint s, GLint t, GLint r, GLint q); /* 122 */ + void (*TexCoord4iv)(const GLint * v); /* 123 */ + void (*TexCoord4s)(GLshort s, GLshort t, GLshort r, GLshort q); /* 124 */ + void (*TexCoord4sv)(const GLshort * v); /* 125 */ + void (*Vertex2d)(GLdouble x, GLdouble y); /* 126 */ + void (*Vertex2dv)(const GLdouble * v); /* 127 */ + void (*Vertex2f)(GLfloat x, GLfloat y); /* 128 */ + void (*Vertex2fv)(const GLfloat * v); /* 129 */ + void (*Vertex2i)(GLint x, GLint y); /* 130 */ + void (*Vertex2iv)(const GLint * v); /* 131 */ + void (*Vertex2s)(GLshort x, GLshort y); /* 132 */ + void (*Vertex2sv)(const GLshort * v); /* 133 */ + void (*Vertex3d)(GLdouble x, GLdouble y, GLdouble z); /* 134 */ + void (*Vertex3dv)(const GLdouble * v); /* 135 */ + void (*Vertex3f)(GLfloat x, GLfloat y, GLfloat z); /* 136 */ + void (*Vertex3fv)(const GLfloat * v); /* 137 */ + void (*Vertex3i)(GLint x, GLint y, GLint z); /* 138 */ + void (*Vertex3iv)(const GLint * v); /* 139 */ + void (*Vertex3s)(GLshort x, GLshort y, GLshort z); /* 140 */ + void (*Vertex3sv)(const GLshort * v); /* 141 */ + void (*Vertex4d)(GLdouble x, GLdouble y, GLdouble z, GLdouble w); /* 142 */ + void (*Vertex4dv)(const GLdouble * v); /* 143 */ + void (*Vertex4f)(GLfloat x, GLfloat y, GLfloat z, GLfloat w); /* 144 */ + void (*Vertex4fv)(const GLfloat * v); /* 145 */ + void (*Vertex4i)(GLint x, GLint y, GLint z, GLint w); /* 146 */ + void (*Vertex4iv)(const GLint * v); /* 147 */ + void (*Vertex4s)(GLshort x, GLshort y, GLshort z, GLshort w); /* 148 */ + void (*Vertex4sv)(const GLshort * v); /* 149 */ + void (*ClipPlane)(GLenum plane, const GLdouble * equation); /* 150 */ + void (*ColorMaterial)(GLenum face, GLenum mode); /* 151 */ + void (*CullFace)(GLenum mode); /* 152 */ + void (*Fogf)(GLenum pname, GLfloat param); /* 153 */ + void (*Fogfv)(GLenum pname, const GLfloat * params); /* 154 */ + void (*Fogi)(GLenum pname, GLint param); /* 155 */ + void (*Fogiv)(GLenum pname, const GLint * params); /* 156 */ + void (*FrontFace)(GLenum mode); /* 157 */ + void (*Hint)(GLenum target, GLenum mode); /* 158 */ + void (*Lightf)(GLenum light, GLenum pname, GLfloat param); /* 159 */ + void (*Lightfv)(GLenum light, GLenum pname, const GLfloat * params); /* 160 */ + void (*Lighti)(GLenum light, GLenum pname, GLint param); /* 161 */ + void (*Lightiv)(GLenum light, GLenum pname, const GLint * params); /* 162 */ + void (*LightModelf)(GLenum pname, GLfloat param); /* 163 */ + void (*LightModelfv)(GLenum pname, const GLfloat * params); /* 164 */ + void (*LightModeli)(GLenum pname, GLint param); /* 165 */ + void (*LightModeliv)(GLenum pname, const GLint * params); /* 166 */ + void (*LineStipple)(GLint factor, GLushort pattern); /* 167 */ + void (*LineWidth)(GLfloat width); /* 168 */ + void (*Materialf)(GLenum face, GLenum pname, GLfloat param); /* 169 */ + void (*Materialfv)(GLenum face, GLenum pname, const GLfloat * params); /* 170 */ + void (*Materiali)(GLenum face, GLenum pname, GLint param); /* 171 */ + void (*Materialiv)(GLenum face, GLenum pname, const GLint * params); /* 172 */ + void (*PointSize)(GLfloat size); /* 173 */ + void (*PolygonMode)(GLenum face, GLenum mode); /* 174 */ + void (*PolygonStipple)(const GLubyte * mask); /* 175 */ + void (*Scissor)(GLint x, GLint y, GLsizei width, GLsizei height); /* 176 */ + void (*ShadeModel)(GLenum mode); /* 177 */ + void (*TexParameterf)(GLenum target, GLenum pname, GLfloat param); /* 178 */ + void (*TexParameterfv)(GLenum target, GLenum pname, const GLfloat * params); /* 179 */ + void (*TexParameteri)(GLenum target, GLenum pname, GLint param); /* 180 */ + void (*TexParameteriv)(GLenum target, GLenum pname, const GLint * params); /* 181 */ + void (*TexImage1D)(GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const GLvoid * pixels); /* 182 */ + void (*TexImage2D)(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid * pixels); /* 183 */ + void (*TexEnvf)(GLenum target, GLenum pname, GLfloat param); /* 184 */ + void (*TexEnvfv)(GLenum target, GLenum pname, const GLfloat * params); /* 185 */ + void (*TexEnvi)(GLenum target, GLenum pname, GLint param); /* 186 */ + void (*TexEnviv)(GLenum target, GLenum pname, const GLint * params); /* 187 */ + void (*TexGend)(GLenum coord, GLenum pname, GLdouble param); /* 188 */ + void (*TexGendv)(GLenum coord, GLenum pname, const GLdouble * params); /* 189 */ + void (*TexGenf)(GLenum coord, GLenum pname, GLfloat param); /* 190 */ + void (*TexGenfv)(GLenum coord, GLenum pname, const GLfloat * params); /* 191 */ + void (*TexGeni)(GLenum coord, GLenum pname, GLint param); /* 192 */ + void (*TexGeniv)(GLenum coord, GLenum pname, const GLint * params); /* 193 */ + void (*FeedbackBuffer)(GLsizei size, GLenum type, GLfloat * buffer); /* 194 */ + void (*SelectBuffer)(GLsizei size, GLuint * buffer); /* 195 */ + GLint (*RenderMode)(GLenum mode); /* 196 */ + void (*InitNames)(void); /* 197 */ + void (*LoadName)(GLuint name); /* 198 */ + void (*PassThrough)(GLfloat token); /* 199 */ + void (*PopName)(void); /* 200 */ + void (*PushName)(GLuint name); /* 201 */ + void (*DrawBuffer)(GLenum mode); /* 202 */ + void (*Clear)(GLbitfield mask); /* 203 */ + void (*ClearAccum)(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha); /* 204 */ + void (*ClearIndex)(GLfloat c); /* 205 */ + void (*ClearColor)(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha); /* 206 */ + void (*ClearStencil)(GLint s); /* 207 */ + void (*ClearDepth)(GLclampd depth); /* 208 */ + void (*StencilMask)(GLuint mask); /* 209 */ + void (*ColorMask)(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha); /* 210 */ + void (*DepthMask)(GLboolean flag); /* 211 */ + void (*IndexMask)(GLuint mask); /* 212 */ + void (*Accum)(GLenum op, GLfloat value); /* 213 */ + void (*Disable)(GLenum cap); /* 214 */ + void (*Enable)(GLenum cap); /* 215 */ + void (*Finish)(void); /* 216 */ + void (*Flush)(void); /* 217 */ + void (*PopAttrib)(void); /* 218 */ + void (*PushAttrib)(GLbitfield mask); /* 219 */ + void (*Map1d)(GLenum target, GLdouble u1, GLdouble u2, GLint stride, GLint order, const GLdouble * points); /* 220 */ + void (*Map1f)(GLenum target, GLfloat u1, GLfloat u2, GLint stride, GLint order, const GLfloat * points); /* 221 */ + void (*Map2d)(GLenum target, GLdouble u1, GLdouble u2, GLint ustride, GLint uorder, GLdouble v1, GLdouble v2, GLint vstride, GLint vorder, const GLdouble * points); /* 222 */ + void (*Map2f)(GLenum target, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder, GLfloat v1, GLfloat v2, GLint vstride, GLint vorder, const GLfloat * points); /* 223 */ + void (*MapGrid1d)(GLint un, GLdouble u1, GLdouble u2); /* 224 */ + void (*MapGrid1f)(GLint un, GLfloat u1, GLfloat u2); /* 225 */ + void (*MapGrid2d)(GLint un, GLdouble u1, GLdouble u2, GLint vn, GLdouble v1, GLdouble v2); /* 226 */ + void (*MapGrid2f)(GLint un, GLfloat u1, GLfloat u2, GLint vn, GLfloat v1, GLfloat v2); /* 227 */ + void (*EvalCoord1d)(GLdouble u); /* 228 */ + void (*EvalCoord1dv)(const GLdouble * u); /* 229 */ + void (*EvalCoord1f)(GLfloat u); /* 230 */ + void (*EvalCoord1fv)(const GLfloat * u); /* 231 */ + void (*EvalCoord2d)(GLdouble u, GLdouble v); /* 232 */ + void (*EvalCoord2dv)(const GLdouble * u); /* 233 */ + void (*EvalCoord2f)(GLfloat u, GLfloat v); /* 234 */ + void (*EvalCoord2fv)(const GLfloat * u); /* 235 */ + void (*EvalMesh1)(GLenum mode, GLint i1, GLint i2); /* 236 */ + void (*EvalPoint1)(GLint i); /* 237 */ + void (*EvalMesh2)(GLenum mode, GLint i1, GLint i2, GLint j1, GLint j2); /* 238 */ + void (*EvalPoint2)(GLint i, GLint j); /* 239 */ + void (*AlphaFunc)(GLenum func, GLclampf ref); /* 240 */ + void (*BlendFunc)(GLenum sfactor, GLenum dfactor); /* 241 */ + void (*LogicOp)(GLenum opcode); /* 242 */ + void (*StencilFunc)(GLenum func, GLint ref, GLuint mask); /* 243 */ + void (*StencilOp)(GLenum fail, GLenum zfail, GLenum zpass); /* 244 */ + void (*DepthFunc)(GLenum func); /* 245 */ + void (*PixelZoom)(GLfloat xfactor, GLfloat yfactor); /* 246 */ + void (*PixelTransferf)(GLenum pname, GLfloat param); /* 247 */ + void (*PixelTransferi)(GLenum pname, GLint param); /* 248 */ + void (*PixelStoref)(GLenum pname, GLfloat param); /* 249 */ + void (*PixelStorei)(GLenum pname, GLint param); /* 250 */ + void (*PixelMapfv)(GLenum map, GLint mapsize, const GLfloat * values); /* 251 */ + void (*PixelMapuiv)(GLenum map, GLint mapsize, const GLuint * values); /* 252 */ + void (*PixelMapusv)(GLenum map, GLint mapsize, const GLushort * values); /* 253 */ + void (*ReadBuffer)(GLenum mode); /* 254 */ + void (*CopyPixels)(GLint x, GLint y, GLsizei width, GLsizei height, GLenum type); /* 255 */ + void (*ReadPixels)(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid * pixels); /* 256 */ + void (*DrawPixels)(GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid * pixels); /* 257 */ + void (*GetBooleanv)(GLenum pname, GLboolean * params); /* 258 */ + void (*GetClipPlane)(GLenum plane, GLdouble * equation); /* 259 */ + void (*GetDoublev)(GLenum pname, GLdouble * params); /* 260 */ + GLenum (*GetError)(void); /* 261 */ + void (*GetFloatv)(GLenum pname, GLfloat * params); /* 262 */ + void (*GetIntegerv)(GLenum pname, GLint * params); /* 263 */ + void (*GetLightfv)(GLenum light, GLenum pname, GLfloat * params); /* 264 */ + void (*GetLightiv)(GLenum light, GLenum pname, GLint * params); /* 265 */ + void (*GetMapdv)(GLenum target, GLenum query, GLdouble * v); /* 266 */ + void (*GetMapfv)(GLenum target, GLenum query, GLfloat * v); /* 267 */ + void (*GetMapiv)(GLenum target, GLenum query, GLint * v); /* 268 */ + void (*GetMaterialfv)(GLenum face, GLenum pname, GLfloat * params); /* 269 */ + void (*GetMaterialiv)(GLenum face, GLenum pname, GLint * params); /* 270 */ + void (*GetPixelMapfv)(GLenum map, GLfloat * values); /* 271 */ + void (*GetPixelMapuiv)(GLenum map, GLuint * values); /* 272 */ + void (*GetPixelMapusv)(GLenum map, GLushort * values); /* 273 */ + void (*GetPolygonStipple)(GLubyte * mask); /* 274 */ + const GLubyte * (*GetString)(GLenum name); /* 275 */ + void (*GetTexEnvfv)(GLenum target, GLenum pname, GLfloat * params); /* 276 */ + void (*GetTexEnviv)(GLenum target, GLenum pname, GLint * params); /* 277 */ + void (*GetTexGendv)(GLenum coord, GLenum pname, GLdouble * params); /* 278 */ + void (*GetTexGenfv)(GLenum coord, GLenum pname, GLfloat * params); /* 279 */ + void (*GetTexGeniv)(GLenum coord, GLenum pname, GLint * params); /* 280 */ + void (*GetTexImage)(GLenum target, GLint level, GLenum format, GLenum type, GLvoid * pixels); /* 281 */ + void (*GetTexParameterfv)(GLenum target, GLenum pname, GLfloat * params); /* 282 */ + void (*GetTexParameteriv)(GLenum target, GLenum pname, GLint * params); /* 283 */ + void (*GetTexLevelParameterfv)(GLenum target, GLint level, GLenum pname, GLfloat * params); /* 284 */ + void (*GetTexLevelParameteriv)(GLenum target, GLint level, GLenum pname, GLint * params); /* 285 */ + GLboolean (*IsEnabled)(GLenum cap); /* 286 */ + GLboolean (*IsList)(GLuint list); /* 287 */ + void (*DepthRange)(GLclampd near, GLclampd far); /* 288 */ + void (*Frustum)(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar); /* 289 */ + void (*LoadIdentity)(void); /* 290 */ + void (*LoadMatrixf)(const GLfloat * m); /* 291 */ + void (*LoadMatrixd)(const GLdouble * m); /* 292 */ + void (*MatrixMode)(GLenum mode); /* 293 */ + void (*MultMatrixf)(const GLfloat * m); /* 294 */ + void (*MultMatrixd)(const GLdouble * m); /* 295 */ + void (*Ortho)(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar); /* 296 */ + void (*PopMatrix)(void); /* 297 */ + void (*PushMatrix)(void); /* 298 */ + void (*Rotated)(GLdouble angle, GLdouble x, GLdouble y, GLdouble z); /* 299 */ + void (*Rotatef)(GLfloat angle, GLfloat x, GLfloat y, GLfloat z); /* 300 */ + void (*Scaled)(GLdouble x, GLdouble y, GLdouble z); /* 301 */ + void (*Scalef)(GLfloat x, GLfloat y, GLfloat z); /* 302 */ + void (*Translated)(GLdouble x, GLdouble y, GLdouble z); /* 303 */ + void (*Translatef)(GLfloat x, GLfloat y, GLfloat z); /* 304 */ + void (*Viewport)(GLint x, GLint y, GLsizei width, GLsizei height); /* 305 */ + void (*ArrayElement)(GLint i); /* 306 */ + void (*BindTexture)(GLenum target, GLenum texture); /* 307 */ + void (*ColorPointer)(GLint size, GLenum type, GLsizei stride, const GLvoid * pointer); /* 308 */ + void (*DisableClientState)(GLenum array); /* 309 */ + void (*DrawArrays)(GLenum mode, GLint first, GLsizei count); /* 310 */ + void (*DrawElements)(GLenum mode, GLsizei count, GLenum type, const GLvoid * indices); /* 311 */ + void (*EdgeFlagPointer)(GLsizei stride, const GLvoid * pointer); /* 312 */ + void (*EnableClientState)(GLenum array); /* 313 */ + void (*IndexPointer)(GLenum type, GLsizei stride, const GLvoid * pointer); /* 314 */ + void (*Indexub)(GLubyte c); /* 315 */ + void (*Indexubv)(const GLubyte * c); /* 316 */ + void (*InterleavedArrays)(GLenum format, GLsizei stride, const GLvoid * pointer); /* 317 */ + void (*NormalPointer)(GLenum type, GLsizei stride, const GLvoid * pointer); /* 318 */ + void (*PolygonOffset)(GLfloat factor, GLfloat units); /* 319 */ + void (*TexCoordPointer)(GLint size, GLenum type, GLsizei stride, const GLvoid * pointer); /* 320 */ + void (*VertexPointer)(GLint size, GLenum type, GLsizei stride, const GLvoid * pointer); /* 321 */ + GLboolean (*AreTexturesResident)(GLsizei n, const GLenum * textures, GLboolean * residences); /* 322 */ + void (*CopyTexImage1D)(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLint border); /* 323 */ + void (*CopyTexImage2D)(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border); /* 324 */ + void (*CopyTexSubImage1D)(GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width); /* 325 */ + void (*CopyTexSubImage2D)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height); /* 326 */ + void (*DeleteTextures)(GLsizei n, const GLenum * textures); /* 327 */ + void (*GenTextures)(GLsizei n, GLenum * textures); /* 328 */ + void (*GetPointerv)(GLenum pname, GLvoid * * params); /* 329 */ + GLboolean (*IsTexture)(GLenum texture); /* 330 */ + void (*PrioritizeTextures)(GLsizei n, const GLenum * textures, const GLclampf * priorities); /* 331 */ + void (*TexSubImage1D)(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const GLvoid * pixels); /* 332 */ + void (*TexSubImage2D)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid * pixels); /* 333 */ + void (*PopClientAttrib)(void); /* 334 */ + void (*PushClientAttrib)(GLbitfield mask); /* 335 */ + void (*BlendColor)(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha); /* 336 */ + void (*BlendEquation)(GLenum mode); /* 337 */ + void (*DrawRangeElements)(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid * indices); /* 338 */ + void (*ColorTable)(GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const GLvoid * table); /* 339 */ + void (*ColorTableParameterfv)(GLenum target, GLenum pname, const GLfloat * params); /* 340 */ + void (*ColorTableParameteriv)(GLenum target, GLenum pname, const GLint * params); /* 341 */ + void (*CopyColorTable)(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width); /* 342 */ + void (*GetColorTable)(GLenum target, GLenum format, GLenum type, GLvoid * table); /* 343 */ + void (*GetColorTableParameterfv)(GLenum target, GLenum pname, GLfloat * params); /* 344 */ + void (*GetColorTableParameteriv)(GLenum target, GLenum pname, GLint * params); /* 345 */ + void (*ColorSubTable)(GLenum target, GLsizei start, GLsizei count, GLenum format, GLenum type, const GLvoid * data); /* 346 */ + void (*CopyColorSubTable)(GLenum target, GLsizei start, GLint x, GLint y, GLsizei width); /* 347 */ + void (*ConvolutionFilter1D)(GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const GLvoid * image); /* 348 */ + void (*ConvolutionFilter2D)(GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid * image); /* 349 */ + void (*ConvolutionParameterf)(GLenum target, GLenum pname, GLfloat params); /* 350 */ + void (*ConvolutionParameterfv)(GLenum target, GLenum pname, const GLfloat * params); /* 351 */ + void (*ConvolutionParameteri)(GLenum target, GLenum pname, GLint params); /* 352 */ + void (*ConvolutionParameteriv)(GLenum target, GLenum pname, const GLint * params); /* 353 */ + void (*CopyConvolutionFilter1D)(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width); /* 354 */ + void (*CopyConvolutionFilter2D)(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height); /* 355 */ + void (*GetConvolutionFilter)(GLenum target, GLenum format, GLenum type, GLvoid * image); /* 356 */ + void (*GetConvolutionParameterfv)(GLenum target, GLenum pname, GLfloat * params); /* 357 */ + void (*GetConvolutionParameteriv)(GLenum target, GLenum pname, GLint * params); /* 358 */ + void (*GetSeparableFilter)(GLenum target, GLenum format, GLenum type, GLvoid * row, GLvoid * column, GLvoid * span); /* 359 */ + void (*SeparableFilter2D)(GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid * row, const GLvoid * column); /* 360 */ + void (*GetHistogram)(GLenum target, GLboolean reset, GLenum format, GLenum type, GLvoid * values); /* 361 */ + void (*GetHistogramParameterfv)(GLenum target, GLenum pname, GLfloat * params); /* 362 */ + void (*GetHistogramParameteriv)(GLenum target, GLenum pname, GLint * params); /* 363 */ + void (*GetMinmax)(GLenum target, GLboolean reset, GLenum format, GLenum type, GLvoid * values); /* 364 */ + void (*GetMinmaxParameterfv)(GLenum target, GLenum pname, GLfloat * params); /* 365 */ + void (*GetMinmaxParameteriv)(GLenum target, GLenum pname, GLint * params); /* 366 */ + void (*Histogram)(GLenum target, GLsizei width, GLenum internalformat, GLboolean sink); /* 367 */ + void (*Minmax)(GLenum target, GLenum internalformat, GLboolean sink); /* 368 */ + void (*ResetHistogram)(GLenum target); /* 369 */ + void (*ResetMinmax)(GLenum target); /* 370 */ + void (*TexImage3D)(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const GLvoid * pixels); /* 371 */ + void (*TexSubImage3D)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const GLvoid * pixels); /* 372 */ + void (*CopyTexSubImage3D)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height); /* 373 */ + void (*ActiveTextureARB)(GLenum texture); /* 374 */ + void (*ClientActiveTextureARB)(GLenum texture); /* 375 */ + void (*MultiTexCoord1dARB)(GLenum target, GLdouble s); /* 376 */ + void (*MultiTexCoord1dvARB)(GLenum target, const GLdouble * v); /* 377 */ + void (*MultiTexCoord1fARB)(GLenum target, GLfloat s); /* 378 */ + void (*MultiTexCoord1fvARB)(GLenum target, const GLfloat * v); /* 379 */ + void (*MultiTexCoord1iARB)(GLenum target, GLint s); /* 380 */ + void (*MultiTexCoord1ivARB)(GLenum target, const GLint * v); /* 381 */ + void (*MultiTexCoord1sARB)(GLenum target, GLshort s); /* 382 */ + void (*MultiTexCoord1svARB)(GLenum target, const GLshort * v); /* 383 */ + void (*MultiTexCoord2dARB)(GLenum target, GLdouble s, GLdouble t); /* 384 */ + void (*MultiTexCoord2dvARB)(GLenum target, const GLdouble * v); /* 385 */ + void (*MultiTexCoord2fARB)(GLenum target, GLfloat s, GLfloat t); /* 386 */ + void (*MultiTexCoord2fvARB)(GLenum target, const GLfloat * v); /* 387 */ + void (*MultiTexCoord2iARB)(GLenum target, GLint s, GLint t); /* 388 */ + void (*MultiTexCoord2ivARB)(GLenum target, const GLint * v); /* 389 */ + void (*MultiTexCoord2sARB)(GLenum target, GLshort s, GLshort t); /* 390 */ + void (*MultiTexCoord2svARB)(GLenum target, const GLshort * v); /* 391 */ + void (*MultiTexCoord3dARB)(GLenum target, GLdouble s, GLdouble t, GLdouble r); /* 392 */ + void (*MultiTexCoord3dvARB)(GLenum target, const GLdouble * v); /* 393 */ + void (*MultiTexCoord3fARB)(GLenum target, GLfloat s, GLfloat t, GLfloat r); /* 394 */ + void (*MultiTexCoord3fvARB)(GLenum target, const GLfloat * v); /* 395 */ + void (*MultiTexCoord3iARB)(GLenum target, GLint s, GLint t, GLint r); /* 396 */ + void (*MultiTexCoord3ivARB)(GLenum target, const GLint * v); /* 397 */ + void (*MultiTexCoord3sARB)(GLenum target, GLshort s, GLshort t, GLshort r); /* 398 */ + void (*MultiTexCoord3svARB)(GLenum target, const GLshort * v); /* 399 */ + void (*MultiTexCoord4dARB)(GLenum target, GLdouble s, GLdouble t, GLdouble r, GLdouble q); /* 400 */ + void (*MultiTexCoord4dvARB)(GLenum target, const GLdouble * v); /* 401 */ + void (*MultiTexCoord4fARB)(GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q); /* 402 */ + void (*MultiTexCoord4fvARB)(GLenum target, const GLfloat * v); /* 403 */ + void (*MultiTexCoord4iARB)(GLenum target, GLint s, GLint t, GLint r, GLint q); /* 404 */ + void (*MultiTexCoord4ivARB)(GLenum target, const GLint * v); /* 405 */ + void (*MultiTexCoord4sARB)(GLenum target, GLshort s, GLshort t, GLshort r, GLshort q); /* 406 */ + void (*MultiTexCoord4svARB)(GLenum target, const GLshort * v); /* 407 */ + void (*LoadTransposeMatrixfARB)(const GLfloat * m); /* 408 */ + void (*LoadTransposeMatrixdARB)(const GLdouble * m); /* 409 */ + void (*MultTransposeMatrixfARB)(const GLfloat * m); /* 410 */ + void (*MultTransposeMatrixdARB)(const GLdouble * m); /* 411 */ + void (*SampleCoverageARB)(GLclampf value, GLboolean invert); /* 412 */ + void (*SamplePassARB)(GLenum pass); /* 413 */ + void (*PolygonOffsetEXT)(GLfloat factor, GLfloat bias); /* 414 */ + void (*GetTexFilterFuncSGIS)(GLenum target, GLenum filter, GLfloat * weights); /* 415 */ + void (*TexFilterFuncSGIS)(GLenum target, GLenum filter, GLsizei n, const GLfloat * weights); /* 416 */ + void (*GetHistogramEXT)(GLenum target, GLboolean reset, GLenum format, GLenum type, GLvoid * values); /* 417 */ + void (*GetHistogramParameterfvEXT)(GLenum target, GLenum pname, GLfloat * params); /* 418 */ + void (*GetHistogramParameterivEXT)(GLenum target, GLenum pname, GLint * params); /* 419 */ + void (*GetMinmaxEXT)(GLenum target, GLboolean reset, GLenum format, GLenum type, GLvoid * values); /* 420 */ + void (*GetMinmaxParameterfvEXT)(GLenum target, GLenum pname, GLfloat * params); /* 421 */ + void (*GetMinmaxParameterivEXT)(GLenum target, GLenum pname, GLint * params); /* 422 */ + void (*GetConvolutionFilterEXT)(GLenum target, GLenum format, GLenum type, GLvoid * image); /* 423 */ + void (*GetConvolutionParameterfvEXT)(GLenum target, GLenum pname, GLfloat * params); /* 424 */ + void (*GetConvolutionParameterivEXT)(GLenum target, GLenum pname, GLint * params); /* 425 */ + void (*GetSeparableFilterEXT)(GLenum target, GLenum format, GLenum type, GLvoid * row, GLvoid * column, GLvoid * span); /* 426 */ + void (*GetColorTableSGI)(GLenum target, GLenum format, GLenum type, GLvoid * table); /* 427 */ + void (*GetColorTableParameterfvSGI)(GLenum target, GLenum pname, GLfloat * params); /* 428 */ + void (*GetColorTableParameterivSGI)(GLenum target, GLenum pname, GLint * params); /* 429 */ + void (*PixelTexGenSGIX)(GLenum mode); /* 430 */ + void (*PixelTexGenParameteriSGIS)(GLenum pname, GLint param); /* 431 */ + void (*PixelTexGenParameterivSGIS)(GLenum pname, const GLint * params); /* 432 */ + void (*PixelTexGenParameterfSGIS)(GLenum pname, GLfloat param); /* 433 */ + void (*PixelTexGenParameterfvSGIS)(GLenum pname, const GLfloat * params); /* 434 */ + void (*GetPixelTexGenParameterivSGIS)(GLenum pname, GLint * params); /* 435 */ + void (*GetPixelTexGenParameterfvSGIS)(GLenum pname, GLfloat * params); /* 436 */ + void (*TexImage4DSGIS)(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLsizei size4d, GLint border, GLenum format, GLenum type, const GLvoid * pixels); /* 437 */ + void (*TexSubImage4DSGIS)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint woffset, GLsizei width, GLsizei height, GLsizei depth, GLsizei size4d, GLenum format, GLenum type, const GLvoid * pixels); /* 438 */ + GLboolean (*AreTexturesResidentEXT)(GLsizei n, const GLenum * textures, GLboolean * residences); /* 439 */ + void (*GenTexturesEXT)(GLsizei n, GLenum * textures); /* 440 */ + GLboolean (*IsTextureEXT)(GLenum texture); /* 441 */ + void (*DetailTexFuncSGIS)(GLenum target, GLsizei n, const GLfloat * points); /* 442 */ + void (*GetDetailTexFuncSGIS)(GLenum target, GLfloat * points); /* 443 */ + void (*SharpenTexFuncSGIS)(GLenum target, GLsizei n, const GLfloat * points); /* 444 */ + void (*GetSharpenTexFuncSGIS)(GLenum target, GLfloat * points); /* 445 */ + void (*SampleMaskSGIS)(GLclampf value, GLboolean invert); /* 446 */ + void (*SamplePatternSGIS)(GLenum pattern); /* 447 */ + void (*ColorPointerEXT)(GLint size, GLenum type, GLsizei stride, GLsizei count, const GLvoid * pointer); /* 448 */ + void (*EdgeFlagPointerEXT)(GLsizei stride, GLsizei count, const GLboolean * pointer); /* 449 */ + void (*IndexPointerEXT)(GLenum type, GLsizei stride, GLsizei count, const GLvoid * pointer); /* 450 */ + void (*NormalPointerEXT)(GLenum type, GLsizei stride, GLsizei count, const GLvoid * pointer); /* 451 */ + void (*TexCoordPointerEXT)(GLint size, GLenum type, GLsizei stride, GLsizei count, const GLvoid * pointer); /* 452 */ + void (*VertexPointerEXT)(GLint size, GLenum type, GLsizei stride, GLsizei count, const GLvoid * pointer); /* 453 */ + void (*SpriteParameterfSGIX)(GLenum pname, GLfloat param); /* 454 */ + void (*SpriteParameterfvSGIX)(GLenum pname, const GLfloat * params); /* 455 */ + void (*SpriteParameteriSGIX)(GLenum pname, GLint param); /* 456 */ + void (*SpriteParameterivSGIX)(GLenum pname, const GLint * params); /* 457 */ + void (*PointParameterfEXT)(GLenum pname, GLfloat param); /* 458 */ + void (*PointParameterfvEXT)(GLenum pname, const GLfloat * params); /* 459 */ + GLint (*GetInstrumentsSGIX)(void); /* 460 */ + void (*InstrumentsBufferSGIX)(GLsizei size, GLint * buffer); /* 461 */ + GLint (*PollInstrumentsSGIX)(GLint * marker_p); /* 462 */ + void (*ReadInstrumentsSGIX)(GLint marker); /* 463 */ + void (*StartInstrumentsSGIX)(void); /* 464 */ + void (*StopInstrumentsSGIX)(GLint marker); /* 465 */ + void (*FrameZoomSGIX)(GLint factor); /* 466 */ + void (*TagSampleBufferSGIX)(void); /* 467 */ + void (*ReferencePlaneSGIX)(const GLdouble * equation); /* 468 */ + void (*FlushRasterSGIX)(void); /* 469 */ + void (*GetListParameterfvSGIX)(GLuint list, GLenum pname, GLfloat * params); /* 470 */ + void (*GetListParameterivSGIX)(GLuint list, GLenum pname, GLint * params); /* 471 */ + void (*ListParameterfSGIX)(GLuint list, GLenum pname, GLfloat param); /* 472 */ + void (*ListParameterfvSGIX)(GLuint list, GLenum pname, const GLfloat * params); /* 473 */ + void (*ListParameteriSGIX)(GLuint list, GLenum pname, GLint param); /* 474 */ + void (*ListParameterivSGIX)(GLuint list, GLenum pname, const GLint * params); /* 475 */ + void (*FragmentColorMaterialSGIX)(GLenum face, GLenum mode); /* 476 */ + void (*FragmentLightfSGIX)(GLenum light, GLenum pname, GLfloat param); /* 477 */ + void (*FragmentLightfvSGIX)(GLenum light, GLenum pname, const GLfloat * params); /* 478 */ + void (*FragmentLightiSGIX)(GLenum light, GLenum pname, GLint param); /* 479 */ + void (*FragmentLightivSGIX)(GLenum light, GLenum pname, const GLint * params); /* 480 */ + void (*FragmentLightModelfSGIX)(GLenum pname, GLfloat param); /* 481 */ + void (*FragmentLightModelfvSGIX)(GLenum pname, const GLfloat * params); /* 482 */ + void (*FragmentLightModeliSGIX)(GLenum pname, GLint param); /* 483 */ + void (*FragmentLightModelivSGIX)(GLenum pname, const GLint * params); /* 484 */ + void (*FragmentMaterialfSGIX)(GLenum face, GLenum pname, GLfloat param); /* 485 */ + void (*FragmentMaterialfvSGIX)(GLenum face, GLenum pname, const GLfloat * params); /* 486 */ + void (*FragmentMaterialiSGIX)(GLenum face, GLenum pname, GLint param); /* 487 */ + void (*FragmentMaterialivSGIX)(GLenum face, GLenum pname, const GLint * params); /* 488 */ + void (*GetFragmentLightfvSGIX)(GLenum light, GLenum pname, GLfloat * params); /* 489 */ + void (*GetFragmentLightivSGIX)(GLenum light, GLenum pname, GLint * params); /* 490 */ + void (*GetFragmentMaterialfvSGIX)(GLenum face, GLenum pname, GLfloat * params); /* 491 */ + void (*GetFragmentMaterialivSGIX)(GLenum face, GLenum pname, GLint * params); /* 492 */ + void (*LightEnviSGIX)(GLenum pname, GLint param); /* 493 */ + void (*VertexWeightfEXT)(GLfloat weight); /* 494 */ + void (*VertexWeightfvEXT)(const GLfloat * weight); /* 495 */ + void (*VertexWeightPointerEXT)(GLsizei size, GLenum type, GLsizei stride, const GLvoid * pointer); /* 496 */ + void (*FlushVertexArrayRangeNV)(void); /* 497 */ + void (*VertexArrayRangeNV)(GLsizei size, const GLvoid * pointer); /* 498 */ + void (*CombinerParameterfvNV)(GLenum pname, const GLfloat * params); /* 499 */ + void (*CombinerParameterfNV)(GLenum pname, GLfloat param); /* 500 */ + void (*CombinerParameterivNV)(GLenum pname, const GLint * params); /* 501 */ + void (*CombinerParameteriNV)(GLenum pname, GLint param); /* 502 */ + void (*CombinerInputNV)(GLenum stage, GLenum portion, GLenum variable, GLenum input, GLenum mapping, GLenum componentUsage); /* 503 */ + void (*CombinerOutputNV)(GLenum stage, GLenum portion, GLenum abOutput, GLenum cdOutput, GLenum sumOutput, GLenum scale, GLenum bias, GLboolean abDotProduct, GLboolean cdDotProduct, GLboolean muxSum); /* 504 */ + void (*FinalCombinerInputNV)(GLenum variable, GLenum input, GLenum mapping, GLenum componentUsage); /* 505 */ + void (*GetCombinerInputParameterfvNV)(GLenum stage, GLenum portion, GLenum variable, GLenum pname, GLfloat * params); /* 506 */ + void (*GetCombinerInputParameterivNV)(GLenum stage, GLenum portion, GLenum variable, GLenum pname, GLint * params); /* 507 */ + void (*GetCombinerOutputParameterfvNV)(GLenum stage, GLenum portion, GLenum pname, GLfloat * params); /* 508 */ + void (*GetCombinerOutputParameterivNV)(GLenum stage, GLenum portion, GLenum pname, GLint * params); /* 509 */ + void (*GetFinalCombinerInputParameterfvNV)(GLenum variable, GLenum pname, GLfloat * params); /* 510 */ + void (*GetFinalCombinerInputParameterivNV)(GLenum variable, GLenum pname, GLint * params); /* 511 */ + void (*ResizeBuffersMESA)(void); /* 512 */ + void (*WindowPos2dMESA)(GLdouble x, GLdouble y); /* 513 */ + void (*WindowPos2dvMESA)(const GLdouble * v); /* 514 */ + void (*WindowPos2fMESA)(GLfloat x, GLfloat y); /* 515 */ + void (*WindowPos2fvMESA)(const GLfloat * v); /* 516 */ + void (*WindowPos2iMESA)(GLint x, GLint y); /* 517 */ + void (*WindowPos2ivMESA)(const GLint * v); /* 518 */ + void (*WindowPos2sMESA)(GLshort x, GLshort y); /* 519 */ + void (*WindowPos2svMESA)(const GLshort * v); /* 520 */ + void (*WindowPos3dMESA)(GLdouble x, GLdouble y, GLdouble z); /* 521 */ + void (*WindowPos3dvMESA)(const GLdouble * v); /* 522 */ + void (*WindowPos3fMESA)(GLfloat x, GLfloat y, GLfloat z); /* 523 */ + void (*WindowPos3fvMESA)(const GLfloat * v); /* 524 */ + void (*WindowPos3iMESA)(GLint x, GLint y, GLint z); /* 525 */ + void (*WindowPos3ivMESA)(const GLint * v); /* 526 */ + void (*WindowPos3sMESA)(GLshort x, GLshort y, GLshort z); /* 527 */ + void (*WindowPos3svMESA)(const GLshort * v); /* 528 */ + void (*WindowPos4dMESA)(GLdouble x, GLdouble y, GLdouble z, GLdouble w); /* 529 */ + void (*WindowPos4dvMESA)(const GLdouble * v); /* 530 */ + void (*WindowPos4fMESA)(GLfloat x, GLfloat y, GLfloat z, GLfloat w); /* 531 */ + void (*WindowPos4fvMESA)(const GLfloat * v); /* 532 */ + void (*WindowPos4iMESA)(GLint x, GLint y, GLint z, GLint w); /* 533 */ + void (*WindowPos4ivMESA)(const GLint * v); /* 534 */ + void (*WindowPos4sMESA)(GLshort x, GLshort y, GLshort z, GLshort w); /* 535 */ + void (*WindowPos4svMESA)(const GLshort * v); /* 536 */ + void (*BlendFuncSeparateEXT)(GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha); /* 537 */ + void (*IndexMaterialEXT)(GLenum face, GLenum mode); /* 538 */ + void (*IndexFuncEXT)(GLenum func, GLclampf ref); /* 539 */ + void (*LockArraysEXT)(GLint first, GLsizei count); /* 540 */ + void (*UnlockArraysEXT)(void); /* 541 */ + void (*CullParameterdvEXT)(GLenum pname, const GLdouble * params); /* 542 */ + void (*CullParameterfvEXT)(GLenum pname, const GLfloat * params); /* 543 */ + void (*HintPGI)(GLenum target, GLint mode); /* 544 */ + void (*FogCoordfEXT)(GLfloat coord); /* 545 */ + void (*FogCoordfvEXT)(const GLfloat * coord); /* 546 */ + void (*FogCoorddEXT)(GLdouble coord); /* 547 */ + void (*FogCoorddvEXT)(const GLdouble * coord); /* 548 */ + void (*FogCoordPointerEXT)(GLenum type, GLsizei stride, const GLvoid * pointer); /* 549 */ + void (*GetColorTableEXT)(GLenum target, GLenum format, GLenum type, GLvoid * data); /* 550 */ + void (*GetColorTableParameterivEXT)(GLenum target, GLenum pname, GLint * params); /* 551 */ + void (*GetColorTableParameterfvEXT)(GLenum target, GLenum pname, GLfloat * params); /* 552 */ }; - #endif diff --git a/xc/extras/Mesa/src/glapitemp.h b/xc/extras/Mesa/src/glapitemp.h index aa3357a38..7b940def6 100644 --- a/xc/extras/Mesa/src/glapitemp.h +++ b/xc/extras/Mesa/src/glapitemp.h @@ -1978,7 +1978,7 @@ KEYWORD1 void KEYWORD2 NAME(SeparableFilter2D)(GLenum target, GLenum internalfor -/* GL_ARB_multitexture */ +/* ARB 0. GL_ARB_multitexture */ KEYWORD1 void KEYWORD2 NAME(ActiveTextureARB)(GLenum texture) { @@ -2160,7 +2160,7 @@ KEYWORD1 void KEYWORD2 NAME(MultiTexCoord4svARB)(GLenum target, const GLshort *v /* 2. GL_EXT_blend_color */ KEYWORD1 void KEYWORD2 NAME(BlendColorEXT)(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha) { - DISPATCH(BlendColorEXT, (red, green, blue, alpha), (F, ";")); + DISPATCH(BlendColor, (red, green, blue, alpha), (F, ";")); } @@ -2177,31 +2177,31 @@ KEYWORD1 void KEYWORD2 NAME(PolygonOffsetEXT)(GLfloat factor, GLfloat bias) KEYWORD1 void KEYWORD2 NAME(CopyTexSubImage3DEXT)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height) { - DISPATCH(CopyTexSubImage3DEXT, (target, level, xoffset, yoffset, zoffset, x, y, width, height), (F, ";")); + DISPATCH(CopyTexSubImage3D, (target, level, xoffset, yoffset, zoffset, x, y, width, height), (F, ";")); } KEYWORD1 void KEYWORD2 NAME(TexImage3DEXT)(GLenum target, GLint level, GLenum internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const GLvoid *pixels) { - DISPATCH(TexImage3DEXT, (target, level, internalFormat, width, height, depth, border, format, type, pixels), (F, ";")); + DISPATCH(TexImage3D, (target, level, internalFormat, width, height, depth, border, format, type, pixels), (F, ";")); } KEYWORD1 void KEYWORD2 NAME(TexSubImage3DEXT)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const GLvoid *pixels) { - DISPATCH(TexSubImage3DEXT, (target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels), (F, ";")); + DISPATCH(TexSubImage3D, (target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels), (F, ";")); } /* 7. GL_SGI_texture_filter4 */ -KEYWORD1 void KEYWORD2 NAME(GetTexFilterFuncSGIS)(GLenum target, GLenum filter, GLsizei n, const GLfloat *weights) +KEYWORD1 void KEYWORD2 NAME(GetTexFilterFuncSGIS)(GLenum target, GLenum filter, GLfloat *weights) { - DISPATCH(GetTexFilterFuncSGIS, (target, filter, n, weights), (F, ";")); + DISPATCH(GetTexFilterFuncSGIS, (target, filter, weights), (F, ";")); } -KEYWORD1 void KEYWORD2 NAME(TexFilterFuncSGIS)(GLenum target, GLenum filter, GLfloat *weights) +KEYWORD1 void KEYWORD2 NAME(TexFilterFuncSGIS)(GLenum target, GLenum filter, GLsizei n, const GLfloat *weights) { - DISPATCH(TexFilterFuncSGIS, (target, filter, weights), (F, ";")); + DISPATCH(TexFilterFuncSGIS, (target, filter, n, weights), (F, ";")); } @@ -2210,17 +2210,17 @@ KEYWORD1 void KEYWORD2 NAME(TexFilterFuncSGIS)(GLenum target, GLenum filter, GLf KEYWORD1 void KEYWORD2 NAME(CopyTexSubImage1DEXT)(GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width) { - DISPATCH(CopyTexSubImage1DEXT, (target, level, xoffset, x, y, width), (F, ";")); + DISPATCH(CopyTexSubImage1D, (target, level, xoffset, x, y, width), (F, ";")); } KEYWORD1 void KEYWORD2 NAME(TexSubImage1DEXT)(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const GLvoid *pixels) { - DISPATCH(TexSubImage1DEXT, (target, level, xoffset, width, format, type, pixels), (F, ";")); + DISPATCH(TexSubImage1D, (target, level, xoffset, width, format, type, pixels), (F, ";")); } KEYWORD1 void KEYWORD2 NAME(TexSubImage2DEXT)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels) { - DISPATCH(TexSubImage2DEXT, (target, level, xoffset, yoffset, width, height, format, type, pixels), (F, ";")); + DISPATCH(TexSubImage2D, (target, level, xoffset, yoffset, width, height, format, type, pixels), (F, ";")); } @@ -2228,18 +2228,18 @@ KEYWORD1 void KEYWORD2 NAME(TexSubImage2DEXT)(GLenum target, GLint level, GLint KEYWORD1 void KEYWORD2 NAME(CopyTexImage1DEXT)(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLint border) { - DISPATCH(CopyTexImage1DEXT, (target, level, internalformat, x, y, width, border), (F, ";")); + DISPATCH(CopyTexImage1D, (target, level, internalformat, x, y, width, border), (F, ";")); } KEYWORD1 void KEYWORD2 NAME(CopyTexImage2DEXT)(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border) { - DISPATCH(CopyTexImage2DEXT, (target, level, internalformat, x, y, width, height, border), (F, ";")); + DISPATCH(CopyTexImage2D, (target, level, internalformat, x, y, width, height, border), (F, ";")); } KEYWORD1 void KEYWORD2 NAME(CopyTexSubImage2DEXT)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height) { - DISPATCH(CopyTexSubImage2DEXT, (target, level, xoffset, yoffset, x, y, width, height), (F, ";")); + DISPATCH(CopyTexSubImage2D, (target, level, xoffset, yoffset, x, y, width, height), (F, ";")); } @@ -2277,22 +2277,22 @@ KEYWORD1 void KEYWORD2 NAME(GetMinmaxParameterivEXT)(GLenum target, GLenum pname KEYWORD1 void KEYWORD2 NAME(HistogramEXT)(GLenum target, GLsizei width, GLenum internalformat, GLboolean sink) { - DISPATCH(HistogramEXT, (target, width, internalformat, sink), (F, ";")); + DISPATCH(Histogram, (target, width, internalformat, sink), (F, ";")); } KEYWORD1 void KEYWORD2 NAME(MinmaxEXT)(GLenum target, GLenum internalformat, GLboolean sink) { - DISPATCH(MinmaxEXT, (target, internalformat, sink), (F, ";")); + DISPATCH(Minmax, (target, internalformat, sink), (F, ";")); } KEYWORD1 void KEYWORD2 NAME(ResetHistogramEXT)(GLenum target) { - DISPATCH(ResetHistogramEXT, (target), (F, ";")); + DISPATCH(ResetHistogram, (target), (F, ";")); } KEYWORD1 void KEYWORD2 NAME(ResetMinmaxEXT)(GLenum target) { - DISPATCH(ResetMinmaxEXT, (target), (F, ";")); + DISPATCH(ResetMinmax, (target), (F, ";")); } @@ -2301,42 +2301,42 @@ KEYWORD1 void KEYWORD2 NAME(ResetMinmaxEXT)(GLenum target) KEYWORD1 void KEYWORD2 NAME(ConvolutionFilter1DEXT)(GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const GLvoid *image) { - DISPATCH(ConvolutionFilter1DEXT, (target, internalformat, width, format, type, image), (F, ";")); + DISPATCH(ConvolutionFilter1D, (target, internalformat, width, format, type, image), (F, ";")); } KEYWORD1 void KEYWORD2 NAME(ConvolutionFilter2DEXT)(GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *image) { - DISPATCH(ConvolutionFilter2DEXT, (target, internalformat, width, height, format, type, image), (F, ";")); + DISPATCH(ConvolutionFilter2D, (target, internalformat, width, height, format, type, image), (F, ";")); } KEYWORD1 void KEYWORD2 NAME(ConvolutionParameterfEXT)(GLenum target, GLenum pname, GLfloat params) { - DISPATCH(ConvolutionParameterfEXT, (target, pname, params), (F, ";")); + DISPATCH(ConvolutionParameterf, (target, pname, params), (F, ";")); } KEYWORD1 void KEYWORD2 NAME(ConvolutionParameterfvEXT)(GLenum target, GLenum pname, const GLfloat *params) { - DISPATCH(ConvolutionParameterfvEXT, (target, pname, params), (F, ";")); + DISPATCH(ConvolutionParameterfv, (target, pname, params), (F, ";")); } KEYWORD1 void KEYWORD2 NAME(ConvolutionParameteriEXT)(GLenum target, GLenum pname, GLint params) { - DISPATCH(ConvolutionParameteriEXT, (target, pname, params), (F, ";")); + DISPATCH(ConvolutionParameteri, (target, pname, params), (F, ";")); } KEYWORD1 void KEYWORD2 NAME(ConvolutionParameterivEXT)(GLenum target, GLenum pname, const GLint *params) { - DISPATCH(ConvolutionParameterivEXT, (target, pname, params), (F, ";")); + DISPATCH(ConvolutionParameteriv, (target, pname, params), (F, ";")); } KEYWORD1 void KEYWORD2 NAME(CopyConvolutionFilter1DEXT)(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width) { - DISPATCH(CopyConvolutionFilter1DEXT, (target, internalformat, x, y, width), (F, ";")); + DISPATCH(CopyConvolutionFilter1D, (target, internalformat, x, y, width), (F, ";")); } KEYWORD1 void KEYWORD2 NAME(CopyConvolutionFilter2DEXT)(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height) { - DISPATCH(CopyConvolutionFilter2DEXT, (target, internalformat, x, y, width, height), (F, ";")); + DISPATCH(CopyConvolutionFilter2D, (target, internalformat, x, y, width, height), (F, ";")); } KEYWORD1 void KEYWORD2 NAME(GetConvolutionFilterEXT)(GLenum target, GLenum format, GLenum type, GLvoid *image) @@ -2361,7 +2361,7 @@ KEYWORD1 void KEYWORD2 NAME(GetSeparableFilterEXT)(GLenum target, GLenum format, KEYWORD1 void KEYWORD2 NAME(SeparableFilter2DEXT)(GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *row, const GLvoid *column) { - DISPATCH(SeparableFilter2DEXT, (target, internalformat, width, height, format, type, row, column), (F, ";")); + DISPATCH(SeparableFilter2D, (target, internalformat, width, height, format, type, row, column), (F, ";")); } @@ -2370,22 +2370,22 @@ KEYWORD1 void KEYWORD2 NAME(SeparableFilter2DEXT)(GLenum target, GLenum internal KEYWORD1 void KEYWORD2 NAME(ColorTableParameterfvSGI)(GLenum target, GLenum pname, const GLfloat *params) { - DISPATCH(ColorTableParameterfvSGI, (target, pname, params), (F, ";")); + DISPATCH(ColorTableParameterfv, (target, pname, params), (F, ";")); } KEYWORD1 void KEYWORD2 NAME(ColorTableParameterivSGI)(GLenum target, GLenum pname, const GLint *params) { - DISPATCH(ColorTableParameterivSGI, (target, pname, params), (F, ";")); + DISPATCH(ColorTableParameteriv, (target, pname, params), (F, ";")); } KEYWORD1 void KEYWORD2 NAME(ColorTableSGI)(GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const GLvoid *table) { - DISPATCH(ColorTableSGI, (target, internalformat, width, format, type, table), (F, ";")); + DISPATCH(ColorTable, (target, internalformat, width, format, type, table), (F, ";")); } KEYWORD1 void KEYWORD2 NAME(CopyColorTableSGI)(GLenum target, GLenum internalFormat, GLint x, GLint y, GLsizei width) { - DISPATCH(CopyColorTableSGI, (target, internalFormat, x, y, width), (F, ";")); + DISPATCH(CopyColorTable, (target, internalFormat, x, y, width), (F, ";")); } KEYWORD1 void KEYWORD2 NAME(GetColorTableSGI)(GLenum target, GLenum format, GLenum type, GLvoid *table) @@ -2404,6 +2404,14 @@ KEYWORD1 void KEYWORD2 NAME(GetColorTableParameterivSGI)(GLenum target, GLenum p +/* ??. GL_SGIX_pixel_texture */ + +KEYWORD1 void KEYWORD2 NAME(PixelTexGenSGIX)(GLenum mode) +{ + DISPATCH(PixelTexGenSGIX, (mode), (F, ";")); +} + + /* 15. GL_SGIS_pixel_texture */ KEYWORD1 void KEYWORD2 NAME(PixelTexGenParameterfSGIS)(GLenum target, GLfloat value) @@ -2411,11 +2419,21 @@ KEYWORD1 void KEYWORD2 NAME(PixelTexGenParameterfSGIS)(GLenum target, GLfloat va DISPATCH(PixelTexGenParameterfSGIS, (target, value), (F, ";")); } +KEYWORD1 void KEYWORD2 NAME(PixelTexGenParameterfvSGIS)(GLenum target, const GLfloat *value) +{ + DISPATCH(PixelTexGenParameterfvSGIS, (target, value), (F, ";")); +} + KEYWORD1 void KEYWORD2 NAME(PixelTexGenParameteriSGIS)(GLenum target, GLint value) { DISPATCH(PixelTexGenParameteriSGIS, (target, value), (F, ";")); } +KEYWORD1 void KEYWORD2 NAME(PixelTexGenParameterivSGIS)(GLenum target, const GLint *value) +{ + DISPATCH(PixelTexGenParameterivSGIS, (target, value), (F, ";")); +} + KEYWORD1 void KEYWORD2 NAME(GetPixelTexGenParameterfvSGIS)(GLenum target, GLfloat *value) { DISPATCH(GetPixelTexGenParameterfvSGIS, (target, value), (F, ";")); @@ -2430,7 +2448,7 @@ KEYWORD1 void KEYWORD2 NAME(GetPixelTexGenParameterivSGIS)(GLenum target, GLint /* 16. GL_SGIS_texture4D */ -KEYWORD1 void KEYWORD2 NAME(TexImage4DSGIS)(GLenum target, GLint level, GLenum internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLsizei extent, GLint border, GLenum format, GLenum type, const void *pixels) +KEYWORD1 void KEYWORD2 NAME(TexImage4DSGIS)(GLenum target, GLint level, GLint internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLsizei extent, GLint border, GLenum format, GLenum type, const void *pixels) { DISPATCH(TexImage4DSGIS, (target, level, internalFormat, width, height, depth, extent, border, format, type, pixels), (F, ";")); } @@ -2566,7 +2584,7 @@ KEYWORD1 void KEYWORD2 NAME(DrawArraysEXT)(GLenum mode, GLint first, GLsizei cou /* 37. GL_EXT_blend_minmax */ KEYWORD1 void KEYWORD2 NAME(BlendEquationEXT)(GLenum mode) { - DISPATCH(BlendEquationEXT, (mode), (F, "glBlendEquationEXT(0x%x);", mode)); + DISPATCH(BlendEquation, (mode), (F, "glBlendEquationEXT(0x%x);", mode)); } @@ -2648,6 +2666,13 @@ KEYWORD1 void KEYWORD2 NAME(FrameZoomSGIX)(GLint factor) } +/* 58. GL_SGIX_tag_sample_buffer */ +KEYWORD1 void KEYWORD2 NAME(TagSampleBufferSGIX)(void) +{ + DISPATCH(TagSampleBufferSGIX, (), (F, ";")); +} + + /* 60. GL_SGIX_reference_plane */ KEYWORD1 void KEYWORD2 NAME(ReferencePlaneSGIX)(const GLdouble *plane) { @@ -2664,6 +2689,7 @@ KEYWORD1 void KEYWORD2 NAME(FlushRasterSGIX)(void) /* 66. GL_HP_image_transform */ +#if 0 KEYWORD1 void KEYWORD2 NAME(GetImageTransformParameterfvHP)(GLenum target, GLenum pname, GLfloat *param) { DISPATCH(GetImageTransformParameterfvHP, (target, pname, param), (F, ";")); @@ -2693,21 +2719,22 @@ KEYWORD1 void KEYWORD2 NAME(ImageTransformParameterivHP)(GLenum target, GLenum p { DISPATCH(ImageTransformParameterivHP, (target, pname, param), (F, ";")); } +#endif + /* 74. GL_EXT_color_subtable */ KEYWORD1 void KEYWORD2 NAME(ColorSubTableEXT)(GLenum target, GLsizei start, GLsizei count, GLenum format, GLenum type, const void *data) { - DISPATCH(ColorSubTableEXT, (target, start, count, format, type, data), (F, ";")); + DISPATCH(ColorSubTable, (target, start, count, format, type, data), (F, ";")); } KEYWORD1 void KEYWORD2 NAME(CopyColorSubTableEXT)(GLenum target, GLsizei start, GLint x, GLint y, GLsizei width) { - DISPATCH(CopyColorSubTableEXT, (target, start, x, y, width), (F, ";")); + DISPATCH(CopyColorSubTable, (target, start, x, y, width), (F, ";")); } - /* 77. GL_PGI_misc_hints */ KEYWORD1 void KEYWORD2 NAME(HintPGI)(GLenum target, GLint mode) { @@ -2715,12 +2742,11 @@ KEYWORD1 void KEYWORD2 NAME(HintPGI)(GLenum target, GLint mode) } - /* 78. GL_EXT_paletted_texture */ KEYWORD1 void KEYWORD2 NAME(ColorTableEXT)(GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const GLvoid *table) { - DISPATCH(ColorTableEXT, (target, internalformat, width, format, type, table), (F, ";")); + DISPATCH(ColorTable, (target, internalformat, width, format, type, table), (F, ";")); } KEYWORD1 void KEYWORD2 NAME(GetColorTableEXT)(GLenum target, GLenum format, GLenum type, GLvoid *table) @@ -2740,8 +2766,8 @@ KEYWORD1 void KEYWORD2 NAME(GetColorTableParameterivEXT)(GLenum target, GLenum p - /* 80. GL_SGIX_list_priority */ + KEYWORD1 void KEYWORD2 NAME(GetListParameterfvSGIX)(GLuint list, GLenum name, GLfloat *param) { DISPATCH(GetListParameterfvSGIX, (list, name, param), (F, ";")); @@ -2815,15 +2841,245 @@ KEYWORD1 void KEYWORD2 NAME(CullParameterdvEXT)(GLenum pname, const GLdouble *pa +/* 102. GL_SGIX_fragment_lighting */ +KEYWORD1 void KEYWORD2 NAME(FragmentColorMaterialSGIX)(GLenum face, GLenum mode) +{ + DISPATCH(FragmentColorMaterialSGIX, (face, mode), (F, ";")); +} + +KEYWORD1 void KEYWORD2 NAME(FragmentLightfSGIX)(GLenum light, GLenum pname, GLfloat param) +{ + DISPATCH(FragmentLightfSGIX, (light, pname, param), (F, ";")); +} + +KEYWORD1 void KEYWORD2 NAME(FragmentLightfvSGIX)(GLenum light, GLenum pname, const GLfloat * params) +{ + DISPATCH(FragmentLightfvSGIX, (light, pname, params), (F, ";")); +} + +KEYWORD1 void KEYWORD2 NAME(FragmentLightiSGIX)(GLenum light, GLenum pname, GLint param) +{ + DISPATCH(FragmentLightiSGIX, (light, pname, param), (F, ";")); +} + +KEYWORD1 void KEYWORD2 NAME(FragmentLightivSGIX)(GLenum light, GLenum pname, const GLint * params) +{ + DISPATCH(FragmentLightivSGIX, (light, pname, params), (F, ";")); +} + +KEYWORD1 void KEYWORD2 NAME(FragmentLightModelfSGIX)(GLenum pname, GLfloat param) +{ + DISPATCH(FragmentLightModelfSGIX, (pname, param), (F, ";")); +} + +KEYWORD1 void KEYWORD2 NAME(FragmentLightModelfvSGIX)(GLenum pname, const GLfloat * params) +{ + DISPATCH(FragmentLightModelfvSGIX, (pname, params), (F, ";")); +} + +KEYWORD1 void KEYWORD2 NAME(FragmentLightModeliSGIX)(GLenum pname, GLint param) +{ + DISPATCH(FragmentLightModeliSGIX, (pname, param), (F, ";")); +} + +KEYWORD1 void KEYWORD2 NAME(FragmentLightModelivSGIX)(GLenum pname, const GLint * params) +{ + DISPATCH(FragmentLightModelivSGIX, (pname, params), (F, ";")); +} + +KEYWORD1 void KEYWORD2 NAME(FragmentMaterialfSGIX)(GLenum face, GLenum pname, GLfloat param) +{ + DISPATCH(FragmentMaterialfSGIX, (face, pname, param), (F, ";")); +} + +KEYWORD1 void KEYWORD2 NAME(FragmentMaterialfvSGIX)(GLenum face, GLenum pname, const GLfloat * params) +{ + DISPATCH(FragmentMaterialfvSGIX, (face, pname, params), (F, ";")); +} + +KEYWORD1 void KEYWORD2 NAME(FragmentMaterialiSGIX)(GLenum face, GLenum pname, GLint param) +{ + DISPATCH(FragmentMaterialiSGIX, (face, pname, param), (F, ";")); +} + +KEYWORD1 void KEYWORD2 NAME(FragmentMaterialivSGIX)(GLenum face, GLenum pname, const GLint * params) +{ + DISPATCH(FragmentMaterialivSGIX, (face, pname, params), (F, ";")); +} + +KEYWORD1 void KEYWORD2 NAME(GetFragmentLightfvSGIX)(GLenum light, GLenum pname, GLfloat * params) +{ + DISPATCH(FragmentLightfvSGIX, (light, pname, params), (F, ";")); +} + +KEYWORD1 void KEYWORD2 NAME(GetFragmentLightivSGIX)(GLenum light, GLenum pname, GLint * params) +{ + DISPATCH(FragmentLightivSGIX, (light, pname, params), (F, ";")); +} + +KEYWORD1 void KEYWORD2 NAME(GetFragmentMaterialfvSGIX)(GLenum face, GLenum pname, GLfloat * params) +{ + DISPATCH(FragmentMaterialfvSGIX, (face, pname, params), (F, ";")); +} + +KEYWORD1 void KEYWORD2 NAME(GetFragmentMaterialivSGIX)(GLenum face, GLenum pname, GLint * params) +{ + DISPATCH(FragmentMaterialivSGIX, (face, pname, params), (F, ";")); +} + +KEYWORD1 void KEYWORD2 NAME(LightEnviSGIX)(GLenum pname, GLint param) +{ + DISPATCH(LightEnviSGIX, (pname, param), (F, ";")); +} + + +/* 149. GL_EXT_fog_coord */ +KEYWORD1 void KEYWORD2 NAME(FogCoordfEXT)(GLfloat coord) +{ + DISPATCH(FogCoordfEXT, (coord), (F, "glFogCoordfEXT(%g);", coord)); +} + +KEYWORD1 void KEYWORD2 NAME(FogCoordfvEXT)(const GLfloat * coord) +{ + DISPATCH(FogCoordfvEXT, (coord), (F, "glFogCoordfvEXT(%p);", coord)); +} + +KEYWORD1 void KEYWORD2 NAME(FogCoorddEXT)(GLdouble coord) +{ + DISPATCH(FogCoorddEXT, (coord), (F, "glFogCoorddEXT(%g);", coord)); +} + +KEYWORD1 void KEYWORD2 NAME(FogCoorddvEXT)(const GLdouble * coord) +{ + DISPATCH(FogCoorddvEXT, (coord), (F, "glFogCoorddvEXT(%p);", coord)); +} + +KEYWORD1 void KEYWORD2 NAME(FogCoordPointerEXT)(GLenum type, GLsizei stride, const GLvoid * pointer) +{ + DISPATCH(FogCoordPointerEXT, (type, stride, pointer), (F, "glFogCoordPointerEXT(0x%x, %d, %p);", type, stride, pointer)); +} + + + /* 173. GL_EXT/INGR_blend_func_separate */ +KEYWORD1 void KEYWORD2 NAME(BlendFuncSeparateEXT)(GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha) +{ + DISPATCH(BlendFuncSeparateEXT, (sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha), (F, ";")); +} + KEYWORD1 void KEYWORD2 NAME(BlendFuncSeparateINGR)(GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha) { - DISPATCH(BlendFuncSeparateINGR, (sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha), (F, ";")); + DISPATCH(BlendFuncSeparateEXT, (sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha), (F, ";")); } +/* 190. GL_NV_vertex_array_range */ +KEYWORD1 void KEYWORD2 NAME(FlushVertexArrayRangeNV)(void) +{ + DISPATCH(FlushVertexArrayRangeNV, (), (F, ";")); +} + +KEYWORD1 void KEYWORD2 NAME(VertexArrayRangeNV)(GLsizei size, const GLvoid * pointer) +{ + DISPATCH(VertexArrayRangeNV, (size, pointer), (F, ";")); +} -/* GL_MESA_window_pos */ + +/* 191. GL_NV_register_combiners */ +KEYWORD1 void KEYWORD2 NAME(CombinerParameterfvNV)(GLenum pname, const GLfloat * params) +{ + DISPATCH(CombinerParameterfvNV, (pname, params), (F, ";")); +} + +KEYWORD1 void KEYWORD2 NAME(CombinerParameterfNV)(GLenum pname, GLfloat param) +{ + DISPATCH(CombinerParameterfNV, (pname, param), (F, ";")); +} + +KEYWORD1 void KEYWORD2 NAME(CombinerParameterivNV)(GLenum pname, const GLint * params) +{ + DISPATCH(CombinerParameterivNV, (pname, params), (F, ";")); +} + +KEYWORD1 void KEYWORD2 NAME(CombinerParameteriNV)(GLenum pname, GLint param) +{ + DISPATCH(CombinerParameteriNV, (pname, param), (F, ";")); +} + +KEYWORD1 void KEYWORD2 NAME(CombinerInputNV)(GLenum stage, GLenum portion, GLenum variable, GLenum input, GLenum mapping, GLenum componentUsage) +{ + DISPATCH(CombinerInputNV, (stage, portion, variable, input, mapping, componentUsage), (F, ";")); +} + +KEYWORD1 void KEYWORD2 NAME(CombinerOutputNV)(GLenum stage, GLenum portion, GLenum abOutput, GLenum cdOutput, GLenum sumOutput, GLenum scale, GLenum bias, GLboolean abDotProduct, GLboolean cdDotProduct, GLboolean muxSum) +{ + DISPATCH(CombinerOutputNV, (stage, portion, abOutput, cdOutput, sumOutput, scale, bias, abDotProduct, cdDotProduct, muxSum), (F, ";")); +} + +KEYWORD1 void KEYWORD2 NAME(FinalCombinerInputNV)(GLenum variable, GLenum input, GLenum mapping, GLenum componentUsage) +{ + DISPATCH(FinalCombinerInputNV, (variable, input, mapping, componentUsage), (F, ";")); +} + +KEYWORD1 void KEYWORD2 NAME(GetCombinerInputParameterfvNV)(GLenum stage, GLenum portion, GLenum variable, GLenum pname, GLfloat * params) +{ + DISPATCH(GetCombinerInputParameterfvNV, (stage, portion, variable, pname, params), (F, ";")); +} + +KEYWORD1 void KEYWORD2 NAME(GetCombinerInputParameterivNV)(GLenum stage, GLenum portion, GLenum variable, GLenum pname, GLint * params) +{ + DISPATCH(GetCombinerInputParameterivNV, (stage, portion, variable, pname, params), (F, ";")); +} + +KEYWORD1 void KEYWORD2 NAME(GetCombinerOutputParameterfvNV)(GLenum stage, GLenum portion, GLenum pname, GLfloat * params) +{ + DISPATCH(GetCombinerOutputParameterfvNV, (stage, portion, pname, params), (F, ";")); +} + +KEYWORD1 void KEYWORD2 NAME(GetCombinerOutputParameterivNV)(GLenum stage, GLenum portion, GLenum pname, GLint * params) +{ + DISPATCH(GetCombinerOutputParameterivNV, (stage, portion, pname, params), (F, ";")); +} + +KEYWORD1 void KEYWORD2 NAME(GetFinalCombinerInputParameterfvNV)(GLenum variable, GLenum pname, GLfloat * params) +{ +DISPATCH(GetFinalCombinerInputParameterfvNV, (variable, pname, params), (F, ";")); +} + +KEYWORD1 void KEYWORD2 NAME(GetFinalCombinerInputParameterivNV)(GLenum variable, GLenum pname, GLint * params) +{ +DISPATCH(GetFinalCombinerInputParameterivNV, (variable, pname, params), (F, ";")); +} + + + +/* 194. GL_EXT_vertex_weighting */ +KEYWORD1 void KEYWORD2 NAME(VertexWeightfEXT)(GLfloat weight) +{ + DISPATCH(VertexWeightfEXT, (weight), (F, ";")); +} + +KEYWORD1 void KEYWORD2 NAME(VertexWeightfvEXT)(const GLfloat * weight) +{ + DISPATCH(VertexWeightfvEXT, (weight), (F, ";")); +} + +KEYWORD1 void KEYWORD2 NAME(VertexWeightPointerEXT)(GLsizei size, GLenum type, GLsizei stride, const GLvoid * pointer) +{ + DISPATCH(VertexWeightPointerEXT, (size, type, stride, pointer), (F, ";")); +} + + + +/* 196. GL_MESA_resize_buffers */ +KEYWORD1 void KEYWORD2 NAME(ResizeBuffersMESA)(void) +{ + DISPATCH(ResizeBuffersMESA, (), (F, "glResizeBuffersMESA();")); +} + + + +/* 197. GL_MESA_window_pos */ KEYWORD1 void KEYWORD2 NAME(WindowPos2iMESA)(GLint x, GLint y) { @@ -2947,15 +3203,7 @@ KEYWORD1 void KEYWORD2 NAME(WindowPos4dvMESA)(const GLdouble *p) -/* GL_MESA_resize_buffers */ -KEYWORD1 void KEYWORD2 NAME(ResizeBuffersMESA)(void) -{ - DISPATCH(ResizeBuffersMESA, (), (F, "glResizeBuffersMESA();")); -} - - - -/* GL_ARB_transpose_matrix */ +/* ARB 2. GL_ARB_transpose_matrix */ KEYWORD1 void KEYWORD2 NAME(LoadTransposeMatrixdARB)(const GLdouble m[16]) { DISPATCH(LoadTransposeMatrixdARB, (m), (F, "glLoadTransposeMatrixARB(%p);", m)); @@ -2977,6 +3225,19 @@ KEYWORD1 void KEYWORD2 NAME(MultTransposeMatrixfARB)(const GLfloat m[16]) } +/* ARB 4. GL_ARB_multisample */ +KEYWORD1 void KEYWORD2 NAME(SampleCoverageARB)(GLclampf value, GLboolean invert) +{ + DISPATCH(SampleCoverageARB, (value, invert), (F, "glSampleCoverageARB(%f, %d);", value, invert)); +} + + +KEYWORD1 void KEYWORD2 NAME(SamplePassARB)(GLenum pass) +{ + DISPATCH(SamplePassARB, (pass), (F, "glSamplePassARB(0x%x);", pass)); +} + + #undef KEYWORD1 #undef KEYWORD2 diff --git a/xc/extras/Mesa/src/glheader.h b/xc/extras/Mesa/src/glheader.h index acf8f5f84..4789ec7a3 100644 --- a/xc/extras/Mesa/src/glheader.h +++ b/xc/extras/Mesa/src/glheader.h @@ -59,7 +59,8 @@ #include "conf.h" #endif -#include <GL/gl.h> +#include "GL/gl.h" +#include "GL/glext.h" /* diff --git a/xc/extras/Mesa/src/image.c b/xc/extras/Mesa/src/image.c index 543c6185c..16c8d4921 100644 --- a/xc/extras/Mesa/src/image.c +++ b/xc/extras/Mesa/src/image.c @@ -1578,10 +1578,17 @@ extract_float_rgba(GLuint n, GLfloat rgba[][4], srcType == GL_INT || srcType == GL_FLOAT || srcType == GL_UNSIGNED_BYTE_3_3_2 || + srcType == GL_UNSIGNED_BYTE_2_3_3_REV || + srcType == GL_UNSIGNED_SHORT_5_6_5 || + srcType == GL_UNSIGNED_SHORT_5_6_5_REV || srcType == GL_UNSIGNED_SHORT_4_4_4_4 || + srcType == GL_UNSIGNED_SHORT_4_4_4_4_REV || srcType == GL_UNSIGNED_SHORT_5_5_5_1 || + srcType == GL_UNSIGNED_SHORT_1_5_5_5_REV || srcType == GL_UNSIGNED_INT_8_8_8_8 || - srcType == GL_UNSIGNED_INT_10_10_10_2); + srcType == GL_UNSIGNED_INT_8_8_8_8_REV || + srcType == GL_UNSIGNED_INT_10_10_10_2 || + srcType == GL_UNSIGNED_INT_2_10_10_10_REV); rComp = gComp = bComp = aComp = -1; @@ -1979,10 +1986,10 @@ extract_float_rgba(GLuint n, GLfloat rgba[][4], for (i = 0; i < n; i ++) { GLuint p = uisrc[i]; SWAP4BYTE(p); - rgba[i][rComp] = ((p ) & 0x3 ) * (1.0F / 3.0F); - rgba[i][gComp] = ((p >> 2) & 0x3ff) * (1.0F / 1023.0F); - rgba[i][bComp] = ((p >> 12) & 0x3ff) * (1.0F / 1023.0F); - rgba[i][aComp] = ((p >> 22) ) * (1.0F / 1023.0F); + rgba[i][rComp] = ((p >> 22) ) * (1.0F / 1023.0F); + rgba[i][gComp] = ((p >> 12) & 0x3ff) * (1.0F / 1023.0F); + rgba[i][bComp] = ((p >> 2) & 0x3ff) * (1.0F / 1023.0F); + rgba[i][aComp] = ((p ) & 0x3 ) * (1.0F / 3.0F); } } else { @@ -1990,10 +1997,10 @@ extract_float_rgba(GLuint n, GLfloat rgba[][4], GLuint i; for (i = 0; i < n; i ++) { GLuint p = uisrc[i]; - rgba[i][rComp] = ((p ) & 0x3 ) * (1.0F / 3.0F); - rgba[i][gComp] = ((p >> 2) & 0x3ff) * (1.0F / 1023.0F); - rgba[i][bComp] = ((p >> 12) & 0x3ff) * (1.0F / 1023.0F); - rgba[i][aComp] = ((p >> 22) ) * (1.0F / 1023.0F); + rgba[i][rComp] = ((p >> 22) ) * (1.0F / 1023.0F); + rgba[i][gComp] = ((p >> 12) & 0x3ff) * (1.0F / 1023.0F); + rgba[i][bComp] = ((p >> 2) & 0x3ff) * (1.0F / 1023.0F); + rgba[i][aComp] = ((p ) & 0x3 ) * (1.0F / 3.0F); } } break; @@ -2087,10 +2094,17 @@ _mesa_unpack_ubyte_color_span( const GLcontext *ctx, srcType == GL_INT || srcType == GL_FLOAT || srcType == GL_UNSIGNED_BYTE_3_3_2 || + srcType == GL_UNSIGNED_BYTE_2_3_3_REV || + srcType == GL_UNSIGNED_SHORT_5_6_5 || + srcType == GL_UNSIGNED_SHORT_5_6_5_REV || srcType == GL_UNSIGNED_SHORT_4_4_4_4 || + srcType == GL_UNSIGNED_SHORT_4_4_4_4_REV || srcType == GL_UNSIGNED_SHORT_5_5_5_1 || + srcType == GL_UNSIGNED_SHORT_1_5_5_5_REV || srcType == GL_UNSIGNED_INT_8_8_8_8 || - srcType == GL_UNSIGNED_INT_10_10_10_2); + srcType == GL_UNSIGNED_INT_8_8_8_8_REV || + srcType == GL_UNSIGNED_INT_10_10_10_2 || + srcType == GL_UNSIGNED_INT_2_10_10_10_REV); /* this is intended for RGBA mode */ assert(ctx->Visual->RGBAflag); diff --git a/xc/extras/Mesa/src/imaging.c b/xc/extras/Mesa/src/imaging.c index 2bff238e7..f1d912b6d 100644 --- a/xc/extras/Mesa/src/imaging.c +++ b/xc/extras/Mesa/src/imaging.c @@ -40,6 +40,7 @@ +#if 0 void _mesa_BlendColor(GLclampf r, GLclampf g, GLclampf b, GLclampf a) { (void) r; @@ -76,6 +77,7 @@ void _mesa_ColorTable(GLenum target, GLenum internalformat, GLsizei width, GLenu (void) table; WARNING("glColorTable"); } +#endif void _mesa_ColorTableParameterfv(GLenum target, GLenum pname, const GLfloat *params) { @@ -190,6 +192,7 @@ void _mesa_CopyConvolutionFilter2D(GLenum target, GLenum internalformat, GLint x WARNING("glCopyConvolutionFilter2D"); } +#if 0 void _mesa_GetColorTable(GLenum target, GLenum format, GLenum type, GLvoid *table) { (void) target; @@ -214,6 +217,7 @@ void _mesa_GetColorTableParameteriv(GLenum target, GLenum pname, GLint *params) (void) params; WARNING("glGetColorTableParameteriv"); } +#endif void _mesa_GetConvolutionFilter(GLenum target, GLenum format, GLenum type, GLvoid *image) { diff --git a/xc/extras/Mesa/src/imaging.h b/xc/extras/Mesa/src/imaging.h index ddede6728..f376be5f6 100644 --- a/xc/extras/Mesa/src/imaging.h +++ b/xc/extras/Mesa/src/imaging.h @@ -3,7 +3,7 @@ * Mesa 3-D graphics library * Version: 3.3 * - * Copyright (C) 1999 Brian Paul All Rights Reserved. + * Copyright (C) 1999-2000 Brian Paul All Rights Reserved. * * Permission is hereby granted, free of charge, to any person obtaining a * copy of this software and associated documentation files (the "Software"), @@ -36,6 +36,7 @@ +#if 0 extern void _mesa_BlendColor(GLclampf r, GLclampf g, GLclampf b, GLclampf a); extern void _mesa_BlendEquation(GLenum eq); @@ -43,11 +44,13 @@ extern void _mesa_BlendEquation(GLenum eq); extern void _mesa_ColorSubTable(GLenum target, GLsizei start, GLsizei count, GLenum format, GLenum type, const GLvoid *data); extern void _mesa_ColorTable(GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const GLvoid *table); +#endif extern void _mesa_ColorTableParameterfv(GLenum target, GLenum pname, const GLfloat *params); extern void _mesa_ColorTableParameteriv(GLenum target, GLenum pname, const GLint *params); + extern void _mesa_ConvolutionFilter1D(GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const GLvoid *image); extern void _mesa_ConvolutionFilter2D(GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *image); @@ -68,11 +71,13 @@ extern void _mesa_CopyConvolutionFilter1D(GLenum target, GLenum internalformat, extern void _mesa_CopyConvolutionFilter2D(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height); +#if 0 extern void _mesa_GetColorTable(GLenum target, GLenum format, GLenum type, GLvoid *table); extern void _mesa_GetColorTableParameterfv(GLenum target, GLenum pname, GLfloat *params); extern void _mesa_GetColorTableParameteriv(GLenum target, GLenum pname, GLint *params); +#endif extern void _mesa_GetConvolutionFilter(GLenum target, GLenum format, GLenum type, GLvoid *image); diff --git a/xc/extras/Mesa/src/matrix.c b/xc/extras/Mesa/src/matrix.c index 1587ee74f..ef1abacd4 100644 --- a/xc/extras/Mesa/src/matrix.c +++ b/xc/extras/Mesa/src/matrix.c @@ -1057,7 +1057,7 @@ _mesa_PushMatrix( void ) switch (ctx->Transform.MatrixMode) { case GL_MODELVIEW: - if (ctx->ModelViewStackDepth>=MAX_MODELVIEW_STACK_DEPTH-1) { + if (ctx->ModelViewStackDepth >= MAX_MODELVIEW_STACK_DEPTH - 1) { gl_error( ctx, GL_STACK_OVERFLOW, "glPushMatrix"); return; } @@ -1065,7 +1065,7 @@ _mesa_PushMatrix( void ) &ctx->ModelView ); break; case GL_PROJECTION: - if (ctx->ProjectionStackDepth>=MAX_PROJECTION_STACK_DEPTH) { + if (ctx->ProjectionStackDepth >= MAX_PROJECTION_STACK_DEPTH - 1) { gl_error( ctx, GL_STACK_OVERFLOW, "glPushMatrix"); return; } @@ -1081,7 +1081,7 @@ _mesa_PushMatrix( void ) case GL_TEXTURE: { GLuint t = ctx->Texture.CurrentTransformUnit; - if (ctx->TextureStackDepth[t] >= MAX_TEXTURE_STACK_DEPTH) { + if (ctx->TextureStackDepth[t] >= MAX_TEXTURE_STACK_DEPTH - 1) { gl_error( ctx, GL_STACK_OVERFLOW, "glPushMatrix"); return; } diff --git a/xc/extras/Mesa/src/span.c b/xc/extras/Mesa/src/span.c index ffb3bc955..38f4449f1 100644 --- a/xc/extras/Mesa/src/span.c +++ b/xc/extras/Mesa/src/span.c @@ -816,15 +816,17 @@ void gl_write_texture_span( GLcontext *ctx, * As above but perform multiple stages of texture application. * Input: texUnits - number of texture units to apply */ -void gl_write_multitexture_span( GLcontext *ctx, GLuint texUnits, - GLuint n, GLint x, GLint y, - const GLdepth z[], - CONST GLfloat s[][MAX_WIDTH], - CONST GLfloat t[][MAX_WIDTH], - CONST GLfloat u[][MAX_WIDTH], - GLfloat lambda[][MAX_WIDTH], - GLubyte rgbaIn[][4], CONST GLubyte spec[][4], - GLenum primitive ) +void +gl_write_multitexture_span( GLcontext *ctx, GLuint texUnits, + GLuint n, GLint x, GLint y, + const GLdepth z[], + CONST GLfloat s[MAX_TEXTURE_UNITS][MAX_WIDTH], + CONST GLfloat t[MAX_TEXTURE_UNITS][MAX_WIDTH], + CONST GLfloat u[MAX_TEXTURE_UNITS][MAX_WIDTH], + GLfloat lambda[][MAX_WIDTH], + GLubyte rgbaIn[MAX_TEXTURE_UNITS][4], + CONST GLubyte spec[MAX_TEXTURE_UNITS][4], + GLenum primitive ) { GLubyte mask[MAX_WIDTH]; GLboolean write_all = GL_TRUE; diff --git a/xc/extras/Mesa/src/span.h b/xc/extras/Mesa/src/span.h index 27bd0a687..d305cb430 100644 --- a/xc/extras/Mesa/src/span.h +++ b/xc/extras/Mesa/src/span.h @@ -65,16 +65,17 @@ extern void gl_write_texture_span( GLcontext *ctx, GLenum primitive ); -extern void gl_write_multitexture_span( GLcontext *ctx, GLuint texSets, - GLuint n, GLint x, GLint y, - const GLdepth z[], - CONST GLfloat s[][MAX_WIDTH], - CONST GLfloat t[][MAX_WIDTH], - CONST GLfloat u[][MAX_WIDTH], - GLfloat lambda[][MAX_WIDTH], - GLubyte rgba[][4], - CONST GLubyte spec[][4], - GLenum primitive ); +extern void +gl_write_multitexture_span( GLcontext *ctx, GLuint texSets, + GLuint n, GLint x, GLint y, + const GLdepth z[], + CONST GLfloat s[MAX_TEXTURE_UNITS][MAX_WIDTH], + CONST GLfloat t[MAX_TEXTURE_UNITS][MAX_WIDTH], + CONST GLfloat u[MAX_TEXTURE_UNITS][MAX_WIDTH], + GLfloat lambda[MAX_TEXTURE_UNITS][MAX_WIDTH], + GLubyte rgba[][4], + CONST GLubyte spec[][4], + GLenum primitive ); extern void gl_read_rgba_span( GLcontext *ctx, GLframebuffer *buffer, diff --git a/xc/extras/Mesa/src/state.c b/xc/extras/Mesa/src/state.c index 510f22656..b135a3df0 100644 --- a/xc/extras/Mesa/src/state.c +++ b/xc/extras/Mesa/src/state.c @@ -87,8 +87,6 @@ - - static int generic_noop(void) { @@ -510,17 +508,21 @@ _mesa_init_exec_table(struct _glapi_table *exec) exec->ResetMinmax = _mesa_ResetMinmax; exec->SeparableFilter2D = _mesa_SeparableFilter2D; - /* 6. GL_EXT_texture3d */ + /* GL_EXT_texture3d */ +#if 0 exec->CopyTexSubImage3DEXT = _mesa_CopyTexSubImage3D; exec->TexImage3DEXT = _mesa_TexImage3DEXT; exec->TexSubImage3DEXT = _mesa_TexSubImage3D; +#endif /* GL_EXT_paletted_texture */ +#if 0 exec->ColorTableEXT = _mesa_ColorTableEXT; exec->ColorSubTableEXT = _mesa_ColorSubTableEXT; - exec->GetColorTableEXT = _mesa_GetColorTableEXT; - exec->GetColorTableParameterfvEXT = _mesa_GetColorTableParameterfvEXT; - exec->GetColorTableParameterivEXT = _mesa_GetColorTableParameterivEXT; +#endif + exec->GetColorTableEXT = _mesa_GetColorTable; + exec->GetColorTableParameterfvEXT = _mesa_GetColorTableParameterfv; + exec->GetColorTableParameterivEXT = _mesa_GetColorTableParameteriv; /* GL_EXT_compiled_vertex_array */ exec->LockArraysEXT = _mesa_LockArraysEXT; @@ -530,17 +532,21 @@ _mesa_init_exec_table(struct _glapi_table *exec) exec->PointParameterfEXT = _mesa_PointParameterfEXT; exec->PointParameterfvEXT = _mesa_PointParameterfvEXT; - /* 77. GL_PGI_misc_hints */ + /* GL_PGI_misc_hints */ exec->HintPGI = _mesa_HintPGI; /* GL_EXT_polygon_offset */ exec->PolygonOffsetEXT = _mesa_PolygonOffsetEXT; /* GL_EXT_blend_minmax */ +#if 0 exec->BlendEquationEXT = _mesa_BlendEquationEXT; +#endif /* GL_EXT_blend_color */ +#if 0 exec->BlendColorEXT = _mesa_BlendColorEXT; +#endif /* GL_ARB_multitexture */ exec->ActiveTextureARB = _mesa_ActiveTextureARB; @@ -579,7 +585,7 @@ _mesa_init_exec_table(struct _glapi_table *exec) exec->MultiTexCoord4svARB = _mesa_MultiTexCoord4svARB; /* GL_INGR_blend_func_separate */ - exec->BlendFuncSeparateINGR = _mesa_BlendFuncSeparateINGR; + exec->BlendFuncSeparateEXT = _mesa_BlendFuncSeparateEXT; /* GL_MESA_window_pos */ exec->WindowPos2dMESA = _mesa_WindowPos2dMESA; diff --git a/xc/extras/Mesa/src/teximage.c b/xc/extras/Mesa/src/teximage.c index 20f16f507..fb7e8be7b 100644 --- a/xc/extras/Mesa/src/teximage.c +++ b/xc/extras/Mesa/src/teximage.c @@ -966,7 +966,7 @@ copytexsubimage_error_check( GLcontext *ctx, GLuint dimensions, return GL_TRUE; } - teximage = texUnit->CurrentD[3]->Image[level]; + teximage = texUnit->CurrentD[dimensions]->Image[level]; if (!teximage) { char message[100]; sprintf(message, "glCopyTexSubImage%dD(undefined texture)", dimensions); diff --git a/xc/extras/Mesa/src/types.h b/xc/extras/Mesa/src/types.h index 88c3b24b5..b3af90a8c 100644 --- a/xc/extras/Mesa/src/types.h +++ b/xc/extras/Mesa/src/types.h @@ -1654,15 +1654,15 @@ struct gl_context { struct gl_constants Const; /* Modelview matrix and stack */ - GLmatrix ModelView; + GLmatrix ModelView; /* current matrix, not stored on stack */ GLuint ModelViewStackDepth; - GLmatrix ModelViewStack[MAX_MODELVIEW_STACK_DEPTH]; + GLmatrix ModelViewStack[MAX_MODELVIEW_STACK_DEPTH - 1]; /* Projection matrix and stack */ - GLmatrix ProjectionMatrix; + GLmatrix ProjectionMatrix; /* current matrix, not stored on stack */ GLuint ProjectionStackDepth; - GLmatrix ProjectionStack[MAX_PROJECTION_STACK_DEPTH]; - GLfloat NearFarStack[MAX_PROJECTION_STACK_DEPTH][2]; + GLmatrix ProjectionStack[MAX_PROJECTION_STACK_DEPTH - 1]; + GLfloat NearFarStack[MAX_PROJECTION_STACK_DEPTH - 1][2]; /* Combined modelview and projection matrix */ GLmatrix ModelProjectMatrix; @@ -1674,7 +1674,7 @@ struct gl_context { /* Texture matrix and stack */ GLmatrix TextureMatrix[MAX_TEXTURE_UNITS]; GLuint TextureStackDepth[MAX_TEXTURE_UNITS]; - GLmatrix TextureStack[MAX_TEXTURE_UNITS][MAX_TEXTURE_STACK_DEPTH]; + GLmatrix TextureStack[MAX_TEXTURE_UNITS][MAX_TEXTURE_STACK_DEPTH - 1]; /* Display lists */ GLuint CallDepth; /* Current recursion calling depth */ diff --git a/xc/extras/Mesa/src/winpos.c b/xc/extras/Mesa/src/winpos.c index 3362b9865..4843188de 100644 --- a/xc/extras/Mesa/src/winpos.c +++ b/xc/extras/Mesa/src/winpos.c @@ -65,8 +65,6 @@ void _mesa_WindowPos4fMESA( GLfloat x, GLfloat y, GLfloat z, GLfloat w ) { - /* KW: Assume that like rasterpos, this must be outside begin/end. - */ GET_CURRENT_CONTEXT(ctx); ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH( ctx, "glWindowPosMESA" ); @@ -77,41 +75,18 @@ _mesa_WindowPos4fMESA( GLfloat x, GLfloat y, GLfloat z, GLfloat w ) ctx->Current.RasterPos[3] = w; ctx->Current.RasterPosValid = GL_TRUE; + ctx->Current.RasterDistance = 0.0F; - /* raster color */ - if (0 && ctx->Light.Enabled) { - - /* KW: I don't see how this can work - would have to take the - * inverse of the projection matrix or the combined - * modelProjection matrix, transform point and normal, and - * do the lighting. Those inverses are not used for - * anything else. This is not an object-space lighting - * issue - what this is trying to do is something like - * clip-space or window-space lighting... - * - * Anyway, since the implementation was never correct, I'm - * not fixing it now - just use the unlit color. - */ - - /* KW: As a reprise, we now *do* keep the inverse of the projection - * matrix, so it is not infeasible to try to swim up stream - * in this manner. I still don't want to implement it, - * however. - */ + /* raster color = current color or index */ + if (ctx->Visual->RGBAflag) { + UBYTE_RGBA_TO_FLOAT_RGBA(ctx->Current.RasterColor, + ctx->Current.ByteColor); } else { - /* use current color or index */ - if (ctx->Visual->RGBAflag) { - UBYTE_RGBA_TO_FLOAT_RGBA(ctx->Current.RasterColor, - ctx->Current.ByteColor); - } - else { - ctx->Current.RasterIndex = ctx->Current.Index; - } + ctx->Current.RasterIndex = ctx->Current.Index; } - ctx->Current.RasterDistance = 0.0; - + /* raster texcoord = current texcoord */ { GLuint texSet; for (texSet=0; texSet<MAX_TEXTURE_UNITS; texSet++) { diff --git a/xc/include/GL/Imakefile b/xc/include/GL/Imakefile index e77cffacb..15d6be89b 100644 --- a/xc/include/GL/Imakefile +++ b/xc/include/GL/Imakefile @@ -2,8 +2,11 @@ XCOMM $XFree86: xc/include/GL/Imakefile,v 1.6 1999/08/14 10:49:14 dawes Exp $ XCOMM $PI: xc/include/GL/Imakefile,v 1.7 1999/06/24 03:11:32 faith Exp $ +LinkSourceFile(gl.h, ../../extras/Mesa/include/GL) +LinkSourceFile(glext.h, ../../extras/Mesa/include/GL) + #if BuildGLXLibrary -GLXHEADERS = gl.h glx.h glxint.h glxmd.h glxproto.h glxtokens.h +GLXHEADERS = gl.h glext.h glx.h glxint.h glxmd.h glxproto.h glxtokens.h #endif HEADERS = $(GLXHEADERS) diff --git a/xc/include/GL/glx.h b/xc/include/GL/glx.h index 54c4abf4c..a9c62d1a7 100644 --- a/xc/include/GL/glx.h +++ b/xc/include/GL/glx.h @@ -39,6 +39,13 @@ extern "C" { typedef XID GLXContextID; typedef XID GLXPixmap; typedef XID GLXDrawable; +/* GLX 1.3 */ +typedef XID GLXFBConfigID; +typedef XID GLXPfuffer; +typedef XID GLXWindow; +typedef XID GLXPbuffer; +typedef XID GLXFBConfig; + /* ** GLXContext is a pointer to opaque data. @@ -69,6 +76,25 @@ extern const char * glXGetClientString (Display *dpy, int name ); extern const char * glXQueryServerString (Display *dpy, int screen, int name ); extern const char * glXQueryExtensionsString (Display *dpy, int screen ); +/* GLX 1.3 */ +extern GLXFBConfig glXChooseFBConfig (Display *dpy, int screen, const int *attribList, int *nitems); +extern int glXGetFBConfigAttrib (Display *dpy, GLXFBConfig config, int attribute, int *value); +extern XVisualInfo * glXGetVisualFromFBConfig (Display *dpy, GLXFBConfig config); +extern GLXWindow glXCreateWindow (Display *dpy, GLXFBConfig config, Window win, const int *attribList); +extern void glXDestroyWindow (Display *dpy, GLXWindow window); +extern GLXPixmap glXCreatePixmap (Display *dpy, GLXFBConfig config,Pixmap pixmap, const int *attribList); +extern void glXDestroyPixmap (Display *dpy, GLXPixmap pixmap); +extern GLXPbuffer glXCreatePbuffer (Display *dpy, GLXFBConfig config, const int *attribList); +extern void glXDestroyPbuffer (Display *dpy, GLXPbuffer pbuf); +extern void glXQueryDrawable (Display *dpy, GLXDrawable draw, int attribute, unsigned int *value); +extern GLXContext glXCreateNewContext (Display *dpy, GLXFBConfig config, int renderType, GLXContext shareList, Bool direct); +extern Bool glXMakeContextCurrent (Display *dpy, GLXDrawable draw, GLXDrawable read, GLXContext ctx); +extern GLXDrawable glXGetCurrentReadDrawable (void); +extern int glXQueryContext (Display *dpy, GLXContext ctx, int attribute, int *value); +extern void glXSelectEvent (Display *dpy, GLXDrawable drawable, unsigned long mask); +extern void glXGetSelectedEvent (Display *dpy, GLXDrawable drawable, unsigned long *mask); + +/* Extensions */ extern Display * glXGetCurrentDisplay (void); extern GLXContextID glXGetContextIDEXT (const GLXContext ctx); extern GLXDrawable glXGetCurrentDrawableEXT (void); diff --git a/xc/lib/GL/dri/dri_glx.c b/xc/lib/GL/dri/dri_glx.c index ac12eb368..f1af23ff8 100644 --- a/xc/lib/GL/dri/dri_glx.c +++ b/xc/lib/GL/dri/dri_glx.c @@ -54,8 +54,8 @@ typedef void *(*CreateScreenFunc)(Display *dpy, int scrn, __DRIscreen *psc, #ifdef BUILT_IN_DRI_DRIVER -extern void *driCreateScreen(Display *dpy, int scrn, __DRIscreen *psc, - int numConfigs, __GLXvisualConfig *config); +extern void *__driCreateScreen(Display *dpy, int scrn, __DRIscreen *psc, + int numConfigs, __GLXvisualConfig *config); #else /* BUILT_IN_DRI_DRIVER */ @@ -95,12 +95,8 @@ static void *DummyCreateScreen(Display *dpy, int scrn, __DRIscreen *psc, * Initialize two arrays: an array of createScreen function pointers * and an array of dlopen library handles. Arrays are indexed by * screen number. - * We use the DRI in order to find the driCreateScreen function + * We use the DRI in order to find the __driCreateScreen function * exported by each screen on a display. - * - * Also, this function calls the driver's _register_gl_extensions() - * function in order to let the driver hook new extension functions - * into the libGL dispatcher. */ static void Find_CreateScreenFuncs(Display *dpy, CreateScreenFunc *createFuncs, @@ -141,7 +137,7 @@ static void Find_CreateScreenFuncs(Display *dpy, /* * dlopen the driver module and save the pointer to its - * driCreateScreen function. + * __driCreateScreen function. */ { char realDriverName[100]; @@ -150,8 +146,8 @@ static void Find_CreateScreenFuncs(Display *dpy, char *libDir = NULL; if (geteuid() == getuid()) { - /* don't allow setuid apps to use DRI_MODULES_DIR */ - libDir = getenv("DRI_MODULES_DIR"); + /* don't allow setuid apps to use LIBGL_DRIVERS_DIR */ + libDir = getenv("LIBGL_DRIVERS_DIR"); } if (!libDir) libDir = DEFAULT_DRIVER_DIR; @@ -166,7 +162,7 @@ static void Find_CreateScreenFuncs(Display *dpy, continue; } - createScreenFunc = (CreateScreenFunc) dlsym(handle, "driCreateScreen"); + createScreenFunc = (CreateScreenFunc) dlsym(handle, "__driCreateScreen"); if (createScreenFunc) { /* success! */ createFuncs[scrn] = createScreenFunc; @@ -178,19 +174,6 @@ static void Find_CreateScreenFuncs(Display *dpy, ErrorMessage(message); dlclose(handle); } - - /* Find the driver's _register_gl_extensions() function and - * call it if present. This will let the driver tell libGL.so - * about any extension functions it wants to export. - */ - { - typedef void *(*RegisterExtFunc)(void); - RegisterExtFunc registerExtFunc = (RegisterExtFunc) dlsym(handle, "_register_gl_extensions"); - if (registerExtFunc) { - (*registerExtFunc)(); - } - } - } } } @@ -254,11 +237,11 @@ void *driCreateDisplay(Display *dpy, __DRIdisplay *pdisp) } #ifdef BUILT_IN_DRI_DRIVER - /* we'll statically bind to the driCreateScreen function */ + /* we'll statically bind to the __driCreateScreen function */ { int i; for (i = 0; i < numScreens; i++) { - pdisp->createScreen[i] = driCreateScreen; + pdisp->createScreen[i] = __driCreateScreen; pdpyp->libraryHandles[i] = NULL; } } @@ -270,4 +253,132 @@ void *driCreateDisplay(Display *dpy, __DRIdisplay *pdisp) } +#ifndef BUILT_IN_DRI_DRIVER + +static GLboolean verbose = GL_FALSE; /* for debugging only */ + + +/* + * Use the DRI and dlopen/dlsym facilities to find the GL extensions + * possible on the given display and screen. + */ +static void +get_extensions_on_display(Display *dpy, int scrNum) +{ + int eventBase, errorBase; + Bool b, b2; + int driMajor, driMinor, driPatch; + int driverMajor, driverMinor, driverPatch; + char *driverName = NULL; + + /* + * Check if the DRI extension is available, check the DRI version, + * determine the 3D driver for the screen. + */ + b = XF86DRIQueryExtension(dpy, &eventBase, &errorBase); + if (!b) { + if (verbose) + fprintf(stderr, "XF86DRIQueryExtension failed\n"); + return; + } + + b = XF86DRIQueryDirectRenderingCapable(dpy, scrNum, &b2); + if (!b || !b2) { + if (verbose) + fprintf(stderr, "XF86DRIQueryDirectRenderingCapable failed\n"); + return; + } + + b = XF86DRIQueryVersion(dpy, &driMajor, &driMinor, &driPatch); + if (!b) { + if (verbose) + fprintf(stderr, "XF86DRIQueryVersion failed\n"); + return; + } + + b = XF86DRIGetClientDriverName(dpy, scrNum, &driverMajor, &driverMinor, + &driverPatch, &driverName); + if (!b) { + if (verbose) + fprintf(stderr, "XF86DRIGetClientDriverName failed\n"); + return; + } + else if (verbose) { + printf("XF86DRIGetClientDriverName: %d.%d.%d %s\n", driverMajor, + driverMinor, driverPatch, driverName); + } + + /* + * OK, now we know the name of the relevant driver for this screen. + * dlopen() the driver library file, get a pointer to the driver's + * __driRegisterExtensions() function, and call it if it exists. + */ + { + char realDriverName[100]; + char *libDir = NULL; + void *handle; + + if (geteuid() == getuid()) { + /* don't allow setuid apps to use LIBGL_DRIVERS_DIR */ + libDir = getenv("LIBGL_DRIVERS_DIR"); + } + if (!libDir) + libDir = DEFAULT_DRIVER_DIR; + + sprintf(realDriverName, "%s/%s_dri.so", libDir, driverName); + /*printf("OPEN %s\n", realDriverName);*/ + handle = dlopen(realDriverName, RTLD_LAZY); + if (handle) { + typedef void *(*RegisterExtFunc)(void); + RegisterExtFunc registerExtFunc = (RegisterExtFunc) dlsym(handle, "__driRegisterExtensions"); + if (registerExtFunc) { + (*registerExtFunc)(); + } + dlclose(handle); + } + } +} + +#endif /* !BUILT_IN_DRI_DRIVER */ + + + +/* +** This is called as soon as libGL is loaded. +** Here we'll query the DRI driver for each screen and let each +** driver register its GL extension functions. +*/ +static void +#if defined(__GNUC__) +__attribute__ ((constructor)) +#endif +register_extensions(void) +{ +#ifdef BUILT_IN_DRI_DRIVER + __driRegisterExtensions(); +#else + int displayNum = 0, screenNum = 0; + while (1) { + char displayName[200]; + Display *dpy; + snprintf(displayName, 199, ":%d.%d", displayNum, screenNum); + dpy = XOpenDisplay(displayName); + if (dpy) { + get_extensions_on_display(dpy, screenNum); + XCloseDisplay(dpy); + screenNum++; + } + else if (screenNum == 0) { + /* 0th screen on current server couldn't be opened - we're done */ + break; + } + else { + /* continue with 0th screen on the next server */ + screenNum = 0; + displayNum++; + } + } +#endif +} + #endif /* GLX_DIRECT_RENDERING */ diff --git a/xc/lib/GL/glx/glxcmds.c b/xc/lib/GL/glx/glxcmds.c index 79e453af2..ad705c87a 100644 --- a/xc/lib/GL/glx/glxcmds.c +++ b/xc/lib/GL/glx/glxcmds.c @@ -67,7 +67,8 @@ GLXContext CreateContext(Display *dpy, XVisualInfo *vis, __GLXdisplayPrivate *priv; #endif - if (getenv("DRI_ALWAYS_INDIRECT")) allowDirect = GL_FALSE; + if (getenv("LIBGL_ALWAYS_INDIRECT")) + allowDirect = GL_FALSE; opcode = __glXSetupForCommand(dpy); if (!opcode) { return NULL; @@ -397,7 +398,7 @@ void glXUseXFont(Font font, int first, int count, int listBase) ** attribute "mask". */ void glXCopyContext(Display *dpy, GLXContext source, GLXContext dest, - GLuint mask) + unsigned long mask) { xGLXCopyContextReq *req; GLXContext gc = __glXGetCurrentContext(); @@ -1492,11 +1493,156 @@ void glXFreeContextEXT(Display *dpy, GLXContext ctx) } + +/* + * GLX 1.3 functions - these are just stubs for now! + */ + +GLXFBConfig glXChooseFBConfig(Display *dpy, int screen, const int *attribList, int *nitems) +{ + (void) dpy; + (void) screen; + (void) attribList; + (void) nitems; + return 0; +} + + +GLXContext glXCreateNewContext(Display *dpy, GLXFBConfig config, int renderType, GLXContext shareList, Bool direct) +{ + (void) dpy; + (void) config; + (void) renderType; + (void) shareList; + (void) direct; + return 0; +} + + +GLXPbuffer glXCreatePbuffer(Display *dpy, GLXFBConfig config, const int *attribList) +{ + (void) dpy; + (void) config; + (void) attribList; + return 0; +} + + +GLXPixmap glXCreatePixmap(Display *dpy, GLXFBConfig config, Pixmap pixmap, const int *attribList) +{ + (void) dpy; + (void) config; + (void) pixmap; + (void) attribList; + return 0; +} + + +GLXWindow glXCreateWindow(Display *dpy, GLXFBConfig config, Window win, const int *attribList) +{ + (void) dpy; + (void) config; + (void) win; + (void) attribList; + return 0; +} + + +void glXDestroyPbuffer(Display *dpy, GLXPbuffer pbuf) +{ + (void) dpy; + (void) pbuf; +} + + +void glXDestroyPixmap(Display *dpy, GLXPixmap pixmap) +{ + (void) dpy; + (void) pixmap; +} + + +void glXDestroyWindow(Display *dpy, GLXWindow window) +{ + (void) dpy; + (void) window; +} + + +GLXDrawable glXGetCurrentReadDrawable(void) +{ + return 0; +} + + +int glXGetFBConfigAttrib(Display *dpy, GLXFBConfig config, int attribute, int *value) +{ + (void) dpy; + (void) config; + (void) attribute; + (void) value; + return 0; +} + + +void glXGetSelectedEvent(Display *dpy, GLXDrawable drawable, unsigned long *mask) +{ + (void) dpy; + (void) drawable; + (void) mask; +} + + +XVisualInfo *glXGetVisualFromFBConfig(Display *dpy, GLXFBConfig config) +{ + (void) dpy; + (void) config; + return 0; +} + + +Bool glXMakeContextCurrent(Display *dpy, GLXDrawable draw, GLXDrawable read, GLXContext ctx) +{ + (void) dpy; + (void) draw; + (void) read; + (void) ctx; + return 0; +} + + +int glXQueryContext(Display *dpy, GLXContext ctx, int attribute, int *value) +{ + (void) dpy; + (void) ctx; + (void) attribute; + (void) value; + return 0; +} + + +void glXQueryDrawable(Display *dpy, GLXDrawable draw, int attribute, unsigned int *value) +{ + (void) dpy; + (void) draw; + (void) attribute; + (void) value; +} + + +void glXSelectEvent(Display *dpy, GLXDrawable drawable, unsigned long mask) +{ + (void) dpy; + (void) drawable; + (void) mask; +} + + + /* ** glXGetProcAddress support */ - struct name_address_pair { const char *Name; GLvoid *Address; @@ -1527,7 +1673,6 @@ static struct name_address_pair GLX_functions[] = { { "glXGetCurrentDisplay", (GLvoid *) glXGetCurrentDisplay }, -#if 0 /* enable this when GLX 1.3 is implemented */ { "glXChooseFBConfig", (GLvoid *) glXChooseFBConfig }, { "glXCreateNewContext", (GLvoid *) glXCreateNewContext }, { "glXCreatePbuffer", (GLvoid *) glXCreatePbuffer }, @@ -1544,7 +1689,6 @@ static struct name_address_pair GLX_functions[] = { { "glXQueryContext", (GLvoid *) glXQueryContext }, { "glXQueryDrawable", (GLvoid *) glXQueryDrawable }, { "glXSelectEvent", (GLvoid *) glXSelectEvent }, -#endif /* extension functions */ { "glXGetContextIDEXT", (GLvoid *) glXGetContextIDEXT }, diff --git a/xc/lib/GL/mesa/dri/dri_mesa.c b/xc/lib/GL/mesa/dri/dri_mesa.c index c136d8e22..4bb8fbb4b 100644 --- a/xc/lib/GL/mesa/dri/dri_mesa.c +++ b/xc/lib/GL/mesa/dri/dri_mesa.c @@ -735,8 +735,8 @@ static void driMesaDestroyScreen(Display *dpy, int scrn, void *private) * This is the entrypoint into the driver. * The driCreateScreen name is the symbol that libGL.so fetches. */ -void *driCreateScreen(Display *dpy, int scrn, __DRIscreen *psc, - int numConfigs, __GLXvisualConfig *config) +void *__driCreateScreen(Display *dpy, int scrn, __DRIscreen *psc, + int numConfigs, __GLXvisualConfig *config) { return driMesaCreateScreen(dpy, scrn, psc, numConfigs, config); } diff --git a/xc/lib/GL/mesa/dri/dri_mesa.h b/xc/lib/GL/mesa/dri/dri_mesa.h index 0f8fd58fc..8751925a3 100644 --- a/xc/lib/GL/mesa/dri/dri_mesa.h +++ b/xc/lib/GL/mesa/dri/dri_mesa.h @@ -29,8 +29,7 @@ SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. /* * Authors: * Kevin E. Martin <kevin@precisioninsight.com> - * - * $PI: xc/lib/GL/dri/dri_mesa.h,v 1.5 1999/04/05 05:24:31 martin Exp $ + * Brian Paul <brian@precisioninsight.com> */ #ifndef _DRI_MESA_H_ diff --git a/xc/lib/GL/mesa/include/GL/Imakefile b/xc/lib/GL/mesa/include/GL/Imakefile index 899ca1abc..1e75ff037 100644 --- a/xc/lib/GL/mesa/include/GL/Imakefile +++ b/xc/lib/GL/mesa/include/GL/Imakefile @@ -7,6 +7,7 @@ XCOMM $PI: xc/programs/Xserver/GL/mesa/include/GL/Imakefile,v 1.6 1999/03/15 21: DEFINES = $(GLX_DEFINES) LinkSourceFile(gl.h, ../../../../../extras/Mesa/include/GL) +LinkSourceFile(glext.h, ../../../../../extras/Mesa/include/GL) LinkSourceFile(glx.h, ../../../../../extras/Mesa/include/GL) LinkSourceFile(xmesa.h, ../../../../../extras/Mesa/include/GL) LinkSourceFile(xmesa_x.h, ../../../../../extras/Mesa/include/GL) diff --git a/xc/lib/GL/mesa/src/Imakefile b/xc/lib/GL/mesa/src/Imakefile index b3dade36c..79fe00505 100644 --- a/xc/lib/GL/mesa/src/Imakefile +++ b/xc/lib/GL/mesa/src/Imakefile @@ -335,7 +335,7 @@ LinkSourceFile(zoom.h, ../../../../extras/Mesa/src) #ifdef i386Architecture ASM_SRCS = ASM_OBJS = - ASM_DEFS = -DUSE_MMX_ASM -DUSE_X86_ASM -DUSE_3DNOW_ASM + ASM_DEFS = -DUSE_MMX_ASM -DUSE_X86_ASM #endif DEFINES = $(ALLOC_DEFINES) GlxDefines $(TDFX_DEFS) $(ASM_DEFS) diff --git a/xc/lib/GL/mesa/src/X86/Imakefile b/xc/lib/GL/mesa/src/X86/Imakefile index 99dfd8ea8..b3619ed96 100644 --- a/xc/lib/GL/mesa/src/X86/Imakefile +++ b/xc/lib/GL/mesa/src/X86/Imakefile @@ -76,7 +76,7 @@ XCOMM Disabling 3DNow code for the time being #endif DEFINES = $(ALLOC_DEFINES) GlxDefines -DFX $(X86_DEFS) $(MMX_DEFS) $(3DNOW_DEFS) - INCLUDES = -I$(XLIBSRC) -I$(EXTINCSRC) -I../include -I../../dri -I.. + INCLUDES = -I$(XLIBSRC) -I$(EXTINCSRC) -I../include -I../../include -I../../dri -I.. SRCS = $(X86_SRCS) $(MMX_SRCS) $(3DNOW_SRCS) OBJS = $(X86_OBJS) $(MMX_OBJS) $(3DNOW_OBJS) diff --git a/xc/lib/GL/mesa/src/drv/tdfx/tdfx_xmesa.c b/xc/lib/GL/mesa/src/drv/tdfx/tdfx_xmesa.c index 38772c95d..7fc55cb16 100644 --- a/xc/lib/GL/mesa/src/drv/tdfx/tdfx_xmesa.c +++ b/xc/lib/GL/mesa/src/drv/tdfx/tdfx_xmesa.c @@ -29,7 +29,6 @@ SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. * Authors: * Daryll Strauss <daryll@precisioninsight.com> * - * $PI: $ */ #ifdef GLX_DIRECT_RENDERING @@ -390,17 +389,22 @@ void XMesaSetSAREA() { } -extern void _register_gl_extensions(void); /* silence compiler warning */ +extern void __driRegisterExtensions(void); /* silence compiler warning */ -void _register_gl_extensions(void) +/* This function is called by libGL.so as soon as libGL.so is loaded. + * This is where we'd register new extension functions with the dispatcher. + */ +void __driRegisterExtensions(void) { - /* Here is where the 3Dfx driver would register new extensions - * with libGL.so. - * This function is called as soon as the driver object is dlopened. - */ #if 0 - /* really, the return code should be checked */ - _glapi_add_entrypoint("glFooBarEXT", _gloffset_FooBarEXT); + /* Example. Also look in fxdd.c for more details. */ + { + const int _gloffset_FooBarEXT = 555; /* just an example number! */ + if (_glapi_add_entrypoint("glFooBarEXT", _gloffset_FooBarEXT)) { + void *f = glXGetProcAddressARB("glFooBarEXT"); + assert(f); + } + } #endif } diff --git a/xc/programs/Xserver/GL/dri/dri.c b/xc/programs/Xserver/GL/dri/dri.c index 4add901fd..aeb9c9a8c 100644 --- a/xc/programs/Xserver/GL/dri/dri.c +++ b/xc/programs/Xserver/GL/dri/dri.c @@ -988,7 +988,7 @@ DRIWakeupHandler( ScreenPtr pScreen = screenInfo.screens[screenNum]; DRIScreenPrivPtr pDRIPriv = DRI_SCREEN_PRIV(pScreen); - DRILock(pScreen); + DRILock(pScreen, 0); if (pDRIPriv->pDriverInfo->driverSwapMethod == DRI_HIDE_X_CONTEXT) { /* hide X context by swapping 2D component here */ (*pDRIPriv->pDriverInfo->SwapContext)(pScreen, @@ -1386,7 +1386,7 @@ DRIValidateTree( } /* Call kernel to release lock */ - DRM_UNLOCK(pDRIPriv->drmFD, pDRIPriv->pSAREA, pDRIPriv->myContext); + DRIUnlock(pScreen); /* Grab drawable spin lock: a time out between 10 and 30 seconds is appropriate, since this should never time out except in the case of @@ -1395,8 +1395,7 @@ DRIValidateTree( DRISpinLockTimeout(&pDRIPriv->pSAREA->drawable_lock, 1, 10000); /* 10 secs */ /* Call kernel flush outstanding buffers and relock */ - DRM_LOCK(pDRIPriv->drmFD, pDRIPriv->pSAREA, pDRIPriv->myContext, - DRM_LOCK_QUIESCENT|DRM_LOCK_FLUSH_ALL); + DRILock(pScreen, DRM_LOCK_QUIESCENT|DRM_LOCK_FLUSH_ALL); /* Switch back to our 2D context if the X context is hidden */ if (pDRIPriv->pDriverInfo->driverSwapMethod == DRI_HIDE_X_CONTEXT) { @@ -1492,11 +1491,11 @@ DRIGetDrawableIndex( } void -DRILock(ScreenPtr pScreen) { +DRILock(ScreenPtr pScreen, int flags) { DRIScreenPrivPtr pDRIPriv = DRI_SCREEN_PRIV(pScreen); if (!lockRefCount) - DRM_LIGHT_LOCK(pDRIPriv->drmFD, pDRIPriv->pSAREA, pDRIPriv->myContext); + DRM_LOCK(pDRIPriv->drmFD, pDRIPriv->pSAREA, pDRIPriv->myContext, flags); lockRefCount++; } diff --git a/xc/programs/Xserver/GL/dri/dri.h b/xc/programs/Xserver/GL/dri/dri.h index 810711086..b58dec738 100644 --- a/xc/programs/Xserver/GL/dri/dri.h +++ b/xc/programs/Xserver/GL/dri/dri.h @@ -236,7 +236,7 @@ void DRIClipNotify( int dy); CARD32 DRIGetDrawableIndex( WindowPtr pWin); -void DRILock(ScreenPtr pScreen); +void DRILock(ScreenPtr pScreen, int flags); void DRIUnlock(ScreenPtr pScreen); void *DRIGetSAREAPrivate(ScreenPtr pScreen); DRIContextPrivPtr diff --git a/xc/programs/Xserver/GL/mesa/src/X/xf86glx_util.c b/xc/programs/Xserver/GL/mesa/src/X/xf86glx_util.c index c0cafaa8e..d9bdae17d 100644 --- a/xc/programs/Xserver/GL/mesa/src/X/xf86glx_util.c +++ b/xc/programs/Xserver/GL/mesa/src/X/xf86glx_util.c @@ -29,8 +29,7 @@ SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. /* * Authors: * Kevin E. Martin <kevin@precisioninsight.com> - * - * $PI: xc/programs/Xserver/GL/mesa/src/X/xf86glx_util.c,v 1.6 1999/05/27 03:43:48 jens Exp $ + * Brian Paul <brian@precisioninsight.com> */ #include <gcstruct.h> @@ -45,7 +44,7 @@ SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. #define ROUNDUP(nbytes, pad) ((((nbytes) + ((pad)-1)) / (pad)) * ((pad)>>3)) -XMesaImage *XMesaCreateImage(int depth, int width, int height, char *data) +XMesaImage *XMesaCreateImage(int bitsPerPixel, int width, int height, char *data) { XMesaImage *image; @@ -56,8 +55,8 @@ XMesaImage *XMesaCreateImage(int depth, int width, int height, char *data) image->height = height; image->data = data; /* Always pad to 32 bits */ - image->bytes_per_line = ROUNDUP((depth * width), 32); - image->bits_per_pixel = depth; + image->bytes_per_line = ROUNDUP((bitsPerPixel * width), 32); + image->bits_per_pixel = bitsPerPixel; } return image; diff --git a/xc/programs/Xserver/GL/mesa/src/X/xf86glx_util.h b/xc/programs/Xserver/GL/mesa/src/X/xf86glx_util.h index e5a88fe86..71965b318 100644 --- a/xc/programs/Xserver/GL/mesa/src/X/xf86glx_util.h +++ b/xc/programs/Xserver/GL/mesa/src/X/xf86glx_util.h @@ -29,8 +29,7 @@ SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. /* * Authors: * Kevin E. Martin <kevin@precisioninsight.com> - * - * $PI: xc/programs/Xserver/GL/mesa/src/X/xf86glx_util.h,v 1.5 1999/03/15 21:36:10 martin Exp $ + * Brian Paul <brian@precisioninsight.com> */ #ifndef _XF86GLX_UTIL_H_ @@ -50,7 +49,7 @@ struct _XMesaImageRec { int bits_per_pixel; }; -extern XMesaImage *XMesaCreateImage(int depth, int width, int height, +extern XMesaImage *XMesaCreateImage(int bitsPerPixel, int width, int height, char *data); extern void XMesaDestroyImage(XMesaImage *image); extern unsigned long XMesaGetPixel(XMesaImage *image, int x, int y); diff --git a/xc/programs/Xserver/hw/xfree86/drivers/i810/i810_driver.c b/xc/programs/Xserver/hw/xfree86/drivers/i810/i810_driver.c index de1cd5868..9691d9392 100644 --- a/xc/programs/Xserver/hw/xfree86/drivers/i810/i810_driver.c +++ b/xc/programs/Xserver/hw/xfree86/drivers/i810/i810_driver.c @@ -1395,7 +1395,7 @@ I810ModeInit(ScrnInfoPtr pScrn, DisplayModePtr mode) #ifdef XF86DRI if (pI810->directRenderingEnabled) { - DRILock(screenInfo.screens[pScrn->scrnIndex]); + DRILock(screenInfo.screens[pScrn->scrnIndex], 0); /* I810SwapContextPrivate(screenInfo.screens[pScrn->scrnIndex]); */ } #endif @@ -1834,7 +1834,7 @@ I810LeaveVT(int scrnIndex, int flags) { vgaHWLock(hwp); #ifdef XF86DRI if (pI810->directRenderingEnabled) - DRILock( screenInfo.screens[scrnIndex] ); + DRILock( screenInfo.screens[scrnIndex], 0 ); #endif } diff --git a/xc/programs/Xserver/hw/xfree86/drivers/tdfx/tdfx_driver.c b/xc/programs/Xserver/hw/xfree86/drivers/tdfx/tdfx_driver.c index 658e1f541..4fcfe8846 100644 --- a/xc/programs/Xserver/hw/xfree86/drivers/tdfx/tdfx_driver.c +++ b/xc/programs/Xserver/hw/xfree86/drivers/tdfx/tdfx_driver.c @@ -1327,7 +1327,7 @@ TDFXModeInit(ScrnInfoPtr pScrn, DisplayModePtr mode) #ifdef XF86DRI if (pTDFX->directRenderingEnabled) { - DRILock(screenInfo.screens[pScrn->scrnIndex]); + DRILock(screenInfo.screens[pScrn->scrnIndex], 0); TDFXSwapContextPrivate(screenInfo.screens[pScrn->scrnIndex]); } #endif @@ -1787,7 +1787,7 @@ TDFXLeaveVT(int scrnIndex, int flags) { #ifdef XF86DRI pTDFX = TDFXPTR(pScrn); if (pTDFX->directRenderingEnabled) { - DRILock(pScreen); + DRILock(pScreen, 0); } #endif } |