get.c revision 09dbc1e5aea9d584d7d031bcf0c945aa16cef2a1
1/* 2 * Mesa 3-D graphics library 3 * Version: 5.1 4 * 5 * Copyright (C) 1999-2003 Brian Paul All Rights Reserved. 6 * 7 * Permission is hereby granted, free of charge, to any person obtaining a 8 * copy of this software and associated documentation files (the "Software"), 9 * to deal in the Software without restriction, including without limitation 10 * the rights to use, copy, modify, merge, publish, distribute, sublicense, 11 * and/or sell copies of the Software, and to permit persons to whom the 12 * Software is furnished to do so, subject to the following conditions: 13 * 14 * The above copyright notice and this permission notice shall be included 15 * in all copies or substantial portions of the Software. 16 * 17 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS 18 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 19 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL 20 * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN 21 * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN 22 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. 23 */ 24 25 26#include "glheader.h" 27#include "colormac.h" 28#include "context.h" 29#include "enable.h" 30#include "enums.h" 31#include "extensions.h" 32#include "get.h" 33#include "macros.h" 34#include "mtypes.h" 35#include "texcompress.h" 36#include "version.h" 37#include "math/m_matrix.h" 38 39 40#define FLOAT_TO_BOOL(X) ( (X)==0.0F ? GL_FALSE : GL_TRUE ) 41#define INT_TO_BOOL(I) ( (I)==0 ? GL_FALSE : GL_TRUE ) 42#define ENUM_TO_BOOL(E) ( (E)==0 ? GL_FALSE : GL_TRUE ) 43 44#ifdef SPECIALCAST 45/* Needed for an Amiga compiler */ 46#define ENUM_TO_FLOAT(X) ((GLfloat)(GLint)(X)) 47#define ENUM_TO_DOUBLE(X) ((GLdouble)(GLint)(X)) 48#else 49/* all other compilers */ 50#define ENUM_TO_FLOAT(X) ((GLfloat)(X)) 51#define ENUM_TO_DOUBLE(X) ((GLdouble)(X)) 52#endif 53 54 55/* Check if named extension is enabled, if not generate error and return */ 56 57#define CHECK_EXTENSION_B(EXTNAME, PNAME) \ 58 if (!ctx->Extensions.EXTNAME) { \ 59 _mesa_error(ctx, GL_INVALID_VALUE, \ 60 "glGetBooleanv(0x%x)", (int) PNAME); \ 61 return; \ 62 } 63 64#define CHECK_EXTENSION_I(EXTNAME, PNAME) \ 65 if (!ctx->Extensions.EXTNAME) { \ 66 _mesa_error(ctx, GL_INVALID_VALUE, \ 67 "glGetIntegerv(0x%x)", (int) PNAME); \ 68 return; \ 69 } 70 71#define CHECK_EXTENSION_F(EXTNAME, PNAME) \ 72 if (!ctx->Extensions.EXTNAME) { \ 73 _mesa_error(ctx, GL_INVALID_VALUE, \ 74 "glGetFloatv(0x%x)", (int) PNAME); \ 75 return; \ 76 } 77 78#define CHECK_EXTENSION_D(EXTNAME, PNAME) \ 79 if (!ctx->Extensions.EXTNAME) { \ 80 _mesa_error(ctx, GL_INVALID_VALUE, \ 81 "glGetDoublev(0x%x)", (int) PNAME); \ 82 return; \ 83 } 84 85 86 87 88static GLenum 89pixel_texgen_mode(const GLcontext *ctx) 90{ 91 if (ctx->Pixel.FragmentRgbSource == GL_CURRENT_RASTER_POSITION) { 92 if (ctx->Pixel.FragmentAlphaSource == GL_CURRENT_RASTER_POSITION) { 93 return GL_RGBA; 94 } 95 else { 96 return GL_RGB; 97 } 98 } 99 else { 100 if (ctx->Pixel.FragmentAlphaSource == GL_CURRENT_RASTER_POSITION) { 101 return GL_ALPHA; 102 } 103 else { 104 return GL_NONE; 105 } 106 } 107} 108 109 110void 111_mesa_GetBooleanv( GLenum pname, GLboolean *params ) 112{ 113 GET_CURRENT_CONTEXT(ctx); 114 GLuint i; 115 GLuint texUnit = ctx->Texture.CurrentUnit; 116 const struct gl_texture_unit *textureUnit = &ctx->Texture.Unit[texUnit]; 117 ASSERT_OUTSIDE_BEGIN_END(ctx); 118 119 if (!params) 120 return; 121 122 /* We need this in order to get correct results for 123 * GL_OCCLUSION_TEST_RESULT_HP. There might be other important cases. 124 */ 125 FLUSH_VERTICES(ctx, 0); 126 127 if (MESA_VERBOSE & VERBOSE_API) 128 _mesa_debug(ctx, "glGetBooleanv %s\n", _mesa_lookup_enum_by_nr(pname)); 129 130 if (ctx->Driver.GetBooleanv 131 && (*ctx->Driver.GetBooleanv)(ctx, pname, params)) 132 return; 133 134 switch (pname) { 135 case GL_ACCUM_RED_BITS: 136 *params = INT_TO_BOOL(ctx->Visual.accumRedBits); 137 break; 138 case GL_ACCUM_GREEN_BITS: 139 *params = INT_TO_BOOL(ctx->Visual.accumGreenBits); 140 break; 141 case GL_ACCUM_BLUE_BITS: 142 *params = INT_TO_BOOL(ctx->Visual.accumBlueBits); 143 break; 144 case GL_ACCUM_ALPHA_BITS: 145 *params = INT_TO_BOOL(ctx->Visual.accumAlphaBits); 146 break; 147 case GL_ACCUM_CLEAR_VALUE: 148 params[0] = FLOAT_TO_BOOL(ctx->Accum.ClearColor[0]); 149 params[1] = FLOAT_TO_BOOL(ctx->Accum.ClearColor[1]); 150 params[2] = FLOAT_TO_BOOL(ctx->Accum.ClearColor[2]); 151 params[3] = FLOAT_TO_BOOL(ctx->Accum.ClearColor[3]); 152 break; 153 case GL_ALPHA_BIAS: 154 *params = FLOAT_TO_BOOL(ctx->Pixel.AlphaBias); 155 break; 156 case GL_ALPHA_BITS: 157 *params = INT_TO_BOOL(ctx->Visual.alphaBits); 158 break; 159 case GL_ALPHA_SCALE: 160 *params = FLOAT_TO_BOOL(ctx->Pixel.AlphaScale); 161 break; 162 case GL_ALPHA_TEST: 163 *params = ctx->Color.AlphaEnabled; 164 break; 165 case GL_ALPHA_TEST_FUNC: 166 *params = ENUM_TO_BOOL(ctx->Color.AlphaFunc); 167 break; 168 case GL_ALPHA_TEST_REF: 169 *params = ctx->Color.AlphaRef ? GL_TRUE : GL_FALSE; 170 break; 171 case GL_ATTRIB_STACK_DEPTH: 172 *params = INT_TO_BOOL(ctx->AttribStackDepth); 173 break; 174 case GL_AUTO_NORMAL: 175 *params = ctx->Eval.AutoNormal; 176 break; 177 case GL_AUX_BUFFERS: 178 *params = (ctx->Const.NumAuxBuffers) ? GL_TRUE : GL_FALSE; 179 break; 180 case GL_BLEND: 181 *params = ctx->Color.BlendEnabled; 182 break; 183 case GL_BLEND_DST: 184 *params = ENUM_TO_BOOL(ctx->Color.BlendDstRGB); 185 break; 186 case GL_BLEND_SRC: 187 *params = ENUM_TO_BOOL(ctx->Color.BlendSrcRGB); 188 break; 189 case GL_BLEND_SRC_RGB_EXT: 190 *params = ENUM_TO_BOOL(ctx->Color.BlendSrcRGB); 191 break; 192 case GL_BLEND_DST_RGB_EXT: 193 *params = ENUM_TO_BOOL(ctx->Color.BlendDstRGB); 194 break; 195 case GL_BLEND_SRC_ALPHA_EXT: 196 *params = ENUM_TO_BOOL(ctx->Color.BlendSrcA); 197 break; 198 case GL_BLEND_DST_ALPHA_EXT: 199 *params = ENUM_TO_BOOL(ctx->Color.BlendDstA); 200 break; 201 case GL_BLEND_EQUATION_EXT: 202 *params = ENUM_TO_BOOL( ctx->Color.BlendEquation ); 203 break; 204 case GL_BLEND_COLOR_EXT: 205 params[0] = FLOAT_TO_BOOL( ctx->Color.BlendColor[0] ); 206 params[1] = FLOAT_TO_BOOL( ctx->Color.BlendColor[1] ); 207 params[2] = FLOAT_TO_BOOL( ctx->Color.BlendColor[2] ); 208 params[3] = FLOAT_TO_BOOL( ctx->Color.BlendColor[3] ); 209 break; 210 case GL_BLUE_BIAS: 211 *params = FLOAT_TO_BOOL(ctx->Pixel.BlueBias); 212 break; 213 case GL_BLUE_BITS: 214 *params = INT_TO_BOOL( ctx->Visual.blueBits ); 215 break; 216 case GL_BLUE_SCALE: 217 *params = FLOAT_TO_BOOL(ctx->Pixel.BlueScale); 218 break; 219 case GL_CLIENT_ATTRIB_STACK_DEPTH: 220 *params = INT_TO_BOOL(ctx->ClientAttribStackDepth); 221 break; 222 case GL_CLIP_PLANE0: 223 case GL_CLIP_PLANE1: 224 case GL_CLIP_PLANE2: 225 case GL_CLIP_PLANE3: 226 case GL_CLIP_PLANE4: 227 case GL_CLIP_PLANE5: 228 if (ctx->Transform.ClipPlanesEnabled & (1 << (pname - GL_CLIP_PLANE0))) 229 *params = GL_TRUE; 230 else 231 *params = GL_FALSE; 232 break; 233 case GL_COLOR_CLEAR_VALUE: 234 params[0] = ctx->Color.ClearColor[0] ? GL_TRUE : GL_FALSE; 235 params[1] = ctx->Color.ClearColor[1] ? GL_TRUE : GL_FALSE; 236 params[2] = ctx->Color.ClearColor[2] ? GL_TRUE : GL_FALSE; 237 params[3] = ctx->Color.ClearColor[3] ? GL_TRUE : GL_FALSE; 238 break; 239 case GL_COLOR_MATERIAL: 240 *params = ctx->Light.ColorMaterialEnabled; 241 break; 242 case GL_COLOR_MATERIAL_FACE: 243 *params = ENUM_TO_BOOL(ctx->Light.ColorMaterialFace); 244 break; 245 case GL_COLOR_MATERIAL_PARAMETER: 246 *params = ENUM_TO_BOOL(ctx->Light.ColorMaterialMode); 247 break; 248 case GL_COLOR_WRITEMASK: 249 params[0] = ctx->Color.ColorMask[RCOMP] ? GL_TRUE : GL_FALSE; 250 params[1] = ctx->Color.ColorMask[GCOMP] ? GL_TRUE : GL_FALSE; 251 params[2] = ctx->Color.ColorMask[BCOMP] ? GL_TRUE : GL_FALSE; 252 params[3] = ctx->Color.ColorMask[ACOMP] ? GL_TRUE : GL_FALSE; 253 break; 254 case GL_CULL_FACE: 255 *params = ctx->Polygon.CullFlag; 256 break; 257 case GL_CULL_FACE_MODE: 258 *params = ENUM_TO_BOOL(ctx->Polygon.CullFaceMode); 259 break; 260 case GL_CURRENT_COLOR: 261 FLUSH_CURRENT(ctx, 0); 262 params[0] = FLOAT_TO_BOOL(ctx->Current.Attrib[VERT_ATTRIB_COLOR0][0]); 263 params[1] = FLOAT_TO_BOOL(ctx->Current.Attrib[VERT_ATTRIB_COLOR0][1]); 264 params[2] = FLOAT_TO_BOOL(ctx->Current.Attrib[VERT_ATTRIB_COLOR0][2]); 265 params[3] = FLOAT_TO_BOOL(ctx->Current.Attrib[VERT_ATTRIB_COLOR0][3]); 266 break; 267 case GL_CURRENT_INDEX: 268 FLUSH_CURRENT(ctx, 0); 269 *params = INT_TO_BOOL(ctx->Current.Index); 270 break; 271 case GL_CURRENT_NORMAL: 272 FLUSH_CURRENT(ctx, 0); 273 params[0] = FLOAT_TO_BOOL(ctx->Current.Attrib[VERT_ATTRIB_NORMAL][0]); 274 params[1] = FLOAT_TO_BOOL(ctx->Current.Attrib[VERT_ATTRIB_NORMAL][1]); 275 params[2] = FLOAT_TO_BOOL(ctx->Current.Attrib[VERT_ATTRIB_NORMAL][2]); 276 break; 277 case GL_CURRENT_RASTER_COLOR: 278 params[0] = FLOAT_TO_BOOL(ctx->Current.RasterColor[0]); 279 params[1] = FLOAT_TO_BOOL(ctx->Current.RasterColor[1]); 280 params[2] = FLOAT_TO_BOOL(ctx->Current.RasterColor[2]); 281 params[3] = FLOAT_TO_BOOL(ctx->Current.RasterColor[3]); 282 break; 283 case GL_CURRENT_RASTER_DISTANCE: 284 *params = FLOAT_TO_BOOL(ctx->Current.RasterDistance); 285 break; 286 case GL_CURRENT_RASTER_INDEX: 287 *params = FLOAT_TO_BOOL(ctx->Current.RasterIndex); 288 break; 289 case GL_CURRENT_RASTER_POSITION: 290 params[0] = FLOAT_TO_BOOL(ctx->Current.RasterPos[0]); 291 params[1] = FLOAT_TO_BOOL(ctx->Current.RasterPos[1]); 292 params[2] = FLOAT_TO_BOOL(ctx->Current.RasterPos[2]); 293 params[3] = FLOAT_TO_BOOL(ctx->Current.RasterPos[3]); 294 break; 295 case GL_CURRENT_RASTER_TEXTURE_COORDS: 296 params[0] = FLOAT_TO_BOOL(ctx->Current.RasterTexCoords[texUnit][0]); 297 params[1] = FLOAT_TO_BOOL(ctx->Current.RasterTexCoords[texUnit][1]); 298 params[2] = FLOAT_TO_BOOL(ctx->Current.RasterTexCoords[texUnit][2]); 299 params[3] = FLOAT_TO_BOOL(ctx->Current.RasterTexCoords[texUnit][3]); 300 break; 301 case GL_CURRENT_RASTER_POSITION_VALID: 302 *params = ctx->Current.RasterPosValid; 303 break; 304 case GL_CURRENT_TEXTURE_COORDS: 305 FLUSH_CURRENT(ctx, 0); 306 params[0] = FLOAT_TO_BOOL(ctx->Current.Attrib[VERT_ATTRIB_TEX0 + texUnit][0]); 307 params[1] = FLOAT_TO_BOOL(ctx->Current.Attrib[VERT_ATTRIB_TEX0 + texUnit][1]); 308 params[2] = FLOAT_TO_BOOL(ctx->Current.Attrib[VERT_ATTRIB_TEX0 + texUnit][2]); 309 params[3] = FLOAT_TO_BOOL(ctx->Current.Attrib[VERT_ATTRIB_TEX0 + texUnit][3]); 310 break; 311 case GL_DEPTH_BIAS: 312 *params = FLOAT_TO_BOOL(ctx->Pixel.DepthBias); 313 break; 314 case GL_DEPTH_BITS: 315 *params = INT_TO_BOOL(ctx->Visual.depthBits); 316 break; 317 case GL_DEPTH_CLEAR_VALUE: 318 *params = FLOAT_TO_BOOL(ctx->Depth.Clear); 319 break; 320 case GL_DEPTH_FUNC: 321 *params = ENUM_TO_BOOL(ctx->Depth.Func); 322 break; 323 case GL_DEPTH_RANGE: 324 params[0] = FLOAT_TO_BOOL(ctx->Viewport.Near); 325 params[1] = FLOAT_TO_BOOL(ctx->Viewport.Far); 326 break; 327 case GL_DEPTH_SCALE: 328 *params = FLOAT_TO_BOOL(ctx->Pixel.DepthScale); 329 break; 330 case GL_DEPTH_TEST: 331 *params = ctx->Depth.Test; 332 break; 333 case GL_DEPTH_WRITEMASK: 334 *params = ctx->Depth.Mask; 335 break; 336 case GL_DITHER: 337 *params = ctx->Color.DitherFlag; 338 break; 339 case GL_DOUBLEBUFFER: 340 *params = ctx->Visual.doubleBufferMode; 341 break; 342 case GL_DRAW_BUFFER: 343 *params = ENUM_TO_BOOL(ctx->Color.DrawBuffer); 344 break; 345 case GL_EDGE_FLAG: 346 FLUSH_CURRENT(ctx, 0); 347 *params = ctx->Current.EdgeFlag; 348 break; 349 case GL_FEEDBACK_BUFFER_SIZE: 350 *params = INT_TO_BOOL(ctx->Feedback.BufferSize); 351 break; 352 case GL_FEEDBACK_BUFFER_TYPE: 353 *params = INT_TO_BOOL(ctx->Feedback.Type); 354 break; 355 case GL_FOG: 356 *params = ctx->Fog.Enabled; 357 break; 358 case GL_FOG_COLOR: 359 params[0] = FLOAT_TO_BOOL(ctx->Fog.Color[0]); 360 params[1] = FLOAT_TO_BOOL(ctx->Fog.Color[1]); 361 params[2] = FLOAT_TO_BOOL(ctx->Fog.Color[2]); 362 params[3] = FLOAT_TO_BOOL(ctx->Fog.Color[3]); 363 break; 364 case GL_FOG_DENSITY: 365 *params = FLOAT_TO_BOOL(ctx->Fog.Density); 366 break; 367 case GL_FOG_END: 368 *params = FLOAT_TO_BOOL(ctx->Fog.End); 369 break; 370 case GL_FOG_HINT: 371 *params = ENUM_TO_BOOL(ctx->Hint.Fog); 372 break; 373 case GL_FOG_INDEX: 374 *params = FLOAT_TO_BOOL(ctx->Fog.Index); 375 break; 376 case GL_FOG_MODE: 377 *params = ENUM_TO_BOOL(ctx->Fog.Mode); 378 break; 379 case GL_FOG_START: 380 *params = FLOAT_TO_BOOL(ctx->Fog.End); 381 break; 382 case GL_FRONT_FACE: 383 *params = ENUM_TO_BOOL(ctx->Polygon.FrontFace); 384 break; 385 case GL_GREEN_BIAS: 386 *params = FLOAT_TO_BOOL(ctx->Pixel.GreenBias); 387 break; 388 case GL_GREEN_BITS: 389 *params = INT_TO_BOOL( ctx->Visual.greenBits ); 390 break; 391 case GL_GREEN_SCALE: 392 *params = FLOAT_TO_BOOL(ctx->Pixel.GreenScale); 393 break; 394 case GL_INDEX_BITS: 395 *params = INT_TO_BOOL( ctx->Visual.indexBits ); 396 break; 397 case GL_INDEX_CLEAR_VALUE: 398 *params = INT_TO_BOOL(ctx->Color.ClearIndex); 399 break; 400 case GL_INDEX_MODE: 401 *params = ctx->Visual.rgbMode ? GL_FALSE : GL_TRUE; 402 break; 403 case GL_INDEX_OFFSET: 404 *params = INT_TO_BOOL(ctx->Pixel.IndexOffset); 405 break; 406 case GL_INDEX_SHIFT: 407 *params = INT_TO_BOOL(ctx->Pixel.IndexShift); 408 break; 409 case GL_INDEX_WRITEMASK: 410 *params = INT_TO_BOOL(ctx->Color.IndexMask); 411 break; 412 case GL_LIGHT0: 413 case GL_LIGHT1: 414 case GL_LIGHT2: 415 case GL_LIGHT3: 416 case GL_LIGHT4: 417 case GL_LIGHT5: 418 case GL_LIGHT6: 419 case GL_LIGHT7: 420 *params = ctx->Light.Light[pname-GL_LIGHT0].Enabled; 421 break; 422 case GL_LIGHTING: 423 *params = ctx->Light.Enabled; 424 break; 425 case GL_LIGHT_MODEL_AMBIENT: 426 params[0] = FLOAT_TO_BOOL(ctx->Light.Model.Ambient[0]); 427 params[1] = FLOAT_TO_BOOL(ctx->Light.Model.Ambient[1]); 428 params[2] = FLOAT_TO_BOOL(ctx->Light.Model.Ambient[2]); 429 params[3] = FLOAT_TO_BOOL(ctx->Light.Model.Ambient[3]); 430 break; 431 case GL_LIGHT_MODEL_COLOR_CONTROL: 432 params[0] = ENUM_TO_BOOL(ctx->Light.Model.ColorControl); 433 break; 434 case GL_LIGHT_MODEL_LOCAL_VIEWER: 435 *params = ctx->Light.Model.LocalViewer; 436 break; 437 case GL_LIGHT_MODEL_TWO_SIDE: 438 *params = ctx->Light.Model.TwoSide; 439 break; 440 case GL_LINE_SMOOTH: 441 *params = ctx->Line.SmoothFlag; 442 break; 443 case GL_LINE_SMOOTH_HINT: 444 *params = ENUM_TO_BOOL(ctx->Hint.LineSmooth); 445 break; 446 case GL_LINE_STIPPLE: 447 *params = ctx->Line.StippleFlag; 448 break; 449 case GL_LINE_STIPPLE_PATTERN: 450 *params = INT_TO_BOOL(ctx->Line.StipplePattern); 451 break; 452 case GL_LINE_STIPPLE_REPEAT: 453 *params = INT_TO_BOOL(ctx->Line.StippleFactor); 454 break; 455 case GL_LINE_WIDTH: 456 *params = FLOAT_TO_BOOL(ctx->Line.Width); 457 break; 458 case GL_LINE_WIDTH_GRANULARITY: 459 *params = FLOAT_TO_BOOL(ctx->Const.LineWidthGranularity); 460 break; 461 case GL_LINE_WIDTH_RANGE: 462 params[0] = FLOAT_TO_BOOL(ctx->Const.MinLineWidthAA); 463 params[1] = FLOAT_TO_BOOL(ctx->Const.MaxLineWidthAA); 464 break; 465 case GL_ALIASED_LINE_WIDTH_RANGE: 466 params[0] = FLOAT_TO_BOOL(ctx->Const.MinLineWidth); 467 params[1] = FLOAT_TO_BOOL(ctx->Const.MaxLineWidth); 468 break; 469 case GL_LIST_BASE: 470 *params = INT_TO_BOOL(ctx->List.ListBase); 471 break; 472 case GL_LIST_INDEX: 473 *params = INT_TO_BOOL( ctx->CurrentListNum ); 474 break; 475 case GL_LIST_MODE: 476 if (!ctx->CompileFlag) 477 *params = 0; 478 else if (ctx->ExecuteFlag) 479 *params = ENUM_TO_BOOL(GL_COMPILE_AND_EXECUTE); 480 else 481 *params = ENUM_TO_BOOL(GL_COMPILE); 482 break; 483 case GL_INDEX_LOGIC_OP: 484 *params = ctx->Color.IndexLogicOpEnabled; 485 break; 486 case GL_COLOR_LOGIC_OP: 487 *params = ctx->Color.ColorLogicOpEnabled; 488 break; 489 case GL_LOGIC_OP_MODE: 490 *params = ENUM_TO_BOOL(ctx->Color.LogicOp); 491 break; 492 case GL_MAP1_COLOR_4: 493 *params = ctx->Eval.Map1Color4; 494 break; 495 case GL_MAP1_GRID_DOMAIN: 496 params[0] = FLOAT_TO_BOOL(ctx->Eval.MapGrid1u1); 497 params[1] = FLOAT_TO_BOOL(ctx->Eval.MapGrid1u2); 498 break; 499 case GL_MAP1_GRID_SEGMENTS: 500 *params = INT_TO_BOOL(ctx->Eval.MapGrid1un); 501 break; 502 case GL_MAP1_INDEX: 503 *params = ctx->Eval.Map1Index; 504 break; 505 case GL_MAP1_NORMAL: 506 *params = ctx->Eval.Map1Normal; 507 break; 508 case GL_MAP1_TEXTURE_COORD_1: 509 *params = ctx->Eval.Map1TextureCoord1; 510 break; 511 case GL_MAP1_TEXTURE_COORD_2: 512 *params = ctx->Eval.Map1TextureCoord2; 513 break; 514 case GL_MAP1_TEXTURE_COORD_3: 515 *params = ctx->Eval.Map1TextureCoord3; 516 break; 517 case GL_MAP1_TEXTURE_COORD_4: 518 *params = ctx->Eval.Map1TextureCoord4; 519 break; 520 case GL_MAP1_VERTEX_3: 521 *params = ctx->Eval.Map1Vertex3; 522 break; 523 case GL_MAP1_VERTEX_4: 524 *params = ctx->Eval.Map1Vertex4; 525 break; 526 case GL_MAP2_COLOR_4: 527 *params = ctx->Eval.Map2Color4; 528 break; 529 case GL_MAP2_GRID_DOMAIN: 530 params[0] = FLOAT_TO_BOOL(ctx->Eval.MapGrid2u1); 531 params[1] = FLOAT_TO_BOOL(ctx->Eval.MapGrid2u2); 532 params[2] = FLOAT_TO_BOOL(ctx->Eval.MapGrid2v1); 533 params[3] = FLOAT_TO_BOOL(ctx->Eval.MapGrid2v2); 534 break; 535 case GL_MAP2_GRID_SEGMENTS: 536 params[0] = INT_TO_BOOL(ctx->Eval.MapGrid2un); 537 params[1] = INT_TO_BOOL(ctx->Eval.MapGrid2vn); 538 break; 539 case GL_MAP2_INDEX: 540 *params = ctx->Eval.Map2Index; 541 break; 542 case GL_MAP2_NORMAL: 543 *params = ctx->Eval.Map2Normal; 544 break; 545 case GL_MAP2_TEXTURE_COORD_1: 546 *params = ctx->Eval.Map2TextureCoord1; 547 break; 548 case GL_MAP2_TEXTURE_COORD_2: 549 *params = ctx->Eval.Map2TextureCoord2; 550 break; 551 case GL_MAP2_TEXTURE_COORD_3: 552 *params = ctx->Eval.Map2TextureCoord3; 553 break; 554 case GL_MAP2_TEXTURE_COORD_4: 555 *params = ctx->Eval.Map2TextureCoord4; 556 break; 557 case GL_MAP2_VERTEX_3: 558 *params = ctx->Eval.Map2Vertex3; 559 break; 560 case GL_MAP2_VERTEX_4: 561 *params = ctx->Eval.Map2Vertex4; 562 break; 563 case GL_MAP_COLOR: 564 *params = ctx->Pixel.MapColorFlag; 565 break; 566 case GL_MAP_STENCIL: 567 *params = ctx->Pixel.MapStencilFlag; 568 break; 569 case GL_MATRIX_MODE: 570 *params = ENUM_TO_BOOL( ctx->Transform.MatrixMode ); 571 break; 572 case GL_MAX_ATTRIB_STACK_DEPTH: 573 *params = INT_TO_BOOL(MAX_ATTRIB_STACK_DEPTH); 574 break; 575 case GL_MAX_CLIENT_ATTRIB_STACK_DEPTH: 576 *params = INT_TO_BOOL( MAX_CLIENT_ATTRIB_STACK_DEPTH); 577 break; 578 case GL_MAX_CLIP_PLANES: 579 *params = INT_TO_BOOL(ctx->Const.MaxClipPlanes); 580 break; 581 case GL_MAX_ELEMENTS_VERTICES: /* GL_VERSION_1_2 */ 582 *params = INT_TO_BOOL(ctx->Const.MaxArrayLockSize); 583 break; 584 case GL_MAX_ELEMENTS_INDICES: /* GL_VERSION_1_2 */ 585 *params = INT_TO_BOOL(ctx->Const.MaxArrayLockSize); 586 break; 587 case GL_MAX_EVAL_ORDER: 588 *params = INT_TO_BOOL(MAX_EVAL_ORDER); 589 break; 590 case GL_MAX_LIGHTS: 591 *params = INT_TO_BOOL(ctx->Const.MaxLights); 592 break; 593 case GL_MAX_LIST_NESTING: 594 *params = INT_TO_BOOL(MAX_LIST_NESTING); 595 break; 596 case GL_MAX_MODELVIEW_STACK_DEPTH: 597 *params = INT_TO_BOOL(MAX_MODELVIEW_STACK_DEPTH); 598 break; 599 case GL_MAX_NAME_STACK_DEPTH: 600 *params = INT_TO_BOOL(MAX_NAME_STACK_DEPTH); 601 break; 602 case GL_MAX_PIXEL_MAP_TABLE: 603 *params = INT_TO_BOOL(MAX_PIXEL_MAP_TABLE); 604 break; 605 case GL_MAX_PROJECTION_STACK_DEPTH: 606 *params = INT_TO_BOOL(MAX_PROJECTION_STACK_DEPTH); 607 break; 608 case GL_MAX_TEXTURE_SIZE: 609 *params = INT_TO_BOOL(1 << (ctx->Const.MaxTextureLevels - 1)); 610 break; 611 case GL_MAX_3D_TEXTURE_SIZE: 612 *params = INT_TO_BOOL(1 << (ctx->Const.Max3DTextureLevels - 1)); 613 break; 614 case GL_MAX_TEXTURE_STACK_DEPTH: 615 *params = INT_TO_BOOL(MAX_TEXTURE_STACK_DEPTH); 616 break; 617 case GL_MAX_VIEWPORT_DIMS: 618 params[0] = INT_TO_BOOL(MAX_WIDTH); 619 params[1] = INT_TO_BOOL(MAX_HEIGHT); 620 break; 621 case GL_MODELVIEW_MATRIX: 622 for (i=0;i<16;i++) { 623 params[i] = FLOAT_TO_BOOL(ctx->ModelviewMatrixStack.Top->m[i]); 624 } 625 break; 626 case GL_MODELVIEW_STACK_DEPTH: 627 *params = INT_TO_BOOL(ctx->ModelviewMatrixStack.Depth + 1); 628 break; 629 case GL_NAME_STACK_DEPTH: 630 *params = INT_TO_BOOL(ctx->Select.NameStackDepth); 631 break; 632 case GL_NORMALIZE: 633 *params = ctx->Transform.Normalize; 634 break; 635 case GL_PACK_ALIGNMENT: 636 *params = INT_TO_BOOL(ctx->Pack.Alignment); 637 break; 638 case GL_PACK_LSB_FIRST: 639 *params = ctx->Pack.LsbFirst; 640 break; 641 case GL_PACK_ROW_LENGTH: 642 *params = INT_TO_BOOL(ctx->Pack.RowLength); 643 break; 644 case GL_PACK_SKIP_PIXELS: 645 *params = INT_TO_BOOL(ctx->Pack.SkipPixels); 646 break; 647 case GL_PACK_SKIP_ROWS: 648 *params = INT_TO_BOOL(ctx->Pack.SkipRows); 649 break; 650 case GL_PACK_SWAP_BYTES: 651 *params = ctx->Pack.SwapBytes; 652 break; 653 case GL_PACK_SKIP_IMAGES_EXT: 654 *params = ctx->Pack.SkipImages; 655 break; 656 case GL_PACK_IMAGE_HEIGHT_EXT: 657 *params = ctx->Pack.ImageHeight; 658 break; 659 case GL_PACK_INVERT_MESA: 660 *params = ctx->Pack.Invert; 661 break; 662 case GL_PERSPECTIVE_CORRECTION_HINT: 663 *params = ENUM_TO_BOOL(ctx->Hint.PerspectiveCorrection); 664 break; 665 case GL_PIXEL_MAP_A_TO_A_SIZE: 666 *params = INT_TO_BOOL(ctx->Pixel.MapAtoAsize); 667 break; 668 case GL_PIXEL_MAP_B_TO_B_SIZE: 669 *params = INT_TO_BOOL(ctx->Pixel.MapBtoBsize); 670 break; 671 case GL_PIXEL_MAP_G_TO_G_SIZE: 672 *params = INT_TO_BOOL(ctx->Pixel.MapGtoGsize); 673 break; 674 case GL_PIXEL_MAP_I_TO_A_SIZE: 675 *params = INT_TO_BOOL(ctx->Pixel.MapItoAsize); 676 break; 677 case GL_PIXEL_MAP_I_TO_B_SIZE: 678 *params = INT_TO_BOOL(ctx->Pixel.MapItoBsize); 679 break; 680 case GL_PIXEL_MAP_I_TO_G_SIZE: 681 *params = INT_TO_BOOL(ctx->Pixel.MapItoGsize); 682 break; 683 case GL_PIXEL_MAP_I_TO_I_SIZE: 684 *params = INT_TO_BOOL(ctx->Pixel.MapItoIsize); 685 break; 686 case GL_PIXEL_MAP_I_TO_R_SIZE: 687 *params = INT_TO_BOOL(ctx->Pixel.MapItoRsize); 688 break; 689 case GL_PIXEL_MAP_R_TO_R_SIZE: 690 *params = INT_TO_BOOL(ctx->Pixel.MapRtoRsize); 691 break; 692 case GL_PIXEL_MAP_S_TO_S_SIZE: 693 *params = INT_TO_BOOL(ctx->Pixel.MapStoSsize); 694 break; 695 case GL_POINT_SIZE: 696 *params = FLOAT_TO_BOOL(ctx->Point.Size); 697 break; 698 case GL_POINT_SIZE_GRANULARITY: 699 *params = FLOAT_TO_BOOL(ctx->Const.PointSizeGranularity ); 700 break; 701 case GL_POINT_SIZE_RANGE: 702 params[0] = FLOAT_TO_BOOL(ctx->Const.MinPointSizeAA); 703 params[1] = FLOAT_TO_BOOL(ctx->Const.MaxPointSizeAA); 704 break; 705 case GL_ALIASED_POINT_SIZE_RANGE: 706 params[0] = FLOAT_TO_BOOL(ctx->Const.MinPointSize); 707 params[1] = FLOAT_TO_BOOL(ctx->Const.MaxPointSize); 708 break; 709 case GL_POINT_SMOOTH: 710 *params = ctx->Point.SmoothFlag; 711 break; 712 case GL_POINT_SMOOTH_HINT: 713 *params = ENUM_TO_BOOL(ctx->Hint.PointSmooth); 714 break; 715 case GL_POINT_SIZE_MIN_EXT: 716 *params = FLOAT_TO_BOOL(ctx->Point.MinSize); 717 break; 718 case GL_POINT_SIZE_MAX_EXT: 719 *params = FLOAT_TO_BOOL(ctx->Point.MaxSize); 720 break; 721 case GL_POINT_FADE_THRESHOLD_SIZE_EXT: 722 *params = FLOAT_TO_BOOL(ctx->Point.Threshold); 723 break; 724 case GL_DISTANCE_ATTENUATION_EXT: 725 params[0] = FLOAT_TO_BOOL(ctx->Point.Params[0]); 726 params[1] = FLOAT_TO_BOOL(ctx->Point.Params[1]); 727 params[2] = FLOAT_TO_BOOL(ctx->Point.Params[2]); 728 break; 729 case GL_POLYGON_MODE: 730 params[0] = ENUM_TO_BOOL(ctx->Polygon.FrontMode); 731 params[1] = ENUM_TO_BOOL(ctx->Polygon.BackMode); 732 break; 733 case GL_POLYGON_OFFSET_BIAS_EXT: /* GL_EXT_polygon_offset */ 734 *params = FLOAT_TO_BOOL( ctx->Polygon.OffsetUnits ); 735 break; 736 case GL_POLYGON_OFFSET_FACTOR: 737 *params = FLOAT_TO_BOOL( ctx->Polygon.OffsetFactor ); 738 break; 739 case GL_POLYGON_OFFSET_UNITS: 740 *params = FLOAT_TO_BOOL( ctx->Polygon.OffsetUnits ); 741 break; 742 case GL_POLYGON_SMOOTH: 743 *params = ctx->Polygon.SmoothFlag; 744 break; 745 case GL_POLYGON_SMOOTH_HINT: 746 *params = ENUM_TO_BOOL(ctx->Hint.PolygonSmooth); 747 break; 748 case GL_POLYGON_STIPPLE: 749 *params = ctx->Polygon.StippleFlag; 750 break; 751 case GL_PROJECTION_MATRIX: 752 for (i=0;i<16;i++) { 753 params[i] = FLOAT_TO_BOOL(ctx->ProjectionMatrixStack.Top->m[i]); 754 } 755 break; 756 case GL_PROJECTION_STACK_DEPTH: 757 *params = INT_TO_BOOL(ctx->ProjectionMatrixStack.Depth + 1); 758 break; 759 case GL_READ_BUFFER: 760 *params = ENUM_TO_BOOL(ctx->Pixel.ReadBuffer); 761 break; 762 case GL_RED_BIAS: 763 *params = FLOAT_TO_BOOL(ctx->Pixel.RedBias); 764 break; 765 case GL_RED_BITS: 766 *params = INT_TO_BOOL( ctx->Visual.redBits ); 767 break; 768 case GL_RED_SCALE: 769 *params = FLOAT_TO_BOOL(ctx->Pixel.RedScale); 770 break; 771 case GL_RENDER_MODE: 772 *params = ENUM_TO_BOOL(ctx->RenderMode); 773 break; 774 case GL_RESCALE_NORMAL: 775 *params = ctx->Transform.RescaleNormals; 776 break; 777 case GL_RGBA_MODE: 778 *params = ctx->Visual.rgbMode; 779 break; 780 case GL_SCISSOR_BOX: 781 params[0] = INT_TO_BOOL(ctx->Scissor.X); 782 params[1] = INT_TO_BOOL(ctx->Scissor.Y); 783 params[2] = INT_TO_BOOL(ctx->Scissor.Width); 784 params[3] = INT_TO_BOOL(ctx->Scissor.Height); 785 break; 786 case GL_SCISSOR_TEST: 787 *params = ctx->Scissor.Enabled; 788 break; 789 case GL_SELECTION_BUFFER_SIZE: 790 *params = INT_TO_BOOL(ctx->Select.BufferSize); 791 break; 792 case GL_SHADE_MODEL: 793 *params = ENUM_TO_BOOL(ctx->Light.ShadeModel); 794 break; 795 case GL_SHARED_TEXTURE_PALETTE_EXT: 796 *params = ctx->Texture.SharedPalette; 797 break; 798 case GL_STENCIL_BITS: 799 *params = INT_TO_BOOL(ctx->Visual.stencilBits); 800 break; 801 case GL_STENCIL_CLEAR_VALUE: 802 *params = INT_TO_BOOL(ctx->Stencil.Clear); 803 break; 804 case GL_STENCIL_FAIL: 805 *params = ENUM_TO_BOOL(ctx->Stencil.FailFunc[ctx->Stencil.ActiveFace]); 806 break; 807 case GL_STENCIL_FUNC: 808 *params = ENUM_TO_BOOL(ctx->Stencil.Function[ctx->Stencil.ActiveFace]); 809 break; 810 case GL_STENCIL_PASS_DEPTH_FAIL: 811 *params = ENUM_TO_BOOL(ctx->Stencil.ZFailFunc[ctx->Stencil.ActiveFace]); 812 break; 813 case GL_STENCIL_PASS_DEPTH_PASS: 814 *params = ENUM_TO_BOOL(ctx->Stencil.ZPassFunc[ctx->Stencil.ActiveFace]); 815 break; 816 case GL_STENCIL_REF: 817 *params = INT_TO_BOOL(ctx->Stencil.Ref[ctx->Stencil.ActiveFace]); 818 break; 819 case GL_STENCIL_TEST: 820 *params = ctx->Stencil.Enabled; 821 break; 822 case GL_STENCIL_VALUE_MASK: 823 *params = INT_TO_BOOL(ctx->Stencil.ValueMask[ctx->Stencil.ActiveFace]); 824 break; 825 case GL_STENCIL_WRITEMASK: 826 *params = INT_TO_BOOL(ctx->Stencil.WriteMask[ctx->Stencil.ActiveFace]); 827 break; 828 case GL_STEREO: 829 *params = ctx->Visual.stereoMode; 830 break; 831 case GL_SUBPIXEL_BITS: 832 *params = INT_TO_BOOL(ctx->Const.SubPixelBits); 833 break; 834 case GL_TEXTURE_1D: 835 *params = _mesa_IsEnabled(GL_TEXTURE_1D); 836 break; 837 case GL_TEXTURE_2D: 838 *params = _mesa_IsEnabled(GL_TEXTURE_2D); 839 break; 840 case GL_TEXTURE_3D: 841 *params = _mesa_IsEnabled(GL_TEXTURE_3D); 842 break; 843 case GL_TEXTURE_BINDING_1D: 844 *params = INT_TO_BOOL(textureUnit->Current1D->Name); 845 break; 846 case GL_TEXTURE_BINDING_2D: 847 *params = INT_TO_BOOL(textureUnit->Current2D->Name); 848 break; 849 case GL_TEXTURE_BINDING_3D: 850 *params = INT_TO_BOOL(textureUnit->Current3D->Name); 851 break; 852 case GL_TEXTURE_ENV_COLOR: 853 { 854 params[0] = FLOAT_TO_BOOL(textureUnit->EnvColor[0]); 855 params[1] = FLOAT_TO_BOOL(textureUnit->EnvColor[1]); 856 params[2] = FLOAT_TO_BOOL(textureUnit->EnvColor[2]); 857 params[3] = FLOAT_TO_BOOL(textureUnit->EnvColor[3]); 858 } 859 break; 860 case GL_TEXTURE_ENV_MODE: 861 *params = ENUM_TO_BOOL(textureUnit->EnvMode); 862 break; 863 case GL_TEXTURE_GEN_S: 864 *params = (textureUnit->TexGenEnabled & S_BIT) ? GL_TRUE : GL_FALSE; 865 break; 866 case GL_TEXTURE_GEN_T: 867 *params = (textureUnit->TexGenEnabled & T_BIT) ? GL_TRUE : GL_FALSE; 868 break; 869 case GL_TEXTURE_GEN_R: 870 *params = (textureUnit->TexGenEnabled & R_BIT) ? GL_TRUE : GL_FALSE; 871 break; 872 case GL_TEXTURE_GEN_Q: 873 *params = (textureUnit->TexGenEnabled & Q_BIT) ? GL_TRUE : GL_FALSE; 874 break; 875 case GL_TEXTURE_MATRIX: 876 for (i=0;i<16;i++) { 877 params[i] = 878 FLOAT_TO_BOOL(ctx->TextureMatrixStack[texUnit].Top->m[i]); 879 } 880 break; 881 case GL_TEXTURE_STACK_DEPTH: 882 *params = INT_TO_BOOL(ctx->TextureMatrixStack[texUnit].Depth + 1); 883 break; 884 case GL_UNPACK_ALIGNMENT: 885 *params = INT_TO_BOOL(ctx->Unpack.Alignment); 886 break; 887 case GL_UNPACK_LSB_FIRST: 888 *params = ctx->Unpack.LsbFirst; 889 break; 890 case GL_UNPACK_ROW_LENGTH: 891 *params = INT_TO_BOOL(ctx->Unpack.RowLength); 892 break; 893 case GL_UNPACK_SKIP_PIXELS: 894 *params = INT_TO_BOOL(ctx->Unpack.SkipPixels); 895 break; 896 case GL_UNPACK_SKIP_ROWS: 897 *params = INT_TO_BOOL(ctx->Unpack.SkipRows); 898 break; 899 case GL_UNPACK_SWAP_BYTES: 900 *params = ctx->Unpack.SwapBytes; 901 break; 902 case GL_UNPACK_SKIP_IMAGES_EXT: 903 *params = ctx->Unpack.SkipImages; 904 break; 905 case GL_UNPACK_IMAGE_HEIGHT_EXT: 906 *params = ctx->Unpack.ImageHeight; 907 break; 908 case GL_UNPACK_CLIENT_STORAGE_APPLE: 909 *params = ctx->Unpack.ClientStorage; 910 break; 911 case GL_VIEWPORT: 912 params[0] = INT_TO_BOOL(ctx->Viewport.X); 913 params[1] = INT_TO_BOOL(ctx->Viewport.Y); 914 params[2] = INT_TO_BOOL(ctx->Viewport.Width); 915 params[3] = INT_TO_BOOL(ctx->Viewport.Height); 916 break; 917 case GL_ZOOM_X: 918 *params = FLOAT_TO_BOOL(ctx->Pixel.ZoomX); 919 break; 920 case GL_ZOOM_Y: 921 *params = FLOAT_TO_BOOL(ctx->Pixel.ZoomY); 922 break; 923 case GL_VERTEX_ARRAY: 924 *params = ctx->Array.Vertex.Enabled; 925 break; 926 case GL_VERTEX_ARRAY_SIZE: 927 *params = INT_TO_BOOL(ctx->Array.Vertex.Size); 928 break; 929 case GL_VERTEX_ARRAY_TYPE: 930 *params = ENUM_TO_BOOL(ctx->Array.Vertex.Type); 931 break; 932 case GL_VERTEX_ARRAY_STRIDE: 933 *params = INT_TO_BOOL(ctx->Array.Vertex.Stride); 934 break; 935 case GL_VERTEX_ARRAY_COUNT_EXT: 936 *params = INT_TO_BOOL(0); 937 break; 938 case GL_NORMAL_ARRAY: 939 *params = ctx->Array.Normal.Enabled; 940 break; 941 case GL_NORMAL_ARRAY_TYPE: 942 *params = ENUM_TO_BOOL(ctx->Array.Normal.Type); 943 break; 944 case GL_NORMAL_ARRAY_STRIDE: 945 *params = INT_TO_BOOL(ctx->Array.Normal.Stride); 946 break; 947 case GL_NORMAL_ARRAY_COUNT_EXT: 948 *params = INT_TO_BOOL(0); 949 break; 950 case GL_COLOR_ARRAY: 951 *params = ctx->Array.Color.Enabled; 952 break; 953 case GL_COLOR_ARRAY_SIZE: 954 *params = INT_TO_BOOL(ctx->Array.Color.Size); 955 break; 956 case GL_COLOR_ARRAY_TYPE: 957 *params = ENUM_TO_BOOL(ctx->Array.Color.Type); 958 break; 959 case GL_COLOR_ARRAY_STRIDE: 960 *params = INT_TO_BOOL(ctx->Array.Color.Stride); 961 break; 962 case GL_COLOR_ARRAY_COUNT_EXT: 963 *params = INT_TO_BOOL(0); 964 break; 965 case GL_INDEX_ARRAY: 966 *params = ctx->Array.Index.Enabled; 967 break; 968 case GL_INDEX_ARRAY_TYPE: 969 *params = ENUM_TO_BOOL(ctx->Array.Index.Type); 970 break; 971 case GL_INDEX_ARRAY_STRIDE: 972 *params = INT_TO_BOOL(ctx->Array.Index.Stride); 973 break; 974 case GL_INDEX_ARRAY_COUNT_EXT: 975 *params = INT_TO_BOOL(0); 976 break; 977 case GL_TEXTURE_COORD_ARRAY: 978 *params = ctx->Array.TexCoord[texUnit].Enabled; 979 break; 980 case GL_TEXTURE_COORD_ARRAY_SIZE: 981 *params = INT_TO_BOOL(ctx->Array.TexCoord[texUnit].Size); 982 break; 983 case GL_TEXTURE_COORD_ARRAY_TYPE: 984 *params = ENUM_TO_BOOL(ctx->Array.TexCoord[texUnit].Type); 985 break; 986 case GL_TEXTURE_COORD_ARRAY_STRIDE: 987 *params = INT_TO_BOOL(ctx->Array.TexCoord[texUnit].Stride); 988 break; 989 case GL_TEXTURE_COORD_ARRAY_COUNT_EXT: 990 *params = INT_TO_BOOL(0); 991 break; 992 case GL_EDGE_FLAG_ARRAY: 993 *params = ctx->Array.EdgeFlag.Enabled; 994 break; 995 case GL_EDGE_FLAG_ARRAY_STRIDE: 996 *params = INT_TO_BOOL(ctx->Array.EdgeFlag.Stride); 997 break; 998 case GL_EDGE_FLAG_ARRAY_COUNT_EXT: 999 *params = INT_TO_BOOL(0); 1000 break; 1001 1002 /* GL_ARB_multitexture */ 1003 case GL_MAX_TEXTURE_UNITS_ARB: 1004 CHECK_EXTENSION_B(ARB_multitexture, pname); 1005 *params = INT_TO_BOOL(MIN2(ctx->Const.MaxTextureImageUnits, 1006 ctx->Const.MaxTextureCoordUnits)); 1007 break; 1008 case GL_ACTIVE_TEXTURE_ARB: 1009 CHECK_EXTENSION_B(ARB_multitexture, pname); 1010 *params = INT_TO_BOOL(GL_TEXTURE0_ARB + ctx->Texture.CurrentUnit); 1011 break; 1012 case GL_CLIENT_ACTIVE_TEXTURE_ARB: 1013 CHECK_EXTENSION_B(ARB_multitexture, pname); 1014 *params = INT_TO_BOOL(GL_TEXTURE0_ARB + ctx->Array.ActiveTexture); 1015 break; 1016 1017 /* GL_ARB_texture_cube_map */ 1018 case GL_TEXTURE_CUBE_MAP_ARB: 1019 CHECK_EXTENSION_B(ARB_texture_cube_map, pname); 1020 *params = _mesa_IsEnabled(GL_TEXTURE_CUBE_MAP_ARB); 1021 break; 1022 case GL_TEXTURE_BINDING_CUBE_MAP_ARB: 1023 CHECK_EXTENSION_B(ARB_texture_cube_map, pname); 1024 *params = INT_TO_BOOL(textureUnit->CurrentCubeMap->Name); 1025 break; 1026 case GL_MAX_CUBE_MAP_TEXTURE_SIZE_ARB: 1027 CHECK_EXTENSION_B(ARB_texture_cube_map, pname); 1028 *params = INT_TO_BOOL(1 << (ctx->Const.MaxCubeTextureLevels - 1)); 1029 break; 1030 1031 /* GL_ARB_texture_compression */ 1032 case GL_TEXTURE_COMPRESSION_HINT_ARB: 1033 CHECK_EXTENSION_B(ARB_texture_compression, pname); 1034 *params = INT_TO_BOOL(ctx->Hint.TextureCompression); 1035 break; 1036 case GL_NUM_COMPRESSED_TEXTURE_FORMATS_ARB: 1037 CHECK_EXTENSION_B(ARB_texture_compression, pname); 1038 *params = INT_TO_BOOL(_mesa_get_compressed_formats(ctx, NULL)); 1039 break; 1040 case GL_COMPRESSED_TEXTURE_FORMATS_ARB: 1041 CHECK_EXTENSION_B(ARB_texture_compression, pname); 1042 { 1043 GLint formats[100]; 1044 GLuint i, n; 1045 n = _mesa_get_compressed_formats(ctx, formats); 1046 for (i = 0; i < n; i++) 1047 params[i] = INT_TO_BOOL(formats[i]); 1048 } 1049 break; 1050 1051 /* GL_EXT_compiled_vertex_array */ 1052 case GL_ARRAY_ELEMENT_LOCK_FIRST_EXT: 1053 *params = ctx->Array.LockFirst ? GL_TRUE : GL_FALSE; 1054 break; 1055 case GL_ARRAY_ELEMENT_LOCK_COUNT_EXT: 1056 *params = ctx->Array.LockCount ? GL_TRUE : GL_FALSE; 1057 break; 1058 1059 /* GL_ARB_transpose_matrix */ 1060 case GL_TRANSPOSE_COLOR_MATRIX_ARB: 1061 { 1062 GLfloat tm[16]; 1063 GLuint i; 1064 _math_transposef(tm, ctx->ColorMatrixStack.Top->m); 1065 for (i=0;i<16;i++) { 1066 params[i] = FLOAT_TO_BOOL(tm[i]); 1067 } 1068 } 1069 break; 1070 case GL_TRANSPOSE_MODELVIEW_MATRIX_ARB: 1071 { 1072 GLfloat tm[16]; 1073 GLuint i; 1074 _math_transposef(tm, ctx->ModelviewMatrixStack.Top->m); 1075 for (i=0;i<16;i++) { 1076 params[i] = FLOAT_TO_BOOL(tm[i]); 1077 } 1078 } 1079 break; 1080 case GL_TRANSPOSE_PROJECTION_MATRIX_ARB: 1081 { 1082 GLfloat tm[16]; 1083 GLuint i; 1084 _math_transposef(tm, ctx->ProjectionMatrixStack.Top->m); 1085 for (i=0;i<16;i++) { 1086 params[i] = FLOAT_TO_BOOL(tm[i]); 1087 } 1088 } 1089 break; 1090 case GL_TRANSPOSE_TEXTURE_MATRIX_ARB: 1091 { 1092 GLfloat tm[16]; 1093 GLuint i; 1094 _math_transposef(tm, ctx->TextureMatrixStack[texUnit].Top->m); 1095 for (i=0;i<16;i++) { 1096 params[i] = FLOAT_TO_BOOL(tm[i]); 1097 } 1098 } 1099 break; 1100 1101 /* GL_HP_occlusion_test */ 1102 case GL_OCCLUSION_TEST_HP: 1103 CHECK_EXTENSION_B(HP_occlusion_test, pname); 1104 *params = ctx->Depth.OcclusionTest; 1105 return; 1106 case GL_OCCLUSION_TEST_RESULT_HP: 1107 CHECK_EXTENSION_B(HP_occlusion_test, pname); 1108 if (ctx->Depth.OcclusionTest) 1109 *params = ctx->OcclusionResult; 1110 else 1111 *params = ctx->OcclusionResultSaved; 1112 /* reset flag now */ 1113 ctx->OcclusionResult = GL_FALSE; 1114 ctx->OcclusionResultSaved = GL_FALSE; 1115 return; 1116 1117 /* GL_SGIS_pixel_texture */ 1118 case GL_PIXEL_TEXTURE_SGIS: 1119 *params = ctx->Pixel.PixelTextureEnabled; 1120 break; 1121 1122 /* GL_SGIX_pixel_texture */ 1123 case GL_PIXEL_TEX_GEN_SGIX: 1124 *params = ctx->Pixel.PixelTextureEnabled; 1125 break; 1126 case GL_PIXEL_TEX_GEN_MODE_SGIX: 1127 *params = (GLboolean) pixel_texgen_mode(ctx); 1128 break; 1129 1130 /* GL_SGI_color_matrix (also in 1.2 imaging) */ 1131 case GL_COLOR_MATRIX_SGI: 1132 for (i=0;i<16;i++) { 1133 params[i] = FLOAT_TO_BOOL(ctx->ColorMatrixStack.Top->m[i]); 1134 } 1135 break; 1136 case GL_COLOR_MATRIX_STACK_DEPTH_SGI: 1137 *params = INT_TO_BOOL(ctx->ColorMatrixStack.Depth + 1); 1138 break; 1139 case GL_MAX_COLOR_MATRIX_STACK_DEPTH_SGI: 1140 *params = FLOAT_TO_BOOL(MAX_COLOR_STACK_DEPTH); 1141 break; 1142 case GL_POST_COLOR_MATRIX_RED_SCALE_SGI: 1143 *params = FLOAT_TO_BOOL(ctx->Pixel.PostColorMatrixScale[0]); 1144 break; 1145 case GL_POST_COLOR_MATRIX_GREEN_SCALE_SGI: 1146 *params = FLOAT_TO_BOOL(ctx->Pixel.PostColorMatrixScale[1]); 1147 break; 1148 case GL_POST_COLOR_MATRIX_BLUE_SCALE_SGI: 1149 *params = FLOAT_TO_BOOL(ctx->Pixel.PostColorMatrixScale[2]); 1150 break; 1151 case GL_POST_COLOR_MATRIX_ALPHA_SCALE_SGI: 1152 *params = FLOAT_TO_BOOL(ctx->Pixel.PostColorMatrixScale[3]); 1153 break; 1154 case GL_POST_COLOR_MATRIX_RED_BIAS_SGI: 1155 *params = FLOAT_TO_BOOL(ctx->Pixel.PostColorMatrixBias[0]); 1156 break; 1157 case GL_POST_COLOR_MATRIX_GREEN_BIAS_SGI: 1158 *params = FLOAT_TO_BOOL(ctx->Pixel.PostColorMatrixBias[1]); 1159 break; 1160 case GL_POST_COLOR_MATRIX_BLUE_BIAS_SGI: 1161 *params = FLOAT_TO_BOOL(ctx->Pixel.PostColorMatrixBias[2]); 1162 break; 1163 case GL_POST_COLOR_MATRIX_ALPHA_BIAS_SGI: 1164 *params = FLOAT_TO_BOOL(ctx->Pixel.PostColorMatrixBias[3]); 1165 break; 1166 1167 /* GL_EXT_convolution (also in 1.2 imaging) */ 1168 case GL_CONVOLUTION_1D_EXT: 1169 CHECK_EXTENSION_B(EXT_convolution, pname); 1170 *params = ctx->Pixel.Convolution1DEnabled; 1171 break; 1172 case GL_CONVOLUTION_2D: 1173 CHECK_EXTENSION_B(EXT_convolution, pname); 1174 *params = ctx->Pixel.Convolution2DEnabled; 1175 break; 1176 case GL_SEPARABLE_2D: 1177 CHECK_EXTENSION_B(EXT_convolution, pname); 1178 *params = ctx->Pixel.Separable2DEnabled; 1179 break; 1180 case GL_POST_CONVOLUTION_RED_SCALE_EXT: 1181 CHECK_EXTENSION_B(EXT_convolution, pname); 1182 *params = FLOAT_TO_BOOL(ctx->Pixel.PostConvolutionScale[0]); 1183 break; 1184 case GL_POST_CONVOLUTION_GREEN_SCALE_EXT: 1185 CHECK_EXTENSION_B(EXT_convolution, pname); 1186 *params = FLOAT_TO_BOOL(ctx->Pixel.PostConvolutionScale[1]); 1187 break; 1188 case GL_POST_CONVOLUTION_BLUE_SCALE_EXT: 1189 CHECK_EXTENSION_B(EXT_convolution, pname); 1190 *params = FLOAT_TO_BOOL(ctx->Pixel.PostConvolutionScale[2]); 1191 break; 1192 case GL_POST_CONVOLUTION_ALPHA_SCALE_EXT: 1193 CHECK_EXTENSION_B(EXT_convolution, pname); 1194 *params = FLOAT_TO_BOOL(ctx->Pixel.PostConvolutionScale[3]); 1195 break; 1196 case GL_POST_CONVOLUTION_RED_BIAS_EXT: 1197 CHECK_EXTENSION_B(EXT_convolution, pname); 1198 *params = FLOAT_TO_BOOL(ctx->Pixel.PostConvolutionBias[0]); 1199 break; 1200 case GL_POST_CONVOLUTION_GREEN_BIAS_EXT: 1201 CHECK_EXTENSION_B(EXT_convolution, pname); 1202 *params = FLOAT_TO_BOOL(ctx->Pixel.PostConvolutionBias[1]); 1203 break; 1204 case GL_POST_CONVOLUTION_BLUE_BIAS_EXT: 1205 CHECK_EXTENSION_B(EXT_convolution, pname); 1206 *params = FLOAT_TO_BOOL(ctx->Pixel.PostConvolutionBias[2]); 1207 break; 1208 case GL_POST_CONVOLUTION_ALPHA_BIAS_EXT: 1209 CHECK_EXTENSION_B(EXT_convolution, pname); 1210 *params = FLOAT_TO_BOOL(ctx->Pixel.PostConvolutionBias[2]); 1211 break; 1212 1213 /* GL_EXT_histogram (also in 1.2 imaging) */ 1214 case GL_HISTOGRAM: 1215 CHECK_EXTENSION_B(EXT_histogram, pname); 1216 *params = ctx->Pixel.HistogramEnabled; 1217 break; 1218 case GL_MINMAX: 1219 CHECK_EXTENSION_B(EXT_histogram, pname); 1220 *params = ctx->Pixel.MinMaxEnabled; 1221 break; 1222 1223 /* GL_SGI_color_table (also in 1.2 imaging */ 1224 case GL_COLOR_TABLE_SGI: 1225 *params = ctx->Pixel.ColorTableEnabled; 1226 break; 1227 case GL_POST_CONVOLUTION_COLOR_TABLE_SGI: 1228 *params = ctx->Pixel.PostConvolutionColorTableEnabled; 1229 break; 1230 case GL_POST_COLOR_MATRIX_COLOR_TABLE_SGI: 1231 *params = ctx->Pixel.PostColorMatrixColorTableEnabled; 1232 break; 1233 1234 /* GL_SGI_texture_color_table */ 1235 case GL_TEXTURE_COLOR_TABLE_SGI: 1236 CHECK_EXTENSION_B(SGI_texture_color_table, pname); 1237 *params = textureUnit->ColorTableEnabled; 1238 break; 1239 1240 /* GL_EXT_secondary_color */ 1241 case GL_COLOR_SUM_EXT: 1242 CHECK_EXTENSION_B(EXT_secondary_color, pname); 1243 *params = ctx->Fog.ColorSumEnabled; 1244 break; 1245 case GL_CURRENT_SECONDARY_COLOR_EXT: 1246 CHECK_EXTENSION_B(EXT_secondary_color, pname); 1247 FLUSH_CURRENT(ctx, 0); 1248 params[0] = INT_TO_BOOL(ctx->Current.Attrib[VERT_ATTRIB_COLOR1][0]); 1249 params[1] = INT_TO_BOOL(ctx->Current.Attrib[VERT_ATTRIB_COLOR1][1]); 1250 params[2] = INT_TO_BOOL(ctx->Current.Attrib[VERT_ATTRIB_COLOR1][2]); 1251 params[3] = INT_TO_BOOL(ctx->Current.Attrib[VERT_ATTRIB_COLOR1][3]); 1252 break; 1253 case GL_SECONDARY_COLOR_ARRAY_EXT: 1254 CHECK_EXTENSION_B(EXT_secondary_color, pname); 1255 *params = ctx->Array.SecondaryColor.Enabled; 1256 break; 1257 case GL_SECONDARY_COLOR_ARRAY_TYPE_EXT: 1258 CHECK_EXTENSION_B(EXT_secondary_color, pname); 1259 *params = ENUM_TO_BOOL(ctx->Array.SecondaryColor.Type); 1260 break; 1261 case GL_SECONDARY_COLOR_ARRAY_STRIDE_EXT: 1262 CHECK_EXTENSION_B(EXT_secondary_color, pname); 1263 *params = INT_TO_BOOL(ctx->Array.SecondaryColor.Stride); 1264 break; 1265 case GL_SECONDARY_COLOR_ARRAY_SIZE_EXT: 1266 CHECK_EXTENSION_B(EXT_secondary_color, pname); 1267 *params = INT_TO_BOOL(ctx->Array.SecondaryColor.Size); 1268 break; 1269 1270 /* GL_EXT_fog_coord */ 1271 case GL_CURRENT_FOG_COORDINATE_EXT: 1272 CHECK_EXTENSION_B(EXT_fog_coord, pname); 1273 FLUSH_CURRENT(ctx, 0); 1274 *params = FLOAT_TO_BOOL(ctx->Current.Attrib[VERT_ATTRIB_FOG][0]); 1275 break; 1276 case GL_FOG_COORDINATE_ARRAY_EXT: 1277 CHECK_EXTENSION_B(EXT_fog_coord, pname); 1278 *params = ctx->Array.FogCoord.Enabled; 1279 break; 1280 case GL_FOG_COORDINATE_ARRAY_TYPE_EXT: 1281 CHECK_EXTENSION_B(EXT_fog_coord, pname); 1282 *params = ENUM_TO_BOOL(ctx->Array.FogCoord.Type); 1283 break; 1284 case GL_FOG_COORDINATE_ARRAY_STRIDE_EXT: 1285 CHECK_EXTENSION_B(EXT_fog_coord, pname); 1286 *params = INT_TO_BOOL(ctx->Array.FogCoord.Stride); 1287 break; 1288 case GL_FOG_COORDINATE_SOURCE_EXT: 1289 CHECK_EXTENSION_B(EXT_fog_coord, pname); 1290 *params = ENUM_TO_BOOL(ctx->Fog.FogCoordinateSource); 1291 break; 1292 1293 /* GL_EXT_texture_lod_bias */ 1294 case GL_MAX_TEXTURE_LOD_BIAS_EXT: 1295 *params = FLOAT_TO_BOOL(ctx->Const.MaxTextureLodBias); 1296 break; 1297 1298 /* GL_EXT_texture_filter_anisotropic */ 1299 case GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT: 1300 CHECK_EXTENSION_B(EXT_texture_filter_anisotropic, pname); 1301 *params = FLOAT_TO_BOOL(ctx->Const.MaxTextureMaxAnisotropy); 1302 break; 1303 1304 /* GL_ARB_multisample */ 1305 case GL_MULTISAMPLE_ARB: 1306 CHECK_EXTENSION_B(ARB_multisample, pname); 1307 *params = ctx->Multisample.Enabled; 1308 break; 1309 case GL_SAMPLE_ALPHA_TO_COVERAGE_ARB: 1310 CHECK_EXTENSION_B(ARB_multisample, pname); 1311 *params = ctx->Multisample.SampleAlphaToCoverage; 1312 break; 1313 case GL_SAMPLE_ALPHA_TO_ONE_ARB: 1314 CHECK_EXTENSION_B(ARB_multisample, pname); 1315 *params = ctx->Multisample.SampleAlphaToOne; 1316 break; 1317 case GL_SAMPLE_COVERAGE_ARB: 1318 CHECK_EXTENSION_B(ARB_multisample, pname); 1319 *params = ctx->Multisample.SampleCoverage; 1320 break; 1321 case GL_SAMPLE_COVERAGE_VALUE_ARB: 1322 CHECK_EXTENSION_B(ARB_multisample, pname); 1323 *params = FLOAT_TO_BOOL(ctx->Multisample.SampleCoverageValue); 1324 break; 1325 case GL_SAMPLE_COVERAGE_INVERT_ARB: 1326 CHECK_EXTENSION_B(ARB_multisample, pname); 1327 *params = ctx->Multisample.SampleCoverageInvert; 1328 break; 1329 case GL_SAMPLE_BUFFERS_ARB: 1330 CHECK_EXTENSION_B(ARB_multisample, pname); 1331 *params = 0; /* XXX fix someday */ 1332 break; 1333 case GL_SAMPLES_ARB: 1334 CHECK_EXTENSION_B(ARB_multisample, pname); 1335 *params = 0; /* XXX fix someday */ 1336 break; 1337 1338 /* GL_IBM_rasterpos_clip */ 1339 case GL_RASTER_POSITION_UNCLIPPED_IBM: 1340 CHECK_EXTENSION_B(IBM_rasterpos_clip, pname); 1341 *params = ctx->Transform.RasterPositionUnclipped; 1342 break; 1343 1344 /* GL_NV_point_sprite */ 1345 case GL_POINT_SPRITE_NV: 1346 CHECK_EXTENSION_B(NV_point_sprite, pname); 1347 *params = ctx->Point.PointSprite; 1348 break; 1349 case GL_POINT_SPRITE_R_MODE_NV: 1350 CHECK_EXTENSION_B(NV_point_sprite, pname); 1351 *params = ENUM_TO_BOOL(ctx->Point.SpriteRMode); 1352 break; 1353 1354 /* GL_SGIS_generate_mipmap */ 1355 case GL_GENERATE_MIPMAP_HINT_SGIS: 1356 CHECK_EXTENSION_B(SGIS_generate_mipmap, pname); 1357 *params = ENUM_TO_BOOL(ctx->Hint.GenerateMipmap); 1358 break; 1359 1360#if FEATURE_NV_vertex_program 1361 case GL_VERTEX_PROGRAM_NV: 1362 CHECK_EXTENSION_B(NV_vertex_program, pname); 1363 *params = ctx->VertexProgram.Enabled; 1364 break; 1365 case GL_VERTEX_PROGRAM_POINT_SIZE_NV: 1366 CHECK_EXTENSION_B(NV_vertex_program, pname); 1367 *params = ctx->VertexProgram.PointSizeEnabled; 1368 break; 1369 case GL_VERTEX_PROGRAM_TWO_SIDE_NV: 1370 CHECK_EXTENSION_B(NV_vertex_program, pname); 1371 *params = ctx->VertexProgram.TwoSideEnabled; 1372 break; 1373 case GL_MAX_TRACK_MATRIX_STACK_DEPTH_NV: 1374 CHECK_EXTENSION_B(NV_vertex_program, pname); 1375 *params = (ctx->Const.MaxProgramMatrixStackDepth > 0) ? GL_TRUE : GL_FALSE; 1376 break; 1377 case GL_MAX_TRACK_MATRICES_NV: 1378 CHECK_EXTENSION_B(NV_vertex_program, pname); 1379 *params = (ctx->Const.MaxProgramMatrices > 0) ? GL_TRUE : GL_FALSE; 1380 break; 1381 case GL_CURRENT_MATRIX_STACK_DEPTH_NV: 1382 CHECK_EXTENSION_B(NV_vertex_program, pname); 1383 *params = GL_TRUE; 1384 break; 1385 case GL_CURRENT_MATRIX_NV: 1386 CHECK_EXTENSION_B(NV_vertex_program, pname); 1387 for (i = 0; i < 16; i++) 1388 params[i] = FLOAT_TO_BOOL(ctx->CurrentStack->Top->m[i]); 1389 break; 1390 case GL_VERTEX_PROGRAM_BINDING_NV: 1391 CHECK_EXTENSION_B(NV_vertex_program, pname); 1392 if (ctx->VertexProgram.Current && 1393 ctx->VertexProgram.Current->Base.Id != 0) 1394 *params = GL_TRUE; 1395 else 1396 *params = GL_FALSE; 1397 break; 1398 case GL_PROGRAM_ERROR_POSITION_NV: 1399 CHECK_EXTENSION_B(NV_vertex_program, pname); 1400 *params = (ctx->Program.ErrorPos != 0) ? GL_TRUE : GL_FALSE; 1401 break; 1402 case GL_VERTEX_ATTRIB_ARRAY0_NV: 1403 case GL_VERTEX_ATTRIB_ARRAY1_NV: 1404 case GL_VERTEX_ATTRIB_ARRAY2_NV: 1405 case GL_VERTEX_ATTRIB_ARRAY3_NV: 1406 case GL_VERTEX_ATTRIB_ARRAY4_NV: 1407 case GL_VERTEX_ATTRIB_ARRAY5_NV: 1408 case GL_VERTEX_ATTRIB_ARRAY6_NV: 1409 case GL_VERTEX_ATTRIB_ARRAY7_NV: 1410 case GL_VERTEX_ATTRIB_ARRAY8_NV: 1411 case GL_VERTEX_ATTRIB_ARRAY9_NV: 1412 case GL_VERTEX_ATTRIB_ARRAY10_NV: 1413 case GL_VERTEX_ATTRIB_ARRAY11_NV: 1414 case GL_VERTEX_ATTRIB_ARRAY12_NV: 1415 case GL_VERTEX_ATTRIB_ARRAY13_NV: 1416 case GL_VERTEX_ATTRIB_ARRAY14_NV: 1417 case GL_VERTEX_ATTRIB_ARRAY15_NV: 1418 CHECK_EXTENSION_B(NV_vertex_program, pname); 1419 { 1420 GLuint n = (GLuint) pname - GL_VERTEX_ATTRIB_ARRAY0_NV; 1421 *params = ctx->Array.VertexAttrib[n].Enabled; 1422 } 1423 break; 1424 case GL_MAP1_VERTEX_ATTRIB0_4_NV: 1425 case GL_MAP1_VERTEX_ATTRIB1_4_NV: 1426 case GL_MAP1_VERTEX_ATTRIB2_4_NV: 1427 case GL_MAP1_VERTEX_ATTRIB3_4_NV: 1428 case GL_MAP1_VERTEX_ATTRIB4_4_NV: 1429 case GL_MAP1_VERTEX_ATTRIB5_4_NV: 1430 case GL_MAP1_VERTEX_ATTRIB6_4_NV: 1431 case GL_MAP1_VERTEX_ATTRIB7_4_NV: 1432 case GL_MAP1_VERTEX_ATTRIB8_4_NV: 1433 case GL_MAP1_VERTEX_ATTRIB9_4_NV: 1434 case GL_MAP1_VERTEX_ATTRIB10_4_NV: 1435 case GL_MAP1_VERTEX_ATTRIB11_4_NV: 1436 case GL_MAP1_VERTEX_ATTRIB12_4_NV: 1437 case GL_MAP1_VERTEX_ATTRIB13_4_NV: 1438 case GL_MAP1_VERTEX_ATTRIB14_4_NV: 1439 case GL_MAP1_VERTEX_ATTRIB15_4_NV: 1440 CHECK_EXTENSION_B(NV_vertex_program, pname); 1441 { 1442 GLuint n = (GLuint) pname - GL_MAP1_VERTEX_ATTRIB0_4_NV; 1443 *params = ctx->Eval.Map1Attrib[n]; 1444 } 1445 break; 1446 case GL_MAP2_VERTEX_ATTRIB0_4_NV: 1447 case GL_MAP2_VERTEX_ATTRIB1_4_NV: 1448 case GL_MAP2_VERTEX_ATTRIB2_4_NV: 1449 case GL_MAP2_VERTEX_ATTRIB3_4_NV: 1450 case GL_MAP2_VERTEX_ATTRIB4_4_NV: 1451 case GL_MAP2_VERTEX_ATTRIB5_4_NV: 1452 case GL_MAP2_VERTEX_ATTRIB6_4_NV: 1453 case GL_MAP2_VERTEX_ATTRIB7_4_NV: 1454 case GL_MAP2_VERTEX_ATTRIB8_4_NV: 1455 case GL_MAP2_VERTEX_ATTRIB9_4_NV: 1456 case GL_MAP2_VERTEX_ATTRIB10_4_NV: 1457 case GL_MAP2_VERTEX_ATTRIB11_4_NV: 1458 case GL_MAP2_VERTEX_ATTRIB12_4_NV: 1459 case GL_MAP2_VERTEX_ATTRIB13_4_NV: 1460 case GL_MAP2_VERTEX_ATTRIB14_4_NV: 1461 case GL_MAP2_VERTEX_ATTRIB15_4_NV: 1462 CHECK_EXTENSION_B(NV_vertex_program, pname); 1463 { 1464 GLuint n = (GLuint) pname - GL_MAP2_VERTEX_ATTRIB0_4_NV; 1465 *params = ctx->Eval.Map2Attrib[n]; 1466 } 1467 break; 1468#endif /* FEATURE_NV_vertex_program */ 1469 1470#if FEATURE_NV_fragment_program 1471 case GL_FRAGMENT_PROGRAM_NV: 1472 CHECK_EXTENSION_B(NV_fragment_program, pname); 1473 *params = ctx->FragmentProgram.Enabled; 1474 break; 1475 case GL_MAX_TEXTURE_COORDS_NV: 1476 CHECK_EXTENSION_B(NV_fragment_program, pname); 1477 *params = INT_TO_BOOL(ctx->Const.MaxTextureCoordUnits); 1478 break; 1479 case GL_MAX_TEXTURE_IMAGE_UNITS_NV: 1480 CHECK_EXTENSION_B(NV_fragment_program, pname); 1481 *params = INT_TO_BOOL(ctx->Const.MaxTextureImageUnits); 1482 break; 1483 case GL_FRAGMENT_PROGRAM_BINDING_NV: 1484 CHECK_EXTENSION_B(NV_fragment_program, pname); 1485 if (ctx->VertexProgram.Current && 1486 ctx->VertexProgram.Current->Base.Id != 0) 1487 *params = GL_TRUE; 1488 else 1489 *params = GL_FALSE; 1490 break; 1491 case GL_MAX_FRAGMENT_PROGRAM_LOCAL_PARAMETERS_NV: 1492 CHECK_EXTENSION_B(NV_fragment_program, pname); 1493 *params = MAX_NV_FRAGMENT_PROGRAM_PARAMS ? GL_TRUE : GL_FALSE; 1494 break; 1495#endif /* FEATURE_NV_fragment_program */ 1496 1497 /* GL_NV_texture_rectangle */ 1498 case GL_TEXTURE_RECTANGLE_NV: 1499 CHECK_EXTENSION_B(NV_texture_rectangle, pname); 1500 *params = _mesa_IsEnabled(GL_TEXTURE_RECTANGLE_NV); 1501 break; 1502 case GL_TEXTURE_BINDING_RECTANGLE_NV: 1503 CHECK_EXTENSION_B(NV_texture_rectangle, pname); 1504 *params = INT_TO_BOOL(textureUnit->CurrentRect->Name); 1505 break; 1506 case GL_MAX_RECTANGLE_TEXTURE_SIZE_NV: 1507 CHECK_EXTENSION_B(NV_texture_rectangle, pname); 1508 *params = INT_TO_BOOL(ctx->Const.MaxTextureRectSize); 1509 break; 1510 1511 /* GL_EXT_stencil_two_side */ 1512 case GL_STENCIL_TEST_TWO_SIDE_EXT: 1513 CHECK_EXTENSION_B(EXT_stencil_two_side, pname); 1514 *params = ctx->Stencil.TestTwoSide; 1515 break; 1516 case GL_ACTIVE_STENCIL_FACE_EXT: 1517 CHECK_EXTENSION_B(EXT_stencil_two_side, pname); 1518 *params = ENUM_TO_BOOL(ctx->Stencil.ActiveFace ? GL_BACK : GL_FRONT); 1519 break; 1520 1521 /* GL_NV_light_max_exponent */ 1522 case GL_MAX_SHININESS_NV: 1523 *params = FLOAT_TO_BOOL(ctx->Const.MaxShininess); 1524 break; 1525 case GL_MAX_SPOT_EXPONENT_NV: 1526 *params = FLOAT_TO_BOOL(ctx->Const.MaxSpotExponent); 1527 break; 1528 1529#if FEATURE_ARB_vertex_buffer_object 1530 case GL_ARRAY_BUFFER_BINDING_ARB: 1531 CHECK_EXTENSION_B(ARB_vertex_buffer_object, pname); 1532 *params = INT_TO_BOOL(ctx->Array.ArrayBufferBinding); 1533 break; 1534 case GL_VERTEX_ARRAY_BUFFER_BINDING_ARB: 1535 CHECK_EXTENSION_B(ARB_vertex_buffer_object, pname); 1536 *params = INT_TO_BOOL(ctx->Array.VertexArrayBufferBinding); 1537 break; 1538 case GL_NORMAL_ARRAY_BUFFER_BINDING_ARB: 1539 CHECK_EXTENSION_B(ARB_vertex_buffer_object, pname); 1540 *params = INT_TO_BOOL(ctx->Array.NormalArrayBufferBinding); 1541 break; 1542 case GL_COLOR_ARRAY_BUFFER_BINDING_ARB: 1543 CHECK_EXTENSION_B(ARB_vertex_buffer_object, pname); 1544 *params = INT_TO_BOOL(ctx->Array.ColorArrayBufferBinding); 1545 break; 1546 case GL_INDEX_ARRAY_BUFFER_BINDING_ARB: 1547 CHECK_EXTENSION_B(ARB_vertex_buffer_object, pname); 1548 *params = INT_TO_BOOL(ctx->Array.IndexArrayBufferBinding); 1549 break; 1550 case GL_TEXTURE_COORD_ARRAY_BUFFER_BINDING_ARB: 1551 CHECK_EXTENSION_B(ARB_vertex_buffer_object, pname); 1552 *params = INT_TO_BOOL(ctx->Array.TextureArrayBufferBinding); 1553 break; 1554 case GL_EDGE_FLAG_ARRAY_BUFFER_BINDING_ARB: 1555 CHECK_EXTENSION_B(ARB_vertex_buffer_object, pname); 1556 *params = INT_TO_BOOL(ctx->Array.EdgeFlagArrayBufferBinding); 1557 break; 1558 case GL_SECONDARY_COLOR_ARRAY_BUFFER_BINDING_ARB: 1559 CHECK_EXTENSION_B(ARB_vertex_buffer_object, pname); 1560 *params = INT_TO_BOOL(ctx->Array.SecondaryColorArrayBufferBinding); 1561 break; 1562 case GL_FOG_COORDINATE_ARRAY_BUFFER_BINDING_ARB: 1563 CHECK_EXTENSION_B(ARB_vertex_buffer_object, pname); 1564 *params = INT_TO_BOOL(ctx->Array.FogCoordArrayBufferBinding); 1565 break; 1566 case GL_WEIGHT_ARRAY_BUFFER_BINDING_ARB: 1567 CHECK_EXTENSION_B(ARB_vertex_buffer_object, pname); 1568 *params = INT_TO_BOOL(ctx->Array.WeightArrayBufferBinding); 1569 break; 1570 case GL_ELEMENT_ARRAY_BUFFER_BINDING_ARB: 1571 CHECK_EXTENSION_B(ARB_vertex_buffer_object, pname); 1572 *params = INT_TO_BOOL(ctx->Array.ElementArrayBufferBinding); 1573 break; 1574#endif 1575 1576#if FEATURE_ARB_fragment_program 1577 case GL_FRAGMENT_PROGRAM_ARB: 1578 CHECK_EXTENSION_B(ARB_fragment_program, pname); 1579 *params = ctx->FragmentProgram.Enabled; 1580 break; 1581 case GL_TRANSPOSE_CURRENT_MATRIX_ARB: 1582 CHECK_EXTENSION_B(ARB_fragment_program, pname); 1583 params[0] = FLOAT_TO_BOOL(ctx->CurrentStack->Top->m[0]); 1584 params[1] = FLOAT_TO_BOOL(ctx->CurrentStack->Top->m[4]); 1585 params[2] = FLOAT_TO_BOOL(ctx->CurrentStack->Top->m[8]); 1586 params[3] = FLOAT_TO_BOOL(ctx->CurrentStack->Top->m[12]); 1587 params[4] = FLOAT_TO_BOOL(ctx->CurrentStack->Top->m[1]); 1588 params[5] = FLOAT_TO_BOOL(ctx->CurrentStack->Top->m[5]); 1589 params[6] = FLOAT_TO_BOOL(ctx->CurrentStack->Top->m[9]); 1590 params[7] = FLOAT_TO_BOOL(ctx->CurrentStack->Top->m[13]); 1591 params[8] = FLOAT_TO_BOOL(ctx->CurrentStack->Top->m[2]); 1592 params[9] = FLOAT_TO_BOOL(ctx->CurrentStack->Top->m[6]); 1593 params[10] = FLOAT_TO_BOOL(ctx->CurrentStack->Top->m[10]); 1594 params[11] = FLOAT_TO_BOOL(ctx->CurrentStack->Top->m[14]); 1595 params[12] = FLOAT_TO_BOOL(ctx->CurrentStack->Top->m[3]); 1596 params[13] = FLOAT_TO_BOOL(ctx->CurrentStack->Top->m[7]); 1597 params[14] = FLOAT_TO_BOOL(ctx->CurrentStack->Top->m[11]); 1598 params[15] = FLOAT_TO_BOOL(ctx->CurrentStack->Top->m[15]); 1599 break; 1600 /* Remaining ARB_fragment_program queries alias with 1601 * the GL_NV_fragment_program queries. 1602 */ 1603#endif 1604 1605 /* GL_EXT_depth_bounds_test */ 1606 case GL_DEPTH_BOUNDS_TEST_EXT: 1607 CHECK_EXTENSION_B(EXT_depth_bounds_test, pname); 1608 params[0] = ctx->Depth.BoundsTest; 1609 break; 1610 case GL_DEPTH_BOUNDS_EXT: 1611 CHECK_EXTENSION_B(EXT_depth_bounds_test, pname); 1612 params[0] = FLOAT_TO_BOOL(ctx->Depth.BoundsMin); 1613 params[1] = FLOAT_TO_BOOL(ctx->Depth.BoundsMax); 1614 break; 1615 1616 default: 1617 _mesa_error(ctx, GL_INVALID_ENUM, "glGetBooleanv(pname=0x%x)", pname); 1618 } 1619} 1620 1621 1622void 1623_mesa_GetDoublev( GLenum pname, GLdouble *params ) 1624{ 1625 GET_CURRENT_CONTEXT(ctx); 1626 GLuint i; 1627 GLuint texUnit = ctx->Texture.CurrentUnit; 1628 const struct gl_texture_unit *textureUnit = &ctx->Texture.Unit[texUnit]; 1629 ASSERT_OUTSIDE_BEGIN_END(ctx); 1630 1631 if (!params) 1632 return; 1633 1634 /* We need this in order to get correct results for 1635 * GL_OCCLUSION_TEST_RESULT_HP. There might be other important cases. 1636 */ 1637 FLUSH_VERTICES(ctx, 0); 1638 1639 if (MESA_VERBOSE & VERBOSE_API) 1640 _mesa_debug(ctx, "glGetDoublev %s\n", _mesa_lookup_enum_by_nr(pname)); 1641 1642 if (ctx->Driver.GetDoublev && (*ctx->Driver.GetDoublev)(ctx, pname, params)) 1643 return; 1644 1645 switch (pname) { 1646 case GL_ACCUM_RED_BITS: 1647 *params = (GLdouble) ctx->Visual.accumRedBits; 1648 break; 1649 case GL_ACCUM_GREEN_BITS: 1650 *params = (GLdouble) ctx->Visual.accumGreenBits; 1651 break; 1652 case GL_ACCUM_BLUE_BITS: 1653 *params = (GLdouble) ctx->Visual.accumBlueBits; 1654 break; 1655 case GL_ACCUM_ALPHA_BITS: 1656 *params = (GLdouble) ctx->Visual.accumAlphaBits; 1657 break; 1658 case GL_ACCUM_CLEAR_VALUE: 1659 params[0] = (GLdouble) ctx->Accum.ClearColor[0]; 1660 params[1] = (GLdouble) ctx->Accum.ClearColor[1]; 1661 params[2] = (GLdouble) ctx->Accum.ClearColor[2]; 1662 params[3] = (GLdouble) ctx->Accum.ClearColor[3]; 1663 break; 1664 case GL_ALPHA_BIAS: 1665 *params = (GLdouble) ctx->Pixel.AlphaBias; 1666 break; 1667 case GL_ALPHA_BITS: 1668 *params = (GLdouble) ctx->Visual.alphaBits; 1669 break; 1670 case GL_ALPHA_SCALE: 1671 *params = (GLdouble) ctx->Pixel.AlphaScale; 1672 break; 1673 case GL_ALPHA_TEST: 1674 *params = (GLdouble) ctx->Color.AlphaEnabled; 1675 break; 1676 case GL_ALPHA_TEST_FUNC: 1677 *params = ENUM_TO_DOUBLE(ctx->Color.AlphaFunc); 1678 break; 1679 case GL_ALPHA_TEST_REF: 1680 *params = (GLdouble) ctx->Color.AlphaRef; 1681 break; 1682 case GL_ATTRIB_STACK_DEPTH: 1683 *params = (GLdouble ) (ctx->AttribStackDepth); 1684 break; 1685 case GL_AUTO_NORMAL: 1686 *params = (GLdouble) ctx->Eval.AutoNormal; 1687 break; 1688 case GL_AUX_BUFFERS: 1689 *params = (GLdouble) ctx->Const.NumAuxBuffers; 1690 break; 1691 case GL_BLEND: 1692 *params = (GLdouble) ctx->Color.BlendEnabled; 1693 break; 1694 case GL_BLEND_DST: 1695 *params = ENUM_TO_DOUBLE(ctx->Color.BlendDstRGB); 1696 break; 1697 case GL_BLEND_SRC: 1698 *params = ENUM_TO_DOUBLE(ctx->Color.BlendSrcRGB); 1699 break; 1700 case GL_BLEND_SRC_RGB_EXT: 1701 *params = ENUM_TO_DOUBLE(ctx->Color.BlendSrcRGB); 1702 break; 1703 case GL_BLEND_DST_RGB_EXT: 1704 *params = ENUM_TO_DOUBLE(ctx->Color.BlendDstRGB); 1705 break; 1706 case GL_BLEND_SRC_ALPHA_EXT: 1707 *params = ENUM_TO_DOUBLE(ctx->Color.BlendSrcA); 1708 break; 1709 case GL_BLEND_DST_ALPHA_EXT: 1710 *params = ENUM_TO_DOUBLE(ctx->Color.BlendDstA); 1711 break; 1712 case GL_BLEND_EQUATION_EXT: 1713 *params = ENUM_TO_DOUBLE(ctx->Color.BlendEquation); 1714 break; 1715 case GL_BLEND_COLOR_EXT: 1716 params[0] = (GLdouble) ctx->Color.BlendColor[0]; 1717 params[1] = (GLdouble) ctx->Color.BlendColor[1]; 1718 params[2] = (GLdouble) ctx->Color.BlendColor[2]; 1719 params[3] = (GLdouble) ctx->Color.BlendColor[3]; 1720 break; 1721 case GL_BLUE_BIAS: 1722 *params = (GLdouble) ctx->Pixel.BlueBias; 1723 break; 1724 case GL_BLUE_BITS: 1725 *params = (GLdouble) ctx->Visual.blueBits; 1726 break; 1727 case GL_BLUE_SCALE: 1728 *params = (GLdouble) ctx->Pixel.BlueScale; 1729 break; 1730 case GL_CLIENT_ATTRIB_STACK_DEPTH: 1731 *params = (GLdouble) (ctx->ClientAttribStackDepth); 1732 break; 1733 case GL_CLIP_PLANE0: 1734 case GL_CLIP_PLANE1: 1735 case GL_CLIP_PLANE2: 1736 case GL_CLIP_PLANE3: 1737 case GL_CLIP_PLANE4: 1738 case GL_CLIP_PLANE5: 1739 if (ctx->Transform.ClipPlanesEnabled & (1 << (pname - GL_CLIP_PLANE0))) 1740 *params = 1.0; 1741 else 1742 *params = 0.0; 1743 break; 1744 case GL_COLOR_CLEAR_VALUE: 1745 params[0] = (GLdouble) ctx->Color.ClearColor[0]; 1746 params[1] = (GLdouble) ctx->Color.ClearColor[1]; 1747 params[2] = (GLdouble) ctx->Color.ClearColor[2]; 1748 params[3] = (GLdouble) ctx->Color.ClearColor[3]; 1749 break; 1750 case GL_COLOR_MATERIAL: 1751 *params = (GLdouble) ctx->Light.ColorMaterialEnabled; 1752 break; 1753 case GL_COLOR_MATERIAL_FACE: 1754 *params = ENUM_TO_DOUBLE(ctx->Light.ColorMaterialFace); 1755 break; 1756 case GL_COLOR_MATERIAL_PARAMETER: 1757 *params = ENUM_TO_DOUBLE(ctx->Light.ColorMaterialMode); 1758 break; 1759 case GL_COLOR_WRITEMASK: 1760 params[0] = ctx->Color.ColorMask[RCOMP] ? 1.0 : 0.0; 1761 params[1] = ctx->Color.ColorMask[GCOMP] ? 1.0 : 0.0; 1762 params[2] = ctx->Color.ColorMask[BCOMP] ? 1.0 : 0.0; 1763 params[3] = ctx->Color.ColorMask[ACOMP] ? 1.0 : 0.0; 1764 break; 1765 case GL_CULL_FACE: 1766 *params = (GLdouble) ctx->Polygon.CullFlag; 1767 break; 1768 case GL_CULL_FACE_MODE: 1769 *params = ENUM_TO_DOUBLE(ctx->Polygon.CullFaceMode); 1770 break; 1771 case GL_CURRENT_COLOR: 1772 FLUSH_CURRENT(ctx, 0); 1773 params[0] = ctx->Current.Attrib[VERT_ATTRIB_COLOR0][0]; 1774 params[1] = ctx->Current.Attrib[VERT_ATTRIB_COLOR0][1]; 1775 params[2] = ctx->Current.Attrib[VERT_ATTRIB_COLOR0][2]; 1776 params[3] = ctx->Current.Attrib[VERT_ATTRIB_COLOR0][3]; 1777 break; 1778 case GL_CURRENT_INDEX: 1779 FLUSH_CURRENT(ctx, 0); 1780 *params = (GLdouble) ctx->Current.Index; 1781 break; 1782 case GL_CURRENT_NORMAL: 1783 FLUSH_CURRENT(ctx, 0); 1784 params[0] = (GLdouble) ctx->Current.Attrib[VERT_ATTRIB_NORMAL][0]; 1785 params[1] = (GLdouble) ctx->Current.Attrib[VERT_ATTRIB_NORMAL][1]; 1786 params[2] = (GLdouble) ctx->Current.Attrib[VERT_ATTRIB_NORMAL][2]; 1787 break; 1788 case GL_CURRENT_RASTER_COLOR: 1789 params[0] = (GLdouble) ctx->Current.RasterColor[0]; 1790 params[1] = (GLdouble) ctx->Current.RasterColor[1]; 1791 params[2] = (GLdouble) ctx->Current.RasterColor[2]; 1792 params[3] = (GLdouble) ctx->Current.RasterColor[3]; 1793 break; 1794 case GL_CURRENT_RASTER_DISTANCE: 1795 params[0] = (GLdouble) ctx->Current.RasterDistance; 1796 break; 1797 case GL_CURRENT_RASTER_INDEX: 1798 *params = (GLdouble) ctx->Current.RasterIndex; 1799 break; 1800 case GL_CURRENT_RASTER_POSITION: 1801 params[0] = (GLdouble) ctx->Current.RasterPos[0]; 1802 params[1] = (GLdouble) ctx->Current.RasterPos[1]; 1803 params[2] = (GLdouble) ctx->Current.RasterPos[2]; 1804 params[3] = (GLdouble) ctx->Current.RasterPos[3]; 1805 break; 1806 case GL_CURRENT_RASTER_TEXTURE_COORDS: 1807 params[0] = (GLdouble) ctx->Current.RasterTexCoords[texUnit][0]; 1808 params[1] = (GLdouble) ctx->Current.RasterTexCoords[texUnit][1]; 1809 params[2] = (GLdouble) ctx->Current.RasterTexCoords[texUnit][2]; 1810 params[3] = (GLdouble) ctx->Current.RasterTexCoords[texUnit][3]; 1811 break; 1812 case GL_CURRENT_RASTER_POSITION_VALID: 1813 *params = (GLdouble) ctx->Current.RasterPosValid; 1814 break; 1815 case GL_CURRENT_TEXTURE_COORDS: 1816 FLUSH_CURRENT(ctx, 0); 1817 params[0] = (GLdouble) ctx->Current.Attrib[VERT_ATTRIB_TEX0 + texUnit][0]; 1818 params[1] = (GLdouble) ctx->Current.Attrib[VERT_ATTRIB_TEX0 + texUnit][1]; 1819 params[2] = (GLdouble) ctx->Current.Attrib[VERT_ATTRIB_TEX0 + texUnit][2]; 1820 params[3] = (GLdouble) ctx->Current.Attrib[VERT_ATTRIB_TEX0 + texUnit][3]; 1821 break; 1822 case GL_DEPTH_BIAS: 1823 *params = (GLdouble) ctx->Pixel.DepthBias; 1824 break; 1825 case GL_DEPTH_BITS: 1826 *params = (GLdouble) ctx->Visual.depthBits; 1827 break; 1828 case GL_DEPTH_CLEAR_VALUE: 1829 *params = (GLdouble) ctx->Depth.Clear; 1830 break; 1831 case GL_DEPTH_FUNC: 1832 *params = ENUM_TO_DOUBLE(ctx->Depth.Func); 1833 break; 1834 case GL_DEPTH_RANGE: 1835 params[0] = (GLdouble) ctx->Viewport.Near; 1836 params[1] = (GLdouble) ctx->Viewport.Far; 1837 break; 1838 case GL_DEPTH_SCALE: 1839 *params = (GLdouble) ctx->Pixel.DepthScale; 1840 break; 1841 case GL_DEPTH_TEST: 1842 *params = (GLdouble) ctx->Depth.Test; 1843 break; 1844 case GL_DEPTH_WRITEMASK: 1845 *params = (GLdouble) ctx->Depth.Mask; 1846 break; 1847 case GL_DITHER: 1848 *params = (GLdouble) ctx->Color.DitherFlag; 1849 break; 1850 case GL_DOUBLEBUFFER: 1851 *params = (GLdouble) ctx->Visual.doubleBufferMode; 1852 break; 1853 case GL_DRAW_BUFFER: 1854 *params = ENUM_TO_DOUBLE(ctx->Color.DrawBuffer); 1855 break; 1856 case GL_EDGE_FLAG: 1857 FLUSH_CURRENT(ctx, 0); 1858 *params = (GLdouble) ctx->Current.EdgeFlag; 1859 break; 1860 case GL_FEEDBACK_BUFFER_SIZE: 1861 *params = (GLdouble) ctx->Feedback.BufferSize; 1862 break; 1863 case GL_FEEDBACK_BUFFER_TYPE: 1864 *params = ENUM_TO_DOUBLE(ctx->Feedback.Type); 1865 break; 1866 case GL_FOG: 1867 *params = (GLdouble) ctx->Fog.Enabled; 1868 break; 1869 case GL_FOG_COLOR: 1870 params[0] = (GLdouble) ctx->Fog.Color[0]; 1871 params[1] = (GLdouble) ctx->Fog.Color[1]; 1872 params[2] = (GLdouble) ctx->Fog.Color[2]; 1873 params[3] = (GLdouble) ctx->Fog.Color[3]; 1874 break; 1875 case GL_FOG_DENSITY: 1876 *params = (GLdouble) ctx->Fog.Density; 1877 break; 1878 case GL_FOG_END: 1879 *params = (GLdouble) ctx->Fog.End; 1880 break; 1881 case GL_FOG_HINT: 1882 *params = ENUM_TO_DOUBLE(ctx->Hint.Fog); 1883 break; 1884 case GL_FOG_INDEX: 1885 *params = (GLdouble) ctx->Fog.Index; 1886 break; 1887 case GL_FOG_MODE: 1888 *params = ENUM_TO_DOUBLE(ctx->Fog.Mode); 1889 break; 1890 case GL_FOG_START: 1891 *params = (GLdouble) ctx->Fog.Start; 1892 break; 1893 case GL_FRONT_FACE: 1894 *params = ENUM_TO_DOUBLE(ctx->Polygon.FrontFace); 1895 break; 1896 case GL_GREEN_BIAS: 1897 *params = (GLdouble) ctx->Pixel.GreenBias; 1898 break; 1899 case GL_GREEN_BITS: 1900 *params = (GLdouble) ctx->Visual.greenBits; 1901 break; 1902 case GL_GREEN_SCALE: 1903 *params = (GLdouble) ctx->Pixel.GreenScale; 1904 break; 1905 case GL_INDEX_BITS: 1906 *params = (GLdouble) ctx->Visual.indexBits; 1907 break; 1908 case GL_INDEX_CLEAR_VALUE: 1909 *params = (GLdouble) ctx->Color.ClearIndex; 1910 break; 1911 case GL_INDEX_MODE: 1912 *params = ctx->Visual.rgbMode ? 0.0 : 1.0; 1913 break; 1914 case GL_INDEX_OFFSET: 1915 *params = (GLdouble) ctx->Pixel.IndexOffset; 1916 break; 1917 case GL_INDEX_SHIFT: 1918 *params = (GLdouble) ctx->Pixel.IndexShift; 1919 break; 1920 case GL_INDEX_WRITEMASK: 1921 *params = (GLdouble) ctx->Color.IndexMask; 1922 break; 1923 case GL_LIGHT0: 1924 case GL_LIGHT1: 1925 case GL_LIGHT2: 1926 case GL_LIGHT3: 1927 case GL_LIGHT4: 1928 case GL_LIGHT5: 1929 case GL_LIGHT6: 1930 case GL_LIGHT7: 1931 *params = (GLdouble) ctx->Light.Light[pname-GL_LIGHT0].Enabled; 1932 break; 1933 case GL_LIGHTING: 1934 *params = (GLdouble) ctx->Light.Enabled; 1935 break; 1936 case GL_LIGHT_MODEL_AMBIENT: 1937 params[0] = (GLdouble) ctx->Light.Model.Ambient[0]; 1938 params[1] = (GLdouble) ctx->Light.Model.Ambient[1]; 1939 params[2] = (GLdouble) ctx->Light.Model.Ambient[2]; 1940 params[3] = (GLdouble) ctx->Light.Model.Ambient[3]; 1941 break; 1942 case GL_LIGHT_MODEL_COLOR_CONTROL: 1943 params[0] = (GLdouble) ctx->Light.Model.ColorControl; 1944 break; 1945 case GL_LIGHT_MODEL_LOCAL_VIEWER: 1946 *params = (GLdouble) ctx->Light.Model.LocalViewer; 1947 break; 1948 case GL_LIGHT_MODEL_TWO_SIDE: 1949 *params = (GLdouble) ctx->Light.Model.TwoSide; 1950 break; 1951 case GL_LINE_SMOOTH: 1952 *params = (GLdouble) ctx->Line.SmoothFlag; 1953 break; 1954 case GL_LINE_SMOOTH_HINT: 1955 *params = ENUM_TO_DOUBLE(ctx->Hint.LineSmooth); 1956 break; 1957 case GL_LINE_STIPPLE: 1958 *params = (GLdouble) ctx->Line.StippleFlag; 1959 break; 1960 case GL_LINE_STIPPLE_PATTERN: 1961 *params = (GLdouble) ctx->Line.StipplePattern; 1962 break; 1963 case GL_LINE_STIPPLE_REPEAT: 1964 *params = (GLdouble) ctx->Line.StippleFactor; 1965 break; 1966 case GL_LINE_WIDTH: 1967 *params = (GLdouble) ctx->Line.Width; 1968 break; 1969 case GL_LINE_WIDTH_GRANULARITY: 1970 *params = (GLdouble) ctx->Const.LineWidthGranularity; 1971 break; 1972 case GL_LINE_WIDTH_RANGE: 1973 params[0] = (GLdouble) ctx->Const.MinLineWidthAA; 1974 params[1] = (GLdouble) ctx->Const.MaxLineWidthAA; 1975 break; 1976 case GL_ALIASED_LINE_WIDTH_RANGE: 1977 params[0] = (GLdouble) ctx->Const.MinLineWidth; 1978 params[1] = (GLdouble) ctx->Const.MaxLineWidth; 1979 break; 1980 case GL_LIST_BASE: 1981 *params = (GLdouble) ctx->List.ListBase; 1982 break; 1983 case GL_LIST_INDEX: 1984 *params = (GLdouble) ctx->CurrentListNum; 1985 break; 1986 case GL_LIST_MODE: 1987 if (!ctx->CompileFlag) 1988 *params = 0.0; 1989 else if (ctx->ExecuteFlag) 1990 *params = ENUM_TO_DOUBLE(GL_COMPILE_AND_EXECUTE); 1991 else 1992 *params = ENUM_TO_DOUBLE(GL_COMPILE); 1993 break; 1994 case GL_INDEX_LOGIC_OP: 1995 *params = (GLdouble) ctx->Color.IndexLogicOpEnabled; 1996 break; 1997 case GL_COLOR_LOGIC_OP: 1998 *params = (GLdouble) ctx->Color.ColorLogicOpEnabled; 1999 break; 2000 case GL_LOGIC_OP_MODE: 2001 *params = ENUM_TO_DOUBLE(ctx->Color.LogicOp); 2002 break; 2003 case GL_MAP1_COLOR_4: 2004 *params = (GLdouble) ctx->Eval.Map1Color4; 2005 break; 2006 case GL_MAP1_GRID_DOMAIN: 2007 params[0] = (GLdouble) ctx->Eval.MapGrid1u1; 2008 params[1] = (GLdouble) ctx->Eval.MapGrid1u2; 2009 break; 2010 case GL_MAP1_GRID_SEGMENTS: 2011 *params = (GLdouble) ctx->Eval.MapGrid1un; 2012 break; 2013 case GL_MAP1_INDEX: 2014 *params = (GLdouble) ctx->Eval.Map1Index; 2015 break; 2016 case GL_MAP1_NORMAL: 2017 *params = (GLdouble) ctx->Eval.Map1Normal; 2018 break; 2019 case GL_MAP1_TEXTURE_COORD_1: 2020 *params = (GLdouble) ctx->Eval.Map1TextureCoord1; 2021 break; 2022 case GL_MAP1_TEXTURE_COORD_2: 2023 *params = (GLdouble) ctx->Eval.Map1TextureCoord2; 2024 break; 2025 case GL_MAP1_TEXTURE_COORD_3: 2026 *params = (GLdouble) ctx->Eval.Map1TextureCoord3; 2027 break; 2028 case GL_MAP1_TEXTURE_COORD_4: 2029 *params = (GLdouble) ctx->Eval.Map1TextureCoord4; 2030 break; 2031 case GL_MAP1_VERTEX_3: 2032 *params = (GLdouble) ctx->Eval.Map1Vertex3; 2033 break; 2034 case GL_MAP1_VERTEX_4: 2035 *params = (GLdouble) ctx->Eval.Map1Vertex4; 2036 break; 2037 case GL_MAP2_COLOR_4: 2038 *params = (GLdouble) ctx->Eval.Map2Color4; 2039 break; 2040 case GL_MAP2_GRID_DOMAIN: 2041 params[0] = (GLdouble) ctx->Eval.MapGrid2u1; 2042 params[1] = (GLdouble) ctx->Eval.MapGrid2u2; 2043 params[2] = (GLdouble) ctx->Eval.MapGrid2v1; 2044 params[3] = (GLdouble) ctx->Eval.MapGrid2v2; 2045 break; 2046 case GL_MAP2_GRID_SEGMENTS: 2047 params[0] = (GLdouble) ctx->Eval.MapGrid2un; 2048 params[1] = (GLdouble) ctx->Eval.MapGrid2vn; 2049 break; 2050 case GL_MAP2_INDEX: 2051 *params = (GLdouble) ctx->Eval.Map2Index; 2052 break; 2053 case GL_MAP2_NORMAL: 2054 *params = (GLdouble) ctx->Eval.Map2Normal; 2055 break; 2056 case GL_MAP2_TEXTURE_COORD_1: 2057 *params = (GLdouble) ctx->Eval.Map2TextureCoord1; 2058 break; 2059 case GL_MAP2_TEXTURE_COORD_2: 2060 *params = (GLdouble) ctx->Eval.Map2TextureCoord2; 2061 break; 2062 case GL_MAP2_TEXTURE_COORD_3: 2063 *params = (GLdouble) ctx->Eval.Map2TextureCoord3; 2064 break; 2065 case GL_MAP2_TEXTURE_COORD_4: 2066 *params = (GLdouble) ctx->Eval.Map2TextureCoord4; 2067 break; 2068 case GL_MAP2_VERTEX_3: 2069 *params = (GLdouble) ctx->Eval.Map2Vertex3; 2070 break; 2071 case GL_MAP2_VERTEX_4: 2072 *params = (GLdouble) ctx->Eval.Map2Vertex4; 2073 break; 2074 case GL_MAP_COLOR: 2075 *params = (GLdouble) ctx->Pixel.MapColorFlag; 2076 break; 2077 case GL_MAP_STENCIL: 2078 *params = (GLdouble) ctx->Pixel.MapStencilFlag; 2079 break; 2080 case GL_MATRIX_MODE: 2081 *params = ENUM_TO_DOUBLE(ctx->Transform.MatrixMode); 2082 break; 2083 case GL_MAX_ATTRIB_STACK_DEPTH: 2084 *params = (GLdouble) MAX_ATTRIB_STACK_DEPTH; 2085 break; 2086 case GL_MAX_CLIENT_ATTRIB_STACK_DEPTH: 2087 *params = (GLdouble) MAX_CLIENT_ATTRIB_STACK_DEPTH; 2088 break; 2089 case GL_MAX_CLIP_PLANES: 2090 *params = (GLdouble) ctx->Const.MaxClipPlanes; 2091 break; 2092 case GL_MAX_ELEMENTS_VERTICES: /* GL_VERSION_1_2 */ 2093 *params = (GLdouble) ctx->Const.MaxArrayLockSize; 2094 break; 2095 case GL_MAX_ELEMENTS_INDICES: /* GL_VERSION_1_2 */ 2096 *params = (GLdouble) ctx->Const.MaxArrayLockSize; 2097 break; 2098 case GL_MAX_EVAL_ORDER: 2099 *params = (GLdouble) MAX_EVAL_ORDER; 2100 break; 2101 case GL_MAX_LIGHTS: 2102 *params = (GLdouble) ctx->Const.MaxLights; 2103 break; 2104 case GL_MAX_LIST_NESTING: 2105 *params = (GLdouble) MAX_LIST_NESTING; 2106 break; 2107 case GL_MAX_MODELVIEW_STACK_DEPTH: 2108 *params = (GLdouble) MAX_MODELVIEW_STACK_DEPTH; 2109 break; 2110 case GL_MAX_NAME_STACK_DEPTH: 2111 *params = (GLdouble) MAX_NAME_STACK_DEPTH; 2112 break; 2113 case GL_MAX_PIXEL_MAP_TABLE: 2114 *params = (GLdouble) MAX_PIXEL_MAP_TABLE; 2115 break; 2116 case GL_MAX_PROJECTION_STACK_DEPTH: 2117 *params = (GLdouble) MAX_PROJECTION_STACK_DEPTH; 2118 break; 2119 case GL_MAX_TEXTURE_SIZE: 2120 *params = (GLdouble) (1 << (ctx->Const.MaxTextureLevels - 1)); 2121 break; 2122 case GL_MAX_3D_TEXTURE_SIZE: 2123 *params = (GLdouble) (1 << (ctx->Const.Max3DTextureLevels - 1)); 2124 break; 2125 case GL_MAX_TEXTURE_STACK_DEPTH: 2126 *params = (GLdouble) MAX_TEXTURE_STACK_DEPTH; 2127 break; 2128 case GL_MAX_VIEWPORT_DIMS: 2129 params[0] = (GLdouble) MAX_WIDTH; 2130 params[1] = (GLdouble) MAX_HEIGHT; 2131 break; 2132 case GL_MODELVIEW_MATRIX: 2133 for (i=0;i<16;i++) { 2134 params[i] = (GLdouble) ctx->ModelviewMatrixStack.Top->m[i]; 2135 } 2136 break; 2137 case GL_MODELVIEW_STACK_DEPTH: 2138 *params = (GLdouble) (ctx->ModelviewMatrixStack.Depth + 1); 2139 break; 2140 case GL_NAME_STACK_DEPTH: 2141 *params = (GLdouble) ctx->Select.NameStackDepth; 2142 break; 2143 case GL_NORMALIZE: 2144 *params = (GLdouble) ctx->Transform.Normalize; 2145 break; 2146 case GL_PACK_ALIGNMENT: 2147 *params = (GLdouble) ctx->Pack.Alignment; 2148 break; 2149 case GL_PACK_LSB_FIRST: 2150 *params = (GLdouble) ctx->Pack.LsbFirst; 2151 break; 2152 case GL_PACK_ROW_LENGTH: 2153 *params = (GLdouble) ctx->Pack.RowLength; 2154 break; 2155 case GL_PACK_SKIP_PIXELS: 2156 *params = (GLdouble) ctx->Pack.SkipPixels; 2157 break; 2158 case GL_PACK_SKIP_ROWS: 2159 *params = (GLdouble) ctx->Pack.SkipRows; 2160 break; 2161 case GL_PACK_SWAP_BYTES: 2162 *params = (GLdouble) ctx->Pack.SwapBytes; 2163 break; 2164 case GL_PACK_SKIP_IMAGES_EXT: 2165 *params = (GLdouble) ctx->Pack.SkipImages; 2166 break; 2167 case GL_PACK_IMAGE_HEIGHT_EXT: 2168 *params = (GLdouble) ctx->Pack.ImageHeight; 2169 break; 2170 case GL_PACK_INVERT_MESA: 2171 *params = (GLdouble) ctx->Pack.Invert; 2172 break; 2173 case GL_PERSPECTIVE_CORRECTION_HINT: 2174 *params = ENUM_TO_DOUBLE(ctx->Hint.PerspectiveCorrection); 2175 break; 2176 case GL_PIXEL_MAP_A_TO_A_SIZE: 2177 *params = (GLdouble) ctx->Pixel.MapAtoAsize; 2178 break; 2179 case GL_PIXEL_MAP_B_TO_B_SIZE: 2180 *params = (GLdouble) ctx->Pixel.MapBtoBsize; 2181 break; 2182 case GL_PIXEL_MAP_G_TO_G_SIZE: 2183 *params = (GLdouble) ctx->Pixel.MapGtoGsize; 2184 break; 2185 case GL_PIXEL_MAP_I_TO_A_SIZE: 2186 *params = (GLdouble) ctx->Pixel.MapItoAsize; 2187 break; 2188 case GL_PIXEL_MAP_I_TO_B_SIZE: 2189 *params = (GLdouble) ctx->Pixel.MapItoBsize; 2190 break; 2191 case GL_PIXEL_MAP_I_TO_G_SIZE: 2192 *params = (GLdouble) ctx->Pixel.MapItoGsize; 2193 break; 2194 case GL_PIXEL_MAP_I_TO_I_SIZE: 2195 *params = (GLdouble) ctx->Pixel.MapItoIsize; 2196 break; 2197 case GL_PIXEL_MAP_I_TO_R_SIZE: 2198 *params = (GLdouble) ctx->Pixel.MapItoRsize; 2199 break; 2200 case GL_PIXEL_MAP_R_TO_R_SIZE: 2201 *params = (GLdouble) ctx->Pixel.MapRtoRsize; 2202 break; 2203 case GL_PIXEL_MAP_S_TO_S_SIZE: 2204 *params = (GLdouble) ctx->Pixel.MapStoSsize; 2205 break; 2206 case GL_POINT_SIZE: 2207 *params = (GLdouble) ctx->Point.Size; 2208 break; 2209 case GL_POINT_SIZE_GRANULARITY: 2210 *params = (GLdouble) ctx->Const.PointSizeGranularity; 2211 break; 2212 case GL_POINT_SIZE_RANGE: 2213 params[0] = (GLdouble) ctx->Const.MinPointSizeAA; 2214 params[1] = (GLdouble) ctx->Const.MaxPointSizeAA; 2215 break; 2216 case GL_ALIASED_POINT_SIZE_RANGE: 2217 params[0] = (GLdouble) ctx->Const.MinPointSize; 2218 params[1] = (GLdouble) ctx->Const.MaxPointSize; 2219 break; 2220 case GL_POINT_SMOOTH: 2221 *params = (GLdouble) ctx->Point.SmoothFlag; 2222 break; 2223 case GL_POINT_SMOOTH_HINT: 2224 *params = ENUM_TO_DOUBLE(ctx->Hint.PointSmooth); 2225 break; 2226 case GL_POINT_SIZE_MIN_EXT: 2227 *params = (GLdouble) (ctx->Point.MinSize); 2228 break; 2229 case GL_POINT_SIZE_MAX_EXT: 2230 *params = (GLdouble) (ctx->Point.MaxSize); 2231 break; 2232 case GL_POINT_FADE_THRESHOLD_SIZE_EXT: 2233 *params = (GLdouble) (ctx->Point.Threshold); 2234 break; 2235 case GL_DISTANCE_ATTENUATION_EXT: 2236 params[0] = (GLdouble) (ctx->Point.Params[0]); 2237 params[1] = (GLdouble) (ctx->Point.Params[1]); 2238 params[2] = (GLdouble) (ctx->Point.Params[2]); 2239 break; 2240 case GL_POLYGON_MODE: 2241 params[0] = ENUM_TO_DOUBLE(ctx->Polygon.FrontMode); 2242 params[1] = ENUM_TO_DOUBLE(ctx->Polygon.BackMode); 2243 break; 2244 case GL_POLYGON_OFFSET_BIAS_EXT: /* GL_EXT_polygon_offset */ 2245 *params = (GLdouble) ctx->Polygon.OffsetUnits; 2246 break; 2247 case GL_POLYGON_OFFSET_FACTOR: 2248 *params = (GLdouble) ctx->Polygon.OffsetFactor; 2249 break; 2250 case GL_POLYGON_OFFSET_UNITS: 2251 *params = (GLdouble) ctx->Polygon.OffsetUnits; 2252 break; 2253 case GL_POLYGON_SMOOTH: 2254 *params = (GLdouble) ctx->Polygon.SmoothFlag; 2255 break; 2256 case GL_POLYGON_SMOOTH_HINT: 2257 *params = ENUM_TO_DOUBLE(ctx->Hint.PolygonSmooth); 2258 break; 2259 case GL_POLYGON_STIPPLE: 2260 *params = (GLdouble) ctx->Polygon.StippleFlag; 2261 break; 2262 case GL_PROJECTION_MATRIX: 2263 for (i=0;i<16;i++) { 2264 params[i] = (GLdouble) ctx->ProjectionMatrixStack.Top->m[i]; 2265 } 2266 break; 2267 case GL_PROJECTION_STACK_DEPTH: 2268 *params = (GLdouble) (ctx->ProjectionMatrixStack.Depth + 1); 2269 break; 2270 case GL_READ_BUFFER: 2271 *params = ENUM_TO_DOUBLE(ctx->Pixel.ReadBuffer); 2272 break; 2273 case GL_RED_BIAS: 2274 *params = (GLdouble) ctx->Pixel.RedBias; 2275 break; 2276 case GL_RED_BITS: 2277 *params = (GLdouble) ctx->Visual.redBits; 2278 break; 2279 case GL_RED_SCALE: 2280 *params = (GLdouble) ctx->Pixel.RedScale; 2281 break; 2282 case GL_RENDER_MODE: 2283 *params = ENUM_TO_DOUBLE(ctx->RenderMode); 2284 break; 2285 case GL_RESCALE_NORMAL: 2286 *params = (GLdouble) ctx->Transform.RescaleNormals; 2287 break; 2288 case GL_RGBA_MODE: 2289 *params = (GLdouble) ctx->Visual.rgbMode; 2290 break; 2291 case GL_SCISSOR_BOX: 2292 params[0] = (GLdouble) ctx->Scissor.X; 2293 params[1] = (GLdouble) ctx->Scissor.Y; 2294 params[2] = (GLdouble) ctx->Scissor.Width; 2295 params[3] = (GLdouble) ctx->Scissor.Height; 2296 break; 2297 case GL_SCISSOR_TEST: 2298 *params = (GLdouble) ctx->Scissor.Enabled; 2299 break; 2300 case GL_SELECTION_BUFFER_SIZE: 2301 *params = (GLdouble) ctx->Select.BufferSize; 2302 break; 2303 case GL_SHADE_MODEL: 2304 *params = ENUM_TO_DOUBLE(ctx->Light.ShadeModel); 2305 break; 2306 case GL_SHARED_TEXTURE_PALETTE_EXT: 2307 *params = (GLdouble) ctx->Texture.SharedPalette; 2308 break; 2309 case GL_STENCIL_BITS: 2310 *params = (GLdouble) ctx->Visual.stencilBits; 2311 break; 2312 case GL_STENCIL_CLEAR_VALUE: 2313 *params = (GLdouble) ctx->Stencil.Clear; 2314 break; 2315 case GL_STENCIL_FAIL: 2316 *params = ENUM_TO_DOUBLE(ctx->Stencil.FailFunc[ctx->Stencil.ActiveFace]); 2317 break; 2318 case GL_STENCIL_FUNC: 2319 *params = ENUM_TO_DOUBLE(ctx->Stencil.Function[ctx->Stencil.ActiveFace]); 2320 break; 2321 case GL_STENCIL_PASS_DEPTH_FAIL: 2322 *params = ENUM_TO_DOUBLE(ctx->Stencil.ZFailFunc[ctx->Stencil.ActiveFace]); 2323 break; 2324 case GL_STENCIL_PASS_DEPTH_PASS: 2325 *params = ENUM_TO_DOUBLE(ctx->Stencil.ZPassFunc[ctx->Stencil.ActiveFace]); 2326 break; 2327 case GL_STENCIL_REF: 2328 *params = (GLdouble) ctx->Stencil.Ref[ctx->Stencil.ActiveFace]; 2329 break; 2330 case GL_STENCIL_TEST: 2331 *params = (GLdouble) ctx->Stencil.Enabled; 2332 break; 2333 case GL_STENCIL_VALUE_MASK: 2334 *params = (GLdouble) ctx->Stencil.ValueMask[ctx->Stencil.ActiveFace]; 2335 break; 2336 case GL_STENCIL_WRITEMASK: 2337 *params = (GLdouble) ctx->Stencil.WriteMask[ctx->Stencil.ActiveFace]; 2338 break; 2339 case GL_STEREO: 2340 *params = (GLdouble) ctx->Visual.stereoMode; 2341 break; 2342 case GL_SUBPIXEL_BITS: 2343 *params = (GLdouble) ctx->Const.SubPixelBits; 2344 break; 2345 case GL_TEXTURE_1D: 2346 *params = _mesa_IsEnabled(GL_TEXTURE_1D) ? 1.0 : 0.0; 2347 break; 2348 case GL_TEXTURE_2D: 2349 *params = _mesa_IsEnabled(GL_TEXTURE_2D) ? 1.0 : 0.0; 2350 break; 2351 case GL_TEXTURE_3D: 2352 *params = _mesa_IsEnabled(GL_TEXTURE_3D) ? 1.0 : 0.0; 2353 break; 2354 case GL_TEXTURE_BINDING_1D: 2355 *params = (GLdouble) textureUnit->Current1D->Name; 2356 break; 2357 case GL_TEXTURE_BINDING_2D: 2358 *params = (GLdouble) textureUnit->Current2D->Name; 2359 break; 2360 case GL_TEXTURE_BINDING_3D: 2361 *params = (GLdouble) textureUnit->Current3D->Name; 2362 break; 2363 case GL_TEXTURE_ENV_COLOR: 2364 params[0] = (GLdouble) textureUnit->EnvColor[0]; 2365 params[1] = (GLdouble) textureUnit->EnvColor[1]; 2366 params[2] = (GLdouble) textureUnit->EnvColor[2]; 2367 params[3] = (GLdouble) textureUnit->EnvColor[3]; 2368 break; 2369 case GL_TEXTURE_ENV_MODE: 2370 *params = ENUM_TO_DOUBLE(textureUnit->EnvMode); 2371 break; 2372 case GL_TEXTURE_GEN_S: 2373 *params = (textureUnit->TexGenEnabled & S_BIT) ? 1.0 : 0.0; 2374 break; 2375 case GL_TEXTURE_GEN_T: 2376 *params = (textureUnit->TexGenEnabled & T_BIT) ? 1.0 : 0.0; 2377 break; 2378 case GL_TEXTURE_GEN_R: 2379 *params = (textureUnit->TexGenEnabled & R_BIT) ? 1.0 : 0.0; 2380 break; 2381 case GL_TEXTURE_GEN_Q: 2382 *params = (textureUnit->TexGenEnabled & Q_BIT) ? 1.0 : 0.0; 2383 break; 2384 case GL_TEXTURE_MATRIX: 2385 for (i=0;i<16;i++) { 2386 params[i] = (GLdouble) ctx->TextureMatrixStack[texUnit].Top->m[i]; 2387 } 2388 break; 2389 case GL_TEXTURE_STACK_DEPTH: 2390 *params = (GLdouble) (ctx->TextureMatrixStack[texUnit].Depth + 1); 2391 break; 2392 case GL_UNPACK_ALIGNMENT: 2393 *params = (GLdouble) ctx->Unpack.Alignment; 2394 break; 2395 case GL_UNPACK_LSB_FIRST: 2396 *params = (GLdouble) ctx->Unpack.LsbFirst; 2397 break; 2398 case GL_UNPACK_ROW_LENGTH: 2399 *params = (GLdouble) ctx->Unpack.RowLength; 2400 break; 2401 case GL_UNPACK_SKIP_PIXELS: 2402 *params = (GLdouble) ctx->Unpack.SkipPixels; 2403 break; 2404 case GL_UNPACK_SKIP_ROWS: 2405 *params = (GLdouble) ctx->Unpack.SkipRows; 2406 break; 2407 case GL_UNPACK_SWAP_BYTES: 2408 *params = (GLdouble) ctx->Unpack.SwapBytes; 2409 break; 2410 case GL_UNPACK_SKIP_IMAGES_EXT: 2411 *params = (GLdouble) ctx->Unpack.SkipImages; 2412 break; 2413 case GL_UNPACK_IMAGE_HEIGHT_EXT: 2414 *params = (GLdouble) ctx->Unpack.ImageHeight; 2415 break; 2416 case GL_UNPACK_CLIENT_STORAGE_APPLE: 2417 *params = (GLdouble) ctx->Unpack.ClientStorage; 2418 break; 2419 case GL_VIEWPORT: 2420 params[0] = (GLdouble) ctx->Viewport.X; 2421 params[1] = (GLdouble) ctx->Viewport.Y; 2422 params[2] = (GLdouble) ctx->Viewport.Width; 2423 params[3] = (GLdouble) ctx->Viewport.Height; 2424 break; 2425 case GL_ZOOM_X: 2426 *params = (GLdouble) ctx->Pixel.ZoomX; 2427 break; 2428 case GL_ZOOM_Y: 2429 *params = (GLdouble) ctx->Pixel.ZoomY; 2430 break; 2431 case GL_VERTEX_ARRAY: 2432 *params = (GLdouble) ctx->Array.Vertex.Enabled; 2433 break; 2434 case GL_VERTEX_ARRAY_SIZE: 2435 *params = (GLdouble) ctx->Array.Vertex.Size; 2436 break; 2437 case GL_VERTEX_ARRAY_TYPE: 2438 *params = ENUM_TO_DOUBLE(ctx->Array.Vertex.Type); 2439 break; 2440 case GL_VERTEX_ARRAY_STRIDE: 2441 *params = (GLdouble) ctx->Array.Vertex.Stride; 2442 break; 2443 case GL_VERTEX_ARRAY_COUNT_EXT: 2444 *params = 0.0; 2445 break; 2446 case GL_NORMAL_ARRAY: 2447 *params = (GLdouble) ctx->Array.Normal.Enabled; 2448 break; 2449 case GL_NORMAL_ARRAY_TYPE: 2450 *params = ENUM_TO_DOUBLE(ctx->Array.Normal.Type); 2451 break; 2452 case GL_NORMAL_ARRAY_STRIDE: 2453 *params = (GLdouble) ctx->Array.Normal.Stride; 2454 break; 2455 case GL_NORMAL_ARRAY_COUNT_EXT: 2456 *params = 0.0; 2457 break; 2458 case GL_COLOR_ARRAY: 2459 *params = (GLdouble) ctx->Array.Color.Enabled; 2460 break; 2461 case GL_COLOR_ARRAY_SIZE: 2462 *params = (GLdouble) ctx->Array.Color.Size; 2463 break; 2464 case GL_COLOR_ARRAY_TYPE: 2465 *params = ENUM_TO_DOUBLE(ctx->Array.Color.Type); 2466 break; 2467 case GL_COLOR_ARRAY_STRIDE: 2468 *params = (GLdouble) ctx->Array.Color.Stride; 2469 break; 2470 case GL_COLOR_ARRAY_COUNT_EXT: 2471 *params = 0.0; 2472 break; 2473 case GL_INDEX_ARRAY: 2474 *params = (GLdouble) ctx->Array.Index.Enabled; 2475 break; 2476 case GL_INDEX_ARRAY_TYPE: 2477 *params = ENUM_TO_DOUBLE(ctx->Array.Index.Type); 2478 break; 2479 case GL_INDEX_ARRAY_STRIDE: 2480 *params = (GLdouble) ctx->Array.Index.Stride; 2481 break; 2482 case GL_INDEX_ARRAY_COUNT_EXT: 2483 *params = 0.0; 2484 break; 2485 case GL_TEXTURE_COORD_ARRAY: 2486 *params = (GLdouble) ctx->Array.TexCoord[texUnit].Enabled; 2487 break; 2488 case GL_TEXTURE_COORD_ARRAY_SIZE: 2489 *params = (GLdouble) ctx->Array.TexCoord[texUnit].Size; 2490 break; 2491 case GL_TEXTURE_COORD_ARRAY_TYPE: 2492 *params = ENUM_TO_DOUBLE(ctx->Array.TexCoord[texUnit].Type); 2493 break; 2494 case GL_TEXTURE_COORD_ARRAY_STRIDE: 2495 *params = (GLdouble) ctx->Array.TexCoord[texUnit].Stride; 2496 break; 2497 case GL_TEXTURE_COORD_ARRAY_COUNT_EXT: 2498 *params = 0.0; 2499 break; 2500 case GL_EDGE_FLAG_ARRAY: 2501 *params = (GLdouble) ctx->Array.EdgeFlag.Enabled; 2502 break; 2503 case GL_EDGE_FLAG_ARRAY_STRIDE: 2504 *params = (GLdouble) ctx->Array.EdgeFlag.Stride; 2505 break; 2506 case GL_EDGE_FLAG_ARRAY_COUNT_EXT: 2507 *params = 0.0; 2508 break; 2509 2510 /* GL_ARB_multitexture */ 2511 case GL_MAX_TEXTURE_UNITS_ARB: 2512 CHECK_EXTENSION_D(ARB_multitexture, pname); 2513 *params = (GLdouble) MIN2(ctx->Const.MaxTextureImageUnits, 2514 ctx->Const.MaxTextureCoordUnits); 2515 break; 2516 case GL_ACTIVE_TEXTURE_ARB: 2517 CHECK_EXTENSION_D(ARB_multitexture, pname); 2518 *params = (GLdouble) (GL_TEXTURE0_ARB + ctx->Texture.CurrentUnit); 2519 break; 2520 case GL_CLIENT_ACTIVE_TEXTURE_ARB: 2521 CHECK_EXTENSION_D(ARB_multitexture, pname); 2522 *params = (GLdouble) (GL_TEXTURE0_ARB + ctx->Array.ActiveTexture); 2523 break; 2524 2525 /* GL_ARB_texture_cube_map */ 2526 case GL_TEXTURE_CUBE_MAP_ARB: 2527 CHECK_EXTENSION_D(ARB_texture_cube_map, pname); 2528 *params = (GLdouble) _mesa_IsEnabled(GL_TEXTURE_CUBE_MAP_ARB); 2529 break; 2530 case GL_TEXTURE_BINDING_CUBE_MAP_ARB: 2531 CHECK_EXTENSION_D(ARB_texture_cube_map, pname); 2532 *params = (GLdouble) textureUnit->CurrentCubeMap->Name; 2533 break; 2534 case GL_MAX_CUBE_MAP_TEXTURE_SIZE_ARB: 2535 CHECK_EXTENSION_D(ARB_texture_cube_map, pname); 2536 *params = (GLdouble) (1 << (ctx->Const.MaxCubeTextureLevels - 1)); 2537 break; 2538 2539 /* GL_ARB_texture_compression */ 2540 case GL_TEXTURE_COMPRESSION_HINT_ARB: 2541 CHECK_EXTENSION_D(ARB_texture_compression, pname); 2542 *params = (GLdouble) ctx->Hint.TextureCompression; 2543 break; 2544 case GL_NUM_COMPRESSED_TEXTURE_FORMATS_ARB: 2545 CHECK_EXTENSION_D(ARB_texture_compression, pname); 2546 *params = (GLdouble) _mesa_get_compressed_formats(ctx, NULL); 2547 break; 2548 case GL_COMPRESSED_TEXTURE_FORMATS_ARB: 2549 CHECK_EXTENSION_D(ARB_texture_compression, pname); 2550 { 2551 GLint formats[100]; 2552 GLuint i, n; 2553 n = _mesa_get_compressed_formats(ctx, formats); 2554 for (i = 0; i < n; i++) 2555 params[i] = (GLdouble) formats[i]; 2556 } 2557 break; 2558 2559 /* GL_EXT_compiled_vertex_array */ 2560 case GL_ARRAY_ELEMENT_LOCK_FIRST_EXT: 2561 *params = (GLdouble) ctx->Array.LockFirst; 2562 break; 2563 case GL_ARRAY_ELEMENT_LOCK_COUNT_EXT: 2564 *params = (GLdouble) ctx->Array.LockCount; 2565 break; 2566 2567 /* GL_ARB_transpose_matrix */ 2568 case GL_TRANSPOSE_COLOR_MATRIX_ARB: 2569 { 2570 GLfloat tm[16]; 2571 GLuint i; 2572 _math_transposef(tm, ctx->ColorMatrixStack.Top->m); 2573 for (i=0;i<16;i++) { 2574 params[i] = (GLdouble) tm[i]; 2575 } 2576 } 2577 break; 2578 case GL_TRANSPOSE_MODELVIEW_MATRIX_ARB: 2579 { 2580 GLfloat tm[16]; 2581 GLuint i; 2582 _math_transposef(tm, ctx->ModelviewMatrixStack.Top->m); 2583 for (i=0;i<16;i++) { 2584 params[i] = (GLdouble) tm[i]; 2585 } 2586 } 2587 break; 2588 case GL_TRANSPOSE_PROJECTION_MATRIX_ARB: 2589 { 2590 GLfloat tm[16]; 2591 GLuint i; 2592 _math_transposef(tm, ctx->ProjectionMatrixStack.Top->m); 2593 for (i=0;i<16;i++) { 2594 params[i] = (GLdouble) tm[i]; 2595 } 2596 } 2597 break; 2598 case GL_TRANSPOSE_TEXTURE_MATRIX_ARB: 2599 { 2600 GLfloat tm[16]; 2601 GLuint i; 2602 _math_transposef(tm, ctx->TextureMatrixStack[texUnit].Top->m); 2603 for (i=0;i<16;i++) { 2604 params[i] = (GLdouble) tm[i]; 2605 } 2606 } 2607 break; 2608 2609 /* GL_HP_occlusion_test */ 2610 case GL_OCCLUSION_TEST_HP: 2611 CHECK_EXTENSION_D(HP_occlusion_test, pname); 2612 *params = (GLdouble) ctx->Depth.OcclusionTest; 2613 break; 2614 case GL_OCCLUSION_TEST_RESULT_HP: 2615 CHECK_EXTENSION_D(HP_occlusion_test, pname); 2616 if (ctx->Depth.OcclusionTest) 2617 *params = (GLdouble) ctx->OcclusionResult; 2618 else 2619 *params = (GLdouble) ctx->OcclusionResultSaved; 2620 /* reset flag now */ 2621 ctx->OcclusionResult = GL_FALSE; 2622 ctx->OcclusionResultSaved = GL_FALSE; 2623 break; 2624 2625 /* GL_SGIS_pixel_texture */ 2626 case GL_PIXEL_TEXTURE_SGIS: 2627 *params = (GLdouble) ctx->Pixel.PixelTextureEnabled; 2628 break; 2629 2630 /* GL_SGIX_pixel_texture */ 2631 case GL_PIXEL_TEX_GEN_SGIX: 2632 *params = (GLdouble) ctx->Pixel.PixelTextureEnabled; 2633 break; 2634 case GL_PIXEL_TEX_GEN_MODE_SGIX: 2635 *params = (GLdouble) pixel_texgen_mode(ctx); 2636 break; 2637 2638 /* GL_SGI_color_matrix (also in 1.2 imaging) */ 2639 case GL_COLOR_MATRIX_SGI: 2640 for (i=0;i<16;i++) { 2641 params[i] = (GLdouble) ctx->ColorMatrixStack.Top->m[i]; 2642 } 2643 break; 2644 case GL_COLOR_MATRIX_STACK_DEPTH_SGI: 2645 *params = (GLdouble) (ctx->ColorMatrixStack.Depth + 1); 2646 break; 2647 case GL_MAX_COLOR_MATRIX_STACK_DEPTH_SGI: 2648 *params = (GLdouble) MAX_COLOR_STACK_DEPTH; 2649 break; 2650 case GL_POST_COLOR_MATRIX_RED_SCALE_SGI: 2651 *params = (GLdouble) ctx->Pixel.PostColorMatrixScale[0]; 2652 break; 2653 case GL_POST_COLOR_MATRIX_GREEN_SCALE_SGI: 2654 *params = (GLdouble) ctx->Pixel.PostColorMatrixScale[1]; 2655 break; 2656 case GL_POST_COLOR_MATRIX_BLUE_SCALE_SGI: 2657 *params = (GLdouble) ctx->Pixel.PostColorMatrixScale[2]; 2658 break; 2659 case GL_POST_COLOR_MATRIX_ALPHA_SCALE_SGI: 2660 *params = (GLdouble) ctx->Pixel.PostColorMatrixScale[3]; 2661 break; 2662 case GL_POST_COLOR_MATRIX_RED_BIAS_SGI: 2663 *params = (GLdouble) ctx->Pixel.PostColorMatrixBias[0]; 2664 break; 2665 case GL_POST_COLOR_MATRIX_GREEN_BIAS_SGI: 2666 *params = (GLdouble) ctx->Pixel.PostColorMatrixBias[1]; 2667 break; 2668 case GL_POST_COLOR_MATRIX_BLUE_BIAS_SGI: 2669 *params = (GLdouble) ctx->Pixel.PostColorMatrixBias[2]; 2670 break; 2671 case GL_POST_COLOR_MATRIX_ALPHA_BIAS_SGI: 2672 *params = (GLdouble) ctx->Pixel.PostColorMatrixBias[3]; 2673 break; 2674 2675 /* GL_EXT_convolution (also in 1.2 imaging) */ 2676 case GL_CONVOLUTION_1D_EXT: 2677 CHECK_EXTENSION_D(EXT_convolution, pname); 2678 *params = (GLdouble) ctx->Pixel.Convolution1DEnabled; 2679 break; 2680 case GL_CONVOLUTION_2D: 2681 CHECK_EXTENSION_D(EXT_convolution, pname); 2682 *params = (GLdouble) ctx->Pixel.Convolution2DEnabled; 2683 break; 2684 case GL_SEPARABLE_2D: 2685 CHECK_EXTENSION_D(EXT_convolution, pname); 2686 *params = (GLdouble) ctx->Pixel.Separable2DEnabled; 2687 break; 2688 case GL_POST_CONVOLUTION_RED_SCALE_EXT: 2689 CHECK_EXTENSION_D(EXT_convolution, pname); 2690 *params = (GLdouble) ctx->Pixel.PostConvolutionScale[0]; 2691 break; 2692 case GL_POST_CONVOLUTION_GREEN_SCALE_EXT: 2693 CHECK_EXTENSION_D(EXT_convolution, pname); 2694 *params = (GLdouble) ctx->Pixel.PostConvolutionScale[1]; 2695 break; 2696 case GL_POST_CONVOLUTION_BLUE_SCALE_EXT: 2697 CHECK_EXTENSION_D(EXT_convolution, pname); 2698 *params = (GLdouble) ctx->Pixel.PostConvolutionScale[2]; 2699 break; 2700 case GL_POST_CONVOLUTION_ALPHA_SCALE_EXT: 2701 CHECK_EXTENSION_D(EXT_convolution, pname); 2702 *params = (GLdouble) ctx->Pixel.PostConvolutionScale[3]; 2703 break; 2704 case GL_POST_CONVOLUTION_RED_BIAS_EXT: 2705 CHECK_EXTENSION_D(EXT_convolution, pname); 2706 *params = (GLdouble) ctx->Pixel.PostConvolutionBias[0]; 2707 break; 2708 case GL_POST_CONVOLUTION_GREEN_BIAS_EXT: 2709 CHECK_EXTENSION_D(EXT_convolution, pname); 2710 *params = (GLdouble) ctx->Pixel.PostConvolutionBias[1]; 2711 break; 2712 case GL_POST_CONVOLUTION_BLUE_BIAS_EXT: 2713 CHECK_EXTENSION_D(EXT_convolution, pname); 2714 *params = (GLdouble) ctx->Pixel.PostConvolutionBias[2]; 2715 break; 2716 case GL_POST_CONVOLUTION_ALPHA_BIAS_EXT: 2717 CHECK_EXTENSION_D(EXT_convolution, pname); 2718 *params = (GLdouble) ctx->Pixel.PostConvolutionBias[2]; 2719 break; 2720 2721 /* GL_EXT_histogram (also in 1.2 imaging) */ 2722 case GL_HISTOGRAM: 2723 CHECK_EXTENSION_D(EXT_histogram, pname); 2724 *params = (GLdouble) ctx->Pixel.HistogramEnabled; 2725 break; 2726 case GL_MINMAX: 2727 CHECK_EXTENSION_D(EXT_histogram, pname); 2728 *params = (GLdouble) ctx->Pixel.MinMaxEnabled; 2729 break; 2730 2731 /* GL_SGI_color_table (also in 1.2 imaging */ 2732 case GL_COLOR_TABLE_SGI: 2733 *params = (GLdouble) ctx->Pixel.ColorTableEnabled; 2734 break; 2735 case GL_POST_CONVOLUTION_COLOR_TABLE_SGI: 2736 *params = (GLdouble) ctx->Pixel.PostConvolutionColorTableEnabled; 2737 break; 2738 case GL_POST_COLOR_MATRIX_COLOR_TABLE_SGI: 2739 *params = (GLdouble) ctx->Pixel.PostColorMatrixColorTableEnabled; 2740 break; 2741 2742 /* GL_SGI_texture_color_table */ 2743 case GL_TEXTURE_COLOR_TABLE_SGI: 2744 CHECK_EXTENSION_D(SGI_texture_color_table, pname); 2745 *params = (GLdouble) textureUnit->ColorTableEnabled; 2746 break; 2747 2748 /* GL_EXT_secondary_color */ 2749 case GL_COLOR_SUM_EXT: 2750 CHECK_EXTENSION_D(EXT_secondary_color, pname); 2751 *params = (GLdouble) ctx->Fog.ColorSumEnabled; 2752 break; 2753 case GL_CURRENT_SECONDARY_COLOR_EXT: 2754 CHECK_EXTENSION_D(EXT_secondary_color, pname); 2755 FLUSH_CURRENT(ctx, 0); 2756 params[0] = ctx->Current.Attrib[VERT_ATTRIB_COLOR1][0]; 2757 params[1] = ctx->Current.Attrib[VERT_ATTRIB_COLOR1][1]; 2758 params[2] = ctx->Current.Attrib[VERT_ATTRIB_COLOR1][2]; 2759 params[3] = ctx->Current.Attrib[VERT_ATTRIB_COLOR1][3]; 2760 break; 2761 case GL_SECONDARY_COLOR_ARRAY_EXT: 2762 CHECK_EXTENSION_D(EXT_secondary_color, pname); 2763 *params = (GLdouble) ctx->Array.SecondaryColor.Enabled; 2764 break; 2765 case GL_SECONDARY_COLOR_ARRAY_TYPE_EXT: 2766 CHECK_EXTENSION_D(EXT_secondary_color, pname); 2767 *params = (GLdouble) ctx->Array.SecondaryColor.Type; 2768 break; 2769 case GL_SECONDARY_COLOR_ARRAY_STRIDE_EXT: 2770 CHECK_EXTENSION_D(EXT_secondary_color, pname); 2771 *params = (GLdouble) ctx->Array.SecondaryColor.Stride; 2772 break; 2773 case GL_SECONDARY_COLOR_ARRAY_SIZE_EXT: 2774 CHECK_EXTENSION_D(EXT_secondary_color, pname); 2775 *params = (GLdouble) ctx->Array.SecondaryColor.Size; 2776 break; 2777 2778 /* GL_EXT_fog_coord */ 2779 case GL_CURRENT_FOG_COORDINATE_EXT: 2780 CHECK_EXTENSION_D(EXT_fog_coord, pname); 2781 FLUSH_CURRENT(ctx, 0); 2782 *params = (GLdouble) ctx->Current.Attrib[VERT_ATTRIB_FOG][0]; 2783 break; 2784 case GL_FOG_COORDINATE_ARRAY_EXT: 2785 CHECK_EXTENSION_D(EXT_fog_coord, pname); 2786 *params = (GLdouble) ctx->Array.FogCoord.Enabled; 2787 break; 2788 case GL_FOG_COORDINATE_ARRAY_TYPE_EXT: 2789 CHECK_EXTENSION_D(EXT_fog_coord, pname); 2790 *params = (GLdouble) ctx->Array.FogCoord.Type; 2791 break; 2792 case GL_FOG_COORDINATE_ARRAY_STRIDE_EXT: 2793 CHECK_EXTENSION_D(EXT_fog_coord, pname); 2794 *params = (GLdouble) ctx->Array.FogCoord.Stride; 2795 break; 2796 case GL_FOG_COORDINATE_SOURCE_EXT: 2797 CHECK_EXTENSION_D(EXT_fog_coord, pname); 2798 *params = (GLdouble) ctx->Fog.FogCoordinateSource; 2799 break; 2800 2801 /* GL_EXT_texture_lod_bias */ 2802 case GL_MAX_TEXTURE_LOD_BIAS_EXT: 2803 *params = (GLdouble) ctx->Const.MaxTextureLodBias; 2804 break; 2805 2806 /* GL_EXT_texture_filter_anisotropic */ 2807 case GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT: 2808 CHECK_EXTENSION_D(EXT_texture_filter_anisotropic, pname); 2809 *params = (GLdouble) ctx->Const.MaxTextureMaxAnisotropy; 2810 break; 2811 2812 /* GL_ARB_multisample */ 2813 case GL_MULTISAMPLE_ARB: 2814 CHECK_EXTENSION_D(ARB_multisample, pname); 2815 *params = (GLdouble) ctx->Multisample.Enabled; 2816 break; 2817 case GL_SAMPLE_ALPHA_TO_COVERAGE_ARB: 2818 CHECK_EXTENSION_D(ARB_multisample, pname); 2819 *params = (GLdouble) ctx->Multisample.SampleAlphaToCoverage; 2820 break; 2821 case GL_SAMPLE_ALPHA_TO_ONE_ARB: 2822 CHECK_EXTENSION_D(ARB_multisample, pname); 2823 *params = (GLdouble) ctx->Multisample.SampleAlphaToOne; 2824 break; 2825 case GL_SAMPLE_COVERAGE_ARB: 2826 CHECK_EXTENSION_D(ARB_multisample, pname); 2827 *params = (GLdouble) ctx->Multisample.SampleCoverage; 2828 break; 2829 case GL_SAMPLE_COVERAGE_VALUE_ARB: 2830 CHECK_EXTENSION_D(ARB_multisample, pname); 2831 *params = ctx->Multisample.SampleCoverageValue; 2832 break; 2833 case GL_SAMPLE_COVERAGE_INVERT_ARB: 2834 CHECK_EXTENSION_D(ARB_multisample, pname); 2835 *params = (GLdouble) ctx->Multisample.SampleCoverageInvert; 2836 break; 2837 case GL_SAMPLE_BUFFERS_ARB: 2838 CHECK_EXTENSION_D(ARB_multisample, pname); 2839 *params = 0.0; /* XXX fix someday */ 2840 break; 2841 case GL_SAMPLES_ARB: 2842 CHECK_EXTENSION_D(ARB_multisample, pname); 2843 *params = 0.0; /* XXX fix someday */ 2844 break; 2845 2846 /* GL_IBM_rasterpos_clip */ 2847 case GL_RASTER_POSITION_UNCLIPPED_IBM: 2848 CHECK_EXTENSION_D(IBM_rasterpos_clip, pname); 2849 *params = (GLdouble) ctx->Transform.RasterPositionUnclipped; 2850 break; 2851 2852 /* GL_NV_point_sprite */ 2853 case GL_POINT_SPRITE_NV: 2854 CHECK_EXTENSION_B(NV_point_sprite, pname); 2855 *params = (GLdouble) ctx->Point.PointSprite; 2856 break; 2857 case GL_POINT_SPRITE_R_MODE_NV: 2858 CHECK_EXTENSION_B(NV_point_sprite, pname); 2859 *params = (GLdouble) ctx->Point.SpriteRMode; 2860 break; 2861 2862 /* GL_SGIS_generate_mipmap */ 2863 case GL_GENERATE_MIPMAP_HINT_SGIS: 2864 CHECK_EXTENSION_D(SGIS_generate_mipmap, pname); 2865 *params = (GLdouble) ctx->Hint.GenerateMipmap; 2866 break; 2867 2868#if FEATURE_NV_vertex_program 2869 case GL_VERTEX_PROGRAM_NV: 2870 CHECK_EXTENSION_D(NV_vertex_program, pname); 2871 *params = (GLdouble) ctx->VertexProgram.Enabled; 2872 break; 2873 case GL_VERTEX_PROGRAM_POINT_SIZE_NV: 2874 CHECK_EXTENSION_D(NV_vertex_program, pname); 2875 *params = (GLdouble) ctx->VertexProgram.PointSizeEnabled; 2876 break; 2877 case GL_VERTEX_PROGRAM_TWO_SIDE_NV: 2878 CHECK_EXTENSION_D(NV_vertex_program, pname); 2879 *params = (GLdouble) ctx->VertexProgram.TwoSideEnabled; 2880 break; 2881 case GL_MAX_TRACK_MATRIX_STACK_DEPTH_NV: 2882 CHECK_EXTENSION_D(NV_vertex_program, pname); 2883 *params = (GLdouble) ctx->Const.MaxProgramMatrixStackDepth; 2884 break; 2885 case GL_MAX_TRACK_MATRICES_NV: 2886 CHECK_EXTENSION_D(NV_vertex_program, pname); 2887 *params = (GLdouble) ctx->Const.MaxProgramMatrices; 2888 break; 2889 case GL_CURRENT_MATRIX_STACK_DEPTH_NV: 2890 CHECK_EXTENSION_D(NV_vertex_program, pname); 2891 *params = (GLdouble) ctx->CurrentStack->Depth + 1; 2892 break; 2893 case GL_CURRENT_MATRIX_NV: 2894 CHECK_EXTENSION_D(NV_vertex_program, pname); 2895 for (i = 0; i < 16; i++) 2896 params[i] = (GLdouble) ctx->CurrentStack->Top->m[i]; 2897 break; 2898 case GL_VERTEX_PROGRAM_BINDING_NV: 2899 CHECK_EXTENSION_D(NV_vertex_program, pname); 2900 if (ctx->VertexProgram.Current) 2901 *params = (GLdouble) ctx->VertexProgram.Current->Base.Id; 2902 else 2903 *params = 0.0; 2904 break; 2905 case GL_PROGRAM_ERROR_POSITION_NV: 2906 CHECK_EXTENSION_D(NV_vertex_program, pname); 2907 *params = (GLdouble) ctx->Program.ErrorPos; 2908 break; 2909 case GL_VERTEX_ATTRIB_ARRAY0_NV: 2910 case GL_VERTEX_ATTRIB_ARRAY1_NV: 2911 case GL_VERTEX_ATTRIB_ARRAY2_NV: 2912 case GL_VERTEX_ATTRIB_ARRAY3_NV: 2913 case GL_VERTEX_ATTRIB_ARRAY4_NV: 2914 case GL_VERTEX_ATTRIB_ARRAY5_NV: 2915 case GL_VERTEX_ATTRIB_ARRAY6_NV: 2916 case GL_VERTEX_ATTRIB_ARRAY7_NV: 2917 case GL_VERTEX_ATTRIB_ARRAY8_NV: 2918 case GL_VERTEX_ATTRIB_ARRAY9_NV: 2919 case GL_VERTEX_ATTRIB_ARRAY10_NV: 2920 case GL_VERTEX_ATTRIB_ARRAY11_NV: 2921 case GL_VERTEX_ATTRIB_ARRAY12_NV: 2922 case GL_VERTEX_ATTRIB_ARRAY13_NV: 2923 case GL_VERTEX_ATTRIB_ARRAY14_NV: 2924 case GL_VERTEX_ATTRIB_ARRAY15_NV: 2925 CHECK_EXTENSION_D(NV_vertex_program, pname); 2926 { 2927 GLuint n = (GLuint) pname - GL_VERTEX_ATTRIB_ARRAY0_NV; 2928 *params = (GLdouble) ctx->Array.VertexAttrib[n].Enabled; 2929 } 2930 break; 2931 case GL_MAP1_VERTEX_ATTRIB0_4_NV: 2932 case GL_MAP1_VERTEX_ATTRIB1_4_NV: 2933 case GL_MAP1_VERTEX_ATTRIB2_4_NV: 2934 case GL_MAP1_VERTEX_ATTRIB3_4_NV: 2935 case GL_MAP1_VERTEX_ATTRIB4_4_NV: 2936 case GL_MAP1_VERTEX_ATTRIB5_4_NV: 2937 case GL_MAP1_VERTEX_ATTRIB6_4_NV: 2938 case GL_MAP1_VERTEX_ATTRIB7_4_NV: 2939 case GL_MAP1_VERTEX_ATTRIB8_4_NV: 2940 case GL_MAP1_VERTEX_ATTRIB9_4_NV: 2941 case GL_MAP1_VERTEX_ATTRIB10_4_NV: 2942 case GL_MAP1_VERTEX_ATTRIB11_4_NV: 2943 case GL_MAP1_VERTEX_ATTRIB12_4_NV: 2944 case GL_MAP1_VERTEX_ATTRIB13_4_NV: 2945 case GL_MAP1_VERTEX_ATTRIB14_4_NV: 2946 case GL_MAP1_VERTEX_ATTRIB15_4_NV: 2947 CHECK_EXTENSION_B(NV_vertex_program, pname); 2948 { 2949 GLuint n = (GLuint) pname - GL_MAP1_VERTEX_ATTRIB0_4_NV; 2950 *params = (GLdouble) ctx->Eval.Map1Attrib[n]; 2951 } 2952 break; 2953 case GL_MAP2_VERTEX_ATTRIB0_4_NV: 2954 case GL_MAP2_VERTEX_ATTRIB1_4_NV: 2955 case GL_MAP2_VERTEX_ATTRIB2_4_NV: 2956 case GL_MAP2_VERTEX_ATTRIB3_4_NV: 2957 case GL_MAP2_VERTEX_ATTRIB4_4_NV: 2958 case GL_MAP2_VERTEX_ATTRIB5_4_NV: 2959 case GL_MAP2_VERTEX_ATTRIB6_4_NV: 2960 case GL_MAP2_VERTEX_ATTRIB7_4_NV: 2961 case GL_MAP2_VERTEX_ATTRIB8_4_NV: 2962 case GL_MAP2_VERTEX_ATTRIB9_4_NV: 2963 case GL_MAP2_VERTEX_ATTRIB10_4_NV: 2964 case GL_MAP2_VERTEX_ATTRIB11_4_NV: 2965 case GL_MAP2_VERTEX_ATTRIB12_4_NV: 2966 case GL_MAP2_VERTEX_ATTRIB13_4_NV: 2967 case GL_MAP2_VERTEX_ATTRIB14_4_NV: 2968 case GL_MAP2_VERTEX_ATTRIB15_4_NV: 2969 CHECK_EXTENSION_B(NV_vertex_program, pname); 2970 { 2971 GLuint n = (GLuint) pname - GL_MAP2_VERTEX_ATTRIB0_4_NV; 2972 *params = (GLdouble) ctx->Eval.Map2Attrib[n]; 2973 } 2974 break; 2975#endif /* FEATURE_NV_vertex_program */ 2976 2977#if FEATURE_NV_fragment_program 2978 case GL_FRAGMENT_PROGRAM_NV: 2979 CHECK_EXTENSION_D(NV_fragment_program, pname); 2980 *params = (GLdouble) ctx->FragmentProgram.Enabled; 2981 break; 2982 case GL_MAX_TEXTURE_COORDS_NV: 2983 CHECK_EXTENSION_B(NV_fragment_program, pname); 2984 *params = (GLdouble) ctx->Const.MaxTextureCoordUnits; 2985 break; 2986 case GL_MAX_TEXTURE_IMAGE_UNITS_NV: 2987 CHECK_EXTENSION_B(NV_fragment_program, pname); 2988 *params = (GLdouble) ctx->Const.MaxTextureImageUnits; 2989 break; 2990 case GL_FRAGMENT_PROGRAM_BINDING_NV: 2991 CHECK_EXTENSION_D(NV_fragment_program, pname); 2992 if (ctx->FragmentProgram.Current) 2993 *params = (GLdouble) ctx->FragmentProgram.Current->Base.Id; 2994 else 2995 *params = 0.0; 2996 break; 2997 case GL_MAX_FRAGMENT_PROGRAM_LOCAL_PARAMETERS_NV: 2998 CHECK_EXTENSION_D(NV_fragment_program, pname); 2999 *params = (GLdouble) MAX_NV_FRAGMENT_PROGRAM_PARAMS; 3000 break; 3001#endif /* FEATURE_NV_fragment_program */ 3002 3003 /* GL_NV_texture_rectangle */ 3004 case GL_TEXTURE_RECTANGLE_NV: 3005 CHECK_EXTENSION_D(NV_texture_rectangle, pname); 3006 *params = (GLdouble) _mesa_IsEnabled(GL_TEXTURE_RECTANGLE_NV); 3007 break; 3008 case GL_TEXTURE_BINDING_RECTANGLE_NV: 3009 CHECK_EXTENSION_D(NV_texture_rectangle, pname); 3010 *params = (GLdouble) textureUnit->CurrentRect->Name; 3011 break; 3012 case GL_MAX_RECTANGLE_TEXTURE_SIZE_NV: 3013 CHECK_EXTENSION_D(NV_texture_rectangle, pname); 3014 *params = (GLdouble) ctx->Const.MaxTextureRectSize; 3015 break; 3016 3017 /* GL_EXT_stencil_two_side */ 3018 case GL_STENCIL_TEST_TWO_SIDE_EXT: 3019 CHECK_EXTENSION_D(EXT_stencil_two_side, pname); 3020 *params = (GLdouble) ctx->Stencil.TestTwoSide; 3021 break; 3022 case GL_ACTIVE_STENCIL_FACE_EXT: 3023 CHECK_EXTENSION_D(EXT_stencil_two_side, pname); 3024 *params = (GLdouble) (ctx->Stencil.ActiveFace ? GL_BACK : GL_FRONT); 3025 break; 3026 3027 /* GL_NV_light_max_exponent */ 3028 case GL_MAX_SHININESS_NV: 3029 *params = (GLdouble) ctx->Const.MaxShininess; 3030 break; 3031 case GL_MAX_SPOT_EXPONENT_NV: 3032 *params = (GLdouble) ctx->Const.MaxSpotExponent; 3033 break; 3034 3035#if FEATURE_ARB_vertex_buffer_object 3036 case GL_ARRAY_BUFFER_BINDING_ARB: 3037 CHECK_EXTENSION_D(ARB_vertex_buffer_object, pname); 3038 *params = (GLdouble) ctx->Array.ArrayBufferBinding; 3039 break; 3040 case GL_VERTEX_ARRAY_BUFFER_BINDING_ARB: 3041 CHECK_EXTENSION_D(ARB_vertex_buffer_object, pname); 3042 *params = (GLdouble) ctx->Array.VertexArrayBufferBinding; 3043 break; 3044 case GL_NORMAL_ARRAY_BUFFER_BINDING_ARB: 3045 CHECK_EXTENSION_D(ARB_vertex_buffer_object, pname); 3046 *params = (GLdouble) ctx->Array.NormalArrayBufferBinding; 3047 break; 3048 case GL_COLOR_ARRAY_BUFFER_BINDING_ARB: 3049 CHECK_EXTENSION_D(ARB_vertex_buffer_object, pname); 3050 *params = (GLdouble) ctx->Array.ColorArrayBufferBinding; 3051 break; 3052 case GL_INDEX_ARRAY_BUFFER_BINDING_ARB: 3053 CHECK_EXTENSION_D(ARB_vertex_buffer_object, pname); 3054 *params = (GLdouble) ctx->Array.IndexArrayBufferBinding; 3055 break; 3056 case GL_TEXTURE_COORD_ARRAY_BUFFER_BINDING_ARB: 3057 CHECK_EXTENSION_D(ARB_vertex_buffer_object, pname); 3058 *params = (GLdouble) ctx->Array.TextureArrayBufferBinding; 3059 break; 3060 case GL_EDGE_FLAG_ARRAY_BUFFER_BINDING_ARB: 3061 CHECK_EXTENSION_D(ARB_vertex_buffer_object, pname); 3062 *params = (GLdouble) ctx->Array.EdgeFlagArrayBufferBinding; 3063 break; 3064 case GL_SECONDARY_COLOR_ARRAY_BUFFER_BINDING_ARB: 3065 CHECK_EXTENSION_D(ARB_vertex_buffer_object, pname); 3066 *params = (GLdouble) ctx->Array.SecondaryColorArrayBufferBinding; 3067 break; 3068 case GL_FOG_COORDINATE_ARRAY_BUFFER_BINDING_ARB: 3069 CHECK_EXTENSION_D(ARB_vertex_buffer_object, pname); 3070 *params = (GLdouble) ctx->Array.FogCoordArrayBufferBinding; 3071 break; 3072 case GL_WEIGHT_ARRAY_BUFFER_BINDING_ARB: 3073 CHECK_EXTENSION_D(ARB_vertex_buffer_object, pname); 3074 *params = (GLdouble) ctx->Array.WeightArrayBufferBinding; 3075 break; 3076 case GL_ELEMENT_ARRAY_BUFFER_BINDING_ARB: 3077 CHECK_EXTENSION_D(ARB_vertex_buffer_object, pname); 3078 *params = (GLdouble) ctx->Array.ElementArrayBufferBinding; 3079 break; 3080#endif 3081 3082#if FEATURE_ARB_fragment_program 3083 case GL_FRAGMENT_PROGRAM_ARB: 3084 CHECK_EXTENSION_D(ARB_fragment_program, pname); 3085 *params = (GLdouble) ctx->FragmentProgram.Enabled; 3086 break; 3087 case GL_TRANSPOSE_CURRENT_MATRIX_ARB: 3088 CHECK_EXTENSION_D(ARB_fragment_program, pname); 3089 params[0] = ctx->CurrentStack->Top->m[0]; 3090 params[1] = ctx->CurrentStack->Top->m[4]; 3091 params[2] = ctx->CurrentStack->Top->m[8]; 3092 params[3] = ctx->CurrentStack->Top->m[12]; 3093 params[4] = ctx->CurrentStack->Top->m[1]; 3094 params[5] = ctx->CurrentStack->Top->m[5]; 3095 params[6] = ctx->CurrentStack->Top->m[9]; 3096 params[7] = ctx->CurrentStack->Top->m[13]; 3097 params[8] = ctx->CurrentStack->Top->m[2]; 3098 params[9] = ctx->CurrentStack->Top->m[6]; 3099 params[10] = ctx->CurrentStack->Top->m[10]; 3100 params[11] = ctx->CurrentStack->Top->m[14]; 3101 params[12] = ctx->CurrentStack->Top->m[3]; 3102 params[13] = ctx->CurrentStack->Top->m[7]; 3103 params[14] = ctx->CurrentStack->Top->m[11]; 3104 params[15] = ctx->CurrentStack->Top->m[15]; 3105 break; 3106 /* Remaining ARB_fragment_program queries alias with 3107 * the GL_NV_fragment_program queries. 3108 */ 3109#endif 3110 3111 /* GL_EXT_depth_bounds_test */ 3112 case GL_DEPTH_BOUNDS_TEST_EXT: 3113 CHECK_EXTENSION_D(EXT_depth_bounds_test, pname); 3114 params[0] = (GLdouble) ctx->Depth.BoundsTest; 3115 break; 3116 case GL_DEPTH_BOUNDS_EXT: 3117 CHECK_EXTENSION_D(EXT_depth_bounds_test, pname); 3118 params[0] = ctx->Depth.BoundsMin; 3119 params[1] = ctx->Depth.BoundsMax; 3120 break; 3121 3122 default: 3123 _mesa_error(ctx, GL_INVALID_ENUM, "glGetDoublev(pname=0x%x)", pname); 3124 } 3125} 3126 3127 3128void 3129_mesa_GetFloatv( GLenum pname, GLfloat *params ) 3130{ 3131 GET_CURRENT_CONTEXT(ctx); 3132 GLuint i; 3133 GLuint texUnit = ctx->Texture.CurrentUnit; 3134 const struct gl_texture_unit *textureUnit = &ctx->Texture.Unit[texUnit]; 3135 ASSERT_OUTSIDE_BEGIN_END(ctx); 3136 3137 if (!params) 3138 return; 3139 3140 /* We need this in order to get correct results for 3141 * GL_OCCLUSION_TEST_RESULT_HP. There might be other important cases. 3142 */ 3143 FLUSH_VERTICES(ctx, 0); 3144 3145 if (MESA_VERBOSE & VERBOSE_API) 3146 _mesa_debug(ctx, "glGetFloatv %s\n", _mesa_lookup_enum_by_nr(pname)); 3147 3148 if (ctx->Driver.GetFloatv && (*ctx->Driver.GetFloatv)(ctx, pname, params)) 3149 return; 3150 3151 switch (pname) { 3152 case GL_ACCUM_RED_BITS: 3153 *params = (GLfloat) ctx->Visual.accumRedBits; 3154 break; 3155 case GL_ACCUM_GREEN_BITS: 3156 *params = (GLfloat) ctx->Visual.accumGreenBits; 3157 break; 3158 case GL_ACCUM_BLUE_BITS: 3159 *params = (GLfloat) ctx->Visual.accumBlueBits; 3160 break; 3161 case GL_ACCUM_ALPHA_BITS: 3162 *params = (GLfloat) ctx->Visual.accumAlphaBits; 3163 break; 3164 case GL_ACCUM_CLEAR_VALUE: 3165 params[0] = ctx->Accum.ClearColor[0]; 3166 params[1] = ctx->Accum.ClearColor[1]; 3167 params[2] = ctx->Accum.ClearColor[2]; 3168 params[3] = ctx->Accum.ClearColor[3]; 3169 break; 3170 case GL_ALPHA_BIAS: 3171 *params = ctx->Pixel.AlphaBias; 3172 break; 3173 case GL_ALPHA_BITS: 3174 *params = (GLfloat) ctx->Visual.alphaBits; 3175 break; 3176 case GL_ALPHA_SCALE: 3177 *params = ctx->Pixel.AlphaScale; 3178 break; 3179 case GL_ALPHA_TEST: 3180 *params = (GLfloat) ctx->Color.AlphaEnabled; 3181 break; 3182 case GL_ALPHA_TEST_FUNC: 3183 *params = ENUM_TO_FLOAT(ctx->Color.AlphaFunc); 3184 break; 3185 case GL_ALPHA_TEST_REF: 3186 *params = (GLfloat) ctx->Color.AlphaRef; 3187 break; 3188 case GL_ATTRIB_STACK_DEPTH: 3189 *params = (GLfloat) (ctx->AttribStackDepth); 3190 break; 3191 case GL_AUTO_NORMAL: 3192 *params = (GLfloat) ctx->Eval.AutoNormal; 3193 break; 3194 case GL_AUX_BUFFERS: 3195 *params = (GLfloat) ctx->Const.NumAuxBuffers; 3196 break; 3197 case GL_BLEND: 3198 *params = (GLfloat) ctx->Color.BlendEnabled; 3199 break; 3200 case GL_BLEND_DST: 3201 *params = ENUM_TO_FLOAT(ctx->Color.BlendDstRGB); 3202 break; 3203 case GL_BLEND_SRC: 3204 *params = ENUM_TO_FLOAT(ctx->Color.BlendSrcRGB); 3205 break; 3206 case GL_BLEND_SRC_RGB_EXT: 3207 *params = ENUM_TO_FLOAT(ctx->Color.BlendSrcRGB); 3208 break; 3209 case GL_BLEND_DST_RGB_EXT: 3210 *params = ENUM_TO_FLOAT(ctx->Color.BlendDstRGB); 3211 break; 3212 case GL_BLEND_SRC_ALPHA_EXT: 3213 *params = ENUM_TO_FLOAT(ctx->Color.BlendSrcA); 3214 break; 3215 case GL_BLEND_DST_ALPHA_EXT: 3216 *params = ENUM_TO_FLOAT(ctx->Color.BlendDstA); 3217 break; 3218 case GL_BLEND_EQUATION_EXT: 3219 *params = ENUM_TO_FLOAT(ctx->Color.BlendEquation); 3220 break; 3221 case GL_BLEND_COLOR_EXT: 3222 params[0] = ctx->Color.BlendColor[0]; 3223 params[1] = ctx->Color.BlendColor[1]; 3224 params[2] = ctx->Color.BlendColor[2]; 3225 params[3] = ctx->Color.BlendColor[3]; 3226 break; 3227 case GL_BLUE_BIAS: 3228 *params = ctx->Pixel.BlueBias; 3229 break; 3230 case GL_BLUE_BITS: 3231 *params = (GLfloat) ctx->Visual.blueBits; 3232 break; 3233 case GL_BLUE_SCALE: 3234 *params = ctx->Pixel.BlueScale; 3235 break; 3236 case GL_CLIENT_ATTRIB_STACK_DEPTH: 3237 *params = (GLfloat) (ctx->ClientAttribStackDepth); 3238 break; 3239 case GL_CLIP_PLANE0: 3240 case GL_CLIP_PLANE1: 3241 case GL_CLIP_PLANE2: 3242 case GL_CLIP_PLANE3: 3243 case GL_CLIP_PLANE4: 3244 case GL_CLIP_PLANE5: 3245 if (ctx->Transform.ClipPlanesEnabled & (1 << (pname - GL_CLIP_PLANE0))) 3246 *params = 1.0; 3247 else 3248 *params = 0.0; 3249 break; 3250 case GL_COLOR_CLEAR_VALUE: 3251 params[0] = ctx->Color.ClearColor[0]; 3252 params[1] = ctx->Color.ClearColor[1]; 3253 params[2] = ctx->Color.ClearColor[2]; 3254 params[3] = ctx->Color.ClearColor[3]; 3255 break; 3256 case GL_COLOR_MATERIAL: 3257 *params = (GLfloat) ctx->Light.ColorMaterialEnabled; 3258 break; 3259 case GL_COLOR_MATERIAL_FACE: 3260 *params = ENUM_TO_FLOAT(ctx->Light.ColorMaterialFace); 3261 break; 3262 case GL_COLOR_MATERIAL_PARAMETER: 3263 *params = ENUM_TO_FLOAT(ctx->Light.ColorMaterialMode); 3264 break; 3265 case GL_COLOR_WRITEMASK: 3266 params[0] = ctx->Color.ColorMask[RCOMP] ? 1.0F : 0.0F; 3267 params[1] = ctx->Color.ColorMask[GCOMP] ? 1.0F : 0.0F; 3268 params[2] = ctx->Color.ColorMask[BCOMP] ? 1.0F : 0.0F; 3269 params[3] = ctx->Color.ColorMask[ACOMP] ? 1.0F : 0.0F; 3270 break; 3271 case GL_CULL_FACE: 3272 *params = (GLfloat) ctx->Polygon.CullFlag; 3273 break; 3274 case GL_CULL_FACE_MODE: 3275 *params = ENUM_TO_FLOAT(ctx->Polygon.CullFaceMode); 3276 break; 3277 case GL_CURRENT_COLOR: 3278 FLUSH_CURRENT(ctx, 0); 3279 params[0] = ctx->Current.Attrib[VERT_ATTRIB_COLOR0][0]; 3280 params[1] = ctx->Current.Attrib[VERT_ATTRIB_COLOR0][1]; 3281 params[2] = ctx->Current.Attrib[VERT_ATTRIB_COLOR0][2]; 3282 params[3] = ctx->Current.Attrib[VERT_ATTRIB_COLOR0][3]; 3283 break; 3284 case GL_CURRENT_INDEX: 3285 FLUSH_CURRENT(ctx, 0); 3286 *params = (GLfloat) ctx->Current.Index; 3287 break; 3288 case GL_CURRENT_NORMAL: 3289 FLUSH_CURRENT(ctx, 0); 3290 params[0] = ctx->Current.Attrib[VERT_ATTRIB_NORMAL][0]; 3291 params[1] = ctx->Current.Attrib[VERT_ATTRIB_NORMAL][1]; 3292 params[2] = ctx->Current.Attrib[VERT_ATTRIB_NORMAL][2]; 3293 break; 3294 case GL_CURRENT_RASTER_COLOR: 3295 params[0] = ctx->Current.RasterColor[0]; 3296 params[1] = ctx->Current.RasterColor[1]; 3297 params[2] = ctx->Current.RasterColor[2]; 3298 params[3] = ctx->Current.RasterColor[3]; 3299 break; 3300 case GL_CURRENT_RASTER_DISTANCE: 3301 params[0] = ctx->Current.RasterDistance; 3302 break; 3303 case GL_CURRENT_RASTER_INDEX: 3304 *params = (GLfloat) ctx->Current.RasterIndex; 3305 break; 3306 case GL_CURRENT_RASTER_POSITION: 3307 params[0] = ctx->Current.RasterPos[0]; 3308 params[1] = ctx->Current.RasterPos[1]; 3309 params[2] = ctx->Current.RasterPos[2]; 3310 params[3] = ctx->Current.RasterPos[3]; 3311 break; 3312 case GL_CURRENT_RASTER_TEXTURE_COORDS: 3313 params[0] = ctx->Current.RasterTexCoords[texUnit][0]; 3314 params[1] = ctx->Current.RasterTexCoords[texUnit][1]; 3315 params[2] = ctx->Current.RasterTexCoords[texUnit][2]; 3316 params[3] = ctx->Current.RasterTexCoords[texUnit][3]; 3317 break; 3318 case GL_CURRENT_RASTER_POSITION_VALID: 3319 *params = (GLfloat) ctx->Current.RasterPosValid; 3320 break; 3321 case GL_CURRENT_TEXTURE_COORDS: 3322 FLUSH_CURRENT(ctx, 0); 3323 params[0] = (GLfloat) ctx->Current.Attrib[VERT_ATTRIB_TEX0 + texUnit][0]; 3324 params[1] = (GLfloat) ctx->Current.Attrib[VERT_ATTRIB_TEX0 + texUnit][1]; 3325 params[2] = (GLfloat) ctx->Current.Attrib[VERT_ATTRIB_TEX0 + texUnit][2]; 3326 params[3] = (GLfloat) ctx->Current.Attrib[VERT_ATTRIB_TEX0 + texUnit][3]; 3327 break; 3328 case GL_DEPTH_BIAS: 3329 *params = (GLfloat) ctx->Pixel.DepthBias; 3330 break; 3331 case GL_DEPTH_BITS: 3332 *params = (GLfloat) ctx->Visual.depthBits; 3333 break; 3334 case GL_DEPTH_CLEAR_VALUE: 3335 *params = (GLfloat) ctx->Depth.Clear; 3336 break; 3337 case GL_DEPTH_FUNC: 3338 *params = ENUM_TO_FLOAT(ctx->Depth.Func); 3339 break; 3340 case GL_DEPTH_RANGE: 3341 params[0] = (GLfloat) ctx->Viewport.Near; 3342 params[1] = (GLfloat) ctx->Viewport.Far; 3343 break; 3344 case GL_DEPTH_SCALE: 3345 *params = (GLfloat) ctx->Pixel.DepthScale; 3346 break; 3347 case GL_DEPTH_TEST: 3348 *params = (GLfloat) ctx->Depth.Test; 3349 break; 3350 case GL_DEPTH_WRITEMASK: 3351 *params = (GLfloat) ctx->Depth.Mask; 3352 break; 3353 case GL_DITHER: 3354 *params = (GLfloat) ctx->Color.DitherFlag; 3355 break; 3356 case GL_DOUBLEBUFFER: 3357 *params = (GLfloat) ctx->Visual.doubleBufferMode; 3358 break; 3359 case GL_DRAW_BUFFER: 3360 *params = ENUM_TO_FLOAT(ctx->Color.DrawBuffer); 3361 break; 3362 case GL_EDGE_FLAG: 3363 FLUSH_CURRENT(ctx, 0); 3364 *params = (GLfloat) ctx->Current.EdgeFlag; 3365 break; 3366 case GL_FEEDBACK_BUFFER_SIZE: 3367 *params = (GLfloat) ctx->Feedback.BufferSize; 3368 break; 3369 case GL_FEEDBACK_BUFFER_TYPE: 3370 *params = ENUM_TO_FLOAT(ctx->Feedback.Type); 3371 break; 3372 case GL_FOG: 3373 *params = (GLfloat) ctx->Fog.Enabled; 3374 break; 3375 case GL_FOG_COLOR: 3376 params[0] = ctx->Fog.Color[0]; 3377 params[1] = ctx->Fog.Color[1]; 3378 params[2] = ctx->Fog.Color[2]; 3379 params[3] = ctx->Fog.Color[3]; 3380 break; 3381 case GL_FOG_DENSITY: 3382 *params = ctx->Fog.Density; 3383 break; 3384 case GL_FOG_END: 3385 *params = ctx->Fog.End; 3386 break; 3387 case GL_FOG_HINT: 3388 *params = ENUM_TO_FLOAT(ctx->Hint.Fog); 3389 break; 3390 case GL_FOG_INDEX: 3391 *params = ctx->Fog.Index; 3392 break; 3393 case GL_FOG_MODE: 3394 *params = ENUM_TO_FLOAT(ctx->Fog.Mode); 3395 break; 3396 case GL_FOG_START: 3397 *params = ctx->Fog.Start; 3398 break; 3399 case GL_FRONT_FACE: 3400 *params = ENUM_TO_FLOAT(ctx->Polygon.FrontFace); 3401 break; 3402 case GL_GREEN_BIAS: 3403 *params = (GLfloat) ctx->Pixel.GreenBias; 3404 break; 3405 case GL_GREEN_BITS: 3406 *params = (GLfloat) ctx->Visual.greenBits; 3407 break; 3408 case GL_GREEN_SCALE: 3409 *params = (GLfloat) ctx->Pixel.GreenScale; 3410 break; 3411 case GL_INDEX_BITS: 3412 *params = (GLfloat) ctx->Visual.indexBits; 3413 break; 3414 case GL_INDEX_CLEAR_VALUE: 3415 *params = (GLfloat) ctx->Color.ClearIndex; 3416 break; 3417 case GL_INDEX_MODE: 3418 *params = ctx->Visual.rgbMode ? 0.0F : 1.0F; 3419 break; 3420 case GL_INDEX_OFFSET: 3421 *params = (GLfloat) ctx->Pixel.IndexOffset; 3422 break; 3423 case GL_INDEX_SHIFT: 3424 *params = (GLfloat) ctx->Pixel.IndexShift; 3425 break; 3426 case GL_INDEX_WRITEMASK: 3427 *params = (GLfloat) ctx->Color.IndexMask; 3428 break; 3429 case GL_LIGHT0: 3430 case GL_LIGHT1: 3431 case GL_LIGHT2: 3432 case GL_LIGHT3: 3433 case GL_LIGHT4: 3434 case GL_LIGHT5: 3435 case GL_LIGHT6: 3436 case GL_LIGHT7: 3437 *params = (GLfloat) ctx->Light.Light[pname-GL_LIGHT0].Enabled; 3438 break; 3439 case GL_LIGHTING: 3440 *params = (GLfloat) ctx->Light.Enabled; 3441 break; 3442 case GL_LIGHT_MODEL_AMBIENT: 3443 params[0] = ctx->Light.Model.Ambient[0]; 3444 params[1] = ctx->Light.Model.Ambient[1]; 3445 params[2] = ctx->Light.Model.Ambient[2]; 3446 params[3] = ctx->Light.Model.Ambient[3]; 3447 break; 3448 case GL_LIGHT_MODEL_COLOR_CONTROL: 3449 params[0] = ENUM_TO_FLOAT(ctx->Light.Model.ColorControl); 3450 break; 3451 case GL_LIGHT_MODEL_LOCAL_VIEWER: 3452 *params = (GLfloat) ctx->Light.Model.LocalViewer; 3453 break; 3454 case GL_LIGHT_MODEL_TWO_SIDE: 3455 *params = (GLfloat) ctx->Light.Model.TwoSide; 3456 break; 3457 case GL_LINE_SMOOTH: 3458 *params = (GLfloat) ctx->Line.SmoothFlag; 3459 break; 3460 case GL_LINE_SMOOTH_HINT: 3461 *params = ENUM_TO_FLOAT(ctx->Hint.LineSmooth); 3462 break; 3463 case GL_LINE_STIPPLE: 3464 *params = (GLfloat) ctx->Line.StippleFlag; 3465 break; 3466 case GL_LINE_STIPPLE_PATTERN: 3467 *params = (GLfloat) ctx->Line.StipplePattern; 3468 break; 3469 case GL_LINE_STIPPLE_REPEAT: 3470 *params = (GLfloat) ctx->Line.StippleFactor; 3471 break; 3472 case GL_LINE_WIDTH: 3473 *params = (GLfloat) ctx->Line.Width; 3474 break; 3475 case GL_LINE_WIDTH_GRANULARITY: 3476 *params = (GLfloat) ctx->Const.LineWidthGranularity; 3477 break; 3478 case GL_LINE_WIDTH_RANGE: 3479 params[0] = (GLfloat) ctx->Const.MinLineWidthAA; 3480 params[1] = (GLfloat) ctx->Const.MaxLineWidthAA; 3481 break; 3482 case GL_ALIASED_LINE_WIDTH_RANGE: 3483 params[0] = (GLfloat) ctx->Const.MinLineWidth; 3484 params[1] = (GLfloat) ctx->Const.MaxLineWidth; 3485 break; 3486 case GL_LIST_BASE: 3487 *params = (GLfloat) ctx->List.ListBase; 3488 break; 3489 case GL_LIST_INDEX: 3490 *params = (GLfloat) ctx->CurrentListNum; 3491 break; 3492 case GL_LIST_MODE: 3493 if (!ctx->CompileFlag) 3494 *params = 0.0F; 3495 else if (ctx->ExecuteFlag) 3496 *params = ENUM_TO_FLOAT(GL_COMPILE_AND_EXECUTE); 3497 else 3498 *params = ENUM_TO_FLOAT(GL_COMPILE); 3499 break; 3500 case GL_INDEX_LOGIC_OP: 3501 *params = (GLfloat) ctx->Color.IndexLogicOpEnabled; 3502 break; 3503 case GL_COLOR_LOGIC_OP: 3504 *params = (GLfloat) ctx->Color.ColorLogicOpEnabled; 3505 break; 3506 case GL_LOGIC_OP_MODE: 3507 *params = ENUM_TO_FLOAT(ctx->Color.LogicOp); 3508 break; 3509 case GL_MAP1_COLOR_4: 3510 *params = (GLfloat) ctx->Eval.Map1Color4; 3511 break; 3512 case GL_MAP1_GRID_DOMAIN: 3513 params[0] = ctx->Eval.MapGrid1u1; 3514 params[1] = ctx->Eval.MapGrid1u2; 3515 break; 3516 case GL_MAP1_GRID_SEGMENTS: 3517 *params = (GLfloat) ctx->Eval.MapGrid1un; 3518 break; 3519 case GL_MAP1_INDEX: 3520 *params = (GLfloat) ctx->Eval.Map1Index; 3521 break; 3522 case GL_MAP1_NORMAL: 3523 *params = (GLfloat) ctx->Eval.Map1Normal; 3524 break; 3525 case GL_MAP1_TEXTURE_COORD_1: 3526 *params = (GLfloat) ctx->Eval.Map1TextureCoord1; 3527 break; 3528 case GL_MAP1_TEXTURE_COORD_2: 3529 *params = (GLfloat) ctx->Eval.Map1TextureCoord2; 3530 break; 3531 case GL_MAP1_TEXTURE_COORD_3: 3532 *params = (GLfloat) ctx->Eval.Map1TextureCoord3; 3533 break; 3534 case GL_MAP1_TEXTURE_COORD_4: 3535 *params = (GLfloat) ctx->Eval.Map1TextureCoord4; 3536 break; 3537 case GL_MAP1_VERTEX_3: 3538 *params = (GLfloat) ctx->Eval.Map1Vertex3; 3539 break; 3540 case GL_MAP1_VERTEX_4: 3541 *params = (GLfloat) ctx->Eval.Map1Vertex4; 3542 break; 3543 case GL_MAP2_COLOR_4: 3544 *params = (GLfloat) ctx->Eval.Map2Color4; 3545 break; 3546 case GL_MAP2_GRID_DOMAIN: 3547 params[0] = ctx->Eval.MapGrid2u1; 3548 params[1] = ctx->Eval.MapGrid2u2; 3549 params[2] = ctx->Eval.MapGrid2v1; 3550 params[3] = ctx->Eval.MapGrid2v2; 3551 break; 3552 case GL_MAP2_GRID_SEGMENTS: 3553 params[0] = (GLfloat) ctx->Eval.MapGrid2un; 3554 params[1] = (GLfloat) ctx->Eval.MapGrid2vn; 3555 break; 3556 case GL_MAP2_INDEX: 3557 *params = (GLfloat) ctx->Eval.Map2Index; 3558 break; 3559 case GL_MAP2_NORMAL: 3560 *params = (GLfloat) ctx->Eval.Map2Normal; 3561 break; 3562 case GL_MAP2_TEXTURE_COORD_1: 3563 *params = ctx->Eval.Map2TextureCoord1; 3564 break; 3565 case GL_MAP2_TEXTURE_COORD_2: 3566 *params = ctx->Eval.Map2TextureCoord2; 3567 break; 3568 case GL_MAP2_TEXTURE_COORD_3: 3569 *params = ctx->Eval.Map2TextureCoord3; 3570 break; 3571 case GL_MAP2_TEXTURE_COORD_4: 3572 *params = ctx->Eval.Map2TextureCoord4; 3573 break; 3574 case GL_MAP2_VERTEX_3: 3575 *params = (GLfloat) ctx->Eval.Map2Vertex3; 3576 break; 3577 case GL_MAP2_VERTEX_4: 3578 *params = (GLfloat) ctx->Eval.Map2Vertex4; 3579 break; 3580 case GL_MAP_COLOR: 3581 *params = (GLfloat) ctx->Pixel.MapColorFlag; 3582 break; 3583 case GL_MAP_STENCIL: 3584 *params = (GLfloat) ctx->Pixel.MapStencilFlag; 3585 break; 3586 case GL_MATRIX_MODE: 3587 *params = ENUM_TO_FLOAT(ctx->Transform.MatrixMode); 3588 break; 3589 case GL_MAX_ATTRIB_STACK_DEPTH: 3590 *params = (GLfloat) MAX_ATTRIB_STACK_DEPTH; 3591 break; 3592 case GL_MAX_CLIENT_ATTRIB_STACK_DEPTH: 3593 *params = (GLfloat) MAX_CLIENT_ATTRIB_STACK_DEPTH; 3594 break; 3595 case GL_MAX_CLIP_PLANES: 3596 *params = (GLfloat) ctx->Const.MaxClipPlanes; 3597 break; 3598 case GL_MAX_ELEMENTS_VERTICES: /* GL_VERSION_1_2 */ 3599 *params = (GLfloat) ctx->Const.MaxArrayLockSize; 3600 break; 3601 case GL_MAX_ELEMENTS_INDICES: /* GL_VERSION_1_2 */ 3602 *params = (GLfloat) ctx->Const.MaxArrayLockSize; 3603 break; 3604 case GL_MAX_EVAL_ORDER: 3605 *params = (GLfloat) MAX_EVAL_ORDER; 3606 break; 3607 case GL_MAX_LIGHTS: 3608 *params = (GLfloat) ctx->Const.MaxLights; 3609 break; 3610 case GL_MAX_LIST_NESTING: 3611 *params = (GLfloat) MAX_LIST_NESTING; 3612 break; 3613 case GL_MAX_MODELVIEW_STACK_DEPTH: 3614 *params = (GLfloat) MAX_MODELVIEW_STACK_DEPTH; 3615 break; 3616 case GL_MAX_NAME_STACK_DEPTH: 3617 *params = (GLfloat) MAX_NAME_STACK_DEPTH; 3618 break; 3619 case GL_MAX_PIXEL_MAP_TABLE: 3620 *params = (GLfloat) MAX_PIXEL_MAP_TABLE; 3621 break; 3622 case GL_MAX_PROJECTION_STACK_DEPTH: 3623 *params = (GLfloat) MAX_PROJECTION_STACK_DEPTH; 3624 break; 3625 case GL_MAX_TEXTURE_SIZE: 3626 *params = (GLfloat) (1 << (ctx->Const.MaxTextureLevels - 1)); 3627 break; 3628 case GL_MAX_3D_TEXTURE_SIZE: 3629 *params = (GLfloat) (1 << (ctx->Const.Max3DTextureLevels - 1)); 3630 break; 3631 case GL_MAX_TEXTURE_STACK_DEPTH: 3632 *params = (GLfloat) MAX_TEXTURE_STACK_DEPTH; 3633 break; 3634 case GL_MAX_VIEWPORT_DIMS: 3635 params[0] = (GLfloat) MAX_WIDTH; 3636 params[1] = (GLfloat) MAX_HEIGHT; 3637 break; 3638 case GL_MODELVIEW_MATRIX: 3639 for (i=0;i<16;i++) { 3640 params[i] = ctx->ModelviewMatrixStack.Top->m[i]; 3641 } 3642 break; 3643 case GL_MODELVIEW_STACK_DEPTH: 3644 *params = (GLfloat) (ctx->ModelviewMatrixStack.Depth + 1); 3645 break; 3646 case GL_NAME_STACK_DEPTH: 3647 *params = (GLfloat) ctx->Select.NameStackDepth; 3648 break; 3649 case GL_NORMALIZE: 3650 *params = (GLfloat) ctx->Transform.Normalize; 3651 break; 3652 case GL_PACK_ALIGNMENT: 3653 *params = (GLfloat) ctx->Pack.Alignment; 3654 break; 3655 case GL_PACK_LSB_FIRST: 3656 *params = (GLfloat) ctx->Pack.LsbFirst; 3657 break; 3658 case GL_PACK_ROW_LENGTH: 3659 *params = (GLfloat) ctx->Pack.RowLength; 3660 break; 3661 case GL_PACK_SKIP_PIXELS: 3662 *params = (GLfloat) ctx->Pack.SkipPixels; 3663 break; 3664 case GL_PACK_SKIP_ROWS: 3665 *params = (GLfloat) ctx->Pack.SkipRows; 3666 break; 3667 case GL_PACK_SWAP_BYTES: 3668 *params = (GLfloat) ctx->Pack.SwapBytes; 3669 break; 3670 case GL_PACK_SKIP_IMAGES_EXT: 3671 *params = (GLfloat) ctx->Pack.SkipImages; 3672 break; 3673 case GL_PACK_IMAGE_HEIGHT_EXT: 3674 *params = (GLfloat) ctx->Pack.ImageHeight; 3675 break; 3676 case GL_PACK_INVERT_MESA: 3677 *params = (GLfloat) ctx->Pack.Invert; 3678 break; 3679 case GL_PERSPECTIVE_CORRECTION_HINT: 3680 *params = ENUM_TO_FLOAT(ctx->Hint.PerspectiveCorrection); 3681 break; 3682 case GL_PIXEL_MAP_A_TO_A_SIZE: 3683 *params = (GLfloat) ctx->Pixel.MapAtoAsize; 3684 break; 3685 case GL_PIXEL_MAP_B_TO_B_SIZE: 3686 *params = (GLfloat) ctx->Pixel.MapBtoBsize; 3687 break; 3688 case GL_PIXEL_MAP_G_TO_G_SIZE: 3689 *params = (GLfloat) ctx->Pixel.MapGtoGsize; 3690 break; 3691 case GL_PIXEL_MAP_I_TO_A_SIZE: 3692 *params = (GLfloat) ctx->Pixel.MapItoAsize; 3693 break; 3694 case GL_PIXEL_MAP_I_TO_B_SIZE: 3695 *params = (GLfloat) ctx->Pixel.MapItoBsize; 3696 break; 3697 case GL_PIXEL_MAP_I_TO_G_SIZE: 3698 *params = (GLfloat) ctx->Pixel.MapItoGsize; 3699 break; 3700 case GL_PIXEL_MAP_I_TO_I_SIZE: 3701 *params = (GLfloat) ctx->Pixel.MapItoIsize; 3702 break; 3703 case GL_PIXEL_MAP_I_TO_R_SIZE: 3704 *params = (GLfloat) ctx->Pixel.MapItoRsize; 3705 break; 3706 case GL_PIXEL_MAP_R_TO_R_SIZE: 3707 *params = (GLfloat) ctx->Pixel.MapRtoRsize; 3708 break; 3709 case GL_PIXEL_MAP_S_TO_S_SIZE: 3710 *params = (GLfloat) ctx->Pixel.MapStoSsize; 3711 break; 3712 case GL_POINT_SIZE: 3713 *params = (GLfloat) ctx->Point.Size; 3714 break; 3715 case GL_POINT_SIZE_GRANULARITY: 3716 *params = (GLfloat) ctx->Const.PointSizeGranularity; 3717 break; 3718 case GL_POINT_SIZE_RANGE: 3719 params[0] = (GLfloat) ctx->Const.MinPointSizeAA; 3720 params[1] = (GLfloat) ctx->Const.MaxPointSizeAA; 3721 break; 3722 case GL_ALIASED_POINT_SIZE_RANGE: 3723 params[0] = (GLfloat) ctx->Const.MinPointSize; 3724 params[1] = (GLfloat) ctx->Const.MaxPointSize; 3725 break; 3726 case GL_POINT_SMOOTH: 3727 *params = (GLfloat) ctx->Point.SmoothFlag; 3728 break; 3729 case GL_POINT_SMOOTH_HINT: 3730 *params = ENUM_TO_FLOAT(ctx->Hint.PointSmooth); 3731 break; 3732 case GL_POINT_SIZE_MIN_EXT: 3733 *params = (GLfloat) (ctx->Point.MinSize); 3734 break; 3735 case GL_POINT_SIZE_MAX_EXT: 3736 *params = (GLfloat) (ctx->Point.MaxSize); 3737 break; 3738 case GL_POINT_FADE_THRESHOLD_SIZE_EXT: 3739 *params = (GLfloat) (ctx->Point.Threshold); 3740 break; 3741 case GL_DISTANCE_ATTENUATION_EXT: 3742 params[0] = (GLfloat) (ctx->Point.Params[0]); 3743 params[1] = (GLfloat) (ctx->Point.Params[1]); 3744 params[2] = (GLfloat) (ctx->Point.Params[2]); 3745 break; 3746 case GL_POLYGON_MODE: 3747 params[0] = ENUM_TO_FLOAT(ctx->Polygon.FrontMode); 3748 params[1] = ENUM_TO_FLOAT(ctx->Polygon.BackMode); 3749 break; 3750#ifdef GL_EXT_polygon_offset 3751 case GL_POLYGON_OFFSET_BIAS_EXT: 3752 *params = ctx->Polygon.OffsetUnits; 3753 break; 3754#endif 3755 case GL_POLYGON_OFFSET_FACTOR: 3756 *params = ctx->Polygon.OffsetFactor; 3757 break; 3758 case GL_POLYGON_OFFSET_UNITS: 3759 *params = ctx->Polygon.OffsetUnits; 3760 break; 3761 case GL_POLYGON_SMOOTH: 3762 *params = (GLfloat) ctx->Polygon.SmoothFlag; 3763 break; 3764 case GL_POLYGON_SMOOTH_HINT: 3765 *params = ENUM_TO_FLOAT(ctx->Hint.PolygonSmooth); 3766 break; 3767 case GL_POLYGON_STIPPLE: 3768 *params = (GLfloat) ctx->Polygon.StippleFlag; 3769 break; 3770 case GL_PROJECTION_MATRIX: 3771 for (i=0;i<16;i++) { 3772 params[i] = ctx->ProjectionMatrixStack.Top->m[i]; 3773 } 3774 break; 3775 case GL_PROJECTION_STACK_DEPTH: 3776 *params = (GLfloat) (ctx->ProjectionMatrixStack.Depth + 1); 3777 break; 3778 case GL_READ_BUFFER: 3779 *params = ENUM_TO_FLOAT(ctx->Pixel.ReadBuffer); 3780 break; 3781 case GL_RED_BIAS: 3782 *params = ctx->Pixel.RedBias; 3783 break; 3784 case GL_RED_BITS: 3785 *params = (GLfloat) ctx->Visual.redBits; 3786 break; 3787 case GL_RED_SCALE: 3788 *params = ctx->Pixel.RedScale; 3789 break; 3790 case GL_RENDER_MODE: 3791 *params = ENUM_TO_FLOAT(ctx->RenderMode); 3792 break; 3793 case GL_RESCALE_NORMAL: 3794 *params = (GLfloat) ctx->Transform.RescaleNormals; 3795 break; 3796 case GL_RGBA_MODE: 3797 *params = (GLfloat) ctx->Visual.rgbMode; 3798 break; 3799 case GL_SCISSOR_BOX: 3800 params[0] = (GLfloat) ctx->Scissor.X; 3801 params[1] = (GLfloat) ctx->Scissor.Y; 3802 params[2] = (GLfloat) ctx->Scissor.Width; 3803 params[3] = (GLfloat) ctx->Scissor.Height; 3804 break; 3805 case GL_SCISSOR_TEST: 3806 *params = (GLfloat) ctx->Scissor.Enabled; 3807 break; 3808 case GL_SELECTION_BUFFER_SIZE: 3809 *params = (GLfloat) ctx->Select.BufferSize; 3810 break; 3811 case GL_SHADE_MODEL: 3812 *params = ENUM_TO_FLOAT(ctx->Light.ShadeModel); 3813 break; 3814 case GL_SHARED_TEXTURE_PALETTE_EXT: 3815 *params = (GLfloat) ctx->Texture.SharedPalette; 3816 break; 3817 case GL_STENCIL_BITS: 3818 *params = (GLfloat) ctx->Visual.stencilBits; 3819 break; 3820 case GL_STENCIL_CLEAR_VALUE: 3821 *params = (GLfloat) ctx->Stencil.Clear; 3822 break; 3823 case GL_STENCIL_FAIL: 3824 *params = ENUM_TO_FLOAT(ctx->Stencil.FailFunc[ctx->Stencil.ActiveFace]); 3825 break; 3826 case GL_STENCIL_FUNC: 3827 *params = ENUM_TO_FLOAT(ctx->Stencil.Function[ctx->Stencil.ActiveFace]); 3828 break; 3829 case GL_STENCIL_PASS_DEPTH_FAIL: 3830 *params = ENUM_TO_FLOAT(ctx->Stencil.ZFailFunc[ctx->Stencil.ActiveFace]); 3831 break; 3832 case GL_STENCIL_PASS_DEPTH_PASS: 3833 *params = ENUM_TO_FLOAT(ctx->Stencil.ZPassFunc[ctx->Stencil.ActiveFace]); 3834 break; 3835 case GL_STENCIL_REF: 3836 *params = (GLfloat) ctx->Stencil.Ref[ctx->Stencil.ActiveFace]; 3837 break; 3838 case GL_STENCIL_TEST: 3839 *params = (GLfloat) ctx->Stencil.Enabled; 3840 break; 3841 case GL_STENCIL_VALUE_MASK: 3842 *params = (GLfloat) ctx->Stencil.ValueMask[ctx->Stencil.ActiveFace]; 3843 break; 3844 case GL_STENCIL_WRITEMASK: 3845 *params = (GLfloat) ctx->Stencil.WriteMask[ctx->Stencil.ActiveFace]; 3846 break; 3847 case GL_STEREO: 3848 *params = (GLfloat) ctx->Visual.stereoMode; 3849 break; 3850 case GL_SUBPIXEL_BITS: 3851 *params = (GLfloat) ctx->Const.SubPixelBits; 3852 break; 3853 case GL_TEXTURE_1D: 3854 *params = _mesa_IsEnabled(GL_TEXTURE_1D) ? 1.0F : 0.0F; 3855 break; 3856 case GL_TEXTURE_2D: 3857 *params = _mesa_IsEnabled(GL_TEXTURE_2D) ? 1.0F : 0.0F; 3858 break; 3859 case GL_TEXTURE_3D: 3860 *params = _mesa_IsEnabled(GL_TEXTURE_3D) ? 1.0F : 0.0F; 3861 break; 3862 case GL_TEXTURE_BINDING_1D: 3863 *params = (GLfloat) textureUnit->Current1D->Name; 3864 break; 3865 case GL_TEXTURE_BINDING_2D: 3866 *params = (GLfloat) textureUnit->Current2D->Name; 3867 break; 3868 case GL_TEXTURE_BINDING_3D: 3869 *params = (GLfloat) textureUnit->Current2D->Name; 3870 break; 3871 case GL_TEXTURE_ENV_COLOR: 3872 params[0] = textureUnit->EnvColor[0]; 3873 params[1] = textureUnit->EnvColor[1]; 3874 params[2] = textureUnit->EnvColor[2]; 3875 params[3] = textureUnit->EnvColor[3]; 3876 break; 3877 case GL_TEXTURE_ENV_MODE: 3878 *params = ENUM_TO_FLOAT(textureUnit->EnvMode); 3879 break; 3880 case GL_TEXTURE_GEN_S: 3881 *params = (textureUnit->TexGenEnabled & S_BIT) ? 1.0F : 0.0F; 3882 break; 3883 case GL_TEXTURE_GEN_T: 3884 *params = (textureUnit->TexGenEnabled & T_BIT) ? 1.0F : 0.0F; 3885 break; 3886 case GL_TEXTURE_GEN_R: 3887 *params = (textureUnit->TexGenEnabled & R_BIT) ? 1.0F : 0.0F; 3888 break; 3889 case GL_TEXTURE_GEN_Q: 3890 *params = (textureUnit->TexGenEnabled & Q_BIT) ? 1.0F : 0.0F; 3891 break; 3892 case GL_TEXTURE_MATRIX: 3893 for (i=0;i<16;i++) { 3894 params[i] = ctx->TextureMatrixStack[texUnit].Top->m[i]; 3895 } 3896 break; 3897 case GL_TEXTURE_STACK_DEPTH: 3898 *params = (GLfloat) (ctx->TextureMatrixStack[texUnit].Depth + 1); 3899 break; 3900 case GL_UNPACK_ALIGNMENT: 3901 *params = (GLfloat) ctx->Unpack.Alignment; 3902 break; 3903 case GL_UNPACK_LSB_FIRST: 3904 *params = (GLfloat) ctx->Unpack.LsbFirst; 3905 break; 3906 case GL_UNPACK_ROW_LENGTH: 3907 *params = (GLfloat) ctx->Unpack.RowLength; 3908 break; 3909 case GL_UNPACK_SKIP_PIXELS: 3910 *params = (GLfloat) ctx->Unpack.SkipPixels; 3911 break; 3912 case GL_UNPACK_SKIP_ROWS: 3913 *params = (GLfloat) ctx->Unpack.SkipRows; 3914 break; 3915 case GL_UNPACK_SWAP_BYTES: 3916 *params = (GLfloat) ctx->Unpack.SwapBytes; 3917 break; 3918 case GL_UNPACK_SKIP_IMAGES_EXT: 3919 *params = (GLfloat) ctx->Unpack.SkipImages; 3920 break; 3921 case GL_UNPACK_IMAGE_HEIGHT_EXT: 3922 *params = (GLfloat) ctx->Unpack.ImageHeight; 3923 break; 3924 case GL_UNPACK_CLIENT_STORAGE_APPLE: 3925 *params = (GLfloat) ctx->Unpack.ClientStorage; 3926 break; 3927 case GL_VIEWPORT: 3928 params[0] = (GLfloat) ctx->Viewport.X; 3929 params[1] = (GLfloat) ctx->Viewport.Y; 3930 params[2] = (GLfloat) ctx->Viewport.Width; 3931 params[3] = (GLfloat) ctx->Viewport.Height; 3932 break; 3933 case GL_ZOOM_X: 3934 *params = (GLfloat) ctx->Pixel.ZoomX; 3935 break; 3936 case GL_ZOOM_Y: 3937 *params = (GLfloat) ctx->Pixel.ZoomY; 3938 break; 3939 case GL_VERTEX_ARRAY: 3940 *params = (GLfloat) ctx->Array.Vertex.Enabled; 3941 break; 3942 case GL_VERTEX_ARRAY_SIZE: 3943 *params = (GLfloat) ctx->Array.Vertex.Size; 3944 break; 3945 case GL_VERTEX_ARRAY_TYPE: 3946 *params = ENUM_TO_FLOAT(ctx->Array.Vertex.Type); 3947 break; 3948 case GL_VERTEX_ARRAY_STRIDE: 3949 *params = (GLfloat) ctx->Array.Vertex.Stride; 3950 break; 3951 case GL_VERTEX_ARRAY_COUNT_EXT: 3952 *params = 0.0; 3953 break; 3954 case GL_NORMAL_ARRAY: 3955 *params = (GLfloat) ctx->Array.Normal.Enabled; 3956 break; 3957 case GL_NORMAL_ARRAY_TYPE: 3958 *params = ENUM_TO_FLOAT(ctx->Array.Normal.Type); 3959 break; 3960 case GL_NORMAL_ARRAY_STRIDE: 3961 *params = (GLfloat) ctx->Array.Normal.Stride; 3962 break; 3963 case GL_NORMAL_ARRAY_COUNT_EXT: 3964 *params = 0.0; 3965 break; 3966 case GL_COLOR_ARRAY: 3967 *params = (GLfloat) ctx->Array.Color.Enabled; 3968 break; 3969 case GL_COLOR_ARRAY_SIZE: 3970 *params = (GLfloat) ctx->Array.Color.Size; 3971 break; 3972 case GL_COLOR_ARRAY_TYPE: 3973 *params = ENUM_TO_FLOAT(ctx->Array.Color.Type); 3974 break; 3975 case GL_COLOR_ARRAY_STRIDE: 3976 *params = (GLfloat) ctx->Array.Color.Stride; 3977 break; 3978 case GL_COLOR_ARRAY_COUNT_EXT: 3979 *params = 0.0; 3980 break; 3981 case GL_INDEX_ARRAY: 3982 *params = (GLfloat) ctx->Array.Index.Enabled; 3983 break; 3984 case GL_INDEX_ARRAY_TYPE: 3985 *params = ENUM_TO_FLOAT(ctx->Array.Index.Type); 3986 break; 3987 case GL_INDEX_ARRAY_STRIDE: 3988 *params = (GLfloat) ctx->Array.Index.Stride; 3989 break; 3990 case GL_INDEX_ARRAY_COUNT_EXT: 3991 *params = 0.0; 3992 break; 3993 case GL_TEXTURE_COORD_ARRAY: 3994 *params = (GLfloat) ctx->Array.TexCoord[texUnit].Enabled; 3995 break; 3996 case GL_TEXTURE_COORD_ARRAY_SIZE: 3997 *params = (GLfloat) ctx->Array.TexCoord[texUnit].Size; 3998 break; 3999 case GL_TEXTURE_COORD_ARRAY_TYPE: 4000 *params = ENUM_TO_FLOAT(ctx->Array.TexCoord[texUnit].Type); 4001 break; 4002 case GL_TEXTURE_COORD_ARRAY_STRIDE: 4003 *params = (GLfloat) ctx->Array.TexCoord[texUnit].Stride; 4004 break; 4005 case GL_TEXTURE_COORD_ARRAY_COUNT_EXT: 4006 *params = 0.0; 4007 break; 4008 case GL_EDGE_FLAG_ARRAY: 4009 *params = (GLfloat) ctx->Array.EdgeFlag.Enabled; 4010 break; 4011 case GL_EDGE_FLAG_ARRAY_STRIDE: 4012 *params = (GLfloat) ctx->Array.EdgeFlag.Stride; 4013 break; 4014 case GL_EDGE_FLAG_ARRAY_COUNT_EXT: 4015 *params = 0.0; 4016 break; 4017 4018 /* GL_ARB_multitexture */ 4019 case GL_MAX_TEXTURE_UNITS_ARB: 4020 CHECK_EXTENSION_F(ARB_multitexture, pname); 4021 *params = (GLfloat) MIN2(ctx->Const.MaxTextureImageUnits, 4022 ctx->Const.MaxTextureCoordUnits); 4023 break; 4024 case GL_ACTIVE_TEXTURE_ARB: 4025 CHECK_EXTENSION_F(ARB_multitexture, pname); 4026 *params = (GLfloat) (GL_TEXTURE0_ARB + ctx->Texture.CurrentUnit); 4027 break; 4028 case GL_CLIENT_ACTIVE_TEXTURE_ARB: 4029 CHECK_EXTENSION_F(ARB_multitexture, pname); 4030 *params = (GLfloat) (GL_TEXTURE0_ARB + ctx->Array.ActiveTexture); 4031 break; 4032 4033 /* GL_ARB_texture_cube_map */ 4034 case GL_TEXTURE_CUBE_MAP_ARB: 4035 CHECK_EXTENSION_F(ARB_texture_cube_map, pname); 4036 *params = (GLfloat) _mesa_IsEnabled(GL_TEXTURE_CUBE_MAP_ARB); 4037 break; 4038 case GL_TEXTURE_BINDING_CUBE_MAP_ARB: 4039 CHECK_EXTENSION_F(ARB_texture_cube_map, pname); 4040 *params = (GLfloat) textureUnit->CurrentCubeMap->Name; 4041 break; 4042 case GL_MAX_CUBE_MAP_TEXTURE_SIZE_ARB: 4043 CHECK_EXTENSION_F(ARB_texture_cube_map, pname); 4044 *params = (GLfloat) (1 << (ctx->Const.MaxCubeTextureLevels - 1)); 4045 break; 4046 4047 /* GL_ARB_texture_compression */ 4048 case GL_TEXTURE_COMPRESSION_HINT_ARB: 4049 CHECK_EXTENSION_F(ARB_texture_compression, pname); 4050 *params = (GLfloat) ctx->Hint.TextureCompression; 4051 break; 4052 case GL_NUM_COMPRESSED_TEXTURE_FORMATS_ARB: 4053 CHECK_EXTENSION_F(ARB_texture_compression, pname); 4054 *params = (GLfloat) _mesa_get_compressed_formats(ctx, NULL); 4055 break; 4056 case GL_COMPRESSED_TEXTURE_FORMATS_ARB: 4057 CHECK_EXTENSION_F(ARB_texture_compression, pname); 4058 { 4059 GLint formats[100]; 4060 GLuint i, n; 4061 n = _mesa_get_compressed_formats(ctx, formats); 4062 for (i = 0; i < n; i++) 4063 params[i] = (GLfloat) formats[i]; 4064 } 4065 break; 4066 4067 /* GL_EXT_compiled_vertex_array */ 4068 case GL_ARRAY_ELEMENT_LOCK_FIRST_EXT: 4069 CHECK_EXTENSION_F(EXT_compiled_vertex_array, pname); 4070 *params = (GLfloat) ctx->Array.LockFirst; 4071 break; 4072 case GL_ARRAY_ELEMENT_LOCK_COUNT_EXT: 4073 CHECK_EXTENSION_F(EXT_compiled_vertex_array, pname); 4074 *params = (GLfloat) ctx->Array.LockCount; 4075 break; 4076 4077 /* GL_ARB_transpose_matrix */ 4078 case GL_TRANSPOSE_COLOR_MATRIX_ARB: 4079 _math_transposef(params, ctx->ColorMatrixStack.Top->m); 4080 break; 4081 case GL_TRANSPOSE_MODELVIEW_MATRIX_ARB: 4082 _math_transposef(params, ctx->ModelviewMatrixStack.Top->m); 4083 break; 4084 case GL_TRANSPOSE_PROJECTION_MATRIX_ARB: 4085 _math_transposef(params, ctx->ProjectionMatrixStack.Top->m); 4086 break; 4087 case GL_TRANSPOSE_TEXTURE_MATRIX_ARB: 4088 _math_transposef(params, ctx->TextureMatrixStack[texUnit].Top->m); 4089 break; 4090 4091 /* GL_HP_occlusion_test */ 4092 case GL_OCCLUSION_TEST_HP: 4093 CHECK_EXTENSION_F(HP_occlusion_test, pname); 4094 *params = (GLfloat) ctx->Depth.OcclusionTest; 4095 break; 4096 case GL_OCCLUSION_TEST_RESULT_HP: 4097 CHECK_EXTENSION_F(HP_occlusion_test, pname); 4098 if (ctx->Depth.OcclusionTest) 4099 *params = (GLfloat) ctx->OcclusionResult; 4100 else 4101 *params = (GLfloat) ctx->OcclusionResultSaved; 4102 /* reset flag now */ 4103 ctx->OcclusionResult = GL_FALSE; 4104 ctx->OcclusionResultSaved = GL_FALSE; 4105 break; 4106 4107 /* GL_SGIS_pixel_texture */ 4108 case GL_PIXEL_TEXTURE_SGIS: 4109 *params = (GLfloat) ctx->Pixel.PixelTextureEnabled; 4110 break; 4111 4112 /* GL_SGIX_pixel_texture */ 4113 case GL_PIXEL_TEX_GEN_SGIX: 4114 *params = (GLfloat) ctx->Pixel.PixelTextureEnabled; 4115 break; 4116 case GL_PIXEL_TEX_GEN_MODE_SGIX: 4117 *params = (GLfloat) pixel_texgen_mode(ctx); 4118 break; 4119 4120 /* GL_SGI_color_matrix (also in 1.2 imaging) */ 4121 case GL_COLOR_MATRIX_SGI: 4122 for (i=0;i<16;i++) { 4123 params[i] = ctx->ColorMatrixStack.Top->m[i]; 4124 } 4125 break; 4126 case GL_COLOR_MATRIX_STACK_DEPTH_SGI: 4127 *params = (GLfloat) (ctx->ColorMatrixStack.Depth + 1); 4128 break; 4129 case GL_MAX_COLOR_MATRIX_STACK_DEPTH_SGI: 4130 *params = (GLfloat) MAX_COLOR_STACK_DEPTH; 4131 break; 4132 case GL_POST_COLOR_MATRIX_RED_SCALE_SGI: 4133 *params = ctx->Pixel.PostColorMatrixScale[0]; 4134 break; 4135 case GL_POST_COLOR_MATRIX_GREEN_SCALE_SGI: 4136 *params = ctx->Pixel.PostColorMatrixScale[1]; 4137 break; 4138 case GL_POST_COLOR_MATRIX_BLUE_SCALE_SGI: 4139 *params = ctx->Pixel.PostColorMatrixScale[2]; 4140 break; 4141 case GL_POST_COLOR_MATRIX_ALPHA_SCALE_SGI: 4142 *params = ctx->Pixel.PostColorMatrixScale[3]; 4143 break; 4144 case GL_POST_COLOR_MATRIX_RED_BIAS_SGI: 4145 *params = ctx->Pixel.PostColorMatrixBias[0]; 4146 break; 4147 case GL_POST_COLOR_MATRIX_GREEN_BIAS_SGI: 4148 *params = ctx->Pixel.PostColorMatrixBias[1]; 4149 break; 4150 case GL_POST_COLOR_MATRIX_BLUE_BIAS_SGI: 4151 *params = ctx->Pixel.PostColorMatrixBias[2]; 4152 break; 4153 case GL_POST_COLOR_MATRIX_ALPHA_BIAS_SGI: 4154 *params = ctx->Pixel.PostColorMatrixBias[3]; 4155 break; 4156 4157 /* GL_EXT_convolution (also in 1.2 imaging) */ 4158 case GL_CONVOLUTION_1D_EXT: 4159 CHECK_EXTENSION_F(EXT_convolution, pname); 4160 *params = (GLfloat) ctx->Pixel.Convolution1DEnabled; 4161 break; 4162 case GL_CONVOLUTION_2D: 4163 CHECK_EXTENSION_F(EXT_convolution, pname); 4164 *params = (GLfloat) ctx->Pixel.Convolution2DEnabled; 4165 break; 4166 case GL_SEPARABLE_2D: 4167 CHECK_EXTENSION_F(EXT_convolution, pname); 4168 *params = (GLfloat) ctx->Pixel.Separable2DEnabled; 4169 break; 4170 case GL_POST_CONVOLUTION_RED_SCALE_EXT: 4171 CHECK_EXTENSION_F(EXT_convolution, pname); 4172 *params = ctx->Pixel.PostConvolutionScale[0]; 4173 break; 4174 case GL_POST_CONVOLUTION_GREEN_SCALE_EXT: 4175 CHECK_EXTENSION_F(EXT_convolution, pname); 4176 *params = ctx->Pixel.PostConvolutionScale[1]; 4177 break; 4178 case GL_POST_CONVOLUTION_BLUE_SCALE_EXT: 4179 CHECK_EXTENSION_F(EXT_convolution, pname); 4180 *params = ctx->Pixel.PostConvolutionScale[2]; 4181 break; 4182 case GL_POST_CONVOLUTION_ALPHA_SCALE_EXT: 4183 CHECK_EXTENSION_F(EXT_convolution, pname); 4184 *params = ctx->Pixel.PostConvolutionScale[3]; 4185 break; 4186 case GL_POST_CONVOLUTION_RED_BIAS_EXT: 4187 CHECK_EXTENSION_F(EXT_convolution, pname); 4188 *params = ctx->Pixel.PostConvolutionBias[0]; 4189 break; 4190 case GL_POST_CONVOLUTION_GREEN_BIAS_EXT: 4191 CHECK_EXTENSION_F(EXT_convolution, pname); 4192 *params = ctx->Pixel.PostConvolutionBias[1]; 4193 break; 4194 case GL_POST_CONVOLUTION_BLUE_BIAS_EXT: 4195 CHECK_EXTENSION_F(EXT_convolution, pname); 4196 *params = ctx->Pixel.PostConvolutionBias[2]; 4197 break; 4198 case GL_POST_CONVOLUTION_ALPHA_BIAS_EXT: 4199 CHECK_EXTENSION_F(EXT_convolution, pname); 4200 *params = ctx->Pixel.PostConvolutionBias[2]; 4201 break; 4202 4203 /* GL_EXT_histogram (also in 1.2 imaging) */ 4204 case GL_HISTOGRAM: 4205 CHECK_EXTENSION_F(EXT_histogram, pname); 4206 *params = (GLfloat) ctx->Pixel.HistogramEnabled; 4207 break; 4208 case GL_MINMAX: 4209 CHECK_EXTENSION_F(EXT_histogram, pname); 4210 *params = (GLfloat) ctx->Pixel.MinMaxEnabled; 4211 break; 4212 4213 /* GL_SGI_color_table (also in 1.2 imaging */ 4214 case GL_COLOR_TABLE_SGI: 4215 *params = (GLfloat) ctx->Pixel.ColorTableEnabled; 4216 break; 4217 case GL_POST_CONVOLUTION_COLOR_TABLE_SGI: 4218 *params = (GLfloat) ctx->Pixel.PostConvolutionColorTableEnabled; 4219 break; 4220 case GL_POST_COLOR_MATRIX_COLOR_TABLE_SGI: 4221 *params = (GLfloat) ctx->Pixel.PostColorMatrixColorTableEnabled; 4222 break; 4223 4224 /* GL_SGI_texture_color_table */ 4225 case GL_TEXTURE_COLOR_TABLE_SGI: 4226 CHECK_EXTENSION_F(SGI_texture_color_table, pname); 4227 *params = (GLfloat) textureUnit->ColorTableEnabled; 4228 break; 4229 4230 /* GL_EXT_secondary_color */ 4231 case GL_COLOR_SUM_EXT: 4232 CHECK_EXTENSION_F(EXT_secondary_color, pname); 4233 *params = (GLfloat) ctx->Fog.ColorSumEnabled; 4234 break; 4235 case GL_CURRENT_SECONDARY_COLOR_EXT: 4236 CHECK_EXTENSION_F(EXT_secondary_color, pname); 4237 FLUSH_CURRENT(ctx, 0); 4238 params[0] = ctx->Current.Attrib[VERT_ATTRIB_COLOR1][0]; 4239 params[1] = ctx->Current.Attrib[VERT_ATTRIB_COLOR1][1]; 4240 params[2] = ctx->Current.Attrib[VERT_ATTRIB_COLOR1][2]; 4241 params[3] = ctx->Current.Attrib[VERT_ATTRIB_COLOR1][3]; 4242 break; 4243 case GL_SECONDARY_COLOR_ARRAY_EXT: 4244 CHECK_EXTENSION_F(EXT_secondary_color, pname); 4245 *params = (GLfloat) ctx->Array.SecondaryColor.Enabled; 4246 break; 4247 case GL_SECONDARY_COLOR_ARRAY_TYPE_EXT: 4248 CHECK_EXTENSION_F(EXT_secondary_color, pname); 4249 *params = (GLfloat) ctx->Array.SecondaryColor.Type; 4250 break; 4251 case GL_SECONDARY_COLOR_ARRAY_STRIDE_EXT: 4252 CHECK_EXTENSION_F(EXT_secondary_color, pname); 4253 *params = (GLfloat) ctx->Array.SecondaryColor.Stride; 4254 break; 4255 case GL_SECONDARY_COLOR_ARRAY_SIZE_EXT: 4256 CHECK_EXTENSION_F(EXT_secondary_color, pname); 4257 *params = (GLfloat) ctx->Array.SecondaryColor.Size; 4258 break; 4259 4260 /* GL_EXT_fog_coord */ 4261 case GL_CURRENT_FOG_COORDINATE_EXT: 4262 CHECK_EXTENSION_F(EXT_fog_coord, pname); 4263 FLUSH_CURRENT(ctx, 0); 4264 *params = (GLfloat) ctx->Current.Attrib[VERT_ATTRIB_FOG][0]; 4265 break; 4266 case GL_FOG_COORDINATE_ARRAY_EXT: 4267 CHECK_EXTENSION_F(EXT_fog_coord, pname); 4268 *params = (GLfloat) ctx->Array.FogCoord.Enabled; 4269 break; 4270 case GL_FOG_COORDINATE_ARRAY_TYPE_EXT: 4271 CHECK_EXTENSION_F(EXT_fog_coord, pname); 4272 *params = (GLfloat) ctx->Array.FogCoord.Type; 4273 break; 4274 case GL_FOG_COORDINATE_ARRAY_STRIDE_EXT: 4275 CHECK_EXTENSION_F(EXT_fog_coord, pname); 4276 *params = (GLfloat) ctx->Array.FogCoord.Stride; 4277 break; 4278 case GL_FOG_COORDINATE_SOURCE_EXT: 4279 CHECK_EXTENSION_F(EXT_fog_coord, pname); 4280 *params = (GLfloat) ctx->Fog.FogCoordinateSource; 4281 break; 4282 4283 /* GL_EXT_texture_lod_bias */ 4284 case GL_MAX_TEXTURE_LOD_BIAS_EXT: 4285 *params = ctx->Const.MaxTextureLodBias; 4286 break; 4287 4288 /* GL_EXT_texture_filter_anisotropic */ 4289 case GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT: 4290 CHECK_EXTENSION_F(EXT_texture_filter_anisotropic, pname); 4291 *params = ctx->Const.MaxTextureMaxAnisotropy; 4292 break; 4293 4294 /* GL_ARB_multisample */ 4295 case GL_MULTISAMPLE_ARB: 4296 CHECK_EXTENSION_F(ARB_multisample, pname); 4297 *params = (GLfloat) ctx->Multisample.Enabled; 4298 break; 4299 case GL_SAMPLE_ALPHA_TO_COVERAGE_ARB: 4300 CHECK_EXTENSION_F(ARB_multisample, pname); 4301 *params = (GLfloat) ctx->Multisample.SampleAlphaToCoverage; 4302 break; 4303 case GL_SAMPLE_ALPHA_TO_ONE_ARB: 4304 CHECK_EXTENSION_F(ARB_multisample, pname); 4305 *params = (GLfloat) ctx->Multisample.SampleAlphaToOne; 4306 break; 4307 case GL_SAMPLE_COVERAGE_ARB: 4308 CHECK_EXTENSION_F(ARB_multisample, pname); 4309 *params = (GLfloat) ctx->Multisample.SampleCoverage; 4310 break; 4311 case GL_SAMPLE_COVERAGE_VALUE_ARB: 4312 CHECK_EXTENSION_F(ARB_multisample, pname); 4313 *params = ctx->Multisample.SampleCoverageValue; 4314 break; 4315 case GL_SAMPLE_COVERAGE_INVERT_ARB: 4316 CHECK_EXTENSION_F(ARB_multisample, pname); 4317 *params = (GLfloat) ctx->Multisample.SampleCoverageInvert; 4318 break; 4319 case GL_SAMPLE_BUFFERS_ARB: 4320 CHECK_EXTENSION_F(ARB_multisample, pname); 4321 *params = 0.0; /* XXX fix someday */ 4322 break; 4323 case GL_SAMPLES_ARB: 4324 CHECK_EXTENSION_F(ARB_multisample, pname); 4325 *params = 0.0; /* XXX fix someday */ 4326 break; 4327 4328 /* GL_IBM_rasterpos_clip */ 4329 case GL_RASTER_POSITION_UNCLIPPED_IBM: 4330 CHECK_EXTENSION_F(IBM_rasterpos_clip, pname); 4331 *params = (GLfloat) ctx->Transform.RasterPositionUnclipped; 4332 break; 4333 4334 /* GL_NV_point_sprite */ 4335 case GL_POINT_SPRITE_NV: 4336 CHECK_EXTENSION_F(NV_point_sprite, pname); 4337 *params = (GLfloat) ctx->Point.PointSprite; 4338 break; 4339 case GL_POINT_SPRITE_R_MODE_NV: 4340 CHECK_EXTENSION_F(NV_point_sprite, pname); 4341 *params = (GLfloat) ctx->Point.SpriteRMode; 4342 break; 4343 4344 /* GL_SGIS_generate_mipmap */ 4345 case GL_GENERATE_MIPMAP_HINT_SGIS: 4346 CHECK_EXTENSION_F(SGIS_generate_mipmap, pname); 4347 *params = (GLfloat) ctx->Hint.GenerateMipmap; 4348 break; 4349 4350#if FEATURE_NV_vertex_program 4351 case GL_VERTEX_PROGRAM_NV: 4352 CHECK_EXTENSION_F(NV_vertex_program, pname); 4353 *params = (GLfloat) ctx->VertexProgram.Enabled; 4354 break; 4355 case GL_VERTEX_PROGRAM_POINT_SIZE_NV: 4356 CHECK_EXTENSION_F(NV_vertex_program, pname); 4357 *params = (GLfloat) ctx->VertexProgram.PointSizeEnabled; 4358 break; 4359 case GL_VERTEX_PROGRAM_TWO_SIDE_NV: 4360 CHECK_EXTENSION_F(NV_vertex_program, pname); 4361 *params = (GLfloat) ctx->VertexProgram.TwoSideEnabled; 4362 break; 4363 case GL_MAX_TRACK_MATRIX_STACK_DEPTH_NV: 4364 CHECK_EXTENSION_F(NV_vertex_program, pname); 4365 *params = (GLfloat) ctx->Const.MaxProgramMatrixStackDepth; 4366 break; 4367 case GL_MAX_TRACK_MATRICES_NV: 4368 CHECK_EXTENSION_F(NV_vertex_program, pname); 4369 *params = (GLfloat) ctx->Const.MaxProgramMatrices; 4370 break; 4371 case GL_CURRENT_MATRIX_STACK_DEPTH_NV: 4372 CHECK_EXTENSION_F(NV_vertex_program, pname); 4373 *params = (GLfloat) ctx->CurrentStack->Depth + 1; 4374 break; 4375 case GL_CURRENT_MATRIX_NV: 4376 CHECK_EXTENSION_F(NV_vertex_program, pname); 4377 for (i = 0; i < 16; i++) 4378 params[i] = ctx->CurrentStack->Top->m[i]; 4379 break; 4380 case GL_VERTEX_PROGRAM_BINDING_NV: 4381 CHECK_EXTENSION_F(NV_vertex_program, pname); 4382 if (ctx->VertexProgram.Current) 4383 *params = (GLfloat) ctx->VertexProgram.Current->Base.Id; 4384 else 4385 *params = 0.0; 4386 break; 4387 case GL_PROGRAM_ERROR_POSITION_NV: 4388 CHECK_EXTENSION_F(NV_vertex_program, pname); 4389 *params = (GLfloat) ctx->Program.ErrorPos; 4390 break; 4391 case GL_VERTEX_ATTRIB_ARRAY0_NV: 4392 case GL_VERTEX_ATTRIB_ARRAY1_NV: 4393 case GL_VERTEX_ATTRIB_ARRAY2_NV: 4394 case GL_VERTEX_ATTRIB_ARRAY3_NV: 4395 case GL_VERTEX_ATTRIB_ARRAY4_NV: 4396 case GL_VERTEX_ATTRIB_ARRAY5_NV: 4397 case GL_VERTEX_ATTRIB_ARRAY6_NV: 4398 case GL_VERTEX_ATTRIB_ARRAY7_NV: 4399 case GL_VERTEX_ATTRIB_ARRAY8_NV: 4400 case GL_VERTEX_ATTRIB_ARRAY9_NV: 4401 case GL_VERTEX_ATTRIB_ARRAY10_NV: 4402 case GL_VERTEX_ATTRIB_ARRAY11_NV: 4403 case GL_VERTEX_ATTRIB_ARRAY12_NV: 4404 case GL_VERTEX_ATTRIB_ARRAY13_NV: 4405 case GL_VERTEX_ATTRIB_ARRAY14_NV: 4406 case GL_VERTEX_ATTRIB_ARRAY15_NV: 4407 CHECK_EXTENSION_F(NV_vertex_program, pname); 4408 { 4409 GLuint n = (GLuint) pname - GL_VERTEX_ATTRIB_ARRAY0_NV; 4410 *params = (GLfloat) ctx->Array.VertexAttrib[n].Enabled; 4411 } 4412 break; 4413 case GL_MAP1_VERTEX_ATTRIB0_4_NV: 4414 case GL_MAP1_VERTEX_ATTRIB1_4_NV: 4415 case GL_MAP1_VERTEX_ATTRIB2_4_NV: 4416 case GL_MAP1_VERTEX_ATTRIB3_4_NV: 4417 case GL_MAP1_VERTEX_ATTRIB4_4_NV: 4418 case GL_MAP1_VERTEX_ATTRIB5_4_NV: 4419 case GL_MAP1_VERTEX_ATTRIB6_4_NV: 4420 case GL_MAP1_VERTEX_ATTRIB7_4_NV: 4421 case GL_MAP1_VERTEX_ATTRIB8_4_NV: 4422 case GL_MAP1_VERTEX_ATTRIB9_4_NV: 4423 case GL_MAP1_VERTEX_ATTRIB10_4_NV: 4424 case GL_MAP1_VERTEX_ATTRIB11_4_NV: 4425 case GL_MAP1_VERTEX_ATTRIB12_4_NV: 4426 case GL_MAP1_VERTEX_ATTRIB13_4_NV: 4427 case GL_MAP1_VERTEX_ATTRIB14_4_NV: 4428 case GL_MAP1_VERTEX_ATTRIB15_4_NV: 4429 CHECK_EXTENSION_F(NV_vertex_program, pname); 4430 { 4431 GLuint n = (GLuint) pname - GL_MAP1_VERTEX_ATTRIB0_4_NV; 4432 *params = (GLfloat) ctx->Eval.Map1Attrib[n]; 4433 } 4434 break; 4435 case GL_MAP2_VERTEX_ATTRIB0_4_NV: 4436 case GL_MAP2_VERTEX_ATTRIB1_4_NV: 4437 case GL_MAP2_VERTEX_ATTRIB2_4_NV: 4438 case GL_MAP2_VERTEX_ATTRIB3_4_NV: 4439 case GL_MAP2_VERTEX_ATTRIB4_4_NV: 4440 case GL_MAP2_VERTEX_ATTRIB5_4_NV: 4441 case GL_MAP2_VERTEX_ATTRIB6_4_NV: 4442 case GL_MAP2_VERTEX_ATTRIB7_4_NV: 4443 case GL_MAP2_VERTEX_ATTRIB8_4_NV: 4444 case GL_MAP2_VERTEX_ATTRIB9_4_NV: 4445 case GL_MAP2_VERTEX_ATTRIB10_4_NV: 4446 case GL_MAP2_VERTEX_ATTRIB11_4_NV: 4447 case GL_MAP2_VERTEX_ATTRIB12_4_NV: 4448 case GL_MAP2_VERTEX_ATTRIB13_4_NV: 4449 case GL_MAP2_VERTEX_ATTRIB14_4_NV: 4450 case GL_MAP2_VERTEX_ATTRIB15_4_NV: 4451 CHECK_EXTENSION_F(NV_vertex_program, pname); 4452 { 4453 GLuint n = (GLuint) pname - GL_MAP2_VERTEX_ATTRIB0_4_NV; 4454 *params = (GLfloat) ctx->Eval.Map2Attrib[n]; 4455 } 4456 break; 4457#endif /* FEATURE_NV_vertex_program */ 4458 4459#if FEATURE_NV_fragment_program 4460 case GL_FRAGMENT_PROGRAM_NV: 4461 CHECK_EXTENSION_F(NV_fragment_program, pname); 4462 *params = (GLfloat) ctx->FragmentProgram.Enabled; 4463 break; 4464 case GL_MAX_TEXTURE_COORDS_NV: 4465 CHECK_EXTENSION_F(NV_fragment_program, pname); 4466 *params = (GLfloat) ctx->Const.MaxTextureCoordUnits; 4467 break; 4468 case GL_MAX_TEXTURE_IMAGE_UNITS_NV: 4469 CHECK_EXTENSION_F(NV_fragment_program, pname); 4470 *params = (GLfloat) ctx->Const.MaxTextureImageUnits; 4471 break; 4472 case GL_FRAGMENT_PROGRAM_BINDING_NV: 4473 CHECK_EXTENSION_F(NV_fragment_program, pname); 4474 if (ctx->FragmentProgram.Current) 4475 *params = (GLfloat) ctx->FragmentProgram.Current->Base.Id; 4476 else 4477 *params = 0.0; 4478 break; 4479 case GL_MAX_FRAGMENT_PROGRAM_LOCAL_PARAMETERS_NV: 4480 CHECK_EXTENSION_F(NV_fragment_program, pname); 4481 *params = (GLfloat) MAX_NV_FRAGMENT_PROGRAM_PARAMS; 4482 break; 4483#endif /* FEATURE_NV_fragment_program */ 4484 4485 /* GL_NV_texture_rectangle */ 4486 case GL_TEXTURE_RECTANGLE_NV: 4487 CHECK_EXTENSION_F(NV_texture_rectangle, pname); 4488 *params = (GLfloat) _mesa_IsEnabled(GL_TEXTURE_RECTANGLE_NV); 4489 break; 4490 case GL_TEXTURE_BINDING_RECTANGLE_NV: 4491 CHECK_EXTENSION_F(NV_texture_rectangle, pname); 4492 *params = (GLfloat) textureUnit->CurrentRect->Name; 4493 break; 4494 case GL_MAX_RECTANGLE_TEXTURE_SIZE_NV: 4495 CHECK_EXTENSION_F(NV_texture_rectangle, pname); 4496 *params = (GLfloat) ctx->Const.MaxTextureRectSize; 4497 break; 4498 4499 /* GL_EXT_stencil_two_side */ 4500 case GL_STENCIL_TEST_TWO_SIDE_EXT: 4501 CHECK_EXTENSION_F(EXT_stencil_two_side, pname); 4502 *params = (GLfloat) ctx->Stencil.TestTwoSide; 4503 break; 4504 case GL_ACTIVE_STENCIL_FACE_EXT: 4505 CHECK_EXTENSION_F(EXT_stencil_two_side, pname); 4506 *params = (GLfloat) (ctx->Stencil.ActiveFace ? GL_BACK : GL_FRONT); 4507 break; 4508 4509 /* GL_NV_light_max_exponent */ 4510 case GL_MAX_SHININESS_NV: 4511 *params = ctx->Const.MaxShininess; 4512 break; 4513 case GL_MAX_SPOT_EXPONENT_NV: 4514 *params = ctx->Const.MaxSpotExponent; 4515 break; 4516 4517#if FEATURE_ARB_vertex_buffer_object 4518 case GL_ARRAY_BUFFER_BINDING_ARB: 4519 CHECK_EXTENSION_F(ARB_vertex_buffer_object, pname); 4520 *params = (GLfloat) ctx->Array.ArrayBufferBinding; 4521 break; 4522 case GL_VERTEX_ARRAY_BUFFER_BINDING_ARB: 4523 CHECK_EXTENSION_F(ARB_vertex_buffer_object, pname); 4524 *params = (GLfloat) ctx->Array.VertexArrayBufferBinding; 4525 break; 4526 case GL_NORMAL_ARRAY_BUFFER_BINDING_ARB: 4527 CHECK_EXTENSION_F(ARB_vertex_buffer_object, pname); 4528 *params = (GLfloat) ctx->Array.NormalArrayBufferBinding; 4529 break; 4530 case GL_COLOR_ARRAY_BUFFER_BINDING_ARB: 4531 CHECK_EXTENSION_F(ARB_vertex_buffer_object, pname); 4532 *params = (GLfloat) ctx->Array.ColorArrayBufferBinding; 4533 break; 4534 case GL_INDEX_ARRAY_BUFFER_BINDING_ARB: 4535 CHECK_EXTENSION_F(ARB_vertex_buffer_object, pname); 4536 *params = (GLfloat) ctx->Array.IndexArrayBufferBinding; 4537 break; 4538 case GL_TEXTURE_COORD_ARRAY_BUFFER_BINDING_ARB: 4539 CHECK_EXTENSION_F(ARB_vertex_buffer_object, pname); 4540 *params = (GLfloat) ctx->Array.TextureArrayBufferBinding; 4541 break; 4542 case GL_EDGE_FLAG_ARRAY_BUFFER_BINDING_ARB: 4543 CHECK_EXTENSION_F(ARB_vertex_buffer_object, pname); 4544 *params = (GLfloat) ctx->Array.EdgeFlagArrayBufferBinding; 4545 break; 4546 case GL_SECONDARY_COLOR_ARRAY_BUFFER_BINDING_ARB: 4547 CHECK_EXTENSION_F(ARB_vertex_buffer_object, pname); 4548 *params = (GLfloat) ctx->Array.SecondaryColorArrayBufferBinding; 4549 break; 4550 case GL_FOG_COORDINATE_ARRAY_BUFFER_BINDING_ARB: 4551 CHECK_EXTENSION_F(ARB_vertex_buffer_object, pname); 4552 *params = (GLfloat) ctx->Array.FogCoordArrayBufferBinding; 4553 break; 4554 case GL_WEIGHT_ARRAY_BUFFER_BINDING_ARB: 4555 CHECK_EXTENSION_F(ARB_vertex_buffer_object, pname); 4556 *params = (GLfloat) ctx->Array.WeightArrayBufferBinding; 4557 break; 4558 case GL_ELEMENT_ARRAY_BUFFER_BINDING_ARB: 4559 CHECK_EXTENSION_F(ARB_vertex_buffer_object, pname); 4560 *params = (GLfloat) ctx->Array.ElementArrayBufferBinding; 4561 break; 4562#endif 4563 4564#if FEATURE_ARB_fragment_program 4565 case GL_FRAGMENT_PROGRAM_ARB: 4566 CHECK_EXTENSION_F(ARB_fragment_program, pname); 4567 *params = (GLfloat) ctx->FragmentProgram.Enabled; 4568 break; 4569 case GL_TRANSPOSE_CURRENT_MATRIX_ARB: 4570 CHECK_EXTENSION_F(ARB_fragment_program, pname); 4571 params[0] = ctx->CurrentStack->Top->m[0]; 4572 params[1] = ctx->CurrentStack->Top->m[4]; 4573 params[2] = ctx->CurrentStack->Top->m[8]; 4574 params[3] = ctx->CurrentStack->Top->m[12]; 4575 params[4] = ctx->CurrentStack->Top->m[1]; 4576 params[5] = ctx->CurrentStack->Top->m[5]; 4577 params[6] = ctx->CurrentStack->Top->m[9]; 4578 params[7] = ctx->CurrentStack->Top->m[13]; 4579 params[8] = ctx->CurrentStack->Top->m[2]; 4580 params[9] = ctx->CurrentStack->Top->m[6]; 4581 params[10] = ctx->CurrentStack->Top->m[10]; 4582 params[11] = ctx->CurrentStack->Top->m[14]; 4583 params[12] = ctx->CurrentStack->Top->m[3]; 4584 params[13] = ctx->CurrentStack->Top->m[7]; 4585 params[14] = ctx->CurrentStack->Top->m[11]; 4586 params[15] = ctx->CurrentStack->Top->m[15]; 4587 break; 4588 /* Remaining ARB_fragment_program queries alias with 4589 * the GL_NV_fragment_program queries. 4590 */ 4591#endif 4592 4593 /* GL_EXT_depth_bounds_test */ 4594 case GL_DEPTH_BOUNDS_TEST_EXT: 4595 CHECK_EXTENSION_F(EXT_depth_bounds_test, pname); 4596 params[0] = (GLfloat) ctx->Depth.BoundsTest; 4597 break; 4598 case GL_DEPTH_BOUNDS_EXT: 4599 CHECK_EXTENSION_F(EXT_depth_bounds_test, pname); 4600 params[0] = ctx->Depth.BoundsMin; 4601 params[1] = ctx->Depth.BoundsMax; 4602 break; 4603 4604 default: 4605 _mesa_error(ctx, GL_INVALID_ENUM, "glGetFloatv(0x%x)", pname); 4606 } 4607} 4608 4609 4610void 4611_mesa_GetIntegerv( GLenum pname, GLint *params ) 4612{ 4613 GET_CURRENT_CONTEXT(ctx); 4614 GLuint i; 4615 GLuint texUnit = ctx->Texture.CurrentUnit; 4616 const struct gl_texture_unit *textureUnit = &ctx->Texture.Unit[texUnit]; 4617 ASSERT_OUTSIDE_BEGIN_END(ctx); 4618 4619 if (!params) 4620 return; 4621 4622 /* We need this in order to get correct results for 4623 * GL_OCCLUSION_TEST_RESULT_HP. There might be other important cases. 4624 */ 4625 FLUSH_VERTICES(ctx, 0); 4626 4627 if (MESA_VERBOSE & VERBOSE_API) 4628 _mesa_debug(ctx, "glGetIntegerv %s\n", _mesa_lookup_enum_by_nr(pname)); 4629 4630 if (ctx->Driver.GetIntegerv 4631 && (*ctx->Driver.GetIntegerv)(ctx, pname, params)) 4632 return; 4633 4634 switch (pname) { 4635 case GL_ACCUM_RED_BITS: 4636 *params = (GLint) ctx->Visual.accumRedBits; 4637 break; 4638 case GL_ACCUM_GREEN_BITS: 4639 *params = (GLint) ctx->Visual.accumGreenBits; 4640 break; 4641 case GL_ACCUM_BLUE_BITS: 4642 *params = (GLint) ctx->Visual.accumBlueBits; 4643 break; 4644 case GL_ACCUM_ALPHA_BITS: 4645 *params = (GLint) ctx->Visual.accumAlphaBits; 4646 break; 4647 case GL_ACCUM_CLEAR_VALUE: 4648 params[0] = FLOAT_TO_INT( ctx->Accum.ClearColor[0] ); 4649 params[1] = FLOAT_TO_INT( ctx->Accum.ClearColor[1] ); 4650 params[2] = FLOAT_TO_INT( ctx->Accum.ClearColor[2] ); 4651 params[3] = FLOAT_TO_INT( ctx->Accum.ClearColor[3] ); 4652 break; 4653 case GL_ALPHA_BIAS: 4654 *params = (GLint) ctx->Pixel.AlphaBias; 4655 break; 4656 case GL_ALPHA_BITS: 4657 *params = ctx->Visual.alphaBits; 4658 break; 4659 case GL_ALPHA_SCALE: 4660 *params = (GLint) ctx->Pixel.AlphaScale; 4661 break; 4662 case GL_ALPHA_TEST: 4663 *params = (GLint) ctx->Color.AlphaEnabled; 4664 break; 4665 case GL_ALPHA_TEST_REF: 4666 *params = FLOAT_TO_INT(ctx->Color.AlphaRef); 4667 break; 4668 case GL_ALPHA_TEST_FUNC: 4669 *params = (GLint) ctx->Color.AlphaFunc; 4670 break; 4671 case GL_ATTRIB_STACK_DEPTH: 4672 *params = (GLint) (ctx->AttribStackDepth); 4673 break; 4674 case GL_AUTO_NORMAL: 4675 *params = (GLint) ctx->Eval.AutoNormal; 4676 break; 4677 case GL_AUX_BUFFERS: 4678 *params = (GLint) ctx->Const.NumAuxBuffers; 4679 break; 4680 case GL_BLEND: 4681 *params = (GLint) ctx->Color.BlendEnabled; 4682 break; 4683 case GL_BLEND_DST: 4684 *params = (GLint) ctx->Color.BlendDstRGB; 4685 break; 4686 case GL_BLEND_SRC: 4687 *params = (GLint) ctx->Color.BlendSrcRGB; 4688 break; 4689 case GL_BLEND_SRC_RGB_EXT: 4690 *params = (GLint) ctx->Color.BlendSrcRGB; 4691 break; 4692 case GL_BLEND_DST_RGB_EXT: 4693 *params = (GLint) ctx->Color.BlendDstRGB; 4694 break; 4695 case GL_BLEND_SRC_ALPHA_EXT: 4696 *params = (GLint) ctx->Color.BlendSrcA; 4697 break; 4698 case GL_BLEND_DST_ALPHA_EXT: 4699 *params = (GLint) ctx->Color.BlendDstA; 4700 break; 4701 case GL_BLEND_EQUATION_EXT: 4702 *params = (GLint) ctx->Color.BlendEquation; 4703 break; 4704 case GL_BLEND_COLOR_EXT: 4705 params[0] = FLOAT_TO_INT( ctx->Color.BlendColor[0] ); 4706 params[1] = FLOAT_TO_INT( ctx->Color.BlendColor[1] ); 4707 params[2] = FLOAT_TO_INT( ctx->Color.BlendColor[2] ); 4708 params[3] = FLOAT_TO_INT( ctx->Color.BlendColor[3] ); 4709 break; 4710 case GL_BLUE_BIAS: 4711 *params = (GLint) ctx->Pixel.BlueBias; 4712 break; 4713 case GL_BLUE_BITS: 4714 *params = (GLint) ctx->Visual.blueBits; 4715 break; 4716 case GL_BLUE_SCALE: 4717 *params = (GLint) ctx->Pixel.BlueScale; 4718 break; 4719 case GL_CLIENT_ATTRIB_STACK_DEPTH: 4720 *params = (GLint) (ctx->ClientAttribStackDepth); 4721 break; 4722 case GL_CLIP_PLANE0: 4723 case GL_CLIP_PLANE1: 4724 case GL_CLIP_PLANE2: 4725 case GL_CLIP_PLANE3: 4726 case GL_CLIP_PLANE4: 4727 case GL_CLIP_PLANE5: 4728 if (ctx->Transform.ClipPlanesEnabled & (1 << (pname - GL_CLIP_PLANE0))) 4729 *params = 1; 4730 else 4731 *params = 0; 4732 break; 4733 case GL_COLOR_CLEAR_VALUE: 4734 params[0] = FLOAT_TO_INT( (ctx->Color.ClearColor[0]) ); 4735 params[1] = FLOAT_TO_INT( (ctx->Color.ClearColor[1]) ); 4736 params[2] = FLOAT_TO_INT( (ctx->Color.ClearColor[2]) ); 4737 params[3] = FLOAT_TO_INT( (ctx->Color.ClearColor[3]) ); 4738 break; 4739 case GL_COLOR_MATERIAL: 4740 *params = (GLint) ctx->Light.ColorMaterialEnabled; 4741 break; 4742 case GL_COLOR_MATERIAL_FACE: 4743 *params = (GLint) ctx->Light.ColorMaterialFace; 4744 break; 4745 case GL_COLOR_MATERIAL_PARAMETER: 4746 *params = (GLint) ctx->Light.ColorMaterialMode; 4747 break; 4748 case GL_COLOR_WRITEMASK: 4749 params[0] = ctx->Color.ColorMask[RCOMP] ? 1 : 0; 4750 params[1] = ctx->Color.ColorMask[GCOMP] ? 1 : 0; 4751 params[2] = ctx->Color.ColorMask[BCOMP] ? 1 : 0; 4752 params[3] = ctx->Color.ColorMask[ACOMP] ? 1 : 0; 4753 break; 4754 case GL_CULL_FACE: 4755 *params = (GLint) ctx->Polygon.CullFlag; 4756 break; 4757 case GL_CULL_FACE_MODE: 4758 *params = (GLint) ctx->Polygon.CullFaceMode; 4759 break; 4760 case GL_CURRENT_COLOR: 4761 FLUSH_CURRENT(ctx, 0); 4762 params[0] = FLOAT_TO_INT(ctx->Current.Attrib[VERT_ATTRIB_COLOR0][0]); 4763 params[1] = FLOAT_TO_INT(ctx->Current.Attrib[VERT_ATTRIB_COLOR0][1]); 4764 params[2] = FLOAT_TO_INT(ctx->Current.Attrib[VERT_ATTRIB_COLOR0][2]); 4765 params[3] = FLOAT_TO_INT(ctx->Current.Attrib[VERT_ATTRIB_COLOR0][3]); 4766 break; 4767 case GL_CURRENT_INDEX: 4768 FLUSH_CURRENT(ctx, 0); 4769 *params = (GLint) ctx->Current.Index; 4770 break; 4771 case GL_CURRENT_NORMAL: 4772 FLUSH_CURRENT(ctx, 0); 4773 params[0] = FLOAT_TO_INT(ctx->Current.Attrib[VERT_ATTRIB_NORMAL][0]); 4774 params[1] = FLOAT_TO_INT(ctx->Current.Attrib[VERT_ATTRIB_NORMAL][1]); 4775 params[2] = FLOAT_TO_INT(ctx->Current.Attrib[VERT_ATTRIB_NORMAL][2]); 4776 break; 4777 case GL_CURRENT_RASTER_COLOR: 4778 params[0] = FLOAT_TO_INT( ctx->Current.RasterColor[0] ); 4779 params[1] = FLOAT_TO_INT( ctx->Current.RasterColor[1] ); 4780 params[2] = FLOAT_TO_INT( ctx->Current.RasterColor[2] ); 4781 params[3] = FLOAT_TO_INT( ctx->Current.RasterColor[3] ); 4782 break; 4783 case GL_CURRENT_RASTER_DISTANCE: 4784 params[0] = (GLint) ctx->Current.RasterDistance; 4785 break; 4786 case GL_CURRENT_RASTER_INDEX: 4787 *params = (GLint) ctx->Current.RasterIndex; 4788 break; 4789 case GL_CURRENT_RASTER_POSITION: 4790 params[0] = (GLint) ctx->Current.RasterPos[0]; 4791 params[1] = (GLint) ctx->Current.RasterPos[1]; 4792 params[2] = (GLint) ctx->Current.RasterPos[2]; 4793 params[3] = (GLint) ctx->Current.RasterPos[3]; 4794 break; 4795 case GL_CURRENT_RASTER_TEXTURE_COORDS: 4796 params[0] = (GLint) ctx->Current.RasterTexCoords[texUnit][0]; 4797 params[1] = (GLint) ctx->Current.RasterTexCoords[texUnit][1]; 4798 params[2] = (GLint) ctx->Current.RasterTexCoords[texUnit][2]; 4799 params[3] = (GLint) ctx->Current.RasterTexCoords[texUnit][3]; 4800 break; 4801 case GL_CURRENT_RASTER_POSITION_VALID: 4802 *params = (GLint) ctx->Current.RasterPosValid; 4803 break; 4804 case GL_CURRENT_TEXTURE_COORDS: 4805 FLUSH_CURRENT(ctx, 0); 4806 params[0] = (GLint) ctx->Current.Attrib[VERT_ATTRIB_TEX0 + texUnit][0]; 4807 params[1] = (GLint) ctx->Current.Attrib[VERT_ATTRIB_TEX0 + texUnit][1]; 4808 params[2] = (GLint) ctx->Current.Attrib[VERT_ATTRIB_TEX0 + texUnit][2]; 4809 params[3] = (GLint) ctx->Current.Attrib[VERT_ATTRIB_TEX0 + texUnit][3]; 4810 break; 4811 case GL_DEPTH_BIAS: 4812 *params = (GLint) ctx->Pixel.DepthBias; 4813 break; 4814 case GL_DEPTH_BITS: 4815 *params = ctx->Visual.depthBits; 4816 break; 4817 case GL_DEPTH_CLEAR_VALUE: 4818 *params = (GLint) ctx->Depth.Clear; 4819 break; 4820 case GL_DEPTH_FUNC: 4821 *params = (GLint) ctx->Depth.Func; 4822 break; 4823 case GL_DEPTH_RANGE: 4824 params[0] = (GLint) ctx->Viewport.Near; 4825 params[1] = (GLint) ctx->Viewport.Far; 4826 break; 4827 case GL_DEPTH_SCALE: 4828 *params = (GLint) ctx->Pixel.DepthScale; 4829 break; 4830 case GL_DEPTH_TEST: 4831 *params = (GLint) ctx->Depth.Test; 4832 break; 4833 case GL_DEPTH_WRITEMASK: 4834 *params = (GLint) ctx->Depth.Mask; 4835 break; 4836 case GL_DITHER: 4837 *params = (GLint) ctx->Color.DitherFlag; 4838 break; 4839 case GL_DOUBLEBUFFER: 4840 *params = (GLint) ctx->Visual.doubleBufferMode; 4841 break; 4842 case GL_DRAW_BUFFER: 4843 *params = (GLint) ctx->Color.DrawBuffer; 4844 break; 4845 case GL_EDGE_FLAG: 4846 FLUSH_CURRENT(ctx, 0); 4847 *params = (GLint) ctx->Current.EdgeFlag; 4848 break; 4849 case GL_FEEDBACK_BUFFER_SIZE: 4850 *params = ctx->Feedback.BufferSize; 4851 break; 4852 case GL_FEEDBACK_BUFFER_TYPE: 4853 *params = ctx->Feedback.Type; 4854 break; 4855 case GL_FOG: 4856 *params = (GLint) ctx->Fog.Enabled; 4857 break; 4858 case GL_FOG_COLOR: 4859 params[0] = FLOAT_TO_INT( ctx->Fog.Color[0] ); 4860 params[1] = FLOAT_TO_INT( ctx->Fog.Color[1] ); 4861 params[2] = FLOAT_TO_INT( ctx->Fog.Color[2] ); 4862 params[3] = FLOAT_TO_INT( ctx->Fog.Color[3] ); 4863 break; 4864 case GL_FOG_DENSITY: 4865 *params = (GLint) ctx->Fog.Density; 4866 break; 4867 case GL_FOG_END: 4868 *params = (GLint) ctx->Fog.End; 4869 break; 4870 case GL_FOG_HINT: 4871 *params = (GLint) ctx->Hint.Fog; 4872 break; 4873 case GL_FOG_INDEX: 4874 *params = (GLint) ctx->Fog.Index; 4875 break; 4876 case GL_FOG_MODE: 4877 *params = (GLint) ctx->Fog.Mode; 4878 break; 4879 case GL_FOG_START: 4880 *params = (GLint) ctx->Fog.Start; 4881 break; 4882 case GL_FRONT_FACE: 4883 *params = (GLint) ctx->Polygon.FrontFace; 4884 break; 4885 case GL_GREEN_BIAS: 4886 *params = (GLint) ctx->Pixel.GreenBias; 4887 break; 4888 case GL_GREEN_BITS: 4889 *params = (GLint) ctx->Visual.greenBits; 4890 break; 4891 case GL_GREEN_SCALE: 4892 *params = (GLint) ctx->Pixel.GreenScale; 4893 break; 4894 case GL_INDEX_BITS: 4895 *params = (GLint) ctx->Visual.indexBits; 4896 break; 4897 case GL_INDEX_CLEAR_VALUE: 4898 *params = (GLint) ctx->Color.ClearIndex; 4899 break; 4900 case GL_INDEX_MODE: 4901 *params = ctx->Visual.rgbMode ? 0 : 1; 4902 break; 4903 case GL_INDEX_OFFSET: 4904 *params = ctx->Pixel.IndexOffset; 4905 break; 4906 case GL_INDEX_SHIFT: 4907 *params = ctx->Pixel.IndexShift; 4908 break; 4909 case GL_INDEX_WRITEMASK: 4910 *params = (GLint) ctx->Color.IndexMask; 4911 break; 4912 case GL_LIGHT0: 4913 case GL_LIGHT1: 4914 case GL_LIGHT2: 4915 case GL_LIGHT3: 4916 case GL_LIGHT4: 4917 case GL_LIGHT5: 4918 case GL_LIGHT6: 4919 case GL_LIGHT7: 4920 *params = (GLint) ctx->Light.Light[pname-GL_LIGHT0].Enabled; 4921 break; 4922 case GL_LIGHTING: 4923 *params = (GLint) ctx->Light.Enabled; 4924 break; 4925 case GL_LIGHT_MODEL_AMBIENT: 4926 params[0] = FLOAT_TO_INT( ctx->Light.Model.Ambient[0] ); 4927 params[1] = FLOAT_TO_INT( ctx->Light.Model.Ambient[1] ); 4928 params[2] = FLOAT_TO_INT( ctx->Light.Model.Ambient[2] ); 4929 params[3] = FLOAT_TO_INT( ctx->Light.Model.Ambient[3] ); 4930 break; 4931 case GL_LIGHT_MODEL_COLOR_CONTROL: 4932 params[0] = (GLint) ctx->Light.Model.ColorControl; 4933 break; 4934 case GL_LIGHT_MODEL_LOCAL_VIEWER: 4935 *params = (GLint) ctx->Light.Model.LocalViewer; 4936 break; 4937 case GL_LIGHT_MODEL_TWO_SIDE: 4938 *params = (GLint) ctx->Light.Model.TwoSide; 4939 break; 4940 case GL_LINE_SMOOTH: 4941 *params = (GLint) ctx->Line.SmoothFlag; 4942 break; 4943 case GL_LINE_SMOOTH_HINT: 4944 *params = (GLint) ctx->Hint.LineSmooth; 4945 break; 4946 case GL_LINE_STIPPLE: 4947 *params = (GLint) ctx->Line.StippleFlag; 4948 break; 4949 case GL_LINE_STIPPLE_PATTERN: 4950 *params = (GLint) ctx->Line.StipplePattern; 4951 break; 4952 case GL_LINE_STIPPLE_REPEAT: 4953 *params = (GLint) ctx->Line.StippleFactor; 4954 break; 4955 case GL_LINE_WIDTH: 4956 *params = (GLint) ctx->Line.Width; 4957 break; 4958 case GL_LINE_WIDTH_GRANULARITY: 4959 *params = (GLint) ctx->Const.LineWidthGranularity; 4960 break; 4961 case GL_LINE_WIDTH_RANGE: 4962 params[0] = (GLint) ctx->Const.MinLineWidthAA; 4963 params[1] = (GLint) ctx->Const.MaxLineWidthAA; 4964 break; 4965 case GL_ALIASED_LINE_WIDTH_RANGE: 4966 params[0] = (GLint) ctx->Const.MinLineWidth; 4967 params[1] = (GLint) ctx->Const.MaxLineWidth; 4968 break; 4969 case GL_LIST_BASE: 4970 *params = (GLint) ctx->List.ListBase; 4971 break; 4972 case GL_LIST_INDEX: 4973 *params = (GLint) ctx->CurrentListNum; 4974 break; 4975 case GL_LIST_MODE: 4976 if (!ctx->CompileFlag) 4977 *params = 0; 4978 else if (ctx->ExecuteFlag) 4979 *params = (GLint) GL_COMPILE_AND_EXECUTE; 4980 else 4981 *params = (GLint) GL_COMPILE; 4982 break; 4983 case GL_INDEX_LOGIC_OP: 4984 *params = (GLint) ctx->Color.IndexLogicOpEnabled; 4985 break; 4986 case GL_COLOR_LOGIC_OP: 4987 *params = (GLint) ctx->Color.ColorLogicOpEnabled; 4988 break; 4989 case GL_LOGIC_OP_MODE: 4990 *params = (GLint) ctx->Color.LogicOp; 4991 break; 4992 case GL_MAP1_COLOR_4: 4993 *params = (GLint) ctx->Eval.Map1Color4; 4994 break; 4995 case GL_MAP1_GRID_DOMAIN: 4996 params[0] = (GLint) ctx->Eval.MapGrid1u1; 4997 params[1] = (GLint) ctx->Eval.MapGrid1u2; 4998 break; 4999 case GL_MAP1_GRID_SEGMENTS: 5000 *params = (GLint) ctx->Eval.MapGrid1un; 5001 break; 5002 case GL_MAP1_INDEX: 5003 *params = (GLint) ctx->Eval.Map1Index; 5004 break; 5005 case GL_MAP1_NORMAL: 5006 *params = (GLint) ctx->Eval.Map1Normal; 5007 break; 5008 case GL_MAP1_TEXTURE_COORD_1: 5009 *params = (GLint) ctx->Eval.Map1TextureCoord1; 5010 break; 5011 case GL_MAP1_TEXTURE_COORD_2: 5012 *params = (GLint) ctx->Eval.Map1TextureCoord2; 5013 break; 5014 case GL_MAP1_TEXTURE_COORD_3: 5015 *params = (GLint) ctx->Eval.Map1TextureCoord3; 5016 break; 5017 case GL_MAP1_TEXTURE_COORD_4: 5018 *params = (GLint) ctx->Eval.Map1TextureCoord4; 5019 break; 5020 case GL_MAP1_VERTEX_3: 5021 *params = (GLint) ctx->Eval.Map1Vertex3; 5022 break; 5023 case GL_MAP1_VERTEX_4: 5024 *params = (GLint) ctx->Eval.Map1Vertex4; 5025 break; 5026 case GL_MAP2_COLOR_4: 5027 *params = (GLint) ctx->Eval.Map2Color4; 5028 break; 5029 case GL_MAP2_GRID_DOMAIN: 5030 params[0] = (GLint) ctx->Eval.MapGrid2u1; 5031 params[1] = (GLint) ctx->Eval.MapGrid2u2; 5032 params[2] = (GLint) ctx->Eval.MapGrid2v1; 5033 params[3] = (GLint) ctx->Eval.MapGrid2v2; 5034 break; 5035 case GL_MAP2_GRID_SEGMENTS: 5036 params[0] = (GLint) ctx->Eval.MapGrid2un; 5037 params[1] = (GLint) ctx->Eval.MapGrid2vn; 5038 break; 5039 case GL_MAP2_INDEX: 5040 *params = (GLint) ctx->Eval.Map2Index; 5041 break; 5042 case GL_MAP2_NORMAL: 5043 *params = (GLint) ctx->Eval.Map2Normal; 5044 break; 5045 case GL_MAP2_TEXTURE_COORD_1: 5046 *params = (GLint) ctx->Eval.Map2TextureCoord1; 5047 break; 5048 case GL_MAP2_TEXTURE_COORD_2: 5049 *params = (GLint) ctx->Eval.Map2TextureCoord2; 5050 break; 5051 case GL_MAP2_TEXTURE_COORD_3: 5052 *params = (GLint) ctx->Eval.Map2TextureCoord3; 5053 break; 5054 case GL_MAP2_TEXTURE_COORD_4: 5055 *params = (GLint) ctx->Eval.Map2TextureCoord4; 5056 break; 5057 case GL_MAP2_VERTEX_3: 5058 *params = (GLint) ctx->Eval.Map2Vertex3; 5059 break; 5060 case GL_MAP2_VERTEX_4: 5061 *params = (GLint) ctx->Eval.Map2Vertex4; 5062 break; 5063 case GL_MAP_COLOR: 5064 *params = (GLint) ctx->Pixel.MapColorFlag; 5065 break; 5066 case GL_MAP_STENCIL: 5067 *params = (GLint) ctx->Pixel.MapStencilFlag; 5068 break; 5069 case GL_MATRIX_MODE: 5070 *params = (GLint) ctx->Transform.MatrixMode; 5071 break; 5072 case GL_MAX_ATTRIB_STACK_DEPTH: 5073 *params = (GLint) MAX_ATTRIB_STACK_DEPTH; 5074 break; 5075 case GL_MAX_CLIENT_ATTRIB_STACK_DEPTH: 5076 *params = (GLint) MAX_CLIENT_ATTRIB_STACK_DEPTH; 5077 break; 5078 case GL_MAX_CLIP_PLANES: 5079 *params = (GLint) ctx->Const.MaxClipPlanes; 5080 break; 5081 case GL_MAX_ELEMENTS_VERTICES: /* GL_VERSION_1_2 */ 5082 *params = (GLint) ctx->Const.MaxArrayLockSize; 5083 break; 5084 case GL_MAX_ELEMENTS_INDICES: /* GL_VERSION_1_2 */ 5085 *params = (GLint) ctx->Const.MaxArrayLockSize; 5086 break; 5087 case GL_MAX_EVAL_ORDER: 5088 *params = (GLint) MAX_EVAL_ORDER; 5089 break; 5090 case GL_MAX_LIGHTS: 5091 *params = (GLint) ctx->Const.MaxLights; 5092 break; 5093 case GL_MAX_LIST_NESTING: 5094 *params = (GLint) MAX_LIST_NESTING; 5095 break; 5096 case GL_MAX_MODELVIEW_STACK_DEPTH: 5097 *params = (GLint) MAX_MODELVIEW_STACK_DEPTH; 5098 break; 5099 case GL_MAX_NAME_STACK_DEPTH: 5100 *params = (GLint) MAX_NAME_STACK_DEPTH; 5101 break; 5102 case GL_MAX_PIXEL_MAP_TABLE: 5103 *params = (GLint) MAX_PIXEL_MAP_TABLE; 5104 break; 5105 case GL_MAX_PROJECTION_STACK_DEPTH: 5106 *params = (GLint) MAX_PROJECTION_STACK_DEPTH; 5107 break; 5108 case GL_MAX_TEXTURE_SIZE: 5109 *params = (1 << (ctx->Const.MaxTextureLevels - 1)); 5110 break; 5111 case GL_MAX_3D_TEXTURE_SIZE: 5112 *params = (1 << (ctx->Const.Max3DTextureLevels - 1)); 5113 break; 5114 case GL_MAX_TEXTURE_STACK_DEPTH: 5115 *params = (GLint) MAX_TEXTURE_STACK_DEPTH; 5116 break; 5117 case GL_MAX_VIEWPORT_DIMS: 5118 params[0] = (GLint) MAX_WIDTH; 5119 params[1] = (GLint) MAX_HEIGHT; 5120 break; 5121 case GL_MODELVIEW_MATRIX: 5122 for (i=0;i<16;i++) { 5123 params[i] = (GLint) ctx->ModelviewMatrixStack.Top->m[i]; 5124 } 5125 break; 5126 case GL_MODELVIEW_STACK_DEPTH: 5127 *params = (GLint) (ctx->ModelviewMatrixStack.Depth + 1); 5128 break; 5129 case GL_NAME_STACK_DEPTH: 5130 *params = (GLint) ctx->Select.NameStackDepth; 5131 break; 5132 case GL_NORMALIZE: 5133 *params = (GLint) ctx->Transform.Normalize; 5134 break; 5135 case GL_PACK_ALIGNMENT: 5136 *params = ctx->Pack.Alignment; 5137 break; 5138 case GL_PACK_LSB_FIRST: 5139 *params = (GLint) ctx->Pack.LsbFirst; 5140 break; 5141 case GL_PACK_ROW_LENGTH: 5142 *params = ctx->Pack.RowLength; 5143 break; 5144 case GL_PACK_SKIP_PIXELS: 5145 *params = ctx->Pack.SkipPixels; 5146 break; 5147 case GL_PACK_SKIP_ROWS: 5148 *params = ctx->Pack.SkipRows; 5149 break; 5150 case GL_PACK_SWAP_BYTES: 5151 *params = (GLint) ctx->Pack.SwapBytes; 5152 break; 5153 case GL_PACK_SKIP_IMAGES_EXT: 5154 *params = ctx->Pack.SkipImages; 5155 break; 5156 case GL_PACK_IMAGE_HEIGHT_EXT: 5157 *params = ctx->Pack.ImageHeight; 5158 break; 5159 case GL_PACK_INVERT_MESA: 5160 *params = ctx->Pack.Invert; 5161 break; 5162 case GL_PERSPECTIVE_CORRECTION_HINT: 5163 *params = (GLint) ctx->Hint.PerspectiveCorrection; 5164 break; 5165 case GL_PIXEL_MAP_A_TO_A_SIZE: 5166 *params = ctx->Pixel.MapAtoAsize; 5167 break; 5168 case GL_PIXEL_MAP_B_TO_B_SIZE: 5169 *params = ctx->Pixel.MapBtoBsize; 5170 break; 5171 case GL_PIXEL_MAP_G_TO_G_SIZE: 5172 *params = ctx->Pixel.MapGtoGsize; 5173 break; 5174 case GL_PIXEL_MAP_I_TO_A_SIZE: 5175 *params = ctx->Pixel.MapItoAsize; 5176 break; 5177 case GL_PIXEL_MAP_I_TO_B_SIZE: 5178 *params = ctx->Pixel.MapItoBsize; 5179 break; 5180 case GL_PIXEL_MAP_I_TO_G_SIZE: 5181 *params = ctx->Pixel.MapItoGsize; 5182 break; 5183 case GL_PIXEL_MAP_I_TO_I_SIZE: 5184 *params = ctx->Pixel.MapItoIsize; 5185 break; 5186 case GL_PIXEL_MAP_I_TO_R_SIZE: 5187 *params = ctx->Pixel.MapItoRsize; 5188 break; 5189 case GL_PIXEL_MAP_R_TO_R_SIZE: 5190 *params = ctx->Pixel.MapRtoRsize; 5191 break; 5192 case GL_PIXEL_MAP_S_TO_S_SIZE: 5193 *params = ctx->Pixel.MapStoSsize; 5194 break; 5195 case GL_POINT_SIZE: 5196 *params = (GLint) ctx->Point.Size; 5197 break; 5198 case GL_POINT_SIZE_GRANULARITY: 5199 *params = (GLint) ctx->Const.PointSizeGranularity; 5200 break; 5201 case GL_POINT_SIZE_RANGE: 5202 params[0] = (GLint) ctx->Const.MinPointSizeAA; 5203 params[1] = (GLint) ctx->Const.MaxPointSizeAA; 5204 break; 5205 case GL_ALIASED_POINT_SIZE_RANGE: 5206 params[0] = (GLint) ctx->Const.MinPointSize; 5207 params[1] = (GLint) ctx->Const.MaxPointSize; 5208 break; 5209 case GL_POINT_SMOOTH: 5210 *params = (GLint) ctx->Point.SmoothFlag; 5211 break; 5212 case GL_POINT_SMOOTH_HINT: 5213 *params = (GLint) ctx->Hint.PointSmooth; 5214 break; 5215 case GL_POINT_SIZE_MIN_EXT: 5216 *params = (GLint) (ctx->Point.MinSize); 5217 break; 5218 case GL_POINT_SIZE_MAX_EXT: 5219 *params = (GLint) (ctx->Point.MaxSize); 5220 break; 5221 case GL_POINT_FADE_THRESHOLD_SIZE_EXT: 5222 *params = (GLint) (ctx->Point.Threshold); 5223 break; 5224 case GL_DISTANCE_ATTENUATION_EXT: 5225 params[0] = (GLint) (ctx->Point.Params[0]); 5226 params[1] = (GLint) (ctx->Point.Params[1]); 5227 params[2] = (GLint) (ctx->Point.Params[2]); 5228 break; 5229 case GL_POLYGON_MODE: 5230 params[0] = (GLint) ctx->Polygon.FrontMode; 5231 params[1] = (GLint) ctx->Polygon.BackMode; 5232 break; 5233 case GL_POLYGON_OFFSET_BIAS_EXT: /* GL_EXT_polygon_offset */ 5234 *params = (GLint) ctx->Polygon.OffsetUnits; 5235 break; 5236 case GL_POLYGON_OFFSET_FACTOR: 5237 *params = (GLint) ctx->Polygon.OffsetFactor; 5238 break; 5239 case GL_POLYGON_OFFSET_UNITS: 5240 *params = (GLint) ctx->Polygon.OffsetUnits; 5241 break; 5242 case GL_POLYGON_SMOOTH: 5243 *params = (GLint) ctx->Polygon.SmoothFlag; 5244 break; 5245 case GL_POLYGON_SMOOTH_HINT: 5246 *params = (GLint) ctx->Hint.PolygonSmooth; 5247 break; 5248 case GL_POLYGON_STIPPLE: 5249 *params = (GLint) ctx->Polygon.StippleFlag; 5250 break; 5251 case GL_PROJECTION_MATRIX: 5252 for (i=0;i<16;i++) { 5253 params[i] = (GLint) ctx->ProjectionMatrixStack.Top->m[i]; 5254 } 5255 break; 5256 case GL_PROJECTION_STACK_DEPTH: 5257 *params = (GLint) (ctx->ProjectionMatrixStack.Depth + 1); 5258 break; 5259 case GL_READ_BUFFER: 5260 *params = (GLint) ctx->Pixel.ReadBuffer; 5261 break; 5262 case GL_RED_BIAS: 5263 *params = (GLint) ctx->Pixel.RedBias; 5264 break; 5265 case GL_RED_BITS: 5266 *params = (GLint) ctx->Visual.redBits; 5267 break; 5268 case GL_RED_SCALE: 5269 *params = (GLint) ctx->Pixel.RedScale; 5270 break; 5271 case GL_RENDER_MODE: 5272 *params = (GLint) ctx->RenderMode; 5273 break; 5274 case GL_RESCALE_NORMAL: 5275 *params = (GLint) ctx->Transform.RescaleNormals; 5276 break; 5277 case GL_RGBA_MODE: 5278 *params = (GLint) ctx->Visual.rgbMode; 5279 break; 5280 case GL_SCISSOR_BOX: 5281 params[0] = (GLint) ctx->Scissor.X; 5282 params[1] = (GLint) ctx->Scissor.Y; 5283 params[2] = (GLint) ctx->Scissor.Width; 5284 params[3] = (GLint) ctx->Scissor.Height; 5285 break; 5286 case GL_SCISSOR_TEST: 5287 *params = (GLint) ctx->Scissor.Enabled; 5288 break; 5289 case GL_SELECTION_BUFFER_SIZE: 5290 *params = (GLint) ctx->Select.BufferSize; 5291 break; 5292 case GL_SHADE_MODEL: 5293 *params = (GLint) ctx->Light.ShadeModel; 5294 break; 5295 case GL_SHARED_TEXTURE_PALETTE_EXT: 5296 *params = (GLint) ctx->Texture.SharedPalette; 5297 break; 5298 case GL_STENCIL_BITS: 5299 *params = ctx->Visual.stencilBits; 5300 break; 5301 case GL_STENCIL_CLEAR_VALUE: 5302 *params = (GLint) ctx->Stencil.Clear; 5303 break; 5304 case GL_STENCIL_FAIL: 5305 *params = (GLint) ctx->Stencil.FailFunc[ctx->Stencil.ActiveFace]; 5306 break; 5307 case GL_STENCIL_FUNC: 5308 *params = (GLint) ctx->Stencil.Function[ctx->Stencil.ActiveFace]; 5309 break; 5310 case GL_STENCIL_PASS_DEPTH_FAIL: 5311 *params = (GLint) ctx->Stencil.ZFailFunc[ctx->Stencil.ActiveFace]; 5312 break; 5313 case GL_STENCIL_PASS_DEPTH_PASS: 5314 *params = (GLint) ctx->Stencil.ZPassFunc[ctx->Stencil.ActiveFace]; 5315 break; 5316 case GL_STENCIL_REF: 5317 *params = (GLint) ctx->Stencil.Ref[ctx->Stencil.ActiveFace]; 5318 break; 5319 case GL_STENCIL_TEST: 5320 *params = (GLint) ctx->Stencil.Enabled; 5321 break; 5322 case GL_STENCIL_VALUE_MASK: 5323 *params = (GLint) ctx->Stencil.ValueMask[ctx->Stencil.ActiveFace]; 5324 break; 5325 case GL_STENCIL_WRITEMASK: 5326 *params = (GLint) ctx->Stencil.WriteMask[ctx->Stencil.ActiveFace]; 5327 break; 5328 case GL_STEREO: 5329 *params = (GLint) ctx->Visual.stereoMode; 5330 break; 5331 case GL_SUBPIXEL_BITS: 5332 *params = ctx->Const.SubPixelBits; 5333 break; 5334 case GL_TEXTURE_1D: 5335 *params = _mesa_IsEnabled(GL_TEXTURE_1D) ? 1 : 0; 5336 break; 5337 case GL_TEXTURE_2D: 5338 *params = _mesa_IsEnabled(GL_TEXTURE_2D) ? 1 : 0; 5339 break; 5340 case GL_TEXTURE_3D: 5341 *params = _mesa_IsEnabled(GL_TEXTURE_3D) ? 1 : 0; 5342 break; 5343 case GL_TEXTURE_BINDING_1D: 5344 *params = textureUnit->Current1D->Name; 5345 break; 5346 case GL_TEXTURE_BINDING_2D: 5347 *params = textureUnit->Current2D->Name; 5348 break; 5349 case GL_TEXTURE_BINDING_3D: 5350 *params = textureUnit->Current3D->Name; 5351 break; 5352 case GL_TEXTURE_ENV_COLOR: 5353 params[0] = FLOAT_TO_INT( textureUnit->EnvColor[0] ); 5354 params[1] = FLOAT_TO_INT( textureUnit->EnvColor[1] ); 5355 params[2] = FLOAT_TO_INT( textureUnit->EnvColor[2] ); 5356 params[3] = FLOAT_TO_INT( textureUnit->EnvColor[3] ); 5357 break; 5358 case GL_TEXTURE_ENV_MODE: 5359 *params = (GLint) textureUnit->EnvMode; 5360 break; 5361 case GL_TEXTURE_GEN_S: 5362 *params = (textureUnit->TexGenEnabled & S_BIT) ? 1 : 0; 5363 break; 5364 case GL_TEXTURE_GEN_T: 5365 *params = (textureUnit->TexGenEnabled & T_BIT) ? 1 : 0; 5366 break; 5367 case GL_TEXTURE_GEN_R: 5368 *params = (textureUnit->TexGenEnabled & R_BIT) ? 1 : 0; 5369 break; 5370 case GL_TEXTURE_GEN_Q: 5371 *params = (textureUnit->TexGenEnabled & Q_BIT) ? 1 : 0; 5372 break; 5373 case GL_TEXTURE_MATRIX: 5374 for (i=0;i<16;i++) { 5375 params[i] = (GLint) ctx->TextureMatrixStack[texUnit].Top->m[i]; 5376 } 5377 break; 5378 case GL_TEXTURE_STACK_DEPTH: 5379 *params = (GLint) (ctx->TextureMatrixStack[texUnit].Depth + 1); 5380 break; 5381 case GL_UNPACK_ALIGNMENT: 5382 *params = ctx->Unpack.Alignment; 5383 break; 5384 case GL_UNPACK_LSB_FIRST: 5385 *params = (GLint) ctx->Unpack.LsbFirst; 5386 break; 5387 case GL_UNPACK_ROW_LENGTH: 5388 *params = ctx->Unpack.RowLength; 5389 break; 5390 case GL_UNPACK_SKIP_PIXELS: 5391 *params = ctx->Unpack.SkipPixels; 5392 break; 5393 case GL_UNPACK_SKIP_ROWS: 5394 *params = ctx->Unpack.SkipRows; 5395 break; 5396 case GL_UNPACK_SWAP_BYTES: 5397 *params = (GLint) ctx->Unpack.SwapBytes; 5398 break; 5399 case GL_UNPACK_SKIP_IMAGES_EXT: 5400 *params = ctx->Unpack.SkipImages; 5401 break; 5402 case GL_UNPACK_IMAGE_HEIGHT_EXT: 5403 *params = ctx->Unpack.ImageHeight; 5404 break; 5405 case GL_UNPACK_CLIENT_STORAGE_APPLE: 5406 *params = ctx->Unpack.ClientStorage; 5407 break; 5408 case GL_VIEWPORT: 5409 params[0] = (GLint) ctx->Viewport.X; 5410 params[1] = (GLint) ctx->Viewport.Y; 5411 params[2] = (GLint) ctx->Viewport.Width; 5412 params[3] = (GLint) ctx->Viewport.Height; 5413 break; 5414 case GL_ZOOM_X: 5415 *params = (GLint) ctx->Pixel.ZoomX; 5416 break; 5417 case GL_ZOOM_Y: 5418 *params = (GLint) ctx->Pixel.ZoomY; 5419 break; 5420 case GL_VERTEX_ARRAY: 5421 *params = (GLint) ctx->Array.Vertex.Enabled; 5422 break; 5423 case GL_VERTEX_ARRAY_SIZE: 5424 *params = ctx->Array.Vertex.Size; 5425 break; 5426 case GL_VERTEX_ARRAY_TYPE: 5427 *params = ctx->Array.Vertex.Type; 5428 break; 5429 case GL_VERTEX_ARRAY_STRIDE: 5430 *params = ctx->Array.Vertex.Stride; 5431 break; 5432 case GL_VERTEX_ARRAY_COUNT_EXT: 5433 *params = 0; 5434 break; 5435 case GL_NORMAL_ARRAY: 5436 *params = (GLint) ctx->Array.Normal.Enabled; 5437 break; 5438 case GL_NORMAL_ARRAY_TYPE: 5439 *params = ctx->Array.Normal.Type; 5440 break; 5441 case GL_NORMAL_ARRAY_STRIDE: 5442 *params = ctx->Array.Normal.Stride; 5443 break; 5444 case GL_NORMAL_ARRAY_COUNT_EXT: 5445 *params = 0; 5446 break; 5447 case GL_COLOR_ARRAY: 5448 *params = (GLint) ctx->Array.Color.Enabled; 5449 break; 5450 case GL_COLOR_ARRAY_SIZE: 5451 *params = ctx->Array.Color.Size; 5452 break; 5453 case GL_COLOR_ARRAY_TYPE: 5454 *params = ctx->Array.Color.Type; 5455 break; 5456 case GL_COLOR_ARRAY_STRIDE: 5457 *params = ctx->Array.Color.Stride; 5458 break; 5459 case GL_COLOR_ARRAY_COUNT_EXT: 5460 *params = 0; 5461 break; 5462 case GL_INDEX_ARRAY: 5463 *params = (GLint) ctx->Array.Index.Enabled; 5464 break; 5465 case GL_INDEX_ARRAY_TYPE: 5466 *params = ctx->Array.Index.Type; 5467 break; 5468 case GL_INDEX_ARRAY_STRIDE: 5469 *params = ctx->Array.Index.Stride; 5470 break; 5471 case GL_INDEX_ARRAY_COUNT_EXT: 5472 *params = 0; 5473 break; 5474 case GL_TEXTURE_COORD_ARRAY: 5475 *params = (GLint) ctx->Array.TexCoord[texUnit].Enabled; 5476 break; 5477 case GL_TEXTURE_COORD_ARRAY_SIZE: 5478 *params = ctx->Array.TexCoord[texUnit].Size; 5479 break; 5480 case GL_TEXTURE_COORD_ARRAY_TYPE: 5481 *params = ctx->Array.TexCoord[texUnit].Type; 5482 break; 5483 case GL_TEXTURE_COORD_ARRAY_STRIDE: 5484 *params = ctx->Array.TexCoord[texUnit].Stride; 5485 break; 5486 case GL_TEXTURE_COORD_ARRAY_COUNT_EXT: 5487 *params = 0; 5488 break; 5489 case GL_EDGE_FLAG_ARRAY: 5490 *params = (GLint) ctx->Array.EdgeFlag.Enabled; 5491 break; 5492 case GL_EDGE_FLAG_ARRAY_STRIDE: 5493 *params = ctx->Array.EdgeFlag.Stride; 5494 break; 5495 case GL_EDGE_FLAG_ARRAY_COUNT_EXT: 5496 *params = 0; 5497 break; 5498 5499 /* GL_ARB_multitexture */ 5500 case GL_MAX_TEXTURE_UNITS_ARB: 5501 CHECK_EXTENSION_I(ARB_multitexture, pname); 5502 *params = MIN2(ctx->Const.MaxTextureImageUnits, 5503 ctx->Const.MaxTextureCoordUnits); 5504 break; 5505 case GL_ACTIVE_TEXTURE_ARB: 5506 CHECK_EXTENSION_I(ARB_multitexture, pname); 5507 *params = GL_TEXTURE0_ARB + ctx->Texture.CurrentUnit; 5508 break; 5509 case GL_CLIENT_ACTIVE_TEXTURE_ARB: 5510 CHECK_EXTENSION_I(ARB_multitexture, pname); 5511 *params = GL_TEXTURE0_ARB + ctx->Array.ActiveTexture; 5512 break; 5513 5514 /* GL_ARB_texture_cube_map */ 5515 case GL_TEXTURE_CUBE_MAP_ARB: 5516 CHECK_EXTENSION_I(ARB_texture_cube_map, pname); 5517 *params = (GLint) _mesa_IsEnabled(GL_TEXTURE_CUBE_MAP_ARB); 5518 break; 5519 case GL_TEXTURE_BINDING_CUBE_MAP_ARB: 5520 CHECK_EXTENSION_I(ARB_texture_cube_map, pname); 5521 *params = textureUnit->CurrentCubeMap->Name; 5522 break; 5523 case GL_MAX_CUBE_MAP_TEXTURE_SIZE_ARB: 5524 CHECK_EXTENSION_I(ARB_texture_cube_map, pname); 5525 *params = (1 << (ctx->Const.MaxCubeTextureLevels - 1)); 5526 break; 5527 5528 /* GL_ARB_texture_compression */ 5529 case GL_TEXTURE_COMPRESSION_HINT_ARB: 5530 CHECK_EXTENSION_I(ARB_texture_compression, pname); 5531 *params = (GLint) ctx->Hint.TextureCompression; 5532 break; 5533 case GL_NUM_COMPRESSED_TEXTURE_FORMATS_ARB: 5534 CHECK_EXTENSION_I(ARB_texture_compression, pname); 5535 *params = (GLint) _mesa_get_compressed_formats(ctx, NULL); 5536 break; 5537 case GL_COMPRESSED_TEXTURE_FORMATS_ARB: 5538 CHECK_EXTENSION_I(ARB_texture_compression, pname); 5539 (void) _mesa_get_compressed_formats(ctx, params); 5540 break; 5541 5542 /* GL_EXT_compiled_vertex_array */ 5543 case GL_ARRAY_ELEMENT_LOCK_FIRST_EXT: 5544 CHECK_EXTENSION_I(EXT_compiled_vertex_array, pname); 5545 *params = ctx->Array.LockFirst; 5546 break; 5547 case GL_ARRAY_ELEMENT_LOCK_COUNT_EXT: 5548 CHECK_EXTENSION_I(EXT_compiled_vertex_array, pname); 5549 *params = ctx->Array.LockCount; 5550 break; 5551 5552 /* GL_ARB_transpose_matrix */ 5553 case GL_TRANSPOSE_COLOR_MATRIX_ARB: 5554 { 5555 GLfloat tm[16]; 5556 GLuint i; 5557 _math_transposef(tm, ctx->ColorMatrixStack.Top->m); 5558 for (i=0;i<16;i++) { 5559 params[i] = (GLint) tm[i]; 5560 } 5561 } 5562 break; 5563 case GL_TRANSPOSE_MODELVIEW_MATRIX_ARB: 5564 { 5565 GLfloat tm[16]; 5566 GLuint i; 5567 _math_transposef(tm, ctx->ModelviewMatrixStack.Top->m); 5568 for (i=0;i<16;i++) { 5569 params[i] = (GLint) tm[i]; 5570 } 5571 } 5572 break; 5573 case GL_TRANSPOSE_PROJECTION_MATRIX_ARB: 5574 { 5575 GLfloat tm[16]; 5576 GLuint i; 5577 _math_transposef(tm, ctx->ProjectionMatrixStack.Top->m); 5578 for (i=0;i<16;i++) { 5579 params[i] = (GLint) tm[i]; 5580 } 5581 } 5582 break; 5583 case GL_TRANSPOSE_TEXTURE_MATRIX_ARB: 5584 { 5585 GLfloat tm[16]; 5586 GLuint i; 5587 _math_transposef(tm, ctx->TextureMatrixStack[texUnit].Top->m); 5588 for (i=0;i<16;i++) { 5589 params[i] = (GLint) tm[i]; 5590 } 5591 } 5592 break; 5593 5594 /* GL_HP_occlusion_test */ 5595 case GL_OCCLUSION_TEST_HP: 5596 CHECK_EXTENSION_I(HP_occlusion_test, pname); 5597 *params = (GLint) ctx->Depth.OcclusionTest; 5598 break; 5599 case GL_OCCLUSION_TEST_RESULT_HP: 5600 CHECK_EXTENSION_I(HP_occlusion_test, pname); 5601 if (ctx->Depth.OcclusionTest) 5602 *params = (GLint) ctx->OcclusionResult; 5603 else 5604 *params = (GLint) ctx->OcclusionResultSaved; 5605 /* reset flag now */ 5606 ctx->OcclusionResult = GL_FALSE; 5607 ctx->OcclusionResultSaved = GL_FALSE; 5608 break; 5609 5610 /* GL_SGIS_pixel_texture */ 5611 case GL_PIXEL_TEXTURE_SGIS: 5612 CHECK_EXTENSION_I(SGIS_pixel_texture, pname); 5613 *params = (GLint) ctx->Pixel.PixelTextureEnabled; 5614 break; 5615 5616 /* GL_SGIX_pixel_texture */ 5617 case GL_PIXEL_TEX_GEN_SGIX: 5618 CHECK_EXTENSION_I(SGIX_pixel_texture, pname); 5619 *params = (GLint) ctx->Pixel.PixelTextureEnabled; 5620 break; 5621 case GL_PIXEL_TEX_GEN_MODE_SGIX: 5622 CHECK_EXTENSION_I(SGIX_pixel_texture, pname); 5623 *params = (GLint) pixel_texgen_mode(ctx); 5624 break; 5625 5626 /* GL_SGI_color_matrix (also in 1.2 imaging) */ 5627 case GL_COLOR_MATRIX_SGI: 5628 CHECK_EXTENSION_I(SGI_color_matrix, pname); 5629 for (i=0;i<16;i++) { 5630 params[i] = (GLint) ctx->ColorMatrixStack.Top->m[i]; 5631 } 5632 break; 5633 case GL_COLOR_MATRIX_STACK_DEPTH_SGI: 5634 CHECK_EXTENSION_I(SGI_color_matrix, pname); 5635 *params = ctx->ColorMatrixStack.Depth + 1; 5636 break; 5637 case GL_MAX_COLOR_MATRIX_STACK_DEPTH_SGI: 5638 CHECK_EXTENSION_I(SGI_color_matrix, pname); 5639 *params = MAX_COLOR_STACK_DEPTH; 5640 break; 5641 case GL_POST_COLOR_MATRIX_RED_SCALE_SGI: 5642 CHECK_EXTENSION_I(SGI_color_matrix, pname); 5643 *params = (GLint) ctx->Pixel.PostColorMatrixScale[0]; 5644 break; 5645 case GL_POST_COLOR_MATRIX_GREEN_SCALE_SGI: 5646 CHECK_EXTENSION_I(SGI_color_matrix, pname); 5647 *params = (GLint) ctx->Pixel.PostColorMatrixScale[1]; 5648 break; 5649 case GL_POST_COLOR_MATRIX_BLUE_SCALE_SGI: 5650 CHECK_EXTENSION_I(SGI_color_matrix, pname); 5651 *params = (GLint) ctx->Pixel.PostColorMatrixScale[2]; 5652 break; 5653 case GL_POST_COLOR_MATRIX_ALPHA_SCALE_SGI: 5654 CHECK_EXTENSION_I(SGI_color_matrix, pname); 5655 *params = (GLint) ctx->Pixel.PostColorMatrixScale[3]; 5656 break; 5657 case GL_POST_COLOR_MATRIX_RED_BIAS_SGI: 5658 CHECK_EXTENSION_I(SGI_color_matrix, pname); 5659 *params = (GLint) ctx->Pixel.PostColorMatrixBias[0]; 5660 break; 5661 case GL_POST_COLOR_MATRIX_GREEN_BIAS_SGI: 5662 CHECK_EXTENSION_I(SGI_color_matrix, pname); 5663 *params = (GLint) ctx->Pixel.PostColorMatrixBias[1]; 5664 break; 5665 case GL_POST_COLOR_MATRIX_BLUE_BIAS_SGI: 5666 CHECK_EXTENSION_I(SGI_color_matrix, pname); 5667 *params = (GLint) ctx->Pixel.PostColorMatrixBias[2]; 5668 break; 5669 case GL_POST_COLOR_MATRIX_ALPHA_BIAS_SGI: 5670 CHECK_EXTENSION_I(SGI_color_matrix, pname); 5671 *params = (GLint) ctx->Pixel.PostColorMatrixBias[3]; 5672 break; 5673 5674 /* GL_EXT_convolution (also in 1.2 imaging) */ 5675 case GL_CONVOLUTION_1D_EXT: 5676 CHECK_EXTENSION_I(EXT_convolution, pname); 5677 *params = (GLint) ctx->Pixel.Convolution1DEnabled; 5678 break; 5679 case GL_CONVOLUTION_2D: 5680 CHECK_EXTENSION_I(EXT_convolution, pname); 5681 *params = (GLint) ctx->Pixel.Convolution2DEnabled; 5682 break; 5683 case GL_SEPARABLE_2D: 5684 CHECK_EXTENSION_I(EXT_convolution, pname); 5685 *params = (GLint) ctx->Pixel.Separable2DEnabled; 5686 break; 5687 case GL_POST_CONVOLUTION_RED_SCALE_EXT: 5688 CHECK_EXTENSION_I(EXT_convolution, pname); 5689 *params = (GLint) ctx->Pixel.PostConvolutionScale[0]; 5690 break; 5691 case GL_POST_CONVOLUTION_GREEN_SCALE_EXT: 5692 CHECK_EXTENSION_I(EXT_convolution, pname); 5693 *params = (GLint) ctx->Pixel.PostConvolutionScale[1]; 5694 break; 5695 case GL_POST_CONVOLUTION_BLUE_SCALE_EXT: 5696 CHECK_EXTENSION_I(EXT_convolution, pname); 5697 *params = (GLint) ctx->Pixel.PostConvolutionScale[2]; 5698 break; 5699 case GL_POST_CONVOLUTION_ALPHA_SCALE_EXT: 5700 CHECK_EXTENSION_I(EXT_convolution, pname); 5701 *params = (GLint) ctx->Pixel.PostConvolutionScale[3]; 5702 break; 5703 case GL_POST_CONVOLUTION_RED_BIAS_EXT: 5704 CHECK_EXTENSION_I(EXT_convolution, pname); 5705 *params = (GLint) ctx->Pixel.PostConvolutionBias[0]; 5706 break; 5707 case GL_POST_CONVOLUTION_GREEN_BIAS_EXT: 5708 CHECK_EXTENSION_I(EXT_convolution, pname); 5709 *params = (GLint) ctx->Pixel.PostConvolutionBias[1]; 5710 break; 5711 case GL_POST_CONVOLUTION_BLUE_BIAS_EXT: 5712 CHECK_EXTENSION_I(EXT_convolution, pname); 5713 *params = (GLint) ctx->Pixel.PostConvolutionBias[2]; 5714 break; 5715 case GL_POST_CONVOLUTION_ALPHA_BIAS_EXT: 5716 CHECK_EXTENSION_I(EXT_convolution, pname); 5717 *params = (GLint) ctx->Pixel.PostConvolutionBias[2]; 5718 break; 5719 5720 /* GL_EXT_histogram (also in 1.2 imaging) */ 5721 case GL_HISTOGRAM: 5722 CHECK_EXTENSION_I(EXT_histogram, pname); 5723 *params = (GLint) ctx->Pixel.HistogramEnabled; 5724 break; 5725 case GL_MINMAX: 5726 CHECK_EXTENSION_I(EXT_histogram, pname); 5727 *params = (GLint) ctx->Pixel.MinMaxEnabled; 5728 break; 5729 5730 /* GL_SGI_color_table (also in 1.2 imaging */ 5731 case GL_COLOR_TABLE_SGI: 5732 CHECK_EXTENSION_I(SGI_color_table, pname); 5733 *params = (GLint) ctx->Pixel.ColorTableEnabled; 5734 break; 5735 case GL_POST_CONVOLUTION_COLOR_TABLE_SGI: 5736 CHECK_EXTENSION_I(SGI_color_table, pname); 5737 *params = (GLint) ctx->Pixel.PostConvolutionColorTableEnabled; 5738 break; 5739 case GL_POST_COLOR_MATRIX_COLOR_TABLE_SGI: 5740 CHECK_EXTENSION_I(SGI_color_table, pname); 5741 *params = (GLint) ctx->Pixel.PostColorMatrixColorTableEnabled; 5742 break; 5743 5744 /* GL_SGI_texture_color_table */ 5745 case GL_TEXTURE_COLOR_TABLE_SGI: 5746 CHECK_EXTENSION_I(SGI_texture_color_table, pname); 5747 *params = (GLint) textureUnit->ColorTableEnabled; 5748 break; 5749 5750 /* GL_EXT_secondary_color */ 5751 case GL_COLOR_SUM_EXT: 5752 CHECK_EXTENSION_I(EXT_secondary_color, pname); 5753 *params = (GLint) ctx->Fog.ColorSumEnabled; 5754 break; 5755 case GL_CURRENT_SECONDARY_COLOR_EXT: 5756 CHECK_EXTENSION_I(EXT_secondary_color, pname); 5757 FLUSH_CURRENT(ctx, 0); 5758 params[0] = FLOAT_TO_INT( (ctx->Current.Attrib[VERT_ATTRIB_COLOR1][0]) ); 5759 params[1] = FLOAT_TO_INT( (ctx->Current.Attrib[VERT_ATTRIB_COLOR1][1]) ); 5760 params[2] = FLOAT_TO_INT( (ctx->Current.Attrib[VERT_ATTRIB_COLOR1][2]) ); 5761 params[3] = FLOAT_TO_INT( (ctx->Current.Attrib[VERT_ATTRIB_COLOR1][3]) ); 5762 break; 5763 case GL_SECONDARY_COLOR_ARRAY_EXT: 5764 CHECK_EXTENSION_I(EXT_secondary_color, pname); 5765 *params = (GLint) ctx->Array.SecondaryColor.Enabled; 5766 break; 5767 case GL_SECONDARY_COLOR_ARRAY_TYPE_EXT: 5768 CHECK_EXTENSION_I(EXT_secondary_color, pname); 5769 *params = (GLint) ctx->Array.SecondaryColor.Type; 5770 break; 5771 case GL_SECONDARY_COLOR_ARRAY_STRIDE_EXT: 5772 CHECK_EXTENSION_I(EXT_secondary_color, pname); 5773 *params = (GLint) ctx->Array.SecondaryColor.Stride; 5774 break; 5775 case GL_SECONDARY_COLOR_ARRAY_SIZE_EXT: 5776 CHECK_EXTENSION_I(EXT_secondary_color, pname); 5777 *params = (GLint) ctx->Array.SecondaryColor.Size; 5778 break; 5779 5780 /* GL_EXT_fog_coord */ 5781 case GL_CURRENT_FOG_COORDINATE_EXT: 5782 CHECK_EXTENSION_I(EXT_fog_coord, pname); 5783 FLUSH_CURRENT(ctx, 0); 5784 *params = (GLint) ctx->Current.Attrib[VERT_ATTRIB_FOG][0]; 5785 break; 5786 case GL_FOG_COORDINATE_ARRAY_EXT: 5787 CHECK_EXTENSION_I(EXT_fog_coord, pname); 5788 *params = (GLint) ctx->Array.FogCoord.Enabled; 5789 break; 5790 case GL_FOG_COORDINATE_ARRAY_TYPE_EXT: 5791 CHECK_EXTENSION_I(EXT_fog_coord, pname); 5792 *params = (GLint) ctx->Array.FogCoord.Type; 5793 break; 5794 case GL_FOG_COORDINATE_ARRAY_STRIDE_EXT: 5795 CHECK_EXTENSION_I(EXT_fog_coord, pname); 5796 *params = (GLint) ctx->Array.FogCoord.Stride; 5797 break; 5798 case GL_FOG_COORDINATE_SOURCE_EXT: 5799 CHECK_EXTENSION_I(EXT_fog_coord, pname); 5800 *params = (GLint) ctx->Fog.FogCoordinateSource; 5801 break; 5802 5803 /* GL_EXT_texture_lod_bias */ 5804 case GL_MAX_TEXTURE_LOD_BIAS_EXT: 5805 *params = (GLint) ctx->Const.MaxTextureLodBias; 5806 break; 5807 5808 /* GL_EXT_texture_filter_anisotropic */ 5809 case GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT: 5810 CHECK_EXTENSION_I(EXT_texture_filter_anisotropic, pname); 5811 *params = (GLint) ctx->Const.MaxTextureMaxAnisotropy; 5812 break; 5813 5814 /* GL_ARB_multisample */ 5815 case GL_MULTISAMPLE_ARB: 5816 CHECK_EXTENSION_I(ARB_multisample, pname); 5817 *params = (GLint) ctx->Multisample.Enabled; 5818 break; 5819 case GL_SAMPLE_ALPHA_TO_COVERAGE_ARB: 5820 CHECK_EXTENSION_I(ARB_multisample, pname); 5821 *params = (GLint) ctx->Multisample.SampleAlphaToCoverage; 5822 break; 5823 case GL_SAMPLE_ALPHA_TO_ONE_ARB: 5824 CHECK_EXTENSION_I(ARB_multisample, pname); 5825 *params = (GLint) ctx->Multisample.SampleAlphaToOne; 5826 break; 5827 case GL_SAMPLE_COVERAGE_ARB: 5828 CHECK_EXTENSION_I(ARB_multisample, pname); 5829 *params = (GLint) ctx->Multisample.SampleCoverage; 5830 break; 5831 case GL_SAMPLE_COVERAGE_VALUE_ARB: 5832 CHECK_EXTENSION_I(ARB_multisample, pname); 5833 *params = (GLint) ctx->Multisample.SampleCoverageValue; 5834 break; 5835 case GL_SAMPLE_COVERAGE_INVERT_ARB: 5836 CHECK_EXTENSION_I(ARB_multisample, pname); 5837 *params = (GLint) ctx->Multisample.SampleCoverageInvert; 5838 break; 5839 case GL_SAMPLE_BUFFERS_ARB: 5840 CHECK_EXTENSION_I(ARB_multisample, pname); 5841 *params = 0; /* XXX fix someday */ 5842 break; 5843 case GL_SAMPLES_ARB: 5844 CHECK_EXTENSION_I(ARB_multisample, pname); 5845 *params = 0; /* XXX fix someday */ 5846 break; 5847 5848 /* GL_IBM_rasterpos_clip */ 5849 case GL_RASTER_POSITION_UNCLIPPED_IBM: 5850 CHECK_EXTENSION_I(IBM_rasterpos_clip, pname); 5851 *params = (GLint) ctx->Transform.RasterPositionUnclipped; 5852 break; 5853 5854 /* GL_NV_point_sprite */ 5855 case GL_POINT_SPRITE_NV: 5856 CHECK_EXTENSION_I(NV_point_sprite, pname); 5857 *params = (GLint) ctx->Point.PointSprite; 5858 break; 5859 case GL_POINT_SPRITE_R_MODE_NV: 5860 CHECK_EXTENSION_I(NV_point_sprite, pname); 5861 *params = (GLint) ctx->Point.SpriteRMode; 5862 break; 5863 5864 /* GL_SGIS_generate_mipmap */ 5865 case GL_GENERATE_MIPMAP_HINT_SGIS: 5866 CHECK_EXTENSION_I(SGIS_generate_mipmap, pname); 5867 *params = (GLint) ctx->Hint.GenerateMipmap; 5868 break; 5869 5870#if FEATURE_NV_vertex_program 5871 case GL_VERTEX_PROGRAM_NV: 5872 CHECK_EXTENSION_I(NV_vertex_program, pname); 5873 *params = (GLint) ctx->VertexProgram.Enabled; 5874 break; 5875 case GL_VERTEX_PROGRAM_POINT_SIZE_NV: 5876 CHECK_EXTENSION_I(NV_vertex_program, pname); 5877 *params = (GLint) ctx->VertexProgram.PointSizeEnabled; 5878 break; 5879 case GL_VERTEX_PROGRAM_TWO_SIDE_NV: 5880 CHECK_EXTENSION_I(NV_vertex_program, pname); 5881 *params = (GLint) ctx->VertexProgram.TwoSideEnabled; 5882 break; 5883 case GL_MAX_TRACK_MATRIX_STACK_DEPTH_NV: 5884 CHECK_EXTENSION_I(NV_vertex_program, pname); 5885 *params = ctx->Const.MaxProgramMatrixStackDepth; 5886 break; 5887 case GL_MAX_TRACK_MATRICES_NV: 5888 CHECK_EXTENSION_I(NV_vertex_program, pname); 5889 *params = ctx->Const.MaxProgramMatrices; 5890 break; 5891 case GL_CURRENT_MATRIX_STACK_DEPTH_NV: 5892 CHECK_EXTENSION_I(NV_vertex_program, pname); 5893 *params = ctx->CurrentStack->Depth + 1; 5894 break; 5895 case GL_CURRENT_MATRIX_NV: 5896 CHECK_EXTENSION_I(NV_vertex_program, pname); 5897 for (i = 0; i < 16; i++) 5898 params[i] = (GLint) ctx->CurrentStack->Top->m[i]; 5899 break; 5900 case GL_VERTEX_PROGRAM_BINDING_NV: 5901 CHECK_EXTENSION_I(NV_vertex_program, pname); 5902 if (ctx->VertexProgram.Current) 5903 *params = (GLint) ctx->VertexProgram.Current->Base.Id; 5904 else 5905 *params = 0; 5906 break; 5907 case GL_PROGRAM_ERROR_POSITION_NV: 5908 CHECK_EXTENSION_I(NV_vertex_program, pname); 5909 *params = (GLint) ctx->Program.ErrorPos; 5910 break; 5911 case GL_VERTEX_ATTRIB_ARRAY0_NV: 5912 case GL_VERTEX_ATTRIB_ARRAY1_NV: 5913 case GL_VERTEX_ATTRIB_ARRAY2_NV: 5914 case GL_VERTEX_ATTRIB_ARRAY3_NV: 5915 case GL_VERTEX_ATTRIB_ARRAY4_NV: 5916 case GL_VERTEX_ATTRIB_ARRAY5_NV: 5917 case GL_VERTEX_ATTRIB_ARRAY6_NV: 5918 case GL_VERTEX_ATTRIB_ARRAY7_NV: 5919 case GL_VERTEX_ATTRIB_ARRAY8_NV: 5920 case GL_VERTEX_ATTRIB_ARRAY9_NV: 5921 case GL_VERTEX_ATTRIB_ARRAY10_NV: 5922 case GL_VERTEX_ATTRIB_ARRAY11_NV: 5923 case GL_VERTEX_ATTRIB_ARRAY12_NV: 5924 case GL_VERTEX_ATTRIB_ARRAY13_NV: 5925 case GL_VERTEX_ATTRIB_ARRAY14_NV: 5926 case GL_VERTEX_ATTRIB_ARRAY15_NV: 5927 CHECK_EXTENSION_I(NV_vertex_program, pname); 5928 { 5929 GLuint n = (GLuint) pname - GL_VERTEX_ATTRIB_ARRAY0_NV; 5930 *params = (GLint) ctx->Array.VertexAttrib[n].Enabled; 5931 } 5932 break; 5933 case GL_MAP1_VERTEX_ATTRIB0_4_NV: 5934 case GL_MAP1_VERTEX_ATTRIB1_4_NV: 5935 case GL_MAP1_VERTEX_ATTRIB2_4_NV: 5936 case GL_MAP1_VERTEX_ATTRIB3_4_NV: 5937 case GL_MAP1_VERTEX_ATTRIB4_4_NV: 5938 case GL_MAP1_VERTEX_ATTRIB5_4_NV: 5939 case GL_MAP1_VERTEX_ATTRIB6_4_NV: 5940 case GL_MAP1_VERTEX_ATTRIB7_4_NV: 5941 case GL_MAP1_VERTEX_ATTRIB8_4_NV: 5942 case GL_MAP1_VERTEX_ATTRIB9_4_NV: 5943 case GL_MAP1_VERTEX_ATTRIB10_4_NV: 5944 case GL_MAP1_VERTEX_ATTRIB11_4_NV: 5945 case GL_MAP1_VERTEX_ATTRIB12_4_NV: 5946 case GL_MAP1_VERTEX_ATTRIB13_4_NV: 5947 case GL_MAP1_VERTEX_ATTRIB14_4_NV: 5948 case GL_MAP1_VERTEX_ATTRIB15_4_NV: 5949 CHECK_EXTENSION_I(NV_vertex_program, pname); 5950 { 5951 GLuint n = (GLuint) pname - GL_MAP1_VERTEX_ATTRIB0_4_NV; 5952 *params = (GLint) ctx->Eval.Map1Attrib[n]; 5953 } 5954 break; 5955 case GL_MAP2_VERTEX_ATTRIB0_4_NV: 5956 case GL_MAP2_VERTEX_ATTRIB1_4_NV: 5957 case GL_MAP2_VERTEX_ATTRIB2_4_NV: 5958 case GL_MAP2_VERTEX_ATTRIB3_4_NV: 5959 case GL_MAP2_VERTEX_ATTRIB4_4_NV: 5960 case GL_MAP2_VERTEX_ATTRIB5_4_NV: 5961 case GL_MAP2_VERTEX_ATTRIB6_4_NV: 5962 case GL_MAP2_VERTEX_ATTRIB7_4_NV: 5963 case GL_MAP2_VERTEX_ATTRIB8_4_NV: 5964 case GL_MAP2_VERTEX_ATTRIB9_4_NV: 5965 case GL_MAP2_VERTEX_ATTRIB10_4_NV: 5966 case GL_MAP2_VERTEX_ATTRIB11_4_NV: 5967 case GL_MAP2_VERTEX_ATTRIB12_4_NV: 5968 case GL_MAP2_VERTEX_ATTRIB13_4_NV: 5969 case GL_MAP2_VERTEX_ATTRIB14_4_NV: 5970 case GL_MAP2_VERTEX_ATTRIB15_4_NV: 5971 CHECK_EXTENSION_I(NV_vertex_program, pname); 5972 { 5973 GLuint n = (GLuint) pname - GL_MAP2_VERTEX_ATTRIB0_4_NV; 5974 *params = (GLint) ctx->Eval.Map2Attrib[n]; 5975 } 5976 break; 5977#endif /* FEATURE_NV_vertex_program */ 5978 5979#if FEATURE_NV_fragment_program 5980 case GL_FRAGMENT_PROGRAM_NV: 5981 CHECK_EXTENSION_I(NV_fragment_program, pname); 5982 *params = (GLint) ctx->FragmentProgram.Enabled; 5983 break; 5984 case GL_MAX_TEXTURE_COORDS_NV: 5985 CHECK_EXTENSION_I(NV_fragment_program, pname); 5986 *params = (GLint) ctx->Const.MaxTextureCoordUnits; 5987 break; 5988 case GL_MAX_TEXTURE_IMAGE_UNITS_NV: 5989 CHECK_EXTENSION_I(NV_fragment_program, pname); 5990 *params = (GLint) ctx->Const.MaxTextureImageUnits; 5991 break; 5992 case GL_FRAGMENT_PROGRAM_BINDING_NV: 5993 CHECK_EXTENSION_I(NV_fragment_program, pname); 5994 if (ctx->FragmentProgram.Current) 5995 *params = (GLint) ctx->FragmentProgram.Current->Base.Id; 5996 else 5997 *params = 0; 5998 break; 5999 case GL_MAX_FRAGMENT_PROGRAM_LOCAL_PARAMETERS_NV: 6000 CHECK_EXTENSION_I(NV_fragment_program, pname); 6001 *params = MAX_NV_FRAGMENT_PROGRAM_PARAMS; 6002 break; 6003#endif /* FEATURE_NV_fragment_program */ 6004 6005 /* GL_NV_texture_rectangle */ 6006 case GL_TEXTURE_RECTANGLE_NV: 6007 CHECK_EXTENSION_I(NV_texture_rectangle, pname); 6008 *params = (GLint) _mesa_IsEnabled(GL_TEXTURE_RECTANGLE_NV); 6009 break; 6010 case GL_TEXTURE_BINDING_RECTANGLE_NV: 6011 CHECK_EXTENSION_I(NV_texture_rectangle, pname); 6012 *params = (GLint) textureUnit->CurrentRect->Name; 6013 break; 6014 case GL_MAX_RECTANGLE_TEXTURE_SIZE_NV: 6015 CHECK_EXTENSION_I(NV_texture_rectangle, pname); 6016 *params = (GLint) ctx->Const.MaxTextureRectSize; 6017 break; 6018 6019 /* GL_EXT_stencil_two_side */ 6020 case GL_STENCIL_TEST_TWO_SIDE_EXT: 6021 CHECK_EXTENSION_I(EXT_stencil_two_side, pname); 6022 *params = (GLint) ctx->Stencil.TestTwoSide; 6023 break; 6024 case GL_ACTIVE_STENCIL_FACE_EXT: 6025 CHECK_EXTENSION_I(EXT_stencil_two_side, pname); 6026 *params = (GLint) (ctx->Stencil.ActiveFace ? GL_BACK : GL_FRONT); 6027 break; 6028 6029 /* GL_NV_light_max_exponent */ 6030 case GL_MAX_SHININESS_NV: 6031 *params = (GLint) ctx->Const.MaxShininess; 6032 break; 6033 case GL_MAX_SPOT_EXPONENT_NV: 6034 *params = (GLint) ctx->Const.MaxSpotExponent; 6035 break; 6036 6037#if FEATURE_ARB_vertex_buffer_object 6038 case GL_ARRAY_BUFFER_BINDING_ARB: 6039 CHECK_EXTENSION_I(ARB_vertex_buffer_object, pname); 6040 *params = (GLint) ctx->Array.ArrayBufferBinding; 6041 break; 6042 case GL_VERTEX_ARRAY_BUFFER_BINDING_ARB: 6043 CHECK_EXTENSION_I(ARB_vertex_buffer_object, pname); 6044 *params = (GLint) ctx->Array.VertexArrayBufferBinding; 6045 break; 6046 case GL_NORMAL_ARRAY_BUFFER_BINDING_ARB: 6047 CHECK_EXTENSION_I(ARB_vertex_buffer_object, pname); 6048 *params = (GLint) ctx->Array.NormalArrayBufferBinding; 6049 break; 6050 case GL_COLOR_ARRAY_BUFFER_BINDING_ARB: 6051 CHECK_EXTENSION_I(ARB_vertex_buffer_object, pname); 6052 *params = (GLint) ctx->Array.ColorArrayBufferBinding; 6053 break; 6054 case GL_INDEX_ARRAY_BUFFER_BINDING_ARB: 6055 CHECK_EXTENSION_I(ARB_vertex_buffer_object, pname); 6056 *params = (GLint) ctx->Array.IndexArrayBufferBinding; 6057 break; 6058 case GL_TEXTURE_COORD_ARRAY_BUFFER_BINDING_ARB: 6059 CHECK_EXTENSION_I(ARB_vertex_buffer_object, pname); 6060 *params = (GLint) ctx->Array.TextureArrayBufferBinding; 6061 break; 6062 case GL_EDGE_FLAG_ARRAY_BUFFER_BINDING_ARB: 6063 CHECK_EXTENSION_I(ARB_vertex_buffer_object, pname); 6064 *params = (GLint) ctx->Array.EdgeFlagArrayBufferBinding; 6065 break; 6066 case GL_SECONDARY_COLOR_ARRAY_BUFFER_BINDING_ARB: 6067 CHECK_EXTENSION_I(ARB_vertex_buffer_object, pname); 6068 *params = (GLint) ctx->Array.SecondaryColorArrayBufferBinding; 6069 break; 6070 case GL_FOG_COORDINATE_ARRAY_BUFFER_BINDING_ARB: 6071 CHECK_EXTENSION_I(ARB_vertex_buffer_object, pname); 6072 *params = (GLint) ctx->Array.FogCoordArrayBufferBinding; 6073 break; 6074 case GL_WEIGHT_ARRAY_BUFFER_BINDING_ARB: 6075 CHECK_EXTENSION_I(ARB_vertex_buffer_object, pname); 6076 *params = (GLint) ctx->Array.WeightArrayBufferBinding; 6077 break; 6078 case GL_ELEMENT_ARRAY_BUFFER_BINDING_ARB: 6079 CHECK_EXTENSION_I(ARB_vertex_buffer_object, pname); 6080 *params = (GLint) ctx->Array.ElementArrayBufferBinding; 6081 break; 6082#endif 6083 6084#if FEATURE_ARB_fragment_program 6085 case GL_FRAGMENT_PROGRAM_ARB: 6086 CHECK_EXTENSION_I(ARB_fragment_program, pname); 6087 *params = ctx->FragmentProgram.Enabled; 6088 break; 6089 case GL_TRANSPOSE_CURRENT_MATRIX_ARB: 6090 CHECK_EXTENSION_I(ARB_fragment_program, pname); 6091 params[0] = (GLint) ctx->CurrentStack->Top->m[0]; 6092 params[1] = (GLint) ctx->CurrentStack->Top->m[4]; 6093 params[2] = (GLint) ctx->CurrentStack->Top->m[8]; 6094 params[3] = (GLint) ctx->CurrentStack->Top->m[12]; 6095 params[4] = (GLint) ctx->CurrentStack->Top->m[1]; 6096 params[5] = (GLint) ctx->CurrentStack->Top->m[5]; 6097 params[6] = (GLint) ctx->CurrentStack->Top->m[9]; 6098 params[7] = (GLint) ctx->CurrentStack->Top->m[13]; 6099 params[8] = (GLint) ctx->CurrentStack->Top->m[2]; 6100 params[9] = (GLint) ctx->CurrentStack->Top->m[6]; 6101 params[10] = (GLint) ctx->CurrentStack->Top->m[10]; 6102 params[11] = (GLint) ctx->CurrentStack->Top->m[14]; 6103 params[12] = (GLint) ctx->CurrentStack->Top->m[3]; 6104 params[13] = (GLint) ctx->CurrentStack->Top->m[7]; 6105 params[14] = (GLint) ctx->CurrentStack->Top->m[11]; 6106 params[15] = (GLint) ctx->CurrentStack->Top->m[15]; 6107 break; 6108 /* Remaining ARB_fragment_program queries alias with 6109 * the GL_NV_fragment_program queries. 6110 */ 6111#endif 6112 6113 /* GL_EXT_depth_bounds_test */ 6114 case GL_DEPTH_BOUNDS_TEST_EXT: 6115 CHECK_EXTENSION_I(EXT_depth_bounds_test, pname); 6116 params[0] = ctx->Depth.BoundsTest; 6117 break; 6118 case GL_DEPTH_BOUNDS_EXT: 6119 CHECK_EXTENSION_I(EXT_depth_bounds_test, pname); 6120 params[0] = (GLint) ctx->Depth.BoundsMin; 6121 params[1] = (GLint) ctx->Depth.BoundsMax; 6122 break; 6123 6124 default: 6125 _mesa_error(ctx, GL_INVALID_ENUM, "glGetIntegerv(pname=0x%x)", pname); 6126 } 6127} 6128 6129 6130 6131void 6132_mesa_GetPointerv( GLenum pname, GLvoid **params ) 6133{ 6134 GET_CURRENT_CONTEXT(ctx); 6135 GLuint texUnit = ctx->Texture.CurrentUnit; 6136 ASSERT_OUTSIDE_BEGIN_END(ctx); 6137 6138 if (!params) 6139 return; 6140 6141 if (MESA_VERBOSE & VERBOSE_API) 6142 _mesa_debug(ctx, "glGetPointerv %s\n", _mesa_lookup_enum_by_nr(pname)); 6143 6144 if (ctx->Driver.GetPointerv 6145 && (*ctx->Driver.GetPointerv)(ctx, pname, params)) 6146 return; 6147 6148 switch (pname) { 6149 case GL_VERTEX_ARRAY_POINTER: 6150 *params = ctx->Array.Vertex.Ptr; 6151 break; 6152 case GL_NORMAL_ARRAY_POINTER: 6153 *params = ctx->Array.Normal.Ptr; 6154 break; 6155 case GL_COLOR_ARRAY_POINTER: 6156 *params = ctx->Array.Color.Ptr; 6157 break; 6158 case GL_SECONDARY_COLOR_ARRAY_POINTER_EXT: 6159 *params = ctx->Array.SecondaryColor.Ptr; 6160 break; 6161 case GL_FOG_COORDINATE_ARRAY_POINTER_EXT: 6162 *params = ctx->Array.FogCoord.Ptr; 6163 break; 6164 case GL_INDEX_ARRAY_POINTER: 6165 *params = ctx->Array.Index.Ptr; 6166 break; 6167 case GL_TEXTURE_COORD_ARRAY_POINTER: 6168 *params = ctx->Array.TexCoord[texUnit].Ptr; 6169 break; 6170 case GL_EDGE_FLAG_ARRAY_POINTER: 6171 *params = ctx->Array.EdgeFlag.Ptr; 6172 break; 6173 case GL_FEEDBACK_BUFFER_POINTER: 6174 *params = ctx->Feedback.Buffer; 6175 break; 6176 case GL_SELECTION_BUFFER_POINTER: 6177 *params = ctx->Select.Buffer; 6178 break; 6179 default: 6180 _mesa_error( ctx, GL_INVALID_ENUM, "glGetPointerv" ); 6181 return; 6182 } 6183} 6184 6185 6186 6187const GLubyte * 6188_mesa_GetString( GLenum name ) 6189{ 6190 GET_CURRENT_CONTEXT(ctx); 6191 static const char *vendor = "Brian Paul"; 6192 static const char *renderer = "Mesa"; 6193 static const char *version_1_2 = "1.2 Mesa " MESA_VERSION_STRING; 6194 static const char *version_1_3 = "1.3 Mesa " MESA_VERSION_STRING; 6195 static const char *version_1_4 = "1.4 Mesa " MESA_VERSION_STRING; 6196 6197 ASSERT_OUTSIDE_BEGIN_END_WITH_RETVAL(ctx, 0); 6198 6199 /* this is a required driver function */ 6200 assert(ctx->Driver.GetString); 6201 { 6202 const GLubyte *str = (*ctx->Driver.GetString)(ctx, name); 6203 if (str) 6204 return str; 6205 6206 switch (name) { 6207 case GL_VENDOR: 6208 return (const GLubyte *) vendor; 6209 case GL_RENDERER: 6210 return (const GLubyte *) renderer; 6211 case GL_VERSION: 6212 if (ctx->Extensions.ARB_multisample && 6213 ctx->Extensions.ARB_multitexture && 6214 ctx->Extensions.ARB_texture_border_clamp && 6215 ctx->Extensions.ARB_texture_compression && 6216 ctx->Extensions.ARB_texture_cube_map && 6217 ctx->Extensions.EXT_texture_env_add && 6218 ctx->Extensions.ARB_texture_env_combine && 6219 ctx->Extensions.ARB_texture_env_dot3) { 6220 if (ctx->Extensions.ARB_depth_texture && 6221 ctx->Extensions.ARB_shadow && 6222 ctx->Extensions.ARB_texture_env_crossbar && 6223 ctx->Extensions.ARB_texture_mirrored_repeat && 6224 ctx->Extensions.ARB_window_pos && 6225 ctx->Extensions.EXT_blend_color && 6226 ctx->Extensions.EXT_blend_func_separate && 6227 ctx->Extensions.EXT_blend_logic_op && 6228 ctx->Extensions.EXT_blend_minmax && 6229 ctx->Extensions.EXT_blend_subtract && 6230 ctx->Extensions.EXT_fog_coord && 6231 ctx->Extensions.EXT_multi_draw_arrays && 6232 ctx->Extensions.EXT_point_parameters && /*aka ARB*/ 6233 ctx->Extensions.EXT_secondary_color && 6234 ctx->Extensions.EXT_stencil_wrap && 6235 ctx->Extensions.SGIS_generate_mipmap) { 6236 return (const GLubyte *) version_1_4; 6237 } 6238 else { 6239 return (const GLubyte *) version_1_3; 6240 } 6241 } 6242 else { 6243 return (const GLubyte *) version_1_2; 6244 } 6245 case GL_EXTENSIONS: 6246 return (const GLubyte *) _mesa_extensions_get_string(ctx); 6247#if FEATURE_NV_fragment_program 6248 case GL_PROGRAM_ERROR_STRING_NV: 6249 if (ctx->Extensions.NV_fragment_program) { 6250 return (const GLubyte *) ctx->Program.ErrorString; 6251 } 6252 /* FALL-THROUGH */ 6253#endif 6254 default: 6255 _mesa_error( ctx, GL_INVALID_ENUM, "glGetString" ); 6256 return (const GLubyte *) 0; 6257 } 6258 } 6259} 6260 6261 6262/* 6263 * Execute a glGetError command 6264 */ 6265GLenum 6266_mesa_GetError( void ) 6267{ 6268 GET_CURRENT_CONTEXT(ctx); 6269 GLenum e = ctx->ErrorValue; 6270 ASSERT_OUTSIDE_BEGIN_END_WITH_RETVAL(ctx, 0); 6271 6272 if (MESA_VERBOSE & VERBOSE_API) 6273 _mesa_debug(ctx, "glGetError <-- %s\n", _mesa_lookup_enum_by_nr(e)); 6274 6275 ctx->ErrorValue = (GLenum) GL_NO_ERROR; 6276 return e; 6277} 6278