src/mesa/main/enable.c

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