projects / mesa.git / blob
? search:


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