projects / mesa.git / blob
? search:


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