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