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