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