src/mesa/main/enable.c

   1 /* $Id: enable.c,v 1.52 2001/12/18 04:06:45 brianp Exp $ */
   2
   3 /*
   4  * Mesa 3-D graphics library
   5  * Version:  3.5
   6  *
   7  * Copyright (C) 1999-2001  Brian Paul   All Rights Reserved.
   8  *
   9  * Permission is hereby granted, free of charge, to any person obtaining a
  10  * copy of this software and associated documentation files (the "Software"),
  11  * to deal in the Software without restriction, including without limitation
  12  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  13  * and/or sell copies of the Software, and to permit persons to whom the
  14  * Software is furnished to do so, subject to the following conditions:
  15  *
  16  * The above copyright notice and this permission notice shall be included
  17  * in all copies or substantial portions of the Software.
  18  *
  19  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  20  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  21  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  22  * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
  23  * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
  24  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  25  */
  26
  27
  28 #ifdef PC_HEADER
  29 #include "all.h"
  30 #else
  31 #include "glheader.h"
  32 #include "context.h"
  33 #include "enable.h"
  34 #include "light.h"
  35 #include "macros.h"
  36 #include "mmath.h"
  37 #include "simple_list.h"
  38 #include "mtypes.h"
  39 #include "enums.h"
  40 #include "math/m_matrix.h"
  41 #include "math/m_xform.h"
  42 #endif
  43
  44
  45 #define CHECK_EXTENSION(EXTNAME)                                        \
  46    if (!ctx->Extensions.EXTNAME) {                                      \
  47       _mesa_error(ctx, GL_INVALID_ENUM,                                 \
  48          state ? "glEnableClientState": "glDisableClientState");        \
  49       return;                                                           \
  50    }
  51
  52
  53
  54 static void
  55 client_state( GLcontext *ctx, GLenum cap, GLboolean state )
  56 {
  57    GLuint flag;
  58    GLboolean *var;
  59
  60    switch (cap) {
  61       case GL_VERTEX_ARRAY:
  62          var = &ctx->Array.Vertex.Enabled;
  63          flag = _NEW_ARRAY_VERTEX;
  64          break;
  65       case GL_NORMAL_ARRAY:
  66          var = &ctx->Array.Normal.Enabled;
  67          flag = _NEW_ARRAY_NORMAL;
  68          break;
  69       case GL_COLOR_ARRAY:
  70          var = &ctx->Array.Color.Enabled;
  71          flag = _NEW_ARRAY_COLOR0;
  72          break;
  73       case GL_INDEX_ARRAY:
  74          var = &ctx->Array.Index.Enabled;
  75          flag = _NEW_ARRAY_INDEX;
  76          break;
  77       case GL_TEXTURE_COORD_ARRAY:
  78          var = &ctx->Array.TexCoord[ctx->Array.ActiveTexture].Enabled;
  79          flag = _NEW_ARRAY_TEXCOORD(ctx->Array.ActiveTexture);
  80          break;
  81       case GL_EDGE_FLAG_ARRAY:
  82          var = &ctx->Array.EdgeFlag.Enabled;
  83          flag = _NEW_ARRAY_EDGEFLAG;
  84          break;
  85       case GL_FOG_COORDINATE_ARRAY_EXT:
  86          var = &ctx->Array.FogCoord.Enabled;
  87          flag = _NEW_ARRAY_FOGCOORD;
  88          break;
  89       case GL_SECONDARY_COLOR_ARRAY_EXT:
  90          var = &ctx->Array.SecondaryColor.Enabled;
  91          flag = _NEW_ARRAY_COLOR1;
  92          break;
  93
  94       /* GL_NV_vertex_program */
  95       case GL_VERTEX_ATTRIB_ARRAY0_NV:
  96       case GL_VERTEX_ATTRIB_ARRAY1_NV:
  97       case GL_VERTEX_ATTRIB_ARRAY2_NV:
  98       case GL_VERTEX_ATTRIB_ARRAY3_NV:
  99       case GL_VERTEX_ATTRIB_ARRAY4_NV:
 100       case GL_VERTEX_ATTRIB_ARRAY5_NV:
 101       case GL_VERTEX_ATTRIB_ARRAY6_NV:
 102       case GL_VERTEX_ATTRIB_ARRAY7_NV:
 103       case GL_VERTEX_ATTRIB_ARRAY8_NV:
 104       case GL_VERTEX_ATTRIB_ARRAY9_NV:
 105       case GL_VERTEX_ATTRIB_ARRAY10_NV:
 106       case GL_VERTEX_ATTRIB_ARRAY11_NV:
 107       case GL_VERTEX_ATTRIB_ARRAY12_NV:
 108       case GL_VERTEX_ATTRIB_ARRAY13_NV:
 109       case GL_VERTEX_ATTRIB_ARRAY14_NV:
 110       case GL_VERTEX_ATTRIB_ARRAY15_NV:
 111          CHECK_EXTENSION(NV_vertex_program);
 112          {
 113             GLint n = (GLint) cap - GL_VERTEX_ATTRIB_ARRAY0_NV;
 114             var = &ctx->Array.VertexAttrib[n].Enabled;
 115             flag = _NEW_ARRAY_VERT_ATTRIB0;  /* XXX flag OK? */
 116          }
 117          break;
 118       default:
 119          _mesa_error( ctx, GL_INVALID_ENUM, "glEnable/DisableClientState" );
 120          return;
 121    }
 122
 123    if (*var == flag)
 124       return;
 125
 126    FLUSH_VERTICES(ctx, _NEW_ARRAY);
 127    ctx->Array.NewState |= flag;
 128    *var = state;
 129
 130    if (state)
 131       ctx->Array._Enabled |= flag;
 132    else
 133       ctx->Array._Enabled &= ~flag;
 134
 135    if (ctx->Driver.Enable) {
 136       (*ctx->Driver.Enable)( ctx, cap, state );
 137    }
 138 }
 139
 140
 141
 142 void
 143 _mesa_EnableClientState( GLenum cap )
 144 {
 145    GET_CURRENT_CONTEXT(ctx);
 146    ASSERT_OUTSIDE_BEGIN_END(ctx);
 147    client_state( ctx, cap, GL_TRUE );
 148 }
 149
 150
 151
 152 void
 153 _mesa_DisableClientState( GLenum cap )
 154 {
 155    GET_CURRENT_CONTEXT(ctx);
 156    ASSERT_OUTSIDE_BEGIN_END(ctx);
 157    client_state( ctx, cap, GL_FALSE );
 158 }
 159
 160
 161 #undef CHECK_EXTENSION
 162 #define CHECK_EXTENSION(EXTNAME)                        \
 163    if (!ctx->Extensions.EXTNAME) {                      \
 164       _mesa_error(ctx, GL_INVALID_ENUM,                 \
 165                   state ? "glEnable": "glDisable");     \
 166       return;                                           \
 167    }
 168
 169
 170 /*
 171  * Perform glEnable and glDisable calls.
 172  */
 173 void _mesa_set_enable( GLcontext *ctx, GLenum cap, GLboolean state )
 174 {
 175    if (MESA_VERBOSE & VERBOSE_API)
 176       fprintf(stderr, "%s %s (newstate is %x)\n",
 177               state ? "glEnable" : "glDisable",
 178               _mesa_lookup_enum_by_nr(cap),
 179               ctx->NewState);
 180
 181    switch (cap) {
 182       case GL_ALPHA_TEST:
 183          if (ctx->Color.AlphaEnabled == state)
 184             return;
 185          FLUSH_VERTICES(ctx, _NEW_COLOR);
 186          ctx->Color.AlphaEnabled = state;
 187          break;
 188       case GL_AUTO_NORMAL:
 189          if (ctx->Eval.AutoNormal == state)
 190             return;
 191          FLUSH_VERTICES(ctx, _NEW_EVAL);
 192          ctx->Eval.AutoNormal = state;
 193          break;
 194       case GL_BLEND:
 195          if (ctx->Color.BlendEnabled == state)
 196             return;
 197          FLUSH_VERTICES(ctx, _NEW_COLOR);
 198          ctx->Color.BlendEnabled = state;
 199          /* The following needed to accomodate 1.0 RGB logic op blending */
 200          ctx->Color.ColorLogicOpEnabled =
 201             (ctx->Color.BlendEquation == GL_LOGIC_OP && state);
 202          break;
 203       case GL_CLIP_PLANE0:
 204       case GL_CLIP_PLANE1:
 205       case GL_CLIP_PLANE2:
 206       case GL_CLIP_PLANE3:
 207       case GL_CLIP_PLANE4:
 208       case GL_CLIP_PLANE5:
 209          {
 210             GLuint p = cap - GL_CLIP_PLANE0;
 211
 212             if (ctx->Transform.ClipEnabled[p] == state)
 213                return;
 214
 215             FLUSH_VERTICES(ctx, _NEW_TRANSFORM);
 216             ctx->Transform.ClipEnabled[p] = state;
 217
 218             if (state) {
 219                ctx->Transform._AnyClip++;
 220
 221                if (ctx->ProjectionMatrixStack.Top->flags & MAT_DIRTY) {
 222                   _math_matrix_analyse( ctx->ProjectionMatrixStack.Top );
 223                }
 224
 225                /* This derived state also calculated in clip.c and
 226                 * from _mesa_update_state() on changes to EyeUserPlane
 227                 * and ctx->ProjectionMatrix respectively.
 228                 */
 229                _mesa_transform_vector( ctx->Transform._ClipUserPlane[p],
 230                                     ctx->Transform.EyeUserPlane[p],
 231                                     ctx->ProjectionMatrixStack.Top->inv );
 232             }
 233          }
 234          break;
 235       case GL_COLOR_MATERIAL:
 236          if (ctx->Light.ColorMaterialEnabled == state)
 237             return;
 238          FLUSH_VERTICES(ctx, _NEW_LIGHT);
 239          ctx->Light.ColorMaterialEnabled = state;
 240          if (state) {
 241             FLUSH_CURRENT(ctx, 0);
 242             _mesa_update_color_material( ctx,
 243                                   ctx->Current.Attrib[VERT_ATTRIB_COLOR0] );
 244          }
 245          break;
 246       case GL_CULL_FACE:
 247          if (ctx->Polygon.CullFlag == state)
 248             return;
 249          FLUSH_VERTICES(ctx, _NEW_POLYGON);
 250          ctx->Polygon.CullFlag = state;
 251          break;
 252       case GL_DEPTH_TEST:
 253          if (state && ctx->Visual.depthBits==0) {
 254             _mesa_warning(ctx,"glEnable(GL_DEPTH_TEST) but no depth buffer");
 255             return;
 256          }
 257          if (ctx->Depth.Test==state)
 258             return;
 259          FLUSH_VERTICES(ctx, _NEW_DEPTH);
 260          ctx->Depth.Test = state;
 261          break;
 262       case GL_DITHER:
 263          if (ctx->NoDither) {
 264             state = GL_FALSE; /* MESA_NO_DITHER env var */
 265          }
 266          if (ctx->Color.DitherFlag==state)
 267             return;
 268          FLUSH_VERTICES(ctx, _NEW_COLOR);
 269          ctx->Color.DitherFlag = state;
 270          break;
 271       case GL_FOG:
 272          if (ctx->Fog.Enabled==state)
 273             return;
 274          FLUSH_VERTICES(ctx, _NEW_FOG);
 275          ctx->Fog.Enabled = state;
 276          break;
 277       case GL_HISTOGRAM:
 278          CHECK_EXTENSION(EXT_histogram);
 279          if (ctx->Pixel.HistogramEnabled == state)
 280             return;
 281          FLUSH_VERTICES(ctx, _NEW_PIXEL);
 282          ctx->Pixel.HistogramEnabled = state;
 283          break;
 284       case GL_LIGHT0:
 285       case GL_LIGHT1:
 286       case GL_LIGHT2:
 287       case GL_LIGHT3:
 288       case GL_LIGHT4:
 289       case GL_LIGHT5:
 290       case GL_LIGHT6:
 291       case GL_LIGHT7:
 292          if (ctx->Light.Light[cap-GL_LIGHT0].Enabled == state)
 293             return;
 294          FLUSH_VERTICES(ctx, _NEW_LIGHT);
 295          ctx->Light.Light[cap-GL_LIGHT0].Enabled = state;
 296          if (state) {
 297             insert_at_tail(&ctx->Light.EnabledList,
 298                            &ctx->Light.Light[cap-GL_LIGHT0]);
 299          }
 300          else {
 301             remove_from_list(&ctx->Light.Light[cap-GL_LIGHT0]);
 302          }
 303          break;
 304       case GL_LIGHTING:
 305          if (ctx->Light.Enabled == state)
 306             return;
 307          FLUSH_VERTICES(ctx, _NEW_LIGHT);
 308          ctx->Light.Enabled = state;
 309
 310          if ((ctx->Light.Enabled &&
 311               ctx->Light.Model.ColorControl==GL_SEPARATE_SPECULAR_COLOR)
 312              || ctx->Fog.ColorSumEnabled)
 313             ctx->_TriangleCaps |= DD_SEPARATE_SPECULAR;
 314          else
 315             ctx->_TriangleCaps &= ~DD_SEPARATE_SPECULAR;
 316
 317          break;
 318       case GL_LINE_SMOOTH:
 319          if (ctx->Line.SmoothFlag == state)
 320             return;
 321          FLUSH_VERTICES(ctx, _NEW_LINE);
 322          ctx->Line.SmoothFlag = state;
 323          ctx->_TriangleCaps ^= DD_LINE_SMOOTH;
 324          break;
 325       case GL_LINE_STIPPLE:
 326          if (ctx->Line.StippleFlag == state)
 327             return;
 328          FLUSH_VERTICES(ctx, _NEW_LINE);
 329          ctx->Line.StippleFlag = state;
 330          ctx->_TriangleCaps ^= DD_LINE_STIPPLE;
 331          break;
 332       case GL_INDEX_LOGIC_OP:
 333          if (ctx->Color.IndexLogicOpEnabled == state)
 334             return;
 335          FLUSH_VERTICES(ctx, _NEW_COLOR);
 336          ctx->Color.IndexLogicOpEnabled = state;
 337          break;
 338       case GL_COLOR_LOGIC_OP:
 339          if (ctx->Color.ColorLogicOpEnabled == state)
 340             return;
 341          FLUSH_VERTICES(ctx, _NEW_COLOR);
 342          ctx->Color.ColorLogicOpEnabled = state;
 343          break;
 344       case GL_MAP1_COLOR_4:
 345          if (ctx->Eval.Map1Color4 == state)
 346             return;
 347          FLUSH_VERTICES(ctx, _NEW_EVAL);
 348          ctx->Eval.Map1Color4 = state;
 349          break;
 350       case GL_MAP1_INDEX:
 351          if (ctx->Eval.Map1Index == state)
 352             return;
 353          FLUSH_VERTICES(ctx, _NEW_EVAL);
 354          ctx->Eval.Map1Index = state;
 355          break;
 356       case GL_MAP1_NORMAL:
 357          if (ctx->Eval.Map1Normal == state)
 358             return;
 359          FLUSH_VERTICES(ctx, _NEW_EVAL);
 360          ctx->Eval.Map1Normal = state;
 361          break;
 362       case GL_MAP1_TEXTURE_COORD_1:
 363          if (ctx->Eval.Map1TextureCoord1 == state)
 364             return;
 365          FLUSH_VERTICES(ctx, _NEW_EVAL);
 366          ctx->Eval.Map1TextureCoord1 = state;
 367          break;
 368       case GL_MAP1_TEXTURE_COORD_2:
 369          if (ctx->Eval.Map1TextureCoord2 == state)
 370             return;
 371          FLUSH_VERTICES(ctx, _NEW_EVAL);
 372          ctx->Eval.Map1TextureCoord2 = state;
 373          break;
 374       case GL_MAP1_TEXTURE_COORD_3:
 375          if (ctx->Eval.Map1TextureCoord3 == state)
 376             return;
 377          FLUSH_VERTICES(ctx, _NEW_EVAL);
 378          ctx->Eval.Map1TextureCoord3 = state;
 379          break;
 380       case GL_MAP1_TEXTURE_COORD_4:
 381          if (ctx->Eval.Map1TextureCoord4 == state)
 382             return;
 383          FLUSH_VERTICES(ctx, _NEW_EVAL);
 384          ctx->Eval.Map1TextureCoord4 = state;
 385          break;
 386       case GL_MAP1_VERTEX_3:
 387          if (ctx->Eval.Map1Vertex3 == state)
 388             return;
 389          FLUSH_VERTICES(ctx, _NEW_EVAL);
 390          ctx->Eval.Map1Vertex3 = state;
 391          break;
 392       case GL_MAP1_VERTEX_4:
 393          if (ctx->Eval.Map1Vertex4 == state)
 394             return;
 395          FLUSH_VERTICES(ctx, _NEW_EVAL);
 396          ctx->Eval.Map1Vertex4 = state;
 397          break;
 398       case GL_MAP2_COLOR_4:
 399          if (ctx->Eval.Map2Color4 == state)
 400             return;
 401          FLUSH_VERTICES(ctx, _NEW_EVAL);
 402          ctx->Eval.Map2Color4 = state;
 403          break;
 404       case GL_MAP2_INDEX:
 405          if (ctx->Eval.Map2Index == state)
 406             return;
 407          FLUSH_VERTICES(ctx, _NEW_EVAL);
 408          ctx->Eval.Map2Index = state;
 409          break;
 410       case GL_MAP2_NORMAL:
 411          if (ctx->Eval.Map2Normal == state)
 412             return;
 413          FLUSH_VERTICES(ctx, _NEW_EVAL);
 414          ctx->Eval.Map2Normal = state;
 415          break;
 416       case GL_MAP2_TEXTURE_COORD_1:
 417          if (ctx->Eval.Map2TextureCoord1 == state)
 418             return;
 419          FLUSH_VERTICES(ctx, _NEW_EVAL);
 420          ctx->Eval.Map2TextureCoord1 = state;
 421          break;
 422       case GL_MAP2_TEXTURE_COORD_2:
 423          if (ctx->Eval.Map2TextureCoord2 == state)
 424             return;
 425          FLUSH_VERTICES(ctx, _NEW_EVAL);
 426          ctx->Eval.Map2TextureCoord2 = state;
 427          break;
 428       case GL_MAP2_TEXTURE_COORD_3:
 429          if (ctx->Eval.Map2TextureCoord3 == state)
 430             return;
 431          FLUSH_VERTICES(ctx, _NEW_EVAL);
 432          ctx->Eval.Map2TextureCoord3 = state;
 433          break;
 434       case GL_MAP2_TEXTURE_COORD_4:
 435          if (ctx->Eval.Map2TextureCoord4 == state)
 436             return;
 437          FLUSH_VERTICES(ctx, _NEW_EVAL);
 438          ctx->Eval.Map2TextureCoord4 = state;
 439          break;
 440       case GL_MAP2_VERTEX_3:
 441          if (ctx->Eval.Map2Vertex3 == state)
 442             return;
 443          FLUSH_VERTICES(ctx, _NEW_EVAL);
 444          ctx->Eval.Map2Vertex3 = state;
 445          break;
 446       case GL_MAP2_VERTEX_4:
 447          if (ctx->Eval.Map2Vertex4 == state)
 448             return;
 449          FLUSH_VERTICES(ctx, _NEW_EVAL);
 450          ctx->Eval.Map2Vertex4 = state;
 451          break;
 452       case GL_MINMAX:
 453          if (ctx->Pixel.MinMaxEnabled == state)
 454             return;
 455          FLUSH_VERTICES(ctx, _NEW_PIXEL);
 456          ctx->Pixel.MinMaxEnabled = state;
 457          break;
 458       case GL_NORMALIZE:
 459          if (ctx->Transform.Normalize == state)
 460             return;
 461          FLUSH_VERTICES(ctx, _NEW_TRANSFORM);
 462          ctx->Transform.Normalize = state;
 463          break;
 464       case GL_POINT_SMOOTH:
 465          if (ctx->Point.SmoothFlag==state)
 466             return;
 467          FLUSH_VERTICES(ctx, _NEW_POINT);
 468          ctx->Point.SmoothFlag = state;
 469          ctx->_TriangleCaps ^= DD_POINT_SMOOTH;
 470          break;
 471       case GL_POLYGON_SMOOTH:
 472          if (ctx->Polygon.SmoothFlag==state)
 473             return;
 474          FLUSH_VERTICES(ctx, _NEW_POLYGON);
 475          ctx->Polygon.SmoothFlag = state;
 476          ctx->_TriangleCaps ^= DD_TRI_SMOOTH;
 477          break;
 478       case GL_POLYGON_STIPPLE:
 479          if (ctx->Polygon.StippleFlag==state)
 480             return;
 481          FLUSH_VERTICES(ctx, _NEW_POLYGON);
 482          ctx->Polygon.StippleFlag = state;
 483          ctx->_TriangleCaps ^= DD_TRI_STIPPLE;
 484          break;
 485       case GL_POLYGON_OFFSET_POINT:
 486          if (ctx->Polygon.OffsetPoint==state)
 487             return;
 488          FLUSH_VERTICES(ctx, _NEW_POLYGON);
 489          ctx->Polygon.OffsetPoint = state;
 490          break;
 491       case GL_POLYGON_OFFSET_LINE:
 492          if (ctx->Polygon.OffsetLine==state)
 493             return;
 494          FLUSH_VERTICES(ctx, _NEW_POLYGON);
 495          ctx->Polygon.OffsetLine = state;
 496          break;
 497       case GL_POLYGON_OFFSET_FILL:
 498          /*case GL_POLYGON_OFFSET_EXT:*/
 499          if (ctx->Polygon.OffsetFill==state)
 500             return;
 501          FLUSH_VERTICES(ctx, _NEW_POLYGON);
 502          ctx->Polygon.OffsetFill = state;
 503          break;
 504       case GL_RESCALE_NORMAL_EXT:
 505          if (ctx->Transform.RescaleNormals == state)
 506             return;
 507          FLUSH_VERTICES(ctx, _NEW_TRANSFORM);
 508          ctx->Transform.RescaleNormals = state;
 509          break;
 510       case GL_SCISSOR_TEST:
 511          if (ctx->Scissor.Enabled==state)
 512             return;
 513          FLUSH_VERTICES(ctx, _NEW_SCISSOR);
 514          ctx->Scissor.Enabled = state;
 515          break;
 516       case GL_SHARED_TEXTURE_PALETTE_EXT:
 517          if (ctx->Texture.SharedPalette == state)
 518             return;
 519          FLUSH_VERTICES(ctx, _NEW_TEXTURE);
 520          ctx->Texture.SharedPalette = state;
 521          break;
 522       case GL_STENCIL_TEST:
 523          if (state && ctx->Visual.stencilBits==0) {
 524             _mesa_warning(ctx,
 525                           "glEnable(GL_STENCIL_TEST) but no stencil buffer");
 526             return;
 527          }
 528          if (ctx->Stencil.Enabled==state)
 529             return;
 530          FLUSH_VERTICES(ctx, _NEW_STENCIL);
 531          ctx->Stencil.Enabled = state;
 532          break;
 533       case GL_TEXTURE_1D: {
 534          const GLuint curr = ctx->Texture.CurrentUnit;
 535          struct gl_texture_unit *texUnit = &ctx->Texture.Unit[curr];
 536          GLuint newenabled = texUnit->Enabled & ~TEXTURE0_1D;
 537          if (state)
 538             newenabled |= TEXTURE0_1D;
 539          if (!ctx->Visual.rgbMode || texUnit->Enabled == newenabled)
 540             return;
 541          FLUSH_VERTICES(ctx, _NEW_TEXTURE);
 542          texUnit->Enabled = newenabled;
 543          break;
 544       }
 545       case GL_TEXTURE_2D: {
 546          const GLuint curr = ctx->Texture.CurrentUnit;
 547          struct gl_texture_unit *texUnit = &ctx->Texture.Unit[curr];
 548          GLuint newenabled = texUnit->Enabled & ~TEXTURE0_2D;
 549          if (state)
 550             newenabled |= TEXTURE0_2D;
 551          if (!ctx->Visual.rgbMode || texUnit->Enabled == newenabled)
 552             return;
 553          FLUSH_VERTICES(ctx, _NEW_TEXTURE);
 554          texUnit->Enabled = newenabled;
 555          break;
 556       }
 557       case GL_TEXTURE_3D: {
 558          const GLuint curr = ctx->Texture.CurrentUnit;
 559          struct gl_texture_unit *texUnit = &ctx->Texture.Unit[curr];
 560          GLuint newenabled = texUnit->Enabled & ~TEXTURE0_3D;
 561          if (state)
 562             newenabled |= TEXTURE0_3D;
 563          if (!ctx->Visual.rgbMode || texUnit->Enabled == newenabled)
 564             return;
 565          FLUSH_VERTICES(ctx, _NEW_TEXTURE);
 566          texUnit->Enabled = newenabled;
 567          break;
 568       }
 569       case GL_TEXTURE_GEN_Q: {
 570          GLuint unit = ctx->Texture.CurrentUnit;
 571          struct gl_texture_unit *texUnit = &ctx->Texture.Unit[unit];
 572          GLuint newenabled = texUnit->TexGenEnabled & ~Q_BIT;
 573          if (state)
 574             newenabled |= Q_BIT;
 575          if (texUnit->TexGenEnabled == newenabled)
 576             return;
 577          FLUSH_VERTICES(ctx, _NEW_TEXTURE);
 578          texUnit->TexGenEnabled = newenabled;
 579          break;
 580       }
 581       case GL_TEXTURE_GEN_R: {
 582          GLuint unit = ctx->Texture.CurrentUnit;
 583          struct gl_texture_unit *texUnit = &ctx->Texture.Unit[unit];
 584          GLuint newenabled = texUnit->TexGenEnabled & ~R_BIT;
 585          if (state)
 586             newenabled |= R_BIT;
 587          if (texUnit->TexGenEnabled == newenabled)
 588             return;
 589          FLUSH_VERTICES(ctx, _NEW_TEXTURE);
 590          texUnit->TexGenEnabled = newenabled;
 591          break;
 592       }
 593       break;
 594       case GL_TEXTURE_GEN_S: {
 595          GLuint unit = ctx->Texture.CurrentUnit;
 596          struct gl_texture_unit *texUnit = &ctx->Texture.Unit[unit];
 597          GLuint newenabled = texUnit->TexGenEnabled & ~S_BIT;
 598          if (state)
 599             newenabled |= S_BIT;
 600          if (texUnit->TexGenEnabled == newenabled)
 601             return;
 602          FLUSH_VERTICES(ctx, _NEW_TEXTURE);
 603          texUnit->TexGenEnabled = newenabled;
 604          break;
 605       }
 606       break;
 607       case GL_TEXTURE_GEN_T: {
 608          GLuint unit = ctx->Texture.CurrentUnit;
 609          struct gl_texture_unit *texUnit = &ctx->Texture.Unit[unit];
 610          GLuint newenabled = texUnit->TexGenEnabled & ~T_BIT;
 611          if (state)
 612             newenabled |= T_BIT;
 613          if (texUnit->TexGenEnabled == newenabled)
 614             return;
 615          FLUSH_VERTICES(ctx, _NEW_TEXTURE);
 616          texUnit->TexGenEnabled = newenabled;
 617          break;
 618       }
 619       break;
 620
 621       /*
 622        * CLIENT STATE!!!
 623        */
 624       case GL_VERTEX_ARRAY:
 625       case GL_NORMAL_ARRAY:
 626       case GL_COLOR_ARRAY:
 627       case GL_INDEX_ARRAY:
 628       case GL_TEXTURE_COORD_ARRAY:
 629       case GL_EDGE_FLAG_ARRAY:
 630       case GL_FOG_COORDINATE_ARRAY_EXT:
 631       case GL_SECONDARY_COLOR_ARRAY_EXT:
 632          client_state( ctx, cap, state );
 633          return;
 634
 635       /* GL_HP_occlusion_test */
 636       case GL_OCCLUSION_TEST_HP:
 637          CHECK_EXTENSION(HP_occlusion_test);
 638          if (ctx->Depth.OcclusionTest == state)
 639             return;
 640          FLUSH_VERTICES(ctx, _NEW_DEPTH);
 641          ctx->Depth.OcclusionTest = state;
 642          if (state)
 643             ctx->OcclusionResult = ctx->OcclusionResultSaved;
 644          else
 645             ctx->OcclusionResultSaved = ctx->OcclusionResult;
 646          break;
 647
 648       /* GL_SGIS_pixel_texture */
 649       case GL_PIXEL_TEXTURE_SGIS:
 650          CHECK_EXTENSION(SGIS_pixel_texture);
 651          if (ctx->Pixel.PixelTextureEnabled == state)
 652             return;
 653          FLUSH_VERTICES(ctx, _NEW_PIXEL);
 654          ctx->Pixel.PixelTextureEnabled = state;
 655          break;
 656
 657       /* GL_SGIX_pixel_texture */
 658       case GL_PIXEL_TEX_GEN_SGIX:
 659          CHECK_EXTENSION(SGIX_pixel_texture);
 660          if (ctx->Pixel.PixelTextureEnabled == state)
 661             return;
 662          FLUSH_VERTICES(ctx, _NEW_PIXEL);
 663          ctx->Pixel.PixelTextureEnabled = state;
 664          break;
 665
 666       /* GL_SGI_color_table */
 667       case GL_COLOR_TABLE_SGI:
 668          CHECK_EXTENSION(SGI_color_table);
 669          if (ctx->Pixel.ColorTableEnabled == state)
 670             return;
 671          FLUSH_VERTICES(ctx, _NEW_PIXEL);
 672          ctx->Pixel.ColorTableEnabled = state;
 673          break;
 674       case GL_POST_CONVOLUTION_COLOR_TABLE_SGI:
 675          CHECK_EXTENSION(SGI_color_table);
 676          if (ctx->Pixel.PostConvolutionColorTableEnabled == state)
 677             return;
 678          FLUSH_VERTICES(ctx, _NEW_PIXEL);
 679          ctx->Pixel.PostConvolutionColorTableEnabled = state;
 680          break;
 681       case GL_POST_COLOR_MATRIX_COLOR_TABLE_SGI:
 682          CHECK_EXTENSION(SGI_color_table);
 683          if (ctx->Pixel.PostColorMatrixColorTableEnabled == state)
 684             return;
 685          FLUSH_VERTICES(ctx, _NEW_PIXEL);
 686          ctx->Pixel.PostColorMatrixColorTableEnabled = state;
 687          break;
 688
 689       /* GL_EXT_convolution */
 690       case GL_CONVOLUTION_1D:
 691          CHECK_EXTENSION(EXT_convolution);
 692          if (ctx->Pixel.Convolution1DEnabled == state)
 693             return;
 694          FLUSH_VERTICES(ctx, _NEW_PIXEL);
 695          ctx->Pixel.Convolution1DEnabled = state;
 696          break;
 697       case GL_CONVOLUTION_2D:
 698          CHECK_EXTENSION(EXT_convolution);
 699          if (ctx->Pixel.Convolution2DEnabled == state)
 700             return;
 701          FLUSH_VERTICES(ctx, _NEW_PIXEL);
 702          ctx->Pixel.Convolution2DEnabled = state;
 703          break;
 704       case GL_SEPARABLE_2D:
 705          CHECK_EXTENSION(EXT_convolution);
 706          if (ctx->Pixel.Separable2DEnabled == state)
 707             return;
 708          FLUSH_VERTICES(ctx, _NEW_PIXEL);
 709          ctx->Pixel.Separable2DEnabled = state;
 710          break;
 711
 712       /* GL_ARB_texture_cube_map */
 713       case GL_TEXTURE_CUBE_MAP_ARB:
 714          {
 715             const GLuint curr = ctx->Texture.CurrentUnit;
 716             struct gl_texture_unit *texUnit = &ctx->Texture.Unit[curr];
 717             GLuint newenabled = texUnit->Enabled & ~TEXTURE0_CUBE;
 718             CHECK_EXTENSION(ARB_texture_cube_map);
 719             if (state)
 720                newenabled |= TEXTURE0_CUBE;
 721             if (!ctx->Visual.rgbMode || texUnit->Enabled == newenabled)
 722                return;
 723             FLUSH_VERTICES(ctx, _NEW_TEXTURE);
 724             texUnit->Enabled = newenabled;
 725          }
 726          break;
 727
 728       /* GL_EXT_secondary_color */
 729       case GL_COLOR_SUM_EXT:
 730          CHECK_EXTENSION(EXT_secondary_color);
 731          if (ctx->Fog.ColorSumEnabled == state)
 732             return;
 733          FLUSH_VERTICES(ctx, _NEW_FOG);
 734          ctx->Fog.ColorSumEnabled = state;
 735
 736          if ((ctx->Light.Enabled &&
 737               ctx->Light.Model.ColorControl==GL_SEPARATE_SPECULAR_COLOR)
 738              || ctx->Fog.ColorSumEnabled)
 739             ctx->_TriangleCaps |= DD_SEPARATE_SPECULAR;
 740          else
 741             ctx->_TriangleCaps &= ~DD_SEPARATE_SPECULAR;
 742
 743          break;
 744
 745       /* GL_ARB_multisample */
 746       case GL_MULTISAMPLE_ARB:
 747          CHECK_EXTENSION(ARB_multisample);
 748          if (ctx->Multisample.Enabled == state)
 749             return;
 750          FLUSH_VERTICES(ctx, _NEW_MULTISAMPLE);
 751          ctx->Multisample.Enabled = state;
 752          break;
 753       case GL_SAMPLE_ALPHA_TO_COVERAGE_ARB:
 754          CHECK_EXTENSION(ARB_multisample);
 755          if (ctx->Multisample.SampleAlphaToCoverage == state)
 756             return;
 757          FLUSH_VERTICES(ctx, _NEW_MULTISAMPLE);
 758          ctx->Multisample.SampleAlphaToCoverage = state;
 759          break;
 760       case GL_SAMPLE_ALPHA_TO_ONE_ARB:
 761          CHECK_EXTENSION(ARB_multisample);
 762          if (ctx->Multisample.SampleAlphaToOne == state)
 763             return;
 764          FLUSH_VERTICES(ctx, _NEW_MULTISAMPLE);
 765          ctx->Multisample.SampleAlphaToOne = state;
 766          break;
 767       case GL_SAMPLE_COVERAGE_ARB:
 768          CHECK_EXTENSION(ARB_multisample);
 769          if (ctx->Multisample.SampleCoverage == state)
 770             return;
 771          FLUSH_VERTICES(ctx, _NEW_MULTISAMPLE);
 772          ctx->Multisample.SampleCoverage = state;
 773          break;
 774       case GL_SAMPLE_COVERAGE_INVERT_ARB:
 775          CHECK_EXTENSION(ARB_multisample);
 776          if (ctx->Multisample.SampleCoverageInvert == state)
 777             return;
 778          FLUSH_VERTICES(ctx, _NEW_MULTISAMPLE);
 779          ctx->Multisample.SampleCoverageInvert = state;
 780          break;
 781
 782       /* GL_IBM_rasterpos_clip */
 783       case GL_RASTER_POSITION_UNCLIPPED_IBM:
 784          CHECK_EXTENSION(IBM_rasterpos_clip);
 785          if (ctx->Transform.RasterPositionUnclipped == state)
 786             return;
 787          FLUSH_VERTICES(ctx, _NEW_TRANSFORM);
 788          ctx->Transform.RasterPositionUnclipped = state;
 789          break;
 790
 791       /* GL_MESA_sprite_point */
 792       case GL_SPRITE_POINT_MESA:
 793          CHECK_EXTENSION(MESA_sprite_point);
 794          if (ctx->Point.SpriteMode == state)
 795             return;
 796          FLUSH_VERTICES(ctx, _NEW_POINT);
 797          ctx->Point.SpriteMode = state;
 798          break;
 799
 800       /* GL_NV_vertex_program */
 801       case GL_VERTEX_PROGRAM_NV:
 802          CHECK_EXTENSION(NV_vertex_program);
 803          if (ctx->VertexProgram.Enabled == state)
 804             return;
 805          FLUSH_VERTICES(ctx, _NEW_TRANSFORM);  /* XXX OK? */
 806          ctx->VertexProgram.Enabled = state;
 807          break;
 808       case GL_VERTEX_PROGRAM_POINT_SIZE_NV:
 809          CHECK_EXTENSION(NV_vertex_program);
 810          if (ctx->VertexProgram.PointSizeEnabled == state)
 811             return;
 812          FLUSH_VERTICES(ctx, _NEW_TRANSFORM);  /* XXX OK? */
 813          ctx->VertexProgram.PointSizeEnabled = state;
 814          break;
 815       case GL_VERTEX_PROGRAM_TWO_SIDE_NV:
 816          CHECK_EXTENSION(NV_vertex_program);
 817          if (ctx->VertexProgram.TwoSideEnabled == state)
 818             return;
 819          FLUSH_VERTICES(ctx, _NEW_TRANSFORM);  /* XXX OK? */
 820          ctx->VertexProgram.TwoSideEnabled = state;
 821          break;
 822       case GL_MAP1_VERTEX_ATTRIB0_4_NV:
 823       case GL_MAP1_VERTEX_ATTRIB1_4_NV:
 824       case GL_MAP1_VERTEX_ATTRIB2_4_NV:
 825       case GL_MAP1_VERTEX_ATTRIB3_4_NV:
 826       case GL_MAP1_VERTEX_ATTRIB4_4_NV:
 827       case GL_MAP1_VERTEX_ATTRIB5_4_NV:
 828       case GL_MAP1_VERTEX_ATTRIB6_4_NV:
 829       case GL_MAP1_VERTEX_ATTRIB7_4_NV:
 830       case GL_MAP1_VERTEX_ATTRIB8_4_NV:
 831       case GL_MAP1_VERTEX_ATTRIB9_4_NV:
 832       case GL_MAP1_VERTEX_ATTRIB10_4_NV:
 833       case GL_MAP1_VERTEX_ATTRIB11_4_NV:
 834       case GL_MAP1_VERTEX_ATTRIB12_4_NV:
 835       case GL_MAP1_VERTEX_ATTRIB13_4_NV:
 836       case GL_MAP1_VERTEX_ATTRIB14_4_NV:
 837       case GL_MAP1_VERTEX_ATTRIB15_4_NV:
 838          CHECK_EXTENSION(NV_vertex_program);
 839          break;
 840       case GL_MAP2_VERTEX_ATTRIB0_4_NV:
 841       case GL_MAP2_VERTEX_ATTRIB1_4_NV:
 842       case GL_MAP2_VERTEX_ATTRIB2_4_NV:
 843       case GL_MAP2_VERTEX_ATTRIB3_4_NV:
 844       case GL_MAP2_VERTEX_ATTRIB4_4_NV:
 845       case GL_MAP2_VERTEX_ATTRIB5_4_NV:
 846       case GL_MAP2_VERTEX_ATTRIB6_4_NV:
 847       case GL_MAP2_VERTEX_ATTRIB7_4_NV:
 848       case GL_MAP2_VERTEX_ATTRIB8_4_NV:
 849       case GL_MAP2_VERTEX_ATTRIB9_4_NV:
 850       case GL_MAP2_VERTEX_ATTRIB10_4_NV:
 851       case GL_MAP2_VERTEX_ATTRIB11_4_NV:
 852       case GL_MAP2_VERTEX_ATTRIB12_4_NV:
 853       case GL_MAP2_VERTEX_ATTRIB13_4_NV:
 854       case GL_MAP2_VERTEX_ATTRIB14_4_NV:
 855       case GL_MAP2_VERTEX_ATTRIB15_4_NV:
 856          CHECK_EXTENSION(NV_vertex_program);
 857          break;
 858
 859       default:
 860          _mesa_error(ctx, GL_INVALID_ENUM, state ? "glEnable" : "glDisable");
 861          return;
 862    }
 863
 864    if (ctx->Driver.Enable) {
 865       (*ctx->Driver.Enable)( ctx, cap, state );
 866    }
 867 }
 868
 869
 870
 871
 872 void
 873 _mesa_Enable( GLenum cap )
 874 {
 875    GET_CURRENT_CONTEXT(ctx);
 876    ASSERT_OUTSIDE_BEGIN_END(ctx);
 877
 878    _mesa_set_enable( ctx, cap, GL_TRUE );
 879 }
 880
 881
 882
 883 void
 884 _mesa_Disable( GLenum cap )
 885 {
 886    GET_CURRENT_CONTEXT(ctx);
 887    ASSERT_OUTSIDE_BEGIN_END(ctx);
 888
 889    _mesa_set_enable( ctx, cap, GL_FALSE );
 890 }
 891
 892
 893 #undef CHECK_EXTENSION
 894 #define CHECK_EXTENSION(EXTNAME)                        \
 895    if (!ctx->Extensions.EXTNAME) {                      \
 896       _mesa_error(ctx, GL_INVALID_ENUM, "glIsEnabled"); \
 897       return GL_FALSE;                                  \
 898    }
 899
 900
 901 GLboolean
 902 _mesa_IsEnabled( GLenum cap )
 903 {
 904    GET_CURRENT_CONTEXT(ctx);
 905    switch (cap) {
 906       case GL_ALPHA_TEST:
 907          return ctx->Color.AlphaEnabled;
 908       case GL_AUTO_NORMAL:
 909          return ctx->Eval.AutoNormal;
 910       case GL_BLEND:
 911          return ctx->Color.BlendEnabled;
 912       case GL_CLIP_PLANE0:
 913       case GL_CLIP_PLANE1:
 914       case GL_CLIP_PLANE2:
 915       case GL_CLIP_PLANE3:
 916       case GL_CLIP_PLANE4:
 917       case GL_CLIP_PLANE5:
 918          return ctx->Transform.ClipEnabled[cap-GL_CLIP_PLANE0];
 919       case GL_COLOR_MATERIAL:
 920          return ctx->Light.ColorMaterialEnabled;
 921       case GL_CULL_FACE:
 922          return ctx->Polygon.CullFlag;
 923       case GL_DEPTH_TEST:
 924          return ctx->Depth.Test;
 925       case GL_DITHER:
 926          return ctx->Color.DitherFlag;
 927       case GL_FOG:
 928          return ctx->Fog.Enabled;
 929       case GL_LIGHTING:
 930          return ctx->Light.Enabled;
 931       case GL_LIGHT0:
 932       case GL_LIGHT1:
 933       case GL_LIGHT2:
 934       case GL_LIGHT3:
 935       case GL_LIGHT4:
 936       case GL_LIGHT5:
 937       case GL_LIGHT6:
 938       case GL_LIGHT7:
 939          return ctx->Light.Light[cap-GL_LIGHT0].Enabled;
 940       case GL_LINE_SMOOTH:
 941          return ctx->Line.SmoothFlag;
 942       case GL_LINE_STIPPLE:
 943          return ctx->Line.StippleFlag;
 944       case GL_INDEX_LOGIC_OP:
 945          return ctx->Color.IndexLogicOpEnabled;
 946       case GL_COLOR_LOGIC_OP:
 947          return ctx->Color.ColorLogicOpEnabled;
 948       case GL_MAP1_COLOR_4:
 949          return ctx->Eval.Map1Color4;
 950       case GL_MAP1_INDEX:
 951          return ctx->Eval.Map1Index;
 952       case GL_MAP1_NORMAL:
 953          return ctx->Eval.Map1Normal;
 954       case GL_MAP1_TEXTURE_COORD_1:
 955          return ctx->Eval.Map1TextureCoord1;
 956       case GL_MAP1_TEXTURE_COORD_2:
 957          return ctx->Eval.Map1TextureCoord2;
 958       case GL_MAP1_TEXTURE_COORD_3:
 959          return ctx->Eval.Map1TextureCoord3;
 960       case GL_MAP1_TEXTURE_COORD_4:
 961          return ctx->Eval.Map1TextureCoord4;
 962       case GL_MAP1_VERTEX_3:
 963          return ctx->Eval.Map1Vertex3;
 964       case GL_MAP1_VERTEX_4:
 965          return ctx->Eval.Map1Vertex4;
 966       case GL_MAP2_COLOR_4:
 967          return ctx->Eval.Map2Color4;
 968       case GL_MAP2_INDEX:
 969          return ctx->Eval.Map2Index;
 970       case GL_MAP2_NORMAL:
 971          return ctx->Eval.Map2Normal;
 972       case GL_MAP2_TEXTURE_COORD_1:
 973          return ctx->Eval.Map2TextureCoord1;
 974       case GL_MAP2_TEXTURE_COORD_2:
 975          return ctx->Eval.Map2TextureCoord2;
 976       case GL_MAP2_TEXTURE_COORD_3:
 977          return ctx->Eval.Map2TextureCoord3;
 978       case GL_MAP2_TEXTURE_COORD_4:
 979          return ctx->Eval.Map2TextureCoord4;
 980       case GL_MAP2_VERTEX_3:
 981          return ctx->Eval.Map2Vertex3;
 982       case GL_MAP2_VERTEX_4:
 983          return ctx->Eval.Map2Vertex4;
 984       case GL_NORMALIZE:
 985          return ctx->Transform.Normalize;
 986       case GL_POINT_SMOOTH:
 987          return ctx->Point.SmoothFlag;
 988       case GL_POLYGON_SMOOTH:
 989          return ctx->Polygon.SmoothFlag;
 990       case GL_POLYGON_STIPPLE:
 991          return ctx->Polygon.StippleFlag;
 992       case GL_POLYGON_OFFSET_POINT:
 993          return ctx->Polygon.OffsetPoint;
 994       case GL_POLYGON_OFFSET_LINE:
 995          return ctx->Polygon.OffsetLine;
 996       case GL_POLYGON_OFFSET_FILL:
 997       /*case GL_POLYGON_OFFSET_EXT:*/
 998          return ctx->Polygon.OffsetFill;
 999       case GL_RESCALE_NORMAL_EXT:
1000          return ctx->Transform.RescaleNormals;
1001       case GL_SCISSOR_TEST:
1002          return ctx->Scissor.Enabled;
1003       case GL_SHARED_TEXTURE_PALETTE_EXT:
1004          return ctx->Texture.SharedPalette;
1005       case GL_STENCIL_TEST:
1006          return ctx->Stencil.Enabled;
1007       case GL_TEXTURE_1D:
1008          {
1009             const struct gl_texture_unit *texUnit;
1010             texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
1011             return (texUnit->Enabled & TEXTURE0_1D) ? GL_TRUE : GL_FALSE;
1012          }
1013       case GL_TEXTURE_2D:
1014          {
1015             const struct gl_texture_unit *texUnit;
1016             texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
1017             return (texUnit->Enabled & TEXTURE0_2D) ? GL_TRUE : GL_FALSE;
1018          }
1019       case GL_TEXTURE_3D:
1020          {
1021             const struct gl_texture_unit *texUnit;
1022             texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
1023             return (texUnit->Enabled & TEXTURE0_3D) ? GL_TRUE : GL_FALSE;
1024          }
1025       case GL_TEXTURE_GEN_Q:
1026          {
1027             const struct gl_texture_unit *texUnit;
1028             texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
1029             return (texUnit->TexGenEnabled & Q_BIT) ? GL_TRUE : GL_FALSE;
1030          }
1031       case GL_TEXTURE_GEN_R:
1032          {
1033             const struct gl_texture_unit *texUnit;
1034             texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
1035             return (texUnit->TexGenEnabled & R_BIT) ? GL_TRUE : GL_FALSE;
1036          }
1037       case GL_TEXTURE_GEN_S:
1038          {
1039             const struct gl_texture_unit *texUnit;
1040             texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
1041             return (texUnit->TexGenEnabled & S_BIT) ? GL_TRUE : GL_FALSE;
1042          }
1043       case GL_TEXTURE_GEN_T:
1044          {
1045             const struct gl_texture_unit *texUnit;
1046             texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
1047             return (texUnit->TexGenEnabled & T_BIT) ? GL_TRUE : GL_FALSE;
1048          }
1049
1050       /*
1051        * CLIENT STATE!!!
1052        */
1053       case GL_VERTEX_ARRAY:
1054          return ctx->Array.Vertex.Enabled;
1055       case GL_NORMAL_ARRAY:
1056          return ctx->Array.Normal.Enabled;
1057       case GL_COLOR_ARRAY:
1058          return ctx->Array.Color.Enabled;
1059       case GL_INDEX_ARRAY:
1060          return ctx->Array.Index.Enabled;
1061       case GL_TEXTURE_COORD_ARRAY:
1062          return ctx->Array.TexCoord[ctx->Array.ActiveTexture].Enabled;
1063       case GL_EDGE_FLAG_ARRAY:
1064          return ctx->Array.EdgeFlag.Enabled;
1065
1066       /* GL_EXT_histogram */
1067       case GL_HISTOGRAM:
1068          CHECK_EXTENSION(EXT_histogram);
1069          return ctx->Pixel.HistogramEnabled;
1070       case GL_MINMAX:
1071          CHECK_EXTENSION(EXT_histogram);
1072          return ctx->Pixel.MinMaxEnabled;
1073
1074       /* GL_HP_occlusion_test */
1075       case GL_OCCLUSION_TEST_HP:
1076          CHECK_EXTENSION(HP_occlusion_test);
1077          return ctx->Depth.OcclusionTest;
1078
1079       /* GL_SGIS_pixel_texture */
1080       case GL_PIXEL_TEXTURE_SGIS:
1081          CHECK_EXTENSION(SGIS_pixel_texture);
1082          return ctx->Pixel.PixelTextureEnabled;
1083
1084       /* GL_SGIX_pixel_texture */
1085       case GL_PIXEL_TEX_GEN_SGIX:
1086          CHECK_EXTENSION(SGIX_pixel_texture);
1087          return ctx->Pixel.PixelTextureEnabled;
1088
1089       /* GL_SGI_color_table */
1090       case GL_COLOR_TABLE_SGI:
1091          CHECK_EXTENSION(SGI_color_table);
1092          return ctx->Pixel.ColorTableEnabled;
1093       case GL_POST_CONVOLUTION_COLOR_TABLE_SGI:
1094          CHECK_EXTENSION(SGI_color_table);
1095          return ctx->Pixel.PostConvolutionColorTableEnabled;
1096       case GL_POST_COLOR_MATRIX_COLOR_TABLE_SGI:
1097          CHECK_EXTENSION(SGI_color_table);
1098          return ctx->Pixel.PostColorMatrixColorTableEnabled;
1099
1100       /* GL_EXT_convolution */
1101       case GL_CONVOLUTION_1D:
1102          CHECK_EXTENSION(EXT_convolution);
1103          return ctx->Pixel.Convolution1DEnabled;
1104       case GL_CONVOLUTION_2D:
1105          CHECK_EXTENSION(EXT_convolution);
1106          return ctx->Pixel.Convolution2DEnabled;
1107       case GL_SEPARABLE_2D:
1108          CHECK_EXTENSION(EXT_convolution);
1109          return ctx->Pixel.Separable2DEnabled;
1110
1111       /* GL_ARB_texture_cube_map */
1112       case GL_TEXTURE_CUBE_MAP_ARB:
1113          CHECK_EXTENSION(ARB_texture_cube_map);
1114          {
1115             const struct gl_texture_unit *texUnit;
1116             texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
1117             return (texUnit->Enabled & TEXTURE0_CUBE) ? GL_TRUE : GL_FALSE;
1118          }
1119
1120       /* GL_ARB_multisample */
1121       case GL_MULTISAMPLE_ARB:
1122          CHECK_EXTENSION(ARB_multisample);
1123          return ctx->Multisample.Enabled;
1124       case GL_SAMPLE_ALPHA_TO_COVERAGE_ARB:
1125          CHECK_EXTENSION(ARB_multisample);
1126          return ctx->Multisample.SampleAlphaToCoverage;
1127       case GL_SAMPLE_ALPHA_TO_ONE_ARB:
1128          CHECK_EXTENSION(ARB_multisample);
1129          return ctx->Multisample.SampleAlphaToOne;
1130       case GL_SAMPLE_COVERAGE_ARB:
1131          CHECK_EXTENSION(ARB_multisample);
1132          return ctx->Multisample.SampleCoverage;
1133       case GL_SAMPLE_COVERAGE_INVERT_ARB:
1134          CHECK_EXTENSION(ARB_multisample);
1135          return ctx->Multisample.SampleCoverageInvert;
1136
1137       /* GL_IBM_rasterpos_clip */
1138       case GL_RASTER_POSITION_UNCLIPPED_IBM:
1139          CHECK_EXTENSION(IBM_rasterpos_clip);
1140          return ctx->Transform.RasterPositionUnclipped;
1141
1142       /* GL_MESA_sprite_point */
1143       case GL_SPRITE_POINT_MESA:
1144          return ctx->Point.SpriteMode;
1145
1146       /* GL_NV_vertex_program */
1147       case GL_VERTEX_PROGRAM_NV:
1148          CHECK_EXTENSION(NV_vertex_program);
1149          return ctx->VertexProgram.Enabled;
1150       case GL_VERTEX_PROGRAM_POINT_SIZE_NV:
1151          CHECK_EXTENSION(NV_vertex_program);
1152          return ctx->VertexProgram.PointSizeEnabled;
1153       case GL_VERTEX_PROGRAM_TWO_SIDE_NV:
1154          CHECK_EXTENSION(NV_vertex_program);
1155          return ctx->VertexProgram.TwoSideEnabled;
1156       case GL_VERTEX_ATTRIB_ARRAY0_NV:
1157       case GL_VERTEX_ATTRIB_ARRAY1_NV:
1158       case GL_VERTEX_ATTRIB_ARRAY2_NV:
1159       case GL_VERTEX_ATTRIB_ARRAY3_NV:
1160       case GL_VERTEX_ATTRIB_ARRAY4_NV:
1161       case GL_VERTEX_ATTRIB_ARRAY5_NV:
1162       case GL_VERTEX_ATTRIB_ARRAY6_NV:
1163       case GL_VERTEX_ATTRIB_ARRAY7_NV:
1164       case GL_VERTEX_ATTRIB_ARRAY8_NV:
1165       case GL_VERTEX_ATTRIB_ARRAY9_NV:
1166       case GL_VERTEX_ATTRIB_ARRAY10_NV:
1167       case GL_VERTEX_ATTRIB_ARRAY11_NV:
1168       case GL_VERTEX_ATTRIB_ARRAY12_NV:
1169       case GL_VERTEX_ATTRIB_ARRAY13_NV:
1170       case GL_VERTEX_ATTRIB_ARRAY14_NV:
1171       case GL_VERTEX_ATTRIB_ARRAY15_NV:
1172          CHECK_EXTENSION(NV_vertex_program);
1173          {
1174             GLint n = (GLint) cap - GL_VERTEX_ATTRIB_ARRAY0_NV;
1175             return ctx->Array.VertexAttrib[n].Enabled;
1176          }
1177       case GL_MAP1_VERTEX_ATTRIB0_4_NV:
1178       case GL_MAP1_VERTEX_ATTRIB1_4_NV:
1179       case GL_MAP1_VERTEX_ATTRIB2_4_NV:
1180       case GL_MAP1_VERTEX_ATTRIB3_4_NV:
1181       case GL_MAP1_VERTEX_ATTRIB4_4_NV:
1182       case GL_MAP1_VERTEX_ATTRIB5_4_NV:
1183       case GL_MAP1_VERTEX_ATTRIB6_4_NV:
1184       case GL_MAP1_VERTEX_ATTRIB7_4_NV:
1185       case GL_MAP1_VERTEX_ATTRIB8_4_NV:
1186       case GL_MAP1_VERTEX_ATTRIB9_4_NV:
1187       case GL_MAP1_VERTEX_ATTRIB10_4_NV:
1188       case GL_MAP1_VERTEX_ATTRIB11_4_NV:
1189       case GL_MAP1_VERTEX_ATTRIB12_4_NV:
1190       case GL_MAP1_VERTEX_ATTRIB13_4_NV:
1191       case GL_MAP1_VERTEX_ATTRIB14_4_NV:
1192       case GL_MAP1_VERTEX_ATTRIB15_4_NV:
1193          CHECK_EXTENSION(NV_vertex_program);
1194          return GL_FALSE;
1195       case GL_MAP2_VERTEX_ATTRIB0_4_NV:
1196       case GL_MAP2_VERTEX_ATTRIB1_4_NV:
1197       case GL_MAP2_VERTEX_ATTRIB2_4_NV:
1198       case GL_MAP2_VERTEX_ATTRIB3_4_NV:
1199       case GL_MAP2_VERTEX_ATTRIB4_4_NV:
1200       case GL_MAP2_VERTEX_ATTRIB5_4_NV:
1201       case GL_MAP2_VERTEX_ATTRIB6_4_NV:
1202       case GL_MAP2_VERTEX_ATTRIB7_4_NV:
1203       case GL_MAP2_VERTEX_ATTRIB8_4_NV:
1204       case GL_MAP2_VERTEX_ATTRIB9_4_NV:
1205       case GL_MAP2_VERTEX_ATTRIB10_4_NV:
1206       case GL_MAP2_VERTEX_ATTRIB11_4_NV:
1207       case GL_MAP2_VERTEX_ATTRIB12_4_NV:
1208       case GL_MAP2_VERTEX_ATTRIB13_4_NV:
1209       case GL_MAP2_VERTEX_ATTRIB14_4_NV:
1210       case GL_MAP2_VERTEX_ATTRIB15_4_NV:
1211          CHECK_EXTENSION(NV_vertex_program);
1212          return GL_FALSE;
1213
1214       default:
1215          _mesa_error( ctx, GL_INVALID_ENUM, "glIsEnabled" );
1216          return GL_FALSE;
1217    }
1218 }