enable.c revision 9499e017b7e05411a32b3e4fa94885eaec0d7277
1/* $Id: enable.c,v 1.30 2000/10/30 16:32:43 brianp 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 */ 50void _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->NewState |= _NEW_PIXEL; 520 break; 521 case GL_POST_CONVOLUTION_COLOR_TABLE_SGI: 522 ctx->Pixel.PostConvolutionColorTableEnabled = state; 523 ctx->NewState |= _NEW_PIXEL; 524 break; 525 case GL_POST_COLOR_MATRIX_COLOR_TABLE_SGI: 526 ctx->Pixel.PostColorMatrixColorTableEnabled = state; 527 ctx->NewState |= _NEW_PIXEL; 528 break; 529 530 /* GL_EXT_convolution */ 531 case GL_CONVOLUTION_1D: 532 /* XXX check for extension */ 533 ctx->Pixel.Convolution1DEnabled = state; 534 ctx->NewState |= _NEW_PIXEL; 535 break; 536 case GL_CONVOLUTION_2D: 537 ctx->Pixel.Convolution2DEnabled = state; 538 ctx->NewState |= _NEW_PIXEL; 539 break; 540 case GL_SEPARABLE_2D: 541 ctx->Pixel.Separable2DEnabled = state; 542 ctx->NewState |= _NEW_PIXEL; 543 break; 544 545 /* GL_ARB_texture_cube_map */ 546 case GL_TEXTURE_CUBE_MAP_ARB: 547 if (ctx->Extensions.ARB_texture_cube_map) { 548 if (ctx->Visual.RGBAflag) { 549 const GLuint curr = ctx->Texture.CurrentUnit; 550 struct gl_texture_unit *texUnit = &ctx->Texture.Unit[curr]; 551 ctx->NewState |= _NEW_TEXTURE; 552 if (state) { 553 texUnit->Enabled |= TEXTURE0_CUBE; 554 } 555 else { 556 texUnit->Enabled &= ~TEXTURE0_CUBE; 557 } 558 } 559 } 560 else { 561 gl_error(ctx, GL_INVALID_ENUM, state ? "glEnable" : "glDisable"); 562 return; 563 } 564 break; 565 566 /* GL_EXT_secondary_color */ 567 case GL_COLOR_SUM_EXT: 568 ctx->Fog.ColorSumEnabled = state; 569 if (state) 570 SET_BITS(ctx->TriangleCaps, DD_SEPERATE_SPECULAR); 571 else if (ctx->Light.Model.ColorControl == GL_SINGLE_COLOR) 572 CLEAR_BITS(ctx->TriangleCaps, DD_SEPERATE_SPECULAR); 573 ctx->NewState |= _NEW_FOG; 574 break; 575 576 default: 577 gl_error(ctx, GL_INVALID_ENUM, state ? "glEnable" : "glDisable"); 578 return; 579 } 580 581 if (ctx->Driver.Enable) { 582 (*ctx->Driver.Enable)( ctx, cap, state ); 583 } 584} 585 586 587 588 589void 590_mesa_Enable( GLenum cap ) 591{ 592 GET_CURRENT_CONTEXT(ctx); 593 _mesa_set_enable( ctx, cap, GL_TRUE ); 594} 595 596 597 598void 599_mesa_Disable( GLenum cap ) 600{ 601 GET_CURRENT_CONTEXT(ctx); 602 _mesa_set_enable( ctx, cap, GL_FALSE ); 603} 604 605 606 607GLboolean 608_mesa_IsEnabled( GLenum cap ) 609{ 610 GET_CURRENT_CONTEXT(ctx); 611 switch (cap) { 612 case GL_ALPHA_TEST: 613 return ctx->Color.AlphaEnabled; 614 case GL_AUTO_NORMAL: 615 return ctx->Eval.AutoNormal; 616 case GL_BLEND: 617 return ctx->Color.BlendEnabled; 618 case GL_CLIP_PLANE0: 619 case GL_CLIP_PLANE1: 620 case GL_CLIP_PLANE2: 621 case GL_CLIP_PLANE3: 622 case GL_CLIP_PLANE4: 623 case GL_CLIP_PLANE5: 624 return ctx->Transform.ClipEnabled[cap-GL_CLIP_PLANE0]; 625 case GL_COLOR_MATERIAL: 626 return ctx->Light.ColorMaterialEnabled; 627 case GL_CULL_FACE: 628 return ctx->Polygon.CullFlag; 629 case GL_DEPTH_TEST: 630 return ctx->Depth.Test; 631 case GL_DITHER: 632 return ctx->Color.DitherFlag; 633 case GL_FOG: 634 return ctx->Fog.Enabled; 635 case GL_HISTOGRAM: 636 if (ctx->Extensions.EXT_histogram) { 637 return ctx->Pixel.HistogramEnabled; 638 } 639 else { 640 gl_error(ctx, GL_INVALID_ENUM, "glIsEnabled"); 641 return GL_FALSE; 642 } 643 case GL_LIGHTING: 644 return ctx->Light.Enabled; 645 case GL_LIGHT0: 646 case GL_LIGHT1: 647 case GL_LIGHT2: 648 case GL_LIGHT3: 649 case GL_LIGHT4: 650 case GL_LIGHT5: 651 case GL_LIGHT6: 652 case GL_LIGHT7: 653 return ctx->Light.Light[cap-GL_LIGHT0].Enabled; 654 case GL_LINE_SMOOTH: 655 return ctx->Line.SmoothFlag; 656 case GL_LINE_STIPPLE: 657 return ctx->Line.StippleFlag; 658 case GL_INDEX_LOGIC_OP: 659 return ctx->Color.IndexLogicOpEnabled; 660 case GL_COLOR_LOGIC_OP: 661 return ctx->Color.ColorLogicOpEnabled; 662 case GL_MAP1_COLOR_4: 663 return ctx->Eval.Map1Color4; 664 case GL_MAP1_INDEX: 665 return ctx->Eval.Map1Index; 666 case GL_MAP1_NORMAL: 667 return ctx->Eval.Map1Normal; 668 case GL_MAP1_TEXTURE_COORD_1: 669 return ctx->Eval.Map1TextureCoord1; 670 case GL_MAP1_TEXTURE_COORD_2: 671 return ctx->Eval.Map1TextureCoord2; 672 case GL_MAP1_TEXTURE_COORD_3: 673 return ctx->Eval.Map1TextureCoord3; 674 case GL_MAP1_TEXTURE_COORD_4: 675 return ctx->Eval.Map1TextureCoord4; 676 case GL_MAP1_VERTEX_3: 677 return ctx->Eval.Map1Vertex3; 678 case GL_MAP1_VERTEX_4: 679 return ctx->Eval.Map1Vertex4; 680 case GL_MAP2_COLOR_4: 681 return ctx->Eval.Map2Color4; 682 case GL_MAP2_INDEX: 683 return ctx->Eval.Map2Index; 684 case GL_MAP2_NORMAL: 685 return ctx->Eval.Map2Normal; 686 case GL_MAP2_TEXTURE_COORD_1: 687 return ctx->Eval.Map2TextureCoord1; 688 case GL_MAP2_TEXTURE_COORD_2: 689 return ctx->Eval.Map2TextureCoord2; 690 case GL_MAP2_TEXTURE_COORD_3: 691 return ctx->Eval.Map2TextureCoord3; 692 case GL_MAP2_TEXTURE_COORD_4: 693 return ctx->Eval.Map2TextureCoord4; 694 case GL_MAP2_VERTEX_3: 695 return ctx->Eval.Map2Vertex3; 696 case GL_MAP2_VERTEX_4: 697 return ctx->Eval.Map2Vertex4; 698 case GL_MINMAX: 699 return ctx->Pixel.MinMaxEnabled; 700 case GL_NORMALIZE: 701 return ctx->Transform.Normalize; 702 case GL_POINT_SMOOTH: 703 return ctx->Point.SmoothFlag; 704 case GL_POLYGON_SMOOTH: 705 return ctx->Polygon.SmoothFlag; 706 case GL_POLYGON_STIPPLE: 707 return ctx->Polygon.StippleFlag; 708 case GL_POLYGON_OFFSET_POINT: 709 return ctx->Polygon.OffsetPoint; 710 case GL_POLYGON_OFFSET_LINE: 711 return ctx->Polygon.OffsetLine; 712 case GL_POLYGON_OFFSET_FILL: 713 /*case GL_POLYGON_OFFSET_EXT:*/ 714 return ctx->Polygon.OffsetFill; 715 case GL_RESCALE_NORMAL_EXT: 716 return ctx->Transform.RescaleNormals; 717 case GL_SCISSOR_TEST: 718 return ctx->Scissor.Enabled; 719 case GL_SHARED_TEXTURE_PALETTE_EXT: 720 return ctx->Texture.SharedPalette; 721 case GL_STENCIL_TEST: 722 return ctx->Stencil.Enabled; 723 case GL_TEXTURE_1D: 724 { 725 const struct gl_texture_unit *texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit]; 726 return (texUnit->Enabled & TEXTURE0_1D) ? GL_TRUE : GL_FALSE; 727 } 728 case GL_TEXTURE_2D: 729 { 730 const struct gl_texture_unit *texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit]; 731 return (texUnit->Enabled & TEXTURE0_2D) ? GL_TRUE : GL_FALSE; 732 } 733 case GL_TEXTURE_3D: 734 { 735 const struct gl_texture_unit *texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit]; 736 return (texUnit->Enabled & TEXTURE0_3D) ? GL_TRUE : GL_FALSE; 737 } 738 case GL_TEXTURE_GEN_Q: 739 { 740 const struct gl_texture_unit *texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit]; 741 return (texUnit->TexGenEnabled & Q_BIT) ? GL_TRUE : GL_FALSE; 742 } 743 case GL_TEXTURE_GEN_R: 744 { 745 const struct gl_texture_unit *texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit]; 746 return (texUnit->TexGenEnabled & R_BIT) ? GL_TRUE : GL_FALSE; 747 } 748 case GL_TEXTURE_GEN_S: 749 { 750 const struct gl_texture_unit *texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit]; 751 return (texUnit->TexGenEnabled & S_BIT) ? GL_TRUE : GL_FALSE; 752 } 753 case GL_TEXTURE_GEN_T: 754 { 755 const struct gl_texture_unit *texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit]; 756 return (texUnit->TexGenEnabled & T_BIT) ? GL_TRUE : GL_FALSE; 757 } 758 759 /* 760 * CLIENT STATE!!! 761 */ 762 case GL_VERTEX_ARRAY: 763 return ctx->Array.Vertex.Enabled; 764 case GL_NORMAL_ARRAY: 765 return ctx->Array.Normal.Enabled; 766 case GL_COLOR_ARRAY: 767 return ctx->Array.Color.Enabled; 768 case GL_INDEX_ARRAY: 769 return ctx->Array.Index.Enabled; 770 case GL_TEXTURE_COORD_ARRAY: 771 return ctx->Array.TexCoord[ctx->Array.ActiveTexture].Enabled; 772 case GL_EDGE_FLAG_ARRAY: 773 return ctx->Array.EdgeFlag.Enabled; 774 775 /* GL_HP_occlusion_test */ 776 case GL_OCCLUSION_TEST_HP: 777 if (ctx->Extensions.HP_occlusion_test) { 778 return ctx->Depth.OcclusionTest; 779 } 780 else { 781 gl_error( ctx, GL_INVALID_ENUM, "glIsEnabled" ); 782 return GL_FALSE; 783 } 784 785 /* GL_SGIS_pixel_texture */ 786 case GL_PIXEL_TEXTURE_SGIS: 787 return ctx->Pixel.PixelTextureEnabled; 788 789 /* GL_SGIX_pixel_texture */ 790 case GL_PIXEL_TEX_GEN_SGIX: 791 return ctx->Pixel.PixelTextureEnabled; 792 793 /* GL_SGI_color_table */ 794 case GL_COLOR_TABLE_SGI: 795 return ctx->Pixel.ColorTableEnabled; 796 case GL_POST_CONVOLUTION_COLOR_TABLE_SGI: 797 return ctx->Pixel.PostConvolutionColorTableEnabled; 798 case GL_POST_COLOR_MATRIX_COLOR_TABLE_SGI: 799 return ctx->Pixel.PostColorMatrixColorTableEnabled; 800 801 /* GL_EXT_convolution */ 802 case GL_CONVOLUTION_1D: 803 return ctx->Pixel.Convolution1DEnabled; 804 case GL_CONVOLUTION_2D: 805 return ctx->Pixel.Convolution2DEnabled; 806 case GL_SEPARABLE_2D: 807 return ctx->Pixel.Separable2DEnabled; 808 809 /* GL_ARB_texture_cube_map */ 810 case GL_TEXTURE_CUBE_MAP_ARB: 811 if (ctx->Extensions.ARB_texture_cube_map) { 812 const struct gl_texture_unit *texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit]; 813 return (texUnit->Enabled & TEXTURE0_CUBE) ? GL_TRUE : GL_FALSE; 814 } 815 else { 816 gl_error(ctx, GL_INVALID_ENUM, "glIsEnabled"); 817 return GL_FALSE; 818 } 819 820 default: 821 gl_error( ctx, GL_INVALID_ENUM, "glIsEnabled" ); 822 return GL_FALSE; 823 } 824} 825 826 827 828 829static void 830client_state( GLcontext *ctx, GLenum cap, GLboolean state ) 831{ 832 ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH( ctx, 833 (state 834 ? "glEnableClientState" 835 : "glDisableClientState") ); 836 837 switch (cap) { 838 case GL_VERTEX_ARRAY: 839 ctx->Array.Vertex.Enabled = state; 840 break; 841 case GL_NORMAL_ARRAY: 842 ctx->Array.Normal.Enabled = state; 843 break; 844 case GL_COLOR_ARRAY: 845 ctx->Array.Color.Enabled = state; 846 break; 847 case GL_INDEX_ARRAY: 848 ctx->Array.Index.Enabled = state; 849 break; 850 case GL_TEXTURE_COORD_ARRAY: 851 ctx->Array.TexCoord[ctx->Array.ActiveTexture].Enabled = state; 852 break; 853 case GL_EDGE_FLAG_ARRAY: 854 ctx->Array.EdgeFlag.Enabled = state; 855 break; 856 case GL_FOG_COORDINATE_ARRAY_EXT: 857 ctx->Array.FogCoord.Enabled = state; 858 break; 859 case GL_SECONDARY_COLOR_ARRAY_EXT: 860 ctx->Array.SecondaryColor.Enabled = state; 861 break; 862 default: 863 gl_error( ctx, GL_INVALID_ENUM, "glEnable/DisableClientState" ); 864 } 865 866 ctx->NewState |= _NEW_ARRAY; 867} 868 869 870 871void 872_mesa_EnableClientState( GLenum cap ) 873{ 874 GET_CURRENT_CONTEXT(ctx); 875 client_state( ctx, cap, GL_TRUE ); 876} 877 878 879 880void 881_mesa_DisableClientState( GLenum cap ) 882{ 883 GET_CURRENT_CONTEXT(ctx); 884 client_state( ctx, cap, GL_FALSE ); 885} 886 887