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  * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
  25  * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
  26  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  27  */
  28
  29
  30 #include "glheader.h"
  31 #include "clip.h"
  32 #include "context.h"
  33 #include "enable.h"
  34 #include "light.h"
  35 #include "simple_list.h"
  36 #include "mfeatures.h"
  37 #include "mtypes.h"
  38 #include "enums.h"
  39 #include "api_arrayelt.h"
  40 #include "texstate.h"
  41
  42
  43
  44 #define CHECK_EXTENSION(EXTNAME, CAP)                                   \
  45    if (!ctx->Extensions.EXTNAME) {                                      \
  46       goto invalid_enum_error;                                          \
  47    }
  48
  49
  50 /**
  51  * Helper to enable/disable client-side state.
  52  */
  53 static void
  54 client_state(struct gl_context *ctx, GLenum cap, GLboolean state)
  55 {
  56    struct gl_array_object *arrayObj = ctx->Array.ArrayObj;
  57    GLuint flag;
  58    GLboolean *var;
  59
  60    switch (cap) {
  61       case GL_VERTEX_ARRAY:
  62          var = &arrayObj->Vertex.Enabled;
  63          flag = _NEW_ARRAY_VERTEX;
  64          break;
  65       case GL_NORMAL_ARRAY:
  66          var = &arrayObj->Normal.Enabled;
  67          flag = _NEW_ARRAY_NORMAL;
  68          break;
  69       case GL_COLOR_ARRAY:
  70          var = &arrayObj->Color.Enabled;
  71          flag = _NEW_ARRAY_COLOR0;
  72          break;
  73       case GL_INDEX_ARRAY:
  74          var = &arrayObj->Index.Enabled;
  75          flag = _NEW_ARRAY_INDEX;
  76          break;
  77       case GL_TEXTURE_COORD_ARRAY:
  78          var = &arrayObj->TexCoord[ctx->Array.ActiveTexture].Enabled;
  79          flag = _NEW_ARRAY_TEXCOORD(ctx->Array.ActiveTexture);
  80          break;
  81       case GL_EDGE_FLAG_ARRAY:
  82          var = &arrayObj->EdgeFlag.Enabled;
  83          flag = _NEW_ARRAY_EDGEFLAG;
  84          break;
  85       case GL_FOG_COORDINATE_ARRAY_EXT:
  86          var = &arrayObj->FogCoord.Enabled;
  87          flag = _NEW_ARRAY_FOGCOORD;
  88          break;
  89       case GL_SECONDARY_COLOR_ARRAY_EXT:
  90          var = &arrayObj->SecondaryColor.Enabled;
  91          flag = _NEW_ARRAY_COLOR1;
  92          break;
  93
  94 #if FEATURE_point_size_array
  95       case GL_POINT_SIZE_ARRAY_OES:
  96          var = &arrayObj->PointSize.Enabled;
  97          flag = _NEW_ARRAY_POINT_SIZE;
  98          break;
  99 #endif
 100
 101 #if FEATURE_NV_vertex_program
 102       case GL_VERTEX_ATTRIB_ARRAY0_NV:
 103       case GL_VERTEX_ATTRIB_ARRAY1_NV:
 104       case GL_VERTEX_ATTRIB_ARRAY2_NV:
 105       case GL_VERTEX_ATTRIB_ARRAY3_NV:
 106       case GL_VERTEX_ATTRIB_ARRAY4_NV:
 107       case GL_VERTEX_ATTRIB_ARRAY5_NV:
 108       case GL_VERTEX_ATTRIB_ARRAY6_NV:
 109       case GL_VERTEX_ATTRIB_ARRAY7_NV:
 110       case GL_VERTEX_ATTRIB_ARRAY8_NV:
 111       case GL_VERTEX_ATTRIB_ARRAY9_NV:
 112       case GL_VERTEX_ATTRIB_ARRAY10_NV:
 113       case GL_VERTEX_ATTRIB_ARRAY11_NV:
 114       case GL_VERTEX_ATTRIB_ARRAY12_NV:
 115       case GL_VERTEX_ATTRIB_ARRAY13_NV:
 116       case GL_VERTEX_ATTRIB_ARRAY14_NV:
 117       case GL_VERTEX_ATTRIB_ARRAY15_NV:
 118          CHECK_EXTENSION(NV_vertex_program, cap);
 119          {
 120             GLint n = (GLint) cap - GL_VERTEX_ATTRIB_ARRAY0_NV;
 121             ASSERT(n < Elements(ctx->Array.ArrayObj->VertexAttrib));
 122             var = &arrayObj->VertexAttrib[n].Enabled;
 123             flag = _NEW_ARRAY_ATTRIB(n);
 124          }
 125          break;
 126 #endif /* FEATURE_NV_vertex_program */
 127
 128       /* GL_NV_primitive_restart */
 129       case GL_PRIMITIVE_RESTART_NV:
 130          if (!ctx->Extensions.NV_primitive_restart) {
 131             goto invalid_enum_error;
 132          }
 133          var = &ctx->Array.PrimitiveRestart;
 134          flag = 0;
 135          break;
 136
 137       default:
 138          goto invalid_enum_error;
 139    }
 140
 141    if (*var == state)
 142       return;
 143
 144    FLUSH_VERTICES(ctx, _NEW_ARRAY);
 145    ctx->Array.NewState |= flag;
 146
 147    _ae_invalidate_state(ctx, _NEW_ARRAY);
 148
 149    *var = state;
 150
 151    if (state)
 152       ctx->Array.ArrayObj->_Enabled |= flag;
 153    else
 154       ctx->Array.ArrayObj->_Enabled &= ~flag;
 155
 156    if (ctx->Driver.Enable) {
 157       ctx->Driver.Enable( ctx, cap, state );
 158    }
 159
 160    return;
 161
 162 invalid_enum_error:
 163    _mesa_error(ctx, GL_INVALID_ENUM, "gl%sClientState(0x%x)",
 164                state ? "Enable" : "Disable", cap);
 165 }
 166
 167
 168 /**
 169  * Enable GL capability.
 170  * \param cap  state to enable/disable.
 171  *
 172  * Get's the current context, assures that we're outside glBegin()/glEnd() and
 173  * calls client_state().
 174  */
 175 void GLAPIENTRY
 176 _mesa_EnableClientState( GLenum cap )
 177 {
 178    GET_CURRENT_CONTEXT(ctx);
 179    ASSERT_OUTSIDE_BEGIN_END(ctx);
 180    client_state( ctx, cap, GL_TRUE );
 181 }
 182
 183
 184 /**
 185  * Disable GL capability.
 186  * \param cap  state to enable/disable.
 187  *
 188  * Get's the current context, assures that we're outside glBegin()/glEnd() and
 189  * calls client_state().
 190  */
 191 void GLAPIENTRY
 192 _mesa_DisableClientState( GLenum cap )
 193 {
 194    GET_CURRENT_CONTEXT(ctx);
 195    ASSERT_OUTSIDE_BEGIN_END(ctx);
 196    client_state( ctx, cap, GL_FALSE );
 197 }
 198
 199
 200 #undef CHECK_EXTENSION
 201 #define CHECK_EXTENSION(EXTNAME, CAP)                                   \
 202    if (!ctx->Extensions.EXTNAME) {                                      \
 203       goto invalid_enum_error;                                          \
 204    }
 205
 206 #define CHECK_EXTENSION2(EXT1, EXT2, CAP)                               \
 207    if (!ctx->Extensions.EXT1 && !ctx->Extensions.EXT2) {                \
 208       goto invalid_enum_error;                                          \
 209    }
 210
 211
 212
 213 /**
 214  * Return pointer to current texture unit for setting/getting coordinate
 215  * state.
 216  * Note that we'll set GL_INVALID_OPERATION and return NULL if the active
 217  * texture unit is higher than the number of supported coordinate units.
 218  */
 219 static struct gl_texture_unit *
 220 get_texcoord_unit(struct gl_context *ctx)
 221 {
 222    if (ctx->Texture.CurrentUnit >= ctx->Const.MaxTextureCoordUnits) {
 223       _mesa_error(ctx, GL_INVALID_OPERATION, "glEnable/Disable(texcoord unit)");
 224       return NULL;
 225    }
 226    else {
 227       return &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
 228    }
 229 }
 230
 231
 232 /**
 233  * Helper function to enable or disable a texture target.
 234  * \param bit  one of the TEXTURE_x_BIT values
 235  * \return GL_TRUE if state is changing or GL_FALSE if no change
 236  */
 237 static GLboolean
 238 enable_texture(struct gl_context *ctx, GLboolean state, GLbitfield texBit)
 239 {
 240    struct gl_texture_unit *texUnit = _mesa_get_current_tex_unit(ctx);
 241    const GLbitfield newenabled = state
 242       ? (texUnit->Enabled | texBit) : (texUnit->Enabled & ~texBit);
 243
 244    if (texUnit->Enabled == newenabled)
 245        return GL_FALSE;
 246
 247    FLUSH_VERTICES(ctx, _NEW_TEXTURE);
 248    texUnit->Enabled = newenabled;
 249    return GL_TRUE;
 250 }
 251
 252
 253 /**
 254  * Helper function to enable or disable state.
 255  *
 256  * \param ctx GL context.
 257  * \param cap  the state to enable/disable
 258  * \param state whether to enable or disable the specified capability.
 259  *
 260  * Updates the current context and flushes the vertices as needed. For
 261  * capabilities associated with extensions it verifies that those extensions
 262  * are effectivly present before updating. Notifies the driver via
 263  * dd_function_table::Enable.
 264  */
 265 void
 266 _mesa_set_enable(struct gl_context *ctx, GLenum cap, GLboolean state)
 267 {
 268    if (MESA_VERBOSE & VERBOSE_API)
 269       _mesa_debug(ctx, "%s %s (newstate is %x)\n",
 270                   state ? "glEnable" : "glDisable",
 271                   _mesa_lookup_enum_by_nr(cap),
 272                   ctx->NewState);
 273
 274    switch (cap) {
 275       case GL_ALPHA_TEST:
 276          if (ctx->Color.AlphaEnabled == state)
 277             return;
 278          FLUSH_VERTICES(ctx, _NEW_COLOR);
 279          ctx->Color.AlphaEnabled = state;
 280          break;
 281       case GL_AUTO_NORMAL:
 282          if (ctx->Eval.AutoNormal == state)
 283             return;
 284          FLUSH_VERTICES(ctx, _NEW_EVAL);
 285          ctx->Eval.AutoNormal = state;
 286          break;
 287       case GL_BLEND:
 288          {
 289             GLbitfield newEnabled =
 290                state * ((1 << ctx->Const.MaxDrawBuffers) - 1);
 291             if (newEnabled != ctx->Color.BlendEnabled) {
 292                FLUSH_VERTICES(ctx, _NEW_COLOR);
 293                ctx->Color.BlendEnabled = newEnabled;
 294             }
 295          }
 296          break;
 297 #if FEATURE_userclip
 298       case GL_CLIP_PLANE0:
 299       case GL_CLIP_PLANE1:
 300       case GL_CLIP_PLANE2:
 301       case GL_CLIP_PLANE3:
 302       case GL_CLIP_PLANE4:
 303       case GL_CLIP_PLANE5:
 304          {
 305             const GLuint p = cap - GL_CLIP_PLANE0;
 306
 307             if ((ctx->Transform.ClipPlanesEnabled & (1 << p))
 308                 == ((GLuint) state << p))
 309                return;
 310
 311             FLUSH_VERTICES(ctx, _NEW_TRANSFORM);
 312
 313             if (state) {
 314                ctx->Transform.ClipPlanesEnabled |= (1 << p);
 315                _mesa_update_clip_plane(ctx, p);
 316             }
 317             else {
 318                ctx->Transform.ClipPlanesEnabled &= ~(1 << p);
 319             }
 320          }
 321          break;
 322 #endif
 323       case GL_COLOR_MATERIAL:
 324          if (ctx->Light.ColorMaterialEnabled == state)
 325             return;
 326          FLUSH_VERTICES(ctx, _NEW_LIGHT);
 327          FLUSH_CURRENT(ctx, 0);
 328          ctx->Light.ColorMaterialEnabled = state;
 329          if (state) {
 330             _mesa_update_color_material( ctx,
 331                                   ctx->Current.Attrib[VERT_ATTRIB_COLOR0] );
 332          }
 333          break;
 334       case GL_CULL_FACE:
 335          if (ctx->Polygon.CullFlag == state)
 336             return;
 337          FLUSH_VERTICES(ctx, _NEW_POLYGON);
 338          ctx->Polygon.CullFlag = state;
 339          break;
 340       case GL_DEPTH_TEST:
 341          if (ctx->Depth.Test == state)
 342             return;
 343          FLUSH_VERTICES(ctx, _NEW_DEPTH);
 344          ctx->Depth.Test = state;
 345          break;
 346       case GL_DITHER:
 347          if (ctx->Color.DitherFlag == state)
 348             return;
 349          FLUSH_VERTICES(ctx, _NEW_COLOR);
 350          ctx->Color.DitherFlag = state;
 351          break;
 352       case GL_FOG:
 353          if (ctx->Fog.Enabled == state)
 354             return;
 355          FLUSH_VERTICES(ctx, _NEW_FOG);
 356          ctx->Fog.Enabled = state;
 357          break;
 358       case GL_LIGHT0:
 359       case GL_LIGHT1:
 360       case GL_LIGHT2:
 361       case GL_LIGHT3:
 362       case GL_LIGHT4:
 363       case GL_LIGHT5:
 364       case GL_LIGHT6:
 365       case GL_LIGHT7:
 366          if (ctx->Light.Light[cap-GL_LIGHT0].Enabled == state)
 367             return;
 368          FLUSH_VERTICES(ctx, _NEW_LIGHT);
 369          ctx->Light.Light[cap-GL_LIGHT0].Enabled = state;
 370          if (state) {
 371             insert_at_tail(&ctx->Light.EnabledList,
 372                            &ctx->Light.Light[cap-GL_LIGHT0]);
 373          }
 374          else {
 375             remove_from_list(&ctx->Light.Light[cap-GL_LIGHT0]);
 376          }
 377          break;
 378       case GL_LIGHTING:
 379          if (ctx->Light.Enabled == state)
 380             return;
 381          FLUSH_VERTICES(ctx, _NEW_LIGHT);
 382          ctx->Light.Enabled = state;
 383          if (ctx->Light.Enabled && ctx->Light.Model.TwoSide)
 384             ctx->_TriangleCaps |= DD_TRI_LIGHT_TWOSIDE;
 385          else
 386             ctx->_TriangleCaps &= ~DD_TRI_LIGHT_TWOSIDE;
 387          break;
 388       case GL_LINE_SMOOTH:
 389          if (ctx->Line.SmoothFlag == state)
 390             return;
 391          FLUSH_VERTICES(ctx, _NEW_LINE);
 392          ctx->Line.SmoothFlag = state;
 393          ctx->_TriangleCaps ^= DD_LINE_SMOOTH;
 394          break;
 395       case GL_LINE_STIPPLE:
 396          if (ctx->Line.StippleFlag == state)
 397             return;
 398          FLUSH_VERTICES(ctx, _NEW_LINE);
 399          ctx->Line.StippleFlag = state;
 400          ctx->_TriangleCaps ^= DD_LINE_STIPPLE;
 401          break;
 402       case GL_INDEX_LOGIC_OP:
 403          if (ctx->Color.IndexLogicOpEnabled == state)
 404             return;
 405          FLUSH_VERTICES(ctx, _NEW_COLOR);
 406          ctx->Color.IndexLogicOpEnabled = state;
 407          break;
 408       case GL_COLOR_LOGIC_OP:
 409          if (ctx->Color.ColorLogicOpEnabled == state)
 410             return;
 411          FLUSH_VERTICES(ctx, _NEW_COLOR);
 412          ctx->Color.ColorLogicOpEnabled = state;
 413          break;
 414       case GL_MAP1_COLOR_4:
 415          if (ctx->Eval.Map1Color4 == state)
 416             return;
 417          FLUSH_VERTICES(ctx, _NEW_EVAL);
 418          ctx->Eval.Map1Color4 = state;
 419          break;
 420       case GL_MAP1_INDEX:
 421          if (ctx->Eval.Map1Index == state)
 422             return;
 423          FLUSH_VERTICES(ctx, _NEW_EVAL);
 424          ctx->Eval.Map1Index = state;
 425          break;
 426       case GL_MAP1_NORMAL:
 427          if (ctx->Eval.Map1Normal == state)
 428             return;
 429          FLUSH_VERTICES(ctx, _NEW_EVAL);
 430          ctx->Eval.Map1Normal = state;
 431          break;
 432       case GL_MAP1_TEXTURE_COORD_1:
 433          if (ctx->Eval.Map1TextureCoord1 == state)
 434             return;
 435          FLUSH_VERTICES(ctx, _NEW_EVAL);
 436          ctx->Eval.Map1TextureCoord1 = state;
 437          break;
 438       case GL_MAP1_TEXTURE_COORD_2:
 439          if (ctx->Eval.Map1TextureCoord2 == state)
 440             return;
 441          FLUSH_VERTICES(ctx, _NEW_EVAL);
 442          ctx->Eval.Map1TextureCoord2 = state;
 443          break;
 444       case GL_MAP1_TEXTURE_COORD_3:
 445          if (ctx->Eval.Map1TextureCoord3 == state)
 446             return;
 447          FLUSH_VERTICES(ctx, _NEW_EVAL);
 448          ctx->Eval.Map1TextureCoord3 = state;
 449          break;
 450       case GL_MAP1_TEXTURE_COORD_4:
 451          if (ctx->Eval.Map1TextureCoord4 == state)
 452             return;
 453          FLUSH_VERTICES(ctx, _NEW_EVAL);
 454          ctx->Eval.Map1TextureCoord4 = state;
 455          break;
 456       case GL_MAP1_VERTEX_3:
 457          if (ctx->Eval.Map1Vertex3 == state)
 458             return;
 459          FLUSH_VERTICES(ctx, _NEW_EVAL);
 460          ctx->Eval.Map1Vertex3 = state;
 461          break;
 462       case GL_MAP1_VERTEX_4:
 463          if (ctx->Eval.Map1Vertex4 == state)
 464             return;
 465          FLUSH_VERTICES(ctx, _NEW_EVAL);
 466          ctx->Eval.Map1Vertex4 = state;
 467          break;
 468       case GL_MAP2_COLOR_4:
 469          if (ctx->Eval.Map2Color4 == state)
 470             return;
 471          FLUSH_VERTICES(ctx, _NEW_EVAL);
 472          ctx->Eval.Map2Color4 = state;
 473          break;
 474       case GL_MAP2_INDEX:
 475          if (ctx->Eval.Map2Index == state)
 476             return;
 477          FLUSH_VERTICES(ctx, _NEW_EVAL);
 478          ctx->Eval.Map2Index = state;
 479          break;
 480       case GL_MAP2_NORMAL:
 481          if (ctx->Eval.Map2Normal == state)
 482             return;
 483          FLUSH_VERTICES(ctx, _NEW_EVAL);
 484          ctx->Eval.Map2Normal = state;
 485          break;
 486       case GL_MAP2_TEXTURE_COORD_1:
 487          if (ctx->Eval.Map2TextureCoord1 == state)
 488             return;
 489          FLUSH_VERTICES(ctx, _NEW_EVAL);
 490          ctx->Eval.Map2TextureCoord1 = state;
 491          break;
 492       case GL_MAP2_TEXTURE_COORD_2:
 493          if (ctx->Eval.Map2TextureCoord2 == state)
 494             return;
 495          FLUSH_VERTICES(ctx, _NEW_EVAL);
 496          ctx->Eval.Map2TextureCoord2 = state;
 497          break;
 498       case GL_MAP2_TEXTURE_COORD_3:
 499          if (ctx->Eval.Map2TextureCoord3 == state)
 500             return;
 501          FLUSH_VERTICES(ctx, _NEW_EVAL);
 502          ctx->Eval.Map2TextureCoord3 = state;
 503          break;
 504       case GL_MAP2_TEXTURE_COORD_4:
 505          if (ctx->Eval.Map2TextureCoord4 == state)
 506             return;
 507          FLUSH_VERTICES(ctx, _NEW_EVAL);
 508          ctx->Eval.Map2TextureCoord4 = state;
 509          break;
 510       case GL_MAP2_VERTEX_3:
 511          if (ctx->Eval.Map2Vertex3 == state)
 512             return;
 513          FLUSH_VERTICES(ctx, _NEW_EVAL);
 514          ctx->Eval.Map2Vertex3 = state;
 515          break;
 516       case GL_MAP2_VERTEX_4:
 517          if (ctx->Eval.Map2Vertex4 == state)
 518             return;
 519          FLUSH_VERTICES(ctx, _NEW_EVAL);
 520          ctx->Eval.Map2Vertex4 = state;
 521          break;
 522       case GL_NORMALIZE:
 523          if (ctx->Transform.Normalize == state)
 524             return;
 525          FLUSH_VERTICES(ctx, _NEW_TRANSFORM);
 526          ctx->Transform.Normalize = state;
 527          break;
 528       case GL_POINT_SMOOTH:
 529          if (ctx->Point.SmoothFlag == state)
 530             return;
 531          FLUSH_VERTICES(ctx, _NEW_POINT);
 532          ctx->Point.SmoothFlag = state;
 533          ctx->_TriangleCaps ^= DD_POINT_SMOOTH;
 534          break;
 535       case GL_POLYGON_SMOOTH:
 536          if (ctx->Polygon.SmoothFlag == state)
 537             return;
 538          FLUSH_VERTICES(ctx, _NEW_POLYGON);
 539          ctx->Polygon.SmoothFlag = state;
 540          ctx->_TriangleCaps ^= DD_TRI_SMOOTH;
 541          break;
 542       case GL_POLYGON_STIPPLE:
 543          if (ctx->Polygon.StippleFlag == state)
 544             return;
 545          FLUSH_VERTICES(ctx, _NEW_POLYGON);
 546          ctx->Polygon.StippleFlag = state;
 547          ctx->_TriangleCaps ^= DD_TRI_STIPPLE;
 548          break;
 549       case GL_POLYGON_OFFSET_POINT:
 550          if (ctx->Polygon.OffsetPoint == state)
 551             return;
 552          FLUSH_VERTICES(ctx, _NEW_POLYGON);
 553          ctx->Polygon.OffsetPoint = state;
 554          break;
 555       case GL_POLYGON_OFFSET_LINE:
 556          if (ctx->Polygon.OffsetLine == state)
 557             return;
 558          FLUSH_VERTICES(ctx, _NEW_POLYGON);
 559          ctx->Polygon.OffsetLine = state;
 560          break;
 561       case GL_POLYGON_OFFSET_FILL:
 562          if (ctx->Polygon.OffsetFill == state)
 563             return;
 564          FLUSH_VERTICES(ctx, _NEW_POLYGON);
 565          ctx->Polygon.OffsetFill = state;
 566          break;
 567       case GL_RESCALE_NORMAL_EXT:
 568          if (ctx->Transform.RescaleNormals == state)
 569             return;
 570          FLUSH_VERTICES(ctx, _NEW_TRANSFORM);
 571          ctx->Transform.RescaleNormals = state;
 572          break;
 573       case GL_SCISSOR_TEST:
 574          if (ctx->Scissor.Enabled == state)
 575             return;
 576          FLUSH_VERTICES(ctx, _NEW_SCISSOR);
 577          ctx->Scissor.Enabled = state;
 578          break;
 579       case GL_STENCIL_TEST:
 580          if (ctx->Stencil.Enabled == state)
 581             return;
 582          FLUSH_VERTICES(ctx, _NEW_STENCIL);
 583          ctx->Stencil.Enabled = state;
 584          break;
 585       case GL_TEXTURE_1D:
 586          if (!enable_texture(ctx, state, TEXTURE_1D_BIT)) {
 587             return;
 588          }
 589          break;
 590       case GL_TEXTURE_2D:
 591          if (!enable_texture(ctx, state, TEXTURE_2D_BIT)) {
 592             return;
 593          }
 594          break;
 595       case GL_TEXTURE_3D:
 596          if (!enable_texture(ctx, state, TEXTURE_3D_BIT)) {
 597             return;
 598          }
 599          break;
 600       case GL_TEXTURE_GEN_S:
 601       case GL_TEXTURE_GEN_T:
 602       case GL_TEXTURE_GEN_R:
 603       case GL_TEXTURE_GEN_Q:
 604          {
 605             struct gl_texture_unit *texUnit = get_texcoord_unit(ctx);
 606             if (texUnit) {
 607                GLbitfield coordBit = S_BIT << (cap - GL_TEXTURE_GEN_S);
 608                GLbitfield newenabled = texUnit->TexGenEnabled & ~coordBit;
 609                if (state)
 610                   newenabled |= coordBit;
 611                if (texUnit->TexGenEnabled == newenabled)
 612                   return;
 613                FLUSH_VERTICES(ctx, _NEW_TEXTURE);
 614                texUnit->TexGenEnabled = newenabled;
 615             }
 616          }
 617          break;
 618
 619 #if FEATURE_ES1
 620       case GL_TEXTURE_GEN_STR_OES:
 621          /* disable S, T, and R at the same time */
 622          {
 623             struct gl_texture_unit *texUnit = get_texcoord_unit(ctx);
 624             if (texUnit) {
 625                GLuint newenabled =
 626                   texUnit->TexGenEnabled & ~STR_BITS;
 627                if (state)
 628                   newenabled |= STR_BITS;
 629                if (texUnit->TexGenEnabled == newenabled)
 630                   return;
 631                FLUSH_VERTICES(ctx, _NEW_TEXTURE);
 632                texUnit->TexGenEnabled = newenabled;
 633             }
 634          }
 635          break;
 636 #endif
 637
 638       /* client-side state */
 639       case GL_VERTEX_ARRAY:
 640       case GL_NORMAL_ARRAY:
 641       case GL_COLOR_ARRAY:
 642       case GL_INDEX_ARRAY:
 643       case GL_TEXTURE_COORD_ARRAY:
 644       case GL_EDGE_FLAG_ARRAY:
 645       case GL_FOG_COORDINATE_ARRAY_EXT:
 646       case GL_SECONDARY_COLOR_ARRAY_EXT:
 647       case GL_POINT_SIZE_ARRAY_OES:
 648          client_state( ctx, cap, state );
 649          return;
 650
 651       /* GL_ARB_texture_cube_map */
 652       case GL_TEXTURE_CUBE_MAP_ARB:
 653          CHECK_EXTENSION(ARB_texture_cube_map, cap);
 654          if (!enable_texture(ctx, state, TEXTURE_CUBE_BIT)) {
 655             return;
 656          }
 657          break;
 658
 659       /* GL_EXT_secondary_color */
 660       case GL_COLOR_SUM_EXT:
 661          CHECK_EXTENSION2(EXT_secondary_color, ARB_vertex_program, cap);
 662          if (ctx->Fog.ColorSumEnabled == state)
 663             return;
 664          FLUSH_VERTICES(ctx, _NEW_FOG);
 665          ctx->Fog.ColorSumEnabled = state;
 666          break;
 667
 668       /* GL_ARB_multisample */
 669       case GL_MULTISAMPLE_ARB:
 670          if (ctx->Multisample.Enabled == state)
 671             return;
 672          FLUSH_VERTICES(ctx, _NEW_MULTISAMPLE);
 673          ctx->Multisample.Enabled = state;
 674          break;
 675       case GL_SAMPLE_ALPHA_TO_COVERAGE_ARB:
 676          if (ctx->Multisample.SampleAlphaToCoverage == state)
 677             return;
 678          FLUSH_VERTICES(ctx, _NEW_MULTISAMPLE);
 679          ctx->Multisample.SampleAlphaToCoverage = state;
 680          break;
 681       case GL_SAMPLE_ALPHA_TO_ONE_ARB:
 682          if (ctx->Multisample.SampleAlphaToOne == state)
 683             return;
 684          FLUSH_VERTICES(ctx, _NEW_MULTISAMPLE);
 685          ctx->Multisample.SampleAlphaToOne = state;
 686          break;
 687       case GL_SAMPLE_COVERAGE_ARB:
 688          if (ctx->Multisample.SampleCoverage == state)
 689             return;
 690          FLUSH_VERTICES(ctx, _NEW_MULTISAMPLE);
 691          ctx->Multisample.SampleCoverage = state;
 692          break;
 693       case GL_SAMPLE_COVERAGE_INVERT_ARB:
 694          if (ctx->Multisample.SampleCoverageInvert == state)
 695             return;
 696          FLUSH_VERTICES(ctx, _NEW_MULTISAMPLE);
 697          ctx->Multisample.SampleCoverageInvert = state;
 698          break;
 699
 700       /* GL_IBM_rasterpos_clip */
 701       case GL_RASTER_POSITION_UNCLIPPED_IBM:
 702          CHECK_EXTENSION(IBM_rasterpos_clip, cap);
 703          if (ctx->Transform.RasterPositionUnclipped == state)
 704             return;
 705          FLUSH_VERTICES(ctx, _NEW_TRANSFORM);
 706          ctx->Transform.RasterPositionUnclipped = state;
 707          break;
 708
 709       /* GL_NV_point_sprite */
 710       case GL_POINT_SPRITE_NV:
 711          CHECK_EXTENSION2(NV_point_sprite, ARB_point_sprite, cap);
 712          if (ctx->Point.PointSprite == state)
 713             return;
 714          FLUSH_VERTICES(ctx, _NEW_POINT);
 715          ctx->Point.PointSprite = state;
 716          break;
 717
 718 #if FEATURE_NV_vertex_program || FEATURE_ARB_vertex_program
 719       case GL_VERTEX_PROGRAM_ARB:
 720          CHECK_EXTENSION2(ARB_vertex_program, NV_vertex_program, cap);
 721          if (ctx->VertexProgram.Enabled == state)
 722             return;
 723          FLUSH_VERTICES(ctx, _NEW_PROGRAM);
 724          ctx->VertexProgram.Enabled = state;
 725          break;
 726       case GL_VERTEX_PROGRAM_POINT_SIZE_ARB:
 727          CHECK_EXTENSION2(ARB_vertex_program, NV_vertex_program, cap);
 728          if (ctx->VertexProgram.PointSizeEnabled == state)
 729             return;
 730          FLUSH_VERTICES(ctx, _NEW_PROGRAM);
 731          ctx->VertexProgram.PointSizeEnabled = state;
 732          break;
 733       case GL_VERTEX_PROGRAM_TWO_SIDE_ARB:
 734          CHECK_EXTENSION2(ARB_vertex_program, NV_vertex_program, cap);
 735          if (ctx->VertexProgram.TwoSideEnabled == state)
 736             return;
 737          FLUSH_VERTICES(ctx, _NEW_PROGRAM);
 738          ctx->VertexProgram.TwoSideEnabled = state;
 739          break;
 740 #endif
 741 #if FEATURE_NV_vertex_program
 742       case GL_MAP1_VERTEX_ATTRIB0_4_NV:
 743       case GL_MAP1_VERTEX_ATTRIB1_4_NV:
 744       case GL_MAP1_VERTEX_ATTRIB2_4_NV:
 745       case GL_MAP1_VERTEX_ATTRIB3_4_NV:
 746       case GL_MAP1_VERTEX_ATTRIB4_4_NV:
 747       case GL_MAP1_VERTEX_ATTRIB5_4_NV:
 748       case GL_MAP1_VERTEX_ATTRIB6_4_NV:
 749       case GL_MAP1_VERTEX_ATTRIB7_4_NV:
 750       case GL_MAP1_VERTEX_ATTRIB8_4_NV:
 751       case GL_MAP1_VERTEX_ATTRIB9_4_NV:
 752       case GL_MAP1_VERTEX_ATTRIB10_4_NV:
 753       case GL_MAP1_VERTEX_ATTRIB11_4_NV:
 754       case GL_MAP1_VERTEX_ATTRIB12_4_NV:
 755       case GL_MAP1_VERTEX_ATTRIB13_4_NV:
 756       case GL_MAP1_VERTEX_ATTRIB14_4_NV:
 757       case GL_MAP1_VERTEX_ATTRIB15_4_NV:
 758          CHECK_EXTENSION(NV_vertex_program, cap);
 759          {
 760             const GLuint map = (GLuint) (cap - GL_MAP1_VERTEX_ATTRIB0_4_NV);
 761             FLUSH_VERTICES(ctx, _NEW_EVAL);
 762             ctx->Eval.Map1Attrib[map] = state;
 763          }
 764          break;
 765       case GL_MAP2_VERTEX_ATTRIB0_4_NV:
 766       case GL_MAP2_VERTEX_ATTRIB1_4_NV:
 767       case GL_MAP2_VERTEX_ATTRIB2_4_NV:
 768       case GL_MAP2_VERTEX_ATTRIB3_4_NV:
 769       case GL_MAP2_VERTEX_ATTRIB4_4_NV:
 770       case GL_MAP2_VERTEX_ATTRIB5_4_NV:
 771       case GL_MAP2_VERTEX_ATTRIB6_4_NV:
 772       case GL_MAP2_VERTEX_ATTRIB7_4_NV:
 773       case GL_MAP2_VERTEX_ATTRIB8_4_NV:
 774       case GL_MAP2_VERTEX_ATTRIB9_4_NV:
 775       case GL_MAP2_VERTEX_ATTRIB10_4_NV:
 776       case GL_MAP2_VERTEX_ATTRIB11_4_NV:
 777       case GL_MAP2_VERTEX_ATTRIB12_4_NV:
 778       case GL_MAP2_VERTEX_ATTRIB13_4_NV:
 779       case GL_MAP2_VERTEX_ATTRIB14_4_NV:
 780       case GL_MAP2_VERTEX_ATTRIB15_4_NV:
 781          CHECK_EXTENSION(NV_vertex_program, cap);
 782          {
 783             const GLuint map = (GLuint) (cap - GL_MAP2_VERTEX_ATTRIB0_4_NV);
 784             FLUSH_VERTICES(ctx, _NEW_EVAL);
 785             ctx->Eval.Map2Attrib[map] = state;
 786          }
 787          break;
 788 #endif /* FEATURE_NV_vertex_program */
 789
 790 #if FEATURE_NV_fragment_program
 791       case GL_FRAGMENT_PROGRAM_NV:
 792          CHECK_EXTENSION(NV_fragment_program, cap);
 793          if (ctx->FragmentProgram.Enabled == state)
 794             return;
 795          FLUSH_VERTICES(ctx, _NEW_PROGRAM);
 796          ctx->FragmentProgram.Enabled = state;
 797          break;
 798 #endif /* FEATURE_NV_fragment_program */
 799
 800       /* GL_NV_texture_rectangle */
 801       case GL_TEXTURE_RECTANGLE_NV:
 802          CHECK_EXTENSION(NV_texture_rectangle, cap);
 803          if (!enable_texture(ctx, state, TEXTURE_RECT_BIT)) {
 804             return;
 805          }
 806          break;
 807
 808       /* GL_EXT_stencil_two_side */
 809       case GL_STENCIL_TEST_TWO_SIDE_EXT:
 810          CHECK_EXTENSION(EXT_stencil_two_side, cap);
 811          if (ctx->Stencil.TestTwoSide == state)
 812             return;
 813          FLUSH_VERTICES(ctx, _NEW_STENCIL);
 814          ctx->Stencil.TestTwoSide = state;
 815          if (state) {
 816             ctx->Stencil._BackFace = 2;
 817             ctx->_TriangleCaps |= DD_TRI_TWOSTENCIL;
 818          } else {
 819             ctx->Stencil._BackFace = 1;
 820             ctx->_TriangleCaps &= ~DD_TRI_TWOSTENCIL;
 821          }
 822          break;
 823
 824 #if FEATURE_ARB_fragment_program
 825       case GL_FRAGMENT_PROGRAM_ARB:
 826          CHECK_EXTENSION(ARB_fragment_program, cap);
 827          if (ctx->FragmentProgram.Enabled == state)
 828             return;
 829          FLUSH_VERTICES(ctx, _NEW_PROGRAM);
 830          ctx->FragmentProgram.Enabled = state;
 831          break;
 832 #endif /* FEATURE_ARB_fragment_program */
 833
 834       /* GL_EXT_depth_bounds_test */
 835       case GL_DEPTH_BOUNDS_TEST_EXT:
 836          CHECK_EXTENSION(EXT_depth_bounds_test, cap);
 837          if (ctx->Depth.BoundsTest == state)
 838             return;
 839          FLUSH_VERTICES(ctx, _NEW_DEPTH);
 840          ctx->Depth.BoundsTest = state;
 841          break;
 842
 843       case GL_DEPTH_CLAMP:
 844          if (ctx->Transform.DepthClamp == state)
 845             return;
 846          CHECK_EXTENSION(ARB_depth_clamp, cap);
 847          FLUSH_VERTICES(ctx, _NEW_TRANSFORM);
 848          ctx->Transform.DepthClamp = state;
 849          break;
 850
 851 #if FEATURE_ATI_fragment_shader
 852       case GL_FRAGMENT_SHADER_ATI:
 853         CHECK_EXTENSION(ATI_fragment_shader, cap);
 854         if (ctx->ATIFragmentShader.Enabled == state)
 855           return;
 856         FLUSH_VERTICES(ctx, _NEW_PROGRAM);
 857         ctx->ATIFragmentShader.Enabled = state;
 858         break;
 859 #endif
 860
 861       /* GL_MESA_texture_array */
 862       case GL_TEXTURE_1D_ARRAY_EXT:
 863          CHECK_EXTENSION(MESA_texture_array, cap);
 864          if (!enable_texture(ctx, state, TEXTURE_1D_ARRAY_BIT)) {
 865             return;
 866          }
 867          break;
 868
 869       case GL_TEXTURE_2D_ARRAY_EXT:
 870          CHECK_EXTENSION(MESA_texture_array, cap);
 871          if (!enable_texture(ctx, state, TEXTURE_2D_ARRAY_BIT)) {
 872             return;
 873          }
 874          break;
 875
 876       case GL_TEXTURE_CUBE_MAP_SEAMLESS:
 877          CHECK_EXTENSION(ARB_seamless_cube_map, cap);
 878          if (ctx->Texture.CubeMapSeamless != state) {
 879             FLUSH_VERTICES(ctx, _NEW_TEXTURE);
 880             ctx->Texture.CubeMapSeamless = state;
 881          }
 882          break;
 883
 884 #if FEATURE_EXT_transform_feedback
 885       case GL_RASTERIZER_DISCARD:
 886          CHECK_EXTENSION(EXT_transform_feedback, cap);
 887          if (ctx->TransformFeedback.RasterDiscard != state) {
 888             FLUSH_VERTICES(ctx, _NEW_TRANSFORM);
 889             ctx->TransformFeedback.RasterDiscard = state;
 890          }
 891          break;
 892 #endif
 893
 894       /* GL 3.1 primitive restart.  Note: this enum is different from
 895        * GL_PRIMITIVE_RESTART_NV (which is client state).
 896        */
 897       case GL_PRIMITIVE_RESTART:
 898          if (ctx->VersionMajor * 10 + ctx->VersionMinor < 31) {
 899             goto invalid_enum_error;
 900          }
 901          if (ctx->Array.PrimitiveRestart != state) {
 902             FLUSH_VERTICES(ctx, _NEW_TRANSFORM);
 903             ctx->Array.PrimitiveRestart = state;
 904          }
 905          break;
 906
 907       /* GL3.0 - GL_framebuffer_sRGB */
 908       case GL_FRAMEBUFFER_SRGB_EXT:
 909          CHECK_EXTENSION(EXT_framebuffer_sRGB, cap);
 910          FLUSH_VERTICES(ctx, _NEW_BUFFERS);
 911          ctx->Color.sRGBEnabled = state;
 912          break;
 913
 914       default:
 915          goto invalid_enum_error;
 916    }
 917
 918    if (ctx->Driver.Enable) {
 919       ctx->Driver.Enable( ctx, cap, state );
 920    }
 921
 922    return;
 923
 924 invalid_enum_error:
 925    _mesa_error(ctx, GL_INVALID_ENUM, "gl%s(0x%x)",
 926                state ? "Enable" : "Disable", cap);
 927 }
 928
 929
 930 /**
 931  * Enable GL capability.  Called by glEnable()
 932  * \param cap  state to enable.
 933  */
 934 void GLAPIENTRY
 935 _mesa_Enable( GLenum cap )
 936 {
 937    GET_CURRENT_CONTEXT(ctx);
 938    ASSERT_OUTSIDE_BEGIN_END(ctx);
 939
 940    _mesa_set_enable( ctx, cap, GL_TRUE );
 941 }
 942
 943
 944 /**
 945  * Disable GL capability.  Called by glDisable()
 946  * \param cap  state to disable.
 947  */
 948 void GLAPIENTRY
 949 _mesa_Disable( GLenum cap )
 950 {
 951    GET_CURRENT_CONTEXT(ctx);
 952    ASSERT_OUTSIDE_BEGIN_END(ctx);
 953
 954    _mesa_set_enable( ctx, cap, GL_FALSE );
 955 }
 956
 957
 958
 959 /**
 960  * Enable/disable an indexed state var.
 961  */
 962 void
 963 _mesa_set_enablei(struct gl_context *ctx, GLenum cap,
 964                   GLuint index, GLboolean state)
 965 {
 966    ASSERT(state == 0 || state == 1);
 967    switch (cap) {
 968    case GL_BLEND:
 969       if (!ctx->Extensions.EXT_draw_buffers2) {
 970          goto invalid_enum_error;
 971       }
 972       if (index >= ctx->Const.MaxDrawBuffers) {
 973          _mesa_error(ctx, GL_INVALID_VALUE, "%s(index=%u)",
 974                      state ? "glEnableIndexed" : "glDisableIndexed", index);
 975          return;
 976       }
 977       if (((ctx->Color.BlendEnabled >> index) & 1) != state) {
 978          FLUSH_VERTICES(ctx, _NEW_COLOR);
 979          if (state)
 980             ctx->Color.BlendEnabled |= (1 << index);
 981          else
 982             ctx->Color.BlendEnabled &= ~(1 << index);
 983       }
 984       break;
 985    default:
 986       goto invalid_enum_error;
 987    }
 988    return;
 989
 990 invalid_enum_error:
 991     _mesa_error(ctx, GL_INVALID_ENUM, "%s(cap=%s)",
 992                 state ? "glEnablei" : "glDisablei",
 993                 _mesa_lookup_enum_by_nr(cap));
 994 }
 995
 996
 997 void GLAPIENTRY
 998 _mesa_DisableIndexed( GLenum cap, GLuint index )
 999 {
1000    GET_CURRENT_CONTEXT(ctx);
1001    ASSERT_OUTSIDE_BEGIN_END(ctx);
1002    _mesa_set_enablei(ctx, cap, index, GL_FALSE);
1003 }
1004
1005
1006 void GLAPIENTRY
1007 _mesa_EnableIndexed( GLenum cap, GLuint index )
1008 {
1009    GET_CURRENT_CONTEXT(ctx);
1010    ASSERT_OUTSIDE_BEGIN_END(ctx);
1011    _mesa_set_enablei(ctx, cap, index, GL_TRUE);
1012 }
1013
1014
1015 GLboolean GLAPIENTRY
1016 _mesa_IsEnabledIndexed( GLenum cap, GLuint index )
1017 {
1018    GET_CURRENT_CONTEXT(ctx);
1019    switch (cap) {
1020    case GL_BLEND:
1021       if (index >= ctx->Const.MaxDrawBuffers) {
1022          _mesa_error(ctx, GL_INVALID_VALUE, "glIsEnabledIndexed(index=%u)",
1023                      index);
1024          return GL_FALSE;
1025       }
1026       return (ctx->Color.BlendEnabled >> index) & 1;
1027    default:
1028       _mesa_error(ctx, GL_INVALID_ENUM, "glIsEnabledIndexed(cap=%s)",
1029                   _mesa_lookup_enum_by_nr(cap));
1030       return GL_FALSE;
1031    }
1032 }
1033
1034
1035
1036
1037 #undef CHECK_EXTENSION
1038 #define CHECK_EXTENSION(EXTNAME)                        \
1039    if (!ctx->Extensions.EXTNAME) {                      \
1040       goto invalid_enum_error;                          \
1041    }
1042
1043 #undef CHECK_EXTENSION2
1044 #define CHECK_EXTENSION2(EXT1, EXT2)                            \
1045    if (!ctx->Extensions.EXT1 && !ctx->Extensions.EXT2) {        \
1046       goto invalid_enum_error;                                  \
1047    }
1048
1049
1050 /**
1051  * Helper function to determine whether a texture target is enabled.
1052  */
1053 static GLboolean
1054 is_texture_enabled(struct gl_context *ctx, GLbitfield bit)
1055 {
1056    const struct gl_texture_unit *const texUnit =
1057        &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
1058    return (texUnit->Enabled & bit) ? GL_TRUE : GL_FALSE;
1059 }
1060
1061
1062 /**
1063  * Return simple enable/disable state.
1064  *
1065  * \param cap  state variable to query.
1066  *
1067  * Returns the state of the specified capability from the current GL context.
1068  * For the capabilities associated with extensions verifies that those
1069  * extensions are effectively present before reporting.
1070  */
1071 GLboolean GLAPIENTRY
1072 _mesa_IsEnabled( GLenum cap )
1073 {
1074    GET_CURRENT_CONTEXT(ctx);
1075    ASSERT_OUTSIDE_BEGIN_END_WITH_RETVAL(ctx, 0);
1076
1077    switch (cap) {
1078       case GL_ALPHA_TEST:
1079          return ctx->Color.AlphaEnabled;
1080       case GL_AUTO_NORMAL:
1081          return ctx->Eval.AutoNormal;
1082       case GL_BLEND:
1083          return ctx->Color.BlendEnabled & 1;  /* return state for buffer[0] */
1084       case GL_CLIP_PLANE0:
1085       case GL_CLIP_PLANE1:
1086       case GL_CLIP_PLANE2:
1087       case GL_CLIP_PLANE3:
1088       case GL_CLIP_PLANE4:
1089       case GL_CLIP_PLANE5:
1090          return (ctx->Transform.ClipPlanesEnabled >> (cap - GL_CLIP_PLANE0)) & 1;
1091       case GL_COLOR_MATERIAL:
1092          return ctx->Light.ColorMaterialEnabled;
1093       case GL_CULL_FACE:
1094          return ctx->Polygon.CullFlag;
1095       case GL_DEPTH_TEST:
1096          return ctx->Depth.Test;
1097       case GL_DITHER:
1098          return ctx->Color.DitherFlag;
1099       case GL_FOG:
1100          return ctx->Fog.Enabled;
1101       case GL_LIGHTING:
1102          return ctx->Light.Enabled;
1103       case GL_LIGHT0:
1104       case GL_LIGHT1:
1105       case GL_LIGHT2:
1106       case GL_LIGHT3:
1107       case GL_LIGHT4:
1108       case GL_LIGHT5:
1109       case GL_LIGHT6:
1110       case GL_LIGHT7:
1111          return ctx->Light.Light[cap-GL_LIGHT0].Enabled;
1112       case GL_LINE_SMOOTH:
1113          return ctx->Line.SmoothFlag;
1114       case GL_LINE_STIPPLE:
1115          return ctx->Line.StippleFlag;
1116       case GL_INDEX_LOGIC_OP:
1117          return ctx->Color.IndexLogicOpEnabled;
1118       case GL_COLOR_LOGIC_OP:
1119          return ctx->Color.ColorLogicOpEnabled;
1120       case GL_MAP1_COLOR_4:
1121          return ctx->Eval.Map1Color4;
1122       case GL_MAP1_INDEX:
1123          return ctx->Eval.Map1Index;
1124       case GL_MAP1_NORMAL:
1125          return ctx->Eval.Map1Normal;
1126       case GL_MAP1_TEXTURE_COORD_1:
1127          return ctx->Eval.Map1TextureCoord1;
1128       case GL_MAP1_TEXTURE_COORD_2:
1129          return ctx->Eval.Map1TextureCoord2;
1130       case GL_MAP1_TEXTURE_COORD_3:
1131          return ctx->Eval.Map1TextureCoord3;
1132       case GL_MAP1_TEXTURE_COORD_4:
1133          return ctx->Eval.Map1TextureCoord4;
1134       case GL_MAP1_VERTEX_3:
1135          return ctx->Eval.Map1Vertex3;
1136       case GL_MAP1_VERTEX_4:
1137          return ctx->Eval.Map1Vertex4;
1138       case GL_MAP2_COLOR_4:
1139          return ctx->Eval.Map2Color4;
1140       case GL_MAP2_INDEX:
1141          return ctx->Eval.Map2Index;
1142       case GL_MAP2_NORMAL:
1143          return ctx->Eval.Map2Normal;
1144       case GL_MAP2_TEXTURE_COORD_1:
1145          return ctx->Eval.Map2TextureCoord1;
1146       case GL_MAP2_TEXTURE_COORD_2:
1147          return ctx->Eval.Map2TextureCoord2;
1148       case GL_MAP2_TEXTURE_COORD_3:
1149          return ctx->Eval.Map2TextureCoord3;
1150       case GL_MAP2_TEXTURE_COORD_4:
1151          return ctx->Eval.Map2TextureCoord4;
1152       case GL_MAP2_VERTEX_3:
1153          return ctx->Eval.Map2Vertex3;
1154       case GL_MAP2_VERTEX_4:
1155          return ctx->Eval.Map2Vertex4;
1156       case GL_NORMALIZE:
1157          return ctx->Transform.Normalize;
1158       case GL_POINT_SMOOTH:
1159          return ctx->Point.SmoothFlag;
1160       case GL_POLYGON_SMOOTH:
1161          return ctx->Polygon.SmoothFlag;
1162       case GL_POLYGON_STIPPLE:
1163          return ctx->Polygon.StippleFlag;
1164       case GL_POLYGON_OFFSET_POINT:
1165          return ctx->Polygon.OffsetPoint;
1166       case GL_POLYGON_OFFSET_LINE:
1167          return ctx->Polygon.OffsetLine;
1168       case GL_POLYGON_OFFSET_FILL:
1169          return ctx->Polygon.OffsetFill;
1170       case GL_RESCALE_NORMAL_EXT:
1171          return ctx->Transform.RescaleNormals;
1172       case GL_SCISSOR_TEST:
1173          return ctx->Scissor.Enabled;
1174       case GL_STENCIL_TEST:
1175          return ctx->Stencil.Enabled;
1176       case GL_TEXTURE_1D:
1177          return is_texture_enabled(ctx, TEXTURE_1D_BIT);
1178       case GL_TEXTURE_2D:
1179          return is_texture_enabled(ctx, TEXTURE_2D_BIT);
1180       case GL_TEXTURE_3D:
1181          return is_texture_enabled(ctx, TEXTURE_3D_BIT);
1182       case GL_TEXTURE_GEN_S:
1183       case GL_TEXTURE_GEN_T:
1184       case GL_TEXTURE_GEN_R:
1185       case GL_TEXTURE_GEN_Q:
1186          {
1187             const struct gl_texture_unit *texUnit = get_texcoord_unit(ctx);
1188             if (texUnit) {
1189                GLbitfield coordBit = S_BIT << (cap - GL_TEXTURE_GEN_S);
1190                return (texUnit->TexGenEnabled & coordBit) ? GL_TRUE : GL_FALSE;
1191             }
1192          }
1193          return GL_FALSE;
1194 #if FEATURE_ES1
1195       case GL_TEXTURE_GEN_STR_OES:
1196          {
1197             const struct gl_texture_unit *texUnit = get_texcoord_unit(ctx);
1198             if (texUnit) {
1199                return (texUnit->TexGenEnabled & STR_BITS) == STR_BITS
1200                   ? GL_TRUE : GL_FALSE;
1201             }
1202          }
1203 #endif
1204
1205       /* client-side state */
1206       case GL_VERTEX_ARRAY:
1207          return (ctx->Array.ArrayObj->Vertex.Enabled != 0);
1208       case GL_NORMAL_ARRAY:
1209          return (ctx->Array.ArrayObj->Normal.Enabled != 0);
1210       case GL_COLOR_ARRAY:
1211          return (ctx->Array.ArrayObj->Color.Enabled != 0);
1212       case GL_INDEX_ARRAY:
1213          return (ctx->Array.ArrayObj->Index.Enabled != 0);
1214       case GL_TEXTURE_COORD_ARRAY:
1215          return (ctx->Array.ArrayObj->TexCoord[ctx->Array.ActiveTexture]
1216                  .Enabled != 0);
1217       case GL_EDGE_FLAG_ARRAY:
1218          return (ctx->Array.ArrayObj->EdgeFlag.Enabled != 0);
1219       case GL_FOG_COORDINATE_ARRAY_EXT:
1220          CHECK_EXTENSION(EXT_fog_coord);
1221          return (ctx->Array.ArrayObj->FogCoord.Enabled != 0);
1222       case GL_SECONDARY_COLOR_ARRAY_EXT:
1223          CHECK_EXTENSION(EXT_secondary_color);
1224          return (ctx->Array.ArrayObj->SecondaryColor.Enabled != 0);
1225 #if FEATURE_point_size_array
1226       case GL_POINT_SIZE_ARRAY_OES:
1227          return (ctx->Array.ArrayObj->PointSize.Enabled != 0);
1228 #endif
1229
1230       /* GL_ARB_texture_cube_map */
1231       case GL_TEXTURE_CUBE_MAP_ARB:
1232          CHECK_EXTENSION(ARB_texture_cube_map);
1233          return is_texture_enabled(ctx, TEXTURE_CUBE_BIT);
1234
1235       /* GL_EXT_secondary_color */
1236       case GL_COLOR_SUM_EXT:
1237          CHECK_EXTENSION2(EXT_secondary_color, ARB_vertex_program);
1238          return ctx->Fog.ColorSumEnabled;
1239
1240       /* GL_ARB_multisample */
1241       case GL_MULTISAMPLE_ARB:
1242          return ctx->Multisample.Enabled;
1243       case GL_SAMPLE_ALPHA_TO_COVERAGE_ARB:
1244          return ctx->Multisample.SampleAlphaToCoverage;
1245       case GL_SAMPLE_ALPHA_TO_ONE_ARB:
1246          return ctx->Multisample.SampleAlphaToOne;
1247       case GL_SAMPLE_COVERAGE_ARB:
1248          return ctx->Multisample.SampleCoverage;
1249       case GL_SAMPLE_COVERAGE_INVERT_ARB:
1250          return ctx->Multisample.SampleCoverageInvert;
1251
1252       /* GL_IBM_rasterpos_clip */
1253       case GL_RASTER_POSITION_UNCLIPPED_IBM:
1254          CHECK_EXTENSION(IBM_rasterpos_clip);
1255          return ctx->Transform.RasterPositionUnclipped;
1256
1257       /* GL_NV_point_sprite */
1258       case GL_POINT_SPRITE_NV:
1259          CHECK_EXTENSION2(NV_point_sprite, ARB_point_sprite)
1260          return ctx->Point.PointSprite;
1261
1262 #if FEATURE_NV_vertex_program || FEATURE_ARB_vertex_program
1263       case GL_VERTEX_PROGRAM_ARB:
1264          CHECK_EXTENSION2(ARB_vertex_program, NV_vertex_program);
1265          return ctx->VertexProgram.Enabled;
1266       case GL_VERTEX_PROGRAM_POINT_SIZE_ARB:
1267          CHECK_EXTENSION2(ARB_vertex_program, NV_vertex_program);
1268          return ctx->VertexProgram.PointSizeEnabled;
1269       case GL_VERTEX_PROGRAM_TWO_SIDE_ARB:
1270          CHECK_EXTENSION2(ARB_vertex_program, NV_vertex_program);
1271          return ctx->VertexProgram.TwoSideEnabled;
1272 #endif
1273 #if FEATURE_NV_vertex_program
1274       case GL_VERTEX_ATTRIB_ARRAY0_NV:
1275       case GL_VERTEX_ATTRIB_ARRAY1_NV:
1276       case GL_VERTEX_ATTRIB_ARRAY2_NV:
1277       case GL_VERTEX_ATTRIB_ARRAY3_NV:
1278       case GL_VERTEX_ATTRIB_ARRAY4_NV:
1279       case GL_VERTEX_ATTRIB_ARRAY5_NV:
1280       case GL_VERTEX_ATTRIB_ARRAY6_NV:
1281       case GL_VERTEX_ATTRIB_ARRAY7_NV:
1282       case GL_VERTEX_ATTRIB_ARRAY8_NV:
1283       case GL_VERTEX_ATTRIB_ARRAY9_NV:
1284       case GL_VERTEX_ATTRIB_ARRAY10_NV:
1285       case GL_VERTEX_ATTRIB_ARRAY11_NV:
1286       case GL_VERTEX_ATTRIB_ARRAY12_NV:
1287       case GL_VERTEX_ATTRIB_ARRAY13_NV:
1288       case GL_VERTEX_ATTRIB_ARRAY14_NV:
1289       case GL_VERTEX_ATTRIB_ARRAY15_NV:
1290          CHECK_EXTENSION(NV_vertex_program);
1291          {
1292             GLint n = (GLint) cap - GL_VERTEX_ATTRIB_ARRAY0_NV;
1293             ASSERT(n < Elements(ctx->Array.ArrayObj->VertexAttrib));
1294             return (ctx->Array.ArrayObj->VertexAttrib[n].Enabled != 0);
1295          }
1296       case GL_MAP1_VERTEX_ATTRIB0_4_NV:
1297       case GL_MAP1_VERTEX_ATTRIB1_4_NV:
1298       case GL_MAP1_VERTEX_ATTRIB2_4_NV:
1299       case GL_MAP1_VERTEX_ATTRIB3_4_NV:
1300       case GL_MAP1_VERTEX_ATTRIB4_4_NV:
1301       case GL_MAP1_VERTEX_ATTRIB5_4_NV:
1302       case GL_MAP1_VERTEX_ATTRIB6_4_NV:
1303       case GL_MAP1_VERTEX_ATTRIB7_4_NV:
1304       case GL_MAP1_VERTEX_ATTRIB8_4_NV:
1305       case GL_MAP1_VERTEX_ATTRIB9_4_NV:
1306       case GL_MAP1_VERTEX_ATTRIB10_4_NV:
1307       case GL_MAP1_VERTEX_ATTRIB11_4_NV:
1308       case GL_MAP1_VERTEX_ATTRIB12_4_NV:
1309       case GL_MAP1_VERTEX_ATTRIB13_4_NV:
1310       case GL_MAP1_VERTEX_ATTRIB14_4_NV:
1311       case GL_MAP1_VERTEX_ATTRIB15_4_NV:
1312          CHECK_EXTENSION(NV_vertex_program);
1313          {
1314             const GLuint map = (GLuint) (cap - GL_MAP1_VERTEX_ATTRIB0_4_NV);
1315             return ctx->Eval.Map1Attrib[map];
1316          }
1317       case GL_MAP2_VERTEX_ATTRIB0_4_NV:
1318       case GL_MAP2_VERTEX_ATTRIB1_4_NV:
1319       case GL_MAP2_VERTEX_ATTRIB2_4_NV:
1320       case GL_MAP2_VERTEX_ATTRIB3_4_NV:
1321       case GL_MAP2_VERTEX_ATTRIB4_4_NV:
1322       case GL_MAP2_VERTEX_ATTRIB5_4_NV:
1323       case GL_MAP2_VERTEX_ATTRIB6_4_NV:
1324       case GL_MAP2_VERTEX_ATTRIB7_4_NV:
1325       case GL_MAP2_VERTEX_ATTRIB8_4_NV:
1326       case GL_MAP2_VERTEX_ATTRIB9_4_NV:
1327       case GL_MAP2_VERTEX_ATTRIB10_4_NV:
1328       case GL_MAP2_VERTEX_ATTRIB11_4_NV:
1329       case GL_MAP2_VERTEX_ATTRIB12_4_NV:
1330       case GL_MAP2_VERTEX_ATTRIB13_4_NV:
1331       case GL_MAP2_VERTEX_ATTRIB14_4_NV:
1332       case GL_MAP2_VERTEX_ATTRIB15_4_NV:
1333          CHECK_EXTENSION(NV_vertex_program);
1334          {
1335             const GLuint map = (GLuint) (cap - GL_MAP2_VERTEX_ATTRIB0_4_NV);
1336             return ctx->Eval.Map2Attrib[map];
1337          }
1338 #endif /* FEATURE_NV_vertex_program */
1339
1340 #if FEATURE_NV_fragment_program
1341       case GL_FRAGMENT_PROGRAM_NV:
1342          CHECK_EXTENSION(NV_fragment_program);
1343          return ctx->FragmentProgram.Enabled;
1344 #endif /* FEATURE_NV_fragment_program */
1345
1346       /* GL_NV_texture_rectangle */
1347       case GL_TEXTURE_RECTANGLE_NV:
1348          CHECK_EXTENSION(NV_texture_rectangle);
1349          return is_texture_enabled(ctx, TEXTURE_RECT_BIT);
1350
1351       /* GL_EXT_stencil_two_side */
1352       case GL_STENCIL_TEST_TWO_SIDE_EXT:
1353          CHECK_EXTENSION(EXT_stencil_two_side);
1354          return ctx->Stencil.TestTwoSide;
1355
1356 #if FEATURE_ARB_fragment_program
1357       case GL_FRAGMENT_PROGRAM_ARB:
1358          return ctx->FragmentProgram.Enabled;
1359 #endif /* FEATURE_ARB_fragment_program */
1360
1361       /* GL_EXT_depth_bounds_test */
1362       case GL_DEPTH_BOUNDS_TEST_EXT:
1363          CHECK_EXTENSION(EXT_depth_bounds_test);
1364          return ctx->Depth.BoundsTest;
1365
1366       /* GL_ARB_depth_clamp */
1367       case GL_DEPTH_CLAMP:
1368          CHECK_EXTENSION(ARB_depth_clamp);
1369          return ctx->Transform.DepthClamp;
1370
1371 #if FEATURE_ATI_fragment_shader
1372       case GL_FRAGMENT_SHADER_ATI:
1373          CHECK_EXTENSION(ATI_fragment_shader);
1374          return ctx->ATIFragmentShader.Enabled;
1375 #endif /* FEATURE_ATI_fragment_shader */
1376
1377       case GL_TEXTURE_CUBE_MAP_SEAMLESS:
1378          CHECK_EXTENSION(ARB_seamless_cube_map);
1379          return ctx->Texture.CubeMapSeamless;
1380
1381 #if FEATURE_EXT_transform_feedback
1382       case GL_RASTERIZER_DISCARD:
1383          CHECK_EXTENSION(EXT_transform_feedback);
1384          return ctx->TransformFeedback.RasterDiscard;
1385 #endif
1386
1387       /* GL_NV_primitive_restart */
1388       case GL_PRIMITIVE_RESTART_NV:
1389          if (!ctx->Extensions.NV_primitive_restart) {
1390             goto invalid_enum_error;
1391          }
1392          return ctx->Array.PrimitiveRestart;
1393
1394       /* GL 3.1 primitive restart */
1395       case GL_PRIMITIVE_RESTART:
1396          if (ctx->VersionMajor * 10 + ctx->VersionMinor < 31) {
1397             goto invalid_enum_error;
1398          }
1399          return ctx->Array.PrimitiveRestart;
1400
1401       /* GL3.0 - GL_framebuffer_sRGB */
1402       case GL_FRAMEBUFFER_SRGB_EXT:
1403          CHECK_EXTENSION(EXT_framebuffer_sRGB);
1404          return ctx->Color.sRGBEnabled;
1405
1406       default:
1407          goto invalid_enum_error;
1408    }
1409
1410    return GL_FALSE;
1411
1412 invalid_enum_error:
1413    _mesa_error(ctx, GL_INVALID_ENUM, "glIsEnabled(0x%x)", (int) cap);
1414    return GL_FALSE;
1415 }