projects / mesa.git / blob
? search:


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