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