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