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