projects / mesa.git / blob
? search:


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