projects / mesa.git / blob
? search:


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