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