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.5.1
   9  *
  10  * Copyright (C) 1999-2006  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          break;
 370       case GL_LINE_SMOOTH:
 371          if (ctx->Line.SmoothFlag == state)
 372             return;
 373          FLUSH_VERTICES(ctx, _NEW_LINE);
 374          ctx->Line.SmoothFlag = state;
 375          break;
 376       case GL_LINE_STIPPLE:
 377          if (ctx->Line.StippleFlag == state)
 378             return;
 379          FLUSH_VERTICES(ctx, _NEW_LINE);
 380          ctx->Line.StippleFlag = state;
 381          break;
 382       case GL_INDEX_LOGIC_OP:
 383          if (ctx->Color.IndexLogicOpEnabled == state)
 384             return;
 385          FLUSH_VERTICES(ctx, _NEW_COLOR);
 386          ctx->Color.IndexLogicOpEnabled = state;
 387          break;
 388       case GL_COLOR_LOGIC_OP:
 389          if (ctx->Color.ColorLogicOpEnabled == state)
 390             return;
 391          FLUSH_VERTICES(ctx, _NEW_COLOR);
 392          ctx->Color.ColorLogicOpEnabled = state;
 393          break;
 394       case GL_MAP1_COLOR_4:
 395          if (ctx->Eval.Map1Color4 == state)
 396             return;
 397          FLUSH_VERTICES(ctx, _NEW_EVAL);
 398          ctx->Eval.Map1Color4 = state;
 399          break;
 400       case GL_MAP1_INDEX:
 401          if (ctx->Eval.Map1Index == state)
 402             return;
 403          FLUSH_VERTICES(ctx, _NEW_EVAL);
 404          ctx->Eval.Map1Index = state;
 405          break;
 406       case GL_MAP1_NORMAL:
 407          if (ctx->Eval.Map1Normal == state)
 408             return;
 409          FLUSH_VERTICES(ctx, _NEW_EVAL);
 410          ctx->Eval.Map1Normal = state;
 411          break;
 412       case GL_MAP1_TEXTURE_COORD_1:
 413          if (ctx->Eval.Map1TextureCoord1 == state)
 414             return;
 415          FLUSH_VERTICES(ctx, _NEW_EVAL);
 416          ctx->Eval.Map1TextureCoord1 = state;
 417          break;
 418       case GL_MAP1_TEXTURE_COORD_2:
 419          if (ctx->Eval.Map1TextureCoord2 == state)
 420             return;
 421          FLUSH_VERTICES(ctx, _NEW_EVAL);
 422          ctx->Eval.Map1TextureCoord2 = state;
 423          break;
 424       case GL_MAP1_TEXTURE_COORD_3:
 425          if (ctx->Eval.Map1TextureCoord3 == state)
 426             return;
 427          FLUSH_VERTICES(ctx, _NEW_EVAL);
 428          ctx->Eval.Map1TextureCoord3 = state;
 429          break;
 430       case GL_MAP1_TEXTURE_COORD_4:
 431          if (ctx->Eval.Map1TextureCoord4 == state)
 432             return;
 433          FLUSH_VERTICES(ctx, _NEW_EVAL);
 434          ctx->Eval.Map1TextureCoord4 = state;
 435          break;
 436       case GL_MAP1_VERTEX_3:
 437          if (ctx->Eval.Map1Vertex3 == state)
 438             return;
 439          FLUSH_VERTICES(ctx, _NEW_EVAL);
 440          ctx->Eval.Map1Vertex3 = state;
 441          break;
 442       case GL_MAP1_VERTEX_4:
 443          if (ctx->Eval.Map1Vertex4 == state)
 444             return;
 445          FLUSH_VERTICES(ctx, _NEW_EVAL);
 446          ctx->Eval.Map1Vertex4 = state;
 447          break;
 448       case GL_MAP2_COLOR_4:
 449          if (ctx->Eval.Map2Color4 == state)
 450             return;
 451          FLUSH_VERTICES(ctx, _NEW_EVAL);
 452          ctx->Eval.Map2Color4 = state;
 453          break;
 454       case GL_MAP2_INDEX:
 455          if (ctx->Eval.Map2Index == state)
 456             return;
 457          FLUSH_VERTICES(ctx, _NEW_EVAL);
 458          ctx->Eval.Map2Index = state;
 459          break;
 460       case GL_MAP2_NORMAL:
 461          if (ctx->Eval.Map2Normal == state)
 462             return;
 463          FLUSH_VERTICES(ctx, _NEW_EVAL);
 464          ctx->Eval.Map2Normal = state;
 465          break;
 466       case GL_MAP2_TEXTURE_COORD_1:
 467          if (ctx->Eval.Map2TextureCoord1 == state)
 468             return;
 469          FLUSH_VERTICES(ctx, _NEW_EVAL);
 470          ctx->Eval.Map2TextureCoord1 = state;
 471          break;
 472       case GL_MAP2_TEXTURE_COORD_2:
 473          if (ctx->Eval.Map2TextureCoord2 == state)
 474             return;
 475          FLUSH_VERTICES(ctx, _NEW_EVAL);
 476          ctx->Eval.Map2TextureCoord2 = state;
 477          break;
 478       case GL_MAP2_TEXTURE_COORD_3:
 479          if (ctx->Eval.Map2TextureCoord3 == state)
 480             return;
 481          FLUSH_VERTICES(ctx, _NEW_EVAL);
 482          ctx->Eval.Map2TextureCoord3 = state;
 483          break;
 484       case GL_MAP2_TEXTURE_COORD_4:
 485          if (ctx->Eval.Map2TextureCoord4 == state)
 486             return;
 487          FLUSH_VERTICES(ctx, _NEW_EVAL);
 488          ctx->Eval.Map2TextureCoord4 = state;
 489          break;
 490       case GL_MAP2_VERTEX_3:
 491          if (ctx->Eval.Map2Vertex3 == state)
 492             return;
 493          FLUSH_VERTICES(ctx, _NEW_EVAL);
 494          ctx->Eval.Map2Vertex3 = state;
 495          break;
 496       case GL_MAP2_VERTEX_4:
 497          if (ctx->Eval.Map2Vertex4 == state)
 498             return;
 499          FLUSH_VERTICES(ctx, _NEW_EVAL);
 500          ctx->Eval.Map2Vertex4 = state;
 501          break;
 502       case GL_MINMAX:
 503          if (ctx->Pixel.MinMaxEnabled == state)
 504             return;
 505          FLUSH_VERTICES(ctx, _NEW_PIXEL);
 506          ctx->Pixel.MinMaxEnabled = state;
 507          break;
 508       case GL_NORMALIZE:
 509          if (ctx->Transform.Normalize == state)
 510             return;
 511          FLUSH_VERTICES(ctx, _NEW_TRANSFORM);
 512          ctx->Transform.Normalize = state;
 513          break;
 514       case GL_POINT_SMOOTH:
 515          if (ctx->Point.SmoothFlag == state)
 516             return;
 517          FLUSH_VERTICES(ctx, _NEW_POINT);
 518          ctx->Point.SmoothFlag = state;
 519          break;
 520       case GL_POLYGON_SMOOTH:
 521          if (ctx->Polygon.SmoothFlag == state)
 522             return;
 523          FLUSH_VERTICES(ctx, _NEW_POLYGON);
 524          ctx->Polygon.SmoothFlag = state;
 525          break;
 526       case GL_POLYGON_STIPPLE:
 527          if (ctx->Polygon.StippleFlag == state)
 528             return;
 529          FLUSH_VERTICES(ctx, _NEW_POLYGON);
 530          ctx->Polygon.StippleFlag = state;
 531          break;
 532       case GL_POLYGON_OFFSET_POINT:
 533          if (ctx->Polygon.OffsetPoint == state)
 534             return;
 535          FLUSH_VERTICES(ctx, _NEW_POLYGON);
 536          ctx->Polygon.OffsetPoint = state;
 537          break;
 538       case GL_POLYGON_OFFSET_LINE:
 539          if (ctx->Polygon.OffsetLine == state)
 540             return;
 541          FLUSH_VERTICES(ctx, _NEW_POLYGON);
 542          ctx->Polygon.OffsetLine = state;
 543          break;
 544       case GL_POLYGON_OFFSET_FILL:
 545          /*case GL_POLYGON_OFFSET_EXT:*/
 546          if (ctx->Polygon.OffsetFill == state)
 547             return;
 548          FLUSH_VERTICES(ctx, _NEW_POLYGON);
 549          ctx->Polygon.OffsetFill = state;
 550          break;
 551       case GL_RESCALE_NORMAL_EXT:
 552          if (ctx->Transform.RescaleNormals == state)
 553             return;
 554          FLUSH_VERTICES(ctx, _NEW_TRANSFORM);
 555          ctx->Transform.RescaleNormals = state;
 556          break;
 557       case GL_SCISSOR_TEST:
 558          if (ctx->Scissor.Enabled == state)
 559             return;
 560          FLUSH_VERTICES(ctx, _NEW_SCISSOR);
 561          ctx->Scissor.Enabled = state;
 562          break;
 563       case GL_SHARED_TEXTURE_PALETTE_EXT:
 564          if (ctx->Texture.SharedPalette == state)
 565             return;
 566          FLUSH_VERTICES(ctx, _NEW_TEXTURE);
 567          ctx->Texture.SharedPalette = state;
 568          break;
 569       case GL_STENCIL_TEST:
 570          if (state && ctx->DrawBuffer->Visual.stencilBits == 0) {
 571             _mesa_warning(ctx,
 572                           "glEnable(GL_STENCIL_TEST) but no stencil buffer");
 573             return;
 574          }
 575          if (ctx->Stencil.Enabled == state)
 576             return;
 577          FLUSH_VERTICES(ctx, _NEW_STENCIL);
 578          ctx->Stencil.Enabled = state;
 579          break;
 580       case GL_TEXTURE_1D:
 581          if (!enable_texture(ctx, state, TEXTURE_1D_BIT)) {
 582             return;
 583          }
 584          break;
 585       case GL_TEXTURE_2D:
 586          if (!enable_texture(ctx, state, TEXTURE_2D_BIT)) {
 587             return;
 588          }
 589          break;
 590       case GL_TEXTURE_3D:
 591          if (!enable_texture(ctx, state, TEXTURE_3D_BIT)) {
 592             return;
 593          }
 594          break;
 595       case GL_TEXTURE_GEN_Q: {
 596          GLuint unit = ctx->Texture.CurrentUnit;
 597          struct gl_texture_unit *texUnit = &ctx->Texture.Unit[unit];
 598          GLuint newenabled = texUnit->TexGenEnabled & ~Q_BIT;
 599          if (state)
 600             newenabled |= Q_BIT;
 601          if (texUnit->TexGenEnabled == newenabled)
 602             return;
 603          FLUSH_VERTICES(ctx, _NEW_TEXTURE);
 604          texUnit->TexGenEnabled = newenabled;
 605          break;
 606       }
 607       case GL_TEXTURE_GEN_R: {
 608          GLuint unit = ctx->Texture.CurrentUnit;
 609          struct gl_texture_unit *texUnit = &ctx->Texture.Unit[unit];
 610          GLuint newenabled = texUnit->TexGenEnabled & ~R_BIT;
 611          if (state)
 612             newenabled |= R_BIT;
 613          if (texUnit->TexGenEnabled == newenabled)
 614             return;
 615          FLUSH_VERTICES(ctx, _NEW_TEXTURE);
 616          texUnit->TexGenEnabled = newenabled;
 617          break;
 618       }
 619       case GL_TEXTURE_GEN_S: {
 620          GLuint unit = ctx->Texture.CurrentUnit;
 621          struct gl_texture_unit *texUnit = &ctx->Texture.Unit[unit];
 622          GLuint newenabled = texUnit->TexGenEnabled & ~S_BIT;
 623          if (state)
 624             newenabled |= S_BIT;
 625          if (texUnit->TexGenEnabled == newenabled)
 626             return;
 627          FLUSH_VERTICES(ctx, _NEW_TEXTURE);
 628          texUnit->TexGenEnabled = newenabled;
 629          break;
 630       }
 631       case GL_TEXTURE_GEN_T: {
 632          GLuint unit = ctx->Texture.CurrentUnit;
 633          struct gl_texture_unit *texUnit = &ctx->Texture.Unit[unit];
 634          GLuint newenabled = texUnit->TexGenEnabled & ~T_BIT;
 635          if (state)
 636             newenabled |= T_BIT;
 637          if (texUnit->TexGenEnabled == newenabled)
 638             return;
 639          FLUSH_VERTICES(ctx, _NEW_TEXTURE);
 640          texUnit->TexGenEnabled = newenabled;
 641          break;
 642       }
 643
 644       /*
 645        * CLIENT STATE!!!
 646        */
 647       case GL_VERTEX_ARRAY:
 648       case GL_NORMAL_ARRAY:
 649       case GL_COLOR_ARRAY:
 650       case GL_INDEX_ARRAY:
 651       case GL_TEXTURE_COORD_ARRAY:
 652       case GL_EDGE_FLAG_ARRAY:
 653       case GL_FOG_COORDINATE_ARRAY_EXT:
 654       case GL_SECONDARY_COLOR_ARRAY_EXT:
 655          client_state( ctx, cap, state );
 656          return;
 657
 658       /* GL_SGI_color_table */
 659       case GL_COLOR_TABLE_SGI:
 660          CHECK_EXTENSION(SGI_color_table, cap);
 661          if (ctx->Pixel.ColorTableEnabled[COLORTABLE_PRECONVOLUTION] == state)
 662             return;
 663          FLUSH_VERTICES(ctx, _NEW_PIXEL);
 664          ctx->Pixel.ColorTableEnabled[COLORTABLE_PRECONVOLUTION] = state;
 665          break;
 666       case GL_POST_CONVOLUTION_COLOR_TABLE_SGI:
 667          CHECK_EXTENSION(SGI_color_table, cap);
 668          if (ctx->Pixel.ColorTableEnabled[COLORTABLE_POSTCONVOLUTION] == state)
 669             return;
 670          FLUSH_VERTICES(ctx, _NEW_PIXEL);
 671          ctx->Pixel.ColorTableEnabled[COLORTABLE_POSTCONVOLUTION] = state;
 672          break;
 673       case GL_POST_COLOR_MATRIX_COLOR_TABLE_SGI:
 674          CHECK_EXTENSION(SGI_color_table, cap);
 675          if (ctx->Pixel.ColorTableEnabled[COLORTABLE_POSTCOLORMATRIX] == state)
 676             return;
 677          FLUSH_VERTICES(ctx, _NEW_PIXEL);
 678          ctx->Pixel.ColorTableEnabled[COLORTABLE_POSTCOLORMATRIX] = state;
 679          break;
 680       case GL_TEXTURE_COLOR_TABLE_SGI:
 681          CHECK_EXTENSION(SGI_texture_color_table, cap);
 682          if (ctx->Texture.Unit[ctx->Texture.CurrentUnit].ColorTableEnabled == state)
 683             return;
 684          FLUSH_VERTICES(ctx, _NEW_TEXTURE);
 685          ctx->Texture.Unit[ctx->Texture.CurrentUnit].ColorTableEnabled = state;
 686          break;
 687
 688       /* GL_EXT_convolution */
 689       case GL_CONVOLUTION_1D:
 690          CHECK_EXTENSION(EXT_convolution, cap);
 691          if (ctx->Pixel.Convolution1DEnabled == state)
 692             return;
 693          FLUSH_VERTICES(ctx, _NEW_PIXEL);
 694          ctx->Pixel.Convolution1DEnabled = state;
 695          break;
 696       case GL_CONVOLUTION_2D:
 697          CHECK_EXTENSION(EXT_convolution, cap);
 698          if (ctx->Pixel.Convolution2DEnabled == state)
 699             return;
 700          FLUSH_VERTICES(ctx, _NEW_PIXEL);
 701          ctx->Pixel.Convolution2DEnabled = state;
 702          break;
 703       case GL_SEPARABLE_2D:
 704          CHECK_EXTENSION(EXT_convolution, cap);
 705          if (ctx->Pixel.Separable2DEnabled == state)
 706             return;
 707          FLUSH_VERTICES(ctx, _NEW_PIXEL);
 708          ctx->Pixel.Separable2DEnabled = state;
 709          break;
 710
 711       /* GL_ARB_texture_cube_map */
 712       case GL_TEXTURE_CUBE_MAP_ARB:
 713          CHECK_EXTENSION(ARB_texture_cube_map, cap);
 714          if (!enable_texture(ctx, state, TEXTURE_CUBE_BIT)) {
 715             return;
 716          }
 717          break;
 718
 719       /* GL_EXT_secondary_color */
 720       case GL_COLOR_SUM_EXT:
 721          CHECK_EXTENSION2(EXT_secondary_color, ARB_vertex_program, cap);
 722          if (ctx->Fog.ColorSumEnabled == state)
 723             return;
 724          FLUSH_VERTICES(ctx, _NEW_FOG);
 725          ctx->Fog.ColorSumEnabled = state;
 726          break;
 727
 728       /* GL_ARB_multisample */
 729       case GL_MULTISAMPLE_ARB:
 730          CHECK_EXTENSION(ARB_multisample, cap);
 731          if (ctx->Multisample.Enabled == state)
 732             return;
 733          FLUSH_VERTICES(ctx, _NEW_MULTISAMPLE);
 734          ctx->Multisample.Enabled = state;
 735          break;
 736       case GL_SAMPLE_ALPHA_TO_COVERAGE_ARB:
 737          CHECK_EXTENSION(ARB_multisample, cap);
 738          if (ctx->Multisample.SampleAlphaToCoverage == state)
 739             return;
 740          FLUSH_VERTICES(ctx, _NEW_MULTISAMPLE);
 741          ctx->Multisample.SampleAlphaToCoverage = state;
 742          break;
 743       case GL_SAMPLE_ALPHA_TO_ONE_ARB:
 744          CHECK_EXTENSION(ARB_multisample, cap);
 745          if (ctx->Multisample.SampleAlphaToOne == state)
 746             return;
 747          FLUSH_VERTICES(ctx, _NEW_MULTISAMPLE);
 748          ctx->Multisample.SampleAlphaToOne = state;
 749          break;
 750       case GL_SAMPLE_COVERAGE_ARB:
 751          CHECK_EXTENSION(ARB_multisample, cap);
 752          if (ctx->Multisample.SampleCoverage == state)
 753             return;
 754          FLUSH_VERTICES(ctx, _NEW_MULTISAMPLE);
 755          ctx->Multisample.SampleCoverage = state;
 756          break;
 757       case GL_SAMPLE_COVERAGE_INVERT_ARB:
 758          CHECK_EXTENSION(ARB_multisample, cap);
 759          if (ctx->Multisample.SampleCoverageInvert == state)
 760             return;
 761          FLUSH_VERTICES(ctx, _NEW_MULTISAMPLE);
 762          ctx->Multisample.SampleCoverageInvert = state;
 763          break;
 764
 765       /* GL_IBM_rasterpos_clip */
 766       case GL_RASTER_POSITION_UNCLIPPED_IBM:
 767          CHECK_EXTENSION(IBM_rasterpos_clip, cap);
 768          if (ctx->Transform.RasterPositionUnclipped == state)
 769             return;
 770          FLUSH_VERTICES(ctx, _NEW_TRANSFORM);
 771          ctx->Transform.RasterPositionUnclipped = state;
 772          break;
 773
 774       /* GL_NV_point_sprite */
 775       case GL_POINT_SPRITE_NV:
 776          CHECK_EXTENSION2(NV_point_sprite, ARB_point_sprite, cap);
 777          if (ctx->Point.PointSprite == state)
 778             return;
 779          FLUSH_VERTICES(ctx, _NEW_POINT);
 780          ctx->Point.PointSprite = state;
 781          break;
 782
 783 #if FEATURE_NV_vertex_program || FEATURE_ARB_vertex_program
 784       case GL_VERTEX_PROGRAM_ARB:
 785          CHECK_EXTENSION2(ARB_vertex_program, NV_vertex_program, cap);
 786          if (ctx->VertexProgram.Enabled == state)
 787             return;
 788          FLUSH_VERTICES(ctx, _NEW_PROGRAM);
 789          ctx->VertexProgram.Enabled = state;
 790          break;
 791       case GL_VERTEX_PROGRAM_POINT_SIZE_ARB:
 792          CHECK_EXTENSION2(ARB_vertex_program, NV_vertex_program, cap);
 793          if (ctx->VertexProgram.PointSizeEnabled == state)
 794             return;
 795          FLUSH_VERTICES(ctx, _NEW_PROGRAM);
 796          ctx->VertexProgram.PointSizeEnabled = state;
 797          break;
 798       case GL_VERTEX_PROGRAM_TWO_SIDE_ARB:
 799          CHECK_EXTENSION2(ARB_vertex_program, NV_vertex_program, cap);
 800          if (ctx->VertexProgram.TwoSideEnabled == state)
 801             return;
 802          FLUSH_VERTICES(ctx, _NEW_PROGRAM);
 803          ctx->VertexProgram.TwoSideEnabled = state;
 804          break;
 805 #endif
 806 #if FEATURE_NV_vertex_program
 807       case GL_MAP1_VERTEX_ATTRIB0_4_NV:
 808       case GL_MAP1_VERTEX_ATTRIB1_4_NV:
 809       case GL_MAP1_VERTEX_ATTRIB2_4_NV:
 810       case GL_MAP1_VERTEX_ATTRIB3_4_NV:
 811       case GL_MAP1_VERTEX_ATTRIB4_4_NV:
 812       case GL_MAP1_VERTEX_ATTRIB5_4_NV:
 813       case GL_MAP1_VERTEX_ATTRIB6_4_NV:
 814       case GL_MAP1_VERTEX_ATTRIB7_4_NV:
 815       case GL_MAP1_VERTEX_ATTRIB8_4_NV:
 816       case GL_MAP1_VERTEX_ATTRIB9_4_NV:
 817       case GL_MAP1_VERTEX_ATTRIB10_4_NV:
 818       case GL_MAP1_VERTEX_ATTRIB11_4_NV:
 819       case GL_MAP1_VERTEX_ATTRIB12_4_NV:
 820       case GL_MAP1_VERTEX_ATTRIB13_4_NV:
 821       case GL_MAP1_VERTEX_ATTRIB14_4_NV:
 822       case GL_MAP1_VERTEX_ATTRIB15_4_NV:
 823          CHECK_EXTENSION(NV_vertex_program, cap);
 824          {
 825             const GLuint map = (GLuint) (cap - GL_MAP1_VERTEX_ATTRIB0_4_NV);
 826             FLUSH_VERTICES(ctx, _NEW_EVAL);
 827             ctx->Eval.Map1Attrib[map] = state;
 828          }
 829          break;
 830       case GL_MAP2_VERTEX_ATTRIB0_4_NV:
 831       case GL_MAP2_VERTEX_ATTRIB1_4_NV:
 832       case GL_MAP2_VERTEX_ATTRIB2_4_NV:
 833       case GL_MAP2_VERTEX_ATTRIB3_4_NV:
 834       case GL_MAP2_VERTEX_ATTRIB4_4_NV:
 835       case GL_MAP2_VERTEX_ATTRIB5_4_NV:
 836       case GL_MAP2_VERTEX_ATTRIB6_4_NV:
 837       case GL_MAP2_VERTEX_ATTRIB7_4_NV:
 838       case GL_MAP2_VERTEX_ATTRIB8_4_NV:
 839       case GL_MAP2_VERTEX_ATTRIB9_4_NV:
 840       case GL_MAP2_VERTEX_ATTRIB10_4_NV:
 841       case GL_MAP2_VERTEX_ATTRIB11_4_NV:
 842       case GL_MAP2_VERTEX_ATTRIB12_4_NV:
 843       case GL_MAP2_VERTEX_ATTRIB13_4_NV:
 844       case GL_MAP2_VERTEX_ATTRIB14_4_NV:
 845       case GL_MAP2_VERTEX_ATTRIB15_4_NV:
 846          CHECK_EXTENSION(NV_vertex_program, cap);
 847          {
 848             const GLuint map = (GLuint) (cap - GL_MAP2_VERTEX_ATTRIB0_4_NV);
 849             FLUSH_VERTICES(ctx, _NEW_EVAL);
 850             ctx->Eval.Map2Attrib[map] = state;
 851          }
 852          break;
 853 #endif /* FEATURE_NV_vertex_program */
 854
 855 #if FEATURE_NV_fragment_program
 856       case GL_FRAGMENT_PROGRAM_NV:
 857          CHECK_EXTENSION(NV_fragment_program, cap);
 858          if (ctx->FragmentProgram.Enabled == state)
 859             return;
 860          FLUSH_VERTICES(ctx, _NEW_PROGRAM);
 861          ctx->FragmentProgram.Enabled = state;
 862          break;
 863 #endif /* FEATURE_NV_fragment_program */
 864
 865       /* GL_NV_texture_rectangle */
 866       case GL_TEXTURE_RECTANGLE_NV:
 867          CHECK_EXTENSION(NV_texture_rectangle, cap);
 868          if (!enable_texture(ctx, state, TEXTURE_RECT_BIT)) {
 869             return;
 870          }
 871          break;
 872
 873       /* GL_EXT_stencil_two_side */
 874       case GL_STENCIL_TEST_TWO_SIDE_EXT:
 875          CHECK_EXTENSION(EXT_stencil_two_side, cap);
 876          if (ctx->Stencil.TestTwoSide == state)
 877             return;
 878          FLUSH_VERTICES(ctx, _NEW_STENCIL);
 879          ctx->Stencil.TestTwoSide = state;
 880          break;
 881
 882 #if FEATURE_ARB_fragment_program
 883       case GL_FRAGMENT_PROGRAM_ARB:
 884          CHECK_EXTENSION(ARB_fragment_program, cap);
 885          if (ctx->FragmentProgram.Enabled == state)
 886             return;
 887          FLUSH_VERTICES(ctx, _NEW_PROGRAM);
 888          ctx->FragmentProgram.Enabled = state;
 889          break;
 890 #endif /* FEATURE_ARB_fragment_program */
 891
 892       /* GL_EXT_depth_bounds_test */
 893       case GL_DEPTH_BOUNDS_TEST_EXT:
 894          CHECK_EXTENSION(EXT_depth_bounds_test, cap);
 895          if (state && ctx->DrawBuffer->Visual.depthBits == 0) {
 896             _mesa_warning(ctx,
 897                    "glEnable(GL_DEPTH_BOUNDS_TEST_EXT) but no depth buffer");
 898             return;
 899          }
 900          if (ctx->Depth.BoundsTest == state)
 901             return;
 902          FLUSH_VERTICES(ctx, _NEW_DEPTH);
 903          ctx->Depth.BoundsTest = state;
 904          break;
 905
 906       /* GL_MESA_program_debug */
 907       case GL_FRAGMENT_PROGRAM_CALLBACK_MESA:
 908          CHECK_EXTENSION(MESA_program_debug, cap);
 909          ctx->FragmentProgram.CallbackEnabled = state;
 910          break;
 911       case GL_VERTEX_PROGRAM_CALLBACK_MESA:
 912          CHECK_EXTENSION(MESA_program_debug, cap);
 913          ctx->VertexProgram.CallbackEnabled = state;
 914          break;
 915
 916 #if FEATURE_ATI_fragment_shader
 917       case GL_FRAGMENT_SHADER_ATI:
 918         CHECK_EXTENSION(ATI_fragment_shader, cap);
 919         if (ctx->ATIFragmentShader.Enabled == state)
 920           return;
 921         FLUSH_VERTICES(ctx, _NEW_PROGRAM);
 922         ctx->ATIFragmentShader.Enabled = state;
 923         break;
 924 #endif
 925
 926       /* GL_MESA_texture_array */
 927       case GL_TEXTURE_1D_ARRAY_EXT:
 928          CHECK_EXTENSION(MESA_texture_array, cap);
 929          if (!enable_texture(ctx, state, TEXTURE_1D_ARRAY_BIT)) {
 930             return;
 931          }
 932          break;
 933
 934       case GL_TEXTURE_2D_ARRAY_EXT:
 935          CHECK_EXTENSION(MESA_texture_array, cap);
 936          if (!enable_texture(ctx, state, TEXTURE_2D_ARRAY_BIT)) {
 937             return;
 938          }
 939          break;
 940
 941       default:
 942          _mesa_error(ctx, GL_INVALID_ENUM,
 943                      "%s(0x%x)", state ? "glEnable" : "glDisable", cap);
 944          return;
 945    }
 946
 947    if (ctx->Driver.Enable) {
 948       ctx->Driver.Enable( ctx, cap, state );
 949    }
 950 }
 951
 952
 953 /**
 954  * Enable GL capability.  Called by glEnable()
 955  * \param cap  state to enable.
 956  */
 957 void GLAPIENTRY
 958 _mesa_Enable( GLenum cap )
 959 {
 960    GET_CURRENT_CONTEXT(ctx);
 961    ASSERT_OUTSIDE_BEGIN_END(ctx);
 962
 963    _mesa_set_enable( ctx, cap, GL_TRUE );
 964 }
 965
 966
 967 /**
 968  * Disable GL capability.  Called by glDisable()
 969  * \param cap  state to disable.
 970  */
 971 void GLAPIENTRY
 972 _mesa_Disable( GLenum cap )
 973 {
 974    GET_CURRENT_CONTEXT(ctx);
 975    ASSERT_OUTSIDE_BEGIN_END(ctx);
 976
 977    _mesa_set_enable( ctx, cap, GL_FALSE );
 978 }
 979
 980
 981 #undef CHECK_EXTENSION
 982 #define CHECK_EXTENSION(EXTNAME)                        \
 983    if (!ctx->Extensions.EXTNAME) {                      \
 984       _mesa_error(ctx, GL_INVALID_ENUM, "glIsEnabled"); \
 985       return GL_FALSE;                                  \
 986    }
 987
 988 #undef CHECK_EXTENSION2
 989 #define CHECK_EXTENSION2(EXT1, EXT2)                            \
 990    if (!ctx->Extensions.EXT1 && !ctx->Extensions.EXT2) {        \
 991       _mesa_error(ctx, GL_INVALID_ENUM, "glIsEnabled");         \
 992       return GL_FALSE;                                          \
 993    }
 994
 995
 996 /**
 997  * Helper function to determine whether a texture target is enabled.
 998  */
 999 static GLboolean
1000 is_texture_enabled(GLcontext *ctx, GLbitfield bit)
1001 {
1002    const struct gl_texture_unit *const texUnit =
1003        &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
1004    return (texUnit->Enabled & bit) ? GL_TRUE : GL_FALSE;
1005 }
1006
1007
1008 /**
1009  * Return simple enable/disable state.
1010  *
1011  * \param cap  state variable to query.
1012  *
1013  * Returns the state of the specified capability from the current GL context.
1014  * For the capabilities associated with extensions verifies that those
1015  * extensions are effectively present before reporting.
1016  */
1017 GLboolean GLAPIENTRY
1018 _mesa_IsEnabled( GLenum cap )
1019 {
1020    GET_CURRENT_CONTEXT(ctx);
1021    switch (cap) {
1022       case GL_ALPHA_TEST:
1023          return ctx->Color.AlphaEnabled;
1024       case GL_AUTO_NORMAL:
1025          return ctx->Eval.AutoNormal;
1026       case GL_BLEND:
1027          return ctx->Color.BlendEnabled;
1028       case GL_CLIP_PLANE0:
1029       case GL_CLIP_PLANE1:
1030       case GL_CLIP_PLANE2:
1031       case GL_CLIP_PLANE3:
1032       case GL_CLIP_PLANE4:
1033       case GL_CLIP_PLANE5:
1034          return (ctx->Transform.ClipPlanesEnabled >> (cap - GL_CLIP_PLANE0)) & 1;
1035       case GL_COLOR_MATERIAL:
1036          return ctx->Light.ColorMaterialEnabled;
1037       case GL_CULL_FACE:
1038          return ctx->Polygon.CullFlag;
1039       case GL_DEPTH_TEST:
1040          return ctx->Depth.Test;
1041       case GL_DITHER:
1042          return ctx->Color.DitherFlag;
1043       case GL_FOG:
1044          return ctx->Fog.Enabled;
1045       case GL_LIGHTING:
1046          return ctx->Light.Enabled;
1047       case GL_LIGHT0:
1048       case GL_LIGHT1:
1049       case GL_LIGHT2:
1050       case GL_LIGHT3:
1051       case GL_LIGHT4:
1052       case GL_LIGHT5:
1053       case GL_LIGHT6:
1054       case GL_LIGHT7:
1055          return ctx->Light.Light[cap-GL_LIGHT0].Enabled;
1056       case GL_LINE_SMOOTH:
1057          return ctx->Line.SmoothFlag;
1058       case GL_LINE_STIPPLE:
1059          return ctx->Line.StippleFlag;
1060       case GL_INDEX_LOGIC_OP:
1061          return ctx->Color.IndexLogicOpEnabled;
1062       case GL_COLOR_LOGIC_OP:
1063          return ctx->Color.ColorLogicOpEnabled;
1064       case GL_MAP1_COLOR_4:
1065          return ctx->Eval.Map1Color4;
1066       case GL_MAP1_INDEX:
1067          return ctx->Eval.Map1Index;
1068       case GL_MAP1_NORMAL:
1069          return ctx->Eval.Map1Normal;
1070       case GL_MAP1_TEXTURE_COORD_1:
1071          return ctx->Eval.Map1TextureCoord1;
1072       case GL_MAP1_TEXTURE_COORD_2:
1073          return ctx->Eval.Map1TextureCoord2;
1074       case GL_MAP1_TEXTURE_COORD_3:
1075          return ctx->Eval.Map1TextureCoord3;
1076       case GL_MAP1_TEXTURE_COORD_4:
1077          return ctx->Eval.Map1TextureCoord4;
1078       case GL_MAP1_VERTEX_3:
1079          return ctx->Eval.Map1Vertex3;
1080       case GL_MAP1_VERTEX_4:
1081          return ctx->Eval.Map1Vertex4;
1082       case GL_MAP2_COLOR_4:
1083          return ctx->Eval.Map2Color4;
1084       case GL_MAP2_INDEX:
1085          return ctx->Eval.Map2Index;
1086       case GL_MAP2_NORMAL:
1087          return ctx->Eval.Map2Normal;
1088       case GL_MAP2_TEXTURE_COORD_1:
1089          return ctx->Eval.Map2TextureCoord1;
1090       case GL_MAP2_TEXTURE_COORD_2:
1091          return ctx->Eval.Map2TextureCoord2;
1092       case GL_MAP2_TEXTURE_COORD_3:
1093          return ctx->Eval.Map2TextureCoord3;
1094       case GL_MAP2_TEXTURE_COORD_4:
1095          return ctx->Eval.Map2TextureCoord4;
1096       case GL_MAP2_VERTEX_3:
1097          return ctx->Eval.Map2Vertex3;
1098       case GL_MAP2_VERTEX_4:
1099          return ctx->Eval.Map2Vertex4;
1100       case GL_NORMALIZE:
1101          return ctx->Transform.Normalize;
1102       case GL_POINT_SMOOTH:
1103          return ctx->Point.SmoothFlag;
1104       case GL_POLYGON_SMOOTH:
1105          return ctx->Polygon.SmoothFlag;
1106       case GL_POLYGON_STIPPLE:
1107          return ctx->Polygon.StippleFlag;
1108       case GL_POLYGON_OFFSET_POINT:
1109          return ctx->Polygon.OffsetPoint;
1110       case GL_POLYGON_OFFSET_LINE:
1111          return ctx->Polygon.OffsetLine;
1112       case GL_POLYGON_OFFSET_FILL:
1113       /*case GL_POLYGON_OFFSET_EXT:*/
1114          return ctx->Polygon.OffsetFill;
1115       case GL_RESCALE_NORMAL_EXT:
1116          return ctx->Transform.RescaleNormals;
1117       case GL_SCISSOR_TEST:
1118          return ctx->Scissor.Enabled;
1119       case GL_SHARED_TEXTURE_PALETTE_EXT:
1120          return ctx->Texture.SharedPalette;
1121       case GL_STENCIL_TEST:
1122          return ctx->Stencil.Enabled;
1123       case GL_TEXTURE_1D:
1124          return is_texture_enabled(ctx, TEXTURE_1D_BIT);
1125       case GL_TEXTURE_2D:
1126          return is_texture_enabled(ctx, TEXTURE_2D_BIT);
1127       case GL_TEXTURE_3D:
1128          return is_texture_enabled(ctx, TEXTURE_3D_BIT);
1129       case GL_TEXTURE_GEN_Q:
1130          {
1131             const struct gl_texture_unit *texUnit;
1132             texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
1133             return (texUnit->TexGenEnabled & Q_BIT) ? GL_TRUE : GL_FALSE;
1134          }
1135       case GL_TEXTURE_GEN_R:
1136          {
1137             const struct gl_texture_unit *texUnit;
1138             texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
1139             return (texUnit->TexGenEnabled & R_BIT) ? GL_TRUE : GL_FALSE;
1140          }
1141       case GL_TEXTURE_GEN_S:
1142          {
1143             const struct gl_texture_unit *texUnit;
1144             texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
1145             return (texUnit->TexGenEnabled & S_BIT) ? GL_TRUE : GL_FALSE;
1146          }
1147       case GL_TEXTURE_GEN_T:
1148          {
1149             const struct gl_texture_unit *texUnit;
1150             texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
1151             return (texUnit->TexGenEnabled & T_BIT) ? GL_TRUE : GL_FALSE;
1152          }
1153
1154       /*
1155        * CLIENT STATE!!!
1156        */
1157       case GL_VERTEX_ARRAY:
1158          return (ctx->Array.ArrayObj->Vertex.Enabled != 0);
1159       case GL_NORMAL_ARRAY:
1160          return (ctx->Array.ArrayObj->Normal.Enabled != 0);
1161       case GL_COLOR_ARRAY:
1162          return (ctx->Array.ArrayObj->Color.Enabled != 0);
1163       case GL_INDEX_ARRAY:
1164          return (ctx->Array.ArrayObj->Index.Enabled != 0);
1165       case GL_TEXTURE_COORD_ARRAY:
1166          return (ctx->Array.ArrayObj->TexCoord[ctx->Array.ActiveTexture].Enabled != 0);
1167       case GL_EDGE_FLAG_ARRAY:
1168          return (ctx->Array.ArrayObj->EdgeFlag.Enabled != 0);
1169       case GL_FOG_COORDINATE_ARRAY_EXT:
1170          CHECK_EXTENSION(EXT_fog_coord);
1171          return (ctx->Array.ArrayObj->FogCoord.Enabled != 0);
1172       case GL_SECONDARY_COLOR_ARRAY_EXT:
1173          CHECK_EXTENSION(EXT_secondary_color);
1174          return (ctx->Array.ArrayObj->SecondaryColor.Enabled != 0);
1175
1176       /* GL_EXT_histogram */
1177       case GL_HISTOGRAM:
1178          CHECK_EXTENSION(EXT_histogram);
1179          return ctx->Pixel.HistogramEnabled;
1180       case GL_MINMAX:
1181          CHECK_EXTENSION(EXT_histogram);
1182          return ctx->Pixel.MinMaxEnabled;
1183
1184       /* GL_SGI_color_table */
1185       case GL_COLOR_TABLE_SGI:
1186          CHECK_EXTENSION(SGI_color_table);
1187          return ctx->Pixel.ColorTableEnabled[COLORTABLE_PRECONVOLUTION];
1188       case GL_POST_CONVOLUTION_COLOR_TABLE_SGI:
1189          CHECK_EXTENSION(SGI_color_table);
1190          return ctx->Pixel.ColorTableEnabled[COLORTABLE_POSTCONVOLUTION];
1191       case GL_POST_COLOR_MATRIX_COLOR_TABLE_SGI:
1192          CHECK_EXTENSION(SGI_color_table);
1193          return ctx->Pixel.ColorTableEnabled[COLORTABLE_POSTCOLORMATRIX];
1194
1195       /* GL_SGI_texture_color_table */
1196       case GL_TEXTURE_COLOR_TABLE_SGI:
1197          CHECK_EXTENSION(SGI_texture_color_table);
1198          return ctx->Texture.Unit[ctx->Texture.CurrentUnit].ColorTableEnabled;
1199
1200       /* GL_EXT_convolution */
1201       case GL_CONVOLUTION_1D:
1202          CHECK_EXTENSION(EXT_convolution);
1203          return ctx->Pixel.Convolution1DEnabled;
1204       case GL_CONVOLUTION_2D:
1205          CHECK_EXTENSION(EXT_convolution);
1206          return ctx->Pixel.Convolution2DEnabled;
1207       case GL_SEPARABLE_2D:
1208          CHECK_EXTENSION(EXT_convolution);
1209          return ctx->Pixel.Separable2DEnabled;
1210
1211       /* GL_ARB_texture_cube_map */
1212       case GL_TEXTURE_CUBE_MAP_ARB:
1213          CHECK_EXTENSION(ARB_texture_cube_map);
1214          return is_texture_enabled(ctx, TEXTURE_CUBE_BIT);
1215
1216       /* GL_EXT_secondary_color */
1217       case GL_COLOR_SUM_EXT:
1218          CHECK_EXTENSION2(EXT_secondary_color, ARB_vertex_program);
1219          return ctx->Fog.ColorSumEnabled;
1220
1221       /* GL_ARB_multisample */
1222       case GL_MULTISAMPLE_ARB:
1223          CHECK_EXTENSION(ARB_multisample);
1224          return ctx->Multisample.Enabled;
1225       case GL_SAMPLE_ALPHA_TO_COVERAGE_ARB:
1226          CHECK_EXTENSION(ARB_multisample);
1227          return ctx->Multisample.SampleAlphaToCoverage;
1228       case GL_SAMPLE_ALPHA_TO_ONE_ARB:
1229          CHECK_EXTENSION(ARB_multisample);
1230          return ctx->Multisample.SampleAlphaToOne;
1231       case GL_SAMPLE_COVERAGE_ARB:
1232          CHECK_EXTENSION(ARB_multisample);
1233          return ctx->Multisample.SampleCoverage;
1234       case GL_SAMPLE_COVERAGE_INVERT_ARB:
1235          CHECK_EXTENSION(ARB_multisample);
1236          return ctx->Multisample.SampleCoverageInvert;
1237
1238       /* GL_IBM_rasterpos_clip */
1239       case GL_RASTER_POSITION_UNCLIPPED_IBM:
1240          CHECK_EXTENSION(IBM_rasterpos_clip);
1241          return ctx->Transform.RasterPositionUnclipped;
1242
1243       /* GL_NV_point_sprite */
1244       case GL_POINT_SPRITE_NV:
1245          CHECK_EXTENSION2(NV_point_sprite, ARB_point_sprite)
1246          return ctx->Point.PointSprite;
1247
1248 #if FEATURE_NV_vertex_program || FEATURE_ARB_vertex_program
1249       case GL_VERTEX_PROGRAM_ARB:
1250          CHECK_EXTENSION2(ARB_vertex_program, NV_vertex_program);
1251          return ctx->VertexProgram.Enabled;
1252       case GL_VERTEX_PROGRAM_POINT_SIZE_ARB:
1253          CHECK_EXTENSION2(ARB_vertex_program, NV_vertex_program);
1254          return ctx->VertexProgram.PointSizeEnabled;
1255       case GL_VERTEX_PROGRAM_TWO_SIDE_ARB:
1256          CHECK_EXTENSION2(ARB_vertex_program, NV_vertex_program);
1257          return ctx->VertexProgram.TwoSideEnabled;
1258 #endif
1259 #if FEATURE_NV_vertex_program
1260       case GL_VERTEX_ATTRIB_ARRAY0_NV:
1261       case GL_VERTEX_ATTRIB_ARRAY1_NV:
1262       case GL_VERTEX_ATTRIB_ARRAY2_NV:
1263       case GL_VERTEX_ATTRIB_ARRAY3_NV:
1264       case GL_VERTEX_ATTRIB_ARRAY4_NV:
1265       case GL_VERTEX_ATTRIB_ARRAY5_NV:
1266       case GL_VERTEX_ATTRIB_ARRAY6_NV:
1267       case GL_VERTEX_ATTRIB_ARRAY7_NV:
1268       case GL_VERTEX_ATTRIB_ARRAY8_NV:
1269       case GL_VERTEX_ATTRIB_ARRAY9_NV:
1270       case GL_VERTEX_ATTRIB_ARRAY10_NV:
1271       case GL_VERTEX_ATTRIB_ARRAY11_NV:
1272       case GL_VERTEX_ATTRIB_ARRAY12_NV:
1273       case GL_VERTEX_ATTRIB_ARRAY13_NV:
1274       case GL_VERTEX_ATTRIB_ARRAY14_NV:
1275       case GL_VERTEX_ATTRIB_ARRAY15_NV:
1276          CHECK_EXTENSION(NV_vertex_program);
1277          {
1278             GLint n = (GLint) cap - GL_VERTEX_ATTRIB_ARRAY0_NV;
1279             return (ctx->Array.ArrayObj->VertexAttrib[n].Enabled != 0);
1280          }
1281       case GL_MAP1_VERTEX_ATTRIB0_4_NV:
1282       case GL_MAP1_VERTEX_ATTRIB1_4_NV:
1283       case GL_MAP1_VERTEX_ATTRIB2_4_NV:
1284       case GL_MAP1_VERTEX_ATTRIB3_4_NV:
1285       case GL_MAP1_VERTEX_ATTRIB4_4_NV:
1286       case GL_MAP1_VERTEX_ATTRIB5_4_NV:
1287       case GL_MAP1_VERTEX_ATTRIB6_4_NV:
1288       case GL_MAP1_VERTEX_ATTRIB7_4_NV:
1289       case GL_MAP1_VERTEX_ATTRIB8_4_NV:
1290       case GL_MAP1_VERTEX_ATTRIB9_4_NV:
1291       case GL_MAP1_VERTEX_ATTRIB10_4_NV:
1292       case GL_MAP1_VERTEX_ATTRIB11_4_NV:
1293       case GL_MAP1_VERTEX_ATTRIB12_4_NV:
1294       case GL_MAP1_VERTEX_ATTRIB13_4_NV:
1295       case GL_MAP1_VERTEX_ATTRIB14_4_NV:
1296       case GL_MAP1_VERTEX_ATTRIB15_4_NV:
1297          CHECK_EXTENSION(NV_vertex_program);
1298          {
1299             const GLuint map = (GLuint) (cap - GL_MAP1_VERTEX_ATTRIB0_4_NV);
1300             return ctx->Eval.Map1Attrib[map];
1301          }
1302       case GL_MAP2_VERTEX_ATTRIB0_4_NV:
1303       case GL_MAP2_VERTEX_ATTRIB1_4_NV:
1304       case GL_MAP2_VERTEX_ATTRIB2_4_NV:
1305       case GL_MAP2_VERTEX_ATTRIB3_4_NV:
1306       case GL_MAP2_VERTEX_ATTRIB4_4_NV:
1307       case GL_MAP2_VERTEX_ATTRIB5_4_NV:
1308       case GL_MAP2_VERTEX_ATTRIB6_4_NV:
1309       case GL_MAP2_VERTEX_ATTRIB7_4_NV:
1310       case GL_MAP2_VERTEX_ATTRIB8_4_NV:
1311       case GL_MAP2_VERTEX_ATTRIB9_4_NV:
1312       case GL_MAP2_VERTEX_ATTRIB10_4_NV:
1313       case GL_MAP2_VERTEX_ATTRIB11_4_NV:
1314       case GL_MAP2_VERTEX_ATTRIB12_4_NV:
1315       case GL_MAP2_VERTEX_ATTRIB13_4_NV:
1316       case GL_MAP2_VERTEX_ATTRIB14_4_NV:
1317       case GL_MAP2_VERTEX_ATTRIB15_4_NV:
1318          CHECK_EXTENSION(NV_vertex_program);
1319          {
1320             const GLuint map = (GLuint) (cap - GL_MAP2_VERTEX_ATTRIB0_4_NV);
1321             return ctx->Eval.Map2Attrib[map];
1322          }
1323 #endif /* FEATURE_NV_vertex_program */
1324
1325 #if FEATURE_NV_fragment_program
1326       case GL_FRAGMENT_PROGRAM_NV:
1327          CHECK_EXTENSION(NV_fragment_program);
1328          return ctx->FragmentProgram.Enabled;
1329 #endif /* FEATURE_NV_fragment_program */
1330
1331       /* GL_NV_texture_rectangle */
1332       case GL_TEXTURE_RECTANGLE_NV:
1333          CHECK_EXTENSION(NV_texture_rectangle);
1334          return is_texture_enabled(ctx, TEXTURE_RECT_BIT);
1335
1336       /* GL_EXT_stencil_two_side */
1337       case GL_STENCIL_TEST_TWO_SIDE_EXT:
1338          CHECK_EXTENSION(EXT_stencil_two_side);
1339          return ctx->Stencil.TestTwoSide;
1340
1341 #if FEATURE_ARB_fragment_program
1342       case GL_FRAGMENT_PROGRAM_ARB:
1343          return ctx->FragmentProgram.Enabled;
1344 #endif /* FEATURE_ARB_fragment_program */
1345
1346       /* GL_EXT_depth_bounds_test */
1347       case GL_DEPTH_BOUNDS_TEST_EXT:
1348          CHECK_EXTENSION(EXT_depth_bounds_test);
1349          return ctx->Depth.BoundsTest;
1350
1351       /* GL_MESA_program_debug */
1352       case GL_FRAGMENT_PROGRAM_CALLBACK_MESA:
1353          CHECK_EXTENSION(MESA_program_debug);
1354          return ctx->FragmentProgram.CallbackEnabled;
1355       case GL_VERTEX_PROGRAM_CALLBACK_MESA:
1356          CHECK_EXTENSION(MESA_program_debug);
1357          return ctx->VertexProgram.CallbackEnabled;
1358 #if FEATURE_ATI_fragment_shader
1359       case GL_FRAGMENT_SHADER_ATI:
1360          CHECK_EXTENSION(ATI_fragment_shader);
1361          return ctx->ATIFragmentShader.Enabled;
1362 #endif /* FEATURE_ATI_fragment_shader */
1363       default:
1364          _mesa_error(ctx, GL_INVALID_ENUM, "glIsEnabled(0x%x)", (int) cap);
1365          return GL_FALSE;
1366    }
1367 }