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