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