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