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