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    GLbitfield64 flag;
  58    GLboolean *var;
  59
  60    switch (cap) {
  61       case GL_VERTEX_ARRAY:
  62          var = &arrayObj->VertexAttrib[VERT_ATTRIB_POS].Enabled;
  63          flag = VERT_BIT_POS;
  64          break;
  65       case GL_NORMAL_ARRAY:
  66          var = &arrayObj->VertexAttrib[VERT_ATTRIB_NORMAL].Enabled;
  67          flag = VERT_BIT_NORMAL;
  68          break;
  69       case GL_COLOR_ARRAY:
  70          var = &arrayObj->VertexAttrib[VERT_ATTRIB_COLOR0].Enabled;
  71          flag = VERT_BIT_COLOR0;
  72          break;
  73       case GL_INDEX_ARRAY:
  74          var = &arrayObj->VertexAttrib[VERT_ATTRIB_COLOR_INDEX].Enabled;
  75          flag = VERT_BIT_COLOR_INDEX;
  76          break;
  77       case GL_TEXTURE_COORD_ARRAY:
  78          var = &arrayObj->VertexAttrib[VERT_ATTRIB_TEX(ctx->Array.ActiveTexture)].Enabled;
  79          flag = VERT_BIT_TEX(ctx->Array.ActiveTexture);
  80          break;
  81       case GL_EDGE_FLAG_ARRAY:
  82          var = &arrayObj->VertexAttrib[VERT_ATTRIB_EDGEFLAG].Enabled;
  83          flag = VERT_BIT_EDGEFLAG;
  84          break;
  85       case GL_FOG_COORDINATE_ARRAY_EXT:
  86          var = &arrayObj->VertexAttrib[VERT_ATTRIB_FOG].Enabled;
  87          flag = VERT_BIT_FOG;
  88          break;
  89       case GL_SECONDARY_COLOR_ARRAY_EXT:
  90          var = &arrayObj->VertexAttrib[VERT_ATTRIB_COLOR1].Enabled;
  91          flag = VERT_BIT_COLOR1;
  92          break;
  93
  94 #if FEATURE_point_size_array
  95       case GL_POINT_SIZE_ARRAY_OES:
  96          var = &arrayObj->VertexAttrib[VERT_ATTRIB_POINT_SIZE].Enabled;
  97          flag = VERT_BIT_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(VERT_ATTRIB_GENERIC(n) < Elements(ctx->Array.ArrayObj->VertexAttrib));
 122             var = &arrayObj->VertexAttrib[VERT_ATTRIB_GENERIC(n)].Enabled;
 123             flag = VERT_BIT_GENERIC(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_DISTANCE0:
 299       case GL_CLIP_DISTANCE1:
 300       case GL_CLIP_DISTANCE2:
 301       case GL_CLIP_DISTANCE3:
 302       case GL_CLIP_DISTANCE4:
 303       case GL_CLIP_DISTANCE5:
 304       case GL_CLIP_DISTANCE6:
 305       case GL_CLIP_DISTANCE7:
 306          {
 307             const GLuint p = cap - GL_CLIP_DISTANCE0;
 308
 309             if (p >= ctx->Const.MaxClipPlanes)
 310                goto invalid_enum_error;
 311
 312             if ((ctx->Transform.ClipPlanesEnabled & (1 << p))
 313                 == ((GLuint) state << p))
 314                return;
 315
 316             FLUSH_VERTICES(ctx, _NEW_TRANSFORM);
 317
 318             if (state) {
 319                ctx->Transform.ClipPlanesEnabled |= (1 << p);
 320                _mesa_update_clip_plane(ctx, p);
 321             }
 322             else {
 323                ctx->Transform.ClipPlanesEnabled &= ~(1 << p);
 324             }
 325          }
 326          break;
 327 #endif
 328       case GL_COLOR_MATERIAL:
 329          if (ctx->Light.ColorMaterialEnabled == state)
 330             return;
 331          FLUSH_VERTICES(ctx, _NEW_LIGHT);
 332          FLUSH_CURRENT(ctx, 0);
 333          ctx->Light.ColorMaterialEnabled = state;
 334          if (state) {
 335             _mesa_update_color_material( ctx,
 336                                   ctx->Current.Attrib[VERT_ATTRIB_COLOR0] );
 337          }
 338          break;
 339       case GL_CULL_FACE:
 340          if (ctx->Polygon.CullFlag == state)
 341             return;
 342          FLUSH_VERTICES(ctx, _NEW_POLYGON);
 343          ctx->Polygon.CullFlag = state;
 344          break;
 345       case GL_DEPTH_TEST:
 346          if (ctx->Depth.Test == state)
 347             return;
 348          FLUSH_VERTICES(ctx, _NEW_DEPTH);
 349          ctx->Depth.Test = state;
 350          break;
 351       case GL_DITHER:
 352          if (ctx->Color.DitherFlag == state)
 353             return;
 354          FLUSH_VERTICES(ctx, _NEW_COLOR);
 355          ctx->Color.DitherFlag = state;
 356          break;
 357       case GL_FOG:
 358          if (ctx->Fog.Enabled == state)
 359             return;
 360          FLUSH_VERTICES(ctx, _NEW_FOG);
 361          ctx->Fog.Enabled = state;
 362          break;
 363       case GL_LIGHT0:
 364       case GL_LIGHT1:
 365       case GL_LIGHT2:
 366       case GL_LIGHT3:
 367       case GL_LIGHT4:
 368       case GL_LIGHT5:
 369       case GL_LIGHT6:
 370       case GL_LIGHT7:
 371          if (ctx->Light.Light[cap-GL_LIGHT0].Enabled == state)
 372             return;
 373          FLUSH_VERTICES(ctx, _NEW_LIGHT);
 374          ctx->Light.Light[cap-GL_LIGHT0].Enabled = state;
 375          if (state) {
 376             insert_at_tail(&ctx->Light.EnabledList,
 377                            &ctx->Light.Light[cap-GL_LIGHT0]);
 378          }
 379          else {
 380             remove_from_list(&ctx->Light.Light[cap-GL_LIGHT0]);
 381          }
 382          break;
 383       case GL_LIGHTING:
 384          if (ctx->Light.Enabled == state)
 385             return;
 386          FLUSH_VERTICES(ctx, _NEW_LIGHT);
 387          ctx->Light.Enabled = state;
 388          if (ctx->Light.Enabled && ctx->Light.Model.TwoSide)
 389             ctx->_TriangleCaps |= DD_TRI_LIGHT_TWOSIDE;
 390          else
 391             ctx->_TriangleCaps &= ~DD_TRI_LIGHT_TWOSIDE;
 392          break;
 393       case GL_LINE_SMOOTH:
 394          if (ctx->Line.SmoothFlag == state)
 395             return;
 396          FLUSH_VERTICES(ctx, _NEW_LINE);
 397          ctx->Line.SmoothFlag = state;
 398          ctx->_TriangleCaps ^= DD_LINE_SMOOTH;
 399          break;
 400       case GL_LINE_STIPPLE:
 401          if (ctx->Line.StippleFlag == state)
 402             return;
 403          FLUSH_VERTICES(ctx, _NEW_LINE);
 404          ctx->Line.StippleFlag = state;
 405          ctx->_TriangleCaps ^= DD_LINE_STIPPLE;
 406          break;
 407       case GL_INDEX_LOGIC_OP:
 408          if (ctx->Color.IndexLogicOpEnabled == state)
 409             return;
 410          FLUSH_VERTICES(ctx, _NEW_COLOR);
 411          ctx->Color.IndexLogicOpEnabled = state;
 412          break;
 413       case GL_COLOR_LOGIC_OP:
 414          if (ctx->Color.ColorLogicOpEnabled == state)
 415             return;
 416          FLUSH_VERTICES(ctx, _NEW_COLOR);
 417          ctx->Color.ColorLogicOpEnabled = state;
 418          break;
 419       case GL_MAP1_COLOR_4:
 420          if (ctx->Eval.Map1Color4 == state)
 421             return;
 422          FLUSH_VERTICES(ctx, _NEW_EVAL);
 423          ctx->Eval.Map1Color4 = state;
 424          break;
 425       case GL_MAP1_INDEX:
 426          if (ctx->Eval.Map1Index == state)
 427             return;
 428          FLUSH_VERTICES(ctx, _NEW_EVAL);
 429          ctx->Eval.Map1Index = state;
 430          break;
 431       case GL_MAP1_NORMAL:
 432          if (ctx->Eval.Map1Normal == state)
 433             return;
 434          FLUSH_VERTICES(ctx, _NEW_EVAL);
 435          ctx->Eval.Map1Normal = state;
 436          break;
 437       case GL_MAP1_TEXTURE_COORD_1:
 438          if (ctx->Eval.Map1TextureCoord1 == state)
 439             return;
 440          FLUSH_VERTICES(ctx, _NEW_EVAL);
 441          ctx->Eval.Map1TextureCoord1 = state;
 442          break;
 443       case GL_MAP1_TEXTURE_COORD_2:
 444          if (ctx->Eval.Map1TextureCoord2 == state)
 445             return;
 446          FLUSH_VERTICES(ctx, _NEW_EVAL);
 447          ctx->Eval.Map1TextureCoord2 = state;
 448          break;
 449       case GL_MAP1_TEXTURE_COORD_3:
 450          if (ctx->Eval.Map1TextureCoord3 == state)
 451             return;
 452          FLUSH_VERTICES(ctx, _NEW_EVAL);
 453          ctx->Eval.Map1TextureCoord3 = state;
 454          break;
 455       case GL_MAP1_TEXTURE_COORD_4:
 456          if (ctx->Eval.Map1TextureCoord4 == state)
 457             return;
 458          FLUSH_VERTICES(ctx, _NEW_EVAL);
 459          ctx->Eval.Map1TextureCoord4 = state;
 460          break;
 461       case GL_MAP1_VERTEX_3:
 462          if (ctx->Eval.Map1Vertex3 == state)
 463             return;
 464          FLUSH_VERTICES(ctx, _NEW_EVAL);
 465          ctx->Eval.Map1Vertex3 = state;
 466          break;
 467       case GL_MAP1_VERTEX_4:
 468          if (ctx->Eval.Map1Vertex4 == state)
 469             return;
 470          FLUSH_VERTICES(ctx, _NEW_EVAL);
 471          ctx->Eval.Map1Vertex4 = state;
 472          break;
 473       case GL_MAP2_COLOR_4:
 474          if (ctx->Eval.Map2Color4 == state)
 475             return;
 476          FLUSH_VERTICES(ctx, _NEW_EVAL);
 477          ctx->Eval.Map2Color4 = state;
 478          break;
 479       case GL_MAP2_INDEX:
 480          if (ctx->Eval.Map2Index == state)
 481             return;
 482          FLUSH_VERTICES(ctx, _NEW_EVAL);
 483          ctx->Eval.Map2Index = state;
 484          break;
 485       case GL_MAP2_NORMAL:
 486          if (ctx->Eval.Map2Normal == state)
 487             return;
 488          FLUSH_VERTICES(ctx, _NEW_EVAL);
 489          ctx->Eval.Map2Normal = state;
 490          break;
 491       case GL_MAP2_TEXTURE_COORD_1:
 492          if (ctx->Eval.Map2TextureCoord1 == state)
 493             return;
 494          FLUSH_VERTICES(ctx, _NEW_EVAL);
 495          ctx->Eval.Map2TextureCoord1 = state;
 496          break;
 497       case GL_MAP2_TEXTURE_COORD_2:
 498          if (ctx->Eval.Map2TextureCoord2 == state)
 499             return;
 500          FLUSH_VERTICES(ctx, _NEW_EVAL);
 501          ctx->Eval.Map2TextureCoord2 = state;
 502          break;
 503       case GL_MAP2_TEXTURE_COORD_3:
 504          if (ctx->Eval.Map2TextureCoord3 == state)
 505             return;
 506          FLUSH_VERTICES(ctx, _NEW_EVAL);
 507          ctx->Eval.Map2TextureCoord3 = state;
 508          break;
 509       case GL_MAP2_TEXTURE_COORD_4:
 510          if (ctx->Eval.Map2TextureCoord4 == state)
 511             return;
 512          FLUSH_VERTICES(ctx, _NEW_EVAL);
 513          ctx->Eval.Map2TextureCoord4 = state;
 514          break;
 515       case GL_MAP2_VERTEX_3:
 516          if (ctx->Eval.Map2Vertex3 == state)
 517             return;
 518          FLUSH_VERTICES(ctx, _NEW_EVAL);
 519          ctx->Eval.Map2Vertex3 = state;
 520          break;
 521       case GL_MAP2_VERTEX_4:
 522          if (ctx->Eval.Map2Vertex4 == state)
 523             return;
 524          FLUSH_VERTICES(ctx, _NEW_EVAL);
 525          ctx->Eval.Map2Vertex4 = state;
 526          break;
 527       case GL_NORMALIZE:
 528          if (ctx->Transform.Normalize == state)
 529             return;
 530          FLUSH_VERTICES(ctx, _NEW_TRANSFORM);
 531          ctx->Transform.Normalize = state;
 532          break;
 533       case GL_POINT_SMOOTH:
 534          if (ctx->Point.SmoothFlag == state)
 535             return;
 536          FLUSH_VERTICES(ctx, _NEW_POINT);
 537          ctx->Point.SmoothFlag = state;
 538          ctx->_TriangleCaps ^= DD_POINT_SMOOTH;
 539          break;
 540       case GL_POLYGON_SMOOTH:
 541          if (ctx->Polygon.SmoothFlag == state)
 542             return;
 543          FLUSH_VERTICES(ctx, _NEW_POLYGON);
 544          ctx->Polygon.SmoothFlag = state;
 545          ctx->_TriangleCaps ^= DD_TRI_SMOOTH;
 546          break;
 547       case GL_POLYGON_STIPPLE:
 548          if (ctx->Polygon.StippleFlag == state)
 549             return;
 550          FLUSH_VERTICES(ctx, _NEW_POLYGON);
 551          ctx->Polygon.StippleFlag = state;
 552          ctx->_TriangleCaps ^= DD_TRI_STIPPLE;
 553          break;
 554       case GL_POLYGON_OFFSET_POINT:
 555          if (ctx->Polygon.OffsetPoint == state)
 556             return;
 557          FLUSH_VERTICES(ctx, _NEW_POLYGON);
 558          ctx->Polygon.OffsetPoint = state;
 559          break;
 560       case GL_POLYGON_OFFSET_LINE:
 561          if (ctx->Polygon.OffsetLine == state)
 562             return;
 563          FLUSH_VERTICES(ctx, _NEW_POLYGON);
 564          ctx->Polygon.OffsetLine = state;
 565          break;
 566       case GL_POLYGON_OFFSET_FILL:
 567          if (ctx->Polygon.OffsetFill == state)
 568             return;
 569          FLUSH_VERTICES(ctx, _NEW_POLYGON);
 570          ctx->Polygon.OffsetFill = state;
 571          break;
 572       case GL_RESCALE_NORMAL_EXT:
 573          if (ctx->Transform.RescaleNormals == state)
 574             return;
 575          FLUSH_VERTICES(ctx, _NEW_TRANSFORM);
 576          ctx->Transform.RescaleNormals = state;
 577          break;
 578       case GL_SCISSOR_TEST:
 579          if (ctx->Scissor.Enabled == state)
 580             return;
 581          FLUSH_VERTICES(ctx, _NEW_SCISSOR);
 582          ctx->Scissor.Enabled = state;
 583          break;
 584       case GL_STENCIL_TEST:
 585          if (ctx->Stencil.Enabled == state)
 586             return;
 587          FLUSH_VERTICES(ctx, _NEW_STENCIL);
 588          ctx->Stencil.Enabled = state;
 589          break;
 590       case GL_TEXTURE_1D:
 591          if (!enable_texture(ctx, state, TEXTURE_1D_BIT)) {
 592             return;
 593          }
 594          break;
 595       case GL_TEXTURE_2D:
 596          if (!enable_texture(ctx, state, TEXTURE_2D_BIT)) {
 597             return;
 598          }
 599          break;
 600       case GL_TEXTURE_3D:
 601          if (!enable_texture(ctx, state, TEXTURE_3D_BIT)) {
 602             return;
 603          }
 604          break;
 605       case GL_TEXTURE_GEN_S:
 606       case GL_TEXTURE_GEN_T:
 607       case GL_TEXTURE_GEN_R:
 608       case GL_TEXTURE_GEN_Q:
 609          {
 610             struct gl_texture_unit *texUnit = get_texcoord_unit(ctx);
 611             if (texUnit) {
 612                GLbitfield coordBit = S_BIT << (cap - GL_TEXTURE_GEN_S);
 613                GLbitfield newenabled = texUnit->TexGenEnabled & ~coordBit;
 614                if (state)
 615                   newenabled |= coordBit;
 616                if (texUnit->TexGenEnabled == newenabled)
 617                   return;
 618                FLUSH_VERTICES(ctx, _NEW_TEXTURE);
 619                texUnit->TexGenEnabled = newenabled;
 620             }
 621          }
 622          break;
 623
 624 #if FEATURE_ES1
 625       case GL_TEXTURE_GEN_STR_OES:
 626          /* disable S, T, and R at the same time */
 627          {
 628             struct gl_texture_unit *texUnit = get_texcoord_unit(ctx);
 629             if (texUnit) {
 630                GLuint newenabled =
 631                   texUnit->TexGenEnabled & ~STR_BITS;
 632                if (state)
 633                   newenabled |= STR_BITS;
 634                if (texUnit->TexGenEnabled == newenabled)
 635                   return;
 636                FLUSH_VERTICES(ctx, _NEW_TEXTURE);
 637                texUnit->TexGenEnabled = newenabled;
 638             }
 639          }
 640          break;
 641 #endif
 642
 643       /* client-side state */
 644       case GL_VERTEX_ARRAY:
 645       case GL_NORMAL_ARRAY:
 646       case GL_COLOR_ARRAY:
 647       case GL_INDEX_ARRAY:
 648       case GL_TEXTURE_COORD_ARRAY:
 649       case GL_EDGE_FLAG_ARRAY:
 650       case GL_FOG_COORDINATE_ARRAY_EXT:
 651       case GL_SECONDARY_COLOR_ARRAY_EXT:
 652       case GL_POINT_SIZE_ARRAY_OES:
 653          client_state( ctx, cap, state );
 654          return;
 655
 656       /* GL_ARB_texture_cube_map */
 657       case GL_TEXTURE_CUBE_MAP_ARB:
 658          CHECK_EXTENSION(ARB_texture_cube_map, cap);
 659          if (!enable_texture(ctx, state, TEXTURE_CUBE_BIT)) {
 660             return;
 661          }
 662          break;
 663
 664       /* GL_EXT_secondary_color */
 665       case GL_COLOR_SUM_EXT:
 666          CHECK_EXTENSION2(EXT_secondary_color, ARB_vertex_program, cap);
 667          if (ctx->Fog.ColorSumEnabled == state)
 668             return;
 669          FLUSH_VERTICES(ctx, _NEW_FOG);
 670          ctx->Fog.ColorSumEnabled = state;
 671          break;
 672
 673       /* GL_ARB_multisample */
 674       case GL_MULTISAMPLE_ARB:
 675          if (ctx->Multisample.Enabled == state)
 676             return;
 677          FLUSH_VERTICES(ctx, _NEW_MULTISAMPLE);
 678          ctx->Multisample.Enabled = state;
 679          break;
 680       case GL_SAMPLE_ALPHA_TO_COVERAGE_ARB:
 681          if (ctx->Multisample.SampleAlphaToCoverage == state)
 682             return;
 683          FLUSH_VERTICES(ctx, _NEW_MULTISAMPLE);
 684          ctx->Multisample.SampleAlphaToCoverage = state;
 685          break;
 686       case GL_SAMPLE_ALPHA_TO_ONE_ARB:
 687          if (ctx->Multisample.SampleAlphaToOne == state)
 688             return;
 689          FLUSH_VERTICES(ctx, _NEW_MULTISAMPLE);
 690          ctx->Multisample.SampleAlphaToOne = state;
 691          break;
 692       case GL_SAMPLE_COVERAGE_ARB:
 693          if (ctx->Multisample.SampleCoverage == state)
 694             return;
 695          FLUSH_VERTICES(ctx, _NEW_MULTISAMPLE);
 696          ctx->Multisample.SampleCoverage = state;
 697          break;
 698       case GL_SAMPLE_COVERAGE_INVERT_ARB:
 699          if (ctx->Multisample.SampleCoverageInvert == state)
 700             return;
 701          FLUSH_VERTICES(ctx, _NEW_MULTISAMPLE);
 702          ctx->Multisample.SampleCoverageInvert = state;
 703          break;
 704
 705       /* GL_IBM_rasterpos_clip */
 706       case GL_RASTER_POSITION_UNCLIPPED_IBM:
 707          CHECK_EXTENSION(IBM_rasterpos_clip, cap);
 708          if (ctx->Transform.RasterPositionUnclipped == state)
 709             return;
 710          FLUSH_VERTICES(ctx, _NEW_TRANSFORM);
 711          ctx->Transform.RasterPositionUnclipped = state;
 712          break;
 713
 714       /* GL_NV_point_sprite */
 715       case GL_POINT_SPRITE_NV:
 716          CHECK_EXTENSION2(NV_point_sprite, ARB_point_sprite, cap);
 717          if (ctx->Point.PointSprite == state)
 718             return;
 719          FLUSH_VERTICES(ctx, _NEW_POINT);
 720          ctx->Point.PointSprite = state;
 721          break;
 722
 723 #if FEATURE_NV_vertex_program || FEATURE_ARB_vertex_program
 724       case GL_VERTEX_PROGRAM_ARB:
 725          CHECK_EXTENSION2(ARB_vertex_program, NV_vertex_program, cap);
 726          if (ctx->VertexProgram.Enabled == state)
 727             return;
 728          FLUSH_VERTICES(ctx, _NEW_PROGRAM);
 729          ctx->VertexProgram.Enabled = state;
 730          break;
 731       case GL_VERTEX_PROGRAM_POINT_SIZE_ARB:
 732          CHECK_EXTENSION2(ARB_vertex_program, NV_vertex_program, cap);
 733          if (ctx->VertexProgram.PointSizeEnabled == state)
 734             return;
 735          FLUSH_VERTICES(ctx, _NEW_PROGRAM);
 736          ctx->VertexProgram.PointSizeEnabled = state;
 737          break;
 738       case GL_VERTEX_PROGRAM_TWO_SIDE_ARB:
 739          CHECK_EXTENSION2(ARB_vertex_program, NV_vertex_program, cap);
 740          if (ctx->VertexProgram.TwoSideEnabled == state)
 741             return;
 742          FLUSH_VERTICES(ctx, _NEW_PROGRAM);
 743          ctx->VertexProgram.TwoSideEnabled = state;
 744          break;
 745 #endif
 746 #if FEATURE_NV_vertex_program
 747       case GL_MAP1_VERTEX_ATTRIB0_4_NV:
 748       case GL_MAP1_VERTEX_ATTRIB1_4_NV:
 749       case GL_MAP1_VERTEX_ATTRIB2_4_NV:
 750       case GL_MAP1_VERTEX_ATTRIB3_4_NV:
 751       case GL_MAP1_VERTEX_ATTRIB4_4_NV:
 752       case GL_MAP1_VERTEX_ATTRIB5_4_NV:
 753       case GL_MAP1_VERTEX_ATTRIB6_4_NV:
 754       case GL_MAP1_VERTEX_ATTRIB7_4_NV:
 755       case GL_MAP1_VERTEX_ATTRIB8_4_NV:
 756       case GL_MAP1_VERTEX_ATTRIB9_4_NV:
 757       case GL_MAP1_VERTEX_ATTRIB10_4_NV:
 758       case GL_MAP1_VERTEX_ATTRIB11_4_NV:
 759       case GL_MAP1_VERTEX_ATTRIB12_4_NV:
 760       case GL_MAP1_VERTEX_ATTRIB13_4_NV:
 761       case GL_MAP1_VERTEX_ATTRIB14_4_NV:
 762       case GL_MAP1_VERTEX_ATTRIB15_4_NV:
 763          CHECK_EXTENSION(NV_vertex_program, cap);
 764          {
 765             const GLuint map = (GLuint) (cap - GL_MAP1_VERTEX_ATTRIB0_4_NV);
 766             FLUSH_VERTICES(ctx, _NEW_EVAL);
 767             ctx->Eval.Map1Attrib[map] = state;
 768          }
 769          break;
 770       case GL_MAP2_VERTEX_ATTRIB0_4_NV:
 771       case GL_MAP2_VERTEX_ATTRIB1_4_NV:
 772       case GL_MAP2_VERTEX_ATTRIB2_4_NV:
 773       case GL_MAP2_VERTEX_ATTRIB3_4_NV:
 774       case GL_MAP2_VERTEX_ATTRIB4_4_NV:
 775       case GL_MAP2_VERTEX_ATTRIB5_4_NV:
 776       case GL_MAP2_VERTEX_ATTRIB6_4_NV:
 777       case GL_MAP2_VERTEX_ATTRIB7_4_NV:
 778       case GL_MAP2_VERTEX_ATTRIB8_4_NV:
 779       case GL_MAP2_VERTEX_ATTRIB9_4_NV:
 780       case GL_MAP2_VERTEX_ATTRIB10_4_NV:
 781       case GL_MAP2_VERTEX_ATTRIB11_4_NV:
 782       case GL_MAP2_VERTEX_ATTRIB12_4_NV:
 783       case GL_MAP2_VERTEX_ATTRIB13_4_NV:
 784       case GL_MAP2_VERTEX_ATTRIB14_4_NV:
 785       case GL_MAP2_VERTEX_ATTRIB15_4_NV:
 786          CHECK_EXTENSION(NV_vertex_program, cap);
 787          {
 788             const GLuint map = (GLuint) (cap - GL_MAP2_VERTEX_ATTRIB0_4_NV);
 789             FLUSH_VERTICES(ctx, _NEW_EVAL);
 790             ctx->Eval.Map2Attrib[map] = state;
 791          }
 792          break;
 793 #endif /* FEATURE_NV_vertex_program */
 794
 795 #if FEATURE_NV_fragment_program
 796       case GL_FRAGMENT_PROGRAM_NV:
 797          CHECK_EXTENSION(NV_fragment_program, cap);
 798          if (ctx->FragmentProgram.Enabled == state)
 799             return;
 800          FLUSH_VERTICES(ctx, _NEW_PROGRAM);
 801          ctx->FragmentProgram.Enabled = state;
 802          break;
 803 #endif /* FEATURE_NV_fragment_program */
 804
 805       /* GL_NV_texture_rectangle */
 806       case GL_TEXTURE_RECTANGLE_NV:
 807          CHECK_EXTENSION(NV_texture_rectangle, cap);
 808          if (!enable_texture(ctx, state, TEXTURE_RECT_BIT)) {
 809             return;
 810          }
 811          break;
 812
 813       /* GL_EXT_stencil_two_side */
 814       case GL_STENCIL_TEST_TWO_SIDE_EXT:
 815          CHECK_EXTENSION(EXT_stencil_two_side, cap);
 816          if (ctx->Stencil.TestTwoSide == state)
 817             return;
 818          FLUSH_VERTICES(ctx, _NEW_STENCIL);
 819          ctx->Stencil.TestTwoSide = state;
 820          if (state) {
 821             ctx->Stencil._BackFace = 2;
 822             ctx->_TriangleCaps |= DD_TRI_TWOSTENCIL;
 823          } else {
 824             ctx->Stencil._BackFace = 1;
 825             ctx->_TriangleCaps &= ~DD_TRI_TWOSTENCIL;
 826          }
 827          break;
 828
 829 #if FEATURE_ARB_fragment_program
 830       case GL_FRAGMENT_PROGRAM_ARB:
 831          CHECK_EXTENSION(ARB_fragment_program, cap);
 832          if (ctx->FragmentProgram.Enabled == state)
 833             return;
 834          FLUSH_VERTICES(ctx, _NEW_PROGRAM);
 835          ctx->FragmentProgram.Enabled = state;
 836          break;
 837 #endif /* FEATURE_ARB_fragment_program */
 838
 839       /* GL_EXT_depth_bounds_test */
 840       case GL_DEPTH_BOUNDS_TEST_EXT:
 841          CHECK_EXTENSION(EXT_depth_bounds_test, cap);
 842          if (ctx->Depth.BoundsTest == state)
 843             return;
 844          FLUSH_VERTICES(ctx, _NEW_DEPTH);
 845          ctx->Depth.BoundsTest = state;
 846          break;
 847
 848       case GL_DEPTH_CLAMP:
 849          if (ctx->Transform.DepthClamp == state)
 850             return;
 851          CHECK_EXTENSION(ARB_depth_clamp, cap);
 852          FLUSH_VERTICES(ctx, _NEW_TRANSFORM);
 853          ctx->Transform.DepthClamp = state;
 854          break;
 855
 856 #if FEATURE_ATI_fragment_shader
 857       case GL_FRAGMENT_SHADER_ATI:
 858         CHECK_EXTENSION(ATI_fragment_shader, cap);
 859         if (ctx->ATIFragmentShader.Enabled == state)
 860           return;
 861         FLUSH_VERTICES(ctx, _NEW_PROGRAM);
 862         ctx->ATIFragmentShader.Enabled = state;
 863         break;
 864 #endif
 865
 866       /* GL_MESA_texture_array */
 867       case GL_TEXTURE_1D_ARRAY_EXT:
 868          CHECK_EXTENSION(MESA_texture_array, cap);
 869          if (!enable_texture(ctx, state, TEXTURE_1D_ARRAY_BIT)) {
 870             return;
 871          }
 872          break;
 873
 874       case GL_TEXTURE_2D_ARRAY_EXT:
 875          CHECK_EXTENSION(MESA_texture_array, cap);
 876          if (!enable_texture(ctx, state, TEXTURE_2D_ARRAY_BIT)) {
 877             return;
 878          }
 879          break;
 880
 881       case GL_TEXTURE_CUBE_MAP_SEAMLESS:
 882          CHECK_EXTENSION(ARB_seamless_cube_map, cap);
 883          if (ctx->Texture.CubeMapSeamless != state) {
 884             FLUSH_VERTICES(ctx, _NEW_TEXTURE);
 885             ctx->Texture.CubeMapSeamless = state;
 886          }
 887          break;
 888
 889 #if FEATURE_EXT_transform_feedback
 890       case GL_RASTERIZER_DISCARD:
 891          CHECK_EXTENSION(EXT_transform_feedback, cap);
 892          if (ctx->RasterDiscard != state) {
 893             FLUSH_VERTICES(ctx, _NEW_TRANSFORM);
 894             ctx->RasterDiscard = state;
 895          }
 896          break;
 897 #endif
 898
 899       /* GL 3.1 primitive restart.  Note: this enum is different from
 900        * GL_PRIMITIVE_RESTART_NV (which is client state).
 901        */
 902       case GL_PRIMITIVE_RESTART:
 903          if (ctx->VersionMajor * 10 + ctx->VersionMinor < 31) {
 904             goto invalid_enum_error;
 905          }
 906          if (ctx->Array.PrimitiveRestart != state) {
 907             FLUSH_VERTICES(ctx, _NEW_TRANSFORM);
 908             ctx->Array.PrimitiveRestart = state;
 909          }
 910          break;
 911
 912       /* GL3.0 - GL_framebuffer_sRGB */
 913       case GL_FRAMEBUFFER_SRGB_EXT:
 914          CHECK_EXTENSION(EXT_framebuffer_sRGB, cap);
 915          FLUSH_VERTICES(ctx, _NEW_BUFFERS);
 916          ctx->Color.sRGBEnabled = state;
 917          break;
 918
 919       /* GL_OES_EGL_image_external */
 920       case GL_TEXTURE_EXTERNAL_OES:
 921          CHECK_EXTENSION(OES_EGL_image_external, cap);
 922          if (!enable_texture(ctx, state, TEXTURE_EXTERNAL_BIT)) {
 923             return;
 924          }
 925          break;
 926
 927       default:
 928          goto invalid_enum_error;
 929    }
 930
 931    if (ctx->Driver.Enable) {
 932       ctx->Driver.Enable( ctx, cap, state );
 933    }
 934
 935    return;
 936
 937 invalid_enum_error:
 938    _mesa_error(ctx, GL_INVALID_ENUM, "gl%s(0x%x)",
 939                state ? "Enable" : "Disable", cap);
 940 }
 941
 942
 943 /**
 944  * Enable GL capability.  Called by glEnable()
 945  * \param cap  state to enable.
 946  */
 947 void GLAPIENTRY
 948 _mesa_Enable( GLenum cap )
 949 {
 950    GET_CURRENT_CONTEXT(ctx);
 951    ASSERT_OUTSIDE_BEGIN_END(ctx);
 952
 953    _mesa_set_enable( ctx, cap, GL_TRUE );
 954 }
 955
 956
 957 /**
 958  * Disable GL capability.  Called by glDisable()
 959  * \param cap  state to disable.
 960  */
 961 void GLAPIENTRY
 962 _mesa_Disable( GLenum cap )
 963 {
 964    GET_CURRENT_CONTEXT(ctx);
 965    ASSERT_OUTSIDE_BEGIN_END(ctx);
 966
 967    _mesa_set_enable( ctx, cap, GL_FALSE );
 968 }
 969
 970
 971
 972 /**
 973  * Enable/disable an indexed state var.
 974  */
 975 void
 976 _mesa_set_enablei(struct gl_context *ctx, GLenum cap,
 977                   GLuint index, GLboolean state)
 978 {
 979    ASSERT(state == 0 || state == 1);
 980    switch (cap) {
 981    case GL_BLEND:
 982       if (!ctx->Extensions.EXT_draw_buffers2) {
 983          goto invalid_enum_error;
 984       }
 985       if (index >= ctx->Const.MaxDrawBuffers) {
 986          _mesa_error(ctx, GL_INVALID_VALUE, "%s(index=%u)",
 987                      state ? "glEnableIndexed" : "glDisableIndexed", index);
 988          return;
 989       }
 990       if (((ctx->Color.BlendEnabled >> index) & 1) != state) {
 991          FLUSH_VERTICES(ctx, _NEW_COLOR);
 992          if (state)
 993             ctx->Color.BlendEnabled |= (1 << index);
 994          else
 995             ctx->Color.BlendEnabled &= ~(1 << index);
 996       }
 997       break;
 998    default:
 999       goto invalid_enum_error;
1000    }
1001    return;
1002
1003 invalid_enum_error:
1004     _mesa_error(ctx, GL_INVALID_ENUM, "%s(cap=%s)",
1005                 state ? "glEnablei" : "glDisablei",
1006                 _mesa_lookup_enum_by_nr(cap));
1007 }
1008
1009
1010 void GLAPIENTRY
1011 _mesa_DisableIndexed( GLenum cap, GLuint index )
1012 {
1013    GET_CURRENT_CONTEXT(ctx);
1014    ASSERT_OUTSIDE_BEGIN_END(ctx);
1015    _mesa_set_enablei(ctx, cap, index, GL_FALSE);
1016 }
1017
1018
1019 void GLAPIENTRY
1020 _mesa_EnableIndexed( GLenum cap, GLuint index )
1021 {
1022    GET_CURRENT_CONTEXT(ctx);
1023    ASSERT_OUTSIDE_BEGIN_END(ctx);
1024    _mesa_set_enablei(ctx, cap, index, GL_TRUE);
1025 }
1026
1027
1028 GLboolean GLAPIENTRY
1029 _mesa_IsEnabledIndexed( GLenum cap, GLuint index )
1030 {
1031    GET_CURRENT_CONTEXT(ctx);
1032    ASSERT_OUTSIDE_BEGIN_END_WITH_RETVAL(ctx, 0);
1033    switch (cap) {
1034    case GL_BLEND:
1035       if (index >= ctx->Const.MaxDrawBuffers) {
1036          _mesa_error(ctx, GL_INVALID_VALUE, "glIsEnabledIndexed(index=%u)",
1037                      index);
1038          return GL_FALSE;
1039       }
1040       return (ctx->Color.BlendEnabled >> index) & 1;
1041    default:
1042       _mesa_error(ctx, GL_INVALID_ENUM, "glIsEnabledIndexed(cap=%s)",
1043                   _mesa_lookup_enum_by_nr(cap));
1044       return GL_FALSE;
1045    }
1046 }
1047
1048
1049
1050
1051 #undef CHECK_EXTENSION
1052 #define CHECK_EXTENSION(EXTNAME)                        \
1053    if (!ctx->Extensions.EXTNAME) {                      \
1054       goto invalid_enum_error;                          \
1055    }
1056
1057 #undef CHECK_EXTENSION2
1058 #define CHECK_EXTENSION2(EXT1, EXT2)                            \
1059    if (!ctx->Extensions.EXT1 && !ctx->Extensions.EXT2) {        \
1060       goto invalid_enum_error;                                  \
1061    }
1062
1063
1064 /**
1065  * Helper function to determine whether a texture target is enabled.
1066  */
1067 static GLboolean
1068 is_texture_enabled(struct gl_context *ctx, GLbitfield bit)
1069 {
1070    const struct gl_texture_unit *const texUnit =
1071        &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
1072    return (texUnit->Enabled & bit) ? GL_TRUE : GL_FALSE;
1073 }
1074
1075
1076 /**
1077  * Return simple enable/disable state.
1078  *
1079  * \param cap  state variable to query.
1080  *
1081  * Returns the state of the specified capability from the current GL context.
1082  * For the capabilities associated with extensions verifies that those
1083  * extensions are effectively present before reporting.
1084  */
1085 GLboolean GLAPIENTRY
1086 _mesa_IsEnabled( GLenum cap )
1087 {
1088    GET_CURRENT_CONTEXT(ctx);
1089    ASSERT_OUTSIDE_BEGIN_END_WITH_RETVAL(ctx, 0);
1090
1091    switch (cap) {
1092       case GL_ALPHA_TEST:
1093          return ctx->Color.AlphaEnabled;
1094       case GL_AUTO_NORMAL:
1095          return ctx->Eval.AutoNormal;
1096       case GL_BLEND:
1097          return ctx->Color.BlendEnabled & 1;  /* return state for buffer[0] */
1098       case GL_CLIP_DISTANCE0:
1099       case GL_CLIP_DISTANCE1:
1100       case GL_CLIP_DISTANCE2:
1101       case GL_CLIP_DISTANCE3:
1102       case GL_CLIP_DISTANCE4:
1103       case GL_CLIP_DISTANCE5:
1104       case GL_CLIP_DISTANCE6:
1105       case GL_CLIP_DISTANCE7: {
1106          const GLuint p = cap - GL_CLIP_DISTANCE0;
1107
1108          if (p >= ctx->Const.MaxClipPlanes)
1109             goto invalid_enum_error;
1110
1111          return (ctx->Transform.ClipPlanesEnabled >> p) & 1;
1112       }
1113       case GL_COLOR_MATERIAL:
1114          return ctx->Light.ColorMaterialEnabled;
1115       case GL_CULL_FACE:
1116          return ctx->Polygon.CullFlag;
1117       case GL_DEPTH_TEST:
1118          return ctx->Depth.Test;
1119       case GL_DITHER:
1120          return ctx->Color.DitherFlag;
1121       case GL_FOG:
1122          return ctx->Fog.Enabled;
1123       case GL_LIGHTING:
1124          return ctx->Light.Enabled;
1125       case GL_LIGHT0:
1126       case GL_LIGHT1:
1127       case GL_LIGHT2:
1128       case GL_LIGHT3:
1129       case GL_LIGHT4:
1130       case GL_LIGHT5:
1131       case GL_LIGHT6:
1132       case GL_LIGHT7:
1133          return ctx->Light.Light[cap-GL_LIGHT0].Enabled;
1134       case GL_LINE_SMOOTH:
1135          return ctx->Line.SmoothFlag;
1136       case GL_LINE_STIPPLE:
1137          return ctx->Line.StippleFlag;
1138       case GL_INDEX_LOGIC_OP:
1139          return ctx->Color.IndexLogicOpEnabled;
1140       case GL_COLOR_LOGIC_OP:
1141          return ctx->Color.ColorLogicOpEnabled;
1142       case GL_MAP1_COLOR_4:
1143          return ctx->Eval.Map1Color4;
1144       case GL_MAP1_INDEX:
1145          return ctx->Eval.Map1Index;
1146       case GL_MAP1_NORMAL:
1147          return ctx->Eval.Map1Normal;
1148       case GL_MAP1_TEXTURE_COORD_1:
1149          return ctx->Eval.Map1TextureCoord1;
1150       case GL_MAP1_TEXTURE_COORD_2:
1151          return ctx->Eval.Map1TextureCoord2;
1152       case GL_MAP1_TEXTURE_COORD_3:
1153          return ctx->Eval.Map1TextureCoord3;
1154       case GL_MAP1_TEXTURE_COORD_4:
1155          return ctx->Eval.Map1TextureCoord4;
1156       case GL_MAP1_VERTEX_3:
1157          return ctx->Eval.Map1Vertex3;
1158       case GL_MAP1_VERTEX_4:
1159          return ctx->Eval.Map1Vertex4;
1160       case GL_MAP2_COLOR_4:
1161          return ctx->Eval.Map2Color4;
1162       case GL_MAP2_INDEX:
1163          return ctx->Eval.Map2Index;
1164       case GL_MAP2_NORMAL:
1165          return ctx->Eval.Map2Normal;
1166       case GL_MAP2_TEXTURE_COORD_1:
1167          return ctx->Eval.Map2TextureCoord1;
1168       case GL_MAP2_TEXTURE_COORD_2:
1169          return ctx->Eval.Map2TextureCoord2;
1170       case GL_MAP2_TEXTURE_COORD_3:
1171          return ctx->Eval.Map2TextureCoord3;
1172       case GL_MAP2_TEXTURE_COORD_4:
1173          return ctx->Eval.Map2TextureCoord4;
1174       case GL_MAP2_VERTEX_3:
1175          return ctx->Eval.Map2Vertex3;
1176       case GL_MAP2_VERTEX_4:
1177          return ctx->Eval.Map2Vertex4;
1178       case GL_NORMALIZE:
1179          return ctx->Transform.Normalize;
1180       case GL_POINT_SMOOTH:
1181          return ctx->Point.SmoothFlag;
1182       case GL_POLYGON_SMOOTH:
1183          return ctx->Polygon.SmoothFlag;
1184       case GL_POLYGON_STIPPLE:
1185          return ctx->Polygon.StippleFlag;
1186       case GL_POLYGON_OFFSET_POINT:
1187          return ctx->Polygon.OffsetPoint;
1188       case GL_POLYGON_OFFSET_LINE:
1189          return ctx->Polygon.OffsetLine;
1190       case GL_POLYGON_OFFSET_FILL:
1191          return ctx->Polygon.OffsetFill;
1192       case GL_RESCALE_NORMAL_EXT:
1193          return ctx->Transform.RescaleNormals;
1194       case GL_SCISSOR_TEST:
1195          return ctx->Scissor.Enabled;
1196       case GL_STENCIL_TEST:
1197          return ctx->Stencil.Enabled;
1198       case GL_TEXTURE_1D:
1199          return is_texture_enabled(ctx, TEXTURE_1D_BIT);
1200       case GL_TEXTURE_2D:
1201          return is_texture_enabled(ctx, TEXTURE_2D_BIT);
1202       case GL_TEXTURE_3D:
1203          return is_texture_enabled(ctx, TEXTURE_3D_BIT);
1204       case GL_TEXTURE_GEN_S:
1205       case GL_TEXTURE_GEN_T:
1206       case GL_TEXTURE_GEN_R:
1207       case GL_TEXTURE_GEN_Q:
1208          {
1209             const struct gl_texture_unit *texUnit = get_texcoord_unit(ctx);
1210             if (texUnit) {
1211                GLbitfield coordBit = S_BIT << (cap - GL_TEXTURE_GEN_S);
1212                return (texUnit->TexGenEnabled & coordBit) ? GL_TRUE : GL_FALSE;
1213             }
1214          }
1215          return GL_FALSE;
1216 #if FEATURE_ES1
1217       case GL_TEXTURE_GEN_STR_OES:
1218          {
1219             const struct gl_texture_unit *texUnit = get_texcoord_unit(ctx);
1220             if (texUnit) {
1221                return (texUnit->TexGenEnabled & STR_BITS) == STR_BITS
1222                   ? GL_TRUE : GL_FALSE;
1223             }
1224          }
1225 #endif
1226
1227       /* client-side state */
1228       case GL_VERTEX_ARRAY:
1229          return (ctx->Array.ArrayObj->VertexAttrib[VERT_ATTRIB_POS].Enabled != 0);
1230       case GL_NORMAL_ARRAY:
1231          return (ctx->Array.ArrayObj->VertexAttrib[VERT_ATTRIB_NORMAL].Enabled != 0);
1232       case GL_COLOR_ARRAY:
1233          return (ctx->Array.ArrayObj->VertexAttrib[VERT_ATTRIB_COLOR0].Enabled != 0);
1234       case GL_INDEX_ARRAY:
1235          return (ctx->Array.ArrayObj->VertexAttrib[VERT_ATTRIB_COLOR_INDEX].Enabled != 0);
1236       case GL_TEXTURE_COORD_ARRAY:
1237          return (ctx->Array.ArrayObj->VertexAttrib[VERT_ATTRIB_TEX(ctx->Array.ActiveTexture)]
1238                  .Enabled != 0);
1239       case GL_EDGE_FLAG_ARRAY:
1240          return (ctx->Array.ArrayObj->VertexAttrib[VERT_ATTRIB_EDGEFLAG].Enabled != 0);
1241       case GL_FOG_COORDINATE_ARRAY_EXT:
1242          CHECK_EXTENSION(EXT_fog_coord);
1243          return (ctx->Array.ArrayObj->VertexAttrib[VERT_ATTRIB_FOG].Enabled != 0);
1244       case GL_SECONDARY_COLOR_ARRAY_EXT:
1245          CHECK_EXTENSION(EXT_secondary_color);
1246          return (ctx->Array.ArrayObj->VertexAttrib[VERT_ATTRIB_COLOR1].Enabled != 0);
1247 #if FEATURE_point_size_array
1248       case GL_POINT_SIZE_ARRAY_OES:
1249          return (ctx->Array.ArrayObj->VertexAttrib[VERT_ATTRIB_POINT_SIZE].Enabled != 0);
1250 #endif
1251
1252       /* GL_ARB_texture_cube_map */
1253       case GL_TEXTURE_CUBE_MAP_ARB:
1254          CHECK_EXTENSION(ARB_texture_cube_map);
1255          return is_texture_enabled(ctx, TEXTURE_CUBE_BIT);
1256
1257       /* GL_EXT_secondary_color */
1258       case GL_COLOR_SUM_EXT:
1259          CHECK_EXTENSION2(EXT_secondary_color, ARB_vertex_program);
1260          return ctx->Fog.ColorSumEnabled;
1261
1262       /* GL_ARB_multisample */
1263       case GL_MULTISAMPLE_ARB:
1264          return ctx->Multisample.Enabled;
1265       case GL_SAMPLE_ALPHA_TO_COVERAGE_ARB:
1266          return ctx->Multisample.SampleAlphaToCoverage;
1267       case GL_SAMPLE_ALPHA_TO_ONE_ARB:
1268          return ctx->Multisample.SampleAlphaToOne;
1269       case GL_SAMPLE_COVERAGE_ARB:
1270          return ctx->Multisample.SampleCoverage;
1271       case GL_SAMPLE_COVERAGE_INVERT_ARB:
1272          return ctx->Multisample.SampleCoverageInvert;
1273
1274       /* GL_IBM_rasterpos_clip */
1275       case GL_RASTER_POSITION_UNCLIPPED_IBM:
1276          CHECK_EXTENSION(IBM_rasterpos_clip);
1277          return ctx->Transform.RasterPositionUnclipped;
1278
1279       /* GL_NV_point_sprite */
1280       case GL_POINT_SPRITE_NV:
1281          CHECK_EXTENSION2(NV_point_sprite, ARB_point_sprite)
1282          return ctx->Point.PointSprite;
1283
1284 #if FEATURE_NV_vertex_program || FEATURE_ARB_vertex_program
1285       case GL_VERTEX_PROGRAM_ARB:
1286          CHECK_EXTENSION2(ARB_vertex_program, NV_vertex_program);
1287          return ctx->VertexProgram.Enabled;
1288       case GL_VERTEX_PROGRAM_POINT_SIZE_ARB:
1289          CHECK_EXTENSION2(ARB_vertex_program, NV_vertex_program);
1290          return ctx->VertexProgram.PointSizeEnabled;
1291       case GL_VERTEX_PROGRAM_TWO_SIDE_ARB:
1292          CHECK_EXTENSION2(ARB_vertex_program, NV_vertex_program);
1293          return ctx->VertexProgram.TwoSideEnabled;
1294 #endif
1295 #if FEATURE_NV_vertex_program
1296       case GL_VERTEX_ATTRIB_ARRAY0_NV:
1297       case GL_VERTEX_ATTRIB_ARRAY1_NV:
1298       case GL_VERTEX_ATTRIB_ARRAY2_NV:
1299       case GL_VERTEX_ATTRIB_ARRAY3_NV:
1300       case GL_VERTEX_ATTRIB_ARRAY4_NV:
1301       case GL_VERTEX_ATTRIB_ARRAY5_NV:
1302       case GL_VERTEX_ATTRIB_ARRAY6_NV:
1303       case GL_VERTEX_ATTRIB_ARRAY7_NV:
1304       case GL_VERTEX_ATTRIB_ARRAY8_NV:
1305       case GL_VERTEX_ATTRIB_ARRAY9_NV:
1306       case GL_VERTEX_ATTRIB_ARRAY10_NV:
1307       case GL_VERTEX_ATTRIB_ARRAY11_NV:
1308       case GL_VERTEX_ATTRIB_ARRAY12_NV:
1309       case GL_VERTEX_ATTRIB_ARRAY13_NV:
1310       case GL_VERTEX_ATTRIB_ARRAY14_NV:
1311       case GL_VERTEX_ATTRIB_ARRAY15_NV:
1312          CHECK_EXTENSION(NV_vertex_program);
1313          {
1314             GLint n = (GLint) cap - GL_VERTEX_ATTRIB_ARRAY0_NV;
1315             ASSERT(VERT_ATTRIB_GENERIC(n) < Elements(ctx->Array.ArrayObj->VertexAttrib));
1316             return (ctx->Array.ArrayObj->VertexAttrib[VERT_ATTRIB_GENERIC(n)].Enabled != 0);
1317          }
1318       case GL_MAP1_VERTEX_ATTRIB0_4_NV:
1319       case GL_MAP1_VERTEX_ATTRIB1_4_NV:
1320       case GL_MAP1_VERTEX_ATTRIB2_4_NV:
1321       case GL_MAP1_VERTEX_ATTRIB3_4_NV:
1322       case GL_MAP1_VERTEX_ATTRIB4_4_NV:
1323       case GL_MAP1_VERTEX_ATTRIB5_4_NV:
1324       case GL_MAP1_VERTEX_ATTRIB6_4_NV:
1325       case GL_MAP1_VERTEX_ATTRIB7_4_NV:
1326       case GL_MAP1_VERTEX_ATTRIB8_4_NV:
1327       case GL_MAP1_VERTEX_ATTRIB9_4_NV:
1328       case GL_MAP1_VERTEX_ATTRIB10_4_NV:
1329       case GL_MAP1_VERTEX_ATTRIB11_4_NV:
1330       case GL_MAP1_VERTEX_ATTRIB12_4_NV:
1331       case GL_MAP1_VERTEX_ATTRIB13_4_NV:
1332       case GL_MAP1_VERTEX_ATTRIB14_4_NV:
1333       case GL_MAP1_VERTEX_ATTRIB15_4_NV:
1334          CHECK_EXTENSION(NV_vertex_program);
1335          {
1336             const GLuint map = (GLuint) (cap - GL_MAP1_VERTEX_ATTRIB0_4_NV);
1337             return ctx->Eval.Map1Attrib[map];
1338          }
1339       case GL_MAP2_VERTEX_ATTRIB0_4_NV:
1340       case GL_MAP2_VERTEX_ATTRIB1_4_NV:
1341       case GL_MAP2_VERTEX_ATTRIB2_4_NV:
1342       case GL_MAP2_VERTEX_ATTRIB3_4_NV:
1343       case GL_MAP2_VERTEX_ATTRIB4_4_NV:
1344       case GL_MAP2_VERTEX_ATTRIB5_4_NV:
1345       case GL_MAP2_VERTEX_ATTRIB6_4_NV:
1346       case GL_MAP2_VERTEX_ATTRIB7_4_NV:
1347       case GL_MAP2_VERTEX_ATTRIB8_4_NV:
1348       case GL_MAP2_VERTEX_ATTRIB9_4_NV:
1349       case GL_MAP2_VERTEX_ATTRIB10_4_NV:
1350       case GL_MAP2_VERTEX_ATTRIB11_4_NV:
1351       case GL_MAP2_VERTEX_ATTRIB12_4_NV:
1352       case GL_MAP2_VERTEX_ATTRIB13_4_NV:
1353       case GL_MAP2_VERTEX_ATTRIB14_4_NV:
1354       case GL_MAP2_VERTEX_ATTRIB15_4_NV:
1355          CHECK_EXTENSION(NV_vertex_program);
1356          {
1357             const GLuint map = (GLuint) (cap - GL_MAP2_VERTEX_ATTRIB0_4_NV);
1358             return ctx->Eval.Map2Attrib[map];
1359          }
1360 #endif /* FEATURE_NV_vertex_program */
1361
1362 #if FEATURE_NV_fragment_program
1363       case GL_FRAGMENT_PROGRAM_NV:
1364          CHECK_EXTENSION(NV_fragment_program);
1365          return ctx->FragmentProgram.Enabled;
1366 #endif /* FEATURE_NV_fragment_program */
1367
1368       /* GL_NV_texture_rectangle */
1369       case GL_TEXTURE_RECTANGLE_NV:
1370          CHECK_EXTENSION(NV_texture_rectangle);
1371          return is_texture_enabled(ctx, TEXTURE_RECT_BIT);
1372
1373       /* GL_EXT_stencil_two_side */
1374       case GL_STENCIL_TEST_TWO_SIDE_EXT:
1375          CHECK_EXTENSION(EXT_stencil_two_side);
1376          return ctx->Stencil.TestTwoSide;
1377
1378 #if FEATURE_ARB_fragment_program
1379       case GL_FRAGMENT_PROGRAM_ARB:
1380          return ctx->FragmentProgram.Enabled;
1381 #endif /* FEATURE_ARB_fragment_program */
1382
1383       /* GL_EXT_depth_bounds_test */
1384       case GL_DEPTH_BOUNDS_TEST_EXT:
1385          CHECK_EXTENSION(EXT_depth_bounds_test);
1386          return ctx->Depth.BoundsTest;
1387
1388       /* GL_ARB_depth_clamp */
1389       case GL_DEPTH_CLAMP:
1390          CHECK_EXTENSION(ARB_depth_clamp);
1391          return ctx->Transform.DepthClamp;
1392
1393 #if FEATURE_ATI_fragment_shader
1394       case GL_FRAGMENT_SHADER_ATI:
1395          CHECK_EXTENSION(ATI_fragment_shader);
1396          return ctx->ATIFragmentShader.Enabled;
1397 #endif /* FEATURE_ATI_fragment_shader */
1398
1399       case GL_TEXTURE_CUBE_MAP_SEAMLESS:
1400          CHECK_EXTENSION(ARB_seamless_cube_map);
1401          return ctx->Texture.CubeMapSeamless;
1402
1403 #if FEATURE_EXT_transform_feedback
1404       case GL_RASTERIZER_DISCARD:
1405          CHECK_EXTENSION(EXT_transform_feedback);
1406          return ctx->RasterDiscard;
1407 #endif
1408
1409       /* GL_NV_primitive_restart */
1410       case GL_PRIMITIVE_RESTART_NV:
1411          if (!ctx->Extensions.NV_primitive_restart) {
1412             goto invalid_enum_error;
1413          }
1414          return ctx->Array.PrimitiveRestart;
1415
1416       /* GL 3.1 primitive restart */
1417       case GL_PRIMITIVE_RESTART:
1418          if (ctx->VersionMajor * 10 + ctx->VersionMinor < 31) {
1419             goto invalid_enum_error;
1420          }
1421          return ctx->Array.PrimitiveRestart;
1422
1423       /* GL3.0 - GL_framebuffer_sRGB */
1424       case GL_FRAMEBUFFER_SRGB_EXT:
1425          CHECK_EXTENSION(EXT_framebuffer_sRGB);
1426          return ctx->Color.sRGBEnabled;
1427
1428       /* GL_OES_EGL_image_external */
1429       case GL_TEXTURE_EXTERNAL_OES:
1430          CHECK_EXTENSION(OES_EGL_image_external);
1431          return is_texture_enabled(ctx, TEXTURE_EXTERNAL_BIT);
1432
1433       default:
1434          goto invalid_enum_error;
1435    }
1436
1437    return GL_FALSE;
1438
1439 invalid_enum_error:
1440    _mesa_error(ctx, GL_INVALID_ENUM, "glIsEnabled(0x%x)", (int) cap);
1441    return GL_FALSE;
1442 }