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