ReactOS Development > Doxygen
enable.c
Go to the documentation of this file.
00001 00006 /* 00007 * Mesa 3-D graphics library 00008 * Version: 7.0.3 00009 * 00010 * Copyright (C) 1999-2007 Brian Paul All Rights Reserved. 00011 * 00012 * Permission is hereby granted, free of charge, to any person obtaining a 00013 * copy of this software and associated documentation files (the "Software"), 00014 * to deal in the Software without restriction, including without limitation 00015 * the rights to use, copy, modify, merge, publish, distribute, sublicense, 00016 * and/or sell copies of the Software, and to permit persons to whom the 00017 * Software is furnished to do so, subject to the following conditions: 00018 * 00019 * The above copyright notice and this permission notice shall be included 00020 * in all copies or substantial portions of the Software. 00021 * 00022 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS 00023 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 00024 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL 00025 * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN 00026 * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN 00027 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. 00028 */ 00029 00030 00031 #include "glheader.h" 00032 #include "context.h" 00033 #include "enable.h" 00034 #include "light.h" 00035 #include "macros.h" 00036 #include "simple_list.h" 00037 #include "mtypes.h" 00038 #include "enums.h" 00039 #include "math/m_matrix.h" 00040 #include "math/m_xform.h" 00041 #include "api_arrayelt.h" 00042 00043 00044 00045 #define CHECK_EXTENSION(EXTNAME, CAP) \ 00046 if (!ctx->Extensions.EXTNAME) { \ 00047 _mesa_error(ctx, GL_INVALID_ENUM, "gl%sClientState(0x%x)", \ 00048 state ? "Enable" : "Disable", CAP); \ 00049 return; \ 00050 } 00051 00052 00056 static void 00057 client_state(GLcontext *ctx, GLenum cap, GLboolean state) 00058 { 00059 GLuint flag; 00060 GLboolean *var; 00061 00062 switch (cap) { 00063 case GL_VERTEX_ARRAY: 00064 var = &ctx->Array.ArrayObj->Vertex.Enabled; 00065 flag = _NEW_ARRAY_VERTEX; 00066 break; 00067 case GL_NORMAL_ARRAY: 00068 var = &ctx->Array.ArrayObj->Normal.Enabled; 00069 flag = _NEW_ARRAY_NORMAL; 00070 break; 00071 case GL_COLOR_ARRAY: 00072 var = &ctx->Array.ArrayObj->Color.Enabled; 00073 flag = _NEW_ARRAY_COLOR0; 00074 break; 00075 case GL_INDEX_ARRAY: 00076 var = &ctx->Array.ArrayObj->Index.Enabled; 00077 flag = _NEW_ARRAY_INDEX; 00078 break; 00079 case GL_TEXTURE_COORD_ARRAY: 00080 var = &ctx->Array.ArrayObj->TexCoord[ctx->Array.ActiveTexture].Enabled; 00081 flag = _NEW_ARRAY_TEXCOORD(ctx->Array.ActiveTexture); 00082 break; 00083 case GL_EDGE_FLAG_ARRAY: 00084 var = &ctx->Array.ArrayObj->EdgeFlag.Enabled; 00085 flag = _NEW_ARRAY_EDGEFLAG; 00086 break; 00087 case GL_FOG_COORDINATE_ARRAY_EXT: 00088 var = &ctx->Array.ArrayObj->FogCoord.Enabled; 00089 flag = _NEW_ARRAY_FOGCOORD; 00090 break; 00091 case GL_SECONDARY_COLOR_ARRAY_EXT: 00092 var = &ctx->Array.ArrayObj->SecondaryColor.Enabled; 00093 flag = _NEW_ARRAY_COLOR1; 00094 break; 00095 00096 #if FEATURE_point_size_array 00097 case GL_POINT_SIZE_ARRAY_OES: 00098 var = &ctx->Array.ArrayObj->PointSize.Enabled; 00099 flag = _NEW_ARRAY_POINT_SIZE; 00100 break; 00101 #endif 00102 00103 #if FEATURE_NV_vertex_program 00104 case GL_VERTEX_ATTRIB_ARRAY0_NV: 00105 case GL_VERTEX_ATTRIB_ARRAY1_NV: 00106 case GL_VERTEX_ATTRIB_ARRAY2_NV: 00107 case GL_VERTEX_ATTRIB_ARRAY3_NV: 00108 case GL_VERTEX_ATTRIB_ARRAY4_NV: 00109 case GL_VERTEX_ATTRIB_ARRAY5_NV: 00110 case GL_VERTEX_ATTRIB_ARRAY6_NV: 00111 case GL_VERTEX_ATTRIB_ARRAY7_NV: 00112 case GL_VERTEX_ATTRIB_ARRAY8_NV: 00113 case GL_VERTEX_ATTRIB_ARRAY9_NV: 00114 case GL_VERTEX_ATTRIB_ARRAY10_NV: 00115 case GL_VERTEX_ATTRIB_ARRAY11_NV: 00116 case GL_VERTEX_ATTRIB_ARRAY12_NV: 00117 case GL_VERTEX_ATTRIB_ARRAY13_NV: 00118 case GL_VERTEX_ATTRIB_ARRAY14_NV: 00119 case GL_VERTEX_ATTRIB_ARRAY15_NV: 00120 CHECK_EXTENSION(NV_vertex_program, cap); 00121 { 00122 GLint n = (GLint) cap - GL_VERTEX_ATTRIB_ARRAY0_NV; 00123 var = &ctx->Array.ArrayObj->VertexAttrib[n].Enabled; 00124 flag = _NEW_ARRAY_ATTRIB(n); 00125 } 00126 break; 00127 #endif /* FEATURE_NV_vertex_program */ 00128 00129 default: 00130 _mesa_error( ctx, GL_INVALID_ENUM, 00131 "glEnable/DisableClientState(0x%x)", cap); 00132 return; 00133 } 00134 00135 if (*var == state) 00136 return; 00137 00138 FLUSH_VERTICES(ctx, _NEW_ARRAY); 00139 ctx->Array.NewState |= flag; 00140 00141 _ae_invalidate_state(ctx, _NEW_ARRAY); 00142 00143 *var = state; 00144 00145 if (state) 00146 ctx->Array.ArrayObj->_Enabled |= flag; 00147 else 00148 ctx->Array.ArrayObj->_Enabled &= ~flag; 00149 00150 if (ctx->Driver.Enable) { 00151 ctx->Driver.Enable( ctx, cap, state ); 00152 } 00153 } 00154 00155 00163 void GLAPIENTRY 00164 _mesa_EnableClientState( GLenum cap ) 00165 { 00166 GET_CURRENT_CONTEXT(ctx); 00167 ASSERT_OUTSIDE_BEGIN_END(ctx); 00168 client_state( ctx, cap, GL_TRUE ); 00169 } 00170 00171 00179 void GLAPIENTRY 00180 _mesa_DisableClientState( GLenum cap ) 00181 { 00182 GET_CURRENT_CONTEXT(ctx); 00183 ASSERT_OUTSIDE_BEGIN_END(ctx); 00184 client_state( ctx, cap, GL_FALSE ); 00185 } 00186 00187 00188 #undef CHECK_EXTENSION 00189 #define CHECK_EXTENSION(EXTNAME, CAP) \ 00190 if (!ctx->Extensions.EXTNAME) { \ 00191 _mesa_error(ctx, GL_INVALID_ENUM, "gl%s(0x%x)", \ 00192 state ? "Enable" : "Disable", CAP); \ 00193 return; \ 00194 } 00195 00196 #define CHECK_EXTENSION2(EXT1, EXT2, CAP) \ 00197 if (!ctx->Extensions.EXT1 && !ctx->Extensions.EXT2) { \ 00198 _mesa_error(ctx, GL_INVALID_ENUM, "gl%s(0x%x)", \ 00199 state ? "Enable" : "Disable", CAP); \ 00200 return; \ 00201 } 00202 00203 00204 00211 static struct gl_texture_unit * 00212 get_texcoord_unit(GLcontext *ctx) 00213 { 00214 if (ctx->Texture.CurrentUnit >= ctx->Const.MaxTextureCoordUnits) { 00215 _mesa_error(ctx, GL_INVALID_OPERATION, "glEnable/Disable(texcoord unit)"); 00216 return NULL; 00217 } 00218 else { 00219 return &ctx->Texture.Unit[ctx->Texture.CurrentUnit]; 00220 } 00221 } 00222 00223 00227 static GLboolean 00228 enable_texture(GLcontext *ctx, GLboolean state, GLbitfield bit) 00229 { 00230 const GLuint curr = ctx->Texture.CurrentUnit; 00231 struct gl_texture_unit *texUnit = &ctx->Texture.Unit[curr]; 00232 const GLuint newenabled = (!state) 00233 ? (texUnit->Enabled & ~bit) : (texUnit->Enabled | bit); 00234 00235 if (!ctx->DrawBuffer->Visual.rgbMode || texUnit->Enabled == newenabled) 00236 return GL_FALSE; 00237 00238 FLUSH_VERTICES(ctx, _NEW_TEXTURE); 00239 texUnit->Enabled = newenabled; 00240 return GL_TRUE; 00241 } 00242 00243 00256 void 00257 _mesa_set_enable(GLcontext *ctx, GLenum cap, GLboolean state) 00258 { 00259 if (MESA_VERBOSE & VERBOSE_API) 00260 _mesa_debug(ctx, "%s %s (newstate is %x)\n", 00261 state ? "glEnable" : "glDisable", 00262 _mesa_lookup_enum_by_nr(cap), 00263 ctx->NewState); 00264 00265 switch (cap) { 00266 case GL_ALPHA_TEST: 00267 if (ctx->Color.AlphaEnabled == state) 00268 return; 00269 FLUSH_VERTICES(ctx, _NEW_COLOR); 00270 ctx->Color.AlphaEnabled = state; 00271 break; 00272 case GL_AUTO_NORMAL: 00273 if (ctx->Eval.AutoNormal == state) 00274 return; 00275 FLUSH_VERTICES(ctx, _NEW_EVAL); 00276 ctx->Eval.AutoNormal = state; 00277 break; 00278 case GL_BLEND: 00279 if (ctx->Color.BlendEnabled == state) 00280 return; 00281 FLUSH_VERTICES(ctx, _NEW_COLOR); 00282 ctx->Color.BlendEnabled = state; 00283 break; 00284 #if FEATURE_userclip 00285 case GL_CLIP_PLANE0: 00286 case GL_CLIP_PLANE1: 00287 case GL_CLIP_PLANE2: 00288 case GL_CLIP_PLANE3: 00289 case GL_CLIP_PLANE4: 00290 case GL_CLIP_PLANE5: 00291 { 00292 const GLuint p = cap - GL_CLIP_PLANE0; 00293 00294 if ((ctx->Transform.ClipPlanesEnabled & (1 << p)) == ((GLuint) state << p)) 00295 return; 00296 00297 FLUSH_VERTICES(ctx, _NEW_TRANSFORM); 00298 00299 if (state) { 00300 ctx->Transform.ClipPlanesEnabled |= (1 << p); 00301 00302 if (_math_matrix_is_dirty(ctx->ProjectionMatrixStack.Top)) 00303 _math_matrix_analyse( ctx->ProjectionMatrixStack.Top ); 00304 00305 /* This derived state also calculated in clip.c and 00306 * from _mesa_update_state() on changes to EyeUserPlane 00307 * and ctx->ProjectionMatrix respectively. 00308 */ 00309 _mesa_transform_vector( ctx->Transform._ClipUserPlane[p], 00310 ctx->Transform.EyeUserPlane[p], 00311 ctx->ProjectionMatrixStack.Top->inv ); 00312 } 00313 else { 00314 ctx->Transform.ClipPlanesEnabled &= ~(1 << p); 00315 } 00316 } 00317 break; 00318 #endif 00319 case GL_COLOR_MATERIAL: 00320 if (ctx->Light.ColorMaterialEnabled == state) 00321 return; 00322 FLUSH_VERTICES(ctx, _NEW_LIGHT); 00323 FLUSH_CURRENT(ctx, 0); 00324 ctx->Light.ColorMaterialEnabled = state; 00325 if (state) { 00326 _mesa_update_color_material( ctx, 00327 ctx->Current.Attrib[VERT_ATTRIB_COLOR0] ); 00328 } 00329 break; 00330 case GL_CULL_FACE: 00331 if (ctx->Polygon.CullFlag == state) 00332 return; 00333 FLUSH_VERTICES(ctx, _NEW_POLYGON); 00334 ctx->Polygon.CullFlag = state; 00335 break; 00336 case GL_CULL_VERTEX_EXT: 00337 CHECK_EXTENSION(EXT_cull_vertex, cap); 00338 if (ctx->Transform.CullVertexFlag == state) 00339 return; 00340 FLUSH_VERTICES(ctx, _NEW_TRANSFORM); 00341 ctx->Transform.CullVertexFlag = state; 00342 break; 00343 case GL_DEPTH_TEST: 00344 if (ctx->Depth.Test == state) 00345 return; 00346 FLUSH_VERTICES(ctx, _NEW_DEPTH); 00347 ctx->Depth.Test = state; 00348 break; 00349 case GL_DITHER: 00350 if (ctx->NoDither) { 00351 state = GL_FALSE; /* MESA_NO_DITHER env var */ 00352 } 00353 if (ctx->Color.DitherFlag == state) 00354 return; 00355 FLUSH_VERTICES(ctx, _NEW_COLOR); 00356 ctx->Color.DitherFlag = state; 00357 break; 00358 case GL_FOG: 00359 if (ctx->Fog.Enabled == state) 00360 return; 00361 FLUSH_VERTICES(ctx, _NEW_FOG); 00362 ctx->Fog.Enabled = state; 00363 break; 00364 case GL_HISTOGRAM: 00365 CHECK_EXTENSION(EXT_histogram, cap); 00366 if (ctx->Pixel.HistogramEnabled == state) 00367 return; 00368 FLUSH_VERTICES(ctx, _NEW_PIXEL); 00369 ctx->Pixel.HistogramEnabled = state; 00370 break; 00371 case GL_LIGHT0: 00372 case GL_LIGHT1: 00373 case GL_LIGHT2: 00374 case GL_LIGHT3: 00375 case GL_LIGHT4: 00376 case GL_LIGHT5: 00377 case GL_LIGHT6: 00378 case GL_LIGHT7: 00379 if (ctx->Light.Light[cap-GL_LIGHT0].Enabled == state) 00380 return; 00381 FLUSH_VERTICES(ctx, _NEW_LIGHT); 00382 ctx->Light.Light[cap-GL_LIGHT0].Enabled = state; 00383 if (state) { 00384 insert_at_tail(&ctx->Light.EnabledList, 00385 &ctx->Light.Light[cap-GL_LIGHT0]); 00386 } 00387 else { 00388 remove_from_list(&ctx->Light.Light[cap-GL_LIGHT0]); 00389 } 00390 break; 00391 case GL_LIGHTING: 00392 if (ctx->Light.Enabled == state) 00393 return; 00394 FLUSH_VERTICES(ctx, _NEW_LIGHT); 00395 ctx->Light.Enabled = state; 00396 if (ctx->Light.Enabled && ctx->Light.Model.TwoSide) 00397 ctx->_TriangleCaps |= DD_TRI_LIGHT_TWOSIDE; 00398 else 00399 ctx->_TriangleCaps &= ~DD_TRI_LIGHT_TWOSIDE; 00400 break; 00401 case GL_LINE_SMOOTH: 00402 if (ctx->Line.SmoothFlag == state) 00403 return; 00404 FLUSH_VERTICES(ctx, _NEW_LINE); 00405 ctx->Line.SmoothFlag = state; 00406 ctx->_TriangleCaps ^= DD_LINE_SMOOTH; 00407 break; 00408 case GL_LINE_STIPPLE: 00409 if (ctx->Line.StippleFlag == state) 00410 return; 00411 FLUSH_VERTICES(ctx, _NEW_LINE); 00412 ctx->Line.StippleFlag = state; 00413 ctx->_TriangleCaps ^= DD_LINE_STIPPLE; 00414 break; 00415 case GL_INDEX_LOGIC_OP: 00416 if (ctx->Color.IndexLogicOpEnabled == state) 00417 return; 00418 FLUSH_VERTICES(ctx, _NEW_COLOR); 00419 ctx->Color.IndexLogicOpEnabled = state; 00420 break; 00421 case GL_COLOR_LOGIC_OP: 00422 if (ctx->Color.ColorLogicOpEnabled == state) 00423 return; 00424 FLUSH_VERTICES(ctx, _NEW_COLOR); 00425 ctx->Color.ColorLogicOpEnabled = state; 00426 break; 00427 case GL_MAP1_COLOR_4: 00428 if (ctx->Eval.Map1Color4 == state) 00429 return; 00430 FLUSH_VERTICES(ctx, _NEW_EVAL); 00431 ctx->Eval.Map1Color4 = state; 00432 break; 00433 case GL_MAP1_INDEX: 00434 if (ctx->Eval.Map1Index == state) 00435 return; 00436 FLUSH_VERTICES(ctx, _NEW_EVAL); 00437 ctx->Eval.Map1Index = state; 00438 break; 00439 case GL_MAP1_NORMAL: 00440 if (ctx->Eval.Map1Normal == state) 00441 return; 00442 FLUSH_VERTICES(ctx, _NEW_EVAL); 00443 ctx->Eval.Map1Normal = state; 00444 break; 00445 case GL_MAP1_TEXTURE_COORD_1: 00446 if (ctx->Eval.Map1TextureCoord1 == state) 00447 return; 00448 FLUSH_VERTICES(ctx, _NEW_EVAL); 00449 ctx->Eval.Map1TextureCoord1 = state; 00450 break; 00451 case GL_MAP1_TEXTURE_COORD_2: 00452 if (ctx->Eval.Map1TextureCoord2 == state) 00453 return; 00454 FLUSH_VERTICES(ctx, _NEW_EVAL); 00455 ctx->Eval.Map1TextureCoord2 = state; 00456 break; 00457 case GL_MAP1_TEXTURE_COORD_3: 00458 if (ctx->Eval.Map1TextureCoord3 == state) 00459 return; 00460 FLUSH_VERTICES(ctx, _NEW_EVAL); 00461 ctx->Eval.Map1TextureCoord3 = state; 00462 break; 00463 case GL_MAP1_TEXTURE_COORD_4: 00464 if (ctx->Eval.Map1TextureCoord4 == state) 00465 return; 00466 FLUSH_VERTICES(ctx, _NEW_EVAL); 00467 ctx->Eval.Map1TextureCoord4 = state; 00468 break; 00469 case GL_MAP1_VERTEX_3: 00470 if (ctx->Eval.Map1Vertex3 == state) 00471 return; 00472 FLUSH_VERTICES(ctx, _NEW_EVAL); 00473 ctx->Eval.Map1Vertex3 = state; 00474 break; 00475 case GL_MAP1_VERTEX_4: 00476 if (ctx->Eval.Map1Vertex4 == state) 00477 return; 00478 FLUSH_VERTICES(ctx, _NEW_EVAL); 00479 ctx->Eval.Map1Vertex4 = state; 00480 break; 00481 case GL_MAP2_COLOR_4: 00482 if (ctx->Eval.Map2Color4 == state) 00483 return; 00484 FLUSH_VERTICES(ctx, _NEW_EVAL); 00485 ctx->Eval.Map2Color4 = state; 00486 break; 00487 case GL_MAP2_INDEX: 00488 if (ctx->Eval.Map2Index == state) 00489 return; 00490 FLUSH_VERTICES(ctx, _NEW_EVAL); 00491 ctx->Eval.Map2Index = state; 00492 break; 00493 case GL_MAP2_NORMAL: 00494 if (ctx->Eval.Map2Normal == state) 00495 return; 00496 FLUSH_VERTICES(ctx, _NEW_EVAL); 00497 ctx->Eval.Map2Normal = state; 00498 break; 00499 case GL_MAP2_TEXTURE_COORD_1: 00500 if (ctx->Eval.Map2TextureCoord1 == state) 00501 return; 00502 FLUSH_VERTICES(ctx, _NEW_EVAL); 00503 ctx->Eval.Map2TextureCoord1 = state; 00504 break; 00505 case GL_MAP2_TEXTURE_COORD_2: 00506 if (ctx->Eval.Map2TextureCoord2 == state) 00507 return; 00508 FLUSH_VERTICES(ctx, _NEW_EVAL); 00509 ctx->Eval.Map2TextureCoord2 = state; 00510 break; 00511 case GL_MAP2_TEXTURE_COORD_3: 00512 if (ctx->Eval.Map2TextureCoord3 == state) 00513 return; 00514 FLUSH_VERTICES(ctx, _NEW_EVAL); 00515 ctx->Eval.Map2TextureCoord3 = state; 00516 break; 00517 case GL_MAP2_TEXTURE_COORD_4: 00518 if (ctx->Eval.Map2TextureCoord4 == state) 00519 return; 00520 FLUSH_VERTICES(ctx, _NEW_EVAL); 00521 ctx->Eval.Map2TextureCoord4 = state; 00522 break; 00523 case GL_MAP2_VERTEX_3: 00524 if (ctx->Eval.Map2Vertex3 == state) 00525 return; 00526 FLUSH_VERTICES(ctx, _NEW_EVAL); 00527 ctx->Eval.Map2Vertex3 = state; 00528 break; 00529 case GL_MAP2_VERTEX_4: 00530 if (ctx->Eval.Map2Vertex4 == state) 00531 return; 00532 FLUSH_VERTICES(ctx, _NEW_EVAL); 00533 ctx->Eval.Map2Vertex4 = state; 00534 break; 00535 case GL_MINMAX: 00536 if (ctx->Pixel.MinMaxEnabled == state) 00537 return; 00538 FLUSH_VERTICES(ctx, _NEW_PIXEL); 00539 ctx->Pixel.MinMaxEnabled = state; 00540 break; 00541 case GL_NORMALIZE: 00542 if (ctx->Transform.Normalize == state) 00543 return; 00544 FLUSH_VERTICES(ctx, _NEW_TRANSFORM); 00545 ctx->Transform.Normalize = state; 00546 break; 00547 case GL_POINT_SMOOTH: 00548 if (ctx->Point.SmoothFlag == state) 00549 return; 00550 FLUSH_VERTICES(ctx, _NEW_POINT); 00551 ctx->Point.SmoothFlag = state; 00552 ctx->_TriangleCaps ^= DD_POINT_SMOOTH; 00553 break; 00554 case GL_POLYGON_SMOOTH: 00555 if (ctx->Polygon.SmoothFlag == state) 00556 return; 00557 FLUSH_VERTICES(ctx, _NEW_POLYGON); 00558 ctx->Polygon.SmoothFlag = state; 00559 ctx->_TriangleCaps ^= DD_TRI_SMOOTH; 00560 break; 00561 case GL_POLYGON_STIPPLE: 00562 if (ctx->Polygon.StippleFlag == state) 00563 return; 00564 FLUSH_VERTICES(ctx, _NEW_POLYGON); 00565 ctx->Polygon.StippleFlag = state; 00566 ctx->_TriangleCaps ^= DD_TRI_STIPPLE; 00567 break; 00568 case GL_POLYGON_OFFSET_POINT: 00569 if (ctx->Polygon.OffsetPoint == state) 00570 return; 00571 FLUSH_VERTICES(ctx, _NEW_POLYGON); 00572 ctx->Polygon.OffsetPoint = state; 00573 break; 00574 case GL_POLYGON_OFFSET_LINE: 00575 if (ctx->Polygon.OffsetLine == state) 00576 return; 00577 FLUSH_VERTICES(ctx, _NEW_POLYGON); 00578 ctx->Polygon.OffsetLine = state; 00579 break; 00580 case GL_POLYGON_OFFSET_FILL: 00581 /*case GL_POLYGON_OFFSET_EXT:*/ 00582 if (ctx->Polygon.OffsetFill == state) 00583 return; 00584 FLUSH_VERTICES(ctx, _NEW_POLYGON); 00585 ctx->Polygon.OffsetFill = state; 00586 break; 00587 case GL_RESCALE_NORMAL_EXT: 00588 if (ctx->Transform.RescaleNormals == state) 00589 return; 00590 FLUSH_VERTICES(ctx, _NEW_TRANSFORM); 00591 ctx->Transform.RescaleNormals = state; 00592 break; 00593 case GL_SCISSOR_TEST: 00594 if (ctx->Scissor.Enabled == state) 00595 return; 00596 FLUSH_VERTICES(ctx, _NEW_SCISSOR); 00597 ctx->Scissor.Enabled = state; 00598 break; 00599 case GL_SHARED_TEXTURE_PALETTE_EXT: 00600 if (ctx->Texture.SharedPalette == state) 00601 return; 00602 FLUSH_VERTICES(ctx, _NEW_TEXTURE); 00603 ctx->Texture.SharedPalette = state; 00604 break; 00605 case GL_STENCIL_TEST: 00606 if (state && ctx->DrawBuffer->Visual.stencilBits == 0) { 00607 _mesa_warning(ctx, 00608 "glEnable(GL_STENCIL_TEST) but no stencil buffer"); 00609 return; 00610 } 00611 if (ctx->Stencil.Enabled == state) 00612 return; 00613 FLUSH_VERTICES(ctx, _NEW_STENCIL); 00614 ctx->Stencil.Enabled = state; 00615 break; 00616 case GL_TEXTURE_1D: 00617 if (!enable_texture(ctx, state, TEXTURE_1D_BIT)) { 00618 return; 00619 } 00620 break; 00621 case GL_TEXTURE_2D: 00622 if (!enable_texture(ctx, state, TEXTURE_2D_BIT)) { 00623 return; 00624 } 00625 break; 00626 case GL_TEXTURE_3D: 00627 if (!enable_texture(ctx, state, TEXTURE_3D_BIT)) { 00628 return; 00629 } 00630 break; 00631 case GL_TEXTURE_GEN_Q: 00632 { 00633 struct gl_texture_unit *texUnit = get_texcoord_unit(ctx); 00634 if (texUnit) { 00635 GLuint newenabled = texUnit->TexGenEnabled & ~Q_BIT; 00636 if (state) 00637 newenabled |= Q_BIT; 00638 if (texUnit->TexGenEnabled == newenabled) 00639 return; 00640 FLUSH_VERTICES(ctx, _NEW_TEXTURE); 00641 texUnit->TexGenEnabled = newenabled; 00642 } 00643 } 00644 break; 00645 case GL_TEXTURE_GEN_R: 00646 { 00647 struct gl_texture_unit *texUnit = get_texcoord_unit(ctx); 00648 if (texUnit) { 00649 GLuint newenabled = texUnit->TexGenEnabled & ~R_BIT; 00650 if (state) 00651 newenabled |= R_BIT; 00652 if (texUnit->TexGenEnabled == newenabled) 00653 return; 00654 FLUSH_VERTICES(ctx, _NEW_TEXTURE); 00655 texUnit->TexGenEnabled = newenabled; 00656 } 00657 } 00658 break; 00659 case GL_TEXTURE_GEN_S: 00660 { 00661 struct gl_texture_unit *texUnit = get_texcoord_unit(ctx); 00662 if (texUnit) { 00663 GLuint newenabled = texUnit->TexGenEnabled & ~S_BIT; 00664 if (state) 00665 newenabled |= S_BIT; 00666 if (texUnit->TexGenEnabled == newenabled) 00667 return; 00668 FLUSH_VERTICES(ctx, _NEW_TEXTURE); 00669 texUnit->TexGenEnabled = newenabled; 00670 } 00671 } 00672 break; 00673 case GL_TEXTURE_GEN_T: 00674 { 00675 struct gl_texture_unit *texUnit = get_texcoord_unit(ctx); 00676 if (texUnit) { 00677 GLuint newenabled = texUnit->TexGenEnabled & ~T_BIT; 00678 if (state) 00679 newenabled |= T_BIT; 00680 if (texUnit->TexGenEnabled == newenabled) 00681 return; 00682 FLUSH_VERTICES(ctx, _NEW_TEXTURE); 00683 texUnit->TexGenEnabled = newenabled; 00684 } 00685 } 00686 break; 00687 00688 /* 00689 * CLIENT STATE!!! 00690 */ 00691 case GL_VERTEX_ARRAY: 00692 case GL_NORMAL_ARRAY: 00693 case GL_COLOR_ARRAY: 00694 case GL_INDEX_ARRAY: 00695 case GL_TEXTURE_COORD_ARRAY: 00696 case GL_EDGE_FLAG_ARRAY: 00697 case GL_FOG_COORDINATE_ARRAY_EXT: 00698 case GL_SECONDARY_COLOR_ARRAY_EXT: 00699 case GL_POINT_SIZE_ARRAY_OES: 00700 client_state( ctx, cap, state ); 00701 return; 00702 00703 /* GL_SGI_color_table */ 00704 case GL_COLOR_TABLE_SGI: 00705 CHECK_EXTENSION(SGI_color_table, cap); 00706 if (ctx->Pixel.ColorTableEnabled[COLORTABLE_PRECONVOLUTION] == state) 00707 return; 00708 FLUSH_VERTICES(ctx, _NEW_PIXEL); 00709 ctx->Pixel.ColorTableEnabled[COLORTABLE_PRECONVOLUTION] = state; 00710 break; 00711 case GL_POST_CONVOLUTION_COLOR_TABLE_SGI: 00712 CHECK_EXTENSION(SGI_color_table, cap); 00713 if (ctx->Pixel.ColorTableEnabled[COLORTABLE_POSTCONVOLUTION] == state) 00714 return; 00715 FLUSH_VERTICES(ctx, _NEW_PIXEL); 00716 ctx->Pixel.ColorTableEnabled[COLORTABLE_POSTCONVOLUTION] = state; 00717 break; 00718 case GL_POST_COLOR_MATRIX_COLOR_TABLE_SGI: 00719 CHECK_EXTENSION(SGI_color_table, cap); 00720 if (ctx->Pixel.ColorTableEnabled[COLORTABLE_POSTCOLORMATRIX] == state) 00721 return; 00722 FLUSH_VERTICES(ctx, _NEW_PIXEL); 00723 ctx->Pixel.ColorTableEnabled[COLORTABLE_POSTCOLORMATRIX] = state; 00724 break; 00725 case GL_TEXTURE_COLOR_TABLE_SGI: 00726 CHECK_EXTENSION(SGI_texture_color_table, cap); 00727 if (ctx->Texture.Unit[ctx->Texture.CurrentUnit].ColorTableEnabled == state) 00728 return; 00729 FLUSH_VERTICES(ctx, _NEW_TEXTURE); 00730 ctx->Texture.Unit[ctx->Texture.CurrentUnit].ColorTableEnabled = state; 00731 break; 00732 00733 /* GL_EXT_convolution */ 00734 case GL_CONVOLUTION_1D: 00735 CHECK_EXTENSION(EXT_convolution, cap); 00736 if (ctx->Pixel.Convolution1DEnabled == state) 00737 return; 00738 FLUSH_VERTICES(ctx, _NEW_PIXEL); 00739 ctx->Pixel.Convolution1DEnabled = state; 00740 break; 00741 case GL_CONVOLUTION_2D: 00742 CHECK_EXTENSION(EXT_convolution, cap); 00743 if (ctx->Pixel.Convolution2DEnabled == state) 00744 return; 00745 FLUSH_VERTICES(ctx, _NEW_PIXEL); 00746 ctx->Pixel.Convolution2DEnabled = state; 00747 break; 00748 case GL_SEPARABLE_2D: 00749 CHECK_EXTENSION(EXT_convolution, cap); 00750 if (ctx->Pixel.Separable2DEnabled == state) 00751 return; 00752 FLUSH_VERTICES(ctx, _NEW_PIXEL); 00753 ctx->Pixel.Separable2DEnabled = state; 00754 break; 00755 00756 /* GL_ARB_texture_cube_map */ 00757 case GL_TEXTURE_CUBE_MAP_ARB: 00758 CHECK_EXTENSION(ARB_texture_cube_map, cap); 00759 if (!enable_texture(ctx, state, TEXTURE_CUBE_BIT)) { 00760 return; 00761 } 00762 break; 00763 00764 /* GL_EXT_secondary_color */ 00765 case GL_COLOR_SUM_EXT: 00766 CHECK_EXTENSION2(EXT_secondary_color, ARB_vertex_program, cap); 00767 if (ctx->Fog.ColorSumEnabled == state) 00768 return; 00769 FLUSH_VERTICES(ctx, _NEW_FOG); 00770 ctx->Fog.ColorSumEnabled = state; 00771 break; 00772 00773 /* GL_ARB_multisample */ 00774 case GL_MULTISAMPLE_ARB: 00775 CHECK_EXTENSION(ARB_multisample, cap); 00776 if (ctx->Multisample.Enabled == state) 00777 return; 00778 FLUSH_VERTICES(ctx, _NEW_MULTISAMPLE); 00779 ctx->Multisample.Enabled = state; 00780 break; 00781 case GL_SAMPLE_ALPHA_TO_COVERAGE_ARB: 00782 CHECK_EXTENSION(ARB_multisample, cap); 00783 if (ctx->Multisample.SampleAlphaToCoverage == state) 00784 return; 00785 FLUSH_VERTICES(ctx, _NEW_MULTISAMPLE); 00786 ctx->Multisample.SampleAlphaToCoverage = state; 00787 break; 00788 case GL_SAMPLE_ALPHA_TO_ONE_ARB: 00789 CHECK_EXTENSION(ARB_multisample, cap); 00790 if (ctx->Multisample.SampleAlphaToOne == state) 00791 return; 00792 FLUSH_VERTICES(ctx, _NEW_MULTISAMPLE); 00793 ctx->Multisample.SampleAlphaToOne = state; 00794 break; 00795 case GL_SAMPLE_COVERAGE_ARB: 00796 CHECK_EXTENSION(ARB_multisample, cap); 00797 if (ctx->Multisample.SampleCoverage == state) 00798 return; 00799 FLUSH_VERTICES(ctx, _NEW_MULTISAMPLE); 00800 ctx->Multisample.SampleCoverage = state; 00801 break; 00802 case GL_SAMPLE_COVERAGE_INVERT_ARB: 00803 CHECK_EXTENSION(ARB_multisample, cap); 00804 if (ctx->Multisample.SampleCoverageInvert == state) 00805 return; 00806 FLUSH_VERTICES(ctx, _NEW_MULTISAMPLE); 00807 ctx->Multisample.SampleCoverageInvert = state; 00808 break; 00809 00810 /* GL_IBM_rasterpos_clip */ 00811 case GL_RASTER_POSITION_UNCLIPPED_IBM: 00812 CHECK_EXTENSION(IBM_rasterpos_clip, cap); 00813 if (ctx->Transform.RasterPositionUnclipped == state) 00814 return; 00815 FLUSH_VERTICES(ctx, _NEW_TRANSFORM); 00816 ctx->Transform.RasterPositionUnclipped = state; 00817 break; 00818 00819 /* GL_NV_point_sprite */ 00820 case GL_POINT_SPRITE_NV: 00821 CHECK_EXTENSION2(NV_point_sprite, ARB_point_sprite, cap); 00822 if (ctx->Point.PointSprite == state) 00823 return; 00824 FLUSH_VERTICES(ctx, _NEW_POINT); 00825 ctx->Point.PointSprite = state; 00826 break; 00827 00828 #if FEATURE_NV_vertex_program || FEATURE_ARB_vertex_program 00829 case GL_VERTEX_PROGRAM_ARB: 00830 CHECK_EXTENSION2(ARB_vertex_program, NV_vertex_program, cap); 00831 if (ctx->VertexProgram.Enabled == state) 00832 return; 00833 FLUSH_VERTICES(ctx, _NEW_PROGRAM); 00834 ctx->VertexProgram.Enabled = state; 00835 break; 00836 case GL_VERTEX_PROGRAM_POINT_SIZE_ARB: 00837 CHECK_EXTENSION2(ARB_vertex_program, NV_vertex_program, cap); 00838 if (ctx->VertexProgram.PointSizeEnabled == state) 00839 return; 00840 FLUSH_VERTICES(ctx, _NEW_PROGRAM); 00841 ctx->VertexProgram.PointSizeEnabled = state; 00842 break; 00843 case GL_VERTEX_PROGRAM_TWO_SIDE_ARB: 00844 CHECK_EXTENSION2(ARB_vertex_program, NV_vertex_program, cap); 00845 if (ctx->VertexProgram.TwoSideEnabled == state) 00846 return; 00847 FLUSH_VERTICES(ctx, _NEW_PROGRAM); 00848 ctx->VertexProgram.TwoSideEnabled = state; 00849 break; 00850 #endif 00851 #if FEATURE_NV_vertex_program 00852 case GL_MAP1_VERTEX_ATTRIB0_4_NV: 00853 case GL_MAP1_VERTEX_ATTRIB1_4_NV: 00854 case GL_MAP1_VERTEX_ATTRIB2_4_NV: 00855 case GL_MAP1_VERTEX_ATTRIB3_4_NV: 00856 case GL_MAP1_VERTEX_ATTRIB4_4_NV: 00857 case GL_MAP1_VERTEX_ATTRIB5_4_NV: 00858 case GL_MAP1_VERTEX_ATTRIB6_4_NV: 00859 case GL_MAP1_VERTEX_ATTRIB7_4_NV: 00860 case GL_MAP1_VERTEX_ATTRIB8_4_NV: 00861 case GL_MAP1_VERTEX_ATTRIB9_4_NV: 00862 case GL_MAP1_VERTEX_ATTRIB10_4_NV: 00863 case GL_MAP1_VERTEX_ATTRIB11_4_NV: 00864 case GL_MAP1_VERTEX_ATTRIB12_4_NV: 00865 case GL_MAP1_VERTEX_ATTRIB13_4_NV: 00866 case GL_MAP1_VERTEX_ATTRIB14_4_NV: 00867 case GL_MAP1_VERTEX_ATTRIB15_4_NV: 00868 CHECK_EXTENSION(NV_vertex_program, cap); 00869 { 00870 const GLuint map = (GLuint) (cap - GL_MAP1_VERTEX_ATTRIB0_4_NV); 00871 FLUSH_VERTICES(ctx, _NEW_EVAL); 00872 ctx->Eval.Map1Attrib[map] = state; 00873 } 00874 break; 00875 case GL_MAP2_VERTEX_ATTRIB0_4_NV: 00876 case GL_MAP2_VERTEX_ATTRIB1_4_NV: 00877 case GL_MAP2_VERTEX_ATTRIB2_4_NV: 00878 case GL_MAP2_VERTEX_ATTRIB3_4_NV: 00879 case GL_MAP2_VERTEX_ATTRIB4_4_NV: 00880 case GL_MAP2_VERTEX_ATTRIB5_4_NV: 00881 case GL_MAP2_VERTEX_ATTRIB6_4_NV: 00882 case GL_MAP2_VERTEX_ATTRIB7_4_NV: 00883 case GL_MAP2_VERTEX_ATTRIB8_4_NV: 00884 case GL_MAP2_VERTEX_ATTRIB9_4_NV: 00885 case GL_MAP2_VERTEX_ATTRIB10_4_NV: 00886 case GL_MAP2_VERTEX_ATTRIB11_4_NV: 00887 case GL_MAP2_VERTEX_ATTRIB12_4_NV: 00888 case GL_MAP2_VERTEX_ATTRIB13_4_NV: 00889 case GL_MAP2_VERTEX_ATTRIB14_4_NV: 00890 case GL_MAP2_VERTEX_ATTRIB15_4_NV: 00891 CHECK_EXTENSION(NV_vertex_program, cap); 00892 { 00893 const GLuint map = (GLuint) (cap - GL_MAP2_VERTEX_ATTRIB0_4_NV); 00894 FLUSH_VERTICES(ctx, _NEW_EVAL); 00895 ctx->Eval.Map2Attrib[map] = state; 00896 } 00897 break; 00898 #endif /* FEATURE_NV_vertex_program */ 00899 00900 #if FEATURE_NV_fragment_program 00901 case GL_FRAGMENT_PROGRAM_NV: 00902 CHECK_EXTENSION(NV_fragment_program, cap); 00903 if (ctx->FragmentProgram.Enabled == state) 00904 return; 00905 FLUSH_VERTICES(ctx, _NEW_PROGRAM); 00906 ctx->FragmentProgram.Enabled = state; 00907 break; 00908 #endif /* FEATURE_NV_fragment_program */ 00909 00910 /* GL_NV_texture_rectangle */ 00911 case GL_TEXTURE_RECTANGLE_NV: 00912 CHECK_EXTENSION(NV_texture_rectangle, cap); 00913 if (!enable_texture(ctx, state, TEXTURE_RECT_BIT)) { 00914 return; 00915 } 00916 break; 00917 00918 /* GL_EXT_stencil_two_side */ 00919 case GL_STENCIL_TEST_TWO_SIDE_EXT: 00920 CHECK_EXTENSION(EXT_stencil_two_side, cap); 00921 if (ctx->Stencil.TestTwoSide == state) 00922 return; 00923 FLUSH_VERTICES(ctx, _NEW_STENCIL); 00924 ctx->Stencil.TestTwoSide = state; 00925 if (state) { 00926 ctx->Stencil._BackFace = 2; 00927 ctx->_TriangleCaps |= DD_TRI_TWOSTENCIL; 00928 } else { 00929 ctx->Stencil._BackFace = 1; 00930 ctx->_TriangleCaps &= ~DD_TRI_TWOSTENCIL; 00931 } 00932 break; 00933 00934 #if FEATURE_ARB_fragment_program 00935 case GL_FRAGMENT_PROGRAM_ARB: 00936 CHECK_EXTENSION(ARB_fragment_program, cap); 00937 if (ctx->FragmentProgram.Enabled == state) 00938 return; 00939 FLUSH_VERTICES(ctx, _NEW_PROGRAM); 00940 ctx->FragmentProgram.Enabled = state; 00941 break; 00942 #endif /* FEATURE_ARB_fragment_program */ 00943 00944 /* GL_EXT_depth_bounds_test */ 00945 case GL_DEPTH_BOUNDS_TEST_EXT: 00946 CHECK_EXTENSION(EXT_depth_bounds_test, cap); 00947 if (state && ctx->DrawBuffer->Visual.depthBits == 0) { 00948 _mesa_warning(ctx, 00949 "glEnable(GL_DEPTH_BOUNDS_TEST_EXT) but no depth buffer"); 00950 return; 00951 } 00952 if (ctx->Depth.BoundsTest == state) 00953 return; 00954 FLUSH_VERTICES(ctx, _NEW_DEPTH); 00955 ctx->Depth.BoundsTest = state; 00956 break; 00957 00958 /* GL_MESA_program_debug */ 00959 case GL_FRAGMENT_PROGRAM_CALLBACK_MESA: 00960 CHECK_EXTENSION(MESA_program_debug, cap); 00961 ctx->FragmentProgram.CallbackEnabled = state; 00962 break; 00963 case GL_VERTEX_PROGRAM_CALLBACK_MESA: 00964 CHECK_EXTENSION(MESA_program_debug, cap); 00965 ctx->VertexProgram.CallbackEnabled = state; 00966 break; 00967 00968 #if FEATURE_ATI_fragment_shader 00969 case GL_FRAGMENT_SHADER_ATI: 00970 CHECK_EXTENSION(ATI_fragment_shader, cap); 00971 if (ctx->ATIFragmentShader.Enabled == state) 00972 return; 00973 FLUSH_VERTICES(ctx, _NEW_PROGRAM); 00974 ctx->ATIFragmentShader.Enabled = state; 00975 break; 00976 #endif 00977 00978 /* GL_MESA_texture_array */ 00979 case GL_TEXTURE_1D_ARRAY_EXT: 00980 CHECK_EXTENSION(MESA_texture_array, cap); 00981 if (!enable_texture(ctx, state, TEXTURE_1D_ARRAY_BIT)) { 00982 return; 00983 } 00984 break; 00985 00986 case GL_TEXTURE_2D_ARRAY_EXT: 00987 CHECK_EXTENSION(MESA_texture_array, cap); 00988 if (!enable_texture(ctx, state, TEXTURE_2D_ARRAY_BIT)) { 00989 return; 00990 } 00991 break; 00992 00993 default: 00994 _mesa_error(ctx, GL_INVALID_ENUM, 00995 "%s(0x%x)", state ? "glEnable" : "glDisable", cap); 00996 return; 00997 } 00998 00999 if (ctx->Driver.Enable) { 01000 ctx->Driver.Enable( ctx, cap, state ); 01001 } 01002 } 01003 01004 01009 void GLAPIENTRY 01010 _mesa_Enable( GLenum cap ) 01011 { 01012 GET_CURRENT_CONTEXT(ctx); 01013 ASSERT_OUTSIDE_BEGIN_END(ctx); 01014 01015 _mesa_set_enable( ctx, cap, GL_TRUE ); 01016 } 01017 01018 01023 void GLAPIENTRY 01024 _mesa_Disable( GLenum cap ) 01025 { 01026 GET_CURRENT_CONTEXT(ctx); 01027 ASSERT_OUTSIDE_BEGIN_END(ctx); 01028 01029 _mesa_set_enable( ctx, cap, GL_FALSE ); 01030 } 01031 01032 01033 #undef CHECK_EXTENSION 01034 #define CHECK_EXTENSION(EXTNAME) \ 01035 if (!ctx->Extensions.EXTNAME) { \ 01036 _mesa_error(ctx, GL_INVALID_ENUM, "glIsEnabled"); \ 01037 return GL_FALSE; \ 01038 } 01039 01040 #undef CHECK_EXTENSION2 01041 #define CHECK_EXTENSION2(EXT1, EXT2) \ 01042 if (!ctx->Extensions.EXT1 && !ctx->Extensions.EXT2) { \ 01043 _mesa_error(ctx, GL_INVALID_ENUM, "glIsEnabled"); \ 01044 return GL_FALSE; \ 01045 } 01046 01047 01051 static GLboolean 01052 is_texture_enabled(GLcontext *ctx, GLbitfield bit) 01053 { 01054 const struct gl_texture_unit *const texUnit = 01055 &ctx->Texture.Unit[ctx->Texture.CurrentUnit]; 01056 return (texUnit->Enabled & bit) ? GL_TRUE : GL_FALSE; 01057 } 01058 01059 01069 GLboolean GLAPIENTRY 01070 _mesa_IsEnabled( GLenum cap ) 01071 { 01072 GET_CURRENT_CONTEXT(ctx); 01073 switch (cap) { 01074 case GL_ALPHA_TEST: 01075 return ctx->Color.AlphaEnabled; 01076 case GL_AUTO_NORMAL: 01077 return ctx->Eval.AutoNormal; 01078 case GL_BLEND: 01079 return ctx->Color.BlendEnabled; 01080 case GL_CLIP_PLANE0: 01081 case GL_CLIP_PLANE1: 01082 case GL_CLIP_PLANE2: 01083 case GL_CLIP_PLANE3: 01084 case GL_CLIP_PLANE4: 01085 case GL_CLIP_PLANE5: 01086 return (ctx->Transform.ClipPlanesEnabled >> (cap - GL_CLIP_PLANE0)) & 1; 01087 case GL_COLOR_MATERIAL: 01088 return ctx->Light.ColorMaterialEnabled; 01089 case GL_CULL_FACE: 01090 return ctx->Polygon.CullFlag; 01091 case GL_DEPTH_TEST: 01092 return ctx->Depth.Test; 01093 case GL_DITHER: 01094 return ctx->Color.DitherFlag; 01095 case GL_FOG: 01096 return ctx->Fog.Enabled; 01097 case GL_LIGHTING: 01098 return ctx->Light.Enabled; 01099 case GL_LIGHT0: 01100 case GL_LIGHT1: 01101 case GL_LIGHT2: 01102 case GL_LIGHT3: 01103 case GL_LIGHT4: 01104 case GL_LIGHT5: 01105 case GL_LIGHT6: 01106 case GL_LIGHT7: 01107 return ctx->Light.Light[cap-GL_LIGHT0].Enabled; 01108 case GL_LINE_SMOOTH: 01109 return ctx->Line.SmoothFlag; 01110 case GL_LINE_STIPPLE: 01111 return ctx->Line.StippleFlag; 01112 case GL_INDEX_LOGIC_OP: 01113 return ctx->Color.IndexLogicOpEnabled; 01114 case GL_COLOR_LOGIC_OP: 01115 return ctx->Color.ColorLogicOpEnabled; 01116 case GL_MAP1_COLOR_4: 01117 return ctx->Eval.Map1Color4; 01118 case GL_MAP1_INDEX: 01119 return ctx->Eval.Map1Index; 01120 case GL_MAP1_NORMAL: 01121 return ctx->Eval.Map1Normal; 01122 case GL_MAP1_TEXTURE_COORD_1: 01123 return ctx->Eval.Map1TextureCoord1; 01124 case GL_MAP1_TEXTURE_COORD_2: 01125 return ctx->Eval.Map1TextureCoord2; 01126 case GL_MAP1_TEXTURE_COORD_3: 01127 return ctx->Eval.Map1TextureCoord3; 01128 case GL_MAP1_TEXTURE_COORD_4: 01129 return ctx->Eval.Map1TextureCoord4; 01130 case GL_MAP1_VERTEX_3: 01131 return ctx->Eval.Map1Vertex3; 01132 case GL_MAP1_VERTEX_4: 01133 return ctx->Eval.Map1Vertex4; 01134 case GL_MAP2_COLOR_4: 01135 return ctx->Eval.Map2Color4; 01136 case GL_MAP2_INDEX: 01137 return ctx->Eval.Map2Index; 01138 case GL_MAP2_NORMAL: 01139 return ctx->Eval.Map2Normal; 01140 case GL_MAP2_TEXTURE_COORD_1: 01141 return ctx->Eval.Map2TextureCoord1; 01142 case GL_MAP2_TEXTURE_COORD_2: 01143 return ctx->Eval.Map2TextureCoord2; 01144 case GL_MAP2_TEXTURE_COORD_3: 01145 return ctx->Eval.Map2TextureCoord3; 01146 case GL_MAP2_TEXTURE_COORD_4: 01147 return ctx->Eval.Map2TextureCoord4; 01148 case GL_MAP2_VERTEX_3: 01149 return ctx->Eval.Map2Vertex3; 01150 case GL_MAP2_VERTEX_4: 01151 return ctx->Eval.Map2Vertex4; 01152 case GL_NORMALIZE: 01153 return ctx->Transform.Normalize; 01154 case GL_POINT_SMOOTH: 01155 return ctx->Point.SmoothFlag; 01156 case GL_POLYGON_SMOOTH: 01157 return ctx->Polygon.SmoothFlag; 01158 case GL_POLYGON_STIPPLE: 01159 return ctx->Polygon.StippleFlag; 01160 case GL_POLYGON_OFFSET_POINT: 01161 return ctx->Polygon.OffsetPoint; 01162 case GL_POLYGON_OFFSET_LINE: 01163 return ctx->Polygon.OffsetLine; 01164 case GL_POLYGON_OFFSET_FILL: 01165 /*case GL_POLYGON_OFFSET_EXT:*/ 01166 return ctx->Polygon.OffsetFill; 01167 case GL_RESCALE_NORMAL_EXT: 01168 return ctx->Transform.RescaleNormals; 01169 case GL_SCISSOR_TEST: 01170 return ctx->Scissor.Enabled; 01171 case GL_SHARED_TEXTURE_PALETTE_EXT: 01172 return ctx->Texture.SharedPalette; 01173 case GL_STENCIL_TEST: 01174 return ctx->Stencil.Enabled; 01175 case GL_TEXTURE_1D: 01176 return is_texture_enabled(ctx, TEXTURE_1D_BIT); 01177 case GL_TEXTURE_2D: 01178 return is_texture_enabled(ctx, TEXTURE_2D_BIT); 01179 case GL_TEXTURE_3D: 01180 return is_texture_enabled(ctx, TEXTURE_3D_BIT); 01181 case GL_TEXTURE_GEN_Q: 01182 { 01183 const struct gl_texture_unit *texUnit = get_texcoord_unit(ctx); 01184 if (texUnit) { 01185 return (texUnit->TexGenEnabled & Q_BIT) ? GL_TRUE : GL_FALSE; 01186 } 01187 } 01188 return GL_FALSE; 01189 case GL_TEXTURE_GEN_R: 01190 { 01191 const struct gl_texture_unit *texUnit = get_texcoord_unit(ctx); 01192 if (texUnit) { 01193 return (texUnit->TexGenEnabled & R_BIT) ? GL_TRUE : GL_FALSE; 01194 } 01195 } 01196 return GL_FALSE; 01197 case GL_TEXTURE_GEN_S: 01198 { 01199 const struct gl_texture_unit *texUnit = get_texcoord_unit(ctx); 01200 if (texUnit) { 01201 return (texUnit->TexGenEnabled & S_BIT) ? GL_TRUE : GL_FALSE; 01202 } 01203 } 01204 return GL_FALSE; 01205 case GL_TEXTURE_GEN_T: 01206 { 01207 const struct gl_texture_unit *texUnit = get_texcoord_unit(ctx); 01208 if (texUnit) { 01209 return (texUnit->TexGenEnabled & T_BIT) ? GL_TRUE : GL_FALSE; 01210 } 01211 } 01212 return GL_FALSE; 01213 01214 /* 01215 * CLIENT STATE!!! 01216 */ 01217 case GL_VERTEX_ARRAY: 01218 return (ctx->Array.ArrayObj->Vertex.Enabled != 0); 01219 case GL_NORMAL_ARRAY: 01220 return (ctx->Array.ArrayObj->Normal.Enabled != 0); 01221 case GL_COLOR_ARRAY: 01222 return (ctx->Array.ArrayObj->Color.Enabled != 0); 01223 case GL_INDEX_ARRAY: 01224 return (ctx->Array.ArrayObj->Index.Enabled != 0); 01225 case GL_TEXTURE_COORD_ARRAY: 01226 return (ctx->Array.ArrayObj->TexCoord[ctx->Array.ActiveTexture].Enabled != 0); 01227 case GL_EDGE_FLAG_ARRAY: 01228 return (ctx->Array.ArrayObj->EdgeFlag.Enabled != 0); 01229 case GL_FOG_COORDINATE_ARRAY_EXT: 01230 CHECK_EXTENSION(EXT_fog_coord); 01231 return (ctx->Array.ArrayObj->FogCoord.Enabled != 0); 01232 case GL_SECONDARY_COLOR_ARRAY_EXT: 01233 CHECK_EXTENSION(EXT_secondary_color); 01234 return (ctx->Array.ArrayObj->SecondaryColor.Enabled != 0); 01235 #if FEATURE_point_size_array 01236 case GL_POINT_SIZE_ARRAY_OES: 01237 return (ctx->Array.ArrayObj->PointSize.Enabled != 0); 01238 #endif 01239 01240 /* GL_EXT_histogram */ 01241 case GL_HISTOGRAM: 01242 CHECK_EXTENSION(EXT_histogram); 01243 return ctx->Pixel.HistogramEnabled; 01244 case GL_MINMAX: 01245 CHECK_EXTENSION(EXT_histogram); 01246 return ctx->Pixel.MinMaxEnabled; 01247 01248 /* GL_SGI_color_table */ 01249 case GL_COLOR_TABLE_SGI: 01250 CHECK_EXTENSION(SGI_color_table); 01251 return ctx->Pixel.ColorTableEnabled[COLORTABLE_PRECONVOLUTION]; 01252 case GL_POST_CONVOLUTION_COLOR_TABLE_SGI: 01253 CHECK_EXTENSION(SGI_color_table); 01254 return ctx->Pixel.ColorTableEnabled[COLORTABLE_POSTCONVOLUTION]; 01255 case GL_POST_COLOR_MATRIX_COLOR_TABLE_SGI: 01256 CHECK_EXTENSION(SGI_color_table); 01257 return ctx->Pixel.ColorTableEnabled[COLORTABLE_POSTCOLORMATRIX]; 01258 01259 /* GL_SGI_texture_color_table */ 01260 case GL_TEXTURE_COLOR_TABLE_SGI: 01261 CHECK_EXTENSION(SGI_texture_color_table); 01262 return ctx->Texture.Unit[ctx->Texture.CurrentUnit].ColorTableEnabled; 01263 01264 /* GL_EXT_convolution */ 01265 case GL_CONVOLUTION_1D: 01266 CHECK_EXTENSION(EXT_convolution); 01267 return ctx->Pixel.Convolution1DEnabled; 01268 case GL_CONVOLUTION_2D: 01269 CHECK_EXTENSION(EXT_convolution); 01270 return ctx->Pixel.Convolution2DEnabled; 01271 case GL_SEPARABLE_2D: 01272 CHECK_EXTENSION(EXT_convolution); 01273 return ctx->Pixel.Separable2DEnabled; 01274 01275 /* GL_ARB_texture_cube_map */ 01276 case GL_TEXTURE_CUBE_MAP_ARB: 01277 CHECK_EXTENSION(ARB_texture_cube_map); 01278 return is_texture_enabled(ctx, TEXTURE_CUBE_BIT); 01279 01280 /* GL_EXT_secondary_color */ 01281 case GL_COLOR_SUM_EXT: 01282 CHECK_EXTENSION2(EXT_secondary_color, ARB_vertex_program); 01283 return ctx->Fog.ColorSumEnabled; 01284 01285 /* GL_ARB_multisample */ 01286 case GL_MULTISAMPLE_ARB: 01287 CHECK_EXTENSION(ARB_multisample); 01288 return ctx->Multisample.Enabled; 01289 case GL_SAMPLE_ALPHA_TO_COVERAGE_ARB: 01290 CHECK_EXTENSION(ARB_multisample); 01291 return ctx->Multisample.SampleAlphaToCoverage; 01292 case GL_SAMPLE_ALPHA_TO_ONE_ARB: 01293 CHECK_EXTENSION(ARB_multisample); 01294 return ctx->Multisample.SampleAlphaToOne; 01295 case GL_SAMPLE_COVERAGE_ARB: 01296 CHECK_EXTENSION(ARB_multisample); 01297 return ctx->Multisample.SampleCoverage; 01298 case GL_SAMPLE_COVERAGE_INVERT_ARB: 01299 CHECK_EXTENSION(ARB_multisample); 01300 return ctx->Multisample.SampleCoverageInvert; 01301 01302 /* GL_IBM_rasterpos_clip */ 01303 case GL_RASTER_POSITION_UNCLIPPED_IBM: 01304 CHECK_EXTENSION(IBM_rasterpos_clip); 01305 return ctx->Transform.RasterPositionUnclipped; 01306 01307 /* GL_NV_point_sprite */ 01308 case GL_POINT_SPRITE_NV: 01309 CHECK_EXTENSION2(NV_point_sprite, ARB_point_sprite) 01310 return ctx->Point.PointSprite; 01311 01312 #if FEATURE_NV_vertex_program || FEATURE_ARB_vertex_program 01313 case GL_VERTEX_PROGRAM_ARB: 01314 CHECK_EXTENSION2(ARB_vertex_program, NV_vertex_program); 01315 return ctx->VertexProgram.Enabled; 01316 case GL_VERTEX_PROGRAM_POINT_SIZE_ARB: 01317 CHECK_EXTENSION2(ARB_vertex_program, NV_vertex_program); 01318 return ctx->VertexProgram.PointSizeEnabled; 01319 case GL_VERTEX_PROGRAM_TWO_SIDE_ARB: 01320 CHECK_EXTENSION2(ARB_vertex_program, NV_vertex_program); 01321 return ctx->VertexProgram.TwoSideEnabled; 01322 #endif 01323 #if FEATURE_NV_vertex_program 01324 case GL_VERTEX_ATTRIB_ARRAY0_NV: 01325 case GL_VERTEX_ATTRIB_ARRAY1_NV: 01326 case GL_VERTEX_ATTRIB_ARRAY2_NV: 01327 case GL_VERTEX_ATTRIB_ARRAY3_NV: 01328 case GL_VERTEX_ATTRIB_ARRAY4_NV: 01329 case GL_VERTEX_ATTRIB_ARRAY5_NV: 01330 case GL_VERTEX_ATTRIB_ARRAY6_NV: 01331 case GL_VERTEX_ATTRIB_ARRAY7_NV: 01332 case GL_VERTEX_ATTRIB_ARRAY8_NV: 01333 case GL_VERTEX_ATTRIB_ARRAY9_NV: 01334 case GL_VERTEX_ATTRIB_ARRAY10_NV: 01335 case GL_VERTEX_ATTRIB_ARRAY11_NV: 01336 case GL_VERTEX_ATTRIB_ARRAY12_NV: 01337 case GL_VERTEX_ATTRIB_ARRAY13_NV: 01338 case GL_VERTEX_ATTRIB_ARRAY14_NV: 01339 case GL_VERTEX_ATTRIB_ARRAY15_NV: 01340 CHECK_EXTENSION(NV_vertex_program); 01341 { 01342 GLint n = (GLint) cap - GL_VERTEX_ATTRIB_ARRAY0_NV; 01343 return (ctx->Array.ArrayObj->VertexAttrib[n].Enabled != 0); 01344 } 01345 case GL_MAP1_VERTEX_ATTRIB0_4_NV: 01346 case GL_MAP1_VERTEX_ATTRIB1_4_NV: 01347 case GL_MAP1_VERTEX_ATTRIB2_4_NV: 01348 case GL_MAP1_VERTEX_ATTRIB3_4_NV: 01349 case GL_MAP1_VERTEX_ATTRIB4_4_NV: 01350 case GL_MAP1_VERTEX_ATTRIB5_4_NV: 01351 case GL_MAP1_VERTEX_ATTRIB6_4_NV: 01352 case GL_MAP1_VERTEX_ATTRIB7_4_NV: 01353 case GL_MAP1_VERTEX_ATTRIB8_4_NV: 01354 case GL_MAP1_VERTEX_ATTRIB9_4_NV: 01355 case GL_MAP1_VERTEX_ATTRIB10_4_NV: 01356 case GL_MAP1_VERTEX_ATTRIB11_4_NV: 01357 case GL_MAP1_VERTEX_ATTRIB12_4_NV: 01358 case GL_MAP1_VERTEX_ATTRIB13_4_NV: 01359 case GL_MAP1_VERTEX_ATTRIB14_4_NV: 01360 case GL_MAP1_VERTEX_ATTRIB15_4_NV: 01361 CHECK_EXTENSION(NV_vertex_program); 01362 { 01363 const GLuint map = (GLuint) (cap - GL_MAP1_VERTEX_ATTRIB0_4_NV); 01364 return ctx->Eval.Map1Attrib[map]; 01365 } 01366 case GL_MAP2_VERTEX_ATTRIB0_4_NV: 01367 case GL_MAP2_VERTEX_ATTRIB1_4_NV: 01368 case GL_MAP2_VERTEX_ATTRIB2_4_NV: 01369 case GL_MAP2_VERTEX_ATTRIB3_4_NV: 01370 case GL_MAP2_VERTEX_ATTRIB4_4_NV: 01371 case GL_MAP2_VERTEX_ATTRIB5_4_NV: 01372 case GL_MAP2_VERTEX_ATTRIB6_4_NV: 01373 case GL_MAP2_VERTEX_ATTRIB7_4_NV: 01374 case GL_MAP2_VERTEX_ATTRIB8_4_NV: 01375 case GL_MAP2_VERTEX_ATTRIB9_4_NV: 01376 case GL_MAP2_VERTEX_ATTRIB10_4_NV: 01377 case GL_MAP2_VERTEX_ATTRIB11_4_NV: 01378 case GL_MAP2_VERTEX_ATTRIB12_4_NV: 01379 case GL_MAP2_VERTEX_ATTRIB13_4_NV: 01380 case GL_MAP2_VERTEX_ATTRIB14_4_NV: 01381 case GL_MAP2_VERTEX_ATTRIB15_4_NV: 01382 CHECK_EXTENSION(NV_vertex_program); 01383 { 01384 const GLuint map = (GLuint) (cap - GL_MAP2_VERTEX_ATTRIB0_4_NV); 01385 return ctx->Eval.Map2Attrib[map]; 01386 } 01387 #endif /* FEATURE_NV_vertex_program */ 01388 01389 #if FEATURE_NV_fragment_program 01390 case GL_FRAGMENT_PROGRAM_NV: 01391 CHECK_EXTENSION(NV_fragment_program); 01392 return ctx->FragmentProgram.Enabled; 01393 #endif /* FEATURE_NV_fragment_program */ 01394 01395 /* GL_NV_texture_rectangle */ 01396 case GL_TEXTURE_RECTANGLE_NV: 01397 CHECK_EXTENSION(NV_texture_rectangle); 01398 return is_texture_enabled(ctx, TEXTURE_RECT_BIT); 01399 01400 /* GL_EXT_stencil_two_side */ 01401 case GL_STENCIL_TEST_TWO_SIDE_EXT: 01402 CHECK_EXTENSION(EXT_stencil_two_side); 01403 return ctx->Stencil.TestTwoSide; 01404 01405 #if FEATURE_ARB_fragment_program 01406 case GL_FRAGMENT_PROGRAM_ARB: 01407 return ctx->FragmentProgram.Enabled; 01408 #endif /* FEATURE_ARB_fragment_program */ 01409 01410 /* GL_EXT_depth_bounds_test */ 01411 case GL_DEPTH_BOUNDS_TEST_EXT: 01412 CHECK_EXTENSION(EXT_depth_bounds_test); 01413 return ctx->Depth.BoundsTest; 01414 01415 /* GL_MESA_program_debug */ 01416 case GL_FRAGMENT_PROGRAM_CALLBACK_MESA: 01417 CHECK_EXTENSION(MESA_program_debug); 01418 return ctx->FragmentProgram.CallbackEnabled; 01419 case GL_VERTEX_PROGRAM_CALLBACK_MESA: 01420 CHECK_EXTENSION(MESA_program_debug); 01421 return ctx->VertexProgram.CallbackEnabled; 01422 #if FEATURE_ATI_fragment_shader 01423 case GL_FRAGMENT_SHADER_ATI: 01424 CHECK_EXTENSION(ATI_fragment_shader); 01425 return ctx->ATIFragmentShader.Enabled; 01426 #endif /* FEATURE_ATI_fragment_shader */ 01427 default: 01428 _mesa_error(ctx, GL_INVALID_ENUM, "glIsEnabled(0x%x)", (int) cap); 01429 return GL_FALSE; 01430 } 01431 }
Generated on Sun May 27 2012 04:20:15 for ReactOS by
1.7.6.1
