projects / mesa.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
Comment out __FUNCTION__ usage.
[mesa.git] / src / mesa / main / get.c
1 /* $Id: get.c,v 1.59 2001/05/03 23:55:38 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 default:
1284 _mesa_error( ctx, GL_INVALID_ENUM, "glGetBooleanv" );
1285 }
1286 }
1287
1288
1289
1290
1291 void
1292 _mesa_GetDoublev( GLenum pname, GLdouble *params )
1293 {
1294 GET_CURRENT_CONTEXT(ctx);
1295 GLuint i;
1296 GLuint texUnit = ctx->Texture.CurrentUnit;
1297 GLuint texTransformUnit = ctx->Texture.CurrentTransformUnit;
1298 const struct gl_texture_unit *textureUnit = &ctx->Texture.Unit[texUnit];
1299 ASSERT_OUTSIDE_BEGIN_END(ctx);
1300
1301 if (!params)
1302 return;
1303
1304 /* We need this in order to get correct results for
1305 * GL_OCCLUSION_TEST_RESULT_HP. There might be other important cases.
1306 */
1307 FLUSH_VERTICES(ctx, 0);
1308
1309 if (MESA_VERBOSE & VERBOSE_API)
1310 fprintf(stderr, "glGetDoublev %s\n", _mesa_lookup_enum_by_nr(pname));
1311
1312 if (ctx->Driver.GetDoublev && (*ctx->Driver.GetDoublev)(ctx, pname, params))
1313 return;
1314
1315 switch (pname) {
1316 case GL_ACCUM_RED_BITS:
1317 *params = (GLdouble) ctx->Visual.accumRedBits;
1318 break;
1319 case GL_ACCUM_GREEN_BITS:
1320 *params = (GLdouble) ctx->Visual.accumGreenBits;
1321 break;
1322 case GL_ACCUM_BLUE_BITS:
1323 *params = (GLdouble) ctx->Visual.accumBlueBits;
1324 break;
1325 case GL_ACCUM_ALPHA_BITS:
1326 *params = (GLdouble) ctx->Visual.accumAlphaBits;
1327 break;
1328 case GL_ACCUM_CLEAR_VALUE:
1329 params[0] = (GLdouble) ctx->Accum.ClearColor[0];
1330 params[1] = (GLdouble) ctx->Accum.ClearColor[1];
1331 params[2] = (GLdouble) ctx->Accum.ClearColor[2];
1332 params[3] = (GLdouble) ctx->Accum.ClearColor[3];
1333 break;
1334 case GL_ALPHA_BIAS:
1335 *params = (GLdouble) ctx->Pixel.AlphaBias;
1336 break;
1337 case GL_ALPHA_BITS:
1338 *params = (GLdouble) ctx->Visual.alphaBits;
1339 break;
1340 case GL_ALPHA_SCALE:
1341 *params = (GLdouble) ctx->Pixel.AlphaScale;
1342 break;
1343 case GL_ALPHA_TEST:
1344 *params = (GLdouble) ctx->Color.AlphaEnabled;
1345 break;
1346 case GL_ALPHA_TEST_FUNC:
1347 *params = ENUM_TO_DOUBLE(ctx->Color.AlphaFunc);
1348 break;
1349 case GL_ALPHA_TEST_REF:
1350 *params = (GLdouble) ctx->Color.AlphaRef / CHAN_MAXF;
1351 break;
1352 case GL_ATTRIB_STACK_DEPTH:
1353 *params = (GLdouble ) (ctx->AttribStackDepth);
1354 break;
1355 case GL_AUTO_NORMAL:
1356 *params = (GLdouble) ctx->Eval.AutoNormal;
1357 break;
1358 case GL_AUX_BUFFERS:
1359 *params = (GLdouble) ctx->Const.NumAuxBuffers;
1360 break;
1361 case GL_BLEND:
1362 *params = (GLdouble) ctx->Color.BlendEnabled;
1363 break;
1364 case GL_BLEND_DST:
1365 *params = ENUM_TO_DOUBLE(ctx->Color.BlendDstRGB);
1366 break;
1367 case GL_BLEND_SRC:
1368 *params = ENUM_TO_DOUBLE(ctx->Color.BlendSrcRGB);
1369 break;
1370 case GL_BLEND_SRC_RGB_EXT:
1371 *params = ENUM_TO_DOUBLE(ctx->Color.BlendSrcRGB);
1372 break;
1373 case GL_BLEND_DST_RGB_EXT:
1374 *params = ENUM_TO_DOUBLE(ctx->Color.BlendDstRGB);
1375 break;
1376 case GL_BLEND_SRC_ALPHA_EXT:
1377 *params = ENUM_TO_DOUBLE(ctx->Color.BlendSrcA);
1378 break;
1379 case GL_BLEND_DST_ALPHA_EXT:
1380 *params = ENUM_TO_DOUBLE(ctx->Color.BlendDstA);
1381 break;
1382 case GL_BLEND_EQUATION_EXT:
1383 *params = ENUM_TO_DOUBLE(ctx->Color.BlendEquation);
1384 break;
1385 case GL_BLEND_COLOR_EXT:
1386 params[0] = (GLdouble) ctx->Color.BlendColor[0];
1387 params[1] = (GLdouble) ctx->Color.BlendColor[1];
1388 params[2] = (GLdouble) ctx->Color.BlendColor[2];
1389 params[3] = (GLdouble) ctx->Color.BlendColor[3];
1390 break;
1391 case GL_BLUE_BIAS:
1392 *params = (GLdouble) ctx->Pixel.BlueBias;
1393 break;
1394 case GL_BLUE_BITS:
1395 *params = (GLdouble) ctx->Visual.blueBits;
1396 break;
1397 case GL_BLUE_SCALE:
1398 *params = (GLdouble) ctx->Pixel.BlueScale;
1399 break;
1400 case GL_CLIENT_ATTRIB_STACK_DEPTH:
1401 *params = (GLdouble) (ctx->ClientAttribStackDepth);
1402 break;
1403 case GL_CLIP_PLANE0:
1404 case GL_CLIP_PLANE1:
1405 case GL_CLIP_PLANE2:
1406 case GL_CLIP_PLANE3:
1407 case GL_CLIP_PLANE4:
1408 case GL_CLIP_PLANE5:
1409 *params = (GLdouble) ctx->Transform.ClipEnabled[pname-GL_CLIP_PLANE0];
1410 break;
1411 case GL_COLOR_CLEAR_VALUE:
1412 params[0] = (GLdouble) CHAN_TO_FLOAT(ctx->Color.ClearColor[0]);
1413 params[1] = (GLdouble) CHAN_TO_FLOAT(ctx->Color.ClearColor[1]);
1414 params[2] = (GLdouble) CHAN_TO_FLOAT(ctx->Color.ClearColor[2]);
1415 params[3] = (GLdouble) CHAN_TO_FLOAT(ctx->Color.ClearColor[3]);
1416 break;
1417 case GL_COLOR_MATERIAL:
1418 *params = (GLdouble) ctx->Light.ColorMaterialEnabled;
1419 break;
1420 case GL_COLOR_MATERIAL_FACE:
1421 *params = ENUM_TO_DOUBLE(ctx->Light.ColorMaterialFace);
1422 break;
1423 case GL_COLOR_MATERIAL_PARAMETER:
1424 *params = ENUM_TO_DOUBLE(ctx->Light.ColorMaterialMode);
1425 break;
1426 case GL_COLOR_WRITEMASK:
1427 params[0] = ctx->Color.ColorMask[RCOMP] ? 1.0 : 0.0;
1428 params[1] = ctx->Color.ColorMask[GCOMP] ? 1.0 : 0.0;
1429 params[2] = ctx->Color.ColorMask[BCOMP] ? 1.0 : 0.0;
1430 params[3] = ctx->Color.ColorMask[ACOMP] ? 1.0 : 0.0;
1431 break;
1432 case GL_CULL_FACE:
1433 *params = (GLdouble) ctx->Polygon.CullFlag;
1434 break;
1435 case GL_CULL_FACE_MODE:
1436 *params = ENUM_TO_DOUBLE(ctx->Polygon.CullFaceMode);
1437 break;
1438 case GL_CURRENT_COLOR:
1439 FLUSH_CURRENT(ctx, 0);
1440 params[0] = (ctx->Current.Color[0]);
1441 params[1] = (ctx->Current.Color[1]);
1442 params[2] = (ctx->Current.Color[2]);
1443 params[3] = (ctx->Current.Color[3]);
1444 break;
1445 case GL_CURRENT_INDEX:
1446 FLUSH_CURRENT(ctx, 0);
1447 *params = (GLdouble) ctx->Current.Index;
1448 break;
1449 case GL_CURRENT_NORMAL:
1450 FLUSH_CURRENT(ctx, 0);
1451 params[0] = (GLdouble) ctx->Current.Normal[0];
1452 params[1] = (GLdouble) ctx->Current.Normal[1];
1453 params[2] = (GLdouble) ctx->Current.Normal[2];
1454 break;
1455 case GL_CURRENT_RASTER_COLOR:
1456 params[0] = (GLdouble) ctx->Current.RasterColor[0];
1457 params[1] = (GLdouble) ctx->Current.RasterColor[1];
1458 params[2] = (GLdouble) ctx->Current.RasterColor[2];
1459 params[3] = (GLdouble) ctx->Current.RasterColor[3];
1460 break;
1461 case GL_CURRENT_RASTER_DISTANCE:
1462 params[0] = (GLdouble) ctx->Current.RasterDistance;
1463 break;
1464 case GL_CURRENT_RASTER_INDEX:
1465 *params = (GLdouble) ctx->Current.RasterIndex;
1466 break;
1467 case GL_CURRENT_RASTER_POSITION:
1468 params[0] = (GLdouble) ctx->Current.RasterPos[0];
1469 params[1] = (GLdouble) ctx->Current.RasterPos[1];
1470 params[2] = (GLdouble) ctx->Current.RasterPos[2];
1471 params[3] = (GLdouble) ctx->Current.RasterPos[3];
1472 break;
1473 case GL_CURRENT_RASTER_TEXTURE_COORDS:
1474 params[0] = (GLdouble) ctx->Current.RasterMultiTexCoord[texTransformUnit][0];
1475 params[1] = (GLdouble) ctx->Current.RasterMultiTexCoord[texTransformUnit][1];
1476 params[2] = (GLdouble) ctx->Current.RasterMultiTexCoord[texTransformUnit][2];
1477 params[3] = (GLdouble) ctx->Current.RasterMultiTexCoord[texTransformUnit][3];
1478 break;
1479 case GL_CURRENT_RASTER_POSITION_VALID:
1480 *params = (GLdouble) ctx->Current.RasterPosValid;
1481 break;
1482 case GL_CURRENT_TEXTURE_COORDS:
1483 FLUSH_CURRENT(ctx, 0);
1484 params[0] = (GLdouble) ctx->Current.Texcoord[texTransformUnit][0];
1485 params[1] = (GLdouble) ctx->Current.Texcoord[texTransformUnit][1];
1486 params[2] = (GLdouble) ctx->Current.Texcoord[texTransformUnit][2];
1487 params[3] = (GLdouble) ctx->Current.Texcoord[texTransformUnit][3];
1488 break;
1489 case GL_DEPTH_BIAS:
1490 *params = (GLdouble) ctx->Pixel.DepthBias;
1491 break;
1492 case GL_DEPTH_BITS:
1493 *params = (GLdouble) ctx->Visual.depthBits;
1494 break;
1495 case GL_DEPTH_CLEAR_VALUE:
1496 *params = (GLdouble) ctx->Depth.Clear;
1497 break;
1498 case GL_DEPTH_FUNC:
1499 *params = ENUM_TO_DOUBLE(ctx->Depth.Func);
1500 break;
1501 case GL_DEPTH_RANGE:
1502 params[0] = (GLdouble) ctx->Viewport.Near;
1503 params[1] = (GLdouble) ctx->Viewport.Far;
1504 break;
1505 case GL_DEPTH_SCALE:
1506 *params = (GLdouble) ctx->Pixel.DepthScale;
1507 break;
1508 case GL_DEPTH_TEST:
1509 *params = (GLdouble) ctx->Depth.Test;
1510 break;
1511 case GL_DEPTH_WRITEMASK:
1512 *params = (GLdouble) ctx->Depth.Mask;
1513 break;
1514 case GL_DITHER:
1515 *params = (GLdouble) ctx->Color.DitherFlag;
1516 break;
1517 case GL_DOUBLEBUFFER:
1518 *params = (GLdouble) ctx->Visual.doubleBufferMode;
1519 break;
1520 case GL_DRAW_BUFFER:
1521 *params = ENUM_TO_DOUBLE(ctx->Color.DrawBuffer);
1522 break;
1523 case GL_EDGE_FLAG:
1524 FLUSH_CURRENT(ctx, 0);
1525 *params = (GLdouble) ctx->Current.EdgeFlag;
1526 break;
1527 case GL_FEEDBACK_BUFFER_SIZE:
1528 *params = (GLdouble) ctx->Feedback.BufferSize;
1529 break;
1530 case GL_FEEDBACK_BUFFER_TYPE:
1531 *params = ENUM_TO_DOUBLE(ctx->Feedback.Type);
1532 break;
1533 case GL_FOG:
1534 *params = (GLdouble) ctx->Fog.Enabled;
1535 break;
1536 case GL_FOG_COLOR:
1537 params[0] = (GLdouble) ctx->Fog.Color[0];
1538 params[1] = (GLdouble) ctx->Fog.Color[1];
1539 params[2] = (GLdouble) ctx->Fog.Color[2];
1540 params[3] = (GLdouble) ctx->Fog.Color[3];
1541 break;
1542 case GL_FOG_DENSITY:
1543 *params = (GLdouble) ctx->Fog.Density;
1544 break;
1545 case GL_FOG_END:
1546 *params = (GLdouble) ctx->Fog.End;
1547 break;
1548 case GL_FOG_HINT:
1549 *params = ENUM_TO_DOUBLE(ctx->Hint.Fog);
1550 break;
1551 case GL_FOG_INDEX:
1552 *params = (GLdouble) ctx->Fog.Index;
1553 break;
1554 case GL_FOG_MODE:
1555 *params = ENUM_TO_DOUBLE(ctx->Fog.Mode);
1556 break;
1557 case GL_FOG_START:
1558 *params = (GLdouble) ctx->Fog.Start;
1559 break;
1560 case GL_FRONT_FACE:
1561 *params = ENUM_TO_DOUBLE(ctx->Polygon.FrontFace);
1562 break;
1563 case GL_GREEN_BIAS:
1564 *params = (GLdouble) ctx->Pixel.GreenBias;
1565 break;
1566 case GL_GREEN_BITS:
1567 *params = (GLdouble) ctx->Visual.greenBits;
1568 break;
1569 case GL_GREEN_SCALE:
1570 *params = (GLdouble) ctx->Pixel.GreenScale;
1571 break;
1572 case GL_HISTOGRAM:
1573 if (ctx->Extensions.EXT_histogram || ctx->Extensions.ARB_imaging) {
1574 *params = (GLdouble) ctx->Pixel.HistogramEnabled;
1575 }
1576 else {
1577 _mesa_error(ctx, GL_INVALID_ENUM, "glGetDoublev");
1578 return;
1579 }
1580 break;
1581 case GL_INDEX_BITS:
1582 *params = (GLdouble) ctx->Visual.indexBits;
1583 break;
1584 case GL_INDEX_CLEAR_VALUE:
1585 *params = (GLdouble) ctx->Color.ClearIndex;
1586 break;
1587 case GL_INDEX_MODE:
1588 *params = ctx->Visual.rgbMode ? 0.0 : 1.0;
1589 break;
1590 case GL_INDEX_OFFSET:
1591 *params = (GLdouble) ctx->Pixel.IndexOffset;
1592 break;
1593 case GL_INDEX_SHIFT:
1594 *params = (GLdouble) ctx->Pixel.IndexShift;
1595 break;
1596 case GL_INDEX_WRITEMASK:
1597 *params = (GLdouble) ctx->Color.IndexMask;
1598 break;
1599 case GL_LIGHT0:
1600 case GL_LIGHT1:
1601 case GL_LIGHT2:
1602 case GL_LIGHT3:
1603 case GL_LIGHT4:
1604 case GL_LIGHT5:
1605 case GL_LIGHT6:
1606 case GL_LIGHT7:
1607 *params = (GLdouble) ctx->Light.Light[pname-GL_LIGHT0].Enabled;
1608 break;
1609 case GL_LIGHTING:
1610 *params = (GLdouble) ctx->Light.Enabled;
1611 break;
1612 case GL_LIGHT_MODEL_AMBIENT:
1613 params[0] = (GLdouble) ctx->Light.Model.Ambient[0];
1614 params[1] = (GLdouble) ctx->Light.Model.Ambient[1];
1615 params[2] = (GLdouble) ctx->Light.Model.Ambient[2];
1616 params[3] = (GLdouble) ctx->Light.Model.Ambient[3];
1617 break;
1618 case GL_LIGHT_MODEL_COLOR_CONTROL:
1619 params[0] = (GLdouble) ctx->Light.Model.ColorControl;
1620 break;
1621 case GL_LIGHT_MODEL_LOCAL_VIEWER:
1622 *params = (GLdouble) ctx->Light.Model.LocalViewer;
1623 break;
1624 case GL_LIGHT_MODEL_TWO_SIDE:
1625 *params = (GLdouble) ctx->Light.Model.TwoSide;
1626 break;
1627 case GL_LINE_SMOOTH:
1628 *params = (GLdouble) ctx->Line.SmoothFlag;
1629 break;
1630 case GL_LINE_SMOOTH_HINT:
1631 *params = ENUM_TO_DOUBLE(ctx->Hint.LineSmooth);
1632 break;
1633 case GL_LINE_STIPPLE:
1634 *params = (GLdouble) ctx->Line.StippleFlag;
1635 break;
1636 case GL_LINE_STIPPLE_PATTERN:
1637 *params = (GLdouble) ctx->Line.StipplePattern;
1638 break;
1639 case GL_LINE_STIPPLE_REPEAT:
1640 *params = (GLdouble) ctx->Line.StippleFactor;
1641 break;
1642 case GL_LINE_WIDTH:
1643 *params = (GLdouble) ctx->Line.Width;
1644 break;
1645 case GL_LINE_WIDTH_GRANULARITY:
1646 *params = (GLdouble) ctx->Const.LineWidthGranularity;
1647 break;
1648 case GL_LINE_WIDTH_RANGE:
1649 params[0] = (GLdouble) ctx->Const.MinLineWidthAA;
1650 params[1] = (GLdouble) ctx->Const.MaxLineWidthAA;
1651 break;
1652 case GL_ALIASED_LINE_WIDTH_RANGE:
1653 params[0] = (GLdouble) ctx->Const.MinLineWidth;
1654 params[1] = (GLdouble) ctx->Const.MaxLineWidth;
1655 break;
1656 case GL_LIST_BASE:
1657 *params = (GLdouble) ctx->List.ListBase;
1658 break;
1659 case GL_LIST_INDEX:
1660 *params = (GLdouble) ctx->CurrentListNum;
1661 break;
1662 case GL_LIST_MODE:
1663 *params = ctx->ExecuteFlag ? ENUM_TO_DOUBLE(GL_COMPILE_AND_EXECUTE)
1664 : ENUM_TO_DOUBLE(GL_COMPILE);
1665 break;
1666 case GL_INDEX_LOGIC_OP:
1667 *params = (GLdouble) ctx->Color.IndexLogicOpEnabled;
1668 break;
1669 case GL_COLOR_LOGIC_OP:
1670 *params = (GLdouble) ctx->Color.ColorLogicOpEnabled;
1671 break;
1672 case GL_LOGIC_OP_MODE:
1673 *params = ENUM_TO_DOUBLE(ctx->Color.LogicOp);
1674 break;
1675 case GL_MAP1_COLOR_4:
1676 *params = (GLdouble) ctx->Eval.Map1Color4;
1677 break;
1678 case GL_MAP1_GRID_DOMAIN:
1679 params[0] = (GLdouble) ctx->Eval.MapGrid1u1;
1680 params[1] = (GLdouble) ctx->Eval.MapGrid1u2;
1681 break;
1682 case GL_MAP1_GRID_SEGMENTS:
1683 *params = (GLdouble) ctx->Eval.MapGrid1un;
1684 break;
1685 case GL_MAP1_INDEX:
1686 *params = (GLdouble) ctx->Eval.Map1Index;
1687 break;
1688 case GL_MAP1_NORMAL:
1689 *params = (GLdouble) ctx->Eval.Map1Normal;
1690 break;
1691 case GL_MAP1_TEXTURE_COORD_1:
1692 *params = (GLdouble) ctx->Eval.Map1TextureCoord1;
1693 break;
1694 case GL_MAP1_TEXTURE_COORD_2:
1695 *params = (GLdouble) ctx->Eval.Map1TextureCoord2;
1696 break;
1697 case GL_MAP1_TEXTURE_COORD_3:
1698 *params = (GLdouble) ctx->Eval.Map1TextureCoord3;
1699 break;
1700 case GL_MAP1_TEXTURE_COORD_4:
1701 *params = (GLdouble) ctx->Eval.Map1TextureCoord4;
1702 break;
1703 case GL_MAP1_VERTEX_3:
1704 *params = (GLdouble) ctx->Eval.Map1Vertex3;
1705 break;
1706 case GL_MAP1_VERTEX_4:
1707 *params = (GLdouble) ctx->Eval.Map1Vertex4;
1708 break;
1709 case GL_MAP2_COLOR_4:
1710 *params = (GLdouble) ctx->Eval.Map2Color4;
1711 break;
1712 case GL_MAP2_GRID_DOMAIN:
1713 params[0] = (GLdouble) ctx->Eval.MapGrid2u1;
1714 params[1] = (GLdouble) ctx->Eval.MapGrid2u2;
1715 params[2] = (GLdouble) ctx->Eval.MapGrid2v1;
1716 params[3] = (GLdouble) ctx->Eval.MapGrid2v2;
1717 break;
1718 case GL_MAP2_GRID_SEGMENTS:
1719 params[0] = (GLdouble) ctx->Eval.MapGrid2un;
1720 params[1] = (GLdouble) ctx->Eval.MapGrid2vn;
1721 break;
1722 case GL_MAP2_INDEX:
1723 *params = (GLdouble) ctx->Eval.Map2Index;
1724 break;
1725 case GL_MAP2_NORMAL:
1726 *params = (GLdouble) ctx->Eval.Map2Normal;
1727 break;
1728 case GL_MAP2_TEXTURE_COORD_1:
1729 *params = (GLdouble) ctx->Eval.Map2TextureCoord1;
1730 break;
1731 case GL_MAP2_TEXTURE_COORD_2:
1732 *params = (GLdouble) ctx->Eval.Map2TextureCoord2;
1733 break;
1734 case GL_MAP2_TEXTURE_COORD_3:
1735 *params = (GLdouble) ctx->Eval.Map2TextureCoord3;
1736 break;
1737 case GL_MAP2_TEXTURE_COORD_4:
1738 *params = (GLdouble) ctx->Eval.Map2TextureCoord4;
1739 break;
1740 case GL_MAP2_VERTEX_3:
1741 *params = (GLdouble) ctx->Eval.Map2Vertex3;
1742 break;
1743 case GL_MAP2_VERTEX_4:
1744 *params = (GLdouble) ctx->Eval.Map2Vertex4;
1745 break;
1746 case GL_MAP_COLOR:
1747 *params = (GLdouble) ctx->Pixel.MapColorFlag;
1748 break;
1749 case GL_MAP_STENCIL:
1750 *params = (GLdouble) ctx->Pixel.MapStencilFlag;
1751 break;
1752 case GL_MATRIX_MODE:
1753 *params = ENUM_TO_DOUBLE(ctx->Transform.MatrixMode);
1754 break;
1755 case GL_MAX_ATTRIB_STACK_DEPTH:
1756 *params = (GLdouble) MAX_ATTRIB_STACK_DEPTH;
1757 break;
1758 case GL_MAX_CLIENT_ATTRIB_STACK_DEPTH:
1759 *params = (GLdouble) MAX_CLIENT_ATTRIB_STACK_DEPTH;
1760 break;
1761 case GL_MAX_CLIP_PLANES:
1762 *params = (GLdouble) ctx->Const.MaxClipPlanes;
1763 break;
1764 case GL_MAX_ELEMENTS_VERTICES: /* GL_VERSION_1_2 */
1765 *params = (GLdouble) ctx->Const.MaxArrayLockSize;
1766 break;
1767 case GL_MAX_ELEMENTS_INDICES: /* GL_VERSION_1_2 */
1768 *params = (GLdouble) ctx->Const.MaxArrayLockSize;
1769 break;
1770 case GL_MAX_EVAL_ORDER:
1771 *params = (GLdouble) MAX_EVAL_ORDER;
1772 break;
1773 case GL_MAX_LIGHTS:
1774 *params = (GLdouble) ctx->Const.MaxLights;
1775 break;
1776 case GL_MAX_LIST_NESTING:
1777 *params = (GLdouble) MAX_LIST_NESTING;
1778 break;
1779 case GL_MAX_MODELVIEW_STACK_DEPTH:
1780 *params = (GLdouble) MAX_MODELVIEW_STACK_DEPTH;
1781 break;
1782 case GL_MAX_NAME_STACK_DEPTH:
1783 *params = (GLdouble) MAX_NAME_STACK_DEPTH;
1784 break;
1785 case GL_MAX_PIXEL_MAP_TABLE:
1786 *params = (GLdouble) MAX_PIXEL_MAP_TABLE;
1787 break;
1788 case GL_MAX_PROJECTION_STACK_DEPTH:
1789 *params = (GLdouble) MAX_PROJECTION_STACK_DEPTH;
1790 break;
1791 case GL_MAX_TEXTURE_SIZE:
1792 case GL_MAX_3D_TEXTURE_SIZE:
1793 *params = (GLdouble) ctx->Const.MaxTextureSize;
1794 break;
1795 case GL_MAX_TEXTURE_STACK_DEPTH:
1796 *params = (GLdouble) MAX_TEXTURE_STACK_DEPTH;
1797 break;
1798 case GL_MAX_VIEWPORT_DIMS:
1799 params[0] = (GLdouble) MAX_WIDTH;
1800 params[1] = (GLdouble) MAX_HEIGHT;
1801 break;
1802 case GL_MINMAX:
1803 *params = (GLdouble) ctx->Pixel.MinMaxEnabled;
1804 break;
1805 case GL_MODELVIEW_MATRIX:
1806 for (i=0;i<16;i++) {
1807 params[i] = (GLdouble) ctx->ModelView.m[i];
1808 }
1809 break;
1810 case GL_MODELVIEW_STACK_DEPTH:
1811 *params = (GLdouble) (ctx->ModelViewStackDepth + 1);
1812 break;
1813 case GL_NAME_STACK_DEPTH:
1814 *params = (GLdouble) ctx->Select.NameStackDepth;
1815 break;
1816 case GL_NORMALIZE:
1817 *params = (GLdouble) ctx->Transform.Normalize;
1818 break;
1819 case GL_PACK_ALIGNMENT:
1820 *params = (GLdouble) ctx->Pack.Alignment;
1821 break;
1822 case GL_PACK_LSB_FIRST:
1823 *params = (GLdouble) ctx->Pack.LsbFirst;
1824 break;
1825 case GL_PACK_ROW_LENGTH:
1826 *params = (GLdouble) ctx->Pack.RowLength;
1827 break;
1828 case GL_PACK_SKIP_PIXELS:
1829 *params = (GLdouble) ctx->Pack.SkipPixels;
1830 break;
1831 case GL_PACK_SKIP_ROWS:
1832 *params = (GLdouble) ctx->Pack.SkipRows;
1833 break;
1834 case GL_PACK_SWAP_BYTES:
1835 *params = (GLdouble) ctx->Pack.SwapBytes;
1836 break;
1837 case GL_PACK_SKIP_IMAGES_EXT:
1838 *params = (GLdouble) ctx->Pack.SkipImages;
1839 break;
1840 case GL_PACK_IMAGE_HEIGHT_EXT:
1841 *params = (GLdouble) ctx->Pack.ImageHeight;
1842 break;
1843 case GL_PERSPECTIVE_CORRECTION_HINT:
1844 *params = ENUM_TO_DOUBLE(ctx->Hint.PerspectiveCorrection);
1845 break;
1846 case GL_PIXEL_MAP_A_TO_A_SIZE:
1847 *params = (GLdouble) ctx->Pixel.MapAtoAsize;
1848 break;
1849 case GL_PIXEL_MAP_B_TO_B_SIZE:
1850 *params = (GLdouble) ctx->Pixel.MapBtoBsize;
1851 break;
1852 case GL_PIXEL_MAP_G_TO_G_SIZE:
1853 *params = (GLdouble) ctx->Pixel.MapGtoGsize;
1854 break;
1855 case GL_PIXEL_MAP_I_TO_A_SIZE:
1856 *params = (GLdouble) ctx->Pixel.MapItoAsize;
1857 break;
1858 case GL_PIXEL_MAP_I_TO_B_SIZE:
1859 *params = (GLdouble) ctx->Pixel.MapItoBsize;
1860 break;
1861 case GL_PIXEL_MAP_I_TO_G_SIZE:
1862 *params = (GLdouble) ctx->Pixel.MapItoGsize;
1863 break;
1864 case GL_PIXEL_MAP_I_TO_I_SIZE:
1865 *params = (GLdouble) ctx->Pixel.MapItoIsize;
1866 break;
1867 case GL_PIXEL_MAP_I_TO_R_SIZE:
1868 *params = (GLdouble) ctx->Pixel.MapItoRsize;
1869 break;
1870 case GL_PIXEL_MAP_R_TO_R_SIZE:
1871 *params = (GLdouble) ctx->Pixel.MapRtoRsize;
1872 break;
1873 case GL_PIXEL_MAP_S_TO_S_SIZE:
1874 *params = (GLdouble) ctx->Pixel.MapStoSsize;
1875 break;
1876 case GL_POINT_SIZE:
1877 *params = (GLdouble) ctx->Point.Size;
1878 break;
1879 case GL_POINT_SIZE_GRANULARITY:
1880 *params = (GLdouble) ctx->Const.PointSizeGranularity;
1881 break;
1882 case GL_POINT_SIZE_RANGE:
1883 params[0] = (GLdouble) ctx->Const.MinPointSizeAA;
1884 params[1] = (GLdouble) ctx->Const.MaxPointSizeAA;
1885 break;
1886 case GL_ALIASED_POINT_SIZE_RANGE:
1887 params[0] = (GLdouble) ctx->Const.MinPointSize;
1888 params[1] = (GLdouble) ctx->Const.MaxPointSize;
1889 break;
1890 case GL_POINT_SMOOTH:
1891 *params = (GLdouble) ctx->Point.SmoothFlag;
1892 break;
1893 case GL_POINT_SMOOTH_HINT:
1894 *params = ENUM_TO_DOUBLE(ctx->Hint.PointSmooth);
1895 break;
1896 case GL_POINT_SIZE_MIN_EXT:
1897 *params = (GLdouble) (ctx->Point.MinSize);
1898 break;
1899 case GL_POINT_SIZE_MAX_EXT:
1900 *params = (GLdouble) (ctx->Point.MaxSize);
1901 break;
1902 case GL_POINT_FADE_THRESHOLD_SIZE_EXT:
1903 *params = (GLdouble) (ctx->Point.Threshold);
1904 break;
1905 case GL_DISTANCE_ATTENUATION_EXT:
1906 params[0] = (GLdouble) (ctx->Point.Params[0]);
1907 params[1] = (GLdouble) (ctx->Point.Params[1]);
1908 params[2] = (GLdouble) (ctx->Point.Params[2]);
1909 break;
1910 case GL_POLYGON_MODE:
1911 params[0] = ENUM_TO_DOUBLE(ctx->Polygon.FrontMode);
1912 params[1] = ENUM_TO_DOUBLE(ctx->Polygon.BackMode);
1913 break;
1914 case GL_POLYGON_OFFSET_BIAS_EXT: /* GL_EXT_polygon_offset */
1915 *params = (GLdouble) ctx->Polygon.OffsetUnits;
1916 break;
1917 case GL_POLYGON_OFFSET_FACTOR:
1918 *params = (GLdouble) ctx->Polygon.OffsetFactor;
1919 break;
1920 case GL_POLYGON_OFFSET_UNITS:
1921 *params = (GLdouble) ctx->Polygon.OffsetUnits;
1922 break;
1923 case GL_POLYGON_SMOOTH:
1924 *params = (GLdouble) ctx->Polygon.SmoothFlag;
1925 break;
1926 case GL_POLYGON_SMOOTH_HINT:
1927 *params = ENUM_TO_DOUBLE(ctx->Hint.PolygonSmooth);
1928 break;
1929 case GL_POLYGON_STIPPLE:
1930 *params = (GLdouble) ctx->Polygon.StippleFlag;
1931 break;
1932 case GL_PROJECTION_MATRIX:
1933 for (i=0;i<16;i++) {
1934 params[i] = (GLdouble) ctx->ProjectionMatrix.m[i];
1935 }
1936 break;
1937 case GL_PROJECTION_STACK_DEPTH:
1938 *params = (GLdouble) (ctx->ProjectionStackDepth + 1);
1939 break;
1940 case GL_READ_BUFFER:
1941 *params = ENUM_TO_DOUBLE(ctx->Pixel.ReadBuffer);
1942 break;
1943 case GL_RED_BIAS:
1944 *params = (GLdouble) ctx->Pixel.RedBias;
1945 break;
1946 case GL_RED_BITS:
1947 *params = (GLdouble) ctx->Visual.redBits;
1948 break;
1949 case GL_RED_SCALE:
1950 *params = (GLdouble) ctx->Pixel.RedScale;
1951 break;
1952 case GL_RENDER_MODE:
1953 *params = ENUM_TO_DOUBLE(ctx->RenderMode);
1954 break;
1955 case GL_RESCALE_NORMAL:
1956 *params = (GLdouble) ctx->Transform.RescaleNormals;
1957 break;
1958 case GL_RGBA_MODE:
1959 *params = (GLdouble) ctx->Visual.rgbMode;
1960 break;
1961 case GL_SCISSOR_BOX:
1962 params[0] = (GLdouble) ctx->Scissor.X;
1963 params[1] = (GLdouble) ctx->Scissor.Y;
1964 params[2] = (GLdouble) ctx->Scissor.Width;
1965 params[3] = (GLdouble) ctx->Scissor.Height;
1966 break;
1967 case GL_SCISSOR_TEST:
1968 *params = (GLdouble) ctx->Scissor.Enabled;
1969 break;
1970 case GL_SELECTION_BUFFER_SIZE:
1971 *params = (GLdouble) ctx->Select.BufferSize;
1972 break;
1973 case GL_SHADE_MODEL:
1974 *params = ENUM_TO_DOUBLE(ctx->Light.ShadeModel);
1975 break;
1976 case GL_SHARED_TEXTURE_PALETTE_EXT:
1977 *params = (GLdouble) ctx->Texture.SharedPalette;
1978 break;
1979 case GL_STENCIL_BITS:
1980 *params = (GLdouble) ctx->Visual.stencilBits;
1981 break;
1982 case GL_STENCIL_CLEAR_VALUE:
1983 *params = (GLdouble) ctx->Stencil.Clear;
1984 break;
1985 case GL_STENCIL_FAIL:
1986 *params = ENUM_TO_DOUBLE(ctx->Stencil.FailFunc);
1987 break;
1988 case GL_STENCIL_FUNC:
1989 *params = ENUM_TO_DOUBLE(ctx->Stencil.Function);
1990 break;
1991 case GL_STENCIL_PASS_DEPTH_FAIL:
1992 *params = ENUM_TO_DOUBLE(ctx->Stencil.ZFailFunc);
1993 break;
1994 case GL_STENCIL_PASS_DEPTH_PASS:
1995 *params = ENUM_TO_DOUBLE(ctx->Stencil.ZPassFunc);
1996 break;
1997 case GL_STENCIL_REF:
1998 *params = (GLdouble) ctx->Stencil.Ref;
1999 break;
2000 case GL_STENCIL_TEST:
2001 *params = (GLdouble) ctx->Stencil.Enabled;
2002 break;
2003 case GL_STENCIL_VALUE_MASK:
2004 *params = (GLdouble) ctx->Stencil.ValueMask;
2005 break;
2006 case GL_STENCIL_WRITEMASK:
2007 *params = (GLdouble) ctx->Stencil.WriteMask;
2008 break;
2009 case GL_STEREO:
2010 *params = (GLdouble) ctx->Visual.stereoMode;
2011 break;
2012 case GL_SUBPIXEL_BITS:
2013 *params = (GLdouble) ctx->Const.SubPixelBits;
2014 break;
2015 case GL_TEXTURE_1D:
2016 *params = _mesa_IsEnabled(GL_TEXTURE_1D) ? 1.0 : 0.0;
2017 break;
2018 case GL_TEXTURE_2D:
2019 *params = _mesa_IsEnabled(GL_TEXTURE_2D) ? 1.0 : 0.0;
2020 break;
2021 case GL_TEXTURE_3D:
2022 *params = _mesa_IsEnabled(GL_TEXTURE_3D) ? 1.0 : 0.0;
2023 break;
2024 case GL_TEXTURE_BINDING_1D:
2025 *params = (GLdouble) textureUnit->Current1D->Name;
2026 break;
2027 case GL_TEXTURE_BINDING_2D:
2028 *params = (GLdouble) textureUnit->Current2D->Name;
2029 break;
2030 case GL_TEXTURE_BINDING_3D:
2031 *params = (GLdouble) textureUnit->Current3D->Name;
2032 break;
2033 case GL_TEXTURE_ENV_COLOR:
2034 params[0] = (GLdouble) textureUnit->EnvColor[0];
2035 params[1] = (GLdouble) textureUnit->EnvColor[1];
2036 params[2] = (GLdouble) textureUnit->EnvColor[2];
2037 params[3] = (GLdouble) textureUnit->EnvColor[3];
2038 break;
2039 case GL_TEXTURE_ENV_MODE:
2040 *params = ENUM_TO_DOUBLE(textureUnit->EnvMode);
2041 break;
2042 case GL_TEXTURE_GEN_S:
2043 *params = (textureUnit->TexGenEnabled & S_BIT) ? 1.0 : 0.0;
2044 break;
2045 case GL_TEXTURE_GEN_T:
2046 *params = (textureUnit->TexGenEnabled & T_BIT) ? 1.0 : 0.0;
2047 break;
2048 case GL_TEXTURE_GEN_R:
2049 *params = (textureUnit->TexGenEnabled & R_BIT) ? 1.0 : 0.0;
2050 break;
2051 case GL_TEXTURE_GEN_Q:
2052 *params = (textureUnit->TexGenEnabled & Q_BIT) ? 1.0 : 0.0;
2053 break;
2054 case GL_TEXTURE_MATRIX:
2055 for (i=0;i<16;i++) {
2056 params[i] = (GLdouble) ctx->TextureMatrix[texTransformUnit].m[i];
2057 }
2058 break;
2059 case GL_TEXTURE_STACK_DEPTH:
2060 *params = (GLdouble) (ctx->TextureStackDepth[texTransformUnit] + 1);
2061 break;
2062 case GL_UNPACK_ALIGNMENT:
2063 *params = (GLdouble) ctx->Unpack.Alignment;
2064 break;
2065 case GL_UNPACK_LSB_FIRST:
2066 *params = (GLdouble) ctx->Unpack.LsbFirst;
2067 break;
2068 case GL_UNPACK_ROW_LENGTH:
2069 *params = (GLdouble) ctx->Unpack.RowLength;
2070 break;
2071 case GL_UNPACK_SKIP_PIXELS:
2072 *params = (GLdouble) ctx->Unpack.SkipPixels;
2073 break;
2074 case GL_UNPACK_SKIP_ROWS:
2075 *params = (GLdouble) ctx->Unpack.SkipRows;
2076 break;
2077 case GL_UNPACK_SWAP_BYTES:
2078 *params = (GLdouble) ctx->Unpack.SwapBytes;
2079 break;
2080 case GL_UNPACK_SKIP_IMAGES_EXT:
2081 *params = (GLdouble) ctx->Unpack.SkipImages;
2082 break;
2083 case GL_UNPACK_IMAGE_HEIGHT_EXT:
2084 *params = (GLdouble) ctx->Unpack.ImageHeight;
2085 break;
2086 case GL_VIEWPORT:
2087 params[0] = (GLdouble) ctx->Viewport.X;
2088 params[1] = (GLdouble) ctx->Viewport.Y;
2089 params[2] = (GLdouble) ctx->Viewport.Width;
2090 params[3] = (GLdouble) ctx->Viewport.Height;
2091 break;
2092 case GL_ZOOM_X:
2093 *params = (GLdouble) ctx->Pixel.ZoomX;
2094 break;
2095 case GL_ZOOM_Y:
2096 *params = (GLdouble) ctx->Pixel.ZoomY;
2097 break;
2098 case GL_VERTEX_ARRAY:
2099 *params = (GLdouble) ctx->Array.Vertex.Enabled;
2100 break;
2101 case GL_VERTEX_ARRAY_SIZE:
2102 *params = (GLdouble) ctx->Array.Vertex.Size;
2103 break;
2104 case GL_VERTEX_ARRAY_TYPE:
2105 *params = ENUM_TO_DOUBLE(ctx->Array.Vertex.Type);
2106 break;
2107 case GL_VERTEX_ARRAY_STRIDE:
2108 *params = (GLdouble) ctx->Array.Vertex.Stride;
2109 break;
2110 case GL_VERTEX_ARRAY_COUNT_EXT:
2111 *params = 0.0;
2112 break;
2113 case GL_NORMAL_ARRAY:
2114 *params = (GLdouble) ctx->Array.Normal.Enabled;
2115 break;
2116 case GL_NORMAL_ARRAY_TYPE:
2117 *params = ENUM_TO_DOUBLE(ctx->Array.Normal.Type);
2118 break;
2119 case GL_NORMAL_ARRAY_STRIDE:
2120 *params = (GLdouble) ctx->Array.Normal.Stride;
2121 break;
2122 case GL_NORMAL_ARRAY_COUNT_EXT:
2123 *params = 0.0;
2124 break;
2125 case GL_COLOR_ARRAY:
2126 *params = (GLdouble) ctx->Array.Color.Enabled;
2127 break;
2128 case GL_COLOR_ARRAY_SIZE:
2129 *params = (GLdouble) ctx->Array.Color.Size;
2130 break;
2131 case GL_COLOR_ARRAY_TYPE:
2132 *params = ENUM_TO_DOUBLE(ctx->Array.Color.Type);
2133 break;
2134 case GL_COLOR_ARRAY_STRIDE:
2135 *params = (GLdouble) ctx->Array.Color.Stride;
2136 break;
2137 case GL_COLOR_ARRAY_COUNT_EXT:
2138 *params = 0.0;
2139 break;
2140 case GL_INDEX_ARRAY:
2141 *params = (GLdouble) ctx->Array.Index.Enabled;
2142 break;
2143 case GL_INDEX_ARRAY_TYPE:
2144 *params = ENUM_TO_DOUBLE(ctx->Array.Index.Type);
2145 break;
2146 case GL_INDEX_ARRAY_STRIDE:
2147 *params = (GLdouble) ctx->Array.Index.Stride;
2148 break;
2149 case GL_INDEX_ARRAY_COUNT_EXT:
2150 *params = 0.0;
2151 break;
2152 case GL_TEXTURE_COORD_ARRAY:
2153 *params = (GLdouble) ctx->Array.TexCoord[texUnit].Enabled;
2154 break;
2155 case GL_TEXTURE_COORD_ARRAY_SIZE:
2156 *params = (GLdouble) ctx->Array.TexCoord[texUnit].Size;
2157 break;
2158 case GL_TEXTURE_COORD_ARRAY_TYPE:
2159 *params = ENUM_TO_DOUBLE(ctx->Array.TexCoord[texUnit].Type);
2160 break;
2161 case GL_TEXTURE_COORD_ARRAY_STRIDE:
2162 *params = (GLdouble) ctx->Array.TexCoord[texUnit].Stride;
2163 break;
2164 case GL_TEXTURE_COORD_ARRAY_COUNT_EXT:
2165 *params = 0.0;
2166 break;
2167 case GL_EDGE_FLAG_ARRAY:
2168 *params = (GLdouble) ctx->Array.EdgeFlag.Enabled;
2169 break;
2170 case GL_EDGE_FLAG_ARRAY_STRIDE:
2171 *params = (GLdouble) ctx->Array.EdgeFlag.Stride;
2172 break;
2173 case GL_EDGE_FLAG_ARRAY_COUNT_EXT:
2174 *params = 0.0;
2175 break;
2176
2177 /* GL_ARB_multitexture */
2178 case GL_MAX_TEXTURE_UNITS_ARB:
2179 *params = (GLdouble) ctx->Const.MaxTextureUnits;
2180 break;
2181 case GL_ACTIVE_TEXTURE_ARB:
2182 *params = (GLdouble) (GL_TEXTURE0_ARB + ctx->Texture.CurrentUnit);
2183 break;
2184 case GL_CLIENT_ACTIVE_TEXTURE_ARB:
2185 *params = (GLdouble) (GL_TEXTURE0_ARB + ctx->Array.ActiveTexture);
2186 break;
2187
2188 /* GL_ARB_texture_cube_map */
2189 case GL_TEXTURE_CUBE_MAP_ARB:
2190 if (ctx->Extensions.ARB_texture_cube_map)
2191 *params = (GLdouble) _mesa_IsEnabled(GL_TEXTURE_CUBE_MAP_ARB);
2192 else
2193 _mesa_error(ctx, GL_INVALID_ENUM, "glGetDoublev");
2194 return;
2195 case GL_TEXTURE_BINDING_CUBE_MAP_ARB:
2196 if (ctx->Extensions.ARB_texture_cube_map)
2197 *params = (GLdouble) textureUnit->CurrentCubeMap->Name;
2198 else
2199 _mesa_error(ctx, GL_INVALID_ENUM, "glGetDoublev");
2200 return;
2201 case GL_MAX_CUBE_MAP_TEXTURE_SIZE_ARB:
2202 if (ctx->Extensions.ARB_texture_cube_map)
2203 *params = (GLdouble) ctx->Const.MaxCubeTextureSize;
2204 else
2205 _mesa_error(ctx, GL_INVALID_ENUM, "glGetDoublev");
2206 return;
2207
2208 /* GL_ARB_texture_compression */
2209 case GL_TEXTURE_COMPRESSION_HINT_ARB:
2210 if (ctx->Extensions.ARB_texture_compression) {
2211 *params = (GLdouble) ctx->Hint.TextureCompression;
2212 }
2213 else
2214 _mesa_error(ctx, GL_INVALID_ENUM, "glGetDoublev");
2215 break;
2216 case GL_NUM_COMPRESSED_TEXTURE_FORMATS_ARB:
2217 if (ctx->Extensions.ARB_texture_compression) {
2218 *params = (GLdouble) ctx->Const.NumCompressedTextureFormats;
2219 }
2220 else
2221 _mesa_error(ctx, GL_INVALID_ENUM, "glGetDoublev");
2222 break;
2223 case GL_COMPRESSED_TEXTURE_FORMATS_ARB:
2224 if (ctx->Extensions.ARB_texture_compression) {
2225 GLuint i;
2226 for (i = 0; i < ctx->Const.NumCompressedTextureFormats; i++)
2227 params[i] = (GLdouble) ctx->Const.CompressedTextureFormats[i];
2228 }
2229 else
2230 _mesa_error(ctx, GL_INVALID_ENUM, "glGetDoublev");
2231 break;
2232
2233 /* GL_EXT_compiled_vertex_array */
2234 case GL_ARRAY_ELEMENT_LOCK_FIRST_EXT:
2235 *params = (GLdouble) ctx->Array.LockFirst;
2236 break;
2237 case GL_ARRAY_ELEMENT_LOCK_COUNT_EXT:
2238 *params = (GLdouble) ctx->Array.LockCount;
2239 break;
2240
2241 /* GL_ARB_transpose_matrix */
2242 case GL_TRANSPOSE_COLOR_MATRIX_ARB:
2243 {
2244 GLfloat tm[16];
2245 GLuint i;
2246 _math_transposef(tm, ctx->ColorMatrix.m);
2247 for (i=0;i<16;i++) {
2248 params[i] = (GLdouble) tm[i];
2249 }
2250 }
2251 break;
2252 case GL_TRANSPOSE_MODELVIEW_MATRIX_ARB:
2253 {
2254 GLfloat tm[16];
2255 GLuint i;
2256 _math_transposef(tm, ctx->ModelView.m);
2257 for (i=0;i<16;i++) {
2258 params[i] = (GLdouble) tm[i];
2259 }
2260 }
2261 break;
2262 case GL_TRANSPOSE_PROJECTION_MATRIX_ARB:
2263 {
2264 GLfloat tm[16];
2265 GLuint i;
2266 _math_transposef(tm, ctx->ProjectionMatrix.m);
2267 for (i=0;i<16;i++) {
2268 params[i] = (GLdouble) tm[i];
2269 }
2270 }
2271 break;
2272 case GL_TRANSPOSE_TEXTURE_MATRIX_ARB:
2273 {
2274 GLfloat tm[16];
2275 GLuint i;
2276 _math_transposef(tm, ctx->TextureMatrix[texTransformUnit].m);
2277 for (i=0;i<16;i++) {
2278 params[i] = (GLdouble) tm[i];
2279 }
2280 }
2281 break;
2282
2283 /* GL_HP_occlusion_test */
2284 case GL_OCCLUSION_TEST_HP:
2285 if (ctx->Extensions.HP_occlusion_test) {
2286 *params = (GLdouble) ctx->Depth.OcclusionTest;
2287 }
2288 else {
2289 _mesa_error( ctx, GL_INVALID_ENUM, "glGetDoublev" );
2290 }
2291 return;
2292 case GL_OCCLUSION_TEST_RESULT_HP:
2293 if (ctx->Extensions.HP_occlusion_test) {
2294 if (ctx->Depth.OcclusionTest)
2295 *params = (GLdouble) ctx->OcclusionResult;
2296 else
2297 *params = (GLdouble) ctx->OcclusionResultSaved;
2298 /* reset flag now */
2299 ctx->OcclusionResult = GL_FALSE;
2300 ctx->OcclusionResultSaved = GL_FALSE;
2301 }
2302 else {
2303 _mesa_error( ctx, GL_INVALID_ENUM, "glGetDoublev" );
2304 }
2305 return;
2306
2307 /* GL_SGIS_pixel_texture */
2308 case GL_PIXEL_TEXTURE_SGIS:
2309 *params = (GLdouble) ctx->Pixel.PixelTextureEnabled;
2310 break;
2311
2312 /* GL_SGIX_pixel_texture */
2313 case GL_PIXEL_TEX_GEN_SGIX:
2314 *params = (GLdouble) ctx->Pixel.PixelTextureEnabled;
2315 break;
2316 case GL_PIXEL_TEX_GEN_MODE_SGIX:
2317 *params = (GLdouble) pixel_texgen_mode(ctx);
2318 break;
2319
2320 /* GL_SGI_color_matrix (also in 1.2 imaging) */
2321 case GL_COLOR_MATRIX_SGI:
2322 for (i=0;i<16;i++) {
2323 params[i] = (GLdouble) ctx->ColorMatrix.m[i];
2324 }
2325 break;
2326 case GL_COLOR_MATRIX_STACK_DEPTH_SGI:
2327 *params = (GLdouble) (ctx->ColorStackDepth + 1);
2328 break;
2329 case GL_MAX_COLOR_MATRIX_STACK_DEPTH_SGI:
2330 *params = (GLdouble) MAX_COLOR_STACK_DEPTH;
2331 break;
2332 case GL_POST_COLOR_MATRIX_RED_SCALE_SGI:
2333 *params = (GLdouble) ctx->Pixel.PostColorMatrixScale[0];
2334 break;
2335 case GL_POST_COLOR_MATRIX_GREEN_SCALE_SGI:
2336 *params = (GLdouble) ctx->Pixel.PostColorMatrixScale[1];
2337 break;
2338 case GL_POST_COLOR_MATRIX_BLUE_SCALE_SGI:
2339 *params = (GLdouble) ctx->Pixel.PostColorMatrixScale[2];
2340 break;
2341 case GL_POST_COLOR_MATRIX_ALPHA_SCALE_SGI:
2342 *params = (GLdouble) ctx->Pixel.PostColorMatrixScale[3];
2343 break;
2344 case GL_POST_COLOR_MATRIX_RED_BIAS_SGI:
2345 *params = (GLdouble) ctx->Pixel.PostColorMatrixBias[0];
2346 break;
2347 case GL_POST_COLOR_MATRIX_GREEN_BIAS_SGI:
2348 *params = (GLdouble) ctx->Pixel.PostColorMatrixBias[1];
2349 break;
2350 case GL_POST_COLOR_MATRIX_BLUE_BIAS_SGI:
2351 *params = (GLdouble) ctx->Pixel.PostColorMatrixBias[2];
2352 break;
2353 case GL_POST_COLOR_MATRIX_ALPHA_BIAS_SGI:
2354 *params = (GLdouble) ctx->Pixel.PostColorMatrixBias[3];
2355 break;
2356
2357 /* GL_EXT_convolution (also in 1.2 imaging) */
2358 case GL_CONVOLUTION_1D_EXT:
2359 if (ctx->Extensions.EXT_convolution || ctx->Extensions.ARB_imaging) {
2360 *params = (GLdouble) ctx->Pixel.Convolution1DEnabled;
2361 }
2362 else {
2363 _mesa_error(ctx, GL_INVALID_ENUM, "glGetDoublev");
2364 return;
2365 }
2366 break;
2367 case GL_CONVOLUTION_2D:
2368 if (ctx->Extensions.EXT_convolution || ctx->Extensions.ARB_imaging) {
2369 *params = (GLdouble) ctx->Pixel.Convolution2DEnabled;
2370 }
2371 else {
2372 _mesa_error(ctx, GL_INVALID_ENUM, "glGetDoublev");
2373 return;
2374 }
2375 break;
2376 case GL_SEPARABLE_2D:
2377 if (ctx->Extensions.EXT_convolution || ctx->Extensions.ARB_imaging) {
2378 *params = (GLdouble) ctx->Pixel.Separable2DEnabled;
2379 }
2380 else {
2381 _mesa_error(ctx, GL_INVALID_ENUM, "glGetDoublev");
2382 return;
2383 }
2384 break;
2385 case GL_MAX_CONVOLUTION_WIDTH:
2386 *params = (GLdouble) ctx->Const.MaxConvolutionWidth;
2387 break;
2388 case GL_MAX_CONVOLUTION_HEIGHT:
2389 *params = (GLdouble) ctx->Const.MaxConvolutionHeight;
2390 break;
2391 case GL_POST_CONVOLUTION_RED_SCALE_EXT:
2392 *params = (GLdouble) ctx->Pixel.PostConvolutionScale[0];
2393 break;
2394 case GL_POST_CONVOLUTION_GREEN_SCALE_EXT:
2395 *params = (GLdouble) ctx->Pixel.PostConvolutionScale[1];
2396 break;
2397 case GL_POST_CONVOLUTION_BLUE_SCALE_EXT:
2398 *params = (GLdouble) ctx->Pixel.PostConvolutionScale[2];
2399 break;
2400 case GL_POST_CONVOLUTION_ALPHA_SCALE_EXT:
2401 *params = (GLdouble) ctx->Pixel.PostConvolutionScale[3];
2402 break;
2403 case GL_POST_CONVOLUTION_RED_BIAS_EXT:
2404 *params = (GLdouble) ctx->Pixel.PostConvolutionBias[0];
2405 break;
2406 case GL_POST_CONVOLUTION_GREEN_BIAS_EXT:
2407 *params = (GLdouble) ctx->Pixel.PostConvolutionBias[1];
2408 break;
2409 case GL_POST_CONVOLUTION_BLUE_BIAS_EXT:
2410 *params = (GLdouble) ctx->Pixel.PostConvolutionBias[2];
2411 break;
2412 case GL_POST_CONVOLUTION_ALPHA_BIAS_EXT:
2413 *params = (GLdouble) ctx->Pixel.PostConvolutionBias[2];
2414 break;
2415
2416 /* GL_SGI_color_table (also in 1.2 imaging */
2417 case GL_COLOR_TABLE_SGI:
2418 *params = (GLdouble) ctx->Pixel.ColorTableEnabled;
2419 break;
2420 case GL_POST_CONVOLUTION_COLOR_TABLE_SGI:
2421 *params = (GLdouble) ctx->Pixel.PostConvolutionColorTableEnabled;
2422 break;
2423 case GL_POST_COLOR_MATRIX_COLOR_TABLE_SGI:
2424 *params = (GLdouble) ctx->Pixel.PostColorMatrixColorTableEnabled;
2425 break;
2426
2427 /* GL_EXT_secondary_color */
2428 case GL_COLOR_SUM_EXT:
2429 *params = (GLdouble) ctx->Fog.ColorSumEnabled;
2430 break;
2431 case GL_CURRENT_SECONDARY_COLOR_EXT:
2432 FLUSH_CURRENT(ctx, 0);
2433 params[0] = (ctx->Current.SecondaryColor[0]);
2434 params[1] = (ctx->Current.SecondaryColor[1]);
2435 params[2] = (ctx->Current.SecondaryColor[2]);
2436 break;
2437 case GL_SECONDARY_COLOR_ARRAY_EXT:
2438 *params = (GLdouble) ctx->Array.SecondaryColor.Enabled;
2439 break;
2440 case GL_SECONDARY_COLOR_ARRAY_TYPE_EXT:
2441 *params = (GLdouble) ctx->Array.SecondaryColor.Type;
2442 break;
2443 case GL_SECONDARY_COLOR_ARRAY_STRIDE_EXT:
2444 *params = (GLdouble) ctx->Array.SecondaryColor.Stride;
2445 break;
2446 case GL_SECONDARY_COLOR_ARRAY_SIZE_EXT:
2447 *params = (GLdouble) ctx->Array.SecondaryColor.Stride;
2448 break;
2449
2450 /* GL_EXT_fog_coord */
2451 case GL_CURRENT_FOG_COORDINATE_EXT:
2452 FLUSH_CURRENT(ctx, 0);
2453 *params = (GLdouble) ctx->Current.FogCoord;
2454 break;
2455 case GL_FOG_COORDINATE_ARRAY_EXT:
2456 *params = (GLdouble) ctx->Array.FogCoord.Enabled;
2457 break;
2458 case GL_FOG_COORDINATE_ARRAY_TYPE_EXT:
2459 *params = (GLdouble) ctx->Array.FogCoord.Type;
2460 break;
2461 case GL_FOG_COORDINATE_ARRAY_STRIDE_EXT:
2462 *params = (GLdouble) ctx->Array.FogCoord.Stride;
2463 break;
2464
2465 /* GL_EXT_texture_filter_anisotropic */
2466 case GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT:
2467 if (ctx->Extensions.EXT_texture_filter_anisotropic) {
2468 *params = (GLdouble) ctx->Const.MaxTextureMaxAnisotropy;
2469 }
2470 else {
2471 _mesa_error( ctx, GL_INVALID_ENUM, "glGetDoublev" );
2472 return;
2473 }
2474 break;
2475
2476 /* GL_MESA_sprite_point */
2477 case GL_SPRITE_POINT_MESA:
2478 if (ctx->Extensions.MESA_sprite_point) {
2479 *params = (GLdouble) ctx->Point.SpriteMode;
2480 }
2481 else {
2482 _mesa_error( ctx, GL_INVALID_ENUM, "glGetDoublev" );
2483 return;
2484 }
2485 break;
2486
2487 default:
2488 _mesa_error( ctx, GL_INVALID_ENUM, "glGetDoublev" );
2489 }
2490 }
2491
2492
2493
2494
2495 void
2496 _mesa_GetFloatv( GLenum pname, GLfloat *params )
2497 {
2498 GET_CURRENT_CONTEXT(ctx);
2499 GLuint i;
2500 GLuint texUnit = ctx->Texture.CurrentUnit;
2501 GLuint texTransformUnit = ctx->Texture.CurrentTransformUnit;
2502 const struct gl_texture_unit *textureUnit = &ctx->Texture.Unit[texUnit];
2503 ASSERT_OUTSIDE_BEGIN_END(ctx);
2504
2505 if (!params)
2506 return;
2507
2508 /* We need this in order to get correct results for
2509 * GL_OCCLUSION_TEST_RESULT_HP. There might be other important cases.
2510 */
2511 FLUSH_VERTICES(ctx, 0);
2512
2513 if (MESA_VERBOSE & VERBOSE_API)
2514 fprintf(stderr, "glGetFloatv %s\n", _mesa_lookup_enum_by_nr(pname));
2515
2516 if (ctx->Driver.GetFloatv && (*ctx->Driver.GetFloatv)(ctx, pname, params))
2517 return;
2518
2519 switch (pname) {
2520 case GL_ACCUM_RED_BITS:
2521 *params = (GLfloat) ctx->Visual.accumRedBits;
2522 break;
2523 case GL_ACCUM_GREEN_BITS:
2524 *params = (GLfloat) ctx->Visual.accumGreenBits;
2525 break;
2526 case GL_ACCUM_BLUE_BITS:
2527 *params = (GLfloat) ctx->Visual.accumBlueBits;
2528 break;
2529 case GL_ACCUM_ALPHA_BITS:
2530 *params = (GLfloat) ctx->Visual.accumAlphaBits;
2531 break;
2532 case GL_ACCUM_CLEAR_VALUE:
2533 params[0] = ctx->Accum.ClearColor[0];
2534 params[1] = ctx->Accum.ClearColor[1];
2535 params[2] = ctx->Accum.ClearColor[2];
2536 params[3] = ctx->Accum.ClearColor[3];
2537 break;
2538 case GL_ALPHA_BIAS:
2539 *params = ctx->Pixel.AlphaBias;
2540 break;
2541 case GL_ALPHA_BITS:
2542 *params = (GLfloat) ctx->Visual.alphaBits;
2543 break;
2544 case GL_ALPHA_SCALE:
2545 *params = ctx->Pixel.AlphaScale;
2546 break;
2547 case GL_ALPHA_TEST:
2548 *params = (GLfloat) ctx->Color.AlphaEnabled;
2549 break;
2550 case GL_ALPHA_TEST_FUNC:
2551 *params = ENUM_TO_FLOAT(ctx->Color.AlphaFunc);
2552 break;
2553 case GL_ALPHA_TEST_REF:
2554 *params = (GLfloat) ctx->Color.AlphaRef / CHAN_MAXF;
2555 break;
2556 case GL_ATTRIB_STACK_DEPTH:
2557 *params = (GLfloat) (ctx->AttribStackDepth);
2558 break;
2559 case GL_AUTO_NORMAL:
2560 *params = (GLfloat) ctx->Eval.AutoNormal;
2561 break;
2562 case GL_AUX_BUFFERS:
2563 *params = (GLfloat) ctx->Const.NumAuxBuffers;
2564 break;
2565 case GL_BLEND:
2566 *params = (GLfloat) ctx->Color.BlendEnabled;
2567 break;
2568 case GL_BLEND_DST:
2569 *params = ENUM_TO_FLOAT(ctx->Color.BlendDstRGB);
2570 break;
2571 case GL_BLEND_SRC:
2572 *params = ENUM_TO_FLOAT(ctx->Color.BlendSrcRGB);
2573 break;
2574 case GL_BLEND_SRC_RGB_EXT:
2575 *params = ENUM_TO_FLOAT(ctx->Color.BlendSrcRGB);
2576 break;
2577 case GL_BLEND_DST_RGB_EXT:
2578 *params = ENUM_TO_FLOAT(ctx->Color.BlendDstRGB);
2579 break;
2580 case GL_BLEND_SRC_ALPHA_EXT:
2581 *params = ENUM_TO_FLOAT(ctx->Color.BlendSrcA);
2582 break;
2583 case GL_BLEND_DST_ALPHA_EXT:
2584 *params = ENUM_TO_FLOAT(ctx->Color.BlendDstA);
2585 break;
2586 case GL_BLEND_EQUATION_EXT:
2587 *params = ENUM_TO_FLOAT(ctx->Color.BlendEquation);
2588 break;
2589 case GL_BLEND_COLOR_EXT:
2590 params[0] = ctx->Color.BlendColor[0];
2591 params[1] = ctx->Color.BlendColor[1];
2592 params[2] = ctx->Color.BlendColor[2];
2593 params[3] = ctx->Color.BlendColor[3];
2594 break;
2595 case GL_BLUE_BIAS:
2596 *params = ctx->Pixel.BlueBias;
2597 break;
2598 case GL_BLUE_BITS:
2599 *params = (GLfloat) ctx->Visual.blueBits;
2600 break;
2601 case GL_BLUE_SCALE:
2602 *params = ctx->Pixel.BlueScale;
2603 break;
2604 case GL_CLIENT_ATTRIB_STACK_DEPTH:
2605 *params = (GLfloat) (ctx->ClientAttribStackDepth);
2606 break;
2607 case GL_CLIP_PLANE0:
2608 case GL_CLIP_PLANE1:
2609 case GL_CLIP_PLANE2:
2610 case GL_CLIP_PLANE3:
2611 case GL_CLIP_PLANE4:
2612 case GL_CLIP_PLANE5:
2613 *params = (GLfloat) ctx->Transform.ClipEnabled[pname-GL_CLIP_PLANE0];
2614 break;
2615 case GL_COLOR_CLEAR_VALUE:
2616 params[0] = CHAN_TO_FLOAT(ctx->Color.ClearColor[0]);
2617 params[1] = CHAN_TO_FLOAT(ctx->Color.ClearColor[1]);
2618 params[2] = CHAN_TO_FLOAT(ctx->Color.ClearColor[2]);
2619 params[3] = CHAN_TO_FLOAT(ctx->Color.ClearColor[3]);
2620 break;
2621 case GL_COLOR_MATERIAL:
2622 *params = (GLfloat) ctx->Light.ColorMaterialEnabled;
2623 break;
2624 case GL_COLOR_MATERIAL_FACE:
2625 *params = ENUM_TO_FLOAT(ctx->Light.ColorMaterialFace);
2626 break;
2627 case GL_COLOR_MATERIAL_PARAMETER:
2628 *params = ENUM_TO_FLOAT(ctx->Light.ColorMaterialMode);
2629 break;
2630 case GL_COLOR_WRITEMASK:
2631 params[0] = ctx->Color.ColorMask[RCOMP] ? 1.0F : 0.0F;
2632 params[1] = ctx->Color.ColorMask[GCOMP] ? 1.0F : 0.0F;
2633 params[2] = ctx->Color.ColorMask[BCOMP] ? 1.0F : 0.0F;
2634 params[3] = ctx->Color.ColorMask[ACOMP] ? 1.0F : 0.0F;
2635 break;
2636 case GL_CULL_FACE:
2637 *params = (GLfloat) ctx->Polygon.CullFlag;
2638 break;
2639 case GL_CULL_FACE_MODE:
2640 *params = ENUM_TO_FLOAT(ctx->Polygon.CullFaceMode);
2641 break;
2642 case GL_CURRENT_COLOR:
2643 FLUSH_CURRENT(ctx, 0);
2644 params[0] = (ctx->Current.Color[0]);
2645 params[1] = (ctx->Current.Color[1]);
2646 params[2] = (ctx->Current.Color[2]);
2647 params[3] = (ctx->Current.Color[3]);
2648 break;
2649 case GL_CURRENT_INDEX:
2650 FLUSH_CURRENT(ctx, 0);
2651 *params = (GLfloat) ctx->Current.Index;
2652 break;
2653 case GL_CURRENT_NORMAL:
2654 FLUSH_CURRENT(ctx, 0);
2655 params[0] = ctx->Current.Normal[0];
2656 params[1] = ctx->Current.Normal[1];
2657 params[2] = ctx->Current.Normal[2];
2658 break;
2659 case GL_CURRENT_RASTER_COLOR:
2660 params[0] = ctx->Current.RasterColor[0];
2661 params[1] = ctx->Current.RasterColor[1];
2662 params[2] = ctx->Current.RasterColor[2];
2663 params[3] = ctx->Current.RasterColor[3];
2664 break;
2665 case GL_CURRENT_RASTER_DISTANCE:
2666 params[0] = ctx->Current.RasterDistance;
2667 break;
2668 case GL_CURRENT_RASTER_INDEX:
2669 *params = (GLfloat) ctx->Current.RasterIndex;
2670 break;
2671 case GL_CURRENT_RASTER_POSITION:
2672 params[0] = ctx->Current.RasterPos[0];
2673 params[1] = ctx->Current.RasterPos[1];
2674 params[2] = ctx->Current.RasterPos[2];
2675 params[3] = ctx->Current.RasterPos[3];
2676 break;
2677 case GL_CURRENT_RASTER_TEXTURE_COORDS:
2678 params[0] = ctx->Current.RasterMultiTexCoord[texTransformUnit][0];
2679 params[1] = ctx->Current.RasterMultiTexCoord[texTransformUnit][1];
2680 params[2] = ctx->Current.RasterMultiTexCoord[texTransformUnit][2];
2681 params[3] = ctx->Current.RasterMultiTexCoord[texTransformUnit][3];
2682 break;
2683 case GL_CURRENT_RASTER_POSITION_VALID:
2684 *params = (GLfloat) ctx->Current.RasterPosValid;
2685 break;
2686 case GL_CURRENT_TEXTURE_COORDS:
2687 FLUSH_CURRENT(ctx, 0);
2688 params[0] = (GLfloat) ctx->Current.Texcoord[texTransformUnit][0];
2689 params[1] = (GLfloat) ctx->Current.Texcoord[texTransformUnit][1];
2690 params[2] = (GLfloat) ctx->Current.Texcoord[texTransformUnit][2];
2691 params[3] = (GLfloat) ctx->Current.Texcoord[texTransformUnit][3];
2692 break;
2693 case GL_DEPTH_BIAS:
2694 *params = (GLfloat) ctx->Pixel.DepthBias;
2695 break;
2696 case GL_DEPTH_BITS:
2697 *params = (GLfloat) ctx->Visual.depthBits;
2698 break;
2699 case GL_DEPTH_CLEAR_VALUE:
2700 *params = (GLfloat) ctx->Depth.Clear;
2701 break;
2702 case GL_DEPTH_FUNC:
2703 *params = ENUM_TO_FLOAT(ctx->Depth.Func);
2704 break;
2705 case GL_DEPTH_RANGE:
2706 params[0] = (GLfloat) ctx->Viewport.Near;
2707 params[1] = (GLfloat) ctx->Viewport.Far;
2708 break;
2709 case GL_DEPTH_SCALE:
2710 *params = (GLfloat) ctx->Pixel.DepthScale;
2711 break;
2712 case GL_DEPTH_TEST:
2713 *params = (GLfloat) ctx->Depth.Test;
2714 break;
2715 case GL_DEPTH_WRITEMASK:
2716 *params = (GLfloat) ctx->Depth.Mask;
2717 break;
2718 case GL_DITHER:
2719 *params = (GLfloat) ctx->Color.DitherFlag;
2720 break;
2721 case GL_DOUBLEBUFFER:
2722 *params = (GLfloat) ctx->Visual.doubleBufferMode;
2723 break;
2724 case GL_DRAW_BUFFER:
2725 *params = ENUM_TO_FLOAT(ctx->Color.DrawBuffer);
2726 break;
2727 case GL_EDGE_FLAG:
2728 FLUSH_CURRENT(ctx, 0);
2729 *params = (GLfloat) ctx->Current.EdgeFlag;
2730 break;
2731 case GL_FEEDBACK_BUFFER_SIZE:
2732 *params = (GLfloat) ctx->Feedback.BufferSize;
2733 break;
2734 case GL_FEEDBACK_BUFFER_TYPE:
2735 *params = ENUM_TO_FLOAT(ctx->Feedback.Type);
2736 break;
2737 case GL_FOG:
2738 *params = (GLfloat) ctx->Fog.Enabled;
2739 break;
2740 case GL_FOG_COLOR:
2741 params[0] = ctx->Fog.Color[0];
2742 params[1] = ctx->Fog.Color[1];
2743 params[2] = ctx->Fog.Color[2];
2744 params[3] = ctx->Fog.Color[3];
2745 break;
2746 case GL_FOG_DENSITY:
2747 *params = ctx->Fog.Density;
2748 break;
2749 case GL_FOG_END:
2750 *params = ctx->Fog.End;
2751 break;
2752 case GL_FOG_HINT:
2753 *params = ENUM_TO_FLOAT(ctx->Hint.Fog);
2754 break;
2755 case GL_FOG_INDEX:
2756 *params = ctx->Fog.Index;
2757 break;
2758 case GL_FOG_MODE:
2759 *params = ENUM_TO_FLOAT(ctx->Fog.Mode);
2760 break;
2761 case GL_FOG_START:
2762 *params = ctx->Fog.Start;
2763 break;
2764 case GL_FRONT_FACE:
2765 *params = ENUM_TO_FLOAT(ctx->Polygon.FrontFace);
2766 break;
2767 case GL_GREEN_BIAS:
2768 *params = (GLfloat) ctx->Pixel.GreenBias;
2769 break;
2770 case GL_GREEN_BITS:
2771 *params = (GLfloat) ctx->Visual.greenBits;
2772 break;
2773 case GL_GREEN_SCALE:
2774 *params = (GLfloat) ctx->Pixel.GreenScale;
2775 break;
2776 case GL_HISTOGRAM:
2777 if (ctx->Extensions.EXT_histogram || ctx->Extensions.ARB_imaging) {
2778 *params = (GLfloat) ctx->Pixel.HistogramEnabled;
2779 }
2780 else {
2781 _mesa_error(ctx, GL_INVALID_ENUM, "glGetFloatv");
2782 return;
2783 }
2784 break;
2785 case GL_INDEX_BITS:
2786 *params = (GLfloat) ctx->Visual.indexBits;
2787 break;
2788 case GL_INDEX_CLEAR_VALUE:
2789 *params = (GLfloat) ctx->Color.ClearIndex;
2790 break;
2791 case GL_INDEX_MODE:
2792 *params = ctx->Visual.rgbMode ? 0.0F : 1.0F;
2793 break;
2794 case GL_INDEX_OFFSET:
2795 *params = (GLfloat) ctx->Pixel.IndexOffset;
2796 break;
2797 case GL_INDEX_SHIFT:
2798 *params = (GLfloat) ctx->Pixel.IndexShift;
2799 break;
2800 case GL_INDEX_WRITEMASK:
2801 *params = (GLfloat) ctx->Color.IndexMask;
2802 break;
2803 case GL_LIGHT0:
2804 case GL_LIGHT1:
2805 case GL_LIGHT2:
2806 case GL_LIGHT3:
2807 case GL_LIGHT4:
2808 case GL_LIGHT5:
2809 case GL_LIGHT6:
2810 case GL_LIGHT7:
2811 *params = (GLfloat) ctx->Light.Light[pname-GL_LIGHT0].Enabled;
2812 break;
2813 case GL_LIGHTING:
2814 *params = (GLfloat) ctx->Light.Enabled;
2815 break;
2816 case GL_LIGHT_MODEL_AMBIENT:
2817 params[0] = ctx->Light.Model.Ambient[0];
2818 params[1] = ctx->Light.Model.Ambient[1];
2819 params[2] = ctx->Light.Model.Ambient[2];
2820 params[3] = ctx->Light.Model.Ambient[3];
2821 break;
2822 case GL_LIGHT_MODEL_COLOR_CONTROL:
2823 params[0] = ENUM_TO_FLOAT(ctx->Light.Model.ColorControl);
2824 break;
2825 case GL_LIGHT_MODEL_LOCAL_VIEWER:
2826 *params = (GLfloat) ctx->Light.Model.LocalViewer;
2827 break;
2828 case GL_LIGHT_MODEL_TWO_SIDE:
2829 *params = (GLfloat) ctx->Light.Model.TwoSide;
2830 break;
2831 case GL_LINE_SMOOTH:
2832 *params = (GLfloat) ctx->Line.SmoothFlag;
2833 break;
2834 case GL_LINE_SMOOTH_HINT:
2835 *params = ENUM_TO_FLOAT(ctx->Hint.LineSmooth);
2836 break;
2837 case GL_LINE_STIPPLE:
2838 *params = (GLfloat) ctx->Line.StippleFlag;
2839 break;
2840 case GL_LINE_STIPPLE_PATTERN:
2841 *params = (GLfloat) ctx->Line.StipplePattern;
2842 break;
2843 case GL_LINE_STIPPLE_REPEAT:
2844 *params = (GLfloat) ctx->Line.StippleFactor;
2845 break;
2846 case GL_LINE_WIDTH:
2847 *params = (GLfloat) ctx->Line.Width;
2848 break;
2849 case GL_LINE_WIDTH_GRANULARITY:
2850 *params = (GLfloat) ctx->Const.LineWidthGranularity;
2851 break;
2852 case GL_LINE_WIDTH_RANGE:
2853 params[0] = (GLfloat) ctx->Const.MinLineWidthAA;
2854 params[1] = (GLfloat) ctx->Const.MaxLineWidthAA;
2855 break;
2856 case GL_ALIASED_LINE_WIDTH_RANGE:
2857 params[0] = (GLfloat) ctx->Const.MinLineWidth;
2858 params[1] = (GLfloat) ctx->Const.MaxLineWidth;
2859 break;
2860 case GL_LIST_BASE:
2861 *params = (GLfloat) ctx->List.ListBase;
2862 break;
2863 case GL_LIST_INDEX:
2864 *params = (GLfloat) ctx->CurrentListNum;
2865 break;
2866 case GL_LIST_MODE:
2867 *params = ctx->ExecuteFlag ? ENUM_TO_FLOAT(GL_COMPILE_AND_EXECUTE)
2868 : ENUM_TO_FLOAT(GL_COMPILE);
2869 break;
2870 case GL_INDEX_LOGIC_OP:
2871 *params = (GLfloat) ctx->Color.IndexLogicOpEnabled;
2872 break;
2873 case GL_COLOR_LOGIC_OP:
2874 *params = (GLfloat) ctx->Color.ColorLogicOpEnabled;
2875 break;
2876 case GL_LOGIC_OP_MODE:
2877 *params = ENUM_TO_FLOAT(ctx->Color.LogicOp);
2878 break;
2879 case GL_MAP1_COLOR_4:
2880 *params = (GLfloat) ctx->Eval.Map1Color4;
2881 break;
2882 case GL_MAP1_GRID_DOMAIN:
2883 params[0] = ctx->Eval.MapGrid1u1;
2884 params[1] = ctx->Eval.MapGrid1u2;
2885 break;
2886 case GL_MAP1_GRID_SEGMENTS:
2887 *params = (GLfloat) ctx->Eval.MapGrid1un;
2888 break;
2889 case GL_MAP1_INDEX:
2890 *params = (GLfloat) ctx->Eval.Map1Index;
2891 break;
2892 case GL_MAP1_NORMAL:
2893 *params = (GLfloat) ctx->Eval.Map1Normal;
2894 break;
2895 case GL_MAP1_TEXTURE_COORD_1:
2896 *params = (GLfloat) ctx->Eval.Map1TextureCoord1;
2897 break;
2898 case GL_MAP1_TEXTURE_COORD_2:
2899 *params = (GLfloat) ctx->Eval.Map1TextureCoord2;
2900 break;
2901 case GL_MAP1_TEXTURE_COORD_3:
2902 *params = (GLfloat) ctx->Eval.Map1TextureCoord3;
2903 break;
2904 case GL_MAP1_TEXTURE_COORD_4:
2905 *params = (GLfloat) ctx->Eval.Map1TextureCoord4;
2906 break;
2907 case GL_MAP1_VERTEX_3:
2908 *params = (GLfloat) ctx->Eval.Map1Vertex3;
2909 break;
2910 case GL_MAP1_VERTEX_4:
2911 *params = (GLfloat) ctx->Eval.Map1Vertex4;
2912 break;
2913 case GL_MAP2_COLOR_4:
2914 *params = (GLfloat) ctx->Eval.Map2Color4;
2915 break;
2916 case GL_MAP2_GRID_DOMAIN:
2917 params[0] = ctx->Eval.MapGrid2u1;
2918 params[1] = ctx->Eval.MapGrid2u2;
2919 params[2] = ctx->Eval.MapGrid2v1;
2920 params[3] = ctx->Eval.MapGrid2v2;
2921 break;
2922 case GL_MAP2_GRID_SEGMENTS:
2923 params[0] = (GLfloat) ctx->Eval.MapGrid2un;
2924 params[1] = (GLfloat) ctx->Eval.MapGrid2vn;
2925 break;
2926 case GL_MAP2_INDEX:
2927 *params = (GLfloat) ctx->Eval.Map2Index;
2928 break;
2929 case GL_MAP2_NORMAL:
2930 *params = (GLfloat) ctx->Eval.Map2Normal;
2931 break;
2932 case GL_MAP2_TEXTURE_COORD_1:
2933 *params = ctx->Eval.Map2TextureCoord1;
2934 break;
2935 case GL_MAP2_TEXTURE_COORD_2:
2936 *params = ctx->Eval.Map2TextureCoord2;
2937 break;
2938 case GL_MAP2_TEXTURE_COORD_3:
2939 *params = ctx->Eval.Map2TextureCoord3;
2940 break;
2941 case GL_MAP2_TEXTURE_COORD_4:
2942 *params = ctx->Eval.Map2TextureCoord4;
2943 break;
2944 case GL_MAP2_VERTEX_3:
2945 *params = (GLfloat) ctx->Eval.Map2Vertex3;
2946 break;
2947 case GL_MAP2_VERTEX_4:
2948 *params = (GLfloat) ctx->Eval.Map2Vertex4;
2949 break;
2950 case GL_MAP_COLOR:
2951 *params = (GLfloat) ctx->Pixel.MapColorFlag;
2952 break;
2953 case GL_MAP_STENCIL:
2954 *params = (GLfloat) ctx->Pixel.MapStencilFlag;
2955 break;
2956 case GL_MATRIX_MODE:
2957 *params = ENUM_TO_FLOAT(ctx->Transform.MatrixMode);
2958 break;
2959 case GL_MAX_ATTRIB_STACK_DEPTH:
2960 *params = (GLfloat) MAX_ATTRIB_STACK_DEPTH;
2961 break;
2962 case GL_MAX_CLIENT_ATTRIB_STACK_DEPTH:
2963 *params = (GLfloat) MAX_CLIENT_ATTRIB_STACK_DEPTH;
2964 break;
2965 case GL_MAX_CLIP_PLANES:
2966 *params = (GLfloat) ctx->Const.MaxClipPlanes;
2967 break;
2968 case GL_MAX_ELEMENTS_VERTICES: /* GL_VERSION_1_2 */
2969 *params = (GLfloat) ctx->Const.MaxArrayLockSize;
2970 break;
2971 case GL_MAX_ELEMENTS_INDICES: /* GL_VERSION_1_2 */
2972 *params = (GLfloat) ctx->Const.MaxArrayLockSize;
2973 break;
2974 case GL_MAX_EVAL_ORDER:
2975 *params = (GLfloat) MAX_EVAL_ORDER;
2976 break;
2977 case GL_MAX_LIGHTS:
2978 *params = (GLfloat) ctx->Const.MaxLights;
2979 break;
2980 case GL_MAX_LIST_NESTING:
2981 *params = (GLfloat) MAX_LIST_NESTING;
2982 break;
2983 case GL_MAX_MODELVIEW_STACK_DEPTH:
2984 *params = (GLfloat) MAX_MODELVIEW_STACK_DEPTH;
2985 break;
2986 case GL_MAX_NAME_STACK_DEPTH:
2987 *params = (GLfloat) MAX_NAME_STACK_DEPTH;
2988 break;
2989 case GL_MAX_PIXEL_MAP_TABLE:
2990 *params = (GLfloat) MAX_PIXEL_MAP_TABLE;
2991 break;
2992 case GL_MAX_PROJECTION_STACK_DEPTH:
2993 *params = (GLfloat) MAX_PROJECTION_STACK_DEPTH;
2994 break;
2995 case GL_MAX_TEXTURE_SIZE:
2996 case GL_MAX_3D_TEXTURE_SIZE:
2997 *params = (GLfloat) ctx->Const.MaxTextureSize;
2998 break;
2999 case GL_MAX_TEXTURE_STACK_DEPTH:
3000 *params = (GLfloat) MAX_TEXTURE_STACK_DEPTH;
3001 break;
3002 case GL_MAX_VIEWPORT_DIMS:
3003 params[0] = (GLfloat) MAX_WIDTH;
3004 params[1] = (GLfloat) MAX_HEIGHT;
3005 break;
3006 case GL_MINMAX:
3007 *params = (GLfloat) ctx->Pixel.MinMaxEnabled;
3008 break;
3009 case GL_MODELVIEW_MATRIX:
3010 for (i=0;i<16;i++) {
3011 params[i] = ctx->ModelView.m[i];
3012 }
3013 break;
3014 case GL_MODELVIEW_STACK_DEPTH:
3015 *params = (GLfloat) (ctx->ModelViewStackDepth + 1);
3016 break;
3017 case GL_NAME_STACK_DEPTH:
3018 *params = (GLfloat) ctx->Select.NameStackDepth;
3019 break;
3020 case GL_NORMALIZE:
3021 *params = (GLfloat) ctx->Transform.Normalize;
3022 break;
3023 case GL_PACK_ALIGNMENT:
3024 *params = (GLfloat) ctx->Pack.Alignment;
3025 break;
3026 case GL_PACK_LSB_FIRST:
3027 *params = (GLfloat) ctx->Pack.LsbFirst;
3028 break;
3029 case GL_PACK_ROW_LENGTH:
3030 *params = (GLfloat) ctx->Pack.RowLength;
3031 break;
3032 case GL_PACK_SKIP_PIXELS:
3033 *params = (GLfloat) ctx->Pack.SkipPixels;
3034 break;
3035 case GL_PACK_SKIP_ROWS:
3036 *params = (GLfloat) ctx->Pack.SkipRows;
3037 break;
3038 case GL_PACK_SWAP_BYTES:
3039 *params = (GLfloat) ctx->Pack.SwapBytes;
3040 break;
3041 case GL_PACK_SKIP_IMAGES_EXT:
3042 *params = (GLfloat) ctx->Pack.SkipImages;
3043 break;
3044 case GL_PACK_IMAGE_HEIGHT_EXT:
3045 *params = (GLfloat) ctx->Pack.ImageHeight;
3046 break;
3047 case GL_PERSPECTIVE_CORRECTION_HINT:
3048 *params = ENUM_TO_FLOAT(ctx->Hint.PerspectiveCorrection);
3049 break;
3050 case GL_PIXEL_MAP_A_TO_A_SIZE:
3051 *params = (GLfloat) ctx->Pixel.MapAtoAsize;
3052 break;
3053 case GL_PIXEL_MAP_B_TO_B_SIZE:
3054 *params = (GLfloat) ctx->Pixel.MapBtoBsize;
3055 break;
3056 case GL_PIXEL_MAP_G_TO_G_SIZE:
3057 *params = (GLfloat) ctx->Pixel.MapGtoGsize;
3058 break;
3059 case GL_PIXEL_MAP_I_TO_A_SIZE:
3060 *params = (GLfloat) ctx->Pixel.MapItoAsize;
3061 break;
3062 case GL_PIXEL_MAP_I_TO_B_SIZE:
3063 *params = (GLfloat) ctx->Pixel.MapItoBsize;
3064 break;
3065 case GL_PIXEL_MAP_I_TO_G_SIZE:
3066 *params = (GLfloat) ctx->Pixel.MapItoGsize;
3067 break;
3068 case GL_PIXEL_MAP_I_TO_I_SIZE:
3069 *params = (GLfloat) ctx->Pixel.MapItoIsize;
3070 break;
3071 case GL_PIXEL_MAP_I_TO_R_SIZE:
3072 *params = (GLfloat) ctx->Pixel.MapItoRsize;
3073 break;
3074 case GL_PIXEL_MAP_R_TO_R_SIZE:
3075 *params = (GLfloat) ctx->Pixel.MapRtoRsize;
3076 break;
3077 case GL_PIXEL_MAP_S_TO_S_SIZE:
3078 *params = (GLfloat) ctx->Pixel.MapStoSsize;
3079 break;
3080 case GL_POINT_SIZE:
3081 *params = (GLfloat) ctx->Point.Size;
3082 break;
3083 case GL_POINT_SIZE_GRANULARITY:
3084 *params = (GLfloat) ctx->Const.PointSizeGranularity;
3085 break;
3086 case GL_POINT_SIZE_RANGE:
3087 params[0] = (GLfloat) ctx->Const.MinPointSizeAA;
3088 params[1] = (GLfloat) ctx->Const.MaxPointSizeAA;
3089 break;
3090 case GL_ALIASED_POINT_SIZE_RANGE:
3091 params[0] = (GLfloat) ctx->Const.MinPointSize;
3092 params[1] = (GLfloat) ctx->Const.MaxPointSize;
3093 break;
3094 case GL_POINT_SMOOTH:
3095 *params = (GLfloat) ctx->Point.SmoothFlag;
3096 break;
3097 case GL_POINT_SMOOTH_HINT:
3098 *params = ENUM_TO_FLOAT(ctx->Hint.PointSmooth);
3099 break;
3100 case GL_POINT_SIZE_MIN_EXT:
3101 *params = (GLfloat) (ctx->Point.MinSize);
3102 break;
3103 case GL_POINT_SIZE_MAX_EXT:
3104 *params = (GLfloat) (ctx->Point.MaxSize);
3105 break;
3106 case GL_POINT_FADE_THRESHOLD_SIZE_EXT:
3107 *params = (GLfloat) (ctx->Point.Threshold);
3108 break;
3109 case GL_DISTANCE_ATTENUATION_EXT:
3110 params[0] = (GLfloat) (ctx->Point.Params[0]);
3111 params[1] = (GLfloat) (ctx->Point.Params[1]);
3112 params[2] = (GLfloat) (ctx->Point.Params[2]);
3113 break;
3114 case GL_POLYGON_MODE:
3115 params[0] = ENUM_TO_FLOAT(ctx->Polygon.FrontMode);
3116 params[1] = ENUM_TO_FLOAT(ctx->Polygon.BackMode);
3117 break;
3118 #ifdef GL_EXT_polygon_offset
3119 case GL_POLYGON_OFFSET_BIAS_EXT:
3120 *params = ctx->Polygon.OffsetUnits;
3121 break;
3122 #endif
3123 case GL_POLYGON_OFFSET_FACTOR:
3124 *params = ctx->Polygon.OffsetFactor;
3125 break;
3126 case GL_POLYGON_OFFSET_UNITS:
3127 *params = ctx->Polygon.OffsetUnits;
3128 break;
3129 case GL_POLYGON_SMOOTH:
3130 *params = (GLfloat) ctx->Polygon.SmoothFlag;
3131 break;
3132 case GL_POLYGON_SMOOTH_HINT:
3133 *params = ENUM_TO_FLOAT(ctx->Hint.PolygonSmooth);
3134 break;
3135 case GL_POLYGON_STIPPLE:
3136 *params = (GLfloat) ctx->Polygon.StippleFlag;
3137 break;
3138 case GL_PROJECTION_MATRIX:
3139 for (i=0;i<16;i++) {
3140 params[i] = ctx->ProjectionMatrix.m[i];
3141 }
3142 break;
3143 case GL_PROJECTION_STACK_DEPTH:
3144 *params = (GLfloat) (ctx->ProjectionStackDepth + 1);
3145 break;
3146 case GL_READ_BUFFER:
3147 *params = ENUM_TO_FLOAT(ctx->Pixel.ReadBuffer);
3148 break;
3149 case GL_RED_BIAS:
3150 *params = ctx->Pixel.RedBias;
3151 break;
3152 case GL_RED_BITS:
3153 *params = (GLfloat) ctx->Visual.redBits;
3154 break;
3155 case GL_RED_SCALE:
3156 *params = ctx->Pixel.RedScale;
3157 break;
3158 case GL_RENDER_MODE:
3159 *params = ENUM_TO_FLOAT(ctx->RenderMode);
3160 break;
3161 case GL_RESCALE_NORMAL:
3162 *params = (GLfloat) ctx->Transform.RescaleNormals;
3163 break;
3164 case GL_RGBA_MODE:
3165 *params = (GLfloat) ctx->Visual.rgbMode;
3166 break;
3167 case GL_SCISSOR_BOX:
3168 params[0] = (GLfloat) ctx->Scissor.X;
3169 params[1] = (GLfloat) ctx->Scissor.Y;
3170 params[2] = (GLfloat) ctx->Scissor.Width;
3171 params[3] = (GLfloat) ctx->Scissor.Height;
3172 break;
3173 case GL_SCISSOR_TEST:
3174 *params = (GLfloat) ctx->Scissor.Enabled;
3175 break;
3176 case GL_SELECTION_BUFFER_SIZE:
3177 *params = (GLfloat) ctx->Select.BufferSize;
3178 break;
3179 case GL_SHADE_MODEL:
3180 *params = ENUM_TO_FLOAT(ctx->Light.ShadeModel);
3181 break;
3182 case GL_SHARED_TEXTURE_PALETTE_EXT:
3183 *params = (GLfloat) ctx->Texture.SharedPalette;
3184 break;
3185 case GL_STENCIL_BITS:
3186 *params = (GLfloat) ctx->Visual.stencilBits;
3187 break;
3188 case GL_STENCIL_CLEAR_VALUE:
3189 *params = (GLfloat) ctx->Stencil.Clear;
3190 break;
3191 case GL_STENCIL_FAIL:
3192 *params = ENUM_TO_FLOAT(ctx->Stencil.FailFunc);
3193 break;
3194 case GL_STENCIL_FUNC:
3195 *params = ENUM_TO_FLOAT(ctx->Stencil.Function);
3196 break;
3197 case GL_STENCIL_PASS_DEPTH_FAIL:
3198 *params = ENUM_TO_FLOAT(ctx->Stencil.ZFailFunc);
3199 break;
3200 case GL_STENCIL_PASS_DEPTH_PASS:
3201 *params = ENUM_TO_FLOAT(ctx->Stencil.ZPassFunc);
3202 break;
3203 case GL_STENCIL_REF:
3204 *params = (GLfloat) ctx->Stencil.Ref;
3205 break;
3206 case GL_STENCIL_TEST:
3207 *params = (GLfloat) ctx->Stencil.Enabled;
3208 break;
3209 case GL_STENCIL_VALUE_MASK:
3210 *params = (GLfloat) ctx->Stencil.ValueMask;
3211 break;
3212 case GL_STENCIL_WRITEMASK:
3213 *params = (GLfloat) ctx->Stencil.WriteMask;
3214 break;
3215 case GL_STEREO:
3216 *params = (GLfloat) ctx->Visual.stereoMode;
3217 break;
3218 case GL_SUBPIXEL_BITS:
3219 *params = (GLfloat) ctx->Const.SubPixelBits;
3220 break;
3221 case GL_TEXTURE_1D:
3222 *params = _mesa_IsEnabled(GL_TEXTURE_1D) ? 1.0 : 0.0;
3223 break;
3224 case GL_TEXTURE_2D:
3225 *params = _mesa_IsEnabled(GL_TEXTURE_2D) ? 1.0 : 0.0;
3226 break;
3227 case GL_TEXTURE_3D:
3228 *params = _mesa_IsEnabled(GL_TEXTURE_3D) ? 1.0 : 0.0;
3229 break;
3230 case GL_TEXTURE_BINDING_1D:
3231 *params = (GLfloat) textureUnit->Current1D->Name;
3232 break;
3233 case GL_TEXTURE_BINDING_2D:
3234 *params = (GLfloat) textureUnit->Current2D->Name;
3235 break;
3236 case GL_TEXTURE_BINDING_3D:
3237 *params = (GLfloat) textureUnit->Current2D->Name;
3238 break;
3239 case GL_TEXTURE_ENV_COLOR:
3240 params[0] = textureUnit->EnvColor[0];
3241 params[1] = textureUnit->EnvColor[1];
3242 params[2] = textureUnit->EnvColor[2];
3243 params[3] = textureUnit->EnvColor[3];
3244 break;
3245 case GL_TEXTURE_ENV_MODE:
3246 *params = ENUM_TO_FLOAT(textureUnit->EnvMode);
3247 break;
3248 case GL_TEXTURE_GEN_S:
3249 *params = (textureUnit->TexGenEnabled & S_BIT) ? 1.0 : 0.0;
3250 break;
3251 case GL_TEXTURE_GEN_T:
3252 *params = (textureUnit->TexGenEnabled & T_BIT) ? 1.0 : 0.0;
3253 break;
3254 case GL_TEXTURE_GEN_R:
3255 *params = (textureUnit->TexGenEnabled & R_BIT) ? 1.0 : 0.0;
3256 break;
3257 case GL_TEXTURE_GEN_Q:
3258 *params = (textureUnit->TexGenEnabled & Q_BIT) ? 1.0 : 0.0;
3259 break;
3260 case GL_TEXTURE_MATRIX:
3261 for (i=0;i<16;i++) {
3262 params[i] = ctx->TextureMatrix[texTransformUnit].m[i];
3263 }
3264 break;
3265 case GL_TEXTURE_STACK_DEPTH:
3266 *params = (GLfloat) (ctx->TextureStackDepth[texTransformUnit] + 1);
3267 break;
3268 case GL_UNPACK_ALIGNMENT:
3269 *params = (GLfloat) ctx->Unpack.Alignment;
3270 break;
3271 case GL_UNPACK_LSB_FIRST:
3272 *params = (GLfloat) ctx->Unpack.LsbFirst;
3273 break;
3274 case GL_UNPACK_ROW_LENGTH:
3275 *params = (GLfloat) ctx->Unpack.RowLength;
3276 break;
3277 case GL_UNPACK_SKIP_PIXELS:
3278 *params = (GLfloat) ctx->Unpack.SkipPixels;
3279 break;
3280 case GL_UNPACK_SKIP_ROWS:
3281 *params = (GLfloat) ctx->Unpack.SkipRows;
3282 break;
3283 case GL_UNPACK_SWAP_BYTES:
3284 *params = (GLfloat) ctx->Unpack.SwapBytes;
3285 break;
3286 case GL_UNPACK_SKIP_IMAGES_EXT:
3287 *params = (GLfloat) ctx->Unpack.SkipImages;
3288 break;
3289 case GL_UNPACK_IMAGE_HEIGHT_EXT:
3290 *params = (GLfloat) ctx->Unpack.ImageHeight;
3291 break;
3292 case GL_VIEWPORT:
3293 params[0] = (GLfloat) ctx->Viewport.X;
3294 params[1] = (GLfloat) ctx->Viewport.Y;
3295 params[2] = (GLfloat) ctx->Viewport.Width;
3296 params[3] = (GLfloat) ctx->Viewport.Height;
3297 break;
3298 case GL_ZOOM_X:
3299 *params = (GLfloat) ctx->Pixel.ZoomX;
3300 break;
3301 case GL_ZOOM_Y:
3302 *params = (GLfloat) ctx->Pixel.ZoomY;
3303 break;
3304 case GL_VERTEX_ARRAY:
3305 *params = (GLfloat) ctx->Array.Vertex.Enabled;
3306 break;
3307 case GL_VERTEX_ARRAY_SIZE:
3308 *params = (GLfloat) ctx->Array.Vertex.Size;
3309 break;
3310 case GL_VERTEX_ARRAY_TYPE:
3311 *params = ENUM_TO_FLOAT(ctx->Array.Vertex.Type);
3312 break;
3313 case GL_VERTEX_ARRAY_STRIDE:
3314 *params = (GLfloat) ctx->Array.Vertex.Stride;
3315 break;
3316 case GL_VERTEX_ARRAY_COUNT_EXT:
3317 *params = 0.0;
3318 break;
3319 case GL_NORMAL_ARRAY:
3320 *params = (GLfloat) ctx->Array.Normal.Enabled;
3321 break;
3322 case GL_NORMAL_ARRAY_TYPE:
3323 *params = ENUM_TO_FLOAT(ctx->Array.Normal.Type);
3324 break;
3325 case GL_NORMAL_ARRAY_STRIDE:
3326 *params = (GLfloat) ctx->Array.Normal.Stride;
3327 break;
3328 case GL_NORMAL_ARRAY_COUNT_EXT:
3329 *params = 0.0;
3330 break;
3331 case GL_COLOR_ARRAY:
3332 *params = (GLfloat) ctx->Array.Color.Enabled;
3333 break;
3334 case GL_COLOR_ARRAY_SIZE:
3335 *params = (GLfloat) ctx->Array.Color.Size;
3336 break;
3337 case GL_COLOR_ARRAY_TYPE:
3338 *params = ENUM_TO_FLOAT(ctx->Array.Color.Type);
3339 break;
3340 case GL_COLOR_ARRAY_STRIDE:
3341 *params = (GLfloat) ctx->Array.Color.Stride;
3342 break;
3343 case GL_COLOR_ARRAY_COUNT_EXT:
3344 *params = 0.0;
3345 break;
3346 case GL_INDEX_ARRAY:
3347 *params = (GLfloat) ctx->Array.Index.Enabled;
3348 break;
3349 case GL_INDEX_ARRAY_TYPE:
3350 *params = ENUM_TO_FLOAT(ctx->Array.Index.Type);
3351 break;
3352 case GL_INDEX_ARRAY_STRIDE:
3353 *params = (GLfloat) ctx->Array.Index.Stride;
3354 break;
3355 case GL_INDEX_ARRAY_COUNT_EXT:
3356 *params = 0.0;
3357 break;
3358 case GL_TEXTURE_COORD_ARRAY:
3359 *params = (GLfloat) ctx->Array.TexCoord[texUnit].Enabled;
3360 break;
3361 case GL_TEXTURE_COORD_ARRAY_SIZE:
3362 *params = (GLfloat) ctx->Array.TexCoord[texUnit].Size;
3363 break;
3364 case GL_TEXTURE_COORD_ARRAY_TYPE:
3365 *params = ENUM_TO_FLOAT(ctx->Array.TexCoord[texUnit].Type);
3366 break;
3367 case GL_TEXTURE_COORD_ARRAY_STRIDE:
3368 *params = (GLfloat) ctx->Array.TexCoord[texUnit].Stride;
3369 break;
3370 case GL_TEXTURE_COORD_ARRAY_COUNT_EXT:
3371 *params = 0.0;
3372 break;
3373 case GL_EDGE_FLAG_ARRAY:
3374 *params = (GLfloat) ctx->Array.EdgeFlag.Enabled;
3375 break;
3376 case GL_EDGE_FLAG_ARRAY_STRIDE:
3377 *params = (GLfloat) ctx->Array.EdgeFlag.Stride;
3378 break;
3379 case GL_EDGE_FLAG_ARRAY_COUNT_EXT:
3380 *params = 0.0;
3381 break;
3382
3383 /* GL_ARB_multitexture */
3384 case GL_MAX_TEXTURE_UNITS_ARB:
3385 *params = (GLfloat) ctx->Const.MaxTextureUnits;
3386 break;
3387 case GL_ACTIVE_TEXTURE_ARB:
3388 *params = (GLfloat) (GL_TEXTURE0_ARB + ctx->Texture.CurrentUnit);
3389 break;
3390 case GL_CLIENT_ACTIVE_TEXTURE_ARB:
3391 *params = (GLfloat) (GL_TEXTURE0_ARB + ctx->Array.ActiveTexture);
3392 break;
3393
3394 /* GL_ARB_texture_cube_map */
3395 case GL_TEXTURE_CUBE_MAP_ARB:
3396 if (ctx->Extensions.ARB_texture_cube_map)
3397 *params = (GLfloat) _mesa_IsEnabled(GL_TEXTURE_CUBE_MAP_ARB);
3398 else
3399 _mesa_error(ctx, GL_INVALID_ENUM, "glGetFloatv");
3400 return;
3401 case GL_TEXTURE_BINDING_CUBE_MAP_ARB:
3402 if (ctx->Extensions.ARB_texture_cube_map)
3403 *params = (GLfloat) textureUnit->CurrentCubeMap->Name;
3404 else
3405 _mesa_error(ctx, GL_INVALID_ENUM, "glGetFloatv");
3406 return;
3407 case GL_MAX_CUBE_MAP_TEXTURE_SIZE_ARB:
3408 if (ctx->Extensions.ARB_texture_cube_map)
3409 *params = (GLfloat) ctx->Const.MaxCubeTextureSize;
3410 else
3411 _mesa_error(ctx, GL_INVALID_ENUM, "glGetFloatv");
3412 return;
3413
3414 /* GL_ARB_texture_compression */
3415 case GL_TEXTURE_COMPRESSION_HINT_ARB:
3416 if (ctx->Extensions.ARB_texture_compression) {
3417 *params = (GLfloat) ctx->Hint.TextureCompression;
3418 }
3419 else
3420 _mesa_error(ctx, GL_INVALID_ENUM, "glGetFloatv");
3421 break;
3422 case GL_NUM_COMPRESSED_TEXTURE_FORMATS_ARB:
3423 if (ctx->Extensions.ARB_texture_compression) {
3424 *params = (GLfloat) ctx->Const.NumCompressedTextureFormats;
3425 }
3426 else
3427 _mesa_error(ctx, GL_INVALID_ENUM, "glGetFloatv");
3428 break;
3429 case GL_COMPRESSED_TEXTURE_FORMATS_ARB:
3430 if (ctx->Extensions.ARB_texture_compression) {
3431 GLuint i;
3432 for (i = 0; i < ctx->Const.NumCompressedTextureFormats; i++)
3433 params[i] = (GLfloat) ctx->Const.CompressedTextureFormats[i];
3434 }
3435 else
3436 _mesa_error(ctx, GL_INVALID_ENUM, "glGetFloatv");
3437 break;
3438
3439 /* GL_EXT_compiled_vertex_array */
3440 case GL_ARRAY_ELEMENT_LOCK_FIRST_EXT:
3441 *params = (GLfloat) ctx->Array.LockFirst;
3442 break;
3443 case GL_ARRAY_ELEMENT_LOCK_COUNT_EXT:
3444 *params = (GLfloat) ctx->Array.LockCount;
3445 break;
3446
3447 /* GL_ARB_transpose_matrix */
3448 case GL_TRANSPOSE_COLOR_MATRIX_ARB:
3449 _math_transposef(params, ctx->ColorMatrix.m);
3450 break;
3451 case GL_TRANSPOSE_MODELVIEW_MATRIX_ARB:
3452 _math_transposef(params, ctx->ModelView.m);
3453 break;
3454 case GL_TRANSPOSE_PROJECTION_MATRIX_ARB:
3455 _math_transposef(params, ctx->ProjectionMatrix.m);
3456 break;
3457 case GL_TRANSPOSE_TEXTURE_MATRIX_ARB:
3458 _math_transposef(params, ctx->TextureMatrix[texTransformUnit].m);
3459 break;
3460
3461 /* GL_HP_occlusion_test */
3462 case GL_OCCLUSION_TEST_HP:
3463 if (ctx->Extensions.HP_occlusion_test) {
3464 *params = (GLfloat) ctx->Depth.OcclusionTest;
3465 }
3466 else {
3467 _mesa_error( ctx, GL_INVALID_ENUM, "glGetFloatv" );
3468 }
3469 return;
3470 case GL_OCCLUSION_TEST_RESULT_HP:
3471 if (ctx->Extensions.HP_occlusion_test) {
3472 if (ctx->Depth.OcclusionTest)
3473 *params = (GLfloat) ctx->OcclusionResult;
3474 else
3475 *params = (GLfloat) ctx->OcclusionResultSaved;
3476 /* reset flag now */
3477 ctx->OcclusionResult = GL_FALSE;
3478 ctx->OcclusionResultSaved = GL_FALSE;
3479 }
3480 else {
3481 _mesa_error( ctx, GL_INVALID_ENUM, "glGetFloatv" );
3482 }
3483 return;
3484
3485 /* GL_SGIS_pixel_texture */
3486 case GL_PIXEL_TEXTURE_SGIS:
3487 *params = (GLfloat) ctx->Pixel.PixelTextureEnabled;
3488 break;
3489
3490 /* GL_SGIX_pixel_texture */
3491 case GL_PIXEL_TEX_GEN_SGIX:
3492 *params = (GLfloat) ctx->Pixel.PixelTextureEnabled;
3493 break;
3494 case GL_PIXEL_TEX_GEN_MODE_SGIX:
3495 *params = (GLfloat) pixel_texgen_mode(ctx);
3496 break;
3497
3498 /* GL_SGI_color_matrix (also in 1.2 imaging) */
3499 case GL_COLOR_MATRIX_SGI:
3500 for (i=0;i<16;i++) {
3501 params[i] = ctx->ColorMatrix.m[i];
3502 }
3503 break;
3504 case GL_COLOR_MATRIX_STACK_DEPTH_SGI:
3505 *params = (GLfloat) (ctx->ColorStackDepth + 1);
3506 break;
3507 case GL_MAX_COLOR_MATRIX_STACK_DEPTH_SGI:
3508 *params = (GLfloat) MAX_COLOR_STACK_DEPTH;
3509 break;
3510 case GL_POST_COLOR_MATRIX_RED_SCALE_SGI:
3511 *params = ctx->Pixel.PostColorMatrixScale[0];
3512 break;
3513 case GL_POST_COLOR_MATRIX_GREEN_SCALE_SGI:
3514 *params = ctx->Pixel.PostColorMatrixScale[1];
3515 break;
3516 case GL_POST_COLOR_MATRIX_BLUE_SCALE_SGI:
3517 *params = ctx->Pixel.PostColorMatrixScale[2];
3518 break;
3519 case GL_POST_COLOR_MATRIX_ALPHA_SCALE_SGI:
3520 *params = ctx->Pixel.PostColorMatrixScale[3];
3521 break;
3522 case GL_POST_COLOR_MATRIX_RED_BIAS_SGI:
3523 *params = ctx->Pixel.PostColorMatrixBias[0];
3524 break;
3525 case GL_POST_COLOR_MATRIX_GREEN_BIAS_SGI:
3526 *params = ctx->Pixel.PostColorMatrixBias[1];
3527 break;
3528 case GL_POST_COLOR_MATRIX_BLUE_BIAS_SGI:
3529 *params = ctx->Pixel.PostColorMatrixBias[2];
3530 break;
3531 case GL_POST_COLOR_MATRIX_ALPHA_BIAS_SGI:
3532 *params = ctx->Pixel.PostColorMatrixBias[3];
3533 break;
3534
3535 /* GL_EXT_convolution (also in 1.2 imaging) */
3536 case GL_CONVOLUTION_1D_EXT:
3537 if (ctx->Extensions.EXT_convolution || ctx->Extensions.ARB_imaging) {
3538 *params = (GLfloat) ctx->Pixel.Convolution1DEnabled;
3539 }
3540 else {
3541 _mesa_error(ctx, GL_INVALID_ENUM, "glGetFloatv");
3542 return;
3543 }
3544 break;
3545 case GL_CONVOLUTION_2D:
3546 if (ctx->Extensions.EXT_convolution || ctx->Extensions.ARB_imaging) {
3547 *params = (GLfloat) ctx->Pixel.Convolution2DEnabled;
3548 }
3549 else {
3550 _mesa_error(ctx, GL_INVALID_ENUM, "glGetFloatv");
3551 return;
3552 }
3553 break;
3554 case GL_SEPARABLE_2D:
3555 if (ctx->Extensions.EXT_convolution || ctx->Extensions.ARB_imaging) {
3556 *params = (GLfloat) ctx->Pixel.Separable2DEnabled;
3557 }
3558 else {
3559 _mesa_error(ctx, GL_INVALID_ENUM, "glGetFloatv");
3560 return;
3561 }
3562 break;
3563 case GL_MAX_CONVOLUTION_WIDTH:
3564 *params = (GLfloat) ctx->Const.MaxConvolutionWidth;
3565 break;
3566 case GL_MAX_CONVOLUTION_HEIGHT:
3567 *params = (GLfloat) ctx->Const.MaxConvolutionHeight;
3568 break;
3569 case GL_POST_CONVOLUTION_RED_SCALE_EXT:
3570 *params = ctx->Pixel.PostConvolutionScale[0];
3571 break;
3572 case GL_POST_CONVOLUTION_GREEN_SCALE_EXT:
3573 *params = ctx->Pixel.PostConvolutionScale[1];
3574 break;
3575 case GL_POST_CONVOLUTION_BLUE_SCALE_EXT:
3576 *params = ctx->Pixel.PostConvolutionScale[2];
3577 break;
3578 case GL_POST_CONVOLUTION_ALPHA_SCALE_EXT:
3579 *params = ctx->Pixel.PostConvolutionScale[3];
3580 break;
3581 case GL_POST_CONVOLUTION_RED_BIAS_EXT:
3582 *params = ctx->Pixel.PostConvolutionBias[0];
3583 break;
3584 case GL_POST_CONVOLUTION_GREEN_BIAS_EXT:
3585 *params = ctx->Pixel.PostConvolutionBias[1];
3586 break;
3587 case GL_POST_CONVOLUTION_BLUE_BIAS_EXT:
3588 *params = ctx->Pixel.PostConvolutionBias[2];
3589 break;
3590 case GL_POST_CONVOLUTION_ALPHA_BIAS_EXT:
3591 *params = ctx->Pixel.PostConvolutionBias[2];
3592 break;
3593
3594 /* GL_SGI_color_table (also in 1.2 imaging */
3595 case GL_COLOR_TABLE_SGI:
3596 *params = (GLfloat) ctx->Pixel.ColorTableEnabled;
3597 break;
3598 case GL_POST_CONVOLUTION_COLOR_TABLE_SGI:
3599 *params = (GLfloat) ctx->Pixel.PostConvolutionColorTableEnabled;
3600 break;
3601 case GL_POST_COLOR_MATRIX_COLOR_TABLE_SGI:
3602 *params = (GLfloat) ctx->Pixel.PostColorMatrixColorTableEnabled;
3603 break;
3604
3605 /* GL_EXT_secondary_color */
3606 case GL_COLOR_SUM_EXT:
3607 *params = (GLfloat) ctx->Fog.ColorSumEnabled;
3608 break;
3609 case GL_CURRENT_SECONDARY_COLOR_EXT:
3610 FLUSH_CURRENT(ctx, 0);
3611 params[0] = (ctx->Current.SecondaryColor[0]);
3612 params[1] = (ctx->Current.SecondaryColor[1]);
3613 params[2] = (ctx->Current.SecondaryColor[2]);
3614 break;
3615 case GL_SECONDARY_COLOR_ARRAY_EXT:
3616 *params = (GLfloat) ctx->Array.SecondaryColor.Enabled;
3617 break;
3618 case GL_SECONDARY_COLOR_ARRAY_TYPE_EXT:
3619 *params = (GLfloat) ctx->Array.SecondaryColor.Type;
3620 break;
3621 case GL_SECONDARY_COLOR_ARRAY_STRIDE_EXT:
3622 *params = (GLfloat) ctx->Array.SecondaryColor.Stride;
3623 break;
3624 case GL_SECONDARY_COLOR_ARRAY_SIZE_EXT:
3625 *params = (GLfloat) ctx->Array.SecondaryColor.Stride;
3626 break;
3627
3628 /* GL_EXT_fog_coord */
3629 case GL_CURRENT_FOG_COORDINATE_EXT:
3630 FLUSH_CURRENT(ctx, 0);
3631 *params = (GLfloat) ctx->Current.FogCoord;
3632 break;
3633 case GL_FOG_COORDINATE_ARRAY_EXT:
3634 *params = (GLfloat) ctx->Array.FogCoord.Enabled;
3635 break;
3636 case GL_FOG_COORDINATE_ARRAY_TYPE_EXT:
3637 *params = (GLfloat) ctx->Array.FogCoord.Type;
3638 break;
3639 case GL_FOG_COORDINATE_ARRAY_STRIDE_EXT:
3640 *params = (GLfloat) ctx->Array.FogCoord.Stride;
3641 break;
3642
3643 /* GL_EXT_texture_filter_anisotropic */
3644 case GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT:
3645 if (ctx->Extensions.EXT_texture_filter_anisotropic) {
3646 *params = ctx->Const.MaxTextureMaxAnisotropy;
3647 }
3648 else {
3649 _mesa_error( ctx, GL_INVALID_ENUM, "glGetFloatv" );
3650 return;
3651 }
3652 break;
3653
3654 /* GL_MESA_sprite_point */
3655 case GL_SPRITE_POINT_MESA:
3656 if (ctx->Extensions.MESA_sprite_point) {
3657 *params = (GLfloat) ctx->Point.SpriteMode;
3658 }
3659 else {
3660 _mesa_error( ctx, GL_INVALID_ENUM, "glGetFloatv" );
3661 return;
3662 }
3663 break;
3664
3665 default:
3666 _mesa_error( ctx, GL_INVALID_ENUM, "glGetFloatv" );
3667 }
3668 }
3669
3670
3671
3672
3673 void
3674 _mesa_GetIntegerv( GLenum pname, GLint *params )
3675 {
3676 GET_CURRENT_CONTEXT(ctx);
3677 GLuint i;
3678 GLuint texUnit = ctx->Texture.CurrentUnit;
3679 GLuint texTransformUnit = ctx->Texture.CurrentTransformUnit;
3680 const struct gl_texture_unit *textureUnit = &ctx->Texture.Unit[texUnit];
3681 ASSERT_OUTSIDE_BEGIN_END(ctx);
3682
3683 if (!params)
3684 return;
3685
3686 /* We need this in order to get correct results for
3687 * GL_OCCLUSION_TEST_RESULT_HP. There might be other important cases.
3688 */
3689 FLUSH_VERTICES(ctx, 0);
3690
3691 if (MESA_VERBOSE & VERBOSE_API)
3692 fprintf(stderr, "glGetIntegerv %s\n", _mesa_lookup_enum_by_nr(pname));
3693
3694 if (ctx->Driver.GetIntegerv
3695 && (*ctx->Driver.GetIntegerv)(ctx, pname, params))
3696 return;
3697
3698 switch (pname) {
3699 case GL_ACCUM_RED_BITS:
3700 *params = (GLint) ctx->Visual.accumRedBits;
3701 break;
3702 case GL_ACCUM_GREEN_BITS:
3703 *params = (GLint) ctx->Visual.accumGreenBits;
3704 break;
3705 case GL_ACCUM_BLUE_BITS:
3706 *params = (GLint) ctx->Visual.accumBlueBits;
3707 break;
3708 case GL_ACCUM_ALPHA_BITS:
3709 *params = (GLint) ctx->Visual.accumAlphaBits;
3710 break;
3711 case GL_ACCUM_CLEAR_VALUE:
3712 params[0] = FLOAT_TO_INT( ctx->Accum.ClearColor[0] );
3713 params[1] = FLOAT_TO_INT( ctx->Accum.ClearColor[1] );
3714 params[2] = FLOAT_TO_INT( ctx->Accum.ClearColor[2] );
3715 params[3] = FLOAT_TO_INT( ctx->Accum.ClearColor[3] );
3716 break;
3717 case GL_ALPHA_BIAS:
3718 *params = (GLint) ctx->Pixel.AlphaBias;
3719 break;
3720 case GL_ALPHA_BITS:
3721 *params = ctx->Visual.alphaBits;
3722 break;
3723 case GL_ALPHA_SCALE:
3724 *params = (GLint) ctx->Pixel.AlphaScale;
3725 break;
3726 case GL_ALPHA_TEST:
3727 *params = (GLint) ctx->Color.AlphaEnabled;
3728 break;
3729 case GL_ALPHA_TEST_REF:
3730 *params = FLOAT_TO_INT( (GLfloat) ctx->Color.AlphaRef / CHAN_MAXF );
3731 break;
3732 case GL_ALPHA_TEST_FUNC:
3733 *params = (GLint) ctx->Color.AlphaFunc;
3734 break;
3735 case GL_ATTRIB_STACK_DEPTH:
3736 *params = (GLint) (ctx->AttribStackDepth);
3737 break;
3738 case GL_AUTO_NORMAL:
3739 *params = (GLint) ctx->Eval.AutoNormal;
3740 break;
3741 case GL_AUX_BUFFERS:
3742 *params = (GLint) ctx->Const.NumAuxBuffers;
3743 break;
3744 case GL_BLEND:
3745 *params = (GLint) ctx->Color.BlendEnabled;
3746 break;
3747 case GL_BLEND_DST:
3748 *params = (GLint) ctx->Color.BlendDstRGB;
3749 break;
3750 case GL_BLEND_SRC:
3751 *params = (GLint) ctx->Color.BlendSrcRGB;
3752 break;
3753 case GL_BLEND_SRC_RGB_EXT:
3754 *params = (GLint) ctx->Color.BlendSrcRGB;
3755 break;
3756 case GL_BLEND_DST_RGB_EXT:
3757 *params = (GLint) ctx->Color.BlendDstRGB;
3758 break;
3759 case GL_BLEND_SRC_ALPHA_EXT:
3760 *params = (GLint) ctx->Color.BlendSrcA;
3761 break;
3762 case GL_BLEND_DST_ALPHA_EXT:
3763 *params = (GLint) ctx->Color.BlendDstA;
3764 break;
3765 case GL_BLEND_EQUATION_EXT:
3766 *params = (GLint) ctx->Color.BlendEquation;
3767 break;
3768 case GL_BLEND_COLOR_EXT:
3769 params[0] = FLOAT_TO_INT( ctx->Color.BlendColor[0] );
3770 params[1] = FLOAT_TO_INT( ctx->Color.BlendColor[1] );
3771 params[2] = FLOAT_TO_INT( ctx->Color.BlendColor[2] );
3772 params[3] = FLOAT_TO_INT( ctx->Color.BlendColor[3] );
3773 break;
3774 case GL_BLUE_BIAS:
3775 *params = (GLint) ctx->Pixel.BlueBias;
3776 break;
3777 case GL_BLUE_BITS:
3778 *params = (GLint) ctx->Visual.blueBits;
3779 break;
3780 case GL_BLUE_SCALE:
3781 *params = (GLint) ctx->Pixel.BlueScale;
3782 break;
3783 case GL_CLIENT_ATTRIB_STACK_DEPTH:
3784 *params = (GLint) (ctx->ClientAttribStackDepth);
3785 break;
3786 case GL_CLIP_PLANE0:
3787 case GL_CLIP_PLANE1:
3788 case GL_CLIP_PLANE2:
3789 case GL_CLIP_PLANE3:
3790 case GL_CLIP_PLANE4:
3791 case GL_CLIP_PLANE5:
3792 i = (GLint) (pname - GL_CLIP_PLANE0);
3793 *params = (GLint) ctx->Transform.ClipEnabled[i];
3794 break;
3795 case GL_COLOR_CLEAR_VALUE:
3796 params[0] = FLOAT_TO_INT( (ctx->Color.ClearColor[0]) );
3797 params[1] = FLOAT_TO_INT( (ctx->Color.ClearColor[1]) );
3798 params[2] = FLOAT_TO_INT( (ctx->Color.ClearColor[2]) );
3799 params[3] = FLOAT_TO_INT( (ctx->Color.ClearColor[3]) );
3800 break;
3801 case GL_COLOR_MATERIAL:
3802 *params = (GLint) ctx->Light.ColorMaterialEnabled;
3803 break;
3804 case GL_COLOR_MATERIAL_FACE:
3805 *params = (GLint) ctx->Light.ColorMaterialFace;
3806 break;
3807 case GL_COLOR_MATERIAL_PARAMETER:
3808 *params = (GLint) ctx->Light.ColorMaterialMode;
3809 break;
3810 case GL_COLOR_WRITEMASK:
3811 params[0] = ctx->Color.ColorMask[RCOMP] ? 1 : 0;
3812 params[1] = ctx->Color.ColorMask[GCOMP] ? 1 : 0;
3813 params[2] = ctx->Color.ColorMask[BCOMP] ? 1 : 0;
3814 params[3] = ctx->Color.ColorMask[ACOMP] ? 1 : 0;
3815 break;
3816 case GL_CULL_FACE:
3817 *params = (GLint) ctx->Polygon.CullFlag;
3818 break;
3819 case GL_CULL_FACE_MODE:
3820 *params = (GLint) ctx->Polygon.CullFaceMode;
3821 break;
3822 case GL_CURRENT_COLOR:
3823 FLUSH_CURRENT(ctx, 0);
3824 params[0] = FLOAT_TO_INT( ( ctx->Current.Color[0] ) );
3825 params[1] = FLOAT_TO_INT( ( ctx->Current.Color[1] ) );
3826 params[2] = FLOAT_TO_INT( ( ctx->Current.Color[2] ) );
3827 params[3] = FLOAT_TO_INT( ( ctx->Current.Color[3] ) );
3828 break;
3829 case GL_CURRENT_INDEX:
3830 FLUSH_CURRENT(ctx, 0);
3831 *params = (GLint) ctx->Current.Index;
3832 break;
3833 case GL_CURRENT_NORMAL:
3834 FLUSH_CURRENT(ctx, 0);
3835 params[0] = FLOAT_TO_INT( ctx->Current.Normal[0] );
3836 params[1] = FLOAT_TO_INT( ctx->Current.Normal[1] );
3837 params[2] = FLOAT_TO_INT( ctx->Current.Normal[2] );
3838 break;
3839 case GL_CURRENT_RASTER_COLOR:
3840 params[0] = FLOAT_TO_INT( ctx->Current.RasterColor[0] );
3841 params[1] = FLOAT_TO_INT( ctx->Current.RasterColor[1] );
3842 params[2] = FLOAT_TO_INT( ctx->Current.RasterColor[2] );
3843 params[3] = FLOAT_TO_INT( ctx->Current.RasterColor[3] );
3844 break;
3845 case GL_CURRENT_RASTER_DISTANCE:
3846 params[0] = (GLint) ctx->Current.RasterDistance;
3847 break;
3848 case GL_CURRENT_RASTER_INDEX:
3849 *params = (GLint) ctx->Current.RasterIndex;
3850 break;
3851 case GL_CURRENT_RASTER_POSITION:
3852 params[0] = (GLint) ctx->Current.RasterPos[0];
3853 params[1] = (GLint) ctx->Current.RasterPos[1];
3854 params[2] = (GLint) ctx->Current.RasterPos[2];
3855 params[3] = (GLint) ctx->Current.RasterPos[3];
3856 break;
3857 case GL_CURRENT_RASTER_TEXTURE_COORDS:
3858 params[0] = (GLint) ctx->Current.RasterMultiTexCoord[texTransformUnit][0];
3859 params[1] = (GLint) ctx->Current.RasterMultiTexCoord[texTransformUnit][1];
3860 params[2] = (GLint) ctx->Current.RasterMultiTexCoord[texTransformUnit][2];
3861 params[3] = (GLint) ctx->Current.RasterMultiTexCoord[texTransformUnit][3];
3862 break;
3863 case GL_CURRENT_RASTER_POSITION_VALID:
3864 *params = (GLint) ctx->Current.RasterPosValid;
3865 break;
3866 case GL_CURRENT_TEXTURE_COORDS:
3867 FLUSH_CURRENT(ctx, 0);
3868 params[0] = (GLint) ctx->Current.Texcoord[texTransformUnit][0];
3869 params[1] = (GLint) ctx->Current.Texcoord[texTransformUnit][1];
3870 params[2] = (GLint) ctx->Current.Texcoord[texTransformUnit][2];
3871 params[3] = (GLint) ctx->Current.Texcoord[texTransformUnit][3];
3872 break;
3873 case GL_DEPTH_BIAS:
3874 *params = (GLint) ctx->Pixel.DepthBias;
3875 break;
3876 case GL_DEPTH_BITS:
3877 *params = ctx->Visual.depthBits;
3878 break;
3879 case GL_DEPTH_CLEAR_VALUE:
3880 *params = (GLint) ctx->Depth.Clear;
3881 break;
3882 case GL_DEPTH_FUNC:
3883 *params = (GLint) ctx->Depth.Func;
3884 break;
3885 case GL_DEPTH_RANGE:
3886 params[0] = (GLint) ctx->Viewport.Near;
3887 params[1] = (GLint) ctx->Viewport.Far;
3888 break;
3889 case GL_DEPTH_SCALE:
3890 *params = (GLint) ctx->Pixel.DepthScale;
3891 break;
3892 case GL_DEPTH_TEST:
3893 *params = (GLint) ctx->Depth.Test;
3894 break;
3895 case GL_DEPTH_WRITEMASK:
3896 *params = (GLint) ctx->Depth.Mask;
3897 break;
3898 case GL_DITHER:
3899 *params = (GLint) ctx->Color.DitherFlag;
3900 break;
3901 case GL_DOUBLEBUFFER:
3902 *params = (GLint) ctx->Visual.doubleBufferMode;
3903 break;
3904 case GL_DRAW_BUFFER:
3905 *params = (GLint) ctx->Color.DrawBuffer;
3906 break;
3907 case GL_EDGE_FLAG:
3908 FLUSH_CURRENT(ctx, 0);
3909 *params = (GLint) ctx->Current.EdgeFlag;
3910 break;
3911 case GL_FEEDBACK_BUFFER_SIZE:
3912 *params = ctx->Feedback.BufferSize;
3913 break;
3914 case GL_FEEDBACK_BUFFER_TYPE:
3915 *params = ctx->Feedback.Type;
3916 break;
3917 case GL_FOG:
3918 *params = (GLint) ctx->Fog.Enabled;
3919 break;
3920 case GL_FOG_COLOR:
3921 params[0] = FLOAT_TO_INT( ctx->Fog.Color[0] );
3922 params[1] = FLOAT_TO_INT( ctx->Fog.Color[1] );
3923 params[2] = FLOAT_TO_INT( ctx->Fog.Color[2] );
3924 params[3] = FLOAT_TO_INT( ctx->Fog.Color[3] );
3925 break;
3926 case GL_FOG_DENSITY:
3927 *params = (GLint) ctx->Fog.Density;
3928 break;
3929 case GL_FOG_END:
3930 *params = (GLint) ctx->Fog.End;
3931 break;
3932 case GL_FOG_HINT:
3933 *params = (GLint) ctx->Hint.Fog;
3934 break;
3935 case GL_FOG_INDEX:
3936 *params = (GLint) ctx->Fog.Index;
3937 break;
3938 case GL_FOG_MODE:
3939 *params = (GLint) ctx->Fog.Mode;
3940 break;
3941 case GL_FOG_START:
3942 *params = (GLint) ctx->Fog.Start;
3943 break;
3944 case GL_FRONT_FACE:
3945 *params = (GLint) ctx->Polygon.FrontFace;
3946 break;
3947 case GL_GREEN_BIAS:
3948 *params = (GLint) ctx->Pixel.GreenBias;
3949 break;
3950 case GL_GREEN_BITS:
3951 *params = (GLint) ctx->Visual.greenBits;
3952 break;
3953 case GL_GREEN_SCALE:
3954 *params = (GLint) ctx->Pixel.GreenScale;
3955 break;
3956 case GL_HISTOGRAM:
3957 if (ctx->Extensions.EXT_histogram || ctx->Extensions.ARB_imaging) {
3958 *params = (GLint) ctx->Pixel.HistogramEnabled;
3959 }
3960 else {
3961 _mesa_error(ctx, GL_INVALID_ENUM, "glGetFloatv");
3962 return;
3963 }
3964 break;
3965 case GL_INDEX_BITS:
3966 *params = (GLint) ctx->Visual.indexBits;
3967 break;
3968 case GL_INDEX_CLEAR_VALUE:
3969 *params = (GLint) ctx->Color.ClearIndex;
3970 break;
3971 case GL_INDEX_MODE:
3972 *params = ctx->Visual.rgbMode ? 0 : 1;
3973 break;
3974 case GL_INDEX_OFFSET:
3975 *params = ctx->Pixel.IndexOffset;
3976 break;
3977 case GL_INDEX_SHIFT:
3978 *params = ctx->Pixel.IndexShift;
3979 break;
3980 case GL_INDEX_WRITEMASK:
3981 *params = (GLint) ctx->Color.IndexMask;
3982 break;
3983 case GL_LIGHT0:
3984 case GL_LIGHT1:
3985 case GL_LIGHT2:
3986 case GL_LIGHT3:
3987 case GL_LIGHT4:
3988 case GL_LIGHT5:
3989 case GL_LIGHT6:
3990 case GL_LIGHT7:
3991 *params = (GLint) ctx->Light.Light[pname-GL_LIGHT0].Enabled;
3992 break;
3993 case GL_LIGHTING:
3994 *params = (GLint) ctx->Light.Enabled;
3995 break;
3996 case GL_LIGHT_MODEL_AMBIENT:
3997 params[0] = FLOAT_TO_INT( ctx->Light.Model.Ambient[0] );
3998 params[1] = FLOAT_TO_INT( ctx->Light.Model.Ambient[1] );
3999 params[2] = FLOAT_TO_INT( ctx->Light.Model.Ambient[2] );
4000 params[3] = FLOAT_TO_INT( ctx->Light.Model.Ambient[3] );
4001 break;
4002 case GL_LIGHT_MODEL_COLOR_CONTROL:
4003 params[0] = (GLint) ctx->Light.Model.ColorControl;
4004 break;
4005 case GL_LIGHT_MODEL_LOCAL_VIEWER:
4006 *params = (GLint) ctx->Light.Model.LocalViewer;
4007 break;
4008 case GL_LIGHT_MODEL_TWO_SIDE:
4009 *params = (GLint) ctx->Light.Model.TwoSide;
4010 break;
4011 case GL_LINE_SMOOTH:
4012 *params = (GLint) ctx->Line.SmoothFlag;
4013 break;
4014 case GL_LINE_SMOOTH_HINT:
4015 *params = (GLint) ctx->Hint.LineSmooth;
4016 break;
4017 case GL_LINE_STIPPLE:
4018 *params = (GLint) ctx->Line.StippleFlag;
4019 break;
4020 case GL_LINE_STIPPLE_PATTERN:
4021 *params = (GLint) ctx->Line.StipplePattern;
4022 break;
4023 case GL_LINE_STIPPLE_REPEAT:
4024 *params = (GLint) ctx->Line.StippleFactor;
4025 break;
4026 case GL_LINE_WIDTH:
4027 *params = (GLint) ctx->Line.Width;
4028 break;
4029 case GL_LINE_WIDTH_GRANULARITY:
4030 *params = (GLint) ctx->Const.LineWidthGranularity;
4031 break;
4032 case GL_LINE_WIDTH_RANGE:
4033 params[0] = (GLint) ctx->Const.MinLineWidthAA;
4034 params[1] = (GLint) ctx->Const.MaxLineWidthAA;
4035 break;
4036 case GL_ALIASED_LINE_WIDTH_RANGE:
4037 params[0] = (GLint) ctx->Const.MinLineWidth;
4038 params[1] = (GLint) ctx->Const.MaxLineWidth;
4039 break;
4040 case GL_LIST_BASE:
4041 *params = (GLint) ctx->List.ListBase;
4042 break;
4043 case GL_LIST_INDEX:
4044 *params = (GLint) ctx->CurrentListNum;
4045 break;
4046 case GL_LIST_MODE:
4047 *params = ctx->ExecuteFlag ? (GLint) GL_COMPILE_AND_EXECUTE
4048 : (GLint) GL_COMPILE;
4049 break;
4050 case GL_INDEX_LOGIC_OP:
4051 *params = (GLint) ctx->Color.IndexLogicOpEnabled;
4052 break;
4053 case GL_COLOR_LOGIC_OP:
4054 *params = (GLint) ctx->Color.ColorLogicOpEnabled;
4055 break;
4056 case GL_LOGIC_OP_MODE:
4057 *params = (GLint) ctx->Color.LogicOp;
4058 break;
4059 case GL_MAP1_COLOR_4:
4060 *params = (GLint) ctx->Eval.Map1Color4;
4061 break;
4062 case GL_MAP1_GRID_DOMAIN:
4063 params[0] = (GLint) ctx->Eval.MapGrid1u1;
4064 params[1] = (GLint) ctx->Eval.MapGrid1u2;
4065 break;
4066 case GL_MAP1_GRID_SEGMENTS:
4067 *params = (GLint) ctx->Eval.MapGrid1un;
4068 break;
4069 case GL_MAP1_INDEX:
4070 *params = (GLint) ctx->Eval.Map1Index;
4071 break;
4072 case GL_MAP1_NORMAL:
4073 *params = (GLint) ctx->Eval.Map1Normal;
4074 break;
4075 case GL_MAP1_TEXTURE_COORD_1:
4076 *params = (GLint) ctx->Eval.Map1TextureCoord1;
4077 break;
4078 case GL_MAP1_TEXTURE_COORD_2:
4079 *params = (GLint) ctx->Eval.Map1TextureCoord2;
4080 break;
4081 case GL_MAP1_TEXTURE_COORD_3:
4082 *params = (GLint) ctx->Eval.Map1TextureCoord3;
4083 break;
4084 case GL_MAP1_TEXTURE_COORD_4:
4085 *params = (GLint) ctx->Eval.Map1TextureCoord4;
4086 break;
4087 case GL_MAP1_VERTEX_3:
4088 *params = (GLint) ctx->Eval.Map1Vertex3;
4089 break;
4090 case GL_MAP1_VERTEX_4:
4091 *params = (GLint) ctx->Eval.Map1Vertex4;
4092 break;
4093 case GL_MAP2_COLOR_4:
4094 *params = (GLint) ctx->Eval.Map2Color4;
4095 break;
4096 case GL_MAP2_GRID_DOMAIN:
4097 params[0] = (GLint) ctx->Eval.MapGrid2u1;
4098 params[1] = (GLint) ctx->Eval.MapGrid2u2;
4099 params[2] = (GLint) ctx->Eval.MapGrid2v1;
4100 params[3] = (GLint) ctx->Eval.MapGrid2v2;
4101 break;
4102 case GL_MAP2_GRID_SEGMENTS:
4103 params[0] = (GLint) ctx->Eval.MapGrid2un;
4104 params[1] = (GLint) ctx->Eval.MapGrid2vn;
4105 break;
4106 case GL_MAP2_INDEX:
4107 *params = (GLint) ctx->Eval.Map2Index;
4108 break;
4109 case GL_MAP2_NORMAL:
4110 *params = (GLint) ctx->Eval.Map2Normal;
4111 break;
4112 case GL_MAP2_TEXTURE_COORD_1:
4113 *params = (GLint) ctx->Eval.Map2TextureCoord1;
4114 break;
4115 case GL_MAP2_TEXTURE_COORD_2:
4116 *params = (GLint) ctx->Eval.Map2TextureCoord2;
4117 break;
4118 case GL_MAP2_TEXTURE_COORD_3:
4119 *params = (GLint) ctx->Eval.Map2TextureCoord3;
4120 break;
4121 case GL_MAP2_TEXTURE_COORD_4:
4122 *params = (GLint) ctx->Eval.Map2TextureCoord4;
4123 break;
4124 case GL_MAP2_VERTEX_3:
4125 *params = (GLint) ctx->Eval.Map2Vertex3;
4126 break;
4127 case GL_MAP2_VERTEX_4:
4128 *params = (GLint) ctx->Eval.Map2Vertex4;
4129 break;
4130 case GL_MAP_COLOR:
4131 *params = (GLint) ctx->Pixel.MapColorFlag;
4132 break;
4133 case GL_MAP_STENCIL:
4134 *params = (GLint) ctx->Pixel.MapStencilFlag;
4135 break;
4136 case GL_MATRIX_MODE:
4137 *params = (GLint) ctx->Transform.MatrixMode;
4138 break;
4139 case GL_MAX_ATTRIB_STACK_DEPTH:
4140 *params = (GLint) MAX_ATTRIB_STACK_DEPTH;
4141 break;
4142 case GL_MAX_CLIENT_ATTRIB_STACK_DEPTH:
4143 *params = (GLint) MAX_CLIENT_ATTRIB_STACK_DEPTH;
4144 break;
4145 case GL_MAX_CLIP_PLANES:
4146 *params = (GLint) ctx->Const.MaxClipPlanes;
4147 break;
4148 case GL_MAX_ELEMENTS_VERTICES: /* GL_VERSION_1_2 */
4149 *params = (GLint) ctx->Const.MaxArrayLockSize;
4150 break;
4151 case GL_MAX_ELEMENTS_INDICES: /* GL_VERSION_1_2 */
4152 *params = (GLint) ctx->Const.MaxArrayLockSize;
4153 break;
4154 case GL_MAX_EVAL_ORDER:
4155 *params = (GLint) MAX_EVAL_ORDER;
4156 break;
4157 case GL_MAX_LIGHTS:
4158 *params = (GLint) ctx->Const.MaxLights;
4159 break;
4160 case GL_MAX_LIST_NESTING:
4161 *params = (GLint) MAX_LIST_NESTING;
4162 break;
4163 case GL_MAX_MODELVIEW_STACK_DEPTH:
4164 *params = (GLint) MAX_MODELVIEW_STACK_DEPTH;
4165 break;
4166 case GL_MAX_NAME_STACK_DEPTH:
4167 *params = (GLint) MAX_NAME_STACK_DEPTH;
4168 break;
4169 case GL_MAX_PIXEL_MAP_TABLE:
4170 *params = (GLint) MAX_PIXEL_MAP_TABLE;
4171 break;
4172 case GL_MAX_PROJECTION_STACK_DEPTH:
4173 *params = (GLint) MAX_PROJECTION_STACK_DEPTH;
4174 break;
4175 case GL_MAX_TEXTURE_SIZE:
4176 case GL_MAX_3D_TEXTURE_SIZE:
4177 *params = ctx->Const.MaxTextureSize;
4178 break;
4179 case GL_MAX_TEXTURE_STACK_DEPTH:
4180 *params = (GLint) MAX_TEXTURE_STACK_DEPTH;
4181 break;
4182 case GL_MAX_VIEWPORT_DIMS:
4183 params[0] = (GLint) MAX_WIDTH;
4184 params[1] = (GLint) MAX_HEIGHT;
4185 break;
4186 case GL_MINMAX:
4187 *params = (GLint) ctx->Pixel.MinMaxEnabled;
4188 break;
4189 case GL_MODELVIEW_MATRIX:
4190 for (i=0;i<16;i++) {
4191 params[i] = (GLint) ctx->ModelView.m[i];
4192 }
4193 break;
4194 case GL_MODELVIEW_STACK_DEPTH:
4195 *params = (GLint) (ctx->ModelViewStackDepth + 1);
4196 break;
4197 case GL_NAME_STACK_DEPTH:
4198 *params = (GLint) ctx->Select.NameStackDepth;
4199 break;
4200 case GL_NORMALIZE:
4201 *params = (GLint) ctx->Transform.Normalize;
4202 break;
4203 case GL_PACK_ALIGNMENT:
4204 *params = ctx->Pack.Alignment;
4205 break;
4206 case GL_PACK_LSB_FIRST:
4207 *params = (GLint) ctx->Pack.LsbFirst;
4208 break;
4209 case GL_PACK_ROW_LENGTH:
4210 *params = ctx->Pack.RowLength;
4211 break;
4212 case GL_PACK_SKIP_PIXELS:
4213 *params = ctx->Pack.SkipPixels;
4214 break;
4215 case GL_PACK_SKIP_ROWS:
4216 *params = ctx->Pack.SkipRows;
4217 break;
4218 case GL_PACK_SWAP_BYTES:
4219 *params = (GLint) ctx->Pack.SwapBytes;
4220 break;
4221 case GL_PACK_SKIP_IMAGES_EXT:
4222 *params = ctx->Pack.SkipImages;
4223 break;
4224 case GL_PACK_IMAGE_HEIGHT_EXT:
4225 *params = ctx->Pack.ImageHeight;
4226 break;
4227 case GL_PERSPECTIVE_CORRECTION_HINT:
4228 *params = (GLint) ctx->Hint.PerspectiveCorrection;
4229 break;
4230 case GL_PIXEL_MAP_A_TO_A_SIZE:
4231 *params = ctx->Pixel.MapAtoAsize;
4232 break;
4233 case GL_PIXEL_MAP_B_TO_B_SIZE:
4234 *params = ctx->Pixel.MapBtoBsize;
4235 break;
4236 case GL_PIXEL_MAP_G_TO_G_SIZE:
4237 *params = ctx->Pixel.MapGtoGsize;
4238 break;
4239 case GL_PIXEL_MAP_I_TO_A_SIZE:
4240 *params = ctx->Pixel.MapItoAsize;
4241 break;
4242 case GL_PIXEL_MAP_I_TO_B_SIZE:
4243 *params = ctx->Pixel.MapItoBsize;
4244 break;
4245 case GL_PIXEL_MAP_I_TO_G_SIZE:
4246 *params = ctx->Pixel.MapItoGsize;
4247 break;
4248 case GL_PIXEL_MAP_I_TO_I_SIZE:
4249 *params = ctx->Pixel.MapItoIsize;
4250 break;
4251 case GL_PIXEL_MAP_I_TO_R_SIZE:
4252 *params = ctx->Pixel.MapItoRsize;
4253 break;
4254 case GL_PIXEL_MAP_R_TO_R_SIZE:
4255 *params = ctx->Pixel.MapRtoRsize;
4256 break;
4257 case GL_PIXEL_MAP_S_TO_S_SIZE:
4258 *params = ctx->Pixel.MapStoSsize;
4259 break;
4260 case GL_POINT_SIZE:
4261 *params = (GLint) ctx->Point.Size;
4262 break;
4263 case GL_POINT_SIZE_GRANULARITY:
4264 *params = (GLint) ctx->Const.PointSizeGranularity;
4265 break;
4266 case GL_POINT_SIZE_RANGE:
4267 params[0] = (GLint) ctx->Const.MinPointSizeAA;
4268 params[1] = (GLint) ctx->Const.MaxPointSizeAA;
4269 break;
4270 case GL_ALIASED_POINT_SIZE_RANGE:
4271 params[0] = (GLint) ctx->Const.MinPointSize;
4272 params[1] = (GLint) ctx->Const.MaxPointSize;
4273 break;
4274 case GL_POINT_SMOOTH:
4275 *params = (GLint) ctx->Point.SmoothFlag;
4276 break;
4277 case GL_POINT_SMOOTH_HINT:
4278 *params = (GLint) ctx->Hint.PointSmooth;
4279 break;
4280 case GL_POINT_SIZE_MIN_EXT:
4281 *params = (GLint) (ctx->Point.MinSize);
4282 break;
4283 case GL_POINT_SIZE_MAX_EXT:
4284 *params = (GLint) (ctx->Point.MaxSize);
4285 break;
4286 case GL_POINT_FADE_THRESHOLD_SIZE_EXT:
4287 *params = (GLint) (ctx->Point.Threshold);
4288 break;
4289 case GL_DISTANCE_ATTENUATION_EXT:
4290 params[0] = (GLint) (ctx->Point.Params[0]);
4291 params[1] = (GLint) (ctx->Point.Params[1]);
4292 params[2] = (GLint) (ctx->Point.Params[2]);
4293 break;
4294 case GL_POLYGON_MODE:
4295 params[0] = (GLint) ctx->Polygon.FrontMode;
4296 params[1] = (GLint) ctx->Polygon.BackMode;
4297 break;
4298 case GL_POLYGON_OFFSET_BIAS_EXT: /* GL_EXT_polygon_offset */
4299 *params = (GLint) ctx->Polygon.OffsetUnits;
4300 break;
4301 case GL_POLYGON_OFFSET_FACTOR:
4302 *params = (GLint) ctx->Polygon.OffsetFactor;
4303 break;
4304 case GL_POLYGON_OFFSET_UNITS:
4305 *params = (GLint) ctx->Polygon.OffsetUnits;
4306 break;
4307 case GL_POLYGON_SMOOTH:
4308 *params = (GLint) ctx->Polygon.SmoothFlag;
4309 break;
4310 case GL_POLYGON_SMOOTH_HINT:
4311 *params = (GLint) ctx->Hint.PolygonSmooth;
4312 break;
4313 case GL_POLYGON_STIPPLE:
4314 *params = (GLint) ctx->Polygon.StippleFlag;
4315 break;
4316 case GL_PROJECTION_MATRIX:
4317 for (i=0;i<16;i++) {
4318 params[i] = (GLint) ctx->ProjectionMatrix.m[i];
4319 }
4320 break;
4321 case GL_PROJECTION_STACK_DEPTH:
4322 *params = (GLint) (ctx->ProjectionStackDepth + 1);
4323 break;
4324 case GL_READ_BUFFER:
4325 *params = (GLint) ctx->Pixel.ReadBuffer;
4326 break;
4327 case GL_RED_BIAS:
4328 *params = (GLint) ctx->Pixel.RedBias;
4329 break;
4330 case GL_RED_BITS:
4331 *params = (GLint) ctx->Visual.redBits;
4332 break;
4333 case GL_RED_SCALE:
4334 *params = (GLint) ctx->Pixel.RedScale;
4335 break;
4336 case GL_RENDER_MODE:
4337 *params = (GLint) ctx->RenderMode;
4338 break;
4339 case GL_RESCALE_NORMAL:
4340 *params = (GLint) ctx->Transform.RescaleNormals;
4341 break;
4342 case GL_RGBA_MODE:
4343 *params = (GLint) ctx->Visual.rgbMode;
4344 break;
4345 case GL_SCISSOR_BOX:
4346 params[0] = (GLint) ctx->Scissor.X;
4347 params[1] = (GLint) ctx->Scissor.Y;
4348 params[2] = (GLint) ctx->Scissor.Width;
4349 params[3] = (GLint) ctx->Scissor.Height;
4350 break;
4351 case GL_SCISSOR_TEST:
4352 *params = (GLint) ctx->Scissor.Enabled;
4353 break;
4354 case GL_SELECTION_BUFFER_SIZE:
4355 *params = (GLint) ctx->Select.BufferSize;
4356 break;
4357 case GL_SHADE_MODEL:
4358 *params = (GLint) ctx->Light.ShadeModel;
4359 break;
4360 case GL_SHARED_TEXTURE_PALETTE_EXT:
4361 *params = (GLint) ctx->Texture.SharedPalette;
4362 break;
4363 case GL_STENCIL_BITS:
4364 *params = ctx->Visual.stencilBits;
4365 break;
4366 case GL_STENCIL_CLEAR_VALUE:
4367 *params = (GLint) ctx->Stencil.Clear;
4368 break;
4369 case GL_STENCIL_FAIL:
4370 *params = (GLint) ctx->Stencil.FailFunc;
4371 break;
4372 case GL_STENCIL_FUNC:
4373 *params = (GLint) ctx->Stencil.Function;
4374 break;
4375 case GL_STENCIL_PASS_DEPTH_FAIL:
4376 *params = (GLint) ctx->Stencil.ZFailFunc;
4377 break;
4378 case GL_STENCIL_PASS_DEPTH_PASS:
4379 *params = (GLint) ctx->Stencil.ZPassFunc;
4380 break;
4381 case GL_STENCIL_REF:
4382 *params = (GLint) ctx->Stencil.Ref;
4383 break;
4384 case GL_STENCIL_TEST:
4385 *params = (GLint) ctx->Stencil.Enabled;
4386 break;
4387 case GL_STENCIL_VALUE_MASK:
4388 *params = (GLint) ctx->Stencil.ValueMask;
4389 break;
4390 case GL_STENCIL_WRITEMASK:
4391 *params = (GLint) ctx->Stencil.WriteMask;
4392 break;
4393 case GL_STEREO:
4394 *params = (GLint) ctx->Visual.stereoMode;
4395 break;
4396 case GL_SUBPIXEL_BITS:
4397 *params = ctx->Const.SubPixelBits;
4398 break;
4399 case GL_TEXTURE_1D:
4400 *params = _mesa_IsEnabled(GL_TEXTURE_1D) ? 1 : 0;
4401 break;
4402 case GL_TEXTURE_2D:
4403 *params = _mesa_IsEnabled(GL_TEXTURE_2D) ? 1 : 0;
4404 break;
4405 case GL_TEXTURE_3D:
4406 *params = _mesa_IsEnabled(GL_TEXTURE_3D) ? 1 : 0;
4407 break;
4408 case GL_TEXTURE_BINDING_1D:
4409 *params = textureUnit->Current1D->Name;
4410 break;
4411 case GL_TEXTURE_BINDING_2D:
4412 *params = textureUnit->Current2D->Name;
4413 break;
4414 case GL_TEXTURE_BINDING_3D:
4415 *params = textureUnit->Current3D->Name;
4416 break;
4417 case GL_TEXTURE_ENV_COLOR:
4418 params[0] = FLOAT_TO_INT( textureUnit->EnvColor[0] );
4419 params[1] = FLOAT_TO_INT( textureUnit->EnvColor[1] );
4420 params[2] = FLOAT_TO_INT( textureUnit->EnvColor[2] );
4421 params[3] = FLOAT_TO_INT( textureUnit->EnvColor[3] );
4422 break;
4423 case GL_TEXTURE_ENV_MODE:
4424 *params = (GLint) textureUnit->EnvMode;
4425 break;
4426 case GL_TEXTURE_GEN_S:
4427 *params = (textureUnit->TexGenEnabled & S_BIT) ? 1 : 0;
4428 break;
4429 case GL_TEXTURE_GEN_T:
4430 *params = (textureUnit->TexGenEnabled & T_BIT) ? 1 : 0;
4431 break;
4432 case GL_TEXTURE_GEN_R:
4433 *params = (textureUnit->TexGenEnabled & R_BIT) ? 1 : 0;
4434 break;
4435 case GL_TEXTURE_GEN_Q:
4436 *params = (textureUnit->TexGenEnabled & Q_BIT) ? 1 : 0;
4437 break;
4438 case GL_TEXTURE_MATRIX:
4439 for (i=0;i<16;i++) {
4440 params[i] = (GLint) ctx->TextureMatrix[texTransformUnit].m[i];
4441 }
4442 break;
4443 case GL_TEXTURE_STACK_DEPTH:
4444 *params = (GLint) (ctx->TextureStackDepth[texTransformUnit] + 1);
4445 break;
4446 case GL_UNPACK_ALIGNMENT:
4447 *params = ctx->Unpack.Alignment;
4448 break;
4449 case GL_UNPACK_LSB_FIRST:
4450 *params = (GLint) ctx->Unpack.LsbFirst;
4451 break;
4452 case GL_UNPACK_ROW_LENGTH:
4453 *params = ctx->Unpack.RowLength;
4454 break;
4455 case GL_UNPACK_SKIP_PIXELS:
4456 *params = ctx->Unpack.SkipPixels;
4457 break;
4458 case GL_UNPACK_SKIP_ROWS:
4459 *params = ctx->Unpack.SkipRows;
4460 break;
4461 case GL_UNPACK_SWAP_BYTES:
4462 *params = (GLint) ctx->Unpack.SwapBytes;
4463 break;
4464 case GL_UNPACK_SKIP_IMAGES_EXT:
4465 *params = ctx->Unpack.SkipImages;
4466 break;
4467 case GL_UNPACK_IMAGE_HEIGHT_EXT:
4468 *params = ctx->Unpack.ImageHeight;
4469 break;
4470 case GL_VIEWPORT:
4471 params[0] = (GLint) ctx->Viewport.X;
4472 params[1] = (GLint) ctx->Viewport.Y;
4473 params[2] = (GLint) ctx->Viewport.Width;
4474 params[3] = (GLint) ctx->Viewport.Height;
4475 break;
4476 case GL_ZOOM_X:
4477 *params = (GLint) ctx->Pixel.ZoomX;
4478 break;
4479 case GL_ZOOM_Y:
4480 *params = (GLint) ctx->Pixel.ZoomY;
4481 break;
4482 case GL_VERTEX_ARRAY:
4483 *params = (GLint) ctx->Array.Vertex.Enabled;
4484 break;
4485 case GL_VERTEX_ARRAY_SIZE:
4486 *params = ctx->Array.Vertex.Size;
4487 break;
4488 case GL_VERTEX_ARRAY_TYPE:
4489 *params = ctx->Array.Vertex.Type;
4490 break;
4491 case GL_VERTEX_ARRAY_STRIDE:
4492 *params = ctx->Array.Vertex.Stride;
4493 break;
4494 case GL_VERTEX_ARRAY_COUNT_EXT:
4495 *params = 0;
4496 break;
4497 case GL_NORMAL_ARRAY:
4498 *params = (GLint) ctx->Array.Normal.Enabled;
4499 break;
4500 case GL_NORMAL_ARRAY_TYPE:
4501 *params = ctx->Array.Normal.Type;
4502 break;
4503 case GL_NORMAL_ARRAY_STRIDE:
4504 *params = ctx->Array.Normal.Stride;
4505 break;
4506 case GL_NORMAL_ARRAY_COUNT_EXT:
4507 *params = 0;
4508 break;
4509 case GL_COLOR_ARRAY:
4510 *params = (GLint) ctx->Array.Color.Enabled;
4511 break;
4512 case GL_COLOR_ARRAY_SIZE:
4513 *params = ctx->Array.Color.Size;
4514 break;
4515 case GL_COLOR_ARRAY_TYPE:
4516 *params = ctx->Array.Color.Type;
4517 break;
4518 case GL_COLOR_ARRAY_STRIDE:
4519 *params = ctx->Array.Color.Stride;
4520 break;
4521 case GL_COLOR_ARRAY_COUNT_EXT:
4522 *params = 0;
4523 break;
4524 case GL_INDEX_ARRAY:
4525 *params = (GLint) ctx->Array.Index.Enabled;
4526 break;
4527 case GL_INDEX_ARRAY_TYPE:
4528 *params = ctx->Array.Index.Type;
4529 break;
4530 case GL_INDEX_ARRAY_STRIDE:
4531 *params = ctx->Array.Index.Stride;
4532 break;
4533 case GL_INDEX_ARRAY_COUNT_EXT:
4534 *params = 0;
4535 break;
4536 case GL_TEXTURE_COORD_ARRAY:
4537 *params = (GLint) ctx->Array.TexCoord[texUnit].Enabled;
4538 break;
4539 case GL_TEXTURE_COORD_ARRAY_SIZE:
4540 *params = ctx->Array.TexCoord[texUnit].Size;
4541 break;
4542 case GL_TEXTURE_COORD_ARRAY_TYPE:
4543 *params = ctx->Array.TexCoord[texUnit].Type;
4544 break;
4545 case GL_TEXTURE_COORD_ARRAY_STRIDE:
4546 *params = ctx->Array.TexCoord[texUnit].Stride;
4547 break;
4548 case GL_TEXTURE_COORD_ARRAY_COUNT_EXT:
4549 *params = 0;
4550 break;
4551 case GL_EDGE_FLAG_ARRAY:
4552 *params = (GLint) ctx->Array.EdgeFlag.Enabled;
4553 break;
4554 case GL_EDGE_FLAG_ARRAY_STRIDE:
4555 *params = ctx->Array.EdgeFlag.Stride;
4556 break;
4557 case GL_EDGE_FLAG_ARRAY_COUNT_EXT:
4558 *params = 0;
4559 break;
4560
4561 /* GL_ARB_multitexture */
4562 case GL_MAX_TEXTURE_UNITS_ARB:
4563 *params = ctx->Const.MaxTextureUnits;
4564 break;
4565 case GL_ACTIVE_TEXTURE_ARB:
4566 *params = GL_TEXTURE0_ARB + ctx->Texture.CurrentUnit;
4567 break;
4568 case GL_CLIENT_ACTIVE_TEXTURE_ARB:
4569 *params = GL_TEXTURE0_ARB + ctx->Array.ActiveTexture;
4570 break;
4571
4572 /* GL_ARB_texture_cube_map */
4573 case GL_TEXTURE_CUBE_MAP_ARB:
4574 if (ctx->Extensions.ARB_texture_cube_map)
4575 *params = (GLint) _mesa_IsEnabled(GL_TEXTURE_CUBE_MAP_ARB);
4576 else
4577 _mesa_error(ctx, GL_INVALID_ENUM, "glGetIntegerv");
4578 return;
4579 case GL_TEXTURE_BINDING_CUBE_MAP_ARB:
4580 if (ctx->Extensions.ARB_texture_cube_map)
4581 *params = textureUnit->CurrentCubeMap->Name;
4582 else
4583 _mesa_error(ctx, GL_INVALID_ENUM, "glGetIntegerv");
4584 return;
4585 case GL_MAX_CUBE_MAP_TEXTURE_SIZE_ARB:
4586 if (ctx->Extensions.ARB_texture_cube_map)
4587 *params = ctx->Const.MaxCubeTextureSize;
4588 else
4589 _mesa_error(ctx, GL_INVALID_ENUM, "glGetIntegerv");
4590 return;
4591
4592 /* GL_ARB_texture_compression */
4593 case GL_TEXTURE_COMPRESSION_HINT_ARB:
4594 if (ctx->Extensions.ARB_texture_compression) {
4595 *params = (GLint) ctx->Hint.TextureCompression;
4596 }
4597 else
4598 _mesa_error(ctx, GL_INVALID_ENUM, "glGetIntegerv");
4599 break;
4600 case GL_NUM_COMPRESSED_TEXTURE_FORMATS_ARB:
4601 if (ctx->Extensions.ARB_texture_compression) {
4602 *params = (GLint) ctx->Const.NumCompressedTextureFormats;
4603 }
4604 else
4605 _mesa_error(ctx, GL_INVALID_ENUM, "glGetIntegerv");
4606 break;
4607 case GL_COMPRESSED_TEXTURE_FORMATS_ARB:
4608 if (ctx->Extensions.ARB_texture_compression) {
4609 GLuint i;
4610 for (i = 0; i < ctx->Const.NumCompressedTextureFormats; i++)
4611 params[i] = (GLint) ctx->Const.CompressedTextureFormats[i];
4612 }
4613 else
4614 _mesa_error(ctx, GL_INVALID_ENUM, "glGetIntegerv");
4615 break;
4616
4617 /* GL_EXT_compiled_vertex_array */
4618 case GL_ARRAY_ELEMENT_LOCK_FIRST_EXT:
4619 *params = ctx->Array.LockFirst;
4620 break;
4621 case GL_ARRAY_ELEMENT_LOCK_COUNT_EXT:
4622 *params = ctx->Array.LockCount;
4623 break;
4624
4625 /* GL_ARB_transpose_matrix */
4626 case GL_TRANSPOSE_COLOR_MATRIX_ARB:
4627 {
4628 GLfloat tm[16];
4629 GLuint i;
4630 _math_transposef(tm, ctx->ColorMatrix.m);
4631 for (i=0;i<16;i++) {
4632 params[i] = (GLint) tm[i];
4633 }
4634 }
4635 break;
4636 case GL_TRANSPOSE_MODELVIEW_MATRIX_ARB:
4637 {
4638 GLfloat tm[16];
4639 GLuint i;
4640 _math_transposef(tm, ctx->ModelView.m);
4641 for (i=0;i<16;i++) {
4642 params[i] = (GLint) tm[i];
4643 }
4644 }
4645 break;
4646 case GL_TRANSPOSE_PROJECTION_MATRIX_ARB:
4647 {
4648 GLfloat tm[16];
4649 GLuint i;
4650 _math_transposef(tm, ctx->ProjectionMatrix.m);
4651 for (i=0;i<16;i++) {
4652 params[i] = (GLint) tm[i];
4653 }
4654 }
4655 break;
4656 case GL_TRANSPOSE_TEXTURE_MATRIX_ARB:
4657 {
4658 GLfloat tm[16];
4659 GLuint i;
4660 _math_transposef(tm, ctx->TextureMatrix[texTransformUnit].m);
4661 for (i=0;i<16;i++) {
4662 params[i] = (GLint) tm[i];
4663 }
4664 }
4665 break;
4666
4667 /* GL_HP_occlusion_test */
4668 case GL_OCCLUSION_TEST_HP:
4669 if (ctx->Extensions.HP_occlusion_test) {
4670 *params = (GLint) ctx->Depth.OcclusionTest;
4671 }
4672 else {
4673 _mesa_error( ctx, GL_INVALID_ENUM, "glGetIntegerv" );
4674 }
4675 return;
4676 case GL_OCCLUSION_TEST_RESULT_HP:
4677 if (ctx->Extensions.HP_occlusion_test) {
4678 if (ctx->Depth.OcclusionTest)
4679 *params = (GLint) ctx->OcclusionResult;
4680 else
4681 *params = (GLint) ctx->OcclusionResultSaved;
4682 /* reset flag now */
4683 ctx->OcclusionResult = GL_FALSE;
4684 ctx->OcclusionResultSaved = GL_FALSE;
4685 }
4686 else {
4687 _mesa_error( ctx, GL_INVALID_ENUM, "glGetIntegerv" );
4688 }
4689 return;
4690
4691 /* GL_SGIS_pixel_texture */
4692 case GL_PIXEL_TEXTURE_SGIS:
4693 *params = (GLint) ctx->Pixel.PixelTextureEnabled;
4694 break;
4695
4696 /* GL_SGIX_pixel_texture */
4697 case GL_PIXEL_TEX_GEN_SGIX:
4698 *params = (GLint) ctx->Pixel.PixelTextureEnabled;
4699 break;
4700 case GL_PIXEL_TEX_GEN_MODE_SGIX:
4701 *params = (GLint) pixel_texgen_mode(ctx);
4702 break;
4703
4704 /* GL_SGI_color_matrix (also in 1.2 imaging) */
4705 case GL_COLOR_MATRIX_SGI:
4706 for (i=0;i<16;i++) {
4707 params[i] = (GLint) ctx->ColorMatrix.m[i];
4708 }
4709 break;
4710 case GL_COLOR_MATRIX_STACK_DEPTH_SGI:
4711 *params = ctx->ColorStackDepth + 1;
4712 break;
4713 case GL_MAX_COLOR_MATRIX_STACK_DEPTH_SGI:
4714 *params = MAX_COLOR_STACK_DEPTH;
4715 break;
4716 case GL_POST_COLOR_MATRIX_RED_SCALE_SGI:
4717 *params = (GLint) ctx->Pixel.PostColorMatrixScale[0];
4718 break;
4719 case GL_POST_COLOR_MATRIX_GREEN_SCALE_SGI:
4720 *params = (GLint) ctx->Pixel.PostColorMatrixScale[1];
4721 break;
4722 case GL_POST_COLOR_MATRIX_BLUE_SCALE_SGI:
4723 *params = (GLint) ctx->Pixel.PostColorMatrixScale[2];
4724 break;
4725 case GL_POST_COLOR_MATRIX_ALPHA_SCALE_SGI:
4726 *params = (GLint) ctx->Pixel.PostColorMatrixScale[3];
4727 break;
4728 case GL_POST_COLOR_MATRIX_RED_BIAS_SGI:
4729 *params = (GLint) ctx->Pixel.PostColorMatrixBias[0];
4730 break;
4731 case GL_POST_COLOR_MATRIX_GREEN_BIAS_SGI:
4732 *params = (GLint) ctx->Pixel.PostColorMatrixBias[1];
4733 break;
4734 case GL_POST_COLOR_MATRIX_BLUE_BIAS_SGI:
4735 *params = (GLint) ctx->Pixel.PostColorMatrixBias[2];
4736 break;
4737 case GL_POST_COLOR_MATRIX_ALPHA_BIAS_SGI:
4738 *params = (GLint) ctx->Pixel.PostColorMatrixBias[3];
4739 break;
4740
4741 /* GL_EXT_convolution (also in 1.2 imaging) */
4742 case GL_CONVOLUTION_1D_EXT:
4743 if (ctx->Extensions.EXT_convolution || ctx->Extensions.ARB_imaging) {
4744 *params = (GLint) ctx->Pixel.Convolution1DEnabled;
4745 }
4746 else {
4747 _mesa_error(ctx, GL_INVALID_ENUM, "glGetIntegerv");
4748 return;
4749 }
4750 break;
4751 case GL_CONVOLUTION_2D:
4752 if (ctx->Extensions.EXT_convolution || ctx->Extensions.ARB_imaging) {
4753 *params = (GLint) ctx->Pixel.Convolution2DEnabled;
4754 }
4755 else {
4756 _mesa_error(ctx, GL_INVALID_ENUM, "glGetIntegerv");
4757 return;
4758 }
4759 break;
4760 case GL_SEPARABLE_2D:
4761 if (ctx->Extensions.EXT_convolution || ctx->Extensions.ARB_imaging) {
4762 *params = (GLint) ctx->Pixel.Separable2DEnabled;
4763 }
4764 else {
4765 _mesa_error(ctx, GL_INVALID_ENUM, "glGetIntegerv");
4766 return;
4767 }
4768 break;
4769 case GL_MAX_CONVOLUTION_WIDTH:
4770 *params = ctx->Const.MaxConvolutionWidth;
4771 break;
4772 case GL_MAX_CONVOLUTION_HEIGHT:
4773 *params = ctx->Const.MaxConvolutionHeight;
4774 break;
4775 case GL_POST_CONVOLUTION_RED_SCALE_EXT:
4776 *params = (GLint) ctx->Pixel.PostConvolutionScale[0];
4777 break;
4778 case GL_POST_CONVOLUTION_GREEN_SCALE_EXT:
4779 *params = (GLint) ctx->Pixel.PostConvolutionScale[1];
4780 break;
4781 case GL_POST_CONVOLUTION_BLUE_SCALE_EXT:
4782 *params = (GLint) ctx->Pixel.PostConvolutionScale[2];
4783 break;
4784 case GL_POST_CONVOLUTION_ALPHA_SCALE_EXT:
4785 *params = (GLint) ctx->Pixel.PostConvolutionScale[3];
4786 break;
4787 case GL_POST_CONVOLUTION_RED_BIAS_EXT:
4788 *params = (GLint) ctx->Pixel.PostConvolutionBias[0];
4789 break;
4790 case GL_POST_CONVOLUTION_GREEN_BIAS_EXT:
4791 *params = (GLint) ctx->Pixel.PostConvolutionBias[1];
4792 break;
4793 case GL_POST_CONVOLUTION_BLUE_BIAS_EXT:
4794 *params = (GLint) ctx->Pixel.PostConvolutionBias[2];
4795 break;
4796 case GL_POST_CONVOLUTION_ALPHA_BIAS_EXT:
4797 *params = (GLint) ctx->Pixel.PostConvolutionBias[2];
4798 break;
4799
4800 /* GL_SGI_color_table (also in 1.2 imaging */
4801 case GL_COLOR_TABLE_SGI:
4802 *params = (GLint) ctx->Pixel.ColorTableEnabled;
4803 break;
4804 case GL_POST_CONVOLUTION_COLOR_TABLE_SGI:
4805 *params = (GLint) ctx->Pixel.PostConvolutionColorTableEnabled;
4806 break;
4807 case GL_POST_COLOR_MATRIX_COLOR_TABLE_SGI:
4808 *params = (GLint) ctx->Pixel.PostColorMatrixColorTableEnabled;
4809 break;
4810
4811
4812 /* GL_EXT_secondary_color */
4813 case GL_COLOR_SUM_EXT:
4814 *params = (GLint) ctx->Fog.ColorSumEnabled;
4815 break;
4816 case GL_CURRENT_SECONDARY_COLOR_EXT:
4817 FLUSH_CURRENT(ctx, 0);
4818 params[0] = FLOAT_TO_INT( (ctx->Current.SecondaryColor[0]) );
4819 params[1] = FLOAT_TO_INT( (ctx->Current.SecondaryColor[1]) );
4820 params[2] = FLOAT_TO_INT( (ctx->Current.SecondaryColor[2]) );
4821 break;
4822 case GL_SECONDARY_COLOR_ARRAY_EXT:
4823 *params = (GLint) ctx->Array.SecondaryColor.Enabled;
4824 break;
4825 case GL_SECONDARY_COLOR_ARRAY_TYPE_EXT:
4826 *params = (GLint) ctx->Array.SecondaryColor.Type;
4827 break;
4828 case GL_SECONDARY_COLOR_ARRAY_STRIDE_EXT:
4829 *params = (GLint) ctx->Array.SecondaryColor.Stride;
4830 break;
4831 case GL_SECONDARY_COLOR_ARRAY_SIZE_EXT:
4832 *params = (GLint) ctx->Array.SecondaryColor.Stride;
4833 break;
4834
4835 /* GL_EXT_fog_coord */
4836 case GL_CURRENT_FOG_COORDINATE_EXT:
4837 if (ctx->Extensions.EXT_fog_coord) {
4838 FLUSH_CURRENT(ctx, 0);
4839 *params = (GLint) ctx->Current.FogCoord;
4840 }
4841 else {
4842 _mesa_error( ctx, GL_INVALID_ENUM, "glGetIntegerv" );
4843 }
4844 break;
4845 case GL_FOG_COORDINATE_ARRAY_EXT:
4846 if (ctx->Extensions.EXT_fog_coord) {
4847 *params = (GLint) ctx->Array.FogCoord.Enabled;
4848 }
4849 else {
4850 _mesa_error( ctx, GL_INVALID_ENUM, "glGetIntegerv" );
4851 }
4852 break;
4853 case GL_FOG_COORDINATE_ARRAY_TYPE_EXT:
4854 if (ctx->Extensions.EXT_fog_coord) {
4855 *params = (GLint) ctx->Array.FogCoord.Type;
4856 }
4857 else {
4858 _mesa_error( ctx, GL_INVALID_ENUM, "glGetIntegerv" );
4859 }
4860 break;
4861 case GL_FOG_COORDINATE_ARRAY_STRIDE_EXT:
4862 if (ctx->Extensions.EXT_fog_coord) {
4863 *params = (GLint) ctx->Array.FogCoord.Stride;
4864 }
4865 else {
4866 _mesa_error( ctx, GL_INVALID_ENUM, "glGetIntegerv" );
4867 }
4868 break;
4869
4870 /* GL_EXT_texture_filter_anisotropic */
4871 case GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT:
4872 if (ctx->Extensions.EXT_texture_filter_anisotropic) {
4873 *params = (GLint) ctx->Const.MaxTextureMaxAnisotropy;
4874 }
4875 else {
4876 _mesa_error( ctx, GL_INVALID_ENUM, "glGetIntegerv" );
4877 return;
4878 }
4879 break;
4880
4881 /* GL_MESA_sprite_point */
4882 case GL_SPRITE_POINT_MESA:
4883 if (ctx->Extensions.MESA_sprite_point) {
4884 *params = (GLint) ctx->Point.SpriteMode;
4885 }
4886 else {
4887 _mesa_error( ctx, GL_INVALID_ENUM, "glGetIntegerv" );
4888 return;
4889 }
4890 break;
4891
4892 default:
4893 _mesa_error( ctx, GL_INVALID_ENUM, "glGetIntegerv" );
4894 }
4895 }
4896
4897
4898
4899 void
4900 _mesa_GetPointerv( GLenum pname, GLvoid **params )
4901 {
4902 GET_CURRENT_CONTEXT(ctx);
4903 GLuint texUnit = ctx->Texture.CurrentUnit;
4904 ASSERT_OUTSIDE_BEGIN_END(ctx);
4905
4906 if (!params)
4907 return;
4908
4909 if (MESA_VERBOSE & VERBOSE_API)
4910 fprintf(stderr, "glGetPointerv %s\n", _mesa_lookup_enum_by_nr(pname));
4911
4912 if (ctx->Driver.GetPointerv
4913 && (*ctx->Driver.GetPointerv)(ctx, pname, params))
4914 return;
4915
4916 switch (pname) {
4917 case GL_VERTEX_ARRAY_POINTER:
4918 *params = ctx->Array.Vertex.Ptr;
4919 break;
4920 case GL_NORMAL_ARRAY_POINTER:
4921 *params = ctx->Array.Normal.Ptr;
4922 break;
4923 case GL_COLOR_ARRAY_POINTER:
4924 *params = ctx->Array.Color.Ptr;
4925 break;
4926 case GL_SECONDARY_COLOR_ARRAY_POINTER_EXT:
4927 *params = ctx->Array.SecondaryColor.Ptr;
4928 break;
4929 case GL_FOG_COORDINATE_ARRAY_POINTER_EXT:
4930 *params = ctx->Array.FogCoord.Ptr;
4931 break;
4932 case GL_INDEX_ARRAY_POINTER:
4933 *params = ctx->Array.Index.Ptr;
4934 break;
4935 case GL_TEXTURE_COORD_ARRAY_POINTER:
4936 *params = ctx->Array.TexCoord[texUnit].Ptr;
4937 break;
4938 case GL_EDGE_FLAG_ARRAY_POINTER:
4939 *params = ctx->Array.EdgeFlag.Ptr;
4940 break;
4941 case GL_FEEDBACK_BUFFER_POINTER:
4942 *params = ctx->Feedback.Buffer;
4943 break;
4944 case GL_SELECTION_BUFFER_POINTER:
4945 *params = ctx->Select.Buffer;
4946 break;
4947 default:
4948 _mesa_error( ctx, GL_INVALID_ENUM, "glGetPointerv" );
4949 return;
4950 }
4951 }
4952
4953
4954
4955 const GLubyte *
4956 _mesa_GetString( GLenum name )
4957 {
4958 GET_CURRENT_CONTEXT(ctx);
4959 static const char *vendor = "Brian Paul";
4960 static const char *renderer = "Mesa";
4961 static const char *version = "1.2 Mesa 3.5 beta";
4962 ASSERT_OUTSIDE_BEGIN_END_WITH_RETVAL(ctx, 0);
4963
4964 /* this is a required driver function */
4965 assert(ctx->Driver.GetString);
4966 {
4967 const GLubyte *str = (*ctx->Driver.GetString)(ctx, name);
4968 if (str)
4969 return str;
4970
4971 switch (name) {
4972 case GL_VENDOR:
4973 return (const GLubyte *) vendor;
4974 case GL_RENDERER:
4975 return (const GLubyte *) renderer;
4976 case GL_VERSION:
4977 return (const GLubyte *) version;
4978 case GL_EXTENSIONS:
4979 return (const GLubyte *) _mesa_extensions_get_string(ctx);
4980 default:
4981 _mesa_error( ctx, GL_INVALID_ENUM, "glGetString" );
4982 return (const GLubyte *) 0;
4983 }
4984 }
4985 }
4986
4987
4988 /*
4989 * Execute a glGetError command
4990 */
4991 GLenum
4992 _mesa_GetError( void )
4993 {
4994 GET_CURRENT_CONTEXT(ctx);
4995 GLenum e = ctx->ErrorValue;
4996 ASSERT_OUTSIDE_BEGIN_END_WITH_RETVAL(ctx, 0);
4997
4998 if (MESA_VERBOSE & VERBOSE_API)
4999 fprintf(stderr, "glGetError <-- %s\n", _mesa_lookup_enum_by_nr(e));
5000
5001 ctx->ErrorValue = (GLenum) GL_NO_ERROR;
5002 return e;
5003 }