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