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