X-Git-Url: https://git.libre-soc.org/?a=blobdiff_plain;f=src%2Fmesa%2Fmain%2Fenable.c;h=40508a4564347f33b10dc0b49152a4810a356dc5;hb=aac1415b66fafedc50c4346dae2d652723156ed9;hp=c4c4e1bb29d7acd602a4ad45faa4c926701e97f6;hpb=a637280e42b9a2f4ccbb5e7b209c5645073f584e;p=mesa.git diff --git a/src/mesa/main/enable.c b/src/mesa/main/enable.c index c4c4e1bb29d..40508a45643 100644 --- a/src/mesa/main/enable.c +++ b/src/mesa/main/enable.c @@ -5,7 +5,6 @@ /* * Mesa 3-D graphics library - * Version: 7.0.3 * * Copyright (C) 1999-2007 Brian Paul All Rights Reserved. * @@ -22,22 +21,24 @@ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL - * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN - * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN - * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + * 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. */ #include "glheader.h" +#include "clip.h" #include "context.h" #include "enable.h" #include "light.h" #include "simple_list.h" -#include "mfeatures.h" #include "mtypes.h" #include "enums.h" #include "api_arrayelt.h" #include "texstate.h" +#include "drivers/common/meta.h" @@ -47,83 +48,63 @@ } +static void +update_derived_primitive_restart_state(struct gl_context *ctx) +{ + /* Update derived primitive restart state. + */ + ctx->Array._PrimitiveRestart = ctx->Array.PrimitiveRestart + || ctx->Array.PrimitiveRestartFixedIndex; +} + /** * Helper to enable/disable client-side state. */ static void client_state(struct gl_context *ctx, GLenum cap, GLboolean state) { - struct gl_array_object *arrayObj = ctx->Array.ArrayObj; - GLuint flag; + struct gl_vertex_array_object *vao = ctx->Array.VAO; + GLbitfield64 flag; GLboolean *var; switch (cap) { case GL_VERTEX_ARRAY: - var = &arrayObj->Vertex.Enabled; - flag = _NEW_ARRAY_VERTEX; + var = &vao->VertexAttrib[VERT_ATTRIB_POS].Enabled; + flag = VERT_BIT_POS; break; case GL_NORMAL_ARRAY: - var = &arrayObj->Normal.Enabled; - flag = _NEW_ARRAY_NORMAL; + var = &vao->VertexAttrib[VERT_ATTRIB_NORMAL].Enabled; + flag = VERT_BIT_NORMAL; break; case GL_COLOR_ARRAY: - var = &arrayObj->Color.Enabled; - flag = _NEW_ARRAY_COLOR0; + var = &vao->VertexAttrib[VERT_ATTRIB_COLOR0].Enabled; + flag = VERT_BIT_COLOR0; break; case GL_INDEX_ARRAY: - var = &arrayObj->Index.Enabled; - flag = _NEW_ARRAY_INDEX; + var = &vao->VertexAttrib[VERT_ATTRIB_COLOR_INDEX].Enabled; + flag = VERT_BIT_COLOR_INDEX; break; case GL_TEXTURE_COORD_ARRAY: - var = &arrayObj->TexCoord[ctx->Array.ActiveTexture].Enabled; - flag = _NEW_ARRAY_TEXCOORD(ctx->Array.ActiveTexture); + var = &vao->VertexAttrib[VERT_ATTRIB_TEX(ctx->Array.ActiveTexture)].Enabled; + flag = VERT_BIT_TEX(ctx->Array.ActiveTexture); break; case GL_EDGE_FLAG_ARRAY: - var = &arrayObj->EdgeFlag.Enabled; - flag = _NEW_ARRAY_EDGEFLAG; + var = &vao->VertexAttrib[VERT_ATTRIB_EDGEFLAG].Enabled; + flag = VERT_BIT_EDGEFLAG; break; case GL_FOG_COORDINATE_ARRAY_EXT: - var = &arrayObj->FogCoord.Enabled; - flag = _NEW_ARRAY_FOGCOORD; + var = &vao->VertexAttrib[VERT_ATTRIB_FOG].Enabled; + flag = VERT_BIT_FOG; break; case GL_SECONDARY_COLOR_ARRAY_EXT: - var = &arrayObj->SecondaryColor.Enabled; - flag = _NEW_ARRAY_COLOR1; + var = &vao->VertexAttrib[VERT_ATTRIB_COLOR1].Enabled; + flag = VERT_BIT_COLOR1; break; -#if FEATURE_point_size_array case GL_POINT_SIZE_ARRAY_OES: - var = &arrayObj->PointSize.Enabled; - flag = _NEW_ARRAY_POINT_SIZE; - break; -#endif - -#if FEATURE_NV_vertex_program - case GL_VERTEX_ATTRIB_ARRAY0_NV: - case GL_VERTEX_ATTRIB_ARRAY1_NV: - case GL_VERTEX_ATTRIB_ARRAY2_NV: - case GL_VERTEX_ATTRIB_ARRAY3_NV: - case GL_VERTEX_ATTRIB_ARRAY4_NV: - case GL_VERTEX_ATTRIB_ARRAY5_NV: - case GL_VERTEX_ATTRIB_ARRAY6_NV: - case GL_VERTEX_ATTRIB_ARRAY7_NV: - case GL_VERTEX_ATTRIB_ARRAY8_NV: - case GL_VERTEX_ATTRIB_ARRAY9_NV: - case GL_VERTEX_ATTRIB_ARRAY10_NV: - case GL_VERTEX_ATTRIB_ARRAY11_NV: - case GL_VERTEX_ATTRIB_ARRAY12_NV: - case GL_VERTEX_ATTRIB_ARRAY13_NV: - case GL_VERTEX_ATTRIB_ARRAY14_NV: - case GL_VERTEX_ATTRIB_ARRAY15_NV: - CHECK_EXTENSION(NV_vertex_program, cap); - { - GLint n = (GLint) cap - GL_VERTEX_ATTRIB_ARRAY0_NV; - ASSERT(n < Elements(ctx->Array.ArrayObj->VertexAttrib)); - var = &arrayObj->VertexAttrib[n].Enabled; - flag = _NEW_ARRAY_ATTRIB(n); - } + var = &vao->VertexAttrib[VERT_ATTRIB_POINT_SIZE].Enabled; + flag = VERT_BIT_POINT_SIZE; break; -#endif /* FEATURE_NV_vertex_program */ /* GL_NV_primitive_restart */ case GL_PRIMITIVE_RESTART_NV: @@ -142,16 +123,19 @@ client_state(struct gl_context *ctx, GLenum cap, GLboolean state) return; FLUSH_VERTICES(ctx, _NEW_ARRAY); - ctx->Array.NewState |= flag; _ae_invalidate_state(ctx, _NEW_ARRAY); *var = state; + update_derived_primitive_restart_state(ctx); + if (state) - ctx->Array.ArrayObj->_Enabled |= flag; + vao->_Enabled |= flag; else - ctx->Array.ArrayObj->_Enabled &= ~flag; + vao->_Enabled &= ~flag; + + vao->NewArrays |= flag; if (ctx->Driver.Enable) { ctx->Driver.Enable( ctx, cap, state ); @@ -160,8 +144,8 @@ client_state(struct gl_context *ctx, GLenum cap, GLboolean state) return; invalid_enum_error: - _mesa_error(ctx, GL_INVALID_ENUM, "gl%sClientState(0x%x)", - state ? "Enable" : "Disable", cap); + _mesa_error(ctx, GL_INVALID_ENUM, "gl%sClientState(%s)", + state ? "Enable" : "Disable", _mesa_lookup_enum_by_nr(cap)); } @@ -176,7 +160,6 @@ void GLAPIENTRY _mesa_EnableClientState( GLenum cap ) { GET_CURRENT_CONTEXT(ctx); - ASSERT_OUTSIDE_BEGIN_END(ctx); client_state( ctx, cap, GL_TRUE ); } @@ -192,7 +175,6 @@ void GLAPIENTRY _mesa_DisableClientState( GLenum cap ) { GET_CURRENT_CONTEXT(ctx); - ASSERT_OUTSIDE_BEGIN_END(ctx); client_state( ctx, cap, GL_FALSE ); } @@ -208,13 +190,11 @@ _mesa_DisableClientState( GLenum cap ) goto invalid_enum_error; \ } - - /** * Return pointer to current texture unit for setting/getting coordinate * state. - * Note that we'll set GL_INVALID_OPERATION if the active texture unit is - * higher than the number of supported coordinate units. And we'll return NULL. + * Note that we'll set GL_INVALID_OPERATION and return NULL if the active + * texture unit is higher than the number of supported coordinate units. */ static struct gl_texture_unit * get_texcoord_unit(struct gl_context *ctx) @@ -250,6 +230,40 @@ enable_texture(struct gl_context *ctx, GLboolean state, GLbitfield texBit) } +/** + * Helper function to enable or disable GL_MULTISAMPLE, skipping the check for + * whether the API supports it (GLES doesn't). + */ +void +_mesa_set_multisample(struct gl_context *ctx, GLboolean state) +{ + if (ctx->Multisample.Enabled == state) + return; + FLUSH_VERTICES(ctx, _NEW_MULTISAMPLE); + ctx->Multisample.Enabled = state; + + if (ctx->Driver.Enable) { + ctx->Driver.Enable(ctx, GL_MULTISAMPLE, state); + } +} + +/** + * Helper function to enable or disable GL_FRAMEBUFFER_SRGB, skipping the + * check for whether the API supports it (GLES doesn't). + */ +void +_mesa_set_framebuffer_srgb(struct gl_context *ctx, GLboolean state) +{ + if (ctx->Color.sRGBEnabled == state) + return; + FLUSH_VERTICES(ctx, _NEW_BUFFERS); + ctx->Color.sRGBEnabled = state; + + if (ctx->Driver.Enable) { + ctx->Driver.Enable(ctx, GL_FRAMEBUFFER_SRGB, state); + } +} + /** * Helper function to enable or disable state. * @@ -273,12 +287,16 @@ _mesa_set_enable(struct gl_context *ctx, GLenum cap, GLboolean state) switch (cap) { case GL_ALPHA_TEST: + if (ctx->API != API_OPENGL_COMPAT && ctx->API != API_OPENGLES) + goto invalid_enum_error; if (ctx->Color.AlphaEnabled == state) return; FLUSH_VERTICES(ctx, _NEW_COLOR); ctx->Color.AlphaEnabled = state; break; case GL_AUTO_NORMAL: + if (ctx->API != API_OPENGL_COMPAT) + goto invalid_enum_error; if (ctx->Eval.AutoNormal == state) return; FLUSH_VERTICES(ctx, _NEW_EVAL); @@ -286,49 +304,46 @@ _mesa_set_enable(struct gl_context *ctx, GLenum cap, GLboolean state) break; case GL_BLEND: { - GLbitfield newEnabled = state * ((1 << ctx->Const.MaxDrawBuffers) - 1); + GLbitfield newEnabled = + state * ((1 << ctx->Const.MaxDrawBuffers) - 1); if (newEnabled != ctx->Color.BlendEnabled) { FLUSH_VERTICES(ctx, _NEW_COLOR); ctx->Color.BlendEnabled = newEnabled; } } break; -#if FEATURE_userclip - case GL_CLIP_PLANE0: - case GL_CLIP_PLANE1: - case GL_CLIP_PLANE2: - case GL_CLIP_PLANE3: - case GL_CLIP_PLANE4: - case GL_CLIP_PLANE5: + case GL_CLIP_DISTANCE0: + case GL_CLIP_DISTANCE1: + case GL_CLIP_DISTANCE2: + case GL_CLIP_DISTANCE3: + case GL_CLIP_DISTANCE4: + case GL_CLIP_DISTANCE5: + case GL_CLIP_DISTANCE6: + case GL_CLIP_DISTANCE7: { - const GLuint p = cap - GL_CLIP_PLANE0; + const GLuint p = cap - GL_CLIP_DISTANCE0; + + if (p >= ctx->Const.MaxClipPlanes) + goto invalid_enum_error; - if ((ctx->Transform.ClipPlanesEnabled & (1 << p)) == ((GLuint) state << p)) + if ((ctx->Transform.ClipPlanesEnabled & (1 << p)) + == ((GLuint) state << p)) return; FLUSH_VERTICES(ctx, _NEW_TRANSFORM); if (state) { ctx->Transform.ClipPlanesEnabled |= (1 << p); - - if (_math_matrix_is_dirty(ctx->ProjectionMatrixStack.Top)) - _math_matrix_analyse( ctx->ProjectionMatrixStack.Top ); - - /* This derived state also calculated in clip.c and - * from _mesa_update_state() on changes to EyeUserPlane - * and ctx->ProjectionMatrix respectively. - */ - _mesa_transform_vector( ctx->Transform._ClipUserPlane[p], - ctx->Transform.EyeUserPlane[p], - ctx->ProjectionMatrixStack.Top->inv ); + _mesa_update_clip_plane(ctx, p); } else { ctx->Transform.ClipPlanesEnabled &= ~(1 << p); } } break; -#endif case GL_COLOR_MATERIAL: + if (ctx->API != API_OPENGL_COMPAT && ctx->API != API_OPENGLES) + goto invalid_enum_error; if (ctx->Light.ColorMaterialEnabled == state) return; FLUSH_VERTICES(ctx, _NEW_LIGHT); @@ -351,16 +366,25 @@ _mesa_set_enable(struct gl_context *ctx, GLenum cap, GLboolean state) FLUSH_VERTICES(ctx, _NEW_DEPTH); ctx->Depth.Test = state; break; + case GL_DEBUG_OUTPUT: + if (!_mesa_is_desktop_gl(ctx)) + goto invalid_enum_error; + ctx->Debug.DebugOutput = state; + break; + case GL_DEBUG_OUTPUT_SYNCHRONOUS_ARB: + if (!_mesa_is_desktop_gl(ctx)) + goto invalid_enum_error; + ctx->Debug.SyncOutput = state; + break; case GL_DITHER: - if (ctx->NoDither) { - state = GL_FALSE; /* MESA_NO_DITHER env var */ - } if (ctx->Color.DitherFlag == state) return; FLUSH_VERTICES(ctx, _NEW_COLOR); ctx->Color.DitherFlag = state; break; case GL_FOG: + if (ctx->API != API_OPENGL_COMPAT && ctx->API != API_OPENGLES) + goto invalid_enum_error; if (ctx->Fog.Enabled == state) return; FLUSH_VERTICES(ctx, _NEW_FOG); @@ -374,6 +398,8 @@ _mesa_set_enable(struct gl_context *ctx, GLenum cap, GLboolean state) case GL_LIGHT5: case GL_LIGHT6: case GL_LIGHT7: + if (ctx->API != API_OPENGL_COMPAT && ctx->API != API_OPENGLES) + goto invalid_enum_error; if (ctx->Light.Light[cap-GL_LIGHT0].Enabled == state) return; FLUSH_VERTICES(ctx, _NEW_LIGHT); @@ -387,212 +413,261 @@ _mesa_set_enable(struct gl_context *ctx, GLenum cap, GLboolean state) } break; case GL_LIGHTING: + if (ctx->API != API_OPENGL_COMPAT && ctx->API != API_OPENGLES) + goto invalid_enum_error; if (ctx->Light.Enabled == state) return; FLUSH_VERTICES(ctx, _NEW_LIGHT); ctx->Light.Enabled = state; - if (ctx->Light.Enabled && ctx->Light.Model.TwoSide) - ctx->_TriangleCaps |= DD_TRI_LIGHT_TWOSIDE; - else - ctx->_TriangleCaps &= ~DD_TRI_LIGHT_TWOSIDE; break; case GL_LINE_SMOOTH: + if (!_mesa_is_desktop_gl(ctx) && ctx->API != API_OPENGLES) + goto invalid_enum_error; if (ctx->Line.SmoothFlag == state) return; FLUSH_VERTICES(ctx, _NEW_LINE); ctx->Line.SmoothFlag = state; - ctx->_TriangleCaps ^= DD_LINE_SMOOTH; break; case GL_LINE_STIPPLE: + if (ctx->API != API_OPENGL_COMPAT) + goto invalid_enum_error; if (ctx->Line.StippleFlag == state) return; FLUSH_VERTICES(ctx, _NEW_LINE); ctx->Line.StippleFlag = state; - ctx->_TriangleCaps ^= DD_LINE_STIPPLE; break; case GL_INDEX_LOGIC_OP: + if (ctx->API != API_OPENGL_COMPAT) + goto invalid_enum_error; if (ctx->Color.IndexLogicOpEnabled == state) return; FLUSH_VERTICES(ctx, _NEW_COLOR); ctx->Color.IndexLogicOpEnabled = state; break; case GL_COLOR_LOGIC_OP: + if (!_mesa_is_desktop_gl(ctx) && ctx->API != API_OPENGLES) + goto invalid_enum_error; if (ctx->Color.ColorLogicOpEnabled == state) return; FLUSH_VERTICES(ctx, _NEW_COLOR); ctx->Color.ColorLogicOpEnabled = state; break; case GL_MAP1_COLOR_4: + if (ctx->API != API_OPENGL_COMPAT) + goto invalid_enum_error; if (ctx->Eval.Map1Color4 == state) return; FLUSH_VERTICES(ctx, _NEW_EVAL); ctx->Eval.Map1Color4 = state; break; case GL_MAP1_INDEX: + if (ctx->API != API_OPENGL_COMPAT) + goto invalid_enum_error; if (ctx->Eval.Map1Index == state) return; FLUSH_VERTICES(ctx, _NEW_EVAL); ctx->Eval.Map1Index = state; break; case GL_MAP1_NORMAL: + if (ctx->API != API_OPENGL_COMPAT) + goto invalid_enum_error; if (ctx->Eval.Map1Normal == state) return; FLUSH_VERTICES(ctx, _NEW_EVAL); ctx->Eval.Map1Normal = state; break; case GL_MAP1_TEXTURE_COORD_1: + if (ctx->API != API_OPENGL_COMPAT) + goto invalid_enum_error; if (ctx->Eval.Map1TextureCoord1 == state) return; FLUSH_VERTICES(ctx, _NEW_EVAL); ctx->Eval.Map1TextureCoord1 = state; break; case GL_MAP1_TEXTURE_COORD_2: + if (ctx->API != API_OPENGL_COMPAT) + goto invalid_enum_error; if (ctx->Eval.Map1TextureCoord2 == state) return; FLUSH_VERTICES(ctx, _NEW_EVAL); ctx->Eval.Map1TextureCoord2 = state; break; case GL_MAP1_TEXTURE_COORD_3: + if (ctx->API != API_OPENGL_COMPAT) + goto invalid_enum_error; if (ctx->Eval.Map1TextureCoord3 == state) return; FLUSH_VERTICES(ctx, _NEW_EVAL); ctx->Eval.Map1TextureCoord3 = state; break; case GL_MAP1_TEXTURE_COORD_4: + if (ctx->API != API_OPENGL_COMPAT) + goto invalid_enum_error; if (ctx->Eval.Map1TextureCoord4 == state) return; FLUSH_VERTICES(ctx, _NEW_EVAL); ctx->Eval.Map1TextureCoord4 = state; break; case GL_MAP1_VERTEX_3: + if (ctx->API != API_OPENGL_COMPAT) + goto invalid_enum_error; if (ctx->Eval.Map1Vertex3 == state) return; FLUSH_VERTICES(ctx, _NEW_EVAL); ctx->Eval.Map1Vertex3 = state; break; case GL_MAP1_VERTEX_4: + if (ctx->API != API_OPENGL_COMPAT) + goto invalid_enum_error; if (ctx->Eval.Map1Vertex4 == state) return; FLUSH_VERTICES(ctx, _NEW_EVAL); ctx->Eval.Map1Vertex4 = state; break; case GL_MAP2_COLOR_4: + if (ctx->API != API_OPENGL_COMPAT) + goto invalid_enum_error; if (ctx->Eval.Map2Color4 == state) return; FLUSH_VERTICES(ctx, _NEW_EVAL); ctx->Eval.Map2Color4 = state; break; case GL_MAP2_INDEX: + if (ctx->API != API_OPENGL_COMPAT) + goto invalid_enum_error; if (ctx->Eval.Map2Index == state) return; FLUSH_VERTICES(ctx, _NEW_EVAL); ctx->Eval.Map2Index = state; break; case GL_MAP2_NORMAL: + if (ctx->API != API_OPENGL_COMPAT) + goto invalid_enum_error; if (ctx->Eval.Map2Normal == state) return; FLUSH_VERTICES(ctx, _NEW_EVAL); ctx->Eval.Map2Normal = state; break; case GL_MAP2_TEXTURE_COORD_1: + if (ctx->API != API_OPENGL_COMPAT) + goto invalid_enum_error; if (ctx->Eval.Map2TextureCoord1 == state) return; FLUSH_VERTICES(ctx, _NEW_EVAL); ctx->Eval.Map2TextureCoord1 = state; break; case GL_MAP2_TEXTURE_COORD_2: + if (ctx->API != API_OPENGL_COMPAT) + goto invalid_enum_error; if (ctx->Eval.Map2TextureCoord2 == state) return; FLUSH_VERTICES(ctx, _NEW_EVAL); ctx->Eval.Map2TextureCoord2 = state; break; case GL_MAP2_TEXTURE_COORD_3: + if (ctx->API != API_OPENGL_COMPAT) + goto invalid_enum_error; if (ctx->Eval.Map2TextureCoord3 == state) return; FLUSH_VERTICES(ctx, _NEW_EVAL); ctx->Eval.Map2TextureCoord3 = state; break; case GL_MAP2_TEXTURE_COORD_4: + if (ctx->API != API_OPENGL_COMPAT) + goto invalid_enum_error; if (ctx->Eval.Map2TextureCoord4 == state) return; FLUSH_VERTICES(ctx, _NEW_EVAL); ctx->Eval.Map2TextureCoord4 = state; break; case GL_MAP2_VERTEX_3: + if (ctx->API != API_OPENGL_COMPAT) + goto invalid_enum_error; if (ctx->Eval.Map2Vertex3 == state) return; FLUSH_VERTICES(ctx, _NEW_EVAL); ctx->Eval.Map2Vertex3 = state; break; case GL_MAP2_VERTEX_4: + if (ctx->API != API_OPENGL_COMPAT) + goto invalid_enum_error; if (ctx->Eval.Map2Vertex4 == state) return; FLUSH_VERTICES(ctx, _NEW_EVAL); ctx->Eval.Map2Vertex4 = state; break; case GL_NORMALIZE: + if (ctx->API != API_OPENGL_COMPAT && ctx->API != API_OPENGLES) + goto invalid_enum_error; if (ctx->Transform.Normalize == state) return; FLUSH_VERTICES(ctx, _NEW_TRANSFORM); ctx->Transform.Normalize = state; break; case GL_POINT_SMOOTH: + if (ctx->API != API_OPENGL_COMPAT && ctx->API != API_OPENGLES) + goto invalid_enum_error; if (ctx->Point.SmoothFlag == state) return; FLUSH_VERTICES(ctx, _NEW_POINT); ctx->Point.SmoothFlag = state; - ctx->_TriangleCaps ^= DD_POINT_SMOOTH; break; case GL_POLYGON_SMOOTH: + if (!_mesa_is_desktop_gl(ctx)) + goto invalid_enum_error; if (ctx->Polygon.SmoothFlag == state) return; FLUSH_VERTICES(ctx, _NEW_POLYGON); ctx->Polygon.SmoothFlag = state; - ctx->_TriangleCaps ^= DD_TRI_SMOOTH; break; case GL_POLYGON_STIPPLE: + if (ctx->API != API_OPENGL_COMPAT) + goto invalid_enum_error; if (ctx->Polygon.StippleFlag == state) return; FLUSH_VERTICES(ctx, _NEW_POLYGON); ctx->Polygon.StippleFlag = state; - ctx->_TriangleCaps ^= DD_TRI_STIPPLE; break; case GL_POLYGON_OFFSET_POINT: + if (!_mesa_is_desktop_gl(ctx)) + goto invalid_enum_error; if (ctx->Polygon.OffsetPoint == state) return; FLUSH_VERTICES(ctx, _NEW_POLYGON); ctx->Polygon.OffsetPoint = state; break; case GL_POLYGON_OFFSET_LINE: + if (!_mesa_is_desktop_gl(ctx)) + goto invalid_enum_error; if (ctx->Polygon.OffsetLine == state) return; FLUSH_VERTICES(ctx, _NEW_POLYGON); ctx->Polygon.OffsetLine = state; break; case GL_POLYGON_OFFSET_FILL: - /*case GL_POLYGON_OFFSET_EXT:*/ if (ctx->Polygon.OffsetFill == state) return; FLUSH_VERTICES(ctx, _NEW_POLYGON); ctx->Polygon.OffsetFill = state; break; case GL_RESCALE_NORMAL_EXT: + if (ctx->API != API_OPENGL_COMPAT && ctx->API != API_OPENGLES) + goto invalid_enum_error; if (ctx->Transform.RescaleNormals == state) return; FLUSH_VERTICES(ctx, _NEW_TRANSFORM); ctx->Transform.RescaleNormals = state; break; case GL_SCISSOR_TEST: - if (ctx->Scissor.Enabled == state) - return; - FLUSH_VERTICES(ctx, _NEW_SCISSOR); - ctx->Scissor.Enabled = state; - break; - case GL_SHARED_TEXTURE_PALETTE_EXT: - if (ctx->Texture.SharedPalette == state) - return; - FLUSH_VERTICES(ctx, _NEW_TEXTURE); - ctx->Texture.SharedPalette = state; + { + /* Must expand glEnable to all scissors */ + GLbitfield newEnabled = + state * ((1 << ctx->Const.MaxViewports) - 1); + if (newEnabled != ctx->Scissor.EnableFlags) { + FLUSH_VERTICES(ctx, _NEW_SCISSOR); + ctx->Scissor.EnableFlags = newEnabled; + } + } break; case GL_STENCIL_TEST: if (ctx->Stencil.Enabled == state) @@ -601,69 +676,41 @@ _mesa_set_enable(struct gl_context *ctx, GLenum cap, GLboolean state) ctx->Stencil.Enabled = state; break; case GL_TEXTURE_1D: + if (ctx->API != API_OPENGL_COMPAT) + goto invalid_enum_error; if (!enable_texture(ctx, state, TEXTURE_1D_BIT)) { return; } break; case GL_TEXTURE_2D: + if (ctx->API != API_OPENGL_COMPAT && ctx->API != API_OPENGLES) + goto invalid_enum_error; if (!enable_texture(ctx, state, TEXTURE_2D_BIT)) { return; } break; case GL_TEXTURE_3D: + if (ctx->API != API_OPENGL_COMPAT && ctx->API != API_OPENGLES) + goto invalid_enum_error; if (!enable_texture(ctx, state, TEXTURE_3D_BIT)) { return; } break; - case GL_TEXTURE_GEN_Q: - { - struct gl_texture_unit *texUnit = get_texcoord_unit(ctx); - if (texUnit) { - GLuint newenabled = texUnit->TexGenEnabled & ~Q_BIT; - if (state) - newenabled |= Q_BIT; - if (texUnit->TexGenEnabled == newenabled) - return; - FLUSH_VERTICES(ctx, _NEW_TEXTURE); - texUnit->TexGenEnabled = newenabled; - } - } - break; - case GL_TEXTURE_GEN_R: - { - struct gl_texture_unit *texUnit = get_texcoord_unit(ctx); - if (texUnit) { - GLuint newenabled = texUnit->TexGenEnabled & ~R_BIT; - if (state) - newenabled |= R_BIT; - if (texUnit->TexGenEnabled == newenabled) - return; - FLUSH_VERTICES(ctx, _NEW_TEXTURE); - texUnit->TexGenEnabled = newenabled; - } - } - break; case GL_TEXTURE_GEN_S: - { - struct gl_texture_unit *texUnit = get_texcoord_unit(ctx); - if (texUnit) { - GLuint newenabled = texUnit->TexGenEnabled & ~S_BIT; - if (state) - newenabled |= S_BIT; - if (texUnit->TexGenEnabled == newenabled) - return; - FLUSH_VERTICES(ctx, _NEW_TEXTURE); - texUnit->TexGenEnabled = newenabled; - } - } - break; case GL_TEXTURE_GEN_T: + case GL_TEXTURE_GEN_R: + case GL_TEXTURE_GEN_Q: { struct gl_texture_unit *texUnit = get_texcoord_unit(ctx); + + if (ctx->API != API_OPENGL_COMPAT) + goto invalid_enum_error; + if (texUnit) { - GLuint newenabled = texUnit->TexGenEnabled & ~T_BIT; + GLbitfield coordBit = S_BIT << (cap - GL_TEXTURE_GEN_S); + GLbitfield newenabled = texUnit->TexGenEnabled & ~coordBit; if (state) - newenabled |= T_BIT; + newenabled |= coordBit; if (texUnit->TexGenEnabled == newenabled) return; FLUSH_VERTICES(ctx, _NEW_TEXTURE); @@ -672,11 +719,14 @@ _mesa_set_enable(struct gl_context *ctx, GLenum cap, GLboolean state) } break; -#if FEATURE_ES1 case GL_TEXTURE_GEN_STR_OES: /* disable S, T, and R at the same time */ { struct gl_texture_unit *texUnit = get_texcoord_unit(ctx); + + if (ctx->API != API_OPENGLES) + goto invalid_enum_error; + if (texUnit) { GLuint newenabled = texUnit->TexGenEnabled & ~STR_BITS; @@ -689,11 +739,8 @@ _mesa_set_enable(struct gl_context *ctx, GLenum cap, GLboolean state) } } break; -#endif - /* - * CLIENT STATE!!! - */ + /* client-side state */ case GL_VERTEX_ARRAY: case GL_NORMAL_ARRAY: case GL_COLOR_ARRAY: @@ -706,17 +753,10 @@ _mesa_set_enable(struct gl_context *ctx, GLenum cap, GLboolean state) client_state( ctx, cap, state ); return; - /* GL_SGI_texture_color_table */ - case GL_TEXTURE_COLOR_TABLE_SGI: - CHECK_EXTENSION(SGI_texture_color_table, cap); - if (ctx->Texture.Unit[ctx->Texture.CurrentUnit].ColorTableEnabled == state) - return; - FLUSH_VERTICES(ctx, _NEW_TEXTURE); - ctx->Texture.Unit[ctx->Texture.CurrentUnit].ColorTableEnabled = state; - break; - /* GL_ARB_texture_cube_map */ case GL_TEXTURE_CUBE_MAP_ARB: + if (ctx->API != API_OPENGL_COMPAT && ctx->API != API_OPENGLES) + goto invalid_enum_error; CHECK_EXTENSION(ARB_texture_cube_map, cap); if (!enable_texture(ctx, state, TEXTURE_CUBE_BIT)) { return; @@ -725,7 +765,8 @@ _mesa_set_enable(struct gl_context *ctx, GLenum cap, GLboolean state) /* GL_EXT_secondary_color */ case GL_COLOR_SUM_EXT: - CHECK_EXTENSION2(EXT_secondary_color, ARB_vertex_program, cap); + if (ctx->API != API_OPENGL_COMPAT) + goto invalid_enum_error; if (ctx->Fog.ColorSumEnabled == state) return; FLUSH_VERTICES(ctx, _NEW_FOG); @@ -734,11 +775,10 @@ _mesa_set_enable(struct gl_context *ctx, GLenum cap, GLboolean state) /* GL_ARB_multisample */ case GL_MULTISAMPLE_ARB: - if (ctx->Multisample.Enabled == state) - return; - FLUSH_VERTICES(ctx, _NEW_MULTISAMPLE); - ctx->Multisample.Enabled = state; - break; + if (!_mesa_is_desktop_gl(ctx) && ctx->API != API_OPENGLES) + goto invalid_enum_error; + _mesa_set_multisample(ctx, state); + return; case GL_SAMPLE_ALPHA_TO_COVERAGE_ARB: if (ctx->Multisample.SampleAlphaToCoverage == state) return; @@ -746,6 +786,8 @@ _mesa_set_enable(struct gl_context *ctx, GLenum cap, GLboolean state) ctx->Multisample.SampleAlphaToCoverage = state; break; case GL_SAMPLE_ALPHA_TO_ONE_ARB: + if (!_mesa_is_desktop_gl(ctx) && ctx->API != API_OPENGLES) + goto invalid_enum_error; if (ctx->Multisample.SampleAlphaToOne == state) return; FLUSH_VERTICES(ctx, _NEW_MULTISAMPLE); @@ -758,15 +800,29 @@ _mesa_set_enable(struct gl_context *ctx, GLenum cap, GLboolean state) ctx->Multisample.SampleCoverage = state; break; case GL_SAMPLE_COVERAGE_INVERT_ARB: + if (!_mesa_is_desktop_gl(ctx)) + goto invalid_enum_error; if (ctx->Multisample.SampleCoverageInvert == state) return; FLUSH_VERTICES(ctx, _NEW_MULTISAMPLE); ctx->Multisample.SampleCoverageInvert = state; break; + /* GL_ARB_sample_shading */ + case GL_SAMPLE_SHADING: + if (!_mesa_is_desktop_gl(ctx)) + goto invalid_enum_error; + CHECK_EXTENSION(ARB_sample_shading, cap); + if (ctx->Multisample.SampleShading == state) + return; + FLUSH_VERTICES(ctx, _NEW_MULTISAMPLE); + ctx->Multisample.SampleShading = state; + break; + /* GL_IBM_rasterpos_clip */ case GL_RASTER_POSITION_UNCLIPPED_IBM: - CHECK_EXTENSION(IBM_rasterpos_clip, cap); + if (ctx->API != API_OPENGL_COMPAT) + goto invalid_enum_error; if (ctx->Transform.RasterPositionUnclipped == state) return; FLUSH_VERTICES(ctx, _NEW_TRANSFORM); @@ -775,6 +831,8 @@ _mesa_set_enable(struct gl_context *ctx, GLenum cap, GLboolean state) /* GL_NV_point_sprite */ case GL_POINT_SPRITE_NV: + if (ctx->API != API_OPENGL_COMPAT && ctx->API != API_OPENGLES) + goto invalid_enum_error; CHECK_EXTENSION2(NV_point_sprite, ARB_point_sprite, cap); if (ctx->Point.PointSprite == state) return; @@ -782,90 +840,41 @@ _mesa_set_enable(struct gl_context *ctx, GLenum cap, GLboolean state) ctx->Point.PointSprite = state; break; -#if FEATURE_NV_vertex_program || FEATURE_ARB_vertex_program case GL_VERTEX_PROGRAM_ARB: - CHECK_EXTENSION2(ARB_vertex_program, NV_vertex_program, cap); + if (ctx->API != API_OPENGL_COMPAT) + goto invalid_enum_error; + CHECK_EXTENSION(ARB_vertex_program, cap); if (ctx->VertexProgram.Enabled == state) return; FLUSH_VERTICES(ctx, _NEW_PROGRAM); ctx->VertexProgram.Enabled = state; break; case GL_VERTEX_PROGRAM_POINT_SIZE_ARB: - CHECK_EXTENSION2(ARB_vertex_program, NV_vertex_program, cap); + /* This was added with ARB_vertex_program, but it is also used with + * GLSL vertex shaders on desktop. + */ + if (!_mesa_is_desktop_gl(ctx)) + goto invalid_enum_error; + CHECK_EXTENSION(ARB_vertex_program, cap); if (ctx->VertexProgram.PointSizeEnabled == state) return; FLUSH_VERTICES(ctx, _NEW_PROGRAM); ctx->VertexProgram.PointSizeEnabled = state; break; case GL_VERTEX_PROGRAM_TWO_SIDE_ARB: - CHECK_EXTENSION2(ARB_vertex_program, NV_vertex_program, cap); + if (ctx->API != API_OPENGL_COMPAT) + goto invalid_enum_error; + CHECK_EXTENSION(ARB_vertex_program, cap); if (ctx->VertexProgram.TwoSideEnabled == state) return; FLUSH_VERTICES(ctx, _NEW_PROGRAM); ctx->VertexProgram.TwoSideEnabled = state; break; -#endif -#if FEATURE_NV_vertex_program - case GL_MAP1_VERTEX_ATTRIB0_4_NV: - case GL_MAP1_VERTEX_ATTRIB1_4_NV: - case GL_MAP1_VERTEX_ATTRIB2_4_NV: - case GL_MAP1_VERTEX_ATTRIB3_4_NV: - case GL_MAP1_VERTEX_ATTRIB4_4_NV: - case GL_MAP1_VERTEX_ATTRIB5_4_NV: - case GL_MAP1_VERTEX_ATTRIB6_4_NV: - case GL_MAP1_VERTEX_ATTRIB7_4_NV: - case GL_MAP1_VERTEX_ATTRIB8_4_NV: - case GL_MAP1_VERTEX_ATTRIB9_4_NV: - case GL_MAP1_VERTEX_ATTRIB10_4_NV: - case GL_MAP1_VERTEX_ATTRIB11_4_NV: - case GL_MAP1_VERTEX_ATTRIB12_4_NV: - case GL_MAP1_VERTEX_ATTRIB13_4_NV: - case GL_MAP1_VERTEX_ATTRIB14_4_NV: - case GL_MAP1_VERTEX_ATTRIB15_4_NV: - CHECK_EXTENSION(NV_vertex_program, cap); - { - const GLuint map = (GLuint) (cap - GL_MAP1_VERTEX_ATTRIB0_4_NV); - FLUSH_VERTICES(ctx, _NEW_EVAL); - ctx->Eval.Map1Attrib[map] = state; - } - break; - case GL_MAP2_VERTEX_ATTRIB0_4_NV: - case GL_MAP2_VERTEX_ATTRIB1_4_NV: - case GL_MAP2_VERTEX_ATTRIB2_4_NV: - case GL_MAP2_VERTEX_ATTRIB3_4_NV: - case GL_MAP2_VERTEX_ATTRIB4_4_NV: - case GL_MAP2_VERTEX_ATTRIB5_4_NV: - case GL_MAP2_VERTEX_ATTRIB6_4_NV: - case GL_MAP2_VERTEX_ATTRIB7_4_NV: - case GL_MAP2_VERTEX_ATTRIB8_4_NV: - case GL_MAP2_VERTEX_ATTRIB9_4_NV: - case GL_MAP2_VERTEX_ATTRIB10_4_NV: - case GL_MAP2_VERTEX_ATTRIB11_4_NV: - case GL_MAP2_VERTEX_ATTRIB12_4_NV: - case GL_MAP2_VERTEX_ATTRIB13_4_NV: - case GL_MAP2_VERTEX_ATTRIB14_4_NV: - case GL_MAP2_VERTEX_ATTRIB15_4_NV: - CHECK_EXTENSION(NV_vertex_program, cap); - { - const GLuint map = (GLuint) (cap - GL_MAP2_VERTEX_ATTRIB0_4_NV); - FLUSH_VERTICES(ctx, _NEW_EVAL); - ctx->Eval.Map2Attrib[map] = state; - } - break; -#endif /* FEATURE_NV_vertex_program */ - -#if FEATURE_NV_fragment_program - case GL_FRAGMENT_PROGRAM_NV: - CHECK_EXTENSION(NV_fragment_program, cap); - if (ctx->FragmentProgram.Enabled == state) - return; - FLUSH_VERTICES(ctx, _NEW_PROGRAM); - ctx->FragmentProgram.Enabled = state; - break; -#endif /* FEATURE_NV_fragment_program */ /* GL_NV_texture_rectangle */ case GL_TEXTURE_RECTANGLE_NV: + if (ctx->API != API_OPENGL_COMPAT) + goto invalid_enum_error; CHECK_EXTENSION(NV_texture_rectangle, cap); if (!enable_texture(ctx, state, TEXTURE_RECT_BIT)) { return; @@ -874,6 +883,8 @@ _mesa_set_enable(struct gl_context *ctx, GLenum cap, GLboolean state) /* GL_EXT_stencil_two_side */ case GL_STENCIL_TEST_TWO_SIDE_EXT: + if (ctx->API != API_OPENGL_COMPAT) + goto invalid_enum_error; CHECK_EXTENSION(EXT_stencil_two_side, cap); if (ctx->Stencil.TestTwoSide == state) return; @@ -881,25 +892,25 @@ _mesa_set_enable(struct gl_context *ctx, GLenum cap, GLboolean state) ctx->Stencil.TestTwoSide = state; if (state) { ctx->Stencil._BackFace = 2; - ctx->_TriangleCaps |= DD_TRI_TWOSTENCIL; } else { ctx->Stencil._BackFace = 1; - ctx->_TriangleCaps &= ~DD_TRI_TWOSTENCIL; } break; -#if FEATURE_ARB_fragment_program case GL_FRAGMENT_PROGRAM_ARB: + if (ctx->API != API_OPENGL_COMPAT) + goto invalid_enum_error; CHECK_EXTENSION(ARB_fragment_program, cap); if (ctx->FragmentProgram.Enabled == state) return; FLUSH_VERTICES(ctx, _NEW_PROGRAM); ctx->FragmentProgram.Enabled = state; break; -#endif /* FEATURE_ARB_fragment_program */ /* GL_EXT_depth_bounds_test */ case GL_DEPTH_BOUNDS_TEST_EXT: + if (!_mesa_is_desktop_gl(ctx)) + goto invalid_enum_error; CHECK_EXTENSION(EXT_depth_bounds_test, cap); if (ctx->Depth.BoundsTest == state) return; @@ -908,71 +919,98 @@ _mesa_set_enable(struct gl_context *ctx, GLenum cap, GLboolean state) break; case GL_DEPTH_CLAMP: + if (!_mesa_is_desktop_gl(ctx)) + goto invalid_enum_error; + CHECK_EXTENSION(ARB_depth_clamp, cap); if (ctx->Transform.DepthClamp == state) return; - CHECK_EXTENSION(ARB_depth_clamp, cap); FLUSH_VERTICES(ctx, _NEW_TRANSFORM); ctx->Transform.DepthClamp = state; break; -#if FEATURE_ATI_fragment_shader case GL_FRAGMENT_SHADER_ATI: + if (ctx->API != API_OPENGL_COMPAT) + goto invalid_enum_error; CHECK_EXTENSION(ATI_fragment_shader, cap); if (ctx->ATIFragmentShader.Enabled == state) return; FLUSH_VERTICES(ctx, _NEW_PROGRAM); ctx->ATIFragmentShader.Enabled = state; break; -#endif - - /* GL_MESA_texture_array */ - case GL_TEXTURE_1D_ARRAY_EXT: - CHECK_EXTENSION(MESA_texture_array, cap); - if (!enable_texture(ctx, state, TEXTURE_1D_ARRAY_BIT)) { - return; - } - break; - - case GL_TEXTURE_2D_ARRAY_EXT: - CHECK_EXTENSION(MESA_texture_array, cap); - if (!enable_texture(ctx, state, TEXTURE_2D_ARRAY_BIT)) { - return; - } - break; case GL_TEXTURE_CUBE_MAP_SEAMLESS: + if (!_mesa_is_desktop_gl(ctx)) + goto invalid_enum_error; CHECK_EXTENSION(ARB_seamless_cube_map, cap); - ctx->Texture.CubeMapSeamless = state; + if (ctx->Texture.CubeMapSeamless != state) { + FLUSH_VERTICES(ctx, _NEW_TEXTURE); + ctx->Texture.CubeMapSeamless = state; + } break; -#if FEATURE_EXT_transform_feedback case GL_RASTERIZER_DISCARD: + if (!_mesa_is_desktop_gl(ctx) && !_mesa_is_gles3(ctx)) + goto invalid_enum_error; CHECK_EXTENSION(EXT_transform_feedback, cap); - if (ctx->TransformFeedback.RasterDiscard != state) { - ctx->TransformFeedback.RasterDiscard = state; - FLUSH_VERTICES(ctx, _NEW_TRANSFORM); + if (ctx->RasterDiscard != state) { + FLUSH_VERTICES(ctx, 0); + ctx->NewDriverState |= ctx->DriverFlags.NewRasterizerDiscard; + ctx->RasterDiscard = state; } break; -#endif /* GL 3.1 primitive restart. Note: this enum is different from * GL_PRIMITIVE_RESTART_NV (which is client state). */ case GL_PRIMITIVE_RESTART: - if (ctx->VersionMajor * 10 + ctx->VersionMinor < 31) { + if (!_mesa_is_desktop_gl(ctx) || ctx->Version < 31) { goto invalid_enum_error; } if (ctx->Array.PrimitiveRestart != state) { FLUSH_VERTICES(ctx, _NEW_TRANSFORM); ctx->Array.PrimitiveRestart = state; + update_derived_primitive_restart_state(ctx); + } + break; + + case GL_PRIMITIVE_RESTART_FIXED_INDEX: + if (!_mesa_is_gles3(ctx) && !ctx->Extensions.ARB_ES3_compatibility) + goto invalid_enum_error; + if (ctx->Array.PrimitiveRestartFixedIndex != state) { + FLUSH_VERTICES(ctx, _NEW_TRANSFORM); + ctx->Array.PrimitiveRestartFixedIndex = state; + update_derived_primitive_restart_state(ctx); } break; /* GL3.0 - GL_framebuffer_sRGB */ case GL_FRAMEBUFFER_SRGB_EXT: - CHECK_EXTENSION(EXT_framebuffer_sRGB, cap); - ctx->Color.sRGBEnabled = state; - break; + if (!_mesa_is_desktop_gl(ctx)) + goto invalid_enum_error; + CHECK_EXTENSION(EXT_framebuffer_sRGB, cap); + _mesa_set_framebuffer_srgb(ctx, state); + return; + + /* GL_OES_EGL_image_external */ + case GL_TEXTURE_EXTERNAL_OES: + if (!_mesa_is_gles(ctx)) + goto invalid_enum_error; + CHECK_EXTENSION(OES_EGL_image_external, cap); + if (!enable_texture(ctx, state, TEXTURE_EXTERNAL_BIT)) { + return; + } + break; + + /* ARB_texture_multisample */ + case GL_SAMPLE_MASK: + if (!_mesa_is_desktop_gl(ctx)) + goto invalid_enum_error; + CHECK_EXTENSION(ARB_texture_multisample, cap); + if (ctx->Multisample.SampleMask == state) + return; + FLUSH_VERTICES(ctx, _NEW_MULTISAMPLE); + ctx->Multisample.SampleMask = state; + break; default: goto invalid_enum_error; @@ -985,8 +1023,8 @@ _mesa_set_enable(struct gl_context *ctx, GLenum cap, GLboolean state) return; invalid_enum_error: - _mesa_error(ctx, GL_INVALID_ENUM, "gl%s(0x%x)", - state ? "Enable" : "Disable", cap); + _mesa_error(ctx, GL_INVALID_ENUM, "gl%s(%s)", + state ? "Enable" : "Disable", _mesa_lookup_enum_by_nr(cap)); } @@ -998,7 +1036,6 @@ void GLAPIENTRY _mesa_Enable( GLenum cap ) { GET_CURRENT_CONTEXT(ctx); - ASSERT_OUTSIDE_BEGIN_END(ctx); _mesa_set_enable( ctx, cap, GL_TRUE ); } @@ -1012,7 +1049,6 @@ void GLAPIENTRY _mesa_Disable( GLenum cap ) { GET_CURRENT_CONTEXT(ctx); - ASSERT_OUTSIDE_BEGIN_END(ctx); _mesa_set_enable( ctx, cap, GL_FALSE ); } @@ -1023,7 +1059,8 @@ _mesa_Disable( GLenum cap ) * Enable/disable an indexed state var. */ void -_mesa_set_enablei(struct gl_context *ctx, GLenum cap, GLuint index, GLboolean state) +_mesa_set_enablei(struct gl_context *ctx, GLenum cap, + GLuint index, GLboolean state) { ASSERT(state == 0 || state == 1); switch (cap) { @@ -1044,6 +1081,20 @@ _mesa_set_enablei(struct gl_context *ctx, GLenum cap, GLuint index, GLboolean st ctx->Color.BlendEnabled &= ~(1 << index); } break; + case GL_SCISSOR_TEST: + if (index >= ctx->Const.MaxViewports) { + _mesa_error(ctx, GL_INVALID_VALUE, "%s(index=%u)", + state ? "glEnablei" : "glDisablei", index); + return; + } + if (((ctx->Scissor.EnableFlags >> index) & 1) != state) { + FLUSH_VERTICES(ctx, _NEW_SCISSOR); + if (state) + ctx->Scissor.EnableFlags |= (1 << index); + else + ctx->Scissor.EnableFlags &= ~(1 << index); + } + break; default: goto invalid_enum_error; } @@ -1057,27 +1108,26 @@ invalid_enum_error: void GLAPIENTRY -_mesa_DisableIndexed( GLenum cap, GLuint index ) +_mesa_Disablei( GLenum cap, GLuint index ) { GET_CURRENT_CONTEXT(ctx); - ASSERT_OUTSIDE_BEGIN_END(ctx); _mesa_set_enablei(ctx, cap, index, GL_FALSE); } void GLAPIENTRY -_mesa_EnableIndexed( GLenum cap, GLuint index ) +_mesa_Enablei( GLenum cap, GLuint index ) { GET_CURRENT_CONTEXT(ctx); - ASSERT_OUTSIDE_BEGIN_END(ctx); _mesa_set_enablei(ctx, cap, index, GL_TRUE); } GLboolean GLAPIENTRY -_mesa_IsEnabledIndexed( GLenum cap, GLuint index ) +_mesa_IsEnabledi( GLenum cap, GLuint index ) { GET_CURRENT_CONTEXT(ctx); + ASSERT_OUTSIDE_BEGIN_END_WITH_RETVAL(ctx, 0); switch (cap) { case GL_BLEND: if (index >= ctx->Const.MaxDrawBuffers) { @@ -1086,6 +1136,13 @@ _mesa_IsEnabledIndexed( GLenum cap, GLuint index ) return GL_FALSE; } return (ctx->Color.BlendEnabled >> index) & 1; + case GL_SCISSOR_TEST: + if (index >= ctx->Const.MaxViewports) { + _mesa_error(ctx, GL_INVALID_VALUE, "glIsEnabledIndexed(index=%u)", + index); + return GL_FALSE; + } + return (ctx->Scissor.EnableFlags >> index) & 1; default: _mesa_error(ctx, GL_INVALID_ENUM, "glIsEnabledIndexed(cap=%s)", _mesa_lookup_enum_by_nr(cap)); @@ -1134,31 +1191,59 @@ GLboolean GLAPIENTRY _mesa_IsEnabled( GLenum cap ) { GET_CURRENT_CONTEXT(ctx); + ASSERT_OUTSIDE_BEGIN_END_WITH_RETVAL(ctx, 0); + switch (cap) { case GL_ALPHA_TEST: + if (ctx->API != API_OPENGL_COMPAT && ctx->API != API_OPENGLES) + goto invalid_enum_error; return ctx->Color.AlphaEnabled; case GL_AUTO_NORMAL: + if (ctx->API != API_OPENGL_COMPAT) + goto invalid_enum_error; return ctx->Eval.AutoNormal; case GL_BLEND: return ctx->Color.BlendEnabled & 1; /* return state for buffer[0] */ - case GL_CLIP_PLANE0: - case GL_CLIP_PLANE1: - case GL_CLIP_PLANE2: - case GL_CLIP_PLANE3: - case GL_CLIP_PLANE4: - case GL_CLIP_PLANE5: - return (ctx->Transform.ClipPlanesEnabled >> (cap - GL_CLIP_PLANE0)) & 1; + case GL_CLIP_DISTANCE0: + case GL_CLIP_DISTANCE1: + case GL_CLIP_DISTANCE2: + case GL_CLIP_DISTANCE3: + case GL_CLIP_DISTANCE4: + case GL_CLIP_DISTANCE5: + case GL_CLIP_DISTANCE6: + case GL_CLIP_DISTANCE7: { + const GLuint p = cap - GL_CLIP_DISTANCE0; + + if (p >= ctx->Const.MaxClipPlanes) + goto invalid_enum_error; + + return (ctx->Transform.ClipPlanesEnabled >> p) & 1; + } case GL_COLOR_MATERIAL: + if (ctx->API != API_OPENGL_COMPAT && ctx->API != API_OPENGLES) + goto invalid_enum_error; return ctx->Light.ColorMaterialEnabled; case GL_CULL_FACE: return ctx->Polygon.CullFlag; + case GL_DEBUG_OUTPUT: + if (!_mesa_is_desktop_gl(ctx)) + goto invalid_enum_error; + return ctx->Debug.DebugOutput; + case GL_DEBUG_OUTPUT_SYNCHRONOUS_ARB: + if (!_mesa_is_desktop_gl(ctx)) + goto invalid_enum_error; + return ctx->Debug.SyncOutput; case GL_DEPTH_TEST: return ctx->Depth.Test; case GL_DITHER: return ctx->Color.DitherFlag; case GL_FOG: + if (ctx->API != API_OPENGL_COMPAT && ctx->API != API_OPENGLES) + goto invalid_enum_error; return ctx->Fog.Enabled; case GL_LIGHTING: + if (ctx->API != API_OPENGL_COMPAT && ctx->API != API_OPENGLES) + goto invalid_enum_error; return ctx->Light.Enabled; case GL_LIGHT0: case GL_LIGHT1: @@ -1168,152 +1253,211 @@ _mesa_IsEnabled( GLenum cap ) case GL_LIGHT5: case GL_LIGHT6: case GL_LIGHT7: + if (ctx->API != API_OPENGL_COMPAT && ctx->API != API_OPENGLES) + goto invalid_enum_error; return ctx->Light.Light[cap-GL_LIGHT0].Enabled; case GL_LINE_SMOOTH: + if (!_mesa_is_desktop_gl(ctx) && ctx->API != API_OPENGLES) + goto invalid_enum_error; return ctx->Line.SmoothFlag; case GL_LINE_STIPPLE: + if (ctx->API != API_OPENGL_COMPAT) + goto invalid_enum_error; return ctx->Line.StippleFlag; case GL_INDEX_LOGIC_OP: + if (ctx->API != API_OPENGL_COMPAT) + goto invalid_enum_error; return ctx->Color.IndexLogicOpEnabled; case GL_COLOR_LOGIC_OP: + if (!_mesa_is_desktop_gl(ctx) && ctx->API != API_OPENGLES) + goto invalid_enum_error; return ctx->Color.ColorLogicOpEnabled; case GL_MAP1_COLOR_4: + if (ctx->API != API_OPENGL_COMPAT) + goto invalid_enum_error; return ctx->Eval.Map1Color4; case GL_MAP1_INDEX: + if (ctx->API != API_OPENGL_COMPAT) + goto invalid_enum_error; return ctx->Eval.Map1Index; case GL_MAP1_NORMAL: + if (ctx->API != API_OPENGL_COMPAT) + goto invalid_enum_error; return ctx->Eval.Map1Normal; case GL_MAP1_TEXTURE_COORD_1: + if (ctx->API != API_OPENGL_COMPAT) + goto invalid_enum_error; return ctx->Eval.Map1TextureCoord1; case GL_MAP1_TEXTURE_COORD_2: + if (ctx->API != API_OPENGL_COMPAT) + goto invalid_enum_error; return ctx->Eval.Map1TextureCoord2; case GL_MAP1_TEXTURE_COORD_3: + if (ctx->API != API_OPENGL_COMPAT) + goto invalid_enum_error; return ctx->Eval.Map1TextureCoord3; case GL_MAP1_TEXTURE_COORD_4: + if (ctx->API != API_OPENGL_COMPAT) + goto invalid_enum_error; return ctx->Eval.Map1TextureCoord4; case GL_MAP1_VERTEX_3: + if (ctx->API != API_OPENGL_COMPAT) + goto invalid_enum_error; return ctx->Eval.Map1Vertex3; case GL_MAP1_VERTEX_4: + if (ctx->API != API_OPENGL_COMPAT) + goto invalid_enum_error; return ctx->Eval.Map1Vertex4; case GL_MAP2_COLOR_4: + if (ctx->API != API_OPENGL_COMPAT) + goto invalid_enum_error; return ctx->Eval.Map2Color4; case GL_MAP2_INDEX: + if (ctx->API != API_OPENGL_COMPAT) + goto invalid_enum_error; return ctx->Eval.Map2Index; case GL_MAP2_NORMAL: + if (ctx->API != API_OPENGL_COMPAT) + goto invalid_enum_error; return ctx->Eval.Map2Normal; case GL_MAP2_TEXTURE_COORD_1: + if (ctx->API != API_OPENGL_COMPAT) + goto invalid_enum_error; return ctx->Eval.Map2TextureCoord1; case GL_MAP2_TEXTURE_COORD_2: + if (ctx->API != API_OPENGL_COMPAT) + goto invalid_enum_error; return ctx->Eval.Map2TextureCoord2; case GL_MAP2_TEXTURE_COORD_3: + if (ctx->API != API_OPENGL_COMPAT) + goto invalid_enum_error; return ctx->Eval.Map2TextureCoord3; case GL_MAP2_TEXTURE_COORD_4: + if (ctx->API != API_OPENGL_COMPAT) + goto invalid_enum_error; return ctx->Eval.Map2TextureCoord4; case GL_MAP2_VERTEX_3: + if (ctx->API != API_OPENGL_COMPAT) + goto invalid_enum_error; return ctx->Eval.Map2Vertex3; case GL_MAP2_VERTEX_4: + if (ctx->API != API_OPENGL_COMPAT) + goto invalid_enum_error; return ctx->Eval.Map2Vertex4; case GL_NORMALIZE: + if (ctx->API != API_OPENGL_COMPAT && ctx->API != API_OPENGLES) + goto invalid_enum_error; return ctx->Transform.Normalize; case GL_POINT_SMOOTH: + if (ctx->API != API_OPENGL_COMPAT && ctx->API != API_OPENGLES) + goto invalid_enum_error; return ctx->Point.SmoothFlag; case GL_POLYGON_SMOOTH: + if (!_mesa_is_desktop_gl(ctx)) + goto invalid_enum_error; return ctx->Polygon.SmoothFlag; case GL_POLYGON_STIPPLE: + if (ctx->API != API_OPENGL_COMPAT) + goto invalid_enum_error; return ctx->Polygon.StippleFlag; case GL_POLYGON_OFFSET_POINT: + if (!_mesa_is_desktop_gl(ctx)) + goto invalid_enum_error; return ctx->Polygon.OffsetPoint; case GL_POLYGON_OFFSET_LINE: + if (!_mesa_is_desktop_gl(ctx)) + goto invalid_enum_error; return ctx->Polygon.OffsetLine; case GL_POLYGON_OFFSET_FILL: - /*case GL_POLYGON_OFFSET_EXT:*/ return ctx->Polygon.OffsetFill; case GL_RESCALE_NORMAL_EXT: + if (ctx->API != API_OPENGL_COMPAT && ctx->API != API_OPENGLES) + goto invalid_enum_error; return ctx->Transform.RescaleNormals; case GL_SCISSOR_TEST: - return ctx->Scissor.Enabled; - case GL_SHARED_TEXTURE_PALETTE_EXT: - return ctx->Texture.SharedPalette; + return ctx->Scissor.EnableFlags & 1; /* return state for index 0 */ case GL_STENCIL_TEST: return ctx->Stencil.Enabled; case GL_TEXTURE_1D: + if (ctx->API != API_OPENGL_COMPAT) + goto invalid_enum_error; return is_texture_enabled(ctx, TEXTURE_1D_BIT); case GL_TEXTURE_2D: + if (ctx->API != API_OPENGL_COMPAT && ctx->API != API_OPENGLES) + goto invalid_enum_error; return is_texture_enabled(ctx, TEXTURE_2D_BIT); case GL_TEXTURE_3D: + if (ctx->API != API_OPENGL_COMPAT && ctx->API != API_OPENGLES) + goto invalid_enum_error; return is_texture_enabled(ctx, TEXTURE_3D_BIT); - case GL_TEXTURE_GEN_Q: - { - const struct gl_texture_unit *texUnit = get_texcoord_unit(ctx); - if (texUnit) { - return (texUnit->TexGenEnabled & Q_BIT) ? GL_TRUE : GL_FALSE; - } - } - return GL_FALSE; - case GL_TEXTURE_GEN_R: - { - const struct gl_texture_unit *texUnit = get_texcoord_unit(ctx); - if (texUnit) { - return (texUnit->TexGenEnabled & R_BIT) ? GL_TRUE : GL_FALSE; - } - } - return GL_FALSE; case GL_TEXTURE_GEN_S: - { - const struct gl_texture_unit *texUnit = get_texcoord_unit(ctx); - if (texUnit) { - return (texUnit->TexGenEnabled & S_BIT) ? GL_TRUE : GL_FALSE; - } - } - return GL_FALSE; case GL_TEXTURE_GEN_T: + case GL_TEXTURE_GEN_R: + case GL_TEXTURE_GEN_Q: { const struct gl_texture_unit *texUnit = get_texcoord_unit(ctx); + + if (ctx->API != API_OPENGL_COMPAT) + goto invalid_enum_error; + if (texUnit) { - return (texUnit->TexGenEnabled & T_BIT) ? GL_TRUE : GL_FALSE; + GLbitfield coordBit = S_BIT << (cap - GL_TEXTURE_GEN_S); + return (texUnit->TexGenEnabled & coordBit) ? GL_TRUE : GL_FALSE; } } return GL_FALSE; -#if FEATURE_ES1 case GL_TEXTURE_GEN_STR_OES: { const struct gl_texture_unit *texUnit = get_texcoord_unit(ctx); + + if (ctx->API != API_OPENGLES) + goto invalid_enum_error; + if (texUnit) { - return (texUnit->TexGenEnabled & STR_BITS) == STR_BITS ? GL_TRUE : GL_FALSE; + return (texUnit->TexGenEnabled & STR_BITS) == STR_BITS + ? GL_TRUE : GL_FALSE; } } -#endif - /* - * CLIENT STATE!!! - */ + /* client-side state */ case GL_VERTEX_ARRAY: - return (ctx->Array.ArrayObj->Vertex.Enabled != 0); + if (ctx->API != API_OPENGL_COMPAT && ctx->API != API_OPENGLES) + goto invalid_enum_error; + return ctx->Array.VAO->VertexAttrib[VERT_ATTRIB_POS].Enabled; case GL_NORMAL_ARRAY: - return (ctx->Array.ArrayObj->Normal.Enabled != 0); + if (ctx->API != API_OPENGL_COMPAT && ctx->API != API_OPENGLES) + goto invalid_enum_error; + return ctx->Array.VAO->VertexAttrib[VERT_ATTRIB_NORMAL].Enabled; case GL_COLOR_ARRAY: - return (ctx->Array.ArrayObj->Color.Enabled != 0); + if (ctx->API != API_OPENGL_COMPAT && ctx->API != API_OPENGLES) + goto invalid_enum_error; + return ctx->Array.VAO->VertexAttrib[VERT_ATTRIB_COLOR0].Enabled; case GL_INDEX_ARRAY: - return (ctx->Array.ArrayObj->Index.Enabled != 0); + if (ctx->API != API_OPENGL_COMPAT) + goto invalid_enum_error; + return ctx->Array.VAO-> + VertexAttrib[VERT_ATTRIB_COLOR_INDEX].Enabled; case GL_TEXTURE_COORD_ARRAY: - return (ctx->Array.ArrayObj->TexCoord[ctx->Array.ActiveTexture].Enabled != 0); + if (ctx->API != API_OPENGL_COMPAT && ctx->API != API_OPENGLES) + goto invalid_enum_error; + return ctx->Array.VAO-> + VertexAttrib[VERT_ATTRIB_TEX(ctx->Array.ActiveTexture)].Enabled; case GL_EDGE_FLAG_ARRAY: - return (ctx->Array.ArrayObj->EdgeFlag.Enabled != 0); + if (ctx->API != API_OPENGL_COMPAT) + goto invalid_enum_error; + return ctx->Array.VAO->VertexAttrib[VERT_ATTRIB_EDGEFLAG].Enabled; case GL_FOG_COORDINATE_ARRAY_EXT: - CHECK_EXTENSION(EXT_fog_coord); - return (ctx->Array.ArrayObj->FogCoord.Enabled != 0); + if (ctx->API != API_OPENGL_COMPAT) + goto invalid_enum_error; + return ctx->Array.VAO->VertexAttrib[VERT_ATTRIB_FOG].Enabled; case GL_SECONDARY_COLOR_ARRAY_EXT: - CHECK_EXTENSION(EXT_secondary_color); - return (ctx->Array.ArrayObj->SecondaryColor.Enabled != 0); -#if FEATURE_point_size_array + if (ctx->API != API_OPENGL_COMPAT) + goto invalid_enum_error; + return ctx->Array.VAO->VertexAttrib[VERT_ATTRIB_COLOR1].Enabled; case GL_POINT_SIZE_ARRAY_OES: - return (ctx->Array.ArrayObj->PointSize.Enabled != 0); -#endif - - /* GL_SGI_texture_color_table */ - case GL_TEXTURE_COLOR_TABLE_SGI: - CHECK_EXTENSION(SGI_texture_color_table); - return ctx->Texture.Unit[ctx->Texture.CurrentUnit].ColorTableEnabled; + if (ctx->API != API_OPENGLES) + goto invalid_enum_error; + return ctx->Array.VAO->VertexAttrib[VERT_ATTRIB_POINT_SIZE].Enabled; /* GL_ARB_texture_cube_map */ case GL_TEXTURE_CUBE_MAP_ARB: @@ -1322,175 +1466,159 @@ _mesa_IsEnabled( GLenum cap ) /* GL_EXT_secondary_color */ case GL_COLOR_SUM_EXT: - CHECK_EXTENSION2(EXT_secondary_color, ARB_vertex_program); + if (ctx->API != API_OPENGL_COMPAT) + goto invalid_enum_error; return ctx->Fog.ColorSumEnabled; /* GL_ARB_multisample */ case GL_MULTISAMPLE_ARB: + if (!_mesa_is_desktop_gl(ctx) && ctx->API != API_OPENGLES) + goto invalid_enum_error; return ctx->Multisample.Enabled; case GL_SAMPLE_ALPHA_TO_COVERAGE_ARB: return ctx->Multisample.SampleAlphaToCoverage; case GL_SAMPLE_ALPHA_TO_ONE_ARB: + if (!_mesa_is_desktop_gl(ctx) && ctx->API != API_OPENGLES) + goto invalid_enum_error; return ctx->Multisample.SampleAlphaToOne; case GL_SAMPLE_COVERAGE_ARB: return ctx->Multisample.SampleCoverage; case GL_SAMPLE_COVERAGE_INVERT_ARB: + if (!_mesa_is_desktop_gl(ctx)) + goto invalid_enum_error; return ctx->Multisample.SampleCoverageInvert; /* GL_IBM_rasterpos_clip */ case GL_RASTER_POSITION_UNCLIPPED_IBM: - CHECK_EXTENSION(IBM_rasterpos_clip); + if (ctx->API != API_OPENGL_COMPAT) + goto invalid_enum_error; return ctx->Transform.RasterPositionUnclipped; /* GL_NV_point_sprite */ case GL_POINT_SPRITE_NV: + if (ctx->API != API_OPENGL_COMPAT && ctx->API != API_OPENGLES) + goto invalid_enum_error; CHECK_EXTENSION2(NV_point_sprite, ARB_point_sprite) return ctx->Point.PointSprite; -#if FEATURE_NV_vertex_program || FEATURE_ARB_vertex_program case GL_VERTEX_PROGRAM_ARB: - CHECK_EXTENSION2(ARB_vertex_program, NV_vertex_program); + if (ctx->API != API_OPENGL_COMPAT) + goto invalid_enum_error; + CHECK_EXTENSION(ARB_vertex_program); return ctx->VertexProgram.Enabled; case GL_VERTEX_PROGRAM_POINT_SIZE_ARB: - CHECK_EXTENSION2(ARB_vertex_program, NV_vertex_program); + /* This was added with ARB_vertex_program, but it is also used with + * GLSL vertex shaders on desktop. + */ + if (!_mesa_is_desktop_gl(ctx)) + goto invalid_enum_error; + CHECK_EXTENSION(ARB_vertex_program); return ctx->VertexProgram.PointSizeEnabled; case GL_VERTEX_PROGRAM_TWO_SIDE_ARB: - CHECK_EXTENSION2(ARB_vertex_program, NV_vertex_program); + if (ctx->API != API_OPENGL_COMPAT) + goto invalid_enum_error; + CHECK_EXTENSION(ARB_vertex_program); return ctx->VertexProgram.TwoSideEnabled; -#endif -#if FEATURE_NV_vertex_program - case GL_VERTEX_ATTRIB_ARRAY0_NV: - case GL_VERTEX_ATTRIB_ARRAY1_NV: - case GL_VERTEX_ATTRIB_ARRAY2_NV: - case GL_VERTEX_ATTRIB_ARRAY3_NV: - case GL_VERTEX_ATTRIB_ARRAY4_NV: - case GL_VERTEX_ATTRIB_ARRAY5_NV: - case GL_VERTEX_ATTRIB_ARRAY6_NV: - case GL_VERTEX_ATTRIB_ARRAY7_NV: - case GL_VERTEX_ATTRIB_ARRAY8_NV: - case GL_VERTEX_ATTRIB_ARRAY9_NV: - case GL_VERTEX_ATTRIB_ARRAY10_NV: - case GL_VERTEX_ATTRIB_ARRAY11_NV: - case GL_VERTEX_ATTRIB_ARRAY12_NV: - case GL_VERTEX_ATTRIB_ARRAY13_NV: - case GL_VERTEX_ATTRIB_ARRAY14_NV: - case GL_VERTEX_ATTRIB_ARRAY15_NV: - 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: - case GL_MAP1_VERTEX_ATTRIB1_4_NV: - case GL_MAP1_VERTEX_ATTRIB2_4_NV: - case GL_MAP1_VERTEX_ATTRIB3_4_NV: - case GL_MAP1_VERTEX_ATTRIB4_4_NV: - case GL_MAP1_VERTEX_ATTRIB5_4_NV: - case GL_MAP1_VERTEX_ATTRIB6_4_NV: - case GL_MAP1_VERTEX_ATTRIB7_4_NV: - case GL_MAP1_VERTEX_ATTRIB8_4_NV: - case GL_MAP1_VERTEX_ATTRIB9_4_NV: - case GL_MAP1_VERTEX_ATTRIB10_4_NV: - case GL_MAP1_VERTEX_ATTRIB11_4_NV: - case GL_MAP1_VERTEX_ATTRIB12_4_NV: - case GL_MAP1_VERTEX_ATTRIB13_4_NV: - case GL_MAP1_VERTEX_ATTRIB14_4_NV: - case GL_MAP1_VERTEX_ATTRIB15_4_NV: - CHECK_EXTENSION(NV_vertex_program); - { - const GLuint map = (GLuint) (cap - GL_MAP1_VERTEX_ATTRIB0_4_NV); - return ctx->Eval.Map1Attrib[map]; - } - case GL_MAP2_VERTEX_ATTRIB0_4_NV: - case GL_MAP2_VERTEX_ATTRIB1_4_NV: - case GL_MAP2_VERTEX_ATTRIB2_4_NV: - case GL_MAP2_VERTEX_ATTRIB3_4_NV: - case GL_MAP2_VERTEX_ATTRIB4_4_NV: - case GL_MAP2_VERTEX_ATTRIB5_4_NV: - case GL_MAP2_VERTEX_ATTRIB6_4_NV: - case GL_MAP2_VERTEX_ATTRIB7_4_NV: - case GL_MAP2_VERTEX_ATTRIB8_4_NV: - case GL_MAP2_VERTEX_ATTRIB9_4_NV: - case GL_MAP2_VERTEX_ATTRIB10_4_NV: - case GL_MAP2_VERTEX_ATTRIB11_4_NV: - case GL_MAP2_VERTEX_ATTRIB12_4_NV: - case GL_MAP2_VERTEX_ATTRIB13_4_NV: - case GL_MAP2_VERTEX_ATTRIB14_4_NV: - case GL_MAP2_VERTEX_ATTRIB15_4_NV: - CHECK_EXTENSION(NV_vertex_program); - { - const GLuint map = (GLuint) (cap - GL_MAP2_VERTEX_ATTRIB0_4_NV); - return ctx->Eval.Map2Attrib[map]; - } -#endif /* FEATURE_NV_vertex_program */ - -#if FEATURE_NV_fragment_program - case GL_FRAGMENT_PROGRAM_NV: - CHECK_EXTENSION(NV_fragment_program); - return ctx->FragmentProgram.Enabled; -#endif /* FEATURE_NV_fragment_program */ /* GL_NV_texture_rectangle */ case GL_TEXTURE_RECTANGLE_NV: + if (ctx->API != API_OPENGL_COMPAT) + goto invalid_enum_error; CHECK_EXTENSION(NV_texture_rectangle); return is_texture_enabled(ctx, TEXTURE_RECT_BIT); /* GL_EXT_stencil_two_side */ case GL_STENCIL_TEST_TWO_SIDE_EXT: + if (ctx->API != API_OPENGL_COMPAT) + goto invalid_enum_error; CHECK_EXTENSION(EXT_stencil_two_side); return ctx->Stencil.TestTwoSide; -#if FEATURE_ARB_fragment_program case GL_FRAGMENT_PROGRAM_ARB: + if (ctx->API != API_OPENGL_COMPAT) + goto invalid_enum_error; return ctx->FragmentProgram.Enabled; -#endif /* FEATURE_ARB_fragment_program */ /* GL_EXT_depth_bounds_test */ case GL_DEPTH_BOUNDS_TEST_EXT: + if (!_mesa_is_desktop_gl(ctx)) + goto invalid_enum_error; CHECK_EXTENSION(EXT_depth_bounds_test); return ctx->Depth.BoundsTest; /* GL_ARB_depth_clamp */ case GL_DEPTH_CLAMP: + if (!_mesa_is_desktop_gl(ctx)) + goto invalid_enum_error; CHECK_EXTENSION(ARB_depth_clamp); return ctx->Transform.DepthClamp; -#if FEATURE_ATI_fragment_shader case GL_FRAGMENT_SHADER_ATI: + if (ctx->API != API_OPENGL_COMPAT) + goto invalid_enum_error; CHECK_EXTENSION(ATI_fragment_shader); return ctx->ATIFragmentShader.Enabled; -#endif /* FEATURE_ATI_fragment_shader */ case GL_TEXTURE_CUBE_MAP_SEAMLESS: + if (!_mesa_is_desktop_gl(ctx)) + goto invalid_enum_error; CHECK_EXTENSION(ARB_seamless_cube_map); return ctx->Texture.CubeMapSeamless; -#if FEATURE_EXT_transform_feedback case GL_RASTERIZER_DISCARD: + if (!_mesa_is_desktop_gl(ctx) && !_mesa_is_gles3(ctx)) + goto invalid_enum_error; CHECK_EXTENSION(EXT_transform_feedback); - return ctx->TransformFeedback.RasterDiscard; -#endif + return ctx->RasterDiscard; /* GL_NV_primitive_restart */ case GL_PRIMITIVE_RESTART_NV: - if (!ctx->Extensions.NV_primitive_restart) { + if (ctx->API != API_OPENGL_COMPAT || !ctx->Extensions.NV_primitive_restart) { goto invalid_enum_error; } return ctx->Array.PrimitiveRestart; /* GL 3.1 primitive restart */ case GL_PRIMITIVE_RESTART: - if (ctx->VersionMajor * 10 + ctx->VersionMinor < 31) { + if (!_mesa_is_desktop_gl(ctx) || ctx->Version < 31) { goto invalid_enum_error; } return ctx->Array.PrimitiveRestart; + case GL_PRIMITIVE_RESTART_FIXED_INDEX: + if (!_mesa_is_gles3(ctx) && !ctx->Extensions.ARB_ES3_compatibility) { + goto invalid_enum_error; + } + return ctx->Array.PrimitiveRestartFixedIndex; + /* GL3.0 - GL_framebuffer_sRGB */ case GL_FRAMEBUFFER_SRGB_EXT: + if (!_mesa_is_desktop_gl(ctx)) + goto invalid_enum_error; CHECK_EXTENSION(EXT_framebuffer_sRGB); return ctx->Color.sRGBEnabled; + /* GL_OES_EGL_image_external */ + case GL_TEXTURE_EXTERNAL_OES: + if (!_mesa_is_gles(ctx)) + goto invalid_enum_error; + CHECK_EXTENSION(OES_EGL_image_external); + return is_texture_enabled(ctx, TEXTURE_EXTERNAL_BIT); + + /* ARB_texture_multisample */ + case GL_SAMPLE_MASK: + if (!_mesa_is_desktop_gl(ctx)) + goto invalid_enum_error; + CHECK_EXTENSION(ARB_texture_multisample); + return ctx->Multisample.SampleMask; + + /* ARB_sample_shading */ + case GL_SAMPLE_SHADING: + if (!_mesa_is_desktop_gl(ctx)) + goto invalid_enum_error; + CHECK_EXTENSION(ARB_sample_shading); + return ctx->Multisample.SampleShading; + default: goto invalid_enum_error; } @@ -1498,6 +1626,7 @@ _mesa_IsEnabled( GLenum cap ) return GL_FALSE; invalid_enum_error: - _mesa_error(ctx, GL_INVALID_ENUM, "glIsEnabled(0x%x)", (int) cap); + _mesa_error(ctx, GL_INVALID_ENUM, "glIsEnabled(%s)", + _mesa_lookup_enum_by_nr(cap)); return GL_FALSE; }