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