src/mesa/main/enable.c

   1 /* $Id: enable.c,v 1.70 2002/10/16 17:57:51 brianp Exp $ */
   2
   3 /*
   4  * Mesa 3-D graphics library
   5  * Version:  4.1
   6  *
   7  * Copyright (C) 1999-2002  Brian Paul   All Rights Reserved.
   8  *
   9  * Permission is hereby granted, free of charge, to any person obtaining a
  10  * copy of this software and associated documentation files (the "Software"),
  11  * to deal in the Software without restriction, including without limitation
  12  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  13  * and/or sell copies of the Software, and to permit persons to whom the
  14  * Software is furnished to do so, subject to the following conditions:
  15  *
  16  * The above copyright notice and this permission notice shall be included
  17  * in all copies or substantial portions of the Software.
  18  *
  19  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  20  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  21  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  22  * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
  23  * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
  24  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  25  */
  26
  27
  28 #ifdef PC_HEADER
  29 #include "all.h"
  30 #else
  31 #include "glheader.h"
  32 #include "context.h"
  33 #include "enable.h"
  34 #include "light.h"
  35 #include "macros.h"
  36 #include "mmath.h"
  37 #include "simple_list.h"
  38 #include "mtypes.h"
  39 #include "enums.h"
  40 #include "math/m_matrix.h"
  41 #include "math/m_xform.h"
  42 #endif
  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 static void
  55 client_state( GLcontext *ctx, GLenum cap, GLboolean state )
  56 {
  57    GLuint flag;
  58    GLuint *var;
  59
  60    switch (cap) {
  61       case GL_VERTEX_ARRAY:
  62          var = &ctx->Array.Vertex.Enabled;
  63          flag = _NEW_ARRAY_VERTEX;
  64          break;
  65       case GL_NORMAL_ARRAY:
  66          var = &ctx->Array.Normal.Enabled;
  67          flag = _NEW_ARRAY_NORMAL;
  68          break;
  69       case GL_COLOR_ARRAY:
  70          var = &ctx->Array.Color.Enabled;
  71          flag = _NEW_ARRAY_COLOR0;
  72          break;
  73       case GL_INDEX_ARRAY:
  74          var = &ctx->Array.Index.Enabled;
  75          flag = _NEW_ARRAY_INDEX;
  76          break;
  77       case GL_TEXTURE_COORD_ARRAY:
  78          var = &ctx->Array.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.EdgeFlag.Enabled;
  83          flag = _NEW_ARRAY_EDGEFLAG;
  84          break;
  85       case GL_FOG_COORDINATE_ARRAY_EXT:
  86          var = &ctx->Array.FogCoord.Enabled;
  87          flag = _NEW_ARRAY_FOGCOORD;
  88          break;
  89       case GL_SECONDARY_COLOR_ARRAY_EXT:
  90          var = &ctx->Array.SecondaryColor.Enabled;
  91          flag = _NEW_ARRAY_COLOR1;
  92          break;
  93
  94 #if FEATURE_NV_vertex_program
  95       case GL_VERTEX_ATTRIB_ARRAY0_NV:
  96       case GL_VERTEX_ATTRIB_ARRAY1_NV:
  97       case GL_VERTEX_ATTRIB_ARRAY2_NV:
  98       case GL_VERTEX_ATTRIB_ARRAY3_NV:
  99       case GL_VERTEX_ATTRIB_ARRAY4_NV:
 100       case GL_VERTEX_ATTRIB_ARRAY5_NV:
 101       case GL_VERTEX_ATTRIB_ARRAY6_NV:
 102       case GL_VERTEX_ATTRIB_ARRAY7_NV:
 103       case GL_VERTEX_ATTRIB_ARRAY8_NV:
 104       case GL_VERTEX_ATTRIB_ARRAY9_NV:
 105       case GL_VERTEX_ATTRIB_ARRAY10_NV:
 106       case GL_VERTEX_ATTRIB_ARRAY11_NV:
 107       case GL_VERTEX_ATTRIB_ARRAY12_NV:
 108       case GL_VERTEX_ATTRIB_ARRAY13_NV:
 109       case GL_VERTEX_ATTRIB_ARRAY14_NV:
 110       case GL_VERTEX_ATTRIB_ARRAY15_NV:
 111          CHECK_EXTENSION(NV_vertex_program, cap);
 112          {
 113             GLint n = (GLint) cap - GL_VERTEX_ATTRIB_ARRAY0_NV;
 114             var = &ctx->Array.VertexAttrib[n].Enabled;
 115             flag = _NEW_ARRAY_ATTRIB(n);
 116          }
 117          break;
 118 #endif /* FEATURE_NV_vertex_program */
 119
 120       default:
 121          _mesa_error( ctx, GL_INVALID_ENUM,
 122                       "glEnable/DisableClientState(0x%x)", cap);
 123          return;
 124    }
 125
 126    if (*var == state)
 127       return;
 128
 129    FLUSH_VERTICES(ctx, _NEW_ARRAY);
 130    ctx->Array.NewState |= flag;
 131    *var = state;
 132
 133    if (state)
 134       ctx->Array._Enabled |= flag;
 135    else
 136       ctx->Array._Enabled &= ~flag;
 137
 138    if (ctx->Driver.Enable) {
 139       (*ctx->Driver.Enable)( ctx, cap, state );
 140    }
 141 }
 142
 143
 144
 145 void
 146 _mesa_EnableClientState( GLenum cap )
 147 {
 148    GET_CURRENT_CONTEXT(ctx);
 149    ASSERT_OUTSIDE_BEGIN_END(ctx);
 150    client_state( ctx, cap, GL_TRUE );
 151 }
 152
 153
 154
 155 void
 156 _mesa_DisableClientState( GLenum cap )
 157 {
 158    GET_CURRENT_CONTEXT(ctx);
 159    ASSERT_OUTSIDE_BEGIN_END(ctx);
 160    client_state( ctx, cap, GL_FALSE );
 161 }
 162
 163
 164 #undef CHECK_EXTENSION
 165 #define CHECK_EXTENSION(EXTNAME, CAP)                                   \
 166    if (!ctx->Extensions.EXTNAME) {                                      \
 167       _mesa_error(ctx, GL_INVALID_ENUM, "gl%s(0x%x)",                   \
 168                   state ? "Enable" : "Disable", CAP);                   \
 169       return;                                                           \
 170    }
 171
 172
 173 /*
 174  * Perform glEnable and glDisable calls.
 175  */
 176 void _mesa_set_enable( GLcontext *ctx, GLenum cap, GLboolean state )
 177 {
 178    if (MESA_VERBOSE & VERBOSE_API)
 179       _mesa_debug(ctx, "%s %s (newstate is %x)\n",
 180                   state ? "glEnable" : "glDisable",
 181                   _mesa_lookup_enum_by_nr(cap),
 182                   ctx->NewState);
 183
 184    switch (cap) {
 185       case GL_ALPHA_TEST:
 186          if (ctx->Color.AlphaEnabled == state)
 187             return;
 188          FLUSH_VERTICES(ctx, _NEW_COLOR);
 189          ctx->Color.AlphaEnabled = state;
 190          break;
 191       case GL_AUTO_NORMAL:
 192          if (ctx->Eval.AutoNormal == state)
 193             return;
 194          FLUSH_VERTICES(ctx, _NEW_EVAL);
 195          ctx->Eval.AutoNormal = state;
 196          break;
 197       case GL_BLEND:
 198          if (ctx->Color.BlendEnabled == state)
 199             return;
 200          FLUSH_VERTICES(ctx, _NEW_COLOR);
 201          ctx->Color.BlendEnabled = state;
 202          /* The following needed to accomodate 1.0 RGB logic op blending */
 203          ctx->Color.ColorLogicOpEnabled =
 204             (ctx->Color.BlendEquation == GL_LOGIC_OP && state);
 205          break;
 206       case GL_CLIP_PLANE0:
 207       case GL_CLIP_PLANE1:
 208       case GL_CLIP_PLANE2:
 209       case GL_CLIP_PLANE3:
 210       case GL_CLIP_PLANE4:
 211       case GL_CLIP_PLANE5:
 212          {
 213             const GLuint p = cap - GL_CLIP_PLANE0;
 214
 215             if ((ctx->Transform.ClipPlanesEnabled & (1 << p)) == ((GLuint) state << p))
 216                return;
 217
 218             FLUSH_VERTICES(ctx, _NEW_TRANSFORM);
 219
 220             if (state) {
 221                ctx->Transform.ClipPlanesEnabled |= (1 << p);
 222
 223                if (ctx->ProjectionMatrixStack.Top->flags & MAT_DIRTY)
 224                   _math_matrix_analyse( ctx->ProjectionMatrixStack.Top );
 225
 226                /* This derived state also calculated in clip.c and
 227                 * from _mesa_update_state() on changes to EyeUserPlane
 228                 * and ctx->ProjectionMatrix respectively.
 229                 */
 230                _mesa_transform_vector( ctx->Transform._ClipUserPlane[p],
 231                                     ctx->Transform.EyeUserPlane[p],
 232                                     ctx->ProjectionMatrixStack.Top->inv );
 233             }
 234             else {
 235                ctx->Transform.ClipPlanesEnabled &= ~(1 << p);
 236             }
 237          }
 238          break;
 239       case GL_COLOR_MATERIAL:
 240          if (ctx->Light.ColorMaterialEnabled == state)
 241             return;
 242          FLUSH_VERTICES(ctx, _NEW_LIGHT);
 243          ctx->Light.ColorMaterialEnabled = state;
 244          if (state) {
 245             FLUSH_CURRENT(ctx, 0);
 246             _mesa_update_color_material( ctx,
 247                                   ctx->Current.Attrib[VERT_ATTRIB_COLOR0] );
 248          }
 249          break;
 250       case GL_CULL_FACE:
 251          if (ctx->Polygon.CullFlag == state)
 252             return;
 253          FLUSH_VERTICES(ctx, _NEW_POLYGON);
 254          ctx->Polygon.CullFlag = state;
 255          break;
 256       case GL_DEPTH_TEST:
 257          if (state && ctx->Visual.depthBits==0) {
 258             _mesa_warning(ctx,"glEnable(GL_DEPTH_TEST) but no depth buffer");
 259             return;
 260          }
 261          if (ctx->Depth.Test==state)
 262             return;
 263          FLUSH_VERTICES(ctx, _NEW_DEPTH);
 264          ctx->Depth.Test = state;
 265          break;
 266       case GL_DITHER:
 267          if (ctx->NoDither) {
 268             state = GL_FALSE; /* MESA_NO_DITHER env var */
 269          }
 270          if (ctx->Color.DitherFlag==state)
 271             return;
 272          FLUSH_VERTICES(ctx, _NEW_COLOR);
 273          ctx->Color.DitherFlag = state;
 274          break;
 275       case GL_FOG:
 276          if (ctx->Fog.Enabled==state)
 277             return;
 278          FLUSH_VERTICES(ctx, _NEW_FOG);
 279          ctx->Fog.Enabled = state;
 280          break;
 281       case GL_HISTOGRAM:
 282          CHECK_EXTENSION(EXT_histogram, cap);
 283          if (ctx->Pixel.HistogramEnabled == state)
 284             return;
 285          FLUSH_VERTICES(ctx, _NEW_PIXEL);
 286          ctx->Pixel.HistogramEnabled = state;
 287          break;
 288       case GL_LIGHT0:
 289       case GL_LIGHT1:
 290       case GL_LIGHT2:
 291       case GL_LIGHT3:
 292       case GL_LIGHT4:
 293       case GL_LIGHT5:
 294       case GL_LIGHT6:
 295       case GL_LIGHT7:
 296          if (ctx->Light.Light[cap-GL_LIGHT0].Enabled == state)
 297             return;
 298          FLUSH_VERTICES(ctx, _NEW_LIGHT);
 299          ctx->Light.Light[cap-GL_LIGHT0].Enabled = state;
 300          if (state) {
 301             insert_at_tail(&ctx->Light.EnabledList,
 302                            &ctx->Light.Light[cap-GL_LIGHT0]);
 303          }
 304          else {
 305             remove_from_list(&ctx->Light.Light[cap-GL_LIGHT0]);
 306          }
 307          break;
 308       case GL_LIGHTING:
 309          if (ctx->Light.Enabled == state)
 310             return;
 311          FLUSH_VERTICES(ctx, _NEW_LIGHT);
 312          ctx->Light.Enabled = state;
 313
 314          if (ctx->Light.Enabled && ctx->Light.Model.TwoSide)
 315            ctx->_TriangleCaps |= DD_TRI_LIGHT_TWOSIDE;
 316          else
 317            ctx->_TriangleCaps &= ~DD_TRI_LIGHT_TWOSIDE;
 318
 319          if ((ctx->Light.Enabled &&
 320               ctx->Light.Model.ColorControl==GL_SEPARATE_SPECULAR_COLOR)
 321              || ctx->Fog.ColorSumEnabled)
 322             ctx->_TriangleCaps |= DD_SEPARATE_SPECULAR;
 323          else
 324             ctx->_TriangleCaps &= ~DD_SEPARATE_SPECULAR;
 325
 326          break;
 327       case GL_LINE_SMOOTH:
 328          if (ctx->Line.SmoothFlag == state)
 329             return;
 330          FLUSH_VERTICES(ctx, _NEW_LINE);
 331          ctx->Line.SmoothFlag = state;
 332          ctx->_TriangleCaps ^= DD_LINE_SMOOTH;
 333          break;
 334       case GL_LINE_STIPPLE:
 335          if (ctx->Line.StippleFlag == state)
 336             return;
 337          FLUSH_VERTICES(ctx, _NEW_LINE);
 338          ctx->Line.StippleFlag = state;
 339          ctx->_TriangleCaps ^= DD_LINE_STIPPLE;
 340          break;
 341       case GL_INDEX_LOGIC_OP:
 342          if (ctx->Color.IndexLogicOpEnabled == state)
 343             return;
 344          FLUSH_VERTICES(ctx, _NEW_COLOR);
 345          ctx->Color.IndexLogicOpEnabled = state;
 346          break;
 347       case GL_COLOR_LOGIC_OP:
 348          if (ctx->Color.ColorLogicOpEnabled == state)
 349             return;
 350          FLUSH_VERTICES(ctx, _NEW_COLOR);
 351          ctx->Color.ColorLogicOpEnabled = state;
 352          break;
 353       case GL_MAP1_COLOR_4:
 354          if (ctx->Eval.Map1Color4 == state)
 355             return;
 356          FLUSH_VERTICES(ctx, _NEW_EVAL);
 357          ctx->Eval.Map1Color4 = state;
 358          break;
 359       case GL_MAP1_INDEX:
 360          if (ctx->Eval.Map1Index == state)
 361             return;
 362          FLUSH_VERTICES(ctx, _NEW_EVAL);
 363          ctx->Eval.Map1Index = state;
 364          break;
 365       case GL_MAP1_NORMAL:
 366          if (ctx->Eval.Map1Normal == state)
 367             return;
 368          FLUSH_VERTICES(ctx, _NEW_EVAL);
 369          ctx->Eval.Map1Normal = state;
 370          break;
 371       case GL_MAP1_TEXTURE_COORD_1:
 372          if (ctx->Eval.Map1TextureCoord1 == state)
 373             return;
 374          FLUSH_VERTICES(ctx, _NEW_EVAL);
 375          ctx->Eval.Map1TextureCoord1 = state;
 376          break;
 377       case GL_MAP1_TEXTURE_COORD_2:
 378          if (ctx->Eval.Map1TextureCoord2 == state)
 379             return;
 380          FLUSH_VERTICES(ctx, _NEW_EVAL);
 381          ctx->Eval.Map1TextureCoord2 = state;
 382          break;
 383       case GL_MAP1_TEXTURE_COORD_3:
 384          if (ctx->Eval.Map1TextureCoord3 == state)
 385             return;
 386          FLUSH_VERTICES(ctx, _NEW_EVAL);
 387          ctx->Eval.Map1TextureCoord3 = state;
 388          break;
 389       case GL_MAP1_TEXTURE_COORD_4:
 390          if (ctx->Eval.Map1TextureCoord4 == state)
 391             return;
 392          FLUSH_VERTICES(ctx, _NEW_EVAL);
 393          ctx->Eval.Map1TextureCoord4 = state;
 394          break;
 395       case GL_MAP1_VERTEX_3:
 396          if (ctx->Eval.Map1Vertex3 == state)
 397             return;
 398          FLUSH_VERTICES(ctx, _NEW_EVAL);
 399          ctx->Eval.Map1Vertex3 = state;
 400          break;
 401       case GL_MAP1_VERTEX_4:
 402          if (ctx->Eval.Map1Vertex4 == state)
 403             return;
 404          FLUSH_VERTICES(ctx, _NEW_EVAL);
 405          ctx->Eval.Map1Vertex4 = state;
 406          break;
 407       case GL_MAP2_COLOR_4:
 408          if (ctx->Eval.Map2Color4 == state)
 409             return;
 410          FLUSH_VERTICES(ctx, _NEW_EVAL);
 411          ctx->Eval.Map2Color4 = state;
 412          break;
 413       case GL_MAP2_INDEX:
 414          if (ctx->Eval.Map2Index == state)
 415             return;
 416          FLUSH_VERTICES(ctx, _NEW_EVAL);
 417          ctx->Eval.Map2Index = state;
 418          break;
 419       case GL_MAP2_NORMAL:
 420          if (ctx->Eval.Map2Normal == state)
 421             return;
 422          FLUSH_VERTICES(ctx, _NEW_EVAL);
 423          ctx->Eval.Map2Normal = state;
 424          break;
 425       case GL_MAP2_TEXTURE_COORD_1:
 426          if (ctx->Eval.Map2TextureCoord1 == state)
 427             return;
 428          FLUSH_VERTICES(ctx, _NEW_EVAL);
 429          ctx->Eval.Map2TextureCoord1 = state;
 430          break;
 431       case GL_MAP2_TEXTURE_COORD_2:
 432          if (ctx->Eval.Map2TextureCoord2 == state)
 433             return;
 434          FLUSH_VERTICES(ctx, _NEW_EVAL);
 435          ctx->Eval.Map2TextureCoord2 = state;
 436          break;
 437       case GL_MAP2_TEXTURE_COORD_3:
 438          if (ctx->Eval.Map2TextureCoord3 == state)
 439             return;
 440          FLUSH_VERTICES(ctx, _NEW_EVAL);
 441          ctx->Eval.Map2TextureCoord3 = state;
 442          break;
 443       case GL_MAP2_TEXTURE_COORD_4:
 444          if (ctx->Eval.Map2TextureCoord4 == state)
 445             return;
 446          FLUSH_VERTICES(ctx, _NEW_EVAL);
 447          ctx->Eval.Map2TextureCoord4 = state;
 448          break;
 449       case GL_MAP2_VERTEX_3:
 450          if (ctx->Eval.Map2Vertex3 == state)
 451             return;
 452          FLUSH_VERTICES(ctx, _NEW_EVAL);
 453          ctx->Eval.Map2Vertex3 = state;
 454          break;
 455       case GL_MAP2_VERTEX_4:
 456          if (ctx->Eval.Map2Vertex4 == state)
 457             return;
 458          FLUSH_VERTICES(ctx, _NEW_EVAL);
 459          ctx->Eval.Map2Vertex4 = state;
 460          break;
 461       case GL_MINMAX:
 462          if (ctx->Pixel.MinMaxEnabled == state)
 463             return;
 464          FLUSH_VERTICES(ctx, _NEW_PIXEL);
 465          ctx->Pixel.MinMaxEnabled = state;
 466          break;
 467       case GL_NORMALIZE:
 468          if (ctx->Transform.Normalize == state)
 469             return;
 470          FLUSH_VERTICES(ctx, _NEW_TRANSFORM);
 471          ctx->Transform.Normalize = state;
 472          break;
 473       case GL_POINT_SMOOTH:
 474          if (ctx->Point.SmoothFlag==state)
 475             return;
 476          FLUSH_VERTICES(ctx, _NEW_POINT);
 477          ctx->Point.SmoothFlag = state;
 478          ctx->_TriangleCaps ^= DD_POINT_SMOOTH;
 479          break;
 480       case GL_POLYGON_SMOOTH:
 481          if (ctx->Polygon.SmoothFlag==state)
 482             return;
 483          FLUSH_VERTICES(ctx, _NEW_POLYGON);
 484          ctx->Polygon.SmoothFlag = state;
 485          ctx->_TriangleCaps ^= DD_TRI_SMOOTH;
 486          break;
 487       case GL_POLYGON_STIPPLE:
 488          if (ctx->Polygon.StippleFlag==state)
 489             return;
 490          FLUSH_VERTICES(ctx, _NEW_POLYGON);
 491          ctx->Polygon.StippleFlag = state;
 492          ctx->_TriangleCaps ^= DD_TRI_STIPPLE;
 493          break;
 494       case GL_POLYGON_OFFSET_POINT:
 495          if (ctx->Polygon.OffsetPoint==state)
 496             return;
 497          FLUSH_VERTICES(ctx, _NEW_POLYGON);
 498          ctx->Polygon.OffsetPoint = state;
 499          break;
 500       case GL_POLYGON_OFFSET_LINE:
 501          if (ctx->Polygon.OffsetLine==state)
 502             return;
 503          FLUSH_VERTICES(ctx, _NEW_POLYGON);
 504          ctx->Polygon.OffsetLine = state;
 505          break;
 506       case GL_POLYGON_OFFSET_FILL:
 507          /*case GL_POLYGON_OFFSET_EXT:*/
 508          if (ctx->Polygon.OffsetFill==state)
 509             return;
 510          FLUSH_VERTICES(ctx, _NEW_POLYGON);
 511          ctx->Polygon.OffsetFill = state;
 512          break;
 513       case GL_RESCALE_NORMAL_EXT:
 514          if (ctx->Transform.RescaleNormals == state)
 515             return;
 516          FLUSH_VERTICES(ctx, _NEW_TRANSFORM);
 517          ctx->Transform.RescaleNormals = state;
 518          break;
 519       case GL_SCISSOR_TEST:
 520          if (ctx->Scissor.Enabled==state)
 521             return;
 522          FLUSH_VERTICES(ctx, _NEW_SCISSOR);
 523          ctx->Scissor.Enabled = state;
 524          break;
 525       case GL_SHARED_TEXTURE_PALETTE_EXT:
 526          if (ctx->Texture.SharedPalette == state)
 527             return;
 528          FLUSH_VERTICES(ctx, _NEW_TEXTURE);
 529          ctx->Texture.SharedPalette = state;
 530          break;
 531       case GL_STENCIL_TEST:
 532          if (state && ctx->Visual.stencilBits==0) {
 533             _mesa_warning(ctx,
 534                           "glEnable(GL_STENCIL_TEST) but no stencil buffer");
 535             return;
 536          }
 537          if (ctx->Stencil.Enabled==state)
 538             return;
 539          FLUSH_VERTICES(ctx, _NEW_STENCIL);
 540          ctx->Stencil.Enabled = state;
 541          break;
 542       case GL_TEXTURE_1D: {
 543          const GLuint curr = ctx->Texture.CurrentUnit;
 544          struct gl_texture_unit *texUnit = &ctx->Texture.Unit[curr];
 545          GLuint newenabled = texUnit->Enabled & ~TEXTURE_1D_BIT;
 546          if (state)
 547             newenabled |= TEXTURE_1D_BIT;
 548          if (!ctx->Visual.rgbMode || texUnit->Enabled == newenabled)
 549             return;
 550          FLUSH_VERTICES(ctx, _NEW_TEXTURE);
 551          texUnit->Enabled = newenabled;
 552          break;
 553       }
 554       case GL_TEXTURE_2D: {
 555          const GLuint curr = ctx->Texture.CurrentUnit;
 556          struct gl_texture_unit *texUnit = &ctx->Texture.Unit[curr];
 557          GLuint newenabled = texUnit->Enabled & ~TEXTURE_2D_BIT;
 558          if (state)
 559             newenabled |= TEXTURE_2D_BIT;
 560          if (!ctx->Visual.rgbMode || texUnit->Enabled == newenabled)
 561             return;
 562          FLUSH_VERTICES(ctx, _NEW_TEXTURE);
 563          texUnit->Enabled = newenabled;
 564          break;
 565       }
 566       case GL_TEXTURE_3D: {
 567          const GLuint curr = ctx->Texture.CurrentUnit;
 568          struct gl_texture_unit *texUnit = &ctx->Texture.Unit[curr];
 569          GLuint newenabled = texUnit->Enabled & ~TEXTURE_3D_BIT;
 570          if (state)
 571             newenabled |= TEXTURE_3D_BIT;
 572          if (!ctx->Visual.rgbMode || texUnit->Enabled == newenabled)
 573             return;
 574          FLUSH_VERTICES(ctx, _NEW_TEXTURE);
 575          texUnit->Enabled = newenabled;
 576          break;
 577       }
 578       case GL_TEXTURE_GEN_Q: {
 579          GLuint unit = ctx->Texture.CurrentUnit;
 580          struct gl_texture_unit *texUnit = &ctx->Texture.Unit[unit];
 581          GLuint newenabled = texUnit->TexGenEnabled & ~Q_BIT;
 582          if (state)
 583             newenabled |= Q_BIT;
 584          if (texUnit->TexGenEnabled == newenabled)
 585             return;
 586          FLUSH_VERTICES(ctx, _NEW_TEXTURE);
 587          texUnit->TexGenEnabled = newenabled;
 588          break;
 589       }
 590       case GL_TEXTURE_GEN_R: {
 591          GLuint unit = ctx->Texture.CurrentUnit;
 592          struct gl_texture_unit *texUnit = &ctx->Texture.Unit[unit];
 593          GLuint newenabled = texUnit->TexGenEnabled & ~R_BIT;
 594          if (state)
 595             newenabled |= R_BIT;
 596          if (texUnit->TexGenEnabled == newenabled)
 597             return;
 598          FLUSH_VERTICES(ctx, _NEW_TEXTURE);
 599          texUnit->TexGenEnabled = newenabled;
 600          break;
 601       }
 602       break;
 603       case GL_TEXTURE_GEN_S: {
 604          GLuint unit = ctx->Texture.CurrentUnit;
 605          struct gl_texture_unit *texUnit = &ctx->Texture.Unit[unit];
 606          GLuint newenabled = texUnit->TexGenEnabled & ~S_BIT;
 607          if (state)
 608             newenabled |= S_BIT;
 609          if (texUnit->TexGenEnabled == newenabled)
 610             return;
 611          FLUSH_VERTICES(ctx, _NEW_TEXTURE);
 612          texUnit->TexGenEnabled = newenabled;
 613          break;
 614       }
 615       break;
 616       case GL_TEXTURE_GEN_T: {
 617          GLuint unit = ctx->Texture.CurrentUnit;
 618          struct gl_texture_unit *texUnit = &ctx->Texture.Unit[unit];
 619          GLuint newenabled = texUnit->TexGenEnabled & ~T_BIT;
 620          if (state)
 621             newenabled |= T_BIT;
 622          if (texUnit->TexGenEnabled == newenabled)
 623             return;
 624          FLUSH_VERTICES(ctx, _NEW_TEXTURE);
 625          texUnit->TexGenEnabled = newenabled;
 626          break;
 627       }
 628       break;
 629
 630       /*
 631        * CLIENT STATE!!!
 632        */
 633       case GL_VERTEX_ARRAY:
 634       case GL_NORMAL_ARRAY:
 635       case GL_COLOR_ARRAY:
 636       case GL_INDEX_ARRAY:
 637       case GL_TEXTURE_COORD_ARRAY:
 638       case GL_EDGE_FLAG_ARRAY:
 639       case GL_FOG_COORDINATE_ARRAY_EXT:
 640       case GL_SECONDARY_COLOR_ARRAY_EXT:
 641          client_state( ctx, cap, state );
 642          return;
 643
 644       /* GL_HP_occlusion_test */
 645       case GL_OCCLUSION_TEST_HP:
 646          CHECK_EXTENSION(HP_occlusion_test, cap);
 647          if (ctx->Depth.OcclusionTest == state)
 648             return;
 649          FLUSH_VERTICES(ctx, _NEW_DEPTH);
 650          ctx->Depth.OcclusionTest = state;
 651          if (state)
 652             ctx->OcclusionResult = ctx->OcclusionResultSaved;
 653          else
 654             ctx->OcclusionResultSaved = ctx->OcclusionResult;
 655          break;
 656
 657       /* GL_SGIS_pixel_texture */
 658       case GL_PIXEL_TEXTURE_SGIS:
 659          CHECK_EXTENSION(SGIS_pixel_texture, cap);
 660          if (ctx->Pixel.PixelTextureEnabled == state)
 661             return;
 662          FLUSH_VERTICES(ctx, _NEW_PIXEL);
 663          ctx->Pixel.PixelTextureEnabled = state;
 664          break;
 665
 666       /* GL_SGIX_pixel_texture */
 667       case GL_PIXEL_TEX_GEN_SGIX:
 668          CHECK_EXTENSION(SGIX_pixel_texture, cap);
 669          if (ctx->Pixel.PixelTextureEnabled == state)
 670             return;
 671          FLUSH_VERTICES(ctx, _NEW_PIXEL);
 672          ctx->Pixel.PixelTextureEnabled = state;
 673          break;
 674
 675       /* GL_SGI_color_table */
 676       case GL_COLOR_TABLE_SGI:
 677          CHECK_EXTENSION(SGI_color_table, cap);
 678          if (ctx->Pixel.ColorTableEnabled == state)
 679             return;
 680          FLUSH_VERTICES(ctx, _NEW_PIXEL);
 681          ctx->Pixel.ColorTableEnabled = state;
 682          break;
 683       case GL_POST_CONVOLUTION_COLOR_TABLE_SGI:
 684          CHECK_EXTENSION(SGI_color_table, cap);
 685          if (ctx->Pixel.PostConvolutionColorTableEnabled == state)
 686             return;
 687          FLUSH_VERTICES(ctx, _NEW_PIXEL);
 688          ctx->Pixel.PostConvolutionColorTableEnabled = state;
 689          break;
 690       case GL_POST_COLOR_MATRIX_COLOR_TABLE_SGI:
 691          CHECK_EXTENSION(SGI_color_table, cap);
 692          if (ctx->Pixel.PostColorMatrixColorTableEnabled == state)
 693             return;
 694          FLUSH_VERTICES(ctx, _NEW_PIXEL);
 695          ctx->Pixel.PostColorMatrixColorTableEnabled = state;
 696          break;
 697
 698       /* GL_EXT_convolution */
 699       case GL_CONVOLUTION_1D:
 700          CHECK_EXTENSION(EXT_convolution, cap);
 701          if (ctx->Pixel.Convolution1DEnabled == state)
 702             return;
 703          FLUSH_VERTICES(ctx, _NEW_PIXEL);
 704          ctx->Pixel.Convolution1DEnabled = state;
 705          break;
 706       case GL_CONVOLUTION_2D:
 707          CHECK_EXTENSION(EXT_convolution, cap);
 708          if (ctx->Pixel.Convolution2DEnabled == state)
 709             return;
 710          FLUSH_VERTICES(ctx, _NEW_PIXEL);
 711          ctx->Pixel.Convolution2DEnabled = state;
 712          break;
 713       case GL_SEPARABLE_2D:
 714          CHECK_EXTENSION(EXT_convolution, cap);
 715          if (ctx->Pixel.Separable2DEnabled == state)
 716             return;
 717          FLUSH_VERTICES(ctx, _NEW_PIXEL);
 718          ctx->Pixel.Separable2DEnabled = state;
 719          break;
 720
 721       /* GL_ARB_texture_cube_map */
 722       case GL_TEXTURE_CUBE_MAP_ARB:
 723          {
 724             const GLuint curr = ctx->Texture.CurrentUnit;
 725             struct gl_texture_unit *texUnit = &ctx->Texture.Unit[curr];
 726             GLuint newenabled = texUnit->Enabled & ~TEXTURE_CUBE_BIT;
 727             CHECK_EXTENSION(ARB_texture_cube_map, cap);
 728             if (state)
 729                newenabled |= TEXTURE_CUBE_BIT;
 730             if (!ctx->Visual.rgbMode || texUnit->Enabled == newenabled)
 731                return;
 732             FLUSH_VERTICES(ctx, _NEW_TEXTURE);
 733             texUnit->Enabled = newenabled;
 734          }
 735          break;
 736
 737       /* GL_EXT_secondary_color */
 738       case GL_COLOR_SUM_EXT:
 739          CHECK_EXTENSION(EXT_secondary_color, cap);
 740          if (ctx->Fog.ColorSumEnabled == state)
 741             return;
 742          FLUSH_VERTICES(ctx, _NEW_FOG);
 743          ctx->Fog.ColorSumEnabled = state;
 744
 745          if ((ctx->Light.Enabled &&
 746               ctx->Light.Model.ColorControl==GL_SEPARATE_SPECULAR_COLOR)
 747              || ctx->Fog.ColorSumEnabled)
 748             ctx->_TriangleCaps |= DD_SEPARATE_SPECULAR;
 749          else
 750             ctx->_TriangleCaps &= ~DD_SEPARATE_SPECULAR;
 751
 752          break;
 753
 754       /* GL_ARB_multisample */
 755       case GL_MULTISAMPLE_ARB:
 756          CHECK_EXTENSION(ARB_multisample, cap);
 757          if (ctx->Multisample.Enabled == state)
 758             return;
 759          FLUSH_VERTICES(ctx, _NEW_MULTISAMPLE);
 760          ctx->Multisample.Enabled = state;
 761          break;
 762       case GL_SAMPLE_ALPHA_TO_COVERAGE_ARB:
 763          CHECK_EXTENSION(ARB_multisample, cap);
 764          if (ctx->Multisample.SampleAlphaToCoverage == state)
 765             return;
 766          FLUSH_VERTICES(ctx, _NEW_MULTISAMPLE);
 767          ctx->Multisample.SampleAlphaToCoverage = state;
 768          break;
 769       case GL_SAMPLE_ALPHA_TO_ONE_ARB:
 770          CHECK_EXTENSION(ARB_multisample, cap);
 771          if (ctx->Multisample.SampleAlphaToOne == state)
 772             return;
 773          FLUSH_VERTICES(ctx, _NEW_MULTISAMPLE);
 774          ctx->Multisample.SampleAlphaToOne = state;
 775          break;
 776       case GL_SAMPLE_COVERAGE_ARB:
 777          CHECK_EXTENSION(ARB_multisample, cap);
 778          if (ctx->Multisample.SampleCoverage == state)
 779             return;
 780          FLUSH_VERTICES(ctx, _NEW_MULTISAMPLE);
 781          ctx->Multisample.SampleCoverage = state;
 782          break;
 783       case GL_SAMPLE_COVERAGE_INVERT_ARB:
 784          CHECK_EXTENSION(ARB_multisample, cap);
 785          if (ctx->Multisample.SampleCoverageInvert == state)
 786             return;
 787          FLUSH_VERTICES(ctx, _NEW_MULTISAMPLE);
 788          ctx->Multisample.SampleCoverageInvert = state;
 789          break;
 790
 791       /* GL_IBM_rasterpos_clip */
 792       case GL_RASTER_POSITION_UNCLIPPED_IBM:
 793          CHECK_EXTENSION(IBM_rasterpos_clip, cap);
 794          if (ctx->Transform.RasterPositionUnclipped == state)
 795             return;
 796          FLUSH_VERTICES(ctx, _NEW_TRANSFORM);
 797          ctx->Transform.RasterPositionUnclipped = state;
 798          break;
 799
 800       /* GL_NV_point_sprite */
 801       case GL_POINT_SPRITE_NV:
 802          CHECK_EXTENSION(NV_point_sprite, cap);
 803          if (ctx->Point.PointSprite == state)
 804             return;
 805          FLUSH_VERTICES(ctx, _NEW_POINT);
 806          ctx->Point.PointSprite = state;
 807          break;
 808
 809 #if FEATURE_NV_vertex_program
 810       case GL_VERTEX_PROGRAM_NV:
 811          CHECK_EXTENSION(NV_vertex_program, cap);
 812          if (ctx->VertexProgram.Enabled == state)
 813             return;
 814          FLUSH_VERTICES(ctx, _NEW_TRANSFORM | _NEW_PROGRAM);  /* XXX OK? */
 815          ctx->VertexProgram.Enabled = state;
 816          break;
 817       case GL_VERTEX_PROGRAM_POINT_SIZE_NV:
 818          CHECK_EXTENSION(NV_vertex_program, cap);
 819          if (ctx->VertexProgram.PointSizeEnabled == state)
 820             return;
 821          FLUSH_VERTICES(ctx, _NEW_POINT | _NEW_PROGRAM);
 822          ctx->VertexProgram.PointSizeEnabled = state;
 823          break;
 824       case GL_VERTEX_PROGRAM_TWO_SIDE_NV:
 825          CHECK_EXTENSION(NV_vertex_program, cap);
 826          if (ctx->VertexProgram.TwoSideEnabled == state)
 827             return;
 828          FLUSH_VERTICES(ctx, _NEW_PROGRAM);  /* XXX OK? */
 829          ctx->VertexProgram.TwoSideEnabled = state;
 830          break;
 831       case GL_MAP1_VERTEX_ATTRIB0_4_NV:
 832       case GL_MAP1_VERTEX_ATTRIB1_4_NV:
 833       case GL_MAP1_VERTEX_ATTRIB2_4_NV:
 834       case GL_MAP1_VERTEX_ATTRIB3_4_NV:
 835       case GL_MAP1_VERTEX_ATTRIB4_4_NV:
 836       case GL_MAP1_VERTEX_ATTRIB5_4_NV:
 837       case GL_MAP1_VERTEX_ATTRIB6_4_NV:
 838       case GL_MAP1_VERTEX_ATTRIB7_4_NV:
 839       case GL_MAP1_VERTEX_ATTRIB8_4_NV:
 840       case GL_MAP1_VERTEX_ATTRIB9_4_NV:
 841       case GL_MAP1_VERTEX_ATTRIB10_4_NV:
 842       case GL_MAP1_VERTEX_ATTRIB11_4_NV:
 843       case GL_MAP1_VERTEX_ATTRIB12_4_NV:
 844       case GL_MAP1_VERTEX_ATTRIB13_4_NV:
 845       case GL_MAP1_VERTEX_ATTRIB14_4_NV:
 846       case GL_MAP1_VERTEX_ATTRIB15_4_NV:
 847          CHECK_EXTENSION(NV_vertex_program, cap);
 848          {
 849             const GLuint map = (GLuint) (cap - GL_MAP1_VERTEX_ATTRIB0_4_NV);
 850             FLUSH_VERTICES(ctx, _NEW_EVAL);
 851             ctx->Eval.Map1Attrib[map] = state;
 852          }
 853          break;
 854       case GL_MAP2_VERTEX_ATTRIB0_4_NV:
 855       case GL_MAP2_VERTEX_ATTRIB1_4_NV:
 856       case GL_MAP2_VERTEX_ATTRIB2_4_NV:
 857       case GL_MAP2_VERTEX_ATTRIB3_4_NV:
 858       case GL_MAP2_VERTEX_ATTRIB4_4_NV:
 859       case GL_MAP2_VERTEX_ATTRIB5_4_NV:
 860       case GL_MAP2_VERTEX_ATTRIB6_4_NV:
 861       case GL_MAP2_VERTEX_ATTRIB7_4_NV:
 862       case GL_MAP2_VERTEX_ATTRIB8_4_NV:
 863       case GL_MAP2_VERTEX_ATTRIB9_4_NV:
 864       case GL_MAP2_VERTEX_ATTRIB10_4_NV:
 865       case GL_MAP2_VERTEX_ATTRIB11_4_NV:
 866       case GL_MAP2_VERTEX_ATTRIB12_4_NV:
 867       case GL_MAP2_VERTEX_ATTRIB13_4_NV:
 868       case GL_MAP2_VERTEX_ATTRIB14_4_NV:
 869       case GL_MAP2_VERTEX_ATTRIB15_4_NV:
 870          CHECK_EXTENSION(NV_vertex_program, cap);
 871          {
 872             const GLuint map = (GLuint) (cap - GL_MAP2_VERTEX_ATTRIB0_4_NV);
 873             FLUSH_VERTICES(ctx, _NEW_EVAL);
 874             ctx->Eval.Map2Attrib[map] = state;
 875          }
 876          break;
 877 #endif /* FEATURE_NV_vertex_program */
 878
 879       /* GL_NV_texture_rectangle */
 880       case GL_TEXTURE_RECTANGLE_NV:
 881          CHECK_EXTENSION(NV_texture_rectangle, cap);
 882          {
 883             const GLuint curr = ctx->Texture.CurrentUnit;
 884             struct gl_texture_unit *texUnit = &ctx->Texture.Unit[curr];
 885             GLuint newenabled = texUnit->Enabled & ~TEXTURE_RECT_BIT;
 886             CHECK_EXTENSION(NV_texture_rectangle, cap);
 887             if (state)
 888                newenabled |= TEXTURE_RECT_BIT;
 889             if (!ctx->Visual.rgbMode || texUnit->Enabled == newenabled)
 890                return;
 891             FLUSH_VERTICES(ctx, _NEW_TEXTURE);
 892             texUnit->Enabled = newenabled;
 893          }
 894          break;
 895
 896       /* GL_EXT_stencil_two_side */
 897       case GL_STENCIL_TEST_TWO_SIDE_EXT:
 898          CHECK_EXTENSION(EXT_stencil_two_side, cap);
 899          if (ctx->Stencil.TestTwoSide == state)
 900             return;
 901          FLUSH_VERTICES(ctx, _NEW_STENCIL);
 902          ctx->Stencil.TestTwoSide = state;
 903          break;
 904
 905       default:
 906          _mesa_error(ctx, GL_INVALID_ENUM,
 907                      "%s(0x%x)", state ? "glEnable" : "glDisable", cap);
 908          return;
 909    }
 910
 911    if (ctx->Driver.Enable) {
 912       (*ctx->Driver.Enable)( ctx, cap, state );
 913    }
 914 }
 915
 916
 917 void
 918 _mesa_Enable( GLenum cap )
 919 {
 920    GET_CURRENT_CONTEXT(ctx);
 921    ASSERT_OUTSIDE_BEGIN_END(ctx);
 922
 923    _mesa_set_enable( ctx, cap, GL_TRUE );
 924 }
 925
 926
 927 void
 928 _mesa_Disable( GLenum cap )
 929 {
 930    GET_CURRENT_CONTEXT(ctx);
 931    ASSERT_OUTSIDE_BEGIN_END(ctx);
 932
 933    _mesa_set_enable( ctx, cap, GL_FALSE );
 934 }
 935
 936
 937 #undef CHECK_EXTENSION
 938 #define CHECK_EXTENSION(EXTNAME)                        \
 939    if (!ctx->Extensions.EXTNAME) {                      \
 940       _mesa_error(ctx, GL_INVALID_ENUM, "glIsEnabled"); \
 941       return GL_FALSE;                                  \
 942    }
 943
 944
 945 GLboolean
 946 _mesa_IsEnabled( GLenum cap )
 947 {
 948    GET_CURRENT_CONTEXT(ctx);
 949    switch (cap) {
 950       case GL_ALPHA_TEST:
 951          return ctx->Color.AlphaEnabled;
 952       case GL_AUTO_NORMAL:
 953          return ctx->Eval.AutoNormal;
 954       case GL_BLEND:
 955          return ctx->Color.BlendEnabled;
 956       case GL_CLIP_PLANE0:
 957       case GL_CLIP_PLANE1:
 958       case GL_CLIP_PLANE2:
 959       case GL_CLIP_PLANE3:
 960       case GL_CLIP_PLANE4:
 961       case GL_CLIP_PLANE5:
 962          return (ctx->Transform.ClipPlanesEnabled >> (cap - GL_CLIP_PLANE0)) & 1;
 963       case GL_COLOR_MATERIAL:
 964          return ctx->Light.ColorMaterialEnabled;
 965       case GL_CULL_FACE:
 966          return ctx->Polygon.CullFlag;
 967       case GL_DEPTH_TEST:
 968          return ctx->Depth.Test;
 969       case GL_DITHER:
 970          return ctx->Color.DitherFlag;
 971       case GL_FOG:
 972          return ctx->Fog.Enabled;
 973       case GL_LIGHTING:
 974          return ctx->Light.Enabled;
 975       case GL_LIGHT0:
 976       case GL_LIGHT1:
 977       case GL_LIGHT2:
 978       case GL_LIGHT3:
 979       case GL_LIGHT4:
 980       case GL_LIGHT5:
 981       case GL_LIGHT6:
 982       case GL_LIGHT7:
 983          return ctx->Light.Light[cap-GL_LIGHT0].Enabled;
 984       case GL_LINE_SMOOTH:
 985          return ctx->Line.SmoothFlag;
 986       case GL_LINE_STIPPLE:
 987          return ctx->Line.StippleFlag;
 988       case GL_INDEX_LOGIC_OP:
 989          return ctx->Color.IndexLogicOpEnabled;
 990       case GL_COLOR_LOGIC_OP:
 991          return ctx->Color.ColorLogicOpEnabled;
 992       case GL_MAP1_COLOR_4:
 993          return ctx->Eval.Map1Color4;
 994       case GL_MAP1_INDEX:
 995          return ctx->Eval.Map1Index;
 996       case GL_MAP1_NORMAL:
 997          return ctx->Eval.Map1Normal;
 998       case GL_MAP1_TEXTURE_COORD_1:
 999          return ctx->Eval.Map1TextureCoord1;
1000       case GL_MAP1_TEXTURE_COORD_2:
1001          return ctx->Eval.Map1TextureCoord2;
1002       case GL_MAP1_TEXTURE_COORD_3:
1003          return ctx->Eval.Map1TextureCoord3;
1004       case GL_MAP1_TEXTURE_COORD_4:
1005          return ctx->Eval.Map1TextureCoord4;
1006       case GL_MAP1_VERTEX_3:
1007          return ctx->Eval.Map1Vertex3;
1008       case GL_MAP1_VERTEX_4:
1009          return ctx->Eval.Map1Vertex4;
1010       case GL_MAP2_COLOR_4:
1011          return ctx->Eval.Map2Color4;
1012       case GL_MAP2_INDEX:
1013          return ctx->Eval.Map2Index;
1014       case GL_MAP2_NORMAL:
1015          return ctx->Eval.Map2Normal;
1016       case GL_MAP2_TEXTURE_COORD_1:
1017          return ctx->Eval.Map2TextureCoord1;
1018       case GL_MAP2_TEXTURE_COORD_2:
1019          return ctx->Eval.Map2TextureCoord2;
1020       case GL_MAP2_TEXTURE_COORD_3:
1021          return ctx->Eval.Map2TextureCoord3;
1022       case GL_MAP2_TEXTURE_COORD_4:
1023          return ctx->Eval.Map2TextureCoord4;
1024       case GL_MAP2_VERTEX_3:
1025          return ctx->Eval.Map2Vertex3;
1026       case GL_MAP2_VERTEX_4:
1027          return ctx->Eval.Map2Vertex4;
1028       case GL_NORMALIZE:
1029          return ctx->Transform.Normalize;
1030       case GL_POINT_SMOOTH:
1031          return ctx->Point.SmoothFlag;
1032       case GL_POLYGON_SMOOTH:
1033          return ctx->Polygon.SmoothFlag;
1034       case GL_POLYGON_STIPPLE:
1035          return ctx->Polygon.StippleFlag;
1036       case GL_POLYGON_OFFSET_POINT:
1037          return ctx->Polygon.OffsetPoint;
1038       case GL_POLYGON_OFFSET_LINE:
1039          return ctx->Polygon.OffsetLine;
1040       case GL_POLYGON_OFFSET_FILL:
1041       /*case GL_POLYGON_OFFSET_EXT:*/
1042          return ctx->Polygon.OffsetFill;
1043       case GL_RESCALE_NORMAL_EXT:
1044          return ctx->Transform.RescaleNormals;
1045       case GL_SCISSOR_TEST:
1046          return ctx->Scissor.Enabled;
1047       case GL_SHARED_TEXTURE_PALETTE_EXT:
1048          return ctx->Texture.SharedPalette;
1049       case GL_STENCIL_TEST:
1050          return ctx->Stencil.Enabled;
1051       case GL_TEXTURE_1D:
1052          {
1053             const struct gl_texture_unit *texUnit;
1054             texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
1055             return (texUnit->Enabled & TEXTURE_1D_BIT) ? GL_TRUE : GL_FALSE;
1056          }
1057       case GL_TEXTURE_2D:
1058          {
1059             const struct gl_texture_unit *texUnit;
1060             texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
1061             return (texUnit->Enabled & TEXTURE_2D_BIT) ? GL_TRUE : GL_FALSE;
1062          }
1063       case GL_TEXTURE_3D:
1064          {
1065             const struct gl_texture_unit *texUnit;
1066             texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
1067             return (texUnit->Enabled & TEXTURE_3D_BIT) ? GL_TRUE : GL_FALSE;
1068          }
1069       case GL_TEXTURE_GEN_Q:
1070          {
1071             const struct gl_texture_unit *texUnit;
1072             texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
1073             return (texUnit->TexGenEnabled & Q_BIT) ? GL_TRUE : GL_FALSE;
1074          }
1075       case GL_TEXTURE_GEN_R:
1076          {
1077             const struct gl_texture_unit *texUnit;
1078             texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
1079             return (texUnit->TexGenEnabled & R_BIT) ? GL_TRUE : GL_FALSE;
1080          }
1081       case GL_TEXTURE_GEN_S:
1082          {
1083             const struct gl_texture_unit *texUnit;
1084             texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
1085             return (texUnit->TexGenEnabled & S_BIT) ? GL_TRUE : GL_FALSE;
1086          }
1087       case GL_TEXTURE_GEN_T:
1088          {
1089             const struct gl_texture_unit *texUnit;
1090             texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
1091             return (texUnit->TexGenEnabled & T_BIT) ? GL_TRUE : GL_FALSE;
1092          }
1093
1094       /*
1095        * CLIENT STATE!!!
1096        */
1097       case GL_VERTEX_ARRAY:
1098          return (ctx->Array.Vertex.Enabled != 0);
1099       case GL_NORMAL_ARRAY:
1100          return (ctx->Array.Normal.Enabled != 0);
1101       case GL_COLOR_ARRAY:
1102          return (ctx->Array.Color.Enabled != 0);
1103       case GL_INDEX_ARRAY:
1104          return (ctx->Array.Index.Enabled != 0);
1105       case GL_TEXTURE_COORD_ARRAY:
1106          return (ctx->Array.TexCoord[ctx->Array.ActiveTexture].Enabled != 0);
1107       case GL_EDGE_FLAG_ARRAY:
1108          return (ctx->Array.EdgeFlag.Enabled != 0);
1109       case GL_FOG_COORDINATE_ARRAY_EXT:
1110          CHECK_EXTENSION(EXT_fog_coord);
1111          return (ctx->Array.FogCoord.Enabled != 0);
1112       case GL_SECONDARY_COLOR_ARRAY_EXT:
1113          CHECK_EXTENSION(EXT_secondary_color);
1114          return (ctx->Array.SecondaryColor.Enabled != 0);
1115
1116       /* GL_EXT_histogram */
1117       case GL_HISTOGRAM:
1118          CHECK_EXTENSION(EXT_histogram);
1119          return ctx->Pixel.HistogramEnabled;
1120       case GL_MINMAX:
1121          CHECK_EXTENSION(EXT_histogram);
1122          return ctx->Pixel.MinMaxEnabled;
1123
1124       /* GL_HP_occlusion_test */
1125       case GL_OCCLUSION_TEST_HP:
1126          CHECK_EXTENSION(HP_occlusion_test);
1127          return ctx->Depth.OcclusionTest;
1128
1129       /* GL_SGIS_pixel_texture */
1130       case GL_PIXEL_TEXTURE_SGIS:
1131          CHECK_EXTENSION(SGIS_pixel_texture);
1132          return ctx->Pixel.PixelTextureEnabled;
1133
1134       /* GL_SGIX_pixel_texture */
1135       case GL_PIXEL_TEX_GEN_SGIX:
1136          CHECK_EXTENSION(SGIX_pixel_texture);
1137          return ctx->Pixel.PixelTextureEnabled;
1138
1139       /* GL_SGI_color_table */
1140       case GL_COLOR_TABLE_SGI:
1141          CHECK_EXTENSION(SGI_color_table);
1142          return ctx->Pixel.ColorTableEnabled;
1143       case GL_POST_CONVOLUTION_COLOR_TABLE_SGI:
1144          CHECK_EXTENSION(SGI_color_table);
1145          return ctx->Pixel.PostConvolutionColorTableEnabled;
1146       case GL_POST_COLOR_MATRIX_COLOR_TABLE_SGI:
1147          CHECK_EXTENSION(SGI_color_table);
1148          return ctx->Pixel.PostColorMatrixColorTableEnabled;
1149
1150       /* GL_EXT_convolution */
1151       case GL_CONVOLUTION_1D:
1152          CHECK_EXTENSION(EXT_convolution);
1153          return ctx->Pixel.Convolution1DEnabled;
1154       case GL_CONVOLUTION_2D:
1155          CHECK_EXTENSION(EXT_convolution);
1156          return ctx->Pixel.Convolution2DEnabled;
1157       case GL_SEPARABLE_2D:
1158          CHECK_EXTENSION(EXT_convolution);
1159          return ctx->Pixel.Separable2DEnabled;
1160
1161       /* GL_ARB_texture_cube_map */
1162       case GL_TEXTURE_CUBE_MAP_ARB:
1163          CHECK_EXTENSION(ARB_texture_cube_map);
1164          {
1165             const struct gl_texture_unit *texUnit;
1166             texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
1167             return (texUnit->Enabled & TEXTURE_CUBE_BIT) ? GL_TRUE : GL_FALSE;
1168          }
1169
1170       /* GL_ARB_multisample */
1171       case GL_MULTISAMPLE_ARB:
1172          CHECK_EXTENSION(ARB_multisample);
1173          return ctx->Multisample.Enabled;
1174       case GL_SAMPLE_ALPHA_TO_COVERAGE_ARB:
1175          CHECK_EXTENSION(ARB_multisample);
1176          return ctx->Multisample.SampleAlphaToCoverage;
1177       case GL_SAMPLE_ALPHA_TO_ONE_ARB:
1178          CHECK_EXTENSION(ARB_multisample);
1179          return ctx->Multisample.SampleAlphaToOne;
1180       case GL_SAMPLE_COVERAGE_ARB:
1181          CHECK_EXTENSION(ARB_multisample);
1182          return ctx->Multisample.SampleCoverage;
1183       case GL_SAMPLE_COVERAGE_INVERT_ARB:
1184          CHECK_EXTENSION(ARB_multisample);
1185          return ctx->Multisample.SampleCoverageInvert;
1186
1187       /* GL_IBM_rasterpos_clip */
1188       case GL_RASTER_POSITION_UNCLIPPED_IBM:
1189          CHECK_EXTENSION(IBM_rasterpos_clip);
1190          return ctx->Transform.RasterPositionUnclipped;
1191
1192       /* GL_NV_point_sprite */
1193       case GL_POINT_SPRITE_NV:
1194          return ctx->Point.PointSprite;
1195
1196 #if FEATURE_NV_vertex_program
1197       case GL_VERTEX_PROGRAM_NV:
1198          CHECK_EXTENSION(NV_vertex_program);
1199          return ctx->VertexProgram.Enabled;
1200       case GL_VERTEX_PROGRAM_POINT_SIZE_NV:
1201          CHECK_EXTENSION(NV_vertex_program);
1202          return ctx->VertexProgram.PointSizeEnabled;
1203       case GL_VERTEX_PROGRAM_TWO_SIDE_NV:
1204          CHECK_EXTENSION(NV_vertex_program);
1205          return ctx->VertexProgram.TwoSideEnabled;
1206       case GL_VERTEX_ATTRIB_ARRAY0_NV:
1207       case GL_VERTEX_ATTRIB_ARRAY1_NV:
1208       case GL_VERTEX_ATTRIB_ARRAY2_NV:
1209       case GL_VERTEX_ATTRIB_ARRAY3_NV:
1210       case GL_VERTEX_ATTRIB_ARRAY4_NV:
1211       case GL_VERTEX_ATTRIB_ARRAY5_NV:
1212       case GL_VERTEX_ATTRIB_ARRAY6_NV:
1213       case GL_VERTEX_ATTRIB_ARRAY7_NV:
1214       case GL_VERTEX_ATTRIB_ARRAY8_NV:
1215       case GL_VERTEX_ATTRIB_ARRAY9_NV:
1216       case GL_VERTEX_ATTRIB_ARRAY10_NV:
1217       case GL_VERTEX_ATTRIB_ARRAY11_NV:
1218       case GL_VERTEX_ATTRIB_ARRAY12_NV:
1219       case GL_VERTEX_ATTRIB_ARRAY13_NV:
1220       case GL_VERTEX_ATTRIB_ARRAY14_NV:
1221       case GL_VERTEX_ATTRIB_ARRAY15_NV:
1222          CHECK_EXTENSION(NV_vertex_program);
1223          {
1224             GLint n = (GLint) cap - GL_VERTEX_ATTRIB_ARRAY0_NV;
1225             return (ctx->Array.VertexAttrib[n].Enabled != 0);
1226          }
1227       case GL_MAP1_VERTEX_ATTRIB0_4_NV:
1228       case GL_MAP1_VERTEX_ATTRIB1_4_NV:
1229       case GL_MAP1_VERTEX_ATTRIB2_4_NV:
1230       case GL_MAP1_VERTEX_ATTRIB3_4_NV:
1231       case GL_MAP1_VERTEX_ATTRIB4_4_NV:
1232       case GL_MAP1_VERTEX_ATTRIB5_4_NV:
1233       case GL_MAP1_VERTEX_ATTRIB6_4_NV:
1234       case GL_MAP1_VERTEX_ATTRIB7_4_NV:
1235       case GL_MAP1_VERTEX_ATTRIB8_4_NV:
1236       case GL_MAP1_VERTEX_ATTRIB9_4_NV:
1237       case GL_MAP1_VERTEX_ATTRIB10_4_NV:
1238       case GL_MAP1_VERTEX_ATTRIB11_4_NV:
1239       case GL_MAP1_VERTEX_ATTRIB12_4_NV:
1240       case GL_MAP1_VERTEX_ATTRIB13_4_NV:
1241       case GL_MAP1_VERTEX_ATTRIB14_4_NV:
1242       case GL_MAP1_VERTEX_ATTRIB15_4_NV:
1243          CHECK_EXTENSION(NV_vertex_program);
1244          {
1245             const GLuint map = (GLuint) (cap - GL_MAP1_VERTEX_ATTRIB0_4_NV);
1246             return ctx->Eval.Map1Attrib[map];
1247          }
1248       case GL_MAP2_VERTEX_ATTRIB0_4_NV:
1249       case GL_MAP2_VERTEX_ATTRIB1_4_NV:
1250       case GL_MAP2_VERTEX_ATTRIB2_4_NV:
1251       case GL_MAP2_VERTEX_ATTRIB3_4_NV:
1252       case GL_MAP2_VERTEX_ATTRIB4_4_NV:
1253       case GL_MAP2_VERTEX_ATTRIB5_4_NV:
1254       case GL_MAP2_VERTEX_ATTRIB6_4_NV:
1255       case GL_MAP2_VERTEX_ATTRIB7_4_NV:
1256       case GL_MAP2_VERTEX_ATTRIB8_4_NV:
1257       case GL_MAP2_VERTEX_ATTRIB9_4_NV:
1258       case GL_MAP2_VERTEX_ATTRIB10_4_NV:
1259       case GL_MAP2_VERTEX_ATTRIB11_4_NV:
1260       case GL_MAP2_VERTEX_ATTRIB12_4_NV:
1261       case GL_MAP2_VERTEX_ATTRIB13_4_NV:
1262       case GL_MAP2_VERTEX_ATTRIB14_4_NV:
1263       case GL_MAP2_VERTEX_ATTRIB15_4_NV:
1264          CHECK_EXTENSION(NV_vertex_program);
1265          {
1266             const GLuint map = (GLuint) (cap - GL_MAP2_VERTEX_ATTRIB0_4_NV);
1267             return ctx->Eval.Map2Attrib[map];
1268          }
1269 #endif /* FEATURE_NV_vertex_program */
1270
1271       /* GL_NV_texture_rectangle */
1272       case GL_TEXTURE_RECTANGLE_NV:
1273          CHECK_EXTENSION(NV_texture_rectangle);
1274          {
1275             const struct gl_texture_unit *texUnit;
1276             texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
1277             return (texUnit->Enabled & TEXTURE_RECT_BIT) ? GL_TRUE : GL_FALSE;
1278          }
1279
1280       /* GL_EXT_stencil_two_side */
1281       case GL_STENCIL_TEST_TWO_SIDE_EXT:
1282          CHECK_EXTENSION(EXT_stencil_two_side);
1283          return ctx->Stencil.TestTwoSide;
1284
1285       default:
1286          _mesa_error(ctx, GL_INVALID_ENUM, "glIsEnabled(0x%x)", (int) cap);
1287          return GL_FALSE;
1288    }
1289 }