projects / mesa.git / blob
? search:


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