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