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