diff options
Diffstat (limited to 'src/mesa/main')
71 files changed, 9137 insertions, 5184 deletions
diff --git a/src/mesa/main/api_arrayelt.c b/src/mesa/main/api_arrayelt.c index d124c724c9..2462a1b003 100644 --- a/src/mesa/main/api_arrayelt.c +++ b/src/mesa/main/api_arrayelt.c @@ -28,6 +28,7 @@ #include "glheader.h" #include "api_arrayelt.h" +#include "bufferobj.h" #include "context.h" #include "imports.h" #include "macros.h" @@ -1071,7 +1072,7 @@ void _ae_destroy_context( GLcontext *ctx ) static void check_vbo( AEcontext *actx, struct gl_buffer_object *vbo ) { - if (vbo->Name && !vbo->Pointer) { + if (_mesa_is_bufferobj(vbo) && !_mesa_bufferobj_mapped(vbo)) { GLuint i; for (i = 0; i < actx->nr_vbos; i++) if (actx->vbo[i] == vbo) @@ -1094,48 +1095,49 @@ static void _ae_update_state( GLcontext *ctx ) AEarray *aa = actx->arrays; AEattrib *at = actx->attribs; GLuint i; + struct gl_array_object *arrayObj = ctx->Array.ArrayObj; actx->nr_vbos = 0; /* conventional vertex arrays */ - if (ctx->Array.ArrayObj->Index.Enabled) { - aa->array = &ctx->Array.ArrayObj->Index; + if (arrayObj->Index.Enabled) { + aa->array = &arrayObj->Index; aa->offset = IndexFuncs[TYPE_IDX(aa->array->Type)]; check_vbo(actx, aa->array->BufferObj); aa++; } - if (ctx->Array.ArrayObj->EdgeFlag.Enabled) { - aa->array = &ctx->Array.ArrayObj->EdgeFlag; + if (arrayObj->EdgeFlag.Enabled) { + aa->array = &arrayObj->EdgeFlag; aa->offset = _gloffset_EdgeFlagv; check_vbo(actx, aa->array->BufferObj); aa++; } - if (ctx->Array.ArrayObj->Normal.Enabled) { - aa->array = &ctx->Array.ArrayObj->Normal; + if (arrayObj->Normal.Enabled) { + aa->array = &arrayObj->Normal; aa->offset = NormalFuncs[TYPE_IDX(aa->array->Type)]; check_vbo(actx, aa->array->BufferObj); aa++; } - if (ctx->Array.ArrayObj->Color.Enabled) { - aa->array = &ctx->Array.ArrayObj->Color; + if (arrayObj->Color.Enabled) { + aa->array = &arrayObj->Color; aa->offset = ColorFuncs[aa->array->Size-3][TYPE_IDX(aa->array->Type)]; check_vbo(actx, aa->array->BufferObj); aa++; } - if (ctx->Array.ArrayObj->SecondaryColor.Enabled) { - aa->array = &ctx->Array.ArrayObj->SecondaryColor; + if (arrayObj->SecondaryColor.Enabled) { + aa->array = &arrayObj->SecondaryColor; aa->offset = SecondaryColorFuncs[TYPE_IDX(aa->array->Type)]; check_vbo(actx, aa->array->BufferObj); aa++; } - if (ctx->Array.ArrayObj->FogCoord.Enabled) { - aa->array = &ctx->Array.ArrayObj->FogCoord; + if (arrayObj->FogCoord.Enabled) { + aa->array = &arrayObj->FogCoord; aa->offset = FogCoordFuncs[TYPE_IDX(aa->array->Type)]; check_vbo(actx, aa->array->BufferObj); aa++; } for (i = 0; i < ctx->Const.MaxTextureCoordUnits; i++) { - struct gl_client_array *attribArray = &ctx->Array.ArrayObj->TexCoord[i]; + struct gl_client_array *attribArray = &arrayObj->TexCoord[i]; if (attribArray->Enabled) { /* NOTE: we use generic glVertexAttribNV functions here. * If we ever remove GL_NV_vertex_program this will have to change. @@ -1152,8 +1154,8 @@ static void _ae_update_state( GLcontext *ctx ) } /* generic vertex attribute arrays */ - for (i = 1; i < VERT_ATTRIB_MAX; i++) { /* skip zero! */ - struct gl_client_array *attribArray = &ctx->Array.ArrayObj->VertexAttrib[i]; + for (i = 1; i < Elements(arrayObj->VertexAttrib); i++) { /* skip zero! */ + struct gl_client_array *attribArray = &arrayObj->VertexAttrib[i]; if (attribArray->Enabled) { at->array = attribArray; /* Note: we can't grab the _glapi_Dispatch->VertexAttrib1fvNV @@ -1179,18 +1181,18 @@ static void _ae_update_state( GLcontext *ctx ) } /* finally, vertex position */ - if (ctx->Array.ArrayObj->VertexAttrib[0].Enabled) { + if (arrayObj->VertexAttrib[0].Enabled) { /* Use glVertex(v) instead of glVertexAttrib(0, v) to be sure it's * issued as the last (provoking) attribute). */ - aa->array = &ctx->Array.ArrayObj->VertexAttrib[0]; + aa->array = &arrayObj->VertexAttrib[0]; assert(aa->array->Size >= 2); /* XXX fix someday? */ aa->offset = VertexFuncs[aa->array->Size-2][TYPE_IDX(aa->array->Type)]; check_vbo(actx, aa->array->BufferObj); aa++; } - else if (ctx->Array.ArrayObj->Vertex.Enabled) { - aa->array = &ctx->Array.ArrayObj->Vertex; + else if (arrayObj->Vertex.Enabled) { + aa->array = &arrayObj->Vertex; aa->offset = VertexFuncs[aa->array->Size-2][TYPE_IDX(aa->array->Type)]; check_vbo(actx, aa->array->BufferObj); aa++; diff --git a/src/mesa/main/api_exec.c b/src/mesa/main/api_exec.c index 6f66ff47a0..02550ae108 100644 --- a/src/mesa/main/api_exec.c +++ b/src/mesa/main/api_exec.c @@ -107,6 +107,7 @@ #include "state.h" #include "stencil.h" #include "texenv.h" +#include "texgetimage.h" #include "teximage.h" #if FEATURE_texgen #include "texgen.h" @@ -128,6 +129,9 @@ #if FEATURE_ARB_shader_objects #include "shaders.h" #endif +#if FEATURE_ARB_sync +#include "syncobj.h" +#endif #include "debug.h" #include "glapi/dispatch.h" @@ -528,7 +532,6 @@ _mesa_init_exec_table(struct _glapi_table *exec) /* 148. GL_EXT_multi_draw_arrays */ #if _HAVE_FULL_GL SET_MultiDrawArraysEXT(exec, _mesa_MultiDrawArraysEXT); - SET_MultiDrawElementsEXT(exec, _mesa_MultiDrawElementsEXT); #endif /* 173. GL_INGR_blend_func_separate */ @@ -641,6 +644,8 @@ _mesa_init_exec_table(struct _glapi_table *exec) /* ???. GL_EXT_depth_bounds_test */ SET_DepthBoundsEXT(exec, _mesa_DepthBoundsEXT); + SET_ProvokingVertexEXT(exec, _mesa_ProvokingVertexEXT); + /* ARB 1. GL_ARB_multitexture */ #if _HAVE_FULL_GL SET_ActiveTextureARB(exec, _mesa_ActiveTextureARB); @@ -821,6 +826,17 @@ _mesa_init_exec_table(struct _glapi_table *exec) SET_GetAttribLocationARB(exec, _mesa_GetAttribLocationARB); #endif /* FEATURE_ARB_vertex_shader */ + /* GL_ARB_sync */ +#if FEATURE_ARB_sync + SET_IsSync(exec, _mesa_IsSync); + SET_DeleteSync(exec, _mesa_DeleteSync); + SET_FenceSync(exec, _mesa_FenceSync); + SET_ClientWaitSync(exec, _mesa_ClientWaitSync); + SET_WaitSync(exec, _mesa_WaitSync); + SET_GetInteger64v(exec, _mesa_GetInteger64v); + SET_GetSynciv(exec, _mesa_GetSynciv); +#endif + /* GL_ATI_fragment_shader */ #if FEATURE_ATI_fragment_shader SET_GenFragmentShadersATI(exec, _mesa_GenFragmentShadersATI); @@ -894,5 +910,16 @@ _mesa_init_exec_table(struct _glapi_table *exec) */ SET_RenderbufferStorageMultisample(exec, _mesa_RenderbufferStorageMultisample); #endif -} +#if FEATURE_ARB_map_buffer_range + SET_MapBufferRange(exec, _mesa_MapBufferRange); + SET_FlushMappedBufferRange(exec, _mesa_FlushMappedBufferRange); +#endif + + /* GL_ARB_copy_buffer */ + SET_CopyBufferSubData(exec, _mesa_CopyBufferSubData); + + /* GL_ARB_vertex_array_object */ + SET_BindVertexArray(exec, _mesa_BindVertexArray); + SET_GenVertexArrays(exec, _mesa_GenVertexArrays); +} diff --git a/src/mesa/main/api_noop.c b/src/mesa/main/api_noop.c index 66f9c4e6bd..09ba7e5062 100644 --- a/src/mesa/main/api_noop.c +++ b/src/mesa/main/api_noop.c @@ -772,6 +772,20 @@ _mesa_noop_DrawRangeElements(GLenum mode, CALL_DrawElements(GET_DISPATCH(), (mode, count, type, indices)); } +/* GL_EXT_multi_draw_arrays */ +void GLAPIENTRY +_mesa_noop_MultiDrawElements(GLenum mode, const GLsizei *count, GLenum type, + const GLvoid **indices, GLsizei primcount) +{ + GLsizei i; + + for (i = 0; i < primcount; i++) { + if (count[i] > 0) { + CALL_DrawElements(GET_DISPATCH(), (mode, count[i], type, indices[i])); + } + } +} + /* * Eval Mesh */ @@ -980,6 +994,7 @@ _mesa_noop_vtxfmt_init( GLvertexformat *vfmt ) vfmt->DrawArrays = _mesa_noop_DrawArrays; vfmt->DrawElements = _mesa_noop_DrawElements; vfmt->DrawRangeElements = _mesa_noop_DrawRangeElements; + vfmt->MultiDrawElementsEXT = _mesa_noop_MultiDrawElements; vfmt->EvalMesh1 = _mesa_noop_EvalMesh1; vfmt->EvalMesh2 = _mesa_noop_EvalMesh2; } diff --git a/src/mesa/main/api_noop.h b/src/mesa/main/api_noop.h index 8bf4660800..a7956d00b3 100644 --- a/src/mesa/main/api_noop.h +++ b/src/mesa/main/api_noop.h @@ -40,6 +40,10 @@ _mesa_noop_EvalMesh2(GLenum mode, GLint i1, GLint i2, GLint j1, GLint j2); extern void GLAPIENTRY _mesa_noop_Materialfv(GLenum face, GLenum pname, const GLfloat *param); +extern void GLAPIENTRY +_mesa_noop_MultiDrawElements(GLenum mode, const GLsizei *count, GLenum type, + const GLvoid **indices, GLsizei primcount); + extern void _mesa_noop_vtxfmt_init(GLvertexformat *vfmt); diff --git a/src/mesa/main/api_validate.c b/src/mesa/main/api_validate.c index 2c6f370df9..507e21fe81 100644 --- a/src/mesa/main/api_validate.c +++ b/src/mesa/main/api_validate.c @@ -24,30 +24,49 @@ #include "glheader.h" #include "api_validate.h" +#include "bufferobj.h" #include "context.h" #include "imports.h" #include "mtypes.h" #include "state.h" + +/** + * \return number of bytes in array [count] of type. + */ +static GLsizei +index_bytes(GLenum type, GLsizei count) +{ + if (type == GL_UNSIGNED_INT) { + return count * sizeof(GLuint); + } + else if (type == GL_UNSIGNED_BYTE) { + return count * sizeof(GLubyte); + } + else { + ASSERT(type == GL_UNSIGNED_SHORT); + return count * sizeof(GLushort); + } +} + + /** * Find the max index in the given element/index buffer */ -static GLuint -max_buffer_index(GLcontext *ctx, GLuint count, GLenum type, - const void *indices, - struct gl_buffer_object *elementBuf) +GLuint +_mesa_max_buffer_index(GLcontext *ctx, GLuint count, GLenum type, + const void *indices, + struct gl_buffer_object *elementBuf) { const GLubyte *map = NULL; GLuint max = 0; GLuint i; - if (elementBuf->Name) { + if (_mesa_is_bufferobj(elementBuf)) { /* elements are in a user-defined buffer object. need to map it */ - map = ctx->Driver.MapBuffer(ctx, - GL_ELEMENT_ARRAY_BUFFER_ARB, - GL_READ_ONLY, - elementBuf); + map = ctx->Driver.MapBuffer(ctx, GL_ELEMENT_ARRAY_BUFFER, + GL_READ_ONLY, elementBuf); /* Actual address is the sum of pointers */ indices = (const GLvoid *) ADD_POINTERS(map, (const GLubyte *) indices); } @@ -70,20 +89,20 @@ max_buffer_index(GLcontext *ctx, GLuint count, GLenum type, } if (map) { - ctx->Driver.UnmapBuffer(ctx, - GL_ELEMENT_ARRAY_BUFFER_ARB, - ctx->Array.ElementArrayBufferObj); + ctx->Driver.UnmapBuffer(ctx, GL_ELEMENT_ARRAY_BUFFER_ARB, elementBuf); } return max; } + +/** + * Check if OK to draw arrays/elements. + */ static GLboolean -check_valid_to_render(GLcontext *ctx, char *function) +check_valid_to_render(GLcontext *ctx, const char *function) { - if (ctx->DrawBuffer->_Status != GL_FRAMEBUFFER_COMPLETE_EXT) { - _mesa_error(ctx, GL_INVALID_FRAMEBUFFER_OPERATION_EXT, - "glDraw%s(incomplete framebuffer)", function); + if (!_mesa_valid_to_render(ctx, function)) { return GL_FALSE; } @@ -105,6 +124,12 @@ check_valid_to_render(GLcontext *ctx, char *function) return GL_TRUE; } + +/** + * Error checking for glDrawElements(). Includes parameter checking + * and VBO bounds checking. + * \return GL_TRUE if OK to render, GL_FALSE if error found + */ GLboolean _mesa_validate_DrawElements(GLcontext *ctx, GLenum mode, GLsizei count, GLenum type, @@ -134,33 +159,14 @@ _mesa_validate_DrawElements(GLcontext *ctx, if (ctx->NewState) _mesa_update_state(ctx); - if (!check_valid_to_render(ctx, "Elements")) + if (!check_valid_to_render(ctx, "glDrawElements")) return GL_FALSE; /* Vertex buffer object tests */ - if (ctx->Array.ElementArrayBufferObj->Name) { + if (_mesa_is_bufferobj(ctx->Array.ElementArrayBufferObj)) { /* use indices in the buffer object */ - GLuint indexBytes; - - if (!ctx->Array.ElementArrayBufferObj->Size) { - _mesa_warning(ctx, - "glDrawElements called with empty array elements buffer"); - return GL_FALSE; - } - - if (type == GL_UNSIGNED_INT) { - indexBytes = count * sizeof(GLuint); - } - else if (type == GL_UNSIGNED_BYTE) { - indexBytes = count * sizeof(GLubyte); - } - else { - ASSERT(type == GL_UNSIGNED_SHORT); - indexBytes = count * sizeof(GLushort); - } - /* make sure count doesn't go outside buffer bounds */ - if (indexBytes > (GLuint) ctx->Array.ElementArrayBufferObj->Size) { + if (index_bytes(type, count) > ctx->Array.ElementArrayBufferObj->Size) { _mesa_warning(ctx, "glDrawElements index out of buffer bounds"); return GL_FALSE; } @@ -173,10 +179,12 @@ _mesa_validate_DrawElements(GLcontext *ctx, if (ctx->Const.CheckArrayBounds) { /* find max array index */ - GLuint max = max_buffer_index(ctx, count, type, indices, - ctx->Array.ElementArrayBufferObj); - if (max >= ctx->Array._MaxElement) { + GLuint max = _mesa_max_buffer_index(ctx, count, type, indices, + ctx->Array.ElementArrayBufferObj); + if (max >= ctx->Array.ArrayObj->_MaxElement) { /* the max element is out of bounds of one or more enabled arrays */ + _mesa_warning(ctx, "glDrawElements() index=%u is " + "out of bounds (max=%u)", max, ctx->Array.ArrayObj->_MaxElement); return GL_FALSE; } } @@ -184,6 +192,12 @@ _mesa_validate_DrawElements(GLcontext *ctx, return GL_TRUE; } + +/** + * Error checking for glDrawRangeElements(). Includes parameter checking + * and VBO bounds checking. + * \return GL_TRUE if OK to render, GL_FALSE if error found + */ GLboolean _mesa_validate_DrawRangeElements(GLcontext *ctx, GLenum mode, GLuint start, GLuint end, @@ -218,27 +232,14 @@ _mesa_validate_DrawRangeElements(GLcontext *ctx, GLenum mode, if (ctx->NewState) _mesa_update_state(ctx); - if (!check_valid_to_render(ctx, "RangeElements")) + if (!check_valid_to_render(ctx, "glDrawRangeElements")) return GL_FALSE; /* Vertex buffer object tests */ - if (ctx->Array.ElementArrayBufferObj->Name) { + if (_mesa_is_bufferobj(ctx->Array.ElementArrayBufferObj)) { /* use indices in the buffer object */ - GLsizei indexBytes; - - if (type == GL_UNSIGNED_INT) { - indexBytes = count * sizeof(GLuint); - } - else if (type == GL_UNSIGNED_BYTE) { - indexBytes = count * sizeof(GLubyte); - } - else { - ASSERT(type == GL_UNSIGNED_SHORT); - indexBytes = count * sizeof(GLushort); - } - /* make sure count doesn't go outside buffer bounds */ - if (indexBytes > ctx->Array.ElementArrayBufferObj->Size) { + if (index_bytes(type, count) > ctx->Array.ElementArrayBufferObj->Size) { _mesa_warning(ctx, "glDrawRangeElements index out of buffer bounds"); return GL_FALSE; } @@ -250,9 +251,9 @@ _mesa_validate_DrawRangeElements(GLcontext *ctx, GLenum mode, } if (ctx->Const.CheckArrayBounds) { - GLuint max = max_buffer_index(ctx, count, type, indices, - ctx->Array.ElementArrayBufferObj); - if (max >= ctx->Array._MaxElement) { + GLuint max = _mesa_max_buffer_index(ctx, count, type, indices, + ctx->Array.ElementArrayBufferObj); + if (max >= ctx->Array.ArrayObj->_MaxElement) { /* the max element is out of bounds of one or more enabled arrays */ return GL_FALSE; } @@ -265,6 +266,7 @@ _mesa_validate_DrawRangeElements(GLcontext *ctx, GLenum mode, /** * Called from the tnl module to error check the function parameters and * verify that we really can draw something. + * \return GL_TRUE if OK to render, GL_FALSE if error found */ GLboolean _mesa_validate_DrawArrays(GLcontext *ctx, @@ -286,11 +288,11 @@ _mesa_validate_DrawArrays(GLcontext *ctx, if (ctx->NewState) _mesa_update_state(ctx); - if (!check_valid_to_render(ctx, "Arrays")) + if (!check_valid_to_render(ctx, "glDrawArrays")) return GL_FALSE; if (ctx->Const.CheckArrayBounds) { - if (start + count > (GLint) ctx->Array._MaxElement) + if (start + count > (GLint) ctx->Array.ArrayObj->_MaxElement) return GL_FALSE; } diff --git a/src/mesa/main/api_validate.h b/src/mesa/main/api_validate.h index 10f0c34e66..ff82a2966c 100644 --- a/src/mesa/main/api_validate.h +++ b/src/mesa/main/api_validate.h @@ -30,6 +30,12 @@ #include "mtypes.h" + +extern GLuint +_mesa_max_buffer_index(GLcontext *ctx, GLuint count, GLenum type, + const void *indices, + struct gl_buffer_object *elementBuf); + extern GLboolean _mesa_validate_DrawArrays(GLcontext *ctx, GLenum mode, GLint start, GLsizei count); diff --git a/src/mesa/main/arrayobj.c b/src/mesa/main/arrayobj.c index 0fa5f0de55..fd35d4e38c 100644 --- a/src/mesa/main/arrayobj.c +++ b/src/mesa/main/arrayobj.c @@ -1,9 +1,10 @@ /* * Mesa 3-D graphics library - * Version: 7.2 + * Version: 7.6 * * Copyright (C) 1999-2008 Brian Paul All Rights Reserved. * (C) Copyright IBM Corporation 2006 + * 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"), @@ -46,6 +47,7 @@ #include "bufferobj.h" #endif #include "arrayobj.h" +#include "macros.h" #include "glapi/dispatch.h" @@ -61,10 +63,11 @@ static INLINE struct gl_array_object * lookup_arrayobj(GLcontext *ctx, GLuint id) { - return (id == 0) - ? NULL - : (struct gl_array_object *) _mesa_HashLookup(ctx->Shared->ArrayObjects, - id); + if (id == 0) + return NULL; + else + return (struct gl_array_object *) + _mesa_HashLookup(ctx->Array.Objects, id); } @@ -79,6 +82,7 @@ unbind_array_object_vbos(GLcontext *ctx, struct gl_array_object *obj) GLuint i; _mesa_reference_buffer_object(ctx, &obj->Vertex.BufferObj, NULL); + _mesa_reference_buffer_object(ctx, &obj->Weight.BufferObj, NULL); _mesa_reference_buffer_object(ctx, &obj->Normal.BufferObj, NULL); _mesa_reference_buffer_object(ctx, &obj->Color.BufferObj, NULL); _mesa_reference_buffer_object(ctx, &obj->SecondaryColor.BufferObj, NULL); @@ -86,10 +90,10 @@ unbind_array_object_vbos(GLcontext *ctx, struct gl_array_object *obj) _mesa_reference_buffer_object(ctx, &obj->Index.BufferObj, NULL); _mesa_reference_buffer_object(ctx, &obj->EdgeFlag.BufferObj, NULL); - for (i = 0; i < MAX_TEXTURE_COORD_UNITS; i++) + for (i = 0; i < Elements(obj->TexCoord); i++) _mesa_reference_buffer_object(ctx, &obj->TexCoord[i].BufferObj, NULL); - for (i = 0; i < VERT_ATTRIB_MAX; i++) + for (i = 0; i < Elements(obj->VertexAttrib); i++) _mesa_reference_buffer_object(ctx, &obj->VertexAttrib[i].BufferObj,NULL); } @@ -198,7 +202,8 @@ init_array(GLcontext *ctx, array->Normalized = GL_FALSE; #if FEATURE_ARB_vertex_buffer_object /* Vertex array buffers */ - array->BufferObj = ctx->Array.NullBufferObj; + _mesa_reference_buffer_object(ctx, &array->BufferObj, + ctx->Shared->NullBufferObj); #endif } @@ -220,16 +225,17 @@ _mesa_initialize_array_object( GLcontext *ctx, /* Init the individual arrays */ init_array(ctx, &obj->Vertex, 4, GL_FLOAT); + init_array(ctx, &obj->Weight, 1, GL_FLOAT); init_array(ctx, &obj->Normal, 3, GL_FLOAT); init_array(ctx, &obj->Color, 4, GL_FLOAT); init_array(ctx, &obj->SecondaryColor, 4, GL_FLOAT); init_array(ctx, &obj->FogCoord, 1, GL_FLOAT); init_array(ctx, &obj->Index, 1, GL_FLOAT); - for (i = 0; i < MAX_TEXTURE_COORD_UNITS; i++) { + for (i = 0; i < Elements(obj->TexCoord); i++) { init_array(ctx, &obj->TexCoord[i], 4, GL_FLOAT); } init_array(ctx, &obj->EdgeFlag, 1, GL_BOOL); - for (i = 0; i < VERT_ATTRIB_MAX; i++) { + for (i = 0; i < Elements(obj->VertexAttrib); i++) { init_array(ctx, &obj->VertexAttrib[i], 4, GL_FLOAT); } @@ -242,12 +248,12 @@ _mesa_initialize_array_object( GLcontext *ctx, /** * Add the given array object to the array object pool. */ -void -_mesa_save_array_object( GLcontext *ctx, struct gl_array_object *obj ) +static void +save_array_object( GLcontext *ctx, struct gl_array_object *obj ) { if (obj->Name > 0) { /* insert into hash table */ - _mesa_HashInsert(ctx->Shared->ArrayObjects, obj->Name, obj); + _mesa_HashInsert(ctx->Array.Objects, obj->Name, obj); } } @@ -256,13 +262,90 @@ _mesa_save_array_object( GLcontext *ctx, struct gl_array_object *obj ) * Remove the given array object from the array object pool. * Do not deallocate the array object though. */ -void -_mesa_remove_array_object( GLcontext *ctx, struct gl_array_object *obj ) +static void +remove_array_object( GLcontext *ctx, struct gl_array_object *obj ) { if (obj->Name > 0) { /* remove from hash table */ - _mesa_HashRemove(ctx->Shared->ArrayObjects, obj->Name); + _mesa_HashRemove(ctx->Array.Objects, obj->Name); + } +} + + + +/** + * Compute the index of the last array element that can be safely accessed + * in a vertex array. We can really only do this when the array lives in + * a VBO. + * The array->_MaxElement field will be updated. + * Later in glDrawArrays/Elements/etc we can do some bounds checking. + */ +static void +compute_max_element(struct gl_client_array *array) +{ + if (array->BufferObj->Name) { + /* Compute the max element we can access in the VBO without going + * out of bounds. + */ + array->_MaxElement = ((GLsizeiptrARB) array->BufferObj->Size + - (GLsizeiptrARB) array->Ptr + array->StrideB + - array->_ElementSize) / array->StrideB; + if (0) + _mesa_printf("%s Object %u Size %u MaxElement %u\n", + __FUNCTION__, + array->BufferObj->Name, + (GLuint) array->BufferObj->Size, + array->_MaxElement); } + else { + /* user-space array, no idea how big it is */ + array->_MaxElement = 2 * 1000 * 1000 * 1000; /* just a big number */ + } +} + + +/** + * Helper for update_arrays(). + * \return min(current min, array->_MaxElement). + */ +static GLuint +update_min(GLuint min, struct gl_client_array *array) +{ + compute_max_element(array); + if (array->Enabled) + return MIN2(min, array->_MaxElement); + else + return min; +} + + +/** + * Examine vertex arrays to update the gl_array_object::_MaxElement field. + */ +void +_mesa_update_array_object_max_element(GLcontext *ctx, + struct gl_array_object *arrayObj) +{ + GLuint i, min = ~0; + + min = update_min(min, &arrayObj->Vertex); + min = update_min(min, &arrayObj->Weight); + min = update_min(min, &arrayObj->Normal); + min = update_min(min, &arrayObj->Color); + min = update_min(min, &arrayObj->SecondaryColor); + min = update_min(min, &arrayObj->FogCoord); + min = update_min(min, &arrayObj->Index); + min = update_min(min, &arrayObj->EdgeFlag); +#if FEATURE_point_size_array + min = update_min(min, &arrayObj->PointSize); +#endif + for (i = 0; i < ctx->Const.MaxTextureCoordUnits; i++) + min = update_min(min, &arrayObj->TexCoord[i]); + for (i = 0; i < Elements(arrayObj->VertexAttrib); i++) + min = update_min(min, &arrayObj->VertexAttrib[i]); + + /* _MaxElement is one past the last legal array element */ + arrayObj->_MaxElement = min; } @@ -270,18 +353,15 @@ _mesa_remove_array_object( GLcontext *ctx, struct gl_array_object *obj ) /* API Functions */ /**********************************************************************/ + /** - * Bind a new array. - * - * \todo - * The binding could be done more efficiently by comparing the non-NULL - * pointers in the old and new objects. The only arrays that are "dirty" are - * the ones that are non-NULL in either object. + * Helper for _mesa_BindVertexArray() and _mesa_BindVertexArrayAPPLE(). + * \param genRequired specifies behavour when id was not generated with + * glGenVertexArrays(). */ -void GLAPIENTRY -_mesa_BindVertexArrayAPPLE( GLuint id ) +static void +bind_vertex_array(GLcontext *ctx, GLuint id, GLboolean genRequired) { - GET_CURRENT_CONTEXT(ctx); struct gl_array_object * const oldObj = ctx->Array.ArrayObj; struct gl_array_object *newObj = NULL; ASSERT_OUTSIDE_BEGIN_END(ctx); @@ -304,14 +384,18 @@ _mesa_BindVertexArrayAPPLE( GLuint id ) /* non-default array object */ newObj = lookup_arrayobj(ctx, id); if (!newObj) { - /* If this is a new array object id, allocate an array object now. - */ + if (genRequired) { + _mesa_error(ctx, GL_INVALID_OPERATION, "glBindVertexArray(id)"); + return; + } + + /* For APPLE version, generate a new array object now */ newObj = (*ctx->Driver.NewArrayObject)(ctx, id); if (!newObj) { _mesa_error(ctx, GL_OUT_OF_MEMORY, "glBindVertexArrayAPPLE"); return; } - _mesa_save_array_object(ctx, newObj); + save_array_object(ctx, newObj); } } @@ -321,7 +405,37 @@ _mesa_BindVertexArrayAPPLE( GLuint id ) /* Pass BindVertexArray call to device driver */ if (ctx->Driver.BindArrayObject && newObj) - (*ctx->Driver.BindArrayObject)( ctx, newObj ); + ctx->Driver.BindArrayObject(ctx, newObj); +} + + +/** + * ARB version of glBindVertexArray() + * This function behaves differently from glBindVertexArrayAPPLE() in + * that this function requires all ids to have been previously generated + * by glGenVertexArrays[APPLE](). + */ +void GLAPIENTRY +_mesa_BindVertexArray( GLuint id ) +{ + GET_CURRENT_CONTEXT(ctx); + bind_vertex_array(ctx, id, GL_TRUE); +} + + +/** + * Bind a new array. + * + * \todo + * The binding could be done more efficiently by comparing the non-NULL + * pointers in the old and new objects. The only arrays that are "dirty" are + * the ones that are non-NULL in either object. + */ +void GLAPIENTRY +_mesa_BindVertexArrayAPPLE( GLuint id ) +{ + GET_CURRENT_CONTEXT(ctx); + bind_vertex_array(ctx, id, GL_FALSE); } @@ -343,8 +457,6 @@ _mesa_DeleteVertexArraysAPPLE(GLsizei n, const GLuint *ids) return; } - _glthread_LOCK_MUTEX(ctx->Shared->Mutex); - for (i = 0; i < n; i++) { struct gl_array_object *obj = lookup_arrayobj(ctx, ids[i]); @@ -360,7 +472,7 @@ _mesa_DeleteVertexArraysAPPLE(GLsizei n, const GLuint *ids) } /* The ID is immediately freed for re-use */ - _mesa_remove_array_object(ctx, obj); + remove_array_object(ctx, obj); /* Unreference the array object. * If refcount hits zero, the object will be deleted. @@ -368,21 +480,19 @@ _mesa_DeleteVertexArraysAPPLE(GLsizei n, const GLuint *ids) _mesa_reference_array_object(ctx, &obj, NULL); } } - - _glthread_UNLOCK_MUTEX(ctx->Shared->Mutex); } /** * Generate a set of unique array object IDs and store them in \c arrays. - * + * Helper for _mesa_GenVertexArrays[APPLE]() functions below. * \param n Number of IDs to generate. * \param arrays Array of \c n locations to store the IDs. + * \param vboOnly Will arrays have to reside in VBOs? */ -void GLAPIENTRY -_mesa_GenVertexArraysAPPLE(GLsizei n, GLuint *arrays) +static void +gen_vertex_arrays(GLcontext *ctx, GLsizei n, GLuint *arrays, GLboolean vboOnly) { - GET_CURRENT_CONTEXT(ctx); GLuint first; GLint i; ASSERT_OUTSIDE_BEGIN_END(ctx); @@ -396,12 +506,7 @@ _mesa_GenVertexArraysAPPLE(GLsizei n, GLuint *arrays) return; } - /* - * This must be atomic (generation and allocation of array object IDs) - */ - _glthread_LOCK_MUTEX(ctx->Shared->Mutex); - - first = _mesa_HashFindFreeKeyBlock(ctx->Shared->ArrayObjects, n); + first = _mesa_HashFindFreeKeyBlock(ctx->Array.Objects, n); /* Allocate new, empty array objects and return identifiers */ for (i = 0; i < n; i++) { @@ -410,15 +515,37 @@ _mesa_GenVertexArraysAPPLE(GLsizei n, GLuint *arrays) obj = (*ctx->Driver.NewArrayObject)( ctx, name ); if (!obj) { - _glthread_UNLOCK_MUTEX(ctx->Shared->Mutex); _mesa_error(ctx, GL_OUT_OF_MEMORY, "glGenVertexArraysAPPLE"); return; } - _mesa_save_array_object(ctx, obj); + obj->VBOonly = vboOnly; + save_array_object(ctx, obj); arrays[i] = first + i; } +} + + +/** + * ARB version of glGenVertexArrays() + * All arrays will be required to live in VBOs. + */ +void GLAPIENTRY +_mesa_GenVertexArrays(GLsizei n, GLuint *arrays) +{ + GET_CURRENT_CONTEXT(ctx); + gen_vertex_arrays(ctx, n, arrays, GL_TRUE); +} + - _glthread_UNLOCK_MUTEX(ctx->Shared->Mutex); +/** + * APPLE version of glGenVertexArraysAPPLE() + * Arrays may live in VBOs or ordinary memory. + */ +void GLAPIENTRY +_mesa_GenVertexArraysAPPLE(GLsizei n, GLuint *arrays) +{ + GET_CURRENT_CONTEXT(ctx); + gen_vertex_arrays(ctx, n, arrays, GL_FALSE); } @@ -439,9 +566,7 @@ _mesa_IsVertexArrayAPPLE( GLuint id ) if (id == 0) return GL_FALSE; - _glthread_LOCK_MUTEX(ctx->Shared->Mutex); obj = lookup_arrayobj(ctx, id); - _glthread_UNLOCK_MUTEX(ctx->Shared->Mutex); return (obj != NULL) ? GL_TRUE : GL_FALSE; } diff --git a/src/mesa/main/arrayobj.h b/src/mesa/main/arrayobj.h index 9c4036af5a..8999edc724 100644 --- a/src/mesa/main/arrayobj.h +++ b/src/mesa/main/arrayobj.h @@ -1,9 +1,10 @@ /* * Mesa 3-D graphics library - * Version: 6.5 + * Version: 7.6 * * Copyright (C) 1999-2004 Brian Paul All Rights Reserved. * (C) Copyright IBM Corporation 2006 + * 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"), @@ -56,22 +57,25 @@ extern void _mesa_initialize_array_object( GLcontext *ctx, struct gl_array_object *obj, GLuint name ); -extern void -_mesa_save_array_object( GLcontext *ctx, struct gl_array_object *obj ); extern void -_mesa_remove_array_object( GLcontext *ctx, struct gl_array_object *obj ); - +_mesa_update_array_object_max_element(GLcontext *ctx, + struct gl_array_object *arrayObj); /* * API functions */ + +void GLAPIENTRY _mesa_BindVertexArray( GLuint id ); + void GLAPIENTRY _mesa_BindVertexArrayAPPLE( GLuint id ); void GLAPIENTRY _mesa_DeleteVertexArraysAPPLE(GLsizei n, const GLuint *ids); +void GLAPIENTRY _mesa_GenVertexArrays(GLsizei n, GLuint *arrays); + void GLAPIENTRY _mesa_GenVertexArraysAPPLE(GLsizei n, GLuint *buffer); GLboolean GLAPIENTRY _mesa_IsVertexArrayAPPLE( GLuint id ); diff --git a/src/mesa/main/attrib.c b/src/mesa/main/attrib.c index 4d85d54bb9..ab99ca1c64 100644 --- a/src/mesa/main/attrib.c +++ b/src/mesa/main/attrib.c @@ -174,24 +174,30 @@ struct texture_state /** - * Allocate a new attribute state node. These nodes have a - * "kind" value and a pointer to a struct of state data. + * Allocate new attribute node of given type/kind. Attach payload data. + * Insert it into the linked list named by 'head'. */ -static struct gl_attrib_node * -new_attrib_node( GLbitfield kind ) +static void +save_attrib_data(struct gl_attrib_node **head, + GLbitfield kind, void *payload) { - struct gl_attrib_node *an = MALLOC_STRUCT(gl_attrib_node); - if (an) { - an->kind = kind; + struct gl_attrib_node *n = MALLOC_STRUCT(gl_attrib_node); + if (n) { + n->kind = kind; + n->data = payload; + /* insert at head */ + n->next = *head; + *head = n; + } + else { + /* out of memory! */ } - return an; } void GLAPIENTRY _mesa_PushAttrib(GLbitfield mask) { - struct gl_attrib_node *newnode; struct gl_attrib_node *head; GET_CURRENT_CONTEXT(ctx); @@ -213,10 +219,7 @@ _mesa_PushAttrib(GLbitfield mask) struct gl_accum_attrib *attr; attr = MALLOC_STRUCT( gl_accum_attrib ); MEMCPY( attr, &ctx->Accum, sizeof(struct gl_accum_attrib) ); - newnode = new_attrib_node( GL_ACCUM_BUFFER_BIT ); - newnode->data = attr; - newnode->next = head; - head = newnode; + save_attrib_data(&head, GL_ACCUM_BUFFER_BIT, attr); } if (mask & GL_COLOR_BUFFER_BIT) { @@ -227,10 +230,7 @@ _mesa_PushAttrib(GLbitfield mask) /* push the Draw FBO's DrawBuffer[] state, not ctx->Color.DrawBuffer[] */ for (i = 0; i < ctx->Const.MaxDrawBuffers; i ++) attr->DrawBuffer[i] = ctx->DrawBuffer->ColorDrawBuffer[i]; - newnode = new_attrib_node( GL_COLOR_BUFFER_BIT ); - newnode->data = attr; - newnode->next = head; - head = newnode; + save_attrib_data(&head, GL_COLOR_BUFFER_BIT, attr); } if (mask & GL_CURRENT_BIT) { @@ -238,20 +238,14 @@ _mesa_PushAttrib(GLbitfield mask) FLUSH_CURRENT( ctx, 0 ); attr = MALLOC_STRUCT( gl_current_attrib ); MEMCPY( attr, &ctx->Current, sizeof(struct gl_current_attrib) ); - newnode = new_attrib_node( GL_CURRENT_BIT ); - newnode->data = attr; - newnode->next = head; - head = newnode; + save_attrib_data(&head, GL_CURRENT_BIT, attr); } if (mask & GL_DEPTH_BUFFER_BIT) { struct gl_depthbuffer_attrib *attr; attr = MALLOC_STRUCT( gl_depthbuffer_attrib ); MEMCPY( attr, &ctx->Depth, sizeof(struct gl_depthbuffer_attrib) ); - newnode = new_attrib_node( GL_DEPTH_BUFFER_BIT ); - newnode->data = attr; - newnode->next = head; - head = newnode; + save_attrib_data(&head, GL_DEPTH_BUFFER_BIT, attr); } if (mask & GL_ENABLE_BIT) { @@ -331,40 +325,28 @@ _mesa_PushAttrib(GLbitfield mask) attr->VertexProgram = ctx->VertexProgram.Enabled; attr->VertexProgramPointSize = ctx->VertexProgram.PointSizeEnabled; attr->VertexProgramTwoSide = ctx->VertexProgram.TwoSideEnabled; - newnode = new_attrib_node( GL_ENABLE_BIT ); - newnode->data = attr; - newnode->next = head; - head = newnode; + save_attrib_data(&head, GL_ENABLE_BIT, attr); } if (mask & GL_EVAL_BIT) { struct gl_eval_attrib *attr; attr = MALLOC_STRUCT( gl_eval_attrib ); MEMCPY( attr, &ctx->Eval, sizeof(struct gl_eval_attrib) ); - newnode = new_attrib_node( GL_EVAL_BIT ); - newnode->data = attr; - newnode->next = head; - head = newnode; + save_attrib_data(&head, GL_EVAL_BIT, attr); } if (mask & GL_FOG_BIT) { struct gl_fog_attrib *attr; attr = MALLOC_STRUCT( gl_fog_attrib ); MEMCPY( attr, &ctx->Fog, sizeof(struct gl_fog_attrib) ); - newnode = new_attrib_node( GL_FOG_BIT ); - newnode->data = attr; - newnode->next = head; - head = newnode; + save_attrib_data(&head, GL_FOG_BIT, attr); } if (mask & GL_HINT_BIT) { struct gl_hint_attrib *attr; attr = MALLOC_STRUCT( gl_hint_attrib ); MEMCPY( attr, &ctx->Hint, sizeof(struct gl_hint_attrib) ); - newnode = new_attrib_node( GL_HINT_BIT ); - newnode->data = attr; - newnode->next = head; - head = newnode; + save_attrib_data(&head, GL_HINT_BIT, attr); } if (mask & GL_LIGHTING_BIT) { @@ -372,30 +354,21 @@ _mesa_PushAttrib(GLbitfield mask) FLUSH_CURRENT(ctx, 0); /* flush material changes */ attr = MALLOC_STRUCT( gl_light_attrib ); MEMCPY( attr, &ctx->Light, sizeof(struct gl_light_attrib) ); - newnode = new_attrib_node( GL_LIGHTING_BIT ); - newnode->data = attr; - newnode->next = head; - head = newnode; + save_attrib_data(&head, GL_LIGHTING_BIT, attr); } if (mask & GL_LINE_BIT) { struct gl_line_attrib *attr; attr = MALLOC_STRUCT( gl_line_attrib ); MEMCPY( attr, &ctx->Line, sizeof(struct gl_line_attrib) ); - newnode = new_attrib_node( GL_LINE_BIT ); - newnode->data = attr; - newnode->next = head; - head = newnode; + save_attrib_data(&head, GL_LINE_BIT, attr); } if (mask & GL_LIST_BIT) { struct gl_list_attrib *attr; attr = MALLOC_STRUCT( gl_list_attrib ); MEMCPY( attr, &ctx->List, sizeof(struct gl_list_attrib) ); - newnode = new_attrib_node( GL_LIST_BIT ); - newnode->data = attr; - newnode->next = head; - head = newnode; + save_attrib_data(&head, GL_LIST_BIT, attr); } if (mask & GL_PIXEL_MODE_BIT) { @@ -404,60 +377,42 @@ _mesa_PushAttrib(GLbitfield mask) MEMCPY( attr, &ctx->Pixel, sizeof(struct gl_pixel_attrib) ); /* push the Read FBO's ReadBuffer state, not ctx->Pixel.ReadBuffer */ attr->ReadBuffer = ctx->ReadBuffer->ColorReadBuffer; - newnode = new_attrib_node( GL_PIXEL_MODE_BIT ); - newnode->data = attr; - newnode->next = head; - head = newnode; + save_attrib_data(&head, GL_PIXEL_MODE_BIT, attr); } if (mask & GL_POINT_BIT) { struct gl_point_attrib *attr; attr = MALLOC_STRUCT( gl_point_attrib ); MEMCPY( attr, &ctx->Point, sizeof(struct gl_point_attrib) ); - newnode = new_attrib_node( GL_POINT_BIT ); - newnode->data = attr; - newnode->next = head; - head = newnode; + save_attrib_data(&head, GL_POINT_BIT, attr); } if (mask & GL_POLYGON_BIT) { struct gl_polygon_attrib *attr; attr = MALLOC_STRUCT( gl_polygon_attrib ); MEMCPY( attr, &ctx->Polygon, sizeof(struct gl_polygon_attrib) ); - newnode = new_attrib_node( GL_POLYGON_BIT ); - newnode->data = attr; - newnode->next = head; - head = newnode; + save_attrib_data(&head, GL_POLYGON_BIT, attr); } if (mask & GL_POLYGON_STIPPLE_BIT) { GLuint *stipple; stipple = (GLuint *) MALLOC( 32*sizeof(GLuint) ); MEMCPY( stipple, ctx->PolygonStipple, 32*sizeof(GLuint) ); - newnode = new_attrib_node( GL_POLYGON_STIPPLE_BIT ); - newnode->data = stipple; - newnode->next = head; - head = newnode; + save_attrib_data(&head, GL_POLYGON_STIPPLE_BIT, stipple); } if (mask & GL_SCISSOR_BIT) { struct gl_scissor_attrib *attr; attr = MALLOC_STRUCT( gl_scissor_attrib ); MEMCPY( attr, &ctx->Scissor, sizeof(struct gl_scissor_attrib) ); - newnode = new_attrib_node( GL_SCISSOR_BIT ); - newnode->data = attr; - newnode->next = head; - head = newnode; + save_attrib_data(&head, GL_SCISSOR_BIT, attr); } if (mask & GL_STENCIL_BUFFER_BIT) { struct gl_stencil_attrib *attr; attr = MALLOC_STRUCT( gl_stencil_attrib ); MEMCPY( attr, &ctx->Stencil, sizeof(struct gl_stencil_attrib) ); - newnode = new_attrib_node( GL_STENCIL_BUFFER_BIT ); - newnode->data = attr; - newnode->next = head; - head = newnode; + save_attrib_data(&head, GL_STENCIL_BUFFER_BIT, attr); } if (mask & GL_TEXTURE_BIT) { @@ -494,30 +449,21 @@ _mesa_PushAttrib(GLbitfield mask) _mesa_unlock_context_textures(ctx); - newnode = new_attrib_node( GL_TEXTURE_BIT ); - newnode->data = texstate; - newnode->next = head; - head = newnode; + save_attrib_data(&head, GL_TEXTURE_BIT, texstate); } if (mask & GL_TRANSFORM_BIT) { struct gl_transform_attrib *attr; attr = MALLOC_STRUCT( gl_transform_attrib ); MEMCPY( attr, &ctx->Transform, sizeof(struct gl_transform_attrib) ); - newnode = new_attrib_node( GL_TRANSFORM_BIT ); - newnode->data = attr; - newnode->next = head; - head = newnode; + save_attrib_data(&head, GL_TRANSFORM_BIT, attr); } if (mask & GL_VIEWPORT_BIT) { struct gl_viewport_attrib *attr; attr = MALLOC_STRUCT( gl_viewport_attrib ); MEMCPY( attr, &ctx->Viewport, sizeof(struct gl_viewport_attrib) ); - newnode = new_attrib_node( GL_VIEWPORT_BIT ); - newnode->data = attr; - newnode->next = head; - head = newnode; + save_attrib_data(&head, GL_VIEWPORT_BIT, attr); } /* GL_ARB_multisample */ @@ -525,10 +471,7 @@ _mesa_PushAttrib(GLbitfield mask) struct gl_multisample_attrib *attr; attr = MALLOC_STRUCT( gl_multisample_attrib ); MEMCPY( attr, &ctx->Multisample, sizeof(struct gl_multisample_attrib) ); - newnode = new_attrib_node( GL_MULTISAMPLE_BIT_ARB ); - newnode->data = attr; - newnode->next = head; - head = newnode; + save_attrib_data(&head, GL_MULTISAMPLE_BIT_ARB, attr); } end: @@ -1324,20 +1267,22 @@ _mesa_PopAttrib(void) * counts when pushing/popping the GL_CLIENT_VERTEX_ARRAY_BIT attribute group. */ static void -adjust_buffer_object_ref_counts(struct gl_array_attrib *array, GLint step) +adjust_buffer_object_ref_counts(struct gl_array_object *arrayObj, GLint step) { GLuint i; - array->ArrayObj->Vertex.BufferObj->RefCount += step; - array->ArrayObj->Normal.BufferObj->RefCount += step; - array->ArrayObj->Color.BufferObj->RefCount += step; - array->ArrayObj->SecondaryColor.BufferObj->RefCount += step; - array->ArrayObj->FogCoord.BufferObj->RefCount += step; - array->ArrayObj->Index.BufferObj->RefCount += step; - array->ArrayObj->EdgeFlag.BufferObj->RefCount += step; - for (i = 0; i < MAX_TEXTURE_COORD_UNITS; i++) - array->ArrayObj->TexCoord[i].BufferObj->RefCount += step; - for (i = 0; i < VERT_ATTRIB_MAX; i++) - array->ArrayObj->VertexAttrib[i].BufferObj->RefCount += step; + + arrayObj->Vertex.BufferObj->RefCount += step; + arrayObj->Weight.BufferObj->RefCount += step; + arrayObj->Normal.BufferObj->RefCount += step; + arrayObj->Color.BufferObj->RefCount += step; + arrayObj->SecondaryColor.BufferObj->RefCount += step; + arrayObj->FogCoord.BufferObj->RefCount += step; + arrayObj->Index.BufferObj->RefCount += step; + arrayObj->EdgeFlag.BufferObj->RefCount += step; + for (i = 0; i < Elements(arrayObj->TexCoord); i++) + arrayObj->TexCoord[i].BufferObj->RefCount += step; + for (i = 0; i < Elements(arrayObj->VertexAttrib); i++) + arrayObj->VertexAttrib[i].BufferObj->RefCount += step; } @@ -1371,7 +1316,6 @@ copy_pixelstore(GLcontext *ctx, void GLAPIENTRY _mesa_PushClientAttrib(GLbitfield mask) { - struct gl_attrib_node *newnode; struct gl_attrib_node *head; GET_CURRENT_CONTEXT(ctx); @@ -1392,17 +1336,11 @@ _mesa_PushClientAttrib(GLbitfield mask) /* packing attribs */ attr = CALLOC_STRUCT( gl_pixelstore_attrib ); copy_pixelstore(ctx, attr, &ctx->Pack); - newnode = new_attrib_node( GL_CLIENT_PACK_BIT ); - newnode->data = attr; - newnode->next = head; - head = newnode; + save_attrib_data(&head, GL_CLIENT_PACK_BIT, attr); /* unpacking attribs */ attr = CALLOC_STRUCT( gl_pixelstore_attrib ); copy_pixelstore(ctx, attr, &ctx->Unpack); - newnode = new_attrib_node( GL_CLIENT_UNPACK_BIT ); - newnode->data = attr; - newnode->next = head; - head = newnode; + save_attrib_data(&head, GL_CLIENT_UNPACK_BIT, attr); } if (mask & GL_CLIENT_VERTEX_ARRAY_BIT) { @@ -1423,12 +1361,10 @@ _mesa_PushClientAttrib(GLbitfield mask) attr->ArrayObj = obj; - newnode = new_attrib_node( GL_CLIENT_VERTEX_ARRAY_BIT ); - newnode->data = attr; - newnode->next = head; - head = newnode; + save_attrib_data(&head, GL_CLIENT_VERTEX_ARRAY_BIT, attr); + /* bump reference counts on buffer objects */ - adjust_buffer_object_ref_counts(&ctx->Array, 1); + adjust_buffer_object_ref_counts(ctx->Array.ArrayObj, 1); } ctx->ClientAttribStack[ctx->ClientAttribStackDepth] = head; @@ -1478,7 +1414,7 @@ _mesa_PopClientAttrib(void) struct gl_array_attrib * data = (struct gl_array_attrib *) node->data; - adjust_buffer_object_ref_counts(&ctx->Array, -1); + adjust_buffer_object_ref_counts(ctx->Array.ArrayObj, -1); ctx->Array.ActiveTexture = data->ActiveTexture; if (data->LockCount != 0) diff --git a/src/mesa/main/bufferobj.c b/src/mesa/main/bufferobj.c index 2d1be5b776..b95e00af5b 100644 --- a/src/mesa/main/bufferobj.c +++ b/src/mesa/main/bufferobj.c @@ -1,9 +1,9 @@ /* * Mesa 3-D graphics library - * Version: 7.5 + * Version: 7.6 * * Copyright (C) 1999-2008 Brian Paul All Rights Reserved. - * Copyright (C) 1999-2009 VMware, Inc. 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"), @@ -39,10 +39,15 @@ #include "bufferobj.h" +/* Debug flags */ +/*#define VBO_DEBUG*/ +/*#define BOUNDS_CHECK*/ + + #ifdef FEATURE_OES_mapbuffer -#define DEFAULT_ACCESS GL_WRITE_ONLY; +#define DEFAULT_ACCESS GL_MAP_WRITE_BIT #else -#define DEFAULT_ACCESS GL_READ_WRITE; +#define DEFAULT_ACCESS (GL_MAP_READ_BIT | GL_MAP_WRITE_BIT) #endif @@ -73,6 +78,16 @@ get_buffer(GLcontext *ctx, GLenum target) case GL_PIXEL_UNPACK_BUFFER_EXT: bufObj = ctx->Unpack.BufferObj; break; + case GL_COPY_READ_BUFFER: + if (ctx->Extensions.ARB_copy_buffer) { + bufObj = ctx->CopyReadBuffer; + } + break; + case GL_COPY_WRITE_BUFFER: + if (ctx->Extensions.ARB_copy_buffer) { + bufObj = ctx->CopyWriteBuffer; + } + break; default: /* error must be recorded by caller */ return NULL; @@ -86,6 +101,24 @@ get_buffer(GLcontext *ctx, GLenum target) /** + * Convert a GLbitfield describing the mapped buffer access flags + * into one of GL_READ_WRITE, GL_READ_ONLY, or GL_WRITE_ONLY. + */ +static GLenum +simplified_access_mode(GLbitfield access) +{ + const GLbitfield rwFlags = GL_MAP_READ_BIT | GL_MAP_WRITE_BIT; + if ((access & rwFlags) == rwFlags) + return GL_READ_WRITE; + if ((access & GL_MAP_READ_BIT) == GL_MAP_READ_BIT) + return GL_READ_ONLY; + if ((access & GL_MAP_WRITE_BIT) == GL_MAP_WRITE_BIT) + return GL_WRITE_ONLY; + return GL_READ_WRITE; /* this should never happen, but no big deal */ +} + + +/** * Tests the subdata range parameters and sets the GL error code for * \c glBufferSubDataARB and \c glGetBufferSubDataARB. * @@ -123,7 +156,7 @@ buffer_object_subdata_range_good( GLcontext * ctx, GLenum target, _mesa_error(ctx, GL_INVALID_ENUM, "%s(target)", caller); return NULL; } - if (bufObj->Name == 0) { + if (!_mesa_is_bufferobj(bufObj)) { _mesa_error(ctx, GL_INVALID_OPERATION, "%s", caller); return NULL; } @@ -132,7 +165,7 @@ buffer_object_subdata_range_good( GLcontext * ctx, GLenum target, "%s(size + offset > buffer size)", caller); return NULL; } - if (bufObj->Pointer) { + if (_mesa_bufferobj_mapped(bufObj)) { /* Buffer is currently mapped */ _mesa_error(ctx, GL_INVALID_OPERATION, "%s", caller); return NULL; @@ -147,7 +180,7 @@ buffer_object_subdata_range_good( GLcontext * ctx, GLenum target, * * Default callback for the \c dd_function_table::NewBufferObject() hook. */ -struct gl_buffer_object * +static struct gl_buffer_object * _mesa_new_buffer_object( GLcontext *ctx, GLuint name, GLenum target ) { struct gl_buffer_object *obj; @@ -165,7 +198,7 @@ _mesa_new_buffer_object( GLcontext *ctx, GLuint name, GLenum target ) * * Default callback for the \c dd_function_table::DeleteBuffer() hook. */ -void +static void _mesa_delete_buffer_object( GLcontext *ctx, struct gl_buffer_object *bufObj ) { (void) ctx; @@ -194,7 +227,7 @@ _mesa_reference_buffer_object(GLcontext *ctx, return; if (*ptr) { - /* Unreference the old texture */ + /* Unreference the old buffer */ GLboolean deleteFlag = GL_FALSE; struct gl_buffer_object *oldObj = *ptr; @@ -227,7 +260,7 @@ _mesa_reference_buffer_object(GLcontext *ctx, ASSERT(!*ptr); if (bufObj) { - /* reference new texture */ + /* reference new buffer */ /*_glthread_LOCK_MUTEX(tex->Mutex);*/ if (bufObj->RefCount == 0) { /* this buffer's being deleted (look just above) */ @@ -261,7 +294,7 @@ _mesa_initialize_buffer_object( struct gl_buffer_object *obj, obj->RefCount = 1; obj->Name = name; obj->Usage = GL_STATIC_DRAW_ARB; - obj->Access = DEFAULT_ACCESS; + obj->AccessFlags = DEFAULT_ACCESS; } @@ -281,9 +314,10 @@ _mesa_initialize_buffer_object( struct gl_buffer_object *obj, * \param usage Hints about how the data will be used. * \param bufObj Object to be used. * + * \return GL_TRUE for success, GL_FALSE for failure * \sa glBufferDataARB, dd_function_table::BufferData. */ -void +static GLboolean _mesa_buffer_data( GLcontext *ctx, GLenum target, GLsizeiptrARB size, const GLvoid * data, GLenum usage, struct gl_buffer_object * bufObj ) @@ -301,6 +335,11 @@ _mesa_buffer_data( GLcontext *ctx, GLenum target, GLsizeiptrARB size, if (data) { _mesa_memcpy( bufObj->Data, data, size ); } + + return GL_TRUE; + } + else { + return GL_FALSE; } } @@ -322,7 +361,7 @@ _mesa_buffer_data( GLcontext *ctx, GLenum target, GLsizeiptrARB size, * * \sa glBufferSubDataARB, dd_function_table::BufferSubData. */ -void +static void _mesa_buffer_subdata( GLcontext *ctx, GLenum target, GLintptrARB offset, GLsizeiptrARB size, const GLvoid * data, struct gl_buffer_object * bufObj ) @@ -355,7 +394,7 @@ _mesa_buffer_subdata( GLcontext *ctx, GLenum target, GLintptrARB offset, * * \sa glBufferGetSubDataARB, dd_function_table::GetBufferSubData. */ -void +static void _mesa_buffer_get_subdata( GLcontext *ctx, GLenum target, GLintptrARB offset, GLsizeiptrARB size, GLvoid * data, struct gl_buffer_object * bufObj ) @@ -382,60 +421,132 @@ _mesa_buffer_get_subdata( GLcontext *ctx, GLenum target, GLintptrARB offset, * * \sa glMapBufferARB, dd_function_table::MapBuffer */ -void * +static void * _mesa_buffer_map( GLcontext *ctx, GLenum target, GLenum access, struct gl_buffer_object *bufObj ) { (void) ctx; (void) target; (void) access; - ASSERT(!bufObj->OnCard); /* Just return a direct pointer to the data */ - if (bufObj->Pointer) { + if (_mesa_bufferobj_mapped(bufObj)) { /* already mapped! */ return NULL; } bufObj->Pointer = bufObj->Data; + bufObj->Length = bufObj->Size; + bufObj->Offset = 0; + return bufObj->Pointer; +} + + +/** + * Default fallback for \c dd_function_table::MapBufferRange(). + * Called via glMapBufferRange(). + */ +static void * +_mesa_buffer_map_range( GLcontext *ctx, GLenum target, GLintptr offset, + GLsizeiptr length, GLbitfield access, + struct gl_buffer_object *bufObj ) +{ + (void) ctx; + (void) target; + assert(!_mesa_bufferobj_mapped(bufObj)); + /* Just return a direct pointer to the data */ + bufObj->Pointer = bufObj->Data + offset; + bufObj->Length = length; + bufObj->Offset = offset; + bufObj->AccessFlags = access; return bufObj->Pointer; } /** + * Default fallback for \c dd_function_table::FlushMappedBufferRange(). + * Called via glFlushMappedBufferRange(). + */ +static void +_mesa_buffer_flush_mapped_range( GLcontext *ctx, GLenum target, + GLintptr offset, GLsizeiptr length, + struct gl_buffer_object *obj ) +{ + (void) ctx; + (void) target; + (void) offset; + (void) length; + (void) obj; + /* no-op */ +} + + +/** * Default callback for \c dd_function_table::MapBuffer(). * * The input parameters will have been already tested for errors. * * \sa glUnmapBufferARB, dd_function_table::UnmapBuffer */ -GLboolean +static GLboolean _mesa_buffer_unmap( GLcontext *ctx, GLenum target, struct gl_buffer_object *bufObj ) { (void) ctx; (void) target; - ASSERT(!bufObj->OnCard); /* XXX we might assert here that bufObj->Pointer is non-null */ bufObj->Pointer = NULL; + bufObj->Length = 0; + bufObj->Offset = 0; + bufObj->AccessFlags = 0x0; return GL_TRUE; } /** + * Default fallback for \c dd_function_table::CopyBufferSubData(). + * Called via glCopyBuffserSubData(). + */ +static void +_mesa_copy_buffer_subdata(GLcontext *ctx, + struct gl_buffer_object *src, + struct gl_buffer_object *dst, + GLintptr readOffset, GLintptr writeOffset, + GLsizeiptr size) +{ + GLubyte *srcPtr, *dstPtr; + + /* buffer should not already be mapped */ + assert(!_mesa_bufferobj_mapped(src)); + assert(!_mesa_bufferobj_mapped(dst)); + + srcPtr = (GLubyte *) ctx->Driver.MapBuffer(ctx, GL_COPY_READ_BUFFER, + GL_READ_ONLY, src); + dstPtr = (GLubyte *) ctx->Driver.MapBuffer(ctx, GL_COPY_WRITE_BUFFER, + GL_WRITE_ONLY, dst); + + if (srcPtr && dstPtr) + _mesa_memcpy(dstPtr + writeOffset, srcPtr + readOffset, size); + + ctx->Driver.UnmapBuffer(ctx, GL_COPY_READ_BUFFER, src); + ctx->Driver.UnmapBuffer(ctx, GL_COPY_WRITE_BUFFER, dst); +} + + + +/** * Initialize the state associated with buffer objects */ void _mesa_init_buffer_objects( GLcontext *ctx ) { - /* Allocate the default buffer object and set refcount so high that - * it never gets deleted. - * XXX with recent/improved refcounting this may not longer be needed. - */ - ctx->Array.NullBufferObj = _mesa_new_buffer_object(ctx, 0, 0); - if (ctx->Array.NullBufferObj) - ctx->Array.NullBufferObj->RefCount = 1000; - - ctx->Array.ArrayBufferObj = ctx->Array.NullBufferObj; - ctx->Array.ElementArrayBufferObj = ctx->Array.NullBufferObj; + _mesa_reference_buffer_object(ctx, &ctx->Array.ArrayBufferObj, + ctx->Shared->NullBufferObj); + _mesa_reference_buffer_object(ctx, &ctx->Array.ElementArrayBufferObj, + ctx->Shared->NullBufferObj); + + _mesa_reference_buffer_object(ctx, &ctx->CopyReadBuffer, + ctx->Shared->NullBufferObj); + _mesa_reference_buffer_object(ctx, &ctx->CopyWriteBuffer, + ctx->Shared->NullBufferObj); } @@ -462,8 +573,22 @@ bind_buffer_object(GLcontext *ctx, GLenum target, GLuint buffer) case GL_PIXEL_UNPACK_BUFFER_EXT: bindTarget = &ctx->Unpack.BufferObj; break; + case GL_COPY_READ_BUFFER: + if (ctx->Extensions.ARB_copy_buffer) { + bindTarget = &ctx->CopyReadBuffer; + } + break; + case GL_COPY_WRITE_BUFFER: + if (ctx->Extensions.ARB_copy_buffer) { + bindTarget = &ctx->CopyWriteBuffer; + } + break; default: - _mesa_error(ctx, GL_INVALID_ENUM, "glBindBufferARB(target)"); + ; /* no-op / we'll hit the follow error test next */ + } + + if (!bindTarget) { + _mesa_error(ctx, GL_INVALID_ENUM, "glBindBufferARB(target 0x%x)"); return; } @@ -479,7 +604,7 @@ bind_buffer_object(GLcontext *ctx, GLenum target, GLuint buffer) /* The spec says there's not a buffer object named 0, but we use * one internally because it simplifies things. */ - newBufObj = ctx->Array.NullBufferObj; + newBufObj = ctx->Shared->NullBufferObj; } else { /* non-default buffer object */ @@ -500,7 +625,7 @@ bind_buffer_object(GLcontext *ctx, GLenum target, GLuint buffer) _mesa_reference_buffer_object(ctx, bindTarget, newBufObj); /* Pass BindBuffer call to device driver */ - if (ctx->Driver.BindBuffer && newBufObj) + if (ctx->Driver.BindBuffer) ctx->Driver.BindBuffer( ctx, target, newBufObj ); } @@ -533,6 +658,8 @@ _mesa_update_default_objects_buffer_objects(GLcontext *ctx) * currently mapped. Whoever calls this function should check for that. * Remember, we can't use a PBO when it's mapped! * + * If we're not using a PBO, this is a no-op. + * * \param width width of image to read/write * \param height height of image to read/write * \param depth depth of image to read/write @@ -551,7 +678,8 @@ _mesa_validate_pbo_access(GLuint dimensions, GLvoid *start, *end; const GLubyte *sizeAddr; /* buffer size, cast to a pointer */ - ASSERT(pack->BufferObj->Name != 0); + if (!_mesa_is_bufferobj(pack->BufferObj)) + return GL_TRUE; /* no PBO, OK */ if (pack->BufferObj->Size == 0) /* no buffer! */ @@ -583,21 +711,22 @@ _mesa_validate_pbo_access(GLuint dimensions, /** - * If the source of glBitmap data is a PBO, check that we won't read out - * of buffer bounds, then map the buffer. - * If not sourcing from a PBO, just return the bitmap pointer. - * This is a helper function for (some) drivers. - * Return NULL if error. - * If non-null return, must call _mesa_unmap_bitmap_pbo() when done. + * For commands that read from a PBO (glDrawPixels, glTexImage, + * glPolygonStipple, etc), if we're reading from a PBO, map it read-only + * and return the pointer into the PBO. If we're not reading from a + * PBO, return \p src as-is. + * If non-null return, must call _mesa_unmap_pbo_source() when done. + * + * \return NULL if error, else pointer to start of data */ -const GLubyte * -_mesa_map_bitmap_pbo(GLcontext *ctx, +const GLvoid * +_mesa_map_pbo_source(GLcontext *ctx, const struct gl_pixelstore_attrib *unpack, - const GLubyte *bitmap) + const GLvoid *src) { const GLubyte *buf; - if (unpack->BufferObj->Name) { + if (_mesa_is_bufferobj(unpack->BufferObj)) { /* unpack from PBO */ buf = (GLubyte *) ctx->Driver.MapBuffer(ctx, GL_PIXEL_UNPACK_BUFFER_EXT, GL_READ_ONLY_ARB, @@ -605,11 +734,11 @@ _mesa_map_bitmap_pbo(GLcontext *ctx, if (!buf) return NULL; - buf = ADD_POINTERS(buf, bitmap); + buf = ADD_POINTERS(buf, src); } else { /* unpack from normal memory */ - buf = bitmap; + buf = src; } return buf; @@ -617,57 +746,55 @@ _mesa_map_bitmap_pbo(GLcontext *ctx, /** - * Counterpart to _mesa_map_bitmap_pbo() - * This is a helper function for (some) drivers. - */ -void -_mesa_unmap_bitmap_pbo(GLcontext *ctx, - const struct gl_pixelstore_attrib *unpack) -{ - if (unpack->BufferObj->Name) { - ctx->Driver.UnmapBuffer(ctx, GL_PIXEL_UNPACK_BUFFER_EXT, - unpack->BufferObj); - } -} - - -/** - * \sa _mesa_map_bitmap_pbo + * Combine PBO-read validation and mapping. + * If any GL errors are detected, they'll be recorded and NULL returned. + * \sa _mesa_validate_pbo_access + * \sa _mesa_map_pbo_source + * A call to this function should have a matching call to + * _mesa_unmap_pbo_source(). */ const GLvoid * -_mesa_map_drawpix_pbo(GLcontext *ctx, - const struct gl_pixelstore_attrib *unpack, - const GLvoid *pixels) +_mesa_map_validate_pbo_source(GLcontext *ctx, + GLuint dimensions, + const struct gl_pixelstore_attrib *unpack, + GLsizei width, GLsizei height, GLsizei depth, + GLenum format, GLenum type, const GLvoid *ptr, + const char *where) { - const GLvoid *buf; + ASSERT(dimensions == 1 || dimensions == 2 || dimensions == 3); - if (unpack->BufferObj->Name) { - /* unpack from PBO */ - buf = (GLubyte *) ctx->Driver.MapBuffer(ctx, GL_PIXEL_UNPACK_BUFFER_EXT, - GL_READ_ONLY_ARB, - unpack->BufferObj); - if (!buf) - return NULL; + if (!_mesa_is_bufferobj(unpack->BufferObj)) { + /* non-PBO access: no validation to be done */ + return ptr; + } - buf = ADD_POINTERS(buf, pixels); + if (!_mesa_validate_pbo_access(dimensions, unpack, + width, height, depth, format, type, ptr)) { + _mesa_error(ctx, GL_INVALID_OPERATION, + "%s(out of bounds PBO access)", where); + return NULL; } - else { - /* unpack from normal memory */ - buf = pixels; + + if (_mesa_bufferobj_mapped(unpack->BufferObj)) { + /* buffer is already mapped - that's an error */ + _mesa_error(ctx, GL_INVALID_OPERATION, "%s(PBO is mapped)", where); + return NULL; } - return buf; + ptr = _mesa_map_pbo_source(ctx, unpack, ptr); + return ptr; } /** - * \sa _mesa_unmap_bitmap_pbo + * Counterpart to _mesa_map_pbo_source() */ void -_mesa_unmap_drawpix_pbo(GLcontext *ctx, - const struct gl_pixelstore_attrib *unpack) +_mesa_unmap_pbo_source(GLcontext *ctx, + const struct gl_pixelstore_attrib *unpack) { - if (unpack->BufferObj->Name) { + ASSERT(unpack != &ctx->Pack); /* catch pack/unpack mismatch */ + if (_mesa_is_bufferobj(unpack->BufferObj)) { ctx->Driver.UnmapBuffer(ctx, GL_PIXEL_UNPACK_BUFFER_EXT, unpack->BufferObj); } @@ -675,18 +802,21 @@ _mesa_unmap_drawpix_pbo(GLcontext *ctx, /** - * If PBO is bound, map the buffer, return dest pointer in mapped buffer. - * Call _mesa_unmap_readpix_pbo() when finished - * \return NULL if error + * For commands that write to a PBO (glReadPixels, glGetColorTable, etc), + * if we're writing to a PBO, map it write-only and return the pointer + * into the PBO. If we're not writing to a PBO, return \p dst as-is. + * If non-null return, must call _mesa_unmap_pbo_dest() when done. + * + * \return NULL if error, else pointer to start of data */ void * -_mesa_map_readpix_pbo(GLcontext *ctx, - const struct gl_pixelstore_attrib *pack, - GLvoid *dest) +_mesa_map_pbo_dest(GLcontext *ctx, + const struct gl_pixelstore_attrib *pack, + GLvoid *dest) { void *buf; - if (pack->BufferObj->Name) { + if (_mesa_is_bufferobj(pack->BufferObj)) { /* pack into PBO */ buf = (GLubyte *) ctx->Driver.MapBuffer(ctx, GL_PIXEL_PACK_BUFFER_EXT, GL_WRITE_ONLY_ARB, @@ -706,13 +836,55 @@ _mesa_map_readpix_pbo(GLcontext *ctx, /** - * Counterpart to _mesa_map_readpix_pbo() + * Combine PBO-write validation and mapping. + * If any GL errors are detected, they'll be recorded and NULL returned. + * \sa _mesa_validate_pbo_access + * \sa _mesa_map_pbo_dest + * A call to this function should have a matching call to + * _mesa_unmap_pbo_dest(). + */ +GLvoid * +_mesa_map_validate_pbo_dest(GLcontext *ctx, + GLuint dimensions, + const struct gl_pixelstore_attrib *unpack, + GLsizei width, GLsizei height, GLsizei depth, + GLenum format, GLenum type, GLvoid *ptr, + const char *where) +{ + ASSERT(dimensions == 1 || dimensions == 2 || dimensions == 3); + + if (!_mesa_is_bufferobj(unpack->BufferObj)) { + /* non-PBO access: no validation to be done */ + return ptr; + } + + if (!_mesa_validate_pbo_access(dimensions, unpack, + width, height, depth, format, type, ptr)) { + _mesa_error(ctx, GL_INVALID_OPERATION, + "%s(out of bounds PBO access)", where); + return NULL; + } + + if (_mesa_bufferobj_mapped(unpack->BufferObj)) { + /* buffer is already mapped - that's an error */ + _mesa_error(ctx, GL_INVALID_OPERATION, "%s(PBO is mapped)", where); + return NULL; + } + + ptr = _mesa_map_pbo_dest(ctx, unpack, ptr); + return ptr; +} + + +/** + * Counterpart to _mesa_map_pbo_dest() */ void -_mesa_unmap_readpix_pbo(GLcontext *ctx, - const struct gl_pixelstore_attrib *pack) +_mesa_unmap_pbo_dest(GLcontext *ctx, + const struct gl_pixelstore_attrib *pack) { - if (pack->BufferObj->Name) { + ASSERT(pack != &ctx->Unpack); /* catch pack/unpack mismatch */ + if (_mesa_is_bufferobj(pack->BufferObj)) { ctx->Driver.UnmapBuffer(ctx, GL_PIXEL_PACK_BUFFER_EXT, pack->BufferObj); } } @@ -746,11 +918,37 @@ unbind(GLcontext *ctx, struct gl_buffer_object *obj) { if (*ptr == obj) { - _mesa_reference_buffer_object(ctx, ptr, ctx->Array.NullBufferObj); + _mesa_reference_buffer_object(ctx, ptr, ctx->Shared->NullBufferObj); } } +/** + * Plug default/fallback buffer object functions into the device + * driver hooks. + */ +void +_mesa_init_buffer_object_functions(struct dd_function_table *driver) +{ + /* GL_ARB_vertex/pixel_buffer_object */ + driver->NewBufferObject = _mesa_new_buffer_object; + driver->DeleteBuffer = _mesa_delete_buffer_object; + driver->BindBuffer = NULL; + driver->BufferData = _mesa_buffer_data; + driver->BufferSubData = _mesa_buffer_subdata; + driver->GetBufferSubData = _mesa_buffer_get_subdata; + driver->MapBuffer = _mesa_buffer_map; + driver->UnmapBuffer = _mesa_buffer_unmap; + + /* GL_ARB_map_buffer_range */ + driver->MapBufferRange = _mesa_buffer_map_range; + driver->FlushMappedBufferRange = _mesa_buffer_flush_mapped_range; + + /* GL_ARB_copy_buffer */ + driver->CopyBufferSubData = _mesa_copy_buffer_subdata; +} + + /**********************************************************************/ /* API Functions */ @@ -789,30 +987,32 @@ _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) { + struct gl_array_object *arrayObj = ctx->Array.ArrayObj; GLuint j; ASSERT(bufObj->Name == ids[i]); - if (bufObj->Pointer) { + if (_mesa_bufferobj_mapped(bufObj)) { /* if mapped, unmap it now */ ctx->Driver.UnmapBuffer(ctx, 0, bufObj); - bufObj->Access = DEFAULT_ACCESS; + bufObj->AccessFlags = 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); - unbind(ctx, &ctx->Array.ArrayObj->SecondaryColor.BufferObj, bufObj); - unbind(ctx, &ctx->Array.ArrayObj->FogCoord.BufferObj, bufObj); - unbind(ctx, &ctx->Array.ArrayObj->Index.BufferObj, bufObj); - unbind(ctx, &ctx->Array.ArrayObj->EdgeFlag.BufferObj, bufObj); - for (j = 0; j < MAX_TEXTURE_COORD_UNITS; j++) { - unbind(ctx, &ctx->Array.ArrayObj->TexCoord[j].BufferObj, bufObj); + unbind(ctx, &arrayObj->Vertex.BufferObj, bufObj); + unbind(ctx, &arrayObj->Weight.BufferObj, bufObj); + unbind(ctx, &arrayObj->Normal.BufferObj, bufObj); + unbind(ctx, &arrayObj->Color.BufferObj, bufObj); + unbind(ctx, &arrayObj->SecondaryColor.BufferObj, bufObj); + unbind(ctx, &arrayObj->FogCoord.BufferObj, bufObj); + unbind(ctx, &arrayObj->Index.BufferObj, bufObj); + unbind(ctx, &arrayObj->EdgeFlag.BufferObj, bufObj); + for (j = 0; j < Elements(arrayObj->TexCoord); j++) { + unbind(ctx, &arrayObj->TexCoord[j].BufferObj, bufObj); } - for (j = 0; j < VERT_ATTRIB_MAX; j++) { - unbind(ctx, &ctx->Array.ArrayObj->VertexAttrib[j].BufferObj, bufObj); + for (j = 0; j < Elements(arrayObj->VertexAttrib); j++) { + unbind(ctx, &arrayObj->VertexAttrib[j].BufferObj, bufObj); } if (ctx->Array.ArrayBufferObj == bufObj) { @@ -946,22 +1146,35 @@ _mesa_BufferDataARB(GLenum target, GLsizeiptrARB size, _mesa_error(ctx, GL_INVALID_ENUM, "glBufferDataARB(target)" ); return; } - if (bufObj->Name == 0) { - _mesa_error(ctx, GL_INVALID_OPERATION, "glBufferDataARB" ); + if (!_mesa_is_bufferobj(bufObj)) { + _mesa_error(ctx, GL_INVALID_OPERATION, "glBufferDataARB(buffer 0)" ); return; } - if (bufObj->Pointer) { + if (_mesa_bufferobj_mapped(bufObj)) { /* 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; + bufObj->AccessFlags = DEFAULT_ACCESS; + ASSERT(bufObj->Pointer == NULL); } - ASSERT(ctx->Driver.BufferData); + FLUSH_VERTICES(ctx, _NEW_BUFFER_OBJECT); + + bufObj->Written = GL_TRUE; - /* Give the buffer object to the driver! <data> may be null! */ - ctx->Driver.BufferData( ctx, target, size, data, usage, bufObj ); +#ifdef VBO_DEBUG + _mesa_printf("glBufferDataARB(%u, sz %ld, from %p, usage 0x%x)\n", + bufObj->Name, size, data, usage); +#endif + +#ifdef BOUNDS_CHECK + size += 100; +#endif + + ASSERT(ctx->Driver.BufferData); + if (!ctx->Driver.BufferData( ctx, target, size, data, usage, bufObj )) { + _mesa_error(ctx, GL_OUT_OF_MEMORY, "glBufferDataARB(access)"); + } } @@ -980,6 +1193,8 @@ _mesa_BufferSubDataARB(GLenum target, GLintptrARB offset, return; } + bufObj->Written = GL_TRUE; + ASSERT(ctx->Driver.BufferSubData); ctx->Driver.BufferSubData( ctx, target, offset, size, data, bufObj ); } @@ -1010,13 +1225,20 @@ _mesa_MapBufferARB(GLenum target, GLenum access) { GET_CURRENT_CONTEXT(ctx); struct gl_buffer_object * bufObj; + GLbitfield accessFlags; + void *map; + ASSERT_OUTSIDE_BEGIN_END_WITH_RETVAL(ctx, NULL); switch (access) { case GL_READ_ONLY_ARB: + accessFlags = GL_MAP_READ_BIT; + break; case GL_WRITE_ONLY_ARB: + accessFlags = GL_MAP_WRITE_BIT; + break; case GL_READ_WRITE_ARB: - /* OK */ + accessFlags = GL_MAP_READ_BIT | GL_MAP_WRITE_BIT; break; default: _mesa_error(ctx, GL_INVALID_ENUM, "glMapBufferARB(access)"); @@ -1028,22 +1250,56 @@ _mesa_MapBufferARB(GLenum target, GLenum access) _mesa_error(ctx, GL_INVALID_ENUM, "glMapBufferARB(target)" ); return NULL; } - if (bufObj->Name == 0) { - _mesa_error(ctx, GL_INVALID_OPERATION, "glMapBufferARB" ); + if (!_mesa_is_bufferobj(bufObj)) { + _mesa_error(ctx, GL_INVALID_OPERATION, "glMapBufferARB(buffer 0)" ); return NULL; } - if (bufObj->Pointer) { + if (_mesa_bufferobj_mapped(bufObj)) { _mesa_error(ctx, GL_INVALID_OPERATION, "glMapBufferARB(already mapped)"); return NULL; } ASSERT(ctx->Driver.MapBuffer); - bufObj->Pointer = ctx->Driver.MapBuffer( ctx, target, access, bufObj ); - if (!bufObj->Pointer) { - _mesa_error(ctx, GL_OUT_OF_MEMORY, "glMapBufferARB(map failed)"); + map = ctx->Driver.MapBuffer( ctx, target, access, bufObj ); + if (!map) { + _mesa_error(ctx, GL_OUT_OF_MEMORY, "glMapBufferARB(access)"); + return NULL; + } + else { + /* The driver callback should have set these fields. + * This is important because other modules (like VBO) might call + * the driver function directly. + */ + ASSERT(bufObj->Pointer == map); + ASSERT(bufObj->Length == bufObj->Size); + ASSERT(bufObj->Offset == 0); + bufObj->AccessFlags = accessFlags; + } + + if (access == GL_WRITE_ONLY_ARB || access == GL_READ_WRITE_ARB) + bufObj->Written = GL_TRUE; + +#ifdef VBO_DEBUG + _mesa_printf("glMapBufferARB(%u, sz %ld, access 0x%x)\n", + bufObj->Name, bufObj->Size, access); + if (access == GL_WRITE_ONLY_ARB) { + GLuint i; + GLubyte *b = (GLubyte *) bufObj->Pointer; + for (i = 0; i < bufObj->Size; i++) + b[i] = i & 0xff; } +#endif - bufObj->Access = access; +#ifdef BOUNDS_CHECK + { + GLubyte *buf = (GLubyte *) bufObj->Pointer; + GLuint i; + /* buffer is 100 bytes larger than requested, fill with magic value */ + for (i = 0; i < 100; i++) { + buf[bufObj->Size - i - 1] = 123; + } + } +#endif return bufObj->Pointer; } @@ -1062,18 +1318,56 @@ _mesa_UnmapBufferARB(GLenum target) _mesa_error(ctx, GL_INVALID_ENUM, "glUnmapBufferARB(target)" ); return GL_FALSE; } - if (bufObj->Name == 0) { + if (!_mesa_is_bufferobj(bufObj)) { _mesa_error(ctx, GL_INVALID_OPERATION, "glUnmapBufferARB" ); return GL_FALSE; } - if (!bufObj->Pointer) { + if (!_mesa_bufferobj_mapped(bufObj)) { _mesa_error(ctx, GL_INVALID_OPERATION, "glUnmapBufferARB"); return GL_FALSE; } +#ifdef BOUNDS_CHECK + if (bufObj->Access != GL_READ_ONLY_ARB) { + GLubyte *buf = (GLubyte *) bufObj->Pointer; + GLuint i; + /* check that last 100 bytes are still = magic value */ + for (i = 0; i < 100; i++) { + GLuint pos = bufObj->Size - i - 1; + if (buf[pos] != 123) { + _mesa_warning(ctx, "Out of bounds buffer object write detected" + " at position %d (value = %u)\n", + pos, buf[pos]); + } + } + } +#endif + +#ifdef VBO_DEBUG + if (bufObj->AccessFlags & GL_MAP_WRITE_BIT) { + GLuint i, unchanged = 0; + GLubyte *b = (GLubyte *) bufObj->Pointer; + GLint pos = -1; + /* check which bytes changed */ + for (i = 0; i < bufObj->Size - 1; i++) { + if (b[i] == (i & 0xff) && b[i+1] == ((i+1) & 0xff)) { + unchanged++; + if (pos == -1) + pos = i; + } + } + if (unchanged) { + _mesa_printf("glUnmapBufferARB(%u): %u of %ld unchanged, starting at %d\n", + bufObj->Name, unchanged, bufObj->Size, pos); + } + } +#endif + status = ctx->Driver.UnmapBuffer( ctx, target, bufObj ); - bufObj->Access = DEFAULT_ACCESS; - bufObj->Pointer = NULL; + bufObj->AccessFlags = DEFAULT_ACCESS; + ASSERT(bufObj->Pointer == NULL); + ASSERT(bufObj->Offset == 0); + ASSERT(bufObj->Length == 0); return status; } @@ -1091,7 +1385,7 @@ _mesa_GetBufferParameterivARB(GLenum target, GLenum pname, GLint *params) _mesa_error(ctx, GL_INVALID_ENUM, "GetBufferParameterivARB(target)" ); return; } - if (bufObj->Name == 0) { + if (!_mesa_is_bufferobj(bufObj)) { _mesa_error(ctx, GL_INVALID_OPERATION, "GetBufferParameterivARB" ); return; } @@ -1104,10 +1398,10 @@ _mesa_GetBufferParameterivARB(GLenum target, GLenum pname, GLint *params) *params = bufObj->Usage; break; case GL_BUFFER_ACCESS_ARB: - *params = bufObj->Access; + *params = simplified_access_mode(bufObj->AccessFlags); break; case GL_BUFFER_MAPPED_ARB: - *params = (bufObj->Pointer != NULL); + *params = _mesa_bufferobj_mapped(bufObj); break; default: _mesa_error(ctx, GL_INVALID_ENUM, "glGetBufferParameterivARB(pname)"); @@ -1133,10 +1427,252 @@ _mesa_GetBufferPointervARB(GLenum target, GLenum pname, GLvoid **params) _mesa_error(ctx, GL_INVALID_ENUM, "glGetBufferPointervARB(target)" ); return; } - if (bufObj->Name == 0) { + if (!_mesa_is_bufferobj(bufObj)) { _mesa_error(ctx, GL_INVALID_OPERATION, "glGetBufferPointervARB" ); return; } *params = bufObj->Pointer; } + + +void GLAPIENTRY +_mesa_CopyBufferSubData(GLenum readTarget, GLenum writeTarget, + GLintptr readOffset, GLintptr writeOffset, + GLsizeiptr size) +{ + GET_CURRENT_CONTEXT(ctx); + struct gl_buffer_object *src, *dst; + ASSERT_OUTSIDE_BEGIN_END(ctx); + + src = get_buffer(ctx, readTarget); + if (!src || !_mesa_is_bufferobj(src)) { + _mesa_error(ctx, GL_INVALID_ENUM, + "glCopyBuffserSubData(readTarget = 0x%x)", readTarget); + return; + } + + dst = get_buffer(ctx, writeTarget); + if (!dst || !_mesa_is_bufferobj(dst)) { + _mesa_error(ctx, GL_INVALID_ENUM, + "glCopyBuffserSubData(writeTarget = 0x%x)", writeTarget); + return; + } + + if (_mesa_bufferobj_mapped(src)) { + _mesa_error(ctx, GL_INVALID_OPERATION, + "glCopyBuffserSubData(readBuffer is mapped)"); + return; + } + + if (_mesa_bufferobj_mapped(dst)) { + _mesa_error(ctx, GL_INVALID_OPERATION, + "glCopyBuffserSubData(writeBuffer is mapped)"); + return; + } + + if (readOffset < 0) { + _mesa_error(ctx, GL_INVALID_VALUE, + "glCopyBuffserSubData(readOffset = %d)", readOffset); + return; + } + + if (writeOffset < 0) { + _mesa_error(ctx, GL_INVALID_VALUE, + "glCopyBuffserSubData(writeOffset = %d)", writeOffset); + return; + } + + if (readOffset + size > src->Size) { + _mesa_error(ctx, GL_INVALID_VALUE, + "glCopyBuffserSubData(readOffset + size = %d)", + readOffset, size); + return; + } + + if (writeOffset + size > dst->Size) { + _mesa_error(ctx, GL_INVALID_VALUE, + "glCopyBuffserSubData(writeOffset + size = %d)", + writeOffset, size); + return; + } + + if (src == dst) { + if (readOffset + size <= writeOffset) { + /* OK */ + } + else if (writeOffset + size <= readOffset) { + /* OK */ + } + else { + /* overlapping src/dst is illegal */ + _mesa_error(ctx, GL_INVALID_VALUE, + "glCopyBuffserSubData(overlapping src/dst)"); + return; + } + } + + ctx->Driver.CopyBufferSubData(ctx, src, dst, readOffset, writeOffset, size); +} + + +/** + * See GL_ARB_map_buffer_range spec + */ +void * GLAPIENTRY +_mesa_MapBufferRange(GLenum target, GLintptr offset, GLsizeiptr length, + GLbitfield access) +{ + GET_CURRENT_CONTEXT(ctx); + struct gl_buffer_object *bufObj; + void *map; + + ASSERT_OUTSIDE_BEGIN_END_WITH_RETVAL(ctx, NULL); + + if (!ctx->Extensions.ARB_map_buffer_range) { + _mesa_error(ctx, GL_INVALID_OPERATION, + "glMapBufferRange(extension not supported)"); + return NULL; + } + + if (offset < 0) { + _mesa_error(ctx, GL_INVALID_VALUE, + "glMapBufferRange(offset = %ld)", offset); + return NULL; + } + + if (length < 0) { + _mesa_error(ctx, GL_INVALID_VALUE, + "glMapBufferRange(length = %ld)", length); + return NULL; + } + + if ((access & (GL_MAP_READ_BIT | GL_MAP_WRITE_BIT)) == 0) { + _mesa_error(ctx, GL_INVALID_OPERATION, + "glMapBufferRange(access indicates neither read or write)"); + return NULL; + } + + if (access & GL_MAP_READ_BIT) { + if ((access & GL_MAP_INVALIDATE_RANGE_BIT) || + (access & GL_MAP_INVALIDATE_BUFFER_BIT) || + (access & GL_MAP_UNSYNCHRONIZED_BIT)) { + _mesa_error(ctx, GL_INVALID_OPERATION, + "glMapBufferRange(invalid access flags)"); + return NULL; + } + } + + if ((access & GL_MAP_FLUSH_EXPLICIT_BIT) && + ((access & GL_MAP_WRITE_BIT) == 0)) { + _mesa_error(ctx, GL_INVALID_OPERATION, + "glMapBufferRange(invalid access flags)"); + return NULL; + } + + bufObj = get_buffer(ctx, target); + if (!bufObj || !_mesa_is_bufferobj(bufObj)) { + _mesa_error(ctx, GL_INVALID_ENUM, + "glMapBufferRange(target = 0x%x)", target); + return NULL; + } + + if (offset + length > bufObj->Size) { + _mesa_error(ctx, GL_INVALID_VALUE, + "glMapBufferRange(offset + length > size)"); + return NULL; + } + + if (_mesa_bufferobj_mapped(bufObj)) { + _mesa_error(ctx, GL_INVALID_OPERATION, + "glMapBufferRange(buffer already mapped)"); + return NULL; + } + + ASSERT(ctx->Driver.MapBufferRange); + map = ctx->Driver.MapBufferRange(ctx, target, offset, length, + access, bufObj); + if (!map) { + _mesa_error(ctx, GL_OUT_OF_MEMORY, "glMapBufferARB(access)"); + } + else { + /* The driver callback should have set all these fields. + * This is important because other modules (like VBO) might call + * the driver function directly. + */ + ASSERT(bufObj->Pointer == map); + ASSERT(bufObj->Length == length); + ASSERT(bufObj->Offset == offset); + ASSERT(bufObj->AccessFlags == access); + } + + return map; +} + + +/** + * See GL_ARB_map_buffer_range spec + */ +void GLAPIENTRY +_mesa_FlushMappedBufferRange(GLenum target, GLintptr offset, GLsizeiptr length) +{ + GET_CURRENT_CONTEXT(ctx); + struct gl_buffer_object *bufObj; + ASSERT_OUTSIDE_BEGIN_END(ctx); + + if (!ctx->Extensions.ARB_map_buffer_range) { + _mesa_error(ctx, GL_INVALID_OPERATION, + "glMapBufferRange(extension not supported)"); + return; + } + + if (offset < 0) { + _mesa_error(ctx, GL_INVALID_VALUE, + "glMapBufferRange(offset = %ld)", offset); + return; + } + + if (length < 0) { + _mesa_error(ctx, GL_INVALID_VALUE, + "glMapBufferRange(length = %ld)", length); + return; + } + + bufObj = get_buffer(ctx, target); + if (!bufObj) { + _mesa_error(ctx, GL_INVALID_ENUM, + "glMapBufferRange(target = 0x%x)", target); + return; + } + + if (!_mesa_is_bufferobj(bufObj)) { + _mesa_error(ctx, GL_INVALID_OPERATION, + "glMapBufferRange(current buffer is 0)"); + return; + } + + if (!_mesa_bufferobj_mapped(bufObj)) { + /* buffer is not mapped */ + _mesa_error(ctx, GL_INVALID_OPERATION, + "glMapBufferRange(buffer is not mapped)"); + return; + } + + if ((bufObj->AccessFlags & GL_MAP_FLUSH_EXPLICIT_BIT) == 0) { + _mesa_error(ctx, GL_INVALID_OPERATION, + "glMapBufferRange(GL_MAP_FLUSH_EXPLICIT_BIT not set)"); + return; + } + + if (offset + length > bufObj->Length) { + _mesa_error(ctx, GL_INVALID_VALUE, + "glMapBufferRange(offset %ld + length %ld > mapped length %ld)", + offset, length, bufObj->Length); + return; + } + + ASSERT(bufObj->AccessFlags & GL_MAP_WRITE_BIT); + + if (ctx->Driver.FlushMappedBufferRange) + ctx->Driver.FlushMappedBufferRange(ctx, target, offset, length, bufObj); +} diff --git a/src/mesa/main/bufferobj.h b/src/mesa/main/bufferobj.h index 3c08f0083c..9f732ec0c0 100644 --- a/src/mesa/main/bufferobj.h +++ b/src/mesa/main/bufferobj.h @@ -1,8 +1,9 @@ /* * Mesa 3-D graphics library - * Version: 7.2 + * Version: 7.6 * * 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"), @@ -35,17 +36,32 @@ * Internal functions */ + +/** Is the given buffer object currently mapped? */ +static INLINE GLboolean +_mesa_bufferobj_mapped(const struct gl_buffer_object *obj) +{ + return obj->Pointer != NULL; +} + +/** + * Is the given buffer object a user-created buffer object? + * Mesa uses default buffer objects in several places. Default buffers + * always have Name==0. User created buffers have Name!=0. + */ +static INLINE GLboolean +_mesa_is_bufferobj(const struct gl_buffer_object *obj) +{ + return obj->Name != 0; +} + + extern void _mesa_init_buffer_objects( GLcontext *ctx ); extern void _mesa_update_default_objects_buffer_objects(GLcontext *ctx); -extern struct gl_buffer_object * -_mesa_new_buffer_object( GLcontext *ctx, GLuint name, GLenum target ); - -extern void -_mesa_delete_buffer_object( GLcontext *ctx, struct gl_buffer_object *bufObj ); extern struct gl_buffer_object * _mesa_lookup_bufferobj(GLcontext *ctx, GLuint buffer); @@ -59,63 +75,50 @@ _mesa_reference_buffer_object(GLcontext *ctx, struct gl_buffer_object **ptr, struct gl_buffer_object *bufObj); -extern void -_mesa_buffer_data( GLcontext *ctx, GLenum target, GLsizeiptrARB size, - const GLvoid * data, GLenum usage, - struct gl_buffer_object * bufObj ); - -extern void -_mesa_buffer_subdata( GLcontext *ctx, GLenum target, GLintptrARB offset, - GLsizeiptrARB size, const GLvoid * data, - struct gl_buffer_object * bufObj ); - -extern void -_mesa_buffer_get_subdata( GLcontext *ctx, GLenum target, GLintptrARB offset, - GLsizeiptrARB size, GLvoid * data, - struct gl_buffer_object * bufObj ); - -extern void * -_mesa_buffer_map( GLcontext *ctx, GLenum target, GLenum access, - struct gl_buffer_object * bufObj ); - -extern GLboolean -_mesa_buffer_unmap( GLcontext *ctx, GLenum target, - struct gl_buffer_object * bufObj ); - extern GLboolean _mesa_validate_pbo_access(GLuint dimensions, const struct gl_pixelstore_attrib *pack, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const GLvoid *ptr); -extern const GLubyte * -_mesa_map_bitmap_pbo(GLcontext *ctx, +extern const GLvoid * +_mesa_map_pbo_source(GLcontext *ctx, const struct gl_pixelstore_attrib *unpack, - const GLubyte *bitmap); - -extern void -_mesa_unmap_bitmap_pbo(GLcontext *ctx, - const struct gl_pixelstore_attrib *unpack); + const GLvoid *src); extern const GLvoid * -_mesa_map_drawpix_pbo(GLcontext *ctx, - const struct gl_pixelstore_attrib *unpack, - const GLvoid *pixels); +_mesa_map_validate_pbo_source(GLcontext *ctx, + GLuint dimensions, + const struct gl_pixelstore_attrib *unpack, + GLsizei width, GLsizei height, GLsizei depth, + GLenum format, GLenum type, const GLvoid *ptr, + const char *where); extern void -_mesa_unmap_drawpix_pbo(GLcontext *ctx, - const struct gl_pixelstore_attrib *unpack); +_mesa_unmap_pbo_source(GLcontext *ctx, + const struct gl_pixelstore_attrib *unpack); extern void * -_mesa_map_readpix_pbo(GLcontext *ctx, - const struct gl_pixelstore_attrib *pack, - GLvoid *dest); +_mesa_map_pbo_dest(GLcontext *ctx, + const struct gl_pixelstore_attrib *pack, + GLvoid *dest); + +extern GLvoid * +_mesa_map_validate_pbo_dest(GLcontext *ctx, + GLuint dimensions, + const struct gl_pixelstore_attrib *unpack, + GLsizei width, GLsizei height, GLsizei depth, + GLenum format, GLenum type, GLvoid *ptr, + const char *where); extern void -_mesa_unmap_readpix_pbo(GLcontext *ctx, - const struct gl_pixelstore_attrib *pack); +_mesa_unmap_pbo_dest(GLcontext *ctx, + const struct gl_pixelstore_attrib *pack); +extern void +_mesa_init_buffer_object_functions(struct dd_function_table *driver); + /* * API functions @@ -154,4 +157,16 @@ _mesa_GetBufferParameterivARB(GLenum target, GLenum pname, GLint *params); extern void GLAPIENTRY _mesa_GetBufferPointervARB(GLenum target, GLenum pname, GLvoid **params); +extern void GLAPIENTRY +_mesa_CopyBufferSubData(GLenum readTarget, GLenum writeTarget, + GLintptr readOffset, GLintptr writeOffset, + GLsizeiptr size); + +extern void * GLAPIENTRY +_mesa_MapBufferRange(GLenum target, GLintptr offset, GLsizeiptr length, + GLbitfield access); + +extern void GLAPIENTRY +_mesa_FlushMappedBufferRange(GLenum target, GLintptr offset, GLsizeiptr length); + #endif diff --git a/src/mesa/main/buffers.c b/src/mesa/main/buffers.c index c5f13345f0..d8b5f3b1f4 100644 --- a/src/mesa/main/buffers.c +++ b/src/mesa/main/buffers.c @@ -443,7 +443,7 @@ _mesa_readbuffer(GLcontext *ctx, GLenum buffer, GLint bufferIndex) fb->ColorReadBuffer = buffer; fb->_ColorReadBufferIndex = bufferIndex; - ctx->NewState |= _NEW_PIXEL; + ctx->NewState |= _NEW_BUFFERS; } diff --git a/src/mesa/main/colortab.c b/src/mesa/main/colortab.c index bd9cf438b4..5a7de5f209 100644 --- a/src/mesa/main/colortab.c +++ b/src/mesa/main/colortab.c @@ -179,26 +179,12 @@ store_colortable_entries(GLcontext *ctx, struct gl_color_table *table, GLfloat bScale, GLfloat bBias, GLfloat aScale, GLfloat aBias) { - if (ctx->Unpack.BufferObj->Name) { - /* Get/unpack the color table data from a PBO */ - GLubyte *buf; - if (!_mesa_validate_pbo_access(1, &ctx->Unpack, count, 1, 1, - format, type, data)) { - _mesa_error(ctx, GL_INVALID_OPERATION, - "glColor[Sub]Table(bad PBO access)"); - return; - } - buf = (GLubyte *) ctx->Driver.MapBuffer(ctx, GL_PIXEL_UNPACK_BUFFER_EXT, - GL_READ_ONLY_ARB, - ctx->Unpack.BufferObj); - if (!buf) { - _mesa_error(ctx, GL_INVALID_OPERATION, - "glColor[Sub]Table(PBO mapped)"); - return; - } - data = ADD_POINTERS(buf, data); - } - + data = _mesa_map_validate_pbo_source(ctx, + 1, &ctx->Unpack, count, 1, 1, + format, type, data, + "glColor[Sub]Table"); + if (!data) + return; { /* convert user-provided data to GLfloat values */ @@ -279,10 +265,7 @@ store_colortable_entries(GLcontext *ctx, struct gl_color_table *table, } } - if (ctx->Unpack.BufferObj->Name) { - ctx->Driver.UnmapBuffer(ctx, GL_PIXEL_UNPACK_BUFFER_EXT, - ctx->Unpack.BufferObj); - } + _mesa_unmap_pbo_source(ctx, &ctx->Unpack); } @@ -696,34 +679,17 @@ _mesa_GetColorTable( GLenum target, GLenum format, return; } - if (ctx->Pack.BufferObj->Name) { - /* pack color table into PBO */ - GLubyte *buf; - if (!_mesa_validate_pbo_access(1, &ctx->Pack, table->Size, 1, 1, - format, type, data)) { - _mesa_error(ctx, GL_INVALID_OPERATION, - "glGetColorTable(invalid PBO access)"); - return; - } - buf = (GLubyte *) ctx->Driver.MapBuffer(ctx, GL_PIXEL_PACK_BUFFER_EXT, - GL_WRITE_ONLY_ARB, - ctx->Pack.BufferObj); - if (!buf) { - /* buffer is already mapped - that's an error */ - _mesa_error(ctx, GL_INVALID_OPERATION, - "glGetColorTable(PBO is mapped)"); - return; - } - data = ADD_POINTERS(buf, data); - } + data = _mesa_map_validate_pbo_dest(ctx, + 1, &ctx->Pack, table->Size, 1, 1, + format, type, data, + "glGetColorTable"); + if (!data) + return; _mesa_pack_rgba_span_float(ctx, table->Size, rgba, format, type, data, &ctx->Pack, 0x0); - if (ctx->Pack.BufferObj->Name) { - ctx->Driver.UnmapBuffer(ctx, GL_PIXEL_PACK_BUFFER_EXT, - ctx->Pack.BufferObj); - } + _mesa_unmap_pbo_dest(ctx, &ctx->Pack); } diff --git a/src/mesa/main/config.h b/src/mesa/main/config.h index 114119006a..8a09efdb53 100644 --- a/src/mesa/main/config.h +++ b/src/mesa/main/config.h @@ -170,10 +170,48 @@ /** For GL_EXT_texture_lod_bias (typically MAX_TEXTURE_LEVELS - 1) */ #define MAX_TEXTURE_LOD_BIAS 12.0 +/** For any program target/extension */ +/*@{*/ +#define MAX_PROGRAM_INSTRUCTIONS (16 * 1024) + +/** + * Per-program constants (power of two) + * + * \c MAX_PROGRAM_LOCAL_PARAMS and \c MAX_UNIFORMS are just the assmebly shader + * and GLSL shader names for the same thing. They should \b always have the + * same value. Each refers to the number of vec4 values supplied as + * per-program parameters. + */ +/*@{*/ +#define MAX_PROGRAM_LOCAL_PARAMS 1024 +#define MAX_UNIFORMS 1024 +/*@}*/ + +/** + * Per-context constants (power of two) + * + * \note + * This value should always be less than or equal to \c MAX_PROGRAM_LOCAL_PARAMS + * and \c MAX_VERTEX_PROGRAM_PARAMS. Otherwise some applications will make + * incorrect assumptions. + */ +#define MAX_PROGRAM_ENV_PARAMS 256 + +#define MAX_PROGRAM_MATRICES 8 +#define MAX_PROGRAM_MATRIX_STACK_DEPTH 4 +#define MAX_PROGRAM_CALL_DEPTH 8 +#define MAX_PROGRAM_TEMPS 256 +#define MAX_PROGRAM_ADDRESS_REGS 2 +#define MAX_VARYING 16 /**< number of float[4] vectors */ +#define MAX_SAMPLERS MAX_TEXTURE_IMAGE_UNITS +#define MAX_PROGRAM_INPUTS 32 +#define MAX_PROGRAM_OUTPUTS 32 +/*@}*/ + /** For GL_ARB_vertex_program */ /*@{*/ #define MAX_VERTEX_PROGRAM_ADDRESS_REGS 1 -#define MAX_VERTEX_PROGRAM_ATTRIBS 16 +#define MAX_VERTEX_PROGRAM_PARAMS MAX_UNIFORMS /*@}*/ /** For GL_ARB_fragment_program */ @@ -181,23 +219,6 @@ #define MAX_FRAGMENT_PROGRAM_ADDRESS_REGS 0 /*@}*/ -/** For any program target/extension */ -/*@{*/ -#define MAX_PROGRAM_INSTRUCTIONS (16 * 1024) -#define MAX_PROGRAM_LOCAL_PARAMS 256 /**< per-program constants (power of two) */ -#define MAX_PROGRAM_ENV_PARAMS 256 /**< per-context constants (power of two) */ -#define MAX_PROGRAM_MATRICES 8 -#define MAX_PROGRAM_MATRIX_STACK_DEPTH 4 -#define MAX_PROGRAM_CALL_DEPTH 8 -#define MAX_PROGRAM_TEMPS 256 -#define MAX_PROGRAM_ADDRESS_REGS 2 -#define MAX_UNIFORMS 1024 /**< number of vec4 uniforms */ -#define MAX_VARYING 16 /**< number of float[4] vectors */ -#define MAX_SAMPLERS MAX_TEXTURE_IMAGE_UNITS -#define MAX_PROGRAM_INPUTS 32 -#define MAX_PROGRAM_OUTPUTS 32 -/*@}*/ - /** For GL_NV_vertex_program */ /*@{*/ #define MAX_NV_VERTEX_PROGRAM_INSTRUCTIONS 128 diff --git a/src/mesa/main/context.c b/src/mesa/main/context.c index 0a4c9acdfe..f6d4ac4595 100644 --- a/src/mesa/main/context.c +++ b/src/mesa/main/context.c @@ -129,6 +129,9 @@ #if FEATURE_ARB_occlusion_query #include "queryobj.h" #endif +#if FEATURE_ARB_sync +#include "syncobj.h" +#endif #if FEATURE_drawpix #include "rastpos.h" #endif @@ -150,6 +153,7 @@ #include "glapi/glapioffsets.h" #include "glapi/glapitable.h" #include "shader/program.h" +#include "shader/prog_print.h" #include "shader/shader_api.h" #if FEATURE_ATI_fragment_shader #include "shader/atifragshader.h" @@ -455,7 +459,7 @@ _mesa_init_current(GLcontext *ctx) GLuint i; /* Init all to (0,0,0,1) */ - for (i = 0; i < VERT_ATTRIB_MAX; i++) { + for (i = 0; i < Elements(ctx->Current.Attrib); i++) { ASSIGN_4V( ctx->Current.Attrib[i], 0.0, 0.0, 0.0, 1.0 ); } @@ -486,7 +490,7 @@ init_program_limits(GLenum type, struct gl_program_constants *prog) prog->MaxUniformComponents = 4 * MAX_UNIFORMS; if (type == GL_VERTEX_PROGRAM_ARB) { - prog->MaxParameters = MAX_NV_VERTEX_PROGRAM_PARAMS; + prog->MaxParameters = MAX_VERTEX_PROGRAM_PARAMS; prog->MaxAttribs = MAX_NV_VERTEX_PROGRAM_INPUTS; prog->MaxAddressRegs = MAX_VERTEX_PROGRAM_ADDRESS_REGS; } @@ -496,15 +500,17 @@ init_program_limits(GLenum type, struct gl_program_constants *prog) prog->MaxAddressRegs = MAX_FRAGMENT_PROGRAM_ADDRESS_REGS; } - /* copy the above limits to init native limits */ - prog->MaxNativeInstructions = prog->MaxInstructions; - prog->MaxNativeAluInstructions = prog->MaxAluInstructions; - prog->MaxNativeTexInstructions = prog->MaxTexInstructions; - prog->MaxNativeTexIndirections = prog->MaxTexIndirections; - prog->MaxNativeAttribs = prog->MaxAttribs; - prog->MaxNativeTemps = prog->MaxTemps; - prog->MaxNativeAddressRegs = prog->MaxAddressRegs; - prog->MaxNativeParameters = prog->MaxParameters; + /* Set the native limits to zero. This implies that there is no native + * support for shaders. Let the drivers fill in the actual values. + */ + prog->MaxNativeInstructions = 0; + prog->MaxNativeAluInstructions = 0; + prog->MaxNativeTexInstructions = 0; + prog->MaxNativeTexIndirections = 0; + prog->MaxNativeAttribs = 0; + prog->MaxNativeTemps = 0; + prog->MaxNativeAddressRegs = 0; + prog->MaxNativeParameters = 0; } @@ -589,9 +595,15 @@ _mesa_init_constants(GLcontext *ctx) /* GL_ARB_framebuffer_object */ ctx->Const.MaxSamples = 0; + /* GL_ARB_sync */ + ctx->Const.MaxServerWaitTimeout = (GLuint64) ~0; + /* GL_ATI_envmap_bumpmap */ ctx->Const.SupportedBumpUnits = SUPPORTED_ATI_BUMP_UNITS; + /* GL_EXT_provoking_vertex */ + ctx->Const.QuadsFollowProvokingVertexConvention = GL_TRUE; + /* sanity checks */ ASSERT(ctx->Const.MaxTextureUnits == MIN2(ctx->Const.MaxTextureImageUnits, ctx->Const.MaxTextureCoordUnits)); @@ -602,6 +614,10 @@ _mesa_init_constants(GLcontext *ctx) ASSERT(MAX_NV_VERTEX_PROGRAM_TEMPS <= MAX_PROGRAM_TEMPS); ASSERT(MAX_NV_VERTEX_PROGRAM_INPUTS <= VERT_ATTRIB_MAX); ASSERT(MAX_NV_VERTEX_PROGRAM_OUTPUTS <= VERT_RESULT_MAX); + + /* check that we don't exceed various 32-bit bitfields */ + ASSERT(VERT_RESULT_MAX <= 32); + ASSERT(FRAG_ATTRIB_MAX <= 32); } @@ -705,6 +721,9 @@ init_attrib_groups(GLcontext *ctx) #if FEATURE_ARB_occlusion_query _mesa_init_query( ctx ); #endif +#if FEATURE_ARB_sync + _mesa_init_sync( ctx ); +#endif #if FEATURE_drawpix _mesa_init_rastpos( ctx ); #endif @@ -1004,6 +1023,10 @@ _mesa_free_context_data( GLcontext *ctx ) #if FEATURE_ARB_occlusion_query _mesa_free_query_data(ctx); #endif +#if FEATURE_ARB_sync + _mesa_free_sync_data(ctx); +#endif + _mesa_free_varray_data(ctx); _mesa_delete_array_object(ctx, ctx->Array.DefaultArrayObj); @@ -1017,10 +1040,6 @@ _mesa_free_context_data( GLcontext *ctx ) _mesa_reference_buffer_object(ctx, &ctx->Array.ElementArrayBufferObj, NULL); #endif -#if FEATURE_ARB_vertex_buffer_object - _mesa_delete_buffer_object(ctx, ctx->Array.NullBufferObj); -#endif - /* free dispatch tables */ _mesa_free(ctx->Exec); _mesa_free(ctx->Save); @@ -1572,4 +1591,82 @@ _mesa_set_mvp_with_dp4( GLcontext *ctx, } + +/** + * Prior to drawing anything with glBegin, glDrawArrays, etc. this function + * is called to see if it's valid to render. This involves checking that + * the current shader is valid and the framebuffer is complete. + * If an error is detected it'll be recorded here. + * \return GL_TRUE if OK to render, GL_FALSE if not + */ +GLboolean +_mesa_valid_to_render(GLcontext *ctx, const char *where) +{ + if (ctx->Shader.CurrentProgram) { + /* using shaders */ + if (!ctx->Shader.CurrentProgram->LinkStatus) { + _mesa_error(ctx, GL_INVALID_OPERATION, + "%s(shader not linked), where"); + return GL_FALSE; + } +#if 0 /* not normally enabled */ + { + char errMsg[100]; + if (!_mesa_validate_shader_program(ctx, ctx->Shader.CurrentProgram, + errMsg)) { + _mesa_warning(ctx, "Shader program %u is invalid: %s", + ctx->Shader.CurrentProgram->Name, errMsg); + } + } +#endif + } + else { + if (ctx->VertexProgram.Enabled && !ctx->VertexProgram._Enabled) { + _mesa_error(ctx, GL_INVALID_OPERATION, + "%s(vertex program not valid)", where); + return GL_FALSE; + } + if (ctx->FragmentProgram.Enabled && !ctx->FragmentProgram._Enabled) { + _mesa_error(ctx, GL_INVALID_OPERATION, + "%s(fragment program not valid)", where); + return GL_FALSE; + } + } + + if (ctx->DrawBuffer->_Status != GL_FRAMEBUFFER_COMPLETE_EXT) { + _mesa_error(ctx, GL_INVALID_FRAMEBUFFER_OPERATION_EXT, + "%s(incomplete framebuffer)", where); + return GL_FALSE; + } + +#ifdef DEBUG + if (ctx->Shader.Flags & GLSL_LOG) { + struct gl_shader_program *shProg = ctx->Shader.CurrentProgram; + if (shProg) { + if (!shProg->_Used) { + /* This is the first time this shader is being used. + * Append shader's constants/uniforms to log file. + */ + GLuint i; + for (i = 0; i < shProg->NumShaders; i++) { + struct gl_shader *sh = shProg->Shaders[i]; + if (sh->Type == GL_VERTEX_SHADER) { + _mesa_append_uniforms_to_file(sh, + &shProg->VertexProgram->Base); + } + else if (sh->Type == GL_FRAGMENT_SHADER) { + _mesa_append_uniforms_to_file(sh, + &shProg->FragmentProgram->Base); + } + } + shProg->_Used = GL_TRUE; + } + } + } +#endif + + return GL_TRUE; +} + + /*@}*/ diff --git a/src/mesa/main/context.h b/src/mesa/main/context.h index 0531ae8ee8..5587695fa0 100644 --- a/src/mesa/main/context.h +++ b/src/mesa/main/context.h @@ -159,6 +159,11 @@ _mesa_set_mvp_with_dp4( GLcontext *ctx, GLboolean flag ); +extern GLboolean +_mesa_valid_to_render(GLcontext *ctx, const char *where); + + + /** \name Miscellaneous */ /*@{*/ @@ -174,7 +179,6 @@ _mesa_Flush( void ); /*@}*/ - /** * \name Macros for flushing buffered rendering commands before state changes, * checking if inside glBegin/glEnd, etc. diff --git a/src/mesa/main/convolve.c b/src/mesa/main/convolve.c index 814c6a0a5a..70951112a1 100644 --- a/src/mesa/main/convolve.c +++ b/src/mesa/main/convolve.c @@ -144,39 +144,19 @@ _mesa_ConvolutionFilter1D(GLenum target, GLenum internalFormat, GLsizei width, G ctx->Convolution1D.Width = width; ctx->Convolution1D.Height = 1; - if (ctx->Unpack.BufferObj->Name) { - /* unpack filter from PBO */ - GLubyte *buf; - if (!_mesa_validate_pbo_access(1, &ctx->Unpack, width, 1, 1, - format, type, image)) { - _mesa_error(ctx, GL_INVALID_OPERATION, - "glConvolutionFilter1D(invalid PBO access)"); - return; - } - buf = (GLubyte *) ctx->Driver.MapBuffer(ctx, GL_PIXEL_UNPACK_BUFFER_EXT, - GL_READ_ONLY_ARB, - ctx->Unpack.BufferObj); - if (!buf) { - /* buffer is already mapped - that's an error */ - _mesa_error(ctx, GL_INVALID_OPERATION, - "glConvolutionFilter1D(PBO is mapped)"); - return; - } - image = ADD_POINTERS(buf, image); - } - else if (!image) { + image = _mesa_map_validate_pbo_source(ctx, + 1, &ctx->Unpack, width, 1, 1, + format, type, image, + "glConvolutionFilter1D"); + if (!image) return; - } _mesa_unpack_color_span_float(ctx, width, GL_RGBA, ctx->Convolution1D.Filter, format, type, image, &ctx->Unpack, 0); /* transferOps */ - if (ctx->Unpack.BufferObj->Name) { - ctx->Driver.UnmapBuffer(ctx, GL_PIXEL_UNPACK_BUFFER_EXT, - ctx->Unpack.BufferObj); - } + _mesa_unmap_pbo_source(ctx, &ctx->Unpack); _mesa_scale_and_bias_rgba(width, (GLfloat (*)[4]) ctx->Convolution1D.Filter, @@ -242,29 +222,12 @@ _mesa_ConvolutionFilter2D(GLenum target, GLenum internalFormat, GLsizei width, G ctx->Convolution2D.Width = width; ctx->Convolution2D.Height = height; - if (ctx->Unpack.BufferObj->Name) { - /* unpack filter from PBO */ - GLubyte *buf; - if (!_mesa_validate_pbo_access(2, &ctx->Unpack, width, height, 1, - format, type, image)) { - _mesa_error(ctx, GL_INVALID_OPERATION, - "glConvolutionFilter2D(invalid PBO access)"); - return; - } - buf = (GLubyte *) ctx->Driver.MapBuffer(ctx, GL_PIXEL_UNPACK_BUFFER_EXT, - GL_READ_ONLY_ARB, - ctx->Unpack.BufferObj); - if (!buf) { - /* buffer is already mapped - that's an error */ - _mesa_error(ctx, GL_INVALID_OPERATION, - "glConvolutionFilter2D(PBO is mapped)"); - return; - } - image = ADD_POINTERS(buf, image); - } - else if (!image) { + image = _mesa_map_validate_pbo_source(ctx, + 2, &ctx->Unpack, width, height, 1, + format, type, image, + "glConvolutionFilter2D"); + if (!image) return; - } /* Unpack filter image. We always store filters in RGBA format. */ for (i = 0; i < height; i++) { @@ -276,10 +239,7 @@ _mesa_ConvolutionFilter2D(GLenum target, GLenum internalFormat, GLsizei width, G 0); /* transferOps */ } - if (ctx->Unpack.BufferObj->Name) { - ctx->Driver.UnmapBuffer(ctx, GL_PIXEL_UNPACK_BUFFER_EXT, - ctx->Unpack.BufferObj); - } + _mesa_unmap_pbo_source(ctx, &ctx->Unpack); _mesa_scale_and_bias_rgba(width * height, (GLfloat (*)[4]) ctx->Convolution2D.Filter, @@ -598,27 +558,12 @@ _mesa_GetConvolutionFilter(GLenum target, GLenum format, GLenum type, return; } - if (ctx->Pack.BufferObj->Name) { - /* Pack the filter into a PBO */ - GLubyte *buf; - if (!_mesa_validate_pbo_access(2, &ctx->Pack, - filter->Width, filter->Height, - 1, format, type, image)) { - _mesa_error(ctx, GL_INVALID_OPERATION, - "glGetConvolutionFilter(invalid PBO access)"); - return; - } - buf = (GLubyte *) ctx->Driver.MapBuffer(ctx, GL_PIXEL_PACK_BUFFER_EXT, - GL_WRITE_ONLY_ARB, - ctx->Pack.BufferObj); - if (!buf) { - /* buffer is already mapped - that's an error */ - _mesa_error(ctx, GL_INVALID_OPERATION, - "glGetConvolutionFilter(PBO is mapped)"); - return; - } - image = ADD_POINTERS(image, buf); - } + image = _mesa_map_validate_pbo_dest(ctx, 2, &ctx->Pack, + filter->Width, filter->Height, 1, + format, type, image, + "glGetConvolutionFilter"); + if (!image) + return; for (row = 0; row < filter->Height; row++) { GLvoid *dst = _mesa_image_address2d(&ctx->Pack, image, filter->Width, @@ -629,10 +574,7 @@ _mesa_GetConvolutionFilter(GLenum target, GLenum format, GLenum type, format, type, dst, &ctx->Pack, 0x0); } - if (ctx->Pack.BufferObj->Name) { - ctx->Driver.UnmapBuffer(ctx, GL_PIXEL_PACK_BUFFER_EXT, - ctx->Pack.BufferObj); - } + _mesa_unmap_pbo_dest(ctx, &ctx->Pack); } @@ -802,59 +744,35 @@ _mesa_GetSeparableFilter(GLenum target, GLenum format, GLenum type, filter = &ctx->Separable2D; - if (ctx->Pack.BufferObj->Name) { - /* Pack filter into PBO */ - GLubyte *buf; - if (!_mesa_validate_pbo_access(1, &ctx->Pack, filter->Width, 1, 1, - format, type, row)) { - _mesa_error(ctx, GL_INVALID_OPERATION, - "glGetSeparableFilter(invalid PBO access, width)"); - return; - } - if (!_mesa_validate_pbo_access(1, &ctx->Pack, filter->Height, 1, 1, - format, type, column)) { - _mesa_error(ctx, GL_INVALID_OPERATION, - "glGetSeparableFilter(invalid PBO access, height)"); - return; - } - buf = (GLubyte *) ctx->Driver.MapBuffer(ctx, GL_PIXEL_PACK_BUFFER_EXT, - GL_WRITE_ONLY_ARB, - ctx->Pack.BufferObj); - if (!buf) { - /* buffer is already mapped - that's an error */ - _mesa_error(ctx, GL_INVALID_OPERATION, - "glGetSeparableFilter(PBO is mapped)"); - return; - } - row = ADD_POINTERS(buf, row); - column = ADD_POINTERS(buf, column); - } - - /* Row filter */ + /* Get row filter */ + row = _mesa_map_validate_pbo_dest(ctx, 1, &ctx->Pack, + filter->Width, 1, 1, + format, type, row, + "glGetConvolutionFilter"); if (row) { GLvoid *dst = _mesa_image_address1d(&ctx->Pack, row, filter->Width, format, type, 0); _mesa_pack_rgba_span_float(ctx, filter->Width, (GLfloat (*)[4]) filter->Filter, format, type, dst, &ctx->Pack, 0x0); + _mesa_unmap_pbo_dest(ctx, &ctx->Pack); } - /* Column filter */ + /* get column filter */ + column = _mesa_map_validate_pbo_dest(ctx, 1, &ctx->Pack, + filter->Height, 1, 1, + format, type, column, + "glGetConvolutionFilter"); if (column) { GLvoid *dst = _mesa_image_address1d(&ctx->Pack, column, filter->Height, format, type, 0); GLfloat (*src)[4] = (GLfloat (*)[4]) (filter->Filter + colStart); _mesa_pack_rgba_span_float(ctx, filter->Height, src, format, type, dst, &ctx->Pack, 0x0); + _mesa_unmap_pbo_dest(ctx, &ctx->Pack); } (void) span; /* unused at this time */ - - if (ctx->Pack.BufferObj->Name) { - /* Pack filter into PBO */ - ctx->Driver.UnmapBuffer(ctx, GL_PIXEL_UNPACK_BUFFER_EXT, - ctx->Unpack.BufferObj); - } } @@ -905,41 +823,16 @@ _mesa_SeparableFilter2D(GLenum target, GLenum internalFormat, GLsizei width, GLs ctx->Separable2D.Width = width; ctx->Separable2D.Height = height; - if (ctx->Unpack.BufferObj->Name) { - /* unpack filter from PBO */ - GLubyte *buf; - if (!_mesa_validate_pbo_access(1, &ctx->Unpack, width, 1, 1, - format, type, row)) { - _mesa_error(ctx, GL_INVALID_OPERATION, - "glSeparableFilter2D(invalid PBO access, width)"); - return; - } - if (!_mesa_validate_pbo_access(1, &ctx->Unpack, height, 1, 1, - format, type, column)) { - _mesa_error(ctx, GL_INVALID_OPERATION, - "glSeparableFilter2D(invalid PBO access, height)"); - return; - } - buf = (GLubyte *) ctx->Driver.MapBuffer(ctx, GL_PIXEL_UNPACK_BUFFER_EXT, - GL_READ_ONLY_ARB, - ctx->Unpack.BufferObj); - if (!buf) { - /* buffer is already mapped - that's an error */ - _mesa_error(ctx, GL_INVALID_OPERATION, - "glSeparableFilter2D(PBO is mapped)"); - return; - } - row = ADD_POINTERS(buf, row); - column = ADD_POINTERS(buf, column); - } - /* unpack row filter */ + row = _mesa_map_validate_pbo_source(ctx, 1, &ctx->Unpack, + width, 1, 1, + format, type, row, + "glSeparableFilter2D"); if (row) { _mesa_unpack_color_span_float(ctx, width, GL_RGBA, ctx->Separable2D.Filter, format, type, row, &ctx->Unpack, - 0); /* transferOps */ - + 0x0); /* transferOps */ _mesa_scale_and_bias_rgba(width, (GLfloat (*)[4]) ctx->Separable2D.Filter, ctx->Pixel.ConvolutionFilterScale[2][0], @@ -950,9 +843,14 @@ _mesa_SeparableFilter2D(GLenum target, GLenum internalFormat, GLsizei width, GLs ctx->Pixel.ConvolutionFilterBias[2][1], ctx->Pixel.ConvolutionFilterBias[2][2], ctx->Pixel.ConvolutionFilterBias[2][3]); + _mesa_unmap_pbo_source(ctx, &ctx->Unpack); } /* unpack column filter */ + column = _mesa_map_validate_pbo_source(ctx, 1, &ctx->Unpack, + height, 1, 1, + format, type, column, + "glSeparableFilter2D"); if (column) { _mesa_unpack_color_span_float(ctx, height, GL_RGBA, &ctx->Separable2D.Filter[colStart], @@ -969,9 +867,10 @@ _mesa_SeparableFilter2D(GLenum target, GLenum internalFormat, GLsizei width, GLs ctx->Pixel.ConvolutionFilterBias[2][1], ctx->Pixel.ConvolutionFilterBias[2][2], ctx->Pixel.ConvolutionFilterBias[2][3]); + _mesa_unmap_pbo_source(ctx, &ctx->Unpack); } - if (ctx->Unpack.BufferObj->Name) { + if (_mesa_is_bufferobj(ctx->Unpack.BufferObj)) { ctx->Driver.UnmapBuffer(ctx, GL_PIXEL_UNPACK_BUFFER_EXT, ctx->Unpack.BufferObj); } diff --git a/src/mesa/main/dd.h b/src/mesa/main/dd.h index 32b1d4e9fa..4a700b5cb4 100644 --- a/src/mesa/main/dd.h +++ b/src/mesa/main/dd.h @@ -766,6 +766,8 @@ struct dd_function_table { /** Return the value or values of a selected parameter */ GLboolean (*GetIntegerv)(GLcontext *ctx, GLenum pname, GLint *result); /** Return the value or values of a selected parameter */ + GLboolean (*GetInteger64v)(GLcontext *ctx, GLenum pname, GLint64 *result); + /** Return the value or values of a selected parameter */ GLboolean (*GetPointerv)(GLcontext *ctx, GLenum pname, GLvoid **result); /*@}*/ @@ -783,9 +785,9 @@ struct dd_function_table { void (*DeleteBuffer)( GLcontext *ctx, struct gl_buffer_object *obj ); - void (*BufferData)( GLcontext *ctx, GLenum target, GLsizeiptrARB size, - const GLvoid *data, GLenum usage, - struct gl_buffer_object *obj ); + GLboolean (*BufferData)( GLcontext *ctx, GLenum target, GLsizeiptrARB size, + const GLvoid *data, GLenum usage, + struct gl_buffer_object *obj ); void (*BufferSubData)( GLcontext *ctx, GLenum target, GLintptrARB offset, GLsizeiptrARB size, const GLvoid *data, @@ -798,6 +800,12 @@ struct dd_function_table { void * (*MapBuffer)( GLcontext *ctx, GLenum target, GLenum access, struct gl_buffer_object *obj ); + void (*CopyBufferSubData)( GLcontext *ctx, + struct gl_buffer_object *src, + struct gl_buffer_object *dst, + GLintptr readOffset, GLintptr writeOffset, + GLsizeiptr size ); + /* May return NULL if MESA_MAP_NOWAIT_BIT is set in access: */ void * (*MapBufferRange)( GLcontext *ctx, GLenum target, @@ -1036,6 +1044,22 @@ struct dd_function_table { */ void (*EndCallList)( GLcontext *ctx ); + +#if FEATURE_ARB_sync + /** + * \name GL_ARB_sync interfaces + */ + /*@{*/ + struct gl_sync_object * (*NewSyncObject)(GLcontext *, GLenum); + void (*FenceSync)(GLcontext *, struct gl_sync_object *, GLenum, GLbitfield); + void (*DeleteSyncObject)(GLcontext *, struct gl_sync_object *); + void (*CheckSync)(GLcontext *, struct gl_sync_object *); + void (*ClientWaitSync)(GLcontext *, struct gl_sync_object *, + GLbitfield, GLuint64); + void (*ServerWaitSync)(GLcontext *, struct gl_sync_object *, + GLbitfield, GLuint64); + /*@}*/ +#endif }; @@ -1144,7 +1168,11 @@ typedef struct { void (GLAPIENTRYP DrawRangeElements)( GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid *indices ); - /*@}*/ + void (GLAPIENTRYP MultiDrawElementsEXT)( GLenum mode, const GLsizei *count, + GLenum type, + const GLvoid **indices, + GLsizei primcount); + /*@}*/ /** * \name Eval diff --git a/src/mesa/main/debug.c b/src/mesa/main/debug.c index b54e47919d..8492c8561d 100644 --- a/src/mesa/main/debug.c +++ b/src/mesa/main/debug.c @@ -24,12 +24,16 @@ */ #include "mtypes.h" +#include "attrib.h" #include "colormac.h" #include "context.h" #include "hash.h" #include "imports.h" #include "debug.h" #include "get.h" +#include "pixelstore.h" +#include "readpix.h" +#include "texgetimage.h" #include "texobj.h" #include "texformat.h" @@ -231,11 +235,11 @@ _mesa_init_debug( GLcontext *ctx ) */ static void write_ppm(const char *filename, const GLubyte *buffer, int width, int height, - int comps, int rcomp, int gcomp, int bcomp) + int comps, int rcomp, int gcomp, int bcomp, GLboolean invert) { FILE *f = fopen( filename, "w" ); if (f) { - int i, x, y; + int x, y; const GLubyte *ptr = buffer; fprintf(f,"P6\n"); fprintf(f,"# ppm-file created by osdemo.c\n"); @@ -243,10 +247,11 @@ write_ppm(const char *filename, const GLubyte *buffer, int width, int height, fprintf(f,"255\n"); fclose(f); f = fopen( filename, "ab" ); /* reopen in binary append mode */ - for (y=height-1; y>=0; y--) { - for (x=0; x<width; x++) { - i = (y*width + x) * comps; - fputc(ptr[i+rcomp], f); /* write red */ + for (y=0; y < height; y++) { + for (x = 0; x < width; x++) { + int yy = invert ? (height - 1 - y) : y; + int i = (yy * width + x) * comps; + fputc(ptr[i+rcomp], f); /* write red */ fputc(ptr[i+gcomp], f); /* write green */ fputc(ptr[i+bcomp], f); /* write blue */ } @@ -260,47 +265,34 @@ write_ppm(const char *filename, const GLubyte *buffer, int width, int height, * Write level[0] image to a ppm file. */ static void -write_texture_image(struct gl_texture_object *texObj) +write_texture_image(struct gl_texture_object *texObj, GLuint face, GLuint level) { - const struct gl_texture_image *img = texObj->Image[0][0]; - if (img && img->Data) { + struct gl_texture_image *img = texObj->Image[face][level]; + if (img) { + GET_CURRENT_CONTEXT(ctx); + struct gl_pixelstore_attrib store; + GLubyte *buffer; char s[100]; + buffer = (GLubyte *) _mesa_malloc(img->Width * img->Height + * img->Depth * 4); + + store = ctx->Pack; /* save */ + ctx->Pack = ctx->DefaultPacking; + + ctx->Driver.GetTexImage(ctx, texObj->Target, level, + GL_RGBA, GL_UNSIGNED_BYTE, + buffer, texObj, img); + /* make filename */ - sprintf(s, "/tmp/teximage%u.ppm", texObj->Name); - - switch (img->TexFormat->MesaFormat) { - case MESA_FORMAT_RGBA8888: - write_ppm(s, img->Data, img->Width, img->Height, 4, 3, 2, 1); - break; - 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); - GLuint 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__); - } + _mesa_sprintf(s, "/tmp/teximage%u.ppm", texObj->Name); + + _mesa_printf(" Writing image level %u to %s\n", level, s); + write_ppm(s, buffer, img->Width, img->Height, 4, 0, 1, 2, GL_FALSE); + + ctx->Pack = store; /* restore */ + + _mesa_free(buffer); } } @@ -313,17 +305,21 @@ dump_texture_cb(GLuint id, void *data, void *userData) { struct gl_texture_object *texObj = (struct gl_texture_object *) data; int i; + GLboolean written = GL_FALSE; (void) userData; - printf("Texture %u\n", texObj->Name); - printf(" Target 0x%x\n", texObj->Target); + _mesa_printf("Texture %u\n", texObj->Name); + _mesa_printf(" Target 0x%x\n", texObj->Target); for (i = 0; i < MAX_TEXTURE_LEVELS; i++) { struct gl_texture_image *texImg = texObj->Image[0][i]; if (texImg) { - printf(" Image %u: %d x %d x %d at %p\n", i, - texImg->Width, texImg->Height, texImg->Depth, texImg->Data); - if (DumpImages && i == 0) { - write_texture_image(texObj); + _mesa_printf(" Image %u: %d x %d x %d, format %u at %p\n", i, + texImg->Width, texImg->Height, texImg->Depth, + texImg->TexFormat->MesaFormat, texImg->Data); + if (DumpImages && !written) { + GLuint face = 0; + write_texture_image(texObj, face, i); + written = GL_TRUE; } } } @@ -341,3 +337,104 @@ _mesa_dump_textures(GLboolean dumpImages) DumpImages = dumpImages; _mesa_HashWalk(ctx->Shared->TexObjects, dump_texture_cb, ctx); } + + +void +_mesa_dump_color_buffer(const char *filename) +{ + GET_CURRENT_CONTEXT(ctx); + const GLuint w = ctx->DrawBuffer->Width; + const GLuint h = ctx->DrawBuffer->Height; + GLubyte *buf; + + buf = (GLubyte *) _mesa_malloc(w * h * 4); + + _mesa_PushClientAttrib(GL_CLIENT_PIXEL_STORE_BIT); + _mesa_PixelStorei(GL_PACK_ALIGNMENT, 1); + _mesa_PixelStorei(GL_PACK_INVERT_MESA, GL_TRUE); + + _mesa_ReadPixels(0, 0, w, h, GL_RGBA, GL_UNSIGNED_BYTE, buf); + + _mesa_printf("ReadBuffer %p 0x%x DrawBuffer %p 0x%x\n", + ctx->ReadBuffer->_ColorReadBuffer, + ctx->ReadBuffer->ColorReadBuffer, + ctx->DrawBuffer->_ColorDrawBuffers[0], + ctx->DrawBuffer->ColorDrawBuffer[0]); + _mesa_printf("Writing %d x %d color buffer to %s\n", w, h, filename); + write_ppm(filename, buf, w, h, 4, 0, 1, 2, GL_TRUE); + + _mesa_PopClientAttrib(); + + _mesa_free(buf); +} + + +void +_mesa_dump_depth_buffer(const char *filename) +{ + GET_CURRENT_CONTEXT(ctx); + const GLuint w = ctx->DrawBuffer->Width; + const GLuint h = ctx->DrawBuffer->Height; + GLuint *buf; + GLubyte *buf2; + GLuint i; + + buf = (GLuint *) _mesa_malloc(w * h * 4); /* 4 bpp */ + buf2 = (GLubyte *) _mesa_malloc(w * h * 3); /* 3 bpp */ + + _mesa_PushClientAttrib(GL_CLIENT_PIXEL_STORE_BIT); + _mesa_PixelStorei(GL_PACK_ALIGNMENT, 1); + _mesa_PixelStorei(GL_PACK_INVERT_MESA, GL_TRUE); + + _mesa_ReadPixels(0, 0, w, h, GL_DEPTH_COMPONENT, GL_UNSIGNED_INT, buf); + + /* spread 24 bits of Z across R, G, B */ + for (i = 0; i < w * h; i++) { + buf2[i*3+0] = (buf[i] >> 24) & 0xff; + buf2[i*3+1] = (buf[i] >> 16) & 0xff; + buf2[i*3+2] = (buf[i] >> 8) & 0xff; + } + + _mesa_printf("Writing %d x %d depth buffer to %s\n", w, h, filename); + write_ppm(filename, buf2, w, h, 3, 0, 1, 2, GL_TRUE); + + _mesa_PopClientAttrib(); + + _mesa_free(buf); + _mesa_free(buf2); +} + + +void +_mesa_dump_stencil_buffer(const char *filename) +{ + GET_CURRENT_CONTEXT(ctx); + const GLuint w = ctx->DrawBuffer->Width; + const GLuint h = ctx->DrawBuffer->Height; + GLubyte *buf; + GLubyte *buf2; + GLuint i; + + buf = (GLubyte *) _mesa_malloc(w * h); /* 1 bpp */ + buf2 = (GLubyte *) _mesa_malloc(w * h * 3); /* 3 bpp */ + + _mesa_PushClientAttrib(GL_CLIENT_PIXEL_STORE_BIT); + _mesa_PixelStorei(GL_PACK_ALIGNMENT, 1); + _mesa_PixelStorei(GL_PACK_INVERT_MESA, GL_TRUE); + + _mesa_ReadPixels(0, 0, w, h, GL_STENCIL_INDEX, GL_UNSIGNED_BYTE, buf); + + for (i = 0; i < w * h; i++) { + buf2[i*3+0] = buf[i]; + buf2[i*3+1] = (buf[i] & 127) * 2; + buf2[i*3+2] = (buf[i] - 128) * 2; + } + + _mesa_printf("Writing %d x %d stencil buffer to %s\n", w, h, filename); + write_ppm(filename, buf2, w, h, 3, 0, 1, 2, GL_TRUE); + + _mesa_PopClientAttrib(); + + _mesa_free(buf); + _mesa_free(buf2); +} diff --git a/src/mesa/main/debug.h b/src/mesa/main/debug.h index 1862ec75b7..bb384c4324 100644 --- a/src/mesa/main/debug.h +++ b/src/mesa/main/debug.h @@ -60,4 +60,13 @@ extern void _mesa_init_debug( GLcontext *ctx ); extern void _mesa_dump_textures(GLboolean dumpImages); +extern void +_mesa_dump_color_buffer(const char *filename); + +extern void +_mesa_dump_depth_buffer(const char *filename); + +extern void +_mesa_dump_stencil_buffer(const char *filename); + #endif diff --git a/src/mesa/main/dlist.c b/src/mesa/main/dlist.c index 2f76ed0276..b53c1733fb 100644 --- a/src/mesa/main/dlist.c +++ b/src/mesa/main/dlist.c @@ -380,6 +380,9 @@ typedef enum OPCODE_EVAL_P1, OPCODE_EVAL_P2, + /* GL_EXT_provoking_vertex */ + OPCODE_PROVOKING_VERTEX, + /* The following three are meta instructions */ OPCODE_ERROR, /* raise compiled-in error */ OPCODE_CONTINUE, @@ -740,7 +743,7 @@ unpack_image(GLcontext *ctx, GLuint dimensions, GLenum format, GLenum type, const GLvoid * pixels, const struct gl_pixelstore_attrib *unpack) { - if (unpack->BufferObj->Name == 0) { + if (!_mesa_is_bufferobj(unpack->BufferObj)) { /* no PBO */ GLvoid *image = _mesa_unpack_image(dimensions, width, height, depth, format, type, pixels, unpack); @@ -4989,7 +4992,7 @@ save_Attr1fNV(GLenum attr, GLfloat x) n[2].f = x; } - ASSERT(attr < MAX_VERTEX_PROGRAM_ATTRIBS); + ASSERT(attr < MAX_VERTEX_GENERIC_ATTRIBS); ctx->ListState.ActiveAttribSize[attr] = 1; ASSIGN_4V(ctx->ListState.CurrentAttrib[attr], x, 0, 0, 1); @@ -5011,7 +5014,7 @@ save_Attr2fNV(GLenum attr, GLfloat x, GLfloat y) n[3].f = y; } - ASSERT(attr < MAX_VERTEX_PROGRAM_ATTRIBS); + ASSERT(attr < MAX_VERTEX_GENERIC_ATTRIBS); ctx->ListState.ActiveAttribSize[attr] = 2; ASSIGN_4V(ctx->ListState.CurrentAttrib[attr], x, y, 0, 1); @@ -5034,7 +5037,7 @@ save_Attr3fNV(GLenum attr, GLfloat x, GLfloat y, GLfloat z) n[4].f = z; } - ASSERT(attr < MAX_VERTEX_PROGRAM_ATTRIBS); + ASSERT(attr < MAX_VERTEX_GENERIC_ATTRIBS); ctx->ListState.ActiveAttribSize[attr] = 3; ASSIGN_4V(ctx->ListState.CurrentAttrib[attr], x, y, z, 1); @@ -5058,7 +5061,7 @@ save_Attr4fNV(GLenum attr, GLfloat x, GLfloat y, GLfloat z, GLfloat w) n[5].f = w; } - ASSERT(attr < MAX_VERTEX_PROGRAM_ATTRIBS); + ASSERT(attr < MAX_VERTEX_GENERIC_ATTRIBS); ctx->ListState.ActiveAttribSize[attr] = 4; ASSIGN_4V(ctx->ListState.CurrentAttrib[attr], x, y, z, w); @@ -5835,6 +5838,24 @@ save_BlitFramebufferEXT(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, #endif +/** GL_EXT_provoking_vertex */ +static void GLAPIENTRY +save_ProvokingVertexEXT(GLenum mode) +{ + GET_CURRENT_CONTEXT(ctx); + Node *n; + ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx); + n = ALLOC_INSTRUCTION(ctx, OPCODE_PROVOKING_VERTEX, 1); + if (n) { + n[1].e = mode; + } + if (ctx->ExecuteFlag) { + /*CALL_ProvokingVertexEXT(ctx->Exec, (mode));*/ + _mesa_ProvokingVertexEXT(mode); + } +} + + /* aka UseProgram() */ static void GLAPIENTRY save_UseProgramObjectARB(GLhandleARB program) @@ -6887,6 +6908,9 @@ execute_list(GLcontext *ctx, GLuint list) case OPCODE_SHADE_MODEL: CALL_ShadeModel(ctx->Exec, (n[1].e)); break; + case OPCODE_PROVOKING_VERTEX: + CALL_ProvokingVertexEXT(ctx->Exec, (n[1].e)); + break; case OPCODE_STENCIL_FUNC: CALL_StencilFunc(ctx->Exec, (n[1].e, n[2].i, n[3].ui)); break; @@ -8358,18 +8382,6 @@ exec_MultiDrawArraysEXT(GLenum mode, GLint * first, CALL_MultiDrawArraysEXT(ctx->Exec, (mode, first, count, primcount)); } -/* GL_EXT_multi_draw_arrays */ -static void GLAPIENTRY -exec_MultiDrawElementsEXT(GLenum mode, const GLsizei * count, - GLenum type, const GLvoid ** indices, - GLsizei primcount) -{ - GET_CURRENT_CONTEXT(ctx); - FLUSH_VERTICES(ctx, 0); - CALL_MultiDrawElementsEXT(ctx->Exec, - (mode, count, type, indices, primcount)); -} - /* GL_IBM_multimode_draw_arrays */ static void GLAPIENTRY exec_MultiModeDrawArraysIBM(const GLenum * mode, const GLint * first, @@ -8715,7 +8727,6 @@ _mesa_init_dlist_table(struct _glapi_table *table) /* 148. GL_EXT_multi_draw_arrays */ SET_MultiDrawArraysEXT(table, exec_MultiDrawArraysEXT); - SET_MultiDrawElementsEXT(table, exec_MultiDrawElementsEXT); /* 149. GL_EXT_fog_coord */ SET_FogCoordPointerEXT(table, exec_FogCoordPointerEXT); @@ -8970,6 +8981,18 @@ _mesa_init_dlist_table(struct _glapi_table *table) SET_ProgramEnvParameters4fvEXT(table, save_ProgramEnvParameters4fvEXT); SET_ProgramLocalParameters4fvEXT(table, save_ProgramLocalParameters4fvEXT); #endif + + /* ARB 50. GL_ARB_map_buffer_range */ +#if FEATURE_ARB_map_buffer_range + SET_MapBufferRange(table, _mesa_MapBufferRange); /* no dlist save */ + SET_FlushMappedBufferRange(table, _mesa_FlushMappedBufferRange); /* no dl */ +#endif + + /* ARB 59. GL_ARB_copy_buffer */ + SET_CopyBufferSubData(table, _mesa_CopyBufferSubData); /* no dlist save */ + + /* 364. GL_EXT_provoking_vertex */ + SET_ProvokingVertexEXT(table, save_ProvokingVertexEXT); } @@ -9206,6 +9229,11 @@ print_list(GLcontext *ctx, GLuint list) _mesa_printf("EVAL_P2 %d %d\n", n[1].i, n[2].i); break; + case OPCODE_PROVOKING_VERTEX: + _mesa_printf("ProvokingVertex %s\n", + _mesa_lookup_enum_by_nr(n[1].ui)); + break; + /* * meta opcodes/commands */ @@ -9341,6 +9369,7 @@ _mesa_save_vtxfmt_init(GLvertexformat * vfmt) vfmt->DrawArrays = 0; vfmt->DrawElements = 0; vfmt->DrawRangeElements = 0; + vfmt->MultiDrawElemementsEXT = 0; #endif } diff --git a/src/mesa/main/drawpix.c b/src/mesa/main/drawpix.c index 6682b5e725..aef6585641 100644 --- a/src/mesa/main/drawpix.c +++ b/src/mesa/main/drawpix.c @@ -27,6 +27,7 @@ #include "bufferobj.h" #include "context.h" #include "drawpix.h" +#include "enums.h" #include "feedback.h" #include "framebuffer.h" #include "image.h" @@ -34,6 +35,18 @@ #include "state.h" + +/** + * If a fragment program is enabled, check that it's valid. + * \return GL_TRUE if valid, GL_FALSE otherwise + */ +static GLboolean +valid_fragment_program(GLcontext *ctx) +{ + return !(ctx->FragmentProgram.Enabled && !ctx->FragmentProgram._Enabled); +} + + #if _HAVE_FULL_GL /* @@ -51,29 +64,34 @@ _mesa_DrawPixels( GLsizei width, GLsizei height, return; } + /* We're not using the current vertex program, and the driver may install + * it's own. + */ + _mesa_set_vp_override(ctx, GL_TRUE); + if (ctx->NewState) { _mesa_update_state(ctx); } - if (ctx->FragmentProgram.Enabled && !ctx->FragmentProgram._Enabled) { + if (!valid_fragment_program(ctx)) { _mesa_error(ctx, GL_INVALID_OPERATION, "glDrawPixels (invalid fragment program)"); - return; + goto end; } if (_mesa_error_check_format_type(ctx, format, type, GL_TRUE)) { - /* found an error */ - return; + /* the error was already recorded */ + goto end; } if (ctx->DrawBuffer->_Status != GL_FRAMEBUFFER_COMPLETE_EXT) { _mesa_error(ctx, GL_INVALID_FRAMEBUFFER_OPERATION_EXT, "glDrawPixels(incomplete framebuffer)" ); - return; + goto end; } if (!ctx->Current.RasterPosValid) { - return; + goto end; /* no-op, not an error */ } if (ctx->RenderMode == GL_RENDER) { @@ -88,13 +106,13 @@ _mesa_DrawPixels( GLsizei width, GLsizei height, format, type, pixels)) { _mesa_error(ctx, GL_INVALID_OPERATION, "glDrawPixels(invalid PBO access)"); - return; + goto end; } - if (ctx->Unpack.BufferObj->Pointer) { + if (_mesa_bufferobj_mapped(ctx->Unpack.BufferObj)) { /* buffer is mapped - that's an error */ _mesa_error(ctx, GL_INVALID_OPERATION, "glDrawPixels(PBO is mapped)"); - return; + goto end; } } @@ -116,6 +134,9 @@ _mesa_DrawPixels( GLsizei width, GLsizei height, ASSERT(ctx->RenderMode == GL_SELECT); /* Do nothing. See OpenGL Spec, Appendix B, Corollary 6. */ } + +end: + _mesa_set_vp_override(ctx, GL_FALSE); } @@ -126,37 +147,55 @@ _mesa_CopyPixels( GLint srcx, GLint srcy, GLsizei width, GLsizei height, GET_CURRENT_CONTEXT(ctx); ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx); + if (width < 0 || height < 0) { + _mesa_error(ctx, GL_INVALID_VALUE, "glCopyPixels(width or height < 0)"); + return; + } + + /* Note: more detailed 'type' checking is done by the + * _mesa_source/dest_buffer_exists() calls below. That's where we + * check if the stencil buffer exists, etc. + */ + if (type != GL_COLOR && + type != GL_DEPTH && + type != GL_STENCIL && + type != GL_DEPTH_STENCIL) { + _mesa_error(ctx, GL_INVALID_ENUM, "glCopyPixels(type=%s)", + _mesa_lookup_enum_by_nr(type)); + return; + } + + /* We're not using the current vertex program, and the driver may install + * it's own. + */ + _mesa_set_vp_override(ctx, GL_TRUE); + if (ctx->NewState) { _mesa_update_state(ctx); } - if (ctx->FragmentProgram.Enabled && !ctx->FragmentProgram._Enabled) { + if (!valid_fragment_program(ctx)) { _mesa_error(ctx, GL_INVALID_OPERATION, "glCopyPixels (invalid fragment program)"); - return; - } - - if (width < 0 || height < 0) { - _mesa_error(ctx, GL_INVALID_VALUE, "glCopyPixels(width or height < 0)"); - return; + goto end; } if (ctx->DrawBuffer->_Status != GL_FRAMEBUFFER_COMPLETE_EXT || ctx->ReadBuffer->_Status != GL_FRAMEBUFFER_COMPLETE_EXT) { _mesa_error(ctx, GL_INVALID_FRAMEBUFFER_OPERATION_EXT, "glCopyPixels(incomplete framebuffer)" ); - return; + goto end; } if (!_mesa_source_buffer_exists(ctx, type) || !_mesa_dest_buffer_exists(ctx, type)) { _mesa_error(ctx, GL_INVALID_OPERATION, "glCopyPixels(missing source or dest buffer)"); - return; + goto end; } if (!ctx->Current.RasterPosValid || width ==0 || height == 0) { - return; + goto end; /* no-op, not an error */ } if (ctx->RenderMode == GL_RENDER) { @@ -181,6 +220,9 @@ _mesa_CopyPixels( GLint srcx, GLint srcy, GLsizei width, GLsizei height, ASSERT(ctx->RenderMode == GL_SELECT); /* Do nothing. See OpenGL Spec, Appendix B, Corollary 6. */ } + +end: + _mesa_set_vp_override(ctx, GL_FALSE); } #endif /* _HAVE_FULL_GL */ @@ -208,7 +250,7 @@ _mesa_Bitmap( GLsizei width, GLsizei height, _mesa_update_state(ctx); } - if (ctx->FragmentProgram.Enabled && !ctx->FragmentProgram._Enabled) { + if (!valid_fragment_program(ctx)) { _mesa_error(ctx, GL_INVALID_OPERATION, "glBitmap (invalid fragment program)"); return; @@ -222,27 +264,30 @@ _mesa_Bitmap( GLsizei width, GLsizei height, if (ctx->RenderMode == GL_RENDER) { /* Truncate, to satisfy conformance tests (matches SGI's OpenGL). */ - const GLfloat epsilon = 0.0001F; - GLint x = IFLOOR(ctx->Current.RasterPos[0] + epsilon - xorig); - GLint y = IFLOOR(ctx->Current.RasterPos[1] + epsilon - yorig); - - if (ctx->Unpack.BufferObj->Name) { - /* unpack from PBO */ - if (!_mesa_validate_pbo_access(2, &ctx->Unpack, width, height, 1, - GL_COLOR_INDEX, GL_BITMAP, - (GLvoid *) bitmap)) { - _mesa_error(ctx, GL_INVALID_OPERATION, - "glBitmap(invalid PBO access)"); - return; - } - if (ctx->Unpack.BufferObj->Pointer) { - /* buffer is mapped - that's an error */ - _mesa_error(ctx, GL_INVALID_OPERATION, "glBitmap(PBO is mapped)"); - return; + if (width > 0 && height > 0) { + const GLfloat epsilon = 0.0001F; + GLint x = IFLOOR(ctx->Current.RasterPos[0] + epsilon - xorig); + GLint y = IFLOOR(ctx->Current.RasterPos[1] + epsilon - yorig); + + if (ctx->Unpack.BufferObj->Name) { + /* unpack from PBO */ + if (!_mesa_validate_pbo_access(2, &ctx->Unpack, width, height, 1, + GL_COLOR_INDEX, GL_BITMAP, + (GLvoid *) bitmap)) { + _mesa_error(ctx, GL_INVALID_OPERATION, + "glBitmap(invalid PBO access)"); + return; + } + if (_mesa_bufferobj_mapped(ctx->Unpack.BufferObj)) { + /* buffer is mapped - that's an error */ + _mesa_error(ctx, GL_INVALID_OPERATION, + "glBitmap(PBO is mapped)"); + return; + } } - } - ctx->Driver.Bitmap( ctx, x, y, width, height, &ctx->Unpack, bitmap ); + ctx->Driver.Bitmap( ctx, x, y, width, height, &ctx->Unpack, bitmap ); + } } #if _HAVE_FULL_GL else if (ctx->RenderMode == GL_FEEDBACK) { @@ -264,68 +309,3 @@ _mesa_Bitmap( GLsizei width, GLsizei height, ctx->Current.RasterPos[0] += xmove; ctx->Current.RasterPos[1] += ymove; } - - - -#if 0 /* experimental */ -/* - * Execute glDrawDepthPixelsMESA(). This function accepts both a color - * image and depth (Z) image. Rasterization produces fragments with - * color and Z taken from these images. This function is intended for - * Z-compositing. Normally, this operation requires two glDrawPixels - * calls with stencil testing. - */ -void GLAPIENTRY -_mesa_DrawDepthPixelsMESA( GLsizei width, GLsizei height, - GLenum colorFormat, GLenum colorType, - const GLvoid *colors, - GLenum depthType, const GLvoid *depths ) -{ - GET_CURRENT_CONTEXT(ctx); - ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx); - - if (width < 0 || height < 0) { - _mesa_error( ctx, GL_INVALID_VALUE, - "glDrawDepthPixelsMESA(width or height < 0" ); - return; - } - - if (!ctx->Current.RasterPosValid) { - return; - } - - if (ctx->NewState) { - _mesa_update_state(ctx); - } - - if (ctx->DrawBuffer->_Status != GL_FRAMEBUFFER_COMPLETE_EXT) { - _mesa_error(ctx, GL_INVALID_FRAMEBUFFER_OPERATION_EXT, - "glDrawDepthPixelsMESA(incomplete framebuffer)"); - return; - } - - if (ctx->RenderMode == GL_RENDER) { - /* Round, to satisfy conformance tests (matches SGI's OpenGL) */ - GLint x = IROUND(ctx->Current.RasterPos[0]); - GLint y = IROUND(ctx->Current.RasterPos[1]); - ctx->Driver.DrawDepthPixelsMESA(ctx, x, y, width, height, - colorFormat, colorType, colors, - depthType, depths, &ctx->Unpack); - } - else if (ctx->RenderMode == GL_FEEDBACK) { - /* Feedback the current raster pos info */ - FLUSH_CURRENT( ctx, 0 ); - _mesa_feedback_token( ctx, (GLfloat) (GLint) GL_DRAW_PIXEL_TOKEN ); - _mesa_feedback_vertex( ctx, - ctx->Current.RasterPos, - ctx->Current.RasterColor, - ctx->Current.RasterIndex, - ctx->Current.RasterTexCoords[0] ); - } - else { - ASSERT(ctx->RenderMode == GL_SELECT); - /* Do nothing. See OpenGL Spec, Appendix B, Corollary 6. */ - } -} - -#endif diff --git a/src/mesa/main/enable.c b/src/mesa/main/enable.c index f432be183c..4bc54771e9 100644 --- a/src/mesa/main/enable.c +++ b/src/mesa/main/enable.c @@ -119,6 +119,7 @@ client_state(GLcontext *ctx, GLenum cap, GLboolean state) CHECK_EXTENSION(NV_vertex_program, cap); { GLint n = (GLint) cap - GL_VERTEX_ATTRIB_ARRAY0_NV; + ASSERT(n < Elements(ctx->Array.ArrayObj->VertexAttrib)); var = &ctx->Array.ArrayObj->VertexAttrib[n].Enabled; flag = _NEW_ARRAY_ATTRIB(n); } @@ -222,14 +223,16 @@ get_texcoord_unit(GLcontext *ctx) /** * Helper function to enable or disable a texture target. + * \param bit one of the TEXTURE_x_BIT values + * \return GL_TRUE if state is changing or GL_FALSE if no change */ static GLboolean -enable_texture(GLcontext *ctx, GLboolean state, GLbitfield bit) +enable_texture(GLcontext *ctx, GLboolean state, GLbitfield texBit) { const GLuint curr = ctx->Texture.CurrentUnit; struct gl_texture_unit *texUnit = &ctx->Texture.Unit[curr]; - const GLuint newenabled = (!state) - ? (texUnit->Enabled & ~bit) : (texUnit->Enabled | bit); + const GLbitfield newenabled = state + ? (texUnit->Enabled | texBit) : (texUnit->Enabled & ~texBit); if (!ctx->DrawBuffer->Visual.rgbMode || texUnit->Enabled == newenabled) return GL_FALSE; @@ -969,6 +972,11 @@ _mesa_set_enable(GLcontext *ctx, GLenum cap, GLboolean state) } break; + case GL_TEXTURE_CUBE_MAP_SEAMLESS: + CHECK_EXTENSION(ARB_seamless_cube_map, cap); + ctx->Texture.CubeMapSeamless = state; + break; + default: _mesa_error(ctx, GL_INVALID_ENUM, "%s(0x%x)", state ? "glEnable" : "glDisable", cap); @@ -1314,6 +1322,7 @@ _mesa_IsEnabled( GLenum cap ) CHECK_EXTENSION(NV_vertex_program); { GLint n = (GLint) cap - GL_VERTEX_ATTRIB_ARRAY0_NV; + ASSERT(n < Elements(ctx->Array.ArrayObj->VertexAttrib)); return (ctx->Array.ArrayObj->VertexAttrib[n].Enabled != 0); } case GL_MAP1_VERTEX_ATTRIB0_4_NV: @@ -1391,6 +1400,11 @@ _mesa_IsEnabled( GLenum cap ) CHECK_EXTENSION(ATI_fragment_shader); return ctx->ATIFragmentShader.Enabled; #endif /* FEATURE_ATI_fragment_shader */ + + case GL_TEXTURE_CUBE_MAP_SEAMLESS: + CHECK_EXTENSION(ARB_seamless_cube_map); + return ctx->Texture.CubeMapSeamless; + default: _mesa_error(ctx, GL_INVALID_ENUM, "glIsEnabled(0x%x)", (int) cap); return GL_FALSE; diff --git a/src/mesa/main/enums.c b/src/mesa/main/enums.c index dff5544086..9f650dadd3 100644 --- a/src/mesa/main/enums.c +++ b/src/mesa/main/enums.c @@ -82,6 +82,7 @@ LONGSTRING static const char enum_string_table[] = "GL_ALPHA_TEST\0" "GL_ALPHA_TEST_FUNC\0" "GL_ALPHA_TEST_REF\0" + "GL_ALREADY_SIGNALED\0" "GL_ALWAYS\0" "GL_AMBIENT\0" "GL_AMBIENT_AND_DIFFUSE\0" @@ -139,10 +140,12 @@ LONGSTRING static const char enum_string_table[] = "GL_BOOL_VEC4_ARB\0" "GL_BUFFER_ACCESS\0" "GL_BUFFER_ACCESS_ARB\0" + "GL_BUFFER_FLUSHING_UNMAP_APPLE\0" "GL_BUFFER_MAPPED\0" "GL_BUFFER_MAPPED_ARB\0" "GL_BUFFER_MAP_POINTER\0" "GL_BUFFER_MAP_POINTER_ARB\0" + "GL_BUFFER_SERIALIZED_MODIFY_APPLE\0" "GL_BUFFER_SIZE\0" "GL_BUFFER_SIZE_ARB\0" "GL_BUFFER_USAGE\0" @@ -303,6 +306,7 @@ LONGSTRING static const char enum_string_table[] = "GL_COMPRESSED_SRGB\0" "GL_COMPRESSED_SRGB_ALPHA\0" "GL_COMPRESSED_TEXTURE_FORMATS\0" + "GL_CONDITION_SATISFIED\0" "GL_CONSTANT\0" "GL_CONSTANT_ALPHA\0" "GL_CONSTANT_ALPHA_EXT\0" @@ -334,6 +338,8 @@ LONGSTRING static const char enum_string_table[] = "GL_COPY\0" "GL_COPY_INVERTED\0" "GL_COPY_PIXEL_TOKEN\0" + "GL_COPY_READ_BUFFER\0" + "GL_COPY_WRITE_BUFFER\0" "GL_CULL_FACE\0" "GL_CULL_FACE_MODE\0" "GL_CULL_VERTEX_EXT\0" @@ -512,6 +518,7 @@ LONGSTRING static const char enum_string_table[] = "GL_FEEDBACK_BUFFER_SIZE\0" "GL_FEEDBACK_BUFFER_TYPE\0" "GL_FILL\0" + "GL_FIRST_VERTEX_CONVENTION_EXT\0" "GL_FLAT\0" "GL_FLOAT\0" "GL_FLOAT_MAT2\0" @@ -694,6 +701,7 @@ LONGSTRING static const char enum_string_table[] = "GL_INVERSE_TRANSPOSE_NV\0" "GL_INVERT\0" "GL_KEEP\0" + "GL_LAST_VERTEX_CONVENTION_EXT\0" "GL_LEFT\0" "GL_LEQUAL\0" "GL_LESS\0" @@ -819,7 +827,13 @@ LONGSTRING static const char enum_string_table[] = "GL_MAP2_VERTEX_ATTRIB8_4_NV\0" "GL_MAP2_VERTEX_ATTRIB9_4_NV\0" "GL_MAP_COLOR\0" + "GL_MAP_FLUSH_EXPLICIT_BIT\0" + "GL_MAP_INVALIDATE_BUFFER_BIT\0" + "GL_MAP_INVALIDATE_RANGE_BIT\0" + "GL_MAP_READ_BIT\0" "GL_MAP_STENCIL\0" + "GL_MAP_UNSYNCHRONIZED_BIT\0" + "GL_MAP_WRITE_BIT\0" "GL_MATRIX0_ARB\0" "GL_MATRIX0_NV\0" "GL_MATRIX10_ARB\0" @@ -932,6 +946,7 @@ LONGSTRING static const char enum_string_table[] = "GL_MAX_RECTANGLE_TEXTURE_SIZE_NV\0" "GL_MAX_RENDERBUFFER_SIZE_EXT\0" "GL_MAX_SAMPLES\0" + "GL_MAX_SERVER_WAIT_TIMEOUT\0" "GL_MAX_SHININESS_NV\0" "GL_MAX_SPOT_EXPONENT_NV\0" "GL_MAX_TEXTURE_COORDS\0" @@ -1060,6 +1075,7 @@ LONGSTRING static const char enum_string_table[] = "GL_OBJECT_PLANE\0" "GL_OBJECT_SHADER_SOURCE_LENGTH_ARB\0" "GL_OBJECT_SUBTYPE_ARB\0" + "GL_OBJECT_TYPE\0" "GL_OBJECT_TYPE_ARB\0" "GL_OBJECT_VALIDATE_STATUS_ARB\0" "GL_OCCLUSION_TEST_HP\0" @@ -1271,6 +1287,7 @@ LONGSTRING static const char enum_string_table[] = "GL_PROJECTION\0" "GL_PROJECTION_MATRIX\0" "GL_PROJECTION_STACK_DEPTH\0" + "GL_PROVOKING_VERTEX_EXT\0" "GL_PROXY_COLOR_TABLE\0" "GL_PROXY_HISTOGRAM\0" "GL_PROXY_HISTOGRAM_EXT\0" @@ -1291,6 +1308,7 @@ LONGSTRING static const char enum_string_table[] = "GL_Q\0" "GL_QUADRATIC_ATTENUATION\0" "GL_QUADS\0" + "GL_QUADS_FOLLOW_PROVOKING_VERTEX_CONVENTION_EXT\0" "GL_QUAD_MESH_SUN\0" "GL_QUAD_STRIP\0" "GL_QUERY_COUNTER_BITS\0" @@ -1438,6 +1456,7 @@ LONGSTRING static const char enum_string_table[] = "GL_SHARED_TEXTURE_PALETTE_EXT\0" "GL_SHININESS\0" "GL_SHORT\0" + "GL_SIGNALED\0" "GL_SIGNED_NORMALIZED\0" "GL_SINGLE_COLOR\0" "GL_SINGLE_COLOR_EXT\0" @@ -1530,6 +1549,9 @@ LONGSTRING static const char enum_string_table[] = "GL_STENCIL_VALUE_MASK\0" "GL_STENCIL_WRITEMASK\0" "GL_STEREO\0" + "GL_STORAGE_CACHED_APPLE\0" + "GL_STORAGE_PRIVATE_APPLE\0" + "GL_STORAGE_SHARED_APPLE\0" "GL_STREAM_COPY\0" "GL_STREAM_COPY_ARB\0" "GL_STREAM_DRAW\0" @@ -1539,6 +1561,12 @@ LONGSTRING static const char enum_string_table[] = "GL_SUBPIXEL_BITS\0" "GL_SUBTRACT\0" "GL_SUBTRACT_ARB\0" + "GL_SYNC_CONDITION\0" + "GL_SYNC_FENCE\0" + "GL_SYNC_FLAGS\0" + "GL_SYNC_FLUSH_COMMANDS_BIT\0" + "GL_SYNC_GPU_COMMANDS_COMPLETE\0" + "GL_SYNC_STATUS\0" "GL_T\0" "GL_T2F_C3F_V3F\0" "GL_T2F_C4F_N3F_V3F\0" @@ -1679,6 +1707,7 @@ LONGSTRING static const char enum_string_table[] = "GL_TEXTURE_CUBE_MAP_POSITIVE_Y_ARB\0" "GL_TEXTURE_CUBE_MAP_POSITIVE_Z\0" "GL_TEXTURE_CUBE_MAP_POSITIVE_Z_ARB\0" + "GL_TEXTURE_CUBE_MAP_SEAMLESS\0" "GL_TEXTURE_DEPTH\0" "GL_TEXTURE_DEPTH_SIZE\0" "GL_TEXTURE_DEPTH_SIZE_ARB\0" @@ -1718,6 +1747,8 @@ LONGSTRING static const char enum_string_table[] = "GL_TEXTURE_MIN_FILTER\0" "GL_TEXTURE_MIN_LOD\0" "GL_TEXTURE_PRIORITY\0" + "GL_TEXTURE_RANGE_LENGTH_APPLE\0" + "GL_TEXTURE_RANGE_POINTER_APPLE\0" "GL_TEXTURE_RECTANGLE_ARB\0" "GL_TEXTURE_RECTANGLE_NV\0" "GL_TEXTURE_RED_SIZE\0" @@ -1725,12 +1756,15 @@ LONGSTRING static const char enum_string_table[] = "GL_TEXTURE_RESIDENT\0" "GL_TEXTURE_STACK_DEPTH\0" "GL_TEXTURE_STENCIL_SIZE\0" + "GL_TEXTURE_STORAGE_HINT_APPLE\0" "GL_TEXTURE_TOO_LARGE_EXT\0" "GL_TEXTURE_UNSIGNED_REMAP_MODE_NV\0" "GL_TEXTURE_WIDTH\0" "GL_TEXTURE_WRAP_R\0" "GL_TEXTURE_WRAP_S\0" "GL_TEXTURE_WRAP_T\0" + "GL_TIMEOUT_EXPIRED\0" + "GL_TIMEOUT_IGNORED\0" "GL_TIME_ELAPSED_EXT\0" "GL_TRACK_MATRIX_NV\0" "GL_TRACK_MATRIX_TRANSFORM_NV\0" @@ -1758,6 +1792,7 @@ LONGSTRING static const char enum_string_table[] = "GL_UNPACK_SKIP_PIXELS\0" "GL_UNPACK_SKIP_ROWS\0" "GL_UNPACK_SWAP_BYTES\0" + "GL_UNSIGNALED\0" "GL_UNSIGNED_BYTE\0" "GL_UNSIGNED_BYTE_2_3_3_REV\0" "GL_UNSIGNED_BYTE_3_3_2\0" @@ -1787,6 +1822,7 @@ LONGSTRING static const char enum_string_table[] = "GL_VENDOR\0" "GL_VERSION\0" "GL_VERTEX_ARRAY\0" + "GL_VERTEX_ARRAY_BINDING\0" "GL_VERTEX_ARRAY_BINDING_APPLE\0" "GL_VERTEX_ARRAY_BUFFER_BINDING\0" "GL_VERTEX_ARRAY_BUFFER_BINDING_ARB\0" @@ -1839,6 +1875,7 @@ LONGSTRING static const char enum_string_table[] = "GL_VERTEX_STATE_PROGRAM_NV\0" "GL_VIEWPORT\0" "GL_VIEWPORT_BIT\0" + "GL_WAIT_FAILED\0" "GL_WEIGHT_ARRAY_ARB\0" "GL_WEIGHT_ARRAY_BUFFER_BINDING\0" "GL_WEIGHT_ARRAY_BUFFER_BINDING_ARB\0" @@ -1858,7 +1895,7 @@ LONGSTRING static const char enum_string_table[] = "GL_ZOOM_Y\0" ; -static const enum_elt all_enums[1820] = +static const enum_elt all_enums[1857] = { { 0, 0x00000600 }, /* GL_2D */ { 6, 0x00001407 }, /* GL_2_BYTES */ @@ -1906,3103 +1943,3168 @@ static const enum_elt all_enums[1820] = { 728, 0x00000BC0 }, /* GL_ALPHA_TEST */ { 742, 0x00000BC1 }, /* GL_ALPHA_TEST_FUNC */ { 761, 0x00000BC2 }, /* GL_ALPHA_TEST_REF */ - { 779, 0x00000207 }, /* GL_ALWAYS */ - { 789, 0x00001200 }, /* GL_AMBIENT */ - { 800, 0x00001602 }, /* GL_AMBIENT_AND_DIFFUSE */ - { 823, 0x00001501 }, /* GL_AND */ - { 830, 0x00001504 }, /* GL_AND_INVERTED */ - { 846, 0x00001502 }, /* GL_AND_REVERSE */ - { 861, 0x00008892 }, /* GL_ARRAY_BUFFER */ - { 877, 0x00008894 }, /* GL_ARRAY_BUFFER_BINDING */ - { 901, 0x00008894 }, /* GL_ARRAY_BUFFER_BINDING_ARB */ - { 929, 0x00008B85 }, /* GL_ATTACHED_SHADERS */ - { 949, 0x00008645 }, /* GL_ATTRIB_ARRAY_POINTER_NV */ - { 976, 0x00008623 }, /* GL_ATTRIB_ARRAY_SIZE_NV */ - { 1000, 0x00008624 }, /* GL_ATTRIB_ARRAY_STRIDE_NV */ - { 1026, 0x00008625 }, /* GL_ATTRIB_ARRAY_TYPE_NV */ - { 1050, 0x00000BB0 }, /* GL_ATTRIB_STACK_DEPTH */ - { 1072, 0x00000D80 }, /* GL_AUTO_NORMAL */ - { 1087, 0x00000409 }, /* GL_AUX0 */ - { 1095, 0x0000040A }, /* GL_AUX1 */ - { 1103, 0x0000040B }, /* GL_AUX2 */ - { 1111, 0x0000040C }, /* GL_AUX3 */ - { 1119, 0x00000C00 }, /* GL_AUX_BUFFERS */ - { 1134, 0x00000405 }, /* GL_BACK */ - { 1142, 0x00000402 }, /* GL_BACK_LEFT */ - { 1155, 0x00000403 }, /* GL_BACK_RIGHT */ - { 1169, 0x000080E0 }, /* GL_BGR */ - { 1176, 0x000080E1 }, /* GL_BGRA */ - { 1184, 0x00001A00 }, /* GL_BITMAP */ - { 1194, 0x00000704 }, /* GL_BITMAP_TOKEN */ - { 1210, 0x00000BE2 }, /* GL_BLEND */ - { 1219, 0x00008005 }, /* GL_BLEND_COLOR */ - { 1234, 0x00008005 }, /* GL_BLEND_COLOR_EXT */ - { 1253, 0x00000BE0 }, /* GL_BLEND_DST */ - { 1266, 0x000080CA }, /* GL_BLEND_DST_ALPHA */ - { 1285, 0x000080C8 }, /* GL_BLEND_DST_RGB */ - { 1302, 0x00008009 }, /* GL_BLEND_EQUATION */ - { 1320, 0x0000883D }, /* GL_BLEND_EQUATION_ALPHA */ - { 1344, 0x0000883D }, /* GL_BLEND_EQUATION_ALPHA_EXT */ - { 1372, 0x00008009 }, /* GL_BLEND_EQUATION_EXT */ - { 1394, 0x00008009 }, /* GL_BLEND_EQUATION_RGB */ - { 1416, 0x00008009 }, /* GL_BLEND_EQUATION_RGB_EXT */ - { 1442, 0x00000BE1 }, /* GL_BLEND_SRC */ - { 1455, 0x000080CB }, /* GL_BLEND_SRC_ALPHA */ - { 1474, 0x000080C9 }, /* GL_BLEND_SRC_RGB */ - { 1491, 0x00001905 }, /* GL_BLUE */ - { 1499, 0x00000D1B }, /* GL_BLUE_BIAS */ - { 1512, 0x00000D54 }, /* GL_BLUE_BITS */ - { 1525, 0x00000D1A }, /* GL_BLUE_SCALE */ - { 1539, 0x00008B56 }, /* GL_BOOL */ - { 1547, 0x00008B56 }, /* GL_BOOL_ARB */ - { 1559, 0x00008B57 }, /* GL_BOOL_VEC2 */ - { 1572, 0x00008B57 }, /* GL_BOOL_VEC2_ARB */ - { 1589, 0x00008B58 }, /* GL_BOOL_VEC3 */ - { 1602, 0x00008B58 }, /* GL_BOOL_VEC3_ARB */ - { 1619, 0x00008B59 }, /* GL_BOOL_VEC4 */ - { 1632, 0x00008B59 }, /* GL_BOOL_VEC4_ARB */ - { 1649, 0x000088BB }, /* GL_BUFFER_ACCESS */ - { 1666, 0x000088BB }, /* GL_BUFFER_ACCESS_ARB */ - { 1687, 0x000088BC }, /* GL_BUFFER_MAPPED */ - { 1704, 0x000088BC }, /* GL_BUFFER_MAPPED_ARB */ - { 1725, 0x000088BD }, /* GL_BUFFER_MAP_POINTER */ - { 1747, 0x000088BD }, /* GL_BUFFER_MAP_POINTER_ARB */ - { 1773, 0x00008764 }, /* GL_BUFFER_SIZE */ - { 1788, 0x00008764 }, /* GL_BUFFER_SIZE_ARB */ - { 1807, 0x00008765 }, /* GL_BUFFER_USAGE */ - { 1823, 0x00008765 }, /* GL_BUFFER_USAGE_ARB */ - { 1843, 0x0000877B }, /* GL_BUMP_ENVMAP_ATI */ - { 1862, 0x00008777 }, /* GL_BUMP_NUM_TEX_UNITS_ATI */ - { 1888, 0x00008775 }, /* GL_BUMP_ROT_MATRIX_ATI */ - { 1911, 0x00008776 }, /* GL_BUMP_ROT_MATRIX_SIZE_ATI */ - { 1939, 0x0000877C }, /* GL_BUMP_TARGET_ATI */ - { 1958, 0x00008778 }, /* GL_BUMP_TEX_UNITS_ATI */ - { 1980, 0x00001400 }, /* GL_BYTE */ - { 1988, 0x00002A24 }, /* GL_C3F_V3F */ - { 1999, 0x00002A26 }, /* GL_C4F_N3F_V3F */ - { 2014, 0x00002A22 }, /* GL_C4UB_V2F */ - { 2026, 0x00002A23 }, /* GL_C4UB_V3F */ - { 2038, 0x00000901 }, /* GL_CCW */ - { 2045, 0x00002900 }, /* GL_CLAMP */ - { 2054, 0x0000812D }, /* GL_CLAMP_TO_BORDER */ - { 2073, 0x0000812D }, /* GL_CLAMP_TO_BORDER_ARB */ - { 2096, 0x0000812D }, /* GL_CLAMP_TO_BORDER_SGIS */ - { 2120, 0x0000812F }, /* GL_CLAMP_TO_EDGE */ - { 2137, 0x0000812F }, /* GL_CLAMP_TO_EDGE_SGIS */ - { 2159, 0x00001500 }, /* GL_CLEAR */ - { 2168, 0x000084E1 }, /* GL_CLIENT_ACTIVE_TEXTURE */ - { 2193, 0x000084E1 }, /* GL_CLIENT_ACTIVE_TEXTURE_ARB */ - { 2222, 0xFFFFFFFF }, /* GL_CLIENT_ALL_ATTRIB_BITS */ - { 2248, 0x00000BB1 }, /* GL_CLIENT_ATTRIB_STACK_DEPTH */ - { 2277, 0x00000001 }, /* GL_CLIENT_PIXEL_STORE_BIT */ - { 2303, 0x00000002 }, /* GL_CLIENT_VERTEX_ARRAY_BIT */ - { 2330, 0x00003000 }, /* GL_CLIP_PLANE0 */ - { 2345, 0x00003001 }, /* GL_CLIP_PLANE1 */ - { 2360, 0x00003002 }, /* GL_CLIP_PLANE2 */ - { 2375, 0x00003003 }, /* GL_CLIP_PLANE3 */ - { 2390, 0x00003004 }, /* GL_CLIP_PLANE4 */ - { 2405, 0x00003005 }, /* GL_CLIP_PLANE5 */ - { 2420, 0x000080F0 }, /* GL_CLIP_VOLUME_CLIPPING_HINT_EXT */ - { 2453, 0x00000A00 }, /* GL_COEFF */ - { 2462, 0x00001800 }, /* GL_COLOR */ - { 2471, 0x00008076 }, /* GL_COLOR_ARRAY */ - { 2486, 0x00008898 }, /* GL_COLOR_ARRAY_BUFFER_BINDING */ - { 2516, 0x00008898 }, /* GL_COLOR_ARRAY_BUFFER_BINDING_ARB */ - { 2550, 0x00008090 }, /* GL_COLOR_ARRAY_POINTER */ - { 2573, 0x00008081 }, /* GL_COLOR_ARRAY_SIZE */ - { 2593, 0x00008083 }, /* GL_COLOR_ARRAY_STRIDE */ - { 2615, 0x00008082 }, /* GL_COLOR_ARRAY_TYPE */ - { 2635, 0x00008CE0 }, /* GL_COLOR_ATTACHMENT0 */ - { 2656, 0x00008CE0 }, /* GL_COLOR_ATTACHMENT0_EXT */ - { 2681, 0x00008CE1 }, /* GL_COLOR_ATTACHMENT1 */ - { 2702, 0x00008CEA }, /* GL_COLOR_ATTACHMENT10 */ - { 2724, 0x00008CEA }, /* GL_COLOR_ATTACHMENT10_EXT */ - { 2750, 0x00008CEB }, /* GL_COLOR_ATTACHMENT11 */ - { 2772, 0x00008CEB }, /* GL_COLOR_ATTACHMENT11_EXT */ - { 2798, 0x00008CEC }, /* GL_COLOR_ATTACHMENT12 */ - { 2820, 0x00008CEC }, /* GL_COLOR_ATTACHMENT12_EXT */ - { 2846, 0x00008CED }, /* GL_COLOR_ATTACHMENT13 */ - { 2868, 0x00008CED }, /* GL_COLOR_ATTACHMENT13_EXT */ - { 2894, 0x00008CEE }, /* GL_COLOR_ATTACHMENT14 */ - { 2916, 0x00008CEE }, /* GL_COLOR_ATTACHMENT14_EXT */ - { 2942, 0x00008CEF }, /* GL_COLOR_ATTACHMENT15 */ - { 2964, 0x00008CEF }, /* GL_COLOR_ATTACHMENT15_EXT */ - { 2990, 0x00008CE1 }, /* GL_COLOR_ATTACHMENT1_EXT */ - { 3015, 0x00008CE2 }, /* GL_COLOR_ATTACHMENT2 */ - { 3036, 0x00008CE2 }, /* GL_COLOR_ATTACHMENT2_EXT */ - { 3061, 0x00008CE3 }, /* GL_COLOR_ATTACHMENT3 */ - { 3082, 0x00008CE3 }, /* GL_COLOR_ATTACHMENT3_EXT */ - { 3107, 0x00008CE4 }, /* GL_COLOR_ATTACHMENT4 */ - { 3128, 0x00008CE4 }, /* GL_COLOR_ATTACHMENT4_EXT */ - { 3153, 0x00008CE5 }, /* GL_COLOR_ATTACHMENT5 */ - { 3174, 0x00008CE5 }, /* GL_COLOR_ATTACHMENT5_EXT */ - { 3199, 0x00008CE6 }, /* GL_COLOR_ATTACHMENT6 */ - { 3220, 0x00008CE6 }, /* GL_COLOR_ATTACHMENT6_EXT */ - { 3245, 0x00008CE7 }, /* GL_COLOR_ATTACHMENT7 */ - { 3266, 0x00008CE7 }, /* GL_COLOR_ATTACHMENT7_EXT */ - { 3291, 0x00008CE8 }, /* GL_COLOR_ATTACHMENT8 */ - { 3312, 0x00008CE8 }, /* GL_COLOR_ATTACHMENT8_EXT */ - { 3337, 0x00008CE9 }, /* GL_COLOR_ATTACHMENT9 */ - { 3358, 0x00008CE9 }, /* GL_COLOR_ATTACHMENT9_EXT */ - { 3383, 0x00004000 }, /* GL_COLOR_BUFFER_BIT */ - { 3403, 0x00000C22 }, /* GL_COLOR_CLEAR_VALUE */ - { 3424, 0x00001900 }, /* GL_COLOR_INDEX */ - { 3439, 0x00001603 }, /* GL_COLOR_INDEXES */ - { 3456, 0x00000BF2 }, /* GL_COLOR_LOGIC_OP */ - { 3474, 0x00000B57 }, /* GL_COLOR_MATERIAL */ - { 3492, 0x00000B55 }, /* GL_COLOR_MATERIAL_FACE */ - { 3515, 0x00000B56 }, /* GL_COLOR_MATERIAL_PARAMETER */ - { 3543, 0x000080B1 }, /* GL_COLOR_MATRIX */ - { 3559, 0x000080B1 }, /* GL_COLOR_MATRIX_SGI */ - { 3579, 0x000080B2 }, /* GL_COLOR_MATRIX_STACK_DEPTH */ - { 3607, 0x000080B2 }, /* GL_COLOR_MATRIX_STACK_DEPTH_SGI */ - { 3639, 0x00008458 }, /* GL_COLOR_SUM */ - { 3652, 0x00008458 }, /* GL_COLOR_SUM_ARB */ - { 3669, 0x000080D0 }, /* GL_COLOR_TABLE */ - { 3684, 0x000080DD }, /* GL_COLOR_TABLE_ALPHA_SIZE */ - { 3710, 0x000080DD }, /* GL_COLOR_TABLE_ALPHA_SIZE_EXT */ - { 3740, 0x000080DD }, /* GL_COLOR_TABLE_ALPHA_SIZE_SGI */ - { 3770, 0x000080D7 }, /* GL_COLOR_TABLE_BIAS */ - { 3790, 0x000080D7 }, /* GL_COLOR_TABLE_BIAS_SGI */ - { 3814, 0x000080DC }, /* GL_COLOR_TABLE_BLUE_SIZE */ - { 3839, 0x000080DC }, /* GL_COLOR_TABLE_BLUE_SIZE_EXT */ - { 3868, 0x000080DC }, /* GL_COLOR_TABLE_BLUE_SIZE_SGI */ - { 3897, 0x000080D8 }, /* GL_COLOR_TABLE_FORMAT */ - { 3919, 0x000080D8 }, /* GL_COLOR_TABLE_FORMAT_EXT */ - { 3945, 0x000080D8 }, /* GL_COLOR_TABLE_FORMAT_SGI */ - { 3971, 0x000080DB }, /* GL_COLOR_TABLE_GREEN_SIZE */ - { 3997, 0x000080DB }, /* GL_COLOR_TABLE_GREEN_SIZE_EXT */ - { 4027, 0x000080DB }, /* GL_COLOR_TABLE_GREEN_SIZE_SGI */ - { 4057, 0x000080DF }, /* GL_COLOR_TABLE_INTENSITY_SIZE */ - { 4087, 0x000080DF }, /* GL_COLOR_TABLE_INTENSITY_SIZE_EXT */ - { 4121, 0x000080DF }, /* GL_COLOR_TABLE_INTENSITY_SIZE_SGI */ - { 4155, 0x000080DE }, /* GL_COLOR_TABLE_LUMINANCE_SIZE */ - { 4185, 0x000080DE }, /* GL_COLOR_TABLE_LUMINANCE_SIZE_EXT */ - { 4219, 0x000080DE }, /* GL_COLOR_TABLE_LUMINANCE_SIZE_SGI */ - { 4253, 0x000080DA }, /* GL_COLOR_TABLE_RED_SIZE */ - { 4277, 0x000080DA }, /* GL_COLOR_TABLE_RED_SIZE_EXT */ - { 4305, 0x000080DA }, /* GL_COLOR_TABLE_RED_SIZE_SGI */ - { 4333, 0x000080D6 }, /* GL_COLOR_TABLE_SCALE */ - { 4354, 0x000080D6 }, /* GL_COLOR_TABLE_SCALE_SGI */ - { 4379, 0x000080D9 }, /* GL_COLOR_TABLE_WIDTH */ - { 4400, 0x000080D9 }, /* GL_COLOR_TABLE_WIDTH_EXT */ - { 4425, 0x000080D9 }, /* GL_COLOR_TABLE_WIDTH_SGI */ - { 4450, 0x00000C23 }, /* GL_COLOR_WRITEMASK */ - { 4469, 0x00008570 }, /* GL_COMBINE */ - { 4480, 0x00008503 }, /* GL_COMBINE4 */ - { 4492, 0x00008572 }, /* GL_COMBINE_ALPHA */ - { 4509, 0x00008572 }, /* GL_COMBINE_ALPHA_ARB */ - { 4530, 0x00008572 }, /* GL_COMBINE_ALPHA_EXT */ - { 4551, 0x00008570 }, /* GL_COMBINE_ARB */ - { 4566, 0x00008570 }, /* GL_COMBINE_EXT */ - { 4581, 0x00008571 }, /* GL_COMBINE_RGB */ - { 4596, 0x00008571 }, /* GL_COMBINE_RGB_ARB */ - { 4615, 0x00008571 }, /* GL_COMBINE_RGB_EXT */ - { 4634, 0x0000884E }, /* GL_COMPARE_REF_DEPTH_TO_TEXTURE_EXT */ - { 4670, 0x0000884E }, /* GL_COMPARE_R_TO_TEXTURE */ - { 4694, 0x0000884E }, /* GL_COMPARE_R_TO_TEXTURE_ARB */ - { 4722, 0x00001300 }, /* GL_COMPILE */ - { 4733, 0x00001301 }, /* GL_COMPILE_AND_EXECUTE */ - { 4756, 0x00008B81 }, /* GL_COMPILE_STATUS */ - { 4774, 0x000084E9 }, /* GL_COMPRESSED_ALPHA */ - { 4794, 0x000084E9 }, /* GL_COMPRESSED_ALPHA_ARB */ - { 4818, 0x000084EC }, /* GL_COMPRESSED_INTENSITY */ - { 4842, 0x000084EC }, /* GL_COMPRESSED_INTENSITY_ARB */ - { 4870, 0x000084EA }, /* GL_COMPRESSED_LUMINANCE */ - { 4894, 0x000084EB }, /* GL_COMPRESSED_LUMINANCE_ALPHA */ - { 4924, 0x000084EB }, /* GL_COMPRESSED_LUMINANCE_ALPHA_ARB */ - { 4958, 0x000084EA }, /* GL_COMPRESSED_LUMINANCE_ARB */ - { 4986, 0x000084ED }, /* GL_COMPRESSED_RGB */ - { 5004, 0x000084EE }, /* GL_COMPRESSED_RGBA */ - { 5023, 0x000084EE }, /* GL_COMPRESSED_RGBA_ARB */ - { 5046, 0x000086B1 }, /* GL_COMPRESSED_RGBA_FXT1_3DFX */ - { 5075, 0x000083F1 }, /* GL_COMPRESSED_RGBA_S3TC_DXT1_EXT */ - { 5108, 0x000083F2 }, /* GL_COMPRESSED_RGBA_S3TC_DXT3_EXT */ - { 5141, 0x000083F3 }, /* GL_COMPRESSED_RGBA_S3TC_DXT5_EXT */ - { 5174, 0x000084ED }, /* GL_COMPRESSED_RGB_ARB */ - { 5196, 0x000086B0 }, /* GL_COMPRESSED_RGB_FXT1_3DFX */ - { 5224, 0x000083F0 }, /* GL_COMPRESSED_RGB_S3TC_DXT1_EXT */ - { 5256, 0x00008C4A }, /* GL_COMPRESSED_SLUMINANCE */ - { 5281, 0x00008C4B }, /* GL_COMPRESSED_SLUMINANCE_ALPHA */ - { 5312, 0x00008C48 }, /* GL_COMPRESSED_SRGB */ - { 5331, 0x00008C49 }, /* GL_COMPRESSED_SRGB_ALPHA */ - { 5356, 0x000086A3 }, /* GL_COMPRESSED_TEXTURE_FORMATS */ - { 5386, 0x00008576 }, /* GL_CONSTANT */ - { 5398, 0x00008003 }, /* GL_CONSTANT_ALPHA */ - { 5416, 0x00008003 }, /* GL_CONSTANT_ALPHA_EXT */ - { 5438, 0x00008576 }, /* GL_CONSTANT_ARB */ - { 5454, 0x00001207 }, /* GL_CONSTANT_ATTENUATION */ - { 5478, 0x00008151 }, /* GL_CONSTANT_BORDER_HP */ - { 5500, 0x00008001 }, /* GL_CONSTANT_COLOR */ - { 5518, 0x00008001 }, /* GL_CONSTANT_COLOR_EXT */ - { 5540, 0x00008576 }, /* GL_CONSTANT_EXT */ - { 5556, 0x00008010 }, /* GL_CONVOLUTION_1D */ - { 5574, 0x00008011 }, /* GL_CONVOLUTION_2D */ - { 5592, 0x00008154 }, /* GL_CONVOLUTION_BORDER_COLOR */ - { 5620, 0x00008154 }, /* GL_CONVOLUTION_BORDER_COLOR_HP */ - { 5651, 0x00008013 }, /* GL_CONVOLUTION_BORDER_MODE */ - { 5678, 0x00008013 }, /* GL_CONVOLUTION_BORDER_MODE_EXT */ - { 5709, 0x00008015 }, /* GL_CONVOLUTION_FILTER_BIAS */ - { 5736, 0x00008015 }, /* GL_CONVOLUTION_FILTER_BIAS_EXT */ - { 5767, 0x00008014 }, /* GL_CONVOLUTION_FILTER_SCALE */ - { 5795, 0x00008014 }, /* GL_CONVOLUTION_FILTER_SCALE_EXT */ - { 5827, 0x00008017 }, /* GL_CONVOLUTION_FORMAT */ - { 5849, 0x00008017 }, /* GL_CONVOLUTION_FORMAT_EXT */ - { 5875, 0x00008019 }, /* GL_CONVOLUTION_HEIGHT */ - { 5897, 0x00008019 }, /* GL_CONVOLUTION_HEIGHT_EXT */ - { 5923, 0x00008018 }, /* GL_CONVOLUTION_WIDTH */ - { 5944, 0x00008018 }, /* GL_CONVOLUTION_WIDTH_EXT */ - { 5969, 0x00008862 }, /* GL_COORD_REPLACE */ - { 5986, 0x00008862 }, /* GL_COORD_REPLACE_ARB */ - { 6007, 0x00008862 }, /* GL_COORD_REPLACE_NV */ - { 6027, 0x00001503 }, /* GL_COPY */ - { 6035, 0x0000150C }, /* GL_COPY_INVERTED */ - { 6052, 0x00000706 }, /* GL_COPY_PIXEL_TOKEN */ - { 6072, 0x00000B44 }, /* GL_CULL_FACE */ - { 6085, 0x00000B45 }, /* GL_CULL_FACE_MODE */ - { 6103, 0x000081AA }, /* GL_CULL_VERTEX_EXT */ - { 6122, 0x000081AC }, /* GL_CULL_VERTEX_EYE_POSITION_EXT */ - { 6154, 0x000081AB }, /* GL_CULL_VERTEX_OBJECT_POSITION_EXT */ - { 6189, 0x00008626 }, /* GL_CURRENT_ATTRIB_NV */ - { 6210, 0x00000001 }, /* GL_CURRENT_BIT */ - { 6225, 0x00000B00 }, /* GL_CURRENT_COLOR */ - { 6242, 0x00008453 }, /* GL_CURRENT_FOG_COORD */ - { 6263, 0x00008453 }, /* GL_CURRENT_FOG_COORDINATE */ - { 6289, 0x00000B01 }, /* GL_CURRENT_INDEX */ - { 6306, 0x00008641 }, /* GL_CURRENT_MATRIX_ARB */ - { 6328, 0x00008845 }, /* GL_CURRENT_MATRIX_INDEX_ARB */ - { 6356, 0x00008641 }, /* GL_CURRENT_MATRIX_NV */ - { 6377, 0x00008640 }, /* GL_CURRENT_MATRIX_STACK_DEPTH_ARB */ - { 6411, 0x00008640 }, /* GL_CURRENT_MATRIX_STACK_DEPTH_NV */ - { 6444, 0x00000B02 }, /* GL_CURRENT_NORMAL */ - { 6462, 0x00008843 }, /* GL_CURRENT_PALETTE_MATRIX_ARB */ - { 6492, 0x00008B8D }, /* GL_CURRENT_PROGRAM */ - { 6511, 0x00008865 }, /* GL_CURRENT_QUERY */ - { 6528, 0x00008865 }, /* GL_CURRENT_QUERY_ARB */ - { 6549, 0x00000B04 }, /* GL_CURRENT_RASTER_COLOR */ - { 6573, 0x00000B09 }, /* GL_CURRENT_RASTER_DISTANCE */ - { 6600, 0x00000B05 }, /* GL_CURRENT_RASTER_INDEX */ - { 6624, 0x00000B07 }, /* GL_CURRENT_RASTER_POSITION */ - { 6651, 0x00000B08 }, /* GL_CURRENT_RASTER_POSITION_VALID */ - { 6684, 0x0000845F }, /* GL_CURRENT_RASTER_SECONDARY_COLOR */ - { 6718, 0x00000B06 }, /* GL_CURRENT_RASTER_TEXTURE_COORDS */ - { 6751, 0x00008459 }, /* GL_CURRENT_SECONDARY_COLOR */ - { 6778, 0x00000B03 }, /* GL_CURRENT_TEXTURE_COORDS */ - { 6804, 0x00008626 }, /* GL_CURRENT_VERTEX_ATTRIB */ - { 6829, 0x00008626 }, /* GL_CURRENT_VERTEX_ATTRIB_ARB */ - { 6858, 0x000086A8 }, /* GL_CURRENT_WEIGHT_ARB */ - { 6880, 0x00000900 }, /* GL_CW */ - { 6886, 0x0000875B }, /* GL_DEBUG_ASSERT_MESA */ - { 6907, 0x00008759 }, /* GL_DEBUG_OBJECT_MESA */ - { 6928, 0x0000875A }, /* GL_DEBUG_PRINT_MESA */ - { 6948, 0x00002101 }, /* GL_DECAL */ - { 6957, 0x00001E03 }, /* GL_DECR */ - { 6965, 0x00008508 }, /* GL_DECR_WRAP */ - { 6978, 0x00008508 }, /* GL_DECR_WRAP_EXT */ - { 6995, 0x00008B80 }, /* GL_DELETE_STATUS */ - { 7012, 0x00001801 }, /* GL_DEPTH */ - { 7021, 0x000088F0 }, /* GL_DEPTH24_STENCIL8 */ - { 7041, 0x00008D00 }, /* GL_DEPTH_ATTACHMENT */ - { 7061, 0x00008D00 }, /* GL_DEPTH_ATTACHMENT_EXT */ - { 7085, 0x00000D1F }, /* GL_DEPTH_BIAS */ - { 7099, 0x00000D56 }, /* GL_DEPTH_BITS */ - { 7113, 0x00008891 }, /* GL_DEPTH_BOUNDS_EXT */ - { 7133, 0x00008890 }, /* GL_DEPTH_BOUNDS_TEST_EXT */ - { 7158, 0x00000100 }, /* GL_DEPTH_BUFFER_BIT */ - { 7178, 0x0000864F }, /* GL_DEPTH_CLAMP_NV */ - { 7196, 0x00000B73 }, /* GL_DEPTH_CLEAR_VALUE */ - { 7217, 0x00001902 }, /* GL_DEPTH_COMPONENT */ - { 7236, 0x000081A5 }, /* GL_DEPTH_COMPONENT16 */ - { 7257, 0x000081A5 }, /* GL_DEPTH_COMPONENT16_ARB */ - { 7282, 0x000081A5 }, /* GL_DEPTH_COMPONENT16_SGIX */ - { 7308, 0x000081A6 }, /* GL_DEPTH_COMPONENT24 */ - { 7329, 0x000081A6 }, /* GL_DEPTH_COMPONENT24_ARB */ - { 7354, 0x000081A6 }, /* GL_DEPTH_COMPONENT24_SGIX */ - { 7380, 0x000081A7 }, /* GL_DEPTH_COMPONENT32 */ - { 7401, 0x000081A7 }, /* GL_DEPTH_COMPONENT32_ARB */ - { 7426, 0x000081A7 }, /* GL_DEPTH_COMPONENT32_SGIX */ - { 7452, 0x00000B74 }, /* GL_DEPTH_FUNC */ - { 7466, 0x00000B70 }, /* GL_DEPTH_RANGE */ - { 7481, 0x00000D1E }, /* GL_DEPTH_SCALE */ - { 7496, 0x000084F9 }, /* GL_DEPTH_STENCIL */ - { 7513, 0x0000821A }, /* GL_DEPTH_STENCIL_ATTACHMENT */ - { 7541, 0x000084F9 }, /* GL_DEPTH_STENCIL_NV */ - { 7561, 0x0000886F }, /* GL_DEPTH_STENCIL_TO_BGRA_NV */ - { 7589, 0x0000886E }, /* GL_DEPTH_STENCIL_TO_RGBA_NV */ - { 7617, 0x00000B71 }, /* GL_DEPTH_TEST */ - { 7631, 0x0000884B }, /* GL_DEPTH_TEXTURE_MODE */ - { 7653, 0x0000884B }, /* GL_DEPTH_TEXTURE_MODE_ARB */ - { 7679, 0x00000B72 }, /* GL_DEPTH_WRITEMASK */ - { 7698, 0x00001201 }, /* GL_DIFFUSE */ - { 7709, 0x00000BD0 }, /* GL_DITHER */ - { 7719, 0x00000A02 }, /* GL_DOMAIN */ - { 7729, 0x00001100 }, /* GL_DONT_CARE */ - { 7742, 0x000086AE }, /* GL_DOT3_RGB */ - { 7754, 0x000086AF }, /* GL_DOT3_RGBA */ - { 7767, 0x000086AF }, /* GL_DOT3_RGBA_ARB */ - { 7784, 0x00008741 }, /* GL_DOT3_RGBA_EXT */ - { 7801, 0x000086AE }, /* GL_DOT3_RGB_ARB */ - { 7817, 0x00008740 }, /* GL_DOT3_RGB_EXT */ - { 7833, 0x0000140A }, /* GL_DOUBLE */ - { 7843, 0x00000C32 }, /* GL_DOUBLEBUFFER */ - { 7859, 0x00000C01 }, /* GL_DRAW_BUFFER */ - { 7874, 0x00008825 }, /* GL_DRAW_BUFFER0 */ - { 7890, 0x00008825 }, /* GL_DRAW_BUFFER0_ARB */ - { 7910, 0x00008825 }, /* GL_DRAW_BUFFER0_ATI */ - { 7930, 0x00008826 }, /* GL_DRAW_BUFFER1 */ - { 7946, 0x0000882F }, /* GL_DRAW_BUFFER10 */ - { 7963, 0x0000882F }, /* GL_DRAW_BUFFER10_ARB */ - { 7984, 0x0000882F }, /* GL_DRAW_BUFFER10_ATI */ - { 8005, 0x00008830 }, /* GL_DRAW_BUFFER11 */ - { 8022, 0x00008830 }, /* GL_DRAW_BUFFER11_ARB */ - { 8043, 0x00008830 }, /* GL_DRAW_BUFFER11_ATI */ - { 8064, 0x00008831 }, /* GL_DRAW_BUFFER12 */ - { 8081, 0x00008831 }, /* GL_DRAW_BUFFER12_ARB */ - { 8102, 0x00008831 }, /* GL_DRAW_BUFFER12_ATI */ - { 8123, 0x00008832 }, /* GL_DRAW_BUFFER13 */ - { 8140, 0x00008832 }, /* GL_DRAW_BUFFER13_ARB */ - { 8161, 0x00008832 }, /* GL_DRAW_BUFFER13_ATI */ - { 8182, 0x00008833 }, /* GL_DRAW_BUFFER14 */ - { 8199, 0x00008833 }, /* GL_DRAW_BUFFER14_ARB */ - { 8220, 0x00008833 }, /* GL_DRAW_BUFFER14_ATI */ - { 8241, 0x00008834 }, /* GL_DRAW_BUFFER15 */ - { 8258, 0x00008834 }, /* GL_DRAW_BUFFER15_ARB */ - { 8279, 0x00008834 }, /* GL_DRAW_BUFFER15_ATI */ - { 8300, 0x00008826 }, /* GL_DRAW_BUFFER1_ARB */ - { 8320, 0x00008826 }, /* GL_DRAW_BUFFER1_ATI */ - { 8340, 0x00008827 }, /* GL_DRAW_BUFFER2 */ - { 8356, 0x00008827 }, /* GL_DRAW_BUFFER2_ARB */ - { 8376, 0x00008827 }, /* GL_DRAW_BUFFER2_ATI */ - { 8396, 0x00008828 }, /* GL_DRAW_BUFFER3 */ - { 8412, 0x00008828 }, /* GL_DRAW_BUFFER3_ARB */ - { 8432, 0x00008828 }, /* GL_DRAW_BUFFER3_ATI */ - { 8452, 0x00008829 }, /* GL_DRAW_BUFFER4 */ - { 8468, 0x00008829 }, /* GL_DRAW_BUFFER4_ARB */ - { 8488, 0x00008829 }, /* GL_DRAW_BUFFER4_ATI */ - { 8508, 0x0000882A }, /* GL_DRAW_BUFFER5 */ - { 8524, 0x0000882A }, /* GL_DRAW_BUFFER5_ARB */ - { 8544, 0x0000882A }, /* GL_DRAW_BUFFER5_ATI */ - { 8564, 0x0000882B }, /* GL_DRAW_BUFFER6 */ - { 8580, 0x0000882B }, /* GL_DRAW_BUFFER6_ARB */ - { 8600, 0x0000882B }, /* GL_DRAW_BUFFER6_ATI */ - { 8620, 0x0000882C }, /* GL_DRAW_BUFFER7 */ - { 8636, 0x0000882C }, /* GL_DRAW_BUFFER7_ARB */ - { 8656, 0x0000882C }, /* GL_DRAW_BUFFER7_ATI */ - { 8676, 0x0000882D }, /* GL_DRAW_BUFFER8 */ - { 8692, 0x0000882D }, /* GL_DRAW_BUFFER8_ARB */ - { 8712, 0x0000882D }, /* GL_DRAW_BUFFER8_ATI */ - { 8732, 0x0000882E }, /* GL_DRAW_BUFFER9 */ - { 8748, 0x0000882E }, /* GL_DRAW_BUFFER9_ARB */ - { 8768, 0x0000882E }, /* GL_DRAW_BUFFER9_ATI */ - { 8788, 0x00008CA9 }, /* GL_DRAW_FRAMEBUFFER */ - { 8808, 0x00008CA6 }, /* GL_DRAW_FRAMEBUFFER_BINDING_EXT */ - { 8840, 0x00008CA9 }, /* GL_DRAW_FRAMEBUFFER_EXT */ - { 8864, 0x00000705 }, /* GL_DRAW_PIXEL_TOKEN */ - { 8884, 0x00000304 }, /* GL_DST_ALPHA */ - { 8897, 0x00000306 }, /* GL_DST_COLOR */ - { 8910, 0x0000877A }, /* GL_DU8DV8_ATI */ - { 8924, 0x00008779 }, /* GL_DUDV_ATI */ - { 8936, 0x000088EA }, /* GL_DYNAMIC_COPY */ - { 8952, 0x000088EA }, /* GL_DYNAMIC_COPY_ARB */ - { 8972, 0x000088E8 }, /* GL_DYNAMIC_DRAW */ - { 8988, 0x000088E8 }, /* GL_DYNAMIC_DRAW_ARB */ - { 9008, 0x000088E9 }, /* GL_DYNAMIC_READ */ - { 9024, 0x000088E9 }, /* GL_DYNAMIC_READ_ARB */ - { 9044, 0x00000B43 }, /* GL_EDGE_FLAG */ - { 9057, 0x00008079 }, /* GL_EDGE_FLAG_ARRAY */ - { 9076, 0x0000889B }, /* GL_EDGE_FLAG_ARRAY_BUFFER_BINDING */ - { 9110, 0x0000889B }, /* GL_EDGE_FLAG_ARRAY_BUFFER_BINDING_ARB */ - { 9148, 0x00008093 }, /* GL_EDGE_FLAG_ARRAY_POINTER */ - { 9175, 0x0000808C }, /* GL_EDGE_FLAG_ARRAY_STRIDE */ - { 9201, 0x00008893 }, /* GL_ELEMENT_ARRAY_BUFFER */ - { 9225, 0x00008895 }, /* GL_ELEMENT_ARRAY_BUFFER_BINDING */ - { 9257, 0x00008895 }, /* GL_ELEMENT_ARRAY_BUFFER_BINDING_ARB */ - { 9293, 0x00001600 }, /* GL_EMISSION */ - { 9305, 0x00002000 }, /* GL_ENABLE_BIT */ - { 9319, 0x00000202 }, /* GL_EQUAL */ - { 9328, 0x00001509 }, /* GL_EQUIV */ - { 9337, 0x00010000 }, /* GL_EVAL_BIT */ - { 9349, 0x00000800 }, /* GL_EXP */ - { 9356, 0x00000801 }, /* GL_EXP2 */ - { 9364, 0x00001F03 }, /* GL_EXTENSIONS */ - { 9378, 0x00002400 }, /* GL_EYE_LINEAR */ - { 9392, 0x00002502 }, /* GL_EYE_PLANE */ - { 9405, 0x0000855C }, /* GL_EYE_PLANE_ABSOLUTE_NV */ - { 9430, 0x0000855B }, /* GL_EYE_RADIAL_NV */ - { 9447, 0x00000000 }, /* GL_FALSE */ - { 9456, 0x00001101 }, /* GL_FASTEST */ - { 9467, 0x00001C01 }, /* GL_FEEDBACK */ - { 9479, 0x00000DF0 }, /* GL_FEEDBACK_BUFFER_POINTER */ - { 9506, 0x00000DF1 }, /* GL_FEEDBACK_BUFFER_SIZE */ - { 9530, 0x00000DF2 }, /* GL_FEEDBACK_BUFFER_TYPE */ - { 9554, 0x00001B02 }, /* GL_FILL */ - { 9562, 0x00001D00 }, /* GL_FLAT */ - { 9570, 0x00001406 }, /* GL_FLOAT */ - { 9579, 0x00008B5A }, /* GL_FLOAT_MAT2 */ - { 9593, 0x00008B5A }, /* GL_FLOAT_MAT2_ARB */ - { 9611, 0x00008B65 }, /* GL_FLOAT_MAT2x3 */ - { 9627, 0x00008B66 }, /* GL_FLOAT_MAT2x4 */ - { 9643, 0x00008B5B }, /* GL_FLOAT_MAT3 */ - { 9657, 0x00008B5B }, /* GL_FLOAT_MAT3_ARB */ - { 9675, 0x00008B67 }, /* GL_FLOAT_MAT3x2 */ - { 9691, 0x00008B68 }, /* GL_FLOAT_MAT3x4 */ - { 9707, 0x00008B5C }, /* GL_FLOAT_MAT4 */ - { 9721, 0x00008B5C }, /* GL_FLOAT_MAT4_ARB */ - { 9739, 0x00008B69 }, /* GL_FLOAT_MAT4x2 */ - { 9755, 0x00008B6A }, /* GL_FLOAT_MAT4x3 */ - { 9771, 0x00008B50 }, /* GL_FLOAT_VEC2 */ - { 9785, 0x00008B50 }, /* GL_FLOAT_VEC2_ARB */ - { 9803, 0x00008B51 }, /* GL_FLOAT_VEC3 */ - { 9817, 0x00008B51 }, /* GL_FLOAT_VEC3_ARB */ - { 9835, 0x00008B52 }, /* GL_FLOAT_VEC4 */ - { 9849, 0x00008B52 }, /* GL_FLOAT_VEC4_ARB */ - { 9867, 0x00000B60 }, /* GL_FOG */ - { 9874, 0x00000080 }, /* GL_FOG_BIT */ - { 9885, 0x00000B66 }, /* GL_FOG_COLOR */ - { 9898, 0x00008451 }, /* GL_FOG_COORD */ - { 9911, 0x00008451 }, /* GL_FOG_COORDINATE */ - { 9929, 0x00008457 }, /* GL_FOG_COORDINATE_ARRAY */ - { 9953, 0x0000889D }, /* GL_FOG_COORDINATE_ARRAY_BUFFER_BINDING */ - { 9992, 0x0000889D }, /* GL_FOG_COORDINATE_ARRAY_BUFFER_BINDING_ARB */ - { 10035, 0x00008456 }, /* GL_FOG_COORDINATE_ARRAY_POINTER */ - { 10067, 0x00008455 }, /* GL_FOG_COORDINATE_ARRAY_STRIDE */ - { 10098, 0x00008454 }, /* GL_FOG_COORDINATE_ARRAY_TYPE */ - { 10127, 0x00008450 }, /* GL_FOG_COORDINATE_SOURCE */ - { 10152, 0x00008457 }, /* GL_FOG_COORD_ARRAY */ - { 10171, 0x0000889D }, /* GL_FOG_COORD_ARRAY_BUFFER_BINDING */ - { 10205, 0x00008456 }, /* GL_FOG_COORD_ARRAY_POINTER */ - { 10232, 0x00008455 }, /* GL_FOG_COORD_ARRAY_STRIDE */ - { 10258, 0x00008454 }, /* GL_FOG_COORD_ARRAY_TYPE */ - { 10282, 0x00008450 }, /* GL_FOG_COORD_SRC */ - { 10299, 0x00000B62 }, /* GL_FOG_DENSITY */ - { 10314, 0x0000855A }, /* GL_FOG_DISTANCE_MODE_NV */ - { 10338, 0x00000B64 }, /* GL_FOG_END */ - { 10349, 0x00000C54 }, /* GL_FOG_HINT */ - { 10361, 0x00000B61 }, /* GL_FOG_INDEX */ - { 10374, 0x00000B65 }, /* GL_FOG_MODE */ - { 10386, 0x00008198 }, /* GL_FOG_OFFSET_SGIX */ - { 10405, 0x00008199 }, /* GL_FOG_OFFSET_VALUE_SGIX */ - { 10430, 0x00000B63 }, /* GL_FOG_START */ - { 10443, 0x00008452 }, /* GL_FRAGMENT_DEPTH */ - { 10461, 0x00008804 }, /* GL_FRAGMENT_PROGRAM_ARB */ - { 10485, 0x00008B30 }, /* GL_FRAGMENT_SHADER */ - { 10504, 0x00008B30 }, /* GL_FRAGMENT_SHADER_ARB */ - { 10527, 0x00008B8B }, /* GL_FRAGMENT_SHADER_DERIVATIVE_HINT */ - { 10562, 0x00008D40 }, /* GL_FRAMEBUFFER */ - { 10577, 0x00008215 }, /* GL_FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE */ - { 10614, 0x00008214 }, /* GL_FRAMEBUFFER_ATTACHMENT_BLUE_SIZE */ - { 10650, 0x00008210 }, /* GL_FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING */ - { 10691, 0x00008211 }, /* GL_FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE */ - { 10732, 0x00008216 }, /* GL_FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE */ - { 10769, 0x00008213 }, /* GL_FRAMEBUFFER_ATTACHMENT_GREEN_SIZE */ - { 10806, 0x00008CD1 }, /* GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME */ - { 10844, 0x00008CD1 }, /* GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME_EXT */ - { 10886, 0x00008CD0 }, /* GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE */ - { 10924, 0x00008CD0 }, /* GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE_EXT */ - { 10966, 0x00008212 }, /* GL_FRAMEBUFFER_ATTACHMENT_RED_SIZE */ - { 11001, 0x00008217 }, /* GL_FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE */ - { 11040, 0x00008CD4 }, /* GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_3D_ZOFFSET_EXT */ - { 11089, 0x00008CD3 }, /* GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE */ - { 11137, 0x00008CD3 }, /* GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE_EXT */ - { 11189, 0x00008CD4 }, /* GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER */ - { 11229, 0x00008CD4 }, /* GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER_EXT */ - { 11273, 0x00008CD2 }, /* GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL */ - { 11313, 0x00008CD2 }, /* GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL_EXT */ - { 11357, 0x00008CA6 }, /* GL_FRAMEBUFFER_BINDING_EXT */ - { 11384, 0x00008CD5 }, /* GL_FRAMEBUFFER_COMPLETE */ - { 11408, 0x00008CD5 }, /* GL_FRAMEBUFFER_COMPLETE_EXT */ - { 11436, 0x00008218 }, /* GL_FRAMEBUFFER_DEFAULT */ - { 11459, 0x00008D40 }, /* GL_FRAMEBUFFER_EXT */ - { 11478, 0x00008CD6 }, /* GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT */ - { 11515, 0x00008CD6 }, /* GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT_EXT */ - { 11556, 0x00008CD9 }, /* GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS_EXT */ - { 11597, 0x00008CDB }, /* GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER_EXT */ - { 11639, 0x00008CD8 }, /* GL_FRAMEBUFFER_INCOMPLETE_DUPLICATE_ATTACHMENT_EXT */ - { 11690, 0x00008CDA }, /* GL_FRAMEBUFFER_INCOMPLETE_FORMATS_EXT */ - { 11728, 0x00008CD7 }, /* GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT */ - { 11773, 0x00008CD7 }, /* GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT_EXT */ - { 11822, 0x00008D56 }, /* GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE */ - { 11860, 0x00008CDC }, /* GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER_EXT */ - { 11902, 0x00008CDE }, /* GL_FRAMEBUFFER_STATUS_ERROR_EXT */ - { 11934, 0x00008219 }, /* GL_FRAMEBUFFER_UNDEFINED */ - { 11959, 0x00008CDD }, /* GL_FRAMEBUFFER_UNSUPPORTED */ - { 11986, 0x00008CDD }, /* GL_FRAMEBUFFER_UNSUPPORTED_EXT */ - { 12017, 0x00000404 }, /* GL_FRONT */ - { 12026, 0x00000408 }, /* GL_FRONT_AND_BACK */ - { 12044, 0x00000B46 }, /* GL_FRONT_FACE */ - { 12058, 0x00000400 }, /* GL_FRONT_LEFT */ - { 12072, 0x00000401 }, /* GL_FRONT_RIGHT */ - { 12087, 0x00008006 }, /* GL_FUNC_ADD */ - { 12099, 0x00008006 }, /* GL_FUNC_ADD_EXT */ - { 12115, 0x0000800B }, /* GL_FUNC_REVERSE_SUBTRACT */ - { 12140, 0x0000800B }, /* GL_FUNC_REVERSE_SUBTRACT_EXT */ - { 12169, 0x0000800A }, /* GL_FUNC_SUBTRACT */ - { 12186, 0x0000800A }, /* GL_FUNC_SUBTRACT_EXT */ - { 12207, 0x00008191 }, /* GL_GENERATE_MIPMAP */ - { 12226, 0x00008192 }, /* GL_GENERATE_MIPMAP_HINT */ - { 12250, 0x00008192 }, /* GL_GENERATE_MIPMAP_HINT_SGIS */ - { 12279, 0x00008191 }, /* GL_GENERATE_MIPMAP_SGIS */ - { 12303, 0x00000206 }, /* GL_GEQUAL */ - { 12313, 0x00000204 }, /* GL_GREATER */ - { 12324, 0x00001904 }, /* GL_GREEN */ - { 12333, 0x00000D19 }, /* GL_GREEN_BIAS */ - { 12347, 0x00000D53 }, /* GL_GREEN_BITS */ - { 12361, 0x00000D18 }, /* GL_GREEN_SCALE */ - { 12376, 0x00008000 }, /* GL_HINT_BIT */ - { 12388, 0x00008024 }, /* GL_HISTOGRAM */ - { 12401, 0x0000802B }, /* GL_HISTOGRAM_ALPHA_SIZE */ - { 12425, 0x0000802B }, /* GL_HISTOGRAM_ALPHA_SIZE_EXT */ - { 12453, 0x0000802A }, /* GL_HISTOGRAM_BLUE_SIZE */ - { 12476, 0x0000802A }, /* GL_HISTOGRAM_BLUE_SIZE_EXT */ - { 12503, 0x00008024 }, /* GL_HISTOGRAM_EXT */ - { 12520, 0x00008027 }, /* GL_HISTOGRAM_FORMAT */ - { 12540, 0x00008027 }, /* GL_HISTOGRAM_FORMAT_EXT */ - { 12564, 0x00008029 }, /* GL_HISTOGRAM_GREEN_SIZE */ - { 12588, 0x00008029 }, /* GL_HISTOGRAM_GREEN_SIZE_EXT */ - { 12616, 0x0000802C }, /* GL_HISTOGRAM_LUMINANCE_SIZE */ - { 12644, 0x0000802C }, /* GL_HISTOGRAM_LUMINANCE_SIZE_EXT */ - { 12676, 0x00008028 }, /* GL_HISTOGRAM_RED_SIZE */ - { 12698, 0x00008028 }, /* GL_HISTOGRAM_RED_SIZE_EXT */ - { 12724, 0x0000802D }, /* GL_HISTOGRAM_SINK */ - { 12742, 0x0000802D }, /* GL_HISTOGRAM_SINK_EXT */ - { 12764, 0x00008026 }, /* GL_HISTOGRAM_WIDTH */ - { 12783, 0x00008026 }, /* GL_HISTOGRAM_WIDTH_EXT */ - { 12806, 0x0000862A }, /* GL_IDENTITY_NV */ - { 12821, 0x00008150 }, /* GL_IGNORE_BORDER_HP */ - { 12841, 0x00008B9B }, /* GL_IMPLEMENTATION_COLOR_READ_FORMAT_OES */ - { 12881, 0x00008B9A }, /* GL_IMPLEMENTATION_COLOR_READ_TYPE_OES */ - { 12919, 0x00001E02 }, /* GL_INCR */ - { 12927, 0x00008507 }, /* GL_INCR_WRAP */ - { 12940, 0x00008507 }, /* GL_INCR_WRAP_EXT */ - { 12957, 0x00008222 }, /* GL_INDEX */ - { 12966, 0x00008077 }, /* GL_INDEX_ARRAY */ - { 12981, 0x00008899 }, /* GL_INDEX_ARRAY_BUFFER_BINDING */ - { 13011, 0x00008899 }, /* GL_INDEX_ARRAY_BUFFER_BINDING_ARB */ - { 13045, 0x00008091 }, /* GL_INDEX_ARRAY_POINTER */ - { 13068, 0x00008086 }, /* GL_INDEX_ARRAY_STRIDE */ - { 13090, 0x00008085 }, /* GL_INDEX_ARRAY_TYPE */ - { 13110, 0x00000D51 }, /* GL_INDEX_BITS */ - { 13124, 0x00000C20 }, /* GL_INDEX_CLEAR_VALUE */ - { 13145, 0x00000BF1 }, /* GL_INDEX_LOGIC_OP */ - { 13163, 0x00000C30 }, /* GL_INDEX_MODE */ - { 13177, 0x00000D13 }, /* GL_INDEX_OFFSET */ - { 13193, 0x00000D12 }, /* GL_INDEX_SHIFT */ - { 13208, 0x00000C21 }, /* GL_INDEX_WRITEMASK */ - { 13227, 0x00008B84 }, /* GL_INFO_LOG_LENGTH */ - { 13246, 0x00001404 }, /* GL_INT */ - { 13253, 0x00008049 }, /* GL_INTENSITY */ - { 13266, 0x0000804C }, /* GL_INTENSITY12 */ - { 13281, 0x0000804C }, /* GL_INTENSITY12_EXT */ - { 13300, 0x0000804D }, /* GL_INTENSITY16 */ - { 13315, 0x0000804D }, /* GL_INTENSITY16_EXT */ - { 13334, 0x0000804A }, /* GL_INTENSITY4 */ - { 13348, 0x0000804A }, /* GL_INTENSITY4_EXT */ - { 13366, 0x0000804B }, /* GL_INTENSITY8 */ - { 13380, 0x0000804B }, /* GL_INTENSITY8_EXT */ - { 13398, 0x00008049 }, /* GL_INTENSITY_EXT */ - { 13415, 0x00008575 }, /* GL_INTERPOLATE */ - { 13430, 0x00008575 }, /* GL_INTERPOLATE_ARB */ - { 13449, 0x00008575 }, /* GL_INTERPOLATE_EXT */ - { 13468, 0x00008B53 }, /* GL_INT_VEC2 */ - { 13480, 0x00008B53 }, /* GL_INT_VEC2_ARB */ - { 13496, 0x00008B54 }, /* GL_INT_VEC3 */ - { 13508, 0x00008B54 }, /* GL_INT_VEC3_ARB */ - { 13524, 0x00008B55 }, /* GL_INT_VEC4 */ - { 13536, 0x00008B55 }, /* GL_INT_VEC4_ARB */ - { 13552, 0x00000500 }, /* GL_INVALID_ENUM */ - { 13568, 0x00000506 }, /* GL_INVALID_FRAMEBUFFER_OPERATION */ - { 13601, 0x00000506 }, /* GL_INVALID_FRAMEBUFFER_OPERATION_EXT */ - { 13638, 0x00000502 }, /* GL_INVALID_OPERATION */ - { 13659, 0x00000501 }, /* GL_INVALID_VALUE */ - { 13676, 0x0000862B }, /* GL_INVERSE_NV */ - { 13690, 0x0000862D }, /* GL_INVERSE_TRANSPOSE_NV */ - { 13714, 0x0000150A }, /* GL_INVERT */ - { 13724, 0x00001E00 }, /* GL_KEEP */ - { 13732, 0x00000406 }, /* GL_LEFT */ - { 13740, 0x00000203 }, /* GL_LEQUAL */ - { 13750, 0x00000201 }, /* GL_LESS */ - { 13758, 0x00004000 }, /* GL_LIGHT0 */ - { 13768, 0x00004001 }, /* GL_LIGHT1 */ - { 13778, 0x00004002 }, /* GL_LIGHT2 */ - { 13788, 0x00004003 }, /* GL_LIGHT3 */ - { 13798, 0x00004004 }, /* GL_LIGHT4 */ - { 13808, 0x00004005 }, /* GL_LIGHT5 */ - { 13818, 0x00004006 }, /* GL_LIGHT6 */ - { 13828, 0x00004007 }, /* GL_LIGHT7 */ - { 13838, 0x00000B50 }, /* GL_LIGHTING */ - { 13850, 0x00000040 }, /* GL_LIGHTING_BIT */ - { 13866, 0x00000B53 }, /* GL_LIGHT_MODEL_AMBIENT */ - { 13889, 0x000081F8 }, /* GL_LIGHT_MODEL_COLOR_CONTROL */ - { 13918, 0x000081F8 }, /* GL_LIGHT_MODEL_COLOR_CONTROL_EXT */ - { 13951, 0x00000B51 }, /* GL_LIGHT_MODEL_LOCAL_VIEWER */ - { 13979, 0x00000B52 }, /* GL_LIGHT_MODEL_TWO_SIDE */ - { 14003, 0x00001B01 }, /* GL_LINE */ - { 14011, 0x00002601 }, /* GL_LINEAR */ - { 14021, 0x00001208 }, /* GL_LINEAR_ATTENUATION */ - { 14043, 0x00008170 }, /* GL_LINEAR_CLIPMAP_LINEAR_SGIX */ - { 14073, 0x0000844F }, /* GL_LINEAR_CLIPMAP_NEAREST_SGIX */ - { 14104, 0x00002703 }, /* GL_LINEAR_MIPMAP_LINEAR */ - { 14128, 0x00002701 }, /* GL_LINEAR_MIPMAP_NEAREST */ - { 14153, 0x00000001 }, /* GL_LINES */ - { 14162, 0x00000004 }, /* GL_LINE_BIT */ - { 14174, 0x00000002 }, /* GL_LINE_LOOP */ - { 14187, 0x00000707 }, /* GL_LINE_RESET_TOKEN */ - { 14207, 0x00000B20 }, /* GL_LINE_SMOOTH */ - { 14222, 0x00000C52 }, /* GL_LINE_SMOOTH_HINT */ - { 14242, 0x00000B24 }, /* GL_LINE_STIPPLE */ - { 14258, 0x00000B25 }, /* GL_LINE_STIPPLE_PATTERN */ - { 14282, 0x00000B26 }, /* GL_LINE_STIPPLE_REPEAT */ - { 14305, 0x00000003 }, /* GL_LINE_STRIP */ - { 14319, 0x00000702 }, /* GL_LINE_TOKEN */ - { 14333, 0x00000B21 }, /* GL_LINE_WIDTH */ - { 14347, 0x00000B23 }, /* GL_LINE_WIDTH_GRANULARITY */ - { 14373, 0x00000B22 }, /* GL_LINE_WIDTH_RANGE */ - { 14393, 0x00008B82 }, /* GL_LINK_STATUS */ - { 14408, 0x00000B32 }, /* GL_LIST_BASE */ - { 14421, 0x00020000 }, /* GL_LIST_BIT */ - { 14433, 0x00000B33 }, /* GL_LIST_INDEX */ - { 14447, 0x00000B30 }, /* GL_LIST_MODE */ - { 14460, 0x00000101 }, /* GL_LOAD */ - { 14468, 0x00000BF1 }, /* GL_LOGIC_OP */ - { 14480, 0x00000BF0 }, /* GL_LOGIC_OP_MODE */ - { 14497, 0x00008CA1 }, /* GL_LOWER_LEFT */ - { 14511, 0x00001909 }, /* GL_LUMINANCE */ - { 14524, 0x00008041 }, /* GL_LUMINANCE12 */ - { 14539, 0x00008047 }, /* GL_LUMINANCE12_ALPHA12 */ - { 14562, 0x00008047 }, /* GL_LUMINANCE12_ALPHA12_EXT */ - { 14589, 0x00008046 }, /* GL_LUMINANCE12_ALPHA4 */ - { 14611, 0x00008046 }, /* GL_LUMINANCE12_ALPHA4_EXT */ - { 14637, 0x00008041 }, /* GL_LUMINANCE12_EXT */ - { 14656, 0x00008042 }, /* GL_LUMINANCE16 */ - { 14671, 0x00008048 }, /* GL_LUMINANCE16_ALPHA16 */ - { 14694, 0x00008048 }, /* GL_LUMINANCE16_ALPHA16_EXT */ - { 14721, 0x00008042 }, /* GL_LUMINANCE16_EXT */ - { 14740, 0x0000803F }, /* GL_LUMINANCE4 */ - { 14754, 0x00008043 }, /* GL_LUMINANCE4_ALPHA4 */ - { 14775, 0x00008043 }, /* GL_LUMINANCE4_ALPHA4_EXT */ - { 14800, 0x0000803F }, /* GL_LUMINANCE4_EXT */ - { 14818, 0x00008044 }, /* GL_LUMINANCE6_ALPHA2 */ - { 14839, 0x00008044 }, /* GL_LUMINANCE6_ALPHA2_EXT */ - { 14864, 0x00008040 }, /* GL_LUMINANCE8 */ - { 14878, 0x00008045 }, /* GL_LUMINANCE8_ALPHA8 */ - { 14899, 0x00008045 }, /* GL_LUMINANCE8_ALPHA8_EXT */ - { 14924, 0x00008040 }, /* GL_LUMINANCE8_EXT */ - { 14942, 0x0000190A }, /* GL_LUMINANCE_ALPHA */ - { 14961, 0x00000D90 }, /* GL_MAP1_COLOR_4 */ - { 14977, 0x00000DD0 }, /* GL_MAP1_GRID_DOMAIN */ - { 14997, 0x00000DD1 }, /* GL_MAP1_GRID_SEGMENTS */ - { 15019, 0x00000D91 }, /* GL_MAP1_INDEX */ - { 15033, 0x00000D92 }, /* GL_MAP1_NORMAL */ - { 15048, 0x00000D93 }, /* GL_MAP1_TEXTURE_COORD_1 */ - { 15072, 0x00000D94 }, /* GL_MAP1_TEXTURE_COORD_2 */ - { 15096, 0x00000D95 }, /* GL_MAP1_TEXTURE_COORD_3 */ - { 15120, 0x00000D96 }, /* GL_MAP1_TEXTURE_COORD_4 */ - { 15144, 0x00000D97 }, /* GL_MAP1_VERTEX_3 */ - { 15161, 0x00000D98 }, /* GL_MAP1_VERTEX_4 */ - { 15178, 0x00008660 }, /* GL_MAP1_VERTEX_ATTRIB0_4_NV */ - { 15206, 0x0000866A }, /* GL_MAP1_VERTEX_ATTRIB10_4_NV */ - { 15235, 0x0000866B }, /* GL_MAP1_VERTEX_ATTRIB11_4_NV */ - { 15264, 0x0000866C }, /* GL_MAP1_VERTEX_ATTRIB12_4_NV */ - { 15293, 0x0000866D }, /* GL_MAP1_VERTEX_ATTRIB13_4_NV */ - { 15322, 0x0000866E }, /* GL_MAP1_VERTEX_ATTRIB14_4_NV */ - { 15351, 0x0000866F }, /* GL_MAP1_VERTEX_ATTRIB15_4_NV */ - { 15380, 0x00008661 }, /* GL_MAP1_VERTEX_ATTRIB1_4_NV */ - { 15408, 0x00008662 }, /* GL_MAP1_VERTEX_ATTRIB2_4_NV */ - { 15436, 0x00008663 }, /* GL_MAP1_VERTEX_ATTRIB3_4_NV */ - { 15464, 0x00008664 }, /* GL_MAP1_VERTEX_ATTRIB4_4_NV */ - { 15492, 0x00008665 }, /* GL_MAP1_VERTEX_ATTRIB5_4_NV */ - { 15520, 0x00008666 }, /* GL_MAP1_VERTEX_ATTRIB6_4_NV */ - { 15548, 0x00008667 }, /* GL_MAP1_VERTEX_ATTRIB7_4_NV */ - { 15576, 0x00008668 }, /* GL_MAP1_VERTEX_ATTRIB8_4_NV */ - { 15604, 0x00008669 }, /* GL_MAP1_VERTEX_ATTRIB9_4_NV */ - { 15632, 0x00000DB0 }, /* GL_MAP2_COLOR_4 */ - { 15648, 0x00000DD2 }, /* GL_MAP2_GRID_DOMAIN */ - { 15668, 0x00000DD3 }, /* GL_MAP2_GRID_SEGMENTS */ - { 15690, 0x00000DB1 }, /* GL_MAP2_INDEX */ - { 15704, 0x00000DB2 }, /* GL_MAP2_NORMAL */ - { 15719, 0x00000DB3 }, /* GL_MAP2_TEXTURE_COORD_1 */ - { 15743, 0x00000DB4 }, /* GL_MAP2_TEXTURE_COORD_2 */ - { 15767, 0x00000DB5 }, /* GL_MAP2_TEXTURE_COORD_3 */ - { 15791, 0x00000DB6 }, /* GL_MAP2_TEXTURE_COORD_4 */ - { 15815, 0x00000DB7 }, /* GL_MAP2_VERTEX_3 */ - { 15832, 0x00000DB8 }, /* GL_MAP2_VERTEX_4 */ - { 15849, 0x00008670 }, /* GL_MAP2_VERTEX_ATTRIB0_4_NV */ - { 15877, 0x0000867A }, /* GL_MAP2_VERTEX_ATTRIB10_4_NV */ - { 15906, 0x0000867B }, /* GL_MAP2_VERTEX_ATTRIB11_4_NV */ - { 15935, 0x0000867C }, /* GL_MAP2_VERTEX_ATTRIB12_4_NV */ - { 15964, 0x0000867D }, /* GL_MAP2_VERTEX_ATTRIB13_4_NV */ - { 15993, 0x0000867E }, /* GL_MAP2_VERTEX_ATTRIB14_4_NV */ - { 16022, 0x0000867F }, /* GL_MAP2_VERTEX_ATTRIB15_4_NV */ - { 16051, 0x00008671 }, /* GL_MAP2_VERTEX_ATTRIB1_4_NV */ - { 16079, 0x00008672 }, /* GL_MAP2_VERTEX_ATTRIB2_4_NV */ - { 16107, 0x00008673 }, /* GL_MAP2_VERTEX_ATTRIB3_4_NV */ - { 16135, 0x00008674 }, /* GL_MAP2_VERTEX_ATTRIB4_4_NV */ - { 16163, 0x00008675 }, /* GL_MAP2_VERTEX_ATTRIB5_4_NV */ - { 16191, 0x00008676 }, /* GL_MAP2_VERTEX_ATTRIB6_4_NV */ - { 16219, 0x00008677 }, /* GL_MAP2_VERTEX_ATTRIB7_4_NV */ - { 16247, 0x00008678 }, /* GL_MAP2_VERTEX_ATTRIB8_4_NV */ - { 16275, 0x00008679 }, /* GL_MAP2_VERTEX_ATTRIB9_4_NV */ - { 16303, 0x00000D10 }, /* GL_MAP_COLOR */ - { 16316, 0x00000D11 }, /* GL_MAP_STENCIL */ - { 16331, 0x000088C0 }, /* GL_MATRIX0_ARB */ - { 16346, 0x00008630 }, /* GL_MATRIX0_NV */ - { 16360, 0x000088CA }, /* GL_MATRIX10_ARB */ - { 16376, 0x000088CB }, /* GL_MATRIX11_ARB */ - { 16392, 0x000088CC }, /* GL_MATRIX12_ARB */ - { 16408, 0x000088CD }, /* GL_MATRIX13_ARB */ - { 16424, 0x000088CE }, /* GL_MATRIX14_ARB */ - { 16440, 0x000088CF }, /* GL_MATRIX15_ARB */ - { 16456, 0x000088D0 }, /* GL_MATRIX16_ARB */ - { 16472, 0x000088D1 }, /* GL_MATRIX17_ARB */ - { 16488, 0x000088D2 }, /* GL_MATRIX18_ARB */ - { 16504, 0x000088D3 }, /* GL_MATRIX19_ARB */ - { 16520, 0x000088C1 }, /* GL_MATRIX1_ARB */ - { 16535, 0x00008631 }, /* GL_MATRIX1_NV */ - { 16549, 0x000088D4 }, /* GL_MATRIX20_ARB */ - { 16565, 0x000088D5 }, /* GL_MATRIX21_ARB */ - { 16581, 0x000088D6 }, /* GL_MATRIX22_ARB */ - { 16597, 0x000088D7 }, /* GL_MATRIX23_ARB */ - { 16613, 0x000088D8 }, /* GL_MATRIX24_ARB */ - { 16629, 0x000088D9 }, /* GL_MATRIX25_ARB */ - { 16645, 0x000088DA }, /* GL_MATRIX26_ARB */ - { 16661, 0x000088DB }, /* GL_MATRIX27_ARB */ - { 16677, 0x000088DC }, /* GL_MATRIX28_ARB */ - { 16693, 0x000088DD }, /* GL_MATRIX29_ARB */ - { 16709, 0x000088C2 }, /* GL_MATRIX2_ARB */ - { 16724, 0x00008632 }, /* GL_MATRIX2_NV */ - { 16738, 0x000088DE }, /* GL_MATRIX30_ARB */ - { 16754, 0x000088DF }, /* GL_MATRIX31_ARB */ - { 16770, 0x000088C3 }, /* GL_MATRIX3_ARB */ - { 16785, 0x00008633 }, /* GL_MATRIX3_NV */ - { 16799, 0x000088C4 }, /* GL_MATRIX4_ARB */ - { 16814, 0x00008634 }, /* GL_MATRIX4_NV */ - { 16828, 0x000088C5 }, /* GL_MATRIX5_ARB */ - { 16843, 0x00008635 }, /* GL_MATRIX5_NV */ - { 16857, 0x000088C6 }, /* GL_MATRIX6_ARB */ - { 16872, 0x00008636 }, /* GL_MATRIX6_NV */ - { 16886, 0x000088C7 }, /* GL_MATRIX7_ARB */ - { 16901, 0x00008637 }, /* GL_MATRIX7_NV */ - { 16915, 0x000088C8 }, /* GL_MATRIX8_ARB */ - { 16930, 0x000088C9 }, /* GL_MATRIX9_ARB */ - { 16945, 0x00008844 }, /* GL_MATRIX_INDEX_ARRAY_ARB */ - { 16971, 0x00008849 }, /* GL_MATRIX_INDEX_ARRAY_POINTER_ARB */ - { 17005, 0x00008846 }, /* GL_MATRIX_INDEX_ARRAY_SIZE_ARB */ - { 17036, 0x00008848 }, /* GL_MATRIX_INDEX_ARRAY_STRIDE_ARB */ - { 17069, 0x00008847 }, /* GL_MATRIX_INDEX_ARRAY_TYPE_ARB */ - { 17100, 0x00000BA0 }, /* GL_MATRIX_MODE */ - { 17115, 0x00008840 }, /* GL_MATRIX_PALETTE_ARB */ - { 17137, 0x00008008 }, /* GL_MAX */ - { 17144, 0x00008073 }, /* GL_MAX_3D_TEXTURE_SIZE */ - { 17167, 0x000088FF }, /* GL_MAX_ARRAY_TEXTURE_LAYERS_EXT */ - { 17199, 0x00000D35 }, /* GL_MAX_ATTRIB_STACK_DEPTH */ - { 17225, 0x00000D3B }, /* GL_MAX_CLIENT_ATTRIB_STACK_DEPTH */ - { 17258, 0x00008177 }, /* GL_MAX_CLIPMAP_DEPTH_SGIX */ - { 17284, 0x00008178 }, /* GL_MAX_CLIPMAP_VIRTUAL_DEPTH_SGIX */ - { 17318, 0x00000D32 }, /* GL_MAX_CLIP_PLANES */ - { 17337, 0x00008CDF }, /* GL_MAX_COLOR_ATTACHMENTS_EXT */ - { 17366, 0x000080B3 }, /* GL_MAX_COLOR_MATRIX_STACK_DEPTH */ - { 17398, 0x000080B3 }, /* GL_MAX_COLOR_MATRIX_STACK_DEPTH_SGI */ - { 17434, 0x00008B4D }, /* GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS */ - { 17470, 0x00008B4D }, /* GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS_ARB */ - { 17510, 0x0000801B }, /* GL_MAX_CONVOLUTION_HEIGHT */ - { 17536, 0x0000801B }, /* GL_MAX_CONVOLUTION_HEIGHT_EXT */ - { 17566, 0x0000801A }, /* GL_MAX_CONVOLUTION_WIDTH */ - { 17591, 0x0000801A }, /* GL_MAX_CONVOLUTION_WIDTH_EXT */ - { 17620, 0x0000851C }, /* GL_MAX_CUBE_MAP_TEXTURE_SIZE */ - { 17649, 0x0000851C }, /* GL_MAX_CUBE_MAP_TEXTURE_SIZE_ARB */ - { 17682, 0x00008824 }, /* GL_MAX_DRAW_BUFFERS */ - { 17702, 0x00008824 }, /* GL_MAX_DRAW_BUFFERS_ARB */ - { 17726, 0x00008824 }, /* GL_MAX_DRAW_BUFFERS_ATI */ - { 17750, 0x000080E9 }, /* GL_MAX_ELEMENTS_INDICES */ - { 17774, 0x000080E8 }, /* GL_MAX_ELEMENTS_VERTICES */ - { 17799, 0x00000D30 }, /* GL_MAX_EVAL_ORDER */ - { 17817, 0x00008008 }, /* GL_MAX_EXT */ - { 17828, 0x00008B49 }, /* GL_MAX_FRAGMENT_UNIFORM_COMPONENTS */ - { 17863, 0x00008B49 }, /* GL_MAX_FRAGMENT_UNIFORM_COMPONENTS_ARB */ - { 17902, 0x00000D31 }, /* GL_MAX_LIGHTS */ - { 17916, 0x00000B31 }, /* GL_MAX_LIST_NESTING */ - { 17936, 0x00008841 }, /* GL_MAX_MATRIX_PALETTE_STACK_DEPTH_ARB */ - { 17974, 0x00000D36 }, /* GL_MAX_MODELVIEW_STACK_DEPTH */ - { 18003, 0x00000D37 }, /* GL_MAX_NAME_STACK_DEPTH */ - { 18027, 0x00008842 }, /* GL_MAX_PALETTE_MATRICES_ARB */ - { 18055, 0x00000D34 }, /* GL_MAX_PIXEL_MAP_TABLE */ - { 18078, 0x000088B1 }, /* GL_MAX_PROGRAM_ADDRESS_REGISTERS_ARB */ - { 18115, 0x0000880B }, /* GL_MAX_PROGRAM_ALU_INSTRUCTIONS_ARB */ - { 18151, 0x000088AD }, /* GL_MAX_PROGRAM_ATTRIBS_ARB */ - { 18178, 0x000088F5 }, /* GL_MAX_PROGRAM_CALL_DEPTH_NV */ - { 18207, 0x000088B5 }, /* GL_MAX_PROGRAM_ENV_PARAMETERS_ARB */ - { 18241, 0x000088F4 }, /* GL_MAX_PROGRAM_EXEC_INSTRUCTIONS_NV */ - { 18277, 0x000088F6 }, /* GL_MAX_PROGRAM_IF_DEPTH_NV */ - { 18304, 0x000088A1 }, /* GL_MAX_PROGRAM_INSTRUCTIONS_ARB */ - { 18336, 0x000088B4 }, /* GL_MAX_PROGRAM_LOCAL_PARAMETERS_ARB */ - { 18372, 0x000088F8 }, /* GL_MAX_PROGRAM_LOOP_COUNT_NV */ - { 18401, 0x000088F7 }, /* GL_MAX_PROGRAM_LOOP_DEPTH_NV */ - { 18430, 0x0000862F }, /* GL_MAX_PROGRAM_MATRICES_ARB */ - { 18458, 0x0000862E }, /* GL_MAX_PROGRAM_MATRIX_STACK_DEPTH_ARB */ - { 18496, 0x000088B3 }, /* GL_MAX_PROGRAM_NATIVE_ADDRESS_REGISTERS_ARB */ - { 18540, 0x0000880E }, /* GL_MAX_PROGRAM_NATIVE_ALU_INSTRUCTIONS_ARB */ - { 18583, 0x000088AF }, /* GL_MAX_PROGRAM_NATIVE_ATTRIBS_ARB */ - { 18617, 0x000088A3 }, /* GL_MAX_PROGRAM_NATIVE_INSTRUCTIONS_ARB */ - { 18656, 0x000088AB }, /* GL_MAX_PROGRAM_NATIVE_PARAMETERS_ARB */ - { 18693, 0x000088A7 }, /* GL_MAX_PROGRAM_NATIVE_TEMPORARIES_ARB */ - { 18731, 0x00008810 }, /* GL_MAX_PROGRAM_NATIVE_TEX_INDIRECTIONS_ARB */ - { 18774, 0x0000880F }, /* GL_MAX_PROGRAM_NATIVE_TEX_INSTRUCTIONS_ARB */ - { 18817, 0x000088A9 }, /* GL_MAX_PROGRAM_PARAMETERS_ARB */ - { 18847, 0x000088A5 }, /* GL_MAX_PROGRAM_TEMPORARIES_ARB */ - { 18878, 0x0000880D }, /* GL_MAX_PROGRAM_TEX_INDIRECTIONS_ARB */ - { 18914, 0x0000880C }, /* GL_MAX_PROGRAM_TEX_INSTRUCTIONS_ARB */ - { 18950, 0x00000D38 }, /* GL_MAX_PROJECTION_STACK_DEPTH */ - { 18980, 0x000084F8 }, /* GL_MAX_RECTANGLE_TEXTURE_SIZE_ARB */ - { 19014, 0x000084F8 }, /* GL_MAX_RECTANGLE_TEXTURE_SIZE_NV */ - { 19047, 0x000084E8 }, /* GL_MAX_RENDERBUFFER_SIZE_EXT */ - { 19076, 0x00008D57 }, /* GL_MAX_SAMPLES */ - { 19091, 0x00008504 }, /* GL_MAX_SHININESS_NV */ - { 19111, 0x00008505 }, /* GL_MAX_SPOT_EXPONENT_NV */ - { 19135, 0x00008871 }, /* GL_MAX_TEXTURE_COORDS */ - { 19157, 0x00008871 }, /* GL_MAX_TEXTURE_COORDS_ARB */ - { 19183, 0x00008872 }, /* GL_MAX_TEXTURE_IMAGE_UNITS */ - { 19210, 0x00008872 }, /* GL_MAX_TEXTURE_IMAGE_UNITS_ARB */ - { 19241, 0x000084FD }, /* GL_MAX_TEXTURE_LOD_BIAS */ - { 19265, 0x000084FF }, /* GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT */ - { 19299, 0x00000D33 }, /* GL_MAX_TEXTURE_SIZE */ - { 19319, 0x00000D39 }, /* GL_MAX_TEXTURE_STACK_DEPTH */ - { 19346, 0x000084E2 }, /* GL_MAX_TEXTURE_UNITS */ - { 19367, 0x000084E2 }, /* GL_MAX_TEXTURE_UNITS_ARB */ - { 19392, 0x0000862F }, /* GL_MAX_TRACK_MATRICES_NV */ - { 19417, 0x0000862E }, /* GL_MAX_TRACK_MATRIX_STACK_DEPTH_NV */ - { 19452, 0x00008B4B }, /* GL_MAX_VARYING_FLOATS */ - { 19474, 0x00008B4B }, /* GL_MAX_VARYING_FLOATS_ARB */ - { 19500, 0x00008869 }, /* GL_MAX_VERTEX_ATTRIBS */ - { 19522, 0x00008869 }, /* GL_MAX_VERTEX_ATTRIBS_ARB */ - { 19548, 0x00008B4C }, /* GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS */ - { 19582, 0x00008B4C }, /* GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS_ARB */ - { 19620, 0x00008B4A }, /* GL_MAX_VERTEX_UNIFORM_COMPONENTS */ - { 19653, 0x00008B4A }, /* GL_MAX_VERTEX_UNIFORM_COMPONENTS_ARB */ - { 19690, 0x000086A4 }, /* GL_MAX_VERTEX_UNITS_ARB */ - { 19714, 0x00000D3A }, /* GL_MAX_VIEWPORT_DIMS */ - { 19735, 0x00008007 }, /* GL_MIN */ - { 19742, 0x0000802E }, /* GL_MINMAX */ - { 19752, 0x0000802E }, /* GL_MINMAX_EXT */ - { 19766, 0x0000802F }, /* GL_MINMAX_FORMAT */ - { 19783, 0x0000802F }, /* GL_MINMAX_FORMAT_EXT */ - { 19804, 0x00008030 }, /* GL_MINMAX_SINK */ - { 19819, 0x00008030 }, /* GL_MINMAX_SINK_EXT */ - { 19838, 0x00008007 }, /* GL_MIN_EXT */ - { 19849, 0x00008370 }, /* GL_MIRRORED_REPEAT */ - { 19868, 0x00008370 }, /* GL_MIRRORED_REPEAT_ARB */ - { 19891, 0x00008370 }, /* GL_MIRRORED_REPEAT_IBM */ - { 19914, 0x00008742 }, /* GL_MIRROR_CLAMP_ATI */ - { 19934, 0x00008742 }, /* GL_MIRROR_CLAMP_EXT */ - { 19954, 0x00008912 }, /* GL_MIRROR_CLAMP_TO_BORDER_EXT */ - { 19984, 0x00008743 }, /* GL_MIRROR_CLAMP_TO_EDGE_ATI */ - { 20012, 0x00008743 }, /* GL_MIRROR_CLAMP_TO_EDGE_EXT */ - { 20040, 0x00001700 }, /* GL_MODELVIEW */ - { 20053, 0x00001700 }, /* GL_MODELVIEW0_ARB */ - { 20071, 0x0000872A }, /* GL_MODELVIEW10_ARB */ - { 20090, 0x0000872B }, /* GL_MODELVIEW11_ARB */ - { 20109, 0x0000872C }, /* GL_MODELVIEW12_ARB */ - { 20128, 0x0000872D }, /* GL_MODELVIEW13_ARB */ - { 20147, 0x0000872E }, /* GL_MODELVIEW14_ARB */ - { 20166, 0x0000872F }, /* GL_MODELVIEW15_ARB */ - { 20185, 0x00008730 }, /* GL_MODELVIEW16_ARB */ - { 20204, 0x00008731 }, /* GL_MODELVIEW17_ARB */ - { 20223, 0x00008732 }, /* GL_MODELVIEW18_ARB */ - { 20242, 0x00008733 }, /* GL_MODELVIEW19_ARB */ - { 20261, 0x0000850A }, /* GL_MODELVIEW1_ARB */ - { 20279, 0x00008734 }, /* GL_MODELVIEW20_ARB */ - { 20298, 0x00008735 }, /* GL_MODELVIEW21_ARB */ - { 20317, 0x00008736 }, /* GL_MODELVIEW22_ARB */ - { 20336, 0x00008737 }, /* GL_MODELVIEW23_ARB */ - { 20355, 0x00008738 }, /* GL_MODELVIEW24_ARB */ - { 20374, 0x00008739 }, /* GL_MODELVIEW25_ARB */ - { 20393, 0x0000873A }, /* GL_MODELVIEW26_ARB */ - { 20412, 0x0000873B }, /* GL_MODELVIEW27_ARB */ - { 20431, 0x0000873C }, /* GL_MODELVIEW28_ARB */ - { 20450, 0x0000873D }, /* GL_MODELVIEW29_ARB */ - { 20469, 0x00008722 }, /* GL_MODELVIEW2_ARB */ - { 20487, 0x0000873E }, /* GL_MODELVIEW30_ARB */ - { 20506, 0x0000873F }, /* GL_MODELVIEW31_ARB */ - { 20525, 0x00008723 }, /* GL_MODELVIEW3_ARB */ - { 20543, 0x00008724 }, /* GL_MODELVIEW4_ARB */ - { 20561, 0x00008725 }, /* GL_MODELVIEW5_ARB */ - { 20579, 0x00008726 }, /* GL_MODELVIEW6_ARB */ - { 20597, 0x00008727 }, /* GL_MODELVIEW7_ARB */ - { 20615, 0x00008728 }, /* GL_MODELVIEW8_ARB */ - { 20633, 0x00008729 }, /* GL_MODELVIEW9_ARB */ - { 20651, 0x00000BA6 }, /* GL_MODELVIEW_MATRIX */ - { 20671, 0x00008629 }, /* GL_MODELVIEW_PROJECTION_NV */ - { 20698, 0x00000BA3 }, /* GL_MODELVIEW_STACK_DEPTH */ - { 20723, 0x00002100 }, /* GL_MODULATE */ - { 20735, 0x00008744 }, /* GL_MODULATE_ADD_ATI */ - { 20755, 0x00008745 }, /* GL_MODULATE_SIGNED_ADD_ATI */ - { 20782, 0x00008746 }, /* GL_MODULATE_SUBTRACT_ATI */ - { 20807, 0x00000103 }, /* GL_MULT */ - { 20815, 0x0000809D }, /* GL_MULTISAMPLE */ - { 20830, 0x000086B2 }, /* GL_MULTISAMPLE_3DFX */ - { 20850, 0x0000809D }, /* GL_MULTISAMPLE_ARB */ - { 20869, 0x20000000 }, /* GL_MULTISAMPLE_BIT */ - { 20888, 0x20000000 }, /* GL_MULTISAMPLE_BIT_3DFX */ - { 20912, 0x20000000 }, /* GL_MULTISAMPLE_BIT_ARB */ - { 20935, 0x00008534 }, /* GL_MULTISAMPLE_FILTER_HINT_NV */ - { 20965, 0x00002A25 }, /* GL_N3F_V3F */ - { 20976, 0x00000D70 }, /* GL_NAME_STACK_DEPTH */ - { 20996, 0x0000150E }, /* GL_NAND */ - { 21004, 0x00002600 }, /* GL_NEAREST */ - { 21015, 0x0000844E }, /* GL_NEAREST_CLIPMAP_LINEAR_SGIX */ - { 21046, 0x0000844D }, /* GL_NEAREST_CLIPMAP_NEAREST_SGIX */ - { 21078, 0x00002702 }, /* GL_NEAREST_MIPMAP_LINEAR */ - { 21103, 0x00002700 }, /* GL_NEAREST_MIPMAP_NEAREST */ - { 21129, 0x00000200 }, /* GL_NEVER */ - { 21138, 0x00001102 }, /* GL_NICEST */ - { 21148, 0x00000000 }, /* GL_NONE */ - { 21156, 0x00001505 }, /* GL_NOOP */ - { 21164, 0x00001508 }, /* GL_NOR */ - { 21171, 0x00000BA1 }, /* GL_NORMALIZE */ - { 21184, 0x00008075 }, /* GL_NORMAL_ARRAY */ - { 21200, 0x00008897 }, /* GL_NORMAL_ARRAY_BUFFER_BINDING */ - { 21231, 0x00008897 }, /* GL_NORMAL_ARRAY_BUFFER_BINDING_ARB */ - { 21266, 0x0000808F }, /* GL_NORMAL_ARRAY_POINTER */ - { 21290, 0x0000807F }, /* GL_NORMAL_ARRAY_STRIDE */ - { 21313, 0x0000807E }, /* GL_NORMAL_ARRAY_TYPE */ - { 21334, 0x00008511 }, /* GL_NORMAL_MAP */ - { 21348, 0x00008511 }, /* GL_NORMAL_MAP_ARB */ - { 21366, 0x00008511 }, /* GL_NORMAL_MAP_NV */ - { 21383, 0x00000205 }, /* GL_NOTEQUAL */ - { 21395, 0x00000000 }, /* GL_NO_ERROR */ - { 21407, 0x000086A2 }, /* GL_NUM_COMPRESSED_TEXTURE_FORMATS */ - { 21441, 0x000086A2 }, /* GL_NUM_COMPRESSED_TEXTURE_FORMATS_ARB */ - { 21479, 0x00008B89 }, /* GL_OBJECT_ACTIVE_ATTRIBUTES_ARB */ - { 21511, 0x00008B8A }, /* GL_OBJECT_ACTIVE_ATTRIBUTE_MAX_LENGTH_ARB */ - { 21553, 0x00008B86 }, /* GL_OBJECT_ACTIVE_UNIFORMS_ARB */ - { 21583, 0x00008B87 }, /* GL_OBJECT_ACTIVE_UNIFORM_MAX_LENGTH_ARB */ - { 21623, 0x00008B85 }, /* GL_OBJECT_ATTACHED_OBJECTS_ARB */ - { 21654, 0x00008B81 }, /* GL_OBJECT_COMPILE_STATUS_ARB */ - { 21683, 0x00008B80 }, /* GL_OBJECT_DELETE_STATUS_ARB */ - { 21711, 0x00008B84 }, /* GL_OBJECT_INFO_LOG_LENGTH_ARB */ - { 21741, 0x00002401 }, /* GL_OBJECT_LINEAR */ - { 21758, 0x00008B82 }, /* GL_OBJECT_LINK_STATUS_ARB */ - { 21784, 0x00002501 }, /* GL_OBJECT_PLANE */ - { 21800, 0x00008B88 }, /* GL_OBJECT_SHADER_SOURCE_LENGTH_ARB */ - { 21835, 0x00008B4F }, /* GL_OBJECT_SUBTYPE_ARB */ - { 21857, 0x00008B4E }, /* GL_OBJECT_TYPE_ARB */ - { 21876, 0x00008B83 }, /* GL_OBJECT_VALIDATE_STATUS_ARB */ - { 21906, 0x00008165 }, /* GL_OCCLUSION_TEST_HP */ - { 21927, 0x00008166 }, /* GL_OCCLUSION_TEST_RESULT_HP */ - { 21955, 0x00000001 }, /* GL_ONE */ - { 21962, 0x00008004 }, /* GL_ONE_MINUS_CONSTANT_ALPHA */ - { 21990, 0x00008004 }, /* GL_ONE_MINUS_CONSTANT_ALPHA_EXT */ - { 22022, 0x00008002 }, /* GL_ONE_MINUS_CONSTANT_COLOR */ - { 22050, 0x00008002 }, /* GL_ONE_MINUS_CONSTANT_COLOR_EXT */ - { 22082, 0x00000305 }, /* GL_ONE_MINUS_DST_ALPHA */ - { 22105, 0x00000307 }, /* GL_ONE_MINUS_DST_COLOR */ - { 22128, 0x00000303 }, /* GL_ONE_MINUS_SRC_ALPHA */ - { 22151, 0x00000301 }, /* GL_ONE_MINUS_SRC_COLOR */ - { 22174, 0x00008598 }, /* GL_OPERAND0_ALPHA */ - { 22192, 0x00008598 }, /* GL_OPERAND0_ALPHA_ARB */ - { 22214, 0x00008598 }, /* GL_OPERAND0_ALPHA_EXT */ - { 22236, 0x00008590 }, /* GL_OPERAND0_RGB */ - { 22252, 0x00008590 }, /* GL_OPERAND0_RGB_ARB */ - { 22272, 0x00008590 }, /* GL_OPERAND0_RGB_EXT */ - { 22292, 0x00008599 }, /* GL_OPERAND1_ALPHA */ - { 22310, 0x00008599 }, /* GL_OPERAND1_ALPHA_ARB */ - { 22332, 0x00008599 }, /* GL_OPERAND1_ALPHA_EXT */ - { 22354, 0x00008591 }, /* GL_OPERAND1_RGB */ - { 22370, 0x00008591 }, /* GL_OPERAND1_RGB_ARB */ - { 22390, 0x00008591 }, /* GL_OPERAND1_RGB_EXT */ - { 22410, 0x0000859A }, /* GL_OPERAND2_ALPHA */ - { 22428, 0x0000859A }, /* GL_OPERAND2_ALPHA_ARB */ - { 22450, 0x0000859A }, /* GL_OPERAND2_ALPHA_EXT */ - { 22472, 0x00008592 }, /* GL_OPERAND2_RGB */ - { 22488, 0x00008592 }, /* GL_OPERAND2_RGB_ARB */ - { 22508, 0x00008592 }, /* GL_OPERAND2_RGB_EXT */ - { 22528, 0x0000859B }, /* GL_OPERAND3_ALPHA_NV */ - { 22549, 0x00008593 }, /* GL_OPERAND3_RGB_NV */ - { 22568, 0x00001507 }, /* GL_OR */ - { 22574, 0x00000A01 }, /* GL_ORDER */ - { 22583, 0x0000150D }, /* GL_OR_INVERTED */ - { 22598, 0x0000150B }, /* GL_OR_REVERSE */ - { 22612, 0x00000505 }, /* GL_OUT_OF_MEMORY */ - { 22629, 0x00000D05 }, /* GL_PACK_ALIGNMENT */ - { 22647, 0x0000806C }, /* GL_PACK_IMAGE_HEIGHT */ - { 22668, 0x00008758 }, /* GL_PACK_INVERT_MESA */ - { 22688, 0x00000D01 }, /* GL_PACK_LSB_FIRST */ - { 22706, 0x00000D02 }, /* GL_PACK_ROW_LENGTH */ - { 22725, 0x0000806B }, /* GL_PACK_SKIP_IMAGES */ - { 22745, 0x00000D04 }, /* GL_PACK_SKIP_PIXELS */ - { 22765, 0x00000D03 }, /* GL_PACK_SKIP_ROWS */ - { 22783, 0x00000D00 }, /* GL_PACK_SWAP_BYTES */ - { 22802, 0x00008B92 }, /* GL_PALETTE4_R5_G6_B5_OES */ - { 22827, 0x00008B94 }, /* GL_PALETTE4_RGB5_A1_OES */ - { 22851, 0x00008B90 }, /* GL_PALETTE4_RGB8_OES */ - { 22872, 0x00008B93 }, /* GL_PALETTE4_RGBA4_OES */ - { 22894, 0x00008B91 }, /* GL_PALETTE4_RGBA8_OES */ - { 22916, 0x00008B97 }, /* GL_PALETTE8_R5_G6_B5_OES */ - { 22941, 0x00008B99 }, /* GL_PALETTE8_RGB5_A1_OES */ - { 22965, 0x00008B95 }, /* GL_PALETTE8_RGB8_OES */ - { 22986, 0x00008B98 }, /* GL_PALETTE8_RGBA4_OES */ - { 23008, 0x00008B96 }, /* GL_PALETTE8_RGBA8_OES */ - { 23030, 0x00000700 }, /* GL_PASS_THROUGH_TOKEN */ - { 23052, 0x00000C50 }, /* GL_PERSPECTIVE_CORRECTION_HINT */ - { 23083, 0x00000C79 }, /* GL_PIXEL_MAP_A_TO_A */ - { 23103, 0x00000CB9 }, /* GL_PIXEL_MAP_A_TO_A_SIZE */ - { 23128, 0x00000C78 }, /* GL_PIXEL_MAP_B_TO_B */ - { 23148, 0x00000CB8 }, /* GL_PIXEL_MAP_B_TO_B_SIZE */ - { 23173, 0x00000C77 }, /* GL_PIXEL_MAP_G_TO_G */ - { 23193, 0x00000CB7 }, /* GL_PIXEL_MAP_G_TO_G_SIZE */ - { 23218, 0x00000C75 }, /* GL_PIXEL_MAP_I_TO_A */ - { 23238, 0x00000CB5 }, /* GL_PIXEL_MAP_I_TO_A_SIZE */ - { 23263, 0x00000C74 }, /* GL_PIXEL_MAP_I_TO_B */ - { 23283, 0x00000CB4 }, /* GL_PIXEL_MAP_I_TO_B_SIZE */ - { 23308, 0x00000C73 }, /* GL_PIXEL_MAP_I_TO_G */ - { 23328, 0x00000CB3 }, /* GL_PIXEL_MAP_I_TO_G_SIZE */ - { 23353, 0x00000C70 }, /* GL_PIXEL_MAP_I_TO_I */ - { 23373, 0x00000CB0 }, /* GL_PIXEL_MAP_I_TO_I_SIZE */ - { 23398, 0x00000C72 }, /* GL_PIXEL_MAP_I_TO_R */ - { 23418, 0x00000CB2 }, /* GL_PIXEL_MAP_I_TO_R_SIZE */ - { 23443, 0x00000C76 }, /* GL_PIXEL_MAP_R_TO_R */ - { 23463, 0x00000CB6 }, /* GL_PIXEL_MAP_R_TO_R_SIZE */ - { 23488, 0x00000C71 }, /* GL_PIXEL_MAP_S_TO_S */ - { 23508, 0x00000CB1 }, /* GL_PIXEL_MAP_S_TO_S_SIZE */ - { 23533, 0x00000020 }, /* GL_PIXEL_MODE_BIT */ - { 23551, 0x000088EB }, /* GL_PIXEL_PACK_BUFFER */ - { 23572, 0x000088ED }, /* GL_PIXEL_PACK_BUFFER_BINDING */ - { 23601, 0x000088ED }, /* GL_PIXEL_PACK_BUFFER_BINDING_EXT */ - { 23634, 0x000088EB }, /* GL_PIXEL_PACK_BUFFER_EXT */ - { 23659, 0x000088EC }, /* GL_PIXEL_UNPACK_BUFFER */ - { 23682, 0x000088EF }, /* GL_PIXEL_UNPACK_BUFFER_BINDING */ - { 23713, 0x000088EF }, /* GL_PIXEL_UNPACK_BUFFER_BINDING_EXT */ - { 23748, 0x000088EC }, /* GL_PIXEL_UNPACK_BUFFER_EXT */ - { 23775, 0x00001B00 }, /* GL_POINT */ - { 23784, 0x00000000 }, /* GL_POINTS */ - { 23794, 0x00000002 }, /* GL_POINT_BIT */ - { 23807, 0x00008129 }, /* GL_POINT_DISTANCE_ATTENUATION */ - { 23837, 0x00008129 }, /* GL_POINT_DISTANCE_ATTENUATION_ARB */ - { 23871, 0x00008129 }, /* GL_POINT_DISTANCE_ATTENUATION_EXT */ - { 23905, 0x00008129 }, /* GL_POINT_DISTANCE_ATTENUATION_SGIS */ - { 23940, 0x00008128 }, /* GL_POINT_FADE_THRESHOLD_SIZE */ - { 23969, 0x00008128 }, /* GL_POINT_FADE_THRESHOLD_SIZE_ARB */ - { 24002, 0x00008128 }, /* GL_POINT_FADE_THRESHOLD_SIZE_EXT */ - { 24035, 0x00008128 }, /* GL_POINT_FADE_THRESHOLD_SIZE_SGIS */ - { 24069, 0x00000B11 }, /* GL_POINT_SIZE */ - { 24083, 0x00000B13 }, /* GL_POINT_SIZE_GRANULARITY */ - { 24109, 0x00008127 }, /* GL_POINT_SIZE_MAX */ - { 24127, 0x00008127 }, /* GL_POINT_SIZE_MAX_ARB */ - { 24149, 0x00008127 }, /* GL_POINT_SIZE_MAX_EXT */ - { 24171, 0x00008127 }, /* GL_POINT_SIZE_MAX_SGIS */ - { 24194, 0x00008126 }, /* GL_POINT_SIZE_MIN */ - { 24212, 0x00008126 }, /* GL_POINT_SIZE_MIN_ARB */ - { 24234, 0x00008126 }, /* GL_POINT_SIZE_MIN_EXT */ - { 24256, 0x00008126 }, /* GL_POINT_SIZE_MIN_SGIS */ - { 24279, 0x00000B12 }, /* GL_POINT_SIZE_RANGE */ - { 24299, 0x00000B10 }, /* GL_POINT_SMOOTH */ - { 24315, 0x00000C51 }, /* GL_POINT_SMOOTH_HINT */ - { 24336, 0x00008861 }, /* GL_POINT_SPRITE */ - { 24352, 0x00008861 }, /* GL_POINT_SPRITE_ARB */ - { 24372, 0x00008CA0 }, /* GL_POINT_SPRITE_COORD_ORIGIN */ - { 24401, 0x00008861 }, /* GL_POINT_SPRITE_NV */ - { 24420, 0x00008863 }, /* GL_POINT_SPRITE_R_MODE_NV */ - { 24446, 0x00000701 }, /* GL_POINT_TOKEN */ - { 24461, 0x00000009 }, /* GL_POLYGON */ - { 24472, 0x00000008 }, /* GL_POLYGON_BIT */ - { 24487, 0x00000B40 }, /* GL_POLYGON_MODE */ - { 24503, 0x00008039 }, /* GL_POLYGON_OFFSET_BIAS */ - { 24526, 0x00008038 }, /* GL_POLYGON_OFFSET_FACTOR */ - { 24551, 0x00008037 }, /* GL_POLYGON_OFFSET_FILL */ - { 24574, 0x00002A02 }, /* GL_POLYGON_OFFSET_LINE */ - { 24597, 0x00002A01 }, /* GL_POLYGON_OFFSET_POINT */ - { 24621, 0x00002A00 }, /* GL_POLYGON_OFFSET_UNITS */ - { 24645, 0x00000B41 }, /* GL_POLYGON_SMOOTH */ - { 24663, 0x00000C53 }, /* GL_POLYGON_SMOOTH_HINT */ - { 24686, 0x00000B42 }, /* GL_POLYGON_STIPPLE */ - { 24705, 0x00000010 }, /* GL_POLYGON_STIPPLE_BIT */ - { 24728, 0x00000703 }, /* GL_POLYGON_TOKEN */ - { 24745, 0x00001203 }, /* GL_POSITION */ - { 24757, 0x000080BB }, /* GL_POST_COLOR_MATRIX_ALPHA_BIAS */ - { 24789, 0x000080BB }, /* GL_POST_COLOR_MATRIX_ALPHA_BIAS_SGI */ - { 24825, 0x000080B7 }, /* GL_POST_COLOR_MATRIX_ALPHA_SCALE */ - { 24858, 0x000080B7 }, /* GL_POST_COLOR_MATRIX_ALPHA_SCALE_SGI */ - { 24895, 0x000080BA }, /* GL_POST_COLOR_MATRIX_BLUE_BIAS */ - { 24926, 0x000080BA }, /* GL_POST_COLOR_MATRIX_BLUE_BIAS_SGI */ - { 24961, 0x000080B6 }, /* GL_POST_COLOR_MATRIX_BLUE_SCALE */ - { 24993, 0x000080B6 }, /* GL_POST_COLOR_MATRIX_BLUE_SCALE_SGI */ - { 25029, 0x000080D2 }, /* GL_POST_COLOR_MATRIX_COLOR_TABLE */ - { 25062, 0x000080B9 }, /* GL_POST_COLOR_MATRIX_GREEN_BIAS */ - { 25094, 0x000080B9 }, /* GL_POST_COLOR_MATRIX_GREEN_BIAS_SGI */ - { 25130, 0x000080B5 }, /* GL_POST_COLOR_MATRIX_GREEN_SCALE */ - { 25163, 0x000080B5 }, /* GL_POST_COLOR_MATRIX_GREEN_SCALE_SGI */ - { 25200, 0x000080B8 }, /* GL_POST_COLOR_MATRIX_RED_BIAS */ - { 25230, 0x000080B8 }, /* GL_POST_COLOR_MATRIX_RED_BIAS_SGI */ - { 25264, 0x000080B4 }, /* GL_POST_COLOR_MATRIX_RED_SCALE */ - { 25295, 0x000080B4 }, /* GL_POST_COLOR_MATRIX_RED_SCALE_SGI */ - { 25330, 0x00008023 }, /* GL_POST_CONVOLUTION_ALPHA_BIAS */ - { 25361, 0x00008023 }, /* GL_POST_CONVOLUTION_ALPHA_BIAS_EXT */ - { 25396, 0x0000801F }, /* GL_POST_CONVOLUTION_ALPHA_SCALE */ - { 25428, 0x0000801F }, /* GL_POST_CONVOLUTION_ALPHA_SCALE_EXT */ - { 25464, 0x00008022 }, /* GL_POST_CONVOLUTION_BLUE_BIAS */ - { 25494, 0x00008022 }, /* GL_POST_CONVOLUTION_BLUE_BIAS_EXT */ - { 25528, 0x0000801E }, /* GL_POST_CONVOLUTION_BLUE_SCALE */ - { 25559, 0x0000801E }, /* GL_POST_CONVOLUTION_BLUE_SCALE_EXT */ - { 25594, 0x000080D1 }, /* GL_POST_CONVOLUTION_COLOR_TABLE */ - { 25626, 0x00008021 }, /* GL_POST_CONVOLUTION_GREEN_BIAS */ - { 25657, 0x00008021 }, /* GL_POST_CONVOLUTION_GREEN_BIAS_EXT */ - { 25692, 0x0000801D }, /* GL_POST_CONVOLUTION_GREEN_SCALE */ - { 25724, 0x0000801D }, /* GL_POST_CONVOLUTION_GREEN_SCALE_EXT */ - { 25760, 0x00008020 }, /* GL_POST_CONVOLUTION_RED_BIAS */ - { 25789, 0x00008020 }, /* GL_POST_CONVOLUTION_RED_BIAS_EXT */ - { 25822, 0x0000801C }, /* GL_POST_CONVOLUTION_RED_SCALE */ - { 25852, 0x0000801C }, /* GL_POST_CONVOLUTION_RED_SCALE_EXT */ - { 25886, 0x0000817B }, /* GL_POST_TEXTURE_FILTER_BIAS_RANGE_SGIX */ - { 25925, 0x00008179 }, /* GL_POST_TEXTURE_FILTER_BIAS_SGIX */ - { 25958, 0x0000817C }, /* GL_POST_TEXTURE_FILTER_SCALE_RANGE_SGIX */ - { 25998, 0x0000817A }, /* GL_POST_TEXTURE_FILTER_SCALE_SGIX */ - { 26032, 0x00008578 }, /* GL_PREVIOUS */ - { 26044, 0x00008578 }, /* GL_PREVIOUS_ARB */ - { 26060, 0x00008578 }, /* GL_PREVIOUS_EXT */ - { 26076, 0x00008577 }, /* GL_PRIMARY_COLOR */ - { 26093, 0x00008577 }, /* GL_PRIMARY_COLOR_ARB */ - { 26114, 0x00008577 }, /* GL_PRIMARY_COLOR_EXT */ - { 26135, 0x000088B0 }, /* GL_PROGRAM_ADDRESS_REGISTERS_ARB */ - { 26168, 0x00008805 }, /* GL_PROGRAM_ALU_INSTRUCTIONS_ARB */ - { 26200, 0x000088AC }, /* GL_PROGRAM_ATTRIBS_ARB */ - { 26223, 0x00008677 }, /* GL_PROGRAM_BINDING_ARB */ - { 26246, 0x0000864B }, /* GL_PROGRAM_ERROR_POSITION_ARB */ - { 26276, 0x0000864B }, /* GL_PROGRAM_ERROR_POSITION_NV */ - { 26305, 0x00008874 }, /* GL_PROGRAM_ERROR_STRING_ARB */ - { 26333, 0x00008876 }, /* GL_PROGRAM_FORMAT_ARB */ - { 26355, 0x00008875 }, /* GL_PROGRAM_FORMAT_ASCII_ARB */ - { 26383, 0x000088A0 }, /* GL_PROGRAM_INSTRUCTIONS_ARB */ - { 26411, 0x00008627 }, /* GL_PROGRAM_LENGTH_ARB */ - { 26433, 0x00008627 }, /* GL_PROGRAM_LENGTH_NV */ - { 26454, 0x000088B2 }, /* GL_PROGRAM_NATIVE_ADDRESS_REGISTERS_ARB */ - { 26494, 0x00008808 }, /* GL_PROGRAM_NATIVE_ALU_INSTRUCTIONS_ARB */ - { 26533, 0x000088AE }, /* GL_PROGRAM_NATIVE_ATTRIBS_ARB */ - { 26563, 0x000088A2 }, /* GL_PROGRAM_NATIVE_INSTRUCTIONS_ARB */ - { 26598, 0x000088AA }, /* GL_PROGRAM_NATIVE_PARAMETERS_ARB */ - { 26631, 0x000088A6 }, /* GL_PROGRAM_NATIVE_TEMPORARIES_ARB */ - { 26665, 0x0000880A }, /* GL_PROGRAM_NATIVE_TEX_INDIRECTIONS_ARB */ - { 26704, 0x00008809 }, /* GL_PROGRAM_NATIVE_TEX_INSTRUCTIONS_ARB */ - { 26743, 0x00008B40 }, /* GL_PROGRAM_OBJECT_ARB */ - { 26765, 0x000088A8 }, /* GL_PROGRAM_PARAMETERS_ARB */ - { 26791, 0x00008644 }, /* GL_PROGRAM_PARAMETER_NV */ - { 26815, 0x00008647 }, /* GL_PROGRAM_RESIDENT_NV */ - { 26838, 0x00008628 }, /* GL_PROGRAM_STRING_ARB */ - { 26860, 0x00008628 }, /* GL_PROGRAM_STRING_NV */ - { 26881, 0x00008646 }, /* GL_PROGRAM_TARGET_NV */ - { 26902, 0x000088A4 }, /* GL_PROGRAM_TEMPORARIES_ARB */ - { 26929, 0x00008807 }, /* GL_PROGRAM_TEX_INDIRECTIONS_ARB */ - { 26961, 0x00008806 }, /* GL_PROGRAM_TEX_INSTRUCTIONS_ARB */ - { 26993, 0x000088B6 }, /* GL_PROGRAM_UNDER_NATIVE_LIMITS_ARB */ - { 27028, 0x00001701 }, /* GL_PROJECTION */ - { 27042, 0x00000BA7 }, /* GL_PROJECTION_MATRIX */ - { 27063, 0x00000BA4 }, /* GL_PROJECTION_STACK_DEPTH */ - { 27089, 0x000080D3 }, /* GL_PROXY_COLOR_TABLE */ - { 27110, 0x00008025 }, /* GL_PROXY_HISTOGRAM */ - { 27129, 0x00008025 }, /* GL_PROXY_HISTOGRAM_EXT */ - { 27152, 0x000080D5 }, /* GL_PROXY_POST_COLOR_MATRIX_COLOR_TABLE */ - { 27191, 0x000080D4 }, /* GL_PROXY_POST_CONVOLUTION_COLOR_TABLE */ - { 27229, 0x00008063 }, /* GL_PROXY_TEXTURE_1D */ - { 27249, 0x00008C19 }, /* GL_PROXY_TEXTURE_1D_ARRAY_EXT */ - { 27279, 0x00008063 }, /* GL_PROXY_TEXTURE_1D_EXT */ - { 27303, 0x00008064 }, /* GL_PROXY_TEXTURE_2D */ - { 27323, 0x00008C1B }, /* GL_PROXY_TEXTURE_2D_ARRAY_EXT */ - { 27353, 0x00008064 }, /* GL_PROXY_TEXTURE_2D_EXT */ - { 27377, 0x00008070 }, /* GL_PROXY_TEXTURE_3D */ - { 27397, 0x000080BD }, /* GL_PROXY_TEXTURE_COLOR_TABLE_SGI */ - { 27430, 0x0000851B }, /* GL_PROXY_TEXTURE_CUBE_MAP */ - { 27456, 0x0000851B }, /* GL_PROXY_TEXTURE_CUBE_MAP_ARB */ - { 27486, 0x000084F7 }, /* GL_PROXY_TEXTURE_RECTANGLE_ARB */ - { 27517, 0x000084F7 }, /* GL_PROXY_TEXTURE_RECTANGLE_NV */ - { 27547, 0x00002003 }, /* GL_Q */ - { 27552, 0x00001209 }, /* GL_QUADRATIC_ATTENUATION */ - { 27577, 0x00000007 }, /* GL_QUADS */ - { 27586, 0x00008614 }, /* GL_QUAD_MESH_SUN */ - { 27603, 0x00000008 }, /* GL_QUAD_STRIP */ - { 27617, 0x00008864 }, /* GL_QUERY_COUNTER_BITS */ - { 27639, 0x00008864 }, /* GL_QUERY_COUNTER_BITS_ARB */ - { 27665, 0x00008866 }, /* GL_QUERY_RESULT */ - { 27681, 0x00008866 }, /* GL_QUERY_RESULT_ARB */ - { 27701, 0x00008867 }, /* GL_QUERY_RESULT_AVAILABLE */ - { 27727, 0x00008867 }, /* GL_QUERY_RESULT_AVAILABLE_ARB */ - { 27757, 0x00002002 }, /* GL_R */ - { 27762, 0x00002A10 }, /* GL_R3_G3_B2 */ - { 27774, 0x00019262 }, /* GL_RASTER_POSITION_UNCLIPPED_IBM */ - { 27807, 0x00000C02 }, /* GL_READ_BUFFER */ - { 27822, 0x00008CA8 }, /* GL_READ_FRAMEBUFFER */ - { 27842, 0x00008CAA }, /* GL_READ_FRAMEBUFFER_BINDING_EXT */ - { 27874, 0x00008CA8 }, /* GL_READ_FRAMEBUFFER_EXT */ - { 27898, 0x000088B8 }, /* GL_READ_ONLY */ - { 27911, 0x000088B8 }, /* GL_READ_ONLY_ARB */ - { 27928, 0x000088BA }, /* GL_READ_WRITE */ - { 27942, 0x000088BA }, /* GL_READ_WRITE_ARB */ - { 27960, 0x00001903 }, /* GL_RED */ - { 27967, 0x00008016 }, /* GL_REDUCE */ - { 27977, 0x00008016 }, /* GL_REDUCE_EXT */ - { 27991, 0x00000D15 }, /* GL_RED_BIAS */ - { 28003, 0x00000D52 }, /* GL_RED_BITS */ - { 28015, 0x00000D14 }, /* GL_RED_SCALE */ - { 28028, 0x00008512 }, /* GL_REFLECTION_MAP */ - { 28046, 0x00008512 }, /* GL_REFLECTION_MAP_ARB */ - { 28068, 0x00008512 }, /* GL_REFLECTION_MAP_NV */ - { 28089, 0x00001C00 }, /* GL_RENDER */ - { 28099, 0x00008D41 }, /* GL_RENDERBUFFER */ - { 28115, 0x00008D53 }, /* GL_RENDERBUFFER_ALPHA_SIZE */ - { 28142, 0x00008CA7 }, /* GL_RENDERBUFFER_BINDING_EXT */ - { 28170, 0x00008D52 }, /* GL_RENDERBUFFER_BLUE_SIZE */ - { 28196, 0x00008D54 }, /* GL_RENDERBUFFER_DEPTH_SIZE */ - { 28223, 0x00008D41 }, /* GL_RENDERBUFFER_EXT */ - { 28243, 0x00008D51 }, /* GL_RENDERBUFFER_GREEN_SIZE */ - { 28270, 0x00008D43 }, /* GL_RENDERBUFFER_HEIGHT */ - { 28293, 0x00008D43 }, /* GL_RENDERBUFFER_HEIGHT_EXT */ - { 28320, 0x00008D44 }, /* GL_RENDERBUFFER_INTERNAL_FORMAT */ - { 28352, 0x00008D44 }, /* GL_RENDERBUFFER_INTERNAL_FORMAT_EXT */ - { 28388, 0x00008D50 }, /* GL_RENDERBUFFER_RED_SIZE */ - { 28413, 0x00008CAB }, /* GL_RENDERBUFFER_SAMPLES */ - { 28437, 0x00008D55 }, /* GL_RENDERBUFFER_STENCIL_SIZE */ - { 28466, 0x00008D42 }, /* GL_RENDERBUFFER_WIDTH */ - { 28488, 0x00008D42 }, /* GL_RENDERBUFFER_WIDTH_EXT */ - { 28514, 0x00001F01 }, /* GL_RENDERER */ - { 28526, 0x00000C40 }, /* GL_RENDER_MODE */ - { 28541, 0x00002901 }, /* GL_REPEAT */ - { 28551, 0x00001E01 }, /* GL_REPLACE */ - { 28562, 0x00008062 }, /* GL_REPLACE_EXT */ - { 28577, 0x00008153 }, /* GL_REPLICATE_BORDER_HP */ - { 28600, 0x0000803A }, /* GL_RESCALE_NORMAL */ - { 28618, 0x0000803A }, /* GL_RESCALE_NORMAL_EXT */ - { 28640, 0x00000102 }, /* GL_RETURN */ - { 28650, 0x00001907 }, /* GL_RGB */ - { 28657, 0x00008052 }, /* GL_RGB10 */ - { 28666, 0x00008059 }, /* GL_RGB10_A2 */ - { 28678, 0x00008059 }, /* GL_RGB10_A2_EXT */ - { 28694, 0x00008052 }, /* GL_RGB10_EXT */ - { 28707, 0x00008053 }, /* GL_RGB12 */ - { 28716, 0x00008053 }, /* GL_RGB12_EXT */ - { 28729, 0x00008054 }, /* GL_RGB16 */ - { 28738, 0x00008054 }, /* GL_RGB16_EXT */ - { 28751, 0x0000804E }, /* GL_RGB2_EXT */ - { 28763, 0x0000804F }, /* GL_RGB4 */ - { 28771, 0x0000804F }, /* GL_RGB4_EXT */ - { 28783, 0x000083A1 }, /* GL_RGB4_S3TC */ - { 28796, 0x00008050 }, /* GL_RGB5 */ - { 28804, 0x00008057 }, /* GL_RGB5_A1 */ - { 28815, 0x00008057 }, /* GL_RGB5_A1_EXT */ - { 28830, 0x00008050 }, /* GL_RGB5_EXT */ - { 28842, 0x00008051 }, /* GL_RGB8 */ - { 28850, 0x00008051 }, /* GL_RGB8_EXT */ - { 28862, 0x00001908 }, /* GL_RGBA */ - { 28870, 0x0000805A }, /* GL_RGBA12 */ - { 28880, 0x0000805A }, /* GL_RGBA12_EXT */ - { 28894, 0x0000805B }, /* GL_RGBA16 */ - { 28904, 0x0000805B }, /* GL_RGBA16_EXT */ - { 28918, 0x00008055 }, /* GL_RGBA2 */ - { 28927, 0x00008055 }, /* GL_RGBA2_EXT */ - { 28940, 0x00008056 }, /* GL_RGBA4 */ - { 28949, 0x000083A5 }, /* GL_RGBA4_DXT5_S3TC */ - { 28968, 0x00008056 }, /* GL_RGBA4_EXT */ - { 28981, 0x000083A3 }, /* GL_RGBA4_S3TC */ - { 28995, 0x00008058 }, /* GL_RGBA8 */ - { 29004, 0x00008058 }, /* GL_RGBA8_EXT */ - { 29017, 0x00008F97 }, /* GL_RGBA8_SNORM */ - { 29032, 0x000083A4 }, /* GL_RGBA_DXT5_S3TC */ - { 29050, 0x00000C31 }, /* GL_RGBA_MODE */ - { 29063, 0x000083A2 }, /* GL_RGBA_S3TC */ - { 29076, 0x00008F93 }, /* GL_RGBA_SNORM */ - { 29090, 0x000083A0 }, /* GL_RGB_S3TC */ - { 29102, 0x00008573 }, /* GL_RGB_SCALE */ - { 29115, 0x00008573 }, /* GL_RGB_SCALE_ARB */ - { 29132, 0x00008573 }, /* GL_RGB_SCALE_EXT */ - { 29149, 0x00000407 }, /* GL_RIGHT */ - { 29158, 0x00002000 }, /* GL_S */ - { 29163, 0x00008B5D }, /* GL_SAMPLER_1D */ - { 29177, 0x00008B61 }, /* GL_SAMPLER_1D_SHADOW */ - { 29198, 0x00008B5E }, /* GL_SAMPLER_2D */ - { 29212, 0x00008B62 }, /* GL_SAMPLER_2D_SHADOW */ - { 29233, 0x00008B5F }, /* GL_SAMPLER_3D */ - { 29247, 0x00008B60 }, /* GL_SAMPLER_CUBE */ - { 29263, 0x000080A9 }, /* GL_SAMPLES */ - { 29274, 0x000086B4 }, /* GL_SAMPLES_3DFX */ - { 29290, 0x000080A9 }, /* GL_SAMPLES_ARB */ - { 29305, 0x00008914 }, /* GL_SAMPLES_PASSED */ - { 29323, 0x00008914 }, /* GL_SAMPLES_PASSED_ARB */ - { 29345, 0x0000809E }, /* GL_SAMPLE_ALPHA_TO_COVERAGE */ - { 29373, 0x0000809E }, /* GL_SAMPLE_ALPHA_TO_COVERAGE_ARB */ - { 29405, 0x0000809F }, /* GL_SAMPLE_ALPHA_TO_ONE */ - { 29428, 0x0000809F }, /* GL_SAMPLE_ALPHA_TO_ONE_ARB */ - { 29455, 0x000080A8 }, /* GL_SAMPLE_BUFFERS */ - { 29473, 0x000086B3 }, /* GL_SAMPLE_BUFFERS_3DFX */ - { 29496, 0x000080A8 }, /* GL_SAMPLE_BUFFERS_ARB */ - { 29518, 0x000080A0 }, /* GL_SAMPLE_COVERAGE */ - { 29537, 0x000080A0 }, /* GL_SAMPLE_COVERAGE_ARB */ - { 29560, 0x000080AB }, /* GL_SAMPLE_COVERAGE_INVERT */ - { 29586, 0x000080AB }, /* GL_SAMPLE_COVERAGE_INVERT_ARB */ - { 29616, 0x000080AA }, /* GL_SAMPLE_COVERAGE_VALUE */ - { 29641, 0x000080AA }, /* GL_SAMPLE_COVERAGE_VALUE_ARB */ - { 29670, 0x00080000 }, /* GL_SCISSOR_BIT */ - { 29685, 0x00000C10 }, /* GL_SCISSOR_BOX */ - { 29700, 0x00000C11 }, /* GL_SCISSOR_TEST */ - { 29716, 0x0000845E }, /* GL_SECONDARY_COLOR_ARRAY */ - { 29741, 0x0000889C }, /* GL_SECONDARY_COLOR_ARRAY_BUFFER_BINDING */ - { 29781, 0x0000889C }, /* GL_SECONDARY_COLOR_ARRAY_BUFFER_BINDING_ARB */ - { 29825, 0x0000845D }, /* GL_SECONDARY_COLOR_ARRAY_POINTER */ - { 29858, 0x0000845A }, /* GL_SECONDARY_COLOR_ARRAY_SIZE */ - { 29888, 0x0000845C }, /* GL_SECONDARY_COLOR_ARRAY_STRIDE */ - { 29920, 0x0000845B }, /* GL_SECONDARY_COLOR_ARRAY_TYPE */ - { 29950, 0x00001C02 }, /* GL_SELECT */ - { 29960, 0x00000DF3 }, /* GL_SELECTION_BUFFER_POINTER */ - { 29988, 0x00000DF4 }, /* GL_SELECTION_BUFFER_SIZE */ - { 30013, 0x00008012 }, /* GL_SEPARABLE_2D */ - { 30029, 0x000081FA }, /* GL_SEPARATE_SPECULAR_COLOR */ - { 30056, 0x000081FA }, /* GL_SEPARATE_SPECULAR_COLOR_EXT */ - { 30087, 0x0000150F }, /* GL_SET */ - { 30094, 0x00008B48 }, /* GL_SHADER_OBJECT_ARB */ - { 30115, 0x00008B88 }, /* GL_SHADER_SOURCE_LENGTH */ - { 30139, 0x00008B4F }, /* GL_SHADER_TYPE */ - { 30154, 0x00000B54 }, /* GL_SHADE_MODEL */ - { 30169, 0x00008B8C }, /* GL_SHADING_LANGUAGE_VERSION */ - { 30197, 0x000080BF }, /* GL_SHADOW_AMBIENT_SGIX */ - { 30220, 0x000081FB }, /* GL_SHARED_TEXTURE_PALETTE_EXT */ - { 30250, 0x00001601 }, /* GL_SHININESS */ - { 30263, 0x00001402 }, /* GL_SHORT */ - { 30272, 0x00008F9C }, /* GL_SIGNED_NORMALIZED */ - { 30293, 0x000081F9 }, /* GL_SINGLE_COLOR */ - { 30309, 0x000081F9 }, /* GL_SINGLE_COLOR_EXT */ - { 30329, 0x000085CC }, /* GL_SLICE_ACCUM_SUN */ - { 30348, 0x00008C46 }, /* GL_SLUMINANCE */ - { 30362, 0x00008C47 }, /* GL_SLUMINANCE8 */ - { 30377, 0x00008C45 }, /* GL_SLUMINANCE8_ALPHA8 */ - { 30399, 0x00008C44 }, /* GL_SLUMINANCE_ALPHA */ - { 30419, 0x00001D01 }, /* GL_SMOOTH */ - { 30429, 0x00000B23 }, /* GL_SMOOTH_LINE_WIDTH_GRANULARITY */ - { 30462, 0x00000B22 }, /* GL_SMOOTH_LINE_WIDTH_RANGE */ - { 30489, 0x00000B13 }, /* GL_SMOOTH_POINT_SIZE_GRANULARITY */ - { 30522, 0x00000B12 }, /* GL_SMOOTH_POINT_SIZE_RANGE */ - { 30549, 0x00008588 }, /* GL_SOURCE0_ALPHA */ - { 30566, 0x00008588 }, /* GL_SOURCE0_ALPHA_ARB */ - { 30587, 0x00008588 }, /* GL_SOURCE0_ALPHA_EXT */ - { 30608, 0x00008580 }, /* GL_SOURCE0_RGB */ - { 30623, 0x00008580 }, /* GL_SOURCE0_RGB_ARB */ - { 30642, 0x00008580 }, /* GL_SOURCE0_RGB_EXT */ - { 30661, 0x00008589 }, /* GL_SOURCE1_ALPHA */ - { 30678, 0x00008589 }, /* GL_SOURCE1_ALPHA_ARB */ - { 30699, 0x00008589 }, /* GL_SOURCE1_ALPHA_EXT */ - { 30720, 0x00008581 }, /* GL_SOURCE1_RGB */ - { 30735, 0x00008581 }, /* GL_SOURCE1_RGB_ARB */ - { 30754, 0x00008581 }, /* GL_SOURCE1_RGB_EXT */ - { 30773, 0x0000858A }, /* GL_SOURCE2_ALPHA */ - { 30790, 0x0000858A }, /* GL_SOURCE2_ALPHA_ARB */ - { 30811, 0x0000858A }, /* GL_SOURCE2_ALPHA_EXT */ - { 30832, 0x00008582 }, /* GL_SOURCE2_RGB */ - { 30847, 0x00008582 }, /* GL_SOURCE2_RGB_ARB */ - { 30866, 0x00008582 }, /* GL_SOURCE2_RGB_EXT */ - { 30885, 0x0000858B }, /* GL_SOURCE3_ALPHA_NV */ - { 30905, 0x00008583 }, /* GL_SOURCE3_RGB_NV */ - { 30923, 0x00001202 }, /* GL_SPECULAR */ - { 30935, 0x00002402 }, /* GL_SPHERE_MAP */ - { 30949, 0x00001206 }, /* GL_SPOT_CUTOFF */ - { 30964, 0x00001204 }, /* GL_SPOT_DIRECTION */ - { 30982, 0x00001205 }, /* GL_SPOT_EXPONENT */ - { 30999, 0x00008588 }, /* GL_SRC0_ALPHA */ - { 31013, 0x00008580 }, /* GL_SRC0_RGB */ - { 31025, 0x00008589 }, /* GL_SRC1_ALPHA */ - { 31039, 0x00008581 }, /* GL_SRC1_RGB */ - { 31051, 0x0000858A }, /* GL_SRC2_ALPHA */ - { 31065, 0x00008582 }, /* GL_SRC2_RGB */ - { 31077, 0x00000302 }, /* GL_SRC_ALPHA */ - { 31090, 0x00000308 }, /* GL_SRC_ALPHA_SATURATE */ - { 31112, 0x00000300 }, /* GL_SRC_COLOR */ - { 31125, 0x00008C40 }, /* GL_SRGB */ - { 31133, 0x00008C41 }, /* GL_SRGB8 */ - { 31142, 0x00008C43 }, /* GL_SRGB8_ALPHA8 */ - { 31158, 0x00008C42 }, /* GL_SRGB_ALPHA */ - { 31172, 0x00000503 }, /* GL_STACK_OVERFLOW */ - { 31190, 0x00000504 }, /* GL_STACK_UNDERFLOW */ - { 31209, 0x000088E6 }, /* GL_STATIC_COPY */ - { 31224, 0x000088E6 }, /* GL_STATIC_COPY_ARB */ - { 31243, 0x000088E4 }, /* GL_STATIC_DRAW */ - { 31258, 0x000088E4 }, /* GL_STATIC_DRAW_ARB */ - { 31277, 0x000088E5 }, /* GL_STATIC_READ */ - { 31292, 0x000088E5 }, /* GL_STATIC_READ_ARB */ - { 31311, 0x00001802 }, /* GL_STENCIL */ - { 31322, 0x00008D20 }, /* GL_STENCIL_ATTACHMENT */ - { 31344, 0x00008D20 }, /* GL_STENCIL_ATTACHMENT_EXT */ - { 31370, 0x00008801 }, /* GL_STENCIL_BACK_FAIL */ - { 31391, 0x00008801 }, /* GL_STENCIL_BACK_FAIL_ATI */ - { 31416, 0x00008800 }, /* GL_STENCIL_BACK_FUNC */ - { 31437, 0x00008800 }, /* GL_STENCIL_BACK_FUNC_ATI */ - { 31462, 0x00008802 }, /* GL_STENCIL_BACK_PASS_DEPTH_FAIL */ - { 31494, 0x00008802 }, /* GL_STENCIL_BACK_PASS_DEPTH_FAIL_ATI */ - { 31530, 0x00008803 }, /* GL_STENCIL_BACK_PASS_DEPTH_PASS */ - { 31562, 0x00008803 }, /* GL_STENCIL_BACK_PASS_DEPTH_PASS_ATI */ - { 31598, 0x00008CA3 }, /* GL_STENCIL_BACK_REF */ - { 31618, 0x00008CA4 }, /* GL_STENCIL_BACK_VALUE_MASK */ - { 31645, 0x00008CA5 }, /* GL_STENCIL_BACK_WRITEMASK */ - { 31671, 0x00000D57 }, /* GL_STENCIL_BITS */ - { 31687, 0x00000400 }, /* GL_STENCIL_BUFFER_BIT */ - { 31709, 0x00000B91 }, /* GL_STENCIL_CLEAR_VALUE */ - { 31732, 0x00000B94 }, /* GL_STENCIL_FAIL */ - { 31748, 0x00000B92 }, /* GL_STENCIL_FUNC */ - { 31764, 0x00001901 }, /* GL_STENCIL_INDEX */ - { 31781, 0x00008D49 }, /* GL_STENCIL_INDEX16_EXT */ - { 31804, 0x00008D46 }, /* GL_STENCIL_INDEX1_EXT */ - { 31826, 0x00008D47 }, /* GL_STENCIL_INDEX4_EXT */ - { 31848, 0x00008D48 }, /* GL_STENCIL_INDEX8_EXT */ - { 31870, 0x00008D45 }, /* GL_STENCIL_INDEX_EXT */ - { 31891, 0x00000B95 }, /* GL_STENCIL_PASS_DEPTH_FAIL */ - { 31918, 0x00000B96 }, /* GL_STENCIL_PASS_DEPTH_PASS */ - { 31945, 0x00000B97 }, /* GL_STENCIL_REF */ - { 31960, 0x00000B90 }, /* GL_STENCIL_TEST */ - { 31976, 0x00008910 }, /* GL_STENCIL_TEST_TWO_SIDE_EXT */ - { 32005, 0x00000B93 }, /* GL_STENCIL_VALUE_MASK */ - { 32027, 0x00000B98 }, /* GL_STENCIL_WRITEMASK */ - { 32048, 0x00000C33 }, /* GL_STEREO */ - { 32058, 0x000088E2 }, /* GL_STREAM_COPY */ - { 32073, 0x000088E2 }, /* GL_STREAM_COPY_ARB */ - { 32092, 0x000088E0 }, /* GL_STREAM_DRAW */ - { 32107, 0x000088E0 }, /* GL_STREAM_DRAW_ARB */ - { 32126, 0x000088E1 }, /* GL_STREAM_READ */ - { 32141, 0x000088E1 }, /* GL_STREAM_READ_ARB */ - { 32160, 0x00000D50 }, /* GL_SUBPIXEL_BITS */ - { 32177, 0x000084E7 }, /* GL_SUBTRACT */ - { 32189, 0x000084E7 }, /* GL_SUBTRACT_ARB */ - { 32205, 0x00002001 }, /* GL_T */ - { 32210, 0x00002A2A }, /* GL_T2F_C3F_V3F */ - { 32225, 0x00002A2C }, /* GL_T2F_C4F_N3F_V3F */ - { 32244, 0x00002A29 }, /* GL_T2F_C4UB_V3F */ - { 32260, 0x00002A2B }, /* GL_T2F_N3F_V3F */ - { 32275, 0x00002A27 }, /* GL_T2F_V3F */ - { 32286, 0x00002A2D }, /* GL_T4F_C4F_N3F_V4F */ - { 32305, 0x00002A28 }, /* GL_T4F_V4F */ - { 32316, 0x00008031 }, /* GL_TABLE_TOO_LARGE_EXT */ - { 32339, 0x00001702 }, /* GL_TEXTURE */ - { 32350, 0x000084C0 }, /* GL_TEXTURE0 */ - { 32362, 0x000084C0 }, /* GL_TEXTURE0_ARB */ - { 32378, 0x000084C1 }, /* GL_TEXTURE1 */ - { 32390, 0x000084CA }, /* GL_TEXTURE10 */ - { 32403, 0x000084CA }, /* GL_TEXTURE10_ARB */ - { 32420, 0x000084CB }, /* GL_TEXTURE11 */ - { 32433, 0x000084CB }, /* GL_TEXTURE11_ARB */ - { 32450, 0x000084CC }, /* GL_TEXTURE12 */ - { 32463, 0x000084CC }, /* GL_TEXTURE12_ARB */ - { 32480, 0x000084CD }, /* GL_TEXTURE13 */ - { 32493, 0x000084CD }, /* GL_TEXTURE13_ARB */ - { 32510, 0x000084CE }, /* GL_TEXTURE14 */ - { 32523, 0x000084CE }, /* GL_TEXTURE14_ARB */ - { 32540, 0x000084CF }, /* GL_TEXTURE15 */ - { 32553, 0x000084CF }, /* GL_TEXTURE15_ARB */ - { 32570, 0x000084D0 }, /* GL_TEXTURE16 */ - { 32583, 0x000084D0 }, /* GL_TEXTURE16_ARB */ - { 32600, 0x000084D1 }, /* GL_TEXTURE17 */ - { 32613, 0x000084D1 }, /* GL_TEXTURE17_ARB */ - { 32630, 0x000084D2 }, /* GL_TEXTURE18 */ - { 32643, 0x000084D2 }, /* GL_TEXTURE18_ARB */ - { 32660, 0x000084D3 }, /* GL_TEXTURE19 */ - { 32673, 0x000084D3 }, /* GL_TEXTURE19_ARB */ - { 32690, 0x000084C1 }, /* GL_TEXTURE1_ARB */ - { 32706, 0x000084C2 }, /* GL_TEXTURE2 */ - { 32718, 0x000084D4 }, /* GL_TEXTURE20 */ - { 32731, 0x000084D4 }, /* GL_TEXTURE20_ARB */ - { 32748, 0x000084D5 }, /* GL_TEXTURE21 */ - { 32761, 0x000084D5 }, /* GL_TEXTURE21_ARB */ - { 32778, 0x000084D6 }, /* GL_TEXTURE22 */ - { 32791, 0x000084D6 }, /* GL_TEXTURE22_ARB */ - { 32808, 0x000084D7 }, /* GL_TEXTURE23 */ - { 32821, 0x000084D7 }, /* GL_TEXTURE23_ARB */ - { 32838, 0x000084D8 }, /* GL_TEXTURE24 */ - { 32851, 0x000084D8 }, /* GL_TEXTURE24_ARB */ - { 32868, 0x000084D9 }, /* GL_TEXTURE25 */ - { 32881, 0x000084D9 }, /* GL_TEXTURE25_ARB */ - { 32898, 0x000084DA }, /* GL_TEXTURE26 */ - { 32911, 0x000084DA }, /* GL_TEXTURE26_ARB */ - { 32928, 0x000084DB }, /* GL_TEXTURE27 */ - { 32941, 0x000084DB }, /* GL_TEXTURE27_ARB */ - { 32958, 0x000084DC }, /* GL_TEXTURE28 */ - { 32971, 0x000084DC }, /* GL_TEXTURE28_ARB */ - { 32988, 0x000084DD }, /* GL_TEXTURE29 */ - { 33001, 0x000084DD }, /* GL_TEXTURE29_ARB */ - { 33018, 0x000084C2 }, /* GL_TEXTURE2_ARB */ - { 33034, 0x000084C3 }, /* GL_TEXTURE3 */ - { 33046, 0x000084DE }, /* GL_TEXTURE30 */ - { 33059, 0x000084DE }, /* GL_TEXTURE30_ARB */ - { 33076, 0x000084DF }, /* GL_TEXTURE31 */ - { 33089, 0x000084DF }, /* GL_TEXTURE31_ARB */ - { 33106, 0x000084C3 }, /* GL_TEXTURE3_ARB */ - { 33122, 0x000084C4 }, /* GL_TEXTURE4 */ - { 33134, 0x000084C4 }, /* GL_TEXTURE4_ARB */ - { 33150, 0x000084C5 }, /* GL_TEXTURE5 */ - { 33162, 0x000084C5 }, /* GL_TEXTURE5_ARB */ - { 33178, 0x000084C6 }, /* GL_TEXTURE6 */ - { 33190, 0x000084C6 }, /* GL_TEXTURE6_ARB */ - { 33206, 0x000084C7 }, /* GL_TEXTURE7 */ - { 33218, 0x000084C7 }, /* GL_TEXTURE7_ARB */ - { 33234, 0x000084C8 }, /* GL_TEXTURE8 */ - { 33246, 0x000084C8 }, /* GL_TEXTURE8_ARB */ - { 33262, 0x000084C9 }, /* GL_TEXTURE9 */ - { 33274, 0x000084C9 }, /* GL_TEXTURE9_ARB */ - { 33290, 0x00000DE0 }, /* GL_TEXTURE_1D */ - { 33304, 0x00008C18 }, /* GL_TEXTURE_1D_ARRAY_EXT */ - { 33328, 0x00000DE1 }, /* GL_TEXTURE_2D */ - { 33342, 0x00008C1A }, /* GL_TEXTURE_2D_ARRAY_EXT */ - { 33366, 0x0000806F }, /* GL_TEXTURE_3D */ - { 33380, 0x0000805F }, /* GL_TEXTURE_ALPHA_SIZE */ - { 33402, 0x0000805F }, /* GL_TEXTURE_ALPHA_SIZE_EXT */ - { 33428, 0x0000813C }, /* GL_TEXTURE_BASE_LEVEL */ - { 33450, 0x00008068 }, /* GL_TEXTURE_BINDING_1D */ - { 33472, 0x00008C1C }, /* GL_TEXTURE_BINDING_1D_ARRAY_EXT */ - { 33504, 0x00008069 }, /* GL_TEXTURE_BINDING_2D */ - { 33526, 0x00008C1D }, /* GL_TEXTURE_BINDING_2D_ARRAY_EXT */ - { 33558, 0x0000806A }, /* GL_TEXTURE_BINDING_3D */ - { 33580, 0x00008514 }, /* GL_TEXTURE_BINDING_CUBE_MAP */ - { 33608, 0x00008514 }, /* GL_TEXTURE_BINDING_CUBE_MAP_ARB */ - { 33640, 0x000084F6 }, /* GL_TEXTURE_BINDING_RECTANGLE_ARB */ - { 33673, 0x000084F6 }, /* GL_TEXTURE_BINDING_RECTANGLE_NV */ - { 33705, 0x00040000 }, /* GL_TEXTURE_BIT */ - { 33720, 0x0000805E }, /* GL_TEXTURE_BLUE_SIZE */ - { 33741, 0x0000805E }, /* GL_TEXTURE_BLUE_SIZE_EXT */ - { 33766, 0x00001005 }, /* GL_TEXTURE_BORDER */ - { 33784, 0x00001004 }, /* GL_TEXTURE_BORDER_COLOR */ - { 33808, 0x00008171 }, /* GL_TEXTURE_CLIPMAP_CENTER_SGIX */ - { 33839, 0x00008176 }, /* GL_TEXTURE_CLIPMAP_DEPTH_SGIX */ - { 33869, 0x00008172 }, /* GL_TEXTURE_CLIPMAP_FRAME_SGIX */ - { 33899, 0x00008175 }, /* GL_TEXTURE_CLIPMAP_LOD_OFFSET_SGIX */ - { 33934, 0x00008173 }, /* GL_TEXTURE_CLIPMAP_OFFSET_SGIX */ - { 33965, 0x00008174 }, /* GL_TEXTURE_CLIPMAP_VIRTUAL_DEPTH_SGIX */ - { 34003, 0x000080BC }, /* GL_TEXTURE_COLOR_TABLE_SGI */ - { 34030, 0x000081EF }, /* GL_TEXTURE_COLOR_WRITEMASK_SGIS */ - { 34062, 0x000080BF }, /* GL_TEXTURE_COMPARE_FAIL_VALUE_ARB */ - { 34096, 0x0000884D }, /* GL_TEXTURE_COMPARE_FUNC */ - { 34120, 0x0000884D }, /* GL_TEXTURE_COMPARE_FUNC_ARB */ - { 34148, 0x0000884C }, /* GL_TEXTURE_COMPARE_MODE */ - { 34172, 0x0000884C }, /* GL_TEXTURE_COMPARE_MODE_ARB */ - { 34200, 0x0000819B }, /* GL_TEXTURE_COMPARE_OPERATOR_SGIX */ - { 34233, 0x0000819A }, /* GL_TEXTURE_COMPARE_SGIX */ - { 34257, 0x00001003 }, /* GL_TEXTURE_COMPONENTS */ - { 34279, 0x000086A1 }, /* GL_TEXTURE_COMPRESSED */ - { 34301, 0x000086A1 }, /* GL_TEXTURE_COMPRESSED_ARB */ - { 34327, 0x000086A3 }, /* GL_TEXTURE_COMPRESSED_FORMATS_ARB */ - { 34361, 0x000086A0 }, /* GL_TEXTURE_COMPRESSED_IMAGE_SIZE */ - { 34394, 0x000086A0 }, /* GL_TEXTURE_COMPRESSED_IMAGE_SIZE_ARB */ - { 34431, 0x000084EF }, /* GL_TEXTURE_COMPRESSION_HINT */ - { 34459, 0x000084EF }, /* GL_TEXTURE_COMPRESSION_HINT_ARB */ - { 34491, 0x00008078 }, /* GL_TEXTURE_COORD_ARRAY */ - { 34514, 0x0000889A }, /* GL_TEXTURE_COORD_ARRAY_BUFFER_BINDING */ - { 34552, 0x0000889A }, /* GL_TEXTURE_COORD_ARRAY_BUFFER_BINDING_ARB */ - { 34594, 0x00008092 }, /* GL_TEXTURE_COORD_ARRAY_POINTER */ - { 34625, 0x00008088 }, /* GL_TEXTURE_COORD_ARRAY_SIZE */ - { 34653, 0x0000808A }, /* GL_TEXTURE_COORD_ARRAY_STRIDE */ - { 34683, 0x00008089 }, /* GL_TEXTURE_COORD_ARRAY_TYPE */ - { 34711, 0x00008513 }, /* GL_TEXTURE_CUBE_MAP */ - { 34731, 0x00008513 }, /* GL_TEXTURE_CUBE_MAP_ARB */ - { 34755, 0x00008516 }, /* GL_TEXTURE_CUBE_MAP_NEGATIVE_X */ - { 34786, 0x00008516 }, /* GL_TEXTURE_CUBE_MAP_NEGATIVE_X_ARB */ - { 34821, 0x00008518 }, /* GL_TEXTURE_CUBE_MAP_NEGATIVE_Y */ - { 34852, 0x00008518 }, /* GL_TEXTURE_CUBE_MAP_NEGATIVE_Y_ARB */ - { 34887, 0x0000851A }, /* GL_TEXTURE_CUBE_MAP_NEGATIVE_Z */ - { 34918, 0x0000851A }, /* GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_ARB */ - { 34953, 0x00008515 }, /* GL_TEXTURE_CUBE_MAP_POSITIVE_X */ - { 34984, 0x00008515 }, /* GL_TEXTURE_CUBE_MAP_POSITIVE_X_ARB */ - { 35019, 0x00008517 }, /* GL_TEXTURE_CUBE_MAP_POSITIVE_Y */ - { 35050, 0x00008517 }, /* GL_TEXTURE_CUBE_MAP_POSITIVE_Y_ARB */ - { 35085, 0x00008519 }, /* GL_TEXTURE_CUBE_MAP_POSITIVE_Z */ - { 35116, 0x00008519 }, /* GL_TEXTURE_CUBE_MAP_POSITIVE_Z_ARB */ - { 35151, 0x00008071 }, /* GL_TEXTURE_DEPTH */ - { 35168, 0x0000884A }, /* GL_TEXTURE_DEPTH_SIZE */ - { 35190, 0x0000884A }, /* GL_TEXTURE_DEPTH_SIZE_ARB */ - { 35216, 0x00002300 }, /* GL_TEXTURE_ENV */ - { 35231, 0x00002201 }, /* GL_TEXTURE_ENV_COLOR */ - { 35252, 0x00002200 }, /* GL_TEXTURE_ENV_MODE */ - { 35272, 0x00008500 }, /* GL_TEXTURE_FILTER_CONTROL */ - { 35298, 0x00002500 }, /* GL_TEXTURE_GEN_MODE */ - { 35318, 0x00000C63 }, /* GL_TEXTURE_GEN_Q */ - { 35335, 0x00000C62 }, /* GL_TEXTURE_GEN_R */ - { 35352, 0x00000C60 }, /* GL_TEXTURE_GEN_S */ - { 35369, 0x00000C61 }, /* GL_TEXTURE_GEN_T */ - { 35386, 0x0000819D }, /* GL_TEXTURE_GEQUAL_R_SGIX */ - { 35411, 0x0000805D }, /* GL_TEXTURE_GREEN_SIZE */ - { 35433, 0x0000805D }, /* GL_TEXTURE_GREEN_SIZE_EXT */ - { 35459, 0x00001001 }, /* GL_TEXTURE_HEIGHT */ - { 35477, 0x000080ED }, /* GL_TEXTURE_INDEX_SIZE_EXT */ - { 35503, 0x00008061 }, /* GL_TEXTURE_INTENSITY_SIZE */ - { 35529, 0x00008061 }, /* GL_TEXTURE_INTENSITY_SIZE_EXT */ - { 35559, 0x00001003 }, /* GL_TEXTURE_INTERNAL_FORMAT */ - { 35586, 0x0000819C }, /* GL_TEXTURE_LEQUAL_R_SGIX */ - { 35611, 0x00008501 }, /* GL_TEXTURE_LOD_BIAS */ - { 35631, 0x00008501 }, /* GL_TEXTURE_LOD_BIAS_EXT */ - { 35655, 0x00008190 }, /* GL_TEXTURE_LOD_BIAS_R_SGIX */ - { 35682, 0x0000818E }, /* GL_TEXTURE_LOD_BIAS_S_SGIX */ - { 35709, 0x0000818F }, /* GL_TEXTURE_LOD_BIAS_T_SGIX */ - { 35736, 0x00008060 }, /* GL_TEXTURE_LUMINANCE_SIZE */ - { 35762, 0x00008060 }, /* GL_TEXTURE_LUMINANCE_SIZE_EXT */ - { 35792, 0x00002800 }, /* GL_TEXTURE_MAG_FILTER */ - { 35814, 0x00000BA8 }, /* GL_TEXTURE_MATRIX */ - { 35832, 0x000084FE }, /* GL_TEXTURE_MAX_ANISOTROPY_EXT */ - { 35862, 0x0000836B }, /* GL_TEXTURE_MAX_CLAMP_R_SGIX */ - { 35890, 0x00008369 }, /* GL_TEXTURE_MAX_CLAMP_S_SGIX */ - { 35918, 0x0000836A }, /* GL_TEXTURE_MAX_CLAMP_T_SGIX */ - { 35946, 0x0000813D }, /* GL_TEXTURE_MAX_LEVEL */ - { 35967, 0x0000813B }, /* GL_TEXTURE_MAX_LOD */ - { 35986, 0x00002801 }, /* GL_TEXTURE_MIN_FILTER */ - { 36008, 0x0000813A }, /* GL_TEXTURE_MIN_LOD */ - { 36027, 0x00008066 }, /* GL_TEXTURE_PRIORITY */ - { 36047, 0x000084F5 }, /* GL_TEXTURE_RECTANGLE_ARB */ - { 36072, 0x000084F5 }, /* GL_TEXTURE_RECTANGLE_NV */ - { 36096, 0x0000805C }, /* GL_TEXTURE_RED_SIZE */ - { 36116, 0x0000805C }, /* GL_TEXTURE_RED_SIZE_EXT */ - { 36140, 0x00008067 }, /* GL_TEXTURE_RESIDENT */ - { 36160, 0x00000BA5 }, /* GL_TEXTURE_STACK_DEPTH */ - { 36183, 0x000088F1 }, /* GL_TEXTURE_STENCIL_SIZE */ - { 36207, 0x00008065 }, /* GL_TEXTURE_TOO_LARGE_EXT */ - { 36232, 0x0000888F }, /* GL_TEXTURE_UNSIGNED_REMAP_MODE_NV */ - { 36266, 0x00001000 }, /* GL_TEXTURE_WIDTH */ - { 36283, 0x00008072 }, /* GL_TEXTURE_WRAP_R */ - { 36301, 0x00002802 }, /* GL_TEXTURE_WRAP_S */ - { 36319, 0x00002803 }, /* GL_TEXTURE_WRAP_T */ - { 36337, 0x000088BF }, /* GL_TIME_ELAPSED_EXT */ - { 36357, 0x00008648 }, /* GL_TRACK_MATRIX_NV */ - { 36376, 0x00008649 }, /* GL_TRACK_MATRIX_TRANSFORM_NV */ - { 36405, 0x00001000 }, /* GL_TRANSFORM_BIT */ - { 36422, 0x000084E6 }, /* GL_TRANSPOSE_COLOR_MATRIX */ - { 36448, 0x000084E6 }, /* GL_TRANSPOSE_COLOR_MATRIX_ARB */ - { 36478, 0x000088B7 }, /* GL_TRANSPOSE_CURRENT_MATRIX_ARB */ - { 36510, 0x000084E3 }, /* GL_TRANSPOSE_MODELVIEW_MATRIX */ - { 36540, 0x000084E3 }, /* GL_TRANSPOSE_MODELVIEW_MATRIX_ARB */ - { 36574, 0x0000862C }, /* GL_TRANSPOSE_NV */ - { 36590, 0x000084E4 }, /* GL_TRANSPOSE_PROJECTION_MATRIX */ - { 36621, 0x000084E4 }, /* GL_TRANSPOSE_PROJECTION_MATRIX_ARB */ - { 36656, 0x000084E5 }, /* GL_TRANSPOSE_TEXTURE_MATRIX */ - { 36684, 0x000084E5 }, /* GL_TRANSPOSE_TEXTURE_MATRIX_ARB */ - { 36716, 0x00000004 }, /* GL_TRIANGLES */ - { 36729, 0x00000006 }, /* GL_TRIANGLE_FAN */ - { 36745, 0x00008615 }, /* GL_TRIANGLE_MESH_SUN */ - { 36766, 0x00000005 }, /* GL_TRIANGLE_STRIP */ - { 36784, 0x00000001 }, /* GL_TRUE */ - { 36792, 0x00000CF5 }, /* GL_UNPACK_ALIGNMENT */ - { 36812, 0x0000806E }, /* GL_UNPACK_IMAGE_HEIGHT */ - { 36835, 0x00000CF1 }, /* GL_UNPACK_LSB_FIRST */ - { 36855, 0x00000CF2 }, /* GL_UNPACK_ROW_LENGTH */ - { 36876, 0x0000806D }, /* GL_UNPACK_SKIP_IMAGES */ - { 36898, 0x00000CF4 }, /* GL_UNPACK_SKIP_PIXELS */ - { 36920, 0x00000CF3 }, /* GL_UNPACK_SKIP_ROWS */ - { 36940, 0x00000CF0 }, /* GL_UNPACK_SWAP_BYTES */ - { 36961, 0x00001401 }, /* GL_UNSIGNED_BYTE */ - { 36978, 0x00008362 }, /* GL_UNSIGNED_BYTE_2_3_3_REV */ - { 37005, 0x00008032 }, /* GL_UNSIGNED_BYTE_3_3_2 */ - { 37028, 0x00001405 }, /* GL_UNSIGNED_INT */ - { 37044, 0x00008036 }, /* GL_UNSIGNED_INT_10_10_10_2 */ - { 37071, 0x000084FA }, /* GL_UNSIGNED_INT_24_8 */ - { 37092, 0x000084FA }, /* GL_UNSIGNED_INT_24_8_NV */ - { 37116, 0x00008368 }, /* GL_UNSIGNED_INT_2_10_10_10_REV */ - { 37147, 0x00008035 }, /* GL_UNSIGNED_INT_8_8_8_8 */ - { 37171, 0x00008367 }, /* GL_UNSIGNED_INT_8_8_8_8_REV */ - { 37199, 0x00008C17 }, /* GL_UNSIGNED_NORMALIZED */ - { 37222, 0x00001403 }, /* GL_UNSIGNED_SHORT */ - { 37240, 0x00008366 }, /* GL_UNSIGNED_SHORT_1_5_5_5_REV */ - { 37270, 0x00008033 }, /* GL_UNSIGNED_SHORT_4_4_4_4 */ - { 37296, 0x00008365 }, /* GL_UNSIGNED_SHORT_4_4_4_4_REV */ - { 37326, 0x00008034 }, /* GL_UNSIGNED_SHORT_5_5_5_1 */ - { 37352, 0x00008363 }, /* GL_UNSIGNED_SHORT_5_6_5 */ - { 37376, 0x00008364 }, /* GL_UNSIGNED_SHORT_5_6_5_REV */ - { 37404, 0x000085BA }, /* GL_UNSIGNED_SHORT_8_8_APPLE */ - { 37432, 0x000085BA }, /* GL_UNSIGNED_SHORT_8_8_MESA */ - { 37459, 0x000085BB }, /* GL_UNSIGNED_SHORT_8_8_REV_APPLE */ - { 37491, 0x000085BB }, /* GL_UNSIGNED_SHORT_8_8_REV_MESA */ - { 37522, 0x00008CA2 }, /* GL_UPPER_LEFT */ - { 37536, 0x00002A20 }, /* GL_V2F */ - { 37543, 0x00002A21 }, /* GL_V3F */ - { 37550, 0x00008B83 }, /* GL_VALIDATE_STATUS */ - { 37569, 0x00001F00 }, /* GL_VENDOR */ - { 37579, 0x00001F02 }, /* GL_VERSION */ - { 37590, 0x00008074 }, /* GL_VERTEX_ARRAY */ - { 37606, 0x000085B5 }, /* GL_VERTEX_ARRAY_BINDING_APPLE */ - { 37636, 0x00008896 }, /* GL_VERTEX_ARRAY_BUFFER_BINDING */ - { 37667, 0x00008896 }, /* GL_VERTEX_ARRAY_BUFFER_BINDING_ARB */ - { 37702, 0x0000808E }, /* GL_VERTEX_ARRAY_POINTER */ - { 37726, 0x0000807A }, /* GL_VERTEX_ARRAY_SIZE */ - { 37747, 0x0000807C }, /* GL_VERTEX_ARRAY_STRIDE */ - { 37770, 0x0000807B }, /* GL_VERTEX_ARRAY_TYPE */ - { 37791, 0x00008650 }, /* GL_VERTEX_ATTRIB_ARRAY0_NV */ - { 37818, 0x0000865A }, /* GL_VERTEX_ATTRIB_ARRAY10_NV */ - { 37846, 0x0000865B }, /* GL_VERTEX_ATTRIB_ARRAY11_NV */ - { 37874, 0x0000865C }, /* GL_VERTEX_ATTRIB_ARRAY12_NV */ - { 37902, 0x0000865D }, /* GL_VERTEX_ATTRIB_ARRAY13_NV */ - { 37930, 0x0000865E }, /* GL_VERTEX_ATTRIB_ARRAY14_NV */ - { 37958, 0x0000865F }, /* GL_VERTEX_ATTRIB_ARRAY15_NV */ - { 37986, 0x00008651 }, /* GL_VERTEX_ATTRIB_ARRAY1_NV */ - { 38013, 0x00008652 }, /* GL_VERTEX_ATTRIB_ARRAY2_NV */ - { 38040, 0x00008653 }, /* GL_VERTEX_ATTRIB_ARRAY3_NV */ - { 38067, 0x00008654 }, /* GL_VERTEX_ATTRIB_ARRAY4_NV */ - { 38094, 0x00008655 }, /* GL_VERTEX_ATTRIB_ARRAY5_NV */ - { 38121, 0x00008656 }, /* GL_VERTEX_ATTRIB_ARRAY6_NV */ - { 38148, 0x00008657 }, /* GL_VERTEX_ATTRIB_ARRAY7_NV */ - { 38175, 0x00008658 }, /* GL_VERTEX_ATTRIB_ARRAY8_NV */ - { 38202, 0x00008659 }, /* GL_VERTEX_ATTRIB_ARRAY9_NV */ - { 38229, 0x0000889F }, /* GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING */ - { 38267, 0x0000889F }, /* GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING_ARB */ - { 38309, 0x00008622 }, /* GL_VERTEX_ATTRIB_ARRAY_ENABLED */ - { 38340, 0x00008622 }, /* GL_VERTEX_ATTRIB_ARRAY_ENABLED_ARB */ - { 38375, 0x0000886A }, /* GL_VERTEX_ATTRIB_ARRAY_NORMALIZED */ - { 38409, 0x0000886A }, /* GL_VERTEX_ATTRIB_ARRAY_NORMALIZED_ARB */ - { 38447, 0x00008645 }, /* GL_VERTEX_ATTRIB_ARRAY_POINTER */ - { 38478, 0x00008645 }, /* GL_VERTEX_ATTRIB_ARRAY_POINTER_ARB */ - { 38513, 0x00008623 }, /* GL_VERTEX_ATTRIB_ARRAY_SIZE */ - { 38541, 0x00008623 }, /* GL_VERTEX_ATTRIB_ARRAY_SIZE_ARB */ - { 38573, 0x00008624 }, /* GL_VERTEX_ATTRIB_ARRAY_STRIDE */ - { 38603, 0x00008624 }, /* GL_VERTEX_ATTRIB_ARRAY_STRIDE_ARB */ - { 38637, 0x00008625 }, /* GL_VERTEX_ATTRIB_ARRAY_TYPE */ - { 38665, 0x00008625 }, /* GL_VERTEX_ATTRIB_ARRAY_TYPE_ARB */ - { 38697, 0x000086A7 }, /* GL_VERTEX_BLEND_ARB */ - { 38717, 0x00008620 }, /* GL_VERTEX_PROGRAM_ARB */ - { 38739, 0x0000864A }, /* GL_VERTEX_PROGRAM_BINDING_NV */ - { 38768, 0x00008620 }, /* GL_VERTEX_PROGRAM_NV */ - { 38789, 0x00008642 }, /* GL_VERTEX_PROGRAM_POINT_SIZE */ - { 38818, 0x00008642 }, /* GL_VERTEX_PROGRAM_POINT_SIZE_ARB */ - { 38851, 0x00008642 }, /* GL_VERTEX_PROGRAM_POINT_SIZE_NV */ - { 38883, 0x00008643 }, /* GL_VERTEX_PROGRAM_TWO_SIDE */ - { 38910, 0x00008643 }, /* GL_VERTEX_PROGRAM_TWO_SIDE_ARB */ - { 38941, 0x00008643 }, /* GL_VERTEX_PROGRAM_TWO_SIDE_NV */ - { 38971, 0x00008B31 }, /* GL_VERTEX_SHADER */ - { 38988, 0x00008B31 }, /* GL_VERTEX_SHADER_ARB */ - { 39009, 0x00008621 }, /* GL_VERTEX_STATE_PROGRAM_NV */ - { 39036, 0x00000BA2 }, /* GL_VIEWPORT */ - { 39048, 0x00000800 }, /* GL_VIEWPORT_BIT */ - { 39064, 0x000086AD }, /* GL_WEIGHT_ARRAY_ARB */ - { 39084, 0x0000889E }, /* GL_WEIGHT_ARRAY_BUFFER_BINDING */ - { 39115, 0x0000889E }, /* GL_WEIGHT_ARRAY_BUFFER_BINDING_ARB */ - { 39150, 0x000086AC }, /* GL_WEIGHT_ARRAY_POINTER_ARB */ - { 39178, 0x000086AB }, /* GL_WEIGHT_ARRAY_SIZE_ARB */ - { 39203, 0x000086AA }, /* GL_WEIGHT_ARRAY_STRIDE_ARB */ - { 39230, 0x000086A9 }, /* GL_WEIGHT_ARRAY_TYPE_ARB */ - { 39255, 0x000086A6 }, /* GL_WEIGHT_SUM_UNITY_ARB */ - { 39279, 0x000081D4 }, /* GL_WRAP_BORDER_SUN */ - { 39298, 0x000088B9 }, /* GL_WRITE_ONLY */ - { 39312, 0x000088B9 }, /* GL_WRITE_ONLY_ARB */ - { 39330, 0x00001506 }, /* GL_XOR */ - { 39337, 0x000085B9 }, /* GL_YCBCR_422_APPLE */ - { 39356, 0x00008757 }, /* GL_YCBCR_MESA */ - { 39370, 0x00000000 }, /* GL_ZERO */ - { 39378, 0x00000D16 }, /* GL_ZOOM_X */ - { 39388, 0x00000D17 }, /* GL_ZOOM_Y */ + { 779, 0x0000911A }, /* GL_ALREADY_SIGNALED */ + { 799, 0x00000207 }, /* GL_ALWAYS */ + { 809, 0x00001200 }, /* GL_AMBIENT */ + { 820, 0x00001602 }, /* GL_AMBIENT_AND_DIFFUSE */ + { 843, 0x00001501 }, /* GL_AND */ + { 850, 0x00001504 }, /* GL_AND_INVERTED */ + { 866, 0x00001502 }, /* GL_AND_REVERSE */ + { 881, 0x00008892 }, /* GL_ARRAY_BUFFER */ + { 897, 0x00008894 }, /* GL_ARRAY_BUFFER_BINDING */ + { 921, 0x00008894 }, /* GL_ARRAY_BUFFER_BINDING_ARB */ + { 949, 0x00008B85 }, /* GL_ATTACHED_SHADERS */ + { 969, 0x00008645 }, /* GL_ATTRIB_ARRAY_POINTER_NV */ + { 996, 0x00008623 }, /* GL_ATTRIB_ARRAY_SIZE_NV */ + { 1020, 0x00008624 }, /* GL_ATTRIB_ARRAY_STRIDE_NV */ + { 1046, 0x00008625 }, /* GL_ATTRIB_ARRAY_TYPE_NV */ + { 1070, 0x00000BB0 }, /* GL_ATTRIB_STACK_DEPTH */ + { 1092, 0x00000D80 }, /* GL_AUTO_NORMAL */ + { 1107, 0x00000409 }, /* GL_AUX0 */ + { 1115, 0x0000040A }, /* GL_AUX1 */ + { 1123, 0x0000040B }, /* GL_AUX2 */ + { 1131, 0x0000040C }, /* GL_AUX3 */ + { 1139, 0x00000C00 }, /* GL_AUX_BUFFERS */ + { 1154, 0x00000405 }, /* GL_BACK */ + { 1162, 0x00000402 }, /* GL_BACK_LEFT */ + { 1175, 0x00000403 }, /* GL_BACK_RIGHT */ + { 1189, 0x000080E0 }, /* GL_BGR */ + { 1196, 0x000080E1 }, /* GL_BGRA */ + { 1204, 0x00001A00 }, /* GL_BITMAP */ + { 1214, 0x00000704 }, /* GL_BITMAP_TOKEN */ + { 1230, 0x00000BE2 }, /* GL_BLEND */ + { 1239, 0x00008005 }, /* GL_BLEND_COLOR */ + { 1254, 0x00008005 }, /* GL_BLEND_COLOR_EXT */ + { 1273, 0x00000BE0 }, /* GL_BLEND_DST */ + { 1286, 0x000080CA }, /* GL_BLEND_DST_ALPHA */ + { 1305, 0x000080C8 }, /* GL_BLEND_DST_RGB */ + { 1322, 0x00008009 }, /* GL_BLEND_EQUATION */ + { 1340, 0x0000883D }, /* GL_BLEND_EQUATION_ALPHA */ + { 1364, 0x0000883D }, /* GL_BLEND_EQUATION_ALPHA_EXT */ + { 1392, 0x00008009 }, /* GL_BLEND_EQUATION_EXT */ + { 1414, 0x00008009 }, /* GL_BLEND_EQUATION_RGB */ + { 1436, 0x00008009 }, /* GL_BLEND_EQUATION_RGB_EXT */ + { 1462, 0x00000BE1 }, /* GL_BLEND_SRC */ + { 1475, 0x000080CB }, /* GL_BLEND_SRC_ALPHA */ + { 1494, 0x000080C9 }, /* GL_BLEND_SRC_RGB */ + { 1511, 0x00001905 }, /* GL_BLUE */ + { 1519, 0x00000D1B }, /* GL_BLUE_BIAS */ + { 1532, 0x00000D54 }, /* GL_BLUE_BITS */ + { 1545, 0x00000D1A }, /* GL_BLUE_SCALE */ + { 1559, 0x00008B56 }, /* GL_BOOL */ + { 1567, 0x00008B56 }, /* GL_BOOL_ARB */ + { 1579, 0x00008B57 }, /* GL_BOOL_VEC2 */ + { 1592, 0x00008B57 }, /* GL_BOOL_VEC2_ARB */ + { 1609, 0x00008B58 }, /* GL_BOOL_VEC3 */ + { 1622, 0x00008B58 }, /* GL_BOOL_VEC3_ARB */ + { 1639, 0x00008B59 }, /* GL_BOOL_VEC4 */ + { 1652, 0x00008B59 }, /* GL_BOOL_VEC4_ARB */ + { 1669, 0x000088BB }, /* GL_BUFFER_ACCESS */ + { 1686, 0x000088BB }, /* GL_BUFFER_ACCESS_ARB */ + { 1707, 0x00008A13 }, /* GL_BUFFER_FLUSHING_UNMAP_APPLE */ + { 1738, 0x000088BC }, /* GL_BUFFER_MAPPED */ + { 1755, 0x000088BC }, /* GL_BUFFER_MAPPED_ARB */ + { 1776, 0x000088BD }, /* GL_BUFFER_MAP_POINTER */ + { 1798, 0x000088BD }, /* GL_BUFFER_MAP_POINTER_ARB */ + { 1824, 0x00008A12 }, /* GL_BUFFER_SERIALIZED_MODIFY_APPLE */ + { 1858, 0x00008764 }, /* GL_BUFFER_SIZE */ + { 1873, 0x00008764 }, /* GL_BUFFER_SIZE_ARB */ + { 1892, 0x00008765 }, /* GL_BUFFER_USAGE */ + { 1908, 0x00008765 }, /* GL_BUFFER_USAGE_ARB */ + { 1928, 0x0000877B }, /* GL_BUMP_ENVMAP_ATI */ + { 1947, 0x00008777 }, /* GL_BUMP_NUM_TEX_UNITS_ATI */ + { 1973, 0x00008775 }, /* GL_BUMP_ROT_MATRIX_ATI */ + { 1996, 0x00008776 }, /* GL_BUMP_ROT_MATRIX_SIZE_ATI */ + { 2024, 0x0000877C }, /* GL_BUMP_TARGET_ATI */ + { 2043, 0x00008778 }, /* GL_BUMP_TEX_UNITS_ATI */ + { 2065, 0x00001400 }, /* GL_BYTE */ + { 2073, 0x00002A24 }, /* GL_C3F_V3F */ + { 2084, 0x00002A26 }, /* GL_C4F_N3F_V3F */ + { 2099, 0x00002A22 }, /* GL_C4UB_V2F */ + { 2111, 0x00002A23 }, /* GL_C4UB_V3F */ + { 2123, 0x00000901 }, /* GL_CCW */ + { 2130, 0x00002900 }, /* GL_CLAMP */ + { 2139, 0x0000812D }, /* GL_CLAMP_TO_BORDER */ + { 2158, 0x0000812D }, /* GL_CLAMP_TO_BORDER_ARB */ + { 2181, 0x0000812D }, /* GL_CLAMP_TO_BORDER_SGIS */ + { 2205, 0x0000812F }, /* GL_CLAMP_TO_EDGE */ + { 2222, 0x0000812F }, /* GL_CLAMP_TO_EDGE_SGIS */ + { 2244, 0x00001500 }, /* GL_CLEAR */ + { 2253, 0x000084E1 }, /* GL_CLIENT_ACTIVE_TEXTURE */ + { 2278, 0x000084E1 }, /* GL_CLIENT_ACTIVE_TEXTURE_ARB */ + { 2307, 0xFFFFFFFF }, /* GL_CLIENT_ALL_ATTRIB_BITS */ + { 2333, 0x00000BB1 }, /* GL_CLIENT_ATTRIB_STACK_DEPTH */ + { 2362, 0x00000001 }, /* GL_CLIENT_PIXEL_STORE_BIT */ + { 2388, 0x00000002 }, /* GL_CLIENT_VERTEX_ARRAY_BIT */ + { 2415, 0x00003000 }, /* GL_CLIP_PLANE0 */ + { 2430, 0x00003001 }, /* GL_CLIP_PLANE1 */ + { 2445, 0x00003002 }, /* GL_CLIP_PLANE2 */ + { 2460, 0x00003003 }, /* GL_CLIP_PLANE3 */ + { 2475, 0x00003004 }, /* GL_CLIP_PLANE4 */ + { 2490, 0x00003005 }, /* GL_CLIP_PLANE5 */ + { 2505, 0x000080F0 }, /* GL_CLIP_VOLUME_CLIPPING_HINT_EXT */ + { 2538, 0x00000A00 }, /* GL_COEFF */ + { 2547, 0x00001800 }, /* GL_COLOR */ + { 2556, 0x00008076 }, /* GL_COLOR_ARRAY */ + { 2571, 0x00008898 }, /* GL_COLOR_ARRAY_BUFFER_BINDING */ + { 2601, 0x00008898 }, /* GL_COLOR_ARRAY_BUFFER_BINDING_ARB */ + { 2635, 0x00008090 }, /* GL_COLOR_ARRAY_POINTER */ + { 2658, 0x00008081 }, /* GL_COLOR_ARRAY_SIZE */ + { 2678, 0x00008083 }, /* GL_COLOR_ARRAY_STRIDE */ + { 2700, 0x00008082 }, /* GL_COLOR_ARRAY_TYPE */ + { 2720, 0x00008CE0 }, /* GL_COLOR_ATTACHMENT0 */ + { 2741, 0x00008CE0 }, /* GL_COLOR_ATTACHMENT0_EXT */ + { 2766, 0x00008CE1 }, /* GL_COLOR_ATTACHMENT1 */ + { 2787, 0x00008CEA }, /* GL_COLOR_ATTACHMENT10 */ + { 2809, 0x00008CEA }, /* GL_COLOR_ATTACHMENT10_EXT */ + { 2835, 0x00008CEB }, /* GL_COLOR_ATTACHMENT11 */ + { 2857, 0x00008CEB }, /* GL_COLOR_ATTACHMENT11_EXT */ + { 2883, 0x00008CEC }, /* GL_COLOR_ATTACHMENT12 */ + { 2905, 0x00008CEC }, /* GL_COLOR_ATTACHMENT12_EXT */ + { 2931, 0x00008CED }, /* GL_COLOR_ATTACHMENT13 */ + { 2953, 0x00008CED }, /* GL_COLOR_ATTACHMENT13_EXT */ + { 2979, 0x00008CEE }, /* GL_COLOR_ATTACHMENT14 */ + { 3001, 0x00008CEE }, /* GL_COLOR_ATTACHMENT14_EXT */ + { 3027, 0x00008CEF }, /* GL_COLOR_ATTACHMENT15 */ + { 3049, 0x00008CEF }, /* GL_COLOR_ATTACHMENT15_EXT */ + { 3075, 0x00008CE1 }, /* GL_COLOR_ATTACHMENT1_EXT */ + { 3100, 0x00008CE2 }, /* GL_COLOR_ATTACHMENT2 */ + { 3121, 0x00008CE2 }, /* GL_COLOR_ATTACHMENT2_EXT */ + { 3146, 0x00008CE3 }, /* GL_COLOR_ATTACHMENT3 */ + { 3167, 0x00008CE3 }, /* GL_COLOR_ATTACHMENT3_EXT */ + { 3192, 0x00008CE4 }, /* GL_COLOR_ATTACHMENT4 */ + { 3213, 0x00008CE4 }, /* GL_COLOR_ATTACHMENT4_EXT */ + { 3238, 0x00008CE5 }, /* GL_COLOR_ATTACHMENT5 */ + { 3259, 0x00008CE5 }, /* GL_COLOR_ATTACHMENT5_EXT */ + { 3284, 0x00008CE6 }, /* GL_COLOR_ATTACHMENT6 */ + { 3305, 0x00008CE6 }, /* GL_COLOR_ATTACHMENT6_EXT */ + { 3330, 0x00008CE7 }, /* GL_COLOR_ATTACHMENT7 */ + { 3351, 0x00008CE7 }, /* GL_COLOR_ATTACHMENT7_EXT */ + { 3376, 0x00008CE8 }, /* GL_COLOR_ATTACHMENT8 */ + { 3397, 0x00008CE8 }, /* GL_COLOR_ATTACHMENT8_EXT */ + { 3422, 0x00008CE9 }, /* GL_COLOR_ATTACHMENT9 */ + { 3443, 0x00008CE9 }, /* GL_COLOR_ATTACHMENT9_EXT */ + { 3468, 0x00004000 }, /* GL_COLOR_BUFFER_BIT */ + { 3488, 0x00000C22 }, /* GL_COLOR_CLEAR_VALUE */ + { 3509, 0x00001900 }, /* GL_COLOR_INDEX */ + { 3524, 0x00001603 }, /* GL_COLOR_INDEXES */ + { 3541, 0x00000BF2 }, /* GL_COLOR_LOGIC_OP */ + { 3559, 0x00000B57 }, /* GL_COLOR_MATERIAL */ + { 3577, 0x00000B55 }, /* GL_COLOR_MATERIAL_FACE */ + { 3600, 0x00000B56 }, /* GL_COLOR_MATERIAL_PARAMETER */ + { 3628, 0x000080B1 }, /* GL_COLOR_MATRIX */ + { 3644, 0x000080B1 }, /* GL_COLOR_MATRIX_SGI */ + { 3664, 0x000080B2 }, /* GL_COLOR_MATRIX_STACK_DEPTH */ + { 3692, 0x000080B2 }, /* GL_COLOR_MATRIX_STACK_DEPTH_SGI */ + { 3724, 0x00008458 }, /* GL_COLOR_SUM */ + { 3737, 0x00008458 }, /* GL_COLOR_SUM_ARB */ + { 3754, 0x000080D0 }, /* GL_COLOR_TABLE */ + { 3769, 0x000080DD }, /* GL_COLOR_TABLE_ALPHA_SIZE */ + { 3795, 0x000080DD }, /* GL_COLOR_TABLE_ALPHA_SIZE_EXT */ + { 3825, 0x000080DD }, /* GL_COLOR_TABLE_ALPHA_SIZE_SGI */ + { 3855, 0x000080D7 }, /* GL_COLOR_TABLE_BIAS */ + { 3875, 0x000080D7 }, /* GL_COLOR_TABLE_BIAS_SGI */ + { 3899, 0x000080DC }, /* GL_COLOR_TABLE_BLUE_SIZE */ + { 3924, 0x000080DC }, /* GL_COLOR_TABLE_BLUE_SIZE_EXT */ + { 3953, 0x000080DC }, /* GL_COLOR_TABLE_BLUE_SIZE_SGI */ + { 3982, 0x000080D8 }, /* GL_COLOR_TABLE_FORMAT */ + { 4004, 0x000080D8 }, /* GL_COLOR_TABLE_FORMAT_EXT */ + { 4030, 0x000080D8 }, /* GL_COLOR_TABLE_FORMAT_SGI */ + { 4056, 0x000080DB }, /* GL_COLOR_TABLE_GREEN_SIZE */ + { 4082, 0x000080DB }, /* GL_COLOR_TABLE_GREEN_SIZE_EXT */ + { 4112, 0x000080DB }, /* GL_COLOR_TABLE_GREEN_SIZE_SGI */ + { 4142, 0x000080DF }, /* GL_COLOR_TABLE_INTENSITY_SIZE */ + { 4172, 0x000080DF }, /* GL_COLOR_TABLE_INTENSITY_SIZE_EXT */ + { 4206, 0x000080DF }, /* GL_COLOR_TABLE_INTENSITY_SIZE_SGI */ + { 4240, 0x000080DE }, /* GL_COLOR_TABLE_LUMINANCE_SIZE */ + { 4270, 0x000080DE }, /* GL_COLOR_TABLE_LUMINANCE_SIZE_EXT */ + { 4304, 0x000080DE }, /* GL_COLOR_TABLE_LUMINANCE_SIZE_SGI */ + { 4338, 0x000080DA }, /* GL_COLOR_TABLE_RED_SIZE */ + { 4362, 0x000080DA }, /* GL_COLOR_TABLE_RED_SIZE_EXT */ + { 4390, 0x000080DA }, /* GL_COLOR_TABLE_RED_SIZE_SGI */ + { 4418, 0x000080D6 }, /* GL_COLOR_TABLE_SCALE */ + { 4439, 0x000080D6 }, /* GL_COLOR_TABLE_SCALE_SGI */ + { 4464, 0x000080D9 }, /* GL_COLOR_TABLE_WIDTH */ + { 4485, 0x000080D9 }, /* GL_COLOR_TABLE_WIDTH_EXT */ + { 4510, 0x000080D9 }, /* GL_COLOR_TABLE_WIDTH_SGI */ + { 4535, 0x00000C23 }, /* GL_COLOR_WRITEMASK */ + { 4554, 0x00008570 }, /* GL_COMBINE */ + { 4565, 0x00008503 }, /* GL_COMBINE4 */ + { 4577, 0x00008572 }, /* GL_COMBINE_ALPHA */ + { 4594, 0x00008572 }, /* GL_COMBINE_ALPHA_ARB */ + { 4615, 0x00008572 }, /* GL_COMBINE_ALPHA_EXT */ + { 4636, 0x00008570 }, /* GL_COMBINE_ARB */ + { 4651, 0x00008570 }, /* GL_COMBINE_EXT */ + { 4666, 0x00008571 }, /* GL_COMBINE_RGB */ + { 4681, 0x00008571 }, /* GL_COMBINE_RGB_ARB */ + { 4700, 0x00008571 }, /* GL_COMBINE_RGB_EXT */ + { 4719, 0x0000884E }, /* GL_COMPARE_REF_DEPTH_TO_TEXTURE_EXT */ + { 4755, 0x0000884E }, /* GL_COMPARE_R_TO_TEXTURE */ + { 4779, 0x0000884E }, /* GL_COMPARE_R_TO_TEXTURE_ARB */ + { 4807, 0x00001300 }, /* GL_COMPILE */ + { 4818, 0x00001301 }, /* GL_COMPILE_AND_EXECUTE */ + { 4841, 0x00008B81 }, /* GL_COMPILE_STATUS */ + { 4859, 0x000084E9 }, /* GL_COMPRESSED_ALPHA */ + { 4879, 0x000084E9 }, /* GL_COMPRESSED_ALPHA_ARB */ + { 4903, 0x000084EC }, /* GL_COMPRESSED_INTENSITY */ + { 4927, 0x000084EC }, /* GL_COMPRESSED_INTENSITY_ARB */ + { 4955, 0x000084EA }, /* GL_COMPRESSED_LUMINANCE */ + { 4979, 0x000084EB }, /* GL_COMPRESSED_LUMINANCE_ALPHA */ + { 5009, 0x000084EB }, /* GL_COMPRESSED_LUMINANCE_ALPHA_ARB */ + { 5043, 0x000084EA }, /* GL_COMPRESSED_LUMINANCE_ARB */ + { 5071, 0x000084ED }, /* GL_COMPRESSED_RGB */ + { 5089, 0x000084EE }, /* GL_COMPRESSED_RGBA */ + { 5108, 0x000084EE }, /* GL_COMPRESSED_RGBA_ARB */ + { 5131, 0x000086B1 }, /* GL_COMPRESSED_RGBA_FXT1_3DFX */ + { 5160, 0x000083F1 }, /* GL_COMPRESSED_RGBA_S3TC_DXT1_EXT */ + { 5193, 0x000083F2 }, /* GL_COMPRESSED_RGBA_S3TC_DXT3_EXT */ + { 5226, 0x000083F3 }, /* GL_COMPRESSED_RGBA_S3TC_DXT5_EXT */ + { 5259, 0x000084ED }, /* GL_COMPRESSED_RGB_ARB */ + { 5281, 0x000086B0 }, /* GL_COMPRESSED_RGB_FXT1_3DFX */ + { 5309, 0x000083F0 }, /* GL_COMPRESSED_RGB_S3TC_DXT1_EXT */ + { 5341, 0x00008C4A }, /* GL_COMPRESSED_SLUMINANCE */ + { 5366, 0x00008C4B }, /* GL_COMPRESSED_SLUMINANCE_ALPHA */ + { 5397, 0x00008C48 }, /* GL_COMPRESSED_SRGB */ + { 5416, 0x00008C49 }, /* GL_COMPRESSED_SRGB_ALPHA */ + { 5441, 0x000086A3 }, /* GL_COMPRESSED_TEXTURE_FORMATS */ + { 5471, 0x0000911C }, /* GL_CONDITION_SATISFIED */ + { 5494, 0x00008576 }, /* GL_CONSTANT */ + { 5506, 0x00008003 }, /* GL_CONSTANT_ALPHA */ + { 5524, 0x00008003 }, /* GL_CONSTANT_ALPHA_EXT */ + { 5546, 0x00008576 }, /* GL_CONSTANT_ARB */ + { 5562, 0x00001207 }, /* GL_CONSTANT_ATTENUATION */ + { 5586, 0x00008151 }, /* GL_CONSTANT_BORDER_HP */ + { 5608, 0x00008001 }, /* GL_CONSTANT_COLOR */ + { 5626, 0x00008001 }, /* GL_CONSTANT_COLOR_EXT */ + { 5648, 0x00008576 }, /* GL_CONSTANT_EXT */ + { 5664, 0x00008010 }, /* GL_CONVOLUTION_1D */ + { 5682, 0x00008011 }, /* GL_CONVOLUTION_2D */ + { 5700, 0x00008154 }, /* GL_CONVOLUTION_BORDER_COLOR */ + { 5728, 0x00008154 }, /* GL_CONVOLUTION_BORDER_COLOR_HP */ + { 5759, 0x00008013 }, /* GL_CONVOLUTION_BORDER_MODE */ + { 5786, 0x00008013 }, /* GL_CONVOLUTION_BORDER_MODE_EXT */ + { 5817, 0x00008015 }, /* GL_CONVOLUTION_FILTER_BIAS */ + { 5844, 0x00008015 }, /* GL_CONVOLUTION_FILTER_BIAS_EXT */ + { 5875, 0x00008014 }, /* GL_CONVOLUTION_FILTER_SCALE */ + { 5903, 0x00008014 }, /* GL_CONVOLUTION_FILTER_SCALE_EXT */ + { 5935, 0x00008017 }, /* GL_CONVOLUTION_FORMAT */ + { 5957, 0x00008017 }, /* GL_CONVOLUTION_FORMAT_EXT */ + { 5983, 0x00008019 }, /* GL_CONVOLUTION_HEIGHT */ + { 6005, 0x00008019 }, /* GL_CONVOLUTION_HEIGHT_EXT */ + { 6031, 0x00008018 }, /* GL_CONVOLUTION_WIDTH */ + { 6052, 0x00008018 }, /* GL_CONVOLUTION_WIDTH_EXT */ + { 6077, 0x00008862 }, /* GL_COORD_REPLACE */ + { 6094, 0x00008862 }, /* GL_COORD_REPLACE_ARB */ + { 6115, 0x00008862 }, /* GL_COORD_REPLACE_NV */ + { 6135, 0x00001503 }, /* GL_COPY */ + { 6143, 0x0000150C }, /* GL_COPY_INVERTED */ + { 6160, 0x00000706 }, /* GL_COPY_PIXEL_TOKEN */ + { 6180, 0x00008F36 }, /* GL_COPY_READ_BUFFER */ + { 6200, 0x00008F37 }, /* GL_COPY_WRITE_BUFFER */ + { 6221, 0x00000B44 }, /* GL_CULL_FACE */ + { 6234, 0x00000B45 }, /* GL_CULL_FACE_MODE */ + { 6252, 0x000081AA }, /* GL_CULL_VERTEX_EXT */ + { 6271, 0x000081AC }, /* GL_CULL_VERTEX_EYE_POSITION_EXT */ + { 6303, 0x000081AB }, /* GL_CULL_VERTEX_OBJECT_POSITION_EXT */ + { 6338, 0x00008626 }, /* GL_CURRENT_ATTRIB_NV */ + { 6359, 0x00000001 }, /* GL_CURRENT_BIT */ + { 6374, 0x00000B00 }, /* GL_CURRENT_COLOR */ + { 6391, 0x00008453 }, /* GL_CURRENT_FOG_COORD */ + { 6412, 0x00008453 }, /* GL_CURRENT_FOG_COORDINATE */ + { 6438, 0x00000B01 }, /* GL_CURRENT_INDEX */ + { 6455, 0x00008641 }, /* GL_CURRENT_MATRIX_ARB */ + { 6477, 0x00008845 }, /* GL_CURRENT_MATRIX_INDEX_ARB */ + { 6505, 0x00008641 }, /* GL_CURRENT_MATRIX_NV */ + { 6526, 0x00008640 }, /* GL_CURRENT_MATRIX_STACK_DEPTH_ARB */ + { 6560, 0x00008640 }, /* GL_CURRENT_MATRIX_STACK_DEPTH_NV */ + { 6593, 0x00000B02 }, /* GL_CURRENT_NORMAL */ + { 6611, 0x00008843 }, /* GL_CURRENT_PALETTE_MATRIX_ARB */ + { 6641, 0x00008B8D }, /* GL_CURRENT_PROGRAM */ + { 6660, 0x00008865 }, /* GL_CURRENT_QUERY */ + { 6677, 0x00008865 }, /* GL_CURRENT_QUERY_ARB */ + { 6698, 0x00000B04 }, /* GL_CURRENT_RASTER_COLOR */ + { 6722, 0x00000B09 }, /* GL_CURRENT_RASTER_DISTANCE */ + { 6749, 0x00000B05 }, /* GL_CURRENT_RASTER_INDEX */ + { 6773, 0x00000B07 }, /* GL_CURRENT_RASTER_POSITION */ + { 6800, 0x00000B08 }, /* GL_CURRENT_RASTER_POSITION_VALID */ + { 6833, 0x0000845F }, /* GL_CURRENT_RASTER_SECONDARY_COLOR */ + { 6867, 0x00000B06 }, /* GL_CURRENT_RASTER_TEXTURE_COORDS */ + { 6900, 0x00008459 }, /* GL_CURRENT_SECONDARY_COLOR */ + { 6927, 0x00000B03 }, /* GL_CURRENT_TEXTURE_COORDS */ + { 6953, 0x00008626 }, /* GL_CURRENT_VERTEX_ATTRIB */ + { 6978, 0x00008626 }, /* GL_CURRENT_VERTEX_ATTRIB_ARB */ + { 7007, 0x000086A8 }, /* GL_CURRENT_WEIGHT_ARB */ + { 7029, 0x00000900 }, /* GL_CW */ + { 7035, 0x0000875B }, /* GL_DEBUG_ASSERT_MESA */ + { 7056, 0x00008759 }, /* GL_DEBUG_OBJECT_MESA */ + { 7077, 0x0000875A }, /* GL_DEBUG_PRINT_MESA */ + { 7097, 0x00002101 }, /* GL_DECAL */ + { 7106, 0x00001E03 }, /* GL_DECR */ + { 7114, 0x00008508 }, /* GL_DECR_WRAP */ + { 7127, 0x00008508 }, /* GL_DECR_WRAP_EXT */ + { 7144, 0x00008B80 }, /* GL_DELETE_STATUS */ + { 7161, 0x00001801 }, /* GL_DEPTH */ + { 7170, 0x000088F0 }, /* GL_DEPTH24_STENCIL8 */ + { 7190, 0x00008D00 }, /* GL_DEPTH_ATTACHMENT */ + { 7210, 0x00008D00 }, /* GL_DEPTH_ATTACHMENT_EXT */ + { 7234, 0x00000D1F }, /* GL_DEPTH_BIAS */ + { 7248, 0x00000D56 }, /* GL_DEPTH_BITS */ + { 7262, 0x00008891 }, /* GL_DEPTH_BOUNDS_EXT */ + { 7282, 0x00008890 }, /* GL_DEPTH_BOUNDS_TEST_EXT */ + { 7307, 0x00000100 }, /* GL_DEPTH_BUFFER_BIT */ + { 7327, 0x0000864F }, /* GL_DEPTH_CLAMP_NV */ + { 7345, 0x00000B73 }, /* GL_DEPTH_CLEAR_VALUE */ + { 7366, 0x00001902 }, /* GL_DEPTH_COMPONENT */ + { 7385, 0x000081A5 }, /* GL_DEPTH_COMPONENT16 */ + { 7406, 0x000081A5 }, /* GL_DEPTH_COMPONENT16_ARB */ + { 7431, 0x000081A5 }, /* GL_DEPTH_COMPONENT16_SGIX */ + { 7457, 0x000081A6 }, /* GL_DEPTH_COMPONENT24 */ + { 7478, 0x000081A6 }, /* GL_DEPTH_COMPONENT24_ARB */ + { 7503, 0x000081A6 }, /* GL_DEPTH_COMPONENT24_SGIX */ + { 7529, 0x000081A7 }, /* GL_DEPTH_COMPONENT32 */ + { 7550, 0x000081A7 }, /* GL_DEPTH_COMPONENT32_ARB */ + { 7575, 0x000081A7 }, /* GL_DEPTH_COMPONENT32_SGIX */ + { 7601, 0x00000B74 }, /* GL_DEPTH_FUNC */ + { 7615, 0x00000B70 }, /* GL_DEPTH_RANGE */ + { 7630, 0x00000D1E }, /* GL_DEPTH_SCALE */ + { 7645, 0x000084F9 }, /* GL_DEPTH_STENCIL */ + { 7662, 0x0000821A }, /* GL_DEPTH_STENCIL_ATTACHMENT */ + { 7690, 0x000084F9 }, /* GL_DEPTH_STENCIL_NV */ + { 7710, 0x0000886F }, /* GL_DEPTH_STENCIL_TO_BGRA_NV */ + { 7738, 0x0000886E }, /* GL_DEPTH_STENCIL_TO_RGBA_NV */ + { 7766, 0x00000B71 }, /* GL_DEPTH_TEST */ + { 7780, 0x0000884B }, /* GL_DEPTH_TEXTURE_MODE */ + { 7802, 0x0000884B }, /* GL_DEPTH_TEXTURE_MODE_ARB */ + { 7828, 0x00000B72 }, /* GL_DEPTH_WRITEMASK */ + { 7847, 0x00001201 }, /* GL_DIFFUSE */ + { 7858, 0x00000BD0 }, /* GL_DITHER */ + { 7868, 0x00000A02 }, /* GL_DOMAIN */ + { 7878, 0x00001100 }, /* GL_DONT_CARE */ + { 7891, 0x000086AE }, /* GL_DOT3_RGB */ + { 7903, 0x000086AF }, /* GL_DOT3_RGBA */ + { 7916, 0x000086AF }, /* GL_DOT3_RGBA_ARB */ + { 7933, 0x00008741 }, /* GL_DOT3_RGBA_EXT */ + { 7950, 0x000086AE }, /* GL_DOT3_RGB_ARB */ + { 7966, 0x00008740 }, /* GL_DOT3_RGB_EXT */ + { 7982, 0x0000140A }, /* GL_DOUBLE */ + { 7992, 0x00000C32 }, /* GL_DOUBLEBUFFER */ + { 8008, 0x00000C01 }, /* GL_DRAW_BUFFER */ + { 8023, 0x00008825 }, /* GL_DRAW_BUFFER0 */ + { 8039, 0x00008825 }, /* GL_DRAW_BUFFER0_ARB */ + { 8059, 0x00008825 }, /* GL_DRAW_BUFFER0_ATI */ + { 8079, 0x00008826 }, /* GL_DRAW_BUFFER1 */ + { 8095, 0x0000882F }, /* GL_DRAW_BUFFER10 */ + { 8112, 0x0000882F }, /* GL_DRAW_BUFFER10_ARB */ + { 8133, 0x0000882F }, /* GL_DRAW_BUFFER10_ATI */ + { 8154, 0x00008830 }, /* GL_DRAW_BUFFER11 */ + { 8171, 0x00008830 }, /* GL_DRAW_BUFFER11_ARB */ + { 8192, 0x00008830 }, /* GL_DRAW_BUFFER11_ATI */ + { 8213, 0x00008831 }, /* GL_DRAW_BUFFER12 */ + { 8230, 0x00008831 }, /* GL_DRAW_BUFFER12_ARB */ + { 8251, 0x00008831 }, /* GL_DRAW_BUFFER12_ATI */ + { 8272, 0x00008832 }, /* GL_DRAW_BUFFER13 */ + { 8289, 0x00008832 }, /* GL_DRAW_BUFFER13_ARB */ + { 8310, 0x00008832 }, /* GL_DRAW_BUFFER13_ATI */ + { 8331, 0x00008833 }, /* GL_DRAW_BUFFER14 */ + { 8348, 0x00008833 }, /* GL_DRAW_BUFFER14_ARB */ + { 8369, 0x00008833 }, /* GL_DRAW_BUFFER14_ATI */ + { 8390, 0x00008834 }, /* GL_DRAW_BUFFER15 */ + { 8407, 0x00008834 }, /* GL_DRAW_BUFFER15_ARB */ + { 8428, 0x00008834 }, /* GL_DRAW_BUFFER15_ATI */ + { 8449, 0x00008826 }, /* GL_DRAW_BUFFER1_ARB */ + { 8469, 0x00008826 }, /* GL_DRAW_BUFFER1_ATI */ + { 8489, 0x00008827 }, /* GL_DRAW_BUFFER2 */ + { 8505, 0x00008827 }, /* GL_DRAW_BUFFER2_ARB */ + { 8525, 0x00008827 }, /* GL_DRAW_BUFFER2_ATI */ + { 8545, 0x00008828 }, /* GL_DRAW_BUFFER3 */ + { 8561, 0x00008828 }, /* GL_DRAW_BUFFER3_ARB */ + { 8581, 0x00008828 }, /* GL_DRAW_BUFFER3_ATI */ + { 8601, 0x00008829 }, /* GL_DRAW_BUFFER4 */ + { 8617, 0x00008829 }, /* GL_DRAW_BUFFER4_ARB */ + { 8637, 0x00008829 }, /* GL_DRAW_BUFFER4_ATI */ + { 8657, 0x0000882A }, /* GL_DRAW_BUFFER5 */ + { 8673, 0x0000882A }, /* GL_DRAW_BUFFER5_ARB */ + { 8693, 0x0000882A }, /* GL_DRAW_BUFFER5_ATI */ + { 8713, 0x0000882B }, /* GL_DRAW_BUFFER6 */ + { 8729, 0x0000882B }, /* GL_DRAW_BUFFER6_ARB */ + { 8749, 0x0000882B }, /* GL_DRAW_BUFFER6_ATI */ + { 8769, 0x0000882C }, /* GL_DRAW_BUFFER7 */ + { 8785, 0x0000882C }, /* GL_DRAW_BUFFER7_ARB */ + { 8805, 0x0000882C }, /* GL_DRAW_BUFFER7_ATI */ + { 8825, 0x0000882D }, /* GL_DRAW_BUFFER8 */ + { 8841, 0x0000882D }, /* GL_DRAW_BUFFER8_ARB */ + { 8861, 0x0000882D }, /* GL_DRAW_BUFFER8_ATI */ + { 8881, 0x0000882E }, /* GL_DRAW_BUFFER9 */ + { 8897, 0x0000882E }, /* GL_DRAW_BUFFER9_ARB */ + { 8917, 0x0000882E }, /* GL_DRAW_BUFFER9_ATI */ + { 8937, 0x00008CA9 }, /* GL_DRAW_FRAMEBUFFER */ + { 8957, 0x00008CA6 }, /* GL_DRAW_FRAMEBUFFER_BINDING_EXT */ + { 8989, 0x00008CA9 }, /* GL_DRAW_FRAMEBUFFER_EXT */ + { 9013, 0x00000705 }, /* GL_DRAW_PIXEL_TOKEN */ + { 9033, 0x00000304 }, /* GL_DST_ALPHA */ + { 9046, 0x00000306 }, /* GL_DST_COLOR */ + { 9059, 0x0000877A }, /* GL_DU8DV8_ATI */ + { 9073, 0x00008779 }, /* GL_DUDV_ATI */ + { 9085, 0x000088EA }, /* GL_DYNAMIC_COPY */ + { 9101, 0x000088EA }, /* GL_DYNAMIC_COPY_ARB */ + { 9121, 0x000088E8 }, /* GL_DYNAMIC_DRAW */ + { 9137, 0x000088E8 }, /* GL_DYNAMIC_DRAW_ARB */ + { 9157, 0x000088E9 }, /* GL_DYNAMIC_READ */ + { 9173, 0x000088E9 }, /* GL_DYNAMIC_READ_ARB */ + { 9193, 0x00000B43 }, /* GL_EDGE_FLAG */ + { 9206, 0x00008079 }, /* GL_EDGE_FLAG_ARRAY */ + { 9225, 0x0000889B }, /* GL_EDGE_FLAG_ARRAY_BUFFER_BINDING */ + { 9259, 0x0000889B }, /* GL_EDGE_FLAG_ARRAY_BUFFER_BINDING_ARB */ + { 9297, 0x00008093 }, /* GL_EDGE_FLAG_ARRAY_POINTER */ + { 9324, 0x0000808C }, /* GL_EDGE_FLAG_ARRAY_STRIDE */ + { 9350, 0x00008893 }, /* GL_ELEMENT_ARRAY_BUFFER */ + { 9374, 0x00008895 }, /* GL_ELEMENT_ARRAY_BUFFER_BINDING */ + { 9406, 0x00008895 }, /* GL_ELEMENT_ARRAY_BUFFER_BINDING_ARB */ + { 9442, 0x00001600 }, /* GL_EMISSION */ + { 9454, 0x00002000 }, /* GL_ENABLE_BIT */ + { 9468, 0x00000202 }, /* GL_EQUAL */ + { 9477, 0x00001509 }, /* GL_EQUIV */ + { 9486, 0x00010000 }, /* GL_EVAL_BIT */ + { 9498, 0x00000800 }, /* GL_EXP */ + { 9505, 0x00000801 }, /* GL_EXP2 */ + { 9513, 0x00001F03 }, /* GL_EXTENSIONS */ + { 9527, 0x00002400 }, /* GL_EYE_LINEAR */ + { 9541, 0x00002502 }, /* GL_EYE_PLANE */ + { 9554, 0x0000855C }, /* GL_EYE_PLANE_ABSOLUTE_NV */ + { 9579, 0x0000855B }, /* GL_EYE_RADIAL_NV */ + { 9596, 0x00000000 }, /* GL_FALSE */ + { 9605, 0x00001101 }, /* GL_FASTEST */ + { 9616, 0x00001C01 }, /* GL_FEEDBACK */ + { 9628, 0x00000DF0 }, /* GL_FEEDBACK_BUFFER_POINTER */ + { 9655, 0x00000DF1 }, /* GL_FEEDBACK_BUFFER_SIZE */ + { 9679, 0x00000DF2 }, /* GL_FEEDBACK_BUFFER_TYPE */ + { 9703, 0x00001B02 }, /* GL_FILL */ + { 9711, 0x00008E4D }, /* GL_FIRST_VERTEX_CONVENTION_EXT */ + { 9742, 0x00001D00 }, /* GL_FLAT */ + { 9750, 0x00001406 }, /* GL_FLOAT */ + { 9759, 0x00008B5A }, /* GL_FLOAT_MAT2 */ + { 9773, 0x00008B5A }, /* GL_FLOAT_MAT2_ARB */ + { 9791, 0x00008B65 }, /* GL_FLOAT_MAT2x3 */ + { 9807, 0x00008B66 }, /* GL_FLOAT_MAT2x4 */ + { 9823, 0x00008B5B }, /* GL_FLOAT_MAT3 */ + { 9837, 0x00008B5B }, /* GL_FLOAT_MAT3_ARB */ + { 9855, 0x00008B67 }, /* GL_FLOAT_MAT3x2 */ + { 9871, 0x00008B68 }, /* GL_FLOAT_MAT3x4 */ + { 9887, 0x00008B5C }, /* GL_FLOAT_MAT4 */ + { 9901, 0x00008B5C }, /* GL_FLOAT_MAT4_ARB */ + { 9919, 0x00008B69 }, /* GL_FLOAT_MAT4x2 */ + { 9935, 0x00008B6A }, /* GL_FLOAT_MAT4x3 */ + { 9951, 0x00008B50 }, /* GL_FLOAT_VEC2 */ + { 9965, 0x00008B50 }, /* GL_FLOAT_VEC2_ARB */ + { 9983, 0x00008B51 }, /* GL_FLOAT_VEC3 */ + { 9997, 0x00008B51 }, /* GL_FLOAT_VEC3_ARB */ + { 10015, 0x00008B52 }, /* GL_FLOAT_VEC4 */ + { 10029, 0x00008B52 }, /* GL_FLOAT_VEC4_ARB */ + { 10047, 0x00000B60 }, /* GL_FOG */ + { 10054, 0x00000080 }, /* GL_FOG_BIT */ + { 10065, 0x00000B66 }, /* GL_FOG_COLOR */ + { 10078, 0x00008451 }, /* GL_FOG_COORD */ + { 10091, 0x00008451 }, /* GL_FOG_COORDINATE */ + { 10109, 0x00008457 }, /* GL_FOG_COORDINATE_ARRAY */ + { 10133, 0x0000889D }, /* GL_FOG_COORDINATE_ARRAY_BUFFER_BINDING */ + { 10172, 0x0000889D }, /* GL_FOG_COORDINATE_ARRAY_BUFFER_BINDING_ARB */ + { 10215, 0x00008456 }, /* GL_FOG_COORDINATE_ARRAY_POINTER */ + { 10247, 0x00008455 }, /* GL_FOG_COORDINATE_ARRAY_STRIDE */ + { 10278, 0x00008454 }, /* GL_FOG_COORDINATE_ARRAY_TYPE */ + { 10307, 0x00008450 }, /* GL_FOG_COORDINATE_SOURCE */ + { 10332, 0x00008457 }, /* GL_FOG_COORD_ARRAY */ + { 10351, 0x0000889D }, /* GL_FOG_COORD_ARRAY_BUFFER_BINDING */ + { 10385, 0x00008456 }, /* GL_FOG_COORD_ARRAY_POINTER */ + { 10412, 0x00008455 }, /* GL_FOG_COORD_ARRAY_STRIDE */ + { 10438, 0x00008454 }, /* GL_FOG_COORD_ARRAY_TYPE */ + { 10462, 0x00008450 }, /* GL_FOG_COORD_SRC */ + { 10479, 0x00000B62 }, /* GL_FOG_DENSITY */ + { 10494, 0x0000855A }, /* GL_FOG_DISTANCE_MODE_NV */ + { 10518, 0x00000B64 }, /* GL_FOG_END */ + { 10529, 0x00000C54 }, /* GL_FOG_HINT */ + { 10541, 0x00000B61 }, /* GL_FOG_INDEX */ + { 10554, 0x00000B65 }, /* GL_FOG_MODE */ + { 10566, 0x00008198 }, /* GL_FOG_OFFSET_SGIX */ + { 10585, 0x00008199 }, /* GL_FOG_OFFSET_VALUE_SGIX */ + { 10610, 0x00000B63 }, /* GL_FOG_START */ + { 10623, 0x00008452 }, /* GL_FRAGMENT_DEPTH */ + { 10641, 0x00008804 }, /* GL_FRAGMENT_PROGRAM_ARB */ + { 10665, 0x00008B30 }, /* GL_FRAGMENT_SHADER */ + { 10684, 0x00008B30 }, /* GL_FRAGMENT_SHADER_ARB */ + { 10707, 0x00008B8B }, /* GL_FRAGMENT_SHADER_DERIVATIVE_HINT */ + { 10742, 0x00008D40 }, /* GL_FRAMEBUFFER */ + { 10757, 0x00008215 }, /* GL_FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE */ + { 10794, 0x00008214 }, /* GL_FRAMEBUFFER_ATTACHMENT_BLUE_SIZE */ + { 10830, 0x00008210 }, /* GL_FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING */ + { 10871, 0x00008211 }, /* GL_FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE */ + { 10912, 0x00008216 }, /* GL_FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE */ + { 10949, 0x00008213 }, /* GL_FRAMEBUFFER_ATTACHMENT_GREEN_SIZE */ + { 10986, 0x00008CD1 }, /* GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME */ + { 11024, 0x00008CD1 }, /* GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME_EXT */ + { 11066, 0x00008CD0 }, /* GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE */ + { 11104, 0x00008CD0 }, /* GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE_EXT */ + { 11146, 0x00008212 }, /* GL_FRAMEBUFFER_ATTACHMENT_RED_SIZE */ + { 11181, 0x00008217 }, /* GL_FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE */ + { 11220, 0x00008CD4 }, /* GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_3D_ZOFFSET_EXT */ + { 11269, 0x00008CD3 }, /* GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE */ + { 11317, 0x00008CD3 }, /* GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE_EXT */ + { 11369, 0x00008CD4 }, /* GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER */ + { 11409, 0x00008CD4 }, /* GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER_EXT */ + { 11453, 0x00008CD2 }, /* GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL */ + { 11493, 0x00008CD2 }, /* GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL_EXT */ + { 11537, 0x00008CA6 }, /* GL_FRAMEBUFFER_BINDING_EXT */ + { 11564, 0x00008CD5 }, /* GL_FRAMEBUFFER_COMPLETE */ + { 11588, 0x00008CD5 }, /* GL_FRAMEBUFFER_COMPLETE_EXT */ + { 11616, 0x00008218 }, /* GL_FRAMEBUFFER_DEFAULT */ + { 11639, 0x00008D40 }, /* GL_FRAMEBUFFER_EXT */ + { 11658, 0x00008CD6 }, /* GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT */ + { 11695, 0x00008CD6 }, /* GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT_EXT */ + { 11736, 0x00008CD9 }, /* GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS_EXT */ + { 11777, 0x00008CDB }, /* GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER_EXT */ + { 11819, 0x00008CD8 }, /* GL_FRAMEBUFFER_INCOMPLETE_DUPLICATE_ATTACHMENT_EXT */ + { 11870, 0x00008CDA }, /* GL_FRAMEBUFFER_INCOMPLETE_FORMATS_EXT */ + { 11908, 0x00008CD7 }, /* GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT */ + { 11953, 0x00008CD7 }, /* GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT_EXT */ + { 12002, 0x00008D56 }, /* GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE */ + { 12040, 0x00008CDC }, /* GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER_EXT */ + { 12082, 0x00008CDE }, /* GL_FRAMEBUFFER_STATUS_ERROR_EXT */ + { 12114, 0x00008219 }, /* GL_FRAMEBUFFER_UNDEFINED */ + { 12139, 0x00008CDD }, /* GL_FRAMEBUFFER_UNSUPPORTED */ + { 12166, 0x00008CDD }, /* GL_FRAMEBUFFER_UNSUPPORTED_EXT */ + { 12197, 0x00000404 }, /* GL_FRONT */ + { 12206, 0x00000408 }, /* GL_FRONT_AND_BACK */ + { 12224, 0x00000B46 }, /* GL_FRONT_FACE */ + { 12238, 0x00000400 }, /* GL_FRONT_LEFT */ + { 12252, 0x00000401 }, /* GL_FRONT_RIGHT */ + { 12267, 0x00008006 }, /* GL_FUNC_ADD */ + { 12279, 0x00008006 }, /* GL_FUNC_ADD_EXT */ + { 12295, 0x0000800B }, /* GL_FUNC_REVERSE_SUBTRACT */ + { 12320, 0x0000800B }, /* GL_FUNC_REVERSE_SUBTRACT_EXT */ + { 12349, 0x0000800A }, /* GL_FUNC_SUBTRACT */ + { 12366, 0x0000800A }, /* GL_FUNC_SUBTRACT_EXT */ + { 12387, 0x00008191 }, /* GL_GENERATE_MIPMAP */ + { 12406, 0x00008192 }, /* GL_GENERATE_MIPMAP_HINT */ + { 12430, 0x00008192 }, /* GL_GENERATE_MIPMAP_HINT_SGIS */ + { 12459, 0x00008191 }, /* GL_GENERATE_MIPMAP_SGIS */ + { 12483, 0x00000206 }, /* GL_GEQUAL */ + { 12493, 0x00000204 }, /* GL_GREATER */ + { 12504, 0x00001904 }, /* GL_GREEN */ + { 12513, 0x00000D19 }, /* GL_GREEN_BIAS */ + { 12527, 0x00000D53 }, /* GL_GREEN_BITS */ + { 12541, 0x00000D18 }, /* GL_GREEN_SCALE */ + { 12556, 0x00008000 }, /* GL_HINT_BIT */ + { 12568, 0x00008024 }, /* GL_HISTOGRAM */ + { 12581, 0x0000802B }, /* GL_HISTOGRAM_ALPHA_SIZE */ + { 12605, 0x0000802B }, /* GL_HISTOGRAM_ALPHA_SIZE_EXT */ + { 12633, 0x0000802A }, /* GL_HISTOGRAM_BLUE_SIZE */ + { 12656, 0x0000802A }, /* GL_HISTOGRAM_BLUE_SIZE_EXT */ + { 12683, 0x00008024 }, /* GL_HISTOGRAM_EXT */ + { 12700, 0x00008027 }, /* GL_HISTOGRAM_FORMAT */ + { 12720, 0x00008027 }, /* GL_HISTOGRAM_FORMAT_EXT */ + { 12744, 0x00008029 }, /* GL_HISTOGRAM_GREEN_SIZE */ + { 12768, 0x00008029 }, /* GL_HISTOGRAM_GREEN_SIZE_EXT */ + { 12796, 0x0000802C }, /* GL_HISTOGRAM_LUMINANCE_SIZE */ + { 12824, 0x0000802C }, /* GL_HISTOGRAM_LUMINANCE_SIZE_EXT */ + { 12856, 0x00008028 }, /* GL_HISTOGRAM_RED_SIZE */ + { 12878, 0x00008028 }, /* GL_HISTOGRAM_RED_SIZE_EXT */ + { 12904, 0x0000802D }, /* GL_HISTOGRAM_SINK */ + { 12922, 0x0000802D }, /* GL_HISTOGRAM_SINK_EXT */ + { 12944, 0x00008026 }, /* GL_HISTOGRAM_WIDTH */ + { 12963, 0x00008026 }, /* GL_HISTOGRAM_WIDTH_EXT */ + { 12986, 0x0000862A }, /* GL_IDENTITY_NV */ + { 13001, 0x00008150 }, /* GL_IGNORE_BORDER_HP */ + { 13021, 0x00008B9B }, /* GL_IMPLEMENTATION_COLOR_READ_FORMAT_OES */ + { 13061, 0x00008B9A }, /* GL_IMPLEMENTATION_COLOR_READ_TYPE_OES */ + { 13099, 0x00001E02 }, /* GL_INCR */ + { 13107, 0x00008507 }, /* GL_INCR_WRAP */ + { 13120, 0x00008507 }, /* GL_INCR_WRAP_EXT */ + { 13137, 0x00008222 }, /* GL_INDEX */ + { 13146, 0x00008077 }, /* GL_INDEX_ARRAY */ + { 13161, 0x00008899 }, /* GL_INDEX_ARRAY_BUFFER_BINDING */ + { 13191, 0x00008899 }, /* GL_INDEX_ARRAY_BUFFER_BINDING_ARB */ + { 13225, 0x00008091 }, /* GL_INDEX_ARRAY_POINTER */ + { 13248, 0x00008086 }, /* GL_INDEX_ARRAY_STRIDE */ + { 13270, 0x00008085 }, /* GL_INDEX_ARRAY_TYPE */ + { 13290, 0x00000D51 }, /* GL_INDEX_BITS */ + { 13304, 0x00000C20 }, /* GL_INDEX_CLEAR_VALUE */ + { 13325, 0x00000BF1 }, /* GL_INDEX_LOGIC_OP */ + { 13343, 0x00000C30 }, /* GL_INDEX_MODE */ + { 13357, 0x00000D13 }, /* GL_INDEX_OFFSET */ + { 13373, 0x00000D12 }, /* GL_INDEX_SHIFT */ + { 13388, 0x00000C21 }, /* GL_INDEX_WRITEMASK */ + { 13407, 0x00008B84 }, /* GL_INFO_LOG_LENGTH */ + { 13426, 0x00001404 }, /* GL_INT */ + { 13433, 0x00008049 }, /* GL_INTENSITY */ + { 13446, 0x0000804C }, /* GL_INTENSITY12 */ + { 13461, 0x0000804C }, /* GL_INTENSITY12_EXT */ + { 13480, 0x0000804D }, /* GL_INTENSITY16 */ + { 13495, 0x0000804D }, /* GL_INTENSITY16_EXT */ + { 13514, 0x0000804A }, /* GL_INTENSITY4 */ + { 13528, 0x0000804A }, /* GL_INTENSITY4_EXT */ + { 13546, 0x0000804B }, /* GL_INTENSITY8 */ + { 13560, 0x0000804B }, /* GL_INTENSITY8_EXT */ + { 13578, 0x00008049 }, /* GL_INTENSITY_EXT */ + { 13595, 0x00008575 }, /* GL_INTERPOLATE */ + { 13610, 0x00008575 }, /* GL_INTERPOLATE_ARB */ + { 13629, 0x00008575 }, /* GL_INTERPOLATE_EXT */ + { 13648, 0x00008B53 }, /* GL_INT_VEC2 */ + { 13660, 0x00008B53 }, /* GL_INT_VEC2_ARB */ + { 13676, 0x00008B54 }, /* GL_INT_VEC3 */ + { 13688, 0x00008B54 }, /* GL_INT_VEC3_ARB */ + { 13704, 0x00008B55 }, /* GL_INT_VEC4 */ + { 13716, 0x00008B55 }, /* GL_INT_VEC4_ARB */ + { 13732, 0x00000500 }, /* GL_INVALID_ENUM */ + { 13748, 0x00000506 }, /* GL_INVALID_FRAMEBUFFER_OPERATION */ + { 13781, 0x00000506 }, /* GL_INVALID_FRAMEBUFFER_OPERATION_EXT */ + { 13818, 0x00000502 }, /* GL_INVALID_OPERATION */ + { 13839, 0x00000501 }, /* GL_INVALID_VALUE */ + { 13856, 0x0000862B }, /* GL_INVERSE_NV */ + { 13870, 0x0000862D }, /* GL_INVERSE_TRANSPOSE_NV */ + { 13894, 0x0000150A }, /* GL_INVERT */ + { 13904, 0x00001E00 }, /* GL_KEEP */ + { 13912, 0x00008E4E }, /* GL_LAST_VERTEX_CONVENTION_EXT */ + { 13942, 0x00000406 }, /* GL_LEFT */ + { 13950, 0x00000203 }, /* GL_LEQUAL */ + { 13960, 0x00000201 }, /* GL_LESS */ + { 13968, 0x00004000 }, /* GL_LIGHT0 */ + { 13978, 0x00004001 }, /* GL_LIGHT1 */ + { 13988, 0x00004002 }, /* GL_LIGHT2 */ + { 13998, 0x00004003 }, /* GL_LIGHT3 */ + { 14008, 0x00004004 }, /* GL_LIGHT4 */ + { 14018, 0x00004005 }, /* GL_LIGHT5 */ + { 14028, 0x00004006 }, /* GL_LIGHT6 */ + { 14038, 0x00004007 }, /* GL_LIGHT7 */ + { 14048, 0x00000B50 }, /* GL_LIGHTING */ + { 14060, 0x00000040 }, /* GL_LIGHTING_BIT */ + { 14076, 0x00000B53 }, /* GL_LIGHT_MODEL_AMBIENT */ + { 14099, 0x000081F8 }, /* GL_LIGHT_MODEL_COLOR_CONTROL */ + { 14128, 0x000081F8 }, /* GL_LIGHT_MODEL_COLOR_CONTROL_EXT */ + { 14161, 0x00000B51 }, /* GL_LIGHT_MODEL_LOCAL_VIEWER */ + { 14189, 0x00000B52 }, /* GL_LIGHT_MODEL_TWO_SIDE */ + { 14213, 0x00001B01 }, /* GL_LINE */ + { 14221, 0x00002601 }, /* GL_LINEAR */ + { 14231, 0x00001208 }, /* GL_LINEAR_ATTENUATION */ + { 14253, 0x00008170 }, /* GL_LINEAR_CLIPMAP_LINEAR_SGIX */ + { 14283, 0x0000844F }, /* GL_LINEAR_CLIPMAP_NEAREST_SGIX */ + { 14314, 0x00002703 }, /* GL_LINEAR_MIPMAP_LINEAR */ + { 14338, 0x00002701 }, /* GL_LINEAR_MIPMAP_NEAREST */ + { 14363, 0x00000001 }, /* GL_LINES */ + { 14372, 0x00000004 }, /* GL_LINE_BIT */ + { 14384, 0x00000002 }, /* GL_LINE_LOOP */ + { 14397, 0x00000707 }, /* GL_LINE_RESET_TOKEN */ + { 14417, 0x00000B20 }, /* GL_LINE_SMOOTH */ + { 14432, 0x00000C52 }, /* GL_LINE_SMOOTH_HINT */ + { 14452, 0x00000B24 }, /* GL_LINE_STIPPLE */ + { 14468, 0x00000B25 }, /* GL_LINE_STIPPLE_PATTERN */ + { 14492, 0x00000B26 }, /* GL_LINE_STIPPLE_REPEAT */ + { 14515, 0x00000003 }, /* GL_LINE_STRIP */ + { 14529, 0x00000702 }, /* GL_LINE_TOKEN */ + { 14543, 0x00000B21 }, /* GL_LINE_WIDTH */ + { 14557, 0x00000B23 }, /* GL_LINE_WIDTH_GRANULARITY */ + { 14583, 0x00000B22 }, /* GL_LINE_WIDTH_RANGE */ + { 14603, 0x00008B82 }, /* GL_LINK_STATUS */ + { 14618, 0x00000B32 }, /* GL_LIST_BASE */ + { 14631, 0x00020000 }, /* GL_LIST_BIT */ + { 14643, 0x00000B33 }, /* GL_LIST_INDEX */ + { 14657, 0x00000B30 }, /* GL_LIST_MODE */ + { 14670, 0x00000101 }, /* GL_LOAD */ + { 14678, 0x00000BF1 }, /* GL_LOGIC_OP */ + { 14690, 0x00000BF0 }, /* GL_LOGIC_OP_MODE */ + { 14707, 0x00008CA1 }, /* GL_LOWER_LEFT */ + { 14721, 0x00001909 }, /* GL_LUMINANCE */ + { 14734, 0x00008041 }, /* GL_LUMINANCE12 */ + { 14749, 0x00008047 }, /* GL_LUMINANCE12_ALPHA12 */ + { 14772, 0x00008047 }, /* GL_LUMINANCE12_ALPHA12_EXT */ + { 14799, 0x00008046 }, /* GL_LUMINANCE12_ALPHA4 */ + { 14821, 0x00008046 }, /* GL_LUMINANCE12_ALPHA4_EXT */ + { 14847, 0x00008041 }, /* GL_LUMINANCE12_EXT */ + { 14866, 0x00008042 }, /* GL_LUMINANCE16 */ + { 14881, 0x00008048 }, /* GL_LUMINANCE16_ALPHA16 */ + { 14904, 0x00008048 }, /* GL_LUMINANCE16_ALPHA16_EXT */ + { 14931, 0x00008042 }, /* GL_LUMINANCE16_EXT */ + { 14950, 0x0000803F }, /* GL_LUMINANCE4 */ + { 14964, 0x00008043 }, /* GL_LUMINANCE4_ALPHA4 */ + { 14985, 0x00008043 }, /* GL_LUMINANCE4_ALPHA4_EXT */ + { 15010, 0x0000803F }, /* GL_LUMINANCE4_EXT */ + { 15028, 0x00008044 }, /* GL_LUMINANCE6_ALPHA2 */ + { 15049, 0x00008044 }, /* GL_LUMINANCE6_ALPHA2_EXT */ + { 15074, 0x00008040 }, /* GL_LUMINANCE8 */ + { 15088, 0x00008045 }, /* GL_LUMINANCE8_ALPHA8 */ + { 15109, 0x00008045 }, /* GL_LUMINANCE8_ALPHA8_EXT */ + { 15134, 0x00008040 }, /* GL_LUMINANCE8_EXT */ + { 15152, 0x0000190A }, /* GL_LUMINANCE_ALPHA */ + { 15171, 0x00000D90 }, /* GL_MAP1_COLOR_4 */ + { 15187, 0x00000DD0 }, /* GL_MAP1_GRID_DOMAIN */ + { 15207, 0x00000DD1 }, /* GL_MAP1_GRID_SEGMENTS */ + { 15229, 0x00000D91 }, /* GL_MAP1_INDEX */ + { 15243, 0x00000D92 }, /* GL_MAP1_NORMAL */ + { 15258, 0x00000D93 }, /* GL_MAP1_TEXTURE_COORD_1 */ + { 15282, 0x00000D94 }, /* GL_MAP1_TEXTURE_COORD_2 */ + { 15306, 0x00000D95 }, /* GL_MAP1_TEXTURE_COORD_3 */ + { 15330, 0x00000D96 }, /* GL_MAP1_TEXTURE_COORD_4 */ + { 15354, 0x00000D97 }, /* GL_MAP1_VERTEX_3 */ + { 15371, 0x00000D98 }, /* GL_MAP1_VERTEX_4 */ + { 15388, 0x00008660 }, /* GL_MAP1_VERTEX_ATTRIB0_4_NV */ + { 15416, 0x0000866A }, /* GL_MAP1_VERTEX_ATTRIB10_4_NV */ + { 15445, 0x0000866B }, /* GL_MAP1_VERTEX_ATTRIB11_4_NV */ + { 15474, 0x0000866C }, /* GL_MAP1_VERTEX_ATTRIB12_4_NV */ + { 15503, 0x0000866D }, /* GL_MAP1_VERTEX_ATTRIB13_4_NV */ + { 15532, 0x0000866E }, /* GL_MAP1_VERTEX_ATTRIB14_4_NV */ + { 15561, 0x0000866F }, /* GL_MAP1_VERTEX_ATTRIB15_4_NV */ + { 15590, 0x00008661 }, /* GL_MAP1_VERTEX_ATTRIB1_4_NV */ + { 15618, 0x00008662 }, /* GL_MAP1_VERTEX_ATTRIB2_4_NV */ + { 15646, 0x00008663 }, /* GL_MAP1_VERTEX_ATTRIB3_4_NV */ + { 15674, 0x00008664 }, /* GL_MAP1_VERTEX_ATTRIB4_4_NV */ + { 15702, 0x00008665 }, /* GL_MAP1_VERTEX_ATTRIB5_4_NV */ + { 15730, 0x00008666 }, /* GL_MAP1_VERTEX_ATTRIB6_4_NV */ + { 15758, 0x00008667 }, /* GL_MAP1_VERTEX_ATTRIB7_4_NV */ + { 15786, 0x00008668 }, /* GL_MAP1_VERTEX_ATTRIB8_4_NV */ + { 15814, 0x00008669 }, /* GL_MAP1_VERTEX_ATTRIB9_4_NV */ + { 15842, 0x00000DB0 }, /* GL_MAP2_COLOR_4 */ + { 15858, 0x00000DD2 }, /* GL_MAP2_GRID_DOMAIN */ + { 15878, 0x00000DD3 }, /* GL_MAP2_GRID_SEGMENTS */ + { 15900, 0x00000DB1 }, /* GL_MAP2_INDEX */ + { 15914, 0x00000DB2 }, /* GL_MAP2_NORMAL */ + { 15929, 0x00000DB3 }, /* GL_MAP2_TEXTURE_COORD_1 */ + { 15953, 0x00000DB4 }, /* GL_MAP2_TEXTURE_COORD_2 */ + { 15977, 0x00000DB5 }, /* GL_MAP2_TEXTURE_COORD_3 */ + { 16001, 0x00000DB6 }, /* GL_MAP2_TEXTURE_COORD_4 */ + { 16025, 0x00000DB7 }, /* GL_MAP2_VERTEX_3 */ + { 16042, 0x00000DB8 }, /* GL_MAP2_VERTEX_4 */ + { 16059, 0x00008670 }, /* GL_MAP2_VERTEX_ATTRIB0_4_NV */ + { 16087, 0x0000867A }, /* GL_MAP2_VERTEX_ATTRIB10_4_NV */ + { 16116, 0x0000867B }, /* GL_MAP2_VERTEX_ATTRIB11_4_NV */ + { 16145, 0x0000867C }, /* GL_MAP2_VERTEX_ATTRIB12_4_NV */ + { 16174, 0x0000867D }, /* GL_MAP2_VERTEX_ATTRIB13_4_NV */ + { 16203, 0x0000867E }, /* GL_MAP2_VERTEX_ATTRIB14_4_NV */ + { 16232, 0x0000867F }, /* GL_MAP2_VERTEX_ATTRIB15_4_NV */ + { 16261, 0x00008671 }, /* GL_MAP2_VERTEX_ATTRIB1_4_NV */ + { 16289, 0x00008672 }, /* GL_MAP2_VERTEX_ATTRIB2_4_NV */ + { 16317, 0x00008673 }, /* GL_MAP2_VERTEX_ATTRIB3_4_NV */ + { 16345, 0x00008674 }, /* GL_MAP2_VERTEX_ATTRIB4_4_NV */ + { 16373, 0x00008675 }, /* GL_MAP2_VERTEX_ATTRIB5_4_NV */ + { 16401, 0x00008676 }, /* GL_MAP2_VERTEX_ATTRIB6_4_NV */ + { 16429, 0x00008677 }, /* GL_MAP2_VERTEX_ATTRIB7_4_NV */ + { 16457, 0x00008678 }, /* GL_MAP2_VERTEX_ATTRIB8_4_NV */ + { 16485, 0x00008679 }, /* GL_MAP2_VERTEX_ATTRIB9_4_NV */ + { 16513, 0x00000D10 }, /* GL_MAP_COLOR */ + { 16526, 0x00000010 }, /* GL_MAP_FLUSH_EXPLICIT_BIT */ + { 16552, 0x00000008 }, /* GL_MAP_INVALIDATE_BUFFER_BIT */ + { 16581, 0x00000004 }, /* GL_MAP_INVALIDATE_RANGE_BIT */ + { 16609, 0x00000001 }, /* GL_MAP_READ_BIT */ + { 16625, 0x00000D11 }, /* GL_MAP_STENCIL */ + { 16640, 0x00000020 }, /* GL_MAP_UNSYNCHRONIZED_BIT */ + { 16666, 0x00000002 }, /* GL_MAP_WRITE_BIT */ + { 16683, 0x000088C0 }, /* GL_MATRIX0_ARB */ + { 16698, 0x00008630 }, /* GL_MATRIX0_NV */ + { 16712, 0x000088CA }, /* GL_MATRIX10_ARB */ + { 16728, 0x000088CB }, /* GL_MATRIX11_ARB */ + { 16744, 0x000088CC }, /* GL_MATRIX12_ARB */ + { 16760, 0x000088CD }, /* GL_MATRIX13_ARB */ + { 16776, 0x000088CE }, /* GL_MATRIX14_ARB */ + { 16792, 0x000088CF }, /* GL_MATRIX15_ARB */ + { 16808, 0x000088D0 }, /* GL_MATRIX16_ARB */ + { 16824, 0x000088D1 }, /* GL_MATRIX17_ARB */ + { 16840, 0x000088D2 }, /* GL_MATRIX18_ARB */ + { 16856, 0x000088D3 }, /* GL_MATRIX19_ARB */ + { 16872, 0x000088C1 }, /* GL_MATRIX1_ARB */ + { 16887, 0x00008631 }, /* GL_MATRIX1_NV */ + { 16901, 0x000088D4 }, /* GL_MATRIX20_ARB */ + { 16917, 0x000088D5 }, /* GL_MATRIX21_ARB */ + { 16933, 0x000088D6 }, /* GL_MATRIX22_ARB */ + { 16949, 0x000088D7 }, /* GL_MATRIX23_ARB */ + { 16965, 0x000088D8 }, /* GL_MATRIX24_ARB */ + { 16981, 0x000088D9 }, /* GL_MATRIX25_ARB */ + { 16997, 0x000088DA }, /* GL_MATRIX26_ARB */ + { 17013, 0x000088DB }, /* GL_MATRIX27_ARB */ + { 17029, 0x000088DC }, /* GL_MATRIX28_ARB */ + { 17045, 0x000088DD }, /* GL_MATRIX29_ARB */ + { 17061, 0x000088C2 }, /* GL_MATRIX2_ARB */ + { 17076, 0x00008632 }, /* GL_MATRIX2_NV */ + { 17090, 0x000088DE }, /* GL_MATRIX30_ARB */ + { 17106, 0x000088DF }, /* GL_MATRIX31_ARB */ + { 17122, 0x000088C3 }, /* GL_MATRIX3_ARB */ + { 17137, 0x00008633 }, /* GL_MATRIX3_NV */ + { 17151, 0x000088C4 }, /* GL_MATRIX4_ARB */ + { 17166, 0x00008634 }, /* GL_MATRIX4_NV */ + { 17180, 0x000088C5 }, /* GL_MATRIX5_ARB */ + { 17195, 0x00008635 }, /* GL_MATRIX5_NV */ + { 17209, 0x000088C6 }, /* GL_MATRIX6_ARB */ + { 17224, 0x00008636 }, /* GL_MATRIX6_NV */ + { 17238, 0x000088C7 }, /* GL_MATRIX7_ARB */ + { 17253, 0x00008637 }, /* GL_MATRIX7_NV */ + { 17267, 0x000088C8 }, /* GL_MATRIX8_ARB */ + { 17282, 0x000088C9 }, /* GL_MATRIX9_ARB */ + { 17297, 0x00008844 }, /* GL_MATRIX_INDEX_ARRAY_ARB */ + { 17323, 0x00008849 }, /* GL_MATRIX_INDEX_ARRAY_POINTER_ARB */ + { 17357, 0x00008846 }, /* GL_MATRIX_INDEX_ARRAY_SIZE_ARB */ + { 17388, 0x00008848 }, /* GL_MATRIX_INDEX_ARRAY_STRIDE_ARB */ + { 17421, 0x00008847 }, /* GL_MATRIX_INDEX_ARRAY_TYPE_ARB */ + { 17452, 0x00000BA0 }, /* GL_MATRIX_MODE */ + { 17467, 0x00008840 }, /* GL_MATRIX_PALETTE_ARB */ + { 17489, 0x00008008 }, /* GL_MAX */ + { 17496, 0x00008073 }, /* GL_MAX_3D_TEXTURE_SIZE */ + { 17519, 0x000088FF }, /* GL_MAX_ARRAY_TEXTURE_LAYERS_EXT */ + { 17551, 0x00000D35 }, /* GL_MAX_ATTRIB_STACK_DEPTH */ + { 17577, 0x00000D3B }, /* GL_MAX_CLIENT_ATTRIB_STACK_DEPTH */ + { 17610, 0x00008177 }, /* GL_MAX_CLIPMAP_DEPTH_SGIX */ + { 17636, 0x00008178 }, /* GL_MAX_CLIPMAP_VIRTUAL_DEPTH_SGIX */ + { 17670, 0x00000D32 }, /* GL_MAX_CLIP_PLANES */ + { 17689, 0x00008CDF }, /* GL_MAX_COLOR_ATTACHMENTS_EXT */ + { 17718, 0x000080B3 }, /* GL_MAX_COLOR_MATRIX_STACK_DEPTH */ + { 17750, 0x000080B3 }, /* GL_MAX_COLOR_MATRIX_STACK_DEPTH_SGI */ + { 17786, 0x00008B4D }, /* GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS */ + { 17822, 0x00008B4D }, /* GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS_ARB */ + { 17862, 0x0000801B }, /* GL_MAX_CONVOLUTION_HEIGHT */ + { 17888, 0x0000801B }, /* GL_MAX_CONVOLUTION_HEIGHT_EXT */ + { 17918, 0x0000801A }, /* GL_MAX_CONVOLUTION_WIDTH */ + { 17943, 0x0000801A }, /* GL_MAX_CONVOLUTION_WIDTH_EXT */ + { 17972, 0x0000851C }, /* GL_MAX_CUBE_MAP_TEXTURE_SIZE */ + { 18001, 0x0000851C }, /* GL_MAX_CUBE_MAP_TEXTURE_SIZE_ARB */ + { 18034, 0x00008824 }, /* GL_MAX_DRAW_BUFFERS */ + { 18054, 0x00008824 }, /* GL_MAX_DRAW_BUFFERS_ARB */ + { 18078, 0x00008824 }, /* GL_MAX_DRAW_BUFFERS_ATI */ + { 18102, 0x000080E9 }, /* GL_MAX_ELEMENTS_INDICES */ + { 18126, 0x000080E8 }, /* GL_MAX_ELEMENTS_VERTICES */ + { 18151, 0x00000D30 }, /* GL_MAX_EVAL_ORDER */ + { 18169, 0x00008008 }, /* GL_MAX_EXT */ + { 18180, 0x00008B49 }, /* GL_MAX_FRAGMENT_UNIFORM_COMPONENTS */ + { 18215, 0x00008B49 }, /* GL_MAX_FRAGMENT_UNIFORM_COMPONENTS_ARB */ + { 18254, 0x00000D31 }, /* GL_MAX_LIGHTS */ + { 18268, 0x00000B31 }, /* GL_MAX_LIST_NESTING */ + { 18288, 0x00008841 }, /* GL_MAX_MATRIX_PALETTE_STACK_DEPTH_ARB */ + { 18326, 0x00000D36 }, /* GL_MAX_MODELVIEW_STACK_DEPTH */ + { 18355, 0x00000D37 }, /* GL_MAX_NAME_STACK_DEPTH */ + { 18379, 0x00008842 }, /* GL_MAX_PALETTE_MATRICES_ARB */ + { 18407, 0x00000D34 }, /* GL_MAX_PIXEL_MAP_TABLE */ + { 18430, 0x000088B1 }, /* GL_MAX_PROGRAM_ADDRESS_REGISTERS_ARB */ + { 18467, 0x0000880B }, /* GL_MAX_PROGRAM_ALU_INSTRUCTIONS_ARB */ + { 18503, 0x000088AD }, /* GL_MAX_PROGRAM_ATTRIBS_ARB */ + { 18530, 0x000088F5 }, /* GL_MAX_PROGRAM_CALL_DEPTH_NV */ + { 18559, 0x000088B5 }, /* GL_MAX_PROGRAM_ENV_PARAMETERS_ARB */ + { 18593, 0x000088F4 }, /* GL_MAX_PROGRAM_EXEC_INSTRUCTIONS_NV */ + { 18629, 0x000088F6 }, /* GL_MAX_PROGRAM_IF_DEPTH_NV */ + { 18656, 0x000088A1 }, /* GL_MAX_PROGRAM_INSTRUCTIONS_ARB */ + { 18688, 0x000088B4 }, /* GL_MAX_PROGRAM_LOCAL_PARAMETERS_ARB */ + { 18724, 0x000088F8 }, /* GL_MAX_PROGRAM_LOOP_COUNT_NV */ + { 18753, 0x000088F7 }, /* GL_MAX_PROGRAM_LOOP_DEPTH_NV */ + { 18782, 0x0000862F }, /* GL_MAX_PROGRAM_MATRICES_ARB */ + { 18810, 0x0000862E }, /* GL_MAX_PROGRAM_MATRIX_STACK_DEPTH_ARB */ + { 18848, 0x000088B3 }, /* GL_MAX_PROGRAM_NATIVE_ADDRESS_REGISTERS_ARB */ + { 18892, 0x0000880E }, /* GL_MAX_PROGRAM_NATIVE_ALU_INSTRUCTIONS_ARB */ + { 18935, 0x000088AF }, /* GL_MAX_PROGRAM_NATIVE_ATTRIBS_ARB */ + { 18969, 0x000088A3 }, /* GL_MAX_PROGRAM_NATIVE_INSTRUCTIONS_ARB */ + { 19008, 0x000088AB }, /* GL_MAX_PROGRAM_NATIVE_PARAMETERS_ARB */ + { 19045, 0x000088A7 }, /* GL_MAX_PROGRAM_NATIVE_TEMPORARIES_ARB */ + { 19083, 0x00008810 }, /* GL_MAX_PROGRAM_NATIVE_TEX_INDIRECTIONS_ARB */ + { 19126, 0x0000880F }, /* GL_MAX_PROGRAM_NATIVE_TEX_INSTRUCTIONS_ARB */ + { 19169, 0x000088A9 }, /* GL_MAX_PROGRAM_PARAMETERS_ARB */ + { 19199, 0x000088A5 }, /* GL_MAX_PROGRAM_TEMPORARIES_ARB */ + { 19230, 0x0000880D }, /* GL_MAX_PROGRAM_TEX_INDIRECTIONS_ARB */ + { 19266, 0x0000880C }, /* GL_MAX_PROGRAM_TEX_INSTRUCTIONS_ARB */ + { 19302, 0x00000D38 }, /* GL_MAX_PROJECTION_STACK_DEPTH */ + { 19332, 0x000084F8 }, /* GL_MAX_RECTANGLE_TEXTURE_SIZE_ARB */ + { 19366, 0x000084F8 }, /* GL_MAX_RECTANGLE_TEXTURE_SIZE_NV */ + { 19399, 0x000084E8 }, /* GL_MAX_RENDERBUFFER_SIZE_EXT */ + { 19428, 0x00008D57 }, /* GL_MAX_SAMPLES */ + { 19443, 0x00009111 }, /* GL_MAX_SERVER_WAIT_TIMEOUT */ + { 19470, 0x00008504 }, /* GL_MAX_SHININESS_NV */ + { 19490, 0x00008505 }, /* GL_MAX_SPOT_EXPONENT_NV */ + { 19514, 0x00008871 }, /* GL_MAX_TEXTURE_COORDS */ + { 19536, 0x00008871 }, /* GL_MAX_TEXTURE_COORDS_ARB */ + { 19562, 0x00008872 }, /* GL_MAX_TEXTURE_IMAGE_UNITS */ + { 19589, 0x00008872 }, /* GL_MAX_TEXTURE_IMAGE_UNITS_ARB */ + { 19620, 0x000084FD }, /* GL_MAX_TEXTURE_LOD_BIAS */ + { 19644, 0x000084FF }, /* GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT */ + { 19678, 0x00000D33 }, /* GL_MAX_TEXTURE_SIZE */ + { 19698, 0x00000D39 }, /* GL_MAX_TEXTURE_STACK_DEPTH */ + { 19725, 0x000084E2 }, /* GL_MAX_TEXTURE_UNITS */ + { 19746, 0x000084E2 }, /* GL_MAX_TEXTURE_UNITS_ARB */ + { 19771, 0x0000862F }, /* GL_MAX_TRACK_MATRICES_NV */ + { 19796, 0x0000862E }, /* GL_MAX_TRACK_MATRIX_STACK_DEPTH_NV */ + { 19831, 0x00008B4B }, /* GL_MAX_VARYING_FLOATS */ + { 19853, 0x00008B4B }, /* GL_MAX_VARYING_FLOATS_ARB */ + { 19879, 0x00008869 }, /* GL_MAX_VERTEX_ATTRIBS */ + { 19901, 0x00008869 }, /* GL_MAX_VERTEX_ATTRIBS_ARB */ + { 19927, 0x00008B4C }, /* GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS */ + { 19961, 0x00008B4C }, /* GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS_ARB */ + { 19999, 0x00008B4A }, /* GL_MAX_VERTEX_UNIFORM_COMPONENTS */ + { 20032, 0x00008B4A }, /* GL_MAX_VERTEX_UNIFORM_COMPONENTS_ARB */ + { 20069, 0x000086A4 }, /* GL_MAX_VERTEX_UNITS_ARB */ + { 20093, 0x00000D3A }, /* GL_MAX_VIEWPORT_DIMS */ + { 20114, 0x00008007 }, /* GL_MIN */ + { 20121, 0x0000802E }, /* GL_MINMAX */ + { 20131, 0x0000802E }, /* GL_MINMAX_EXT */ + { 20145, 0x0000802F }, /* GL_MINMAX_FORMAT */ + { 20162, 0x0000802F }, /* GL_MINMAX_FORMAT_EXT */ + { 20183, 0x00008030 }, /* GL_MINMAX_SINK */ + { 20198, 0x00008030 }, /* GL_MINMAX_SINK_EXT */ + { 20217, 0x00008007 }, /* GL_MIN_EXT */ + { 20228, 0x00008370 }, /* GL_MIRRORED_REPEAT */ + { 20247, 0x00008370 }, /* GL_MIRRORED_REPEAT_ARB */ + { 20270, 0x00008370 }, /* GL_MIRRORED_REPEAT_IBM */ + { 20293, 0x00008742 }, /* GL_MIRROR_CLAMP_ATI */ + { 20313, 0x00008742 }, /* GL_MIRROR_CLAMP_EXT */ + { 20333, 0x00008912 }, /* GL_MIRROR_CLAMP_TO_BORDER_EXT */ + { 20363, 0x00008743 }, /* GL_MIRROR_CLAMP_TO_EDGE_ATI */ + { 20391, 0x00008743 }, /* GL_MIRROR_CLAMP_TO_EDGE_EXT */ + { 20419, 0x00001700 }, /* GL_MODELVIEW */ + { 20432, 0x00001700 }, /* GL_MODELVIEW0_ARB */ + { 20450, 0x0000872A }, /* GL_MODELVIEW10_ARB */ + { 20469, 0x0000872B }, /* GL_MODELVIEW11_ARB */ + { 20488, 0x0000872C }, /* GL_MODELVIEW12_ARB */ + { 20507, 0x0000872D }, /* GL_MODELVIEW13_ARB */ + { 20526, 0x0000872E }, /* GL_MODELVIEW14_ARB */ + { 20545, 0x0000872F }, /* GL_MODELVIEW15_ARB */ + { 20564, 0x00008730 }, /* GL_MODELVIEW16_ARB */ + { 20583, 0x00008731 }, /* GL_MODELVIEW17_ARB */ + { 20602, 0x00008732 }, /* GL_MODELVIEW18_ARB */ + { 20621, 0x00008733 }, /* GL_MODELVIEW19_ARB */ + { 20640, 0x0000850A }, /* GL_MODELVIEW1_ARB */ + { 20658, 0x00008734 }, /* GL_MODELVIEW20_ARB */ + { 20677, 0x00008735 }, /* GL_MODELVIEW21_ARB */ + { 20696, 0x00008736 }, /* GL_MODELVIEW22_ARB */ + { 20715, 0x00008737 }, /* GL_MODELVIEW23_ARB */ + { 20734, 0x00008738 }, /* GL_MODELVIEW24_ARB */ + { 20753, 0x00008739 }, /* GL_MODELVIEW25_ARB */ + { 20772, 0x0000873A }, /* GL_MODELVIEW26_ARB */ + { 20791, 0x0000873B }, /* GL_MODELVIEW27_ARB */ + { 20810, 0x0000873C }, /* GL_MODELVIEW28_ARB */ + { 20829, 0x0000873D }, /* GL_MODELVIEW29_ARB */ + { 20848, 0x00008722 }, /* GL_MODELVIEW2_ARB */ + { 20866, 0x0000873E }, /* GL_MODELVIEW30_ARB */ + { 20885, 0x0000873F }, /* GL_MODELVIEW31_ARB */ + { 20904, 0x00008723 }, /* GL_MODELVIEW3_ARB */ + { 20922, 0x00008724 }, /* GL_MODELVIEW4_ARB */ + { 20940, 0x00008725 }, /* GL_MODELVIEW5_ARB */ + { 20958, 0x00008726 }, /* GL_MODELVIEW6_ARB */ + { 20976, 0x00008727 }, /* GL_MODELVIEW7_ARB */ + { 20994, 0x00008728 }, /* GL_MODELVIEW8_ARB */ + { 21012, 0x00008729 }, /* GL_MODELVIEW9_ARB */ + { 21030, 0x00000BA6 }, /* GL_MODELVIEW_MATRIX */ + { 21050, 0x00008629 }, /* GL_MODELVIEW_PROJECTION_NV */ + { 21077, 0x00000BA3 }, /* GL_MODELVIEW_STACK_DEPTH */ + { 21102, 0x00002100 }, /* GL_MODULATE */ + { 21114, 0x00008744 }, /* GL_MODULATE_ADD_ATI */ + { 21134, 0x00008745 }, /* GL_MODULATE_SIGNED_ADD_ATI */ + { 21161, 0x00008746 }, /* GL_MODULATE_SUBTRACT_ATI */ + { 21186, 0x00000103 }, /* GL_MULT */ + { 21194, 0x0000809D }, /* GL_MULTISAMPLE */ + { 21209, 0x000086B2 }, /* GL_MULTISAMPLE_3DFX */ + { 21229, 0x0000809D }, /* GL_MULTISAMPLE_ARB */ + { 21248, 0x20000000 }, /* GL_MULTISAMPLE_BIT */ + { 21267, 0x20000000 }, /* GL_MULTISAMPLE_BIT_3DFX */ + { 21291, 0x20000000 }, /* GL_MULTISAMPLE_BIT_ARB */ + { 21314, 0x00008534 }, /* GL_MULTISAMPLE_FILTER_HINT_NV */ + { 21344, 0x00002A25 }, /* GL_N3F_V3F */ + { 21355, 0x00000D70 }, /* GL_NAME_STACK_DEPTH */ + { 21375, 0x0000150E }, /* GL_NAND */ + { 21383, 0x00002600 }, /* GL_NEAREST */ + { 21394, 0x0000844E }, /* GL_NEAREST_CLIPMAP_LINEAR_SGIX */ + { 21425, 0x0000844D }, /* GL_NEAREST_CLIPMAP_NEAREST_SGIX */ + { 21457, 0x00002702 }, /* GL_NEAREST_MIPMAP_LINEAR */ + { 21482, 0x00002700 }, /* GL_NEAREST_MIPMAP_NEAREST */ + { 21508, 0x00000200 }, /* GL_NEVER */ + { 21517, 0x00001102 }, /* GL_NICEST */ + { 21527, 0x00000000 }, /* GL_NONE */ + { 21535, 0x00001505 }, /* GL_NOOP */ + { 21543, 0x00001508 }, /* GL_NOR */ + { 21550, 0x00000BA1 }, /* GL_NORMALIZE */ + { 21563, 0x00008075 }, /* GL_NORMAL_ARRAY */ + { 21579, 0x00008897 }, /* GL_NORMAL_ARRAY_BUFFER_BINDING */ + { 21610, 0x00008897 }, /* GL_NORMAL_ARRAY_BUFFER_BINDING_ARB */ + { 21645, 0x0000808F }, /* GL_NORMAL_ARRAY_POINTER */ + { 21669, 0x0000807F }, /* GL_NORMAL_ARRAY_STRIDE */ + { 21692, 0x0000807E }, /* GL_NORMAL_ARRAY_TYPE */ + { 21713, 0x00008511 }, /* GL_NORMAL_MAP */ + { 21727, 0x00008511 }, /* GL_NORMAL_MAP_ARB */ + { 21745, 0x00008511 }, /* GL_NORMAL_MAP_NV */ + { 21762, 0x00000205 }, /* GL_NOTEQUAL */ + { 21774, 0x00000000 }, /* GL_NO_ERROR */ + { 21786, 0x000086A2 }, /* GL_NUM_COMPRESSED_TEXTURE_FORMATS */ + { 21820, 0x000086A2 }, /* GL_NUM_COMPRESSED_TEXTURE_FORMATS_ARB */ + { 21858, 0x00008B89 }, /* GL_OBJECT_ACTIVE_ATTRIBUTES_ARB */ + { 21890, 0x00008B8A }, /* GL_OBJECT_ACTIVE_ATTRIBUTE_MAX_LENGTH_ARB */ + { 21932, 0x00008B86 }, /* GL_OBJECT_ACTIVE_UNIFORMS_ARB */ + { 21962, 0x00008B87 }, /* GL_OBJECT_ACTIVE_UNIFORM_MAX_LENGTH_ARB */ + { 22002, 0x00008B85 }, /* GL_OBJECT_ATTACHED_OBJECTS_ARB */ + { 22033, 0x00008B81 }, /* GL_OBJECT_COMPILE_STATUS_ARB */ + { 22062, 0x00008B80 }, /* GL_OBJECT_DELETE_STATUS_ARB */ + { 22090, 0x00008B84 }, /* GL_OBJECT_INFO_LOG_LENGTH_ARB */ + { 22120, 0x00002401 }, /* GL_OBJECT_LINEAR */ + { 22137, 0x00008B82 }, /* GL_OBJECT_LINK_STATUS_ARB */ + { 22163, 0x00002501 }, /* GL_OBJECT_PLANE */ + { 22179, 0x00008B88 }, /* GL_OBJECT_SHADER_SOURCE_LENGTH_ARB */ + { 22214, 0x00008B4F }, /* GL_OBJECT_SUBTYPE_ARB */ + { 22236, 0x00009112 }, /* GL_OBJECT_TYPE */ + { 22251, 0x00008B4E }, /* GL_OBJECT_TYPE_ARB */ + { 22270, 0x00008B83 }, /* GL_OBJECT_VALIDATE_STATUS_ARB */ + { 22300, 0x00008165 }, /* GL_OCCLUSION_TEST_HP */ + { 22321, 0x00008166 }, /* GL_OCCLUSION_TEST_RESULT_HP */ + { 22349, 0x00000001 }, /* GL_ONE */ + { 22356, 0x00008004 }, /* GL_ONE_MINUS_CONSTANT_ALPHA */ + { 22384, 0x00008004 }, /* GL_ONE_MINUS_CONSTANT_ALPHA_EXT */ + { 22416, 0x00008002 }, /* GL_ONE_MINUS_CONSTANT_COLOR */ + { 22444, 0x00008002 }, /* GL_ONE_MINUS_CONSTANT_COLOR_EXT */ + { 22476, 0x00000305 }, /* GL_ONE_MINUS_DST_ALPHA */ + { 22499, 0x00000307 }, /* GL_ONE_MINUS_DST_COLOR */ + { 22522, 0x00000303 }, /* GL_ONE_MINUS_SRC_ALPHA */ + { 22545, 0x00000301 }, /* GL_ONE_MINUS_SRC_COLOR */ + { 22568, 0x00008598 }, /* GL_OPERAND0_ALPHA */ + { 22586, 0x00008598 }, /* GL_OPERAND0_ALPHA_ARB */ + { 22608, 0x00008598 }, /* GL_OPERAND0_ALPHA_EXT */ + { 22630, 0x00008590 }, /* GL_OPERAND0_RGB */ + { 22646, 0x00008590 }, /* GL_OPERAND0_RGB_ARB */ + { 22666, 0x00008590 }, /* GL_OPERAND0_RGB_EXT */ + { 22686, 0x00008599 }, /* GL_OPERAND1_ALPHA */ + { 22704, 0x00008599 }, /* GL_OPERAND1_ALPHA_ARB */ + { 22726, 0x00008599 }, /* GL_OPERAND1_ALPHA_EXT */ + { 22748, 0x00008591 }, /* GL_OPERAND1_RGB */ + { 22764, 0x00008591 }, /* GL_OPERAND1_RGB_ARB */ + { 22784, 0x00008591 }, /* GL_OPERAND1_RGB_EXT */ + { 22804, 0x0000859A }, /* GL_OPERAND2_ALPHA */ + { 22822, 0x0000859A }, /* GL_OPERAND2_ALPHA_ARB */ + { 22844, 0x0000859A }, /* GL_OPERAND2_ALPHA_EXT */ + { 22866, 0x00008592 }, /* GL_OPERAND2_RGB */ + { 22882, 0x00008592 }, /* GL_OPERAND2_RGB_ARB */ + { 22902, 0x00008592 }, /* GL_OPERAND2_RGB_EXT */ + { 22922, 0x0000859B }, /* GL_OPERAND3_ALPHA_NV */ + { 22943, 0x00008593 }, /* GL_OPERAND3_RGB_NV */ + { 22962, 0x00001507 }, /* GL_OR */ + { 22968, 0x00000A01 }, /* GL_ORDER */ + { 22977, 0x0000150D }, /* GL_OR_INVERTED */ + { 22992, 0x0000150B }, /* GL_OR_REVERSE */ + { 23006, 0x00000505 }, /* GL_OUT_OF_MEMORY */ + { 23023, 0x00000D05 }, /* GL_PACK_ALIGNMENT */ + { 23041, 0x0000806C }, /* GL_PACK_IMAGE_HEIGHT */ + { 23062, 0x00008758 }, /* GL_PACK_INVERT_MESA */ + { 23082, 0x00000D01 }, /* GL_PACK_LSB_FIRST */ + { 23100, 0x00000D02 }, /* GL_PACK_ROW_LENGTH */ + { 23119, 0x0000806B }, /* GL_PACK_SKIP_IMAGES */ + { 23139, 0x00000D04 }, /* GL_PACK_SKIP_PIXELS */ + { 23159, 0x00000D03 }, /* GL_PACK_SKIP_ROWS */ + { 23177, 0x00000D00 }, /* GL_PACK_SWAP_BYTES */ + { 23196, 0x00008B92 }, /* GL_PALETTE4_R5_G6_B5_OES */ + { 23221, 0x00008B94 }, /* GL_PALETTE4_RGB5_A1_OES */ + { 23245, 0x00008B90 }, /* GL_PALETTE4_RGB8_OES */ + { 23266, 0x00008B93 }, /* GL_PALETTE4_RGBA4_OES */ + { 23288, 0x00008B91 }, /* GL_PALETTE4_RGBA8_OES */ + { 23310, 0x00008B97 }, /* GL_PALETTE8_R5_G6_B5_OES */ + { 23335, 0x00008B99 }, /* GL_PALETTE8_RGB5_A1_OES */ + { 23359, 0x00008B95 }, /* GL_PALETTE8_RGB8_OES */ + { 23380, 0x00008B98 }, /* GL_PALETTE8_RGBA4_OES */ + { 23402, 0x00008B96 }, /* GL_PALETTE8_RGBA8_OES */ + { 23424, 0x00000700 }, /* GL_PASS_THROUGH_TOKEN */ + { 23446, 0x00000C50 }, /* GL_PERSPECTIVE_CORRECTION_HINT */ + { 23477, 0x00000C79 }, /* GL_PIXEL_MAP_A_TO_A */ + { 23497, 0x00000CB9 }, /* GL_PIXEL_MAP_A_TO_A_SIZE */ + { 23522, 0x00000C78 }, /* GL_PIXEL_MAP_B_TO_B */ + { 23542, 0x00000CB8 }, /* GL_PIXEL_MAP_B_TO_B_SIZE */ + { 23567, 0x00000C77 }, /* GL_PIXEL_MAP_G_TO_G */ + { 23587, 0x00000CB7 }, /* GL_PIXEL_MAP_G_TO_G_SIZE */ + { 23612, 0x00000C75 }, /* GL_PIXEL_MAP_I_TO_A */ + { 23632, 0x00000CB5 }, /* GL_PIXEL_MAP_I_TO_A_SIZE */ + { 23657, 0x00000C74 }, /* GL_PIXEL_MAP_I_TO_B */ + { 23677, 0x00000CB4 }, /* GL_PIXEL_MAP_I_TO_B_SIZE */ + { 23702, 0x00000C73 }, /* GL_PIXEL_MAP_I_TO_G */ + { 23722, 0x00000CB3 }, /* GL_PIXEL_MAP_I_TO_G_SIZE */ + { 23747, 0x00000C70 }, /* GL_PIXEL_MAP_I_TO_I */ + { 23767, 0x00000CB0 }, /* GL_PIXEL_MAP_I_TO_I_SIZE */ + { 23792, 0x00000C72 }, /* GL_PIXEL_MAP_I_TO_R */ + { 23812, 0x00000CB2 }, /* GL_PIXEL_MAP_I_TO_R_SIZE */ + { 23837, 0x00000C76 }, /* GL_PIXEL_MAP_R_TO_R */ + { 23857, 0x00000CB6 }, /* GL_PIXEL_MAP_R_TO_R_SIZE */ + { 23882, 0x00000C71 }, /* GL_PIXEL_MAP_S_TO_S */ + { 23902, 0x00000CB1 }, /* GL_PIXEL_MAP_S_TO_S_SIZE */ + { 23927, 0x00000020 }, /* GL_PIXEL_MODE_BIT */ + { 23945, 0x000088EB }, /* GL_PIXEL_PACK_BUFFER */ + { 23966, 0x000088ED }, /* GL_PIXEL_PACK_BUFFER_BINDING */ + { 23995, 0x000088ED }, /* GL_PIXEL_PACK_BUFFER_BINDING_EXT */ + { 24028, 0x000088EB }, /* GL_PIXEL_PACK_BUFFER_EXT */ + { 24053, 0x000088EC }, /* GL_PIXEL_UNPACK_BUFFER */ + { 24076, 0x000088EF }, /* GL_PIXEL_UNPACK_BUFFER_BINDING */ + { 24107, 0x000088EF }, /* GL_PIXEL_UNPACK_BUFFER_BINDING_EXT */ + { 24142, 0x000088EC }, /* GL_PIXEL_UNPACK_BUFFER_EXT */ + { 24169, 0x00001B00 }, /* GL_POINT */ + { 24178, 0x00000000 }, /* GL_POINTS */ + { 24188, 0x00000002 }, /* GL_POINT_BIT */ + { 24201, 0x00008129 }, /* GL_POINT_DISTANCE_ATTENUATION */ + { 24231, 0x00008129 }, /* GL_POINT_DISTANCE_ATTENUATION_ARB */ + { 24265, 0x00008129 }, /* GL_POINT_DISTANCE_ATTENUATION_EXT */ + { 24299, 0x00008129 }, /* GL_POINT_DISTANCE_ATTENUATION_SGIS */ + { 24334, 0x00008128 }, /* GL_POINT_FADE_THRESHOLD_SIZE */ + { 24363, 0x00008128 }, /* GL_POINT_FADE_THRESHOLD_SIZE_ARB */ + { 24396, 0x00008128 }, /* GL_POINT_FADE_THRESHOLD_SIZE_EXT */ + { 24429, 0x00008128 }, /* GL_POINT_FADE_THRESHOLD_SIZE_SGIS */ + { 24463, 0x00000B11 }, /* GL_POINT_SIZE */ + { 24477, 0x00000B13 }, /* GL_POINT_SIZE_GRANULARITY */ + { 24503, 0x00008127 }, /* GL_POINT_SIZE_MAX */ + { 24521, 0x00008127 }, /* GL_POINT_SIZE_MAX_ARB */ + { 24543, 0x00008127 }, /* GL_POINT_SIZE_MAX_EXT */ + { 24565, 0x00008127 }, /* GL_POINT_SIZE_MAX_SGIS */ + { 24588, 0x00008126 }, /* GL_POINT_SIZE_MIN */ + { 24606, 0x00008126 }, /* GL_POINT_SIZE_MIN_ARB */ + { 24628, 0x00008126 }, /* GL_POINT_SIZE_MIN_EXT */ + { 24650, 0x00008126 }, /* GL_POINT_SIZE_MIN_SGIS */ + { 24673, 0x00000B12 }, /* GL_POINT_SIZE_RANGE */ + { 24693, 0x00000B10 }, /* GL_POINT_SMOOTH */ + { 24709, 0x00000C51 }, /* GL_POINT_SMOOTH_HINT */ + { 24730, 0x00008861 }, /* GL_POINT_SPRITE */ + { 24746, 0x00008861 }, /* GL_POINT_SPRITE_ARB */ + { 24766, 0x00008CA0 }, /* GL_POINT_SPRITE_COORD_ORIGIN */ + { 24795, 0x00008861 }, /* GL_POINT_SPRITE_NV */ + { 24814, 0x00008863 }, /* GL_POINT_SPRITE_R_MODE_NV */ + { 24840, 0x00000701 }, /* GL_POINT_TOKEN */ + { 24855, 0x00000009 }, /* GL_POLYGON */ + { 24866, 0x00000008 }, /* GL_POLYGON_BIT */ + { 24881, 0x00000B40 }, /* GL_POLYGON_MODE */ + { 24897, 0x00008039 }, /* GL_POLYGON_OFFSET_BIAS */ + { 24920, 0x00008038 }, /* GL_POLYGON_OFFSET_FACTOR */ + { 24945, 0x00008037 }, /* GL_POLYGON_OFFSET_FILL */ + { 24968, 0x00002A02 }, /* GL_POLYGON_OFFSET_LINE */ + { 24991, 0x00002A01 }, /* GL_POLYGON_OFFSET_POINT */ + { 25015, 0x00002A00 }, /* GL_POLYGON_OFFSET_UNITS */ + { 25039, 0x00000B41 }, /* GL_POLYGON_SMOOTH */ + { 25057, 0x00000C53 }, /* GL_POLYGON_SMOOTH_HINT */ + { 25080, 0x00000B42 }, /* GL_POLYGON_STIPPLE */ + { 25099, 0x00000010 }, /* GL_POLYGON_STIPPLE_BIT */ + { 25122, 0x00000703 }, /* GL_POLYGON_TOKEN */ + { 25139, 0x00001203 }, /* GL_POSITION */ + { 25151, 0x000080BB }, /* GL_POST_COLOR_MATRIX_ALPHA_BIAS */ + { 25183, 0x000080BB }, /* GL_POST_COLOR_MATRIX_ALPHA_BIAS_SGI */ + { 25219, 0x000080B7 }, /* GL_POST_COLOR_MATRIX_ALPHA_SCALE */ + { 25252, 0x000080B7 }, /* GL_POST_COLOR_MATRIX_ALPHA_SCALE_SGI */ + { 25289, 0x000080BA }, /* GL_POST_COLOR_MATRIX_BLUE_BIAS */ + { 25320, 0x000080BA }, /* GL_POST_COLOR_MATRIX_BLUE_BIAS_SGI */ + { 25355, 0x000080B6 }, /* GL_POST_COLOR_MATRIX_BLUE_SCALE */ + { 25387, 0x000080B6 }, /* GL_POST_COLOR_MATRIX_BLUE_SCALE_SGI */ + { 25423, 0x000080D2 }, /* GL_POST_COLOR_MATRIX_COLOR_TABLE */ + { 25456, 0x000080B9 }, /* GL_POST_COLOR_MATRIX_GREEN_BIAS */ + { 25488, 0x000080B9 }, /* GL_POST_COLOR_MATRIX_GREEN_BIAS_SGI */ + { 25524, 0x000080B5 }, /* GL_POST_COLOR_MATRIX_GREEN_SCALE */ + { 25557, 0x000080B5 }, /* GL_POST_COLOR_MATRIX_GREEN_SCALE_SGI */ + { 25594, 0x000080B8 }, /* GL_POST_COLOR_MATRIX_RED_BIAS */ + { 25624, 0x000080B8 }, /* GL_POST_COLOR_MATRIX_RED_BIAS_SGI */ + { 25658, 0x000080B4 }, /* GL_POST_COLOR_MATRIX_RED_SCALE */ + { 25689, 0x000080B4 }, /* GL_POST_COLOR_MATRIX_RED_SCALE_SGI */ + { 25724, 0x00008023 }, /* GL_POST_CONVOLUTION_ALPHA_BIAS */ + { 25755, 0x00008023 }, /* GL_POST_CONVOLUTION_ALPHA_BIAS_EXT */ + { 25790, 0x0000801F }, /* GL_POST_CONVOLUTION_ALPHA_SCALE */ + { 25822, 0x0000801F }, /* GL_POST_CONVOLUTION_ALPHA_SCALE_EXT */ + { 25858, 0x00008022 }, /* GL_POST_CONVOLUTION_BLUE_BIAS */ + { 25888, 0x00008022 }, /* GL_POST_CONVOLUTION_BLUE_BIAS_EXT */ + { 25922, 0x0000801E }, /* GL_POST_CONVOLUTION_BLUE_SCALE */ + { 25953, 0x0000801E }, /* GL_POST_CONVOLUTION_BLUE_SCALE_EXT */ + { 25988, 0x000080D1 }, /* GL_POST_CONVOLUTION_COLOR_TABLE */ + { 26020, 0x00008021 }, /* GL_POST_CONVOLUTION_GREEN_BIAS */ + { 26051, 0x00008021 }, /* GL_POST_CONVOLUTION_GREEN_BIAS_EXT */ + { 26086, 0x0000801D }, /* GL_POST_CONVOLUTION_GREEN_SCALE */ + { 26118, 0x0000801D }, /* GL_POST_CONVOLUTION_GREEN_SCALE_EXT */ + { 26154, 0x00008020 }, /* GL_POST_CONVOLUTION_RED_BIAS */ + { 26183, 0x00008020 }, /* GL_POST_CONVOLUTION_RED_BIAS_EXT */ + { 26216, 0x0000801C }, /* GL_POST_CONVOLUTION_RED_SCALE */ + { 26246, 0x0000801C }, /* GL_POST_CONVOLUTION_RED_SCALE_EXT */ + { 26280, 0x0000817B }, /* GL_POST_TEXTURE_FILTER_BIAS_RANGE_SGIX */ + { 26319, 0x00008179 }, /* GL_POST_TEXTURE_FILTER_BIAS_SGIX */ + { 26352, 0x0000817C }, /* GL_POST_TEXTURE_FILTER_SCALE_RANGE_SGIX */ + { 26392, 0x0000817A }, /* GL_POST_TEXTURE_FILTER_SCALE_SGIX */ + { 26426, 0x00008578 }, /* GL_PREVIOUS */ + { 26438, 0x00008578 }, /* GL_PREVIOUS_ARB */ + { 26454, 0x00008578 }, /* GL_PREVIOUS_EXT */ + { 26470, 0x00008577 }, /* GL_PRIMARY_COLOR */ + { 26487, 0x00008577 }, /* GL_PRIMARY_COLOR_ARB */ + { 26508, 0x00008577 }, /* GL_PRIMARY_COLOR_EXT */ + { 26529, 0x000088B0 }, /* GL_PROGRAM_ADDRESS_REGISTERS_ARB */ + { 26562, 0x00008805 }, /* GL_PROGRAM_ALU_INSTRUCTIONS_ARB */ + { 26594, 0x000088AC }, /* GL_PROGRAM_ATTRIBS_ARB */ + { 26617, 0x00008677 }, /* GL_PROGRAM_BINDING_ARB */ + { 26640, 0x0000864B }, /* GL_PROGRAM_ERROR_POSITION_ARB */ + { 26670, 0x0000864B }, /* GL_PROGRAM_ERROR_POSITION_NV */ + { 26699, 0x00008874 }, /* GL_PROGRAM_ERROR_STRING_ARB */ + { 26727, 0x00008876 }, /* GL_PROGRAM_FORMAT_ARB */ + { 26749, 0x00008875 }, /* GL_PROGRAM_FORMAT_ASCII_ARB */ + { 26777, 0x000088A0 }, /* GL_PROGRAM_INSTRUCTIONS_ARB */ + { 26805, 0x00008627 }, /* GL_PROGRAM_LENGTH_ARB */ + { 26827, 0x00008627 }, /* GL_PROGRAM_LENGTH_NV */ + { 26848, 0x000088B2 }, /* GL_PROGRAM_NATIVE_ADDRESS_REGISTERS_ARB */ + { 26888, 0x00008808 }, /* GL_PROGRAM_NATIVE_ALU_INSTRUCTIONS_ARB */ + { 26927, 0x000088AE }, /* GL_PROGRAM_NATIVE_ATTRIBS_ARB */ + { 26957, 0x000088A2 }, /* GL_PROGRAM_NATIVE_INSTRUCTIONS_ARB */ + { 26992, 0x000088AA }, /* GL_PROGRAM_NATIVE_PARAMETERS_ARB */ + { 27025, 0x000088A6 }, /* GL_PROGRAM_NATIVE_TEMPORARIES_ARB */ + { 27059, 0x0000880A }, /* GL_PROGRAM_NATIVE_TEX_INDIRECTIONS_ARB */ + { 27098, 0x00008809 }, /* GL_PROGRAM_NATIVE_TEX_INSTRUCTIONS_ARB */ + { 27137, 0x00008B40 }, /* GL_PROGRAM_OBJECT_ARB */ + { 27159, 0x000088A8 }, /* GL_PROGRAM_PARAMETERS_ARB */ + { 27185, 0x00008644 }, /* GL_PROGRAM_PARAMETER_NV */ + { 27209, 0x00008647 }, /* GL_PROGRAM_RESIDENT_NV */ + { 27232, 0x00008628 }, /* GL_PROGRAM_STRING_ARB */ + { 27254, 0x00008628 }, /* GL_PROGRAM_STRING_NV */ + { 27275, 0x00008646 }, /* GL_PROGRAM_TARGET_NV */ + { 27296, 0x000088A4 }, /* GL_PROGRAM_TEMPORARIES_ARB */ + { 27323, 0x00008807 }, /* GL_PROGRAM_TEX_INDIRECTIONS_ARB */ + { 27355, 0x00008806 }, /* GL_PROGRAM_TEX_INSTRUCTIONS_ARB */ + { 27387, 0x000088B6 }, /* GL_PROGRAM_UNDER_NATIVE_LIMITS_ARB */ + { 27422, 0x00001701 }, /* GL_PROJECTION */ + { 27436, 0x00000BA7 }, /* GL_PROJECTION_MATRIX */ + { 27457, 0x00000BA4 }, /* GL_PROJECTION_STACK_DEPTH */ + { 27483, 0x00008E4F }, /* GL_PROVOKING_VERTEX_EXT */ + { 27507, 0x000080D3 }, /* GL_PROXY_COLOR_TABLE */ + { 27528, 0x00008025 }, /* GL_PROXY_HISTOGRAM */ + { 27547, 0x00008025 }, /* GL_PROXY_HISTOGRAM_EXT */ + { 27570, 0x000080D5 }, /* GL_PROXY_POST_COLOR_MATRIX_COLOR_TABLE */ + { 27609, 0x000080D4 }, /* GL_PROXY_POST_CONVOLUTION_COLOR_TABLE */ + { 27647, 0x00008063 }, /* GL_PROXY_TEXTURE_1D */ + { 27667, 0x00008C19 }, /* GL_PROXY_TEXTURE_1D_ARRAY_EXT */ + { 27697, 0x00008063 }, /* GL_PROXY_TEXTURE_1D_EXT */ + { 27721, 0x00008064 }, /* GL_PROXY_TEXTURE_2D */ + { 27741, 0x00008C1B }, /* GL_PROXY_TEXTURE_2D_ARRAY_EXT */ + { 27771, 0x00008064 }, /* GL_PROXY_TEXTURE_2D_EXT */ + { 27795, 0x00008070 }, /* GL_PROXY_TEXTURE_3D */ + { 27815, 0x000080BD }, /* GL_PROXY_TEXTURE_COLOR_TABLE_SGI */ + { 27848, 0x0000851B }, /* GL_PROXY_TEXTURE_CUBE_MAP */ + { 27874, 0x0000851B }, /* GL_PROXY_TEXTURE_CUBE_MAP_ARB */ + { 27904, 0x000084F7 }, /* GL_PROXY_TEXTURE_RECTANGLE_ARB */ + { 27935, 0x000084F7 }, /* GL_PROXY_TEXTURE_RECTANGLE_NV */ + { 27965, 0x00002003 }, /* GL_Q */ + { 27970, 0x00001209 }, /* GL_QUADRATIC_ATTENUATION */ + { 27995, 0x00000007 }, /* GL_QUADS */ + { 28004, 0x00008E4C }, /* GL_QUADS_FOLLOW_PROVOKING_VERTEX_CONVENTION_EXT */ + { 28052, 0x00008614 }, /* GL_QUAD_MESH_SUN */ + { 28069, 0x00000008 }, /* GL_QUAD_STRIP */ + { 28083, 0x00008864 }, /* GL_QUERY_COUNTER_BITS */ + { 28105, 0x00008864 }, /* GL_QUERY_COUNTER_BITS_ARB */ + { 28131, 0x00008866 }, /* GL_QUERY_RESULT */ + { 28147, 0x00008866 }, /* GL_QUERY_RESULT_ARB */ + { 28167, 0x00008867 }, /* GL_QUERY_RESULT_AVAILABLE */ + { 28193, 0x00008867 }, /* GL_QUERY_RESULT_AVAILABLE_ARB */ + { 28223, 0x00002002 }, /* GL_R */ + { 28228, 0x00002A10 }, /* GL_R3_G3_B2 */ + { 28240, 0x00019262 }, /* GL_RASTER_POSITION_UNCLIPPED_IBM */ + { 28273, 0x00000C02 }, /* GL_READ_BUFFER */ + { 28288, 0x00008CA8 }, /* GL_READ_FRAMEBUFFER */ + { 28308, 0x00008CAA }, /* GL_READ_FRAMEBUFFER_BINDING_EXT */ + { 28340, 0x00008CA8 }, /* GL_READ_FRAMEBUFFER_EXT */ + { 28364, 0x000088B8 }, /* GL_READ_ONLY */ + { 28377, 0x000088B8 }, /* GL_READ_ONLY_ARB */ + { 28394, 0x000088BA }, /* GL_READ_WRITE */ + { 28408, 0x000088BA }, /* GL_READ_WRITE_ARB */ + { 28426, 0x00001903 }, /* GL_RED */ + { 28433, 0x00008016 }, /* GL_REDUCE */ + { 28443, 0x00008016 }, /* GL_REDUCE_EXT */ + { 28457, 0x00000D15 }, /* GL_RED_BIAS */ + { 28469, 0x00000D52 }, /* GL_RED_BITS */ + { 28481, 0x00000D14 }, /* GL_RED_SCALE */ + { 28494, 0x00008512 }, /* GL_REFLECTION_MAP */ + { 28512, 0x00008512 }, /* GL_REFLECTION_MAP_ARB */ + { 28534, 0x00008512 }, /* GL_REFLECTION_MAP_NV */ + { 28555, 0x00001C00 }, /* GL_RENDER */ + { 28565, 0x00008D41 }, /* GL_RENDERBUFFER */ + { 28581, 0x00008D53 }, /* GL_RENDERBUFFER_ALPHA_SIZE */ + { 28608, 0x00008CA7 }, /* GL_RENDERBUFFER_BINDING_EXT */ + { 28636, 0x00008D52 }, /* GL_RENDERBUFFER_BLUE_SIZE */ + { 28662, 0x00008D54 }, /* GL_RENDERBUFFER_DEPTH_SIZE */ + { 28689, 0x00008D41 }, /* GL_RENDERBUFFER_EXT */ + { 28709, 0x00008D51 }, /* GL_RENDERBUFFER_GREEN_SIZE */ + { 28736, 0x00008D43 }, /* GL_RENDERBUFFER_HEIGHT */ + { 28759, 0x00008D43 }, /* GL_RENDERBUFFER_HEIGHT_EXT */ + { 28786, 0x00008D44 }, /* GL_RENDERBUFFER_INTERNAL_FORMAT */ + { 28818, 0x00008D44 }, /* GL_RENDERBUFFER_INTERNAL_FORMAT_EXT */ + { 28854, 0x00008D50 }, /* GL_RENDERBUFFER_RED_SIZE */ + { 28879, 0x00008CAB }, /* GL_RENDERBUFFER_SAMPLES */ + { 28903, 0x00008D55 }, /* GL_RENDERBUFFER_STENCIL_SIZE */ + { 28932, 0x00008D42 }, /* GL_RENDERBUFFER_WIDTH */ + { 28954, 0x00008D42 }, /* GL_RENDERBUFFER_WIDTH_EXT */ + { 28980, 0x00001F01 }, /* GL_RENDERER */ + { 28992, 0x00000C40 }, /* GL_RENDER_MODE */ + { 29007, 0x00002901 }, /* GL_REPEAT */ + { 29017, 0x00001E01 }, /* GL_REPLACE */ + { 29028, 0x00008062 }, /* GL_REPLACE_EXT */ + { 29043, 0x00008153 }, /* GL_REPLICATE_BORDER_HP */ + { 29066, 0x0000803A }, /* GL_RESCALE_NORMAL */ + { 29084, 0x0000803A }, /* GL_RESCALE_NORMAL_EXT */ + { 29106, 0x00000102 }, /* GL_RETURN */ + { 29116, 0x00001907 }, /* GL_RGB */ + { 29123, 0x00008052 }, /* GL_RGB10 */ + { 29132, 0x00008059 }, /* GL_RGB10_A2 */ + { 29144, 0x00008059 }, /* GL_RGB10_A2_EXT */ + { 29160, 0x00008052 }, /* GL_RGB10_EXT */ + { 29173, 0x00008053 }, /* GL_RGB12 */ + { 29182, 0x00008053 }, /* GL_RGB12_EXT */ + { 29195, 0x00008054 }, /* GL_RGB16 */ + { 29204, 0x00008054 }, /* GL_RGB16_EXT */ + { 29217, 0x0000804E }, /* GL_RGB2_EXT */ + { 29229, 0x0000804F }, /* GL_RGB4 */ + { 29237, 0x0000804F }, /* GL_RGB4_EXT */ + { 29249, 0x000083A1 }, /* GL_RGB4_S3TC */ + { 29262, 0x00008050 }, /* GL_RGB5 */ + { 29270, 0x00008057 }, /* GL_RGB5_A1 */ + { 29281, 0x00008057 }, /* GL_RGB5_A1_EXT */ + { 29296, 0x00008050 }, /* GL_RGB5_EXT */ + { 29308, 0x00008051 }, /* GL_RGB8 */ + { 29316, 0x00008051 }, /* GL_RGB8_EXT */ + { 29328, 0x00001908 }, /* GL_RGBA */ + { 29336, 0x0000805A }, /* GL_RGBA12 */ + { 29346, 0x0000805A }, /* GL_RGBA12_EXT */ + { 29360, 0x0000805B }, /* GL_RGBA16 */ + { 29370, 0x0000805B }, /* GL_RGBA16_EXT */ + { 29384, 0x00008055 }, /* GL_RGBA2 */ + { 29393, 0x00008055 }, /* GL_RGBA2_EXT */ + { 29406, 0x00008056 }, /* GL_RGBA4 */ + { 29415, 0x000083A5 }, /* GL_RGBA4_DXT5_S3TC */ + { 29434, 0x00008056 }, /* GL_RGBA4_EXT */ + { 29447, 0x000083A3 }, /* GL_RGBA4_S3TC */ + { 29461, 0x00008058 }, /* GL_RGBA8 */ + { 29470, 0x00008058 }, /* GL_RGBA8_EXT */ + { 29483, 0x00008F97 }, /* GL_RGBA8_SNORM */ + { 29498, 0x000083A4 }, /* GL_RGBA_DXT5_S3TC */ + { 29516, 0x00000C31 }, /* GL_RGBA_MODE */ + { 29529, 0x000083A2 }, /* GL_RGBA_S3TC */ + { 29542, 0x00008F93 }, /* GL_RGBA_SNORM */ + { 29556, 0x000083A0 }, /* GL_RGB_S3TC */ + { 29568, 0x00008573 }, /* GL_RGB_SCALE */ + { 29581, 0x00008573 }, /* GL_RGB_SCALE_ARB */ + { 29598, 0x00008573 }, /* GL_RGB_SCALE_EXT */ + { 29615, 0x00000407 }, /* GL_RIGHT */ + { 29624, 0x00002000 }, /* GL_S */ + { 29629, 0x00008B5D }, /* GL_SAMPLER_1D */ + { 29643, 0x00008B61 }, /* GL_SAMPLER_1D_SHADOW */ + { 29664, 0x00008B5E }, /* GL_SAMPLER_2D */ + { 29678, 0x00008B62 }, /* GL_SAMPLER_2D_SHADOW */ + { 29699, 0x00008B5F }, /* GL_SAMPLER_3D */ + { 29713, 0x00008B60 }, /* GL_SAMPLER_CUBE */ + { 29729, 0x000080A9 }, /* GL_SAMPLES */ + { 29740, 0x000086B4 }, /* GL_SAMPLES_3DFX */ + { 29756, 0x000080A9 }, /* GL_SAMPLES_ARB */ + { 29771, 0x00008914 }, /* GL_SAMPLES_PASSED */ + { 29789, 0x00008914 }, /* GL_SAMPLES_PASSED_ARB */ + { 29811, 0x0000809E }, /* GL_SAMPLE_ALPHA_TO_COVERAGE */ + { 29839, 0x0000809E }, /* GL_SAMPLE_ALPHA_TO_COVERAGE_ARB */ + { 29871, 0x0000809F }, /* GL_SAMPLE_ALPHA_TO_ONE */ + { 29894, 0x0000809F }, /* GL_SAMPLE_ALPHA_TO_ONE_ARB */ + { 29921, 0x000080A8 }, /* GL_SAMPLE_BUFFERS */ + { 29939, 0x000086B3 }, /* GL_SAMPLE_BUFFERS_3DFX */ + { 29962, 0x000080A8 }, /* GL_SAMPLE_BUFFERS_ARB */ + { 29984, 0x000080A0 }, /* GL_SAMPLE_COVERAGE */ + { 30003, 0x000080A0 }, /* GL_SAMPLE_COVERAGE_ARB */ + { 30026, 0x000080AB }, /* GL_SAMPLE_COVERAGE_INVERT */ + { 30052, 0x000080AB }, /* GL_SAMPLE_COVERAGE_INVERT_ARB */ + { 30082, 0x000080AA }, /* GL_SAMPLE_COVERAGE_VALUE */ + { 30107, 0x000080AA }, /* GL_SAMPLE_COVERAGE_VALUE_ARB */ + { 30136, 0x00080000 }, /* GL_SCISSOR_BIT */ + { 30151, 0x00000C10 }, /* GL_SCISSOR_BOX */ + { 30166, 0x00000C11 }, /* GL_SCISSOR_TEST */ + { 30182, 0x0000845E }, /* GL_SECONDARY_COLOR_ARRAY */ + { 30207, 0x0000889C }, /* GL_SECONDARY_COLOR_ARRAY_BUFFER_BINDING */ + { 30247, 0x0000889C }, /* GL_SECONDARY_COLOR_ARRAY_BUFFER_BINDING_ARB */ + { 30291, 0x0000845D }, /* GL_SECONDARY_COLOR_ARRAY_POINTER */ + { 30324, 0x0000845A }, /* GL_SECONDARY_COLOR_ARRAY_SIZE */ + { 30354, 0x0000845C }, /* GL_SECONDARY_COLOR_ARRAY_STRIDE */ + { 30386, 0x0000845B }, /* GL_SECONDARY_COLOR_ARRAY_TYPE */ + { 30416, 0x00001C02 }, /* GL_SELECT */ + { 30426, 0x00000DF3 }, /* GL_SELECTION_BUFFER_POINTER */ + { 30454, 0x00000DF4 }, /* GL_SELECTION_BUFFER_SIZE */ + { 30479, 0x00008012 }, /* GL_SEPARABLE_2D */ + { 30495, 0x000081FA }, /* GL_SEPARATE_SPECULAR_COLOR */ + { 30522, 0x000081FA }, /* GL_SEPARATE_SPECULAR_COLOR_EXT */ + { 30553, 0x0000150F }, /* GL_SET */ + { 30560, 0x00008B48 }, /* GL_SHADER_OBJECT_ARB */ + { 30581, 0x00008B88 }, /* GL_SHADER_SOURCE_LENGTH */ + { 30605, 0x00008B4F }, /* GL_SHADER_TYPE */ + { 30620, 0x00000B54 }, /* GL_SHADE_MODEL */ + { 30635, 0x00008B8C }, /* GL_SHADING_LANGUAGE_VERSION */ + { 30663, 0x000080BF }, /* GL_SHADOW_AMBIENT_SGIX */ + { 30686, 0x000081FB }, /* GL_SHARED_TEXTURE_PALETTE_EXT */ + { 30716, 0x00001601 }, /* GL_SHININESS */ + { 30729, 0x00001402 }, /* GL_SHORT */ + { 30738, 0x00009119 }, /* GL_SIGNALED */ + { 30750, 0x00008F9C }, /* GL_SIGNED_NORMALIZED */ + { 30771, 0x000081F9 }, /* GL_SINGLE_COLOR */ + { 30787, 0x000081F9 }, /* GL_SINGLE_COLOR_EXT */ + { 30807, 0x000085CC }, /* GL_SLICE_ACCUM_SUN */ + { 30826, 0x00008C46 }, /* GL_SLUMINANCE */ + { 30840, 0x00008C47 }, /* GL_SLUMINANCE8 */ + { 30855, 0x00008C45 }, /* GL_SLUMINANCE8_ALPHA8 */ + { 30877, 0x00008C44 }, /* GL_SLUMINANCE_ALPHA */ + { 30897, 0x00001D01 }, /* GL_SMOOTH */ + { 30907, 0x00000B23 }, /* GL_SMOOTH_LINE_WIDTH_GRANULARITY */ + { 30940, 0x00000B22 }, /* GL_SMOOTH_LINE_WIDTH_RANGE */ + { 30967, 0x00000B13 }, /* GL_SMOOTH_POINT_SIZE_GRANULARITY */ + { 31000, 0x00000B12 }, /* GL_SMOOTH_POINT_SIZE_RANGE */ + { 31027, 0x00008588 }, /* GL_SOURCE0_ALPHA */ + { 31044, 0x00008588 }, /* GL_SOURCE0_ALPHA_ARB */ + { 31065, 0x00008588 }, /* GL_SOURCE0_ALPHA_EXT */ + { 31086, 0x00008580 }, /* GL_SOURCE0_RGB */ + { 31101, 0x00008580 }, /* GL_SOURCE0_RGB_ARB */ + { 31120, 0x00008580 }, /* GL_SOURCE0_RGB_EXT */ + { 31139, 0x00008589 }, /* GL_SOURCE1_ALPHA */ + { 31156, 0x00008589 }, /* GL_SOURCE1_ALPHA_ARB */ + { 31177, 0x00008589 }, /* GL_SOURCE1_ALPHA_EXT */ + { 31198, 0x00008581 }, /* GL_SOURCE1_RGB */ + { 31213, 0x00008581 }, /* GL_SOURCE1_RGB_ARB */ + { 31232, 0x00008581 }, /* GL_SOURCE1_RGB_EXT */ + { 31251, 0x0000858A }, /* GL_SOURCE2_ALPHA */ + { 31268, 0x0000858A }, /* GL_SOURCE2_ALPHA_ARB */ + { 31289, 0x0000858A }, /* GL_SOURCE2_ALPHA_EXT */ + { 31310, 0x00008582 }, /* GL_SOURCE2_RGB */ + { 31325, 0x00008582 }, /* GL_SOURCE2_RGB_ARB */ + { 31344, 0x00008582 }, /* GL_SOURCE2_RGB_EXT */ + { 31363, 0x0000858B }, /* GL_SOURCE3_ALPHA_NV */ + { 31383, 0x00008583 }, /* GL_SOURCE3_RGB_NV */ + { 31401, 0x00001202 }, /* GL_SPECULAR */ + { 31413, 0x00002402 }, /* GL_SPHERE_MAP */ + { 31427, 0x00001206 }, /* GL_SPOT_CUTOFF */ + { 31442, 0x00001204 }, /* GL_SPOT_DIRECTION */ + { 31460, 0x00001205 }, /* GL_SPOT_EXPONENT */ + { 31477, 0x00008588 }, /* GL_SRC0_ALPHA */ + { 31491, 0x00008580 }, /* GL_SRC0_RGB */ + { 31503, 0x00008589 }, /* GL_SRC1_ALPHA */ + { 31517, 0x00008581 }, /* GL_SRC1_RGB */ + { 31529, 0x0000858A }, /* GL_SRC2_ALPHA */ + { 31543, 0x00008582 }, /* GL_SRC2_RGB */ + { 31555, 0x00000302 }, /* GL_SRC_ALPHA */ + { 31568, 0x00000308 }, /* GL_SRC_ALPHA_SATURATE */ + { 31590, 0x00000300 }, /* GL_SRC_COLOR */ + { 31603, 0x00008C40 }, /* GL_SRGB */ + { 31611, 0x00008C41 }, /* GL_SRGB8 */ + { 31620, 0x00008C43 }, /* GL_SRGB8_ALPHA8 */ + { 31636, 0x00008C42 }, /* GL_SRGB_ALPHA */ + { 31650, 0x00000503 }, /* GL_STACK_OVERFLOW */ + { 31668, 0x00000504 }, /* GL_STACK_UNDERFLOW */ + { 31687, 0x000088E6 }, /* GL_STATIC_COPY */ + { 31702, 0x000088E6 }, /* GL_STATIC_COPY_ARB */ + { 31721, 0x000088E4 }, /* GL_STATIC_DRAW */ + { 31736, 0x000088E4 }, /* GL_STATIC_DRAW_ARB */ + { 31755, 0x000088E5 }, /* GL_STATIC_READ */ + { 31770, 0x000088E5 }, /* GL_STATIC_READ_ARB */ + { 31789, 0x00001802 }, /* GL_STENCIL */ + { 31800, 0x00008D20 }, /* GL_STENCIL_ATTACHMENT */ + { 31822, 0x00008D20 }, /* GL_STENCIL_ATTACHMENT_EXT */ + { 31848, 0x00008801 }, /* GL_STENCIL_BACK_FAIL */ + { 31869, 0x00008801 }, /* GL_STENCIL_BACK_FAIL_ATI */ + { 31894, 0x00008800 }, /* GL_STENCIL_BACK_FUNC */ + { 31915, 0x00008800 }, /* GL_STENCIL_BACK_FUNC_ATI */ + { 31940, 0x00008802 }, /* GL_STENCIL_BACK_PASS_DEPTH_FAIL */ + { 31972, 0x00008802 }, /* GL_STENCIL_BACK_PASS_DEPTH_FAIL_ATI */ + { 32008, 0x00008803 }, /* GL_STENCIL_BACK_PASS_DEPTH_PASS */ + { 32040, 0x00008803 }, /* GL_STENCIL_BACK_PASS_DEPTH_PASS_ATI */ + { 32076, 0x00008CA3 }, /* GL_STENCIL_BACK_REF */ + { 32096, 0x00008CA4 }, /* GL_STENCIL_BACK_VALUE_MASK */ + { 32123, 0x00008CA5 }, /* GL_STENCIL_BACK_WRITEMASK */ + { 32149, 0x00000D57 }, /* GL_STENCIL_BITS */ + { 32165, 0x00000400 }, /* GL_STENCIL_BUFFER_BIT */ + { 32187, 0x00000B91 }, /* GL_STENCIL_CLEAR_VALUE */ + { 32210, 0x00000B94 }, /* GL_STENCIL_FAIL */ + { 32226, 0x00000B92 }, /* GL_STENCIL_FUNC */ + { 32242, 0x00001901 }, /* GL_STENCIL_INDEX */ + { 32259, 0x00008D49 }, /* GL_STENCIL_INDEX16_EXT */ + { 32282, 0x00008D46 }, /* GL_STENCIL_INDEX1_EXT */ + { 32304, 0x00008D47 }, /* GL_STENCIL_INDEX4_EXT */ + { 32326, 0x00008D48 }, /* GL_STENCIL_INDEX8_EXT */ + { 32348, 0x00008D45 }, /* GL_STENCIL_INDEX_EXT */ + { 32369, 0x00000B95 }, /* GL_STENCIL_PASS_DEPTH_FAIL */ + { 32396, 0x00000B96 }, /* GL_STENCIL_PASS_DEPTH_PASS */ + { 32423, 0x00000B97 }, /* GL_STENCIL_REF */ + { 32438, 0x00000B90 }, /* GL_STENCIL_TEST */ + { 32454, 0x00008910 }, /* GL_STENCIL_TEST_TWO_SIDE_EXT */ + { 32483, 0x00000B93 }, /* GL_STENCIL_VALUE_MASK */ + { 32505, 0x00000B98 }, /* GL_STENCIL_WRITEMASK */ + { 32526, 0x00000C33 }, /* GL_STEREO */ + { 32536, 0x000085BE }, /* GL_STORAGE_CACHED_APPLE */ + { 32560, 0x000085BD }, /* GL_STORAGE_PRIVATE_APPLE */ + { 32585, 0x000085BF }, /* GL_STORAGE_SHARED_APPLE */ + { 32609, 0x000088E2 }, /* GL_STREAM_COPY */ + { 32624, 0x000088E2 }, /* GL_STREAM_COPY_ARB */ + { 32643, 0x000088E0 }, /* GL_STREAM_DRAW */ + { 32658, 0x000088E0 }, /* GL_STREAM_DRAW_ARB */ + { 32677, 0x000088E1 }, /* GL_STREAM_READ */ + { 32692, 0x000088E1 }, /* GL_STREAM_READ_ARB */ + { 32711, 0x00000D50 }, /* GL_SUBPIXEL_BITS */ + { 32728, 0x000084E7 }, /* GL_SUBTRACT */ + { 32740, 0x000084E7 }, /* GL_SUBTRACT_ARB */ + { 32756, 0x00009113 }, /* GL_SYNC_CONDITION */ + { 32774, 0x00009116 }, /* GL_SYNC_FENCE */ + { 32788, 0x00009115 }, /* GL_SYNC_FLAGS */ + { 32802, 0x00000001 }, /* GL_SYNC_FLUSH_COMMANDS_BIT */ + { 32829, 0x00009117 }, /* GL_SYNC_GPU_COMMANDS_COMPLETE */ + { 32859, 0x00009114 }, /* GL_SYNC_STATUS */ + { 32874, 0x00002001 }, /* GL_T */ + { 32879, 0x00002A2A }, /* GL_T2F_C3F_V3F */ + { 32894, 0x00002A2C }, /* GL_T2F_C4F_N3F_V3F */ + { 32913, 0x00002A29 }, /* GL_T2F_C4UB_V3F */ + { 32929, 0x00002A2B }, /* GL_T2F_N3F_V3F */ + { 32944, 0x00002A27 }, /* GL_T2F_V3F */ + { 32955, 0x00002A2D }, /* GL_T4F_C4F_N3F_V4F */ + { 32974, 0x00002A28 }, /* GL_T4F_V4F */ + { 32985, 0x00008031 }, /* GL_TABLE_TOO_LARGE_EXT */ + { 33008, 0x00001702 }, /* GL_TEXTURE */ + { 33019, 0x000084C0 }, /* GL_TEXTURE0 */ + { 33031, 0x000084C0 }, /* GL_TEXTURE0_ARB */ + { 33047, 0x000084C1 }, /* GL_TEXTURE1 */ + { 33059, 0x000084CA }, /* GL_TEXTURE10 */ + { 33072, 0x000084CA }, /* GL_TEXTURE10_ARB */ + { 33089, 0x000084CB }, /* GL_TEXTURE11 */ + { 33102, 0x000084CB }, /* GL_TEXTURE11_ARB */ + { 33119, 0x000084CC }, /* GL_TEXTURE12 */ + { 33132, 0x000084CC }, /* GL_TEXTURE12_ARB */ + { 33149, 0x000084CD }, /* GL_TEXTURE13 */ + { 33162, 0x000084CD }, /* GL_TEXTURE13_ARB */ + { 33179, 0x000084CE }, /* GL_TEXTURE14 */ + { 33192, 0x000084CE }, /* GL_TEXTURE14_ARB */ + { 33209, 0x000084CF }, /* GL_TEXTURE15 */ + { 33222, 0x000084CF }, /* GL_TEXTURE15_ARB */ + { 33239, 0x000084D0 }, /* GL_TEXTURE16 */ + { 33252, 0x000084D0 }, /* GL_TEXTURE16_ARB */ + { 33269, 0x000084D1 }, /* GL_TEXTURE17 */ + { 33282, 0x000084D1 }, /* GL_TEXTURE17_ARB */ + { 33299, 0x000084D2 }, /* GL_TEXTURE18 */ + { 33312, 0x000084D2 }, /* GL_TEXTURE18_ARB */ + { 33329, 0x000084D3 }, /* GL_TEXTURE19 */ + { 33342, 0x000084D3 }, /* GL_TEXTURE19_ARB */ + { 33359, 0x000084C1 }, /* GL_TEXTURE1_ARB */ + { 33375, 0x000084C2 }, /* GL_TEXTURE2 */ + { 33387, 0x000084D4 }, /* GL_TEXTURE20 */ + { 33400, 0x000084D4 }, /* GL_TEXTURE20_ARB */ + { 33417, 0x000084D5 }, /* GL_TEXTURE21 */ + { 33430, 0x000084D5 }, /* GL_TEXTURE21_ARB */ + { 33447, 0x000084D6 }, /* GL_TEXTURE22 */ + { 33460, 0x000084D6 }, /* GL_TEXTURE22_ARB */ + { 33477, 0x000084D7 }, /* GL_TEXTURE23 */ + { 33490, 0x000084D7 }, /* GL_TEXTURE23_ARB */ + { 33507, 0x000084D8 }, /* GL_TEXTURE24 */ + { 33520, 0x000084D8 }, /* GL_TEXTURE24_ARB */ + { 33537, 0x000084D9 }, /* GL_TEXTURE25 */ + { 33550, 0x000084D9 }, /* GL_TEXTURE25_ARB */ + { 33567, 0x000084DA }, /* GL_TEXTURE26 */ + { 33580, 0x000084DA }, /* GL_TEXTURE26_ARB */ + { 33597, 0x000084DB }, /* GL_TEXTURE27 */ + { 33610, 0x000084DB }, /* GL_TEXTURE27_ARB */ + { 33627, 0x000084DC }, /* GL_TEXTURE28 */ + { 33640, 0x000084DC }, /* GL_TEXTURE28_ARB */ + { 33657, 0x000084DD }, /* GL_TEXTURE29 */ + { 33670, 0x000084DD }, /* GL_TEXTURE29_ARB */ + { 33687, 0x000084C2 }, /* GL_TEXTURE2_ARB */ + { 33703, 0x000084C3 }, /* GL_TEXTURE3 */ + { 33715, 0x000084DE }, /* GL_TEXTURE30 */ + { 33728, 0x000084DE }, /* GL_TEXTURE30_ARB */ + { 33745, 0x000084DF }, /* GL_TEXTURE31 */ + { 33758, 0x000084DF }, /* GL_TEXTURE31_ARB */ + { 33775, 0x000084C3 }, /* GL_TEXTURE3_ARB */ + { 33791, 0x000084C4 }, /* GL_TEXTURE4 */ + { 33803, 0x000084C4 }, /* GL_TEXTURE4_ARB */ + { 33819, 0x000084C5 }, /* GL_TEXTURE5 */ + { 33831, 0x000084C5 }, /* GL_TEXTURE5_ARB */ + { 33847, 0x000084C6 }, /* GL_TEXTURE6 */ + { 33859, 0x000084C6 }, /* GL_TEXTURE6_ARB */ + { 33875, 0x000084C7 }, /* GL_TEXTURE7 */ + { 33887, 0x000084C7 }, /* GL_TEXTURE7_ARB */ + { 33903, 0x000084C8 }, /* GL_TEXTURE8 */ + { 33915, 0x000084C8 }, /* GL_TEXTURE8_ARB */ + { 33931, 0x000084C9 }, /* GL_TEXTURE9 */ + { 33943, 0x000084C9 }, /* GL_TEXTURE9_ARB */ + { 33959, 0x00000DE0 }, /* GL_TEXTURE_1D */ + { 33973, 0x00008C18 }, /* GL_TEXTURE_1D_ARRAY_EXT */ + { 33997, 0x00000DE1 }, /* GL_TEXTURE_2D */ + { 34011, 0x00008C1A }, /* GL_TEXTURE_2D_ARRAY_EXT */ + { 34035, 0x0000806F }, /* GL_TEXTURE_3D */ + { 34049, 0x0000805F }, /* GL_TEXTURE_ALPHA_SIZE */ + { 34071, 0x0000805F }, /* GL_TEXTURE_ALPHA_SIZE_EXT */ + { 34097, 0x0000813C }, /* GL_TEXTURE_BASE_LEVEL */ + { 34119, 0x00008068 }, /* GL_TEXTURE_BINDING_1D */ + { 34141, 0x00008C1C }, /* GL_TEXTURE_BINDING_1D_ARRAY_EXT */ + { 34173, 0x00008069 }, /* GL_TEXTURE_BINDING_2D */ + { 34195, 0x00008C1D }, /* GL_TEXTURE_BINDING_2D_ARRAY_EXT */ + { 34227, 0x0000806A }, /* GL_TEXTURE_BINDING_3D */ + { 34249, 0x00008514 }, /* GL_TEXTURE_BINDING_CUBE_MAP */ + { 34277, 0x00008514 }, /* GL_TEXTURE_BINDING_CUBE_MAP_ARB */ + { 34309, 0x000084F6 }, /* GL_TEXTURE_BINDING_RECTANGLE_ARB */ + { 34342, 0x000084F6 }, /* GL_TEXTURE_BINDING_RECTANGLE_NV */ + { 34374, 0x00040000 }, /* GL_TEXTURE_BIT */ + { 34389, 0x0000805E }, /* GL_TEXTURE_BLUE_SIZE */ + { 34410, 0x0000805E }, /* GL_TEXTURE_BLUE_SIZE_EXT */ + { 34435, 0x00001005 }, /* GL_TEXTURE_BORDER */ + { 34453, 0x00001004 }, /* GL_TEXTURE_BORDER_COLOR */ + { 34477, 0x00008171 }, /* GL_TEXTURE_CLIPMAP_CENTER_SGIX */ + { 34508, 0x00008176 }, /* GL_TEXTURE_CLIPMAP_DEPTH_SGIX */ + { 34538, 0x00008172 }, /* GL_TEXTURE_CLIPMAP_FRAME_SGIX */ + { 34568, 0x00008175 }, /* GL_TEXTURE_CLIPMAP_LOD_OFFSET_SGIX */ + { 34603, 0x00008173 }, /* GL_TEXTURE_CLIPMAP_OFFSET_SGIX */ + { 34634, 0x00008174 }, /* GL_TEXTURE_CLIPMAP_VIRTUAL_DEPTH_SGIX */ + { 34672, 0x000080BC }, /* GL_TEXTURE_COLOR_TABLE_SGI */ + { 34699, 0x000081EF }, /* GL_TEXTURE_COLOR_WRITEMASK_SGIS */ + { 34731, 0x000080BF }, /* GL_TEXTURE_COMPARE_FAIL_VALUE_ARB */ + { 34765, 0x0000884D }, /* GL_TEXTURE_COMPARE_FUNC */ + { 34789, 0x0000884D }, /* GL_TEXTURE_COMPARE_FUNC_ARB */ + { 34817, 0x0000884C }, /* GL_TEXTURE_COMPARE_MODE */ + { 34841, 0x0000884C }, /* GL_TEXTURE_COMPARE_MODE_ARB */ + { 34869, 0x0000819B }, /* GL_TEXTURE_COMPARE_OPERATOR_SGIX */ + { 34902, 0x0000819A }, /* GL_TEXTURE_COMPARE_SGIX */ + { 34926, 0x00001003 }, /* GL_TEXTURE_COMPONENTS */ + { 34948, 0x000086A1 }, /* GL_TEXTURE_COMPRESSED */ + { 34970, 0x000086A1 }, /* GL_TEXTURE_COMPRESSED_ARB */ + { 34996, 0x000086A3 }, /* GL_TEXTURE_COMPRESSED_FORMATS_ARB */ + { 35030, 0x000086A0 }, /* GL_TEXTURE_COMPRESSED_IMAGE_SIZE */ + { 35063, 0x000086A0 }, /* GL_TEXTURE_COMPRESSED_IMAGE_SIZE_ARB */ + { 35100, 0x000084EF }, /* GL_TEXTURE_COMPRESSION_HINT */ + { 35128, 0x000084EF }, /* GL_TEXTURE_COMPRESSION_HINT_ARB */ + { 35160, 0x00008078 }, /* GL_TEXTURE_COORD_ARRAY */ + { 35183, 0x0000889A }, /* GL_TEXTURE_COORD_ARRAY_BUFFER_BINDING */ + { 35221, 0x0000889A }, /* GL_TEXTURE_COORD_ARRAY_BUFFER_BINDING_ARB */ + { 35263, 0x00008092 }, /* GL_TEXTURE_COORD_ARRAY_POINTER */ + { 35294, 0x00008088 }, /* GL_TEXTURE_COORD_ARRAY_SIZE */ + { 35322, 0x0000808A }, /* GL_TEXTURE_COORD_ARRAY_STRIDE */ + { 35352, 0x00008089 }, /* GL_TEXTURE_COORD_ARRAY_TYPE */ + { 35380, 0x00008513 }, /* GL_TEXTURE_CUBE_MAP */ + { 35400, 0x00008513 }, /* GL_TEXTURE_CUBE_MAP_ARB */ + { 35424, 0x00008516 }, /* GL_TEXTURE_CUBE_MAP_NEGATIVE_X */ + { 35455, 0x00008516 }, /* GL_TEXTURE_CUBE_MAP_NEGATIVE_X_ARB */ + { 35490, 0x00008518 }, /* GL_TEXTURE_CUBE_MAP_NEGATIVE_Y */ + { 35521, 0x00008518 }, /* GL_TEXTURE_CUBE_MAP_NEGATIVE_Y_ARB */ + { 35556, 0x0000851A }, /* GL_TEXTURE_CUBE_MAP_NEGATIVE_Z */ + { 35587, 0x0000851A }, /* GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_ARB */ + { 35622, 0x00008515 }, /* GL_TEXTURE_CUBE_MAP_POSITIVE_X */ + { 35653, 0x00008515 }, /* GL_TEXTURE_CUBE_MAP_POSITIVE_X_ARB */ + { 35688, 0x00008517 }, /* GL_TEXTURE_CUBE_MAP_POSITIVE_Y */ + { 35719, 0x00008517 }, /* GL_TEXTURE_CUBE_MAP_POSITIVE_Y_ARB */ + { 35754, 0x00008519 }, /* GL_TEXTURE_CUBE_MAP_POSITIVE_Z */ + { 35785, 0x00008519 }, /* GL_TEXTURE_CUBE_MAP_POSITIVE_Z_ARB */ + { 35820, 0x000088F4 }, /* GL_TEXTURE_CUBE_MAP_SEAMLESS */ + { 35849, 0x00008071 }, /* GL_TEXTURE_DEPTH */ + { 35866, 0x0000884A }, /* GL_TEXTURE_DEPTH_SIZE */ + { 35888, 0x0000884A }, /* GL_TEXTURE_DEPTH_SIZE_ARB */ + { 35914, 0x00002300 }, /* GL_TEXTURE_ENV */ + { 35929, 0x00002201 }, /* GL_TEXTURE_ENV_COLOR */ + { 35950, 0x00002200 }, /* GL_TEXTURE_ENV_MODE */ + { 35970, 0x00008500 }, /* GL_TEXTURE_FILTER_CONTROL */ + { 35996, 0x00002500 }, /* GL_TEXTURE_GEN_MODE */ + { 36016, 0x00000C63 }, /* GL_TEXTURE_GEN_Q */ + { 36033, 0x00000C62 }, /* GL_TEXTURE_GEN_R */ + { 36050, 0x00000C60 }, /* GL_TEXTURE_GEN_S */ + { 36067, 0x00000C61 }, /* GL_TEXTURE_GEN_T */ + { 36084, 0x0000819D }, /* GL_TEXTURE_GEQUAL_R_SGIX */ + { 36109, 0x0000805D }, /* GL_TEXTURE_GREEN_SIZE */ + { 36131, 0x0000805D }, /* GL_TEXTURE_GREEN_SIZE_EXT */ + { 36157, 0x00001001 }, /* GL_TEXTURE_HEIGHT */ + { 36175, 0x000080ED }, /* GL_TEXTURE_INDEX_SIZE_EXT */ + { 36201, 0x00008061 }, /* GL_TEXTURE_INTENSITY_SIZE */ + { 36227, 0x00008061 }, /* GL_TEXTURE_INTENSITY_SIZE_EXT */ + { 36257, 0x00001003 }, /* GL_TEXTURE_INTERNAL_FORMAT */ + { 36284, 0x0000819C }, /* GL_TEXTURE_LEQUAL_R_SGIX */ + { 36309, 0x00008501 }, /* GL_TEXTURE_LOD_BIAS */ + { 36329, 0x00008501 }, /* GL_TEXTURE_LOD_BIAS_EXT */ + { 36353, 0x00008190 }, /* GL_TEXTURE_LOD_BIAS_R_SGIX */ + { 36380, 0x0000818E }, /* GL_TEXTURE_LOD_BIAS_S_SGIX */ + { 36407, 0x0000818F }, /* GL_TEXTURE_LOD_BIAS_T_SGIX */ + { 36434, 0x00008060 }, /* GL_TEXTURE_LUMINANCE_SIZE */ + { 36460, 0x00008060 }, /* GL_TEXTURE_LUMINANCE_SIZE_EXT */ + { 36490, 0x00002800 }, /* GL_TEXTURE_MAG_FILTER */ + { 36512, 0x00000BA8 }, /* GL_TEXTURE_MATRIX */ + { 36530, 0x000084FE }, /* GL_TEXTURE_MAX_ANISOTROPY_EXT */ + { 36560, 0x0000836B }, /* GL_TEXTURE_MAX_CLAMP_R_SGIX */ + { 36588, 0x00008369 }, /* GL_TEXTURE_MAX_CLAMP_S_SGIX */ + { 36616, 0x0000836A }, /* GL_TEXTURE_MAX_CLAMP_T_SGIX */ + { 36644, 0x0000813D }, /* GL_TEXTURE_MAX_LEVEL */ + { 36665, 0x0000813B }, /* GL_TEXTURE_MAX_LOD */ + { 36684, 0x00002801 }, /* GL_TEXTURE_MIN_FILTER */ + { 36706, 0x0000813A }, /* GL_TEXTURE_MIN_LOD */ + { 36725, 0x00008066 }, /* GL_TEXTURE_PRIORITY */ + { 36745, 0x000085B7 }, /* GL_TEXTURE_RANGE_LENGTH_APPLE */ + { 36775, 0x000085B8 }, /* GL_TEXTURE_RANGE_POINTER_APPLE */ + { 36806, 0x000084F5 }, /* GL_TEXTURE_RECTANGLE_ARB */ + { 36831, 0x000084F5 }, /* GL_TEXTURE_RECTANGLE_NV */ + { 36855, 0x0000805C }, /* GL_TEXTURE_RED_SIZE */ + { 36875, 0x0000805C }, /* GL_TEXTURE_RED_SIZE_EXT */ + { 36899, 0x00008067 }, /* GL_TEXTURE_RESIDENT */ + { 36919, 0x00000BA5 }, /* GL_TEXTURE_STACK_DEPTH */ + { 36942, 0x000088F1 }, /* GL_TEXTURE_STENCIL_SIZE */ + { 36966, 0x000085BC }, /* GL_TEXTURE_STORAGE_HINT_APPLE */ + { 36996, 0x00008065 }, /* GL_TEXTURE_TOO_LARGE_EXT */ + { 37021, 0x0000888F }, /* GL_TEXTURE_UNSIGNED_REMAP_MODE_NV */ + { 37055, 0x00001000 }, /* GL_TEXTURE_WIDTH */ + { 37072, 0x00008072 }, /* GL_TEXTURE_WRAP_R */ + { 37090, 0x00002802 }, /* GL_TEXTURE_WRAP_S */ + { 37108, 0x00002803 }, /* GL_TEXTURE_WRAP_T */ + { 37126, 0x0000911B }, /* GL_TIMEOUT_EXPIRED */ + { 37145, 0xFFFFFFFFFFFFFFFF }, /* GL_TIMEOUT_IGNORED */ + { 37164, 0x000088BF }, /* GL_TIME_ELAPSED_EXT */ + { 37184, 0x00008648 }, /* GL_TRACK_MATRIX_NV */ + { 37203, 0x00008649 }, /* GL_TRACK_MATRIX_TRANSFORM_NV */ + { 37232, 0x00001000 }, /* GL_TRANSFORM_BIT */ + { 37249, 0x000084E6 }, /* GL_TRANSPOSE_COLOR_MATRIX */ + { 37275, 0x000084E6 }, /* GL_TRANSPOSE_COLOR_MATRIX_ARB */ + { 37305, 0x000088B7 }, /* GL_TRANSPOSE_CURRENT_MATRIX_ARB */ + { 37337, 0x000084E3 }, /* GL_TRANSPOSE_MODELVIEW_MATRIX */ + { 37367, 0x000084E3 }, /* GL_TRANSPOSE_MODELVIEW_MATRIX_ARB */ + { 37401, 0x0000862C }, /* GL_TRANSPOSE_NV */ + { 37417, 0x000084E4 }, /* GL_TRANSPOSE_PROJECTION_MATRIX */ + { 37448, 0x000084E4 }, /* GL_TRANSPOSE_PROJECTION_MATRIX_ARB */ + { 37483, 0x000084E5 }, /* GL_TRANSPOSE_TEXTURE_MATRIX */ + { 37511, 0x000084E5 }, /* GL_TRANSPOSE_TEXTURE_MATRIX_ARB */ + { 37543, 0x00000004 }, /* GL_TRIANGLES */ + { 37556, 0x00000006 }, /* GL_TRIANGLE_FAN */ + { 37572, 0x00008615 }, /* GL_TRIANGLE_MESH_SUN */ + { 37593, 0x00000005 }, /* GL_TRIANGLE_STRIP */ + { 37611, 0x00000001 }, /* GL_TRUE */ + { 37619, 0x00000CF5 }, /* GL_UNPACK_ALIGNMENT */ + { 37639, 0x0000806E }, /* GL_UNPACK_IMAGE_HEIGHT */ + { 37662, 0x00000CF1 }, /* GL_UNPACK_LSB_FIRST */ + { 37682, 0x00000CF2 }, /* GL_UNPACK_ROW_LENGTH */ + { 37703, 0x0000806D }, /* GL_UNPACK_SKIP_IMAGES */ + { 37725, 0x00000CF4 }, /* GL_UNPACK_SKIP_PIXELS */ + { 37747, 0x00000CF3 }, /* GL_UNPACK_SKIP_ROWS */ + { 37767, 0x00000CF0 }, /* GL_UNPACK_SWAP_BYTES */ + { 37788, 0x00009118 }, /* GL_UNSIGNALED */ + { 37802, 0x00001401 }, /* GL_UNSIGNED_BYTE */ + { 37819, 0x00008362 }, /* GL_UNSIGNED_BYTE_2_3_3_REV */ + { 37846, 0x00008032 }, /* GL_UNSIGNED_BYTE_3_3_2 */ + { 37869, 0x00001405 }, /* GL_UNSIGNED_INT */ + { 37885, 0x00008036 }, /* GL_UNSIGNED_INT_10_10_10_2 */ + { 37912, 0x000084FA }, /* GL_UNSIGNED_INT_24_8 */ + { 37933, 0x000084FA }, /* GL_UNSIGNED_INT_24_8_NV */ + { 37957, 0x00008368 }, /* GL_UNSIGNED_INT_2_10_10_10_REV */ + { 37988, 0x00008035 }, /* GL_UNSIGNED_INT_8_8_8_8 */ + { 38012, 0x00008367 }, /* GL_UNSIGNED_INT_8_8_8_8_REV */ + { 38040, 0x00008C17 }, /* GL_UNSIGNED_NORMALIZED */ + { 38063, 0x00001403 }, /* GL_UNSIGNED_SHORT */ + { 38081, 0x00008366 }, /* GL_UNSIGNED_SHORT_1_5_5_5_REV */ + { 38111, 0x00008033 }, /* GL_UNSIGNED_SHORT_4_4_4_4 */ + { 38137, 0x00008365 }, /* GL_UNSIGNED_SHORT_4_4_4_4_REV */ + { 38167, 0x00008034 }, /* GL_UNSIGNED_SHORT_5_5_5_1 */ + { 38193, 0x00008363 }, /* GL_UNSIGNED_SHORT_5_6_5 */ + { 38217, 0x00008364 }, /* GL_UNSIGNED_SHORT_5_6_5_REV */ + { 38245, 0x000085BA }, /* GL_UNSIGNED_SHORT_8_8_APPLE */ + { 38273, 0x000085BA }, /* GL_UNSIGNED_SHORT_8_8_MESA */ + { 38300, 0x000085BB }, /* GL_UNSIGNED_SHORT_8_8_REV_APPLE */ + { 38332, 0x000085BB }, /* GL_UNSIGNED_SHORT_8_8_REV_MESA */ + { 38363, 0x00008CA2 }, /* GL_UPPER_LEFT */ + { 38377, 0x00002A20 }, /* GL_V2F */ + { 38384, 0x00002A21 }, /* GL_V3F */ + { 38391, 0x00008B83 }, /* GL_VALIDATE_STATUS */ + { 38410, 0x00001F00 }, /* GL_VENDOR */ + { 38420, 0x00001F02 }, /* GL_VERSION */ + { 38431, 0x00008074 }, /* GL_VERTEX_ARRAY */ + { 38447, 0x000085B5 }, /* GL_VERTEX_ARRAY_BINDING */ + { 38471, 0x000085B5 }, /* GL_VERTEX_ARRAY_BINDING_APPLE */ + { 38501, 0x00008896 }, /* GL_VERTEX_ARRAY_BUFFER_BINDING */ + { 38532, 0x00008896 }, /* GL_VERTEX_ARRAY_BUFFER_BINDING_ARB */ + { 38567, 0x0000808E }, /* GL_VERTEX_ARRAY_POINTER */ + { 38591, 0x0000807A }, /* GL_VERTEX_ARRAY_SIZE */ + { 38612, 0x0000807C }, /* GL_VERTEX_ARRAY_STRIDE */ + { 38635, 0x0000807B }, /* GL_VERTEX_ARRAY_TYPE */ + { 38656, 0x00008650 }, /* GL_VERTEX_ATTRIB_ARRAY0_NV */ + { 38683, 0x0000865A }, /* GL_VERTEX_ATTRIB_ARRAY10_NV */ + { 38711, 0x0000865B }, /* GL_VERTEX_ATTRIB_ARRAY11_NV */ + { 38739, 0x0000865C }, /* GL_VERTEX_ATTRIB_ARRAY12_NV */ + { 38767, 0x0000865D }, /* GL_VERTEX_ATTRIB_ARRAY13_NV */ + { 38795, 0x0000865E }, /* GL_VERTEX_ATTRIB_ARRAY14_NV */ + { 38823, 0x0000865F }, /* GL_VERTEX_ATTRIB_ARRAY15_NV */ + { 38851, 0x00008651 }, /* GL_VERTEX_ATTRIB_ARRAY1_NV */ + { 38878, 0x00008652 }, /* GL_VERTEX_ATTRIB_ARRAY2_NV */ + { 38905, 0x00008653 }, /* GL_VERTEX_ATTRIB_ARRAY3_NV */ + { 38932, 0x00008654 }, /* GL_VERTEX_ATTRIB_ARRAY4_NV */ + { 38959, 0x00008655 }, /* GL_VERTEX_ATTRIB_ARRAY5_NV */ + { 38986, 0x00008656 }, /* GL_VERTEX_ATTRIB_ARRAY6_NV */ + { 39013, 0x00008657 }, /* GL_VERTEX_ATTRIB_ARRAY7_NV */ + { 39040, 0x00008658 }, /* GL_VERTEX_ATTRIB_ARRAY8_NV */ + { 39067, 0x00008659 }, /* GL_VERTEX_ATTRIB_ARRAY9_NV */ + { 39094, 0x0000889F }, /* GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING */ + { 39132, 0x0000889F }, /* GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING_ARB */ + { 39174, 0x00008622 }, /* GL_VERTEX_ATTRIB_ARRAY_ENABLED */ + { 39205, 0x00008622 }, /* GL_VERTEX_ATTRIB_ARRAY_ENABLED_ARB */ + { 39240, 0x0000886A }, /* GL_VERTEX_ATTRIB_ARRAY_NORMALIZED */ + { 39274, 0x0000886A }, /* GL_VERTEX_ATTRIB_ARRAY_NORMALIZED_ARB */ + { 39312, 0x00008645 }, /* GL_VERTEX_ATTRIB_ARRAY_POINTER */ + { 39343, 0x00008645 }, /* GL_VERTEX_ATTRIB_ARRAY_POINTER_ARB */ + { 39378, 0x00008623 }, /* GL_VERTEX_ATTRIB_ARRAY_SIZE */ + { 39406, 0x00008623 }, /* GL_VERTEX_ATTRIB_ARRAY_SIZE_ARB */ + { 39438, 0x00008624 }, /* GL_VERTEX_ATTRIB_ARRAY_STRIDE */ + { 39468, 0x00008624 }, /* GL_VERTEX_ATTRIB_ARRAY_STRIDE_ARB */ + { 39502, 0x00008625 }, /* GL_VERTEX_ATTRIB_ARRAY_TYPE */ + { 39530, 0x00008625 }, /* GL_VERTEX_ATTRIB_ARRAY_TYPE_ARB */ + { 39562, 0x000086A7 }, /* GL_VERTEX_BLEND_ARB */ + { 39582, 0x00008620 }, /* GL_VERTEX_PROGRAM_ARB */ + { 39604, 0x0000864A }, /* GL_VERTEX_PROGRAM_BINDING_NV */ + { 39633, 0x00008620 }, /* GL_VERTEX_PROGRAM_NV */ + { 39654, 0x00008642 }, /* GL_VERTEX_PROGRAM_POINT_SIZE */ + { 39683, 0x00008642 }, /* GL_VERTEX_PROGRAM_POINT_SIZE_ARB */ + { 39716, 0x00008642 }, /* GL_VERTEX_PROGRAM_POINT_SIZE_NV */ + { 39748, 0x00008643 }, /* GL_VERTEX_PROGRAM_TWO_SIDE */ + { 39775, 0x00008643 }, /* GL_VERTEX_PROGRAM_TWO_SIDE_ARB */ + { 39806, 0x00008643 }, /* GL_VERTEX_PROGRAM_TWO_SIDE_NV */ + { 39836, 0x00008B31 }, /* GL_VERTEX_SHADER */ + { 39853, 0x00008B31 }, /* GL_VERTEX_SHADER_ARB */ + { 39874, 0x00008621 }, /* GL_VERTEX_STATE_PROGRAM_NV */ + { 39901, 0x00000BA2 }, /* GL_VIEWPORT */ + { 39913, 0x00000800 }, /* GL_VIEWPORT_BIT */ + { 39929, 0x0000911D }, /* GL_WAIT_FAILED */ + { 39944, 0x000086AD }, /* GL_WEIGHT_ARRAY_ARB */ + { 39964, 0x0000889E }, /* GL_WEIGHT_ARRAY_BUFFER_BINDING */ + { 39995, 0x0000889E }, /* GL_WEIGHT_ARRAY_BUFFER_BINDING_ARB */ + { 40030, 0x000086AC }, /* GL_WEIGHT_ARRAY_POINTER_ARB */ + { 40058, 0x000086AB }, /* GL_WEIGHT_ARRAY_SIZE_ARB */ + { 40083, 0x000086AA }, /* GL_WEIGHT_ARRAY_STRIDE_ARB */ + { 40110, 0x000086A9 }, /* GL_WEIGHT_ARRAY_TYPE_ARB */ + { 40135, 0x000086A6 }, /* GL_WEIGHT_SUM_UNITY_ARB */ + { 40159, 0x000081D4 }, /* GL_WRAP_BORDER_SUN */ + { 40178, 0x000088B9 }, /* GL_WRITE_ONLY */ + { 40192, 0x000088B9 }, /* GL_WRITE_ONLY_ARB */ + { 40210, 0x00001506 }, /* GL_XOR */ + { 40217, 0x000085B9 }, /* GL_YCBCR_422_APPLE */ + { 40236, 0x00008757 }, /* GL_YCBCR_MESA */ + { 40250, 0x00000000 }, /* GL_ZERO */ + { 40258, 0x00000D16 }, /* GL_ZOOM_X */ + { 40268, 0x00000D17 }, /* GL_ZOOM_Y */ }; -static const unsigned reduced_enums[1319] = +static const unsigned reduced_enums[1347] = { - 469, /* GL_FALSE */ - 683, /* GL_LINES */ - 685, /* GL_LINE_LOOP */ - 692, /* GL_LINE_STRIP */ - 1709, /* GL_TRIANGLES */ - 1712, /* GL_TRIANGLE_STRIP */ - 1710, /* GL_TRIANGLE_FAN */ - 1254, /* GL_QUADS */ - 1256, /* GL_QUAD_STRIP */ - 1142, /* GL_POLYGON */ - 1154, /* GL_POLYGON_STIPPLE_BIT */ - 1103, /* GL_PIXEL_MODE_BIT */ - 670, /* GL_LIGHTING_BIT */ - 497, /* GL_FOG_BIT */ + 475, /* GL_FALSE */ + 691, /* GL_LINES */ + 693, /* GL_LINE_LOOP */ + 700, /* GL_LINE_STRIP */ + 1743, /* GL_TRIANGLES */ + 1746, /* GL_TRIANGLE_STRIP */ + 1744, /* GL_TRIANGLE_FAN */ + 1271, /* GL_QUADS */ + 1274, /* GL_QUAD_STRIP */ + 1158, /* GL_POLYGON */ + 1170, /* GL_POLYGON_STIPPLE_BIT */ + 1119, /* GL_PIXEL_MODE_BIT */ + 678, /* GL_LIGHTING_BIT */ + 504, /* GL_FOG_BIT */ 8, /* GL_ACCUM */ - 702, /* GL_LOAD */ - 1308, /* GL_RETURN */ - 976, /* GL_MULT */ + 710, /* GL_LOAD */ + 1326, /* GL_RETURN */ + 991, /* GL_MULT */ 23, /* GL_ADD */ - 992, /* GL_NEVER */ - 660, /* GL_LESS */ - 459, /* GL_EQUAL */ - 659, /* GL_LEQUAL */ - 583, /* GL_GREATER */ - 1007, /* GL_NOTEQUAL */ - 582, /* GL_GEQUAL */ - 46, /* GL_ALWAYS */ - 1448, /* GL_SRC_COLOR */ - 1036, /* GL_ONE_MINUS_SRC_COLOR */ - 1446, /* GL_SRC_ALPHA */ - 1035, /* GL_ONE_MINUS_SRC_ALPHA */ - 438, /* GL_DST_ALPHA */ - 1033, /* GL_ONE_MINUS_DST_ALPHA */ - 439, /* GL_DST_COLOR */ - 1034, /* GL_ONE_MINUS_DST_COLOR */ - 1447, /* GL_SRC_ALPHA_SATURATE */ - 570, /* GL_FRONT_LEFT */ - 571, /* GL_FRONT_RIGHT */ - 68, /* GL_BACK_LEFT */ - 69, /* GL_BACK_RIGHT */ - 567, /* GL_FRONT */ - 67, /* GL_BACK */ - 658, /* GL_LEFT */ - 1350, /* GL_RIGHT */ - 568, /* GL_FRONT_AND_BACK */ - 62, /* GL_AUX0 */ - 63, /* GL_AUX1 */ - 64, /* GL_AUX2 */ - 65, /* GL_AUX3 */ - 649, /* GL_INVALID_ENUM */ - 653, /* GL_INVALID_VALUE */ - 652, /* GL_INVALID_OPERATION */ - 1453, /* GL_STACK_OVERFLOW */ - 1454, /* GL_STACK_UNDERFLOW */ - 1061, /* GL_OUT_OF_MEMORY */ - 650, /* GL_INVALID_FRAMEBUFFER_OPERATION */ + 1007, /* GL_NEVER */ + 668, /* GL_LESS */ + 465, /* GL_EQUAL */ + 667, /* GL_LEQUAL */ + 590, /* GL_GREATER */ + 1022, /* GL_NOTEQUAL */ + 589, /* GL_GEQUAL */ + 47, /* GL_ALWAYS */ + 1467, /* GL_SRC_COLOR */ + 1052, /* GL_ONE_MINUS_SRC_COLOR */ + 1465, /* GL_SRC_ALPHA */ + 1051, /* GL_ONE_MINUS_SRC_ALPHA */ + 444, /* GL_DST_ALPHA */ + 1049, /* GL_ONE_MINUS_DST_ALPHA */ + 445, /* GL_DST_COLOR */ + 1050, /* GL_ONE_MINUS_DST_COLOR */ + 1466, /* GL_SRC_ALPHA_SATURATE */ + 577, /* GL_FRONT_LEFT */ + 578, /* GL_FRONT_RIGHT */ + 69, /* GL_BACK_LEFT */ + 70, /* GL_BACK_RIGHT */ + 574, /* GL_FRONT */ + 68, /* GL_BACK */ + 666, /* GL_LEFT */ + 1368, /* GL_RIGHT */ + 575, /* GL_FRONT_AND_BACK */ + 63, /* GL_AUX0 */ + 64, /* GL_AUX1 */ + 65, /* GL_AUX2 */ + 66, /* GL_AUX3 */ + 656, /* GL_INVALID_ENUM */ + 660, /* GL_INVALID_VALUE */ + 659, /* GL_INVALID_OPERATION */ + 1472, /* GL_STACK_OVERFLOW */ + 1473, /* GL_STACK_UNDERFLOW */ + 1077, /* GL_OUT_OF_MEMORY */ + 657, /* GL_INVALID_FRAMEBUFFER_OPERATION */ 0, /* GL_2D */ 2, /* GL_3D */ 3, /* GL_3D_COLOR */ 4, /* GL_3D_COLOR_TEXTURE */ 6, /* GL_4D_COLOR_TEXTURE */ - 1081, /* GL_PASS_THROUGH_TOKEN */ - 1141, /* GL_POINT_TOKEN */ - 693, /* GL_LINE_TOKEN */ - 1155, /* GL_POLYGON_TOKEN */ - 73, /* GL_BITMAP_TOKEN */ - 437, /* GL_DRAW_PIXEL_TOKEN */ - 297, /* GL_COPY_PIXEL_TOKEN */ - 686, /* GL_LINE_RESET_TOKEN */ - 462, /* GL_EXP */ - 463, /* GL_EXP2 */ - 331, /* GL_CW */ - 122, /* GL_CCW */ - 143, /* GL_COEFF */ - 1058, /* GL_ORDER */ - 375, /* GL_DOMAIN */ - 305, /* GL_CURRENT_COLOR */ - 308, /* GL_CURRENT_INDEX */ - 314, /* GL_CURRENT_NORMAL */ - 327, /* GL_CURRENT_TEXTURE_COORDS */ - 319, /* GL_CURRENT_RASTER_COLOR */ - 321, /* GL_CURRENT_RASTER_INDEX */ - 325, /* GL_CURRENT_RASTER_TEXTURE_COORDS */ - 322, /* GL_CURRENT_RASTER_POSITION */ - 323, /* GL_CURRENT_RASTER_POSITION_VALID */ - 320, /* GL_CURRENT_RASTER_DISTANCE */ - 1134, /* GL_POINT_SMOOTH */ - 1123, /* GL_POINT_SIZE */ - 1133, /* GL_POINT_SIZE_RANGE */ - 1124, /* GL_POINT_SIZE_GRANULARITY */ - 687, /* GL_LINE_SMOOTH */ - 694, /* GL_LINE_WIDTH */ - 696, /* GL_LINE_WIDTH_RANGE */ - 695, /* GL_LINE_WIDTH_GRANULARITY */ - 689, /* GL_LINE_STIPPLE */ - 690, /* GL_LINE_STIPPLE_PATTERN */ - 691, /* GL_LINE_STIPPLE_REPEAT */ - 701, /* GL_LIST_MODE */ - 860, /* GL_MAX_LIST_NESTING */ - 698, /* GL_LIST_BASE */ - 700, /* GL_LIST_INDEX */ - 1144, /* GL_POLYGON_MODE */ - 1151, /* GL_POLYGON_SMOOTH */ - 1153, /* GL_POLYGON_STIPPLE */ - 448, /* GL_EDGE_FLAG */ - 298, /* GL_CULL_FACE */ - 299, /* GL_CULL_FACE_MODE */ - 569, /* GL_FRONT_FACE */ - 669, /* GL_LIGHTING */ - 674, /* GL_LIGHT_MODEL_LOCAL_VIEWER */ - 675, /* GL_LIGHT_MODEL_TWO_SIDE */ - 671, /* GL_LIGHT_MODEL_AMBIENT */ - 1396, /* GL_SHADE_MODEL */ - 190, /* GL_COLOR_MATERIAL_FACE */ - 191, /* GL_COLOR_MATERIAL_PARAMETER */ - 189, /* GL_COLOR_MATERIAL */ - 496, /* GL_FOG */ - 518, /* GL_FOG_INDEX */ - 514, /* GL_FOG_DENSITY */ - 522, /* GL_FOG_START */ - 516, /* GL_FOG_END */ - 519, /* GL_FOG_MODE */ - 498, /* GL_FOG_COLOR */ - 362, /* GL_DEPTH_RANGE */ - 369, /* GL_DEPTH_TEST */ - 372, /* GL_DEPTH_WRITEMASK */ - 350, /* GL_DEPTH_CLEAR_VALUE */ - 361, /* GL_DEPTH_FUNC */ + 1097, /* GL_PASS_THROUGH_TOKEN */ + 1157, /* GL_POINT_TOKEN */ + 701, /* GL_LINE_TOKEN */ + 1171, /* GL_POLYGON_TOKEN */ + 74, /* GL_BITMAP_TOKEN */ + 443, /* GL_DRAW_PIXEL_TOKEN */ + 301, /* GL_COPY_PIXEL_TOKEN */ + 694, /* GL_LINE_RESET_TOKEN */ + 468, /* GL_EXP */ + 469, /* GL_EXP2 */ + 337, /* GL_CW */ + 125, /* GL_CCW */ + 146, /* GL_COEFF */ + 1074, /* GL_ORDER */ + 381, /* GL_DOMAIN */ + 311, /* GL_CURRENT_COLOR */ + 314, /* GL_CURRENT_INDEX */ + 320, /* GL_CURRENT_NORMAL */ + 333, /* GL_CURRENT_TEXTURE_COORDS */ + 325, /* GL_CURRENT_RASTER_COLOR */ + 327, /* GL_CURRENT_RASTER_INDEX */ + 331, /* GL_CURRENT_RASTER_TEXTURE_COORDS */ + 328, /* GL_CURRENT_RASTER_POSITION */ + 329, /* GL_CURRENT_RASTER_POSITION_VALID */ + 326, /* GL_CURRENT_RASTER_DISTANCE */ + 1150, /* GL_POINT_SMOOTH */ + 1139, /* GL_POINT_SIZE */ + 1149, /* GL_POINT_SIZE_RANGE */ + 1140, /* GL_POINT_SIZE_GRANULARITY */ + 695, /* GL_LINE_SMOOTH */ + 702, /* GL_LINE_WIDTH */ + 704, /* GL_LINE_WIDTH_RANGE */ + 703, /* GL_LINE_WIDTH_GRANULARITY */ + 697, /* GL_LINE_STIPPLE */ + 698, /* GL_LINE_STIPPLE_PATTERN */ + 699, /* GL_LINE_STIPPLE_REPEAT */ + 709, /* GL_LIST_MODE */ + 874, /* GL_MAX_LIST_NESTING */ + 706, /* GL_LIST_BASE */ + 708, /* GL_LIST_INDEX */ + 1160, /* GL_POLYGON_MODE */ + 1167, /* GL_POLYGON_SMOOTH */ + 1169, /* GL_POLYGON_STIPPLE */ + 454, /* GL_EDGE_FLAG */ + 304, /* GL_CULL_FACE */ + 305, /* GL_CULL_FACE_MODE */ + 576, /* GL_FRONT_FACE */ + 677, /* GL_LIGHTING */ + 682, /* GL_LIGHT_MODEL_LOCAL_VIEWER */ + 683, /* GL_LIGHT_MODEL_TWO_SIDE */ + 679, /* GL_LIGHT_MODEL_AMBIENT */ + 1414, /* GL_SHADE_MODEL */ + 193, /* GL_COLOR_MATERIAL_FACE */ + 194, /* GL_COLOR_MATERIAL_PARAMETER */ + 192, /* GL_COLOR_MATERIAL */ + 503, /* GL_FOG */ + 525, /* GL_FOG_INDEX */ + 521, /* GL_FOG_DENSITY */ + 529, /* GL_FOG_START */ + 523, /* GL_FOG_END */ + 526, /* GL_FOG_MODE */ + 505, /* GL_FOG_COLOR */ + 368, /* GL_DEPTH_RANGE */ + 375, /* GL_DEPTH_TEST */ + 378, /* GL_DEPTH_WRITEMASK */ + 356, /* GL_DEPTH_CLEAR_VALUE */ + 367, /* GL_DEPTH_FUNC */ 12, /* GL_ACCUM_CLEAR_VALUE */ - 1489, /* GL_STENCIL_TEST */ - 1477, /* GL_STENCIL_CLEAR_VALUE */ - 1479, /* GL_STENCIL_FUNC */ - 1491, /* GL_STENCIL_VALUE_MASK */ - 1478, /* GL_STENCIL_FAIL */ - 1486, /* GL_STENCIL_PASS_DEPTH_FAIL */ - 1487, /* GL_STENCIL_PASS_DEPTH_PASS */ - 1488, /* GL_STENCIL_REF */ - 1492, /* GL_STENCIL_WRITEMASK */ - 829, /* GL_MATRIX_MODE */ - 997, /* GL_NORMALIZE */ - 1801, /* GL_VIEWPORT */ - 971, /* GL_MODELVIEW_STACK_DEPTH */ - 1234, /* GL_PROJECTION_STACK_DEPTH */ - 1687, /* GL_TEXTURE_STACK_DEPTH */ - 969, /* GL_MODELVIEW_MATRIX */ - 1233, /* GL_PROJECTION_MATRIX */ - 1672, /* GL_TEXTURE_MATRIX */ - 60, /* GL_ATTRIB_STACK_DEPTH */ - 133, /* GL_CLIENT_ATTRIB_STACK_DEPTH */ + 1508, /* GL_STENCIL_TEST */ + 1496, /* GL_STENCIL_CLEAR_VALUE */ + 1498, /* GL_STENCIL_FUNC */ + 1510, /* GL_STENCIL_VALUE_MASK */ + 1497, /* GL_STENCIL_FAIL */ + 1505, /* GL_STENCIL_PASS_DEPTH_FAIL */ + 1506, /* GL_STENCIL_PASS_DEPTH_PASS */ + 1507, /* GL_STENCIL_REF */ + 1511, /* GL_STENCIL_WRITEMASK */ + 843, /* GL_MATRIX_MODE */ + 1012, /* GL_NORMALIZE */ + 1837, /* GL_VIEWPORT */ + 986, /* GL_MODELVIEW_STACK_DEPTH */ + 1250, /* GL_PROJECTION_STACK_DEPTH */ + 1718, /* GL_TEXTURE_STACK_DEPTH */ + 984, /* GL_MODELVIEW_MATRIX */ + 1249, /* GL_PROJECTION_MATRIX */ + 1701, /* GL_TEXTURE_MATRIX */ + 61, /* GL_ATTRIB_STACK_DEPTH */ + 136, /* GL_CLIENT_ATTRIB_STACK_DEPTH */ 43, /* GL_ALPHA_TEST */ 44, /* GL_ALPHA_TEST_FUNC */ 45, /* GL_ALPHA_TEST_REF */ - 374, /* GL_DITHER */ - 77, /* GL_BLEND_DST */ - 86, /* GL_BLEND_SRC */ - 74, /* GL_BLEND */ - 704, /* GL_LOGIC_OP_MODE */ - 623, /* GL_INDEX_LOGIC_OP */ - 188, /* GL_COLOR_LOGIC_OP */ - 66, /* GL_AUX_BUFFERS */ - 385, /* GL_DRAW_BUFFER */ - 1266, /* GL_READ_BUFFER */ - 1377, /* GL_SCISSOR_BOX */ - 1378, /* GL_SCISSOR_TEST */ - 622, /* GL_INDEX_CLEAR_VALUE */ - 627, /* GL_INDEX_WRITEMASK */ - 185, /* GL_COLOR_CLEAR_VALUE */ - 227, /* GL_COLOR_WRITEMASK */ - 624, /* GL_INDEX_MODE */ - 1343, /* GL_RGBA_MODE */ - 384, /* GL_DOUBLEBUFFER */ - 1493, /* GL_STEREO */ - 1301, /* GL_RENDER_MODE */ - 1082, /* GL_PERSPECTIVE_CORRECTION_HINT */ - 1135, /* GL_POINT_SMOOTH_HINT */ - 688, /* GL_LINE_SMOOTH_HINT */ - 1152, /* GL_POLYGON_SMOOTH_HINT */ - 517, /* GL_FOG_HINT */ - 1653, /* GL_TEXTURE_GEN_S */ - 1654, /* GL_TEXTURE_GEN_T */ - 1652, /* GL_TEXTURE_GEN_R */ - 1651, /* GL_TEXTURE_GEN_Q */ - 1095, /* GL_PIXEL_MAP_I_TO_I */ - 1101, /* GL_PIXEL_MAP_S_TO_S */ - 1097, /* GL_PIXEL_MAP_I_TO_R */ - 1093, /* GL_PIXEL_MAP_I_TO_G */ - 1091, /* GL_PIXEL_MAP_I_TO_B */ - 1089, /* GL_PIXEL_MAP_I_TO_A */ - 1099, /* GL_PIXEL_MAP_R_TO_R */ - 1087, /* GL_PIXEL_MAP_G_TO_G */ - 1085, /* GL_PIXEL_MAP_B_TO_B */ - 1083, /* GL_PIXEL_MAP_A_TO_A */ - 1096, /* GL_PIXEL_MAP_I_TO_I_SIZE */ - 1102, /* GL_PIXEL_MAP_S_TO_S_SIZE */ - 1098, /* GL_PIXEL_MAP_I_TO_R_SIZE */ - 1094, /* GL_PIXEL_MAP_I_TO_G_SIZE */ - 1092, /* GL_PIXEL_MAP_I_TO_B_SIZE */ - 1090, /* GL_PIXEL_MAP_I_TO_A_SIZE */ - 1100, /* GL_PIXEL_MAP_R_TO_R_SIZE */ - 1088, /* GL_PIXEL_MAP_G_TO_G_SIZE */ - 1086, /* GL_PIXEL_MAP_B_TO_B_SIZE */ - 1084, /* GL_PIXEL_MAP_A_TO_A_SIZE */ - 1721, /* GL_UNPACK_SWAP_BYTES */ - 1716, /* GL_UNPACK_LSB_FIRST */ - 1717, /* GL_UNPACK_ROW_LENGTH */ - 1720, /* GL_UNPACK_SKIP_ROWS */ - 1719, /* GL_UNPACK_SKIP_PIXELS */ - 1714, /* GL_UNPACK_ALIGNMENT */ - 1070, /* GL_PACK_SWAP_BYTES */ - 1065, /* GL_PACK_LSB_FIRST */ - 1066, /* GL_PACK_ROW_LENGTH */ - 1069, /* GL_PACK_SKIP_ROWS */ - 1068, /* GL_PACK_SKIP_PIXELS */ - 1062, /* GL_PACK_ALIGNMENT */ - 782, /* GL_MAP_COLOR */ - 783, /* GL_MAP_STENCIL */ - 626, /* GL_INDEX_SHIFT */ - 625, /* GL_INDEX_OFFSET */ - 1279, /* GL_RED_SCALE */ - 1277, /* GL_RED_BIAS */ - 1818, /* GL_ZOOM_X */ - 1819, /* GL_ZOOM_Y */ - 587, /* GL_GREEN_SCALE */ - 585, /* GL_GREEN_BIAS */ - 92, /* GL_BLUE_SCALE */ - 90, /* GL_BLUE_BIAS */ + 380, /* GL_DITHER */ + 78, /* GL_BLEND_DST */ + 87, /* GL_BLEND_SRC */ + 75, /* GL_BLEND */ + 712, /* GL_LOGIC_OP_MODE */ + 630, /* GL_INDEX_LOGIC_OP */ + 191, /* GL_COLOR_LOGIC_OP */ + 67, /* GL_AUX_BUFFERS */ + 391, /* GL_DRAW_BUFFER */ + 1284, /* GL_READ_BUFFER */ + 1395, /* GL_SCISSOR_BOX */ + 1396, /* GL_SCISSOR_TEST */ + 629, /* GL_INDEX_CLEAR_VALUE */ + 634, /* GL_INDEX_WRITEMASK */ + 188, /* GL_COLOR_CLEAR_VALUE */ + 230, /* GL_COLOR_WRITEMASK */ + 631, /* GL_INDEX_MODE */ + 1361, /* GL_RGBA_MODE */ + 390, /* GL_DOUBLEBUFFER */ + 1512, /* GL_STEREO */ + 1319, /* GL_RENDER_MODE */ + 1098, /* GL_PERSPECTIVE_CORRECTION_HINT */ + 1151, /* GL_POINT_SMOOTH_HINT */ + 696, /* GL_LINE_SMOOTH_HINT */ + 1168, /* GL_POLYGON_SMOOTH_HINT */ + 524, /* GL_FOG_HINT */ + 1682, /* GL_TEXTURE_GEN_S */ + 1683, /* GL_TEXTURE_GEN_T */ + 1681, /* GL_TEXTURE_GEN_R */ + 1680, /* GL_TEXTURE_GEN_Q */ + 1111, /* GL_PIXEL_MAP_I_TO_I */ + 1117, /* GL_PIXEL_MAP_S_TO_S */ + 1113, /* GL_PIXEL_MAP_I_TO_R */ + 1109, /* GL_PIXEL_MAP_I_TO_G */ + 1107, /* GL_PIXEL_MAP_I_TO_B */ + 1105, /* GL_PIXEL_MAP_I_TO_A */ + 1115, /* GL_PIXEL_MAP_R_TO_R */ + 1103, /* GL_PIXEL_MAP_G_TO_G */ + 1101, /* GL_PIXEL_MAP_B_TO_B */ + 1099, /* GL_PIXEL_MAP_A_TO_A */ + 1112, /* GL_PIXEL_MAP_I_TO_I_SIZE */ + 1118, /* GL_PIXEL_MAP_S_TO_S_SIZE */ + 1114, /* GL_PIXEL_MAP_I_TO_R_SIZE */ + 1110, /* GL_PIXEL_MAP_I_TO_G_SIZE */ + 1108, /* GL_PIXEL_MAP_I_TO_B_SIZE */ + 1106, /* GL_PIXEL_MAP_I_TO_A_SIZE */ + 1116, /* GL_PIXEL_MAP_R_TO_R_SIZE */ + 1104, /* GL_PIXEL_MAP_G_TO_G_SIZE */ + 1102, /* GL_PIXEL_MAP_B_TO_B_SIZE */ + 1100, /* GL_PIXEL_MAP_A_TO_A_SIZE */ + 1755, /* GL_UNPACK_SWAP_BYTES */ + 1750, /* GL_UNPACK_LSB_FIRST */ + 1751, /* GL_UNPACK_ROW_LENGTH */ + 1754, /* GL_UNPACK_SKIP_ROWS */ + 1753, /* GL_UNPACK_SKIP_PIXELS */ + 1748, /* GL_UNPACK_ALIGNMENT */ + 1086, /* GL_PACK_SWAP_BYTES */ + 1081, /* GL_PACK_LSB_FIRST */ + 1082, /* GL_PACK_ROW_LENGTH */ + 1085, /* GL_PACK_SKIP_ROWS */ + 1084, /* GL_PACK_SKIP_PIXELS */ + 1078, /* GL_PACK_ALIGNMENT */ + 790, /* GL_MAP_COLOR */ + 795, /* GL_MAP_STENCIL */ + 633, /* GL_INDEX_SHIFT */ + 632, /* GL_INDEX_OFFSET */ + 1297, /* GL_RED_SCALE */ + 1295, /* GL_RED_BIAS */ + 1855, /* GL_ZOOM_X */ + 1856, /* GL_ZOOM_Y */ + 594, /* GL_GREEN_SCALE */ + 592, /* GL_GREEN_BIAS */ + 93, /* GL_BLUE_SCALE */ + 91, /* GL_BLUE_BIAS */ 42, /* GL_ALPHA_SCALE */ 40, /* GL_ALPHA_BIAS */ - 363, /* GL_DEPTH_SCALE */ - 344, /* GL_DEPTH_BIAS */ - 855, /* GL_MAX_EVAL_ORDER */ - 859, /* GL_MAX_LIGHTS */ - 838, /* GL_MAX_CLIP_PLANES */ - 904, /* GL_MAX_TEXTURE_SIZE */ - 865, /* GL_MAX_PIXEL_MAP_TABLE */ - 834, /* GL_MAX_ATTRIB_STACK_DEPTH */ - 862, /* GL_MAX_MODELVIEW_STACK_DEPTH */ - 863, /* GL_MAX_NAME_STACK_DEPTH */ - 891, /* GL_MAX_PROJECTION_STACK_DEPTH */ - 905, /* GL_MAX_TEXTURE_STACK_DEPTH */ - 919, /* GL_MAX_VIEWPORT_DIMS */ - 835, /* GL_MAX_CLIENT_ATTRIB_STACK_DEPTH */ - 1500, /* GL_SUBPIXEL_BITS */ - 621, /* GL_INDEX_BITS */ - 1278, /* GL_RED_BITS */ - 586, /* GL_GREEN_BITS */ - 91, /* GL_BLUE_BITS */ + 369, /* GL_DEPTH_SCALE */ + 350, /* GL_DEPTH_BIAS */ + 869, /* GL_MAX_EVAL_ORDER */ + 873, /* GL_MAX_LIGHTS */ + 852, /* GL_MAX_CLIP_PLANES */ + 919, /* GL_MAX_TEXTURE_SIZE */ + 879, /* GL_MAX_PIXEL_MAP_TABLE */ + 848, /* GL_MAX_ATTRIB_STACK_DEPTH */ + 876, /* GL_MAX_MODELVIEW_STACK_DEPTH */ + 877, /* GL_MAX_NAME_STACK_DEPTH */ + 905, /* GL_MAX_PROJECTION_STACK_DEPTH */ + 920, /* GL_MAX_TEXTURE_STACK_DEPTH */ + 934, /* GL_MAX_VIEWPORT_DIMS */ + 849, /* GL_MAX_CLIENT_ATTRIB_STACK_DEPTH */ + 1522, /* GL_SUBPIXEL_BITS */ + 628, /* GL_INDEX_BITS */ + 1296, /* GL_RED_BITS */ + 593, /* GL_GREEN_BITS */ + 92, /* GL_BLUE_BITS */ 41, /* GL_ALPHA_BITS */ - 345, /* GL_DEPTH_BITS */ - 1475, /* GL_STENCIL_BITS */ + 351, /* GL_DEPTH_BITS */ + 1494, /* GL_STENCIL_BITS */ 14, /* GL_ACCUM_RED_BITS */ 13, /* GL_ACCUM_GREEN_BITS */ 10, /* GL_ACCUM_BLUE_BITS */ 9, /* GL_ACCUM_ALPHA_BITS */ - 985, /* GL_NAME_STACK_DEPTH */ - 61, /* GL_AUTO_NORMAL */ - 728, /* GL_MAP1_COLOR_4 */ - 731, /* GL_MAP1_INDEX */ - 732, /* GL_MAP1_NORMAL */ - 733, /* GL_MAP1_TEXTURE_COORD_1 */ - 734, /* GL_MAP1_TEXTURE_COORD_2 */ - 735, /* GL_MAP1_TEXTURE_COORD_3 */ - 736, /* GL_MAP1_TEXTURE_COORD_4 */ - 737, /* GL_MAP1_VERTEX_3 */ - 738, /* GL_MAP1_VERTEX_4 */ - 755, /* GL_MAP2_COLOR_4 */ - 758, /* GL_MAP2_INDEX */ - 759, /* GL_MAP2_NORMAL */ - 760, /* GL_MAP2_TEXTURE_COORD_1 */ - 761, /* GL_MAP2_TEXTURE_COORD_2 */ - 762, /* GL_MAP2_TEXTURE_COORD_3 */ - 763, /* GL_MAP2_TEXTURE_COORD_4 */ - 764, /* GL_MAP2_VERTEX_3 */ - 765, /* GL_MAP2_VERTEX_4 */ - 729, /* GL_MAP1_GRID_DOMAIN */ - 730, /* GL_MAP1_GRID_SEGMENTS */ - 756, /* GL_MAP2_GRID_DOMAIN */ - 757, /* GL_MAP2_GRID_SEGMENTS */ - 1577, /* GL_TEXTURE_1D */ - 1579, /* GL_TEXTURE_2D */ - 472, /* GL_FEEDBACK_BUFFER_POINTER */ - 473, /* GL_FEEDBACK_BUFFER_SIZE */ - 474, /* GL_FEEDBACK_BUFFER_TYPE */ - 1387, /* GL_SELECTION_BUFFER_POINTER */ - 1388, /* GL_SELECTION_BUFFER_SIZE */ - 1691, /* GL_TEXTURE_WIDTH */ - 1658, /* GL_TEXTURE_HEIGHT */ - 1614, /* GL_TEXTURE_COMPONENTS */ - 1598, /* GL_TEXTURE_BORDER_COLOR */ - 1597, /* GL_TEXTURE_BORDER */ - 376, /* GL_DONT_CARE */ - 470, /* GL_FASTEST */ - 993, /* GL_NICEST */ - 47, /* GL_AMBIENT */ - 373, /* GL_DIFFUSE */ - 1435, /* GL_SPECULAR */ - 1156, /* GL_POSITION */ - 1438, /* GL_SPOT_DIRECTION */ - 1439, /* GL_SPOT_EXPONENT */ - 1437, /* GL_SPOT_CUTOFF */ - 271, /* GL_CONSTANT_ATTENUATION */ - 678, /* GL_LINEAR_ATTENUATION */ - 1253, /* GL_QUADRATIC_ATTENUATION */ - 241, /* GL_COMPILE */ - 242, /* GL_COMPILE_AND_EXECUTE */ - 117, /* GL_BYTE */ - 1722, /* GL_UNSIGNED_BYTE */ - 1401, /* GL_SHORT */ - 1733, /* GL_UNSIGNED_SHORT */ - 629, /* GL_INT */ - 1725, /* GL_UNSIGNED_INT */ - 477, /* GL_FLOAT */ + 1000, /* GL_NAME_STACK_DEPTH */ + 62, /* GL_AUTO_NORMAL */ + 736, /* GL_MAP1_COLOR_4 */ + 739, /* GL_MAP1_INDEX */ + 740, /* GL_MAP1_NORMAL */ + 741, /* GL_MAP1_TEXTURE_COORD_1 */ + 742, /* GL_MAP1_TEXTURE_COORD_2 */ + 743, /* GL_MAP1_TEXTURE_COORD_3 */ + 744, /* GL_MAP1_TEXTURE_COORD_4 */ + 745, /* GL_MAP1_VERTEX_3 */ + 746, /* GL_MAP1_VERTEX_4 */ + 763, /* GL_MAP2_COLOR_4 */ + 766, /* GL_MAP2_INDEX */ + 767, /* GL_MAP2_NORMAL */ + 768, /* GL_MAP2_TEXTURE_COORD_1 */ + 769, /* GL_MAP2_TEXTURE_COORD_2 */ + 770, /* GL_MAP2_TEXTURE_COORD_3 */ + 771, /* GL_MAP2_TEXTURE_COORD_4 */ + 772, /* GL_MAP2_VERTEX_3 */ + 773, /* GL_MAP2_VERTEX_4 */ + 737, /* GL_MAP1_GRID_DOMAIN */ + 738, /* GL_MAP1_GRID_SEGMENTS */ + 764, /* GL_MAP2_GRID_DOMAIN */ + 765, /* GL_MAP2_GRID_SEGMENTS */ + 1605, /* GL_TEXTURE_1D */ + 1607, /* GL_TEXTURE_2D */ + 478, /* GL_FEEDBACK_BUFFER_POINTER */ + 479, /* GL_FEEDBACK_BUFFER_SIZE */ + 480, /* GL_FEEDBACK_BUFFER_TYPE */ + 1405, /* GL_SELECTION_BUFFER_POINTER */ + 1406, /* GL_SELECTION_BUFFER_SIZE */ + 1723, /* GL_TEXTURE_WIDTH */ + 1687, /* GL_TEXTURE_HEIGHT */ + 1642, /* GL_TEXTURE_COMPONENTS */ + 1626, /* GL_TEXTURE_BORDER_COLOR */ + 1625, /* GL_TEXTURE_BORDER */ + 382, /* GL_DONT_CARE */ + 476, /* GL_FASTEST */ + 1008, /* GL_NICEST */ + 48, /* GL_AMBIENT */ + 379, /* GL_DIFFUSE */ + 1454, /* GL_SPECULAR */ + 1172, /* GL_POSITION */ + 1457, /* GL_SPOT_DIRECTION */ + 1458, /* GL_SPOT_EXPONENT */ + 1456, /* GL_SPOT_CUTOFF */ + 275, /* GL_CONSTANT_ATTENUATION */ + 686, /* GL_LINEAR_ATTENUATION */ + 1270, /* GL_QUADRATIC_ATTENUATION */ + 244, /* GL_COMPILE */ + 245, /* GL_COMPILE_AND_EXECUTE */ + 120, /* GL_BYTE */ + 1757, /* GL_UNSIGNED_BYTE */ + 1419, /* GL_SHORT */ + 1768, /* GL_UNSIGNED_SHORT */ + 636, /* GL_INT */ + 1760, /* GL_UNSIGNED_INT */ + 484, /* GL_FLOAT */ 1, /* GL_2_BYTES */ 5, /* GL_3_BYTES */ 7, /* GL_4_BYTES */ - 383, /* GL_DOUBLE */ - 129, /* GL_CLEAR */ - 49, /* GL_AND */ - 51, /* GL_AND_REVERSE */ - 295, /* GL_COPY */ - 50, /* GL_AND_INVERTED */ - 995, /* GL_NOOP */ - 1814, /* GL_XOR */ - 1057, /* GL_OR */ - 996, /* GL_NOR */ - 460, /* GL_EQUIV */ - 656, /* GL_INVERT */ - 1060, /* GL_OR_REVERSE */ - 296, /* GL_COPY_INVERTED */ - 1059, /* GL_OR_INVERTED */ - 986, /* GL_NAND */ - 1392, /* GL_SET */ - 457, /* GL_EMISSION */ - 1400, /* GL_SHININESS */ - 48, /* GL_AMBIENT_AND_DIFFUSE */ - 187, /* GL_COLOR_INDEXES */ - 936, /* GL_MODELVIEW */ - 1232, /* GL_PROJECTION */ - 1512, /* GL_TEXTURE */ - 144, /* GL_COLOR */ - 340, /* GL_DEPTH */ - 1461, /* GL_STENCIL */ - 186, /* GL_COLOR_INDEX */ - 1480, /* GL_STENCIL_INDEX */ - 351, /* GL_DEPTH_COMPONENT */ - 1274, /* GL_RED */ - 584, /* GL_GREEN */ - 89, /* GL_BLUE */ + 389, /* GL_DOUBLE */ + 132, /* GL_CLEAR */ + 50, /* GL_AND */ + 52, /* GL_AND_REVERSE */ + 299, /* GL_COPY */ + 51, /* GL_AND_INVERTED */ + 1010, /* GL_NOOP */ + 1851, /* GL_XOR */ + 1073, /* GL_OR */ + 1011, /* GL_NOR */ + 466, /* GL_EQUIV */ + 663, /* GL_INVERT */ + 1076, /* GL_OR_REVERSE */ + 300, /* GL_COPY_INVERTED */ + 1075, /* GL_OR_INVERTED */ + 1001, /* GL_NAND */ + 1410, /* GL_SET */ + 463, /* GL_EMISSION */ + 1418, /* GL_SHININESS */ + 49, /* GL_AMBIENT_AND_DIFFUSE */ + 190, /* GL_COLOR_INDEXES */ + 951, /* GL_MODELVIEW */ + 1248, /* GL_PROJECTION */ + 1540, /* GL_TEXTURE */ + 147, /* GL_COLOR */ + 346, /* GL_DEPTH */ + 1480, /* GL_STENCIL */ + 189, /* GL_COLOR_INDEX */ + 1499, /* GL_STENCIL_INDEX */ + 357, /* GL_DEPTH_COMPONENT */ + 1292, /* GL_RED */ + 591, /* GL_GREEN */ + 90, /* GL_BLUE */ 31, /* GL_ALPHA */ - 1309, /* GL_RGB */ - 1328, /* GL_RGBA */ - 706, /* GL_LUMINANCE */ - 727, /* GL_LUMINANCE_ALPHA */ - 72, /* GL_BITMAP */ - 1112, /* GL_POINT */ - 676, /* GL_LINE */ - 475, /* GL_FILL */ - 1283, /* GL_RENDER */ - 471, /* GL_FEEDBACK */ - 1386, /* GL_SELECT */ - 476, /* GL_FLAT */ - 1410, /* GL_SMOOTH */ - 657, /* GL_KEEP */ - 1303, /* GL_REPLACE */ - 611, /* GL_INCR */ - 336, /* GL_DECR */ - 1748, /* GL_VENDOR */ - 1300, /* GL_RENDERER */ - 1749, /* GL_VERSION */ - 464, /* GL_EXTENSIONS */ - 1351, /* GL_S */ - 1503, /* GL_T */ - 1263, /* GL_R */ - 1252, /* GL_Q */ - 972, /* GL_MODULATE */ - 335, /* GL_DECAL */ - 1648, /* GL_TEXTURE_ENV_MODE */ - 1647, /* GL_TEXTURE_ENV_COLOR */ - 1646, /* GL_TEXTURE_ENV */ - 465, /* GL_EYE_LINEAR */ - 1019, /* GL_OBJECT_LINEAR */ - 1436, /* GL_SPHERE_MAP */ - 1650, /* GL_TEXTURE_GEN_MODE */ - 1021, /* GL_OBJECT_PLANE */ - 466, /* GL_EYE_PLANE */ - 987, /* GL_NEAREST */ - 677, /* GL_LINEAR */ - 991, /* GL_NEAREST_MIPMAP_NEAREST */ - 682, /* GL_LINEAR_MIPMAP_NEAREST */ - 990, /* GL_NEAREST_MIPMAP_LINEAR */ - 681, /* GL_LINEAR_MIPMAP_LINEAR */ - 1671, /* GL_TEXTURE_MAG_FILTER */ - 1679, /* GL_TEXTURE_MIN_FILTER */ - 1693, /* GL_TEXTURE_WRAP_S */ - 1694, /* GL_TEXTURE_WRAP_T */ - 123, /* 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 */ - 1745, /* GL_V2F */ - 1746, /* GL_V3F */ - 120, /* GL_C4UB_V2F */ - 121, /* GL_C4UB_V3F */ - 118, /* GL_C3F_V3F */ - 984, /* GL_N3F_V3F */ - 119, /* GL_C4F_N3F_V3F */ - 1508, /* GL_T2F_V3F */ - 1510, /* GL_T4F_V4F */ - 1506, /* GL_T2F_C4UB_V3F */ - 1504, /* GL_T2F_C3F_V3F */ - 1507, /* GL_T2F_N3F_V3F */ - 1505, /* GL_T2F_C4F_N3F_V3F */ - 1509, /* GL_T4F_C4F_N3F_V4F */ - 136, /* GL_CLIP_PLANE0 */ - 137, /* GL_CLIP_PLANE1 */ - 138, /* GL_CLIP_PLANE2 */ - 139, /* GL_CLIP_PLANE3 */ - 140, /* GL_CLIP_PLANE4 */ - 141, /* GL_CLIP_PLANE5 */ - 661, /* GL_LIGHT0 */ - 662, /* GL_LIGHT1 */ - 663, /* GL_LIGHT2 */ - 664, /* GL_LIGHT3 */ - 665, /* GL_LIGHT4 */ - 666, /* GL_LIGHT5 */ - 667, /* GL_LIGHT6 */ - 668, /* GL_LIGHT7 */ - 588, /* GL_HINT_BIT */ - 273, /* GL_CONSTANT_COLOR */ - 1031, /* GL_ONE_MINUS_CONSTANT_COLOR */ - 268, /* GL_CONSTANT_ALPHA */ - 1029, /* GL_ONE_MINUS_CONSTANT_ALPHA */ - 75, /* GL_BLEND_COLOR */ - 572, /* GL_FUNC_ADD */ - 920, /* GL_MIN */ - 831, /* GL_MAX */ - 80, /* GL_BLEND_EQUATION */ - 576, /* GL_FUNC_SUBTRACT */ - 574, /* GL_FUNC_REVERSE_SUBTRACT */ - 276, /* GL_CONVOLUTION_1D */ - 277, /* GL_CONVOLUTION_2D */ - 1389, /* GL_SEPARABLE_2D */ - 280, /* GL_CONVOLUTION_BORDER_MODE */ - 284, /* GL_CONVOLUTION_FILTER_SCALE */ - 282, /* GL_CONVOLUTION_FILTER_BIAS */ - 1275, /* GL_REDUCE */ - 286, /* GL_CONVOLUTION_FORMAT */ - 290, /* GL_CONVOLUTION_WIDTH */ - 288, /* GL_CONVOLUTION_HEIGHT */ - 846, /* GL_MAX_CONVOLUTION_WIDTH */ - 844, /* 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 */ - 589, /* GL_HISTOGRAM */ - 1236, /* GL_PROXY_HISTOGRAM */ - 605, /* GL_HISTOGRAM_WIDTH */ - 595, /* GL_HISTOGRAM_FORMAT */ - 601, /* GL_HISTOGRAM_RED_SIZE */ - 597, /* GL_HISTOGRAM_GREEN_SIZE */ - 592, /* GL_HISTOGRAM_BLUE_SIZE */ - 590, /* GL_HISTOGRAM_ALPHA_SIZE */ - 599, /* GL_HISTOGRAM_LUMINANCE_SIZE */ - 603, /* GL_HISTOGRAM_SINK */ - 921, /* GL_MINMAX */ - 923, /* GL_MINMAX_FORMAT */ - 925, /* GL_MINMAX_SINK */ - 1511, /* GL_TABLE_TOO_LARGE_EXT */ - 1724, /* GL_UNSIGNED_BYTE_3_3_2 */ - 1735, /* GL_UNSIGNED_SHORT_4_4_4_4 */ - 1737, /* GL_UNSIGNED_SHORT_5_5_5_1 */ - 1730, /* GL_UNSIGNED_INT_8_8_8_8 */ - 1726, /* 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 */ + 1327, /* GL_RGB */ + 1346, /* GL_RGBA */ + 714, /* GL_LUMINANCE */ + 735, /* GL_LUMINANCE_ALPHA */ + 73, /* GL_BITMAP */ + 1128, /* GL_POINT */ + 684, /* GL_LINE */ + 481, /* GL_FILL */ + 1301, /* GL_RENDER */ + 477, /* GL_FEEDBACK */ + 1404, /* GL_SELECT */ + 483, /* GL_FLAT */ + 1429, /* GL_SMOOTH */ + 664, /* GL_KEEP */ + 1321, /* GL_REPLACE */ + 618, /* GL_INCR */ + 342, /* GL_DECR */ + 1783, /* GL_VENDOR */ + 1318, /* GL_RENDERER */ + 1784, /* GL_VERSION */ + 470, /* GL_EXTENSIONS */ + 1369, /* GL_S */ + 1531, /* GL_T */ + 1281, /* GL_R */ + 1269, /* GL_Q */ + 987, /* GL_MODULATE */ + 341, /* GL_DECAL */ + 1677, /* GL_TEXTURE_ENV_MODE */ + 1676, /* GL_TEXTURE_ENV_COLOR */ + 1675, /* GL_TEXTURE_ENV */ + 471, /* GL_EYE_LINEAR */ + 1034, /* GL_OBJECT_LINEAR */ + 1455, /* GL_SPHERE_MAP */ + 1679, /* GL_TEXTURE_GEN_MODE */ + 1036, /* GL_OBJECT_PLANE */ + 472, /* GL_EYE_PLANE */ + 1002, /* GL_NEAREST */ + 685, /* GL_LINEAR */ + 1006, /* GL_NEAREST_MIPMAP_NEAREST */ + 690, /* GL_LINEAR_MIPMAP_NEAREST */ + 1005, /* GL_NEAREST_MIPMAP_LINEAR */ + 689, /* GL_LINEAR_MIPMAP_LINEAR */ + 1700, /* GL_TEXTURE_MAG_FILTER */ + 1708, /* GL_TEXTURE_MIN_FILTER */ + 1725, /* GL_TEXTURE_WRAP_S */ + 1726, /* GL_TEXTURE_WRAP_T */ + 126, /* GL_CLAMP */ + 1320, /* GL_REPEAT */ + 1166, /* GL_POLYGON_OFFSET_UNITS */ + 1165, /* GL_POLYGON_OFFSET_POINT */ + 1164, /* GL_POLYGON_OFFSET_LINE */ + 1282, /* GL_R3_G3_B2 */ + 1780, /* GL_V2F */ + 1781, /* GL_V3F */ + 123, /* GL_C4UB_V2F */ + 124, /* GL_C4UB_V3F */ + 121, /* GL_C3F_V3F */ + 999, /* GL_N3F_V3F */ + 122, /* GL_C4F_N3F_V3F */ + 1536, /* GL_T2F_V3F */ + 1538, /* GL_T4F_V4F */ + 1534, /* GL_T2F_C4UB_V3F */ + 1532, /* GL_T2F_C3F_V3F */ + 1535, /* GL_T2F_N3F_V3F */ + 1533, /* GL_T2F_C4F_N3F_V3F */ + 1537, /* GL_T4F_C4F_N3F_V4F */ + 139, /* GL_CLIP_PLANE0 */ + 140, /* GL_CLIP_PLANE1 */ + 141, /* GL_CLIP_PLANE2 */ + 142, /* GL_CLIP_PLANE3 */ + 143, /* GL_CLIP_PLANE4 */ + 144, /* GL_CLIP_PLANE5 */ + 669, /* GL_LIGHT0 */ + 670, /* GL_LIGHT1 */ + 671, /* GL_LIGHT2 */ + 672, /* GL_LIGHT3 */ + 673, /* GL_LIGHT4 */ + 674, /* GL_LIGHT5 */ + 675, /* GL_LIGHT6 */ + 676, /* GL_LIGHT7 */ + 595, /* GL_HINT_BIT */ + 277, /* GL_CONSTANT_COLOR */ + 1047, /* GL_ONE_MINUS_CONSTANT_COLOR */ + 272, /* GL_CONSTANT_ALPHA */ + 1045, /* GL_ONE_MINUS_CONSTANT_ALPHA */ + 76, /* GL_BLEND_COLOR */ + 579, /* GL_FUNC_ADD */ + 935, /* GL_MIN */ + 845, /* GL_MAX */ + 81, /* GL_BLEND_EQUATION */ + 583, /* GL_FUNC_SUBTRACT */ + 581, /* GL_FUNC_REVERSE_SUBTRACT */ + 280, /* GL_CONVOLUTION_1D */ + 281, /* GL_CONVOLUTION_2D */ + 1407, /* GL_SEPARABLE_2D */ + 284, /* GL_CONVOLUTION_BORDER_MODE */ + 288, /* GL_CONVOLUTION_FILTER_SCALE */ + 286, /* GL_CONVOLUTION_FILTER_BIAS */ + 1293, /* GL_REDUCE */ + 290, /* GL_CONVOLUTION_FORMAT */ + 294, /* GL_CONVOLUTION_WIDTH */ + 292, /* GL_CONVOLUTION_HEIGHT */ + 860, /* GL_MAX_CONVOLUTION_WIDTH */ + 858, /* GL_MAX_CONVOLUTION_HEIGHT */ + 1205, /* GL_POST_CONVOLUTION_RED_SCALE */ + 1201, /* GL_POST_CONVOLUTION_GREEN_SCALE */ + 1196, /* GL_POST_CONVOLUTION_BLUE_SCALE */ + 1192, /* GL_POST_CONVOLUTION_ALPHA_SCALE */ + 1203, /* GL_POST_CONVOLUTION_RED_BIAS */ + 1199, /* GL_POST_CONVOLUTION_GREEN_BIAS */ + 1194, /* GL_POST_CONVOLUTION_BLUE_BIAS */ + 1190, /* GL_POST_CONVOLUTION_ALPHA_BIAS */ + 596, /* GL_HISTOGRAM */ + 1253, /* GL_PROXY_HISTOGRAM */ + 612, /* GL_HISTOGRAM_WIDTH */ + 602, /* GL_HISTOGRAM_FORMAT */ + 608, /* GL_HISTOGRAM_RED_SIZE */ + 604, /* GL_HISTOGRAM_GREEN_SIZE */ + 599, /* GL_HISTOGRAM_BLUE_SIZE */ + 597, /* GL_HISTOGRAM_ALPHA_SIZE */ + 606, /* GL_HISTOGRAM_LUMINANCE_SIZE */ + 610, /* GL_HISTOGRAM_SINK */ + 936, /* GL_MINMAX */ + 938, /* GL_MINMAX_FORMAT */ + 940, /* GL_MINMAX_SINK */ + 1539, /* GL_TABLE_TOO_LARGE_EXT */ + 1759, /* GL_UNSIGNED_BYTE_3_3_2 */ + 1770, /* GL_UNSIGNED_SHORT_4_4_4_4 */ + 1772, /* GL_UNSIGNED_SHORT_5_5_5_1 */ + 1765, /* GL_UNSIGNED_INT_8_8_8_8 */ + 1761, /* GL_UNSIGNED_INT_10_10_10_2 */ + 1163, /* GL_POLYGON_OFFSET_FILL */ + 1162, /* GL_POLYGON_OFFSET_FACTOR */ + 1161, /* GL_POLYGON_OFFSET_BIAS */ + 1324, /* GL_RESCALE_NORMAL */ 36, /* GL_ALPHA4 */ 38, /* GL_ALPHA8 */ 32, /* GL_ALPHA12 */ 34, /* GL_ALPHA16 */ - 717, /* GL_LUMINANCE4 */ - 723, /* GL_LUMINANCE8 */ - 707, /* GL_LUMINANCE12 */ - 713, /* GL_LUMINANCE16 */ - 718, /* GL_LUMINANCE4_ALPHA4 */ - 721, /* GL_LUMINANCE6_ALPHA2 */ - 724, /* GL_LUMINANCE8_ALPHA8 */ - 710, /* GL_LUMINANCE12_ALPHA4 */ - 708, /* GL_LUMINANCE12_ALPHA12 */ - 714, /* GL_LUMINANCE16_ALPHA16 */ - 630, /* GL_INTENSITY */ - 635, /* GL_INTENSITY4 */ - 637, /* GL_INTENSITY8 */ - 631, /* GL_INTENSITY12 */ - 633, /* 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 */ - 1684, /* GL_TEXTURE_RED_SIZE */ - 1656, /* GL_TEXTURE_GREEN_SIZE */ - 1595, /* GL_TEXTURE_BLUE_SIZE */ - 1582, /* GL_TEXTURE_ALPHA_SIZE */ - 1669, /* GL_TEXTURE_LUMINANCE_SIZE */ - 1660, /* GL_TEXTURE_INTENSITY_SIZE */ - 1304, /* GL_REPLACE_EXT */ - 1240, /* GL_PROXY_TEXTURE_1D */ - 1243, /* GL_PROXY_TEXTURE_2D */ - 1689, /* GL_TEXTURE_TOO_LARGE_EXT */ - 1681, /* GL_TEXTURE_PRIORITY */ - 1686, /* GL_TEXTURE_RESIDENT */ - 1585, /* GL_TEXTURE_BINDING_1D */ - 1587, /* GL_TEXTURE_BINDING_2D */ - 1589, /* GL_TEXTURE_BINDING_3D */ - 1067, /* GL_PACK_SKIP_IMAGES */ - 1063, /* GL_PACK_IMAGE_HEIGHT */ - 1718, /* GL_UNPACK_SKIP_IMAGES */ - 1715, /* GL_UNPACK_IMAGE_HEIGHT */ - 1581, /* GL_TEXTURE_3D */ - 1246, /* GL_PROXY_TEXTURE_3D */ - 1643, /* GL_TEXTURE_DEPTH */ - 1692, /* GL_TEXTURE_WRAP_R */ - 832, /* GL_MAX_3D_TEXTURE_SIZE */ - 1750, /* GL_VERTEX_ARRAY */ - 998, /* GL_NORMAL_ARRAY */ - 145, /* GL_COLOR_ARRAY */ - 615, /* GL_INDEX_ARRAY */ - 1622, /* GL_TEXTURE_COORD_ARRAY */ - 449, /* GL_EDGE_FLAG_ARRAY */ - 1755, /* GL_VERTEX_ARRAY_SIZE */ - 1757, /* GL_VERTEX_ARRAY_TYPE */ - 1756, /* GL_VERTEX_ARRAY_STRIDE */ - 1003, /* GL_NORMAL_ARRAY_TYPE */ - 1002, /* GL_NORMAL_ARRAY_STRIDE */ - 149, /* GL_COLOR_ARRAY_SIZE */ - 151, /* GL_COLOR_ARRAY_TYPE */ - 150, /* GL_COLOR_ARRAY_STRIDE */ - 620, /* GL_INDEX_ARRAY_TYPE */ - 619, /* GL_INDEX_ARRAY_STRIDE */ - 1626, /* GL_TEXTURE_COORD_ARRAY_SIZE */ - 1628, /* GL_TEXTURE_COORD_ARRAY_TYPE */ - 1627, /* GL_TEXTURE_COORD_ARRAY_STRIDE */ - 453, /* GL_EDGE_FLAG_ARRAY_STRIDE */ - 1754, /* GL_VERTEX_ARRAY_POINTER */ - 1001, /* GL_NORMAL_ARRAY_POINTER */ - 148, /* GL_COLOR_ARRAY_POINTER */ - 618, /* GL_INDEX_ARRAY_POINTER */ - 1625, /* GL_TEXTURE_COORD_ARRAY_POINTER */ - 452, /* GL_EDGE_FLAG_ARRAY_POINTER */ - 977, /* GL_MULTISAMPLE */ - 1363, /* GL_SAMPLE_ALPHA_TO_COVERAGE */ - 1365, /* GL_SAMPLE_ALPHA_TO_ONE */ - 1370, /* GL_SAMPLE_COVERAGE */ - 1367, /* GL_SAMPLE_BUFFERS */ - 1358, /* GL_SAMPLES */ - 1374, /* GL_SAMPLE_COVERAGE_VALUE */ - 1372, /* GL_SAMPLE_COVERAGE_INVERT */ - 192, /* GL_COLOR_MATRIX */ - 194, /* GL_COLOR_MATRIX_STACK_DEPTH */ - 840, /* 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 */ - 1605, /* GL_TEXTURE_COLOR_TABLE_SGI */ - 1247, /* GL_PROXY_TEXTURE_COLOR_TABLE_SGI */ - 1607, /* GL_TEXTURE_COMPARE_FAIL_VALUE_ARB */ - 79, /* GL_BLEND_DST_RGB */ - 88, /* GL_BLEND_SRC_RGB */ - 78, /* GL_BLEND_DST_ALPHA */ - 87, /* GL_BLEND_SRC_ALPHA */ - 198, /* 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 */ - 222, /* GL_COLOR_TABLE_SCALE */ - 202, /* GL_COLOR_TABLE_BIAS */ - 207, /* GL_COLOR_TABLE_FORMAT */ - 224, /* GL_COLOR_TABLE_WIDTH */ - 219, /* GL_COLOR_TABLE_RED_SIZE */ - 210, /* GL_COLOR_TABLE_GREEN_SIZE */ - 204, /* GL_COLOR_TABLE_BLUE_SIZE */ - 199, /* GL_COLOR_TABLE_ALPHA_SIZE */ - 216, /* GL_COLOR_TABLE_LUMINANCE_SIZE */ - 213, /* GL_COLOR_TABLE_INTENSITY_SIZE */ - 70, /* GL_BGR */ - 71, /* GL_BGRA */ - 854, /* GL_MAX_ELEMENTS_VERTICES */ - 853, /* GL_MAX_ELEMENTS_INDICES */ - 1659, /* GL_TEXTURE_INDEX_SIZE_EXT */ - 142, /* 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 */ - 124, /* GL_CLAMP_TO_BORDER */ - 127, /* GL_CLAMP_TO_EDGE */ - 1680, /* GL_TEXTURE_MIN_LOD */ - 1678, /* GL_TEXTURE_MAX_LOD */ - 1584, /* GL_TEXTURE_BASE_LEVEL */ - 1677, /* GL_TEXTURE_MAX_LEVEL */ - 608, /* GL_IGNORE_BORDER_HP */ - 272, /* GL_CONSTANT_BORDER_HP */ - 1305, /* GL_REPLICATE_BORDER_HP */ - 278, /* GL_CONVOLUTION_BORDER_COLOR */ - 1026, /* GL_OCCLUSION_TEST_HP */ - 1027, /* GL_OCCLUSION_TEST_RESULT_HP */ - 679, /* GL_LINEAR_CLIPMAP_LINEAR_SGIX */ - 1599, /* GL_TEXTURE_CLIPMAP_CENTER_SGIX */ - 1601, /* GL_TEXTURE_CLIPMAP_FRAME_SGIX */ - 1603, /* GL_TEXTURE_CLIPMAP_OFFSET_SGIX */ - 1604, /* GL_TEXTURE_CLIPMAP_VIRTUAL_DEPTH_SGIX */ - 1602, /* GL_TEXTURE_CLIPMAP_LOD_OFFSET_SGIX */ - 1600, /* GL_TEXTURE_CLIPMAP_DEPTH_SGIX */ - 836, /* GL_MAX_CLIPMAP_DEPTH_SGIX */ - 837, /* 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 */ - 1667, /* GL_TEXTURE_LOD_BIAS_S_SGIX */ - 1668, /* GL_TEXTURE_LOD_BIAS_T_SGIX */ - 1666, /* GL_TEXTURE_LOD_BIAS_R_SGIX */ - 578, /* GL_GENERATE_MIPMAP */ - 579, /* GL_GENERATE_MIPMAP_HINT */ - 520, /* GL_FOG_OFFSET_SGIX */ - 521, /* GL_FOG_OFFSET_VALUE_SGIX */ - 1613, /* GL_TEXTURE_COMPARE_SGIX */ - 1612, /* GL_TEXTURE_COMPARE_OPERATOR_SGIX */ - 1663, /* GL_TEXTURE_LEQUAL_R_SGIX */ - 1655, /* GL_TEXTURE_GEQUAL_R_SGIX */ - 352, /* GL_DEPTH_COMPONENT16 */ - 355, /* GL_DEPTH_COMPONENT24 */ - 358, /* GL_DEPTH_COMPONENT32 */ - 300, /* GL_CULL_VERTEX_EXT */ - 302, /* GL_CULL_VERTEX_OBJECT_POSITION_EXT */ - 301, /* GL_CULL_VERTEX_EYE_POSITION_EXT */ - 1811, /* GL_WRAP_BORDER_SUN */ - 1606, /* GL_TEXTURE_COLOR_WRITEMASK_SGIS */ - 672, /* GL_LIGHT_MODEL_COLOR_CONTROL */ - 1403, /* GL_SINGLE_COLOR */ - 1390, /* GL_SEPARATE_SPECULAR_COLOR */ - 1399, /* GL_SHARED_TEXTURE_PALETTE_EXT */ - 531, /* GL_FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING */ - 532, /* GL_FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE */ - 539, /* GL_FRAMEBUFFER_ATTACHMENT_RED_SIZE */ - 534, /* GL_FRAMEBUFFER_ATTACHMENT_GREEN_SIZE */ - 530, /* GL_FRAMEBUFFER_ATTACHMENT_BLUE_SIZE */ - 529, /* GL_FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE */ - 533, /* GL_FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE */ - 540, /* GL_FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE */ - 551, /* GL_FRAMEBUFFER_DEFAULT */ - 564, /* GL_FRAMEBUFFER_UNDEFINED */ - 365, /* GL_DEPTH_STENCIL_ATTACHMENT */ - 614, /* GL_INDEX */ - 1723, /* GL_UNSIGNED_BYTE_2_3_3_REV */ - 1738, /* GL_UNSIGNED_SHORT_5_6_5 */ - 1739, /* GL_UNSIGNED_SHORT_5_6_5_REV */ - 1736, /* GL_UNSIGNED_SHORT_4_4_4_4_REV */ - 1734, /* GL_UNSIGNED_SHORT_1_5_5_5_REV */ - 1731, /* GL_UNSIGNED_INT_8_8_8_8_REV */ - 1729, /* GL_UNSIGNED_INT_2_10_10_10_REV */ - 1675, /* GL_TEXTURE_MAX_CLAMP_S_SGIX */ - 1676, /* GL_TEXTURE_MAX_CLAMP_T_SGIX */ - 1674, /* GL_TEXTURE_MAX_CLAMP_R_SGIX */ - 928, /* GL_MIRRORED_REPEAT */ - 1346, /* GL_RGB_S3TC */ - 1321, /* GL_RGB4_S3TC */ - 1344, /* GL_RGBA_S3TC */ - 1338, /* GL_RGBA4_S3TC */ - 1342, /* GL_RGBA_DXT5_S3TC */ - 1336, /* GL_RGBA4_DXT5_S3TC */ - 261, /* GL_COMPRESSED_RGB_S3TC_DXT1_EXT */ - 256, /* GL_COMPRESSED_RGBA_S3TC_DXT1_EXT */ - 257, /* GL_COMPRESSED_RGBA_S3TC_DXT3_EXT */ - 258, /* GL_COMPRESSED_RGBA_S3TC_DXT5_EXT */ - 989, /* GL_NEAREST_CLIPMAP_NEAREST_SGIX */ - 988, /* GL_NEAREST_CLIPMAP_LINEAR_SGIX */ - 680, /* GL_LINEAR_CLIPMAP_NEAREST_SGIX */ - 507, /* GL_FOG_COORDINATE_SOURCE */ - 499, /* GL_FOG_COORD */ - 523, /* GL_FRAGMENT_DEPTH */ - 306, /* GL_CURRENT_FOG_COORD */ - 506, /* GL_FOG_COORDINATE_ARRAY_TYPE */ - 505, /* GL_FOG_COORDINATE_ARRAY_STRIDE */ - 504, /* GL_FOG_COORDINATE_ARRAY_POINTER */ - 501, /* GL_FOG_COORDINATE_ARRAY */ - 196, /* GL_COLOR_SUM */ - 326, /* GL_CURRENT_SECONDARY_COLOR */ - 1383, /* GL_SECONDARY_COLOR_ARRAY_SIZE */ - 1385, /* GL_SECONDARY_COLOR_ARRAY_TYPE */ - 1384, /* GL_SECONDARY_COLOR_ARRAY_STRIDE */ - 1382, /* GL_SECONDARY_COLOR_ARRAY_POINTER */ - 1379, /* GL_SECONDARY_COLOR_ARRAY */ - 324, /* GL_CURRENT_RASTER_SECONDARY_COLOR */ + 725, /* GL_LUMINANCE4 */ + 731, /* GL_LUMINANCE8 */ + 715, /* GL_LUMINANCE12 */ + 721, /* GL_LUMINANCE16 */ + 726, /* GL_LUMINANCE4_ALPHA4 */ + 729, /* GL_LUMINANCE6_ALPHA2 */ + 732, /* GL_LUMINANCE8_ALPHA8 */ + 718, /* GL_LUMINANCE12_ALPHA4 */ + 716, /* GL_LUMINANCE12_ALPHA12 */ + 722, /* GL_LUMINANCE16_ALPHA16 */ + 637, /* GL_INTENSITY */ + 642, /* GL_INTENSITY4 */ + 644, /* GL_INTENSITY8 */ + 638, /* GL_INTENSITY12 */ + 640, /* GL_INTENSITY16 */ + 1336, /* GL_RGB2_EXT */ + 1337, /* GL_RGB4 */ + 1340, /* GL_RGB5 */ + 1344, /* GL_RGB8 */ + 1328, /* GL_RGB10 */ + 1332, /* GL_RGB12 */ + 1334, /* GL_RGB16 */ + 1351, /* GL_RGBA2 */ + 1353, /* GL_RGBA4 */ + 1341, /* GL_RGB5_A1 */ + 1357, /* GL_RGBA8 */ + 1329, /* GL_RGB10_A2 */ + 1347, /* GL_RGBA12 */ + 1349, /* GL_RGBA16 */ + 1715, /* GL_TEXTURE_RED_SIZE */ + 1685, /* GL_TEXTURE_GREEN_SIZE */ + 1623, /* GL_TEXTURE_BLUE_SIZE */ + 1610, /* GL_TEXTURE_ALPHA_SIZE */ + 1698, /* GL_TEXTURE_LUMINANCE_SIZE */ + 1689, /* GL_TEXTURE_INTENSITY_SIZE */ + 1322, /* GL_REPLACE_EXT */ + 1257, /* GL_PROXY_TEXTURE_1D */ + 1260, /* GL_PROXY_TEXTURE_2D */ + 1721, /* GL_TEXTURE_TOO_LARGE_EXT */ + 1710, /* GL_TEXTURE_PRIORITY */ + 1717, /* GL_TEXTURE_RESIDENT */ + 1613, /* GL_TEXTURE_BINDING_1D */ + 1615, /* GL_TEXTURE_BINDING_2D */ + 1617, /* GL_TEXTURE_BINDING_3D */ + 1083, /* GL_PACK_SKIP_IMAGES */ + 1079, /* GL_PACK_IMAGE_HEIGHT */ + 1752, /* GL_UNPACK_SKIP_IMAGES */ + 1749, /* GL_UNPACK_IMAGE_HEIGHT */ + 1609, /* GL_TEXTURE_3D */ + 1263, /* GL_PROXY_TEXTURE_3D */ + 1672, /* GL_TEXTURE_DEPTH */ + 1724, /* GL_TEXTURE_WRAP_R */ + 846, /* GL_MAX_3D_TEXTURE_SIZE */ + 1785, /* GL_VERTEX_ARRAY */ + 1013, /* GL_NORMAL_ARRAY */ + 148, /* GL_COLOR_ARRAY */ + 622, /* GL_INDEX_ARRAY */ + 1650, /* GL_TEXTURE_COORD_ARRAY */ + 455, /* GL_EDGE_FLAG_ARRAY */ + 1791, /* GL_VERTEX_ARRAY_SIZE */ + 1793, /* GL_VERTEX_ARRAY_TYPE */ + 1792, /* GL_VERTEX_ARRAY_STRIDE */ + 1018, /* GL_NORMAL_ARRAY_TYPE */ + 1017, /* GL_NORMAL_ARRAY_STRIDE */ + 152, /* GL_COLOR_ARRAY_SIZE */ + 154, /* GL_COLOR_ARRAY_TYPE */ + 153, /* GL_COLOR_ARRAY_STRIDE */ + 627, /* GL_INDEX_ARRAY_TYPE */ + 626, /* GL_INDEX_ARRAY_STRIDE */ + 1654, /* GL_TEXTURE_COORD_ARRAY_SIZE */ + 1656, /* GL_TEXTURE_COORD_ARRAY_TYPE */ + 1655, /* GL_TEXTURE_COORD_ARRAY_STRIDE */ + 459, /* GL_EDGE_FLAG_ARRAY_STRIDE */ + 1790, /* GL_VERTEX_ARRAY_POINTER */ + 1016, /* GL_NORMAL_ARRAY_POINTER */ + 151, /* GL_COLOR_ARRAY_POINTER */ + 625, /* GL_INDEX_ARRAY_POINTER */ + 1653, /* GL_TEXTURE_COORD_ARRAY_POINTER */ + 458, /* GL_EDGE_FLAG_ARRAY_POINTER */ + 992, /* GL_MULTISAMPLE */ + 1381, /* GL_SAMPLE_ALPHA_TO_COVERAGE */ + 1383, /* GL_SAMPLE_ALPHA_TO_ONE */ + 1388, /* GL_SAMPLE_COVERAGE */ + 1385, /* GL_SAMPLE_BUFFERS */ + 1376, /* GL_SAMPLES */ + 1392, /* GL_SAMPLE_COVERAGE_VALUE */ + 1390, /* GL_SAMPLE_COVERAGE_INVERT */ + 195, /* GL_COLOR_MATRIX */ + 197, /* GL_COLOR_MATRIX_STACK_DEPTH */ + 854, /* GL_MAX_COLOR_MATRIX_STACK_DEPTH */ + 1188, /* GL_POST_COLOR_MATRIX_RED_SCALE */ + 1184, /* GL_POST_COLOR_MATRIX_GREEN_SCALE */ + 1179, /* GL_POST_COLOR_MATRIX_BLUE_SCALE */ + 1175, /* GL_POST_COLOR_MATRIX_ALPHA_SCALE */ + 1186, /* GL_POST_COLOR_MATRIX_RED_BIAS */ + 1182, /* GL_POST_COLOR_MATRIX_GREEN_BIAS */ + 1177, /* GL_POST_COLOR_MATRIX_BLUE_BIAS */ + 1173, /* GL_POST_COLOR_MATRIX_ALPHA_BIAS */ + 1633, /* GL_TEXTURE_COLOR_TABLE_SGI */ + 1264, /* GL_PROXY_TEXTURE_COLOR_TABLE_SGI */ + 1635, /* GL_TEXTURE_COMPARE_FAIL_VALUE_ARB */ + 80, /* GL_BLEND_DST_RGB */ + 89, /* GL_BLEND_SRC_RGB */ + 79, /* GL_BLEND_DST_ALPHA */ + 88, /* GL_BLEND_SRC_ALPHA */ + 201, /* GL_COLOR_TABLE */ + 1198, /* GL_POST_CONVOLUTION_COLOR_TABLE */ + 1181, /* GL_POST_COLOR_MATRIX_COLOR_TABLE */ + 1252, /* GL_PROXY_COLOR_TABLE */ + 1256, /* GL_PROXY_POST_CONVOLUTION_COLOR_TABLE */ + 1255, /* GL_PROXY_POST_COLOR_MATRIX_COLOR_TABLE */ + 225, /* GL_COLOR_TABLE_SCALE */ + 205, /* GL_COLOR_TABLE_BIAS */ + 210, /* GL_COLOR_TABLE_FORMAT */ + 227, /* GL_COLOR_TABLE_WIDTH */ + 222, /* GL_COLOR_TABLE_RED_SIZE */ + 213, /* GL_COLOR_TABLE_GREEN_SIZE */ + 207, /* GL_COLOR_TABLE_BLUE_SIZE */ + 202, /* GL_COLOR_TABLE_ALPHA_SIZE */ + 219, /* GL_COLOR_TABLE_LUMINANCE_SIZE */ + 216, /* GL_COLOR_TABLE_INTENSITY_SIZE */ + 71, /* GL_BGR */ + 72, /* GL_BGRA */ + 868, /* GL_MAX_ELEMENTS_VERTICES */ + 867, /* GL_MAX_ELEMENTS_INDICES */ + 1688, /* GL_TEXTURE_INDEX_SIZE_EXT */ + 145, /* GL_CLIP_VOLUME_CLIPPING_HINT_EXT */ + 1145, /* GL_POINT_SIZE_MIN */ + 1141, /* GL_POINT_SIZE_MAX */ + 1135, /* GL_POINT_FADE_THRESHOLD_SIZE */ + 1131, /* GL_POINT_DISTANCE_ATTENUATION */ + 127, /* GL_CLAMP_TO_BORDER */ + 130, /* GL_CLAMP_TO_EDGE */ + 1709, /* GL_TEXTURE_MIN_LOD */ + 1707, /* GL_TEXTURE_MAX_LOD */ + 1612, /* GL_TEXTURE_BASE_LEVEL */ + 1706, /* GL_TEXTURE_MAX_LEVEL */ + 615, /* GL_IGNORE_BORDER_HP */ + 276, /* GL_CONSTANT_BORDER_HP */ + 1323, /* GL_REPLICATE_BORDER_HP */ + 282, /* GL_CONVOLUTION_BORDER_COLOR */ + 1042, /* GL_OCCLUSION_TEST_HP */ + 1043, /* GL_OCCLUSION_TEST_RESULT_HP */ + 687, /* GL_LINEAR_CLIPMAP_LINEAR_SGIX */ + 1627, /* GL_TEXTURE_CLIPMAP_CENTER_SGIX */ + 1629, /* GL_TEXTURE_CLIPMAP_FRAME_SGIX */ + 1631, /* GL_TEXTURE_CLIPMAP_OFFSET_SGIX */ + 1632, /* GL_TEXTURE_CLIPMAP_VIRTUAL_DEPTH_SGIX */ + 1630, /* GL_TEXTURE_CLIPMAP_LOD_OFFSET_SGIX */ + 1628, /* GL_TEXTURE_CLIPMAP_DEPTH_SGIX */ + 850, /* GL_MAX_CLIPMAP_DEPTH_SGIX */ + 851, /* GL_MAX_CLIPMAP_VIRTUAL_DEPTH_SGIX */ + 1208, /* GL_POST_TEXTURE_FILTER_BIAS_SGIX */ + 1210, /* GL_POST_TEXTURE_FILTER_SCALE_SGIX */ + 1207, /* GL_POST_TEXTURE_FILTER_BIAS_RANGE_SGIX */ + 1209, /* GL_POST_TEXTURE_FILTER_SCALE_RANGE_SGIX */ + 1696, /* GL_TEXTURE_LOD_BIAS_S_SGIX */ + 1697, /* GL_TEXTURE_LOD_BIAS_T_SGIX */ + 1695, /* GL_TEXTURE_LOD_BIAS_R_SGIX */ + 585, /* GL_GENERATE_MIPMAP */ + 586, /* GL_GENERATE_MIPMAP_HINT */ + 527, /* GL_FOG_OFFSET_SGIX */ + 528, /* GL_FOG_OFFSET_VALUE_SGIX */ + 1641, /* GL_TEXTURE_COMPARE_SGIX */ + 1640, /* GL_TEXTURE_COMPARE_OPERATOR_SGIX */ + 1692, /* GL_TEXTURE_LEQUAL_R_SGIX */ + 1684, /* GL_TEXTURE_GEQUAL_R_SGIX */ + 358, /* GL_DEPTH_COMPONENT16 */ + 361, /* GL_DEPTH_COMPONENT24 */ + 364, /* GL_DEPTH_COMPONENT32 */ + 306, /* GL_CULL_VERTEX_EXT */ + 308, /* GL_CULL_VERTEX_OBJECT_POSITION_EXT */ + 307, /* GL_CULL_VERTEX_EYE_POSITION_EXT */ + 1848, /* GL_WRAP_BORDER_SUN */ + 1634, /* GL_TEXTURE_COLOR_WRITEMASK_SGIS */ + 680, /* GL_LIGHT_MODEL_COLOR_CONTROL */ + 1422, /* GL_SINGLE_COLOR */ + 1408, /* GL_SEPARATE_SPECULAR_COLOR */ + 1417, /* GL_SHARED_TEXTURE_PALETTE_EXT */ + 538, /* GL_FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING */ + 539, /* GL_FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE */ + 546, /* GL_FRAMEBUFFER_ATTACHMENT_RED_SIZE */ + 541, /* GL_FRAMEBUFFER_ATTACHMENT_GREEN_SIZE */ + 537, /* GL_FRAMEBUFFER_ATTACHMENT_BLUE_SIZE */ + 536, /* GL_FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE */ + 540, /* GL_FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE */ + 547, /* GL_FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE */ + 558, /* GL_FRAMEBUFFER_DEFAULT */ + 571, /* GL_FRAMEBUFFER_UNDEFINED */ + 371, /* GL_DEPTH_STENCIL_ATTACHMENT */ + 621, /* GL_INDEX */ + 1758, /* GL_UNSIGNED_BYTE_2_3_3_REV */ + 1773, /* GL_UNSIGNED_SHORT_5_6_5 */ + 1774, /* GL_UNSIGNED_SHORT_5_6_5_REV */ + 1771, /* GL_UNSIGNED_SHORT_4_4_4_4_REV */ + 1769, /* GL_UNSIGNED_SHORT_1_5_5_5_REV */ + 1766, /* GL_UNSIGNED_INT_8_8_8_8_REV */ + 1764, /* GL_UNSIGNED_INT_2_10_10_10_REV */ + 1704, /* GL_TEXTURE_MAX_CLAMP_S_SGIX */ + 1705, /* GL_TEXTURE_MAX_CLAMP_T_SGIX */ + 1703, /* GL_TEXTURE_MAX_CLAMP_R_SGIX */ + 943, /* GL_MIRRORED_REPEAT */ + 1364, /* GL_RGB_S3TC */ + 1339, /* GL_RGB4_S3TC */ + 1362, /* GL_RGBA_S3TC */ + 1356, /* GL_RGBA4_S3TC */ + 1360, /* GL_RGBA_DXT5_S3TC */ + 1354, /* GL_RGBA4_DXT5_S3TC */ + 264, /* GL_COMPRESSED_RGB_S3TC_DXT1_EXT */ + 259, /* GL_COMPRESSED_RGBA_S3TC_DXT1_EXT */ + 260, /* GL_COMPRESSED_RGBA_S3TC_DXT3_EXT */ + 261, /* GL_COMPRESSED_RGBA_S3TC_DXT5_EXT */ + 1004, /* GL_NEAREST_CLIPMAP_NEAREST_SGIX */ + 1003, /* GL_NEAREST_CLIPMAP_LINEAR_SGIX */ + 688, /* GL_LINEAR_CLIPMAP_NEAREST_SGIX */ + 514, /* GL_FOG_COORDINATE_SOURCE */ + 506, /* GL_FOG_COORD */ + 530, /* GL_FRAGMENT_DEPTH */ + 312, /* GL_CURRENT_FOG_COORD */ + 513, /* GL_FOG_COORDINATE_ARRAY_TYPE */ + 512, /* GL_FOG_COORDINATE_ARRAY_STRIDE */ + 511, /* GL_FOG_COORDINATE_ARRAY_POINTER */ + 508, /* GL_FOG_COORDINATE_ARRAY */ + 199, /* GL_COLOR_SUM */ + 332, /* GL_CURRENT_SECONDARY_COLOR */ + 1401, /* GL_SECONDARY_COLOR_ARRAY_SIZE */ + 1403, /* GL_SECONDARY_COLOR_ARRAY_TYPE */ + 1402, /* GL_SECONDARY_COLOR_ARRAY_STRIDE */ + 1400, /* GL_SECONDARY_COLOR_ARRAY_POINTER */ + 1397, /* GL_SECONDARY_COLOR_ARRAY */ + 330, /* GL_CURRENT_RASTER_SECONDARY_COLOR */ 28, /* GL_ALIASED_POINT_SIZE_RANGE */ 27, /* GL_ALIASED_LINE_WIDTH_RANGE */ - 1513, /* GL_TEXTURE0 */ - 1515, /* GL_TEXTURE1 */ - 1537, /* GL_TEXTURE2 */ - 1559, /* GL_TEXTURE3 */ - 1565, /* GL_TEXTURE4 */ - 1567, /* GL_TEXTURE5 */ - 1569, /* GL_TEXTURE6 */ - 1571, /* GL_TEXTURE7 */ - 1573, /* GL_TEXTURE8 */ - 1575, /* GL_TEXTURE9 */ - 1516, /* GL_TEXTURE10 */ - 1518, /* GL_TEXTURE11 */ - 1520, /* GL_TEXTURE12 */ - 1522, /* GL_TEXTURE13 */ - 1524, /* GL_TEXTURE14 */ - 1526, /* GL_TEXTURE15 */ - 1528, /* GL_TEXTURE16 */ - 1530, /* GL_TEXTURE17 */ - 1532, /* GL_TEXTURE18 */ - 1534, /* GL_TEXTURE19 */ - 1538, /* GL_TEXTURE20 */ - 1540, /* GL_TEXTURE21 */ - 1542, /* GL_TEXTURE22 */ - 1544, /* GL_TEXTURE23 */ - 1546, /* GL_TEXTURE24 */ - 1548, /* GL_TEXTURE25 */ - 1550, /* GL_TEXTURE26 */ - 1552, /* GL_TEXTURE27 */ - 1554, /* GL_TEXTURE28 */ - 1556, /* GL_TEXTURE29 */ - 1560, /* GL_TEXTURE30 */ - 1562, /* GL_TEXTURE31 */ + 1541, /* GL_TEXTURE0 */ + 1543, /* GL_TEXTURE1 */ + 1565, /* GL_TEXTURE2 */ + 1587, /* GL_TEXTURE3 */ + 1593, /* GL_TEXTURE4 */ + 1595, /* GL_TEXTURE5 */ + 1597, /* GL_TEXTURE6 */ + 1599, /* GL_TEXTURE7 */ + 1601, /* GL_TEXTURE8 */ + 1603, /* GL_TEXTURE9 */ + 1544, /* GL_TEXTURE10 */ + 1546, /* GL_TEXTURE11 */ + 1548, /* GL_TEXTURE12 */ + 1550, /* GL_TEXTURE13 */ + 1552, /* GL_TEXTURE14 */ + 1554, /* GL_TEXTURE15 */ + 1556, /* GL_TEXTURE16 */ + 1558, /* GL_TEXTURE17 */ + 1560, /* GL_TEXTURE18 */ + 1562, /* GL_TEXTURE19 */ + 1566, /* GL_TEXTURE20 */ + 1568, /* GL_TEXTURE21 */ + 1570, /* GL_TEXTURE22 */ + 1572, /* GL_TEXTURE23 */ + 1574, /* GL_TEXTURE24 */ + 1576, /* GL_TEXTURE25 */ + 1578, /* GL_TEXTURE26 */ + 1580, /* GL_TEXTURE27 */ + 1582, /* GL_TEXTURE28 */ + 1584, /* GL_TEXTURE29 */ + 1588, /* GL_TEXTURE30 */ + 1590, /* GL_TEXTURE31 */ 18, /* GL_ACTIVE_TEXTURE */ - 130, /* GL_CLIENT_ACTIVE_TEXTURE */ - 906, /* GL_MAX_TEXTURE_UNITS */ - 1702, /* GL_TRANSPOSE_MODELVIEW_MATRIX */ - 1705, /* GL_TRANSPOSE_PROJECTION_MATRIX */ - 1707, /* GL_TRANSPOSE_TEXTURE_MATRIX */ - 1699, /* GL_TRANSPOSE_COLOR_MATRIX */ - 1501, /* GL_SUBTRACT */ - 894, /* GL_MAX_RENDERBUFFER_SIZE_EXT */ - 244, /* GL_COMPRESSED_ALPHA */ - 248, /* GL_COMPRESSED_LUMINANCE */ - 249, /* GL_COMPRESSED_LUMINANCE_ALPHA */ - 246, /* GL_COMPRESSED_INTENSITY */ - 252, /* GL_COMPRESSED_RGB */ - 253, /* GL_COMPRESSED_RGBA */ - 1620, /* GL_TEXTURE_COMPRESSION_HINT */ - 1682, /* GL_TEXTURE_RECTANGLE_ARB */ - 1592, /* GL_TEXTURE_BINDING_RECTANGLE_ARB */ - 1250, /* GL_PROXY_TEXTURE_RECTANGLE_ARB */ - 892, /* GL_MAX_RECTANGLE_TEXTURE_SIZE_ARB */ - 364, /* GL_DEPTH_STENCIL */ - 1727, /* GL_UNSIGNED_INT_24_8 */ - 902, /* GL_MAX_TEXTURE_LOD_BIAS */ - 1673, /* GL_TEXTURE_MAX_ANISOTROPY_EXT */ - 903, /* GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT */ - 1649, /* GL_TEXTURE_FILTER_CONTROL */ - 1664, /* GL_TEXTURE_LOD_BIAS */ - 229, /* GL_COMBINE4 */ - 896, /* GL_MAX_SHININESS_NV */ - 897, /* GL_MAX_SPOT_EXPONENT_NV */ - 612, /* GL_INCR_WRAP */ - 337, /* GL_DECR_WRAP */ - 948, /* GL_MODELVIEW1_ARB */ - 1004, /* GL_NORMAL_MAP */ - 1280, /* GL_REFLECTION_MAP */ - 1629, /* GL_TEXTURE_CUBE_MAP */ - 1590, /* GL_TEXTURE_BINDING_CUBE_MAP */ - 1637, /* GL_TEXTURE_CUBE_MAP_POSITIVE_X */ - 1631, /* GL_TEXTURE_CUBE_MAP_NEGATIVE_X */ - 1639, /* GL_TEXTURE_CUBE_MAP_POSITIVE_Y */ - 1633, /* GL_TEXTURE_CUBE_MAP_NEGATIVE_Y */ - 1641, /* GL_TEXTURE_CUBE_MAP_POSITIVE_Z */ - 1635, /* GL_TEXTURE_CUBE_MAP_NEGATIVE_Z */ - 1248, /* GL_PROXY_TEXTURE_CUBE_MAP */ - 848, /* GL_MAX_CUBE_MAP_TEXTURE_SIZE */ - 983, /* GL_MULTISAMPLE_FILTER_HINT_NV */ - 515, /* GL_FOG_DISTANCE_MODE_NV */ - 468, /* GL_EYE_RADIAL_NV */ - 467, /* GL_EYE_PLANE_ABSOLUTE_NV */ - 228, /* GL_COMBINE */ - 235, /* GL_COMBINE_RGB */ - 230, /* GL_COMBINE_ALPHA */ - 1347, /* GL_RGB_SCALE */ + 133, /* GL_CLIENT_ACTIVE_TEXTURE */ + 921, /* GL_MAX_TEXTURE_UNITS */ + 1736, /* GL_TRANSPOSE_MODELVIEW_MATRIX */ + 1739, /* GL_TRANSPOSE_PROJECTION_MATRIX */ + 1741, /* GL_TRANSPOSE_TEXTURE_MATRIX */ + 1733, /* GL_TRANSPOSE_COLOR_MATRIX */ + 1523, /* GL_SUBTRACT */ + 908, /* GL_MAX_RENDERBUFFER_SIZE_EXT */ + 247, /* GL_COMPRESSED_ALPHA */ + 251, /* GL_COMPRESSED_LUMINANCE */ + 252, /* GL_COMPRESSED_LUMINANCE_ALPHA */ + 249, /* GL_COMPRESSED_INTENSITY */ + 255, /* GL_COMPRESSED_RGB */ + 256, /* GL_COMPRESSED_RGBA */ + 1648, /* GL_TEXTURE_COMPRESSION_HINT */ + 1713, /* GL_TEXTURE_RECTANGLE_ARB */ + 1620, /* GL_TEXTURE_BINDING_RECTANGLE_ARB */ + 1267, /* GL_PROXY_TEXTURE_RECTANGLE_ARB */ + 906, /* GL_MAX_RECTANGLE_TEXTURE_SIZE_ARB */ + 370, /* GL_DEPTH_STENCIL */ + 1762, /* GL_UNSIGNED_INT_24_8 */ + 917, /* GL_MAX_TEXTURE_LOD_BIAS */ + 1702, /* GL_TEXTURE_MAX_ANISOTROPY_EXT */ + 918, /* GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT */ + 1678, /* GL_TEXTURE_FILTER_CONTROL */ + 1693, /* GL_TEXTURE_LOD_BIAS */ + 232, /* GL_COMBINE4 */ + 911, /* GL_MAX_SHININESS_NV */ + 912, /* GL_MAX_SPOT_EXPONENT_NV */ + 619, /* GL_INCR_WRAP */ + 343, /* GL_DECR_WRAP */ + 963, /* GL_MODELVIEW1_ARB */ + 1019, /* GL_NORMAL_MAP */ + 1298, /* GL_REFLECTION_MAP */ + 1657, /* GL_TEXTURE_CUBE_MAP */ + 1618, /* GL_TEXTURE_BINDING_CUBE_MAP */ + 1665, /* GL_TEXTURE_CUBE_MAP_POSITIVE_X */ + 1659, /* GL_TEXTURE_CUBE_MAP_NEGATIVE_X */ + 1667, /* GL_TEXTURE_CUBE_MAP_POSITIVE_Y */ + 1661, /* GL_TEXTURE_CUBE_MAP_NEGATIVE_Y */ + 1669, /* GL_TEXTURE_CUBE_MAP_POSITIVE_Z */ + 1663, /* GL_TEXTURE_CUBE_MAP_NEGATIVE_Z */ + 1265, /* GL_PROXY_TEXTURE_CUBE_MAP */ + 862, /* GL_MAX_CUBE_MAP_TEXTURE_SIZE */ + 998, /* GL_MULTISAMPLE_FILTER_HINT_NV */ + 522, /* GL_FOG_DISTANCE_MODE_NV */ + 474, /* GL_EYE_RADIAL_NV */ + 473, /* GL_EYE_PLANE_ABSOLUTE_NV */ + 231, /* GL_COMBINE */ + 238, /* GL_COMBINE_RGB */ + 233, /* GL_COMBINE_ALPHA */ + 1365, /* GL_RGB_SCALE */ 24, /* GL_ADD_SIGNED */ - 640, /* GL_INTERPOLATE */ - 267, /* GL_CONSTANT */ - 1198, /* GL_PRIMARY_COLOR */ - 1195, /* GL_PREVIOUS */ - 1418, /* GL_SOURCE0_RGB */ - 1424, /* GL_SOURCE1_RGB */ - 1430, /* GL_SOURCE2_RGB */ - 1434, /* GL_SOURCE3_RGB_NV */ - 1415, /* GL_SOURCE0_ALPHA */ - 1421, /* GL_SOURCE1_ALPHA */ - 1427, /* GL_SOURCE2_ALPHA */ - 1433, /* GL_SOURCE3_ALPHA_NV */ - 1040, /* GL_OPERAND0_RGB */ - 1046, /* GL_OPERAND1_RGB */ - 1052, /* GL_OPERAND2_RGB */ - 1056, /* GL_OPERAND3_RGB_NV */ - 1037, /* GL_OPERAND0_ALPHA */ - 1043, /* GL_OPERAND1_ALPHA */ - 1049, /* GL_OPERAND2_ALPHA */ - 1055, /* GL_OPERAND3_ALPHA_NV */ - 1751, /* GL_VERTEX_ARRAY_BINDING_APPLE */ - 1815, /* GL_YCBCR_422_APPLE */ - 1740, /* GL_UNSIGNED_SHORT_8_8_APPLE */ - 1742, /* GL_UNSIGNED_SHORT_8_8_REV_APPLE */ - 1405, /* GL_SLICE_ACCUM_SUN */ - 1255, /* GL_QUAD_MESH_SUN */ - 1711, /* GL_TRIANGLE_MESH_SUN */ - 1789, /* GL_VERTEX_PROGRAM_ARB */ - 1800, /* GL_VERTEX_STATE_PROGRAM_NV */ - 1776, /* GL_VERTEX_ATTRIB_ARRAY_ENABLED */ - 1782, /* GL_VERTEX_ATTRIB_ARRAY_SIZE */ - 1784, /* GL_VERTEX_ATTRIB_ARRAY_STRIDE */ - 1786, /* GL_VERTEX_ATTRIB_ARRAY_TYPE */ - 328, /* GL_CURRENT_VERTEX_ATTRIB */ - 1211, /* GL_PROGRAM_LENGTH_ARB */ - 1225, /* GL_PROGRAM_STRING_ARB */ - 970, /* GL_MODELVIEW_PROJECTION_NV */ - 607, /* GL_IDENTITY_NV */ - 654, /* GL_INVERSE_NV */ - 1704, /* GL_TRANSPOSE_NV */ - 655, /* GL_INVERSE_TRANSPOSE_NV */ - 878, /* GL_MAX_PROGRAM_MATRIX_STACK_DEPTH_ARB */ - 877, /* GL_MAX_PROGRAM_MATRICES_ARB */ - 785, /* GL_MATRIX0_NV */ - 797, /* GL_MATRIX1_NV */ - 809, /* GL_MATRIX2_NV */ - 813, /* GL_MATRIX3_NV */ - 815, /* GL_MATRIX4_NV */ - 817, /* GL_MATRIX5_NV */ - 819, /* GL_MATRIX6_NV */ - 821, /* GL_MATRIX7_NV */ - 312, /* GL_CURRENT_MATRIX_STACK_DEPTH_ARB */ - 309, /* GL_CURRENT_MATRIX_ARB */ - 1792, /* GL_VERTEX_PROGRAM_POINT_SIZE */ - 1795, /* GL_VERTEX_PROGRAM_TWO_SIDE */ - 1223, /* GL_PROGRAM_PARAMETER_NV */ - 1780, /* GL_VERTEX_ATTRIB_ARRAY_POINTER */ - 1227, /* GL_PROGRAM_TARGET_NV */ - 1224, /* GL_PROGRAM_RESIDENT_NV */ - 1696, /* GL_TRACK_MATRIX_NV */ - 1697, /* GL_TRACK_MATRIX_TRANSFORM_NV */ - 1790, /* GL_VERTEX_PROGRAM_BINDING_NV */ - 1205, /* GL_PROGRAM_ERROR_POSITION_ARB */ - 349, /* GL_DEPTH_CLAMP_NV */ - 1758, /* GL_VERTEX_ATTRIB_ARRAY0_NV */ - 1765, /* GL_VERTEX_ATTRIB_ARRAY1_NV */ - 1766, /* GL_VERTEX_ATTRIB_ARRAY2_NV */ - 1767, /* GL_VERTEX_ATTRIB_ARRAY3_NV */ - 1768, /* GL_VERTEX_ATTRIB_ARRAY4_NV */ - 1769, /* GL_VERTEX_ATTRIB_ARRAY5_NV */ - 1770, /* GL_VERTEX_ATTRIB_ARRAY6_NV */ - 1771, /* GL_VERTEX_ATTRIB_ARRAY7_NV */ - 1772, /* GL_VERTEX_ATTRIB_ARRAY8_NV */ - 1773, /* GL_VERTEX_ATTRIB_ARRAY9_NV */ - 1759, /* GL_VERTEX_ATTRIB_ARRAY10_NV */ - 1760, /* GL_VERTEX_ATTRIB_ARRAY11_NV */ - 1761, /* GL_VERTEX_ATTRIB_ARRAY12_NV */ - 1762, /* GL_VERTEX_ATTRIB_ARRAY13_NV */ - 1763, /* GL_VERTEX_ATTRIB_ARRAY14_NV */ - 1764, /* GL_VERTEX_ATTRIB_ARRAY15_NV */ - 739, /* GL_MAP1_VERTEX_ATTRIB0_4_NV */ - 746, /* GL_MAP1_VERTEX_ATTRIB1_4_NV */ - 747, /* GL_MAP1_VERTEX_ATTRIB2_4_NV */ - 748, /* GL_MAP1_VERTEX_ATTRIB3_4_NV */ - 749, /* GL_MAP1_VERTEX_ATTRIB4_4_NV */ - 750, /* GL_MAP1_VERTEX_ATTRIB5_4_NV */ - 751, /* GL_MAP1_VERTEX_ATTRIB6_4_NV */ - 752, /* GL_MAP1_VERTEX_ATTRIB7_4_NV */ - 753, /* GL_MAP1_VERTEX_ATTRIB8_4_NV */ - 754, /* GL_MAP1_VERTEX_ATTRIB9_4_NV */ - 740, /* GL_MAP1_VERTEX_ATTRIB10_4_NV */ - 741, /* GL_MAP1_VERTEX_ATTRIB11_4_NV */ - 742, /* GL_MAP1_VERTEX_ATTRIB12_4_NV */ - 743, /* GL_MAP1_VERTEX_ATTRIB13_4_NV */ - 744, /* GL_MAP1_VERTEX_ATTRIB14_4_NV */ - 745, /* GL_MAP1_VERTEX_ATTRIB15_4_NV */ - 766, /* GL_MAP2_VERTEX_ATTRIB0_4_NV */ - 773, /* GL_MAP2_VERTEX_ATTRIB1_4_NV */ - 774, /* GL_MAP2_VERTEX_ATTRIB2_4_NV */ - 775, /* GL_MAP2_VERTEX_ATTRIB3_4_NV */ - 776, /* GL_MAP2_VERTEX_ATTRIB4_4_NV */ - 777, /* GL_MAP2_VERTEX_ATTRIB5_4_NV */ - 778, /* GL_MAP2_VERTEX_ATTRIB6_4_NV */ - 1204, /* GL_PROGRAM_BINDING_ARB */ - 780, /* GL_MAP2_VERTEX_ATTRIB8_4_NV */ - 781, /* GL_MAP2_VERTEX_ATTRIB9_4_NV */ - 767, /* GL_MAP2_VERTEX_ATTRIB10_4_NV */ - 768, /* GL_MAP2_VERTEX_ATTRIB11_4_NV */ - 769, /* GL_MAP2_VERTEX_ATTRIB12_4_NV */ - 770, /* GL_MAP2_VERTEX_ATTRIB13_4_NV */ - 771, /* GL_MAP2_VERTEX_ATTRIB14_4_NV */ - 772, /* GL_MAP2_VERTEX_ATTRIB15_4_NV */ - 1618, /* GL_TEXTURE_COMPRESSED_IMAGE_SIZE */ - 1615, /* GL_TEXTURE_COMPRESSED */ - 1009, /* GL_NUM_COMPRESSED_TEXTURE_FORMATS */ - 266, /* GL_COMPRESSED_TEXTURE_FORMATS */ - 918, /* GL_MAX_VERTEX_UNITS_ARB */ + 647, /* GL_INTERPOLATE */ + 271, /* GL_CONSTANT */ + 1214, /* GL_PRIMARY_COLOR */ + 1211, /* GL_PREVIOUS */ + 1437, /* GL_SOURCE0_RGB */ + 1443, /* GL_SOURCE1_RGB */ + 1449, /* GL_SOURCE2_RGB */ + 1453, /* GL_SOURCE3_RGB_NV */ + 1434, /* GL_SOURCE0_ALPHA */ + 1440, /* GL_SOURCE1_ALPHA */ + 1446, /* GL_SOURCE2_ALPHA */ + 1452, /* GL_SOURCE3_ALPHA_NV */ + 1056, /* GL_OPERAND0_RGB */ + 1062, /* GL_OPERAND1_RGB */ + 1068, /* GL_OPERAND2_RGB */ + 1072, /* GL_OPERAND3_RGB_NV */ + 1053, /* GL_OPERAND0_ALPHA */ + 1059, /* GL_OPERAND1_ALPHA */ + 1065, /* GL_OPERAND2_ALPHA */ + 1071, /* GL_OPERAND3_ALPHA_NV */ + 1786, /* GL_VERTEX_ARRAY_BINDING */ + 1711, /* GL_TEXTURE_RANGE_LENGTH_APPLE */ + 1712, /* GL_TEXTURE_RANGE_POINTER_APPLE */ + 1852, /* GL_YCBCR_422_APPLE */ + 1775, /* GL_UNSIGNED_SHORT_8_8_APPLE */ + 1777, /* GL_UNSIGNED_SHORT_8_8_REV_APPLE */ + 1720, /* GL_TEXTURE_STORAGE_HINT_APPLE */ + 1514, /* GL_STORAGE_PRIVATE_APPLE */ + 1513, /* GL_STORAGE_CACHED_APPLE */ + 1515, /* GL_STORAGE_SHARED_APPLE */ + 1424, /* GL_SLICE_ACCUM_SUN */ + 1273, /* GL_QUAD_MESH_SUN */ + 1745, /* GL_TRIANGLE_MESH_SUN */ + 1825, /* GL_VERTEX_PROGRAM_ARB */ + 1836, /* GL_VERTEX_STATE_PROGRAM_NV */ + 1812, /* GL_VERTEX_ATTRIB_ARRAY_ENABLED */ + 1818, /* GL_VERTEX_ATTRIB_ARRAY_SIZE */ + 1820, /* GL_VERTEX_ATTRIB_ARRAY_STRIDE */ + 1822, /* GL_VERTEX_ATTRIB_ARRAY_TYPE */ + 334, /* GL_CURRENT_VERTEX_ATTRIB */ + 1227, /* GL_PROGRAM_LENGTH_ARB */ + 1241, /* GL_PROGRAM_STRING_ARB */ + 985, /* GL_MODELVIEW_PROJECTION_NV */ + 614, /* GL_IDENTITY_NV */ + 661, /* GL_INVERSE_NV */ + 1738, /* GL_TRANSPOSE_NV */ + 662, /* GL_INVERSE_TRANSPOSE_NV */ + 892, /* GL_MAX_PROGRAM_MATRIX_STACK_DEPTH_ARB */ + 891, /* GL_MAX_PROGRAM_MATRICES_ARB */ + 799, /* GL_MATRIX0_NV */ + 811, /* GL_MATRIX1_NV */ + 823, /* GL_MATRIX2_NV */ + 827, /* GL_MATRIX3_NV */ + 829, /* GL_MATRIX4_NV */ + 831, /* GL_MATRIX5_NV */ + 833, /* GL_MATRIX6_NV */ + 835, /* GL_MATRIX7_NV */ + 318, /* GL_CURRENT_MATRIX_STACK_DEPTH_ARB */ + 315, /* GL_CURRENT_MATRIX_ARB */ + 1828, /* GL_VERTEX_PROGRAM_POINT_SIZE */ + 1831, /* GL_VERTEX_PROGRAM_TWO_SIDE */ + 1239, /* GL_PROGRAM_PARAMETER_NV */ + 1816, /* GL_VERTEX_ATTRIB_ARRAY_POINTER */ + 1243, /* GL_PROGRAM_TARGET_NV */ + 1240, /* GL_PROGRAM_RESIDENT_NV */ + 1730, /* GL_TRACK_MATRIX_NV */ + 1731, /* GL_TRACK_MATRIX_TRANSFORM_NV */ + 1826, /* GL_VERTEX_PROGRAM_BINDING_NV */ + 1221, /* GL_PROGRAM_ERROR_POSITION_ARB */ + 355, /* GL_DEPTH_CLAMP_NV */ + 1794, /* GL_VERTEX_ATTRIB_ARRAY0_NV */ + 1801, /* GL_VERTEX_ATTRIB_ARRAY1_NV */ + 1802, /* GL_VERTEX_ATTRIB_ARRAY2_NV */ + 1803, /* GL_VERTEX_ATTRIB_ARRAY3_NV */ + 1804, /* GL_VERTEX_ATTRIB_ARRAY4_NV */ + 1805, /* GL_VERTEX_ATTRIB_ARRAY5_NV */ + 1806, /* GL_VERTEX_ATTRIB_ARRAY6_NV */ + 1807, /* GL_VERTEX_ATTRIB_ARRAY7_NV */ + 1808, /* GL_VERTEX_ATTRIB_ARRAY8_NV */ + 1809, /* GL_VERTEX_ATTRIB_ARRAY9_NV */ + 1795, /* GL_VERTEX_ATTRIB_ARRAY10_NV */ + 1796, /* GL_VERTEX_ATTRIB_ARRAY11_NV */ + 1797, /* GL_VERTEX_ATTRIB_ARRAY12_NV */ + 1798, /* GL_VERTEX_ATTRIB_ARRAY13_NV */ + 1799, /* GL_VERTEX_ATTRIB_ARRAY14_NV */ + 1800, /* GL_VERTEX_ATTRIB_ARRAY15_NV */ + 747, /* GL_MAP1_VERTEX_ATTRIB0_4_NV */ + 754, /* GL_MAP1_VERTEX_ATTRIB1_4_NV */ + 755, /* GL_MAP1_VERTEX_ATTRIB2_4_NV */ + 756, /* GL_MAP1_VERTEX_ATTRIB3_4_NV */ + 757, /* GL_MAP1_VERTEX_ATTRIB4_4_NV */ + 758, /* GL_MAP1_VERTEX_ATTRIB5_4_NV */ + 759, /* GL_MAP1_VERTEX_ATTRIB6_4_NV */ + 760, /* GL_MAP1_VERTEX_ATTRIB7_4_NV */ + 761, /* GL_MAP1_VERTEX_ATTRIB8_4_NV */ + 762, /* GL_MAP1_VERTEX_ATTRIB9_4_NV */ + 748, /* GL_MAP1_VERTEX_ATTRIB10_4_NV */ + 749, /* GL_MAP1_VERTEX_ATTRIB11_4_NV */ + 750, /* GL_MAP1_VERTEX_ATTRIB12_4_NV */ + 751, /* GL_MAP1_VERTEX_ATTRIB13_4_NV */ + 752, /* GL_MAP1_VERTEX_ATTRIB14_4_NV */ + 753, /* GL_MAP1_VERTEX_ATTRIB15_4_NV */ + 774, /* GL_MAP2_VERTEX_ATTRIB0_4_NV */ + 781, /* GL_MAP2_VERTEX_ATTRIB1_4_NV */ + 782, /* GL_MAP2_VERTEX_ATTRIB2_4_NV */ + 783, /* GL_MAP2_VERTEX_ATTRIB3_4_NV */ + 784, /* GL_MAP2_VERTEX_ATTRIB4_4_NV */ + 785, /* GL_MAP2_VERTEX_ATTRIB5_4_NV */ + 786, /* GL_MAP2_VERTEX_ATTRIB6_4_NV */ + 1220, /* GL_PROGRAM_BINDING_ARB */ + 788, /* GL_MAP2_VERTEX_ATTRIB8_4_NV */ + 789, /* GL_MAP2_VERTEX_ATTRIB9_4_NV */ + 775, /* GL_MAP2_VERTEX_ATTRIB10_4_NV */ + 776, /* GL_MAP2_VERTEX_ATTRIB11_4_NV */ + 777, /* GL_MAP2_VERTEX_ATTRIB12_4_NV */ + 778, /* GL_MAP2_VERTEX_ATTRIB13_4_NV */ + 779, /* GL_MAP2_VERTEX_ATTRIB14_4_NV */ + 780, /* GL_MAP2_VERTEX_ATTRIB15_4_NV */ + 1646, /* GL_TEXTURE_COMPRESSED_IMAGE_SIZE */ + 1643, /* GL_TEXTURE_COMPRESSED */ + 1024, /* GL_NUM_COMPRESSED_TEXTURE_FORMATS */ + 269, /* GL_COMPRESSED_TEXTURE_FORMATS */ + 933, /* GL_MAX_VERTEX_UNITS_ARB */ 22, /* GL_ACTIVE_VERTEX_UNITS_ARB */ - 1810, /* GL_WEIGHT_SUM_UNITY_ARB */ - 1788, /* GL_VERTEX_BLEND_ARB */ - 330, /* GL_CURRENT_WEIGHT_ARB */ - 1809, /* GL_WEIGHT_ARRAY_TYPE_ARB */ - 1808, /* GL_WEIGHT_ARRAY_STRIDE_ARB */ - 1807, /* GL_WEIGHT_ARRAY_SIZE_ARB */ - 1806, /* GL_WEIGHT_ARRAY_POINTER_ARB */ - 1803, /* GL_WEIGHT_ARRAY_ARB */ - 377, /* GL_DOT3_RGB */ - 378, /* GL_DOT3_RGBA */ - 260, /* GL_COMPRESSED_RGB_FXT1_3DFX */ - 255, /* GL_COMPRESSED_RGBA_FXT1_3DFX */ - 978, /* GL_MULTISAMPLE_3DFX */ - 1368, /* GL_SAMPLE_BUFFERS_3DFX */ - 1359, /* GL_SAMPLES_3DFX */ - 959, /* GL_MODELVIEW2_ARB */ - 962, /* GL_MODELVIEW3_ARB */ - 963, /* GL_MODELVIEW4_ARB */ - 964, /* GL_MODELVIEW5_ARB */ - 965, /* GL_MODELVIEW6_ARB */ - 966, /* GL_MODELVIEW7_ARB */ - 967, /* GL_MODELVIEW8_ARB */ - 968, /* GL_MODELVIEW9_ARB */ - 938, /* GL_MODELVIEW10_ARB */ - 939, /* GL_MODELVIEW11_ARB */ - 940, /* GL_MODELVIEW12_ARB */ - 941, /* GL_MODELVIEW13_ARB */ - 942, /* GL_MODELVIEW14_ARB */ - 943, /* GL_MODELVIEW15_ARB */ - 944, /* GL_MODELVIEW16_ARB */ - 945, /* GL_MODELVIEW17_ARB */ - 946, /* GL_MODELVIEW18_ARB */ - 947, /* GL_MODELVIEW19_ARB */ - 949, /* GL_MODELVIEW20_ARB */ - 950, /* GL_MODELVIEW21_ARB */ - 951, /* GL_MODELVIEW22_ARB */ - 952, /* GL_MODELVIEW23_ARB */ - 953, /* GL_MODELVIEW24_ARB */ - 954, /* GL_MODELVIEW25_ARB */ - 955, /* GL_MODELVIEW26_ARB */ - 956, /* GL_MODELVIEW27_ARB */ - 957, /* GL_MODELVIEW28_ARB */ - 958, /* GL_MODELVIEW29_ARB */ - 960, /* GL_MODELVIEW30_ARB */ - 961, /* GL_MODELVIEW31_ARB */ - 382, /* GL_DOT3_RGB_EXT */ - 380, /* GL_DOT3_RGBA_EXT */ - 932, /* GL_MIRROR_CLAMP_EXT */ - 935, /* GL_MIRROR_CLAMP_TO_EDGE_EXT */ - 973, /* GL_MODULATE_ADD_ATI */ - 974, /* GL_MODULATE_SIGNED_ADD_ATI */ - 975, /* GL_MODULATE_SUBTRACT_ATI */ - 1816, /* GL_YCBCR_MESA */ - 1064, /* GL_PACK_INVERT_MESA */ - 333, /* GL_DEBUG_OBJECT_MESA */ - 334, /* GL_DEBUG_PRINT_MESA */ - 332, /* GL_DEBUG_ASSERT_MESA */ - 107, /* GL_BUFFER_SIZE */ - 109, /* GL_BUFFER_USAGE */ - 113, /* GL_BUMP_ROT_MATRIX_ATI */ - 114, /* GL_BUMP_ROT_MATRIX_SIZE_ATI */ - 112, /* GL_BUMP_NUM_TEX_UNITS_ATI */ - 116, /* GL_BUMP_TEX_UNITS_ATI */ - 441, /* GL_DUDV_ATI */ - 440, /* GL_DU8DV8_ATI */ - 111, /* GL_BUMP_ENVMAP_ATI */ - 115, /* GL_BUMP_TARGET_ATI */ - 1466, /* GL_STENCIL_BACK_FUNC */ - 1464, /* GL_STENCIL_BACK_FAIL */ - 1468, /* GL_STENCIL_BACK_PASS_DEPTH_FAIL */ - 1470, /* GL_STENCIL_BACK_PASS_DEPTH_PASS */ - 524, /* 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 */ - 867, /* GL_MAX_PROGRAM_ALU_INSTRUCTIONS_ARB */ - 890, /* GL_MAX_PROGRAM_TEX_INSTRUCTIONS_ARB */ - 889, /* GL_MAX_PROGRAM_TEX_INDIRECTIONS_ARB */ - 880, /* GL_MAX_PROGRAM_NATIVE_ALU_INSTRUCTIONS_ARB */ - 886, /* GL_MAX_PROGRAM_NATIVE_TEX_INSTRUCTIONS_ARB */ - 885, /* GL_MAX_PROGRAM_NATIVE_TEX_INDIRECTIONS_ARB */ - 850, /* GL_MAX_DRAW_BUFFERS */ - 386, /* GL_DRAW_BUFFER0 */ - 389, /* GL_DRAW_BUFFER1 */ - 410, /* GL_DRAW_BUFFER2 */ - 413, /* GL_DRAW_BUFFER3 */ - 416, /* GL_DRAW_BUFFER4 */ - 419, /* GL_DRAW_BUFFER5 */ - 422, /* GL_DRAW_BUFFER6 */ - 425, /* GL_DRAW_BUFFER7 */ - 428, /* GL_DRAW_BUFFER8 */ - 431, /* GL_DRAW_BUFFER9 */ - 390, /* GL_DRAW_BUFFER10 */ - 393, /* GL_DRAW_BUFFER11 */ - 396, /* GL_DRAW_BUFFER12 */ - 399, /* GL_DRAW_BUFFER13 */ - 402, /* GL_DRAW_BUFFER14 */ - 405, /* GL_DRAW_BUFFER15 */ - 81, /* GL_BLEND_EQUATION_ALPHA */ - 830, /* GL_MATRIX_PALETTE_ARB */ - 861, /* GL_MAX_MATRIX_PALETTE_STACK_DEPTH_ARB */ - 864, /* GL_MAX_PALETTE_MATRICES_ARB */ - 315, /* GL_CURRENT_PALETTE_MATRIX_ARB */ - 824, /* GL_MATRIX_INDEX_ARRAY_ARB */ - 310, /* GL_CURRENT_MATRIX_INDEX_ARB */ - 826, /* GL_MATRIX_INDEX_ARRAY_SIZE_ARB */ - 828, /* GL_MATRIX_INDEX_ARRAY_TYPE_ARB */ - 827, /* GL_MATRIX_INDEX_ARRAY_STRIDE_ARB */ - 825, /* GL_MATRIX_INDEX_ARRAY_POINTER_ARB */ - 1644, /* GL_TEXTURE_DEPTH_SIZE */ - 370, /* GL_DEPTH_TEXTURE_MODE */ - 1610, /* GL_TEXTURE_COMPARE_MODE */ - 1608, /* GL_TEXTURE_COMPARE_FUNC */ - 239, /* GL_COMPARE_R_TO_TEXTURE */ - 1136, /* GL_POINT_SPRITE */ - 292, /* GL_COORD_REPLACE */ - 1140, /* GL_POINT_SPRITE_R_MODE_NV */ - 1257, /* GL_QUERY_COUNTER_BITS */ - 317, /* GL_CURRENT_QUERY */ - 1259, /* GL_QUERY_RESULT */ - 1261, /* GL_QUERY_RESULT_AVAILABLE */ - 912, /* GL_MAX_VERTEX_ATTRIBS */ - 1778, /* GL_VERTEX_ATTRIB_ARRAY_NORMALIZED */ - 368, /* GL_DEPTH_STENCIL_TO_RGBA_NV */ - 367, /* GL_DEPTH_STENCIL_TO_BGRA_NV */ - 898, /* GL_MAX_TEXTURE_COORDS */ - 900, /* GL_MAX_TEXTURE_IMAGE_UNITS */ - 1207, /* GL_PROGRAM_ERROR_STRING_ARB */ - 1209, /* GL_PROGRAM_FORMAT_ASCII_ARB */ - 1208, /* GL_PROGRAM_FORMAT_ARB */ - 1690, /* GL_TEXTURE_UNSIGNED_REMAP_MODE_NV */ - 347, /* GL_DEPTH_BOUNDS_TEST_EXT */ - 346, /* GL_DEPTH_BOUNDS_EXT */ - 52, /* GL_ARRAY_BUFFER */ - 454, /* GL_ELEMENT_ARRAY_BUFFER */ - 53, /* GL_ARRAY_BUFFER_BINDING */ - 455, /* GL_ELEMENT_ARRAY_BUFFER_BINDING */ - 1752, /* GL_VERTEX_ARRAY_BUFFER_BINDING */ - 999, /* GL_NORMAL_ARRAY_BUFFER_BINDING */ - 146, /* GL_COLOR_ARRAY_BUFFER_BINDING */ - 616, /* GL_INDEX_ARRAY_BUFFER_BINDING */ - 1623, /* GL_TEXTURE_COORD_ARRAY_BUFFER_BINDING */ - 450, /* GL_EDGE_FLAG_ARRAY_BUFFER_BINDING */ - 1380, /* GL_SECONDARY_COLOR_ARRAY_BUFFER_BINDING */ - 502, /* GL_FOG_COORDINATE_ARRAY_BUFFER_BINDING */ - 1804, /* GL_WEIGHT_ARRAY_BUFFER_BINDING */ - 1774, /* GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING */ - 1210, /* GL_PROGRAM_INSTRUCTIONS_ARB */ - 873, /* GL_MAX_PROGRAM_INSTRUCTIONS_ARB */ - 1216, /* GL_PROGRAM_NATIVE_INSTRUCTIONS_ARB */ - 882, /* GL_MAX_PROGRAM_NATIVE_INSTRUCTIONS_ARB */ - 1228, /* GL_PROGRAM_TEMPORARIES_ARB */ - 888, /* GL_MAX_PROGRAM_TEMPORARIES_ARB */ - 1218, /* GL_PROGRAM_NATIVE_TEMPORARIES_ARB */ - 884, /* GL_MAX_PROGRAM_NATIVE_TEMPORARIES_ARB */ - 1222, /* GL_PROGRAM_PARAMETERS_ARB */ - 887, /* GL_MAX_PROGRAM_PARAMETERS_ARB */ - 1217, /* GL_PROGRAM_NATIVE_PARAMETERS_ARB */ - 883, /* GL_MAX_PROGRAM_NATIVE_PARAMETERS_ARB */ - 1203, /* GL_PROGRAM_ATTRIBS_ARB */ - 868, /* GL_MAX_PROGRAM_ATTRIBS_ARB */ - 1215, /* GL_PROGRAM_NATIVE_ATTRIBS_ARB */ - 881, /* GL_MAX_PROGRAM_NATIVE_ATTRIBS_ARB */ - 1201, /* GL_PROGRAM_ADDRESS_REGISTERS_ARB */ - 866, /* GL_MAX_PROGRAM_ADDRESS_REGISTERS_ARB */ - 1213, /* GL_PROGRAM_NATIVE_ADDRESS_REGISTERS_ARB */ - 879, /* GL_MAX_PROGRAM_NATIVE_ADDRESS_REGISTERS_ARB */ - 874, /* GL_MAX_PROGRAM_LOCAL_PARAMETERS_ARB */ - 870, /* GL_MAX_PROGRAM_ENV_PARAMETERS_ARB */ - 1231, /* GL_PROGRAM_UNDER_NATIVE_LIMITS_ARB */ - 1701, /* GL_TRANSPOSE_CURRENT_MATRIX_ARB */ - 1270, /* GL_READ_ONLY */ - 1812, /* GL_WRITE_ONLY */ - 1272, /* GL_READ_WRITE */ - 101, /* GL_BUFFER_ACCESS */ - 103, /* GL_BUFFER_MAPPED */ - 105, /* GL_BUFFER_MAP_POINTER */ - 1695, /* GL_TIME_ELAPSED_EXT */ - 784, /* GL_MATRIX0_ARB */ - 796, /* GL_MATRIX1_ARB */ - 808, /* GL_MATRIX2_ARB */ - 812, /* GL_MATRIX3_ARB */ - 814, /* GL_MATRIX4_ARB */ - 816, /* GL_MATRIX5_ARB */ - 818, /* GL_MATRIX6_ARB */ - 820, /* GL_MATRIX7_ARB */ - 822, /* GL_MATRIX8_ARB */ - 823, /* GL_MATRIX9_ARB */ - 786, /* GL_MATRIX10_ARB */ - 787, /* GL_MATRIX11_ARB */ - 788, /* GL_MATRIX12_ARB */ - 789, /* GL_MATRIX13_ARB */ - 790, /* GL_MATRIX14_ARB */ - 791, /* GL_MATRIX15_ARB */ - 792, /* GL_MATRIX16_ARB */ - 793, /* GL_MATRIX17_ARB */ - 794, /* GL_MATRIX18_ARB */ - 795, /* GL_MATRIX19_ARB */ - 798, /* GL_MATRIX20_ARB */ - 799, /* GL_MATRIX21_ARB */ - 800, /* GL_MATRIX22_ARB */ - 801, /* GL_MATRIX23_ARB */ - 802, /* GL_MATRIX24_ARB */ - 803, /* GL_MATRIX25_ARB */ - 804, /* GL_MATRIX26_ARB */ - 805, /* GL_MATRIX27_ARB */ - 806, /* GL_MATRIX28_ARB */ - 807, /* GL_MATRIX29_ARB */ - 810, /* GL_MATRIX30_ARB */ - 811, /* GL_MATRIX31_ARB */ - 1496, /* GL_STREAM_DRAW */ - 1498, /* GL_STREAM_READ */ - 1494, /* GL_STREAM_COPY */ - 1457, /* GL_STATIC_DRAW */ - 1459, /* GL_STATIC_READ */ - 1455, /* GL_STATIC_COPY */ - 444, /* GL_DYNAMIC_DRAW */ - 446, /* GL_DYNAMIC_READ */ - 442, /* GL_DYNAMIC_COPY */ - 1104, /* GL_PIXEL_PACK_BUFFER */ - 1108, /* GL_PIXEL_UNPACK_BUFFER */ - 1105, /* GL_PIXEL_PACK_BUFFER_BINDING */ - 1109, /* GL_PIXEL_UNPACK_BUFFER_BINDING */ - 341, /* GL_DEPTH24_STENCIL8 */ - 1688, /* GL_TEXTURE_STENCIL_SIZE */ - 871, /* GL_MAX_PROGRAM_EXEC_INSTRUCTIONS_NV */ - 869, /* GL_MAX_PROGRAM_CALL_DEPTH_NV */ - 872, /* GL_MAX_PROGRAM_IF_DEPTH_NV */ - 876, /* GL_MAX_PROGRAM_LOOP_DEPTH_NV */ - 875, /* GL_MAX_PROGRAM_LOOP_COUNT_NV */ - 833, /* GL_MAX_ARRAY_TEXTURE_LAYERS_EXT */ - 1490, /* GL_STENCIL_TEST_TWO_SIDE_EXT */ + 1847, /* GL_WEIGHT_SUM_UNITY_ARB */ + 1824, /* GL_VERTEX_BLEND_ARB */ + 336, /* GL_CURRENT_WEIGHT_ARB */ + 1846, /* GL_WEIGHT_ARRAY_TYPE_ARB */ + 1845, /* GL_WEIGHT_ARRAY_STRIDE_ARB */ + 1844, /* GL_WEIGHT_ARRAY_SIZE_ARB */ + 1843, /* GL_WEIGHT_ARRAY_POINTER_ARB */ + 1840, /* GL_WEIGHT_ARRAY_ARB */ + 383, /* GL_DOT3_RGB */ + 384, /* GL_DOT3_RGBA */ + 263, /* GL_COMPRESSED_RGB_FXT1_3DFX */ + 258, /* GL_COMPRESSED_RGBA_FXT1_3DFX */ + 993, /* GL_MULTISAMPLE_3DFX */ + 1386, /* GL_SAMPLE_BUFFERS_3DFX */ + 1377, /* GL_SAMPLES_3DFX */ + 974, /* GL_MODELVIEW2_ARB */ + 977, /* GL_MODELVIEW3_ARB */ + 978, /* GL_MODELVIEW4_ARB */ + 979, /* GL_MODELVIEW5_ARB */ + 980, /* GL_MODELVIEW6_ARB */ + 981, /* GL_MODELVIEW7_ARB */ + 982, /* GL_MODELVIEW8_ARB */ + 983, /* GL_MODELVIEW9_ARB */ + 953, /* GL_MODELVIEW10_ARB */ + 954, /* GL_MODELVIEW11_ARB */ + 955, /* GL_MODELVIEW12_ARB */ + 956, /* GL_MODELVIEW13_ARB */ + 957, /* GL_MODELVIEW14_ARB */ + 958, /* GL_MODELVIEW15_ARB */ + 959, /* GL_MODELVIEW16_ARB */ + 960, /* GL_MODELVIEW17_ARB */ + 961, /* GL_MODELVIEW18_ARB */ + 962, /* GL_MODELVIEW19_ARB */ + 964, /* GL_MODELVIEW20_ARB */ + 965, /* GL_MODELVIEW21_ARB */ + 966, /* GL_MODELVIEW22_ARB */ + 967, /* GL_MODELVIEW23_ARB */ + 968, /* GL_MODELVIEW24_ARB */ + 969, /* GL_MODELVIEW25_ARB */ + 970, /* GL_MODELVIEW26_ARB */ + 971, /* GL_MODELVIEW27_ARB */ + 972, /* GL_MODELVIEW28_ARB */ + 973, /* GL_MODELVIEW29_ARB */ + 975, /* GL_MODELVIEW30_ARB */ + 976, /* GL_MODELVIEW31_ARB */ + 388, /* GL_DOT3_RGB_EXT */ + 386, /* GL_DOT3_RGBA_EXT */ + 947, /* GL_MIRROR_CLAMP_EXT */ + 950, /* GL_MIRROR_CLAMP_TO_EDGE_EXT */ + 988, /* GL_MODULATE_ADD_ATI */ + 989, /* GL_MODULATE_SIGNED_ADD_ATI */ + 990, /* GL_MODULATE_SUBTRACT_ATI */ + 1853, /* GL_YCBCR_MESA */ + 1080, /* GL_PACK_INVERT_MESA */ + 339, /* GL_DEBUG_OBJECT_MESA */ + 340, /* GL_DEBUG_PRINT_MESA */ + 338, /* GL_DEBUG_ASSERT_MESA */ + 110, /* GL_BUFFER_SIZE */ + 112, /* GL_BUFFER_USAGE */ + 116, /* GL_BUMP_ROT_MATRIX_ATI */ + 117, /* GL_BUMP_ROT_MATRIX_SIZE_ATI */ + 115, /* GL_BUMP_NUM_TEX_UNITS_ATI */ + 119, /* GL_BUMP_TEX_UNITS_ATI */ + 447, /* GL_DUDV_ATI */ + 446, /* GL_DU8DV8_ATI */ + 114, /* GL_BUMP_ENVMAP_ATI */ + 118, /* GL_BUMP_TARGET_ATI */ + 1485, /* GL_STENCIL_BACK_FUNC */ + 1483, /* GL_STENCIL_BACK_FAIL */ + 1487, /* GL_STENCIL_BACK_PASS_DEPTH_FAIL */ + 1489, /* GL_STENCIL_BACK_PASS_DEPTH_PASS */ + 531, /* GL_FRAGMENT_PROGRAM_ARB */ + 1218, /* GL_PROGRAM_ALU_INSTRUCTIONS_ARB */ + 1246, /* GL_PROGRAM_TEX_INSTRUCTIONS_ARB */ + 1245, /* GL_PROGRAM_TEX_INDIRECTIONS_ARB */ + 1230, /* GL_PROGRAM_NATIVE_ALU_INSTRUCTIONS_ARB */ + 1236, /* GL_PROGRAM_NATIVE_TEX_INSTRUCTIONS_ARB */ + 1235, /* GL_PROGRAM_NATIVE_TEX_INDIRECTIONS_ARB */ + 881, /* GL_MAX_PROGRAM_ALU_INSTRUCTIONS_ARB */ + 904, /* GL_MAX_PROGRAM_TEX_INSTRUCTIONS_ARB */ + 903, /* GL_MAX_PROGRAM_TEX_INDIRECTIONS_ARB */ + 894, /* GL_MAX_PROGRAM_NATIVE_ALU_INSTRUCTIONS_ARB */ + 900, /* GL_MAX_PROGRAM_NATIVE_TEX_INSTRUCTIONS_ARB */ + 899, /* GL_MAX_PROGRAM_NATIVE_TEX_INDIRECTIONS_ARB */ + 864, /* GL_MAX_DRAW_BUFFERS */ + 392, /* GL_DRAW_BUFFER0 */ + 395, /* GL_DRAW_BUFFER1 */ + 416, /* GL_DRAW_BUFFER2 */ + 419, /* GL_DRAW_BUFFER3 */ + 422, /* GL_DRAW_BUFFER4 */ + 425, /* GL_DRAW_BUFFER5 */ + 428, /* GL_DRAW_BUFFER6 */ + 431, /* GL_DRAW_BUFFER7 */ + 434, /* GL_DRAW_BUFFER8 */ + 437, /* GL_DRAW_BUFFER9 */ + 396, /* GL_DRAW_BUFFER10 */ + 399, /* GL_DRAW_BUFFER11 */ + 402, /* GL_DRAW_BUFFER12 */ + 405, /* GL_DRAW_BUFFER13 */ + 408, /* GL_DRAW_BUFFER14 */ + 411, /* GL_DRAW_BUFFER15 */ + 82, /* GL_BLEND_EQUATION_ALPHA */ + 844, /* GL_MATRIX_PALETTE_ARB */ + 875, /* GL_MAX_MATRIX_PALETTE_STACK_DEPTH_ARB */ + 878, /* GL_MAX_PALETTE_MATRICES_ARB */ + 321, /* GL_CURRENT_PALETTE_MATRIX_ARB */ + 838, /* GL_MATRIX_INDEX_ARRAY_ARB */ + 316, /* GL_CURRENT_MATRIX_INDEX_ARB */ + 840, /* GL_MATRIX_INDEX_ARRAY_SIZE_ARB */ + 842, /* GL_MATRIX_INDEX_ARRAY_TYPE_ARB */ + 841, /* GL_MATRIX_INDEX_ARRAY_STRIDE_ARB */ + 839, /* GL_MATRIX_INDEX_ARRAY_POINTER_ARB */ + 1673, /* GL_TEXTURE_DEPTH_SIZE */ + 376, /* GL_DEPTH_TEXTURE_MODE */ + 1638, /* GL_TEXTURE_COMPARE_MODE */ + 1636, /* GL_TEXTURE_COMPARE_FUNC */ + 242, /* GL_COMPARE_R_TO_TEXTURE */ + 1152, /* GL_POINT_SPRITE */ + 296, /* GL_COORD_REPLACE */ + 1156, /* GL_POINT_SPRITE_R_MODE_NV */ + 1275, /* GL_QUERY_COUNTER_BITS */ + 323, /* GL_CURRENT_QUERY */ + 1277, /* GL_QUERY_RESULT */ + 1279, /* GL_QUERY_RESULT_AVAILABLE */ + 927, /* GL_MAX_VERTEX_ATTRIBS */ + 1814, /* GL_VERTEX_ATTRIB_ARRAY_NORMALIZED */ + 374, /* GL_DEPTH_STENCIL_TO_RGBA_NV */ + 373, /* GL_DEPTH_STENCIL_TO_BGRA_NV */ + 913, /* GL_MAX_TEXTURE_COORDS */ + 915, /* GL_MAX_TEXTURE_IMAGE_UNITS */ + 1223, /* GL_PROGRAM_ERROR_STRING_ARB */ + 1225, /* GL_PROGRAM_FORMAT_ASCII_ARB */ + 1224, /* GL_PROGRAM_FORMAT_ARB */ + 1722, /* GL_TEXTURE_UNSIGNED_REMAP_MODE_NV */ + 353, /* GL_DEPTH_BOUNDS_TEST_EXT */ + 352, /* GL_DEPTH_BOUNDS_EXT */ + 53, /* GL_ARRAY_BUFFER */ + 460, /* GL_ELEMENT_ARRAY_BUFFER */ + 54, /* GL_ARRAY_BUFFER_BINDING */ + 461, /* GL_ELEMENT_ARRAY_BUFFER_BINDING */ + 1788, /* GL_VERTEX_ARRAY_BUFFER_BINDING */ + 1014, /* GL_NORMAL_ARRAY_BUFFER_BINDING */ + 149, /* GL_COLOR_ARRAY_BUFFER_BINDING */ + 623, /* GL_INDEX_ARRAY_BUFFER_BINDING */ + 1651, /* GL_TEXTURE_COORD_ARRAY_BUFFER_BINDING */ + 456, /* GL_EDGE_FLAG_ARRAY_BUFFER_BINDING */ + 1398, /* GL_SECONDARY_COLOR_ARRAY_BUFFER_BINDING */ + 509, /* GL_FOG_COORDINATE_ARRAY_BUFFER_BINDING */ + 1841, /* GL_WEIGHT_ARRAY_BUFFER_BINDING */ + 1810, /* GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING */ + 1226, /* GL_PROGRAM_INSTRUCTIONS_ARB */ + 887, /* GL_MAX_PROGRAM_INSTRUCTIONS_ARB */ + 1232, /* GL_PROGRAM_NATIVE_INSTRUCTIONS_ARB */ + 896, /* GL_MAX_PROGRAM_NATIVE_INSTRUCTIONS_ARB */ + 1244, /* GL_PROGRAM_TEMPORARIES_ARB */ + 902, /* GL_MAX_PROGRAM_TEMPORARIES_ARB */ + 1234, /* GL_PROGRAM_NATIVE_TEMPORARIES_ARB */ + 898, /* GL_MAX_PROGRAM_NATIVE_TEMPORARIES_ARB */ + 1238, /* GL_PROGRAM_PARAMETERS_ARB */ + 901, /* GL_MAX_PROGRAM_PARAMETERS_ARB */ + 1233, /* GL_PROGRAM_NATIVE_PARAMETERS_ARB */ + 897, /* GL_MAX_PROGRAM_NATIVE_PARAMETERS_ARB */ + 1219, /* GL_PROGRAM_ATTRIBS_ARB */ + 882, /* GL_MAX_PROGRAM_ATTRIBS_ARB */ + 1231, /* GL_PROGRAM_NATIVE_ATTRIBS_ARB */ + 895, /* GL_MAX_PROGRAM_NATIVE_ATTRIBS_ARB */ + 1217, /* GL_PROGRAM_ADDRESS_REGISTERS_ARB */ + 880, /* GL_MAX_PROGRAM_ADDRESS_REGISTERS_ARB */ + 1229, /* GL_PROGRAM_NATIVE_ADDRESS_REGISTERS_ARB */ + 893, /* GL_MAX_PROGRAM_NATIVE_ADDRESS_REGISTERS_ARB */ + 888, /* GL_MAX_PROGRAM_LOCAL_PARAMETERS_ARB */ + 884, /* GL_MAX_PROGRAM_ENV_PARAMETERS_ARB */ + 1247, /* GL_PROGRAM_UNDER_NATIVE_LIMITS_ARB */ + 1735, /* GL_TRANSPOSE_CURRENT_MATRIX_ARB */ + 1288, /* GL_READ_ONLY */ + 1849, /* GL_WRITE_ONLY */ + 1290, /* GL_READ_WRITE */ + 102, /* GL_BUFFER_ACCESS */ + 105, /* GL_BUFFER_MAPPED */ + 107, /* GL_BUFFER_MAP_POINTER */ + 1729, /* GL_TIME_ELAPSED_EXT */ + 798, /* GL_MATRIX0_ARB */ + 810, /* GL_MATRIX1_ARB */ + 822, /* GL_MATRIX2_ARB */ + 826, /* GL_MATRIX3_ARB */ + 828, /* GL_MATRIX4_ARB */ + 830, /* GL_MATRIX5_ARB */ + 832, /* GL_MATRIX6_ARB */ + 834, /* GL_MATRIX7_ARB */ + 836, /* GL_MATRIX8_ARB */ + 837, /* GL_MATRIX9_ARB */ + 800, /* GL_MATRIX10_ARB */ + 801, /* GL_MATRIX11_ARB */ + 802, /* GL_MATRIX12_ARB */ + 803, /* GL_MATRIX13_ARB */ + 804, /* GL_MATRIX14_ARB */ + 805, /* GL_MATRIX15_ARB */ + 806, /* GL_MATRIX16_ARB */ + 807, /* GL_MATRIX17_ARB */ + 808, /* GL_MATRIX18_ARB */ + 809, /* GL_MATRIX19_ARB */ + 812, /* GL_MATRIX20_ARB */ + 813, /* GL_MATRIX21_ARB */ + 814, /* GL_MATRIX22_ARB */ + 815, /* GL_MATRIX23_ARB */ + 816, /* GL_MATRIX24_ARB */ + 817, /* GL_MATRIX25_ARB */ + 818, /* GL_MATRIX26_ARB */ + 819, /* GL_MATRIX27_ARB */ + 820, /* GL_MATRIX28_ARB */ + 821, /* GL_MATRIX29_ARB */ + 824, /* GL_MATRIX30_ARB */ + 825, /* GL_MATRIX31_ARB */ + 1518, /* GL_STREAM_DRAW */ + 1520, /* GL_STREAM_READ */ + 1516, /* GL_STREAM_COPY */ + 1476, /* GL_STATIC_DRAW */ + 1478, /* GL_STATIC_READ */ + 1474, /* GL_STATIC_COPY */ + 450, /* GL_DYNAMIC_DRAW */ + 452, /* GL_DYNAMIC_READ */ + 448, /* GL_DYNAMIC_COPY */ + 1120, /* GL_PIXEL_PACK_BUFFER */ + 1124, /* GL_PIXEL_UNPACK_BUFFER */ + 1121, /* GL_PIXEL_PACK_BUFFER_BINDING */ + 1125, /* GL_PIXEL_UNPACK_BUFFER_BINDING */ + 347, /* GL_DEPTH24_STENCIL8 */ + 1719, /* GL_TEXTURE_STENCIL_SIZE */ + 1671, /* GL_TEXTURE_CUBE_MAP_SEAMLESS */ + 883, /* GL_MAX_PROGRAM_CALL_DEPTH_NV */ + 886, /* GL_MAX_PROGRAM_IF_DEPTH_NV */ + 890, /* GL_MAX_PROGRAM_LOOP_DEPTH_NV */ + 889, /* GL_MAX_PROGRAM_LOOP_COUNT_NV */ + 847, /* GL_MAX_ARRAY_TEXTURE_LAYERS_EXT */ + 1509, /* GL_STENCIL_TEST_TWO_SIDE_EXT */ 17, /* GL_ACTIVE_STENCIL_FACE_EXT */ - 933, /* GL_MIRROR_CLAMP_TO_BORDER_EXT */ - 1361, /* GL_SAMPLES_PASSED */ - 525, /* GL_FRAGMENT_SHADER */ - 1798, /* GL_VERTEX_SHADER */ - 1221, /* GL_PROGRAM_OBJECT_ARB */ - 1393, /* GL_SHADER_OBJECT_ARB */ - 857, /* GL_MAX_FRAGMENT_UNIFORM_COMPONENTS */ - 916, /* GL_MAX_VERTEX_UNIFORM_COMPONENTS */ - 910, /* GL_MAX_VARYING_FLOATS */ - 914, /* GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS */ - 842, /* GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS */ - 1024, /* GL_OBJECT_TYPE_ARB */ - 1395, /* GL_SHADER_TYPE */ - 490, /* GL_FLOAT_VEC2 */ - 492, /* GL_FLOAT_VEC3 */ - 494, /* GL_FLOAT_VEC4 */ - 643, /* GL_INT_VEC2 */ - 645, /* GL_INT_VEC3 */ - 647, /* GL_INT_VEC4 */ - 93, /* GL_BOOL */ - 95, /* GL_BOOL_VEC2 */ - 97, /* GL_BOOL_VEC3 */ - 99, /* GL_BOOL_VEC4 */ - 478, /* GL_FLOAT_MAT2 */ - 482, /* GL_FLOAT_MAT3 */ - 486, /* GL_FLOAT_MAT4 */ - 1352, /* GL_SAMPLER_1D */ - 1354, /* GL_SAMPLER_2D */ - 1356, /* GL_SAMPLER_3D */ - 1357, /* GL_SAMPLER_CUBE */ - 1353, /* GL_SAMPLER_1D_SHADOW */ - 1355, /* GL_SAMPLER_2D_SHADOW */ - 480, /* GL_FLOAT_MAT2x3 */ - 481, /* GL_FLOAT_MAT2x4 */ - 484, /* GL_FLOAT_MAT3x2 */ - 485, /* GL_FLOAT_MAT3x4 */ - 488, /* GL_FLOAT_MAT4x2 */ - 489, /* GL_FLOAT_MAT4x3 */ - 339, /* GL_DELETE_STATUS */ - 243, /* GL_COMPILE_STATUS */ - 697, /* GL_LINK_STATUS */ - 1747, /* GL_VALIDATE_STATUS */ - 628, /* GL_INFO_LOG_LENGTH */ - 55, /* GL_ATTACHED_SHADERS */ + 948, /* GL_MIRROR_CLAMP_TO_BORDER_EXT */ + 1379, /* GL_SAMPLES_PASSED */ + 109, /* GL_BUFFER_SERIALIZED_MODIFY_APPLE */ + 104, /* GL_BUFFER_FLUSHING_UNMAP_APPLE */ + 532, /* GL_FRAGMENT_SHADER */ + 1834, /* GL_VERTEX_SHADER */ + 1237, /* GL_PROGRAM_OBJECT_ARB */ + 1411, /* GL_SHADER_OBJECT_ARB */ + 871, /* GL_MAX_FRAGMENT_UNIFORM_COMPONENTS */ + 931, /* GL_MAX_VERTEX_UNIFORM_COMPONENTS */ + 925, /* GL_MAX_VARYING_FLOATS */ + 929, /* GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS */ + 856, /* GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS */ + 1040, /* GL_OBJECT_TYPE_ARB */ + 1413, /* GL_SHADER_TYPE */ + 497, /* GL_FLOAT_VEC2 */ + 499, /* GL_FLOAT_VEC3 */ + 501, /* GL_FLOAT_VEC4 */ + 650, /* GL_INT_VEC2 */ + 652, /* GL_INT_VEC3 */ + 654, /* GL_INT_VEC4 */ + 94, /* GL_BOOL */ + 96, /* GL_BOOL_VEC2 */ + 98, /* GL_BOOL_VEC3 */ + 100, /* GL_BOOL_VEC4 */ + 485, /* GL_FLOAT_MAT2 */ + 489, /* GL_FLOAT_MAT3 */ + 493, /* GL_FLOAT_MAT4 */ + 1370, /* GL_SAMPLER_1D */ + 1372, /* GL_SAMPLER_2D */ + 1374, /* GL_SAMPLER_3D */ + 1375, /* GL_SAMPLER_CUBE */ + 1371, /* GL_SAMPLER_1D_SHADOW */ + 1373, /* GL_SAMPLER_2D_SHADOW */ + 487, /* GL_FLOAT_MAT2x3 */ + 488, /* GL_FLOAT_MAT2x4 */ + 491, /* GL_FLOAT_MAT3x2 */ + 492, /* GL_FLOAT_MAT3x4 */ + 495, /* GL_FLOAT_MAT4x2 */ + 496, /* GL_FLOAT_MAT4x3 */ + 345, /* GL_DELETE_STATUS */ + 246, /* GL_COMPILE_STATUS */ + 705, /* GL_LINK_STATUS */ + 1782, /* GL_VALIDATE_STATUS */ + 635, /* GL_INFO_LOG_LENGTH */ + 56, /* GL_ATTACHED_SHADERS */ 20, /* GL_ACTIVE_UNIFORMS */ 21, /* GL_ACTIVE_UNIFORM_MAX_LENGTH */ - 1394, /* GL_SHADER_SOURCE_LENGTH */ + 1412, /* GL_SHADER_SOURCE_LENGTH */ 15, /* GL_ACTIVE_ATTRIBUTES */ 16, /* GL_ACTIVE_ATTRIBUTE_MAX_LENGTH */ - 527, /* GL_FRAGMENT_SHADER_DERIVATIVE_HINT */ - 1397, /* GL_SHADING_LANGUAGE_VERSION */ - 316, /* GL_CURRENT_PROGRAM */ - 1073, /* GL_PALETTE4_RGB8_OES */ - 1075, /* GL_PALETTE4_RGBA8_OES */ - 1071, /* GL_PALETTE4_R5_G6_B5_OES */ - 1074, /* GL_PALETTE4_RGBA4_OES */ - 1072, /* GL_PALETTE4_RGB5_A1_OES */ - 1078, /* GL_PALETTE8_RGB8_OES */ - 1080, /* GL_PALETTE8_RGBA8_OES */ - 1076, /* GL_PALETTE8_R5_G6_B5_OES */ - 1079, /* GL_PALETTE8_RGBA4_OES */ - 1077, /* GL_PALETTE8_RGB5_A1_OES */ - 610, /* GL_IMPLEMENTATION_COLOR_READ_TYPE_OES */ - 609, /* GL_IMPLEMENTATION_COLOR_READ_FORMAT_OES */ - 1732, /* GL_UNSIGNED_NORMALIZED */ - 1578, /* GL_TEXTURE_1D_ARRAY_EXT */ - 1241, /* GL_PROXY_TEXTURE_1D_ARRAY_EXT */ - 1580, /* GL_TEXTURE_2D_ARRAY_EXT */ - 1244, /* GL_PROXY_TEXTURE_2D_ARRAY_EXT */ - 1586, /* GL_TEXTURE_BINDING_1D_ARRAY_EXT */ - 1588, /* GL_TEXTURE_BINDING_2D_ARRAY_EXT */ - 1449, /* GL_SRGB */ - 1450, /* GL_SRGB8 */ - 1452, /* GL_SRGB_ALPHA */ - 1451, /* GL_SRGB8_ALPHA8 */ - 1409, /* GL_SLUMINANCE_ALPHA */ - 1408, /* GL_SLUMINANCE8_ALPHA8 */ - 1406, /* GL_SLUMINANCE */ - 1407, /* GL_SLUMINANCE8 */ - 264, /* GL_COMPRESSED_SRGB */ - 265, /* GL_COMPRESSED_SRGB_ALPHA */ - 262, /* GL_COMPRESSED_SLUMINANCE */ - 263, /* GL_COMPRESSED_SLUMINANCE_ALPHA */ - 1138, /* GL_POINT_SPRITE_COORD_ORIGIN */ - 705, /* GL_LOWER_LEFT */ - 1744, /* GL_UPPER_LEFT */ - 1472, /* GL_STENCIL_BACK_REF */ - 1473, /* GL_STENCIL_BACK_VALUE_MASK */ - 1474, /* GL_STENCIL_BACK_WRITEMASK */ - 435, /* GL_DRAW_FRAMEBUFFER_BINDING_EXT */ - 1286, /* GL_RENDERBUFFER_BINDING_EXT */ - 1267, /* GL_READ_FRAMEBUFFER */ - 434, /* GL_DRAW_FRAMEBUFFER */ - 1268, /* GL_READ_FRAMEBUFFER_BINDING_EXT */ - 1296, /* GL_RENDERBUFFER_SAMPLES */ - 537, /* GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE */ - 535, /* GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME */ - 546, /* GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL */ - 542, /* GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE */ - 544, /* GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER */ - 549, /* GL_FRAMEBUFFER_COMPLETE */ - 553, /* GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT */ - 559, /* GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT */ - 557, /* GL_FRAMEBUFFER_INCOMPLETE_DUPLICATE_ATTACHMENT_EXT */ - 555, /* GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS_EXT */ - 558, /* GL_FRAMEBUFFER_INCOMPLETE_FORMATS_EXT */ - 556, /* GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER_EXT */ - 562, /* GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER_EXT */ - 565, /* GL_FRAMEBUFFER_UNSUPPORTED */ - 563, /* GL_FRAMEBUFFER_STATUS_ERROR_EXT */ - 839, /* GL_MAX_COLOR_ATTACHMENTS_EXT */ - 152, /* GL_COLOR_ATTACHMENT0 */ - 154, /* GL_COLOR_ATTACHMENT1 */ - 168, /* GL_COLOR_ATTACHMENT2 */ - 170, /* GL_COLOR_ATTACHMENT3 */ - 172, /* GL_COLOR_ATTACHMENT4 */ - 174, /* GL_COLOR_ATTACHMENT5 */ - 176, /* GL_COLOR_ATTACHMENT6 */ - 178, /* GL_COLOR_ATTACHMENT7 */ - 180, /* GL_COLOR_ATTACHMENT8 */ - 182, /* GL_COLOR_ATTACHMENT9 */ - 155, /* GL_COLOR_ATTACHMENT10 */ - 157, /* GL_COLOR_ATTACHMENT11 */ - 159, /* GL_COLOR_ATTACHMENT12 */ - 161, /* GL_COLOR_ATTACHMENT13 */ - 163, /* GL_COLOR_ATTACHMENT14 */ - 165, /* GL_COLOR_ATTACHMENT15 */ - 342, /* GL_DEPTH_ATTACHMENT */ - 1462, /* GL_STENCIL_ATTACHMENT */ - 528, /* GL_FRAMEBUFFER */ - 1284, /* GL_RENDERBUFFER */ - 1298, /* GL_RENDERBUFFER_WIDTH */ - 1291, /* GL_RENDERBUFFER_HEIGHT */ - 1293, /* GL_RENDERBUFFER_INTERNAL_FORMAT */ - 1485, /* GL_STENCIL_INDEX_EXT */ - 1482, /* GL_STENCIL_INDEX1_EXT */ - 1483, /* GL_STENCIL_INDEX4_EXT */ - 1484, /* GL_STENCIL_INDEX8_EXT */ - 1481, /* 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 */ - 561, /* GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE */ - 895, /* GL_MAX_SAMPLES */ - 1345, /* GL_RGBA_SNORM */ - 1341, /* GL_RGBA8_SNORM */ - 1402, /* GL_SIGNED_NORMALIZED */ - 461, /* GL_EVAL_BIT */ - 1265, /* GL_RASTER_POSITION_UNCLIPPED_IBM */ - 699, /* GL_LIST_BIT */ - 1594, /* GL_TEXTURE_BIT */ - 1376, /* GL_SCISSOR_BIT */ + 534, /* GL_FRAGMENT_SHADER_DERIVATIVE_HINT */ + 1415, /* GL_SHADING_LANGUAGE_VERSION */ + 322, /* GL_CURRENT_PROGRAM */ + 1089, /* GL_PALETTE4_RGB8_OES */ + 1091, /* GL_PALETTE4_RGBA8_OES */ + 1087, /* GL_PALETTE4_R5_G6_B5_OES */ + 1090, /* GL_PALETTE4_RGBA4_OES */ + 1088, /* GL_PALETTE4_RGB5_A1_OES */ + 1094, /* GL_PALETTE8_RGB8_OES */ + 1096, /* GL_PALETTE8_RGBA8_OES */ + 1092, /* GL_PALETTE8_R5_G6_B5_OES */ + 1095, /* GL_PALETTE8_RGBA4_OES */ + 1093, /* GL_PALETTE8_RGB5_A1_OES */ + 617, /* GL_IMPLEMENTATION_COLOR_READ_TYPE_OES */ + 616, /* GL_IMPLEMENTATION_COLOR_READ_FORMAT_OES */ + 1767, /* GL_UNSIGNED_NORMALIZED */ + 1606, /* GL_TEXTURE_1D_ARRAY_EXT */ + 1258, /* GL_PROXY_TEXTURE_1D_ARRAY_EXT */ + 1608, /* GL_TEXTURE_2D_ARRAY_EXT */ + 1261, /* GL_PROXY_TEXTURE_2D_ARRAY_EXT */ + 1614, /* GL_TEXTURE_BINDING_1D_ARRAY_EXT */ + 1616, /* GL_TEXTURE_BINDING_2D_ARRAY_EXT */ + 1468, /* GL_SRGB */ + 1469, /* GL_SRGB8 */ + 1471, /* GL_SRGB_ALPHA */ + 1470, /* GL_SRGB8_ALPHA8 */ + 1428, /* GL_SLUMINANCE_ALPHA */ + 1427, /* GL_SLUMINANCE8_ALPHA8 */ + 1425, /* GL_SLUMINANCE */ + 1426, /* GL_SLUMINANCE8 */ + 267, /* GL_COMPRESSED_SRGB */ + 268, /* GL_COMPRESSED_SRGB_ALPHA */ + 265, /* GL_COMPRESSED_SLUMINANCE */ + 266, /* GL_COMPRESSED_SLUMINANCE_ALPHA */ + 1154, /* GL_POINT_SPRITE_COORD_ORIGIN */ + 713, /* GL_LOWER_LEFT */ + 1779, /* GL_UPPER_LEFT */ + 1491, /* GL_STENCIL_BACK_REF */ + 1492, /* GL_STENCIL_BACK_VALUE_MASK */ + 1493, /* GL_STENCIL_BACK_WRITEMASK */ + 441, /* GL_DRAW_FRAMEBUFFER_BINDING_EXT */ + 1304, /* GL_RENDERBUFFER_BINDING_EXT */ + 1285, /* GL_READ_FRAMEBUFFER */ + 440, /* GL_DRAW_FRAMEBUFFER */ + 1286, /* GL_READ_FRAMEBUFFER_BINDING_EXT */ + 1314, /* GL_RENDERBUFFER_SAMPLES */ + 544, /* GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE */ + 542, /* GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME */ + 553, /* GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL */ + 549, /* GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE */ + 551, /* GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER */ + 556, /* GL_FRAMEBUFFER_COMPLETE */ + 560, /* GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT */ + 566, /* GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT */ + 564, /* GL_FRAMEBUFFER_INCOMPLETE_DUPLICATE_ATTACHMENT_EXT */ + 562, /* GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS_EXT */ + 565, /* GL_FRAMEBUFFER_INCOMPLETE_FORMATS_EXT */ + 563, /* GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER_EXT */ + 569, /* GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER_EXT */ + 572, /* GL_FRAMEBUFFER_UNSUPPORTED */ + 570, /* GL_FRAMEBUFFER_STATUS_ERROR_EXT */ + 853, /* GL_MAX_COLOR_ATTACHMENTS_EXT */ + 155, /* GL_COLOR_ATTACHMENT0 */ + 157, /* GL_COLOR_ATTACHMENT1 */ + 171, /* GL_COLOR_ATTACHMENT2 */ + 173, /* GL_COLOR_ATTACHMENT3 */ + 175, /* GL_COLOR_ATTACHMENT4 */ + 177, /* GL_COLOR_ATTACHMENT5 */ + 179, /* GL_COLOR_ATTACHMENT6 */ + 181, /* GL_COLOR_ATTACHMENT7 */ + 183, /* GL_COLOR_ATTACHMENT8 */ + 185, /* GL_COLOR_ATTACHMENT9 */ + 158, /* GL_COLOR_ATTACHMENT10 */ + 160, /* GL_COLOR_ATTACHMENT11 */ + 162, /* GL_COLOR_ATTACHMENT12 */ + 164, /* GL_COLOR_ATTACHMENT13 */ + 166, /* GL_COLOR_ATTACHMENT14 */ + 168, /* GL_COLOR_ATTACHMENT15 */ + 348, /* GL_DEPTH_ATTACHMENT */ + 1481, /* GL_STENCIL_ATTACHMENT */ + 535, /* GL_FRAMEBUFFER */ + 1302, /* GL_RENDERBUFFER */ + 1316, /* GL_RENDERBUFFER_WIDTH */ + 1309, /* GL_RENDERBUFFER_HEIGHT */ + 1311, /* GL_RENDERBUFFER_INTERNAL_FORMAT */ + 1504, /* GL_STENCIL_INDEX_EXT */ + 1501, /* GL_STENCIL_INDEX1_EXT */ + 1502, /* GL_STENCIL_INDEX4_EXT */ + 1503, /* GL_STENCIL_INDEX8_EXT */ + 1500, /* GL_STENCIL_INDEX16_EXT */ + 1313, /* GL_RENDERBUFFER_RED_SIZE */ + 1308, /* GL_RENDERBUFFER_GREEN_SIZE */ + 1305, /* GL_RENDERBUFFER_BLUE_SIZE */ + 1303, /* GL_RENDERBUFFER_ALPHA_SIZE */ + 1306, /* GL_RENDERBUFFER_DEPTH_SIZE */ + 1315, /* GL_RENDERBUFFER_STENCIL_SIZE */ + 568, /* GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE */ + 909, /* GL_MAX_SAMPLES */ + 1272, /* GL_QUADS_FOLLOW_PROVOKING_VERTEX_CONVENTION_EXT */ + 482, /* GL_FIRST_VERTEX_CONVENTION_EXT */ + 665, /* GL_LAST_VERTEX_CONVENTION_EXT */ + 1251, /* GL_PROVOKING_VERTEX_EXT */ + 302, /* GL_COPY_READ_BUFFER */ + 303, /* GL_COPY_WRITE_BUFFER */ + 1363, /* GL_RGBA_SNORM */ + 1359, /* GL_RGBA8_SNORM */ + 1421, /* GL_SIGNED_NORMALIZED */ + 910, /* GL_MAX_SERVER_WAIT_TIMEOUT */ + 1039, /* GL_OBJECT_TYPE */ + 1525, /* GL_SYNC_CONDITION */ + 1530, /* GL_SYNC_STATUS */ + 1527, /* GL_SYNC_FLAGS */ + 1526, /* GL_SYNC_FENCE */ + 1529, /* GL_SYNC_GPU_COMMANDS_COMPLETE */ + 1756, /* GL_UNSIGNALED */ + 1420, /* GL_SIGNALED */ + 46, /* GL_ALREADY_SIGNALED */ + 1727, /* GL_TIMEOUT_EXPIRED */ + 270, /* GL_CONDITION_SATISFIED */ + 1839, /* GL_WAIT_FAILED */ + 467, /* GL_EVAL_BIT */ + 1283, /* GL_RASTER_POSITION_UNCLIPPED_IBM */ + 707, /* GL_LIST_BIT */ + 1622, /* GL_TEXTURE_BIT */ + 1394, /* GL_SCISSOR_BIT */ 29, /* GL_ALL_ATTRIB_BITS */ - 980, /* GL_MULTISAMPLE_BIT */ + 995, /* GL_MULTISAMPLE_BIT */ 30, /* GL_ALL_CLIENT_ATTRIB_BITS */ + 1728, /* GL_TIMEOUT_IGNORED */ }; typedef int (*cfunc)(const void *, const void *); diff --git a/src/mesa/main/extensions.c b/src/mesa/main/extensions.c index ebbe28acf4..e3070b1547 100644 --- a/src/mesa/main/extensions.c +++ b/src/mesa/main/extensions.c @@ -1,8 +1,9 @@ /* * Mesa 3-D graphics library - * Version: 7.3 + * Version: 7.6 * * 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"), @@ -44,6 +45,7 @@ static const struct { const char *name; int flag_offset; } default_extensions[] = { + { OFF, "GL_ARB_copy_buffer", F(ARB_copy_buffer) }, { OFF, "GL_ARB_depth_texture", F(ARB_depth_texture) }, { ON, "GL_ARB_draw_buffers", F(ARB_draw_buffers) }, { OFF, "GL_ARB_fragment_program", F(ARB_fragment_program) }, @@ -52,17 +54,20 @@ static const struct { { OFF, "GL_ARB_framebuffer_object", F(ARB_framebuffer_object) }, { OFF, "GL_ARB_half_float_pixel", F(ARB_half_float_pixel) }, { OFF, "GL_ARB_imaging", F(ARB_imaging) }, + { OFF, "GL_ARB_map_buffer_range", F(ARB_map_buffer_range) }, { ON, "GL_ARB_multisample", F(ARB_multisample) }, { OFF, "GL_ARB_multitexture", F(ARB_multitexture) }, { OFF, "GL_ARB_occlusion_query", F(ARB_occlusion_query) }, { OFF, "GL_ARB_pixel_buffer_object", F(EXT_pixel_buffer_object) }, { OFF, "GL_ARB_point_parameters", F(EXT_point_parameters) }, { OFF, "GL_ARB_point_sprite", F(ARB_point_sprite) }, + { OFF, "GL_ARB_seamless_cube_map", F(ARB_seamless_cube_map) }, { OFF, "GL_ARB_shader_objects", F(ARB_shader_objects) }, { OFF, "GL_ARB_shading_language_100", F(ARB_shading_language_100) }, { OFF, "GL_ARB_shading_language_120", F(ARB_shading_language_120) }, { OFF, "GL_ARB_shadow", F(ARB_shadow) }, { OFF, "GL_ARB_shadow_ambient", F(ARB_shadow_ambient) }, + { OFF, "GL_ARB_sync", F(ARB_sync) }, { OFF, "GL_ARB_texture_border_clamp", F(ARB_texture_border_clamp) }, { ON, "GL_ARB_texture_compression", F(ARB_texture_compression) }, { OFF, "GL_ARB_texture_cube_map", F(ARB_texture_cube_map) }, @@ -75,6 +80,8 @@ static const struct { { OFF, "GL_ARB_texture_non_power_of_two", F(ARB_texture_non_power_of_two)}, { OFF, "GL_ARB_texture_rectangle", F(NV_texture_rectangle) }, { ON, "GL_ARB_transpose_matrix", F(ARB_transpose_matrix) }, + { OFF, "GL_ARB_vertex_array_bgra", F(EXT_vertex_array_bgra) }, + { OFF, "GL_ARB_vertex_array_object", F(ARB_vertex_array_object) }, { ON, "GL_ARB_vertex_buffer_object", F(ARB_vertex_buffer_object) }, { OFF, "GL_ARB_vertex_program", F(ARB_vertex_program) }, { OFF, "GL_ARB_vertex_shader", F(ARB_vertex_shader) }, @@ -106,6 +113,7 @@ static const struct { { OFF, "GL_EXT_pixel_buffer_object", F(EXT_pixel_buffer_object) }, { OFF, "GL_EXT_point_parameters", F(EXT_point_parameters) }, { ON, "GL_EXT_polygon_offset", F(EXT_polygon_offset) }, + { OFF, "GL_EXT_provoking_vertex", F(EXT_provoking_vertex) }, { ON, "GL_EXT_rescale_normal", F(EXT_rescale_normal) }, { OFF, "GL_EXT_secondary_color", F(EXT_secondary_color) }, { ON, "GL_EXT_separate_specular_color", F(EXT_separate_specular_color) }, @@ -183,6 +191,7 @@ static const struct { void _mesa_enable_sw_extensions(GLcontext *ctx) { + ctx->Extensions.ARB_copy_buffer = GL_TRUE; ctx->Extensions.ARB_depth_texture = GL_TRUE; /*ctx->Extensions.ARB_draw_buffers = GL_TRUE;*/ #if FEATURE_ARB_fragment_program @@ -197,6 +206,7 @@ _mesa_enable_sw_extensions(GLcontext *ctx) #endif ctx->Extensions.ARB_half_float_pixel = GL_TRUE; ctx->Extensions.ARB_imaging = GL_TRUE; + ctx->Extensions.ARB_map_buffer_range = GL_TRUE; ctx->Extensions.ARB_multitexture = GL_TRUE; #if FEATURE_ARB_occlusion_query ctx->Extensions.ARB_occlusion_query = GL_TRUE; @@ -221,6 +231,7 @@ _mesa_enable_sw_extensions(GLcontext *ctx) /*ctx->Extensions.ARB_texture_float = GL_TRUE;*/ ctx->Extensions.ARB_texture_mirrored_repeat = GL_TRUE; ctx->Extensions.ARB_texture_non_power_of_two = GL_TRUE; + ctx->Extensions.ARB_vertex_array_object = GL_TRUE; #if FEATURE_ARB_vertex_program ctx->Extensions.ARB_vertex_program = GL_TRUE; #endif @@ -230,6 +241,9 @@ _mesa_enable_sw_extensions(GLcontext *ctx) #if FEATURE_ARB_vertex_buffer_object /*ctx->Extensions.ARB_vertex_buffer_object = GL_TRUE;*/ #endif +#if FEATURE_ARB_sync + ctx->Extensions.ARB_sync = GL_TRUE; +#endif ctx->Extensions.APPLE_vertex_array_object = GL_TRUE; ctx->Extensions.ATI_envmap_bumpmap = GL_TRUE; #if FEATURE_ATI_fragment_shader @@ -261,6 +275,7 @@ _mesa_enable_sw_extensions(GLcontext *ctx) ctx->Extensions.EXT_pixel_buffer_object = GL_TRUE; #endif ctx->Extensions.EXT_point_parameters = GL_TRUE; + ctx->Extensions.EXT_provoking_vertex = GL_TRUE; ctx->Extensions.EXT_shadow_funcs = GL_TRUE; ctx->Extensions.EXT_secondary_color = GL_TRUE; ctx->Extensions.EXT_shared_texture_palette = GL_TRUE; @@ -441,8 +456,9 @@ _mesa_enable_2_1_extensions(GLcontext *ctx) /** * Either enable or disable the named extension. + * \return GL_TRUE for success, GL_FALSE if invalid extension name */ -static void +static GLboolean set_extension( GLcontext *ctx, const char *name, GLboolean state ) { GLboolean *base = (GLboolean *) &ctx->Extensions; @@ -451,7 +467,7 @@ set_extension( GLcontext *ctx, const char *name, GLboolean state ) if (ctx->Extensions.String) { /* The string was already queried - can't change it now! */ _mesa_problem(ctx, "Trying to enable/disable extension after glGetString(GL_EXTENSIONS): %s", name); - return; + return GL_FALSE; } for (i = 0 ; i < Elements(default_extensions) ; i++) { @@ -460,10 +476,10 @@ set_extension( GLcontext *ctx, const char *name, GLboolean state ) GLboolean *enabled = base + default_extensions[i].flag_offset; *enabled = state; } - return; + return GL_TRUE; } } - _mesa_problem(ctx, "Trying to enable unknown extension: %s", name); + return GL_FALSE; } @@ -474,7 +490,8 @@ set_extension( GLcontext *ctx, const char *name, GLboolean state ) void _mesa_enable_extension( GLcontext *ctx, const char *name ) { - set_extension(ctx, name, GL_TRUE); + if (!set_extension(ctx, name, GL_TRUE)) + _mesa_problem(ctx, "Trying to enable unknown extension: %s", name); } @@ -485,7 +502,8 @@ _mesa_enable_extension( GLcontext *ctx, const char *name ) void _mesa_disable_extension( GLcontext *ctx, const char *name ) { - set_extension(ctx, name, GL_FALSE); + if (!set_extension(ctx, name, GL_FALSE)) + _mesa_problem(ctx, "Trying to disable unknown extension: %s", name); } @@ -510,6 +528,80 @@ _mesa_extension_is_enabled( GLcontext *ctx, const char *name ) /** + * Append string 'b' onto string 'a'. Free 'a' and return new string. + */ +static char * +append(const char *a, const char *b) +{ + const GLuint aLen = a ? _mesa_strlen(a) : 0; + const GLuint bLen = b ? _mesa_strlen(b) : 0; + char *s = _mesa_calloc(aLen + bLen + 1); + if (s) { + if (a) + _mesa_memcpy(s, a, aLen); + if (b) + _mesa_memcpy(s + aLen, b, bLen); + s[aLen + bLen] = '\0'; + } + if (a) + _mesa_free((void *) a); + return s; +} + + +/** + * Check the MESA_EXTENSION_OVERRIDE env var. + * For extension names that are recognized, turn them on. For extension + * names that are recognized and prefixed with '-', turn them off. + * Return a string of the unknown/leftover names. + */ +static const char * +get_extension_override( GLcontext *ctx ) +{ + const char *envExt = _mesa_getenv("MESA_EXTENSION_OVERRIDE"); + char *extraExt = NULL; + char ext[1000]; + GLuint extLen = 0; + GLuint i; + GLboolean disableExt = GL_FALSE; + + if (!envExt) + return NULL; + + for (i = 0; ; i++) { + if (envExt[i] == '\0' || envExt[i] == ' ') { + /* terminate/process 'ext' if extLen > 0 */ + if (extLen > 0) { + assert(extLen < sizeof(ext)); + /* enable extension named by 'ext' */ + ext[extLen] = 0; + if (!set_extension(ctx, ext, !disableExt)) { + /* unknown extension name, append it to extraExt */ + if (extraExt) { + extraExt = append(extraExt, " "); + } + extraExt = append(extraExt, ext); + } + extLen = 0; + disableExt = GL_FALSE; + } + if (envExt[i] == '\0') + break; + } + else if (envExt[i] == '-') { + disableExt = GL_TRUE; + } + else { + /* accumulate this non-space character */ + ext[extLen++] = envExt[i]; + } + } + + return extraExt; +} + + +/** * Run through the default_extensions array above and set the * ctx->Extensions.ARB/EXT_* flags accordingly. * To be called during context initialization. @@ -537,8 +629,9 @@ GLubyte * _mesa_make_extension_string( GLcontext *ctx ) { const GLboolean *base = (const GLboolean *) &ctx->Extensions; + const char *extraExt = get_extension_override(ctx); GLuint extStrLen = 0; - GLubyte *s; + char *s; GLuint i; /* first, compute length of the extension string */ @@ -548,7 +641,14 @@ _mesa_make_extension_string( GLcontext *ctx ) extStrLen += (GLuint)_mesa_strlen(default_extensions[i].name) + 1; } } - s = (GLubyte *) _mesa_malloc(extStrLen); + + if (extraExt) + extStrLen += _mesa_strlen(extraExt) + 1; /* +1 for space */ + + /* allocate the extension string */ + s = (char *) _mesa_malloc(extStrLen); + if (!s) + return NULL; /* second, build the extension string */ extStrLen = 0; @@ -558,13 +658,18 @@ _mesa_make_extension_string( GLcontext *ctx ) GLuint len = (GLuint)_mesa_strlen(default_extensions[i].name); _mesa_memcpy(s + extStrLen, default_extensions[i].name, len); extStrLen += len; - s[extStrLen] = (GLubyte) ' '; + s[extStrLen] = ' '; extStrLen++; } } ASSERT(extStrLen > 0); - s[extStrLen - 1] = 0; + s[extStrLen - 1] = 0; /* -1 to overwrite trailing the ' ' */ - return s; + if (extraExt) { + s = append(s, " "); + s = append(s, extraExt); + } + + return (GLubyte *) s; } diff --git a/src/mesa/main/ffvertex_prog.c b/src/mesa/main/ffvertex_prog.c index 8e21a27f89..356476e35a 100644 --- a/src/mesa/main/ffvertex_prog.c +++ b/src/mesa/main/ffvertex_prog.c @@ -46,6 +46,9 @@ #include "shader/prog_statevars.h" +/** Max of number of lights and texture coord units */ +#define NUM_UNITS MAX2(MAX_TEXTURE_COORD_UNITS, MAX_LIGHTS) + struct state_key { unsigned light_color_material_mask:12; unsigned light_global_enabled:1; @@ -77,7 +80,7 @@ struct state_key { unsigned texgen_mode1:4; unsigned texgen_mode2:4; unsigned texgen_mode3:4; - } unit[8]; + } unit[NUM_UNITS]; }; diff --git a/src/mesa/main/framebuffer.c b/src/mesa/main/framebuffer.c index 5a13c88a7a..dc79b8ca61 100644 --- a/src/mesa/main/framebuffer.c +++ b/src/mesa/main/framebuffer.c @@ -817,7 +817,7 @@ _mesa_update_framebuffer(GLcontext *ctx) /** * Check if the renderbuffer for a read operation (glReadPixels, glCopyPixels, - * glCopyTex[Sub]Image, etc. exists. + * glCopyTex[Sub]Image, etc) exists. * \param format a basic image format such as GL_RGB, GL_RGBA, GL_ALPHA, * GL_DEPTH_COMPONENT, etc. or GL_COLOR, GL_DEPTH, GL_STENCIL. * \return GL_TRUE if buffer exists, GL_FALSE otherwise @@ -825,8 +825,12 @@ _mesa_update_framebuffer(GLcontext *ctx) GLboolean _mesa_source_buffer_exists(GLcontext *ctx, GLenum format) { - const struct gl_renderbuffer_attachment *att - = ctx->ReadBuffer->Attachment; + const struct gl_renderbuffer_attachment *att = ctx->ReadBuffer->Attachment; + + /* If we don't know the framebuffer status, update it now */ + if (ctx->ReadBuffer->_Status == 0) { + _mesa_test_framebuffer_completeness(ctx, ctx->ReadBuffer); + } if (ctx->ReadBuffer->_Status != GL_FRAMEBUFFER_COMPLETE_EXT) { return GL_FALSE; @@ -850,10 +854,8 @@ _mesa_source_buffer_exists(GLcontext *ctx, GLenum format) if (ctx->ReadBuffer->_ColorReadBuffer == NULL) { return GL_FALSE; } - /* XXX enable this post 6.5 release: ASSERT(ctx->ReadBuffer->_ColorReadBuffer->RedBits > 0 || ctx->ReadBuffer->_ColorReadBuffer->IndexBits > 0); - */ break; case GL_DEPTH: case GL_DEPTH_COMPONENT: @@ -891,13 +893,17 @@ _mesa_source_buffer_exists(GLcontext *ctx, GLenum format) /** * As above, but for drawing operations. - * XXX code do some code merging w/ above function. + * XXX could do some code merging w/ above function. */ GLboolean _mesa_dest_buffer_exists(GLcontext *ctx, GLenum format) { - const struct gl_renderbuffer_attachment *att - = ctx->ReadBuffer->Attachment; + const struct gl_renderbuffer_attachment *att = ctx->DrawBuffer->Attachment; + + /* If we don't know the framebuffer status, update it now */ + if (ctx->DrawBuffer->_Status == 0) { + _mesa_test_framebuffer_completeness(ctx, ctx->DrawBuffer); + } if (ctx->DrawBuffer->_Status != GL_FRAMEBUFFER_COMPLETE_EXT) { return GL_FALSE; @@ -918,7 +924,7 @@ _mesa_dest_buffer_exists(GLcontext *ctx, GLenum format) case GL_BGRA: case GL_ABGR_EXT: case GL_COLOR_INDEX: - /* nothing special */ + /* Nothing special since GL_DRAW_BUFFER could be GL_NONE. */ /* Could assert that colorbuffer has RedBits > 0 */ break; case GL_DEPTH: @@ -945,7 +951,7 @@ _mesa_dest_buffer_exists(GLcontext *ctx, GLenum format) break; default: _mesa_problem(ctx, - "Unexpected format 0x%x in _mesa_source_buffer_exists", + "Unexpected format 0x%x in _mesa_dest_buffer_exists", format); return GL_FALSE; } diff --git a/src/mesa/main/get.c b/src/mesa/main/get.c index 1ed6fc3383..477ed01030 100644 --- a/src/mesa/main/get.c +++ b/src/mesa/main/get.c @@ -19,9 +19,15 @@ #define INT_TO_BOOLEAN(I) ( (I) ? GL_TRUE : GL_FALSE ) +#define INT64_TO_BOOLEAN(I) ( (I) ? GL_TRUE : GL_FALSE ) +#define INT64_TO_INT(I) ( (GLint)((I > INT_MAX) ? INT_MAX : ((I < INT_MIN) ? INT_MIN : (I))) ) + #define BOOLEAN_TO_INT(B) ( (GLint) (B) ) +#define BOOLEAN_TO_INT64(B) ( (GLint64) (B) ) #define BOOLEAN_TO_FLOAT(B) ( (B) ? 1.0F : 0.0F ) +#define ENUM_TO_INT64(E) ( (GLint64) (E) ) + /* * Check if named extension is enabled, if not generate error and return. @@ -276,6 +282,7 @@ _mesa_GetBooleanv( GLenum pname, GLboolean *params ) case GL_CURRENT_TEXTURE_COORDS: { const GLuint texUnit = ctx->Texture.CurrentUnit; + FLUSH_CURRENT(ctx, 0); params[0] = FLOAT_TO_BOOLEAN(ctx->Current.Attrib[VERT_ATTRIB_TEX0 + texUnit][0]); params[1] = FLOAT_TO_BOOLEAN(ctx->Current.Attrib[VERT_ATTRIB_TEX0 + texUnit][1]); params[2] = FLOAT_TO_BOOLEAN(ctx->Current.Attrib[VERT_ATTRIB_TEX0 + texUnit][2]); @@ -1835,6 +1842,14 @@ _mesa_GetBooleanv( GLenum pname, GLboolean *params ) CHECK_EXT1(EXT_framebuffer_blit, "GetBooleanv"); params[0] = INT_TO_BOOLEAN(ctx->ReadBuffer->Name); break; + case GL_PROVOKING_VERTEX_EXT: + CHECK_EXT1(EXT_provoking_vertex, "GetBooleanv"); + params[0] = ctx->Light.ProvokingVertex; + break; + case GL_QUADS_FOLLOW_PROVOKING_VERTEX_CONVENTION_EXT: + CHECK_EXT1(EXT_provoking_vertex, "GetBooleanv"); + params[0] = ctx->Const.QuadsFollowProvokingVertexConvention; + break; case GL_MAX_FRAGMENT_UNIFORM_COMPONENTS_ARB: CHECK_EXT1(ARB_fragment_shader, "GetBooleanv"); params[0] = INT_TO_BOOLEAN(ctx->Const.FragmentProgram.MaxUniformComponents); @@ -1871,6 +1886,14 @@ _mesa_GetBooleanv( GLenum pname, GLboolean *params ) CHECK_EXT1(APPLE_vertex_array_object, "GetBooleanv"); params[0] = INT_TO_BOOLEAN(ctx->Array.ArrayObj->Name); break; + case GL_TEXTURE_CUBE_MAP_SEAMLESS: + CHECK_EXT1(ARB_seamless_cube_map, "GetBooleanv"); + params[0] = ctx->Texture.CubeMapSeamless; + break; + case GL_MAX_SERVER_WAIT_TIMEOUT: + CHECK_EXT1(ARB_sync, "GetBooleanv"); + params[0] = INT64_TO_BOOLEAN(ctx->Const.MaxServerWaitTimeout); + break; default: _mesa_error(ctx, GL_INVALID_ENUM, "glGetBooleanv(pname=0x%x)", pname); } @@ -2090,6 +2113,7 @@ _mesa_GetFloatv( GLenum pname, GLfloat *params ) case GL_CURRENT_TEXTURE_COORDS: { const GLuint texUnit = ctx->Texture.CurrentUnit; + FLUSH_CURRENT(ctx, 0); params[0] = ctx->Current.Attrib[VERT_ATTRIB_TEX0 + texUnit][0]; params[1] = ctx->Current.Attrib[VERT_ATTRIB_TEX0 + texUnit][1]; params[2] = ctx->Current.Attrib[VERT_ATTRIB_TEX0 + texUnit][2]; @@ -3649,6 +3673,14 @@ _mesa_GetFloatv( GLenum pname, GLfloat *params ) CHECK_EXT1(EXT_framebuffer_blit, "GetFloatv"); params[0] = (GLfloat)(ctx->ReadBuffer->Name); break; + case GL_PROVOKING_VERTEX_EXT: + CHECK_EXT1(EXT_provoking_vertex, "GetFloatv"); + params[0] = BOOLEAN_TO_FLOAT(ctx->Light.ProvokingVertex); + break; + case GL_QUADS_FOLLOW_PROVOKING_VERTEX_CONVENTION_EXT: + CHECK_EXT1(EXT_provoking_vertex, "GetFloatv"); + params[0] = BOOLEAN_TO_FLOAT(ctx->Const.QuadsFollowProvokingVertexConvention); + break; case GL_MAX_FRAGMENT_UNIFORM_COMPONENTS_ARB: CHECK_EXT1(ARB_fragment_shader, "GetFloatv"); params[0] = (GLfloat)(ctx->Const.FragmentProgram.MaxUniformComponents); @@ -3685,6 +3717,14 @@ _mesa_GetFloatv( GLenum pname, GLfloat *params ) CHECK_EXT1(APPLE_vertex_array_object, "GetFloatv"); params[0] = (GLfloat)(ctx->Array.ArrayObj->Name); break; + case GL_TEXTURE_CUBE_MAP_SEAMLESS: + CHECK_EXT1(ARB_seamless_cube_map, "GetFloatv"); + params[0] = BOOLEAN_TO_FLOAT(ctx->Texture.CubeMapSeamless); + break; + case GL_MAX_SERVER_WAIT_TIMEOUT: + CHECK_EXT1(ARB_sync, "GetFloatv"); + params[0] = (GLfloat)(ctx->Const.MaxServerWaitTimeout); + break; default: _mesa_error(ctx, GL_INVALID_ENUM, "glGetFloatv(pname=0x%x)", pname); } @@ -3904,6 +3944,7 @@ _mesa_GetIntegerv( GLenum pname, GLint *params ) case GL_CURRENT_TEXTURE_COORDS: { const GLuint texUnit = ctx->Texture.CurrentUnit; + FLUSH_CURRENT(ctx, 0); params[0] = IROUND(ctx->Current.Attrib[VERT_ATTRIB_TEX0 + texUnit][0]); params[1] = IROUND(ctx->Current.Attrib[VERT_ATTRIB_TEX0 + texUnit][1]); params[2] = IROUND(ctx->Current.Attrib[VERT_ATTRIB_TEX0 + texUnit][2]); @@ -5463,6 +5504,14 @@ _mesa_GetIntegerv( GLenum pname, GLint *params ) CHECK_EXT1(EXT_framebuffer_blit, "GetIntegerv"); params[0] = ctx->ReadBuffer->Name; break; + case GL_PROVOKING_VERTEX_EXT: + CHECK_EXT1(EXT_provoking_vertex, "GetIntegerv"); + params[0] = BOOLEAN_TO_INT(ctx->Light.ProvokingVertex); + break; + case GL_QUADS_FOLLOW_PROVOKING_VERTEX_CONVENTION_EXT: + CHECK_EXT1(EXT_provoking_vertex, "GetIntegerv"); + params[0] = BOOLEAN_TO_INT(ctx->Const.QuadsFollowProvokingVertexConvention); + break; case GL_MAX_FRAGMENT_UNIFORM_COMPONENTS_ARB: CHECK_EXT1(ARB_fragment_shader, "GetIntegerv"); params[0] = ctx->Const.FragmentProgram.MaxUniformComponents; @@ -5499,11 +5548,1852 @@ _mesa_GetIntegerv( GLenum pname, GLint *params ) CHECK_EXT1(APPLE_vertex_array_object, "GetIntegerv"); params[0] = ctx->Array.ArrayObj->Name; break; + case GL_TEXTURE_CUBE_MAP_SEAMLESS: + CHECK_EXT1(ARB_seamless_cube_map, "GetIntegerv"); + params[0] = BOOLEAN_TO_INT(ctx->Texture.CubeMapSeamless); + break; + case GL_MAX_SERVER_WAIT_TIMEOUT: + CHECK_EXT1(ARB_sync, "GetIntegerv"); + params[0] = INT64_TO_INT(ctx->Const.MaxServerWaitTimeout); + break; default: _mesa_error(ctx, GL_INVALID_ENUM, "glGetIntegerv(pname=0x%x)", pname); } } +#if FEATURE_ARB_sync +void GLAPIENTRY +_mesa_GetInteger64v( GLenum pname, GLint64 *params ) +{ + GET_CURRENT_CONTEXT(ctx); + ASSERT_OUTSIDE_BEGIN_END(ctx); + + if (!params) + return; + + if (ctx->NewState) + _mesa_update_state(ctx); + + if (ctx->Driver.GetInteger64v && + ctx->Driver.GetInteger64v(ctx, pname, params)) + return; + + switch (pname) { + case GL_ACCUM_RED_BITS: + params[0] = ctx->DrawBuffer->Visual.accumRedBits; + break; + case GL_ACCUM_GREEN_BITS: + params[0] = ctx->DrawBuffer->Visual.accumGreenBits; + break; + case GL_ACCUM_BLUE_BITS: + params[0] = ctx->DrawBuffer->Visual.accumBlueBits; + break; + case GL_ACCUM_ALPHA_BITS: + params[0] = ctx->DrawBuffer->Visual.accumAlphaBits; + break; + case GL_ACCUM_CLEAR_VALUE: + params[0] = FLOAT_TO_INT64(ctx->Accum.ClearColor[0]); + params[1] = FLOAT_TO_INT64(ctx->Accum.ClearColor[1]); + params[2] = FLOAT_TO_INT64(ctx->Accum.ClearColor[2]); + params[3] = FLOAT_TO_INT64(ctx->Accum.ClearColor[3]); + break; + case GL_ALPHA_BIAS: + params[0] = IROUND64(ctx->Pixel.AlphaBias); + break; + case GL_ALPHA_BITS: + params[0] = ctx->DrawBuffer->Visual.alphaBits; + break; + case GL_ALPHA_SCALE: + params[0] = IROUND64(ctx->Pixel.AlphaScale); + break; + case GL_ALPHA_TEST: + params[0] = BOOLEAN_TO_INT64(ctx->Color.AlphaEnabled); + break; + case GL_ALPHA_TEST_FUNC: + params[0] = ENUM_TO_INT64(ctx->Color.AlphaFunc); + break; + case GL_ALPHA_TEST_REF: + params[0] = FLOAT_TO_INT64(ctx->Color.AlphaRef); + break; + case GL_ATTRIB_STACK_DEPTH: + params[0] = ctx->AttribStackDepth; + break; + case GL_AUTO_NORMAL: + params[0] = BOOLEAN_TO_INT64(ctx->Eval.AutoNormal); + break; + case GL_AUX_BUFFERS: + params[0] = ctx->DrawBuffer->Visual.numAuxBuffers; + break; + case GL_BLEND: + params[0] = BOOLEAN_TO_INT64(ctx->Color.BlendEnabled); + break; + case GL_BLEND_DST: + params[0] = ENUM_TO_INT64(ctx->Color.BlendDstRGB); + break; + case GL_BLEND_SRC: + params[0] = ENUM_TO_INT64(ctx->Color.BlendSrcRGB); + break; + case GL_BLEND_SRC_RGB_EXT: + params[0] = ENUM_TO_INT64(ctx->Color.BlendSrcRGB); + break; + case GL_BLEND_DST_RGB_EXT: + params[0] = ENUM_TO_INT64(ctx->Color.BlendDstRGB); + break; + case GL_BLEND_SRC_ALPHA_EXT: + params[0] = ENUM_TO_INT64(ctx->Color.BlendSrcA); + break; + case GL_BLEND_DST_ALPHA_EXT: + params[0] = ENUM_TO_INT64(ctx->Color.BlendDstA); + break; + case GL_BLEND_EQUATION: + params[0] = ENUM_TO_INT64(ctx->Color.BlendEquationRGB ); + break; + case GL_BLEND_EQUATION_ALPHA_EXT: + params[0] = ENUM_TO_INT64(ctx->Color.BlendEquationA ); + break; + case GL_BLEND_COLOR_EXT: + params[0] = FLOAT_TO_INT64(ctx->Color.BlendColor[0]); + params[1] = FLOAT_TO_INT64(ctx->Color.BlendColor[1]); + params[2] = FLOAT_TO_INT64(ctx->Color.BlendColor[2]); + params[3] = FLOAT_TO_INT64(ctx->Color.BlendColor[3]); + break; + case GL_BLUE_BIAS: + params[0] = IROUND64(ctx->Pixel.BlueBias); + break; + case GL_BLUE_BITS: + params[0] = ctx->DrawBuffer->Visual.blueBits; + break; + case GL_BLUE_SCALE: + params[0] = IROUND64(ctx->Pixel.BlueScale); + break; + case GL_CLIENT_ATTRIB_STACK_DEPTH: + params[0] = ctx->ClientAttribStackDepth; + break; + case GL_CLIP_PLANE0: + params[0] = BOOLEAN_TO_INT64((ctx->Transform.ClipPlanesEnabled >> 0) & 1); + break; + case GL_CLIP_PLANE1: + params[0] = BOOLEAN_TO_INT64((ctx->Transform.ClipPlanesEnabled >> 1) & 1); + break; + case GL_CLIP_PLANE2: + params[0] = BOOLEAN_TO_INT64((ctx->Transform.ClipPlanesEnabled >> 2) & 1); + break; + case GL_CLIP_PLANE3: + params[0] = BOOLEAN_TO_INT64((ctx->Transform.ClipPlanesEnabled >> 3) & 1); + break; + case GL_CLIP_PLANE4: + params[0] = BOOLEAN_TO_INT64((ctx->Transform.ClipPlanesEnabled >> 4) & 1); + break; + case GL_CLIP_PLANE5: + params[0] = BOOLEAN_TO_INT64((ctx->Transform.ClipPlanesEnabled >> 5) & 1); + break; + case GL_COLOR_CLEAR_VALUE: + params[0] = FLOAT_TO_INT64(ctx->Color.ClearColor[0]); + params[1] = FLOAT_TO_INT64(ctx->Color.ClearColor[1]); + params[2] = FLOAT_TO_INT64(ctx->Color.ClearColor[2]); + params[3] = FLOAT_TO_INT64(ctx->Color.ClearColor[3]); + break; + case GL_COLOR_MATERIAL: + params[0] = BOOLEAN_TO_INT64(ctx->Light.ColorMaterialEnabled); + break; + case GL_COLOR_MATERIAL_FACE: + params[0] = ENUM_TO_INT64(ctx->Light.ColorMaterialFace); + break; + case GL_COLOR_MATERIAL_PARAMETER: + params[0] = ENUM_TO_INT64(ctx->Light.ColorMaterialMode); + break; + case GL_COLOR_WRITEMASK: + params[0] = ctx->Color.ColorMask[RCOMP] ? 1 : 0; + params[1] = ctx->Color.ColorMask[GCOMP] ? 1 : 0; + params[2] = ctx->Color.ColorMask[BCOMP] ? 1 : 0; + params[3] = ctx->Color.ColorMask[ACOMP] ? 1 : 0; + break; + case GL_CULL_FACE: + params[0] = BOOLEAN_TO_INT64(ctx->Polygon.CullFlag); + break; + case GL_CULL_FACE_MODE: + params[0] = ENUM_TO_INT64(ctx->Polygon.CullFaceMode); + break; + case GL_CURRENT_COLOR: + { + FLUSH_CURRENT(ctx, 0); + params[0] = FLOAT_TO_INT64(ctx->Current.Attrib[VERT_ATTRIB_COLOR0][0]); + params[1] = FLOAT_TO_INT64(ctx->Current.Attrib[VERT_ATTRIB_COLOR0][1]); + params[2] = FLOAT_TO_INT64(ctx->Current.Attrib[VERT_ATTRIB_COLOR0][2]); + params[3] = FLOAT_TO_INT64(ctx->Current.Attrib[VERT_ATTRIB_COLOR0][3]); + } + break; + case GL_CURRENT_INDEX: + { + FLUSH_CURRENT(ctx, 0); + params[0] = IROUND64(ctx->Current.Attrib[VERT_ATTRIB_COLOR_INDEX][0]); + } + break; + case GL_CURRENT_NORMAL: + { + FLUSH_CURRENT(ctx, 0); + params[0] = FLOAT_TO_INT64(ctx->Current.Attrib[VERT_ATTRIB_NORMAL][0]); + params[1] = FLOAT_TO_INT64(ctx->Current.Attrib[VERT_ATTRIB_NORMAL][1]); + params[2] = FLOAT_TO_INT64(ctx->Current.Attrib[VERT_ATTRIB_NORMAL][2]); + } + break; + case GL_CURRENT_RASTER_COLOR: + params[0] = FLOAT_TO_INT64(ctx->Current.RasterColor[0]); + params[1] = FLOAT_TO_INT64(ctx->Current.RasterColor[1]); + params[2] = FLOAT_TO_INT64(ctx->Current.RasterColor[2]); + params[3] = FLOAT_TO_INT64(ctx->Current.RasterColor[3]); + break; + case GL_CURRENT_RASTER_DISTANCE: + params[0] = IROUND64(ctx->Current.RasterDistance); + break; + case GL_CURRENT_RASTER_INDEX: + params[0] = IROUND64(ctx->Current.RasterIndex); + break; + case GL_CURRENT_RASTER_POSITION: + params[0] = IROUND64(ctx->Current.RasterPos[0]); + params[1] = IROUND64(ctx->Current.RasterPos[1]); + params[2] = IROUND64(ctx->Current.RasterPos[2]); + params[3] = IROUND64(ctx->Current.RasterPos[3]); + break; + case GL_CURRENT_RASTER_SECONDARY_COLOR: + params[0] = FLOAT_TO_INT64(ctx->Current.RasterSecondaryColor[0]); + params[1] = FLOAT_TO_INT64(ctx->Current.RasterSecondaryColor[1]); + params[2] = FLOAT_TO_INT64(ctx->Current.RasterSecondaryColor[2]); + params[3] = FLOAT_TO_INT64(ctx->Current.RasterSecondaryColor[3]); + break; + case GL_CURRENT_RASTER_TEXTURE_COORDS: + { + const GLuint texUnit = ctx->Texture.CurrentUnit; + params[0] = IROUND64(ctx->Current.RasterTexCoords[texUnit][0]); + params[1] = IROUND64(ctx->Current.RasterTexCoords[texUnit][1]); + params[2] = IROUND64(ctx->Current.RasterTexCoords[texUnit][2]); + params[3] = IROUND64(ctx->Current.RasterTexCoords[texUnit][3]); + } + break; + case GL_CURRENT_RASTER_POSITION_VALID: + params[0] = BOOLEAN_TO_INT64(ctx->Current.RasterPosValid); + break; + case GL_CURRENT_TEXTURE_COORDS: + { + const GLuint texUnit = ctx->Texture.CurrentUnit; + FLUSH_CURRENT(ctx, 0); + params[0] = IROUND64(ctx->Current.Attrib[VERT_ATTRIB_TEX0 + texUnit][0]); + params[1] = IROUND64(ctx->Current.Attrib[VERT_ATTRIB_TEX0 + texUnit][1]); + params[2] = IROUND64(ctx->Current.Attrib[VERT_ATTRIB_TEX0 + texUnit][2]); + params[3] = IROUND64(ctx->Current.Attrib[VERT_ATTRIB_TEX0 + texUnit][3]); + } + break; + case GL_DEPTH_BIAS: + params[0] = IROUND64(ctx->Pixel.DepthBias); + break; + case GL_DEPTH_BITS: + params[0] = ctx->DrawBuffer->Visual.depthBits; + break; + case GL_DEPTH_CLEAR_VALUE: + params[0] = FLOAT_TO_INT64(((GLfloat) ctx->Depth.Clear)); + break; + case GL_DEPTH_FUNC: + params[0] = ENUM_TO_INT64(ctx->Depth.Func); + break; + case GL_DEPTH_RANGE: + params[0] = FLOAT_TO_INT64(ctx->Viewport.Near); + params[1] = FLOAT_TO_INT64(ctx->Viewport.Far); + break; + case GL_DEPTH_SCALE: + params[0] = IROUND64(ctx->Pixel.DepthScale); + break; + case GL_DEPTH_TEST: + params[0] = BOOLEAN_TO_INT64(ctx->Depth.Test); + break; + case GL_DEPTH_WRITEMASK: + params[0] = BOOLEAN_TO_INT64(ctx->Depth.Mask); + break; + case GL_DITHER: + params[0] = BOOLEAN_TO_INT64(ctx->Color.DitherFlag); + break; + case GL_DOUBLEBUFFER: + params[0] = BOOLEAN_TO_INT64(ctx->DrawBuffer->Visual.doubleBufferMode); + break; + case GL_DRAW_BUFFER: + params[0] = ENUM_TO_INT64(ctx->DrawBuffer->ColorDrawBuffer[0]); + break; + case GL_EDGE_FLAG: + { + FLUSH_CURRENT(ctx, 0); + params[0] = BOOLEAN_TO_INT64((ctx->Current.Attrib[VERT_ATTRIB_EDGEFLAG][0] == 1.0)); + } + break; + case GL_FEEDBACK_BUFFER_SIZE: + params[0] = ctx->Feedback.BufferSize; + break; + case GL_FEEDBACK_BUFFER_TYPE: + params[0] = ENUM_TO_INT64(ctx->Feedback.Type); + break; + case GL_FOG: + params[0] = BOOLEAN_TO_INT64(ctx->Fog.Enabled); + break; + case GL_FOG_COLOR: + params[0] = FLOAT_TO_INT64(ctx->Fog.Color[0]); + params[1] = FLOAT_TO_INT64(ctx->Fog.Color[1]); + params[2] = FLOAT_TO_INT64(ctx->Fog.Color[2]); + params[3] = FLOAT_TO_INT64(ctx->Fog.Color[3]); + break; + case GL_FOG_DENSITY: + params[0] = IROUND64(ctx->Fog.Density); + break; + case GL_FOG_END: + params[0] = IROUND64(ctx->Fog.End); + break; + case GL_FOG_HINT: + params[0] = ENUM_TO_INT64(ctx->Hint.Fog); + break; + case GL_FOG_INDEX: + params[0] = IROUND64(ctx->Fog.Index); + break; + case GL_FOG_MODE: + params[0] = ENUM_TO_INT64(ctx->Fog.Mode); + break; + case GL_FOG_START: + params[0] = IROUND64(ctx->Fog.Start); + break; + case GL_FRONT_FACE: + params[0] = ENUM_TO_INT64(ctx->Polygon.FrontFace); + break; + case GL_GREEN_BIAS: + params[0] = IROUND64(ctx->Pixel.GreenBias); + break; + case GL_GREEN_BITS: + params[0] = ctx->DrawBuffer->Visual.greenBits; + break; + case GL_GREEN_SCALE: + params[0] = IROUND64(ctx->Pixel.GreenScale); + break; + case GL_INDEX_BITS: + params[0] = ctx->DrawBuffer->Visual.indexBits; + break; + case GL_INDEX_CLEAR_VALUE: + params[0] = ctx->Color.ClearIndex; + break; + case GL_INDEX_MODE: + params[0] = BOOLEAN_TO_INT64(!ctx->DrawBuffer->Visual.rgbMode); + break; + case GL_INDEX_OFFSET: + params[0] = ctx->Pixel.IndexOffset; + break; + case GL_INDEX_SHIFT: + params[0] = ctx->Pixel.IndexShift; + break; + case GL_INDEX_WRITEMASK: + params[0] = ctx->Color.IndexMask; + break; + case GL_LIGHT0: + params[0] = BOOLEAN_TO_INT64(ctx->Light.Light[0].Enabled); + break; + case GL_LIGHT1: + params[0] = BOOLEAN_TO_INT64(ctx->Light.Light[1].Enabled); + break; + case GL_LIGHT2: + params[0] = BOOLEAN_TO_INT64(ctx->Light.Light[2].Enabled); + break; + case GL_LIGHT3: + params[0] = BOOLEAN_TO_INT64(ctx->Light.Light[3].Enabled); + break; + case GL_LIGHT4: + params[0] = BOOLEAN_TO_INT64(ctx->Light.Light[4].Enabled); + break; + case GL_LIGHT5: + params[0] = BOOLEAN_TO_INT64(ctx->Light.Light[5].Enabled); + break; + case GL_LIGHT6: + params[0] = BOOLEAN_TO_INT64(ctx->Light.Light[6].Enabled); + break; + case GL_LIGHT7: + params[0] = BOOLEAN_TO_INT64(ctx->Light.Light[7].Enabled); + break; + case GL_LIGHTING: + params[0] = BOOLEAN_TO_INT64(ctx->Light.Enabled); + break; + case GL_LIGHT_MODEL_AMBIENT: + params[0] = FLOAT_TO_INT64(ctx->Light.Model.Ambient[0]); + params[1] = FLOAT_TO_INT64(ctx->Light.Model.Ambient[1]); + params[2] = FLOAT_TO_INT64(ctx->Light.Model.Ambient[2]); + params[3] = FLOAT_TO_INT64(ctx->Light.Model.Ambient[3]); + break; + case GL_LIGHT_MODEL_COLOR_CONTROL: + params[0] = ENUM_TO_INT64(ctx->Light.Model.ColorControl); + break; + case GL_LIGHT_MODEL_LOCAL_VIEWER: + params[0] = BOOLEAN_TO_INT64(ctx->Light.Model.LocalViewer); + break; + case GL_LIGHT_MODEL_TWO_SIDE: + params[0] = BOOLEAN_TO_INT64(ctx->Light.Model.TwoSide); + break; + case GL_LINE_SMOOTH: + params[0] = BOOLEAN_TO_INT64(ctx->Line.SmoothFlag); + break; + case GL_LINE_SMOOTH_HINT: + params[0] = ENUM_TO_INT64(ctx->Hint.LineSmooth); + break; + case GL_LINE_STIPPLE: + params[0] = BOOLEAN_TO_INT64(ctx->Line.StippleFlag); + break; + case GL_LINE_STIPPLE_PATTERN: + params[0] = ctx->Line.StipplePattern; + break; + case GL_LINE_STIPPLE_REPEAT: + params[0] = ctx->Line.StippleFactor; + break; + case GL_LINE_WIDTH: + params[0] = IROUND64(ctx->Line.Width); + break; + case GL_LINE_WIDTH_GRANULARITY: + params[0] = IROUND64(ctx->Const.LineWidthGranularity); + break; + case GL_LINE_WIDTH_RANGE: + params[0] = IROUND64(ctx->Const.MinLineWidthAA); + params[1] = IROUND64(ctx->Const.MaxLineWidthAA); + break; + case GL_ALIASED_LINE_WIDTH_RANGE: + params[0] = IROUND64(ctx->Const.MinLineWidth); + params[1] = IROUND64(ctx->Const.MaxLineWidth); + break; + case GL_LIST_BASE: + params[0] = ctx->List.ListBase; + break; + case GL_LIST_INDEX: + params[0] = (ctx->ListState.CurrentList ? ctx->ListState.CurrentList->Name : 0); + break; + case GL_LIST_MODE: + { + GLenum mode; + if (!ctx->CompileFlag) + mode = 0; + else if (ctx->ExecuteFlag) + mode = GL_COMPILE_AND_EXECUTE; + else + mode = GL_COMPILE; + params[0] = ENUM_TO_INT64(mode); + } + break; + case GL_INDEX_LOGIC_OP: + params[0] = BOOLEAN_TO_INT64(ctx->Color.IndexLogicOpEnabled); + break; + case GL_COLOR_LOGIC_OP: + params[0] = BOOLEAN_TO_INT64(ctx->Color.ColorLogicOpEnabled); + break; + case GL_LOGIC_OP_MODE: + params[0] = ENUM_TO_INT64(ctx->Color.LogicOp); + break; + case GL_MAP1_COLOR_4: + params[0] = BOOLEAN_TO_INT64(ctx->Eval.Map1Color4); + break; + case GL_MAP1_GRID_DOMAIN: + params[0] = IROUND64(ctx->Eval.MapGrid1u1); + params[1] = IROUND64(ctx->Eval.MapGrid1u2); + break; + case GL_MAP1_GRID_SEGMENTS: + params[0] = ctx->Eval.MapGrid1un; + break; + case GL_MAP1_INDEX: + params[0] = BOOLEAN_TO_INT64(ctx->Eval.Map1Index); + break; + case GL_MAP1_NORMAL: + params[0] = BOOLEAN_TO_INT64(ctx->Eval.Map1Normal); + break; + case GL_MAP1_TEXTURE_COORD_1: + params[0] = BOOLEAN_TO_INT64(ctx->Eval.Map1TextureCoord1); + break; + case GL_MAP1_TEXTURE_COORD_2: + params[0] = BOOLEAN_TO_INT64(ctx->Eval.Map1TextureCoord2); + break; + case GL_MAP1_TEXTURE_COORD_3: + params[0] = BOOLEAN_TO_INT64(ctx->Eval.Map1TextureCoord3); + break; + case GL_MAP1_TEXTURE_COORD_4: + params[0] = BOOLEAN_TO_INT64(ctx->Eval.Map1TextureCoord4); + break; + case GL_MAP1_VERTEX_3: + params[0] = BOOLEAN_TO_INT64(ctx->Eval.Map1Vertex3); + break; + case GL_MAP1_VERTEX_4: + params[0] = BOOLEAN_TO_INT64(ctx->Eval.Map1Vertex4); + break; + case GL_MAP2_COLOR_4: + params[0] = BOOLEAN_TO_INT64(ctx->Eval.Map2Color4); + break; + case GL_MAP2_GRID_DOMAIN: + params[0] = IROUND64(ctx->Eval.MapGrid2u1); + params[1] = IROUND64(ctx->Eval.MapGrid2u2); + params[2] = IROUND64(ctx->Eval.MapGrid2v1); + params[3] = IROUND64(ctx->Eval.MapGrid2v2); + break; + case GL_MAP2_GRID_SEGMENTS: + params[0] = ctx->Eval.MapGrid2un; + params[1] = ctx->Eval.MapGrid2vn; + break; + case GL_MAP2_INDEX: + params[0] = BOOLEAN_TO_INT64(ctx->Eval.Map2Index); + break; + case GL_MAP2_NORMAL: + params[0] = BOOLEAN_TO_INT64(ctx->Eval.Map2Normal); + break; + case GL_MAP2_TEXTURE_COORD_1: + params[0] = BOOLEAN_TO_INT64(ctx->Eval.Map2TextureCoord1); + break; + case GL_MAP2_TEXTURE_COORD_2: + params[0] = BOOLEAN_TO_INT64(ctx->Eval.Map2TextureCoord2); + break; + case GL_MAP2_TEXTURE_COORD_3: + params[0] = BOOLEAN_TO_INT64(ctx->Eval.Map2TextureCoord3); + break; + case GL_MAP2_TEXTURE_COORD_4: + params[0] = BOOLEAN_TO_INT64(ctx->Eval.Map2TextureCoord4); + break; + case GL_MAP2_VERTEX_3: + params[0] = BOOLEAN_TO_INT64(ctx->Eval.Map2Vertex3); + break; + case GL_MAP2_VERTEX_4: + params[0] = BOOLEAN_TO_INT64(ctx->Eval.Map2Vertex4); + break; + case GL_MAP_COLOR: + params[0] = BOOLEAN_TO_INT64(ctx->Pixel.MapColorFlag); + break; + case GL_MAP_STENCIL: + params[0] = BOOLEAN_TO_INT64(ctx->Pixel.MapStencilFlag); + break; + case GL_MATRIX_MODE: + params[0] = ENUM_TO_INT64(ctx->Transform.MatrixMode); + break; + case GL_MAX_ATTRIB_STACK_DEPTH: + params[0] = MAX_ATTRIB_STACK_DEPTH; + break; + case GL_MAX_CLIENT_ATTRIB_STACK_DEPTH: + params[0] = MAX_CLIENT_ATTRIB_STACK_DEPTH; + break; + case GL_MAX_CLIP_PLANES: + params[0] = ctx->Const.MaxClipPlanes; + break; + case GL_MAX_ELEMENTS_VERTICES: + params[0] = ctx->Const.MaxArrayLockSize; + break; + case GL_MAX_ELEMENTS_INDICES: + params[0] = ctx->Const.MaxArrayLockSize; + break; + case GL_MAX_EVAL_ORDER: + params[0] = MAX_EVAL_ORDER; + break; + case GL_MAX_LIGHTS: + params[0] = ctx->Const.MaxLights; + break; + case GL_MAX_LIST_NESTING: + params[0] = MAX_LIST_NESTING; + break; + case GL_MAX_MODELVIEW_STACK_DEPTH: + params[0] = MAX_MODELVIEW_STACK_DEPTH; + break; + case GL_MAX_NAME_STACK_DEPTH: + params[0] = MAX_NAME_STACK_DEPTH; + break; + case GL_MAX_PIXEL_MAP_TABLE: + params[0] = MAX_PIXEL_MAP_TABLE; + break; + case GL_MAX_PROJECTION_STACK_DEPTH: + params[0] = MAX_PROJECTION_STACK_DEPTH; + break; + case GL_MAX_TEXTURE_SIZE: + params[0] = 1 << (ctx->Const.MaxTextureLevels - 1); + break; + case GL_MAX_3D_TEXTURE_SIZE: + params[0] = 1 << (ctx->Const.Max3DTextureLevels - 1); + break; + case GL_MAX_TEXTURE_STACK_DEPTH: + params[0] = MAX_TEXTURE_STACK_DEPTH; + break; + case GL_MAX_VIEWPORT_DIMS: + params[0] = ctx->Const.MaxViewportWidth; + params[1] = ctx->Const.MaxViewportHeight; + break; + case GL_MODELVIEW_MATRIX: + { + const GLfloat *matrix = ctx->ModelviewMatrixStack.Top->m; + params[0] = IROUND64(matrix[0]); + params[1] = IROUND64(matrix[1]); + params[2] = IROUND64(matrix[2]); + params[3] = IROUND64(matrix[3]); + params[4] = IROUND64(matrix[4]); + params[5] = IROUND64(matrix[5]); + params[6] = IROUND64(matrix[6]); + params[7] = IROUND64(matrix[7]); + params[8] = IROUND64(matrix[8]); + params[9] = IROUND64(matrix[9]); + params[10] = IROUND64(matrix[10]); + params[11] = IROUND64(matrix[11]); + params[12] = IROUND64(matrix[12]); + params[13] = IROUND64(matrix[13]); + params[14] = IROUND64(matrix[14]); + params[15] = IROUND64(matrix[15]); + } + break; + case GL_MODELVIEW_STACK_DEPTH: + params[0] = ctx->ModelviewMatrixStack.Depth + 1; + break; + case GL_NAME_STACK_DEPTH: + params[0] = ctx->Select.NameStackDepth; + break; + case GL_NORMALIZE: + params[0] = BOOLEAN_TO_INT64(ctx->Transform.Normalize); + break; + case GL_PACK_ALIGNMENT: + params[0] = ctx->Pack.Alignment; + break; + case GL_PACK_LSB_FIRST: + params[0] = BOOLEAN_TO_INT64(ctx->Pack.LsbFirst); + break; + case GL_PACK_ROW_LENGTH: + params[0] = ctx->Pack.RowLength; + break; + case GL_PACK_SKIP_PIXELS: + params[0] = ctx->Pack.SkipPixels; + break; + case GL_PACK_SKIP_ROWS: + params[0] = ctx->Pack.SkipRows; + break; + case GL_PACK_SWAP_BYTES: + params[0] = BOOLEAN_TO_INT64(ctx->Pack.SwapBytes); + break; + case GL_PACK_SKIP_IMAGES_EXT: + params[0] = ctx->Pack.SkipImages; + break; + case GL_PACK_IMAGE_HEIGHT_EXT: + params[0] = ctx->Pack.ImageHeight; + break; + case GL_PACK_INVERT_MESA: + params[0] = BOOLEAN_TO_INT64(ctx->Pack.Invert); + break; + case GL_PERSPECTIVE_CORRECTION_HINT: + params[0] = ENUM_TO_INT64(ctx->Hint.PerspectiveCorrection); + break; + case GL_PIXEL_MAP_A_TO_A_SIZE: + params[0] = ctx->PixelMaps.AtoA.Size; + break; + case GL_PIXEL_MAP_B_TO_B_SIZE: + params[0] = ctx->PixelMaps.BtoB.Size; + break; + case GL_PIXEL_MAP_G_TO_G_SIZE: + params[0] = ctx->PixelMaps.GtoG.Size; + break; + case GL_PIXEL_MAP_I_TO_A_SIZE: + params[0] = ctx->PixelMaps.ItoA.Size; + break; + case GL_PIXEL_MAP_I_TO_B_SIZE: + params[0] = ctx->PixelMaps.ItoB.Size; + break; + case GL_PIXEL_MAP_I_TO_G_SIZE: + params[0] = ctx->PixelMaps.ItoG.Size; + break; + case GL_PIXEL_MAP_I_TO_I_SIZE: + params[0] = ctx->PixelMaps.ItoI.Size; + break; + case GL_PIXEL_MAP_I_TO_R_SIZE: + params[0] = ctx->PixelMaps.ItoR.Size; + break; + case GL_PIXEL_MAP_R_TO_R_SIZE: + params[0] = ctx->PixelMaps.RtoR.Size; + break; + case GL_PIXEL_MAP_S_TO_S_SIZE: + params[0] = ctx->PixelMaps.StoS.Size; + break; + case GL_POINT_SIZE: + params[0] = IROUND64(ctx->Point.Size); + break; + case GL_POINT_SIZE_GRANULARITY: + params[0] = IROUND64(ctx->Const.PointSizeGranularity); + break; + case GL_POINT_SIZE_RANGE: + params[0] = IROUND64(ctx->Const.MinPointSizeAA); + params[1] = IROUND64(ctx->Const.MaxPointSizeAA); + break; + case GL_ALIASED_POINT_SIZE_RANGE: + params[0] = IROUND64(ctx->Const.MinPointSize); + params[1] = IROUND64(ctx->Const.MaxPointSize); + break; + case GL_POINT_SMOOTH: + params[0] = BOOLEAN_TO_INT64(ctx->Point.SmoothFlag); + break; + case GL_POINT_SMOOTH_HINT: + params[0] = ENUM_TO_INT64(ctx->Hint.PointSmooth); + break; + case GL_POINT_SIZE_MIN_EXT: + params[0] = IROUND64(ctx->Point.MinSize); + break; + case GL_POINT_SIZE_MAX_EXT: + params[0] = IROUND64(ctx->Point.MaxSize); + break; + case GL_POINT_FADE_THRESHOLD_SIZE_EXT: + params[0] = IROUND64(ctx->Point.Threshold); + break; + case GL_DISTANCE_ATTENUATION_EXT: + params[0] = IROUND64(ctx->Point.Params[0]); + params[1] = IROUND64(ctx->Point.Params[1]); + params[2] = IROUND64(ctx->Point.Params[2]); + break; + case GL_POLYGON_MODE: + params[0] = ENUM_TO_INT64(ctx->Polygon.FrontMode); + params[1] = ENUM_TO_INT64(ctx->Polygon.BackMode); + break; + case GL_POLYGON_OFFSET_BIAS_EXT: + params[0] = IROUND64(ctx->Polygon.OffsetUnits); + break; + case GL_POLYGON_OFFSET_FACTOR: + params[0] = IROUND64(ctx->Polygon.OffsetFactor ); + break; + case GL_POLYGON_OFFSET_UNITS: + params[0] = IROUND64(ctx->Polygon.OffsetUnits ); + break; + case GL_POLYGON_OFFSET_POINT: + params[0] = BOOLEAN_TO_INT64(ctx->Polygon.OffsetPoint); + break; + case GL_POLYGON_OFFSET_LINE: + params[0] = BOOLEAN_TO_INT64(ctx->Polygon.OffsetLine); + break; + case GL_POLYGON_OFFSET_FILL: + params[0] = BOOLEAN_TO_INT64(ctx->Polygon.OffsetFill); + break; + case GL_POLYGON_SMOOTH: + params[0] = BOOLEAN_TO_INT64(ctx->Polygon.SmoothFlag); + break; + case GL_POLYGON_SMOOTH_HINT: + params[0] = ENUM_TO_INT64(ctx->Hint.PolygonSmooth); + break; + case GL_POLYGON_STIPPLE: + params[0] = BOOLEAN_TO_INT64(ctx->Polygon.StippleFlag); + break; + case GL_PROJECTION_MATRIX: + { + const GLfloat *matrix = ctx->ProjectionMatrixStack.Top->m; + params[0] = IROUND64(matrix[0]); + params[1] = IROUND64(matrix[1]); + params[2] = IROUND64(matrix[2]); + params[3] = IROUND64(matrix[3]); + params[4] = IROUND64(matrix[4]); + params[5] = IROUND64(matrix[5]); + params[6] = IROUND64(matrix[6]); + params[7] = IROUND64(matrix[7]); + params[8] = IROUND64(matrix[8]); + params[9] = IROUND64(matrix[9]); + params[10] = IROUND64(matrix[10]); + params[11] = IROUND64(matrix[11]); + params[12] = IROUND64(matrix[12]); + params[13] = IROUND64(matrix[13]); + params[14] = IROUND64(matrix[14]); + params[15] = IROUND64(matrix[15]); + } + break; + case GL_PROJECTION_STACK_DEPTH: + params[0] = ctx->ProjectionMatrixStack.Depth + 1; + break; + case GL_READ_BUFFER: + params[0] = ENUM_TO_INT64(ctx->ReadBuffer->ColorReadBuffer); + break; + case GL_RED_BIAS: + params[0] = IROUND64(ctx->Pixel.RedBias); + break; + case GL_RED_BITS: + params[0] = ctx->DrawBuffer->Visual.redBits; + break; + case GL_RED_SCALE: + params[0] = IROUND64(ctx->Pixel.RedScale); + break; + case GL_RENDER_MODE: + params[0] = ENUM_TO_INT64(ctx->RenderMode); + break; + case GL_RESCALE_NORMAL: + params[0] = BOOLEAN_TO_INT64(ctx->Transform.RescaleNormals); + break; + case GL_RGBA_MODE: + params[0] = BOOLEAN_TO_INT64(ctx->DrawBuffer->Visual.rgbMode); + break; + case GL_SCISSOR_BOX: + params[0] = ctx->Scissor.X; + params[1] = ctx->Scissor.Y; + params[2] = ctx->Scissor.Width; + params[3] = ctx->Scissor.Height; + break; + case GL_SCISSOR_TEST: + params[0] = BOOLEAN_TO_INT64(ctx->Scissor.Enabled); + break; + case GL_SELECTION_BUFFER_SIZE: + params[0] = ctx->Select.BufferSize; + break; + case GL_SHADE_MODEL: + params[0] = ENUM_TO_INT64(ctx->Light.ShadeModel); + break; + case GL_SHARED_TEXTURE_PALETTE_EXT: + params[0] = BOOLEAN_TO_INT64(ctx->Texture.SharedPalette); + break; + case GL_STENCIL_BITS: + params[0] = ctx->DrawBuffer->Visual.stencilBits; + break; + case GL_STENCIL_CLEAR_VALUE: + params[0] = ctx->Stencil.Clear; + break; + case GL_STENCIL_FAIL: + params[0] = ENUM_TO_INT64(ctx->Stencil.FailFunc[ctx->Stencil.ActiveFace]); + break; + case GL_STENCIL_FUNC: + params[0] = ENUM_TO_INT64(ctx->Stencil.Function[ctx->Stencil.ActiveFace]); + break; + case GL_STENCIL_PASS_DEPTH_FAIL: + params[0] = ENUM_TO_INT64(ctx->Stencil.ZFailFunc[ctx->Stencil.ActiveFace]); + break; + case GL_STENCIL_PASS_DEPTH_PASS: + params[0] = ENUM_TO_INT64(ctx->Stencil.ZPassFunc[ctx->Stencil.ActiveFace]); + break; + case GL_STENCIL_REF: + params[0] = ctx->Stencil.Ref[ctx->Stencil.ActiveFace]; + break; + case GL_STENCIL_TEST: + params[0] = BOOLEAN_TO_INT64(ctx->Stencil.Enabled); + break; + case GL_STENCIL_VALUE_MASK: + params[0] = ctx->Stencil.ValueMask[ctx->Stencil.ActiveFace]; + break; + case GL_STENCIL_WRITEMASK: + params[0] = ctx->Stencil.WriteMask[ctx->Stencil.ActiveFace]; + break; + case GL_STEREO: + params[0] = BOOLEAN_TO_INT64(ctx->DrawBuffer->Visual.stereoMode); + break; + case GL_SUBPIXEL_BITS: + params[0] = ctx->Const.SubPixelBits; + break; + case GL_TEXTURE_1D: + params[0] = BOOLEAN_TO_INT64(_mesa_IsEnabled(GL_TEXTURE_1D)); + break; + case GL_TEXTURE_2D: + params[0] = BOOLEAN_TO_INT64(_mesa_IsEnabled(GL_TEXTURE_2D)); + break; + case GL_TEXTURE_3D: + params[0] = BOOLEAN_TO_INT64(_mesa_IsEnabled(GL_TEXTURE_3D)); + break; + case GL_TEXTURE_1D_ARRAY_EXT: + CHECK_EXT1(MESA_texture_array, "GetInteger64v"); + params[0] = BOOLEAN_TO_INT64(_mesa_IsEnabled(GL_TEXTURE_1D_ARRAY_EXT)); + break; + case GL_TEXTURE_2D_ARRAY_EXT: + CHECK_EXT1(MESA_texture_array, "GetInteger64v"); + params[0] = BOOLEAN_TO_INT64(_mesa_IsEnabled(GL_TEXTURE_2D_ARRAY_EXT)); + break; + case GL_TEXTURE_BINDING_1D: + 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].CurrentTex[TEXTURE_2D_INDEX]->Name; + break; + case GL_TEXTURE_BINDING_3D: + 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, "GetInteger64v"); + 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, "GetInteger64v"); + params[0] = ctx->Texture.Unit[ctx->Texture.CurrentUnit].CurrentTex[TEXTURE_2D_ARRAY_INDEX]->Name; + break; + case GL_TEXTURE_GEN_S: + params[0] = BOOLEAN_TO_INT64(((ctx->Texture.Unit[ctx->Texture.CurrentUnit].TexGenEnabled & S_BIT) ? 1 : 0)); + break; + case GL_TEXTURE_GEN_T: + params[0] = BOOLEAN_TO_INT64(((ctx->Texture.Unit[ctx->Texture.CurrentUnit].TexGenEnabled & T_BIT) ? 1 : 0)); + break; + case GL_TEXTURE_GEN_R: + params[0] = BOOLEAN_TO_INT64(((ctx->Texture.Unit[ctx->Texture.CurrentUnit].TexGenEnabled & R_BIT) ? 1 : 0)); + break; + case GL_TEXTURE_GEN_Q: + params[0] = BOOLEAN_TO_INT64(((ctx->Texture.Unit[ctx->Texture.CurrentUnit].TexGenEnabled & Q_BIT) ? 1 : 0)); + break; + case GL_TEXTURE_MATRIX: + { + const GLfloat *matrix = ctx->TextureMatrixStack[ctx->Texture.CurrentUnit].Top->m; + params[0] = IROUND64(matrix[0]); + params[1] = IROUND64(matrix[1]); + params[2] = IROUND64(matrix[2]); + params[3] = IROUND64(matrix[3]); + params[4] = IROUND64(matrix[4]); + params[5] = IROUND64(matrix[5]); + params[6] = IROUND64(matrix[6]); + params[7] = IROUND64(matrix[7]); + params[8] = IROUND64(matrix[8]); + params[9] = IROUND64(matrix[9]); + params[10] = IROUND64(matrix[10]); + params[11] = IROUND64(matrix[11]); + params[12] = IROUND64(matrix[12]); + params[13] = IROUND64(matrix[13]); + params[14] = IROUND64(matrix[14]); + params[15] = IROUND64(matrix[15]); + } + break; + case GL_TEXTURE_STACK_DEPTH: + params[0] = ctx->TextureMatrixStack[ctx->Texture.CurrentUnit].Depth + 1; + break; + case GL_UNPACK_ALIGNMENT: + params[0] = ctx->Unpack.Alignment; + break; + case GL_UNPACK_LSB_FIRST: + params[0] = BOOLEAN_TO_INT64(ctx->Unpack.LsbFirst); + break; + case GL_UNPACK_ROW_LENGTH: + params[0] = ctx->Unpack.RowLength; + break; + case GL_UNPACK_SKIP_PIXELS: + params[0] = ctx->Unpack.SkipPixels; + break; + case GL_UNPACK_SKIP_ROWS: + params[0] = ctx->Unpack.SkipRows; + break; + case GL_UNPACK_SWAP_BYTES: + params[0] = BOOLEAN_TO_INT64(ctx->Unpack.SwapBytes); + break; + case GL_UNPACK_SKIP_IMAGES_EXT: + params[0] = ctx->Unpack.SkipImages; + break; + case GL_UNPACK_IMAGE_HEIGHT_EXT: + params[0] = ctx->Unpack.ImageHeight; + break; + case GL_UNPACK_CLIENT_STORAGE_APPLE: + params[0] = BOOLEAN_TO_INT64(ctx->Unpack.ClientStorage); + break; + case GL_VIEWPORT: + params[0] = ctx->Viewport.X; + params[1] = ctx->Viewport.Y; + params[2] = ctx->Viewport.Width; + params[3] = ctx->Viewport.Height; + break; + case GL_ZOOM_X: + params[0] = IROUND64(ctx->Pixel.ZoomX); + break; + case GL_ZOOM_Y: + params[0] = IROUND64(ctx->Pixel.ZoomY); + break; + case GL_VERTEX_ARRAY: + params[0] = BOOLEAN_TO_INT64(ctx->Array.ArrayObj->Vertex.Enabled); + break; + case GL_VERTEX_ARRAY_SIZE: + params[0] = ctx->Array.ArrayObj->Vertex.Size; + break; + case GL_VERTEX_ARRAY_TYPE: + params[0] = ENUM_TO_INT64(ctx->Array.ArrayObj->Vertex.Type); + break; + case GL_VERTEX_ARRAY_STRIDE: + params[0] = ctx->Array.ArrayObj->Vertex.Stride; + break; + case GL_VERTEX_ARRAY_COUNT_EXT: + params[0] = 0; + break; + case GL_NORMAL_ARRAY: + params[0] = ENUM_TO_INT64(ctx->Array.ArrayObj->Normal.Enabled); + break; + case GL_NORMAL_ARRAY_TYPE: + params[0] = ENUM_TO_INT64(ctx->Array.ArrayObj->Normal.Type); + break; + case GL_NORMAL_ARRAY_STRIDE: + params[0] = ctx->Array.ArrayObj->Normal.Stride; + break; + case GL_NORMAL_ARRAY_COUNT_EXT: + params[0] = 0; + break; + case GL_COLOR_ARRAY: + params[0] = BOOLEAN_TO_INT64(ctx->Array.ArrayObj->Color.Enabled); + break; + case GL_COLOR_ARRAY_SIZE: + params[0] = ctx->Array.ArrayObj->Color.Size; + break; + case GL_COLOR_ARRAY_TYPE: + params[0] = ENUM_TO_INT64(ctx->Array.ArrayObj->Color.Type); + break; + case GL_COLOR_ARRAY_STRIDE: + params[0] = ctx->Array.ArrayObj->Color.Stride; + break; + case GL_COLOR_ARRAY_COUNT_EXT: + params[0] = 0; + break; + case GL_INDEX_ARRAY: + params[0] = BOOLEAN_TO_INT64(ctx->Array.ArrayObj->Index.Enabled); + break; + case GL_INDEX_ARRAY_TYPE: + params[0] = ENUM_TO_INT64(ctx->Array.ArrayObj->Index.Type); + break; + case GL_INDEX_ARRAY_STRIDE: + params[0] = ctx->Array.ArrayObj->Index.Stride; + break; + case GL_INDEX_ARRAY_COUNT_EXT: + params[0] = 0; + break; + case GL_TEXTURE_COORD_ARRAY: + params[0] = BOOLEAN_TO_INT64(ctx->Array.ArrayObj->TexCoord[ctx->Array.ActiveTexture].Enabled); + break; + case GL_TEXTURE_COORD_ARRAY_SIZE: + params[0] = ctx->Array.ArrayObj->TexCoord[ctx->Array.ActiveTexture].Size; + break; + case GL_TEXTURE_COORD_ARRAY_TYPE: + params[0] = ENUM_TO_INT64(ctx->Array.ArrayObj->TexCoord[ctx->Array.ActiveTexture].Type); + break; + case GL_TEXTURE_COORD_ARRAY_STRIDE: + params[0] = ctx->Array.ArrayObj->TexCoord[ctx->Array.ActiveTexture].Stride; + break; + case GL_TEXTURE_COORD_ARRAY_COUNT_EXT: + params[0] = 0; + break; + case GL_EDGE_FLAG_ARRAY: + params[0] = BOOLEAN_TO_INT64(ctx->Array.ArrayObj->EdgeFlag.Enabled); + break; + case GL_EDGE_FLAG_ARRAY_STRIDE: + params[0] = ctx->Array.ArrayObj->EdgeFlag.Stride; + break; + case GL_EDGE_FLAG_ARRAY_COUNT_EXT: + params[0] = 0; + break; + case GL_MAX_TEXTURE_UNITS_ARB: + CHECK_EXT1(ARB_multitexture, "GetInteger64v"); + params[0] = ctx->Const.MaxTextureUnits; + break; + case GL_ACTIVE_TEXTURE_ARB: + CHECK_EXT1(ARB_multitexture, "GetInteger64v"); + params[0] = GL_TEXTURE0_ARB + ctx->Texture.CurrentUnit; + break; + case GL_CLIENT_ACTIVE_TEXTURE_ARB: + CHECK_EXT1(ARB_multitexture, "GetInteger64v"); + params[0] = GL_TEXTURE0_ARB + ctx->Array.ActiveTexture; + break; + case GL_TEXTURE_CUBE_MAP_ARB: + CHECK_EXT1(ARB_texture_cube_map, "GetInteger64v"); + params[0] = BOOLEAN_TO_INT64(_mesa_IsEnabled(GL_TEXTURE_CUBE_MAP_ARB)); + break; + case GL_TEXTURE_BINDING_CUBE_MAP_ARB: + CHECK_EXT1(ARB_texture_cube_map, "GetInteger64v"); + 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, "GetInteger64v"); + params[0] = (1 << (ctx->Const.MaxCubeTextureLevels - 1)); + break; + case GL_TEXTURE_COMPRESSION_HINT_ARB: + params[0] = ctx->Hint.TextureCompression; + break; + case GL_NUM_COMPRESSED_TEXTURE_FORMATS_ARB: + params[0] = _mesa_get_compressed_formats(ctx, NULL, GL_FALSE); + break; + case GL_COMPRESSED_TEXTURE_FORMATS_ARB: + { + GLint formats[100]; + GLuint i, n = _mesa_get_compressed_formats(ctx, formats, GL_FALSE); + ASSERT(n <= 100); + for (i = 0; i < n; i++) + params[i] = ENUM_TO_INT64(formats[i]); + } + break; + case GL_ARRAY_ELEMENT_LOCK_FIRST_EXT: + CHECK_EXT1(EXT_compiled_vertex_array, "GetInteger64v"); + params[0] = ctx->Array.LockFirst; + break; + case GL_ARRAY_ELEMENT_LOCK_COUNT_EXT: + CHECK_EXT1(EXT_compiled_vertex_array, "GetInteger64v"); + params[0] = ctx->Array.LockCount; + break; + case GL_TRANSPOSE_COLOR_MATRIX_ARB: + { + const GLfloat *matrix = ctx->ColorMatrixStack.Top->m; + params[0] = IROUND64(matrix[0]); + params[1] = IROUND64(matrix[4]); + params[2] = IROUND64(matrix[8]); + params[3] = IROUND64(matrix[12]); + params[4] = IROUND64(matrix[1]); + params[5] = IROUND64(matrix[5]); + params[6] = IROUND64(matrix[9]); + params[7] = IROUND64(matrix[13]); + params[8] = IROUND64(matrix[2]); + params[9] = IROUND64(matrix[6]); + params[10] = IROUND64(matrix[10]); + params[11] = IROUND64(matrix[14]); + params[12] = IROUND64(matrix[3]); + params[13] = IROUND64(matrix[7]); + params[14] = IROUND64(matrix[11]); + params[15] = IROUND64(matrix[15]); + } + break; + case GL_TRANSPOSE_MODELVIEW_MATRIX_ARB: + { + const GLfloat *matrix = ctx->ModelviewMatrixStack.Top->m; + params[0] = IROUND64(matrix[0]); + params[1] = IROUND64(matrix[4]); + params[2] = IROUND64(matrix[8]); + params[3] = IROUND64(matrix[12]); + params[4] = IROUND64(matrix[1]); + params[5] = IROUND64(matrix[5]); + params[6] = IROUND64(matrix[9]); + params[7] = IROUND64(matrix[13]); + params[8] = IROUND64(matrix[2]); + params[9] = IROUND64(matrix[6]); + params[10] = IROUND64(matrix[10]); + params[11] = IROUND64(matrix[14]); + params[12] = IROUND64(matrix[3]); + params[13] = IROUND64(matrix[7]); + params[14] = IROUND64(matrix[11]); + params[15] = IROUND64(matrix[15]); + } + break; + case GL_TRANSPOSE_PROJECTION_MATRIX_ARB: + { + const GLfloat *matrix = ctx->ProjectionMatrixStack.Top->m; + params[0] = IROUND64(matrix[0]); + params[1] = IROUND64(matrix[4]); + params[2] = IROUND64(matrix[8]); + params[3] = IROUND64(matrix[12]); + params[4] = IROUND64(matrix[1]); + params[5] = IROUND64(matrix[5]); + params[6] = IROUND64(matrix[9]); + params[7] = IROUND64(matrix[13]); + params[8] = IROUND64(matrix[2]); + params[9] = IROUND64(matrix[6]); + params[10] = IROUND64(matrix[10]); + params[11] = IROUND64(matrix[14]); + params[12] = IROUND64(matrix[3]); + params[13] = IROUND64(matrix[7]); + params[14] = IROUND64(matrix[11]); + params[15] = IROUND64(matrix[15]); + } + break; + case GL_TRANSPOSE_TEXTURE_MATRIX_ARB: + { + const GLfloat *matrix = ctx->TextureMatrixStack[ctx->Texture.CurrentUnit].Top->m; + params[0] = IROUND64(matrix[0]); + params[1] = IROUND64(matrix[4]); + params[2] = IROUND64(matrix[8]); + params[3] = IROUND64(matrix[12]); + params[4] = IROUND64(matrix[1]); + params[5] = IROUND64(matrix[5]); + params[6] = IROUND64(matrix[9]); + params[7] = IROUND64(matrix[13]); + params[8] = IROUND64(matrix[2]); + params[9] = IROUND64(matrix[6]); + params[10] = IROUND64(matrix[10]); + params[11] = IROUND64(matrix[14]); + params[12] = IROUND64(matrix[3]); + params[13] = IROUND64(matrix[7]); + params[14] = IROUND64(matrix[11]); + params[15] = IROUND64(matrix[15]); + } + break; + case GL_COLOR_MATRIX_SGI: + { + const GLfloat *matrix = ctx->ColorMatrixStack.Top->m; + params[0] = IROUND64(matrix[0]); + params[1] = IROUND64(matrix[1]); + params[2] = IROUND64(matrix[2]); + params[3] = IROUND64(matrix[3]); + params[4] = IROUND64(matrix[4]); + params[5] = IROUND64(matrix[5]); + params[6] = IROUND64(matrix[6]); + params[7] = IROUND64(matrix[7]); + params[8] = IROUND64(matrix[8]); + params[9] = IROUND64(matrix[9]); + params[10] = IROUND64(matrix[10]); + params[11] = IROUND64(matrix[11]); + params[12] = IROUND64(matrix[12]); + params[13] = IROUND64(matrix[13]); + params[14] = IROUND64(matrix[14]); + params[15] = IROUND64(matrix[15]); + } + break; + case GL_COLOR_MATRIX_STACK_DEPTH_SGI: + params[0] = ctx->ColorMatrixStack.Depth + 1; + break; + case GL_MAX_COLOR_MATRIX_STACK_DEPTH_SGI: + params[0] = MAX_COLOR_STACK_DEPTH; + break; + case GL_POST_COLOR_MATRIX_RED_SCALE_SGI: + params[0] = IROUND64(ctx->Pixel.PostColorMatrixScale[0]); + break; + case GL_POST_COLOR_MATRIX_GREEN_SCALE_SGI: + params[0] = IROUND64(ctx->Pixel.PostColorMatrixScale[1]); + break; + case GL_POST_COLOR_MATRIX_BLUE_SCALE_SGI: + params[0] = IROUND64(ctx->Pixel.PostColorMatrixScale[2]); + break; + case GL_POST_COLOR_MATRIX_ALPHA_SCALE_SGI: + params[0] = IROUND64(ctx->Pixel.PostColorMatrixScale[3]); + break; + case GL_POST_COLOR_MATRIX_RED_BIAS_SGI: + params[0] = IROUND64(ctx->Pixel.PostColorMatrixBias[0]); + break; + case GL_POST_COLOR_MATRIX_GREEN_BIAS_SGI: + params[0] = IROUND64(ctx->Pixel.PostColorMatrixBias[1]); + break; + case GL_POST_COLOR_MATRIX_BLUE_BIAS_SGI: + params[0] = IROUND64(ctx->Pixel.PostColorMatrixBias[2]); + break; + case GL_POST_COLOR_MATRIX_ALPHA_BIAS_SGI: + params[0] = IROUND64(ctx->Pixel.PostColorMatrixBias[3]); + break; + case GL_CONVOLUTION_1D_EXT: + CHECK_EXT1(EXT_convolution, "GetInteger64v"); + params[0] = BOOLEAN_TO_INT64(ctx->Pixel.Convolution1DEnabled); + break; + case GL_CONVOLUTION_2D_EXT: + CHECK_EXT1(EXT_convolution, "GetInteger64v"); + params[0] = BOOLEAN_TO_INT64(ctx->Pixel.Convolution2DEnabled); + break; + case GL_SEPARABLE_2D_EXT: + CHECK_EXT1(EXT_convolution, "GetInteger64v"); + params[0] = BOOLEAN_TO_INT64(ctx->Pixel.Separable2DEnabled); + break; + case GL_POST_CONVOLUTION_RED_SCALE_EXT: + CHECK_EXT1(EXT_convolution, "GetInteger64v"); + params[0] = IROUND64(ctx->Pixel.PostConvolutionScale[0]); + break; + case GL_POST_CONVOLUTION_GREEN_SCALE_EXT: + CHECK_EXT1(EXT_convolution, "GetInteger64v"); + params[0] = IROUND64(ctx->Pixel.PostConvolutionScale[1]); + break; + case GL_POST_CONVOLUTION_BLUE_SCALE_EXT: + CHECK_EXT1(EXT_convolution, "GetInteger64v"); + params[0] = IROUND64(ctx->Pixel.PostConvolutionScale[2]); + break; + case GL_POST_CONVOLUTION_ALPHA_SCALE_EXT: + CHECK_EXT1(EXT_convolution, "GetInteger64v"); + params[0] = IROUND64(ctx->Pixel.PostConvolutionScale[3]); + break; + case GL_POST_CONVOLUTION_RED_BIAS_EXT: + CHECK_EXT1(EXT_convolution, "GetInteger64v"); + params[0] = IROUND64(ctx->Pixel.PostConvolutionBias[0]); + break; + case GL_POST_CONVOLUTION_GREEN_BIAS_EXT: + CHECK_EXT1(EXT_convolution, "GetInteger64v"); + params[0] = IROUND64(ctx->Pixel.PostConvolutionBias[1]); + break; + case GL_POST_CONVOLUTION_BLUE_BIAS_EXT: + CHECK_EXT1(EXT_convolution, "GetInteger64v"); + params[0] = IROUND64(ctx->Pixel.PostConvolutionBias[2]); + break; + case GL_POST_CONVOLUTION_ALPHA_BIAS_EXT: + CHECK_EXT1(EXT_convolution, "GetInteger64v"); + params[0] = IROUND64(ctx->Pixel.PostConvolutionBias[3]); + break; + case GL_HISTOGRAM: + CHECK_EXT1(EXT_histogram, "GetInteger64v"); + params[0] = BOOLEAN_TO_INT64(ctx->Pixel.HistogramEnabled); + break; + case GL_MINMAX: + CHECK_EXT1(EXT_histogram, "GetInteger64v"); + params[0] = BOOLEAN_TO_INT64(ctx->Pixel.MinMaxEnabled); + break; + case GL_COLOR_TABLE_SGI: + CHECK_EXT1(SGI_color_table, "GetInteger64v"); + params[0] = BOOLEAN_TO_INT64(ctx->Pixel.ColorTableEnabled[COLORTABLE_PRECONVOLUTION]); + break; + case GL_POST_CONVOLUTION_COLOR_TABLE_SGI: + CHECK_EXT1(SGI_color_table, "GetInteger64v"); + params[0] = BOOLEAN_TO_INT64(ctx->Pixel.ColorTableEnabled[COLORTABLE_POSTCONVOLUTION]); + break; + case GL_POST_COLOR_MATRIX_COLOR_TABLE_SGI: + CHECK_EXT1(SGI_color_table, "GetInteger64v"); + params[0] = BOOLEAN_TO_INT64(ctx->Pixel.ColorTableEnabled[COLORTABLE_POSTCOLORMATRIX]); + break; + case GL_TEXTURE_COLOR_TABLE_SGI: + CHECK_EXT1(SGI_texture_color_table, "GetInteger64v"); + params[0] = BOOLEAN_TO_INT64(ctx->Texture.Unit[ctx->Texture.CurrentUnit].ColorTableEnabled); + break; + case GL_COLOR_SUM_EXT: + CHECK_EXT2(EXT_secondary_color, ARB_vertex_program, "GetInteger64v"); + params[0] = BOOLEAN_TO_INT64(ctx->Fog.ColorSumEnabled); + break; + case GL_CURRENT_SECONDARY_COLOR_EXT: + CHECK_EXT1(EXT_secondary_color, "GetInteger64v"); + { + FLUSH_CURRENT(ctx, 0); + params[0] = FLOAT_TO_INT64(ctx->Current.Attrib[VERT_ATTRIB_COLOR1][0]); + params[1] = FLOAT_TO_INT64(ctx->Current.Attrib[VERT_ATTRIB_COLOR1][1]); + params[2] = FLOAT_TO_INT64(ctx->Current.Attrib[VERT_ATTRIB_COLOR1][2]); + params[3] = FLOAT_TO_INT64(ctx->Current.Attrib[VERT_ATTRIB_COLOR1][3]); + } + break; + case GL_SECONDARY_COLOR_ARRAY_EXT: + CHECK_EXT1(EXT_secondary_color, "GetInteger64v"); + params[0] = BOOLEAN_TO_INT64(ctx->Array.ArrayObj->SecondaryColor.Enabled); + break; + case GL_SECONDARY_COLOR_ARRAY_TYPE_EXT: + CHECK_EXT1(EXT_secondary_color, "GetInteger64v"); + params[0] = ENUM_TO_INT64(ctx->Array.ArrayObj->SecondaryColor.Type); + break; + case GL_SECONDARY_COLOR_ARRAY_STRIDE_EXT: + CHECK_EXT1(EXT_secondary_color, "GetInteger64v"); + params[0] = ctx->Array.ArrayObj->SecondaryColor.Stride; + break; + case GL_SECONDARY_COLOR_ARRAY_SIZE_EXT: + CHECK_EXT1(EXT_secondary_color, "GetInteger64v"); + params[0] = ctx->Array.ArrayObj->SecondaryColor.Size; + break; + case GL_CURRENT_FOG_COORDINATE_EXT: + CHECK_EXT1(EXT_fog_coord, "GetInteger64v"); + { + FLUSH_CURRENT(ctx, 0); + params[0] = IROUND64(ctx->Current.Attrib[VERT_ATTRIB_FOG][0]); + } + break; + case GL_FOG_COORDINATE_ARRAY_EXT: + CHECK_EXT1(EXT_fog_coord, "GetInteger64v"); + params[0] = BOOLEAN_TO_INT64(ctx->Array.ArrayObj->FogCoord.Enabled); + break; + case GL_FOG_COORDINATE_ARRAY_TYPE_EXT: + CHECK_EXT1(EXT_fog_coord, "GetInteger64v"); + params[0] = ENUM_TO_INT64(ctx->Array.ArrayObj->FogCoord.Type); + break; + case GL_FOG_COORDINATE_ARRAY_STRIDE_EXT: + CHECK_EXT1(EXT_fog_coord, "GetInteger64v"); + params[0] = ctx->Array.ArrayObj->FogCoord.Stride; + break; + case GL_FOG_COORDINATE_SOURCE_EXT: + CHECK_EXT1(EXT_fog_coord, "GetInteger64v"); + params[0] = ENUM_TO_INT64(ctx->Fog.FogCoordinateSource); + break; + case GL_MAX_TEXTURE_LOD_BIAS_EXT: + CHECK_EXT1(EXT_texture_lod_bias, "GetInteger64v"); + params[0] = IROUND64(ctx->Const.MaxTextureLodBias); + break; + case GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT: + CHECK_EXT1(EXT_texture_filter_anisotropic, "GetInteger64v"); + params[0] = IROUND64(ctx->Const.MaxTextureMaxAnisotropy); + break; + case GL_MULTISAMPLE_ARB: + params[0] = BOOLEAN_TO_INT64(ctx->Multisample.Enabled); + break; + case GL_SAMPLE_ALPHA_TO_COVERAGE_ARB: + params[0] = BOOLEAN_TO_INT64(ctx->Multisample.SampleAlphaToCoverage); + break; + case GL_SAMPLE_ALPHA_TO_ONE_ARB: + params[0] = BOOLEAN_TO_INT64(ctx->Multisample.SampleAlphaToOne); + break; + case GL_SAMPLE_COVERAGE_ARB: + params[0] = BOOLEAN_TO_INT64(ctx->Multisample.SampleCoverage); + break; + case GL_SAMPLE_COVERAGE_VALUE_ARB: + params[0] = IROUND64(ctx->Multisample.SampleCoverageValue); + break; + case GL_SAMPLE_COVERAGE_INVERT_ARB: + params[0] = BOOLEAN_TO_INT64(ctx->Multisample.SampleCoverageInvert); + break; + case GL_SAMPLE_BUFFERS_ARB: + params[0] = ctx->DrawBuffer->Visual.sampleBuffers; + break; + case GL_SAMPLES_ARB: + params[0] = ctx->DrawBuffer->Visual.samples; + break; + case GL_RASTER_POSITION_UNCLIPPED_IBM: + CHECK_EXT1(IBM_rasterpos_clip, "GetInteger64v"); + params[0] = BOOLEAN_TO_INT64(ctx->Transform.RasterPositionUnclipped); + break; + case GL_POINT_SPRITE_NV: + CHECK_EXT2(NV_point_sprite, ARB_point_sprite, "GetInteger64v"); + params[0] = BOOLEAN_TO_INT64(ctx->Point.PointSprite); + break; + case GL_POINT_SPRITE_R_MODE_NV: + CHECK_EXT1(NV_point_sprite, "GetInteger64v"); + params[0] = ENUM_TO_INT64(ctx->Point.SpriteRMode); + break; + case GL_POINT_SPRITE_COORD_ORIGIN: + CHECK_EXT2(NV_point_sprite, ARB_point_sprite, "GetInteger64v"); + params[0] = ENUM_TO_INT64(ctx->Point.SpriteOrigin); + break; + case GL_GENERATE_MIPMAP_HINT_SGIS: + CHECK_EXT1(SGIS_generate_mipmap, "GetInteger64v"); + params[0] = ENUM_TO_INT64(ctx->Hint.GenerateMipmap); + break; + case GL_VERTEX_PROGRAM_BINDING_NV: + CHECK_EXT1(NV_vertex_program, "GetInteger64v"); + params[0] = (ctx->VertexProgram.Current ? ctx->VertexProgram.Current->Base.Id : 0); + break; + case GL_VERTEX_ATTRIB_ARRAY0_NV: + CHECK_EXT1(NV_vertex_program, "GetInteger64v"); + params[0] = BOOLEAN_TO_INT64(ctx->Array.ArrayObj->VertexAttrib[0].Enabled); + break; + case GL_VERTEX_ATTRIB_ARRAY1_NV: + CHECK_EXT1(NV_vertex_program, "GetInteger64v"); + params[0] = BOOLEAN_TO_INT64(ctx->Array.ArrayObj->VertexAttrib[1].Enabled); + break; + case GL_VERTEX_ATTRIB_ARRAY2_NV: + CHECK_EXT1(NV_vertex_program, "GetInteger64v"); + params[0] = BOOLEAN_TO_INT64(ctx->Array.ArrayObj->VertexAttrib[2].Enabled); + break; + case GL_VERTEX_ATTRIB_ARRAY3_NV: + CHECK_EXT1(NV_vertex_program, "GetInteger64v"); + params[0] = BOOLEAN_TO_INT64(ctx->Array.ArrayObj->VertexAttrib[3].Enabled); + break; + case GL_VERTEX_ATTRIB_ARRAY4_NV: + CHECK_EXT1(NV_vertex_program, "GetInteger64v"); + params[0] = BOOLEAN_TO_INT64(ctx->Array.ArrayObj->VertexAttrib[4].Enabled); + break; + case GL_VERTEX_ATTRIB_ARRAY5_NV: + CHECK_EXT1(NV_vertex_program, "GetInteger64v"); + params[0] = BOOLEAN_TO_INT64(ctx->Array.ArrayObj->VertexAttrib[5].Enabled); + break; + case GL_VERTEX_ATTRIB_ARRAY6_NV: + CHECK_EXT1(NV_vertex_program, "GetInteger64v"); + params[0] = BOOLEAN_TO_INT64(ctx->Array.ArrayObj->VertexAttrib[6].Enabled); + break; + case GL_VERTEX_ATTRIB_ARRAY7_NV: + CHECK_EXT1(NV_vertex_program, "GetInteger64v"); + params[0] = BOOLEAN_TO_INT64(ctx->Array.ArrayObj->VertexAttrib[7].Enabled); + break; + case GL_VERTEX_ATTRIB_ARRAY8_NV: + CHECK_EXT1(NV_vertex_program, "GetInteger64v"); + params[0] = BOOLEAN_TO_INT64(ctx->Array.ArrayObj->VertexAttrib[8].Enabled); + break; + case GL_VERTEX_ATTRIB_ARRAY9_NV: + CHECK_EXT1(NV_vertex_program, "GetInteger64v"); + params[0] = BOOLEAN_TO_INT64(ctx->Array.ArrayObj->VertexAttrib[9].Enabled); + break; + case GL_VERTEX_ATTRIB_ARRAY10_NV: + CHECK_EXT1(NV_vertex_program, "GetInteger64v"); + params[0] = BOOLEAN_TO_INT64(ctx->Array.ArrayObj->VertexAttrib[10].Enabled); + break; + case GL_VERTEX_ATTRIB_ARRAY11_NV: + CHECK_EXT1(NV_vertex_program, "GetInteger64v"); + params[0] = BOOLEAN_TO_INT64(ctx->Array.ArrayObj->VertexAttrib[11].Enabled); + break; + case GL_VERTEX_ATTRIB_ARRAY12_NV: + CHECK_EXT1(NV_vertex_program, "GetInteger64v"); + params[0] = BOOLEAN_TO_INT64(ctx->Array.ArrayObj->VertexAttrib[12].Enabled); + break; + case GL_VERTEX_ATTRIB_ARRAY13_NV: + CHECK_EXT1(NV_vertex_program, "GetInteger64v"); + params[0] = BOOLEAN_TO_INT64(ctx->Array.ArrayObj->VertexAttrib[13].Enabled); + break; + case GL_VERTEX_ATTRIB_ARRAY14_NV: + CHECK_EXT1(NV_vertex_program, "GetInteger64v"); + params[0] = BOOLEAN_TO_INT64(ctx->Array.ArrayObj->VertexAttrib[14].Enabled); + break; + case GL_VERTEX_ATTRIB_ARRAY15_NV: + CHECK_EXT1(NV_vertex_program, "GetInteger64v"); + params[0] = BOOLEAN_TO_INT64(ctx->Array.ArrayObj->VertexAttrib[15].Enabled); + break; + case GL_MAP1_VERTEX_ATTRIB0_4_NV: + CHECK_EXT1(NV_vertex_program, "GetInteger64v"); + params[0] = BOOLEAN_TO_INT64(ctx->Eval.Map1Attrib[0]); + break; + case GL_MAP1_VERTEX_ATTRIB1_4_NV: + CHECK_EXT1(NV_vertex_program, "GetInteger64v"); + params[0] = BOOLEAN_TO_INT64(ctx->Eval.Map1Attrib[1]); + break; + case GL_MAP1_VERTEX_ATTRIB2_4_NV: + CHECK_EXT1(NV_vertex_program, "GetInteger64v"); + params[0] = BOOLEAN_TO_INT64(ctx->Eval.Map1Attrib[2]); + break; + case GL_MAP1_VERTEX_ATTRIB3_4_NV: + CHECK_EXT1(NV_vertex_program, "GetInteger64v"); + params[0] = BOOLEAN_TO_INT64(ctx->Eval.Map1Attrib[3]); + break; + case GL_MAP1_VERTEX_ATTRIB4_4_NV: + CHECK_EXT1(NV_vertex_program, "GetInteger64v"); + params[0] = BOOLEAN_TO_INT64(ctx->Eval.Map1Attrib[4]); + break; + case GL_MAP1_VERTEX_ATTRIB5_4_NV: + CHECK_EXT1(NV_vertex_program, "GetInteger64v"); + params[0] = BOOLEAN_TO_INT64(ctx->Eval.Map1Attrib[5]); + break; + case GL_MAP1_VERTEX_ATTRIB6_4_NV: + CHECK_EXT1(NV_vertex_program, "GetInteger64v"); + params[0] = BOOLEAN_TO_INT64(ctx->Eval.Map1Attrib[6]); + break; + case GL_MAP1_VERTEX_ATTRIB7_4_NV: + CHECK_EXT1(NV_vertex_program, "GetInteger64v"); + params[0] = BOOLEAN_TO_INT64(ctx->Eval.Map1Attrib[7]); + break; + case GL_MAP1_VERTEX_ATTRIB8_4_NV: + CHECK_EXT1(NV_vertex_program, "GetInteger64v"); + params[0] = BOOLEAN_TO_INT64(ctx->Eval.Map1Attrib[8]); + break; + case GL_MAP1_VERTEX_ATTRIB9_4_NV: + CHECK_EXT1(NV_vertex_program, "GetInteger64v"); + params[0] = BOOLEAN_TO_INT64(ctx->Eval.Map1Attrib[9]); + break; + case GL_MAP1_VERTEX_ATTRIB10_4_NV: + CHECK_EXT1(NV_vertex_program, "GetInteger64v"); + params[0] = BOOLEAN_TO_INT64(ctx->Eval.Map1Attrib[10]); + break; + case GL_MAP1_VERTEX_ATTRIB11_4_NV: + CHECK_EXT1(NV_vertex_program, "GetInteger64v"); + params[0] = BOOLEAN_TO_INT64(ctx->Eval.Map1Attrib[11]); + break; + case GL_MAP1_VERTEX_ATTRIB12_4_NV: + CHECK_EXT1(NV_vertex_program, "GetInteger64v"); + params[0] = BOOLEAN_TO_INT64(ctx->Eval.Map1Attrib[12]); + break; + case GL_MAP1_VERTEX_ATTRIB13_4_NV: + CHECK_EXT1(NV_vertex_program, "GetInteger64v"); + params[0] = BOOLEAN_TO_INT64(ctx->Eval.Map1Attrib[13]); + break; + case GL_MAP1_VERTEX_ATTRIB14_4_NV: + CHECK_EXT1(NV_vertex_program, "GetInteger64v"); + params[0] = BOOLEAN_TO_INT64(ctx->Eval.Map1Attrib[14]); + break; + case GL_MAP1_VERTEX_ATTRIB15_4_NV: + CHECK_EXT1(NV_vertex_program, "GetInteger64v"); + params[0] = BOOLEAN_TO_INT64(ctx->Eval.Map1Attrib[15]); + break; + case GL_FRAGMENT_PROGRAM_NV: + CHECK_EXT1(NV_fragment_program, "GetInteger64v"); + params[0] = BOOLEAN_TO_INT64(ctx->FragmentProgram.Enabled); + break; + case GL_FRAGMENT_PROGRAM_BINDING_NV: + CHECK_EXT1(NV_fragment_program, "GetInteger64v"); + params[0] = ctx->FragmentProgram.Current ? ctx->FragmentProgram.Current->Base.Id : 0; + break; + case GL_MAX_FRAGMENT_PROGRAM_LOCAL_PARAMETERS_NV: + CHECK_EXT1(NV_fragment_program, "GetInteger64v"); + params[0] = MAX_NV_FRAGMENT_PROGRAM_PARAMS; + break; + case GL_TEXTURE_RECTANGLE_NV: + CHECK_EXT1(NV_texture_rectangle, "GetInteger64v"); + params[0] = BOOLEAN_TO_INT64(_mesa_IsEnabled(GL_TEXTURE_RECTANGLE_NV)); + break; + case GL_TEXTURE_BINDING_RECTANGLE_NV: + CHECK_EXT1(NV_texture_rectangle, "GetInteger64v"); + 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, "GetInteger64v"); + params[0] = ctx->Const.MaxTextureRectSize; + break; + case GL_STENCIL_TEST_TWO_SIDE_EXT: + CHECK_EXT1(EXT_stencil_two_side, "GetInteger64v"); + params[0] = BOOLEAN_TO_INT64(ctx->Stencil.TestTwoSide); + break; + case GL_ACTIVE_STENCIL_FACE_EXT: + CHECK_EXT1(EXT_stencil_two_side, "GetInteger64v"); + params[0] = ENUM_TO_INT64(ctx->Stencil.ActiveFace ? GL_BACK : GL_FRONT); + break; + case GL_MAX_SHININESS_NV: + CHECK_EXT1(NV_light_max_exponent, "GetInteger64v"); + params[0] = IROUND64(ctx->Const.MaxShininess); + break; + case GL_MAX_SPOT_EXPONENT_NV: + CHECK_EXT1(NV_light_max_exponent, "GetInteger64v"); + params[0] = IROUND64(ctx->Const.MaxSpotExponent); + break; + case GL_ARRAY_BUFFER_BINDING_ARB: + params[0] = ctx->Array.ArrayBufferObj->Name; + break; + case GL_VERTEX_ARRAY_BUFFER_BINDING_ARB: + params[0] = ctx->Array.ArrayObj->Vertex.BufferObj->Name; + break; + case GL_NORMAL_ARRAY_BUFFER_BINDING_ARB: + params[0] = ctx->Array.ArrayObj->Normal.BufferObj->Name; + break; + case GL_COLOR_ARRAY_BUFFER_BINDING_ARB: + params[0] = ctx->Array.ArrayObj->Color.BufferObj->Name; + break; + case GL_INDEX_ARRAY_BUFFER_BINDING_ARB: + params[0] = ctx->Array.ArrayObj->Index.BufferObj->Name; + break; + case GL_TEXTURE_COORD_ARRAY_BUFFER_BINDING_ARB: + params[0] = ctx->Array.ArrayObj->TexCoord[ctx->Array.ActiveTexture].BufferObj->Name; + break; + case GL_EDGE_FLAG_ARRAY_BUFFER_BINDING_ARB: + params[0] = ctx->Array.ArrayObj->EdgeFlag.BufferObj->Name; + break; + case GL_SECONDARY_COLOR_ARRAY_BUFFER_BINDING_ARB: + params[0] = ctx->Array.ArrayObj->SecondaryColor.BufferObj->Name; + break; + case GL_FOG_COORDINATE_ARRAY_BUFFER_BINDING_ARB: + params[0] = ctx->Array.ArrayObj->FogCoord.BufferObj->Name; + break; + case GL_ELEMENT_ARRAY_BUFFER_BINDING_ARB: + params[0] = ctx->Array.ElementArrayBufferObj->Name; + break; + case GL_PIXEL_PACK_BUFFER_BINDING_EXT: + CHECK_EXT1(EXT_pixel_buffer_object, "GetInteger64v"); + params[0] = ctx->Pack.BufferObj->Name; + break; + case GL_PIXEL_UNPACK_BUFFER_BINDING_EXT: + CHECK_EXT1(EXT_pixel_buffer_object, "GetInteger64v"); + params[0] = ctx->Unpack.BufferObj->Name; + break; + case GL_VERTEX_PROGRAM_ARB: + CHECK_EXT2(ARB_vertex_program, NV_vertex_program, "GetInteger64v"); + params[0] = BOOLEAN_TO_INT64(ctx->VertexProgram.Enabled); + break; + case GL_VERTEX_PROGRAM_POINT_SIZE_ARB: + CHECK_EXT2(ARB_vertex_program, NV_vertex_program, "GetInteger64v"); + params[0] = BOOLEAN_TO_INT64(ctx->VertexProgram.PointSizeEnabled); + break; + case GL_VERTEX_PROGRAM_TWO_SIDE_ARB: + CHECK_EXT2(ARB_vertex_program, NV_vertex_program, "GetInteger64v"); + params[0] = BOOLEAN_TO_INT64(ctx->VertexProgram.TwoSideEnabled); + break; + case GL_MAX_PROGRAM_MATRIX_STACK_DEPTH_ARB: + CHECK_EXT3(ARB_vertex_program, ARB_fragment_program, NV_vertex_program, "GetInteger64v"); + params[0] = ctx->Const.MaxProgramMatrixStackDepth; + break; + case GL_MAX_PROGRAM_MATRICES_ARB: + CHECK_EXT3(ARB_vertex_program, ARB_fragment_program, NV_vertex_program, "GetInteger64v"); + params[0] = ctx->Const.MaxProgramMatrices; + break; + case GL_CURRENT_MATRIX_STACK_DEPTH_ARB: + CHECK_EXT3(ARB_vertex_program, ARB_fragment_program, NV_vertex_program, "GetInteger64v"); + params[0] = BOOLEAN_TO_INT64(ctx->CurrentStack->Depth + 1); + break; + case GL_CURRENT_MATRIX_ARB: + CHECK_EXT3(ARB_vertex_program, ARB_fragment_program, NV_fragment_program, "GetInteger64v"); + { + const GLfloat *matrix = ctx->CurrentStack->Top->m; + params[0] = IROUND64(matrix[0]); + params[1] = IROUND64(matrix[1]); + params[2] = IROUND64(matrix[2]); + params[3] = IROUND64(matrix[3]); + params[4] = IROUND64(matrix[4]); + params[5] = IROUND64(matrix[5]); + params[6] = IROUND64(matrix[6]); + params[7] = IROUND64(matrix[7]); + params[8] = IROUND64(matrix[8]); + params[9] = IROUND64(matrix[9]); + params[10] = IROUND64(matrix[10]); + params[11] = IROUND64(matrix[11]); + params[12] = IROUND64(matrix[12]); + params[13] = IROUND64(matrix[13]); + params[14] = IROUND64(matrix[14]); + params[15] = IROUND64(matrix[15]); + } + break; + case GL_TRANSPOSE_CURRENT_MATRIX_ARB: + CHECK_EXT2(ARB_vertex_program, ARB_fragment_program, "GetInteger64v"); + { + const GLfloat *matrix = ctx->CurrentStack->Top->m; + params[0] = IROUND64(matrix[0]); + params[1] = IROUND64(matrix[4]); + params[2] = IROUND64(matrix[8]); + params[3] = IROUND64(matrix[12]); + params[4] = IROUND64(matrix[1]); + params[5] = IROUND64(matrix[5]); + params[6] = IROUND64(matrix[9]); + params[7] = IROUND64(matrix[13]); + params[8] = IROUND64(matrix[2]); + params[9] = IROUND64(matrix[6]); + params[10] = IROUND64(matrix[10]); + params[11] = IROUND64(matrix[14]); + params[12] = IROUND64(matrix[3]); + params[13] = IROUND64(matrix[7]); + params[14] = IROUND64(matrix[11]); + params[15] = IROUND64(matrix[15]); + } + break; + case GL_MAX_VERTEX_ATTRIBS_ARB: + CHECK_EXT1(ARB_vertex_program, "GetInteger64v"); + params[0] = ctx->Const.VertexProgram.MaxAttribs; + break; + case GL_PROGRAM_ERROR_POSITION_ARB: + CHECK_EXT4(NV_vertex_program, ARB_vertex_program, NV_fragment_program, ARB_fragment_program, "GetInteger64v"); + params[0] = ctx->Program.ErrorPos; + break; + case GL_FRAGMENT_PROGRAM_ARB: + CHECK_EXT1(ARB_fragment_program, "GetInteger64v"); + params[0] = BOOLEAN_TO_INT64(ctx->FragmentProgram.Enabled); + break; + case GL_MAX_TEXTURE_COORDS_ARB: + CHECK_EXT2(ARB_fragment_program, NV_fragment_program, "GetInteger64v"); + params[0] = ctx->Const.MaxTextureCoordUnits; + break; + case GL_MAX_TEXTURE_IMAGE_UNITS_ARB: + CHECK_EXT2(ARB_fragment_program, NV_fragment_program, "GetInteger64v"); + params[0] = ctx->Const.MaxTextureImageUnits; + break; + case GL_DEPTH_BOUNDS_TEST_EXT: + CHECK_EXT1(EXT_depth_bounds_test, "GetInteger64v"); + params[0] = BOOLEAN_TO_INT64(ctx->Depth.BoundsTest); + break; + case GL_DEPTH_BOUNDS_EXT: + CHECK_EXT1(EXT_depth_bounds_test, "GetInteger64v"); + params[0] = IROUND64(ctx->Depth.BoundsMin); + params[1] = IROUND64(ctx->Depth.BoundsMax); + break; + case GL_MAX_DRAW_BUFFERS_ARB: + params[0] = ctx->Const.MaxDrawBuffers; + break; + case GL_DRAW_BUFFER0_ARB: + params[0] = ENUM_TO_INT64(ctx->DrawBuffer->ColorDrawBuffer[0]); + break; + case GL_DRAW_BUFFER1_ARB: + { + GLenum buffer; + if (pname - GL_DRAW_BUFFER0_ARB >= ctx->Const.MaxDrawBuffers) { + _mesa_error(ctx, GL_INVALID_ENUM, "glGet(GL_DRAW_BUFFERx_ARB)"); + return; + } + buffer = ctx->DrawBuffer->ColorDrawBuffer[1]; + params[0] = ENUM_TO_INT64(buffer); + } + break; + case GL_DRAW_BUFFER2_ARB: + { + GLenum buffer; + if (pname - GL_DRAW_BUFFER0_ARB >= ctx->Const.MaxDrawBuffers) { + _mesa_error(ctx, GL_INVALID_ENUM, "glGet(GL_DRAW_BUFFERx_ARB)"); + return; + } + buffer = ctx->DrawBuffer->ColorDrawBuffer[2]; + params[0] = ENUM_TO_INT64(buffer); + } + break; + case GL_DRAW_BUFFER3_ARB: + { + GLenum buffer; + if (pname - GL_DRAW_BUFFER0_ARB >= ctx->Const.MaxDrawBuffers) { + _mesa_error(ctx, GL_INVALID_ENUM, "glGet(GL_DRAW_BUFFERx_ARB)"); + return; + } + buffer = ctx->DrawBuffer->ColorDrawBuffer[3]; + params[0] = ENUM_TO_INT64(buffer); + } + break; + case GL_IMPLEMENTATION_COLOR_READ_TYPE_OES: + CHECK_EXT1(OES_read_format, "GetInteger64v"); + params[0] = ctx->Const.ColorReadType; + break; + case GL_IMPLEMENTATION_COLOR_READ_FORMAT_OES: + CHECK_EXT1(OES_read_format, "GetInteger64v"); + params[0] = ctx->Const.ColorReadFormat; + break; + case GL_NUM_FRAGMENT_REGISTERS_ATI: + CHECK_EXT1(ATI_fragment_shader, "GetInteger64v"); + params[0] = 6; + break; + case GL_NUM_FRAGMENT_CONSTANTS_ATI: + CHECK_EXT1(ATI_fragment_shader, "GetInteger64v"); + params[0] = 8; + break; + case GL_NUM_PASSES_ATI: + CHECK_EXT1(ATI_fragment_shader, "GetInteger64v"); + params[0] = 2; + break; + case GL_NUM_INSTRUCTIONS_PER_PASS_ATI: + CHECK_EXT1(ATI_fragment_shader, "GetInteger64v"); + params[0] = 8; + break; + case GL_NUM_INSTRUCTIONS_TOTAL_ATI: + CHECK_EXT1(ATI_fragment_shader, "GetInteger64v"); + params[0] = 16; + break; + case GL_COLOR_ALPHA_PAIRING_ATI: + CHECK_EXT1(ATI_fragment_shader, "GetInteger64v"); + params[0] = BOOLEAN_TO_INT64(GL_TRUE); + break; + case GL_NUM_LOOPBACK_COMPONENTS_ATI: + CHECK_EXT1(ATI_fragment_shader, "GetInteger64v"); + params[0] = 3; + break; + case GL_NUM_INPUT_INTERPOLATOR_COMPONENTS_ATI: + CHECK_EXT1(ATI_fragment_shader, "GetInteger64v"); + params[0] = 3; + break; + case GL_STENCIL_BACK_FUNC: + params[0] = ENUM_TO_INT64(ctx->Stencil.Function[1]); + break; + case GL_STENCIL_BACK_VALUE_MASK: + params[0] = ctx->Stencil.ValueMask[1]; + break; + case GL_STENCIL_BACK_WRITEMASK: + params[0] = ctx->Stencil.WriteMask[1]; + break; + case GL_STENCIL_BACK_REF: + params[0] = ctx->Stencil.Ref[1]; + break; + case GL_STENCIL_BACK_FAIL: + params[0] = ENUM_TO_INT64(ctx->Stencil.FailFunc[1]); + break; + case GL_STENCIL_BACK_PASS_DEPTH_FAIL: + params[0] = ENUM_TO_INT64(ctx->Stencil.ZFailFunc[1]); + break; + case GL_STENCIL_BACK_PASS_DEPTH_PASS: + params[0] = ENUM_TO_INT64(ctx->Stencil.ZPassFunc[1]); + break; + case GL_FRAMEBUFFER_BINDING_EXT: + CHECK_EXT1(EXT_framebuffer_object, "GetInteger64v"); + params[0] = ctx->DrawBuffer->Name; + break; + case GL_RENDERBUFFER_BINDING_EXT: + CHECK_EXT1(EXT_framebuffer_object, "GetInteger64v"); + params[0] = ctx->CurrentRenderbuffer ? ctx->CurrentRenderbuffer->Name : 0; + break; + case GL_MAX_COLOR_ATTACHMENTS_EXT: + CHECK_EXT1(EXT_framebuffer_object, "GetInteger64v"); + params[0] = ctx->Const.MaxColorAttachments; + break; + case GL_MAX_RENDERBUFFER_SIZE_EXT: + CHECK_EXT1(EXT_framebuffer_object, "GetInteger64v"); + params[0] = ctx->Const.MaxRenderbufferSize; + break; + case GL_READ_FRAMEBUFFER_BINDING_EXT: + CHECK_EXT1(EXT_framebuffer_blit, "GetInteger64v"); + params[0] = ctx->ReadBuffer->Name; + break; + case GL_PROVOKING_VERTEX_EXT: + CHECK_EXT1(EXT_provoking_vertex, "GetInteger64v"); + params[0] = BOOLEAN_TO_INT64(ctx->Light.ProvokingVertex); + break; + case GL_QUADS_FOLLOW_PROVOKING_VERTEX_CONVENTION_EXT: + CHECK_EXT1(EXT_provoking_vertex, "GetInteger64v"); + params[0] = BOOLEAN_TO_INT64(ctx->Const.QuadsFollowProvokingVertexConvention); + break; + case GL_MAX_FRAGMENT_UNIFORM_COMPONENTS_ARB: + CHECK_EXT1(ARB_fragment_shader, "GetInteger64v"); + params[0] = ctx->Const.FragmentProgram.MaxUniformComponents; + break; + case GL_FRAGMENT_SHADER_DERIVATIVE_HINT_ARB: + CHECK_EXT1(ARB_fragment_shader, "GetInteger64v"); + params[0] = ENUM_TO_INT64(ctx->Hint.FragmentShaderDerivative); + break; + case GL_MAX_VERTEX_UNIFORM_COMPONENTS_ARB: + CHECK_EXT1(ARB_vertex_shader, "GetInteger64v"); + params[0] = ctx->Const.VertexProgram.MaxUniformComponents; + break; + case GL_MAX_VARYING_FLOATS_ARB: + CHECK_EXT1(ARB_vertex_shader, "GetInteger64v"); + params[0] = ctx->Const.MaxVarying * 4; + break; + case GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS_ARB: + CHECK_EXT1(ARB_vertex_shader, "GetInteger64v"); + params[0] = ctx->Const.MaxVertexTextureImageUnits; + break; + case GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS_ARB: + CHECK_EXT1(ARB_vertex_shader, "GetInteger64v"); + params[0] = MAX_COMBINED_TEXTURE_IMAGE_UNITS; + break; + case GL_CURRENT_PROGRAM: + CHECK_EXT1(ARB_shader_objects, "GetInteger64v"); + params[0] = ctx->Shader.CurrentProgram ? ctx->Shader.CurrentProgram->Name : 0; + break; + case GL_MAX_SAMPLES: + CHECK_EXT1(ARB_framebuffer_object, "GetInteger64v"); + params[0] = ctx->Const.MaxSamples; + break; + case GL_VERTEX_ARRAY_BINDING_APPLE: + CHECK_EXT1(APPLE_vertex_array_object, "GetInteger64v"); + params[0] = ctx->Array.ArrayObj->Name; + break; + case GL_TEXTURE_CUBE_MAP_SEAMLESS: + CHECK_EXT1(ARB_seamless_cube_map, "GetInteger64v"); + params[0] = BOOLEAN_TO_INT64(ctx->Texture.CubeMapSeamless); + break; + case GL_MAX_SERVER_WAIT_TIMEOUT: + CHECK_EXT1(ARB_sync, "GetInteger64v"); + params[0] = ctx->Const.MaxServerWaitTimeout; + break; + default: + _mesa_error(ctx, GL_INVALID_ENUM, "glGetInteger64v(pname=0x%x)", pname); + } +} +#endif /* FEATURE_ARB_sync */ + void GLAPIENTRY _mesa_GetDoublev( GLenum pname, GLdouble *params ) diff --git a/src/mesa/main/get.h b/src/mesa/main/get.h index 9b47b230a9..77a9a7d04b 100644 --- a/src/mesa/main/get.h +++ b/src/mesa/main/get.h @@ -48,6 +48,9 @@ extern void GLAPIENTRY _mesa_GetIntegerv( GLenum pname, GLint *params ); extern void GLAPIENTRY +_mesa_GetInteger64v( GLenum pname, GLint64 *params ); + +extern void GLAPIENTRY _mesa_GetPointerv( GLenum pname, GLvoid **params ); extern const GLubyte * GLAPIENTRY diff --git a/src/mesa/main/get_gen.py b/src/mesa/main/get_gen.py index 43ee5fff10..2878c1b552 100644 --- a/src/mesa/main/get_gen.py +++ b/src/mesa/main/get_gen.py @@ -35,6 +35,7 @@ GLfloat = 3 GLdouble = 4 GLboolean = 5 GLfloatN = 6 # A normalized value, such as a color or depth range +GLint64 = 7 TypeStrings = { @@ -42,7 +43,8 @@ TypeStrings = { GLenum : "GLenum", GLfloat : "GLfloat", GLdouble : "GLdouble", - GLboolean : "GLboolean" + GLboolean : "GLboolean", + GLint64 : "GLint64" } @@ -176,7 +178,8 @@ StateVars = [ "ctx->Current.Attrib[VERT_ATTRIB_TEX0 + texUnit][1]", "ctx->Current.Attrib[VERT_ATTRIB_TEX0 + texUnit][2]", "ctx->Current.Attrib[VERT_ATTRIB_TEX0 + texUnit][3]"], - "const GLuint texUnit = ctx->Texture.CurrentUnit;", None ), + """const GLuint texUnit = ctx->Texture.CurrentUnit; + FLUSH_CURRENT(ctx, 0);""", None ), ( "GL_DEPTH_BIAS", GLfloat, ["ctx->Pixel.DepthBias"], "", None ), ( "GL_DEPTH_BITS", GLint, ["ctx->DrawBuffer->Visual.depthBits"], "", None ), @@ -976,6 +979,13 @@ StateVars = [ ( "GL_READ_FRAMEBUFFER_BINDING_EXT", GLint, ["ctx->ReadBuffer->Name"], "", ["EXT_framebuffer_blit"] ), + # GL_EXT_provoking_vertex + ( "GL_PROVOKING_VERTEX_EXT", GLboolean, + ["ctx->Light.ProvokingVertex"], "", ["EXT_provoking_vertex"] ), + ( "GL_QUADS_FOLLOW_PROVOKING_VERTEX_CONVENTION_EXT", GLboolean, + ["ctx->Const.QuadsFollowProvokingVertexConvention"], "", + ["EXT_provoking_vertex"] ), + # GL_ARB_fragment_shader ( "GL_MAX_FRAGMENT_UNIFORM_COMPONENTS_ARB", GLint, ["ctx->Const.FragmentProgram.MaxUniformComponents"], "", @@ -1008,6 +1018,14 @@ StateVars = [ # GL_APPLE_vertex_array_object ( "GL_VERTEX_ARRAY_BINDING_APPLE", GLint, ["ctx->Array.ArrayObj->Name"], "", ["APPLE_vertex_array_object"] ), + + # GL_ARB_seamless_cube_map + ( "GL_TEXTURE_CUBE_MAP_SEAMLESS", GLboolean, ["ctx->Texture.CubeMapSeamless"], "", + ["ARB_seamless_cube_map"] ), + + # GL_ARB_sync + ( "GL_MAX_SERVER_WAIT_TIMEOUT", GLint64, ["ctx->Const.MaxServerWaitTimeout"], "", + ["ARB_sync"] ), ] @@ -1017,10 +1035,16 @@ def ConversionFunc(fromType, toType): return "" elif fromType == GLfloat and toType == GLint: return "IROUND" + elif fromType == GLfloat and toType == GLint64: + return "IROUND64" elif fromType == GLfloatN and toType == GLfloat: return "" elif fromType == GLint and toType == GLfloat: # but not GLfloatN! return "(GLfloat)" + elif fromType == GLint and toType == GLint64: + return "" + elif fromType == GLint64 and toType == GLfloat: # but not GLfloatN! + return "(GLfloat)" else: if fromType == GLfloatN: fromType = GLfloat @@ -1035,6 +1059,7 @@ def EmitGetFunction(stateVars, returnType): """Emit the code to implement glGetBooleanv, glGetIntegerv or glGetFloatv.""" assert (returnType == GLboolean or returnType == GLint or + returnType == GLint64 or returnType == GLfloat) strType = TypeStrings[returnType] @@ -1045,9 +1070,14 @@ def EmitGetFunction(stateVars, returnType): function = "GetBooleanv" elif returnType == GLfloat: function = "GetFloatv" + elif returnType == GLint64: + function = "GetInteger64v" else: abort() + if returnType == GLint64: + print "#if FEATURE_ARB_sync" + print "void GLAPIENTRY" print "_mesa_%s( GLenum pname, %s *params )" % (function, strType) print "{" @@ -1101,6 +1131,8 @@ def EmitGetFunction(stateVars, returnType): print ' _mesa_error(ctx, GL_INVALID_ENUM, "gl%s(pname=0x%%x)", pname);' % function print " }" print "}" + if returnType == GLint64: + print "#endif /* FEATURE_ARB_sync */" print "" return @@ -1129,9 +1161,15 @@ def EmitHeader(): #define INT_TO_BOOLEAN(I) ( (I) ? GL_TRUE : GL_FALSE ) +#define INT64_TO_BOOLEAN(I) ( (I) ? GL_TRUE : GL_FALSE ) +#define INT64_TO_INT(I) ( (GLint)((I > INT_MAX) ? INT_MAX : ((I < INT_MIN) ? INT_MIN : (I))) ) + #define BOOLEAN_TO_INT(B) ( (GLint) (B) ) +#define BOOLEAN_TO_INT64(B) ( (GLint64) (B) ) #define BOOLEAN_TO_FLOAT(B) ( (B) ? 1.0F : 0.0F ) +#define ENUM_TO_INT64(E) ( (GLint64) (E) ) + /* * Check if named extension is enabled, if not generate error and return. @@ -1209,5 +1247,6 @@ EmitHeader() EmitGetFunction(StateVars, GLboolean) EmitGetFunction(StateVars, GLfloat) EmitGetFunction(StateVars, GLint) +EmitGetFunction(StateVars, GLint64) EmitGetDoublev() diff --git a/src/mesa/main/getstring.c b/src/mesa/main/getstring.c index 41fd786d7d..6599ed9698 100644 --- a/src/mesa/main/getstring.c +++ b/src/mesa/main/getstring.c @@ -266,5 +266,6 @@ _mesa_GetError( void ) _mesa_debug(ctx, "glGetError <-- %s\n", _mesa_lookup_enum_by_nr(e)); ctx->ErrorValue = (GLenum) GL_NO_ERROR; + ctx->ErrorDebugCount = 0; return e; } diff --git a/src/mesa/main/histogram.c b/src/mesa/main/histogram.c index 5fee4fd0e3..ceb0d5a6a8 100644 --- a/src/mesa/main/histogram.c +++ b/src/mesa/main/histogram.c @@ -649,29 +649,11 @@ _mesa_GetMinmax(GLenum target, GLboolean reset, GLenum format, GLenum type, GLvo return; } - if (ctx->Pack.BufferObj->Name) { - /* pack min/max values into a PBO */ - GLubyte *buf; - if (!_mesa_validate_pbo_access(1, &ctx->Pack, 2, 1, 1, - format, type, values)) { - _mesa_error(ctx, GL_INVALID_OPERATION, - "glGetMinMax(invalid PBO access)"); - return; - } - buf = (GLubyte *) ctx->Driver.MapBuffer(ctx, GL_PIXEL_PACK_BUFFER_EXT, - GL_WRITE_ONLY_ARB, - ctx->Pack.BufferObj); - if (!buf) { - /* buffer is already mapped - that's an error */ - _mesa_error(ctx, GL_INVALID_OPERATION,"glGetMinMax(PBO is mapped)"); - return; - } - values = ADD_POINTERS(buf, values); - } - else if (!values) { - /* not an error */ + + values = _mesa_map_validate_pbo_dest(ctx, 1, &ctx->Pack, 2, 1, 1, + format, type, values, "glGetMinmax"); + if (!values) return; - } { GLfloat minmax[2][4]; @@ -687,10 +669,7 @@ _mesa_GetMinmax(GLenum target, GLboolean reset, GLenum format, GLenum type, GLvo format, type, values, &ctx->Pack, 0x0); } - if (ctx->Pack.BufferObj->Name) { - ctx->Driver.UnmapBuffer(ctx, GL_PIXEL_PACK_BUFFER_EXT, - ctx->Pack.BufferObj); - } + _mesa_unmap_pbo_dest(ctx, &ctx->Pack); if (reset) { _mesa_ResetMinmax(GL_MINMAX); @@ -733,38 +712,18 @@ _mesa_GetHistogram(GLenum target, GLboolean reset, GLenum format, GLenum type, G return; } - if (ctx->Pack.BufferObj->Name) { - /* pack min/max values into a PBO */ - GLubyte *buf; - if (!_mesa_validate_pbo_access(1, &ctx->Pack, ctx->Histogram.Width, 1, 1, - format, type, values)) { - _mesa_error(ctx, GL_INVALID_OPERATION, - "glGetHistogram(invalid PBO access)"); - return; - } - buf = (GLubyte *) ctx->Driver.MapBuffer(ctx, GL_PIXEL_PACK_BUFFER_EXT, - GL_WRITE_ONLY_ARB, - ctx->Pack.BufferObj); - if (!buf) { - /* buffer is already mapped - that's an error */ - _mesa_error(ctx,GL_INVALID_OPERATION,"glGetHistogram(PBO is mapped)"); - return; - } - values = ADD_POINTERS(buf, values); - } - else if (!values) { - /* not an error */ + values = _mesa_map_validate_pbo_dest(ctx, 1, &ctx->Pack, + ctx->Histogram.Width, 1, 1, + format, type, values, + "glGetHistogram"); + if (!values) return; - } pack_histogram(ctx, ctx->Histogram.Width, (CONST GLuint (*)[4]) ctx->Histogram.Count, format, type, values, &ctx->Pack); - if (ctx->Pack.BufferObj->Name) { - ctx->Driver.UnmapBuffer(ctx, GL_PIXEL_PACK_BUFFER_EXT, - ctx->Pack.BufferObj); - } + _mesa_unmap_pbo_dest(ctx, &ctx->Pack); if (reset) { GLuint i; diff --git a/src/mesa/main/image.c b/src/mesa/main/image.c index 1a4d22256f..baecbab0a3 100644 --- a/src/mesa/main/image.c +++ b/src/mesa/main/image.c @@ -182,6 +182,8 @@ _mesa_sizeof_type( GLenum type ) return sizeof(GLint); case GL_FLOAT: return sizeof(GLfloat); + case GL_DOUBLE: + return sizeof(GLdouble); case GL_HALF_FLOAT_ARB: return sizeof(GLhalfARB); default: @@ -529,6 +531,226 @@ _mesa_is_legal_format_and_type( GLcontext *ctx, GLenum format, GLenum type ) /** + * Test if the given image format is a color/RGBA format (i.e., not color + * index, depth, stencil, etc). + * \param format the image format value (may by an internal texture format) + * \return GL_TRUE if its a color/RGBA format, GL_FALSE otherwise. + */ +GLboolean +_mesa_is_color_format(GLenum format) +{ + switch (format) { + case GL_RED: + case GL_GREEN: + case GL_BLUE: + case GL_ALPHA: + case GL_ALPHA4: + case GL_ALPHA8: + case GL_ALPHA12: + case GL_ALPHA16: + case 1: + case GL_LUMINANCE: + case GL_LUMINANCE4: + case GL_LUMINANCE8: + case GL_LUMINANCE12: + case GL_LUMINANCE16: + case 2: + case GL_LUMINANCE_ALPHA: + case GL_LUMINANCE4_ALPHA4: + case GL_LUMINANCE6_ALPHA2: + case GL_LUMINANCE8_ALPHA8: + case GL_LUMINANCE12_ALPHA4: + case GL_LUMINANCE12_ALPHA12: + case GL_LUMINANCE16_ALPHA16: + case GL_INTENSITY: + case GL_INTENSITY4: + case GL_INTENSITY8: + case GL_INTENSITY12: + case GL_INTENSITY16: + case 3: + case GL_RGB: + case GL_BGR: + case GL_R3_G3_B2: + case GL_RGB4: + case GL_RGB5: + case GL_RGB8: + case GL_RGB10: + case GL_RGB12: + case GL_RGB16: + case 4: + case GL_ABGR_EXT: + case GL_RGBA: + case GL_BGRA: + case GL_RGBA2: + case GL_RGBA4: + case GL_RGB5_A1: + case GL_RGBA8: + case GL_RGB10_A2: + case GL_RGBA12: + case GL_RGBA16: + /* float texture formats */ + case GL_ALPHA16F_ARB: + case GL_ALPHA32F_ARB: + case GL_LUMINANCE16F_ARB: + case GL_LUMINANCE32F_ARB: + case GL_LUMINANCE_ALPHA16F_ARB: + case GL_LUMINANCE_ALPHA32F_ARB: + case GL_INTENSITY16F_ARB: + case GL_INTENSITY32F_ARB: + case GL_RGB16F_ARB: + case GL_RGB32F_ARB: + case GL_RGBA16F_ARB: + case GL_RGBA32F_ARB: + /* compressed formats */ + case GL_COMPRESSED_ALPHA: + case GL_COMPRESSED_LUMINANCE: + case GL_COMPRESSED_LUMINANCE_ALPHA: + case GL_COMPRESSED_INTENSITY: + case GL_COMPRESSED_RGB: + case GL_COMPRESSED_RGBA: + case GL_RGB_S3TC: + case GL_RGB4_S3TC: + case GL_RGBA_S3TC: + case GL_RGBA4_S3TC: + case GL_COMPRESSED_RGB_S3TC_DXT1_EXT: + case GL_COMPRESSED_RGBA_S3TC_DXT1_EXT: + case GL_COMPRESSED_RGBA_S3TC_DXT3_EXT: + case GL_COMPRESSED_RGBA_S3TC_DXT5_EXT: + case GL_COMPRESSED_RGB_FXT1_3DFX: + case GL_COMPRESSED_RGBA_FXT1_3DFX: +#if FEATURE_EXT_texture_sRGB + case GL_SRGB_EXT: + case GL_SRGB8_EXT: + case GL_SRGB_ALPHA_EXT: + case GL_SRGB8_ALPHA8_EXT: + case GL_SLUMINANCE_ALPHA_EXT: + case GL_SLUMINANCE8_ALPHA8_EXT: + case GL_SLUMINANCE_EXT: + case GL_SLUMINANCE8_EXT: + case GL_COMPRESSED_SRGB_EXT: + case GL_COMPRESSED_SRGB_S3TC_DXT1_EXT: + case GL_COMPRESSED_SRGB_ALPHA_EXT: + case GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT: + case GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT: + case GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT: + case GL_COMPRESSED_SLUMINANCE_EXT: + case GL_COMPRESSED_SLUMINANCE_ALPHA_EXT: +#endif /* FEATURE_EXT_texture_sRGB */ + return GL_TRUE; + /* signed texture formats */ + case GL_RGBA_SNORM: + case GL_RGBA8_SNORM: + return GL_TRUE; + case GL_YCBCR_MESA: /* not considered to be RGB */ + /* fall-through */ + default: + return GL_FALSE; + } +} + + +/** + * Test if the given image format is a color index format. + */ +GLboolean +_mesa_is_index_format(GLenum format) +{ + switch (format) { + case GL_COLOR_INDEX: + case GL_COLOR_INDEX1_EXT: + case GL_COLOR_INDEX2_EXT: + case GL_COLOR_INDEX4_EXT: + case GL_COLOR_INDEX8_EXT: + case GL_COLOR_INDEX12_EXT: + case GL_COLOR_INDEX16_EXT: + return GL_TRUE; + default: + return GL_FALSE; + } +} + + +/** + * Test if the given image format is a depth component format. + */ +GLboolean +_mesa_is_depth_format(GLenum format) +{ + switch (format) { + case GL_DEPTH_COMPONENT: + case GL_DEPTH_COMPONENT16: + case GL_DEPTH_COMPONENT24: + case GL_DEPTH_COMPONENT32: + return GL_TRUE; + default: + return GL_FALSE; + } +} + + +/** + * Test if the given image format is a stencil format. + */ +GLboolean +_mesa_is_stencil_format(GLenum format) +{ + switch (format) { + case GL_STENCIL_INDEX: + case GL_DEPTH_STENCIL: + return GL_TRUE; + default: + return GL_FALSE; + } +} + + +/** + * Test if the given image format is a YCbCr format. + */ +GLboolean +_mesa_is_ycbcr_format(GLenum format) +{ + switch (format) { + case GL_YCBCR_MESA: + return GL_TRUE; + default: + return GL_FALSE; + } +} + + +/** + * Test if the given image format is a depth+stencil format. + */ +GLboolean +_mesa_is_depthstencil_format(GLenum format) +{ + switch (format) { + case GL_DEPTH24_STENCIL8_EXT: + case GL_DEPTH_STENCIL_EXT: + return GL_TRUE; + default: + return GL_FALSE; + } +} + +/** + * Test if the given image format is a dudv format. + */ +GLboolean +_mesa_is_dudv_format(GLenum format) +{ + switch (format) { + case GL_DUDV_ATI: + case GL_DU8DV8_ATI: + return GL_TRUE; + default: + return GL_FALSE; + } +} + + +/** * Return the address of a specific pixel in an image (1D, 2D or 3D). * * Pixel unpacking/packing parameters are observed according to \p packing. @@ -1037,6 +1259,91 @@ _mesa_pack_bitmap( GLint width, GLint height, const GLubyte *source, } +/** + * "Expand" a bitmap from 1-bit per pixel to 8-bits per pixel. + * This is typically used to convert a bitmap into a GLubyte/pixel texture. + * "On" bits will set texels to \p onValue. + * "Off" bits will not modify texels. + * \param width src bitmap width in pixels + * \param height src bitmap height in pixels + * \param unpack bitmap unpacking state + * \param bitmap the src bitmap data + * \param destBuffer start of dest buffer + * \param destStride row stride in dest buffer + * \param onValue if bit is 1, set destBuffer pixel to this value + */ +void +_mesa_expand_bitmap(GLsizei width, GLsizei height, + const struct gl_pixelstore_attrib *unpack, + const GLubyte *bitmap, + GLubyte *destBuffer, GLint destStride, + GLubyte onValue) +{ + const GLubyte *srcRow = (const GLubyte *) + _mesa_image_address2d(unpack, bitmap, width, height, + GL_COLOR_INDEX, GL_BITMAP, 0, 0); + const GLint srcStride = _mesa_image_row_stride(unpack, width, + GL_COLOR_INDEX, GL_BITMAP); + GLint row, col; + +#define SET_PIXEL(COL, ROW) \ + destBuffer[(ROW) * destStride + (COL)] = onValue; + + for (row = 0; row < height; row++) { + const GLubyte *src = srcRow; + + if (unpack->LsbFirst) { + /* Lsb first */ + GLubyte mask = 1U << (unpack->SkipPixels & 0x7); + for (col = 0; col < width; col++) { + + if (*src & mask) { + SET_PIXEL(col, row); + } + + if (mask == 128U) { + src++; + mask = 1U; + } + else { + mask = mask << 1; + } + } + + /* get ready for next row */ + if (mask != 1) + src++; + } + else { + /* Msb first */ + GLubyte mask = 128U >> (unpack->SkipPixels & 0x7); + for (col = 0; col < width; col++) { + + if (*src & mask) { + SET_PIXEL(col, row); + } + + if (mask == 1U) { + src++; + mask = 128U; + } + else { + mask = mask >> 1; + } + } + + /* get ready for next row */ + if (mask != 128) + src++; + } + + srcRow += srcStride; + } /* row */ + +#undef SET_PIXEL +} + + /**********************************************************************/ /***** Pixel processing functions ******/ /**********************************************************************/ diff --git a/src/mesa/main/image.h b/src/mesa/main/image.h index ee17accb80..72717d6787 100644 --- a/src/mesa/main/image.h +++ b/src/mesa/main/image.h @@ -54,6 +54,27 @@ _mesa_bytes_per_pixel( GLenum format, GLenum type ); extern GLboolean _mesa_is_legal_format_and_type( GLcontext *ctx, GLenum format, GLenum type ); +extern GLboolean +_mesa_is_color_format(GLenum format); + +extern GLboolean +_mesa_is_index_format(GLenum format); + +extern GLboolean +_mesa_is_depth_format(GLenum format); + +extern GLboolean +_mesa_is_stencil_format(GLenum format); + +extern GLboolean +_mesa_is_ycbcr_format(GLenum format); + +extern GLboolean +_mesa_is_depthstencil_format(GLenum format); + +extern GLboolean +_mesa_is_dudv_format(GLenum format); + extern GLvoid * _mesa_image_address( GLuint dimensions, @@ -113,6 +134,13 @@ extern void _mesa_pack_bitmap( GLint width, GLint height, const GLubyte *source, GLubyte *dest, const struct gl_pixelstore_attrib *packing ); +extern void +_mesa_expand_bitmap(GLsizei width, GLsizei height, + const struct gl_pixelstore_attrib *unpack, + const GLubyte *bitmap, + GLubyte *destBuffer, GLint destStride, + GLubyte onValue); + /** \name Pixel processing functions */ /*@{*/ diff --git a/src/mesa/main/imports.c b/src/mesa/main/imports.c index 1722579e82..6ffaddcde9 100644 --- a/src/mesa/main/imports.c +++ b/src/mesa/main/imports.c @@ -911,6 +911,20 @@ _mesa_strtod( const char *s, char **end ) return strtod(s, end); } +/** Compute simple checksum/hash for a string */ +unsigned int +_mesa_str_checksum(const char *str) +{ + /* This could probably be much better */ + unsigned int sum, i; + const char *c; + sum = i = 1; + for (c = str; *c; c++) + sum += *c * (i % 100); + return sum; +} + + /*@}*/ @@ -1021,23 +1035,59 @@ output_if_debug(const char *prefixString, const char *outputString, } } -static const char *error_string( GLenum error ); -static void flush_delayed_errors( GLcontext *ctx ) +/** + * Return string version of GL error code. + */ +static const char * +error_string( GLenum error ) +{ + switch (error) { + case GL_NO_ERROR: + return "GL_NO_ERROR"; + case GL_INVALID_VALUE: + return "GL_INVALID_VALUE"; + case GL_INVALID_ENUM: + return "GL_INVALID_ENUM"; + case GL_INVALID_OPERATION: + return "GL_INVALID_OPERATION"; + case GL_STACK_OVERFLOW: + return "GL_STACK_OVERFLOW"; + case GL_STACK_UNDERFLOW: + return "GL_STACK_UNDERFLOW"; + case GL_OUT_OF_MEMORY: + return "GL_OUT_OF_MEMORY"; + case GL_TABLE_TOO_LARGE: + return "GL_TABLE_TOO_LARGE"; + case GL_INVALID_FRAMEBUFFER_OPERATION_EXT: + return "GL_INVALID_FRAMEBUFFER_OPERATION"; + default: + return "unknown"; + } +} + + +/** + * When a new type of error is recorded, print a message describing + * previous errors which were accumulated. + */ +static void +flush_delayed_errors( GLcontext *ctx ) { - char s2[MAXSTRING]; + char s[MAXSTRING]; if (ctx->ErrorDebugCount) { - _mesa_snprintf(s2, MAXSTRING, "%d similar %s errors", + _mesa_snprintf(s, MAXSTRING, "%d similar %s errors", ctx->ErrorDebugCount, error_string(ctx->ErrorValue)); - output_if_debug("Mesa: ", s2, GL_TRUE); + output_if_debug("Mesa", s, GL_TRUE); ctx->ErrorDebugCount = 0; } } + /** * Report a warning (a recoverable error condition) to stderr if * either DEBUG is defined or the MESA_DEBUG env var is set. @@ -1083,31 +1133,6 @@ _mesa_problem( const GLcontext *ctx, const char *fmtString, ... ) fprintf(stderr, "Please report at bugzilla.freedesktop.org\n"); } -static const char *error_string( GLenum error ) -{ - switch (error) { - case GL_NO_ERROR: - return "GL_NO_ERROR"; - case GL_INVALID_VALUE: - return "GL_INVALID_VALUE"; - case GL_INVALID_ENUM: - return "GL_INVALID_ENUM"; - case GL_INVALID_OPERATION: - return "GL_INVALID_OPERATION"; - case GL_STACK_OVERFLOW: - return "GL_STACK_OVERFLOW"; - case GL_STACK_UNDERFLOW: - return "GL_STACK_UNDERFLOW"; - case GL_OUT_OF_MEMORY: - return "GL_OUT_OF_MEMORY"; - case GL_TABLE_TOO_LARGE: - return "GL_TABLE_TOO_LARGE"; - case GL_INVALID_FRAMEBUFFER_OPERATION_EXT: - return "GL_INVALID_FRAMEBUFFER_OPERATION"; - default: - return "unknown"; - } -} /** * Record an OpenGL state error. These usually occur when the user diff --git a/src/mesa/main/imports.h b/src/mesa/main/imports.h index 7b61e22e93..7d4012a856 100644 --- a/src/mesa/main/imports.h +++ b/src/mesa/main/imports.h @@ -291,6 +291,7 @@ long iround(float f); #define IROUND(f) ((int) (((f) >= 0.0F) ? ((f) + 0.5F) : ((f) - 0.5F))) #endif +#define IROUND64(f) ((GLint64) (((f) >= 0.0F) ? ((f) + 0.5F) : ((f) - 0.5F))) /*** *** IROUND_POS: return (as an integer) positive float rounded to nearest int @@ -586,6 +587,9 @@ _mesa_atoi( const char *s ); extern double _mesa_strtod( const char *s, char **end ); +extern unsigned int +_mesa_str_checksum(const char *str); + extern int _mesa_sprintf( char *str, const char *fmt, ... ); diff --git a/src/mesa/main/light.c b/src/mesa/main/light.c index 7479fe8fc4..10c89f4368 100644 --- a/src/mesa/main/light.c +++ b/src/mesa/main/light.c @@ -1,8 +1,9 @@ /* * Mesa 3-D graphics library - * Version: 7.0 + * 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"), @@ -64,6 +65,37 @@ _mesa_ShadeModel( GLenum mode ) /** + * Set the provoking vertex (the vertex which specifies the prim's + * color when flat shading) to either the first or last vertex of the + * triangle or line. + */ +void GLAPIENTRY +_mesa_ProvokingVertexEXT(GLenum mode) +{ + GET_CURRENT_CONTEXT(ctx); + ASSERT_OUTSIDE_BEGIN_END(ctx); + + if (MESA_VERBOSE&VERBOSE_API) + _mesa_debug(ctx, "glProvokingVertexEXT 0x%x\n", mode); + + switch (mode) { + case GL_FIRST_VERTEX_CONVENTION_EXT: + case GL_LAST_VERTEX_CONVENTION_EXT: + break; + default: + _mesa_error(ctx, GL_INVALID_ENUM, "glProvokingVertexEXT(0x%x)", mode); + return; + } + + if (ctx->Light.ProvokingVertex == mode) + return; + + FLUSH_VERTICES(ctx, _NEW_LIGHT); + ctx->Light.ProvokingVertex = mode; +} + + +/** * Helper function called by _mesa_Lightfv and _mesa_PopAttrib to set * per-light state. * For GL_POSITION and GL_SPOT_DIRECTION the params position/direction @@ -1348,6 +1380,7 @@ _mesa_init_lighting( GLcontext *ctx ) init_lightmodel( &ctx->Light.Model ); init_material( &ctx->Light.Material ); ctx->Light.ShadeModel = GL_SMOOTH; + ctx->Light.ProvokingVertex = GL_LAST_VERTEX_CONVENTION_EXT; ctx->Light.Enabled = GL_FALSE; ctx->Light.ColorMaterialFace = GL_FRONT_AND_BACK; ctx->Light.ColorMaterialMode = GL_AMBIENT_AND_DIFFUSE; diff --git a/src/mesa/main/light.h b/src/mesa/main/light.h index b97e17b5be..9c1a5eefad 100644 --- a/src/mesa/main/light.h +++ b/src/mesa/main/light.h @@ -1,13 +1,9 @@ -/** - * \file light.h - * Lighting. - */ - /* * 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"), @@ -37,6 +33,10 @@ extern void GLAPIENTRY _mesa_ShadeModel( GLenum mode ); +extern void GLAPIENTRY +_mesa_ProvokingVertexEXT(GLenum mode); + + #if _HAVE_FULL_GL extern void GLAPIENTRY _mesa_ColorMaterial( GLenum face, GLenum mode ); diff --git a/src/mesa/main/macros.h b/src/mesa/main/macros.h index 4ca7957ffa..3d9a1aba98 100644 --- a/src/mesa/main/macros.h +++ b/src/mesa/main/macros.h @@ -99,6 +99,9 @@ extern GLfloat _mesa_ubyte_to_float_color_tab[256]; /* a close approximation: */ #define FLOAT_TO_INT(X) ( (GLint) (2147483647.0 * (X)) ) +/** Convert GLfloat in [-1.0,1.0] to GLint64 in [-(1<<63),(1 << 63) -1] */ +#define FLOAT_TO_INT64(X) ( (GLint64) (9223372036854775807.0 * (double)(X)) ) + /** Convert GLint in [-2147483648,2147483647] to GLfloat in [-1.0,1.0], texture/fb data */ #define INT_TO_FLOAT_TEX(I) ((I) == -2147483648 ? -1.0F : (I) * (1.0F/2147483647.0)) diff --git a/src/mesa/main/mfeatures.h b/src/mesa/main/mfeatures.h index 62c3ead3e1..e23cdb1f42 100644 --- a/src/mesa/main/mfeatures.h +++ b/src/mesa/main/mfeatures.h @@ -61,6 +61,7 @@ #define FEATURE_ARB_occlusion_query _HAVE_FULL_GL #define FEATURE_ARB_fragment_program _HAVE_FULL_GL #define FEATURE_ARB_framebuffer_object _HAVE_FULL_GL +#define FEATURE_ARB_map_buffer_range _HAVE_FULL_GL #define FEATURE_ARB_pixel_buffer_object _HAVE_FULL_GL #define FEATURE_ARB_vertex_buffer_object _HAVE_FULL_GL #define FEATURE_ARB_vertex_program _HAVE_FULL_GL @@ -69,6 +70,7 @@ #define FEATURE_ARB_shader_objects (FEATURE_ARB_vertex_shader || FEATURE_ARB_fragment_shader) #define FEATURE_ARB_shading_language_100 FEATURE_ARB_shader_objects #define FEATURE_ARB_shading_language_120 FEATURE_ARB_shader_objects +#define FEATURE_ARB_sync _HAVE_FULL_GL #define FEATURE_EXT_framebuffer_blit _HAVE_FULL_GL #define FEATURE_EXT_framebuffer_object _HAVE_FULL_GL diff --git a/src/mesa/main/mipmap.c b/src/mesa/main/mipmap.c index b306700484..3dca09d9f2 100644 --- a/src/mesa/main/mipmap.c +++ b/src/mesa/main/mipmap.c @@ -1481,9 +1481,12 @@ next_mipmap_level_size(GLenum target, GLint border, /** - * For GL_SGIX_generate_mipmap: - * Generate a complete set of mipmaps from texObj's base-level image. + * Automatic mipmap generation. + * This is the fallback/default function for ctx->Driver.GenerateMipmap(). + * Generate a complete set of mipmaps from texObj's BaseLevel image. * Stop at texObj's MaxLevel or when we get to the 1x1 texture. + * For cube maps, target will be one of + * GL_TEXTURE_CUBE_MAP_POSITIVE/NEGATIVE_X/Y/Z; never GL_TEXTURE_CUBE_MAP. */ void _mesa_generate_mipmap(GLcontext *ctx, GLenum target, diff --git a/src/mesa/main/mtypes.h b/src/mesa/main/mtypes.h index 3b0ebcb7ae..6b64bf8139 100644 --- a/src/mesa/main/mtypes.h +++ b/src/mesa/main/mtypes.h @@ -40,6 +40,7 @@ #include "main/mfeatures.h" #include "glapi/glapi.h" #include "math/m_matrix.h" /* GLmatrix */ +#include "main/simple_list.h" /* struct simple_node */ /** @@ -83,6 +84,7 @@ /*@{*/ struct _mesa_HashTable; struct gl_attrib_node; +struct gl_meta_state; struct gl_pixelstore_attrib; struct gl_program_cache; struct gl_texture_format; @@ -227,7 +229,9 @@ typedef enum FRAG_ATTRIB_TEX5 = 9, FRAG_ATTRIB_TEX6 = 10, FRAG_ATTRIB_TEX7 = 11, - FRAG_ATTRIB_VAR0 = 12, /**< shader varying */ + FRAG_ATTRIB_FACE = 12, /**< front/back face */ + FRAG_ATTRIB_PNTC = 13, /**< sprite/point coord */ + FRAG_ATTRIB_VAR0 = 14, /**< shader varying */ FRAG_ATTRIB_MAX = (FRAG_ATTRIB_VAR0 + MAX_VARYING) } gl_frag_attrib; @@ -239,6 +243,8 @@ typedef enum #define FRAG_BIT_COL0 (1 << FRAG_ATTRIB_COL0) #define FRAG_BIT_COL1 (1 << FRAG_ATTRIB_COL1) #define FRAG_BIT_FOGC (1 << FRAG_ATTRIB_FOGC) +#define FRAG_BIT_FACE (1 << FRAG_ATTRIB_FACE) +#define FRAG_BIT_PNTC (1 << FRAG_ATTRIB_PNTC) #define FRAG_BIT_TEX0 (1 << FRAG_ATTRIB_TEX0) #define FRAG_BIT_TEX1 (1 << FRAG_ATTRIB_TEX1) #define FRAG_BIT_TEX2 (1 << FRAG_ATTRIB_TEX2) @@ -770,6 +776,7 @@ struct gl_light_attrib GLboolean Enabled; /**< Lighting enabled flag */ GLenum ShadeModel; /**< GL_FLAT or GL_SMOOTH */ + GLenum ProvokingVertex; /**< GL_EXT_provoking_vertex */ GLenum ColorMaterialFace; /**< GL_FRONT, BACK or FRONT_AND_BACK */ GLenum ColorMaterialMode; /**< GL_AMBIENT, GL_DIFFUSE, etc */ GLbitfield ColorMaterialBitmask; /**< bitmask formed from Face and Mode */ @@ -1028,7 +1035,7 @@ struct gl_stencil_attrib /** * 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. + * texture target enums, such as GL_TEXTURE_2D, GL_TEXTURE_CUBE_MAP, etc. * Note: the order is from highest priority to lowest priority. */ typedef enum @@ -1439,6 +1446,9 @@ struct gl_texture_attrib struct gl_texture_object *ProxyTex[NUM_TEXTURE_TARGETS]; + /** GL_ARB_seamless_cubemap */ + GLboolean CubeMapSeamless; + /** GL_EXT_shared_texture_palette */ GLboolean SharedPalette; struct gl_color_table Palette; @@ -1498,14 +1508,17 @@ struct gl_buffer_object { GLint RefCount; GLuint Name; - 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) */ + GLenum Usage; /**< GL_STREAM_DRAW_ARB, GL_STREAM_READ_ARB, etc. */ + GLsizeiptrARB Size; /**< Size of buffer storage in bytes */ + GLubyte *Data; /**< Location of storage either in RAM or VRAM. */ + /** Fields describing a mapped buffer */ + /*@{*/ + GLbitfield AccessFlags; /**< Mask of GL_MAP_x_BIT flags */ + GLvoid *Pointer; /**< User-space address of mapping */ + GLintptr Offset; /**< Mapped offset */ + GLsizeiptr Length; /**< Mapped length */ + /*@}*/ + GLboolean Written; /**< Ever written to? (for debugging) */ }; @@ -1541,10 +1554,10 @@ struct gl_client_array const GLubyte *Ptr; /**< Points to array data */ GLboolean Enabled; /**< Enabled flag is a boolean */ GLboolean Normalized; /**< GL_ARB_vertex_program */ + GLuint _ElementSize; /**< size of each element in bytes */ - /**< GL_ARB_vertex_buffer_object */ - struct gl_buffer_object *BufferObj; - GLuint _MaxElement; + struct gl_buffer_object *BufferObj;/**< GL_ARB_vertex_buffer_object */ + GLuint _MaxElement; /**< max element index into array buffer + 1 */ }; @@ -1559,10 +1572,12 @@ struct gl_array_object GLint RefCount; _glthread_Mutex Mutex; + GLboolean VBOonly; /**< require all arrays to live in VBOs? */ /** Conventional vertex arrays */ /*@{*/ struct gl_client_array Vertex; + struct gl_client_array Weight; struct gl_client_array Normal; struct gl_client_array Color; struct gl_client_array SecondaryColor; @@ -1573,11 +1588,22 @@ struct gl_array_object struct gl_client_array PointSize; /*@}*/ - /** Generic arrays for vertex programs/shaders */ - struct gl_client_array VertexAttrib[VERT_ATTRIB_MAX]; + /** + * Generic arrays for vertex programs/shaders. + * For NV vertex programs, these attributes alias and take priority + * over the conventional attribs above. For ARB vertex programs and + * GLSL vertex shaders, these attributes are separate. + */ + struct gl_client_array VertexAttrib[MAX_VERTEX_GENERIC_ATTRIBS]; /** Mask of _NEW_ARRAY_* values indicating which arrays are enabled */ GLbitfield _Enabled; + + /** + * Min of all enabled arrays' _MaxElement. When arrays reside inside VBOs + * we can determine the max legal (in bounds) glDrawElements array index. + */ + GLuint _MaxElement; }; @@ -1586,9 +1612,15 @@ struct gl_array_object */ struct gl_array_attrib { + /** Currently bound array object. See _mesa_BindVertexArrayAPPLE() */ struct gl_array_object *ArrayObj; + + /** The default vertex array object */ struct gl_array_object *DefaultArrayObj; + /** Array objects (GL_ARB/APPLE_vertex_array_object) */ + struct _mesa_HashTable *Objects; + GLint ActiveTexture; /**< Client Active Texture */ GLuint LockFirst; /**< GL_EXT_compiled_vertex_array */ GLuint LockCount; /**< GL_EXT_compiled_vertex_array */ @@ -1596,11 +1628,9 @@ struct gl_array_attrib GLbitfield NewState; /**< mask of _NEW_ARRAY_* values */ #if FEATURE_ARB_vertex_buffer_object - struct gl_buffer_object *NullBufferObj; struct gl_buffer_object *ArrayBufferObj; struct gl_buffer_object *ElementArrayBufferObj; #endif - GLuint _MaxElement; /* Min of all enabled array's maxes */ }; @@ -1770,7 +1800,7 @@ struct gl_program /** Map from sampler unit to texture unit (set by glUniform1i()) */ GLubyte SamplerUnits[MAX_SAMPLERS]; /** Which texture target is being sampled (TEXTURE_1D/2D/3D/etc_INDEX) */ - GLubyte SamplerTargets[MAX_SAMPLERS]; + gl_texture_index SamplerTargets[MAX_SAMPLERS]; /** Logical counts */ /*@{*/ @@ -1813,9 +1843,6 @@ struct gl_fragment_program struct gl_program Base; /**< base class */ GLenum FogOption; GLboolean UsesKill; /**< shader uses KIL instruction */ - GLboolean UsesPointCoord; /**< shader uses gl_PointCoord */ - GLboolean UsesFrontFacing; /**< shader used gl_FrontFacing */ - GLboolean UsesFogFragCoord; /**< shader used gl_FogFragCoord */ }; @@ -1960,6 +1987,21 @@ struct gl_query_state }; +/** Sync object state */ +struct gl_sync_object { + struct simple_node link; + GLenum Type; /**< GL_SYNC_FENCE */ + GLuint Name; /**< Fence name */ + GLint RefCount; /**< Reference count */ + GLboolean DeletePending; /**< Object was deleted while there were still + * live references (e.g., sync not yet finished) + */ + GLenum SyncCondition; + GLbitfield Flags; /**< Flags passed to glFenceSync */ + GLuint StatusFlag:1; /**< Has the sync object been signaled? */ +}; + + /** Set by #pragma directives */ struct gl_sl_pragmas { @@ -1983,6 +2025,7 @@ struct gl_shader GLboolean Main; /**< shader defines main() */ GLboolean UnresolvedRefs; const GLchar *Source; /**< Source code string */ + GLuint SourceChecksum; /**< for debug/logging purposes */ struct gl_program *Program; /**< Post-compile assembly code */ GLchar *InfoLog; struct gl_sl_pragmas Pragmas; @@ -2013,6 +2056,7 @@ struct gl_shader_program struct gl_program_parameter_list *Varying; GLboolean LinkStatus; /**< GL_LINK_STATUS */ GLboolean Validated; + GLboolean _Used; /**< Ever used for drawing? */ GLchar *InfoLog; }; @@ -2068,6 +2112,8 @@ struct gl_shared_state GLuint TextureStateStamp; /**< state notification for shared tex */ /*@}*/ + /** Default buffer object for vertex arrays that aren't in VBOs */ + struct gl_buffer_object *NullBufferObj; /** * \name Vertex/fragment programs @@ -2101,8 +2147,9 @@ struct gl_shared_state struct _mesa_HashTable *FrameBuffers; #endif - /** Objects associated with the GL_APPLE_vertex_array_object extension. */ - struct _mesa_HashTable *ArrayObjects; +#if FEATURE_ARB_sync + struct simple_node SyncObjects; +#endif void *DriverData; /**< Device driver shared state */ }; @@ -2407,6 +2454,15 @@ struct gl_constants GLuint MaxVarying; /**< Number of float[4] varying parameters */ GLbitfield SupportedBumpUnits; /**> units supporting GL_ATI_envmap_bumpmap as targets */ + + /** + * Maximum amount of time, measured in nanseconds, that the server can wait. + */ + GLuint64 MaxServerWaitTimeout; + + + /**< GL_EXT_provoking_vertex */ + GLboolean QuadsFollowProvokingVertexConvention; }; @@ -2417,6 +2473,7 @@ struct gl_constants struct gl_extensions { GLboolean dummy; /* don't remove this! */ + GLboolean ARB_copy_buffer; GLboolean ARB_depth_texture; GLboolean ARB_draw_buffers; GLboolean ARB_fragment_program; @@ -2425,15 +2482,18 @@ struct gl_extensions GLboolean ARB_framebuffer_object; GLboolean ARB_half_float_pixel; GLboolean ARB_imaging; + GLboolean ARB_map_buffer_range; GLboolean ARB_multisample; GLboolean ARB_multitexture; GLboolean ARB_occlusion_query; GLboolean ARB_point_sprite; + GLboolean ARB_seamless_cube_map; GLboolean ARB_shader_objects; GLboolean ARB_shading_language_100; GLboolean ARB_shading_language_120; GLboolean ARB_shadow; GLboolean ARB_shadow_ambient; /* or GL_ARB_shadow_ambient */ + GLboolean ARB_sync; GLboolean ARB_texture_border_clamp; GLboolean ARB_texture_compression; GLboolean ARB_texture_cube_map; @@ -2444,6 +2504,7 @@ struct gl_extensions GLboolean ARB_texture_mirrored_repeat; GLboolean ARB_texture_non_power_of_two; GLboolean ARB_transpose_matrix; + GLboolean ARB_vertex_array_object; GLboolean ARB_vertex_buffer_object; GLboolean ARB_vertex_program; GLboolean ARB_vertex_shader; @@ -2475,6 +2536,7 @@ struct gl_extensions GLboolean EXT_pixel_buffer_object; GLboolean EXT_point_parameters; GLboolean EXT_polygon_offset; + GLboolean EXT_provoking_vertex; GLboolean EXT_rescale_normal; GLboolean EXT_shadow_funcs; GLboolean EXT_secondary_color; @@ -2623,6 +2685,7 @@ struct gl_matrix_stack #define _NEW_PROGRAM 0x8000000 /**< __GLcontextRec::VertexProgram */ #define _NEW_CURRENT_ATTRIB 0x10000000 /**< __GLcontextRec::Current */ #define _NEW_PROGRAM_CONSTANTS 0x20000000 +#define _NEW_BUFFER_OBJECT 0x40000000 #define _NEW_ALL ~0 /*@}*/ @@ -2948,8 +3011,13 @@ struct __GLcontextRec struct gl_shader_state Shader; /**< GLSL shader object state */ struct gl_query_state Query; /**< occlusion, timer queries */ + + struct gl_buffer_object *CopyReadBuffer; /**< GL_ARB_copy_buffer */ + struct gl_buffer_object *CopyWriteBuffer; /**< GL_ARB_copy_buffer */ /*@}*/ + struct gl_meta_state *Meta; /**< for "meta" operations */ + #if FEATURE_EXT_framebuffer_object struct gl_renderbuffer *CurrentRenderbuffer; #endif diff --git a/src/mesa/main/pixel.c b/src/mesa/main/pixel.c index 57ae9c721a..fcef6dfd42 100644 --- a/src/mesa/main/pixel.c +++ b/src/mesa/main/pixel.c @@ -136,6 +136,33 @@ store_pixelmap(GLcontext *ctx, GLenum map, GLsizei mapsize, } +/** + * Convenience wrapper for _mesa_validate_pbo_access() for gl[Get]PixelMap(). + */ +static GLboolean +validate_pbo_access(GLcontext *ctx, struct gl_pixelstore_attrib *pack, + GLsizei mapsize, GLenum format, GLenum type, + const GLvoid *ptr) +{ + GLboolean ok; + + /* Note, need to use DefaultPacking and Unpack's buffer object */ + ctx->DefaultPacking.BufferObj = pack->BufferObj; + + ok = _mesa_validate_pbo_access(1, &ctx->DefaultPacking, mapsize, 1, 1, + format, type, ptr); + + /* restore */ + ctx->DefaultPacking.BufferObj = ctx->Shared->NullBufferObj; + + if (!ok) { + _mesa_error(ctx, GL_INVALID_OPERATION, + "glPixelMap(invalid PBO access)"); + } + return ok; +} + + void GLAPIENTRY _mesa_PixelMapfv( GLenum map, GLsizei mapsize, const GLfloat *values ) { @@ -158,40 +185,23 @@ _mesa_PixelMapfv( GLenum map, GLsizei mapsize, const GLfloat *values ) FLUSH_VERTICES(ctx, _NEW_PIXEL); - if (ctx->Unpack.BufferObj->Name) { - /* unpack pixelmap from PBO */ - GLubyte *buf; - /* Note, need to use DefaultPacking and Unpack's buffer object */ - ctx->DefaultPacking.BufferObj = ctx->Unpack.BufferObj; - if (!_mesa_validate_pbo_access(1, &ctx->DefaultPacking, mapsize, 1, 1, - GL_INTENSITY, GL_FLOAT, values)) { - _mesa_error(ctx, GL_INVALID_OPERATION, - "glPixelMapfv(invalid PBO access)"); - return; - } - /* restore */ - ctx->DefaultPacking.BufferObj = ctx->Array.NullBufferObj; - buf = (GLubyte *) ctx->Driver.MapBuffer(ctx, GL_PIXEL_UNPACK_BUFFER_EXT, - GL_READ_ONLY_ARB, - ctx->Unpack.BufferObj); - if (!buf) { - /* buffer is already mapped - that's an error */ + if (!validate_pbo_access(ctx, &ctx->Unpack, mapsize, + GL_INTENSITY, GL_FLOAT, values)) { + return; + } + + values = (const GLfloat *) _mesa_map_pbo_source(ctx, &ctx->Unpack, values); + if (!values) { + if (_mesa_is_bufferobj(ctx->Unpack.BufferObj)) { _mesa_error(ctx, GL_INVALID_OPERATION, "glPixelMapfv(PBO is mapped)"); - return; } - values = (const GLfloat *) ADD_POINTERS(buf, values); - } - else if (!values) { return; } store_pixelmap(ctx, map, mapsize, values); - if (ctx->Unpack.BufferObj->Name) { - ctx->Driver.UnmapBuffer(ctx, GL_PIXEL_UNPACK_BUFFER_EXT, - ctx->Unpack.BufferObj); - } + _mesa_unmap_pbo_source(ctx, &ctx->Unpack); } @@ -217,31 +227,17 @@ _mesa_PixelMapuiv(GLenum map, GLsizei mapsize, const GLuint *values ) FLUSH_VERTICES(ctx, _NEW_PIXEL); - if (ctx->Unpack.BufferObj->Name) { - /* unpack pixelmap from PBO */ - GLubyte *buf; - /* Note, need to use DefaultPacking and Unpack's buffer object */ - ctx->DefaultPacking.BufferObj = ctx->Unpack.BufferObj; - if (!_mesa_validate_pbo_access(1, &ctx->DefaultPacking, mapsize, 1, 1, - GL_INTENSITY, GL_UNSIGNED_INT, values)) { - _mesa_error(ctx, GL_INVALID_OPERATION, - "glPixelMapuiv(invalid PBO access)"); - return; - } - /* restore */ - ctx->DefaultPacking.BufferObj = ctx->Array.NullBufferObj; - buf = (GLubyte *) ctx->Driver.MapBuffer(ctx, GL_PIXEL_UNPACK_BUFFER_EXT, - GL_READ_ONLY_ARB, - ctx->Unpack.BufferObj); - if (!buf) { - /* buffer is already mapped - that's an error */ + if (!validate_pbo_access(ctx, &ctx->Unpack, mapsize, + GL_INTENSITY, GL_UNSIGNED_INT, values)) { + return; + } + + values = (const GLuint *) _mesa_map_pbo_source(ctx, &ctx->Unpack, values); + if (!values) { + if (_mesa_is_bufferobj(ctx->Unpack.BufferObj)) { _mesa_error(ctx, GL_INVALID_OPERATION, "glPixelMapuiv(PBO is mapped)"); - return; } - values = (const GLuint *) ADD_POINTERS(buf, values); - } - else if (!values) { return; } @@ -259,10 +255,7 @@ _mesa_PixelMapuiv(GLenum map, GLsizei mapsize, const GLuint *values ) } } - if (ctx->Unpack.BufferObj->Name) { - ctx->Driver.UnmapBuffer(ctx, GL_PIXEL_UNPACK_BUFFER_EXT, - ctx->Unpack.BufferObj); - } + _mesa_unmap_pbo_source(ctx, &ctx->Unpack); store_pixelmap(ctx, map, mapsize, fvalues); } @@ -290,32 +283,17 @@ _mesa_PixelMapusv(GLenum map, GLsizei mapsize, const GLushort *values ) FLUSH_VERTICES(ctx, _NEW_PIXEL); - if (ctx->Unpack.BufferObj->Name) { - /* unpack pixelmap from PBO */ - GLubyte *buf; - /* Note, need to use DefaultPacking and Unpack's buffer object */ - ctx->DefaultPacking.BufferObj = ctx->Unpack.BufferObj; - if (!_mesa_validate_pbo_access(1, &ctx->DefaultPacking, mapsize, 1, 1, - GL_INTENSITY, GL_UNSIGNED_SHORT, - values)) { - _mesa_error(ctx, GL_INVALID_OPERATION, - "glPixelMapusv(invalid PBO access)"); - return; - } - /* restore */ - ctx->DefaultPacking.BufferObj = ctx->Array.NullBufferObj; - buf = (GLubyte *) ctx->Driver.MapBuffer(ctx, GL_PIXEL_UNPACK_BUFFER_EXT, - GL_READ_ONLY_ARB, - ctx->Unpack.BufferObj); - if (!buf) { - /* buffer is already mapped - that's an error */ + if (!validate_pbo_access(ctx, &ctx->Unpack, mapsize, + GL_INTENSITY, GL_UNSIGNED_SHORT, values)) { + return; + } + + values = (const GLushort *) _mesa_map_pbo_source(ctx, &ctx->Unpack, values); + if (!values) { + if (_mesa_is_bufferobj(ctx->Unpack.BufferObj)) { _mesa_error(ctx, GL_INVALID_OPERATION, "glPixelMapusv(PBO is mapped)"); - return; } - values = (const GLushort *) ADD_POINTERS(buf, values); - } - else if (!values) { return; } @@ -333,10 +311,7 @@ _mesa_PixelMapusv(GLenum map, GLsizei mapsize, const GLushort *values ) } } - if (ctx->Unpack.BufferObj->Name) { - ctx->Driver.UnmapBuffer(ctx, GL_PIXEL_UNPACK_BUFFER_EXT, - ctx->Unpack.BufferObj); - } + _mesa_unmap_pbo_source(ctx, &ctx->Unpack); store_pixelmap(ctx, map, mapsize, fvalues); } @@ -359,31 +334,17 @@ _mesa_GetPixelMapfv( GLenum map, GLfloat *values ) mapsize = pm->Size; - if (ctx->Pack.BufferObj->Name) { - /* pack pixelmap into PBO */ - GLubyte *buf; - /* Note, need to use DefaultPacking and Pack's buffer object */ - ctx->DefaultPacking.BufferObj = ctx->Pack.BufferObj; - if (!_mesa_validate_pbo_access(1, &ctx->DefaultPacking, mapsize, 1, 1, - GL_INTENSITY, GL_FLOAT, values)) { - _mesa_error(ctx, GL_INVALID_OPERATION, - "glGetPixelMapfv(invalid PBO access)"); - return; - } - /* restore */ - ctx->DefaultPacking.BufferObj = ctx->Array.NullBufferObj; - buf = (GLubyte *) ctx->Driver.MapBuffer(ctx, GL_PIXEL_PACK_BUFFER_EXT, - GL_WRITE_ONLY_ARB, - ctx->Pack.BufferObj); - if (!buf) { - /* buffer is already mapped - that's an error */ + if (!validate_pbo_access(ctx, &ctx->Pack, mapsize, + GL_INTENSITY, GL_FLOAT, values)) { + return; + } + + values = (GLfloat *) _mesa_map_pbo_dest(ctx, &ctx->Pack, values); + if (!values) { + if (_mesa_is_bufferobj(ctx->Pack.BufferObj)) { _mesa_error(ctx, GL_INVALID_OPERATION, "glGetPixelMapfv(PBO is mapped)"); - return; } - values = (GLfloat *) ADD_POINTERS(buf, values); - } - else if (!values) { return; } @@ -397,10 +358,7 @@ _mesa_GetPixelMapfv( GLenum map, GLfloat *values ) MEMCPY(values, pm->Map, mapsize * sizeof(GLfloat)); } - if (ctx->Pack.BufferObj->Name) { - ctx->Driver.UnmapBuffer(ctx, GL_PIXEL_PACK_BUFFER_EXT, - ctx->Pack.BufferObj); - } + _mesa_unmap_pbo_dest(ctx, &ctx->Pack); } @@ -420,31 +378,17 @@ _mesa_GetPixelMapuiv( GLenum map, GLuint *values ) } mapsize = pm->Size; - if (ctx->Pack.BufferObj->Name) { - /* pack pixelmap into PBO */ - GLubyte *buf; - /* Note, need to use DefaultPacking and Pack's buffer object */ - ctx->DefaultPacking.BufferObj = ctx->Pack.BufferObj; - if (!_mesa_validate_pbo_access(1, &ctx->DefaultPacking, mapsize, 1, 1, - GL_INTENSITY, GL_UNSIGNED_INT, values)) { - _mesa_error(ctx, GL_INVALID_OPERATION, - "glGetPixelMapuiv(invalid PBO access)"); - return; - } - /* restore */ - ctx->DefaultPacking.BufferObj = ctx->Array.NullBufferObj; - buf = (GLubyte *) ctx->Driver.MapBuffer(ctx, GL_PIXEL_PACK_BUFFER_EXT, - GL_WRITE_ONLY_ARB, - ctx->Pack.BufferObj); - if (!buf) { - /* buffer is already mapped - that's an error */ + if (!validate_pbo_access(ctx, &ctx->Pack, mapsize, + GL_INTENSITY, GL_UNSIGNED_INT, values)) { + return; + } + + values = (GLuint *) _mesa_map_pbo_dest(ctx, &ctx->Pack, values); + if (!values) { + if (_mesa_is_bufferobj(ctx->Pack.BufferObj)) { _mesa_error(ctx, GL_INVALID_OPERATION, "glGetPixelMapuiv(PBO is mapped)"); - return; } - values = (GLuint *) ADD_POINTERS(buf, values); - } - else if (!values) { return; } @@ -458,10 +402,7 @@ _mesa_GetPixelMapuiv( GLenum map, GLuint *values ) } } - if (ctx->Pack.BufferObj->Name) { - ctx->Driver.UnmapBuffer(ctx, GL_PIXEL_PACK_BUFFER_EXT, - ctx->Pack.BufferObj); - } + _mesa_unmap_pbo_dest(ctx, &ctx->Pack); } @@ -481,32 +422,17 @@ _mesa_GetPixelMapusv( GLenum map, GLushort *values ) } mapsize = pm ? pm->Size : 0; - if (ctx->Pack.BufferObj->Name) { - /* pack pixelmap into PBO */ - GLubyte *buf; - /* Note, need to use DefaultPacking and Pack's buffer object */ - ctx->DefaultPacking.BufferObj = ctx->Pack.BufferObj; - if (!_mesa_validate_pbo_access(1, &ctx->DefaultPacking, mapsize, 1, 1, - GL_INTENSITY, GL_UNSIGNED_SHORT, - values)) { - _mesa_error(ctx, GL_INVALID_OPERATION, - "glGetPixelMapusv(invalid PBO access)"); - return; - } - /* restore */ - ctx->DefaultPacking.BufferObj = ctx->Array.NullBufferObj; - buf = (GLubyte *) ctx->Driver.MapBuffer(ctx, GL_PIXEL_PACK_BUFFER_EXT, - GL_WRITE_ONLY_ARB, - ctx->Pack.BufferObj); - if (!buf) { - /* buffer is already mapped - that's an error */ + if (!validate_pbo_access(ctx, &ctx->Pack, mapsize, + GL_INTENSITY, GL_UNSIGNED_SHORT, values)) { + return; + } + + values = (GLushort *) _mesa_map_pbo_dest(ctx, &ctx->Pack, values); + if (!values) { + if (_mesa_is_bufferobj(ctx->Pack.BufferObj)) { _mesa_error(ctx, GL_INVALID_OPERATION, "glGetPixelMapusv(PBO is mapped)"); - return; } - values = (GLushort *) ADD_POINTERS(buf, values); - } - else if (!values) { return; } @@ -528,10 +454,7 @@ _mesa_GetPixelMapusv( GLenum map, GLushort *values ) } } - if (ctx->Pack.BufferObj->Name) { - ctx->Driver.UnmapBuffer(ctx, GL_PIXEL_PACK_BUFFER_EXT, - ctx->Pack.BufferObj); - } + _mesa_unmap_pbo_dest(ctx, &ctx->Pack); } diff --git a/src/mesa/main/pixelstore.c b/src/mesa/main/pixelstore.c index ff1a6344cc..6a641f83f2 100644 --- a/src/mesa/main/pixelstore.c +++ b/src/mesa/main/pixelstore.c @@ -245,7 +245,8 @@ _mesa_init_pixelstore( GLcontext *ctx ) ctx->Pack.ClientStorage = GL_FALSE; ctx->Pack.Invert = GL_FALSE; #if FEATURE_EXT_pixel_buffer_object - ctx->Pack.BufferObj = ctx->Array.NullBufferObj; + _mesa_reference_buffer_object(ctx, &ctx->Pack.BufferObj, + ctx->Shared->NullBufferObj); #endif ctx->Unpack.Alignment = 4; ctx->Unpack.RowLength = 0; @@ -258,7 +259,8 @@ _mesa_init_pixelstore( GLcontext *ctx ) ctx->Unpack.ClientStorage = GL_FALSE; ctx->Unpack.Invert = GL_FALSE; #if FEATURE_EXT_pixel_buffer_object - ctx->Unpack.BufferObj = ctx->Array.NullBufferObj; + _mesa_reference_buffer_object(ctx, &ctx->Unpack.BufferObj, + ctx->Shared->NullBufferObj); #endif /* @@ -278,6 +280,7 @@ _mesa_init_pixelstore( GLcontext *ctx ) ctx->DefaultPacking.ClientStorage = GL_FALSE; ctx->DefaultPacking.Invert = GL_FALSE; #if FEATURE_EXT_pixel_buffer_object - ctx->DefaultPacking.BufferObj = ctx->Array.NullBufferObj; + _mesa_reference_buffer_object(ctx, &ctx->DefaultPacking.BufferObj, + ctx->Shared->NullBufferObj); #endif } diff --git a/src/mesa/main/polygon.c b/src/mesa/main/polygon.c index 564250b881..376a87a396 100644 --- a/src/mesa/main/polygon.c +++ b/src/mesa/main/polygon.c @@ -193,32 +193,16 @@ _mesa_PolygonMode( GLenum face, GLenum mode ) void _mesa_polygon_stipple(GLcontext *ctx, const GLubyte *pattern) { - if (ctx->Unpack.BufferObj->Name) { - /* Get/unpack the stipple pattern from a PBO */ - GLubyte *buf; - if (!_mesa_validate_pbo_access(2, &ctx->Unpack, 32, 32, 1, - GL_COLOR_INDEX, GL_BITMAP, pattern)) { - _mesa_error(ctx, GL_INVALID_OPERATION, - "glPolygonStipple(bad PBO access)"); - return; - } - buf = (GLubyte *) ctx->Driver.MapBuffer(ctx, GL_PIXEL_UNPACK_BUFFER_EXT, - GL_READ_ONLY_ARB, - ctx->Unpack.BufferObj); - if (!buf) { - _mesa_error(ctx, GL_INVALID_OPERATION, - "glPolygonStipple(PBO mapped)"); - return; - } - buf = ADD_POINTERS(buf, pattern); - _mesa_unpack_polygon_stipple(buf, ctx->PolygonStipple, &ctx->Unpack); - ctx->Driver.UnmapBuffer(ctx, GL_PIXEL_UNPACK_BUFFER_EXT, - ctx->Unpack.BufferObj); - } - else { - /* Get/unpack the stipple pattern from user memory */ - _mesa_unpack_polygon_stipple(pattern, ctx->PolygonStipple, &ctx->Unpack); - } + pattern = _mesa_map_validate_pbo_source(ctx, 2, + &ctx->Unpack, 32, 32, 1, + GL_COLOR_INDEX, GL_BITMAP, pattern, + "glPolygonStipple"); + if (!pattern) + return; + + _mesa_unpack_polygon_stipple(pattern, ctx->PolygonStipple, &ctx->Unpack); + + _mesa_unmap_pbo_source(ctx, &ctx->Unpack); } @@ -255,35 +239,16 @@ _mesa_GetPolygonStipple( GLubyte *dest ) if (MESA_VERBOSE&VERBOSE_API) _mesa_debug(ctx, "glGetPolygonStipple\n"); - /* XXX someday we may put this code into a separate function and call - * it with ctx->Driver.GetPolygonStipple(). - */ - if (ctx->Pack.BufferObj->Name) { - /* Put/pack the stipple pattern into a PBO */ - GLubyte *buf; - if (!_mesa_validate_pbo_access(2, &ctx->Pack, 32, 32, 1, - GL_COLOR_INDEX, GL_BITMAP, dest)) { - _mesa_error(ctx, GL_INVALID_OPERATION, - "glGetPolygonStipple(bad PBO access)"); - return; - } - buf = (GLubyte *) ctx->Driver.MapBuffer(ctx, GL_PIXEL_PACK_BUFFER_EXT, - GL_WRITE_ONLY_ARB, - ctx->Pack.BufferObj); - if (!buf) { - _mesa_error(ctx, GL_INVALID_OPERATION, - "glGetPolygonStipple(PBO mapped)"); - return; - } - buf = ADD_POINTERS(buf, dest); - _mesa_pack_polygon_stipple(ctx->PolygonStipple, buf, &ctx->Pack); - ctx->Driver.UnmapBuffer(ctx, GL_PIXEL_PACK_BUFFER_EXT, - ctx->Pack.BufferObj); - } - else { - /* Put/pack the stipple pattern into user memory */ - _mesa_pack_polygon_stipple(ctx->PolygonStipple, dest, &ctx->Pack); - } + dest = _mesa_map_validate_pbo_dest(ctx, 2, + &ctx->Pack, 32, 32, 1, + GL_COLOR_INDEX, GL_BITMAP, dest, + "glGetPolygonStipple"); + if (!dest) + return; + + _mesa_pack_polygon_stipple(ctx->PolygonStipple, dest, &ctx->Pack); + + _mesa_unmap_pbo_dest(ctx, &ctx->Pack); } diff --git a/src/mesa/main/queryobj.c b/src/mesa/main/queryobj.c index c25b31af02..a73c6e0508 100644 --- a/src/mesa/main/queryobj.c +++ b/src/mesa/main/queryobj.c @@ -38,7 +38,7 @@ * \param id - the new object's ID * \return pointer to new query_object object or NULL if out of memory. */ -struct gl_query_object * +static struct gl_query_object * _mesa_new_query_object(GLcontext *ctx, GLuint id) { struct gl_query_object *q = MALLOC_STRUCT(gl_query_object); @@ -57,7 +57,7 @@ _mesa_new_query_object(GLcontext *ctx, GLuint id) * Begin a query. Software driver fallback. * Called via ctx->Driver.BeginQuery(). */ -void +static void _mesa_begin_query(GLcontext *ctx, struct gl_query_object *q) { /* no-op */ @@ -68,7 +68,7 @@ _mesa_begin_query(GLcontext *ctx, struct gl_query_object *q) * End a query. Software driver fallback. * Called via ctx->Driver.EndQuery(). */ -void +static void _mesa_end_query(GLcontext *ctx, struct gl_query_object *q) { q->Ready = GL_TRUE; @@ -79,7 +79,7 @@ _mesa_end_query(GLcontext *ctx, struct gl_query_object *q) * Wait for query to complete. Software driver fallback. * Called via ctx->Driver.WaitQuery(). */ -void +static void _mesa_wait_query(GLcontext *ctx, struct gl_query_object *q) { /* For software drivers, _mesa_end_query() should have completed the query. @@ -94,7 +94,7 @@ _mesa_wait_query(GLcontext *ctx, struct gl_query_object *q) * Check if a query results are ready. Software driver fallback. * Called via ctx->Driver.CheckQuery(). */ -void +static void _mesa_check_query(GLcontext *ctx, struct gl_query_object *q) { /* No-op for sw rendering. @@ -107,7 +107,7 @@ _mesa_check_query(GLcontext *ctx, struct gl_query_object *q) * Delete a query object. Called via ctx->Driver.DeleteQuery(). * Not removed from hash table here. */ -void +static void _mesa_delete_query(GLcontext *ctx, struct gl_query_object *q) { _mesa_free(q); @@ -123,6 +123,18 @@ lookup_query_object(GLcontext *ctx, GLuint id) +void +_mesa_init_query_object_functions(struct dd_function_table *driver) +{ + driver->NewQueryObject = _mesa_new_query_object; + driver->DeleteQuery = _mesa_delete_query; + driver->BeginQuery = _mesa_begin_query; + driver->EndQuery = _mesa_end_query; + driver->WaitQuery = _mesa_wait_query; + driver->CheckQuery = _mesa_check_query; +} + + void GLAPIENTRY _mesa_GenQueriesARB(GLsizei n, GLuint *ids) { diff --git a/src/mesa/main/queryobj.h b/src/mesa/main/queryobj.h index bc02b65b54..ee775ef959 100644 --- a/src/mesa/main/queryobj.h +++ b/src/mesa/main/queryobj.h @@ -27,9 +27,6 @@ #define OCCLUDE_H -extern struct gl_query_object * -_mesa_new_query_object(GLcontext *ctx, GLuint id); - extern void _mesa_init_query(GLcontext *ctx); @@ -37,19 +34,7 @@ extern void _mesa_free_query_data(GLcontext *ctx); extern void -_mesa_delete_query(GLcontext *ctx, struct gl_query_object *q); - -extern void -_mesa_begin_query(GLcontext *ctx, struct gl_query_object *q); - -extern void -_mesa_end_query(GLcontext *ctx, struct gl_query_object *q); - -extern void -_mesa_wait_query(GLcontext *ctx, struct gl_query_object *q); - -extern void -_mesa_check_query(GLcontext *ctx, struct gl_query_object *q); +_mesa_init_query_object_functions(struct dd_function_table *driver); extern void GLAPIENTRY diff --git a/src/mesa/main/readpix.c b/src/mesa/main/readpix.c index 2326776ecb..feea1d375f 100644 --- a/src/mesa/main/readpix.c +++ b/src/mesa/main/readpix.c @@ -44,6 +44,10 @@ _mesa_error_check_format_type(GLcontext *ctx, GLenum format, GLenum type, GLboolean drawing) { const char *readDraw = drawing ? "Draw" : "Read"; + const GLboolean reading = !drawing; + + /* state validation should have already been done */ + ASSERT(ctx->NewState == 0x0); if (ctx->Extensions.EXT_packed_depth_stencil && type == GL_UNSIGNED_INT_24_8_EXT @@ -73,32 +77,45 @@ _mesa_error_check_format_type(GLcontext *ctx, GLenum format, GLenum type, case GL_RGBA: case GL_BGRA: case GL_ABGR_EXT: - if (drawing && !ctx->Visual.rgbMode) { - _mesa_error(ctx, GL_INVALID_OPERATION, + if (drawing) { + if (!ctx->DrawBuffer->Visual.rgbMode) { + _mesa_error(ctx, GL_INVALID_OPERATION, "glDrawPixels(drawing RGB pixels into color index buffer)"); - return GL_TRUE; + return GL_TRUE; + } } - if (!drawing && !_mesa_dest_buffer_exists(ctx, GL_COLOR)) { - _mesa_error(ctx, GL_INVALID_OPERATION, - "glReadPixels(no color buffer)"); - return GL_TRUE; + else { + /* reading */ + if (!_mesa_source_buffer_exists(ctx, GL_COLOR)) { + _mesa_error(ctx, GL_INVALID_OPERATION, + "glReadPixels(no color buffer)"); + return GL_TRUE; + } } break; case GL_COLOR_INDEX: - if (!drawing && ctx->Visual.rgbMode) { - _mesa_error(ctx, GL_INVALID_OPERATION, - "glReadPixels(reading color index format from RGB buffer)"); - return GL_TRUE; + if (drawing) { + if (ctx->DrawBuffer->Visual.rgbMode && + (ctx->PixelMaps.ItoR.Size == 0 || + ctx->PixelMaps.ItoG.Size == 0 || + ctx->PixelMaps.ItoB.Size == 0)) { + _mesa_error(ctx, GL_INVALID_OPERATION, + "glDrawPixels(drawing color index pixels into RGB buffer)"); + return GL_TRUE; + } } - if (!drawing && !_mesa_dest_buffer_exists(ctx, GL_COLOR)) { - _mesa_error(ctx, GL_INVALID_OPERATION, - "glReadPixels(no color buffer)"); - return GL_TRUE; + else { + /* reading */ + if (!_mesa_source_buffer_exists(ctx, GL_COLOR)) { + _mesa_error(ctx, GL_INVALID_OPERATION, + "glReadPixels(no color buffer)"); + return GL_TRUE; + } } break; case GL_STENCIL_INDEX: if ((drawing && !_mesa_dest_buffer_exists(ctx, format)) || - (!drawing && !_mesa_source_buffer_exists(ctx, format))) { + (reading && !_mesa_source_buffer_exists(ctx, format))) { _mesa_error(ctx, GL_INVALID_OPERATION, "gl%sPixels(no stencil buffer)", readDraw); return GL_TRUE; @@ -118,7 +135,7 @@ _mesa_error_check_format_type(GLcontext *ctx, GLenum format, GLenum type, return GL_TRUE; } if ((drawing && !_mesa_dest_buffer_exists(ctx, format)) || - (!drawing && !_mesa_source_buffer_exists(ctx, format))) { + (reading && !_mesa_source_buffer_exists(ctx, format))) { _mesa_error(ctx, GL_INVALID_OPERATION, "gl%sPixels(no depth or stencil buffer)", readDraw); return GL_TRUE; @@ -173,7 +190,7 @@ _mesa_ReadPixels( GLint x, GLint y, GLsizei width, GLsizei height, if (width == 0 || height == 0) return; /* nothing to do */ - if (ctx->Pack.BufferObj->Name) { + if (_mesa_is_bufferobj(ctx->Pack.BufferObj)) { if (!_mesa_validate_pbo_access(2, &ctx->Pack, width, height, 1, format, type, pixels)) { _mesa_error(ctx, GL_INVALID_OPERATION, @@ -181,7 +198,7 @@ _mesa_ReadPixels( GLint x, GLint y, GLsizei width, GLsizei height, return; } - if (ctx->Pack.BufferObj->Pointer) { + if (_mesa_bufferobj_mapped(ctx->Pack.BufferObj)) { /* buffer is mapped - that's an error */ _mesa_error(ctx, GL_INVALID_OPERATION, "glReadPixels(PBO is mapped)"); return; diff --git a/src/mesa/main/shared.c b/src/mesa/main/shared.c index ae8dd2a836..643ad3354e 100644 --- a/src/mesa/main/shared.c +++ b/src/mesa/main/shared.c @@ -33,6 +33,7 @@ #include "mtypes.h" #include "hash.h" #include "arrayobj.h" +#include "bufferobj.h" #include "shared.h" #include "shader/program.h" #include "shader/shader_api.h" @@ -42,7 +43,9 @@ #if FEATURE_ATI_fragment_shader #include "shader/atifragshader.h" #endif - +#if FEATURE_ARB_sync +#include "syncobj.h" +#endif /** * Allocate and initialize a shared context state structure. @@ -92,7 +95,12 @@ _mesa_alloc_shared_state(GLcontext *ctx) shared->BufferObjects = _mesa_NewHashTable(); #endif - shared->ArrayObjects = _mesa_NewHashTable(); + /* Allocate the default buffer object and set refcount so high that + * it never gets deleted. + * XXX with recent/improved refcounting this may not longer be needed. + */ + shared->NullBufferObj = ctx->Driver.NewBufferObject(ctx, 0, 0); + shared->NullBufferObj->RefCount = 1000 * 1000 * 1000; /* Create default texture objects */ for (i = 0; i < NUM_TEXTURE_TARGETS; i++) { @@ -121,6 +129,10 @@ _mesa_alloc_shared_state(GLcontext *ctx) shared->RenderBuffers = _mesa_NewHashTable(); #endif +#if FEATURE_ARB_sync + make_empty_list(& shared->SyncObjects); +#endif + return shared; } @@ -190,7 +202,7 @@ delete_bufferobj_cb(GLuint id, void *data, void *userData) { struct gl_buffer_object *bufObj = (struct gl_buffer_object *) data; GLcontext *ctx = (GLcontext *) userData; - if (bufObj->Pointer) { + if (_mesa_bufferobj_mapped(bufObj)) { ctx->Driver.UnmapBuffer(ctx, 0, bufObj); bufObj->Pointer = NULL; } @@ -199,18 +211,6 @@ delete_bufferobj_cb(GLuint id, void *data, void *userData) /** - * 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. */ @@ -312,9 +312,6 @@ _mesa_free_shared_state(GLcontext *ctx, struct gl_shared_state *shared) _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 @@ -341,6 +338,21 @@ _mesa_free_shared_state(GLcontext *ctx, struct gl_shared_state *shared) _mesa_DeleteHashTable(shared->RenderBuffers); #endif +#if FEATURE_ARB_vertex_buffer_object + ctx->Driver.DeleteBuffer(ctx, shared->NullBufferObj); +#endif + +#if FEATURE_ARB_sync + { + struct simple_node *node; + struct simple_node *temp; + + foreach_s(node, temp, & shared->SyncObjects) { + _mesa_unref_sync_object(ctx, (struct gl_sync_object *) node); + } + } +#endif + /* * Free texture objects (after FBOs since some textures might have * been bound to FBOs). diff --git a/src/mesa/main/simple_list.h b/src/mesa/main/simple_list.h index 63475f6f74..ff7f888238 100644 --- a/src/mesa/main/simple_list.h +++ b/src/mesa/main/simple_list.h @@ -37,6 +37,11 @@ #ifndef _SIMPLE_LIST_H #define _SIMPLE_LIST_H +struct simple_node { + struct simple_node *next; + struct simple_node *prev; +}; + /** * Remove an element from list. * diff --git a/src/mesa/main/state.c b/src/mesa/main/state.c index 51726461b6..140a998df2 100644 --- a/src/mesa/main/state.c +++ b/src/mesa/main/state.c @@ -64,114 +64,159 @@ update_separate_specular(GLcontext *ctx) /** - * Update state dependent on vertex arrays. + * Compute the index of the last array element that can be safely accessed + * in a vertex array. We can really only do this when the array lives in + * a VBO. + * The array->_MaxElement field will be updated. + * Later in glDrawArrays/Elements/etc we can do some bounds checking. + */ +static void +compute_max_element(struct gl_client_array *array) +{ + assert(array->Enabled); + if (array->BufferObj->Name) { + GLsizeiptrARB offset = (GLsizeiptrARB) array->Ptr; + GLsizeiptrARB obj_size = (GLsizeiptrARB) array->BufferObj->Size; + + if (offset < obj_size) { + array->_MaxElement = (obj_size - offset + + array->StrideB - + array->_ElementSize) / array->StrideB; + } else { + array->_MaxElement = 0; + } + /* Compute the max element we can access in the VBO without going + * out of bounds. + */ + array->_MaxElement = ((GLsizeiptrARB) array->BufferObj->Size + - (GLsizeiptrARB) array->Ptr + array->StrideB + - array->_ElementSize) / array->StrideB; + } + else { + /* user-space array, no idea how big it is */ + array->_MaxElement = 2 * 1000 * 1000 * 1000; /* just a big number */ + } +} + + +/** + * Helper for update_arrays(). + * \return min(current min, array->_MaxElement). + */ +static GLuint +update_min(GLuint min, struct gl_client_array *array) +{ + compute_max_element(array); + return MIN2(min, array->_MaxElement); +} + + +/** + * Update ctx->Array._MaxElement (the max legal index into all enabled arrays). + * Need to do this upon new array state or new buffer object state. */ static void update_arrays( GLcontext *ctx ) { - GLuint i, min; + struct gl_array_object *arrayObj = ctx->Array.ArrayObj; + GLuint i, min = ~0; /* find min of _MaxElement values for all enabled arrays */ /* 0 */ if (ctx->VertexProgram._Current - && ctx->Array.ArrayObj->VertexAttrib[VERT_ATTRIB_POS].Enabled) { - min = ctx->Array.ArrayObj->VertexAttrib[VERT_ATTRIB_POS]._MaxElement; + && arrayObj->VertexAttrib[VERT_ATTRIB_POS].Enabled) { + min = update_min(min, &arrayObj->VertexAttrib[VERT_ATTRIB_POS]); } - else if (ctx->Array.ArrayObj->Vertex.Enabled) { - min = ctx->Array.ArrayObj->Vertex._MaxElement; - } - else { - /* can't draw anything without vertex positions! */ - min = 0; + else if (arrayObj->Vertex.Enabled) { + min = update_min(min, &arrayObj->Vertex); } /* 1 */ if (ctx->VertexProgram._Enabled - && ctx->Array.ArrayObj->VertexAttrib[VERT_ATTRIB_WEIGHT].Enabled) { - min = MIN2(min, ctx->Array.ArrayObj->VertexAttrib[VERT_ATTRIB_WEIGHT]._MaxElement); + && arrayObj->VertexAttrib[VERT_ATTRIB_WEIGHT].Enabled) { + min = update_min(min, &arrayObj->VertexAttrib[VERT_ATTRIB_WEIGHT]); } /* no conventional vertex weight array */ /* 2 */ if (ctx->VertexProgram._Enabled - && ctx->Array.ArrayObj->VertexAttrib[VERT_ATTRIB_NORMAL].Enabled) { - min = MIN2(min, ctx->Array.ArrayObj->VertexAttrib[VERT_ATTRIB_NORMAL]._MaxElement); + && arrayObj->VertexAttrib[VERT_ATTRIB_NORMAL].Enabled) { + min = update_min(min, &arrayObj->VertexAttrib[VERT_ATTRIB_NORMAL]); } - else if (ctx->Array.ArrayObj->Normal.Enabled) { - min = MIN2(min, ctx->Array.ArrayObj->Normal._MaxElement); + else if (arrayObj->Normal.Enabled) { + min = update_min(min, &arrayObj->Normal); } /* 3 */ if (ctx->VertexProgram._Enabled - && ctx->Array.ArrayObj->VertexAttrib[VERT_ATTRIB_COLOR0].Enabled) { - min = MIN2(min, ctx->Array.ArrayObj->VertexAttrib[VERT_ATTRIB_COLOR0]._MaxElement); + && arrayObj->VertexAttrib[VERT_ATTRIB_COLOR0].Enabled) { + min = update_min(min, &arrayObj->VertexAttrib[VERT_ATTRIB_COLOR0]); } - else if (ctx->Array.ArrayObj->Color.Enabled) { - min = MIN2(min, ctx->Array.ArrayObj->Color._MaxElement); + else if (arrayObj->Color.Enabled) { + min = update_min(min, &arrayObj->Color); } /* 4 */ if (ctx->VertexProgram._Enabled - && ctx->Array.ArrayObj->VertexAttrib[VERT_ATTRIB_COLOR1].Enabled) { - min = MIN2(min, ctx->Array.ArrayObj->VertexAttrib[VERT_ATTRIB_COLOR1]._MaxElement); + && arrayObj->VertexAttrib[VERT_ATTRIB_COLOR1].Enabled) { + min = update_min(min, &arrayObj->VertexAttrib[VERT_ATTRIB_COLOR1]); } - else if (ctx->Array.ArrayObj->SecondaryColor.Enabled) { - min = MIN2(min, ctx->Array.ArrayObj->SecondaryColor._MaxElement); + else if (arrayObj->SecondaryColor.Enabled) { + min = update_min(min, &arrayObj->SecondaryColor); } /* 5 */ if (ctx->VertexProgram._Enabled - && ctx->Array.ArrayObj->VertexAttrib[VERT_ATTRIB_FOG].Enabled) { - min = MIN2(min, ctx->Array.ArrayObj->VertexAttrib[VERT_ATTRIB_FOG]._MaxElement); + && arrayObj->VertexAttrib[VERT_ATTRIB_FOG].Enabled) { + min = update_min(min, &arrayObj->VertexAttrib[VERT_ATTRIB_FOG]); } - else if (ctx->Array.ArrayObj->FogCoord.Enabled) { - min = MIN2(min, ctx->Array.ArrayObj->FogCoord._MaxElement); + else if (arrayObj->FogCoord.Enabled) { + min = update_min(min, &arrayObj->FogCoord); } /* 6 */ if (ctx->VertexProgram._Enabled - && ctx->Array.ArrayObj->VertexAttrib[VERT_ATTRIB_COLOR_INDEX].Enabled) { - min = MIN2(min, ctx->Array.ArrayObj->VertexAttrib[VERT_ATTRIB_COLOR_INDEX]._MaxElement); + && arrayObj->VertexAttrib[VERT_ATTRIB_COLOR_INDEX].Enabled) { + min = update_min(min, &arrayObj->VertexAttrib[VERT_ATTRIB_COLOR_INDEX]); } - else if (ctx->Array.ArrayObj->Index.Enabled) { - min = MIN2(min, ctx->Array.ArrayObj->Index._MaxElement); + else if (arrayObj->Index.Enabled) { + min = update_min(min, &arrayObj->Index); } - /* 7 */ if (ctx->VertexProgram._Enabled - && ctx->Array.ArrayObj->VertexAttrib[VERT_ATTRIB_EDGEFLAG].Enabled) { - min = MIN2(min, ctx->Array.ArrayObj->VertexAttrib[VERT_ATTRIB_EDGEFLAG]._MaxElement); + && arrayObj->VertexAttrib[VERT_ATTRIB_EDGEFLAG].Enabled) { + min = update_min(min, &arrayObj->VertexAttrib[VERT_ATTRIB_EDGEFLAG]); } /* 8..15 */ for (i = VERT_ATTRIB_TEX0; i <= VERT_ATTRIB_TEX7; i++) { if (ctx->VertexProgram._Enabled - && ctx->Array.ArrayObj->VertexAttrib[i].Enabled) { - min = MIN2(min, ctx->Array.ArrayObj->VertexAttrib[i]._MaxElement); + && arrayObj->VertexAttrib[i].Enabled) { + min = update_min(min, &arrayObj->VertexAttrib[i]); } else if (i - VERT_ATTRIB_TEX0 < ctx->Const.MaxTextureCoordUnits - && ctx->Array.ArrayObj->TexCoord[i - VERT_ATTRIB_TEX0].Enabled) { - min = MIN2(min, ctx->Array.ArrayObj->TexCoord[i - VERT_ATTRIB_TEX0]._MaxElement); + && arrayObj->TexCoord[i - VERT_ATTRIB_TEX0].Enabled) { + min = update_min(min, &arrayObj->TexCoord[i - VERT_ATTRIB_TEX0]); } } /* 16..31 */ if (ctx->VertexProgram._Current) { - for (i = 0; i < Elements(ctx->Array.ArrayObj->VertexAttrib); i++) { - if (ctx->Array.ArrayObj->VertexAttrib[i].Enabled) { - min = MIN2(min, ctx->Array.ArrayObj->VertexAttrib[i]._MaxElement); + for (i = 0; i < Elements(arrayObj->VertexAttrib); i++) { + if (arrayObj->VertexAttrib[i].Enabled) { + min = update_min(min, &arrayObj->VertexAttrib[i]); } } } - if (ctx->Array.ArrayObj->EdgeFlag.Enabled) { - min = MIN2(min, ctx->Array.ArrayObj->EdgeFlag._MaxElement); + if (arrayObj->EdgeFlag.Enabled) { + min = update_min(min, &arrayObj->EdgeFlag); } /* _MaxElement is one past the last legal array element */ - ctx->Array._MaxElement = min; + arrayObj->_MaxElement = min; } @@ -501,7 +546,7 @@ _mesa_update_state_locked( GLcontext *ctx ) /* Determine which state flags effect vertex/fragment program state */ if (ctx->FragmentProgram._MaintainTexEnvProgram) { - prog_flags |= (_NEW_TEXTURE | _NEW_FOG | _DD_NEW_SEPARATE_SPECULAR | + prog_flags |= (_NEW_TEXTURE | _NEW_FOG | _NEW_ARRAY | _NEW_LIGHT | _NEW_POINT | _NEW_RENDERMODE | _NEW_PROGRAM); } @@ -548,7 +593,7 @@ _mesa_update_state_locked( GLcontext *ctx ) if (new_state & _DD_NEW_SEPARATE_SPECULAR) update_separate_specular( ctx ); - if (new_state & (_NEW_ARRAY | _NEW_PROGRAM)) + if (new_state & (_NEW_ARRAY | _NEW_PROGRAM | _NEW_BUFFER_OBJECT)) update_arrays( ctx ); if (new_state & (_NEW_BUFFERS | _NEW_VIEWPORT)) @@ -668,6 +713,6 @@ _mesa_set_vp_override(GLcontext *ctx, GLboolean flag) /* Set one of the bits which will trigger fragment program * regeneration: */ - ctx->NewState |= _NEW_ARRAY; + ctx->NewState |= _NEW_PROGRAM; } } diff --git a/src/mesa/main/syncobj.c b/src/mesa/main/syncobj.c new file mode 100644 index 0000000000..64f923ff91 --- /dev/null +++ b/src/mesa/main/syncobj.c @@ -0,0 +1,409 @@ +/* + * Copyright © 2009 Intel Corporation + * + * 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 (including the next + * paragraph) 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 + * THE AUTHORS OR COPYRIGHT HOLDERS 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 syncobj.c + * Sync object management. + * + * Unlike textures and other objects that are shared between contexts, sync + * objects are not bound to the context. As a result, the reference counting + * and delete behavior of sync objects is slightly different. References to + * sync objects are added: + * + * - By \c glFencSynce. This sets the initial reference count to 1. + * - At the start of \c glClientWaitSync. The reference is held for the + * duration of the wait call. + * + * References are removed: + * + * - By \c glDeleteSync. + * - At the end of \c glClientWaitSync. + * + * Additionally, drivers may call \c _mesa_ref_sync_object and + * \c _mesa_unref_sync_object as needed to implement \c ServerWaitSync. + * + * As with shader objects, sync object names become invalid as soon as + * \c glDeleteSync is called. For this reason \c glDeleteSync sets the + * \c DeletePending flag. All functions validate object handles by testing + * this flag. + * + * \note + * Only \c GL_ARB_sync objects are shared between contexts. If support is ever + * added for either \c GL_NV_fence or \c GL_APPLE_fence different semantics + * will need to be implemented. + * + * \author Ian Romanick <ian.d.romanick@intel.com> + */ + +#include "glheader.h" +#include "imports.h" +#include "context.h" +#include "macros.h" + +#if FEATURE_ARB_sync +#include "syncobj.h" + +static struct gl_sync_object * +_mesa_new_sync_object(GLcontext *ctx, GLenum type) +{ + struct gl_sync_object *s = MALLOC_STRUCT(gl_sync_object); + (void) ctx; + (void) type; + + return s; +} + + +static void +_mesa_delete_sync_object(GLcontext *ctx, struct gl_sync_object *syncObj) +{ + (void) ctx; + _mesa_free(syncObj); +} + + +static void +_mesa_fence_sync(GLcontext *ctx, struct gl_sync_object *syncObj, + GLenum condition, GLbitfield flags) +{ + (void) ctx; + (void) condition; + (void) flags; + + syncObj->StatusFlag = 1; +} + + +static void +_mesa_check_sync(GLcontext *ctx, struct gl_sync_object *syncObj) +{ + (void) ctx; + (void) syncObj; + + /* No-op for software rendering. Hardware drivers will need to determine + * whether the state of the sync object has changed. + */ +} + + +static void +_mesa_wait_sync(GLcontext *ctx, struct gl_sync_object *syncObj, + GLbitfield flags, GLuint64 timeout) +{ + (void) ctx; + (void) syncObj; + (void) flags; + (void) timeout; + + /* No-op for software rendering. Hardware drivers will need to wait until + * the state of the sync object changes or the timeout expires. + */ +} + + +void +_mesa_init_sync_object_functions(struct dd_function_table *driver) +{ + driver->NewSyncObject = _mesa_new_sync_object; + driver->FenceSync = _mesa_fence_sync; + driver->DeleteSyncObject = _mesa_delete_sync_object; + driver->CheckSync = _mesa_check_sync; + + /* Use the same no-op wait function for both. + */ + driver->ClientWaitSync = _mesa_wait_sync; + driver->ServerWaitSync = _mesa_wait_sync; +} + + +/** + * Allocate/init the context state related to sync objects. + */ +void +_mesa_init_sync(GLcontext *ctx) +{ + (void) ctx; +} + + +/** + * Free the context state related to sync objects. + */ +void +_mesa_free_sync_data(GLcontext *ctx) +{ + (void) ctx; +} + + +static int +_mesa_validate_sync(struct gl_sync_object *syncObj) +{ + return (syncObj != NULL) + && (syncObj->Type == GL_SYNC_FENCE) + && !syncObj->DeletePending; +} + + +void +_mesa_ref_sync_object(GLcontext *ctx, struct gl_sync_object *syncObj) +{ + _glthread_LOCK_MUTEX(ctx->Shared->Mutex); + syncObj->RefCount++; + _glthread_UNLOCK_MUTEX(ctx->Shared->Mutex); +} + + +void +_mesa_unref_sync_object(GLcontext *ctx, struct gl_sync_object *syncObj) +{ + _glthread_LOCK_MUTEX(ctx->Shared->Mutex); + syncObj->RefCount--; + if (syncObj->RefCount == 0) { + remove_from_list(& syncObj->link); + _glthread_UNLOCK_MUTEX(ctx->Shared->Mutex); + + ctx->Driver.DeleteSyncObject(ctx, syncObj); + } else { + _glthread_UNLOCK_MUTEX(ctx->Shared->Mutex); + } +} + + +GLboolean +_mesa_IsSync(GLsync sync) +{ + GET_CURRENT_CONTEXT(ctx); + struct gl_sync_object *const syncObj = (struct gl_sync_object *) sync; + ASSERT_OUTSIDE_BEGIN_END_WITH_RETVAL(ctx, GL_FALSE); + + return _mesa_validate_sync(syncObj) ? GL_TRUE : GL_FALSE; +} + + +void +_mesa_DeleteSync(GLsync sync) +{ + GET_CURRENT_CONTEXT(ctx); + struct gl_sync_object *const syncObj = (struct gl_sync_object *) sync; + ASSERT_OUTSIDE_BEGIN_END(ctx); + + /* From the GL_ARB_sync spec: + * + * DeleteSync will silently ignore a <sync> value of zero. An + * INVALID_VALUE error is generated if <sync> is neither zero nor the + * name of a sync object. + */ + if (sync == 0) { + return; + } + + if (!_mesa_validate_sync(syncObj)) { + _mesa_error(ctx, GL_INVALID_OPERATION, "glDeleteSync"); + return; + } + + /* If there are no client-waits or server-waits pending on this sync, delete + * the underlying object. + */ + syncObj->DeletePending = GL_TRUE; + _mesa_unref_sync_object(ctx, syncObj); +} + + +GLsync +_mesa_FenceSync(GLenum condition, GLbitfield flags) +{ + GET_CURRENT_CONTEXT(ctx); + struct gl_sync_object *syncObj; + ASSERT_OUTSIDE_BEGIN_END_WITH_RETVAL(ctx, 0); + + if (condition != GL_SYNC_GPU_COMMANDS_COMPLETE) { + _mesa_error(ctx, GL_INVALID_ENUM, "glFenceSync(condition=0x%x)", + condition); + return 0; + } + + if (flags != 0) { + _mesa_error(ctx, GL_INVALID_VALUE, "glFenceSync(flags=0x%x)", + condition); + return 0; + } + + syncObj = ctx->Driver.NewSyncObject(ctx, GL_SYNC_FENCE); + if (syncObj != NULL) { + syncObj->Type = GL_SYNC_FENCE; + /* The name is not currently used, and it is never visible to + * applications. If sync support is extended to provide support for + * NV_fence, this field will be used. We'll also need to add an object + * ID hashtable. + */ + syncObj->Name = 1; + syncObj->RefCount = 1; + syncObj->DeletePending = GL_FALSE; + syncObj->SyncCondition = condition; + syncObj->Flags = flags; + syncObj->StatusFlag = 0; + + ctx->Driver.FenceSync(ctx, syncObj, condition, flags); + + _glthread_LOCK_MUTEX(ctx->Shared->Mutex); + insert_at_tail(& ctx->Shared->SyncObjects, & syncObj->link); + _glthread_UNLOCK_MUTEX(ctx->Shared->Mutex); + + return (GLsync) syncObj; + } + + return NULL; +} + + +GLenum +_mesa_ClientWaitSync(GLsync sync, GLbitfield flags, GLuint64 timeout) +{ + GET_CURRENT_CONTEXT(ctx); + struct gl_sync_object *const syncObj = (struct gl_sync_object *) sync; + GLenum ret; + ASSERT_OUTSIDE_BEGIN_END_WITH_RETVAL(ctx, GL_WAIT_FAILED); + + if (!_mesa_validate_sync(syncObj)) { + _mesa_error(ctx, GL_INVALID_OPERATION, "glClientWaitSync"); + return GL_WAIT_FAILED; + } + + if ((flags & ~GL_SYNC_FLUSH_COMMANDS_BIT) != 0) { + _mesa_error(ctx, GL_INVALID_ENUM, "glClientWaitSync(flags=0x%x)", flags); + return GL_WAIT_FAILED; + } + + _mesa_ref_sync_object(ctx, syncObj); + + /* From the GL_ARB_sync spec: + * + * ClientWaitSync returns one of four status values. A return value of + * ALREADY_SIGNALED indicates that <sync> was signaled at the time + * ClientWaitSync was called. ALREADY_SIGNALED will always be returned + * if <sync> was signaled, even if the value of <timeout> is zero. + */ + ctx->Driver.CheckSync(ctx, syncObj); + if (syncObj->StatusFlag) { + ret = GL_ALREADY_SIGNALED; + } else { + ctx->Driver.ClientWaitSync(ctx, syncObj, flags, timeout); + + ret = syncObj->StatusFlag ? GL_CONDITION_SATISFIED : GL_TIMEOUT_EXPIRED; + } + + _mesa_unref_sync_object(ctx, syncObj); + return ret; +} + + +void +_mesa_WaitSync(GLsync sync, GLbitfield flags, GLuint64 timeout) +{ + GET_CURRENT_CONTEXT(ctx); + struct gl_sync_object *const syncObj = (struct gl_sync_object *) sync; + ASSERT_OUTSIDE_BEGIN_END(ctx); + + if (!_mesa_validate_sync(syncObj)) { + _mesa_error(ctx, GL_INVALID_OPERATION, "glWaitSync"); + return; + } + + if (flags != 0) { + _mesa_error(ctx, GL_INVALID_ENUM, "glWaitSync(flags=0x%x)", flags); + return; + } + + /* From the GL_ARB_sync spec: + * + * If the value of <timeout> is zero, then WaitSync does nothing. + */ + if (timeout == 0) { + return; + } + + ctx->Driver.ServerWaitSync(ctx, syncObj, flags, timeout); +} + + +void +_mesa_GetSynciv(GLsync sync, GLenum pname, GLsizei bufSize, GLsizei *length, + GLint *values) +{ + GET_CURRENT_CONTEXT(ctx); + struct gl_sync_object *const syncObj = (struct gl_sync_object *) sync; + GLsizei size = 0; + GLint v[1]; + ASSERT_OUTSIDE_BEGIN_END(ctx); + + if (!_mesa_validate_sync(syncObj)) { + _mesa_error(ctx, GL_INVALID_OPERATION, "glGetSynciv"); + return; + } + + switch (pname) { + case GL_OBJECT_TYPE: + v[0] = syncObj->Type; + size = 1; + break; + + case GL_SYNC_CONDITION: + v[0] = syncObj->SyncCondition; + size = 1; + break; + + case GL_SYNC_STATUS: + /* Update the state of the sync by dipping into the driver. Note that + * this call won't block. It just updates state in the common object + * data from the current driver state. + */ + ctx->Driver.CheckSync(ctx, syncObj); + + v[0] = (syncObj->StatusFlag) ? GL_SIGNALED : GL_UNSIGNALED; + size = 1; + break; + + case GL_SYNC_FLAGS: + v[0] = syncObj->Flags; + size = 1; + break; + + default: + _mesa_error(ctx, GL_INVALID_ENUM, "glGetSynciv(pname=0x%x)\n", pname); + return; + } + + if (size > 0) { + const GLsizei copy_count = MIN2(size, bufSize); + + _mesa_memcpy(values, v, sizeof(GLint) * copy_count); + } + + if (length != NULL) { + *length = size; + } +} + +#endif /* FEATURE_ARB_sync */ diff --git a/src/mesa/main/syncobj.h b/src/mesa/main/syncobj.h new file mode 100644 index 0000000000..fc160af289 --- /dev/null +++ b/src/mesa/main/syncobj.h @@ -0,0 +1,70 @@ +/* + * Copyright © 2009 Intel Corporation + * + * 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 (including the next + * paragraph) 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 + * THE AUTHORS OR COPYRIGHT HOLDERS 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 syncobj.h + * Sync object management. + * + * \author Ian Romanick <ian.d.romanick@intel.com> + */ + +#ifndef SYNCOBJ_H +#define SYNCOBJ_H + +#include "context.h" + +extern void +_mesa_init_sync_object_functions(struct dd_function_table *driver); + +extern void +_mesa_init_sync(GLcontext *); + +extern void +_mesa_free_sync_data(GLcontext *); + +extern void +_mesa_ref_sync_object(GLcontext *ctx, struct gl_sync_object *syncObj); + +extern void +_mesa_unref_sync_object(GLcontext *ctx, struct gl_sync_object *syncObj); + +extern GLboolean +_mesa_IsSync(GLsync sync); + +extern void +_mesa_DeleteSync(GLsync sync); + +extern GLsync +_mesa_FenceSync(GLenum condition, GLbitfield flags); + +extern GLenum +_mesa_ClientWaitSync(GLsync sync, GLbitfield flags, GLuint64 timeout); + +extern void +_mesa_WaitSync(GLsync sync, GLbitfield flags, GLuint64 timeout); + +extern void +_mesa_GetSynciv(GLsync sync, GLenum pname, GLsizei bufSize, GLsizei *length, + GLint *values); + +#endif /* SYNCOBJ_H */ diff --git a/src/mesa/main/texenv.c b/src/mesa/main/texenv.c index 4c04a7ed37..6d86a4275c 100644 --- a/src/mesa/main/texenv.c +++ b/src/mesa/main/texenv.c @@ -35,6 +35,7 @@ #include "main/enums.h" #include "main/macros.h" #include "main/texenv.h" +#include "main/texstate.h" #define TE_ERROR(errCode, msg, value) \ @@ -466,7 +467,7 @@ _mesa_TexEnvfv( GLenum target, GLenum pname, const GLfloat *param ) return; } - texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit]; + texUnit = _mesa_get_current_tex_unit(ctx); if (target == GL_TEXTURE_ENV) { switch (pname) { @@ -793,7 +794,7 @@ _mesa_GetTexEnvfv( GLenum target, GLenum pname, GLfloat *params ) return; } - texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit]; + texUnit = _mesa_get_current_tex_unit(ctx); if (target == GL_TEXTURE_ENV) { if (pname == GL_TEXTURE_ENV_COLOR) { @@ -857,7 +858,7 @@ _mesa_GetTexEnviv( GLenum target, GLenum pname, GLint *params ) return; } - texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit]; + texUnit = _mesa_get_current_tex_unit(ctx); if (target == GL_TEXTURE_ENV) { if (pname == GL_TEXTURE_ENV_COLOR) { @@ -908,12 +909,26 @@ _mesa_GetTexEnviv( GLenum target, GLenum pname, GLint *params ) } } -/* why does ATI_envmap_bumpmap require new entrypoints? Should just - reuse TexEnv ones... */ + +/** + * 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]; + GET_CURRENT_CONTEXT(ctx); + ASSERT_OUTSIDE_BEGIN_END(ctx); + + if (!ctx->Extensions.ATI_envmap_bumpmap) { + /* This isn't an "official" error case, but let's tell the user + * that something's wrong. + */ + _mesa_error(ctx, GL_INVALID_OPERATION, "glTexBumpParameterivATI"); + return; + } + if (pname == GL_BUMP_ROT_MATRIX_ATI) { /* hope that conversion is correct here */ p[0] = INT_TO_FLOAT( param[0] ); @@ -923,11 +938,12 @@ _mesa_TexBumpParameterivATI( GLenum pname, const GLint *param ) } else { p[0] = (GLfloat) param[0]; - p[1] = p[2] = p[3] = 0; /* init to zero, just to be safe */ + p[1] = p[2] = p[3] = 0.0F; /* init to zero, just to be safe */ } _mesa_TexBumpParameterfvATI( pname, p ); } + void GLAPIENTRY _mesa_TexBumpParameterfvATI( GLenum pname, const GLfloat *param ) { @@ -935,8 +951,12 @@ _mesa_TexBumpParameterfvATI( GLenum pname, const GLfloat *param ) GET_CURRENT_CONTEXT(ctx); ASSERT_OUTSIDE_BEGIN_END(ctx); - /* should return error if extension not supported? */ - texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit]; + if (!ctx->Extensions.ATI_envmap_bumpmap) { + _mesa_error(ctx, GL_INVALID_OPERATION, "glTexBumpParameterfvATI"); + return; + } + + texUnit = _mesa_get_current_tex_unit(ctx); if (pname == GL_BUMP_ROT_MATRIX_ATI) { if (TEST_EQ_4V(param, texUnit->RotMatrix)) @@ -955,17 +975,21 @@ _mesa_TexBumpParameterfvATI( GLenum pname, const GLfloat *param ) } } + void GLAPIENTRY _mesa_GetTexBumpParameterivATI( GLenum pname, GLint *param ) { const struct gl_texture_unit *texUnit; GLuint 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 (!ctx->Extensions.ATI_envmap_bumpmap) { + _mesa_error(ctx, GL_INVALID_OPERATION, "glGetTexBumpParameterivATI"); + return; + } + + texUnit = _mesa_get_current_tex_unit(ctx); if (pname == GL_BUMP_ROT_MATRIX_SIZE_ATI) { /* spec leaves open to support larger matrices. @@ -982,12 +1006,13 @@ _mesa_GetTexBumpParameterivATI( GLenum pname, GLint *param ) param[3] = FLOAT_TO_INT(texUnit->RotMatrix[3]); } else if (pname == GL_BUMP_NUM_TEX_UNITS_ATI) { + GLint count = 0; for (i = 0; i < ctx->Const.MaxTextureImageUnits; i++) { if (ctx->Const.SupportedBumpUnits & (1 << i)) { - temp++; + count++; } } - *param = temp; + *param = count; } else if (pname == GL_BUMP_TEX_UNITS_ATI) { for (i = 0; i < ctx->Const.MaxTextureImageUnits; i++) { @@ -1002,23 +1027,27 @@ _mesa_GetTexBumpParameterivATI( GLenum pname, GLint *param ) } } + void GLAPIENTRY _mesa_GetTexBumpParameterfvATI( GLenum pname, GLfloat *param ) { const struct gl_texture_unit *texUnit; GLuint 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 (!ctx->Extensions.ATI_envmap_bumpmap) { + _mesa_error(ctx, GL_INVALID_OPERATION, "glGetTexBumpParameterfvATI"); + return; + } + + texUnit = _mesa_get_current_tex_unit(ctx); 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; + *param = 4.0F; } else if (pname == GL_BUMP_ROT_MATRIX_ATI) { param[0] = texUnit->RotMatrix[0]; @@ -1027,12 +1056,13 @@ _mesa_GetTexBumpParameterfvATI( GLenum pname, GLfloat *param ) param[3] = texUnit->RotMatrix[3]; } else if (pname == GL_BUMP_NUM_TEX_UNITS_ATI) { + GLint count = 0; for (i = 0; i < ctx->Const.MaxTextureImageUnits; i++) { if (ctx->Const.SupportedBumpUnits & (1 << i)) { - temp++; + count++; } } - *param = (GLfloat) temp; + *param = (GLfloat) count; } else if (pname == GL_BUMP_TEX_UNITS_ATI) { for (i = 0; i < ctx->Const.MaxTextureImageUnits; i++) { @@ -1046,4 +1076,3 @@ _mesa_GetTexBumpParameterfvATI( GLenum pname, GLfloat *param ) return; } } - diff --git a/src/mesa/main/texenvprogram.c b/src/mesa/main/texenvprogram.c index 454d97506e..2f3e47e69e 100644 --- a/src/mesa/main/texenvprogram.c +++ b/src/mesa/main/texenvprogram.c @@ -27,8 +27,7 @@ **************************************************************************/ #include "glheader.h" -#include "macros.h" -#include "enums.h" +#include "imports.h" #include "shader/program.h" #include "shader/prog_parameter.h" #include "shader/prog_cache.h" @@ -62,6 +61,18 @@ struct texenvprog_cache_item struct texenvprog_cache_item *next; }; +static GLboolean +texenv_doing_secondary_color(GLcontext *ctx) +{ + if (ctx->Light.Enabled && + (ctx->Light.Model.ColorControl == GL_SEPARATE_SPECULAR_COLOR)) + return GL_TRUE; + + if (ctx->Fog.ColorSumEnabled) + return GL_TRUE; + + return GL_FALSE; +} /** * Up to nine instructions per tex unit, plus fog, specular color. @@ -71,8 +82,13 @@ struct texenvprog_cache_item #define DISASSEM (MESA_VERBOSE & VERBOSE_DISASSEM) struct mode_opt { - GLuint Source:4; - GLuint Operand:3; +#ifdef __GNUC__ + __extension__ GLubyte Source:4; /**< SRC_x */ + __extension__ GLubyte Operand:3; /**< OPR_x */ +#else + GLubyte Source; /**< SRC_x */ + GLubyte Operand; /**< OPR_x */ +#endif }; struct state_key { @@ -80,24 +96,26 @@ struct state_key { GLuint enabled_units:8; GLuint separate_specular:1; GLuint fog_enabled:1; - GLuint fog_mode:2; + GLuint fog_mode:2; /**< FOG_x */ GLuint inputs_available:12; + /* NOTE: This array of structs must be last! (see "keySize" below) */ struct { GLuint enabled:1; - GLuint source_index:3; /* one of TEXTURE_1D/2D/3D/CUBE/RECT_INDEX */ + GLuint source_index:3; /**< TEXTURE_x_INDEX */ GLuint shadow:1; GLuint ScaleShiftRGB:2; GLuint ScaleShiftA:2; - GLuint NumArgsRGB:3; - GLuint ModeRGB:5; - struct mode_opt OptRGB[MAX_COMBINER_TERMS]; + GLuint NumArgsRGB:3; /**< up to MAX_COMBINER_TERMS */ + GLuint ModeRGB:5; /**< MODE_x */ + + GLuint NumArgsA:3; /**< up to MAX_COMBINER_TERMS */ + GLuint ModeA:5; /**< MODE_x */ - GLuint NumArgsA:3; - GLuint ModeA:5; + struct mode_opt OptRGB[MAX_COMBINER_TERMS]; struct mode_opt OptA[MAX_COMBINER_TERMS]; - } unit[8]; + } unit[MAX_TEXTURE_UNITS]; }; #define FOG_LINEAR 0 @@ -228,25 +246,51 @@ static GLuint translate_mode( GLenum envMode, GLenum mode ) } } -#define TEXTURE_UNKNOWN_INDEX 7 -static GLuint translate_tex_src_bit( GLbitfield bit ) + +/** + * Do we need to clamp the results of the given texture env/combine mode? + * If the inputs to the mode are in [0,1] we don't always have to clamp + * the results. + */ +static GLboolean +need_saturate( GLuint mode ) { - /* make sure number of switch cases is correct */ - assert(NUM_TEXTURE_TARGETS == 7); - switch (bit) { - case TEXTURE_1D_BIT: return TEXTURE_1D_INDEX; - case TEXTURE_2D_BIT: return TEXTURE_2D_INDEX; - case TEXTURE_RECT_BIT: return TEXTURE_RECT_INDEX; - case TEXTURE_3D_BIT: return TEXTURE_3D_INDEX; - case TEXTURE_CUBE_BIT: return TEXTURE_CUBE_INDEX; - case TEXTURE_1D_ARRAY_BIT: return TEXTURE_1D_ARRAY_INDEX; - case TEXTURE_2D_ARRAY_BIT: return TEXTURE_2D_ARRAY_INDEX; + switch (mode) { + case MODE_REPLACE: + case MODE_MODULATE: + case MODE_INTERPOLATE: + return GL_FALSE; + case MODE_ADD: + case MODE_ADD_SIGNED: + case MODE_SUBTRACT: + case MODE_DOT3_RGB: + case MODE_DOT3_RGB_EXT: + case MODE_DOT3_RGBA: + case MODE_DOT3_RGBA_EXT: + case MODE_MODULATE_ADD_ATI: + case MODE_MODULATE_SIGNED_ADD_ATI: + case MODE_MODULATE_SUBTRACT_ATI: + case MODE_ADD_PRODUCTS: + case MODE_ADD_PRODUCTS_SIGNED: + case MODE_BUMP_ENVMAP_ATI: + return GL_TRUE; default: assert(0); - return TEXTURE_UNKNOWN_INDEX; } } + + +/** + * Translate TEXTURE_x_BIT to TEXTURE_x_INDEX. + */ +static GLuint translate_tex_src_bit( GLbitfield bit ) +{ + ASSERT(bit); + return _mesa_ffs(bit) - 1; +} + + #define VERT_BIT_TEX_ANY (0xff << VERT_ATTRIB_TEX0) #define VERT_RESULT_TEX_ANY (0xff << VERT_RESULT_TEX0) @@ -299,7 +343,7 @@ static GLbitfield get_fp_input_mask( GLcontext *ctx ) if (ctx->Light.Enabled) { fp_inputs |= FRAG_BIT_COL0; - if (ctx->_TriangleCaps & DD_SEPARATE_SPECULAR) + if (texenv_doing_secondary_color(ctx)) fp_inputs |= FRAG_BIT_COL1; } @@ -310,8 +354,10 @@ static GLbitfield get_fp_input_mask( GLcontext *ctx ) /* Then look at what might be varying as a result of enabled * arrays, etc: */ - if (varying_inputs & VERT_BIT_COLOR0) fp_inputs |= FRAG_BIT_COL0; - if (varying_inputs & VERT_BIT_COLOR1) fp_inputs |= FRAG_BIT_COL1; + if (varying_inputs & VERT_BIT_COLOR0) + fp_inputs |= FRAG_BIT_COL0; + if (varying_inputs & VERT_BIT_COLOR1) + fp_inputs |= FRAG_BIT_COL1; fp_inputs |= (((varying_inputs & VERT_BIT_TEX_ANY) >> VERT_ATTRIB_TEX0) << FRAG_ATTRIB_TEX0); @@ -340,8 +386,10 @@ static GLbitfield get_fp_input_mask( GLcontext *ctx ) if (ctx->Point.PointSprite) vp_outputs |= FRAG_BITS_TEX_ANY; - if (vp_outputs & (1 << VERT_RESULT_COL0)) fp_inputs |= FRAG_BIT_COL0; - if (vp_outputs & (1 << VERT_RESULT_COL1)) fp_inputs |= FRAG_BIT_COL1; + if (vp_outputs & (1 << VERT_RESULT_COL0)) + fp_inputs |= FRAG_BIT_COL0; + if (vp_outputs & (1 << VERT_RESULT_COL1)) + fp_inputs |= FRAG_BIT_COL1; fp_inputs |= (((vp_outputs & VERT_RESULT_TEX_ANY) >> VERT_RESULT_TEX0) << FRAG_ATTRIB_TEX0); @@ -355,55 +403,55 @@ static GLbitfield get_fp_input_mask( GLcontext *ctx ) * Examine current texture environment state and generate a unique * key to identify it. */ -static void make_state_key( GLcontext *ctx, struct state_key *key ) +static GLuint make_state_key( GLcontext *ctx, struct state_key *key ) { GLuint i, j; GLbitfield inputs_referenced = FRAG_BIT_COL0; - GLbitfield inputs_available = get_fp_input_mask( ctx ); + const GLbitfield inputs_available = get_fp_input_mask( ctx ); + GLuint keySize; memset(key, 0, sizeof(*key)); /* _NEW_TEXTURE */ for (i = 0; i < ctx->Const.MaxTextureUnits; i++) { const struct gl_texture_unit *texUnit = &ctx->Texture.Unit[i]; + const struct gl_texture_object *texObj = texUnit->_Current; + const struct gl_tex_env_combine_state *comb = texUnit->_CurrentCombine; GLenum format; if (!texUnit->_ReallyEnabled || !texUnit->Enabled) continue; - format = texUnit->_Current->Image[0][texUnit->_Current->BaseLevel]->_BaseFormat; + format = texObj->Image[0][texObj->BaseLevel]->_BaseFormat; key->unit[i].enabled = 1; key->enabled_units |= (1<<i); - key->nr_enabled_units = i+1; + key->nr_enabled_units = i + 1; inputs_referenced |= FRAG_BIT_TEX(i); - key->unit[i].source_index = - translate_tex_src_bit(texUnit->_ReallyEnabled); - key->unit[i].shadow = ((texUnit->_Current->CompareMode == GL_COMPARE_R_TO_TEXTURE) && + key->unit[i].source_index = + translate_tex_src_bit(texUnit->_ReallyEnabled); + + key->unit[i].shadow = ((texObj->CompareMode == GL_COMPARE_R_TO_TEXTURE) && ((format == GL_DEPTH_COMPONENT) || (format == GL_DEPTH_STENCIL_EXT))); - key->unit[i].NumArgsRGB = texUnit->_CurrentCombine->_NumArgsRGB; - key->unit[i].NumArgsA = texUnit->_CurrentCombine->_NumArgsA; + key->unit[i].NumArgsRGB = comb->_NumArgsRGB; + key->unit[i].NumArgsA = comb->_NumArgsA; key->unit[i].ModeRGB = - translate_mode(texUnit->EnvMode, texUnit->_CurrentCombine->ModeRGB); + translate_mode(texUnit->EnvMode, comb->ModeRGB); key->unit[i].ModeA = - translate_mode(texUnit->EnvMode, texUnit->_CurrentCombine->ModeA); + translate_mode(texUnit->EnvMode, comb->ModeA); - key->unit[i].ScaleShiftRGB = texUnit->_CurrentCombine->ScaleShiftRGB; - key->unit[i].ScaleShiftA = texUnit->_CurrentCombine->ScaleShiftA; + key->unit[i].ScaleShiftRGB = comb->ScaleShiftRGB; + key->unit[i].ScaleShiftA = comb->ScaleShiftA; for (j = 0; j < MAX_COMBINER_TERMS; j++) { - key->unit[i].OptRGB[j].Operand = - translate_operand(texUnit->_CurrentCombine->OperandRGB[j]); - key->unit[i].OptA[j].Operand = - translate_operand(texUnit->_CurrentCombine->OperandA[j]); - key->unit[i].OptRGB[j].Source = - translate_source(texUnit->_CurrentCombine->SourceRGB[j]); - key->unit[i].OptA[j].Source = - translate_source(texUnit->_CurrentCombine->SourceA[j]); + key->unit[i].OptRGB[j].Operand = translate_operand(comb->OperandRGB[j]); + key->unit[i].OptA[j].Operand = translate_operand(comb->OperandA[j]); + key->unit[i].OptRGB[j].Source = translate_source(comb->SourceRGB[j]); + key->unit[i].OptA[j].Source = translate_source(comb->SourceA[j]); } if (key->unit[i].ModeRGB == MODE_BUMP_ENVMAP_ATI) { @@ -417,8 +465,8 @@ static void make_state_key( GLcontext *ctx, struct state_key *key ) } } - /* _DD_NEW_SEPARATE_SPECULAR */ - if (ctx->_TriangleCaps & DD_SEPARATE_SPECULAR) { + /* _NEW_LIGHT | _NEW_FOG */ + if (texenv_doing_secondary_color(ctx)) { key->separate_specular = 1; inputs_referenced |= FRAG_BIT_COL1; } @@ -431,8 +479,15 @@ static void make_state_key( GLcontext *ctx, struct state_key *key ) } key->inputs_available = (inputs_available & inputs_referenced); + + /* compute size of state key, ignoring unused texture units */ + keySize = sizeof(*key) - sizeof(key->unit) + + key->nr_enabled_units * sizeof(key->unit[0]); + + return keySize; } + /** * Use uregs to represent registers internally, translate to Mesa's * expected formats on emit. @@ -450,10 +505,8 @@ struct ureg { GLuint file:4; GLuint idx:8; GLuint negatebase:1; - GLuint abs:1; - GLuint negateabs:1; GLuint swz:12; - GLuint pad:5; + GLuint pad:7; }; static const struct ureg undef = { @@ -461,8 +514,6 @@ static const struct ureg undef = { ~0, 0, 0, - 0, - 0, 0 }; @@ -471,7 +522,6 @@ static const struct ureg undef = { */ struct texenv_fragment_program { struct gl_fragment_program *program; - GLcontext *ctx; struct state_key *state; GLbitfield alu_temps; /**< Track texture indirections, see spec. */ @@ -508,8 +558,6 @@ static struct ureg make_ureg(GLuint file, GLuint idx) reg.file = file; reg.idx = idx; reg.negatebase = 0; - reg.abs = 0; - reg.negateabs = 0; reg.swz = SWIZZLE_NOOP; reg.pad = 0; return reg; @@ -675,7 +723,7 @@ static void emit_arg( struct prog_src_register *reg, reg->Index = ureg.idx; reg->Swizzle = ureg.swz; reg->Negate = ureg.negatebase ? NEGATE_XYZW : NEGATE_NONE; - reg->Abs = ureg.abs; + reg->Abs = GL_FALSE; } static void emit_dst( struct prog_dst_register *dst, @@ -698,7 +746,7 @@ emit_op(struct texenv_fragment_program *p, struct ureg src1, struct ureg src2 ) { - GLuint nr = p->program->Base.NumInstructions++; + const GLuint nr = p->program->Base.NumInstructions++; struct prog_instruction *inst = &p->program->Base.Instructions[nr]; assert(nr < MAX_INSTRUCTIONS); @@ -936,17 +984,22 @@ static struct ureg emit_combine_source( struct texenv_fragment_program *p, } } +/** + * Check if the RGB and Alpha sources and operands match for the given + * texture unit's combinder state. When the RGB and A sources and + * operands match, we can emit fewer instructions. + */ static GLboolean args_match( const struct state_key *key, GLuint unit ) { - GLuint i, nr = key->unit[unit].NumArgsRGB; + GLuint i, numArgs = key->unit[unit].NumArgsRGB; - for (i = 0 ; i < nr ; i++) { + for (i = 0; i < numArgs; i++) { if (key->unit[unit].OptA[i].Source != key->unit[unit].OptRGB[i].Source) return GL_FALSE; - switch(key->unit[unit].OptA[i].Operand) { + switch (key->unit[unit].OptA[i].Operand) { case OPR_SRC_ALPHA: - switch(key->unit[unit].OptRGB[i].Operand) { + switch (key->unit[unit].OptRGB[i].Operand) { case OPR_SRC_COLOR: case OPR_SRC_ALPHA: break; @@ -955,7 +1008,7 @@ static GLboolean args_match( const struct state_key *key, GLuint unit ) } break; case OPR_ONE_MINUS_SRC_ALPHA: - switch(key->unit[unit].OptRGB[i].Operand) { + switch (key->unit[unit].OptRGB[i].Operand) { case OPR_ONE_MINUS_SRC_COLOR: case OPR_ONE_MINUS_SRC_ALPHA: break; @@ -1097,7 +1150,7 @@ static struct ureg emit_texenv(struct texenv_fragment_program *p, GLuint unit) { const struct state_key *key = p->state; - GLboolean saturate; + GLboolean rgb_saturate, alpha_saturate; GLuint rgb_shift, alpha_shift; struct ureg out, dest; @@ -1127,7 +1180,19 @@ emit_texenv(struct texenv_fragment_program *p, GLuint unit) /* If we'll do rgb/alpha shifting don't saturate in emit_combine(). * We don't want to clamp twice. */ - saturate = !(rgb_shift || alpha_shift); + if (rgb_shift) + rgb_saturate = GL_FALSE; /* saturate after rgb shift */ + else if (need_saturate(key->unit[unit].ModeRGB)) + rgb_saturate = GL_TRUE; + else + rgb_saturate = GL_FALSE; + + if (alpha_shift) + alpha_saturate = GL_FALSE; /* saturate after alpha shift */ + else if (need_saturate(key->unit[unit].ModeA)) + alpha_saturate = GL_TRUE; + else + alpha_saturate = GL_FALSE; /* If this is the very last calculation, emit direct to output reg: */ @@ -1143,7 +1208,7 @@ emit_texenv(struct texenv_fragment_program *p, GLuint unit) */ if (key->unit[unit].ModeRGB == key->unit[unit].ModeA && args_match(key, unit)) { - out = emit_combine( p, dest, WRITEMASK_XYZW, saturate, + out = emit_combine( p, dest, WRITEMASK_XYZW, rgb_saturate, unit, key->unit[unit].NumArgsRGB, key->unit[unit].ModeRGB, @@ -1151,7 +1216,7 @@ emit_texenv(struct texenv_fragment_program *p, GLuint unit) } else if (key->unit[unit].ModeRGB == MODE_DOT3_RGBA_EXT || key->unit[unit].ModeRGB == MODE_DOT3_RGBA) { - out = emit_combine( p, dest, WRITEMASK_XYZW, saturate, + out = emit_combine( p, dest, WRITEMASK_XYZW, rgb_saturate, unit, key->unit[unit].NumArgsRGB, key->unit[unit].ModeRGB, @@ -1161,12 +1226,12 @@ emit_texenv(struct texenv_fragment_program *p, GLuint unit) /* Need to do something to stop from re-emitting identical * argument calculations here: */ - out = emit_combine( p, dest, WRITEMASK_XYZ, saturate, + out = emit_combine( p, dest, WRITEMASK_XYZ, rgb_saturate, unit, key->unit[unit].NumArgsRGB, key->unit[unit].ModeRGB, key->unit[unit].OptRGB); - out = emit_combine( p, dest, WRITEMASK_W, saturate, + out = emit_combine( p, dest, WRITEMASK_W, alpha_saturate, unit, key->unit[unit].NumArgsA, key->unit[unit].ModeA, @@ -1177,8 +1242,7 @@ emit_texenv(struct texenv_fragment_program *p, GLuint unit) */ if (alpha_shift || rgb_shift) { struct ureg shift; - - saturate = GL_TRUE; /* always saturate at this point */ + GLboolean saturate = GL_TRUE; /* always saturate at this point */ if (rgb_shift == alpha_shift) { shift = register_scalar_const(p, (GLfloat)(1<<rgb_shift)); @@ -1204,7 +1268,7 @@ 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 texTarget = p->state->unit[unit].source_index; + const GLuint texTarget = p->state->unit[unit].source_index; struct ureg texcoord; struct ureg tmp = get_tex_temp( p ); @@ -1216,9 +1280,6 @@ static void load_texture( struct texenv_fragment_program *p, GLuint unit ) 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) { @@ -1277,7 +1338,7 @@ static GLboolean load_texenv_source( struct texenv_fragment_program *p, * Generate instructions for loading all texture source terms. */ static GLboolean -load_texunit_sources( struct texenv_fragment_program *p, int unit ) +load_texunit_sources( struct texenv_fragment_program *p, GLuint unit ) { const struct state_key *key = p->state; GLuint i; @@ -1297,7 +1358,7 @@ load_texunit_sources( struct texenv_fragment_program *p, int unit ) * Generate instructions for loading bump map textures. */ static GLboolean -load_texunit_bumpmap( struct texenv_fragment_program *p, int unit ) +load_texunit_bumpmap( struct texenv_fragment_program *p, GLuint unit ) { const struct state_key *key = p->state; GLuint bumpedUnitNr = key->unit[unit].OptRGB[1].Source - SRC_TEXTURE0; @@ -1313,17 +1374,20 @@ load_texunit_bumpmap( struct texenv_fragment_program *p, int 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) */ + /* 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 ); + /* 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; } @@ -1342,7 +1406,6 @@ create_new_program(GLcontext *ctx, struct state_key *key, struct ureg cf, out; _mesa_memset(&p, 0, sizeof(p)); - p.ctx = ctx; p.state = key; p.program = program; @@ -1351,17 +1414,17 @@ 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; + p.program->Base.String = NULL; + p.program->Base.NumTexIndirections = 1; /* is this right? */ p.program->Base.NumTexInstructions = 0; p.program->Base.NumAluInstructions = 0; - p.program->Base.String = NULL; - p.program->Base.NumInstructions = - p.program->Base.NumTemporaries = - p.program->Base.NumParameters = - p.program->Base.NumAttributes = p.program->Base.NumAddressRegs = 0; + p.program->Base.NumInstructions = 0; + p.program->Base.NumTemporaries = 0; + p.program->Base.NumParameters = 0; + p.program->Base.NumAttributes = 0; + p.program->Base.NumAddressRegs = 0; p.program->Base.Parameters = _mesa_new_parameter_list(); - - p.program->Base.InputsRead = 0; + p.program->Base.InputsRead = 0x0; p.program->Base.OutputsWritten = 1 << FRAG_RESULT_COLOR; for (unit = 0; unit < ctx->Const.MaxTextureUnits; unit++) { @@ -1378,10 +1441,12 @@ create_new_program(GLcontext *ctx, struct state_key *key, release_temps(ctx, &p); if (key->enabled_units) { - GLboolean needbumpstage = GL_FALSE; + 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) { + for (unit = 0; unit < key->nr_enabled_units; unit++) + if (key->unit[unit].enabled && + key->unit[unit].ModeRGB == MODE_BUMP_ENVMAP_ATI) { needbumpstage = GL_TRUE; load_texunit_bumpmap( &p, unit ); } @@ -1392,7 +1457,7 @@ create_new_program(GLcontext *ctx, struct state_key *key, * all referenced texture sources and emit texld instructions * for each: */ - for (unit = 0 ; unit < ctx->Const.MaxTextureUnits ; unit++) + for (unit = 0; unit < key->nr_enabled_units; unit++) if (key->unit[unit].enabled) { load_texunit_sources( &p, unit ); p.last_tex_stage = unit; @@ -1400,8 +1465,8 @@ create_new_program(GLcontext *ctx, struct state_key *key, /* Second pass - emit combine instructions to build final color: */ - for (unit = 0 ; unit < ctx->Const.MaxTextureUnits; unit++) - if (key->enabled_units & (1<<unit)) { + for (unit = 0; unit < key->nr_enabled_units; unit++) + if (key->unit[unit].enabled) { p.src_previous = emit_texenv( &p, unit ); reserve_temp(&p, p.src_previous); /* don't re-use this temp reg */ release_temps(ctx, &p); /* release all temps */ @@ -1434,9 +1499,11 @@ create_new_program(GLcontext *ctx, struct state_key *key, * a reduced value and not what is expected in FogOption */ p.program->FogOption = ctx->Fog.Mode; - p.program->Base.InputsRead |= FRAG_BIT_FOGC; /* XXX new */ - } else + p.program->Base.InputsRead |= FRAG_BIT_FOGC; + } + else { p.program->FogOption = GL_NONE; + } if (p.program->Base.NumTexIndirections > ctx->Const.FragmentProgram.MaxTexIndirections) program_error(&p, "Exceeded max nr indirect texture lookups"); @@ -1489,12 +1556,13 @@ _mesa_get_fixed_func_fragment_program(GLcontext *ctx) { struct gl_fragment_program *prog; struct state_key key; + GLuint keySize; - make_state_key(ctx, &key); + keySize = make_state_key(ctx, &key); prog = (struct gl_fragment_program *) _mesa_search_program_cache(ctx->FragmentProgram.Cache, - &key, sizeof(key)); + &key, keySize); if (!prog) { prog = (struct gl_fragment_program *) @@ -1503,7 +1571,7 @@ _mesa_get_fixed_func_fragment_program(GLcontext *ctx) create_new_program(ctx, &key, prog); _mesa_program_cache_insert(ctx, ctx->FragmentProgram.Cache, - &key, sizeof(key), &prog->Base); + &key, keySize, &prog->Base); } return prog; diff --git a/src/mesa/main/texgetimage.c b/src/mesa/main/texgetimage.c index 02409d8009..14d6fc7659 100644 --- a/src/mesa/main/texgetimage.c +++ b/src/mesa/main/texgetimage.c @@ -30,11 +30,14 @@ #include "glheader.h" +#include "bufferobj.h" #include "context.h" #include "image.h" #include "texcompress.h" #include "texformat.h" #include "texgetimage.h" +#include "teximage.h" +#include "texstate.h" @@ -116,7 +119,7 @@ _mesa_get_teximage(GLcontext *ctx, GLenum target, GLint level, { const GLuint dimensions = (target == GL_TEXTURE_3D) ? 3 : 2; - if (ctx->Pack.BufferObj->Name) { + if (_mesa_is_bufferobj(ctx->Pack.BufferObj)) { /* Packing texture image into a PBO. * Map the (potentially) VRAM-based buffer into our process space so * we can write into it with the code below. @@ -296,7 +299,7 @@ _mesa_get_teximage(GLcontext *ctx, GLenum target, GLint level, } /* img */ } - if (ctx->Pack.BufferObj->Name) { + if (_mesa_is_bufferobj(ctx->Pack.BufferObj)) { ctx->Driver.UnmapBuffer(ctx, GL_PIXEL_PACK_BUFFER_EXT, ctx->Pack.BufferObj); } @@ -316,7 +319,7 @@ _mesa_get_compressed_teximage(GLcontext *ctx, GLenum target, GLint level, { GLuint size; - if (ctx->Pack.BufferObj->Name) { + if (_mesa_is_bufferobj(ctx->Pack.BufferObj)) { /* pack texture image into a PBO */ GLubyte *buf; if ((const GLubyte *) img + texImage->CompressedSize > @@ -349,8 +352,230 @@ _mesa_get_compressed_teximage(GLcontext *ctx, GLenum target, GLint level, /* just memcpy, no pixelstore or pixel transfer */ _mesa_memcpy(img, texImage->Data, size); - if (ctx->Pack.BufferObj->Name) { + if (_mesa_is_bufferobj(ctx->Pack.BufferObj)) { ctx->Driver.UnmapBuffer(ctx, GL_PIXEL_PACK_BUFFER_EXT, ctx->Pack.BufferObj); } } + + + +/** + * Do error checking for a glGetTexImage() call. + * \return GL_TRUE if any error, GL_FALSE if no errors. + */ +static GLboolean +getteximage_error_check(GLcontext *ctx, GLenum target, GLint level, + GLenum format, GLenum type, GLvoid *pixels ) +{ + const struct gl_texture_unit *texUnit; + struct gl_texture_object *texObj; + struct gl_texture_image *texImage; + const GLuint maxLevels = _mesa_max_texture_levels(ctx, target); + + if (maxLevels == 0) { + _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexImage(target=0x%x)", target); + return GL_TRUE; + } + + if (level < 0 || level >= maxLevels) { + _mesa_error( ctx, GL_INVALID_VALUE, "glGetTexImage(level)" ); + return GL_TRUE; + } + + if (_mesa_sizeof_packed_type(type) <= 0) { + _mesa_error( ctx, GL_INVALID_ENUM, "glGetTexImage(type)" ); + return GL_TRUE; + } + + if (_mesa_components_in_format(format) <= 0 || + format == GL_STENCIL_INDEX) { + _mesa_error( ctx, GL_INVALID_ENUM, "glGetTexImage(format)" ); + return GL_TRUE; + } + + if (!ctx->Extensions.EXT_paletted_texture && _mesa_is_index_format(format)) { + _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexImage(format)"); + return GL_TRUE; + } + + if (!ctx->Extensions.ARB_depth_texture && _mesa_is_depth_format(format)) { + _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexImage(format)"); + return GL_TRUE; + } + + if (!ctx->Extensions.MESA_ycbcr_texture && _mesa_is_ycbcr_format(format)) { + _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexImage(format)"); + return GL_TRUE; + } + + if (!ctx->Extensions.EXT_packed_depth_stencil + && _mesa_is_depthstencil_format(format)) { + _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexImage(format)"); + return GL_TRUE; + } + + if (!ctx->Extensions.ATI_envmap_bumpmap + && _mesa_is_dudv_format(format)) { + _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexImage(format)"); + return GL_TRUE; + } + + texUnit = _mesa_get_current_tex_unit(ctx); + texObj = _mesa_select_tex_object(ctx, texUnit, target); + + if (!texObj || _mesa_is_proxy_texture(target)) { + _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexImage(target)"); + return GL_TRUE; + } + + texImage = _mesa_select_tex_image(ctx, texObj, target, level); + if (!texImage) { + /* out of memory */ + return GL_TRUE; + } + + /* Make sure the requested image format is compatible with the + * texture's format. Note that a color index texture can be converted + * to RGBA so that combo is allowed. + */ + if (_mesa_is_color_format(format) + && !_mesa_is_color_format(texImage->TexFormat->BaseFormat) + && !_mesa_is_index_format(texImage->TexFormat->BaseFormat)) { + _mesa_error(ctx, GL_INVALID_OPERATION, "glGetTexImage(format mismatch)"); + return GL_TRUE; + } + else if (_mesa_is_index_format(format) + && !_mesa_is_index_format(texImage->TexFormat->BaseFormat)) { + _mesa_error(ctx, GL_INVALID_OPERATION, "glGetTexImage(format mismatch)"); + return GL_TRUE; + } + else if (_mesa_is_depth_format(format) + && !_mesa_is_depth_format(texImage->TexFormat->BaseFormat) + && !_mesa_is_depthstencil_format(texImage->TexFormat->BaseFormat)) { + _mesa_error(ctx, GL_INVALID_OPERATION, "glGetTexImage(format mismatch)"); + return GL_TRUE; + } + else if (_mesa_is_ycbcr_format(format) + && !_mesa_is_ycbcr_format(texImage->TexFormat->BaseFormat)) { + _mesa_error(ctx, GL_INVALID_OPERATION, "glGetTexImage(format mismatch)"); + return GL_TRUE; + } + else if (_mesa_is_depthstencil_format(format) + && !_mesa_is_depthstencil_format(texImage->TexFormat->BaseFormat)) { + _mesa_error(ctx, GL_INVALID_OPERATION, "glGetTexImage(format mismatch)"); + return GL_TRUE; + } + else if (_mesa_is_dudv_format(format) + && !_mesa_is_dudv_format(texImage->TexFormat->BaseFormat)) { + _mesa_error(ctx, GL_INVALID_OPERATION, "glGetTexImage(format mismatch)"); + return GL_TRUE; + } + + if (_mesa_is_bufferobj(ctx->Pack.BufferObj)) { + /* packing texture image into a PBO */ + const GLuint dimensions = (target == GL_TEXTURE_3D) ? 3 : 2; + if (!_mesa_validate_pbo_access(dimensions, &ctx->Pack, texImage->Width, + texImage->Height, texImage->Depth, + format, type, pixels)) { + _mesa_error(ctx, GL_INVALID_OPERATION, + "glGetTexImage(invalid PBO access)"); + return GL_TRUE; + } + } + + return GL_FALSE; +} + + + +/** + * Get texture image. Called by glGetTexImage. + * + * \param target texture target. + * \param level image level. + * \param format pixel data format for returned image. + * \param type pixel data type for returned image. + * \param pixels returned pixel data. + */ +void GLAPIENTRY +_mesa_GetTexImage( GLenum target, GLint level, GLenum format, + GLenum type, GLvoid *pixels ) +{ + const struct gl_texture_unit *texUnit; + struct gl_texture_object *texObj; + GET_CURRENT_CONTEXT(ctx); + ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx); + + if (getteximage_error_check(ctx, target, level, format, type, pixels)) { + return; + } + + texUnit = _mesa_get_current_tex_unit(ctx); + texObj = _mesa_select_tex_object(ctx, texUnit, target); + + _mesa_lock_texture(ctx, texObj); + { + struct gl_texture_image *texImage = + _mesa_select_tex_image(ctx, texObj, target, level); + + /* typically, this will call _mesa_get_teximage() */ + ctx->Driver.GetTexImage(ctx, target, level, format, type, pixels, + texObj, texImage); + } + _mesa_unlock_texture(ctx, texObj); +} + + +void GLAPIENTRY +_mesa_GetCompressedTexImageARB(GLenum target, GLint level, GLvoid *img) +{ + const struct gl_texture_unit *texUnit; + struct gl_texture_object *texObj; + struct gl_texture_image *texImage; + GLint maxLevels; + GET_CURRENT_CONTEXT(ctx); + ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx); + + texUnit = _mesa_get_current_tex_unit(ctx); + texObj = _mesa_select_tex_object(ctx, texUnit, target); + if (!texObj) { + _mesa_error(ctx, GL_INVALID_ENUM, "glGetCompressedTexImageARB"); + return; + } + + maxLevels = _mesa_max_texture_levels(ctx, target); + ASSERT(maxLevels > 0); /* 0 indicates bad target, caught above */ + + if (level < 0 || level >= maxLevels) { + _mesa_error(ctx, GL_INVALID_VALUE, "glGetCompressedTexImageARB(level)"); + return; + } + + if (_mesa_is_proxy_texture(target)) { + _mesa_error(ctx, GL_INVALID_ENUM, "glGetCompressedTexImageARB(target)"); + return; + } + + _mesa_lock_texture(ctx, texObj); + { + texImage = _mesa_select_tex_image(ctx, texObj, target, level); + if (texImage) { + if (texImage->IsCompressed) { + /* this typically calls _mesa_get_compressed_teximage() */ + ctx->Driver.GetCompressedTexImage(ctx, target, level, img, + texObj, texImage); + } + else { + _mesa_error(ctx, GL_INVALID_OPERATION, + "glGetCompressedTexImageARB"); + } + } + else { + /* probably invalid mipmap level */ + _mesa_error(ctx, GL_INVALID_VALUE, + "glGetCompressedTexImageARB(level)"); + } + } + _mesa_unlock_texture(ctx, texObj); +} diff --git a/src/mesa/main/texgetimage.h b/src/mesa/main/texgetimage.h index 01f486e8f0..088d27c7e1 100644 --- a/src/mesa/main/texgetimage.h +++ b/src/mesa/main/texgetimage.h @@ -43,4 +43,13 @@ _mesa_get_compressed_teximage(GLcontext *ctx, GLenum target, GLint level, +extern void GLAPIENTRY +_mesa_GetTexImage( GLenum target, GLint level, + GLenum format, GLenum type, GLvoid *pixels ); + + +extern void GLAPIENTRY +_mesa_GetCompressedTexImageARB(GLenum target, GLint lod, GLvoid *img); + + #endif /* TEXGETIMAGE_H */ diff --git a/src/mesa/main/teximage.c b/src/mesa/main/teximage.c index 6e21066537..a8160c2735 100644 --- a/src/mesa/main/teximage.c +++ b/src/mesa/main/teximage.c @@ -1,6 +1,6 @@ /* * mesa 3-D graphics library - * Version: 7.5 + * Version: 7.6 * * Copyright (C) 1999-2008 Brian Paul All Rights Reserved. * Copyright (C) 2009 VMware, Inc. All Rights Reserved. @@ -36,6 +36,7 @@ #if FEATURE_convolve #include "convolve.h" #endif +#include "enums.h" #include "fbobject.h" #include "framebuffer.h" #include "hash.h" @@ -182,6 +183,8 @@ logbase2( int n ) * * This is the format which is used during texture application (i.e. the * texture format and env mode determine the arithmetic used. + * + * XXX this could be static */ GLint _mesa_base_tex_format( GLcontext *ctx, GLint internalFormat ) @@ -415,211 +418,6 @@ _mesa_base_tex_format( GLcontext *ctx, GLint internalFormat ) /** - * Test if the given image format is a color/RGBA format (i.e., not color - * index, depth, stencil, etc). - * \param format the image format value (may by an internal texture format) - * \return GL_TRUE if its a color/RGBA format, GL_FALSE otherwise. - * XXX maybe move this func to image.c - */ -GLboolean -_mesa_is_color_format(GLenum format) -{ - switch (format) { - case GL_RED: - case GL_GREEN: - case GL_BLUE: - case GL_ALPHA: - case GL_ALPHA4: - case GL_ALPHA8: - case GL_ALPHA12: - case GL_ALPHA16: - case 1: - case GL_LUMINANCE: - case GL_LUMINANCE4: - case GL_LUMINANCE8: - case GL_LUMINANCE12: - case GL_LUMINANCE16: - case 2: - case GL_LUMINANCE_ALPHA: - case GL_LUMINANCE4_ALPHA4: - case GL_LUMINANCE6_ALPHA2: - case GL_LUMINANCE8_ALPHA8: - case GL_LUMINANCE12_ALPHA4: - case GL_LUMINANCE12_ALPHA12: - case GL_LUMINANCE16_ALPHA16: - case GL_INTENSITY: - case GL_INTENSITY4: - case GL_INTENSITY8: - case GL_INTENSITY12: - case GL_INTENSITY16: - case 3: - case GL_RGB: - case GL_BGR: - case GL_R3_G3_B2: - case GL_RGB4: - case GL_RGB5: - case GL_RGB8: - case GL_RGB10: - case GL_RGB12: - case GL_RGB16: - case 4: - case GL_ABGR_EXT: - case GL_RGBA: - case GL_BGRA: - case GL_RGBA2: - case GL_RGBA4: - case GL_RGB5_A1: - case GL_RGBA8: - case GL_RGB10_A2: - case GL_RGBA12: - case GL_RGBA16: - /* float texture formats */ - case GL_ALPHA16F_ARB: - case GL_ALPHA32F_ARB: - case GL_LUMINANCE16F_ARB: - case GL_LUMINANCE32F_ARB: - case GL_LUMINANCE_ALPHA16F_ARB: - case GL_LUMINANCE_ALPHA32F_ARB: - case GL_INTENSITY16F_ARB: - case GL_INTENSITY32F_ARB: - case GL_RGB16F_ARB: - case GL_RGB32F_ARB: - case GL_RGBA16F_ARB: - case GL_RGBA32F_ARB: - /* compressed formats */ - case GL_COMPRESSED_ALPHA: - case GL_COMPRESSED_LUMINANCE: - case GL_COMPRESSED_LUMINANCE_ALPHA: - case GL_COMPRESSED_INTENSITY: - case GL_COMPRESSED_RGB: - case GL_COMPRESSED_RGBA: - case GL_RGB_S3TC: - case GL_RGB4_S3TC: - case GL_RGBA_S3TC: - case GL_RGBA4_S3TC: - case GL_COMPRESSED_RGB_S3TC_DXT1_EXT: - case GL_COMPRESSED_RGBA_S3TC_DXT1_EXT: - case GL_COMPRESSED_RGBA_S3TC_DXT3_EXT: - case GL_COMPRESSED_RGBA_S3TC_DXT5_EXT: - case GL_COMPRESSED_RGB_FXT1_3DFX: - case GL_COMPRESSED_RGBA_FXT1_3DFX: -#if FEATURE_EXT_texture_sRGB - case GL_SRGB_EXT: - case GL_SRGB8_EXT: - case GL_SRGB_ALPHA_EXT: - case GL_SRGB8_ALPHA8_EXT: - case GL_SLUMINANCE_ALPHA_EXT: - case GL_SLUMINANCE8_ALPHA8_EXT: - case GL_SLUMINANCE_EXT: - case GL_SLUMINANCE8_EXT: - case GL_COMPRESSED_SRGB_EXT: - case GL_COMPRESSED_SRGB_S3TC_DXT1_EXT: - case GL_COMPRESSED_SRGB_ALPHA_EXT: - case GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT: - case GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT: - case GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT: - case GL_COMPRESSED_SLUMINANCE_EXT: - case GL_COMPRESSED_SLUMINANCE_ALPHA_EXT: -#endif /* FEATURE_EXT_texture_sRGB */ - return GL_TRUE; - /* signed texture formats */ - case GL_RGBA_SNORM: - case GL_RGBA8_SNORM: - return GL_TRUE; - case GL_YCBCR_MESA: /* not considered to be RGB */ - /* fall-through */ - default: - return GL_FALSE; - } -} - - -/** - * Test if the given image format is a color index format. - */ -static GLboolean -is_index_format(GLenum format) -{ - switch (format) { - case GL_COLOR_INDEX: - case GL_COLOR_INDEX1_EXT: - case GL_COLOR_INDEX2_EXT: - case GL_COLOR_INDEX4_EXT: - case GL_COLOR_INDEX8_EXT: - case GL_COLOR_INDEX12_EXT: - case GL_COLOR_INDEX16_EXT: - return GL_TRUE; - default: - return GL_FALSE; - } -} - - -/** - * Test if the given image format is a depth component format. - */ -static GLboolean -is_depth_format(GLenum format) -{ - switch (format) { - case GL_DEPTH_COMPONENT16: - case GL_DEPTH_COMPONENT24: - case GL_DEPTH_COMPONENT32: - case GL_DEPTH_COMPONENT: - return GL_TRUE; - default: - return GL_FALSE; - } -} - - -/** - * Test if the given image format is a YCbCr format. - */ -static GLboolean -is_ycbcr_format(GLenum format) -{ - switch (format) { - case GL_YCBCR_MESA: - return GL_TRUE; - default: - return GL_FALSE; - } -} - - -/** - * Test if the given image format is a Depth/Stencil format. - */ -static GLboolean -is_depthstencil_format(GLenum format) -{ - switch (format) { - case GL_DEPTH24_STENCIL8_EXT: - case GL_DEPTH_STENCIL_EXT: - return GL_TRUE; - default: - return GL_FALSE; - } -} - -/** - * 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; - } -} - - -/** * Test if it is a supported compressed format. * * \param internalFormat the internal format token provided by the user. @@ -679,37 +477,14 @@ _mesa_set_tex_image(struct gl_texture_object *tObj, GLenum target, GLint level, struct gl_texture_image *texImage) { + const GLuint face = _mesa_tex_target_to_face(target); + ASSERT(tObj); ASSERT(texImage); - /* XXX simplify this with _mesa_tex_target_to_face() */ - switch (target) { - case GL_TEXTURE_1D: - case GL_TEXTURE_2D: - case GL_TEXTURE_3D: - case GL_TEXTURE_1D_ARRAY_EXT: - case GL_TEXTURE_2D_ARRAY_EXT: - tObj->Image[0][level] = texImage; - break; - case GL_TEXTURE_CUBE_MAP_POSITIVE_X_ARB: - case GL_TEXTURE_CUBE_MAP_NEGATIVE_X_ARB: - case GL_TEXTURE_CUBE_MAP_POSITIVE_Y_ARB: - case GL_TEXTURE_CUBE_MAP_NEGATIVE_Y_ARB: - case GL_TEXTURE_CUBE_MAP_POSITIVE_Z_ARB: - case GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_ARB: - { - GLuint face = ((GLuint) target - - (GLuint) GL_TEXTURE_CUBE_MAP_POSITIVE_X); - tObj->Image[face][level] = texImage; - } - break; - case GL_TEXTURE_RECTANGLE_NV: - ASSERT(level == 0); - tObj->Image[0][level] = texImage; - break; - default: - _mesa_problem(NULL, "bad target in _mesa_set_tex_image()"); - return; - } + ASSERT(target != GL_TEXTURE_RECTANGLE_NV || level == 0); + + tObj->Image[face][level] = texImage; + /* Set the 'back' pointer */ texImage->TexObject = tObj; } @@ -788,6 +563,9 @@ _mesa_delete_texture_image( GLcontext *ctx, struct gl_texture_image *texImage ) GLboolean _mesa_is_proxy_texture(GLenum target) { + /* NUM_TEXTURE_TARGETS should match number of terms below */ + assert(NUM_TEXTURE_TARGETS == 7); + return (target == GL_PROXY_TEXTURE_1D || target == GL_PROXY_TEXTURE_2D || target == GL_PROXY_TEXTURE_3D || @@ -864,74 +642,28 @@ _mesa_select_tex_object(GLcontext *ctx, const struct gl_texture_unit *texUnit, /** - * Get the texture image struct which corresponds to target and level - * of the given texture unit. + * Get a texture image pointer from a texture object, given a texture + * target and mipmap level. The target and level parameters should + * have already been error-checked. * * \param ctx GL context. * \param texObj texture unit. * \param target texture target. * \param level image level. * - * \return pointer to the texture image structure on success, or NULL on failure. - * - * \sa gl_texture_unit. + * \return pointer to the texture image structure, or NULL on failure. */ struct gl_texture_image * _mesa_select_tex_image(GLcontext *ctx, const struct gl_texture_object *texObj, GLenum target, GLint level) { - ASSERT(texObj); - - if (level < 0 || level >= MAX_TEXTURE_LEVELS) - return NULL; - - /* XXX simplify this with _mesa_tex_target_to_face() */ - switch (target) { - case GL_TEXTURE_1D: - case GL_PROXY_TEXTURE_1D: - case GL_TEXTURE_2D: - case GL_PROXY_TEXTURE_2D: - case GL_TEXTURE_3D: - case GL_PROXY_TEXTURE_3D: - return texObj->Image[0][level]; - - case GL_TEXTURE_CUBE_MAP_POSITIVE_X_ARB: - case GL_TEXTURE_CUBE_MAP_NEGATIVE_X_ARB: - case GL_TEXTURE_CUBE_MAP_POSITIVE_Y_ARB: - case GL_TEXTURE_CUBE_MAP_NEGATIVE_Y_ARB: - case GL_TEXTURE_CUBE_MAP_POSITIVE_Z_ARB: - case GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_ARB: - if (ctx->Extensions.ARB_texture_cube_map) { - GLuint face = ((GLuint) target - - (GLuint) GL_TEXTURE_CUBE_MAP_POSITIVE_X); - return texObj->Image[face][level]; - } - else - return NULL; - - case GL_PROXY_TEXTURE_CUBE_MAP_ARB: - if (ctx->Extensions.ARB_texture_cube_map) - return texObj->Image[0][level]; - else - return NULL; - - case GL_TEXTURE_RECTANGLE_NV: - case GL_PROXY_TEXTURE_RECTANGLE_NV: - if (ctx->Extensions.NV_texture_rectangle && level == 0) - return texObj->Image[0][level]; - else - return NULL; + const GLuint face = _mesa_tex_target_to_face(target); - case GL_TEXTURE_1D_ARRAY_EXT: - case GL_PROXY_TEXTURE_1D_ARRAY_EXT: - case GL_TEXTURE_2D_ARRAY_EXT: - case GL_PROXY_TEXTURE_2D_ARRAY_EXT: - return (ctx->Extensions.MESA_texture_array) - ? texObj->Image[0][level] : NULL; + ASSERT(texObj); + ASSERT(level >= 0); + ASSERT(level < MAX_TEXTURE_LEVELS); - default: - return NULL; - } + return texObj->Image[face][level]; } @@ -1053,10 +785,6 @@ _mesa_max_texture_levels(GLcontext *ctx, GLenum target) case GL_PROXY_TEXTURE_1D: case GL_TEXTURE_2D: case GL_PROXY_TEXTURE_2D: - case GL_TEXTURE_1D_ARRAY_EXT: - case GL_PROXY_TEXTURE_1D_ARRAY_EXT: - case GL_TEXTURE_2D_ARRAY_EXT: - case GL_PROXY_TEXTURE_2D_ARRAY_EXT: return ctx->Const.MaxTextureLevels; case GL_TEXTURE_3D: case GL_PROXY_TEXTURE_3D: @@ -1069,10 +797,17 @@ _mesa_max_texture_levels(GLcontext *ctx, GLenum target) case GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_ARB: case GL_TEXTURE_CUBE_MAP_ARB: case GL_PROXY_TEXTURE_CUBE_MAP_ARB: - return ctx->Const.MaxCubeTextureLevels; + return ctx->Extensions.ARB_texture_cube_map + ? ctx->Const.MaxCubeTextureLevels : 0; case GL_TEXTURE_RECTANGLE_NV: case GL_PROXY_TEXTURE_RECTANGLE_NV: - return 1; + return ctx->Extensions.NV_texture_rectangle ? 1 : 0; + case GL_TEXTURE_1D_ARRAY_EXT: + case GL_PROXY_TEXTURE_1D_ARRAY_EXT: + case GL_TEXTURE_2D_ARRAY_EXT: + case GL_PROXY_TEXTURE_2D_ARRAY_EXT: + return ctx->Extensions.MESA_texture_array + ? ctx->Const.MaxTextureLevels : 0; default: return 0; /* bad target */ } @@ -1273,6 +1008,23 @@ _mesa_init_teximage_fields(GLcontext *ctx, GLenum target, /** + * Free and clear fields of the gl_texture_image struct. + * + * \param ctx GL context. + * \param texImage texture image structure to be cleared. + * + * After the call, \p texImage will have no data associated with it. Its + * fields are cleared so that its parent object will test incomplete. + */ +void +_mesa_clear_texture_image(GLcontext *ctx, struct gl_texture_image *texImage) +{ + ctx->Driver.FreeTexImageData(ctx, texImage); + clear_teximage_fields(texImage); +} + + +/** * This is the fallback for Driver.TestProxyTexImage(). Test the texture * level, width, height and depth against the ctx->Const limits for textures. * @@ -1586,13 +1338,13 @@ texture_error_check( GLcontext *ctx, GLenum target, /* make sure internal format and format basically agree */ colorFormat = _mesa_is_color_format(format); - indexFormat = is_index_format(format); + indexFormat = _mesa_is_index_format(format); if ((_mesa_is_color_format(internalFormat) && !colorFormat && !indexFormat) || - (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_dudv_format(internalFormat) != is_dudv_format(format))) { + (_mesa_is_index_format(internalFormat) && !indexFormat) || + (_mesa_is_depth_format(internalFormat) != _mesa_is_depth_format(format)) || + (_mesa_is_ycbcr_format(internalFormat) != _mesa_is_ycbcr_format(format)) || + (_mesa_is_depthstencil_format(internalFormat) != _mesa_is_depthstencil_format(format)) || + (_mesa_is_dudv_format(internalFormat) != _mesa_is_dudv_format(format))) { if (!isProxy) _mesa_error(ctx, GL_INVALID_OPERATION, "glTexImage%dD(incompatible internalFormat 0x%x, format 0x%x)", @@ -1926,14 +1678,14 @@ copytexture_error_check( GLcontext *ctx, GLuint dimensions, return GL_TRUE; } - /* NOTE: the format and type aren't really significant for - * TestProxyTexImage(). Only the internalformat really matters. if (!_mesa_source_buffer_exists(ctx, format)) { _mesa_error(ctx, GL_INVALID_OPERATION, "glCopyTexImage%dD(missing readbuffer)", dimensions); return GL_TRUE; } + /* NOTE: the format and type aren't really significant for + * TestProxyTexImage(). Only the internalformat really matters. */ type = GL_FLOAT; @@ -2027,7 +1779,7 @@ copytexture_error_check( GLcontext *ctx, GLuint dimensions, return GL_TRUE; } } - else if (is_depth_format(internalFormat)) { + else if (_mesa_is_depth_format(internalFormat)) { /* make sure we have depth/stencil buffers */ if (!ctx->ReadBuffer->_DepthBuffer) { _mesa_error(ctx, GL_INVALID_OPERATION, @@ -2035,7 +1787,7 @@ copytexture_error_check( GLcontext *ctx, GLuint dimensions, return GL_TRUE; } } - else if (is_depthstencil_format(internalFormat)) { + else if (_mesa_is_depthstencil_format(internalFormat)) { /* make sure we have depth/stencil buffers */ if (!ctx->ReadBuffer->_DepthBuffer || !ctx->ReadBuffer->_StencilBuffer) { _mesa_error(ctx, GL_INVALID_OPERATION, @@ -2260,147 +2012,6 @@ copytexsubimage_error_check2( GLcontext *ctx, GLuint dimensions, } -/** - * Get texture image. Called by glGetTexImage. - * - * \param target texture target. - * \param level image level. - * \param format pixel data format for returned image. - * \param type pixel data type for returned image. - * \param pixels returned pixel data. - */ -void GLAPIENTRY -_mesa_GetTexImage( GLenum target, GLint level, GLenum format, - GLenum type, GLvoid *pixels ) -{ - const struct gl_texture_unit *texUnit; - struct gl_texture_object *texObj; - struct gl_texture_image *texImage; - GLint maxLevels = 0; - GET_CURRENT_CONTEXT(ctx); - ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx); - - texUnit = &(ctx->Texture.Unit[ctx->Texture.CurrentUnit]); - texObj = _mesa_select_tex_object(ctx, texUnit, target); - if (!texObj || _mesa_is_proxy_texture(target)) { - _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexImage(target)"); - return; - } - - maxLevels = _mesa_max_texture_levels(ctx, target); - ASSERT(maxLevels > 0); /* 0 indicates bad target, caught above */ - - if (level < 0 || level >= maxLevels) { - _mesa_error( ctx, GL_INVALID_VALUE, "glGetTexImage(level)" ); - return; - } - - if (_mesa_sizeof_packed_type(type) <= 0) { - _mesa_error( ctx, GL_INVALID_ENUM, "glGetTexImage(type)" ); - return; - } - - if (_mesa_components_in_format(format) <= 0 || - format == GL_STENCIL_INDEX) { - _mesa_error( ctx, GL_INVALID_ENUM, "glGetTexImage(format)" ); - return; - } - - if (!ctx->Extensions.EXT_paletted_texture && is_index_format(format)) { - _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexImage(format)"); - return; - } - - if (!ctx->Extensions.ARB_depth_texture && is_depth_format(format)) { - _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexImage(format)"); - return; - } - - if (!ctx->Extensions.MESA_ycbcr_texture && is_ycbcr_format(format)) { - _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexImage(format)"); - return; - } - - if (!ctx->Extensions.EXT_packed_depth_stencil - && is_depthstencil_format(format)) { - _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexImage(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); - if (!texImage) { - /* invalid mipmap level, not an error */ - goto out; - } - - - /* Make sure the requested image format is compatible with the - * texture's format. Note that a color index texture can be converted - * to RGBA so that combo is allowed. - */ - if (_mesa_is_color_format(format) - && !_mesa_is_color_format(texImage->TexFormat->BaseFormat) - && !is_index_format(texImage->TexFormat->BaseFormat)) { - _mesa_error(ctx, GL_INVALID_OPERATION, "glGetTexImage(format mismatch)"); - goto out; - } - else if (is_index_format(format) - && !is_index_format(texImage->TexFormat->BaseFormat)) { - _mesa_error(ctx, GL_INVALID_OPERATION, "glGetTexImage(format mismatch)"); - goto out; - } - else if (is_depth_format(format) - && !is_depth_format(texImage->TexFormat->BaseFormat) - && !is_depthstencil_format(texImage->TexFormat->BaseFormat)) { - _mesa_error(ctx, GL_INVALID_OPERATION, "glGetTexImage(format mismatch)"); - goto out; - } - else if (is_ycbcr_format(format) - && !is_ycbcr_format(texImage->TexFormat->BaseFormat)) { - _mesa_error(ctx, GL_INVALID_OPERATION, "glGetTexImage(format mismatch)"); - goto out; - } - else if (is_depthstencil_format(format) - && !is_depthstencil_format(texImage->TexFormat->BaseFormat)) { - _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 */ - const GLuint dimensions = (target == GL_TEXTURE_3D) ? 3 : 2; - if (!_mesa_validate_pbo_access(dimensions, &ctx->Pack, texImage->Width, - texImage->Height, texImage->Depth, - format, type, pixels)) { - _mesa_error(ctx, GL_INVALID_OPERATION, - "glGetTexImage(invalid PBO access)"); - goto out; - } - } - - /* typically, this will call _mesa_get_teximage() */ - ctx->Driver.GetTexImage(ctx, target, level, format, type, pixels, - texObj, texImage); - - } - out: - _mesa_unlock_texture(ctx, texObj); -} - - /** Callback info for walking over FBO hash table */ struct cb_info { @@ -2521,6 +2132,13 @@ _mesa_TexImage1D( GLenum target, GLint level, GLint internalFormat, GET_CURRENT_CONTEXT(ctx); ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx); + if (MESA_VERBOSE & (VERBOSE_API|VERBOSE_TEXTURE)) + _mesa_debug(ctx, "glTexImage1D %s %d %s %d %d %s %s %p\n", + _mesa_lookup_enum_by_nr(target), level, + _mesa_lookup_enum_by_nr(internalFormat), width, border, + _mesa_lookup_enum_by_nr(format), + _mesa_lookup_enum_by_nr(type), pixels); + internalFormat = override_internal_format(internalFormat, width, 1); #if FEATURE_convolve @@ -2544,7 +2162,7 @@ _mesa_TexImage1D( GLenum target, GLint level, GLint internalFormat, if (ctx->NewState & _MESA_NEW_TRANSFER_STATE) _mesa_update_state(ctx); - texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit]; + texUnit = _mesa_get_current_tex_unit(ctx); texObj = _mesa_select_tex_object(ctx, texUnit, target); _mesa_lock_texture(ctx, texObj); { @@ -2620,6 +2238,13 @@ _mesa_TexImage2D( GLenum target, GLint level, GLint internalFormat, GET_CURRENT_CONTEXT(ctx); ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx); + if (MESA_VERBOSE & (VERBOSE_API|VERBOSE_TEXTURE)) + _mesa_debug(ctx, "glTexImage2D %s %d %s %d %d %d %s %s %p\n", + _mesa_lookup_enum_by_nr(target), level, + _mesa_lookup_enum_by_nr(internalFormat), width, height, + border, _mesa_lookup_enum_by_nr(format), + _mesa_lookup_enum_by_nr(type), pixels); + internalFormat = override_internal_format(internalFormat, width, height); #if FEATURE_convolve @@ -2652,7 +2277,7 @@ _mesa_TexImage2D( GLenum target, GLint level, GLint internalFormat, if (ctx->NewState & _MESA_NEW_TRANSFER_STATE) _mesa_update_state(ctx); - texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit]; + texUnit = _mesa_get_current_tex_unit(ctx); texObj = _mesa_select_tex_object(ctx, texUnit, target); _mesa_lock_texture(ctx, texObj); { @@ -2736,6 +2361,13 @@ _mesa_TexImage3D( GLenum target, GLint level, GLint internalFormat, GET_CURRENT_CONTEXT(ctx); ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx); + if (MESA_VERBOSE & (VERBOSE_API|VERBOSE_TEXTURE)) + _mesa_debug(ctx, "glTexImage3D %s %d %s %d %d %d %d %s %s %p\n", + _mesa_lookup_enum_by_nr(target), level, + _mesa_lookup_enum_by_nr(internalFormat), width, height, + depth, border, _mesa_lookup_enum_by_nr(format), + _mesa_lookup_enum_by_nr(type), pixels); + internalFormat = override_internal_format(internalFormat, width, height); if (target == GL_TEXTURE_3D || @@ -2755,7 +2387,7 @@ _mesa_TexImage3D( GLenum target, GLint level, GLint internalFormat, if (ctx->NewState & _MESA_NEW_TRANSFER_STATE) _mesa_update_state(ctx); - texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit]; + texUnit = _mesa_get_current_tex_unit(ctx); texObj = _mesa_select_tex_object(ctx, texUnit, target); _mesa_lock_texture(ctx, texObj); { @@ -2845,6 +2477,12 @@ _mesa_TexSubImage1D( GLenum target, GLint level, GET_CURRENT_CONTEXT(ctx); ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx); + if (MESA_VERBOSE & (VERBOSE_API|VERBOSE_TEXTURE)) + _mesa_debug(ctx, "glTexSubImage1D %s %d %d %d %s %s %p\n", + _mesa_lookup_enum_by_nr(target), level, + xoffset, width, _mesa_lookup_enum_by_nr(format), + _mesa_lookup_enum_by_nr(type), pixels); + if (ctx->NewState & _MESA_NEW_TRANSFER_STATE) _mesa_update_state(ctx); @@ -2861,7 +2499,7 @@ _mesa_TexSubImage1D( GLenum target, GLint level, } - texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit]; + texUnit = _mesa_get_current_tex_unit(ctx); texObj = _mesa_select_tex_object(ctx, texUnit, target); assert(texObj); @@ -2905,6 +2543,13 @@ _mesa_TexSubImage2D( GLenum target, GLint level, GET_CURRENT_CONTEXT(ctx); ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx); + if (MESA_VERBOSE & (VERBOSE_API|VERBOSE_TEXTURE)) + _mesa_debug(ctx, "glTexSubImage2D %s %d %d %d %d %d %s %s %p\n", + _mesa_lookup_enum_by_nr(target), level, + xoffset, yoffset, width, height, + _mesa_lookup_enum_by_nr(format), + _mesa_lookup_enum_by_nr(type), pixels); + if (ctx->NewState & _MESA_NEW_TRANSFER_STATE) _mesa_update_state(ctx); @@ -2921,7 +2566,7 @@ _mesa_TexSubImage2D( GLenum target, GLint level, return; /* error was detected */ } - texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit]; + texUnit = _mesa_get_current_tex_unit(ctx); texObj = _mesa_select_tex_object(ctx, texUnit, target); _mesa_lock_texture(ctx, texObj); { @@ -2965,6 +2610,13 @@ _mesa_TexSubImage3D( GLenum target, GLint level, GET_CURRENT_CONTEXT(ctx); ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx); + if (MESA_VERBOSE & (VERBOSE_API|VERBOSE_TEXTURE)) + _mesa_debug(ctx, "glTexSubImage3D %s %d %d %d %d %d %d %d %s %s %p\n", + _mesa_lookup_enum_by_nr(target), level, + xoffset, yoffset, zoffset, width, height, depth, + _mesa_lookup_enum_by_nr(format), + _mesa_lookup_enum_by_nr(type), pixels); + if (ctx->NewState & _MESA_NEW_TRANSFER_STATE) _mesa_update_state(ctx); @@ -2973,7 +2625,7 @@ _mesa_TexSubImage3D( GLenum target, GLint level, return; /* error was detected */ } - texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit]; + texUnit = _mesa_get_current_tex_unit(ctx); texObj = _mesa_select_tex_object(ctx, texUnit, target); _mesa_lock_texture(ctx, texObj); @@ -3021,6 +2673,12 @@ _mesa_CopyTexImage1D( GLenum target, GLint level, GET_CURRENT_CONTEXT(ctx); ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx); + if (MESA_VERBOSE & (VERBOSE_API|VERBOSE_TEXTURE)) + _mesa_debug(ctx, "glCopyTexImage1D %s %d %s %d %d %d %d\n", + _mesa_lookup_enum_by_nr(target), level, + _mesa_lookup_enum_by_nr(internalFormat), + x, y, width, border); + if (ctx->NewState & NEW_COPY_TEX_STATE) _mesa_update_state(ctx); @@ -3034,7 +2692,7 @@ _mesa_CopyTexImage1D( GLenum target, GLint level, postConvWidth, 1, border)) return; - texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit]; + texUnit = _mesa_get_current_tex_unit(ctx); texObj = _mesa_select_tex_object(ctx, texUnit, target); _mesa_lock_texture(ctx, texObj); { @@ -3086,6 +2744,12 @@ _mesa_CopyTexImage2D( GLenum target, GLint level, GLenum internalFormat, GET_CURRENT_CONTEXT(ctx); ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx); + if (MESA_VERBOSE & (VERBOSE_API|VERBOSE_TEXTURE)) + _mesa_debug(ctx, "glCopyTexImage2D %s %d %s %d %d %d %d %d\n", + _mesa_lookup_enum_by_nr(target), level, + _mesa_lookup_enum_by_nr(internalFormat), + x, y, width, height, border); + if (ctx->NewState & NEW_COPY_TEX_STATE) _mesa_update_state(ctx); @@ -3100,7 +2764,7 @@ _mesa_CopyTexImage2D( GLenum target, GLint level, GLenum internalFormat, postConvWidth, postConvHeight, border)) return; - texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit]; + texUnit = _mesa_get_current_tex_unit(ctx); texObj = _mesa_select_tex_object(ctx, texUnit, target); _mesa_lock_texture(ctx, texObj); @@ -3154,13 +2818,18 @@ _mesa_CopyTexSubImage1D( GLenum target, GLint level, GET_CURRENT_CONTEXT(ctx); ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx); + if (MESA_VERBOSE & (VERBOSE_API|VERBOSE_TEXTURE)) + _mesa_debug(ctx, "glCopyTexSubImage1D %s %d %d %d %d %d\n", + _mesa_lookup_enum_by_nr(target), + level, xoffset, x, y, width); + if (ctx->NewState & NEW_COPY_TEX_STATE) _mesa_update_state(ctx); if (copytexsubimage_error_check1(ctx, 1, target, level)) return; - texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit]; + texUnit = _mesa_get_current_tex_unit(ctx); texObj = _mesa_select_tex_object(ctx, texUnit, target); _mesa_lock_texture(ctx, texObj); @@ -3209,13 +2878,18 @@ _mesa_CopyTexSubImage2D( GLenum target, GLint level, GET_CURRENT_CONTEXT(ctx); ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx); + if (MESA_VERBOSE & (VERBOSE_API|VERBOSE_TEXTURE)) + _mesa_debug(ctx, "glCopyTexSubImage2D %s %d %d %d %d %d %d %d\n", + _mesa_lookup_enum_by_nr(target), + level, xoffset, yoffset, x, y, width, height); + if (ctx->NewState & NEW_COPY_TEX_STATE) _mesa_update_state(ctx); if (copytexsubimage_error_check1(ctx, 2, target, level)) return; - texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit]; + texUnit = _mesa_get_current_tex_unit(ctx); texObj = _mesa_select_tex_object(ctx, texUnit, target); _mesa_lock_texture(ctx, texObj); @@ -3264,13 +2938,18 @@ _mesa_CopyTexSubImage3D( GLenum target, GLint level, GET_CURRENT_CONTEXT(ctx); ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx); + if (MESA_VERBOSE & (VERBOSE_API|VERBOSE_TEXTURE)) + _mesa_debug(ctx, "glCopyTexSubImage3D %s %d %d %d %d %d %d %d %d\n", + _mesa_lookup_enum_by_nr(target), + level, xoffset, yoffset, zoffset, x, y, width, height); + if (ctx->NewState & NEW_COPY_TEX_STATE) _mesa_update_state(ctx); if (copytexsubimage_error_check1(ctx, 3, target, level)) return; - texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit]; + texUnit = _mesa_get_current_tex_unit(ctx); texObj = _mesa_select_tex_object(ctx, texUnit, target); _mesa_lock_texture(ctx, texObj); @@ -3512,6 +3191,12 @@ _mesa_CompressedTexImage1DARB(GLenum target, GLint level, GET_CURRENT_CONTEXT(ctx); ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx); + if (MESA_VERBOSE & (VERBOSE_API|VERBOSE_TEXTURE)) + _mesa_debug(ctx, "glCompressedTexImage1DARB %s %d %s %d %d %d %p\n", + _mesa_lookup_enum_by_nr(target), level, + _mesa_lookup_enum_by_nr(internalFormat), + width, border, imageSize, data); + if (target == GL_TEXTURE_1D) { /* non-proxy target */ struct gl_texture_unit *texUnit; @@ -3524,7 +3209,7 @@ _mesa_CompressedTexImage1DARB(GLenum target, GLint level, return; } - texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit]; + texUnit = _mesa_get_current_tex_unit(ctx); texObj = _mesa_select_tex_object(ctx, texUnit, target); _mesa_lock_texture(ctx, texObj); @@ -3578,7 +3263,7 @@ _mesa_CompressedTexImage1DARB(GLenum target, GLint level, struct gl_texture_unit *texUnit; struct gl_texture_object *texObj; struct gl_texture_image *texImage; - texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit]; + texUnit = _mesa_get_current_tex_unit(ctx); texObj = _mesa_select_tex_object(ctx, texUnit, target); _mesa_lock_texture(ctx, texObj); @@ -3606,6 +3291,12 @@ _mesa_CompressedTexImage2DARB(GLenum target, GLint level, GET_CURRENT_CONTEXT(ctx); ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx); + if (MESA_VERBOSE & (VERBOSE_API|VERBOSE_TEXTURE)) + _mesa_debug(ctx, "glCompressedTexImage2DARB %s %d %s %d %d %d %d %p\n", + _mesa_lookup_enum_by_nr(target), level, + _mesa_lookup_enum_by_nr(internalFormat), + width, height, border, imageSize, data); + if (target == GL_TEXTURE_2D || (ctx->Extensions.ARB_texture_cube_map && target >= GL_TEXTURE_CUBE_MAP_POSITIVE_X_ARB && @@ -3621,7 +3312,7 @@ _mesa_CompressedTexImage2DARB(GLenum target, GLint level, return; } - texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit]; + texUnit = _mesa_get_current_tex_unit(ctx); texObj = _mesa_select_tex_object(ctx, texUnit, target); _mesa_lock_texture(ctx, texObj); @@ -3677,7 +3368,7 @@ _mesa_CompressedTexImage2DARB(GLenum target, GLint level, struct gl_texture_unit *texUnit; struct gl_texture_object *texObj; struct gl_texture_image *texImage; - texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit]; + texUnit = _mesa_get_current_tex_unit(ctx); texObj = _mesa_select_tex_object(ctx, texUnit, target); _mesa_lock_texture(ctx, texObj); @@ -3705,6 +3396,12 @@ _mesa_CompressedTexImage3DARB(GLenum target, GLint level, GET_CURRENT_CONTEXT(ctx); ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx); + if (MESA_VERBOSE & (VERBOSE_API|VERBOSE_TEXTURE)) + _mesa_debug(ctx, "glCompressedTexImage3DARB %s %d %s %d %d %d %d %d %p\n", + _mesa_lookup_enum_by_nr(target), level, + _mesa_lookup_enum_by_nr(internalFormat), + width, height, depth, border, imageSize, data); + if (target == GL_TEXTURE_3D) { /* non-proxy target */ struct gl_texture_unit *texUnit; @@ -3717,7 +3414,7 @@ _mesa_CompressedTexImage3DARB(GLenum target, GLint level, return; } - texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit]; + texUnit = _mesa_get_current_tex_unit(ctx); texObj = _mesa_select_tex_object(ctx, texUnit, target); _mesa_lock_texture(ctx, texObj); { @@ -3771,7 +3468,7 @@ _mesa_CompressedTexImage3DARB(GLenum target, GLint level, struct gl_texture_unit *texUnit; struct gl_texture_object *texObj; struct gl_texture_image *texImage; - texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit]; + texUnit = _mesa_get_current_tex_unit(ctx); texObj = _mesa_select_tex_object(ctx, texUnit, target); _mesa_lock_texture(ctx, texObj); { @@ -3810,7 +3507,7 @@ _mesa_CompressedTexSubImage1DARB(GLenum target, GLint level, GLint xoffset, return; } - texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit]; + texUnit = _mesa_get_current_tex_unit(ctx); texObj = _mesa_select_tex_object(ctx, texUnit, target); _mesa_lock_texture(ctx, texObj); { @@ -3867,7 +3564,7 @@ _mesa_CompressedTexSubImage2DARB(GLenum target, GLint level, GLint xoffset, return; } - texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit]; + texUnit = _mesa_get_current_tex_unit(ctx); texObj = _mesa_select_tex_object(ctx, texUnit, target); _mesa_lock_texture(ctx, texObj); { @@ -3924,7 +3621,7 @@ _mesa_CompressedTexSubImage3DARB(GLenum target, GLint level, GLint xoffset, return; } - texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit]; + texUnit = _mesa_get_current_tex_unit(ctx); texObj = _mesa_select_tex_object(ctx, texUnit, target); _mesa_lock_texture(ctx, texObj); { @@ -3961,55 +3658,3 @@ _mesa_CompressedTexSubImage3DARB(GLenum target, GLint level, GLint xoffset, } -void GLAPIENTRY -_mesa_GetCompressedTexImageARB(GLenum target, GLint level, GLvoid *img) -{ - const struct gl_texture_unit *texUnit; - struct gl_texture_object *texObj; - struct gl_texture_image *texImage; - GLint maxLevels; - GET_CURRENT_CONTEXT(ctx); - ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx); - - texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit]; - texObj = _mesa_select_tex_object(ctx, texUnit, target); - if (!texObj) { - _mesa_error(ctx, GL_INVALID_ENUM, "glGetCompressedTexImageARB"); - return; - } - - maxLevels = _mesa_max_texture_levels(ctx, target); - ASSERT(maxLevels > 0); /* 0 indicates bad target, caught above */ - - if (level < 0 || level >= maxLevels) { - _mesa_error(ctx, GL_INVALID_VALUE, "glGetCompressedTexImageARB(level)"); - return; - } - - if (_mesa_is_proxy_texture(target)) { - _mesa_error(ctx, GL_INVALID_ENUM, "glGetCompressedTexImageARB(target)"); - return; - } - - _mesa_lock_texture(ctx, texObj); - { - texImage = _mesa_select_tex_image(ctx, texObj, target, level); - if (texImage) { - if (texImage->IsCompressed) { - /* this typically calls _mesa_get_compressed_teximage() */ - ctx->Driver.GetCompressedTexImage(ctx, target, level, img, - texObj, texImage); - } - else { - _mesa_error(ctx, GL_INVALID_OPERATION, - "glGetCompressedTexImageARB"); - } - } - else { - /* probably invalid mipmap level */ - _mesa_error(ctx, GL_INVALID_VALUE, - "glGetCompressedTexImageARB(level)"); - } - } - _mesa_unlock_texture(ctx, texObj); -} diff --git a/src/mesa/main/teximage.h b/src/mesa/main/teximage.h index eb60a1fa8f..094177da79 100644 --- a/src/mesa/main/teximage.h +++ b/src/mesa/main/teximage.h @@ -73,6 +73,10 @@ _mesa_init_teximage_fields(GLcontext *ctx, GLenum target, extern void +_mesa_clear_texture_image(GLcontext *ctx, struct gl_texture_image *texImage); + + +extern void _mesa_set_tex_image(struct gl_texture_object *tObj, GLenum target, GLint level, struct gl_texture_image *texImage); @@ -111,10 +115,6 @@ extern GLuint _mesa_tex_target_to_face(GLenum target); -extern GLboolean -_mesa_is_color_format(GLenum format); - - /** * Lock a texture for updating. See also _mesa_lock_context_textures(). */ @@ -164,11 +164,6 @@ _mesa_TexImage3DEXT( GLenum target, GLint level, GLenum internalformat, extern void GLAPIENTRY -_mesa_GetTexImage( GLenum target, GLint level, - GLenum format, GLenum type, GLvoid *pixels ); - - -extern void GLAPIENTRY _mesa_TexSubImage1D( GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, @@ -260,9 +255,6 @@ _mesa_CompressedTexSubImage3DARB(GLenum target, GLint level, GLint xoffset, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const GLvoid *data); -extern void GLAPIENTRY -_mesa_GetCompressedTexImageARB(GLenum target, GLint lod, GLvoid *img); - /*@}*/ #endif diff --git a/src/mesa/main/texobj.c b/src/mesa/main/texobj.c index 89ee69770e..d09c439250 100644 --- a/src/mesa/main/texobj.c +++ b/src/mesa/main/texobj.c @@ -261,6 +261,32 @@ _mesa_copy_texture_object( struct gl_texture_object *dest, /** + * Clear all texture images of the given texture object. + * + * \param ctx GL context. + * \param t texture object. + * + * \sa _mesa_clear_texture_image(). + */ +void +_mesa_clear_texture_object(GLcontext *ctx, struct gl_texture_object *texObj) +{ + GLuint i, j; + + if (texObj->Target == 0) + return; + + for (i = 0; i < MAX_FACES; i++) { + for (j = 0; j < MAX_TEXTURE_LEVELS; j++) { + struct gl_texture_image *texImage = texObj->Image[i][j]; + if (texImage) + _mesa_clear_texture_image(ctx, texImage); + } + } +} + + +/** * Check if the given texture object is valid by examining its Target field. * For debugging only. */ @@ -281,7 +307,8 @@ valid_texture_object(const struct gl_texture_object *tex) _mesa_problem(NULL, "invalid reference to a deleted texture object"); return GL_FALSE; default: - _mesa_problem(NULL, "invalid texture object Target value"); + _mesa_problem(NULL, "invalid texture object Target 0x%x, Id = %u", + tex->Target, tex->Name); return GL_FALSE; } } @@ -307,7 +334,7 @@ _mesa_reference_texobj(struct gl_texture_object **ptr, GLboolean deleteFlag = GL_FALSE; struct gl_texture_object *oldTex = *ptr; - assert(valid_texture_object(oldTex)); + ASSERT(valid_texture_object(oldTex)); _glthread_LOCK_MUTEX(oldTex->Mutex); ASSERT(oldTex->RefCount > 0); @@ -330,7 +357,7 @@ _mesa_reference_texobj(struct gl_texture_object **ptr, if (tex) { /* reference new texture */ - assert(valid_texture_object(tex)); + ASSERT(valid_texture_object(tex)); _glthread_LOCK_MUTEX(tex->Mutex); if (tex->RefCount == 0) { /* this texture's being deleted (look just above) */ @@ -664,6 +691,24 @@ _mesa_test_texobj_completeness( const GLcontext *ctx, /** + * Mark a texture object dirty. It forces the object to be incomplete + * and optionally forces the context to re-validate its state. + * + * \param ctx GL context. + * \param texObj texture object. + * \param invalidate_state also invalidate context state. + */ +void +_mesa_dirty_texobj(GLcontext *ctx, struct gl_texture_object *texObj, + GLboolean invalidate_state) +{ + texObj->_Complete = GL_FALSE; + if (invalidate_state) + ctx->NewState |= _NEW_TEXTURE; +} + + +/** * Return pointer to a default/fallback texture. * The texture is a 2D 8x8 RGBA texture with all texels = (0,0,0,1). * That's the value a sampler should get when sampling from an @@ -714,7 +759,6 @@ _mesa_get_fallback_texture(GLcontext *ctx) } - /*@}*/ @@ -1159,10 +1203,9 @@ _mesa_IsTexture( GLuint texture ) /** - * Simplest implementation of texture locking: Grab the a new mutex in - * the shared context. Examine the shared context state timestamp and - * if there has been a change, set the appropriate bits in - * ctx->NewState. + * Simplest implementation of texture locking: grab the shared tex + * mutex. Examine the shared context state timestamp and if there has + * been a change, set the appropriate bits in ctx->NewState. * * This is used to deal with synchronizing things when a texture object * is used/modified by different contexts (or threads) which are sharing diff --git a/src/mesa/main/texobj.h b/src/mesa/main/texobj.h index 2599c0816a..9bfebd45c8 100644 --- a/src/mesa/main/texobj.h +++ b/src/mesa/main/texobj.h @@ -58,6 +58,9 @@ _mesa_copy_texture_object( struct gl_texture_object *dest, const struct gl_texture_object *src ); extern void +_mesa_clear_texture_object(GLcontext *ctx, struct gl_texture_object *obj); + +extern void _mesa_reference_texobj(struct gl_texture_object **ptr, struct gl_texture_object *tex); @@ -65,6 +68,10 @@ extern void _mesa_test_texobj_completeness( const GLcontext *ctx, struct gl_texture_object *obj ); +extern void +_mesa_dirty_texobj(GLcontext *ctx, struct gl_texture_object *texObj, + GLboolean invalidate_state); + extern struct gl_texture_object * _mesa_get_fallback_texture(GLcontext *ctx); @@ -76,7 +83,6 @@ _mesa_lock_context_textures( GLcontext *ctx ); /*@}*/ - /** * \name API functions */ diff --git a/src/mesa/main/texparam.c b/src/mesa/main/texparam.c index 35c3c920e7..b2fbe2205b 100644 --- a/src/mesa/main/texparam.c +++ b/src/mesa/main/texparam.c @@ -38,6 +38,7 @@ #include "main/texcompress.h" #include "main/texparam.h" #include "main/teximage.h" +#include "main/texstate.h" #include "shader/prog_instruction.h" @@ -88,7 +89,7 @@ get_texobj(GLcontext *ctx, GLenum target) return NULL; } - texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit]; + texUnit = _mesa_get_current_tex_unit(ctx); switch (target) { case GL_TEXTURE_1D: @@ -469,8 +470,10 @@ set_tex_parameterf(GLcontext *ctx, return GL_TRUE; } else { - _mesa_error(ctx, GL_INVALID_ENUM, - "glTexParameter(pname=GL_TEXTURE_MAX_ANISOTROPY_EXT)"); + static GLuint count = 0; + if (count++ < 10) + _mesa_error(ctx, GL_INVALID_ENUM, + "glTexParameter(pname=GL_TEXTURE_MAX_ANISOTROPY_EXT)"); } return GL_FALSE; @@ -714,44 +717,6 @@ _mesa_GetTexLevelParameterfv( GLenum target, GLint level, } -static GLuint -tex_image_dimensions(GLcontext *ctx, GLenum target) -{ - switch (target) { - case GL_TEXTURE_1D: - case GL_PROXY_TEXTURE_1D: - return 1; - case GL_TEXTURE_2D: - case GL_PROXY_TEXTURE_2D: - return 2; - case GL_TEXTURE_3D: - case GL_PROXY_TEXTURE_3D: - return 3; - case GL_TEXTURE_CUBE_MAP: - case GL_PROXY_TEXTURE_CUBE_MAP: - case GL_TEXTURE_CUBE_MAP_POSITIVE_X: - case GL_TEXTURE_CUBE_MAP_NEGATIVE_X: - case GL_TEXTURE_CUBE_MAP_POSITIVE_Y: - case GL_TEXTURE_CUBE_MAP_NEGATIVE_Y: - case GL_TEXTURE_CUBE_MAP_POSITIVE_Z: - case GL_TEXTURE_CUBE_MAP_NEGATIVE_Z: - return ctx->Extensions.ARB_texture_cube_map ? 2 : 0; - case GL_TEXTURE_RECTANGLE_NV: - case GL_PROXY_TEXTURE_RECTANGLE_NV: - return ctx->Extensions.NV_texture_rectangle ? 2 : 0; - case GL_TEXTURE_1D_ARRAY_EXT: - case GL_PROXY_TEXTURE_1D_ARRAY_EXT: - return ctx->Extensions.MESA_texture_array ? 2 : 0; - case GL_TEXTURE_2D_ARRAY_EXT: - case GL_PROXY_TEXTURE_2D_ARRAY_EXT: - return ctx->Extensions.MESA_texture_array ? 3 : 0; - default: - _mesa_problem(ctx, "bad target in _mesa_tex_target_dimensions()"); - return 0; - } -} - - void GLAPIENTRY _mesa_GetTexLevelParameteriv( GLenum target, GLint level, GLenum pname, GLint *params ) @@ -759,7 +724,6 @@ _mesa_GetTexLevelParameteriv( GLenum target, GLint level, const struct gl_texture_unit *texUnit; struct gl_texture_object *texObj; const struct gl_texture_image *img = NULL; - GLuint dimensions; GLboolean isProxy; GLint maxLevels; GET_CURRENT_CONTEXT(ctx); @@ -771,19 +735,13 @@ _mesa_GetTexLevelParameteriv( GLenum target, GLint level, return; } - texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit]; + texUnit = _mesa_get_current_tex_unit(ctx); /* this will catch bad target values */ - dimensions = tex_image_dimensions(ctx, target); /* 1, 2 or 3 */ - if (dimensions == 0) { - _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexLevelParameter[if]v(target)"); - return; - } - maxLevels = _mesa_max_texture_levels(ctx, target); if (maxLevels == 0) { - /* should not happen since <target> was just checked above */ - _mesa_problem(ctx, "maxLevels=0 in _mesa_GetTexLevelParameter"); + _mesa_error(ctx, GL_INVALID_ENUM, + "glGetTexLevelParameter[if]v(target=0x%x)", target); return; } @@ -880,7 +838,8 @@ _mesa_GetTexLevelParameteriv( GLenum target, GLint level, "glGetTexLevelParameter[if]v(pname)"); break; case GL_TEXTURE_STENCIL_SIZE_EXT: - if (ctx->Extensions.EXT_packed_depth_stencil) { + if (ctx->Extensions.EXT_packed_depth_stencil || + ctx->Extensions.ARB_framebuffer_object) { *params = img->TexFormat->StencilBits; } else { @@ -999,7 +958,7 @@ _mesa_GetTexParameterfv( GLenum target, GLenum pname, GLfloat *params ) return; } - texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit]; + texUnit = _mesa_get_current_tex_unit(ctx); obj = _mesa_select_tex_object(ctx, texUnit, target); if (!obj) { @@ -1166,7 +1125,7 @@ _mesa_GetTexParameteriv( GLenum target, GLenum pname, GLint *params ) return; } - texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit]; + texUnit = _mesa_get_current_tex_unit(ctx); obj = _mesa_select_tex_object(ctx, texUnit, target); if (!obj) { diff --git a/src/mesa/main/texstate.c b/src/mesa/main/texstate.c index 6e0c0c688a..861c5f37c4 100644 --- a/src/mesa/main/texstate.c +++ b/src/mesa/main/texstate.c @@ -729,14 +729,7 @@ init_texture_unit( GLcontext *ctx, GLuint unit ) 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 ); diff --git a/src/mesa/main/texstate.h b/src/mesa/main/texstate.h index a7d7088c62..17ac68000c 100644 --- a/src/mesa/main/texstate.h +++ b/src/mesa/main/texstate.h @@ -35,6 +35,18 @@ #include "mtypes.h" +/** + * Return pointer to current texture unit. + * This the texture unit set by glActiveTexture(), not glClientActiveTexture(). + */ +static INLINE struct gl_texture_unit * +_mesa_get_current_tex_unit(GLcontext *ctx) +{ + ASSERT(ctx->Texture.CurrentUnit < Elements(ctx->Texture.Unit)); + return &(ctx->Texture.Unit[ctx->Texture.CurrentUnit]); +} + + extern void _mesa_copy_texture_state( const GLcontext *src, GLcontext *dst ); @@ -48,16 +60,14 @@ _mesa_print_texunit_state( GLcontext *ctx, GLuint unit ); */ /*@{*/ - -/* - * GL_ARB_multitexture - */ extern void GLAPIENTRY _mesa_ActiveTextureARB( GLenum target ); extern void GLAPIENTRY _mesa_ClientActiveTextureARB( GLenum target ); +/*@}*/ + /** * \name Initialization, state maintenance diff --git a/src/mesa/main/texstore.c b/src/mesa/main/texstore.c index bfced1b3f4..a22db628d3 100644 --- a/src/mesa/main/texstore.c +++ b/src/mesa/main/texstore.c @@ -3138,7 +3138,7 @@ _mesa_validate_pbo_teximage(GLcontext *ctx, GLuint dimensions, { GLubyte *buf; - if (unpack->BufferObj->Name == 0) { + if (!_mesa_is_bufferobj(unpack->BufferObj)) { /* no PBO */ return pixels; } @@ -3174,7 +3174,7 @@ _mesa_validate_pbo_compressed_teximage(GLcontext *ctx, { GLubyte *buf; - if (packing->BufferObj->Name == 0) { + if (!_mesa_is_bufferobj(packing->BufferObj)) { /* not using a PBO - return pointer unchanged */ return pixels; } @@ -3204,7 +3204,7 @@ void _mesa_unmap_teximage_pbo(GLcontext *ctx, const struct gl_pixelstore_attrib *unpack) { - if (unpack->BufferObj->Name) { + if (_mesa_is_bufferobj(unpack->BufferObj)) { ctx->Driver.UnmapBuffer(ctx, GL_PIXEL_UNPACK_BUFFER_EXT, unpack->BufferObj); } diff --git a/src/mesa/main/varray.c b/src/mesa/main/varray.c index 8f6621ee45..6cd2a2f4f6 100644 --- a/src/mesa/main/varray.c +++ b/src/mesa/main/varray.c @@ -1,8 +1,9 @@ /* * Mesa 3-D graphics library - * Version: 7.2 + * Version: 7.6 * * 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"), @@ -29,6 +30,7 @@ #include "context.h" #include "enable.h" #include "enums.h" +#include "hash.h" #include "mtypes.h" #include "varray.h" #include "arrayobj.h" @@ -36,26 +38,39 @@ /** - * Update the fields of a vertex array object. - * We need to do a few special things for arrays that live in - * vertex buffer objects. + * Set the fields of a vertex array. + * Also do an error check for GL_ARB_vertex_array_object: check that + * all arrays reside in VBOs when using a vertex array object. * * \param array the array to update * \param dirtyBit which bit to set in ctx->Array.NewState for this array * \param elementSize size of each array element, in bytes * \param size components per element (1, 2, 3 or 4) * \param type datatype of each component (GL_FLOAT, GL_INT, etc) + * \param format either GL_RGBA or GL_BGRA * \param stride stride between elements, in elements * \param normalized are integer types converted to floats in [-1, 1]? * \param ptr the address (or offset inside VBO) of the array data + * \return GL_TRUE if no error, GL_FALSE if error */ -static void +static GLboolean update_array(GLcontext *ctx, struct gl_client_array *array, GLbitfield dirtyBit, GLsizei elementSize, GLint size, GLenum type, GLenum format, GLsizei stride, GLboolean normalized, const GLvoid *ptr) { ASSERT(format == GL_RGBA || format == GL_BGRA); + + if (ctx->Array.ArrayObj->VBOonly && + ctx->Array.ArrayBufferObj->Name == 0) { + /* GL_ARB_vertex_array_object requires that all arrays reside in VBOs. + * Generate GL_INVALID_OPERATION if that's not true. + */ + _mesa_error(ctx, GL_INVALID_OPERATION, + "glVertex/Normal/EtcPointer(non-VBO array)"); + return GL_FALSE; + } + array->Size = size; array->Type = type; array->Format = format; @@ -63,24 +78,15 @@ update_array(GLcontext *ctx, struct gl_client_array *array, array->StrideB = stride ? stride : elementSize; array->Normalized = normalized; array->Ptr = (const GLubyte *) ptr; -#if FEATURE_ARB_vertex_buffer_object + array->_ElementSize = elementSize; + _mesa_reference_buffer_object(ctx, &array->BufferObj, ctx->Array.ArrayBufferObj); - /* Compute the index of the last array element that's inside the buffer. - * Later in glDrawArrays we'll check if start + count > _MaxElement to - * be sure we won't go out of bounds. - */ - if (ctx->Array.ArrayBufferObj->Name) - array->_MaxElement = ((GLsizeiptrARB) ctx->Array.ArrayBufferObj->Size - - (GLsizeiptrARB) array->Ptr + array->StrideB - - elementSize) / array->StrideB; - else -#endif - array->_MaxElement = 2 * 1000 * 1000 * 1000; /* just a big number */ - ctx->NewState |= _NEW_ARRAY; ctx->Array.NewState |= dirtyBit; + + return GL_TRUE; } @@ -129,12 +135,14 @@ _mesa_VertexPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *ptr) break; #endif default: - _mesa_error( ctx, GL_INVALID_ENUM, "glVertexPointer(type)" ); + _mesa_error( ctx, GL_INVALID_ENUM, "glVertexPointer(type=%s)", + _mesa_lookup_enum_by_nr(type)); return; } - update_array(ctx, &ctx->Array.ArrayObj->Vertex, _NEW_ARRAY_VERTEX, - elementSize, size, type, GL_RGBA, stride, GL_FALSE, ptr); + if (!update_array(ctx, &ctx->Array.ArrayObj->Vertex, _NEW_ARRAY_VERTEX, + elementSize, size, type, GL_RGBA, stride, GL_FALSE, ptr)) + return; if (ctx->Driver.VertexPointer) ctx->Driver.VertexPointer( ctx, size, type, stride, ptr ); @@ -179,12 +187,14 @@ _mesa_NormalPointer(GLenum type, GLsizei stride, const GLvoid *ptr ) break; #endif default: - _mesa_error( ctx, GL_INVALID_ENUM, "glNormalPointer(type)" ); + _mesa_error( ctx, GL_INVALID_ENUM, "glNormalPointer(type=%s)", + _mesa_lookup_enum_by_nr(type)); return; } - update_array(ctx, &ctx->Array.ArrayObj->Normal, _NEW_ARRAY_NORMAL, - elementSize, 3, type, GL_RGBA, stride, GL_TRUE, ptr); + if (!update_array(ctx, &ctx->Array.ArrayObj->Normal, _NEW_ARRAY_NORMAL, + elementSize, 3, type, GL_RGBA, stride, GL_TRUE, ptr)) + return; if (ctx->Driver.NormalPointer) ctx->Driver.NormalPointer( ctx, type, stride, ptr ); @@ -257,12 +267,14 @@ _mesa_ColorPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *ptr) break; #endif default: - _mesa_error( ctx, GL_INVALID_ENUM, "glColorPointer(type)" ); + _mesa_error( ctx, GL_INVALID_ENUM, "glColorPointer(type=%s)", + _mesa_lookup_enum_by_nr(type)); return; } - update_array(ctx, &ctx->Array.ArrayObj->Color, _NEW_ARRAY_COLOR0, - elementSize, size, type, format, stride, GL_TRUE, ptr); + if (!update_array(ctx, &ctx->Array.ArrayObj->Color, _NEW_ARRAY_COLOR0, + elementSize, size, type, format, stride, GL_TRUE, ptr)) + return; if (ctx->Driver.ColorPointer) ctx->Driver.ColorPointer( ctx, size, type, stride, ptr ); @@ -293,8 +305,9 @@ _mesa_FogCoordPointerEXT(GLenum type, GLsizei stride, const GLvoid *ptr) return; } - update_array(ctx, &ctx->Array.ArrayObj->FogCoord, _NEW_ARRAY_FOGCOORD, - elementSize, 1, type, GL_RGBA, stride, GL_FALSE, ptr); + if (!update_array(ctx, &ctx->Array.ArrayObj->FogCoord, _NEW_ARRAY_FOGCOORD, + elementSize, 1, type, GL_RGBA, stride, GL_FALSE, ptr)) + return; if (ctx->Driver.FogCoordPointer) ctx->Driver.FogCoordPointer( ctx, type, stride, ptr ); @@ -334,8 +347,9 @@ _mesa_IndexPointer(GLenum type, GLsizei stride, const GLvoid *ptr) return; } - update_array(ctx, &ctx->Array.ArrayObj->Index, _NEW_ARRAY_INDEX, - elementSize, 1, type, GL_RGBA, stride, GL_FALSE, ptr); + if (!update_array(ctx, &ctx->Array.ArrayObj->Index, _NEW_ARRAY_INDEX, + elementSize, 1, type, GL_RGBA, stride, GL_FALSE, ptr)) + return; if (ctx->Driver.IndexPointer) ctx->Driver.IndexPointer( ctx, type, stride, ptr ); @@ -404,12 +418,15 @@ _mesa_SecondaryColorPointerEXT(GLint size, GLenum type, elementSize = size * sizeof(GLdouble); break; default: - _mesa_error( ctx, GL_INVALID_ENUM, "glSecondaryColorPointer(type)" ); + _mesa_error( ctx, GL_INVALID_ENUM, "glSecondaryColorPointer(type=%s)", + _mesa_lookup_enum_by_nr(type)); return; } - update_array(ctx, &ctx->Array.ArrayObj->SecondaryColor, _NEW_ARRAY_COLOR1, - elementSize, size, type, format, stride, GL_TRUE, ptr); + if (!update_array(ctx, &ctx->Array.ArrayObj->SecondaryColor, + _NEW_ARRAY_COLOR1, elementSize, size, type, + format, stride, GL_TRUE, ptr)) + return; if (ctx->Driver.SecondaryColorPointer) ctx->Driver.SecondaryColorPointer( ctx, size, type, stride, ptr ); @@ -463,13 +480,15 @@ _mesa_TexCoordPointer(GLint size, GLenum type, GLsizei stride, break; #endif default: - _mesa_error( ctx, GL_INVALID_ENUM, "glTexCoordPointer(type)" ); + _mesa_error( ctx, GL_INVALID_ENUM, "glTexCoordPointer(type=%s)", + _mesa_lookup_enum_by_nr(type)); return; } - update_array(ctx, &ctx->Array.ArrayObj->TexCoord[unit], - _NEW_ARRAY_TEXCOORD(unit), - elementSize, size, type, GL_RGBA, stride, GL_FALSE, ptr); + if (!update_array(ctx, &ctx->Array.ArrayObj->TexCoord[unit], + _NEW_ARRAY_TEXCOORD(unit), + elementSize, size, type, GL_RGBA, stride, GL_FALSE, ptr)) + return; if (ctx->Driver.TexCoordPointer) ctx->Driver.TexCoordPointer( ctx, size, type, stride, ptr ); @@ -487,9 +506,10 @@ _mesa_EdgeFlagPointer(GLsizei stride, const GLvoid *ptr) return; } - update_array(ctx, &ctx->Array.ArrayObj->EdgeFlag, _NEW_ARRAY_EDGEFLAG, - sizeof(GLboolean), 1, GL_UNSIGNED_BYTE, GL_RGBA, - stride, GL_FALSE, ptr); + if (!update_array(ctx, &ctx->Array.ArrayObj->EdgeFlag, _NEW_ARRAY_EDGEFLAG, + sizeof(GLboolean), 1, GL_UNSIGNED_BYTE, GL_RGBA, + stride, GL_FALSE, ptr)) + return; if (ctx->Driver.EdgeFlagPointer) ctx->Driver.EdgeFlagPointer( ctx, stride, ptr ); @@ -528,6 +548,12 @@ _mesa_PointSizePointer(GLenum type, GLsizei stride, const GLvoid *ptr) #if FEATURE_NV_vertex_program +/** + * Set a vertex attribute array. + * Note that these arrays DO alias the conventional GL vertex arrays + * (position, normal, color, fog, texcoord, etc). + * The generic attribute slots at #16 and above are not touched. + */ void GLAPIENTRY _mesa_VertexAttribPointerNV(GLuint index, GLint size, GLenum type, GLsizei stride, const GLvoid *ptr) @@ -589,13 +615,15 @@ _mesa_VertexAttribPointerNV(GLuint index, GLint size, GLenum type, elementSize = size * sizeof(GLdouble); break; default: - _mesa_error( ctx, GL_INVALID_ENUM, "glVertexAttribPointerNV(type)" ); + _mesa_error( ctx, GL_INVALID_ENUM, "glVertexAttribPointerNV(type=%s)", + _mesa_lookup_enum_by_nr(type)); return; } - update_array(ctx, &ctx->Array.ArrayObj->VertexAttrib[index], - _NEW_ARRAY_ATTRIB(index), - elementSize, size, type, format, stride, normalized, ptr); + if (!update_array(ctx, &ctx->Array.ArrayObj->VertexAttrib[index], + _NEW_ARRAY_ATTRIB(index), + elementSize, size, type, format, stride, normalized, ptr)) + return; if (ctx->Driver.VertexAttribPointer) ctx->Driver.VertexAttribPointer( ctx, index, size, type, stride, ptr ); @@ -604,6 +632,11 @@ _mesa_VertexAttribPointerNV(GLuint index, GLint size, GLenum type, #if FEATURE_ARB_vertex_program +/** + * Set a generic vertex attribute array. + * Note that these arrays DO NOT alias the conventional GL vertex arrays + * (position, normal, color, fog, texcoord, etc). + */ void GLAPIENTRY _mesa_VertexAttribPointerARB(GLuint index, GLint size, GLenum type, GLboolean normalized, @@ -687,9 +720,10 @@ _mesa_VertexAttribPointerARB(GLuint index, GLint size, GLenum type, return; } - update_array(ctx, &ctx->Array.ArrayObj->VertexAttrib[index], - _NEW_ARRAY_ATTRIB(index), - elementSize, size, type, format, stride, normalized, ptr); + if (!update_array(ctx, &ctx->Array.ArrayObj->VertexAttrib[index], + _NEW_ARRAY_ATTRIB(index), + elementSize, size, type, format, stride, normalized, ptr)) + return; if (ctx->Driver.VertexAttribPointer) ctx->Driver.VertexAttribPointer(ctx, index, size, type, stride, ptr); @@ -1004,24 +1038,6 @@ _mesa_MultiDrawArraysEXT( GLenum mode, GLint *first, } -/* GL_EXT_multi_draw_arrays */ -void GLAPIENTRY -_mesa_MultiDrawElementsEXT( GLenum mode, const GLsizei *count, GLenum type, - const GLvoid **indices, GLsizei primcount ) -{ - GET_CURRENT_CONTEXT(ctx); - GLint i; - - ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx); - - for (i = 0; i < primcount; i++) { - if (count[i] > 0) { - CALL_DrawElements(ctx->Exec, (mode, count[i], type, indices[i])); - } - } -} - - /* GL_IBM_multimode_draw_arrays */ void GLAPIENTRY _mesa_MultiModeDrawArraysIBM( const GLenum * mode, const GLint * first, @@ -1065,6 +1081,75 @@ _mesa_MultiModeDrawElementsIBM( const GLenum * mode, const GLsizei * count, /** + * Copy one client vertex array to another. + */ +void +_mesa_copy_client_array(GLcontext *ctx, + struct gl_client_array *dst, + struct gl_client_array *src) +{ + dst->Size = src->Size; + dst->Type = src->Type; + dst->Format = src->Format; + dst->Stride = src->Stride; + dst->StrideB = src->StrideB; + dst->Ptr = src->Ptr; + dst->Enabled = src->Enabled; + dst->Normalized = src->Normalized; + dst->_ElementSize = src->_ElementSize; + _mesa_reference_buffer_object(ctx, &dst->BufferObj, src->BufferObj); + dst->_MaxElement = src->_MaxElement; +} + + + +/** + * Print vertex array's fields. + */ +static void +print_array(const char *name, GLint index, const struct gl_client_array *array) +{ + if (index >= 0) + _mesa_printf(" %s[%d]: ", name, index); + else + _mesa_printf(" %s: ", name); + _mesa_printf("Ptr=%p, Type=0x%x, Size=%d, ElemSize=%u, Stride=%d, Buffer=%u(Size %u), MaxElem=%u\n", + array->Ptr, array->Type, array->Size, + array->_ElementSize, array->StrideB, + array->BufferObj->Name, array->BufferObj->Size, + array->_MaxElement); +} + + +/** + * Print current vertex object/array info. For debug. + */ +void +_mesa_print_arrays(GLcontext *ctx) +{ + struct gl_array_object *arrayObj = ctx->Array.ArrayObj; + GLuint i; + + _mesa_update_array_object_max_element(ctx, arrayObj); + + _mesa_printf("Array Object %u\n", arrayObj->Name); + if (arrayObj->Vertex.Enabled) + print_array("Vertex", -1, &arrayObj->Vertex); + if (arrayObj->Normal.Enabled) + print_array("Normal", -1, &arrayObj->Normal); + if (arrayObj->Color.Enabled) + print_array("Color", -1, &arrayObj->Color); + for (i = 0; i < Elements(arrayObj->TexCoord); i++) + if (arrayObj->TexCoord[i].Enabled) + print_array("TexCoord", i, &arrayObj->TexCoord[i]); + for (i = 0; i < Elements(arrayObj->VertexAttrib); i++) + if (arrayObj->VertexAttrib[i].Enabled) + print_array("Attrib", i, &arrayObj->VertexAttrib[i]); + _mesa_printf(" _MaxElement = %u\n", arrayObj->_MaxElement); +} + + +/** * Initialize vertex array state for given context. */ void @@ -1074,4 +1159,29 @@ _mesa_init_varray(GLcontext *ctx) _mesa_reference_array_object(ctx, &ctx->Array.ArrayObj, ctx->Array.DefaultArrayObj); ctx->Array.ActiveTexture = 0; /* GL_ARB_multitexture */ + + ctx->Array.Objects = _mesa_NewHashTable(); +} + + +/** + * 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); +} + + +/** + * Free vertex array state for given context. + */ +void +_mesa_free_varray_data(GLcontext *ctx) +{ + _mesa_HashDeleteAll(ctx->Array.Objects, delete_arrayobj_cb, ctx); + _mesa_DeleteHashTable(ctx->Array.Objects); } diff --git a/src/mesa/main/varray.h b/src/mesa/main/varray.h index 97d5c8219d..becc67c29d 100644 --- a/src/mesa/main/varray.h +++ b/src/mesa/main/varray.h @@ -1,18 +1,9 @@ -/** - * \file varray.h - * Vertex arrays. - * - * \if subset - * (No-op) - * - * \endif - */ - /* * Mesa 3-D graphics library - * Version: 4.1 + * Version: 7.6 * - * Copyright (C) 1999-2002 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"), @@ -169,14 +160,26 @@ _mesa_DrawRangeElements(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid *indices); +extern void +_mesa_copy_client_array(GLcontext *ctx, + struct gl_client_array *dst, + struct gl_client_array *src); + + +extern void +_mesa_print_arrays(GLcontext *ctx); extern void _mesa_init_varray( GLcontext * ctx ); +extern void +_mesa_free_varray_data(GLcontext *ctx); + #else /** No-op */ #define _mesa_init_varray( c ) ((void)0) +#define _mesa_free_varray_data( c ) ((void)0) #endif diff --git a/src/mesa/main/version.h b/src/mesa/main/version.h index 995e46d318..d4d3dd1a94 100644 --- a/src/mesa/main/version.h +++ b/src/mesa/main/version.h @@ -1,8 +1,9 @@ /* * Mesa 3-D graphics library - * Version: 7.5.2 + * Version: 7.6 * - * Copyright (C) 1999-2009 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"), @@ -29,9 +30,9 @@ /* Mesa version */ #define MESA_MAJOR 7 -#define MESA_MINOR 5 -#define MESA_PATCH 2 -#define MESA_VERSION_STRING "7.5.2-devel" +#define MESA_MINOR 6 +#define MESA_PATCH 0 +#define MESA_VERSION_STRING "7.6-devel" /* To make version comparison easy */ #define MESA_VERSION(a,b,c) (((a) << 16) + ((b) << 8) + (c)) diff --git a/src/mesa/main/viewport.c b/src/mesa/main/viewport.c index 50e0402d27..309308c983 100644 --- a/src/mesa/main/viewport.c +++ b/src/mesa/main/viewport.c @@ -120,6 +120,10 @@ _mesa_DepthRange(GLclampd nearval, GLclampd farval) if (MESA_VERBOSE&VERBOSE_API) _mesa_debug(ctx, "glDepthRange %f %f\n", nearval, farval); + if (ctx->Viewport.Near == nearval && + ctx->Viewport.Far == farval) + return; + ctx->Viewport.Near = (GLfloat) CLAMP(nearval, 0.0, 1.0); ctx->Viewport.Far = (GLfloat) CLAMP(farval, 0.0, 1.0); ctx->NewState |= _NEW_VIEWPORT; diff --git a/src/mesa/main/vtxfmt.c b/src/mesa/main/vtxfmt.c index 1f807dc3dc..8d6f560a80 100644 --- a/src/mesa/main/vtxfmt.c +++ b/src/mesa/main/vtxfmt.c @@ -133,6 +133,7 @@ install_vtxfmt( struct _glapi_table *tab, const GLvertexformat *vfmt ) SET_DrawArrays(tab, vfmt->DrawArrays); SET_DrawElements(tab, vfmt->DrawElements); SET_DrawRangeElements(tab, vfmt->DrawRangeElements); + SET_MultiDrawElementsEXT(tab, vfmt->MultiDrawElementsEXT); SET_EvalMesh1(tab, vfmt->EvalMesh1); SET_EvalMesh2(tab, vfmt->EvalMesh2); ASSERT(tab->EvalMesh2); diff --git a/src/mesa/main/vtxfmt_tmp.h b/src/mesa/main/vtxfmt_tmp.h index 6f5d01e40f..1308d0aa46 100644 --- a/src/mesa/main/vtxfmt_tmp.h +++ b/src/mesa/main/vtxfmt_tmp.h @@ -335,6 +335,17 @@ static void GLAPIENTRY TAG(DrawElements)( GLenum mode, GLsizei count, GLenum typ CALL_DrawElements(GET_DISPATCH(), ( mode, count, type, indices )); } +static void GLAPIENTRY TAG(MultiDrawElementsEXT)( GLenum mode, + const GLsizei *count, + GLenum type, + const GLvoid **indices, + GLsizei primcount) +{ + PRE_LOOPBACK( MultiDrawElementsEXT ); + CALL_MultiDrawElementsEXT(GET_DISPATCH(), ( mode, count, type, indices, + primcount )); +} + static void GLAPIENTRY TAG(DrawRangeElements)( GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid *indices ) @@ -522,6 +533,7 @@ static GLvertexformat TAG(vtxfmt) = { TAG(DrawArrays), TAG(DrawElements), TAG(DrawRangeElements), + TAG(MultiDrawElementsEXT), TAG(EvalMesh1), TAG(EvalMesh2) }; |