src/mesa/main/enable.c

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