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