src/mesa/main/enable.c

   1 /* $Id: enable.c,v 1.2 1999/08/19 13:24:27 brianp Exp $ */
   2
   3 /*
   4  * Mesa 3-D graphics library
   5  * Version:  3.1
   6  *
   7  * Copyright (C) 1999  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 <string.h>
  32 #include <stdio.h>
  33 #include "context.h"
  34 #include "enable.h"
  35 #include "light.h"
  36 #include "macros.h"
  37 #include "matrix.h"
  38 #include "mmath.h"
  39 #include "simple_list.h"
  40 #include "types.h"
  41 #include "vbfill.h"
  42 #include "xform.h"
  43 #include "enums.h"
  44 #ifdef XFree86Server
  45 #include "GL/xf86glx.h"
  46 #endif
  47 #endif
  48
  49
  50
  51 /*
  52  * Perform glEnable and glDisable calls.
  53  */
  54 void gl_set_enable( GLcontext *ctx, GLenum cap, GLboolean state )
  55 {
  56    ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH( ctx, "gl_enable/disable" );
  57
  58    if (MESA_VERBOSE & VERBOSE_API)
  59       fprintf(stderr, "%s %s (%x)\n",
  60               state ? "glEnable" : "glDisable",
  61               gl_lookup_enum_by_nr(cap),
  62               ctx->NewState);
  63
  64    switch (cap) {
  65       case GL_ALPHA_TEST:
  66          if (ctx->Color.AlphaEnabled!=state) {
  67             ctx->Color.AlphaEnabled = state;
  68             ctx->NewState |= NEW_RASTER_OPS;
  69          }
  70          break;
  71       case GL_AUTO_NORMAL:
  72          ctx->Eval.AutoNormal = state;
  73          break;
  74       case GL_BLEND:
  75          if (ctx->Color.BlendEnabled!=state) {
  76             ctx->Color.BlendEnabled = state;
  77             /* The following needed to accomodate 1.0 RGB logic op blending */
  78             if (ctx->Color.BlendEquation==GL_LOGIC_OP && state) {
  79                ctx->Color.ColorLogicOpEnabled = GL_TRUE;
  80             }
  81             else {
  82                ctx->Color.ColorLogicOpEnabled = GL_FALSE;
  83             }
  84             ctx->NewState |= NEW_RASTER_OPS;
  85          }
  86          break;
  87       case GL_CLIP_PLANE0:
  88       case GL_CLIP_PLANE1:
  89       case GL_CLIP_PLANE2:
  90       case GL_CLIP_PLANE3:
  91       case GL_CLIP_PLANE4:
  92       case GL_CLIP_PLANE5:
  93          if (cap >= GL_CLIP_PLANE0 &&
  94              cap <= GL_CLIP_PLANE5 &&
  95              ctx->Transform.ClipEnabled[cap-GL_CLIP_PLANE0] != state)
  96          {
  97             GLuint p = cap-GL_CLIP_PLANE0;
  98
  99             ctx->Transform.ClipEnabled[p] = state;
 100             ctx->NewState |= NEW_USER_CLIP;
 101
 102             if (state) {
 103                ctx->Enabled |= ENABLE_USERCLIP;
 104                ctx->Transform.AnyClip++;
 105
 106                if (ctx->ProjectionMatrix.flags & MAT_DIRTY_ALL_OVER) {
 107                   gl_matrix_analyze( &ctx->ProjectionMatrix );
 108                }
 109
 110                gl_transform_vector( ctx->Transform.ClipUserPlane[p],
 111                                     ctx->Transform.EyeUserPlane[p],
 112                                     ctx->ProjectionMatrix.inv );
 113             } else {
 114                if (--ctx->Transform.AnyClip == 0)
 115                   ctx->Enabled &= ~ENABLE_USERCLIP;
 116             }
 117          }
 118          break;
 119       case GL_COLOR_MATERIAL:
 120          if (ctx->Light.ColorMaterialEnabled!=state) {
 121             ctx->Light.ColorMaterialEnabled = state;
 122             ctx->NewState |= NEW_LIGHTING;
 123          }
 124          break;
 125       case GL_CULL_FACE:
 126          if (ctx->Polygon.CullFlag!=state) {
 127             ctx->Polygon.CullFlag = state;
 128             ctx->TriangleCaps ^= DD_TRI_CULL;
 129             ctx->NewState |= NEW_POLYGON;
 130          }
 131          break;
 132       case GL_DEPTH_TEST:
 133          if (state && ctx->Visual->DepthBits==0) {
 134             gl_warning(ctx,"glEnable(GL_DEPTH_TEST) but no depth buffer");
 135             return;
 136          }
 137          if (ctx->Depth.Test!=state) {
 138             ctx->Depth.Test = state;
 139             ctx->NewState |= NEW_RASTER_OPS;
 140          }
 141          break;
 142       case GL_DITHER:
 143          if (ctx->NoDither) {
 144             /* MESA_NO_DITHER env var */
 145             state = GL_FALSE;
 146          }
 147          if (ctx->Color.DitherFlag!=state) {
 148             ctx->Color.DitherFlag = state;
 149             ctx->NewState |= NEW_RASTER_OPS;
 150          }
 151          break;
 152       case GL_FOG:
 153          if (ctx->Fog.Enabled!=state) {
 154             ctx->Fog.Enabled = state;
 155             ctx->Enabled ^= ENABLE_FOG;
 156             ctx->NewState |= NEW_FOG;
 157          }
 158          break;
 159       case GL_LIGHT0:
 160       case GL_LIGHT1:
 161       case GL_LIGHT2:
 162       case GL_LIGHT3:
 163       case GL_LIGHT4:
 164       case GL_LIGHT5:
 165       case GL_LIGHT6:
 166       case GL_LIGHT7:
 167          if (ctx->Light.Light[cap-GL_LIGHT0].Enabled != state)
 168          {
 169             ctx->Light.Light[cap-GL_LIGHT0].Enabled = state;
 170
 171             if (state) {
 172                insert_at_tail(&ctx->Light.EnabledList,
 173                               &ctx->Light.Light[cap-GL_LIGHT0]);
 174                if (ctx->Light.Enabled)
 175                   ctx->Enabled |= ENABLE_LIGHT;
 176             } else {
 177                remove_from_list(&ctx->Light.Light[cap-GL_LIGHT0]);
 178                if (is_empty_list(&ctx->Light.EnabledList))
 179                   ctx->Enabled &= ~ENABLE_LIGHT;
 180             }
 181
 182             ctx->NewState |= NEW_LIGHTING;
 183          }
 184          break;
 185       case GL_LIGHTING:
 186          if (ctx->Light.Enabled!=state) {
 187             ctx->Light.Enabled = state;
 188             ctx->Enabled &= ~ENABLE_LIGHT;
 189             if (state && !is_empty_list(&ctx->Light.EnabledList))
 190                ctx->Enabled |= ENABLE_LIGHT;
 191             ctx->NewState |= NEW_LIGHTING;
 192          }
 193          break;
 194       case GL_LINE_SMOOTH:
 195          if (ctx->Line.SmoothFlag!=state) {
 196             ctx->Line.SmoothFlag = state;
 197             ctx->NewState |= NEW_RASTER_OPS;
 198          }
 199          break;
 200       case GL_LINE_STIPPLE:
 201          if (ctx->Line.StippleFlag!=state) {
 202             ctx->Line.StippleFlag = state;
 203             ctx->TriangleCaps ^= DD_LINE_STIPPLE;
 204             ctx->NewState |= NEW_RASTER_OPS;
 205          }
 206          break;
 207       case GL_INDEX_LOGIC_OP:
 208          if (ctx->Color.IndexLogicOpEnabled!=state) {
 209             ctx->Color.IndexLogicOpEnabled = state;
 210             ctx->NewState |= NEW_RASTER_OPS;
 211          }
 212          break;
 213       case GL_COLOR_LOGIC_OP:
 214          if (ctx->Color.ColorLogicOpEnabled!=state) {
 215             ctx->Color.ColorLogicOpEnabled = state;
 216             ctx->NewState |= NEW_RASTER_OPS;
 217          }
 218          break;
 219       case GL_MAP1_COLOR_4:
 220          ctx->Eval.Map1Color4 = state;
 221          break;
 222       case GL_MAP1_INDEX:
 223          ctx->Eval.Map1Index = state;
 224          break;
 225       case GL_MAP1_NORMAL:
 226          ctx->Eval.Map1Normal = state;
 227          break;
 228       case GL_MAP1_TEXTURE_COORD_1:
 229          ctx->Eval.Map1TextureCoord1 = state;
 230          break;
 231       case GL_MAP1_TEXTURE_COORD_2:
 232          ctx->Eval.Map1TextureCoord2 = state;
 233          break;
 234       case GL_MAP1_TEXTURE_COORD_3:
 235          ctx->Eval.Map1TextureCoord3 = state;
 236          break;
 237       case GL_MAP1_TEXTURE_COORD_4:
 238          ctx->Eval.Map1TextureCoord4 = state;
 239          break;
 240       case GL_MAP1_VERTEX_3:
 241          ctx->Eval.Map1Vertex3 = state;
 242          break;
 243       case GL_MAP1_VERTEX_4:
 244          ctx->Eval.Map1Vertex4 = state;
 245          break;
 246       case GL_MAP2_COLOR_4:
 247          ctx->Eval.Map2Color4 = state;
 248          break;
 249       case GL_MAP2_INDEX:
 250          ctx->Eval.Map2Index = state;
 251          break;
 252       case GL_MAP2_NORMAL:
 253          ctx->Eval.Map2Normal = state;
 254          break;
 255       case GL_MAP2_TEXTURE_COORD_1:
 256          ctx->Eval.Map2TextureCoord1 = state;
 257          break;
 258       case GL_MAP2_TEXTURE_COORD_2:
 259          ctx->Eval.Map2TextureCoord2 = state;
 260          break;
 261       case GL_MAP2_TEXTURE_COORD_3:
 262          ctx->Eval.Map2TextureCoord3 = state;
 263          break;
 264       case GL_MAP2_TEXTURE_COORD_4:
 265          ctx->Eval.Map2TextureCoord4 = state;
 266          break;
 267       case GL_MAP2_VERTEX_3:
 268          ctx->Eval.Map2Vertex3 = state;
 269          break;
 270       case GL_MAP2_VERTEX_4:
 271          ctx->Eval.Map2Vertex4 = state;
 272          break;
 273       case GL_NORMALIZE:
 274          if (ctx->Transform.Normalize != state) {
 275             ctx->Transform.Normalize = state;
 276             ctx->NewState |= NEW_NORMAL_TRANSFORM|NEW_LIGHTING;
 277             ctx->Enabled ^= ENABLE_NORMALIZE;
 278          }
 279          break;
 280       case GL_POINT_SMOOTH:
 281          if (ctx->Point.SmoothFlag!=state) {
 282             ctx->Point.SmoothFlag = state;
 283             ctx->NewState |= NEW_RASTER_OPS;
 284          }
 285          break;
 286       case GL_POLYGON_SMOOTH:
 287          if (ctx->Polygon.SmoothFlag!=state) {
 288             ctx->Polygon.SmoothFlag = state;
 289             ctx->NewState |= NEW_RASTER_OPS;
 290          }
 291          break;
 292       case GL_POLYGON_STIPPLE:
 293          if (ctx->Polygon.StippleFlag!=state) {
 294             ctx->Polygon.StippleFlag = state;
 295             ctx->TriangleCaps ^= DD_TRI_STIPPLE;
 296             ctx->NewState |= NEW_RASTER_OPS;
 297          }
 298          break;
 299       case GL_POLYGON_OFFSET_POINT:
 300          if (ctx->Polygon.OffsetPoint!=state) {
 301             ctx->Polygon.OffsetPoint = state;
 302             ctx->NewState |= NEW_POLYGON;
 303          }
 304          break;
 305       case GL_POLYGON_OFFSET_LINE:
 306          if (ctx->Polygon.OffsetLine!=state) {
 307             ctx->Polygon.OffsetLine = state;
 308             ctx->NewState |= NEW_POLYGON;
 309          }
 310          break;
 311       case GL_POLYGON_OFFSET_FILL:
 312       /*case GL_POLYGON_OFFSET_EXT:*/
 313          if (ctx->Polygon.OffsetFill!=state) {
 314             ctx->Polygon.OffsetFill = state;
 315             ctx->NewState |= NEW_POLYGON;
 316          }
 317          break;
 318       case GL_RESCALE_NORMAL_EXT:
 319          if (ctx->Transform.RescaleNormals != state) {
 320             ctx->Transform.RescaleNormals = state;
 321             ctx->NewState |= NEW_NORMAL_TRANSFORM|NEW_LIGHTING;
 322             ctx->Enabled ^= ENABLE_RESCALE;
 323          }
 324          break;
 325       case GL_SCISSOR_TEST:
 326          if (ctx->Scissor.Enabled!=state) {
 327             ctx->Scissor.Enabled = state;
 328             ctx->NewState |= NEW_RASTER_OPS;
 329          }
 330          break;
 331       case GL_SHARED_TEXTURE_PALETTE_EXT:
 332          ctx->Texture.SharedPalette = state;
 333          if (ctx->Driver.UseGlobalTexturePalette)
 334             (*ctx->Driver.UseGlobalTexturePalette)( ctx, state );
 335          break;
 336       case GL_STENCIL_TEST:
 337          if (state && ctx->Visual->StencilBits==0) {
 338             gl_warning(ctx, "glEnable(GL_STENCIL_TEST) but no stencil buffer");
 339             return;
 340          }
 341          if (ctx->Stencil.Enabled!=state) {
 342             ctx->Stencil.Enabled = state;
 343             ctx->NewState |= NEW_RASTER_OPS;
 344          }
 345          break;
 346       case GL_TEXTURE_1D:
 347          if (ctx->Visual->RGBAflag) {
 348             const GLuint curr = ctx->Texture.CurrentUnit;
 349             const GLuint flag = TEXTURE0_1D << (curr * 4);
 350             struct gl_texture_unit *texUnit = &ctx->Texture.Unit[curr];
 351             ctx->NewState |= NEW_TEXTURE_ENABLE;
 352             if (state) {
 353                texUnit->Enabled |= TEXTURE0_1D;
 354                ctx->Enabled |= flag;
 355             }
 356             else {
 357                texUnit->Enabled &= ~TEXTURE0_1D;
 358                ctx->Enabled &= ~flag;
 359             }
 360          }
 361          break;
 362       case GL_TEXTURE_2D:
 363          if (ctx->Visual->RGBAflag) {
 364             const GLuint curr = ctx->Texture.CurrentUnit;
 365             const GLuint flag = TEXTURE0_2D << (curr * 4);
 366             struct gl_texture_unit *texUnit = &ctx->Texture.Unit[curr];
 367             ctx->NewState |= NEW_TEXTURE_ENABLE;
 368             if (state) {
 369                texUnit->Enabled |= TEXTURE0_2D;
 370                ctx->Enabled |= flag;
 371             }
 372             else {
 373                texUnit->Enabled &= ~TEXTURE0_2D;
 374                ctx->Enabled &= ~flag;
 375             }
 376          }
 377          break;
 378       case GL_TEXTURE_3D:
 379          if (ctx->Visual->RGBAflag) {
 380             const GLuint curr = ctx->Texture.CurrentUnit;
 381             const GLuint flag = TEXTURE0_3D << (curr * 4);
 382             struct gl_texture_unit *texUnit = &ctx->Texture.Unit[curr];
 383             ctx->NewState |= NEW_TEXTURE_ENABLE;
 384             if (state) {
 385                texUnit->Enabled |= TEXTURE0_3D;
 386                ctx->Enabled |= flag;
 387             }
 388             else {
 389                texUnit->Enabled &= ~TEXTURE0_3D;
 390                ctx->Enabled &= ~flag;
 391             }
 392          }
 393          break;
 394       case GL_TEXTURE_GEN_Q:
 395          {
 396             struct gl_texture_unit *texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
 397             if (state)
 398                texUnit->TexGenEnabled |= Q_BIT;
 399             else
 400                texUnit->TexGenEnabled &= ~Q_BIT;
 401             ctx->NewState |= NEW_TEXTURING;
 402          }
 403          break;
 404       case GL_TEXTURE_GEN_R:
 405          {
 406             struct gl_texture_unit *texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
 407             if (state)
 408                texUnit->TexGenEnabled |= R_BIT;
 409             else
 410                texUnit->TexGenEnabled &= ~R_BIT;
 411             ctx->NewState |= NEW_TEXTURING;
 412          }
 413          break;
 414       case GL_TEXTURE_GEN_S:
 415          {
 416             struct gl_texture_unit *texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
 417             if (state)
 418                texUnit->TexGenEnabled |= S_BIT;
 419             else
 420                texUnit->TexGenEnabled &= ~S_BIT;
 421             ctx->NewState |= NEW_TEXTURING;
 422          }
 423          break;
 424       case GL_TEXTURE_GEN_T:
 425          {
 426             struct gl_texture_unit *texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
 427             if (state)
 428                texUnit->TexGenEnabled |= T_BIT;
 429             else
 430                texUnit->TexGenEnabled &= ~T_BIT;
 431             ctx->NewState |= NEW_TEXTURING;
 432          }
 433          break;
 434
 435       /*
 436        * CLIENT STATE!!!
 437        */
 438       case GL_VERTEX_ARRAY:
 439          ctx->Array.Vertex.Enabled = state;
 440          break;
 441       case GL_NORMAL_ARRAY:
 442          ctx->Array.Normal.Enabled = state;
 443          break;
 444       case GL_COLOR_ARRAY:
 445          ctx->Array.Color.Enabled = state;
 446          break;
 447       case GL_INDEX_ARRAY:
 448          ctx->Array.Index.Enabled = state;
 449          break;
 450       case GL_TEXTURE_COORD_ARRAY:
 451          ctx->Array.TexCoord[ctx->TexCoordUnit].Enabled = state;
 452          break;
 453       case GL_EDGE_FLAG_ARRAY:
 454          ctx->Array.EdgeFlag.Enabled = state;
 455          break;
 456
 457       default:
 458          if (state) {
 459             gl_error( ctx, GL_INVALID_ENUM, "glEnable" );
 460          }
 461          else {
 462             gl_error( ctx, GL_INVALID_ENUM, "glDisable" );
 463          }
 464          return;
 465    }
 466
 467    if (ctx->Driver.Enable) {
 468       (*ctx->Driver.Enable)( ctx, cap, state );
 469    }
 470 }
 471
 472
 473
 474
 475 void gl_Enable( GLcontext* ctx, GLenum cap )
 476 {
 477    gl_set_enable( ctx, cap, GL_TRUE );
 478 }
 479
 480
 481
 482 void gl_Disable( GLcontext* ctx, GLenum cap )
 483 {
 484    gl_set_enable( ctx, cap, GL_FALSE );
 485 }
 486
 487
 488
 489 GLboolean gl_IsEnabled( GLcontext* ctx, GLenum cap )
 490 {
 491    switch (cap) {
 492       case GL_ALPHA_TEST:
 493          return ctx->Color.AlphaEnabled;
 494       case GL_AUTO_NORMAL:
 495          return ctx->Eval.AutoNormal;
 496       case GL_BLEND:
 497          return ctx->Color.BlendEnabled;
 498       case GL_CLIP_PLANE0:
 499       case GL_CLIP_PLANE1:
 500       case GL_CLIP_PLANE2:
 501       case GL_CLIP_PLANE3:
 502       case GL_CLIP_PLANE4:
 503       case GL_CLIP_PLANE5:
 504          return ctx->Transform.ClipEnabled[cap-GL_CLIP_PLANE0];
 505       case GL_COLOR_MATERIAL:
 506          return ctx->Light.ColorMaterialEnabled;
 507       case GL_CULL_FACE:
 508          return ctx->Polygon.CullFlag;
 509       case GL_DEPTH_TEST:
 510          return ctx->Depth.Test;
 511       case GL_DITHER:
 512          return ctx->Color.DitherFlag;
 513       case GL_FOG:
 514          return ctx->Fog.Enabled;
 515       case GL_LIGHTING:
 516          return ctx->Light.Enabled;
 517       case GL_LIGHT0:
 518       case GL_LIGHT1:
 519       case GL_LIGHT2:
 520       case GL_LIGHT3:
 521       case GL_LIGHT4:
 522       case GL_LIGHT5:
 523       case GL_LIGHT6:
 524       case GL_LIGHT7:
 525          return ctx->Light.Light[cap-GL_LIGHT0].Enabled;
 526       case GL_LINE_SMOOTH:
 527          return ctx->Line.SmoothFlag;
 528       case GL_LINE_STIPPLE:
 529          return ctx->Line.StippleFlag;
 530       case GL_INDEX_LOGIC_OP:
 531          return ctx->Color.IndexLogicOpEnabled;
 532       case GL_COLOR_LOGIC_OP:
 533          return ctx->Color.ColorLogicOpEnabled;
 534       case GL_MAP1_COLOR_4:
 535          return ctx->Eval.Map1Color4;
 536       case GL_MAP1_INDEX:
 537          return ctx->Eval.Map1Index;
 538       case GL_MAP1_NORMAL:
 539          return ctx->Eval.Map1Normal;
 540       case GL_MAP1_TEXTURE_COORD_1:
 541          return ctx->Eval.Map1TextureCoord1;
 542       case GL_MAP1_TEXTURE_COORD_2:
 543          return ctx->Eval.Map1TextureCoord2;
 544       case GL_MAP1_TEXTURE_COORD_3:
 545          return ctx->Eval.Map1TextureCoord3;
 546       case GL_MAP1_TEXTURE_COORD_4:
 547          return ctx->Eval.Map1TextureCoord4;
 548       case GL_MAP1_VERTEX_3:
 549          return ctx->Eval.Map1Vertex3;
 550       case GL_MAP1_VERTEX_4:
 551          return ctx->Eval.Map1Vertex4;
 552       case GL_MAP2_COLOR_4:
 553          return ctx->Eval.Map2Color4;
 554       case GL_MAP2_INDEX:
 555          return ctx->Eval.Map2Index;
 556       case GL_MAP2_NORMAL:
 557          return ctx->Eval.Map2Normal;
 558       case GL_MAP2_TEXTURE_COORD_1:
 559          return ctx->Eval.Map2TextureCoord1;
 560       case GL_MAP2_TEXTURE_COORD_2:
 561          return ctx->Eval.Map2TextureCoord2;
 562       case GL_MAP2_TEXTURE_COORD_3:
 563          return ctx->Eval.Map2TextureCoord3;
 564       case GL_MAP2_TEXTURE_COORD_4:
 565          return ctx->Eval.Map2TextureCoord4;
 566       case GL_MAP2_VERTEX_3:
 567          return ctx->Eval.Map2Vertex3;
 568       case GL_MAP2_VERTEX_4:
 569          return ctx->Eval.Map2Vertex4;
 570       case GL_NORMALIZE:
 571          return ctx->Transform.Normalize;
 572       case GL_POINT_SMOOTH:
 573          return ctx->Point.SmoothFlag;
 574       case GL_POLYGON_SMOOTH:
 575          return ctx->Polygon.SmoothFlag;
 576       case GL_POLYGON_STIPPLE:
 577          return ctx->Polygon.StippleFlag;
 578       case GL_POLYGON_OFFSET_POINT:
 579          return ctx->Polygon.OffsetPoint;
 580       case GL_POLYGON_OFFSET_LINE:
 581          return ctx->Polygon.OffsetLine;
 582       case GL_POLYGON_OFFSET_FILL:
 583       /*case GL_POLYGON_OFFSET_EXT:*/
 584          return ctx->Polygon.OffsetFill;
 585       case GL_RESCALE_NORMAL_EXT:
 586          return ctx->Transform.RescaleNormals;
 587       case GL_SCISSOR_TEST:
 588          return ctx->Scissor.Enabled;
 589       case GL_SHARED_TEXTURE_PALETTE_EXT:
 590          return ctx->Texture.SharedPalette;
 591       case GL_STENCIL_TEST:
 592          return ctx->Stencil.Enabled;
 593       case GL_TEXTURE_1D:
 594          {
 595             const struct gl_texture_unit *texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
 596             return (texUnit->Enabled & TEXTURE0_1D) ? GL_TRUE : GL_FALSE;
 597          }
 598       case GL_TEXTURE_2D:
 599          {
 600             const struct gl_texture_unit *texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
 601             return (texUnit->Enabled & TEXTURE0_2D) ? GL_TRUE : GL_FALSE;
 602          }
 603       case GL_TEXTURE_3D:
 604          {
 605             const struct gl_texture_unit *texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
 606             return (texUnit->Enabled & TEXTURE0_3D) ? GL_TRUE : GL_FALSE;
 607          }
 608       case GL_TEXTURE_GEN_Q:
 609          {
 610             const struct gl_texture_unit *texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
 611             return (texUnit->TexGenEnabled & Q_BIT) ? GL_TRUE : GL_FALSE;
 612          }
 613       case GL_TEXTURE_GEN_R:
 614          {
 615             const struct gl_texture_unit *texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
 616             return (texUnit->TexGenEnabled & R_BIT) ? GL_TRUE : GL_FALSE;
 617          }
 618       case GL_TEXTURE_GEN_S:
 619          {
 620             const struct gl_texture_unit *texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
 621             return (texUnit->TexGenEnabled & S_BIT) ? GL_TRUE : GL_FALSE;
 622          }
 623       case GL_TEXTURE_GEN_T:
 624          {
 625             const struct gl_texture_unit *texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
 626             return (texUnit->TexGenEnabled & T_BIT) ? GL_TRUE : GL_FALSE;
 627          }
 628
 629       /*
 630        * CLIENT STATE!!!
 631        */
 632       case GL_VERTEX_ARRAY:
 633          return ctx->Array.Vertex.Enabled;
 634       case GL_NORMAL_ARRAY:
 635          return ctx->Array.Normal.Enabled;
 636       case GL_COLOR_ARRAY:
 637          return ctx->Array.Color.Enabled;
 638       case GL_INDEX_ARRAY:
 639          return ctx->Array.Index.Enabled;
 640       case GL_TEXTURE_COORD_ARRAY:
 641          return ctx->Array.TexCoord[ctx->TexCoordUnit].Enabled;
 642       case GL_EDGE_FLAG_ARRAY:
 643          return ctx->Array.EdgeFlag.Enabled;
 644       default:
 645          gl_error( ctx, GL_INVALID_ENUM, "glIsEnabled" );
 646          return GL_FALSE;
 647    }
 648 }
 649
 650
 651
 652
 653 static void gl_client_state( GLcontext *ctx, GLenum cap, GLboolean state )
 654 {
 655    ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH( ctx,
 656                                        (state
 657                                         ? "glEnableClientState"
 658                                         : "glDisableClientState") );
 659
 660    switch (cap) {
 661       case GL_VERTEX_ARRAY:
 662          ctx->Array.Vertex.Enabled = state;
 663          break;
 664       case GL_NORMAL_ARRAY:
 665          ctx->Array.Normal.Enabled = state;
 666          break;
 667       case GL_COLOR_ARRAY:
 668          ctx->Array.Color.Enabled = state;
 669          break;
 670       case GL_INDEX_ARRAY:
 671          ctx->Array.Index.Enabled = state;
 672          break;
 673       case GL_TEXTURE_COORD_ARRAY:
 674          ctx->Array.TexCoord[ctx->TexCoordUnit].Enabled = state;
 675          break;
 676       case GL_EDGE_FLAG_ARRAY:
 677          ctx->Array.EdgeFlag.Enabled = state;
 678          break;
 679       default:
 680          gl_error( ctx, GL_INVALID_ENUM, "glEnable/DisableClientState" );
 681    }
 682
 683    ctx->NewState |= NEW_CLIENT_STATE;
 684 }
 685
 686
 687
 688 void gl_EnableClientState( GLcontext *ctx, GLenum cap )
 689 {
 690    gl_client_state( ctx, cap, GL_TRUE );
 691 }
 692
 693
 694
 695 void gl_DisableClientState( GLcontext *ctx, GLenum cap )
 696 {
 697    gl_client_state( ctx, cap, GL_FALSE );
 698 }
 699