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