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