projects / mesa.git / blob
? search:


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