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