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 "simple_list.h"
  36 #include "mtypes.h"
  37 #include "enums.h"
  38 #include "api_arrayelt.h"
  39 #include "texstate.h"
  40
  41
  42
  43 #define CHECK_EXTENSION(EXTNAME, CAP)                                   \
  44    if (!ctx->Extensions.EXTNAME) {                                      \
  45       goto invalid_enum_error;                                          \
  46    }
  47
  48
  49 /**
  50  * Helper to enable/disable client-side state.
  51  */
  52 static void
  53 client_state(GLcontext *ctx, GLenum cap, GLboolean state)
  54 {
  55    struct gl_array_object *arrayObj = ctx->Array.ArrayObj;
  56    GLuint flag;
  57    GLboolean *var;
  58
  59    switch (cap) {
  60       case GL_VERTEX_ARRAY:
  61          var = &arrayObj->Vertex.Enabled;
  62          flag = _NEW_ARRAY_VERTEX;
  63          break;
  64       case GL_NORMAL_ARRAY:
  65          var = &arrayObj->Normal.Enabled;
  66          flag = _NEW_ARRAY_NORMAL;
  67          break;
  68       case GL_COLOR_ARRAY:
  69          var = &arrayObj->Color.Enabled;
  70          flag = _NEW_ARRAY_COLOR0;
  71          break;
  72       case GL_INDEX_ARRAY:
  73          var = &arrayObj->Index.Enabled;
  74          flag = _NEW_ARRAY_INDEX;
  75          break;
  76       case GL_TEXTURE_COORD_ARRAY:
  77          var = &arrayObj->TexCoord[ctx->Array.ActiveTexture].Enabled;
  78          flag = _NEW_ARRAY_TEXCOORD(ctx->Array.ActiveTexture);
  79          break;
  80       case GL_EDGE_FLAG_ARRAY:
  81          var = &arrayObj->EdgeFlag.Enabled;
  82          flag = _NEW_ARRAY_EDGEFLAG;
  83          break;
  84       case GL_FOG_COORDINATE_ARRAY_EXT:
  85          var = &arrayObj->FogCoord.Enabled;
  86          flag = _NEW_ARRAY_FOGCOORD;
  87          break;
  88       case GL_SECONDARY_COLOR_ARRAY_EXT:
  89          var = &arrayObj->SecondaryColor.Enabled;
  90          flag = _NEW_ARRAY_COLOR1;
  91          break;
  92
  93 #if FEATURE_point_size_array
  94       case GL_POINT_SIZE_ARRAY_OES:
  95          var = &arrayObj->PointSize.Enabled;
  96          flag = _NEW_ARRAY_POINT_SIZE;
  97          break;
  98 #endif
  99
 100 #if FEATURE_NV_vertex_program
 101       case GL_VERTEX_ATTRIB_ARRAY0_NV:
 102       case GL_VERTEX_ATTRIB_ARRAY1_NV:
 103       case GL_VERTEX_ATTRIB_ARRAY2_NV:
 104       case GL_VERTEX_ATTRIB_ARRAY3_NV:
 105       case GL_VERTEX_ATTRIB_ARRAY4_NV:
 106       case GL_VERTEX_ATTRIB_ARRAY5_NV:
 107       case GL_VERTEX_ATTRIB_ARRAY6_NV:
 108       case GL_VERTEX_ATTRIB_ARRAY7_NV:
 109       case GL_VERTEX_ATTRIB_ARRAY8_NV:
 110       case GL_VERTEX_ATTRIB_ARRAY9_NV:
 111       case GL_VERTEX_ATTRIB_ARRAY10_NV:
 112       case GL_VERTEX_ATTRIB_ARRAY11_NV:
 113       case GL_VERTEX_ATTRIB_ARRAY12_NV:
 114       case GL_VERTEX_ATTRIB_ARRAY13_NV:
 115       case GL_VERTEX_ATTRIB_ARRAY14_NV:
 116       case GL_VERTEX_ATTRIB_ARRAY15_NV:
 117          CHECK_EXTENSION(NV_vertex_program, cap);
 118          {
 119             GLint n = (GLint) cap - GL_VERTEX_ATTRIB_ARRAY0_NV;
 120             ASSERT(n < Elements(ctx->Array.ArrayObj->VertexAttrib));
 121             var = &arrayObj->VertexAttrib[n].Enabled;
 122             flag = _NEW_ARRAY_ATTRIB(n);
 123          }
 124          break;
 125 #endif /* FEATURE_NV_vertex_program */
 126
 127       default:
 128          goto invalid_enum_error;
 129    }
 130
 131    if (*var == state)
 132       return;
 133
 134    FLUSH_VERTICES(ctx, _NEW_ARRAY);
 135    ctx->Array.NewState |= flag;
 136
 137    _ae_invalidate_state(ctx, _NEW_ARRAY);
 138
 139    *var = state;
 140
 141    if (state)
 142       ctx->Array.ArrayObj->_Enabled |= flag;
 143    else
 144       ctx->Array.ArrayObj->_Enabled &= ~flag;
 145
 146    if (ctx->Driver.Enable) {
 147       ctx->Driver.Enable( ctx, cap, state );
 148    }
 149
 150    return;
 151
 152 invalid_enum_error:
 153    _mesa_error(ctx, GL_INVALID_ENUM, "gl%sClientState(0x%x)",
 154                state ? "Enable" : "Disable", cap);
 155 }
 156
 157
 158 /**
 159  * Enable GL capability.
 160  * \param cap  state to enable/disable.
 161  *
 162  * Get's the current context, assures that we're outside glBegin()/glEnd() and
 163  * calls client_state().
 164  */
 165 void GLAPIENTRY
 166 _mesa_EnableClientState( GLenum cap )
 167 {
 168    GET_CURRENT_CONTEXT(ctx);
 169    ASSERT_OUTSIDE_BEGIN_END(ctx);
 170    client_state( ctx, cap, GL_TRUE );
 171 }
 172
 173
 174 /**
 175  * Disable GL capability.
 176  * \param cap  state to enable/disable.
 177  *
 178  * Get's the current context, assures that we're outside glBegin()/glEnd() and
 179  * calls client_state().
 180  */
 181 void GLAPIENTRY
 182 _mesa_DisableClientState( GLenum cap )
 183 {
 184    GET_CURRENT_CONTEXT(ctx);
 185    ASSERT_OUTSIDE_BEGIN_END(ctx);
 186    client_state( ctx, cap, GL_FALSE );
 187 }
 188
 189
 190 #undef CHECK_EXTENSION
 191 #define CHECK_EXTENSION(EXTNAME, CAP)                                   \
 192    if (!ctx->Extensions.EXTNAME) {                                      \
 193       goto invalid_enum_error;                                          \
 194    }
 195
 196 #define CHECK_EXTENSION2(EXT1, EXT2, CAP)                               \
 197    if (!ctx->Extensions.EXT1 && !ctx->Extensions.EXT2) {                \
 198       goto invalid_enum_error;                                          \
 199    }
 200
 201
 202
 203 /**
 204  * Return pointer to current texture unit for setting/getting coordinate
 205  * state.
 206  * Note that we'll set GL_INVALID_OPERATION if the active texture unit is
 207  * higher than the number of supported coordinate units.  And we'll return NULL.
 208  */
 209 static struct gl_texture_unit *
 210 get_texcoord_unit(GLcontext *ctx)
 211 {
 212    if (ctx->Texture.CurrentUnit >= ctx->Const.MaxTextureCoordUnits) {
 213       _mesa_error(ctx, GL_INVALID_OPERATION, "glEnable/Disable(texcoord unit)");
 214       return NULL;
 215    }
 216    else {
 217       return &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
 218    }
 219 }
 220
 221
 222 /**
 223  * Helper function to enable or disable a texture target.
 224  * \param bit  one of the TEXTURE_x_BIT values
 225  * \return GL_TRUE if state is changing or GL_FALSE if no change
 226  */
 227 static GLboolean
 228 enable_texture(GLcontext *ctx, GLboolean state, GLbitfield texBit)
 229 {
 230    struct gl_texture_unit *texUnit = _mesa_get_current_tex_unit(ctx);
 231    const GLbitfield newenabled = state
 232       ? (texUnit->Enabled | texBit) : (texUnit->Enabled & ~texBit);
 233
 234    if (texUnit->Enabled == newenabled)
 235        return GL_FALSE;
 236
 237    FLUSH_VERTICES(ctx, _NEW_TEXTURE);
 238    texUnit->Enabled = newenabled;
 239    return GL_TRUE;
 240 }
 241
 242
 243 /**
 244  * Helper function to enable or disable state.
 245  *
 246  * \param ctx GL context.
 247  * \param cap  the state to enable/disable
 248  * \param state whether to enable or disable the specified capability.
 249  *
 250  * Updates the current context and flushes the vertices as needed. For
 251  * capabilities associated with extensions it verifies that those extensions
 252  * are effectivly present before updating. Notifies the driver via
 253  * dd_function_table::Enable.
 254  */
 255 void
 256 _mesa_set_enable(GLcontext *ctx, GLenum cap, GLboolean state)
 257 {
 258    if (MESA_VERBOSE & VERBOSE_API)
 259       _mesa_debug(ctx, "%s %s (newstate is %x)\n",
 260                   state ? "glEnable" : "glDisable",
 261                   _mesa_lookup_enum_by_nr(cap),
 262                   ctx->NewState);
 263
 264    switch (cap) {
 265       case GL_ALPHA_TEST:
 266          if (ctx->Color.AlphaEnabled == state)
 267             return;
 268          FLUSH_VERTICES(ctx, _NEW_COLOR);
 269          ctx->Color.AlphaEnabled = state;
 270          break;
 271       case GL_AUTO_NORMAL:
 272          if (ctx->Eval.AutoNormal == state)
 273             return;
 274          FLUSH_VERTICES(ctx, _NEW_EVAL);
 275          ctx->Eval.AutoNormal = state;
 276          break;
 277       case GL_BLEND:
 278          {
 279             GLbitfield newEnabled = state * ((1 << ctx->Const.MaxDrawBuffers) - 1);
 280             if (newEnabled != ctx->Color.BlendEnabled) {
 281                FLUSH_VERTICES(ctx, _NEW_COLOR);
 282                ctx->Color.BlendEnabled = newEnabled;
 283             }
 284          }
 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 #if FEATURE_ES1
 686       case GL_TEXTURE_GEN_STR_OES:
 687          /* disable S, T, and R at the same time */
 688          {
 689             struct gl_texture_unit *texUnit = get_texcoord_unit(ctx);
 690             if (texUnit) {
 691                GLuint newenabled =
 692                   texUnit->TexGenEnabled & ~STR_BITS;
 693                if (state)
 694                   newenabled |= STR_BITS;
 695                if (texUnit->TexGenEnabled == newenabled)
 696                   return;
 697                FLUSH_VERTICES(ctx, _NEW_TEXTURE);
 698                texUnit->TexGenEnabled = newenabled;
 699             }
 700          }
 701          break;
 702 #endif
 703
 704       /*
 705        * CLIENT STATE!!!
 706        */
 707       case GL_VERTEX_ARRAY:
 708       case GL_NORMAL_ARRAY:
 709       case GL_COLOR_ARRAY:
 710       case GL_INDEX_ARRAY:
 711       case GL_TEXTURE_COORD_ARRAY:
 712       case GL_EDGE_FLAG_ARRAY:
 713       case GL_FOG_COORDINATE_ARRAY_EXT:
 714       case GL_SECONDARY_COLOR_ARRAY_EXT:
 715       case GL_POINT_SIZE_ARRAY_OES:
 716          client_state( ctx, cap, state );
 717          return;
 718
 719       /* GL_SGI_color_table */
 720       case GL_COLOR_TABLE_SGI:
 721          CHECK_EXTENSION(SGI_color_table, cap);
 722          if (ctx->Pixel.ColorTableEnabled[COLORTABLE_PRECONVOLUTION] == state)
 723             return;
 724          FLUSH_VERTICES(ctx, _NEW_PIXEL);
 725          ctx->Pixel.ColorTableEnabled[COLORTABLE_PRECONVOLUTION] = state;
 726          break;
 727       case GL_POST_CONVOLUTION_COLOR_TABLE_SGI:
 728          CHECK_EXTENSION(SGI_color_table, cap);
 729          if (ctx->Pixel.ColorTableEnabled[COLORTABLE_POSTCONVOLUTION] == state)
 730             return;
 731          FLUSH_VERTICES(ctx, _NEW_PIXEL);
 732          ctx->Pixel.ColorTableEnabled[COLORTABLE_POSTCONVOLUTION] = state;
 733          break;
 734       case GL_POST_COLOR_MATRIX_COLOR_TABLE_SGI:
 735          CHECK_EXTENSION(SGI_color_table, cap);
 736          if (ctx->Pixel.ColorTableEnabled[COLORTABLE_POSTCOLORMATRIX] == state)
 737             return;
 738          FLUSH_VERTICES(ctx, _NEW_PIXEL);
 739          ctx->Pixel.ColorTableEnabled[COLORTABLE_POSTCOLORMATRIX] = state;
 740          break;
 741       case GL_TEXTURE_COLOR_TABLE_SGI:
 742          CHECK_EXTENSION(SGI_texture_color_table, cap);
 743          if (ctx->Texture.Unit[ctx->Texture.CurrentUnit].ColorTableEnabled == state)
 744             return;
 745          FLUSH_VERTICES(ctx, _NEW_TEXTURE);
 746          ctx->Texture.Unit[ctx->Texture.CurrentUnit].ColorTableEnabled = state;
 747          break;
 748
 749       /* GL_EXT_convolution */
 750       case GL_CONVOLUTION_1D:
 751          CHECK_EXTENSION(EXT_convolution, cap);
 752          if (ctx->Pixel.Convolution1DEnabled == state)
 753             return;
 754          FLUSH_VERTICES(ctx, _NEW_PIXEL);
 755          ctx->Pixel.Convolution1DEnabled = state;
 756          break;
 757       case GL_CONVOLUTION_2D:
 758          CHECK_EXTENSION(EXT_convolution, cap);
 759          if (ctx->Pixel.Convolution2DEnabled == state)
 760             return;
 761          FLUSH_VERTICES(ctx, _NEW_PIXEL);
 762          ctx->Pixel.Convolution2DEnabled = state;
 763          break;
 764       case GL_SEPARABLE_2D:
 765          CHECK_EXTENSION(EXT_convolution, cap);
 766          if (ctx->Pixel.Separable2DEnabled == state)
 767             return;
 768          FLUSH_VERTICES(ctx, _NEW_PIXEL);
 769          ctx->Pixel.Separable2DEnabled = state;
 770          break;
 771
 772       /* GL_ARB_texture_cube_map */
 773       case GL_TEXTURE_CUBE_MAP_ARB:
 774          CHECK_EXTENSION(ARB_texture_cube_map, cap);
 775          if (!enable_texture(ctx, state, TEXTURE_CUBE_BIT)) {
 776             return;
 777          }
 778          break;
 779
 780       /* GL_EXT_secondary_color */
 781       case GL_COLOR_SUM_EXT:
 782          CHECK_EXTENSION2(EXT_secondary_color, ARB_vertex_program, cap);
 783          if (ctx->Fog.ColorSumEnabled == state)
 784             return;
 785          FLUSH_VERTICES(ctx, _NEW_FOG);
 786          ctx->Fog.ColorSumEnabled = state;
 787          break;
 788
 789       /* GL_ARB_multisample */
 790       case GL_MULTISAMPLE_ARB:
 791          if (ctx->Multisample.Enabled == state)
 792             return;
 793          FLUSH_VERTICES(ctx, _NEW_MULTISAMPLE);
 794          ctx->Multisample.Enabled = state;
 795          break;
 796       case GL_SAMPLE_ALPHA_TO_COVERAGE_ARB:
 797          if (ctx->Multisample.SampleAlphaToCoverage == state)
 798             return;
 799          FLUSH_VERTICES(ctx, _NEW_MULTISAMPLE);
 800          ctx->Multisample.SampleAlphaToCoverage = state;
 801          break;
 802       case GL_SAMPLE_ALPHA_TO_ONE_ARB:
 803          if (ctx->Multisample.SampleAlphaToOne == state)
 804             return;
 805          FLUSH_VERTICES(ctx, _NEW_MULTISAMPLE);
 806          ctx->Multisample.SampleAlphaToOne = state;
 807          break;
 808       case GL_SAMPLE_COVERAGE_ARB:
 809          if (ctx->Multisample.SampleCoverage == state)
 810             return;
 811          FLUSH_VERTICES(ctx, _NEW_MULTISAMPLE);
 812          ctx->Multisample.SampleCoverage = state;
 813          break;
 814       case GL_SAMPLE_COVERAGE_INVERT_ARB:
 815          if (ctx->Multisample.SampleCoverageInvert == state)
 816             return;
 817          FLUSH_VERTICES(ctx, _NEW_MULTISAMPLE);
 818          ctx->Multisample.SampleCoverageInvert = state;
 819          break;
 820
 821       /* GL_IBM_rasterpos_clip */
 822       case GL_RASTER_POSITION_UNCLIPPED_IBM:
 823          CHECK_EXTENSION(IBM_rasterpos_clip, cap);
 824          if (ctx->Transform.RasterPositionUnclipped == state)
 825             return;
 826          FLUSH_VERTICES(ctx, _NEW_TRANSFORM);
 827          ctx->Transform.RasterPositionUnclipped = state;
 828          break;
 829
 830       /* GL_NV_point_sprite */
 831       case GL_POINT_SPRITE_NV:
 832          CHECK_EXTENSION2(NV_point_sprite, ARB_point_sprite, cap);
 833          if (ctx->Point.PointSprite == state)
 834             return;
 835          FLUSH_VERTICES(ctx, _NEW_POINT);
 836          ctx->Point.PointSprite = state;
 837          break;
 838
 839 #if FEATURE_NV_vertex_program || FEATURE_ARB_vertex_program
 840       case GL_VERTEX_PROGRAM_ARB:
 841          CHECK_EXTENSION2(ARB_vertex_program, NV_vertex_program, cap);
 842          if (ctx->VertexProgram.Enabled == state)
 843             return;
 844          FLUSH_VERTICES(ctx, _NEW_PROGRAM);
 845          ctx->VertexProgram.Enabled = state;
 846          break;
 847       case GL_VERTEX_PROGRAM_POINT_SIZE_ARB:
 848          CHECK_EXTENSION2(ARB_vertex_program, NV_vertex_program, cap);
 849          if (ctx->VertexProgram.PointSizeEnabled == state)
 850             return;
 851          FLUSH_VERTICES(ctx, _NEW_PROGRAM);
 852          ctx->VertexProgram.PointSizeEnabled = state;
 853          break;
 854       case GL_VERTEX_PROGRAM_TWO_SIDE_ARB:
 855          CHECK_EXTENSION2(ARB_vertex_program, NV_vertex_program, cap);
 856          if (ctx->VertexProgram.TwoSideEnabled == state)
 857             return;
 858          FLUSH_VERTICES(ctx, _NEW_PROGRAM);
 859          ctx->VertexProgram.TwoSideEnabled = state;
 860          break;
 861 #endif
 862 #if FEATURE_NV_vertex_program
 863       case GL_MAP1_VERTEX_ATTRIB0_4_NV:
 864       case GL_MAP1_VERTEX_ATTRIB1_4_NV:
 865       case GL_MAP1_VERTEX_ATTRIB2_4_NV:
 866       case GL_MAP1_VERTEX_ATTRIB3_4_NV:
 867       case GL_MAP1_VERTEX_ATTRIB4_4_NV:
 868       case GL_MAP1_VERTEX_ATTRIB5_4_NV:
 869       case GL_MAP1_VERTEX_ATTRIB6_4_NV:
 870       case GL_MAP1_VERTEX_ATTRIB7_4_NV:
 871       case GL_MAP1_VERTEX_ATTRIB8_4_NV:
 872       case GL_MAP1_VERTEX_ATTRIB9_4_NV:
 873       case GL_MAP1_VERTEX_ATTRIB10_4_NV:
 874       case GL_MAP1_VERTEX_ATTRIB11_4_NV:
 875       case GL_MAP1_VERTEX_ATTRIB12_4_NV:
 876       case GL_MAP1_VERTEX_ATTRIB13_4_NV:
 877       case GL_MAP1_VERTEX_ATTRIB14_4_NV:
 878       case GL_MAP1_VERTEX_ATTRIB15_4_NV:
 879          CHECK_EXTENSION(NV_vertex_program, cap);
 880          {
 881             const GLuint map = (GLuint) (cap - GL_MAP1_VERTEX_ATTRIB0_4_NV);
 882             FLUSH_VERTICES(ctx, _NEW_EVAL);
 883             ctx->Eval.Map1Attrib[map] = state;
 884          }
 885          break;
 886       case GL_MAP2_VERTEX_ATTRIB0_4_NV:
 887       case GL_MAP2_VERTEX_ATTRIB1_4_NV:
 888       case GL_MAP2_VERTEX_ATTRIB2_4_NV:
 889       case GL_MAP2_VERTEX_ATTRIB3_4_NV:
 890       case GL_MAP2_VERTEX_ATTRIB4_4_NV:
 891       case GL_MAP2_VERTEX_ATTRIB5_4_NV:
 892       case GL_MAP2_VERTEX_ATTRIB6_4_NV:
 893       case GL_MAP2_VERTEX_ATTRIB7_4_NV:
 894       case GL_MAP2_VERTEX_ATTRIB8_4_NV:
 895       case GL_MAP2_VERTEX_ATTRIB9_4_NV:
 896       case GL_MAP2_VERTEX_ATTRIB10_4_NV:
 897       case GL_MAP2_VERTEX_ATTRIB11_4_NV:
 898       case GL_MAP2_VERTEX_ATTRIB12_4_NV:
 899       case GL_MAP2_VERTEX_ATTRIB13_4_NV:
 900       case GL_MAP2_VERTEX_ATTRIB14_4_NV:
 901       case GL_MAP2_VERTEX_ATTRIB15_4_NV:
 902          CHECK_EXTENSION(NV_vertex_program, cap);
 903          {
 904             const GLuint map = (GLuint) (cap - GL_MAP2_VERTEX_ATTRIB0_4_NV);
 905             FLUSH_VERTICES(ctx, _NEW_EVAL);
 906             ctx->Eval.Map2Attrib[map] = state;
 907          }
 908          break;
 909 #endif /* FEATURE_NV_vertex_program */
 910
 911 #if FEATURE_NV_fragment_program
 912       case GL_FRAGMENT_PROGRAM_NV:
 913          CHECK_EXTENSION(NV_fragment_program, cap);
 914          if (ctx->FragmentProgram.Enabled == state)
 915             return;
 916          FLUSH_VERTICES(ctx, _NEW_PROGRAM);
 917          ctx->FragmentProgram.Enabled = state;
 918          break;
 919 #endif /* FEATURE_NV_fragment_program */
 920
 921       /* GL_NV_texture_rectangle */
 922       case GL_TEXTURE_RECTANGLE_NV:
 923          CHECK_EXTENSION(NV_texture_rectangle, cap);
 924          if (!enable_texture(ctx, state, TEXTURE_RECT_BIT)) {
 925             return;
 926          }
 927          break;
 928
 929       /* GL_EXT_stencil_two_side */
 930       case GL_STENCIL_TEST_TWO_SIDE_EXT:
 931          CHECK_EXTENSION(EXT_stencil_two_side, cap);
 932          if (ctx->Stencil.TestTwoSide == state)
 933             return;
 934          FLUSH_VERTICES(ctx, _NEW_STENCIL);
 935          ctx->Stencil.TestTwoSide = state;
 936          if (state) {
 937             ctx->Stencil._BackFace = 2;
 938             ctx->_TriangleCaps |= DD_TRI_TWOSTENCIL;
 939          } else {
 940             ctx->Stencil._BackFace = 1;
 941             ctx->_TriangleCaps &= ~DD_TRI_TWOSTENCIL;
 942          }
 943          break;
 944
 945 #if FEATURE_ARB_fragment_program
 946       case GL_FRAGMENT_PROGRAM_ARB:
 947          CHECK_EXTENSION(ARB_fragment_program, cap);
 948          if (ctx->FragmentProgram.Enabled == state)
 949             return;
 950          FLUSH_VERTICES(ctx, _NEW_PROGRAM);
 951          ctx->FragmentProgram.Enabled = state;
 952          break;
 953 #endif /* FEATURE_ARB_fragment_program */
 954
 955       /* GL_EXT_depth_bounds_test */
 956       case GL_DEPTH_BOUNDS_TEST_EXT:
 957          CHECK_EXTENSION(EXT_depth_bounds_test, cap);
 958          if (ctx->Depth.BoundsTest == state)
 959             return;
 960          FLUSH_VERTICES(ctx, _NEW_DEPTH);
 961          ctx->Depth.BoundsTest = state;
 962          break;
 963
 964       case GL_DEPTH_CLAMP:
 965          if (ctx->Transform.DepthClamp == state)
 966             return;
 967          CHECK_EXTENSION(ARB_depth_clamp, cap);
 968          FLUSH_VERTICES(ctx, _NEW_TRANSFORM);
 969          ctx->Transform.DepthClamp = state;
 970          break;
 971
 972 #if FEATURE_ATI_fragment_shader
 973       case GL_FRAGMENT_SHADER_ATI:
 974         CHECK_EXTENSION(ATI_fragment_shader, cap);
 975         if (ctx->ATIFragmentShader.Enabled == state)
 976           return;
 977         FLUSH_VERTICES(ctx, _NEW_PROGRAM);
 978         ctx->ATIFragmentShader.Enabled = state;
 979         break;
 980 #endif
 981
 982       /* GL_MESA_texture_array */
 983       case GL_TEXTURE_1D_ARRAY_EXT:
 984          CHECK_EXTENSION(MESA_texture_array, cap);
 985          if (!enable_texture(ctx, state, TEXTURE_1D_ARRAY_BIT)) {
 986             return;
 987          }
 988          break;
 989
 990       case GL_TEXTURE_2D_ARRAY_EXT:
 991          CHECK_EXTENSION(MESA_texture_array, cap);
 992          if (!enable_texture(ctx, state, TEXTURE_2D_ARRAY_BIT)) {
 993             return;
 994          }
 995          break;
 996
 997       case GL_TEXTURE_CUBE_MAP_SEAMLESS:
 998          CHECK_EXTENSION(ARB_seamless_cube_map, cap);
 999          ctx->Texture.CubeMapSeamless = state;
1000          break;
1001
1002 #if FEATURE_EXT_transform_feedback
1003       case GL_RASTERIZER_DISCARD:
1004          CHECK_EXTENSION(EXT_transform_feedback, cap);
1005          if (ctx->TransformFeedback.RasterDiscard != state) {
1006             ctx->TransformFeedback.RasterDiscard = state;
1007             FLUSH_VERTICES(ctx, _NEW_TRANSFORM);
1008          }
1009          break;
1010 #endif
1011
1012       /* GL 3.1 primitive restart */
1013       case GL_PRIMITIVE_RESTART:
1014          if (ctx->VersionMajor * 10 + ctx->VersionMinor < 31) {
1015             goto invalid_enum_error;
1016          }
1017          if (ctx->Array.PrimitiveRestart != state) {
1018             FLUSH_VERTICES(ctx, _NEW_TRANSFORM);
1019             ctx->Array.PrimitiveRestart = state;
1020          }
1021          break;
1022
1023       default:
1024          goto invalid_enum_error;
1025    }
1026
1027    if (ctx->Driver.Enable) {
1028       ctx->Driver.Enable( ctx, cap, state );
1029    }
1030
1031    return;
1032
1033 invalid_enum_error:
1034    _mesa_error(ctx, GL_INVALID_ENUM, "gl%s(0x%x)",
1035                state ? "Enable" : "Disable", cap);
1036 }
1037
1038
1039 /**
1040  * Enable GL capability.  Called by glEnable()
1041  * \param cap  state to enable.
1042  */
1043 void GLAPIENTRY
1044 _mesa_Enable( GLenum cap )
1045 {
1046    GET_CURRENT_CONTEXT(ctx);
1047    ASSERT_OUTSIDE_BEGIN_END(ctx);
1048
1049    _mesa_set_enable( ctx, cap, GL_TRUE );
1050 }
1051
1052
1053 /**
1054  * Disable GL capability.  Called by glDisable()
1055  * \param cap  state to disable.
1056  */
1057 void GLAPIENTRY
1058 _mesa_Disable( GLenum cap )
1059 {
1060    GET_CURRENT_CONTEXT(ctx);
1061    ASSERT_OUTSIDE_BEGIN_END(ctx);
1062
1063    _mesa_set_enable( ctx, cap, GL_FALSE );
1064 }
1065
1066
1067
1068 /**
1069  * Enable/disable an indexed state var.
1070  */
1071 void
1072 _mesa_set_enablei(GLcontext *ctx, GLenum cap, GLuint index, GLboolean state)
1073 {
1074    ASSERT(state == 0 || state == 1);
1075    switch (cap) {
1076    case GL_BLEND:
1077       if (!ctx->Extensions.EXT_draw_buffers2) {
1078          goto invalid_enum_error;
1079       }
1080       if (index >= ctx->Const.MaxDrawBuffers) {
1081          _mesa_error(ctx, GL_INVALID_VALUE, "%s(index=%u)",
1082                      state ? "glEnableIndexed" : "glDisableIndexed", index);
1083          return;
1084       }
1085       if (((ctx->Color.BlendEnabled >> index) & 1) != state) {
1086          FLUSH_VERTICES(ctx, _NEW_COLOR);
1087          if (state)
1088             ctx->Color.BlendEnabled |= (1 << index);
1089          else
1090             ctx->Color.BlendEnabled &= ~(1 << index);
1091       }
1092       break;
1093    default:
1094       goto invalid_enum_error;
1095    }
1096    return;
1097
1098 invalid_enum_error:
1099     _mesa_error(ctx, GL_INVALID_ENUM, "%s(cap=%s)",
1100                 state ? "glEnablei" : "glDisablei",
1101                 _mesa_lookup_enum_by_nr(cap));
1102 }
1103
1104
1105 void GLAPIENTRY
1106 _mesa_DisableIndexed( GLenum cap, GLuint index )
1107 {
1108    GET_CURRENT_CONTEXT(ctx);
1109    ASSERT_OUTSIDE_BEGIN_END(ctx);
1110    _mesa_set_enablei(ctx, cap, index, GL_FALSE);
1111 }
1112
1113
1114 void GLAPIENTRY
1115 _mesa_EnableIndexed( GLenum cap, GLuint index )
1116 {
1117    GET_CURRENT_CONTEXT(ctx);
1118    ASSERT_OUTSIDE_BEGIN_END(ctx);
1119    _mesa_set_enablei(ctx, cap, index, GL_TRUE);
1120 }
1121
1122
1123 GLboolean GLAPIENTRY
1124 _mesa_IsEnabledIndexed( GLenum cap, GLuint index )
1125 {
1126    GET_CURRENT_CONTEXT(ctx);
1127    switch (cap) {
1128    case GL_BLEND:
1129       if (index >= ctx->Const.MaxDrawBuffers) {
1130          _mesa_error(ctx, GL_INVALID_VALUE, "glIsEnabledIndexed(index=%u)",
1131                      index);
1132          return GL_FALSE;
1133       }
1134       return (ctx->Color.BlendEnabled >> index) & 1;
1135    default:
1136       _mesa_error(ctx, GL_INVALID_ENUM, "glIsEnabledIndexed(cap=%s)",
1137                   _mesa_lookup_enum_by_nr(cap));
1138       return GL_FALSE;
1139    }
1140 }
1141
1142
1143
1144
1145 #undef CHECK_EXTENSION
1146 #define CHECK_EXTENSION(EXTNAME)                        \
1147    if (!ctx->Extensions.EXTNAME) {                      \
1148       goto invalid_enum_error;                          \
1149    }
1150
1151 #undef CHECK_EXTENSION2
1152 #define CHECK_EXTENSION2(EXT1, EXT2)                            \
1153    if (!ctx->Extensions.EXT1 && !ctx->Extensions.EXT2) {        \
1154       goto invalid_enum_error;                                  \
1155    }
1156
1157
1158 /**
1159  * Helper function to determine whether a texture target is enabled.
1160  */
1161 static GLboolean
1162 is_texture_enabled(GLcontext *ctx, GLbitfield bit)
1163 {
1164    const struct gl_texture_unit *const texUnit =
1165        &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
1166    return (texUnit->Enabled & bit) ? GL_TRUE : GL_FALSE;
1167 }
1168
1169
1170 /**
1171  * Return simple enable/disable state.
1172  *
1173  * \param cap  state variable to query.
1174  *
1175  * Returns the state of the specified capability from the current GL context.
1176  * For the capabilities associated with extensions verifies that those
1177  * extensions are effectively present before reporting.
1178  */
1179 GLboolean GLAPIENTRY
1180 _mesa_IsEnabled( GLenum cap )
1181 {
1182    GET_CURRENT_CONTEXT(ctx);
1183    switch (cap) {
1184       case GL_ALPHA_TEST:
1185          return ctx->Color.AlphaEnabled;
1186       case GL_AUTO_NORMAL:
1187          return ctx->Eval.AutoNormal;
1188       case GL_BLEND:
1189          return ctx->Color.BlendEnabled & 1;  /* return state for buffer[0] */
1190       case GL_CLIP_PLANE0:
1191       case GL_CLIP_PLANE1:
1192       case GL_CLIP_PLANE2:
1193       case GL_CLIP_PLANE3:
1194       case GL_CLIP_PLANE4:
1195       case GL_CLIP_PLANE5:
1196          return (ctx->Transform.ClipPlanesEnabled >> (cap - GL_CLIP_PLANE0)) & 1;
1197       case GL_COLOR_MATERIAL:
1198          return ctx->Light.ColorMaterialEnabled;
1199       case GL_CULL_FACE:
1200          return ctx->Polygon.CullFlag;
1201       case GL_DEPTH_TEST:
1202          return ctx->Depth.Test;
1203       case GL_DITHER:
1204          return ctx->Color.DitherFlag;
1205       case GL_FOG:
1206          return ctx->Fog.Enabled;
1207       case GL_LIGHTING:
1208          return ctx->Light.Enabled;
1209       case GL_LIGHT0:
1210       case GL_LIGHT1:
1211       case GL_LIGHT2:
1212       case GL_LIGHT3:
1213       case GL_LIGHT4:
1214       case GL_LIGHT5:
1215       case GL_LIGHT6:
1216       case GL_LIGHT7:
1217          return ctx->Light.Light[cap-GL_LIGHT0].Enabled;
1218       case GL_LINE_SMOOTH:
1219          return ctx->Line.SmoothFlag;
1220       case GL_LINE_STIPPLE:
1221          return ctx->Line.StippleFlag;
1222       case GL_INDEX_LOGIC_OP:
1223          return ctx->Color.IndexLogicOpEnabled;
1224       case GL_COLOR_LOGIC_OP:
1225          return ctx->Color.ColorLogicOpEnabled;
1226       case GL_MAP1_COLOR_4:
1227          return ctx->Eval.Map1Color4;
1228       case GL_MAP1_INDEX:
1229          return ctx->Eval.Map1Index;
1230       case GL_MAP1_NORMAL:
1231          return ctx->Eval.Map1Normal;
1232       case GL_MAP1_TEXTURE_COORD_1:
1233          return ctx->Eval.Map1TextureCoord1;
1234       case GL_MAP1_TEXTURE_COORD_2:
1235          return ctx->Eval.Map1TextureCoord2;
1236       case GL_MAP1_TEXTURE_COORD_3:
1237          return ctx->Eval.Map1TextureCoord3;
1238       case GL_MAP1_TEXTURE_COORD_4:
1239          return ctx->Eval.Map1TextureCoord4;
1240       case GL_MAP1_VERTEX_3:
1241          return ctx->Eval.Map1Vertex3;
1242       case GL_MAP1_VERTEX_4:
1243          return ctx->Eval.Map1Vertex4;
1244       case GL_MAP2_COLOR_4:
1245          return ctx->Eval.Map2Color4;
1246       case GL_MAP2_INDEX:
1247          return ctx->Eval.Map2Index;
1248       case GL_MAP2_NORMAL:
1249          return ctx->Eval.Map2Normal;
1250       case GL_MAP2_TEXTURE_COORD_1:
1251          return ctx->Eval.Map2TextureCoord1;
1252       case GL_MAP2_TEXTURE_COORD_2:
1253          return ctx->Eval.Map2TextureCoord2;
1254       case GL_MAP2_TEXTURE_COORD_3:
1255          return ctx->Eval.Map2TextureCoord3;
1256       case GL_MAP2_TEXTURE_COORD_4:
1257          return ctx->Eval.Map2TextureCoord4;
1258       case GL_MAP2_VERTEX_3:
1259          return ctx->Eval.Map2Vertex3;
1260       case GL_MAP2_VERTEX_4:
1261          return ctx->Eval.Map2Vertex4;
1262       case GL_NORMALIZE:
1263          return ctx->Transform.Normalize;
1264       case GL_POINT_SMOOTH:
1265          return ctx->Point.SmoothFlag;
1266       case GL_POLYGON_SMOOTH:
1267          return ctx->Polygon.SmoothFlag;
1268       case GL_POLYGON_STIPPLE:
1269          return ctx->Polygon.StippleFlag;
1270       case GL_POLYGON_OFFSET_POINT:
1271          return ctx->Polygon.OffsetPoint;
1272       case GL_POLYGON_OFFSET_LINE:
1273          return ctx->Polygon.OffsetLine;
1274       case GL_POLYGON_OFFSET_FILL:
1275       /*case GL_POLYGON_OFFSET_EXT:*/
1276          return ctx->Polygon.OffsetFill;
1277       case GL_RESCALE_NORMAL_EXT:
1278          return ctx->Transform.RescaleNormals;
1279       case GL_SCISSOR_TEST:
1280          return ctx->Scissor.Enabled;
1281       case GL_SHARED_TEXTURE_PALETTE_EXT:
1282          return ctx->Texture.SharedPalette;
1283       case GL_STENCIL_TEST:
1284          return ctx->Stencil.Enabled;
1285       case GL_TEXTURE_1D:
1286          return is_texture_enabled(ctx, TEXTURE_1D_BIT);
1287       case GL_TEXTURE_2D:
1288          return is_texture_enabled(ctx, TEXTURE_2D_BIT);
1289       case GL_TEXTURE_3D:
1290          return is_texture_enabled(ctx, TEXTURE_3D_BIT);
1291       case GL_TEXTURE_GEN_Q:
1292          {
1293             const struct gl_texture_unit *texUnit = get_texcoord_unit(ctx);
1294             if (texUnit) {
1295                return (texUnit->TexGenEnabled & Q_BIT) ? GL_TRUE : GL_FALSE;
1296             }
1297          }
1298          return GL_FALSE;
1299       case GL_TEXTURE_GEN_R:
1300          {
1301             const struct gl_texture_unit *texUnit = get_texcoord_unit(ctx);
1302             if (texUnit) {
1303                return (texUnit->TexGenEnabled & R_BIT) ? GL_TRUE : GL_FALSE;
1304             }
1305          }
1306          return GL_FALSE;
1307       case GL_TEXTURE_GEN_S:
1308          {
1309             const struct gl_texture_unit *texUnit = get_texcoord_unit(ctx);
1310             if (texUnit) {
1311                return (texUnit->TexGenEnabled & S_BIT) ? GL_TRUE : GL_FALSE;
1312             }
1313          }
1314          return GL_FALSE;
1315       case GL_TEXTURE_GEN_T:
1316          {
1317             const struct gl_texture_unit *texUnit = get_texcoord_unit(ctx);
1318             if (texUnit) {
1319                return (texUnit->TexGenEnabled & T_BIT) ? GL_TRUE : GL_FALSE;
1320             }
1321          }
1322          return GL_FALSE;
1323 #if FEATURE_ES1
1324       case GL_TEXTURE_GEN_STR_OES:
1325          {
1326             const struct gl_texture_unit *texUnit = get_texcoord_unit(ctx);
1327             if (texUnit) {
1328                     return (texUnit->TexGenEnabled & STR_BITS) == STR_BITS ? GL_TRUE : GL_FALSE;
1329             }
1330          }
1331 #endif
1332
1333       /*
1334        * CLIENT STATE!!!
1335        */
1336       case GL_VERTEX_ARRAY:
1337          return (ctx->Array.ArrayObj->Vertex.Enabled != 0);
1338       case GL_NORMAL_ARRAY:
1339          return (ctx->Array.ArrayObj->Normal.Enabled != 0);
1340       case GL_COLOR_ARRAY:
1341          return (ctx->Array.ArrayObj->Color.Enabled != 0);
1342       case GL_INDEX_ARRAY:
1343          return (ctx->Array.ArrayObj->Index.Enabled != 0);
1344       case GL_TEXTURE_COORD_ARRAY:
1345          return (ctx->Array.ArrayObj->TexCoord[ctx->Array.ActiveTexture].Enabled != 0);
1346       case GL_EDGE_FLAG_ARRAY:
1347          return (ctx->Array.ArrayObj->EdgeFlag.Enabled != 0);
1348       case GL_FOG_COORDINATE_ARRAY_EXT:
1349          CHECK_EXTENSION(EXT_fog_coord);
1350          return (ctx->Array.ArrayObj->FogCoord.Enabled != 0);
1351       case GL_SECONDARY_COLOR_ARRAY_EXT:
1352          CHECK_EXTENSION(EXT_secondary_color);
1353          return (ctx->Array.ArrayObj->SecondaryColor.Enabled != 0);
1354 #if FEATURE_point_size_array
1355       case GL_POINT_SIZE_ARRAY_OES:
1356          return (ctx->Array.ArrayObj->PointSize.Enabled != 0);
1357 #endif
1358
1359       /* GL_EXT_histogram */
1360       case GL_HISTOGRAM:
1361          CHECK_EXTENSION(EXT_histogram);
1362          return ctx->Pixel.HistogramEnabled;
1363       case GL_MINMAX:
1364          CHECK_EXTENSION(EXT_histogram);
1365          return ctx->Pixel.MinMaxEnabled;
1366
1367       /* GL_SGI_color_table */
1368       case GL_COLOR_TABLE_SGI:
1369          CHECK_EXTENSION(SGI_color_table);
1370          return ctx->Pixel.ColorTableEnabled[COLORTABLE_PRECONVOLUTION];
1371       case GL_POST_CONVOLUTION_COLOR_TABLE_SGI:
1372          CHECK_EXTENSION(SGI_color_table);
1373          return ctx->Pixel.ColorTableEnabled[COLORTABLE_POSTCONVOLUTION];
1374       case GL_POST_COLOR_MATRIX_COLOR_TABLE_SGI:
1375          CHECK_EXTENSION(SGI_color_table);
1376          return ctx->Pixel.ColorTableEnabled[COLORTABLE_POSTCOLORMATRIX];
1377
1378       /* GL_SGI_texture_color_table */
1379       case GL_TEXTURE_COLOR_TABLE_SGI:
1380          CHECK_EXTENSION(SGI_texture_color_table);
1381          return ctx->Texture.Unit[ctx->Texture.CurrentUnit].ColorTableEnabled;
1382
1383       /* GL_EXT_convolution */
1384       case GL_CONVOLUTION_1D:
1385          CHECK_EXTENSION(EXT_convolution);
1386          return ctx->Pixel.Convolution1DEnabled;
1387       case GL_CONVOLUTION_2D:
1388          CHECK_EXTENSION(EXT_convolution);
1389          return ctx->Pixel.Convolution2DEnabled;
1390       case GL_SEPARABLE_2D:
1391          CHECK_EXTENSION(EXT_convolution);
1392          return ctx->Pixel.Separable2DEnabled;
1393
1394       /* GL_ARB_texture_cube_map */
1395       case GL_TEXTURE_CUBE_MAP_ARB:
1396          CHECK_EXTENSION(ARB_texture_cube_map);
1397          return is_texture_enabled(ctx, TEXTURE_CUBE_BIT);
1398
1399       /* GL_EXT_secondary_color */
1400       case GL_COLOR_SUM_EXT:
1401          CHECK_EXTENSION2(EXT_secondary_color, ARB_vertex_program);
1402          return ctx->Fog.ColorSumEnabled;
1403
1404       /* GL_ARB_multisample */
1405       case GL_MULTISAMPLE_ARB:
1406          return ctx->Multisample.Enabled;
1407       case GL_SAMPLE_ALPHA_TO_COVERAGE_ARB:
1408          return ctx->Multisample.SampleAlphaToCoverage;
1409       case GL_SAMPLE_ALPHA_TO_ONE_ARB:
1410          return ctx->Multisample.SampleAlphaToOne;
1411       case GL_SAMPLE_COVERAGE_ARB:
1412          return ctx->Multisample.SampleCoverage;
1413       case GL_SAMPLE_COVERAGE_INVERT_ARB:
1414          return ctx->Multisample.SampleCoverageInvert;
1415
1416       /* GL_IBM_rasterpos_clip */
1417       case GL_RASTER_POSITION_UNCLIPPED_IBM:
1418          CHECK_EXTENSION(IBM_rasterpos_clip);
1419          return ctx->Transform.RasterPositionUnclipped;
1420
1421       /* GL_NV_point_sprite */
1422       case GL_POINT_SPRITE_NV:
1423          CHECK_EXTENSION2(NV_point_sprite, ARB_point_sprite)
1424          return ctx->Point.PointSprite;
1425
1426 #if FEATURE_NV_vertex_program || FEATURE_ARB_vertex_program
1427       case GL_VERTEX_PROGRAM_ARB:
1428          CHECK_EXTENSION2(ARB_vertex_program, NV_vertex_program);
1429          return ctx->VertexProgram.Enabled;
1430       case GL_VERTEX_PROGRAM_POINT_SIZE_ARB:
1431          CHECK_EXTENSION2(ARB_vertex_program, NV_vertex_program);
1432          return ctx->VertexProgram.PointSizeEnabled;
1433       case GL_VERTEX_PROGRAM_TWO_SIDE_ARB:
1434          CHECK_EXTENSION2(ARB_vertex_program, NV_vertex_program);
1435          return ctx->VertexProgram.TwoSideEnabled;
1436 #endif
1437 #if FEATURE_NV_vertex_program
1438       case GL_VERTEX_ATTRIB_ARRAY0_NV:
1439       case GL_VERTEX_ATTRIB_ARRAY1_NV:
1440       case GL_VERTEX_ATTRIB_ARRAY2_NV:
1441       case GL_VERTEX_ATTRIB_ARRAY3_NV:
1442       case GL_VERTEX_ATTRIB_ARRAY4_NV:
1443       case GL_VERTEX_ATTRIB_ARRAY5_NV:
1444       case GL_VERTEX_ATTRIB_ARRAY6_NV:
1445       case GL_VERTEX_ATTRIB_ARRAY7_NV:
1446       case GL_VERTEX_ATTRIB_ARRAY8_NV:
1447       case GL_VERTEX_ATTRIB_ARRAY9_NV:
1448       case GL_VERTEX_ATTRIB_ARRAY10_NV:
1449       case GL_VERTEX_ATTRIB_ARRAY11_NV:
1450       case GL_VERTEX_ATTRIB_ARRAY12_NV:
1451       case GL_VERTEX_ATTRIB_ARRAY13_NV:
1452       case GL_VERTEX_ATTRIB_ARRAY14_NV:
1453       case GL_VERTEX_ATTRIB_ARRAY15_NV:
1454          CHECK_EXTENSION(NV_vertex_program);
1455          {
1456             GLint n = (GLint) cap - GL_VERTEX_ATTRIB_ARRAY0_NV;
1457             ASSERT(n < Elements(ctx->Array.ArrayObj->VertexAttrib));
1458             return (ctx->Array.ArrayObj->VertexAttrib[n].Enabled != 0);
1459          }
1460       case GL_MAP1_VERTEX_ATTRIB0_4_NV:
1461       case GL_MAP1_VERTEX_ATTRIB1_4_NV:
1462       case GL_MAP1_VERTEX_ATTRIB2_4_NV:
1463       case GL_MAP1_VERTEX_ATTRIB3_4_NV:
1464       case GL_MAP1_VERTEX_ATTRIB4_4_NV:
1465       case GL_MAP1_VERTEX_ATTRIB5_4_NV:
1466       case GL_MAP1_VERTEX_ATTRIB6_4_NV:
1467       case GL_MAP1_VERTEX_ATTRIB7_4_NV:
1468       case GL_MAP1_VERTEX_ATTRIB8_4_NV:
1469       case GL_MAP1_VERTEX_ATTRIB9_4_NV:
1470       case GL_MAP1_VERTEX_ATTRIB10_4_NV:
1471       case GL_MAP1_VERTEX_ATTRIB11_4_NV:
1472       case GL_MAP1_VERTEX_ATTRIB12_4_NV:
1473       case GL_MAP1_VERTEX_ATTRIB13_4_NV:
1474       case GL_MAP1_VERTEX_ATTRIB14_4_NV:
1475       case GL_MAP1_VERTEX_ATTRIB15_4_NV:
1476          CHECK_EXTENSION(NV_vertex_program);
1477          {
1478             const GLuint map = (GLuint) (cap - GL_MAP1_VERTEX_ATTRIB0_4_NV);
1479             return ctx->Eval.Map1Attrib[map];
1480          }
1481       case GL_MAP2_VERTEX_ATTRIB0_4_NV:
1482       case GL_MAP2_VERTEX_ATTRIB1_4_NV:
1483       case GL_MAP2_VERTEX_ATTRIB2_4_NV:
1484       case GL_MAP2_VERTEX_ATTRIB3_4_NV:
1485       case GL_MAP2_VERTEX_ATTRIB4_4_NV:
1486       case GL_MAP2_VERTEX_ATTRIB5_4_NV:
1487       case GL_MAP2_VERTEX_ATTRIB6_4_NV:
1488       case GL_MAP2_VERTEX_ATTRIB7_4_NV:
1489       case GL_MAP2_VERTEX_ATTRIB8_4_NV:
1490       case GL_MAP2_VERTEX_ATTRIB9_4_NV:
1491       case GL_MAP2_VERTEX_ATTRIB10_4_NV:
1492       case GL_MAP2_VERTEX_ATTRIB11_4_NV:
1493       case GL_MAP2_VERTEX_ATTRIB12_4_NV:
1494       case GL_MAP2_VERTEX_ATTRIB13_4_NV:
1495       case GL_MAP2_VERTEX_ATTRIB14_4_NV:
1496       case GL_MAP2_VERTEX_ATTRIB15_4_NV:
1497          CHECK_EXTENSION(NV_vertex_program);
1498          {
1499             const GLuint map = (GLuint) (cap - GL_MAP2_VERTEX_ATTRIB0_4_NV);
1500             return ctx->Eval.Map2Attrib[map];
1501          }
1502 #endif /* FEATURE_NV_vertex_program */
1503
1504 #if FEATURE_NV_fragment_program
1505       case GL_FRAGMENT_PROGRAM_NV:
1506          CHECK_EXTENSION(NV_fragment_program);
1507          return ctx->FragmentProgram.Enabled;
1508 #endif /* FEATURE_NV_fragment_program */
1509
1510       /* GL_NV_texture_rectangle */
1511       case GL_TEXTURE_RECTANGLE_NV:
1512          CHECK_EXTENSION(NV_texture_rectangle);
1513          return is_texture_enabled(ctx, TEXTURE_RECT_BIT);
1514
1515       /* GL_EXT_stencil_two_side */
1516       case GL_STENCIL_TEST_TWO_SIDE_EXT:
1517          CHECK_EXTENSION(EXT_stencil_two_side);
1518          return ctx->Stencil.TestTwoSide;
1519
1520 #if FEATURE_ARB_fragment_program
1521       case GL_FRAGMENT_PROGRAM_ARB:
1522          return ctx->FragmentProgram.Enabled;
1523 #endif /* FEATURE_ARB_fragment_program */
1524
1525       /* GL_EXT_depth_bounds_test */
1526       case GL_DEPTH_BOUNDS_TEST_EXT:
1527          CHECK_EXTENSION(EXT_depth_bounds_test);
1528          return ctx->Depth.BoundsTest;
1529
1530       /* GL_ARB_depth_clamp */
1531       case GL_DEPTH_CLAMP:
1532          CHECK_EXTENSION(ARB_depth_clamp);
1533          return ctx->Transform.DepthClamp;
1534
1535 #if FEATURE_ATI_fragment_shader
1536       case GL_FRAGMENT_SHADER_ATI:
1537          CHECK_EXTENSION(ATI_fragment_shader);
1538          return ctx->ATIFragmentShader.Enabled;
1539 #endif /* FEATURE_ATI_fragment_shader */
1540
1541       case GL_TEXTURE_CUBE_MAP_SEAMLESS:
1542          CHECK_EXTENSION(ARB_seamless_cube_map);
1543          return ctx->Texture.CubeMapSeamless;
1544
1545 #if FEATURE_EXT_transform_feedback
1546       case GL_RASTERIZER_DISCARD:
1547          CHECK_EXTENSION(EXT_transform_feedback);
1548          return ctx->TransformFeedback.RasterDiscard;
1549 #endif
1550
1551       /* GL 3.1 primitive restart */
1552       case GL_PRIMITIVE_RESTART:
1553          if (ctx->VersionMajor * 10 + ctx->VersionMinor < 31) {
1554             goto invalid_enum_error;
1555          }
1556          return ctx->Array.PrimitiveRestart;
1557
1558       default:
1559          goto invalid_enum_error;
1560    }
1561
1562    return GL_FALSE;
1563
1564 invalid_enum_error:
1565    _mesa_error(ctx, GL_INVALID_ENUM, "glIsEnabled(0x%x)", (int) cap);
1566    return GL_FALSE;
1567 }