source: trunk/src/opengl/mesa/get.c@ 3670

Last change on this file since 3670 was 3598, checked in by jeroen, 25 years ago

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