src/mesa/main/enable.c

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