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