enable.c revision 60b152a1b366b1c9b9326dda1d91ab600fbb0d86
1/** 2 * \file enable.c 3 * Enable/disable/query GL capabilities. 4 */ 5 6/* 7 * Mesa 3-D graphics library 8 * Version: 7.0.3 9 * 10 * Copyright (C) 1999-2007 Brian Paul All Rights Reserved. 11 * 12 * Permission is hereby granted, free of charge, to any person obtaining a 13 * copy of this software and associated documentation files (the "Software"), 14 * to deal in the Software without restriction, including without limitation 15 * the rights to use, copy, modify, merge, publish, distribute, sublicense, 16 * and/or sell copies of the Software, and to permit persons to whom the 17 * Software is furnished to do so, subject to the following conditions: 18 * 19 * The above copyright notice and this permission notice shall be included 20 * in all copies or substantial portions of the Software. 21 * 22 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS 23 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 24 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL 25 * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN 26 * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN 27 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. 28 */ 29 30 31#include "glheader.h" 32#include "context.h" 33#include "enable.h" 34#include "light.h" 35#include "macros.h" 36#include "simple_list.h" 37#include "mtypes.h" 38#include "enums.h" 39#include "math/m_matrix.h" 40#include "api_arrayelt.h" 41 42 43 44#define CHECK_EXTENSION(EXTNAME, CAP) \ 45 if (!ctx->Extensions.EXTNAME) { \ 46 _mesa_error(ctx, GL_INVALID_ENUM, "gl%sClientState(0x%x)", \ 47 state ? "Enable" : "Disable", CAP); \ 48 return; \ 49 } 50 51 52/** 53 * Helper to enable/disable client-side state. 54 */ 55static void 56client_state(GLcontext *ctx, GLenum cap, GLboolean state) 57{ 58 GLuint flag; 59 GLboolean *var; 60 61 switch (cap) { 62 case GL_VERTEX_ARRAY: 63 var = &ctx->Array.ArrayObj->Vertex.Enabled; 64 flag = _NEW_ARRAY_VERTEX; 65 break; 66 case GL_NORMAL_ARRAY: 67 var = &ctx->Array.ArrayObj->Normal.Enabled; 68 flag = _NEW_ARRAY_NORMAL; 69 break; 70 case GL_COLOR_ARRAY: 71 var = &ctx->Array.ArrayObj->Color.Enabled; 72 flag = _NEW_ARRAY_COLOR0; 73 break; 74 case GL_INDEX_ARRAY: 75 var = &ctx->Array.ArrayObj->Index.Enabled; 76 flag = _NEW_ARRAY_INDEX; 77 break; 78 case GL_TEXTURE_COORD_ARRAY: 79 var = &ctx->Array.ArrayObj->TexCoord[ctx->Array.ActiveTexture].Enabled; 80 flag = _NEW_ARRAY_TEXCOORD(ctx->Array.ActiveTexture); 81 break; 82 case GL_EDGE_FLAG_ARRAY: 83 var = &ctx->Array.ArrayObj->EdgeFlag.Enabled; 84 flag = _NEW_ARRAY_EDGEFLAG; 85 break; 86 case GL_FOG_COORDINATE_ARRAY_EXT: 87 var = &ctx->Array.ArrayObj->FogCoord.Enabled; 88 flag = _NEW_ARRAY_FOGCOORD; 89 break; 90 case GL_SECONDARY_COLOR_ARRAY_EXT: 91 var = &ctx->Array.ArrayObj->SecondaryColor.Enabled; 92 flag = _NEW_ARRAY_COLOR1; 93 break; 94 95#if FEATURE_point_size_array 96 case GL_POINT_SIZE_ARRAY_OES: 97 var = &ctx->Array.ArrayObj->PointSize.Enabled; 98 flag = _NEW_ARRAY_POINT_SIZE; 99 break; 100#endif 101 102#if FEATURE_NV_vertex_program 103 case GL_VERTEX_ATTRIB_ARRAY0_NV: 104 case GL_VERTEX_ATTRIB_ARRAY1_NV: 105 case GL_VERTEX_ATTRIB_ARRAY2_NV: 106 case GL_VERTEX_ATTRIB_ARRAY3_NV: 107 case GL_VERTEX_ATTRIB_ARRAY4_NV: 108 case GL_VERTEX_ATTRIB_ARRAY5_NV: 109 case GL_VERTEX_ATTRIB_ARRAY6_NV: 110 case GL_VERTEX_ATTRIB_ARRAY7_NV: 111 case GL_VERTEX_ATTRIB_ARRAY8_NV: 112 case GL_VERTEX_ATTRIB_ARRAY9_NV: 113 case GL_VERTEX_ATTRIB_ARRAY10_NV: 114 case GL_VERTEX_ATTRIB_ARRAY11_NV: 115 case GL_VERTEX_ATTRIB_ARRAY12_NV: 116 case GL_VERTEX_ATTRIB_ARRAY13_NV: 117 case GL_VERTEX_ATTRIB_ARRAY14_NV: 118 case GL_VERTEX_ATTRIB_ARRAY15_NV: 119 CHECK_EXTENSION(NV_vertex_program, cap); 120 { 121 GLint n = (GLint) cap - GL_VERTEX_ATTRIB_ARRAY0_NV; 122 var = &ctx->Array.ArrayObj->VertexAttrib[n].Enabled; 123 flag = _NEW_ARRAY_ATTRIB(n); 124 } 125 break; 126#endif /* FEATURE_NV_vertex_program */ 127 128 default: 129 _mesa_error( ctx, GL_INVALID_ENUM, 130 "glEnable/DisableClientState(0x%x)", cap); 131 return; 132 } 133 134 if (*var == state) 135 return; 136 137 FLUSH_VERTICES(ctx, _NEW_ARRAY); 138 ctx->Array.NewState |= flag; 139 140 _ae_invalidate_state(ctx, _NEW_ARRAY); 141 142 *var = state; 143 144 if (state) 145 ctx->Array.ArrayObj->_Enabled |= flag; 146 else 147 ctx->Array.ArrayObj->_Enabled &= ~flag; 148 149 if (ctx->Driver.Enable) { 150 ctx->Driver.Enable( ctx, cap, state ); 151 } 152} 153 154 155/** 156 * Enable GL capability. 157 * \param cap state to enable/disable. 158 * 159 * Get's the current context, assures that we're outside glBegin()/glEnd() and 160 * calls client_state(). 161 */ 162void GLAPIENTRY 163_mesa_EnableClientState( GLenum cap ) 164{ 165 GET_CURRENT_CONTEXT(ctx); 166 ASSERT_OUTSIDE_BEGIN_END(ctx); 167 client_state( ctx, cap, GL_TRUE ); 168} 169 170 171/** 172 * Disable GL capability. 173 * \param cap state to enable/disable. 174 * 175 * Get's the current context, assures that we're outside glBegin()/glEnd() and 176 * calls client_state(). 177 */ 178void GLAPIENTRY 179_mesa_DisableClientState( GLenum cap ) 180{ 181 GET_CURRENT_CONTEXT(ctx); 182 ASSERT_OUTSIDE_BEGIN_END(ctx); 183 client_state( ctx, cap, GL_FALSE ); 184} 185 186 187#undef CHECK_EXTENSION 188#define CHECK_EXTENSION(EXTNAME, CAP) \ 189 if (!ctx->Extensions.EXTNAME) { \ 190 _mesa_error(ctx, GL_INVALID_ENUM, "gl%s(0x%x)", \ 191 state ? "Enable" : "Disable", CAP); \ 192 return; \ 193 } 194 195#define CHECK_EXTENSION2(EXT1, EXT2, CAP) \ 196 if (!ctx->Extensions.EXT1 && !ctx->Extensions.EXT2) { \ 197 _mesa_error(ctx, GL_INVALID_ENUM, "gl%s(0x%x)", \ 198 state ? "Enable" : "Disable", CAP); \ 199 return; \ 200 } 201 202 203 204/** 205 * Return pointer to current texture unit for setting/getting coordinate 206 * state. 207 * Note that we'll set GL_INVALID_OPERATION if the active texture unit is 208 * higher than the number of supported coordinate units. And we'll return NULL. 209 */ 210static struct gl_texture_unit * 211get_texcoord_unit(GLcontext *ctx) 212{ 213 if (ctx->Texture.CurrentUnit >= ctx->Const.MaxTextureCoordUnits) { 214 _mesa_error(ctx, GL_INVALID_OPERATION, "glEnable/Disable(texcoord unit)"); 215 return NULL; 216 } 217 else { 218 return &ctx->Texture.Unit[ctx->Texture.CurrentUnit]; 219 } 220} 221 222 223/** 224 * Helper function to enable or disable a texture target. 225 */ 226static GLboolean 227enable_texture(GLcontext *ctx, GLboolean state, GLbitfield bit) 228{ 229 const GLuint curr = ctx->Texture.CurrentUnit; 230 struct gl_texture_unit *texUnit = &ctx->Texture.Unit[curr]; 231 const GLuint newenabled = (!state) 232 ? (texUnit->Enabled & ~bit) : (texUnit->Enabled | bit); 233 234 if (texUnit->Enabled == newenabled) 235 return GL_FALSE; 236 237 FLUSH_VERTICES(ctx, _NEW_TEXTURE); 238 texUnit->Enabled = newenabled; 239 return GL_TRUE; 240} 241 242 243/** 244 * Helper function to enable or disable state. 245 * 246 * \param ctx GL context. 247 * \param cap the state to enable/disable 248 * \param state whether to enable or disable the specified capability. 249 * 250 * Updates the current context and flushes the vertices as needed. For 251 * capabilities associated with extensions it verifies that those extensions 252 * are effectivly present before updating. Notifies the driver via 253 * dd_function_table::Enable. 254 */ 255void 256_mesa_set_enable(GLcontext *ctx, GLenum cap, GLboolean state) 257{ 258 if (MESA_VERBOSE & VERBOSE_API) 259 _mesa_debug(ctx, "%s %s (newstate is %x)\n", 260 state ? "glEnable" : "glDisable", 261 _mesa_lookup_enum_by_nr(cap), 262 ctx->NewState); 263 264 switch (cap) { 265 case GL_ALPHA_TEST: 266 if (ctx->Color.AlphaEnabled == state) 267 return; 268 FLUSH_VERTICES(ctx, _NEW_COLOR); 269 ctx->Color.AlphaEnabled = state; 270 break; 271 case GL_AUTO_NORMAL: 272 if (ctx->Eval.AutoNormal == state) 273 return; 274 FLUSH_VERTICES(ctx, _NEW_EVAL); 275 ctx->Eval.AutoNormal = state; 276 break; 277 case GL_BLEND: 278 if (ctx->Color.BlendEnabled == state) 279 return; 280 FLUSH_VERTICES(ctx, _NEW_COLOR); 281 ctx->Color.BlendEnabled = state; 282 break; 283#if FEATURE_userclip 284 case GL_CLIP_PLANE0: 285 case GL_CLIP_PLANE1: 286 case GL_CLIP_PLANE2: 287 case GL_CLIP_PLANE3: 288 case GL_CLIP_PLANE4: 289 case GL_CLIP_PLANE5: 290 { 291 const GLuint p = cap - GL_CLIP_PLANE0; 292 293 if ((ctx->Transform.ClipPlanesEnabled & (1 << p)) == ((GLuint) state << p)) 294 return; 295 296 FLUSH_VERTICES(ctx, _NEW_TRANSFORM); 297 298 if (state) { 299 ctx->Transform.ClipPlanesEnabled |= (1 << p); 300 301 if (_math_matrix_is_dirty(ctx->ProjectionMatrixStack.Top)) 302 _math_matrix_analyse( ctx->ProjectionMatrixStack.Top ); 303 304 /* This derived state also calculated in clip.c and 305 * from _mesa_update_state() on changes to EyeUserPlane 306 * and ctx->ProjectionMatrix respectively. 307 */ 308 _mesa_transform_vector( ctx->Transform._ClipUserPlane[p], 309 ctx->Transform.EyeUserPlane[p], 310 ctx->ProjectionMatrixStack.Top->inv ); 311 } 312 else { 313 ctx->Transform.ClipPlanesEnabled &= ~(1 << p); 314 } 315 } 316 break; 317#endif 318 case GL_COLOR_MATERIAL: 319 if (ctx->Light.ColorMaterialEnabled == state) 320 return; 321 FLUSH_VERTICES(ctx, _NEW_LIGHT); 322 FLUSH_CURRENT(ctx, 0); 323 ctx->Light.ColorMaterialEnabled = state; 324 if (state) { 325 _mesa_update_color_material( ctx, 326 ctx->Current.Attrib[VERT_ATTRIB_COLOR0] ); 327 } 328 break; 329 case GL_CULL_FACE: 330 if (ctx->Polygon.CullFlag == state) 331 return; 332 FLUSH_VERTICES(ctx, _NEW_POLYGON); 333 ctx->Polygon.CullFlag = state; 334 break; 335 case GL_CULL_VERTEX_EXT: 336 CHECK_EXTENSION(EXT_cull_vertex, cap); 337 if (ctx->Transform.CullVertexFlag == state) 338 return; 339 FLUSH_VERTICES(ctx, _NEW_TRANSFORM); 340 ctx->Transform.CullVertexFlag = state; 341 break; 342 case GL_DEPTH_TEST: 343 if (ctx->Depth.Test == state) 344 return; 345 FLUSH_VERTICES(ctx, _NEW_DEPTH); 346 ctx->Depth.Test = state; 347 break; 348 case GL_DITHER: 349 if (ctx->NoDither) { 350 state = GL_FALSE; /* MESA_NO_DITHER env var */ 351 } 352 if (ctx->Color.DitherFlag == state) 353 return; 354 FLUSH_VERTICES(ctx, _NEW_COLOR); 355 ctx->Color.DitherFlag = state; 356 break; 357 case GL_FOG: 358 if (ctx->Fog.Enabled == state) 359 return; 360 FLUSH_VERTICES(ctx, _NEW_FOG); 361 ctx->Fog.Enabled = state; 362 break; 363 case GL_HISTOGRAM: 364 CHECK_EXTENSION(EXT_histogram, cap); 365 if (ctx->Pixel.HistogramEnabled == state) 366 return; 367 FLUSH_VERTICES(ctx, _NEW_PIXEL); 368 ctx->Pixel.HistogramEnabled = state; 369 break; 370 case GL_LIGHT0: 371 case GL_LIGHT1: 372 case GL_LIGHT2: 373 case GL_LIGHT3: 374 case GL_LIGHT4: 375 case GL_LIGHT5: 376 case GL_LIGHT6: 377 case GL_LIGHT7: 378 if (ctx->Light.Light[cap-GL_LIGHT0].Enabled == state) 379 return; 380 FLUSH_VERTICES(ctx, _NEW_LIGHT); 381 ctx->Light.Light[cap-GL_LIGHT0].Enabled = state; 382 if (state) { 383 insert_at_tail(&ctx->Light.EnabledList, 384 &ctx->Light.Light[cap-GL_LIGHT0]); 385 } 386 else { 387 remove_from_list(&ctx->Light.Light[cap-GL_LIGHT0]); 388 } 389 break; 390 case GL_LIGHTING: 391 if (ctx->Light.Enabled == state) 392 return; 393 FLUSH_VERTICES(ctx, _NEW_LIGHT); 394 ctx->Light.Enabled = state; 395 if (ctx->Light.Enabled && ctx->Light.Model.TwoSide) 396 ctx->_TriangleCaps |= DD_TRI_LIGHT_TWOSIDE; 397 else 398 ctx->_TriangleCaps &= ~DD_TRI_LIGHT_TWOSIDE; 399 break; 400 case GL_LINE_SMOOTH: 401 if (ctx->Line.SmoothFlag == state) 402 return; 403 FLUSH_VERTICES(ctx, _NEW_LINE); 404 ctx->Line.SmoothFlag = state; 405 ctx->_TriangleCaps ^= DD_LINE_SMOOTH; 406 break; 407 case GL_LINE_STIPPLE: 408 if (ctx->Line.StippleFlag == state) 409 return; 410 FLUSH_VERTICES(ctx, _NEW_LINE); 411 ctx->Line.StippleFlag = state; 412 ctx->_TriangleCaps ^= DD_LINE_STIPPLE; 413 break; 414 case GL_INDEX_LOGIC_OP: 415 if (ctx->Color.IndexLogicOpEnabled == state) 416 return; 417 FLUSH_VERTICES(ctx, _NEW_COLOR); 418 ctx->Color.IndexLogicOpEnabled = state; 419 break; 420 case GL_COLOR_LOGIC_OP: 421 if (ctx->Color.ColorLogicOpEnabled == state) 422 return; 423 FLUSH_VERTICES(ctx, _NEW_COLOR); 424 ctx->Color.ColorLogicOpEnabled = state; 425 break; 426 case GL_MAP1_COLOR_4: 427 if (ctx->Eval.Map1Color4 == state) 428 return; 429 FLUSH_VERTICES(ctx, _NEW_EVAL); 430 ctx->Eval.Map1Color4 = state; 431 break; 432 case GL_MAP1_INDEX: 433 if (ctx->Eval.Map1Index == state) 434 return; 435 FLUSH_VERTICES(ctx, _NEW_EVAL); 436 ctx->Eval.Map1Index = state; 437 break; 438 case GL_MAP1_NORMAL: 439 if (ctx->Eval.Map1Normal == state) 440 return; 441 FLUSH_VERTICES(ctx, _NEW_EVAL); 442 ctx->Eval.Map1Normal = state; 443 break; 444 case GL_MAP1_TEXTURE_COORD_1: 445 if (ctx->Eval.Map1TextureCoord1 == state) 446 return; 447 FLUSH_VERTICES(ctx, _NEW_EVAL); 448 ctx->Eval.Map1TextureCoord1 = state; 449 break; 450 case GL_MAP1_TEXTURE_COORD_2: 451 if (ctx->Eval.Map1TextureCoord2 == state) 452 return; 453 FLUSH_VERTICES(ctx, _NEW_EVAL); 454 ctx->Eval.Map1TextureCoord2 = state; 455 break; 456 case GL_MAP1_TEXTURE_COORD_3: 457 if (ctx->Eval.Map1TextureCoord3 == state) 458 return; 459 FLUSH_VERTICES(ctx, _NEW_EVAL); 460 ctx->Eval.Map1TextureCoord3 = state; 461 break; 462 case GL_MAP1_TEXTURE_COORD_4: 463 if (ctx->Eval.Map1TextureCoord4 == state) 464 return; 465 FLUSH_VERTICES(ctx, _NEW_EVAL); 466 ctx->Eval.Map1TextureCoord4 = state; 467 break; 468 case GL_MAP1_VERTEX_3: 469 if (ctx->Eval.Map1Vertex3 == state) 470 return; 471 FLUSH_VERTICES(ctx, _NEW_EVAL); 472 ctx->Eval.Map1Vertex3 = state; 473 break; 474 case GL_MAP1_VERTEX_4: 475 if (ctx->Eval.Map1Vertex4 == state) 476 return; 477 FLUSH_VERTICES(ctx, _NEW_EVAL); 478 ctx->Eval.Map1Vertex4 = state; 479 break; 480 case GL_MAP2_COLOR_4: 481 if (ctx->Eval.Map2Color4 == state) 482 return; 483 FLUSH_VERTICES(ctx, _NEW_EVAL); 484 ctx->Eval.Map2Color4 = state; 485 break; 486 case GL_MAP2_INDEX: 487 if (ctx->Eval.Map2Index == state) 488 return; 489 FLUSH_VERTICES(ctx, _NEW_EVAL); 490 ctx->Eval.Map2Index = state; 491 break; 492 case GL_MAP2_NORMAL: 493 if (ctx->Eval.Map2Normal == state) 494 return; 495 FLUSH_VERTICES(ctx, _NEW_EVAL); 496 ctx->Eval.Map2Normal = state; 497 break; 498 case GL_MAP2_TEXTURE_COORD_1: 499 if (ctx->Eval.Map2TextureCoord1 == state) 500 return; 501 FLUSH_VERTICES(ctx, _NEW_EVAL); 502 ctx->Eval.Map2TextureCoord1 = state; 503 break; 504 case GL_MAP2_TEXTURE_COORD_2: 505 if (ctx->Eval.Map2TextureCoord2 == state) 506 return; 507 FLUSH_VERTICES(ctx, _NEW_EVAL); 508 ctx->Eval.Map2TextureCoord2 = state; 509 break; 510 case GL_MAP2_TEXTURE_COORD_3: 511 if (ctx->Eval.Map2TextureCoord3 == state) 512 return; 513 FLUSH_VERTICES(ctx, _NEW_EVAL); 514 ctx->Eval.Map2TextureCoord3 = state; 515 break; 516 case GL_MAP2_TEXTURE_COORD_4: 517 if (ctx->Eval.Map2TextureCoord4 == state) 518 return; 519 FLUSH_VERTICES(ctx, _NEW_EVAL); 520 ctx->Eval.Map2TextureCoord4 = state; 521 break; 522 case GL_MAP2_VERTEX_3: 523 if (ctx->Eval.Map2Vertex3 == state) 524 return; 525 FLUSH_VERTICES(ctx, _NEW_EVAL); 526 ctx->Eval.Map2Vertex3 = state; 527 break; 528 case GL_MAP2_VERTEX_4: 529 if (ctx->Eval.Map2Vertex4 == state) 530 return; 531 FLUSH_VERTICES(ctx, _NEW_EVAL); 532 ctx->Eval.Map2Vertex4 = state; 533 break; 534 case GL_MINMAX: 535 if (ctx->Pixel.MinMaxEnabled == state) 536 return; 537 FLUSH_VERTICES(ctx, _NEW_PIXEL); 538 ctx->Pixel.MinMaxEnabled = state; 539 break; 540 case GL_NORMALIZE: 541 if (ctx->Transform.Normalize == state) 542 return; 543 FLUSH_VERTICES(ctx, _NEW_TRANSFORM); 544 ctx->Transform.Normalize = state; 545 break; 546 case GL_POINT_SMOOTH: 547 if (ctx->Point.SmoothFlag == state) 548 return; 549 FLUSH_VERTICES(ctx, _NEW_POINT); 550 ctx->Point.SmoothFlag = state; 551 ctx->_TriangleCaps ^= DD_POINT_SMOOTH; 552 break; 553 case GL_POLYGON_SMOOTH: 554 if (ctx->Polygon.SmoothFlag == state) 555 return; 556 FLUSH_VERTICES(ctx, _NEW_POLYGON); 557 ctx->Polygon.SmoothFlag = state; 558 ctx->_TriangleCaps ^= DD_TRI_SMOOTH; 559 break; 560 case GL_POLYGON_STIPPLE: 561 if (ctx->Polygon.StippleFlag == state) 562 return; 563 FLUSH_VERTICES(ctx, _NEW_POLYGON); 564 ctx->Polygon.StippleFlag = state; 565 ctx->_TriangleCaps ^= DD_TRI_STIPPLE; 566 break; 567 case GL_POLYGON_OFFSET_POINT: 568 if (ctx->Polygon.OffsetPoint == state) 569 return; 570 FLUSH_VERTICES(ctx, _NEW_POLYGON); 571 ctx->Polygon.OffsetPoint = state; 572 break; 573 case GL_POLYGON_OFFSET_LINE: 574 if (ctx->Polygon.OffsetLine == state) 575 return; 576 FLUSH_VERTICES(ctx, _NEW_POLYGON); 577 ctx->Polygon.OffsetLine = state; 578 break; 579 case GL_POLYGON_OFFSET_FILL: 580 /*case GL_POLYGON_OFFSET_EXT:*/ 581 if (ctx->Polygon.OffsetFill == state) 582 return; 583 FLUSH_VERTICES(ctx, _NEW_POLYGON); 584 ctx->Polygon.OffsetFill = state; 585 break; 586 case GL_RESCALE_NORMAL_EXT: 587 if (ctx->Transform.RescaleNormals == state) 588 return; 589 FLUSH_VERTICES(ctx, _NEW_TRANSFORM); 590 ctx->Transform.RescaleNormals = state; 591 break; 592 case GL_SCISSOR_TEST: 593 if (ctx->Scissor.Enabled == state) 594 return; 595 FLUSH_VERTICES(ctx, _NEW_SCISSOR); 596 ctx->Scissor.Enabled = state; 597 break; 598 case GL_SHARED_TEXTURE_PALETTE_EXT: 599 if (ctx->Texture.SharedPalette == state) 600 return; 601 FLUSH_VERTICES(ctx, _NEW_TEXTURE); 602 ctx->Texture.SharedPalette = state; 603 break; 604 case GL_STENCIL_TEST: 605 if (ctx->Stencil.Enabled == state) 606 return; 607 FLUSH_VERTICES(ctx, _NEW_STENCIL); 608 ctx->Stencil.Enabled = state; 609 break; 610 case GL_TEXTURE_1D: 611 if (!enable_texture(ctx, state, TEXTURE_1D_BIT)) { 612 return; 613 } 614 break; 615 case GL_TEXTURE_2D: 616 if (!enable_texture(ctx, state, TEXTURE_2D_BIT)) { 617 return; 618 } 619 break; 620 case GL_TEXTURE_3D: 621 if (!enable_texture(ctx, state, TEXTURE_3D_BIT)) { 622 return; 623 } 624 break; 625 case GL_TEXTURE_GEN_Q: 626 { 627 struct gl_texture_unit *texUnit = get_texcoord_unit(ctx); 628 if (texUnit) { 629 GLuint newenabled = texUnit->TexGenEnabled & ~Q_BIT; 630 if (state) 631 newenabled |= Q_BIT; 632 if (texUnit->TexGenEnabled == newenabled) 633 return; 634 FLUSH_VERTICES(ctx, _NEW_TEXTURE); 635 texUnit->TexGenEnabled = newenabled; 636 } 637 } 638 break; 639 case GL_TEXTURE_GEN_R: 640 { 641 struct gl_texture_unit *texUnit = get_texcoord_unit(ctx); 642 if (texUnit) { 643 GLuint newenabled = texUnit->TexGenEnabled & ~R_BIT; 644 if (state) 645 newenabled |= R_BIT; 646 if (texUnit->TexGenEnabled == newenabled) 647 return; 648 FLUSH_VERTICES(ctx, _NEW_TEXTURE); 649 texUnit->TexGenEnabled = newenabled; 650 } 651 } 652 break; 653 case GL_TEXTURE_GEN_S: 654 { 655 struct gl_texture_unit *texUnit = get_texcoord_unit(ctx); 656 if (texUnit) { 657 GLuint newenabled = texUnit->TexGenEnabled & ~S_BIT; 658 if (state) 659 newenabled |= S_BIT; 660 if (texUnit->TexGenEnabled == newenabled) 661 return; 662 FLUSH_VERTICES(ctx, _NEW_TEXTURE); 663 texUnit->TexGenEnabled = newenabled; 664 } 665 } 666 break; 667 case GL_TEXTURE_GEN_T: 668 { 669 struct gl_texture_unit *texUnit = get_texcoord_unit(ctx); 670 if (texUnit) { 671 GLuint newenabled = texUnit->TexGenEnabled & ~T_BIT; 672 if (state) 673 newenabled |= T_BIT; 674 if (texUnit->TexGenEnabled == newenabled) 675 return; 676 FLUSH_VERTICES(ctx, _NEW_TEXTURE); 677 texUnit->TexGenEnabled = newenabled; 678 } 679 } 680 break; 681 682 /* 683 * CLIENT STATE!!! 684 */ 685 case GL_VERTEX_ARRAY: 686 case GL_NORMAL_ARRAY: 687 case GL_COLOR_ARRAY: 688 case GL_INDEX_ARRAY: 689 case GL_TEXTURE_COORD_ARRAY: 690 case GL_EDGE_FLAG_ARRAY: 691 case GL_FOG_COORDINATE_ARRAY_EXT: 692 case GL_SECONDARY_COLOR_ARRAY_EXT: 693 case GL_POINT_SIZE_ARRAY_OES: 694 client_state( ctx, cap, state ); 695 return; 696 697 /* GL_SGI_color_table */ 698 case GL_COLOR_TABLE_SGI: 699 CHECK_EXTENSION(SGI_color_table, cap); 700 if (ctx->Pixel.ColorTableEnabled[COLORTABLE_PRECONVOLUTION] == state) 701 return; 702 FLUSH_VERTICES(ctx, _NEW_PIXEL); 703 ctx->Pixel.ColorTableEnabled[COLORTABLE_PRECONVOLUTION] = state; 704 break; 705 case GL_POST_CONVOLUTION_COLOR_TABLE_SGI: 706 CHECK_EXTENSION(SGI_color_table, cap); 707 if (ctx->Pixel.ColorTableEnabled[COLORTABLE_POSTCONVOLUTION] == state) 708 return; 709 FLUSH_VERTICES(ctx, _NEW_PIXEL); 710 ctx->Pixel.ColorTableEnabled[COLORTABLE_POSTCONVOLUTION] = state; 711 break; 712 case GL_POST_COLOR_MATRIX_COLOR_TABLE_SGI: 713 CHECK_EXTENSION(SGI_color_table, cap); 714 if (ctx->Pixel.ColorTableEnabled[COLORTABLE_POSTCOLORMATRIX] == state) 715 return; 716 FLUSH_VERTICES(ctx, _NEW_PIXEL); 717 ctx->Pixel.ColorTableEnabled[COLORTABLE_POSTCOLORMATRIX] = state; 718 break; 719 case GL_TEXTURE_COLOR_TABLE_SGI: 720 CHECK_EXTENSION(SGI_texture_color_table, cap); 721 if (ctx->Texture.Unit[ctx->Texture.CurrentUnit].ColorTableEnabled == state) 722 return; 723 FLUSH_VERTICES(ctx, _NEW_TEXTURE); 724 ctx->Texture.Unit[ctx->Texture.CurrentUnit].ColorTableEnabled = state; 725 break; 726 727 /* GL_EXT_convolution */ 728 case GL_CONVOLUTION_1D: 729 CHECK_EXTENSION(EXT_convolution, cap); 730 if (ctx->Pixel.Convolution1DEnabled == state) 731 return; 732 FLUSH_VERTICES(ctx, _NEW_PIXEL); 733 ctx->Pixel.Convolution1DEnabled = state; 734 break; 735 case GL_CONVOLUTION_2D: 736 CHECK_EXTENSION(EXT_convolution, cap); 737 if (ctx->Pixel.Convolution2DEnabled == state) 738 return; 739 FLUSH_VERTICES(ctx, _NEW_PIXEL); 740 ctx->Pixel.Convolution2DEnabled = state; 741 break; 742 case GL_SEPARABLE_2D: 743 CHECK_EXTENSION(EXT_convolution, cap); 744 if (ctx->Pixel.Separable2DEnabled == state) 745 return; 746 FLUSH_VERTICES(ctx, _NEW_PIXEL); 747 ctx->Pixel.Separable2DEnabled = state; 748 break; 749 750 /* GL_ARB_texture_cube_map */ 751 case GL_TEXTURE_CUBE_MAP_ARB: 752 CHECK_EXTENSION(ARB_texture_cube_map, cap); 753 if (!enable_texture(ctx, state, TEXTURE_CUBE_BIT)) { 754 return; 755 } 756 break; 757 758 /* GL_EXT_secondary_color */ 759 case GL_COLOR_SUM_EXT: 760 CHECK_EXTENSION2(EXT_secondary_color, ARB_vertex_program, cap); 761 if (ctx->Fog.ColorSumEnabled == state) 762 return; 763 FLUSH_VERTICES(ctx, _NEW_FOG); 764 ctx->Fog.ColorSumEnabled = state; 765 break; 766 767 /* GL_ARB_multisample */ 768 case GL_MULTISAMPLE_ARB: 769 if (ctx->Multisample.Enabled == state) 770 return; 771 FLUSH_VERTICES(ctx, _NEW_MULTISAMPLE); 772 ctx->Multisample.Enabled = state; 773 break; 774 case GL_SAMPLE_ALPHA_TO_COVERAGE_ARB: 775 if (ctx->Multisample.SampleAlphaToCoverage == state) 776 return; 777 FLUSH_VERTICES(ctx, _NEW_MULTISAMPLE); 778 ctx->Multisample.SampleAlphaToCoverage = state; 779 break; 780 case GL_SAMPLE_ALPHA_TO_ONE_ARB: 781 if (ctx->Multisample.SampleAlphaToOne == state) 782 return; 783 FLUSH_VERTICES(ctx, _NEW_MULTISAMPLE); 784 ctx->Multisample.SampleAlphaToOne = state; 785 break; 786 case GL_SAMPLE_COVERAGE_ARB: 787 if (ctx->Multisample.SampleCoverage == state) 788 return; 789 FLUSH_VERTICES(ctx, _NEW_MULTISAMPLE); 790 ctx->Multisample.SampleCoverage = state; 791 break; 792 case GL_SAMPLE_COVERAGE_INVERT_ARB: 793 if (ctx->Multisample.SampleCoverageInvert == state) 794 return; 795 FLUSH_VERTICES(ctx, _NEW_MULTISAMPLE); 796 ctx->Multisample.SampleCoverageInvert = state; 797 break; 798 799 /* GL_IBM_rasterpos_clip */ 800 case GL_RASTER_POSITION_UNCLIPPED_IBM: 801 CHECK_EXTENSION(IBM_rasterpos_clip, cap); 802 if (ctx->Transform.RasterPositionUnclipped == state) 803 return; 804 FLUSH_VERTICES(ctx, _NEW_TRANSFORM); 805 ctx->Transform.RasterPositionUnclipped = state; 806 break; 807 808 /* GL_NV_point_sprite */ 809 case GL_POINT_SPRITE_NV: 810 CHECK_EXTENSION2(NV_point_sprite, ARB_point_sprite, cap); 811 if (ctx->Point.PointSprite == state) 812 return; 813 FLUSH_VERTICES(ctx, _NEW_POINT); 814 ctx->Point.PointSprite = state; 815 break; 816 817#if FEATURE_NV_vertex_program || FEATURE_ARB_vertex_program 818 case GL_VERTEX_PROGRAM_ARB: 819 CHECK_EXTENSION2(ARB_vertex_program, NV_vertex_program, cap); 820 if (ctx->VertexProgram.Enabled == state) 821 return; 822 FLUSH_VERTICES(ctx, _NEW_PROGRAM); 823 ctx->VertexProgram.Enabled = state; 824 break; 825 case GL_VERTEX_PROGRAM_POINT_SIZE_ARB: 826 CHECK_EXTENSION2(ARB_vertex_program, NV_vertex_program, cap); 827 if (ctx->VertexProgram.PointSizeEnabled == state) 828 return; 829 FLUSH_VERTICES(ctx, _NEW_PROGRAM); 830 ctx->VertexProgram.PointSizeEnabled = state; 831 break; 832 case GL_VERTEX_PROGRAM_TWO_SIDE_ARB: 833 CHECK_EXTENSION2(ARB_vertex_program, NV_vertex_program, cap); 834 if (ctx->VertexProgram.TwoSideEnabled == state) 835 return; 836 FLUSH_VERTICES(ctx, _NEW_PROGRAM); 837 ctx->VertexProgram.TwoSideEnabled = state; 838 break; 839#endif 840#if FEATURE_NV_vertex_program 841 case GL_MAP1_VERTEX_ATTRIB0_4_NV: 842 case GL_MAP1_VERTEX_ATTRIB1_4_NV: 843 case GL_MAP1_VERTEX_ATTRIB2_4_NV: 844 case GL_MAP1_VERTEX_ATTRIB3_4_NV: 845 case GL_MAP1_VERTEX_ATTRIB4_4_NV: 846 case GL_MAP1_VERTEX_ATTRIB5_4_NV: 847 case GL_MAP1_VERTEX_ATTRIB6_4_NV: 848 case GL_MAP1_VERTEX_ATTRIB7_4_NV: 849 case GL_MAP1_VERTEX_ATTRIB8_4_NV: 850 case GL_MAP1_VERTEX_ATTRIB9_4_NV: 851 case GL_MAP1_VERTEX_ATTRIB10_4_NV: 852 case GL_MAP1_VERTEX_ATTRIB11_4_NV: 853 case GL_MAP1_VERTEX_ATTRIB12_4_NV: 854 case GL_MAP1_VERTEX_ATTRIB13_4_NV: 855 case GL_MAP1_VERTEX_ATTRIB14_4_NV: 856 case GL_MAP1_VERTEX_ATTRIB15_4_NV: 857 CHECK_EXTENSION(NV_vertex_program, cap); 858 { 859 const GLuint map = (GLuint) (cap - GL_MAP1_VERTEX_ATTRIB0_4_NV); 860 FLUSH_VERTICES(ctx, _NEW_EVAL); 861 ctx->Eval.Map1Attrib[map] = state; 862 } 863 break; 864 case GL_MAP2_VERTEX_ATTRIB0_4_NV: 865 case GL_MAP2_VERTEX_ATTRIB1_4_NV: 866 case GL_MAP2_VERTEX_ATTRIB2_4_NV: 867 case GL_MAP2_VERTEX_ATTRIB3_4_NV: 868 case GL_MAP2_VERTEX_ATTRIB4_4_NV: 869 case GL_MAP2_VERTEX_ATTRIB5_4_NV: 870 case GL_MAP2_VERTEX_ATTRIB6_4_NV: 871 case GL_MAP2_VERTEX_ATTRIB7_4_NV: 872 case GL_MAP2_VERTEX_ATTRIB8_4_NV: 873 case GL_MAP2_VERTEX_ATTRIB9_4_NV: 874 case GL_MAP2_VERTEX_ATTRIB10_4_NV: 875 case GL_MAP2_VERTEX_ATTRIB11_4_NV: 876 case GL_MAP2_VERTEX_ATTRIB12_4_NV: 877 case GL_MAP2_VERTEX_ATTRIB13_4_NV: 878 case GL_MAP2_VERTEX_ATTRIB14_4_NV: 879 case GL_MAP2_VERTEX_ATTRIB15_4_NV: 880 CHECK_EXTENSION(NV_vertex_program, cap); 881 { 882 const GLuint map = (GLuint) (cap - GL_MAP2_VERTEX_ATTRIB0_4_NV); 883 FLUSH_VERTICES(ctx, _NEW_EVAL); 884 ctx->Eval.Map2Attrib[map] = state; 885 } 886 break; 887#endif /* FEATURE_NV_vertex_program */ 888 889#if FEATURE_NV_fragment_program 890 case GL_FRAGMENT_PROGRAM_NV: 891 CHECK_EXTENSION(NV_fragment_program, cap); 892 if (ctx->FragmentProgram.Enabled == state) 893 return; 894 FLUSH_VERTICES(ctx, _NEW_PROGRAM); 895 ctx->FragmentProgram.Enabled = state; 896 break; 897#endif /* FEATURE_NV_fragment_program */ 898 899 /* GL_NV_texture_rectangle */ 900 case GL_TEXTURE_RECTANGLE_NV: 901 CHECK_EXTENSION(NV_texture_rectangle, cap); 902 if (!enable_texture(ctx, state, TEXTURE_RECT_BIT)) { 903 return; 904 } 905 break; 906 907 /* GL_EXT_stencil_two_side */ 908 case GL_STENCIL_TEST_TWO_SIDE_EXT: 909 CHECK_EXTENSION(EXT_stencil_two_side, cap); 910 if (ctx->Stencil.TestTwoSide == state) 911 return; 912 FLUSH_VERTICES(ctx, _NEW_STENCIL); 913 ctx->Stencil.TestTwoSide = state; 914 if (state) { 915 ctx->Stencil._BackFace = 2; 916 ctx->_TriangleCaps |= DD_TRI_TWOSTENCIL; 917 } else { 918 ctx->Stencil._BackFace = 1; 919 ctx->_TriangleCaps &= ~DD_TRI_TWOSTENCIL; 920 } 921 break; 922 923#if FEATURE_ARB_fragment_program 924 case GL_FRAGMENT_PROGRAM_ARB: 925 CHECK_EXTENSION(ARB_fragment_program, cap); 926 if (ctx->FragmentProgram.Enabled == state) 927 return; 928 FLUSH_VERTICES(ctx, _NEW_PROGRAM); 929 ctx->FragmentProgram.Enabled = state; 930 break; 931#endif /* FEATURE_ARB_fragment_program */ 932 933 /* GL_EXT_depth_bounds_test */ 934 case GL_DEPTH_BOUNDS_TEST_EXT: 935 CHECK_EXTENSION(EXT_depth_bounds_test, cap); 936 if (ctx->Depth.BoundsTest == state) 937 return; 938 FLUSH_VERTICES(ctx, _NEW_DEPTH); 939 ctx->Depth.BoundsTest = state; 940 break; 941 942#if FEATURE_ATI_fragment_shader 943 case GL_FRAGMENT_SHADER_ATI: 944 CHECK_EXTENSION(ATI_fragment_shader, cap); 945 if (ctx->ATIFragmentShader.Enabled == state) 946 return; 947 FLUSH_VERTICES(ctx, _NEW_PROGRAM); 948 ctx->ATIFragmentShader.Enabled = state; 949 break; 950#endif 951 952 /* GL_MESA_texture_array */ 953 case GL_TEXTURE_1D_ARRAY_EXT: 954 CHECK_EXTENSION(MESA_texture_array, cap); 955 if (!enable_texture(ctx, state, TEXTURE_1D_ARRAY_BIT)) { 956 return; 957 } 958 break; 959 960 case GL_TEXTURE_2D_ARRAY_EXT: 961 CHECK_EXTENSION(MESA_texture_array, cap); 962 if (!enable_texture(ctx, state, TEXTURE_2D_ARRAY_BIT)) { 963 return; 964 } 965 break; 966 967 default: 968 _mesa_error(ctx, GL_INVALID_ENUM, 969 "%s(0x%x)", state ? "glEnable" : "glDisable", cap); 970 return; 971 } 972 973 if (ctx->Driver.Enable) { 974 ctx->Driver.Enable( ctx, cap, state ); 975 } 976} 977 978 979/** 980 * Enable GL capability. Called by glEnable() 981 * \param cap state to enable. 982 */ 983void GLAPIENTRY 984_mesa_Enable( GLenum cap ) 985{ 986 GET_CURRENT_CONTEXT(ctx); 987 ASSERT_OUTSIDE_BEGIN_END(ctx); 988 989 _mesa_set_enable( ctx, cap, GL_TRUE ); 990} 991 992 993/** 994 * Disable GL capability. Called by glDisable() 995 * \param cap state to disable. 996 */ 997void GLAPIENTRY 998_mesa_Disable( GLenum cap ) 999{ 1000 GET_CURRENT_CONTEXT(ctx); 1001 ASSERT_OUTSIDE_BEGIN_END(ctx); 1002 1003 _mesa_set_enable( ctx, cap, GL_FALSE ); 1004} 1005 1006 1007#undef CHECK_EXTENSION 1008#define CHECK_EXTENSION(EXTNAME) \ 1009 if (!ctx->Extensions.EXTNAME) { \ 1010 _mesa_error(ctx, GL_INVALID_ENUM, "glIsEnabled"); \ 1011 return GL_FALSE; \ 1012 } 1013 1014#undef CHECK_EXTENSION2 1015#define CHECK_EXTENSION2(EXT1, EXT2) \ 1016 if (!ctx->Extensions.EXT1 && !ctx->Extensions.EXT2) { \ 1017 _mesa_error(ctx, GL_INVALID_ENUM, "glIsEnabled"); \ 1018 return GL_FALSE; \ 1019 } 1020 1021 1022/** 1023 * Helper function to determine whether a texture target is enabled. 1024 */ 1025static GLboolean 1026is_texture_enabled(GLcontext *ctx, GLbitfield bit) 1027{ 1028 const struct gl_texture_unit *const texUnit = 1029 &ctx->Texture.Unit[ctx->Texture.CurrentUnit]; 1030 return (texUnit->Enabled & bit) ? GL_TRUE : GL_FALSE; 1031} 1032 1033 1034/** 1035 * Return simple enable/disable state. 1036 * 1037 * \param cap state variable to query. 1038 * 1039 * Returns the state of the specified capability from the current GL context. 1040 * For the capabilities associated with extensions verifies that those 1041 * extensions are effectively present before reporting. 1042 */ 1043GLboolean GLAPIENTRY 1044_mesa_IsEnabled( GLenum cap ) 1045{ 1046 GET_CURRENT_CONTEXT(ctx); 1047 switch (cap) { 1048 case GL_ALPHA_TEST: 1049 return ctx->Color.AlphaEnabled; 1050 case GL_AUTO_NORMAL: 1051 return ctx->Eval.AutoNormal; 1052 case GL_BLEND: 1053 return ctx->Color.BlendEnabled; 1054 case GL_CLIP_PLANE0: 1055 case GL_CLIP_PLANE1: 1056 case GL_CLIP_PLANE2: 1057 case GL_CLIP_PLANE3: 1058 case GL_CLIP_PLANE4: 1059 case GL_CLIP_PLANE5: 1060 return (ctx->Transform.ClipPlanesEnabled >> (cap - GL_CLIP_PLANE0)) & 1; 1061 case GL_COLOR_MATERIAL: 1062 return ctx->Light.ColorMaterialEnabled; 1063 case GL_CULL_FACE: 1064 return ctx->Polygon.CullFlag; 1065 case GL_DEPTH_TEST: 1066 return ctx->Depth.Test; 1067 case GL_DITHER: 1068 return ctx->Color.DitherFlag; 1069 case GL_FOG: 1070 return ctx->Fog.Enabled; 1071 case GL_LIGHTING: 1072 return ctx->Light.Enabled; 1073 case GL_LIGHT0: 1074 case GL_LIGHT1: 1075 case GL_LIGHT2: 1076 case GL_LIGHT3: 1077 case GL_LIGHT4: 1078 case GL_LIGHT5: 1079 case GL_LIGHT6: 1080 case GL_LIGHT7: 1081 return ctx->Light.Light[cap-GL_LIGHT0].Enabled; 1082 case GL_LINE_SMOOTH: 1083 return ctx->Line.SmoothFlag; 1084 case GL_LINE_STIPPLE: 1085 return ctx->Line.StippleFlag; 1086 case GL_INDEX_LOGIC_OP: 1087 return ctx->Color.IndexLogicOpEnabled; 1088 case GL_COLOR_LOGIC_OP: 1089 return ctx->Color.ColorLogicOpEnabled; 1090 case GL_MAP1_COLOR_4: 1091 return ctx->Eval.Map1Color4; 1092 case GL_MAP1_INDEX: 1093 return ctx->Eval.Map1Index; 1094 case GL_MAP1_NORMAL: 1095 return ctx->Eval.Map1Normal; 1096 case GL_MAP1_TEXTURE_COORD_1: 1097 return ctx->Eval.Map1TextureCoord1; 1098 case GL_MAP1_TEXTURE_COORD_2: 1099 return ctx->Eval.Map1TextureCoord2; 1100 case GL_MAP1_TEXTURE_COORD_3: 1101 return ctx->Eval.Map1TextureCoord3; 1102 case GL_MAP1_TEXTURE_COORD_4: 1103 return ctx->Eval.Map1TextureCoord4; 1104 case GL_MAP1_VERTEX_3: 1105 return ctx->Eval.Map1Vertex3; 1106 case GL_MAP1_VERTEX_4: 1107 return ctx->Eval.Map1Vertex4; 1108 case GL_MAP2_COLOR_4: 1109 return ctx->Eval.Map2Color4; 1110 case GL_MAP2_INDEX: 1111 return ctx->Eval.Map2Index; 1112 case GL_MAP2_NORMAL: 1113 return ctx->Eval.Map2Normal; 1114 case GL_MAP2_TEXTURE_COORD_1: 1115 return ctx->Eval.Map2TextureCoord1; 1116 case GL_MAP2_TEXTURE_COORD_2: 1117 return ctx->Eval.Map2TextureCoord2; 1118 case GL_MAP2_TEXTURE_COORD_3: 1119 return ctx->Eval.Map2TextureCoord3; 1120 case GL_MAP2_TEXTURE_COORD_4: 1121 return ctx->Eval.Map2TextureCoord4; 1122 case GL_MAP2_VERTEX_3: 1123 return ctx->Eval.Map2Vertex3; 1124 case GL_MAP2_VERTEX_4: 1125 return ctx->Eval.Map2Vertex4; 1126 case GL_NORMALIZE: 1127 return ctx->Transform.Normalize; 1128 case GL_POINT_SMOOTH: 1129 return ctx->Point.SmoothFlag; 1130 case GL_POLYGON_SMOOTH: 1131 return ctx->Polygon.SmoothFlag; 1132 case GL_POLYGON_STIPPLE: 1133 return ctx->Polygon.StippleFlag; 1134 case GL_POLYGON_OFFSET_POINT: 1135 return ctx->Polygon.OffsetPoint; 1136 case GL_POLYGON_OFFSET_LINE: 1137 return ctx->Polygon.OffsetLine; 1138 case GL_POLYGON_OFFSET_FILL: 1139 /*case GL_POLYGON_OFFSET_EXT:*/ 1140 return ctx->Polygon.OffsetFill; 1141 case GL_RESCALE_NORMAL_EXT: 1142 return ctx->Transform.RescaleNormals; 1143 case GL_SCISSOR_TEST: 1144 return ctx->Scissor.Enabled; 1145 case GL_SHARED_TEXTURE_PALETTE_EXT: 1146 return ctx->Texture.SharedPalette; 1147 case GL_STENCIL_TEST: 1148 return ctx->Stencil.Enabled; 1149 case GL_TEXTURE_1D: 1150 return is_texture_enabled(ctx, TEXTURE_1D_BIT); 1151 case GL_TEXTURE_2D: 1152 return is_texture_enabled(ctx, TEXTURE_2D_BIT); 1153 case GL_TEXTURE_3D: 1154 return is_texture_enabled(ctx, TEXTURE_3D_BIT); 1155 case GL_TEXTURE_GEN_Q: 1156 { 1157 const struct gl_texture_unit *texUnit = get_texcoord_unit(ctx); 1158 if (texUnit) { 1159 return (texUnit->TexGenEnabled & Q_BIT) ? GL_TRUE : GL_FALSE; 1160 } 1161 } 1162 return GL_FALSE; 1163 case GL_TEXTURE_GEN_R: 1164 { 1165 const struct gl_texture_unit *texUnit = get_texcoord_unit(ctx); 1166 if (texUnit) { 1167 return (texUnit->TexGenEnabled & R_BIT) ? GL_TRUE : GL_FALSE; 1168 } 1169 } 1170 return GL_FALSE; 1171 case GL_TEXTURE_GEN_S: 1172 { 1173 const struct gl_texture_unit *texUnit = get_texcoord_unit(ctx); 1174 if (texUnit) { 1175 return (texUnit->TexGenEnabled & S_BIT) ? GL_TRUE : GL_FALSE; 1176 } 1177 } 1178 return GL_FALSE; 1179 case GL_TEXTURE_GEN_T: 1180 { 1181 const struct gl_texture_unit *texUnit = get_texcoord_unit(ctx); 1182 if (texUnit) { 1183 return (texUnit->TexGenEnabled & T_BIT) ? GL_TRUE : GL_FALSE; 1184 } 1185 } 1186 return GL_FALSE; 1187 1188 /* 1189 * CLIENT STATE!!! 1190 */ 1191 case GL_VERTEX_ARRAY: 1192 return (ctx->Array.ArrayObj->Vertex.Enabled != 0); 1193 case GL_NORMAL_ARRAY: 1194 return (ctx->Array.ArrayObj->Normal.Enabled != 0); 1195 case GL_COLOR_ARRAY: 1196 return (ctx->Array.ArrayObj->Color.Enabled != 0); 1197 case GL_INDEX_ARRAY: 1198 return (ctx->Array.ArrayObj->Index.Enabled != 0); 1199 case GL_TEXTURE_COORD_ARRAY: 1200 return (ctx->Array.ArrayObj->TexCoord[ctx->Array.ActiveTexture].Enabled != 0); 1201 case GL_EDGE_FLAG_ARRAY: 1202 return (ctx->Array.ArrayObj->EdgeFlag.Enabled != 0); 1203 case GL_FOG_COORDINATE_ARRAY_EXT: 1204 CHECK_EXTENSION(EXT_fog_coord); 1205 return (ctx->Array.ArrayObj->FogCoord.Enabled != 0); 1206 case GL_SECONDARY_COLOR_ARRAY_EXT: 1207 CHECK_EXTENSION(EXT_secondary_color); 1208 return (ctx->Array.ArrayObj->SecondaryColor.Enabled != 0); 1209#if FEATURE_point_size_array 1210 case GL_POINT_SIZE_ARRAY_OES: 1211 return (ctx->Array.ArrayObj->PointSize.Enabled != 0); 1212#endif 1213 1214 /* GL_EXT_histogram */ 1215 case GL_HISTOGRAM: 1216 CHECK_EXTENSION(EXT_histogram); 1217 return ctx->Pixel.HistogramEnabled; 1218 case GL_MINMAX: 1219 CHECK_EXTENSION(EXT_histogram); 1220 return ctx->Pixel.MinMaxEnabled; 1221 1222 /* GL_SGI_color_table */ 1223 case GL_COLOR_TABLE_SGI: 1224 CHECK_EXTENSION(SGI_color_table); 1225 return ctx->Pixel.ColorTableEnabled[COLORTABLE_PRECONVOLUTION]; 1226 case GL_POST_CONVOLUTION_COLOR_TABLE_SGI: 1227 CHECK_EXTENSION(SGI_color_table); 1228 return ctx->Pixel.ColorTableEnabled[COLORTABLE_POSTCONVOLUTION]; 1229 case GL_POST_COLOR_MATRIX_COLOR_TABLE_SGI: 1230 CHECK_EXTENSION(SGI_color_table); 1231 return ctx->Pixel.ColorTableEnabled[COLORTABLE_POSTCOLORMATRIX]; 1232 1233 /* GL_SGI_texture_color_table */ 1234 case GL_TEXTURE_COLOR_TABLE_SGI: 1235 CHECK_EXTENSION(SGI_texture_color_table); 1236 return ctx->Texture.Unit[ctx->Texture.CurrentUnit].ColorTableEnabled; 1237 1238 /* GL_EXT_convolution */ 1239 case GL_CONVOLUTION_1D: 1240 CHECK_EXTENSION(EXT_convolution); 1241 return ctx->Pixel.Convolution1DEnabled; 1242 case GL_CONVOLUTION_2D: 1243 CHECK_EXTENSION(EXT_convolution); 1244 return ctx->Pixel.Convolution2DEnabled; 1245 case GL_SEPARABLE_2D: 1246 CHECK_EXTENSION(EXT_convolution); 1247 return ctx->Pixel.Separable2DEnabled; 1248 1249 /* GL_ARB_texture_cube_map */ 1250 case GL_TEXTURE_CUBE_MAP_ARB: 1251 CHECK_EXTENSION(ARB_texture_cube_map); 1252 return is_texture_enabled(ctx, TEXTURE_CUBE_BIT); 1253 1254 /* GL_EXT_secondary_color */ 1255 case GL_COLOR_SUM_EXT: 1256 CHECK_EXTENSION2(EXT_secondary_color, ARB_vertex_program); 1257 return ctx->Fog.ColorSumEnabled; 1258 1259 /* GL_ARB_multisample */ 1260 case GL_MULTISAMPLE_ARB: 1261 return ctx->Multisample.Enabled; 1262 case GL_SAMPLE_ALPHA_TO_COVERAGE_ARB: 1263 return ctx->Multisample.SampleAlphaToCoverage; 1264 case GL_SAMPLE_ALPHA_TO_ONE_ARB: 1265 return ctx->Multisample.SampleAlphaToOne; 1266 case GL_SAMPLE_COVERAGE_ARB: 1267 return ctx->Multisample.SampleCoverage; 1268 case GL_SAMPLE_COVERAGE_INVERT_ARB: 1269 return ctx->Multisample.SampleCoverageInvert; 1270 1271 /* GL_IBM_rasterpos_clip */ 1272 case GL_RASTER_POSITION_UNCLIPPED_IBM: 1273 CHECK_EXTENSION(IBM_rasterpos_clip); 1274 return ctx->Transform.RasterPositionUnclipped; 1275 1276 /* GL_NV_point_sprite */ 1277 case GL_POINT_SPRITE_NV: 1278 CHECK_EXTENSION2(NV_point_sprite, ARB_point_sprite) 1279 return ctx->Point.PointSprite; 1280 1281#if FEATURE_NV_vertex_program || FEATURE_ARB_vertex_program 1282 case GL_VERTEX_PROGRAM_ARB: 1283 CHECK_EXTENSION2(ARB_vertex_program, NV_vertex_program); 1284 return ctx->VertexProgram.Enabled; 1285 case GL_VERTEX_PROGRAM_POINT_SIZE_ARB: 1286 CHECK_EXTENSION2(ARB_vertex_program, NV_vertex_program); 1287 return ctx->VertexProgram.PointSizeEnabled; 1288 case GL_VERTEX_PROGRAM_TWO_SIDE_ARB: 1289 CHECK_EXTENSION2(ARB_vertex_program, NV_vertex_program); 1290 return ctx->VertexProgram.TwoSideEnabled; 1291#endif 1292#if FEATURE_NV_vertex_program 1293 case GL_VERTEX_ATTRIB_ARRAY0_NV: 1294 case GL_VERTEX_ATTRIB_ARRAY1_NV: 1295 case GL_VERTEX_ATTRIB_ARRAY2_NV: 1296 case GL_VERTEX_ATTRIB_ARRAY3_NV: 1297 case GL_VERTEX_ATTRIB_ARRAY4_NV: 1298 case GL_VERTEX_ATTRIB_ARRAY5_NV: 1299 case GL_VERTEX_ATTRIB_ARRAY6_NV: 1300 case GL_VERTEX_ATTRIB_ARRAY7_NV: 1301 case GL_VERTEX_ATTRIB_ARRAY8_NV: 1302 case GL_VERTEX_ATTRIB_ARRAY9_NV: 1303 case GL_VERTEX_ATTRIB_ARRAY10_NV: 1304 case GL_VERTEX_ATTRIB_ARRAY11_NV: 1305 case GL_VERTEX_ATTRIB_ARRAY12_NV: 1306 case GL_VERTEX_ATTRIB_ARRAY13_NV: 1307 case GL_VERTEX_ATTRIB_ARRAY14_NV: 1308 case GL_VERTEX_ATTRIB_ARRAY15_NV: 1309 CHECK_EXTENSION(NV_vertex_program); 1310 { 1311 GLint n = (GLint) cap - GL_VERTEX_ATTRIB_ARRAY0_NV; 1312 return (ctx->Array.ArrayObj->VertexAttrib[n].Enabled != 0); 1313 } 1314 case GL_MAP1_VERTEX_ATTRIB0_4_NV: 1315 case GL_MAP1_VERTEX_ATTRIB1_4_NV: 1316 case GL_MAP1_VERTEX_ATTRIB2_4_NV: 1317 case GL_MAP1_VERTEX_ATTRIB3_4_NV: 1318 case GL_MAP1_VERTEX_ATTRIB4_4_NV: 1319 case GL_MAP1_VERTEX_ATTRIB5_4_NV: 1320 case GL_MAP1_VERTEX_ATTRIB6_4_NV: 1321 case GL_MAP1_VERTEX_ATTRIB7_4_NV: 1322 case GL_MAP1_VERTEX_ATTRIB8_4_NV: 1323 case GL_MAP1_VERTEX_ATTRIB9_4_NV: 1324 case GL_MAP1_VERTEX_ATTRIB10_4_NV: 1325 case GL_MAP1_VERTEX_ATTRIB11_4_NV: 1326 case GL_MAP1_VERTEX_ATTRIB12_4_NV: 1327 case GL_MAP1_VERTEX_ATTRIB13_4_NV: 1328 case GL_MAP1_VERTEX_ATTRIB14_4_NV: 1329 case GL_MAP1_VERTEX_ATTRIB15_4_NV: 1330 CHECK_EXTENSION(NV_vertex_program); 1331 { 1332 const GLuint map = (GLuint) (cap - GL_MAP1_VERTEX_ATTRIB0_4_NV); 1333 return ctx->Eval.Map1Attrib[map]; 1334 } 1335 case GL_MAP2_VERTEX_ATTRIB0_4_NV: 1336 case GL_MAP2_VERTEX_ATTRIB1_4_NV: 1337 case GL_MAP2_VERTEX_ATTRIB2_4_NV: 1338 case GL_MAP2_VERTEX_ATTRIB3_4_NV: 1339 case GL_MAP2_VERTEX_ATTRIB4_4_NV: 1340 case GL_MAP2_VERTEX_ATTRIB5_4_NV: 1341 case GL_MAP2_VERTEX_ATTRIB6_4_NV: 1342 case GL_MAP2_VERTEX_ATTRIB7_4_NV: 1343 case GL_MAP2_VERTEX_ATTRIB8_4_NV: 1344 case GL_MAP2_VERTEX_ATTRIB9_4_NV: 1345 case GL_MAP2_VERTEX_ATTRIB10_4_NV: 1346 case GL_MAP2_VERTEX_ATTRIB11_4_NV: 1347 case GL_MAP2_VERTEX_ATTRIB12_4_NV: 1348 case GL_MAP2_VERTEX_ATTRIB13_4_NV: 1349 case GL_MAP2_VERTEX_ATTRIB14_4_NV: 1350 case GL_MAP2_VERTEX_ATTRIB15_4_NV: 1351 CHECK_EXTENSION(NV_vertex_program); 1352 { 1353 const GLuint map = (GLuint) (cap - GL_MAP2_VERTEX_ATTRIB0_4_NV); 1354 return ctx->Eval.Map2Attrib[map]; 1355 } 1356#endif /* FEATURE_NV_vertex_program */ 1357 1358#if FEATURE_NV_fragment_program 1359 case GL_FRAGMENT_PROGRAM_NV: 1360 CHECK_EXTENSION(NV_fragment_program); 1361 return ctx->FragmentProgram.Enabled; 1362#endif /* FEATURE_NV_fragment_program */ 1363 1364 /* GL_NV_texture_rectangle */ 1365 case GL_TEXTURE_RECTANGLE_NV: 1366 CHECK_EXTENSION(NV_texture_rectangle); 1367 return is_texture_enabled(ctx, TEXTURE_RECT_BIT); 1368 1369 /* GL_EXT_stencil_two_side */ 1370 case GL_STENCIL_TEST_TWO_SIDE_EXT: 1371 CHECK_EXTENSION(EXT_stencil_two_side); 1372 return ctx->Stencil.TestTwoSide; 1373 1374#if FEATURE_ARB_fragment_program 1375 case GL_FRAGMENT_PROGRAM_ARB: 1376 return ctx->FragmentProgram.Enabled; 1377#endif /* FEATURE_ARB_fragment_program */ 1378 1379 /* GL_EXT_depth_bounds_test */ 1380 case GL_DEPTH_BOUNDS_TEST_EXT: 1381 CHECK_EXTENSION(EXT_depth_bounds_test); 1382 return ctx->Depth.BoundsTest; 1383 1384#if FEATURE_ATI_fragment_shader 1385 case GL_FRAGMENT_SHADER_ATI: 1386 CHECK_EXTENSION(ATI_fragment_shader); 1387 return ctx->ATIFragmentShader.Enabled; 1388#endif /* FEATURE_ATI_fragment_shader */ 1389 default: 1390 _mesa_error(ctx, GL_INVALID_ENUM, "glIsEnabled(0x%x)", (int) cap); 1391 return GL_FALSE; 1392 } 1393} 1394