diff options
Diffstat (limited to 'src/mesa/main')
66 files changed, 6367 insertions, 5669 deletions
diff --git a/src/mesa/main/api_exec.c b/src/mesa/main/api_exec.c index f8ee0d59dd..6f66ff47a0 100644 --- a/src/mesa/main/api_exec.c +++ b/src/mesa/main/api_exec.c @@ -29,7 +29,7 @@ */ -#include "glheader.h" +#include "mfeatures.h" #if FEATURE_accum #include "accum.h" #endif @@ -116,6 +116,7 @@ #include "texstate.h" #include "mtypes.h" #include "varray.h" +#include "viewport.h" #if FEATURE_NV_vertex_program #include "shader/nvprogram.h" #endif @@ -838,6 +839,12 @@ _mesa_init_exec_table(struct _glapi_table *exec) SET_SetFragmentShaderConstantATI(exec, _mesa_SetFragmentShaderConstantATI); #endif + /* GL_ATI_envmap_bumpmap */ + SET_GetTexBumpParameterivATI(exec, _mesa_GetTexBumpParameterivATI); + SET_GetTexBumpParameterfvATI(exec, _mesa_GetTexBumpParameterfvATI); + SET_TexBumpParameterivATI(exec, _mesa_TexBumpParameterivATI); + SET_TexBumpParameterfvATI(exec, _mesa_TexBumpParameterfvATI); + #if FEATURE_EXT_framebuffer_object SET_IsRenderbufferEXT(exec, _mesa_IsRenderbufferEXT); SET_BindRenderbufferEXT(exec, _mesa_BindRenderbufferEXT); diff --git a/src/mesa/main/api_validate.c b/src/mesa/main/api_validate.c index 5c8955d7c8..42d1e579e0 100644 --- a/src/mesa/main/api_validate.c +++ b/src/mesa/main/api_validate.c @@ -87,11 +87,20 @@ check_valid_to_render(GLcontext *ctx, char *function) return GL_FALSE; } - /* Always need vertex positions, unless a vertex program is in use */ - if (!ctx->VertexProgram._Current && - !ctx->Array.ArrayObj->Vertex.Enabled && +#if FEATURE_es2_glsl + /* For ES2, we can draw if any vertex array is enabled (and we should + * always have a vertex program/shader). + */ + if (ctx->Array.ArrayObj->_Enabled == 0x0 || !ctx->VertexProgram._Current) + return GL_FALSE; +#else + /* For regular OpenGL, only draw if we have vertex positions (regardless + * of whether or not we have a vertex program/shader). + */ + if (!ctx->Array.ArrayObj->Vertex.Enabled && !ctx->Array.ArrayObj->VertexAttrib[0].Enabled) return GL_FALSE; +#endif return GL_TRUE; } diff --git a/src/mesa/main/attrib.c b/src/mesa/main/attrib.c index 218e0aeb6b..1d2c460488 100644 --- a/src/mesa/main/attrib.c +++ b/src/mesa/main/attrib.c @@ -55,8 +55,105 @@ #include "texparam.h" #include "texstate.h" #include "varray.h" +#include "viewport.h" #include "mtypes.h" -#include "math/m_xform.h" + + +/** + * glEnable()/glDisable() attribute group (GL_ENABLE_BIT). + */ +struct gl_enable_attrib +{ + GLboolean AlphaTest; + GLboolean AutoNormal; + GLboolean Blend; + GLbitfield ClipPlanes; + GLboolean ColorMaterial; + GLboolean ColorTable[COLORTABLE_MAX]; + GLboolean Convolution1D; + GLboolean Convolution2D; + GLboolean Separable2D; + GLboolean CullFace; + GLboolean DepthTest; + GLboolean Dither; + GLboolean Fog; + GLboolean Histogram; + GLboolean Light[MAX_LIGHTS]; + GLboolean Lighting; + GLboolean LineSmooth; + GLboolean LineStipple; + GLboolean IndexLogicOp; + GLboolean ColorLogicOp; + + GLboolean Map1Color4; + GLboolean Map1Index; + GLboolean Map1Normal; + GLboolean Map1TextureCoord1; + GLboolean Map1TextureCoord2; + GLboolean Map1TextureCoord3; + GLboolean Map1TextureCoord4; + GLboolean Map1Vertex3; + GLboolean Map1Vertex4; + GLboolean Map1Attrib[16]; /* GL_NV_vertex_program */ + GLboolean Map2Color4; + GLboolean Map2Index; + GLboolean Map2Normal; + GLboolean Map2TextureCoord1; + GLboolean Map2TextureCoord2; + GLboolean Map2TextureCoord3; + GLboolean Map2TextureCoord4; + GLboolean Map2Vertex3; + GLboolean Map2Vertex4; + GLboolean Map2Attrib[16]; /* GL_NV_vertex_program */ + + GLboolean MinMax; + GLboolean Normalize; + GLboolean PixelTexture; + GLboolean PointSmooth; + GLboolean PolygonOffsetPoint; + GLboolean PolygonOffsetLine; + GLboolean PolygonOffsetFill; + GLboolean PolygonSmooth; + GLboolean PolygonStipple; + GLboolean RescaleNormals; + GLboolean Scissor; + GLboolean Stencil; + GLboolean StencilTwoSide; /* GL_EXT_stencil_two_side */ + GLboolean MultisampleEnabled; /* GL_ARB_multisample */ + GLboolean SampleAlphaToCoverage; /* GL_ARB_multisample */ + GLboolean SampleAlphaToOne; /* GL_ARB_multisample */ + GLboolean SampleCoverage; /* GL_ARB_multisample */ + GLboolean SampleCoverageInvert; /* GL_ARB_multisample */ + GLboolean RasterPositionUnclipped; /* GL_IBM_rasterpos_clip */ + + GLbitfield Texture[MAX_TEXTURE_UNITS]; + GLbitfield TexGen[MAX_TEXTURE_UNITS]; + + /* SGI_texture_color_table */ + GLboolean TextureColorTable[MAX_TEXTURE_UNITS]; + + /* GL_ARB_vertex_program / GL_NV_vertex_program */ + GLboolean VertexProgram; + GLboolean VertexProgramPointSize; + GLboolean VertexProgramTwoSide; + + /* GL_ARB_point_sprite / GL_NV_point_sprite */ + GLboolean PointSprite; + GLboolean FragmentShaderATI; +}; + + +/** + * Node for the attribute stack. + */ +struct gl_attrib_node +{ + GLbitfield kind; + void *data; + struct gl_attrib_node *next; +}; + + /** * Special struct for saving/restoring texture state (GL_TEXTURE_BIT) @@ -365,7 +462,7 @@ _mesa_PushAttrib(GLbitfield mask) if (mask & GL_TEXTURE_BIT) { struct texture_state *texstate = CALLOC_STRUCT(texture_state); - GLuint u; + GLuint u, tex; if (!texstate) { _mesa_error(ctx, GL_OUT_OF_MEMORY, "glPushAttrib(GL_TEXTURE_BIT)"); @@ -381,38 +478,18 @@ _mesa_PushAttrib(GLbitfield mask) * accidentally get deleted while referenced in the attribute stack. */ for (u = 0; u < ctx->Const.MaxTextureUnits; u++) { - _mesa_reference_texobj(&texstate->SavedTexRef[u][TEXTURE_1D_INDEX], - ctx->Texture.Unit[u].Current1D); - _mesa_reference_texobj(&texstate->SavedTexRef[u][TEXTURE_2D_INDEX], - ctx->Texture.Unit[u].Current2D); - _mesa_reference_texobj(&texstate->SavedTexRef[u][TEXTURE_3D_INDEX], - ctx->Texture.Unit[u].Current3D); - _mesa_reference_texobj(&texstate->SavedTexRef[u][TEXTURE_CUBE_INDEX], - ctx->Texture.Unit[u].CurrentCubeMap); - _mesa_reference_texobj(&texstate->SavedTexRef[u][TEXTURE_RECT_INDEX], - ctx->Texture.Unit[u].CurrentRect); - _mesa_reference_texobj(&texstate->SavedTexRef[u][TEXTURE_1D_ARRAY_INDEX], - ctx->Texture.Unit[u].Current1DArray); - _mesa_reference_texobj(&texstate->SavedTexRef[u][TEXTURE_2D_ARRAY_INDEX], - ctx->Texture.Unit[u].Current2DArray); + for (tex = 0; tex < NUM_TEXTURE_TARGETS; tex++) { + _mesa_reference_texobj(&texstate->SavedTexRef[u][tex], + ctx->Texture.Unit[u].CurrentTex[tex]); + } } /* copy state/contents of the currently bound texture objects */ for (u = 0; u < ctx->Const.MaxTextureUnits; u++) { - _mesa_copy_texture_object(&texstate->SavedObj[u][TEXTURE_1D_INDEX], - ctx->Texture.Unit[u].Current1D); - _mesa_copy_texture_object(&texstate->SavedObj[u][TEXTURE_2D_INDEX], - ctx->Texture.Unit[u].Current2D); - _mesa_copy_texture_object(&texstate->SavedObj[u][TEXTURE_3D_INDEX], - ctx->Texture.Unit[u].Current3D); - _mesa_copy_texture_object(&texstate->SavedObj[u][TEXTURE_CUBE_INDEX], - ctx->Texture.Unit[u].CurrentCubeMap); - _mesa_copy_texture_object(&texstate->SavedObj[u][TEXTURE_RECT_INDEX], - ctx->Texture.Unit[u].CurrentRect); - _mesa_copy_texture_object(&texstate->SavedObj[u][TEXTURE_1D_ARRAY_INDEX], - ctx->Texture.Unit[u].Current1DArray); - _mesa_copy_texture_object(&texstate->SavedObj[u][TEXTURE_2D_ARRAY_INDEX], - ctx->Texture.Unit[u].Current2DArray); + for (tex = 0; tex < NUM_TEXTURE_TARGETS; tex++) { + _mesa_copy_texture_object(&texstate->SavedObj[u][tex], + ctx->Texture.Unit[u].CurrentTex[tex]); + } } _mesa_unlock_context_textures(ctx); @@ -699,26 +776,26 @@ pop_texture_group(GLcontext *ctx, struct texture_state *texstate) } _mesa_TexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, unit->EnvMode); _mesa_TexEnvfv(GL_TEXTURE_ENV, GL_TEXTURE_ENV_COLOR, unit->EnvColor); - _mesa_TexGeni(GL_S, GL_TEXTURE_GEN_MODE, unit->GenModeS); - _mesa_TexGeni(GL_T, GL_TEXTURE_GEN_MODE, unit->GenModeT); - _mesa_TexGeni(GL_R, GL_TEXTURE_GEN_MODE, unit->GenModeR); - _mesa_TexGeni(GL_Q, GL_TEXTURE_GEN_MODE, unit->GenModeQ); - _mesa_TexGenfv(GL_S, GL_OBJECT_PLANE, unit->ObjectPlaneS); - _mesa_TexGenfv(GL_T, GL_OBJECT_PLANE, unit->ObjectPlaneT); - _mesa_TexGenfv(GL_R, GL_OBJECT_PLANE, unit->ObjectPlaneR); - _mesa_TexGenfv(GL_Q, GL_OBJECT_PLANE, unit->ObjectPlaneQ); + _mesa_TexGeni(GL_S, GL_TEXTURE_GEN_MODE, unit->GenS.Mode); + _mesa_TexGeni(GL_T, GL_TEXTURE_GEN_MODE, unit->GenT.Mode); + _mesa_TexGeni(GL_R, GL_TEXTURE_GEN_MODE, unit->GenR.Mode); + _mesa_TexGeni(GL_Q, GL_TEXTURE_GEN_MODE, unit->GenQ.Mode); + _mesa_TexGenfv(GL_S, GL_OBJECT_PLANE, unit->GenS.ObjectPlane); + _mesa_TexGenfv(GL_T, GL_OBJECT_PLANE, unit->GenT.ObjectPlane); + _mesa_TexGenfv(GL_R, GL_OBJECT_PLANE, unit->GenR.ObjectPlane); + _mesa_TexGenfv(GL_Q, GL_OBJECT_PLANE, unit->GenQ.ObjectPlane); /* Eye plane done differently to avoid re-transformation */ { struct gl_texture_unit *destUnit = &ctx->Texture.Unit[u]; - COPY_4FV(destUnit->EyePlaneS, unit->EyePlaneS); - COPY_4FV(destUnit->EyePlaneT, unit->EyePlaneT); - COPY_4FV(destUnit->EyePlaneR, unit->EyePlaneR); - COPY_4FV(destUnit->EyePlaneQ, unit->EyePlaneQ); + COPY_4FV(destUnit->GenS.EyePlane, unit->GenS.EyePlane); + COPY_4FV(destUnit->GenT.EyePlane, unit->GenT.EyePlane); + COPY_4FV(destUnit->GenR.EyePlane, unit->GenR.EyePlane); + COPY_4FV(destUnit->GenQ.EyePlane, unit->GenQ.EyePlane); if (ctx->Driver.TexGen) { - ctx->Driver.TexGen(ctx, GL_S, GL_EYE_PLANE, unit->EyePlaneS); - ctx->Driver.TexGen(ctx, GL_T, GL_EYE_PLANE, unit->EyePlaneT); - ctx->Driver.TexGen(ctx, GL_R, GL_EYE_PLANE, unit->EyePlaneR); - ctx->Driver.TexGen(ctx, GL_Q, GL_EYE_PLANE, unit->EyePlaneQ); + ctx->Driver.TexGen(ctx, GL_S, GL_EYE_PLANE, unit->GenS.EyePlane); + ctx->Driver.TexGen(ctx, GL_T, GL_EYE_PLANE, unit->GenT.EyePlane); + ctx->Driver.TexGen(ctx, GL_R, GL_EYE_PLANE, unit->GenR.EyePlane); + ctx->Driver.TexGen(ctx, GL_Q, GL_EYE_PLANE, unit->GenQ.EyePlane); } } _mesa_set_enable(ctx, GL_TEXTURE_GEN_S, diff --git a/src/mesa/main/bufferobj.c b/src/mesa/main/bufferobj.c index 016543da01..c8d160baa9 100644 --- a/src/mesa/main/bufferobj.c +++ b/src/mesa/main/bufferobj.c @@ -1,8 +1,9 @@ /* * Mesa 3-D graphics library - * Version: 7.2 + * Version: 7.5 * * Copyright (C) 1999-2008 Brian Paul All Rights Reserved. + * Copyright (C) 1999-2009 VMware, Inc. 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"), @@ -25,7 +26,7 @@ /** * \file bufferobj.c - * \brief Functions for the GL_ARB_vertex_buffer_object extension. + * \brief Functions for the GL_ARB_vertex/pixel_buffer_object extensions. * \author Brian Paul, Ian Romanick */ @@ -144,8 +145,7 @@ buffer_object_subdata_range_good( GLcontext * ctx, GLenum target, /** * Allocate and initialize a new buffer object. * - * This function is intended to be called via - * \c dd_function_table::NewBufferObject. + * Default callback for the \c dd_function_table::NewBufferObject() hook. */ struct gl_buffer_object * _mesa_new_buffer_object( GLcontext *ctx, GLuint name, GLenum target ) @@ -163,8 +163,7 @@ _mesa_new_buffer_object( GLcontext *ctx, GLuint name, GLenum target ) /** * Delete a buffer object. * - * This function is intended to be called via - * \c dd_function_table::DeleteBuffer. + * Default callback for the \c dd_function_table::DeleteBuffer() hook. */ void _mesa_delete_buffer_object( GLcontext *ctx, struct gl_buffer_object *bufObj ) @@ -271,9 +270,8 @@ _mesa_initialize_buffer_object( struct gl_buffer_object *obj, * previously stored in the buffer object is lost. If \c data is \c NULL, * memory will be allocated, but no copy will occur. * - * This function is intended to be called via - * \c dd_function_table::BufferData. This function need not set GL error - * codes. The input parameters will have been tested before calling. + * This is the default callback for \c dd_function_table::BufferData() + * Note that all GL error checking will have been done already. * * \param ctx GL context. * \param target Buffer object target on which to operate. @@ -312,9 +310,8 @@ _mesa_buffer_data( GLcontext *ctx, GLenum target, GLsizeiptrARB size, * specified by \c size + \c offset extends beyond the end of the buffer or * if \c data is \c NULL, no copy is performed. * - * This function is intended to be called by - * \c dd_function_table::BufferSubData. This function need not set GL error - * codes. The input parameters will have been tested before calling. + * This is the default callback for \c dd_function_table::BufferSubData() + * Note that all GL error checking will have been done already. * * \param ctx GL context. * \param target Buffer object target on which to operate. @@ -346,15 +343,14 @@ _mesa_buffer_subdata( GLcontext *ctx, GLenum target, GLintptrARB offset, * specified by \c size + \c offset extends beyond the end of the buffer or * if \c data is \c NULL, no copy is performed. * - * This function is intended to be called by - * \c dd_function_table::BufferGetSubData. This function need not set GL error - * codes. The input parameters will have been tested before calling. + * This is the default callback for \c dd_function_table::GetBufferSubData() + * Note that all GL error checking will have been done already. * * \param ctx GL context. * \param target Buffer object target on which to operate. - * \param offset Offset of the first byte to be modified. + * \param offset Offset of the first byte to be fetched. * \param size Size, in bytes, of the data range. - * \param data Pointer to the data to store in the buffer object. + * \param data Destination for data * \param bufObj Object to be used. * * \sa glBufferGetSubDataARB, dd_function_table::GetBufferSubData. @@ -373,9 +369,7 @@ _mesa_buffer_get_subdata( GLcontext *ctx, GLenum target, GLintptrARB offset, /** - * Fallback function called via ctx->Driver.MapBuffer(). - * Hardware drivers that really implement buffer objects should never use - * this function. + * Default callback for \c dd_function_tabel::MapBuffer(). * * The function parameters will have been already tested for errors. * @@ -407,9 +401,7 @@ _mesa_buffer_map( GLcontext *ctx, GLenum target, GLenum access, /** - * Fallback function called via ctx->Driver.MapBuffer(). - * Hardware drivers that really implement buffer objects should never use - * function. + * Default callback for \c dd_function_table::MapBuffer(). * * The input parameters will have been already tested for errors. * @@ -446,6 +438,7 @@ _mesa_init_buffer_objects( GLcontext *ctx ) ctx->Array.ElementArrayBufferObj = ctx->Array.NullBufferObj; } + /** * Bind the specified target to buffer for the specified context. */ @@ -796,11 +789,18 @@ _mesa_DeleteBuffersARB(GLsizei n, const GLuint *ids) for (i = 0; i < n; i++) { struct gl_buffer_object *bufObj = _mesa_lookup_bufferobj(ctx, ids[i]); if (bufObj) { - /* unbind any vertex pointers bound to this buffer */ GLuint j; ASSERT(bufObj->Name == ids[i]); + if (bufObj->Pointer) { + /* if mapped, unmap it now */ + ctx->Driver.UnmapBuffer(ctx, 0, bufObj); + bufObj->Access = DEFAULT_ACCESS; + bufObj->Pointer = NULL; + } + + /* unbind any vertex pointers bound to this buffer */ unbind(ctx, &ctx->Array.ArrayObj->Vertex.BufferObj, bufObj); unbind(ctx, &ctx->Array.ArrayObj->Normal.BufferObj, bufObj); unbind(ctx, &ctx->Array.ArrayObj->Color.BufferObj, bufObj); @@ -822,6 +822,7 @@ _mesa_DeleteBuffersARB(GLsizei n, const GLuint *ids) _mesa_BindBufferARB( GL_ELEMENT_ARRAY_BUFFER_ARB, 0 ); } + /* unbind any pixel pack/unpack pointers bound to this buffer */ if (ctx->Pack.BufferObj == bufObj) { _mesa_BindBufferARB( GL_PIXEL_PACK_BUFFER_EXT, 0 ); } @@ -951,8 +952,10 @@ _mesa_BufferDataARB(GLenum target, GLsizeiptrARB size, } if (bufObj->Pointer) { - _mesa_error(ctx, GL_INVALID_OPERATION, "glBufferDataARB(buffer is mapped)" ); - return; + /* Unmap the existing buffer. We'll replace it now. Not an error. */ + ctx->Driver.UnmapBuffer(ctx, target, bufObj); + bufObj->Access = DEFAULT_ACCESS; + bufObj->Pointer = NULL; } ASSERT(ctx->Driver.BufferData); @@ -1068,10 +1071,7 @@ _mesa_UnmapBufferARB(GLenum target) return GL_FALSE; } - if (ctx->Driver.UnmapBuffer) { - status = ctx->Driver.UnmapBuffer( ctx, target, bufObj ); - } - + status = ctx->Driver.UnmapBuffer( ctx, target, bufObj ); bufObj->Access = DEFAULT_ACCESS; bufObj->Pointer = NULL; diff --git a/src/mesa/main/buffers.c b/src/mesa/main/buffers.c index 818d068a12..c5f13345f0 100644 --- a/src/mesa/main/buffers.c +++ b/src/mesa/main/buffers.c @@ -120,11 +120,9 @@ draw_buffer_enum_to_bitmask(GLenum buffer) case GL_AUX0: return BUFFER_BIT_AUX0; case GL_AUX1: - return BUFFER_BIT_AUX1; case GL_AUX2: - return BUFFER_BIT_AUX2; case GL_AUX3: - return BUFFER_BIT_AUX3; + return 1 << BUFFER_COUNT; /* invalid, but not BAD_MASK */ case GL_COLOR_ATTACHMENT0_EXT: return BUFFER_BIT_COLOR0; case GL_COLOR_ATTACHMENT1_EXT: @@ -177,11 +175,9 @@ read_buffer_enum_to_index(GLenum buffer) case GL_AUX0: return BUFFER_AUX0; case GL_AUX1: - return BUFFER_AUX1; case GL_AUX2: - return BUFFER_AUX2; case GL_AUX3: - return BUFFER_AUX3; + return BUFFER_COUNT; /* invalid, but not -1 */ case GL_COLOR_ATTACHMENT0_EXT: return BUFFER_COLOR0; case GL_COLOR_ATTACHMENT1_EXT: @@ -290,7 +286,10 @@ _mesa_DrawBuffersARB(GLsizei n, const GLenum *buffers) GET_CURRENT_CONTEXT(ctx); ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx); - if (n < 1 || n > (GLsizei) ctx->Const.MaxDrawBuffers) { + /* Turns out n==0 is a valid input that should not produce an error. + * The remaining code below correctly handles the n==0 case. + */ + if (n < 0 || n > (GLsizei) ctx->Const.MaxDrawBuffers) { _mesa_error(ctx, GL_INVALID_VALUE, "glDrawBuffersARB(n)"); return; } @@ -332,12 +331,14 @@ _mesa_DrawBuffersARB(GLsizei n, const GLenum *buffers) _mesa_drawbuffers(ctx, n, buffers, destMask); /* - * Call device driver function. + * Call device driver function. Note that n can be equal to 0, + * in which case we don't want to reference buffers[0], which + * may not be valid. */ if (ctx->Driver.DrawBuffers) ctx->Driver.DrawBuffers(ctx, n, buffers); else if (ctx->Driver.DrawBuffer) - ctx->Driver.DrawBuffer(ctx, buffers[0]); + ctx->Driver.DrawBuffer(ctx, n>0? buffers[0]:GL_NONE); } diff --git a/src/mesa/main/clip.c b/src/mesa/main/clip.c index 43ef55ee3b..96c80e6ef8 100644 --- a/src/mesa/main/clip.c +++ b/src/mesa/main/clip.c @@ -29,7 +29,6 @@ #include "macros.h" #include "mtypes.h" -#include "math/m_xform.h" #include "math/m_matrix.h" diff --git a/src/mesa/main/compiler.h b/src/mesa/main/compiler.h new file mode 100644 index 0000000000..39b19bb776 --- /dev/null +++ b/src/mesa/main/compiler.h @@ -0,0 +1,479 @@ +/* + * Mesa 3-D graphics library + * Version: 7.5 + * + * Copyright (C) 1999-2008 Brian Paul All Rights Reserved. + * Copyright (C) 2009 VMware, Inc. 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. + */ + + +/** + * \file compiler.h + * Compiler-related stuff. + */ + + +#ifndef COMPILER_H +#define COMPILER_H + + +#include <assert.h> +#include <ctype.h> +#if defined(__alpha__) && defined(CCPML) +#include <cpml.h> /* use Compaq's Fast Math Library on Alpha */ +#else +#include <math.h> +#endif +#include <limits.h> +#include <stdlib.h> +#include <stdio.h> +#include <string.h> +#if defined(__linux__) && defined(__i386__) +#include <fpu_control.h> +#endif +#include <float.h> +#include <stdarg.h> + + +#ifdef __cplusplus +extern "C" { +#endif + + +/** + * Get standard integer types + */ +#if defined(_MSC_VER) + typedef __int8 int8_t; + typedef unsigned __int8 uint8_t; + typedef __int16 int16_t; + typedef unsigned __int16 uint16_t; +# ifndef __eglplatform_h_ + typedef __int32 int32_t; +# endif + typedef unsigned __int32 uint32_t; + typedef __int64 int64_t; + typedef unsigned __int64 uint64_t; + +# if defined(_WIN64) + typedef __int64 intptr_t; + typedef unsigned __int64 uintptr_t; +# else + typedef __int32 intptr_t; + typedef unsigned __int32 uintptr_t; +# endif + +# define INT64_C(__val) __val##i64 +# define UINT64_C(__val) __val##ui64 +#else +# include <stdint.h> +#endif + + +/** + * Sun compilers define __i386 instead of the gcc-style __i386__ + */ +#ifdef __SUNPRO_C +# if !defined(__i386__) && defined(__i386) +# define __i386__ +# elif !defined(__amd64__) && defined(__amd64) +# define __amd64__ +# elif !defined(__sparc__) && defined(__sparc) +# define __sparc__ +# endif +# if !defined(__volatile) +# define __volatile volatile +# endif +#endif + + +/** + * finite macro. + */ +#if defined(_WIN32) && !defined(__WIN32__) && !defined(__CYGWIN__) && !defined(BUILD_FOR_SNAP) +# define __WIN32__ +# define finite _finite +#endif +#if defined(__WATCOMC__) +# define finite _finite +# pragma disable_message(201) /* Disable unreachable code warnings */ +#endif + + +/** + * Disable assorted warnings + */ +#if !defined(OPENSTEP) && (defined(__WIN32__) && !defined(__CYGWIN__)) && !defined(BUILD_FOR_SNAP) +# if !defined(__GNUC__) /* mingw environment */ +# pragma warning( disable : 4068 ) /* unknown pragma */ +# 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 */ +# endif +# endif +#endif + + +/** + * Function inlining + */ +#if defined(__GNUC__) +# define INLINE __inline__ +#elif defined(__MSC__) +# define INLINE __inline +#elif defined(_MSC_VER) +# define INLINE __inline +#elif defined(__ICL) +# define INLINE __inline +#elif defined(__INTEL_COMPILER) +# define INLINE inline +#elif defined(__WATCOMC__) && (__WATCOMC__ >= 1100) +# define INLINE __inline +#elif defined(__SUNPRO_C) && defined(__C99FEATURES__) +# define INLINE inline +# define __inline inline +# define __inline__ inline +#elif (__STDC_VERSION__ >= 199901L) /* C99 */ +# define INLINE inline +#else +# define INLINE +#endif + + +/** + * PUBLIC/USED macros + * + * If we build the library with gcc's -fvisibility=hidden flag, we'll + * use the PUBLIC macro to mark functions that are to be exported. + * + * We also need to define a USED attribute, so the optimizer doesn't + * inline a static function that we later use in an alias. - ajax + */ +#if defined(__GNUC__) && (__GNUC__ * 100 + __GNUC_MINOR__) >= 303 +# define PUBLIC __attribute__((visibility("default"))) +# define USED __attribute__((used)) +#else +# define PUBLIC +# define USED +#endif + + +/** + * Some compilers don't like some of Mesa's const usage. In those places use + * CONST instead of const. Pass -DNO_CONST to compilers where this matters. + */ +#ifdef NO_CONST +# define CONST +#else +# define CONST const +#endif + + +/** + * __builtin_expect macros + */ +#if (!defined(__GNUC__) || __GNUC__ < 3) && (!defined(__IBMC__) || __IBMC__ < 900) +# define __builtin_expect(x, y) x +#endif + + +/** + * The __FUNCTION__ gcc variable is generally only used for debugging. + * If we're not using gcc, define __FUNCTION__ as a cpp symbol here. + * Don't define it if using a newer Windows compiler. + */ +#ifndef __FUNCTION__ +# if defined(__VMS) +# define __FUNCTION__ "VMS$NL:" +# elif ((!defined __GNUC__) || (__GNUC__ < 2)) && (!defined __xlC__) && \ + (!defined(_MSC_VER) || _MSC_VER < 1300) +# if (__STDC_VERSION__ >= 199901L) /* C99 */ || \ + (defined(__SUNPRO_C) && defined(__C99FEATURES__)) +# define __FUNCTION__ __func__ +# else +# define __FUNCTION__ "<unknown>" +# endif +# endif +#endif + + +/** + * Either define MESA_BIG_ENDIAN or MESA_LITTLE_ENDIAN. + * Do not use them unless absolutely necessary! + * Try to use a runtime test instead. + * For now, only used by some DRI hardware drivers for color/texel packing. + */ +#if defined(BYTE_ORDER) && defined(BIG_ENDIAN) && BYTE_ORDER == BIG_ENDIAN +#if defined(__linux__) +#include <byteswap.h> +#define CPU_TO_LE32( x ) bswap_32( x ) +#else /*__linux__*/ +#include <sys/endian.h> +#define CPU_TO_LE32( x ) bswap32( x ) +#endif /*__linux__*/ +#define MESA_BIG_ENDIAN 1 +#else +#define CPU_TO_LE32( x ) ( x ) +#define MESA_LITTLE_ENDIAN 1 +#endif +#define LE32_TO_CPU( x ) CPU_TO_LE32( x ) + + + +#if !defined(CAPI) && defined(WIN32) && !defined(BUILD_FOR_SNAP) +#define CAPI _cdecl +#endif + + +/** + * Create a macro so that asm functions can be linked into compilers other + * than GNU C + */ +#ifndef _ASMAPI +#if defined(WIN32) && !defined(BUILD_FOR_SNAP)/* was: !defined( __GNUC__ ) && !defined( VMS ) && !defined( __INTEL_COMPILER )*/ +#define _ASMAPI __cdecl +#else +#define _ASMAPI +#endif +#ifdef PTR_DECL_IN_FRONT +#define _ASMAPIP * _ASMAPI +#else +#define _ASMAPIP _ASMAPI * +#endif +#endif + +#ifdef USE_X86_ASM +#define _NORMAPI _ASMAPI +#define _NORMAPIP _ASMAPIP +#else +#define _NORMAPI +#define _NORMAPIP * +#endif + + +/* This is a macro on IRIX */ +#ifdef _P +#undef _P +#endif + + +/* Turn off macro checking systems used by other libraries */ +#ifdef CHECK +#undef CHECK +#endif + + +/** + * ASSERT macro + */ +#if !defined(_WIN32_WCE) +#if defined(BUILD_FOR_SNAP) && defined(CHECKED) +# define ASSERT(X) _CHECK(X) +#elif defined(DEBUG) +# define ASSERT(X) assert(X) +#else +# define ASSERT(X) +#endif +#endif + + +#ifndef NULL +#define NULL 0 +#endif + + +/** + * LONGSTRING macro + * gcc -pedantic warns about long string literals, LONGSTRING silences that. + */ +#if !defined(__GNUC__) || (__GNUC__ < 2) || \ + ((__GNUC__ == 2) && (__GNUC_MINOR__ <= 7)) +# define LONGSTRING +#else +# define LONGSTRING __extension__ +#endif + + +#ifndef M_PI +#define M_PI (3.1415926536) +#endif + +#ifndef M_E +#define M_E (2.7182818284590452354) +#endif + +#ifndef ONE_DIV_LN2 +#define ONE_DIV_LN2 (1.442695040888963456) +#endif + +#ifndef ONE_DIV_SQRT_LN2 +#define ONE_DIV_SQRT_LN2 (1.201122408786449815) +#endif + +#ifndef FLT_MAX_EXP +#define FLT_MAX_EXP 128 +#endif + + +/** + * USE_IEEE: Determine if we're using IEEE floating point + */ +#if defined(__i386__) || defined(__386__) || defined(__sparc__) || \ + defined(__s390x__) || defined(__powerpc__) || \ + defined(__x86_64__) || \ + defined(ia64) || defined(__ia64__) || \ + defined(__hppa__) || defined(hpux) || \ + defined(__mips) || defined(_MIPS_ARCH) || \ + defined(__arm__) || \ + defined(__sh__) || defined(__m32r__) || \ + (defined(__sun) && defined(_IEEE_754)) || \ + (defined(__alpha__) && (defined(__IEEE_FLOAT) || !defined(VMS))) +#define USE_IEEE +#define IEEE_ONE 0x3f800000 +#endif + + +/** + * START/END_FAST_MATH macros: + * + * START_FAST_MATH: Set x86 FPU to faster, 32-bit precision mode (and save + * original mode to a temporary). + * END_FAST_MATH: Restore x86 FPU to original mode. + */ +#if defined(__GNUC__) && defined(__i386__) +/* + * Set the x86 FPU control word to guarentee only 32 bits of precision + * are stored in registers. Allowing the FPU to store more introduces + * differences between situations where numbers are pulled out of memory + * vs. situations where the compiler is able to optimize register usage. + * + * In the worst case, we force the compiler to use a memory access to + * truncate the float, by specifying the 'volatile' keyword. + */ +/* Hardware default: All exceptions masked, extended double precision, + * round to nearest (IEEE compliant): + */ +#define DEFAULT_X86_FPU 0x037f +/* All exceptions masked, single precision, round to nearest: + */ +#define FAST_X86_FPU 0x003f +/* The fldcw instruction will cause any pending FP exceptions to be + * raised prior to entering the block, and we clear any pending + * exceptions before exiting the block. Hence, asm code has free + * reign over the FPU while in the fast math block. + */ +#if defined(NO_FAST_MATH) +#define START_FAST_MATH(x) \ +do { \ + static GLuint mask = DEFAULT_X86_FPU; \ + __asm__ ( "fnstcw %0" : "=m" (*&(x)) ); \ + __asm__ ( "fldcw %0" : : "m" (mask) ); \ +} while (0) +#else +#define START_FAST_MATH(x) \ +do { \ + static GLuint mask = FAST_X86_FPU; \ + __asm__ ( "fnstcw %0" : "=m" (*&(x)) ); \ + __asm__ ( "fldcw %0" : : "m" (mask) ); \ +} while (0) +#endif +/* Restore original FPU mode, and clear any exceptions that may have + * occurred in the FAST_MATH block. + */ +#define END_FAST_MATH(x) \ +do { \ + __asm__ ( "fnclex ; fldcw %0" : : "m" (*&(x)) ); \ +} while (0) + +#elif defined(__WATCOMC__) && defined(__386__) +#define DEFAULT_X86_FPU 0x037f /* See GCC comments above */ +#define FAST_X86_FPU 0x003f /* See GCC comments above */ +void _watcom_start_fast_math(unsigned short *x,unsigned short *mask); +#pragma aux _watcom_start_fast_math = \ + "fnstcw word ptr [eax]" \ + "fldcw word ptr [ecx]" \ + parm [eax] [ecx] \ + modify exact []; +void _watcom_end_fast_math(unsigned short *x); +#pragma aux _watcom_end_fast_math = \ + "fnclex" \ + "fldcw word ptr [eax]" \ + parm [eax] \ + modify exact []; +#if defined(NO_FAST_MATH) +#define START_FAST_MATH(x) \ +do { \ + static GLushort mask = DEFAULT_X86_FPU; \ + _watcom_start_fast_math(&x,&mask); \ +} while (0) +#else +#define START_FAST_MATH(x) \ +do { \ + static GLushort mask = FAST_X86_FPU; \ + _watcom_start_fast_math(&x,&mask); \ +} while (0) +#endif +#define END_FAST_MATH(x) _watcom_end_fast_math(&x) + +#elif defined(_MSC_VER) && defined(_M_IX86) +#define DEFAULT_X86_FPU 0x037f /* See GCC comments above */ +#define FAST_X86_FPU 0x003f /* See GCC comments above */ +#if defined(NO_FAST_MATH) +#define START_FAST_MATH(x) do {\ + static GLuint mask = DEFAULT_X86_FPU;\ + __asm fnstcw word ptr [x]\ + __asm fldcw word ptr [mask]\ +} while(0) +#else +#define START_FAST_MATH(x) do {\ + static GLuint mask = FAST_X86_FPU;\ + __asm fnstcw word ptr [x]\ + __asm fldcw word ptr [mask]\ +} while(0) +#endif +#define END_FAST_MATH(x) do {\ + __asm fnclex\ + __asm fldcw word ptr [x]\ +} while(0) + +#else +#define START_FAST_MATH(x) x = 0 +#define END_FAST_MATH(x) (void)(x) +#endif + + + +#define Elements(x) (sizeof(x)/sizeof(*(x))) + + + + +#ifdef __cplusplus +} +#endif + + +#endif /* COMPILER_H */ diff --git a/src/mesa/main/config.h b/src/mesa/main/config.h index c3feffda98..fc31155b35 100644 --- a/src/mesa/main/config.h +++ b/src/mesa/main/config.h @@ -1,6 +1,6 @@ /* * Mesa 3-D graphics library - * Version: 7.3 + * Version: 7.5 * * Copyright (C) 1999-2007 Brian Paul All Rights Reserved. * Copyright (C) 2008 VMware, Inc. All Rights Reserved. @@ -32,9 +32,6 @@ #define MESA_CONFIG_H_INCLUDED -#include "main/mfeatures.h" - - /** * \name OpenGL implementation limits */ @@ -71,7 +68,7 @@ #define MAX_PIXEL_MAP_TABLE 256 /** Maximum number of auxillary color buffers */ -#define MAX_AUX_BUFFERS 4 +#define MAX_AUX_BUFFERS 1 /** Maximum order (degree) of curves */ #ifdef AMIGA @@ -101,16 +98,16 @@ #define MAX_COLOR_TABLE_SIZE 256 /** Number of 1D/2D texture mipmap levels */ -#define MAX_TEXTURE_LEVELS 12 +#define MAX_TEXTURE_LEVELS 13 /** Number of 3D texture mipmap levels */ #define MAX_3D_TEXTURE_LEVELS 9 /** Number of cube texture mipmap levels - GL_ARB_texture_cube_map */ -#define MAX_CUBE_TEXTURE_LEVELS 12 +#define MAX_CUBE_TEXTURE_LEVELS 13 /** Maximum rectangular texture size - GL_NV_texture_rectangle */ -#define MAX_TEXTURE_RECT_SIZE 2048 +#define MAX_TEXTURE_RECT_SIZE 4096 /** Maximum number of layers in a 1D or 2D array texture - GL_MESA_texture_array */ #define MAX_ARRAY_TEXTURE_LAYERS 64 @@ -166,7 +163,7 @@ #define MAX_TEXTURE_MAX_ANISOTROPY 16.0 /** For GL_EXT_texture_lod_bias (typically MAX_TEXTURE_LEVELS - 1) */ -#define MAX_TEXTURE_LOD_BIAS 11.0 +#define MAX_TEXTURE_LOD_BIAS 12.0 /** For GL_ARB_vertex_program */ /*@{*/ @@ -189,7 +186,7 @@ #define MAX_PROGRAM_CALL_DEPTH 8 #define MAX_PROGRAM_TEMPS 128 #define MAX_PROGRAM_ADDRESS_REGS 2 -#define MAX_UNIFORMS 256 /**< number of vec4 uniforms */ +#define MAX_UNIFORMS 1024 /**< number of vec4 uniforms */ #define MAX_VARYING 8 /**< number of float[4] vectors */ #define MAX_SAMPLERS MAX_TEXTURE_IMAGE_UNITS #define MAX_PROGRAM_INPUTS 32 @@ -235,7 +232,8 @@ #define MAX_COLOR_ATTACHMENTS 8 /*@}*/ - +/** For GL_ATI_envmap_bump - support bump mapping on first 8 units */ +#define SUPPORTED_ATI_BUMP_UNITS 0xff /** * \name Mesa-specific parameters diff --git a/src/mesa/main/context.c b/src/mesa/main/context.c index c5b90d9cda..b24a3b4409 100644 --- a/src/mesa/main/context.c +++ b/src/mesa/main/context.c @@ -77,6 +77,7 @@ #include "glheader.h" +#include "mfeatures.h" #include "imports.h" #if FEATURE_accum #include "accum.h" @@ -93,6 +94,7 @@ #include "colortab.h" #endif #include "context.h" +#include "cpuinfo.h" #include "debug.h" #include "depth.h" #if FEATURE_dlist @@ -131,6 +133,7 @@ #include "rastpos.h" #endif #include "scissor.h" +#include "shared.h" #include "simple_list.h" #include "state.h" #include "stencil.h" @@ -141,6 +144,7 @@ #include "mtypes.h" #include "varray.h" #include "version.h" +#include "viewport.h" #include "vtxfmt.h" #include "glapi/glthread.h" #include "glapi/glapioffsets.h" @@ -175,7 +179,7 @@ GLfloat _mesa_ubyte_to_float_color_tab[256]; /** * Swap buffers notification callback. * - * \param gc GL context. + * \param ctx GL context. * * Called by window system just before swapping buffers. * We have to finish any pending rendering. @@ -183,6 +187,7 @@ GLfloat _mesa_ubyte_to_float_color_tab[256]; void _mesa_notifySwapBuffers(__GLcontext *ctx) { + FLUSH_VERTICES( ctx, 0 ); if (ctx->Driver.Flush) { ctx->Driver.Flush(ctx); } @@ -349,6 +354,36 @@ _mesa_destroy_visual( GLvisual *vis ) /**********************************************************************/ /*@{*/ + +/** + * This is lame. gdb only seems to recognize enum types that are + * actually used somewhere. We want to be able to print/use enum + * values such as TEXTURE_2D_INDEX in gdb. But we don't actually use + * the gl_texture_index type anywhere. Thus, this lame function. + */ +static void +dummy_enum_func(void) +{ + gl_buffer_index bi; + gl_colortable_index ci; + gl_face_index fi; + gl_frag_attrib fa; + gl_frag_result fr; + gl_texture_index ti; + gl_vert_attrib va; + gl_vert_result vr; + + (void) bi; + (void) ci; + (void) fi; + (void) fa; + (void) fr; + (void) ti; + (void) va; + (void) vr; +} + + /** * One-time initialization mutex lock. * @@ -382,15 +417,14 @@ one_time_init( GLcontext *ctx ) assert( sizeof(GLint) == 4 ); assert( sizeof(GLuint) == 4 ); + _mesa_get_cpu_features(); + _mesa_init_sqrt_table(); for (i = 0; i < 256; i++) { _mesa_ubyte_to_float_color_tab[i] = (float) i / 255.0F; } -#ifdef USE_SPARC_ASM - _mesa_init_sparc_glapi_relocs(); -#endif if (_mesa_getenv("MESA_DEBUG")) { _glapi_noop_enable_warnings(GL_TRUE); _glapi_set_warning_func( (_glapi_warning_func) _mesa_warning ); @@ -407,384 +441,8 @@ one_time_init( GLcontext *ctx ) alreadyCalled = GL_TRUE; } _glthread_UNLOCK_MUTEX(OneTimeLock); -} - - -/** - * Allocate and initialize a shared context state structure. - * Initializes the display list, texture objects and vertex programs hash - * tables, allocates the texture objects. If it runs out of memory, frees - * everything already allocated before returning NULL. - * - * \return pointer to a gl_shared_state structure on success, or NULL on - * failure. - */ -static GLboolean -alloc_shared_state( GLcontext *ctx ) -{ - struct gl_shared_state *ss = CALLOC_STRUCT(gl_shared_state); - if (!ss) - return GL_FALSE; - - ctx->Shared = ss; - - _glthread_INIT_MUTEX(ss->Mutex); - ss->DisplayList = _mesa_NewHashTable(); - ss->TexObjects = _mesa_NewHashTable(); - ss->Programs = _mesa_NewHashTable(); - -#if FEATURE_ARB_vertex_program - ss->DefaultVertexProgram = (struct gl_vertex_program *) - ctx->Driver.NewProgram(ctx, GL_VERTEX_PROGRAM_ARB, 0); - if (!ss->DefaultVertexProgram) - goto cleanup; -#endif -#if FEATURE_ARB_fragment_program - ss->DefaultFragmentProgram = (struct gl_fragment_program *) - ctx->Driver.NewProgram(ctx, GL_FRAGMENT_PROGRAM_ARB, 0); - if (!ss->DefaultFragmentProgram) - goto cleanup; -#endif -#if FEATURE_ATI_fragment_shader - ss->ATIShaders = _mesa_NewHashTable(); - ss->DefaultFragmentShader = _mesa_new_ati_fragment_shader(ctx, 0); - if (!ss->DefaultFragmentShader) - goto cleanup; -#endif - -#if FEATURE_ARB_vertex_buffer_object || FEATURE_ARB_pixel_buffer_object - ss->BufferObjects = _mesa_NewHashTable(); -#endif - - ss->ArrayObjects = _mesa_NewHashTable(); - -#if FEATURE_ARB_shader_objects - ss->ShaderObjects = _mesa_NewHashTable(); -#endif - - ss->Default1D = (*ctx->Driver.NewTextureObject)(ctx, 0, GL_TEXTURE_1D); - if (!ss->Default1D) - goto cleanup; - - ss->Default2D = (*ctx->Driver.NewTextureObject)(ctx, 0, GL_TEXTURE_2D); - if (!ss->Default2D) - goto cleanup; - - ss->Default3D = (*ctx->Driver.NewTextureObject)(ctx, 0, GL_TEXTURE_3D); - if (!ss->Default3D) - goto cleanup; - - ss->DefaultCubeMap = (*ctx->Driver.NewTextureObject)(ctx, 0, GL_TEXTURE_CUBE_MAP_ARB); - if (!ss->DefaultCubeMap) - goto cleanup; - - ss->DefaultRect = (*ctx->Driver.NewTextureObject)(ctx, 0, GL_TEXTURE_RECTANGLE_NV); - if (!ss->DefaultRect) - goto cleanup; - - ss->Default1DArray = (*ctx->Driver.NewTextureObject)(ctx, 0, GL_TEXTURE_1D_ARRAY_EXT); - if (!ss->Default1DArray) - goto cleanup; - - ss->Default2DArray = (*ctx->Driver.NewTextureObject)(ctx, 0, GL_TEXTURE_2D_ARRAY_EXT); - if (!ss->Default2DArray) - goto cleanup; - - /* sanity check */ - assert(ss->Default1D->RefCount == 1); - - _glthread_INIT_MUTEX(ss->TexMutex); - ss->TextureStateStamp = 0; - -#if FEATURE_EXT_framebuffer_object - ss->FrameBuffers = _mesa_NewHashTable(); - if (!ss->FrameBuffers) - goto cleanup; - ss->RenderBuffers = _mesa_NewHashTable(); - if (!ss->RenderBuffers) - goto cleanup; -#endif - - return GL_TRUE; - -cleanup: - /* Ran out of memory at some point. Free everything and return NULL */ - if (ss->DisplayList) - _mesa_DeleteHashTable(ss->DisplayList); - if (ss->TexObjects) - _mesa_DeleteHashTable(ss->TexObjects); - if (ss->Programs) - _mesa_DeleteHashTable(ss->Programs); -#if FEATURE_ARB_vertex_program - _mesa_reference_vertprog(ctx, &ss->DefaultVertexProgram, NULL); -#endif -#if FEATURE_ARB_fragment_program - _mesa_reference_fragprog(ctx, &ss->DefaultFragmentProgram, NULL); -#endif -#if FEATURE_ATI_fragment_shader - if (ss->DefaultFragmentShader) - _mesa_delete_ati_fragment_shader(ctx, ss->DefaultFragmentShader); -#endif -#if FEATURE_ARB_vertex_buffer_object || FEATURE_ARB_pixel_buffer_object - if (ss->BufferObjects) - _mesa_DeleteHashTable(ss->BufferObjects); -#endif - - if (ss->ArrayObjects) - _mesa_DeleteHashTable (ss->ArrayObjects); - -#if FEATURE_ARB_shader_objects - if (ss->ShaderObjects) - _mesa_DeleteHashTable (ss->ShaderObjects); -#endif - -#if FEATURE_EXT_framebuffer_object - if (ss->FrameBuffers) - _mesa_DeleteHashTable(ss->FrameBuffers); - if (ss->RenderBuffers) - _mesa_DeleteHashTable(ss->RenderBuffers); -#endif - - if (ss->Default1D) - (*ctx->Driver.DeleteTexture)(ctx, ss->Default1D); - if (ss->Default2D) - (*ctx->Driver.DeleteTexture)(ctx, ss->Default2D); - if (ss->Default3D) - (*ctx->Driver.DeleteTexture)(ctx, ss->Default3D); - if (ss->DefaultCubeMap) - (*ctx->Driver.DeleteTexture)(ctx, ss->DefaultCubeMap); - if (ss->DefaultRect) - (*ctx->Driver.DeleteTexture)(ctx, ss->DefaultRect); - if (ss->Default1DArray) - (*ctx->Driver.DeleteTexture)(ctx, ss->Default1DArray); - if (ss->Default2DArray) - (*ctx->Driver.DeleteTexture)(ctx, ss->Default2DArray); - - _mesa_free(ss); - - return GL_FALSE; -} - - -/** - * Callback for deleting a display list. Called by _mesa_HashDeleteAll(). - */ -static void -delete_displaylist_cb(GLuint id, void *data, void *userData) -{ -#if FEATURE_dlist - struct gl_display_list *list = (struct gl_display_list *) data; - GLcontext *ctx = (GLcontext *) userData; - _mesa_delete_list(ctx, list); -#endif -} - -/** - * Callback for deleting a texture object. Called by _mesa_HashDeleteAll(). - */ -static void -delete_texture_cb(GLuint id, void *data, void *userData) -{ - struct gl_texture_object *texObj = (struct gl_texture_object *) data; - GLcontext *ctx = (GLcontext *) userData; - ctx->Driver.DeleteTexture(ctx, texObj); -} - -/** - * Callback for deleting a program object. Called by _mesa_HashDeleteAll(). - */ -static void -delete_program_cb(GLuint id, void *data, void *userData) -{ - struct gl_program *prog = (struct gl_program *) data; - GLcontext *ctx = (GLcontext *) userData; - ASSERT(prog->RefCount == 1); /* should only be referenced by hash table */ - prog->RefCount = 0; /* now going away */ - ctx->Driver.DeleteProgram(ctx, prog); -} - -#if FEATURE_ATI_fragment_shader -/** - * Callback for deleting an ATI fragment shader object. - * Called by _mesa_HashDeleteAll(). - */ -static void -delete_fragshader_cb(GLuint id, void *data, void *userData) -{ - struct ati_fragment_shader *shader = (struct ati_fragment_shader *) data; - GLcontext *ctx = (GLcontext *) userData; - _mesa_delete_ati_fragment_shader(ctx, shader); -} -#endif - -/** - * Callback for deleting a buffer object. Called by _mesa_HashDeleteAll(). - */ -static void -delete_bufferobj_cb(GLuint id, void *data, void *userData) -{ - struct gl_buffer_object *bufObj = (struct gl_buffer_object *) data; - GLcontext *ctx = (GLcontext *) userData; - ctx->Driver.DeleteBuffer(ctx, bufObj); -} - -/** - * Callback for deleting an array object. Called by _mesa_HashDeleteAll(). - */ -static void -delete_arrayobj_cb(GLuint id, void *data, void *userData) -{ - struct gl_array_object *arrayObj = (struct gl_array_object *) data; - GLcontext *ctx = (GLcontext *) userData; - _mesa_delete_array_object(ctx, arrayObj); -} - -/** - * Callback for freeing shader program data. Call it before delete_shader_cb - * to avoid memory access error. - */ -static void -free_shader_program_data_cb(GLuint id, void *data, void *userData) -{ - GLcontext *ctx = (GLcontext *) userData; - struct gl_shader_program *shProg = (struct gl_shader_program *) data; - - if (shProg->Type == GL_SHADER_PROGRAM_MESA) { - _mesa_free_shader_program_data(ctx, shProg); - } -} - -/** - * Callback for deleting shader and shader programs objects. - * Called by _mesa_HashDeleteAll(). - */ -static void -delete_shader_cb(GLuint id, void *data, void *userData) -{ - GLcontext *ctx = (GLcontext *) userData; - struct gl_shader *sh = (struct gl_shader *) data; - if (sh->Type == GL_FRAGMENT_SHADER || sh->Type == GL_VERTEX_SHADER) { - _mesa_free_shader(ctx, sh); - } - else { - struct gl_shader_program *shProg = (struct gl_shader_program *) data; - ASSERT(shProg->Type == GL_SHADER_PROGRAM_MESA); - _mesa_free_shader_program(ctx, shProg); - } -} - -/** - * Callback for deleting a framebuffer object. Called by _mesa_HashDeleteAll() - */ -static void -delete_framebuffer_cb(GLuint id, void *data, void *userData) -{ - struct gl_framebuffer *fb = (struct gl_framebuffer *) data; - /* The fact that the framebuffer is in the hashtable means its refcount - * is one, but we're removing from the hashtable now. So clear refcount. - */ - /*assert(fb->RefCount == 1);*/ - fb->RefCount = 0; - - /* NOTE: Delete should always be defined but there are two reports - * of it being NULL (bugs 13507, 14293). Work-around for now. - */ - if (fb->Delete) - fb->Delete(fb); -} - -/** - * Callback for deleting a renderbuffer object. Called by _mesa_HashDeleteAll() - */ -static void -delete_renderbuffer_cb(GLuint id, void *data, void *userData) -{ - struct gl_renderbuffer *rb = (struct gl_renderbuffer *) data; - rb->RefCount = 0; /* see comment for FBOs above */ - if (rb->Delete) - rb->Delete(rb); -} - - -/** - * Deallocate a shared state object and all children structures. - * - * \param ctx GL context. - * \param ss shared state pointer. - * - * Frees the display lists, the texture objects (calling the driver texture - * deletion callback to free its private data) and the vertex programs, as well - * as their hash tables. - * - * \sa alloc_shared_state(). - */ -static void -free_shared_state( GLcontext *ctx, struct gl_shared_state *ss ) -{ - /* - * Free display lists - */ - _mesa_HashDeleteAll(ss->DisplayList, delete_displaylist_cb, ctx); - _mesa_DeleteHashTable(ss->DisplayList); - -#if FEATURE_ARB_shader_objects - _mesa_HashWalk(ss->ShaderObjects, free_shader_program_data_cb, ctx); - _mesa_HashDeleteAll(ss->ShaderObjects, delete_shader_cb, ctx); - _mesa_DeleteHashTable(ss->ShaderObjects); -#endif - - _mesa_HashDeleteAll(ss->Programs, delete_program_cb, ctx); - _mesa_DeleteHashTable(ss->Programs); - -#if FEATURE_ARB_vertex_program - _mesa_reference_vertprog(ctx, &ss->DefaultVertexProgram, NULL); -#endif -#if FEATURE_ARB_fragment_program - _mesa_reference_fragprog(ctx, &ss->DefaultFragmentProgram, NULL); -#endif - -#if FEATURE_ATI_fragment_shader - _mesa_HashDeleteAll(ss->ATIShaders, delete_fragshader_cb, ctx); - _mesa_DeleteHashTable(ss->ATIShaders); - _mesa_delete_ati_fragment_shader(ctx, ss->DefaultFragmentShader); -#endif - -#if FEATURE_ARB_vertex_buffer_object || FEATURE_ARB_pixel_buffer_object - _mesa_HashDeleteAll(ss->BufferObjects, delete_bufferobj_cb, ctx); - _mesa_DeleteHashTable(ss->BufferObjects); -#endif - - _mesa_HashDeleteAll(ss->ArrayObjects, delete_arrayobj_cb, ctx); - _mesa_DeleteHashTable(ss->ArrayObjects); - -#if FEATURE_EXT_framebuffer_object - _mesa_HashDeleteAll(ss->FrameBuffers, delete_framebuffer_cb, ctx); - _mesa_DeleteHashTable(ss->FrameBuffers); - _mesa_HashDeleteAll(ss->RenderBuffers, delete_renderbuffer_cb, ctx); - _mesa_DeleteHashTable(ss->RenderBuffers); -#endif - - /* - * Free texture objects (after FBOs since some textures might have - * been bound to FBOs). - */ - ASSERT(ctx->Driver.DeleteTexture); - /* the default textures */ - ctx->Driver.DeleteTexture(ctx, ss->Default1D); - ctx->Driver.DeleteTexture(ctx, ss->Default2D); - ctx->Driver.DeleteTexture(ctx, ss->Default3D); - ctx->Driver.DeleteTexture(ctx, ss->DefaultCubeMap); - ctx->Driver.DeleteTexture(ctx, ss->DefaultRect); - ctx->Driver.DeleteTexture(ctx, ss->Default1DArray); - ctx->Driver.DeleteTexture(ctx, ss->Default2DArray); - /* all other textures */ - _mesa_HashDeleteAll(ss->TexObjects, delete_texture_cb, ctx); - _mesa_DeleteHashTable(ss->TexObjects); - - _glthread_DESTROY_MUTEX(ss->Mutex); - - _mesa_free(ss); + dummy_enum_func(); } @@ -863,6 +521,9 @@ _mesa_init_constants(GLcontext *ctx) assert(MAX_TEXTURE_LEVELS >= MAX_3D_TEXTURE_LEVELS); assert(MAX_TEXTURE_LEVELS >= MAX_CUBE_TEXTURE_LEVELS); + /* Max texture size should be <= max viewport size (render to texture) */ + assert((1 << (MAX_TEXTURE_LEVELS - 1)) <= MAX_WIDTH); + /* Constants, may be overriden (usually only reduced) by device drivers */ ctx->Const.MaxTextureLevels = MAX_TEXTURE_LEVELS; ctx->Const.Max3DTextureLevels = MAX_3D_TEXTURE_LEVELS; @@ -928,6 +589,9 @@ _mesa_init_constants(GLcontext *ctx) /* GL_ARB_framebuffer_object */ ctx->Const.MaxSamples = 0; + /* GL_ATI_envmap_bumpmap */ + ctx->Const.SupportedBumpUnits = SUPPORTED_ATI_BUMP_UNITS; + /* sanity checks */ ASSERT(ctx->Const.MaxTextureUnits == MIN2(ctx->Const.MaxTextureImageUnits, ctx->Const.MaxTextureCoordUnits)); @@ -959,13 +623,18 @@ check_context_limits(GLcontext *ctx) /* number of coord units cannot be greater than number of image units */ assert(ctx->Const.MaxTextureCoordUnits <= ctx->Const.MaxTextureImageUnits); - assert(ctx->Const.MaxViewportWidth <= MAX_WIDTH); - assert(ctx->Const.MaxViewportHeight <= MAX_WIDTH); + assert(ctx->Const.MaxTextureLevels <= MAX_TEXTURE_LEVELS); + assert(ctx->Const.Max3DTextureLevels <= MAX_3D_TEXTURE_LEVELS); + assert(ctx->Const.MaxCubeTextureLevels <= MAX_CUBE_TEXTURE_LEVELS); + assert(ctx->Const.MaxTextureRectSize <= MAX_TEXTURE_RECT_SIZE); /* make sure largest texture image is <= MAX_WIDTH in size */ - assert((1 << (ctx->Const.MaxTextureLevels -1 )) <= MAX_WIDTH); - assert((1 << (ctx->Const.MaxCubeTextureLevels -1 )) <= MAX_WIDTH); - assert((1 << (ctx->Const.Max3DTextureLevels -1 )) <= MAX_WIDTH); + assert((1 << (ctx->Const.MaxTextureLevels - 1)) <= MAX_WIDTH); + assert((1 << (ctx->Const.MaxCubeTextureLevels - 1)) <= MAX_WIDTH); + assert((1 << (ctx->Const.Max3DTextureLevels - 1)) <= MAX_WIDTH); + + assert(ctx->Const.MaxViewportWidth <= MAX_WIDTH); + assert(ctx->Const.MaxViewportHeight <= MAX_WIDTH); assert(ctx->Const.MaxDrawBuffers <= MAX_DRAW_BUFFERS); @@ -1159,6 +828,8 @@ _mesa_initialize_context(GLcontext *ctx, const struct dd_function_table *driverFunctions, void *driverContext) { + struct gl_shared_state *shared; + /*ASSERT(driverContext);*/ assert(driverFunctions->NewTextureObject); assert(driverFunctions->FreeTexImageData); @@ -1182,20 +853,22 @@ _mesa_initialize_context(GLcontext *ctx, if (share_list) { /* share state with another context */ - ctx->Shared = share_list->Shared; + shared = share_list->Shared; } else { /* allocate new, unshared state */ - if (!alloc_shared_state( ctx )) { + shared = _mesa_alloc_shared_state(ctx); + if (!shared) return GL_FALSE; - } } - _glthread_LOCK_MUTEX(ctx->Shared->Mutex); - ctx->Shared->RefCount++; - _glthread_UNLOCK_MUTEX(ctx->Shared->Mutex); + + _glthread_LOCK_MUTEX(shared->Mutex); + ctx->Shared = shared; + shared->RefCount++; + _glthread_UNLOCK_MUTEX(shared->Mutex); if (!init_attrib_groups( ctx )) { - free_shared_state(ctx, ctx->Shared); + _mesa_free_shared_state(ctx, ctx->Shared); return GL_FALSE; } @@ -1203,7 +876,7 @@ _mesa_initialize_context(GLcontext *ctx, ctx->Exec = alloc_dispatch_table(); ctx->Save = alloc_dispatch_table(); if (!ctx->Exec || !ctx->Save) { - free_shared_state(ctx, ctx->Shared); + _mesa_free_shared_state(ctx, ctx->Shared); if (ctx->Exec) _mesa_free(ctx->Exec); } @@ -1250,7 +923,7 @@ _mesa_initialize_context(GLcontext *ctx, * \param share_list another context to share display lists with or NULL * \param driverFunctions points to the dd_function_table into which the * driver has plugged in all its special functions. - * \param driverCtx points to the device driver's private context state + * \param driverContext points to the device driver's private context state * * \return pointer to a new __GLcontextRec or NULL if error. */ @@ -1290,6 +963,8 @@ _mesa_create_context(const GLvisual *visual, void _mesa_free_context_data( GLcontext *ctx ) { + GLint RefCount; + if (!_mesa_get_current_context()){ /* No current context, but we may need one in order to delete * texture objs, etc. So temporarily bind the context now. @@ -1341,12 +1016,12 @@ _mesa_free_context_data( GLcontext *ctx ) /* Shared context state (display lists, textures, etc) */ _glthread_LOCK_MUTEX(ctx->Shared->Mutex); - ctx->Shared->RefCount--; - assert(ctx->Shared->RefCount >= 0); + RefCount = --ctx->Shared->RefCount; _glthread_UNLOCK_MUTEX(ctx->Shared->Mutex); - if (ctx->Shared->RefCount == 0) { + assert(RefCount >= 0); + if (RefCount == 0) { /* free shared state */ - free_shared_state( ctx, ctx->Shared ); + _mesa_free_shared_state( ctx, ctx->Shared ); } if (ctx->Extensions.String) @@ -1730,7 +1405,7 @@ _mesa_share_state(GLcontext *ctx, GLcontext *ctxToShare) oldSharedState->RefCount--; if (oldSharedState->RefCount == 0) { - free_shared_state(ctx, oldSharedState); + _mesa_free_shared_state(ctx, oldSharedState); } return GL_TRUE; diff --git a/src/mesa/main/context.h b/src/mesa/main/context.h index 54f1af911d..ecc1cec779 100644 --- a/src/mesa/main/context.h +++ b/src/mesa/main/context.h @@ -49,11 +49,13 @@ #define CONTEXT_H -#include "glapi/glapi.h" #include "imports.h" #include "mtypes.h" +struct _glapi_table; + + /** \name Visual-related functions */ /*@{*/ diff --git a/src/mesa/main/cpuinfo.c b/src/mesa/main/cpuinfo.c new file mode 100644 index 0000000000..b4bfb40eb1 --- /dev/null +++ b/src/mesa/main/cpuinfo.c @@ -0,0 +1,109 @@ +/* + * Mesa 3-D graphics library + * Version: 7.5 + * + * Copyright (C) 2009 VMware, Inc. 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 "main/imports.h" +#include "main/cpuinfo.h" + + +/** + * This function should be called before the various "cpu_has_foo" macros + * are used. + */ +void +_mesa_get_cpu_features(void) +{ +#ifdef USE_X86_ASM + _mesa_get_x86_features(); +#endif +} + + +/** + * Return a string describing the CPU architexture and extensions that + * Mesa is using (such as SSE or Altivec). + * \return information string, free it with _mesa_free() + */ +char * +_mesa_get_cpu_string(void) +{ +#define MAX_STRING 50 + char *buffer; + + buffer = (char *) _mesa_malloc(MAX_STRING); + if (!buffer) + return NULL; + + buffer[0] = 0; + +#ifdef USE_X86_ASM + + if (_mesa_x86_cpu_features) { + strcat(buffer, "x86"); + } + +# ifdef USE_MMX_ASM + if (cpu_has_mmx) { + strcat(buffer, (cpu_has_mmxext) ? "/MMX+" : "/MMX"); + } +# endif +# ifdef USE_3DNOW_ASM + if (cpu_has_3dnow) { + strcat(buffer, (cpu_has_3dnowext) ? "/3DNow!+" : "/3DNow!"); + } +# endif +# ifdef USE_SSE_ASM + if (cpu_has_xmm) { + strcat(buffer, (cpu_has_xmm2) ? "/SSE2" : "/SSE"); + } +# endif + +#elif defined(USE_SPARC_ASM) + + strcat(buffer, "SPARC"); + +#elif defined(USE_PPC_ASM) + + if (_mesa_ppc_cpu_features) { + strcat(buffer, (cpu_has_64) ? "PowerPC 64" : "PowerPC"); + } + +# ifdef USE_VMX_ASM + + if (cpu_has_vmx) { + strcat(buffer, "/Altivec"); + } + +# endif + + if (! cpu_has_fpu) { + strcat(buffer, "/No FPU"); + } + +#endif + + assert(_mesa_strlen(buffer) < MAX_STRING); + + return buffer; +} diff --git a/src/mesa/main/cpuinfo.h b/src/mesa/main/cpuinfo.h new file mode 100644 index 0000000000..c41a90b075 --- /dev/null +++ b/src/mesa/main/cpuinfo.h @@ -0,0 +1,47 @@ +/* + * Mesa 3-D graphics library + * Version: 7.5 + * + * Copyright (C) 2009 VMware, Inc. 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. + */ + + +#ifndef CPUINFO_H +#define CPUINFO_H + + +#if defined(USE_X86_ASM) +#include "x86/common_x86_asm.h" +#endif + +#if defined(USE_PPC_ASM) +#include "ppc/common_ppc_features.h" +#endif + + +extern void +_mesa_get_cpu_features(void); + + +extern char * +_mesa_get_cpu_string(void); + + +#endif /* CPUINFO_H */ diff --git a/src/mesa/main/dd.h b/src/mesa/main/dd.h index 411b6a7b21..d994401e55 100644 --- a/src/mesa/main/dd.h +++ b/src/mesa/main/dd.h @@ -36,6 +36,22 @@ struct gl_pixelstore_attrib; struct gl_display_list; +#if FEATURE_ARB_vertex_buffer_object +/* Modifies GL_MAP_UNSYNCHRONIZED_BIT to allow driver to fail (return + * NULL) if buffer is unavailable for immediate mapping. + * + * Does GL_MAP_INVALIDATE_RANGE_BIT do this? It seems so, but it + * would require more book-keeping in the driver than seems necessary + * at this point. + * + * Does GL_MAP_INVALDIATE_BUFFER_BIT do this? Not really -- we don't + * want to provoke the driver to throw away the old storage, we will + * respect the contents of already referenced data. + */ +#define MESA_MAP_NOWAIT_BIT 0x0040 +#endif + + /** * Device driver function table. * Core Mesa uses these function pointers to call into device drivers. @@ -586,9 +602,6 @@ struct dd_function_table { /** Notify driver that a program string has been specified. */ void (*ProgramStringNotify)(GLcontext *ctx, GLenum target, struct gl_program *prog); - /** Get value of a program register during program execution. */ - void (*GetProgramRegister)(GLcontext *ctx, enum register_file file, - GLuint index, GLfloat val[4]); /** Query if program can be loaded onto hardware */ GLboolean (*IsProgramNative)(GLcontext *ctx, GLenum target, @@ -785,6 +798,16 @@ struct dd_function_table { void * (*MapBuffer)( GLcontext *ctx, GLenum target, GLenum access, struct gl_buffer_object *obj ); + /* May return NULL if MESA_MAP_NOWAIT_BIT is set in access: + */ + void * (*MapBufferRange)( GLcontext *ctx, GLenum target, + GLintptr offset, GLsizeiptr length, GLbitfield access, + struct gl_buffer_object *obj); + + void (*FlushMappedBufferRange) (GLcontext *ctx, GLenum target, + GLintptr offset, GLsizeiptr length, + struct gl_buffer_object *obj); + GLboolean (*UnmapBuffer)( GLcontext *ctx, GLenum target, struct gl_buffer_object *obj ); /*@}*/ @@ -954,6 +977,12 @@ struct dd_function_table { GLuint NeedFlush; GLuint SaveNeedFlush; + + /* Called prior to any of the GLvertexformat functions being + * called. Paired with Driver.FlushVertices(). + */ + void (*BeginVertices)( GLcontext *ctx ); + /** * If inside glBegin()/glEnd(), it should ASSERT(0). Otherwise, if * FLUSH_STORED_VERTICES bit in \p flags is set flushes any buffered diff --git a/src/mesa/main/debug.c b/src/mesa/main/debug.c index fcef093ac3..fdd10dd307 100644 --- a/src/mesa/main/debug.c +++ b/src/mesa/main/debug.c @@ -23,6 +23,7 @@ */ #include "mtypes.h" +#include "colormac.h" #include "context.h" #include "hash.h" #include "imports.h" @@ -274,6 +275,27 @@ write_texture_image(struct gl_texture_object *texObj) case MESA_FORMAT_ARGB8888: write_ppm(s, img->Data, img->Width, img->Height, 4, 2, 1, 0); break; + case MESA_FORMAT_RGB888: + write_ppm(s, img->Data, img->Width, img->Height, 3, 2, 1, 0); + break; + case MESA_FORMAT_RGB565: + { + GLubyte *buf2 = (GLubyte *) _mesa_malloc(img->Width * img->Height * 3); + GLint i; + for (i = 0; i < img->Width * img->Height; i++) { + GLint r, g, b; + GLushort s = ((GLushort *) img->Data)[i]; + r = UBYTE_TO_CHAN( ((s >> 8) & 0xf8) | ((s >> 13) & 0x7) ); + g = UBYTE_TO_CHAN( ((s >> 3) & 0xfc) | ((s >> 9) & 0x3) ); + b = UBYTE_TO_CHAN( ((s << 3) & 0xf8) | ((s >> 2) & 0x7) ); + buf2[i*3+1] = r; + buf2[i*3+2] = g; + buf2[i*3+3] = b; + } + write_ppm(s, buf2, img->Width, img->Height, 3, 2, 1, 0); + _mesa_free(buf2); + } + break; default: printf("XXXX unsupported mesa tex format %d in %s\n", img->TexFormat->MesaFormat, __FUNCTION__); diff --git a/src/mesa/main/dispatch.c b/src/mesa/main/dispatch.c index 34127cb248..bf1a013789 100644 --- a/src/mesa/main/dispatch.c +++ b/src/mesa/main/dispatch.c @@ -40,6 +40,7 @@ #ifndef GLX_USE_APPLEGL #include "main/glheader.h" +#include "main/compiler.h" #include "glapi/glapi.h" #include "glapi/glapitable.h" #include "glapi/glthread.h" diff --git a/src/mesa/main/dlist.c b/src/mesa/main/dlist.c index db1415bc06..8f7f703da9 100644 --- a/src/mesa/main/dlist.c +++ b/src/mesa/main/dlist.c @@ -33,6 +33,7 @@ #include "api_arrayelt.h" #include "api_loopback.h" #include "config.h" +#include "mfeatures.h" #include "attrib.h" #include "blend.h" #include "buffers.h" @@ -85,7 +86,6 @@ #endif #include "math/m_matrix.h" -#include "math/m_xform.h" #include "glapi/dispatch.h" @@ -320,6 +320,8 @@ typedef enum /* GL_ARB_draw_buffers */ OPCODE_DRAW_BUFFERS_ARB, /* GL_ATI_fragment_shader */ + OPCODE_TEX_BUMP_PARAMETER_ATI, + /* GL_ATI_fragment_shader */ OPCODE_BIND_FRAGMENT_SHADER_ATI, OPCODE_SET_FRAGMENT_SHADER_CONSTANTS_ATI, /* OpenGL 2.0 */ @@ -705,7 +707,7 @@ unpack_image(GLuint dimensions, GLsizei width, GLsizei height, GLsizei depth, /** * Allocate space for a display list instruction. * \param opcode the instruction opcode (OPCODE_* value) - * \param size instruction size in bytes, not counting opcode. + * \param bytes instruction size in bytes, not counting opcode. * \return pointer to the usable data area (not including the internal * opcode). */ @@ -4803,6 +4805,36 @@ save_DrawBuffersARB(GLsizei count, const GLenum * buffers) } } +static void GLAPIENTRY +save_TexBumpParameterfvATI(GLenum pname, const GLfloat *param) +{ + GET_CURRENT_CONTEXT(ctx); + Node *n; + + n = ALLOC_INSTRUCTION(ctx, OPCODE_TEX_BUMP_PARAMETER_ATI, 5); + if (n) { + n[1].ui = pname; + n[2].f = param[0]; + n[3].f = param[1]; + n[4].f = param[2]; + n[5].f = param[3]; + } + if (ctx->ExecuteFlag) { + CALL_TexBumpParameterfvATI(ctx->Exec, (pname, param)); + } +} + +static void GLAPIENTRY +save_TexBumpParameterivATI(GLenum pname, const GLint *param) +{ + GLfloat p[4]; + p[0] = INT_TO_FLOAT(param[0]); + p[1] = INT_TO_FLOAT(param[1]); + p[2] = INT_TO_FLOAT(param[2]); + p[3] = INT_TO_FLOAT(param[3]); + save_TexBumpParameterfvATI(pname, p); +} + #if FEATURE_ATI_fragment_shader static void GLAPIENTRY save_BindFragmentShaderATI(GLuint id) @@ -6505,6 +6537,16 @@ execute_list(GLcontext *ctx, GLuint list) n[9].i, n[10].e)); break; #endif + case OPCODE_TEX_BUMP_PARAMETER_ATI: + { + GLfloat values[4]; + GLuint i, pname = n[1].ui; + + for (i = 0; i < 4; i++) + values[i] = n[1 + i].f; + CALL_TexBumpParameterfvATI(ctx->Exec, (pname, values)); + } + break; #if FEATURE_ATI_fragment_shader case OPCODE_BIND_FRAGMENT_SHADER_ATI: CALL_BindFragmentShaderATI(ctx->Exec, (n[1].i)); @@ -8043,6 +8085,10 @@ _mesa_init_dlist_table(struct _glapi_table *table) SET_VertexAttribPointerNV(table, _mesa_VertexAttribPointerNV); #endif + /* 244. GL_ATI_envmap_bumpmap */ + SET_TexBumpParameterivATI(table, save_TexBumpParameterivATI); + SET_TexBumpParameterfvATI(table, save_TexBumpParameterfvATI); + /* 245. GL_ATI_fragment_shader */ #if FEATURE_ATI_fragment_shader SET_BindFragmentShaderATI(table, save_BindFragmentShaderATI); diff --git a/src/mesa/main/dlopen.c b/src/mesa/main/dlopen.c index 8bc83c094f..414cfad8e2 100644 --- a/src/mesa/main/dlopen.c +++ b/src/mesa/main/dlopen.c @@ -28,13 +28,15 @@ */ -#include "glheader.h" -#include "imports.h" +#include "compiler.h" #include "dlopen.h" #if defined(_GNU_SOURCE) && !defined(__MINGW32__) #include <dlfcn.h> #endif +#if defined(_WIN32) +#include <windows.h> +#endif /** diff --git a/src/mesa/main/drawpix.c b/src/mesa/main/drawpix.c index 13cfa0e756..e9de0c097a 100644 --- a/src/mesa/main/drawpix.c +++ b/src/mesa/main/drawpix.c @@ -103,7 +103,7 @@ _mesa_DrawPixels( GLsizei width, GLsizei height, else if (ctx->RenderMode == GL_FEEDBACK) { /* Feedback the current raster pos info */ FLUSH_CURRENT( ctx, 0 ); - FEEDBACK_TOKEN( ctx, (GLfloat) (GLint) GL_DRAW_PIXEL_TOKEN ); + _mesa_feedback_token( ctx, (GLfloat) (GLint) GL_DRAW_PIXEL_TOKEN ); _mesa_feedback_vertex( ctx, ctx->Current.RasterPos, ctx->Current.RasterColor, @@ -166,7 +166,7 @@ _mesa_CopyPixels( GLint srcx, GLint srcy, GLsizei width, GLsizei height, } else if (ctx->RenderMode == GL_FEEDBACK) { FLUSH_CURRENT( ctx, 0 ); - FEEDBACK_TOKEN( ctx, (GLfloat) (GLint) GL_COPY_PIXEL_TOKEN ); + _mesa_feedback_token( ctx, (GLfloat) (GLint) GL_COPY_PIXEL_TOKEN ); _mesa_feedback_vertex( ctx, ctx->Current.RasterPos, ctx->Current.RasterColor, @@ -243,7 +243,7 @@ _mesa_Bitmap( GLsizei width, GLsizei height, #if _HAVE_FULL_GL else if (ctx->RenderMode == GL_FEEDBACK) { FLUSH_CURRENT(ctx, 0); - FEEDBACK_TOKEN( ctx, (GLfloat) (GLint) GL_BITMAP_TOKEN ); + _mesa_feedback_token( ctx, (GLfloat) (GLint) GL_BITMAP_TOKEN ); _mesa_feedback_vertex( ctx, ctx->Current.RasterPos, ctx->Current.RasterColor, @@ -311,7 +311,7 @@ _mesa_DrawDepthPixelsMESA( GLsizei width, GLsizei height, else if (ctx->RenderMode == GL_FEEDBACK) { /* Feedback the current raster pos info */ FLUSH_CURRENT( ctx, 0 ); - FEEDBACK_TOKEN( ctx, (GLfloat) (GLint) GL_DRAW_PIXEL_TOKEN ); + _mesa_feedback_token( ctx, (GLfloat) (GLint) GL_DRAW_PIXEL_TOKEN ); _mesa_feedback_vertex( ctx, ctx->Current.RasterPos, ctx->Current.RasterColor, diff --git a/src/mesa/main/enable.c b/src/mesa/main/enable.c index 2b54fac694..f432be183c 100644 --- a/src/mesa/main/enable.c +++ b/src/mesa/main/enable.c @@ -37,7 +37,6 @@ #include "mtypes.h" #include "enums.h" #include "math/m_matrix.h" -#include "math/m_xform.h" #include "api_arrayelt.h" @@ -603,11 +602,6 @@ _mesa_set_enable(GLcontext *ctx, GLenum cap, GLboolean state) ctx->Texture.SharedPalette = state; break; case GL_STENCIL_TEST: - if (state && ctx->DrawBuffer->Visual.stencilBits == 0) { - _mesa_warning(ctx, - "glEnable(GL_STENCIL_TEST) but no stencil buffer"); - return; - } if (ctx->Stencil.Enabled == state) return; FLUSH_VERTICES(ctx, _NEW_STENCIL); @@ -950,18 +944,6 @@ _mesa_set_enable(GLcontext *ctx, GLenum cap, GLboolean state) ctx->Depth.BoundsTest = state; break; - /* GL_MESA_program_debug */ -#if FEATURE_MESA_program_debug - case GL_FRAGMENT_PROGRAM_CALLBACK_MESA: - CHECK_EXTENSION(MESA_program_debug, cap); - ctx->FragmentProgram.CallbackEnabled = state; - break; - case GL_VERTEX_PROGRAM_CALLBACK_MESA: - CHECK_EXTENSION(MESA_program_debug, cap); - ctx->VertexProgram.CallbackEnabled = state; - break; -#endif - #if FEATURE_ATI_fragment_shader case GL_FRAGMENT_SHADER_ATI: CHECK_EXTENSION(ATI_fragment_shader, cap); @@ -1404,16 +1386,6 @@ _mesa_IsEnabled( GLenum cap ) CHECK_EXTENSION(EXT_depth_bounds_test); return ctx->Depth.BoundsTest; - /* GL_MESA_program_debug */ -#if FEATURE_MESA_program_debug - case GL_FRAGMENT_PROGRAM_CALLBACK_MESA: - CHECK_EXTENSION(MESA_program_debug); - return ctx->FragmentProgram.CallbackEnabled; - case GL_VERTEX_PROGRAM_CALLBACK_MESA: - CHECK_EXTENSION(MESA_program_debug); - return ctx->VertexProgram.CallbackEnabled; -#endif - #if FEATURE_ATI_fragment_shader case GL_FRAGMENT_SHADER_ATI: CHECK_EXTENSION(ATI_fragment_shader); diff --git a/src/mesa/main/enums.c b/src/mesa/main/enums.c index a864f5a070..e63a04e915 100644 --- a/src/mesa/main/enums.c +++ b/src/mesa/main/enums.c @@ -26,6 +26,7 @@ */ #include "glheader.h" +#include "mfeatures.h" #include "enums.h" #include "imports.h" @@ -145,6 +146,12 @@ LONGSTRING static const char enum_string_table[] = "GL_BUFFER_SIZE_ARB\0" "GL_BUFFER_USAGE\0" "GL_BUFFER_USAGE_ARB\0" + "GL_BUMP_ENVMAP_ATI\0" + "GL_BUMP_NUM_TEX_UNITS_ATI\0" + "GL_BUMP_ROT_MATRIX_ATI\0" + "GL_BUMP_ROT_MATRIX_SIZE_ATI\0" + "GL_BUMP_TARGET_ATI\0" + "GL_BUMP_TEX_UNITS_ATI\0" "GL_BYTE\0" "GL_C3F_V3F\0" "GL_C4F_N3F_V3F\0" @@ -463,6 +470,8 @@ LONGSTRING static const char enum_string_table[] = "GL_DRAW_PIXEL_TOKEN\0" "GL_DST_ALPHA\0" "GL_DST_COLOR\0" + "GL_DU8DV8_ATI\0" + "GL_DUDV_ATI\0" "GL_DYNAMIC_COPY\0" "GL_DYNAMIC_COPY_ARB\0" "GL_DYNAMIC_DRAW\0" @@ -1847,7 +1856,7 @@ LONGSTRING static const char enum_string_table[] = "GL_ZOOM_Y\0" ; -static const enum_elt all_enums[1810] = +static const enum_elt all_enums[1818] = { { 0, 0x00000600 }, /* GL_2D */ { 6, 0x00001407 }, /* GL_2_BYTES */ @@ -1959,3022 +1968,3036 @@ static const enum_elt all_enums[1810] = { 1766, 0x00008764 }, /* GL_BUFFER_SIZE_ARB */ { 1785, 0x00008765 }, /* GL_BUFFER_USAGE */ { 1801, 0x00008765 }, /* GL_BUFFER_USAGE_ARB */ - { 1821, 0x00001400 }, /* GL_BYTE */ - { 1829, 0x00002A24 }, /* GL_C3F_V3F */ - { 1840, 0x00002A26 }, /* GL_C4F_N3F_V3F */ - { 1855, 0x00002A22 }, /* GL_C4UB_V2F */ - { 1867, 0x00002A23 }, /* GL_C4UB_V3F */ - { 1879, 0x00000901 }, /* GL_CCW */ - { 1886, 0x00002900 }, /* GL_CLAMP */ - { 1895, 0x0000812D }, /* GL_CLAMP_TO_BORDER */ - { 1914, 0x0000812D }, /* GL_CLAMP_TO_BORDER_ARB */ - { 1937, 0x0000812D }, /* GL_CLAMP_TO_BORDER_SGIS */ - { 1961, 0x0000812F }, /* GL_CLAMP_TO_EDGE */ - { 1978, 0x0000812F }, /* GL_CLAMP_TO_EDGE_SGIS */ - { 2000, 0x00001500 }, /* GL_CLEAR */ - { 2009, 0x000084E1 }, /* GL_CLIENT_ACTIVE_TEXTURE */ - { 2034, 0x000084E1 }, /* GL_CLIENT_ACTIVE_TEXTURE_ARB */ - { 2063, 0xFFFFFFFF }, /* GL_CLIENT_ALL_ATTRIB_BITS */ - { 2089, 0x00000BB1 }, /* GL_CLIENT_ATTRIB_STACK_DEPTH */ - { 2118, 0x00000001 }, /* GL_CLIENT_PIXEL_STORE_BIT */ - { 2144, 0x00000002 }, /* GL_CLIENT_VERTEX_ARRAY_BIT */ - { 2171, 0x00003000 }, /* GL_CLIP_PLANE0 */ - { 2186, 0x00003001 }, /* GL_CLIP_PLANE1 */ - { 2201, 0x00003002 }, /* GL_CLIP_PLANE2 */ - { 2216, 0x00003003 }, /* GL_CLIP_PLANE3 */ - { 2231, 0x00003004 }, /* GL_CLIP_PLANE4 */ - { 2246, 0x00003005 }, /* GL_CLIP_PLANE5 */ - { 2261, 0x000080F0 }, /* GL_CLIP_VOLUME_CLIPPING_HINT_EXT */ - { 2294, 0x00000A00 }, /* GL_COEFF */ - { 2303, 0x00001800 }, /* GL_COLOR */ - { 2312, 0x00008076 }, /* GL_COLOR_ARRAY */ - { 2327, 0x00008898 }, /* GL_COLOR_ARRAY_BUFFER_BINDING */ - { 2357, 0x00008898 }, /* GL_COLOR_ARRAY_BUFFER_BINDING_ARB */ - { 2391, 0x00008090 }, /* GL_COLOR_ARRAY_POINTER */ - { 2414, 0x00008081 }, /* GL_COLOR_ARRAY_SIZE */ - { 2434, 0x00008083 }, /* GL_COLOR_ARRAY_STRIDE */ - { 2456, 0x00008082 }, /* GL_COLOR_ARRAY_TYPE */ - { 2476, 0x00008CE0 }, /* GL_COLOR_ATTACHMENT0 */ - { 2497, 0x00008CE0 }, /* GL_COLOR_ATTACHMENT0_EXT */ - { 2522, 0x00008CE1 }, /* GL_COLOR_ATTACHMENT1 */ - { 2543, 0x00008CEA }, /* GL_COLOR_ATTACHMENT10 */ - { 2565, 0x00008CEA }, /* GL_COLOR_ATTACHMENT10_EXT */ - { 2591, 0x00008CEB }, /* GL_COLOR_ATTACHMENT11 */ - { 2613, 0x00008CEB }, /* GL_COLOR_ATTACHMENT11_EXT */ - { 2639, 0x00008CEC }, /* GL_COLOR_ATTACHMENT12 */ - { 2661, 0x00008CEC }, /* GL_COLOR_ATTACHMENT12_EXT */ - { 2687, 0x00008CED }, /* GL_COLOR_ATTACHMENT13 */ - { 2709, 0x00008CED }, /* GL_COLOR_ATTACHMENT13_EXT */ - { 2735, 0x00008CEE }, /* GL_COLOR_ATTACHMENT14 */ - { 2757, 0x00008CEE }, /* GL_COLOR_ATTACHMENT14_EXT */ - { 2783, 0x00008CEF }, /* GL_COLOR_ATTACHMENT15 */ - { 2805, 0x00008CEF }, /* GL_COLOR_ATTACHMENT15_EXT */ - { 2831, 0x00008CE1 }, /* GL_COLOR_ATTACHMENT1_EXT */ - { 2856, 0x00008CE2 }, /* GL_COLOR_ATTACHMENT2 */ - { 2877, 0x00008CE2 }, /* GL_COLOR_ATTACHMENT2_EXT */ - { 2902, 0x00008CE3 }, /* GL_COLOR_ATTACHMENT3 */ - { 2923, 0x00008CE3 }, /* GL_COLOR_ATTACHMENT3_EXT */ - { 2948, 0x00008CE4 }, /* GL_COLOR_ATTACHMENT4 */ - { 2969, 0x00008CE4 }, /* GL_COLOR_ATTACHMENT4_EXT */ - { 2994, 0x00008CE5 }, /* GL_COLOR_ATTACHMENT5 */ - { 3015, 0x00008CE5 }, /* GL_COLOR_ATTACHMENT5_EXT */ - { 3040, 0x00008CE6 }, /* GL_COLOR_ATTACHMENT6 */ - { 3061, 0x00008CE6 }, /* GL_COLOR_ATTACHMENT6_EXT */ - { 3086, 0x00008CE7 }, /* GL_COLOR_ATTACHMENT7 */ - { 3107, 0x00008CE7 }, /* GL_COLOR_ATTACHMENT7_EXT */ - { 3132, 0x00008CE8 }, /* GL_COLOR_ATTACHMENT8 */ - { 3153, 0x00008CE8 }, /* GL_COLOR_ATTACHMENT8_EXT */ - { 3178, 0x00008CE9 }, /* GL_COLOR_ATTACHMENT9 */ - { 3199, 0x00008CE9 }, /* GL_COLOR_ATTACHMENT9_EXT */ - { 3224, 0x00004000 }, /* GL_COLOR_BUFFER_BIT */ - { 3244, 0x00000C22 }, /* GL_COLOR_CLEAR_VALUE */ - { 3265, 0x00001900 }, /* GL_COLOR_INDEX */ - { 3280, 0x00001603 }, /* GL_COLOR_INDEXES */ - { 3297, 0x00000BF2 }, /* GL_COLOR_LOGIC_OP */ - { 3315, 0x00000B57 }, /* GL_COLOR_MATERIAL */ - { 3333, 0x00000B55 }, /* GL_COLOR_MATERIAL_FACE */ - { 3356, 0x00000B56 }, /* GL_COLOR_MATERIAL_PARAMETER */ - { 3384, 0x000080B1 }, /* GL_COLOR_MATRIX */ - { 3400, 0x000080B1 }, /* GL_COLOR_MATRIX_SGI */ - { 3420, 0x000080B2 }, /* GL_COLOR_MATRIX_STACK_DEPTH */ - { 3448, 0x000080B2 }, /* GL_COLOR_MATRIX_STACK_DEPTH_SGI */ - { 3480, 0x00008458 }, /* GL_COLOR_SUM */ - { 3493, 0x00008458 }, /* GL_COLOR_SUM_ARB */ - { 3510, 0x000080D0 }, /* GL_COLOR_TABLE */ - { 3525, 0x000080DD }, /* GL_COLOR_TABLE_ALPHA_SIZE */ - { 3551, 0x000080DD }, /* GL_COLOR_TABLE_ALPHA_SIZE_EXT */ - { 3581, 0x000080DD }, /* GL_COLOR_TABLE_ALPHA_SIZE_SGI */ - { 3611, 0x000080D7 }, /* GL_COLOR_TABLE_BIAS */ - { 3631, 0x000080D7 }, /* GL_COLOR_TABLE_BIAS_SGI */ - { 3655, 0x000080DC }, /* GL_COLOR_TABLE_BLUE_SIZE */ - { 3680, 0x000080DC }, /* GL_COLOR_TABLE_BLUE_SIZE_EXT */ - { 3709, 0x000080DC }, /* GL_COLOR_TABLE_BLUE_SIZE_SGI */ - { 3738, 0x000080D8 }, /* GL_COLOR_TABLE_FORMAT */ - { 3760, 0x000080D8 }, /* GL_COLOR_TABLE_FORMAT_EXT */ - { 3786, 0x000080D8 }, /* GL_COLOR_TABLE_FORMAT_SGI */ - { 3812, 0x000080DB }, /* GL_COLOR_TABLE_GREEN_SIZE */ - { 3838, 0x000080DB }, /* GL_COLOR_TABLE_GREEN_SIZE_EXT */ - { 3868, 0x000080DB }, /* GL_COLOR_TABLE_GREEN_SIZE_SGI */ - { 3898, 0x000080DF }, /* GL_COLOR_TABLE_INTENSITY_SIZE */ - { 3928, 0x000080DF }, /* GL_COLOR_TABLE_INTENSITY_SIZE_EXT */ - { 3962, 0x000080DF }, /* GL_COLOR_TABLE_INTENSITY_SIZE_SGI */ - { 3996, 0x000080DE }, /* GL_COLOR_TABLE_LUMINANCE_SIZE */ - { 4026, 0x000080DE }, /* GL_COLOR_TABLE_LUMINANCE_SIZE_EXT */ - { 4060, 0x000080DE }, /* GL_COLOR_TABLE_LUMINANCE_SIZE_SGI */ - { 4094, 0x000080DA }, /* GL_COLOR_TABLE_RED_SIZE */ - { 4118, 0x000080DA }, /* GL_COLOR_TABLE_RED_SIZE_EXT */ - { 4146, 0x000080DA }, /* GL_COLOR_TABLE_RED_SIZE_SGI */ - { 4174, 0x000080D6 }, /* GL_COLOR_TABLE_SCALE */ - { 4195, 0x000080D6 }, /* GL_COLOR_TABLE_SCALE_SGI */ - { 4220, 0x000080D9 }, /* GL_COLOR_TABLE_WIDTH */ - { 4241, 0x000080D9 }, /* GL_COLOR_TABLE_WIDTH_EXT */ - { 4266, 0x000080D9 }, /* GL_COLOR_TABLE_WIDTH_SGI */ - { 4291, 0x00000C23 }, /* GL_COLOR_WRITEMASK */ - { 4310, 0x00008570 }, /* GL_COMBINE */ - { 4321, 0x00008503 }, /* GL_COMBINE4 */ - { 4333, 0x00008572 }, /* GL_COMBINE_ALPHA */ - { 4350, 0x00008572 }, /* GL_COMBINE_ALPHA_ARB */ - { 4371, 0x00008572 }, /* GL_COMBINE_ALPHA_EXT */ - { 4392, 0x00008570 }, /* GL_COMBINE_ARB */ - { 4407, 0x00008570 }, /* GL_COMBINE_EXT */ - { 4422, 0x00008571 }, /* GL_COMBINE_RGB */ - { 4437, 0x00008571 }, /* GL_COMBINE_RGB_ARB */ - { 4456, 0x00008571 }, /* GL_COMBINE_RGB_EXT */ - { 4475, 0x0000884E }, /* GL_COMPARE_REF_DEPTH_TO_TEXTURE_EXT */ - { 4511, 0x0000884E }, /* GL_COMPARE_R_TO_TEXTURE */ - { 4535, 0x0000884E }, /* GL_COMPARE_R_TO_TEXTURE_ARB */ - { 4563, 0x00001300 }, /* GL_COMPILE */ - { 4574, 0x00001301 }, /* GL_COMPILE_AND_EXECUTE */ - { 4597, 0x00008B81 }, /* GL_COMPILE_STATUS */ - { 4615, 0x000084E9 }, /* GL_COMPRESSED_ALPHA */ - { 4635, 0x000084E9 }, /* GL_COMPRESSED_ALPHA_ARB */ - { 4659, 0x000084EC }, /* GL_COMPRESSED_INTENSITY */ - { 4683, 0x000084EC }, /* GL_COMPRESSED_INTENSITY_ARB */ - { 4711, 0x000084EA }, /* GL_COMPRESSED_LUMINANCE */ - { 4735, 0x000084EB }, /* GL_COMPRESSED_LUMINANCE_ALPHA */ - { 4765, 0x000084EB }, /* GL_COMPRESSED_LUMINANCE_ALPHA_ARB */ - { 4799, 0x000084EA }, /* GL_COMPRESSED_LUMINANCE_ARB */ - { 4827, 0x000084ED }, /* GL_COMPRESSED_RGB */ - { 4845, 0x000084EE }, /* GL_COMPRESSED_RGBA */ - { 4864, 0x000084EE }, /* GL_COMPRESSED_RGBA_ARB */ - { 4887, 0x000086B1 }, /* GL_COMPRESSED_RGBA_FXT1_3DFX */ - { 4916, 0x000083F1 }, /* GL_COMPRESSED_RGBA_S3TC_DXT1_EXT */ - { 4949, 0x000083F2 }, /* GL_COMPRESSED_RGBA_S3TC_DXT3_EXT */ - { 4982, 0x000083F3 }, /* GL_COMPRESSED_RGBA_S3TC_DXT5_EXT */ - { 5015, 0x000084ED }, /* GL_COMPRESSED_RGB_ARB */ - { 5037, 0x000086B0 }, /* GL_COMPRESSED_RGB_FXT1_3DFX */ - { 5065, 0x000083F0 }, /* GL_COMPRESSED_RGB_S3TC_DXT1_EXT */ - { 5097, 0x000086A3 }, /* GL_COMPRESSED_TEXTURE_FORMATS */ - { 5127, 0x00008576 }, /* GL_CONSTANT */ - { 5139, 0x00008003 }, /* GL_CONSTANT_ALPHA */ - { 5157, 0x00008003 }, /* GL_CONSTANT_ALPHA_EXT */ - { 5179, 0x00008576 }, /* GL_CONSTANT_ARB */ - { 5195, 0x00001207 }, /* GL_CONSTANT_ATTENUATION */ - { 5219, 0x00008151 }, /* GL_CONSTANT_BORDER_HP */ - { 5241, 0x00008001 }, /* GL_CONSTANT_COLOR */ - { 5259, 0x00008001 }, /* GL_CONSTANT_COLOR_EXT */ - { 5281, 0x00008576 }, /* GL_CONSTANT_EXT */ - { 5297, 0x00008010 }, /* GL_CONVOLUTION_1D */ - { 5315, 0x00008011 }, /* GL_CONVOLUTION_2D */ - { 5333, 0x00008154 }, /* GL_CONVOLUTION_BORDER_COLOR */ - { 5361, 0x00008154 }, /* GL_CONVOLUTION_BORDER_COLOR_HP */ - { 5392, 0x00008013 }, /* GL_CONVOLUTION_BORDER_MODE */ - { 5419, 0x00008013 }, /* GL_CONVOLUTION_BORDER_MODE_EXT */ - { 5450, 0x00008015 }, /* GL_CONVOLUTION_FILTER_BIAS */ - { 5477, 0x00008015 }, /* GL_CONVOLUTION_FILTER_BIAS_EXT */ - { 5508, 0x00008014 }, /* GL_CONVOLUTION_FILTER_SCALE */ - { 5536, 0x00008014 }, /* GL_CONVOLUTION_FILTER_SCALE_EXT */ - { 5568, 0x00008017 }, /* GL_CONVOLUTION_FORMAT */ - { 5590, 0x00008017 }, /* GL_CONVOLUTION_FORMAT_EXT */ - { 5616, 0x00008019 }, /* GL_CONVOLUTION_HEIGHT */ - { 5638, 0x00008019 }, /* GL_CONVOLUTION_HEIGHT_EXT */ - { 5664, 0x00008018 }, /* GL_CONVOLUTION_WIDTH */ - { 5685, 0x00008018 }, /* GL_CONVOLUTION_WIDTH_EXT */ - { 5710, 0x00008862 }, /* GL_COORD_REPLACE */ - { 5727, 0x00008862 }, /* GL_COORD_REPLACE_ARB */ - { 5748, 0x00008862 }, /* GL_COORD_REPLACE_NV */ - { 5768, 0x00001503 }, /* GL_COPY */ - { 5776, 0x0000150C }, /* GL_COPY_INVERTED */ - { 5793, 0x00000706 }, /* GL_COPY_PIXEL_TOKEN */ - { 5813, 0x00000B44 }, /* GL_CULL_FACE */ - { 5826, 0x00000B45 }, /* GL_CULL_FACE_MODE */ - { 5844, 0x000081AA }, /* GL_CULL_VERTEX_EXT */ - { 5863, 0x000081AC }, /* GL_CULL_VERTEX_EYE_POSITION_EXT */ - { 5895, 0x000081AB }, /* GL_CULL_VERTEX_OBJECT_POSITION_EXT */ - { 5930, 0x00008626 }, /* GL_CURRENT_ATTRIB_NV */ - { 5951, 0x00000001 }, /* GL_CURRENT_BIT */ - { 5966, 0x00000B00 }, /* GL_CURRENT_COLOR */ - { 5983, 0x00008453 }, /* GL_CURRENT_FOG_COORD */ - { 6004, 0x00008453 }, /* GL_CURRENT_FOG_COORDINATE */ - { 6030, 0x00000B01 }, /* GL_CURRENT_INDEX */ - { 6047, 0x00008641 }, /* GL_CURRENT_MATRIX_ARB */ - { 6069, 0x00008845 }, /* GL_CURRENT_MATRIX_INDEX_ARB */ - { 6097, 0x00008641 }, /* GL_CURRENT_MATRIX_NV */ - { 6118, 0x00008640 }, /* GL_CURRENT_MATRIX_STACK_DEPTH_ARB */ - { 6152, 0x00008640 }, /* GL_CURRENT_MATRIX_STACK_DEPTH_NV */ - { 6185, 0x00000B02 }, /* GL_CURRENT_NORMAL */ - { 6203, 0x00008843 }, /* GL_CURRENT_PALETTE_MATRIX_ARB */ - { 6233, 0x00008B8D }, /* GL_CURRENT_PROGRAM */ - { 6252, 0x00008865 }, /* GL_CURRENT_QUERY */ - { 6269, 0x00008865 }, /* GL_CURRENT_QUERY_ARB */ - { 6290, 0x00000B04 }, /* GL_CURRENT_RASTER_COLOR */ - { 6314, 0x00000B09 }, /* GL_CURRENT_RASTER_DISTANCE */ - { 6341, 0x00000B05 }, /* GL_CURRENT_RASTER_INDEX */ - { 6365, 0x00000B07 }, /* GL_CURRENT_RASTER_POSITION */ - { 6392, 0x00000B08 }, /* GL_CURRENT_RASTER_POSITION_VALID */ - { 6425, 0x00000B06 }, /* GL_CURRENT_RASTER_TEXTURE_COORDS */ - { 6458, 0x00008459 }, /* GL_CURRENT_SECONDARY_COLOR */ - { 6485, 0x00000B03 }, /* GL_CURRENT_TEXTURE_COORDS */ - { 6511, 0x00008626 }, /* GL_CURRENT_VERTEX_ATTRIB */ - { 6536, 0x00008626 }, /* GL_CURRENT_VERTEX_ATTRIB_ARB */ - { 6565, 0x000086A8 }, /* GL_CURRENT_WEIGHT_ARB */ - { 6587, 0x00000900 }, /* GL_CW */ - { 6593, 0x0000875B }, /* GL_DEBUG_ASSERT_MESA */ - { 6614, 0x00008759 }, /* GL_DEBUG_OBJECT_MESA */ - { 6635, 0x0000875A }, /* GL_DEBUG_PRINT_MESA */ - { 6655, 0x00002101 }, /* GL_DECAL */ - { 6664, 0x00001E03 }, /* GL_DECR */ - { 6672, 0x00008508 }, /* GL_DECR_WRAP */ - { 6685, 0x00008508 }, /* GL_DECR_WRAP_EXT */ - { 6702, 0x00008B80 }, /* GL_DELETE_STATUS */ - { 6719, 0x00001801 }, /* GL_DEPTH */ - { 6728, 0x000088F0 }, /* GL_DEPTH24_STENCIL8 */ - { 6748, 0x00008D00 }, /* GL_DEPTH_ATTACHMENT */ - { 6768, 0x00008D00 }, /* GL_DEPTH_ATTACHMENT_EXT */ - { 6792, 0x00000D1F }, /* GL_DEPTH_BIAS */ - { 6806, 0x00000D56 }, /* GL_DEPTH_BITS */ - { 6820, 0x00008891 }, /* GL_DEPTH_BOUNDS_EXT */ - { 6840, 0x00008890 }, /* GL_DEPTH_BOUNDS_TEST_EXT */ - { 6865, 0x00000100 }, /* GL_DEPTH_BUFFER_BIT */ - { 6885, 0x0000864F }, /* GL_DEPTH_CLAMP_NV */ - { 6903, 0x00000B73 }, /* GL_DEPTH_CLEAR_VALUE */ - { 6924, 0x00001902 }, /* GL_DEPTH_COMPONENT */ - { 6943, 0x000081A5 }, /* GL_DEPTH_COMPONENT16 */ - { 6964, 0x000081A5 }, /* GL_DEPTH_COMPONENT16_ARB */ - { 6989, 0x000081A5 }, /* GL_DEPTH_COMPONENT16_SGIX */ - { 7015, 0x000081A6 }, /* GL_DEPTH_COMPONENT24 */ - { 7036, 0x000081A6 }, /* GL_DEPTH_COMPONENT24_ARB */ - { 7061, 0x000081A6 }, /* GL_DEPTH_COMPONENT24_SGIX */ - { 7087, 0x000081A7 }, /* GL_DEPTH_COMPONENT32 */ - { 7108, 0x000081A7 }, /* GL_DEPTH_COMPONENT32_ARB */ - { 7133, 0x000081A7 }, /* GL_DEPTH_COMPONENT32_SGIX */ - { 7159, 0x00000B74 }, /* GL_DEPTH_FUNC */ - { 7173, 0x00000B70 }, /* GL_DEPTH_RANGE */ - { 7188, 0x00000D1E }, /* GL_DEPTH_SCALE */ - { 7203, 0x000084F9 }, /* GL_DEPTH_STENCIL */ - { 7220, 0x0000821A }, /* GL_DEPTH_STENCIL_ATTACHMENT */ - { 7248, 0x000084F9 }, /* GL_DEPTH_STENCIL_NV */ - { 7268, 0x0000886F }, /* GL_DEPTH_STENCIL_TO_BGRA_NV */ - { 7296, 0x0000886E }, /* GL_DEPTH_STENCIL_TO_RGBA_NV */ - { 7324, 0x00000B71 }, /* GL_DEPTH_TEST */ - { 7338, 0x0000884B }, /* GL_DEPTH_TEXTURE_MODE */ - { 7360, 0x0000884B }, /* GL_DEPTH_TEXTURE_MODE_ARB */ - { 7386, 0x00000B72 }, /* GL_DEPTH_WRITEMASK */ - { 7405, 0x00001201 }, /* GL_DIFFUSE */ - { 7416, 0x00000BD0 }, /* GL_DITHER */ - { 7426, 0x00000A02 }, /* GL_DOMAIN */ - { 7436, 0x00001100 }, /* GL_DONT_CARE */ - { 7449, 0x000086AE }, /* GL_DOT3_RGB */ - { 7461, 0x000086AF }, /* GL_DOT3_RGBA */ - { 7474, 0x000086AF }, /* GL_DOT3_RGBA_ARB */ - { 7491, 0x00008741 }, /* GL_DOT3_RGBA_EXT */ - { 7508, 0x000086AE }, /* GL_DOT3_RGB_ARB */ - { 7524, 0x00008740 }, /* GL_DOT3_RGB_EXT */ - { 7540, 0x0000140A }, /* GL_DOUBLE */ - { 7550, 0x00000C32 }, /* GL_DOUBLEBUFFER */ - { 7566, 0x00000C01 }, /* GL_DRAW_BUFFER */ - { 7581, 0x00008825 }, /* GL_DRAW_BUFFER0 */ - { 7597, 0x00008825 }, /* GL_DRAW_BUFFER0_ARB */ - { 7617, 0x00008825 }, /* GL_DRAW_BUFFER0_ATI */ - { 7637, 0x00008826 }, /* GL_DRAW_BUFFER1 */ - { 7653, 0x0000882F }, /* GL_DRAW_BUFFER10 */ - { 7670, 0x0000882F }, /* GL_DRAW_BUFFER10_ARB */ - { 7691, 0x0000882F }, /* GL_DRAW_BUFFER10_ATI */ - { 7712, 0x00008830 }, /* GL_DRAW_BUFFER11 */ - { 7729, 0x00008830 }, /* GL_DRAW_BUFFER11_ARB */ - { 7750, 0x00008830 }, /* GL_DRAW_BUFFER11_ATI */ - { 7771, 0x00008831 }, /* GL_DRAW_BUFFER12 */ - { 7788, 0x00008831 }, /* GL_DRAW_BUFFER12_ARB */ - { 7809, 0x00008831 }, /* GL_DRAW_BUFFER12_ATI */ - { 7830, 0x00008832 }, /* GL_DRAW_BUFFER13 */ - { 7847, 0x00008832 }, /* GL_DRAW_BUFFER13_ARB */ - { 7868, 0x00008832 }, /* GL_DRAW_BUFFER13_ATI */ - { 7889, 0x00008833 }, /* GL_DRAW_BUFFER14 */ - { 7906, 0x00008833 }, /* GL_DRAW_BUFFER14_ARB */ - { 7927, 0x00008833 }, /* GL_DRAW_BUFFER14_ATI */ - { 7948, 0x00008834 }, /* GL_DRAW_BUFFER15 */ - { 7965, 0x00008834 }, /* GL_DRAW_BUFFER15_ARB */ - { 7986, 0x00008834 }, /* GL_DRAW_BUFFER15_ATI */ - { 8007, 0x00008826 }, /* GL_DRAW_BUFFER1_ARB */ - { 8027, 0x00008826 }, /* GL_DRAW_BUFFER1_ATI */ - { 8047, 0x00008827 }, /* GL_DRAW_BUFFER2 */ - { 8063, 0x00008827 }, /* GL_DRAW_BUFFER2_ARB */ - { 8083, 0x00008827 }, /* GL_DRAW_BUFFER2_ATI */ - { 8103, 0x00008828 }, /* GL_DRAW_BUFFER3 */ - { 8119, 0x00008828 }, /* GL_DRAW_BUFFER3_ARB */ - { 8139, 0x00008828 }, /* GL_DRAW_BUFFER3_ATI */ - { 8159, 0x00008829 }, /* GL_DRAW_BUFFER4 */ - { 8175, 0x00008829 }, /* GL_DRAW_BUFFER4_ARB */ - { 8195, 0x00008829 }, /* GL_DRAW_BUFFER4_ATI */ - { 8215, 0x0000882A }, /* GL_DRAW_BUFFER5 */ - { 8231, 0x0000882A }, /* GL_DRAW_BUFFER5_ARB */ - { 8251, 0x0000882A }, /* GL_DRAW_BUFFER5_ATI */ - { 8271, 0x0000882B }, /* GL_DRAW_BUFFER6 */ - { 8287, 0x0000882B }, /* GL_DRAW_BUFFER6_ARB */ - { 8307, 0x0000882B }, /* GL_DRAW_BUFFER6_ATI */ - { 8327, 0x0000882C }, /* GL_DRAW_BUFFER7 */ - { 8343, 0x0000882C }, /* GL_DRAW_BUFFER7_ARB */ - { 8363, 0x0000882C }, /* GL_DRAW_BUFFER7_ATI */ - { 8383, 0x0000882D }, /* GL_DRAW_BUFFER8 */ - { 8399, 0x0000882D }, /* GL_DRAW_BUFFER8_ARB */ - { 8419, 0x0000882D }, /* GL_DRAW_BUFFER8_ATI */ - { 8439, 0x0000882E }, /* GL_DRAW_BUFFER9 */ - { 8455, 0x0000882E }, /* GL_DRAW_BUFFER9_ARB */ - { 8475, 0x0000882E }, /* GL_DRAW_BUFFER9_ATI */ - { 8495, 0x00008CA9 }, /* GL_DRAW_FRAMEBUFFER */ - { 8515, 0x00008CA6 }, /* GL_DRAW_FRAMEBUFFER_BINDING_EXT */ - { 8547, 0x00008CA9 }, /* GL_DRAW_FRAMEBUFFER_EXT */ - { 8571, 0x00000705 }, /* GL_DRAW_PIXEL_TOKEN */ - { 8591, 0x00000304 }, /* GL_DST_ALPHA */ - { 8604, 0x00000306 }, /* GL_DST_COLOR */ - { 8617, 0x000088EA }, /* GL_DYNAMIC_COPY */ - { 8633, 0x000088EA }, /* GL_DYNAMIC_COPY_ARB */ - { 8653, 0x000088E8 }, /* GL_DYNAMIC_DRAW */ - { 8669, 0x000088E8 }, /* GL_DYNAMIC_DRAW_ARB */ - { 8689, 0x000088E9 }, /* GL_DYNAMIC_READ */ - { 8705, 0x000088E9 }, /* GL_DYNAMIC_READ_ARB */ - { 8725, 0x00000B43 }, /* GL_EDGE_FLAG */ - { 8738, 0x00008079 }, /* GL_EDGE_FLAG_ARRAY */ - { 8757, 0x0000889B }, /* GL_EDGE_FLAG_ARRAY_BUFFER_BINDING */ - { 8791, 0x0000889B }, /* GL_EDGE_FLAG_ARRAY_BUFFER_BINDING_ARB */ - { 8829, 0x00008093 }, /* GL_EDGE_FLAG_ARRAY_POINTER */ - { 8856, 0x0000808C }, /* GL_EDGE_FLAG_ARRAY_STRIDE */ - { 8882, 0x00008893 }, /* GL_ELEMENT_ARRAY_BUFFER */ - { 8906, 0x00008895 }, /* GL_ELEMENT_ARRAY_BUFFER_BINDING */ - { 8938, 0x00008895 }, /* GL_ELEMENT_ARRAY_BUFFER_BINDING_ARB */ - { 8974, 0x00001600 }, /* GL_EMISSION */ - { 8986, 0x00002000 }, /* GL_ENABLE_BIT */ - { 9000, 0x00000202 }, /* GL_EQUAL */ - { 9009, 0x00001509 }, /* GL_EQUIV */ - { 9018, 0x00010000 }, /* GL_EVAL_BIT */ - { 9030, 0x00000800 }, /* GL_EXP */ - { 9037, 0x00000801 }, /* GL_EXP2 */ - { 9045, 0x00001F03 }, /* GL_EXTENSIONS */ - { 9059, 0x00002400 }, /* GL_EYE_LINEAR */ - { 9073, 0x00002502 }, /* GL_EYE_PLANE */ - { 9086, 0x0000855C }, /* GL_EYE_PLANE_ABSOLUTE_NV */ - { 9111, 0x0000855B }, /* GL_EYE_RADIAL_NV */ - { 9128, 0x00000000 }, /* GL_FALSE */ - { 9137, 0x00001101 }, /* GL_FASTEST */ - { 9148, 0x00001C01 }, /* GL_FEEDBACK */ - { 9160, 0x00000DF0 }, /* GL_FEEDBACK_BUFFER_POINTER */ - { 9187, 0x00000DF1 }, /* GL_FEEDBACK_BUFFER_SIZE */ - { 9211, 0x00000DF2 }, /* GL_FEEDBACK_BUFFER_TYPE */ - { 9235, 0x00001B02 }, /* GL_FILL */ - { 9243, 0x00001D00 }, /* GL_FLAT */ - { 9251, 0x00001406 }, /* GL_FLOAT */ - { 9260, 0x00008B5A }, /* GL_FLOAT_MAT2 */ - { 9274, 0x00008B5A }, /* GL_FLOAT_MAT2_ARB */ - { 9292, 0x00008B5B }, /* GL_FLOAT_MAT3 */ - { 9306, 0x00008B5B }, /* GL_FLOAT_MAT3_ARB */ - { 9324, 0x00008B5C }, /* GL_FLOAT_MAT4 */ - { 9338, 0x00008B5C }, /* GL_FLOAT_MAT4_ARB */ - { 9356, 0x00008B50 }, /* GL_FLOAT_VEC2 */ - { 9370, 0x00008B50 }, /* GL_FLOAT_VEC2_ARB */ - { 9388, 0x00008B51 }, /* GL_FLOAT_VEC3 */ - { 9402, 0x00008B51 }, /* GL_FLOAT_VEC3_ARB */ - { 9420, 0x00008B52 }, /* GL_FLOAT_VEC4 */ - { 9434, 0x00008B52 }, /* GL_FLOAT_VEC4_ARB */ - { 9452, 0x00000B60 }, /* GL_FOG */ - { 9459, 0x00000080 }, /* GL_FOG_BIT */ - { 9470, 0x00000B66 }, /* GL_FOG_COLOR */ - { 9483, 0x00008451 }, /* GL_FOG_COORD */ - { 9496, 0x00008451 }, /* GL_FOG_COORDINATE */ - { 9514, 0x00008457 }, /* GL_FOG_COORDINATE_ARRAY */ - { 9538, 0x0000889D }, /* GL_FOG_COORDINATE_ARRAY_BUFFER_BINDING */ - { 9577, 0x0000889D }, /* GL_FOG_COORDINATE_ARRAY_BUFFER_BINDING_ARB */ - { 9620, 0x00008456 }, /* GL_FOG_COORDINATE_ARRAY_POINTER */ - { 9652, 0x00008455 }, /* GL_FOG_COORDINATE_ARRAY_STRIDE */ - { 9683, 0x00008454 }, /* GL_FOG_COORDINATE_ARRAY_TYPE */ - { 9712, 0x00008450 }, /* GL_FOG_COORDINATE_SOURCE */ - { 9737, 0x00008457 }, /* GL_FOG_COORD_ARRAY */ - { 9756, 0x0000889D }, /* GL_FOG_COORD_ARRAY_BUFFER_BINDING */ - { 9790, 0x00008456 }, /* GL_FOG_COORD_ARRAY_POINTER */ - { 9817, 0x00008455 }, /* GL_FOG_COORD_ARRAY_STRIDE */ - { 9843, 0x00008454 }, /* GL_FOG_COORD_ARRAY_TYPE */ - { 9867, 0x00008450 }, /* GL_FOG_COORD_SRC */ - { 9884, 0x00000B62 }, /* GL_FOG_DENSITY */ - { 9899, 0x0000855A }, /* GL_FOG_DISTANCE_MODE_NV */ - { 9923, 0x00000B64 }, /* GL_FOG_END */ - { 9934, 0x00000C54 }, /* GL_FOG_HINT */ - { 9946, 0x00000B61 }, /* GL_FOG_INDEX */ - { 9959, 0x00000B65 }, /* GL_FOG_MODE */ - { 9971, 0x00008198 }, /* GL_FOG_OFFSET_SGIX */ - { 9990, 0x00008199 }, /* GL_FOG_OFFSET_VALUE_SGIX */ - { 10015, 0x00000B63 }, /* GL_FOG_START */ - { 10028, 0x00008452 }, /* GL_FRAGMENT_DEPTH */ - { 10046, 0x00008804 }, /* GL_FRAGMENT_PROGRAM_ARB */ - { 10070, 0x00008B30 }, /* GL_FRAGMENT_SHADER */ - { 10089, 0x00008B30 }, /* GL_FRAGMENT_SHADER_ARB */ - { 10112, 0x00008B8B }, /* GL_FRAGMENT_SHADER_DERIVATIVE_HINT */ - { 10147, 0x00008D40 }, /* GL_FRAMEBUFFER */ - { 10162, 0x00008215 }, /* GL_FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE */ - { 10199, 0x00008214 }, /* GL_FRAMEBUFFER_ATTACHMENT_BLUE_SIZE */ - { 10235, 0x00008210 }, /* GL_FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING */ - { 10276, 0x00008211 }, /* GL_FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE */ - { 10317, 0x00008216 }, /* GL_FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE */ - { 10354, 0x00008213 }, /* GL_FRAMEBUFFER_ATTACHMENT_GREEN_SIZE */ - { 10391, 0x00008CD1 }, /* GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME */ - { 10429, 0x00008CD1 }, /* GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME_EXT */ - { 10471, 0x00008CD0 }, /* GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE */ - { 10509, 0x00008CD0 }, /* GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE_EXT */ - { 10551, 0x00008212 }, /* GL_FRAMEBUFFER_ATTACHMENT_RED_SIZE */ - { 10586, 0x00008217 }, /* GL_FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE */ - { 10625, 0x00008CD4 }, /* GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_3D_ZOFFSET_EXT */ - { 10674, 0x00008CD3 }, /* GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE */ - { 10722, 0x00008CD3 }, /* GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE_EXT */ - { 10774, 0x00008CD4 }, /* GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER */ - { 10814, 0x00008CD4 }, /* GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER_EXT */ - { 10858, 0x00008CD2 }, /* GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL */ - { 10898, 0x00008CD2 }, /* GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL_EXT */ - { 10942, 0x00008CA6 }, /* GL_FRAMEBUFFER_BINDING_EXT */ - { 10969, 0x00008CD5 }, /* GL_FRAMEBUFFER_COMPLETE */ - { 10993, 0x00008CD5 }, /* GL_FRAMEBUFFER_COMPLETE_EXT */ - { 11021, 0x00008218 }, /* GL_FRAMEBUFFER_DEFAULT */ - { 11044, 0x00008D40 }, /* GL_FRAMEBUFFER_EXT */ - { 11063, 0x00008CD6 }, /* GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT */ - { 11100, 0x00008CD6 }, /* GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT_EXT */ - { 11141, 0x00008CD9 }, /* GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS_EXT */ - { 11182, 0x00008CDB }, /* GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER_EXT */ - { 11224, 0x00008CD8 }, /* GL_FRAMEBUFFER_INCOMPLETE_DUPLICATE_ATTACHMENT_EXT */ - { 11275, 0x00008CDA }, /* GL_FRAMEBUFFER_INCOMPLETE_FORMATS_EXT */ - { 11313, 0x00008CD7 }, /* GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT */ - { 11358, 0x00008CD7 }, /* GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT_EXT */ - { 11407, 0x00008D56 }, /* GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE */ - { 11445, 0x00008CDC }, /* GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER_EXT */ - { 11487, 0x00008CDE }, /* GL_FRAMEBUFFER_STATUS_ERROR_EXT */ - { 11519, 0x00008219 }, /* GL_FRAMEBUFFER_UNDEFINED */ - { 11544, 0x00008CDD }, /* GL_FRAMEBUFFER_UNSUPPORTED */ - { 11571, 0x00008CDD }, /* GL_FRAMEBUFFER_UNSUPPORTED_EXT */ - { 11602, 0x00000404 }, /* GL_FRONT */ - { 11611, 0x00000408 }, /* GL_FRONT_AND_BACK */ - { 11629, 0x00000B46 }, /* GL_FRONT_FACE */ - { 11643, 0x00000400 }, /* GL_FRONT_LEFT */ - { 11657, 0x00000401 }, /* GL_FRONT_RIGHT */ - { 11672, 0x00008006 }, /* GL_FUNC_ADD */ - { 11684, 0x00008006 }, /* GL_FUNC_ADD_EXT */ - { 11700, 0x0000800B }, /* GL_FUNC_REVERSE_SUBTRACT */ - { 11725, 0x0000800B }, /* GL_FUNC_REVERSE_SUBTRACT_EXT */ - { 11754, 0x0000800A }, /* GL_FUNC_SUBTRACT */ - { 11771, 0x0000800A }, /* GL_FUNC_SUBTRACT_EXT */ - { 11792, 0x00008191 }, /* GL_GENERATE_MIPMAP */ - { 11811, 0x00008192 }, /* GL_GENERATE_MIPMAP_HINT */ - { 11835, 0x00008192 }, /* GL_GENERATE_MIPMAP_HINT_SGIS */ - { 11864, 0x00008191 }, /* GL_GENERATE_MIPMAP_SGIS */ - { 11888, 0x00000206 }, /* GL_GEQUAL */ - { 11898, 0x00008009 }, /* GL_GL_BLEND_EQUATION_RGB */ - { 11923, 0x00008C4A }, /* GL_GL_COMPRESSED_SLUMINANCE */ - { 11951, 0x00008C4B }, /* GL_GL_COMPRESSED_SLUMINANCE_ALPHA */ - { 11985, 0x00008C48 }, /* GL_GL_COMPRESSED_SRGB */ - { 12007, 0x00008C49 }, /* GL_GL_COMPRESSED_SRGB_ALPHA */ - { 12035, 0x0000845F }, /* GL_GL_CURRENT_RASTER_SECONDARY_COLOR */ - { 12072, 0x00008B65 }, /* GL_GL_FLOAT_MAT2x3 */ - { 12091, 0x00008B66 }, /* GL_GL_FLOAT_MAT2x4 */ - { 12110, 0x00008B67 }, /* GL_GL_FLOAT_MAT3x2 */ - { 12129, 0x00008B68 }, /* GL_GL_FLOAT_MAT3x4 */ - { 12148, 0x00008B69 }, /* GL_GL_FLOAT_MAT4x2 */ - { 12167, 0x00008B6A }, /* GL_GL_FLOAT_MAT4x3 */ - { 12186, 0x000088EB }, /* GL_GL_PIXEL_PACK_BUFFER */ - { 12210, 0x000088ED }, /* GL_GL_PIXEL_PACK_BUFFER_BINDING */ - { 12242, 0x000088EC }, /* GL_GL_PIXEL_UNPACK_BUFFER */ - { 12268, 0x000088EF }, /* GL_GL_PIXEL_UNPACK_BUFFER_BINDING */ - { 12302, 0x00008C46 }, /* GL_GL_SLUMINANCE */ - { 12319, 0x00008C47 }, /* GL_GL_SLUMINANCE8 */ - { 12337, 0x00008C45 }, /* GL_GL_SLUMINANCE8_ALPHA8 */ - { 12362, 0x00008C44 }, /* GL_GL_SLUMINANCE_ALPHA */ - { 12385, 0x00008C40 }, /* GL_GL_SRGB */ - { 12396, 0x00008C41 }, /* GL_GL_SRGB8 */ - { 12408, 0x00008C43 }, /* GL_GL_SRGB8_ALPHA8 */ - { 12427, 0x00008C42 }, /* GL_GL_SRGB_ALPHA */ - { 12444, 0x00000204 }, /* GL_GREATER */ - { 12455, 0x00001904 }, /* GL_GREEN */ - { 12464, 0x00000D19 }, /* GL_GREEN_BIAS */ - { 12478, 0x00000D53 }, /* GL_GREEN_BITS */ - { 12492, 0x00000D18 }, /* GL_GREEN_SCALE */ - { 12507, 0x00008000 }, /* GL_HINT_BIT */ - { 12519, 0x00008024 }, /* GL_HISTOGRAM */ - { 12532, 0x0000802B }, /* GL_HISTOGRAM_ALPHA_SIZE */ - { 12556, 0x0000802B }, /* GL_HISTOGRAM_ALPHA_SIZE_EXT */ - { 12584, 0x0000802A }, /* GL_HISTOGRAM_BLUE_SIZE */ - { 12607, 0x0000802A }, /* GL_HISTOGRAM_BLUE_SIZE_EXT */ - { 12634, 0x00008024 }, /* GL_HISTOGRAM_EXT */ - { 12651, 0x00008027 }, /* GL_HISTOGRAM_FORMAT */ - { 12671, 0x00008027 }, /* GL_HISTOGRAM_FORMAT_EXT */ - { 12695, 0x00008029 }, /* GL_HISTOGRAM_GREEN_SIZE */ - { 12719, 0x00008029 }, /* GL_HISTOGRAM_GREEN_SIZE_EXT */ - { 12747, 0x0000802C }, /* GL_HISTOGRAM_LUMINANCE_SIZE */ - { 12775, 0x0000802C }, /* GL_HISTOGRAM_LUMINANCE_SIZE_EXT */ - { 12807, 0x00008028 }, /* GL_HISTOGRAM_RED_SIZE */ - { 12829, 0x00008028 }, /* GL_HISTOGRAM_RED_SIZE_EXT */ - { 12855, 0x0000802D }, /* GL_HISTOGRAM_SINK */ - { 12873, 0x0000802D }, /* GL_HISTOGRAM_SINK_EXT */ - { 12895, 0x00008026 }, /* GL_HISTOGRAM_WIDTH */ - { 12914, 0x00008026 }, /* GL_HISTOGRAM_WIDTH_EXT */ - { 12937, 0x0000862A }, /* GL_IDENTITY_NV */ - { 12952, 0x00008150 }, /* GL_IGNORE_BORDER_HP */ - { 12972, 0x00008B9B }, /* GL_IMPLEMENTATION_COLOR_READ_FORMAT_OES */ - { 13012, 0x00008B9A }, /* GL_IMPLEMENTATION_COLOR_READ_TYPE_OES */ - { 13050, 0x00001E02 }, /* GL_INCR */ - { 13058, 0x00008507 }, /* GL_INCR_WRAP */ - { 13071, 0x00008507 }, /* GL_INCR_WRAP_EXT */ - { 13088, 0x00008222 }, /* GL_INDEX */ - { 13097, 0x00008077 }, /* GL_INDEX_ARRAY */ - { 13112, 0x00008899 }, /* GL_INDEX_ARRAY_BUFFER_BINDING */ - { 13142, 0x00008899 }, /* GL_INDEX_ARRAY_BUFFER_BINDING_ARB */ - { 13176, 0x00008091 }, /* GL_INDEX_ARRAY_POINTER */ - { 13199, 0x00008086 }, /* GL_INDEX_ARRAY_STRIDE */ - { 13221, 0x00008085 }, /* GL_INDEX_ARRAY_TYPE */ - { 13241, 0x00000D51 }, /* GL_INDEX_BITS */ - { 13255, 0x00000C20 }, /* GL_INDEX_CLEAR_VALUE */ - { 13276, 0x00000BF1 }, /* GL_INDEX_LOGIC_OP */ - { 13294, 0x00000C30 }, /* GL_INDEX_MODE */ - { 13308, 0x00000D13 }, /* GL_INDEX_OFFSET */ - { 13324, 0x00000D12 }, /* GL_INDEX_SHIFT */ - { 13339, 0x00000C21 }, /* GL_INDEX_WRITEMASK */ - { 13358, 0x00008B84 }, /* GL_INFO_LOG_LENGTH */ - { 13377, 0x00001404 }, /* GL_INT */ - { 13384, 0x00008049 }, /* GL_INTENSITY */ - { 13397, 0x0000804C }, /* GL_INTENSITY12 */ - { 13412, 0x0000804C }, /* GL_INTENSITY12_EXT */ - { 13431, 0x0000804D }, /* GL_INTENSITY16 */ - { 13446, 0x0000804D }, /* GL_INTENSITY16_EXT */ - { 13465, 0x0000804A }, /* GL_INTENSITY4 */ - { 13479, 0x0000804A }, /* GL_INTENSITY4_EXT */ - { 13497, 0x0000804B }, /* GL_INTENSITY8 */ - { 13511, 0x0000804B }, /* GL_INTENSITY8_EXT */ - { 13529, 0x00008049 }, /* GL_INTENSITY_EXT */ - { 13546, 0x00008575 }, /* GL_INTERPOLATE */ - { 13561, 0x00008575 }, /* GL_INTERPOLATE_ARB */ - { 13580, 0x00008575 }, /* GL_INTERPOLATE_EXT */ - { 13599, 0x00008B53 }, /* GL_INT_VEC2 */ - { 13611, 0x00008B53 }, /* GL_INT_VEC2_ARB */ - { 13627, 0x00008B54 }, /* GL_INT_VEC3 */ - { 13639, 0x00008B54 }, /* GL_INT_VEC3_ARB */ - { 13655, 0x00008B55 }, /* GL_INT_VEC4 */ - { 13667, 0x00008B55 }, /* GL_INT_VEC4_ARB */ - { 13683, 0x00000500 }, /* GL_INVALID_ENUM */ - { 13699, 0x00000506 }, /* GL_INVALID_FRAMEBUFFER_OPERATION */ - { 13732, 0x00000506 }, /* GL_INVALID_FRAMEBUFFER_OPERATION_EXT */ - { 13769, 0x00000502 }, /* GL_INVALID_OPERATION */ - { 13790, 0x00000501 }, /* GL_INVALID_VALUE */ - { 13807, 0x0000862B }, /* GL_INVERSE_NV */ - { 13821, 0x0000862D }, /* GL_INVERSE_TRANSPOSE_NV */ - { 13845, 0x0000150A }, /* GL_INVERT */ - { 13855, 0x00001E00 }, /* GL_KEEP */ - { 13863, 0x00000406 }, /* GL_LEFT */ - { 13871, 0x00000203 }, /* GL_LEQUAL */ - { 13881, 0x00000201 }, /* GL_LESS */ - { 13889, 0x00004000 }, /* GL_LIGHT0 */ - { 13899, 0x00004001 }, /* GL_LIGHT1 */ - { 13909, 0x00004002 }, /* GL_LIGHT2 */ - { 13919, 0x00004003 }, /* GL_LIGHT3 */ - { 13929, 0x00004004 }, /* GL_LIGHT4 */ - { 13939, 0x00004005 }, /* GL_LIGHT5 */ - { 13949, 0x00004006 }, /* GL_LIGHT6 */ - { 13959, 0x00004007 }, /* GL_LIGHT7 */ - { 13969, 0x00000B50 }, /* GL_LIGHTING */ - { 13981, 0x00000040 }, /* GL_LIGHTING_BIT */ - { 13997, 0x00000B53 }, /* GL_LIGHT_MODEL_AMBIENT */ - { 14020, 0x000081F8 }, /* GL_LIGHT_MODEL_COLOR_CONTROL */ - { 14049, 0x000081F8 }, /* GL_LIGHT_MODEL_COLOR_CONTROL_EXT */ - { 14082, 0x00000B51 }, /* GL_LIGHT_MODEL_LOCAL_VIEWER */ - { 14110, 0x00000B52 }, /* GL_LIGHT_MODEL_TWO_SIDE */ - { 14134, 0x00001B01 }, /* GL_LINE */ - { 14142, 0x00002601 }, /* GL_LINEAR */ - { 14152, 0x00001208 }, /* GL_LINEAR_ATTENUATION */ - { 14174, 0x00008170 }, /* GL_LINEAR_CLIPMAP_LINEAR_SGIX */ - { 14204, 0x0000844F }, /* GL_LINEAR_CLIPMAP_NEAREST_SGIX */ - { 14235, 0x00002703 }, /* GL_LINEAR_MIPMAP_LINEAR */ - { 14259, 0x00002701 }, /* GL_LINEAR_MIPMAP_NEAREST */ - { 14284, 0x00000001 }, /* GL_LINES */ - { 14293, 0x00000004 }, /* GL_LINE_BIT */ - { 14305, 0x00000002 }, /* GL_LINE_LOOP */ - { 14318, 0x00000707 }, /* GL_LINE_RESET_TOKEN */ - { 14338, 0x00000B20 }, /* GL_LINE_SMOOTH */ - { 14353, 0x00000C52 }, /* GL_LINE_SMOOTH_HINT */ - { 14373, 0x00000B24 }, /* GL_LINE_STIPPLE */ - { 14389, 0x00000B25 }, /* GL_LINE_STIPPLE_PATTERN */ - { 14413, 0x00000B26 }, /* GL_LINE_STIPPLE_REPEAT */ - { 14436, 0x00000003 }, /* GL_LINE_STRIP */ - { 14450, 0x00000702 }, /* GL_LINE_TOKEN */ - { 14464, 0x00000B21 }, /* GL_LINE_WIDTH */ - { 14478, 0x00000B23 }, /* GL_LINE_WIDTH_GRANULARITY */ - { 14504, 0x00000B22 }, /* GL_LINE_WIDTH_RANGE */ - { 14524, 0x00008B82 }, /* GL_LINK_STATUS */ - { 14539, 0x00000B32 }, /* GL_LIST_BASE */ - { 14552, 0x00020000 }, /* GL_LIST_BIT */ - { 14564, 0x00000B33 }, /* GL_LIST_INDEX */ - { 14578, 0x00000B30 }, /* GL_LIST_MODE */ - { 14591, 0x00000101 }, /* GL_LOAD */ - { 14599, 0x00000BF1 }, /* GL_LOGIC_OP */ - { 14611, 0x00000BF0 }, /* GL_LOGIC_OP_MODE */ - { 14628, 0x00008CA1 }, /* GL_LOWER_LEFT */ - { 14642, 0x00001909 }, /* GL_LUMINANCE */ - { 14655, 0x00008041 }, /* GL_LUMINANCE12 */ - { 14670, 0x00008047 }, /* GL_LUMINANCE12_ALPHA12 */ - { 14693, 0x00008047 }, /* GL_LUMINANCE12_ALPHA12_EXT */ - { 14720, 0x00008046 }, /* GL_LUMINANCE12_ALPHA4 */ - { 14742, 0x00008046 }, /* GL_LUMINANCE12_ALPHA4_EXT */ - { 14768, 0x00008041 }, /* GL_LUMINANCE12_EXT */ - { 14787, 0x00008042 }, /* GL_LUMINANCE16 */ - { 14802, 0x00008048 }, /* GL_LUMINANCE16_ALPHA16 */ - { 14825, 0x00008048 }, /* GL_LUMINANCE16_ALPHA16_EXT */ - { 14852, 0x00008042 }, /* GL_LUMINANCE16_EXT */ - { 14871, 0x0000803F }, /* GL_LUMINANCE4 */ - { 14885, 0x00008043 }, /* GL_LUMINANCE4_ALPHA4 */ - { 14906, 0x00008043 }, /* GL_LUMINANCE4_ALPHA4_EXT */ - { 14931, 0x0000803F }, /* GL_LUMINANCE4_EXT */ - { 14949, 0x00008044 }, /* GL_LUMINANCE6_ALPHA2 */ - { 14970, 0x00008044 }, /* GL_LUMINANCE6_ALPHA2_EXT */ - { 14995, 0x00008040 }, /* GL_LUMINANCE8 */ - { 15009, 0x00008045 }, /* GL_LUMINANCE8_ALPHA8 */ - { 15030, 0x00008045 }, /* GL_LUMINANCE8_ALPHA8_EXT */ - { 15055, 0x00008040 }, /* GL_LUMINANCE8_EXT */ - { 15073, 0x0000190A }, /* GL_LUMINANCE_ALPHA */ - { 15092, 0x00000D90 }, /* GL_MAP1_COLOR_4 */ - { 15108, 0x00000DD0 }, /* GL_MAP1_GRID_DOMAIN */ - { 15128, 0x00000DD1 }, /* GL_MAP1_GRID_SEGMENTS */ - { 15150, 0x00000D91 }, /* GL_MAP1_INDEX */ - { 15164, 0x00000D92 }, /* GL_MAP1_NORMAL */ - { 15179, 0x00000D93 }, /* GL_MAP1_TEXTURE_COORD_1 */ - { 15203, 0x00000D94 }, /* GL_MAP1_TEXTURE_COORD_2 */ - { 15227, 0x00000D95 }, /* GL_MAP1_TEXTURE_COORD_3 */ - { 15251, 0x00000D96 }, /* GL_MAP1_TEXTURE_COORD_4 */ - { 15275, 0x00000D97 }, /* GL_MAP1_VERTEX_3 */ - { 15292, 0x00000D98 }, /* GL_MAP1_VERTEX_4 */ - { 15309, 0x00008660 }, /* GL_MAP1_VERTEX_ATTRIB0_4_NV */ - { 15337, 0x0000866A }, /* GL_MAP1_VERTEX_ATTRIB10_4_NV */ - { 15366, 0x0000866B }, /* GL_MAP1_VERTEX_ATTRIB11_4_NV */ - { 15395, 0x0000866C }, /* GL_MAP1_VERTEX_ATTRIB12_4_NV */ - { 15424, 0x0000866D }, /* GL_MAP1_VERTEX_ATTRIB13_4_NV */ - { 15453, 0x0000866E }, /* GL_MAP1_VERTEX_ATTRIB14_4_NV */ - { 15482, 0x0000866F }, /* GL_MAP1_VERTEX_ATTRIB15_4_NV */ - { 15511, 0x00008661 }, /* GL_MAP1_VERTEX_ATTRIB1_4_NV */ - { 15539, 0x00008662 }, /* GL_MAP1_VERTEX_ATTRIB2_4_NV */ - { 15567, 0x00008663 }, /* GL_MAP1_VERTEX_ATTRIB3_4_NV */ - { 15595, 0x00008664 }, /* GL_MAP1_VERTEX_ATTRIB4_4_NV */ - { 15623, 0x00008665 }, /* GL_MAP1_VERTEX_ATTRIB5_4_NV */ - { 15651, 0x00008666 }, /* GL_MAP1_VERTEX_ATTRIB6_4_NV */ - { 15679, 0x00008667 }, /* GL_MAP1_VERTEX_ATTRIB7_4_NV */ - { 15707, 0x00008668 }, /* GL_MAP1_VERTEX_ATTRIB8_4_NV */ - { 15735, 0x00008669 }, /* GL_MAP1_VERTEX_ATTRIB9_4_NV */ - { 15763, 0x00000DB0 }, /* GL_MAP2_COLOR_4 */ - { 15779, 0x00000DD2 }, /* GL_MAP2_GRID_DOMAIN */ - { 15799, 0x00000DD3 }, /* GL_MAP2_GRID_SEGMENTS */ - { 15821, 0x00000DB1 }, /* GL_MAP2_INDEX */ - { 15835, 0x00000DB2 }, /* GL_MAP2_NORMAL */ - { 15850, 0x00000DB3 }, /* GL_MAP2_TEXTURE_COORD_1 */ - { 15874, 0x00000DB4 }, /* GL_MAP2_TEXTURE_COORD_2 */ - { 15898, 0x00000DB5 }, /* GL_MAP2_TEXTURE_COORD_3 */ - { 15922, 0x00000DB6 }, /* GL_MAP2_TEXTURE_COORD_4 */ - { 15946, 0x00000DB7 }, /* GL_MAP2_VERTEX_3 */ - { 15963, 0x00000DB8 }, /* GL_MAP2_VERTEX_4 */ - { 15980, 0x00008670 }, /* GL_MAP2_VERTEX_ATTRIB0_4_NV */ - { 16008, 0x0000867A }, /* GL_MAP2_VERTEX_ATTRIB10_4_NV */ - { 16037, 0x0000867B }, /* GL_MAP2_VERTEX_ATTRIB11_4_NV */ - { 16066, 0x0000867C }, /* GL_MAP2_VERTEX_ATTRIB12_4_NV */ - { 16095, 0x0000867D }, /* GL_MAP2_VERTEX_ATTRIB13_4_NV */ - { 16124, 0x0000867E }, /* GL_MAP2_VERTEX_ATTRIB14_4_NV */ - { 16153, 0x0000867F }, /* GL_MAP2_VERTEX_ATTRIB15_4_NV */ - { 16182, 0x00008671 }, /* GL_MAP2_VERTEX_ATTRIB1_4_NV */ - { 16210, 0x00008672 }, /* GL_MAP2_VERTEX_ATTRIB2_4_NV */ - { 16238, 0x00008673 }, /* GL_MAP2_VERTEX_ATTRIB3_4_NV */ - { 16266, 0x00008674 }, /* GL_MAP2_VERTEX_ATTRIB4_4_NV */ - { 16294, 0x00008675 }, /* GL_MAP2_VERTEX_ATTRIB5_4_NV */ - { 16322, 0x00008676 }, /* GL_MAP2_VERTEX_ATTRIB6_4_NV */ - { 16350, 0x00008677 }, /* GL_MAP2_VERTEX_ATTRIB7_4_NV */ - { 16378, 0x00008678 }, /* GL_MAP2_VERTEX_ATTRIB8_4_NV */ - { 16406, 0x00008679 }, /* GL_MAP2_VERTEX_ATTRIB9_4_NV */ - { 16434, 0x00000D10 }, /* GL_MAP_COLOR */ - { 16447, 0x00000D11 }, /* GL_MAP_STENCIL */ - { 16462, 0x000088C0 }, /* GL_MATRIX0_ARB */ - { 16477, 0x00008630 }, /* GL_MATRIX0_NV */ - { 16491, 0x000088CA }, /* GL_MATRIX10_ARB */ - { 16507, 0x000088CB }, /* GL_MATRIX11_ARB */ - { 16523, 0x000088CC }, /* GL_MATRIX12_ARB */ - { 16539, 0x000088CD }, /* GL_MATRIX13_ARB */ - { 16555, 0x000088CE }, /* GL_MATRIX14_ARB */ - { 16571, 0x000088CF }, /* GL_MATRIX15_ARB */ - { 16587, 0x000088D0 }, /* GL_MATRIX16_ARB */ - { 16603, 0x000088D1 }, /* GL_MATRIX17_ARB */ - { 16619, 0x000088D2 }, /* GL_MATRIX18_ARB */ - { 16635, 0x000088D3 }, /* GL_MATRIX19_ARB */ - { 16651, 0x000088C1 }, /* GL_MATRIX1_ARB */ - { 16666, 0x00008631 }, /* GL_MATRIX1_NV */ - { 16680, 0x000088D4 }, /* GL_MATRIX20_ARB */ - { 16696, 0x000088D5 }, /* GL_MATRIX21_ARB */ - { 16712, 0x000088D6 }, /* GL_MATRIX22_ARB */ - { 16728, 0x000088D7 }, /* GL_MATRIX23_ARB */ - { 16744, 0x000088D8 }, /* GL_MATRIX24_ARB */ - { 16760, 0x000088D9 }, /* GL_MATRIX25_ARB */ - { 16776, 0x000088DA }, /* GL_MATRIX26_ARB */ - { 16792, 0x000088DB }, /* GL_MATRIX27_ARB */ - { 16808, 0x000088DC }, /* GL_MATRIX28_ARB */ - { 16824, 0x000088DD }, /* GL_MATRIX29_ARB */ - { 16840, 0x000088C2 }, /* GL_MATRIX2_ARB */ - { 16855, 0x00008632 }, /* GL_MATRIX2_NV */ - { 16869, 0x000088DE }, /* GL_MATRIX30_ARB */ - { 16885, 0x000088DF }, /* GL_MATRIX31_ARB */ - { 16901, 0x000088C3 }, /* GL_MATRIX3_ARB */ - { 16916, 0x00008633 }, /* GL_MATRIX3_NV */ - { 16930, 0x000088C4 }, /* GL_MATRIX4_ARB */ - { 16945, 0x00008634 }, /* GL_MATRIX4_NV */ - { 16959, 0x000088C5 }, /* GL_MATRIX5_ARB */ - { 16974, 0x00008635 }, /* GL_MATRIX5_NV */ - { 16988, 0x000088C6 }, /* GL_MATRIX6_ARB */ - { 17003, 0x00008636 }, /* GL_MATRIX6_NV */ - { 17017, 0x000088C7 }, /* GL_MATRIX7_ARB */ - { 17032, 0x00008637 }, /* GL_MATRIX7_NV */ - { 17046, 0x000088C8 }, /* GL_MATRIX8_ARB */ - { 17061, 0x000088C9 }, /* GL_MATRIX9_ARB */ - { 17076, 0x00008844 }, /* GL_MATRIX_INDEX_ARRAY_ARB */ - { 17102, 0x00008849 }, /* GL_MATRIX_INDEX_ARRAY_POINTER_ARB */ - { 17136, 0x00008846 }, /* GL_MATRIX_INDEX_ARRAY_SIZE_ARB */ - { 17167, 0x00008848 }, /* GL_MATRIX_INDEX_ARRAY_STRIDE_ARB */ - { 17200, 0x00008847 }, /* GL_MATRIX_INDEX_ARRAY_TYPE_ARB */ - { 17231, 0x00000BA0 }, /* GL_MATRIX_MODE */ - { 17246, 0x00008840 }, /* GL_MATRIX_PALETTE_ARB */ - { 17268, 0x00008008 }, /* GL_MAX */ - { 17275, 0x00008073 }, /* GL_MAX_3D_TEXTURE_SIZE */ - { 17298, 0x000088FF }, /* GL_MAX_ARRAY_TEXTURE_LAYERS_EXT */ - { 17330, 0x00000D35 }, /* GL_MAX_ATTRIB_STACK_DEPTH */ - { 17356, 0x00000D3B }, /* GL_MAX_CLIENT_ATTRIB_STACK_DEPTH */ - { 17389, 0x00008177 }, /* GL_MAX_CLIPMAP_DEPTH_SGIX */ - { 17415, 0x00008178 }, /* GL_MAX_CLIPMAP_VIRTUAL_DEPTH_SGIX */ - { 17449, 0x00000D32 }, /* GL_MAX_CLIP_PLANES */ - { 17468, 0x00008CDF }, /* GL_MAX_COLOR_ATTACHMENTS_EXT */ - { 17497, 0x000080B3 }, /* GL_MAX_COLOR_MATRIX_STACK_DEPTH */ - { 17529, 0x000080B3 }, /* GL_MAX_COLOR_MATRIX_STACK_DEPTH_SGI */ - { 17565, 0x00008B4D }, /* GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS */ - { 17601, 0x00008B4D }, /* GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS_ARB */ - { 17641, 0x0000801B }, /* GL_MAX_CONVOLUTION_HEIGHT */ - { 17667, 0x0000801B }, /* GL_MAX_CONVOLUTION_HEIGHT_EXT */ - { 17697, 0x0000801A }, /* GL_MAX_CONVOLUTION_WIDTH */ - { 17722, 0x0000801A }, /* GL_MAX_CONVOLUTION_WIDTH_EXT */ - { 17751, 0x0000851C }, /* GL_MAX_CUBE_MAP_TEXTURE_SIZE */ - { 17780, 0x0000851C }, /* GL_MAX_CUBE_MAP_TEXTURE_SIZE_ARB */ - { 17813, 0x00008824 }, /* GL_MAX_DRAW_BUFFERS */ - { 17833, 0x00008824 }, /* GL_MAX_DRAW_BUFFERS_ARB */ - { 17857, 0x00008824 }, /* GL_MAX_DRAW_BUFFERS_ATI */ - { 17881, 0x000080E9 }, /* GL_MAX_ELEMENTS_INDICES */ - { 17905, 0x000080E8 }, /* GL_MAX_ELEMENTS_VERTICES */ - { 17930, 0x00000D30 }, /* GL_MAX_EVAL_ORDER */ - { 17948, 0x00008008 }, /* GL_MAX_EXT */ - { 17959, 0x00008B49 }, /* GL_MAX_FRAGMENT_UNIFORM_COMPONENTS */ - { 17994, 0x00008B49 }, /* GL_MAX_FRAGMENT_UNIFORM_COMPONENTS_ARB */ - { 18033, 0x00000D31 }, /* GL_MAX_LIGHTS */ - { 18047, 0x00000B31 }, /* GL_MAX_LIST_NESTING */ - { 18067, 0x00008841 }, /* GL_MAX_MATRIX_PALETTE_STACK_DEPTH_ARB */ - { 18105, 0x00000D36 }, /* GL_MAX_MODELVIEW_STACK_DEPTH */ - { 18134, 0x00000D37 }, /* GL_MAX_NAME_STACK_DEPTH */ - { 18158, 0x00008842 }, /* GL_MAX_PALETTE_MATRICES_ARB */ - { 18186, 0x00000D34 }, /* GL_MAX_PIXEL_MAP_TABLE */ - { 18209, 0x000088B1 }, /* GL_MAX_PROGRAM_ADDRESS_REGISTERS_ARB */ - { 18246, 0x0000880B }, /* GL_MAX_PROGRAM_ALU_INSTRUCTIONS_ARB */ - { 18282, 0x000088AD }, /* GL_MAX_PROGRAM_ATTRIBS_ARB */ - { 18309, 0x000088F5 }, /* GL_MAX_PROGRAM_CALL_DEPTH_NV */ - { 18338, 0x000088B5 }, /* GL_MAX_PROGRAM_ENV_PARAMETERS_ARB */ - { 18372, 0x000088F4 }, /* GL_MAX_PROGRAM_EXEC_INSTRUCTIONS_NV */ - { 18408, 0x000088F6 }, /* GL_MAX_PROGRAM_IF_DEPTH_NV */ - { 18435, 0x000088A1 }, /* GL_MAX_PROGRAM_INSTRUCTIONS_ARB */ - { 18467, 0x000088B4 }, /* GL_MAX_PROGRAM_LOCAL_PARAMETERS_ARB */ - { 18503, 0x000088F8 }, /* GL_MAX_PROGRAM_LOOP_COUNT_NV */ - { 18532, 0x000088F7 }, /* GL_MAX_PROGRAM_LOOP_DEPTH_NV */ - { 18561, 0x0000862F }, /* GL_MAX_PROGRAM_MATRICES_ARB */ - { 18589, 0x0000862E }, /* GL_MAX_PROGRAM_MATRIX_STACK_DEPTH_ARB */ - { 18627, 0x000088B3 }, /* GL_MAX_PROGRAM_NATIVE_ADDRESS_REGISTERS_ARB */ - { 18671, 0x0000880E }, /* GL_MAX_PROGRAM_NATIVE_ALU_INSTRUCTIONS_ARB */ - { 18714, 0x000088AF }, /* GL_MAX_PROGRAM_NATIVE_ATTRIBS_ARB */ - { 18748, 0x000088A3 }, /* GL_MAX_PROGRAM_NATIVE_INSTRUCTIONS_ARB */ - { 18787, 0x000088AB }, /* GL_MAX_PROGRAM_NATIVE_PARAMETERS_ARB */ - { 18824, 0x000088A7 }, /* GL_MAX_PROGRAM_NATIVE_TEMPORARIES_ARB */ - { 18862, 0x00008810 }, /* GL_MAX_PROGRAM_NATIVE_TEX_INDIRECTIONS_ARB */ - { 18905, 0x0000880F }, /* GL_MAX_PROGRAM_NATIVE_TEX_INSTRUCTIONS_ARB */ - { 18948, 0x000088A9 }, /* GL_MAX_PROGRAM_PARAMETERS_ARB */ - { 18978, 0x000088A5 }, /* GL_MAX_PROGRAM_TEMPORARIES_ARB */ - { 19009, 0x0000880D }, /* GL_MAX_PROGRAM_TEX_INDIRECTIONS_ARB */ - { 19045, 0x0000880C }, /* GL_MAX_PROGRAM_TEX_INSTRUCTIONS_ARB */ - { 19081, 0x00000D38 }, /* GL_MAX_PROJECTION_STACK_DEPTH */ - { 19111, 0x000084F8 }, /* GL_MAX_RECTANGLE_TEXTURE_SIZE_ARB */ - { 19145, 0x000084F8 }, /* GL_MAX_RECTANGLE_TEXTURE_SIZE_NV */ - { 19178, 0x000084E8 }, /* GL_MAX_RENDERBUFFER_SIZE_EXT */ - { 19207, 0x00008D57 }, /* GL_MAX_SAMPLES */ - { 19222, 0x00008504 }, /* GL_MAX_SHININESS_NV */ - { 19242, 0x00008505 }, /* GL_MAX_SPOT_EXPONENT_NV */ - { 19266, 0x00008871 }, /* GL_MAX_TEXTURE_COORDS */ - { 19288, 0x00008871 }, /* GL_MAX_TEXTURE_COORDS_ARB */ - { 19314, 0x00008872 }, /* GL_MAX_TEXTURE_IMAGE_UNITS */ - { 19341, 0x00008872 }, /* GL_MAX_TEXTURE_IMAGE_UNITS_ARB */ - { 19372, 0x000084FD }, /* GL_MAX_TEXTURE_LOD_BIAS */ - { 19396, 0x000084FF }, /* GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT */ - { 19430, 0x00000D33 }, /* GL_MAX_TEXTURE_SIZE */ - { 19450, 0x00000D39 }, /* GL_MAX_TEXTURE_STACK_DEPTH */ - { 19477, 0x000084E2 }, /* GL_MAX_TEXTURE_UNITS */ - { 19498, 0x000084E2 }, /* GL_MAX_TEXTURE_UNITS_ARB */ - { 19523, 0x0000862F }, /* GL_MAX_TRACK_MATRICES_NV */ - { 19548, 0x0000862E }, /* GL_MAX_TRACK_MATRIX_STACK_DEPTH_NV */ - { 19583, 0x00008B4B }, /* GL_MAX_VARYING_FLOATS */ - { 19605, 0x00008B4B }, /* GL_MAX_VARYING_FLOATS_ARB */ - { 19631, 0x00008869 }, /* GL_MAX_VERTEX_ATTRIBS */ - { 19653, 0x00008869 }, /* GL_MAX_VERTEX_ATTRIBS_ARB */ - { 19679, 0x00008B4C }, /* GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS */ - { 19713, 0x00008B4C }, /* GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS_ARB */ - { 19751, 0x00008B4A }, /* GL_MAX_VERTEX_UNIFORM_COMPONENTS */ - { 19784, 0x00008B4A }, /* GL_MAX_VERTEX_UNIFORM_COMPONENTS_ARB */ - { 19821, 0x000086A4 }, /* GL_MAX_VERTEX_UNITS_ARB */ - { 19845, 0x00000D3A }, /* GL_MAX_VIEWPORT_DIMS */ - { 19866, 0x00008007 }, /* GL_MIN */ - { 19873, 0x0000802E }, /* GL_MINMAX */ - { 19883, 0x0000802E }, /* GL_MINMAX_EXT */ - { 19897, 0x0000802F }, /* GL_MINMAX_FORMAT */ - { 19914, 0x0000802F }, /* GL_MINMAX_FORMAT_EXT */ - { 19935, 0x00008030 }, /* GL_MINMAX_SINK */ - { 19950, 0x00008030 }, /* GL_MINMAX_SINK_EXT */ - { 19969, 0x00008007 }, /* GL_MIN_EXT */ - { 19980, 0x00008370 }, /* GL_MIRRORED_REPEAT */ - { 19999, 0x00008370 }, /* GL_MIRRORED_REPEAT_ARB */ - { 20022, 0x00008370 }, /* GL_MIRRORED_REPEAT_IBM */ - { 20045, 0x00008742 }, /* GL_MIRROR_CLAMP_ATI */ - { 20065, 0x00008742 }, /* GL_MIRROR_CLAMP_EXT */ - { 20085, 0x00008912 }, /* GL_MIRROR_CLAMP_TO_BORDER_EXT */ - { 20115, 0x00008743 }, /* GL_MIRROR_CLAMP_TO_EDGE_ATI */ - { 20143, 0x00008743 }, /* GL_MIRROR_CLAMP_TO_EDGE_EXT */ - { 20171, 0x00001700 }, /* GL_MODELVIEW */ - { 20184, 0x00001700 }, /* GL_MODELVIEW0_ARB */ - { 20202, 0x0000872A }, /* GL_MODELVIEW10_ARB */ - { 20221, 0x0000872B }, /* GL_MODELVIEW11_ARB */ - { 20240, 0x0000872C }, /* GL_MODELVIEW12_ARB */ - { 20259, 0x0000872D }, /* GL_MODELVIEW13_ARB */ - { 20278, 0x0000872E }, /* GL_MODELVIEW14_ARB */ - { 20297, 0x0000872F }, /* GL_MODELVIEW15_ARB */ - { 20316, 0x00008730 }, /* GL_MODELVIEW16_ARB */ - { 20335, 0x00008731 }, /* GL_MODELVIEW17_ARB */ - { 20354, 0x00008732 }, /* GL_MODELVIEW18_ARB */ - { 20373, 0x00008733 }, /* GL_MODELVIEW19_ARB */ - { 20392, 0x0000850A }, /* GL_MODELVIEW1_ARB */ - { 20410, 0x00008734 }, /* GL_MODELVIEW20_ARB */ - { 20429, 0x00008735 }, /* GL_MODELVIEW21_ARB */ - { 20448, 0x00008736 }, /* GL_MODELVIEW22_ARB */ - { 20467, 0x00008737 }, /* GL_MODELVIEW23_ARB */ - { 20486, 0x00008738 }, /* GL_MODELVIEW24_ARB */ - { 20505, 0x00008739 }, /* GL_MODELVIEW25_ARB */ - { 20524, 0x0000873A }, /* GL_MODELVIEW26_ARB */ - { 20543, 0x0000873B }, /* GL_MODELVIEW27_ARB */ - { 20562, 0x0000873C }, /* GL_MODELVIEW28_ARB */ - { 20581, 0x0000873D }, /* GL_MODELVIEW29_ARB */ - { 20600, 0x00008722 }, /* GL_MODELVIEW2_ARB */ - { 20618, 0x0000873E }, /* GL_MODELVIEW30_ARB */ - { 20637, 0x0000873F }, /* GL_MODELVIEW31_ARB */ - { 20656, 0x00008723 }, /* GL_MODELVIEW3_ARB */ - { 20674, 0x00008724 }, /* GL_MODELVIEW4_ARB */ - { 20692, 0x00008725 }, /* GL_MODELVIEW5_ARB */ - { 20710, 0x00008726 }, /* GL_MODELVIEW6_ARB */ - { 20728, 0x00008727 }, /* GL_MODELVIEW7_ARB */ - { 20746, 0x00008728 }, /* GL_MODELVIEW8_ARB */ - { 20764, 0x00008729 }, /* GL_MODELVIEW9_ARB */ - { 20782, 0x00000BA6 }, /* GL_MODELVIEW_MATRIX */ - { 20802, 0x00008629 }, /* GL_MODELVIEW_PROJECTION_NV */ - { 20829, 0x00000BA3 }, /* GL_MODELVIEW_STACK_DEPTH */ - { 20854, 0x00002100 }, /* GL_MODULATE */ - { 20866, 0x00008744 }, /* GL_MODULATE_ADD_ATI */ - { 20886, 0x00008745 }, /* GL_MODULATE_SIGNED_ADD_ATI */ - { 20913, 0x00008746 }, /* GL_MODULATE_SUBTRACT_ATI */ - { 20938, 0x00000103 }, /* GL_MULT */ - { 20946, 0x0000809D }, /* GL_MULTISAMPLE */ - { 20961, 0x000086B2 }, /* GL_MULTISAMPLE_3DFX */ - { 20981, 0x0000809D }, /* GL_MULTISAMPLE_ARB */ - { 21000, 0x20000000 }, /* GL_MULTISAMPLE_BIT */ - { 21019, 0x20000000 }, /* GL_MULTISAMPLE_BIT_3DFX */ - { 21043, 0x20000000 }, /* GL_MULTISAMPLE_BIT_ARB */ - { 21066, 0x00008534 }, /* GL_MULTISAMPLE_FILTER_HINT_NV */ - { 21096, 0x00002A25 }, /* GL_N3F_V3F */ - { 21107, 0x00000D70 }, /* GL_NAME_STACK_DEPTH */ - { 21127, 0x0000150E }, /* GL_NAND */ - { 21135, 0x00002600 }, /* GL_NEAREST */ - { 21146, 0x0000844E }, /* GL_NEAREST_CLIPMAP_LINEAR_SGIX */ - { 21177, 0x0000844D }, /* GL_NEAREST_CLIPMAP_NEAREST_SGIX */ - { 21209, 0x00002702 }, /* GL_NEAREST_MIPMAP_LINEAR */ - { 21234, 0x00002700 }, /* GL_NEAREST_MIPMAP_NEAREST */ - { 21260, 0x00000200 }, /* GL_NEVER */ - { 21269, 0x00001102 }, /* GL_NICEST */ - { 21279, 0x00000000 }, /* GL_NONE */ - { 21287, 0x00001505 }, /* GL_NOOP */ - { 21295, 0x00001508 }, /* GL_NOR */ - { 21302, 0x00000BA1 }, /* GL_NORMALIZE */ - { 21315, 0x00008075 }, /* GL_NORMAL_ARRAY */ - { 21331, 0x00008897 }, /* GL_NORMAL_ARRAY_BUFFER_BINDING */ - { 21362, 0x00008897 }, /* GL_NORMAL_ARRAY_BUFFER_BINDING_ARB */ - { 21397, 0x0000808F }, /* GL_NORMAL_ARRAY_POINTER */ - { 21421, 0x0000807F }, /* GL_NORMAL_ARRAY_STRIDE */ - { 21444, 0x0000807E }, /* GL_NORMAL_ARRAY_TYPE */ - { 21465, 0x00008511 }, /* GL_NORMAL_MAP */ - { 21479, 0x00008511 }, /* GL_NORMAL_MAP_ARB */ - { 21497, 0x00008511 }, /* GL_NORMAL_MAP_NV */ - { 21514, 0x00000205 }, /* GL_NOTEQUAL */ - { 21526, 0x00000000 }, /* GL_NO_ERROR */ - { 21538, 0x000086A2 }, /* GL_NUM_COMPRESSED_TEXTURE_FORMATS */ - { 21572, 0x000086A2 }, /* GL_NUM_COMPRESSED_TEXTURE_FORMATS_ARB */ - { 21610, 0x00008B89 }, /* GL_OBJECT_ACTIVE_ATTRIBUTES_ARB */ - { 21642, 0x00008B8A }, /* GL_OBJECT_ACTIVE_ATTRIBUTE_MAX_LENGTH_ARB */ - { 21684, 0x00008B86 }, /* GL_OBJECT_ACTIVE_UNIFORMS_ARB */ - { 21714, 0x00008B87 }, /* GL_OBJECT_ACTIVE_UNIFORM_MAX_LENGTH_ARB */ - { 21754, 0x00008B85 }, /* GL_OBJECT_ATTACHED_OBJECTS_ARB */ - { 21785, 0x00008B81 }, /* GL_OBJECT_COMPILE_STATUS_ARB */ - { 21814, 0x00008B80 }, /* GL_OBJECT_DELETE_STATUS_ARB */ - { 21842, 0x00008B84 }, /* GL_OBJECT_INFO_LOG_LENGTH_ARB */ - { 21872, 0x00002401 }, /* GL_OBJECT_LINEAR */ - { 21889, 0x00008B82 }, /* GL_OBJECT_LINK_STATUS_ARB */ - { 21915, 0x00002501 }, /* GL_OBJECT_PLANE */ - { 21931, 0x00008B88 }, /* GL_OBJECT_SHADER_SOURCE_LENGTH_ARB */ - { 21966, 0x00008B4F }, /* GL_OBJECT_SUBTYPE_ARB */ - { 21988, 0x00008B4E }, /* GL_OBJECT_TYPE_ARB */ - { 22007, 0x00008B83 }, /* GL_OBJECT_VALIDATE_STATUS_ARB */ - { 22037, 0x00008165 }, /* GL_OCCLUSION_TEST_HP */ - { 22058, 0x00008166 }, /* GL_OCCLUSION_TEST_RESULT_HP */ - { 22086, 0x00000001 }, /* GL_ONE */ - { 22093, 0x00008004 }, /* GL_ONE_MINUS_CONSTANT_ALPHA */ - { 22121, 0x00008004 }, /* GL_ONE_MINUS_CONSTANT_ALPHA_EXT */ - { 22153, 0x00008002 }, /* GL_ONE_MINUS_CONSTANT_COLOR */ - { 22181, 0x00008002 }, /* GL_ONE_MINUS_CONSTANT_COLOR_EXT */ - { 22213, 0x00000305 }, /* GL_ONE_MINUS_DST_ALPHA */ - { 22236, 0x00000307 }, /* GL_ONE_MINUS_DST_COLOR */ - { 22259, 0x00000303 }, /* GL_ONE_MINUS_SRC_ALPHA */ - { 22282, 0x00000301 }, /* GL_ONE_MINUS_SRC_COLOR */ - { 22305, 0x00008598 }, /* GL_OPERAND0_ALPHA */ - { 22323, 0x00008598 }, /* GL_OPERAND0_ALPHA_ARB */ - { 22345, 0x00008598 }, /* GL_OPERAND0_ALPHA_EXT */ - { 22367, 0x00008590 }, /* GL_OPERAND0_RGB */ - { 22383, 0x00008590 }, /* GL_OPERAND0_RGB_ARB */ - { 22403, 0x00008590 }, /* GL_OPERAND0_RGB_EXT */ - { 22423, 0x00008599 }, /* GL_OPERAND1_ALPHA */ - { 22441, 0x00008599 }, /* GL_OPERAND1_ALPHA_ARB */ - { 22463, 0x00008599 }, /* GL_OPERAND1_ALPHA_EXT */ - { 22485, 0x00008591 }, /* GL_OPERAND1_RGB */ - { 22501, 0x00008591 }, /* GL_OPERAND1_RGB_ARB */ - { 22521, 0x00008591 }, /* GL_OPERAND1_RGB_EXT */ - { 22541, 0x0000859A }, /* GL_OPERAND2_ALPHA */ - { 22559, 0x0000859A }, /* GL_OPERAND2_ALPHA_ARB */ - { 22581, 0x0000859A }, /* GL_OPERAND2_ALPHA_EXT */ - { 22603, 0x00008592 }, /* GL_OPERAND2_RGB */ - { 22619, 0x00008592 }, /* GL_OPERAND2_RGB_ARB */ - { 22639, 0x00008592 }, /* GL_OPERAND2_RGB_EXT */ - { 22659, 0x0000859B }, /* GL_OPERAND3_ALPHA_NV */ - { 22680, 0x00008593 }, /* GL_OPERAND3_RGB_NV */ - { 22699, 0x00001507 }, /* GL_OR */ - { 22705, 0x00000A01 }, /* GL_ORDER */ - { 22714, 0x0000150D }, /* GL_OR_INVERTED */ - { 22729, 0x0000150B }, /* GL_OR_REVERSE */ - { 22743, 0x00000505 }, /* GL_OUT_OF_MEMORY */ - { 22760, 0x00000D05 }, /* GL_PACK_ALIGNMENT */ - { 22778, 0x0000806C }, /* GL_PACK_IMAGE_HEIGHT */ - { 22799, 0x00008758 }, /* GL_PACK_INVERT_MESA */ - { 22819, 0x00000D01 }, /* GL_PACK_LSB_FIRST */ - { 22837, 0x00000D02 }, /* GL_PACK_ROW_LENGTH */ - { 22856, 0x0000806B }, /* GL_PACK_SKIP_IMAGES */ - { 22876, 0x00000D04 }, /* GL_PACK_SKIP_PIXELS */ - { 22896, 0x00000D03 }, /* GL_PACK_SKIP_ROWS */ - { 22914, 0x00000D00 }, /* GL_PACK_SWAP_BYTES */ - { 22933, 0x00008B92 }, /* GL_PALETTE4_R5_G6_B5_OES */ - { 22958, 0x00008B94 }, /* GL_PALETTE4_RGB5_A1_OES */ - { 22982, 0x00008B90 }, /* GL_PALETTE4_RGB8_OES */ - { 23003, 0x00008B93 }, /* GL_PALETTE4_RGBA4_OES */ - { 23025, 0x00008B91 }, /* GL_PALETTE4_RGBA8_OES */ - { 23047, 0x00008B97 }, /* GL_PALETTE8_R5_G6_B5_OES */ - { 23072, 0x00008B99 }, /* GL_PALETTE8_RGB5_A1_OES */ - { 23096, 0x00008B95 }, /* GL_PALETTE8_RGB8_OES */ - { 23117, 0x00008B98 }, /* GL_PALETTE8_RGBA4_OES */ - { 23139, 0x00008B96 }, /* GL_PALETTE8_RGBA8_OES */ - { 23161, 0x00000700 }, /* GL_PASS_THROUGH_TOKEN */ - { 23183, 0x00000C50 }, /* GL_PERSPECTIVE_CORRECTION_HINT */ - { 23214, 0x00000C79 }, /* GL_PIXEL_MAP_A_TO_A */ - { 23234, 0x00000CB9 }, /* GL_PIXEL_MAP_A_TO_A_SIZE */ - { 23259, 0x00000C78 }, /* GL_PIXEL_MAP_B_TO_B */ - { 23279, 0x00000CB8 }, /* GL_PIXEL_MAP_B_TO_B_SIZE */ - { 23304, 0x00000C77 }, /* GL_PIXEL_MAP_G_TO_G */ - { 23324, 0x00000CB7 }, /* GL_PIXEL_MAP_G_TO_G_SIZE */ - { 23349, 0x00000C75 }, /* GL_PIXEL_MAP_I_TO_A */ - { 23369, 0x00000CB5 }, /* GL_PIXEL_MAP_I_TO_A_SIZE */ - { 23394, 0x00000C74 }, /* GL_PIXEL_MAP_I_TO_B */ - { 23414, 0x00000CB4 }, /* GL_PIXEL_MAP_I_TO_B_SIZE */ - { 23439, 0x00000C73 }, /* GL_PIXEL_MAP_I_TO_G */ - { 23459, 0x00000CB3 }, /* GL_PIXEL_MAP_I_TO_G_SIZE */ - { 23484, 0x00000C70 }, /* GL_PIXEL_MAP_I_TO_I */ - { 23504, 0x00000CB0 }, /* GL_PIXEL_MAP_I_TO_I_SIZE */ - { 23529, 0x00000C72 }, /* GL_PIXEL_MAP_I_TO_R */ - { 23549, 0x00000CB2 }, /* GL_PIXEL_MAP_I_TO_R_SIZE */ - { 23574, 0x00000C76 }, /* GL_PIXEL_MAP_R_TO_R */ - { 23594, 0x00000CB6 }, /* GL_PIXEL_MAP_R_TO_R_SIZE */ - { 23619, 0x00000C71 }, /* GL_PIXEL_MAP_S_TO_S */ - { 23639, 0x00000CB1 }, /* GL_PIXEL_MAP_S_TO_S_SIZE */ - { 23664, 0x00000020 }, /* GL_PIXEL_MODE_BIT */ - { 23682, 0x000088ED }, /* GL_PIXEL_PACK_BUFFER_BINDING_EXT */ - { 23715, 0x000088EB }, /* GL_PIXEL_PACK_BUFFER_EXT */ - { 23740, 0x000088EF }, /* GL_PIXEL_UNPACK_BUFFER_BINDING_EXT */ - { 23775, 0x000088EC }, /* GL_PIXEL_UNPACK_BUFFER_EXT */ - { 23802, 0x00001B00 }, /* GL_POINT */ - { 23811, 0x00000000 }, /* GL_POINTS */ - { 23821, 0x00000002 }, /* GL_POINT_BIT */ - { 23834, 0x00008129 }, /* GL_POINT_DISTANCE_ATTENUATION */ - { 23864, 0x00008129 }, /* GL_POINT_DISTANCE_ATTENUATION_ARB */ - { 23898, 0x00008129 }, /* GL_POINT_DISTANCE_ATTENUATION_EXT */ - { 23932, 0x00008129 }, /* GL_POINT_DISTANCE_ATTENUATION_SGIS */ - { 23967, 0x00008128 }, /* GL_POINT_FADE_THRESHOLD_SIZE */ - { 23996, 0x00008128 }, /* GL_POINT_FADE_THRESHOLD_SIZE_ARB */ - { 24029, 0x00008128 }, /* GL_POINT_FADE_THRESHOLD_SIZE_EXT */ - { 24062, 0x00008128 }, /* GL_POINT_FADE_THRESHOLD_SIZE_SGIS */ - { 24096, 0x00000B11 }, /* GL_POINT_SIZE */ - { 24110, 0x00000B13 }, /* GL_POINT_SIZE_GRANULARITY */ - { 24136, 0x00008127 }, /* GL_POINT_SIZE_MAX */ - { 24154, 0x00008127 }, /* GL_POINT_SIZE_MAX_ARB */ - { 24176, 0x00008127 }, /* GL_POINT_SIZE_MAX_EXT */ - { 24198, 0x00008127 }, /* GL_POINT_SIZE_MAX_SGIS */ - { 24221, 0x00008126 }, /* GL_POINT_SIZE_MIN */ - { 24239, 0x00008126 }, /* GL_POINT_SIZE_MIN_ARB */ - { 24261, 0x00008126 }, /* GL_POINT_SIZE_MIN_EXT */ - { 24283, 0x00008126 }, /* GL_POINT_SIZE_MIN_SGIS */ - { 24306, 0x00000B12 }, /* GL_POINT_SIZE_RANGE */ - { 24326, 0x00000B10 }, /* GL_POINT_SMOOTH */ - { 24342, 0x00000C51 }, /* GL_POINT_SMOOTH_HINT */ - { 24363, 0x00008861 }, /* GL_POINT_SPRITE */ - { 24379, 0x00008861 }, /* GL_POINT_SPRITE_ARB */ - { 24399, 0x00008CA0 }, /* GL_POINT_SPRITE_COORD_ORIGIN */ - { 24428, 0x00008861 }, /* GL_POINT_SPRITE_NV */ - { 24447, 0x00008863 }, /* GL_POINT_SPRITE_R_MODE_NV */ - { 24473, 0x00000701 }, /* GL_POINT_TOKEN */ - { 24488, 0x00000009 }, /* GL_POLYGON */ - { 24499, 0x00000008 }, /* GL_POLYGON_BIT */ - { 24514, 0x00000B40 }, /* GL_POLYGON_MODE */ - { 24530, 0x00008039 }, /* GL_POLYGON_OFFSET_BIAS */ - { 24553, 0x00008038 }, /* GL_POLYGON_OFFSET_FACTOR */ - { 24578, 0x00008037 }, /* GL_POLYGON_OFFSET_FILL */ - { 24601, 0x00002A02 }, /* GL_POLYGON_OFFSET_LINE */ - { 24624, 0x00002A01 }, /* GL_POLYGON_OFFSET_POINT */ - { 24648, 0x00002A00 }, /* GL_POLYGON_OFFSET_UNITS */ - { 24672, 0x00000B41 }, /* GL_POLYGON_SMOOTH */ - { 24690, 0x00000C53 }, /* GL_POLYGON_SMOOTH_HINT */ - { 24713, 0x00000B42 }, /* GL_POLYGON_STIPPLE */ - { 24732, 0x00000010 }, /* GL_POLYGON_STIPPLE_BIT */ - { 24755, 0x00000703 }, /* GL_POLYGON_TOKEN */ - { 24772, 0x00001203 }, /* GL_POSITION */ - { 24784, 0x000080BB }, /* GL_POST_COLOR_MATRIX_ALPHA_BIAS */ - { 24816, 0x000080BB }, /* GL_POST_COLOR_MATRIX_ALPHA_BIAS_SGI */ - { 24852, 0x000080B7 }, /* GL_POST_COLOR_MATRIX_ALPHA_SCALE */ - { 24885, 0x000080B7 }, /* GL_POST_COLOR_MATRIX_ALPHA_SCALE_SGI */ - { 24922, 0x000080BA }, /* GL_POST_COLOR_MATRIX_BLUE_BIAS */ - { 24953, 0x000080BA }, /* GL_POST_COLOR_MATRIX_BLUE_BIAS_SGI */ - { 24988, 0x000080B6 }, /* GL_POST_COLOR_MATRIX_BLUE_SCALE */ - { 25020, 0x000080B6 }, /* GL_POST_COLOR_MATRIX_BLUE_SCALE_SGI */ - { 25056, 0x000080D2 }, /* GL_POST_COLOR_MATRIX_COLOR_TABLE */ - { 25089, 0x000080B9 }, /* GL_POST_COLOR_MATRIX_GREEN_BIAS */ - { 25121, 0x000080B9 }, /* GL_POST_COLOR_MATRIX_GREEN_BIAS_SGI */ - { 25157, 0x000080B5 }, /* GL_POST_COLOR_MATRIX_GREEN_SCALE */ - { 25190, 0x000080B5 }, /* GL_POST_COLOR_MATRIX_GREEN_SCALE_SGI */ - { 25227, 0x000080B8 }, /* GL_POST_COLOR_MATRIX_RED_BIAS */ - { 25257, 0x000080B8 }, /* GL_POST_COLOR_MATRIX_RED_BIAS_SGI */ - { 25291, 0x000080B4 }, /* GL_POST_COLOR_MATRIX_RED_SCALE */ - { 25322, 0x000080B4 }, /* GL_POST_COLOR_MATRIX_RED_SCALE_SGI */ - { 25357, 0x00008023 }, /* GL_POST_CONVOLUTION_ALPHA_BIAS */ - { 25388, 0x00008023 }, /* GL_POST_CONVOLUTION_ALPHA_BIAS_EXT */ - { 25423, 0x0000801F }, /* GL_POST_CONVOLUTION_ALPHA_SCALE */ - { 25455, 0x0000801F }, /* GL_POST_CONVOLUTION_ALPHA_SCALE_EXT */ - { 25491, 0x00008022 }, /* GL_POST_CONVOLUTION_BLUE_BIAS */ - { 25521, 0x00008022 }, /* GL_POST_CONVOLUTION_BLUE_BIAS_EXT */ - { 25555, 0x0000801E }, /* GL_POST_CONVOLUTION_BLUE_SCALE */ - { 25586, 0x0000801E }, /* GL_POST_CONVOLUTION_BLUE_SCALE_EXT */ - { 25621, 0x000080D1 }, /* GL_POST_CONVOLUTION_COLOR_TABLE */ - { 25653, 0x00008021 }, /* GL_POST_CONVOLUTION_GREEN_BIAS */ - { 25684, 0x00008021 }, /* GL_POST_CONVOLUTION_GREEN_BIAS_EXT */ - { 25719, 0x0000801D }, /* GL_POST_CONVOLUTION_GREEN_SCALE */ - { 25751, 0x0000801D }, /* GL_POST_CONVOLUTION_GREEN_SCALE_EXT */ - { 25787, 0x00008020 }, /* GL_POST_CONVOLUTION_RED_BIAS */ - { 25816, 0x00008020 }, /* GL_POST_CONVOLUTION_RED_BIAS_EXT */ - { 25849, 0x0000801C }, /* GL_POST_CONVOLUTION_RED_SCALE */ - { 25879, 0x0000801C }, /* GL_POST_CONVOLUTION_RED_SCALE_EXT */ - { 25913, 0x0000817B }, /* GL_POST_TEXTURE_FILTER_BIAS_RANGE_SGIX */ - { 25952, 0x00008179 }, /* GL_POST_TEXTURE_FILTER_BIAS_SGIX */ - { 25985, 0x0000817C }, /* GL_POST_TEXTURE_FILTER_SCALE_RANGE_SGIX */ - { 26025, 0x0000817A }, /* GL_POST_TEXTURE_FILTER_SCALE_SGIX */ - { 26059, 0x00008578 }, /* GL_PREVIOUS */ - { 26071, 0x00008578 }, /* GL_PREVIOUS_ARB */ - { 26087, 0x00008578 }, /* GL_PREVIOUS_EXT */ - { 26103, 0x00008577 }, /* GL_PRIMARY_COLOR */ - { 26120, 0x00008577 }, /* GL_PRIMARY_COLOR_ARB */ - { 26141, 0x00008577 }, /* GL_PRIMARY_COLOR_EXT */ - { 26162, 0x000088B0 }, /* GL_PROGRAM_ADDRESS_REGISTERS_ARB */ - { 26195, 0x00008805 }, /* GL_PROGRAM_ALU_INSTRUCTIONS_ARB */ - { 26227, 0x000088AC }, /* GL_PROGRAM_ATTRIBS_ARB */ - { 26250, 0x00008677 }, /* GL_PROGRAM_BINDING_ARB */ - { 26273, 0x0000864B }, /* GL_PROGRAM_ERROR_POSITION_ARB */ - { 26303, 0x0000864B }, /* GL_PROGRAM_ERROR_POSITION_NV */ - { 26332, 0x00008874 }, /* GL_PROGRAM_ERROR_STRING_ARB */ - { 26360, 0x00008876 }, /* GL_PROGRAM_FORMAT_ARB */ - { 26382, 0x00008875 }, /* GL_PROGRAM_FORMAT_ASCII_ARB */ - { 26410, 0x000088A0 }, /* GL_PROGRAM_INSTRUCTIONS_ARB */ - { 26438, 0x00008627 }, /* GL_PROGRAM_LENGTH_ARB */ - { 26460, 0x00008627 }, /* GL_PROGRAM_LENGTH_NV */ - { 26481, 0x000088B2 }, /* GL_PROGRAM_NATIVE_ADDRESS_REGISTERS_ARB */ - { 26521, 0x00008808 }, /* GL_PROGRAM_NATIVE_ALU_INSTRUCTIONS_ARB */ - { 26560, 0x000088AE }, /* GL_PROGRAM_NATIVE_ATTRIBS_ARB */ - { 26590, 0x000088A2 }, /* GL_PROGRAM_NATIVE_INSTRUCTIONS_ARB */ - { 26625, 0x000088AA }, /* GL_PROGRAM_NATIVE_PARAMETERS_ARB */ - { 26658, 0x000088A6 }, /* GL_PROGRAM_NATIVE_TEMPORARIES_ARB */ - { 26692, 0x0000880A }, /* GL_PROGRAM_NATIVE_TEX_INDIRECTIONS_ARB */ - { 26731, 0x00008809 }, /* GL_PROGRAM_NATIVE_TEX_INSTRUCTIONS_ARB */ - { 26770, 0x00008B40 }, /* GL_PROGRAM_OBJECT_ARB */ - { 26792, 0x000088A8 }, /* GL_PROGRAM_PARAMETERS_ARB */ - { 26818, 0x00008644 }, /* GL_PROGRAM_PARAMETER_NV */ - { 26842, 0x00008647 }, /* GL_PROGRAM_RESIDENT_NV */ - { 26865, 0x00008628 }, /* GL_PROGRAM_STRING_ARB */ - { 26887, 0x00008628 }, /* GL_PROGRAM_STRING_NV */ - { 26908, 0x00008646 }, /* GL_PROGRAM_TARGET_NV */ - { 26929, 0x000088A4 }, /* GL_PROGRAM_TEMPORARIES_ARB */ - { 26956, 0x00008807 }, /* GL_PROGRAM_TEX_INDIRECTIONS_ARB */ - { 26988, 0x00008806 }, /* GL_PROGRAM_TEX_INSTRUCTIONS_ARB */ - { 27020, 0x000088B6 }, /* GL_PROGRAM_UNDER_NATIVE_LIMITS_ARB */ - { 27055, 0x00001701 }, /* GL_PROJECTION */ - { 27069, 0x00000BA7 }, /* GL_PROJECTION_MATRIX */ - { 27090, 0x00000BA4 }, /* GL_PROJECTION_STACK_DEPTH */ - { 27116, 0x000080D3 }, /* GL_PROXY_COLOR_TABLE */ - { 27137, 0x00008025 }, /* GL_PROXY_HISTOGRAM */ - { 27156, 0x00008025 }, /* GL_PROXY_HISTOGRAM_EXT */ - { 27179, 0x000080D5 }, /* GL_PROXY_POST_COLOR_MATRIX_COLOR_TABLE */ - { 27218, 0x000080D4 }, /* GL_PROXY_POST_CONVOLUTION_COLOR_TABLE */ - { 27256, 0x00008063 }, /* GL_PROXY_TEXTURE_1D */ - { 27276, 0x00008C19 }, /* GL_PROXY_TEXTURE_1D_ARRAY_EXT */ - { 27306, 0x00008063 }, /* GL_PROXY_TEXTURE_1D_EXT */ - { 27330, 0x00008064 }, /* GL_PROXY_TEXTURE_2D */ - { 27350, 0x00008C1B }, /* GL_PROXY_TEXTURE_2D_ARRAY_EXT */ - { 27380, 0x00008064 }, /* GL_PROXY_TEXTURE_2D_EXT */ - { 27404, 0x00008070 }, /* GL_PROXY_TEXTURE_3D */ - { 27424, 0x000080BD }, /* GL_PROXY_TEXTURE_COLOR_TABLE_SGI */ - { 27457, 0x0000851B }, /* GL_PROXY_TEXTURE_CUBE_MAP */ - { 27483, 0x0000851B }, /* GL_PROXY_TEXTURE_CUBE_MAP_ARB */ - { 27513, 0x000084F7 }, /* GL_PROXY_TEXTURE_RECTANGLE_ARB */ - { 27544, 0x000084F7 }, /* GL_PROXY_TEXTURE_RECTANGLE_NV */ - { 27574, 0x00002003 }, /* GL_Q */ - { 27579, 0x00001209 }, /* GL_QUADRATIC_ATTENUATION */ - { 27604, 0x00000007 }, /* GL_QUADS */ - { 27613, 0x00008614 }, /* GL_QUAD_MESH_SUN */ - { 27630, 0x00000008 }, /* GL_QUAD_STRIP */ - { 27644, 0x00008864 }, /* GL_QUERY_COUNTER_BITS */ - { 27666, 0x00008864 }, /* GL_QUERY_COUNTER_BITS_ARB */ - { 27692, 0x00008866 }, /* GL_QUERY_RESULT */ - { 27708, 0x00008866 }, /* GL_QUERY_RESULT_ARB */ - { 27728, 0x00008867 }, /* GL_QUERY_RESULT_AVAILABLE */ - { 27754, 0x00008867 }, /* GL_QUERY_RESULT_AVAILABLE_ARB */ - { 27784, 0x00002002 }, /* GL_R */ - { 27789, 0x00002A10 }, /* GL_R3_G3_B2 */ - { 27801, 0x00019262 }, /* GL_RASTER_POSITION_UNCLIPPED_IBM */ - { 27834, 0x00000C02 }, /* GL_READ_BUFFER */ - { 27849, 0x00008CA8 }, /* GL_READ_FRAMEBUFFER */ - { 27869, 0x00008CAA }, /* GL_READ_FRAMEBUFFER_BINDING_EXT */ - { 27901, 0x00008CA8 }, /* GL_READ_FRAMEBUFFER_EXT */ - { 27925, 0x000088B8 }, /* GL_READ_ONLY */ - { 27938, 0x000088B8 }, /* GL_READ_ONLY_ARB */ - { 27955, 0x000088BA }, /* GL_READ_WRITE */ - { 27969, 0x000088BA }, /* GL_READ_WRITE_ARB */ - { 27987, 0x00001903 }, /* GL_RED */ - { 27994, 0x00008016 }, /* GL_REDUCE */ - { 28004, 0x00008016 }, /* GL_REDUCE_EXT */ - { 28018, 0x00000D15 }, /* GL_RED_BIAS */ - { 28030, 0x00000D52 }, /* GL_RED_BITS */ - { 28042, 0x00000D14 }, /* GL_RED_SCALE */ - { 28055, 0x00008512 }, /* GL_REFLECTION_MAP */ - { 28073, 0x00008512 }, /* GL_REFLECTION_MAP_ARB */ - { 28095, 0x00008512 }, /* GL_REFLECTION_MAP_NV */ - { 28116, 0x00001C00 }, /* GL_RENDER */ - { 28126, 0x00008D41 }, /* GL_RENDERBUFFER */ - { 28142, 0x00008D53 }, /* GL_RENDERBUFFER_ALPHA_SIZE */ - { 28169, 0x00008CA7 }, /* GL_RENDERBUFFER_BINDING_EXT */ - { 28197, 0x00008D52 }, /* GL_RENDERBUFFER_BLUE_SIZE */ - { 28223, 0x00008D54 }, /* GL_RENDERBUFFER_DEPTH_SIZE */ - { 28250, 0x00008D41 }, /* GL_RENDERBUFFER_EXT */ - { 28270, 0x00008D51 }, /* GL_RENDERBUFFER_GREEN_SIZE */ - { 28297, 0x00008D43 }, /* GL_RENDERBUFFER_HEIGHT */ - { 28320, 0x00008D43 }, /* GL_RENDERBUFFER_HEIGHT_EXT */ - { 28347, 0x00008D44 }, /* GL_RENDERBUFFER_INTERNAL_FORMAT */ - { 28379, 0x00008D44 }, /* GL_RENDERBUFFER_INTERNAL_FORMAT_EXT */ - { 28415, 0x00008D50 }, /* GL_RENDERBUFFER_RED_SIZE */ - { 28440, 0x00008CAB }, /* GL_RENDERBUFFER_SAMPLES */ - { 28464, 0x00008D55 }, /* GL_RENDERBUFFER_STENCIL_SIZE */ - { 28493, 0x00008D42 }, /* GL_RENDERBUFFER_WIDTH */ - { 28515, 0x00008D42 }, /* GL_RENDERBUFFER_WIDTH_EXT */ - { 28541, 0x00001F01 }, /* GL_RENDERER */ - { 28553, 0x00000C40 }, /* GL_RENDER_MODE */ - { 28568, 0x00002901 }, /* GL_REPEAT */ - { 28578, 0x00001E01 }, /* GL_REPLACE */ - { 28589, 0x00008062 }, /* GL_REPLACE_EXT */ - { 28604, 0x00008153 }, /* GL_REPLICATE_BORDER_HP */ - { 28627, 0x0000803A }, /* GL_RESCALE_NORMAL */ - { 28645, 0x0000803A }, /* GL_RESCALE_NORMAL_EXT */ - { 28667, 0x00000102 }, /* GL_RETURN */ - { 28677, 0x00001907 }, /* GL_RGB */ - { 28684, 0x00008052 }, /* GL_RGB10 */ - { 28693, 0x00008059 }, /* GL_RGB10_A2 */ - { 28705, 0x00008059 }, /* GL_RGB10_A2_EXT */ - { 28721, 0x00008052 }, /* GL_RGB10_EXT */ - { 28734, 0x00008053 }, /* GL_RGB12 */ - { 28743, 0x00008053 }, /* GL_RGB12_EXT */ - { 28756, 0x00008054 }, /* GL_RGB16 */ - { 28765, 0x00008054 }, /* GL_RGB16_EXT */ - { 28778, 0x0000804E }, /* GL_RGB2_EXT */ - { 28790, 0x0000804F }, /* GL_RGB4 */ - { 28798, 0x0000804F }, /* GL_RGB4_EXT */ - { 28810, 0x000083A1 }, /* GL_RGB4_S3TC */ - { 28823, 0x00008050 }, /* GL_RGB5 */ - { 28831, 0x00008057 }, /* GL_RGB5_A1 */ - { 28842, 0x00008057 }, /* GL_RGB5_A1_EXT */ - { 28857, 0x00008050 }, /* GL_RGB5_EXT */ - { 28869, 0x00008051 }, /* GL_RGB8 */ - { 28877, 0x00008051 }, /* GL_RGB8_EXT */ - { 28889, 0x00001908 }, /* GL_RGBA */ - { 28897, 0x0000805A }, /* GL_RGBA12 */ - { 28907, 0x0000805A }, /* GL_RGBA12_EXT */ - { 28921, 0x0000805B }, /* GL_RGBA16 */ - { 28931, 0x0000805B }, /* GL_RGBA16_EXT */ - { 28945, 0x00008055 }, /* GL_RGBA2 */ - { 28954, 0x00008055 }, /* GL_RGBA2_EXT */ - { 28967, 0x00008056 }, /* GL_RGBA4 */ - { 28976, 0x000083A5 }, /* GL_RGBA4_DXT5_S3TC */ - { 28995, 0x00008056 }, /* GL_RGBA4_EXT */ - { 29008, 0x000083A3 }, /* GL_RGBA4_S3TC */ - { 29022, 0x00008058 }, /* GL_RGBA8 */ - { 29031, 0x00008058 }, /* GL_RGBA8_EXT */ - { 29044, 0x000083A4 }, /* GL_RGBA_DXT5_S3TC */ - { 29062, 0x00000C31 }, /* GL_RGBA_MODE */ - { 29075, 0x000083A2 }, /* GL_RGBA_S3TC */ - { 29088, 0x000083A0 }, /* GL_RGB_S3TC */ - { 29100, 0x00008573 }, /* GL_RGB_SCALE */ - { 29113, 0x00008573 }, /* GL_RGB_SCALE_ARB */ - { 29130, 0x00008573 }, /* GL_RGB_SCALE_EXT */ - { 29147, 0x00000407 }, /* GL_RIGHT */ - { 29156, 0x00002000 }, /* GL_S */ - { 29161, 0x00008B5D }, /* GL_SAMPLER_1D */ - { 29175, 0x00008B61 }, /* GL_SAMPLER_1D_SHADOW */ - { 29196, 0x00008B5E }, /* GL_SAMPLER_2D */ - { 29210, 0x00008B62 }, /* GL_SAMPLER_2D_SHADOW */ - { 29231, 0x00008B5F }, /* GL_SAMPLER_3D */ - { 29245, 0x00008B60 }, /* GL_SAMPLER_CUBE */ - { 29261, 0x000080A9 }, /* GL_SAMPLES */ - { 29272, 0x000086B4 }, /* GL_SAMPLES_3DFX */ - { 29288, 0x000080A9 }, /* GL_SAMPLES_ARB */ - { 29303, 0x00008914 }, /* GL_SAMPLES_PASSED */ - { 29321, 0x00008914 }, /* GL_SAMPLES_PASSED_ARB */ - { 29343, 0x0000809E }, /* GL_SAMPLE_ALPHA_TO_COVERAGE */ - { 29371, 0x0000809E }, /* GL_SAMPLE_ALPHA_TO_COVERAGE_ARB */ - { 29403, 0x0000809F }, /* GL_SAMPLE_ALPHA_TO_ONE */ - { 29426, 0x0000809F }, /* GL_SAMPLE_ALPHA_TO_ONE_ARB */ - { 29453, 0x000080A8 }, /* GL_SAMPLE_BUFFERS */ - { 29471, 0x000086B3 }, /* GL_SAMPLE_BUFFERS_3DFX */ - { 29494, 0x000080A8 }, /* GL_SAMPLE_BUFFERS_ARB */ - { 29516, 0x000080A0 }, /* GL_SAMPLE_COVERAGE */ - { 29535, 0x000080A0 }, /* GL_SAMPLE_COVERAGE_ARB */ - { 29558, 0x000080AB }, /* GL_SAMPLE_COVERAGE_INVERT */ - { 29584, 0x000080AB }, /* GL_SAMPLE_COVERAGE_INVERT_ARB */ - { 29614, 0x000080AA }, /* GL_SAMPLE_COVERAGE_VALUE */ - { 29639, 0x000080AA }, /* GL_SAMPLE_COVERAGE_VALUE_ARB */ - { 29668, 0x00080000 }, /* GL_SCISSOR_BIT */ - { 29683, 0x00000C10 }, /* GL_SCISSOR_BOX */ - { 29698, 0x00000C11 }, /* GL_SCISSOR_TEST */ - { 29714, 0x0000845E }, /* GL_SECONDARY_COLOR_ARRAY */ - { 29739, 0x0000889C }, /* GL_SECONDARY_COLOR_ARRAY_BUFFER_BINDING */ - { 29779, 0x0000889C }, /* GL_SECONDARY_COLOR_ARRAY_BUFFER_BINDING_ARB */ - { 29823, 0x0000845D }, /* GL_SECONDARY_COLOR_ARRAY_POINTER */ - { 29856, 0x0000845A }, /* GL_SECONDARY_COLOR_ARRAY_SIZE */ - { 29886, 0x0000845C }, /* GL_SECONDARY_COLOR_ARRAY_STRIDE */ - { 29918, 0x0000845B }, /* GL_SECONDARY_COLOR_ARRAY_TYPE */ - { 29948, 0x00001C02 }, /* GL_SELECT */ - { 29958, 0x00000DF3 }, /* GL_SELECTION_BUFFER_POINTER */ - { 29986, 0x00000DF4 }, /* GL_SELECTION_BUFFER_SIZE */ - { 30011, 0x00008012 }, /* GL_SEPARABLE_2D */ - { 30027, 0x000081FA }, /* GL_SEPARATE_SPECULAR_COLOR */ - { 30054, 0x000081FA }, /* GL_SEPARATE_SPECULAR_COLOR_EXT */ - { 30085, 0x0000150F }, /* GL_SET */ - { 30092, 0x00008B48 }, /* GL_SHADER_OBJECT_ARB */ - { 30113, 0x00008B88 }, /* GL_SHADER_SOURCE_LENGTH */ - { 30137, 0x00008B4F }, /* GL_SHADER_TYPE */ - { 30152, 0x00000B54 }, /* GL_SHADE_MODEL */ - { 30167, 0x00008B8C }, /* GL_SHADING_LANGUAGE_VERSION */ - { 30195, 0x000080BF }, /* GL_SHADOW_AMBIENT_SGIX */ - { 30218, 0x000081FB }, /* GL_SHARED_TEXTURE_PALETTE_EXT */ - { 30248, 0x00001601 }, /* GL_SHININESS */ - { 30261, 0x00001402 }, /* GL_SHORT */ - { 30270, 0x000081F9 }, /* GL_SINGLE_COLOR */ - { 30286, 0x000081F9 }, /* GL_SINGLE_COLOR_EXT */ - { 30306, 0x000085CC }, /* GL_SLICE_ACCUM_SUN */ - { 30325, 0x00001D01 }, /* GL_SMOOTH */ - { 30335, 0x00000B23 }, /* GL_SMOOTH_LINE_WIDTH_GRANULARITY */ - { 30368, 0x00000B22 }, /* GL_SMOOTH_LINE_WIDTH_RANGE */ - { 30395, 0x00000B13 }, /* GL_SMOOTH_POINT_SIZE_GRANULARITY */ - { 30428, 0x00000B12 }, /* GL_SMOOTH_POINT_SIZE_RANGE */ - { 30455, 0x00008588 }, /* GL_SOURCE0_ALPHA */ - { 30472, 0x00008588 }, /* GL_SOURCE0_ALPHA_ARB */ - { 30493, 0x00008588 }, /* GL_SOURCE0_ALPHA_EXT */ - { 30514, 0x00008580 }, /* GL_SOURCE0_RGB */ - { 30529, 0x00008580 }, /* GL_SOURCE0_RGB_ARB */ - { 30548, 0x00008580 }, /* GL_SOURCE0_RGB_EXT */ - { 30567, 0x00008589 }, /* GL_SOURCE1_ALPHA */ - { 30584, 0x00008589 }, /* GL_SOURCE1_ALPHA_ARB */ - { 30605, 0x00008589 }, /* GL_SOURCE1_ALPHA_EXT */ - { 30626, 0x00008581 }, /* GL_SOURCE1_RGB */ - { 30641, 0x00008581 }, /* GL_SOURCE1_RGB_ARB */ - { 30660, 0x00008581 }, /* GL_SOURCE1_RGB_EXT */ - { 30679, 0x0000858A }, /* GL_SOURCE2_ALPHA */ - { 30696, 0x0000858A }, /* GL_SOURCE2_ALPHA_ARB */ - { 30717, 0x0000858A }, /* GL_SOURCE2_ALPHA_EXT */ - { 30738, 0x00008582 }, /* GL_SOURCE2_RGB */ - { 30753, 0x00008582 }, /* GL_SOURCE2_RGB_ARB */ - { 30772, 0x00008582 }, /* GL_SOURCE2_RGB_EXT */ - { 30791, 0x0000858B }, /* GL_SOURCE3_ALPHA_NV */ - { 30811, 0x00008583 }, /* GL_SOURCE3_RGB_NV */ - { 30829, 0x00001202 }, /* GL_SPECULAR */ - { 30841, 0x00002402 }, /* GL_SPHERE_MAP */ - { 30855, 0x00001206 }, /* GL_SPOT_CUTOFF */ - { 30870, 0x00001204 }, /* GL_SPOT_DIRECTION */ - { 30888, 0x00001205 }, /* GL_SPOT_EXPONENT */ - { 30905, 0x00008588 }, /* GL_SRC0_ALPHA */ - { 30919, 0x00008580 }, /* GL_SRC0_RGB */ - { 30931, 0x00008589 }, /* GL_SRC1_ALPHA */ - { 30945, 0x00008581 }, /* GL_SRC1_RGB */ - { 30957, 0x0000858A }, /* GL_SRC2_ALPHA */ - { 30971, 0x00008582 }, /* GL_SRC2_RGB */ - { 30983, 0x00000302 }, /* GL_SRC_ALPHA */ - { 30996, 0x00000308 }, /* GL_SRC_ALPHA_SATURATE */ - { 31018, 0x00000300 }, /* GL_SRC_COLOR */ - { 31031, 0x00008C40 }, /* GL_SRGB */ - { 31039, 0x00000503 }, /* GL_STACK_OVERFLOW */ - { 31057, 0x00000504 }, /* GL_STACK_UNDERFLOW */ - { 31076, 0x000088E6 }, /* GL_STATIC_COPY */ - { 31091, 0x000088E6 }, /* GL_STATIC_COPY_ARB */ - { 31110, 0x000088E4 }, /* GL_STATIC_DRAW */ - { 31125, 0x000088E4 }, /* GL_STATIC_DRAW_ARB */ - { 31144, 0x000088E5 }, /* GL_STATIC_READ */ - { 31159, 0x000088E5 }, /* GL_STATIC_READ_ARB */ - { 31178, 0x00001802 }, /* GL_STENCIL */ - { 31189, 0x00008D20 }, /* GL_STENCIL_ATTACHMENT */ - { 31211, 0x00008D20 }, /* GL_STENCIL_ATTACHMENT_EXT */ - { 31237, 0x00008801 }, /* GL_STENCIL_BACK_FAIL */ - { 31258, 0x00008801 }, /* GL_STENCIL_BACK_FAIL_ATI */ - { 31283, 0x00008800 }, /* GL_STENCIL_BACK_FUNC */ - { 31304, 0x00008800 }, /* GL_STENCIL_BACK_FUNC_ATI */ - { 31329, 0x00008802 }, /* GL_STENCIL_BACK_PASS_DEPTH_FAIL */ - { 31361, 0x00008802 }, /* GL_STENCIL_BACK_PASS_DEPTH_FAIL_ATI */ - { 31397, 0x00008803 }, /* GL_STENCIL_BACK_PASS_DEPTH_PASS */ - { 31429, 0x00008803 }, /* GL_STENCIL_BACK_PASS_DEPTH_PASS_ATI */ - { 31465, 0x00008CA3 }, /* GL_STENCIL_BACK_REF */ - { 31485, 0x00008CA4 }, /* GL_STENCIL_BACK_VALUE_MASK */ - { 31512, 0x00008CA5 }, /* GL_STENCIL_BACK_WRITEMASK */ - { 31538, 0x00000D57 }, /* GL_STENCIL_BITS */ - { 31554, 0x00000400 }, /* GL_STENCIL_BUFFER_BIT */ - { 31576, 0x00000B91 }, /* GL_STENCIL_CLEAR_VALUE */ - { 31599, 0x00000B94 }, /* GL_STENCIL_FAIL */ - { 31615, 0x00000B92 }, /* GL_STENCIL_FUNC */ - { 31631, 0x00001901 }, /* GL_STENCIL_INDEX */ - { 31648, 0x00008D49 }, /* GL_STENCIL_INDEX16_EXT */ - { 31671, 0x00008D46 }, /* GL_STENCIL_INDEX1_EXT */ - { 31693, 0x00008D47 }, /* GL_STENCIL_INDEX4_EXT */ - { 31715, 0x00008D48 }, /* GL_STENCIL_INDEX8_EXT */ - { 31737, 0x00008D45 }, /* GL_STENCIL_INDEX_EXT */ - { 31758, 0x00000B95 }, /* GL_STENCIL_PASS_DEPTH_FAIL */ - { 31785, 0x00000B96 }, /* GL_STENCIL_PASS_DEPTH_PASS */ - { 31812, 0x00000B97 }, /* GL_STENCIL_REF */ - { 31827, 0x00000B90 }, /* GL_STENCIL_TEST */ - { 31843, 0x00008910 }, /* GL_STENCIL_TEST_TWO_SIDE_EXT */ - { 31872, 0x00000B93 }, /* GL_STENCIL_VALUE_MASK */ - { 31894, 0x00000B98 }, /* GL_STENCIL_WRITEMASK */ - { 31915, 0x00000C33 }, /* GL_STEREO */ - { 31925, 0x000088E2 }, /* GL_STREAM_COPY */ - { 31940, 0x000088E2 }, /* GL_STREAM_COPY_ARB */ - { 31959, 0x000088E0 }, /* GL_STREAM_DRAW */ - { 31974, 0x000088E0 }, /* GL_STREAM_DRAW_ARB */ - { 31993, 0x000088E1 }, /* GL_STREAM_READ */ - { 32008, 0x000088E1 }, /* GL_STREAM_READ_ARB */ - { 32027, 0x00000D50 }, /* GL_SUBPIXEL_BITS */ - { 32044, 0x000084E7 }, /* GL_SUBTRACT */ - { 32056, 0x000084E7 }, /* GL_SUBTRACT_ARB */ - { 32072, 0x00002001 }, /* GL_T */ - { 32077, 0x00002A2A }, /* GL_T2F_C3F_V3F */ - { 32092, 0x00002A2C }, /* GL_T2F_C4F_N3F_V3F */ - { 32111, 0x00002A29 }, /* GL_T2F_C4UB_V3F */ - { 32127, 0x00002A2B }, /* GL_T2F_N3F_V3F */ - { 32142, 0x00002A27 }, /* GL_T2F_V3F */ - { 32153, 0x00002A2D }, /* GL_T4F_C4F_N3F_V4F */ - { 32172, 0x00002A28 }, /* GL_T4F_V4F */ - { 32183, 0x00008031 }, /* GL_TABLE_TOO_LARGE_EXT */ - { 32206, 0x00001702 }, /* GL_TEXTURE */ - { 32217, 0x000084C0 }, /* GL_TEXTURE0 */ - { 32229, 0x000084C0 }, /* GL_TEXTURE0_ARB */ - { 32245, 0x000084C1 }, /* GL_TEXTURE1 */ - { 32257, 0x000084CA }, /* GL_TEXTURE10 */ - { 32270, 0x000084CA }, /* GL_TEXTURE10_ARB */ - { 32287, 0x000084CB }, /* GL_TEXTURE11 */ - { 32300, 0x000084CB }, /* GL_TEXTURE11_ARB */ - { 32317, 0x000084CC }, /* GL_TEXTURE12 */ - { 32330, 0x000084CC }, /* GL_TEXTURE12_ARB */ - { 32347, 0x000084CD }, /* GL_TEXTURE13 */ - { 32360, 0x000084CD }, /* GL_TEXTURE13_ARB */ - { 32377, 0x000084CE }, /* GL_TEXTURE14 */ - { 32390, 0x000084CE }, /* GL_TEXTURE14_ARB */ - { 32407, 0x000084CF }, /* GL_TEXTURE15 */ - { 32420, 0x000084CF }, /* GL_TEXTURE15_ARB */ - { 32437, 0x000084D0 }, /* GL_TEXTURE16 */ - { 32450, 0x000084D0 }, /* GL_TEXTURE16_ARB */ - { 32467, 0x000084D1 }, /* GL_TEXTURE17 */ - { 32480, 0x000084D1 }, /* GL_TEXTURE17_ARB */ - { 32497, 0x000084D2 }, /* GL_TEXTURE18 */ - { 32510, 0x000084D2 }, /* GL_TEXTURE18_ARB */ - { 32527, 0x000084D3 }, /* GL_TEXTURE19 */ - { 32540, 0x000084D3 }, /* GL_TEXTURE19_ARB */ - { 32557, 0x000084C1 }, /* GL_TEXTURE1_ARB */ - { 32573, 0x000084C2 }, /* GL_TEXTURE2 */ - { 32585, 0x000084D4 }, /* GL_TEXTURE20 */ - { 32598, 0x000084D4 }, /* GL_TEXTURE20_ARB */ - { 32615, 0x000084D5 }, /* GL_TEXTURE21 */ - { 32628, 0x000084D5 }, /* GL_TEXTURE21_ARB */ - { 32645, 0x000084D6 }, /* GL_TEXTURE22 */ - { 32658, 0x000084D6 }, /* GL_TEXTURE22_ARB */ - { 32675, 0x000084D7 }, /* GL_TEXTURE23 */ - { 32688, 0x000084D7 }, /* GL_TEXTURE23_ARB */ - { 32705, 0x000084D8 }, /* GL_TEXTURE24 */ - { 32718, 0x000084D8 }, /* GL_TEXTURE24_ARB */ - { 32735, 0x000084D9 }, /* GL_TEXTURE25 */ - { 32748, 0x000084D9 }, /* GL_TEXTURE25_ARB */ - { 32765, 0x000084DA }, /* GL_TEXTURE26 */ - { 32778, 0x000084DA }, /* GL_TEXTURE26_ARB */ - { 32795, 0x000084DB }, /* GL_TEXTURE27 */ - { 32808, 0x000084DB }, /* GL_TEXTURE27_ARB */ - { 32825, 0x000084DC }, /* GL_TEXTURE28 */ - { 32838, 0x000084DC }, /* GL_TEXTURE28_ARB */ - { 32855, 0x000084DD }, /* GL_TEXTURE29 */ - { 32868, 0x000084DD }, /* GL_TEXTURE29_ARB */ - { 32885, 0x000084C2 }, /* GL_TEXTURE2_ARB */ - { 32901, 0x000084C3 }, /* GL_TEXTURE3 */ - { 32913, 0x000084DE }, /* GL_TEXTURE30 */ - { 32926, 0x000084DE }, /* GL_TEXTURE30_ARB */ - { 32943, 0x000084DF }, /* GL_TEXTURE31 */ - { 32956, 0x000084DF }, /* GL_TEXTURE31_ARB */ - { 32973, 0x000084C3 }, /* GL_TEXTURE3_ARB */ - { 32989, 0x000084C4 }, /* GL_TEXTURE4 */ - { 33001, 0x000084C4 }, /* GL_TEXTURE4_ARB */ - { 33017, 0x000084C5 }, /* GL_TEXTURE5 */ - { 33029, 0x000084C5 }, /* GL_TEXTURE5_ARB */ - { 33045, 0x000084C6 }, /* GL_TEXTURE6 */ - { 33057, 0x000084C6 }, /* GL_TEXTURE6_ARB */ - { 33073, 0x000084C7 }, /* GL_TEXTURE7 */ - { 33085, 0x000084C7 }, /* GL_TEXTURE7_ARB */ - { 33101, 0x000084C8 }, /* GL_TEXTURE8 */ - { 33113, 0x000084C8 }, /* GL_TEXTURE8_ARB */ - { 33129, 0x000084C9 }, /* GL_TEXTURE9 */ - { 33141, 0x000084C9 }, /* GL_TEXTURE9_ARB */ - { 33157, 0x00000DE0 }, /* GL_TEXTURE_1D */ - { 33171, 0x00008C18 }, /* GL_TEXTURE_1D_ARRAY_EXT */ - { 33195, 0x00000DE1 }, /* GL_TEXTURE_2D */ - { 33209, 0x00008C1A }, /* GL_TEXTURE_2D_ARRAY_EXT */ - { 33233, 0x0000806F }, /* GL_TEXTURE_3D */ - { 33247, 0x0000805F }, /* GL_TEXTURE_ALPHA_SIZE */ - { 33269, 0x0000805F }, /* GL_TEXTURE_ALPHA_SIZE_EXT */ - { 33295, 0x0000813C }, /* GL_TEXTURE_BASE_LEVEL */ - { 33317, 0x00008068 }, /* GL_TEXTURE_BINDING_1D */ - { 33339, 0x00008C1C }, /* GL_TEXTURE_BINDING_1D_ARRAY_EXT */ - { 33371, 0x00008069 }, /* GL_TEXTURE_BINDING_2D */ - { 33393, 0x00008C1D }, /* GL_TEXTURE_BINDING_2D_ARRAY_EXT */ - { 33425, 0x0000806A }, /* GL_TEXTURE_BINDING_3D */ - { 33447, 0x00008514 }, /* GL_TEXTURE_BINDING_CUBE_MAP */ - { 33475, 0x00008514 }, /* GL_TEXTURE_BINDING_CUBE_MAP_ARB */ - { 33507, 0x000084F6 }, /* GL_TEXTURE_BINDING_RECTANGLE_ARB */ - { 33540, 0x000084F6 }, /* GL_TEXTURE_BINDING_RECTANGLE_NV */ - { 33572, 0x00040000 }, /* GL_TEXTURE_BIT */ - { 33587, 0x0000805E }, /* GL_TEXTURE_BLUE_SIZE */ - { 33608, 0x0000805E }, /* GL_TEXTURE_BLUE_SIZE_EXT */ - { 33633, 0x00001005 }, /* GL_TEXTURE_BORDER */ - { 33651, 0x00001004 }, /* GL_TEXTURE_BORDER_COLOR */ - { 33675, 0x00008171 }, /* GL_TEXTURE_CLIPMAP_CENTER_SGIX */ - { 33706, 0x00008176 }, /* GL_TEXTURE_CLIPMAP_DEPTH_SGIX */ - { 33736, 0x00008172 }, /* GL_TEXTURE_CLIPMAP_FRAME_SGIX */ - { 33766, 0x00008175 }, /* GL_TEXTURE_CLIPMAP_LOD_OFFSET_SGIX */ - { 33801, 0x00008173 }, /* GL_TEXTURE_CLIPMAP_OFFSET_SGIX */ - { 33832, 0x00008174 }, /* GL_TEXTURE_CLIPMAP_VIRTUAL_DEPTH_SGIX */ - { 33870, 0x000080BC }, /* GL_TEXTURE_COLOR_TABLE_SGI */ - { 33897, 0x000081EF }, /* GL_TEXTURE_COLOR_WRITEMASK_SGIS */ - { 33929, 0x000080BF }, /* GL_TEXTURE_COMPARE_FAIL_VALUE_ARB */ - { 33963, 0x0000884D }, /* GL_TEXTURE_COMPARE_FUNC */ - { 33987, 0x0000884D }, /* GL_TEXTURE_COMPARE_FUNC_ARB */ - { 34015, 0x0000884C }, /* GL_TEXTURE_COMPARE_MODE */ - { 34039, 0x0000884C }, /* GL_TEXTURE_COMPARE_MODE_ARB */ - { 34067, 0x0000819B }, /* GL_TEXTURE_COMPARE_OPERATOR_SGIX */ - { 34100, 0x0000819A }, /* GL_TEXTURE_COMPARE_SGIX */ - { 34124, 0x00001003 }, /* GL_TEXTURE_COMPONENTS */ - { 34146, 0x000086A1 }, /* GL_TEXTURE_COMPRESSED */ - { 34168, 0x000086A1 }, /* GL_TEXTURE_COMPRESSED_ARB */ - { 34194, 0x000086A3 }, /* GL_TEXTURE_COMPRESSED_FORMATS_ARB */ - { 34228, 0x000086A0 }, /* GL_TEXTURE_COMPRESSED_IMAGE_SIZE */ - { 34261, 0x000086A0 }, /* GL_TEXTURE_COMPRESSED_IMAGE_SIZE_ARB */ - { 34298, 0x000084EF }, /* GL_TEXTURE_COMPRESSION_HINT */ - { 34326, 0x000084EF }, /* GL_TEXTURE_COMPRESSION_HINT_ARB */ - { 34358, 0x00008078 }, /* GL_TEXTURE_COORD_ARRAY */ - { 34381, 0x0000889A }, /* GL_TEXTURE_COORD_ARRAY_BUFFER_BINDING */ - { 34419, 0x0000889A }, /* GL_TEXTURE_COORD_ARRAY_BUFFER_BINDING_ARB */ - { 34461, 0x00008092 }, /* GL_TEXTURE_COORD_ARRAY_POINTER */ - { 34492, 0x00008088 }, /* GL_TEXTURE_COORD_ARRAY_SIZE */ - { 34520, 0x0000808A }, /* GL_TEXTURE_COORD_ARRAY_STRIDE */ - { 34550, 0x00008089 }, /* GL_TEXTURE_COORD_ARRAY_TYPE */ - { 34578, 0x00008513 }, /* GL_TEXTURE_CUBE_MAP */ - { 34598, 0x00008513 }, /* GL_TEXTURE_CUBE_MAP_ARB */ - { 34622, 0x00008516 }, /* GL_TEXTURE_CUBE_MAP_NEGATIVE_X */ - { 34653, 0x00008516 }, /* GL_TEXTURE_CUBE_MAP_NEGATIVE_X_ARB */ - { 34688, 0x00008518 }, /* GL_TEXTURE_CUBE_MAP_NEGATIVE_Y */ - { 34719, 0x00008518 }, /* GL_TEXTURE_CUBE_MAP_NEGATIVE_Y_ARB */ - { 34754, 0x0000851A }, /* GL_TEXTURE_CUBE_MAP_NEGATIVE_Z */ - { 34785, 0x0000851A }, /* GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_ARB */ - { 34820, 0x00008515 }, /* GL_TEXTURE_CUBE_MAP_POSITIVE_X */ - { 34851, 0x00008515 }, /* GL_TEXTURE_CUBE_MAP_POSITIVE_X_ARB */ - { 34886, 0x00008517 }, /* GL_TEXTURE_CUBE_MAP_POSITIVE_Y */ - { 34917, 0x00008517 }, /* GL_TEXTURE_CUBE_MAP_POSITIVE_Y_ARB */ - { 34952, 0x00008519 }, /* GL_TEXTURE_CUBE_MAP_POSITIVE_Z */ - { 34983, 0x00008519 }, /* GL_TEXTURE_CUBE_MAP_POSITIVE_Z_ARB */ - { 35018, 0x00008071 }, /* GL_TEXTURE_DEPTH */ - { 35035, 0x0000884A }, /* GL_TEXTURE_DEPTH_SIZE */ - { 35057, 0x0000884A }, /* GL_TEXTURE_DEPTH_SIZE_ARB */ - { 35083, 0x00002300 }, /* GL_TEXTURE_ENV */ - { 35098, 0x00002201 }, /* GL_TEXTURE_ENV_COLOR */ - { 35119, 0x00002200 }, /* GL_TEXTURE_ENV_MODE */ - { 35139, 0x00008500 }, /* GL_TEXTURE_FILTER_CONTROL */ - { 35165, 0x00002500 }, /* GL_TEXTURE_GEN_MODE */ - { 35185, 0x00000C63 }, /* GL_TEXTURE_GEN_Q */ - { 35202, 0x00000C62 }, /* GL_TEXTURE_GEN_R */ - { 35219, 0x00000C60 }, /* GL_TEXTURE_GEN_S */ - { 35236, 0x00000C61 }, /* GL_TEXTURE_GEN_T */ - { 35253, 0x0000819D }, /* GL_TEXTURE_GEQUAL_R_SGIX */ - { 35278, 0x0000805D }, /* GL_TEXTURE_GREEN_SIZE */ - { 35300, 0x0000805D }, /* GL_TEXTURE_GREEN_SIZE_EXT */ - { 35326, 0x00001001 }, /* GL_TEXTURE_HEIGHT */ - { 35344, 0x000080ED }, /* GL_TEXTURE_INDEX_SIZE_EXT */ - { 35370, 0x00008061 }, /* GL_TEXTURE_INTENSITY_SIZE */ - { 35396, 0x00008061 }, /* GL_TEXTURE_INTENSITY_SIZE_EXT */ - { 35426, 0x00001003 }, /* GL_TEXTURE_INTERNAL_FORMAT */ - { 35453, 0x0000819C }, /* GL_TEXTURE_LEQUAL_R_SGIX */ - { 35478, 0x00008501 }, /* GL_TEXTURE_LOD_BIAS */ - { 35498, 0x00008501 }, /* GL_TEXTURE_LOD_BIAS_EXT */ - { 35522, 0x00008190 }, /* GL_TEXTURE_LOD_BIAS_R_SGIX */ - { 35549, 0x0000818E }, /* GL_TEXTURE_LOD_BIAS_S_SGIX */ - { 35576, 0x0000818F }, /* GL_TEXTURE_LOD_BIAS_T_SGIX */ - { 35603, 0x00008060 }, /* GL_TEXTURE_LUMINANCE_SIZE */ - { 35629, 0x00008060 }, /* GL_TEXTURE_LUMINANCE_SIZE_EXT */ - { 35659, 0x00002800 }, /* GL_TEXTURE_MAG_FILTER */ - { 35681, 0x00000BA8 }, /* GL_TEXTURE_MATRIX */ - { 35699, 0x000084FE }, /* GL_TEXTURE_MAX_ANISOTROPY_EXT */ - { 35729, 0x0000836B }, /* GL_TEXTURE_MAX_CLAMP_R_SGIX */ - { 35757, 0x00008369 }, /* GL_TEXTURE_MAX_CLAMP_S_SGIX */ - { 35785, 0x0000836A }, /* GL_TEXTURE_MAX_CLAMP_T_SGIX */ - { 35813, 0x0000813D }, /* GL_TEXTURE_MAX_LEVEL */ - { 35834, 0x0000813B }, /* GL_TEXTURE_MAX_LOD */ - { 35853, 0x00002801 }, /* GL_TEXTURE_MIN_FILTER */ - { 35875, 0x0000813A }, /* GL_TEXTURE_MIN_LOD */ - { 35894, 0x00008066 }, /* GL_TEXTURE_PRIORITY */ - { 35914, 0x000084F5 }, /* GL_TEXTURE_RECTANGLE_ARB */ - { 35939, 0x000084F5 }, /* GL_TEXTURE_RECTANGLE_NV */ - { 35963, 0x0000805C }, /* GL_TEXTURE_RED_SIZE */ - { 35983, 0x0000805C }, /* GL_TEXTURE_RED_SIZE_EXT */ - { 36007, 0x00008067 }, /* GL_TEXTURE_RESIDENT */ - { 36027, 0x00000BA5 }, /* GL_TEXTURE_STACK_DEPTH */ - { 36050, 0x000088F1 }, /* GL_TEXTURE_STENCIL_SIZE */ - { 36074, 0x00008065 }, /* GL_TEXTURE_TOO_LARGE_EXT */ - { 36099, 0x0000888F }, /* GL_TEXTURE_UNSIGNED_REMAP_MODE_NV */ - { 36133, 0x00001000 }, /* GL_TEXTURE_WIDTH */ - { 36150, 0x00008072 }, /* GL_TEXTURE_WRAP_R */ - { 36168, 0x00002802 }, /* GL_TEXTURE_WRAP_S */ - { 36186, 0x00002803 }, /* GL_TEXTURE_WRAP_T */ - { 36204, 0x000088BF }, /* GL_TIME_ELAPSED_EXT */ - { 36224, 0x00008648 }, /* GL_TRACK_MATRIX_NV */ - { 36243, 0x00008649 }, /* GL_TRACK_MATRIX_TRANSFORM_NV */ - { 36272, 0x00001000 }, /* GL_TRANSFORM_BIT */ - { 36289, 0x000084E6 }, /* GL_TRANSPOSE_COLOR_MATRIX */ - { 36315, 0x000084E6 }, /* GL_TRANSPOSE_COLOR_MATRIX_ARB */ - { 36345, 0x000088B7 }, /* GL_TRANSPOSE_CURRENT_MATRIX_ARB */ - { 36377, 0x000084E3 }, /* GL_TRANSPOSE_MODELVIEW_MATRIX */ - { 36407, 0x000084E3 }, /* GL_TRANSPOSE_MODELVIEW_MATRIX_ARB */ - { 36441, 0x0000862C }, /* GL_TRANSPOSE_NV */ - { 36457, 0x000084E4 }, /* GL_TRANSPOSE_PROJECTION_MATRIX */ - { 36488, 0x000084E4 }, /* GL_TRANSPOSE_PROJECTION_MATRIX_ARB */ - { 36523, 0x000084E5 }, /* GL_TRANSPOSE_TEXTURE_MATRIX */ - { 36551, 0x000084E5 }, /* GL_TRANSPOSE_TEXTURE_MATRIX_ARB */ - { 36583, 0x00000004 }, /* GL_TRIANGLES */ - { 36596, 0x00000006 }, /* GL_TRIANGLE_FAN */ - { 36612, 0x00008615 }, /* GL_TRIANGLE_MESH_SUN */ - { 36633, 0x00000005 }, /* GL_TRIANGLE_STRIP */ - { 36651, 0x00000001 }, /* GL_TRUE */ - { 36659, 0x00000CF5 }, /* GL_UNPACK_ALIGNMENT */ - { 36679, 0x0000806E }, /* GL_UNPACK_IMAGE_HEIGHT */ - { 36702, 0x00000CF1 }, /* GL_UNPACK_LSB_FIRST */ - { 36722, 0x00000CF2 }, /* GL_UNPACK_ROW_LENGTH */ - { 36743, 0x0000806D }, /* GL_UNPACK_SKIP_IMAGES */ - { 36765, 0x00000CF4 }, /* GL_UNPACK_SKIP_PIXELS */ - { 36787, 0x00000CF3 }, /* GL_UNPACK_SKIP_ROWS */ - { 36807, 0x00000CF0 }, /* GL_UNPACK_SWAP_BYTES */ - { 36828, 0x00001401 }, /* GL_UNSIGNED_BYTE */ - { 36845, 0x00008362 }, /* GL_UNSIGNED_BYTE_2_3_3_REV */ - { 36872, 0x00008032 }, /* GL_UNSIGNED_BYTE_3_3_2 */ - { 36895, 0x00001405 }, /* GL_UNSIGNED_INT */ - { 36911, 0x00008036 }, /* GL_UNSIGNED_INT_10_10_10_2 */ - { 36938, 0x000084FA }, /* GL_UNSIGNED_INT_24_8 */ - { 36959, 0x000084FA }, /* GL_UNSIGNED_INT_24_8_NV */ - { 36983, 0x00008368 }, /* GL_UNSIGNED_INT_2_10_10_10_REV */ - { 37014, 0x00008035 }, /* GL_UNSIGNED_INT_8_8_8_8 */ - { 37038, 0x00008367 }, /* GL_UNSIGNED_INT_8_8_8_8_REV */ - { 37066, 0x00008C17 }, /* GL_UNSIGNED_NORMALIZED */ - { 37089, 0x00001403 }, /* GL_UNSIGNED_SHORT */ - { 37107, 0x00008366 }, /* GL_UNSIGNED_SHORT_1_5_5_5_REV */ - { 37137, 0x00008033 }, /* GL_UNSIGNED_SHORT_4_4_4_4 */ - { 37163, 0x00008365 }, /* GL_UNSIGNED_SHORT_4_4_4_4_REV */ - { 37193, 0x00008034 }, /* GL_UNSIGNED_SHORT_5_5_5_1 */ - { 37219, 0x00008363 }, /* GL_UNSIGNED_SHORT_5_6_5 */ - { 37243, 0x00008364 }, /* GL_UNSIGNED_SHORT_5_6_5_REV */ - { 37271, 0x000085BA }, /* GL_UNSIGNED_SHORT_8_8_APPLE */ - { 37299, 0x000085BA }, /* GL_UNSIGNED_SHORT_8_8_MESA */ - { 37326, 0x000085BB }, /* GL_UNSIGNED_SHORT_8_8_REV_APPLE */ - { 37358, 0x000085BB }, /* GL_UNSIGNED_SHORT_8_8_REV_MESA */ - { 37389, 0x00008CA2 }, /* GL_UPPER_LEFT */ - { 37403, 0x00002A20 }, /* GL_V2F */ - { 37410, 0x00002A21 }, /* GL_V3F */ - { 37417, 0x00008B83 }, /* GL_VALIDATE_STATUS */ - { 37436, 0x00001F00 }, /* GL_VENDOR */ - { 37446, 0x00001F02 }, /* GL_VERSION */ - { 37457, 0x00008074 }, /* GL_VERTEX_ARRAY */ - { 37473, 0x000085B5 }, /* GL_VERTEX_ARRAY_BINDING_APPLE */ - { 37503, 0x00008896 }, /* GL_VERTEX_ARRAY_BUFFER_BINDING */ - { 37534, 0x00008896 }, /* GL_VERTEX_ARRAY_BUFFER_BINDING_ARB */ - { 37569, 0x0000808E }, /* GL_VERTEX_ARRAY_POINTER */ - { 37593, 0x0000807A }, /* GL_VERTEX_ARRAY_SIZE */ - { 37614, 0x0000807C }, /* GL_VERTEX_ARRAY_STRIDE */ - { 37637, 0x0000807B }, /* GL_VERTEX_ARRAY_TYPE */ - { 37658, 0x00008650 }, /* GL_VERTEX_ATTRIB_ARRAY0_NV */ - { 37685, 0x0000865A }, /* GL_VERTEX_ATTRIB_ARRAY10_NV */ - { 37713, 0x0000865B }, /* GL_VERTEX_ATTRIB_ARRAY11_NV */ - { 37741, 0x0000865C }, /* GL_VERTEX_ATTRIB_ARRAY12_NV */ - { 37769, 0x0000865D }, /* GL_VERTEX_ATTRIB_ARRAY13_NV */ - { 37797, 0x0000865E }, /* GL_VERTEX_ATTRIB_ARRAY14_NV */ - { 37825, 0x0000865F }, /* GL_VERTEX_ATTRIB_ARRAY15_NV */ - { 37853, 0x00008651 }, /* GL_VERTEX_ATTRIB_ARRAY1_NV */ - { 37880, 0x00008652 }, /* GL_VERTEX_ATTRIB_ARRAY2_NV */ - { 37907, 0x00008653 }, /* GL_VERTEX_ATTRIB_ARRAY3_NV */ - { 37934, 0x00008654 }, /* GL_VERTEX_ATTRIB_ARRAY4_NV */ - { 37961, 0x00008655 }, /* GL_VERTEX_ATTRIB_ARRAY5_NV */ - { 37988, 0x00008656 }, /* GL_VERTEX_ATTRIB_ARRAY6_NV */ - { 38015, 0x00008657 }, /* GL_VERTEX_ATTRIB_ARRAY7_NV */ - { 38042, 0x00008658 }, /* GL_VERTEX_ATTRIB_ARRAY8_NV */ - { 38069, 0x00008659 }, /* GL_VERTEX_ATTRIB_ARRAY9_NV */ - { 38096, 0x0000889F }, /* GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING */ - { 38134, 0x0000889F }, /* GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING_ARB */ - { 38176, 0x00008622 }, /* GL_VERTEX_ATTRIB_ARRAY_ENABLED */ - { 38207, 0x00008622 }, /* GL_VERTEX_ATTRIB_ARRAY_ENABLED_ARB */ - { 38242, 0x0000886A }, /* GL_VERTEX_ATTRIB_ARRAY_NORMALIZED */ - { 38276, 0x0000886A }, /* GL_VERTEX_ATTRIB_ARRAY_NORMALIZED_ARB */ - { 38314, 0x00008645 }, /* GL_VERTEX_ATTRIB_ARRAY_POINTER */ - { 38345, 0x00008645 }, /* GL_VERTEX_ATTRIB_ARRAY_POINTER_ARB */ - { 38380, 0x00008623 }, /* GL_VERTEX_ATTRIB_ARRAY_SIZE */ - { 38408, 0x00008623 }, /* GL_VERTEX_ATTRIB_ARRAY_SIZE_ARB */ - { 38440, 0x00008624 }, /* GL_VERTEX_ATTRIB_ARRAY_STRIDE */ - { 38470, 0x00008624 }, /* GL_VERTEX_ATTRIB_ARRAY_STRIDE_ARB */ - { 38504, 0x00008625 }, /* GL_VERTEX_ATTRIB_ARRAY_TYPE */ - { 38532, 0x00008625 }, /* GL_VERTEX_ATTRIB_ARRAY_TYPE_ARB */ - { 38564, 0x000086A7 }, /* GL_VERTEX_BLEND_ARB */ - { 38584, 0x00008620 }, /* GL_VERTEX_PROGRAM_ARB */ - { 38606, 0x0000864A }, /* GL_VERTEX_PROGRAM_BINDING_NV */ - { 38635, 0x00008620 }, /* GL_VERTEX_PROGRAM_NV */ - { 38656, 0x00008642 }, /* GL_VERTEX_PROGRAM_POINT_SIZE */ - { 38685, 0x00008642 }, /* GL_VERTEX_PROGRAM_POINT_SIZE_ARB */ - { 38718, 0x00008642 }, /* GL_VERTEX_PROGRAM_POINT_SIZE_NV */ - { 38750, 0x00008643 }, /* GL_VERTEX_PROGRAM_TWO_SIDE */ - { 38777, 0x00008643 }, /* GL_VERTEX_PROGRAM_TWO_SIDE_ARB */ - { 38808, 0x00008643 }, /* GL_VERTEX_PROGRAM_TWO_SIDE_NV */ - { 38838, 0x00008B31 }, /* GL_VERTEX_SHADER */ - { 38855, 0x00008B31 }, /* GL_VERTEX_SHADER_ARB */ - { 38876, 0x00008621 }, /* GL_VERTEX_STATE_PROGRAM_NV */ - { 38903, 0x00000BA2 }, /* GL_VIEWPORT */ - { 38915, 0x00000800 }, /* GL_VIEWPORT_BIT */ - { 38931, 0x000086AD }, /* GL_WEIGHT_ARRAY_ARB */ - { 38951, 0x0000889E }, /* GL_WEIGHT_ARRAY_BUFFER_BINDING */ - { 38982, 0x0000889E }, /* GL_WEIGHT_ARRAY_BUFFER_BINDING_ARB */ - { 39017, 0x000086AC }, /* GL_WEIGHT_ARRAY_POINTER_ARB */ - { 39045, 0x000086AB }, /* GL_WEIGHT_ARRAY_SIZE_ARB */ - { 39070, 0x000086AA }, /* GL_WEIGHT_ARRAY_STRIDE_ARB */ - { 39097, 0x000086A9 }, /* GL_WEIGHT_ARRAY_TYPE_ARB */ - { 39122, 0x000086A6 }, /* GL_WEIGHT_SUM_UNITY_ARB */ - { 39146, 0x000081D4 }, /* GL_WRAP_BORDER_SUN */ - { 39165, 0x000088B9 }, /* GL_WRITE_ONLY */ - { 39179, 0x000088B9 }, /* GL_WRITE_ONLY_ARB */ - { 39197, 0x00001506 }, /* GL_XOR */ - { 39204, 0x000085B9 }, /* GL_YCBCR_422_APPLE */ - { 39223, 0x00008757 }, /* GL_YCBCR_MESA */ - { 39237, 0x00000000 }, /* GL_ZERO */ - { 39245, 0x00000D16 }, /* GL_ZOOM_X */ - { 39255, 0x00000D17 }, /* GL_ZOOM_Y */ + { 1821, 0x0000877B }, /* GL_BUMP_ENVMAP_ATI */ + { 1840, 0x00008777 }, /* GL_BUMP_NUM_TEX_UNITS_ATI */ + { 1866, 0x00008775 }, /* GL_BUMP_ROT_MATRIX_ATI */ + { 1889, 0x00008776 }, /* GL_BUMP_ROT_MATRIX_SIZE_ATI */ + { 1917, 0x0000877C }, /* GL_BUMP_TARGET_ATI */ + { 1936, 0x00008778 }, /* GL_BUMP_TEX_UNITS_ATI */ + { 1958, 0x00001400 }, /* GL_BYTE */ + { 1966, 0x00002A24 }, /* GL_C3F_V3F */ + { 1977, 0x00002A26 }, /* GL_C4F_N3F_V3F */ + { 1992, 0x00002A22 }, /* GL_C4UB_V2F */ + { 2004, 0x00002A23 }, /* GL_C4UB_V3F */ + { 2016, 0x00000901 }, /* GL_CCW */ + { 2023, 0x00002900 }, /* GL_CLAMP */ + { 2032, 0x0000812D }, /* GL_CLAMP_TO_BORDER */ + { 2051, 0x0000812D }, /* GL_CLAMP_TO_BORDER_ARB */ + { 2074, 0x0000812D }, /* GL_CLAMP_TO_BORDER_SGIS */ + { 2098, 0x0000812F }, /* GL_CLAMP_TO_EDGE */ + { 2115, 0x0000812F }, /* GL_CLAMP_TO_EDGE_SGIS */ + { 2137, 0x00001500 }, /* GL_CLEAR */ + { 2146, 0x000084E1 }, /* GL_CLIENT_ACTIVE_TEXTURE */ + { 2171, 0x000084E1 }, /* GL_CLIENT_ACTIVE_TEXTURE_ARB */ + { 2200, 0xFFFFFFFF }, /* GL_CLIENT_ALL_ATTRIB_BITS */ + { 2226, 0x00000BB1 }, /* GL_CLIENT_ATTRIB_STACK_DEPTH */ + { 2255, 0x00000001 }, /* GL_CLIENT_PIXEL_STORE_BIT */ + { 2281, 0x00000002 }, /* GL_CLIENT_VERTEX_ARRAY_BIT */ + { 2308, 0x00003000 }, /* GL_CLIP_PLANE0 */ + { 2323, 0x00003001 }, /* GL_CLIP_PLANE1 */ + { 2338, 0x00003002 }, /* GL_CLIP_PLANE2 */ + { 2353, 0x00003003 }, /* GL_CLIP_PLANE3 */ + { 2368, 0x00003004 }, /* GL_CLIP_PLANE4 */ + { 2383, 0x00003005 }, /* GL_CLIP_PLANE5 */ + { 2398, 0x000080F0 }, /* GL_CLIP_VOLUME_CLIPPING_HINT_EXT */ + { 2431, 0x00000A00 }, /* GL_COEFF */ + { 2440, 0x00001800 }, /* GL_COLOR */ + { 2449, 0x00008076 }, /* GL_COLOR_ARRAY */ + { 2464, 0x00008898 }, /* GL_COLOR_ARRAY_BUFFER_BINDING */ + { 2494, 0x00008898 }, /* GL_COLOR_ARRAY_BUFFER_BINDING_ARB */ + { 2528, 0x00008090 }, /* GL_COLOR_ARRAY_POINTER */ + { 2551, 0x00008081 }, /* GL_COLOR_ARRAY_SIZE */ + { 2571, 0x00008083 }, /* GL_COLOR_ARRAY_STRIDE */ + { 2593, 0x00008082 }, /* GL_COLOR_ARRAY_TYPE */ + { 2613, 0x00008CE0 }, /* GL_COLOR_ATTACHMENT0 */ + { 2634, 0x00008CE0 }, /* GL_COLOR_ATTACHMENT0_EXT */ + { 2659, 0x00008CE1 }, /* GL_COLOR_ATTACHMENT1 */ + { 2680, 0x00008CEA }, /* GL_COLOR_ATTACHMENT10 */ + { 2702, 0x00008CEA }, /* GL_COLOR_ATTACHMENT10_EXT */ + { 2728, 0x00008CEB }, /* GL_COLOR_ATTACHMENT11 */ + { 2750, 0x00008CEB }, /* GL_COLOR_ATTACHMENT11_EXT */ + { 2776, 0x00008CEC }, /* GL_COLOR_ATTACHMENT12 */ + { 2798, 0x00008CEC }, /* GL_COLOR_ATTACHMENT12_EXT */ + { 2824, 0x00008CED }, /* GL_COLOR_ATTACHMENT13 */ + { 2846, 0x00008CED }, /* GL_COLOR_ATTACHMENT13_EXT */ + { 2872, 0x00008CEE }, /* GL_COLOR_ATTACHMENT14 */ + { 2894, 0x00008CEE }, /* GL_COLOR_ATTACHMENT14_EXT */ + { 2920, 0x00008CEF }, /* GL_COLOR_ATTACHMENT15 */ + { 2942, 0x00008CEF }, /* GL_COLOR_ATTACHMENT15_EXT */ + { 2968, 0x00008CE1 }, /* GL_COLOR_ATTACHMENT1_EXT */ + { 2993, 0x00008CE2 }, /* GL_COLOR_ATTACHMENT2 */ + { 3014, 0x00008CE2 }, /* GL_COLOR_ATTACHMENT2_EXT */ + { 3039, 0x00008CE3 }, /* GL_COLOR_ATTACHMENT3 */ + { 3060, 0x00008CE3 }, /* GL_COLOR_ATTACHMENT3_EXT */ + { 3085, 0x00008CE4 }, /* GL_COLOR_ATTACHMENT4 */ + { 3106, 0x00008CE4 }, /* GL_COLOR_ATTACHMENT4_EXT */ + { 3131, 0x00008CE5 }, /* GL_COLOR_ATTACHMENT5 */ + { 3152, 0x00008CE5 }, /* GL_COLOR_ATTACHMENT5_EXT */ + { 3177, 0x00008CE6 }, /* GL_COLOR_ATTACHMENT6 */ + { 3198, 0x00008CE6 }, /* GL_COLOR_ATTACHMENT6_EXT */ + { 3223, 0x00008CE7 }, /* GL_COLOR_ATTACHMENT7 */ + { 3244, 0x00008CE7 }, /* GL_COLOR_ATTACHMENT7_EXT */ + { 3269, 0x00008CE8 }, /* GL_COLOR_ATTACHMENT8 */ + { 3290, 0x00008CE8 }, /* GL_COLOR_ATTACHMENT8_EXT */ + { 3315, 0x00008CE9 }, /* GL_COLOR_ATTACHMENT9 */ + { 3336, 0x00008CE9 }, /* GL_COLOR_ATTACHMENT9_EXT */ + { 3361, 0x00004000 }, /* GL_COLOR_BUFFER_BIT */ + { 3381, 0x00000C22 }, /* GL_COLOR_CLEAR_VALUE */ + { 3402, 0x00001900 }, /* GL_COLOR_INDEX */ + { 3417, 0x00001603 }, /* GL_COLOR_INDEXES */ + { 3434, 0x00000BF2 }, /* GL_COLOR_LOGIC_OP */ + { 3452, 0x00000B57 }, /* GL_COLOR_MATERIAL */ + { 3470, 0x00000B55 }, /* GL_COLOR_MATERIAL_FACE */ + { 3493, 0x00000B56 }, /* GL_COLOR_MATERIAL_PARAMETER */ + { 3521, 0x000080B1 }, /* GL_COLOR_MATRIX */ + { 3537, 0x000080B1 }, /* GL_COLOR_MATRIX_SGI */ + { 3557, 0x000080B2 }, /* GL_COLOR_MATRIX_STACK_DEPTH */ + { 3585, 0x000080B2 }, /* GL_COLOR_MATRIX_STACK_DEPTH_SGI */ + { 3617, 0x00008458 }, /* GL_COLOR_SUM */ + { 3630, 0x00008458 }, /* GL_COLOR_SUM_ARB */ + { 3647, 0x000080D0 }, /* GL_COLOR_TABLE */ + { 3662, 0x000080DD }, /* GL_COLOR_TABLE_ALPHA_SIZE */ + { 3688, 0x000080DD }, /* GL_COLOR_TABLE_ALPHA_SIZE_EXT */ + { 3718, 0x000080DD }, /* GL_COLOR_TABLE_ALPHA_SIZE_SGI */ + { 3748, 0x000080D7 }, /* GL_COLOR_TABLE_BIAS */ + { 3768, 0x000080D7 }, /* GL_COLOR_TABLE_BIAS_SGI */ + { 3792, 0x000080DC }, /* GL_COLOR_TABLE_BLUE_SIZE */ + { 3817, 0x000080DC }, /* GL_COLOR_TABLE_BLUE_SIZE_EXT */ + { 3846, 0x000080DC }, /* GL_COLOR_TABLE_BLUE_SIZE_SGI */ + { 3875, 0x000080D8 }, /* GL_COLOR_TABLE_FORMAT */ + { 3897, 0x000080D8 }, /* GL_COLOR_TABLE_FORMAT_EXT */ + { 3923, 0x000080D8 }, /* GL_COLOR_TABLE_FORMAT_SGI */ + { 3949, 0x000080DB }, /* GL_COLOR_TABLE_GREEN_SIZE */ + { 3975, 0x000080DB }, /* GL_COLOR_TABLE_GREEN_SIZE_EXT */ + { 4005, 0x000080DB }, /* GL_COLOR_TABLE_GREEN_SIZE_SGI */ + { 4035, 0x000080DF }, /* GL_COLOR_TABLE_INTENSITY_SIZE */ + { 4065, 0x000080DF }, /* GL_COLOR_TABLE_INTENSITY_SIZE_EXT */ + { 4099, 0x000080DF }, /* GL_COLOR_TABLE_INTENSITY_SIZE_SGI */ + { 4133, 0x000080DE }, /* GL_COLOR_TABLE_LUMINANCE_SIZE */ + { 4163, 0x000080DE }, /* GL_COLOR_TABLE_LUMINANCE_SIZE_EXT */ + { 4197, 0x000080DE }, /* GL_COLOR_TABLE_LUMINANCE_SIZE_SGI */ + { 4231, 0x000080DA }, /* GL_COLOR_TABLE_RED_SIZE */ + { 4255, 0x000080DA }, /* GL_COLOR_TABLE_RED_SIZE_EXT */ + { 4283, 0x000080DA }, /* GL_COLOR_TABLE_RED_SIZE_SGI */ + { 4311, 0x000080D6 }, /* GL_COLOR_TABLE_SCALE */ + { 4332, 0x000080D6 }, /* GL_COLOR_TABLE_SCALE_SGI */ + { 4357, 0x000080D9 }, /* GL_COLOR_TABLE_WIDTH */ + { 4378, 0x000080D9 }, /* GL_COLOR_TABLE_WIDTH_EXT */ + { 4403, 0x000080D9 }, /* GL_COLOR_TABLE_WIDTH_SGI */ + { 4428, 0x00000C23 }, /* GL_COLOR_WRITEMASK */ + { 4447, 0x00008570 }, /* GL_COMBINE */ + { 4458, 0x00008503 }, /* GL_COMBINE4 */ + { 4470, 0x00008572 }, /* GL_COMBINE_ALPHA */ + { 4487, 0x00008572 }, /* GL_COMBINE_ALPHA_ARB */ + { 4508, 0x00008572 }, /* GL_COMBINE_ALPHA_EXT */ + { 4529, 0x00008570 }, /* GL_COMBINE_ARB */ + { 4544, 0x00008570 }, /* GL_COMBINE_EXT */ + { 4559, 0x00008571 }, /* GL_COMBINE_RGB */ + { 4574, 0x00008571 }, /* GL_COMBINE_RGB_ARB */ + { 4593, 0x00008571 }, /* GL_COMBINE_RGB_EXT */ + { 4612, 0x0000884E }, /* GL_COMPARE_REF_DEPTH_TO_TEXTURE_EXT */ + { 4648, 0x0000884E }, /* GL_COMPARE_R_TO_TEXTURE */ + { 4672, 0x0000884E }, /* GL_COMPARE_R_TO_TEXTURE_ARB */ + { 4700, 0x00001300 }, /* GL_COMPILE */ + { 4711, 0x00001301 }, /* GL_COMPILE_AND_EXECUTE */ + { 4734, 0x00008B81 }, /* GL_COMPILE_STATUS */ + { 4752, 0x000084E9 }, /* GL_COMPRESSED_ALPHA */ + { 4772, 0x000084E9 }, /* GL_COMPRESSED_ALPHA_ARB */ + { 4796, 0x000084EC }, /* GL_COMPRESSED_INTENSITY */ + { 4820, 0x000084EC }, /* GL_COMPRESSED_INTENSITY_ARB */ + { 4848, 0x000084EA }, /* GL_COMPRESSED_LUMINANCE */ + { 4872, 0x000084EB }, /* GL_COMPRESSED_LUMINANCE_ALPHA */ + { 4902, 0x000084EB }, /* GL_COMPRESSED_LUMINANCE_ALPHA_ARB */ + { 4936, 0x000084EA }, /* GL_COMPRESSED_LUMINANCE_ARB */ + { 4964, 0x000084ED }, /* GL_COMPRESSED_RGB */ + { 4982, 0x000084EE }, /* GL_COMPRESSED_RGBA */ + { 5001, 0x000084EE }, /* GL_COMPRESSED_RGBA_ARB */ + { 5024, 0x000086B1 }, /* GL_COMPRESSED_RGBA_FXT1_3DFX */ + { 5053, 0x000083F1 }, /* GL_COMPRESSED_RGBA_S3TC_DXT1_EXT */ + { 5086, 0x000083F2 }, /* GL_COMPRESSED_RGBA_S3TC_DXT3_EXT */ + { 5119, 0x000083F3 }, /* GL_COMPRESSED_RGBA_S3TC_DXT5_EXT */ + { 5152, 0x000084ED }, /* GL_COMPRESSED_RGB_ARB */ + { 5174, 0x000086B0 }, /* GL_COMPRESSED_RGB_FXT1_3DFX */ + { 5202, 0x000083F0 }, /* GL_COMPRESSED_RGB_S3TC_DXT1_EXT */ + { 5234, 0x000086A3 }, /* GL_COMPRESSED_TEXTURE_FORMATS */ + { 5264, 0x00008576 }, /* GL_CONSTANT */ + { 5276, 0x00008003 }, /* GL_CONSTANT_ALPHA */ + { 5294, 0x00008003 }, /* GL_CONSTANT_ALPHA_EXT */ + { 5316, 0x00008576 }, /* GL_CONSTANT_ARB */ + { 5332, 0x00001207 }, /* GL_CONSTANT_ATTENUATION */ + { 5356, 0x00008151 }, /* GL_CONSTANT_BORDER_HP */ + { 5378, 0x00008001 }, /* GL_CONSTANT_COLOR */ + { 5396, 0x00008001 }, /* GL_CONSTANT_COLOR_EXT */ + { 5418, 0x00008576 }, /* GL_CONSTANT_EXT */ + { 5434, 0x00008010 }, /* GL_CONVOLUTION_1D */ + { 5452, 0x00008011 }, /* GL_CONVOLUTION_2D */ + { 5470, 0x00008154 }, /* GL_CONVOLUTION_BORDER_COLOR */ + { 5498, 0x00008154 }, /* GL_CONVOLUTION_BORDER_COLOR_HP */ + { 5529, 0x00008013 }, /* GL_CONVOLUTION_BORDER_MODE */ + { 5556, 0x00008013 }, /* GL_CONVOLUTION_BORDER_MODE_EXT */ + { 5587, 0x00008015 }, /* GL_CONVOLUTION_FILTER_BIAS */ + { 5614, 0x00008015 }, /* GL_CONVOLUTION_FILTER_BIAS_EXT */ + { 5645, 0x00008014 }, /* GL_CONVOLUTION_FILTER_SCALE */ + { 5673, 0x00008014 }, /* GL_CONVOLUTION_FILTER_SCALE_EXT */ + { 5705, 0x00008017 }, /* GL_CONVOLUTION_FORMAT */ + { 5727, 0x00008017 }, /* GL_CONVOLUTION_FORMAT_EXT */ + { 5753, 0x00008019 }, /* GL_CONVOLUTION_HEIGHT */ + { 5775, 0x00008019 }, /* GL_CONVOLUTION_HEIGHT_EXT */ + { 5801, 0x00008018 }, /* GL_CONVOLUTION_WIDTH */ + { 5822, 0x00008018 }, /* GL_CONVOLUTION_WIDTH_EXT */ + { 5847, 0x00008862 }, /* GL_COORD_REPLACE */ + { 5864, 0x00008862 }, /* GL_COORD_REPLACE_ARB */ + { 5885, 0x00008862 }, /* GL_COORD_REPLACE_NV */ + { 5905, 0x00001503 }, /* GL_COPY */ + { 5913, 0x0000150C }, /* GL_COPY_INVERTED */ + { 5930, 0x00000706 }, /* GL_COPY_PIXEL_TOKEN */ + { 5950, 0x00000B44 }, /* GL_CULL_FACE */ + { 5963, 0x00000B45 }, /* GL_CULL_FACE_MODE */ + { 5981, 0x000081AA }, /* GL_CULL_VERTEX_EXT */ + { 6000, 0x000081AC }, /* GL_CULL_VERTEX_EYE_POSITION_EXT */ + { 6032, 0x000081AB }, /* GL_CULL_VERTEX_OBJECT_POSITION_EXT */ + { 6067, 0x00008626 }, /* GL_CURRENT_ATTRIB_NV */ + { 6088, 0x00000001 }, /* GL_CURRENT_BIT */ + { 6103, 0x00000B00 }, /* GL_CURRENT_COLOR */ + { 6120, 0x00008453 }, /* GL_CURRENT_FOG_COORD */ + { 6141, 0x00008453 }, /* GL_CURRENT_FOG_COORDINATE */ + { 6167, 0x00000B01 }, /* GL_CURRENT_INDEX */ + { 6184, 0x00008641 }, /* GL_CURRENT_MATRIX_ARB */ + { 6206, 0x00008845 }, /* GL_CURRENT_MATRIX_INDEX_ARB */ + { 6234, 0x00008641 }, /* GL_CURRENT_MATRIX_NV */ + { 6255, 0x00008640 }, /* GL_CURRENT_MATRIX_STACK_DEPTH_ARB */ + { 6289, 0x00008640 }, /* GL_CURRENT_MATRIX_STACK_DEPTH_NV */ + { 6322, 0x00000B02 }, /* GL_CURRENT_NORMAL */ + { 6340, 0x00008843 }, /* GL_CURRENT_PALETTE_MATRIX_ARB */ + { 6370, 0x00008B8D }, /* GL_CURRENT_PROGRAM */ + { 6389, 0x00008865 }, /* GL_CURRENT_QUERY */ + { 6406, 0x00008865 }, /* GL_CURRENT_QUERY_ARB */ + { 6427, 0x00000B04 }, /* GL_CURRENT_RASTER_COLOR */ + { 6451, 0x00000B09 }, /* GL_CURRENT_RASTER_DISTANCE */ + { 6478, 0x00000B05 }, /* GL_CURRENT_RASTER_INDEX */ + { 6502, 0x00000B07 }, /* GL_CURRENT_RASTER_POSITION */ + { 6529, 0x00000B08 }, /* GL_CURRENT_RASTER_POSITION_VALID */ + { 6562, 0x00000B06 }, /* GL_CURRENT_RASTER_TEXTURE_COORDS */ + { 6595, 0x00008459 }, /* GL_CURRENT_SECONDARY_COLOR */ + { 6622, 0x00000B03 }, /* GL_CURRENT_TEXTURE_COORDS */ + { 6648, 0x00008626 }, /* GL_CURRENT_VERTEX_ATTRIB */ + { 6673, 0x00008626 }, /* GL_CURRENT_VERTEX_ATTRIB_ARB */ + { 6702, 0x000086A8 }, /* GL_CURRENT_WEIGHT_ARB */ + { 6724, 0x00000900 }, /* GL_CW */ + { 6730, 0x0000875B }, /* GL_DEBUG_ASSERT_MESA */ + { 6751, 0x00008759 }, /* GL_DEBUG_OBJECT_MESA */ + { 6772, 0x0000875A }, /* GL_DEBUG_PRINT_MESA */ + { 6792, 0x00002101 }, /* GL_DECAL */ + { 6801, 0x00001E03 }, /* GL_DECR */ + { 6809, 0x00008508 }, /* GL_DECR_WRAP */ + { 6822, 0x00008508 }, /* GL_DECR_WRAP_EXT */ + { 6839, 0x00008B80 }, /* GL_DELETE_STATUS */ + { 6856, 0x00001801 }, /* GL_DEPTH */ + { 6865, 0x000088F0 }, /* GL_DEPTH24_STENCIL8 */ + { 6885, 0x00008D00 }, /* GL_DEPTH_ATTACHMENT */ + { 6905, 0x00008D00 }, /* GL_DEPTH_ATTACHMENT_EXT */ + { 6929, 0x00000D1F }, /* GL_DEPTH_BIAS */ + { 6943, 0x00000D56 }, /* GL_DEPTH_BITS */ + { 6957, 0x00008891 }, /* GL_DEPTH_BOUNDS_EXT */ + { 6977, 0x00008890 }, /* GL_DEPTH_BOUNDS_TEST_EXT */ + { 7002, 0x00000100 }, /* GL_DEPTH_BUFFER_BIT */ + { 7022, 0x0000864F }, /* GL_DEPTH_CLAMP_NV */ + { 7040, 0x00000B73 }, /* GL_DEPTH_CLEAR_VALUE */ + { 7061, 0x00001902 }, /* GL_DEPTH_COMPONENT */ + { 7080, 0x000081A5 }, /* GL_DEPTH_COMPONENT16 */ + { 7101, 0x000081A5 }, /* GL_DEPTH_COMPONENT16_ARB */ + { 7126, 0x000081A5 }, /* GL_DEPTH_COMPONENT16_SGIX */ + { 7152, 0x000081A6 }, /* GL_DEPTH_COMPONENT24 */ + { 7173, 0x000081A6 }, /* GL_DEPTH_COMPONENT24_ARB */ + { 7198, 0x000081A6 }, /* GL_DEPTH_COMPONENT24_SGIX */ + { 7224, 0x000081A7 }, /* GL_DEPTH_COMPONENT32 */ + { 7245, 0x000081A7 }, /* GL_DEPTH_COMPONENT32_ARB */ + { 7270, 0x000081A7 }, /* GL_DEPTH_COMPONENT32_SGIX */ + { 7296, 0x00000B74 }, /* GL_DEPTH_FUNC */ + { 7310, 0x00000B70 }, /* GL_DEPTH_RANGE */ + { 7325, 0x00000D1E }, /* GL_DEPTH_SCALE */ + { 7340, 0x000084F9 }, /* GL_DEPTH_STENCIL */ + { 7357, 0x0000821A }, /* GL_DEPTH_STENCIL_ATTACHMENT */ + { 7385, 0x000084F9 }, /* GL_DEPTH_STENCIL_NV */ + { 7405, 0x0000886F }, /* GL_DEPTH_STENCIL_TO_BGRA_NV */ + { 7433, 0x0000886E }, /* GL_DEPTH_STENCIL_TO_RGBA_NV */ + { 7461, 0x00000B71 }, /* GL_DEPTH_TEST */ + { 7475, 0x0000884B }, /* GL_DEPTH_TEXTURE_MODE */ + { 7497, 0x0000884B }, /* GL_DEPTH_TEXTURE_MODE_ARB */ + { 7523, 0x00000B72 }, /* GL_DEPTH_WRITEMASK */ + { 7542, 0x00001201 }, /* GL_DIFFUSE */ + { 7553, 0x00000BD0 }, /* GL_DITHER */ + { 7563, 0x00000A02 }, /* GL_DOMAIN */ + { 7573, 0x00001100 }, /* GL_DONT_CARE */ + { 7586, 0x000086AE }, /* GL_DOT3_RGB */ + { 7598, 0x000086AF }, /* GL_DOT3_RGBA */ + { 7611, 0x000086AF }, /* GL_DOT3_RGBA_ARB */ + { 7628, 0x00008741 }, /* GL_DOT3_RGBA_EXT */ + { 7645, 0x000086AE }, /* GL_DOT3_RGB_ARB */ + { 7661, 0x00008740 }, /* GL_DOT3_RGB_EXT */ + { 7677, 0x0000140A }, /* GL_DOUBLE */ + { 7687, 0x00000C32 }, /* GL_DOUBLEBUFFER */ + { 7703, 0x00000C01 }, /* GL_DRAW_BUFFER */ + { 7718, 0x00008825 }, /* GL_DRAW_BUFFER0 */ + { 7734, 0x00008825 }, /* GL_DRAW_BUFFER0_ARB */ + { 7754, 0x00008825 }, /* GL_DRAW_BUFFER0_ATI */ + { 7774, 0x00008826 }, /* GL_DRAW_BUFFER1 */ + { 7790, 0x0000882F }, /* GL_DRAW_BUFFER10 */ + { 7807, 0x0000882F }, /* GL_DRAW_BUFFER10_ARB */ + { 7828, 0x0000882F }, /* GL_DRAW_BUFFER10_ATI */ + { 7849, 0x00008830 }, /* GL_DRAW_BUFFER11 */ + { 7866, 0x00008830 }, /* GL_DRAW_BUFFER11_ARB */ + { 7887, 0x00008830 }, /* GL_DRAW_BUFFER11_ATI */ + { 7908, 0x00008831 }, /* GL_DRAW_BUFFER12 */ + { 7925, 0x00008831 }, /* GL_DRAW_BUFFER12_ARB */ + { 7946, 0x00008831 }, /* GL_DRAW_BUFFER12_ATI */ + { 7967, 0x00008832 }, /* GL_DRAW_BUFFER13 */ + { 7984, 0x00008832 }, /* GL_DRAW_BUFFER13_ARB */ + { 8005, 0x00008832 }, /* GL_DRAW_BUFFER13_ATI */ + { 8026, 0x00008833 }, /* GL_DRAW_BUFFER14 */ + { 8043, 0x00008833 }, /* GL_DRAW_BUFFER14_ARB */ + { 8064, 0x00008833 }, /* GL_DRAW_BUFFER14_ATI */ + { 8085, 0x00008834 }, /* GL_DRAW_BUFFER15 */ + { 8102, 0x00008834 }, /* GL_DRAW_BUFFER15_ARB */ + { 8123, 0x00008834 }, /* GL_DRAW_BUFFER15_ATI */ + { 8144, 0x00008826 }, /* GL_DRAW_BUFFER1_ARB */ + { 8164, 0x00008826 }, /* GL_DRAW_BUFFER1_ATI */ + { 8184, 0x00008827 }, /* GL_DRAW_BUFFER2 */ + { 8200, 0x00008827 }, /* GL_DRAW_BUFFER2_ARB */ + { 8220, 0x00008827 }, /* GL_DRAW_BUFFER2_ATI */ + { 8240, 0x00008828 }, /* GL_DRAW_BUFFER3 */ + { 8256, 0x00008828 }, /* GL_DRAW_BUFFER3_ARB */ + { 8276, 0x00008828 }, /* GL_DRAW_BUFFER3_ATI */ + { 8296, 0x00008829 }, /* GL_DRAW_BUFFER4 */ + { 8312, 0x00008829 }, /* GL_DRAW_BUFFER4_ARB */ + { 8332, 0x00008829 }, /* GL_DRAW_BUFFER4_ATI */ + { 8352, 0x0000882A }, /* GL_DRAW_BUFFER5 */ + { 8368, 0x0000882A }, /* GL_DRAW_BUFFER5_ARB */ + { 8388, 0x0000882A }, /* GL_DRAW_BUFFER5_ATI */ + { 8408, 0x0000882B }, /* GL_DRAW_BUFFER6 */ + { 8424, 0x0000882B }, /* GL_DRAW_BUFFER6_ARB */ + { 8444, 0x0000882B }, /* GL_DRAW_BUFFER6_ATI */ + { 8464, 0x0000882C }, /* GL_DRAW_BUFFER7 */ + { 8480, 0x0000882C }, /* GL_DRAW_BUFFER7_ARB */ + { 8500, 0x0000882C }, /* GL_DRAW_BUFFER7_ATI */ + { 8520, 0x0000882D }, /* GL_DRAW_BUFFER8 */ + { 8536, 0x0000882D }, /* GL_DRAW_BUFFER8_ARB */ + { 8556, 0x0000882D }, /* GL_DRAW_BUFFER8_ATI */ + { 8576, 0x0000882E }, /* GL_DRAW_BUFFER9 */ + { 8592, 0x0000882E }, /* GL_DRAW_BUFFER9_ARB */ + { 8612, 0x0000882E }, /* GL_DRAW_BUFFER9_ATI */ + { 8632, 0x00008CA9 }, /* GL_DRAW_FRAMEBUFFER */ + { 8652, 0x00008CA6 }, /* GL_DRAW_FRAMEBUFFER_BINDING_EXT */ + { 8684, 0x00008CA9 }, /* GL_DRAW_FRAMEBUFFER_EXT */ + { 8708, 0x00000705 }, /* GL_DRAW_PIXEL_TOKEN */ + { 8728, 0x00000304 }, /* GL_DST_ALPHA */ + { 8741, 0x00000306 }, /* GL_DST_COLOR */ + { 8754, 0x0000877A }, /* GL_DU8DV8_ATI */ + { 8768, 0x00008779 }, /* GL_DUDV_ATI */ + { 8780, 0x000088EA }, /* GL_DYNAMIC_COPY */ + { 8796, 0x000088EA }, /* GL_DYNAMIC_COPY_ARB */ + { 8816, 0x000088E8 }, /* GL_DYNAMIC_DRAW */ + { 8832, 0x000088E8 }, /* GL_DYNAMIC_DRAW_ARB */ + { 8852, 0x000088E9 }, /* GL_DYNAMIC_READ */ + { 8868, 0x000088E9 }, /* GL_DYNAMIC_READ_ARB */ + { 8888, 0x00000B43 }, /* GL_EDGE_FLAG */ + { 8901, 0x00008079 }, /* GL_EDGE_FLAG_ARRAY */ + { 8920, 0x0000889B }, /* GL_EDGE_FLAG_ARRAY_BUFFER_BINDING */ + { 8954, 0x0000889B }, /* GL_EDGE_FLAG_ARRAY_BUFFER_BINDING_ARB */ + { 8992, 0x00008093 }, /* GL_EDGE_FLAG_ARRAY_POINTER */ + { 9019, 0x0000808C }, /* GL_EDGE_FLAG_ARRAY_STRIDE */ + { 9045, 0x00008893 }, /* GL_ELEMENT_ARRAY_BUFFER */ + { 9069, 0x00008895 }, /* GL_ELEMENT_ARRAY_BUFFER_BINDING */ + { 9101, 0x00008895 }, /* GL_ELEMENT_ARRAY_BUFFER_BINDING_ARB */ + { 9137, 0x00001600 }, /* GL_EMISSION */ + { 9149, 0x00002000 }, /* GL_ENABLE_BIT */ + { 9163, 0x00000202 }, /* GL_EQUAL */ + { 9172, 0x00001509 }, /* GL_EQUIV */ + { 9181, 0x00010000 }, /* GL_EVAL_BIT */ + { 9193, 0x00000800 }, /* GL_EXP */ + { 9200, 0x00000801 }, /* GL_EXP2 */ + { 9208, 0x00001F03 }, /* GL_EXTENSIONS */ + { 9222, 0x00002400 }, /* GL_EYE_LINEAR */ + { 9236, 0x00002502 }, /* GL_EYE_PLANE */ + { 9249, 0x0000855C }, /* GL_EYE_PLANE_ABSOLUTE_NV */ + { 9274, 0x0000855B }, /* GL_EYE_RADIAL_NV */ + { 9291, 0x00000000 }, /* GL_FALSE */ + { 9300, 0x00001101 }, /* GL_FASTEST */ + { 9311, 0x00001C01 }, /* GL_FEEDBACK */ + { 9323, 0x00000DF0 }, /* GL_FEEDBACK_BUFFER_POINTER */ + { 9350, 0x00000DF1 }, /* GL_FEEDBACK_BUFFER_SIZE */ + { 9374, 0x00000DF2 }, /* GL_FEEDBACK_BUFFER_TYPE */ + { 9398, 0x00001B02 }, /* GL_FILL */ + { 9406, 0x00001D00 }, /* GL_FLAT */ + { 9414, 0x00001406 }, /* GL_FLOAT */ + { 9423, 0x00008B5A }, /* GL_FLOAT_MAT2 */ + { 9437, 0x00008B5A }, /* GL_FLOAT_MAT2_ARB */ + { 9455, 0x00008B5B }, /* GL_FLOAT_MAT3 */ + { 9469, 0x00008B5B }, /* GL_FLOAT_MAT3_ARB */ + { 9487, 0x00008B5C }, /* GL_FLOAT_MAT4 */ + { 9501, 0x00008B5C }, /* GL_FLOAT_MAT4_ARB */ + { 9519, 0x00008B50 }, /* GL_FLOAT_VEC2 */ + { 9533, 0x00008B50 }, /* GL_FLOAT_VEC2_ARB */ + { 9551, 0x00008B51 }, /* GL_FLOAT_VEC3 */ + { 9565, 0x00008B51 }, /* GL_FLOAT_VEC3_ARB */ + { 9583, 0x00008B52 }, /* GL_FLOAT_VEC4 */ + { 9597, 0x00008B52 }, /* GL_FLOAT_VEC4_ARB */ + { 9615, 0x00000B60 }, /* GL_FOG */ + { 9622, 0x00000080 }, /* GL_FOG_BIT */ + { 9633, 0x00000B66 }, /* GL_FOG_COLOR */ + { 9646, 0x00008451 }, /* GL_FOG_COORD */ + { 9659, 0x00008451 }, /* GL_FOG_COORDINATE */ + { 9677, 0x00008457 }, /* GL_FOG_COORDINATE_ARRAY */ + { 9701, 0x0000889D }, /* GL_FOG_COORDINATE_ARRAY_BUFFER_BINDING */ + { 9740, 0x0000889D }, /* GL_FOG_COORDINATE_ARRAY_BUFFER_BINDING_ARB */ + { 9783, 0x00008456 }, /* GL_FOG_COORDINATE_ARRAY_POINTER */ + { 9815, 0x00008455 }, /* GL_FOG_COORDINATE_ARRAY_STRIDE */ + { 9846, 0x00008454 }, /* GL_FOG_COORDINATE_ARRAY_TYPE */ + { 9875, 0x00008450 }, /* GL_FOG_COORDINATE_SOURCE */ + { 9900, 0x00008457 }, /* GL_FOG_COORD_ARRAY */ + { 9919, 0x0000889D }, /* GL_FOG_COORD_ARRAY_BUFFER_BINDING */ + { 9953, 0x00008456 }, /* GL_FOG_COORD_ARRAY_POINTER */ + { 9980, 0x00008455 }, /* GL_FOG_COORD_ARRAY_STRIDE */ + { 10006, 0x00008454 }, /* GL_FOG_COORD_ARRAY_TYPE */ + { 10030, 0x00008450 }, /* GL_FOG_COORD_SRC */ + { 10047, 0x00000B62 }, /* GL_FOG_DENSITY */ + { 10062, 0x0000855A }, /* GL_FOG_DISTANCE_MODE_NV */ + { 10086, 0x00000B64 }, /* GL_FOG_END */ + { 10097, 0x00000C54 }, /* GL_FOG_HINT */ + { 10109, 0x00000B61 }, /* GL_FOG_INDEX */ + { 10122, 0x00000B65 }, /* GL_FOG_MODE */ + { 10134, 0x00008198 }, /* GL_FOG_OFFSET_SGIX */ + { 10153, 0x00008199 }, /* GL_FOG_OFFSET_VALUE_SGIX */ + { 10178, 0x00000B63 }, /* GL_FOG_START */ + { 10191, 0x00008452 }, /* GL_FRAGMENT_DEPTH */ + { 10209, 0x00008804 }, /* GL_FRAGMENT_PROGRAM_ARB */ + { 10233, 0x00008B30 }, /* GL_FRAGMENT_SHADER */ + { 10252, 0x00008B30 }, /* GL_FRAGMENT_SHADER_ARB */ + { 10275, 0x00008B8B }, /* GL_FRAGMENT_SHADER_DERIVATIVE_HINT */ + { 10310, 0x00008D40 }, /* GL_FRAMEBUFFER */ + { 10325, 0x00008215 }, /* GL_FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE */ + { 10362, 0x00008214 }, /* GL_FRAMEBUFFER_ATTACHMENT_BLUE_SIZE */ + { 10398, 0x00008210 }, /* GL_FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING */ + { 10439, 0x00008211 }, /* GL_FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE */ + { 10480, 0x00008216 }, /* GL_FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE */ + { 10517, 0x00008213 }, /* GL_FRAMEBUFFER_ATTACHMENT_GREEN_SIZE */ + { 10554, 0x00008CD1 }, /* GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME */ + { 10592, 0x00008CD1 }, /* GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME_EXT */ + { 10634, 0x00008CD0 }, /* GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE */ + { 10672, 0x00008CD0 }, /* GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE_EXT */ + { 10714, 0x00008212 }, /* GL_FRAMEBUFFER_ATTACHMENT_RED_SIZE */ + { 10749, 0x00008217 }, /* GL_FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE */ + { 10788, 0x00008CD4 }, /* GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_3D_ZOFFSET_EXT */ + { 10837, 0x00008CD3 }, /* GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE */ + { 10885, 0x00008CD3 }, /* GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE_EXT */ + { 10937, 0x00008CD4 }, /* GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER */ + { 10977, 0x00008CD4 }, /* GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER_EXT */ + { 11021, 0x00008CD2 }, /* GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL */ + { 11061, 0x00008CD2 }, /* GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL_EXT */ + { 11105, 0x00008CA6 }, /* GL_FRAMEBUFFER_BINDING_EXT */ + { 11132, 0x00008CD5 }, /* GL_FRAMEBUFFER_COMPLETE */ + { 11156, 0x00008CD5 }, /* GL_FRAMEBUFFER_COMPLETE_EXT */ + { 11184, 0x00008218 }, /* GL_FRAMEBUFFER_DEFAULT */ + { 11207, 0x00008D40 }, /* GL_FRAMEBUFFER_EXT */ + { 11226, 0x00008CD6 }, /* GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT */ + { 11263, 0x00008CD6 }, /* GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT_EXT */ + { 11304, 0x00008CD9 }, /* GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS_EXT */ + { 11345, 0x00008CDB }, /* GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER_EXT */ + { 11387, 0x00008CD8 }, /* GL_FRAMEBUFFER_INCOMPLETE_DUPLICATE_ATTACHMENT_EXT */ + { 11438, 0x00008CDA }, /* GL_FRAMEBUFFER_INCOMPLETE_FORMATS_EXT */ + { 11476, 0x00008CD7 }, /* GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT */ + { 11521, 0x00008CD7 }, /* GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT_EXT */ + { 11570, 0x00008D56 }, /* GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE */ + { 11608, 0x00008CDC }, /* GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER_EXT */ + { 11650, 0x00008CDE }, /* GL_FRAMEBUFFER_STATUS_ERROR_EXT */ + { 11682, 0x00008219 }, /* GL_FRAMEBUFFER_UNDEFINED */ + { 11707, 0x00008CDD }, /* GL_FRAMEBUFFER_UNSUPPORTED */ + { 11734, 0x00008CDD }, /* GL_FRAMEBUFFER_UNSUPPORTED_EXT */ + { 11765, 0x00000404 }, /* GL_FRONT */ + { 11774, 0x00000408 }, /* GL_FRONT_AND_BACK */ + { 11792, 0x00000B46 }, /* GL_FRONT_FACE */ + { 11806, 0x00000400 }, /* GL_FRONT_LEFT */ + { 11820, 0x00000401 }, /* GL_FRONT_RIGHT */ + { 11835, 0x00008006 }, /* GL_FUNC_ADD */ + { 11847, 0x00008006 }, /* GL_FUNC_ADD_EXT */ + { 11863, 0x0000800B }, /* GL_FUNC_REVERSE_SUBTRACT */ + { 11888, 0x0000800B }, /* GL_FUNC_REVERSE_SUBTRACT_EXT */ + { 11917, 0x0000800A }, /* GL_FUNC_SUBTRACT */ + { 11934, 0x0000800A }, /* GL_FUNC_SUBTRACT_EXT */ + { 11955, 0x00008191 }, /* GL_GENERATE_MIPMAP */ + { 11974, 0x00008192 }, /* GL_GENERATE_MIPMAP_HINT */ + { 11998, 0x00008192 }, /* GL_GENERATE_MIPMAP_HINT_SGIS */ + { 12027, 0x00008191 }, /* GL_GENERATE_MIPMAP_SGIS */ + { 12051, 0x00000206 }, /* GL_GEQUAL */ + { 12061, 0x00008009 }, /* GL_GL_BLEND_EQUATION_RGB */ + { 12086, 0x00008C4A }, /* GL_GL_COMPRESSED_SLUMINANCE */ + { 12114, 0x00008C4B }, /* GL_GL_COMPRESSED_SLUMINANCE_ALPHA */ + { 12148, 0x00008C48 }, /* GL_GL_COMPRESSED_SRGB */ + { 12170, 0x00008C49 }, /* GL_GL_COMPRESSED_SRGB_ALPHA */ + { 12198, 0x0000845F }, /* GL_GL_CURRENT_RASTER_SECONDARY_COLOR */ + { 12235, 0x00008B65 }, /* GL_GL_FLOAT_MAT2x3 */ + { 12254, 0x00008B66 }, /* GL_GL_FLOAT_MAT2x4 */ + { 12273, 0x00008B67 }, /* GL_GL_FLOAT_MAT3x2 */ + { 12292, 0x00008B68 }, /* GL_GL_FLOAT_MAT3x4 */ + { 12311, 0x00008B69 }, /* GL_GL_FLOAT_MAT4x2 */ + { 12330, 0x00008B6A }, /* GL_GL_FLOAT_MAT4x3 */ + { 12349, 0x000088EB }, /* GL_GL_PIXEL_PACK_BUFFER */ + { 12373, 0x000088ED }, /* GL_GL_PIXEL_PACK_BUFFER_BINDING */ + { 12405, 0x000088EC }, /* GL_GL_PIXEL_UNPACK_BUFFER */ + { 12431, 0x000088EF }, /* GL_GL_PIXEL_UNPACK_BUFFER_BINDING */ + { 12465, 0x00008C46 }, /* GL_GL_SLUMINANCE */ + { 12482, 0x00008C47 }, /* GL_GL_SLUMINANCE8 */ + { 12500, 0x00008C45 }, /* GL_GL_SLUMINANCE8_ALPHA8 */ + { 12525, 0x00008C44 }, /* GL_GL_SLUMINANCE_ALPHA */ + { 12548, 0x00008C40 }, /* GL_GL_SRGB */ + { 12559, 0x00008C41 }, /* GL_GL_SRGB8 */ + { 12571, 0x00008C43 }, /* GL_GL_SRGB8_ALPHA8 */ + { 12590, 0x00008C42 }, /* GL_GL_SRGB_ALPHA */ + { 12607, 0x00000204 }, /* GL_GREATER */ + { 12618, 0x00001904 }, /* GL_GREEN */ + { 12627, 0x00000D19 }, /* GL_GREEN_BIAS */ + { 12641, 0x00000D53 }, /* GL_GREEN_BITS */ + { 12655, 0x00000D18 }, /* GL_GREEN_SCALE */ + { 12670, 0x00008000 }, /* GL_HINT_BIT */ + { 12682, 0x00008024 }, /* GL_HISTOGRAM */ + { 12695, 0x0000802B }, /* GL_HISTOGRAM_ALPHA_SIZE */ + { 12719, 0x0000802B }, /* GL_HISTOGRAM_ALPHA_SIZE_EXT */ + { 12747, 0x0000802A }, /* GL_HISTOGRAM_BLUE_SIZE */ + { 12770, 0x0000802A }, /* GL_HISTOGRAM_BLUE_SIZE_EXT */ + { 12797, 0x00008024 }, /* GL_HISTOGRAM_EXT */ + { 12814, 0x00008027 }, /* GL_HISTOGRAM_FORMAT */ + { 12834, 0x00008027 }, /* GL_HISTOGRAM_FORMAT_EXT */ + { 12858, 0x00008029 }, /* GL_HISTOGRAM_GREEN_SIZE */ + { 12882, 0x00008029 }, /* GL_HISTOGRAM_GREEN_SIZE_EXT */ + { 12910, 0x0000802C }, /* GL_HISTOGRAM_LUMINANCE_SIZE */ + { 12938, 0x0000802C }, /* GL_HISTOGRAM_LUMINANCE_SIZE_EXT */ + { 12970, 0x00008028 }, /* GL_HISTOGRAM_RED_SIZE */ + { 12992, 0x00008028 }, /* GL_HISTOGRAM_RED_SIZE_EXT */ + { 13018, 0x0000802D }, /* GL_HISTOGRAM_SINK */ + { 13036, 0x0000802D }, /* GL_HISTOGRAM_SINK_EXT */ + { 13058, 0x00008026 }, /* GL_HISTOGRAM_WIDTH */ + { 13077, 0x00008026 }, /* GL_HISTOGRAM_WIDTH_EXT */ + { 13100, 0x0000862A }, /* GL_IDENTITY_NV */ + { 13115, 0x00008150 }, /* GL_IGNORE_BORDER_HP */ + { 13135, 0x00008B9B }, /* GL_IMPLEMENTATION_COLOR_READ_FORMAT_OES */ + { 13175, 0x00008B9A }, /* GL_IMPLEMENTATION_COLOR_READ_TYPE_OES */ + { 13213, 0x00001E02 }, /* GL_INCR */ + { 13221, 0x00008507 }, /* GL_INCR_WRAP */ + { 13234, 0x00008507 }, /* GL_INCR_WRAP_EXT */ + { 13251, 0x00008222 }, /* GL_INDEX */ + { 13260, 0x00008077 }, /* GL_INDEX_ARRAY */ + { 13275, 0x00008899 }, /* GL_INDEX_ARRAY_BUFFER_BINDING */ + { 13305, 0x00008899 }, /* GL_INDEX_ARRAY_BUFFER_BINDING_ARB */ + { 13339, 0x00008091 }, /* GL_INDEX_ARRAY_POINTER */ + { 13362, 0x00008086 }, /* GL_INDEX_ARRAY_STRIDE */ + { 13384, 0x00008085 }, /* GL_INDEX_ARRAY_TYPE */ + { 13404, 0x00000D51 }, /* GL_INDEX_BITS */ + { 13418, 0x00000C20 }, /* GL_INDEX_CLEAR_VALUE */ + { 13439, 0x00000BF1 }, /* GL_INDEX_LOGIC_OP */ + { 13457, 0x00000C30 }, /* GL_INDEX_MODE */ + { 13471, 0x00000D13 }, /* GL_INDEX_OFFSET */ + { 13487, 0x00000D12 }, /* GL_INDEX_SHIFT */ + { 13502, 0x00000C21 }, /* GL_INDEX_WRITEMASK */ + { 13521, 0x00008B84 }, /* GL_INFO_LOG_LENGTH */ + { 13540, 0x00001404 }, /* GL_INT */ + { 13547, 0x00008049 }, /* GL_INTENSITY */ + { 13560, 0x0000804C }, /* GL_INTENSITY12 */ + { 13575, 0x0000804C }, /* GL_INTENSITY12_EXT */ + { 13594, 0x0000804D }, /* GL_INTENSITY16 */ + { 13609, 0x0000804D }, /* GL_INTENSITY16_EXT */ + { 13628, 0x0000804A }, /* GL_INTENSITY4 */ + { 13642, 0x0000804A }, /* GL_INTENSITY4_EXT */ + { 13660, 0x0000804B }, /* GL_INTENSITY8 */ + { 13674, 0x0000804B }, /* GL_INTENSITY8_EXT */ + { 13692, 0x00008049 }, /* GL_INTENSITY_EXT */ + { 13709, 0x00008575 }, /* GL_INTERPOLATE */ + { 13724, 0x00008575 }, /* GL_INTERPOLATE_ARB */ + { 13743, 0x00008575 }, /* GL_INTERPOLATE_EXT */ + { 13762, 0x00008B53 }, /* GL_INT_VEC2 */ + { 13774, 0x00008B53 }, /* GL_INT_VEC2_ARB */ + { 13790, 0x00008B54 }, /* GL_INT_VEC3 */ + { 13802, 0x00008B54 }, /* GL_INT_VEC3_ARB */ + { 13818, 0x00008B55 }, /* GL_INT_VEC4 */ + { 13830, 0x00008B55 }, /* GL_INT_VEC4_ARB */ + { 13846, 0x00000500 }, /* GL_INVALID_ENUM */ + { 13862, 0x00000506 }, /* GL_INVALID_FRAMEBUFFER_OPERATION */ + { 13895, 0x00000506 }, /* GL_INVALID_FRAMEBUFFER_OPERATION_EXT */ + { 13932, 0x00000502 }, /* GL_INVALID_OPERATION */ + { 13953, 0x00000501 }, /* GL_INVALID_VALUE */ + { 13970, 0x0000862B }, /* GL_INVERSE_NV */ + { 13984, 0x0000862D }, /* GL_INVERSE_TRANSPOSE_NV */ + { 14008, 0x0000150A }, /* GL_INVERT */ + { 14018, 0x00001E00 }, /* GL_KEEP */ + { 14026, 0x00000406 }, /* GL_LEFT */ + { 14034, 0x00000203 }, /* GL_LEQUAL */ + { 14044, 0x00000201 }, /* GL_LESS */ + { 14052, 0x00004000 }, /* GL_LIGHT0 */ + { 14062, 0x00004001 }, /* GL_LIGHT1 */ + { 14072, 0x00004002 }, /* GL_LIGHT2 */ + { 14082, 0x00004003 }, /* GL_LIGHT3 */ + { 14092, 0x00004004 }, /* GL_LIGHT4 */ + { 14102, 0x00004005 }, /* GL_LIGHT5 */ + { 14112, 0x00004006 }, /* GL_LIGHT6 */ + { 14122, 0x00004007 }, /* GL_LIGHT7 */ + { 14132, 0x00000B50 }, /* GL_LIGHTING */ + { 14144, 0x00000040 }, /* GL_LIGHTING_BIT */ + { 14160, 0x00000B53 }, /* GL_LIGHT_MODEL_AMBIENT */ + { 14183, 0x000081F8 }, /* GL_LIGHT_MODEL_COLOR_CONTROL */ + { 14212, 0x000081F8 }, /* GL_LIGHT_MODEL_COLOR_CONTROL_EXT */ + { 14245, 0x00000B51 }, /* GL_LIGHT_MODEL_LOCAL_VIEWER */ + { 14273, 0x00000B52 }, /* GL_LIGHT_MODEL_TWO_SIDE */ + { 14297, 0x00001B01 }, /* GL_LINE */ + { 14305, 0x00002601 }, /* GL_LINEAR */ + { 14315, 0x00001208 }, /* GL_LINEAR_ATTENUATION */ + { 14337, 0x00008170 }, /* GL_LINEAR_CLIPMAP_LINEAR_SGIX */ + { 14367, 0x0000844F }, /* GL_LINEAR_CLIPMAP_NEAREST_SGIX */ + { 14398, 0x00002703 }, /* GL_LINEAR_MIPMAP_LINEAR */ + { 14422, 0x00002701 }, /* GL_LINEAR_MIPMAP_NEAREST */ + { 14447, 0x00000001 }, /* GL_LINES */ + { 14456, 0x00000004 }, /* GL_LINE_BIT */ + { 14468, 0x00000002 }, /* GL_LINE_LOOP */ + { 14481, 0x00000707 }, /* GL_LINE_RESET_TOKEN */ + { 14501, 0x00000B20 }, /* GL_LINE_SMOOTH */ + { 14516, 0x00000C52 }, /* GL_LINE_SMOOTH_HINT */ + { 14536, 0x00000B24 }, /* GL_LINE_STIPPLE */ + { 14552, 0x00000B25 }, /* GL_LINE_STIPPLE_PATTERN */ + { 14576, 0x00000B26 }, /* GL_LINE_STIPPLE_REPEAT */ + { 14599, 0x00000003 }, /* GL_LINE_STRIP */ + { 14613, 0x00000702 }, /* GL_LINE_TOKEN */ + { 14627, 0x00000B21 }, /* GL_LINE_WIDTH */ + { 14641, 0x00000B23 }, /* GL_LINE_WIDTH_GRANULARITY */ + { 14667, 0x00000B22 }, /* GL_LINE_WIDTH_RANGE */ + { 14687, 0x00008B82 }, /* GL_LINK_STATUS */ + { 14702, 0x00000B32 }, /* GL_LIST_BASE */ + { 14715, 0x00020000 }, /* GL_LIST_BIT */ + { 14727, 0x00000B33 }, /* GL_LIST_INDEX */ + { 14741, 0x00000B30 }, /* GL_LIST_MODE */ + { 14754, 0x00000101 }, /* GL_LOAD */ + { 14762, 0x00000BF1 }, /* GL_LOGIC_OP */ + { 14774, 0x00000BF0 }, /* GL_LOGIC_OP_MODE */ + { 14791, 0x00008CA1 }, /* GL_LOWER_LEFT */ + { 14805, 0x00001909 }, /* GL_LUMINANCE */ + { 14818, 0x00008041 }, /* GL_LUMINANCE12 */ + { 14833, 0x00008047 }, /* GL_LUMINANCE12_ALPHA12 */ + { 14856, 0x00008047 }, /* GL_LUMINANCE12_ALPHA12_EXT */ + { 14883, 0x00008046 }, /* GL_LUMINANCE12_ALPHA4 */ + { 14905, 0x00008046 }, /* GL_LUMINANCE12_ALPHA4_EXT */ + { 14931, 0x00008041 }, /* GL_LUMINANCE12_EXT */ + { 14950, 0x00008042 }, /* GL_LUMINANCE16 */ + { 14965, 0x00008048 }, /* GL_LUMINANCE16_ALPHA16 */ + { 14988, 0x00008048 }, /* GL_LUMINANCE16_ALPHA16_EXT */ + { 15015, 0x00008042 }, /* GL_LUMINANCE16_EXT */ + { 15034, 0x0000803F }, /* GL_LUMINANCE4 */ + { 15048, 0x00008043 }, /* GL_LUMINANCE4_ALPHA4 */ + { 15069, 0x00008043 }, /* GL_LUMINANCE4_ALPHA4_EXT */ + { 15094, 0x0000803F }, /* GL_LUMINANCE4_EXT */ + { 15112, 0x00008044 }, /* GL_LUMINANCE6_ALPHA2 */ + { 15133, 0x00008044 }, /* GL_LUMINANCE6_ALPHA2_EXT */ + { 15158, 0x00008040 }, /* GL_LUMINANCE8 */ + { 15172, 0x00008045 }, /* GL_LUMINANCE8_ALPHA8 */ + { 15193, 0x00008045 }, /* GL_LUMINANCE8_ALPHA8_EXT */ + { 15218, 0x00008040 }, /* GL_LUMINANCE8_EXT */ + { 15236, 0x0000190A }, /* GL_LUMINANCE_ALPHA */ + { 15255, 0x00000D90 }, /* GL_MAP1_COLOR_4 */ + { 15271, 0x00000DD0 }, /* GL_MAP1_GRID_DOMAIN */ + { 15291, 0x00000DD1 }, /* GL_MAP1_GRID_SEGMENTS */ + { 15313, 0x00000D91 }, /* GL_MAP1_INDEX */ + { 15327, 0x00000D92 }, /* GL_MAP1_NORMAL */ + { 15342, 0x00000D93 }, /* GL_MAP1_TEXTURE_COORD_1 */ + { 15366, 0x00000D94 }, /* GL_MAP1_TEXTURE_COORD_2 */ + { 15390, 0x00000D95 }, /* GL_MAP1_TEXTURE_COORD_3 */ + { 15414, 0x00000D96 }, /* GL_MAP1_TEXTURE_COORD_4 */ + { 15438, 0x00000D97 }, /* GL_MAP1_VERTEX_3 */ + { 15455, 0x00000D98 }, /* GL_MAP1_VERTEX_4 */ + { 15472, 0x00008660 }, /* GL_MAP1_VERTEX_ATTRIB0_4_NV */ + { 15500, 0x0000866A }, /* GL_MAP1_VERTEX_ATTRIB10_4_NV */ + { 15529, 0x0000866B }, /* GL_MAP1_VERTEX_ATTRIB11_4_NV */ + { 15558, 0x0000866C }, /* GL_MAP1_VERTEX_ATTRIB12_4_NV */ + { 15587, 0x0000866D }, /* GL_MAP1_VERTEX_ATTRIB13_4_NV */ + { 15616, 0x0000866E }, /* GL_MAP1_VERTEX_ATTRIB14_4_NV */ + { 15645, 0x0000866F }, /* GL_MAP1_VERTEX_ATTRIB15_4_NV */ + { 15674, 0x00008661 }, /* GL_MAP1_VERTEX_ATTRIB1_4_NV */ + { 15702, 0x00008662 }, /* GL_MAP1_VERTEX_ATTRIB2_4_NV */ + { 15730, 0x00008663 }, /* GL_MAP1_VERTEX_ATTRIB3_4_NV */ + { 15758, 0x00008664 }, /* GL_MAP1_VERTEX_ATTRIB4_4_NV */ + { 15786, 0x00008665 }, /* GL_MAP1_VERTEX_ATTRIB5_4_NV */ + { 15814, 0x00008666 }, /* GL_MAP1_VERTEX_ATTRIB6_4_NV */ + { 15842, 0x00008667 }, /* GL_MAP1_VERTEX_ATTRIB7_4_NV */ + { 15870, 0x00008668 }, /* GL_MAP1_VERTEX_ATTRIB8_4_NV */ + { 15898, 0x00008669 }, /* GL_MAP1_VERTEX_ATTRIB9_4_NV */ + { 15926, 0x00000DB0 }, /* GL_MAP2_COLOR_4 */ + { 15942, 0x00000DD2 }, /* GL_MAP2_GRID_DOMAIN */ + { 15962, 0x00000DD3 }, /* GL_MAP2_GRID_SEGMENTS */ + { 15984, 0x00000DB1 }, /* GL_MAP2_INDEX */ + { 15998, 0x00000DB2 }, /* GL_MAP2_NORMAL */ + { 16013, 0x00000DB3 }, /* GL_MAP2_TEXTURE_COORD_1 */ + { 16037, 0x00000DB4 }, /* GL_MAP2_TEXTURE_COORD_2 */ + { 16061, 0x00000DB5 }, /* GL_MAP2_TEXTURE_COORD_3 */ + { 16085, 0x00000DB6 }, /* GL_MAP2_TEXTURE_COORD_4 */ + { 16109, 0x00000DB7 }, /* GL_MAP2_VERTEX_3 */ + { 16126, 0x00000DB8 }, /* GL_MAP2_VERTEX_4 */ + { 16143, 0x00008670 }, /* GL_MAP2_VERTEX_ATTRIB0_4_NV */ + { 16171, 0x0000867A }, /* GL_MAP2_VERTEX_ATTRIB10_4_NV */ + { 16200, 0x0000867B }, /* GL_MAP2_VERTEX_ATTRIB11_4_NV */ + { 16229, 0x0000867C }, /* GL_MAP2_VERTEX_ATTRIB12_4_NV */ + { 16258, 0x0000867D }, /* GL_MAP2_VERTEX_ATTRIB13_4_NV */ + { 16287, 0x0000867E }, /* GL_MAP2_VERTEX_ATTRIB14_4_NV */ + { 16316, 0x0000867F }, /* GL_MAP2_VERTEX_ATTRIB15_4_NV */ + { 16345, 0x00008671 }, /* GL_MAP2_VERTEX_ATTRIB1_4_NV */ + { 16373, 0x00008672 }, /* GL_MAP2_VERTEX_ATTRIB2_4_NV */ + { 16401, 0x00008673 }, /* GL_MAP2_VERTEX_ATTRIB3_4_NV */ + { 16429, 0x00008674 }, /* GL_MAP2_VERTEX_ATTRIB4_4_NV */ + { 16457, 0x00008675 }, /* GL_MAP2_VERTEX_ATTRIB5_4_NV */ + { 16485, 0x00008676 }, /* GL_MAP2_VERTEX_ATTRIB6_4_NV */ + { 16513, 0x00008677 }, /* GL_MAP2_VERTEX_ATTRIB7_4_NV */ + { 16541, 0x00008678 }, /* GL_MAP2_VERTEX_ATTRIB8_4_NV */ + { 16569, 0x00008679 }, /* GL_MAP2_VERTEX_ATTRIB9_4_NV */ + { 16597, 0x00000D10 }, /* GL_MAP_COLOR */ + { 16610, 0x00000D11 }, /* GL_MAP_STENCIL */ + { 16625, 0x000088C0 }, /* GL_MATRIX0_ARB */ + { 16640, 0x00008630 }, /* GL_MATRIX0_NV */ + { 16654, 0x000088CA }, /* GL_MATRIX10_ARB */ + { 16670, 0x000088CB }, /* GL_MATRIX11_ARB */ + { 16686, 0x000088CC }, /* GL_MATRIX12_ARB */ + { 16702, 0x000088CD }, /* GL_MATRIX13_ARB */ + { 16718, 0x000088CE }, /* GL_MATRIX14_ARB */ + { 16734, 0x000088CF }, /* GL_MATRIX15_ARB */ + { 16750, 0x000088D0 }, /* GL_MATRIX16_ARB */ + { 16766, 0x000088D1 }, /* GL_MATRIX17_ARB */ + { 16782, 0x000088D2 }, /* GL_MATRIX18_ARB */ + { 16798, 0x000088D3 }, /* GL_MATRIX19_ARB */ + { 16814, 0x000088C1 }, /* GL_MATRIX1_ARB */ + { 16829, 0x00008631 }, /* GL_MATRIX1_NV */ + { 16843, 0x000088D4 }, /* GL_MATRIX20_ARB */ + { 16859, 0x000088D5 }, /* GL_MATRIX21_ARB */ + { 16875, 0x000088D6 }, /* GL_MATRIX22_ARB */ + { 16891, 0x000088D7 }, /* GL_MATRIX23_ARB */ + { 16907, 0x000088D8 }, /* GL_MATRIX24_ARB */ + { 16923, 0x000088D9 }, /* GL_MATRIX25_ARB */ + { 16939, 0x000088DA }, /* GL_MATRIX26_ARB */ + { 16955, 0x000088DB }, /* GL_MATRIX27_ARB */ + { 16971, 0x000088DC }, /* GL_MATRIX28_ARB */ + { 16987, 0x000088DD }, /* GL_MATRIX29_ARB */ + { 17003, 0x000088C2 }, /* GL_MATRIX2_ARB */ + { 17018, 0x00008632 }, /* GL_MATRIX2_NV */ + { 17032, 0x000088DE }, /* GL_MATRIX30_ARB */ + { 17048, 0x000088DF }, /* GL_MATRIX31_ARB */ + { 17064, 0x000088C3 }, /* GL_MATRIX3_ARB */ + { 17079, 0x00008633 }, /* GL_MATRIX3_NV */ + { 17093, 0x000088C4 }, /* GL_MATRIX4_ARB */ + { 17108, 0x00008634 }, /* GL_MATRIX4_NV */ + { 17122, 0x000088C5 }, /* GL_MATRIX5_ARB */ + { 17137, 0x00008635 }, /* GL_MATRIX5_NV */ + { 17151, 0x000088C6 }, /* GL_MATRIX6_ARB */ + { 17166, 0x00008636 }, /* GL_MATRIX6_NV */ + { 17180, 0x000088C7 }, /* GL_MATRIX7_ARB */ + { 17195, 0x00008637 }, /* GL_MATRIX7_NV */ + { 17209, 0x000088C8 }, /* GL_MATRIX8_ARB */ + { 17224, 0x000088C9 }, /* GL_MATRIX9_ARB */ + { 17239, 0x00008844 }, /* GL_MATRIX_INDEX_ARRAY_ARB */ + { 17265, 0x00008849 }, /* GL_MATRIX_INDEX_ARRAY_POINTER_ARB */ + { 17299, 0x00008846 }, /* GL_MATRIX_INDEX_ARRAY_SIZE_ARB */ + { 17330, 0x00008848 }, /* GL_MATRIX_INDEX_ARRAY_STRIDE_ARB */ + { 17363, 0x00008847 }, /* GL_MATRIX_INDEX_ARRAY_TYPE_ARB */ + { 17394, 0x00000BA0 }, /* GL_MATRIX_MODE */ + { 17409, 0x00008840 }, /* GL_MATRIX_PALETTE_ARB */ + { 17431, 0x00008008 }, /* GL_MAX */ + { 17438, 0x00008073 }, /* GL_MAX_3D_TEXTURE_SIZE */ + { 17461, 0x000088FF }, /* GL_MAX_ARRAY_TEXTURE_LAYERS_EXT */ + { 17493, 0x00000D35 }, /* GL_MAX_ATTRIB_STACK_DEPTH */ + { 17519, 0x00000D3B }, /* GL_MAX_CLIENT_ATTRIB_STACK_DEPTH */ + { 17552, 0x00008177 }, /* GL_MAX_CLIPMAP_DEPTH_SGIX */ + { 17578, 0x00008178 }, /* GL_MAX_CLIPMAP_VIRTUAL_DEPTH_SGIX */ + { 17612, 0x00000D32 }, /* GL_MAX_CLIP_PLANES */ + { 17631, 0x00008CDF }, /* GL_MAX_COLOR_ATTACHMENTS_EXT */ + { 17660, 0x000080B3 }, /* GL_MAX_COLOR_MATRIX_STACK_DEPTH */ + { 17692, 0x000080B3 }, /* GL_MAX_COLOR_MATRIX_STACK_DEPTH_SGI */ + { 17728, 0x00008B4D }, /* GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS */ + { 17764, 0x00008B4D }, /* GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS_ARB */ + { 17804, 0x0000801B }, /* GL_MAX_CONVOLUTION_HEIGHT */ + { 17830, 0x0000801B }, /* GL_MAX_CONVOLUTION_HEIGHT_EXT */ + { 17860, 0x0000801A }, /* GL_MAX_CONVOLUTION_WIDTH */ + { 17885, 0x0000801A }, /* GL_MAX_CONVOLUTION_WIDTH_EXT */ + { 17914, 0x0000851C }, /* GL_MAX_CUBE_MAP_TEXTURE_SIZE */ + { 17943, 0x0000851C }, /* GL_MAX_CUBE_MAP_TEXTURE_SIZE_ARB */ + { 17976, 0x00008824 }, /* GL_MAX_DRAW_BUFFERS */ + { 17996, 0x00008824 }, /* GL_MAX_DRAW_BUFFERS_ARB */ + { 18020, 0x00008824 }, /* GL_MAX_DRAW_BUFFERS_ATI */ + { 18044, 0x000080E9 }, /* GL_MAX_ELEMENTS_INDICES */ + { 18068, 0x000080E8 }, /* GL_MAX_ELEMENTS_VERTICES */ + { 18093, 0x00000D30 }, /* GL_MAX_EVAL_ORDER */ + { 18111, 0x00008008 }, /* GL_MAX_EXT */ + { 18122, 0x00008B49 }, /* GL_MAX_FRAGMENT_UNIFORM_COMPONENTS */ + { 18157, 0x00008B49 }, /* GL_MAX_FRAGMENT_UNIFORM_COMPONENTS_ARB */ + { 18196, 0x00000D31 }, /* GL_MAX_LIGHTS */ + { 18210, 0x00000B31 }, /* GL_MAX_LIST_NESTING */ + { 18230, 0x00008841 }, /* GL_MAX_MATRIX_PALETTE_STACK_DEPTH_ARB */ + { 18268, 0x00000D36 }, /* GL_MAX_MODELVIEW_STACK_DEPTH */ + { 18297, 0x00000D37 }, /* GL_MAX_NAME_STACK_DEPTH */ + { 18321, 0x00008842 }, /* GL_MAX_PALETTE_MATRICES_ARB */ + { 18349, 0x00000D34 }, /* GL_MAX_PIXEL_MAP_TABLE */ + { 18372, 0x000088B1 }, /* GL_MAX_PROGRAM_ADDRESS_REGISTERS_ARB */ + { 18409, 0x0000880B }, /* GL_MAX_PROGRAM_ALU_INSTRUCTIONS_ARB */ + { 18445, 0x000088AD }, /* GL_MAX_PROGRAM_ATTRIBS_ARB */ + { 18472, 0x000088F5 }, /* GL_MAX_PROGRAM_CALL_DEPTH_NV */ + { 18501, 0x000088B5 }, /* GL_MAX_PROGRAM_ENV_PARAMETERS_ARB */ + { 18535, 0x000088F4 }, /* GL_MAX_PROGRAM_EXEC_INSTRUCTIONS_NV */ + { 18571, 0x000088F6 }, /* GL_MAX_PROGRAM_IF_DEPTH_NV */ + { 18598, 0x000088A1 }, /* GL_MAX_PROGRAM_INSTRUCTIONS_ARB */ + { 18630, 0x000088B4 }, /* GL_MAX_PROGRAM_LOCAL_PARAMETERS_ARB */ + { 18666, 0x000088F8 }, /* GL_MAX_PROGRAM_LOOP_COUNT_NV */ + { 18695, 0x000088F7 }, /* GL_MAX_PROGRAM_LOOP_DEPTH_NV */ + { 18724, 0x0000862F }, /* GL_MAX_PROGRAM_MATRICES_ARB */ + { 18752, 0x0000862E }, /* GL_MAX_PROGRAM_MATRIX_STACK_DEPTH_ARB */ + { 18790, 0x000088B3 }, /* GL_MAX_PROGRAM_NATIVE_ADDRESS_REGISTERS_ARB */ + { 18834, 0x0000880E }, /* GL_MAX_PROGRAM_NATIVE_ALU_INSTRUCTIONS_ARB */ + { 18877, 0x000088AF }, /* GL_MAX_PROGRAM_NATIVE_ATTRIBS_ARB */ + { 18911, 0x000088A3 }, /* GL_MAX_PROGRAM_NATIVE_INSTRUCTIONS_ARB */ + { 18950, 0x000088AB }, /* GL_MAX_PROGRAM_NATIVE_PARAMETERS_ARB */ + { 18987, 0x000088A7 }, /* GL_MAX_PROGRAM_NATIVE_TEMPORARIES_ARB */ + { 19025, 0x00008810 }, /* GL_MAX_PROGRAM_NATIVE_TEX_INDIRECTIONS_ARB */ + { 19068, 0x0000880F }, /* GL_MAX_PROGRAM_NATIVE_TEX_INSTRUCTIONS_ARB */ + { 19111, 0x000088A9 }, /* GL_MAX_PROGRAM_PARAMETERS_ARB */ + { 19141, 0x000088A5 }, /* GL_MAX_PROGRAM_TEMPORARIES_ARB */ + { 19172, 0x0000880D }, /* GL_MAX_PROGRAM_TEX_INDIRECTIONS_ARB */ + { 19208, 0x0000880C }, /* GL_MAX_PROGRAM_TEX_INSTRUCTIONS_ARB */ + { 19244, 0x00000D38 }, /* GL_MAX_PROJECTION_STACK_DEPTH */ + { 19274, 0x000084F8 }, /* GL_MAX_RECTANGLE_TEXTURE_SIZE_ARB */ + { 19308, 0x000084F8 }, /* GL_MAX_RECTANGLE_TEXTURE_SIZE_NV */ + { 19341, 0x000084E8 }, /* GL_MAX_RENDERBUFFER_SIZE_EXT */ + { 19370, 0x00008D57 }, /* GL_MAX_SAMPLES */ + { 19385, 0x00008504 }, /* GL_MAX_SHININESS_NV */ + { 19405, 0x00008505 }, /* GL_MAX_SPOT_EXPONENT_NV */ + { 19429, 0x00008871 }, /* GL_MAX_TEXTURE_COORDS */ + { 19451, 0x00008871 }, /* GL_MAX_TEXTURE_COORDS_ARB */ + { 19477, 0x00008872 }, /* GL_MAX_TEXTURE_IMAGE_UNITS */ + { 19504, 0x00008872 }, /* GL_MAX_TEXTURE_IMAGE_UNITS_ARB */ + { 19535, 0x000084FD }, /* GL_MAX_TEXTURE_LOD_BIAS */ + { 19559, 0x000084FF }, /* GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT */ + { 19593, 0x00000D33 }, /* GL_MAX_TEXTURE_SIZE */ + { 19613, 0x00000D39 }, /* GL_MAX_TEXTURE_STACK_DEPTH */ + { 19640, 0x000084E2 }, /* GL_MAX_TEXTURE_UNITS */ + { 19661, 0x000084E2 }, /* GL_MAX_TEXTURE_UNITS_ARB */ + { 19686, 0x0000862F }, /* GL_MAX_TRACK_MATRICES_NV */ + { 19711, 0x0000862E }, /* GL_MAX_TRACK_MATRIX_STACK_DEPTH_NV */ + { 19746, 0x00008B4B }, /* GL_MAX_VARYING_FLOATS */ + { 19768, 0x00008B4B }, /* GL_MAX_VARYING_FLOATS_ARB */ + { 19794, 0x00008869 }, /* GL_MAX_VERTEX_ATTRIBS */ + { 19816, 0x00008869 }, /* GL_MAX_VERTEX_ATTRIBS_ARB */ + { 19842, 0x00008B4C }, /* GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS */ + { 19876, 0x00008B4C }, /* GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS_ARB */ + { 19914, 0x00008B4A }, /* GL_MAX_VERTEX_UNIFORM_COMPONENTS */ + { 19947, 0x00008B4A }, /* GL_MAX_VERTEX_UNIFORM_COMPONENTS_ARB */ + { 19984, 0x000086A4 }, /* GL_MAX_VERTEX_UNITS_ARB */ + { 20008, 0x00000D3A }, /* GL_MAX_VIEWPORT_DIMS */ + { 20029, 0x00008007 }, /* GL_MIN */ + { 20036, 0x0000802E }, /* GL_MINMAX */ + { 20046, 0x0000802E }, /* GL_MINMAX_EXT */ + { 20060, 0x0000802F }, /* GL_MINMAX_FORMAT */ + { 20077, 0x0000802F }, /* GL_MINMAX_FORMAT_EXT */ + { 20098, 0x00008030 }, /* GL_MINMAX_SINK */ + { 20113, 0x00008030 }, /* GL_MINMAX_SINK_EXT */ + { 20132, 0x00008007 }, /* GL_MIN_EXT */ + { 20143, 0x00008370 }, /* GL_MIRRORED_REPEAT */ + { 20162, 0x00008370 }, /* GL_MIRRORED_REPEAT_ARB */ + { 20185, 0x00008370 }, /* GL_MIRRORED_REPEAT_IBM */ + { 20208, 0x00008742 }, /* GL_MIRROR_CLAMP_ATI */ + { 20228, 0x00008742 }, /* GL_MIRROR_CLAMP_EXT */ + { 20248, 0x00008912 }, /* GL_MIRROR_CLAMP_TO_BORDER_EXT */ + { 20278, 0x00008743 }, /* GL_MIRROR_CLAMP_TO_EDGE_ATI */ + { 20306, 0x00008743 }, /* GL_MIRROR_CLAMP_TO_EDGE_EXT */ + { 20334, 0x00001700 }, /* GL_MODELVIEW */ + { 20347, 0x00001700 }, /* GL_MODELVIEW0_ARB */ + { 20365, 0x0000872A }, /* GL_MODELVIEW10_ARB */ + { 20384, 0x0000872B }, /* GL_MODELVIEW11_ARB */ + { 20403, 0x0000872C }, /* GL_MODELVIEW12_ARB */ + { 20422, 0x0000872D }, /* GL_MODELVIEW13_ARB */ + { 20441, 0x0000872E }, /* GL_MODELVIEW14_ARB */ + { 20460, 0x0000872F }, /* GL_MODELVIEW15_ARB */ + { 20479, 0x00008730 }, /* GL_MODELVIEW16_ARB */ + { 20498, 0x00008731 }, /* GL_MODELVIEW17_ARB */ + { 20517, 0x00008732 }, /* GL_MODELVIEW18_ARB */ + { 20536, 0x00008733 }, /* GL_MODELVIEW19_ARB */ + { 20555, 0x0000850A }, /* GL_MODELVIEW1_ARB */ + { 20573, 0x00008734 }, /* GL_MODELVIEW20_ARB */ + { 20592, 0x00008735 }, /* GL_MODELVIEW21_ARB */ + { 20611, 0x00008736 }, /* GL_MODELVIEW22_ARB */ + { 20630, 0x00008737 }, /* GL_MODELVIEW23_ARB */ + { 20649, 0x00008738 }, /* GL_MODELVIEW24_ARB */ + { 20668, 0x00008739 }, /* GL_MODELVIEW25_ARB */ + { 20687, 0x0000873A }, /* GL_MODELVIEW26_ARB */ + { 20706, 0x0000873B }, /* GL_MODELVIEW27_ARB */ + { 20725, 0x0000873C }, /* GL_MODELVIEW28_ARB */ + { 20744, 0x0000873D }, /* GL_MODELVIEW29_ARB */ + { 20763, 0x00008722 }, /* GL_MODELVIEW2_ARB */ + { 20781, 0x0000873E }, /* GL_MODELVIEW30_ARB */ + { 20800, 0x0000873F }, /* GL_MODELVIEW31_ARB */ + { 20819, 0x00008723 }, /* GL_MODELVIEW3_ARB */ + { 20837, 0x00008724 }, /* GL_MODELVIEW4_ARB */ + { 20855, 0x00008725 }, /* GL_MODELVIEW5_ARB */ + { 20873, 0x00008726 }, /* GL_MODELVIEW6_ARB */ + { 20891, 0x00008727 }, /* GL_MODELVIEW7_ARB */ + { 20909, 0x00008728 }, /* GL_MODELVIEW8_ARB */ + { 20927, 0x00008729 }, /* GL_MODELVIEW9_ARB */ + { 20945, 0x00000BA6 }, /* GL_MODELVIEW_MATRIX */ + { 20965, 0x00008629 }, /* GL_MODELVIEW_PROJECTION_NV */ + { 20992, 0x00000BA3 }, /* GL_MODELVIEW_STACK_DEPTH */ + { 21017, 0x00002100 }, /* GL_MODULATE */ + { 21029, 0x00008744 }, /* GL_MODULATE_ADD_ATI */ + { 21049, 0x00008745 }, /* GL_MODULATE_SIGNED_ADD_ATI */ + { 21076, 0x00008746 }, /* GL_MODULATE_SUBTRACT_ATI */ + { 21101, 0x00000103 }, /* GL_MULT */ + { 21109, 0x0000809D }, /* GL_MULTISAMPLE */ + { 21124, 0x000086B2 }, /* GL_MULTISAMPLE_3DFX */ + { 21144, 0x0000809D }, /* GL_MULTISAMPLE_ARB */ + { 21163, 0x20000000 }, /* GL_MULTISAMPLE_BIT */ + { 21182, 0x20000000 }, /* GL_MULTISAMPLE_BIT_3DFX */ + { 21206, 0x20000000 }, /* GL_MULTISAMPLE_BIT_ARB */ + { 21229, 0x00008534 }, /* GL_MULTISAMPLE_FILTER_HINT_NV */ + { 21259, 0x00002A25 }, /* GL_N3F_V3F */ + { 21270, 0x00000D70 }, /* GL_NAME_STACK_DEPTH */ + { 21290, 0x0000150E }, /* GL_NAND */ + { 21298, 0x00002600 }, /* GL_NEAREST */ + { 21309, 0x0000844E }, /* GL_NEAREST_CLIPMAP_LINEAR_SGIX */ + { 21340, 0x0000844D }, /* GL_NEAREST_CLIPMAP_NEAREST_SGIX */ + { 21372, 0x00002702 }, /* GL_NEAREST_MIPMAP_LINEAR */ + { 21397, 0x00002700 }, /* GL_NEAREST_MIPMAP_NEAREST */ + { 21423, 0x00000200 }, /* GL_NEVER */ + { 21432, 0x00001102 }, /* GL_NICEST */ + { 21442, 0x00000000 }, /* GL_NONE */ + { 21450, 0x00001505 }, /* GL_NOOP */ + { 21458, 0x00001508 }, /* GL_NOR */ + { 21465, 0x00000BA1 }, /* GL_NORMALIZE */ + { 21478, 0x00008075 }, /* GL_NORMAL_ARRAY */ + { 21494, 0x00008897 }, /* GL_NORMAL_ARRAY_BUFFER_BINDING */ + { 21525, 0x00008897 }, /* GL_NORMAL_ARRAY_BUFFER_BINDING_ARB */ + { 21560, 0x0000808F }, /* GL_NORMAL_ARRAY_POINTER */ + { 21584, 0x0000807F }, /* GL_NORMAL_ARRAY_STRIDE */ + { 21607, 0x0000807E }, /* GL_NORMAL_ARRAY_TYPE */ + { 21628, 0x00008511 }, /* GL_NORMAL_MAP */ + { 21642, 0x00008511 }, /* GL_NORMAL_MAP_ARB */ + { 21660, 0x00008511 }, /* GL_NORMAL_MAP_NV */ + { 21677, 0x00000205 }, /* GL_NOTEQUAL */ + { 21689, 0x00000000 }, /* GL_NO_ERROR */ + { 21701, 0x000086A2 }, /* GL_NUM_COMPRESSED_TEXTURE_FORMATS */ + { 21735, 0x000086A2 }, /* GL_NUM_COMPRESSED_TEXTURE_FORMATS_ARB */ + { 21773, 0x00008B89 }, /* GL_OBJECT_ACTIVE_ATTRIBUTES_ARB */ + { 21805, 0x00008B8A }, /* GL_OBJECT_ACTIVE_ATTRIBUTE_MAX_LENGTH_ARB */ + { 21847, 0x00008B86 }, /* GL_OBJECT_ACTIVE_UNIFORMS_ARB */ + { 21877, 0x00008B87 }, /* GL_OBJECT_ACTIVE_UNIFORM_MAX_LENGTH_ARB */ + { 21917, 0x00008B85 }, /* GL_OBJECT_ATTACHED_OBJECTS_ARB */ + { 21948, 0x00008B81 }, /* GL_OBJECT_COMPILE_STATUS_ARB */ + { 21977, 0x00008B80 }, /* GL_OBJECT_DELETE_STATUS_ARB */ + { 22005, 0x00008B84 }, /* GL_OBJECT_INFO_LOG_LENGTH_ARB */ + { 22035, 0x00002401 }, /* GL_OBJECT_LINEAR */ + { 22052, 0x00008B82 }, /* GL_OBJECT_LINK_STATUS_ARB */ + { 22078, 0x00002501 }, /* GL_OBJECT_PLANE */ + { 22094, 0x00008B88 }, /* GL_OBJECT_SHADER_SOURCE_LENGTH_ARB */ + { 22129, 0x00008B4F }, /* GL_OBJECT_SUBTYPE_ARB */ + { 22151, 0x00008B4E }, /* GL_OBJECT_TYPE_ARB */ + { 22170, 0x00008B83 }, /* GL_OBJECT_VALIDATE_STATUS_ARB */ + { 22200, 0x00008165 }, /* GL_OCCLUSION_TEST_HP */ + { 22221, 0x00008166 }, /* GL_OCCLUSION_TEST_RESULT_HP */ + { 22249, 0x00000001 }, /* GL_ONE */ + { 22256, 0x00008004 }, /* GL_ONE_MINUS_CONSTANT_ALPHA */ + { 22284, 0x00008004 }, /* GL_ONE_MINUS_CONSTANT_ALPHA_EXT */ + { 22316, 0x00008002 }, /* GL_ONE_MINUS_CONSTANT_COLOR */ + { 22344, 0x00008002 }, /* GL_ONE_MINUS_CONSTANT_COLOR_EXT */ + { 22376, 0x00000305 }, /* GL_ONE_MINUS_DST_ALPHA */ + { 22399, 0x00000307 }, /* GL_ONE_MINUS_DST_COLOR */ + { 22422, 0x00000303 }, /* GL_ONE_MINUS_SRC_ALPHA */ + { 22445, 0x00000301 }, /* GL_ONE_MINUS_SRC_COLOR */ + { 22468, 0x00008598 }, /* GL_OPERAND0_ALPHA */ + { 22486, 0x00008598 }, /* GL_OPERAND0_ALPHA_ARB */ + { 22508, 0x00008598 }, /* GL_OPERAND0_ALPHA_EXT */ + { 22530, 0x00008590 }, /* GL_OPERAND0_RGB */ + { 22546, 0x00008590 }, /* GL_OPERAND0_RGB_ARB */ + { 22566, 0x00008590 }, /* GL_OPERAND0_RGB_EXT */ + { 22586, 0x00008599 }, /* GL_OPERAND1_ALPHA */ + { 22604, 0x00008599 }, /* GL_OPERAND1_ALPHA_ARB */ + { 22626, 0x00008599 }, /* GL_OPERAND1_ALPHA_EXT */ + { 22648, 0x00008591 }, /* GL_OPERAND1_RGB */ + { 22664, 0x00008591 }, /* GL_OPERAND1_RGB_ARB */ + { 22684, 0x00008591 }, /* GL_OPERAND1_RGB_EXT */ + { 22704, 0x0000859A }, /* GL_OPERAND2_ALPHA */ + { 22722, 0x0000859A }, /* GL_OPERAND2_ALPHA_ARB */ + { 22744, 0x0000859A }, /* GL_OPERAND2_ALPHA_EXT */ + { 22766, 0x00008592 }, /* GL_OPERAND2_RGB */ + { 22782, 0x00008592 }, /* GL_OPERAND2_RGB_ARB */ + { 22802, 0x00008592 }, /* GL_OPERAND2_RGB_EXT */ + { 22822, 0x0000859B }, /* GL_OPERAND3_ALPHA_NV */ + { 22843, 0x00008593 }, /* GL_OPERAND3_RGB_NV */ + { 22862, 0x00001507 }, /* GL_OR */ + { 22868, 0x00000A01 }, /* GL_ORDER */ + { 22877, 0x0000150D }, /* GL_OR_INVERTED */ + { 22892, 0x0000150B }, /* GL_OR_REVERSE */ + { 22906, 0x00000505 }, /* GL_OUT_OF_MEMORY */ + { 22923, 0x00000D05 }, /* GL_PACK_ALIGNMENT */ + { 22941, 0x0000806C }, /* GL_PACK_IMAGE_HEIGHT */ + { 22962, 0x00008758 }, /* GL_PACK_INVERT_MESA */ + { 22982, 0x00000D01 }, /* GL_PACK_LSB_FIRST */ + { 23000, 0x00000D02 }, /* GL_PACK_ROW_LENGTH */ + { 23019, 0x0000806B }, /* GL_PACK_SKIP_IMAGES */ + { 23039, 0x00000D04 }, /* GL_PACK_SKIP_PIXELS */ + { 23059, 0x00000D03 }, /* GL_PACK_SKIP_ROWS */ + { 23077, 0x00000D00 }, /* GL_PACK_SWAP_BYTES */ + { 23096, 0x00008B92 }, /* GL_PALETTE4_R5_G6_B5_OES */ + { 23121, 0x00008B94 }, /* GL_PALETTE4_RGB5_A1_OES */ + { 23145, 0x00008B90 }, /* GL_PALETTE4_RGB8_OES */ + { 23166, 0x00008B93 }, /* GL_PALETTE4_RGBA4_OES */ + { 23188, 0x00008B91 }, /* GL_PALETTE4_RGBA8_OES */ + { 23210, 0x00008B97 }, /* GL_PALETTE8_R5_G6_B5_OES */ + { 23235, 0x00008B99 }, /* GL_PALETTE8_RGB5_A1_OES */ + { 23259, 0x00008B95 }, /* GL_PALETTE8_RGB8_OES */ + { 23280, 0x00008B98 }, /* GL_PALETTE8_RGBA4_OES */ + { 23302, 0x00008B96 }, /* GL_PALETTE8_RGBA8_OES */ + { 23324, 0x00000700 }, /* GL_PASS_THROUGH_TOKEN */ + { 23346, 0x00000C50 }, /* GL_PERSPECTIVE_CORRECTION_HINT */ + { 23377, 0x00000C79 }, /* GL_PIXEL_MAP_A_TO_A */ + { 23397, 0x00000CB9 }, /* GL_PIXEL_MAP_A_TO_A_SIZE */ + { 23422, 0x00000C78 }, /* GL_PIXEL_MAP_B_TO_B */ + { 23442, 0x00000CB8 }, /* GL_PIXEL_MAP_B_TO_B_SIZE */ + { 23467, 0x00000C77 }, /* GL_PIXEL_MAP_G_TO_G */ + { 23487, 0x00000CB7 }, /* GL_PIXEL_MAP_G_TO_G_SIZE */ + { 23512, 0x00000C75 }, /* GL_PIXEL_MAP_I_TO_A */ + { 23532, 0x00000CB5 }, /* GL_PIXEL_MAP_I_TO_A_SIZE */ + { 23557, 0x00000C74 }, /* GL_PIXEL_MAP_I_TO_B */ + { 23577, 0x00000CB4 }, /* GL_PIXEL_MAP_I_TO_B_SIZE */ + { 23602, 0x00000C73 }, /* GL_PIXEL_MAP_I_TO_G */ + { 23622, 0x00000CB3 }, /* GL_PIXEL_MAP_I_TO_G_SIZE */ + { 23647, 0x00000C70 }, /* GL_PIXEL_MAP_I_TO_I */ + { 23667, 0x00000CB0 }, /* GL_PIXEL_MAP_I_TO_I_SIZE */ + { 23692, 0x00000C72 }, /* GL_PIXEL_MAP_I_TO_R */ + { 23712, 0x00000CB2 }, /* GL_PIXEL_MAP_I_TO_R_SIZE */ + { 23737, 0x00000C76 }, /* GL_PIXEL_MAP_R_TO_R */ + { 23757, 0x00000CB6 }, /* GL_PIXEL_MAP_R_TO_R_SIZE */ + { 23782, 0x00000C71 }, /* GL_PIXEL_MAP_S_TO_S */ + { 23802, 0x00000CB1 }, /* GL_PIXEL_MAP_S_TO_S_SIZE */ + { 23827, 0x00000020 }, /* GL_PIXEL_MODE_BIT */ + { 23845, 0x000088ED }, /* GL_PIXEL_PACK_BUFFER_BINDING_EXT */ + { 23878, 0x000088EB }, /* GL_PIXEL_PACK_BUFFER_EXT */ + { 23903, 0x000088EF }, /* GL_PIXEL_UNPACK_BUFFER_BINDING_EXT */ + { 23938, 0x000088EC }, /* GL_PIXEL_UNPACK_BUFFER_EXT */ + { 23965, 0x00001B00 }, /* GL_POINT */ + { 23974, 0x00000000 }, /* GL_POINTS */ + { 23984, 0x00000002 }, /* GL_POINT_BIT */ + { 23997, 0x00008129 }, /* GL_POINT_DISTANCE_ATTENUATION */ + { 24027, 0x00008129 }, /* GL_POINT_DISTANCE_ATTENUATION_ARB */ + { 24061, 0x00008129 }, /* GL_POINT_DISTANCE_ATTENUATION_EXT */ + { 24095, 0x00008129 }, /* GL_POINT_DISTANCE_ATTENUATION_SGIS */ + { 24130, 0x00008128 }, /* GL_POINT_FADE_THRESHOLD_SIZE */ + { 24159, 0x00008128 }, /* GL_POINT_FADE_THRESHOLD_SIZE_ARB */ + { 24192, 0x00008128 }, /* GL_POINT_FADE_THRESHOLD_SIZE_EXT */ + { 24225, 0x00008128 }, /* GL_POINT_FADE_THRESHOLD_SIZE_SGIS */ + { 24259, 0x00000B11 }, /* GL_POINT_SIZE */ + { 24273, 0x00000B13 }, /* GL_POINT_SIZE_GRANULARITY */ + { 24299, 0x00008127 }, /* GL_POINT_SIZE_MAX */ + { 24317, 0x00008127 }, /* GL_POINT_SIZE_MAX_ARB */ + { 24339, 0x00008127 }, /* GL_POINT_SIZE_MAX_EXT */ + { 24361, 0x00008127 }, /* GL_POINT_SIZE_MAX_SGIS */ + { 24384, 0x00008126 }, /* GL_POINT_SIZE_MIN */ + { 24402, 0x00008126 }, /* GL_POINT_SIZE_MIN_ARB */ + { 24424, 0x00008126 }, /* GL_POINT_SIZE_MIN_EXT */ + { 24446, 0x00008126 }, /* GL_POINT_SIZE_MIN_SGIS */ + { 24469, 0x00000B12 }, /* GL_POINT_SIZE_RANGE */ + { 24489, 0x00000B10 }, /* GL_POINT_SMOOTH */ + { 24505, 0x00000C51 }, /* GL_POINT_SMOOTH_HINT */ + { 24526, 0x00008861 }, /* GL_POINT_SPRITE */ + { 24542, 0x00008861 }, /* GL_POINT_SPRITE_ARB */ + { 24562, 0x00008CA0 }, /* GL_POINT_SPRITE_COORD_ORIGIN */ + { 24591, 0x00008861 }, /* GL_POINT_SPRITE_NV */ + { 24610, 0x00008863 }, /* GL_POINT_SPRITE_R_MODE_NV */ + { 24636, 0x00000701 }, /* GL_POINT_TOKEN */ + { 24651, 0x00000009 }, /* GL_POLYGON */ + { 24662, 0x00000008 }, /* GL_POLYGON_BIT */ + { 24677, 0x00000B40 }, /* GL_POLYGON_MODE */ + { 24693, 0x00008039 }, /* GL_POLYGON_OFFSET_BIAS */ + { 24716, 0x00008038 }, /* GL_POLYGON_OFFSET_FACTOR */ + { 24741, 0x00008037 }, /* GL_POLYGON_OFFSET_FILL */ + { 24764, 0x00002A02 }, /* GL_POLYGON_OFFSET_LINE */ + { 24787, 0x00002A01 }, /* GL_POLYGON_OFFSET_POINT */ + { 24811, 0x00002A00 }, /* GL_POLYGON_OFFSET_UNITS */ + { 24835, 0x00000B41 }, /* GL_POLYGON_SMOOTH */ + { 24853, 0x00000C53 }, /* GL_POLYGON_SMOOTH_HINT */ + { 24876, 0x00000B42 }, /* GL_POLYGON_STIPPLE */ + { 24895, 0x00000010 }, /* GL_POLYGON_STIPPLE_BIT */ + { 24918, 0x00000703 }, /* GL_POLYGON_TOKEN */ + { 24935, 0x00001203 }, /* GL_POSITION */ + { 24947, 0x000080BB }, /* GL_POST_COLOR_MATRIX_ALPHA_BIAS */ + { 24979, 0x000080BB }, /* GL_POST_COLOR_MATRIX_ALPHA_BIAS_SGI */ + { 25015, 0x000080B7 }, /* GL_POST_COLOR_MATRIX_ALPHA_SCALE */ + { 25048, 0x000080B7 }, /* GL_POST_COLOR_MATRIX_ALPHA_SCALE_SGI */ + { 25085, 0x000080BA }, /* GL_POST_COLOR_MATRIX_BLUE_BIAS */ + { 25116, 0x000080BA }, /* GL_POST_COLOR_MATRIX_BLUE_BIAS_SGI */ + { 25151, 0x000080B6 }, /* GL_POST_COLOR_MATRIX_BLUE_SCALE */ + { 25183, 0x000080B6 }, /* GL_POST_COLOR_MATRIX_BLUE_SCALE_SGI */ + { 25219, 0x000080D2 }, /* GL_POST_COLOR_MATRIX_COLOR_TABLE */ + { 25252, 0x000080B9 }, /* GL_POST_COLOR_MATRIX_GREEN_BIAS */ + { 25284, 0x000080B9 }, /* GL_POST_COLOR_MATRIX_GREEN_BIAS_SGI */ + { 25320, 0x000080B5 }, /* GL_POST_COLOR_MATRIX_GREEN_SCALE */ + { 25353, 0x000080B5 }, /* GL_POST_COLOR_MATRIX_GREEN_SCALE_SGI */ + { 25390, 0x000080B8 }, /* GL_POST_COLOR_MATRIX_RED_BIAS */ + { 25420, 0x000080B8 }, /* GL_POST_COLOR_MATRIX_RED_BIAS_SGI */ + { 25454, 0x000080B4 }, /* GL_POST_COLOR_MATRIX_RED_SCALE */ + { 25485, 0x000080B4 }, /* GL_POST_COLOR_MATRIX_RED_SCALE_SGI */ + { 25520, 0x00008023 }, /* GL_POST_CONVOLUTION_ALPHA_BIAS */ + { 25551, 0x00008023 }, /* GL_POST_CONVOLUTION_ALPHA_BIAS_EXT */ + { 25586, 0x0000801F }, /* GL_POST_CONVOLUTION_ALPHA_SCALE */ + { 25618, 0x0000801F }, /* GL_POST_CONVOLUTION_ALPHA_SCALE_EXT */ + { 25654, 0x00008022 }, /* GL_POST_CONVOLUTION_BLUE_BIAS */ + { 25684, 0x00008022 }, /* GL_POST_CONVOLUTION_BLUE_BIAS_EXT */ + { 25718, 0x0000801E }, /* GL_POST_CONVOLUTION_BLUE_SCALE */ + { 25749, 0x0000801E }, /* GL_POST_CONVOLUTION_BLUE_SCALE_EXT */ + { 25784, 0x000080D1 }, /* GL_POST_CONVOLUTION_COLOR_TABLE */ + { 25816, 0x00008021 }, /* GL_POST_CONVOLUTION_GREEN_BIAS */ + { 25847, 0x00008021 }, /* GL_POST_CONVOLUTION_GREEN_BIAS_EXT */ + { 25882, 0x0000801D }, /* GL_POST_CONVOLUTION_GREEN_SCALE */ + { 25914, 0x0000801D }, /* GL_POST_CONVOLUTION_GREEN_SCALE_EXT */ + { 25950, 0x00008020 }, /* GL_POST_CONVOLUTION_RED_BIAS */ + { 25979, 0x00008020 }, /* GL_POST_CONVOLUTION_RED_BIAS_EXT */ + { 26012, 0x0000801C }, /* GL_POST_CONVOLUTION_RED_SCALE */ + { 26042, 0x0000801C }, /* GL_POST_CONVOLUTION_RED_SCALE_EXT */ + { 26076, 0x0000817B }, /* GL_POST_TEXTURE_FILTER_BIAS_RANGE_SGIX */ + { 26115, 0x00008179 }, /* GL_POST_TEXTURE_FILTER_BIAS_SGIX */ + { 26148, 0x0000817C }, /* GL_POST_TEXTURE_FILTER_SCALE_RANGE_SGIX */ + { 26188, 0x0000817A }, /* GL_POST_TEXTURE_FILTER_SCALE_SGIX */ + { 26222, 0x00008578 }, /* GL_PREVIOUS */ + { 26234, 0x00008578 }, /* GL_PREVIOUS_ARB */ + { 26250, 0x00008578 }, /* GL_PREVIOUS_EXT */ + { 26266, 0x00008577 }, /* GL_PRIMARY_COLOR */ + { 26283, 0x00008577 }, /* GL_PRIMARY_COLOR_ARB */ + { 26304, 0x00008577 }, /* GL_PRIMARY_COLOR_EXT */ + { 26325, 0x000088B0 }, /* GL_PROGRAM_ADDRESS_REGISTERS_ARB */ + { 26358, 0x00008805 }, /* GL_PROGRAM_ALU_INSTRUCTIONS_ARB */ + { 26390, 0x000088AC }, /* GL_PROGRAM_ATTRIBS_ARB */ + { 26413, 0x00008677 }, /* GL_PROGRAM_BINDING_ARB */ + { 26436, 0x0000864B }, /* GL_PROGRAM_ERROR_POSITION_ARB */ + { 26466, 0x0000864B }, /* GL_PROGRAM_ERROR_POSITION_NV */ + { 26495, 0x00008874 }, /* GL_PROGRAM_ERROR_STRING_ARB */ + { 26523, 0x00008876 }, /* GL_PROGRAM_FORMAT_ARB */ + { 26545, 0x00008875 }, /* GL_PROGRAM_FORMAT_ASCII_ARB */ + { 26573, 0x000088A0 }, /* GL_PROGRAM_INSTRUCTIONS_ARB */ + { 26601, 0x00008627 }, /* GL_PROGRAM_LENGTH_ARB */ + { 26623, 0x00008627 }, /* GL_PROGRAM_LENGTH_NV */ + { 26644, 0x000088B2 }, /* GL_PROGRAM_NATIVE_ADDRESS_REGISTERS_ARB */ + { 26684, 0x00008808 }, /* GL_PROGRAM_NATIVE_ALU_INSTRUCTIONS_ARB */ + { 26723, 0x000088AE }, /* GL_PROGRAM_NATIVE_ATTRIBS_ARB */ + { 26753, 0x000088A2 }, /* GL_PROGRAM_NATIVE_INSTRUCTIONS_ARB */ + { 26788, 0x000088AA }, /* GL_PROGRAM_NATIVE_PARAMETERS_ARB */ + { 26821, 0x000088A6 }, /* GL_PROGRAM_NATIVE_TEMPORARIES_ARB */ + { 26855, 0x0000880A }, /* GL_PROGRAM_NATIVE_TEX_INDIRECTIONS_ARB */ + { 26894, 0x00008809 }, /* GL_PROGRAM_NATIVE_TEX_INSTRUCTIONS_ARB */ + { 26933, 0x00008B40 }, /* GL_PROGRAM_OBJECT_ARB */ + { 26955, 0x000088A8 }, /* GL_PROGRAM_PARAMETERS_ARB */ + { 26981, 0x00008644 }, /* GL_PROGRAM_PARAMETER_NV */ + { 27005, 0x00008647 }, /* GL_PROGRAM_RESIDENT_NV */ + { 27028, 0x00008628 }, /* GL_PROGRAM_STRING_ARB */ + { 27050, 0x00008628 }, /* GL_PROGRAM_STRING_NV */ + { 27071, 0x00008646 }, /* GL_PROGRAM_TARGET_NV */ + { 27092, 0x000088A4 }, /* GL_PROGRAM_TEMPORARIES_ARB */ + { 27119, 0x00008807 }, /* GL_PROGRAM_TEX_INDIRECTIONS_ARB */ + { 27151, 0x00008806 }, /* GL_PROGRAM_TEX_INSTRUCTIONS_ARB */ + { 27183, 0x000088B6 }, /* GL_PROGRAM_UNDER_NATIVE_LIMITS_ARB */ + { 27218, 0x00001701 }, /* GL_PROJECTION */ + { 27232, 0x00000BA7 }, /* GL_PROJECTION_MATRIX */ + { 27253, 0x00000BA4 }, /* GL_PROJECTION_STACK_DEPTH */ + { 27279, 0x000080D3 }, /* GL_PROXY_COLOR_TABLE */ + { 27300, 0x00008025 }, /* GL_PROXY_HISTOGRAM */ + { 27319, 0x00008025 }, /* GL_PROXY_HISTOGRAM_EXT */ + { 27342, 0x000080D5 }, /* GL_PROXY_POST_COLOR_MATRIX_COLOR_TABLE */ + { 27381, 0x000080D4 }, /* GL_PROXY_POST_CONVOLUTION_COLOR_TABLE */ + { 27419, 0x00008063 }, /* GL_PROXY_TEXTURE_1D */ + { 27439, 0x00008C19 }, /* GL_PROXY_TEXTURE_1D_ARRAY_EXT */ + { 27469, 0x00008063 }, /* GL_PROXY_TEXTURE_1D_EXT */ + { 27493, 0x00008064 }, /* GL_PROXY_TEXTURE_2D */ + { 27513, 0x00008C1B }, /* GL_PROXY_TEXTURE_2D_ARRAY_EXT */ + { 27543, 0x00008064 }, /* GL_PROXY_TEXTURE_2D_EXT */ + { 27567, 0x00008070 }, /* GL_PROXY_TEXTURE_3D */ + { 27587, 0x000080BD }, /* GL_PROXY_TEXTURE_COLOR_TABLE_SGI */ + { 27620, 0x0000851B }, /* GL_PROXY_TEXTURE_CUBE_MAP */ + { 27646, 0x0000851B }, /* GL_PROXY_TEXTURE_CUBE_MAP_ARB */ + { 27676, 0x000084F7 }, /* GL_PROXY_TEXTURE_RECTANGLE_ARB */ + { 27707, 0x000084F7 }, /* GL_PROXY_TEXTURE_RECTANGLE_NV */ + { 27737, 0x00002003 }, /* GL_Q */ + { 27742, 0x00001209 }, /* GL_QUADRATIC_ATTENUATION */ + { 27767, 0x00000007 }, /* GL_QUADS */ + { 27776, 0x00008614 }, /* GL_QUAD_MESH_SUN */ + { 27793, 0x00000008 }, /* GL_QUAD_STRIP */ + { 27807, 0x00008864 }, /* GL_QUERY_COUNTER_BITS */ + { 27829, 0x00008864 }, /* GL_QUERY_COUNTER_BITS_ARB */ + { 27855, 0x00008866 }, /* GL_QUERY_RESULT */ + { 27871, 0x00008866 }, /* GL_QUERY_RESULT_ARB */ + { 27891, 0x00008867 }, /* GL_QUERY_RESULT_AVAILABLE */ + { 27917, 0x00008867 }, /* GL_QUERY_RESULT_AVAILABLE_ARB */ + { 27947, 0x00002002 }, /* GL_R */ + { 27952, 0x00002A10 }, /* GL_R3_G3_B2 */ + { 27964, 0x00019262 }, /* GL_RASTER_POSITION_UNCLIPPED_IBM */ + { 27997, 0x00000C02 }, /* GL_READ_BUFFER */ + { 28012, 0x00008CA8 }, /* GL_READ_FRAMEBUFFER */ + { 28032, 0x00008CAA }, /* GL_READ_FRAMEBUFFER_BINDING_EXT */ + { 28064, 0x00008CA8 }, /* GL_READ_FRAMEBUFFER_EXT */ + { 28088, 0x000088B8 }, /* GL_READ_ONLY */ + { 28101, 0x000088B8 }, /* GL_READ_ONLY_ARB */ + { 28118, 0x000088BA }, /* GL_READ_WRITE */ + { 28132, 0x000088BA }, /* GL_READ_WRITE_ARB */ + { 28150, 0x00001903 }, /* GL_RED */ + { 28157, 0x00008016 }, /* GL_REDUCE */ + { 28167, 0x00008016 }, /* GL_REDUCE_EXT */ + { 28181, 0x00000D15 }, /* GL_RED_BIAS */ + { 28193, 0x00000D52 }, /* GL_RED_BITS */ + { 28205, 0x00000D14 }, /* GL_RED_SCALE */ + { 28218, 0x00008512 }, /* GL_REFLECTION_MAP */ + { 28236, 0x00008512 }, /* GL_REFLECTION_MAP_ARB */ + { 28258, 0x00008512 }, /* GL_REFLECTION_MAP_NV */ + { 28279, 0x00001C00 }, /* GL_RENDER */ + { 28289, 0x00008D41 }, /* GL_RENDERBUFFER */ + { 28305, 0x00008D53 }, /* GL_RENDERBUFFER_ALPHA_SIZE */ + { 28332, 0x00008CA7 }, /* GL_RENDERBUFFER_BINDING_EXT */ + { 28360, 0x00008D52 }, /* GL_RENDERBUFFER_BLUE_SIZE */ + { 28386, 0x00008D54 }, /* GL_RENDERBUFFER_DEPTH_SIZE */ + { 28413, 0x00008D41 }, /* GL_RENDERBUFFER_EXT */ + { 28433, 0x00008D51 }, /* GL_RENDERBUFFER_GREEN_SIZE */ + { 28460, 0x00008D43 }, /* GL_RENDERBUFFER_HEIGHT */ + { 28483, 0x00008D43 }, /* GL_RENDERBUFFER_HEIGHT_EXT */ + { 28510, 0x00008D44 }, /* GL_RENDERBUFFER_INTERNAL_FORMAT */ + { 28542, 0x00008D44 }, /* GL_RENDERBUFFER_INTERNAL_FORMAT_EXT */ + { 28578, 0x00008D50 }, /* GL_RENDERBUFFER_RED_SIZE */ + { 28603, 0x00008CAB }, /* GL_RENDERBUFFER_SAMPLES */ + { 28627, 0x00008D55 }, /* GL_RENDERBUFFER_STENCIL_SIZE */ + { 28656, 0x00008D42 }, /* GL_RENDERBUFFER_WIDTH */ + { 28678, 0x00008D42 }, /* GL_RENDERBUFFER_WIDTH_EXT */ + { 28704, 0x00001F01 }, /* GL_RENDERER */ + { 28716, 0x00000C40 }, /* GL_RENDER_MODE */ + { 28731, 0x00002901 }, /* GL_REPEAT */ + { 28741, 0x00001E01 }, /* GL_REPLACE */ + { 28752, 0x00008062 }, /* GL_REPLACE_EXT */ + { 28767, 0x00008153 }, /* GL_REPLICATE_BORDER_HP */ + { 28790, 0x0000803A }, /* GL_RESCALE_NORMAL */ + { 28808, 0x0000803A }, /* GL_RESCALE_NORMAL_EXT */ + { 28830, 0x00000102 }, /* GL_RETURN */ + { 28840, 0x00001907 }, /* GL_RGB */ + { 28847, 0x00008052 }, /* GL_RGB10 */ + { 28856, 0x00008059 }, /* GL_RGB10_A2 */ + { 28868, 0x00008059 }, /* GL_RGB10_A2_EXT */ + { 28884, 0x00008052 }, /* GL_RGB10_EXT */ + { 28897, 0x00008053 }, /* GL_RGB12 */ + { 28906, 0x00008053 }, /* GL_RGB12_EXT */ + { 28919, 0x00008054 }, /* GL_RGB16 */ + { 28928, 0x00008054 }, /* GL_RGB16_EXT */ + { 28941, 0x0000804E }, /* GL_RGB2_EXT */ + { 28953, 0x0000804F }, /* GL_RGB4 */ + { 28961, 0x0000804F }, /* GL_RGB4_EXT */ + { 28973, 0x000083A1 }, /* GL_RGB4_S3TC */ + { 28986, 0x00008050 }, /* GL_RGB5 */ + { 28994, 0x00008057 }, /* GL_RGB5_A1 */ + { 29005, 0x00008057 }, /* GL_RGB5_A1_EXT */ + { 29020, 0x00008050 }, /* GL_RGB5_EXT */ + { 29032, 0x00008051 }, /* GL_RGB8 */ + { 29040, 0x00008051 }, /* GL_RGB8_EXT */ + { 29052, 0x00001908 }, /* GL_RGBA */ + { 29060, 0x0000805A }, /* GL_RGBA12 */ + { 29070, 0x0000805A }, /* GL_RGBA12_EXT */ + { 29084, 0x0000805B }, /* GL_RGBA16 */ + { 29094, 0x0000805B }, /* GL_RGBA16_EXT */ + { 29108, 0x00008055 }, /* GL_RGBA2 */ + { 29117, 0x00008055 }, /* GL_RGBA2_EXT */ + { 29130, 0x00008056 }, /* GL_RGBA4 */ + { 29139, 0x000083A5 }, /* GL_RGBA4_DXT5_S3TC */ + { 29158, 0x00008056 }, /* GL_RGBA4_EXT */ + { 29171, 0x000083A3 }, /* GL_RGBA4_S3TC */ + { 29185, 0x00008058 }, /* GL_RGBA8 */ + { 29194, 0x00008058 }, /* GL_RGBA8_EXT */ + { 29207, 0x000083A4 }, /* GL_RGBA_DXT5_S3TC */ + { 29225, 0x00000C31 }, /* GL_RGBA_MODE */ + { 29238, 0x000083A2 }, /* GL_RGBA_S3TC */ + { 29251, 0x000083A0 }, /* GL_RGB_S3TC */ + { 29263, 0x00008573 }, /* GL_RGB_SCALE */ + { 29276, 0x00008573 }, /* GL_RGB_SCALE_ARB */ + { 29293, 0x00008573 }, /* GL_RGB_SCALE_EXT */ + { 29310, 0x00000407 }, /* GL_RIGHT */ + { 29319, 0x00002000 }, /* GL_S */ + { 29324, 0x00008B5D }, /* GL_SAMPLER_1D */ + { 29338, 0x00008B61 }, /* GL_SAMPLER_1D_SHADOW */ + { 29359, 0x00008B5E }, /* GL_SAMPLER_2D */ + { 29373, 0x00008B62 }, /* GL_SAMPLER_2D_SHADOW */ + { 29394, 0x00008B5F }, /* GL_SAMPLER_3D */ + { 29408, 0x00008B60 }, /* GL_SAMPLER_CUBE */ + { 29424, 0x000080A9 }, /* GL_SAMPLES */ + { 29435, 0x000086B4 }, /* GL_SAMPLES_3DFX */ + { 29451, 0x000080A9 }, /* GL_SAMPLES_ARB */ + { 29466, 0x00008914 }, /* GL_SAMPLES_PASSED */ + { 29484, 0x00008914 }, /* GL_SAMPLES_PASSED_ARB */ + { 29506, 0x0000809E }, /* GL_SAMPLE_ALPHA_TO_COVERAGE */ + { 29534, 0x0000809E }, /* GL_SAMPLE_ALPHA_TO_COVERAGE_ARB */ + { 29566, 0x0000809F }, /* GL_SAMPLE_ALPHA_TO_ONE */ + { 29589, 0x0000809F }, /* GL_SAMPLE_ALPHA_TO_ONE_ARB */ + { 29616, 0x000080A8 }, /* GL_SAMPLE_BUFFERS */ + { 29634, 0x000086B3 }, /* GL_SAMPLE_BUFFERS_3DFX */ + { 29657, 0x000080A8 }, /* GL_SAMPLE_BUFFERS_ARB */ + { 29679, 0x000080A0 }, /* GL_SAMPLE_COVERAGE */ + { 29698, 0x000080A0 }, /* GL_SAMPLE_COVERAGE_ARB */ + { 29721, 0x000080AB }, /* GL_SAMPLE_COVERAGE_INVERT */ + { 29747, 0x000080AB }, /* GL_SAMPLE_COVERAGE_INVERT_ARB */ + { 29777, 0x000080AA }, /* GL_SAMPLE_COVERAGE_VALUE */ + { 29802, 0x000080AA }, /* GL_SAMPLE_COVERAGE_VALUE_ARB */ + { 29831, 0x00080000 }, /* GL_SCISSOR_BIT */ + { 29846, 0x00000C10 }, /* GL_SCISSOR_BOX */ + { 29861, 0x00000C11 }, /* GL_SCISSOR_TEST */ + { 29877, 0x0000845E }, /* GL_SECONDARY_COLOR_ARRAY */ + { 29902, 0x0000889C }, /* GL_SECONDARY_COLOR_ARRAY_BUFFER_BINDING */ + { 29942, 0x0000889C }, /* GL_SECONDARY_COLOR_ARRAY_BUFFER_BINDING_ARB */ + { 29986, 0x0000845D }, /* GL_SECONDARY_COLOR_ARRAY_POINTER */ + { 30019, 0x0000845A }, /* GL_SECONDARY_COLOR_ARRAY_SIZE */ + { 30049, 0x0000845C }, /* GL_SECONDARY_COLOR_ARRAY_STRIDE */ + { 30081, 0x0000845B }, /* GL_SECONDARY_COLOR_ARRAY_TYPE */ + { 30111, 0x00001C02 }, /* GL_SELECT */ + { 30121, 0x00000DF3 }, /* GL_SELECTION_BUFFER_POINTER */ + { 30149, 0x00000DF4 }, /* GL_SELECTION_BUFFER_SIZE */ + { 30174, 0x00008012 }, /* GL_SEPARABLE_2D */ + { 30190, 0x000081FA }, /* GL_SEPARATE_SPECULAR_COLOR */ + { 30217, 0x000081FA }, /* GL_SEPARATE_SPECULAR_COLOR_EXT */ + { 30248, 0x0000150F }, /* GL_SET */ + { 30255, 0x00008B48 }, /* GL_SHADER_OBJECT_ARB */ + { 30276, 0x00008B88 }, /* GL_SHADER_SOURCE_LENGTH */ + { 30300, 0x00008B4F }, /* GL_SHADER_TYPE */ + { 30315, 0x00000B54 }, /* GL_SHADE_MODEL */ + { 30330, 0x00008B8C }, /* GL_SHADING_LANGUAGE_VERSION */ + { 30358, 0x000080BF }, /* GL_SHADOW_AMBIENT_SGIX */ + { 30381, 0x000081FB }, /* GL_SHARED_TEXTURE_PALETTE_EXT */ + { 30411, 0x00001601 }, /* GL_SHININESS */ + { 30424, 0x00001402 }, /* GL_SHORT */ + { 30433, 0x000081F9 }, /* GL_SINGLE_COLOR */ + { 30449, 0x000081F9 }, /* GL_SINGLE_COLOR_EXT */ + { 30469, 0x000085CC }, /* GL_SLICE_ACCUM_SUN */ + { 30488, 0x00001D01 }, /* GL_SMOOTH */ + { 30498, 0x00000B23 }, /* GL_SMOOTH_LINE_WIDTH_GRANULARITY */ + { 30531, 0x00000B22 }, /* GL_SMOOTH_LINE_WIDTH_RANGE */ + { 30558, 0x00000B13 }, /* GL_SMOOTH_POINT_SIZE_GRANULARITY */ + { 30591, 0x00000B12 }, /* GL_SMOOTH_POINT_SIZE_RANGE */ + { 30618, 0x00008588 }, /* GL_SOURCE0_ALPHA */ + { 30635, 0x00008588 }, /* GL_SOURCE0_ALPHA_ARB */ + { 30656, 0x00008588 }, /* GL_SOURCE0_ALPHA_EXT */ + { 30677, 0x00008580 }, /* GL_SOURCE0_RGB */ + { 30692, 0x00008580 }, /* GL_SOURCE0_RGB_ARB */ + { 30711, 0x00008580 }, /* GL_SOURCE0_RGB_EXT */ + { 30730, 0x00008589 }, /* GL_SOURCE1_ALPHA */ + { 30747, 0x00008589 }, /* GL_SOURCE1_ALPHA_ARB */ + { 30768, 0x00008589 }, /* GL_SOURCE1_ALPHA_EXT */ + { 30789, 0x00008581 }, /* GL_SOURCE1_RGB */ + { 30804, 0x00008581 }, /* GL_SOURCE1_RGB_ARB */ + { 30823, 0x00008581 }, /* GL_SOURCE1_RGB_EXT */ + { 30842, 0x0000858A }, /* GL_SOURCE2_ALPHA */ + { 30859, 0x0000858A }, /* GL_SOURCE2_ALPHA_ARB */ + { 30880, 0x0000858A }, /* GL_SOURCE2_ALPHA_EXT */ + { 30901, 0x00008582 }, /* GL_SOURCE2_RGB */ + { 30916, 0x00008582 }, /* GL_SOURCE2_RGB_ARB */ + { 30935, 0x00008582 }, /* GL_SOURCE2_RGB_EXT */ + { 30954, 0x0000858B }, /* GL_SOURCE3_ALPHA_NV */ + { 30974, 0x00008583 }, /* GL_SOURCE3_RGB_NV */ + { 30992, 0x00001202 }, /* GL_SPECULAR */ + { 31004, 0x00002402 }, /* GL_SPHERE_MAP */ + { 31018, 0x00001206 }, /* GL_SPOT_CUTOFF */ + { 31033, 0x00001204 }, /* GL_SPOT_DIRECTION */ + { 31051, 0x00001205 }, /* GL_SPOT_EXPONENT */ + { 31068, 0x00008588 }, /* GL_SRC0_ALPHA */ + { 31082, 0x00008580 }, /* GL_SRC0_RGB */ + { 31094, 0x00008589 }, /* GL_SRC1_ALPHA */ + { 31108, 0x00008581 }, /* GL_SRC1_RGB */ + { 31120, 0x0000858A }, /* GL_SRC2_ALPHA */ + { 31134, 0x00008582 }, /* GL_SRC2_RGB */ + { 31146, 0x00000302 }, /* GL_SRC_ALPHA */ + { 31159, 0x00000308 }, /* GL_SRC_ALPHA_SATURATE */ + { 31181, 0x00000300 }, /* GL_SRC_COLOR */ + { 31194, 0x00008C40 }, /* GL_SRGB */ + { 31202, 0x00000503 }, /* GL_STACK_OVERFLOW */ + { 31220, 0x00000504 }, /* GL_STACK_UNDERFLOW */ + { 31239, 0x000088E6 }, /* GL_STATIC_COPY */ + { 31254, 0x000088E6 }, /* GL_STATIC_COPY_ARB */ + { 31273, 0x000088E4 }, /* GL_STATIC_DRAW */ + { 31288, 0x000088E4 }, /* GL_STATIC_DRAW_ARB */ + { 31307, 0x000088E5 }, /* GL_STATIC_READ */ + { 31322, 0x000088E5 }, /* GL_STATIC_READ_ARB */ + { 31341, 0x00001802 }, /* GL_STENCIL */ + { 31352, 0x00008D20 }, /* GL_STENCIL_ATTACHMENT */ + { 31374, 0x00008D20 }, /* GL_STENCIL_ATTACHMENT_EXT */ + { 31400, 0x00008801 }, /* GL_STENCIL_BACK_FAIL */ + { 31421, 0x00008801 }, /* GL_STENCIL_BACK_FAIL_ATI */ + { 31446, 0x00008800 }, /* GL_STENCIL_BACK_FUNC */ + { 31467, 0x00008800 }, /* GL_STENCIL_BACK_FUNC_ATI */ + { 31492, 0x00008802 }, /* GL_STENCIL_BACK_PASS_DEPTH_FAIL */ + { 31524, 0x00008802 }, /* GL_STENCIL_BACK_PASS_DEPTH_FAIL_ATI */ + { 31560, 0x00008803 }, /* GL_STENCIL_BACK_PASS_DEPTH_PASS */ + { 31592, 0x00008803 }, /* GL_STENCIL_BACK_PASS_DEPTH_PASS_ATI */ + { 31628, 0x00008CA3 }, /* GL_STENCIL_BACK_REF */ + { 31648, 0x00008CA4 }, /* GL_STENCIL_BACK_VALUE_MASK */ + { 31675, 0x00008CA5 }, /* GL_STENCIL_BACK_WRITEMASK */ + { 31701, 0x00000D57 }, /* GL_STENCIL_BITS */ + { 31717, 0x00000400 }, /* GL_STENCIL_BUFFER_BIT */ + { 31739, 0x00000B91 }, /* GL_STENCIL_CLEAR_VALUE */ + { 31762, 0x00000B94 }, /* GL_STENCIL_FAIL */ + { 31778, 0x00000B92 }, /* GL_STENCIL_FUNC */ + { 31794, 0x00001901 }, /* GL_STENCIL_INDEX */ + { 31811, 0x00008D49 }, /* GL_STENCIL_INDEX16_EXT */ + { 31834, 0x00008D46 }, /* GL_STENCIL_INDEX1_EXT */ + { 31856, 0x00008D47 }, /* GL_STENCIL_INDEX4_EXT */ + { 31878, 0x00008D48 }, /* GL_STENCIL_INDEX8_EXT */ + { 31900, 0x00008D45 }, /* GL_STENCIL_INDEX_EXT */ + { 31921, 0x00000B95 }, /* GL_STENCIL_PASS_DEPTH_FAIL */ + { 31948, 0x00000B96 }, /* GL_STENCIL_PASS_DEPTH_PASS */ + { 31975, 0x00000B97 }, /* GL_STENCIL_REF */ + { 31990, 0x00000B90 }, /* GL_STENCIL_TEST */ + { 32006, 0x00008910 }, /* GL_STENCIL_TEST_TWO_SIDE_EXT */ + { 32035, 0x00000B93 }, /* GL_STENCIL_VALUE_MASK */ + { 32057, 0x00000B98 }, /* GL_STENCIL_WRITEMASK */ + { 32078, 0x00000C33 }, /* GL_STEREO */ + { 32088, 0x000088E2 }, /* GL_STREAM_COPY */ + { 32103, 0x000088E2 }, /* GL_STREAM_COPY_ARB */ + { 32122, 0x000088E0 }, /* GL_STREAM_DRAW */ + { 32137, 0x000088E0 }, /* GL_STREAM_DRAW_ARB */ + { 32156, 0x000088E1 }, /* GL_STREAM_READ */ + { 32171, 0x000088E1 }, /* GL_STREAM_READ_ARB */ + { 32190, 0x00000D50 }, /* GL_SUBPIXEL_BITS */ + { 32207, 0x000084E7 }, /* GL_SUBTRACT */ + { 32219, 0x000084E7 }, /* GL_SUBTRACT_ARB */ + { 32235, 0x00002001 }, /* GL_T */ + { 32240, 0x00002A2A }, /* GL_T2F_C3F_V3F */ + { 32255, 0x00002A2C }, /* GL_T2F_C4F_N3F_V3F */ + { 32274, 0x00002A29 }, /* GL_T2F_C4UB_V3F */ + { 32290, 0x00002A2B }, /* GL_T2F_N3F_V3F */ + { 32305, 0x00002A27 }, /* GL_T2F_V3F */ + { 32316, 0x00002A2D }, /* GL_T4F_C4F_N3F_V4F */ + { 32335, 0x00002A28 }, /* GL_T4F_V4F */ + { 32346, 0x00008031 }, /* GL_TABLE_TOO_LARGE_EXT */ + { 32369, 0x00001702 }, /* GL_TEXTURE */ + { 32380, 0x000084C0 }, /* GL_TEXTURE0 */ + { 32392, 0x000084C0 }, /* GL_TEXTURE0_ARB */ + { 32408, 0x000084C1 }, /* GL_TEXTURE1 */ + { 32420, 0x000084CA }, /* GL_TEXTURE10 */ + { 32433, 0x000084CA }, /* GL_TEXTURE10_ARB */ + { 32450, 0x000084CB }, /* GL_TEXTURE11 */ + { 32463, 0x000084CB }, /* GL_TEXTURE11_ARB */ + { 32480, 0x000084CC }, /* GL_TEXTURE12 */ + { 32493, 0x000084CC }, /* GL_TEXTURE12_ARB */ + { 32510, 0x000084CD }, /* GL_TEXTURE13 */ + { 32523, 0x000084CD }, /* GL_TEXTURE13_ARB */ + { 32540, 0x000084CE }, /* GL_TEXTURE14 */ + { 32553, 0x000084CE }, /* GL_TEXTURE14_ARB */ + { 32570, 0x000084CF }, /* GL_TEXTURE15 */ + { 32583, 0x000084CF }, /* GL_TEXTURE15_ARB */ + { 32600, 0x000084D0 }, /* GL_TEXTURE16 */ + { 32613, 0x000084D0 }, /* GL_TEXTURE16_ARB */ + { 32630, 0x000084D1 }, /* GL_TEXTURE17 */ + { 32643, 0x000084D1 }, /* GL_TEXTURE17_ARB */ + { 32660, 0x000084D2 }, /* GL_TEXTURE18 */ + { 32673, 0x000084D2 }, /* GL_TEXTURE18_ARB */ + { 32690, 0x000084D3 }, /* GL_TEXTURE19 */ + { 32703, 0x000084D3 }, /* GL_TEXTURE19_ARB */ + { 32720, 0x000084C1 }, /* GL_TEXTURE1_ARB */ + { 32736, 0x000084C2 }, /* GL_TEXTURE2 */ + { 32748, 0x000084D4 }, /* GL_TEXTURE20 */ + { 32761, 0x000084D4 }, /* GL_TEXTURE20_ARB */ + { 32778, 0x000084D5 }, /* GL_TEXTURE21 */ + { 32791, 0x000084D5 }, /* GL_TEXTURE21_ARB */ + { 32808, 0x000084D6 }, /* GL_TEXTURE22 */ + { 32821, 0x000084D6 }, /* GL_TEXTURE22_ARB */ + { 32838, 0x000084D7 }, /* GL_TEXTURE23 */ + { 32851, 0x000084D7 }, /* GL_TEXTURE23_ARB */ + { 32868, 0x000084D8 }, /* GL_TEXTURE24 */ + { 32881, 0x000084D8 }, /* GL_TEXTURE24_ARB */ + { 32898, 0x000084D9 }, /* GL_TEXTURE25 */ + { 32911, 0x000084D9 }, /* GL_TEXTURE25_ARB */ + { 32928, 0x000084DA }, /* GL_TEXTURE26 */ + { 32941, 0x000084DA }, /* GL_TEXTURE26_ARB */ + { 32958, 0x000084DB }, /* GL_TEXTURE27 */ + { 32971, 0x000084DB }, /* GL_TEXTURE27_ARB */ + { 32988, 0x000084DC }, /* GL_TEXTURE28 */ + { 33001, 0x000084DC }, /* GL_TEXTURE28_ARB */ + { 33018, 0x000084DD }, /* GL_TEXTURE29 */ + { 33031, 0x000084DD }, /* GL_TEXTURE29_ARB */ + { 33048, 0x000084C2 }, /* GL_TEXTURE2_ARB */ + { 33064, 0x000084C3 }, /* GL_TEXTURE3 */ + { 33076, 0x000084DE }, /* GL_TEXTURE30 */ + { 33089, 0x000084DE }, /* GL_TEXTURE30_ARB */ + { 33106, 0x000084DF }, /* GL_TEXTURE31 */ + { 33119, 0x000084DF }, /* GL_TEXTURE31_ARB */ + { 33136, 0x000084C3 }, /* GL_TEXTURE3_ARB */ + { 33152, 0x000084C4 }, /* GL_TEXTURE4 */ + { 33164, 0x000084C4 }, /* GL_TEXTURE4_ARB */ + { 33180, 0x000084C5 }, /* GL_TEXTURE5 */ + { 33192, 0x000084C5 }, /* GL_TEXTURE5_ARB */ + { 33208, 0x000084C6 }, /* GL_TEXTURE6 */ + { 33220, 0x000084C6 }, /* GL_TEXTURE6_ARB */ + { 33236, 0x000084C7 }, /* GL_TEXTURE7 */ + { 33248, 0x000084C7 }, /* GL_TEXTURE7_ARB */ + { 33264, 0x000084C8 }, /* GL_TEXTURE8 */ + { 33276, 0x000084C8 }, /* GL_TEXTURE8_ARB */ + { 33292, 0x000084C9 }, /* GL_TEXTURE9 */ + { 33304, 0x000084C9 }, /* GL_TEXTURE9_ARB */ + { 33320, 0x00000DE0 }, /* GL_TEXTURE_1D */ + { 33334, 0x00008C18 }, /* GL_TEXTURE_1D_ARRAY_EXT */ + { 33358, 0x00000DE1 }, /* GL_TEXTURE_2D */ + { 33372, 0x00008C1A }, /* GL_TEXTURE_2D_ARRAY_EXT */ + { 33396, 0x0000806F }, /* GL_TEXTURE_3D */ + { 33410, 0x0000805F }, /* GL_TEXTURE_ALPHA_SIZE */ + { 33432, 0x0000805F }, /* GL_TEXTURE_ALPHA_SIZE_EXT */ + { 33458, 0x0000813C }, /* GL_TEXTURE_BASE_LEVEL */ + { 33480, 0x00008068 }, /* GL_TEXTURE_BINDING_1D */ + { 33502, 0x00008C1C }, /* GL_TEXTURE_BINDING_1D_ARRAY_EXT */ + { 33534, 0x00008069 }, /* GL_TEXTURE_BINDING_2D */ + { 33556, 0x00008C1D }, /* GL_TEXTURE_BINDING_2D_ARRAY_EXT */ + { 33588, 0x0000806A }, /* GL_TEXTURE_BINDING_3D */ + { 33610, 0x00008514 }, /* GL_TEXTURE_BINDING_CUBE_MAP */ + { 33638, 0x00008514 }, /* GL_TEXTURE_BINDING_CUBE_MAP_ARB */ + { 33670, 0x000084F6 }, /* GL_TEXTURE_BINDING_RECTANGLE_ARB */ + { 33703, 0x000084F6 }, /* GL_TEXTURE_BINDING_RECTANGLE_NV */ + { 33735, 0x00040000 }, /* GL_TEXTURE_BIT */ + { 33750, 0x0000805E }, /* GL_TEXTURE_BLUE_SIZE */ + { 33771, 0x0000805E }, /* GL_TEXTURE_BLUE_SIZE_EXT */ + { 33796, 0x00001005 }, /* GL_TEXTURE_BORDER */ + { 33814, 0x00001004 }, /* GL_TEXTURE_BORDER_COLOR */ + { 33838, 0x00008171 }, /* GL_TEXTURE_CLIPMAP_CENTER_SGIX */ + { 33869, 0x00008176 }, /* GL_TEXTURE_CLIPMAP_DEPTH_SGIX */ + { 33899, 0x00008172 }, /* GL_TEXTURE_CLIPMAP_FRAME_SGIX */ + { 33929, 0x00008175 }, /* GL_TEXTURE_CLIPMAP_LOD_OFFSET_SGIX */ + { 33964, 0x00008173 }, /* GL_TEXTURE_CLIPMAP_OFFSET_SGIX */ + { 33995, 0x00008174 }, /* GL_TEXTURE_CLIPMAP_VIRTUAL_DEPTH_SGIX */ + { 34033, 0x000080BC }, /* GL_TEXTURE_COLOR_TABLE_SGI */ + { 34060, 0x000081EF }, /* GL_TEXTURE_COLOR_WRITEMASK_SGIS */ + { 34092, 0x000080BF }, /* GL_TEXTURE_COMPARE_FAIL_VALUE_ARB */ + { 34126, 0x0000884D }, /* GL_TEXTURE_COMPARE_FUNC */ + { 34150, 0x0000884D }, /* GL_TEXTURE_COMPARE_FUNC_ARB */ + { 34178, 0x0000884C }, /* GL_TEXTURE_COMPARE_MODE */ + { 34202, 0x0000884C }, /* GL_TEXTURE_COMPARE_MODE_ARB */ + { 34230, 0x0000819B }, /* GL_TEXTURE_COMPARE_OPERATOR_SGIX */ + { 34263, 0x0000819A }, /* GL_TEXTURE_COMPARE_SGIX */ + { 34287, 0x00001003 }, /* GL_TEXTURE_COMPONENTS */ + { 34309, 0x000086A1 }, /* GL_TEXTURE_COMPRESSED */ + { 34331, 0x000086A1 }, /* GL_TEXTURE_COMPRESSED_ARB */ + { 34357, 0x000086A3 }, /* GL_TEXTURE_COMPRESSED_FORMATS_ARB */ + { 34391, 0x000086A0 }, /* GL_TEXTURE_COMPRESSED_IMAGE_SIZE */ + { 34424, 0x000086A0 }, /* GL_TEXTURE_COMPRESSED_IMAGE_SIZE_ARB */ + { 34461, 0x000084EF }, /* GL_TEXTURE_COMPRESSION_HINT */ + { 34489, 0x000084EF }, /* GL_TEXTURE_COMPRESSION_HINT_ARB */ + { 34521, 0x00008078 }, /* GL_TEXTURE_COORD_ARRAY */ + { 34544, 0x0000889A }, /* GL_TEXTURE_COORD_ARRAY_BUFFER_BINDING */ + { 34582, 0x0000889A }, /* GL_TEXTURE_COORD_ARRAY_BUFFER_BINDING_ARB */ + { 34624, 0x00008092 }, /* GL_TEXTURE_COORD_ARRAY_POINTER */ + { 34655, 0x00008088 }, /* GL_TEXTURE_COORD_ARRAY_SIZE */ + { 34683, 0x0000808A }, /* GL_TEXTURE_COORD_ARRAY_STRIDE */ + { 34713, 0x00008089 }, /* GL_TEXTURE_COORD_ARRAY_TYPE */ + { 34741, 0x00008513 }, /* GL_TEXTURE_CUBE_MAP */ + { 34761, 0x00008513 }, /* GL_TEXTURE_CUBE_MAP_ARB */ + { 34785, 0x00008516 }, /* GL_TEXTURE_CUBE_MAP_NEGATIVE_X */ + { 34816, 0x00008516 }, /* GL_TEXTURE_CUBE_MAP_NEGATIVE_X_ARB */ + { 34851, 0x00008518 }, /* GL_TEXTURE_CUBE_MAP_NEGATIVE_Y */ + { 34882, 0x00008518 }, /* GL_TEXTURE_CUBE_MAP_NEGATIVE_Y_ARB */ + { 34917, 0x0000851A }, /* GL_TEXTURE_CUBE_MAP_NEGATIVE_Z */ + { 34948, 0x0000851A }, /* GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_ARB */ + { 34983, 0x00008515 }, /* GL_TEXTURE_CUBE_MAP_POSITIVE_X */ + { 35014, 0x00008515 }, /* GL_TEXTURE_CUBE_MAP_POSITIVE_X_ARB */ + { 35049, 0x00008517 }, /* GL_TEXTURE_CUBE_MAP_POSITIVE_Y */ + { 35080, 0x00008517 }, /* GL_TEXTURE_CUBE_MAP_POSITIVE_Y_ARB */ + { 35115, 0x00008519 }, /* GL_TEXTURE_CUBE_MAP_POSITIVE_Z */ + { 35146, 0x00008519 }, /* GL_TEXTURE_CUBE_MAP_POSITIVE_Z_ARB */ + { 35181, 0x00008071 }, /* GL_TEXTURE_DEPTH */ + { 35198, 0x0000884A }, /* GL_TEXTURE_DEPTH_SIZE */ + { 35220, 0x0000884A }, /* GL_TEXTURE_DEPTH_SIZE_ARB */ + { 35246, 0x00002300 }, /* GL_TEXTURE_ENV */ + { 35261, 0x00002201 }, /* GL_TEXTURE_ENV_COLOR */ + { 35282, 0x00002200 }, /* GL_TEXTURE_ENV_MODE */ + { 35302, 0x00008500 }, /* GL_TEXTURE_FILTER_CONTROL */ + { 35328, 0x00002500 }, /* GL_TEXTURE_GEN_MODE */ + { 35348, 0x00000C63 }, /* GL_TEXTURE_GEN_Q */ + { 35365, 0x00000C62 }, /* GL_TEXTURE_GEN_R */ + { 35382, 0x00000C60 }, /* GL_TEXTURE_GEN_S */ + { 35399, 0x00000C61 }, /* GL_TEXTURE_GEN_T */ + { 35416, 0x0000819D }, /* GL_TEXTURE_GEQUAL_R_SGIX */ + { 35441, 0x0000805D }, /* GL_TEXTURE_GREEN_SIZE */ + { 35463, 0x0000805D }, /* GL_TEXTURE_GREEN_SIZE_EXT */ + { 35489, 0x00001001 }, /* GL_TEXTURE_HEIGHT */ + { 35507, 0x000080ED }, /* GL_TEXTURE_INDEX_SIZE_EXT */ + { 35533, 0x00008061 }, /* GL_TEXTURE_INTENSITY_SIZE */ + { 35559, 0x00008061 }, /* GL_TEXTURE_INTENSITY_SIZE_EXT */ + { 35589, 0x00001003 }, /* GL_TEXTURE_INTERNAL_FORMAT */ + { 35616, 0x0000819C }, /* GL_TEXTURE_LEQUAL_R_SGIX */ + { 35641, 0x00008501 }, /* GL_TEXTURE_LOD_BIAS */ + { 35661, 0x00008501 }, /* GL_TEXTURE_LOD_BIAS_EXT */ + { 35685, 0x00008190 }, /* GL_TEXTURE_LOD_BIAS_R_SGIX */ + { 35712, 0x0000818E }, /* GL_TEXTURE_LOD_BIAS_S_SGIX */ + { 35739, 0x0000818F }, /* GL_TEXTURE_LOD_BIAS_T_SGIX */ + { 35766, 0x00008060 }, /* GL_TEXTURE_LUMINANCE_SIZE */ + { 35792, 0x00008060 }, /* GL_TEXTURE_LUMINANCE_SIZE_EXT */ + { 35822, 0x00002800 }, /* GL_TEXTURE_MAG_FILTER */ + { 35844, 0x00000BA8 }, /* GL_TEXTURE_MATRIX */ + { 35862, 0x000084FE }, /* GL_TEXTURE_MAX_ANISOTROPY_EXT */ + { 35892, 0x0000836B }, /* GL_TEXTURE_MAX_CLAMP_R_SGIX */ + { 35920, 0x00008369 }, /* GL_TEXTURE_MAX_CLAMP_S_SGIX */ + { 35948, 0x0000836A }, /* GL_TEXTURE_MAX_CLAMP_T_SGIX */ + { 35976, 0x0000813D }, /* GL_TEXTURE_MAX_LEVEL */ + { 35997, 0x0000813B }, /* GL_TEXTURE_MAX_LOD */ + { 36016, 0x00002801 }, /* GL_TEXTURE_MIN_FILTER */ + { 36038, 0x0000813A }, /* GL_TEXTURE_MIN_LOD */ + { 36057, 0x00008066 }, /* GL_TEXTURE_PRIORITY */ + { 36077, 0x000084F5 }, /* GL_TEXTURE_RECTANGLE_ARB */ + { 36102, 0x000084F5 }, /* GL_TEXTURE_RECTANGLE_NV */ + { 36126, 0x0000805C }, /* GL_TEXTURE_RED_SIZE */ + { 36146, 0x0000805C }, /* GL_TEXTURE_RED_SIZE_EXT */ + { 36170, 0x00008067 }, /* GL_TEXTURE_RESIDENT */ + { 36190, 0x00000BA5 }, /* GL_TEXTURE_STACK_DEPTH */ + { 36213, 0x000088F1 }, /* GL_TEXTURE_STENCIL_SIZE */ + { 36237, 0x00008065 }, /* GL_TEXTURE_TOO_LARGE_EXT */ + { 36262, 0x0000888F }, /* GL_TEXTURE_UNSIGNED_REMAP_MODE_NV */ + { 36296, 0x00001000 }, /* GL_TEXTURE_WIDTH */ + { 36313, 0x00008072 }, /* GL_TEXTURE_WRAP_R */ + { 36331, 0x00002802 }, /* GL_TEXTURE_WRAP_S */ + { 36349, 0x00002803 }, /* GL_TEXTURE_WRAP_T */ + { 36367, 0x000088BF }, /* GL_TIME_ELAPSED_EXT */ + { 36387, 0x00008648 }, /* GL_TRACK_MATRIX_NV */ + { 36406, 0x00008649 }, /* GL_TRACK_MATRIX_TRANSFORM_NV */ + { 36435, 0x00001000 }, /* GL_TRANSFORM_BIT */ + { 36452, 0x000084E6 }, /* GL_TRANSPOSE_COLOR_MATRIX */ + { 36478, 0x000084E6 }, /* GL_TRANSPOSE_COLOR_MATRIX_ARB */ + { 36508, 0x000088B7 }, /* GL_TRANSPOSE_CURRENT_MATRIX_ARB */ + { 36540, 0x000084E3 }, /* GL_TRANSPOSE_MODELVIEW_MATRIX */ + { 36570, 0x000084E3 }, /* GL_TRANSPOSE_MODELVIEW_MATRIX_ARB */ + { 36604, 0x0000862C }, /* GL_TRANSPOSE_NV */ + { 36620, 0x000084E4 }, /* GL_TRANSPOSE_PROJECTION_MATRIX */ + { 36651, 0x000084E4 }, /* GL_TRANSPOSE_PROJECTION_MATRIX_ARB */ + { 36686, 0x000084E5 }, /* GL_TRANSPOSE_TEXTURE_MATRIX */ + { 36714, 0x000084E5 }, /* GL_TRANSPOSE_TEXTURE_MATRIX_ARB */ + { 36746, 0x00000004 }, /* GL_TRIANGLES */ + { 36759, 0x00000006 }, /* GL_TRIANGLE_FAN */ + { 36775, 0x00008615 }, /* GL_TRIANGLE_MESH_SUN */ + { 36796, 0x00000005 }, /* GL_TRIANGLE_STRIP */ + { 36814, 0x00000001 }, /* GL_TRUE */ + { 36822, 0x00000CF5 }, /* GL_UNPACK_ALIGNMENT */ + { 36842, 0x0000806E }, /* GL_UNPACK_IMAGE_HEIGHT */ + { 36865, 0x00000CF1 }, /* GL_UNPACK_LSB_FIRST */ + { 36885, 0x00000CF2 }, /* GL_UNPACK_ROW_LENGTH */ + { 36906, 0x0000806D }, /* GL_UNPACK_SKIP_IMAGES */ + { 36928, 0x00000CF4 }, /* GL_UNPACK_SKIP_PIXELS */ + { 36950, 0x00000CF3 }, /* GL_UNPACK_SKIP_ROWS */ + { 36970, 0x00000CF0 }, /* GL_UNPACK_SWAP_BYTES */ + { 36991, 0x00001401 }, /* GL_UNSIGNED_BYTE */ + { 37008, 0x00008362 }, /* GL_UNSIGNED_BYTE_2_3_3_REV */ + { 37035, 0x00008032 }, /* GL_UNSIGNED_BYTE_3_3_2 */ + { 37058, 0x00001405 }, /* GL_UNSIGNED_INT */ + { 37074, 0x00008036 }, /* GL_UNSIGNED_INT_10_10_10_2 */ + { 37101, 0x000084FA }, /* GL_UNSIGNED_INT_24_8 */ + { 37122, 0x000084FA }, /* GL_UNSIGNED_INT_24_8_NV */ + { 37146, 0x00008368 }, /* GL_UNSIGNED_INT_2_10_10_10_REV */ + { 37177, 0x00008035 }, /* GL_UNSIGNED_INT_8_8_8_8 */ + { 37201, 0x00008367 }, /* GL_UNSIGNED_INT_8_8_8_8_REV */ + { 37229, 0x00008C17 }, /* GL_UNSIGNED_NORMALIZED */ + { 37252, 0x00001403 }, /* GL_UNSIGNED_SHORT */ + { 37270, 0x00008366 }, /* GL_UNSIGNED_SHORT_1_5_5_5_REV */ + { 37300, 0x00008033 }, /* GL_UNSIGNED_SHORT_4_4_4_4 */ + { 37326, 0x00008365 }, /* GL_UNSIGNED_SHORT_4_4_4_4_REV */ + { 37356, 0x00008034 }, /* GL_UNSIGNED_SHORT_5_5_5_1 */ + { 37382, 0x00008363 }, /* GL_UNSIGNED_SHORT_5_6_5 */ + { 37406, 0x00008364 }, /* GL_UNSIGNED_SHORT_5_6_5_REV */ + { 37434, 0x000085BA }, /* GL_UNSIGNED_SHORT_8_8_APPLE */ + { 37462, 0x000085BA }, /* GL_UNSIGNED_SHORT_8_8_MESA */ + { 37489, 0x000085BB }, /* GL_UNSIGNED_SHORT_8_8_REV_APPLE */ + { 37521, 0x000085BB }, /* GL_UNSIGNED_SHORT_8_8_REV_MESA */ + { 37552, 0x00008CA2 }, /* GL_UPPER_LEFT */ + { 37566, 0x00002A20 }, /* GL_V2F */ + { 37573, 0x00002A21 }, /* GL_V3F */ + { 37580, 0x00008B83 }, /* GL_VALIDATE_STATUS */ + { 37599, 0x00001F00 }, /* GL_VENDOR */ + { 37609, 0x00001F02 }, /* GL_VERSION */ + { 37620, 0x00008074 }, /* GL_VERTEX_ARRAY */ + { 37636, 0x000085B5 }, /* GL_VERTEX_ARRAY_BINDING_APPLE */ + { 37666, 0x00008896 }, /* GL_VERTEX_ARRAY_BUFFER_BINDING */ + { 37697, 0x00008896 }, /* GL_VERTEX_ARRAY_BUFFER_BINDING_ARB */ + { 37732, 0x0000808E }, /* GL_VERTEX_ARRAY_POINTER */ + { 37756, 0x0000807A }, /* GL_VERTEX_ARRAY_SIZE */ + { 37777, 0x0000807C }, /* GL_VERTEX_ARRAY_STRIDE */ + { 37800, 0x0000807B }, /* GL_VERTEX_ARRAY_TYPE */ + { 37821, 0x00008650 }, /* GL_VERTEX_ATTRIB_ARRAY0_NV */ + { 37848, 0x0000865A }, /* GL_VERTEX_ATTRIB_ARRAY10_NV */ + { 37876, 0x0000865B }, /* GL_VERTEX_ATTRIB_ARRAY11_NV */ + { 37904, 0x0000865C }, /* GL_VERTEX_ATTRIB_ARRAY12_NV */ + { 37932, 0x0000865D }, /* GL_VERTEX_ATTRIB_ARRAY13_NV */ + { 37960, 0x0000865E }, /* GL_VERTEX_ATTRIB_ARRAY14_NV */ + { 37988, 0x0000865F }, /* GL_VERTEX_ATTRIB_ARRAY15_NV */ + { 38016, 0x00008651 }, /* GL_VERTEX_ATTRIB_ARRAY1_NV */ + { 38043, 0x00008652 }, /* GL_VERTEX_ATTRIB_ARRAY2_NV */ + { 38070, 0x00008653 }, /* GL_VERTEX_ATTRIB_ARRAY3_NV */ + { 38097, 0x00008654 }, /* GL_VERTEX_ATTRIB_ARRAY4_NV */ + { 38124, 0x00008655 }, /* GL_VERTEX_ATTRIB_ARRAY5_NV */ + { 38151, 0x00008656 }, /* GL_VERTEX_ATTRIB_ARRAY6_NV */ + { 38178, 0x00008657 }, /* GL_VERTEX_ATTRIB_ARRAY7_NV */ + { 38205, 0x00008658 }, /* GL_VERTEX_ATTRIB_ARRAY8_NV */ + { 38232, 0x00008659 }, /* GL_VERTEX_ATTRIB_ARRAY9_NV */ + { 38259, 0x0000889F }, /* GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING */ + { 38297, 0x0000889F }, /* GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING_ARB */ + { 38339, 0x00008622 }, /* GL_VERTEX_ATTRIB_ARRAY_ENABLED */ + { 38370, 0x00008622 }, /* GL_VERTEX_ATTRIB_ARRAY_ENABLED_ARB */ + { 38405, 0x0000886A }, /* GL_VERTEX_ATTRIB_ARRAY_NORMALIZED */ + { 38439, 0x0000886A }, /* GL_VERTEX_ATTRIB_ARRAY_NORMALIZED_ARB */ + { 38477, 0x00008645 }, /* GL_VERTEX_ATTRIB_ARRAY_POINTER */ + { 38508, 0x00008645 }, /* GL_VERTEX_ATTRIB_ARRAY_POINTER_ARB */ + { 38543, 0x00008623 }, /* GL_VERTEX_ATTRIB_ARRAY_SIZE */ + { 38571, 0x00008623 }, /* GL_VERTEX_ATTRIB_ARRAY_SIZE_ARB */ + { 38603, 0x00008624 }, /* GL_VERTEX_ATTRIB_ARRAY_STRIDE */ + { 38633, 0x00008624 }, /* GL_VERTEX_ATTRIB_ARRAY_STRIDE_ARB */ + { 38667, 0x00008625 }, /* GL_VERTEX_ATTRIB_ARRAY_TYPE */ + { 38695, 0x00008625 }, /* GL_VERTEX_ATTRIB_ARRAY_TYPE_ARB */ + { 38727, 0x000086A7 }, /* GL_VERTEX_BLEND_ARB */ + { 38747, 0x00008620 }, /* GL_VERTEX_PROGRAM_ARB */ + { 38769, 0x0000864A }, /* GL_VERTEX_PROGRAM_BINDING_NV */ + { 38798, 0x00008620 }, /* GL_VERTEX_PROGRAM_NV */ + { 38819, 0x00008642 }, /* GL_VERTEX_PROGRAM_POINT_SIZE */ + { 38848, 0x00008642 }, /* GL_VERTEX_PROGRAM_POINT_SIZE_ARB */ + { 38881, 0x00008642 }, /* GL_VERTEX_PROGRAM_POINT_SIZE_NV */ + { 38913, 0x00008643 }, /* GL_VERTEX_PROGRAM_TWO_SIDE */ + { 38940, 0x00008643 }, /* GL_VERTEX_PROGRAM_TWO_SIDE_ARB */ + { 38971, 0x00008643 }, /* GL_VERTEX_PROGRAM_TWO_SIDE_NV */ + { 39001, 0x00008B31 }, /* GL_VERTEX_SHADER */ + { 39018, 0x00008B31 }, /* GL_VERTEX_SHADER_ARB */ + { 39039, 0x00008621 }, /* GL_VERTEX_STATE_PROGRAM_NV */ + { 39066, 0x00000BA2 }, /* GL_VIEWPORT */ + { 39078, 0x00000800 }, /* GL_VIEWPORT_BIT */ + { 39094, 0x000086AD }, /* GL_WEIGHT_ARRAY_ARB */ + { 39114, 0x0000889E }, /* GL_WEIGHT_ARRAY_BUFFER_BINDING */ + { 39145, 0x0000889E }, /* GL_WEIGHT_ARRAY_BUFFER_BINDING_ARB */ + { 39180, 0x000086AC }, /* GL_WEIGHT_ARRAY_POINTER_ARB */ + { 39208, 0x000086AB }, /* GL_WEIGHT_ARRAY_SIZE_ARB */ + { 39233, 0x000086AA }, /* GL_WEIGHT_ARRAY_STRIDE_ARB */ + { 39260, 0x000086A9 }, /* GL_WEIGHT_ARRAY_TYPE_ARB */ + { 39285, 0x000086A6 }, /* GL_WEIGHT_SUM_UNITY_ARB */ + { 39309, 0x000081D4 }, /* GL_WRAP_BORDER_SUN */ + { 39328, 0x000088B9 }, /* GL_WRITE_ONLY */ + { 39342, 0x000088B9 }, /* GL_WRITE_ONLY_ARB */ + { 39360, 0x00001506 }, /* GL_XOR */ + { 39367, 0x000085B9 }, /* GL_YCBCR_422_APPLE */ + { 39386, 0x00008757 }, /* GL_YCBCR_MESA */ + { 39400, 0x00000000 }, /* GL_ZERO */ + { 39408, 0x00000D16 }, /* GL_ZOOM_X */ + { 39418, 0x00000D17 }, /* GL_ZOOM_Y */ }; -static const unsigned reduced_enums[1308] = +static const unsigned reduced_enums[1316] = { - 455, /* GL_FALSE */ - 687, /* GL_LINES */ - 689, /* GL_LINE_LOOP */ - 696, /* GL_LINE_STRIP */ - 1699, /* GL_TRIANGLES */ - 1702, /* GL_TRIANGLE_STRIP */ - 1700, /* GL_TRIANGLE_FAN */ - 1254, /* GL_QUADS */ - 1256, /* GL_QUAD_STRIP */ - 1142, /* GL_POLYGON */ - 1154, /* GL_POLYGON_STIPPLE_BIT */ - 1107, /* GL_PIXEL_MODE_BIT */ - 674, /* GL_LIGHTING_BIT */ - 477, /* GL_FOG_BIT */ + 463, /* GL_FALSE */ + 695, /* GL_LINES */ + 697, /* GL_LINE_LOOP */ + 704, /* GL_LINE_STRIP */ + 1707, /* GL_TRIANGLES */ + 1710, /* GL_TRIANGLE_STRIP */ + 1708, /* GL_TRIANGLE_FAN */ + 1262, /* GL_QUADS */ + 1264, /* GL_QUAD_STRIP */ + 1150, /* GL_POLYGON */ + 1162, /* GL_POLYGON_STIPPLE_BIT */ + 1115, /* GL_PIXEL_MODE_BIT */ + 682, /* GL_LIGHTING_BIT */ + 485, /* GL_FOG_BIT */ 8, /* GL_ACCUM */ - 706, /* GL_LOAD */ - 1308, /* GL_RETURN */ - 980, /* GL_MULT */ + 714, /* GL_LOAD */ + 1316, /* GL_RETURN */ + 988, /* GL_MULT */ 23, /* GL_ADD */ - 996, /* GL_NEVER */ - 664, /* GL_LESS */ - 445, /* GL_EQUAL */ - 663, /* GL_LEQUAL */ - 587, /* GL_GREATER */ - 1011, /* GL_NOTEQUAL */ - 562, /* GL_GEQUAL */ + 1004, /* GL_NEVER */ + 672, /* GL_LESS */ + 453, /* GL_EQUAL */ + 671, /* GL_LEQUAL */ + 595, /* GL_GREATER */ + 1019, /* GL_NOTEQUAL */ + 570, /* GL_GEQUAL */ 46, /* GL_ALWAYS */ - 1441, /* GL_SRC_COLOR */ - 1040, /* GL_ONE_MINUS_SRC_COLOR */ - 1439, /* GL_SRC_ALPHA */ - 1039, /* GL_ONE_MINUS_SRC_ALPHA */ - 426, /* GL_DST_ALPHA */ - 1037, /* GL_ONE_MINUS_DST_ALPHA */ - 427, /* GL_DST_COLOR */ - 1038, /* GL_ONE_MINUS_DST_COLOR */ - 1440, /* GL_SRC_ALPHA_SATURATE */ - 550, /* GL_FRONT_LEFT */ - 551, /* GL_FRONT_RIGHT */ + 1449, /* GL_SRC_COLOR */ + 1048, /* GL_ONE_MINUS_SRC_COLOR */ + 1447, /* GL_SRC_ALPHA */ + 1047, /* GL_ONE_MINUS_SRC_ALPHA */ + 432, /* GL_DST_ALPHA */ + 1045, /* GL_ONE_MINUS_DST_ALPHA */ + 433, /* GL_DST_COLOR */ + 1046, /* GL_ONE_MINUS_DST_COLOR */ + 1448, /* GL_SRC_ALPHA_SATURATE */ + 558, /* GL_FRONT_LEFT */ + 559, /* GL_FRONT_RIGHT */ 68, /* GL_BACK_LEFT */ 69, /* GL_BACK_RIGHT */ - 547, /* GL_FRONT */ + 555, /* GL_FRONT */ 67, /* GL_BACK */ - 662, /* GL_LEFT */ - 1348, /* GL_RIGHT */ - 548, /* GL_FRONT_AND_BACK */ + 670, /* GL_LEFT */ + 1356, /* GL_RIGHT */ + 556, /* GL_FRONT_AND_BACK */ 62, /* GL_AUX0 */ 63, /* GL_AUX1 */ 64, /* GL_AUX2 */ 65, /* GL_AUX3 */ - 653, /* GL_INVALID_ENUM */ - 657, /* GL_INVALID_VALUE */ - 656, /* GL_INVALID_OPERATION */ - 1443, /* GL_STACK_OVERFLOW */ - 1444, /* GL_STACK_UNDERFLOW */ - 1065, /* GL_OUT_OF_MEMORY */ - 654, /* GL_INVALID_FRAMEBUFFER_OPERATION */ + 661, /* GL_INVALID_ENUM */ + 665, /* GL_INVALID_VALUE */ + 664, /* GL_INVALID_OPERATION */ + 1451, /* GL_STACK_OVERFLOW */ + 1452, /* GL_STACK_UNDERFLOW */ + 1073, /* GL_OUT_OF_MEMORY */ + 662, /* GL_INVALID_FRAMEBUFFER_OPERATION */ 0, /* GL_2D */ 2, /* GL_3D */ 3, /* GL_3D_COLOR */ 4, /* GL_3D_COLOR_TEXTURE */ 6, /* GL_4D_COLOR_TEXTURE */ - 1085, /* GL_PASS_THROUGH_TOKEN */ - 1141, /* GL_POINT_TOKEN */ - 697, /* GL_LINE_TOKEN */ - 1155, /* GL_POLYGON_TOKEN */ + 1093, /* GL_PASS_THROUGH_TOKEN */ + 1149, /* GL_POINT_TOKEN */ + 705, /* GL_LINE_TOKEN */ + 1163, /* GL_POLYGON_TOKEN */ 73, /* GL_BITMAP_TOKEN */ - 425, /* GL_DRAW_PIXEL_TOKEN */ - 286, /* GL_COPY_PIXEL_TOKEN */ - 690, /* GL_LINE_RESET_TOKEN */ - 448, /* GL_EXP */ - 449, /* GL_EXP2 */ - 319, /* GL_CW */ - 115, /* GL_CCW */ - 136, /* GL_COEFF */ - 1062, /* GL_ORDER */ - 363, /* GL_DOMAIN */ - 294, /* GL_CURRENT_COLOR */ - 297, /* GL_CURRENT_INDEX */ - 303, /* GL_CURRENT_NORMAL */ - 315, /* GL_CURRENT_TEXTURE_COORDS */ - 308, /* GL_CURRENT_RASTER_COLOR */ - 310, /* GL_CURRENT_RASTER_INDEX */ - 313, /* GL_CURRENT_RASTER_TEXTURE_COORDS */ - 311, /* GL_CURRENT_RASTER_POSITION */ - 312, /* GL_CURRENT_RASTER_POSITION_VALID */ - 309, /* GL_CURRENT_RASTER_DISTANCE */ - 1134, /* GL_POINT_SMOOTH */ - 1123, /* GL_POINT_SIZE */ - 1133, /* GL_POINT_SIZE_RANGE */ - 1124, /* GL_POINT_SIZE_GRANULARITY */ - 691, /* GL_LINE_SMOOTH */ - 698, /* GL_LINE_WIDTH */ - 700, /* GL_LINE_WIDTH_RANGE */ - 699, /* GL_LINE_WIDTH_GRANULARITY */ - 693, /* GL_LINE_STIPPLE */ - 694, /* GL_LINE_STIPPLE_PATTERN */ - 695, /* GL_LINE_STIPPLE_REPEAT */ - 705, /* GL_LIST_MODE */ - 864, /* GL_MAX_LIST_NESTING */ - 702, /* GL_LIST_BASE */ - 704, /* GL_LIST_INDEX */ - 1144, /* GL_POLYGON_MODE */ - 1151, /* GL_POLYGON_SMOOTH */ - 1153, /* GL_POLYGON_STIPPLE */ - 434, /* GL_EDGE_FLAG */ - 287, /* GL_CULL_FACE */ - 288, /* GL_CULL_FACE_MODE */ - 549, /* GL_FRONT_FACE */ - 673, /* GL_LIGHTING */ - 678, /* GL_LIGHT_MODEL_LOCAL_VIEWER */ - 679, /* GL_LIGHT_MODEL_TWO_SIDE */ - 675, /* GL_LIGHT_MODEL_AMBIENT */ - 1394, /* GL_SHADE_MODEL */ - 183, /* GL_COLOR_MATERIAL_FACE */ - 184, /* GL_COLOR_MATERIAL_PARAMETER */ - 182, /* GL_COLOR_MATERIAL */ - 476, /* GL_FOG */ - 498, /* GL_FOG_INDEX */ - 494, /* GL_FOG_DENSITY */ - 502, /* GL_FOG_START */ - 496, /* GL_FOG_END */ - 499, /* GL_FOG_MODE */ - 478, /* GL_FOG_COLOR */ - 350, /* GL_DEPTH_RANGE */ - 357, /* GL_DEPTH_TEST */ - 360, /* GL_DEPTH_WRITEMASK */ - 338, /* GL_DEPTH_CLEAR_VALUE */ - 349, /* GL_DEPTH_FUNC */ + 431, /* GL_DRAW_PIXEL_TOKEN */ + 292, /* GL_COPY_PIXEL_TOKEN */ + 698, /* GL_LINE_RESET_TOKEN */ + 456, /* GL_EXP */ + 457, /* GL_EXP2 */ + 325, /* GL_CW */ + 121, /* GL_CCW */ + 142, /* GL_COEFF */ + 1070, /* GL_ORDER */ + 369, /* GL_DOMAIN */ + 300, /* GL_CURRENT_COLOR */ + 303, /* GL_CURRENT_INDEX */ + 309, /* GL_CURRENT_NORMAL */ + 321, /* GL_CURRENT_TEXTURE_COORDS */ + 314, /* GL_CURRENT_RASTER_COLOR */ + 316, /* GL_CURRENT_RASTER_INDEX */ + 319, /* GL_CURRENT_RASTER_TEXTURE_COORDS */ + 317, /* GL_CURRENT_RASTER_POSITION */ + 318, /* GL_CURRENT_RASTER_POSITION_VALID */ + 315, /* GL_CURRENT_RASTER_DISTANCE */ + 1142, /* GL_POINT_SMOOTH */ + 1131, /* GL_POINT_SIZE */ + 1141, /* GL_POINT_SIZE_RANGE */ + 1132, /* GL_POINT_SIZE_GRANULARITY */ + 699, /* GL_LINE_SMOOTH */ + 706, /* GL_LINE_WIDTH */ + 708, /* GL_LINE_WIDTH_RANGE */ + 707, /* GL_LINE_WIDTH_GRANULARITY */ + 701, /* GL_LINE_STIPPLE */ + 702, /* GL_LINE_STIPPLE_PATTERN */ + 703, /* GL_LINE_STIPPLE_REPEAT */ + 713, /* GL_LIST_MODE */ + 872, /* GL_MAX_LIST_NESTING */ + 710, /* GL_LIST_BASE */ + 712, /* GL_LIST_INDEX */ + 1152, /* GL_POLYGON_MODE */ + 1159, /* GL_POLYGON_SMOOTH */ + 1161, /* GL_POLYGON_STIPPLE */ + 442, /* GL_EDGE_FLAG */ + 293, /* GL_CULL_FACE */ + 294, /* GL_CULL_FACE_MODE */ + 557, /* GL_FRONT_FACE */ + 681, /* GL_LIGHTING */ + 686, /* GL_LIGHT_MODEL_LOCAL_VIEWER */ + 687, /* GL_LIGHT_MODEL_TWO_SIDE */ + 683, /* GL_LIGHT_MODEL_AMBIENT */ + 1402, /* GL_SHADE_MODEL */ + 189, /* GL_COLOR_MATERIAL_FACE */ + 190, /* GL_COLOR_MATERIAL_PARAMETER */ + 188, /* GL_COLOR_MATERIAL */ + 484, /* GL_FOG */ + 506, /* GL_FOG_INDEX */ + 502, /* GL_FOG_DENSITY */ + 510, /* GL_FOG_START */ + 504, /* GL_FOG_END */ + 507, /* GL_FOG_MODE */ + 486, /* GL_FOG_COLOR */ + 356, /* GL_DEPTH_RANGE */ + 363, /* GL_DEPTH_TEST */ + 366, /* GL_DEPTH_WRITEMASK */ + 344, /* GL_DEPTH_CLEAR_VALUE */ + 355, /* GL_DEPTH_FUNC */ 12, /* GL_ACCUM_CLEAR_VALUE */ - 1479, /* GL_STENCIL_TEST */ - 1467, /* GL_STENCIL_CLEAR_VALUE */ - 1469, /* GL_STENCIL_FUNC */ - 1481, /* GL_STENCIL_VALUE_MASK */ - 1468, /* GL_STENCIL_FAIL */ - 1476, /* GL_STENCIL_PASS_DEPTH_FAIL */ - 1477, /* GL_STENCIL_PASS_DEPTH_PASS */ - 1478, /* GL_STENCIL_REF */ - 1482, /* GL_STENCIL_WRITEMASK */ - 833, /* GL_MATRIX_MODE */ - 1001, /* GL_NORMALIZE */ - 1791, /* GL_VIEWPORT */ - 975, /* GL_MODELVIEW_STACK_DEPTH */ - 1234, /* GL_PROJECTION_STACK_DEPTH */ - 1677, /* GL_TEXTURE_STACK_DEPTH */ - 973, /* GL_MODELVIEW_MATRIX */ - 1233, /* GL_PROJECTION_MATRIX */ - 1662, /* GL_TEXTURE_MATRIX */ + 1487, /* GL_STENCIL_TEST */ + 1475, /* GL_STENCIL_CLEAR_VALUE */ + 1477, /* GL_STENCIL_FUNC */ + 1489, /* GL_STENCIL_VALUE_MASK */ + 1476, /* GL_STENCIL_FAIL */ + 1484, /* GL_STENCIL_PASS_DEPTH_FAIL */ + 1485, /* GL_STENCIL_PASS_DEPTH_PASS */ + 1486, /* GL_STENCIL_REF */ + 1490, /* GL_STENCIL_WRITEMASK */ + 841, /* GL_MATRIX_MODE */ + 1009, /* GL_NORMALIZE */ + 1799, /* GL_VIEWPORT */ + 983, /* GL_MODELVIEW_STACK_DEPTH */ + 1242, /* GL_PROJECTION_STACK_DEPTH */ + 1685, /* GL_TEXTURE_STACK_DEPTH */ + 981, /* GL_MODELVIEW_MATRIX */ + 1241, /* GL_PROJECTION_MATRIX */ + 1670, /* GL_TEXTURE_MATRIX */ 60, /* GL_ATTRIB_STACK_DEPTH */ - 126, /* GL_CLIENT_ATTRIB_STACK_DEPTH */ + 132, /* GL_CLIENT_ATTRIB_STACK_DEPTH */ 43, /* GL_ALPHA_TEST */ 44, /* GL_ALPHA_TEST_FUNC */ 45, /* GL_ALPHA_TEST_REF */ - 362, /* GL_DITHER */ + 368, /* GL_DITHER */ 77, /* GL_BLEND_DST */ 85, /* GL_BLEND_SRC */ 74, /* GL_BLEND */ - 708, /* GL_LOGIC_OP_MODE */ - 627, /* GL_INDEX_LOGIC_OP */ - 181, /* GL_COLOR_LOGIC_OP */ + 716, /* GL_LOGIC_OP_MODE */ + 635, /* GL_INDEX_LOGIC_OP */ + 187, /* GL_COLOR_LOGIC_OP */ 66, /* GL_AUX_BUFFERS */ - 373, /* GL_DRAW_BUFFER */ - 1266, /* GL_READ_BUFFER */ - 1375, /* GL_SCISSOR_BOX */ - 1376, /* GL_SCISSOR_TEST */ - 626, /* GL_INDEX_CLEAR_VALUE */ - 631, /* GL_INDEX_WRITEMASK */ - 178, /* GL_COLOR_CLEAR_VALUE */ - 220, /* GL_COLOR_WRITEMASK */ - 628, /* GL_INDEX_MODE */ - 1342, /* GL_RGBA_MODE */ - 372, /* GL_DOUBLEBUFFER */ - 1483, /* GL_STEREO */ - 1301, /* GL_RENDER_MODE */ - 1086, /* GL_PERSPECTIVE_CORRECTION_HINT */ - 1135, /* GL_POINT_SMOOTH_HINT */ - 692, /* GL_LINE_SMOOTH_HINT */ - 1152, /* GL_POLYGON_SMOOTH_HINT */ - 497, /* GL_FOG_HINT */ - 1643, /* GL_TEXTURE_GEN_S */ - 1644, /* GL_TEXTURE_GEN_T */ - 1642, /* GL_TEXTURE_GEN_R */ - 1641, /* GL_TEXTURE_GEN_Q */ - 1099, /* GL_PIXEL_MAP_I_TO_I */ - 1105, /* GL_PIXEL_MAP_S_TO_S */ - 1101, /* GL_PIXEL_MAP_I_TO_R */ - 1097, /* GL_PIXEL_MAP_I_TO_G */ - 1095, /* GL_PIXEL_MAP_I_TO_B */ - 1093, /* GL_PIXEL_MAP_I_TO_A */ - 1103, /* GL_PIXEL_MAP_R_TO_R */ - 1091, /* GL_PIXEL_MAP_G_TO_G */ - 1089, /* GL_PIXEL_MAP_B_TO_B */ - 1087, /* GL_PIXEL_MAP_A_TO_A */ - 1100, /* GL_PIXEL_MAP_I_TO_I_SIZE */ - 1106, /* GL_PIXEL_MAP_S_TO_S_SIZE */ - 1102, /* GL_PIXEL_MAP_I_TO_R_SIZE */ - 1098, /* GL_PIXEL_MAP_I_TO_G_SIZE */ - 1096, /* GL_PIXEL_MAP_I_TO_B_SIZE */ - 1094, /* GL_PIXEL_MAP_I_TO_A_SIZE */ - 1104, /* GL_PIXEL_MAP_R_TO_R_SIZE */ - 1092, /* GL_PIXEL_MAP_G_TO_G_SIZE */ - 1090, /* GL_PIXEL_MAP_B_TO_B_SIZE */ - 1088, /* GL_PIXEL_MAP_A_TO_A_SIZE */ - 1711, /* GL_UNPACK_SWAP_BYTES */ - 1706, /* GL_UNPACK_LSB_FIRST */ - 1707, /* GL_UNPACK_ROW_LENGTH */ - 1710, /* GL_UNPACK_SKIP_ROWS */ - 1709, /* GL_UNPACK_SKIP_PIXELS */ - 1704, /* GL_UNPACK_ALIGNMENT */ - 1074, /* GL_PACK_SWAP_BYTES */ - 1069, /* GL_PACK_LSB_FIRST */ - 1070, /* GL_PACK_ROW_LENGTH */ - 1073, /* GL_PACK_SKIP_ROWS */ - 1072, /* GL_PACK_SKIP_PIXELS */ - 1066, /* GL_PACK_ALIGNMENT */ - 786, /* GL_MAP_COLOR */ - 787, /* GL_MAP_STENCIL */ - 630, /* GL_INDEX_SHIFT */ - 629, /* GL_INDEX_OFFSET */ - 1279, /* GL_RED_SCALE */ - 1277, /* GL_RED_BIAS */ - 1808, /* GL_ZOOM_X */ - 1809, /* GL_ZOOM_Y */ - 591, /* GL_GREEN_SCALE */ - 589, /* GL_GREEN_BIAS */ + 379, /* GL_DRAW_BUFFER */ + 1274, /* GL_READ_BUFFER */ + 1383, /* GL_SCISSOR_BOX */ + 1384, /* GL_SCISSOR_TEST */ + 634, /* GL_INDEX_CLEAR_VALUE */ + 639, /* GL_INDEX_WRITEMASK */ + 184, /* GL_COLOR_CLEAR_VALUE */ + 226, /* GL_COLOR_WRITEMASK */ + 636, /* GL_INDEX_MODE */ + 1350, /* GL_RGBA_MODE */ + 378, /* GL_DOUBLEBUFFER */ + 1491, /* GL_STEREO */ + 1309, /* GL_RENDER_MODE */ + 1094, /* GL_PERSPECTIVE_CORRECTION_HINT */ + 1143, /* GL_POINT_SMOOTH_HINT */ + 700, /* GL_LINE_SMOOTH_HINT */ + 1160, /* GL_POLYGON_SMOOTH_HINT */ + 505, /* GL_FOG_HINT */ + 1651, /* GL_TEXTURE_GEN_S */ + 1652, /* GL_TEXTURE_GEN_T */ + 1650, /* GL_TEXTURE_GEN_R */ + 1649, /* GL_TEXTURE_GEN_Q */ + 1107, /* GL_PIXEL_MAP_I_TO_I */ + 1113, /* GL_PIXEL_MAP_S_TO_S */ + 1109, /* GL_PIXEL_MAP_I_TO_R */ + 1105, /* GL_PIXEL_MAP_I_TO_G */ + 1103, /* GL_PIXEL_MAP_I_TO_B */ + 1101, /* GL_PIXEL_MAP_I_TO_A */ + 1111, /* GL_PIXEL_MAP_R_TO_R */ + 1099, /* GL_PIXEL_MAP_G_TO_G */ + 1097, /* GL_PIXEL_MAP_B_TO_B */ + 1095, /* GL_PIXEL_MAP_A_TO_A */ + 1108, /* GL_PIXEL_MAP_I_TO_I_SIZE */ + 1114, /* GL_PIXEL_MAP_S_TO_S_SIZE */ + 1110, /* GL_PIXEL_MAP_I_TO_R_SIZE */ + 1106, /* GL_PIXEL_MAP_I_TO_G_SIZE */ + 1104, /* GL_PIXEL_MAP_I_TO_B_SIZE */ + 1102, /* GL_PIXEL_MAP_I_TO_A_SIZE */ + 1112, /* GL_PIXEL_MAP_R_TO_R_SIZE */ + 1100, /* GL_PIXEL_MAP_G_TO_G_SIZE */ + 1098, /* GL_PIXEL_MAP_B_TO_B_SIZE */ + 1096, /* GL_PIXEL_MAP_A_TO_A_SIZE */ + 1719, /* GL_UNPACK_SWAP_BYTES */ + 1714, /* GL_UNPACK_LSB_FIRST */ + 1715, /* GL_UNPACK_ROW_LENGTH */ + 1718, /* GL_UNPACK_SKIP_ROWS */ + 1717, /* GL_UNPACK_SKIP_PIXELS */ + 1712, /* GL_UNPACK_ALIGNMENT */ + 1082, /* GL_PACK_SWAP_BYTES */ + 1077, /* GL_PACK_LSB_FIRST */ + 1078, /* GL_PACK_ROW_LENGTH */ + 1081, /* GL_PACK_SKIP_ROWS */ + 1080, /* GL_PACK_SKIP_PIXELS */ + 1074, /* GL_PACK_ALIGNMENT */ + 794, /* GL_MAP_COLOR */ + 795, /* GL_MAP_STENCIL */ + 638, /* GL_INDEX_SHIFT */ + 637, /* GL_INDEX_OFFSET */ + 1287, /* GL_RED_SCALE */ + 1285, /* GL_RED_BIAS */ + 1816, /* GL_ZOOM_X */ + 1817, /* GL_ZOOM_Y */ + 599, /* GL_GREEN_SCALE */ + 597, /* GL_GREEN_BIAS */ 91, /* GL_BLUE_SCALE */ 89, /* GL_BLUE_BIAS */ 42, /* GL_ALPHA_SCALE */ 40, /* GL_ALPHA_BIAS */ - 351, /* GL_DEPTH_SCALE */ - 332, /* GL_DEPTH_BIAS */ - 859, /* GL_MAX_EVAL_ORDER */ - 863, /* GL_MAX_LIGHTS */ - 842, /* GL_MAX_CLIP_PLANES */ - 908, /* GL_MAX_TEXTURE_SIZE */ - 869, /* GL_MAX_PIXEL_MAP_TABLE */ - 838, /* GL_MAX_ATTRIB_STACK_DEPTH */ - 866, /* GL_MAX_MODELVIEW_STACK_DEPTH */ - 867, /* GL_MAX_NAME_STACK_DEPTH */ - 895, /* GL_MAX_PROJECTION_STACK_DEPTH */ - 909, /* GL_MAX_TEXTURE_STACK_DEPTH */ - 923, /* GL_MAX_VIEWPORT_DIMS */ - 839, /* GL_MAX_CLIENT_ATTRIB_STACK_DEPTH */ - 1490, /* GL_SUBPIXEL_BITS */ - 625, /* GL_INDEX_BITS */ - 1278, /* GL_RED_BITS */ - 590, /* GL_GREEN_BITS */ + 357, /* GL_DEPTH_SCALE */ + 338, /* GL_DEPTH_BIAS */ + 867, /* GL_MAX_EVAL_ORDER */ + 871, /* GL_MAX_LIGHTS */ + 850, /* GL_MAX_CLIP_PLANES */ + 916, /* GL_MAX_TEXTURE_SIZE */ + 877, /* GL_MAX_PIXEL_MAP_TABLE */ + 846, /* GL_MAX_ATTRIB_STACK_DEPTH */ + 874, /* GL_MAX_MODELVIEW_STACK_DEPTH */ + 875, /* GL_MAX_NAME_STACK_DEPTH */ + 903, /* GL_MAX_PROJECTION_STACK_DEPTH */ + 917, /* GL_MAX_TEXTURE_STACK_DEPTH */ + 931, /* GL_MAX_VIEWPORT_DIMS */ + 847, /* GL_MAX_CLIENT_ATTRIB_STACK_DEPTH */ + 1498, /* GL_SUBPIXEL_BITS */ + 633, /* GL_INDEX_BITS */ + 1286, /* GL_RED_BITS */ + 598, /* GL_GREEN_BITS */ 90, /* GL_BLUE_BITS */ 41, /* GL_ALPHA_BITS */ - 333, /* GL_DEPTH_BITS */ - 1465, /* GL_STENCIL_BITS */ + 339, /* GL_DEPTH_BITS */ + 1473, /* GL_STENCIL_BITS */ 14, /* GL_ACCUM_RED_BITS */ 13, /* GL_ACCUM_GREEN_BITS */ 10, /* GL_ACCUM_BLUE_BITS */ 9, /* GL_ACCUM_ALPHA_BITS */ - 989, /* GL_NAME_STACK_DEPTH */ + 997, /* GL_NAME_STACK_DEPTH */ 61, /* GL_AUTO_NORMAL */ - 732, /* GL_MAP1_COLOR_4 */ - 735, /* GL_MAP1_INDEX */ - 736, /* GL_MAP1_NORMAL */ - 737, /* GL_MAP1_TEXTURE_COORD_1 */ - 738, /* GL_MAP1_TEXTURE_COORD_2 */ - 739, /* GL_MAP1_TEXTURE_COORD_3 */ - 740, /* GL_MAP1_TEXTURE_COORD_4 */ - 741, /* GL_MAP1_VERTEX_3 */ - 742, /* GL_MAP1_VERTEX_4 */ - 759, /* GL_MAP2_COLOR_4 */ - 762, /* GL_MAP2_INDEX */ - 763, /* GL_MAP2_NORMAL */ - 764, /* GL_MAP2_TEXTURE_COORD_1 */ - 765, /* GL_MAP2_TEXTURE_COORD_2 */ - 766, /* GL_MAP2_TEXTURE_COORD_3 */ - 767, /* GL_MAP2_TEXTURE_COORD_4 */ - 768, /* GL_MAP2_VERTEX_3 */ - 769, /* GL_MAP2_VERTEX_4 */ - 733, /* GL_MAP1_GRID_DOMAIN */ - 734, /* GL_MAP1_GRID_SEGMENTS */ - 760, /* GL_MAP2_GRID_DOMAIN */ - 761, /* GL_MAP2_GRID_SEGMENTS */ - 1567, /* GL_TEXTURE_1D */ - 1569, /* GL_TEXTURE_2D */ - 458, /* GL_FEEDBACK_BUFFER_POINTER */ - 459, /* GL_FEEDBACK_BUFFER_SIZE */ - 460, /* GL_FEEDBACK_BUFFER_TYPE */ - 1385, /* GL_SELECTION_BUFFER_POINTER */ - 1386, /* GL_SELECTION_BUFFER_SIZE */ - 1681, /* GL_TEXTURE_WIDTH */ - 1648, /* GL_TEXTURE_HEIGHT */ - 1604, /* GL_TEXTURE_COMPONENTS */ - 1588, /* GL_TEXTURE_BORDER_COLOR */ - 1587, /* GL_TEXTURE_BORDER */ - 364, /* GL_DONT_CARE */ - 456, /* GL_FASTEST */ - 997, /* GL_NICEST */ + 740, /* GL_MAP1_COLOR_4 */ + 743, /* GL_MAP1_INDEX */ + 744, /* GL_MAP1_NORMAL */ + 745, /* GL_MAP1_TEXTURE_COORD_1 */ + 746, /* GL_MAP1_TEXTURE_COORD_2 */ + 747, /* GL_MAP1_TEXTURE_COORD_3 */ + 748, /* GL_MAP1_TEXTURE_COORD_4 */ + 749, /* GL_MAP1_VERTEX_3 */ + 750, /* GL_MAP1_VERTEX_4 */ + 767, /* GL_MAP2_COLOR_4 */ + 770, /* GL_MAP2_INDEX */ + 771, /* GL_MAP2_NORMAL */ + 772, /* GL_MAP2_TEXTURE_COORD_1 */ + 773, /* GL_MAP2_TEXTURE_COORD_2 */ + 774, /* GL_MAP2_TEXTURE_COORD_3 */ + 775, /* GL_MAP2_TEXTURE_COORD_4 */ + 776, /* GL_MAP2_VERTEX_3 */ + 777, /* GL_MAP2_VERTEX_4 */ + 741, /* GL_MAP1_GRID_DOMAIN */ + 742, /* GL_MAP1_GRID_SEGMENTS */ + 768, /* GL_MAP2_GRID_DOMAIN */ + 769, /* GL_MAP2_GRID_SEGMENTS */ + 1575, /* GL_TEXTURE_1D */ + 1577, /* GL_TEXTURE_2D */ + 466, /* GL_FEEDBACK_BUFFER_POINTER */ + 467, /* GL_FEEDBACK_BUFFER_SIZE */ + 468, /* GL_FEEDBACK_BUFFER_TYPE */ + 1393, /* GL_SELECTION_BUFFER_POINTER */ + 1394, /* GL_SELECTION_BUFFER_SIZE */ + 1689, /* GL_TEXTURE_WIDTH */ + 1656, /* GL_TEXTURE_HEIGHT */ + 1612, /* GL_TEXTURE_COMPONENTS */ + 1596, /* GL_TEXTURE_BORDER_COLOR */ + 1595, /* GL_TEXTURE_BORDER */ + 370, /* GL_DONT_CARE */ + 464, /* GL_FASTEST */ + 1005, /* GL_NICEST */ 47, /* GL_AMBIENT */ - 361, /* GL_DIFFUSE */ - 1428, /* GL_SPECULAR */ - 1156, /* GL_POSITION */ - 1431, /* GL_SPOT_DIRECTION */ - 1432, /* GL_SPOT_EXPONENT */ - 1430, /* GL_SPOT_CUTOFF */ - 260, /* GL_CONSTANT_ATTENUATION */ - 682, /* GL_LINEAR_ATTENUATION */ - 1253, /* GL_QUADRATIC_ATTENUATION */ - 234, /* GL_COMPILE */ - 235, /* GL_COMPILE_AND_EXECUTE */ - 110, /* GL_BYTE */ - 1712, /* GL_UNSIGNED_BYTE */ - 1399, /* GL_SHORT */ - 1723, /* GL_UNSIGNED_SHORT */ - 633, /* GL_INT */ - 1715, /* GL_UNSIGNED_INT */ - 463, /* GL_FLOAT */ + 367, /* GL_DIFFUSE */ + 1436, /* GL_SPECULAR */ + 1164, /* GL_POSITION */ + 1439, /* GL_SPOT_DIRECTION */ + 1440, /* GL_SPOT_EXPONENT */ + 1438, /* GL_SPOT_CUTOFF */ + 266, /* GL_CONSTANT_ATTENUATION */ + 690, /* GL_LINEAR_ATTENUATION */ + 1261, /* GL_QUADRATIC_ATTENUATION */ + 240, /* GL_COMPILE */ + 241, /* GL_COMPILE_AND_EXECUTE */ + 116, /* GL_BYTE */ + 1720, /* GL_UNSIGNED_BYTE */ + 1407, /* GL_SHORT */ + 1731, /* GL_UNSIGNED_SHORT */ + 641, /* GL_INT */ + 1723, /* GL_UNSIGNED_INT */ + 471, /* GL_FLOAT */ 1, /* GL_2_BYTES */ 5, /* GL_3_BYTES */ 7, /* GL_4_BYTES */ - 371, /* GL_DOUBLE */ - 122, /* GL_CLEAR */ + 377, /* GL_DOUBLE */ + 128, /* GL_CLEAR */ 49, /* GL_AND */ 51, /* GL_AND_REVERSE */ - 284, /* GL_COPY */ + 290, /* GL_COPY */ 50, /* GL_AND_INVERTED */ - 999, /* GL_NOOP */ - 1804, /* GL_XOR */ - 1061, /* GL_OR */ - 1000, /* GL_NOR */ - 446, /* GL_EQUIV */ - 660, /* GL_INVERT */ - 1064, /* GL_OR_REVERSE */ - 285, /* GL_COPY_INVERTED */ - 1063, /* GL_OR_INVERTED */ - 990, /* GL_NAND */ - 1390, /* GL_SET */ - 443, /* GL_EMISSION */ - 1398, /* GL_SHININESS */ + 1007, /* GL_NOOP */ + 1812, /* GL_XOR */ + 1069, /* GL_OR */ + 1008, /* GL_NOR */ + 454, /* GL_EQUIV */ + 668, /* GL_INVERT */ + 1072, /* GL_OR_REVERSE */ + 291, /* GL_COPY_INVERTED */ + 1071, /* GL_OR_INVERTED */ + 998, /* GL_NAND */ + 1398, /* GL_SET */ + 451, /* GL_EMISSION */ + 1406, /* GL_SHININESS */ 48, /* GL_AMBIENT_AND_DIFFUSE */ - 180, /* GL_COLOR_INDEXES */ - 940, /* GL_MODELVIEW */ - 1232, /* GL_PROJECTION */ - 1502, /* GL_TEXTURE */ - 137, /* GL_COLOR */ - 328, /* GL_DEPTH */ - 1451, /* GL_STENCIL */ - 179, /* GL_COLOR_INDEX */ - 1470, /* GL_STENCIL_INDEX */ - 339, /* GL_DEPTH_COMPONENT */ - 1274, /* GL_RED */ - 588, /* GL_GREEN */ + 186, /* GL_COLOR_INDEXES */ + 948, /* GL_MODELVIEW */ + 1240, /* GL_PROJECTION */ + 1510, /* GL_TEXTURE */ + 143, /* GL_COLOR */ + 334, /* GL_DEPTH */ + 1459, /* GL_STENCIL */ + 185, /* GL_COLOR_INDEX */ + 1478, /* GL_STENCIL_INDEX */ + 345, /* GL_DEPTH_COMPONENT */ + 1282, /* GL_RED */ + 596, /* GL_GREEN */ 88, /* GL_BLUE */ 31, /* GL_ALPHA */ - 1309, /* GL_RGB */ - 1328, /* GL_RGBA */ - 710, /* GL_LUMINANCE */ - 731, /* GL_LUMINANCE_ALPHA */ + 1317, /* GL_RGB */ + 1336, /* GL_RGBA */ + 718, /* GL_LUMINANCE */ + 739, /* GL_LUMINANCE_ALPHA */ 72, /* GL_BITMAP */ - 1112, /* GL_POINT */ - 680, /* GL_LINE */ - 461, /* GL_FILL */ - 1283, /* GL_RENDER */ - 457, /* GL_FEEDBACK */ - 1384, /* GL_SELECT */ - 462, /* GL_FLAT */ - 1403, /* GL_SMOOTH */ - 661, /* GL_KEEP */ - 1303, /* GL_REPLACE */ - 615, /* GL_INCR */ - 324, /* GL_DECR */ - 1738, /* GL_VENDOR */ - 1300, /* GL_RENDERER */ - 1739, /* GL_VERSION */ - 450, /* GL_EXTENSIONS */ - 1349, /* GL_S */ - 1493, /* GL_T */ - 1263, /* GL_R */ - 1252, /* GL_Q */ - 976, /* GL_MODULATE */ - 323, /* GL_DECAL */ - 1638, /* GL_TEXTURE_ENV_MODE */ - 1637, /* GL_TEXTURE_ENV_COLOR */ - 1636, /* GL_TEXTURE_ENV */ - 451, /* GL_EYE_LINEAR */ - 1023, /* GL_OBJECT_LINEAR */ - 1429, /* GL_SPHERE_MAP */ - 1640, /* GL_TEXTURE_GEN_MODE */ - 1025, /* GL_OBJECT_PLANE */ - 452, /* GL_EYE_PLANE */ - 991, /* GL_NEAREST */ - 681, /* GL_LINEAR */ - 995, /* GL_NEAREST_MIPMAP_NEAREST */ - 686, /* GL_LINEAR_MIPMAP_NEAREST */ - 994, /* GL_NEAREST_MIPMAP_LINEAR */ - 685, /* GL_LINEAR_MIPMAP_LINEAR */ - 1661, /* GL_TEXTURE_MAG_FILTER */ - 1669, /* GL_TEXTURE_MIN_FILTER */ - 1683, /* GL_TEXTURE_WRAP_S */ - 1684, /* GL_TEXTURE_WRAP_T */ - 116, /* GL_CLAMP */ - 1302, /* GL_REPEAT */ - 1150, /* GL_POLYGON_OFFSET_UNITS */ - 1149, /* GL_POLYGON_OFFSET_POINT */ - 1148, /* GL_POLYGON_OFFSET_LINE */ - 1264, /* GL_R3_G3_B2 */ - 1735, /* GL_V2F */ - 1736, /* GL_V3F */ - 113, /* GL_C4UB_V2F */ - 114, /* GL_C4UB_V3F */ - 111, /* GL_C3F_V3F */ - 988, /* GL_N3F_V3F */ - 112, /* GL_C4F_N3F_V3F */ - 1498, /* GL_T2F_V3F */ - 1500, /* GL_T4F_V4F */ - 1496, /* GL_T2F_C4UB_V3F */ - 1494, /* GL_T2F_C3F_V3F */ - 1497, /* GL_T2F_N3F_V3F */ - 1495, /* GL_T2F_C4F_N3F_V3F */ - 1499, /* GL_T4F_C4F_N3F_V4F */ - 129, /* GL_CLIP_PLANE0 */ - 130, /* GL_CLIP_PLANE1 */ - 131, /* GL_CLIP_PLANE2 */ - 132, /* GL_CLIP_PLANE3 */ - 133, /* GL_CLIP_PLANE4 */ - 134, /* GL_CLIP_PLANE5 */ - 665, /* GL_LIGHT0 */ - 666, /* GL_LIGHT1 */ - 667, /* GL_LIGHT2 */ - 668, /* GL_LIGHT3 */ - 669, /* GL_LIGHT4 */ - 670, /* GL_LIGHT5 */ - 671, /* GL_LIGHT6 */ - 672, /* GL_LIGHT7 */ - 592, /* GL_HINT_BIT */ - 262, /* GL_CONSTANT_COLOR */ - 1035, /* GL_ONE_MINUS_CONSTANT_COLOR */ - 257, /* GL_CONSTANT_ALPHA */ - 1033, /* GL_ONE_MINUS_CONSTANT_ALPHA */ + 1120, /* GL_POINT */ + 688, /* GL_LINE */ + 469, /* GL_FILL */ + 1291, /* GL_RENDER */ + 465, /* GL_FEEDBACK */ + 1392, /* GL_SELECT */ + 470, /* GL_FLAT */ + 1411, /* GL_SMOOTH */ + 669, /* GL_KEEP */ + 1311, /* GL_REPLACE */ + 623, /* GL_INCR */ + 330, /* GL_DECR */ + 1746, /* GL_VENDOR */ + 1308, /* GL_RENDERER */ + 1747, /* GL_VERSION */ + 458, /* GL_EXTENSIONS */ + 1357, /* GL_S */ + 1501, /* GL_T */ + 1271, /* GL_R */ + 1260, /* GL_Q */ + 984, /* GL_MODULATE */ + 329, /* GL_DECAL */ + 1646, /* GL_TEXTURE_ENV_MODE */ + 1645, /* GL_TEXTURE_ENV_COLOR */ + 1644, /* GL_TEXTURE_ENV */ + 459, /* GL_EYE_LINEAR */ + 1031, /* GL_OBJECT_LINEAR */ + 1437, /* GL_SPHERE_MAP */ + 1648, /* GL_TEXTURE_GEN_MODE */ + 1033, /* GL_OBJECT_PLANE */ + 460, /* GL_EYE_PLANE */ + 999, /* GL_NEAREST */ + 689, /* GL_LINEAR */ + 1003, /* GL_NEAREST_MIPMAP_NEAREST */ + 694, /* GL_LINEAR_MIPMAP_NEAREST */ + 1002, /* GL_NEAREST_MIPMAP_LINEAR */ + 693, /* GL_LINEAR_MIPMAP_LINEAR */ + 1669, /* GL_TEXTURE_MAG_FILTER */ + 1677, /* GL_TEXTURE_MIN_FILTER */ + 1691, /* GL_TEXTURE_WRAP_S */ + 1692, /* GL_TEXTURE_WRAP_T */ + 122, /* GL_CLAMP */ + 1310, /* GL_REPEAT */ + 1158, /* GL_POLYGON_OFFSET_UNITS */ + 1157, /* GL_POLYGON_OFFSET_POINT */ + 1156, /* GL_POLYGON_OFFSET_LINE */ + 1272, /* GL_R3_G3_B2 */ + 1743, /* GL_V2F */ + 1744, /* GL_V3F */ + 119, /* GL_C4UB_V2F */ + 120, /* GL_C4UB_V3F */ + 117, /* GL_C3F_V3F */ + 996, /* GL_N3F_V3F */ + 118, /* GL_C4F_N3F_V3F */ + 1506, /* GL_T2F_V3F */ + 1508, /* GL_T4F_V4F */ + 1504, /* GL_T2F_C4UB_V3F */ + 1502, /* GL_T2F_C3F_V3F */ + 1505, /* GL_T2F_N3F_V3F */ + 1503, /* GL_T2F_C4F_N3F_V3F */ + 1507, /* GL_T4F_C4F_N3F_V4F */ + 135, /* GL_CLIP_PLANE0 */ + 136, /* GL_CLIP_PLANE1 */ + 137, /* GL_CLIP_PLANE2 */ + 138, /* GL_CLIP_PLANE3 */ + 139, /* GL_CLIP_PLANE4 */ + 140, /* GL_CLIP_PLANE5 */ + 673, /* GL_LIGHT0 */ + 674, /* GL_LIGHT1 */ + 675, /* GL_LIGHT2 */ + 676, /* GL_LIGHT3 */ + 677, /* GL_LIGHT4 */ + 678, /* GL_LIGHT5 */ + 679, /* GL_LIGHT6 */ + 680, /* GL_LIGHT7 */ + 600, /* GL_HINT_BIT */ + 268, /* GL_CONSTANT_COLOR */ + 1043, /* GL_ONE_MINUS_CONSTANT_COLOR */ + 263, /* GL_CONSTANT_ALPHA */ + 1041, /* GL_ONE_MINUS_CONSTANT_ALPHA */ 75, /* GL_BLEND_COLOR */ - 552, /* GL_FUNC_ADD */ - 924, /* GL_MIN */ - 835, /* GL_MAX */ + 560, /* GL_FUNC_ADD */ + 932, /* GL_MIN */ + 843, /* GL_MAX */ 80, /* GL_BLEND_EQUATION */ - 556, /* GL_FUNC_SUBTRACT */ - 554, /* GL_FUNC_REVERSE_SUBTRACT */ - 265, /* GL_CONVOLUTION_1D */ - 266, /* GL_CONVOLUTION_2D */ - 1387, /* GL_SEPARABLE_2D */ - 269, /* GL_CONVOLUTION_BORDER_MODE */ - 273, /* GL_CONVOLUTION_FILTER_SCALE */ - 271, /* GL_CONVOLUTION_FILTER_BIAS */ - 1275, /* GL_REDUCE */ - 275, /* GL_CONVOLUTION_FORMAT */ - 279, /* GL_CONVOLUTION_WIDTH */ - 277, /* GL_CONVOLUTION_HEIGHT */ - 850, /* GL_MAX_CONVOLUTION_WIDTH */ - 848, /* GL_MAX_CONVOLUTION_HEIGHT */ - 1189, /* GL_POST_CONVOLUTION_RED_SCALE */ - 1185, /* GL_POST_CONVOLUTION_GREEN_SCALE */ - 1180, /* GL_POST_CONVOLUTION_BLUE_SCALE */ - 1176, /* GL_POST_CONVOLUTION_ALPHA_SCALE */ - 1187, /* GL_POST_CONVOLUTION_RED_BIAS */ - 1183, /* GL_POST_CONVOLUTION_GREEN_BIAS */ - 1178, /* GL_POST_CONVOLUTION_BLUE_BIAS */ - 1174, /* GL_POST_CONVOLUTION_ALPHA_BIAS */ - 593, /* GL_HISTOGRAM */ - 1236, /* GL_PROXY_HISTOGRAM */ - 609, /* GL_HISTOGRAM_WIDTH */ - 599, /* GL_HISTOGRAM_FORMAT */ - 605, /* GL_HISTOGRAM_RED_SIZE */ - 601, /* GL_HISTOGRAM_GREEN_SIZE */ - 596, /* GL_HISTOGRAM_BLUE_SIZE */ - 594, /* GL_HISTOGRAM_ALPHA_SIZE */ - 603, /* GL_HISTOGRAM_LUMINANCE_SIZE */ - 607, /* GL_HISTOGRAM_SINK */ - 925, /* GL_MINMAX */ - 927, /* GL_MINMAX_FORMAT */ - 929, /* GL_MINMAX_SINK */ - 1501, /* GL_TABLE_TOO_LARGE_EXT */ - 1714, /* GL_UNSIGNED_BYTE_3_3_2 */ - 1725, /* GL_UNSIGNED_SHORT_4_4_4_4 */ - 1727, /* GL_UNSIGNED_SHORT_5_5_5_1 */ - 1720, /* GL_UNSIGNED_INT_8_8_8_8 */ - 1716, /* GL_UNSIGNED_INT_10_10_10_2 */ - 1147, /* GL_POLYGON_OFFSET_FILL */ - 1146, /* GL_POLYGON_OFFSET_FACTOR */ - 1145, /* GL_POLYGON_OFFSET_BIAS */ - 1306, /* GL_RESCALE_NORMAL */ + 564, /* GL_FUNC_SUBTRACT */ + 562, /* GL_FUNC_REVERSE_SUBTRACT */ + 271, /* GL_CONVOLUTION_1D */ + 272, /* GL_CONVOLUTION_2D */ + 1395, /* GL_SEPARABLE_2D */ + 275, /* GL_CONVOLUTION_BORDER_MODE */ + 279, /* GL_CONVOLUTION_FILTER_SCALE */ + 277, /* GL_CONVOLUTION_FILTER_BIAS */ + 1283, /* GL_REDUCE */ + 281, /* GL_CONVOLUTION_FORMAT */ + 285, /* GL_CONVOLUTION_WIDTH */ + 283, /* GL_CONVOLUTION_HEIGHT */ + 858, /* GL_MAX_CONVOLUTION_WIDTH */ + 856, /* GL_MAX_CONVOLUTION_HEIGHT */ + 1197, /* GL_POST_CONVOLUTION_RED_SCALE */ + 1193, /* GL_POST_CONVOLUTION_GREEN_SCALE */ + 1188, /* GL_POST_CONVOLUTION_BLUE_SCALE */ + 1184, /* GL_POST_CONVOLUTION_ALPHA_SCALE */ + 1195, /* GL_POST_CONVOLUTION_RED_BIAS */ + 1191, /* GL_POST_CONVOLUTION_GREEN_BIAS */ + 1186, /* GL_POST_CONVOLUTION_BLUE_BIAS */ + 1182, /* GL_POST_CONVOLUTION_ALPHA_BIAS */ + 601, /* GL_HISTOGRAM */ + 1244, /* GL_PROXY_HISTOGRAM */ + 617, /* GL_HISTOGRAM_WIDTH */ + 607, /* GL_HISTOGRAM_FORMAT */ + 613, /* GL_HISTOGRAM_RED_SIZE */ + 609, /* GL_HISTOGRAM_GREEN_SIZE */ + 604, /* GL_HISTOGRAM_BLUE_SIZE */ + 602, /* GL_HISTOGRAM_ALPHA_SIZE */ + 611, /* GL_HISTOGRAM_LUMINANCE_SIZE */ + 615, /* GL_HISTOGRAM_SINK */ + 933, /* GL_MINMAX */ + 935, /* GL_MINMAX_FORMAT */ + 937, /* GL_MINMAX_SINK */ + 1509, /* GL_TABLE_TOO_LARGE_EXT */ + 1722, /* GL_UNSIGNED_BYTE_3_3_2 */ + 1733, /* GL_UNSIGNED_SHORT_4_4_4_4 */ + 1735, /* GL_UNSIGNED_SHORT_5_5_5_1 */ + 1728, /* GL_UNSIGNED_INT_8_8_8_8 */ + 1724, /* GL_UNSIGNED_INT_10_10_10_2 */ + 1155, /* GL_POLYGON_OFFSET_FILL */ + 1154, /* GL_POLYGON_OFFSET_FACTOR */ + 1153, /* GL_POLYGON_OFFSET_BIAS */ + 1314, /* GL_RESCALE_NORMAL */ 36, /* GL_ALPHA4 */ 38, /* GL_ALPHA8 */ 32, /* GL_ALPHA12 */ 34, /* GL_ALPHA16 */ - 721, /* GL_LUMINANCE4 */ - 727, /* GL_LUMINANCE8 */ - 711, /* GL_LUMINANCE12 */ - 717, /* GL_LUMINANCE16 */ - 722, /* GL_LUMINANCE4_ALPHA4 */ - 725, /* GL_LUMINANCE6_ALPHA2 */ - 728, /* GL_LUMINANCE8_ALPHA8 */ - 714, /* GL_LUMINANCE12_ALPHA4 */ - 712, /* GL_LUMINANCE12_ALPHA12 */ - 718, /* GL_LUMINANCE16_ALPHA16 */ - 634, /* GL_INTENSITY */ - 639, /* GL_INTENSITY4 */ - 641, /* GL_INTENSITY8 */ - 635, /* GL_INTENSITY12 */ - 637, /* GL_INTENSITY16 */ - 1318, /* GL_RGB2_EXT */ - 1319, /* GL_RGB4 */ - 1322, /* GL_RGB5 */ - 1326, /* GL_RGB8 */ - 1310, /* GL_RGB10 */ - 1314, /* GL_RGB12 */ - 1316, /* GL_RGB16 */ - 1333, /* GL_RGBA2 */ - 1335, /* GL_RGBA4 */ - 1323, /* GL_RGB5_A1 */ - 1339, /* GL_RGBA8 */ - 1311, /* GL_RGB10_A2 */ - 1329, /* GL_RGBA12 */ - 1331, /* GL_RGBA16 */ - 1674, /* GL_TEXTURE_RED_SIZE */ - 1646, /* GL_TEXTURE_GREEN_SIZE */ - 1585, /* GL_TEXTURE_BLUE_SIZE */ - 1572, /* GL_TEXTURE_ALPHA_SIZE */ - 1659, /* GL_TEXTURE_LUMINANCE_SIZE */ - 1650, /* GL_TEXTURE_INTENSITY_SIZE */ - 1304, /* GL_REPLACE_EXT */ - 1240, /* GL_PROXY_TEXTURE_1D */ - 1243, /* GL_PROXY_TEXTURE_2D */ - 1679, /* GL_TEXTURE_TOO_LARGE_EXT */ - 1671, /* GL_TEXTURE_PRIORITY */ - 1676, /* GL_TEXTURE_RESIDENT */ - 1575, /* GL_TEXTURE_BINDING_1D */ - 1577, /* GL_TEXTURE_BINDING_2D */ - 1579, /* GL_TEXTURE_BINDING_3D */ - 1071, /* GL_PACK_SKIP_IMAGES */ - 1067, /* GL_PACK_IMAGE_HEIGHT */ - 1708, /* GL_UNPACK_SKIP_IMAGES */ - 1705, /* GL_UNPACK_IMAGE_HEIGHT */ - 1571, /* GL_TEXTURE_3D */ - 1246, /* GL_PROXY_TEXTURE_3D */ - 1633, /* GL_TEXTURE_DEPTH */ - 1682, /* GL_TEXTURE_WRAP_R */ - 836, /* GL_MAX_3D_TEXTURE_SIZE */ - 1740, /* GL_VERTEX_ARRAY */ - 1002, /* GL_NORMAL_ARRAY */ - 138, /* GL_COLOR_ARRAY */ - 619, /* GL_INDEX_ARRAY */ - 1612, /* GL_TEXTURE_COORD_ARRAY */ - 435, /* GL_EDGE_FLAG_ARRAY */ - 1745, /* GL_VERTEX_ARRAY_SIZE */ - 1747, /* GL_VERTEX_ARRAY_TYPE */ - 1746, /* GL_VERTEX_ARRAY_STRIDE */ - 1007, /* GL_NORMAL_ARRAY_TYPE */ - 1006, /* GL_NORMAL_ARRAY_STRIDE */ - 142, /* GL_COLOR_ARRAY_SIZE */ - 144, /* GL_COLOR_ARRAY_TYPE */ - 143, /* GL_COLOR_ARRAY_STRIDE */ - 624, /* GL_INDEX_ARRAY_TYPE */ - 623, /* GL_INDEX_ARRAY_STRIDE */ - 1616, /* GL_TEXTURE_COORD_ARRAY_SIZE */ - 1618, /* GL_TEXTURE_COORD_ARRAY_TYPE */ - 1617, /* GL_TEXTURE_COORD_ARRAY_STRIDE */ - 439, /* GL_EDGE_FLAG_ARRAY_STRIDE */ - 1744, /* GL_VERTEX_ARRAY_POINTER */ - 1005, /* GL_NORMAL_ARRAY_POINTER */ - 141, /* GL_COLOR_ARRAY_POINTER */ - 622, /* GL_INDEX_ARRAY_POINTER */ - 1615, /* GL_TEXTURE_COORD_ARRAY_POINTER */ - 438, /* GL_EDGE_FLAG_ARRAY_POINTER */ - 981, /* GL_MULTISAMPLE */ - 1361, /* GL_SAMPLE_ALPHA_TO_COVERAGE */ - 1363, /* GL_SAMPLE_ALPHA_TO_ONE */ - 1368, /* GL_SAMPLE_COVERAGE */ - 1365, /* GL_SAMPLE_BUFFERS */ - 1356, /* GL_SAMPLES */ - 1372, /* GL_SAMPLE_COVERAGE_VALUE */ - 1370, /* GL_SAMPLE_COVERAGE_INVERT */ - 185, /* GL_COLOR_MATRIX */ - 187, /* GL_COLOR_MATRIX_STACK_DEPTH */ - 844, /* GL_MAX_COLOR_MATRIX_STACK_DEPTH */ - 1172, /* GL_POST_COLOR_MATRIX_RED_SCALE */ - 1168, /* GL_POST_COLOR_MATRIX_GREEN_SCALE */ - 1163, /* GL_POST_COLOR_MATRIX_BLUE_SCALE */ - 1159, /* GL_POST_COLOR_MATRIX_ALPHA_SCALE */ - 1170, /* GL_POST_COLOR_MATRIX_RED_BIAS */ - 1166, /* GL_POST_COLOR_MATRIX_GREEN_BIAS */ - 1161, /* GL_POST_COLOR_MATRIX_BLUE_BIAS */ - 1157, /* GL_POST_COLOR_MATRIX_ALPHA_BIAS */ - 1595, /* GL_TEXTURE_COLOR_TABLE_SGI */ - 1247, /* GL_PROXY_TEXTURE_COLOR_TABLE_SGI */ - 1597, /* GL_TEXTURE_COMPARE_FAIL_VALUE_ARB */ + 729, /* GL_LUMINANCE4 */ + 735, /* GL_LUMINANCE8 */ + 719, /* GL_LUMINANCE12 */ + 725, /* GL_LUMINANCE16 */ + 730, /* GL_LUMINANCE4_ALPHA4 */ + 733, /* GL_LUMINANCE6_ALPHA2 */ + 736, /* GL_LUMINANCE8_ALPHA8 */ + 722, /* GL_LUMINANCE12_ALPHA4 */ + 720, /* GL_LUMINANCE12_ALPHA12 */ + 726, /* GL_LUMINANCE16_ALPHA16 */ + 642, /* GL_INTENSITY */ + 647, /* GL_INTENSITY4 */ + 649, /* GL_INTENSITY8 */ + 643, /* GL_INTENSITY12 */ + 645, /* GL_INTENSITY16 */ + 1326, /* GL_RGB2_EXT */ + 1327, /* GL_RGB4 */ + 1330, /* GL_RGB5 */ + 1334, /* GL_RGB8 */ + 1318, /* GL_RGB10 */ + 1322, /* GL_RGB12 */ + 1324, /* GL_RGB16 */ + 1341, /* GL_RGBA2 */ + 1343, /* GL_RGBA4 */ + 1331, /* GL_RGB5_A1 */ + 1347, /* GL_RGBA8 */ + 1319, /* GL_RGB10_A2 */ + 1337, /* GL_RGBA12 */ + 1339, /* GL_RGBA16 */ + 1682, /* GL_TEXTURE_RED_SIZE */ + 1654, /* GL_TEXTURE_GREEN_SIZE */ + 1593, /* GL_TEXTURE_BLUE_SIZE */ + 1580, /* GL_TEXTURE_ALPHA_SIZE */ + 1667, /* GL_TEXTURE_LUMINANCE_SIZE */ + 1658, /* GL_TEXTURE_INTENSITY_SIZE */ + 1312, /* GL_REPLACE_EXT */ + 1248, /* GL_PROXY_TEXTURE_1D */ + 1251, /* GL_PROXY_TEXTURE_2D */ + 1687, /* GL_TEXTURE_TOO_LARGE_EXT */ + 1679, /* GL_TEXTURE_PRIORITY */ + 1684, /* GL_TEXTURE_RESIDENT */ + 1583, /* GL_TEXTURE_BINDING_1D */ + 1585, /* GL_TEXTURE_BINDING_2D */ + 1587, /* GL_TEXTURE_BINDING_3D */ + 1079, /* GL_PACK_SKIP_IMAGES */ + 1075, /* GL_PACK_IMAGE_HEIGHT */ + 1716, /* GL_UNPACK_SKIP_IMAGES */ + 1713, /* GL_UNPACK_IMAGE_HEIGHT */ + 1579, /* GL_TEXTURE_3D */ + 1254, /* GL_PROXY_TEXTURE_3D */ + 1641, /* GL_TEXTURE_DEPTH */ + 1690, /* GL_TEXTURE_WRAP_R */ + 844, /* GL_MAX_3D_TEXTURE_SIZE */ + 1748, /* GL_VERTEX_ARRAY */ + 1010, /* GL_NORMAL_ARRAY */ + 144, /* GL_COLOR_ARRAY */ + 627, /* GL_INDEX_ARRAY */ + 1620, /* GL_TEXTURE_COORD_ARRAY */ + 443, /* GL_EDGE_FLAG_ARRAY */ + 1753, /* GL_VERTEX_ARRAY_SIZE */ + 1755, /* GL_VERTEX_ARRAY_TYPE */ + 1754, /* GL_VERTEX_ARRAY_STRIDE */ + 1015, /* GL_NORMAL_ARRAY_TYPE */ + 1014, /* GL_NORMAL_ARRAY_STRIDE */ + 148, /* GL_COLOR_ARRAY_SIZE */ + 150, /* GL_COLOR_ARRAY_TYPE */ + 149, /* GL_COLOR_ARRAY_STRIDE */ + 632, /* GL_INDEX_ARRAY_TYPE */ + 631, /* GL_INDEX_ARRAY_STRIDE */ + 1624, /* GL_TEXTURE_COORD_ARRAY_SIZE */ + 1626, /* GL_TEXTURE_COORD_ARRAY_TYPE */ + 1625, /* GL_TEXTURE_COORD_ARRAY_STRIDE */ + 447, /* GL_EDGE_FLAG_ARRAY_STRIDE */ + 1752, /* GL_VERTEX_ARRAY_POINTER */ + 1013, /* GL_NORMAL_ARRAY_POINTER */ + 147, /* GL_COLOR_ARRAY_POINTER */ + 630, /* GL_INDEX_ARRAY_POINTER */ + 1623, /* GL_TEXTURE_COORD_ARRAY_POINTER */ + 446, /* GL_EDGE_FLAG_ARRAY_POINTER */ + 989, /* GL_MULTISAMPLE */ + 1369, /* GL_SAMPLE_ALPHA_TO_COVERAGE */ + 1371, /* GL_SAMPLE_ALPHA_TO_ONE */ + 1376, /* GL_SAMPLE_COVERAGE */ + 1373, /* GL_SAMPLE_BUFFERS */ + 1364, /* GL_SAMPLES */ + 1380, /* GL_SAMPLE_COVERAGE_VALUE */ + 1378, /* GL_SAMPLE_COVERAGE_INVERT */ + 191, /* GL_COLOR_MATRIX */ + 193, /* GL_COLOR_MATRIX_STACK_DEPTH */ + 852, /* GL_MAX_COLOR_MATRIX_STACK_DEPTH */ + 1180, /* GL_POST_COLOR_MATRIX_RED_SCALE */ + 1176, /* GL_POST_COLOR_MATRIX_GREEN_SCALE */ + 1171, /* GL_POST_COLOR_MATRIX_BLUE_SCALE */ + 1167, /* GL_POST_COLOR_MATRIX_ALPHA_SCALE */ + 1178, /* GL_POST_COLOR_MATRIX_RED_BIAS */ + 1174, /* GL_POST_COLOR_MATRIX_GREEN_BIAS */ + 1169, /* GL_POST_COLOR_MATRIX_BLUE_BIAS */ + 1165, /* GL_POST_COLOR_MATRIX_ALPHA_BIAS */ + 1603, /* GL_TEXTURE_COLOR_TABLE_SGI */ + 1255, /* GL_PROXY_TEXTURE_COLOR_TABLE_SGI */ + 1605, /* GL_TEXTURE_COMPARE_FAIL_VALUE_ARB */ 79, /* GL_BLEND_DST_RGB */ 87, /* GL_BLEND_SRC_RGB */ 78, /* GL_BLEND_DST_ALPHA */ 86, /* GL_BLEND_SRC_ALPHA */ - 191, /* GL_COLOR_TABLE */ - 1182, /* GL_POST_CONVOLUTION_COLOR_TABLE */ - 1165, /* GL_POST_COLOR_MATRIX_COLOR_TABLE */ - 1235, /* GL_PROXY_COLOR_TABLE */ - 1239, /* GL_PROXY_POST_CONVOLUTION_COLOR_TABLE */ - 1238, /* GL_PROXY_POST_COLOR_MATRIX_COLOR_TABLE */ - 215, /* GL_COLOR_TABLE_SCALE */ - 195, /* GL_COLOR_TABLE_BIAS */ - 200, /* GL_COLOR_TABLE_FORMAT */ - 217, /* GL_COLOR_TABLE_WIDTH */ - 212, /* GL_COLOR_TABLE_RED_SIZE */ - 203, /* GL_COLOR_TABLE_GREEN_SIZE */ - 197, /* GL_COLOR_TABLE_BLUE_SIZE */ - 192, /* GL_COLOR_TABLE_ALPHA_SIZE */ - 209, /* GL_COLOR_TABLE_LUMINANCE_SIZE */ - 206, /* GL_COLOR_TABLE_INTENSITY_SIZE */ + 197, /* GL_COLOR_TABLE */ + 1190, /* GL_POST_CONVOLUTION_COLOR_TABLE */ + 1173, /* GL_POST_COLOR_MATRIX_COLOR_TABLE */ + 1243, /* GL_PROXY_COLOR_TABLE */ + 1247, /* GL_PROXY_POST_CONVOLUTION_COLOR_TABLE */ + 1246, /* GL_PROXY_POST_COLOR_MATRIX_COLOR_TABLE */ + 221, /* GL_COLOR_TABLE_SCALE */ + 201, /* GL_COLOR_TABLE_BIAS */ + 206, /* GL_COLOR_TABLE_FORMAT */ + 223, /* GL_COLOR_TABLE_WIDTH */ + 218, /* GL_COLOR_TABLE_RED_SIZE */ + 209, /* GL_COLOR_TABLE_GREEN_SIZE */ + 203, /* GL_COLOR_TABLE_BLUE_SIZE */ + 198, /* GL_COLOR_TABLE_ALPHA_SIZE */ + 215, /* GL_COLOR_TABLE_LUMINANCE_SIZE */ + 212, /* GL_COLOR_TABLE_INTENSITY_SIZE */ 70, /* GL_BGR */ 71, /* GL_BGRA */ - 858, /* GL_MAX_ELEMENTS_VERTICES */ - 857, /* GL_MAX_ELEMENTS_INDICES */ - 1649, /* GL_TEXTURE_INDEX_SIZE_EXT */ - 135, /* GL_CLIP_VOLUME_CLIPPING_HINT_EXT */ - 1129, /* GL_POINT_SIZE_MIN */ - 1125, /* GL_POINT_SIZE_MAX */ - 1119, /* GL_POINT_FADE_THRESHOLD_SIZE */ - 1115, /* GL_POINT_DISTANCE_ATTENUATION */ - 117, /* GL_CLAMP_TO_BORDER */ - 120, /* GL_CLAMP_TO_EDGE */ - 1670, /* GL_TEXTURE_MIN_LOD */ - 1668, /* GL_TEXTURE_MAX_LOD */ - 1574, /* GL_TEXTURE_BASE_LEVEL */ - 1667, /* GL_TEXTURE_MAX_LEVEL */ - 612, /* GL_IGNORE_BORDER_HP */ - 261, /* GL_CONSTANT_BORDER_HP */ - 1305, /* GL_REPLICATE_BORDER_HP */ - 267, /* GL_CONVOLUTION_BORDER_COLOR */ - 1030, /* GL_OCCLUSION_TEST_HP */ - 1031, /* GL_OCCLUSION_TEST_RESULT_HP */ - 683, /* GL_LINEAR_CLIPMAP_LINEAR_SGIX */ - 1589, /* GL_TEXTURE_CLIPMAP_CENTER_SGIX */ - 1591, /* GL_TEXTURE_CLIPMAP_FRAME_SGIX */ - 1593, /* GL_TEXTURE_CLIPMAP_OFFSET_SGIX */ - 1594, /* GL_TEXTURE_CLIPMAP_VIRTUAL_DEPTH_SGIX */ - 1592, /* GL_TEXTURE_CLIPMAP_LOD_OFFSET_SGIX */ - 1590, /* GL_TEXTURE_CLIPMAP_DEPTH_SGIX */ - 840, /* GL_MAX_CLIPMAP_DEPTH_SGIX */ - 841, /* GL_MAX_CLIPMAP_VIRTUAL_DEPTH_SGIX */ - 1192, /* GL_POST_TEXTURE_FILTER_BIAS_SGIX */ - 1194, /* GL_POST_TEXTURE_FILTER_SCALE_SGIX */ - 1191, /* GL_POST_TEXTURE_FILTER_BIAS_RANGE_SGIX */ - 1193, /* GL_POST_TEXTURE_FILTER_SCALE_RANGE_SGIX */ - 1657, /* GL_TEXTURE_LOD_BIAS_S_SGIX */ - 1658, /* GL_TEXTURE_LOD_BIAS_T_SGIX */ - 1656, /* GL_TEXTURE_LOD_BIAS_R_SGIX */ - 558, /* GL_GENERATE_MIPMAP */ - 559, /* GL_GENERATE_MIPMAP_HINT */ - 500, /* GL_FOG_OFFSET_SGIX */ - 501, /* GL_FOG_OFFSET_VALUE_SGIX */ - 1603, /* GL_TEXTURE_COMPARE_SGIX */ - 1602, /* GL_TEXTURE_COMPARE_OPERATOR_SGIX */ - 1653, /* GL_TEXTURE_LEQUAL_R_SGIX */ - 1645, /* GL_TEXTURE_GEQUAL_R_SGIX */ - 340, /* GL_DEPTH_COMPONENT16 */ - 343, /* GL_DEPTH_COMPONENT24 */ - 346, /* GL_DEPTH_COMPONENT32 */ - 289, /* GL_CULL_VERTEX_EXT */ - 291, /* GL_CULL_VERTEX_OBJECT_POSITION_EXT */ - 290, /* GL_CULL_VERTEX_EYE_POSITION_EXT */ - 1801, /* GL_WRAP_BORDER_SUN */ - 1596, /* GL_TEXTURE_COLOR_WRITEMASK_SGIS */ - 676, /* GL_LIGHT_MODEL_COLOR_CONTROL */ - 1400, /* GL_SINGLE_COLOR */ - 1388, /* GL_SEPARATE_SPECULAR_COLOR */ - 1397, /* GL_SHARED_TEXTURE_PALETTE_EXT */ - 511, /* GL_FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING */ - 512, /* GL_FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE */ - 519, /* GL_FRAMEBUFFER_ATTACHMENT_RED_SIZE */ - 514, /* GL_FRAMEBUFFER_ATTACHMENT_GREEN_SIZE */ - 510, /* GL_FRAMEBUFFER_ATTACHMENT_BLUE_SIZE */ - 509, /* GL_FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE */ - 513, /* GL_FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE */ - 520, /* GL_FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE */ - 531, /* GL_FRAMEBUFFER_DEFAULT */ - 544, /* GL_FRAMEBUFFER_UNDEFINED */ - 353, /* GL_DEPTH_STENCIL_ATTACHMENT */ - 618, /* GL_INDEX */ - 1713, /* GL_UNSIGNED_BYTE_2_3_3_REV */ - 1728, /* GL_UNSIGNED_SHORT_5_6_5 */ - 1729, /* GL_UNSIGNED_SHORT_5_6_5_REV */ - 1726, /* GL_UNSIGNED_SHORT_4_4_4_4_REV */ - 1724, /* GL_UNSIGNED_SHORT_1_5_5_5_REV */ - 1721, /* GL_UNSIGNED_INT_8_8_8_8_REV */ - 1719, /* GL_UNSIGNED_INT_2_10_10_10_REV */ - 1665, /* GL_TEXTURE_MAX_CLAMP_S_SGIX */ - 1666, /* GL_TEXTURE_MAX_CLAMP_T_SGIX */ - 1664, /* GL_TEXTURE_MAX_CLAMP_R_SGIX */ - 932, /* GL_MIRRORED_REPEAT */ - 1344, /* GL_RGB_S3TC */ - 1321, /* GL_RGB4_S3TC */ - 1343, /* GL_RGBA_S3TC */ - 1338, /* GL_RGBA4_S3TC */ - 1341, /* GL_RGBA_DXT5_S3TC */ - 1336, /* GL_RGBA4_DXT5_S3TC */ - 254, /* GL_COMPRESSED_RGB_S3TC_DXT1_EXT */ - 249, /* GL_COMPRESSED_RGBA_S3TC_DXT1_EXT */ - 250, /* GL_COMPRESSED_RGBA_S3TC_DXT3_EXT */ - 251, /* GL_COMPRESSED_RGBA_S3TC_DXT5_EXT */ - 993, /* GL_NEAREST_CLIPMAP_NEAREST_SGIX */ - 992, /* GL_NEAREST_CLIPMAP_LINEAR_SGIX */ - 684, /* GL_LINEAR_CLIPMAP_NEAREST_SGIX */ - 487, /* GL_FOG_COORDINATE_SOURCE */ - 479, /* GL_FOG_COORD */ - 503, /* GL_FRAGMENT_DEPTH */ - 295, /* GL_CURRENT_FOG_COORD */ - 486, /* GL_FOG_COORDINATE_ARRAY_TYPE */ - 485, /* GL_FOG_COORDINATE_ARRAY_STRIDE */ - 484, /* GL_FOG_COORDINATE_ARRAY_POINTER */ - 481, /* GL_FOG_COORDINATE_ARRAY */ - 189, /* GL_COLOR_SUM */ - 314, /* GL_CURRENT_SECONDARY_COLOR */ - 1381, /* GL_SECONDARY_COLOR_ARRAY_SIZE */ - 1383, /* GL_SECONDARY_COLOR_ARRAY_TYPE */ - 1382, /* GL_SECONDARY_COLOR_ARRAY_STRIDE */ - 1380, /* GL_SECONDARY_COLOR_ARRAY_POINTER */ - 1377, /* GL_SECONDARY_COLOR_ARRAY */ - 568, /* GL_GL_CURRENT_RASTER_SECONDARY_COLOR */ + 866, /* GL_MAX_ELEMENTS_VERTICES */ + 865, /* GL_MAX_ELEMENTS_INDICES */ + 1657, /* GL_TEXTURE_INDEX_SIZE_EXT */ + 141, /* GL_CLIP_VOLUME_CLIPPING_HINT_EXT */ + 1137, /* GL_POINT_SIZE_MIN */ + 1133, /* GL_POINT_SIZE_MAX */ + 1127, /* GL_POINT_FADE_THRESHOLD_SIZE */ + 1123, /* GL_POINT_DISTANCE_ATTENUATION */ + 123, /* GL_CLAMP_TO_BORDER */ + 126, /* GL_CLAMP_TO_EDGE */ + 1678, /* GL_TEXTURE_MIN_LOD */ + 1676, /* GL_TEXTURE_MAX_LOD */ + 1582, /* GL_TEXTURE_BASE_LEVEL */ + 1675, /* GL_TEXTURE_MAX_LEVEL */ + 620, /* GL_IGNORE_BORDER_HP */ + 267, /* GL_CONSTANT_BORDER_HP */ + 1313, /* GL_REPLICATE_BORDER_HP */ + 273, /* GL_CONVOLUTION_BORDER_COLOR */ + 1038, /* GL_OCCLUSION_TEST_HP */ + 1039, /* GL_OCCLUSION_TEST_RESULT_HP */ + 691, /* GL_LINEAR_CLIPMAP_LINEAR_SGIX */ + 1597, /* GL_TEXTURE_CLIPMAP_CENTER_SGIX */ + 1599, /* GL_TEXTURE_CLIPMAP_FRAME_SGIX */ + 1601, /* GL_TEXTURE_CLIPMAP_OFFSET_SGIX */ + 1602, /* GL_TEXTURE_CLIPMAP_VIRTUAL_DEPTH_SGIX */ + 1600, /* GL_TEXTURE_CLIPMAP_LOD_OFFSET_SGIX */ + 1598, /* GL_TEXTURE_CLIPMAP_DEPTH_SGIX */ + 848, /* GL_MAX_CLIPMAP_DEPTH_SGIX */ + 849, /* GL_MAX_CLIPMAP_VIRTUAL_DEPTH_SGIX */ + 1200, /* GL_POST_TEXTURE_FILTER_BIAS_SGIX */ + 1202, /* GL_POST_TEXTURE_FILTER_SCALE_SGIX */ + 1199, /* GL_POST_TEXTURE_FILTER_BIAS_RANGE_SGIX */ + 1201, /* GL_POST_TEXTURE_FILTER_SCALE_RANGE_SGIX */ + 1665, /* GL_TEXTURE_LOD_BIAS_S_SGIX */ + 1666, /* GL_TEXTURE_LOD_BIAS_T_SGIX */ + 1664, /* GL_TEXTURE_LOD_BIAS_R_SGIX */ + 566, /* GL_GENERATE_MIPMAP */ + 567, /* GL_GENERATE_MIPMAP_HINT */ + 508, /* GL_FOG_OFFSET_SGIX */ + 509, /* GL_FOG_OFFSET_VALUE_SGIX */ + 1611, /* GL_TEXTURE_COMPARE_SGIX */ + 1610, /* GL_TEXTURE_COMPARE_OPERATOR_SGIX */ + 1661, /* GL_TEXTURE_LEQUAL_R_SGIX */ + 1653, /* GL_TEXTURE_GEQUAL_R_SGIX */ + 346, /* GL_DEPTH_COMPONENT16 */ + 349, /* GL_DEPTH_COMPONENT24 */ + 352, /* GL_DEPTH_COMPONENT32 */ + 295, /* GL_CULL_VERTEX_EXT */ + 297, /* GL_CULL_VERTEX_OBJECT_POSITION_EXT */ + 296, /* GL_CULL_VERTEX_EYE_POSITION_EXT */ + 1809, /* GL_WRAP_BORDER_SUN */ + 1604, /* GL_TEXTURE_COLOR_WRITEMASK_SGIS */ + 684, /* GL_LIGHT_MODEL_COLOR_CONTROL */ + 1408, /* GL_SINGLE_COLOR */ + 1396, /* GL_SEPARATE_SPECULAR_COLOR */ + 1405, /* GL_SHARED_TEXTURE_PALETTE_EXT */ + 519, /* GL_FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING */ + 520, /* GL_FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE */ + 527, /* GL_FRAMEBUFFER_ATTACHMENT_RED_SIZE */ + 522, /* GL_FRAMEBUFFER_ATTACHMENT_GREEN_SIZE */ + 518, /* GL_FRAMEBUFFER_ATTACHMENT_BLUE_SIZE */ + 517, /* GL_FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE */ + 521, /* GL_FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE */ + 528, /* GL_FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE */ + 539, /* GL_FRAMEBUFFER_DEFAULT */ + 552, /* GL_FRAMEBUFFER_UNDEFINED */ + 359, /* GL_DEPTH_STENCIL_ATTACHMENT */ + 626, /* GL_INDEX */ + 1721, /* GL_UNSIGNED_BYTE_2_3_3_REV */ + 1736, /* GL_UNSIGNED_SHORT_5_6_5 */ + 1737, /* GL_UNSIGNED_SHORT_5_6_5_REV */ + 1734, /* GL_UNSIGNED_SHORT_4_4_4_4_REV */ + 1732, /* GL_UNSIGNED_SHORT_1_5_5_5_REV */ + 1729, /* GL_UNSIGNED_INT_8_8_8_8_REV */ + 1727, /* GL_UNSIGNED_INT_2_10_10_10_REV */ + 1673, /* GL_TEXTURE_MAX_CLAMP_S_SGIX */ + 1674, /* GL_TEXTURE_MAX_CLAMP_T_SGIX */ + 1672, /* GL_TEXTURE_MAX_CLAMP_R_SGIX */ + 940, /* GL_MIRRORED_REPEAT */ + 1352, /* GL_RGB_S3TC */ + 1329, /* GL_RGB4_S3TC */ + 1351, /* GL_RGBA_S3TC */ + 1346, /* GL_RGBA4_S3TC */ + 1349, /* GL_RGBA_DXT5_S3TC */ + 1344, /* GL_RGBA4_DXT5_S3TC */ + 260, /* GL_COMPRESSED_RGB_S3TC_DXT1_EXT */ + 255, /* GL_COMPRESSED_RGBA_S3TC_DXT1_EXT */ + 256, /* GL_COMPRESSED_RGBA_S3TC_DXT3_EXT */ + 257, /* GL_COMPRESSED_RGBA_S3TC_DXT5_EXT */ + 1001, /* GL_NEAREST_CLIPMAP_NEAREST_SGIX */ + 1000, /* GL_NEAREST_CLIPMAP_LINEAR_SGIX */ + 692, /* GL_LINEAR_CLIPMAP_NEAREST_SGIX */ + 495, /* GL_FOG_COORDINATE_SOURCE */ + 487, /* GL_FOG_COORD */ + 511, /* GL_FRAGMENT_DEPTH */ + 301, /* GL_CURRENT_FOG_COORD */ + 494, /* GL_FOG_COORDINATE_ARRAY_TYPE */ + 493, /* GL_FOG_COORDINATE_ARRAY_STRIDE */ + 492, /* GL_FOG_COORDINATE_ARRAY_POINTER */ + 489, /* GL_FOG_COORDINATE_ARRAY */ + 195, /* GL_COLOR_SUM */ + 320, /* GL_CURRENT_SECONDARY_COLOR */ + 1389, /* GL_SECONDARY_COLOR_ARRAY_SIZE */ + 1391, /* GL_SECONDARY_COLOR_ARRAY_TYPE */ + 1390, /* GL_SECONDARY_COLOR_ARRAY_STRIDE */ + 1388, /* GL_SECONDARY_COLOR_ARRAY_POINTER */ + 1385, /* GL_SECONDARY_COLOR_ARRAY */ + 576, /* GL_GL_CURRENT_RASTER_SECONDARY_COLOR */ 28, /* GL_ALIASED_POINT_SIZE_RANGE */ 27, /* GL_ALIASED_LINE_WIDTH_RANGE */ - 1503, /* GL_TEXTURE0 */ - 1505, /* GL_TEXTURE1 */ - 1527, /* GL_TEXTURE2 */ - 1549, /* GL_TEXTURE3 */ - 1555, /* GL_TEXTURE4 */ - 1557, /* GL_TEXTURE5 */ - 1559, /* GL_TEXTURE6 */ - 1561, /* GL_TEXTURE7 */ - 1563, /* GL_TEXTURE8 */ - 1565, /* GL_TEXTURE9 */ - 1506, /* GL_TEXTURE10 */ - 1508, /* GL_TEXTURE11 */ - 1510, /* GL_TEXTURE12 */ - 1512, /* GL_TEXTURE13 */ - 1514, /* GL_TEXTURE14 */ - 1516, /* GL_TEXTURE15 */ - 1518, /* GL_TEXTURE16 */ - 1520, /* GL_TEXTURE17 */ - 1522, /* GL_TEXTURE18 */ - 1524, /* GL_TEXTURE19 */ - 1528, /* GL_TEXTURE20 */ - 1530, /* GL_TEXTURE21 */ - 1532, /* GL_TEXTURE22 */ - 1534, /* GL_TEXTURE23 */ - 1536, /* GL_TEXTURE24 */ - 1538, /* GL_TEXTURE25 */ - 1540, /* GL_TEXTURE26 */ - 1542, /* GL_TEXTURE27 */ - 1544, /* GL_TEXTURE28 */ - 1546, /* GL_TEXTURE29 */ - 1550, /* GL_TEXTURE30 */ - 1552, /* GL_TEXTURE31 */ + 1511, /* GL_TEXTURE0 */ + 1513, /* GL_TEXTURE1 */ + 1535, /* GL_TEXTURE2 */ + 1557, /* GL_TEXTURE3 */ + 1563, /* GL_TEXTURE4 */ + 1565, /* GL_TEXTURE5 */ + 1567, /* GL_TEXTURE6 */ + 1569, /* GL_TEXTURE7 */ + 1571, /* GL_TEXTURE8 */ + 1573, /* GL_TEXTURE9 */ + 1514, /* GL_TEXTURE10 */ + 1516, /* GL_TEXTURE11 */ + 1518, /* GL_TEXTURE12 */ + 1520, /* GL_TEXTURE13 */ + 1522, /* GL_TEXTURE14 */ + 1524, /* GL_TEXTURE15 */ + 1526, /* GL_TEXTURE16 */ + 1528, /* GL_TEXTURE17 */ + 1530, /* GL_TEXTURE18 */ + 1532, /* GL_TEXTURE19 */ + 1536, /* GL_TEXTURE20 */ + 1538, /* GL_TEXTURE21 */ + 1540, /* GL_TEXTURE22 */ + 1542, /* GL_TEXTURE23 */ + 1544, /* GL_TEXTURE24 */ + 1546, /* GL_TEXTURE25 */ + 1548, /* GL_TEXTURE26 */ + 1550, /* GL_TEXTURE27 */ + 1552, /* GL_TEXTURE28 */ + 1554, /* GL_TEXTURE29 */ + 1558, /* GL_TEXTURE30 */ + 1560, /* GL_TEXTURE31 */ 18, /* GL_ACTIVE_TEXTURE */ - 123, /* GL_CLIENT_ACTIVE_TEXTURE */ - 910, /* GL_MAX_TEXTURE_UNITS */ - 1692, /* GL_TRANSPOSE_MODELVIEW_MATRIX */ - 1695, /* GL_TRANSPOSE_PROJECTION_MATRIX */ - 1697, /* GL_TRANSPOSE_TEXTURE_MATRIX */ - 1689, /* GL_TRANSPOSE_COLOR_MATRIX */ - 1491, /* GL_SUBTRACT */ - 898, /* GL_MAX_RENDERBUFFER_SIZE_EXT */ - 237, /* GL_COMPRESSED_ALPHA */ - 241, /* GL_COMPRESSED_LUMINANCE */ - 242, /* GL_COMPRESSED_LUMINANCE_ALPHA */ - 239, /* GL_COMPRESSED_INTENSITY */ - 245, /* GL_COMPRESSED_RGB */ - 246, /* GL_COMPRESSED_RGBA */ - 1610, /* GL_TEXTURE_COMPRESSION_HINT */ - 1672, /* GL_TEXTURE_RECTANGLE_ARB */ - 1582, /* GL_TEXTURE_BINDING_RECTANGLE_ARB */ - 1250, /* GL_PROXY_TEXTURE_RECTANGLE_ARB */ - 896, /* GL_MAX_RECTANGLE_TEXTURE_SIZE_ARB */ - 352, /* GL_DEPTH_STENCIL */ - 1717, /* GL_UNSIGNED_INT_24_8 */ - 906, /* GL_MAX_TEXTURE_LOD_BIAS */ - 1663, /* GL_TEXTURE_MAX_ANISOTROPY_EXT */ - 907, /* GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT */ - 1639, /* GL_TEXTURE_FILTER_CONTROL */ - 1654, /* GL_TEXTURE_LOD_BIAS */ - 222, /* GL_COMBINE4 */ - 900, /* GL_MAX_SHININESS_NV */ - 901, /* GL_MAX_SPOT_EXPONENT_NV */ - 616, /* GL_INCR_WRAP */ - 325, /* GL_DECR_WRAP */ - 952, /* GL_MODELVIEW1_ARB */ - 1008, /* GL_NORMAL_MAP */ - 1280, /* GL_REFLECTION_MAP */ - 1619, /* GL_TEXTURE_CUBE_MAP */ - 1580, /* GL_TEXTURE_BINDING_CUBE_MAP */ - 1627, /* GL_TEXTURE_CUBE_MAP_POSITIVE_X */ - 1621, /* GL_TEXTURE_CUBE_MAP_NEGATIVE_X */ - 1629, /* GL_TEXTURE_CUBE_MAP_POSITIVE_Y */ - 1623, /* GL_TEXTURE_CUBE_MAP_NEGATIVE_Y */ - 1631, /* GL_TEXTURE_CUBE_MAP_POSITIVE_Z */ - 1625, /* GL_TEXTURE_CUBE_MAP_NEGATIVE_Z */ - 1248, /* GL_PROXY_TEXTURE_CUBE_MAP */ - 852, /* GL_MAX_CUBE_MAP_TEXTURE_SIZE */ - 987, /* GL_MULTISAMPLE_FILTER_HINT_NV */ - 495, /* GL_FOG_DISTANCE_MODE_NV */ - 454, /* GL_EYE_RADIAL_NV */ - 453, /* GL_EYE_PLANE_ABSOLUTE_NV */ - 221, /* GL_COMBINE */ - 228, /* GL_COMBINE_RGB */ - 223, /* GL_COMBINE_ALPHA */ - 1345, /* GL_RGB_SCALE */ + 129, /* GL_CLIENT_ACTIVE_TEXTURE */ + 918, /* GL_MAX_TEXTURE_UNITS */ + 1700, /* GL_TRANSPOSE_MODELVIEW_MATRIX */ + 1703, /* GL_TRANSPOSE_PROJECTION_MATRIX */ + 1705, /* GL_TRANSPOSE_TEXTURE_MATRIX */ + 1697, /* GL_TRANSPOSE_COLOR_MATRIX */ + 1499, /* GL_SUBTRACT */ + 906, /* GL_MAX_RENDERBUFFER_SIZE_EXT */ + 243, /* GL_COMPRESSED_ALPHA */ + 247, /* GL_COMPRESSED_LUMINANCE */ + 248, /* GL_COMPRESSED_LUMINANCE_ALPHA */ + 245, /* GL_COMPRESSED_INTENSITY */ + 251, /* GL_COMPRESSED_RGB */ + 252, /* GL_COMPRESSED_RGBA */ + 1618, /* GL_TEXTURE_COMPRESSION_HINT */ + 1680, /* GL_TEXTURE_RECTANGLE_ARB */ + 1590, /* GL_TEXTURE_BINDING_RECTANGLE_ARB */ + 1258, /* GL_PROXY_TEXTURE_RECTANGLE_ARB */ + 904, /* GL_MAX_RECTANGLE_TEXTURE_SIZE_ARB */ + 358, /* GL_DEPTH_STENCIL */ + 1725, /* GL_UNSIGNED_INT_24_8 */ + 914, /* GL_MAX_TEXTURE_LOD_BIAS */ + 1671, /* GL_TEXTURE_MAX_ANISOTROPY_EXT */ + 915, /* GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT */ + 1647, /* GL_TEXTURE_FILTER_CONTROL */ + 1662, /* GL_TEXTURE_LOD_BIAS */ + 228, /* GL_COMBINE4 */ + 908, /* GL_MAX_SHININESS_NV */ + 909, /* GL_MAX_SPOT_EXPONENT_NV */ + 624, /* GL_INCR_WRAP */ + 331, /* GL_DECR_WRAP */ + 960, /* GL_MODELVIEW1_ARB */ + 1016, /* GL_NORMAL_MAP */ + 1288, /* GL_REFLECTION_MAP */ + 1627, /* GL_TEXTURE_CUBE_MAP */ + 1588, /* GL_TEXTURE_BINDING_CUBE_MAP */ + 1635, /* GL_TEXTURE_CUBE_MAP_POSITIVE_X */ + 1629, /* GL_TEXTURE_CUBE_MAP_NEGATIVE_X */ + 1637, /* GL_TEXTURE_CUBE_MAP_POSITIVE_Y */ + 1631, /* GL_TEXTURE_CUBE_MAP_NEGATIVE_Y */ + 1639, /* GL_TEXTURE_CUBE_MAP_POSITIVE_Z */ + 1633, /* GL_TEXTURE_CUBE_MAP_NEGATIVE_Z */ + 1256, /* GL_PROXY_TEXTURE_CUBE_MAP */ + 860, /* GL_MAX_CUBE_MAP_TEXTURE_SIZE */ + 995, /* GL_MULTISAMPLE_FILTER_HINT_NV */ + 503, /* GL_FOG_DISTANCE_MODE_NV */ + 462, /* GL_EYE_RADIAL_NV */ + 461, /* GL_EYE_PLANE_ABSOLUTE_NV */ + 227, /* GL_COMBINE */ + 234, /* GL_COMBINE_RGB */ + 229, /* GL_COMBINE_ALPHA */ + 1353, /* GL_RGB_SCALE */ 24, /* GL_ADD_SIGNED */ - 644, /* GL_INTERPOLATE */ - 256, /* GL_CONSTANT */ - 1198, /* GL_PRIMARY_COLOR */ - 1195, /* GL_PREVIOUS */ - 1411, /* GL_SOURCE0_RGB */ - 1417, /* GL_SOURCE1_RGB */ - 1423, /* GL_SOURCE2_RGB */ - 1427, /* GL_SOURCE3_RGB_NV */ - 1408, /* GL_SOURCE0_ALPHA */ - 1414, /* GL_SOURCE1_ALPHA */ - 1420, /* GL_SOURCE2_ALPHA */ - 1426, /* GL_SOURCE3_ALPHA_NV */ - 1044, /* GL_OPERAND0_RGB */ - 1050, /* GL_OPERAND1_RGB */ - 1056, /* GL_OPERAND2_RGB */ - 1060, /* GL_OPERAND3_RGB_NV */ - 1041, /* GL_OPERAND0_ALPHA */ - 1047, /* GL_OPERAND1_ALPHA */ - 1053, /* GL_OPERAND2_ALPHA */ - 1059, /* GL_OPERAND3_ALPHA_NV */ - 1741, /* GL_VERTEX_ARRAY_BINDING_APPLE */ - 1805, /* GL_YCBCR_422_APPLE */ - 1730, /* GL_UNSIGNED_SHORT_8_8_APPLE */ - 1732, /* GL_UNSIGNED_SHORT_8_8_REV_APPLE */ - 1402, /* GL_SLICE_ACCUM_SUN */ - 1255, /* GL_QUAD_MESH_SUN */ - 1701, /* GL_TRIANGLE_MESH_SUN */ - 1779, /* GL_VERTEX_PROGRAM_ARB */ - 1790, /* GL_VERTEX_STATE_PROGRAM_NV */ - 1766, /* GL_VERTEX_ATTRIB_ARRAY_ENABLED */ - 1772, /* GL_VERTEX_ATTRIB_ARRAY_SIZE */ - 1774, /* GL_VERTEX_ATTRIB_ARRAY_STRIDE */ - 1776, /* GL_VERTEX_ATTRIB_ARRAY_TYPE */ - 316, /* GL_CURRENT_VERTEX_ATTRIB */ - 1211, /* GL_PROGRAM_LENGTH_ARB */ - 1225, /* GL_PROGRAM_STRING_ARB */ - 974, /* GL_MODELVIEW_PROJECTION_NV */ - 611, /* GL_IDENTITY_NV */ - 658, /* GL_INVERSE_NV */ - 1694, /* GL_TRANSPOSE_NV */ - 659, /* GL_INVERSE_TRANSPOSE_NV */ - 882, /* GL_MAX_PROGRAM_MATRIX_STACK_DEPTH_ARB */ - 881, /* GL_MAX_PROGRAM_MATRICES_ARB */ - 789, /* GL_MATRIX0_NV */ - 801, /* GL_MATRIX1_NV */ - 813, /* GL_MATRIX2_NV */ - 817, /* GL_MATRIX3_NV */ - 819, /* GL_MATRIX4_NV */ - 821, /* GL_MATRIX5_NV */ - 823, /* GL_MATRIX6_NV */ - 825, /* GL_MATRIX7_NV */ - 301, /* GL_CURRENT_MATRIX_STACK_DEPTH_ARB */ - 298, /* GL_CURRENT_MATRIX_ARB */ - 1782, /* GL_VERTEX_PROGRAM_POINT_SIZE */ - 1785, /* GL_VERTEX_PROGRAM_TWO_SIDE */ - 1223, /* GL_PROGRAM_PARAMETER_NV */ - 1770, /* GL_VERTEX_ATTRIB_ARRAY_POINTER */ - 1227, /* GL_PROGRAM_TARGET_NV */ - 1224, /* GL_PROGRAM_RESIDENT_NV */ - 1686, /* GL_TRACK_MATRIX_NV */ - 1687, /* GL_TRACK_MATRIX_TRANSFORM_NV */ - 1780, /* GL_VERTEX_PROGRAM_BINDING_NV */ - 1205, /* GL_PROGRAM_ERROR_POSITION_ARB */ - 337, /* GL_DEPTH_CLAMP_NV */ - 1748, /* GL_VERTEX_ATTRIB_ARRAY0_NV */ - 1755, /* GL_VERTEX_ATTRIB_ARRAY1_NV */ - 1756, /* GL_VERTEX_ATTRIB_ARRAY2_NV */ - 1757, /* GL_VERTEX_ATTRIB_ARRAY3_NV */ - 1758, /* GL_VERTEX_ATTRIB_ARRAY4_NV */ - 1759, /* GL_VERTEX_ATTRIB_ARRAY5_NV */ - 1760, /* GL_VERTEX_ATTRIB_ARRAY6_NV */ - 1761, /* GL_VERTEX_ATTRIB_ARRAY7_NV */ - 1762, /* GL_VERTEX_ATTRIB_ARRAY8_NV */ - 1763, /* GL_VERTEX_ATTRIB_ARRAY9_NV */ - 1749, /* GL_VERTEX_ATTRIB_ARRAY10_NV */ - 1750, /* GL_VERTEX_ATTRIB_ARRAY11_NV */ - 1751, /* GL_VERTEX_ATTRIB_ARRAY12_NV */ - 1752, /* GL_VERTEX_ATTRIB_ARRAY13_NV */ - 1753, /* GL_VERTEX_ATTRIB_ARRAY14_NV */ - 1754, /* GL_VERTEX_ATTRIB_ARRAY15_NV */ - 743, /* GL_MAP1_VERTEX_ATTRIB0_4_NV */ - 750, /* GL_MAP1_VERTEX_ATTRIB1_4_NV */ - 751, /* GL_MAP1_VERTEX_ATTRIB2_4_NV */ - 752, /* GL_MAP1_VERTEX_ATTRIB3_4_NV */ - 753, /* GL_MAP1_VERTEX_ATTRIB4_4_NV */ - 754, /* GL_MAP1_VERTEX_ATTRIB5_4_NV */ - 755, /* GL_MAP1_VERTEX_ATTRIB6_4_NV */ - 756, /* GL_MAP1_VERTEX_ATTRIB7_4_NV */ - 757, /* GL_MAP1_VERTEX_ATTRIB8_4_NV */ - 758, /* GL_MAP1_VERTEX_ATTRIB9_4_NV */ - 744, /* GL_MAP1_VERTEX_ATTRIB10_4_NV */ - 745, /* GL_MAP1_VERTEX_ATTRIB11_4_NV */ - 746, /* GL_MAP1_VERTEX_ATTRIB12_4_NV */ - 747, /* GL_MAP1_VERTEX_ATTRIB13_4_NV */ - 748, /* GL_MAP1_VERTEX_ATTRIB14_4_NV */ - 749, /* GL_MAP1_VERTEX_ATTRIB15_4_NV */ - 770, /* GL_MAP2_VERTEX_ATTRIB0_4_NV */ - 777, /* GL_MAP2_VERTEX_ATTRIB1_4_NV */ - 778, /* GL_MAP2_VERTEX_ATTRIB2_4_NV */ - 779, /* GL_MAP2_VERTEX_ATTRIB3_4_NV */ - 780, /* GL_MAP2_VERTEX_ATTRIB4_4_NV */ - 781, /* GL_MAP2_VERTEX_ATTRIB5_4_NV */ - 782, /* GL_MAP2_VERTEX_ATTRIB6_4_NV */ - 1204, /* GL_PROGRAM_BINDING_ARB */ - 784, /* GL_MAP2_VERTEX_ATTRIB8_4_NV */ - 785, /* GL_MAP2_VERTEX_ATTRIB9_4_NV */ - 771, /* GL_MAP2_VERTEX_ATTRIB10_4_NV */ - 772, /* GL_MAP2_VERTEX_ATTRIB11_4_NV */ - 773, /* GL_MAP2_VERTEX_ATTRIB12_4_NV */ - 774, /* GL_MAP2_VERTEX_ATTRIB13_4_NV */ - 775, /* GL_MAP2_VERTEX_ATTRIB14_4_NV */ - 776, /* GL_MAP2_VERTEX_ATTRIB15_4_NV */ - 1608, /* GL_TEXTURE_COMPRESSED_IMAGE_SIZE */ - 1605, /* GL_TEXTURE_COMPRESSED */ - 1013, /* GL_NUM_COMPRESSED_TEXTURE_FORMATS */ - 255, /* GL_COMPRESSED_TEXTURE_FORMATS */ - 922, /* GL_MAX_VERTEX_UNITS_ARB */ + 652, /* GL_INTERPOLATE */ + 262, /* GL_CONSTANT */ + 1206, /* GL_PRIMARY_COLOR */ + 1203, /* GL_PREVIOUS */ + 1419, /* GL_SOURCE0_RGB */ + 1425, /* GL_SOURCE1_RGB */ + 1431, /* GL_SOURCE2_RGB */ + 1435, /* GL_SOURCE3_RGB_NV */ + 1416, /* GL_SOURCE0_ALPHA */ + 1422, /* GL_SOURCE1_ALPHA */ + 1428, /* GL_SOURCE2_ALPHA */ + 1434, /* GL_SOURCE3_ALPHA_NV */ + 1052, /* GL_OPERAND0_RGB */ + 1058, /* GL_OPERAND1_RGB */ + 1064, /* GL_OPERAND2_RGB */ + 1068, /* GL_OPERAND3_RGB_NV */ + 1049, /* GL_OPERAND0_ALPHA */ + 1055, /* GL_OPERAND1_ALPHA */ + 1061, /* GL_OPERAND2_ALPHA */ + 1067, /* GL_OPERAND3_ALPHA_NV */ + 1749, /* GL_VERTEX_ARRAY_BINDING_APPLE */ + 1813, /* GL_YCBCR_422_APPLE */ + 1738, /* GL_UNSIGNED_SHORT_8_8_APPLE */ + 1740, /* GL_UNSIGNED_SHORT_8_8_REV_APPLE */ + 1410, /* GL_SLICE_ACCUM_SUN */ + 1263, /* GL_QUAD_MESH_SUN */ + 1709, /* GL_TRIANGLE_MESH_SUN */ + 1787, /* GL_VERTEX_PROGRAM_ARB */ + 1798, /* GL_VERTEX_STATE_PROGRAM_NV */ + 1774, /* GL_VERTEX_ATTRIB_ARRAY_ENABLED */ + 1780, /* GL_VERTEX_ATTRIB_ARRAY_SIZE */ + 1782, /* GL_VERTEX_ATTRIB_ARRAY_STRIDE */ + 1784, /* GL_VERTEX_ATTRIB_ARRAY_TYPE */ + 322, /* GL_CURRENT_VERTEX_ATTRIB */ + 1219, /* GL_PROGRAM_LENGTH_ARB */ + 1233, /* GL_PROGRAM_STRING_ARB */ + 982, /* GL_MODELVIEW_PROJECTION_NV */ + 619, /* GL_IDENTITY_NV */ + 666, /* GL_INVERSE_NV */ + 1702, /* GL_TRANSPOSE_NV */ + 667, /* GL_INVERSE_TRANSPOSE_NV */ + 890, /* GL_MAX_PROGRAM_MATRIX_STACK_DEPTH_ARB */ + 889, /* GL_MAX_PROGRAM_MATRICES_ARB */ + 797, /* GL_MATRIX0_NV */ + 809, /* GL_MATRIX1_NV */ + 821, /* GL_MATRIX2_NV */ + 825, /* GL_MATRIX3_NV */ + 827, /* GL_MATRIX4_NV */ + 829, /* GL_MATRIX5_NV */ + 831, /* GL_MATRIX6_NV */ + 833, /* GL_MATRIX7_NV */ + 307, /* GL_CURRENT_MATRIX_STACK_DEPTH_ARB */ + 304, /* GL_CURRENT_MATRIX_ARB */ + 1790, /* GL_VERTEX_PROGRAM_POINT_SIZE */ + 1793, /* GL_VERTEX_PROGRAM_TWO_SIDE */ + 1231, /* GL_PROGRAM_PARAMETER_NV */ + 1778, /* GL_VERTEX_ATTRIB_ARRAY_POINTER */ + 1235, /* GL_PROGRAM_TARGET_NV */ + 1232, /* GL_PROGRAM_RESIDENT_NV */ + 1694, /* GL_TRACK_MATRIX_NV */ + 1695, /* GL_TRACK_MATRIX_TRANSFORM_NV */ + 1788, /* GL_VERTEX_PROGRAM_BINDING_NV */ + 1213, /* GL_PROGRAM_ERROR_POSITION_ARB */ + 343, /* GL_DEPTH_CLAMP_NV */ + 1756, /* GL_VERTEX_ATTRIB_ARRAY0_NV */ + 1763, /* GL_VERTEX_ATTRIB_ARRAY1_NV */ + 1764, /* GL_VERTEX_ATTRIB_ARRAY2_NV */ + 1765, /* GL_VERTEX_ATTRIB_ARRAY3_NV */ + 1766, /* GL_VERTEX_ATTRIB_ARRAY4_NV */ + 1767, /* GL_VERTEX_ATTRIB_ARRAY5_NV */ + 1768, /* GL_VERTEX_ATTRIB_ARRAY6_NV */ + 1769, /* GL_VERTEX_ATTRIB_ARRAY7_NV */ + 1770, /* GL_VERTEX_ATTRIB_ARRAY8_NV */ + 1771, /* GL_VERTEX_ATTRIB_ARRAY9_NV */ + 1757, /* GL_VERTEX_ATTRIB_ARRAY10_NV */ + 1758, /* GL_VERTEX_ATTRIB_ARRAY11_NV */ + 1759, /* GL_VERTEX_ATTRIB_ARRAY12_NV */ + 1760, /* GL_VERTEX_ATTRIB_ARRAY13_NV */ + 1761, /* GL_VERTEX_ATTRIB_ARRAY14_NV */ + 1762, /* GL_VERTEX_ATTRIB_ARRAY15_NV */ + 751, /* GL_MAP1_VERTEX_ATTRIB0_4_NV */ + 758, /* GL_MAP1_VERTEX_ATTRIB1_4_NV */ + 759, /* GL_MAP1_VERTEX_ATTRIB2_4_NV */ + 760, /* GL_MAP1_VERTEX_ATTRIB3_4_NV */ + 761, /* GL_MAP1_VERTEX_ATTRIB4_4_NV */ + 762, /* GL_MAP1_VERTEX_ATTRIB5_4_NV */ + 763, /* GL_MAP1_VERTEX_ATTRIB6_4_NV */ + 764, /* GL_MAP1_VERTEX_ATTRIB7_4_NV */ + 765, /* GL_MAP1_VERTEX_ATTRIB8_4_NV */ + 766, /* GL_MAP1_VERTEX_ATTRIB9_4_NV */ + 752, /* GL_MAP1_VERTEX_ATTRIB10_4_NV */ + 753, /* GL_MAP1_VERTEX_ATTRIB11_4_NV */ + 754, /* GL_MAP1_VERTEX_ATTRIB12_4_NV */ + 755, /* GL_MAP1_VERTEX_ATTRIB13_4_NV */ + 756, /* GL_MAP1_VERTEX_ATTRIB14_4_NV */ + 757, /* GL_MAP1_VERTEX_ATTRIB15_4_NV */ + 778, /* GL_MAP2_VERTEX_ATTRIB0_4_NV */ + 785, /* GL_MAP2_VERTEX_ATTRIB1_4_NV */ + 786, /* GL_MAP2_VERTEX_ATTRIB2_4_NV */ + 787, /* GL_MAP2_VERTEX_ATTRIB3_4_NV */ + 788, /* GL_MAP2_VERTEX_ATTRIB4_4_NV */ + 789, /* GL_MAP2_VERTEX_ATTRIB5_4_NV */ + 790, /* GL_MAP2_VERTEX_ATTRIB6_4_NV */ + 1212, /* GL_PROGRAM_BINDING_ARB */ + 792, /* GL_MAP2_VERTEX_ATTRIB8_4_NV */ + 793, /* GL_MAP2_VERTEX_ATTRIB9_4_NV */ + 779, /* GL_MAP2_VERTEX_ATTRIB10_4_NV */ + 780, /* GL_MAP2_VERTEX_ATTRIB11_4_NV */ + 781, /* GL_MAP2_VERTEX_ATTRIB12_4_NV */ + 782, /* GL_MAP2_VERTEX_ATTRIB13_4_NV */ + 783, /* GL_MAP2_VERTEX_ATTRIB14_4_NV */ + 784, /* GL_MAP2_VERTEX_ATTRIB15_4_NV */ + 1616, /* GL_TEXTURE_COMPRESSED_IMAGE_SIZE */ + 1613, /* GL_TEXTURE_COMPRESSED */ + 1021, /* GL_NUM_COMPRESSED_TEXTURE_FORMATS */ + 261, /* GL_COMPRESSED_TEXTURE_FORMATS */ + 930, /* GL_MAX_VERTEX_UNITS_ARB */ 22, /* GL_ACTIVE_VERTEX_UNITS_ARB */ - 1800, /* GL_WEIGHT_SUM_UNITY_ARB */ - 1778, /* GL_VERTEX_BLEND_ARB */ - 318, /* GL_CURRENT_WEIGHT_ARB */ - 1799, /* GL_WEIGHT_ARRAY_TYPE_ARB */ - 1798, /* GL_WEIGHT_ARRAY_STRIDE_ARB */ - 1797, /* GL_WEIGHT_ARRAY_SIZE_ARB */ - 1796, /* GL_WEIGHT_ARRAY_POINTER_ARB */ - 1793, /* GL_WEIGHT_ARRAY_ARB */ - 365, /* GL_DOT3_RGB */ - 366, /* GL_DOT3_RGBA */ - 253, /* GL_COMPRESSED_RGB_FXT1_3DFX */ - 248, /* GL_COMPRESSED_RGBA_FXT1_3DFX */ - 982, /* GL_MULTISAMPLE_3DFX */ - 1366, /* GL_SAMPLE_BUFFERS_3DFX */ - 1357, /* GL_SAMPLES_3DFX */ - 963, /* GL_MODELVIEW2_ARB */ - 966, /* GL_MODELVIEW3_ARB */ - 967, /* GL_MODELVIEW4_ARB */ - 968, /* GL_MODELVIEW5_ARB */ - 969, /* GL_MODELVIEW6_ARB */ - 970, /* GL_MODELVIEW7_ARB */ - 971, /* GL_MODELVIEW8_ARB */ - 972, /* GL_MODELVIEW9_ARB */ - 942, /* GL_MODELVIEW10_ARB */ - 943, /* GL_MODELVIEW11_ARB */ - 944, /* GL_MODELVIEW12_ARB */ - 945, /* GL_MODELVIEW13_ARB */ - 946, /* GL_MODELVIEW14_ARB */ - 947, /* GL_MODELVIEW15_ARB */ - 948, /* GL_MODELVIEW16_ARB */ - 949, /* GL_MODELVIEW17_ARB */ - 950, /* GL_MODELVIEW18_ARB */ - 951, /* GL_MODELVIEW19_ARB */ - 953, /* GL_MODELVIEW20_ARB */ - 954, /* GL_MODELVIEW21_ARB */ - 955, /* GL_MODELVIEW22_ARB */ - 956, /* GL_MODELVIEW23_ARB */ - 957, /* GL_MODELVIEW24_ARB */ - 958, /* GL_MODELVIEW25_ARB */ - 959, /* GL_MODELVIEW26_ARB */ - 960, /* GL_MODELVIEW27_ARB */ - 961, /* GL_MODELVIEW28_ARB */ - 962, /* GL_MODELVIEW29_ARB */ - 964, /* GL_MODELVIEW30_ARB */ - 965, /* GL_MODELVIEW31_ARB */ - 370, /* GL_DOT3_RGB_EXT */ - 368, /* GL_DOT3_RGBA_EXT */ - 936, /* GL_MIRROR_CLAMP_EXT */ - 939, /* GL_MIRROR_CLAMP_TO_EDGE_EXT */ - 977, /* GL_MODULATE_ADD_ATI */ - 978, /* GL_MODULATE_SIGNED_ADD_ATI */ - 979, /* GL_MODULATE_SUBTRACT_ATI */ - 1806, /* GL_YCBCR_MESA */ - 1068, /* GL_PACK_INVERT_MESA */ - 321, /* GL_DEBUG_OBJECT_MESA */ - 322, /* GL_DEBUG_PRINT_MESA */ - 320, /* GL_DEBUG_ASSERT_MESA */ + 1808, /* GL_WEIGHT_SUM_UNITY_ARB */ + 1786, /* GL_VERTEX_BLEND_ARB */ + 324, /* GL_CURRENT_WEIGHT_ARB */ + 1807, /* GL_WEIGHT_ARRAY_TYPE_ARB */ + 1806, /* GL_WEIGHT_ARRAY_STRIDE_ARB */ + 1805, /* GL_WEIGHT_ARRAY_SIZE_ARB */ + 1804, /* GL_WEIGHT_ARRAY_POINTER_ARB */ + 1801, /* GL_WEIGHT_ARRAY_ARB */ + 371, /* GL_DOT3_RGB */ + 372, /* GL_DOT3_RGBA */ + 259, /* GL_COMPRESSED_RGB_FXT1_3DFX */ + 254, /* GL_COMPRESSED_RGBA_FXT1_3DFX */ + 990, /* GL_MULTISAMPLE_3DFX */ + 1374, /* GL_SAMPLE_BUFFERS_3DFX */ + 1365, /* GL_SAMPLES_3DFX */ + 971, /* GL_MODELVIEW2_ARB */ + 974, /* GL_MODELVIEW3_ARB */ + 975, /* GL_MODELVIEW4_ARB */ + 976, /* GL_MODELVIEW5_ARB */ + 977, /* GL_MODELVIEW6_ARB */ + 978, /* GL_MODELVIEW7_ARB */ + 979, /* GL_MODELVIEW8_ARB */ + 980, /* GL_MODELVIEW9_ARB */ + 950, /* GL_MODELVIEW10_ARB */ + 951, /* GL_MODELVIEW11_ARB */ + 952, /* GL_MODELVIEW12_ARB */ + 953, /* GL_MODELVIEW13_ARB */ + 954, /* GL_MODELVIEW14_ARB */ + 955, /* GL_MODELVIEW15_ARB */ + 956, /* GL_MODELVIEW16_ARB */ + 957, /* GL_MODELVIEW17_ARB */ + 958, /* GL_MODELVIEW18_ARB */ + 959, /* GL_MODELVIEW19_ARB */ + 961, /* GL_MODELVIEW20_ARB */ + 962, /* GL_MODELVIEW21_ARB */ + 963, /* GL_MODELVIEW22_ARB */ + 964, /* GL_MODELVIEW23_ARB */ + 965, /* GL_MODELVIEW24_ARB */ + 966, /* GL_MODELVIEW25_ARB */ + 967, /* GL_MODELVIEW26_ARB */ + 968, /* GL_MODELVIEW27_ARB */ + 969, /* GL_MODELVIEW28_ARB */ + 970, /* GL_MODELVIEW29_ARB */ + 972, /* GL_MODELVIEW30_ARB */ + 973, /* GL_MODELVIEW31_ARB */ + 376, /* GL_DOT3_RGB_EXT */ + 374, /* GL_DOT3_RGBA_EXT */ + 944, /* GL_MIRROR_CLAMP_EXT */ + 947, /* GL_MIRROR_CLAMP_TO_EDGE_EXT */ + 985, /* GL_MODULATE_ADD_ATI */ + 986, /* GL_MODULATE_SIGNED_ADD_ATI */ + 987, /* GL_MODULATE_SUBTRACT_ATI */ + 1814, /* GL_YCBCR_MESA */ + 1076, /* GL_PACK_INVERT_MESA */ + 327, /* GL_DEBUG_OBJECT_MESA */ + 328, /* GL_DEBUG_PRINT_MESA */ + 326, /* GL_DEBUG_ASSERT_MESA */ 106, /* GL_BUFFER_SIZE */ 108, /* GL_BUFFER_USAGE */ - 1456, /* GL_STENCIL_BACK_FUNC */ - 1454, /* GL_STENCIL_BACK_FAIL */ - 1458, /* GL_STENCIL_BACK_PASS_DEPTH_FAIL */ - 1460, /* GL_STENCIL_BACK_PASS_DEPTH_PASS */ - 504, /* GL_FRAGMENT_PROGRAM_ARB */ - 1202, /* GL_PROGRAM_ALU_INSTRUCTIONS_ARB */ - 1230, /* GL_PROGRAM_TEX_INSTRUCTIONS_ARB */ - 1229, /* GL_PROGRAM_TEX_INDIRECTIONS_ARB */ - 1214, /* GL_PROGRAM_NATIVE_ALU_INSTRUCTIONS_ARB */ - 1220, /* GL_PROGRAM_NATIVE_TEX_INSTRUCTIONS_ARB */ - 1219, /* GL_PROGRAM_NATIVE_TEX_INDIRECTIONS_ARB */ - 871, /* GL_MAX_PROGRAM_ALU_INSTRUCTIONS_ARB */ - 894, /* GL_MAX_PROGRAM_TEX_INSTRUCTIONS_ARB */ - 893, /* GL_MAX_PROGRAM_TEX_INDIRECTIONS_ARB */ - 884, /* GL_MAX_PROGRAM_NATIVE_ALU_INSTRUCTIONS_ARB */ - 890, /* GL_MAX_PROGRAM_NATIVE_TEX_INSTRUCTIONS_ARB */ - 889, /* GL_MAX_PROGRAM_NATIVE_TEX_INDIRECTIONS_ARB */ - 854, /* GL_MAX_DRAW_BUFFERS */ - 374, /* GL_DRAW_BUFFER0 */ - 377, /* GL_DRAW_BUFFER1 */ - 398, /* GL_DRAW_BUFFER2 */ - 401, /* GL_DRAW_BUFFER3 */ - 404, /* GL_DRAW_BUFFER4 */ - 407, /* GL_DRAW_BUFFER5 */ - 410, /* GL_DRAW_BUFFER6 */ - 413, /* GL_DRAW_BUFFER7 */ - 416, /* GL_DRAW_BUFFER8 */ - 419, /* GL_DRAW_BUFFER9 */ - 378, /* GL_DRAW_BUFFER10 */ - 381, /* GL_DRAW_BUFFER11 */ - 384, /* GL_DRAW_BUFFER12 */ - 387, /* GL_DRAW_BUFFER13 */ - 390, /* GL_DRAW_BUFFER14 */ - 393, /* GL_DRAW_BUFFER15 */ + 112, /* GL_BUMP_ROT_MATRIX_ATI */ + 113, /* GL_BUMP_ROT_MATRIX_SIZE_ATI */ + 111, /* GL_BUMP_NUM_TEX_UNITS_ATI */ + 115, /* GL_BUMP_TEX_UNITS_ATI */ + 435, /* GL_DUDV_ATI */ + 434, /* GL_DU8DV8_ATI */ + 110, /* GL_BUMP_ENVMAP_ATI */ + 114, /* GL_BUMP_TARGET_ATI */ + 1464, /* GL_STENCIL_BACK_FUNC */ + 1462, /* GL_STENCIL_BACK_FAIL */ + 1466, /* GL_STENCIL_BACK_PASS_DEPTH_FAIL */ + 1468, /* GL_STENCIL_BACK_PASS_DEPTH_PASS */ + 512, /* GL_FRAGMENT_PROGRAM_ARB */ + 1210, /* GL_PROGRAM_ALU_INSTRUCTIONS_ARB */ + 1238, /* GL_PROGRAM_TEX_INSTRUCTIONS_ARB */ + 1237, /* GL_PROGRAM_TEX_INDIRECTIONS_ARB */ + 1222, /* GL_PROGRAM_NATIVE_ALU_INSTRUCTIONS_ARB */ + 1228, /* GL_PROGRAM_NATIVE_TEX_INSTRUCTIONS_ARB */ + 1227, /* GL_PROGRAM_NATIVE_TEX_INDIRECTIONS_ARB */ + 879, /* GL_MAX_PROGRAM_ALU_INSTRUCTIONS_ARB */ + 902, /* GL_MAX_PROGRAM_TEX_INSTRUCTIONS_ARB */ + 901, /* GL_MAX_PROGRAM_TEX_INDIRECTIONS_ARB */ + 892, /* GL_MAX_PROGRAM_NATIVE_ALU_INSTRUCTIONS_ARB */ + 898, /* GL_MAX_PROGRAM_NATIVE_TEX_INSTRUCTIONS_ARB */ + 897, /* GL_MAX_PROGRAM_NATIVE_TEX_INDIRECTIONS_ARB */ + 862, /* GL_MAX_DRAW_BUFFERS */ + 380, /* GL_DRAW_BUFFER0 */ + 383, /* GL_DRAW_BUFFER1 */ + 404, /* GL_DRAW_BUFFER2 */ + 407, /* GL_DRAW_BUFFER3 */ + 410, /* GL_DRAW_BUFFER4 */ + 413, /* GL_DRAW_BUFFER5 */ + 416, /* GL_DRAW_BUFFER6 */ + 419, /* GL_DRAW_BUFFER7 */ + 422, /* GL_DRAW_BUFFER8 */ + 425, /* GL_DRAW_BUFFER9 */ + 384, /* GL_DRAW_BUFFER10 */ + 387, /* GL_DRAW_BUFFER11 */ + 390, /* GL_DRAW_BUFFER12 */ + 393, /* GL_DRAW_BUFFER13 */ + 396, /* GL_DRAW_BUFFER14 */ + 399, /* GL_DRAW_BUFFER15 */ 81, /* GL_BLEND_EQUATION_ALPHA */ - 834, /* GL_MATRIX_PALETTE_ARB */ - 865, /* GL_MAX_MATRIX_PALETTE_STACK_DEPTH_ARB */ - 868, /* GL_MAX_PALETTE_MATRICES_ARB */ - 304, /* GL_CURRENT_PALETTE_MATRIX_ARB */ - 828, /* GL_MATRIX_INDEX_ARRAY_ARB */ - 299, /* GL_CURRENT_MATRIX_INDEX_ARB */ - 830, /* GL_MATRIX_INDEX_ARRAY_SIZE_ARB */ - 832, /* GL_MATRIX_INDEX_ARRAY_TYPE_ARB */ - 831, /* GL_MATRIX_INDEX_ARRAY_STRIDE_ARB */ - 829, /* GL_MATRIX_INDEX_ARRAY_POINTER_ARB */ - 1634, /* GL_TEXTURE_DEPTH_SIZE */ - 358, /* GL_DEPTH_TEXTURE_MODE */ - 1600, /* GL_TEXTURE_COMPARE_MODE */ - 1598, /* GL_TEXTURE_COMPARE_FUNC */ - 232, /* GL_COMPARE_R_TO_TEXTURE */ - 1136, /* GL_POINT_SPRITE */ - 281, /* GL_COORD_REPLACE */ - 1140, /* GL_POINT_SPRITE_R_MODE_NV */ - 1257, /* GL_QUERY_COUNTER_BITS */ - 306, /* GL_CURRENT_QUERY */ - 1259, /* GL_QUERY_RESULT */ - 1261, /* GL_QUERY_RESULT_AVAILABLE */ - 916, /* GL_MAX_VERTEX_ATTRIBS */ - 1768, /* GL_VERTEX_ATTRIB_ARRAY_NORMALIZED */ - 356, /* GL_DEPTH_STENCIL_TO_RGBA_NV */ - 355, /* GL_DEPTH_STENCIL_TO_BGRA_NV */ - 902, /* GL_MAX_TEXTURE_COORDS */ - 904, /* GL_MAX_TEXTURE_IMAGE_UNITS */ - 1207, /* GL_PROGRAM_ERROR_STRING_ARB */ - 1209, /* GL_PROGRAM_FORMAT_ASCII_ARB */ - 1208, /* GL_PROGRAM_FORMAT_ARB */ - 1680, /* GL_TEXTURE_UNSIGNED_REMAP_MODE_NV */ - 335, /* GL_DEPTH_BOUNDS_TEST_EXT */ - 334, /* GL_DEPTH_BOUNDS_EXT */ + 842, /* GL_MATRIX_PALETTE_ARB */ + 873, /* GL_MAX_MATRIX_PALETTE_STACK_DEPTH_ARB */ + 876, /* GL_MAX_PALETTE_MATRICES_ARB */ + 310, /* GL_CURRENT_PALETTE_MATRIX_ARB */ + 836, /* GL_MATRIX_INDEX_ARRAY_ARB */ + 305, /* GL_CURRENT_MATRIX_INDEX_ARB */ + 838, /* GL_MATRIX_INDEX_ARRAY_SIZE_ARB */ + 840, /* GL_MATRIX_INDEX_ARRAY_TYPE_ARB */ + 839, /* GL_MATRIX_INDEX_ARRAY_STRIDE_ARB */ + 837, /* GL_MATRIX_INDEX_ARRAY_POINTER_ARB */ + 1642, /* GL_TEXTURE_DEPTH_SIZE */ + 364, /* GL_DEPTH_TEXTURE_MODE */ + 1608, /* GL_TEXTURE_COMPARE_MODE */ + 1606, /* GL_TEXTURE_COMPARE_FUNC */ + 238, /* GL_COMPARE_R_TO_TEXTURE */ + 1144, /* GL_POINT_SPRITE */ + 287, /* GL_COORD_REPLACE */ + 1148, /* GL_POINT_SPRITE_R_MODE_NV */ + 1265, /* GL_QUERY_COUNTER_BITS */ + 312, /* GL_CURRENT_QUERY */ + 1267, /* GL_QUERY_RESULT */ + 1269, /* GL_QUERY_RESULT_AVAILABLE */ + 924, /* GL_MAX_VERTEX_ATTRIBS */ + 1776, /* GL_VERTEX_ATTRIB_ARRAY_NORMALIZED */ + 362, /* GL_DEPTH_STENCIL_TO_RGBA_NV */ + 361, /* GL_DEPTH_STENCIL_TO_BGRA_NV */ + 910, /* GL_MAX_TEXTURE_COORDS */ + 912, /* GL_MAX_TEXTURE_IMAGE_UNITS */ + 1215, /* GL_PROGRAM_ERROR_STRING_ARB */ + 1217, /* GL_PROGRAM_FORMAT_ASCII_ARB */ + 1216, /* GL_PROGRAM_FORMAT_ARB */ + 1688, /* GL_TEXTURE_UNSIGNED_REMAP_MODE_NV */ + 341, /* GL_DEPTH_BOUNDS_TEST_EXT */ + 340, /* GL_DEPTH_BOUNDS_EXT */ 52, /* GL_ARRAY_BUFFER */ - 440, /* GL_ELEMENT_ARRAY_BUFFER */ + 448, /* GL_ELEMENT_ARRAY_BUFFER */ 53, /* GL_ARRAY_BUFFER_BINDING */ - 441, /* GL_ELEMENT_ARRAY_BUFFER_BINDING */ - 1742, /* GL_VERTEX_ARRAY_BUFFER_BINDING */ - 1003, /* GL_NORMAL_ARRAY_BUFFER_BINDING */ - 139, /* GL_COLOR_ARRAY_BUFFER_BINDING */ - 620, /* GL_INDEX_ARRAY_BUFFER_BINDING */ - 1613, /* GL_TEXTURE_COORD_ARRAY_BUFFER_BINDING */ - 436, /* GL_EDGE_FLAG_ARRAY_BUFFER_BINDING */ - 1378, /* GL_SECONDARY_COLOR_ARRAY_BUFFER_BINDING */ - 482, /* GL_FOG_COORDINATE_ARRAY_BUFFER_BINDING */ - 1794, /* GL_WEIGHT_ARRAY_BUFFER_BINDING */ - 1764, /* GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING */ - 1210, /* GL_PROGRAM_INSTRUCTIONS_ARB */ - 877, /* GL_MAX_PROGRAM_INSTRUCTIONS_ARB */ - 1216, /* GL_PROGRAM_NATIVE_INSTRUCTIONS_ARB */ - 886, /* GL_MAX_PROGRAM_NATIVE_INSTRUCTIONS_ARB */ - 1228, /* GL_PROGRAM_TEMPORARIES_ARB */ - 892, /* GL_MAX_PROGRAM_TEMPORARIES_ARB */ - 1218, /* GL_PROGRAM_NATIVE_TEMPORARIES_ARB */ - 888, /* GL_MAX_PROGRAM_NATIVE_TEMPORARIES_ARB */ - 1222, /* GL_PROGRAM_PARAMETERS_ARB */ - 891, /* GL_MAX_PROGRAM_PARAMETERS_ARB */ - 1217, /* GL_PROGRAM_NATIVE_PARAMETERS_ARB */ - 887, /* GL_MAX_PROGRAM_NATIVE_PARAMETERS_ARB */ - 1203, /* GL_PROGRAM_ATTRIBS_ARB */ - 872, /* GL_MAX_PROGRAM_ATTRIBS_ARB */ - 1215, /* GL_PROGRAM_NATIVE_ATTRIBS_ARB */ - 885, /* GL_MAX_PROGRAM_NATIVE_ATTRIBS_ARB */ - 1201, /* GL_PROGRAM_ADDRESS_REGISTERS_ARB */ - 870, /* GL_MAX_PROGRAM_ADDRESS_REGISTERS_ARB */ - 1213, /* GL_PROGRAM_NATIVE_ADDRESS_REGISTERS_ARB */ - 883, /* GL_MAX_PROGRAM_NATIVE_ADDRESS_REGISTERS_ARB */ - 878, /* GL_MAX_PROGRAM_LOCAL_PARAMETERS_ARB */ - 874, /* GL_MAX_PROGRAM_ENV_PARAMETERS_ARB */ - 1231, /* GL_PROGRAM_UNDER_NATIVE_LIMITS_ARB */ - 1691, /* GL_TRANSPOSE_CURRENT_MATRIX_ARB */ - 1270, /* GL_READ_ONLY */ - 1802, /* GL_WRITE_ONLY */ - 1272, /* GL_READ_WRITE */ + 449, /* GL_ELEMENT_ARRAY_BUFFER_BINDING */ + 1750, /* GL_VERTEX_ARRAY_BUFFER_BINDING */ + 1011, /* GL_NORMAL_ARRAY_BUFFER_BINDING */ + 145, /* GL_COLOR_ARRAY_BUFFER_BINDING */ + 628, /* GL_INDEX_ARRAY_BUFFER_BINDING */ + 1621, /* GL_TEXTURE_COORD_ARRAY_BUFFER_BINDING */ + 444, /* GL_EDGE_FLAG_ARRAY_BUFFER_BINDING */ + 1386, /* GL_SECONDARY_COLOR_ARRAY_BUFFER_BINDING */ + 490, /* GL_FOG_COORDINATE_ARRAY_BUFFER_BINDING */ + 1802, /* GL_WEIGHT_ARRAY_BUFFER_BINDING */ + 1772, /* GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING */ + 1218, /* GL_PROGRAM_INSTRUCTIONS_ARB */ + 885, /* GL_MAX_PROGRAM_INSTRUCTIONS_ARB */ + 1224, /* GL_PROGRAM_NATIVE_INSTRUCTIONS_ARB */ + 894, /* GL_MAX_PROGRAM_NATIVE_INSTRUCTIONS_ARB */ + 1236, /* GL_PROGRAM_TEMPORARIES_ARB */ + 900, /* GL_MAX_PROGRAM_TEMPORARIES_ARB */ + 1226, /* GL_PROGRAM_NATIVE_TEMPORARIES_ARB */ + 896, /* GL_MAX_PROGRAM_NATIVE_TEMPORARIES_ARB */ + 1230, /* GL_PROGRAM_PARAMETERS_ARB */ + 899, /* GL_MAX_PROGRAM_PARAMETERS_ARB */ + 1225, /* GL_PROGRAM_NATIVE_PARAMETERS_ARB */ + 895, /* GL_MAX_PROGRAM_NATIVE_PARAMETERS_ARB */ + 1211, /* GL_PROGRAM_ATTRIBS_ARB */ + 880, /* GL_MAX_PROGRAM_ATTRIBS_ARB */ + 1223, /* GL_PROGRAM_NATIVE_ATTRIBS_ARB */ + 893, /* GL_MAX_PROGRAM_NATIVE_ATTRIBS_ARB */ + 1209, /* GL_PROGRAM_ADDRESS_REGISTERS_ARB */ + 878, /* GL_MAX_PROGRAM_ADDRESS_REGISTERS_ARB */ + 1221, /* GL_PROGRAM_NATIVE_ADDRESS_REGISTERS_ARB */ + 891, /* GL_MAX_PROGRAM_NATIVE_ADDRESS_REGISTERS_ARB */ + 886, /* GL_MAX_PROGRAM_LOCAL_PARAMETERS_ARB */ + 882, /* GL_MAX_PROGRAM_ENV_PARAMETERS_ARB */ + 1239, /* GL_PROGRAM_UNDER_NATIVE_LIMITS_ARB */ + 1699, /* GL_TRANSPOSE_CURRENT_MATRIX_ARB */ + 1278, /* GL_READ_ONLY */ + 1810, /* GL_WRITE_ONLY */ + 1280, /* GL_READ_WRITE */ 100, /* GL_BUFFER_ACCESS */ 102, /* GL_BUFFER_MAPPED */ 104, /* GL_BUFFER_MAP_POINTER */ - 1685, /* GL_TIME_ELAPSED_EXT */ - 788, /* GL_MATRIX0_ARB */ - 800, /* GL_MATRIX1_ARB */ - 812, /* GL_MATRIX2_ARB */ - 816, /* GL_MATRIX3_ARB */ - 818, /* GL_MATRIX4_ARB */ - 820, /* GL_MATRIX5_ARB */ - 822, /* GL_MATRIX6_ARB */ - 824, /* GL_MATRIX7_ARB */ - 826, /* GL_MATRIX8_ARB */ - 827, /* GL_MATRIX9_ARB */ - 790, /* GL_MATRIX10_ARB */ - 791, /* GL_MATRIX11_ARB */ - 792, /* GL_MATRIX12_ARB */ - 793, /* GL_MATRIX13_ARB */ - 794, /* GL_MATRIX14_ARB */ - 795, /* GL_MATRIX15_ARB */ - 796, /* GL_MATRIX16_ARB */ - 797, /* GL_MATRIX17_ARB */ - 798, /* GL_MATRIX18_ARB */ - 799, /* GL_MATRIX19_ARB */ - 802, /* GL_MATRIX20_ARB */ - 803, /* GL_MATRIX21_ARB */ - 804, /* GL_MATRIX22_ARB */ - 805, /* GL_MATRIX23_ARB */ - 806, /* GL_MATRIX24_ARB */ - 807, /* GL_MATRIX25_ARB */ - 808, /* GL_MATRIX26_ARB */ - 809, /* GL_MATRIX27_ARB */ - 810, /* GL_MATRIX28_ARB */ - 811, /* GL_MATRIX29_ARB */ - 814, /* GL_MATRIX30_ARB */ - 815, /* GL_MATRIX31_ARB */ - 1486, /* GL_STREAM_DRAW */ - 1488, /* GL_STREAM_READ */ - 1484, /* GL_STREAM_COPY */ - 1447, /* GL_STATIC_DRAW */ - 1449, /* GL_STATIC_READ */ - 1445, /* GL_STATIC_COPY */ - 430, /* GL_DYNAMIC_DRAW */ - 432, /* GL_DYNAMIC_READ */ - 428, /* GL_DYNAMIC_COPY */ - 575, /* GL_GL_PIXEL_PACK_BUFFER */ - 577, /* GL_GL_PIXEL_UNPACK_BUFFER */ - 576, /* GL_GL_PIXEL_PACK_BUFFER_BINDING */ - 578, /* GL_GL_PIXEL_UNPACK_BUFFER_BINDING */ - 329, /* GL_DEPTH24_STENCIL8 */ - 1678, /* GL_TEXTURE_STENCIL_SIZE */ - 875, /* GL_MAX_PROGRAM_EXEC_INSTRUCTIONS_NV */ - 873, /* GL_MAX_PROGRAM_CALL_DEPTH_NV */ - 876, /* GL_MAX_PROGRAM_IF_DEPTH_NV */ - 880, /* GL_MAX_PROGRAM_LOOP_DEPTH_NV */ - 879, /* GL_MAX_PROGRAM_LOOP_COUNT_NV */ - 837, /* GL_MAX_ARRAY_TEXTURE_LAYERS_EXT */ - 1480, /* GL_STENCIL_TEST_TWO_SIDE_EXT */ + 1693, /* GL_TIME_ELAPSED_EXT */ + 796, /* GL_MATRIX0_ARB */ + 808, /* GL_MATRIX1_ARB */ + 820, /* GL_MATRIX2_ARB */ + 824, /* GL_MATRIX3_ARB */ + 826, /* GL_MATRIX4_ARB */ + 828, /* GL_MATRIX5_ARB */ + 830, /* GL_MATRIX6_ARB */ + 832, /* GL_MATRIX7_ARB */ + 834, /* GL_MATRIX8_ARB */ + 835, /* GL_MATRIX9_ARB */ + 798, /* GL_MATRIX10_ARB */ + 799, /* GL_MATRIX11_ARB */ + 800, /* GL_MATRIX12_ARB */ + 801, /* GL_MATRIX13_ARB */ + 802, /* GL_MATRIX14_ARB */ + 803, /* GL_MATRIX15_ARB */ + 804, /* GL_MATRIX16_ARB */ + 805, /* GL_MATRIX17_ARB */ + 806, /* GL_MATRIX18_ARB */ + 807, /* GL_MATRIX19_ARB */ + 810, /* GL_MATRIX20_ARB */ + 811, /* GL_MATRIX21_ARB */ + 812, /* GL_MATRIX22_ARB */ + 813, /* GL_MATRIX23_ARB */ + 814, /* GL_MATRIX24_ARB */ + 815, /* GL_MATRIX25_ARB */ + 816, /* GL_MATRIX26_ARB */ + 817, /* GL_MATRIX27_ARB */ + 818, /* GL_MATRIX28_ARB */ + 819, /* GL_MATRIX29_ARB */ + 822, /* GL_MATRIX30_ARB */ + 823, /* GL_MATRIX31_ARB */ + 1494, /* GL_STREAM_DRAW */ + 1496, /* GL_STREAM_READ */ + 1492, /* GL_STREAM_COPY */ + 1455, /* GL_STATIC_DRAW */ + 1457, /* GL_STATIC_READ */ + 1453, /* GL_STATIC_COPY */ + 438, /* GL_DYNAMIC_DRAW */ + 440, /* GL_DYNAMIC_READ */ + 436, /* GL_DYNAMIC_COPY */ + 583, /* GL_GL_PIXEL_PACK_BUFFER */ + 585, /* GL_GL_PIXEL_UNPACK_BUFFER */ + 584, /* GL_GL_PIXEL_PACK_BUFFER_BINDING */ + 586, /* GL_GL_PIXEL_UNPACK_BUFFER_BINDING */ + 335, /* GL_DEPTH24_STENCIL8 */ + 1686, /* GL_TEXTURE_STENCIL_SIZE */ + 883, /* GL_MAX_PROGRAM_EXEC_INSTRUCTIONS_NV */ + 881, /* GL_MAX_PROGRAM_CALL_DEPTH_NV */ + 884, /* GL_MAX_PROGRAM_IF_DEPTH_NV */ + 888, /* GL_MAX_PROGRAM_LOOP_DEPTH_NV */ + 887, /* GL_MAX_PROGRAM_LOOP_COUNT_NV */ + 845, /* GL_MAX_ARRAY_TEXTURE_LAYERS_EXT */ + 1488, /* GL_STENCIL_TEST_TWO_SIDE_EXT */ 17, /* GL_ACTIVE_STENCIL_FACE_EXT */ - 937, /* GL_MIRROR_CLAMP_TO_BORDER_EXT */ - 1359, /* GL_SAMPLES_PASSED */ - 505, /* GL_FRAGMENT_SHADER */ - 1788, /* GL_VERTEX_SHADER */ - 1221, /* GL_PROGRAM_OBJECT_ARB */ - 1391, /* GL_SHADER_OBJECT_ARB */ - 861, /* GL_MAX_FRAGMENT_UNIFORM_COMPONENTS */ - 920, /* GL_MAX_VERTEX_UNIFORM_COMPONENTS */ - 914, /* GL_MAX_VARYING_FLOATS */ - 918, /* GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS */ - 846, /* GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS */ - 1028, /* GL_OBJECT_TYPE_ARB */ - 1393, /* GL_SHADER_TYPE */ - 470, /* GL_FLOAT_VEC2 */ - 472, /* GL_FLOAT_VEC3 */ - 474, /* GL_FLOAT_VEC4 */ - 647, /* GL_INT_VEC2 */ - 649, /* GL_INT_VEC3 */ - 651, /* GL_INT_VEC4 */ + 945, /* GL_MIRROR_CLAMP_TO_BORDER_EXT */ + 1367, /* GL_SAMPLES_PASSED */ + 513, /* GL_FRAGMENT_SHADER */ + 1796, /* GL_VERTEX_SHADER */ + 1229, /* GL_PROGRAM_OBJECT_ARB */ + 1399, /* GL_SHADER_OBJECT_ARB */ + 869, /* GL_MAX_FRAGMENT_UNIFORM_COMPONENTS */ + 928, /* GL_MAX_VERTEX_UNIFORM_COMPONENTS */ + 922, /* GL_MAX_VARYING_FLOATS */ + 926, /* GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS */ + 854, /* GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS */ + 1036, /* GL_OBJECT_TYPE_ARB */ + 1401, /* GL_SHADER_TYPE */ + 478, /* GL_FLOAT_VEC2 */ + 480, /* GL_FLOAT_VEC3 */ + 482, /* GL_FLOAT_VEC4 */ + 655, /* GL_INT_VEC2 */ + 657, /* GL_INT_VEC3 */ + 659, /* GL_INT_VEC4 */ 92, /* GL_BOOL */ 94, /* GL_BOOL_VEC2 */ 96, /* GL_BOOL_VEC3 */ 98, /* GL_BOOL_VEC4 */ - 464, /* GL_FLOAT_MAT2 */ - 466, /* GL_FLOAT_MAT3 */ - 468, /* GL_FLOAT_MAT4 */ - 1350, /* GL_SAMPLER_1D */ - 1352, /* GL_SAMPLER_2D */ - 1354, /* GL_SAMPLER_3D */ - 1355, /* GL_SAMPLER_CUBE */ - 1351, /* GL_SAMPLER_1D_SHADOW */ - 1353, /* GL_SAMPLER_2D_SHADOW */ - 569, /* GL_GL_FLOAT_MAT2x3 */ - 570, /* GL_GL_FLOAT_MAT2x4 */ - 571, /* GL_GL_FLOAT_MAT3x2 */ - 572, /* GL_GL_FLOAT_MAT3x4 */ - 573, /* GL_GL_FLOAT_MAT4x2 */ - 574, /* GL_GL_FLOAT_MAT4x3 */ - 327, /* GL_DELETE_STATUS */ - 236, /* GL_COMPILE_STATUS */ - 701, /* GL_LINK_STATUS */ - 1737, /* GL_VALIDATE_STATUS */ - 632, /* GL_INFO_LOG_LENGTH */ + 472, /* GL_FLOAT_MAT2 */ + 474, /* GL_FLOAT_MAT3 */ + 476, /* GL_FLOAT_MAT4 */ + 1358, /* GL_SAMPLER_1D */ + 1360, /* GL_SAMPLER_2D */ + 1362, /* GL_SAMPLER_3D */ + 1363, /* GL_SAMPLER_CUBE */ + 1359, /* GL_SAMPLER_1D_SHADOW */ + 1361, /* GL_SAMPLER_2D_SHADOW */ + 577, /* GL_GL_FLOAT_MAT2x3 */ + 578, /* GL_GL_FLOAT_MAT2x4 */ + 579, /* GL_GL_FLOAT_MAT3x2 */ + 580, /* GL_GL_FLOAT_MAT3x4 */ + 581, /* GL_GL_FLOAT_MAT4x2 */ + 582, /* GL_GL_FLOAT_MAT4x3 */ + 333, /* GL_DELETE_STATUS */ + 242, /* GL_COMPILE_STATUS */ + 709, /* GL_LINK_STATUS */ + 1745, /* GL_VALIDATE_STATUS */ + 640, /* GL_INFO_LOG_LENGTH */ 55, /* GL_ATTACHED_SHADERS */ 20, /* GL_ACTIVE_UNIFORMS */ 21, /* GL_ACTIVE_UNIFORM_MAX_LENGTH */ - 1392, /* GL_SHADER_SOURCE_LENGTH */ + 1400, /* GL_SHADER_SOURCE_LENGTH */ 15, /* GL_ACTIVE_ATTRIBUTES */ 16, /* GL_ACTIVE_ATTRIBUTE_MAX_LENGTH */ - 507, /* GL_FRAGMENT_SHADER_DERIVATIVE_HINT */ - 1395, /* GL_SHADING_LANGUAGE_VERSION */ - 305, /* GL_CURRENT_PROGRAM */ - 1077, /* GL_PALETTE4_RGB8_OES */ - 1079, /* GL_PALETTE4_RGBA8_OES */ - 1075, /* GL_PALETTE4_R5_G6_B5_OES */ - 1078, /* GL_PALETTE4_RGBA4_OES */ - 1076, /* GL_PALETTE4_RGB5_A1_OES */ - 1082, /* GL_PALETTE8_RGB8_OES */ - 1084, /* GL_PALETTE8_RGBA8_OES */ - 1080, /* GL_PALETTE8_R5_G6_B5_OES */ - 1083, /* GL_PALETTE8_RGBA4_OES */ - 1081, /* GL_PALETTE8_RGB5_A1_OES */ - 614, /* GL_IMPLEMENTATION_COLOR_READ_TYPE_OES */ - 613, /* GL_IMPLEMENTATION_COLOR_READ_FORMAT_OES */ - 1722, /* GL_UNSIGNED_NORMALIZED */ - 1568, /* GL_TEXTURE_1D_ARRAY_EXT */ - 1241, /* GL_PROXY_TEXTURE_1D_ARRAY_EXT */ - 1570, /* GL_TEXTURE_2D_ARRAY_EXT */ - 1244, /* GL_PROXY_TEXTURE_2D_ARRAY_EXT */ - 1576, /* GL_TEXTURE_BINDING_1D_ARRAY_EXT */ - 1578, /* GL_TEXTURE_BINDING_2D_ARRAY_EXT */ - 583, /* GL_GL_SRGB */ - 584, /* GL_GL_SRGB8 */ - 586, /* GL_GL_SRGB_ALPHA */ - 585, /* GL_GL_SRGB8_ALPHA8 */ - 582, /* GL_GL_SLUMINANCE_ALPHA */ - 581, /* GL_GL_SLUMINANCE8_ALPHA8 */ - 579, /* GL_GL_SLUMINANCE */ - 580, /* GL_GL_SLUMINANCE8 */ - 566, /* GL_GL_COMPRESSED_SRGB */ - 567, /* GL_GL_COMPRESSED_SRGB_ALPHA */ - 564, /* GL_GL_COMPRESSED_SLUMINANCE */ - 565, /* GL_GL_COMPRESSED_SLUMINANCE_ALPHA */ - 1138, /* GL_POINT_SPRITE_COORD_ORIGIN */ - 709, /* GL_LOWER_LEFT */ - 1734, /* GL_UPPER_LEFT */ - 1462, /* GL_STENCIL_BACK_REF */ - 1463, /* GL_STENCIL_BACK_VALUE_MASK */ - 1464, /* GL_STENCIL_BACK_WRITEMASK */ - 423, /* GL_DRAW_FRAMEBUFFER_BINDING_EXT */ - 1286, /* GL_RENDERBUFFER_BINDING_EXT */ - 1267, /* GL_READ_FRAMEBUFFER */ - 422, /* GL_DRAW_FRAMEBUFFER */ - 1268, /* GL_READ_FRAMEBUFFER_BINDING_EXT */ - 1296, /* GL_RENDERBUFFER_SAMPLES */ - 517, /* GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE */ - 515, /* GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME */ - 526, /* GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL */ - 522, /* GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE */ - 524, /* GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER */ - 529, /* GL_FRAMEBUFFER_COMPLETE */ - 533, /* GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT */ - 539, /* GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT */ - 537, /* GL_FRAMEBUFFER_INCOMPLETE_DUPLICATE_ATTACHMENT_EXT */ - 535, /* GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS_EXT */ - 538, /* GL_FRAMEBUFFER_INCOMPLETE_FORMATS_EXT */ - 536, /* GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER_EXT */ - 542, /* GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER_EXT */ - 545, /* GL_FRAMEBUFFER_UNSUPPORTED */ - 543, /* GL_FRAMEBUFFER_STATUS_ERROR_EXT */ - 843, /* GL_MAX_COLOR_ATTACHMENTS_EXT */ - 145, /* GL_COLOR_ATTACHMENT0 */ - 147, /* GL_COLOR_ATTACHMENT1 */ - 161, /* GL_COLOR_ATTACHMENT2 */ - 163, /* GL_COLOR_ATTACHMENT3 */ - 165, /* GL_COLOR_ATTACHMENT4 */ - 167, /* GL_COLOR_ATTACHMENT5 */ - 169, /* GL_COLOR_ATTACHMENT6 */ - 171, /* GL_COLOR_ATTACHMENT7 */ - 173, /* GL_COLOR_ATTACHMENT8 */ - 175, /* GL_COLOR_ATTACHMENT9 */ - 148, /* GL_COLOR_ATTACHMENT10 */ - 150, /* GL_COLOR_ATTACHMENT11 */ - 152, /* GL_COLOR_ATTACHMENT12 */ - 154, /* GL_COLOR_ATTACHMENT13 */ - 156, /* GL_COLOR_ATTACHMENT14 */ - 158, /* GL_COLOR_ATTACHMENT15 */ - 330, /* GL_DEPTH_ATTACHMENT */ - 1452, /* GL_STENCIL_ATTACHMENT */ - 508, /* GL_FRAMEBUFFER */ - 1284, /* GL_RENDERBUFFER */ - 1298, /* GL_RENDERBUFFER_WIDTH */ - 1291, /* GL_RENDERBUFFER_HEIGHT */ - 1293, /* GL_RENDERBUFFER_INTERNAL_FORMAT */ - 1475, /* GL_STENCIL_INDEX_EXT */ - 1472, /* GL_STENCIL_INDEX1_EXT */ - 1473, /* GL_STENCIL_INDEX4_EXT */ - 1474, /* GL_STENCIL_INDEX8_EXT */ - 1471, /* GL_STENCIL_INDEX16_EXT */ - 1295, /* GL_RENDERBUFFER_RED_SIZE */ - 1290, /* GL_RENDERBUFFER_GREEN_SIZE */ - 1287, /* GL_RENDERBUFFER_BLUE_SIZE */ - 1285, /* GL_RENDERBUFFER_ALPHA_SIZE */ - 1288, /* GL_RENDERBUFFER_DEPTH_SIZE */ - 1297, /* GL_RENDERBUFFER_STENCIL_SIZE */ - 541, /* GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE */ - 899, /* GL_MAX_SAMPLES */ - 447, /* GL_EVAL_BIT */ - 1265, /* GL_RASTER_POSITION_UNCLIPPED_IBM */ - 703, /* GL_LIST_BIT */ - 1584, /* GL_TEXTURE_BIT */ - 1374, /* GL_SCISSOR_BIT */ + 515, /* GL_FRAGMENT_SHADER_DERIVATIVE_HINT */ + 1403, /* GL_SHADING_LANGUAGE_VERSION */ + 311, /* GL_CURRENT_PROGRAM */ + 1085, /* GL_PALETTE4_RGB8_OES */ + 1087, /* GL_PALETTE4_RGBA8_OES */ + 1083, /* GL_PALETTE4_R5_G6_B5_OES */ + 1086, /* GL_PALETTE4_RGBA4_OES */ + 1084, /* GL_PALETTE4_RGB5_A1_OES */ + 1090, /* GL_PALETTE8_RGB8_OES */ + 1092, /* GL_PALETTE8_RGBA8_OES */ + 1088, /* GL_PALETTE8_R5_G6_B5_OES */ + 1091, /* GL_PALETTE8_RGBA4_OES */ + 1089, /* GL_PALETTE8_RGB5_A1_OES */ + 622, /* GL_IMPLEMENTATION_COLOR_READ_TYPE_OES */ + 621, /* GL_IMPLEMENTATION_COLOR_READ_FORMAT_OES */ + 1730, /* GL_UNSIGNED_NORMALIZED */ + 1576, /* GL_TEXTURE_1D_ARRAY_EXT */ + 1249, /* GL_PROXY_TEXTURE_1D_ARRAY_EXT */ + 1578, /* GL_TEXTURE_2D_ARRAY_EXT */ + 1252, /* GL_PROXY_TEXTURE_2D_ARRAY_EXT */ + 1584, /* GL_TEXTURE_BINDING_1D_ARRAY_EXT */ + 1586, /* GL_TEXTURE_BINDING_2D_ARRAY_EXT */ + 591, /* GL_GL_SRGB */ + 592, /* GL_GL_SRGB8 */ + 594, /* GL_GL_SRGB_ALPHA */ + 593, /* GL_GL_SRGB8_ALPHA8 */ + 590, /* GL_GL_SLUMINANCE_ALPHA */ + 589, /* GL_GL_SLUMINANCE8_ALPHA8 */ + 587, /* GL_GL_SLUMINANCE */ + 588, /* GL_GL_SLUMINANCE8 */ + 574, /* GL_GL_COMPRESSED_SRGB */ + 575, /* GL_GL_COMPRESSED_SRGB_ALPHA */ + 572, /* GL_GL_COMPRESSED_SLUMINANCE */ + 573, /* GL_GL_COMPRESSED_SLUMINANCE_ALPHA */ + 1146, /* GL_POINT_SPRITE_COORD_ORIGIN */ + 717, /* GL_LOWER_LEFT */ + 1742, /* GL_UPPER_LEFT */ + 1470, /* GL_STENCIL_BACK_REF */ + 1471, /* GL_STENCIL_BACK_VALUE_MASK */ + 1472, /* GL_STENCIL_BACK_WRITEMASK */ + 429, /* GL_DRAW_FRAMEBUFFER_BINDING_EXT */ + 1294, /* GL_RENDERBUFFER_BINDING_EXT */ + 1275, /* GL_READ_FRAMEBUFFER */ + 428, /* GL_DRAW_FRAMEBUFFER */ + 1276, /* GL_READ_FRAMEBUFFER_BINDING_EXT */ + 1304, /* GL_RENDERBUFFER_SAMPLES */ + 525, /* GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE */ + 523, /* GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME */ + 534, /* GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL */ + 530, /* GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE */ + 532, /* GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER */ + 537, /* GL_FRAMEBUFFER_COMPLETE */ + 541, /* GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT */ + 547, /* GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT */ + 545, /* GL_FRAMEBUFFER_INCOMPLETE_DUPLICATE_ATTACHMENT_EXT */ + 543, /* GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS_EXT */ + 546, /* GL_FRAMEBUFFER_INCOMPLETE_FORMATS_EXT */ + 544, /* GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER_EXT */ + 550, /* GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER_EXT */ + 553, /* GL_FRAMEBUFFER_UNSUPPORTED */ + 551, /* GL_FRAMEBUFFER_STATUS_ERROR_EXT */ + 851, /* GL_MAX_COLOR_ATTACHMENTS_EXT */ + 151, /* GL_COLOR_ATTACHMENT0 */ + 153, /* GL_COLOR_ATTACHMENT1 */ + 167, /* GL_COLOR_ATTACHMENT2 */ + 169, /* GL_COLOR_ATTACHMENT3 */ + 171, /* GL_COLOR_ATTACHMENT4 */ + 173, /* GL_COLOR_ATTACHMENT5 */ + 175, /* GL_COLOR_ATTACHMENT6 */ + 177, /* GL_COLOR_ATTACHMENT7 */ + 179, /* GL_COLOR_ATTACHMENT8 */ + 181, /* GL_COLOR_ATTACHMENT9 */ + 154, /* GL_COLOR_ATTACHMENT10 */ + 156, /* GL_COLOR_ATTACHMENT11 */ + 158, /* GL_COLOR_ATTACHMENT12 */ + 160, /* GL_COLOR_ATTACHMENT13 */ + 162, /* GL_COLOR_ATTACHMENT14 */ + 164, /* GL_COLOR_ATTACHMENT15 */ + 336, /* GL_DEPTH_ATTACHMENT */ + 1460, /* GL_STENCIL_ATTACHMENT */ + 516, /* GL_FRAMEBUFFER */ + 1292, /* GL_RENDERBUFFER */ + 1306, /* GL_RENDERBUFFER_WIDTH */ + 1299, /* GL_RENDERBUFFER_HEIGHT */ + 1301, /* GL_RENDERBUFFER_INTERNAL_FORMAT */ + 1483, /* GL_STENCIL_INDEX_EXT */ + 1480, /* GL_STENCIL_INDEX1_EXT */ + 1481, /* GL_STENCIL_INDEX4_EXT */ + 1482, /* GL_STENCIL_INDEX8_EXT */ + 1479, /* GL_STENCIL_INDEX16_EXT */ + 1303, /* GL_RENDERBUFFER_RED_SIZE */ + 1298, /* GL_RENDERBUFFER_GREEN_SIZE */ + 1295, /* GL_RENDERBUFFER_BLUE_SIZE */ + 1293, /* GL_RENDERBUFFER_ALPHA_SIZE */ + 1296, /* GL_RENDERBUFFER_DEPTH_SIZE */ + 1305, /* GL_RENDERBUFFER_STENCIL_SIZE */ + 549, /* GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE */ + 907, /* GL_MAX_SAMPLES */ + 455, /* GL_EVAL_BIT */ + 1273, /* GL_RASTER_POSITION_UNCLIPPED_IBM */ + 711, /* GL_LIST_BIT */ + 1592, /* GL_TEXTURE_BIT */ + 1382, /* GL_SCISSOR_BIT */ 29, /* GL_ALL_ATTRIB_BITS */ - 984, /* GL_MULTISAMPLE_BIT */ + 992, /* GL_MULTISAMPLE_BIT */ 30, /* GL_ALL_CLIENT_ATTRIB_BITS */ }; -#define Elements(x) sizeof(x)/sizeof(*x) - typedef int (*cfunc)(const void *, const void *); /** diff --git a/src/mesa/main/execmem.c b/src/mesa/main/execmem.c index f95c31862a..57c1e117c8 100644 --- a/src/mesa/main/execmem.c +++ b/src/mesa/main/execmem.c @@ -24,7 +24,7 @@ /** - * \file exemem.c + * \file execmem.c * Functions for allocating executable memory. * * \author Keith Whitwell @@ -36,7 +36,7 @@ -#if defined(__linux__) || defined(__OpenBSD__) || defined(_NetBSD__) +#if defined(__linux__) || defined(__OpenBSD__) || defined(_NetBSD__) || defined(__sun) /* * Allocate a large block of memory which can hold code then dole it out diff --git a/src/mesa/main/extensions.c b/src/mesa/main/extensions.c index 1b31e283cd..2d2bf51784 100644 --- a/src/mesa/main/extensions.c +++ b/src/mesa/main/extensions.c @@ -137,6 +137,7 @@ static const struct { { ON, "GL_APPLE_packed_pixels", F(APPLE_packed_pixels) }, { OFF, "GL_APPLE_vertex_array_object", F(APPLE_vertex_array_object) }, { OFF, "GL_ATI_blend_equation_separate", F(EXT_blend_equation_separate) }, + { OFF, "GL_ATI_envmap_bumpmap", F(ATI_envmap_bumpmap) }, { OFF, "GL_ATI_texture_env_combine3", F(ATI_texture_env_combine3)}, { OFF, "GL_ATI_texture_mirror_once", F(ATI_texture_mirror_once)}, { OFF, "GL_ATI_fragment_shader", F(ATI_fragment_shader)}, @@ -147,7 +148,6 @@ static const struct { { OFF, "GL_INGR_blend_func_separate", F(EXT_blend_func_separate) }, { OFF, "GL_MESA_pack_invert", F(MESA_pack_invert) }, { OFF, "GL_MESA_packed_depth_stencil", F(MESA_packed_depth_stencil) }, - { OFF, "GL_MESA_program_debug", F(MESA_program_debug) }, { OFF, "GL_MESA_resize_buffers", F(MESA_resize_buffers) }, { OFF, "GL_MESA_texture_array", F(MESA_texture_array) }, { OFF, "GL_MESA_ycbcr_texture", F(MESA_ycbcr_texture) }, @@ -208,7 +208,7 @@ _mesa_enable_sw_extensions(GLcontext *ctx) ctx->Extensions.ARB_shading_language_100 = GL_TRUE; #endif #if FEATURE_ARB_shading_language_120 - ctx->Extensions.ARB_shading_language_120 = GL_FALSE; /* not quite done */ + ctx->Extensions.ARB_shading_language_120 = GL_TRUE; #endif ctx->Extensions.ARB_shadow = GL_TRUE; ctx->Extensions.ARB_shadow_ambient = GL_TRUE; @@ -230,6 +230,7 @@ _mesa_enable_sw_extensions(GLcontext *ctx) /*ctx->Extensions.ARB_vertex_buffer_object = GL_TRUE;*/ #endif ctx->Extensions.APPLE_vertex_array_object = GL_TRUE; + ctx->Extensions.ATI_envmap_bumpmap = GL_TRUE; #if FEATURE_ATI_fragment_shader ctx->Extensions.ATI_fragment_shader = GL_TRUE; #endif @@ -276,9 +277,6 @@ _mesa_enable_sw_extensions(GLcontext *ctx) ctx->Extensions.EXT_vertex_array_bgra = GL_TRUE; /*ctx->Extensions.IBM_multimode_draw_arrays = GL_TRUE;*/ ctx->Extensions.MESA_pack_invert = GL_TRUE; -#if FEATURE_MESA_program_debug - ctx->Extensions.MESA_program_debug = GL_TRUE; -#endif ctx->Extensions.MESA_resize_buffers = GL_TRUE; ctx->Extensions.MESA_texture_array = GL_TRUE; ctx->Extensions.MESA_ycbcr_texture = GL_TRUE; @@ -433,7 +431,7 @@ _mesa_enable_2_1_extensions(GLcontext *ctx) ctx->Extensions.EXT_texture_sRGB = GL_TRUE; #endif #ifdef FEATURE_ARB_shading_language_120 - ctx->Extensions.ARB_shading_language_120 = GL_FALSE; /* not quite done */ + ctx->Extensions.ARB_shading_language_120 = GL_TRUE; #endif } diff --git a/src/mesa/main/fbobject.c b/src/mesa/main/fbobject.c index c3cdc11037..151e29053a 100644 --- a/src/mesa/main/fbobject.c +++ b/src/mesa/main/fbobject.c @@ -303,6 +303,20 @@ _mesa_framebuffer_renderbuffer(GLcontext *ctx, struct gl_framebuffer *fb, /** + * For debug only. + */ +static void +att_incomplete(const char *msg) +{ +#if 0 + _mesa_printf("attachment incomplete: %s\n", msg); +#else + (void) msg; +#endif +} + + +/** * Test if an attachment point is complete and update its Complete field. * \param format if GL_COLOR, this is a color attachment point, * if GL_DEPTH, this is a depth component attachment point, @@ -323,20 +337,26 @@ test_attachment_completeness(const GLcontext *ctx, GLenum format, struct gl_texture_image *texImage; if (!texObj) { + att_incomplete("no texobj"); att->Complete = GL_FALSE; return; } texImage = texObj->Image[att->CubeMapFace][att->TextureLevel]; if (!texImage) { + att_incomplete("no teximage"); att->Complete = GL_FALSE; return; } if (texImage->Width < 1 || texImage->Height < 1) { + att_incomplete("teximage width/height=0"); + _mesa_printf("texobj = %u\n", texObj->Name); + _mesa_printf("level = %d\n", att->TextureLevel); att->Complete = GL_FALSE; return; } if (texObj->Target == GL_TEXTURE_3D && att->Zoffset >= texImage->Depth) { + att_incomplete("bad z offset"); att->Complete = GL_FALSE; return; } @@ -344,6 +364,7 @@ test_attachment_completeness(const GLcontext *ctx, GLenum format, if (format == GL_COLOR) { if (texImage->TexFormat->BaseFormat != GL_RGB && texImage->TexFormat->BaseFormat != GL_RGBA) { + att_incomplete("bad format"); att->Complete = GL_FALSE; return; } @@ -358,11 +379,13 @@ test_attachment_completeness(const GLcontext *ctx, GLenum format, } else { att->Complete = GL_FALSE; + att_incomplete("bad depth format"); return; } } else { /* no such thing as stencil textures */ + att_incomplete("illegal stencil texture"); att->Complete = GL_FALSE; return; } @@ -372,6 +395,7 @@ test_attachment_completeness(const GLcontext *ctx, GLenum format, if (!att->Renderbuffer->InternalFormat || att->Renderbuffer->Width < 1 || att->Renderbuffer->Height < 1) { + att_incomplete("0x0 renderbuffer"); att->Complete = GL_FALSE; return; } @@ -381,6 +405,7 @@ test_attachment_completeness(const GLcontext *ctx, GLenum format, ASSERT(att->Renderbuffer->RedBits); ASSERT(att->Renderbuffer->GreenBits); ASSERT(att->Renderbuffer->BlueBits); + att_incomplete("bad renderbuffer color format"); att->Complete = GL_FALSE; return; } @@ -395,6 +420,7 @@ test_attachment_completeness(const GLcontext *ctx, GLenum format, /* OK */ } else { + att_incomplete("bad renderbuffer depth format"); att->Complete = GL_FALSE; return; } @@ -411,6 +437,7 @@ test_attachment_completeness(const GLcontext *ctx, GLenum format, } else { att->Complete = GL_FALSE; + att_incomplete("bad renderbuffer stencil format"); return; } } @@ -1202,19 +1229,26 @@ _mesa_BindFramebufferEXT(GLenum target, GLuint framebuffer) ASSERT(newFb != &DummyFramebuffer); /* - * XXX check if re-binding same buffer and skip some of this code. + * OK, now bind the new Draw/Read framebuffers, if they're changing. */ if (bindReadBuf) { - _mesa_reference_framebuffer(&ctx->ReadBuffer, newFbread); + if (ctx->ReadBuffer == newFbread) + bindReadBuf = GL_FALSE; /* no change */ + else + _mesa_reference_framebuffer(&ctx->ReadBuffer, newFbread); } if (bindDrawBuf) { /* check if old FB had any texture attachments */ - check_end_texture_render(ctx, ctx->DrawBuffer); + if (ctx->DrawBuffer->Name != 0) { + check_end_texture_render(ctx, ctx->DrawBuffer); + } - /* check if time to delete this framebuffer */ - _mesa_reference_framebuffer(&ctx->DrawBuffer, newFb); + if (ctx->DrawBuffer == newFb) + bindDrawBuf = GL_FALSE; /* no change */ + else + _mesa_reference_framebuffer(&ctx->DrawBuffer, newFb); if (newFb->Name != 0) { /* check if newly bound framebuffer has any texture attachments */ @@ -1222,7 +1256,7 @@ _mesa_BindFramebufferEXT(GLenum target, GLuint framebuffer) } } - if (ctx->Driver.BindFramebuffer) { + if ((bindDrawBuf || bindReadBuf) && ctx->Driver.BindFramebuffer) { ctx->Driver.BindFramebuffer(ctx, target, newFb, newFbread); } } diff --git a/src/mesa/main/fbobject.h b/src/mesa/main/fbobject.h index 33d16cc5a0..5409394073 100644 --- a/src/mesa/main/fbobject.h +++ b/src/mesa/main/fbobject.h @@ -83,7 +83,7 @@ extern void GLAPIENTRY _mesa_RenderbufferStorageEXT(GLenum target, GLenum internalformat, GLsizei width, GLsizei height); -void GLAPIENTRY +extern void GLAPIENTRY _mesa_RenderbufferStorageMultisample(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height); diff --git a/src/mesa/main/feedback.c b/src/mesa/main/feedback.c index 48c2ccbff3..818a804540 100644 --- a/src/mesa/main/feedback.c +++ b/src/mesa/main/feedback.c @@ -1,13 +1,9 @@ -/** - * \file feedback.c - * Selection and feedback modes functions. - */ - /* * Mesa 3-D graphics library - * Version: 5.1 + * Version: 7.5 * - * Copyright (C) 1999-2003 Brian Paul All Rights Reserved. + * Copyright (C) 1999-2008 Brian Paul All Rights Reserved. + * Copyright (C) 2009 VMware, Inc. 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"), @@ -27,6 +23,11 @@ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ +/** + * \file feedback.c + * Selection and feedback modes functions. + */ + #include "glheader.h" #include "colormac.h" @@ -110,60 +111,49 @@ _mesa_PassThrough( GLfloat token ) if (ctx->RenderMode==GL_FEEDBACK) { FLUSH_VERTICES(ctx, 0); - FEEDBACK_TOKEN( ctx, (GLfloat) (GLint) GL_PASS_THROUGH_TOKEN ); - FEEDBACK_TOKEN( ctx, token ); + _mesa_feedback_token( ctx, (GLfloat) (GLint) GL_PASS_THROUGH_TOKEN ); + _mesa_feedback_token( ctx, token ); } } - -/* +/** * Put a vertex into the feedback buffer. */ -void _mesa_feedback_vertex( GLcontext *ctx, - const GLfloat win[4], - const GLfloat color[4], - GLfloat index, - const GLfloat texcoord[4] ) +void +_mesa_feedback_vertex(GLcontext *ctx, + const GLfloat win[4], + const GLfloat color[4], + GLfloat index, + const GLfloat texcoord[4]) { -#if 0 - { - /* snap window x, y to fractional pixel position */ - const GLint snapMask = ~((FIXED_ONE / (1 << SUB_PIXEL_BITS)) - 1); - GLfixed x, y; - x = FloatToFixed(win[0]) & snapMask; - y = FloatToFixed(win[1]) & snapMask; - FEEDBACK_TOKEN(ctx, FixedToFloat(x)); - FEEDBACK_TOKEN(ctx, FixedToFloat(y) ); - } -#else - FEEDBACK_TOKEN( ctx, win[0] ); - FEEDBACK_TOKEN( ctx, win[1] ); -#endif + _mesa_feedback_token( ctx, win[0] ); + _mesa_feedback_token( ctx, win[1] ); if (ctx->Feedback._Mask & FB_3D) { - FEEDBACK_TOKEN( ctx, win[2] ); + _mesa_feedback_token( ctx, win[2] ); } if (ctx->Feedback._Mask & FB_4D) { - FEEDBACK_TOKEN( ctx, win[3] ); + _mesa_feedback_token( ctx, win[3] ); } if (ctx->Feedback._Mask & FB_INDEX) { - FEEDBACK_TOKEN( ctx, (GLfloat) index ); + _mesa_feedback_token( ctx, (GLfloat) index ); } if (ctx->Feedback._Mask & FB_COLOR) { - FEEDBACK_TOKEN( ctx, color[0] ); - FEEDBACK_TOKEN( ctx, color[1] ); - FEEDBACK_TOKEN( ctx, color[2] ); - FEEDBACK_TOKEN( ctx, color[3] ); + _mesa_feedback_token( ctx, color[0] ); + _mesa_feedback_token( ctx, color[1] ); + _mesa_feedback_token( ctx, color[2] ); + _mesa_feedback_token( ctx, color[3] ); } if (ctx->Feedback._Mask & FB_TEXTURE) { - FEEDBACK_TOKEN( ctx, texcoord[0] ); - FEEDBACK_TOKEN( ctx, texcoord[1] ); - FEEDBACK_TOKEN( ctx, texcoord[2] ); - FEEDBACK_TOKEN( ctx, texcoord[3] ); + _mesa_feedback_token( ctx, texcoord[0] ); + _mesa_feedback_token( ctx, texcoord[1] ); + _mesa_feedback_token( ctx, texcoord[2] ); + _mesa_feedback_token( ctx, texcoord[3] ); } } -#endif + +#endif /* _HAVE_FULL_GL */ /**********************************************************************/ @@ -207,17 +197,20 @@ _mesa_SelectBuffer( GLsizei size, GLuint *buffer ) /** * Write a value of a record into the selection buffer. * - * \param CTX GL context. - * \param V value. + * \param ctx GL context. + * \param value value. * * Verifies there is free space in the buffer to write the value and * increments the pointer. */ -#define WRITE_RECORD( CTX, V ) \ - if (CTX->Select.BufferCount < CTX->Select.BufferSize) { \ - CTX->Select.Buffer[CTX->Select.BufferCount] = (V); \ - } \ - CTX->Select.BufferCount++; +static INLINE void +write_record(GLcontext *ctx, GLuint value) +{ + if (ctx->Select.BufferCount < ctx->Select.BufferSize) { + ctx->Select.Buffer[ctx->Select.BufferCount] = value; + } + ctx->Select.BufferCount++; +} /** @@ -229,7 +222,8 @@ _mesa_SelectBuffer( GLsizei size, GLuint *buffer ) * Sets gl_selection::HitFlag and updates gl_selection::HitMinZ and * gl_selection::HitMaxZ. */ -void _mesa_update_hitflag( GLcontext *ctx, GLfloat z ) +void +_mesa_update_hitflag(GLcontext *ctx, GLfloat z) { ctx->Select.HitFlag = GL_TRUE; if (z < ctx->Select.HitMinZ) { @@ -252,7 +246,8 @@ void _mesa_update_hitflag( GLcontext *ctx, GLfloat z ) * * \sa gl_selection. */ -static void write_hit_record( GLcontext *ctx ) +static void +write_hit_record(GLcontext *ctx) { GLuint i; GLuint zmin, zmax, zscale = (~0u); @@ -264,11 +259,11 @@ static void write_hit_record( GLcontext *ctx ) zmin = (GLuint) ((GLfloat) zscale * ctx->Select.HitMinZ); zmax = (GLuint) ((GLfloat) zscale * ctx->Select.HitMaxZ); - WRITE_RECORD( ctx, ctx->Select.NameStackDepth ); - WRITE_RECORD( ctx, zmin ); - WRITE_RECORD( ctx, zmax ); + write_record( ctx, ctx->Select.NameStackDepth ); + write_record( ctx, zmin ); + write_record( ctx, zmax ); for (i = 0; i < ctx->Select.NameStackDepth; i++) { - WRITE_RECORD( ctx, ctx->Select.NameStack[i] ); + write_record( ctx, ctx->Select.NameStack[i] ); } ctx->Select.Hits++; diff --git a/src/mesa/main/feedback.h b/src/mesa/main/feedback.h index 6c448ad631..72c2acd5ed 100644 --- a/src/mesa/main/feedback.h +++ b/src/mesa/main/feedback.h @@ -1,13 +1,9 @@ -/** - * \file feedback.h - * Selection and feedback modes functions. - */ - /* * Mesa 3-D graphics library - * Version: 3.5 + * Version: 7.5 * - * Copyright (C) 1999-2001 Brian Paul All Rights Reserved. + * Copyright (C) 1999-2008 Brian Paul All Rights Reserved. + * Copyright (C) 2009 VMware, Inc. 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"), @@ -27,7 +23,6 @@ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ - #ifndef FEEDBACK_H #define FEEDBACK_H @@ -35,23 +30,29 @@ #include "mtypes.h" -#define FEEDBACK_TOKEN( CTX, T ) \ - if (CTX->Feedback.Count < CTX->Feedback.BufferSize) { \ - CTX->Feedback.Buffer[CTX->Feedback.Count] = (GLfloat) (T); \ - } \ - CTX->Feedback.Count++; +extern void +_mesa_init_feedback( GLcontext *ctx ); +extern void +_mesa_feedback_vertex( GLcontext *ctx, + const GLfloat win[4], + const GLfloat color[4], + GLfloat index, + const GLfloat texcoord[4] ); -extern void _mesa_init_feedback( GLcontext * ctx ); -extern void _mesa_feedback_vertex( GLcontext *ctx, - const GLfloat win[4], - const GLfloat color[4], - GLfloat index, - const GLfloat texcoord[4] ); +static INLINE void +_mesa_feedback_token( GLcontext *ctx, GLfloat token ) +{ + if (ctx->Feedback.Count < ctx->Feedback.BufferSize) { + ctx->Feedback.Buffer[ctx->Feedback.Count] = token; + } + ctx->Feedback.Count++; +} -extern void _mesa_update_hitflag( GLcontext *ctx, GLfloat z ); +extern void +_mesa_update_hitflag( GLcontext *ctx, GLfloat z ); extern void GLAPIENTRY diff --git a/src/mesa/main/ffvertex_prog.c b/src/mesa/main/ffvertex_prog.c index d70b78f258..72b880e28e 100644 --- a/src/mesa/main/ffvertex_prog.c +++ b/src/mesa/main/ffvertex_prog.c @@ -293,16 +293,16 @@ static void make_state_key( GLcontext *ctx, struct state_key *key ) key->unit[i].texgen_mode0 = translate_texgen( texUnit->TexGenEnabled & (1<<0), - texUnit->GenModeS ); + texUnit->GenS.Mode ); key->unit[i].texgen_mode1 = translate_texgen( texUnit->TexGenEnabled & (1<<1), - texUnit->GenModeT ); + texUnit->GenT.Mode ); key->unit[i].texgen_mode2 = translate_texgen( texUnit->TexGenEnabled & (1<<2), - texUnit->GenModeR ); + texUnit->GenR.Mode ); key->unit[i].texgen_mode3 = translate_texgen( texUnit->TexGenEnabled & (1<<3), - texUnit->GenModeQ ); + texUnit->GenQ.Mode ); } } } @@ -655,7 +655,6 @@ static void emit_op3fn(struct tnl_program *p, inst = &p->program->Base.Instructions[nr]; inst->Opcode = (enum prog_opcode) op; - inst->StringPos = 0; inst->Data = 0; emit_arg( &inst->SrcReg[0], src0 ); diff --git a/src/mesa/main/framebuffer.c b/src/mesa/main/framebuffer.c index 351bf6959a..5a13c88a7a 100644 --- a/src/mesa/main/framebuffer.c +++ b/src/mesa/main/framebuffer.c @@ -116,6 +116,7 @@ _mesa_new_framebuffer(GLcontext *ctx, GLuint name) fb->ColorReadBuffer = GL_COLOR_ATTACHMENT0_EXT; fb->_ColorReadBufferIndex = BUFFER_COLOR0; fb->Delete = _mesa_destroy_framebuffer; + _glthread_INIT_MUTEX(fb->Mutex); } return fb; } @@ -252,22 +253,6 @@ _mesa_reference_framebuffer(struct gl_framebuffer **ptr, /** - * XXX this function is deprecated. - * Undo/remove a reference to a framebuffer object. - * Decrement the framebuffer object's reference count and delete it when - * the refcount hits zero. - * Note: we pass the address of a pointer and set it to NULL. - */ -void -_mesa_unreference_framebuffer(struct gl_framebuffer **fb) -{ - _mesa_reference_framebuffer(fb, NULL); -} - - - - -/** * Resize the given framebuffer's renderbuffers to the new width and height. * This should only be used for window-system framebuffers, not * user-created renderbuffers (i.e. made with GL_EXT_framebuffer_object). diff --git a/src/mesa/main/framebuffer.h b/src/mesa/main/framebuffer.h index e9eeed28cb..45a4703ba9 100644 --- a/src/mesa/main/framebuffer.h +++ b/src/mesa/main/framebuffer.h @@ -47,9 +47,6 @@ _mesa_reference_framebuffer(struct gl_framebuffer **ptr, struct gl_framebuffer *fb); extern void -_mesa_unreference_framebuffer(struct gl_framebuffer **fb); - -extern void _mesa_resize_framebuffer(GLcontext *ctx, struct gl_framebuffer *fb, GLuint width, GLuint height); diff --git a/src/mesa/main/get.c b/src/mesa/main/get.c index 87a821b12d..0937fd053c 100644 --- a/src/mesa/main/get.c +++ b/src/mesa/main/get.c @@ -884,21 +884,21 @@ _mesa_GetBooleanv( GLenum pname, GLboolean *params ) params[0] = _mesa_IsEnabled(GL_TEXTURE_2D_ARRAY_EXT); break; case GL_TEXTURE_BINDING_1D: - params[0] = INT_TO_BOOLEAN(ctx->Texture.Unit[ctx->Texture.CurrentUnit].Current1D->Name); + params[0] = INT_TO_BOOLEAN(ctx->Texture.Unit[ctx->Texture.CurrentUnit].CurrentTex[TEXTURE_1D_INDEX]->Name); break; case GL_TEXTURE_BINDING_2D: - params[0] = INT_TO_BOOLEAN(ctx->Texture.Unit[ctx->Texture.CurrentUnit].Current2D->Name); + params[0] = INT_TO_BOOLEAN(ctx->Texture.Unit[ctx->Texture.CurrentUnit].CurrentTex[TEXTURE_2D_INDEX]->Name); break; case GL_TEXTURE_BINDING_3D: - params[0] = INT_TO_BOOLEAN(ctx->Texture.Unit[ctx->Texture.CurrentUnit].Current3D->Name); + params[0] = INT_TO_BOOLEAN(ctx->Texture.Unit[ctx->Texture.CurrentUnit].CurrentTex[TEXTURE_3D_INDEX]->Name); break; case GL_TEXTURE_BINDING_1D_ARRAY_EXT: CHECK_EXT1(MESA_texture_array, "GetBooleanv"); - params[0] = INT_TO_BOOLEAN(ctx->Texture.Unit[ctx->Texture.CurrentUnit].Current1DArray->Name); + params[0] = INT_TO_BOOLEAN(ctx->Texture.Unit[ctx->Texture.CurrentUnit].CurrentTex[TEXTURE_1D_ARRAY_INDEX]->Name); break; case GL_TEXTURE_BINDING_2D_ARRAY_EXT: CHECK_EXT1(MESA_texture_array, "GetBooleanv"); - params[0] = INT_TO_BOOLEAN(ctx->Texture.Unit[ctx->Texture.CurrentUnit].Current2DArray->Name); + params[0] = INT_TO_BOOLEAN(ctx->Texture.Unit[ctx->Texture.CurrentUnit].CurrentTex[TEXTURE_2D_ARRAY_INDEX]->Name); break; case GL_TEXTURE_GEN_S: params[0] = ((ctx->Texture.Unit[ctx->Texture.CurrentUnit].TexGenEnabled & S_BIT) ? 1 : 0); @@ -1071,7 +1071,7 @@ _mesa_GetBooleanv( GLenum pname, GLboolean *params ) break; case GL_TEXTURE_BINDING_CUBE_MAP_ARB: CHECK_EXT1(ARB_texture_cube_map, "GetBooleanv"); - params[0] = INT_TO_BOOLEAN(ctx->Texture.Unit[ctx->Texture.CurrentUnit].CurrentCubeMap->Name); + params[0] = INT_TO_BOOLEAN(ctx->Texture.Unit[ctx->Texture.CurrentUnit].CurrentTex[TEXTURE_CUBE_INDEX]->Name); break; case GL_MAX_CUBE_MAP_TEXTURE_SIZE_ARB: CHECK_EXT1(ARB_texture_cube_map, "GetBooleanv"); @@ -1558,7 +1558,7 @@ _mesa_GetBooleanv( GLenum pname, GLboolean *params ) break; case GL_TEXTURE_BINDING_RECTANGLE_NV: CHECK_EXT1(NV_texture_rectangle, "GetBooleanv"); - params[0] = INT_TO_BOOLEAN(ctx->Texture.Unit[ctx->Texture.CurrentUnit].CurrentRect->Name); + params[0] = INT_TO_BOOLEAN(ctx->Texture.Unit[ctx->Texture.CurrentUnit].CurrentTex[TEXTURE_RECT_INDEX]->Name); break; case GL_MAX_RECTANGLE_TEXTURE_SIZE_NV: CHECK_EXT1(NV_texture_rectangle, "GetBooleanv"); @@ -1715,22 +1715,6 @@ _mesa_GetBooleanv( GLenum pname, GLboolean *params ) params[0] = FLOAT_TO_BOOLEAN(ctx->Depth.BoundsMin); params[1] = FLOAT_TO_BOOLEAN(ctx->Depth.BoundsMax); break; - case GL_FRAGMENT_PROGRAM_CALLBACK_MESA: - CHECK_EXT1(MESA_program_debug, "GetBooleanv"); - params[0] = ctx->FragmentProgram.CallbackEnabled; - break; - case GL_VERTEX_PROGRAM_CALLBACK_MESA: - CHECK_EXT1(MESA_program_debug, "GetBooleanv"); - params[0] = ctx->VertexProgram.CallbackEnabled; - break; - case GL_FRAGMENT_PROGRAM_POSITION_MESA: - CHECK_EXT1(MESA_program_debug, "GetBooleanv"); - params[0] = INT_TO_BOOLEAN(ctx->FragmentProgram.CurrentPosition); - break; - case GL_VERTEX_PROGRAM_POSITION_MESA: - CHECK_EXT1(MESA_program_debug, "GetBooleanv"); - params[0] = INT_TO_BOOLEAN(ctx->VertexProgram.CurrentPosition); - break; case GL_MAX_DRAW_BUFFERS_ARB: params[0] = INT_TO_BOOLEAN(ctx->Const.MaxDrawBuffers); break; @@ -2710,21 +2694,21 @@ _mesa_GetFloatv( GLenum pname, GLfloat *params ) params[0] = BOOLEAN_TO_FLOAT(_mesa_IsEnabled(GL_TEXTURE_2D_ARRAY_EXT)); break; case GL_TEXTURE_BINDING_1D: - params[0] = (GLfloat)(ctx->Texture.Unit[ctx->Texture.CurrentUnit].Current1D->Name); + params[0] = (GLfloat)(ctx->Texture.Unit[ctx->Texture.CurrentUnit].CurrentTex[TEXTURE_1D_INDEX]->Name); break; case GL_TEXTURE_BINDING_2D: - params[0] = (GLfloat)(ctx->Texture.Unit[ctx->Texture.CurrentUnit].Current2D->Name); + params[0] = (GLfloat)(ctx->Texture.Unit[ctx->Texture.CurrentUnit].CurrentTex[TEXTURE_2D_INDEX]->Name); break; case GL_TEXTURE_BINDING_3D: - params[0] = (GLfloat)(ctx->Texture.Unit[ctx->Texture.CurrentUnit].Current3D->Name); + params[0] = (GLfloat)(ctx->Texture.Unit[ctx->Texture.CurrentUnit].CurrentTex[TEXTURE_3D_INDEX]->Name); break; case GL_TEXTURE_BINDING_1D_ARRAY_EXT: CHECK_EXT1(MESA_texture_array, "GetFloatv"); - params[0] = (GLfloat)(ctx->Texture.Unit[ctx->Texture.CurrentUnit].Current1DArray->Name); + params[0] = (GLfloat)(ctx->Texture.Unit[ctx->Texture.CurrentUnit].CurrentTex[TEXTURE_1D_ARRAY_INDEX]->Name); break; case GL_TEXTURE_BINDING_2D_ARRAY_EXT: CHECK_EXT1(MESA_texture_array, "GetFloatv"); - params[0] = (GLfloat)(ctx->Texture.Unit[ctx->Texture.CurrentUnit].Current2DArray->Name); + params[0] = (GLfloat)(ctx->Texture.Unit[ctx->Texture.CurrentUnit].CurrentTex[TEXTURE_2D_ARRAY_INDEX]->Name); break; case GL_TEXTURE_GEN_S: params[0] = BOOLEAN_TO_FLOAT(((ctx->Texture.Unit[ctx->Texture.CurrentUnit].TexGenEnabled & S_BIT) ? 1 : 0)); @@ -2897,7 +2881,7 @@ _mesa_GetFloatv( GLenum pname, GLfloat *params ) break; case GL_TEXTURE_BINDING_CUBE_MAP_ARB: CHECK_EXT1(ARB_texture_cube_map, "GetFloatv"); - params[0] = (GLfloat)(ctx->Texture.Unit[ctx->Texture.CurrentUnit].CurrentCubeMap->Name); + params[0] = (GLfloat)(ctx->Texture.Unit[ctx->Texture.CurrentUnit].CurrentTex[TEXTURE_CUBE_INDEX]->Name); break; case GL_MAX_CUBE_MAP_TEXTURE_SIZE_ARB: CHECK_EXT1(ARB_texture_cube_map, "GetFloatv"); @@ -3384,7 +3368,7 @@ _mesa_GetFloatv( GLenum pname, GLfloat *params ) break; case GL_TEXTURE_BINDING_RECTANGLE_NV: CHECK_EXT1(NV_texture_rectangle, "GetFloatv"); - params[0] = (GLfloat)(ctx->Texture.Unit[ctx->Texture.CurrentUnit].CurrentRect->Name); + params[0] = (GLfloat)(ctx->Texture.Unit[ctx->Texture.CurrentUnit].CurrentTex[TEXTURE_RECT_INDEX]->Name); break; case GL_MAX_RECTANGLE_TEXTURE_SIZE_NV: CHECK_EXT1(NV_texture_rectangle, "GetFloatv"); @@ -3541,22 +3525,6 @@ _mesa_GetFloatv( GLenum pname, GLfloat *params ) params[0] = ctx->Depth.BoundsMin; params[1] = ctx->Depth.BoundsMax; break; - case GL_FRAGMENT_PROGRAM_CALLBACK_MESA: - CHECK_EXT1(MESA_program_debug, "GetFloatv"); - params[0] = BOOLEAN_TO_FLOAT(ctx->FragmentProgram.CallbackEnabled); - break; - case GL_VERTEX_PROGRAM_CALLBACK_MESA: - CHECK_EXT1(MESA_program_debug, "GetFloatv"); - params[0] = BOOLEAN_TO_FLOAT(ctx->VertexProgram.CallbackEnabled); - break; - case GL_FRAGMENT_PROGRAM_POSITION_MESA: - CHECK_EXT1(MESA_program_debug, "GetFloatv"); - params[0] = (GLfloat)(ctx->FragmentProgram.CurrentPosition); - break; - case GL_VERTEX_PROGRAM_POSITION_MESA: - CHECK_EXT1(MESA_program_debug, "GetFloatv"); - params[0] = (GLfloat)(ctx->VertexProgram.CurrentPosition); - break; case GL_MAX_DRAW_BUFFERS_ARB: params[0] = (GLfloat)(ctx->Const.MaxDrawBuffers); break; @@ -4536,21 +4504,21 @@ _mesa_GetIntegerv( GLenum pname, GLint *params ) params[0] = BOOLEAN_TO_INT(_mesa_IsEnabled(GL_TEXTURE_2D_ARRAY_EXT)); break; case GL_TEXTURE_BINDING_1D: - params[0] = ctx->Texture.Unit[ctx->Texture.CurrentUnit].Current1D->Name; + params[0] = ctx->Texture.Unit[ctx->Texture.CurrentUnit].CurrentTex[TEXTURE_1D_INDEX]->Name; break; case GL_TEXTURE_BINDING_2D: - params[0] = ctx->Texture.Unit[ctx->Texture.CurrentUnit].Current2D->Name; + params[0] = ctx->Texture.Unit[ctx->Texture.CurrentUnit].CurrentTex[TEXTURE_2D_INDEX]->Name; break; case GL_TEXTURE_BINDING_3D: - params[0] = ctx->Texture.Unit[ctx->Texture.CurrentUnit].Current3D->Name; + params[0] = ctx->Texture.Unit[ctx->Texture.CurrentUnit].CurrentTex[TEXTURE_3D_INDEX]->Name; break; case GL_TEXTURE_BINDING_1D_ARRAY_EXT: CHECK_EXT1(MESA_texture_array, "GetIntegerv"); - params[0] = ctx->Texture.Unit[ctx->Texture.CurrentUnit].Current1DArray->Name; + params[0] = ctx->Texture.Unit[ctx->Texture.CurrentUnit].CurrentTex[TEXTURE_1D_ARRAY_INDEX]->Name; break; case GL_TEXTURE_BINDING_2D_ARRAY_EXT: CHECK_EXT1(MESA_texture_array, "GetIntegerv"); - params[0] = ctx->Texture.Unit[ctx->Texture.CurrentUnit].Current2DArray->Name; + params[0] = ctx->Texture.Unit[ctx->Texture.CurrentUnit].CurrentTex[TEXTURE_2D_ARRAY_INDEX]->Name; break; case GL_TEXTURE_GEN_S: params[0] = BOOLEAN_TO_INT(((ctx->Texture.Unit[ctx->Texture.CurrentUnit].TexGenEnabled & S_BIT) ? 1 : 0)); @@ -4723,7 +4691,7 @@ _mesa_GetIntegerv( GLenum pname, GLint *params ) break; case GL_TEXTURE_BINDING_CUBE_MAP_ARB: CHECK_EXT1(ARB_texture_cube_map, "GetIntegerv"); - params[0] = ctx->Texture.Unit[ctx->Texture.CurrentUnit].CurrentCubeMap->Name; + params[0] = ctx->Texture.Unit[ctx->Texture.CurrentUnit].CurrentTex[TEXTURE_CUBE_INDEX]->Name; break; case GL_MAX_CUBE_MAP_TEXTURE_SIZE_ARB: CHECK_EXT1(ARB_texture_cube_map, "GetIntegerv"); @@ -5210,7 +5178,7 @@ _mesa_GetIntegerv( GLenum pname, GLint *params ) break; case GL_TEXTURE_BINDING_RECTANGLE_NV: CHECK_EXT1(NV_texture_rectangle, "GetIntegerv"); - params[0] = ctx->Texture.Unit[ctx->Texture.CurrentUnit].CurrentRect->Name; + params[0] = ctx->Texture.Unit[ctx->Texture.CurrentUnit].CurrentTex[TEXTURE_RECT_INDEX]->Name; break; case GL_MAX_RECTANGLE_TEXTURE_SIZE_NV: CHECK_EXT1(NV_texture_rectangle, "GetIntegerv"); @@ -5367,22 +5335,6 @@ _mesa_GetIntegerv( GLenum pname, GLint *params ) params[0] = IROUND(ctx->Depth.BoundsMin); params[1] = IROUND(ctx->Depth.BoundsMax); break; - case GL_FRAGMENT_PROGRAM_CALLBACK_MESA: - CHECK_EXT1(MESA_program_debug, "GetIntegerv"); - params[0] = BOOLEAN_TO_INT(ctx->FragmentProgram.CallbackEnabled); - break; - case GL_VERTEX_PROGRAM_CALLBACK_MESA: - CHECK_EXT1(MESA_program_debug, "GetIntegerv"); - params[0] = BOOLEAN_TO_INT(ctx->VertexProgram.CallbackEnabled); - break; - case GL_FRAGMENT_PROGRAM_POSITION_MESA: - CHECK_EXT1(MESA_program_debug, "GetIntegerv"); - params[0] = ctx->FragmentProgram.CurrentPosition; - break; - case GL_VERTEX_PROGRAM_POSITION_MESA: - CHECK_EXT1(MESA_program_debug, "GetIntegerv"); - params[0] = ctx->VertexProgram.CurrentPosition; - break; case GL_MAX_DRAW_BUFFERS_ARB: params[0] = ctx->Const.MaxDrawBuffers; break; diff --git a/src/mesa/main/get_gen.py b/src/mesa/main/get_gen.py index 3b2496c663..fa695c48f1 100644 --- a/src/mesa/main/get_gen.py +++ b/src/mesa/main/get_gen.py @@ -432,15 +432,15 @@ StateVars = [ ( "GL_TEXTURE_1D_ARRAY_EXT", GLboolean, ["_mesa_IsEnabled(GL_TEXTURE_1D_ARRAY_EXT)"], "", ["MESA_texture_array"] ), ( "GL_TEXTURE_2D_ARRAY_EXT", GLboolean, ["_mesa_IsEnabled(GL_TEXTURE_2D_ARRAY_EXT)"], "", ["MESA_texture_array"] ), ( "GL_TEXTURE_BINDING_1D", GLint, - ["ctx->Texture.Unit[ctx->Texture.CurrentUnit].Current1D->Name"], "", None ), + ["ctx->Texture.Unit[ctx->Texture.CurrentUnit].CurrentTex[TEXTURE_1D_INDEX]->Name"], "", None ), ( "GL_TEXTURE_BINDING_2D", GLint, - ["ctx->Texture.Unit[ctx->Texture.CurrentUnit].Current2D->Name"], "", None ), + ["ctx->Texture.Unit[ctx->Texture.CurrentUnit].CurrentTex[TEXTURE_2D_INDEX]->Name"], "", None ), ( "GL_TEXTURE_BINDING_3D", GLint, - ["ctx->Texture.Unit[ctx->Texture.CurrentUnit].Current3D->Name"], "", None ), + ["ctx->Texture.Unit[ctx->Texture.CurrentUnit].CurrentTex[TEXTURE_3D_INDEX]->Name"], "", None ), ( "GL_TEXTURE_BINDING_1D_ARRAY_EXT", GLint, - ["ctx->Texture.Unit[ctx->Texture.CurrentUnit].Current1DArray->Name"], "", ["MESA_texture_array"] ), + ["ctx->Texture.Unit[ctx->Texture.CurrentUnit].CurrentTex[TEXTURE_1D_ARRAY_INDEX]->Name"], "", ["MESA_texture_array"] ), ( "GL_TEXTURE_BINDING_2D_ARRAY_EXT", GLint, - ["ctx->Texture.Unit[ctx->Texture.CurrentUnit].Current2DArray->Name"], "", ["MESA_texture_array"] ), + ["ctx->Texture.Unit[ctx->Texture.CurrentUnit].CurrentTex[TEXTURE_2D_ARRAY_INDEX]->Name"], "", ["MESA_texture_array"] ), ( "GL_TEXTURE_GEN_S", GLboolean, ["((ctx->Texture.Unit[ctx->Texture.CurrentUnit].TexGenEnabled & S_BIT) ? 1 : 0)"], "", None ), ( "GL_TEXTURE_GEN_T", GLboolean, @@ -515,7 +515,7 @@ StateVars = [ ( "GL_TEXTURE_CUBE_MAP_ARB", GLboolean, ["_mesa_IsEnabled(GL_TEXTURE_CUBE_MAP_ARB)"], "", ["ARB_texture_cube_map"] ), ( "GL_TEXTURE_BINDING_CUBE_MAP_ARB", GLint, - ["ctx->Texture.Unit[ctx->Texture.CurrentUnit].CurrentCubeMap->Name"], + ["ctx->Texture.Unit[ctx->Texture.CurrentUnit].CurrentTex[TEXTURE_CUBE_INDEX]->Name"], "", ["ARB_texture_cube_map"] ), ( "GL_MAX_CUBE_MAP_TEXTURE_SIZE_ARB", GLint, ["(1 << (ctx->Const.MaxCubeTextureLevels - 1))"], @@ -795,7 +795,7 @@ StateVars = [ ( "GL_TEXTURE_RECTANGLE_NV", GLboolean, ["_mesa_IsEnabled(GL_TEXTURE_RECTANGLE_NV)"], "", ["NV_texture_rectangle"] ), ( "GL_TEXTURE_BINDING_RECTANGLE_NV", GLint, - ["ctx->Texture.Unit[ctx->Texture.CurrentUnit].CurrentRect->Name"], + ["ctx->Texture.Unit[ctx->Texture.CurrentUnit].CurrentTex[TEXTURE_RECT_INDEX]->Name"], "", ["NV_texture_rectangle"] ), ( "GL_MAX_RECTANGLE_TEXTURE_SIZE_NV", GLint, ["ctx->Const.MaxTextureRectSize"], "", ["NV_texture_rectangle"] ), @@ -902,16 +902,6 @@ StateVars = [ ["ctx->Depth.BoundsMin", "ctx->Depth.BoundsMax"], "", ["EXT_depth_bounds_test"] ), - # GL_MESA_program_debug - ( "GL_FRAGMENT_PROGRAM_CALLBACK_MESA", GLboolean, - ["ctx->FragmentProgram.CallbackEnabled"], "", ["MESA_program_debug"] ), - ( "GL_VERTEX_PROGRAM_CALLBACK_MESA", GLboolean, - ["ctx->VertexProgram.CallbackEnabled"], "", ["MESA_program_debug"] ), - ( "GL_FRAGMENT_PROGRAM_POSITION_MESA", GLint, - ["ctx->FragmentProgram.CurrentPosition"], "", ["MESA_program_debug"] ), - ( "GL_VERTEX_PROGRAM_POSITION_MESA", GLint, - ["ctx->VertexProgram.CurrentPosition"], "", ["MESA_program_debug"] ), - # GL_ARB_draw_buffers ( "GL_MAX_DRAW_BUFFERS_ARB", GLint, ["ctx->Const.MaxDrawBuffers"], "", None ), diff --git a/src/mesa/main/getstring.c b/src/mesa/main/getstring.c index a9e22d340a..41fd786d7d 100644 --- a/src/mesa/main/getstring.c +++ b/src/mesa/main/getstring.c @@ -93,7 +93,7 @@ compute_version(const GLcontext *ctx) (ctx->Extensions.EXT_stencil_two_side || ctx->Extensions.ATI_separate_stencil)); const GLboolean ver_2_1 = (ver_2_0 && - /*ctx->Extensions.ARB_shading_language_120 &&*/ + ctx->Extensions.ARB_shading_language_120 && ctx->Extensions.EXT_pixel_buffer_object && ctx->Extensions.EXT_texture_sRGB); if (ver_2_1) @@ -242,36 +242,6 @@ _mesa_GetPointerv( GLenum pname, GLvoid **params ) case GL_SELECTION_BUFFER_POINTER: *params = ctx->Select.Buffer; break; -#if FEATURE_MESA_program_debug - case GL_FRAGMENT_PROGRAM_CALLBACK_FUNC_MESA: - if (!ctx->Extensions.MESA_program_debug) { - _mesa_error(ctx, GL_INVALID_ENUM, "glGetPointerv"); - return; - } - *params = *(GLvoid **) &ctx->FragmentProgram.Callback; - break; - case GL_FRAGMENT_PROGRAM_CALLBACK_DATA_MESA: - if (!ctx->Extensions.MESA_program_debug) { - _mesa_error(ctx, GL_INVALID_ENUM, "glGetPointerv"); - return; - } - *params = ctx->FragmentProgram.CallbackData; - break; - case GL_VERTEX_PROGRAM_CALLBACK_FUNC_MESA: - if (!ctx->Extensions.MESA_program_debug) { - _mesa_error(ctx, GL_INVALID_ENUM, "glGetPointerv"); - return; - } - *params = *(GLvoid **) &ctx->VertexProgram.Callback; - break; - case GL_VERTEX_PROGRAM_CALLBACK_DATA_MESA: - if (!ctx->Extensions.MESA_program_debug) { - _mesa_error(ctx, GL_INVALID_ENUM, "glGetPointerv"); - return; - } - *params = ctx->VertexProgram.CallbackData; - break; -#endif default: _mesa_error( ctx, GL_INVALID_ENUM, "glGetPointerv" ); return; diff --git a/src/mesa/main/glheader.h b/src/mesa/main/glheader.h index 5657976711..ad095321e3 100644 --- a/src/mesa/main/glheader.h +++ b/src/mesa/main/glheader.h @@ -1,28 +1,8 @@ -/** - * \file glheader.h - * Top-most include file. - * - * This is the top-most include file of the Mesa sources. - * It includes gl.h and all system headers which are needed. - * Other Mesa source files should \e not directly include any system - * headers. This allows system-dependent hacks/workarounds to be - * collected in one place. - * - * \note Actually, a lot of system-dependent stuff is now in imports.[ch]. - * - * If you touch this file, everything gets recompiled! - * - * This file should be included before any other header in the .c files. - * - * Put compiler/OS/assembly pragmas and macros here to avoid - * cluttering other source files. - */ - /* * Mesa 3-D graphics library - * Version: 6.5 + * Version: 7.5 * - * Copyright (C) 1999-2005 Brian Paul All Rights Reserved. + * Copyright (C) 1999-2008 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"), @@ -43,99 +23,22 @@ */ -#ifndef GLHEADER_H -#define GLHEADER_H - -#include <assert.h> -#include <ctype.h> -#if defined(__alpha__) && defined(CCPML) -#include <cpml.h> /* use Compaq's Fast Math Library on Alpha */ -#else -#include <math.h> -#endif -#include <limits.h> -#include <stdlib.h> -#include <stdio.h> -#include <string.h> -#if defined(__linux__) && defined(__i386__) -#include <fpu_control.h> -#endif -#include <float.h> -#include <stdarg.h> - - -/* Get standard integer types */ -#if defined(_MSC_VER) - - typedef __int8 int8_t; - typedef unsigned __int8 uint8_t; - typedef __int16 int16_t; - typedef unsigned __int16 uint16_t; -# ifndef __eglplatform_h_ - typedef __int32 int32_t; -# endif - typedef unsigned __int32 uint32_t; - typedef __int64 int64_t; - typedef unsigned __int64 uint64_t; - -# if defined(_WIN64) - typedef __int64 intptr_t; - typedef unsigned __int64 uintptr_t; -# else - typedef __int32 intptr_t; - typedef unsigned __int32 uintptr_t; -# endif - -# define INT64_C(__val) __val##i64 -# define UINT64_C(__val) __val##ui64 - -#else -# include <stdint.h> -#endif - +/** + * \file glheader.h + * Wrapper for GL/gl.h and GL/glext.h + */ -/* Sun compilers define __i386 instead of the gcc-style __i386__ */ -#ifdef __SUNPRO_C -# if !defined(__i386__) && defined(__i386) -# define __i386__ -# elif !defined(__amd64__) && defined(__amd64) -# define __amd64__ -# elif !defined(__sparc__) && defined(__sparc) -# define __sparc__ -# endif -# if !defined(__volatile) -# define __volatile volatile -# endif -#endif -#if defined(_WIN32) && !defined(__WIN32__) && !defined(__CYGWIN__) && !defined(BUILD_FOR_SNAP) -# define __WIN32__ -# define finite _finite -#endif +#ifndef GLHEADER_H +#define GLHEADER_H -#if defined(__WATCOMC__) -# define finite _finite -# pragma disable_message(201) /* Disable unreachable code warnings */ -#endif #ifdef WGLAPI -# undef WGLAPI +#undef WGLAPI #endif + #if !defined(OPENSTEP) && (defined(__WIN32__) && !defined(__CYGWIN__)) && !defined(BUILD_FOR_SNAP) -# if !defined(__GNUC__) /* mingw environment */ -# pragma warning( disable : 4068 ) /* unknown pragma */ -# 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 */ -# endif -# endif # if (defined(_MSC_VER) || defined(__MINGW32__)) && defined(BUILD_GL32) /* tag specify we're building mesa as a DLL */ # define WGLAPI __declspec(dllexport) # elif (defined(_MSC_VER) || defined(__MINGW32__)) && defined(_DLL) /* tag specifying we're building for DLL runtime support */ @@ -146,31 +49,10 @@ #endif /* WIN32 / CYGWIN bracket */ -/* - * Either define MESA_BIG_ENDIAN or MESA_LITTLE_ENDIAN. - * Do not use them unless absolutely necessary! - * Try to use a runtime test instead. - * For now, only used by some DRI hardware drivers for color/texel packing. - */ -#if defined(BYTE_ORDER) && defined(BIG_ENDIAN) && BYTE_ORDER == BIG_ENDIAN -#if defined(__linux__) -#include <byteswap.h> -#define CPU_TO_LE32( x ) bswap_32( x ) -#else /*__linux__*/ -#include <sys/endian.h> -#define CPU_TO_LE32( x ) bswap32( x ) -#endif /*__linux__*/ -#define MESA_BIG_ENDIAN 1 -#else -#define CPU_TO_LE32( x ) ( x ) -#define MESA_LITTLE_ENDIAN 1 -#endif -#define LE32_TO_CPU( x ) CPU_TO_LE32( x ) - - #define GL_GLEXT_PROTOTYPES #include "GL/gl.h" #include "GL/glext.h" +#include "GL/internal/glcore.h" #ifndef GL_FIXED @@ -192,129 +74,10 @@ #endif -#if !defined(CAPI) && defined(WIN32) && !defined(BUILD_FOR_SNAP) -#define CAPI _cdecl -#endif - - -/* This is a macro on IRIX */ -#ifdef _P -#undef _P -#endif - - -/* Turn off macro checking systems used by other libraries */ -#ifdef CHECK -#undef CHECK -#endif - - -/* Create a macro so that asm functions can be linked into compilers other - * than GNU C - */ -#ifndef _ASMAPI -#if defined(WIN32) && !defined(BUILD_FOR_SNAP)/* was: !defined( __GNUC__ ) && !defined( VMS ) && !defined( __INTEL_COMPILER )*/ -#define _ASMAPI __cdecl -#else -#define _ASMAPI -#endif -#ifdef PTR_DECL_IN_FRONT -#define _ASMAPIP * _ASMAPI -#else -#define _ASMAPIP _ASMAPI * -#endif -#endif - -#ifdef USE_X86_ASM -#define _NORMAPI _ASMAPI -#define _NORMAPIP _ASMAPIP -#else -#define _NORMAPI -#define _NORMAPIP * -#endif - - -/* Function inlining */ -#if defined(__GNUC__) -# define INLINE __inline__ -#elif defined(__MSC__) -# define INLINE __inline -#elif defined(_MSC_VER) -# define INLINE __inline -#elif defined(__ICL) -# define INLINE __inline -#elif defined(__INTEL_COMPILER) -# define INLINE inline -#elif defined(__WATCOMC__) && (__WATCOMC__ >= 1100) -# define INLINE __inline -#elif defined(__SUNPRO_C) && defined(__C99FEATURES__) -# define INLINE inline -# define __inline inline -# define __inline__ inline -#elif (__STDC_VERSION__ >= 199901L) /* C99 */ -# define INLINE inline -#else -# define INLINE -#endif - - -/* If we build the library with gcc's -fvisibility=hidden flag, we'll - * use the PUBLIC macro to mark functions that are to be exported. - * - * We also need to define a USED attribute, so the optimizer doesn't - * inline a static function that we later use in an alias. - ajax - */ -#if defined(__GNUC__) && (__GNUC__ * 100 + __GNUC_MINOR__) >= 303 -# define PUBLIC __attribute__((visibility("default"))) -# define USED __attribute__((used)) -#else -# define PUBLIC -# define USED -#endif - - -/* Some compilers don't like some of Mesa's const usage */ -#ifdef NO_CONST -# define CONST -#else -# define CONST const -#endif - - -#if !defined(_WIN32_WCE) -#if defined(BUILD_FOR_SNAP) && defined(CHECKED) -# define ASSERT(X) _CHECK(X) -#elif defined(DEBUG) -# define ASSERT(X) assert(X) -#else -# define ASSERT(X) -#endif -#endif - - -#if (!defined(__GNUC__) || __GNUC__ < 3) && (!defined(__IBMC__) || __IBMC__ < 900) -# define __builtin_expect(x, y) x -#endif - -/* The __FUNCTION__ gcc variable is generally only used for debugging. - * If we're not using gcc, define __FUNCTION__ as a cpp symbol here. - * Don't define it if using a newer Windows compiler. +/** + * Special, internal token */ -#ifndef __FUNCTION__ -# if defined(__VMS) -# define __FUNCTION__ "VMS$NL:" -# elif ((!defined __GNUC__) || (__GNUC__ < 2)) && (!defined __xlC__) && \ - (!defined(_MSC_VER) || _MSC_VER < 1300) -# if (__STDC_VERSION__ >= 199901L) /* C99 */ || \ - (defined(__SUNPRO_C) && defined(__C99FEATURES__)) -# define __FUNCTION__ __func__ -# else -# define __FUNCTION__ "<unknown>" -# endif -# endif -#endif - +#define GL_SHADER_PROGRAM_MESA 0x9999 -#include "config.h" #endif /* GLHEADER_H */ diff --git a/src/mesa/main/hash.c b/src/mesa/main/hash.c index ffb2c4d946..976f9d999b 100644 --- a/src/mesa/main/hash.c +++ b/src/mesa/main/hash.c @@ -300,7 +300,7 @@ _mesa_HashWalk(const struct _mesa_HashTable *table, GLuint pos; ASSERT(table); ASSERT(callback); - _glthread_UNLOCK_MUTEX(table2->Mutex); + _glthread_LOCK_MUTEX(table2->Mutex); for (pos = 0; pos < TABLE_SIZE; pos++) { struct HashEntry *entry; for (entry = table->Table[pos]; entry; entry = entry->Next) { diff --git a/src/mesa/main/image.c b/src/mesa/main/image.c index 4d86c54777..fa3149d56d 100644 --- a/src/mesa/main/image.c +++ b/src/mesa/main/image.c @@ -293,6 +293,9 @@ _mesa_components_in_format( GLenum format ) return 2; case GL_DEPTH_STENCIL_EXT: return 2; + case GL_DUDV_ATI: + case GL_DU8DV8_ATI: + return 2; default: return -1; } @@ -503,6 +506,20 @@ _mesa_is_legal_format_and_type( GLcontext *ctx, GLenum format, GLenum type ) return GL_TRUE; else return GL_FALSE; + case GL_DUDV_ATI: + case GL_DU8DV8_ATI: + switch (type) { + case GL_BYTE: + case GL_UNSIGNED_BYTE: + case GL_SHORT: + case GL_UNSIGNED_SHORT: + case GL_INT: + case GL_UNSIGNED_INT: + case GL_FLOAT: + return GL_TRUE; + default: + return GL_FALSE; + } default: ; /* fall-through */ } @@ -1674,8 +1691,19 @@ _mesa_pack_rgba_span_float(GLcontext *ctx, GLuint n, GLfloat rgba[][4], GLfloat luminance[MAX_WIDTH]; const GLint comps = _mesa_components_in_format(dstFormat); GLuint i; - - if (dstType != GL_FLOAT || ctx->Color.ClampReadColor == GL_TRUE) { + /* clamping only applies to colors, not the dudv values, but still need + it if converting to unsigned values (which doesn't make much sense) */ + if (dstFormat == GL_DUDV_ATI || dstFormat == GL_DU8DV8_ATI) { + switch (dstType) { + case GL_UNSIGNED_BYTE: + case GL_UNSIGNED_SHORT: + case GL_UNSIGNED_INT: + transferOps |= IMAGE_CLAMP_BIT; + break; + /* actually might want clamp to [-1,1] otherwise but shouldn't matter? */ + } + } + else if (dstType != GL_FLOAT || ctx->Color.ClampReadColor == GL_TRUE) { /* need to clamp to [0, 1] */ transferOps |= IMAGE_CLAMP_BIT; } @@ -1774,6 +1802,13 @@ _mesa_pack_rgba_span_float(GLcontext *ctx, GLuint n, GLfloat rgba[][4], dst[i*4+3] = FLOAT_TO_UBYTE(rgba[i][RCOMP]); } break; + case GL_DUDV_ATI: + case GL_DU8DV8_ATI: + for (i=0;i<n;i++) { + dst[i*2+0] = FLOAT_TO_UBYTE(rgba[i][RCOMP]); + dst[i*2+1] = FLOAT_TO_UBYTE(rgba[i][GCOMP]); + } + break; default: _mesa_problem(ctx, "bad format in _mesa_pack_rgba_span\n"); } @@ -1847,6 +1882,13 @@ _mesa_pack_rgba_span_float(GLcontext *ctx, GLuint n, GLfloat rgba[][4], dst[i*4+3] = FLOAT_TO_BYTE(rgba[i][RCOMP]); } break; + case GL_DUDV_ATI: + case GL_DU8DV8_ATI: + for (i=0;i<n;i++) { + dst[i*2+0] = FLOAT_TO_BYTE(rgba[i][RCOMP]); + dst[i*2+1] = FLOAT_TO_BYTE(rgba[i][GCOMP]); + } + break; default: _mesa_problem(ctx, "bad format in _mesa_pack_rgba_span\n"); } @@ -1920,6 +1962,13 @@ _mesa_pack_rgba_span_float(GLcontext *ctx, GLuint n, GLfloat rgba[][4], CLAMPED_FLOAT_TO_USHORT(dst[i*4+3], rgba[i][RCOMP]); } break; + case GL_DUDV_ATI: + case GL_DU8DV8_ATI: + for (i=0;i<n;i++) { + dst[i*2+0] = FLOAT_TO_USHORT(rgba[i][RCOMP]); + dst[i*2+1] = FLOAT_TO_USHORT(rgba[i][GCOMP]); + } + break; default: _mesa_problem(ctx, "bad format in _mesa_pack_rgba_span\n"); } @@ -1993,6 +2042,13 @@ _mesa_pack_rgba_span_float(GLcontext *ctx, GLuint n, GLfloat rgba[][4], dst[i*4+3] = FLOAT_TO_SHORT(rgba[i][RCOMP]); } break; + case GL_DUDV_ATI: + case GL_DU8DV8_ATI: + for (i=0;i<n;i++) { + dst[i*2+0] = FLOAT_TO_SHORT(rgba[i][RCOMP]); + dst[i*2+1] = FLOAT_TO_SHORT(rgba[i][GCOMP]); + } + break; default: _mesa_problem(ctx, "bad format in _mesa_pack_rgba_span\n"); } @@ -2066,6 +2122,13 @@ _mesa_pack_rgba_span_float(GLcontext *ctx, GLuint n, GLfloat rgba[][4], dst[i*4+3] = FLOAT_TO_UINT(rgba[i][RCOMP]); } break; + case GL_DUDV_ATI: + case GL_DU8DV8_ATI: + for (i=0;i<n;i++) { + dst[i*2+0] = FLOAT_TO_UINT(rgba[i][RCOMP]); + dst[i*2+1] = FLOAT_TO_UINT(rgba[i][GCOMP]); + } + break; default: _mesa_problem(ctx, "bad format in _mesa_pack_rgba_span\n"); } @@ -2139,6 +2202,13 @@ _mesa_pack_rgba_span_float(GLcontext *ctx, GLuint n, GLfloat rgba[][4], dst[i*4+3] = FLOAT_TO_INT(rgba[i][RCOMP]); } break; + case GL_DUDV_ATI: + case GL_DU8DV8_ATI: + for (i=0;i<n;i++) { + dst[i*2+0] = FLOAT_TO_INT(rgba[i][RCOMP]); + dst[i*2+1] = FLOAT_TO_INT(rgba[i][GCOMP]); + } + break; default: _mesa_problem(ctx, "bad format in _mesa_pack_rgba_span\n"); } @@ -2212,6 +2282,13 @@ _mesa_pack_rgba_span_float(GLcontext *ctx, GLuint n, GLfloat rgba[][4], dst[i*4+3] = rgba[i][RCOMP]; } break; + case GL_DUDV_ATI: + case GL_DU8DV8_ATI: + for (i=0;i<n;i++) { + dst[i*2+0] = rgba[i][RCOMP]; + dst[i*2+1] = rgba[i][GCOMP]; + } + break; default: _mesa_problem(ctx, "bad format in _mesa_pack_rgba_span\n"); } @@ -2285,6 +2362,13 @@ _mesa_pack_rgba_span_float(GLcontext *ctx, GLuint n, GLfloat rgba[][4], dst[i*4+3] = _mesa_float_to_half(rgba[i][RCOMP]); } break; + case GL_DUDV_ATI: + case GL_DU8DV8_ATI: + for (i=0;i<n;i++) { + dst[i*2+0] = _mesa_float_to_half(rgba[i][RCOMP]); + dst[i*2+1] = _mesa_float_to_half(rgba[i][GCOMP]); + } + break; default: _mesa_problem(ctx, "bad format in _mesa_pack_rgba_span\n"); } @@ -2294,9 +2378,9 @@ _mesa_pack_rgba_span_float(GLcontext *ctx, GLuint n, GLfloat rgba[][4], if (dstFormat == GL_RGB) { GLubyte *dst = (GLubyte *) dstAddr; for (i=0;i<n;i++) { - dst[i] = (((GLint) (rgba[i][RCOMP] * 7.0F)) << 5) - | (((GLint) (rgba[i][GCOMP] * 7.0F)) << 2) - | (((GLint) (rgba[i][BCOMP] * 3.0F)) ); + dst[i] = (IROUND(rgba[i][RCOMP] * 7.0F) << 5) + | (IROUND(rgba[i][GCOMP] * 7.0F) << 2) + | (IROUND(rgba[i][BCOMP] * 3.0F) ); } } break; @@ -2304,9 +2388,9 @@ _mesa_pack_rgba_span_float(GLcontext *ctx, GLuint n, GLfloat rgba[][4], if (dstFormat == GL_RGB) { GLubyte *dst = (GLubyte *) dstAddr; for (i=0;i<n;i++) { - dst[i] = (((GLint) (rgba[i][RCOMP] * 7.0F)) ) - | (((GLint) (rgba[i][GCOMP] * 7.0F)) << 3) - | (((GLint) (rgba[i][BCOMP] * 3.0F)) << 6); + dst[i] = (IROUND(rgba[i][RCOMP] * 7.0F) ) + | (IROUND(rgba[i][GCOMP] * 7.0F) << 3) + | (IROUND(rgba[i][BCOMP] * 3.0F) << 6); } } break; @@ -2314,9 +2398,9 @@ _mesa_pack_rgba_span_float(GLcontext *ctx, GLuint n, GLfloat rgba[][4], if (dstFormat == GL_RGB) { GLushort *dst = (GLushort *) dstAddr; for (i=0;i<n;i++) { - dst[i] = (((GLint) (rgba[i][RCOMP] * 31.0F)) << 11) - | (((GLint) (rgba[i][GCOMP] * 63.0F)) << 5) - | (((GLint) (rgba[i][BCOMP] * 31.0F)) ); + dst[i] = (IROUND(rgba[i][RCOMP] * 31.0F) << 11) + | (IROUND(rgba[i][GCOMP] * 63.0F) << 5) + | (IROUND(rgba[i][BCOMP] * 31.0F) ); } } break; @@ -2324,9 +2408,9 @@ _mesa_pack_rgba_span_float(GLcontext *ctx, GLuint n, GLfloat rgba[][4], if (dstFormat == GL_RGB) { GLushort *dst = (GLushort *) dstAddr; for (i=0;i<n;i++) { - dst[i] = (((GLint) (rgba[i][RCOMP] * 31.0F)) ) - | (((GLint) (rgba[i][GCOMP] * 63.0F)) << 5) - | (((GLint) (rgba[i][BCOMP] * 31.0F)) << 11); + dst[i] = (IROUND(rgba[i][RCOMP] * 31.0F) ) + | (IROUND(rgba[i][GCOMP] * 63.0F) << 5) + | (IROUND(rgba[i][BCOMP] * 31.0F) << 11); } } break; @@ -2334,28 +2418,28 @@ _mesa_pack_rgba_span_float(GLcontext *ctx, GLuint n, GLfloat rgba[][4], if (dstFormat == GL_RGBA) { GLushort *dst = (GLushort *) dstAddr; for (i=0;i<n;i++) { - dst[i] = (((GLint) (rgba[i][RCOMP] * 15.0F)) << 12) - | (((GLint) (rgba[i][GCOMP] * 15.0F)) << 8) - | (((GLint) (rgba[i][BCOMP] * 15.0F)) << 4) - | (((GLint) (rgba[i][ACOMP] * 15.0F)) ); + dst[i] = (IROUND(rgba[i][RCOMP] * 15.0F) << 12) + | (IROUND(rgba[i][GCOMP] * 15.0F) << 8) + | (IROUND(rgba[i][BCOMP] * 15.0F) << 4) + | (IROUND(rgba[i][ACOMP] * 15.0F) ); } } else if (dstFormat == GL_BGRA) { GLushort *dst = (GLushort *) dstAddr; for (i=0;i<n;i++) { - dst[i] = (((GLint) (rgba[i][BCOMP] * 15.0F)) << 12) - | (((GLint) (rgba[i][GCOMP] * 15.0F)) << 8) - | (((GLint) (rgba[i][RCOMP] * 15.0F)) << 4) - | (((GLint) (rgba[i][ACOMP] * 15.0F)) ); + dst[i] = (IROUND(rgba[i][BCOMP] * 15.0F) << 12) + | (IROUND(rgba[i][GCOMP] * 15.0F) << 8) + | (IROUND(rgba[i][RCOMP] * 15.0F) << 4) + | (IROUND(rgba[i][ACOMP] * 15.0F) ); } } else if (dstFormat == GL_ABGR_EXT) { GLushort *dst = (GLushort *) dstAddr; for (i=0;i<n;i++) { - dst[i] = (((GLint) (rgba[i][ACOMP] * 15.0F)) << 12) - | (((GLint) (rgba[i][BCOMP] * 15.0F)) << 8) - | (((GLint) (rgba[i][GCOMP] * 15.0F)) << 4) - | (((GLint) (rgba[i][RCOMP] * 15.0F)) ); + dst[i] = (IROUND(rgba[i][ACOMP] * 15.0F) << 12) + | (IROUND(rgba[i][BCOMP] * 15.0F) << 8) + | (IROUND(rgba[i][GCOMP] * 15.0F) << 4) + | (IROUND(rgba[i][RCOMP] * 15.0F) ); } } break; @@ -2363,28 +2447,28 @@ _mesa_pack_rgba_span_float(GLcontext *ctx, GLuint n, GLfloat rgba[][4], if (dstFormat == GL_RGBA) { GLushort *dst = (GLushort *) dstAddr; for (i=0;i<n;i++) { - dst[i] = (((GLint) (rgba[i][RCOMP] * 15.0F)) ) - | (((GLint) (rgba[i][GCOMP] * 15.0F)) << 4) - | (((GLint) (rgba[i][BCOMP] * 15.0F)) << 8) - | (((GLint) (rgba[i][ACOMP] * 15.0F)) << 12); + dst[i] = (IROUND(rgba[i][RCOMP] * 15.0F) ) + | (IROUND(rgba[i][GCOMP] * 15.0F) << 4) + | (IROUND(rgba[i][BCOMP] * 15.0F) << 8) + | (IROUND(rgba[i][ACOMP] * 15.0F) << 12); } } else if (dstFormat == GL_BGRA) { GLushort *dst = (GLushort *) dstAddr; for (i=0;i<n;i++) { - dst[i] = (((GLint) (rgba[i][BCOMP] * 15.0F)) ) - | (((GLint) (rgba[i][GCOMP] * 15.0F)) << 4) - | (((GLint) (rgba[i][RCOMP] * 15.0F)) << 8) - | (((GLint) (rgba[i][ACOMP] * 15.0F)) << 12); + dst[i] = (IROUND(rgba[i][BCOMP] * 15.0F) ) + | (IROUND(rgba[i][GCOMP] * 15.0F) << 4) + | (IROUND(rgba[i][RCOMP] * 15.0F) << 8) + | (IROUND(rgba[i][ACOMP] * 15.0F) << 12); } } else if (dstFormat == GL_ABGR_EXT) { GLushort *dst = (GLushort *) dstAddr; for (i=0;i<n;i++) { - dst[i] = (((GLint) (rgba[i][ACOMP] * 15.0F)) ) - | (((GLint) (rgba[i][BCOMP] * 15.0F)) << 4) - | (((GLint) (rgba[i][GCOMP] * 15.0F)) << 8) - | (((GLint) (rgba[i][RCOMP] * 15.0F)) << 12); + dst[i] = (IROUND(rgba[i][ACOMP] * 15.0F) ) + | (IROUND(rgba[i][BCOMP] * 15.0F) << 4) + | (IROUND(rgba[i][GCOMP] * 15.0F) << 8) + | (IROUND(rgba[i][RCOMP] * 15.0F) << 12); } } break; @@ -2392,28 +2476,28 @@ _mesa_pack_rgba_span_float(GLcontext *ctx, GLuint n, GLfloat rgba[][4], if (dstFormat == GL_RGBA) { GLushort *dst = (GLushort *) dstAddr; for (i=0;i<n;i++) { - dst[i] = (((GLint) (rgba[i][RCOMP] * 31.0F)) << 11) - | (((GLint) (rgba[i][GCOMP] * 31.0F)) << 6) - | (((GLint) (rgba[i][BCOMP] * 31.0F)) << 1) - | (((GLint) (rgba[i][ACOMP] * 1.0F)) ); + dst[i] = (IROUND(rgba[i][RCOMP] * 31.0F) << 11) + | (IROUND(rgba[i][GCOMP] * 31.0F) << 6) + | (IROUND(rgba[i][BCOMP] * 31.0F) << 1) + | (IROUND(rgba[i][ACOMP] * 1.0F) ); } } else if (dstFormat == GL_BGRA) { GLushort *dst = (GLushort *) dstAddr; for (i=0;i<n;i++) { - dst[i] = (((GLint) (rgba[i][BCOMP] * 31.0F)) << 11) - | (((GLint) (rgba[i][GCOMP] * 31.0F)) << 6) - | (((GLint) (rgba[i][RCOMP] * 31.0F)) << 1) - | (((GLint) (rgba[i][ACOMP] * 1.0F)) ); + dst[i] = (IROUND(rgba[i][BCOMP] * 31.0F) << 11) + | (IROUND(rgba[i][GCOMP] * 31.0F) << 6) + | (IROUND(rgba[i][RCOMP] * 31.0F) << 1) + | (IROUND(rgba[i][ACOMP] * 1.0F) ); } } else if (dstFormat == GL_ABGR_EXT) { GLushort *dst = (GLushort *) dstAddr; for (i=0;i<n;i++) { - dst[i] = (((GLint) (rgba[i][ACOMP] * 31.0F)) << 11) - | (((GLint) (rgba[i][BCOMP] * 31.0F)) << 6) - | (((GLint) (rgba[i][GCOMP] * 31.0F)) << 1) - | (((GLint) (rgba[i][RCOMP] * 1.0F)) ); + dst[i] = (IROUND(rgba[i][ACOMP] * 31.0F) << 11) + | (IROUND(rgba[i][BCOMP] * 31.0F) << 6) + | (IROUND(rgba[i][GCOMP] * 31.0F) << 1) + | (IROUND(rgba[i][RCOMP] * 1.0F) ); } } break; @@ -2421,28 +2505,28 @@ _mesa_pack_rgba_span_float(GLcontext *ctx, GLuint n, GLfloat rgba[][4], if (dstFormat == GL_RGBA) { GLushort *dst = (GLushort *) dstAddr; for (i=0;i<n;i++) { - dst[i] = (((GLint) (rgba[i][RCOMP] * 31.0F)) ) - | (((GLint) (rgba[i][GCOMP] * 31.0F)) << 5) - | (((GLint) (rgba[i][BCOMP] * 31.0F)) << 10) - | (((GLint) (rgba[i][ACOMP] * 1.0F)) << 15); + dst[i] = (IROUND(rgba[i][RCOMP] * 31.0F) ) + | (IROUND(rgba[i][GCOMP] * 31.0F) << 5) + | (IROUND(rgba[i][BCOMP] * 31.0F) << 10) + | (IROUND(rgba[i][ACOMP] * 1.0F) << 15); } } else if (dstFormat == GL_BGRA) { GLushort *dst = (GLushort *) dstAddr; for (i=0;i<n;i++) { - dst[i] = (((GLint) (rgba[i][BCOMP] * 31.0F)) ) - | (((GLint) (rgba[i][GCOMP] * 31.0F)) << 5) - | (((GLint) (rgba[i][RCOMP] * 31.0F)) << 10) - | (((GLint) (rgba[i][ACOMP] * 1.0F)) << 15); + dst[i] = (IROUND(rgba[i][BCOMP] * 31.0F) ) + | (IROUND(rgba[i][GCOMP] * 31.0F) << 5) + | (IROUND(rgba[i][RCOMP] * 31.0F) << 10) + | (IROUND(rgba[i][ACOMP] * 1.0F) << 15); } } else if (dstFormat == GL_ABGR_EXT) { GLushort *dst = (GLushort *) dstAddr; for (i=0;i<n;i++) { - dst[i] = (((GLint) (rgba[i][ACOMP] * 31.0F)) ) - | (((GLint) (rgba[i][BCOMP] * 31.0F)) << 5) - | (((GLint) (rgba[i][GCOMP] * 31.0F)) << 10) - | (((GLint) (rgba[i][RCOMP] * 1.0F)) << 15); + dst[i] = (IROUND(rgba[i][ACOMP] * 31.0F) ) + | (IROUND(rgba[i][BCOMP] * 31.0F) << 5) + | (IROUND(rgba[i][GCOMP] * 31.0F) << 10) + | (IROUND(rgba[i][RCOMP] * 1.0F) << 15); } } break; @@ -2450,28 +2534,28 @@ _mesa_pack_rgba_span_float(GLcontext *ctx, GLuint n, GLfloat rgba[][4], if (dstFormat == GL_RGBA) { GLuint *dst = (GLuint *) dstAddr; for (i=0;i<n;i++) { - dst[i] = (((GLuint) (rgba[i][RCOMP] * 255.0F)) << 24) - | (((GLuint) (rgba[i][GCOMP] * 255.0F)) << 16) - | (((GLuint) (rgba[i][BCOMP] * 255.0F)) << 8) - | (((GLuint) (rgba[i][ACOMP] * 255.0F)) ); + dst[i] = (IROUND(rgba[i][RCOMP] * 255.F) << 24) + | (IROUND(rgba[i][GCOMP] * 255.F) << 16) + | (IROUND(rgba[i][BCOMP] * 255.F) << 8) + | (IROUND(rgba[i][ACOMP] * 255.F) ); } } else if (dstFormat == GL_BGRA) { GLuint *dst = (GLuint *) dstAddr; for (i=0;i<n;i++) { - dst[i] = (((GLuint) (rgba[i][BCOMP] * 255.0F)) << 24) - | (((GLuint) (rgba[i][GCOMP] * 255.0F)) << 16) - | (((GLuint) (rgba[i][RCOMP] * 255.0F)) << 8) - | (((GLuint) (rgba[i][ACOMP] * 255.0F)) ); + dst[i] = (IROUND(rgba[i][BCOMP] * 255.F) << 24) + | (IROUND(rgba[i][GCOMP] * 255.F) << 16) + | (IROUND(rgba[i][RCOMP] * 255.F) << 8) + | (IROUND(rgba[i][ACOMP] * 255.F) ); } } else if (dstFormat == GL_ABGR_EXT) { GLuint *dst = (GLuint *) dstAddr; for (i=0;i<n;i++) { - dst[i] = (((GLuint) (rgba[i][ACOMP] * 255.0F)) << 24) - | (((GLuint) (rgba[i][BCOMP] * 255.0F)) << 16) - | (((GLuint) (rgba[i][GCOMP] * 255.0F)) << 8) - | (((GLuint) (rgba[i][RCOMP] * 255.0F)) ); + dst[i] = (IROUND(rgba[i][ACOMP] * 255.F) << 24) + | (IROUND(rgba[i][BCOMP] * 255.F) << 16) + | (IROUND(rgba[i][GCOMP] * 255.F) << 8) + | (IROUND(rgba[i][RCOMP] * 255.F) ); } } break; @@ -2479,28 +2563,28 @@ _mesa_pack_rgba_span_float(GLcontext *ctx, GLuint n, GLfloat rgba[][4], if (dstFormat == GL_RGBA) { GLuint *dst = (GLuint *) dstAddr; for (i=0;i<n;i++) { - dst[i] = (((GLuint) (rgba[i][RCOMP] * 255.0F)) ) - | (((GLuint) (rgba[i][GCOMP] * 255.0F)) << 8) - | (((GLuint) (rgba[i][BCOMP] * 255.0F)) << 16) - | (((GLuint) (rgba[i][ACOMP] * 255.0F)) << 24); + dst[i] = (IROUND(rgba[i][RCOMP] * 255.0F) ) + | (IROUND(rgba[i][GCOMP] * 255.0F) << 8) + | (IROUND(rgba[i][BCOMP] * 255.0F) << 16) + | (IROUND(rgba[i][ACOMP] * 255.0F) << 24); } } else if (dstFormat == GL_BGRA) { GLuint *dst = (GLuint *) dstAddr; for (i=0;i<n;i++) { - dst[i] = (((GLuint) (rgba[i][BCOMP] * 255.0F)) ) - | (((GLuint) (rgba[i][GCOMP] * 255.0F)) << 8) - | (((GLuint) (rgba[i][RCOMP] * 255.0F)) << 16) - | (((GLuint) (rgba[i][ACOMP] * 255.0F)) << 24); + dst[i] = (IROUND(rgba[i][BCOMP] * 255.0F) ) + | (IROUND(rgba[i][GCOMP] * 255.0F) << 8) + | (IROUND(rgba[i][RCOMP] * 255.0F) << 16) + | (IROUND(rgba[i][ACOMP] * 255.0F) << 24); } } else if (dstFormat == GL_ABGR_EXT) { GLuint *dst = (GLuint *) dstAddr; for (i=0;i<n;i++) { - dst[i] = (((GLuint) (rgba[i][ACOMP] * 255.0F)) ) - | (((GLuint) (rgba[i][BCOMP] * 255.0F)) << 8) - | (((GLuint) (rgba[i][GCOMP] * 255.0F)) << 16) - | (((GLuint) (rgba[i][RCOMP] * 255.0F)) << 24); + dst[i] = (IROUND(rgba[i][ACOMP] * 255.0F) ) + | (IROUND(rgba[i][BCOMP] * 255.0F) << 8) + | (IROUND(rgba[i][GCOMP] * 255.0F) << 16) + | (IROUND(rgba[i][RCOMP] * 255.0F) << 24); } } break; @@ -2508,28 +2592,28 @@ _mesa_pack_rgba_span_float(GLcontext *ctx, GLuint n, GLfloat rgba[][4], if (dstFormat == GL_RGBA) { GLuint *dst = (GLuint *) dstAddr; for (i=0;i<n;i++) { - dst[i] = (((GLuint) (rgba[i][RCOMP] * 1023.0F)) << 22) - | (((GLuint) (rgba[i][GCOMP] * 1023.0F)) << 12) - | (((GLuint) (rgba[i][BCOMP] * 1023.0F)) << 2) - | (((GLuint) (rgba[i][ACOMP] * 3.0F)) ); + dst[i] = (IROUND(rgba[i][RCOMP] * 1023.0F) << 22) + | (IROUND(rgba[i][GCOMP] * 1023.0F) << 12) + | (IROUND(rgba[i][BCOMP] * 1023.0F) << 2) + | (IROUND(rgba[i][ACOMP] * 3.0F) ); } } else if (dstFormat == GL_BGRA) { GLuint *dst = (GLuint *) dstAddr; for (i=0;i<n;i++) { - dst[i] = (((GLuint) (rgba[i][BCOMP] * 1023.0F)) << 22) - | (((GLuint) (rgba[i][GCOMP] * 1023.0F)) << 12) - | (((GLuint) (rgba[i][RCOMP] * 1023.0F)) << 2) - | (((GLuint) (rgba[i][ACOMP] * 3.0F)) ); + dst[i] = (IROUND(rgba[i][BCOMP] * 1023.0F) << 22) + | (IROUND(rgba[i][GCOMP] * 1023.0F) << 12) + | (IROUND(rgba[i][RCOMP] * 1023.0F) << 2) + | (IROUND(rgba[i][ACOMP] * 3.0F) ); } } else if (dstFormat == GL_ABGR_EXT) { GLuint *dst = (GLuint *) dstAddr; for (i=0;i<n;i++) { - dst[i] = (((GLuint) (rgba[i][ACOMP] * 1023.0F)) << 22) - | (((GLuint) (rgba[i][BCOMP] * 1023.0F)) << 12) - | (((GLuint) (rgba[i][GCOMP] * 1023.0F)) << 2) - | (((GLuint) (rgba[i][RCOMP] * 3.0F)) ); + dst[i] = (IROUND(rgba[i][ACOMP] * 1023.0F) << 22) + | (IROUND(rgba[i][BCOMP] * 1023.0F) << 12) + | (IROUND(rgba[i][GCOMP] * 1023.0F) << 2) + | (IROUND(rgba[i][RCOMP] * 3.0F) ); } } break; @@ -2537,28 +2621,28 @@ _mesa_pack_rgba_span_float(GLcontext *ctx, GLuint n, GLfloat rgba[][4], if (dstFormat == GL_RGBA) { GLuint *dst = (GLuint *) dstAddr; for (i=0;i<n;i++) { - dst[i] = (((GLuint) (rgba[i][RCOMP] * 1023.0F)) ) - | (((GLuint) (rgba[i][GCOMP] * 1023.0F)) << 10) - | (((GLuint) (rgba[i][BCOMP] * 1023.0F)) << 20) - | (((GLuint) (rgba[i][ACOMP] * 3.0F)) << 30); + dst[i] = (IROUND(rgba[i][RCOMP] * 1023.0F) ) + | (IROUND(rgba[i][GCOMP] * 1023.0F) << 10) + | (IROUND(rgba[i][BCOMP] * 1023.0F) << 20) + | (IROUND(rgba[i][ACOMP] * 3.0F) << 30); } } else if (dstFormat == GL_BGRA) { GLuint *dst = (GLuint *) dstAddr; for (i=0;i<n;i++) { - dst[i] = (((GLuint) (rgba[i][BCOMP] * 1023.0F)) ) - | (((GLuint) (rgba[i][GCOMP] * 1023.0F)) << 10) - | (((GLuint) (rgba[i][RCOMP] * 1023.0F)) << 20) - | (((GLuint) (rgba[i][ACOMP] * 3.0F)) << 30); + dst[i] = (IROUND(rgba[i][BCOMP] * 1023.0F) ) + | (IROUND(rgba[i][GCOMP] * 1023.0F) << 10) + | (IROUND(rgba[i][RCOMP] * 1023.0F) << 20) + | (IROUND(rgba[i][ACOMP] * 3.0F) << 30); } } else if (dstFormat == GL_ABGR_EXT) { GLuint *dst = (GLuint *) dstAddr; for (i=0;i<n;i++) { - dst[i] = (((GLuint) (rgba[i][ACOMP] * 1023.0F)) ) - | (((GLuint) (rgba[i][BCOMP] * 1023.0F)) << 10) - | (((GLuint) (rgba[i][GCOMP] * 1023.0F)) << 20) - | (((GLuint) (rgba[i][RCOMP] * 3.0F)) << 30); + dst[i] = (IROUND(rgba[i][ACOMP] * 1023.0F) ) + | (IROUND(rgba[i][BCOMP] * 1023.0F) << 10) + | (IROUND(rgba[i][GCOMP] * 1023.0F) << 20) + | (IROUND(rgba[i][RCOMP] * 3.0F) << 30); } } break; @@ -2834,7 +2918,8 @@ extract_float_rgba(GLuint n, GLfloat rgba[][4], srcFormat == GL_BGR || srcFormat == GL_RGBA || srcFormat == GL_BGRA || - srcFormat == GL_ABGR_EXT); + srcFormat == GL_ABGR_EXT || + srcFormat == GL_DUDV_ATI); ASSERT(srcType == GL_UNSIGNED_BYTE || srcType == GL_BYTE || @@ -2949,6 +3034,13 @@ extract_float_rgba(GLuint n, GLfloat rgba[][4], aComp = 0; stride = 4; break; + case GL_DUDV_ATI: + redIndex = 0; + greenIndex = 1; + blueIndex = -1; + alphaIndex = -1; + stride = 2; + break; default: _mesa_problem(NULL, "bad srcFormat in extract float data"); return; @@ -3877,6 +3969,62 @@ _mesa_unpack_color_span_float( GLcontext *ctx, } } +/** + * Similar to _mesa_unpack_color_span_float(), but for dudv data instead of rgba, + * directly return GLbyte data, no transfer ops apply. + */ +void +_mesa_unpack_dudv_span_byte( GLcontext *ctx, + GLuint n, GLenum dstFormat, GLbyte dest[], + GLenum srcFormat, GLenum srcType, + const GLvoid *source, + const struct gl_pixelstore_attrib *srcPacking, + GLbitfield transferOps ) +{ + ASSERT(dstFormat == GL_DUDV_ATI); + ASSERT(srcFormat == GL_DUDV_ATI); + + ASSERT(srcType == GL_UNSIGNED_BYTE || + srcType == GL_BYTE || + srcType == GL_UNSIGNED_SHORT || + srcType == GL_SHORT || + srcType == GL_UNSIGNED_INT || + srcType == GL_INT || + srcType == GL_HALF_FLOAT_ARB || + srcType == GL_FLOAT); + + /* general solution */ + { + GLint dstComponents; + GLfloat rgba[MAX_WIDTH][4]; + GLbyte *dst = dest; + GLuint i; + + dstComponents = _mesa_components_in_format( dstFormat ); + /* source & dest image formats should have been error checked by now */ + assert(dstComponents > 0); + + /* + * Extract image data and convert to RGBA floats + */ + assert(n <= MAX_WIDTH); + extract_float_rgba(n, rgba, srcFormat, srcType, source, + srcPacking->SwapBytes); + + + /* Now determine which color channels we need to produce. + * And determine the dest index (offset) within each color tuple. + */ + + /* Now pack results in the requested dstFormat */ + for (i = 0; i < n; i++) { + /* not sure - need clamp[-1,1] here? */ + dst[0] = FLOAT_TO_BYTE(rgba[i][RCOMP]); + dst[1] = FLOAT_TO_BYTE(rgba[i][GCOMP]); + dst += dstComponents; + } + } +} /* * Unpack a row of color index data from a client buffer according to diff --git a/src/mesa/main/image.h b/src/mesa/main/image.h index 0e0bbd96d8..b26c27e5a8 100644 --- a/src/mesa/main/image.h +++ b/src/mesa/main/image.h @@ -198,6 +198,13 @@ _mesa_unpack_color_span_float( GLcontext *ctx, const struct gl_pixelstore_attrib *srcPacking, GLbitfield transferOps ); +extern void +_mesa_unpack_dudv_span_byte( GLcontext *ctx, + GLuint n, GLenum dstFormat, GLbyte dest[], + GLenum srcFormat, GLenum srcType, + const GLvoid *source, + const struct gl_pixelstore_attrib *srcPacking, + GLbitfield transferOps ); extern void _mesa_unpack_index_span( const GLcontext *ctx, GLuint n, diff --git a/src/mesa/main/imports.c b/src/mesa/main/imports.c index cb04594c1f..20b8342064 100644 --- a/src/mesa/main/imports.c +++ b/src/mesa/main/imports.c @@ -1011,7 +1011,7 @@ _mesa_warning( GLcontext *ctx, const char *fmtString, ... ) * Prints the message to stderr via fprintf(). * * \param ctx GL context. - * \param s problem description string. + * \param fmtString problem description string. */ void _mesa_problem( const GLcontext *ctx, const char *fmtString, ... ) diff --git a/src/mesa/main/imports.h b/src/mesa/main/imports.h index a421eb5e75..7b61e22e93 100644 --- a/src/mesa/main/imports.h +++ b/src/mesa/main/imports.h @@ -1,6 +1,6 @@ /* * Mesa 3-D graphics library - * Version: 7.1 + * Version: 7.5 * * Copyright (C) 1999-2008 Brian Paul All Rights Reserved. * @@ -36,10 +36,8 @@ #define IMPORTS_H -/* XXX some of the stuff in glheader.h should be moved into this file. - */ +#include "compiler.h" #include "glheader.h" -#include <GL/internal/glcore.h> #ifdef __cplusplus @@ -48,26 +46,6 @@ extern "C" { /**********************************************************************/ -/** \name General macros */ -/*@{*/ - -#ifndef NULL -#define NULL 0 -#endif - - -/** gcc -pedantic warns about long string literals, LONGSTRING silences that */ -#if !defined(__GNUC__) || (__GNUC__ < 2) || \ - ((__GNUC__ == 2) && (__GNUC_MINOR__ <= 7)) -# define LONGSTRING -#else -# define LONGSTRING __extension__ -#endif - -/*@}*/ - - -/**********************************************************************/ /** Memory macros */ /*@{*/ @@ -130,49 +108,11 @@ typedef union { GLfloat f; GLint i; } fi_type; #define MAX_GLUSHORT 0xffff #define MAX_GLUINT 0xffffffff -#ifndef M_PI -#define M_PI (3.1415926536) -#endif - -#ifndef M_E -#define M_E (2.7182818284590452354) -#endif - -#ifndef ONE_DIV_LN2 -#define ONE_DIV_LN2 (1.442695040888963456) -#endif - -#ifndef ONE_DIV_SQRT_LN2 -#define ONE_DIV_SQRT_LN2 (1.201122408786449815) -#endif - -#ifndef FLT_MAX_EXP -#define FLT_MAX_EXP 128 -#endif - /* Degrees to radians conversion: */ #define DEG2RAD (M_PI/180.0) /*** - *** USE_IEEE: Determine if we're using IEEE floating point - ***/ -#if defined(__i386__) || defined(__386__) || defined(__sparc__) || \ - defined(__s390x__) || defined(__powerpc__) || \ - defined(__x86_64__) || \ - defined(ia64) || defined(__ia64__) || \ - defined(__hppa__) || defined(hpux) || \ - defined(__mips) || defined(_MIPS_ARCH) || \ - defined(__arm__) || \ - defined(__sh__) || defined(__m32r__) || \ - (defined(__sun) && defined(_IEEE_754)) || \ - (defined(__alpha__) && (defined(__IEEE_FLOAT) || !defined(VMS))) -#define USE_IEEE -#define IEEE_ONE 0x3f800000 -#endif - - -/*** *** SQRTF: single-precision square root ***/ #if 0 /* _mesa_sqrtf() not accurate enough - temporarily disabled */ @@ -316,16 +256,9 @@ static INLINE int GET_FLOAT_BITS( float x ) /*** *** IROUND: return (as an integer) float rounded to nearest integer ***/ -#if defined(USE_SPARC_ASM) && defined(__GNUC__) && defined(__sparc__) -static INLINE int iround(float f) -{ - int r; - __asm__ ("fstoi %1, %0" : "=f" (r) : "f" (f)); - return r; -} -#define IROUND(x) iround(x) -#elif defined(USE_X86_ASM) && defined(__GNUC__) && defined(__i386__) && \ - (!defined(__BEOS__) || (__GNUC__ > 2 || (__GNUC__ == 2 && __GNUC_MINOR__ >= 95))) +#if defined(USE_X86_ASM) && defined(__GNUC__) && defined(__i386__) && \ + (!(defined(__BEOS__) || defined(__HAIKU__)) || \ + (__GNUC__ > 2 || (__GNUC__ == 2 && __GNUC_MINOR__ >= 95))) static INLINE int iround(float f) { int r; @@ -508,113 +441,6 @@ _mesa_is_pow_two(int x) #endif -/*** - *** START_FAST_MATH: Set x86 FPU to faster, 32-bit precision mode (and save - *** original mode to a temporary). - *** END_FAST_MATH: Restore x86 FPU to original mode. - ***/ -#if defined(__GNUC__) && defined(__i386__) -/* - * Set the x86 FPU control word to guarentee only 32 bits of precision - * are stored in registers. Allowing the FPU to store more introduces - * differences between situations where numbers are pulled out of memory - * vs. situations where the compiler is able to optimize register usage. - * - * In the worst case, we force the compiler to use a memory access to - * truncate the float, by specifying the 'volatile' keyword. - */ -/* Hardware default: All exceptions masked, extended double precision, - * round to nearest (IEEE compliant): - */ -#define DEFAULT_X86_FPU 0x037f -/* All exceptions masked, single precision, round to nearest: - */ -#define FAST_X86_FPU 0x003f -/* The fldcw instruction will cause any pending FP exceptions to be - * raised prior to entering the block, and we clear any pending - * exceptions before exiting the block. Hence, asm code has free - * reign over the FPU while in the fast math block. - */ -#if defined(NO_FAST_MATH) -#define START_FAST_MATH(x) \ -do { \ - static GLuint mask = DEFAULT_X86_FPU; \ - __asm__ ( "fnstcw %0" : "=m" (*&(x)) ); \ - __asm__ ( "fldcw %0" : : "m" (mask) ); \ -} while (0) -#else -#define START_FAST_MATH(x) \ -do { \ - static GLuint mask = FAST_X86_FPU; \ - __asm__ ( "fnstcw %0" : "=m" (*&(x)) ); \ - __asm__ ( "fldcw %0" : : "m" (mask) ); \ -} while (0) -#endif -/* Restore original FPU mode, and clear any exceptions that may have - * occurred in the FAST_MATH block. - */ -#define END_FAST_MATH(x) \ -do { \ - __asm__ ( "fnclex ; fldcw %0" : : "m" (*&(x)) ); \ -} while (0) - -#elif defined(__WATCOMC__) && defined(__386__) -#define DEFAULT_X86_FPU 0x037f /* See GCC comments above */ -#define FAST_X86_FPU 0x003f /* See GCC comments above */ -void _watcom_start_fast_math(unsigned short *x,unsigned short *mask); -#pragma aux _watcom_start_fast_math = \ - "fnstcw word ptr [eax]" \ - "fldcw word ptr [ecx]" \ - parm [eax] [ecx] \ - modify exact []; -void _watcom_end_fast_math(unsigned short *x); -#pragma aux _watcom_end_fast_math = \ - "fnclex" \ - "fldcw word ptr [eax]" \ - parm [eax] \ - modify exact []; -#if defined(NO_FAST_MATH) -#define START_FAST_MATH(x) \ -do { \ - static GLushort mask = DEFAULT_X86_FPU; \ - _watcom_start_fast_math(&x,&mask); \ -} while (0) -#else -#define START_FAST_MATH(x) \ -do { \ - static GLushort mask = FAST_X86_FPU; \ - _watcom_start_fast_math(&x,&mask); \ -} while (0) -#endif -#define END_FAST_MATH(x) _watcom_end_fast_math(&x) - -#elif defined(_MSC_VER) && defined(_M_IX86) -#define DEFAULT_X86_FPU 0x037f /* See GCC comments above */ -#define FAST_X86_FPU 0x003f /* See GCC comments above */ -#if defined(NO_FAST_MATH) -#define START_FAST_MATH(x) do {\ - static GLuint mask = DEFAULT_X86_FPU;\ - __asm fnstcw word ptr [x]\ - __asm fldcw word ptr [mask]\ -} while(0) -#else -#define START_FAST_MATH(x) do {\ - static GLuint mask = FAST_X86_FPU;\ - __asm fnstcw word ptr [x]\ - __asm fldcw word ptr [mask]\ -} while(0) -#endif -#define END_FAST_MATH(x) do {\ - __asm fnclex\ - __asm fldcw word ptr [x]\ -} while(0) - -#else -#define START_FAST_MATH(x) x = 0 -#define END_FAST_MATH(x) (void)(x) -#endif - - /** * Return 1 if this is a little endian machine, 0 if big endian. */ diff --git a/src/mesa/main/macros.h b/src/mesa/main/macros.h index 2630855a0e..bfd740870e 100644 --- a/src/mesa/main/macros.h +++ b/src/mesa/main/macros.h @@ -54,13 +54,16 @@ extern GLfloat _mesa_ubyte_to_float_color_tab[256]; #define FLOAT_TO_BYTE(X) ( (((GLint) (255.0F * (X))) - 1) / 2 ) -/** Convert GLushort in [0,65536] to GLfloat in [0.0,1.0] */ +/** Convert GLushort in [0,65535] to GLfloat in [0.0,1.0] */ #define USHORT_TO_FLOAT(S) ((GLfloat) (S) * (1.0F / 65535.0F)) +/** Convert GLfloat in [0.0,1.0] to GLushort in [0, 65535] */ +#define FLOAT_TO_USHORT(X) ((GLuint) ((X) * 65535.0)) + /** Convert GLshort in [-32768,32767] to GLfloat in [-1.0,1.0] */ #define SHORT_TO_FLOAT(S) ((2.0F * (S) + 1.0F) * (1.0F/65535.0F)) -/** Convert GLfloat in [0.0,1.0] to GLshort in [-32768,32767] */ +/** Convert GLfloat in [-1.0,1.0] to GLshort in [-32768,32767] */ #define FLOAT_TO_SHORT(X) ( (((GLint) (65535.0F * (X))) - 1) / 2 ) diff --git a/src/mesa/main/matrix.c b/src/mesa/main/matrix.c index 0f96f94909..aebf48134f 100644 --- a/src/mesa/main/matrix.c +++ b/src/mesa/main/matrix.c @@ -1,8 +1,9 @@ /* * Mesa 3-D graphics library - * Version: 6.5.3 + * Version: 7.5 * - * Copyright (C) 1999-2007 Brian Paul All Rights Reserved. + * Copyright (C) 1999-2008 Brian Paul All Rights Reserved. + * Copyright (C) 2009 VMware, Inc. 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"), @@ -42,7 +43,6 @@ #include "matrix.h" #include "mtypes.h" #include "math/m_matrix.h" -#include "math/m_xform.h" /** @@ -536,120 +536,6 @@ _mesa_MultTransposeMatrixdARB( const GLdouble *m ) } #endif -/** - * Set the viewport. - * - * \param x, y coordinates of the lower-left corner of the viewport rectangle. - * \param width width of the viewport rectangle. - * \param height height of the viewport rectangle. - * - * \sa Called via glViewport() or display list execution. - * - * Flushes the vertices and calls _mesa_set_viewport() with the given - * parameters. - */ -void GLAPIENTRY -_mesa_Viewport( GLint x, GLint y, GLsizei width, GLsizei height ) -{ - GET_CURRENT_CONTEXT(ctx); - ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx); - _mesa_set_viewport(ctx, x, y, width, height); -} - - -/** - * Set new viewport parameters and update derived state (the _WindowMap - * matrix). Usually called from _mesa_Viewport(). - * - * \param ctx GL context. - * \param x, y coordinates of the lower left corner of the viewport rectangle. - * \param width width of the viewport rectangle. - * \param height height of the viewport rectangle. - */ -void -_mesa_set_viewport( GLcontext *ctx, GLint x, GLint y, - GLsizei width, GLsizei height ) -{ - if (MESA_VERBOSE & VERBOSE_API) - _mesa_debug(ctx, "glViewport %d %d %d %d\n", x, y, width, height); - - if (width < 0 || height < 0) { - _mesa_error( ctx, GL_INVALID_VALUE, - "glViewport(%d, %d, %d, %d)", x, y, width, height ); - return; - } - - /* clamp width and height to the implementation dependent range */ - width = CLAMP(width, 1, (GLsizei) ctx->Const.MaxViewportWidth); - height = CLAMP(height, 1, (GLsizei) ctx->Const.MaxViewportHeight); - - ctx->Viewport.X = x; - ctx->Viewport.Width = width; - ctx->Viewport.Y = y; - ctx->Viewport.Height = height; - ctx->NewState |= _NEW_VIEWPORT; - -#if 1 - /* XXX remove this someday. Currently the DRI drivers rely on - * the WindowMap matrix being up to date in the driver's Viewport - * and DepthRange functions. - */ - _math_matrix_viewport(&ctx->Viewport._WindowMap, - ctx->Viewport.X, ctx->Viewport.Y, - ctx->Viewport.Width, ctx->Viewport.Height, - ctx->Viewport.Near, ctx->Viewport.Far, - ctx->DrawBuffer->_DepthMaxF); -#endif - - if (ctx->Driver.Viewport) { - /* Many drivers will use this call to check for window size changes - * and reallocate the z/stencil/accum/etc buffers if needed. - */ - (*ctx->Driver.Viewport)( ctx, x, y, width, height ); - } -} - - -#if _HAVE_FULL_GL -/** - * Called by glDepthRange - * - * \param nearval specifies the Z buffer value which should correspond to - * the near clip plane - * \param farval specifies the Z buffer value which should correspond to - * the far clip plane - */ -void GLAPIENTRY -_mesa_DepthRange( GLclampd nearval, GLclampd farval ) -{ - GET_CURRENT_CONTEXT(ctx); - ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx); - - if (MESA_VERBOSE&VERBOSE_API) - _mesa_debug(ctx, "glDepthRange %f %f\n", nearval, farval); - - ctx->Viewport.Near = (GLfloat) CLAMP( nearval, 0.0, 1.0 ); - ctx->Viewport.Far = (GLfloat) CLAMP( farval, 0.0, 1.0 ); - ctx->NewState |= _NEW_VIEWPORT; - -#if 1 - /* XXX remove this someday. Currently the DRI drivers rely on - * the WindowMap matrix being up to date in the driver's Viewport - * and DepthRange functions. - */ - _math_matrix_viewport(&ctx->Viewport._WindowMap, - ctx->Viewport.X, ctx->Viewport.Y, - ctx->Viewport.Width, ctx->Viewport.Height, - ctx->Viewport.Near, ctx->Viewport.Far, - ctx->DrawBuffer->_DepthMaxF); -#endif - - if (ctx->Driver.DepthRange) { - (*ctx->Driver.DepthRange)( ctx, nearval, farval ); - } -} -#endif - /**********************************************************************/ @@ -893,41 +779,4 @@ void _mesa_init_transform( GLcontext *ctx ) } -/** - * Initialize the context viewport attribute group. - * - * \param ctx GL context. - * - * \todo Move this to a new file with other 'viewport' routines. - */ -void _mesa_init_viewport( GLcontext *ctx ) -{ - GLfloat depthMax = 65535.0F; /* sorf of arbitrary */ - - /* Viewport group */ - ctx->Viewport.X = 0; - ctx->Viewport.Y = 0; - ctx->Viewport.Width = 0; - ctx->Viewport.Height = 0; - ctx->Viewport.Near = 0.0; - ctx->Viewport.Far = 1.0; - _math_matrix_ctr(&ctx->Viewport._WindowMap); - - _math_matrix_viewport(&ctx->Viewport._WindowMap, 0, 0, 0, 0, - 0.0F, 1.0F, depthMax); -} - - -/** - * Free the context viewport attribute group data. - * - * \param ctx GL context. - * - * \todo Move this to a new file with other 'viewport' routines. - */ -void _mesa_free_viewport_data( GLcontext *ctx ) -{ - _math_matrix_dtr(&ctx->Viewport._WindowMap); -} - /*@}*/ diff --git a/src/mesa/main/matrix.h b/src/mesa/main/matrix.h index 38769867a7..a53d1045c7 100644 --- a/src/mesa/main/matrix.h +++ b/src/mesa/main/matrix.h @@ -1,13 +1,9 @@ -/** - * \file matrix.h - * Matrix operations. - */ - /* * Mesa 3-D graphics library - * Version: 3.5 + * Version: 7.5 * - * Copyright (C) 1999-2001 Brian Paul All Rights Reserved. + * Copyright (C) 1999-2008 Brian Paul All Rights Reserved. + * Copyright (C) 2009 VMware, Inc. 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"), @@ -99,15 +95,6 @@ _mesa_MultTransposeMatrixfARB( const GLfloat *m ); extern void GLAPIENTRY _mesa_MultTransposeMatrixdARB( const GLdouble *m ); -extern void GLAPIENTRY -_mesa_Viewport( GLint x, GLint y, GLsizei width, GLsizei height ); - -extern void -_mesa_set_viewport( GLcontext *ctx, GLint x, GLint y, GLsizei width, GLsizei height ); - -extern void GLAPIENTRY -_mesa_DepthRange( GLclampd nearval, GLclampd farval ); - extern void _mesa_init_matrix( GLcontext * ctx ); @@ -115,16 +102,10 @@ _mesa_init_matrix( GLcontext * ctx ); extern void _mesa_init_transform( GLcontext *ctx ); -extern void -_mesa_init_viewport( GLcontext *ctx ); - extern void _mesa_free_matrix_data( GLcontext *ctx ); extern void -_mesa_free_viewport_data( GLcontext *ctx ); - -extern void _mesa_update_modelview_project( GLcontext *ctx, GLuint newstate ); diff --git a/src/mesa/main/mfeatures.h b/src/mesa/main/mfeatures.h index 8fb32dd7e9..f570647942 100644 --- a/src/mesa/main/mfeatures.h +++ b/src/mesa/main/mfeatures.h @@ -75,7 +75,6 @@ #define FEATURE_EXT_texture_sRGB _HAVE_FULL_GL #define FEATURE_EXT_timer_query _HAVE_FULL_GL #define FEATURE_ATI_fragment_shader _HAVE_FULL_GL -#define FEATURE_MESA_program_debug _HAVE_FULL_GL #define FEATURE_NV_fence _HAVE_FULL_GL #define FEATURE_NV_fragment_program _HAVE_FULL_GL #define FEATURE_NV_vertex_program _HAVE_FULL_GL diff --git a/src/mesa/main/mipmap.c b/src/mesa/main/mipmap.c index 3dd4b3391b..4a79430c34 100644 --- a/src/mesa/main/mipmap.c +++ b/src/mesa/main/mipmap.c @@ -85,7 +85,7 @@ bytes_per_pixel(GLenum datatype, GLuint comps) rowC[j][e], rowC[k][e], \ rowD[j][e], rowD[k][e]); \ } while(0) - + #define FILTER_F_3D(e) \ do { \ dst[i][e] = (rowA[j][e] + rowA[k][e] \ @@ -226,7 +226,6 @@ do_row(GLenum datatype, GLuint comps, GLint srcWidth, dst[i] = (rowA[j] + rowA[k] + rowB[j] + rowB[k]) / 4; } } - else if (datatype == GL_FLOAT && comps == 4) { GLuint i, j, k; const GLfloat(*rowA)[4] = (const GLfloat(*)[4]) srcRowA; @@ -471,6 +470,17 @@ do_row(GLenum datatype, GLuint comps, GLint srcWidth, dst[i] = (blue << 5) | (green << 2) | red; } } + else if (datatype == GL_BYTE && comps == 2) { + GLuint i, j, k; + const GLbyte(*rowA)[2] = (const GLbyte(*)[2]) srcRowA; + const GLbyte(*rowB)[2] = (const GLbyte(*)[2]) srcRowB; + GLbyte(*dst)[2] = (GLbyte(*)[2]) dstRow; + for (i = j = 0, k = k0; i < (GLuint) dstWidth; + i++, j += colStride, k += colStride) { + dst[i][0] = (rowA[j][0] + rowA[k][0] + rowB[j][0] + rowB[k][0]) >> 2; + dst[i][1] = (rowA[j][1] + rowA[k][1] + rowB[j][1] + rowB[k][1]) >> 2; + } + } else { _mesa_problem(NULL, "bad format in do_row()"); } @@ -1176,7 +1186,7 @@ make_1d_stack_mipmap(GLenum datatype, GLuint comps, GLint border, /** - * \bugs + * \bug * There is quite a bit of refactoring that could be done with this function * and \c make_2d_mipmap. */ diff --git a/src/mesa/main/mtypes.h b/src/mesa/main/mtypes.h index be982afe39..5293009454 100644 --- a/src/mesa/main/mtypes.h +++ b/src/mesa/main/mtypes.h @@ -1,9 +1,9 @@ /* * Mesa 3-D graphics library - * Version: 7.3 + * Version: 7.5 * - * Copyright (C) 1999-2007 Brian Paul All Rights Reserved. - * Copyright (C) 1999-2008 VMware, Inc. All Rights Reserved. + * Copyright (C) 1999-2008 Brian Paul All Rights Reserved. + * Copyright (C) 2009 VMware, Inc. 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"), @@ -30,22 +30,16 @@ * Please try to mark derived values with a leading underscore ('_'). */ -#ifndef TYPES_H -#define TYPES_H +#ifndef MTYPES_H +#define MTYPES_H -#include "glheader.h" -#include <GL/internal/glcore.h> /* __GLcontextModes (GLvisual) */ -#include "config.h" /* Hardwired parameters */ +#include "main/glheader.h" +#include "main/config.h" +#include "main/compiler.h" +#include "main/mfeatures.h" #include "glapi/glapi.h" #include "math/m_matrix.h" /* GLmatrix */ -#include "bitset.h" - - -/** - * Special, internal token - */ -#define GL_SHADER_PROGRAM_MESA 0x9999 /** @@ -84,49 +78,17 @@ /** - * Fixed point data type. - */ -typedef int GLfixed; -/* - * Fixed point arithmetic macros - */ -#ifndef FIXED_FRAC_BITS -#define FIXED_FRAC_BITS 11 -#endif - -#define FIXED_SHIFT FIXED_FRAC_BITS -#define FIXED_ONE (1 << FIXED_SHIFT) -#define FIXED_HALF (1 << (FIXED_SHIFT-1)) -#define FIXED_FRAC_MASK (FIXED_ONE - 1) -#define FIXED_INT_MASK (~FIXED_FRAC_MASK) -#define FIXED_EPSILON 1 -#define FIXED_SCALE ((float) FIXED_ONE) -#define FIXED_DBL_SCALE ((double) FIXED_ONE) -#define FloatToFixed(X) (IROUND((X) * FIXED_SCALE)) -#define FixedToDouble(X) ((X) * (1.0 / FIXED_DBL_SCALE)) -#define IntToFixed(I) ((I) << FIXED_SHIFT) -#define FixedToInt(X) ((X) >> FIXED_SHIFT) -#define FixedToUns(X) (((unsigned int)(X)) >> FIXED_SHIFT) -#define FixedCeil(X) (((X) + FIXED_ONE - FIXED_EPSILON) & FIXED_INT_MASK) -#define FixedFloor(X) ((X) & FIXED_INT_MASK) -#define FixedToFloat(X) ((X) * (1.0F / FIXED_SCALE)) -#define PosFloatToFixed(X) FloatToFixed(X) -#define SignedFloatToFixed(X) FloatToFixed(X) - - - -/** * \name Some forward type declarations */ /*@{*/ struct _mesa_HashTable; +struct gl_attrib_node; struct gl_pixelstore_attrib; struct gl_program_cache; struct gl_texture_format; struct gl_texture_image; struct gl_texture_object; struct st_context; -struct pipe_surface; typedef struct __GLcontextRec GLcontext; typedef struct __GLcontextModesRec GLvisual; typedef struct gl_framebuffer GLframebuffer; @@ -141,7 +103,7 @@ typedef struct gl_framebuffer GLframebuffer; * In GL_ARB_vertex_shader / OpenGL 2.0 the aliasing is disallowed (the * generic attributes are distinct/separate). */ -enum +typedef enum { VERT_ATTRIB_POS = 0, VERT_ATTRIB_WEIGHT = 1, @@ -177,7 +139,7 @@ enum VERT_ATTRIB_GENERIC14 = 30, VERT_ATTRIB_GENERIC15 = 31, VERT_ATTRIB_MAX = 32 -}; +} gl_vert_attrib; /** * Bitflags for vertex attributes. @@ -225,32 +187,33 @@ enum /** * Indexes for vertex program result attributes */ -/*@{*/ -#define VERT_RESULT_HPOS 0 -#define VERT_RESULT_COL0 1 -#define VERT_RESULT_COL1 2 -#define VERT_RESULT_FOGC 3 -#define VERT_RESULT_TEX0 4 -#define VERT_RESULT_TEX1 5 -#define VERT_RESULT_TEX2 6 -#define VERT_RESULT_TEX3 7 -#define VERT_RESULT_TEX4 8 -#define VERT_RESULT_TEX5 9 -#define VERT_RESULT_TEX6 10 -#define VERT_RESULT_TEX7 11 -#define VERT_RESULT_PSIZ 12 -#define VERT_RESULT_BFC0 13 -#define VERT_RESULT_BFC1 14 -#define VERT_RESULT_EDGE 15 -#define VERT_RESULT_VAR0 16 /**< shader varying */ -#define VERT_RESULT_MAX (VERT_RESULT_VAR0 + MAX_VARYING) -/*@}*/ +typedef enum +{ + VERT_RESULT_HPOS = 0, + VERT_RESULT_COL0 = 1, + VERT_RESULT_COL1 = 2, + VERT_RESULT_FOGC = 3, + VERT_RESULT_TEX0 = 4, + VERT_RESULT_TEX1 = 5, + VERT_RESULT_TEX2 = 6, + VERT_RESULT_TEX3 = 7, + VERT_RESULT_TEX4 = 8, + VERT_RESULT_TEX5 = 9, + VERT_RESULT_TEX6 = 10, + VERT_RESULT_TEX7 = 11, + VERT_RESULT_PSIZ = 12, + VERT_RESULT_BFC0 = 13, + VERT_RESULT_BFC1 = 14, + VERT_RESULT_EDGE = 15, + VERT_RESULT_VAR0 = 16 /**< shader varying */, + VERT_RESULT_MAX = (VERT_RESULT_VAR0 + MAX_VARYING) +} gl_vert_result; /** * Indexes for fragment program input attributes. */ -enum +typedef enum { FRAG_ATTRIB_WPOS = 0, FRAG_ATTRIB_COL0 = 1, @@ -266,7 +229,7 @@ enum FRAG_ATTRIB_TEX7 = 11, FRAG_ATTRIB_VAR0 = 12, /**< shader varying */ FRAG_ATTRIB_MAX = (FRAG_ATTRIB_VAR0 + MAX_VARYING) -}; +} gl_frag_attrib; /** * Bitflags for fragment program input attributes. @@ -303,41 +266,41 @@ enum /** * Fragment program results */ -enum +typedef enum { - FRAG_RESULT_COLR = 0, - FRAG_RESULT_COLH = 1, - FRAG_RESULT_DEPR = 2, - FRAG_RESULT_DATA0 = 3, + FRAG_RESULT_DEPTH = 0, + FRAG_RESULT_COLOR = 1, + FRAG_RESULT_DATA0 = 2, FRAG_RESULT_MAX = (FRAG_RESULT_DATA0 + MAX_DRAW_BUFFERS) -}; +} gl_frag_result; /** * Indexes for all renderbuffers */ -enum { - BUFFER_FRONT_LEFT = 0, /* the four standard color buffers */ - BUFFER_BACK_LEFT = 1, - BUFFER_FRONT_RIGHT = 2, - BUFFER_BACK_RIGHT = 3, - BUFFER_AUX0 = 4, /* optional aux buffer */ - BUFFER_AUX1 = 5, - BUFFER_AUX2 = 6, - BUFFER_AUX3 = 7, - BUFFER_DEPTH = 8, - BUFFER_STENCIL = 9, - BUFFER_ACCUM = 10, - BUFFER_COLOR0 = 11, /* generic renderbuffers */ - BUFFER_COLOR1 = 12, - BUFFER_COLOR2 = 13, - BUFFER_COLOR3 = 14, - BUFFER_COLOR4 = 15, - BUFFER_COLOR5 = 16, - BUFFER_COLOR6 = 17, - BUFFER_COLOR7 = 18, - BUFFER_COUNT = 19 -}; +typedef enum +{ + /* the four standard color buffers */ + BUFFER_FRONT_LEFT, + BUFFER_BACK_LEFT, + BUFFER_FRONT_RIGHT, + BUFFER_BACK_RIGHT, + BUFFER_DEPTH, + BUFFER_STENCIL, + BUFFER_ACCUM, + /* optional aux buffer */ + BUFFER_AUX0, + /* generic renderbuffers */ + BUFFER_COLOR0, + BUFFER_COLOR1, + BUFFER_COLOR2, + BUFFER_COLOR3, + BUFFER_COLOR4, + BUFFER_COLOR5, + BUFFER_COLOR6, + BUFFER_COLOR7, + BUFFER_COUNT +} gl_buffer_index; /** * Bit flags for all renderbuffers @@ -370,9 +333,6 @@ enum { BUFFER_BIT_FRONT_RIGHT | \ BUFFER_BIT_BACK_RIGHT | \ BUFFER_BIT_AUX0 | \ - BUFFER_BIT_AUX1 | \ - BUFFER_BIT_AUX2 | \ - BUFFER_BIT_AUX3 | \ BUFFER_BIT_COLOR0 | \ BUFFER_BIT_COLOR1 | \ BUFFER_BIT_COLOR2 | \ @@ -384,12 +344,13 @@ enum { /** The pixel transfer path has three color tables: */ -/*@{*/ -#define COLORTABLE_PRECONVOLUTION 0 -#define COLORTABLE_POSTCONVOLUTION 1 -#define COLORTABLE_POSTCOLORMATRIX 2 -#define COLORTABLE_MAX 3 -/*@}*/ +typedef enum +{ + COLORTABLE_PRECONVOLUTION, + COLORTABLE_POSTCONVOLUTION, + COLORTABLE_POSTCOLORMATRIX, + COLORTABLE_MAX +} gl_colortable_index; /** @@ -626,9 +587,7 @@ struct gl_current_attrib * \note Index and Edgeflag current values are stored as floats in the * SIX and SEVEN attribute slots. */ - /*@{*/ GLfloat Attrib[VERT_ATTRIB_MAX][4]; /**< Position, color, texcoords, etc */ - /*@}*/ /** * \name Current raster position attributes (always valid). @@ -661,84 +620,6 @@ struct gl_depthbuffer_attrib /** - * glEnable()/glDisable() attribute group (GL_ENABLE_BIT). - */ -struct gl_enable_attrib -{ - GLboolean AlphaTest; - GLboolean AutoNormal; - GLboolean Blend; - GLbitfield ClipPlanes; - GLboolean ColorMaterial; - GLboolean ColorTable[COLORTABLE_MAX]; - GLboolean Convolution1D; - GLboolean Convolution2D; - GLboolean Separable2D; - GLboolean CullFace; - GLboolean DepthTest; - GLboolean Dither; - GLboolean Fog; - GLboolean Histogram; - GLboolean Light[MAX_LIGHTS]; - GLboolean Lighting; - GLboolean LineSmooth; - GLboolean LineStipple; - GLboolean IndexLogicOp; - GLboolean ColorLogicOp; - GLboolean Map1Color4; - GLboolean Map1Index; - GLboolean Map1Normal; - GLboolean Map1TextureCoord1; - GLboolean Map1TextureCoord2; - GLboolean Map1TextureCoord3; - GLboolean Map1TextureCoord4; - GLboolean Map1Vertex3; - GLboolean Map1Vertex4; - GLboolean Map1Attrib[16]; /* GL_NV_vertex_program */ - GLboolean Map2Color4; - GLboolean Map2Index; - GLboolean Map2Normal; - GLboolean Map2TextureCoord1; - GLboolean Map2TextureCoord2; - GLboolean Map2TextureCoord3; - GLboolean Map2TextureCoord4; - GLboolean Map2Vertex3; - GLboolean Map2Vertex4; - GLboolean Map2Attrib[16]; /* GL_NV_vertex_program */ - GLboolean MinMax; - GLboolean Normalize; - GLboolean PixelTexture; - GLboolean PointSmooth; - GLboolean PolygonOffsetPoint; - GLboolean PolygonOffsetLine; - GLboolean PolygonOffsetFill; - GLboolean PolygonSmooth; - GLboolean PolygonStipple; - GLboolean RescaleNormals; - GLboolean Scissor; - GLboolean Stencil; - GLboolean StencilTwoSide; /* GL_EXT_stencil_two_side */ - GLboolean MultisampleEnabled; /* GL_ARB_multisample */ - GLboolean SampleAlphaToCoverage; /* GL_ARB_multisample */ - GLboolean SampleAlphaToOne; /* GL_ARB_multisample */ - GLboolean SampleCoverage; /* GL_ARB_multisample */ - GLboolean SampleCoverageInvert; /* GL_ARB_multisample */ - GLboolean RasterPositionUnclipped; /* GL_IBM_rasterpos_clip */ - GLuint Texture[MAX_TEXTURE_UNITS]; - GLuint TexGen[MAX_TEXTURE_UNITS]; - /* SGI_texture_color_table */ - GLboolean TextureColorTable[MAX_TEXTURE_UNITS]; - /* GL_ARB_vertex_program / GL_NV_vertex_program */ - GLboolean VertexProgram; - GLboolean VertexProgramPointSize; - GLboolean VertexProgramTwoSide; - /* GL_ARB_point_sprite / GL_NV_point_sprite */ - GLboolean PointSprite; - GLboolean FragmentShaderATI; -}; - - -/** * Evaluator attribute group (GL_EVAL_BIT). */ struct gl_eval_attrib @@ -825,11 +706,11 @@ struct gl_hint_attrib */ struct gl_histogram_attrib { - GLuint Width; /**< number of table entries */ - GLint Format; /**< GL_ALPHA, GL_RGB, etc */ - GLuint Count[HISTOGRAM_TABLE_SIZE][4]; /**< the histogram */ - GLboolean Sink; /**< terminate image transfer? */ - GLubyte RedSize; /**< Bits per counter */ + GLuint Width; /**< number of table entries */ + GLint Format; /**< GL_ALPHA, GL_RGB, etc */ + GLuint Count[HISTOGRAM_TABLE_SIZE][4]; /**< the histogram */ + GLboolean Sink; /**< terminate image transfer? */ + GLubyte RedSize; /**< Bits per counter */ GLubyte GreenSize; GLubyte BlueSize; GLubyte AlphaSize; @@ -1008,13 +889,15 @@ struct gl_pixel_attrib /*--- Begin Pixel Transfer State ---*/ /* Fields are in the order in which they're applied... */ - /* Scale & Bias (index shift, offset) */ + /** Scale & Bias (index shift, offset) */ + /*@{*/ GLfloat RedBias, RedScale; GLfloat GreenBias, GreenScale; GLfloat BlueBias, BlueScale; GLfloat AlphaBias, AlphaScale; GLfloat DepthBias, DepthScale; GLint IndexShift, IndexOffset; + /*@}*/ /* Pixel Maps */ /* Note: actual pixel maps are not part of this attrib group */ @@ -1030,7 +913,7 @@ struct gl_pixel_attrib GLboolean Convolution1DEnabled; GLboolean Convolution2DEnabled; GLboolean Separable2DEnabled; - GLfloat ConvolutionBorderColor[3][4]; + GLfloat ConvolutionBorderColor[3][4]; /**< RGBA */ GLenum ConvolutionBorderMode[3]; GLfloat ConvolutionFilterScale[3][4]; /**< RGBA */ GLfloat ConvolutionFilterBias[3][4]; /**< RGBA */ @@ -1049,12 +932,12 @@ struct gl_pixel_attrib /*--- End Pixel Transfer State ---*/ - /* Pixel Zoom */ + /** glPixelZoom */ GLfloat ZoomX, ZoomY; /** GL_SGI_texture_color_table */ - GLfloat TextureColorTableScale[4]; - GLfloat TextureColorTableBias[4]; + GLfloat TextureColorTableScale[4]; /**< RGBA */ + GLfloat TextureColorTableBias[4]; /**< RGBA */ }; @@ -1129,8 +1012,9 @@ struct gl_stencil_attrib GLboolean Enabled; /**< Enabled flag */ GLboolean TestTwoSide; /**< GL_EXT_stencil_two_side */ GLubyte ActiveFace; /**< GL_EXT_stencil_two_side (0 or 2) */ + GLboolean _Enabled; /**< Enabled and stencil buffer present */ GLboolean _TestTwoSide; - GLubyte _BackFace; + GLubyte _BackFace; /**< Current back stencil state (1 or 2) */ GLenum Function[3]; /**< Stencil function */ GLenum FailFunc[3]; /**< Fail function */ GLenum ZPassFunc[3]; /**< Depth buffer pass function */ @@ -1142,34 +1026,36 @@ struct gl_stencil_attrib }; -/** 1D, 2D, 3D, CUBE, RECT, 1D_ARRAY, and 2D_ARRAY targets */ -#define NUM_TEXTURE_TARGETS 7 - /** - * An index for each type of texture object + * An index for each type of texture object. These correspond to the GL + * target target enums, such as GL_TEXTURE_2D, GL_TEXTURE_CUBE_MAP, etc. + * Note: the order is from highest priority to lowest priority. */ -/*@{*/ -#define TEXTURE_1D_INDEX 0 -#define TEXTURE_2D_INDEX 1 -#define TEXTURE_3D_INDEX 2 -#define TEXTURE_CUBE_INDEX 3 -#define TEXTURE_RECT_INDEX 4 -#define TEXTURE_1D_ARRAY_INDEX 5 -#define TEXTURE_2D_ARRAY_INDEX 6 -/*@}*/ +typedef enum +{ + TEXTURE_2D_ARRAY_INDEX, + TEXTURE_1D_ARRAY_INDEX, + TEXTURE_CUBE_INDEX, + TEXTURE_3D_INDEX, + TEXTURE_RECT_INDEX, + TEXTURE_2D_INDEX, + TEXTURE_1D_INDEX, + NUM_TEXTURE_TARGETS +} gl_texture_index; + /** * Bit flags for each type of texture object * Used for Texture.Unit[]._ReallyEnabled flags. */ /*@{*/ -#define TEXTURE_1D_BIT (1 << TEXTURE_1D_INDEX) -#define TEXTURE_2D_BIT (1 << TEXTURE_2D_INDEX) -#define TEXTURE_3D_BIT (1 << TEXTURE_3D_INDEX) +#define TEXTURE_2D_ARRAY_BIT (1 << TEXTURE_2D_ARRAY_INDEX) +#define TEXTURE_1D_ARRAY_BIT (1 << TEXTURE_1D_ARRAY_INDEX) #define TEXTURE_CUBE_BIT (1 << TEXTURE_CUBE_INDEX) +#define TEXTURE_3D_BIT (1 << TEXTURE_3D_INDEX) #define TEXTURE_RECT_BIT (1 << TEXTURE_RECT_INDEX) -#define TEXTURE_1D_ARRAY_BIT (1 << TEXTURE_1D_ARRAY_INDEX) -#define TEXTURE_2D_ARRAY_BIT (1 << TEXTURE_2D_ARRAY_INDEX) +#define TEXTURE_2D_BIT (1 << TEXTURE_2D_INDEX) +#define TEXTURE_1D_BIT (1 << TEXTURE_1D_INDEX) /*@}*/ @@ -1204,27 +1090,12 @@ struct gl_stencil_attrib /*@}*/ -/* A selection of state flags to make driver and module's lives easier. */ -#define ENABLE_TEXGEN0 0x1 -#define ENABLE_TEXGEN1 0x2 -#define ENABLE_TEXGEN2 0x4 -#define ENABLE_TEXGEN3 0x8 -#define ENABLE_TEXGEN4 0x10 -#define ENABLE_TEXGEN5 0x20 -#define ENABLE_TEXGEN6 0x40 -#define ENABLE_TEXGEN7 0x80 -#define ENABLE_TEXMAT0 0x1 /* Ie. not the identity matrix */ -#define ENABLE_TEXMAT1 0x2 -#define ENABLE_TEXMAT2 0x4 -#define ENABLE_TEXMAT3 0x8 -#define ENABLE_TEXMAT4 0x10 -#define ENABLE_TEXMAT5 0x20 -#define ENABLE_TEXMAT6 0x40 -#define ENABLE_TEXMAT7 0x80 +/** Tex-gen enabled for texture unit? */ +#define ENABLE_TEXGEN(unit) (1 << (unit)) -#define ENABLE_TEXGEN(i) (ENABLE_TEXGEN0 << (i)) -#define ENABLE_TEXMAT(i) (ENABLE_TEXMAT0 << (i)) +/** Non-identity texture matrix for texture unit? */ +#define ENABLE_TEXMAT(unit) (1 << (unit)) /** @@ -1400,15 +1271,16 @@ struct gl_texture_image /** * Indexes for cube map faces. */ -/*@{*/ -#define FACE_POS_X 0 -#define FACE_NEG_X 1 -#define FACE_POS_Y 2 -#define FACE_NEG_Y 3 -#define FACE_POS_Z 4 -#define FACE_NEG_Z 5 -#define MAX_FACES 6 -/*@}*/ +typedef enum +{ + FACE_POS_X = 0, + FACE_NEG_X = 1, + FACE_POS_Y = 2, + FACE_NEG_Y = 3, + FACE_POS_Z = 4, + FACE_NEG_Z = 5, + MAX_FACES = 6 +} gl_face_index; /** @@ -1439,10 +1311,6 @@ struct gl_texture_object GLenum CompareMode; /**< GL_ARB_shadow */ GLenum CompareFunc; /**< GL_ARB_shadow */ GLfloat CompareFailValue; /**< GL_ARB_shadow_ambient */ - GLenum _Function; /**< Comparison function derived from - * \c CompareOperator, \c CompareMode, and - * \c CompareFunc. - */ GLenum DepthMode; /**< GL_ARB_depth_texture */ GLint _MaxLevel; /**< actual max mipmap level (q in the spec) */ GLfloat _MaxLambda; /**< = _MaxLevel - BaseLevel (q - b in spec) */ @@ -1490,6 +1358,18 @@ struct gl_tex_env_combine_state /** + * Texture coord generation state. + */ +struct gl_texgen +{ + GLenum Mode; /**< GL_EYE_LINEAR, GL_SPHERE_MAP, etc */ + GLbitfield _ModeBit; /**< TEXGEN_x bit corresponding to Mode */ + GLfloat ObjectPlane[4]; + GLfloat EyePlane[4]; +}; + + +/** * Texture unit state. Contains enable flags, texture environment/function/ * combiners, texgen state, pointers to current texture objects and * post-filter color tables. @@ -1501,29 +1381,17 @@ struct gl_texture_unit GLenum EnvMode; /**< GL_MODULATE, GL_DECAL, GL_BLEND, etc. */ GLfloat EnvColor[4]; + + struct gl_texgen GenS; + struct gl_texgen GenT; + struct gl_texgen GenR; + struct gl_texgen GenQ; GLbitfield TexGenEnabled; /**< Bitwise-OR of [STRQ]_BIT values */ - /** \name Tex coord generation mode - * Either GL_OBJECT_LINEAR, GL_EYE_LINEAR or GL_SPHERE_MAP. */ - /*@{*/ - GLenum GenModeS; - GLenum GenModeT; - GLenum GenModeR; - GLenum GenModeQ; - /*@}*/ - GLbitfield _GenBitS; - GLbitfield _GenBitT; - GLbitfield _GenBitR; - GLbitfield _GenBitQ; - GLbitfield _GenFlags; /**< bitwise or of _GenBit[STRQ] */ - GLfloat ObjectPlaneS[4]; - GLfloat ObjectPlaneT[4]; - GLfloat ObjectPlaneR[4]; - GLfloat ObjectPlaneQ[4]; - GLfloat EyePlaneS[4]; - GLfloat EyePlaneT[4]; - GLfloat EyePlaneR[4]; - GLfloat EyePlaneQ[4]; + GLbitfield _GenFlags; /**< Bitwise-OR of Gen[STRQ]._ModeBit */ + GLfloat LodBias; /**< for biasing mipmap levels */ + GLenum BumpTarget; + GLfloat RotMatrix[4]; /* 2x2 matrix */ /** * \name GL_EXT_texture_env_combine @@ -1542,15 +1410,11 @@ struct gl_texture_unit */ struct gl_tex_env_combine_state *_CurrentCombine; - struct gl_texture_object *Current1D; - struct gl_texture_object *Current2D; - struct gl_texture_object *Current3D; - struct gl_texture_object *CurrentCubeMap; /**< GL_ARB_texture_cube_map */ - struct gl_texture_object *CurrentRect; /**< GL_NV_texture_rectangle */ - struct gl_texture_object *Current1DArray; /**< GL_MESA_texture_array */ - struct gl_texture_object *Current2DArray; /**< GL_MESA_texture_array */ + /** Current texture object pointers */ + struct gl_texture_object *CurrentTex[NUM_TEXTURE_TARGETS]; - struct gl_texture_object *_Current; /**< Points to really enabled tex obj */ + /** Points to highest priority, complete and enabled texture object */ + struct gl_texture_object *_Current; /** GL_SGI_texture_color_table */ /*@{*/ @@ -1561,24 +1425,12 @@ struct gl_texture_unit }; - /** * Texture attribute group (GL_TEXTURE_BIT). */ struct gl_texture_attrib { - /** - * name multitexture - */ - /**@{*/ - GLuint CurrentUnit; /**< Active texture unit [0, MaxTextureImageUnits-1] */ - GLbitfield _EnabledUnits; /**< one bit set for each really-enabled unit */ - GLbitfield _EnabledCoordUnits; /**< one bit per enabled coordinate unit */ - GLbitfield _GenFlags; /**< for texgen */ - GLbitfield _TexGenEnabled; - GLbitfield _TexMatEnabled; - /**@}*/ - + GLuint CurrentUnit; /**< GL_ACTIVE_TEXTURE */ struct gl_texture_unit Unit[MAX_TEXTURE_UNITS]; struct gl_texture_object *ProxyTex[NUM_TEXTURE_TARGETS]; @@ -1586,6 +1438,21 @@ struct gl_texture_attrib /** GL_EXT_shared_texture_palette */ GLboolean SharedPalette; struct gl_color_table Palette; + + /** Texture units/samplers used by vertex or fragment texturing */ + GLbitfield _EnabledUnits; + + /** Texture coord units/sets used for fragment texturing */ + GLbitfield _EnabledCoordUnits; + + /** Texture coord units that have texgen enabled */ + GLbitfield _TexGenEnabled; + + /** Texture coord units that have non-identity matrices */ + GLbitfield _TexMatEnabled; + + /** Bitwise-OR of all Texture.Unit[i]._GenFlags */ + GLbitfield _GenFlags; }; @@ -1621,17 +1488,6 @@ struct gl_viewport_attrib /** - * Node for the attribute stack. - */ -struct gl_attrib_node -{ - GLbitfield kind; - void *data; - struct gl_attrib_node *next; -}; - - -/** * GL_ARB_vertex/pixel_buffer_object buffer object */ struct gl_buffer_object @@ -1641,13 +1497,14 @@ struct gl_buffer_object GLenum Usage; GLenum Access; GLvoid *Pointer; /**< Only valid while buffer is mapped */ + GLintptr Offset; /**< mapped offset */ + GLsizeiptr Length; /**< mapped length */ GLsizeiptrARB Size; /**< Size of storage in bytes */ GLubyte *Data; /**< Location of storage either in RAM or VRAM. */ GLboolean OnCard; /**< Is buffer in VRAM? (hardware drivers) */ }; - /** * Client pixel packing/unpacking attributes */ @@ -1657,8 +1514,8 @@ struct gl_pixelstore_attrib GLint RowLength; GLint SkipPixels; GLint SkipRows; - GLint ImageHeight; /**< for GL_EXT_texture3D */ - GLint SkipImages; /**< for GL_EXT_texture3D */ + GLint ImageHeight; + GLint SkipImages; GLboolean SwapBytes; GLboolean LsbFirst; GLboolean ClientStorage; /**< GL_APPLE_client_storage */ @@ -1667,7 +1524,6 @@ struct gl_pixelstore_attrib }; - /** * Client vertex array attributes */ @@ -1747,7 +1603,7 @@ struct gl_array_attrib struct gl_feedback { GLenum Type; - GLbitfield _Mask; /* FB_* bits */ + GLbitfield _Mask; /**< FB_* bits */ GLfloat *Buffer; GLuint BufferSize; GLuint Count; @@ -1845,24 +1701,24 @@ struct gl_evaluators * be "uniform" variables since they can only be set outside glBegin/End. * They're also all stored in the same Parameters array. */ -enum register_file -{ - PROGRAM_TEMPORARY = 0, /**< machine->Temporary[] */ - PROGRAM_LOCAL_PARAM = 1, /**< gl_program->LocalParams[] */ - PROGRAM_ENV_PARAM = 2, /**< gl_program->Parameters[] */ - PROGRAM_STATE_VAR = 3, /**< gl_program->Parameters[] */ - PROGRAM_INPUT = 4, /**< machine->Inputs[] */ - PROGRAM_OUTPUT = 5, /**< machine->Outputs[] */ - PROGRAM_NAMED_PARAM = 6, /**< gl_program->Parameters[] */ - PROGRAM_CONSTANT = 7, /**< gl_program->Parameters[] */ - PROGRAM_UNIFORM = 8, /**< gl_program->Parameters[] */ - PROGRAM_VARYING = 9, /**< machine->Inputs[]/Outputs[] */ - PROGRAM_WRITE_ONLY = 10, /**< A dummy, write-only register */ - PROGRAM_ADDRESS = 11, /**< machine->AddressReg */ - PROGRAM_SAMPLER = 12, /**< for shader samplers, compile-time only */ - PROGRAM_UNDEFINED = 13, /**< Invalid value */ +typedef enum +{ + PROGRAM_TEMPORARY, /**< machine->Temporary[] */ + PROGRAM_INPUT, /**< machine->Inputs[] */ + PROGRAM_OUTPUT, /**< machine->Outputs[] */ + PROGRAM_VARYING, /**< machine->Inputs[]/Outputs[] */ + PROGRAM_LOCAL_PARAM, /**< gl_program->LocalParams[] */ + PROGRAM_ENV_PARAM, /**< gl_program->Parameters[] */ + PROGRAM_STATE_VAR, /**< gl_program->Parameters[] */ + PROGRAM_NAMED_PARAM, /**< gl_program->Parameters[] */ + PROGRAM_CONSTANT, /**< gl_program->Parameters[] */ + PROGRAM_UNIFORM, /**< gl_program->Parameters[] */ + PROGRAM_WRITE_ONLY, /**< A dummy, write-only register */ + PROGRAM_ADDRESS, /**< machine->AddressReg */ + PROGRAM_SAMPLER, /**< for shader samplers, compile-time only */ + PROGRAM_UNDEFINED, /**< Invalid/TBD value */ PROGRAM_FILE_MAX -}; +} gl_register_file; /** Vertex and fragment instructions */ @@ -1971,14 +1827,14 @@ struct gl_program_state */ struct gl_vertex_program_state { - GLboolean Enabled; /**< User-set GL_VERTEX_PROGRAM_ARB/NV flag */ - GLboolean _Enabled; /**< Enabled and _valid_ user program? */ - GLboolean PointSizeEnabled; /**< GL_VERTEX_PROGRAM_POINT_SIZE_ARB/NV */ - GLboolean TwoSideEnabled; /**< GL_VERTEX_PROGRAM_TWO_SIDE_ARB/NV */ + GLboolean Enabled; /**< User-set GL_VERTEX_PROGRAM_ARB/NV flag */ + GLboolean _Enabled; /**< Enabled and _valid_ user program? */ + GLboolean PointSizeEnabled; /**< GL_VERTEX_PROGRAM_POINT_SIZE_ARB/NV */ + GLboolean TwoSideEnabled; /**< GL_VERTEX_PROGRAM_TWO_SIDE_ARB/NV */ struct gl_vertex_program *Current; /**< User-bound vertex program */ - /** Currently enabled and valid vertex program (including internal programs, - * user-defined vertex programs and GLSL vertex shaders). + /** Currently enabled and valid vertex program (including internal + * programs, user-defined vertex programs and GLSL vertex shaders). * This is the program we must use when rendering. */ struct gl_vertex_program *_Current; @@ -1998,13 +1854,6 @@ struct gl_vertex_program_state /** Cache of fixed-function programs */ struct gl_program_cache *Cache; -#if FEATURE_MESA_program_debug - GLprogramcallbackMESA Callback; - GLvoid *CallbackData; - GLboolean CallbackEnabled; - GLuint CurrentPosition; -#endif - GLboolean _Overriden; }; @@ -2018,8 +1867,8 @@ struct gl_fragment_program_state GLboolean _Enabled; /**< Enabled and _valid_ user program? */ struct gl_fragment_program *Current; /**< User-bound fragment program */ - /** Currently enabled and valid fragment program (including internal programs, - * user-defined fragment programs and GLSL fragment shaders). + /** Currently enabled and valid fragment program (including internal + * programs, user-defined fragment programs and GLSL fragment shaders). * This is the program we must use when rendering. */ struct gl_fragment_program *_Current; @@ -2034,13 +1883,6 @@ struct gl_fragment_program_state /** Cache of fixed-function programs */ struct gl_program_cache *Cache; - -#if FEATURE_MESA_program_debug - GLprogramcallbackMESA Callback; - GLvoid *CallbackData; - GLboolean CallbackEnabled; - GLuint CurrentPosition; -#endif }; @@ -2114,6 +1956,8 @@ struct gl_query_state /** Set by #pragma directives */ struct gl_sl_pragmas { + GLboolean IgnoreOptimize; /**< ignore #pragma optimize(on/off) ? */ + GLboolean IgnoreDebug; /**< ignore #pragma debug(on/off) ? */ GLboolean Optimize; /**< defaults on */ GLboolean Debug; /**< defaults off */ }; @@ -2184,6 +2028,7 @@ struct gl_shader_state GLboolean EmitComments; /**< Annotated instructions */ void *MemPool; GLbitfield Flags; /**< Mask of GLSL_x flags */ + struct gl_sl_pragmas DefaultPragmas; /**< Default #pragma settings */ }; @@ -2197,18 +2042,8 @@ struct gl_shared_state struct _mesa_HashTable *DisplayList; /**< Display lists hash table */ struct _mesa_HashTable *TexObjects; /**< Texture objects hash table */ - /** - * \name Default texture objects (shared by all multi-texture units) - */ - /*@{*/ - struct gl_texture_object *Default1D; - struct gl_texture_object *Default2D; - struct gl_texture_object *Default3D; - struct gl_texture_object *DefaultCubeMap; - struct gl_texture_object *DefaultRect; - struct gl_texture_object *Default1DArray; - struct gl_texture_object *Default2DArray; - /*@}*/ + /** Default texture objects (shared by all texture units) */ + struct gl_texture_object *DefaultTex[NUM_TEXTURE_TARGETS]; /** * \name Thread safety and statechange notification for texture @@ -2372,9 +2207,8 @@ struct gl_renderbuffer /** - * A renderbuffer attachment point points to either a texture object - * (and specifies a mipmap level, cube face or 3D texture slice) or - * points to a renderbuffer. + * A renderbuffer attachment points to either a texture object (and specifies + * a mipmap level, cube face or 3D texture slice) or points to a renderbuffer. */ struct gl_renderbuffer_attachment { @@ -2406,14 +2240,24 @@ struct gl_renderbuffer_attachment */ struct gl_framebuffer { - _glthread_Mutex Mutex; /**< for thread safety */ - GLuint Name; /* if zero, this is a window system framebuffer */ + _glthread_Mutex Mutex; /**< for thread safety */ + /** + * If zero, this is a window system framebuffer. If non-zero, this + * is a FBO framebuffer; note that for some devices (i.e. those with + * a natural pixel coordinate system for FBOs that differs from the + * OpenGL/Mesa coordinate system), this means that the viewport, + * polygon face orientation, and polygon stipple will have to be inverted. + */ + GLuint Name; + GLint RefCount; GLboolean DeletePending; - GLvisual Visual; /**< The framebuffer's visual. - Immutable if this is a window system buffer. - Computed from attachments if user-made FBO. */ + /** + * The framebuffer's visual. Immutable if this is a window system buffer. + * Computed from attachments if user-made FBO. + */ + GLvisual Visual; GLboolean Initialized; @@ -2432,9 +2276,10 @@ struct gl_framebuffer GLfloat _MRD; /**< minimum resolvable difference in Z values */ /*@}*/ - GLenum _Status; /* One of the GL_FRAMEBUFFER_(IN)COMPLETE_* tokens */ + /** One of the GL_FRAMEBUFFER_(IN)COMPLETE_* tokens */ + GLenum _Status; - /* Array of all renderbuffer attachments, indexed by BUFFER_* tokens. */ + /** Array of all renderbuffer attachments, indexed by BUFFER_* tokens. */ struct gl_renderbuffer_attachment Attachment[BUFFER_COUNT]; /* In unextended OpenGL these vars are part of the GL_COLOR_BUFFER @@ -2496,52 +2341,60 @@ struct gl_program_constants */ struct gl_constants { - GLint MaxTextureLevels; /**< Maximum number of allowed mipmap levels. */ - GLint Max3DTextureLevels; /**< Maximum number of allowed mipmap levels for 3D texture targets. */ - GLint MaxCubeTextureLevels; /**< Maximum number of allowed mipmap levels for GL_ARB_texture_cube_map */ - GLint MaxArrayTextureLayers; /**< Maximum number of layers in an array texture. */ - GLint MaxTextureRectSize; /* GL_NV_texture_rectangle */ + GLint MaxTextureLevels; /**< Max mipmap levels. */ + GLint Max3DTextureLevels; /**< Max mipmap levels for 3D textures */ + GLint MaxCubeTextureLevels; /**< Max mipmap levels for cube textures */ + GLint MaxArrayTextureLayers; /**< Max layers in array textures */ + GLint MaxTextureRectSize; /**< Max rectangle texture size, in pixes */ GLuint MaxTextureCoordUnits; GLuint MaxTextureImageUnits; - GLuint MaxTextureUnits; /**< = MIN(CoordUnits, ImageUnits) */ - GLfloat MaxTextureMaxAnisotropy; /**< GL_EXT_texture_filter_anisotropic */ - GLfloat MaxTextureLodBias; /**< GL_EXT_texture_lod_bias */ + GLuint MaxVertexTextureImageUnits; + GLuint MaxTextureUnits; /**< = MIN(CoordUnits, ImageUnits) */ + GLfloat MaxTextureMaxAnisotropy; /**< GL_EXT_texture_filter_anisotropic */ + GLfloat MaxTextureLodBias; /**< GL_EXT_texture_lod_bias */ + GLuint MaxArrayLockSize; + GLint SubPixelBits; - GLfloat MinPointSize, MaxPointSize; /* aliased */ - GLfloat MinPointSizeAA, MaxPointSizeAA; /* antialiased */ + + GLfloat MinPointSize, MaxPointSize; /**< aliased */ + GLfloat MinPointSizeAA, MaxPointSizeAA; /**< antialiased */ GLfloat PointSizeGranularity; - GLfloat MinLineWidth, MaxLineWidth; /* aliased */ - GLfloat MinLineWidthAA, MaxLineWidthAA; /* antialiased */ + GLfloat MinLineWidth, MaxLineWidth; /**< aliased */ + GLfloat MinLineWidthAA, MaxLineWidthAA; /**< antialiased */ GLfloat LineWidthGranularity; + GLuint MaxColorTableSize; GLuint MaxConvolutionWidth; GLuint MaxConvolutionHeight; + GLuint MaxClipPlanes; GLuint MaxLights; - GLfloat MaxShininess; /* GL_NV_light_max_exponent */ - GLfloat MaxSpotExponent; /* GL_NV_light_max_exponent */ + GLfloat MaxShininess; /**< GL_NV_light_max_exponent */ + GLfloat MaxSpotExponent; /**< GL_NV_light_max_exponent */ + GLuint MaxViewportWidth, MaxViewportHeight; - struct gl_program_constants VertexProgram; /* GL_ARB_vertex_program */ - struct gl_program_constants FragmentProgram; /* GL_ARB_fragment_program */ - /* shared by vertex and fragment program: */ + + struct gl_program_constants VertexProgram; /**< GL_ARB_vertex_program */ + struct gl_program_constants FragmentProgram; /**< GL_ARB_fragment_program */ GLuint MaxProgramMatrices; GLuint MaxProgramMatrixStackDepth; - /* vertex array / buffer object bounds checking */ + + /** vertex array / buffer object bounds checking */ GLboolean CheckArrayBounds; - /* GL_ARB_draw_buffers */ - GLuint MaxDrawBuffers; - /* GL_OES_read_format */ - GLenum ColorReadFormat; - GLenum ColorReadType; - /* GL_EXT_framebuffer_object */ - GLuint MaxColorAttachments; - GLuint MaxRenderbufferSize; - /* GL_ARB_vertex_shader */ - GLuint MaxVertexTextureImageUnits; - GLuint MaxVarying; /**< Number of float[4] vectors */ - /* GL_ARB_framebuffer_object */ - GLuint MaxSamples; + + GLuint MaxDrawBuffers; /**< GL_ARB_draw_buffers */ + + GLenum ColorReadFormat; /**< GL_OES_read_format */ + GLenum ColorReadType; /**< GL_OES_read_format */ + + GLuint MaxColorAttachments; /**< GL_EXT_framebuffer_object */ + GLuint MaxRenderbufferSize; /**< GL_EXT_framebuffer_object */ + GLuint MaxSamples; /**< GL_ARB_framebuffer_object */ + + GLuint MaxVarying; /**< Number of float[4] varying parameters */ + + GLbitfield SupportedBumpUnits; /**> units supporting GL_ATI_envmap_bumpmap as targets */ }; @@ -2551,12 +2404,6 @@ struct gl_constants */ struct gl_extensions { - /** - * \name Flags to quickly test if certain extensions are available. - * - * Not every extension needs to have such a flag, but it's encouraged. - */ - /*@{*/ GLboolean dummy; /* don't remove this! */ GLboolean ARB_depth_texture; GLboolean ARB_draw_buffers; @@ -2644,6 +2491,7 @@ struct gl_extensions GLboolean APPLE_client_storage; GLboolean APPLE_packed_pixels; GLboolean APPLE_vertex_array_object; + GLboolean ATI_envmap_bumpmap; GLboolean ATI_texture_mirror_once; GLboolean ATI_texture_env_combine3; GLboolean ATI_fragment_shader; @@ -2652,7 +2500,6 @@ struct gl_extensions GLboolean IBM_multimode_draw_arrays; GLboolean MESA_pack_invert; GLboolean MESA_packed_depth_stencil; - GLboolean MESA_program_debug; GLboolean MESA_resize_buffers; GLboolean MESA_ycbcr_texture; GLboolean MESA_texture_array; @@ -2674,8 +2521,7 @@ struct gl_extensions GLboolean SGIS_texture_lod; GLboolean TDFX_texture_compression_FXT1; GLboolean S3_s3tc; - /*@}*/ - /* The extension string */ + /** The extension string */ const GLubyte *String; }; @@ -2695,7 +2541,6 @@ struct gl_matrix_stack /** * \name Bits for image transfer operations - * * \sa __GLcontextRec::ImageTransferState. */ /*@{*/ @@ -2710,7 +2555,7 @@ struct gl_matrix_stack #define IMAGE_POST_COLOR_MATRIX_COLOR_TABLE_BIT 0x100 #define IMAGE_HISTOGRAM_BIT 0x200 #define IMAGE_MIN_MAX_BIT 0x400 -#define IMAGE_CLAMP_BIT 0x800 /* extra */ +#define IMAGE_CLAMP_BIT 0x800 /** Pixel Transfer ops up to convolution */ @@ -3073,21 +2918,15 @@ struct __GLcontextRec struct gl_color_table ColorTable[COLORTABLE_MAX]; struct gl_color_table ProxyColorTable[COLORTABLE_MAX]; -#if 0 - struct gl_color_table PostConvolutionColorTable; - struct gl_color_table ProxyPostConvolutionColorTable; - struct gl_color_table PostColorMatrixColorTable; - struct gl_color_table ProxyPostColorMatrixColorTable; -#endif - struct gl_program_state Program; /**< for vertex or fragment progs */ - struct gl_vertex_program_state VertexProgram; /**< GL_ARB/NV_vertex_program */ - struct gl_fragment_program_state FragmentProgram; /**< GL_ARB/NV_vertex_program */ - struct gl_ati_fragment_shader_state ATIFragmentShader; /**< GL_ATI_fragment_shader */ - - struct gl_query_state Query; /**< GL_ARB_occlusion_query */ + struct gl_program_state Program; /**< general program state */ + struct gl_vertex_program_state VertexProgram; + struct gl_fragment_program_state FragmentProgram; + struct gl_ati_fragment_shader_state ATIFragmentShader; struct gl_shader_state Shader; /**< GLSL shader object state */ + + struct gl_query_state Query; /**< occlusion, timer queries */ /*@}*/ #if FEATURE_EXT_framebuffer_object @@ -3111,9 +2950,8 @@ struct __GLcontextRec GLfloat _ModelViewInvScale; GLboolean _NeedEyeCoords; GLboolean _ForceEyeCoords; - GLenum _CurrentProgram; /* currently executing program */ - GLuint TextureStateTimestamp; /* detect changes to shared state */ + GLuint TextureStateTimestamp; /**< detect changes to shared state */ struct gl_shine_tab *_ShineTable[2]; /**< Active shine tables */ struct gl_shine_tab *_ShineTabList; /**< MRU list of inactive shine tables */ @@ -3193,7 +3031,4 @@ enum _debug -#define Elements(x) sizeof(x)/sizeof(*(x)) - - -#endif /* TYPES_H */ +#endif /* MTYPES_H */ diff --git a/src/mesa/main/shaders.c b/src/mesa/main/shaders.c index 7491d00c35..be93b45a7d 100644 --- a/src/mesa/main/shaders.c +++ b/src/mesa/main/shaders.c @@ -374,6 +374,43 @@ _mesa_LinkProgramARB(GLhandleARB programObj) } + +/** + * Read shader source code from a file. + * Useful for debugging to override an app's shader. + */ +static GLcharARB * +_mesa_read_shader(const char *fname) +{ + const int max = 50*1000; + FILE *f = fopen(fname, "r"); + GLcharARB *buffer, *shader; + int len; + + if (!f) { + _mesa_fprintf(stderr, "Unable to open shader file %s\n", fname); + return NULL; + } + + buffer = (char *) malloc(max); + len = fread(buffer, 1, max, f); + buffer[len] = 0; + + fclose(f); + + shader = _mesa_strdup(buffer); + free(buffer); + + if (0) { + _mesa_fprintf(stderr, "Read shader %s:\n", fname); + _mesa_fprintf(stderr, "%s\n", shader); + } + + return shader; +} + + + /** * Called via glShaderSource() and glShaderSourceARB() API functions. * Basically, concatenate the source code strings into one long string @@ -438,6 +475,20 @@ _mesa_ShaderSourceARB(GLhandleARB shaderObj, GLsizei count, source[totalLength - 1] = '\0'; source[totalLength - 2] = '\0'; +#if 0 + if (0) { + GLcharARB *newSource; + + newSource = _mesa_read_shader("newshader.frag"); + if (newSource) { + _mesa_free(source); + source = newSource; + } + } +#else + (void) _mesa_read_shader; +#endif + ctx->Driver.ShaderSource(ctx, shaderObj, source); _mesa_free(offsets); diff --git a/src/mesa/main/shared.c b/src/mesa/main/shared.c new file mode 100644 index 0000000000..fa45e466b7 --- /dev/null +++ b/src/mesa/main/shared.c @@ -0,0 +1,356 @@ +/* + * Mesa 3-D graphics library + * Version: 7.5 + * + * Copyright (C) 2009 VMware, Inc. 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. + */ + +/** + * \file shared.c + * Shared-context state + */ + + + +#include "imports.h" +#include "mtypes.h" +#include "hash.h" +#include "arrayobj.h" +#include "shared.h" +#include "shader/program.h" +#include "shader/shader_api.h" +#if FEATURE_dlist +#include "dlist.h" +#endif +#if FEATURE_ATI_fragment_shader +#include "shader/atifragshader.h" +#endif + + +/** + * Allocate and initialize a shared context state structure. + * Initializes the display list, texture objects and vertex programs hash + * tables, allocates the texture objects. If it runs out of memory, frees + * everything already allocated before returning NULL. + * + * \return pointer to a gl_shared_state structure on success, or NULL on + * failure. + */ +struct gl_shared_state * +_mesa_alloc_shared_state(GLcontext *ctx) +{ + struct gl_shared_state *shared; + GLuint i; + + shared = CALLOC_STRUCT(gl_shared_state); + if (!shared) + return NULL; + + _glthread_INIT_MUTEX(shared->Mutex); + + shared->DisplayList = _mesa_NewHashTable(); + shared->TexObjects = _mesa_NewHashTable(); + shared->Programs = _mesa_NewHashTable(); + +#if FEATURE_ARB_vertex_program + shared->DefaultVertexProgram = (struct gl_vertex_program *) + ctx->Driver.NewProgram(ctx, GL_VERTEX_PROGRAM_ARB, 0); +#endif + +#if FEATURE_ARB_fragment_program + shared->DefaultFragmentProgram = (struct gl_fragment_program *) + ctx->Driver.NewProgram(ctx, GL_FRAGMENT_PROGRAM_ARB, 0); +#endif + +#if FEATURE_ATI_fragment_shader + shared->ATIShaders = _mesa_NewHashTable(); + shared->DefaultFragmentShader = _mesa_new_ati_fragment_shader(ctx, 0); +#endif + +#if FEATURE_ARB_shader_objects + shared->ShaderObjects = _mesa_NewHashTable(); +#endif + +#if FEATURE_ARB_vertex_buffer_object || FEATURE_ARB_pixel_buffer_object + shared->BufferObjects = _mesa_NewHashTable(); +#endif + + shared->ArrayObjects = _mesa_NewHashTable(); + + /* Create default texture objects */ + for (i = 0; i < NUM_TEXTURE_TARGETS; i++) { + /* NOTE: the order of these enums matches the TEXTURE_x_INDEX values */ + static const GLenum targets[NUM_TEXTURE_TARGETS] = { + GL_TEXTURE_2D_ARRAY_EXT, + GL_TEXTURE_1D_ARRAY_EXT, + GL_TEXTURE_CUBE_MAP, + GL_TEXTURE_3D, + GL_TEXTURE_RECTANGLE_NV, + GL_TEXTURE_2D, + GL_TEXTURE_1D + }; + shared->DefaultTex[i] = ctx->Driver.NewTextureObject(ctx, 0, targets[i]); + } + + /* sanity check */ + assert(shared->DefaultTex[TEXTURE_1D_INDEX]->RefCount == 1); + + /* Mutex and timestamp for texobj state validation */ + _glthread_INIT_MUTEX(shared->TexMutex); + shared->TextureStateStamp = 0; + +#if FEATURE_EXT_framebuffer_object + shared->FrameBuffers = _mesa_NewHashTable(); + shared->RenderBuffers = _mesa_NewHashTable(); +#endif + + return shared; +} + + +/** + * Callback for deleting a display list. Called by _mesa_HashDeleteAll(). + */ +static void +delete_displaylist_cb(GLuint id, void *data, void *userData) +{ +#if FEATURE_dlist + struct gl_display_list *list = (struct gl_display_list *) data; + GLcontext *ctx = (GLcontext *) userData; + _mesa_delete_list(ctx, list); +#endif +} + + +/** + * Callback for deleting a texture object. Called by _mesa_HashDeleteAll(). + */ +static void +delete_texture_cb(GLuint id, void *data, void *userData) +{ + struct gl_texture_object *texObj = (struct gl_texture_object *) data; + GLcontext *ctx = (GLcontext *) userData; + ctx->Driver.DeleteTexture(ctx, texObj); +} + + +/** + * Callback for deleting a program object. Called by _mesa_HashDeleteAll(). + */ +static void +delete_program_cb(GLuint id, void *data, void *userData) +{ + struct gl_program *prog = (struct gl_program *) data; + GLcontext *ctx = (GLcontext *) userData; + ASSERT(prog->RefCount == 1); /* should only be referenced by hash table */ + prog->RefCount = 0; /* now going away */ + ctx->Driver.DeleteProgram(ctx, prog); +} + + +#if FEATURE_ATI_fragment_shader +/** + * Callback for deleting an ATI fragment shader object. + * Called by _mesa_HashDeleteAll(). + */ +static void +delete_fragshader_cb(GLuint id, void *data, void *userData) +{ + struct ati_fragment_shader *shader = (struct ati_fragment_shader *) data; + GLcontext *ctx = (GLcontext *) userData; + _mesa_delete_ati_fragment_shader(ctx, shader); +} +#endif + + +/** + * Callback for deleting a buffer object. Called by _mesa_HashDeleteAll(). + */ +static void +delete_bufferobj_cb(GLuint id, void *data, void *userData) +{ + struct gl_buffer_object *bufObj = (struct gl_buffer_object *) data; + GLcontext *ctx = (GLcontext *) userData; + ctx->Driver.DeleteBuffer(ctx, bufObj); +} + + +/** + * Callback for deleting an array object. Called by _mesa_HashDeleteAll(). + */ +static void +delete_arrayobj_cb(GLuint id, void *data, void *userData) +{ + struct gl_array_object *arrayObj = (struct gl_array_object *) data; + GLcontext *ctx = (GLcontext *) userData; + _mesa_delete_array_object(ctx, arrayObj); +} + + +/** + * Callback for freeing shader program data. Call it before delete_shader_cb + * to avoid memory access error. + */ +static void +free_shader_program_data_cb(GLuint id, void *data, void *userData) +{ + GLcontext *ctx = (GLcontext *) userData; + struct gl_shader_program *shProg = (struct gl_shader_program *) data; + + if (shProg->Type == GL_SHADER_PROGRAM_MESA) { + _mesa_free_shader_program_data(ctx, shProg); + } +} + + +/** + * Callback for deleting shader and shader programs objects. + * Called by _mesa_HashDeleteAll(). + */ +static void +delete_shader_cb(GLuint id, void *data, void *userData) +{ + GLcontext *ctx = (GLcontext *) userData; + struct gl_shader *sh = (struct gl_shader *) data; + if (sh->Type == GL_FRAGMENT_SHADER || sh->Type == GL_VERTEX_SHADER) { + _mesa_free_shader(ctx, sh); + } + else { + struct gl_shader_program *shProg = (struct gl_shader_program *) data; + ASSERT(shProg->Type == GL_SHADER_PROGRAM_MESA); + _mesa_free_shader_program(ctx, shProg); + } +} + + +/** + * Callback for deleting a framebuffer object. Called by _mesa_HashDeleteAll() + */ +static void +delete_framebuffer_cb(GLuint id, void *data, void *userData) +{ + struct gl_framebuffer *fb = (struct gl_framebuffer *) data; + /* The fact that the framebuffer is in the hashtable means its refcount + * is one, but we're removing from the hashtable now. So clear refcount. + */ + /*assert(fb->RefCount == 1);*/ + fb->RefCount = 0; + + /* NOTE: Delete should always be defined but there are two reports + * of it being NULL (bugs 13507, 14293). Work-around for now. + */ + if (fb->Delete) + fb->Delete(fb); +} + + +/** + * Callback for deleting a renderbuffer object. Called by _mesa_HashDeleteAll() + */ +static void +delete_renderbuffer_cb(GLuint id, void *data, void *userData) +{ + struct gl_renderbuffer *rb = (struct gl_renderbuffer *) data; + rb->RefCount = 0; /* see comment for FBOs above */ + if (rb->Delete) + rb->Delete(rb); +} + + +/** + * Deallocate a shared state object and all children structures. + * + * \param ctx GL context. + * \param shared shared state pointer. + * + * Frees the display lists, the texture objects (calling the driver texture + * deletion callback to free its private data) and the vertex programs, as well + * as their hash tables. + * + * \sa alloc_shared_state(). + */ +void +_mesa_free_shared_state(GLcontext *ctx, struct gl_shared_state *shared) +{ + GLuint i; + + /* + * Free display lists + */ + _mesa_HashDeleteAll(shared->DisplayList, delete_displaylist_cb, ctx); + _mesa_DeleteHashTable(shared->DisplayList); + +#if FEATURE_ARB_shader_objects + _mesa_HashWalk(shared->ShaderObjects, free_shader_program_data_cb, ctx); + _mesa_HashDeleteAll(shared->ShaderObjects, delete_shader_cb, ctx); + _mesa_DeleteHashTable(shared->ShaderObjects); +#endif + + _mesa_HashDeleteAll(shared->Programs, delete_program_cb, ctx); + _mesa_DeleteHashTable(shared->Programs); + + _mesa_HashDeleteAll(shared->ArrayObjects, delete_arrayobj_cb, ctx); + _mesa_DeleteHashTable(shared->ArrayObjects); + +#if FEATURE_ARB_vertex_program + _mesa_reference_vertprog(ctx, &shared->DefaultVertexProgram, NULL); +#endif + +#if FEATURE_ARB_fragment_program + _mesa_reference_fragprog(ctx, &shared->DefaultFragmentProgram, NULL); +#endif + +#if FEATURE_ATI_fragment_shader + _mesa_HashDeleteAll(shared->ATIShaders, delete_fragshader_cb, ctx); + _mesa_DeleteHashTable(shared->ATIShaders); + _mesa_delete_ati_fragment_shader(ctx, shared->DefaultFragmentShader); +#endif + +#if FEATURE_ARB_vertex_buffer_object || FEATURE_ARB_pixel_buffer_object + _mesa_HashDeleteAll(shared->BufferObjects, delete_bufferobj_cb, ctx); + _mesa_DeleteHashTable(shared->BufferObjects); +#endif + +#if FEATURE_EXT_framebuffer_object + _mesa_HashDeleteAll(shared->FrameBuffers, delete_framebuffer_cb, ctx); + _mesa_DeleteHashTable(shared->FrameBuffers); + _mesa_HashDeleteAll(shared->RenderBuffers, delete_renderbuffer_cb, ctx); + _mesa_DeleteHashTable(shared->RenderBuffers); +#endif + + /* + * Free texture objects (after FBOs since some textures might have + * been bound to FBOs). + */ + ASSERT(ctx->Driver.DeleteTexture); + /* the default textures */ + for (i = 0; i < NUM_TEXTURE_TARGETS; i++) { + ctx->Driver.DeleteTexture(ctx, shared->DefaultTex[i]); + } + + /* all other textures */ + _mesa_HashDeleteAll(shared->TexObjects, delete_texture_cb, ctx); + _mesa_DeleteHashTable(shared->TexObjects); + + _glthread_DESTROY_MUTEX(shared->Mutex); + _glthread_DESTROY_MUTEX(shared->TexMutex); + + _mesa_free(shared); +} diff --git a/src/mesa/main/shared.h b/src/mesa/main/shared.h new file mode 100644 index 0000000000..e59177e968 --- /dev/null +++ b/src/mesa/main/shared.h @@ -0,0 +1,37 @@ +/* + * Mesa 3-D graphics library + * Version: 7.5 + * + * Copyright (C) 2009 VMware, Inc. 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. + */ + +#ifndef SHARED_H +#define SHARED_H + + +struct gl_shared_state * +_mesa_alloc_shared_state(GLcontext *ctx); + + +void +_mesa_free_shared_state(GLcontext *ctx, struct gl_shared_state *shared); + + +#endif diff --git a/src/mesa/main/state.c b/src/mesa/main/state.c index 0a39279bff..cc37d63636 100644 --- a/src/mesa/main/state.c +++ b/src/mesa/main/state.c @@ -49,6 +49,7 @@ #include "texenvprogram.h" #include "texobj.h" #include "texstate.h" +#include "viewport.h" static void @@ -202,13 +203,17 @@ update_program_enables(GLcontext *ctx) * * This function needs to be called after texture state validation in case * we're generating a fragment program from fixed-function texture state. + * + * \return bitfield which will indicate _NEW_PROGRAM state if a new vertex + * or fragment program is being used. */ -static void +static GLbitfield update_program(GLcontext *ctx) { const struct gl_shader_program *shProg = ctx->Shader.CurrentProgram; const struct gl_vertex_program *prevVP = ctx->VertexProgram._Current; const struct gl_fragment_program *prevFP = ctx->FragmentProgram._Current; + GLbitfield new_state = 0x0; /* * Set the ctx->VertexProgram._Current and ctx->FragmentProgram._Current @@ -278,15 +283,23 @@ update_program(GLcontext *ctx) /* Let the driver know what's happening: */ - if (ctx->FragmentProgram._Current != prevFP && ctx->Driver.BindProgram) { - ctx->Driver.BindProgram(ctx, GL_FRAGMENT_PROGRAM_ARB, - (struct gl_program *) ctx->FragmentProgram._Current); + if (ctx->FragmentProgram._Current != prevFP) { + new_state |= _NEW_PROGRAM; + if (ctx->Driver.BindProgram) { + ctx->Driver.BindProgram(ctx, GL_FRAGMENT_PROGRAM_ARB, + (struct gl_program *) ctx->FragmentProgram._Current); + } } - if (ctx->VertexProgram._Current != prevVP && ctx->Driver.BindProgram) { - ctx->Driver.BindProgram(ctx, GL_VERTEX_PROGRAM_ARB, - (struct gl_program *) ctx->VertexProgram._Current); + if (ctx->VertexProgram._Current != prevVP) { + new_state |= _NEW_PROGRAM; + if (ctx->Driver.BindProgram) { + ctx->Driver.BindProgram(ctx, GL_VERTEX_PROGRAM_ARB, + (struct gl_program *) ctx->VertexProgram._Current); + } } + + return new_state; } @@ -447,6 +460,7 @@ _mesa_update_state_locked( GLcontext *ctx ) { GLbitfield new_state = ctx->NewState; GLbitfield prog_flags = _NEW_PROGRAM; + GLbitfield new_prog_state = 0x0; if (new_state == _NEW_CURRENT_ATTRIB) goto out; @@ -490,7 +504,7 @@ _mesa_update_state_locked( GLcontext *ctx ) if (new_state & _NEW_LIGHT) _mesa_update_lighting( ctx ); - if (new_state & _NEW_STENCIL) + if (new_state & (_NEW_STENCIL | _NEW_BUFFERS)) _mesa_update_stencil( ctx ); #if FEATURE_pixel_transfer @@ -531,8 +545,13 @@ _mesa_update_state_locked( GLcontext *ctx ) if (new_state & _MESA_NEW_NEED_EYE_COORDS) _mesa_update_tnl_spaces( ctx, new_state ); - if (new_state & prog_flags) - update_program( ctx ); + if (new_state & prog_flags) { + /* When we generate programs from fixed-function vertex/fragment state + * this call may generate/bind a new program. If so, we need to + * propogate the _NEW_PROGRAM flag to the driver. + */ + new_prog_state |= update_program( ctx ); + } /* * Give the driver a chance to act upon the new_state flags. @@ -544,7 +563,7 @@ _mesa_update_state_locked( GLcontext *ctx ) * Driver.UpdateState() has to call FLUSH_VERTICES(). (fixed?) */ out: - new_state = ctx->NewState; + new_state = ctx->NewState | new_prog_state; ctx->NewState = 0; ctx->Driver.UpdateState(ctx, new_state); ctx->Array.NewState = 0; diff --git a/src/mesa/main/stencil.c b/src/mesa/main/stencil.c index b4ea9978d8..15c98e2015 100644 --- a/src/mesa/main/stencil.c +++ b/src/mesa/main/stencil.c @@ -27,6 +27,23 @@ * \file stencil.c * Stencil operations. * + * Note: There's some conflict between GL_EXT_stencil_two_side and + * OpenGL 2.0's two-sided stencil feature. + * + * With GL_EXT_stencil_two_side, calling glStencilOp/Func/Mask() only the + * front OR back face state (as set by glActiveStencilFaceEXT) is set. + * + * But with OpenGL 2.0, calling glStencilOp/Func/Mask() sets BOTH the + * front AND back state. + * + * Also, note that GL_ATI_separate_stencil is different as well: + * glStencilFuncSeparateATI(GLenum frontfunc, GLenum backfunc, ...) vs. + * glStencilFuncSeparate(GLenum face, GLenum func, ...). + * + * This problem is solved by keeping three sets of stencil state: + * state[0] = GL_FRONT state. + * state[1] = OpenGL 2.0 / GL_ATI_separate_stencil GL_BACK state. + * state[2] = GL_EXT_stencil_two_side GL_BACK state. */ @@ -519,7 +536,11 @@ _mesa_update_stencil(GLcontext *ctx) { const GLint face = ctx->Stencil._BackFace; - ctx->Stencil._TestTwoSide = + ctx->Stencil._Enabled = (ctx->Stencil.Enabled && + ctx->DrawBuffer->Visual.stencilBits > 0); + + ctx->Stencil._TestTwoSide = + ctx->Stencil._Enabled && (ctx->Stencil.Function[0] != ctx->Stencil.Function[face] || ctx->Stencil.FailFunc[0] != ctx->Stencil.FailFunc[face] || ctx->Stencil.ZPassFunc[0] != ctx->Stencil.ZPassFunc[face] || @@ -542,7 +563,7 @@ _mesa_init_stencil(GLcontext *ctx) { ctx->Stencil.Enabled = GL_FALSE; ctx->Stencil.TestTwoSide = GL_FALSE; - ctx->Stencil.ActiveFace = 0; /* 0 = GL_FRONT, 1 = GL_BACK */ + ctx->Stencil.ActiveFace = 0; /* 0 = GL_FRONT, 2 = GL_BACK */ ctx->Stencil.Function[0] = GL_ALWAYS; ctx->Stencil.Function[1] = GL_ALWAYS; ctx->Stencil.Function[2] = GL_ALWAYS; @@ -565,4 +586,5 @@ _mesa_init_stencil(GLcontext *ctx) ctx->Stencil.WriteMask[1] = ~0U; ctx->Stencil.WriteMask[2] = ~0U; ctx->Stencil.Clear = 0; + ctx->Stencil._BackFace = 1; } diff --git a/src/mesa/main/texenv.c b/src/mesa/main/texenv.c index 097923182a..c2960fc820 100644 --- a/src/mesa/main/texenv.c +++ b/src/mesa/main/texenv.c @@ -35,7 +35,6 @@ #include "main/enums.h" #include "main/macros.h" #include "main/texenv.h" -#include "math/m_xform.h" #define TE_ERROR(errCode, msg, value) \ @@ -143,7 +142,11 @@ set_combiner_mode(GLcontext *ctx, case GL_MODULATE_ADD_ATI: case GL_MODULATE_SIGNED_ADD_ATI: case GL_MODULATE_SUBTRACT_ATI: - legal =ctx->Extensions.ATI_texture_env_combine3; + legal = ctx->Extensions.ATI_texture_env_combine3; + break; + case GL_BUMP_ENVMAP_ATI: + legal = (ctx->Extensions.ATI_envmap_bumpmap && + pname == GL_COMBINE_RGB); break; default: legal = GL_FALSE; @@ -501,6 +504,26 @@ _mesa_TexEnvfv( GLenum target, GLenum pname, const GLfloat *param ) case GL_ALPHA_SCALE: set_combiner_scale(ctx, texUnit, pname, param[0]); break; + case GL_BUMP_TARGET_ATI: + if (!ctx->Extensions.ATI_envmap_bumpmap) { + _mesa_error( ctx, GL_INVALID_ENUM, "glTexEnv(pname=0x%x)", pname ); + return; + } + if (((GLenum) (GLint) param[0] < GL_TEXTURE0) || + ((GLenum) (GLint) param[0] > GL_TEXTURE31)) { + /* spec doesn't say this but it seems logical */ + _mesa_error( ctx, GL_INVALID_ENUM, "glTexEnv(param=0x%x)", (GLenum) (GLint) param[0]); + return; + } + if (!((1 << ((GLenum) (GLint) param[0] - GL_TEXTURE0)) & ctx->Const.SupportedBumpUnits)) { + _mesa_error( ctx, GL_INVALID_VALUE, "glTexEnv(param=0x%x)", (GLenum) (GLint) param[0]); + return; + } + else { + FLUSH_VERTICES(ctx, _NEW_TEXTURE); + texUnit->BumpTarget = (GLenum) (GLint) param[0]; + } + break; default: _mesa_error( ctx, GL_INVALID_ENUM, "glTexEnv(pname)" ); return; @@ -736,6 +759,16 @@ get_texenvi(GLcontext *ctx, const struct gl_texture_unit *texUnit, _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexEnvfv(pname)"); } break; + case GL_BUMP_TARGET_ATI: + /* spec doesn't say so, but I think this should be queryable */ + if (ctx->Extensions.ATI_envmap_bumpmap) { + return texUnit->BumpTarget; + } + else { + _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexEnvfv(pname)"); + } + break; + default: ; } @@ -875,4 +908,142 @@ _mesa_GetTexEnviv( GLenum target, GLenum pname, GLint *params ) } } +/* why does ATI_envmap_bumpmap require new entrypoints? Should just + reuse TexEnv ones... */ +void GLAPIENTRY +_mesa_TexBumpParameterivATI( GLenum pname, const GLint *param ) +{ + GLfloat p[4]; + if (pname == GL_BUMP_ROT_MATRIX_ATI) { + /* hope that conversion is correct here */ + p[0] = INT_TO_FLOAT( param[0] ); + p[1] = INT_TO_FLOAT( param[1] ); + p[2] = INT_TO_FLOAT( param[2] ); + p[3] = INT_TO_FLOAT( param[3] ); + } + else { + p[0] = (GLfloat) param[0]; + p[1] = p[2] = p[3] = 0; /* init to zero, just to be safe */ + } + _mesa_TexBumpParameterfvATI( pname, p ); +} + +void GLAPIENTRY +_mesa_TexBumpParameterfvATI( GLenum pname, const GLfloat *param ) +{ + struct gl_texture_unit *texUnit; + GET_CURRENT_CONTEXT(ctx); + ASSERT_OUTSIDE_BEGIN_END(ctx); + + /* should return error if extension not supported? */ + texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit]; + + if (pname == GL_BUMP_ROT_MATRIX_ATI) { + if (TEST_EQ_4V(param, texUnit->RotMatrix)) + return; + FLUSH_VERTICES(ctx, _NEW_TEXTURE); + COPY_4FV(texUnit->RotMatrix, param); + } + else { + _mesa_error( ctx, GL_INVALID_ENUM, "glTexBumpParameter(pname)" ); + return; + } + /* Drivers might want to know about this, instead of dedicated function + just shove it into TexEnv where it really belongs anyway */ + if (ctx->Driver.TexEnv) { + (*ctx->Driver.TexEnv)( ctx, 0, pname, param ); + } +} + +void GLAPIENTRY +_mesa_GetTexBumpParameterivATI( GLenum pname, GLint *param ) +{ + const struct gl_texture_unit *texUnit; + GLint i; + GLint temp = 0; + GET_CURRENT_CONTEXT(ctx); + ASSERT_OUTSIDE_BEGIN_END(ctx); + + /* should return error if extension not supported? */ + texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit]; + + if (pname == GL_BUMP_ROT_MATRIX_SIZE_ATI) { + /* spec leaves open to support larger matrices. + Don't think anyone would ever want to use it + (and apps almost certainly would not understand it and + thus fail to submit matrices correctly) so hardcode this. */ + *param = 4; + } + else if (pname == GL_BUMP_ROT_MATRIX_ATI) { + /* hope that conversion is correct here */ + param[0] = FLOAT_TO_INT(texUnit->RotMatrix[0]); + param[1] = FLOAT_TO_INT(texUnit->RotMatrix[1]); + param[2] = FLOAT_TO_INT(texUnit->RotMatrix[2]); + param[3] = FLOAT_TO_INT(texUnit->RotMatrix[3]); + } + else if (pname == GL_BUMP_NUM_TEX_UNITS_ATI) { + for (i = 0; i < ctx->Const.MaxTextureImageUnits; i++) { + if (ctx->Const.SupportedBumpUnits & (1 << i)) { + temp++; + } + } + *param = temp; + } + else if (pname == GL_BUMP_TEX_UNITS_ATI) { + for (i = 0; i < ctx->Const.MaxTextureImageUnits; i++) { + if (ctx->Const.SupportedBumpUnits & (1 << i)) { + *param++ = i + GL_TEXTURE0; + } + } + } + else { + _mesa_error( ctx, GL_INVALID_ENUM, "glGetTexBumpParameter(pname)" ); + return; + } +} + +void GLAPIENTRY +_mesa_GetTexBumpParameterfvATI( GLenum pname, GLfloat *param ) +{ + const struct gl_texture_unit *texUnit; + GLint i; + GLint temp = 0; + GET_CURRENT_CONTEXT(ctx); + ASSERT_OUTSIDE_BEGIN_END(ctx); + + /* should return error if extension not supported? */ + texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit]; + + if (pname == GL_BUMP_ROT_MATRIX_SIZE_ATI) { + /* spec leaves open to support larger matrices. + Don't think anyone would ever want to use it + (and apps might not understand it) so hardcode this. */ + *param = (GLfloat) 4; + } + else if (pname == GL_BUMP_ROT_MATRIX_ATI) { + param[0] = texUnit->RotMatrix[0]; + param[1] = texUnit->RotMatrix[1]; + param[2] = texUnit->RotMatrix[2]; + param[3] = texUnit->RotMatrix[3]; + } + else if (pname == GL_BUMP_NUM_TEX_UNITS_ATI) { + for (i = 0; i < ctx->Const.MaxTextureImageUnits; i++) { + if (ctx->Const.SupportedBumpUnits & (1 << i)) { + temp++; + } + } + *param = (GLfloat) temp; + } + else if (pname == GL_BUMP_TEX_UNITS_ATI) { + for (i = 0; i < ctx->Const.MaxTextureImageUnits; i++) { + if (ctx->Const.SupportedBumpUnits & (1 << i)) { + *param++ = (GLfloat) (i + GL_TEXTURE0); + } + } + } + else { + _mesa_error( ctx, GL_INVALID_ENUM, "glGetTexBumpParameter(pname)" ); + return; + } +} diff --git a/src/mesa/main/texenv.h b/src/mesa/main/texenv.h index bdff7fdb82..1e9c5faed7 100644 --- a/src/mesa/main/texenv.h +++ b/src/mesa/main/texenv.h @@ -48,5 +48,16 @@ _mesa_TexEnvi( GLenum target, GLenum pname, GLint param ); extern void GLAPIENTRY _mesa_TexEnviv( GLenum target, GLenum pname, const GLint *param ); +extern void GLAPIENTRY +_mesa_TexBumpParameterivATI( GLenum pname, const GLint *param ); + +extern void GLAPIENTRY +_mesa_TexBumpParameterfvATI( GLenum pname, const GLfloat *param ); + +extern void GLAPIENTRY +_mesa_GetTexBumpParameterivATI( GLenum pname, GLint *param ); + +extern void GLAPIENTRY +_mesa_GetTexBumpParameterfvATI( GLenum pname, GLfloat *param ); #endif /* TEXENV_H */ diff --git a/src/mesa/main/texenvprogram.c b/src/mesa/main/texenvprogram.c index af51a206a5..3fbd119b34 100644 --- a/src/mesa/main/texenvprogram.c +++ b/src/mesa/main/texenvprogram.c @@ -94,11 +94,11 @@ struct state_key { GLuint ScaleShiftA:2; GLuint NumArgsRGB:3; - GLuint ModeRGB:4; + GLuint ModeRGB:5; struct mode_opt OptRGB[MAX_TERMS]; GLuint NumArgsA:3; - GLuint ModeA:4; + GLuint ModeA:5; struct mode_opt OptA[MAX_TERMS]; } unit[8]; }; @@ -194,7 +194,8 @@ static GLuint translate_source( GLenum src ) #define MODE_MODULATE_SUBTRACT_ATI 12 /* r = a0 * a2 - a1 */ #define MODE_ADD_PRODUCTS 13 /* r = a0 * a1 + a2 * a3 */ #define MODE_ADD_PRODUCTS_SIGNED 14 /* r = a0 * a1 + a2 * a3 - 0.5 */ -#define MODE_UNKNOWN 15 +#define MODE_BUMP_ENVMAP_ATI 15 /* special */ +#define MODE_UNKNOWN 16 /** * Translate GL combiner state into a MODE_x value @@ -223,6 +224,7 @@ static GLuint translate_mode( GLenum envMode, GLenum mode ) case GL_MODULATE_ADD_ATI: return MODE_MODULATE_ADD_ATI; case GL_MODULATE_SIGNED_ADD_ATI: return MODE_MODULATE_SIGNED_ADD_ATI; case GL_MODULATE_SUBTRACT_ATI: return MODE_MODULATE_SUBTRACT_ATI; + case GL_BUMP_ENVMAP_ATI: return MODE_BUMP_ENVMAP_ATI; default: assert(0); return MODE_UNKNOWN; @@ -383,7 +385,7 @@ static void make_state_key( GLcontext *ctx, struct state_key *key ) translate_mode(texUnit->EnvMode, texUnit->_CurrentCombine->ModeRGB); key->unit[i].ModeA = translate_mode(texUnit->EnvMode, texUnit->_CurrentCombine->ModeA); - + key->unit[i].ScaleShiftRGB = texUnit->_CurrentCombine->ScaleShiftRGB; key->unit[i].ScaleShiftA = texUnit->_CurrentCombine->ScaleShiftA; @@ -397,8 +399,18 @@ static void make_state_key( GLcontext *ctx, struct state_key *key ) key->unit[i].OptA[j].Source = translate_source(texUnit->_CurrentCombine->SourceA[j]); } + + if (key->unit[i].ModeRGB == MODE_BUMP_ENVMAP_ATI) { + /* requires some special translation */ + key->unit[i].NumArgsRGB = 2; + key->unit[i].ScaleShiftRGB = 0; + key->unit[i].OptRGB[0].Operand = OPR_SRC_COLOR; + key->unit[i].OptRGB[0].Source = SRC_TEXTURE; + key->unit[i].OptRGB[1].Operand = OPR_SRC_COLOR; + key->unit[i].OptRGB[1].Source = texUnit->BumpTarget - GL_TEXTURE0 + SRC_TEXTURE0; + } } - + if (ctx->_TriangleCaps & DD_SEPARATE_SPECULAR) { key->separate_specular = 1; inputs_referenced |= FRAG_BIT_COL1; @@ -464,6 +476,11 @@ struct texenv_fragment_program { * else undef. */ + struct ureg texcoord_tex[MAX_TEXTURE_COORD_UNITS]; + /* Reg containing texcoord for a texture unit, + * needed for bump mapping, else undef. + */ + struct ureg src_previous; /**< Reg containing color from previous * stage. May need to be decl'd. */ @@ -736,6 +753,7 @@ static struct ureg emit_texld( struct texenv_fragment_program *p, GLuint destmask, GLuint tex_unit, GLuint tex_idx, + GLuint tex_shadow, struct ureg coord ) { struct prog_instruction *inst = emit_op( p, op, @@ -747,6 +765,7 @@ static struct ureg emit_texld( struct texenv_fragment_program *p, inst->TexSrcTarget = tex_idx; inst->TexSrcUnit = tex_unit; + inst->TexShadow = tex_shadow; p->program->Base.NumTexInstructions++; @@ -754,6 +773,7 @@ static struct ureg emit_texld( struct texenv_fragment_program *p, */ reserve_temp(p, dest); +#if 0 /* Is this a texture indirection? */ if ((coord.file == PROGRAM_TEMPORARY && @@ -765,6 +785,7 @@ static struct ureg emit_texld( struct texenv_fragment_program *p, p->alu_temps = 0; assert(0); /* KW: texture env crossbar */ } +#endif return dest; } @@ -1050,6 +1071,10 @@ static struct ureg emit_combine( struct texenv_fragment_program *p, emit_arith( p, OPCODE_SUB, dest, mask, saturate, tmp0, half, undef ); } return dest; + case MODE_BUMP_ENVMAP_ATI: + /* special - not handled here */ + assert(0); + return src[0]; default: assert(0); return src[0]; @@ -1072,6 +1097,10 @@ emit_texenv(struct texenv_fragment_program *p, GLuint unit) if (!key->unit[unit].enabled) { return get_source(p, SRC_PREVIOUS, 0); } + if (key->unit[unit].ModeRGB == MODE_BUMP_ENVMAP_ATI) { + /* this isn't really a env stage delivering a color and handled elsewhere */ + return get_source(p, SRC_PREVIOUS, 0); + } switch (key->unit[unit].ModeRGB) { case MODE_DOT3_RGB_EXT: @@ -1096,7 +1125,7 @@ emit_texenv(struct texenv_fragment_program *p, GLuint unit) rgb_shift) dest = get_temp( p ); else - dest = make_ureg(PROGRAM_OUTPUT, FRAG_RESULT_COLR); + dest = make_ureg(PROGRAM_OUTPUT, FRAG_RESULT_COLOR); /* Emit the RGB and A combine ops */ @@ -1160,22 +1189,35 @@ emit_texenv(struct texenv_fragment_program *p, GLuint unit) static void load_texture( struct texenv_fragment_program *p, GLuint unit ) { if (is_undef(p->src_texture[unit])) { - GLuint dim = p->state->unit[unit].source_index; - struct ureg texcoord = register_input(p, FRAG_ATTRIB_TEX0+unit); + GLuint texTarget = p->state->unit[unit].source_index; + struct ureg texcoord; struct ureg tmp = get_tex_temp( p ); - if (dim == TEXTURE_UNKNOWN_INDEX) + if (is_undef(p->texcoord_tex[unit])) { + texcoord = register_input(p, FRAG_ATTRIB_TEX0+unit); + } + else { + /* might want to reuse this reg for tex output actually */ + texcoord = p->texcoord_tex[unit]; + } + + if (texTarget == TEXTURE_UNKNOWN_INDEX) program_error(p, "TexSrcBit"); /* TODO: Use D0_MASK_XY where possible. */ if (p->state->unit[unit].enabled) { - p->src_texture[unit] = emit_texld( p, OPCODE_TXP, - tmp, WRITEMASK_XYZW, - unit, dim, texcoord ); + GLboolean shadow = GL_FALSE; - if (p->state->unit[unit].shadow) + if (p->state->unit[unit].shadow) { p->program->Base.ShadowSamplers |= 1 << unit; + shadow = GL_TRUE; + } + + p->src_texture[unit] = emit_texld( p, OPCODE_TXP, + tmp, WRITEMASK_XYZW, + unit, texTarget, shadow, + texcoord ); p->program->Base.SamplersUsed |= (1 << unit); /* This identity mapping should already be in place @@ -1226,7 +1268,7 @@ load_texunit_sources( struct texenv_fragment_program *p, int unit ) GLuint i; for (i = 0; i < key->unit[unit].NumArgsRGB; i++) { - load_texenv_source( p, key->unit[unit].OptRGB[i].Source, unit); + load_texenv_source( p, key->unit[unit].OptRGB[i].Source, unit ); } for (i = 0; i < key->unit[unit].NumArgsA; i++) { @@ -1236,6 +1278,40 @@ load_texunit_sources( struct texenv_fragment_program *p, int unit ) return GL_TRUE; } +/** + * Generate instructions for loading bump map textures. + */ +static GLboolean +load_texunit_bumpmap( struct texenv_fragment_program *p, int unit ) +{ + struct state_key *key = p->state; + GLuint bumpedUnitNr = key->unit[unit].OptRGB[1].Source - SRC_TEXTURE0; + struct ureg texcDst, bumpMapRes; + struct ureg constdudvcolor = register_const4f(p, 0.0, 0.0, 0.0, 1.0); + struct ureg texcSrc = register_input(p, FRAG_ATTRIB_TEX0 + bumpedUnitNr); + struct ureg rotMat0 = register_param3( p, STATE_INTERNAL, STATE_ROT_MATRIX_0, unit ); + struct ureg rotMat1 = register_param3( p, STATE_INTERNAL, STATE_ROT_MATRIX_1, unit ); + + load_texenv_source( p, unit + SRC_TEXTURE0, unit ); + + bumpMapRes = get_source(p, key->unit[unit].OptRGB[0].Source, unit); + texcDst = get_tex_temp( p ); + p->texcoord_tex[bumpedUnitNr] = texcDst; + + /* apply rot matrix and add coords to be available in next phase */ + /* dest = (Arg0.xxxx * rotMat0 + Arg1) + (Arg0.yyyy * rotMat1) */ + /* note only 2 coords are affected the rest are left unchanged (mul by 0) */ + emit_arith( p, OPCODE_MAD, texcDst, WRITEMASK_XYZW, 0, + swizzle1(bumpMapRes, SWIZZLE_X), rotMat0, texcSrc ); + emit_arith( p, OPCODE_MAD, texcDst, WRITEMASK_XYZW, 0, + swizzle1(bumpMapRes, SWIZZLE_Y), rotMat1, texcDst ); + + /* move 0,0,0,1 into bumpmap src if someone (crossbar) is foolish + enough to access this later, should optimize away */ + emit_arith( p, OPCODE_MOV, bumpMapRes, WRITEMASK_XYZW, 0, constdudvcolor, undef, undef ); + + return GL_TRUE; +} /** * Generate a new fragment program which implements the context's @@ -1260,7 +1336,7 @@ create_new_program(GLcontext *ctx, struct state_key *key, */ p.program->Base.Instructions = instBuffer; p.program->Base.Target = GL_FRAGMENT_PROGRAM_ARB; - p.program->Base.NumTexIndirections = 1; /* correct? */ + p.program->Base.NumTexIndirections = 1; p.program->Base.NumTexInstructions = 0; p.program->Base.NumAluInstructions = 0; p.program->Base.String = NULL; @@ -1271,10 +1347,12 @@ create_new_program(GLcontext *ctx, struct state_key *key, p.program->Base.Parameters = _mesa_new_parameter_list(); p.program->Base.InputsRead = 0; - p.program->Base.OutputsWritten = 1 << FRAG_RESULT_COLR; + p.program->Base.OutputsWritten = 1 << FRAG_RESULT_COLOR; - for (unit = 0; unit < ctx->Const.MaxTextureUnits; unit++) + for (unit = 0; unit < ctx->Const.MaxTextureUnits; unit++) { p.src_texture[unit] = undef; + p.texcoord_tex[unit] = undef; + } p.src_previous = undef; p.half = undef; @@ -1285,6 +1363,16 @@ create_new_program(GLcontext *ctx, struct state_key *key, release_temps(ctx, &p); if (key->enabled_units) { + GLboolean needbumpstage = GL_FALSE; + /* Zeroth pass - bump map textures first */ + for (unit = 0 ; unit < ctx->Const.MaxTextureUnits ; unit++) + if (key->unit[unit].enabled && key->unit[unit].ModeRGB == MODE_BUMP_ENVMAP_ATI) { + needbumpstage = GL_TRUE; + load_texunit_bumpmap( &p, unit ); + } + if (needbumpstage) + p.program->Base.NumTexIndirections++; + /* First pass - to support texture_env_crossbar, first identify * all referenced texture sources and emit texld instructions * for each: @@ -1306,7 +1394,7 @@ create_new_program(GLcontext *ctx, struct state_key *key, } cf = get_source( &p, SRC_PREVIOUS, 0 ); - out = make_ureg( PROGRAM_OUTPUT, FRAG_RESULT_COLR ); + out = make_ureg( PROGRAM_OUTPUT, FRAG_RESULT_COLOR ); if (key->separate_specular) { /* Emit specular add. diff --git a/src/mesa/main/texformat.c b/src/mesa/main/texformat.c index 16d05cc7d0..c372b49398 100644 --- a/src/mesa/main/texformat.c +++ b/src/mesa/main/texformat.c @@ -696,6 +696,33 @@ const struct gl_texture_format _mesa_texformat_intensity_float16 = { store_texel_intensity_f16 /* StoreTexel */ }; +const struct gl_texture_format _mesa_texformat_dudv8 = { + MESA_FORMAT_DUDV8, /* MesaFormat */ + GL_DUDV_ATI, /* BaseFormat */ + /* FIXME: spec doesn't say since that parameter didn't exist then, + but this should be something like SIGNED_NORMALIZED */ + GL_UNSIGNED_NORMALIZED_ARB, /* DataType */ + /* maybe should add dudvBits field, but spec seems to be + lacking the ability to query with GetTexLevelParameter anyway */ + 0, /* RedBits */ + 0, /* GreenBits */ + 0, /* BlueBits */ + 0, /* AlphaBits */ + 0, /* LuminanceBits */ + 0, /* IntensityBits */ + 0, /* IndexBits */ + 0, /* DepthBits */ + 0, /* StencilBits */ + 2, /* TexelBytes */ + _mesa_texstore_dudv8, /* StoreTexImageFunc */ + NULL, /* FetchTexel1D */ + NULL, /* FetchTexel2D */ + NULL, /* FetchTexel3D */ + fetch_texel_1d_dudv8, /* FetchTexel1Df */ + fetch_texel_2d_dudv8, /* FetchTexel2Df */ + fetch_texel_3d_dudv8, /* FetchTexel3Df */ + NULL /* StoreTexel */ +}; /*@}*/ @@ -1634,6 +1661,16 @@ _mesa_choose_tex_format( GLcontext *ctx, GLint internalFormat, } } + if (ctx->Extensions.ATI_envmap_bumpmap) { + switch (internalFormat) { + case GL_DUDV_ATI: + case GL_DU8DV8_ATI: + return &_mesa_texformat_dudv8; + default: + ; /* fallthrough */ + } + } + #if FEATURE_EXT_texture_sRGB if (ctx->Extensions.EXT_texture_sRGB) { switch (internalFormat) { @@ -1778,6 +1815,11 @@ _mesa_format_to_type_and_comps(const struct gl_texture_format *format, *comps = 1; return; + case MESA_FORMAT_DUDV8: + *datatype = GL_BYTE; + *comps = 2; + return; + #if FEATURE_EXT_texture_sRGB case MESA_FORMAT_SRGB8: *datatype = GL_UNSIGNED_BYTE; diff --git a/src/mesa/main/texformat.h b/src/mesa/main/texformat.h index 31364c36b1..7fa70ad4fe 100644 --- a/src/mesa/main/texformat.h +++ b/src/mesa/main/texformat.h @@ -161,7 +161,14 @@ enum _format { MESA_FORMAT_LUMINANCE_ALPHA_FLOAT32, MESA_FORMAT_LUMINANCE_ALPHA_FLOAT16, MESA_FORMAT_INTENSITY_FLOAT32, - MESA_FORMAT_INTENSITY_FLOAT16 + MESA_FORMAT_INTENSITY_FLOAT16, + /*@}*/ + + /** + * \name Signed fixed point texture formats. + */ + /*@{*/ + MESA_FORMAT_DUDV8 /*@}*/ }; @@ -209,6 +216,11 @@ extern const struct gl_texture_format _mesa_texformat_intensity_float32; extern const struct gl_texture_format _mesa_texformat_intensity_float16; /*@}*/ +/** Signed fixed point texture formats */ +/*@{*/ +extern const struct gl_texture_format _mesa_texformat_dudv8; +/*@}*/ + /** \name Assorted hardware-friendly formats */ /*@{*/ extern const struct gl_texture_format _mesa_texformat_rgba8888; diff --git a/src/mesa/main/texformat_tmp.h b/src/mesa/main/texformat_tmp.h index 275340cabd..0f6a172ef0 100644 --- a/src/mesa/main/texformat_tmp.h +++ b/src/mesa/main/texformat_tmp.h @@ -719,9 +719,9 @@ static void store_texel_rgb888(struct gl_texture_image *texImage, { const GLubyte *rgba = (const GLubyte *) texel; GLubyte *dst = TEXEL_ADDR(GLubyte, texImage, i, j, k, 3); - dst[0] = rgba[RCOMP]; + dst[0] = rgba[BCOMP]; dst[1] = rgba[GCOMP]; - dst[2] = rgba[BCOMP]; + dst[2] = rgba[RCOMP]; } #endif @@ -745,9 +745,9 @@ static void store_texel_bgr888(struct gl_texture_image *texImage, { const GLubyte *rgba = (const GLubyte *) texel; GLubyte *dst = TEXEL_ADDR(GLubyte, texImage, i, j, k, 3); - dst[0] = rgba[BCOMP]; + dst[0] = rgba[RCOMP]; dst[1] = rgba[GCOMP]; - dst[2] = rgba[RCOMP]; + dst[2] = rgba[BCOMP]; } #endif @@ -1269,7 +1269,7 @@ static void FETCH(sl8)(const struct gl_texture_image *texImage, texel[RCOMP] = texel[GCOMP] = texel[BCOMP] = nonlinear_to_linear(src[0]); - texel[ACOMP] = CHAN_MAX; + texel[ACOMP] = 1.0F; } #if DIM == 3 @@ -1304,10 +1304,22 @@ static void store_texel_sla8(struct gl_texture_image *texImage, } #endif +#endif /* FEATURE_EXT_texture_sRGB */ -#endif /* FEATURE_EXT_texture_sRGB */ +/* MESA_FORMAT_DUDV8 ********************************************************/ +/* this format by definition produces 0,0,0,1 as rgba values, + however we'll return the dudv values as rg and fix up elsewhere */ +static void FETCH(dudv8)(const struct gl_texture_image *texImage, + GLint i, GLint j, GLint k, GLfloat *texel ) +{ + const GLbyte *src = TEXEL_ADDR(GLbyte, texImage, i, j, k, 2); + texel[RCOMP] = BYTE_TO_FLOAT(src[0]); + texel[GCOMP] = BYTE_TO_FLOAT(src[1]); + texel[BCOMP] = 0; + texel[ACOMP] = 0; +} /* MESA_FORMAT_YCBCR *********************************************************/ diff --git a/src/mesa/main/texgen.c b/src/mesa/main/texgen.c index 244c7aaafc..e3feb024c3 100644 --- a/src/mesa/main/texgen.c +++ b/src/mesa/main/texgen.c @@ -1,8 +1,9 @@ /* * Mesa 3-D graphics library - * Version: 7.1 + * Version: 7.5 * * Copyright (C) 1999-2008 Brian Paul All Rights Reserved. + * Copyright (C) 2009 VMware, Inc. 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"), @@ -34,15 +35,36 @@ #include "main/enums.h" #include "main/macros.h" #include "main/texgen.h" -#include "math/m_xform.h" +#include "math/m_matrix.h" +/** + * Return texgen state for given coordinate + */ +static struct gl_texgen * +get_texgen(struct gl_texture_unit *texUnit, GLenum coord) +{ + switch (coord) { + case GL_S: + return &texUnit->GenS; + case GL_T: + return &texUnit->GenT; + case GL_R: + return &texUnit->GenR; + case GL_Q: + return &texUnit->GenQ; + default: + return NULL; + } +} + void GLAPIENTRY _mesa_TexGenfv( GLenum coord, GLenum pname, const GLfloat *params ) { - GET_CURRENT_CONTEXT(ctx); struct gl_texture_unit *texUnit; + struct gl_texgen *texgen; + GET_CURRENT_CONTEXT(ctx); ASSERT_OUTSIDE_BEGIN_END(ctx); if (MESA_VERBOSE&(VERBOSE_API|VERBOSE_TEXTURE)) @@ -59,210 +81,79 @@ _mesa_TexGenfv( GLenum coord, GLenum pname, const GLfloat *params ) texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit]; - switch (coord) { - case GL_S: - if (pname==GL_TEXTURE_GEN_MODE) { - GLenum mode = (GLenum) (GLint) *params; - GLbitfield bits; - switch (mode) { - case GL_OBJECT_LINEAR: - bits = TEXGEN_OBJ_LINEAR; - break; - case GL_EYE_LINEAR: - bits = TEXGEN_EYE_LINEAR; - break; - case GL_REFLECTION_MAP_NV: - bits = TEXGEN_REFLECTION_MAP_NV; - break; - case GL_NORMAL_MAP_NV: - bits = TEXGEN_NORMAL_MAP_NV; - break; - case GL_SPHERE_MAP: - bits = TEXGEN_SPHERE_MAP; - break; - default: - _mesa_error( ctx, GL_INVALID_ENUM, "glTexGenfv(param)" ); - return; - } - if (texUnit->GenModeS == mode) - return; - FLUSH_VERTICES(ctx, _NEW_TEXTURE); - texUnit->GenModeS = mode; - texUnit->_GenBitS = bits; - } - else if (pname==GL_OBJECT_PLANE) { - if (TEST_EQ_4V(texUnit->ObjectPlaneS, params)) - return; - FLUSH_VERTICES(ctx, _NEW_TEXTURE); - COPY_4FV(texUnit->ObjectPlaneS, params); - } - else if (pname==GL_EYE_PLANE) { - GLfloat tmp[4]; - /* Transform plane equation by the inverse modelview matrix */ - if (_math_matrix_is_dirty(ctx->ModelviewMatrixStack.Top)) { - _math_matrix_analyse( ctx->ModelviewMatrixStack.Top ); - } - _mesa_transform_vector( tmp, params, ctx->ModelviewMatrixStack.Top->inv ); - if (TEST_EQ_4V(texUnit->EyePlaneS, tmp)) - return; - FLUSH_VERTICES(ctx, _NEW_TEXTURE); - COPY_4FV(texUnit->EyePlaneS, tmp); - } - else { - _mesa_error( ctx, GL_INVALID_ENUM, "glTexGenfv(pname)" ); - return; - } - break; - case GL_T: - if (pname==GL_TEXTURE_GEN_MODE) { - GLenum mode = (GLenum) (GLint) *params; - GLbitfield bitt; - switch (mode) { - case GL_OBJECT_LINEAR: - bitt = TEXGEN_OBJ_LINEAR; - break; - case GL_EYE_LINEAR: - bitt = TEXGEN_EYE_LINEAR; - break; - case GL_REFLECTION_MAP_NV: - bitt = TEXGEN_REFLECTION_MAP_NV; - break; - case GL_NORMAL_MAP_NV: - bitt = TEXGEN_NORMAL_MAP_NV; - break; - case GL_SPHERE_MAP: - bitt = TEXGEN_SPHERE_MAP; - break; - default: - _mesa_error( ctx, GL_INVALID_ENUM, "glTexGenfv(param)" ); - return; - } - if (texUnit->GenModeT == mode) - return; - FLUSH_VERTICES(ctx, _NEW_TEXTURE); - texUnit->GenModeT = mode; - texUnit->_GenBitT = bitt; - } - else if (pname==GL_OBJECT_PLANE) { - if (TEST_EQ_4V(texUnit->ObjectPlaneT, params)) - return; - FLUSH_VERTICES(ctx, _NEW_TEXTURE); - COPY_4FV(texUnit->ObjectPlaneT, params); - } - else if (pname==GL_EYE_PLANE) { - GLfloat tmp[4]; - /* Transform plane equation by the inverse modelview matrix */ - if (_math_matrix_is_dirty(ctx->ModelviewMatrixStack.Top)) { - _math_matrix_analyse( ctx->ModelviewMatrixStack.Top ); - } - _mesa_transform_vector( tmp, params, ctx->ModelviewMatrixStack.Top->inv ); - if (TEST_EQ_4V(texUnit->EyePlaneT, tmp)) - return; - FLUSH_VERTICES(ctx, _NEW_TEXTURE); - COPY_4FV(texUnit->EyePlaneT, tmp); - } - else { - _mesa_error( ctx, GL_INVALID_ENUM, "glTexGenfv(pname)" ); - return; - } - break; - case GL_R: - if (pname==GL_TEXTURE_GEN_MODE) { - GLenum mode = (GLenum) (GLint) *params; - GLbitfield bitr; - switch (mode) { - case GL_OBJECT_LINEAR: - bitr = TEXGEN_OBJ_LINEAR; - break; - case GL_REFLECTION_MAP_NV: - bitr = TEXGEN_REFLECTION_MAP_NV; - break; - case GL_NORMAL_MAP_NV: - bitr = TEXGEN_NORMAL_MAP_NV; - break; - case GL_EYE_LINEAR: - bitr = TEXGEN_EYE_LINEAR; - break; - default: - _mesa_error( ctx, GL_INVALID_ENUM, "glTexGenfv(param)" ); - return; - } - if (texUnit->GenModeR == mode) - return; - FLUSH_VERTICES(ctx, _NEW_TEXTURE); - texUnit->GenModeR = mode; - texUnit->_GenBitR = bitr; - } - else if (pname==GL_OBJECT_PLANE) { - if (TEST_EQ_4V(texUnit->ObjectPlaneR, params)) - return; - FLUSH_VERTICES(ctx, _NEW_TEXTURE); - COPY_4FV(texUnit->ObjectPlaneR, params); - } - else if (pname==GL_EYE_PLANE) { - GLfloat tmp[4]; - /* Transform plane equation by the inverse modelview matrix */ - if (_math_matrix_is_dirty(ctx->ModelviewMatrixStack.Top)) { - _math_matrix_analyse( ctx->ModelviewMatrixStack.Top ); - } - _mesa_transform_vector( tmp, params, ctx->ModelviewMatrixStack.Top->inv ); - if (TEST_EQ_4V(texUnit->EyePlaneR, tmp)) - return; - FLUSH_VERTICES(ctx, _NEW_TEXTURE); - COPY_4FV(texUnit->EyePlaneR, tmp); - } - else { - _mesa_error( ctx, GL_INVALID_ENUM, "glTexGenfv(pname)" ); - return; - } - break; - case GL_Q: - if (pname==GL_TEXTURE_GEN_MODE) { - GLenum mode = (GLenum) (GLint) *params; - GLbitfield bitq; - switch (mode) { - case GL_OBJECT_LINEAR: - bitq = TEXGEN_OBJ_LINEAR; - break; - case GL_EYE_LINEAR: - bitq = TEXGEN_EYE_LINEAR; - break; - default: - _mesa_error( ctx, GL_INVALID_ENUM, "glTexGenfv(param)" ); - return; - } - if (texUnit->GenModeQ == mode) - return; - FLUSH_VERTICES(ctx, _NEW_TEXTURE); - texUnit->GenModeQ = mode; - texUnit->_GenBitQ = bitq; - } - else if (pname==GL_OBJECT_PLANE) { - if (TEST_EQ_4V(texUnit->ObjectPlaneQ, params)) - return; - FLUSH_VERTICES(ctx, _NEW_TEXTURE); - COPY_4FV(texUnit->ObjectPlaneQ, params); - } - else if (pname==GL_EYE_PLANE) { - GLfloat tmp[4]; - /* Transform plane equation by the inverse modelview matrix */ - if (_math_matrix_is_dirty(ctx->ModelviewMatrixStack.Top)) { - _math_matrix_analyse( ctx->ModelviewMatrixStack.Top ); - } - _mesa_transform_vector( tmp, params, ctx->ModelviewMatrixStack.Top->inv ); - if (TEST_EQ_4V(texUnit->EyePlaneQ, tmp)) - return; - FLUSH_VERTICES(ctx, _NEW_TEXTURE); - COPY_4FV(texUnit->EyePlaneQ, tmp); - } - else { - _mesa_error( ctx, GL_INVALID_ENUM, "glTexGenfv(pname)" ); - return; - } - break; - default: - _mesa_error( ctx, GL_INVALID_ENUM, "glTexGenfv(coord)" ); - return; + texgen = get_texgen(texUnit, coord); + if (!texgen) { + _mesa_error(ctx, GL_INVALID_ENUM, "glTexGen(coord)"); + return; + } + + switch (pname) { + case GL_TEXTURE_GEN_MODE: + { + GLenum mode = (GLenum) (GLint) params[0]; + GLbitfield bit = 0x0; + if (texgen->Mode == mode) + return; + switch (mode) { + case GL_OBJECT_LINEAR: + bit = TEXGEN_OBJ_LINEAR; + break; + case GL_EYE_LINEAR: + bit = TEXGEN_EYE_LINEAR; + break; + case GL_SPHERE_MAP: + if (coord == GL_S || coord == GL_T) + bit = TEXGEN_SPHERE_MAP; + break; + case GL_REFLECTION_MAP_NV: + if (coord != GL_Q) + bit = TEXGEN_REFLECTION_MAP_NV; + break; + case GL_NORMAL_MAP_NV: + if (coord != GL_Q) + bit = TEXGEN_NORMAL_MAP_NV; + break; + default: + ; /* nop */ + } + if (!bit) { + _mesa_error( ctx, GL_INVALID_ENUM, "glTexGenfv(param)" ); + return; + } + FLUSH_VERTICES(ctx, _NEW_TEXTURE); + texgen->Mode = mode; + texgen->_ModeBit = bit; + } + break; + + case GL_OBJECT_PLANE: + { + if (TEST_EQ_4V(texgen->ObjectPlane, params)) + return; + FLUSH_VERTICES(ctx, _NEW_TEXTURE); + COPY_4FV(texgen->ObjectPlane, params); + } + break; + + case GL_EYE_PLANE: + { + GLfloat tmp[4]; + /* Transform plane equation by the inverse modelview matrix */ + if (_math_matrix_is_dirty(ctx->ModelviewMatrixStack.Top)) { + _math_matrix_analyse(ctx->ModelviewMatrixStack.Top); + } + _mesa_transform_vector(tmp, params, + ctx->ModelviewMatrixStack.Top->inv); + if (TEST_EQ_4V(texgen->EyePlane, tmp)) + return; + FLUSH_VERTICES(ctx, _NEW_TEXTURE); + COPY_4FV(texgen->EyePlane, tmp); + } + break; + + default: + _mesa_error( ctx, GL_INVALID_ENUM, "glTexGenfv(pname)" ); + return; } if (ctx->Driver.TexGen) @@ -330,7 +221,8 @@ _mesa_TexGeni( GLenum coord, GLenum pname, GLint param ) void GLAPIENTRY _mesa_GetTexGendv( GLenum coord, GLenum pname, GLdouble *params ) { - const struct gl_texture_unit *texUnit; + struct gl_texture_unit *texUnit; + struct gl_texgen *texgen; GET_CURRENT_CONTEXT(ctx); ASSERT_OUTSIDE_BEGIN_END(ctx); @@ -341,70 +233,24 @@ _mesa_GetTexGendv( GLenum coord, GLenum pname, GLdouble *params ) texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit]; - switch (coord) { - case GL_S: - if (pname==GL_TEXTURE_GEN_MODE) { - params[0] = ENUM_TO_DOUBLE(texUnit->GenModeS); - } - else if (pname==GL_OBJECT_PLANE) { - COPY_4V( params, texUnit->ObjectPlaneS ); - } - else if (pname==GL_EYE_PLANE) { - COPY_4V( params, texUnit->EyePlaneS ); - } - else { - _mesa_error( ctx, GL_INVALID_ENUM, "glGetTexGendv(pname)" ); - return; - } - break; - case GL_T: - if (pname==GL_TEXTURE_GEN_MODE) { - params[0] = ENUM_TO_DOUBLE(texUnit->GenModeT); - } - else if (pname==GL_OBJECT_PLANE) { - COPY_4V( params, texUnit->ObjectPlaneT ); - } - else if (pname==GL_EYE_PLANE) { - COPY_4V( params, texUnit->EyePlaneT ); - } - else { - _mesa_error( ctx, GL_INVALID_ENUM, "glGetTexGendv(pname)" ); - return; - } - break; - case GL_R: - if (pname==GL_TEXTURE_GEN_MODE) { - params[0] = ENUM_TO_DOUBLE(texUnit->GenModeR); - } - else if (pname==GL_OBJECT_PLANE) { - COPY_4V( params, texUnit->ObjectPlaneR ); - } - else if (pname==GL_EYE_PLANE) { - COPY_4V( params, texUnit->EyePlaneR ); - } - else { - _mesa_error( ctx, GL_INVALID_ENUM, "glGetTexGendv(pname)" ); - return; - } - break; - case GL_Q: - if (pname==GL_TEXTURE_GEN_MODE) { - params[0] = ENUM_TO_DOUBLE(texUnit->GenModeQ); - } - else if (pname==GL_OBJECT_PLANE) { - COPY_4V( params, texUnit->ObjectPlaneQ ); - } - else if (pname==GL_EYE_PLANE) { - COPY_4V( params, texUnit->EyePlaneQ ); - } - else { - _mesa_error( ctx, GL_INVALID_ENUM, "glGetTexGendv(pname)" ); - return; - } - break; - default: - _mesa_error( ctx, GL_INVALID_ENUM, "glGetTexGendv(coord)" ); - return; + texgen = get_texgen(texUnit, coord); + if (!texgen) { + _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexGendv(coord)"); + return; + } + + switch (pname) { + case GL_TEXTURE_GEN_MODE: + params[0] = ENUM_TO_DOUBLE(texgen->Mode); + break; + case GL_OBJECT_PLANE: + COPY_4V(params, texgen->ObjectPlane); + break; + case GL_EYE_PLANE: + COPY_4V(params, texgen->EyePlane); + break; + default: + _mesa_error( ctx, GL_INVALID_ENUM, "glGetTexGendv(pname)" ); } } @@ -413,7 +259,8 @@ _mesa_GetTexGendv( GLenum coord, GLenum pname, GLdouble *params ) void GLAPIENTRY _mesa_GetTexGenfv( GLenum coord, GLenum pname, GLfloat *params ) { - const struct gl_texture_unit *texUnit; + struct gl_texture_unit *texUnit; + struct gl_texgen *texgen; GET_CURRENT_CONTEXT(ctx); ASSERT_OUTSIDE_BEGIN_END(ctx); @@ -424,70 +271,24 @@ _mesa_GetTexGenfv( GLenum coord, GLenum pname, GLfloat *params ) texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit]; - switch (coord) { - case GL_S: - if (pname==GL_TEXTURE_GEN_MODE) { - params[0] = ENUM_TO_FLOAT(texUnit->GenModeS); - } - else if (pname==GL_OBJECT_PLANE) { - COPY_4V( params, texUnit->ObjectPlaneS ); - } - else if (pname==GL_EYE_PLANE) { - COPY_4V( params, texUnit->EyePlaneS ); - } - else { - _mesa_error( ctx, GL_INVALID_ENUM, "glGetTexGenfv(pname)" ); - return; - } - break; - case GL_T: - if (pname==GL_TEXTURE_GEN_MODE) { - params[0] = ENUM_TO_FLOAT(texUnit->GenModeT); - } - else if (pname==GL_OBJECT_PLANE) { - COPY_4V( params, texUnit->ObjectPlaneT ); - } - else if (pname==GL_EYE_PLANE) { - COPY_4V( params, texUnit->EyePlaneT ); - } - else { - _mesa_error( ctx, GL_INVALID_ENUM, "glGetTexGenfv(pname)" ); - return; - } - break; - case GL_R: - if (pname==GL_TEXTURE_GEN_MODE) { - params[0] = ENUM_TO_FLOAT(texUnit->GenModeR); - } - else if (pname==GL_OBJECT_PLANE) { - COPY_4V( params, texUnit->ObjectPlaneR ); - } - else if (pname==GL_EYE_PLANE) { - COPY_4V( params, texUnit->EyePlaneR ); - } - else { - _mesa_error( ctx, GL_INVALID_ENUM, "glGetTexGenfv(pname)" ); - return; - } - break; - case GL_Q: - if (pname==GL_TEXTURE_GEN_MODE) { - params[0] = ENUM_TO_FLOAT(texUnit->GenModeQ); - } - else if (pname==GL_OBJECT_PLANE) { - COPY_4V( params, texUnit->ObjectPlaneQ ); - } - else if (pname==GL_EYE_PLANE) { - COPY_4V( params, texUnit->EyePlaneQ ); - } - else { - _mesa_error( ctx, GL_INVALID_ENUM, "glGetTexGenfv(pname)" ); - return; - } - break; - default: - _mesa_error( ctx, GL_INVALID_ENUM, "glGetTexGenfv(coord)" ); - return; + texgen = get_texgen(texUnit, coord); + if (!texgen) { + _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexGenfv(coord)"); + return; + } + + switch (pname) { + case GL_TEXTURE_GEN_MODE: + params[0] = ENUM_TO_FLOAT(texgen->Mode); + break; + case GL_OBJECT_PLANE: + COPY_4V(params, texgen->ObjectPlane); + break; + case GL_EYE_PLANE: + COPY_4V(params, texgen->EyePlane); + break; + default: + _mesa_error( ctx, GL_INVALID_ENUM, "glGetTexGenfv(pname)" ); } } @@ -496,7 +297,8 @@ _mesa_GetTexGenfv( GLenum coord, GLenum pname, GLfloat *params ) void GLAPIENTRY _mesa_GetTexGeniv( GLenum coord, GLenum pname, GLint *params ) { - const struct gl_texture_unit *texUnit; + struct gl_texture_unit *texUnit; + struct gl_texgen *texgen; GET_CURRENT_CONTEXT(ctx); ASSERT_OUTSIDE_BEGIN_END(ctx); @@ -507,94 +309,30 @@ _mesa_GetTexGeniv( GLenum coord, GLenum pname, GLint *params ) texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit]; - switch (coord) { - case GL_S: - if (pname==GL_TEXTURE_GEN_MODE) { - params[0] = texUnit->GenModeS; - } - else if (pname==GL_OBJECT_PLANE) { - params[0] = (GLint) texUnit->ObjectPlaneS[0]; - params[1] = (GLint) texUnit->ObjectPlaneS[1]; - params[2] = (GLint) texUnit->ObjectPlaneS[2]; - params[3] = (GLint) texUnit->ObjectPlaneS[3]; - } - else if (pname==GL_EYE_PLANE) { - params[0] = (GLint) texUnit->EyePlaneS[0]; - params[1] = (GLint) texUnit->EyePlaneS[1]; - params[2] = (GLint) texUnit->EyePlaneS[2]; - params[3] = (GLint) texUnit->EyePlaneS[3]; - } - else { - _mesa_error( ctx, GL_INVALID_ENUM, "glGetTexGeniv(pname)" ); - return; - } - break; - case GL_T: - if (pname==GL_TEXTURE_GEN_MODE) { - params[0] = texUnit->GenModeT; - } - else if (pname==GL_OBJECT_PLANE) { - params[0] = (GLint) texUnit->ObjectPlaneT[0]; - params[1] = (GLint) texUnit->ObjectPlaneT[1]; - params[2] = (GLint) texUnit->ObjectPlaneT[2]; - params[3] = (GLint) texUnit->ObjectPlaneT[3]; - } - else if (pname==GL_EYE_PLANE) { - params[0] = (GLint) texUnit->EyePlaneT[0]; - params[1] = (GLint) texUnit->EyePlaneT[1]; - params[2] = (GLint) texUnit->EyePlaneT[2]; - params[3] = (GLint) texUnit->EyePlaneT[3]; - } - else { - _mesa_error( ctx, GL_INVALID_ENUM, "glGetTexGeniv(pname)" ); - return; - } - break; - case GL_R: - if (pname==GL_TEXTURE_GEN_MODE) { - params[0] = texUnit->GenModeR; - } - else if (pname==GL_OBJECT_PLANE) { - params[0] = (GLint) texUnit->ObjectPlaneR[0]; - params[1] = (GLint) texUnit->ObjectPlaneR[1]; - params[2] = (GLint) texUnit->ObjectPlaneR[2]; - params[3] = (GLint) texUnit->ObjectPlaneR[3]; - } - else if (pname==GL_EYE_PLANE) { - params[0] = (GLint) texUnit->EyePlaneR[0]; - params[1] = (GLint) texUnit->EyePlaneR[1]; - params[2] = (GLint) texUnit->EyePlaneR[2]; - params[3] = (GLint) texUnit->EyePlaneR[3]; - } - else { - _mesa_error( ctx, GL_INVALID_ENUM, "glGetTexGeniv(pname)" ); - return; - } - break; - case GL_Q: - if (pname==GL_TEXTURE_GEN_MODE) { - params[0] = texUnit->GenModeQ; - } - else if (pname==GL_OBJECT_PLANE) { - params[0] = (GLint) texUnit->ObjectPlaneQ[0]; - params[1] = (GLint) texUnit->ObjectPlaneQ[1]; - params[2] = (GLint) texUnit->ObjectPlaneQ[2]; - params[3] = (GLint) texUnit->ObjectPlaneQ[3]; - } - else if (pname==GL_EYE_PLANE) { - params[0] = (GLint) texUnit->EyePlaneQ[0]; - params[1] = (GLint) texUnit->EyePlaneQ[1]; - params[2] = (GLint) texUnit->EyePlaneQ[2]; - params[3] = (GLint) texUnit->EyePlaneQ[3]; - } - else { - _mesa_error( ctx, GL_INVALID_ENUM, "glGetTexGeniv(pname)" ); - return; - } - break; - default: - _mesa_error( ctx, GL_INVALID_ENUM, "glGetTexGeniv(coord)" ); - return; + texgen = get_texgen(texUnit, coord); + if (!texgen) { + _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexGeniv(coord)"); + return; + } + + switch (pname) { + case GL_TEXTURE_GEN_MODE: + params[0] = texgen->Mode; + break; + case GL_OBJECT_PLANE: + params[0] = (GLint) texgen->ObjectPlane[0]; + params[1] = (GLint) texgen->ObjectPlane[1]; + params[2] = (GLint) texgen->ObjectPlane[2]; + params[3] = (GLint) texgen->ObjectPlane[3]; + break; + case GL_EYE_PLANE: + params[0] = (GLint) texgen->EyePlane[0]; + params[1] = (GLint) texgen->EyePlane[1]; + params[2] = (GLint) texgen->EyePlane[2]; + params[3] = (GLint) texgen->EyePlane[3]; + break; + default: + _mesa_error( ctx, GL_INVALID_ENUM, "glGetTexGeniv(pname)" ); } } diff --git a/src/mesa/main/teximage.c b/src/mesa/main/teximage.c index 8fd69c4f6a..4f297738df 100644 --- a/src/mesa/main/teximage.c +++ b/src/mesa/main/teximage.c @@ -339,6 +339,17 @@ _mesa_base_tex_format( GLcontext *ctx, GLint internalFormat ) } } + if (ctx->Extensions.ATI_envmap_bumpmap) { + switch (internalFormat) { + case GL_DUDV_ATI: + case GL_DU8DV8_ATI: + return GL_DUDV_ATI; + default: + ; /* fallthrough */ + } + } + + if (ctx->Extensions.EXT_packed_depth_stencil) { switch (internalFormat) { case GL_DEPTH_STENCIL_EXT: @@ -568,6 +579,20 @@ is_depthstencil_format(GLenum format) } } +/** + * Test if the given image format is a dudv format. + */ +static GLboolean +is_dudv_format(GLenum format) +{ + switch (format) { + case GL_DUDV_ATI: + case GL_DU8DV8_ATI: + return GL_TRUE; + default: + return GL_FALSE; + } +} /** @@ -687,7 +712,7 @@ _mesa_new_texture_image( GLcontext *ctx ) * Free texture image data. * This function is a fallback called via ctx->Driver.FreeTexImageData(). * - * \param teximage texture image. + * \param texImage texture image. * * Free the texture image data if it's not marked as client data. */ @@ -709,7 +734,7 @@ _mesa_free_texture_image_data(GLcontext *ctx, /** * Free texture image. * - * \param teximage texture image. + * \param texImage texture image. * * Free the texture image structure and the associated image data. */ @@ -766,15 +791,15 @@ _mesa_select_tex_object(GLcontext *ctx, const struct gl_texture_unit *texUnit, { switch (target) { case GL_TEXTURE_1D: - return texUnit->Current1D; + return texUnit->CurrentTex[TEXTURE_1D_INDEX]; case GL_PROXY_TEXTURE_1D: return ctx->Texture.ProxyTex[TEXTURE_1D_INDEX]; case GL_TEXTURE_2D: - return texUnit->Current2D; + return texUnit->CurrentTex[TEXTURE_2D_INDEX]; case GL_PROXY_TEXTURE_2D: return ctx->Texture.ProxyTex[TEXTURE_2D_INDEX]; case GL_TEXTURE_3D: - return texUnit->Current3D; + return texUnit->CurrentTex[TEXTURE_3D_INDEX]; case GL_PROXY_TEXTURE_3D: return ctx->Texture.ProxyTex[TEXTURE_3D_INDEX]; case GL_TEXTURE_CUBE_MAP_POSITIVE_X_ARB: @@ -785,25 +810,25 @@ _mesa_select_tex_object(GLcontext *ctx, const struct gl_texture_unit *texUnit, case GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_ARB: case GL_TEXTURE_CUBE_MAP_ARB: return ctx->Extensions.ARB_texture_cube_map - ? texUnit->CurrentCubeMap : NULL; + ? texUnit->CurrentTex[TEXTURE_CUBE_INDEX] : NULL; case GL_PROXY_TEXTURE_CUBE_MAP_ARB: return ctx->Extensions.ARB_texture_cube_map ? ctx->Texture.ProxyTex[TEXTURE_CUBE_INDEX] : NULL; case GL_TEXTURE_RECTANGLE_NV: return ctx->Extensions.NV_texture_rectangle - ? texUnit->CurrentRect : NULL; + ? texUnit->CurrentTex[TEXTURE_RECT_INDEX] : NULL; case GL_PROXY_TEXTURE_RECTANGLE_NV: return ctx->Extensions.NV_texture_rectangle ? ctx->Texture.ProxyTex[TEXTURE_RECT_INDEX] : NULL; case GL_TEXTURE_1D_ARRAY_EXT: return ctx->Extensions.MESA_texture_array - ? texUnit->Current1DArray : NULL; + ? texUnit->CurrentTex[TEXTURE_1D_ARRAY_INDEX] : NULL; case GL_PROXY_TEXTURE_1D_ARRAY_EXT: return ctx->Extensions.MESA_texture_array ? ctx->Texture.ProxyTex[TEXTURE_1D_ARRAY_INDEX] : NULL; case GL_TEXTURE_2D_ARRAY_EXT: return ctx->Extensions.MESA_texture_array - ? texUnit->Current2DArray : NULL; + ? texUnit->CurrentTex[TEXTURE_2D_ARRAY_INDEX] : NULL; case GL_PROXY_TEXTURE_2D_ARRAY_EXT: return ctx->Extensions.MESA_texture_array ? ctx->Texture.ProxyTex[TEXTURE_2D_ARRAY_INDEX] : NULL; @@ -819,7 +844,7 @@ _mesa_select_tex_object(GLcontext *ctx, const struct gl_texture_unit *texUnit, * of the given texture unit. * * \param ctx GL context. - * \param texUnit texture unit. + * \param texObj texture unit. * \param target texture target. * \param level image level. * @@ -1527,7 +1552,8 @@ texture_error_check( GLcontext *ctx, GLenum target, */ if (!isProxy) { _mesa_error(ctx, GL_INVALID_OPERATION, - "glTexImage%dD(format or type)", dimensions); + "glTexImage%dD(incompatible format 0x%x, type 0x%x)", + dimensions, format, type); } return GL_TRUE; } @@ -1539,10 +1565,12 @@ texture_error_check( GLcontext *ctx, GLenum target, (is_index_format(internalFormat) && !indexFormat) || (is_depth_format(internalFormat) != is_depth_format(format)) || (is_ycbcr_format(internalFormat) != is_ycbcr_format(format)) || - (is_depthstencil_format(internalFormat) != is_depthstencil_format(format))) { + (is_depthstencil_format(internalFormat) != is_depthstencil_format(format)) || + (is_dudv_format(internalFormat) != is_dudv_format(format))) { if (!isProxy) _mesa_error(ctx, GL_INVALID_OPERATION, - "glTexImage(internalFormat/format)"); + "glTexImage%dD(incompatible internalFormat 0x%x, format 0x%x)", + dimensions, internalFormat, format); return GL_TRUE; } @@ -1716,7 +1744,8 @@ subtexture_error_check( GLcontext *ctx, GLuint dimensions, if (!_mesa_is_legal_format_and_type(ctx, format, type)) { _mesa_error(ctx, GL_INVALID_ENUM, - "glTexSubImage%dD(format or type)", dimensions); + "glTexSubImage%dD(incompatible format 0x%x, type 0x%x)", + dimensions, format, type); return GL_TRUE; } @@ -1823,7 +1852,6 @@ subtexture_error_check2( GLcontext *ctx, GLuint dimensions, * \param internalFormat internal format given by the user. * \param width image width given by the user. * \param height image height given by the user. - * \param depth image depth given by the user. * \param border texture border. * * \return GL_TRUE if an error was detected, or GL_FALSE if no errors. @@ -2273,6 +2301,12 @@ _mesa_GetTexImage( GLenum target, GLint level, GLenum format, return; } + if (!ctx->Extensions.ATI_envmap_bumpmap + && is_dudv_format(format)) { + _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexImage(format)"); + return; + } + _mesa_lock_texture(ctx, texObj); { texImage = _mesa_select_tex_image(ctx, texObj, target, level); @@ -2313,6 +2347,11 @@ _mesa_GetTexImage( GLenum target, GLint level, GLenum format, _mesa_error(ctx, GL_INVALID_OPERATION, "glGetTexImage(format mismatch)"); goto out; } + else if (is_dudv_format(format) + && !is_dudv_format(texImage->TexFormat->BaseFormat)) { + _mesa_error(ctx, GL_INVALID_OPERATION, "glGetTexImage(format mismatch)"); + goto out; + } if (ctx->Pack.BufferObj->Name) { /* packing texture image into a PBO */ @@ -2400,6 +2439,49 @@ update_fbo_texture(GLcontext *ctx, struct gl_texture_object *texObj, } +/** Debug helper: override the user-requested internal format */ +static GLenum +override_internal_format(GLenum internalFormat, GLint width, GLint height) +{ +#if 0 + if (internalFormat == GL_RGBA16F_ARB || + internalFormat == GL_RGBA32F_ARB) { + printf("Convert rgba float tex to int %d x %d\n", width, height); + return GL_RGBA; + } + else if (internalFormat == GL_RGB16F_ARB || + internalFormat == GL_RGB32F_ARB) { + printf("Convert rgb float tex to int %d x %d\n", width, height); + return GL_RGB; + } + else if (internalFormat == GL_LUMINANCE_ALPHA16F_ARB || + internalFormat == GL_LUMINANCE_ALPHA32F_ARB) { + printf("Convert luminance float tex to int %d x %d\n", width, height); + return GL_LUMINANCE_ALPHA; + } + else if (internalFormat == GL_LUMINANCE16F_ARB || + internalFormat == GL_LUMINANCE32F_ARB) { + printf("Convert luminance float tex to int %d x %d\n", width, height); + return GL_LUMINANCE; + } + else if (internalFormat == GL_ALPHA16F_ARB || + internalFormat == GL_ALPHA32F_ARB) { + printf("Convert luminance float tex to int %d x %d\n", width, height); + return GL_ALPHA; + } + /* + else if (internalFormat == GL_COMPRESSED_RGBA_S3TC_DXT1_EXT) { + internalFormat = GL_RGBA; + } + */ + else { + return internalFormat; + } +#else + return internalFormat; +#endif +} + /* * Called from the API. Note that width includes the border. @@ -2413,6 +2495,8 @@ _mesa_TexImage1D( GLenum target, GLint level, GLint internalFormat, GET_CURRENT_CONTEXT(ctx); ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx); + internalFormat = override_internal_format(internalFormat, width, 1); + #if FEATURE_convolve if (_mesa_is_color_format(internalFormat)) { _mesa_adjust_image_for_convolution(ctx, 1, &postConvWidth, NULL); @@ -2510,6 +2594,8 @@ _mesa_TexImage2D( GLenum target, GLint level, GLint internalFormat, GET_CURRENT_CONTEXT(ctx); ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx); + internalFormat = override_internal_format(internalFormat, width, height); + #if FEATURE_convolve if (_mesa_is_color_format(internalFormat)) { _mesa_adjust_image_for_convolution(ctx, 2, &postConvWidth, @@ -2624,6 +2710,8 @@ _mesa_TexImage3D( GLenum target, GLint level, GLint internalFormat, GET_CURRENT_CONTEXT(ctx); ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx); + internalFormat = override_internal_format(internalFormat, width, height); + if (target == GL_TEXTURE_3D || (ctx->Extensions.MESA_texture_array && target == GL_TEXTURE_2D_ARRAY_EXT)) { diff --git a/src/mesa/main/texobj.c b/src/mesa/main/texobj.c index b4e30c8bb7..b63f747fe8 100644 --- a/src/mesa/main/texobj.c +++ b/src/mesa/main/texobj.c @@ -28,7 +28,7 @@ */ -#include "glheader.h" +#include "mfeatures.h" #if FEATURE_colortable #include "colortab.h" #endif @@ -180,7 +180,7 @@ finish_texture_init(GLcontext *ctx, GLenum target, * Called via ctx->Driver.DeleteTexture() if not overriden by a driver. * * \param shared the shared GL state to which the object belongs. - * \param texOjb the texture object to delete. + * \param texObj the texture object to delete. */ void _mesa_delete_texture_object( GLcontext *ctx, struct gl_texture_object *texObj ) @@ -759,37 +759,17 @@ unbind_texobj_from_fbo(GLcontext *ctx, struct gl_texture_object *texObj) static void unbind_texobj_from_texunits(GLcontext *ctx, struct gl_texture_object *texObj) { - GLuint u; + GLuint u, tex; for (u = 0; u < MAX_TEXTURE_IMAGE_UNITS; u++) { struct gl_texture_unit *unit = &ctx->Texture.Unit[u]; - if (texObj == unit->Current1D) { - _mesa_reference_texobj(&unit->Current1D, ctx->Shared->Default1D); - ASSERT(unit->Current1D); - } - else if (texObj == unit->Current2D) { - _mesa_reference_texobj(&unit->Current2D, ctx->Shared->Default2D); - ASSERT(unit->Current2D); - } - else if (texObj == unit->Current3D) { - _mesa_reference_texobj(&unit->Current3D, ctx->Shared->Default3D); - ASSERT(unit->Current3D); - } - else if (texObj == unit->CurrentCubeMap) { - _mesa_reference_texobj(&unit->CurrentCubeMap, ctx->Shared->DefaultCubeMap); - ASSERT(unit->CurrentCubeMap); - } - else if (texObj == unit->CurrentRect) { - _mesa_reference_texobj(&unit->CurrentRect, ctx->Shared->DefaultRect); - ASSERT(unit->CurrentRect); - } - else if (texObj == unit->Current1DArray) { - _mesa_reference_texobj(&unit->Current1DArray, ctx->Shared->Default1DArray); - ASSERT(unit->Current1DArray); - } - else if (texObj == unit->Current2DArray) { - _mesa_reference_texobj(&unit->Current2DArray, ctx->Shared->Default2DArray); - ASSERT(unit->Current2DArray); + for (tex = 0; tex < NUM_TEXTURE_TARGETS; tex++) { + if (texObj == unit->CurrentTex[tex]) { + _mesa_reference_texobj(&unit->CurrentTex[tex], + ctx->Shared->DefaultTex[TEXTURE_1D_INDEX]); + ASSERT(unit->CurrentTex[tex]); + break; + } } } } @@ -860,6 +840,35 @@ _mesa_DeleteTextures( GLsizei n, const GLuint *textures) /** + * Convert a GL texture target enum such as GL_TEXTURE_2D or GL_TEXTURE_3D + * into the corresponding Mesa texture target index. + * Return -1 if target is invalid. + */ +static GLint +target_enum_to_index(GLenum target) +{ + switch (target) { + case GL_TEXTURE_1D: + return TEXTURE_1D_INDEX; + case GL_TEXTURE_2D: + return TEXTURE_2D_INDEX; + case GL_TEXTURE_3D: + return TEXTURE_3D_INDEX; + case GL_TEXTURE_CUBE_MAP_ARB: + return TEXTURE_CUBE_INDEX; + case GL_TEXTURE_RECTANGLE_NV: + return TEXTURE_RECT_INDEX; + case GL_TEXTURE_1D_ARRAY_EXT: + return TEXTURE_1D_ARRAY_INDEX; + case GL_TEXTURE_2D_ARRAY_EXT: + return TEXTURE_2D_ARRAY_INDEX; + default: + return -1; + } +} + + +/** * Bind a named texture to a texturing target. * * \param target texture target. @@ -881,38 +890,20 @@ _mesa_BindTexture( GLenum target, GLuint texName ) const GLuint unit = ctx->Texture.CurrentUnit; struct gl_texture_unit *texUnit = &ctx->Texture.Unit[unit]; struct gl_texture_object *newTexObj = NULL, *defaultTexObj = NULL; + GLint targetIndex; ASSERT_OUTSIDE_BEGIN_END(ctx); if (MESA_VERBOSE & (VERBOSE_API|VERBOSE_TEXTURE)) _mesa_debug(ctx, "glBindTexture %s %d\n", _mesa_lookup_enum_by_nr(target), (GLint) texName); - switch (target) { - case GL_TEXTURE_1D: - defaultTexObj = ctx->Shared->Default1D; - break; - case GL_TEXTURE_2D: - defaultTexObj = ctx->Shared->Default2D; - break; - case GL_TEXTURE_3D: - defaultTexObj = ctx->Shared->Default3D; - break; - case GL_TEXTURE_CUBE_MAP_ARB: - defaultTexObj = ctx->Shared->DefaultCubeMap; - break; - case GL_TEXTURE_RECTANGLE_NV: - defaultTexObj = ctx->Shared->DefaultRect; - break; - case GL_TEXTURE_1D_ARRAY_EXT: - defaultTexObj = ctx->Shared->Default1DArray; - break; - case GL_TEXTURE_2D_ARRAY_EXT: - defaultTexObj = ctx->Shared->Default2DArray; - break; - default: + targetIndex = target_enum_to_index(target); + if (targetIndex < 0) { _mesa_error(ctx, GL_INVALID_ENUM, "glBindTexture(target)"); return; } + assert(targetIndex < NUM_TEXTURE_TARGETS); + defaultTexObj = ctx->Shared->DefaultTex[targetIndex]; /* * Get pointer to new texture object (newTexObj) @@ -960,40 +951,8 @@ _mesa_BindTexture( GLenum target, GLuint texName ) * texture object will be decremented. It'll be deleted if the * count hits zero. */ - switch (target) { - case GL_TEXTURE_1D: - _mesa_reference_texobj(&texUnit->Current1D, newTexObj); - ASSERT(texUnit->Current1D); - break; - case GL_TEXTURE_2D: - _mesa_reference_texobj(&texUnit->Current2D, newTexObj); - ASSERT(texUnit->Current2D); - break; - case GL_TEXTURE_3D: - _mesa_reference_texobj(&texUnit->Current3D, newTexObj); - ASSERT(texUnit->Current3D); - break; - case GL_TEXTURE_CUBE_MAP_ARB: - _mesa_reference_texobj(&texUnit->CurrentCubeMap, newTexObj); - ASSERT(texUnit->CurrentCubeMap); - break; - case GL_TEXTURE_RECTANGLE_NV: - _mesa_reference_texobj(&texUnit->CurrentRect, newTexObj); - ASSERT(texUnit->CurrentRect); - break; - case GL_TEXTURE_1D_ARRAY_EXT: - _mesa_reference_texobj(&texUnit->Current1DArray, newTexObj); - ASSERT(texUnit->Current1DArray); - break; - case GL_TEXTURE_2D_ARRAY_EXT: - _mesa_reference_texobj(&texUnit->Current2DArray, newTexObj); - ASSERT(texUnit->Current2DArray); - break; - default: - /* Bad target should be caught above */ - _mesa_problem(ctx, "bad target in BindTexture"); - return; - } + _mesa_reference_texobj(&texUnit->CurrentTex[targetIndex], newTexObj); + ASSERT(texUnit->CurrentTex[targetIndex]); /* Pass BindTexture call to device driver */ if (ctx->Driver.BindTexture) diff --git a/src/mesa/main/texparam.c b/src/mesa/main/texparam.c index 865aae8627..50f867e1c1 100644 --- a/src/mesa/main/texparam.c +++ b/src/mesa/main/texparam.c @@ -92,29 +92,29 @@ get_texobj(GLcontext *ctx, GLenum target) switch (target) { case GL_TEXTURE_1D: - return texUnit->Current1D; + return texUnit->CurrentTex[TEXTURE_1D_INDEX]; case GL_TEXTURE_2D: - return texUnit->Current2D; + return texUnit->CurrentTex[TEXTURE_2D_INDEX]; case GL_TEXTURE_3D: - return texUnit->Current3D; + return texUnit->CurrentTex[TEXTURE_3D_INDEX]; case GL_TEXTURE_CUBE_MAP: if (ctx->Extensions.ARB_texture_cube_map) { - return texUnit->CurrentCubeMap; + return texUnit->CurrentTex[TEXTURE_CUBE_INDEX]; } break; case GL_TEXTURE_RECTANGLE_NV: if (ctx->Extensions.NV_texture_rectangle) { - return texUnit->CurrentRect; + return texUnit->CurrentTex[TEXTURE_RECT_INDEX]; } break; case GL_TEXTURE_1D_ARRAY_EXT: if (ctx->Extensions.MESA_texture_array) { - return texUnit->Current1DArray; + return texUnit->CurrentTex[TEXTURE_1D_ARRAY_INDEX]; } break; case GL_TEXTURE_2D_ARRAY_EXT: if (ctx->Extensions.MESA_texture_array) { - return texUnit->Current2DArray; + return texUnit->CurrentTex[TEXTURE_2D_ARRAY_INDEX]; } break; default: diff --git a/src/mesa/main/texstate.c b/src/mesa/main/texstate.c index 7761af7589..73f8a5339e 100644 --- a/src/mesa/main/texstate.c +++ b/src/mesa/main/texstate.c @@ -1,6 +1,6 @@ /* * Mesa 3-D graphics library - * Version: 7.1 + * Version: 7.5 * * Copyright (C) 1999-2007 Brian Paul All Rights Reserved. * @@ -29,6 +29,7 @@ */ #include "glheader.h" +#include "mfeatures.h" #include "colormac.h" #if FEATURE_colortable #include "colortab.h" @@ -42,7 +43,6 @@ #include "texstate.h" #include "texenvprogram.h" #include "mtypes.h" -#include "math/m_xform.h" @@ -69,7 +69,7 @@ static const struct gl_tex_env_combine_state default_combine_state = { void _mesa_copy_texture_state( const GLcontext *src, GLcontext *dst ) { - GLuint i; + GLuint u, tex; ASSERT(src); ASSERT(dst); @@ -81,57 +81,32 @@ _mesa_copy_texture_state( const GLcontext *src, GLcontext *dst ) dst->Texture.SharedPalette = src->Texture.SharedPalette; /* per-unit state */ - for (i = 0; i < src->Const.MaxTextureImageUnits; i++) { - dst->Texture.Unit[i].Enabled = src->Texture.Unit[i].Enabled; - dst->Texture.Unit[i].EnvMode = src->Texture.Unit[i].EnvMode; - COPY_4V(dst->Texture.Unit[i].EnvColor, src->Texture.Unit[i].EnvColor); - dst->Texture.Unit[i].TexGenEnabled = src->Texture.Unit[i].TexGenEnabled; - dst->Texture.Unit[i].GenModeS = src->Texture.Unit[i].GenModeS; - dst->Texture.Unit[i].GenModeT = src->Texture.Unit[i].GenModeT; - dst->Texture.Unit[i].GenModeR = src->Texture.Unit[i].GenModeR; - dst->Texture.Unit[i].GenModeQ = src->Texture.Unit[i].GenModeQ; - dst->Texture.Unit[i]._GenBitS = src->Texture.Unit[i]._GenBitS; - dst->Texture.Unit[i]._GenBitT = src->Texture.Unit[i]._GenBitT; - dst->Texture.Unit[i]._GenBitR = src->Texture.Unit[i]._GenBitR; - dst->Texture.Unit[i]._GenBitQ = src->Texture.Unit[i]._GenBitQ; - dst->Texture.Unit[i]._GenFlags = src->Texture.Unit[i]._GenFlags; - COPY_4V(dst->Texture.Unit[i].ObjectPlaneS, src->Texture.Unit[i].ObjectPlaneS); - COPY_4V(dst->Texture.Unit[i].ObjectPlaneT, src->Texture.Unit[i].ObjectPlaneT); - COPY_4V(dst->Texture.Unit[i].ObjectPlaneR, src->Texture.Unit[i].ObjectPlaneR); - COPY_4V(dst->Texture.Unit[i].ObjectPlaneQ, src->Texture.Unit[i].ObjectPlaneQ); - COPY_4V(dst->Texture.Unit[i].EyePlaneS, src->Texture.Unit[i].EyePlaneS); - COPY_4V(dst->Texture.Unit[i].EyePlaneT, src->Texture.Unit[i].EyePlaneT); - COPY_4V(dst->Texture.Unit[i].EyePlaneR, src->Texture.Unit[i].EyePlaneR); - COPY_4V(dst->Texture.Unit[i].EyePlaneQ, src->Texture.Unit[i].EyePlaneQ); - dst->Texture.Unit[i].LodBias = src->Texture.Unit[i].LodBias; + for (u = 0; u < src->Const.MaxTextureImageUnits; u++) { + dst->Texture.Unit[u].Enabled = src->Texture.Unit[u].Enabled; + dst->Texture.Unit[u].EnvMode = src->Texture.Unit[u].EnvMode; + COPY_4V(dst->Texture.Unit[u].EnvColor, src->Texture.Unit[u].EnvColor); + dst->Texture.Unit[u].TexGenEnabled = src->Texture.Unit[u].TexGenEnabled; + dst->Texture.Unit[u].GenS = src->Texture.Unit[u].GenS; + dst->Texture.Unit[u].GenT = src->Texture.Unit[u].GenT; + dst->Texture.Unit[u].GenR = src->Texture.Unit[u].GenR; + dst->Texture.Unit[u].GenQ = src->Texture.Unit[u].GenQ; + dst->Texture.Unit[u].LodBias = src->Texture.Unit[u].LodBias; /* GL_EXT_texture_env_combine */ - dst->Texture.Unit[i].Combine.ModeRGB = src->Texture.Unit[i].Combine.ModeRGB; - dst->Texture.Unit[i].Combine.ModeA = src->Texture.Unit[i].Combine.ModeA; - COPY_3V(dst->Texture.Unit[i].Combine.SourceRGB, src->Texture.Unit[i].Combine.SourceRGB); - COPY_3V(dst->Texture.Unit[i].Combine.SourceA, src->Texture.Unit[i].Combine.SourceA); - COPY_3V(dst->Texture.Unit[i].Combine.OperandRGB, src->Texture.Unit[i].Combine.OperandRGB); - COPY_3V(dst->Texture.Unit[i].Combine.OperandA, src->Texture.Unit[i].Combine.OperandA); - dst->Texture.Unit[i].Combine.ScaleShiftRGB = src->Texture.Unit[i].Combine.ScaleShiftRGB; - dst->Texture.Unit[i].Combine.ScaleShiftA = src->Texture.Unit[i].Combine.ScaleShiftA; + dst->Texture.Unit[u].Combine = src->Texture.Unit[u].Combine; + + /* GL_ATI_envmap_bumpmap - need this? */ + dst->Texture.Unit[u].BumpTarget = src->Texture.Unit[u].BumpTarget; + COPY_4V(dst->Texture.Unit[u].RotMatrix, src->Texture.Unit[u].RotMatrix); + /* copy texture object bindings, not contents of texture objects */ _mesa_lock_context_textures(dst); - _mesa_reference_texobj(&dst->Texture.Unit[i].Current1D, - src->Texture.Unit[i].Current1D); - _mesa_reference_texobj(&dst->Texture.Unit[i].Current2D, - src->Texture.Unit[i].Current2D); - _mesa_reference_texobj(&dst->Texture.Unit[i].Current3D, - src->Texture.Unit[i].Current3D); - _mesa_reference_texobj(&dst->Texture.Unit[i].CurrentCubeMap, - src->Texture.Unit[i].CurrentCubeMap); - _mesa_reference_texobj(&dst->Texture.Unit[i].CurrentRect, - src->Texture.Unit[i].CurrentRect); - _mesa_reference_texobj(&dst->Texture.Unit[i].Current1DArray, - src->Texture.Unit[i].Current1DArray); - _mesa_reference_texobj(&dst->Texture.Unit[i].Current2DArray, - src->Texture.Unit[i].Current2DArray); + for (tex = 0; tex < NUM_TEXTURE_TARGETS; tex++) { + _mesa_reference_texobj(&dst->Texture.Unit[u].CurrentTex[tex], + src->Texture.Unit[u].CurrentTex[tex]); + } _mesa_unlock_context_textures(dst); } @@ -204,11 +179,14 @@ calculate_derived_texenv( struct gl_tex_env_combine_state *state, case GL_LUMINANCE: case GL_RGB: case GL_YCBCR_MESA: + case GL_DUDV_ATI: state->SourceA[0] = GL_PREVIOUS; break; default: - _mesa_problem(NULL, "Invalid texBaseFormat in calculate_derived_texenv"); + _mesa_problem(NULL, + "Invalid texBaseFormat 0x%x in calculate_derived_texenv", + texBaseFormat); return; } @@ -241,6 +219,7 @@ calculate_derived_texenv( struct gl_tex_env_combine_state *state, break; case GL_RGB: case GL_YCBCR_MESA: + case GL_DUDV_ATI: mode_rgb = GL_REPLACE; break; case GL_RGBA: @@ -267,6 +246,7 @@ calculate_derived_texenv( struct gl_tex_env_combine_state *state, case GL_LUMINANCE_ALPHA: case GL_RGBA: case GL_YCBCR_MESA: + case GL_DUDV_ATI: state->SourceRGB[2] = GL_TEXTURE; state->SourceA[2] = GL_TEXTURE; state->SourceRGB[0] = GL_CONSTANT; @@ -282,7 +262,8 @@ calculate_derived_texenv( struct gl_tex_env_combine_state *state, default: _mesa_problem(NULL, - "Invalid texture env mode in calculate_derived_texenv"); + "Invalid texture env mode 0x%x in calculate_derived_texenv", + mode); return; } @@ -364,73 +345,20 @@ _mesa_ClientActiveTextureARB(GLenum texture) static void update_texture_matrices( GLcontext *ctx ) { - GLuint i; + GLuint u; - ctx->Texture._TexMatEnabled = 0; + ctx->Texture._TexMatEnabled = 0x0; - for (i=0; i < ctx->Const.MaxTextureCoordUnits; i++) { - if (_math_matrix_is_dirty(ctx->TextureMatrixStack[i].Top)) { - _math_matrix_analyse( ctx->TextureMatrixStack[i].Top ); + for (u = 0; u < ctx->Const.MaxTextureCoordUnits; u++) { + if (_math_matrix_is_dirty(ctx->TextureMatrixStack[u].Top)) { + _math_matrix_analyse( ctx->TextureMatrixStack[u].Top ); - if (ctx->Texture.Unit[i]._ReallyEnabled && - ctx->TextureMatrixStack[i].Top->type != MATRIX_IDENTITY) - ctx->Texture._TexMatEnabled |= ENABLE_TEXMAT(i); + if (ctx->Texture.Unit[u]._ReallyEnabled && + ctx->TextureMatrixStack[u].Top->type != MATRIX_IDENTITY) + ctx->Texture._TexMatEnabled |= ENABLE_TEXMAT(u); if (ctx->Driver.TextureMatrix) - ctx->Driver.TextureMatrix( ctx, i, ctx->TextureMatrixStack[i].Top); - } - } -} - - -/** - * Update texture object's _Function field. We need to do this - * whenever any of the texture object's shadow-related fields change - * or when we start/stop using a fragment program. - * - * This function could be expanded someday to update additional per-object - * fields that depend on assorted state changes. - */ -static void -update_texture_compare_function(GLcontext *ctx, - struct gl_texture_object *tObj) -{ - /* XXX temporarily disable this test since it breaks the GLSL - * shadow2D(), etc. functions. - */ - if (0 /*ctx->FragmentProgram._Current*/) { - /* Texel/coordinate comparison is ignored for programs. - * See GL_ARB_fragment_program/shader spec for details. - */ - tObj->_Function = GL_NONE; - } - else if (tObj->CompareMode == GL_COMPARE_R_TO_TEXTURE_ARB) { - /* GL_ARB_shadow */ - tObj->_Function = tObj->CompareFunc; - } - else { - tObj->_Function = GL_NONE; /* pass depth through as grayscale */ - } -} - - -/** - * Helper function for determining which texture object (1D, 2D, cube, etc) - * should actually be used. - */ -static void -texture_override(GLcontext *ctx, - struct gl_texture_unit *texUnit, GLbitfield enableBits, - struct gl_texture_object *texObj, GLuint textureBit) -{ - if (!texUnit->_ReallyEnabled && (enableBits & textureBit)) { - if (!texObj->_Complete) { - _mesa_test_texobj_completeness(ctx, texObj); - } - if (texObj->_Complete) { - texUnit->_ReallyEnabled = textureBit; - texUnit->_Current = texObj; - update_texture_compare_function(ctx, texObj); + ctx->Driver.TextureMatrix( ctx, u, ctx->TextureMatrixStack[u].Top); } } } @@ -442,6 +370,8 @@ texture_override(GLcontext *ctx, static void update_tex_combine(GLcontext *ctx, struct gl_texture_unit *texUnit) { + struct gl_tex_env_combine_state *combine; + /* Set the texUnit->_CurrentCombine field to point to the user's combiner * state, or the combiner state which is derived from traditional texenv * mode. @@ -464,17 +394,19 @@ update_tex_combine(GLcontext *ctx, struct gl_texture_unit *texUnit) texUnit->_CurrentCombine = & texUnit->_EnvMode; } + combine = texUnit->_CurrentCombine; + /* Determine number of source RGB terms in the combiner function */ - switch (texUnit->_CurrentCombine->ModeRGB) { + switch (combine->ModeRGB) { case GL_REPLACE: - texUnit->_CurrentCombine->_NumArgsRGB = 1; + combine->_NumArgsRGB = 1; break; case GL_ADD: case GL_ADD_SIGNED: if (texUnit->EnvMode == GL_COMBINE4_NV) - texUnit->_CurrentCombine->_NumArgsRGB = 4; + combine->_NumArgsRGB = 4; else - texUnit->_CurrentCombine->_NumArgsRGB = 2; + combine->_NumArgsRGB = 2; break; case GL_MODULATE: case GL_SUBTRACT: @@ -482,44 +414,48 @@ update_tex_combine(GLcontext *ctx, struct gl_texture_unit *texUnit) case GL_DOT3_RGBA: case GL_DOT3_RGB_EXT: case GL_DOT3_RGBA_EXT: - texUnit->_CurrentCombine->_NumArgsRGB = 2; + combine->_NumArgsRGB = 2; break; case GL_INTERPOLATE: case GL_MODULATE_ADD_ATI: case GL_MODULATE_SIGNED_ADD_ATI: case GL_MODULATE_SUBTRACT_ATI: - texUnit->_CurrentCombine->_NumArgsRGB = 3; + combine->_NumArgsRGB = 3; + break; + case GL_BUMP_ENVMAP_ATI: + /* no real arguments for this case */ + combine->_NumArgsRGB = 0; break; default: - texUnit->_CurrentCombine->_NumArgsRGB = 0; + combine->_NumArgsRGB = 0; _mesa_problem(ctx, "invalid RGB combine mode in update_texture_state"); return; } /* Determine number of source Alpha terms in the combiner function */ - switch (texUnit->_CurrentCombine->ModeA) { + switch (combine->ModeA) { case GL_REPLACE: - texUnit->_CurrentCombine->_NumArgsA = 1; + combine->_NumArgsA = 1; break; case GL_ADD: case GL_ADD_SIGNED: if (texUnit->EnvMode == GL_COMBINE4_NV) - texUnit->_CurrentCombine->_NumArgsA = 4; + combine->_NumArgsA = 4; else - texUnit->_CurrentCombine->_NumArgsA = 2; + combine->_NumArgsA = 2; break; case GL_MODULATE: case GL_SUBTRACT: - texUnit->_CurrentCombine->_NumArgsA = 2; + combine->_NumArgsA = 2; break; case GL_INTERPOLATE: case GL_MODULATE_ADD_ATI: case GL_MODULATE_SIGNED_ADD_ATI: case GL_MODULATE_SUBTRACT_ATI: - texUnit->_CurrentCombine->_NumArgsA = 3; + combine->_NumArgsA = 3; break; default: - texUnit->_CurrentCombine->_NumArgsA = 0; + combine->_NumArgsA = 0; _mesa_problem(ctx, "invalid Alpha combine mode in update_texture_state"); break; } @@ -540,6 +476,7 @@ update_texture_state( GLcontext *ctx ) GLuint unit; struct gl_fragment_program *fprog = NULL; struct gl_vertex_program *vprog = NULL; + GLbitfield enabledFragUnits = 0x0; if (ctx->Shader.CurrentProgram && ctx->Shader.CurrentProgram->LinkStatus) { @@ -561,71 +498,70 @@ update_texture_state( GLcontext *ctx ) /* TODO: only set this if there are actual changes */ ctx->NewState |= _NEW_TEXTURE; - ctx->Texture._EnabledUnits = 0; - ctx->Texture._GenFlags = 0; - ctx->Texture._TexMatEnabled = 0; - ctx->Texture._TexGenEnabled = 0; + ctx->Texture._EnabledUnits = 0x0; + ctx->Texture._GenFlags = 0x0; + ctx->Texture._TexMatEnabled = 0x0; + ctx->Texture._TexGenEnabled = 0x0; /* * Update texture unit state. */ for (unit = 0; unit < ctx->Const.MaxTextureImageUnits; unit++) { struct gl_texture_unit *texUnit = &ctx->Texture.Unit[unit]; - GLbitfield enableBits; - - texUnit->_Current = NULL; - texUnit->_ReallyEnabled = 0; - texUnit->_GenFlags = 0; + GLbitfield enabledVertTargets = 0x0; + GLbitfield enabledFragTargets = 0x0; + GLbitfield enabledTargets = 0x0; + GLuint texIndex; /* Get the bitmask of texture target enables. * enableBits will be a mask of the TEXTURE_*_BIT flags indicating * which texture targets are enabled (fixed function) or referenced * by a fragment shader/program. When multiple flags are set, we'll - * settle on the one with highest priority (see texture_override below). + * settle on the one with highest priority (see below). */ - enableBits = 0x0; if (vprog) { - enableBits |= vprog->Base.TexturesUsed[unit]; + enabledVertTargets |= vprog->Base.TexturesUsed[unit]; } + if (fprog) { - enableBits |= fprog->Base.TexturesUsed[unit]; + enabledFragTargets |= fprog->Base.TexturesUsed[unit]; } else { /* fixed-function fragment program */ - enableBits |= texUnit->Enabled; + enabledFragTargets |= texUnit->Enabled; } - if (enableBits == 0x0) + enabledTargets = enabledVertTargets | enabledFragTargets; + + texUnit->_ReallyEnabled = 0x0; + + if (enabledTargets == 0x0) { + /* neither vertex nor fragment processing uses this unit */ continue; + } - ASSERT(texUnit->Current1D); - ASSERT(texUnit->Current2D); - ASSERT(texUnit->Current3D); - ASSERT(texUnit->CurrentCubeMap); - ASSERT(texUnit->CurrentRect); - ASSERT(texUnit->Current1DArray); - ASSERT(texUnit->Current2DArray); - - /* Look for the highest-priority texture target that's enabled and - * complete. That's the one we'll use for texturing. If we're using - * a fragment program we're guaranteed that bitcount(enabledBits) <= 1. + /* Look for the highest priority texture target that's enabled (or used + * by the vert/frag shaders) and "complete". That's the one we'll use + * for texturing. If we're using vert/frag program we're guaranteed + * that bitcount(enabledBits) <= 1. + * Note that the TEXTURE_x_INDEX values are in high to low priority. */ - texture_override(ctx, texUnit, enableBits, - texUnit->Current2DArray, TEXTURE_2D_ARRAY_BIT); - texture_override(ctx, texUnit, enableBits, - texUnit->Current1DArray, TEXTURE_1D_ARRAY_BIT); - texture_override(ctx, texUnit, enableBits, - texUnit->CurrentCubeMap, TEXTURE_CUBE_BIT); - texture_override(ctx, texUnit, enableBits, - texUnit->Current3D, TEXTURE_3D_BIT); - texture_override(ctx, texUnit, enableBits, - texUnit->CurrentRect, TEXTURE_RECT_BIT); - texture_override(ctx, texUnit, enableBits, - texUnit->Current2D, TEXTURE_2D_BIT); - texture_override(ctx, texUnit, enableBits, - texUnit->Current1D, TEXTURE_1D_BIT); + for (texIndex = 0; texIndex < NUM_TEXTURE_TARGETS; texIndex++) { + if (enabledTargets & (1 << texIndex)) { + struct gl_texture_object *texObj = texUnit->CurrentTex[texIndex]; + if (!texObj->_Complete) { + _mesa_test_texobj_completeness(ctx, texObj); + } + if (texObj->_Complete) { + texUnit->_ReallyEnabled = 1 << texIndex; + _mesa_reference_texobj(&texUnit->_Current, texObj); + break; + } + } + } if (!texUnit->_ReallyEnabled) { + _mesa_reference_texobj(&texUnit->_Current, NULL); continue; } @@ -633,6 +569,9 @@ update_texture_state( GLcontext *ctx ) ctx->Texture._EnabledUnits |= (1 << unit); + if (enabledFragTargets) + enabledFragUnits |= (1 << unit); + update_tex_combine(ctx, texUnit); } @@ -644,28 +583,30 @@ update_texture_state( GLcontext *ctx ) = (fprog->Base.InputsRead >> FRAG_ATTRIB_TEX0) & coordMask; } else { - ctx->Texture._EnabledCoordUnits = ctx->Texture._EnabledUnits; + ctx->Texture._EnabledCoordUnits = enabledFragUnits; } /* Setup texgen for those texture coordinate sets that are in use */ for (unit = 0; unit < ctx->Const.MaxTextureCoordUnits; unit++) { struct gl_texture_unit *texUnit = &ctx->Texture.Unit[unit]; + texUnit->_GenFlags = 0x0; + if (!(ctx->Texture._EnabledCoordUnits & (1 << unit))) continue; if (texUnit->TexGenEnabled) { if (texUnit->TexGenEnabled & S_BIT) { - texUnit->_GenFlags |= texUnit->_GenBitS; + texUnit->_GenFlags |= texUnit->GenS._ModeBit; } if (texUnit->TexGenEnabled & T_BIT) { - texUnit->_GenFlags |= texUnit->_GenBitT; - } - if (texUnit->TexGenEnabled & Q_BIT) { - texUnit->_GenFlags |= texUnit->_GenBitQ; + texUnit->_GenFlags |= texUnit->GenT._ModeBit; } if (texUnit->TexGenEnabled & R_BIT) { - texUnit->_GenFlags |= texUnit->_GenBitR; + texUnit->_GenFlags |= texUnit->GenR._ModeBit; + } + if (texUnit->TexGenEnabled & Q_BIT) { + texUnit->_GenFlags |= texUnit->GenQ._ModeBit; } ctx->Texture._TexGenEnabled |= ENABLE_TEXGEN(unit); @@ -748,6 +689,7 @@ static void init_texture_unit( GLcontext *ctx, GLuint unit ) { struct gl_texture_unit *texUnit = &ctx->Texture.Unit[unit]; + GLuint tex; texUnit->EnvMode = GL_MODULATE; ASSIGN_4V( texUnit->EnvColor, 0.0, 0.0, 0.0, 0.0 ); @@ -755,35 +697,43 @@ init_texture_unit( GLcontext *ctx, GLuint unit ) texUnit->Combine = default_combine_state; texUnit->_EnvMode = default_combine_state; texUnit->_CurrentCombine = & texUnit->_EnvMode; - - texUnit->TexGenEnabled = 0; - texUnit->GenModeS = GL_EYE_LINEAR; - texUnit->GenModeT = GL_EYE_LINEAR; - texUnit->GenModeR = GL_EYE_LINEAR; - texUnit->GenModeQ = GL_EYE_LINEAR; - texUnit->_GenBitS = TEXGEN_EYE_LINEAR; - texUnit->_GenBitT = TEXGEN_EYE_LINEAR; - texUnit->_GenBitR = TEXGEN_EYE_LINEAR; - texUnit->_GenBitQ = TEXGEN_EYE_LINEAR; + texUnit->BumpTarget = GL_TEXTURE0; + + texUnit->TexGenEnabled = 0x0; + texUnit->GenS.Mode = GL_EYE_LINEAR; + texUnit->GenT.Mode = GL_EYE_LINEAR; + texUnit->GenR.Mode = GL_EYE_LINEAR; + texUnit->GenQ.Mode = GL_EYE_LINEAR; + texUnit->GenS._ModeBit = TEXGEN_EYE_LINEAR; + texUnit->GenT._ModeBit = TEXGEN_EYE_LINEAR; + texUnit->GenR._ModeBit = TEXGEN_EYE_LINEAR; + texUnit->GenQ._ModeBit = TEXGEN_EYE_LINEAR; /* Yes, these plane coefficients are correct! */ - ASSIGN_4V( texUnit->ObjectPlaneS, 1.0, 0.0, 0.0, 0.0 ); - ASSIGN_4V( texUnit->ObjectPlaneT, 0.0, 1.0, 0.0, 0.0 ); - ASSIGN_4V( texUnit->ObjectPlaneR, 0.0, 0.0, 0.0, 0.0 ); - ASSIGN_4V( texUnit->ObjectPlaneQ, 0.0, 0.0, 0.0, 0.0 ); - ASSIGN_4V( texUnit->EyePlaneS, 1.0, 0.0, 0.0, 0.0 ); - ASSIGN_4V( texUnit->EyePlaneT, 0.0, 1.0, 0.0, 0.0 ); - ASSIGN_4V( texUnit->EyePlaneR, 0.0, 0.0, 0.0, 0.0 ); - ASSIGN_4V( texUnit->EyePlaneQ, 0.0, 0.0, 0.0, 0.0 ); + ASSIGN_4V( texUnit->GenS.ObjectPlane, 1.0, 0.0, 0.0, 0.0 ); + ASSIGN_4V( texUnit->GenT.ObjectPlane, 0.0, 1.0, 0.0, 0.0 ); + ASSIGN_4V( texUnit->GenR.ObjectPlane, 0.0, 0.0, 0.0, 0.0 ); + ASSIGN_4V( texUnit->GenQ.ObjectPlane, 0.0, 0.0, 0.0, 0.0 ); + ASSIGN_4V( texUnit->GenS.EyePlane, 1.0, 0.0, 0.0, 0.0 ); + ASSIGN_4V( texUnit->GenT.EyePlane, 0.0, 1.0, 0.0, 0.0 ); + ASSIGN_4V( texUnit->GenR.EyePlane, 0.0, 0.0, 0.0, 0.0 ); + ASSIGN_4V( texUnit->GenQ.EyePlane, 0.0, 0.0, 0.0, 0.0 ); + ASSIGN_4V( texUnit->GenS.ObjectPlane, 1.0, 0.0, 0.0, 0.0 ); + ASSIGN_4V( texUnit->GenT.ObjectPlane, 0.0, 1.0, 0.0, 0.0 ); + ASSIGN_4V( texUnit->GenR.ObjectPlane, 0.0, 0.0, 0.0, 0.0 ); + ASSIGN_4V( texUnit->GenQ.ObjectPlane, 0.0, 0.0, 0.0, 0.0 ); + ASSIGN_4V( texUnit->GenS.EyePlane, 1.0, 0.0, 0.0, 0.0 ); + ASSIGN_4V( texUnit->GenT.EyePlane, 0.0, 1.0, 0.0, 0.0 ); + ASSIGN_4V( texUnit->GenR.EyePlane, 0.0, 0.0, 0.0, 0.0 ); + ASSIGN_4V( texUnit->GenQ.EyePlane, 0.0, 0.0, 0.0, 0.0 ); + /* no mention of this in spec, but maybe id matrix expected? */ + ASSIGN_4V( texUnit->RotMatrix, 1.0, 0.0, 0.0, 1.0 ); /* initialize current texture object ptrs to the shared default objects */ - _mesa_reference_texobj(&texUnit->Current1D, ctx->Shared->Default1D); - _mesa_reference_texobj(&texUnit->Current2D, ctx->Shared->Default2D); - _mesa_reference_texobj(&texUnit->Current3D, ctx->Shared->Default3D); - _mesa_reference_texobj(&texUnit->CurrentCubeMap, ctx->Shared->DefaultCubeMap); - _mesa_reference_texobj(&texUnit->CurrentRect, ctx->Shared->DefaultRect); - _mesa_reference_texobj(&texUnit->Current1DArray, ctx->Shared->Default1DArray); - _mesa_reference_texobj(&texUnit->Current2DArray, ctx->Shared->Default2DArray); + for (tex = 0; tex < NUM_TEXTURE_TARGETS; tex++) { + _mesa_reference_texobj(&texUnit->CurrentTex[tex], + ctx->Shared->DefaultTex[tex]); + } } @@ -793,26 +743,24 @@ init_texture_unit( GLcontext *ctx, GLuint unit ) GLboolean _mesa_init_texture(GLcontext *ctx) { - GLuint i; - - assert(MAX_TEXTURE_LEVELS >= MAX_3D_TEXTURE_LEVELS); - assert(MAX_TEXTURE_LEVELS >= MAX_CUBE_TEXTURE_LEVELS); + GLuint u; /* Texture group */ ctx->Texture.CurrentUnit = 0; /* multitexture */ - ctx->Texture._EnabledUnits = 0; + ctx->Texture._EnabledUnits = 0x0; ctx->Texture.SharedPalette = GL_FALSE; #if FEATURE_colortable _mesa_init_colortable(&ctx->Texture.Palette); #endif - for (i = 0; i < MAX_TEXTURE_UNITS; i++) - init_texture_unit( ctx, i ); + for (u = 0; u < MAX_TEXTURE_UNITS; u++) + init_texture_unit(ctx, u); /* After we're done initializing the context's texture state the default * texture objects' refcounts should be at least MAX_TEXTURE_UNITS + 1. */ - assert(ctx->Shared->Default1D->RefCount >= MAX_TEXTURE_UNITS + 1); + assert(ctx->Shared->DefaultTex[TEXTURE_1D_INDEX]->RefCount + >= MAX_TEXTURE_UNITS + 1); /* Allocate proxy textures */ if (!alloc_proxy_textures( ctx )) @@ -832,14 +780,9 @@ _mesa_free_texture_data(GLcontext *ctx) /* unreference current textures */ for (u = 0; u < MAX_TEXTURE_IMAGE_UNITS; u++) { - struct gl_texture_unit *unit = ctx->Texture.Unit + u; - _mesa_reference_texobj(&unit->Current1D, NULL); - _mesa_reference_texobj(&unit->Current2D, NULL); - _mesa_reference_texobj(&unit->Current3D, NULL); - _mesa_reference_texobj(&unit->CurrentCubeMap, NULL); - _mesa_reference_texobj(&unit->CurrentRect, NULL); - _mesa_reference_texobj(&unit->Current1DArray, NULL); - _mesa_reference_texobj(&unit->Current2DArray, NULL); + for (tgt = 0; tgt < NUM_TEXTURE_TARGETS; tgt++) { + _mesa_reference_texobj(&ctx->Texture.Unit[u].CurrentTex[tgt], NULL); + } } /* Free proxy texture objects */ @@ -847,11 +790,8 @@ _mesa_free_texture_data(GLcontext *ctx) ctx->Driver.DeleteTexture(ctx, ctx->Texture.ProxyTex[tgt]); #if FEATURE_colortable - { - GLuint i; - for (i = 0; i < MAX_TEXTURE_IMAGE_UNITS; i++) - _mesa_free_colortable_data( &ctx->Texture.Unit[i].ColorTable ); - } + for (u = 0; u < MAX_TEXTURE_IMAGE_UNITS; u++) + _mesa_free_colortable_data(&ctx->Texture.Unit[u].ColorTable); #endif } @@ -864,17 +804,13 @@ _mesa_free_texture_data(GLcontext *ctx) void _mesa_update_default_objects_texture(GLcontext *ctx) { - GLuint i; - - for (i = 0; i < MAX_TEXTURE_UNITS; i++) { - struct gl_texture_unit *texUnit = &ctx->Texture.Unit[i]; - - _mesa_reference_texobj(&texUnit->Current1D, ctx->Shared->Default1D); - _mesa_reference_texobj(&texUnit->Current2D, ctx->Shared->Default2D); - _mesa_reference_texobj(&texUnit->Current3D, ctx->Shared->Default3D); - _mesa_reference_texobj(&texUnit->CurrentCubeMap, ctx->Shared->DefaultCubeMap); - _mesa_reference_texobj(&texUnit->CurrentRect, ctx->Shared->DefaultRect); - _mesa_reference_texobj(&texUnit->Current1DArray, ctx->Shared->Default1DArray); - _mesa_reference_texobj(&texUnit->Current2DArray, ctx->Shared->Default2DArray); + GLuint u, tex; + + for (u = 0; u < MAX_TEXTURE_UNITS; u++) { + struct gl_texture_unit *texUnit = &ctx->Texture.Unit[u]; + for (tex = 0; tex < NUM_TEXTURE_TARGETS; tex++) { + _mesa_reference_texobj(&texUnit->CurrentTex[tex], + ctx->Shared->DefaultTex[tex]); + } } } diff --git a/src/mesa/main/texstore.c b/src/mesa/main/texstore.c index 6360ca15f8..cc3c6958c7 100644 --- a/src/mesa/main/texstore.c +++ b/src/mesa/main/texstore.c @@ -2471,6 +2471,95 @@ _mesa_texstore_ycbcr(TEXSTORE_PARAMS) return GL_TRUE; } +GLboolean +_mesa_texstore_dudv8(TEXSTORE_PARAMS) +{ + const GLboolean littleEndian = _mesa_little_endian(); + + ASSERT(dstFormat == &_mesa_texformat_dudv8); + ASSERT(dstFormat->TexelBytes == 2); + ASSERT(ctx->Extensions.ATI_envmap_bumpmap); + ASSERT((srcFormat == GL_DU8DV8_ATI) || + (srcFormat == GL_DUDV_ATI)); + ASSERT(baseInternalFormat == GL_DUDV_ATI); + + if (!srcPacking->SwapBytes && srcType == GL_BYTE && + littleEndian) { + /* simple memcpy path */ + memcpy_texture(ctx, dims, + dstFormat, dstAddr, dstXoffset, dstYoffset, dstZoffset, + dstRowStride, + dstImageOffsets, + srcWidth, srcHeight, srcDepth, srcFormat, srcType, + srcAddr, srcPacking); + } + else if (srcType == GL_BYTE) { + + GLubyte dstmap[4]; + + /* dstmap - how to swizzle from RGBA to dst format: + */ + if (littleEndian) { + dstmap[0] = 0; + dstmap[1] = 3; + } + else { + dstmap[0] = 3; + dstmap[1] = 0; + } + dstmap[2] = ZERO; /* ? */ + dstmap[3] = ONE; /* ? */ + + _mesa_swizzle_ubyte_image(ctx, dims, + GL_LUMINANCE_ALPHA, /* hack */ + GL_UNSIGNED_BYTE, /* hack */ + GL_LUMINANCE_ALPHA, /* hack */ + dstmap, 2, + dstAddr, dstXoffset, dstYoffset, dstZoffset, + dstRowStride, dstImageOffsets, + srcWidth, srcHeight, srcDepth, srcAddr, + srcPacking); + } + else { + /* general path - note this is defined for 2d textures only */ + const GLint components = _mesa_components_in_format(baseInternalFormat); + const GLint srcStride = _mesa_image_row_stride(srcPacking, + srcWidth, srcFormat, srcType); + GLbyte *tempImage, *dst, *src; + GLint row; + + tempImage = (GLbyte *) _mesa_malloc(srcWidth * srcHeight * srcDepth + * components * sizeof(GLbyte)); + if (!tempImage) + return GL_FALSE; + + src = (GLbyte *) _mesa_image_address(dims, srcPacking, srcAddr, + srcWidth, srcHeight, + srcFormat, srcType, + 0, 0, 0); + + dst = tempImage; + for (row = 0; row < srcHeight; row++) { + _mesa_unpack_dudv_span_byte(ctx, srcWidth, baseInternalFormat, + dst, srcFormat, srcType, src, + srcPacking, 0); + dst += srcWidth * components; + src += srcStride; + } + + src = tempImage; + dst = (GLbyte *) dstAddr + + dstYoffset * dstRowStride + + dstXoffset * dstFormat->TexelBytes; + for (row = 0; row < srcHeight; row++) { + memcpy(dst, src, srcWidth * dstFormat->TexelBytes); + dst += dstRowStride; + src += srcWidth * dstFormat->TexelBytes; + } + _mesa_free((void *) tempImage); + } + return GL_TRUE; +} /** @@ -3882,7 +3971,7 @@ _mesa_get_teximage(GLcontext *ctx, GLenum target, GLint level, GLint col; GLbitfield transferOps = 0x0; - if (type == GL_FLOAT && + if (type == GL_FLOAT && texImage->TexFormat->BaseFormat != GL_DUDV_ATI && ((ctx->Color.ClampReadColor == GL_TRUE) || (ctx->Color.ClampReadColor == GL_FIXED_ONLY_ARB && texImage->TexFormat->DataType != GL_FLOAT))) diff --git a/src/mesa/main/texstore.h b/src/mesa/main/texstore.h index b03386b2ac..c9e639be4e 100644 --- a/src/mesa/main/texstore.h +++ b/src/mesa/main/texstore.h @@ -78,7 +78,7 @@ extern GLboolean _mesa_texstore_sargb8(TEXSTORE_PARAMS); extern GLboolean _mesa_texstore_sl8(TEXSTORE_PARAMS); extern GLboolean _mesa_texstore_sla8(TEXSTORE_PARAMS); #endif - +extern GLboolean _mesa_texstore_dudv8(TEXSTORE_PARAMS); extern GLchan * _mesa_make_temp_chan_image(GLcontext *ctx, GLuint dims, diff --git a/src/mesa/main/version.h b/src/mesa/main/version.h index 9287e8515c..f5bf6e2c85 100644 --- a/src/mesa/main/version.h +++ b/src/mesa/main/version.h @@ -1,10 +1,6 @@ /* * Mesa 3-D graphics library -<<<<<<< HEAD:src/mesa/main/version.h * Version: 7.5 -======= - * Version: 7.4 ->>>>>>> origin/gallium-0.2:src/mesa/main/version.h * * Copyright (C) 1999-2008 Brian Paul All Rights Reserved. * diff --git a/src/mesa/main/viewport.c b/src/mesa/main/viewport.c new file mode 100644 index 0000000000..ead856d32c --- /dev/null +++ b/src/mesa/main/viewport.c @@ -0,0 +1,176 @@ +/* + * Mesa 3-D graphics library + * Version: 7.5 + * + * Copyright (C) 2009 VMware, Inc. 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. + */ + + +/** + * \file viewport.c + * glViewport and glDepthRange functions. + */ + + +#include "context.h" +#include "macros.h" +#include "viewport.h" + + +/** + * Set the viewport. + * \sa Called via glViewport() or display list execution. + * + * Flushes the vertices and calls _mesa_set_viewport() with the given + * parameters. + */ +void GLAPIENTRY +_mesa_Viewport(GLint x, GLint y, GLsizei width, GLsizei height) +{ + GET_CURRENT_CONTEXT(ctx); + ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx); + _mesa_set_viewport(ctx, x, y, width, height); +} + + +/** + * Set new viewport parameters and update derived state (the _WindowMap + * matrix). Usually called from _mesa_Viewport(). + * + * \param ctx GL context. + * \param x, y coordinates of the lower left corner of the viewport rectangle. + * \param width width of the viewport rectangle. + * \param height height of the viewport rectangle. + */ +void +_mesa_set_viewport(GLcontext *ctx, GLint x, GLint y, + GLsizei width, GLsizei height) +{ + if (MESA_VERBOSE & VERBOSE_API) + _mesa_debug(ctx, "glViewport %d %d %d %d\n", x, y, width, height); + + if (width < 0 || height < 0) { + _mesa_error(ctx, GL_INVALID_VALUE, + "glViewport(%d, %d, %d, %d)", x, y, width, height); + return; + } + + /* clamp width and height to the implementation dependent range */ + width = CLAMP(width, 1, (GLsizei) ctx->Const.MaxViewportWidth); + height = CLAMP(height, 1, (GLsizei) ctx->Const.MaxViewportHeight); + + ctx->Viewport.X = x; + ctx->Viewport.Width = width; + ctx->Viewport.Y = y; + ctx->Viewport.Height = height; + ctx->NewState |= _NEW_VIEWPORT; + +#if 1 + /* XXX remove this someday. Currently the DRI drivers rely on + * the WindowMap matrix being up to date in the driver's Viewport + * and DepthRange functions. + */ + _math_matrix_viewport(&ctx->Viewport._WindowMap, + ctx->Viewport.X, ctx->Viewport.Y, + ctx->Viewport.Width, ctx->Viewport.Height, + ctx->Viewport.Near, ctx->Viewport.Far, + ctx->DrawBuffer->_DepthMaxF); +#endif + + if (ctx->Driver.Viewport) { + /* Many drivers will use this call to check for window size changes + * and reallocate the z/stencil/accum/etc buffers if needed. + */ + ctx->Driver.Viewport(ctx, x, y, width, height); + } +} + + +/** + * Called by glDepthRange + * + * \param nearval specifies the Z buffer value which should correspond to + * the near clip plane + * \param farval specifies the Z buffer value which should correspond to + * the far clip plane + */ +void GLAPIENTRY +_mesa_DepthRange(GLclampd nearval, GLclampd farval) +{ + GET_CURRENT_CONTEXT(ctx); + ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx); + + if (MESA_VERBOSE&VERBOSE_API) + _mesa_debug(ctx, "glDepthRange %f %f\n", nearval, farval); + + ctx->Viewport.Near = (GLfloat) CLAMP(nearval, 0.0, 1.0); + ctx->Viewport.Far = (GLfloat) CLAMP(farval, 0.0, 1.0); + ctx->NewState |= _NEW_VIEWPORT; + +#if 1 + /* XXX remove this someday. Currently the DRI drivers rely on + * the WindowMap matrix being up to date in the driver's Viewport + * and DepthRange functions. + */ + _math_matrix_viewport(&ctx->Viewport._WindowMap, + ctx->Viewport.X, ctx->Viewport.Y, + ctx->Viewport.Width, ctx->Viewport.Height, + ctx->Viewport.Near, ctx->Viewport.Far, + ctx->DrawBuffer->_DepthMaxF); +#endif + + if (ctx->Driver.DepthRange) { + ctx->Driver.DepthRange(ctx, nearval, farval); + } +} + + + +/** + * Initialize the context viewport attribute group. + * \param ctx the GL context. + */ +void _mesa_init_viewport(GLcontext *ctx) +{ + GLfloat depthMax = 65535.0F; /* sorf of arbitrary */ + + /* Viewport group */ + ctx->Viewport.X = 0; + ctx->Viewport.Y = 0; + ctx->Viewport.Width = 0; + ctx->Viewport.Height = 0; + ctx->Viewport.Near = 0.0; + ctx->Viewport.Far = 1.0; + _math_matrix_ctr(&ctx->Viewport._WindowMap); + + _math_matrix_viewport(&ctx->Viewport._WindowMap, 0, 0, 0, 0, + 0.0F, 1.0F, depthMax); +} + + +/** + * Free the context viewport attribute group data. + * \param ctx the GL context. + */ +void _mesa_free_viewport_data(GLcontext *ctx) +{ + _math_matrix_dtr(&ctx->Viewport._WindowMap); +} + diff --git a/src/mesa/main/viewport.h b/src/mesa/main/viewport.h new file mode 100644 index 0000000000..f08fef2797 --- /dev/null +++ b/src/mesa/main/viewport.h @@ -0,0 +1,52 @@ +/* + * Mesa 3-D graphics library + * Version: 7.5 + * + * Copyright (C) 1999-2008 Brian Paul All Rights Reserved. + * Copyright (C) 2009 VMware, Inc. 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. + */ + + +#ifndef VIEWPORT_H +#define VIEWPORT_H + + +extern void GLAPIENTRY +_mesa_Viewport(GLint x, GLint y, GLsizei width, GLsizei height); + + +extern void +_mesa_set_viewport(GLcontext *ctx, GLint x, GLint y, + GLsizei width, GLsizei height); + + +extern void GLAPIENTRY +_mesa_DepthRange(GLclampd nearval, GLclampd farval); + + +extern void +_mesa_init_viewport(GLcontext *ctx); + + +extern void +_mesa_free_viewport_data(GLcontext *ctx); + + +#endif diff --git a/src/mesa/main/vtxfmt.c b/src/mesa/main/vtxfmt.c index 0204979003..1f807dc3dc 100644 --- a/src/mesa/main/vtxfmt.c +++ b/src/mesa/main/vtxfmt.c @@ -54,9 +54,12 @@ ASSERT( tnl->Current ); \ ASSERT( tnl->SwapCount < NUM_VERTEX_FORMAT_ENTRIES ); \ ASSERT( tmp_offset >= 0 ); \ - \ - /* Save the swapped function's dispatch entry so it can be */ \ - /* restored later. */ \ + \ + if (tnl->SwapCount == 0) \ + ctx->Driver.BeginVertices( ctx ); \ + \ + /* Save the swapped function's dispatch entry so it can be */ \ + /* restored later. */ \ tnl->Swapped[tnl->SwapCount].location = & (((_glapi_proc *)ctx->Exec)[tmp_offset]); \ tnl->Swapped[tnl->SwapCount].function = (_glapi_proc)TAG(FUNC); \ tnl->SwapCount++; \ |