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