src/mesa/main/enable.c

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