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