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