src/mesa/main/enable.c

   1 /* $Id: enable.c,v 1.42 2001/02/16 18:14:41 keithw Exp $ */
   2
   3 /*
   4  * Mesa 3-D graphics library
   5  * Version:  3.5
   6  *
   7  * Copyright (C) 1999-2000  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
  41 #include "math/m_matrix.h"
  42 #include "math/m_xform.h"
  43
  44 #endif
  45
  46
  47 static void
  48 client_state( GLcontext *ctx, GLenum cap, GLboolean state )
  49 {
  50    GLuint flag;
  51    GLboolean *var;
  52
  53    switch (cap) {
  54    case GL_VERTEX_ARRAY:
  55       var = &ctx->Array.Vertex.Enabled;
  56       flag = _NEW_ARRAY_VERTEX;
  57       break;
  58    case GL_NORMAL_ARRAY:
  59       var = &ctx->Array.Normal.Enabled;
  60       flag = _NEW_ARRAY_NORMAL;
  61       break;
  62    case GL_COLOR_ARRAY:
  63       var = &ctx->Array.Color.Enabled;
  64       flag = _NEW_ARRAY_COLOR;
  65       break;
  66    case GL_INDEX_ARRAY:
  67       var = &ctx->Array.Index.Enabled;
  68       flag = _NEW_ARRAY_INDEX;
  69       break;
  70    case GL_TEXTURE_COORD_ARRAY:
  71       var = &ctx->Array.TexCoord[ctx->Array.ActiveTexture].Enabled;
  72       flag = _NEW_ARRAY_TEXCOORD(ctx->Array.ActiveTexture);
  73       break;
  74    case GL_EDGE_FLAG_ARRAY:
  75       var = &ctx->Array.EdgeFlag.Enabled;
  76       flag = _NEW_ARRAY_EDGEFLAG;
  77       break;
  78    case GL_FOG_COORDINATE_ARRAY_EXT:
  79       var = &ctx->Array.FogCoord.Enabled;
  80       flag = _NEW_ARRAY_FOGCOORD;
  81       break;
  82    case GL_SECONDARY_COLOR_ARRAY_EXT:
  83       var = &ctx->Array.SecondaryColor.Enabled;
  84       flag = _NEW_ARRAY_SECONDARYCOLOR;
  85       break;
  86    default:
  87       gl_error( ctx, GL_INVALID_ENUM, "glEnable/DisableClientState" );
  88       return;
  89    }
  90
  91    if (*var == flag)
  92       return;
  93
  94    FLUSH_VERTICES(ctx, _NEW_ARRAY);
  95    ctx->Array.NewState |= flag;
  96    *var = state;
  97
  98    if (state)
  99       ctx->Array._Enabled |= flag;
 100    else
 101       ctx->Array._Enabled &= ~flag;
 102
 103    if (ctx->Driver.Enable) {
 104       (*ctx->Driver.Enable)( ctx, cap, state );
 105    }
 106 }
 107
 108
 109
 110 void
 111 _mesa_EnableClientState( GLenum cap )
 112 {
 113    GET_CURRENT_CONTEXT(ctx);
 114    ASSERT_OUTSIDE_BEGIN_END(ctx);
 115    client_state( ctx, cap, GL_TRUE );
 116 }
 117
 118
 119
 120 void
 121 _mesa_DisableClientState( GLenum cap )
 122 {
 123    GET_CURRENT_CONTEXT(ctx);
 124    ASSERT_OUTSIDE_BEGIN_END(ctx);
 125    client_state( ctx, cap, GL_FALSE );
 126 }
 127
 128
 129 /*
 130  * Perform glEnable and glDisable calls.
 131  */
 132 void _mesa_set_enable( GLcontext *ctx, GLenum cap, GLboolean state )
 133 {
 134    if (MESA_VERBOSE & VERBOSE_API)
 135       fprintf(stderr, "%s %s (newstate is %x)\n",
 136               state ? "glEnable" : "glDisable",
 137               gl_lookup_enum_by_nr(cap),
 138               ctx->NewState);
 139
 140    switch (cap) {
 141    case GL_ALPHA_TEST:
 142       if (ctx->Color.AlphaEnabled == state)
 143          return;
 144       FLUSH_VERTICES(ctx, _NEW_COLOR);
 145       ctx->Color.AlphaEnabled = state;
 146       break;
 147    case GL_AUTO_NORMAL:
 148       if (ctx->Eval.AutoNormal == state)
 149          return;
 150       FLUSH_VERTICES(ctx, _NEW_EVAL);
 151       ctx->Eval.AutoNormal = state;
 152       break;
 153    case GL_BLEND:
 154       if (ctx->Color.BlendEnabled == state)
 155          return;
 156
 157       FLUSH_VERTICES(ctx, _NEW_COLOR);
 158       ctx->Color.BlendEnabled = state;
 159       /* The following needed to accomodate 1.0 RGB logic op blending */
 160       ctx->Color.ColorLogicOpEnabled =
 161          (ctx->Color.BlendEquation == GL_LOGIC_OP && state);
 162       break;
 163    case GL_CLIP_PLANE0:
 164    case GL_CLIP_PLANE1:
 165    case GL_CLIP_PLANE2:
 166    case GL_CLIP_PLANE3:
 167    case GL_CLIP_PLANE4:
 168    case GL_CLIP_PLANE5: {
 169       GLuint p = cap-GL_CLIP_PLANE0;
 170
 171       if (ctx->Transform.ClipEnabled[p] == state)
 172          return;
 173
 174       FLUSH_VERTICES(ctx, _NEW_TRANSFORM);
 175       ctx->Transform.ClipEnabled[p] = state;
 176
 177       if (state) {
 178          ctx->_Enabled |= ENABLE_USERCLIP;
 179          ctx->Transform._AnyClip++;
 180
 181          if (ctx->ProjectionMatrix.flags & MAT_DIRTY) {
 182             _math_matrix_analyse( &ctx->ProjectionMatrix );
 183          }
 184
 185          /* This derived state also calculated in clip.c and
 186           * from gl_update_state() on changes to EyeUserPlane
 187           * and ctx->ProjectionMatrix respectively.
 188           */
 189          gl_transform_vector( ctx->Transform._ClipUserPlane[p],
 190                               ctx->Transform.EyeUserPlane[p],
 191                               ctx->ProjectionMatrix.inv );
 192       } else {
 193          if (--ctx->Transform._AnyClip == 0)
 194             ctx->_Enabled &= ~ENABLE_USERCLIP;
 195       }
 196    }
 197    break;
 198    case GL_COLOR_MATERIAL:
 199       if (ctx->Light.ColorMaterialEnabled == state)
 200          return;
 201       FLUSH_VERTICES(ctx, _NEW_LIGHT);
 202       ctx->Light.ColorMaterialEnabled = state;
 203       if (state) {
 204          FLUSH_CURRENT(ctx, 0);
 205          gl_update_color_material( ctx, ctx->Current.Color );
 206       }
 207       break;
 208    case GL_CULL_FACE:
 209       if (ctx->Polygon.CullFlag == state)
 210          return;
 211       FLUSH_VERTICES(ctx, _NEW_POLYGON);
 212       ctx->Polygon.CullFlag = state;
 213       break;
 214    case GL_DEPTH_TEST:
 215       if (state && ctx->Visual.depthBits==0) {
 216          _mesa_warning(ctx,"glEnable(GL_DEPTH_TEST) but no depth buffer");
 217          return;
 218       }
 219       if (ctx->Depth.Test==state)
 220          return;
 221       FLUSH_VERTICES(ctx, _NEW_DEPTH);
 222       ctx->Depth.Test = state;
 223       break;
 224    case GL_DITHER:
 225       if (ctx->NoDither) {
 226          state = GL_FALSE; /* MESA_NO_DITHER env var */
 227       }
 228       if (ctx->Color.DitherFlag==state)
 229          return;
 230       FLUSH_VERTICES(ctx, _NEW_COLOR);
 231       ctx->Color.DitherFlag = state;
 232       break;
 233    case GL_FOG:
 234       if (ctx->Fog.Enabled==state)
 235          return;
 236       FLUSH_VERTICES(ctx, _NEW_FOG);
 237       ctx->Fog.Enabled = state;
 238       ctx->_Enabled ^= ENABLE_FOG;
 239       break;
 240    case GL_HISTOGRAM:
 241       if (!ctx->Extensions.EXT_histogram) {
 242          gl_error(ctx, GL_INVALID_ENUM, "glEnable(GL_HISTOGRAM)");
 243          return;
 244       }
 245       if (ctx->Pixel.HistogramEnabled == state)
 246          return;
 247       FLUSH_VERTICES(ctx, _NEW_PIXEL);
 248       ctx->Pixel.HistogramEnabled = state;
 249       break;
 250    case GL_LIGHT0:
 251    case GL_LIGHT1:
 252    case GL_LIGHT2:
 253    case GL_LIGHT3:
 254    case GL_LIGHT4:
 255    case GL_LIGHT5:
 256    case GL_LIGHT6:
 257    case GL_LIGHT7:
 258       if (ctx->Light.Light[cap-GL_LIGHT0].Enabled == state)
 259          return;
 260       FLUSH_VERTICES(ctx, _NEW_LIGHT);
 261       ctx->Light.Light[cap-GL_LIGHT0].Enabled = state;
 262       if (state) {
 263          insert_at_tail(&ctx->Light.EnabledList,
 264                         &ctx->Light.Light[cap-GL_LIGHT0]);
 265       }
 266       else {
 267          remove_from_list(&ctx->Light.Light[cap-GL_LIGHT0]);
 268       }
 269       break;
 270    case GL_LIGHTING:
 271       if (ctx->Light.Enabled == state)
 272          return;
 273       FLUSH_VERTICES(ctx, _NEW_LIGHT);
 274       ctx->Light.Enabled = state;
 275       ctx->_Enabled ^= ENABLE_LIGHT;
 276
 277       if ((ctx->Light.Enabled &&
 278            ctx->Light.Model.ColorControl==GL_SEPARATE_SPECULAR_COLOR)
 279           || ctx->Fog.ColorSumEnabled)
 280          ctx->_TriangleCaps |= DD_SEPERATE_SPECULAR;
 281       else
 282          ctx->_TriangleCaps &= ~DD_SEPERATE_SPECULAR;
 283
 284       break;
 285    case GL_LINE_SMOOTH:
 286       if (ctx->Line.SmoothFlag == state)
 287          return;
 288       FLUSH_VERTICES(ctx, _NEW_LINE);
 289       ctx->Line.SmoothFlag = state;
 290       ctx->_TriangleCaps ^= DD_LINE_SMOOTH;
 291       break;
 292    case GL_LINE_STIPPLE:
 293       if (ctx->Line.StippleFlag == state)
 294          return;
 295       FLUSH_VERTICES(ctx, _NEW_LINE);
 296       ctx->Line.StippleFlag = state;
 297       ctx->_TriangleCaps ^= DD_LINE_STIPPLE;
 298       break;
 299    case GL_INDEX_LOGIC_OP:
 300       if (ctx->Color.IndexLogicOpEnabled == state)
 301          return;
 302       FLUSH_VERTICES(ctx, _NEW_COLOR);
 303       ctx->Color.IndexLogicOpEnabled = state;
 304       break;
 305    case GL_COLOR_LOGIC_OP:
 306       if (ctx->Color.ColorLogicOpEnabled == state)
 307          return;
 308       FLUSH_VERTICES(ctx, _NEW_COLOR);
 309       ctx->Color.ColorLogicOpEnabled = state;
 310       break;
 311    case GL_MAP1_COLOR_4:
 312       if (ctx->Eval.Map1Color4 == state)
 313          return;
 314       FLUSH_VERTICES(ctx, _NEW_EVAL);
 315       ctx->Eval.Map1Color4 = state;
 316       break;
 317    case GL_MAP1_INDEX:
 318       if (ctx->Eval.Map1Index == state)
 319          return;
 320       FLUSH_VERTICES(ctx, _NEW_EVAL);
 321       ctx->Eval.Map1Index = state;
 322       break;
 323    case GL_MAP1_NORMAL:
 324       if (ctx->Eval.Map1Normal == state)
 325          return;
 326       FLUSH_VERTICES(ctx, _NEW_EVAL);
 327       ctx->Eval.Map1Normal = state;
 328       break;
 329    case GL_MAP1_TEXTURE_COORD_1:
 330       if (ctx->Eval.Map1TextureCoord1 == state)
 331          return;
 332       FLUSH_VERTICES(ctx, _NEW_EVAL);
 333       ctx->Eval.Map1TextureCoord1 = state;
 334       break;
 335    case GL_MAP1_TEXTURE_COORD_2:
 336       if (ctx->Eval.Map1TextureCoord2 == state)
 337          return;
 338       FLUSH_VERTICES(ctx, _NEW_EVAL);
 339       ctx->Eval.Map1TextureCoord2 = state;
 340       break;
 341    case GL_MAP1_TEXTURE_COORD_3:
 342       if (ctx->Eval.Map1TextureCoord3 == state)
 343          return;
 344       FLUSH_VERTICES(ctx, _NEW_EVAL);
 345       ctx->Eval.Map1TextureCoord3 = state;
 346       break;
 347    case GL_MAP1_TEXTURE_COORD_4:
 348       if (ctx->Eval.Map1TextureCoord4 == state)
 349          return;
 350       FLUSH_VERTICES(ctx, _NEW_EVAL);
 351       ctx->Eval.Map1TextureCoord4 = state;
 352       break;
 353    case GL_MAP1_VERTEX_3:
 354       if (ctx->Eval.Map1Vertex3 == state)
 355          return;
 356       FLUSH_VERTICES(ctx, _NEW_EVAL);
 357       ctx->Eval.Map1Vertex3 = state;
 358       break;
 359    case GL_MAP1_VERTEX_4:
 360       if (ctx->Eval.Map1Vertex4 == state)
 361          return;
 362       FLUSH_VERTICES(ctx, _NEW_EVAL);
 363       ctx->Eval.Map1Vertex4 = state;
 364       break;
 365    case GL_MAP2_COLOR_4:
 366       if (ctx->Eval.Map2Color4 == state)
 367          return;
 368       FLUSH_VERTICES(ctx, _NEW_EVAL);
 369       ctx->Eval.Map2Color4 = state;
 370       break;
 371    case GL_MAP2_INDEX:
 372       if (ctx->Eval.Map2Index == state)
 373          return;
 374       FLUSH_VERTICES(ctx, _NEW_EVAL);
 375       ctx->Eval.Map2Index = state;
 376       break;
 377    case GL_MAP2_NORMAL:
 378       if (ctx->Eval.Map2Normal == state)
 379          return;
 380       FLUSH_VERTICES(ctx, _NEW_EVAL);
 381       ctx->Eval.Map2Normal = state;
 382       break;
 383    case GL_MAP2_TEXTURE_COORD_1:
 384       if (ctx->Eval.Map2TextureCoord1 == state)
 385          return;
 386       FLUSH_VERTICES(ctx, _NEW_EVAL);
 387       ctx->Eval.Map2TextureCoord1 = state;
 388       break;
 389    case GL_MAP2_TEXTURE_COORD_2:
 390       if (ctx->Eval.Map2TextureCoord2 == state)
 391          return;
 392       FLUSH_VERTICES(ctx, _NEW_EVAL);
 393       ctx->Eval.Map2TextureCoord2 = state;
 394       break;
 395    case GL_MAP2_TEXTURE_COORD_3:
 396       if (ctx->Eval.Map2TextureCoord3 == state)
 397          return;
 398       FLUSH_VERTICES(ctx, _NEW_EVAL);
 399       ctx->Eval.Map2TextureCoord3 = state;
 400       break;
 401    case GL_MAP2_TEXTURE_COORD_4:
 402       if (ctx->Eval.Map2TextureCoord4 == state)
 403          return;
 404       FLUSH_VERTICES(ctx, _NEW_EVAL);
 405       ctx->Eval.Map2TextureCoord4 = state;
 406       break;
 407    case GL_MAP2_VERTEX_3:
 408       if (ctx->Eval.Map2Vertex3 == state)
 409          return;
 410       FLUSH_VERTICES(ctx, _NEW_EVAL);
 411       ctx->Eval.Map2Vertex3 = state;
 412       break;
 413    case GL_MAP2_VERTEX_4:
 414       if (ctx->Eval.Map2Vertex4 == state)
 415          return;
 416       FLUSH_VERTICES(ctx, _NEW_EVAL);
 417       ctx->Eval.Map2Vertex4 = state;
 418       break;
 419    case GL_MINMAX:
 420       if (ctx->Pixel.MinMaxEnabled == state)
 421          return;
 422       FLUSH_VERTICES(ctx, _NEW_PIXEL);
 423       ctx->Pixel.MinMaxEnabled = state;
 424       break;
 425    case GL_NORMALIZE:
 426       if (ctx->Transform.Normalize == state)
 427          return;
 428       FLUSH_VERTICES(ctx, _NEW_TRANSFORM);
 429       ctx->Transform.Normalize = state;
 430       ctx->_Enabled ^= ENABLE_NORMALIZE;
 431       break;
 432    case GL_POINT_SMOOTH:
 433       if (ctx->Point.SmoothFlag==state)
 434          return;
 435       FLUSH_VERTICES(ctx, _NEW_POINT);
 436       ctx->Point.SmoothFlag = state;
 437       ctx->_TriangleCaps ^= DD_POINT_SMOOTH;
 438       break;
 439    case GL_POLYGON_SMOOTH:
 440       if (ctx->Polygon.SmoothFlag==state)
 441          return;
 442       FLUSH_VERTICES(ctx, _NEW_POLYGON);
 443       ctx->Polygon.SmoothFlag = state;
 444       ctx->_TriangleCaps ^= DD_TRI_SMOOTH;
 445       break;
 446    case GL_POLYGON_STIPPLE:
 447       if (ctx->Polygon.StippleFlag==state)
 448          return;
 449       FLUSH_VERTICES(ctx, _NEW_POLYGON);
 450       ctx->Polygon.StippleFlag = state;
 451       ctx->_TriangleCaps ^= DD_TRI_STIPPLE;
 452       break;
 453    case GL_POLYGON_OFFSET_POINT:
 454       if (ctx->Polygon.OffsetPoint==state)
 455          return;
 456       FLUSH_VERTICES(ctx, _NEW_POLYGON);
 457       ctx->Polygon.OffsetPoint = state;
 458       break;
 459    case GL_POLYGON_OFFSET_LINE:
 460       if (ctx->Polygon.OffsetLine==state)
 461          return;
 462       FLUSH_VERTICES(ctx, _NEW_POLYGON);
 463       ctx->Polygon.OffsetLine = state;
 464       break;
 465    case GL_POLYGON_OFFSET_FILL:
 466       /*case GL_POLYGON_OFFSET_EXT:*/
 467       if (ctx->Polygon.OffsetFill==state)
 468          return;
 469       FLUSH_VERTICES(ctx, _NEW_POLYGON);
 470       ctx->Polygon.OffsetFill = state;
 471       break;
 472    case GL_RESCALE_NORMAL_EXT:
 473       if (ctx->Transform.RescaleNormals == state)
 474          return;
 475       FLUSH_VERTICES(ctx, _NEW_TRANSFORM);
 476       ctx->Transform.RescaleNormals = state;
 477       ctx->_Enabled ^= ENABLE_RESCALE;
 478       break;
 479    case GL_SCISSOR_TEST:
 480       if (ctx->Scissor.Enabled==state)
 481          return;
 482       FLUSH_VERTICES(ctx, _NEW_SCISSOR);
 483       ctx->Scissor.Enabled = state;
 484       break;
 485    case GL_SHARED_TEXTURE_PALETTE_EXT:
 486       if (ctx->Texture.SharedPalette == state)
 487          return;
 488       FLUSH_VERTICES(ctx, _NEW_TEXTURE);
 489       ctx->Texture.SharedPalette = state;
 490       break;
 491    case GL_STENCIL_TEST:
 492       if (state && ctx->Visual.stencilBits==0) {
 493          _mesa_warning(ctx, "glEnable(GL_STENCIL_TEST) but no stencil buffer");
 494          return;
 495       }
 496       if (ctx->Stencil.Enabled==state)
 497          return;
 498       FLUSH_VERTICES(ctx, _NEW_STENCIL);
 499       ctx->Stencil.Enabled = state;
 500       ctx->_TriangleCaps ^= DD_STENCIL;
 501       break;
 502    case GL_TEXTURE_1D: {
 503       const GLuint curr = ctx->Texture.CurrentUnit;
 504       struct gl_texture_unit *texUnit = &ctx->Texture.Unit[curr];
 505       GLuint newenabled = texUnit->Enabled & ~TEXTURE0_1D;
 506       if (state)
 507          newenabled |= TEXTURE0_1D;
 508       if (!ctx->Visual.rgbMode || texUnit->Enabled == newenabled)
 509          return;
 510       FLUSH_VERTICES(ctx, _NEW_TEXTURE);
 511       texUnit->Enabled = newenabled;
 512       break;
 513    }
 514    case GL_TEXTURE_2D: {
 515       const GLuint curr = ctx->Texture.CurrentUnit;
 516       struct gl_texture_unit *texUnit = &ctx->Texture.Unit[curr];
 517       GLuint newenabled = texUnit->Enabled & ~TEXTURE0_2D;
 518       if (state)
 519          newenabled |= TEXTURE0_2D;
 520       if (!ctx->Visual.rgbMode || texUnit->Enabled == newenabled)
 521          return;
 522       FLUSH_VERTICES(ctx, _NEW_TEXTURE);
 523       texUnit->Enabled = newenabled;
 524       break;
 525    }
 526    case GL_TEXTURE_3D: {
 527       const GLuint curr = ctx->Texture.CurrentUnit;
 528       struct gl_texture_unit *texUnit = &ctx->Texture.Unit[curr];
 529       GLuint newenabled = texUnit->Enabled & ~TEXTURE0_3D;
 530       if (state)
 531          newenabled |= TEXTURE0_3D;
 532       if (!ctx->Visual.rgbMode || texUnit->Enabled == newenabled)
 533          return;
 534       FLUSH_VERTICES(ctx, _NEW_TEXTURE);
 535       texUnit->Enabled = newenabled;
 536       break;
 537    }
 538    case GL_TEXTURE_GEN_Q: {
 539       GLuint unit = ctx->Texture.CurrentUnit;
 540       struct gl_texture_unit *texUnit = &ctx->Texture.Unit[unit];
 541       GLuint newenabled = texUnit->TexGenEnabled & ~Q_BIT;
 542       if (state)
 543          newenabled |= Q_BIT;
 544       if (texUnit->TexGenEnabled == newenabled)
 545          return;
 546       FLUSH_VERTICES(ctx, _NEW_TEXTURE);
 547       texUnit->TexGenEnabled = newenabled;
 548       break;
 549    }
 550    case GL_TEXTURE_GEN_R: {
 551       GLuint unit = ctx->Texture.CurrentUnit;
 552       struct gl_texture_unit *texUnit = &ctx->Texture.Unit[unit];
 553       GLuint newenabled = texUnit->TexGenEnabled & ~R_BIT;
 554       if (state)
 555          newenabled |= R_BIT;
 556       if (texUnit->TexGenEnabled == newenabled)
 557          return;
 558       FLUSH_VERTICES(ctx, _NEW_TEXTURE);
 559       texUnit->TexGenEnabled = newenabled;
 560       break;
 561    }
 562    break;
 563    case GL_TEXTURE_GEN_S: {
 564       GLuint unit = ctx->Texture.CurrentUnit;
 565       struct gl_texture_unit *texUnit = &ctx->Texture.Unit[unit];
 566       GLuint newenabled = texUnit->TexGenEnabled & ~S_BIT;
 567       if (state)
 568          newenabled |= S_BIT;
 569       if (texUnit->TexGenEnabled == newenabled)
 570          return;
 571       FLUSH_VERTICES(ctx, _NEW_TEXTURE);
 572       texUnit->TexGenEnabled = newenabled;
 573       break;
 574    }
 575    break;
 576    case GL_TEXTURE_GEN_T: {
 577       GLuint unit = ctx->Texture.CurrentUnit;
 578       struct gl_texture_unit *texUnit = &ctx->Texture.Unit[unit];
 579       GLuint newenabled = texUnit->TexGenEnabled & ~T_BIT;
 580       if (state)
 581          newenabled |= T_BIT;
 582       if (texUnit->TexGenEnabled == newenabled)
 583          return;
 584       FLUSH_VERTICES(ctx, _NEW_TEXTURE);
 585       texUnit->TexGenEnabled = newenabled;
 586       break;
 587    }
 588    break;
 589
 590    /*
 591     * CLIENT STATE!!!
 592     */
 593    case GL_VERTEX_ARRAY:
 594    case GL_NORMAL_ARRAY:
 595    case GL_COLOR_ARRAY:
 596    case GL_INDEX_ARRAY:
 597    case GL_TEXTURE_COORD_ARRAY:
 598    case GL_EDGE_FLAG_ARRAY:
 599    case GL_FOG_COORDINATE_ARRAY_EXT:
 600    case GL_SECONDARY_COLOR_ARRAY_EXT:
 601       client_state( ctx, cap, state );
 602       return;
 603
 604       /* GL_HP_occlusion_test */
 605    case GL_OCCLUSION_TEST_HP:
 606       if (!ctx->Extensions.HP_occlusion_test) {
 607          gl_error( ctx, GL_INVALID_ENUM, state ? "glEnable": "glDisable" );
 608          return;
 609       }
 610       if (ctx->Depth.OcclusionTest == state)
 611          return;
 612       FLUSH_VERTICES(ctx, _NEW_DEPTH);
 613       ctx->Depth.OcclusionTest = state;
 614       if (state)
 615          ctx->OcclusionResult = ctx->OcclusionResultSaved;
 616       else
 617          ctx->OcclusionResultSaved = ctx->OcclusionResult;
 618       break;
 619
 620       /* GL_SGIS_pixel_texture */
 621    case GL_PIXEL_TEXTURE_SGIS:
 622       if (!ctx->Extensions.SGIS_pixel_texture) {
 623          gl_error( ctx, GL_INVALID_ENUM, state ? "glEnable": "glDisable" );
 624          return;
 625       }
 626       if (ctx->Pixel.PixelTextureEnabled == state)
 627          return;
 628       FLUSH_VERTICES(ctx, _NEW_PIXEL);
 629       ctx->Pixel.PixelTextureEnabled = state;
 630       break;
 631
 632       /* GL_SGIX_pixel_texture */
 633    case GL_PIXEL_TEX_GEN_SGIX:
 634       if (!ctx->Extensions.SGIX_pixel_texture) {
 635          gl_error( ctx, GL_INVALID_ENUM, state ? "glEnable": "glDisable" );
 636          return;
 637       }
 638       if (ctx->Pixel.PixelTextureEnabled == state)
 639          return;
 640       FLUSH_VERTICES(ctx, _NEW_PIXEL);
 641       ctx->Pixel.PixelTextureEnabled = state;
 642       break;
 643
 644       /* GL_SGI_color_table */
 645    case GL_COLOR_TABLE_SGI:
 646       if (!ctx->Extensions.SGI_color_table) {
 647          gl_error( ctx, GL_INVALID_ENUM, state ? "glEnable": "glDisable" );
 648          return;
 649       }
 650       if (ctx->Pixel.ColorTableEnabled == state)
 651          return;
 652       FLUSH_VERTICES(ctx, _NEW_PIXEL);
 653       ctx->Pixel.ColorTableEnabled = state;
 654       break;
 655    case GL_POST_CONVOLUTION_COLOR_TABLE_SGI:
 656       if (!ctx->Extensions.SGI_color_table) {
 657          gl_error( ctx, GL_INVALID_ENUM, state ? "glEnable": "glDisable" );
 658          return;
 659       }
 660       if (ctx->Pixel.PostConvolutionColorTableEnabled == state)
 661          return;
 662       FLUSH_VERTICES(ctx, _NEW_PIXEL);
 663       ctx->Pixel.PostConvolutionColorTableEnabled = state;
 664       break;
 665    case GL_POST_COLOR_MATRIX_COLOR_TABLE_SGI:
 666       if (!ctx->Extensions.SGI_color_table) {
 667          gl_error( ctx, GL_INVALID_ENUM, state ? "glEnable": "glDisable" );
 668          return;
 669       }
 670       if (ctx->Pixel.PostColorMatrixColorTableEnabled == state)
 671          return;
 672       FLUSH_VERTICES(ctx, _NEW_PIXEL);
 673       ctx->Pixel.PostColorMatrixColorTableEnabled = state;
 674       break;
 675
 676       /* GL_EXT_convolution */
 677    case GL_CONVOLUTION_1D:
 678       if (!ctx->Extensions.EXT_convolution) {
 679          gl_error(ctx, GL_INVALID_ENUM, state ? "glEnable" : "glDisable");
 680          return;
 681       }
 682       if (ctx->Pixel.Convolution1DEnabled == state)
 683          return;
 684       FLUSH_VERTICES(ctx, _NEW_PIXEL);
 685       ctx->Pixel.Convolution1DEnabled = state;
 686       break;
 687    case GL_CONVOLUTION_2D:
 688       if (!ctx->Extensions.EXT_convolution) {
 689          gl_error(ctx, GL_INVALID_ENUM, state ? "glEnable" : "glDisable");
 690          return;
 691       }
 692       if (ctx->Pixel.Convolution2DEnabled == state)
 693          return;
 694       FLUSH_VERTICES(ctx, _NEW_PIXEL);
 695       ctx->Pixel.Convolution2DEnabled = state;
 696       break;
 697    case GL_SEPARABLE_2D:
 698       if (!ctx->Extensions.EXT_convolution) {
 699          gl_error(ctx, GL_INVALID_ENUM, state ? "glEnable" : "glDisable");
 700          return;
 701       }
 702       if (ctx->Pixel.Separable2DEnabled == state)
 703          return;
 704       FLUSH_VERTICES(ctx, _NEW_PIXEL);
 705       ctx->Pixel.Separable2DEnabled = state;
 706       break;
 707
 708       /* GL_ARB_texture_cube_map */
 709    case GL_TEXTURE_CUBE_MAP_ARB: {
 710       const GLuint curr = ctx->Texture.CurrentUnit;
 711       struct gl_texture_unit *texUnit = &ctx->Texture.Unit[curr];
 712       GLuint newenabled = texUnit->Enabled & ~TEXTURE0_CUBE;
 713       if (state)
 714          newenabled |= TEXTURE0_CUBE;
 715       if (!ctx->Extensions.ARB_texture_cube_map) {
 716          gl_error(ctx, GL_INVALID_ENUM, state ? "glEnable" : "glDisable");
 717          return;
 718       }
 719       if (!ctx->Visual.rgbMode || texUnit->Enabled == newenabled)
 720          return;
 721       FLUSH_VERTICES(ctx, _NEW_TEXTURE);
 722       texUnit->Enabled = newenabled;
 723       break;
 724    }
 725       /* GL_EXT_secondary_color */
 726    case GL_COLOR_SUM_EXT:
 727       if (!ctx->Extensions.EXT_secondary_color) {
 728          gl_error(ctx, GL_INVALID_ENUM, state ? "glEnable" : "glDisable");
 729          return;
 730       }
 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_SEPERATE_SPECULAR;
 740       else
 741          ctx->_TriangleCaps &= ~DD_SEPERATE_SPECULAR;
 742
 743       break;
 744
 745       /* GL_MESA_sprite_point */
 746    case GL_SPRITE_POINT_MESA:
 747       if (!ctx->Extensions.MESA_sprite_point) {
 748          gl_error(ctx, GL_INVALID_ENUM, state ? "glEnable" : "glDisable");
 749          return;
 750       }
 751       if (ctx->Point.SpriteMode == state)
 752          return;
 753       FLUSH_VERTICES(ctx, _NEW_POINT);
 754       ctx->Point.SpriteMode = state;
 755       break;
 756
 757    default:
 758       gl_error(ctx, GL_INVALID_ENUM, state ? "glEnable" : "glDisable");
 759       return;
 760    }
 761
 762    if (ctx->Driver.Enable) {
 763       (*ctx->Driver.Enable)( ctx, cap, state );
 764    }
 765 }
 766
 767
 768
 769
 770 void
 771 _mesa_Enable( GLenum cap )
 772 {
 773    GET_CURRENT_CONTEXT(ctx);
 774    ASSERT_OUTSIDE_BEGIN_END(ctx);
 775
 776    _mesa_set_enable( ctx, cap, GL_TRUE );
 777 }
 778
 779
 780
 781 void
 782 _mesa_Disable( GLenum cap )
 783 {
 784    GET_CURRENT_CONTEXT(ctx);
 785    ASSERT_OUTSIDE_BEGIN_END(ctx);
 786
 787    _mesa_set_enable( ctx, cap, GL_FALSE );
 788 }
 789
 790
 791
 792 GLboolean
 793 _mesa_IsEnabled( GLenum cap )
 794 {
 795    GET_CURRENT_CONTEXT(ctx);
 796    switch (cap) {
 797       case GL_ALPHA_TEST:
 798          return ctx->Color.AlphaEnabled;
 799       case GL_AUTO_NORMAL:
 800          return ctx->Eval.AutoNormal;
 801       case GL_BLEND:
 802          return ctx->Color.BlendEnabled;
 803       case GL_CLIP_PLANE0:
 804       case GL_CLIP_PLANE1:
 805       case GL_CLIP_PLANE2:
 806       case GL_CLIP_PLANE3:
 807       case GL_CLIP_PLANE4:
 808       case GL_CLIP_PLANE5:
 809          return ctx->Transform.ClipEnabled[cap-GL_CLIP_PLANE0];
 810       case GL_COLOR_MATERIAL:
 811          return ctx->Light.ColorMaterialEnabled;
 812       case GL_CULL_FACE:
 813          return ctx->Polygon.CullFlag;
 814       case GL_DEPTH_TEST:
 815          return ctx->Depth.Test;
 816       case GL_DITHER:
 817          return ctx->Color.DitherFlag;
 818       case GL_FOG:
 819          return ctx->Fog.Enabled;
 820       case GL_HISTOGRAM:
 821          if (ctx->Extensions.EXT_histogram) {
 822             return ctx->Pixel.HistogramEnabled;
 823          }
 824          else {
 825             gl_error(ctx, GL_INVALID_ENUM, "glIsEnabled");
 826             return GL_FALSE;
 827          }
 828       case GL_LIGHTING:
 829          return ctx->Light.Enabled;
 830       case GL_LIGHT0:
 831       case GL_LIGHT1:
 832       case GL_LIGHT2:
 833       case GL_LIGHT3:
 834       case GL_LIGHT4:
 835       case GL_LIGHT5:
 836       case GL_LIGHT6:
 837       case GL_LIGHT7:
 838          return ctx->Light.Light[cap-GL_LIGHT0].Enabled;
 839       case GL_LINE_SMOOTH:
 840          return ctx->Line.SmoothFlag;
 841       case GL_LINE_STIPPLE:
 842          return ctx->Line.StippleFlag;
 843       case GL_INDEX_LOGIC_OP:
 844          return ctx->Color.IndexLogicOpEnabled;
 845       case GL_COLOR_LOGIC_OP:
 846          return ctx->Color.ColorLogicOpEnabled;
 847       case GL_MAP1_COLOR_4:
 848          return ctx->Eval.Map1Color4;
 849       case GL_MAP1_INDEX:
 850          return ctx->Eval.Map1Index;
 851       case GL_MAP1_NORMAL:
 852          return ctx->Eval.Map1Normal;
 853       case GL_MAP1_TEXTURE_COORD_1:
 854          return ctx->Eval.Map1TextureCoord1;
 855       case GL_MAP1_TEXTURE_COORD_2:
 856          return ctx->Eval.Map1TextureCoord2;
 857       case GL_MAP1_TEXTURE_COORD_3:
 858          return ctx->Eval.Map1TextureCoord3;
 859       case GL_MAP1_TEXTURE_COORD_4:
 860          return ctx->Eval.Map1TextureCoord4;
 861       case GL_MAP1_VERTEX_3:
 862          return ctx->Eval.Map1Vertex3;
 863       case GL_MAP1_VERTEX_4:
 864          return ctx->Eval.Map1Vertex4;
 865       case GL_MAP2_COLOR_4:
 866          return ctx->Eval.Map2Color4;
 867       case GL_MAP2_INDEX:
 868          return ctx->Eval.Map2Index;
 869       case GL_MAP2_NORMAL:
 870          return ctx->Eval.Map2Normal;
 871       case GL_MAP2_TEXTURE_COORD_1:
 872          return ctx->Eval.Map2TextureCoord1;
 873       case GL_MAP2_TEXTURE_COORD_2:
 874          return ctx->Eval.Map2TextureCoord2;
 875       case GL_MAP2_TEXTURE_COORD_3:
 876          return ctx->Eval.Map2TextureCoord3;
 877       case GL_MAP2_TEXTURE_COORD_4:
 878          return ctx->Eval.Map2TextureCoord4;
 879       case GL_MAP2_VERTEX_3:
 880          return ctx->Eval.Map2Vertex3;
 881       case GL_MAP2_VERTEX_4:
 882          return ctx->Eval.Map2Vertex4;
 883       case GL_MINMAX:
 884          return ctx->Pixel.MinMaxEnabled;
 885       case GL_NORMALIZE:
 886          return ctx->Transform.Normalize;
 887       case GL_POINT_SMOOTH:
 888          return ctx->Point.SmoothFlag;
 889       case GL_POLYGON_SMOOTH:
 890          return ctx->Polygon.SmoothFlag;
 891       case GL_POLYGON_STIPPLE:
 892          return ctx->Polygon.StippleFlag;
 893       case GL_POLYGON_OFFSET_POINT:
 894          return ctx->Polygon.OffsetPoint;
 895       case GL_POLYGON_OFFSET_LINE:
 896          return ctx->Polygon.OffsetLine;
 897       case GL_POLYGON_OFFSET_FILL:
 898       /*case GL_POLYGON_OFFSET_EXT:*/
 899          return ctx->Polygon.OffsetFill;
 900       case GL_RESCALE_NORMAL_EXT:
 901          return ctx->Transform.RescaleNormals;
 902       case GL_SCISSOR_TEST:
 903          return ctx->Scissor.Enabled;
 904       case GL_SHARED_TEXTURE_PALETTE_EXT:
 905          return ctx->Texture.SharedPalette;
 906       case GL_STENCIL_TEST:
 907          return ctx->Stencil.Enabled;
 908       case GL_TEXTURE_1D:
 909          {
 910             const struct gl_texture_unit *texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
 911             return (texUnit->Enabled & TEXTURE0_1D) ? GL_TRUE : GL_FALSE;
 912          }
 913       case GL_TEXTURE_2D:
 914          {
 915             const struct gl_texture_unit *texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
 916             return (texUnit->Enabled & TEXTURE0_2D) ? GL_TRUE : GL_FALSE;
 917          }
 918       case GL_TEXTURE_3D:
 919          {
 920             const struct gl_texture_unit *texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
 921             return (texUnit->Enabled & TEXTURE0_3D) ? GL_TRUE : GL_FALSE;
 922          }
 923       case GL_TEXTURE_GEN_Q:
 924          {
 925             const struct gl_texture_unit *texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
 926             return (texUnit->TexGenEnabled & Q_BIT) ? GL_TRUE : GL_FALSE;
 927          }
 928       case GL_TEXTURE_GEN_R:
 929          {
 930             const struct gl_texture_unit *texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
 931             return (texUnit->TexGenEnabled & R_BIT) ? GL_TRUE : GL_FALSE;
 932          }
 933       case GL_TEXTURE_GEN_S:
 934          {
 935             const struct gl_texture_unit *texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
 936             return (texUnit->TexGenEnabled & S_BIT) ? GL_TRUE : GL_FALSE;
 937          }
 938       case GL_TEXTURE_GEN_T:
 939          {
 940             const struct gl_texture_unit *texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
 941             return (texUnit->TexGenEnabled & T_BIT) ? GL_TRUE : GL_FALSE;
 942          }
 943
 944       /*
 945        * CLIENT STATE!!!
 946        */
 947       case GL_VERTEX_ARRAY:
 948          return ctx->Array.Vertex.Enabled;
 949       case GL_NORMAL_ARRAY:
 950          return ctx->Array.Normal.Enabled;
 951       case GL_COLOR_ARRAY:
 952          return ctx->Array.Color.Enabled;
 953       case GL_INDEX_ARRAY:
 954          return ctx->Array.Index.Enabled;
 955       case GL_TEXTURE_COORD_ARRAY:
 956          return ctx->Array.TexCoord[ctx->Array.ActiveTexture].Enabled;
 957       case GL_EDGE_FLAG_ARRAY:
 958          return ctx->Array.EdgeFlag.Enabled;
 959
 960       /* GL_HP_occlusion_test */
 961       case GL_OCCLUSION_TEST_HP:
 962          if (ctx->Extensions.HP_occlusion_test) {
 963             return ctx->Depth.OcclusionTest;
 964          }
 965          else {
 966             gl_error( ctx, GL_INVALID_ENUM, "glIsEnabled" );
 967             return GL_FALSE;
 968          }
 969
 970       /* GL_SGIS_pixel_texture */
 971       case GL_PIXEL_TEXTURE_SGIS:
 972          return ctx->Pixel.PixelTextureEnabled;
 973
 974       /* GL_SGIX_pixel_texture */
 975       case GL_PIXEL_TEX_GEN_SGIX:
 976          return ctx->Pixel.PixelTextureEnabled;
 977
 978       /* GL_SGI_color_table */
 979       case GL_COLOR_TABLE_SGI:
 980          return ctx->Pixel.ColorTableEnabled;
 981       case GL_POST_CONVOLUTION_COLOR_TABLE_SGI:
 982          return ctx->Pixel.PostConvolutionColorTableEnabled;
 983       case GL_POST_COLOR_MATRIX_COLOR_TABLE_SGI:
 984          return ctx->Pixel.PostColorMatrixColorTableEnabled;
 985
 986       /* GL_EXT_convolution */
 987       case GL_CONVOLUTION_1D:
 988          return ctx->Pixel.Convolution1DEnabled;
 989       case GL_CONVOLUTION_2D:
 990          return ctx->Pixel.Convolution2DEnabled;
 991       case GL_SEPARABLE_2D:
 992          return ctx->Pixel.Separable2DEnabled;
 993
 994       /* GL_ARB_texture_cube_map */
 995       case GL_TEXTURE_CUBE_MAP_ARB:
 996          if (ctx->Extensions.ARB_texture_cube_map) {
 997             const struct gl_texture_unit *texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
 998             return (texUnit->Enabled & TEXTURE0_CUBE) ? GL_TRUE : GL_FALSE;
 999          }
1000          else {
1001             gl_error(ctx, GL_INVALID_ENUM, "glIsEnabled");
1002             return GL_FALSE;
1003          }
1004
1005       /* GL_MESA_sprite_point */
1006       case GL_SPRITE_POINT_MESA:
1007          return ctx->Point.SpriteMode;
1008
1009       default:
1010          gl_error( ctx, GL_INVALID_ENUM, "glIsEnabled" );
1011          return GL_FALSE;
1012    }
1013 }
1014
1015
1016
1017
1018
1019
1020