src/mesa/main/enable.c

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