Debian Codegraph @

nx-X11/extras/Mesa/src/mesa/main/get.c

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