projects / mesa.git / blob
? search:


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