projects / mesa.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
new fix for initial window size problem
[mesa.git] / src / mesa / main / get.c
1 /* $Id: get.c,v 1.82 2002/06/15 03:03:08 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 _mesa_debug(ctx, "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 /* GL_NV_texture_rectangle */
1445 case GL_TEXTURE_RECTANGLE_NV:
1446 CHECK_EXTENSION_B(NV_texture_rectangle);
1447 *params = _mesa_IsEnabled(GL_TEXTURE_RECTANGLE_NV);
1448 break;
1449 case GL_TEXTURE_BINDING_RECTANGLE_NV:
1450 CHECK_EXTENSION_B(NV_texture_rectangle);
1451 *params = INT_TO_BOOL(textureUnit->CurrentRect->Name);
1452 break;
1453 case GL_MAX_RECTANGLE_TEXTURE_SIZE_NV:
1454 CHECK_EXTENSION_B(NV_texture_rectangle);
1455 *params = INT_TO_BOOL(ctx->Const.MaxTextureRectSize);
1456 break;
1457
1458 default:
1459 _mesa_error( ctx, GL_INVALID_ENUM, "glGetBooleanv" );
1460 }
1461 }
1462
1463
1464 void
1465 _mesa_GetDoublev( GLenum pname, GLdouble *params )
1466 {
1467 GET_CURRENT_CONTEXT(ctx);
1468 GLuint i;
1469 GLuint texUnit = ctx->Texture.CurrentUnit;
1470 const struct gl_texture_unit *textureUnit = &ctx->Texture.Unit[texUnit];
1471 ASSERT_OUTSIDE_BEGIN_END(ctx);
1472
1473 if (!params)
1474 return;
1475
1476 /* We need this in order to get correct results for
1477 * GL_OCCLUSION_TEST_RESULT_HP. There might be other important cases.
1478 */
1479 FLUSH_VERTICES(ctx, 0);
1480
1481 if (MESA_VERBOSE & VERBOSE_API)
1482 _mesa_debug(ctx, "glGetDoublev %s\n", _mesa_lookup_enum_by_nr(pname));
1483
1484 if (ctx->Driver.GetDoublev && (*ctx->Driver.GetDoublev)(ctx, pname, params))
1485 return;
1486
1487 switch (pname) {
1488 case GL_ACCUM_RED_BITS:
1489 *params = (GLdouble) ctx->Visual.accumRedBits;
1490 break;
1491 case GL_ACCUM_GREEN_BITS:
1492 *params = (GLdouble) ctx->Visual.accumGreenBits;
1493 break;
1494 case GL_ACCUM_BLUE_BITS:
1495 *params = (GLdouble) ctx->Visual.accumBlueBits;
1496 break;
1497 case GL_ACCUM_ALPHA_BITS:
1498 *params = (GLdouble) ctx->Visual.accumAlphaBits;
1499 break;
1500 case GL_ACCUM_CLEAR_VALUE:
1501 params[0] = (GLdouble) ctx->Accum.ClearColor[0];
1502 params[1] = (GLdouble) ctx->Accum.ClearColor[1];
1503 params[2] = (GLdouble) ctx->Accum.ClearColor[2];
1504 params[3] = (GLdouble) ctx->Accum.ClearColor[3];
1505 break;
1506 case GL_ALPHA_BIAS:
1507 *params = (GLdouble) ctx->Pixel.AlphaBias;
1508 break;
1509 case GL_ALPHA_BITS:
1510 *params = (GLdouble) ctx->Visual.alphaBits;
1511 break;
1512 case GL_ALPHA_SCALE:
1513 *params = (GLdouble) ctx->Pixel.AlphaScale;
1514 break;
1515 case GL_ALPHA_TEST:
1516 *params = (GLdouble) ctx->Color.AlphaEnabled;
1517 break;
1518 case GL_ALPHA_TEST_FUNC:
1519 *params = ENUM_TO_DOUBLE(ctx->Color.AlphaFunc);
1520 break;
1521 case GL_ALPHA_TEST_REF:
1522 *params = (GLdouble) ctx->Color.AlphaRef / CHAN_MAXF;
1523 break;
1524 case GL_ATTRIB_STACK_DEPTH:
1525 *params = (GLdouble ) (ctx->AttribStackDepth);
1526 break;
1527 case GL_AUTO_NORMAL:
1528 *params = (GLdouble) ctx->Eval.AutoNormal;
1529 break;
1530 case GL_AUX_BUFFERS:
1531 *params = (GLdouble) ctx->Const.NumAuxBuffers;
1532 break;
1533 case GL_BLEND:
1534 *params = (GLdouble) ctx->Color.BlendEnabled;
1535 break;
1536 case GL_BLEND_DST:
1537 *params = ENUM_TO_DOUBLE(ctx->Color.BlendDstRGB);
1538 break;
1539 case GL_BLEND_SRC:
1540 *params = ENUM_TO_DOUBLE(ctx->Color.BlendSrcRGB);
1541 break;
1542 case GL_BLEND_SRC_RGB_EXT:
1543 *params = ENUM_TO_DOUBLE(ctx->Color.BlendSrcRGB);
1544 break;
1545 case GL_BLEND_DST_RGB_EXT:
1546 *params = ENUM_TO_DOUBLE(ctx->Color.BlendDstRGB);
1547 break;
1548 case GL_BLEND_SRC_ALPHA_EXT:
1549 *params = ENUM_TO_DOUBLE(ctx->Color.BlendSrcA);
1550 break;
1551 case GL_BLEND_DST_ALPHA_EXT:
1552 *params = ENUM_TO_DOUBLE(ctx->Color.BlendDstA);
1553 break;
1554 case GL_BLEND_EQUATION_EXT:
1555 *params = ENUM_TO_DOUBLE(ctx->Color.BlendEquation);
1556 break;
1557 case GL_BLEND_COLOR_EXT:
1558 params[0] = (GLdouble) ctx->Color.BlendColor[0];
1559 params[1] = (GLdouble) ctx->Color.BlendColor[1];
1560 params[2] = (GLdouble) ctx->Color.BlendColor[2];
1561 params[3] = (GLdouble) ctx->Color.BlendColor[3];
1562 break;
1563 case GL_BLUE_BIAS:
1564 *params = (GLdouble) ctx->Pixel.BlueBias;
1565 break;
1566 case GL_BLUE_BITS:
1567 *params = (GLdouble) ctx->Visual.blueBits;
1568 break;
1569 case GL_BLUE_SCALE:
1570 *params = (GLdouble) ctx->Pixel.BlueScale;
1571 break;
1572 case GL_CLIENT_ATTRIB_STACK_DEPTH:
1573 *params = (GLdouble) (ctx->ClientAttribStackDepth);
1574 break;
1575 case GL_CLIP_PLANE0:
1576 case GL_CLIP_PLANE1:
1577 case GL_CLIP_PLANE2:
1578 case GL_CLIP_PLANE3:
1579 case GL_CLIP_PLANE4:
1580 case GL_CLIP_PLANE5:
1581 if (ctx->Transform.ClipPlanesEnabled & (1 << (pname - GL_CLIP_PLANE0)))
1582 *params = 1.0;
1583 else
1584 *params = 0.0;
1585 break;
1586 case GL_COLOR_CLEAR_VALUE:
1587 params[0] = (GLdouble) CHAN_TO_FLOAT(ctx->Color.ClearColor[0]);
1588 params[1] = (GLdouble) CHAN_TO_FLOAT(ctx->Color.ClearColor[1]);
1589 params[2] = (GLdouble) CHAN_TO_FLOAT(ctx->Color.ClearColor[2]);
1590 params[3] = (GLdouble) CHAN_TO_FLOAT(ctx->Color.ClearColor[3]);
1591 break;
1592 case GL_COLOR_MATERIAL:
1593 *params = (GLdouble) ctx->Light.ColorMaterialEnabled;
1594 break;
1595 case GL_COLOR_MATERIAL_FACE:
1596 *params = ENUM_TO_DOUBLE(ctx->Light.ColorMaterialFace);
1597 break;
1598 case GL_COLOR_MATERIAL_PARAMETER:
1599 *params = ENUM_TO_DOUBLE(ctx->Light.ColorMaterialMode);
1600 break;
1601 case GL_COLOR_WRITEMASK:
1602 params[0] = ctx->Color.ColorMask[RCOMP] ? 1.0 : 0.0;
1603 params[1] = ctx->Color.ColorMask[GCOMP] ? 1.0 : 0.0;
1604 params[2] = ctx->Color.ColorMask[BCOMP] ? 1.0 : 0.0;
1605 params[3] = ctx->Color.ColorMask[ACOMP] ? 1.0 : 0.0;
1606 break;
1607 case GL_CULL_FACE:
1608 *params = (GLdouble) ctx->Polygon.CullFlag;
1609 break;
1610 case GL_CULL_FACE_MODE:
1611 *params = ENUM_TO_DOUBLE(ctx->Polygon.CullFaceMode);
1612 break;
1613 case GL_CURRENT_COLOR:
1614 FLUSH_CURRENT(ctx, 0);
1615 params[0] = ctx->Current.Attrib[VERT_ATTRIB_COLOR0][0];
1616 params[1] = ctx->Current.Attrib[VERT_ATTRIB_COLOR0][1];
1617 params[2] = ctx->Current.Attrib[VERT_ATTRIB_COLOR0][2];
1618 params[3] = ctx->Current.Attrib[VERT_ATTRIB_COLOR0][3];
1619 break;
1620 case GL_CURRENT_INDEX:
1621 FLUSH_CURRENT(ctx, 0);
1622 *params = (GLdouble) ctx->Current.Index;
1623 break;
1624 case GL_CURRENT_NORMAL:
1625 FLUSH_CURRENT(ctx, 0);
1626 params[0] = (GLdouble) ctx->Current.Attrib[VERT_ATTRIB_NORMAL][0];
1627 params[1] = (GLdouble) ctx->Current.Attrib[VERT_ATTRIB_NORMAL][1];
1628 params[2] = (GLdouble) ctx->Current.Attrib[VERT_ATTRIB_NORMAL][2];
1629 break;
1630 case GL_CURRENT_RASTER_COLOR:
1631 params[0] = (GLdouble) ctx->Current.RasterColor[0];
1632 params[1] = (GLdouble) ctx->Current.RasterColor[1];
1633 params[2] = (GLdouble) ctx->Current.RasterColor[2];
1634 params[3] = (GLdouble) ctx->Current.RasterColor[3];
1635 break;
1636 case GL_CURRENT_RASTER_DISTANCE:
1637 params[0] = (GLdouble) ctx->Current.RasterDistance;
1638 break;
1639 case GL_CURRENT_RASTER_INDEX:
1640 *params = (GLdouble) ctx->Current.RasterIndex;
1641 break;
1642 case GL_CURRENT_RASTER_POSITION:
1643 params[0] = (GLdouble) ctx->Current.RasterPos[0];
1644 params[1] = (GLdouble) ctx->Current.RasterPos[1];
1645 params[2] = (GLdouble) ctx->Current.RasterPos[2];
1646 params[3] = (GLdouble) ctx->Current.RasterPos[3];
1647 break;
1648 case GL_CURRENT_RASTER_TEXTURE_COORDS:
1649 params[0] = (GLdouble) ctx->Current.RasterTexCoords[texUnit][0];
1650 params[1] = (GLdouble) ctx->Current.RasterTexCoords[texUnit][1];
1651 params[2] = (GLdouble) ctx->Current.RasterTexCoords[texUnit][2];
1652 params[3] = (GLdouble) ctx->Current.RasterTexCoords[texUnit][3];
1653 break;
1654 case GL_CURRENT_RASTER_POSITION_VALID:
1655 *params = (GLdouble) ctx->Current.RasterPosValid;
1656 break;
1657 case GL_CURRENT_TEXTURE_COORDS:
1658 FLUSH_CURRENT(ctx, 0);
1659 params[0] = (GLdouble) ctx->Current.Attrib[VERT_ATTRIB_TEX0 + texUnit][0];
1660 params[1] = (GLdouble) ctx->Current.Attrib[VERT_ATTRIB_TEX0 + texUnit][1];
1661 params[2] = (GLdouble) ctx->Current.Attrib[VERT_ATTRIB_TEX0 + texUnit][2];
1662 params[3] = (GLdouble) ctx->Current.Attrib[VERT_ATTRIB_TEX0 + texUnit][3];
1663 break;
1664 case GL_DEPTH_BIAS:
1665 *params = (GLdouble) ctx->Pixel.DepthBias;
1666 break;
1667 case GL_DEPTH_BITS:
1668 *params = (GLdouble) ctx->Visual.depthBits;
1669 break;
1670 case GL_DEPTH_CLEAR_VALUE:
1671 *params = (GLdouble) ctx->Depth.Clear;
1672 break;
1673 case GL_DEPTH_FUNC:
1674 *params = ENUM_TO_DOUBLE(ctx->Depth.Func);
1675 break;
1676 case GL_DEPTH_RANGE:
1677 params[0] = (GLdouble) ctx->Viewport.Near;
1678 params[1] = (GLdouble) ctx->Viewport.Far;
1679 break;
1680 case GL_DEPTH_SCALE:
1681 *params = (GLdouble) ctx->Pixel.DepthScale;
1682 break;
1683 case GL_DEPTH_TEST:
1684 *params = (GLdouble) ctx->Depth.Test;
1685 break;
1686 case GL_DEPTH_WRITEMASK:
1687 *params = (GLdouble) ctx->Depth.Mask;
1688 break;
1689 case GL_DITHER:
1690 *params = (GLdouble) ctx->Color.DitherFlag;
1691 break;
1692 case GL_DOUBLEBUFFER:
1693 *params = (GLdouble) ctx->Visual.doubleBufferMode;
1694 break;
1695 case GL_DRAW_BUFFER:
1696 *params = ENUM_TO_DOUBLE(ctx->Color.DrawBuffer);
1697 break;
1698 case GL_EDGE_FLAG:
1699 FLUSH_CURRENT(ctx, 0);
1700 *params = (GLdouble) ctx->Current.EdgeFlag;
1701 break;
1702 case GL_FEEDBACK_BUFFER_SIZE:
1703 *params = (GLdouble) ctx->Feedback.BufferSize;
1704 break;
1705 case GL_FEEDBACK_BUFFER_TYPE:
1706 *params = ENUM_TO_DOUBLE(ctx->Feedback.Type);
1707 break;
1708 case GL_FOG:
1709 *params = (GLdouble) ctx->Fog.Enabled;
1710 break;
1711 case GL_FOG_COLOR:
1712 params[0] = (GLdouble) ctx->Fog.Color[0];
1713 params[1] = (GLdouble) ctx->Fog.Color[1];
1714 params[2] = (GLdouble) ctx->Fog.Color[2];
1715 params[3] = (GLdouble) ctx->Fog.Color[3];
1716 break;
1717 case GL_FOG_DENSITY:
1718 *params = (GLdouble) ctx->Fog.Density;
1719 break;
1720 case GL_FOG_END:
1721 *params = (GLdouble) ctx->Fog.End;
1722 break;
1723 case GL_FOG_HINT:
1724 *params = ENUM_TO_DOUBLE(ctx->Hint.Fog);
1725 break;
1726 case GL_FOG_INDEX:
1727 *params = (GLdouble) ctx->Fog.Index;
1728 break;
1729 case GL_FOG_MODE:
1730 *params = ENUM_TO_DOUBLE(ctx->Fog.Mode);
1731 break;
1732 case GL_FOG_START:
1733 *params = (GLdouble) ctx->Fog.Start;
1734 break;
1735 case GL_FRONT_FACE:
1736 *params = ENUM_TO_DOUBLE(ctx->Polygon.FrontFace);
1737 break;
1738 case GL_GREEN_BIAS:
1739 *params = (GLdouble) ctx->Pixel.GreenBias;
1740 break;
1741 case GL_GREEN_BITS:
1742 *params = (GLdouble) ctx->Visual.greenBits;
1743 break;
1744 case GL_GREEN_SCALE:
1745 *params = (GLdouble) ctx->Pixel.GreenScale;
1746 break;
1747 case GL_INDEX_BITS:
1748 *params = (GLdouble) ctx->Visual.indexBits;
1749 break;
1750 case GL_INDEX_CLEAR_VALUE:
1751 *params = (GLdouble) ctx->Color.ClearIndex;
1752 break;
1753 case GL_INDEX_MODE:
1754 *params = ctx->Visual.rgbMode ? 0.0 : 1.0;
1755 break;
1756 case GL_INDEX_OFFSET:
1757 *params = (GLdouble) ctx->Pixel.IndexOffset;
1758 break;
1759 case GL_INDEX_SHIFT:
1760 *params = (GLdouble) ctx->Pixel.IndexShift;
1761 break;
1762 case GL_INDEX_WRITEMASK:
1763 *params = (GLdouble) ctx->Color.IndexMask;
1764 break;
1765 case GL_LIGHT0:
1766 case GL_LIGHT1:
1767 case GL_LIGHT2:
1768 case GL_LIGHT3:
1769 case GL_LIGHT4:
1770 case GL_LIGHT5:
1771 case GL_LIGHT6:
1772 case GL_LIGHT7:
1773 *params = (GLdouble) ctx->Light.Light[pname-GL_LIGHT0].Enabled;
1774 break;
1775 case GL_LIGHTING:
1776 *params = (GLdouble) ctx->Light.Enabled;
1777 break;
1778 case GL_LIGHT_MODEL_AMBIENT:
1779 params[0] = (GLdouble) ctx->Light.Model.Ambient[0];
1780 params[1] = (GLdouble) ctx->Light.Model.Ambient[1];
1781 params[2] = (GLdouble) ctx->Light.Model.Ambient[2];
1782 params[3] = (GLdouble) ctx->Light.Model.Ambient[3];
1783 break;
1784 case GL_LIGHT_MODEL_COLOR_CONTROL:
1785 params[0] = (GLdouble) ctx->Light.Model.ColorControl;
1786 break;
1787 case GL_LIGHT_MODEL_LOCAL_VIEWER:
1788 *params = (GLdouble) ctx->Light.Model.LocalViewer;
1789 break;
1790 case GL_LIGHT_MODEL_TWO_SIDE:
1791 *params = (GLdouble) ctx->Light.Model.TwoSide;
1792 break;
1793 case GL_LINE_SMOOTH:
1794 *params = (GLdouble) ctx->Line.SmoothFlag;
1795 break;
1796 case GL_LINE_SMOOTH_HINT:
1797 *params = ENUM_TO_DOUBLE(ctx->Hint.LineSmooth);
1798 break;
1799 case GL_LINE_STIPPLE:
1800 *params = (GLdouble) ctx->Line.StippleFlag;
1801 break;
1802 case GL_LINE_STIPPLE_PATTERN:
1803 *params = (GLdouble) ctx->Line.StipplePattern;
1804 break;
1805 case GL_LINE_STIPPLE_REPEAT:
1806 *params = (GLdouble) ctx->Line.StippleFactor;
1807 break;
1808 case GL_LINE_WIDTH:
1809 *params = (GLdouble) ctx->Line.Width;
1810 break;
1811 case GL_LINE_WIDTH_GRANULARITY:
1812 *params = (GLdouble) ctx->Const.LineWidthGranularity;
1813 break;
1814 case GL_LINE_WIDTH_RANGE:
1815 params[0] = (GLdouble) ctx->Const.MinLineWidthAA;
1816 params[1] = (GLdouble) ctx->Const.MaxLineWidthAA;
1817 break;
1818 case GL_ALIASED_LINE_WIDTH_RANGE:
1819 params[0] = (GLdouble) ctx->Const.MinLineWidth;
1820 params[1] = (GLdouble) ctx->Const.MaxLineWidth;
1821 break;
1822 case GL_LIST_BASE:
1823 *params = (GLdouble) ctx->List.ListBase;
1824 break;
1825 case GL_LIST_INDEX:
1826 *params = (GLdouble) ctx->CurrentListNum;
1827 break;
1828 case GL_LIST_MODE:
1829 *params = ctx->ExecuteFlag ? ENUM_TO_DOUBLE(GL_COMPILE_AND_EXECUTE)
1830 : ENUM_TO_DOUBLE(GL_COMPILE);
1831 break;
1832 case GL_INDEX_LOGIC_OP:
1833 *params = (GLdouble) ctx->Color.IndexLogicOpEnabled;
1834 break;
1835 case GL_COLOR_LOGIC_OP:
1836 *params = (GLdouble) ctx->Color.ColorLogicOpEnabled;
1837 break;
1838 case GL_LOGIC_OP_MODE:
1839 *params = ENUM_TO_DOUBLE(ctx->Color.LogicOp);
1840 break;
1841 case GL_MAP1_COLOR_4:
1842 *params = (GLdouble) ctx->Eval.Map1Color4;
1843 break;
1844 case GL_MAP1_GRID_DOMAIN:
1845 params[0] = (GLdouble) ctx->Eval.MapGrid1u1;
1846 params[1] = (GLdouble) ctx->Eval.MapGrid1u2;
1847 break;
1848 case GL_MAP1_GRID_SEGMENTS:
1849 *params = (GLdouble) ctx->Eval.MapGrid1un;
1850 break;
1851 case GL_MAP1_INDEX:
1852 *params = (GLdouble) ctx->Eval.Map1Index;
1853 break;
1854 case GL_MAP1_NORMAL:
1855 *params = (GLdouble) ctx->Eval.Map1Normal;
1856 break;
1857 case GL_MAP1_TEXTURE_COORD_1:
1858 *params = (GLdouble) ctx->Eval.Map1TextureCoord1;
1859 break;
1860 case GL_MAP1_TEXTURE_COORD_2:
1861 *params = (GLdouble) ctx->Eval.Map1TextureCoord2;
1862 break;
1863 case GL_MAP1_TEXTURE_COORD_3:
1864 *params = (GLdouble) ctx->Eval.Map1TextureCoord3;
1865 break;
1866 case GL_MAP1_TEXTURE_COORD_4:
1867 *params = (GLdouble) ctx->Eval.Map1TextureCoord4;
1868 break;
1869 case GL_MAP1_VERTEX_3:
1870 *params = (GLdouble) ctx->Eval.Map1Vertex3;
1871 break;
1872 case GL_MAP1_VERTEX_4:
1873 *params = (GLdouble) ctx->Eval.Map1Vertex4;
1874 break;
1875 case GL_MAP2_COLOR_4:
1876 *params = (GLdouble) ctx->Eval.Map2Color4;
1877 break;
1878 case GL_MAP2_GRID_DOMAIN:
1879 params[0] = (GLdouble) ctx->Eval.MapGrid2u1;
1880 params[1] = (GLdouble) ctx->Eval.MapGrid2u2;
1881 params[2] = (GLdouble) ctx->Eval.MapGrid2v1;
1882 params[3] = (GLdouble) ctx->Eval.MapGrid2v2;
1883 break;
1884 case GL_MAP2_GRID_SEGMENTS:
1885 params[0] = (GLdouble) ctx->Eval.MapGrid2un;
1886 params[1] = (GLdouble) ctx->Eval.MapGrid2vn;
1887 break;
1888 case GL_MAP2_INDEX:
1889 *params = (GLdouble) ctx->Eval.Map2Index;
1890 break;
1891 case GL_MAP2_NORMAL:
1892 *params = (GLdouble) ctx->Eval.Map2Normal;
1893 break;
1894 case GL_MAP2_TEXTURE_COORD_1:
1895 *params = (GLdouble) ctx->Eval.Map2TextureCoord1;
1896 break;
1897 case GL_MAP2_TEXTURE_COORD_2:
1898 *params = (GLdouble) ctx->Eval.Map2TextureCoord2;
1899 break;
1900 case GL_MAP2_TEXTURE_COORD_3:
1901 *params = (GLdouble) ctx->Eval.Map2TextureCoord3;
1902 break;
1903 case GL_MAP2_TEXTURE_COORD_4:
1904 *params = (GLdouble) ctx->Eval.Map2TextureCoord4;
1905 break;
1906 case GL_MAP2_VERTEX_3:
1907 *params = (GLdouble) ctx->Eval.Map2Vertex3;
1908 break;
1909 case GL_MAP2_VERTEX_4:
1910 *params = (GLdouble) ctx->Eval.Map2Vertex4;
1911 break;
1912 case GL_MAP_COLOR:
1913 *params = (GLdouble) ctx->Pixel.MapColorFlag;
1914 break;
1915 case GL_MAP_STENCIL:
1916 *params = (GLdouble) ctx->Pixel.MapStencilFlag;
1917 break;
1918 case GL_MATRIX_MODE:
1919 *params = ENUM_TO_DOUBLE(ctx->Transform.MatrixMode);
1920 break;
1921 case GL_MAX_ATTRIB_STACK_DEPTH:
1922 *params = (GLdouble) MAX_ATTRIB_STACK_DEPTH;
1923 break;
1924 case GL_MAX_CLIENT_ATTRIB_STACK_DEPTH:
1925 *params = (GLdouble) MAX_CLIENT_ATTRIB_STACK_DEPTH;
1926 break;
1927 case GL_MAX_CLIP_PLANES:
1928 *params = (GLdouble) ctx->Const.MaxClipPlanes;
1929 break;
1930 case GL_MAX_ELEMENTS_VERTICES: /* GL_VERSION_1_2 */
1931 *params = (GLdouble) ctx->Const.MaxArrayLockSize;
1932 break;
1933 case GL_MAX_ELEMENTS_INDICES: /* GL_VERSION_1_2 */
1934 *params = (GLdouble) ctx->Const.MaxArrayLockSize;
1935 break;
1936 case GL_MAX_EVAL_ORDER:
1937 *params = (GLdouble) MAX_EVAL_ORDER;
1938 break;
1939 case GL_MAX_LIGHTS:
1940 *params = (GLdouble) ctx->Const.MaxLights;
1941 break;
1942 case GL_MAX_LIST_NESTING:
1943 *params = (GLdouble) MAX_LIST_NESTING;
1944 break;
1945 case GL_MAX_MODELVIEW_STACK_DEPTH:
1946 *params = (GLdouble) MAX_MODELVIEW_STACK_DEPTH;
1947 break;
1948 case GL_MAX_NAME_STACK_DEPTH:
1949 *params = (GLdouble) MAX_NAME_STACK_DEPTH;
1950 break;
1951 case GL_MAX_PIXEL_MAP_TABLE:
1952 *params = (GLdouble) MAX_PIXEL_MAP_TABLE;
1953 break;
1954 case GL_MAX_PROJECTION_STACK_DEPTH:
1955 *params = (GLdouble) MAX_PROJECTION_STACK_DEPTH;
1956 break;
1957 case GL_MAX_TEXTURE_SIZE:
1958 *params = (GLdouble) (1 << (ctx->Const.MaxTextureLevels - 1));
1959 break;
1960 case GL_MAX_3D_TEXTURE_SIZE:
1961 *params = (GLdouble) (1 << (ctx->Const.Max3DTextureLevels - 1));
1962 break;
1963 case GL_MAX_TEXTURE_STACK_DEPTH:
1964 *params = (GLdouble) MAX_TEXTURE_STACK_DEPTH;
1965 break;
1966 case GL_MAX_VIEWPORT_DIMS:
1967 params[0] = (GLdouble) MAX_WIDTH;
1968 params[1] = (GLdouble) MAX_HEIGHT;
1969 break;
1970 case GL_MODELVIEW_MATRIX:
1971 for (i=0;i<16;i++) {
1972 params[i] = (GLdouble) ctx->ModelviewMatrixStack.Top->m[i];
1973 }
1974 break;
1975 case GL_MODELVIEW_STACK_DEPTH:
1976 *params = (GLdouble) (ctx->ModelviewMatrixStack.Depth + 1);
1977 break;
1978 case GL_NAME_STACK_DEPTH:
1979 *params = (GLdouble) ctx->Select.NameStackDepth;
1980 break;
1981 case GL_NORMALIZE:
1982 *params = (GLdouble) ctx->Transform.Normalize;
1983 break;
1984 case GL_PACK_ALIGNMENT:
1985 *params = (GLdouble) ctx->Pack.Alignment;
1986 break;
1987 case GL_PACK_LSB_FIRST:
1988 *params = (GLdouble) ctx->Pack.LsbFirst;
1989 break;
1990 case GL_PACK_ROW_LENGTH:
1991 *params = (GLdouble) ctx->Pack.RowLength;
1992 break;
1993 case GL_PACK_SKIP_PIXELS:
1994 *params = (GLdouble) ctx->Pack.SkipPixels;
1995 break;
1996 case GL_PACK_SKIP_ROWS:
1997 *params = (GLdouble) ctx->Pack.SkipRows;
1998 break;
1999 case GL_PACK_SWAP_BYTES:
2000 *params = (GLdouble) ctx->Pack.SwapBytes;
2001 break;
2002 case GL_PACK_SKIP_IMAGES_EXT:
2003 *params = (GLdouble) ctx->Pack.SkipImages;
2004 break;
2005 case GL_PACK_IMAGE_HEIGHT_EXT:
2006 *params = (GLdouble) ctx->Pack.ImageHeight;
2007 break;
2008 case GL_PERSPECTIVE_CORRECTION_HINT:
2009 *params = ENUM_TO_DOUBLE(ctx->Hint.PerspectiveCorrection);
2010 break;
2011 case GL_PIXEL_MAP_A_TO_A_SIZE:
2012 *params = (GLdouble) ctx->Pixel.MapAtoAsize;
2013 break;
2014 case GL_PIXEL_MAP_B_TO_B_SIZE:
2015 *params = (GLdouble) ctx->Pixel.MapBtoBsize;
2016 break;
2017 case GL_PIXEL_MAP_G_TO_G_SIZE:
2018 *params = (GLdouble) ctx->Pixel.MapGtoGsize;
2019 break;
2020 case GL_PIXEL_MAP_I_TO_A_SIZE:
2021 *params = (GLdouble) ctx->Pixel.MapItoAsize;
2022 break;
2023 case GL_PIXEL_MAP_I_TO_B_SIZE:
2024 *params = (GLdouble) ctx->Pixel.MapItoBsize;
2025 break;
2026 case GL_PIXEL_MAP_I_TO_G_SIZE:
2027 *params = (GLdouble) ctx->Pixel.MapItoGsize;
2028 break;
2029 case GL_PIXEL_MAP_I_TO_I_SIZE:
2030 *params = (GLdouble) ctx->Pixel.MapItoIsize;
2031 break;
2032 case GL_PIXEL_MAP_I_TO_R_SIZE:
2033 *params = (GLdouble) ctx->Pixel.MapItoRsize;
2034 break;
2035 case GL_PIXEL_MAP_R_TO_R_SIZE:
2036 *params = (GLdouble) ctx->Pixel.MapRtoRsize;
2037 break;
2038 case GL_PIXEL_MAP_S_TO_S_SIZE:
2039 *params = (GLdouble) ctx->Pixel.MapStoSsize;
2040 break;
2041 case GL_POINT_SIZE:
2042 *params = (GLdouble) ctx->Point.Size;
2043 break;
2044 case GL_POINT_SIZE_GRANULARITY:
2045 *params = (GLdouble) ctx->Const.PointSizeGranularity;
2046 break;
2047 case GL_POINT_SIZE_RANGE:
2048 params[0] = (GLdouble) ctx->Const.MinPointSizeAA;
2049 params[1] = (GLdouble) ctx->Const.MaxPointSizeAA;
2050 break;
2051 case GL_ALIASED_POINT_SIZE_RANGE:
2052 params[0] = (GLdouble) ctx->Const.MinPointSize;
2053 params[1] = (GLdouble) ctx->Const.MaxPointSize;
2054 break;
2055 case GL_POINT_SMOOTH:
2056 *params = (GLdouble) ctx->Point.SmoothFlag;
2057 break;
2058 case GL_POINT_SMOOTH_HINT:
2059 *params = ENUM_TO_DOUBLE(ctx->Hint.PointSmooth);
2060 break;
2061 case GL_POINT_SIZE_MIN_EXT:
2062 *params = (GLdouble) (ctx->Point.MinSize);
2063 break;
2064 case GL_POINT_SIZE_MAX_EXT:
2065 *params = (GLdouble) (ctx->Point.MaxSize);
2066 break;
2067 case GL_POINT_FADE_THRESHOLD_SIZE_EXT:
2068 *params = (GLdouble) (ctx->Point.Threshold);
2069 break;
2070 case GL_DISTANCE_ATTENUATION_EXT:
2071 params[0] = (GLdouble) (ctx->Point.Params[0]);
2072 params[1] = (GLdouble) (ctx->Point.Params[1]);
2073 params[2] = (GLdouble) (ctx->Point.Params[2]);
2074 break;
2075 case GL_POLYGON_MODE:
2076 params[0] = ENUM_TO_DOUBLE(ctx->Polygon.FrontMode);
2077 params[1] = ENUM_TO_DOUBLE(ctx->Polygon.BackMode);
2078 break;
2079 case GL_POLYGON_OFFSET_BIAS_EXT: /* GL_EXT_polygon_offset */
2080 *params = (GLdouble) ctx->Polygon.OffsetUnits;
2081 break;
2082 case GL_POLYGON_OFFSET_FACTOR:
2083 *params = (GLdouble) ctx->Polygon.OffsetFactor;
2084 break;
2085 case GL_POLYGON_OFFSET_UNITS:
2086 *params = (GLdouble) ctx->Polygon.OffsetUnits;
2087 break;
2088 case GL_POLYGON_SMOOTH:
2089 *params = (GLdouble) ctx->Polygon.SmoothFlag;
2090 break;
2091 case GL_POLYGON_SMOOTH_HINT:
2092 *params = ENUM_TO_DOUBLE(ctx->Hint.PolygonSmooth);
2093 break;
2094 case GL_POLYGON_STIPPLE:
2095 *params = (GLdouble) ctx->Polygon.StippleFlag;
2096 break;
2097 case GL_PROJECTION_MATRIX:
2098 for (i=0;i<16;i++) {
2099 params[i] = (GLdouble) ctx->ProjectionMatrixStack.Top->m[i];
2100 }
2101 break;
2102 case GL_PROJECTION_STACK_DEPTH:
2103 *params = (GLdouble) (ctx->ProjectionMatrixStack.Depth + 1);
2104 break;
2105 case GL_READ_BUFFER:
2106 *params = ENUM_TO_DOUBLE(ctx->Pixel.ReadBuffer);
2107 break;
2108 case GL_RED_BIAS:
2109 *params = (GLdouble) ctx->Pixel.RedBias;
2110 break;
2111 case GL_RED_BITS:
2112 *params = (GLdouble) ctx->Visual.redBits;
2113 break;
2114 case GL_RED_SCALE:
2115 *params = (GLdouble) ctx->Pixel.RedScale;
2116 break;
2117 case GL_RENDER_MODE:
2118 *params = ENUM_TO_DOUBLE(ctx->RenderMode);
2119 break;
2120 case GL_RESCALE_NORMAL:
2121 *params = (GLdouble) ctx->Transform.RescaleNormals;
2122 break;
2123 case GL_RGBA_MODE:
2124 *params = (GLdouble) ctx->Visual.rgbMode;
2125 break;
2126 case GL_SCISSOR_BOX:
2127 params[0] = (GLdouble) ctx->Scissor.X;
2128 params[1] = (GLdouble) ctx->Scissor.Y;
2129 params[2] = (GLdouble) ctx->Scissor.Width;
2130 params[3] = (GLdouble) ctx->Scissor.Height;
2131 break;
2132 case GL_SCISSOR_TEST:
2133 *params = (GLdouble) ctx->Scissor.Enabled;
2134 break;
2135 case GL_SELECTION_BUFFER_SIZE:
2136 *params = (GLdouble) ctx->Select.BufferSize;
2137 break;
2138 case GL_SHADE_MODEL:
2139 *params = ENUM_TO_DOUBLE(ctx->Light.ShadeModel);
2140 break;
2141 case GL_SHARED_TEXTURE_PALETTE_EXT:
2142 *params = (GLdouble) ctx->Texture.SharedPalette;
2143 break;
2144 case GL_STENCIL_BITS:
2145 *params = (GLdouble) ctx->Visual.stencilBits;
2146 break;
2147 case GL_STENCIL_CLEAR_VALUE:
2148 *params = (GLdouble) ctx->Stencil.Clear;
2149 break;
2150 case GL_STENCIL_FAIL:
2151 *params = ENUM_TO_DOUBLE(ctx->Stencil.FailFunc);
2152 break;
2153 case GL_STENCIL_FUNC:
2154 *params = ENUM_TO_DOUBLE(ctx->Stencil.Function);
2155 break;
2156 case GL_STENCIL_PASS_DEPTH_FAIL:
2157 *params = ENUM_TO_DOUBLE(ctx->Stencil.ZFailFunc);
2158 break;
2159 case GL_STENCIL_PASS_DEPTH_PASS:
2160 *params = ENUM_TO_DOUBLE(ctx->Stencil.ZPassFunc);
2161 break;
2162 case GL_STENCIL_REF:
2163 *params = (GLdouble) ctx->Stencil.Ref;
2164 break;
2165 case GL_STENCIL_TEST:
2166 *params = (GLdouble) ctx->Stencil.Enabled;
2167 break;
2168 case GL_STENCIL_VALUE_MASK:
2169 *params = (GLdouble) ctx->Stencil.ValueMask;
2170 break;
2171 case GL_STENCIL_WRITEMASK:
2172 *params = (GLdouble) ctx->Stencil.WriteMask;
2173 break;
2174 case GL_STEREO:
2175 *params = (GLdouble) ctx->Visual.stereoMode;
2176 break;
2177 case GL_SUBPIXEL_BITS:
2178 *params = (GLdouble) ctx->Const.SubPixelBits;
2179 break;
2180 case GL_TEXTURE_1D:
2181 *params = _mesa_IsEnabled(GL_TEXTURE_1D) ? 1.0 : 0.0;
2182 break;
2183 case GL_TEXTURE_2D:
2184 *params = _mesa_IsEnabled(GL_TEXTURE_2D) ? 1.0 : 0.0;
2185 break;
2186 case GL_TEXTURE_3D:
2187 *params = _mesa_IsEnabled(GL_TEXTURE_3D) ? 1.0 : 0.0;
2188 break;
2189 case GL_TEXTURE_BINDING_1D:
2190 *params = (GLdouble) textureUnit->Current1D->Name;
2191 break;
2192 case GL_TEXTURE_BINDING_2D:
2193 *params = (GLdouble) textureUnit->Current2D->Name;
2194 break;
2195 case GL_TEXTURE_BINDING_3D:
2196 *params = (GLdouble) textureUnit->Current3D->Name;
2197 break;
2198 case GL_TEXTURE_ENV_COLOR:
2199 params[0] = (GLdouble) textureUnit->EnvColor[0];
2200 params[1] = (GLdouble) textureUnit->EnvColor[1];
2201 params[2] = (GLdouble) textureUnit->EnvColor[2];
2202 params[3] = (GLdouble) textureUnit->EnvColor[3];
2203 break;
2204 case GL_TEXTURE_ENV_MODE:
2205 *params = ENUM_TO_DOUBLE(textureUnit->EnvMode);
2206 break;
2207 case GL_TEXTURE_GEN_S:
2208 *params = (textureUnit->TexGenEnabled & S_BIT) ? 1.0 : 0.0;
2209 break;
2210 case GL_TEXTURE_GEN_T:
2211 *params = (textureUnit->TexGenEnabled & T_BIT) ? 1.0 : 0.0;
2212 break;
2213 case GL_TEXTURE_GEN_R:
2214 *params = (textureUnit->TexGenEnabled & R_BIT) ? 1.0 : 0.0;
2215 break;
2216 case GL_TEXTURE_GEN_Q:
2217 *params = (textureUnit->TexGenEnabled & Q_BIT) ? 1.0 : 0.0;
2218 break;
2219 case GL_TEXTURE_MATRIX:
2220 for (i=0;i<16;i++) {
2221 params[i] = (GLdouble) ctx->TextureMatrixStack[texUnit].Top->m[i];
2222 }
2223 break;
2224 case GL_TEXTURE_STACK_DEPTH:
2225 *params = (GLdouble) (ctx->TextureMatrixStack[texUnit].Depth + 1);
2226 break;
2227 case GL_UNPACK_ALIGNMENT:
2228 *params = (GLdouble) ctx->Unpack.Alignment;
2229 break;
2230 case GL_UNPACK_LSB_FIRST:
2231 *params = (GLdouble) ctx->Unpack.LsbFirst;
2232 break;
2233 case GL_UNPACK_ROW_LENGTH:
2234 *params = (GLdouble) ctx->Unpack.RowLength;
2235 break;
2236 case GL_UNPACK_SKIP_PIXELS:
2237 *params = (GLdouble) ctx->Unpack.SkipPixels;
2238 break;
2239 case GL_UNPACK_SKIP_ROWS:
2240 *params = (GLdouble) ctx->Unpack.SkipRows;
2241 break;
2242 case GL_UNPACK_SWAP_BYTES:
2243 *params = (GLdouble) ctx->Unpack.SwapBytes;
2244 break;
2245 case GL_UNPACK_SKIP_IMAGES_EXT:
2246 *params = (GLdouble) ctx->Unpack.SkipImages;
2247 break;
2248 case GL_UNPACK_IMAGE_HEIGHT_EXT:
2249 *params = (GLdouble) ctx->Unpack.ImageHeight;
2250 break;
2251 case GL_VIEWPORT:
2252 params[0] = (GLdouble) ctx->Viewport.X;
2253 params[1] = (GLdouble) ctx->Viewport.Y;
2254 params[2] = (GLdouble) ctx->Viewport.Width;
2255 params[3] = (GLdouble) ctx->Viewport.Height;
2256 break;
2257 case GL_ZOOM_X:
2258 *params = (GLdouble) ctx->Pixel.ZoomX;
2259 break;
2260 case GL_ZOOM_Y:
2261 *params = (GLdouble) ctx->Pixel.ZoomY;
2262 break;
2263 case GL_VERTEX_ARRAY:
2264 *params = (GLdouble) ctx->Array.Vertex.Enabled;
2265 break;
2266 case GL_VERTEX_ARRAY_SIZE:
2267 *params = (GLdouble) ctx->Array.Vertex.Size;
2268 break;
2269 case GL_VERTEX_ARRAY_TYPE:
2270 *params = ENUM_TO_DOUBLE(ctx->Array.Vertex.Type);
2271 break;
2272 case GL_VERTEX_ARRAY_STRIDE:
2273 *params = (GLdouble) ctx->Array.Vertex.Stride;
2274 break;
2275 case GL_VERTEX_ARRAY_COUNT_EXT:
2276 *params = 0.0;
2277 break;
2278 case GL_NORMAL_ARRAY:
2279 *params = (GLdouble) ctx->Array.Normal.Enabled;
2280 break;
2281 case GL_NORMAL_ARRAY_TYPE:
2282 *params = ENUM_TO_DOUBLE(ctx->Array.Normal.Type);
2283 break;
2284 case GL_NORMAL_ARRAY_STRIDE:
2285 *params = (GLdouble) ctx->Array.Normal.Stride;
2286 break;
2287 case GL_NORMAL_ARRAY_COUNT_EXT:
2288 *params = 0.0;
2289 break;
2290 case GL_COLOR_ARRAY:
2291 *params = (GLdouble) ctx->Array.Color.Enabled;
2292 break;
2293 case GL_COLOR_ARRAY_SIZE:
2294 *params = (GLdouble) ctx->Array.Color.Size;
2295 break;
2296 case GL_COLOR_ARRAY_TYPE:
2297 *params = ENUM_TO_DOUBLE(ctx->Array.Color.Type);
2298 break;
2299 case GL_COLOR_ARRAY_STRIDE:
2300 *params = (GLdouble) ctx->Array.Color.Stride;
2301 break;
2302 case GL_COLOR_ARRAY_COUNT_EXT:
2303 *params = 0.0;
2304 break;
2305 case GL_INDEX_ARRAY:
2306 *params = (GLdouble) ctx->Array.Index.Enabled;
2307 break;
2308 case GL_INDEX_ARRAY_TYPE:
2309 *params = ENUM_TO_DOUBLE(ctx->Array.Index.Type);
2310 break;
2311 case GL_INDEX_ARRAY_STRIDE:
2312 *params = (GLdouble) ctx->Array.Index.Stride;
2313 break;
2314 case GL_INDEX_ARRAY_COUNT_EXT:
2315 *params = 0.0;
2316 break;
2317 case GL_TEXTURE_COORD_ARRAY:
2318 *params = (GLdouble) ctx->Array.TexCoord[texUnit].Enabled;
2319 break;
2320 case GL_TEXTURE_COORD_ARRAY_SIZE:
2321 *params = (GLdouble) ctx->Array.TexCoord[texUnit].Size;
2322 break;
2323 case GL_TEXTURE_COORD_ARRAY_TYPE:
2324 *params = ENUM_TO_DOUBLE(ctx->Array.TexCoord[texUnit].Type);
2325 break;
2326 case GL_TEXTURE_COORD_ARRAY_STRIDE:
2327 *params = (GLdouble) ctx->Array.TexCoord[texUnit].Stride;
2328 break;
2329 case GL_TEXTURE_COORD_ARRAY_COUNT_EXT:
2330 *params = 0.0;
2331 break;
2332 case GL_EDGE_FLAG_ARRAY:
2333 *params = (GLdouble) ctx->Array.EdgeFlag.Enabled;
2334 break;
2335 case GL_EDGE_FLAG_ARRAY_STRIDE:
2336 *params = (GLdouble) ctx->Array.EdgeFlag.Stride;
2337 break;
2338 case GL_EDGE_FLAG_ARRAY_COUNT_EXT:
2339 *params = 0.0;
2340 break;
2341
2342 /* GL_ARB_multitexture */
2343 case GL_MAX_TEXTURE_UNITS_ARB:
2344 *params = (GLdouble) ctx->Const.MaxTextureUnits;
2345 break;
2346 case GL_ACTIVE_TEXTURE_ARB:
2347 *params = (GLdouble) (GL_TEXTURE0_ARB + ctx->Texture.CurrentUnit);
2348 break;
2349 case GL_CLIENT_ACTIVE_TEXTURE_ARB:
2350 *params = (GLdouble) (GL_TEXTURE0_ARB + ctx->Array.ActiveTexture);
2351 break;
2352
2353 /* GL_ARB_texture_cube_map */
2354 case GL_TEXTURE_CUBE_MAP_ARB:
2355 CHECK_EXTENSION_D(ARB_texture_cube_map);
2356 *params = (GLdouble) _mesa_IsEnabled(GL_TEXTURE_CUBE_MAP_ARB);
2357 break;
2358 case GL_TEXTURE_BINDING_CUBE_MAP_ARB:
2359 CHECK_EXTENSION_D(ARB_texture_cube_map);
2360 *params = (GLdouble) textureUnit->CurrentCubeMap->Name;
2361 break;
2362 case GL_MAX_CUBE_MAP_TEXTURE_SIZE_ARB:
2363 CHECK_EXTENSION_D(ARB_texture_cube_map);
2364 *params = (GLdouble) (1 << (ctx->Const.MaxCubeTextureLevels - 1));
2365 break;
2366
2367 /* GL_ARB_texture_compression */
2368 case GL_TEXTURE_COMPRESSION_HINT_ARB:
2369 CHECK_EXTENSION_D(ARB_texture_compression);
2370 *params = (GLdouble) ctx->Hint.TextureCompression;
2371 break;
2372 case GL_NUM_COMPRESSED_TEXTURE_FORMATS_ARB:
2373 CHECK_EXTENSION_D(ARB_texture_compression);
2374 *params = (GLdouble) ctx->Const.NumCompressedTextureFormats;
2375 break;
2376 case GL_COMPRESSED_TEXTURE_FORMATS_ARB:
2377 CHECK_EXTENSION_D(ARB_texture_compression);
2378 {
2379 GLuint i;
2380 for (i = 0; i < ctx->Const.NumCompressedTextureFormats; i++)
2381 params[i] = (GLdouble) ctx->Const.CompressedTextureFormats[i];
2382 }
2383 break;
2384
2385 /* GL_EXT_compiled_vertex_array */
2386 case GL_ARRAY_ELEMENT_LOCK_FIRST_EXT:
2387 *params = (GLdouble) ctx->Array.LockFirst;
2388 break;
2389 case GL_ARRAY_ELEMENT_LOCK_COUNT_EXT:
2390 *params = (GLdouble) ctx->Array.LockCount;
2391 break;
2392
2393 /* GL_ARB_transpose_matrix */
2394 case GL_TRANSPOSE_COLOR_MATRIX_ARB:
2395 {
2396 GLfloat tm[16];
2397 GLuint i;
2398 _math_transposef(tm, ctx->ColorMatrixStack.Top->m);
2399 for (i=0;i<16;i++) {
2400 params[i] = (GLdouble) tm[i];
2401 }
2402 }
2403 break;
2404 case GL_TRANSPOSE_MODELVIEW_MATRIX_ARB:
2405 {
2406 GLfloat tm[16];
2407 GLuint i;
2408 _math_transposef(tm, ctx->ModelviewMatrixStack.Top->m);
2409 for (i=0;i<16;i++) {
2410 params[i] = (GLdouble) tm[i];
2411 }
2412 }
2413 break;
2414 case GL_TRANSPOSE_PROJECTION_MATRIX_ARB:
2415 {
2416 GLfloat tm[16];
2417 GLuint i;
2418 _math_transposef(tm, ctx->ProjectionMatrixStack.Top->m);
2419 for (i=0;i<16;i++) {
2420 params[i] = (GLdouble) tm[i];
2421 }
2422 }
2423 break;
2424 case GL_TRANSPOSE_TEXTURE_MATRIX_ARB:
2425 {
2426 GLfloat tm[16];
2427 GLuint i;
2428 _math_transposef(tm, ctx->TextureMatrixStack[texUnit].Top->m);
2429 for (i=0;i<16;i++) {
2430 params[i] = (GLdouble) tm[i];
2431 }
2432 }
2433 break;
2434
2435 /* GL_HP_occlusion_test */
2436 case GL_OCCLUSION_TEST_HP:
2437 CHECK_EXTENSION_D(HP_occlusion_test);
2438 *params = (GLdouble) ctx->Depth.OcclusionTest;
2439 break;
2440 case GL_OCCLUSION_TEST_RESULT_HP:
2441 CHECK_EXTENSION_D(HP_occlusion_test);
2442 if (ctx->Depth.OcclusionTest)
2443 *params = (GLdouble) ctx->OcclusionResult;
2444 else
2445 *params = (GLdouble) ctx->OcclusionResultSaved;
2446 /* reset flag now */
2447 ctx->OcclusionResult = GL_FALSE;
2448 ctx->OcclusionResultSaved = GL_FALSE;
2449 break;
2450
2451 /* GL_SGIS_pixel_texture */
2452 case GL_PIXEL_TEXTURE_SGIS:
2453 *params = (GLdouble) ctx->Pixel.PixelTextureEnabled;
2454 break;
2455
2456 /* GL_SGIX_pixel_texture */
2457 case GL_PIXEL_TEX_GEN_SGIX:
2458 *params = (GLdouble) ctx->Pixel.PixelTextureEnabled;
2459 break;
2460 case GL_PIXEL_TEX_GEN_MODE_SGIX:
2461 *params = (GLdouble) pixel_texgen_mode(ctx);
2462 break;
2463
2464 /* GL_SGI_color_matrix (also in 1.2 imaging) */
2465 case GL_COLOR_MATRIX_SGI:
2466 for (i=0;i<16;i++) {
2467 params[i] = (GLdouble) ctx->ColorMatrixStack.Top->m[i];
2468 }
2469 break;
2470 case GL_COLOR_MATRIX_STACK_DEPTH_SGI:
2471 *params = (GLdouble) (ctx->ColorMatrixStack.Depth + 1);
2472 break;
2473 case GL_MAX_COLOR_MATRIX_STACK_DEPTH_SGI:
2474 *params = (GLdouble) MAX_COLOR_STACK_DEPTH;
2475 break;
2476 case GL_POST_COLOR_MATRIX_RED_SCALE_SGI:
2477 *params = (GLdouble) ctx->Pixel.PostColorMatrixScale[0];
2478 break;
2479 case GL_POST_COLOR_MATRIX_GREEN_SCALE_SGI:
2480 *params = (GLdouble) ctx->Pixel.PostColorMatrixScale[1];
2481 break;
2482 case GL_POST_COLOR_MATRIX_BLUE_SCALE_SGI:
2483 *params = (GLdouble) ctx->Pixel.PostColorMatrixScale[2];
2484 break;
2485 case GL_POST_COLOR_MATRIX_ALPHA_SCALE_SGI:
2486 *params = (GLdouble) ctx->Pixel.PostColorMatrixScale[3];
2487 break;
2488 case GL_POST_COLOR_MATRIX_RED_BIAS_SGI:
2489 *params = (GLdouble) ctx->Pixel.PostColorMatrixBias[0];
2490 break;
2491 case GL_POST_COLOR_MATRIX_GREEN_BIAS_SGI:
2492 *params = (GLdouble) ctx->Pixel.PostColorMatrixBias[1];
2493 break;
2494 case GL_POST_COLOR_MATRIX_BLUE_BIAS_SGI:
2495 *params = (GLdouble) ctx->Pixel.PostColorMatrixBias[2];
2496 break;
2497 case GL_POST_COLOR_MATRIX_ALPHA_BIAS_SGI:
2498 *params = (GLdouble) ctx->Pixel.PostColorMatrixBias[3];
2499 break;
2500
2501 /* GL_EXT_convolution (also in 1.2 imaging) */
2502 case GL_CONVOLUTION_1D_EXT:
2503 CHECK_EXTENSION_D(EXT_convolution);
2504 *params = (GLdouble) ctx->Pixel.Convolution1DEnabled;
2505 break;
2506 case GL_CONVOLUTION_2D:
2507 CHECK_EXTENSION_D(EXT_convolution);
2508 *params = (GLdouble) ctx->Pixel.Convolution2DEnabled;
2509 break;
2510 case GL_SEPARABLE_2D:
2511 CHECK_EXTENSION_D(EXT_convolution);
2512 *params = (GLdouble) ctx->Pixel.Separable2DEnabled;
2513 break;
2514 case GL_MAX_CONVOLUTION_WIDTH:
2515 CHECK_EXTENSION_D(EXT_convolution);
2516 *params = (GLdouble) ctx->Const.MaxConvolutionWidth;
2517 break;
2518 case GL_MAX_CONVOLUTION_HEIGHT:
2519 CHECK_EXTENSION_D(EXT_convolution);
2520 *params = (GLdouble) ctx->Const.MaxConvolutionHeight;
2521 break;
2522 case GL_POST_CONVOLUTION_RED_SCALE_EXT:
2523 CHECK_EXTENSION_D(EXT_convolution);
2524 *params = (GLdouble) ctx->Pixel.PostConvolutionScale[0];
2525 break;
2526 case GL_POST_CONVOLUTION_GREEN_SCALE_EXT:
2527 CHECK_EXTENSION_D(EXT_convolution);
2528 *params = (GLdouble) ctx->Pixel.PostConvolutionScale[1];
2529 break;
2530 case GL_POST_CONVOLUTION_BLUE_SCALE_EXT:
2531 CHECK_EXTENSION_D(EXT_convolution);
2532 *params = (GLdouble) ctx->Pixel.PostConvolutionScale[2];
2533 break;
2534 case GL_POST_CONVOLUTION_ALPHA_SCALE_EXT:
2535 CHECK_EXTENSION_D(EXT_convolution);
2536 *params = (GLdouble) ctx->Pixel.PostConvolutionScale[3];
2537 break;
2538 case GL_POST_CONVOLUTION_RED_BIAS_EXT:
2539 CHECK_EXTENSION_D(EXT_convolution);
2540 *params = (GLdouble) ctx->Pixel.PostConvolutionBias[0];
2541 break;
2542 case GL_POST_CONVOLUTION_GREEN_BIAS_EXT:
2543 CHECK_EXTENSION_D(EXT_convolution);
2544 *params = (GLdouble) ctx->Pixel.PostConvolutionBias[1];
2545 break;
2546 case GL_POST_CONVOLUTION_BLUE_BIAS_EXT:
2547 CHECK_EXTENSION_D(EXT_convolution);
2548 *params = (GLdouble) ctx->Pixel.PostConvolutionBias[2];
2549 break;
2550 case GL_POST_CONVOLUTION_ALPHA_BIAS_EXT:
2551 CHECK_EXTENSION_D(EXT_convolution);
2552 *params = (GLdouble) ctx->Pixel.PostConvolutionBias[2];
2553 break;
2554
2555 /* GL_EXT_histogram (also in 1.2 imaging) */
2556 case GL_HISTOGRAM:
2557 CHECK_EXTENSION_D(EXT_histogram);
2558 *params = (GLdouble) ctx->Pixel.HistogramEnabled;
2559 break;
2560 case GL_MINMAX:
2561 CHECK_EXTENSION_D(EXT_histogram);
2562 *params = (GLdouble) ctx->Pixel.MinMaxEnabled;
2563 break;
2564
2565 /* GL_SGI_color_table (also in 1.2 imaging */
2566 case GL_COLOR_TABLE_SGI:
2567 *params = (GLdouble) ctx->Pixel.ColorTableEnabled;
2568 break;
2569 case GL_POST_CONVOLUTION_COLOR_TABLE_SGI:
2570 *params = (GLdouble) ctx->Pixel.PostConvolutionColorTableEnabled;
2571 break;
2572 case GL_POST_COLOR_MATRIX_COLOR_TABLE_SGI:
2573 *params = (GLdouble) ctx->Pixel.PostColorMatrixColorTableEnabled;
2574 break;
2575
2576 /* GL_EXT_secondary_color */
2577 case GL_COLOR_SUM_EXT:
2578 CHECK_EXTENSION_D(EXT_secondary_color);
2579 *params = (GLdouble) ctx->Fog.ColorSumEnabled;
2580 break;
2581 case GL_CURRENT_SECONDARY_COLOR_EXT:
2582 CHECK_EXTENSION_D(EXT_secondary_color);
2583 FLUSH_CURRENT(ctx, 0);
2584 params[0] = ctx->Current.Attrib[VERT_ATTRIB_COLOR1][0];
2585 params[1] = ctx->Current.Attrib[VERT_ATTRIB_COLOR1][1];
2586 params[2] = ctx->Current.Attrib[VERT_ATTRIB_COLOR1][2];
2587 break;
2588 case GL_SECONDARY_COLOR_ARRAY_EXT:
2589 CHECK_EXTENSION_D(EXT_secondary_color);
2590 *params = (GLdouble) ctx->Array.SecondaryColor.Enabled;
2591 break;
2592 case GL_SECONDARY_COLOR_ARRAY_TYPE_EXT:
2593 CHECK_EXTENSION_D(EXT_secondary_color);
2594 *params = (GLdouble) ctx->Array.SecondaryColor.Type;
2595 break;
2596 case GL_SECONDARY_COLOR_ARRAY_STRIDE_EXT:
2597 CHECK_EXTENSION_D(EXT_secondary_color);
2598 *params = (GLdouble) ctx->Array.SecondaryColor.Stride;
2599 break;
2600 case GL_SECONDARY_COLOR_ARRAY_SIZE_EXT:
2601 CHECK_EXTENSION_D(EXT_secondary_color);
2602 *params = (GLdouble) ctx->Array.SecondaryColor.Stride;
2603 break;
2604
2605 /* GL_EXT_fog_coord */
2606 case GL_CURRENT_FOG_COORDINATE_EXT:
2607 CHECK_EXTENSION_D(EXT_fog_coord);
2608 FLUSH_CURRENT(ctx, 0);
2609 *params = (GLdouble) ctx->Current.Attrib[VERT_ATTRIB_FOG][0];
2610 break;
2611 case GL_FOG_COORDINATE_ARRAY_EXT:
2612 CHECK_EXTENSION_D(EXT_fog_coord);
2613 *params = (GLdouble) ctx->Array.FogCoord.Enabled;
2614 break;
2615 case GL_FOG_COORDINATE_ARRAY_TYPE_EXT:
2616 CHECK_EXTENSION_D(EXT_fog_coord);
2617 *params = (GLdouble) ctx->Array.FogCoord.Type;
2618 break;
2619 case GL_FOG_COORDINATE_ARRAY_STRIDE_EXT:
2620 CHECK_EXTENSION_D(EXT_fog_coord);
2621 *params = (GLdouble) ctx->Array.FogCoord.Stride;
2622 break;
2623
2624 /* GL_EXT_texture_lod_bias */
2625 case GL_MAX_TEXTURE_LOD_BIAS_EXT:
2626 *params = (GLdouble) ctx->Const.MaxTextureLodBias;
2627 break;
2628
2629 /* GL_EXT_texture_filter_anisotropic */
2630 case GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT:
2631 CHECK_EXTENSION_D(EXT_texture_filter_anisotropic);
2632 *params = (GLdouble) ctx->Const.MaxTextureMaxAnisotropy;
2633 break;
2634
2635 /* GL_ARB_multisample */
2636 case GL_MULTISAMPLE_ARB:
2637 CHECK_EXTENSION_D(ARB_multisample);
2638 *params = (GLdouble) ctx->Multisample.Enabled;
2639 break;
2640 case GL_SAMPLE_ALPHA_TO_COVERAGE_ARB:
2641 CHECK_EXTENSION_D(ARB_multisample);
2642 *params = (GLdouble) ctx->Multisample.SampleAlphaToCoverage;
2643 break;
2644 case GL_SAMPLE_ALPHA_TO_ONE_ARB:
2645 CHECK_EXTENSION_D(ARB_multisample);
2646 *params = (GLdouble) ctx->Multisample.SampleAlphaToOne;
2647 break;
2648 case GL_SAMPLE_COVERAGE_ARB:
2649 CHECK_EXTENSION_D(ARB_multisample);
2650 *params = (GLdouble) ctx->Multisample.SampleCoverage;
2651 break;
2652 case GL_SAMPLE_COVERAGE_VALUE_ARB:
2653 CHECK_EXTENSION_D(ARB_multisample);
2654 *params = ctx->Multisample.SampleCoverageValue;
2655 break;
2656 case GL_SAMPLE_COVERAGE_INVERT_ARB:
2657 CHECK_EXTENSION_D(ARB_multisample);
2658 *params = (GLdouble) ctx->Multisample.SampleCoverageInvert;
2659 break;
2660 case GL_SAMPLE_BUFFERS_ARB:
2661 CHECK_EXTENSION_D(ARB_multisample);
2662 *params = 0.0; /* XXX fix someday */
2663 break;
2664 case GL_SAMPLES_ARB:
2665 CHECK_EXTENSION_D(ARB_multisample);
2666 *params = 0.0; /* XXX fix someday */
2667 break;
2668
2669 /* GL_IBM_rasterpos_clip */
2670 case GL_RASTER_POSITION_UNCLIPPED_IBM:
2671 CHECK_EXTENSION_D(IBM_rasterpos_clip);
2672 *params = (GLdouble) ctx->Transform.RasterPositionUnclipped;
2673 break;
2674
2675 /* GL_NV_point_sprite */
2676 case GL_POINT_SPRITE_NV:
2677 CHECK_EXTENSION_B(NV_point_sprite);
2678 *params = (GLdouble) ctx->Point.PointSprite;
2679 break;
2680 case GL_POINT_SPRITE_R_MODE_NV:
2681 CHECK_EXTENSION_B(NV_point_sprite);
2682 *params = (GLdouble) ctx->Point.SpriteRMode;
2683 break;
2684
2685 /* GL_SGIS_generate_mipmap */
2686 case GL_GENERATE_MIPMAP_HINT_SGIS:
2687 CHECK_EXTENSION_D(SGIS_generate_mipmap);
2688 *params = (GLdouble) ctx->Hint.GenerateMipmap;
2689 break;
2690
2691 /* GL_NV_vertex_program */
2692 /* XXX to do */
2693
2694 /* GL_NV_texture_rectangle */
2695 case GL_TEXTURE_RECTANGLE_NV:
2696 CHECK_EXTENSION_D(NV_texture_rectangle);
2697 *params = (GLdouble) _mesa_IsEnabled(GL_TEXTURE_RECTANGLE_NV);
2698 break;
2699 case GL_TEXTURE_BINDING_RECTANGLE_NV:
2700 CHECK_EXTENSION_D(NV_texture_rectangle);
2701 *params = (GLdouble) textureUnit->CurrentRect->Name;
2702 break;
2703 case GL_MAX_RECTANGLE_TEXTURE_SIZE_NV:
2704 CHECK_EXTENSION_D(NV_texture_rectangle);
2705 *params = (GLdouble) ctx->Const.MaxTextureRectSize;
2706 break;
2707
2708 default:
2709 _mesa_error( ctx, GL_INVALID_ENUM, "glGetDoublev" );
2710 }
2711 }
2712
2713
2714 #define GET_FLOAT_ERROR \
2715 { \
2716 char s[100]; \
2717 sprintf(s, "glGetFloatv(0x%x)", pname); \
2718 _mesa_error(ctx, GL_INVALID_ENUM, s); \
2719 }
2720
2721 void
2722 _mesa_GetFloatv( GLenum pname, GLfloat *params )
2723 {
2724 GET_CURRENT_CONTEXT(ctx);
2725 GLuint i;
2726 GLuint texUnit = ctx->Texture.CurrentUnit;
2727 const struct gl_texture_unit *textureUnit = &ctx->Texture.Unit[texUnit];
2728 ASSERT_OUTSIDE_BEGIN_END(ctx);
2729
2730 if (!params)
2731 return;
2732
2733 /* We need this in order to get correct results for
2734 * GL_OCCLUSION_TEST_RESULT_HP. There might be other important cases.
2735 */
2736 FLUSH_VERTICES(ctx, 0);
2737
2738 if (MESA_VERBOSE & VERBOSE_API)
2739 _mesa_debug(ctx, "glGetFloatv %s\n", _mesa_lookup_enum_by_nr(pname));
2740
2741 if (ctx->Driver.GetFloatv && (*ctx->Driver.GetFloatv)(ctx, pname, params))
2742 return;
2743
2744 switch (pname) {
2745 case GL_ACCUM_RED_BITS:
2746 *params = (GLfloat) ctx->Visual.accumRedBits;
2747 break;
2748 case GL_ACCUM_GREEN_BITS:
2749 *params = (GLfloat) ctx->Visual.accumGreenBits;
2750 break;
2751 case GL_ACCUM_BLUE_BITS:
2752 *params = (GLfloat) ctx->Visual.accumBlueBits;
2753 break;
2754 case GL_ACCUM_ALPHA_BITS:
2755 *params = (GLfloat) ctx->Visual.accumAlphaBits;
2756 break;
2757 case GL_ACCUM_CLEAR_VALUE:
2758 params[0] = ctx->Accum.ClearColor[0];
2759 params[1] = ctx->Accum.ClearColor[1];
2760 params[2] = ctx->Accum.ClearColor[2];
2761 params[3] = ctx->Accum.ClearColor[3];
2762 break;
2763 case GL_ALPHA_BIAS:
2764 *params = ctx->Pixel.AlphaBias;
2765 break;
2766 case GL_ALPHA_BITS:
2767 *params = (GLfloat) ctx->Visual.alphaBits;
2768 break;
2769 case GL_ALPHA_SCALE:
2770 *params = ctx->Pixel.AlphaScale;
2771 break;
2772 case GL_ALPHA_TEST:
2773 *params = (GLfloat) ctx->Color.AlphaEnabled;
2774 break;
2775 case GL_ALPHA_TEST_FUNC:
2776 *params = ENUM_TO_FLOAT(ctx->Color.AlphaFunc);
2777 break;
2778 case GL_ALPHA_TEST_REF:
2779 *params = (GLfloat) ctx->Color.AlphaRef / CHAN_MAXF;
2780 break;
2781 case GL_ATTRIB_STACK_DEPTH:
2782 *params = (GLfloat) (ctx->AttribStackDepth);
2783 break;
2784 case GL_AUTO_NORMAL:
2785 *params = (GLfloat) ctx->Eval.AutoNormal;
2786 break;
2787 case GL_AUX_BUFFERS:
2788 *params = (GLfloat) ctx->Const.NumAuxBuffers;
2789 break;
2790 case GL_BLEND:
2791 *params = (GLfloat) ctx->Color.BlendEnabled;
2792 break;
2793 case GL_BLEND_DST:
2794 *params = ENUM_TO_FLOAT(ctx->Color.BlendDstRGB);
2795 break;
2796 case GL_BLEND_SRC:
2797 *params = ENUM_TO_FLOAT(ctx->Color.BlendSrcRGB);
2798 break;
2799 case GL_BLEND_SRC_RGB_EXT:
2800 *params = ENUM_TO_FLOAT(ctx->Color.BlendSrcRGB);
2801 break;
2802 case GL_BLEND_DST_RGB_EXT:
2803 *params = ENUM_TO_FLOAT(ctx->Color.BlendDstRGB);
2804 break;
2805 case GL_BLEND_SRC_ALPHA_EXT:
2806 *params = ENUM_TO_FLOAT(ctx->Color.BlendSrcA);
2807 break;
2808 case GL_BLEND_DST_ALPHA_EXT:
2809 *params = ENUM_TO_FLOAT(ctx->Color.BlendDstA);
2810 break;
2811 case GL_BLEND_EQUATION_EXT:
2812 *params = ENUM_TO_FLOAT(ctx->Color.BlendEquation);
2813 break;
2814 case GL_BLEND_COLOR_EXT:
2815 params[0] = ctx->Color.BlendColor[0];
2816 params[1] = ctx->Color.BlendColor[1];
2817 params[2] = ctx->Color.BlendColor[2];
2818 params[3] = ctx->Color.BlendColor[3];
2819 break;
2820 case GL_BLUE_BIAS:
2821 *params = ctx->Pixel.BlueBias;
2822 break;
2823 case GL_BLUE_BITS:
2824 *params = (GLfloat) ctx->Visual.blueBits;
2825 break;
2826 case GL_BLUE_SCALE:
2827 *params = ctx->Pixel.BlueScale;
2828 break;
2829 case GL_CLIENT_ATTRIB_STACK_DEPTH:
2830 *params = (GLfloat) (ctx->ClientAttribStackDepth);
2831 break;
2832 case GL_CLIP_PLANE0:
2833 case GL_CLIP_PLANE1:
2834 case GL_CLIP_PLANE2:
2835 case GL_CLIP_PLANE3:
2836 case GL_CLIP_PLANE4:
2837 case GL_CLIP_PLANE5:
2838 if (ctx->Transform.ClipPlanesEnabled & (1 << (pname - GL_CLIP_PLANE0)))
2839 *params = 1.0;
2840 else
2841 *params = 0.0;
2842 break;
2843 case GL_COLOR_CLEAR_VALUE:
2844 params[0] = CHAN_TO_FLOAT(ctx->Color.ClearColor[0]);
2845 params[1] = CHAN_TO_FLOAT(ctx->Color.ClearColor[1]);
2846 params[2] = CHAN_TO_FLOAT(ctx->Color.ClearColor[2]);
2847 params[3] = CHAN_TO_FLOAT(ctx->Color.ClearColor[3]);
2848 break;
2849 case GL_COLOR_MATERIAL:
2850 *params = (GLfloat) ctx->Light.ColorMaterialEnabled;
2851 break;
2852 case GL_COLOR_MATERIAL_FACE:
2853 *params = ENUM_TO_FLOAT(ctx->Light.ColorMaterialFace);
2854 break;
2855 case GL_COLOR_MATERIAL_PARAMETER:
2856 *params = ENUM_TO_FLOAT(ctx->Light.ColorMaterialMode);
2857 break;
2858 case GL_COLOR_WRITEMASK:
2859 params[0] = ctx->Color.ColorMask[RCOMP] ? 1.0F : 0.0F;
2860 params[1] = ctx->Color.ColorMask[GCOMP] ? 1.0F : 0.0F;
2861 params[2] = ctx->Color.ColorMask[BCOMP] ? 1.0F : 0.0F;
2862 params[3] = ctx->Color.ColorMask[ACOMP] ? 1.0F : 0.0F;
2863 break;
2864 case GL_CULL_FACE:
2865 *params = (GLfloat) ctx->Polygon.CullFlag;
2866 break;
2867 case GL_CULL_FACE_MODE:
2868 *params = ENUM_TO_FLOAT(ctx->Polygon.CullFaceMode);
2869 break;
2870 case GL_CURRENT_COLOR:
2871 FLUSH_CURRENT(ctx, 0);
2872 params[0] = ctx->Current.Attrib[VERT_ATTRIB_COLOR0][0];
2873 params[1] = ctx->Current.Attrib[VERT_ATTRIB_COLOR0][1];
2874 params[2] = ctx->Current.Attrib[VERT_ATTRIB_COLOR0][2];
2875 params[3] = ctx->Current.Attrib[VERT_ATTRIB_COLOR0][3];
2876 break;
2877 case GL_CURRENT_INDEX:
2878 FLUSH_CURRENT(ctx, 0);
2879 *params = (GLfloat) ctx->Current.Index;
2880 break;
2881 case GL_CURRENT_NORMAL:
2882 FLUSH_CURRENT(ctx, 0);
2883 params[0] = ctx->Current.Attrib[VERT_ATTRIB_NORMAL][0];
2884 params[1] = ctx->Current.Attrib[VERT_ATTRIB_NORMAL][1];
2885 params[2] = ctx->Current.Attrib[VERT_ATTRIB_NORMAL][2];
2886 break;
2887 case GL_CURRENT_RASTER_COLOR:
2888 params[0] = ctx->Current.RasterColor[0];
2889 params[1] = ctx->Current.RasterColor[1];
2890 params[2] = ctx->Current.RasterColor[2];
2891 params[3] = ctx->Current.RasterColor[3];
2892 break;
2893 case GL_CURRENT_RASTER_DISTANCE:
2894 params[0] = ctx->Current.RasterDistance;
2895 break;
2896 case GL_CURRENT_RASTER_INDEX:
2897 *params = (GLfloat) ctx->Current.RasterIndex;
2898 break;
2899 case GL_CURRENT_RASTER_POSITION:
2900 params[0] = ctx->Current.RasterPos[0];
2901 params[1] = ctx->Current.RasterPos[1];
2902 params[2] = ctx->Current.RasterPos[2];
2903 params[3] = ctx->Current.RasterPos[3];
2904 break;
2905 case GL_CURRENT_RASTER_TEXTURE_COORDS:
2906 params[0] = ctx->Current.RasterTexCoords[texUnit][0];
2907 params[1] = ctx->Current.RasterTexCoords[texUnit][1];
2908 params[2] = ctx->Current.RasterTexCoords[texUnit][2];
2909 params[3] = ctx->Current.RasterTexCoords[texUnit][3];
2910 break;
2911 case GL_CURRENT_RASTER_POSITION_VALID:
2912 *params = (GLfloat) ctx->Current.RasterPosValid;
2913 break;
2914 case GL_CURRENT_TEXTURE_COORDS:
2915 FLUSH_CURRENT(ctx, 0);
2916 params[0] = (GLfloat) ctx->Current.Attrib[VERT_ATTRIB_TEX0 + texUnit][0];
2917 params[1] = (GLfloat) ctx->Current.Attrib[VERT_ATTRIB_TEX0 + texUnit][1];
2918 params[2] = (GLfloat) ctx->Current.Attrib[VERT_ATTRIB_TEX0 + texUnit][2];
2919 params[3] = (GLfloat) ctx->Current.Attrib[VERT_ATTRIB_TEX0 + texUnit][3];
2920 break;
2921 case GL_DEPTH_BIAS:
2922 *params = (GLfloat) ctx->Pixel.DepthBias;
2923 break;
2924 case GL_DEPTH_BITS:
2925 *params = (GLfloat) ctx->Visual.depthBits;
2926 break;
2927 case GL_DEPTH_CLEAR_VALUE:
2928 *params = (GLfloat) ctx->Depth.Clear;
2929 break;
2930 case GL_DEPTH_FUNC:
2931 *params = ENUM_TO_FLOAT(ctx->Depth.Func);
2932 break;
2933 case GL_DEPTH_RANGE:
2934 params[0] = (GLfloat) ctx->Viewport.Near;
2935 params[1] = (GLfloat) ctx->Viewport.Far;
2936 break;
2937 case GL_DEPTH_SCALE:
2938 *params = (GLfloat) ctx->Pixel.DepthScale;
2939 break;
2940 case GL_DEPTH_TEST:
2941 *params = (GLfloat) ctx->Depth.Test;
2942 break;
2943 case GL_DEPTH_WRITEMASK:
2944 *params = (GLfloat) ctx->Depth.Mask;
2945 break;
2946 case GL_DITHER:
2947 *params = (GLfloat) ctx->Color.DitherFlag;
2948 break;
2949 case GL_DOUBLEBUFFER:
2950 *params = (GLfloat) ctx->Visual.doubleBufferMode;
2951 break;
2952 case GL_DRAW_BUFFER:
2953 *params = ENUM_TO_FLOAT(ctx->Color.DrawBuffer);
2954 break;
2955 case GL_EDGE_FLAG:
2956 FLUSH_CURRENT(ctx, 0);
2957 *params = (GLfloat) ctx->Current.EdgeFlag;
2958 break;
2959 case GL_FEEDBACK_BUFFER_SIZE:
2960 *params = (GLfloat) ctx->Feedback.BufferSize;
2961 break;
2962 case GL_FEEDBACK_BUFFER_TYPE:
2963 *params = ENUM_TO_FLOAT(ctx->Feedback.Type);
2964 break;
2965 case GL_FOG:
2966 *params = (GLfloat) ctx->Fog.Enabled;
2967 break;
2968 case GL_FOG_COLOR:
2969 params[0] = ctx->Fog.Color[0];
2970 params[1] = ctx->Fog.Color[1];
2971 params[2] = ctx->Fog.Color[2];
2972 params[3] = ctx->Fog.Color[3];
2973 break;
2974 case GL_FOG_DENSITY:
2975 *params = ctx->Fog.Density;
2976 break;
2977 case GL_FOG_END:
2978 *params = ctx->Fog.End;
2979 break;
2980 case GL_FOG_HINT:
2981 *params = ENUM_TO_FLOAT(ctx->Hint.Fog);
2982 break;
2983 case GL_FOG_INDEX:
2984 *params = ctx->Fog.Index;
2985 break;
2986 case GL_FOG_MODE:
2987 *params = ENUM_TO_FLOAT(ctx->Fog.Mode);
2988 break;
2989 case GL_FOG_START:
2990 *params = ctx->Fog.Start;
2991 break;
2992 case GL_FRONT_FACE:
2993 *params = ENUM_TO_FLOAT(ctx->Polygon.FrontFace);
2994 break;
2995 case GL_GREEN_BIAS:
2996 *params = (GLfloat) ctx->Pixel.GreenBias;
2997 break;
2998 case GL_GREEN_BITS:
2999 *params = (GLfloat) ctx->Visual.greenBits;
3000 break;
3001 case GL_GREEN_SCALE:
3002 *params = (GLfloat) ctx->Pixel.GreenScale;
3003 break;
3004 case GL_INDEX_BITS:
3005 *params = (GLfloat) ctx->Visual.indexBits;
3006 break;
3007 case GL_INDEX_CLEAR_VALUE:
3008 *params = (GLfloat) ctx->Color.ClearIndex;
3009 break;
3010 case GL_INDEX_MODE:
3011 *params = ctx->Visual.rgbMode ? 0.0F : 1.0F;
3012 break;
3013 case GL_INDEX_OFFSET:
3014 *params = (GLfloat) ctx->Pixel.IndexOffset;
3015 break;
3016 case GL_INDEX_SHIFT:
3017 *params = (GLfloat) ctx->Pixel.IndexShift;
3018 break;
3019 case GL_INDEX_WRITEMASK:
3020 *params = (GLfloat) ctx->Color.IndexMask;
3021 break;
3022 case GL_LIGHT0:
3023 case GL_LIGHT1:
3024 case GL_LIGHT2:
3025 case GL_LIGHT3:
3026 case GL_LIGHT4:
3027 case GL_LIGHT5:
3028 case GL_LIGHT6:
3029 case GL_LIGHT7:
3030 *params = (GLfloat) ctx->Light.Light[pname-GL_LIGHT0].Enabled;
3031 break;
3032 case GL_LIGHTING:
3033 *params = (GLfloat) ctx->Light.Enabled;
3034 break;
3035 case GL_LIGHT_MODEL_AMBIENT:
3036 params[0] = ctx->Light.Model.Ambient[0];
3037 params[1] = ctx->Light.Model.Ambient[1];
3038 params[2] = ctx->Light.Model.Ambient[2];
3039 params[3] = ctx->Light.Model.Ambient[3];
3040 break;
3041 case GL_LIGHT_MODEL_COLOR_CONTROL:
3042 params[0] = ENUM_TO_FLOAT(ctx->Light.Model.ColorControl);
3043 break;
3044 case GL_LIGHT_MODEL_LOCAL_VIEWER:
3045 *params = (GLfloat) ctx->Light.Model.LocalViewer;
3046 break;
3047 case GL_LIGHT_MODEL_TWO_SIDE:
3048 *params = (GLfloat) ctx->Light.Model.TwoSide;
3049 break;
3050 case GL_LINE_SMOOTH:
3051 *params = (GLfloat) ctx->Line.SmoothFlag;
3052 break;
3053 case GL_LINE_SMOOTH_HINT:
3054 *params = ENUM_TO_FLOAT(ctx->Hint.LineSmooth);
3055 break;
3056 case GL_LINE_STIPPLE:
3057 *params = (GLfloat) ctx->Line.StippleFlag;
3058 break;
3059 case GL_LINE_STIPPLE_PATTERN:
3060 *params = (GLfloat) ctx->Line.StipplePattern;
3061 break;
3062 case GL_LINE_STIPPLE_REPEAT:
3063 *params = (GLfloat) ctx->Line.StippleFactor;
3064 break;
3065 case GL_LINE_WIDTH:
3066 *params = (GLfloat) ctx->Line.Width;
3067 break;
3068 case GL_LINE_WIDTH_GRANULARITY:
3069 *params = (GLfloat) ctx->Const.LineWidthGranularity;
3070 break;
3071 case GL_LINE_WIDTH_RANGE:
3072 params[0] = (GLfloat) ctx->Const.MinLineWidthAA;
3073 params[1] = (GLfloat) ctx->Const.MaxLineWidthAA;
3074 break;
3075 case GL_ALIASED_LINE_WIDTH_RANGE:
3076 params[0] = (GLfloat) ctx->Const.MinLineWidth;
3077 params[1] = (GLfloat) ctx->Const.MaxLineWidth;
3078 break;
3079 case GL_LIST_BASE:
3080 *params = (GLfloat) ctx->List.ListBase;
3081 break;
3082 case GL_LIST_INDEX:
3083 *params = (GLfloat) ctx->CurrentListNum;
3084 break;
3085 case GL_LIST_MODE:
3086 *params = ctx->ExecuteFlag ? ENUM_TO_FLOAT(GL_COMPILE_AND_EXECUTE)
3087 : ENUM_TO_FLOAT(GL_COMPILE);
3088 break;
3089 case GL_INDEX_LOGIC_OP:
3090 *params = (GLfloat) ctx->Color.IndexLogicOpEnabled;
3091 break;
3092 case GL_COLOR_LOGIC_OP:
3093 *params = (GLfloat) ctx->Color.ColorLogicOpEnabled;
3094 break;
3095 case GL_LOGIC_OP_MODE:
3096 *params = ENUM_TO_FLOAT(ctx->Color.LogicOp);
3097 break;
3098 case GL_MAP1_COLOR_4:
3099 *params = (GLfloat) ctx->Eval.Map1Color4;
3100 break;
3101 case GL_MAP1_GRID_DOMAIN:
3102 params[0] = ctx->Eval.MapGrid1u1;
3103 params[1] = ctx->Eval.MapGrid1u2;
3104 break;
3105 case GL_MAP1_GRID_SEGMENTS:
3106 *params = (GLfloat) ctx->Eval.MapGrid1un;
3107 break;
3108 case GL_MAP1_INDEX:
3109 *params = (GLfloat) ctx->Eval.Map1Index;
3110 break;
3111 case GL_MAP1_NORMAL:
3112 *params = (GLfloat) ctx->Eval.Map1Normal;
3113 break;
3114 case GL_MAP1_TEXTURE_COORD_1:
3115 *params = (GLfloat) ctx->Eval.Map1TextureCoord1;
3116 break;
3117 case GL_MAP1_TEXTURE_COORD_2:
3118 *params = (GLfloat) ctx->Eval.Map1TextureCoord2;
3119 break;
3120 case GL_MAP1_TEXTURE_COORD_3:
3121 *params = (GLfloat) ctx->Eval.Map1TextureCoord3;
3122 break;
3123 case GL_MAP1_TEXTURE_COORD_4:
3124 *params = (GLfloat) ctx->Eval.Map1TextureCoord4;
3125 break;
3126 case GL_MAP1_VERTEX_3:
3127 *params = (GLfloat) ctx->Eval.Map1Vertex3;
3128 break;
3129 case GL_MAP1_VERTEX_4:
3130 *params = (GLfloat) ctx->Eval.Map1Vertex4;
3131 break;
3132 case GL_MAP2_COLOR_4:
3133 *params = (GLfloat) ctx->Eval.Map2Color4;
3134 break;
3135 case GL_MAP2_GRID_DOMAIN:
3136 params[0] = ctx->Eval.MapGrid2u1;
3137 params[1] = ctx->Eval.MapGrid2u2;
3138 params[2] = ctx->Eval.MapGrid2v1;
3139 params[3] = ctx->Eval.MapGrid2v2;
3140 break;
3141 case GL_MAP2_GRID_SEGMENTS:
3142 params[0] = (GLfloat) ctx->Eval.MapGrid2un;
3143 params[1] = (GLfloat) ctx->Eval.MapGrid2vn;
3144 break;
3145 case GL_MAP2_INDEX:
3146 *params = (GLfloat) ctx->Eval.Map2Index;
3147 break;
3148 case GL_MAP2_NORMAL:
3149 *params = (GLfloat) ctx->Eval.Map2Normal;
3150 break;
3151 case GL_MAP2_TEXTURE_COORD_1:
3152 *params = ctx->Eval.Map2TextureCoord1;
3153 break;
3154 case GL_MAP2_TEXTURE_COORD_2:
3155 *params = ctx->Eval.Map2TextureCoord2;
3156 break;
3157 case GL_MAP2_TEXTURE_COORD_3:
3158 *params = ctx->Eval.Map2TextureCoord3;
3159 break;
3160 case GL_MAP2_TEXTURE_COORD_4:
3161 *params = ctx->Eval.Map2TextureCoord4;
3162 break;
3163 case GL_MAP2_VERTEX_3:
3164 *params = (GLfloat) ctx->Eval.Map2Vertex3;
3165 break;
3166 case GL_MAP2_VERTEX_4:
3167 *params = (GLfloat) ctx->Eval.Map2Vertex4;
3168 break;
3169 case GL_MAP_COLOR:
3170 *params = (GLfloat) ctx->Pixel.MapColorFlag;
3171 break;
3172 case GL_MAP_STENCIL:
3173 *params = (GLfloat) ctx->Pixel.MapStencilFlag;
3174 break;
3175 case GL_MATRIX_MODE:
3176 *params = ENUM_TO_FLOAT(ctx->Transform.MatrixMode);
3177 break;
3178 case GL_MAX_ATTRIB_STACK_DEPTH:
3179 *params = (GLfloat) MAX_ATTRIB_STACK_DEPTH;
3180 break;
3181 case GL_MAX_CLIENT_ATTRIB_STACK_DEPTH:
3182 *params = (GLfloat) MAX_CLIENT_ATTRIB_STACK_DEPTH;
3183 break;
3184 case GL_MAX_CLIP_PLANES:
3185 *params = (GLfloat) ctx->Const.MaxClipPlanes;
3186 break;
3187 case GL_MAX_ELEMENTS_VERTICES: /* GL_VERSION_1_2 */
3188 *params = (GLfloat) ctx->Const.MaxArrayLockSize;
3189 break;
3190 case GL_MAX_ELEMENTS_INDICES: /* GL_VERSION_1_2 */
3191 *params = (GLfloat) ctx->Const.MaxArrayLockSize;
3192 break;
3193 case GL_MAX_EVAL_ORDER:
3194 *params = (GLfloat) MAX_EVAL_ORDER;
3195 break;
3196 case GL_MAX_LIGHTS:
3197 *params = (GLfloat) ctx->Const.MaxLights;
3198 break;
3199 case GL_MAX_LIST_NESTING:
3200 *params = (GLfloat) MAX_LIST_NESTING;
3201 break;
3202 case GL_MAX_MODELVIEW_STACK_DEPTH:
3203 *params = (GLfloat) MAX_MODELVIEW_STACK_DEPTH;
3204 break;
3205 case GL_MAX_NAME_STACK_DEPTH:
3206 *params = (GLfloat) MAX_NAME_STACK_DEPTH;
3207 break;
3208 case GL_MAX_PIXEL_MAP_TABLE:
3209 *params = (GLfloat) MAX_PIXEL_MAP_TABLE;
3210 break;
3211 case GL_MAX_PROJECTION_STACK_DEPTH:
3212 *params = (GLfloat) MAX_PROJECTION_STACK_DEPTH;
3213 break;
3214 case GL_MAX_TEXTURE_SIZE:
3215 *params = (GLfloat) (1 << (ctx->Const.MaxTextureLevels - 1));
3216 break;
3217 case GL_MAX_3D_TEXTURE_SIZE:
3218 *params = (GLfloat) (1 << (ctx->Const.Max3DTextureLevels - 1));
3219 break;
3220 case GL_MAX_TEXTURE_STACK_DEPTH:
3221 *params = (GLfloat) MAX_TEXTURE_STACK_DEPTH;
3222 break;
3223 case GL_MAX_VIEWPORT_DIMS:
3224 params[0] = (GLfloat) MAX_WIDTH;
3225 params[1] = (GLfloat) MAX_HEIGHT;
3226 break;
3227 case GL_MODELVIEW_MATRIX:
3228 for (i=0;i<16;i++) {
3229 params[i] = ctx->ModelviewMatrixStack.Top->m[i];
3230 }
3231 break;
3232 case GL_MODELVIEW_STACK_DEPTH:
3233 *params = (GLfloat) (ctx->ModelviewMatrixStack.Depth + 1);
3234 break;
3235 case GL_NAME_STACK_DEPTH:
3236 *params = (GLfloat) ctx->Select.NameStackDepth;
3237 break;
3238 case GL_NORMALIZE:
3239 *params = (GLfloat) ctx->Transform.Normalize;
3240 break;
3241 case GL_PACK_ALIGNMENT:
3242 *params = (GLfloat) ctx->Pack.Alignment;
3243 break;
3244 case GL_PACK_LSB_FIRST:
3245 *params = (GLfloat) ctx->Pack.LsbFirst;
3246 break;
3247 case GL_PACK_ROW_LENGTH:
3248 *params = (GLfloat) ctx->Pack.RowLength;
3249 break;
3250 case GL_PACK_SKIP_PIXELS:
3251 *params = (GLfloat) ctx->Pack.SkipPixels;
3252 break;
3253 case GL_PACK_SKIP_ROWS:
3254 *params = (GLfloat) ctx->Pack.SkipRows;
3255 break;
3256 case GL_PACK_SWAP_BYTES:
3257 *params = (GLfloat) ctx->Pack.SwapBytes;
3258 break;
3259 case GL_PACK_SKIP_IMAGES_EXT:
3260 *params = (GLfloat) ctx->Pack.SkipImages;
3261 break;
3262 case GL_PACK_IMAGE_HEIGHT_EXT:
3263 *params = (GLfloat) ctx->Pack.ImageHeight;
3264 break;
3265 case GL_PERSPECTIVE_CORRECTION_HINT:
3266 *params = ENUM_TO_FLOAT(ctx->Hint.PerspectiveCorrection);
3267 break;
3268 case GL_PIXEL_MAP_A_TO_A_SIZE:
3269 *params = (GLfloat) ctx->Pixel.MapAtoAsize;
3270 break;
3271 case GL_PIXEL_MAP_B_TO_B_SIZE:
3272 *params = (GLfloat) ctx->Pixel.MapBtoBsize;
3273 break;
3274 case GL_PIXEL_MAP_G_TO_G_SIZE:
3275 *params = (GLfloat) ctx->Pixel.MapGtoGsize;
3276 break;
3277 case GL_PIXEL_MAP_I_TO_A_SIZE:
3278 *params = (GLfloat) ctx->Pixel.MapItoAsize;
3279 break;
3280 case GL_PIXEL_MAP_I_TO_B_SIZE:
3281 *params = (GLfloat) ctx->Pixel.MapItoBsize;
3282 break;
3283 case GL_PIXEL_MAP_I_TO_G_SIZE:
3284 *params = (GLfloat) ctx->Pixel.MapItoGsize;
3285 break;
3286 case GL_PIXEL_MAP_I_TO_I_SIZE:
3287 *params = (GLfloat) ctx->Pixel.MapItoIsize;
3288 break;
3289 case GL_PIXEL_MAP_I_TO_R_SIZE:
3290 *params = (GLfloat) ctx->Pixel.MapItoRsize;
3291 break;
3292 case GL_PIXEL_MAP_R_TO_R_SIZE:
3293 *params = (GLfloat) ctx->Pixel.MapRtoRsize;
3294 break;
3295 case GL_PIXEL_MAP_S_TO_S_SIZE:
3296 *params = (GLfloat) ctx->Pixel.MapStoSsize;
3297 break;
3298 case GL_POINT_SIZE:
3299 *params = (GLfloat) ctx->Point.Size;
3300 break;
3301 case GL_POINT_SIZE_GRANULARITY:
3302 *params = (GLfloat) ctx->Const.PointSizeGranularity;
3303 break;
3304 case GL_POINT_SIZE_RANGE:
3305 params[0] = (GLfloat) ctx->Const.MinPointSizeAA;
3306 params[1] = (GLfloat) ctx->Const.MaxPointSizeAA;
3307 break;
3308 case GL_ALIASED_POINT_SIZE_RANGE:
3309 params[0] = (GLfloat) ctx->Const.MinPointSize;
3310 params[1] = (GLfloat) ctx->Const.MaxPointSize;
3311 break;
3312 case GL_POINT_SMOOTH:
3313 *params = (GLfloat) ctx->Point.SmoothFlag;
3314 break;
3315 case GL_POINT_SMOOTH_HINT:
3316 *params = ENUM_TO_FLOAT(ctx->Hint.PointSmooth);
3317 break;
3318 case GL_POINT_SIZE_MIN_EXT:
3319 *params = (GLfloat) (ctx->Point.MinSize);
3320 break;
3321 case GL_POINT_SIZE_MAX_EXT:
3322 *params = (GLfloat) (ctx->Point.MaxSize);
3323 break;
3324 case GL_POINT_FADE_THRESHOLD_SIZE_EXT:
3325 *params = (GLfloat) (ctx->Point.Threshold);
3326 break;
3327 case GL_DISTANCE_ATTENUATION_EXT:
3328 params[0] = (GLfloat) (ctx->Point.Params[0]);
3329 params[1] = (GLfloat) (ctx->Point.Params[1]);
3330 params[2] = (GLfloat) (ctx->Point.Params[2]);
3331 break;
3332 case GL_POLYGON_MODE:
3333 params[0] = ENUM_TO_FLOAT(ctx->Polygon.FrontMode);
3334 params[1] = ENUM_TO_FLOAT(ctx->Polygon.BackMode);
3335 break;
3336 #ifdef GL_EXT_polygon_offset
3337 case GL_POLYGON_OFFSET_BIAS_EXT:
3338 *params = ctx->Polygon.OffsetUnits;
3339 break;
3340 #endif
3341 case GL_POLYGON_OFFSET_FACTOR:
3342 *params = ctx->Polygon.OffsetFactor;
3343 break;
3344 case GL_POLYGON_OFFSET_UNITS:
3345 *params = ctx->Polygon.OffsetUnits;
3346 break;
3347 case GL_POLYGON_SMOOTH:
3348 *params = (GLfloat) ctx->Polygon.SmoothFlag;
3349 break;
3350 case GL_POLYGON_SMOOTH_HINT:
3351 *params = ENUM_TO_FLOAT(ctx->Hint.PolygonSmooth);
3352 break;
3353 case GL_POLYGON_STIPPLE:
3354 *params = (GLfloat) ctx->Polygon.StippleFlag;
3355 break;
3356 case GL_PROJECTION_MATRIX:
3357 for (i=0;i<16;i++) {
3358 params[i] = ctx->ProjectionMatrixStack.Top->m[i];
3359 }
3360 break;
3361 case GL_PROJECTION_STACK_DEPTH:
3362 *params = (GLfloat) (ctx->ProjectionMatrixStack.Depth + 1);
3363 break;
3364 case GL_READ_BUFFER:
3365 *params = ENUM_TO_FLOAT(ctx->Pixel.ReadBuffer);
3366 break;
3367 case GL_RED_BIAS:
3368 *params = ctx->Pixel.RedBias;
3369 break;
3370 case GL_RED_BITS:
3371 *params = (GLfloat) ctx->Visual.redBits;
3372 break;
3373 case GL_RED_SCALE:
3374 *params = ctx->Pixel.RedScale;
3375 break;
3376 case GL_RENDER_MODE:
3377 *params = ENUM_TO_FLOAT(ctx->RenderMode);
3378 break;
3379 case GL_RESCALE_NORMAL:
3380 *params = (GLfloat) ctx->Transform.RescaleNormals;
3381 break;
3382 case GL_RGBA_MODE:
3383 *params = (GLfloat) ctx->Visual.rgbMode;
3384 break;
3385 case GL_SCISSOR_BOX:
3386 params[0] = (GLfloat) ctx->Scissor.X;
3387 params[1] = (GLfloat) ctx->Scissor.Y;
3388 params[2] = (GLfloat) ctx->Scissor.Width;
3389 params[3] = (GLfloat) ctx->Scissor.Height;
3390 break;
3391 case GL_SCISSOR_TEST:
3392 *params = (GLfloat) ctx->Scissor.Enabled;
3393 break;
3394 case GL_SELECTION_BUFFER_SIZE:
3395 *params = (GLfloat) ctx->Select.BufferSize;
3396 break;
3397 case GL_SHADE_MODEL:
3398 *params = ENUM_TO_FLOAT(ctx->Light.ShadeModel);
3399 break;
3400 case GL_SHARED_TEXTURE_PALETTE_EXT:
3401 *params = (GLfloat) ctx->Texture.SharedPalette;
3402 break;
3403 case GL_STENCIL_BITS:
3404 *params = (GLfloat) ctx->Visual.stencilBits;
3405 break;
3406 case GL_STENCIL_CLEAR_VALUE:
3407 *params = (GLfloat) ctx->Stencil.Clear;
3408 break;
3409 case GL_STENCIL_FAIL:
3410 *params = ENUM_TO_FLOAT(ctx->Stencil.FailFunc);
3411 break;
3412 case GL_STENCIL_FUNC:
3413 *params = ENUM_TO_FLOAT(ctx->Stencil.Function);
3414 break;
3415 case GL_STENCIL_PASS_DEPTH_FAIL:
3416 *params = ENUM_TO_FLOAT(ctx->Stencil.ZFailFunc);
3417 break;
3418 case GL_STENCIL_PASS_DEPTH_PASS:
3419 *params = ENUM_TO_FLOAT(ctx->Stencil.ZPassFunc);
3420 break;
3421 case GL_STENCIL_REF:
3422 *params = (GLfloat) ctx->Stencil.Ref;
3423 break;
3424 case GL_STENCIL_TEST:
3425 *params = (GLfloat) ctx->Stencil.Enabled;
3426 break;
3427 case GL_STENCIL_VALUE_MASK:
3428 *params = (GLfloat) ctx->Stencil.ValueMask;
3429 break;
3430 case GL_STENCIL_WRITEMASK:
3431 *params = (GLfloat) ctx->Stencil.WriteMask;
3432 break;
3433 case GL_STEREO:
3434 *params = (GLfloat) ctx->Visual.stereoMode;
3435 break;
3436 case GL_SUBPIXEL_BITS:
3437 *params = (GLfloat) ctx->Const.SubPixelBits;
3438 break;
3439 case GL_TEXTURE_1D:
3440 *params = _mesa_IsEnabled(GL_TEXTURE_1D) ? 1.0F : 0.0F;
3441 break;
3442 case GL_TEXTURE_2D:
3443 *params = _mesa_IsEnabled(GL_TEXTURE_2D) ? 1.0F : 0.0F;
3444 break;
3445 case GL_TEXTURE_3D:
3446 *params = _mesa_IsEnabled(GL_TEXTURE_3D) ? 1.0F : 0.0F;
3447 break;
3448 case GL_TEXTURE_BINDING_1D:
3449 *params = (GLfloat) textureUnit->Current1D->Name;
3450 break;
3451 case GL_TEXTURE_BINDING_2D:
3452 *params = (GLfloat) textureUnit->Current2D->Name;
3453 break;
3454 case GL_TEXTURE_BINDING_3D:
3455 *params = (GLfloat) textureUnit->Current2D->Name;
3456 break;
3457 case GL_TEXTURE_ENV_COLOR:
3458 params[0] = textureUnit->EnvColor[0];
3459 params[1] = textureUnit->EnvColor[1];
3460 params[2] = textureUnit->EnvColor[2];
3461 params[3] = textureUnit->EnvColor[3];
3462 break;
3463 case GL_TEXTURE_ENV_MODE:
3464 *params = ENUM_TO_FLOAT(textureUnit->EnvMode);
3465 break;
3466 case GL_TEXTURE_GEN_S:
3467 *params = (textureUnit->TexGenEnabled & S_BIT) ? 1.0F : 0.0F;
3468 break;
3469 case GL_TEXTURE_GEN_T:
3470 *params = (textureUnit->TexGenEnabled & T_BIT) ? 1.0F : 0.0F;
3471 break;
3472 case GL_TEXTURE_GEN_R:
3473 *params = (textureUnit->TexGenEnabled & R_BIT) ? 1.0F : 0.0F;
3474 break;
3475 case GL_TEXTURE_GEN_Q:
3476 *params = (textureUnit->TexGenEnabled & Q_BIT) ? 1.0F : 0.0F;
3477 break;
3478 case GL_TEXTURE_MATRIX:
3479 for (i=0;i<16;i++) {
3480 params[i] = ctx->TextureMatrixStack[texUnit].Top->m[i];
3481 }
3482 break;
3483 case GL_TEXTURE_STACK_DEPTH:
3484 *params = (GLfloat) (ctx->TextureMatrixStack[texUnit].Depth + 1);
3485 break;
3486 case GL_UNPACK_ALIGNMENT:
3487 *params = (GLfloat) ctx->Unpack.Alignment;
3488 break;
3489 case GL_UNPACK_LSB_FIRST:
3490 *params = (GLfloat) ctx->Unpack.LsbFirst;
3491 break;
3492 case GL_UNPACK_ROW_LENGTH:
3493 *params = (GLfloat) ctx->Unpack.RowLength;
3494 break;
3495 case GL_UNPACK_SKIP_PIXELS:
3496 *params = (GLfloat) ctx->Unpack.SkipPixels;
3497 break;
3498 case GL_UNPACK_SKIP_ROWS:
3499 *params = (GLfloat) ctx->Unpack.SkipRows;
3500 break;
3501 case GL_UNPACK_SWAP_BYTES:
3502 *params = (GLfloat) ctx->Unpack.SwapBytes;
3503 break;
3504 case GL_UNPACK_SKIP_IMAGES_EXT:
3505 *params = (GLfloat) ctx->Unpack.SkipImages;
3506 break;
3507 case GL_UNPACK_IMAGE_HEIGHT_EXT:
3508 *params = (GLfloat) ctx->Unpack.ImageHeight;
3509 break;
3510 case GL_VIEWPORT:
3511 params[0] = (GLfloat) ctx->Viewport.X;
3512 params[1] = (GLfloat) ctx->Viewport.Y;
3513 params[2] = (GLfloat) ctx->Viewport.Width;
3514 params[3] = (GLfloat) ctx->Viewport.Height;
3515 break;
3516 case GL_ZOOM_X:
3517 *params = (GLfloat) ctx->Pixel.ZoomX;
3518 break;
3519 case GL_ZOOM_Y:
3520 *params = (GLfloat) ctx->Pixel.ZoomY;
3521 break;
3522 case GL_VERTEX_ARRAY:
3523 *params = (GLfloat) ctx->Array.Vertex.Enabled;
3524 break;
3525 case GL_VERTEX_ARRAY_SIZE:
3526 *params = (GLfloat) ctx->Array.Vertex.Size;
3527 break;
3528 case GL_VERTEX_ARRAY_TYPE:
3529 *params = ENUM_TO_FLOAT(ctx->Array.Vertex.Type);
3530 break;
3531 case GL_VERTEX_ARRAY_STRIDE:
3532 *params = (GLfloat) ctx->Array.Vertex.Stride;
3533 break;
3534 case GL_VERTEX_ARRAY_COUNT_EXT:
3535 *params = 0.0;
3536 break;
3537 case GL_NORMAL_ARRAY:
3538 *params = (GLfloat) ctx->Array.Normal.Enabled;
3539 break;
3540 case GL_NORMAL_ARRAY_TYPE:
3541 *params = ENUM_TO_FLOAT(ctx->Array.Normal.Type);
3542 break;
3543 case GL_NORMAL_ARRAY_STRIDE:
3544 *params = (GLfloat) ctx->Array.Normal.Stride;
3545 break;
3546 case GL_NORMAL_ARRAY_COUNT_EXT:
3547 *params = 0.0;
3548 break;
3549 case GL_COLOR_ARRAY:
3550 *params = (GLfloat) ctx->Array.Color.Enabled;
3551 break;
3552 case GL_COLOR_ARRAY_SIZE:
3553 *params = (GLfloat) ctx->Array.Color.Size;
3554 break;
3555 case GL_COLOR_ARRAY_TYPE:
3556 *params = ENUM_TO_FLOAT(ctx->Array.Color.Type);
3557 break;
3558 case GL_COLOR_ARRAY_STRIDE:
3559 *params = (GLfloat) ctx->Array.Color.Stride;
3560 break;
3561 case GL_COLOR_ARRAY_COUNT_EXT:
3562 *params = 0.0;
3563 break;
3564 case GL_INDEX_ARRAY:
3565 *params = (GLfloat) ctx->Array.Index.Enabled;
3566 break;
3567 case GL_INDEX_ARRAY_TYPE:
3568 *params = ENUM_TO_FLOAT(ctx->Array.Index.Type);
3569 break;
3570 case GL_INDEX_ARRAY_STRIDE:
3571 *params = (GLfloat) ctx->Array.Index.Stride;
3572 break;
3573 case GL_INDEX_ARRAY_COUNT_EXT:
3574 *params = 0.0;
3575 break;
3576 case GL_TEXTURE_COORD_ARRAY:
3577 *params = (GLfloat) ctx->Array.TexCoord[texUnit].Enabled;
3578 break;
3579 case GL_TEXTURE_COORD_ARRAY_SIZE:
3580 *params = (GLfloat) ctx->Array.TexCoord[texUnit].Size;
3581 break;
3582 case GL_TEXTURE_COORD_ARRAY_TYPE:
3583 *params = ENUM_TO_FLOAT(ctx->Array.TexCoord[texUnit].Type);
3584 break;
3585 case GL_TEXTURE_COORD_ARRAY_STRIDE:
3586 *params = (GLfloat) ctx->Array.TexCoord[texUnit].Stride;
3587 break;
3588 case GL_TEXTURE_COORD_ARRAY_COUNT_EXT:
3589 *params = 0.0;
3590 break;
3591 case GL_EDGE_FLAG_ARRAY:
3592 *params = (GLfloat) ctx->Array.EdgeFlag.Enabled;
3593 break;
3594 case GL_EDGE_FLAG_ARRAY_STRIDE:
3595 *params = (GLfloat) ctx->Array.EdgeFlag.Stride;
3596 break;
3597 case GL_EDGE_FLAG_ARRAY_COUNT_EXT:
3598 *params = 0.0;
3599 break;
3600
3601 /* GL_ARB_multitexture */
3602 case GL_MAX_TEXTURE_UNITS_ARB:
3603 *params = (GLfloat) ctx->Const.MaxTextureUnits;
3604 break;
3605 case GL_ACTIVE_TEXTURE_ARB:
3606 *params = (GLfloat) (GL_TEXTURE0_ARB + ctx->Texture.CurrentUnit);
3607 break;
3608 case GL_CLIENT_ACTIVE_TEXTURE_ARB:
3609 *params = (GLfloat) (GL_TEXTURE0_ARB + ctx->Array.ActiveTexture);
3610 break;
3611
3612 /* GL_ARB_texture_cube_map */
3613 case GL_TEXTURE_CUBE_MAP_ARB:
3614 CHECK_EXTENSION_F(ARB_texture_cube_map);
3615 *params = (GLfloat) _mesa_IsEnabled(GL_TEXTURE_CUBE_MAP_ARB);
3616 break;
3617 case GL_TEXTURE_BINDING_CUBE_MAP_ARB:
3618 CHECK_EXTENSION_F(ARB_texture_cube_map);
3619 *params = (GLfloat) textureUnit->CurrentCubeMap->Name;
3620 break;
3621 case GL_MAX_CUBE_MAP_TEXTURE_SIZE_ARB:
3622 CHECK_EXTENSION_F(ARB_texture_cube_map);
3623 *params = (GLfloat) (1 << (ctx->Const.MaxCubeTextureLevels - 1));
3624 break;
3625
3626 /* GL_ARB_texture_compression */
3627 case GL_TEXTURE_COMPRESSION_HINT_ARB:
3628 CHECK_EXTENSION_F(ARB_texture_compression);
3629 *params = (GLfloat) ctx->Hint.TextureCompression;
3630 break;
3631 case GL_NUM_COMPRESSED_TEXTURE_FORMATS_ARB:
3632 CHECK_EXTENSION_F(ARB_texture_compression);
3633 *params = (GLfloat) ctx->Const.NumCompressedTextureFormats;
3634 break;
3635 case GL_COMPRESSED_TEXTURE_FORMATS_ARB:
3636 CHECK_EXTENSION_F(ARB_texture_compression);
3637 {
3638 GLuint i;
3639 for (i = 0; i < ctx->Const.NumCompressedTextureFormats; i++)
3640 params[i] = (GLfloat) ctx->Const.CompressedTextureFormats[i];
3641 }
3642 break;
3643
3644 /* GL_EXT_compiled_vertex_array */
3645 case GL_ARRAY_ELEMENT_LOCK_FIRST_EXT:
3646 CHECK_EXTENSION_F(EXT_compiled_vertex_array);
3647 *params = (GLfloat) ctx->Array.LockFirst;
3648 break;
3649 case GL_ARRAY_ELEMENT_LOCK_COUNT_EXT:
3650 CHECK_EXTENSION_F(EXT_compiled_vertex_array);
3651 *params = (GLfloat) ctx->Array.LockCount;
3652 break;
3653
3654 /* GL_ARB_transpose_matrix */
3655 case GL_TRANSPOSE_COLOR_MATRIX_ARB:
3656 _math_transposef(params, ctx->ColorMatrixStack.Top->m);
3657 break;
3658 case GL_TRANSPOSE_MODELVIEW_MATRIX_ARB:
3659 _math_transposef(params, ctx->ModelviewMatrixStack.Top->m);
3660 break;
3661 case GL_TRANSPOSE_PROJECTION_MATRIX_ARB:
3662 _math_transposef(params, ctx->ProjectionMatrixStack.Top->m);
3663 break;
3664 case GL_TRANSPOSE_TEXTURE_MATRIX_ARB:
3665 _math_transposef(params, ctx->TextureMatrixStack[texUnit].Top->m);
3666 break;
3667
3668 /* GL_HP_occlusion_test */
3669 case GL_OCCLUSION_TEST_HP:
3670 CHECK_EXTENSION_F(HP_occlusion_test);
3671 *params = (GLfloat) ctx->Depth.OcclusionTest;
3672 break;
3673 case GL_OCCLUSION_TEST_RESULT_HP:
3674 CHECK_EXTENSION_F(HP_occlusion_test);
3675 if (ctx->Depth.OcclusionTest)
3676 *params = (GLfloat) ctx->OcclusionResult;
3677 else
3678 *params = (GLfloat) ctx->OcclusionResultSaved;
3679 /* reset flag now */
3680 ctx->OcclusionResult = GL_FALSE;
3681 ctx->OcclusionResultSaved = GL_FALSE;
3682 break;
3683
3684 /* GL_SGIS_pixel_texture */
3685 case GL_PIXEL_TEXTURE_SGIS:
3686 *params = (GLfloat) ctx->Pixel.PixelTextureEnabled;
3687 break;
3688
3689 /* GL_SGIX_pixel_texture */
3690 case GL_PIXEL_TEX_GEN_SGIX:
3691 *params = (GLfloat) ctx->Pixel.PixelTextureEnabled;
3692 break;
3693 case GL_PIXEL_TEX_GEN_MODE_SGIX:
3694 *params = (GLfloat) pixel_texgen_mode(ctx);
3695 break;
3696
3697 /* GL_SGI_color_matrix (also in 1.2 imaging) */
3698 case GL_COLOR_MATRIX_SGI:
3699 for (i=0;i<16;i++) {
3700 params[i] = ctx->ColorMatrixStack.Top->m[i];
3701 }
3702 break;
3703 case GL_COLOR_MATRIX_STACK_DEPTH_SGI:
3704 *params = (GLfloat) (ctx->ColorMatrixStack.Depth + 1);
3705 break;
3706 case GL_MAX_COLOR_MATRIX_STACK_DEPTH_SGI:
3707 *params = (GLfloat) MAX_COLOR_STACK_DEPTH;
3708 break;
3709 case GL_POST_COLOR_MATRIX_RED_SCALE_SGI:
3710 *params = ctx->Pixel.PostColorMatrixScale[0];
3711 break;
3712 case GL_POST_COLOR_MATRIX_GREEN_SCALE_SGI:
3713 *params = ctx->Pixel.PostColorMatrixScale[1];
3714 break;
3715 case GL_POST_COLOR_MATRIX_BLUE_SCALE_SGI:
3716 *params = ctx->Pixel.PostColorMatrixScale[2];
3717 break;
3718 case GL_POST_COLOR_MATRIX_ALPHA_SCALE_SGI:
3719 *params = ctx->Pixel.PostColorMatrixScale[3];
3720 break;
3721 case GL_POST_COLOR_MATRIX_RED_BIAS_SGI:
3722 *params = ctx->Pixel.PostColorMatrixBias[0];
3723 break;
3724 case GL_POST_COLOR_MATRIX_GREEN_BIAS_SGI:
3725 *params = ctx->Pixel.PostColorMatrixBias[1];
3726 break;
3727 case GL_POST_COLOR_MATRIX_BLUE_BIAS_SGI:
3728 *params = ctx->Pixel.PostColorMatrixBias[2];
3729 break;
3730 case GL_POST_COLOR_MATRIX_ALPHA_BIAS_SGI:
3731 *params = ctx->Pixel.PostColorMatrixBias[3];
3732 break;
3733
3734 /* GL_EXT_convolution (also in 1.2 imaging) */
3735 case GL_CONVOLUTION_1D_EXT:
3736 CHECK_EXTENSION_F(EXT_convolution);
3737 *params = (GLfloat) ctx->Pixel.Convolution1DEnabled;
3738 break;
3739 case GL_CONVOLUTION_2D:
3740 CHECK_EXTENSION_F(EXT_convolution);
3741 *params = (GLfloat) ctx->Pixel.Convolution2DEnabled;
3742 break;
3743 case GL_SEPARABLE_2D:
3744 CHECK_EXTENSION_F(EXT_convolution);
3745 *params = (GLfloat) ctx->Pixel.Separable2DEnabled;
3746 break;
3747 case GL_MAX_CONVOLUTION_WIDTH:
3748 CHECK_EXTENSION_F(EXT_convolution);
3749 *params = (GLfloat) ctx->Const.MaxConvolutionWidth;
3750 break;
3751 case GL_MAX_CONVOLUTION_HEIGHT:
3752 CHECK_EXTENSION_F(EXT_convolution);
3753 *params = (GLfloat) ctx->Const.MaxConvolutionHeight;
3754 break;
3755 case GL_POST_CONVOLUTION_RED_SCALE_EXT:
3756 CHECK_EXTENSION_F(EXT_convolution);
3757 *params = ctx->Pixel.PostConvolutionScale[0];
3758 break;
3759 case GL_POST_CONVOLUTION_GREEN_SCALE_EXT:
3760 CHECK_EXTENSION_F(EXT_convolution);
3761 *params = ctx->Pixel.PostConvolutionScale[1];
3762 break;
3763 case GL_POST_CONVOLUTION_BLUE_SCALE_EXT:
3764 CHECK_EXTENSION_F(EXT_convolution);
3765 *params = ctx->Pixel.PostConvolutionScale[2];
3766 break;
3767 case GL_POST_CONVOLUTION_ALPHA_SCALE_EXT:
3768 CHECK_EXTENSION_F(EXT_convolution);
3769 *params = ctx->Pixel.PostConvolutionScale[3];
3770 break;
3771 case GL_POST_CONVOLUTION_RED_BIAS_EXT:
3772 CHECK_EXTENSION_F(EXT_convolution);
3773 *params = ctx->Pixel.PostConvolutionBias[0];
3774 break;
3775 case GL_POST_CONVOLUTION_GREEN_BIAS_EXT:
3776 CHECK_EXTENSION_F(EXT_convolution);
3777 *params = ctx->Pixel.PostConvolutionBias[1];
3778 break;
3779 case GL_POST_CONVOLUTION_BLUE_BIAS_EXT:
3780 CHECK_EXTENSION_F(EXT_convolution);
3781 *params = ctx->Pixel.PostConvolutionBias[2];
3782 break;
3783 case GL_POST_CONVOLUTION_ALPHA_BIAS_EXT:
3784 CHECK_EXTENSION_F(EXT_convolution);
3785 *params = ctx->Pixel.PostConvolutionBias[2];
3786 break;
3787
3788 /* GL_EXT_histogram (also in 1.2 imaging) */
3789 case GL_HISTOGRAM:
3790 CHECK_EXTENSION_F(EXT_histogram);
3791 *params = (GLfloat) ctx->Pixel.HistogramEnabled;
3792 break;
3793 case GL_MINMAX:
3794 CHECK_EXTENSION_F(EXT_histogram);
3795 *params = (GLfloat) ctx->Pixel.MinMaxEnabled;
3796 break;
3797
3798 /* GL_SGI_color_table (also in 1.2 imaging */
3799 case GL_COLOR_TABLE_SGI:
3800 *params = (GLfloat) ctx->Pixel.ColorTableEnabled;
3801 break;
3802 case GL_POST_CONVOLUTION_COLOR_TABLE_SGI:
3803 *params = (GLfloat) ctx->Pixel.PostConvolutionColorTableEnabled;
3804 break;
3805 case GL_POST_COLOR_MATRIX_COLOR_TABLE_SGI:
3806 *params = (GLfloat) ctx->Pixel.PostColorMatrixColorTableEnabled;
3807 break;
3808
3809 /* GL_EXT_secondary_color */
3810 case GL_COLOR_SUM_EXT:
3811 CHECK_EXTENSION_F(EXT_secondary_color);
3812 *params = (GLfloat) ctx->Fog.ColorSumEnabled;
3813 break;
3814 case GL_CURRENT_SECONDARY_COLOR_EXT:
3815 CHECK_EXTENSION_F(EXT_secondary_color);
3816 FLUSH_CURRENT(ctx, 0);
3817 params[0] = ctx->Current.Attrib[VERT_ATTRIB_COLOR1][0];
3818 params[1] = ctx->Current.Attrib[VERT_ATTRIB_COLOR1][1];
3819 params[2] = ctx->Current.Attrib[VERT_ATTRIB_COLOR1][2];
3820 break;
3821 case GL_SECONDARY_COLOR_ARRAY_EXT:
3822 CHECK_EXTENSION_F(EXT_secondary_color);
3823 *params = (GLfloat) ctx->Array.SecondaryColor.Enabled;
3824 break;
3825 case GL_SECONDARY_COLOR_ARRAY_TYPE_EXT:
3826 CHECK_EXTENSION_F(EXT_secondary_color);
3827 *params = (GLfloat) ctx->Array.SecondaryColor.Type;
3828 break;
3829 case GL_SECONDARY_COLOR_ARRAY_STRIDE_EXT:
3830 CHECK_EXTENSION_F(EXT_secondary_color);
3831 *params = (GLfloat) ctx->Array.SecondaryColor.Stride;
3832 break;
3833 case GL_SECONDARY_COLOR_ARRAY_SIZE_EXT:
3834 CHECK_EXTENSION_F(EXT_secondary_color);
3835 *params = (GLfloat) ctx->Array.SecondaryColor.Stride;
3836 break;
3837
3838 /* GL_EXT_fog_coord */
3839 case GL_CURRENT_FOG_COORDINATE_EXT:
3840 CHECK_EXTENSION_F(EXT_fog_coord);
3841 FLUSH_CURRENT(ctx, 0);
3842 *params = (GLfloat) ctx->Current.Attrib[VERT_ATTRIB_FOG][0];
3843 break;
3844 case GL_FOG_COORDINATE_ARRAY_EXT:
3845 CHECK_EXTENSION_F(EXT_fog_coord);
3846 *params = (GLfloat) ctx->Array.FogCoord.Enabled;
3847 break;
3848 case GL_FOG_COORDINATE_ARRAY_TYPE_EXT:
3849 CHECK_EXTENSION_F(EXT_fog_coord);
3850 *params = (GLfloat) ctx->Array.FogCoord.Type;
3851 break;
3852 case GL_FOG_COORDINATE_ARRAY_STRIDE_EXT:
3853 CHECK_EXTENSION_F(EXT_fog_coord);
3854 *params = (GLfloat) ctx->Array.FogCoord.Stride;
3855 break;
3856
3857 /* GL_EXT_texture_lod_bias */
3858 case GL_MAX_TEXTURE_LOD_BIAS_EXT:
3859 *params = ctx->Const.MaxTextureLodBias;
3860 break;
3861
3862 /* GL_EXT_texture_filter_anisotropic */
3863 case GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT:
3864 CHECK_EXTENSION_F(EXT_texture_filter_anisotropic);
3865 *params = ctx->Const.MaxTextureMaxAnisotropy;
3866 break;
3867
3868 /* GL_ARB_multisample */
3869 case GL_MULTISAMPLE_ARB:
3870 CHECK_EXTENSION_F(ARB_multisample);
3871 *params = (GLfloat) ctx->Multisample.Enabled;
3872 break;
3873 case GL_SAMPLE_ALPHA_TO_COVERAGE_ARB:
3874 CHECK_EXTENSION_F(ARB_multisample);
3875 *params = (GLfloat) ctx->Multisample.SampleAlphaToCoverage;
3876 break;
3877 case GL_SAMPLE_ALPHA_TO_ONE_ARB:
3878 CHECK_EXTENSION_F(ARB_multisample);
3879 *params = (GLfloat) ctx->Multisample.SampleAlphaToOne;
3880 break;
3881 case GL_SAMPLE_COVERAGE_ARB:
3882 CHECK_EXTENSION_F(ARB_multisample);
3883 *params = (GLfloat) ctx->Multisample.SampleCoverage;
3884 break;
3885 case GL_SAMPLE_COVERAGE_VALUE_ARB:
3886 CHECK_EXTENSION_F(ARB_multisample);
3887 *params = ctx->Multisample.SampleCoverageValue;
3888 break;
3889 case GL_SAMPLE_COVERAGE_INVERT_ARB:
3890 CHECK_EXTENSION_F(ARB_multisample);
3891 *params = (GLfloat) ctx->Multisample.SampleCoverageInvert;
3892 break;
3893 case GL_SAMPLE_BUFFERS_ARB:
3894 CHECK_EXTENSION_F(ARB_multisample);
3895 *params = 0.0; /* XXX fix someday */
3896 break;
3897 case GL_SAMPLES_ARB:
3898 CHECK_EXTENSION_F(ARB_multisample);
3899 *params = 0.0; /* XXX fix someday */
3900 break;
3901
3902 /* GL_IBM_rasterpos_clip */
3903 case GL_RASTER_POSITION_UNCLIPPED_IBM:
3904 CHECK_EXTENSION_F(IBM_rasterpos_clip);
3905 *params = (GLfloat) ctx->Transform.RasterPositionUnclipped;
3906 break;
3907
3908 /* GL_NV_point_sprite */
3909 case GL_POINT_SPRITE_NV:
3910 CHECK_EXTENSION_B(NV_point_sprite);
3911 *params = (GLfloat) ctx->Point.PointSprite;
3912 break;
3913 case GL_POINT_SPRITE_R_MODE_NV:
3914 CHECK_EXTENSION_B(NV_point_sprite);
3915 *params = (GLfloat) ctx->Point.SpriteRMode;
3916 break;
3917
3918 /* GL_SGIS_generate_mipmap */
3919 case GL_GENERATE_MIPMAP_HINT_SGIS:
3920 CHECK_EXTENSION_F(SGIS_generate_mipmap);
3921 *params = (GLfloat) ctx->Hint.GenerateMipmap;
3922 break;
3923
3924 /* GL_NV_vertex_program */
3925 /* XXX to do */
3926
3927 /* GL_NV_texture_rectangle */
3928 case GL_TEXTURE_RECTANGLE_NV:
3929 CHECK_EXTENSION_F(NV_texture_rectangle);
3930 *params = (GLfloat) _mesa_IsEnabled(GL_TEXTURE_RECTANGLE_NV);
3931 break;
3932 case GL_TEXTURE_BINDING_RECTANGLE_NV:
3933 CHECK_EXTENSION_F(NV_texture_rectangle);
3934 *params = (GLfloat) textureUnit->CurrentRect->Name;
3935 break;
3936 case GL_MAX_RECTANGLE_TEXTURE_SIZE_NV:
3937 CHECK_EXTENSION_F(NV_texture_rectangle);
3938 *params = (GLfloat) ctx->Const.MaxTextureRectSize;
3939 break;
3940
3941 default:
3942 GET_FLOAT_ERROR;
3943 }
3944 }
3945
3946
3947 void
3948 _mesa_GetIntegerv( GLenum pname, GLint *params )
3949 {
3950 GET_CURRENT_CONTEXT(ctx);
3951 GLuint i;
3952 GLuint texUnit = ctx->Texture.CurrentUnit;
3953 const struct gl_texture_unit *textureUnit = &ctx->Texture.Unit[texUnit];
3954 ASSERT_OUTSIDE_BEGIN_END(ctx);
3955
3956 if (!params)
3957 return;
3958
3959 /* We need this in order to get correct results for
3960 * GL_OCCLUSION_TEST_RESULT_HP. There might be other important cases.
3961 */
3962 FLUSH_VERTICES(ctx, 0);
3963
3964 if (MESA_VERBOSE & VERBOSE_API)
3965 _mesa_debug(ctx, "glGetIntegerv %s\n", _mesa_lookup_enum_by_nr(pname));
3966
3967 if (ctx->Driver.GetIntegerv
3968 && (*ctx->Driver.GetIntegerv)(ctx, pname, params))
3969 return;
3970
3971 switch (pname) {
3972 case GL_ACCUM_RED_BITS:
3973 *params = (GLint) ctx->Visual.accumRedBits;
3974 break;
3975 case GL_ACCUM_GREEN_BITS:
3976 *params = (GLint) ctx->Visual.accumGreenBits;
3977 break;
3978 case GL_ACCUM_BLUE_BITS:
3979 *params = (GLint) ctx->Visual.accumBlueBits;
3980 break;
3981 case GL_ACCUM_ALPHA_BITS:
3982 *params = (GLint) ctx->Visual.accumAlphaBits;
3983 break;
3984 case GL_ACCUM_CLEAR_VALUE:
3985 params[0] = FLOAT_TO_INT( ctx->Accum.ClearColor[0] );
3986 params[1] = FLOAT_TO_INT( ctx->Accum.ClearColor[1] );
3987 params[2] = FLOAT_TO_INT( ctx->Accum.ClearColor[2] );
3988 params[3] = FLOAT_TO_INT( ctx->Accum.ClearColor[3] );
3989 break;
3990 case GL_ALPHA_BIAS:
3991 *params = (GLint) ctx->Pixel.AlphaBias;
3992 break;
3993 case GL_ALPHA_BITS:
3994 *params = ctx->Visual.alphaBits;
3995 break;
3996 case GL_ALPHA_SCALE:
3997 *params = (GLint) ctx->Pixel.AlphaScale;
3998 break;
3999 case GL_ALPHA_TEST:
4000 *params = (GLint) ctx->Color.AlphaEnabled;
4001 break;
4002 case GL_ALPHA_TEST_REF:
4003 *params = FLOAT_TO_INT( (GLfloat) ctx->Color.AlphaRef / CHAN_MAXF );
4004 break;
4005 case GL_ALPHA_TEST_FUNC:
4006 *params = (GLint) ctx->Color.AlphaFunc;
4007 break;
4008 case GL_ATTRIB_STACK_DEPTH:
4009 *params = (GLint) (ctx->AttribStackDepth);
4010 break;
4011 case GL_AUTO_NORMAL:
4012 *params = (GLint) ctx->Eval.AutoNormal;
4013 break;
4014 case GL_AUX_BUFFERS:
4015 *params = (GLint) ctx->Const.NumAuxBuffers;
4016 break;
4017 case GL_BLEND:
4018 *params = (GLint) ctx->Color.BlendEnabled;
4019 break;
4020 case GL_BLEND_DST:
4021 *params = (GLint) ctx->Color.BlendDstRGB;
4022 break;
4023 case GL_BLEND_SRC:
4024 *params = (GLint) ctx->Color.BlendSrcRGB;
4025 break;
4026 case GL_BLEND_SRC_RGB_EXT:
4027 *params = (GLint) ctx->Color.BlendSrcRGB;
4028 break;
4029 case GL_BLEND_DST_RGB_EXT:
4030 *params = (GLint) ctx->Color.BlendDstRGB;
4031 break;
4032 case GL_BLEND_SRC_ALPHA_EXT:
4033 *params = (GLint) ctx->Color.BlendSrcA;
4034 break;
4035 case GL_BLEND_DST_ALPHA_EXT:
4036 *params = (GLint) ctx->Color.BlendDstA;
4037 break;
4038 case GL_BLEND_EQUATION_EXT:
4039 *params = (GLint) ctx->Color.BlendEquation;
4040 break;
4041 case GL_BLEND_COLOR_EXT:
4042 params[0] = FLOAT_TO_INT( ctx->Color.BlendColor[0] );
4043 params[1] = FLOAT_TO_INT( ctx->Color.BlendColor[1] );
4044 params[2] = FLOAT_TO_INT( ctx->Color.BlendColor[2] );
4045 params[3] = FLOAT_TO_INT( ctx->Color.BlendColor[3] );
4046 break;
4047 case GL_BLUE_BIAS:
4048 *params = (GLint) ctx->Pixel.BlueBias;
4049 break;
4050 case GL_BLUE_BITS:
4051 *params = (GLint) ctx->Visual.blueBits;
4052 break;
4053 case GL_BLUE_SCALE:
4054 *params = (GLint) ctx->Pixel.BlueScale;
4055 break;
4056 case GL_CLIENT_ATTRIB_STACK_DEPTH:
4057 *params = (GLint) (ctx->ClientAttribStackDepth);
4058 break;
4059 case GL_CLIP_PLANE0:
4060 case GL_CLIP_PLANE1:
4061 case GL_CLIP_PLANE2:
4062 case GL_CLIP_PLANE3:
4063 case GL_CLIP_PLANE4:
4064 case GL_CLIP_PLANE5:
4065 if (ctx->Transform.ClipPlanesEnabled & (1 << (pname - GL_CLIP_PLANE0)))
4066 *params = 1;
4067 else
4068 *params = 0;
4069 break;
4070 case GL_COLOR_CLEAR_VALUE:
4071 params[0] = FLOAT_TO_INT( (ctx->Color.ClearColor[0]) );
4072 params[1] = FLOAT_TO_INT( (ctx->Color.ClearColor[1]) );
4073 params[2] = FLOAT_TO_INT( (ctx->Color.ClearColor[2]) );
4074 params[3] = FLOAT_TO_INT( (ctx->Color.ClearColor[3]) );
4075 break;
4076 case GL_COLOR_MATERIAL:
4077 *params = (GLint) ctx->Light.ColorMaterialEnabled;
4078 break;
4079 case GL_COLOR_MATERIAL_FACE:
4080 *params = (GLint) ctx->Light.ColorMaterialFace;
4081 break;
4082 case GL_COLOR_MATERIAL_PARAMETER:
4083 *params = (GLint) ctx->Light.ColorMaterialMode;
4084 break;
4085 case GL_COLOR_WRITEMASK:
4086 params[0] = ctx->Color.ColorMask[RCOMP] ? 1 : 0;
4087 params[1] = ctx->Color.ColorMask[GCOMP] ? 1 : 0;
4088 params[2] = ctx->Color.ColorMask[BCOMP] ? 1 : 0;
4089 params[3] = ctx->Color.ColorMask[ACOMP] ? 1 : 0;
4090 break;
4091 case GL_CULL_FACE:
4092 *params = (GLint) ctx->Polygon.CullFlag;
4093 break;
4094 case GL_CULL_FACE_MODE:
4095 *params = (GLint) ctx->Polygon.CullFaceMode;
4096 break;
4097 case GL_CURRENT_COLOR:
4098 FLUSH_CURRENT(ctx, 0);
4099 params[0] = FLOAT_TO_INT(ctx->Current.Attrib[VERT_ATTRIB_COLOR0][0]);
4100 params[1] = FLOAT_TO_INT(ctx->Current.Attrib[VERT_ATTRIB_COLOR0][1]);
4101 params[2] = FLOAT_TO_INT(ctx->Current.Attrib[VERT_ATTRIB_COLOR0][2]);
4102 params[3] = FLOAT_TO_INT(ctx->Current.Attrib[VERT_ATTRIB_COLOR0][3]);
4103 break;
4104 case GL_CURRENT_INDEX:
4105 FLUSH_CURRENT(ctx, 0);
4106 *params = (GLint) ctx->Current.Index;
4107 break;
4108 case GL_CURRENT_NORMAL:
4109 FLUSH_CURRENT(ctx, 0);
4110 params[0] = FLOAT_TO_INT(ctx->Current.Attrib[VERT_ATTRIB_NORMAL][0]);
4111 params[1] = FLOAT_TO_INT(ctx->Current.Attrib[VERT_ATTRIB_NORMAL][1]);
4112 params[2] = FLOAT_TO_INT(ctx->Current.Attrib[VERT_ATTRIB_NORMAL][2]);
4113 break;
4114 case GL_CURRENT_RASTER_COLOR:
4115 params[0] = FLOAT_TO_INT( ctx->Current.RasterColor[0] );
4116 params[1] = FLOAT_TO_INT( ctx->Current.RasterColor[1] );
4117 params[2] = FLOAT_TO_INT( ctx->Current.RasterColor[2] );
4118 params[3] = FLOAT_TO_INT( ctx->Current.RasterColor[3] );
4119 break;
4120 case GL_CURRENT_RASTER_DISTANCE:
4121 params[0] = (GLint) ctx->Current.RasterDistance;
4122 break;
4123 case GL_CURRENT_RASTER_INDEX:
4124 *params = (GLint) ctx->Current.RasterIndex;
4125 break;
4126 case GL_CURRENT_RASTER_POSITION:
4127 params[0] = (GLint) ctx->Current.RasterPos[0];
4128 params[1] = (GLint) ctx->Current.RasterPos[1];
4129 params[2] = (GLint) ctx->Current.RasterPos[2];
4130 params[3] = (GLint) ctx->Current.RasterPos[3];
4131 break;
4132 case GL_CURRENT_RASTER_TEXTURE_COORDS:
4133 params[0] = (GLint) ctx->Current.RasterTexCoords[texUnit][0];
4134 params[1] = (GLint) ctx->Current.RasterTexCoords[texUnit][1];
4135 params[2] = (GLint) ctx->Current.RasterTexCoords[texUnit][2];
4136 params[3] = (GLint) ctx->Current.RasterTexCoords[texUnit][3];
4137 break;
4138 case GL_CURRENT_RASTER_POSITION_VALID:
4139 *params = (GLint) ctx->Current.RasterPosValid;
4140 break;
4141 case GL_CURRENT_TEXTURE_COORDS:
4142 FLUSH_CURRENT(ctx, 0);
4143 params[0] = (GLint) ctx->Current.Attrib[VERT_ATTRIB_TEX0 + texUnit][0];
4144 params[1] = (GLint) ctx->Current.Attrib[VERT_ATTRIB_TEX0 + texUnit][1];
4145 params[2] = (GLint) ctx->Current.Attrib[VERT_ATTRIB_TEX0 + texUnit][2];
4146 params[3] = (GLint) ctx->Current.Attrib[VERT_ATTRIB_TEX0 + texUnit][3];
4147 break;
4148 case GL_DEPTH_BIAS:
4149 *params = (GLint) ctx->Pixel.DepthBias;
4150 break;
4151 case GL_DEPTH_BITS:
4152 *params = ctx->Visual.depthBits;
4153 break;
4154 case GL_DEPTH_CLEAR_VALUE:
4155 *params = (GLint) ctx->Depth.Clear;
4156 break;
4157 case GL_DEPTH_FUNC:
4158 *params = (GLint) ctx->Depth.Func;
4159 break;
4160 case GL_DEPTH_RANGE:
4161 params[0] = (GLint) ctx->Viewport.Near;
4162 params[1] = (GLint) ctx->Viewport.Far;
4163 break;
4164 case GL_DEPTH_SCALE:
4165 *params = (GLint) ctx->Pixel.DepthScale;
4166 break;
4167 case GL_DEPTH_TEST:
4168 *params = (GLint) ctx->Depth.Test;
4169 break;
4170 case GL_DEPTH_WRITEMASK:
4171 *params = (GLint) ctx->Depth.Mask;
4172 break;
4173 case GL_DITHER:
4174 *params = (GLint) ctx->Color.DitherFlag;
4175 break;
4176 case GL_DOUBLEBUFFER:
4177 *params = (GLint) ctx->Visual.doubleBufferMode;
4178 break;
4179 case GL_DRAW_BUFFER:
4180 *params = (GLint) ctx->Color.DrawBuffer;
4181 break;
4182 case GL_EDGE_FLAG:
4183 FLUSH_CURRENT(ctx, 0);
4184 *params = (GLint) ctx->Current.EdgeFlag;
4185 break;
4186 case GL_FEEDBACK_BUFFER_SIZE:
4187 *params = ctx->Feedback.BufferSize;
4188 break;
4189 case GL_FEEDBACK_BUFFER_TYPE:
4190 *params = ctx->Feedback.Type;
4191 break;
4192 case GL_FOG:
4193 *params = (GLint) ctx->Fog.Enabled;
4194 break;
4195 case GL_FOG_COLOR:
4196 params[0] = FLOAT_TO_INT( ctx->Fog.Color[0] );
4197 params[1] = FLOAT_TO_INT( ctx->Fog.Color[1] );
4198 params[2] = FLOAT_TO_INT( ctx->Fog.Color[2] );
4199 params[3] = FLOAT_TO_INT( ctx->Fog.Color[3] );
4200 break;
4201 case GL_FOG_DENSITY:
4202 *params = (GLint) ctx->Fog.Density;
4203 break;
4204 case GL_FOG_END:
4205 *params = (GLint) ctx->Fog.End;
4206 break;
4207 case GL_FOG_HINT:
4208 *params = (GLint) ctx->Hint.Fog;
4209 break;
4210 case GL_FOG_INDEX:
4211 *params = (GLint) ctx->Fog.Index;
4212 break;
4213 case GL_FOG_MODE:
4214 *params = (GLint) ctx->Fog.Mode;
4215 break;
4216 case GL_FOG_START:
4217 *params = (GLint) ctx->Fog.Start;
4218 break;
4219 case GL_FRONT_FACE:
4220 *params = (GLint) ctx->Polygon.FrontFace;
4221 break;
4222 case GL_GREEN_BIAS:
4223 *params = (GLint) ctx->Pixel.GreenBias;
4224 break;
4225 case GL_GREEN_BITS:
4226 *params = (GLint) ctx->Visual.greenBits;
4227 break;
4228 case GL_GREEN_SCALE:
4229 *params = (GLint) ctx->Pixel.GreenScale;
4230 break;
4231 case GL_INDEX_BITS:
4232 *params = (GLint) ctx->Visual.indexBits;
4233 break;
4234 case GL_INDEX_CLEAR_VALUE:
4235 *params = (GLint) ctx->Color.ClearIndex;
4236 break;
4237 case GL_INDEX_MODE:
4238 *params = ctx->Visual.rgbMode ? 0 : 1;
4239 break;
4240 case GL_INDEX_OFFSET:
4241 *params = ctx->Pixel.IndexOffset;
4242 break;
4243 case GL_INDEX_SHIFT:
4244 *params = ctx->Pixel.IndexShift;
4245 break;
4246 case GL_INDEX_WRITEMASK:
4247 *params = (GLint) ctx->Color.IndexMask;
4248 break;
4249 case GL_LIGHT0:
4250 case GL_LIGHT1:
4251 case GL_LIGHT2:
4252 case GL_LIGHT3:
4253 case GL_LIGHT4:
4254 case GL_LIGHT5:
4255 case GL_LIGHT6:
4256 case GL_LIGHT7:
4257 *params = (GLint) ctx->Light.Light[pname-GL_LIGHT0].Enabled;
4258 break;
4259 case GL_LIGHTING:
4260 *params = (GLint) ctx->Light.Enabled;
4261 break;
4262 case GL_LIGHT_MODEL_AMBIENT:
4263 params[0] = FLOAT_TO_INT( ctx->Light.Model.Ambient[0] );
4264 params[1] = FLOAT_TO_INT( ctx->Light.Model.Ambient[1] );
4265 params[2] = FLOAT_TO_INT( ctx->Light.Model.Ambient[2] );
4266 params[3] = FLOAT_TO_INT( ctx->Light.Model.Ambient[3] );
4267 break;
4268 case GL_LIGHT_MODEL_COLOR_CONTROL:
4269 params[0] = (GLint) ctx->Light.Model.ColorControl;
4270 break;
4271 case GL_LIGHT_MODEL_LOCAL_VIEWER:
4272 *params = (GLint) ctx->Light.Model.LocalViewer;
4273 break;
4274 case GL_LIGHT_MODEL_TWO_SIDE:
4275 *params = (GLint) ctx->Light.Model.TwoSide;
4276 break;
4277 case GL_LINE_SMOOTH:
4278 *params = (GLint) ctx->Line.SmoothFlag;
4279 break;
4280 case GL_LINE_SMOOTH_HINT:
4281 *params = (GLint) ctx->Hint.LineSmooth;
4282 break;
4283 case GL_LINE_STIPPLE:
4284 *params = (GLint) ctx->Line.StippleFlag;
4285 break;
4286 case GL_LINE_STIPPLE_PATTERN:
4287 *params = (GLint) ctx->Line.StipplePattern;
4288 break;
4289 case GL_LINE_STIPPLE_REPEAT:
4290 *params = (GLint) ctx->Line.StippleFactor;
4291 break;
4292 case GL_LINE_WIDTH:
4293 *params = (GLint) ctx->Line.Width;
4294 break;
4295 case GL_LINE_WIDTH_GRANULARITY:
4296 *params = (GLint) ctx->Const.LineWidthGranularity;
4297 break;
4298 case GL_LINE_WIDTH_RANGE:
4299 params[0] = (GLint) ctx->Const.MinLineWidthAA;
4300 params[1] = (GLint) ctx->Const.MaxLineWidthAA;
4301 break;
4302 case GL_ALIASED_LINE_WIDTH_RANGE:
4303 params[0] = (GLint) ctx->Const.MinLineWidth;
4304 params[1] = (GLint) ctx->Const.MaxLineWidth;
4305 break;
4306 case GL_LIST_BASE:
4307 *params = (GLint) ctx->List.ListBase;
4308 break;
4309 case GL_LIST_INDEX:
4310 *params = (GLint) ctx->CurrentListNum;
4311 break;
4312 case GL_LIST_MODE:
4313 *params = ctx->ExecuteFlag ? (GLint) GL_COMPILE_AND_EXECUTE
4314 : (GLint) GL_COMPILE;
4315 break;
4316 case GL_INDEX_LOGIC_OP:
4317 *params = (GLint) ctx->Color.IndexLogicOpEnabled;
4318 break;
4319 case GL_COLOR_LOGIC_OP:
4320 *params = (GLint) ctx->Color.ColorLogicOpEnabled;
4321 break;
4322 case GL_LOGIC_OP_MODE:
4323 *params = (GLint) ctx->Color.LogicOp;
4324 break;
4325 case GL_MAP1_COLOR_4:
4326 *params = (GLint) ctx->Eval.Map1Color4;
4327 break;
4328 case GL_MAP1_GRID_DOMAIN:
4329 params[0] = (GLint) ctx->Eval.MapGrid1u1;
4330 params[1] = (GLint) ctx->Eval.MapGrid1u2;
4331 break;
4332 case GL_MAP1_GRID_SEGMENTS:
4333 *params = (GLint) ctx->Eval.MapGrid1un;
4334 break;
4335 case GL_MAP1_INDEX:
4336 *params = (GLint) ctx->Eval.Map1Index;
4337 break;
4338 case GL_MAP1_NORMAL:
4339 *params = (GLint) ctx->Eval.Map1Normal;
4340 break;
4341 case GL_MAP1_TEXTURE_COORD_1:
4342 *params = (GLint) ctx->Eval.Map1TextureCoord1;
4343 break;
4344 case GL_MAP1_TEXTURE_COORD_2:
4345 *params = (GLint) ctx->Eval.Map1TextureCoord2;
4346 break;
4347 case GL_MAP1_TEXTURE_COORD_3:
4348 *params = (GLint) ctx->Eval.Map1TextureCoord3;
4349 break;
4350 case GL_MAP1_TEXTURE_COORD_4:
4351 *params = (GLint) ctx->Eval.Map1TextureCoord4;
4352 break;
4353 case GL_MAP1_VERTEX_3:
4354 *params = (GLint) ctx->Eval.Map1Vertex3;
4355 break;
4356 case GL_MAP1_VERTEX_4:
4357 *params = (GLint) ctx->Eval.Map1Vertex4;
4358 break;
4359 case GL_MAP2_COLOR_4:
4360 *params = (GLint) ctx->Eval.Map2Color4;
4361 break;
4362 case GL_MAP2_GRID_DOMAIN:
4363 params[0] = (GLint) ctx->Eval.MapGrid2u1;
4364 params[1] = (GLint) ctx->Eval.MapGrid2u2;
4365 params[2] = (GLint) ctx->Eval.MapGrid2v1;
4366 params[3] = (GLint) ctx->Eval.MapGrid2v2;
4367 break;
4368 case GL_MAP2_GRID_SEGMENTS:
4369 params[0] = (GLint) ctx->Eval.MapGrid2un;
4370 params[1] = (GLint) ctx->Eval.MapGrid2vn;
4371 break;
4372 case GL_MAP2_INDEX:
4373 *params = (GLint) ctx->Eval.Map2Index;
4374 break;
4375 case GL_MAP2_NORMAL:
4376 *params = (GLint) ctx->Eval.Map2Normal;
4377 break;
4378 case GL_MAP2_TEXTURE_COORD_1:
4379 *params = (GLint) ctx->Eval.Map2TextureCoord1;
4380 break;
4381 case GL_MAP2_TEXTURE_COORD_2:
4382 *params = (GLint) ctx->Eval.Map2TextureCoord2;
4383 break;
4384 case GL_MAP2_TEXTURE_COORD_3:
4385 *params = (GLint) ctx->Eval.Map2TextureCoord3;
4386 break;
4387 case GL_MAP2_TEXTURE_COORD_4:
4388 *params = (GLint) ctx->Eval.Map2TextureCoord4;
4389 break;
4390 case GL_MAP2_VERTEX_3:
4391 *params = (GLint) ctx->Eval.Map2Vertex3;
4392 break;
4393 case GL_MAP2_VERTEX_4:
4394 *params = (GLint) ctx->Eval.Map2Vertex4;
4395 break;
4396 case GL_MAP_COLOR:
4397 *params = (GLint) ctx->Pixel.MapColorFlag;
4398 break;
4399 case GL_MAP_STENCIL:
4400 *params = (GLint) ctx->Pixel.MapStencilFlag;
4401 break;
4402 case GL_MATRIX_MODE:
4403 *params = (GLint) ctx->Transform.MatrixMode;
4404 break;
4405 case GL_MAX_ATTRIB_STACK_DEPTH:
4406 *params = (GLint) MAX_ATTRIB_STACK_DEPTH;
4407 break;
4408 case GL_MAX_CLIENT_ATTRIB_STACK_DEPTH:
4409 *params = (GLint) MAX_CLIENT_ATTRIB_STACK_DEPTH;
4410 break;
4411 case GL_MAX_CLIP_PLANES:
4412 *params = (GLint) ctx->Const.MaxClipPlanes;
4413 break;
4414 case GL_MAX_ELEMENTS_VERTICES: /* GL_VERSION_1_2 */
4415 *params = (GLint) ctx->Const.MaxArrayLockSize;
4416 break;
4417 case GL_MAX_ELEMENTS_INDICES: /* GL_VERSION_1_2 */
4418 *params = (GLint) ctx->Const.MaxArrayLockSize;
4419 break;
4420 case GL_MAX_EVAL_ORDER:
4421 *params = (GLint) MAX_EVAL_ORDER;
4422 break;
4423 case GL_MAX_LIGHTS:
4424 *params = (GLint) ctx->Const.MaxLights;
4425 break;
4426 case GL_MAX_LIST_NESTING:
4427 *params = (GLint) MAX_LIST_NESTING;
4428 break;
4429 case GL_MAX_MODELVIEW_STACK_DEPTH:
4430 *params = (GLint) MAX_MODELVIEW_STACK_DEPTH;
4431 break;
4432 case GL_MAX_NAME_STACK_DEPTH:
4433 *params = (GLint) MAX_NAME_STACK_DEPTH;
4434 break;
4435 case GL_MAX_PIXEL_MAP_TABLE:
4436 *params = (GLint) MAX_PIXEL_MAP_TABLE;
4437 break;
4438 case GL_MAX_PROJECTION_STACK_DEPTH:
4439 *params = (GLint) MAX_PROJECTION_STACK_DEPTH;
4440 break;
4441 case GL_MAX_TEXTURE_SIZE:
4442 *params = (1 << (ctx->Const.MaxTextureLevels - 1));
4443 break;
4444 case GL_MAX_3D_TEXTURE_SIZE:
4445 *params = (1 << (ctx->Const.Max3DTextureLevels - 1));
4446 break;
4447 case GL_MAX_TEXTURE_STACK_DEPTH:
4448 *params = (GLint) MAX_TEXTURE_STACK_DEPTH;
4449 break;
4450 case GL_MAX_VIEWPORT_DIMS:
4451 params[0] = (GLint) MAX_WIDTH;
4452 params[1] = (GLint) MAX_HEIGHT;
4453 break;
4454 case GL_MODELVIEW_MATRIX:
4455 for (i=0;i<16;i++) {
4456 params[i] = (GLint) ctx->ModelviewMatrixStack.Top->m[i];
4457 }
4458 break;
4459 case GL_MODELVIEW_STACK_DEPTH:
4460 *params = (GLint) (ctx->ModelviewMatrixStack.Depth + 1);
4461 break;
4462 case GL_NAME_STACK_DEPTH:
4463 *params = (GLint) ctx->Select.NameStackDepth;
4464 break;
4465 case GL_NORMALIZE:
4466 *params = (GLint) ctx->Transform.Normalize;
4467 break;
4468 case GL_PACK_ALIGNMENT:
4469 *params = ctx->Pack.Alignment;
4470 break;
4471 case GL_PACK_LSB_FIRST:
4472 *params = (GLint) ctx->Pack.LsbFirst;
4473 break;
4474 case GL_PACK_ROW_LENGTH:
4475 *params = ctx->Pack.RowLength;
4476 break;
4477 case GL_PACK_SKIP_PIXELS:
4478 *params = ctx->Pack.SkipPixels;
4479 break;
4480 case GL_PACK_SKIP_ROWS:
4481 *params = ctx->Pack.SkipRows;
4482 break;
4483 case GL_PACK_SWAP_BYTES:
4484 *params = (GLint) ctx->Pack.SwapBytes;
4485 break;
4486 case GL_PACK_SKIP_IMAGES_EXT:
4487 *params = ctx->Pack.SkipImages;
4488 break;
4489 case GL_PACK_IMAGE_HEIGHT_EXT:
4490 *params = ctx->Pack.ImageHeight;
4491 break;
4492 case GL_PERSPECTIVE_CORRECTION_HINT:
4493 *params = (GLint) ctx->Hint.PerspectiveCorrection;
4494 break;
4495 case GL_PIXEL_MAP_A_TO_A_SIZE:
4496 *params = ctx->Pixel.MapAtoAsize;
4497 break;
4498 case GL_PIXEL_MAP_B_TO_B_SIZE:
4499 *params = ctx->Pixel.MapBtoBsize;
4500 break;
4501 case GL_PIXEL_MAP_G_TO_G_SIZE:
4502 *params = ctx->Pixel.MapGtoGsize;
4503 break;
4504 case GL_PIXEL_MAP_I_TO_A_SIZE:
4505 *params = ctx->Pixel.MapItoAsize;
4506 break;
4507 case GL_PIXEL_MAP_I_TO_B_SIZE:
4508 *params = ctx->Pixel.MapItoBsize;
4509 break;
4510 case GL_PIXEL_MAP_I_TO_G_SIZE:
4511 *params = ctx->Pixel.MapItoGsize;
4512 break;
4513 case GL_PIXEL_MAP_I_TO_I_SIZE:
4514 *params = ctx->Pixel.MapItoIsize;
4515 break;
4516 case GL_PIXEL_MAP_I_TO_R_SIZE:
4517 *params = ctx->Pixel.MapItoRsize;
4518 break;
4519 case GL_PIXEL_MAP_R_TO_R_SIZE:
4520 *params = ctx->Pixel.MapRtoRsize;
4521 break;
4522 case GL_PIXEL_MAP_S_TO_S_SIZE:
4523 *params = ctx->Pixel.MapStoSsize;
4524 break;
4525 case GL_POINT_SIZE:
4526 *params = (GLint) ctx->Point.Size;
4527 break;
4528 case GL_POINT_SIZE_GRANULARITY:
4529 *params = (GLint) ctx->Const.PointSizeGranularity;
4530 break;
4531 case GL_POINT_SIZE_RANGE:
4532 params[0] = (GLint) ctx->Const.MinPointSizeAA;
4533 params[1] = (GLint) ctx->Const.MaxPointSizeAA;
4534 break;
4535 case GL_ALIASED_POINT_SIZE_RANGE:
4536 params[0] = (GLint) ctx->Const.MinPointSize;
4537 params[1] = (GLint) ctx->Const.MaxPointSize;
4538 break;
4539 case GL_POINT_SMOOTH:
4540 *params = (GLint) ctx->Point.SmoothFlag;
4541 break;
4542 case GL_POINT_SMOOTH_HINT:
4543 *params = (GLint) ctx->Hint.PointSmooth;
4544 break;
4545 case GL_POINT_SIZE_MIN_EXT:
4546 *params = (GLint) (ctx->Point.MinSize);
4547 break;
4548 case GL_POINT_SIZE_MAX_EXT:
4549 *params = (GLint) (ctx->Point.MaxSize);
4550 break;
4551 case GL_POINT_FADE_THRESHOLD_SIZE_EXT:
4552 *params = (GLint) (ctx->Point.Threshold);
4553 break;
4554 case GL_DISTANCE_ATTENUATION_EXT:
4555 params[0] = (GLint) (ctx->Point.Params[0]);
4556 params[1] = (GLint) (ctx->Point.Params[1]);
4557 params[2] = (GLint) (ctx->Point.Params[2]);
4558 break;
4559 case GL_POLYGON_MODE:
4560 params[0] = (GLint) ctx->Polygon.FrontMode;
4561 params[1] = (GLint) ctx->Polygon.BackMode;
4562 break;
4563 case GL_POLYGON_OFFSET_BIAS_EXT: /* GL_EXT_polygon_offset */
4564 *params = (GLint) ctx->Polygon.OffsetUnits;
4565 break;
4566 case GL_POLYGON_OFFSET_FACTOR:
4567 *params = (GLint) ctx->Polygon.OffsetFactor;
4568 break;
4569 case GL_POLYGON_OFFSET_UNITS:
4570 *params = (GLint) ctx->Polygon.OffsetUnits;
4571 break;
4572 case GL_POLYGON_SMOOTH:
4573 *params = (GLint) ctx->Polygon.SmoothFlag;
4574 break;
4575 case GL_POLYGON_SMOOTH_HINT:
4576 *params = (GLint) ctx->Hint.PolygonSmooth;
4577 break;
4578 case GL_POLYGON_STIPPLE:
4579 *params = (GLint) ctx->Polygon.StippleFlag;
4580 break;
4581 case GL_PROJECTION_MATRIX:
4582 for (i=0;i<16;i++) {
4583 params[i] = (GLint) ctx->ProjectionMatrixStack.Top->m[i];
4584 }
4585 break;
4586 case GL_PROJECTION_STACK_DEPTH:
4587 *params = (GLint) (ctx->ProjectionMatrixStack.Depth + 1);
4588 break;
4589 case GL_READ_BUFFER:
4590 *params = (GLint) ctx->Pixel.ReadBuffer;
4591 break;
4592 case GL_RED_BIAS:
4593 *params = (GLint) ctx->Pixel.RedBias;
4594 break;
4595 case GL_RED_BITS:
4596 *params = (GLint) ctx->Visual.redBits;
4597 break;
4598 case GL_RED_SCALE:
4599 *params = (GLint) ctx->Pixel.RedScale;
4600 break;
4601 case GL_RENDER_MODE:
4602 *params = (GLint) ctx->RenderMode;
4603 break;
4604 case GL_RESCALE_NORMAL:
4605 *params = (GLint) ctx->Transform.RescaleNormals;
4606 break;
4607 case GL_RGBA_MODE:
4608 *params = (GLint) ctx->Visual.rgbMode;
4609 break;
4610 case GL_SCISSOR_BOX:
4611 params[0] = (GLint) ctx->Scissor.X;
4612 params[1] = (GLint) ctx->Scissor.Y;
4613 params[2] = (GLint) ctx->Scissor.Width;
4614 params[3] = (GLint) ctx->Scissor.Height;
4615 break;
4616 case GL_SCISSOR_TEST:
4617 *params = (GLint) ctx->Scissor.Enabled;
4618 break;
4619 case GL_SELECTION_BUFFER_SIZE:
4620 *params = (GLint) ctx->Select.BufferSize;
4621 break;
4622 case GL_SHADE_MODEL:
4623 *params = (GLint) ctx->Light.ShadeModel;
4624 break;
4625 case GL_SHARED_TEXTURE_PALETTE_EXT:
4626 *params = (GLint) ctx->Texture.SharedPalette;
4627 break;
4628 case GL_STENCIL_BITS:
4629 *params = ctx->Visual.stencilBits;
4630 break;
4631 case GL_STENCIL_CLEAR_VALUE:
4632 *params = (GLint) ctx->Stencil.Clear;
4633 break;
4634 case GL_STENCIL_FAIL:
4635 *params = (GLint) ctx->Stencil.FailFunc;
4636 break;
4637 case GL_STENCIL_FUNC:
4638 *params = (GLint) ctx->Stencil.Function;
4639 break;
4640 case GL_STENCIL_PASS_DEPTH_FAIL:
4641 *params = (GLint) ctx->Stencil.ZFailFunc;
4642 break;
4643 case GL_STENCIL_PASS_DEPTH_PASS:
4644 *params = (GLint) ctx->Stencil.ZPassFunc;
4645 break;
4646 case GL_STENCIL_REF:
4647 *params = (GLint) ctx->Stencil.Ref;
4648 break;
4649 case GL_STENCIL_TEST:
4650 *params = (GLint) ctx->Stencil.Enabled;
4651 break;
4652 case GL_STENCIL_VALUE_MASK:
4653 *params = (GLint) ctx->Stencil.ValueMask;
4654 break;
4655 case GL_STENCIL_WRITEMASK:
4656 *params = (GLint) ctx->Stencil.WriteMask;
4657 break;
4658 case GL_STEREO:
4659 *params = (GLint) ctx->Visual.stereoMode;
4660 break;
4661 case GL_SUBPIXEL_BITS:
4662 *params = ctx->Const.SubPixelBits;
4663 break;
4664 case GL_TEXTURE_1D:
4665 *params = _mesa_IsEnabled(GL_TEXTURE_1D) ? 1 : 0;
4666 break;
4667 case GL_TEXTURE_2D:
4668 *params = _mesa_IsEnabled(GL_TEXTURE_2D) ? 1 : 0;
4669 break;
4670 case GL_TEXTURE_3D:
4671 *params = _mesa_IsEnabled(GL_TEXTURE_3D) ? 1 : 0;
4672 break;
4673 case GL_TEXTURE_BINDING_1D:
4674 *params = textureUnit->Current1D->Name;
4675 break;
4676 case GL_TEXTURE_BINDING_2D:
4677 *params = textureUnit->Current2D->Name;
4678 break;
4679 case GL_TEXTURE_BINDING_3D:
4680 *params = textureUnit->Current3D->Name;
4681 break;
4682 case GL_TEXTURE_ENV_COLOR:
4683 params[0] = FLOAT_TO_INT( textureUnit->EnvColor[0] );
4684 params[1] = FLOAT_TO_INT( textureUnit->EnvColor[1] );
4685 params[2] = FLOAT_TO_INT( textureUnit->EnvColor[2] );
4686 params[3] = FLOAT_TO_INT( textureUnit->EnvColor[3] );
4687 break;
4688 case GL_TEXTURE_ENV_MODE:
4689 *params = (GLint) textureUnit->EnvMode;
4690 break;
4691 case GL_TEXTURE_GEN_S:
4692 *params = (textureUnit->TexGenEnabled & S_BIT) ? 1 : 0;
4693 break;
4694 case GL_TEXTURE_GEN_T:
4695 *params = (textureUnit->TexGenEnabled & T_BIT) ? 1 : 0;
4696 break;
4697 case GL_TEXTURE_GEN_R:
4698 *params = (textureUnit->TexGenEnabled & R_BIT) ? 1 : 0;
4699 break;
4700 case GL_TEXTURE_GEN_Q:
4701 *params = (textureUnit->TexGenEnabled & Q_BIT) ? 1 : 0;
4702 break;
4703 case GL_TEXTURE_MATRIX:
4704 for (i=0;i<16;i++) {
4705 params[i] = (GLint) ctx->TextureMatrixStack[texUnit].Top->m[i];
4706 }
4707 break;
4708 case GL_TEXTURE_STACK_DEPTH:
4709 *params = (GLint) (ctx->TextureMatrixStack[texUnit].Depth + 1);
4710 break;
4711 case GL_UNPACK_ALIGNMENT:
4712 *params = ctx->Unpack.Alignment;
4713 break;
4714 case GL_UNPACK_LSB_FIRST:
4715 *params = (GLint) ctx->Unpack.LsbFirst;
4716 break;
4717 case GL_UNPACK_ROW_LENGTH:
4718 *params = ctx->Unpack.RowLength;
4719 break;
4720 case GL_UNPACK_SKIP_PIXELS:
4721 *params = ctx->Unpack.SkipPixels;
4722 break;
4723 case GL_UNPACK_SKIP_ROWS:
4724 *params = ctx->Unpack.SkipRows;
4725 break;
4726 case GL_UNPACK_SWAP_BYTES:
4727 *params = (GLint) ctx->Unpack.SwapBytes;
4728 break;
4729 case GL_UNPACK_SKIP_IMAGES_EXT:
4730 *params = ctx->Unpack.SkipImages;
4731 break;
4732 case GL_UNPACK_IMAGE_HEIGHT_EXT:
4733 *params = ctx->Unpack.ImageHeight;
4734 break;
4735 case GL_VIEWPORT:
4736 params[0] = (GLint) ctx->Viewport.X;
4737 params[1] = (GLint) ctx->Viewport.Y;
4738 params[2] = (GLint) ctx->Viewport.Width;
4739 params[3] = (GLint) ctx->Viewport.Height;
4740 break;
4741 case GL_ZOOM_X:
4742 *params = (GLint) ctx->Pixel.ZoomX;
4743 break;
4744 case GL_ZOOM_Y:
4745 *params = (GLint) ctx->Pixel.ZoomY;
4746 break;
4747 case GL_VERTEX_ARRAY:
4748 *params = (GLint) ctx->Array.Vertex.Enabled;
4749 break;
4750 case GL_VERTEX_ARRAY_SIZE:
4751 *params = ctx->Array.Vertex.Size;
4752 break;
4753 case GL_VERTEX_ARRAY_TYPE:
4754 *params = ctx->Array.Vertex.Type;
4755 break;
4756 case GL_VERTEX_ARRAY_STRIDE:
4757 *params = ctx->Array.Vertex.Stride;
4758 break;
4759 case GL_VERTEX_ARRAY_COUNT_EXT:
4760 *params = 0;
4761 break;
4762 case GL_NORMAL_ARRAY:
4763 *params = (GLint) ctx->Array.Normal.Enabled;
4764 break;
4765 case GL_NORMAL_ARRAY_TYPE:
4766 *params = ctx->Array.Normal.Type;
4767 break;
4768 case GL_NORMAL_ARRAY_STRIDE:
4769 *params = ctx->Array.Normal.Stride;
4770 break;
4771 case GL_NORMAL_ARRAY_COUNT_EXT:
4772 *params = 0;
4773 break;
4774 case GL_COLOR_ARRAY:
4775 *params = (GLint) ctx->Array.Color.Enabled;
4776 break;
4777 case GL_COLOR_ARRAY_SIZE:
4778 *params = ctx->Array.Color.Size;
4779 break;
4780 case GL_COLOR_ARRAY_TYPE:
4781 *params = ctx->Array.Color.Type;
4782 break;
4783 case GL_COLOR_ARRAY_STRIDE:
4784 *params = ctx->Array.Color.Stride;
4785 break;
4786 case GL_COLOR_ARRAY_COUNT_EXT:
4787 *params = 0;
4788 break;
4789 case GL_INDEX_ARRAY:
4790 *params = (GLint) ctx->Array.Index.Enabled;
4791 break;
4792 case GL_INDEX_ARRAY_TYPE:
4793 *params = ctx->Array.Index.Type;
4794 break;
4795 case GL_INDEX_ARRAY_STRIDE:
4796 *params = ctx->Array.Index.Stride;
4797 break;
4798 case GL_INDEX_ARRAY_COUNT_EXT:
4799 *params = 0;
4800 break;
4801 case GL_TEXTURE_COORD_ARRAY:
4802 *params = (GLint) ctx->Array.TexCoord[texUnit].Enabled;
4803 break;
4804 case GL_TEXTURE_COORD_ARRAY_SIZE:
4805 *params = ctx->Array.TexCoord[texUnit].Size;
4806 break;
4807 case GL_TEXTURE_COORD_ARRAY_TYPE:
4808 *params = ctx->Array.TexCoord[texUnit].Type;
4809 break;
4810 case GL_TEXTURE_COORD_ARRAY_STRIDE:
4811 *params = ctx->Array.TexCoord[texUnit].Stride;
4812 break;
4813 case GL_TEXTURE_COORD_ARRAY_COUNT_EXT:
4814 *params = 0;
4815 break;
4816 case GL_EDGE_FLAG_ARRAY:
4817 *params = (GLint) ctx->Array.EdgeFlag.Enabled;
4818 break;
4819 case GL_EDGE_FLAG_ARRAY_STRIDE:
4820 *params = ctx->Array.EdgeFlag.Stride;
4821 break;
4822 case GL_EDGE_FLAG_ARRAY_COUNT_EXT:
4823 *params = 0;
4824 break;
4825
4826 /* GL_ARB_multitexture */
4827 case GL_MAX_TEXTURE_UNITS_ARB:
4828 *params = ctx->Const.MaxTextureUnits;
4829 break;
4830 case GL_ACTIVE_TEXTURE_ARB:
4831 *params = GL_TEXTURE0_ARB + ctx->Texture.CurrentUnit;
4832 break;
4833 case GL_CLIENT_ACTIVE_TEXTURE_ARB:
4834 *params = GL_TEXTURE0_ARB + ctx->Array.ActiveTexture;
4835 break;
4836
4837 /* GL_ARB_texture_cube_map */
4838 case GL_TEXTURE_CUBE_MAP_ARB:
4839 CHECK_EXTENSION_I(ARB_texture_cube_map);
4840 *params = (GLint) _mesa_IsEnabled(GL_TEXTURE_CUBE_MAP_ARB);
4841 break;
4842 case GL_TEXTURE_BINDING_CUBE_MAP_ARB:
4843 CHECK_EXTENSION_I(ARB_texture_cube_map);
4844 *params = textureUnit->CurrentCubeMap->Name;
4845 break;
4846 case GL_MAX_CUBE_MAP_TEXTURE_SIZE_ARB:
4847 CHECK_EXTENSION_I(ARB_texture_cube_map);
4848 *params = (1 << (ctx->Const.MaxCubeTextureLevels - 1));
4849 break;
4850
4851 /* GL_ARB_texture_compression */
4852 case GL_TEXTURE_COMPRESSION_HINT_ARB:
4853 CHECK_EXTENSION_I(ARB_texture_compression);
4854 *params = (GLint) ctx->Hint.TextureCompression;
4855 break;
4856 case GL_NUM_COMPRESSED_TEXTURE_FORMATS_ARB:
4857 CHECK_EXTENSION_I(ARB_texture_compression);
4858 *params = (GLint) ctx->Const.NumCompressedTextureFormats;
4859 break;
4860 case GL_COMPRESSED_TEXTURE_FORMATS_ARB:
4861 CHECK_EXTENSION_I(ARB_texture_compression);
4862 {
4863 GLuint i;
4864 for (i = 0; i < ctx->Const.NumCompressedTextureFormats; i++)
4865 params[i] = (GLint) ctx->Const.CompressedTextureFormats[i];
4866 }
4867 break;
4868
4869 /* GL_EXT_compiled_vertex_array */
4870 case GL_ARRAY_ELEMENT_LOCK_FIRST_EXT:
4871 CHECK_EXTENSION_I(EXT_compiled_vertex_array);
4872 *params = ctx->Array.LockFirst;
4873 break;
4874 case GL_ARRAY_ELEMENT_LOCK_COUNT_EXT:
4875 CHECK_EXTENSION_I(EXT_compiled_vertex_array);
4876 *params = ctx->Array.LockCount;
4877 break;
4878
4879 /* GL_ARB_transpose_matrix */
4880 case GL_TRANSPOSE_COLOR_MATRIX_ARB:
4881 {
4882 GLfloat tm[16];
4883 GLuint i;
4884 _math_transposef(tm, ctx->ColorMatrixStack.Top->m);
4885 for (i=0;i<16;i++) {
4886 params[i] = (GLint) tm[i];
4887 }
4888 }
4889 break;
4890 case GL_TRANSPOSE_MODELVIEW_MATRIX_ARB:
4891 {
4892 GLfloat tm[16];
4893 GLuint i;
4894 _math_transposef(tm, ctx->ModelviewMatrixStack.Top->m);
4895 for (i=0;i<16;i++) {
4896 params[i] = (GLint) tm[i];
4897 }
4898 }
4899 break;
4900 case GL_TRANSPOSE_PROJECTION_MATRIX_ARB:
4901 {
4902 GLfloat tm[16];
4903 GLuint i;
4904 _math_transposef(tm, ctx->ProjectionMatrixStack.Top->m);
4905 for (i=0;i<16;i++) {
4906 params[i] = (GLint) tm[i];
4907 }
4908 }
4909 break;
4910 case GL_TRANSPOSE_TEXTURE_MATRIX_ARB:
4911 {
4912 GLfloat tm[16];
4913 GLuint i;
4914 _math_transposef(tm, ctx->TextureMatrixStack[texUnit].Top->m);
4915 for (i=0;i<16;i++) {
4916 params[i] = (GLint) tm[i];
4917 }
4918 }
4919 break;
4920
4921 /* GL_HP_occlusion_test */
4922 case GL_OCCLUSION_TEST_HP:
4923 CHECK_EXTENSION_I(HP_occlusion_test);
4924 *params = (GLint) ctx->Depth.OcclusionTest;
4925 break;
4926 case GL_OCCLUSION_TEST_RESULT_HP:
4927 CHECK_EXTENSION_I(HP_occlusion_test);
4928 if (ctx->Depth.OcclusionTest)
4929 *params = (GLint) ctx->OcclusionResult;
4930 else
4931 *params = (GLint) ctx->OcclusionResultSaved;
4932 /* reset flag now */
4933 ctx->OcclusionResult = GL_FALSE;
4934 ctx->OcclusionResultSaved = GL_FALSE;
4935 break;
4936
4937 /* GL_SGIS_pixel_texture */
4938 case GL_PIXEL_TEXTURE_SGIS:
4939 CHECK_EXTENSION_I(SGIS_pixel_texture);
4940 *params = (GLint) ctx->Pixel.PixelTextureEnabled;
4941 break;
4942
4943 /* GL_SGIX_pixel_texture */
4944 case GL_PIXEL_TEX_GEN_SGIX:
4945 CHECK_EXTENSION_I(SGIX_pixel_texture);
4946 *params = (GLint) ctx->Pixel.PixelTextureEnabled;
4947 break;
4948 case GL_PIXEL_TEX_GEN_MODE_SGIX:
4949 CHECK_EXTENSION_I(SGIX_pixel_texture);
4950 *params = (GLint) pixel_texgen_mode(ctx);
4951 break;
4952
4953 /* GL_SGI_color_matrix (also in 1.2 imaging) */
4954 case GL_COLOR_MATRIX_SGI:
4955 CHECK_EXTENSION_I(SGI_color_matrix);
4956 for (i=0;i<16;i++) {
4957 params[i] = (GLint) ctx->ColorMatrixStack.Top->m[i];
4958 }
4959 break;
4960 case GL_COLOR_MATRIX_STACK_DEPTH_SGI:
4961 CHECK_EXTENSION_I(SGI_color_matrix);
4962 *params = ctx->ColorMatrixStack.Depth + 1;
4963 break;
4964 case GL_MAX_COLOR_MATRIX_STACK_DEPTH_SGI:
4965 CHECK_EXTENSION_I(SGI_color_matrix);
4966 *params = MAX_COLOR_STACK_DEPTH;
4967 break;
4968 case GL_POST_COLOR_MATRIX_RED_SCALE_SGI:
4969 CHECK_EXTENSION_I(SGI_color_matrix);
4970 *params = (GLint) ctx->Pixel.PostColorMatrixScale[0];
4971 break;
4972 case GL_POST_COLOR_MATRIX_GREEN_SCALE_SGI:
4973 CHECK_EXTENSION_I(SGI_color_matrix);
4974 *params = (GLint) ctx->Pixel.PostColorMatrixScale[1];
4975 break;
4976 case GL_POST_COLOR_MATRIX_BLUE_SCALE_SGI:
4977 CHECK_EXTENSION_I(SGI_color_matrix);
4978 *params = (GLint) ctx->Pixel.PostColorMatrixScale[2];
4979 break;
4980 case GL_POST_COLOR_MATRIX_ALPHA_SCALE_SGI:
4981 CHECK_EXTENSION_I(SGI_color_matrix);
4982 *params = (GLint) ctx->Pixel.PostColorMatrixScale[3];
4983 break;
4984 case GL_POST_COLOR_MATRIX_RED_BIAS_SGI:
4985 CHECK_EXTENSION_I(SGI_color_matrix);
4986 *params = (GLint) ctx->Pixel.PostColorMatrixBias[0];
4987 break;
4988 case GL_POST_COLOR_MATRIX_GREEN_BIAS_SGI:
4989 CHECK_EXTENSION_I(SGI_color_matrix);
4990 *params = (GLint) ctx->Pixel.PostColorMatrixBias[1];
4991 break;
4992 case GL_POST_COLOR_MATRIX_BLUE_BIAS_SGI:
4993 CHECK_EXTENSION_I(SGI_color_matrix);
4994 *params = (GLint) ctx->Pixel.PostColorMatrixBias[2];
4995 break;
4996 case GL_POST_COLOR_MATRIX_ALPHA_BIAS_SGI:
4997 CHECK_EXTENSION_I(SGI_color_matrix);
4998 *params = (GLint) ctx->Pixel.PostColorMatrixBias[3];
4999 break;
5000
5001 /* GL_EXT_convolution (also in 1.2 imaging) */
5002 case GL_CONVOLUTION_1D_EXT:
5003 CHECK_EXTENSION_I(EXT_convolution);
5004 *params = (GLint) ctx->Pixel.Convolution1DEnabled;
5005 break;
5006 case GL_CONVOLUTION_2D:
5007 CHECK_EXTENSION_I(EXT_convolution);
5008 *params = (GLint) ctx->Pixel.Convolution2DEnabled;
5009 break;
5010 case GL_SEPARABLE_2D:
5011 CHECK_EXTENSION_I(EXT_convolution);
5012 *params = (GLint) ctx->Pixel.Separable2DEnabled;
5013 break;
5014 case GL_MAX_CONVOLUTION_WIDTH:
5015 CHECK_EXTENSION_I(EXT_convolution);
5016 *params = ctx->Const.MaxConvolutionWidth;
5017 break;
5018 case GL_MAX_CONVOLUTION_HEIGHT:
5019 CHECK_EXTENSION_I(EXT_convolution);
5020 *params = ctx->Const.MaxConvolutionHeight;
5021 break;
5022 case GL_POST_CONVOLUTION_RED_SCALE_EXT:
5023 CHECK_EXTENSION_I(EXT_convolution);
5024 *params = (GLint) ctx->Pixel.PostConvolutionScale[0];
5025 break;
5026 case GL_POST_CONVOLUTION_GREEN_SCALE_EXT:
5027 CHECK_EXTENSION_I(EXT_convolution);
5028 *params = (GLint) ctx->Pixel.PostConvolutionScale[1];
5029 break;
5030 case GL_POST_CONVOLUTION_BLUE_SCALE_EXT:
5031 CHECK_EXTENSION_I(EXT_convolution);
5032 *params = (GLint) ctx->Pixel.PostConvolutionScale[2];
5033 break;
5034 case GL_POST_CONVOLUTION_ALPHA_SCALE_EXT:
5035 CHECK_EXTENSION_I(EXT_convolution);
5036 *params = (GLint) ctx->Pixel.PostConvolutionScale[3];
5037 break;
5038 case GL_POST_CONVOLUTION_RED_BIAS_EXT:
5039 CHECK_EXTENSION_I(EXT_convolution);
5040 *params = (GLint) ctx->Pixel.PostConvolutionBias[0];
5041 break;
5042 case GL_POST_CONVOLUTION_GREEN_BIAS_EXT:
5043 CHECK_EXTENSION_I(EXT_convolution);
5044 *params = (GLint) ctx->Pixel.PostConvolutionBias[1];
5045 break;
5046 case GL_POST_CONVOLUTION_BLUE_BIAS_EXT:
5047 CHECK_EXTENSION_I(EXT_convolution);
5048 *params = (GLint) ctx->Pixel.PostConvolutionBias[2];
5049 break;
5050 case GL_POST_CONVOLUTION_ALPHA_BIAS_EXT:
5051 CHECK_EXTENSION_I(EXT_convolution);
5052 *params = (GLint) ctx->Pixel.PostConvolutionBias[2];
5053 break;
5054
5055 /* GL_EXT_histogram (also in 1.2 imaging) */
5056 case GL_HISTOGRAM:
5057 CHECK_EXTENSION_I(EXT_histogram);
5058 *params = (GLint) ctx->Pixel.HistogramEnabled;
5059 break;
5060 case GL_MINMAX:
5061 CHECK_EXTENSION_I(EXT_histogram);
5062 *params = (GLint) ctx->Pixel.MinMaxEnabled;
5063 break;
5064
5065 /* GL_SGI_color_table (also in 1.2 imaging */
5066 case GL_COLOR_TABLE_SGI:
5067 CHECK_EXTENSION_I(SGI_color_table);
5068 *params = (GLint) ctx->Pixel.ColorTableEnabled;
5069 break;
5070 case GL_POST_CONVOLUTION_COLOR_TABLE_SGI:
5071 CHECK_EXTENSION_I(SGI_color_table);
5072 *params = (GLint) ctx->Pixel.PostConvolutionColorTableEnabled;
5073 break;
5074 case GL_POST_COLOR_MATRIX_COLOR_TABLE_SGI:
5075 CHECK_EXTENSION_I(SGI_color_table);
5076 *params = (GLint) ctx->Pixel.PostColorMatrixColorTableEnabled;
5077 break;
5078
5079
5080 /* GL_EXT_secondary_color */
5081 case GL_COLOR_SUM_EXT:
5082 CHECK_EXTENSION_I(EXT_secondary_color);
5083 *params = (GLint) ctx->Fog.ColorSumEnabled;
5084 break;
5085 case GL_CURRENT_SECONDARY_COLOR_EXT:
5086 CHECK_EXTENSION_I(EXT_secondary_color);
5087 FLUSH_CURRENT(ctx, 0);
5088 params[0] = FLOAT_TO_INT( (ctx->Current.Attrib[VERT_ATTRIB_COLOR1][0]) );
5089 params[1] = FLOAT_TO_INT( (ctx->Current.Attrib[VERT_ATTRIB_COLOR1][1]) );
5090 params[2] = FLOAT_TO_INT( (ctx->Current.Attrib[VERT_ATTRIB_COLOR1][2]) );
5091 break;
5092 case GL_SECONDARY_COLOR_ARRAY_EXT:
5093 CHECK_EXTENSION_I(EXT_secondary_color);
5094 *params = (GLint) ctx->Array.SecondaryColor.Enabled;
5095 break;
5096 case GL_SECONDARY_COLOR_ARRAY_TYPE_EXT:
5097 CHECK_EXTENSION_I(EXT_secondary_color);
5098 *params = (GLint) ctx->Array.SecondaryColor.Type;
5099 break;
5100 case GL_SECONDARY_COLOR_ARRAY_STRIDE_EXT:
5101 CHECK_EXTENSION_I(EXT_secondary_color);
5102 *params = (GLint) ctx->Array.SecondaryColor.Stride;
5103 break;
5104 case GL_SECONDARY_COLOR_ARRAY_SIZE_EXT:
5105 CHECK_EXTENSION_I(EXT_secondary_color);
5106 *params = (GLint) ctx->Array.SecondaryColor.Stride;
5107 break;
5108
5109 /* GL_EXT_fog_coord */
5110 case GL_CURRENT_FOG_COORDINATE_EXT:
5111 CHECK_EXTENSION_I(EXT_fog_coord);
5112 FLUSH_CURRENT(ctx, 0);
5113 *params = (GLint) ctx->Current.Attrib[VERT_ATTRIB_FOG][0];
5114 break;
5115 case GL_FOG_COORDINATE_ARRAY_EXT:
5116 CHECK_EXTENSION_I(EXT_fog_coord);
5117 *params = (GLint) ctx->Array.FogCoord.Enabled;
5118 break;
5119 case GL_FOG_COORDINATE_ARRAY_TYPE_EXT:
5120 CHECK_EXTENSION_I(EXT_fog_coord);
5121 *params = (GLint) ctx->Array.FogCoord.Type;
5122 break;
5123 case GL_FOG_COORDINATE_ARRAY_STRIDE_EXT:
5124 CHECK_EXTENSION_I(EXT_fog_coord);
5125 *params = (GLint) ctx->Array.FogCoord.Stride;
5126 break;
5127
5128 /* GL_EXT_texture_lod_bias */
5129 case GL_MAX_TEXTURE_LOD_BIAS_EXT:
5130 *params = (GLint) ctx->Const.MaxTextureLodBias;
5131 break;
5132
5133 /* GL_EXT_texture_filter_anisotropic */
5134 case GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT:
5135 CHECK_EXTENSION_I(EXT_texture_filter_anisotropic);
5136 *params = (GLint) ctx->Const.MaxTextureMaxAnisotropy;
5137 break;
5138
5139 /* GL_ARB_multisample */
5140 case GL_MULTISAMPLE_ARB:
5141 CHECK_EXTENSION_I(ARB_multisample);
5142 *params = (GLint) ctx->Multisample.Enabled;
5143 break;
5144 case GL_SAMPLE_ALPHA_TO_COVERAGE_ARB:
5145 CHECK_EXTENSION_I(ARB_multisample);
5146 *params = (GLint) ctx->Multisample.SampleAlphaToCoverage;
5147 break;
5148 case GL_SAMPLE_ALPHA_TO_ONE_ARB:
5149 CHECK_EXTENSION_I(ARB_multisample);
5150 *params = (GLint) ctx->Multisample.SampleAlphaToOne;
5151 break;
5152 case GL_SAMPLE_COVERAGE_ARB:
5153 CHECK_EXTENSION_I(ARB_multisample);
5154 *params = (GLint) ctx->Multisample.SampleCoverage;
5155 break;
5156 case GL_SAMPLE_COVERAGE_VALUE_ARB:
5157 CHECK_EXTENSION_I(ARB_multisample);
5158 *params = (GLint) ctx->Multisample.SampleCoverageValue;
5159 break;
5160 case GL_SAMPLE_COVERAGE_INVERT_ARB:
5161 CHECK_EXTENSION_I(ARB_multisample);
5162 *params = (GLint) ctx->Multisample.SampleCoverageInvert;
5163 break;
5164 case GL_SAMPLE_BUFFERS_ARB:
5165 CHECK_EXTENSION_I(ARB_multisample);
5166 *params = 0; /* XXX fix someday */
5167 break;
5168 case GL_SAMPLES_ARB:
5169 CHECK_EXTENSION_I(ARB_multisample);
5170 *params = 0; /* XXX fix someday */
5171 break;
5172
5173 /* GL_IBM_rasterpos_clip */
5174 case GL_RASTER_POSITION_UNCLIPPED_IBM:
5175 CHECK_EXTENSION_I(IBM_rasterpos_clip);
5176 *params = (GLint) ctx->Transform.RasterPositionUnclipped;
5177 break;
5178
5179 /* GL_NV_point_sprite */
5180 case GL_POINT_SPRITE_NV:
5181 CHECK_EXTENSION_B(NV_point_sprite);
5182 *params = (GLint) ctx->Point.PointSprite;
5183 break;
5184 case GL_POINT_SPRITE_R_MODE_NV:
5185 CHECK_EXTENSION_B(NV_point_sprite);
5186 *params = (GLint) ctx->Point.SpriteRMode;
5187 break;
5188
5189 /* GL_SGIS_generate_mipmap */
5190 case GL_GENERATE_MIPMAP_HINT_SGIS:
5191 CHECK_EXTENSION_I(SGIS_generate_mipmap);
5192 *params = (GLint) ctx->Hint.GenerateMipmap;
5193 break;
5194
5195 /* GL_NV_vertex_program */
5196 /* XXX to do */
5197
5198 /* GL_NV_texture_rectangle */
5199 case GL_TEXTURE_RECTANGLE_NV:
5200 CHECK_EXTENSION_I(NV_texture_rectangle);
5201 *params = (GLint) _mesa_IsEnabled(GL_TEXTURE_RECTANGLE_NV);
5202 break;
5203 case GL_TEXTURE_BINDING_RECTANGLE_NV:
5204 CHECK_EXTENSION_I(NV_texture_rectangle);
5205 *params = (GLint) textureUnit->CurrentRect->Name;
5206 break;
5207 case GL_MAX_RECTANGLE_TEXTURE_SIZE_NV:
5208 CHECK_EXTENSION_I(NV_texture_rectangle);
5209 *params = (GLint) ctx->Const.MaxTextureRectSize;
5210 break;
5211
5212 default:
5213 _mesa_error( ctx, GL_INVALID_ENUM, "glGetIntegerv" );
5214 }
5215 }
5216
5217
5218
5219 void
5220 _mesa_GetPointerv( GLenum pname, GLvoid **params )
5221 {
5222 GET_CURRENT_CONTEXT(ctx);
5223 GLuint texUnit = ctx->Texture.CurrentUnit;
5224 ASSERT_OUTSIDE_BEGIN_END(ctx);
5225
5226 if (!params)
5227 return;
5228
5229 if (MESA_VERBOSE & VERBOSE_API)
5230 _mesa_debug(ctx, "glGetPointerv %s\n", _mesa_lookup_enum_by_nr(pname));
5231
5232 if (ctx->Driver.GetPointerv
5233 && (*ctx->Driver.GetPointerv)(ctx, pname, params))
5234 return;
5235
5236 switch (pname) {
5237 case GL_VERTEX_ARRAY_POINTER:
5238 *params = ctx->Array.Vertex.Ptr;
5239 break;
5240 case GL_NORMAL_ARRAY_POINTER:
5241 *params = ctx->Array.Normal.Ptr;
5242 break;
5243 case GL_COLOR_ARRAY_POINTER:
5244 *params = ctx->Array.Color.Ptr;
5245 break;
5246 case GL_SECONDARY_COLOR_ARRAY_POINTER_EXT:
5247 *params = ctx->Array.SecondaryColor.Ptr;
5248 break;
5249 case GL_FOG_COORDINATE_ARRAY_POINTER_EXT:
5250 *params = ctx->Array.FogCoord.Ptr;
5251 break;
5252 case GL_INDEX_ARRAY_POINTER:
5253 *params = ctx->Array.Index.Ptr;
5254 break;
5255 case GL_TEXTURE_COORD_ARRAY_POINTER:
5256 *params = ctx->Array.TexCoord[texUnit].Ptr;
5257 break;
5258 case GL_EDGE_FLAG_ARRAY_POINTER:
5259 *params = ctx->Array.EdgeFlag.Ptr;
5260 break;
5261 case GL_FEEDBACK_BUFFER_POINTER:
5262 *params = ctx->Feedback.Buffer;
5263 break;
5264 case GL_SELECTION_BUFFER_POINTER:
5265 *params = ctx->Select.Buffer;
5266 break;
5267 default:
5268 _mesa_error( ctx, GL_INVALID_ENUM, "glGetPointerv" );
5269 return;
5270 }
5271 }
5272
5273
5274
5275 const GLubyte *
5276 _mesa_GetString( GLenum name )
5277 {
5278 GET_CURRENT_CONTEXT(ctx);
5279 static const char *vendor = "Brian Paul";
5280 static const char *renderer = "Mesa";
5281 static const char *version_1_2 = "1.2 Mesa 4.1 beta";
5282 static const char *version_1_3 = "1.3 Mesa 4.1 beta";
5283
5284 ASSERT_OUTSIDE_BEGIN_END_WITH_RETVAL(ctx, 0);
5285
5286 /* this is a required driver function */
5287 assert(ctx->Driver.GetString);
5288 {
5289 const GLubyte *str = (*ctx->Driver.GetString)(ctx, name);
5290 if (str)
5291 return str;
5292
5293 switch (name) {
5294 case GL_VENDOR:
5295 return (const GLubyte *) vendor;
5296 case GL_RENDERER:
5297 return (const GLubyte *) renderer;
5298 case GL_VERSION:
5299 if (ctx->Extensions.ARB_multitexture &&
5300 ctx->Extensions.ARB_multisample &&
5301 ctx->Extensions.ARB_texture_border_clamp &&
5302 ctx->Extensions.ARB_texture_compression &&
5303 ctx->Extensions.EXT_texture_env_add &&
5304 ctx->Extensions.ARB_texture_env_combine &&
5305 ctx->Extensions.ARB_texture_env_dot3)
5306 return (const GLubyte *) version_1_3;
5307 else
5308 return (const GLubyte *) version_1_2;
5309 case GL_EXTENSIONS:
5310 return (const GLubyte *) _mesa_extensions_get_string(ctx);
5311 default:
5312 _mesa_error( ctx, GL_INVALID_ENUM, "glGetString" );
5313 return (const GLubyte *) 0;
5314 }
5315 }
5316 }
5317
5318
5319 /*
5320 * Execute a glGetError command
5321 */
5322 GLenum
5323 _mesa_GetError( void )
5324 {
5325 GET_CURRENT_CONTEXT(ctx);
5326 GLenum e = ctx->ErrorValue;
5327 ASSERT_OUTSIDE_BEGIN_END_WITH_RETVAL(ctx, 0);
5328
5329 if (MESA_VERBOSE & VERBOSE_API)
5330 _mesa_debug(ctx, "glGetError <-- %s\n", _mesa_lookup_enum_by_nr(e));
5331
5332 ctx->ErrorValue = (GLenum) GL_NO_ERROR;
5333 return e;
5334 }