src/mesa/main/enable.c

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