projects / mesa.git / blob
? search:


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