src/mesa/main/enable.c

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