src/mesa/main/enable.c

   1 /**
   2  * \file enable.c
   3  * Enable/disable/query GL capabilities.
   4  */
   5
   6 /*
   7  * Mesa 3-D graphics library
   8  *
   9  * Copyright (C) 1999-2007  Brian Paul   All Rights Reserved.
  10  *
  11  * Permission is hereby granted, free of charge, to any person obtaining a
  12  * copy of this software and associated documentation files (the "Software"),
  13  * to deal in the Software without restriction, including without limitation
  14  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  15  * and/or sell copies of the Software, and to permit persons to whom the
  16  * Software is furnished to do so, subject to the following conditions:
  17  *
  18  * The above copyright notice and this permission notice shall be included
  19  * in all copies or substantial portions of the Software.
  20  *
  21  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  22  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  23  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  24  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
  25  * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
  26  * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
  27  * OTHER DEALINGS IN THE SOFTWARE.
  28  */
  29
  30
  31 #include "glheader.h"
  32 #include "arrayobj.h"
  33 #include "blend.h"
  34 #include "clip.h"
  35 #include "context.h"
  36 #include "debug_output.h"
  37 #include "enable.h"
  38 #include "errors.h"
  39 #include "light.h"
  40 #include "mtypes.h"
  41 #include "enums.h"
  42 #include "state.h"
  43 #include "texstate.h"
  44 #include "varray.h"
  45
  46
  47 static void
  48 update_derived_primitive_restart_state(struct gl_context *ctx)
  49 {
  50    /* Update derived primitive restart state.
  51     */
  52    ctx->Array._PrimitiveRestart = ctx->Array.PrimitiveRestart
  53       || ctx->Array.PrimitiveRestartFixedIndex;
  54 }
  55
  56
  57 /**
  58  * Helper to enable/disable VAO client-side state.
  59  */
  60 static void
  61 vao_state(struct gl_context *ctx, gl_vert_attrib attr, GLboolean state)
  62 {
  63    if (state)
  64       _mesa_enable_vertex_array_attrib(ctx, ctx->Array.VAO, attr);
  65    else
  66       _mesa_disable_vertex_array_attrib(ctx, ctx->Array.VAO, attr);
  67 }
  68
  69
  70 /**
  71  * Helper to enable/disable client-side state.
  72  */
  73 static void
  74 client_state(struct gl_context *ctx, GLenum cap, GLboolean state)
  75 {
  76    switch (cap) {
  77       case GL_VERTEX_ARRAY:
  78          vao_state(ctx, VERT_ATTRIB_POS, state);
  79          break;
  80       case GL_NORMAL_ARRAY:
  81          vao_state(ctx, VERT_ATTRIB_NORMAL, state);
  82          break;
  83       case GL_COLOR_ARRAY:
  84          vao_state(ctx, VERT_ATTRIB_COLOR0, state);
  85          break;
  86       case GL_INDEX_ARRAY:
  87          vao_state(ctx, VERT_ATTRIB_COLOR_INDEX, state);
  88          break;
  89       case GL_TEXTURE_COORD_ARRAY:
  90          vao_state(ctx, VERT_ATTRIB_TEX(ctx->Array.ActiveTexture), state);
  91          break;
  92       case GL_EDGE_FLAG_ARRAY:
  93          vao_state(ctx, VERT_ATTRIB_EDGEFLAG, state);
  94          break;
  95       case GL_FOG_COORDINATE_ARRAY_EXT:
  96          vao_state(ctx, VERT_ATTRIB_FOG, state);
  97          break;
  98       case GL_SECONDARY_COLOR_ARRAY_EXT:
  99          vao_state(ctx, VERT_ATTRIB_COLOR1, state);
 100          break;
 101
 102       case GL_POINT_SIZE_ARRAY_OES:
 103          FLUSH_VERTICES(ctx, _NEW_PROGRAM);
 104          ctx->VertexProgram.PointSizeEnabled = state;
 105          vao_state(ctx, VERT_ATTRIB_POINT_SIZE, state);
 106          break;
 107
 108       /* GL_NV_primitive_restart */
 109       case GL_PRIMITIVE_RESTART_NV:
 110          if (!_mesa_has_NV_primitive_restart(ctx))
 111             goto invalid_enum_error;
 112          if (ctx->Array.PrimitiveRestart == state)
 113             return;
 114
 115          FLUSH_VERTICES(ctx, 0);
 116          ctx->Array.PrimitiveRestart = state;
 117          update_derived_primitive_restart_state(ctx);
 118          return;
 119
 120       default:
 121          goto invalid_enum_error;
 122    }
 123
 124    if (ctx->Driver.Enable) {
 125       ctx->Driver.Enable( ctx, cap, state );
 126    }
 127
 128    return;
 129
 130 invalid_enum_error:
 131    _mesa_error(ctx, GL_INVALID_ENUM, "gl%sClientState(%s)",
 132                state ? "Enable" : "Disable", _mesa_enum_to_string(cap));
 133 }
 134
 135
 136 /**
 137  * Enable GL capability.
 138  * \param cap  state to enable/disable.
 139  *
 140  * Get's the current context, assures that we're outside glBegin()/glEnd() and
 141  * calls client_state().
 142  */
 143 void GLAPIENTRY
 144 _mesa_EnableClientState( GLenum cap )
 145 {
 146    GET_CURRENT_CONTEXT(ctx);
 147    client_state( ctx, cap, GL_TRUE );
 148 }
 149
 150
 151 /**
 152  * Disable GL capability.
 153  * \param cap  state to enable/disable.
 154  *
 155  * Get's the current context, assures that we're outside glBegin()/glEnd() and
 156  * calls client_state().
 157  */
 158 void GLAPIENTRY
 159 _mesa_DisableClientState( GLenum cap )
 160 {
 161    GET_CURRENT_CONTEXT(ctx);
 162    client_state( ctx, cap, GL_FALSE );
 163 }
 164
 165
 166 #define CHECK_EXTENSION(EXTNAME)                                        \
 167    if (!ctx->Extensions.EXTNAME) {                                      \
 168       goto invalid_enum_error;                                          \
 169    }
 170
 171 #define CHECK_EXTENSION2(EXT1, EXT2)                            \
 172    if (!ctx->Extensions.EXT1 && !ctx->Extensions.EXT2) {                \
 173       goto invalid_enum_error;                                          \
 174    }
 175
 176 /**
 177  * Return pointer to current texture unit for setting/getting coordinate
 178  * state.
 179  * Note that we'll set GL_INVALID_OPERATION and return NULL if the active
 180  * texture unit is higher than the number of supported coordinate units.
 181  */
 182 static struct gl_fixedfunc_texture_unit *
 183 get_texcoord_unit(struct gl_context *ctx)
 184 {
 185    if (ctx->Texture.CurrentUnit >= ctx->Const.MaxTextureCoordUnits) {
 186       _mesa_error(ctx, GL_INVALID_OPERATION, "glEnable/Disable(texcoord unit)");
 187       return NULL;
 188    }
 189    else {
 190       return &ctx->Texture.FixedFuncUnit[ctx->Texture.CurrentUnit];
 191    }
 192 }
 193
 194
 195 /**
 196  * Helper function to enable or disable a texture target.
 197  * \param bit  one of the TEXTURE_x_BIT values
 198  * \return GL_TRUE if state is changing or GL_FALSE if no change
 199  */
 200 static GLboolean
 201 enable_texture(struct gl_context *ctx, GLboolean state, GLbitfield texBit)
 202 {
 203    struct gl_fixedfunc_texture_unit *texUnit =
 204       _mesa_get_current_fixedfunc_tex_unit(ctx);
 205    if (!texUnit)
 206       return GL_FALSE;
 207
 208    const GLbitfield newenabled = state
 209       ? (texUnit->Enabled | texBit) : (texUnit->Enabled & ~texBit);
 210
 211    if (texUnit->Enabled == newenabled)
 212        return GL_FALSE;
 213
 214    FLUSH_VERTICES(ctx, _NEW_TEXTURE_STATE);
 215    texUnit->Enabled = newenabled;
 216    return GL_TRUE;
 217 }
 218
 219
 220 /**
 221  * Helper function to enable or disable GL_MULTISAMPLE, skipping the check for
 222  * whether the API supports it (GLES doesn't).
 223  */
 224 void
 225 _mesa_set_multisample(struct gl_context *ctx, GLboolean state)
 226 {
 227    if (ctx->Multisample.Enabled == state)
 228       return;
 229
 230    /* GL compatibility needs Multisample.Enable to determine program state
 231     * constants.
 232     */
 233    if (ctx->API == API_OPENGL_COMPAT || ctx->API == API_OPENGLES ||
 234        !ctx->DriverFlags.NewMultisampleEnable) {
 235       FLUSH_VERTICES(ctx, _NEW_MULTISAMPLE);
 236    } else {
 237       FLUSH_VERTICES(ctx, 0);
 238    }
 239
 240    ctx->NewDriverState |= ctx->DriverFlags.NewMultisampleEnable;
 241    ctx->Multisample.Enabled = state;
 242
 243    if (ctx->Driver.Enable) {
 244       ctx->Driver.Enable(ctx, GL_MULTISAMPLE, state);
 245    }
 246 }
 247
 248 /**
 249  * Helper function to enable or disable GL_FRAMEBUFFER_SRGB, skipping the
 250  * check for whether the API supports it (GLES doesn't).
 251  */
 252 void
 253 _mesa_set_framebuffer_srgb(struct gl_context *ctx, GLboolean state)
 254 {
 255    if (ctx->Color.sRGBEnabled == state)
 256       return;
 257
 258    /* TODO: Switch i965 to the new flag and remove the conditional */
 259    FLUSH_VERTICES(ctx, ctx->DriverFlags.NewFramebufferSRGB ? 0 : _NEW_BUFFERS);
 260    ctx->NewDriverState |= ctx->DriverFlags.NewFramebufferSRGB;
 261    ctx->Color.sRGBEnabled = state;
 262
 263    if (ctx->Driver.Enable) {
 264       ctx->Driver.Enable(ctx, GL_FRAMEBUFFER_SRGB, state);
 265    }
 266 }
 267
 268 /**
 269  * Helper function to enable or disable state.
 270  *
 271  * \param ctx GL context.
 272  * \param cap  the state to enable/disable
 273  * \param state whether to enable or disable the specified capability.
 274  *
 275  * Updates the current context and flushes the vertices as needed. For
 276  * capabilities associated with extensions it verifies that those extensions
 277  * are effectivly present before updating. Notifies the driver via
 278  * dd_function_table::Enable.
 279  */
 280 void
 281 _mesa_set_enable(struct gl_context *ctx, GLenum cap, GLboolean state)
 282 {
 283    if (MESA_VERBOSE & VERBOSE_API)
 284       _mesa_debug(ctx, "%s %s (newstate is %x)\n",
 285                   state ? "glEnable" : "glDisable",
 286                   _mesa_enum_to_string(cap),
 287                   ctx->NewState);
 288
 289    switch (cap) {
 290       case GL_ALPHA_TEST:
 291          if (ctx->API != API_OPENGL_COMPAT && ctx->API != API_OPENGLES)
 292             goto invalid_enum_error;
 293          if (ctx->Color.AlphaEnabled == state)
 294             return;
 295          /* AlphaEnabled is used by the fixed-func fragment program */
 296          FLUSH_VERTICES(ctx, _NEW_COLOR);
 297          ctx->NewDriverState |= ctx->DriverFlags.NewAlphaTest;
 298          ctx->Color.AlphaEnabled = state;
 299          break;
 300       case GL_AUTO_NORMAL:
 301          if (ctx->API != API_OPENGL_COMPAT)
 302             goto invalid_enum_error;
 303          if (ctx->Eval.AutoNormal == state)
 304             return;
 305          FLUSH_VERTICES(ctx, _NEW_EVAL);
 306          ctx->Eval.AutoNormal = state;
 307          break;
 308       case GL_BLEND:
 309          {
 310             GLbitfield newEnabled =
 311                state * ((1 << ctx->Const.MaxDrawBuffers) - 1);
 312             if (newEnabled != ctx->Color.BlendEnabled) {
 313                _mesa_flush_vertices_for_blend_adv(ctx, newEnabled,
 314                                                ctx->Color._AdvancedBlendMode);
 315                ctx->Color.BlendEnabled = newEnabled;
 316             }
 317          }
 318          break;
 319       case GL_CLIP_DISTANCE0: /* aka GL_CLIP_PLANE0 */
 320       case GL_CLIP_DISTANCE1:
 321       case GL_CLIP_DISTANCE2:
 322       case GL_CLIP_DISTANCE3:
 323       case GL_CLIP_DISTANCE4:
 324       case GL_CLIP_DISTANCE5:
 325       case GL_CLIP_DISTANCE6:
 326       case GL_CLIP_DISTANCE7:
 327          {
 328             const GLuint p = cap - GL_CLIP_DISTANCE0;
 329
 330             if (p >= ctx->Const.MaxClipPlanes)
 331                goto invalid_enum_error;
 332
 333             if ((ctx->Transform.ClipPlanesEnabled & (1 << p))
 334                 == ((GLuint) state << p))
 335                return;
 336
 337             /* The compatibility profile needs _NEW_TRANSFORM to transform
 338              * clip planes according to the projection matrix.
 339              */
 340             if (ctx->API == API_OPENGL_COMPAT || ctx->API == API_OPENGLES ||
 341                 !ctx->DriverFlags.NewClipPlaneEnable) {
 342                FLUSH_VERTICES(ctx, _NEW_TRANSFORM);
 343             } else {
 344                FLUSH_VERTICES(ctx, 0);
 345             }
 346             ctx->NewDriverState |= ctx->DriverFlags.NewClipPlaneEnable;
 347
 348             if (state) {
 349                ctx->Transform.ClipPlanesEnabled |= (1 << p);
 350
 351                /* The projection matrix transforms the clip plane. */
 352                /* TODO: glEnable might not be the best place to do it. */
 353                if (ctx->API == API_OPENGL_COMPAT || ctx->API == API_OPENGLES) {
 354                   _mesa_update_clip_plane(ctx, p);
 355                   ctx->NewDriverState |= ctx->DriverFlags.NewClipPlane;
 356                }
 357             }
 358             else {
 359                ctx->Transform.ClipPlanesEnabled &= ~(1 << p);
 360             }
 361          }
 362          break;
 363       case GL_COLOR_MATERIAL:
 364          if (ctx->API != API_OPENGL_COMPAT && ctx->API != API_OPENGLES)
 365             goto invalid_enum_error;
 366          if (ctx->Light.ColorMaterialEnabled == state)
 367             return;
 368          FLUSH_VERTICES(ctx, _NEW_LIGHT);
 369          FLUSH_CURRENT(ctx, 0);
 370          ctx->Light.ColorMaterialEnabled = state;
 371          if (state) {
 372             _mesa_update_color_material( ctx,
 373                                   ctx->Current.Attrib[VERT_ATTRIB_COLOR0] );
 374          }
 375          break;
 376       case GL_CULL_FACE:
 377          if (ctx->Polygon.CullFlag == state)
 378             return;
 379          FLUSH_VERTICES(ctx,
 380                         ctx->DriverFlags.NewPolygonState ? 0 : _NEW_POLYGON);
 381          ctx->NewDriverState |= ctx->DriverFlags.NewPolygonState;
 382          ctx->Polygon.CullFlag = state;
 383          break;
 384       case GL_DEPTH_TEST:
 385          if (ctx->Depth.Test == state)
 386             return;
 387          FLUSH_VERTICES(ctx, ctx->DriverFlags.NewDepth ? 0 : _NEW_DEPTH);
 388          ctx->NewDriverState |= ctx->DriverFlags.NewDepth;
 389          ctx->Depth.Test = state;
 390          break;
 391       case GL_DEBUG_OUTPUT:
 392       case GL_DEBUG_OUTPUT_SYNCHRONOUS_ARB:
 393          _mesa_set_debug_state_int(ctx, cap, state);
 394          break;
 395       case GL_DITHER:
 396          if (ctx->Color.DitherFlag == state)
 397             return;
 398          FLUSH_VERTICES(ctx, ctx->DriverFlags.NewBlend ? 0 : _NEW_COLOR);
 399          ctx->NewDriverState |= ctx->DriverFlags.NewBlend;
 400          ctx->Color.DitherFlag = state;
 401          break;
 402       case GL_FOG:
 403          if (ctx->API != API_OPENGL_COMPAT && ctx->API != API_OPENGLES)
 404             goto invalid_enum_error;
 405          if (ctx->Fog.Enabled == state)
 406             return;
 407          FLUSH_VERTICES(ctx, _NEW_FOG);
 408          ctx->Fog.Enabled = state;
 409          ctx->Fog._PackedEnabledMode = state ? ctx->Fog._PackedMode : FOG_NONE;
 410          break;
 411       case GL_LIGHT0:
 412       case GL_LIGHT1:
 413       case GL_LIGHT2:
 414       case GL_LIGHT3:
 415       case GL_LIGHT4:
 416       case GL_LIGHT5:
 417       case GL_LIGHT6:
 418       case GL_LIGHT7:
 419          if (ctx->API != API_OPENGL_COMPAT && ctx->API != API_OPENGLES)
 420             goto invalid_enum_error;
 421          if (ctx->Light.Light[cap-GL_LIGHT0].Enabled == state)
 422             return;
 423          FLUSH_VERTICES(ctx, _NEW_LIGHT);
 424          ctx->Light.Light[cap-GL_LIGHT0].Enabled = state;
 425          if (state) {
 426             ctx->Light._EnabledLights |= 1u << (cap - GL_LIGHT0);
 427          }
 428          else {
 429             ctx->Light._EnabledLights &= ~(1u << (cap - GL_LIGHT0));
 430          }
 431          break;
 432       case GL_LIGHTING:
 433          if (ctx->API != API_OPENGL_COMPAT && ctx->API != API_OPENGLES)
 434             goto invalid_enum_error;
 435          if (ctx->Light.Enabled == state)
 436             return;
 437          FLUSH_VERTICES(ctx, _NEW_LIGHT);
 438          ctx->Light.Enabled = state;
 439          break;
 440       case GL_LINE_SMOOTH:
 441          if (!_mesa_is_desktop_gl(ctx) && ctx->API != API_OPENGLES)
 442             goto invalid_enum_error;
 443          if (ctx->Line.SmoothFlag == state)
 444             return;
 445          FLUSH_VERTICES(ctx, ctx->DriverFlags.NewLineState ? 0 : _NEW_LINE);
 446          ctx->NewDriverState |= ctx->DriverFlags.NewLineState;
 447          ctx->Line.SmoothFlag = state;
 448          break;
 449       case GL_LINE_STIPPLE:
 450          if (ctx->API != API_OPENGL_COMPAT)
 451             goto invalid_enum_error;
 452          if (ctx->Line.StippleFlag == state)
 453             return;
 454          FLUSH_VERTICES(ctx, ctx->DriverFlags.NewLineState ? 0 : _NEW_LINE);
 455          ctx->NewDriverState |= ctx->DriverFlags.NewLineState;
 456          ctx->Line.StippleFlag = state;
 457          break;
 458       case GL_INDEX_LOGIC_OP:
 459          if (ctx->API != API_OPENGL_COMPAT)
 460             goto invalid_enum_error;
 461          if (ctx->Color.IndexLogicOpEnabled == state)
 462             return;
 463          FLUSH_VERTICES(ctx, ctx->DriverFlags.NewLogicOp ? 0 : _NEW_COLOR);
 464          ctx->NewDriverState |= ctx->DriverFlags.NewLogicOp;
 465          ctx->Color.IndexLogicOpEnabled = state;
 466          break;
 467       case GL_CONSERVATIVE_RASTERIZATION_INTEL:
 468          if (!_mesa_has_INTEL_conservative_rasterization(ctx))
 469             goto invalid_enum_error;
 470          if (ctx->IntelConservativeRasterization == state)
 471             return;
 472          FLUSH_VERTICES(ctx, 0);
 473          ctx->NewDriverState |=
 474             ctx->DriverFlags.NewIntelConservativeRasterization;
 475          ctx->IntelConservativeRasterization = state;
 476          break;
 477       case GL_CONSERVATIVE_RASTERIZATION_NV:
 478          if (!_mesa_has_NV_conservative_raster(ctx))
 479             goto invalid_enum_error;
 480          if (ctx->ConservativeRasterization == state)
 481             return;
 482          FLUSH_VERTICES(ctx, 0);
 483          ctx->NewDriverState |=
 484             ctx->DriverFlags.NewNvConservativeRasterization;
 485          ctx->ConservativeRasterization = state;
 486          break;
 487       case GL_COLOR_LOGIC_OP:
 488          if (!_mesa_is_desktop_gl(ctx) && ctx->API != API_OPENGLES)
 489             goto invalid_enum_error;
 490          if (ctx->Color.ColorLogicOpEnabled == state)
 491             return;
 492          FLUSH_VERTICES(ctx, ctx->DriverFlags.NewLogicOp ? 0 : _NEW_COLOR);
 493          ctx->NewDriverState |= ctx->DriverFlags.NewLogicOp;
 494          ctx->Color.ColorLogicOpEnabled = state;
 495          break;
 496       case GL_MAP1_COLOR_4:
 497          if (ctx->API != API_OPENGL_COMPAT)
 498             goto invalid_enum_error;
 499          if (ctx->Eval.Map1Color4 == state)
 500             return;
 501          FLUSH_VERTICES(ctx, _NEW_EVAL);
 502          ctx->Eval.Map1Color4 = state;
 503          break;
 504       case GL_MAP1_INDEX:
 505          if (ctx->API != API_OPENGL_COMPAT)
 506             goto invalid_enum_error;
 507          if (ctx->Eval.Map1Index == state)
 508             return;
 509          FLUSH_VERTICES(ctx, _NEW_EVAL);
 510          ctx->Eval.Map1Index = state;
 511          break;
 512       case GL_MAP1_NORMAL:
 513          if (ctx->API != API_OPENGL_COMPAT)
 514             goto invalid_enum_error;
 515          if (ctx->Eval.Map1Normal == state)
 516             return;
 517          FLUSH_VERTICES(ctx, _NEW_EVAL);
 518          ctx->Eval.Map1Normal = state;
 519          break;
 520       case GL_MAP1_TEXTURE_COORD_1:
 521          if (ctx->API != API_OPENGL_COMPAT)
 522             goto invalid_enum_error;
 523          if (ctx->Eval.Map1TextureCoord1 == state)
 524             return;
 525          FLUSH_VERTICES(ctx, _NEW_EVAL);
 526          ctx->Eval.Map1TextureCoord1 = state;
 527          break;
 528       case GL_MAP1_TEXTURE_COORD_2:
 529          if (ctx->API != API_OPENGL_COMPAT)
 530             goto invalid_enum_error;
 531          if (ctx->Eval.Map1TextureCoord2 == state)
 532             return;
 533          FLUSH_VERTICES(ctx, _NEW_EVAL);
 534          ctx->Eval.Map1TextureCoord2 = state;
 535          break;
 536       case GL_MAP1_TEXTURE_COORD_3:
 537          if (ctx->API != API_OPENGL_COMPAT)
 538             goto invalid_enum_error;
 539          if (ctx->Eval.Map1TextureCoord3 == state)
 540             return;
 541          FLUSH_VERTICES(ctx, _NEW_EVAL);
 542          ctx->Eval.Map1TextureCoord3 = state;
 543          break;
 544       case GL_MAP1_TEXTURE_COORD_4:
 545          if (ctx->API != API_OPENGL_COMPAT)
 546             goto invalid_enum_error;
 547          if (ctx->Eval.Map1TextureCoord4 == state)
 548             return;
 549          FLUSH_VERTICES(ctx, _NEW_EVAL);
 550          ctx->Eval.Map1TextureCoord4 = state;
 551          break;
 552       case GL_MAP1_VERTEX_3:
 553          if (ctx->API != API_OPENGL_COMPAT)
 554             goto invalid_enum_error;
 555          if (ctx->Eval.Map1Vertex3 == state)
 556             return;
 557          FLUSH_VERTICES(ctx, _NEW_EVAL);
 558          ctx->Eval.Map1Vertex3 = state;
 559          break;
 560       case GL_MAP1_VERTEX_4:
 561          if (ctx->API != API_OPENGL_COMPAT)
 562             goto invalid_enum_error;
 563          if (ctx->Eval.Map1Vertex4 == state)
 564             return;
 565          FLUSH_VERTICES(ctx, _NEW_EVAL);
 566          ctx->Eval.Map1Vertex4 = state;
 567          break;
 568       case GL_MAP2_COLOR_4:
 569          if (ctx->API != API_OPENGL_COMPAT)
 570             goto invalid_enum_error;
 571          if (ctx->Eval.Map2Color4 == state)
 572             return;
 573          FLUSH_VERTICES(ctx, _NEW_EVAL);
 574          ctx->Eval.Map2Color4 = state;
 575          break;
 576       case GL_MAP2_INDEX:
 577          if (ctx->API != API_OPENGL_COMPAT)
 578             goto invalid_enum_error;
 579          if (ctx->Eval.Map2Index == state)
 580             return;
 581          FLUSH_VERTICES(ctx, _NEW_EVAL);
 582          ctx->Eval.Map2Index = state;
 583          break;
 584       case GL_MAP2_NORMAL:
 585          if (ctx->API != API_OPENGL_COMPAT)
 586             goto invalid_enum_error;
 587          if (ctx->Eval.Map2Normal == state)
 588             return;
 589          FLUSH_VERTICES(ctx, _NEW_EVAL);
 590          ctx->Eval.Map2Normal = state;
 591          break;
 592       case GL_MAP2_TEXTURE_COORD_1:
 593          if (ctx->API != API_OPENGL_COMPAT)
 594             goto invalid_enum_error;
 595          if (ctx->Eval.Map2TextureCoord1 == state)
 596             return;
 597          FLUSH_VERTICES(ctx, _NEW_EVAL);
 598          ctx->Eval.Map2TextureCoord1 = state;
 599          break;
 600       case GL_MAP2_TEXTURE_COORD_2:
 601          if (ctx->API != API_OPENGL_COMPAT)
 602             goto invalid_enum_error;
 603          if (ctx->Eval.Map2TextureCoord2 == state)
 604             return;
 605          FLUSH_VERTICES(ctx, _NEW_EVAL);
 606          ctx->Eval.Map2TextureCoord2 = state;
 607          break;
 608       case GL_MAP2_TEXTURE_COORD_3:
 609          if (ctx->API != API_OPENGL_COMPAT)
 610             goto invalid_enum_error;
 611          if (ctx->Eval.Map2TextureCoord3 == state)
 612             return;
 613          FLUSH_VERTICES(ctx, _NEW_EVAL);
 614          ctx->Eval.Map2TextureCoord3 = state;
 615          break;
 616       case GL_MAP2_TEXTURE_COORD_4:
 617          if (ctx->API != API_OPENGL_COMPAT)
 618             goto invalid_enum_error;
 619          if (ctx->Eval.Map2TextureCoord4 == state)
 620             return;
 621          FLUSH_VERTICES(ctx, _NEW_EVAL);
 622          ctx->Eval.Map2TextureCoord4 = state;
 623          break;
 624       case GL_MAP2_VERTEX_3:
 625          if (ctx->API != API_OPENGL_COMPAT)
 626             goto invalid_enum_error;
 627          if (ctx->Eval.Map2Vertex3 == state)
 628             return;
 629          FLUSH_VERTICES(ctx, _NEW_EVAL);
 630          ctx->Eval.Map2Vertex3 = state;
 631          break;
 632       case GL_MAP2_VERTEX_4:
 633          if (ctx->API != API_OPENGL_COMPAT)
 634             goto invalid_enum_error;
 635          if (ctx->Eval.Map2Vertex4 == state)
 636             return;
 637          FLUSH_VERTICES(ctx, _NEW_EVAL);
 638          ctx->Eval.Map2Vertex4 = state;
 639          break;
 640       case GL_NORMALIZE:
 641          if (ctx->API != API_OPENGL_COMPAT && ctx->API != API_OPENGLES)
 642             goto invalid_enum_error;
 643          if (ctx->Transform.Normalize == state)
 644             return;
 645          FLUSH_VERTICES(ctx, _NEW_TRANSFORM);
 646          ctx->Transform.Normalize = state;
 647          break;
 648       case GL_POINT_SMOOTH:
 649          if (ctx->API != API_OPENGL_COMPAT && ctx->API != API_OPENGLES)
 650             goto invalid_enum_error;
 651          if (ctx->Point.SmoothFlag == state)
 652             return;
 653          FLUSH_VERTICES(ctx, _NEW_POINT);
 654          ctx->Point.SmoothFlag = state;
 655          break;
 656       case GL_POLYGON_SMOOTH:
 657          if (!_mesa_is_desktop_gl(ctx))
 658             goto invalid_enum_error;
 659          if (ctx->Polygon.SmoothFlag == state)
 660             return;
 661          FLUSH_VERTICES(ctx,
 662                         ctx->DriverFlags.NewPolygonState ? 0 : _NEW_POLYGON);
 663          ctx->NewDriverState |= ctx->DriverFlags.NewPolygonState;
 664          ctx->Polygon.SmoothFlag = state;
 665          break;
 666       case GL_POLYGON_STIPPLE:
 667          if (ctx->API != API_OPENGL_COMPAT)
 668             goto invalid_enum_error;
 669          if (ctx->Polygon.StippleFlag == state)
 670             return;
 671          FLUSH_VERTICES(ctx,
 672                         ctx->DriverFlags.NewPolygonState ? 0 : _NEW_POLYGON);
 673          ctx->NewDriverState |= ctx->DriverFlags.NewPolygonState;
 674          ctx->Polygon.StippleFlag = state;
 675          break;
 676       case GL_POLYGON_OFFSET_POINT:
 677          if (!_mesa_is_desktop_gl(ctx))
 678             goto invalid_enum_error;
 679          if (ctx->Polygon.OffsetPoint == state)
 680             return;
 681          FLUSH_VERTICES(ctx,
 682                         ctx->DriverFlags.NewPolygonState ? 0 : _NEW_POLYGON);
 683          ctx->NewDriverState |= ctx->DriverFlags.NewPolygonState;
 684          ctx->Polygon.OffsetPoint = state;
 685          break;
 686       case GL_POLYGON_OFFSET_LINE:
 687          if (!_mesa_is_desktop_gl(ctx))
 688             goto invalid_enum_error;
 689          if (ctx->Polygon.OffsetLine == state)
 690             return;
 691          FLUSH_VERTICES(ctx,
 692                         ctx->DriverFlags.NewPolygonState ? 0 : _NEW_POLYGON);
 693          ctx->NewDriverState |= ctx->DriverFlags.NewPolygonState;
 694          ctx->Polygon.OffsetLine = state;
 695          break;
 696       case GL_POLYGON_OFFSET_FILL:
 697          if (ctx->Polygon.OffsetFill == state)
 698             return;
 699          FLUSH_VERTICES(ctx,
 700                         ctx->DriverFlags.NewPolygonState ? 0 : _NEW_POLYGON);
 701          ctx->NewDriverState |= ctx->DriverFlags.NewPolygonState;
 702          ctx->Polygon.OffsetFill = state;
 703          break;
 704       case GL_RESCALE_NORMAL_EXT:
 705          if (ctx->API != API_OPENGL_COMPAT && ctx->API != API_OPENGLES)
 706             goto invalid_enum_error;
 707          if (ctx->Transform.RescaleNormals == state)
 708             return;
 709          FLUSH_VERTICES(ctx, _NEW_TRANSFORM);
 710          ctx->Transform.RescaleNormals = state;
 711          break;
 712       case GL_SCISSOR_TEST:
 713          {
 714             /* Must expand glEnable to all scissors */
 715             GLbitfield newEnabled =
 716                state * ((1 << ctx->Const.MaxViewports) - 1);
 717             if (newEnabled != ctx->Scissor.EnableFlags) {
 718                FLUSH_VERTICES(ctx, ctx->DriverFlags.NewScissorTest ? 0 :
 719                                                                 _NEW_SCISSOR);
 720                ctx->NewDriverState |= ctx->DriverFlags.NewScissorTest;
 721                ctx->Scissor.EnableFlags = newEnabled;
 722             }
 723          }
 724          break;
 725       case GL_STENCIL_TEST:
 726          if (ctx->Stencil.Enabled == state)
 727             return;
 728          FLUSH_VERTICES(ctx, ctx->DriverFlags.NewStencil ? 0 : _NEW_STENCIL);
 729          ctx->NewDriverState |= ctx->DriverFlags.NewStencil;
 730          ctx->Stencil.Enabled = state;
 731          break;
 732       case GL_TEXTURE_1D:
 733          if (ctx->API != API_OPENGL_COMPAT)
 734             goto invalid_enum_error;
 735          if (!enable_texture(ctx, state, TEXTURE_1D_BIT)) {
 736             return;
 737          }
 738          break;
 739       case GL_TEXTURE_2D:
 740          if (ctx->API != API_OPENGL_COMPAT && ctx->API != API_OPENGLES)
 741             goto invalid_enum_error;
 742          if (!enable_texture(ctx, state, TEXTURE_2D_BIT)) {
 743             return;
 744          }
 745          break;
 746       case GL_TEXTURE_3D:
 747          if (ctx->API != API_OPENGL_COMPAT && ctx->API != API_OPENGLES)
 748             goto invalid_enum_error;
 749          if (!enable_texture(ctx, state, TEXTURE_3D_BIT)) {
 750             return;
 751          }
 752          break;
 753       case GL_TEXTURE_GEN_S:
 754       case GL_TEXTURE_GEN_T:
 755       case GL_TEXTURE_GEN_R:
 756       case GL_TEXTURE_GEN_Q:
 757          {
 758             struct gl_fixedfunc_texture_unit *texUnit = get_texcoord_unit(ctx);
 759
 760             if (ctx->API != API_OPENGL_COMPAT)
 761                goto invalid_enum_error;
 762
 763             if (texUnit) {
 764                GLbitfield coordBit = S_BIT << (cap - GL_TEXTURE_GEN_S);
 765                GLbitfield newenabled = texUnit->TexGenEnabled & ~coordBit;
 766                if (state)
 767                   newenabled |= coordBit;
 768                if (texUnit->TexGenEnabled == newenabled)
 769                   return;
 770                FLUSH_VERTICES(ctx, _NEW_TEXTURE_STATE);
 771                texUnit->TexGenEnabled = newenabled;
 772             }
 773          }
 774          break;
 775
 776       case GL_TEXTURE_GEN_STR_OES:
 777          /* disable S, T, and R at the same time */
 778          {
 779             struct gl_fixedfunc_texture_unit *texUnit = get_texcoord_unit(ctx);
 780
 781             if (ctx->API != API_OPENGLES)
 782                goto invalid_enum_error;
 783
 784             if (texUnit) {
 785                GLuint newenabled =
 786                   texUnit->TexGenEnabled & ~STR_BITS;
 787                if (state)
 788                   newenabled |= STR_BITS;
 789                if (texUnit->TexGenEnabled == newenabled)
 790                   return;
 791                FLUSH_VERTICES(ctx, _NEW_TEXTURE_STATE);
 792                texUnit->TexGenEnabled = newenabled;
 793             }
 794          }
 795          break;
 796
 797       /* client-side state */
 798       case GL_VERTEX_ARRAY:
 799       case GL_NORMAL_ARRAY:
 800       case GL_COLOR_ARRAY:
 801       case GL_TEXTURE_COORD_ARRAY:
 802          if (ctx->API != API_OPENGL_COMPAT && ctx->API != API_OPENGLES)
 803             goto invalid_enum_error;
 804          client_state( ctx, cap, state );
 805          return;
 806       case GL_INDEX_ARRAY:
 807       case GL_EDGE_FLAG_ARRAY:
 808       case GL_FOG_COORDINATE_ARRAY_EXT:
 809       case GL_SECONDARY_COLOR_ARRAY_EXT:
 810          if (ctx->API != API_OPENGL_COMPAT)
 811             goto invalid_enum_error;
 812          client_state( ctx, cap, state );
 813          return;
 814       case GL_POINT_SIZE_ARRAY_OES:
 815          if (ctx->API != API_OPENGLES)
 816             goto invalid_enum_error;
 817          client_state( ctx, cap, state );
 818          return;
 819
 820       /* GL_ARB_texture_cube_map */
 821       case GL_TEXTURE_CUBE_MAP:
 822          if (!_mesa_has_ARB_texture_cube_map(ctx) &&
 823              !_mesa_has_OES_texture_cube_map(ctx))
 824             goto invalid_enum_error;
 825          if (!enable_texture(ctx, state, TEXTURE_CUBE_BIT)) {
 826             return;
 827          }
 828          break;
 829
 830       /* GL_EXT_secondary_color */
 831       case GL_COLOR_SUM_EXT:
 832          if (ctx->API != API_OPENGL_COMPAT)
 833             goto invalid_enum_error;
 834          if (ctx->Fog.ColorSumEnabled == state)
 835             return;
 836          FLUSH_VERTICES(ctx, _NEW_FOG);
 837          ctx->Fog.ColorSumEnabled = state;
 838          break;
 839
 840       /* GL_ARB_multisample */
 841       case GL_MULTISAMPLE_ARB:
 842          if (!_mesa_is_desktop_gl(ctx) && ctx->API != API_OPENGLES)
 843             goto invalid_enum_error;
 844          _mesa_set_multisample(ctx, state);
 845          return;
 846       case GL_SAMPLE_ALPHA_TO_COVERAGE_ARB:
 847          if (ctx->Multisample.SampleAlphaToCoverage == state)
 848             return;
 849          FLUSH_VERTICES(ctx, ctx->DriverFlags.NewSampleAlphaToXEnable ? 0 :
 850                                                          _NEW_MULTISAMPLE);
 851          ctx->NewDriverState |= ctx->DriverFlags.NewSampleAlphaToXEnable;
 852          ctx->Multisample.SampleAlphaToCoverage = state;
 853          break;
 854       case GL_SAMPLE_ALPHA_TO_ONE_ARB:
 855          if (!_mesa_is_desktop_gl(ctx) && ctx->API != API_OPENGLES)
 856             goto invalid_enum_error;
 857          if (ctx->Multisample.SampleAlphaToOne == state)
 858             return;
 859          FLUSH_VERTICES(ctx, ctx->DriverFlags.NewSampleAlphaToXEnable ? 0 :
 860                                                          _NEW_MULTISAMPLE);
 861          ctx->NewDriverState |= ctx->DriverFlags.NewSampleAlphaToXEnable;
 862          ctx->Multisample.SampleAlphaToOne = state;
 863          break;
 864       case GL_SAMPLE_COVERAGE_ARB:
 865          if (ctx->Multisample.SampleCoverage == state)
 866             return;
 867          FLUSH_VERTICES(ctx, ctx->DriverFlags.NewSampleMask ? 0 :
 868                                                          _NEW_MULTISAMPLE);
 869          ctx->NewDriverState |= ctx->DriverFlags.NewSampleMask;
 870          ctx->Multisample.SampleCoverage = state;
 871          break;
 872       case GL_SAMPLE_COVERAGE_INVERT_ARB:
 873          if (!_mesa_is_desktop_gl(ctx))
 874             goto invalid_enum_error;
 875          if (ctx->Multisample.SampleCoverageInvert == state)
 876             return;
 877          FLUSH_VERTICES(ctx, ctx->DriverFlags.NewSampleMask ? 0 :
 878                                                          _NEW_MULTISAMPLE);
 879          ctx->NewDriverState |= ctx->DriverFlags.NewSampleMask;
 880          ctx->Multisample.SampleCoverageInvert = state;
 881          break;
 882
 883       /* GL_ARB_sample_shading */
 884       case GL_SAMPLE_SHADING:
 885          if (!_mesa_has_ARB_sample_shading(ctx) && !_mesa_is_gles3(ctx))
 886             goto invalid_enum_error;
 887          if (ctx->Multisample.SampleShading == state)
 888             return;
 889          FLUSH_VERTICES(ctx, ctx->DriverFlags.NewSampleShading ? 0 :
 890                                                          _NEW_MULTISAMPLE);
 891          ctx->NewDriverState |= ctx->DriverFlags.NewSampleShading;
 892          ctx->Multisample.SampleShading = state;
 893          break;
 894
 895       /* GL_IBM_rasterpos_clip */
 896       case GL_RASTER_POSITION_UNCLIPPED_IBM:
 897          if (ctx->API != API_OPENGL_COMPAT)
 898             goto invalid_enum_error;
 899          if (ctx->Transform.RasterPositionUnclipped == state)
 900             return;
 901          FLUSH_VERTICES(ctx, 0);
 902          ctx->Transform.RasterPositionUnclipped = state;
 903          break;
 904
 905       /* GL_NV_point_sprite */
 906       case GL_POINT_SPRITE_NV:
 907          if (ctx->API != API_OPENGL_COMPAT && ctx->API != API_OPENGLES)
 908             goto invalid_enum_error;
 909          CHECK_EXTENSION2(NV_point_sprite, ARB_point_sprite);
 910          if (ctx->Point.PointSprite == state)
 911             return;
 912          FLUSH_VERTICES(ctx, _NEW_POINT);
 913          ctx->Point.PointSprite = state;
 914          break;
 915
 916       case GL_VERTEX_PROGRAM_ARB:
 917          if (ctx->API != API_OPENGL_COMPAT)
 918             goto invalid_enum_error;
 919          CHECK_EXTENSION(ARB_vertex_program);
 920          if (ctx->VertexProgram.Enabled == state)
 921             return;
 922          FLUSH_VERTICES(ctx, _NEW_PROGRAM);
 923          ctx->VertexProgram.Enabled = state;
 924          _mesa_update_vertex_processing_mode(ctx);
 925          break;
 926       case GL_VERTEX_PROGRAM_POINT_SIZE_ARB:
 927          /* This was added with ARB_vertex_program, but it is also used with
 928           * GLSL vertex shaders on desktop.
 929           */
 930          if (!_mesa_is_desktop_gl(ctx))
 931             goto invalid_enum_error;
 932          CHECK_EXTENSION(ARB_vertex_program);
 933          if (ctx->VertexProgram.PointSizeEnabled == state)
 934             return;
 935          FLUSH_VERTICES(ctx, _NEW_PROGRAM);
 936          ctx->VertexProgram.PointSizeEnabled = state;
 937          break;
 938       case GL_VERTEX_PROGRAM_TWO_SIDE_ARB:
 939          if (ctx->API != API_OPENGL_COMPAT)
 940             goto invalid_enum_error;
 941          CHECK_EXTENSION(ARB_vertex_program);
 942          if (ctx->VertexProgram.TwoSideEnabled == state)
 943             return;
 944          FLUSH_VERTICES(ctx, _NEW_PROGRAM);
 945          ctx->VertexProgram.TwoSideEnabled = state;
 946          break;
 947
 948       /* GL_NV_texture_rectangle */
 949       case GL_TEXTURE_RECTANGLE_NV:
 950          if (ctx->API != API_OPENGL_COMPAT)
 951             goto invalid_enum_error;
 952          CHECK_EXTENSION(NV_texture_rectangle);
 953          if (!enable_texture(ctx, state, TEXTURE_RECT_BIT)) {
 954             return;
 955          }
 956          break;
 957
 958       /* GL_EXT_stencil_two_side */
 959       case GL_STENCIL_TEST_TWO_SIDE_EXT:
 960          if (ctx->API != API_OPENGL_COMPAT)
 961             goto invalid_enum_error;
 962          CHECK_EXTENSION(EXT_stencil_two_side);
 963          if (ctx->Stencil.TestTwoSide == state)
 964             return;
 965          FLUSH_VERTICES(ctx, ctx->DriverFlags.NewStencil ? 0 : _NEW_STENCIL);
 966          ctx->NewDriverState |= ctx->DriverFlags.NewStencil;
 967          ctx->Stencil.TestTwoSide = state;
 968          if (state) {
 969             ctx->Stencil._BackFace = 2;
 970          } else {
 971             ctx->Stencil._BackFace = 1;
 972          }
 973          break;
 974
 975       case GL_FRAGMENT_PROGRAM_ARB:
 976          if (!_mesa_has_ARB_fragment_program(ctx))
 977             goto invalid_enum_error;
 978          if (ctx->FragmentProgram.Enabled == state)
 979             return;
 980          FLUSH_VERTICES(ctx, _NEW_PROGRAM);
 981          ctx->FragmentProgram.Enabled = state;
 982          break;
 983
 984       /* GL_EXT_depth_bounds_test */
 985       case GL_DEPTH_BOUNDS_TEST_EXT:
 986          if (!_mesa_is_desktop_gl(ctx))
 987             goto invalid_enum_error;
 988          CHECK_EXTENSION(EXT_depth_bounds_test);
 989          if (ctx->Depth.BoundsTest == state)
 990             return;
 991          FLUSH_VERTICES(ctx, ctx->DriverFlags.NewDepth ? 0 : _NEW_DEPTH);
 992          ctx->NewDriverState |= ctx->DriverFlags.NewDepth;
 993          ctx->Depth.BoundsTest = state;
 994          break;
 995
 996       case GL_DEPTH_CLAMP:
 997          if (!_mesa_has_ARB_depth_clamp(ctx) &&
 998              !_mesa_has_EXT_depth_clamp(ctx))
 999             goto invalid_enum_error;
1000          if (ctx->Transform.DepthClampNear == state &&
1001              ctx->Transform.DepthClampFar == state)
1002             return;
1003          FLUSH_VERTICES(ctx, ctx->DriverFlags.NewDepthClamp ? 0 :
1004                                                            _NEW_TRANSFORM);
1005          ctx->NewDriverState |= ctx->DriverFlags.NewDepthClamp;
1006          ctx->Transform.DepthClampNear = state;
1007          ctx->Transform.DepthClampFar = state;
1008          break;
1009
1010       case GL_DEPTH_CLAMP_NEAR_AMD:
1011          if (!_mesa_is_desktop_gl(ctx))
1012             goto invalid_enum_error;
1013          CHECK_EXTENSION(AMD_depth_clamp_separate);
1014          if (ctx->Transform.DepthClampNear == state)
1015             return;
1016          FLUSH_VERTICES(ctx, ctx->DriverFlags.NewDepthClamp ? 0 :
1017                                                            _NEW_TRANSFORM);
1018          ctx->NewDriverState |= ctx->DriverFlags.NewDepthClamp;
1019          ctx->Transform.DepthClampNear = state;
1020          break;
1021
1022       case GL_DEPTH_CLAMP_FAR_AMD:
1023          if (!_mesa_is_desktop_gl(ctx))
1024             goto invalid_enum_error;
1025          CHECK_EXTENSION(AMD_depth_clamp_separate);
1026          if (ctx->Transform.DepthClampFar == state)
1027             return;
1028          FLUSH_VERTICES(ctx, ctx->DriverFlags.NewDepthClamp ? 0 :
1029                                                            _NEW_TRANSFORM);
1030          ctx->NewDriverState |= ctx->DriverFlags.NewDepthClamp;
1031          ctx->Transform.DepthClampFar = state;
1032          break;
1033
1034       case GL_FRAGMENT_SHADER_ATI:
1035          if (ctx->API != API_OPENGL_COMPAT)
1036             goto invalid_enum_error;
1037         CHECK_EXTENSION(ATI_fragment_shader);
1038         if (ctx->ATIFragmentShader.Enabled == state)
1039            return;
1040         FLUSH_VERTICES(ctx, _NEW_PROGRAM);
1041         ctx->ATIFragmentShader.Enabled = state;
1042         break;
1043
1044       case GL_TEXTURE_CUBE_MAP_SEAMLESS:
1045          if (!_mesa_is_desktop_gl(ctx))
1046             goto invalid_enum_error;
1047          CHECK_EXTENSION(ARB_seamless_cube_map);
1048          if (ctx->Texture.CubeMapSeamless != state) {
1049             FLUSH_VERTICES(ctx, _NEW_TEXTURE_OBJECT);
1050             ctx->Texture.CubeMapSeamless = state;
1051          }
1052          break;
1053
1054       case GL_RASTERIZER_DISCARD:
1055          if (!_mesa_is_desktop_gl(ctx) && !_mesa_is_gles3(ctx))
1056             goto invalid_enum_error;
1057          CHECK_EXTENSION(EXT_transform_feedback);
1058          if (ctx->RasterDiscard != state) {
1059             FLUSH_VERTICES(ctx, 0);
1060             ctx->NewDriverState |= ctx->DriverFlags.NewRasterizerDiscard;
1061             ctx->RasterDiscard = state;
1062          }
1063          break;
1064
1065       case GL_TILE_RASTER_ORDER_FIXED_MESA:
1066          if (!_mesa_has_MESA_tile_raster_order(ctx))
1067             goto invalid_enum_error;
1068          if (ctx->TileRasterOrderFixed != state) {
1069             FLUSH_VERTICES(ctx, 0);
1070             ctx->NewDriverState |= ctx->DriverFlags.NewTileRasterOrder;
1071             ctx->TileRasterOrderFixed = state;
1072          }
1073          break;
1074
1075       case GL_TILE_RASTER_ORDER_INCREASING_X_MESA:
1076          if (!_mesa_has_MESA_tile_raster_order(ctx))
1077             goto invalid_enum_error;
1078          if (ctx->TileRasterOrderIncreasingX != state) {
1079             FLUSH_VERTICES(ctx, 0);
1080             ctx->NewDriverState |= ctx->DriverFlags.NewTileRasterOrder;
1081             ctx->TileRasterOrderIncreasingX = state;
1082          }
1083          break;
1084
1085       case GL_TILE_RASTER_ORDER_INCREASING_Y_MESA:
1086          if (!_mesa_has_MESA_tile_raster_order(ctx))
1087             goto invalid_enum_error;
1088          if (ctx->TileRasterOrderIncreasingY != state) {
1089             FLUSH_VERTICES(ctx, 0);
1090             ctx->NewDriverState |= ctx->DriverFlags.NewTileRasterOrder;
1091             ctx->TileRasterOrderIncreasingY = state;
1092          }
1093          break;
1094
1095       /* GL 3.1 primitive restart.  Note: this enum is different from
1096        * GL_PRIMITIVE_RESTART_NV (which is client state).
1097        */
1098       case GL_PRIMITIVE_RESTART:
1099          if (!_mesa_is_desktop_gl(ctx) || ctx->Version < 31) {
1100             goto invalid_enum_error;
1101          }
1102          if (ctx->Array.PrimitiveRestart != state) {
1103             FLUSH_VERTICES(ctx, 0);
1104             ctx->Array.PrimitiveRestart = state;
1105             update_derived_primitive_restart_state(ctx);
1106          }
1107          break;
1108
1109       case GL_PRIMITIVE_RESTART_FIXED_INDEX:
1110          if (!_mesa_is_gles3(ctx) && !_mesa_has_ARB_ES3_compatibility(ctx))
1111             goto invalid_enum_error;
1112          if (ctx->Array.PrimitiveRestartFixedIndex != state) {
1113             FLUSH_VERTICES(ctx, 0);
1114             ctx->Array.PrimitiveRestartFixedIndex = state;
1115             update_derived_primitive_restart_state(ctx);
1116          }
1117          break;
1118
1119       /* GL3.0 - GL_framebuffer_sRGB */
1120       case GL_FRAMEBUFFER_SRGB_EXT:
1121          if (!_mesa_has_EXT_framebuffer_sRGB(ctx) &&
1122              !_mesa_has_EXT_sRGB_write_control(ctx))
1123             goto invalid_enum_error;
1124          _mesa_set_framebuffer_srgb(ctx, state);
1125          return;
1126
1127       /* GL_OES_EGL_image_external */
1128       case GL_TEXTURE_EXTERNAL_OES:
1129          if (!_mesa_is_gles(ctx))
1130             goto invalid_enum_error;
1131          CHECK_EXTENSION(OES_EGL_image_external);
1132          if (!enable_texture(ctx, state, TEXTURE_EXTERNAL_BIT)) {
1133             return;
1134          }
1135          break;
1136
1137       /* ARB_texture_multisample */
1138       case GL_SAMPLE_MASK:
1139          if (!_mesa_has_ARB_texture_multisample(ctx) && !_mesa_is_gles31(ctx))
1140             goto invalid_enum_error;
1141          if (ctx->Multisample.SampleMask == state)
1142             return;
1143          FLUSH_VERTICES(ctx, ctx->DriverFlags.NewSampleMask ? 0 :
1144                                                          _NEW_MULTISAMPLE);
1145          ctx->NewDriverState |= ctx->DriverFlags.NewSampleMask;
1146          ctx->Multisample.SampleMask = state;
1147          break;
1148
1149       case GL_BLEND_ADVANCED_COHERENT_KHR:
1150          if (!_mesa_has_KHR_blend_equation_advanced_coherent(ctx))
1151             goto invalid_enum_error;
1152          if (ctx->Color.BlendCoherent == state)
1153             return;
1154          FLUSH_VERTICES(ctx, ctx->DriverFlags.NewBlend ? 0 : _NEW_COLOR);
1155          ctx->NewDriverState |= ctx->DriverFlags.NewBlend;
1156          ctx->Color.BlendCoherent = state;
1157          break;
1158
1159       default:
1160          goto invalid_enum_error;
1161    }
1162
1163    if (ctx->Driver.Enable) {
1164       ctx->Driver.Enable( ctx, cap, state );
1165    }
1166
1167    return;
1168
1169 invalid_enum_error:
1170    _mesa_error(ctx, GL_INVALID_ENUM, "gl%s(%s)",
1171                state ? "Enable" : "Disable", _mesa_enum_to_string(cap));
1172 }
1173
1174
1175 /**
1176  * Enable GL capability.  Called by glEnable()
1177  * \param cap  state to enable.
1178  */
1179 void GLAPIENTRY
1180 _mesa_Enable( GLenum cap )
1181 {
1182    GET_CURRENT_CONTEXT(ctx);
1183
1184    _mesa_set_enable( ctx, cap, GL_TRUE );
1185 }
1186
1187
1188 /**
1189  * Disable GL capability.  Called by glDisable()
1190  * \param cap  state to disable.
1191  */
1192 void GLAPIENTRY
1193 _mesa_Disable( GLenum cap )
1194 {
1195    GET_CURRENT_CONTEXT(ctx);
1196
1197    _mesa_set_enable( ctx, cap, GL_FALSE );
1198 }
1199
1200
1201
1202 /**
1203  * Enable/disable an indexed state var.
1204  */
1205 void
1206 _mesa_set_enablei(struct gl_context *ctx, GLenum cap,
1207                   GLuint index, GLboolean state)
1208 {
1209    assert(state == 0 || state == 1);
1210    switch (cap) {
1211    case GL_BLEND:
1212       if (!ctx->Extensions.EXT_draw_buffers2) {
1213          goto invalid_enum_error;
1214       }
1215       if (index >= ctx->Const.MaxDrawBuffers) {
1216          _mesa_error(ctx, GL_INVALID_VALUE, "%s(index=%u)",
1217                      state ? "glEnableIndexed" : "glDisableIndexed", index);
1218          return;
1219       }
1220       if (((ctx->Color.BlendEnabled >> index) & 1) != state) {
1221          GLbitfield enabled = ctx->Color.BlendEnabled;
1222
1223          if (state)
1224             enabled |= (1 << index);
1225          else
1226             enabled &= ~(1 << index);
1227
1228          _mesa_flush_vertices_for_blend_adv(ctx, enabled,
1229                                             ctx->Color._AdvancedBlendMode);
1230          ctx->Color.BlendEnabled = enabled;
1231       }
1232       break;
1233    case GL_SCISSOR_TEST:
1234       if (index >= ctx->Const.MaxViewports) {
1235          _mesa_error(ctx, GL_INVALID_VALUE, "%s(index=%u)",
1236                      state ? "glEnablei" : "glDisablei", index);
1237          return;
1238       }
1239       if (((ctx->Scissor.EnableFlags >> index) & 1) != state) {
1240          FLUSH_VERTICES(ctx,
1241                         ctx->DriverFlags.NewScissorTest ? 0 : _NEW_SCISSOR);
1242          ctx->NewDriverState |= ctx->DriverFlags.NewScissorTest;
1243          if (state)
1244             ctx->Scissor.EnableFlags |= (1 << index);
1245          else
1246             ctx->Scissor.EnableFlags &= ~(1 << index);
1247       }
1248       break;
1249    default:
1250       goto invalid_enum_error;
1251    }
1252    return;
1253
1254 invalid_enum_error:
1255     _mesa_error(ctx, GL_INVALID_ENUM, "%s(cap=%s)",
1256                 state ? "glEnablei" : "glDisablei",
1257                 _mesa_enum_to_string(cap));
1258 }
1259
1260
1261 void GLAPIENTRY
1262 _mesa_Disablei( GLenum cap, GLuint index )
1263 {
1264    GET_CURRENT_CONTEXT(ctx);
1265    _mesa_set_enablei(ctx, cap, index, GL_FALSE);
1266 }
1267
1268
1269 void GLAPIENTRY
1270 _mesa_Enablei( GLenum cap, GLuint index )
1271 {
1272    GET_CURRENT_CONTEXT(ctx);
1273    _mesa_set_enablei(ctx, cap, index, GL_TRUE);
1274 }
1275
1276
1277 GLboolean GLAPIENTRY
1278 _mesa_IsEnabledi( GLenum cap, GLuint index )
1279 {
1280    GET_CURRENT_CONTEXT(ctx);
1281    ASSERT_OUTSIDE_BEGIN_END_WITH_RETVAL(ctx, 0);
1282    switch (cap) {
1283    case GL_BLEND:
1284       if (index >= ctx->Const.MaxDrawBuffers) {
1285          _mesa_error(ctx, GL_INVALID_VALUE, "glIsEnabledIndexed(index=%u)",
1286                      index);
1287          return GL_FALSE;
1288       }
1289       return (ctx->Color.BlendEnabled >> index) & 1;
1290    case GL_SCISSOR_TEST:
1291       if (index >= ctx->Const.MaxViewports) {
1292          _mesa_error(ctx, GL_INVALID_VALUE, "glIsEnabledIndexed(index=%u)",
1293                      index);
1294          return GL_FALSE;
1295       }
1296       return (ctx->Scissor.EnableFlags >> index) & 1;
1297    default:
1298       _mesa_error(ctx, GL_INVALID_ENUM, "glIsEnabledIndexed(cap=%s)",
1299                   _mesa_enum_to_string(cap));
1300       return GL_FALSE;
1301    }
1302 }
1303
1304
1305
1306 /**
1307  * Helper function to determine whether a texture target is enabled.
1308  */
1309 static GLboolean
1310 is_texture_enabled(struct gl_context *ctx, GLbitfield bit)
1311 {
1312    const struct gl_fixedfunc_texture_unit *const texUnit =
1313       _mesa_get_current_fixedfunc_tex_unit(ctx);
1314
1315    if (!texUnit)
1316       return GL_FALSE;
1317
1318    return (texUnit->Enabled & bit) ? GL_TRUE : GL_FALSE;
1319 }
1320
1321
1322 /**
1323  * Return simple enable/disable state.
1324  *
1325  * \param cap  state variable to query.
1326  *
1327  * Returns the state of the specified capability from the current GL context.
1328  * For the capabilities associated with extensions verifies that those
1329  * extensions are effectively present before reporting.
1330  */
1331 GLboolean GLAPIENTRY
1332 _mesa_IsEnabled( GLenum cap )
1333 {
1334    GET_CURRENT_CONTEXT(ctx);
1335    ASSERT_OUTSIDE_BEGIN_END_WITH_RETVAL(ctx, 0);
1336
1337    switch (cap) {
1338       case GL_ALPHA_TEST:
1339          if (ctx->API != API_OPENGL_COMPAT && ctx->API != API_OPENGLES)
1340             goto invalid_enum_error;
1341          return ctx->Color.AlphaEnabled;
1342       case GL_AUTO_NORMAL:
1343          if (ctx->API != API_OPENGL_COMPAT)
1344             goto invalid_enum_error;
1345          return ctx->Eval.AutoNormal;
1346       case GL_BLEND:
1347          return ctx->Color.BlendEnabled & 1;  /* return state for buffer[0] */
1348       case GL_CLIP_DISTANCE0: /* aka GL_CLIP_PLANE0 */
1349       case GL_CLIP_DISTANCE1:
1350       case GL_CLIP_DISTANCE2:
1351       case GL_CLIP_DISTANCE3:
1352       case GL_CLIP_DISTANCE4:
1353       case GL_CLIP_DISTANCE5:
1354       case GL_CLIP_DISTANCE6:
1355       case GL_CLIP_DISTANCE7: {
1356          const GLuint p = cap - GL_CLIP_DISTANCE0;
1357
1358          if (p >= ctx->Const.MaxClipPlanes)
1359             goto invalid_enum_error;
1360
1361          return (ctx->Transform.ClipPlanesEnabled >> p) & 1;
1362       }
1363       case GL_COLOR_MATERIAL:
1364          if (ctx->API != API_OPENGL_COMPAT && ctx->API != API_OPENGLES)
1365             goto invalid_enum_error;
1366          return ctx->Light.ColorMaterialEnabled;
1367       case GL_CULL_FACE:
1368          return ctx->Polygon.CullFlag;
1369       case GL_DEBUG_OUTPUT:
1370       case GL_DEBUG_OUTPUT_SYNCHRONOUS_ARB:
1371          return (GLboolean) _mesa_get_debug_state_int(ctx, cap);
1372       case GL_DEPTH_TEST:
1373          return ctx->Depth.Test;
1374       case GL_DITHER:
1375          return ctx->Color.DitherFlag;
1376       case GL_FOG:
1377          if (ctx->API != API_OPENGL_COMPAT && ctx->API != API_OPENGLES)
1378             goto invalid_enum_error;
1379          return ctx->Fog.Enabled;
1380       case GL_LIGHTING:
1381          if (ctx->API != API_OPENGL_COMPAT && ctx->API != API_OPENGLES)
1382             goto invalid_enum_error;
1383          return ctx->Light.Enabled;
1384       case GL_LIGHT0:
1385       case GL_LIGHT1:
1386       case GL_LIGHT2:
1387       case GL_LIGHT3:
1388       case GL_LIGHT4:
1389       case GL_LIGHT5:
1390       case GL_LIGHT6:
1391       case GL_LIGHT7:
1392          if (ctx->API != API_OPENGL_COMPAT && ctx->API != API_OPENGLES)
1393             goto invalid_enum_error;
1394          return ctx->Light.Light[cap-GL_LIGHT0].Enabled;
1395       case GL_LINE_SMOOTH:
1396          if (!_mesa_is_desktop_gl(ctx) && ctx->API != API_OPENGLES)
1397             goto invalid_enum_error;
1398          return ctx->Line.SmoothFlag;
1399       case GL_LINE_STIPPLE:
1400          if (ctx->API != API_OPENGL_COMPAT)
1401             goto invalid_enum_error;
1402          return ctx->Line.StippleFlag;
1403       case GL_INDEX_LOGIC_OP:
1404          if (ctx->API != API_OPENGL_COMPAT)
1405             goto invalid_enum_error;
1406          return ctx->Color.IndexLogicOpEnabled;
1407       case GL_COLOR_LOGIC_OP:
1408          if (!_mesa_is_desktop_gl(ctx) && ctx->API != API_OPENGLES)
1409             goto invalid_enum_error;
1410          return ctx->Color.ColorLogicOpEnabled;
1411       case GL_MAP1_COLOR_4:
1412          if (ctx->API != API_OPENGL_COMPAT)
1413             goto invalid_enum_error;
1414          return ctx->Eval.Map1Color4;
1415       case GL_MAP1_INDEX:
1416          if (ctx->API != API_OPENGL_COMPAT)
1417             goto invalid_enum_error;
1418          return ctx->Eval.Map1Index;
1419       case GL_MAP1_NORMAL:
1420          if (ctx->API != API_OPENGL_COMPAT)
1421             goto invalid_enum_error;
1422          return ctx->Eval.Map1Normal;
1423       case GL_MAP1_TEXTURE_COORD_1:
1424          if (ctx->API != API_OPENGL_COMPAT)
1425             goto invalid_enum_error;
1426          return ctx->Eval.Map1TextureCoord1;
1427       case GL_MAP1_TEXTURE_COORD_2:
1428          if (ctx->API != API_OPENGL_COMPAT)
1429             goto invalid_enum_error;
1430          return ctx->Eval.Map1TextureCoord2;
1431       case GL_MAP1_TEXTURE_COORD_3:
1432          if (ctx->API != API_OPENGL_COMPAT)
1433             goto invalid_enum_error;
1434          return ctx->Eval.Map1TextureCoord3;
1435       case GL_MAP1_TEXTURE_COORD_4:
1436          if (ctx->API != API_OPENGL_COMPAT)
1437             goto invalid_enum_error;
1438          return ctx->Eval.Map1TextureCoord4;
1439       case GL_MAP1_VERTEX_3:
1440          if (ctx->API != API_OPENGL_COMPAT)
1441             goto invalid_enum_error;
1442          return ctx->Eval.Map1Vertex3;
1443       case GL_MAP1_VERTEX_4:
1444          if (ctx->API != API_OPENGL_COMPAT)
1445             goto invalid_enum_error;
1446          return ctx->Eval.Map1Vertex4;
1447       case GL_MAP2_COLOR_4:
1448          if (ctx->API != API_OPENGL_COMPAT)
1449             goto invalid_enum_error;
1450          return ctx->Eval.Map2Color4;
1451       case GL_MAP2_INDEX:
1452          if (ctx->API != API_OPENGL_COMPAT)
1453             goto invalid_enum_error;
1454          return ctx->Eval.Map2Index;
1455       case GL_MAP2_NORMAL:
1456          if (ctx->API != API_OPENGL_COMPAT)
1457             goto invalid_enum_error;
1458          return ctx->Eval.Map2Normal;
1459       case GL_MAP2_TEXTURE_COORD_1:
1460          if (ctx->API != API_OPENGL_COMPAT)
1461             goto invalid_enum_error;
1462          return ctx->Eval.Map2TextureCoord1;
1463       case GL_MAP2_TEXTURE_COORD_2:
1464          if (ctx->API != API_OPENGL_COMPAT)
1465             goto invalid_enum_error;
1466          return ctx->Eval.Map2TextureCoord2;
1467       case GL_MAP2_TEXTURE_COORD_3:
1468          if (ctx->API != API_OPENGL_COMPAT)
1469             goto invalid_enum_error;
1470          return ctx->Eval.Map2TextureCoord3;
1471       case GL_MAP2_TEXTURE_COORD_4:
1472          if (ctx->API != API_OPENGL_COMPAT)
1473             goto invalid_enum_error;
1474          return ctx->Eval.Map2TextureCoord4;
1475       case GL_MAP2_VERTEX_3:
1476          if (ctx->API != API_OPENGL_COMPAT)
1477             goto invalid_enum_error;
1478          return ctx->Eval.Map2Vertex3;
1479       case GL_MAP2_VERTEX_4:
1480          if (ctx->API != API_OPENGL_COMPAT)
1481             goto invalid_enum_error;
1482          return ctx->Eval.Map2Vertex4;
1483       case GL_NORMALIZE:
1484          if (ctx->API != API_OPENGL_COMPAT && ctx->API != API_OPENGLES)
1485             goto invalid_enum_error;
1486          return ctx->Transform.Normalize;
1487       case GL_POINT_SMOOTH:
1488          if (ctx->API != API_OPENGL_COMPAT && ctx->API != API_OPENGLES)
1489             goto invalid_enum_error;
1490          return ctx->Point.SmoothFlag;
1491       case GL_POLYGON_SMOOTH:
1492          if (!_mesa_is_desktop_gl(ctx))
1493             goto invalid_enum_error;
1494          return ctx->Polygon.SmoothFlag;
1495       case GL_POLYGON_STIPPLE:
1496          if (ctx->API != API_OPENGL_COMPAT)
1497             goto invalid_enum_error;
1498          return ctx->Polygon.StippleFlag;
1499       case GL_POLYGON_OFFSET_POINT:
1500          if (!_mesa_is_desktop_gl(ctx))
1501             goto invalid_enum_error;
1502          return ctx->Polygon.OffsetPoint;
1503       case GL_POLYGON_OFFSET_LINE:
1504          if (!_mesa_is_desktop_gl(ctx))
1505             goto invalid_enum_error;
1506          return ctx->Polygon.OffsetLine;
1507       case GL_POLYGON_OFFSET_FILL:
1508          return ctx->Polygon.OffsetFill;
1509       case GL_RESCALE_NORMAL_EXT:
1510          if (ctx->API != API_OPENGL_COMPAT && ctx->API != API_OPENGLES)
1511             goto invalid_enum_error;
1512          return ctx->Transform.RescaleNormals;
1513       case GL_SCISSOR_TEST:
1514          return ctx->Scissor.EnableFlags & 1;  /* return state for index 0 */
1515       case GL_STENCIL_TEST:
1516          return ctx->Stencil.Enabled;
1517       case GL_TEXTURE_1D:
1518          if (ctx->API != API_OPENGL_COMPAT)
1519             goto invalid_enum_error;
1520          return is_texture_enabled(ctx, TEXTURE_1D_BIT);
1521       case GL_TEXTURE_2D:
1522          if (ctx->API != API_OPENGL_COMPAT && ctx->API != API_OPENGLES)
1523             goto invalid_enum_error;
1524          return is_texture_enabled(ctx, TEXTURE_2D_BIT);
1525       case GL_TEXTURE_3D:
1526          if (ctx->API != API_OPENGL_COMPAT && ctx->API != API_OPENGLES)
1527             goto invalid_enum_error;
1528          return is_texture_enabled(ctx, TEXTURE_3D_BIT);
1529       case GL_TEXTURE_GEN_S:
1530       case GL_TEXTURE_GEN_T:
1531       case GL_TEXTURE_GEN_R:
1532       case GL_TEXTURE_GEN_Q:
1533          {
1534             const struct gl_fixedfunc_texture_unit *texUnit =
1535                get_texcoord_unit(ctx);
1536
1537             if (ctx->API != API_OPENGL_COMPAT)
1538                goto invalid_enum_error;
1539
1540             if (texUnit) {
1541                GLbitfield coordBit = S_BIT << (cap - GL_TEXTURE_GEN_S);
1542                return (texUnit->TexGenEnabled & coordBit) ? GL_TRUE : GL_FALSE;
1543             }
1544          }
1545          return GL_FALSE;
1546       case GL_TEXTURE_GEN_STR_OES:
1547          {
1548             const struct gl_fixedfunc_texture_unit *texUnit =
1549                get_texcoord_unit(ctx);
1550
1551             if (ctx->API != API_OPENGLES)
1552                goto invalid_enum_error;
1553
1554             if (texUnit) {
1555                return (texUnit->TexGenEnabled & STR_BITS) == STR_BITS
1556                   ? GL_TRUE : GL_FALSE;
1557             }
1558          }
1559
1560       /* client-side state */
1561       case GL_VERTEX_ARRAY:
1562          if (ctx->API != API_OPENGL_COMPAT && ctx->API != API_OPENGLES)
1563             goto invalid_enum_error;
1564          return !!(ctx->Array.VAO->Enabled & VERT_BIT_POS);
1565       case GL_NORMAL_ARRAY:
1566          if (ctx->API != API_OPENGL_COMPAT && ctx->API != API_OPENGLES)
1567             goto invalid_enum_error;
1568          return !!(ctx->Array.VAO->Enabled & VERT_BIT_NORMAL);
1569       case GL_COLOR_ARRAY:
1570          if (ctx->API != API_OPENGL_COMPAT && ctx->API != API_OPENGLES)
1571             goto invalid_enum_error;
1572          return !!(ctx->Array.VAO->Enabled & VERT_BIT_COLOR0);
1573       case GL_INDEX_ARRAY:
1574          if (ctx->API != API_OPENGL_COMPAT)
1575             goto invalid_enum_error;
1576          return !!(ctx->Array.VAO->Enabled & VERT_BIT_COLOR_INDEX);
1577       case GL_TEXTURE_COORD_ARRAY:
1578          if (ctx->API != API_OPENGL_COMPAT && ctx->API != API_OPENGLES)
1579             goto invalid_enum_error;
1580          return !!(ctx->Array.VAO->Enabled &
1581                    VERT_BIT_TEX(ctx->Array.ActiveTexture));
1582       case GL_EDGE_FLAG_ARRAY:
1583          if (ctx->API != API_OPENGL_COMPAT)
1584             goto invalid_enum_error;
1585          return !!(ctx->Array.VAO->Enabled & VERT_BIT_EDGEFLAG);
1586       case GL_FOG_COORDINATE_ARRAY_EXT:
1587          if (ctx->API != API_OPENGL_COMPAT)
1588             goto invalid_enum_error;
1589          return !!(ctx->Array.VAO->Enabled & VERT_BIT_FOG);
1590       case GL_SECONDARY_COLOR_ARRAY_EXT:
1591          if (ctx->API != API_OPENGL_COMPAT)
1592             goto invalid_enum_error;
1593          return !!(ctx->Array.VAO->Enabled & VERT_BIT_COLOR1);
1594       case GL_POINT_SIZE_ARRAY_OES:
1595          if (ctx->API != API_OPENGLES)
1596             goto invalid_enum_error;
1597          return !!(ctx->Array.VAO->Enabled & VERT_BIT_POINT_SIZE);
1598
1599       /* GL_ARB_texture_cube_map */
1600       case GL_TEXTURE_CUBE_MAP:
1601          if (!_mesa_has_ARB_texture_cube_map(ctx) &&
1602              !_mesa_has_OES_texture_cube_map(ctx))
1603             goto invalid_enum_error;
1604          return is_texture_enabled(ctx, TEXTURE_CUBE_BIT);
1605
1606       /* GL_EXT_secondary_color */
1607       case GL_COLOR_SUM_EXT:
1608          if (ctx->API != API_OPENGL_COMPAT)
1609             goto invalid_enum_error;
1610          return ctx->Fog.ColorSumEnabled;
1611
1612       /* GL_ARB_multisample */
1613       case GL_MULTISAMPLE_ARB:
1614          if (!_mesa_is_desktop_gl(ctx) && ctx->API != API_OPENGLES)
1615             goto invalid_enum_error;
1616          return ctx->Multisample.Enabled;
1617       case GL_SAMPLE_ALPHA_TO_COVERAGE_ARB:
1618          return ctx->Multisample.SampleAlphaToCoverage;
1619       case GL_SAMPLE_ALPHA_TO_ONE_ARB:
1620          if (!_mesa_is_desktop_gl(ctx) && ctx->API != API_OPENGLES)
1621             goto invalid_enum_error;
1622          return ctx->Multisample.SampleAlphaToOne;
1623       case GL_SAMPLE_COVERAGE_ARB:
1624          return ctx->Multisample.SampleCoverage;
1625       case GL_SAMPLE_COVERAGE_INVERT_ARB:
1626          if (!_mesa_is_desktop_gl(ctx))
1627             goto invalid_enum_error;
1628          return ctx->Multisample.SampleCoverageInvert;
1629
1630       /* GL_IBM_rasterpos_clip */
1631       case GL_RASTER_POSITION_UNCLIPPED_IBM:
1632          if (ctx->API != API_OPENGL_COMPAT)
1633             goto invalid_enum_error;
1634          return ctx->Transform.RasterPositionUnclipped;
1635
1636       /* GL_NV_point_sprite */
1637       case GL_POINT_SPRITE_NV:
1638          if (ctx->API != API_OPENGL_COMPAT && ctx->API != API_OPENGLES)
1639             goto invalid_enum_error;
1640          CHECK_EXTENSION2(NV_point_sprite, ARB_point_sprite)
1641          return ctx->Point.PointSprite;
1642
1643       case GL_VERTEX_PROGRAM_ARB:
1644          if (ctx->API != API_OPENGL_COMPAT)
1645             goto invalid_enum_error;
1646          CHECK_EXTENSION(ARB_vertex_program);
1647          return ctx->VertexProgram.Enabled;
1648       case GL_VERTEX_PROGRAM_POINT_SIZE_ARB:
1649          /* This was added with ARB_vertex_program, but it is also used with
1650           * GLSL vertex shaders on desktop.
1651           */
1652          if (!_mesa_is_desktop_gl(ctx))
1653             goto invalid_enum_error;
1654          CHECK_EXTENSION(ARB_vertex_program);
1655          return ctx->VertexProgram.PointSizeEnabled;
1656       case GL_VERTEX_PROGRAM_TWO_SIDE_ARB:
1657          if (ctx->API != API_OPENGL_COMPAT)
1658             goto invalid_enum_error;
1659          CHECK_EXTENSION(ARB_vertex_program);
1660          return ctx->VertexProgram.TwoSideEnabled;
1661
1662       /* GL_NV_texture_rectangle */
1663       case GL_TEXTURE_RECTANGLE_NV:
1664          if (ctx->API != API_OPENGL_COMPAT)
1665             goto invalid_enum_error;
1666          CHECK_EXTENSION(NV_texture_rectangle);
1667          return is_texture_enabled(ctx, TEXTURE_RECT_BIT);
1668
1669       /* GL_EXT_stencil_two_side */
1670       case GL_STENCIL_TEST_TWO_SIDE_EXT:
1671          if (ctx->API != API_OPENGL_COMPAT)
1672             goto invalid_enum_error;
1673          CHECK_EXTENSION(EXT_stencil_two_side);
1674          return ctx->Stencil.TestTwoSide;
1675
1676       case GL_FRAGMENT_PROGRAM_ARB:
1677          if (!_mesa_has_ARB_fragment_program(ctx))
1678             goto invalid_enum_error;
1679          return ctx->FragmentProgram.Enabled;
1680
1681       /* GL_EXT_depth_bounds_test */
1682       case GL_DEPTH_BOUNDS_TEST_EXT:
1683          if (!_mesa_is_desktop_gl(ctx))
1684             goto invalid_enum_error;
1685          CHECK_EXTENSION(EXT_depth_bounds_test);
1686          return ctx->Depth.BoundsTest;
1687
1688       /* GL_ARB_depth_clamp */
1689       case GL_DEPTH_CLAMP:
1690          if (!_mesa_has_ARB_depth_clamp(ctx) &&
1691              !_mesa_has_EXT_depth_clamp(ctx))
1692             goto invalid_enum_error;
1693          return ctx->Transform.DepthClampNear ||
1694                 ctx->Transform.DepthClampFar;
1695
1696       case GL_DEPTH_CLAMP_NEAR_AMD:
1697          if (!_mesa_is_desktop_gl(ctx))
1698             goto invalid_enum_error;
1699          CHECK_EXTENSION(AMD_depth_clamp_separate);
1700          return ctx->Transform.DepthClampNear;
1701
1702       case GL_DEPTH_CLAMP_FAR_AMD:
1703          if (!_mesa_is_desktop_gl(ctx))
1704             goto invalid_enum_error;
1705          CHECK_EXTENSION(AMD_depth_clamp_separate);
1706          return ctx->Transform.DepthClampFar;
1707
1708       case GL_FRAGMENT_SHADER_ATI:
1709          if (ctx->API != API_OPENGL_COMPAT)
1710             goto invalid_enum_error;
1711          CHECK_EXTENSION(ATI_fragment_shader);
1712          return ctx->ATIFragmentShader.Enabled;
1713
1714       case GL_TEXTURE_CUBE_MAP_SEAMLESS:
1715          if (!_mesa_is_desktop_gl(ctx))
1716             goto invalid_enum_error;
1717          CHECK_EXTENSION(ARB_seamless_cube_map);
1718          return ctx->Texture.CubeMapSeamless;
1719
1720       case GL_RASTERIZER_DISCARD:
1721          if (!_mesa_is_desktop_gl(ctx) && !_mesa_is_gles3(ctx))
1722             goto invalid_enum_error;
1723          CHECK_EXTENSION(EXT_transform_feedback);
1724          return ctx->RasterDiscard;
1725
1726       /* GL_NV_primitive_restart */
1727       case GL_PRIMITIVE_RESTART_NV:
1728          if (!_mesa_has_NV_primitive_restart(ctx))
1729             goto invalid_enum_error;
1730          return ctx->Array.PrimitiveRestart;
1731
1732       /* GL 3.1 primitive restart */
1733       case GL_PRIMITIVE_RESTART:
1734          if (!_mesa_is_desktop_gl(ctx) || ctx->Version < 31) {
1735             goto invalid_enum_error;
1736          }
1737          return ctx->Array.PrimitiveRestart;
1738
1739       case GL_PRIMITIVE_RESTART_FIXED_INDEX:
1740          if (!_mesa_is_gles3(ctx) && !_mesa_has_ARB_ES3_compatibility(ctx))
1741             goto invalid_enum_error;
1742          return ctx->Array.PrimitiveRestartFixedIndex;
1743
1744       /* GL3.0 - GL_framebuffer_sRGB */
1745       case GL_FRAMEBUFFER_SRGB_EXT:
1746          if (!_mesa_has_EXT_framebuffer_sRGB(ctx) &&
1747              !_mesa_has_EXT_sRGB_write_control(ctx))
1748             goto invalid_enum_error;
1749          return ctx->Color.sRGBEnabled;
1750
1751       /* GL_OES_EGL_image_external */
1752       case GL_TEXTURE_EXTERNAL_OES:
1753          if (!_mesa_is_gles(ctx))
1754             goto invalid_enum_error;
1755          CHECK_EXTENSION(OES_EGL_image_external);
1756          return is_texture_enabled(ctx, TEXTURE_EXTERNAL_BIT);
1757
1758       /* ARB_texture_multisample */
1759       case GL_SAMPLE_MASK:
1760          if (!_mesa_has_ARB_texture_multisample(ctx) && !_mesa_is_gles31(ctx))
1761             goto invalid_enum_error;
1762          return ctx->Multisample.SampleMask;
1763
1764       /* ARB_sample_shading */
1765       case GL_SAMPLE_SHADING:
1766          if (!_mesa_has_ARB_sample_shading(ctx) && !_mesa_is_gles3(ctx))
1767             goto invalid_enum_error;
1768          return ctx->Multisample.SampleShading;
1769
1770       case GL_BLEND_ADVANCED_COHERENT_KHR:
1771          if (!_mesa_has_KHR_blend_equation_advanced_coherent(ctx))
1772             goto invalid_enum_error;
1773          return ctx->Color.BlendCoherent;
1774
1775       case GL_CONSERVATIVE_RASTERIZATION_INTEL:
1776          if (!_mesa_has_INTEL_conservative_rasterization(ctx))
1777             goto invalid_enum_error;
1778          return ctx->IntelConservativeRasterization;
1779
1780       case GL_CONSERVATIVE_RASTERIZATION_NV:
1781          if (!_mesa_has_NV_conservative_raster(ctx))
1782             goto invalid_enum_error;
1783          return ctx->ConservativeRasterization;
1784
1785       case GL_TILE_RASTER_ORDER_FIXED_MESA:
1786          if (!_mesa_has_MESA_tile_raster_order(ctx))
1787             goto invalid_enum_error;
1788          return ctx->TileRasterOrderFixed;
1789
1790       case GL_TILE_RASTER_ORDER_INCREASING_X_MESA:
1791          if (!_mesa_has_MESA_tile_raster_order(ctx))
1792             goto invalid_enum_error;
1793          return ctx->TileRasterOrderIncreasingX;
1794
1795       case GL_TILE_RASTER_ORDER_INCREASING_Y_MESA:
1796          if (!_mesa_has_MESA_tile_raster_order(ctx))
1797             goto invalid_enum_error;
1798          return ctx->TileRasterOrderIncreasingY;
1799
1800       default:
1801          goto invalid_enum_error;
1802    }
1803
1804    return GL_FALSE;
1805
1806 invalid_enum_error:
1807    _mesa_error(ctx, GL_INVALID_ENUM, "glIsEnabled(%s)",
1808                _mesa_enum_to_string(cap));
1809    return GL_FALSE;
1810 }