src/mesa/main/enable.c

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