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