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