projects / mesa.git / blob
? search:


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