projects / mesa.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
replaced components with internalFormat
[mesa.git] / src / mesa / main / get.c
1 /* $Id: get.c,v 1.25 2000/05/07 23:18:54 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 case GL_MAX_TEXTURE_UNITS_ARB:
947 *params = ctx->Const.MaxTextureUnits;
948 break;
949 case GL_ACTIVE_TEXTURE_ARB:
950 *params = INT_TO_BOOL(GL_TEXTURE0_ARB + ctx->Texture.CurrentUnit);
951 break;
952 case GL_CLIENT_ACTIVE_TEXTURE_ARB:
953 *params = INT_TO_BOOL(GL_TEXTURE0_ARB + ctx->Array.ActiveTexture);
954 break;
955
956 /* GL_PGI_misc_hints */
957 case GL_STRICT_DEPTHFUNC_HINT_PGI:
958 *params = ENUM_TO_BOOL(GL_NICEST);
959 break;
960 case GL_STRICT_LIGHTING_HINT_PGI:
961 *params = ENUM_TO_BOOL(ctx->Hint.StrictLighting);
962 break;
963 case GL_STRICT_SCISSOR_HINT_PGI:
964 case GL_FULL_STIPPLE_HINT_PGI:
965 *params = ENUM_TO_BOOL(GL_TRUE);
966 break;
967 case GL_CONSERVE_MEMORY_HINT_PGI:
968 *params = ENUM_TO_BOOL(GL_FALSE);
969 break;
970 case GL_ALWAYS_FAST_HINT_PGI:
971 *params = (GLboolean) (ctx->Hint.AllowDrawWin == GL_TRUE &&
972 ctx->Hint.AllowDrawFrg == GL_FALSE &&
973 ctx->Hint.AllowDrawMem == GL_FALSE);
974 break;
975 case GL_ALWAYS_SOFT_HINT_PGI:
976 *params = (GLboolean) (ctx->Hint.AllowDrawWin == GL_TRUE &&
977 ctx->Hint.AllowDrawFrg == GL_TRUE &&
978 ctx->Hint.AllowDrawMem == GL_TRUE);
979 break;
980 case GL_ALLOW_DRAW_OBJ_HINT_PGI:
981 *params = (GLboolean) GL_TRUE;
982 break;
983 case GL_ALLOW_DRAW_WIN_HINT_PGI:
984 *params = (GLboolean) ctx->Hint.AllowDrawWin;
985 break;
986 case GL_ALLOW_DRAW_FRG_HINT_PGI:
987 *params = (GLboolean) ctx->Hint.AllowDrawFrg;
988 break;
989 case GL_ALLOW_DRAW_MEM_HINT_PGI:
990 *params = (GLboolean) ctx->Hint.AllowDrawMem;
991 break;
992 case GL_CLIP_NEAR_HINT_PGI:
993 case GL_CLIP_FAR_HINT_PGI:
994 *params = ENUM_TO_BOOL(GL_TRUE);
995 break;
996 case GL_WIDE_LINE_HINT_PGI:
997 *params = ENUM_TO_BOOL(GL_DONT_CARE);
998 break;
999 case GL_BACK_NORMALS_HINT_PGI:
1000 *params = ENUM_TO_BOOL(GL_TRUE);
1001 break;
1002 case GL_NATIVE_GRAPHICS_HANDLE_PGI:
1003 *params = 0;
1004 break;
1005
1006 /* GL_EXT_compiled_vertex_array */
1007 case GL_ARRAY_ELEMENT_LOCK_FIRST_EXT:
1008 *params = ctx->Array.LockFirst ? GL_TRUE : GL_FALSE;
1009 break;
1010 case GL_ARRAY_ELEMENT_LOCK_COUNT_EXT:
1011 *params = ctx->Array.LockCount ? GL_TRUE : GL_FALSE;
1012 break;
1013
1014 /* GL_ARB_transpose_matrix */
1015 case GL_TRANSPOSE_COLOR_MATRIX_ARB:
1016 /* don't have a color matrix */
1017 break;
1018 case GL_TRANSPOSE_MODELVIEW_MATRIX_ARB:
1019 {
1020 GLfloat tm[16];
1021 GLuint i;
1022 gl_matrix_transposef(tm, ctx->ModelView.m);
1023 for (i=0;i<16;i++) {
1024 params[i] = FLOAT_TO_BOOL(tm[i]);
1025 }
1026 }
1027 break;
1028 case GL_TRANSPOSE_PROJECTION_MATRIX_ARB:
1029 {
1030 GLfloat tm[16];
1031 GLuint i;
1032 gl_matrix_transposef(tm, ctx->ProjectionMatrix.m);
1033 for (i=0;i<16;i++) {
1034 params[i] = FLOAT_TO_BOOL(tm[i]);
1035 }
1036 }
1037 break;
1038 case GL_TRANSPOSE_TEXTURE_MATRIX_ARB:
1039 {
1040 GLfloat tm[16];
1041 GLuint i;
1042 gl_matrix_transposef(tm, ctx->TextureMatrix[texTransformUnit].m);
1043 for (i=0;i<16;i++) {
1044 params[i] = FLOAT_TO_BOOL(tm[i]);
1045 }
1046 }
1047 break;
1048
1049 /* GL_HP_occlusion_test */
1050 case GL_OCCLUSION_TEST_HP:
1051 if (ctx->Extensions.HaveHpOcclusionTest) {
1052 *params = ctx->Depth.OcclusionTest;
1053 }
1054 else {
1055 gl_error( ctx, GL_INVALID_ENUM, "glGetBooleanv" );
1056 }
1057 return;
1058 case GL_OCCLUSION_TEST_RESULT_HP:
1059 if (ctx->Extensions.HaveHpOcclusionTest) {
1060 if (ctx->Depth.OcclusionTest)
1061 *params = ctx->OcclusionResult;
1062 else
1063 *params = ctx->OcclusionResultSaved;
1064 /* reset flag now */
1065 ctx->OcclusionResult = GL_FALSE;
1066 ctx->OcclusionResultSaved = GL_FALSE;
1067 }
1068 else {
1069 gl_error( ctx, GL_INVALID_ENUM, "glGetBooleanv" );
1070 }
1071 return;
1072
1073 /* GL_SGIS_pixel_texture */
1074 case GL_PIXEL_TEXTURE_SGIS:
1075 *params = ctx->Pixel.PixelTextureEnabled;
1076 break;
1077
1078 /* GL_SGIX_pixel_texture */
1079 case GL_PIXEL_TEX_GEN_SGIX:
1080 *params = ctx->Pixel.PixelTextureEnabled;
1081 break;
1082 case GL_PIXEL_TEX_GEN_MODE_SGIX:
1083 *params = (GLboolean) pixel_texgen_mode(ctx);
1084 break;
1085
1086 /* GL_SGI_color_matrix (also in 1.2 imaging) */
1087 case GL_COLOR_MATRIX_SGI:
1088 for (i=0;i<16;i++) {
1089 params[i] = FLOAT_TO_BOOL(ctx->ColorMatrix.m[i]);
1090 }
1091 break;
1092 case GL_COLOR_MATRIX_STACK_DEPTH_SGI:
1093 *params = INT_TO_BOOL(ctx->ColorStackDepth + 1);
1094 break;
1095 case GL_MAX_COLOR_MATRIX_STACK_DEPTH_SGI:
1096 *params = FLOAT_TO_BOOL(MAX_COLOR_STACK_DEPTH);
1097 break;
1098 case GL_POST_COLOR_MATRIX_RED_SCALE_SGI:
1099 *params = FLOAT_TO_BOOL(ctx->Pixel.PostColorMatrixScale[0]);
1100 break;
1101 case GL_POST_COLOR_MATRIX_GREEN_SCALE_SGI:
1102 *params = FLOAT_TO_BOOL(ctx->Pixel.PostColorMatrixScale[1]);
1103 break;
1104 case GL_POST_COLOR_MATRIX_BLUE_SCALE_SGI:
1105 *params = FLOAT_TO_BOOL(ctx->Pixel.PostColorMatrixScale[2]);
1106 break;
1107 case GL_POST_COLOR_MATRIX_ALPHA_SCALE_SGI:
1108 *params = FLOAT_TO_BOOL(ctx->Pixel.PostColorMatrixScale[3]);
1109 break;
1110 case GL_POST_COLOR_MATRIX_RED_BIAS_SGI:
1111 *params = FLOAT_TO_BOOL(ctx->Pixel.PostColorMatrixBias[0]);
1112 break;
1113 case GL_POST_COLOR_MATRIX_GREEN_BIAS_SGI:
1114 *params = FLOAT_TO_BOOL(ctx->Pixel.PostColorMatrixBias[1]);
1115 break;
1116 case GL_POST_COLOR_MATRIX_BLUE_BIAS_SGI:
1117 *params = FLOAT_TO_BOOL(ctx->Pixel.PostColorMatrixBias[2]);
1118 break;
1119 case GL_POST_COLOR_MATRIX_ALPHA_BIAS_SGI:
1120 *params = FLOAT_TO_BOOL(ctx->Pixel.PostColorMatrixBias[3]);
1121 break;
1122
1123 /* GL_EXT_convolution (also in 1.2 imaging) */
1124 case GL_MAX_CONVOLUTION_WIDTH:
1125 *params = INT_TO_BOOL(ctx->Const.MaxConvolutionWidth);
1126 break;
1127 case GL_MAX_CONVOLUTION_HEIGHT:
1128 *params = INT_TO_BOOL(ctx->Const.MaxConvolutionHeight);
1129 break;
1130 case GL_POST_CONVOLUTION_RED_SCALE_EXT:
1131 *params = FLOAT_TO_BOOL(ctx->Pixel.PostConvolutionScale[0]);
1132 break;
1133 case GL_POST_CONVOLUTION_GREEN_SCALE_EXT:
1134 *params = FLOAT_TO_BOOL(ctx->Pixel.PostConvolutionScale[1]);
1135 break;
1136 case GL_POST_CONVOLUTION_BLUE_SCALE_EXT:
1137 *params = FLOAT_TO_BOOL(ctx->Pixel.PostConvolutionScale[2]);
1138 break;
1139 case GL_POST_CONVOLUTION_ALPHA_SCALE_EXT:
1140 *params = FLOAT_TO_BOOL(ctx->Pixel.PostConvolutionScale[3]);
1141 break;
1142 case GL_POST_CONVOLUTION_RED_BIAS_EXT:
1143 *params = FLOAT_TO_BOOL(ctx->Pixel.PostConvolutionBias[0]);
1144 break;
1145 case GL_POST_CONVOLUTION_GREEN_BIAS_EXT:
1146 *params = FLOAT_TO_BOOL(ctx->Pixel.PostConvolutionBias[1]);
1147 break;
1148 case GL_POST_CONVOLUTION_BLUE_BIAS_EXT:
1149 *params = FLOAT_TO_BOOL(ctx->Pixel.PostConvolutionBias[2]);
1150 break;
1151 case GL_POST_CONVOLUTION_ALPHA_BIAS_EXT:
1152 *params = FLOAT_TO_BOOL(ctx->Pixel.PostConvolutionBias[2]);
1153 break;
1154
1155 /* GL_SGI_color_table (also in 1.2 imaging */
1156 case GL_COLOR_TABLE_SGI:
1157 *params = ctx->Pixel.ColorTableEnabled;
1158 break;
1159 case GL_POST_CONVOLUTION_COLOR_TABLE_SGI:
1160 *params = ctx->Pixel.PostConvolutionColorTableEnabled;
1161 break;
1162 case GL_POST_COLOR_MATRIX_COLOR_TABLE_SGI:
1163 *params = ctx->Pixel.PostColorMatrixColorTableEnabled;
1164 break;
1165
1166 default:
1167 gl_error( ctx, GL_INVALID_ENUM, "glGetBooleanv" );
1168 }
1169 }
1170
1171
1172
1173
1174 void
1175 _mesa_GetDoublev( GLenum pname, GLdouble *params )
1176 {
1177 GET_CURRENT_CONTEXT(ctx);
1178 GLuint i;
1179 GLuint texUnit = ctx->Texture.CurrentUnit;
1180 GLuint texTransformUnit = ctx->Texture.CurrentTransformUnit;
1181 const struct gl_texture_unit *textureUnit = &ctx->Texture.Unit[texUnit];
1182
1183 ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx, "glGetDoublev");
1184
1185 if (MESA_VERBOSE & VERBOSE_API)
1186 fprintf(stderr, "glGetDoublev %s\n", gl_lookup_enum_by_nr(pname));
1187
1188 switch (pname) {
1189 case GL_ACCUM_RED_BITS:
1190 *params = (GLdouble) ctx->Visual->AccumRedBits;
1191 break;
1192 case GL_ACCUM_GREEN_BITS:
1193 *params = (GLdouble) ctx->Visual->AccumGreenBits;
1194 break;
1195 case GL_ACCUM_BLUE_BITS:
1196 *params = (GLdouble) ctx->Visual->AccumBlueBits;
1197 break;
1198 case GL_ACCUM_ALPHA_BITS:
1199 *params = (GLdouble) ctx->Visual->AccumAlphaBits;
1200 break;
1201 case GL_ACCUM_CLEAR_VALUE:
1202 params[0] = (GLdouble) ctx->Accum.ClearColor[0];
1203 params[1] = (GLdouble) ctx->Accum.ClearColor[1];
1204 params[2] = (GLdouble) ctx->Accum.ClearColor[2];
1205 params[3] = (GLdouble) ctx->Accum.ClearColor[3];
1206 break;
1207 case GL_ALPHA_BIAS:
1208 *params = (GLdouble) ctx->Pixel.AlphaBias;
1209 break;
1210 case GL_ALPHA_BITS:
1211 *params = (GLdouble) ctx->Visual->AlphaBits;
1212 break;
1213 case GL_ALPHA_SCALE:
1214 *params = (GLdouble) ctx->Pixel.AlphaScale;
1215 break;
1216 case GL_ALPHA_TEST:
1217 *params = (GLdouble) ctx->Color.AlphaEnabled;
1218 break;
1219 case GL_ALPHA_TEST_FUNC:
1220 *params = ENUM_TO_DOUBLE(ctx->Color.AlphaFunc);
1221 break;
1222 case GL_ALPHA_TEST_REF:
1223 *params = (GLdouble) ctx->Color.AlphaRef / 255.0;
1224 break;
1225 case GL_ATTRIB_STACK_DEPTH:
1226 *params = (GLdouble ) (ctx->AttribStackDepth);
1227 break;
1228 case GL_AUTO_NORMAL:
1229 *params = (GLdouble) ctx->Eval.AutoNormal;
1230 break;
1231 case GL_AUX_BUFFERS:
1232 *params = (GLdouble) ctx->Const.NumAuxBuffers;
1233 break;
1234 case GL_BLEND:
1235 *params = (GLdouble) ctx->Color.BlendEnabled;
1236 break;
1237 case GL_BLEND_DST:
1238 *params = ENUM_TO_DOUBLE(ctx->Color.BlendDstRGB);
1239 break;
1240 case GL_BLEND_SRC:
1241 *params = ENUM_TO_DOUBLE(ctx->Color.BlendSrcRGB);
1242 break;
1243 case GL_BLEND_SRC_RGB_EXT:
1244 *params = ENUM_TO_DOUBLE(ctx->Color.BlendSrcRGB);
1245 break;
1246 case GL_BLEND_DST_RGB_EXT:
1247 *params = ENUM_TO_DOUBLE(ctx->Color.BlendDstRGB);
1248 break;
1249 case GL_BLEND_SRC_ALPHA_EXT:
1250 *params = ENUM_TO_DOUBLE(ctx->Color.BlendSrcA);
1251 break;
1252 case GL_BLEND_DST_ALPHA_EXT:
1253 *params = ENUM_TO_DOUBLE(ctx->Color.BlendDstA);
1254 break;
1255 case GL_BLEND_EQUATION_EXT:
1256 *params = ENUM_TO_DOUBLE(ctx->Color.BlendEquation);
1257 break;
1258 case GL_BLEND_COLOR_EXT:
1259 params[0] = (GLdouble) ctx->Color.BlendColor[0];
1260 params[1] = (GLdouble) ctx->Color.BlendColor[1];
1261 params[2] = (GLdouble) ctx->Color.BlendColor[2];
1262 params[3] = (GLdouble) ctx->Color.BlendColor[3];
1263 break;
1264 case GL_BLUE_BIAS:
1265 *params = (GLdouble) ctx->Pixel.BlueBias;
1266 break;
1267 case GL_BLUE_BITS:
1268 *params = (GLdouble) ctx->Visual->BlueBits;
1269 break;
1270 case GL_BLUE_SCALE:
1271 *params = (GLdouble) ctx->Pixel.BlueScale;
1272 break;
1273 case GL_CLIENT_ATTRIB_STACK_DEPTH:
1274 *params = (GLdouble) (ctx->ClientAttribStackDepth);
1275 break;
1276 case GL_CLIP_PLANE0:
1277 case GL_CLIP_PLANE1:
1278 case GL_CLIP_PLANE2:
1279 case GL_CLIP_PLANE3:
1280 case GL_CLIP_PLANE4:
1281 case GL_CLIP_PLANE5:
1282 *params = (GLdouble) ctx->Transform.ClipEnabled[pname-GL_CLIP_PLANE0];
1283 break;
1284 case GL_COLOR_CLEAR_VALUE:
1285 params[0] = (GLdouble) ctx->Color.ClearColor[0];
1286 params[1] = (GLdouble) ctx->Color.ClearColor[1];
1287 params[2] = (GLdouble) ctx->Color.ClearColor[2];
1288 params[3] = (GLdouble) ctx->Color.ClearColor[3];
1289 break;
1290 case GL_COLOR_MATERIAL:
1291 *params = (GLdouble) ctx->Light.ColorMaterialEnabled;
1292 break;
1293 case GL_COLOR_MATERIAL_FACE:
1294 *params = ENUM_TO_DOUBLE(ctx->Light.ColorMaterialFace);
1295 break;
1296 case GL_COLOR_MATERIAL_PARAMETER:
1297 *params = ENUM_TO_DOUBLE(ctx->Light.ColorMaterialMode);
1298 break;
1299 case GL_COLOR_WRITEMASK:
1300 params[0] = ctx->Color.ColorMask[RCOMP] ? 1.0 : 0.0;
1301 params[1] = ctx->Color.ColorMask[GCOMP] ? 1.0 : 0.0;
1302 params[2] = ctx->Color.ColorMask[BCOMP] ? 1.0 : 0.0;
1303 params[3] = ctx->Color.ColorMask[ACOMP] ? 1.0 : 0.0;
1304 break;
1305 case GL_CULL_FACE:
1306 *params = (GLdouble) ctx->Polygon.CullFlag;
1307 break;
1308 case GL_CULL_FACE_MODE:
1309 *params = ENUM_TO_DOUBLE(ctx->Polygon.CullFaceMode);
1310 break;
1311 case GL_CURRENT_COLOR:
1312 params[0] = UBYTE_COLOR_TO_FLOAT_COLOR(ctx->Current.ByteColor[0]);
1313 params[1] = UBYTE_COLOR_TO_FLOAT_COLOR(ctx->Current.ByteColor[1]);
1314 params[2] = UBYTE_COLOR_TO_FLOAT_COLOR(ctx->Current.ByteColor[2]);
1315 params[3] = UBYTE_COLOR_TO_FLOAT_COLOR(ctx->Current.ByteColor[3]);
1316 break;
1317 case GL_CURRENT_INDEX:
1318 *params = (GLdouble) ctx->Current.Index;
1319 break;
1320 case GL_CURRENT_NORMAL:
1321 params[0] = (GLdouble) ctx->Current.Normal[0];
1322 params[1] = (GLdouble) ctx->Current.Normal[1];
1323 params[2] = (GLdouble) ctx->Current.Normal[2];
1324 break;
1325 case GL_CURRENT_RASTER_COLOR:
1326 params[0] = (GLdouble) ctx->Current.RasterColor[0];
1327 params[1] = (GLdouble) ctx->Current.RasterColor[1];
1328 params[2] = (GLdouble) ctx->Current.RasterColor[2];
1329 params[3] = (GLdouble) ctx->Current.RasterColor[3];
1330 break;
1331 case GL_CURRENT_RASTER_DISTANCE:
1332 params[0] = (GLdouble) ctx->Current.RasterDistance;
1333 break;
1334 case GL_CURRENT_RASTER_INDEX:
1335 *params = (GLdouble) ctx->Current.RasterIndex;
1336 break;
1337 case GL_CURRENT_RASTER_POSITION:
1338 params[0] = (GLdouble) ctx->Current.RasterPos[0];
1339 params[1] = (GLdouble) ctx->Current.RasterPos[1];
1340 params[2] = (GLdouble) ctx->Current.RasterPos[2];
1341 params[3] = (GLdouble) ctx->Current.RasterPos[3];
1342 break;
1343 case GL_CURRENT_RASTER_TEXTURE_COORDS:
1344 params[0] = (GLdouble) ctx->Current.RasterMultiTexCoord[texTransformUnit][0];
1345 params[1] = (GLdouble) ctx->Current.RasterMultiTexCoord[texTransformUnit][1];
1346 params[2] = (GLdouble) ctx->Current.RasterMultiTexCoord[texTransformUnit][2];
1347 params[3] = (GLdouble) ctx->Current.RasterMultiTexCoord[texTransformUnit][3];
1348 break;
1349 case GL_CURRENT_RASTER_POSITION_VALID:
1350 *params = (GLdouble) ctx->Current.RasterPosValid;
1351 break;
1352 case GL_CURRENT_TEXTURE_COORDS:
1353 params[0] = (GLdouble) ctx->Current.Texcoord[texTransformUnit][0];
1354 params[1] = (GLdouble) ctx->Current.Texcoord[texTransformUnit][1];
1355 params[2] = (GLdouble) ctx->Current.Texcoord[texTransformUnit][2];
1356 params[3] = (GLdouble) ctx->Current.Texcoord[texTransformUnit][3];
1357 break;
1358 case GL_DEPTH_BIAS:
1359 *params = (GLdouble) ctx->Pixel.DepthBias;
1360 break;
1361 case GL_DEPTH_BITS:
1362 *params = (GLdouble) ctx->Visual->DepthBits;
1363 break;
1364 case GL_DEPTH_CLEAR_VALUE:
1365 *params = (GLdouble) ctx->Depth.Clear;
1366 break;
1367 case GL_DEPTH_FUNC:
1368 *params = ENUM_TO_DOUBLE(ctx->Depth.Func);
1369 break;
1370 case GL_DEPTH_RANGE:
1371 params[0] = (GLdouble) ctx->Viewport.Near;
1372 params[1] = (GLdouble) ctx->Viewport.Far;
1373 break;
1374 case GL_DEPTH_SCALE:
1375 *params = (GLdouble) ctx->Pixel.DepthScale;
1376 break;
1377 case GL_DEPTH_TEST:
1378 *params = (GLdouble) ctx->Depth.Test;
1379 break;
1380 case GL_DEPTH_WRITEMASK:
1381 *params = (GLdouble) ctx->Depth.Mask;
1382 break;
1383 case GL_DITHER:
1384 *params = (GLdouble) ctx->Color.DitherFlag;
1385 break;
1386 case GL_DOUBLEBUFFER:
1387 *params = (GLdouble) ctx->Visual->DBflag;
1388 break;
1389 case GL_DRAW_BUFFER:
1390 *params = ENUM_TO_DOUBLE(ctx->Color.DrawBuffer);
1391 break;
1392 case GL_EDGE_FLAG:
1393 *params = (GLdouble) ctx->Current.EdgeFlag;
1394 break;
1395 case GL_FEEDBACK_BUFFER_SIZE:
1396 *params = (GLdouble) ctx->Feedback.BufferSize;
1397 break;
1398 case GL_FEEDBACK_BUFFER_TYPE:
1399 *params = ENUM_TO_DOUBLE(ctx->Feedback.Type);
1400 break;
1401 case GL_FOG:
1402 *params = (GLdouble) ctx->Fog.Enabled;
1403 break;
1404 case GL_FOG_COLOR:
1405 params[0] = (GLdouble) ctx->Fog.Color[0];
1406 params[1] = (GLdouble) ctx->Fog.Color[1];
1407 params[2] = (GLdouble) ctx->Fog.Color[2];
1408 params[3] = (GLdouble) ctx->Fog.Color[3];
1409 break;
1410 case GL_FOG_DENSITY:
1411 *params = (GLdouble) ctx->Fog.Density;
1412 break;
1413 case GL_FOG_END:
1414 *params = (GLdouble) ctx->Fog.End;
1415 break;
1416 case GL_FOG_HINT:
1417 *params = ENUM_TO_DOUBLE(ctx->Hint.Fog);
1418 break;
1419 case GL_FOG_INDEX:
1420 *params = (GLdouble) ctx->Fog.Index;
1421 break;
1422 case GL_FOG_MODE:
1423 *params = ENUM_TO_DOUBLE(ctx->Fog.Mode);
1424 break;
1425 case GL_FOG_START:
1426 *params = (GLdouble) ctx->Fog.Start;
1427 break;
1428 case GL_FRONT_FACE:
1429 *params = ENUM_TO_DOUBLE(ctx->Polygon.FrontFace);
1430 break;
1431 case GL_GREEN_BIAS:
1432 *params = (GLdouble) ctx->Pixel.GreenBias;
1433 break;
1434 case GL_GREEN_BITS:
1435 *params = (GLdouble) ctx->Visual->GreenBits;
1436 break;
1437 case GL_GREEN_SCALE:
1438 *params = (GLdouble) ctx->Pixel.GreenScale;
1439 break;
1440 case GL_HISTOGRAM:
1441 *params = (GLdouble) ctx->Pixel.HistogramEnabled;
1442 break;
1443 case GL_INDEX_BITS:
1444 *params = (GLdouble) ctx->Visual->IndexBits;
1445 break;
1446 case GL_INDEX_CLEAR_VALUE:
1447 *params = (GLdouble) ctx->Color.ClearIndex;
1448 break;
1449 case GL_INDEX_MODE:
1450 *params = ctx->Visual->RGBAflag ? 0.0 : 1.0;
1451 break;
1452 case GL_INDEX_OFFSET:
1453 *params = (GLdouble) ctx->Pixel.IndexOffset;
1454 break;
1455 case GL_INDEX_SHIFT:
1456 *params = (GLdouble) ctx->Pixel.IndexShift;
1457 break;
1458 case GL_INDEX_WRITEMASK:
1459 *params = (GLdouble) ctx->Color.IndexMask;
1460 break;
1461 case GL_LIGHT0:
1462 case GL_LIGHT1:
1463 case GL_LIGHT2:
1464 case GL_LIGHT3:
1465 case GL_LIGHT4:
1466 case GL_LIGHT5:
1467 case GL_LIGHT6:
1468 case GL_LIGHT7:
1469 *params = (GLdouble) ctx->Light.Light[pname-GL_LIGHT0].Enabled;
1470 break;
1471 case GL_LIGHTING:
1472 *params = (GLdouble) ctx->Light.Enabled;
1473 break;
1474 case GL_LIGHT_MODEL_AMBIENT:
1475 params[0] = (GLdouble) ctx->Light.Model.Ambient[0];
1476 params[1] = (GLdouble) ctx->Light.Model.Ambient[1];
1477 params[2] = (GLdouble) ctx->Light.Model.Ambient[2];
1478 params[3] = (GLdouble) ctx->Light.Model.Ambient[3];
1479 break;
1480 case GL_LIGHT_MODEL_COLOR_CONTROL:
1481 params[0] = (GLdouble) ctx->Light.Model.ColorControl;
1482 break;
1483 case GL_LIGHT_MODEL_LOCAL_VIEWER:
1484 *params = (GLdouble) ctx->Light.Model.LocalViewer;
1485 break;
1486 case GL_LIGHT_MODEL_TWO_SIDE:
1487 *params = (GLdouble) ctx->Light.Model.TwoSide;
1488 break;
1489 case GL_LINE_SMOOTH:
1490 *params = (GLdouble) ctx->Line.SmoothFlag;
1491 break;
1492 case GL_LINE_SMOOTH_HINT:
1493 *params = ENUM_TO_DOUBLE(ctx->Hint.LineSmooth);
1494 break;
1495 case GL_LINE_STIPPLE:
1496 *params = (GLdouble) ctx->Line.StippleFlag;
1497 break;
1498 case GL_LINE_STIPPLE_PATTERN:
1499 *params = (GLdouble) ctx->Line.StipplePattern;
1500 break;
1501 case GL_LINE_STIPPLE_REPEAT:
1502 *params = (GLdouble) ctx->Line.StippleFactor;
1503 break;
1504 case GL_LINE_WIDTH:
1505 *params = (GLdouble) ctx->Line.Width;
1506 break;
1507 case GL_LINE_WIDTH_GRANULARITY:
1508 *params = (GLdouble) ctx->Const.LineWidthGranularity;
1509 break;
1510 case GL_LINE_WIDTH_RANGE:
1511 params[0] = (GLdouble) ctx->Const.MinLineWidthAA;
1512 params[1] = (GLdouble) ctx->Const.MaxLineWidthAA;
1513 break;
1514 case GL_ALIASED_LINE_WIDTH_RANGE:
1515 params[0] = (GLdouble) ctx->Const.MinLineWidth;
1516 params[1] = (GLdouble) ctx->Const.MaxLineWidth;
1517 break;
1518 case GL_LIST_BASE:
1519 *params = (GLdouble) ctx->List.ListBase;
1520 break;
1521 case GL_LIST_INDEX:
1522 *params = (GLdouble) ctx->CurrentListNum;
1523 break;
1524 case GL_LIST_MODE:
1525 *params = ctx->ExecuteFlag ? ENUM_TO_DOUBLE(GL_COMPILE_AND_EXECUTE)
1526 : ENUM_TO_DOUBLE(GL_COMPILE);
1527 break;
1528 case GL_INDEX_LOGIC_OP:
1529 *params = (GLdouble) ctx->Color.IndexLogicOpEnabled;
1530 break;
1531 case GL_COLOR_LOGIC_OP:
1532 *params = (GLdouble) ctx->Color.ColorLogicOpEnabled;
1533 break;
1534 case GL_LOGIC_OP_MODE:
1535 *params = ENUM_TO_DOUBLE(ctx->Color.LogicOp);
1536 break;
1537 case GL_MAP1_COLOR_4:
1538 *params = (GLdouble) ctx->Eval.Map1Color4;
1539 break;
1540 case GL_MAP1_GRID_DOMAIN:
1541 params[0] = (GLdouble) ctx->Eval.MapGrid1u1;
1542 params[1] = (GLdouble) ctx->Eval.MapGrid1u2;
1543 break;
1544 case GL_MAP1_GRID_SEGMENTS:
1545 *params = (GLdouble) ctx->Eval.MapGrid1un;
1546 break;
1547 case GL_MAP1_INDEX:
1548 *params = (GLdouble) ctx->Eval.Map1Index;
1549 break;
1550 case GL_MAP1_NORMAL:
1551 *params = (GLdouble) ctx->Eval.Map1Normal;
1552 break;
1553 case GL_MAP1_TEXTURE_COORD_1:
1554 *params = (GLdouble) ctx->Eval.Map1TextureCoord1;
1555 break;
1556 case GL_MAP1_TEXTURE_COORD_2:
1557 *params = (GLdouble) ctx->Eval.Map1TextureCoord2;
1558 break;
1559 case GL_MAP1_TEXTURE_COORD_3:
1560 *params = (GLdouble) ctx->Eval.Map1TextureCoord3;
1561 break;
1562 case GL_MAP1_TEXTURE_COORD_4:
1563 *params = (GLdouble) ctx->Eval.Map1TextureCoord4;
1564 break;
1565 case GL_MAP1_VERTEX_3:
1566 *params = (GLdouble) ctx->Eval.Map1Vertex3;
1567 break;
1568 case GL_MAP1_VERTEX_4:
1569 *params = (GLdouble) ctx->Eval.Map1Vertex4;
1570 break;
1571 case GL_MAP2_COLOR_4:
1572 *params = (GLdouble) ctx->Eval.Map2Color4;
1573 break;
1574 case GL_MAP2_GRID_DOMAIN:
1575 params[0] = (GLdouble) ctx->Eval.MapGrid2u1;
1576 params[1] = (GLdouble) ctx->Eval.MapGrid2u2;
1577 params[2] = (GLdouble) ctx->Eval.MapGrid2v1;
1578 params[3] = (GLdouble) ctx->Eval.MapGrid2v2;
1579 break;
1580 case GL_MAP2_GRID_SEGMENTS:
1581 params[0] = (GLdouble) ctx->Eval.MapGrid2un;
1582 params[1] = (GLdouble) ctx->Eval.MapGrid2vn;
1583 break;
1584 case GL_MAP2_INDEX:
1585 *params = (GLdouble) ctx->Eval.Map2Index;
1586 break;
1587 case GL_MAP2_NORMAL:
1588 *params = (GLdouble) ctx->Eval.Map2Normal;
1589 break;
1590 case GL_MAP2_TEXTURE_COORD_1:
1591 *params = (GLdouble) ctx->Eval.Map2TextureCoord1;
1592 break;
1593 case GL_MAP2_TEXTURE_COORD_2:
1594 *params = (GLdouble) ctx->Eval.Map2TextureCoord2;
1595 break;
1596 case GL_MAP2_TEXTURE_COORD_3:
1597 *params = (GLdouble) ctx->Eval.Map2TextureCoord3;
1598 break;
1599 case GL_MAP2_TEXTURE_COORD_4:
1600 *params = (GLdouble) ctx->Eval.Map2TextureCoord4;
1601 break;
1602 case GL_MAP2_VERTEX_3:
1603 *params = (GLdouble) ctx->Eval.Map2Vertex3;
1604 break;
1605 case GL_MAP2_VERTEX_4:
1606 *params = (GLdouble) ctx->Eval.Map2Vertex4;
1607 break;
1608 case GL_MAP_COLOR:
1609 *params = (GLdouble) ctx->Pixel.MapColorFlag;
1610 break;
1611 case GL_MAP_STENCIL:
1612 *params = (GLdouble) ctx->Pixel.MapStencilFlag;
1613 break;
1614 case GL_MATRIX_MODE:
1615 *params = ENUM_TO_DOUBLE(ctx->Transform.MatrixMode);
1616 break;
1617 case GL_MAX_ATTRIB_STACK_DEPTH:
1618 *params = (GLdouble) MAX_ATTRIB_STACK_DEPTH;
1619 break;
1620 case GL_MAX_CLIENT_ATTRIB_STACK_DEPTH:
1621 *params = (GLdouble) MAX_CLIENT_ATTRIB_STACK_DEPTH;
1622 break;
1623 case GL_MAX_CLIP_PLANES:
1624 *params = (GLdouble) MAX_CLIP_PLANES;
1625 break;
1626 case GL_MAX_ELEMENTS_VERTICES: /* GL_VERSION_1_2 */
1627 *params = (GLdouble) VB_MAX;
1628 break;
1629 case GL_MAX_ELEMENTS_INDICES: /* GL_VERSION_1_2 */
1630 *params = (GLdouble) VB_MAX;
1631 break;
1632 case GL_MAX_EVAL_ORDER:
1633 *params = (GLdouble) MAX_EVAL_ORDER;
1634 break;
1635 case GL_MAX_LIGHTS:
1636 *params = (GLdouble) MAX_LIGHTS;
1637 break;
1638 case GL_MAX_LIST_NESTING:
1639 *params = (GLdouble) MAX_LIST_NESTING;
1640 break;
1641 case GL_MAX_MODELVIEW_STACK_DEPTH:
1642 *params = (GLdouble) MAX_MODELVIEW_STACK_DEPTH;
1643 break;
1644 case GL_MAX_NAME_STACK_DEPTH:
1645 *params = (GLdouble) MAX_NAME_STACK_DEPTH;
1646 break;
1647 case GL_MAX_PIXEL_MAP_TABLE:
1648 *params = (GLdouble) MAX_PIXEL_MAP_TABLE;
1649 break;
1650 case GL_MAX_PROJECTION_STACK_DEPTH:
1651 *params = (GLdouble) MAX_PROJECTION_STACK_DEPTH;
1652 break;
1653 case GL_MAX_TEXTURE_SIZE:
1654 case GL_MAX_3D_TEXTURE_SIZE:
1655 *params = (GLdouble) ctx->Const.MaxTextureSize;
1656 break;
1657 case GL_MAX_TEXTURE_STACK_DEPTH:
1658 *params = (GLdouble) MAX_TEXTURE_STACK_DEPTH;
1659 break;
1660 case GL_MAX_VIEWPORT_DIMS:
1661 params[0] = (GLdouble) MAX_WIDTH;
1662 params[1] = (GLdouble) MAX_HEIGHT;
1663 break;
1664 case GL_MINMAX:
1665 *params = (GLdouble) ctx->Pixel.MinMaxEnabled;
1666 break;
1667 case GL_MODELVIEW_MATRIX:
1668 for (i=0;i<16;i++) {
1669 params[i] = (GLdouble) ctx->ModelView.m[i];
1670 }
1671 break;
1672 case GL_MODELVIEW_STACK_DEPTH:
1673 *params = (GLdouble) (ctx->ModelViewStackDepth + 1);
1674 break;
1675 case GL_NAME_STACK_DEPTH:
1676 *params = (GLdouble) ctx->Select.NameStackDepth;
1677 break;
1678 case GL_NORMALIZE:
1679 *params = (GLdouble) ctx->Transform.Normalize;
1680 break;
1681 case GL_PACK_ALIGNMENT:
1682 *params = (GLdouble) ctx->Pack.Alignment;
1683 break;
1684 case GL_PACK_LSB_FIRST:
1685 *params = (GLdouble) ctx->Pack.LsbFirst;
1686 break;
1687 case GL_PACK_ROW_LENGTH:
1688 *params = (GLdouble) ctx->Pack.RowLength;
1689 break;
1690 case GL_PACK_SKIP_PIXELS:
1691 *params = (GLdouble) ctx->Pack.SkipPixels;
1692 break;
1693 case GL_PACK_SKIP_ROWS:
1694 *params = (GLdouble) ctx->Pack.SkipRows;
1695 break;
1696 case GL_PACK_SWAP_BYTES:
1697 *params = (GLdouble) ctx->Pack.SwapBytes;
1698 break;
1699 case GL_PACK_SKIP_IMAGES_EXT:
1700 *params = (GLdouble) ctx->Pack.SkipImages;
1701 break;
1702 case GL_PACK_IMAGE_HEIGHT_EXT:
1703 *params = (GLdouble) ctx->Pack.ImageHeight;
1704 break;
1705 case GL_PERSPECTIVE_CORRECTION_HINT:
1706 *params = ENUM_TO_DOUBLE(ctx->Hint.PerspectiveCorrection);
1707 break;
1708 case GL_PIXEL_MAP_A_TO_A_SIZE:
1709 *params = (GLdouble) ctx->Pixel.MapAtoAsize;
1710 break;
1711 case GL_PIXEL_MAP_B_TO_B_SIZE:
1712 *params = (GLdouble) ctx->Pixel.MapBtoBsize;
1713 break;
1714 case GL_PIXEL_MAP_G_TO_G_SIZE:
1715 *params = (GLdouble) ctx->Pixel.MapGtoGsize;
1716 break;
1717 case GL_PIXEL_MAP_I_TO_A_SIZE:
1718 *params = (GLdouble) ctx->Pixel.MapItoAsize;
1719 break;
1720 case GL_PIXEL_MAP_I_TO_B_SIZE:
1721 *params = (GLdouble) ctx->Pixel.MapItoBsize;
1722 break;
1723 case GL_PIXEL_MAP_I_TO_G_SIZE:
1724 *params = (GLdouble) ctx->Pixel.MapItoGsize;
1725 break;
1726 case GL_PIXEL_MAP_I_TO_I_SIZE:
1727 *params = (GLdouble) ctx->Pixel.MapItoIsize;
1728 break;
1729 case GL_PIXEL_MAP_I_TO_R_SIZE:
1730 *params = (GLdouble) ctx->Pixel.MapItoRsize;
1731 break;
1732 case GL_PIXEL_MAP_R_TO_R_SIZE:
1733 *params = (GLdouble) ctx->Pixel.MapRtoRsize;
1734 break;
1735 case GL_PIXEL_MAP_S_TO_S_SIZE:
1736 *params = (GLdouble) ctx->Pixel.MapStoSsize;
1737 break;
1738 case GL_POINT_SIZE:
1739 *params = (GLdouble) ctx->Point.UserSize;
1740 break;
1741 case GL_POINT_SIZE_GRANULARITY:
1742 *params = (GLdouble) ctx->Const.PointSizeGranularity;
1743 break;
1744 case GL_POINT_SIZE_RANGE:
1745 params[0] = (GLdouble) ctx->Const.MinPointSizeAA;
1746 params[1] = (GLdouble) ctx->Const.MaxPointSizeAA;
1747 break;
1748 case GL_ALIASED_POINT_SIZE_RANGE:
1749 params[0] = (GLdouble) ctx->Const.MinPointSize;
1750 params[1] = (GLdouble) ctx->Const.MaxPointSize;
1751 break;
1752 case GL_POINT_SMOOTH:
1753 *params = (GLdouble) ctx->Point.SmoothFlag;
1754 break;
1755 case GL_POINT_SMOOTH_HINT:
1756 *params = ENUM_TO_DOUBLE(ctx->Hint.PointSmooth);
1757 break;
1758 case GL_POINT_SIZE_MIN_EXT:
1759 *params = (GLdouble) (ctx->Point.MinSize);
1760 break;
1761 case GL_POINT_SIZE_MAX_EXT:
1762 *params = (GLdouble) (ctx->Point.MaxSize);
1763 break;
1764 case GL_POINT_FADE_THRESHOLD_SIZE_EXT:
1765 *params = (GLdouble) (ctx->Point.Threshold);
1766 break;
1767 case GL_DISTANCE_ATTENUATION_EXT:
1768 params[0] = (GLdouble) (ctx->Point.Params[0]);
1769 params[1] = (GLdouble) (ctx->Point.Params[1]);
1770 params[2] = (GLdouble) (ctx->Point.Params[2]);
1771 break;
1772 case GL_POLYGON_MODE:
1773 params[0] = ENUM_TO_DOUBLE(ctx->Polygon.FrontMode);
1774 params[1] = ENUM_TO_DOUBLE(ctx->Polygon.BackMode);
1775 break;
1776 case GL_POLYGON_OFFSET_BIAS_EXT: /* GL_EXT_polygon_offset */
1777 *params = (GLdouble) ctx->Polygon.OffsetUnits;
1778 break;
1779 case GL_POLYGON_OFFSET_FACTOR:
1780 *params = (GLdouble) ctx->Polygon.OffsetFactor;
1781 break;
1782 case GL_POLYGON_OFFSET_UNITS:
1783 *params = (GLdouble) ctx->Polygon.OffsetUnits;
1784 break;
1785 case GL_POLYGON_SMOOTH:
1786 *params = (GLdouble) ctx->Polygon.SmoothFlag;
1787 break;
1788 case GL_POLYGON_SMOOTH_HINT:
1789 *params = ENUM_TO_DOUBLE(ctx->Hint.PolygonSmooth);
1790 break;
1791 case GL_POLYGON_STIPPLE:
1792 *params = (GLdouble) ctx->Polygon.StippleFlag;
1793 break;
1794 case GL_PROJECTION_MATRIX:
1795 for (i=0;i<16;i++) {
1796 params[i] = (GLdouble) ctx->ProjectionMatrix.m[i];
1797 }
1798 break;
1799 case GL_PROJECTION_STACK_DEPTH:
1800 *params = (GLdouble) (ctx->ProjectionStackDepth + 1);
1801 break;
1802 case GL_READ_BUFFER:
1803 *params = ENUM_TO_DOUBLE(ctx->Pixel.ReadBuffer);
1804 break;
1805 case GL_RED_BIAS:
1806 *params = (GLdouble) ctx->Pixel.RedBias;
1807 break;
1808 case GL_RED_BITS:
1809 *params = (GLdouble) ctx->Visual->RedBits;
1810 break;
1811 case GL_RED_SCALE:
1812 *params = (GLdouble) ctx->Pixel.RedScale;
1813 break;
1814 case GL_RENDER_MODE:
1815 *params = ENUM_TO_DOUBLE(ctx->RenderMode);
1816 break;
1817 case GL_RGBA_MODE:
1818 *params = (GLdouble) ctx->Visual->RGBAflag;
1819 break;
1820 case GL_SCISSOR_BOX:
1821 params[0] = (GLdouble) ctx->Scissor.X;
1822 params[1] = (GLdouble) ctx->Scissor.Y;
1823 params[2] = (GLdouble) ctx->Scissor.Width;
1824 params[3] = (GLdouble) ctx->Scissor.Height;
1825 break;
1826 case GL_SCISSOR_TEST:
1827 *params = (GLdouble) ctx->Scissor.Enabled;
1828 break;
1829 case GL_SELECTION_BUFFER_SIZE:
1830 *params = (GLdouble) ctx->Select.BufferSize;
1831 break;
1832 case GL_SHADE_MODEL:
1833 *params = ENUM_TO_DOUBLE(ctx->Light.ShadeModel);
1834 break;
1835 case GL_SHARED_TEXTURE_PALETTE_EXT:
1836 *params = (GLdouble) ctx->Texture.SharedPalette;
1837 break;
1838 case GL_STENCIL_BITS:
1839 *params = (GLdouble) ctx->Visual->StencilBits;
1840 break;
1841 case GL_STENCIL_CLEAR_VALUE:
1842 *params = (GLdouble) ctx->Stencil.Clear;
1843 break;
1844 case GL_STENCIL_FAIL:
1845 *params = ENUM_TO_DOUBLE(ctx->Stencil.FailFunc);
1846 break;
1847 case GL_STENCIL_FUNC:
1848 *params = ENUM_TO_DOUBLE(ctx->Stencil.Function);
1849 break;
1850 case GL_STENCIL_PASS_DEPTH_FAIL:
1851 *params = ENUM_TO_DOUBLE(ctx->Stencil.ZFailFunc);
1852 break;
1853 case GL_STENCIL_PASS_DEPTH_PASS:
1854 *params = ENUM_TO_DOUBLE(ctx->Stencil.ZPassFunc);
1855 break;
1856 case GL_STENCIL_REF:
1857 *params = (GLdouble) ctx->Stencil.Ref;
1858 break;
1859 case GL_STENCIL_TEST:
1860 *params = (GLdouble) ctx->Stencil.Enabled;
1861 break;
1862 case GL_STENCIL_VALUE_MASK:
1863 *params = (GLdouble) ctx->Stencil.ValueMask;
1864 break;
1865 case GL_STENCIL_WRITEMASK:
1866 *params = (GLdouble) ctx->Stencil.WriteMask;
1867 break;
1868 case GL_STEREO:
1869 *params = (GLdouble) ctx->Visual->StereoFlag;
1870 break;
1871 case GL_SUBPIXEL_BITS:
1872 *params = (GLdouble) ctx->Const.SubPixelBits;
1873 break;
1874 case GL_TEXTURE_1D:
1875 *params = _mesa_IsEnabled(GL_TEXTURE_1D) ? 1.0 : 0.0;
1876 break;
1877 case GL_TEXTURE_2D:
1878 *params = _mesa_IsEnabled(GL_TEXTURE_2D) ? 1.0 : 0.0;
1879 break;
1880 case GL_TEXTURE_3D:
1881 *params = _mesa_IsEnabled(GL_TEXTURE_3D) ? 1.0 : 0.0;
1882 break;
1883 case GL_TEXTURE_BINDING_1D:
1884 *params = (GLdouble) textureUnit->CurrentD[1]->Name;
1885 break;
1886 case GL_TEXTURE_BINDING_2D:
1887 *params = (GLdouble) textureUnit->CurrentD[2]->Name;
1888 break;
1889 case GL_TEXTURE_BINDING_3D:
1890 *params = (GLdouble) textureUnit->CurrentD[3]->Name;
1891 break;
1892 case GL_TEXTURE_ENV_COLOR:
1893 params[0] = (GLdouble) textureUnit->EnvColor[0];
1894 params[1] = (GLdouble) textureUnit->EnvColor[1];
1895 params[2] = (GLdouble) textureUnit->EnvColor[2];
1896 params[3] = (GLdouble) textureUnit->EnvColor[3];
1897 break;
1898 case GL_TEXTURE_ENV_MODE:
1899 *params = ENUM_TO_DOUBLE(textureUnit->EnvMode);
1900 break;
1901 case GL_TEXTURE_GEN_S:
1902 *params = (textureUnit->TexGenEnabled & S_BIT) ? 1.0 : 0.0;
1903 break;
1904 case GL_TEXTURE_GEN_T:
1905 *params = (textureUnit->TexGenEnabled & T_BIT) ? 1.0 : 0.0;
1906 break;
1907 case GL_TEXTURE_GEN_R:
1908 *params = (textureUnit->TexGenEnabled & R_BIT) ? 1.0 : 0.0;
1909 break;
1910 case GL_TEXTURE_GEN_Q:
1911 *params = (textureUnit->TexGenEnabled & Q_BIT) ? 1.0 : 0.0;
1912 break;
1913 case GL_TEXTURE_MATRIX:
1914 for (i=0;i<16;i++) {
1915 params[i] = (GLdouble) ctx->TextureMatrix[texTransformUnit].m[i];
1916 }
1917 break;
1918 case GL_TEXTURE_STACK_DEPTH:
1919 *params = (GLdouble) (ctx->TextureStackDepth[texTransformUnit] + 1);
1920 break;
1921 case GL_UNPACK_ALIGNMENT:
1922 *params = (GLdouble) ctx->Unpack.Alignment;
1923 break;
1924 case GL_UNPACK_LSB_FIRST:
1925 *params = (GLdouble) ctx->Unpack.LsbFirst;
1926 break;
1927 case GL_UNPACK_ROW_LENGTH:
1928 *params = (GLdouble) ctx->Unpack.RowLength;
1929 break;
1930 case GL_UNPACK_SKIP_PIXELS:
1931 *params = (GLdouble) ctx->Unpack.SkipPixels;
1932 break;
1933 case GL_UNPACK_SKIP_ROWS:
1934 *params = (GLdouble) ctx->Unpack.SkipRows;
1935 break;
1936 case GL_UNPACK_SWAP_BYTES:
1937 *params = (GLdouble) ctx->Unpack.SwapBytes;
1938 break;
1939 case GL_UNPACK_SKIP_IMAGES_EXT:
1940 *params = (GLdouble) ctx->Unpack.SkipImages;
1941 break;
1942 case GL_UNPACK_IMAGE_HEIGHT_EXT:
1943 *params = (GLdouble) ctx->Unpack.ImageHeight;
1944 break;
1945 case GL_VIEWPORT:
1946 params[0] = (GLdouble) ctx->Viewport.X;
1947 params[1] = (GLdouble) ctx->Viewport.Y;
1948 params[2] = (GLdouble) ctx->Viewport.Width;
1949 params[3] = (GLdouble) ctx->Viewport.Height;
1950 break;
1951 case GL_ZOOM_X:
1952 *params = (GLdouble) ctx->Pixel.ZoomX;
1953 break;
1954 case GL_ZOOM_Y:
1955 *params = (GLdouble) ctx->Pixel.ZoomY;
1956 break;
1957 case GL_VERTEX_ARRAY:
1958 *params = (GLdouble) ctx->Array.Vertex.Enabled;
1959 break;
1960 case GL_VERTEX_ARRAY_SIZE:
1961 *params = (GLdouble) ctx->Array.Vertex.Size;
1962 break;
1963 case GL_VERTEX_ARRAY_TYPE:
1964 *params = ENUM_TO_DOUBLE(ctx->Array.Vertex.Type);
1965 break;
1966 case GL_VERTEX_ARRAY_STRIDE:
1967 *params = (GLdouble) ctx->Array.Vertex.Stride;
1968 break;
1969 case GL_VERTEX_ARRAY_COUNT_EXT:
1970 *params = 0.0;
1971 break;
1972 case GL_NORMAL_ARRAY:
1973 *params = (GLdouble) ctx->Array.Normal.Enabled;
1974 break;
1975 case GL_NORMAL_ARRAY_TYPE:
1976 *params = ENUM_TO_DOUBLE(ctx->Array.Normal.Type);
1977 break;
1978 case GL_NORMAL_ARRAY_STRIDE:
1979 *params = (GLdouble) ctx->Array.Normal.Stride;
1980 break;
1981 case GL_NORMAL_ARRAY_COUNT_EXT:
1982 *params = 0.0;
1983 break;
1984 case GL_COLOR_ARRAY:
1985 *params = (GLdouble) ctx->Array.Color.Enabled;
1986 break;
1987 case GL_COLOR_ARRAY_SIZE:
1988 *params = (GLdouble) ctx->Array.Color.Size;
1989 break;
1990 case GL_COLOR_ARRAY_TYPE:
1991 *params = ENUM_TO_DOUBLE(ctx->Array.Color.Type);
1992 break;
1993 case GL_COLOR_ARRAY_STRIDE:
1994 *params = (GLdouble) ctx->Array.Color.Stride;
1995 break;
1996 case GL_COLOR_ARRAY_COUNT_EXT:
1997 *params = 0.0;
1998 break;
1999 case GL_INDEX_ARRAY:
2000 *params = (GLdouble) ctx->Array.Index.Enabled;
2001 break;
2002 case GL_INDEX_ARRAY_TYPE:
2003 *params = ENUM_TO_DOUBLE(ctx->Array.Index.Type);
2004 break;
2005 case GL_INDEX_ARRAY_STRIDE:
2006 *params = (GLdouble) ctx->Array.Index.Stride;
2007 break;
2008 case GL_INDEX_ARRAY_COUNT_EXT:
2009 *params = 0.0;
2010 break;
2011 case GL_TEXTURE_COORD_ARRAY:
2012 *params = (GLdouble) ctx->Array.TexCoord[texUnit].Enabled;
2013 break;
2014 case GL_TEXTURE_COORD_ARRAY_SIZE:
2015 *params = (GLdouble) ctx->Array.TexCoord[texUnit].Size;
2016 break;
2017 case GL_TEXTURE_COORD_ARRAY_TYPE:
2018 *params = ENUM_TO_DOUBLE(ctx->Array.TexCoord[texUnit].Type);
2019 break;
2020 case GL_TEXTURE_COORD_ARRAY_STRIDE:
2021 *params = (GLdouble) ctx->Array.TexCoord[texUnit].Stride;
2022 break;
2023 case GL_TEXTURE_COORD_ARRAY_COUNT_EXT:
2024 *params = 0.0;
2025 break;
2026 case GL_EDGE_FLAG_ARRAY:
2027 *params = (GLdouble) ctx->Array.EdgeFlag.Enabled;
2028 break;
2029 case GL_EDGE_FLAG_ARRAY_STRIDE:
2030 *params = (GLdouble) ctx->Array.EdgeFlag.Stride;
2031 break;
2032 case GL_EDGE_FLAG_ARRAY_COUNT_EXT:
2033 *params = 0.0;
2034 break;
2035
2036 case GL_MAX_TEXTURE_UNITS_ARB:
2037 *params = (GLdouble) ctx->Const.MaxTextureUnits;
2038 break;
2039 case GL_ACTIVE_TEXTURE_ARB:
2040 *params = (GLdouble) (GL_TEXTURE0_ARB + ctx->Texture.CurrentUnit);
2041 break;
2042 case GL_CLIENT_ACTIVE_TEXTURE_ARB:
2043 *params = (GLdouble) (GL_TEXTURE0_ARB + ctx->Array.ActiveTexture);
2044 break;
2045
2046
2047 /* GL_PGI_misc_hints */
2048 case GL_STRICT_DEPTHFUNC_HINT_PGI:
2049 *params = ENUM_TO_DOUBLE(GL_NICEST);
2050 break;
2051 case GL_STRICT_LIGHTING_HINT_PGI:
2052 *params = ENUM_TO_DOUBLE(ctx->Hint.StrictLighting);
2053 break;
2054 case GL_STRICT_SCISSOR_HINT_PGI:
2055 case GL_FULL_STIPPLE_HINT_PGI:
2056 *params = ENUM_TO_DOUBLE(GL_TRUE);
2057 break;
2058 case GL_CONSERVE_MEMORY_HINT_PGI:
2059 *params = ENUM_TO_DOUBLE(GL_FALSE);
2060 break;
2061 case GL_ALWAYS_FAST_HINT_PGI:
2062 *params = (GLdouble) (ctx->Hint.AllowDrawWin == GL_TRUE &&
2063 ctx->Hint.AllowDrawFrg == GL_FALSE &&
2064 ctx->Hint.AllowDrawMem == GL_FALSE);
2065 break;
2066 case GL_ALWAYS_SOFT_HINT_PGI:
2067 *params = (GLdouble) (ctx->Hint.AllowDrawWin == GL_TRUE &&
2068 ctx->Hint.AllowDrawFrg == GL_TRUE &&
2069 ctx->Hint.AllowDrawMem == GL_TRUE);
2070 break;
2071 case GL_ALLOW_DRAW_OBJ_HINT_PGI:
2072 *params = (GLdouble) GL_TRUE;
2073 break;
2074 case GL_ALLOW_DRAW_WIN_HINT_PGI:
2075 *params = (GLdouble) ctx->Hint.AllowDrawWin;
2076 break;
2077 case GL_ALLOW_DRAW_FRG_HINT_PGI:
2078 *params = (GLdouble) ctx->Hint.AllowDrawFrg;
2079 break;
2080 case GL_ALLOW_DRAW_MEM_HINT_PGI:
2081 *params = (GLdouble) ctx->Hint.AllowDrawMem;
2082 break;
2083 case GL_CLIP_NEAR_HINT_PGI:
2084 case GL_CLIP_FAR_HINT_PGI:
2085 *params = ENUM_TO_DOUBLE(GL_TRUE);
2086 break;
2087 case GL_WIDE_LINE_HINT_PGI:
2088 *params = ENUM_TO_DOUBLE(GL_DONT_CARE);
2089 break;
2090 case GL_BACK_NORMALS_HINT_PGI:
2091 *params = ENUM_TO_DOUBLE(GL_TRUE);
2092 break;
2093 case GL_NATIVE_GRAPHICS_HANDLE_PGI:
2094 *params = 0;
2095 break;
2096
2097 /* GL_EXT_compiled_vertex_array */
2098 case GL_ARRAY_ELEMENT_LOCK_FIRST_EXT:
2099 *params = (GLdouble) ctx->Array.LockFirst;
2100 break;
2101 case GL_ARRAY_ELEMENT_LOCK_COUNT_EXT:
2102 *params = (GLdouble) ctx->Array.LockCount;
2103 break;
2104
2105 /* GL_ARB_transpose_matrix */
2106 case GL_TRANSPOSE_COLOR_MATRIX_ARB:
2107 /* don't have a color matrix */
2108 break;
2109 case GL_TRANSPOSE_MODELVIEW_MATRIX_ARB:
2110 {
2111 GLfloat tm[16];
2112 GLuint i;
2113 gl_matrix_transposef(tm, ctx->ModelView.m);
2114 for (i=0;i<16;i++) {
2115 params[i] = (GLdouble) tm[i];
2116 }
2117 }
2118 break;
2119 case GL_TRANSPOSE_PROJECTION_MATRIX_ARB:
2120 {
2121 GLfloat tm[16];
2122 GLuint i;
2123 gl_matrix_transposef(tm, ctx->ProjectionMatrix.m);
2124 for (i=0;i<16;i++) {
2125 params[i] = (GLdouble) tm[i];
2126 }
2127 }
2128 break;
2129 case GL_TRANSPOSE_TEXTURE_MATRIX_ARB:
2130 {
2131 GLfloat tm[16];
2132 GLuint i;
2133 gl_matrix_transposef(tm, ctx->TextureMatrix[texTransformUnit].m);
2134 for (i=0;i<16;i++) {
2135 params[i] = (GLdouble) tm[i];
2136 }
2137 }
2138 break;
2139
2140 /* GL_HP_occlusion_test */
2141 case GL_OCCLUSION_TEST_HP:
2142 if (ctx->Extensions.HaveHpOcclusionTest) {
2143 *params = (GLdouble) ctx->Depth.OcclusionTest;
2144 }
2145 else {
2146 gl_error( ctx, GL_INVALID_ENUM, "glGetDoublev" );
2147 }
2148 return;
2149 case GL_OCCLUSION_TEST_RESULT_HP:
2150 if (ctx->Extensions.HaveHpOcclusionTest) {
2151 if (ctx->Depth.OcclusionTest)
2152 *params = (GLdouble) ctx->OcclusionResult;
2153 else
2154 *params = (GLdouble) ctx->OcclusionResultSaved;
2155 /* reset flag now */
2156 ctx->OcclusionResult = GL_FALSE;
2157 ctx->OcclusionResultSaved = GL_FALSE;
2158 }
2159 else {
2160 gl_error( ctx, GL_INVALID_ENUM, "glGetDoublev" );
2161 }
2162 return;
2163
2164 /* GL_SGIS_pixel_texture */
2165 case GL_PIXEL_TEXTURE_SGIS:
2166 *params = (GLdouble) ctx->Pixel.PixelTextureEnabled;
2167 break;
2168
2169 /* GL_SGIX_pixel_texture */
2170 case GL_PIXEL_TEX_GEN_SGIX:
2171 *params = (GLdouble) ctx->Pixel.PixelTextureEnabled;
2172 break;
2173 case GL_PIXEL_TEX_GEN_MODE_SGIX:
2174 *params = (GLdouble) pixel_texgen_mode(ctx);
2175 break;
2176
2177 /* GL_SGI_color_matrix (also in 1.2 imaging) */
2178 case GL_COLOR_MATRIX_SGI:
2179 for (i=0;i<16;i++) {
2180 params[i] = (GLdouble) ctx->ColorMatrix.m[i];
2181 }
2182 break;
2183 case GL_COLOR_MATRIX_STACK_DEPTH_SGI:
2184 *params = (GLdouble) (ctx->ColorStackDepth + 1);
2185 break;
2186 case GL_MAX_COLOR_MATRIX_STACK_DEPTH_SGI:
2187 *params = (GLdouble) MAX_COLOR_STACK_DEPTH;
2188 break;
2189 case GL_POST_COLOR_MATRIX_RED_SCALE_SGI:
2190 *params = (GLdouble) ctx->Pixel.PostColorMatrixScale[0];
2191 break;
2192 case GL_POST_COLOR_MATRIX_GREEN_SCALE_SGI:
2193 *params = (GLdouble) ctx->Pixel.PostColorMatrixScale[1];
2194 break;
2195 case GL_POST_COLOR_MATRIX_BLUE_SCALE_SGI:
2196 *params = (GLdouble) ctx->Pixel.PostColorMatrixScale[2];
2197 break;
2198 case GL_POST_COLOR_MATRIX_ALPHA_SCALE_SGI:
2199 *params = (GLdouble) ctx->Pixel.PostColorMatrixScale[3];
2200 break;
2201 case GL_POST_COLOR_MATRIX_RED_BIAS_SGI:
2202 *params = (GLdouble) ctx->Pixel.PostColorMatrixBias[0];
2203 break;
2204 case GL_POST_COLOR_MATRIX_GREEN_BIAS_SGI:
2205 *params = (GLdouble) ctx->Pixel.PostColorMatrixBias[1];
2206 break;
2207 case GL_POST_COLOR_MATRIX_BLUE_BIAS_SGI:
2208 *params = (GLdouble) ctx->Pixel.PostColorMatrixBias[2];
2209 break;
2210 case GL_POST_COLOR_MATRIX_ALPHA_BIAS_SGI:
2211 *params = (GLdouble) ctx->Pixel.PostColorMatrixBias[3];
2212 break;
2213
2214 /* GL_EXT_convolution (also in 1.2 imaging) */
2215 case GL_MAX_CONVOLUTION_WIDTH:
2216 *params = (GLdouble) ctx->Const.MaxConvolutionWidth;
2217 break;
2218 case GL_MAX_CONVOLUTION_HEIGHT:
2219 *params = (GLdouble) ctx->Const.MaxConvolutionHeight;
2220 break;
2221 case GL_POST_CONVOLUTION_RED_SCALE_EXT:
2222 *params = (GLdouble) ctx->Pixel.PostConvolutionScale[0];
2223 break;
2224 case GL_POST_CONVOLUTION_GREEN_SCALE_EXT:
2225 *params = (GLdouble) ctx->Pixel.PostConvolutionScale[1];
2226 break;
2227 case GL_POST_CONVOLUTION_BLUE_SCALE_EXT:
2228 *params = (GLdouble) ctx->Pixel.PostConvolutionScale[2];
2229 break;
2230 case GL_POST_CONVOLUTION_ALPHA_SCALE_EXT:
2231 *params = (GLdouble) ctx->Pixel.PostConvolutionScale[3];
2232 break;
2233 case GL_POST_CONVOLUTION_RED_BIAS_EXT:
2234 *params = (GLdouble) ctx->Pixel.PostConvolutionBias[0];
2235 break;
2236 case GL_POST_CONVOLUTION_GREEN_BIAS_EXT:
2237 *params = (GLdouble) ctx->Pixel.PostConvolutionBias[1];
2238 break;
2239 case GL_POST_CONVOLUTION_BLUE_BIAS_EXT:
2240 *params = (GLdouble) ctx->Pixel.PostConvolutionBias[2];
2241 break;
2242 case GL_POST_CONVOLUTION_ALPHA_BIAS_EXT:
2243 *params = (GLdouble) ctx->Pixel.PostConvolutionBias[2];
2244 break;
2245
2246 /* GL_SGI_color_table (also in 1.2 imaging */
2247 case GL_COLOR_TABLE_SGI:
2248 *params = (GLdouble) ctx->Pixel.ColorTableEnabled;
2249 break;
2250 case GL_POST_CONVOLUTION_COLOR_TABLE_SGI:
2251 *params = (GLdouble) ctx->Pixel.PostConvolutionColorTableEnabled;
2252 break;
2253 case GL_POST_COLOR_MATRIX_COLOR_TABLE_SGI:
2254 *params = (GLdouble) ctx->Pixel.PostColorMatrixColorTableEnabled;
2255 break;
2256
2257 default:
2258 gl_error( ctx, GL_INVALID_ENUM, "glGetDoublev" );
2259 }
2260 }
2261
2262
2263
2264
2265 void
2266 _mesa_GetFloatv( GLenum pname, GLfloat *params )
2267 {
2268 GET_CURRENT_CONTEXT(ctx);
2269 GLuint i;
2270 GLuint texUnit = ctx->Texture.CurrentUnit;
2271 GLuint texTransformUnit = ctx->Texture.CurrentTransformUnit;
2272 const struct gl_texture_unit *textureUnit = &ctx->Texture.Unit[texUnit];
2273
2274 ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx, "glGetFloatv");
2275
2276 if (MESA_VERBOSE & VERBOSE_API)
2277 fprintf(stderr, "glGetFloatv %s\n", gl_lookup_enum_by_nr(pname));
2278
2279 switch (pname) {
2280 case GL_ACCUM_RED_BITS:
2281 *params = (GLfloat) ctx->Visual->AccumRedBits;
2282 break;
2283 case GL_ACCUM_GREEN_BITS:
2284 *params = (GLfloat) ctx->Visual->AccumGreenBits;
2285 break;
2286 case GL_ACCUM_BLUE_BITS:
2287 *params = (GLfloat) ctx->Visual->AccumBlueBits;
2288 break;
2289 case GL_ACCUM_ALPHA_BITS:
2290 *params = (GLfloat) ctx->Visual->AccumAlphaBits;
2291 break;
2292 case GL_ACCUM_CLEAR_VALUE:
2293 params[0] = ctx->Accum.ClearColor[0];
2294 params[1] = ctx->Accum.ClearColor[1];
2295 params[2] = ctx->Accum.ClearColor[2];
2296 params[3] = ctx->Accum.ClearColor[3];
2297 break;
2298 case GL_ALPHA_BIAS:
2299 *params = ctx->Pixel.AlphaBias;
2300 break;
2301 case GL_ALPHA_BITS:
2302 *params = (GLfloat) ctx->Visual->AlphaBits;
2303 break;
2304 case GL_ALPHA_SCALE:
2305 *params = ctx->Pixel.AlphaScale;
2306 break;
2307 case GL_ALPHA_TEST:
2308 *params = (GLfloat) ctx->Color.AlphaEnabled;
2309 break;
2310 case GL_ALPHA_TEST_FUNC:
2311 *params = ENUM_TO_FLOAT(ctx->Color.AlphaFunc);
2312 break;
2313 case GL_ALPHA_TEST_REF:
2314 *params = (GLfloat) ctx->Color.AlphaRef / 255.0;
2315 break;
2316 case GL_ATTRIB_STACK_DEPTH:
2317 *params = (GLfloat) (ctx->AttribStackDepth);
2318 break;
2319 case GL_AUTO_NORMAL:
2320 *params = (GLfloat) ctx->Eval.AutoNormal;
2321 break;
2322 case GL_AUX_BUFFERS:
2323 *params = (GLfloat) ctx->Const.NumAuxBuffers;
2324 break;
2325 case GL_BLEND:
2326 *params = (GLfloat) ctx->Color.BlendEnabled;
2327 break;
2328 case GL_BLEND_DST:
2329 *params = ENUM_TO_FLOAT(ctx->Color.BlendDstRGB);
2330 break;
2331 case GL_BLEND_SRC:
2332 *params = ENUM_TO_FLOAT(ctx->Color.BlendSrcRGB);
2333 break;
2334 case GL_BLEND_SRC_RGB_EXT:
2335 *params = ENUM_TO_FLOAT(ctx->Color.BlendSrcRGB);
2336 break;
2337 case GL_BLEND_DST_RGB_EXT:
2338 *params = ENUM_TO_FLOAT(ctx->Color.BlendDstRGB);
2339 break;
2340 case GL_BLEND_SRC_ALPHA_EXT:
2341 *params = ENUM_TO_FLOAT(ctx->Color.BlendSrcA);
2342 break;
2343 case GL_BLEND_DST_ALPHA_EXT:
2344 *params = ENUM_TO_FLOAT(ctx->Color.BlendDstA);
2345 break;
2346 case GL_BLEND_EQUATION_EXT:
2347 *params = ENUM_TO_FLOAT(ctx->Color.BlendEquation);
2348 break;
2349 case GL_BLEND_COLOR_EXT:
2350 params[0] = ctx->Color.BlendColor[0];
2351 params[1] = ctx->Color.BlendColor[1];
2352 params[2] = ctx->Color.BlendColor[2];
2353 params[3] = ctx->Color.BlendColor[3];
2354 break;
2355 case GL_BLUE_BIAS:
2356 *params = ctx->Pixel.BlueBias;
2357 break;
2358 case GL_BLUE_BITS:
2359 *params = (GLfloat) ctx->Visual->BlueBits;
2360 break;
2361 case GL_BLUE_SCALE:
2362 *params = ctx->Pixel.BlueScale;
2363 break;
2364 case GL_CLIENT_ATTRIB_STACK_DEPTH:
2365 *params = (GLfloat) (ctx->ClientAttribStackDepth);
2366 break;
2367 case GL_CLIP_PLANE0:
2368 case GL_CLIP_PLANE1:
2369 case GL_CLIP_PLANE2:
2370 case GL_CLIP_PLANE3:
2371 case GL_CLIP_PLANE4:
2372 case GL_CLIP_PLANE5:
2373 *params = (GLfloat) ctx->Transform.ClipEnabled[pname-GL_CLIP_PLANE0];
2374 break;
2375 case GL_COLOR_CLEAR_VALUE:
2376 params[0] = (GLfloat) ctx->Color.ClearColor[0];
2377 params[1] = (GLfloat) ctx->Color.ClearColor[1];
2378 params[2] = (GLfloat) ctx->Color.ClearColor[2];
2379 params[3] = (GLfloat) ctx->Color.ClearColor[3];
2380 break;
2381 case GL_COLOR_MATERIAL:
2382 *params = (GLfloat) ctx->Light.ColorMaterialEnabled;
2383 break;
2384 case GL_COLOR_MATERIAL_FACE:
2385 *params = ENUM_TO_FLOAT(ctx->Light.ColorMaterialFace);
2386 break;
2387 case GL_COLOR_MATERIAL_PARAMETER:
2388 *params = ENUM_TO_FLOAT(ctx->Light.ColorMaterialMode);
2389 break;
2390 case GL_COLOR_WRITEMASK:
2391 params[0] = ctx->Color.ColorMask[RCOMP] ? 1.0F : 0.0F;
2392 params[1] = ctx->Color.ColorMask[GCOMP] ? 1.0F : 0.0F;
2393 params[2] = ctx->Color.ColorMask[BCOMP] ? 1.0F : 0.0F;
2394 params[3] = ctx->Color.ColorMask[ACOMP] ? 1.0F : 0.0F;
2395 break;
2396 case GL_CULL_FACE:
2397 *params = (GLfloat) ctx->Polygon.CullFlag;
2398 break;
2399 case GL_CULL_FACE_MODE:
2400 *params = ENUM_TO_FLOAT(ctx->Polygon.CullFaceMode);
2401 break;
2402 case GL_CURRENT_COLOR:
2403 UBYTE_RGBA_TO_FLOAT_RGBA(params, ctx->Current.ByteColor);
2404 break;
2405 case GL_CURRENT_INDEX:
2406 *params = (GLfloat) ctx->Current.Index;
2407 break;
2408 case GL_CURRENT_NORMAL:
2409 params[0] = ctx->Current.Normal[0];
2410 params[1] = ctx->Current.Normal[1];
2411 params[2] = ctx->Current.Normal[2];
2412 break;
2413 case GL_CURRENT_RASTER_COLOR:
2414 params[0] = ctx->Current.RasterColor[0];
2415 params[1] = ctx->Current.RasterColor[1];
2416 params[2] = ctx->Current.RasterColor[2];
2417 params[3] = ctx->Current.RasterColor[3];
2418 break;
2419 case GL_CURRENT_RASTER_DISTANCE:
2420 params[0] = ctx->Current.RasterDistance;
2421 break;
2422 case GL_CURRENT_RASTER_INDEX:
2423 *params = (GLfloat) ctx->Current.RasterIndex;
2424 break;
2425 case GL_CURRENT_RASTER_POSITION:
2426 params[0] = ctx->Current.RasterPos[0];
2427 params[1] = ctx->Current.RasterPos[1];
2428 params[2] = ctx->Current.RasterPos[2];
2429 params[3] = ctx->Current.RasterPos[3];
2430 break;
2431 case GL_CURRENT_RASTER_TEXTURE_COORDS:
2432 params[0] = ctx->Current.RasterMultiTexCoord[texTransformUnit][0];
2433 params[1] = ctx->Current.RasterMultiTexCoord[texTransformUnit][1];
2434 params[2] = ctx->Current.RasterMultiTexCoord[texTransformUnit][2];
2435 params[3] = ctx->Current.RasterMultiTexCoord[texTransformUnit][3];
2436 break;
2437 case GL_CURRENT_RASTER_POSITION_VALID:
2438 *params = (GLfloat) ctx->Current.RasterPosValid;
2439 break;
2440 case GL_CURRENT_TEXTURE_COORDS:
2441 params[0] = (GLfloat) ctx->Current.Texcoord[texTransformUnit][0];
2442 params[1] = (GLfloat) ctx->Current.Texcoord[texTransformUnit][1];
2443 params[2] = (GLfloat) ctx->Current.Texcoord[texTransformUnit][2];
2444 params[3] = (GLfloat) ctx->Current.Texcoord[texTransformUnit][3];
2445 break;
2446 case GL_DEPTH_BIAS:
2447 *params = (GLfloat) ctx->Pixel.DepthBias;
2448 break;
2449 case GL_DEPTH_BITS:
2450 *params = (GLfloat) ctx->Visual->DepthBits;
2451 break;
2452 case GL_DEPTH_CLEAR_VALUE:
2453 *params = (GLfloat) ctx->Depth.Clear;
2454 break;
2455 case GL_DEPTH_FUNC:
2456 *params = ENUM_TO_FLOAT(ctx->Depth.Func);
2457 break;
2458 case GL_DEPTH_RANGE:
2459 params[0] = (GLfloat) ctx->Viewport.Near;
2460 params[1] = (GLfloat) ctx->Viewport.Far;
2461 break;
2462 case GL_DEPTH_SCALE:
2463 *params = (GLfloat) ctx->Pixel.DepthScale;
2464 break;
2465 case GL_DEPTH_TEST:
2466 *params = (GLfloat) ctx->Depth.Test;
2467 break;
2468 case GL_DEPTH_WRITEMASK:
2469 *params = (GLfloat) ctx->Depth.Mask;
2470 break;
2471 case GL_DITHER:
2472 *params = (GLfloat) ctx->Color.DitherFlag;
2473 break;
2474 case GL_DOUBLEBUFFER:
2475 *params = (GLfloat) ctx->Visual->DBflag;
2476 break;
2477 case GL_DRAW_BUFFER:
2478 *params = ENUM_TO_FLOAT(ctx->Color.DrawBuffer);
2479 break;
2480 case GL_EDGE_FLAG:
2481 *params = (GLfloat) ctx->Current.EdgeFlag;
2482 break;
2483 case GL_FEEDBACK_BUFFER_SIZE:
2484 *params = (GLfloat) ctx->Feedback.BufferSize;
2485 break;
2486 case GL_FEEDBACK_BUFFER_TYPE:
2487 *params = ENUM_TO_FLOAT(ctx->Feedback.Type);
2488 break;
2489 case GL_FOG:
2490 *params = (GLfloat) ctx->Fog.Enabled;
2491 break;
2492 case GL_FOG_COLOR:
2493 params[0] = ctx->Fog.Color[0];
2494 params[1] = ctx->Fog.Color[1];
2495 params[2] = ctx->Fog.Color[2];
2496 params[3] = ctx->Fog.Color[3];
2497 break;
2498 case GL_FOG_DENSITY:
2499 *params = ctx->Fog.Density;
2500 break;
2501 case GL_FOG_END:
2502 *params = ctx->Fog.End;
2503 break;
2504 case GL_FOG_HINT:
2505 *params = ENUM_TO_FLOAT(ctx->Hint.Fog);
2506 break;
2507 case GL_FOG_INDEX:
2508 *params = ctx->Fog.Index;
2509 break;
2510 case GL_FOG_MODE:
2511 *params = ENUM_TO_FLOAT(ctx->Fog.Mode);
2512 break;
2513 case GL_FOG_START:
2514 *params = ctx->Fog.Start;
2515 break;
2516 case GL_FRONT_FACE:
2517 *params = ENUM_TO_FLOAT(ctx->Polygon.FrontFace);
2518 break;
2519 case GL_GREEN_BIAS:
2520 *params = (GLfloat) ctx->Pixel.GreenBias;
2521 break;
2522 case GL_GREEN_BITS:
2523 *params = (GLfloat) ctx->Visual->GreenBits;
2524 break;
2525 case GL_GREEN_SCALE:
2526 *params = (GLfloat) ctx->Pixel.GreenScale;
2527 break;
2528 case GL_HISTOGRAM:
2529 *params = (GLfloat) ctx->Pixel.HistogramEnabled;
2530 break;
2531 case GL_INDEX_BITS:
2532 *params = (GLfloat) ctx->Visual->IndexBits;
2533 break;
2534 case GL_INDEX_CLEAR_VALUE:
2535 *params = (GLfloat) ctx->Color.ClearIndex;
2536 break;
2537 case GL_INDEX_MODE:
2538 *params = ctx->Visual->RGBAflag ? 0.0F : 1.0F;
2539 break;
2540 case GL_INDEX_OFFSET:
2541 *params = (GLfloat) ctx->Pixel.IndexOffset;
2542 break;
2543 case GL_INDEX_SHIFT:
2544 *params = (GLfloat) ctx->Pixel.IndexShift;
2545 break;
2546 case GL_INDEX_WRITEMASK:
2547 *params = (GLfloat) ctx->Color.IndexMask;
2548 break;
2549 case GL_LIGHT0:
2550 case GL_LIGHT1:
2551 case GL_LIGHT2:
2552 case GL_LIGHT3:
2553 case GL_LIGHT4:
2554 case GL_LIGHT5:
2555 case GL_LIGHT6:
2556 case GL_LIGHT7:
2557 *params = (GLfloat) ctx->Light.Light[pname-GL_LIGHT0].Enabled;
2558 break;
2559 case GL_LIGHTING:
2560 *params = (GLfloat) ctx->Light.Enabled;
2561 break;
2562 case GL_LIGHT_MODEL_AMBIENT:
2563 params[0] = ctx->Light.Model.Ambient[0];
2564 params[1] = ctx->Light.Model.Ambient[1];
2565 params[2] = ctx->Light.Model.Ambient[2];
2566 params[3] = ctx->Light.Model.Ambient[3];
2567 break;
2568 case GL_LIGHT_MODEL_COLOR_CONTROL:
2569 params[0] = ENUM_TO_FLOAT(ctx->Light.Model.ColorControl);
2570 break;
2571 case GL_LIGHT_MODEL_LOCAL_VIEWER:
2572 *params = (GLfloat) ctx->Light.Model.LocalViewer;
2573 break;
2574 case GL_LIGHT_MODEL_TWO_SIDE:
2575 *params = (GLfloat) ctx->Light.Model.TwoSide;
2576 break;
2577 case GL_LINE_SMOOTH:
2578 *params = (GLfloat) ctx->Line.SmoothFlag;
2579 break;
2580 case GL_LINE_SMOOTH_HINT:
2581 *params = ENUM_TO_FLOAT(ctx->Hint.LineSmooth);
2582 break;
2583 case GL_LINE_STIPPLE:
2584 *params = (GLfloat) ctx->Line.StippleFlag;
2585 break;
2586 case GL_LINE_STIPPLE_PATTERN:
2587 *params = (GLfloat) ctx->Line.StipplePattern;
2588 break;
2589 case GL_LINE_STIPPLE_REPEAT:
2590 *params = (GLfloat) ctx->Line.StippleFactor;
2591 break;
2592 case GL_LINE_WIDTH:
2593 *params = (GLfloat) ctx->Line.Width;
2594 break;
2595 case GL_LINE_WIDTH_GRANULARITY:
2596 *params = (GLfloat) ctx->Const.LineWidthGranularity;
2597 break;
2598 case GL_LINE_WIDTH_RANGE:
2599 params[0] = (GLfloat) ctx->Const.MinLineWidthAA;
2600 params[1] = (GLfloat) ctx->Const.MaxLineWidthAA;
2601 break;
2602 case GL_ALIASED_LINE_WIDTH_RANGE:
2603 params[0] = (GLfloat) ctx->Const.MinLineWidth;
2604 params[1] = (GLfloat) ctx->Const.MaxLineWidth;
2605 break;
2606 case GL_LIST_BASE:
2607 *params = (GLfloat) ctx->List.ListBase;
2608 break;
2609 case GL_LIST_INDEX:
2610 *params = (GLfloat) ctx->CurrentListNum;
2611 break;
2612 case GL_LIST_MODE:
2613 *params = ctx->ExecuteFlag ? ENUM_TO_FLOAT(GL_COMPILE_AND_EXECUTE)
2614 : ENUM_TO_FLOAT(GL_COMPILE);
2615 break;
2616 case GL_INDEX_LOGIC_OP:
2617 *params = (GLfloat) ctx->Color.IndexLogicOpEnabled;
2618 break;
2619 case GL_COLOR_LOGIC_OP:
2620 *params = (GLfloat) ctx->Color.ColorLogicOpEnabled;
2621 break;
2622 case GL_LOGIC_OP_MODE:
2623 *params = ENUM_TO_FLOAT(ctx->Color.LogicOp);
2624 break;
2625 case GL_MAP1_COLOR_4:
2626 *params = (GLfloat) ctx->Eval.Map1Color4;
2627 break;
2628 case GL_MAP1_GRID_DOMAIN:
2629 params[0] = ctx->Eval.MapGrid1u1;
2630 params[1] = ctx->Eval.MapGrid1u2;
2631 break;
2632 case GL_MAP1_GRID_SEGMENTS:
2633 *params = (GLfloat) ctx->Eval.MapGrid1un;
2634 break;
2635 case GL_MAP1_INDEX:
2636 *params = (GLfloat) ctx->Eval.Map1Index;
2637 break;
2638 case GL_MAP1_NORMAL:
2639 *params = (GLfloat) ctx->Eval.Map1Normal;
2640 break;
2641 case GL_MAP1_TEXTURE_COORD_1:
2642 *params = (GLfloat) ctx->Eval.Map1TextureCoord1;
2643 break;
2644 case GL_MAP1_TEXTURE_COORD_2:
2645 *params = (GLfloat) ctx->Eval.Map1TextureCoord2;
2646 break;
2647 case GL_MAP1_TEXTURE_COORD_3:
2648 *params = (GLfloat) ctx->Eval.Map1TextureCoord3;
2649 break;
2650 case GL_MAP1_TEXTURE_COORD_4:
2651 *params = (GLfloat) ctx->Eval.Map1TextureCoord4;
2652 break;
2653 case GL_MAP1_VERTEX_3:
2654 *params = (GLfloat) ctx->Eval.Map1Vertex3;
2655 break;
2656 case GL_MAP1_VERTEX_4:
2657 *params = (GLfloat) ctx->Eval.Map1Vertex4;
2658 break;
2659 case GL_MAP2_COLOR_4:
2660 *params = (GLfloat) ctx->Eval.Map2Color4;
2661 break;
2662 case GL_MAP2_GRID_DOMAIN:
2663 params[0] = ctx->Eval.MapGrid2u1;
2664 params[1] = ctx->Eval.MapGrid2u2;
2665 params[2] = ctx->Eval.MapGrid2v1;
2666 params[3] = ctx->Eval.MapGrid2v2;
2667 break;
2668 case GL_MAP2_GRID_SEGMENTS:
2669 params[0] = (GLfloat) ctx->Eval.MapGrid2un;
2670 params[1] = (GLfloat) ctx->Eval.MapGrid2vn;
2671 break;
2672 case GL_MAP2_INDEX:
2673 *params = (GLfloat) ctx->Eval.Map2Index;
2674 break;
2675 case GL_MAP2_NORMAL:
2676 *params = (GLfloat) ctx->Eval.Map2Normal;
2677 break;
2678 case GL_MAP2_TEXTURE_COORD_1:
2679 *params = ctx->Eval.Map2TextureCoord1;
2680 break;
2681 case GL_MAP2_TEXTURE_COORD_2:
2682 *params = ctx->Eval.Map2TextureCoord2;
2683 break;
2684 case GL_MAP2_TEXTURE_COORD_3:
2685 *params = ctx->Eval.Map2TextureCoord3;
2686 break;
2687 case GL_MAP2_TEXTURE_COORD_4:
2688 *params = ctx->Eval.Map2TextureCoord4;
2689 break;
2690 case GL_MAP2_VERTEX_3:
2691 *params = (GLfloat) ctx->Eval.Map2Vertex3;
2692 break;
2693 case GL_MAP2_VERTEX_4:
2694 *params = (GLfloat) ctx->Eval.Map2Vertex4;
2695 break;
2696 case GL_MAP_COLOR:
2697 *params = (GLfloat) ctx->Pixel.MapColorFlag;
2698 break;
2699 case GL_MAP_STENCIL:
2700 *params = (GLfloat) ctx->Pixel.MapStencilFlag;
2701 break;
2702 case GL_MATRIX_MODE:
2703 *params = ENUM_TO_FLOAT(ctx->Transform.MatrixMode);
2704 break;
2705 case GL_MAX_ATTRIB_STACK_DEPTH:
2706 *params = (GLfloat) MAX_ATTRIB_STACK_DEPTH;
2707 break;
2708 case GL_MAX_CLIENT_ATTRIB_STACK_DEPTH:
2709 *params = (GLfloat) MAX_CLIENT_ATTRIB_STACK_DEPTH;
2710 break;
2711 case GL_MAX_CLIP_PLANES:
2712 *params = (GLfloat) MAX_CLIP_PLANES;
2713 break;
2714 case GL_MAX_ELEMENTS_VERTICES: /* GL_VERSION_1_2 */
2715 *params = (GLfloat) VB_MAX;
2716 break;
2717 case GL_MAX_ELEMENTS_INDICES: /* GL_VERSION_1_2 */
2718 *params = (GLfloat) VB_MAX;
2719 break;
2720 case GL_MAX_EVAL_ORDER:
2721 *params = (GLfloat) MAX_EVAL_ORDER;
2722 break;
2723 case GL_MAX_LIGHTS:
2724 *params = (GLfloat) MAX_LIGHTS;
2725 break;
2726 case GL_MAX_LIST_NESTING:
2727 *params = (GLfloat) MAX_LIST_NESTING;
2728 break;
2729 case GL_MAX_MODELVIEW_STACK_DEPTH:
2730 *params = (GLfloat) MAX_MODELVIEW_STACK_DEPTH;
2731 break;
2732 case GL_MAX_NAME_STACK_DEPTH:
2733 *params = (GLfloat) MAX_NAME_STACK_DEPTH;
2734 break;
2735 case GL_MAX_PIXEL_MAP_TABLE:
2736 *params = (GLfloat) MAX_PIXEL_MAP_TABLE;
2737 break;
2738 case GL_MAX_PROJECTION_STACK_DEPTH:
2739 *params = (GLfloat) MAX_PROJECTION_STACK_DEPTH;
2740 break;
2741 case GL_MAX_TEXTURE_SIZE:
2742 case GL_MAX_3D_TEXTURE_SIZE:
2743 *params = (GLfloat) ctx->Const.MaxTextureSize;
2744 break;
2745 case GL_MAX_TEXTURE_STACK_DEPTH:
2746 *params = (GLfloat) MAX_TEXTURE_STACK_DEPTH;
2747 break;
2748 case GL_MAX_VIEWPORT_DIMS:
2749 params[0] = (GLfloat) MAX_WIDTH;
2750 params[1] = (GLfloat) MAX_HEIGHT;
2751 break;
2752 case GL_MINMAX:
2753 *params = (GLfloat) ctx->Pixel.MinMaxEnabled;
2754 break;
2755 case GL_MODELVIEW_MATRIX:
2756 for (i=0;i<16;i++) {
2757 params[i] = ctx->ModelView.m[i];
2758 }
2759 break;
2760 case GL_MODELVIEW_STACK_DEPTH:
2761 *params = (GLfloat) (ctx->ModelViewStackDepth + 1);
2762 break;
2763 case GL_NAME_STACK_DEPTH:
2764 *params = (GLfloat) ctx->Select.NameStackDepth;
2765 break;
2766 case GL_NORMALIZE:
2767 *params = (GLfloat) ctx->Transform.Normalize;
2768 break;
2769 case GL_PACK_ALIGNMENT:
2770 *params = (GLfloat) ctx->Pack.Alignment;
2771 break;
2772 case GL_PACK_LSB_FIRST:
2773 *params = (GLfloat) ctx->Pack.LsbFirst;
2774 break;
2775 case GL_PACK_ROW_LENGTH:
2776 *params = (GLfloat) ctx->Pack.RowLength;
2777 break;
2778 case GL_PACK_SKIP_PIXELS:
2779 *params = (GLfloat) ctx->Pack.SkipPixels;
2780 break;
2781 case GL_PACK_SKIP_ROWS:
2782 *params = (GLfloat) ctx->Pack.SkipRows;
2783 break;
2784 case GL_PACK_SWAP_BYTES:
2785 *params = (GLfloat) ctx->Pack.SwapBytes;
2786 break;
2787 case GL_PACK_SKIP_IMAGES_EXT:
2788 *params = (GLfloat) ctx->Pack.SkipImages;
2789 break;
2790 case GL_PACK_IMAGE_HEIGHT_EXT:
2791 *params = (GLfloat) ctx->Pack.ImageHeight;
2792 break;
2793 case GL_PERSPECTIVE_CORRECTION_HINT:
2794 *params = ENUM_TO_FLOAT(ctx->Hint.PerspectiveCorrection);
2795 break;
2796 case GL_PIXEL_MAP_A_TO_A_SIZE:
2797 *params = (GLfloat) ctx->Pixel.MapAtoAsize;
2798 break;
2799 case GL_PIXEL_MAP_B_TO_B_SIZE:
2800 *params = (GLfloat) ctx->Pixel.MapBtoBsize;
2801 break;
2802 case GL_PIXEL_MAP_G_TO_G_SIZE:
2803 *params = (GLfloat) ctx->Pixel.MapGtoGsize;
2804 break;
2805 case GL_PIXEL_MAP_I_TO_A_SIZE:
2806 *params = (GLfloat) ctx->Pixel.MapItoAsize;
2807 break;
2808 case GL_PIXEL_MAP_I_TO_B_SIZE:
2809 *params = (GLfloat) ctx->Pixel.MapItoBsize;
2810 break;
2811 case GL_PIXEL_MAP_I_TO_G_SIZE:
2812 *params = (GLfloat) ctx->Pixel.MapItoGsize;
2813 break;
2814 case GL_PIXEL_MAP_I_TO_I_SIZE:
2815 *params = (GLfloat) ctx->Pixel.MapItoIsize;
2816 break;
2817 case GL_PIXEL_MAP_I_TO_R_SIZE:
2818 *params = (GLfloat) ctx->Pixel.MapItoRsize;
2819 break;
2820 case GL_PIXEL_MAP_R_TO_R_SIZE:
2821 *params = (GLfloat) ctx->Pixel.MapRtoRsize;
2822 break;
2823 case GL_PIXEL_MAP_S_TO_S_SIZE:
2824 *params = (GLfloat) ctx->Pixel.MapStoSsize;
2825 break;
2826 case GL_POINT_SIZE:
2827 *params = (GLfloat) ctx->Point.UserSize;
2828 break;
2829 case GL_POINT_SIZE_GRANULARITY:
2830 *params = (GLfloat) ctx->Const.PointSizeGranularity;
2831 break;
2832 case GL_POINT_SIZE_RANGE:
2833 params[0] = (GLfloat) ctx->Const.MinPointSizeAA;
2834 params[1] = (GLfloat) ctx->Const.MaxPointSizeAA;
2835 break;
2836 case GL_ALIASED_POINT_SIZE_RANGE:
2837 params[0] = (GLfloat) ctx->Const.MinPointSize;
2838 params[1] = (GLfloat) ctx->Const.MaxPointSize;
2839 break;
2840 case GL_POINT_SMOOTH:
2841 *params = (GLfloat) ctx->Point.SmoothFlag;
2842 break;
2843 case GL_POINT_SMOOTH_HINT:
2844 *params = ENUM_TO_FLOAT(ctx->Hint.PointSmooth);
2845 break;
2846 case GL_POINT_SIZE_MIN_EXT:
2847 *params = (GLfloat) (ctx->Point.MinSize);
2848 break;
2849 case GL_POINT_SIZE_MAX_EXT:
2850 *params = (GLfloat) (ctx->Point.MaxSize);
2851 break;
2852 case GL_POINT_FADE_THRESHOLD_SIZE_EXT:
2853 *params = (GLfloat) (ctx->Point.Threshold);
2854 break;
2855 case GL_DISTANCE_ATTENUATION_EXT:
2856 params[0] = (GLfloat) (ctx->Point.Params[0]);
2857 params[1] = (GLfloat) (ctx->Point.Params[1]);
2858 params[2] = (GLfloat) (ctx->Point.Params[2]);
2859 break;
2860 case GL_POLYGON_MODE:
2861 params[0] = ENUM_TO_FLOAT(ctx->Polygon.FrontMode);
2862 params[1] = ENUM_TO_FLOAT(ctx->Polygon.BackMode);
2863 break;
2864 #ifdef GL_EXT_polygon_offset
2865 case GL_POLYGON_OFFSET_BIAS_EXT:
2866 *params = ctx->Polygon.OffsetUnits;
2867 break;
2868 #endif
2869 case GL_POLYGON_OFFSET_FACTOR:
2870 *params = ctx->Polygon.OffsetFactor;
2871 break;
2872 case GL_POLYGON_OFFSET_UNITS:
2873 *params = ctx->Polygon.OffsetUnits;
2874 break;
2875 case GL_POLYGON_SMOOTH:
2876 *params = (GLfloat) ctx->Polygon.SmoothFlag;
2877 break;
2878 case GL_POLYGON_SMOOTH_HINT:
2879 *params = ENUM_TO_FLOAT(ctx->Hint.PolygonSmooth);
2880 break;
2881 case GL_POLYGON_STIPPLE:
2882 *params = (GLfloat) ctx->Polygon.StippleFlag;
2883 break;
2884 case GL_PROJECTION_MATRIX:
2885 for (i=0;i<16;i++) {
2886 params[i] = ctx->ProjectionMatrix.m[i];
2887 }
2888 break;
2889 case GL_PROJECTION_STACK_DEPTH:
2890 *params = (GLfloat) (ctx->ProjectionStackDepth + 1);
2891 break;
2892 case GL_READ_BUFFER:
2893 *params = ENUM_TO_FLOAT(ctx->Pixel.ReadBuffer);
2894 break;
2895 case GL_RED_BIAS:
2896 *params = ctx->Pixel.RedBias;
2897 break;
2898 case GL_RED_BITS:
2899 *params = (GLfloat) ctx->Visual->RedBits;
2900 break;
2901 case GL_RED_SCALE:
2902 *params = ctx->Pixel.RedScale;
2903 break;
2904 case GL_RENDER_MODE:
2905 *params = ENUM_TO_FLOAT(ctx->RenderMode);
2906 break;
2907 case GL_RGBA_MODE:
2908 *params = (GLfloat) ctx->Visual->RGBAflag;
2909 break;
2910 case GL_SCISSOR_BOX:
2911 params[0] = (GLfloat) ctx->Scissor.X;
2912 params[1] = (GLfloat) ctx->Scissor.Y;
2913 params[2] = (GLfloat) ctx->Scissor.Width;
2914 params[3] = (GLfloat) ctx->Scissor.Height;
2915 break;
2916 case GL_SCISSOR_TEST:
2917 *params = (GLfloat) ctx->Scissor.Enabled;
2918 break;
2919 case GL_SELECTION_BUFFER_SIZE:
2920 *params = (GLfloat) ctx->Select.BufferSize;
2921 break;
2922 case GL_SHADE_MODEL:
2923 *params = ENUM_TO_FLOAT(ctx->Light.ShadeModel);
2924 break;
2925 case GL_SHARED_TEXTURE_PALETTE_EXT:
2926 *params = (GLfloat) ctx->Texture.SharedPalette;
2927 break;
2928 case GL_STENCIL_BITS:
2929 *params = (GLfloat) ctx->Visual->StencilBits;
2930 break;
2931 case GL_STENCIL_CLEAR_VALUE:
2932 *params = (GLfloat) ctx->Stencil.Clear;
2933 break;
2934 case GL_STENCIL_FAIL:
2935 *params = ENUM_TO_FLOAT(ctx->Stencil.FailFunc);
2936 break;
2937 case GL_STENCIL_FUNC:
2938 *params = ENUM_TO_FLOAT(ctx->Stencil.Function);
2939 break;
2940 case GL_STENCIL_PASS_DEPTH_FAIL:
2941 *params = ENUM_TO_FLOAT(ctx->Stencil.ZFailFunc);
2942 break;
2943 case GL_STENCIL_PASS_DEPTH_PASS:
2944 *params = ENUM_TO_FLOAT(ctx->Stencil.ZPassFunc);
2945 break;
2946 case GL_STENCIL_REF:
2947 *params = (GLfloat) ctx->Stencil.Ref;
2948 break;
2949 case GL_STENCIL_TEST:
2950 *params = (GLfloat) ctx->Stencil.Enabled;
2951 break;
2952 case GL_STENCIL_VALUE_MASK:
2953 *params = (GLfloat) ctx->Stencil.ValueMask;
2954 break;
2955 case GL_STENCIL_WRITEMASK:
2956 *params = (GLfloat) ctx->Stencil.WriteMask;
2957 break;
2958 case GL_STEREO:
2959 *params = (GLfloat) ctx->Visual->StereoFlag;
2960 break;
2961 case GL_SUBPIXEL_BITS:
2962 *params = (GLfloat) ctx->Const.SubPixelBits;
2963 break;
2964 case GL_TEXTURE_1D:
2965 *params = _mesa_IsEnabled(GL_TEXTURE_1D) ? 1.0 : 0.0;
2966 break;
2967 case GL_TEXTURE_2D:
2968 *params = _mesa_IsEnabled(GL_TEXTURE_2D) ? 1.0 : 0.0;
2969 break;
2970 case GL_TEXTURE_3D:
2971 *params = _mesa_IsEnabled(GL_TEXTURE_3D) ? 1.0 : 0.0;
2972 break;
2973 case GL_TEXTURE_BINDING_1D:
2974 *params = (GLfloat) textureUnit->CurrentD[1]->Name;
2975 break;
2976 case GL_TEXTURE_BINDING_2D:
2977 *params = (GLfloat) textureUnit->CurrentD[2]->Name;
2978 break;
2979 case GL_TEXTURE_BINDING_3D:
2980 *params = (GLfloat) textureUnit->CurrentD[2]->Name;
2981 break;
2982 case GL_TEXTURE_ENV_COLOR:
2983 params[0] = textureUnit->EnvColor[0];
2984 params[1] = textureUnit->EnvColor[1];
2985 params[2] = textureUnit->EnvColor[2];
2986 params[3] = textureUnit->EnvColor[3];
2987 break;
2988 case GL_TEXTURE_ENV_MODE:
2989 *params = ENUM_TO_FLOAT(textureUnit->EnvMode);
2990 break;
2991 case GL_TEXTURE_GEN_S:
2992 *params = (textureUnit->TexGenEnabled & S_BIT) ? 1.0 : 0.0;
2993 break;
2994 case GL_TEXTURE_GEN_T:
2995 *params = (textureUnit->TexGenEnabled & T_BIT) ? 1.0 : 0.0;
2996 break;
2997 case GL_TEXTURE_GEN_R:
2998 *params = (textureUnit->TexGenEnabled & R_BIT) ? 1.0 : 0.0;
2999 break;
3000 case GL_TEXTURE_GEN_Q:
3001 *params = (textureUnit->TexGenEnabled & Q_BIT) ? 1.0 : 0.0;
3002 break;
3003 case GL_TEXTURE_MATRIX:
3004 for (i=0;i<16;i++) {
3005 params[i] = ctx->TextureMatrix[texTransformUnit].m[i];
3006 }
3007 break;
3008 case GL_TEXTURE_STACK_DEPTH:
3009 *params = (GLfloat) (ctx->TextureStackDepth[texTransformUnit] + 1);
3010 break;
3011 case GL_UNPACK_ALIGNMENT:
3012 *params = (GLfloat) ctx->Unpack.Alignment;
3013 break;
3014 case GL_UNPACK_LSB_FIRST:
3015 *params = (GLfloat) ctx->Unpack.LsbFirst;
3016 break;
3017 case GL_UNPACK_ROW_LENGTH:
3018 *params = (GLfloat) ctx->Unpack.RowLength;
3019 break;
3020 case GL_UNPACK_SKIP_PIXELS:
3021 *params = (GLfloat) ctx->Unpack.SkipPixels;
3022 break;
3023 case GL_UNPACK_SKIP_ROWS:
3024 *params = (GLfloat) ctx->Unpack.SkipRows;
3025 break;
3026 case GL_UNPACK_SWAP_BYTES:
3027 *params = (GLfloat) ctx->Unpack.SwapBytes;
3028 break;
3029 case GL_UNPACK_SKIP_IMAGES_EXT:
3030 *params = (GLfloat) ctx->Unpack.SkipImages;
3031 break;
3032 case GL_UNPACK_IMAGE_HEIGHT_EXT:
3033 *params = (GLfloat) ctx->Unpack.ImageHeight;
3034 break;
3035 case GL_VIEWPORT:
3036 params[0] = (GLfloat) ctx->Viewport.X;
3037 params[1] = (GLfloat) ctx->Viewport.Y;
3038 params[2] = (GLfloat) ctx->Viewport.Width;
3039 params[3] = (GLfloat) ctx->Viewport.Height;
3040 break;
3041 case GL_ZOOM_X:
3042 *params = (GLfloat) ctx->Pixel.ZoomX;
3043 break;
3044 case GL_ZOOM_Y:
3045 *params = (GLfloat) ctx->Pixel.ZoomY;
3046 break;
3047 case GL_VERTEX_ARRAY:
3048 *params = (GLfloat) ctx->Array.Vertex.Enabled;
3049 break;
3050 case GL_VERTEX_ARRAY_SIZE:
3051 *params = (GLfloat) ctx->Array.Vertex.Size;
3052 break;
3053 case GL_VERTEX_ARRAY_TYPE:
3054 *params = ENUM_TO_FLOAT(ctx->Array.Vertex.Type);
3055 break;
3056 case GL_VERTEX_ARRAY_STRIDE:
3057 *params = (GLfloat) ctx->Array.Vertex.Stride;
3058 break;
3059 case GL_VERTEX_ARRAY_COUNT_EXT:
3060 *params = 0.0;
3061 break;
3062 case GL_NORMAL_ARRAY:
3063 *params = (GLfloat) ctx->Array.Normal.Enabled;
3064 break;
3065 case GL_NORMAL_ARRAY_TYPE:
3066 *params = ENUM_TO_FLOAT(ctx->Array.Normal.Type);
3067 break;
3068 case GL_NORMAL_ARRAY_STRIDE:
3069 *params = (GLfloat) ctx->Array.Normal.Stride;
3070 break;
3071 case GL_NORMAL_ARRAY_COUNT_EXT:
3072 *params = 0.0;
3073 break;
3074 case GL_COLOR_ARRAY:
3075 *params = (GLfloat) ctx->Array.Color.Enabled;
3076 break;
3077 case GL_COLOR_ARRAY_SIZE:
3078 *params = (GLfloat) ctx->Array.Color.Size;
3079 break;
3080 case GL_COLOR_ARRAY_TYPE:
3081 *params = ENUM_TO_FLOAT(ctx->Array.Color.Type);
3082 break;
3083 case GL_COLOR_ARRAY_STRIDE:
3084 *params = (GLfloat) ctx->Array.Color.Stride;
3085 break;
3086 case GL_COLOR_ARRAY_COUNT_EXT:
3087 *params = 0.0;
3088 break;
3089 case GL_INDEX_ARRAY:
3090 *params = (GLfloat) ctx->Array.Index.Enabled;
3091 break;
3092 case GL_INDEX_ARRAY_TYPE:
3093 *params = ENUM_TO_FLOAT(ctx->Array.Index.Type);
3094 break;
3095 case GL_INDEX_ARRAY_STRIDE:
3096 *params = (GLfloat) ctx->Array.Index.Stride;
3097 break;
3098 case GL_INDEX_ARRAY_COUNT_EXT:
3099 *params = 0.0;
3100 break;
3101 case GL_TEXTURE_COORD_ARRAY:
3102 *params = (GLfloat) ctx->Array.TexCoord[texUnit].Enabled;
3103 break;
3104 case GL_TEXTURE_COORD_ARRAY_SIZE:
3105 *params = (GLfloat) ctx->Array.TexCoord[texUnit].Size;
3106 break;
3107 case GL_TEXTURE_COORD_ARRAY_TYPE:
3108 *params = ENUM_TO_FLOAT(ctx->Array.TexCoord[texUnit].Type);
3109 break;
3110 case GL_TEXTURE_COORD_ARRAY_STRIDE:
3111 *params = (GLfloat) ctx->Array.TexCoord[texUnit].Stride;
3112 break;
3113 case GL_TEXTURE_COORD_ARRAY_COUNT_EXT:
3114 *params = 0.0;
3115 break;
3116 case GL_EDGE_FLAG_ARRAY:
3117 *params = (GLfloat) ctx->Array.EdgeFlag.Enabled;
3118 break;
3119 case GL_EDGE_FLAG_ARRAY_STRIDE:
3120 *params = (GLfloat) ctx->Array.EdgeFlag.Stride;
3121 break;
3122 case GL_EDGE_FLAG_ARRAY_COUNT_EXT:
3123 *params = 0.0;
3124 break;
3125
3126 case GL_MAX_TEXTURE_UNITS_ARB:
3127 *params = (GLfloat) ctx->Const.MaxTextureUnits;
3128 break;
3129 case GL_ACTIVE_TEXTURE_ARB:
3130 *params = (GLfloat) (GL_TEXTURE0_ARB + ctx->Texture.CurrentUnit);
3131 break;
3132 case GL_CLIENT_ACTIVE_TEXTURE_ARB:
3133 *params = (GLfloat) (GL_TEXTURE0_ARB + ctx->Array.ActiveTexture);
3134 break;
3135
3136 /* GL_PGI_misc_hints */
3137 case GL_STRICT_DEPTHFUNC_HINT_PGI:
3138 *params = ENUM_TO_FLOAT(GL_NICEST);
3139 break;
3140 case GL_STRICT_LIGHTING_HINT_PGI:
3141 *params = ENUM_TO_FLOAT(ctx->Hint.StrictLighting);
3142 break;
3143 case GL_STRICT_SCISSOR_HINT_PGI:
3144 case GL_FULL_STIPPLE_HINT_PGI:
3145 *params = ENUM_TO_FLOAT(GL_TRUE);
3146 break;
3147 case GL_CONSERVE_MEMORY_HINT_PGI:
3148 *params = ENUM_TO_FLOAT(GL_FALSE);
3149 break;
3150 case GL_ALWAYS_FAST_HINT_PGI:
3151 *params = (GLfloat) (ctx->Hint.AllowDrawWin == GL_TRUE &&
3152 ctx->Hint.AllowDrawFrg == GL_FALSE &&
3153 ctx->Hint.AllowDrawMem == GL_FALSE);
3154 break;
3155 case GL_ALWAYS_SOFT_HINT_PGI:
3156 *params = (GLfloat) (ctx->Hint.AllowDrawWin == GL_TRUE &&
3157 ctx->Hint.AllowDrawFrg == GL_TRUE &&
3158 ctx->Hint.AllowDrawMem == GL_TRUE);
3159 break;
3160 case GL_ALLOW_DRAW_OBJ_HINT_PGI:
3161 *params = (GLfloat) GL_TRUE;
3162 break;
3163 case GL_ALLOW_DRAW_WIN_HINT_PGI:
3164 *params = (GLfloat) ctx->Hint.AllowDrawWin;
3165 break;
3166 case GL_ALLOW_DRAW_FRG_HINT_PGI:
3167 *params = (GLfloat) ctx->Hint.AllowDrawFrg;
3168 break;
3169 case GL_ALLOW_DRAW_MEM_HINT_PGI:
3170 *params = (GLfloat) ctx->Hint.AllowDrawMem;
3171 break;
3172 case GL_CLIP_NEAR_HINT_PGI:
3173 case GL_CLIP_FAR_HINT_PGI:
3174 *params = ENUM_TO_FLOAT(GL_TRUE);
3175 break;
3176 case GL_WIDE_LINE_HINT_PGI:
3177 *params = ENUM_TO_FLOAT(GL_DONT_CARE);
3178 break;
3179 case GL_BACK_NORMALS_HINT_PGI:
3180 *params = ENUM_TO_FLOAT(GL_TRUE);
3181 break;
3182 case GL_NATIVE_GRAPHICS_HANDLE_PGI:
3183 *params = 0;
3184 break;
3185
3186 /* GL_EXT_compiled_vertex_array */
3187 case GL_ARRAY_ELEMENT_LOCK_FIRST_EXT:
3188 *params = (GLfloat) ctx->Array.LockFirst;
3189 break;
3190 case GL_ARRAY_ELEMENT_LOCK_COUNT_EXT:
3191 *params = (GLfloat) ctx->Array.LockCount;
3192 break;
3193
3194 /* GL_ARB_transpose_matrix */
3195 case GL_TRANSPOSE_COLOR_MATRIX_ARB:
3196 /* don't have a color matrix */
3197 break;
3198 case GL_TRANSPOSE_MODELVIEW_MATRIX_ARB:
3199 gl_matrix_transposef(params, ctx->ModelView.m);
3200 break;
3201 case GL_TRANSPOSE_PROJECTION_MATRIX_ARB:
3202 gl_matrix_transposef(params, ctx->ProjectionMatrix.m);
3203 break;
3204 case GL_TRANSPOSE_TEXTURE_MATRIX_ARB:
3205 gl_matrix_transposef(params, ctx->TextureMatrix[texTransformUnit].m);
3206 break;
3207
3208 /* GL_HP_occlusion_test */
3209 case GL_OCCLUSION_TEST_HP:
3210 if (ctx->Extensions.HaveHpOcclusionTest) {
3211 *params = (GLfloat) ctx->Depth.OcclusionTest;
3212 }
3213 else {
3214 gl_error( ctx, GL_INVALID_ENUM, "glGetFloatv" );
3215 }
3216 return;
3217 case GL_OCCLUSION_TEST_RESULT_HP:
3218 if (ctx->Extensions.HaveHpOcclusionTest) {
3219 if (ctx->Depth.OcclusionTest)
3220 *params = (GLfloat) ctx->OcclusionResult;
3221 else
3222 *params = (GLfloat) ctx->OcclusionResultSaved;
3223 /* reset flag now */
3224 ctx->OcclusionResult = GL_FALSE;
3225 ctx->OcclusionResultSaved = GL_FALSE;
3226 }
3227 else {
3228 gl_error( ctx, GL_INVALID_ENUM, "glGetFloatv" );
3229 }
3230 return;
3231
3232 /* GL_SGIS_pixel_texture */
3233 case GL_PIXEL_TEXTURE_SGIS:
3234 *params = (GLfloat) ctx->Pixel.PixelTextureEnabled;
3235 break;
3236
3237 /* GL_SGIX_pixel_texture */
3238 case GL_PIXEL_TEX_GEN_SGIX:
3239 *params = (GLfloat) ctx->Pixel.PixelTextureEnabled;
3240 break;
3241 case GL_PIXEL_TEX_GEN_MODE_SGIX:
3242 *params = (GLfloat) pixel_texgen_mode(ctx);
3243 break;
3244
3245 /* GL_SGI_color_matrix (also in 1.2 imaging) */
3246 case GL_COLOR_MATRIX_SGI:
3247 for (i=0;i<16;i++) {
3248 params[i] = ctx->ColorMatrix.m[i];
3249 }
3250 break;
3251 case GL_COLOR_MATRIX_STACK_DEPTH_SGI:
3252 *params = (GLfloat) (ctx->ColorStackDepth + 1);
3253 break;
3254 case GL_MAX_COLOR_MATRIX_STACK_DEPTH_SGI:
3255 *params = (GLfloat) MAX_COLOR_STACK_DEPTH;
3256 break;
3257 case GL_POST_COLOR_MATRIX_RED_SCALE_SGI:
3258 *params = ctx->Pixel.PostColorMatrixScale[0];
3259 break;
3260 case GL_POST_COLOR_MATRIX_GREEN_SCALE_SGI:
3261 *params = ctx->Pixel.PostColorMatrixScale[1];
3262 break;
3263 case GL_POST_COLOR_MATRIX_BLUE_SCALE_SGI:
3264 *params = ctx->Pixel.PostColorMatrixScale[2];
3265 break;
3266 case GL_POST_COLOR_MATRIX_ALPHA_SCALE_SGI:
3267 *params = ctx->Pixel.PostColorMatrixScale[3];
3268 break;
3269 case GL_POST_COLOR_MATRIX_RED_BIAS_SGI:
3270 *params = ctx->Pixel.PostColorMatrixBias[0];
3271 break;
3272 case GL_POST_COLOR_MATRIX_GREEN_BIAS_SGI:
3273 *params = ctx->Pixel.PostColorMatrixBias[1];
3274 break;
3275 case GL_POST_COLOR_MATRIX_BLUE_BIAS_SGI:
3276 *params = ctx->Pixel.PostColorMatrixBias[2];
3277 break;
3278 case GL_POST_COLOR_MATRIX_ALPHA_BIAS_SGI:
3279 *params = ctx->Pixel.PostColorMatrixBias[3];
3280 break;
3281
3282 /* GL_EXT_convolution (also in 1.2 imaging) */
3283 case GL_MAX_CONVOLUTION_WIDTH:
3284 *params = (GLfloat) ctx->Const.MaxConvolutionWidth;
3285 break;
3286 case GL_MAX_CONVOLUTION_HEIGHT:
3287 *params = (GLfloat) ctx->Const.MaxConvolutionHeight;
3288 break;
3289 case GL_POST_CONVOLUTION_RED_SCALE_EXT:
3290 *params = ctx->Pixel.PostConvolutionScale[0];
3291 break;
3292 case GL_POST_CONVOLUTION_GREEN_SCALE_EXT:
3293 *params = ctx->Pixel.PostConvolutionScale[1];
3294 break;
3295 case GL_POST_CONVOLUTION_BLUE_SCALE_EXT:
3296 *params = ctx->Pixel.PostConvolutionScale[2];
3297 break;
3298 case GL_POST_CONVOLUTION_ALPHA_SCALE_EXT:
3299 *params = ctx->Pixel.PostConvolutionScale[3];
3300 break;
3301 case GL_POST_CONVOLUTION_RED_BIAS_EXT:
3302 *params = ctx->Pixel.PostConvolutionBias[0];
3303 break;
3304 case GL_POST_CONVOLUTION_GREEN_BIAS_EXT:
3305 *params = ctx->Pixel.PostConvolutionBias[1];
3306 break;
3307 case GL_POST_CONVOLUTION_BLUE_BIAS_EXT:
3308 *params = ctx->Pixel.PostConvolutionBias[2];
3309 break;
3310 case GL_POST_CONVOLUTION_ALPHA_BIAS_EXT:
3311 *params = ctx->Pixel.PostConvolutionBias[2];
3312 break;
3313
3314 /* GL_SGI_color_table (also in 1.2 imaging */
3315 case GL_COLOR_TABLE_SGI:
3316 *params = (GLfloat) ctx->Pixel.ColorTableEnabled;
3317 break;
3318 case GL_POST_CONVOLUTION_COLOR_TABLE_SGI:
3319 *params = (GLfloat) ctx->Pixel.PostConvolutionColorTableEnabled;
3320 break;
3321 case GL_POST_COLOR_MATRIX_COLOR_TABLE_SGI:
3322 *params = (GLfloat) ctx->Pixel.PostColorMatrixColorTableEnabled;
3323 break;
3324
3325 default:
3326 gl_error( ctx, GL_INVALID_ENUM, "glGetFloatv" );
3327 }
3328 }
3329
3330
3331
3332
3333 void
3334 _mesa_GetIntegerv( GLenum pname, GLint *params )
3335 {
3336 GET_CURRENT_CONTEXT(ctx);
3337 GLuint i;
3338 GLuint texUnit = ctx->Texture.CurrentUnit;
3339 GLuint texTransformUnit = ctx->Texture.CurrentTransformUnit;
3340 const struct gl_texture_unit *textureUnit = &ctx->Texture.Unit[texUnit];
3341
3342 ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx, "glGetIntegerv");
3343
3344 if (MESA_VERBOSE & VERBOSE_API)
3345 fprintf(stderr, "glGetIntegerv %s\n", gl_lookup_enum_by_nr(pname));
3346
3347 switch (pname) {
3348 case GL_ACCUM_RED_BITS:
3349 *params = (GLint) ctx->Visual->AccumRedBits;
3350 break;
3351 case GL_ACCUM_GREEN_BITS:
3352 *params = (GLint) ctx->Visual->AccumGreenBits;
3353 break;
3354 case GL_ACCUM_BLUE_BITS:
3355 *params = (GLint) ctx->Visual->AccumBlueBits;
3356 break;
3357 case GL_ACCUM_ALPHA_BITS:
3358 *params = (GLint) ctx->Visual->AccumAlphaBits;
3359 break;
3360 case GL_ACCUM_CLEAR_VALUE:
3361 params[0] = FLOAT_TO_INT( ctx->Accum.ClearColor[0] );
3362 params[1] = FLOAT_TO_INT( ctx->Accum.ClearColor[1] );
3363 params[2] = FLOAT_TO_INT( ctx->Accum.ClearColor[2] );
3364 params[3] = FLOAT_TO_INT( ctx->Accum.ClearColor[3] );
3365 break;
3366 case GL_ALPHA_BIAS:
3367 *params = (GLint) ctx->Pixel.AlphaBias;
3368 break;
3369 case GL_ALPHA_BITS:
3370 *params = ctx->Visual->AlphaBits;
3371 break;
3372 case GL_ALPHA_SCALE:
3373 *params = (GLint) ctx->Pixel.AlphaScale;
3374 break;
3375 case GL_ALPHA_TEST:
3376 *params = (GLint) ctx->Color.AlphaEnabled;
3377 break;
3378 case GL_ALPHA_TEST_REF:
3379 *params = FLOAT_TO_INT( (GLfloat) ctx->Color.AlphaRef / 255.0 );
3380 break;
3381 case GL_ALPHA_TEST_FUNC:
3382 *params = (GLint) ctx->Color.AlphaFunc;
3383 break;
3384 case GL_ATTRIB_STACK_DEPTH:
3385 *params = (GLint) (ctx->AttribStackDepth);
3386 break;
3387 case GL_AUTO_NORMAL:
3388 *params = (GLint) ctx->Eval.AutoNormal;
3389 break;
3390 case GL_AUX_BUFFERS:
3391 *params = (GLint) ctx->Const.NumAuxBuffers;
3392 break;
3393 case GL_BLEND:
3394 *params = (GLint) ctx->Color.BlendEnabled;
3395 break;
3396 case GL_BLEND_DST:
3397 *params = (GLint) ctx->Color.BlendDstRGB;
3398 break;
3399 case GL_BLEND_SRC:
3400 *params = (GLint) ctx->Color.BlendSrcRGB;
3401 break;
3402 case GL_BLEND_SRC_RGB_EXT:
3403 *params = (GLint) ctx->Color.BlendSrcRGB;
3404 break;
3405 case GL_BLEND_DST_RGB_EXT:
3406 *params = (GLint) ctx->Color.BlendDstRGB;
3407 break;
3408 case GL_BLEND_SRC_ALPHA_EXT:
3409 *params = (GLint) ctx->Color.BlendSrcA;
3410 break;
3411 case GL_BLEND_DST_ALPHA_EXT:
3412 *params = (GLint) ctx->Color.BlendDstA;
3413 break;
3414 case GL_BLEND_EQUATION_EXT:
3415 *params = (GLint) ctx->Color.BlendEquation;
3416 break;
3417 case GL_BLEND_COLOR_EXT:
3418 params[0] = FLOAT_TO_INT( ctx->Color.BlendColor[0] );
3419 params[1] = FLOAT_TO_INT( ctx->Color.BlendColor[1] );
3420 params[2] = FLOAT_TO_INT( ctx->Color.BlendColor[2] );
3421 params[3] = FLOAT_TO_INT( ctx->Color.BlendColor[3] );
3422 break;
3423 case GL_BLUE_BIAS:
3424 *params = (GLint) ctx->Pixel.BlueBias;
3425 break;
3426 case GL_BLUE_BITS:
3427 *params = (GLint) ctx->Visual->BlueBits;
3428 break;
3429 case GL_BLUE_SCALE:
3430 *params = (GLint) ctx->Pixel.BlueScale;
3431 break;
3432 case GL_CLIENT_ATTRIB_STACK_DEPTH:
3433 *params = (GLint) (ctx->ClientAttribStackDepth);
3434 break;
3435 case GL_CLIP_PLANE0:
3436 case GL_CLIP_PLANE1:
3437 case GL_CLIP_PLANE2:
3438 case GL_CLIP_PLANE3:
3439 case GL_CLIP_PLANE4:
3440 case GL_CLIP_PLANE5:
3441 i = (GLint) (pname - GL_CLIP_PLANE0);
3442 *params = (GLint) ctx->Transform.ClipEnabled[i];
3443 break;
3444 case GL_COLOR_CLEAR_VALUE:
3445 params[0] = FLOAT_TO_INT( ctx->Color.ClearColor[0] );
3446 params[1] = FLOAT_TO_INT( ctx->Color.ClearColor[1] );
3447 params[2] = FLOAT_TO_INT( ctx->Color.ClearColor[2] );
3448 params[3] = FLOAT_TO_INT( ctx->Color.ClearColor[3] );
3449 break;
3450 case GL_COLOR_MATERIAL:
3451 *params = (GLint) ctx->Light.ColorMaterialEnabled;
3452 break;
3453 case GL_COLOR_MATERIAL_FACE:
3454 *params = (GLint) ctx->Light.ColorMaterialFace;
3455 break;
3456 case GL_COLOR_MATERIAL_PARAMETER:
3457 *params = (GLint) ctx->Light.ColorMaterialMode;
3458 break;
3459 case GL_COLOR_WRITEMASK:
3460 params[0] = ctx->Color.ColorMask[RCOMP] ? 1 : 0;
3461 params[1] = ctx->Color.ColorMask[GCOMP] ? 1 : 0;
3462 params[2] = ctx->Color.ColorMask[BCOMP] ? 1 : 0;
3463 params[3] = ctx->Color.ColorMask[ACOMP] ? 1 : 0;
3464 break;
3465 case GL_CULL_FACE:
3466 *params = (GLint) ctx->Polygon.CullFlag;
3467 break;
3468 case GL_CULL_FACE_MODE:
3469 *params = (GLint) ctx->Polygon.CullFaceMode;
3470 break;
3471 case GL_CURRENT_COLOR:
3472 params[0] = FLOAT_TO_INT( UBYTE_COLOR_TO_FLOAT_COLOR( ctx->Current.ByteColor[0] ) );
3473 params[1] = FLOAT_TO_INT( UBYTE_COLOR_TO_FLOAT_COLOR( ctx->Current.ByteColor[1] ) );
3474 params[2] = FLOAT_TO_INT( UBYTE_COLOR_TO_FLOAT_COLOR( ctx->Current.ByteColor[2] ) );
3475 params[3] = FLOAT_TO_INT( UBYTE_COLOR_TO_FLOAT_COLOR( ctx->Current.ByteColor[3] ) );
3476 break;
3477 case GL_CURRENT_INDEX:
3478 *params = (GLint) ctx->Current.Index;
3479 break;
3480 case GL_CURRENT_NORMAL:
3481 params[0] = FLOAT_TO_INT( ctx->Current.Normal[0] );
3482 params[1] = FLOAT_TO_INT( ctx->Current.Normal[1] );
3483 params[2] = FLOAT_TO_INT( ctx->Current.Normal[2] );
3484 break;
3485 case GL_CURRENT_RASTER_COLOR:
3486 params[0] = FLOAT_TO_INT( ctx->Current.RasterColor[0] );
3487 params[1] = FLOAT_TO_INT( ctx->Current.RasterColor[1] );
3488 params[2] = FLOAT_TO_INT( ctx->Current.RasterColor[2] );
3489 params[3] = FLOAT_TO_INT( ctx->Current.RasterColor[3] );
3490 break;
3491 case GL_CURRENT_RASTER_DISTANCE:
3492 params[0] = (GLint) ctx->Current.RasterDistance;
3493 break;
3494 case GL_CURRENT_RASTER_INDEX:
3495 *params = (GLint) ctx->Current.RasterIndex;
3496 break;
3497 case GL_CURRENT_RASTER_POSITION:
3498 params[0] = (GLint) ctx->Current.RasterPos[0];
3499 params[1] = (GLint) ctx->Current.RasterPos[1];
3500 params[2] = (GLint) ctx->Current.RasterPos[2];
3501 params[3] = (GLint) ctx->Current.RasterPos[3];
3502 break;
3503 case GL_CURRENT_RASTER_TEXTURE_COORDS:
3504 params[0] = (GLint) ctx->Current.RasterMultiTexCoord[texTransformUnit][0];
3505 params[1] = (GLint) ctx->Current.RasterMultiTexCoord[texTransformUnit][1];
3506 params[2] = (GLint) ctx->Current.RasterMultiTexCoord[texTransformUnit][2];
3507 params[3] = (GLint) ctx->Current.RasterMultiTexCoord[texTransformUnit][3];
3508 break;
3509 case GL_CURRENT_RASTER_POSITION_VALID:
3510 *params = (GLint) ctx->Current.RasterPosValid;
3511 break;
3512 case GL_CURRENT_TEXTURE_COORDS:
3513 params[0] = (GLint) ctx->Current.Texcoord[texTransformUnit][0];
3514 params[1] = (GLint) ctx->Current.Texcoord[texTransformUnit][1];
3515 params[2] = (GLint) ctx->Current.Texcoord[texTransformUnit][2];
3516 params[3] = (GLint) ctx->Current.Texcoord[texTransformUnit][3];
3517 break;
3518 case GL_DEPTH_BIAS:
3519 *params = (GLint) ctx->Pixel.DepthBias;
3520 break;
3521 case GL_DEPTH_BITS:
3522 *params = ctx->Visual->DepthBits;
3523 break;
3524 case GL_DEPTH_CLEAR_VALUE:
3525 *params = (GLint) ctx->Depth.Clear;
3526 break;
3527 case GL_DEPTH_FUNC:
3528 *params = (GLint) ctx->Depth.Func;
3529 break;
3530 case GL_DEPTH_RANGE:
3531 params[0] = (GLint) ctx->Viewport.Near;
3532 params[1] = (GLint) ctx->Viewport.Far;
3533 break;
3534 case GL_DEPTH_SCALE:
3535 *params = (GLint) ctx->Pixel.DepthScale;
3536 break;
3537 case GL_DEPTH_TEST:
3538 *params = (GLint) ctx->Depth.Test;
3539 break;
3540 case GL_DEPTH_WRITEMASK:
3541 *params = (GLint) ctx->Depth.Mask;
3542 break;
3543 case GL_DITHER:
3544 *params = (GLint) ctx->Color.DitherFlag;
3545 break;
3546 case GL_DOUBLEBUFFER:
3547 *params = (GLint) ctx->Visual->DBflag;
3548 break;
3549 case GL_DRAW_BUFFER:
3550 *params = (GLint) ctx->Color.DrawBuffer;
3551 break;
3552 case GL_EDGE_FLAG:
3553 *params = (GLint) ctx->Current.EdgeFlag;
3554 break;
3555 case GL_FEEDBACK_BUFFER_SIZE:
3556 *params = ctx->Feedback.BufferSize;
3557 break;
3558 case GL_FEEDBACK_BUFFER_TYPE:
3559 *params = ctx->Feedback.Type;
3560 break;
3561 case GL_FOG:
3562 *params = (GLint) ctx->Fog.Enabled;
3563 break;
3564 case GL_FOG_COLOR:
3565 params[0] = FLOAT_TO_INT( ctx->Fog.Color[0] );
3566 params[1] = FLOAT_TO_INT( ctx->Fog.Color[1] );
3567 params[2] = FLOAT_TO_INT( ctx->Fog.Color[2] );
3568 params[3] = FLOAT_TO_INT( ctx->Fog.Color[3] );
3569 break;
3570 case GL_FOG_DENSITY:
3571 *params = (GLint) ctx->Fog.Density;
3572 break;
3573 case GL_FOG_END:
3574 *params = (GLint) ctx->Fog.End;
3575 break;
3576 case GL_FOG_HINT:
3577 *params = (GLint) ctx->Hint.Fog;
3578 break;
3579 case GL_FOG_INDEX:
3580 *params = (GLint) ctx->Fog.Index;
3581 break;
3582 case GL_FOG_MODE:
3583 *params = (GLint) ctx->Fog.Mode;
3584 break;
3585 case GL_FOG_START:
3586 *params = (GLint) ctx->Fog.Start;
3587 break;
3588 case GL_FRONT_FACE:
3589 *params = (GLint) ctx->Polygon.FrontFace;
3590 break;
3591 case GL_GREEN_BIAS:
3592 *params = (GLint) ctx->Pixel.GreenBias;
3593 break;
3594 case GL_GREEN_BITS:
3595 *params = (GLint) ctx->Visual->GreenBits;
3596 break;
3597 case GL_GREEN_SCALE:
3598 *params = (GLint) ctx->Pixel.GreenScale;
3599 break;
3600 case GL_HISTOGRAM:
3601 *params = (GLint) ctx->Pixel.HistogramEnabled;
3602 break;
3603 case GL_INDEX_BITS:
3604 *params = (GLint) ctx->Visual->IndexBits;
3605 break;
3606 case GL_INDEX_CLEAR_VALUE:
3607 *params = (GLint) ctx->Color.ClearIndex;
3608 break;
3609 case GL_INDEX_MODE:
3610 *params = ctx->Visual->RGBAflag ? 0 : 1;
3611 break;
3612 case GL_INDEX_OFFSET:
3613 *params = ctx->Pixel.IndexOffset;
3614 break;
3615 case GL_INDEX_SHIFT:
3616 *params = ctx->Pixel.IndexShift;
3617 break;
3618 case GL_INDEX_WRITEMASK:
3619 *params = (GLint) ctx->Color.IndexMask;
3620 break;
3621 case GL_LIGHT0:
3622 case GL_LIGHT1:
3623 case GL_LIGHT2:
3624 case GL_LIGHT3:
3625 case GL_LIGHT4:
3626 case GL_LIGHT5:
3627 case GL_LIGHT6:
3628 case GL_LIGHT7:
3629 *params = (GLint) ctx->Light.Light[pname-GL_LIGHT0].Enabled;
3630 break;
3631 case GL_LIGHTING:
3632 *params = (GLint) ctx->Light.Enabled;
3633 break;
3634 case GL_LIGHT_MODEL_AMBIENT:
3635 params[0] = FLOAT_TO_INT( ctx->Light.Model.Ambient[0] );
3636 params[1] = FLOAT_TO_INT( ctx->Light.Model.Ambient[1] );
3637 params[2] = FLOAT_TO_INT( ctx->Light.Model.Ambient[2] );
3638 params[3] = FLOAT_TO_INT( ctx->Light.Model.Ambient[3] );
3639 break;
3640 case GL_LIGHT_MODEL_COLOR_CONTROL:
3641 params[0] = (GLint) ctx->Light.Model.ColorControl;
3642 break;
3643 case GL_LIGHT_MODEL_LOCAL_VIEWER:
3644 *params = (GLint) ctx->Light.Model.LocalViewer;
3645 break;
3646 case GL_LIGHT_MODEL_TWO_SIDE:
3647 *params = (GLint) ctx->Light.Model.TwoSide;
3648 break;
3649 case GL_LINE_SMOOTH:
3650 *params = (GLint) ctx->Line.SmoothFlag;
3651 break;
3652 case GL_LINE_SMOOTH_HINT:
3653 *params = (GLint) ctx->Hint.LineSmooth;
3654 break;
3655 case GL_LINE_STIPPLE:
3656 *params = (GLint) ctx->Line.StippleFlag;
3657 break;
3658 case GL_LINE_STIPPLE_PATTERN:
3659 *params = (GLint) ctx->Line.StipplePattern;
3660 break;
3661 case GL_LINE_STIPPLE_REPEAT:
3662 *params = (GLint) ctx->Line.StippleFactor;
3663 break;
3664 case GL_LINE_WIDTH:
3665 *params = (GLint) ctx->Line.Width;
3666 break;
3667 case GL_LINE_WIDTH_GRANULARITY:
3668 *params = (GLint) ctx->Const.LineWidthGranularity;
3669 break;
3670 case GL_LINE_WIDTH_RANGE:
3671 params[0] = (GLint) ctx->Const.MinLineWidthAA;
3672 params[1] = (GLint) ctx->Const.MaxLineWidthAA;
3673 break;
3674 case GL_ALIASED_LINE_WIDTH_RANGE:
3675 params[0] = (GLint) ctx->Const.MinLineWidth;
3676 params[1] = (GLint) ctx->Const.MaxLineWidth;
3677 break;
3678 case GL_LIST_BASE:
3679 *params = (GLint) ctx->List.ListBase;
3680 break;
3681 case GL_LIST_INDEX:
3682 *params = (GLint) ctx->CurrentListNum;
3683 break;
3684 case GL_LIST_MODE:
3685 *params = ctx->ExecuteFlag ? (GLint) GL_COMPILE_AND_EXECUTE
3686 : (GLint) GL_COMPILE;
3687 break;
3688 case GL_INDEX_LOGIC_OP:
3689 *params = (GLint) ctx->Color.IndexLogicOpEnabled;
3690 break;
3691 case GL_COLOR_LOGIC_OP:
3692 *params = (GLint) ctx->Color.ColorLogicOpEnabled;
3693 break;
3694 case GL_LOGIC_OP_MODE:
3695 *params = (GLint) ctx->Color.LogicOp;
3696 break;
3697 case GL_MAP1_COLOR_4:
3698 *params = (GLint) ctx->Eval.Map1Color4;
3699 break;
3700 case GL_MAP1_GRID_DOMAIN:
3701 params[0] = (GLint) ctx->Eval.MapGrid1u1;
3702 params[1] = (GLint) ctx->Eval.MapGrid1u2;
3703 break;
3704 case GL_MAP1_GRID_SEGMENTS:
3705 *params = (GLint) ctx->Eval.MapGrid1un;
3706 break;
3707 case GL_MAP1_INDEX:
3708 *params = (GLint) ctx->Eval.Map1Index;
3709 break;
3710 case GL_MAP1_NORMAL:
3711 *params = (GLint) ctx->Eval.Map1Normal;
3712 break;
3713 case GL_MAP1_TEXTURE_COORD_1:
3714 *params = (GLint) ctx->Eval.Map1TextureCoord1;
3715 break;
3716 case GL_MAP1_TEXTURE_COORD_2:
3717 *params = (GLint) ctx->Eval.Map1TextureCoord2;
3718 break;
3719 case GL_MAP1_TEXTURE_COORD_3:
3720 *params = (GLint) ctx->Eval.Map1TextureCoord3;
3721 break;
3722 case GL_MAP1_TEXTURE_COORD_4:
3723 *params = (GLint) ctx->Eval.Map1TextureCoord4;
3724 break;
3725 case GL_MAP1_VERTEX_3:
3726 *params = (GLint) ctx->Eval.Map1Vertex3;
3727 break;
3728 case GL_MAP1_VERTEX_4:
3729 *params = (GLint) ctx->Eval.Map1Vertex4;
3730 break;
3731 case GL_MAP2_COLOR_4:
3732 *params = (GLint) ctx->Eval.Map2Color4;
3733 break;
3734 case GL_MAP2_GRID_DOMAIN:
3735 params[0] = (GLint) ctx->Eval.MapGrid2u1;
3736 params[1] = (GLint) ctx->Eval.MapGrid2u2;
3737 params[2] = (GLint) ctx->Eval.MapGrid2v1;
3738 params[3] = (GLint) ctx->Eval.MapGrid2v2;
3739 break;
3740 case GL_MAP2_GRID_SEGMENTS:
3741 params[0] = (GLint) ctx->Eval.MapGrid2un;
3742 params[1] = (GLint) ctx->Eval.MapGrid2vn;
3743 break;
3744 case GL_MAP2_INDEX:
3745 *params = (GLint) ctx->Eval.Map2Index;
3746 break;
3747 case GL_MAP2_NORMAL:
3748 *params = (GLint) ctx->Eval.Map2Normal;
3749 break;
3750 case GL_MAP2_TEXTURE_COORD_1:
3751 *params = (GLint) ctx->Eval.Map2TextureCoord1;
3752 break;
3753 case GL_MAP2_TEXTURE_COORD_2:
3754 *params = (GLint) ctx->Eval.Map2TextureCoord2;
3755 break;
3756 case GL_MAP2_TEXTURE_COORD_3:
3757 *params = (GLint) ctx->Eval.Map2TextureCoord3;
3758 break;
3759 case GL_MAP2_TEXTURE_COORD_4:
3760 *params = (GLint) ctx->Eval.Map2TextureCoord4;
3761 break;
3762 case GL_MAP2_VERTEX_3:
3763 *params = (GLint) ctx->Eval.Map2Vertex3;
3764 break;
3765 case GL_MAP2_VERTEX_4:
3766 *params = (GLint) ctx->Eval.Map2Vertex4;
3767 break;
3768 case GL_MAP_COLOR:
3769 *params = (GLint) ctx->Pixel.MapColorFlag;
3770 break;
3771 case GL_MAP_STENCIL:
3772 *params = (GLint) ctx->Pixel.MapStencilFlag;
3773 break;
3774 case GL_MATRIX_MODE:
3775 *params = (GLint) ctx->Transform.MatrixMode;
3776 break;
3777 case GL_MAX_ATTRIB_STACK_DEPTH:
3778 *params = (GLint) MAX_ATTRIB_STACK_DEPTH;
3779 break;
3780 case GL_MAX_CLIENT_ATTRIB_STACK_DEPTH:
3781 *params = (GLint) MAX_CLIENT_ATTRIB_STACK_DEPTH;
3782 break;
3783 case GL_MAX_CLIP_PLANES:
3784 *params = (GLint) MAX_CLIP_PLANES;
3785 break;
3786 case GL_MAX_ELEMENTS_VERTICES: /* GL_VERSION_1_2 */
3787 *params = VB_MAX;
3788 break;
3789 case GL_MAX_ELEMENTS_INDICES: /* GL_VERSION_1_2 */
3790 *params = VB_MAX;
3791 break;
3792 case GL_MAX_EVAL_ORDER:
3793 *params = (GLint) MAX_EVAL_ORDER;
3794 break;
3795 case GL_MAX_LIGHTS:
3796 *params = (GLint) MAX_LIGHTS;
3797 break;
3798 case GL_MAX_LIST_NESTING:
3799 *params = (GLint) MAX_LIST_NESTING;
3800 break;
3801 case GL_MAX_MODELVIEW_STACK_DEPTH:
3802 *params = (GLint) MAX_MODELVIEW_STACK_DEPTH;
3803 break;
3804 case GL_MAX_NAME_STACK_DEPTH:
3805 *params = (GLint) MAX_NAME_STACK_DEPTH;
3806 break;
3807 case GL_MAX_PIXEL_MAP_TABLE:
3808 *params = (GLint) MAX_PIXEL_MAP_TABLE;
3809 break;
3810 case GL_MAX_PROJECTION_STACK_DEPTH:
3811 *params = (GLint) MAX_PROJECTION_STACK_DEPTH;
3812 break;
3813 case GL_MAX_TEXTURE_SIZE:
3814 case GL_MAX_3D_TEXTURE_SIZE:
3815 *params = ctx->Const.MaxTextureSize;
3816 break;
3817 case GL_MAX_TEXTURE_STACK_DEPTH:
3818 *params = (GLint) MAX_TEXTURE_STACK_DEPTH;
3819 break;
3820 case GL_MAX_VIEWPORT_DIMS:
3821 params[0] = (GLint) MAX_WIDTH;
3822 params[1] = (GLint) MAX_HEIGHT;
3823 break;
3824 case GL_MINMAX:
3825 *params = (GLint) ctx->Pixel.MinMaxEnabled;
3826 break;
3827 case GL_MODELVIEW_MATRIX:
3828 for (i=0;i<16;i++) {
3829 params[i] = (GLint) ctx->ModelView.m[i];
3830 }
3831 break;
3832 case GL_MODELVIEW_STACK_DEPTH:
3833 *params = (GLint) (ctx->ModelViewStackDepth + 1);
3834 break;
3835 case GL_NAME_STACK_DEPTH:
3836 *params = (GLint) ctx->Select.NameStackDepth;
3837 break;
3838 case GL_NORMALIZE:
3839 *params = (GLint) ctx->Transform.Normalize;
3840 break;
3841 case GL_PACK_ALIGNMENT:
3842 *params = ctx->Pack.Alignment;
3843 break;
3844 case GL_PACK_LSB_FIRST:
3845 *params = (GLint) ctx->Pack.LsbFirst;
3846 break;
3847 case GL_PACK_ROW_LENGTH:
3848 *params = ctx->Pack.RowLength;
3849 break;
3850 case GL_PACK_SKIP_PIXELS:
3851 *params = ctx->Pack.SkipPixels;
3852 break;
3853 case GL_PACK_SKIP_ROWS:
3854 *params = ctx->Pack.SkipRows;
3855 break;
3856 case GL_PACK_SWAP_BYTES:
3857 *params = (GLint) ctx->Pack.SwapBytes;
3858 break;
3859 case GL_PACK_SKIP_IMAGES_EXT:
3860 *params = ctx->Pack.SkipImages;
3861 break;
3862 case GL_PACK_IMAGE_HEIGHT_EXT:
3863 *params = ctx->Pack.ImageHeight;
3864 break;
3865 case GL_PERSPECTIVE_CORRECTION_HINT:
3866 *params = (GLint) ctx->Hint.PerspectiveCorrection;
3867 break;
3868 case GL_PIXEL_MAP_A_TO_A_SIZE:
3869 *params = ctx->Pixel.MapAtoAsize;
3870 break;
3871 case GL_PIXEL_MAP_B_TO_B_SIZE:
3872 *params = ctx->Pixel.MapBtoBsize;
3873 break;
3874 case GL_PIXEL_MAP_G_TO_G_SIZE:
3875 *params = ctx->Pixel.MapGtoGsize;
3876 break;
3877 case GL_PIXEL_MAP_I_TO_A_SIZE:
3878 *params = ctx->Pixel.MapItoAsize;
3879 break;
3880 case GL_PIXEL_MAP_I_TO_B_SIZE:
3881 *params = ctx->Pixel.MapItoBsize;
3882 break;
3883 case GL_PIXEL_MAP_I_TO_G_SIZE:
3884 *params = ctx->Pixel.MapItoGsize;
3885 break;
3886 case GL_PIXEL_MAP_I_TO_I_SIZE:
3887 *params = ctx->Pixel.MapItoIsize;
3888 break;
3889 case GL_PIXEL_MAP_I_TO_R_SIZE:
3890 *params = ctx->Pixel.MapItoRsize;
3891 break;
3892 case GL_PIXEL_MAP_R_TO_R_SIZE:
3893 *params = ctx->Pixel.MapRtoRsize;
3894 break;
3895 case GL_PIXEL_MAP_S_TO_S_SIZE:
3896 *params = ctx->Pixel.MapStoSsize;
3897 break;
3898 case GL_POINT_SIZE:
3899 *params = (GLint) ctx->Point.UserSize;
3900 break;
3901 case GL_POINT_SIZE_GRANULARITY:
3902 *params = (GLint) ctx->Const.PointSizeGranularity;
3903 break;
3904 case GL_POINT_SIZE_RANGE:
3905 params[0] = (GLint) ctx->Const.MinPointSizeAA;
3906 params[1] = (GLint) ctx->Const.MaxPointSizeAA;
3907 break;
3908 case GL_ALIASED_POINT_SIZE_RANGE:
3909 params[0] = (GLint) ctx->Const.MinPointSize;
3910 params[1] = (GLint) ctx->Const.MaxPointSize;
3911 break;
3912 case GL_POINT_SMOOTH:
3913 *params = (GLint) ctx->Point.SmoothFlag;
3914 break;
3915 case GL_POINT_SMOOTH_HINT:
3916 *params = (GLint) ctx->Hint.PointSmooth;
3917 break;
3918 case GL_POINT_SIZE_MIN_EXT:
3919 *params = (GLint) (ctx->Point.MinSize);
3920 break;
3921 case GL_POINT_SIZE_MAX_EXT:
3922 *params = (GLint) (ctx->Point.MaxSize);
3923 break;
3924 case GL_POINT_FADE_THRESHOLD_SIZE_EXT:
3925 *params = (GLint) (ctx->Point.Threshold);
3926 break;
3927 case GL_DISTANCE_ATTENUATION_EXT:
3928 params[0] = (GLint) (ctx->Point.Params[0]);
3929 params[1] = (GLint) (ctx->Point.Params[1]);
3930 params[2] = (GLint) (ctx->Point.Params[2]);
3931 break;
3932 case GL_POLYGON_MODE:
3933 params[0] = (GLint) ctx->Polygon.FrontMode;
3934 params[1] = (GLint) ctx->Polygon.BackMode;
3935 break;
3936 case GL_POLYGON_OFFSET_BIAS_EXT: /* GL_EXT_polygon_offset */
3937 *params = (GLint) ctx->Polygon.OffsetUnits;
3938 break;
3939 case GL_POLYGON_OFFSET_FACTOR:
3940 *params = (GLint) ctx->Polygon.OffsetFactor;
3941 break;
3942 case GL_POLYGON_OFFSET_UNITS:
3943 *params = (GLint) ctx->Polygon.OffsetUnits;
3944 break;
3945 case GL_POLYGON_SMOOTH:
3946 *params = (GLint) ctx->Polygon.SmoothFlag;
3947 break;
3948 case GL_POLYGON_SMOOTH_HINT:
3949 *params = (GLint) ctx->Hint.PolygonSmooth;
3950 break;
3951 case GL_POLYGON_STIPPLE:
3952 *params = (GLint) ctx->Polygon.StippleFlag;
3953 break;
3954 case GL_PROJECTION_MATRIX:
3955 for (i=0;i<16;i++) {
3956 params[i] = (GLint) ctx->ProjectionMatrix.m[i];
3957 }
3958 break;
3959 case GL_PROJECTION_STACK_DEPTH:
3960 *params = (GLint) (ctx->ProjectionStackDepth + 1);
3961 break;
3962 case GL_READ_BUFFER:
3963 *params = (GLint) ctx->Pixel.ReadBuffer;
3964 break;
3965 case GL_RED_BIAS:
3966 *params = (GLint) ctx->Pixel.RedBias;
3967 break;
3968 case GL_RED_BITS:
3969 *params = (GLint) ctx->Visual->RedBits;
3970 break;
3971 case GL_RED_SCALE:
3972 *params = (GLint) ctx->Pixel.RedScale;
3973 break;
3974 case GL_RENDER_MODE:
3975 *params = (GLint) ctx->RenderMode;
3976 break;
3977 case GL_RGBA_MODE:
3978 *params = (GLint) ctx->Visual->RGBAflag;
3979 break;
3980 case GL_SCISSOR_BOX:
3981 params[0] = (GLint) ctx->Scissor.X;
3982 params[1] = (GLint) ctx->Scissor.Y;
3983 params[2] = (GLint) ctx->Scissor.Width;
3984 params[3] = (GLint) ctx->Scissor.Height;
3985 break;
3986 case GL_SCISSOR_TEST:
3987 *params = (GLint) ctx->Scissor.Enabled;
3988 break;
3989 case GL_SELECTION_BUFFER_SIZE:
3990 *params = (GLint) ctx->Select.BufferSize;
3991 break;
3992 case GL_SHADE_MODEL:
3993 *params = (GLint) ctx->Light.ShadeModel;
3994 break;
3995 case GL_SHARED_TEXTURE_PALETTE_EXT:
3996 *params = (GLint) ctx->Texture.SharedPalette;
3997 break;
3998 case GL_STENCIL_BITS:
3999 *params = ctx->Visual->StencilBits;
4000 break;
4001 case GL_STENCIL_CLEAR_VALUE:
4002 *params = (GLint) ctx->Stencil.Clear;
4003 break;
4004 case GL_STENCIL_FAIL:
4005 *params = (GLint) ctx->Stencil.FailFunc;
4006 break;
4007 case GL_STENCIL_FUNC:
4008 *params = (GLint) ctx->Stencil.Function;
4009 break;
4010 case GL_STENCIL_PASS_DEPTH_FAIL:
4011 *params = (GLint) ctx->Stencil.ZFailFunc;
4012 break;
4013 case GL_STENCIL_PASS_DEPTH_PASS:
4014 *params = (GLint) ctx->Stencil.ZPassFunc;
4015 break;
4016 case GL_STENCIL_REF:
4017 *params = (GLint) ctx->Stencil.Ref;
4018 break;
4019 case GL_STENCIL_TEST:
4020 *params = (GLint) ctx->Stencil.Enabled;
4021 break;
4022 case GL_STENCIL_VALUE_MASK:
4023 *params = (GLint) ctx->Stencil.ValueMask;
4024 break;
4025 case GL_STENCIL_WRITEMASK:
4026 *params = (GLint) ctx->Stencil.WriteMask;
4027 break;
4028 case GL_STEREO:
4029 *params = (GLint) ctx->Visual->StereoFlag;
4030 break;
4031 case GL_SUBPIXEL_BITS:
4032 *params = ctx->Const.SubPixelBits;
4033 break;
4034 case GL_TEXTURE_1D:
4035 *params = _mesa_IsEnabled(GL_TEXTURE_1D) ? 1 : 0;
4036 break;
4037 case GL_TEXTURE_2D:
4038 *params = _mesa_IsEnabled(GL_TEXTURE_2D) ? 1 : 0;
4039 break;
4040 case GL_TEXTURE_3D:
4041 *params = _mesa_IsEnabled(GL_TEXTURE_3D) ? 1 : 0;
4042 break;
4043 case GL_TEXTURE_BINDING_1D:
4044 *params = textureUnit->CurrentD[1]->Name;
4045 break;
4046 case GL_TEXTURE_BINDING_2D:
4047 *params = textureUnit->CurrentD[2]->Name;
4048 break;
4049 case GL_TEXTURE_BINDING_3D:
4050 *params = textureUnit->CurrentD[3]->Name;
4051 break;
4052 case GL_TEXTURE_ENV_COLOR:
4053 params[0] = FLOAT_TO_INT( textureUnit->EnvColor[0] );
4054 params[1] = FLOAT_TO_INT( textureUnit->EnvColor[1] );
4055 params[2] = FLOAT_TO_INT( textureUnit->EnvColor[2] );
4056 params[3] = FLOAT_TO_INT( textureUnit->EnvColor[3] );
4057 break;
4058 case GL_TEXTURE_ENV_MODE:
4059 *params = (GLint) textureUnit->EnvMode;
4060 break;
4061 case GL_TEXTURE_GEN_S:
4062 *params = (textureUnit->TexGenEnabled & S_BIT) ? 1 : 0;
4063 break;
4064 case GL_TEXTURE_GEN_T:
4065 *params = (textureUnit->TexGenEnabled & T_BIT) ? 1 : 0;
4066 break;
4067 case GL_TEXTURE_GEN_R:
4068 *params = (textureUnit->TexGenEnabled & R_BIT) ? 1 : 0;
4069 break;
4070 case GL_TEXTURE_GEN_Q:
4071 *params = (textureUnit->TexGenEnabled & Q_BIT) ? 1 : 0;
4072 break;
4073 case GL_TEXTURE_MATRIX:
4074 for (i=0;i<16;i++) {
4075 params[i] = (GLint) ctx->TextureMatrix[texTransformUnit].m[i];
4076 }
4077 break;
4078 case GL_TEXTURE_STACK_DEPTH:
4079 *params = (GLint) (ctx->TextureStackDepth[texTransformUnit] + 1);
4080 break;
4081 case GL_UNPACK_ALIGNMENT:
4082 *params = ctx->Unpack.Alignment;
4083 break;
4084 case GL_UNPACK_LSB_FIRST:
4085 *params = (GLint) ctx->Unpack.LsbFirst;
4086 break;
4087 case GL_UNPACK_ROW_LENGTH:
4088 *params = ctx->Unpack.RowLength;
4089 break;
4090 case GL_UNPACK_SKIP_PIXELS:
4091 *params = ctx->Unpack.SkipPixels;
4092 break;
4093 case GL_UNPACK_SKIP_ROWS:
4094 *params = ctx->Unpack.SkipRows;
4095 break;
4096 case GL_UNPACK_SWAP_BYTES:
4097 *params = (GLint) ctx->Unpack.SwapBytes;
4098 break;
4099 case GL_UNPACK_SKIP_IMAGES_EXT:
4100 *params = ctx->Unpack.SkipImages;
4101 break;
4102 case GL_UNPACK_IMAGE_HEIGHT_EXT:
4103 *params = ctx->Unpack.ImageHeight;
4104 break;
4105 case GL_VIEWPORT:
4106 params[0] = (GLint) ctx->Viewport.X;
4107 params[1] = (GLint) ctx->Viewport.Y;
4108 params[2] = (GLint) ctx->Viewport.Width;
4109 params[3] = (GLint) ctx->Viewport.Height;
4110 break;
4111 case GL_ZOOM_X:
4112 *params = (GLint) ctx->Pixel.ZoomX;
4113 break;
4114 case GL_ZOOM_Y:
4115 *params = (GLint) ctx->Pixel.ZoomY;
4116 break;
4117 case GL_VERTEX_ARRAY:
4118 *params = (GLint) ctx->Array.Vertex.Enabled;
4119 break;
4120 case GL_VERTEX_ARRAY_SIZE:
4121 *params = ctx->Array.Vertex.Size;
4122 break;
4123 case GL_VERTEX_ARRAY_TYPE:
4124 *params = ctx->Array.Vertex.Type;
4125 break;
4126 case GL_VERTEX_ARRAY_STRIDE:
4127 *params = ctx->Array.Vertex.Stride;
4128 break;
4129 case GL_VERTEX_ARRAY_COUNT_EXT:
4130 *params = 0;
4131 break;
4132 case GL_NORMAL_ARRAY:
4133 *params = (GLint) ctx->Array.Normal.Enabled;
4134 break;
4135 case GL_NORMAL_ARRAY_TYPE:
4136 *params = ctx->Array.Normal.Type;
4137 break;
4138 case GL_NORMAL_ARRAY_STRIDE:
4139 *params = ctx->Array.Normal.Stride;
4140 break;
4141 case GL_NORMAL_ARRAY_COUNT_EXT:
4142 *params = 0;
4143 break;
4144 case GL_COLOR_ARRAY:
4145 *params = (GLint) ctx->Array.Color.Enabled;
4146 break;
4147 case GL_COLOR_ARRAY_SIZE:
4148 *params = ctx->Array.Color.Size;
4149 break;
4150 case GL_COLOR_ARRAY_TYPE:
4151 *params = ctx->Array.Color.Type;
4152 break;
4153 case GL_COLOR_ARRAY_STRIDE:
4154 *params = ctx->Array.Color.Stride;
4155 break;
4156 case GL_COLOR_ARRAY_COUNT_EXT:
4157 *params = 0;
4158 break;
4159 case GL_INDEX_ARRAY:
4160 *params = (GLint) ctx->Array.Index.Enabled;
4161 break;
4162 case GL_INDEX_ARRAY_TYPE:
4163 *params = ctx->Array.Index.Type;
4164 break;
4165 case GL_INDEX_ARRAY_STRIDE:
4166 *params = ctx->Array.Index.Stride;
4167 break;
4168 case GL_INDEX_ARRAY_COUNT_EXT:
4169 *params = 0;
4170 break;
4171 case GL_TEXTURE_COORD_ARRAY:
4172 *params = (GLint) ctx->Array.TexCoord[texUnit].Enabled;
4173 break;
4174 case GL_TEXTURE_COORD_ARRAY_SIZE:
4175 *params = ctx->Array.TexCoord[texUnit].Size;
4176 break;
4177 case GL_TEXTURE_COORD_ARRAY_TYPE:
4178 *params = ctx->Array.TexCoord[texUnit].Type;
4179 break;
4180 case GL_TEXTURE_COORD_ARRAY_STRIDE:
4181 *params = ctx->Array.TexCoord[texUnit].Stride;
4182 break;
4183 case GL_TEXTURE_COORD_ARRAY_COUNT_EXT:
4184 *params = 0;
4185 break;
4186 case GL_EDGE_FLAG_ARRAY:
4187 *params = (GLint) ctx->Array.EdgeFlag.Enabled;
4188 break;
4189 case GL_EDGE_FLAG_ARRAY_STRIDE:
4190 *params = ctx->Array.EdgeFlag.Stride;
4191 break;
4192 case GL_EDGE_FLAG_ARRAY_COUNT_EXT:
4193 *params = 0;
4194 break;
4195
4196 case GL_MAX_TEXTURE_UNITS_ARB:
4197 *params = ctx->Const.MaxTextureUnits;
4198 break;
4199 case GL_ACTIVE_TEXTURE_ARB:
4200 *params = GL_TEXTURE0_ARB + ctx->Texture.CurrentUnit;
4201 break;
4202 case GL_CLIENT_ACTIVE_TEXTURE_ARB:
4203 *params = GL_TEXTURE0_ARB + ctx->Array.ActiveTexture;
4204 break;
4205
4206 /* GL_PGI_misc_hints */
4207 case GL_STRICT_DEPTHFUNC_HINT_PGI:
4208 *params = (GL_NICEST);
4209 break;
4210 case GL_STRICT_LIGHTING_HINT_PGI:
4211 *params = (ctx->Hint.StrictLighting);
4212 break;
4213 case GL_STRICT_SCISSOR_HINT_PGI:
4214 case GL_FULL_STIPPLE_HINT_PGI:
4215 *params = (GL_TRUE);
4216 break;
4217 case GL_CONSERVE_MEMORY_HINT_PGI:
4218 *params = (GL_FALSE);
4219 break;
4220 case GL_ALWAYS_FAST_HINT_PGI:
4221 *params = (ctx->Hint.AllowDrawWin == GL_TRUE &&
4222 ctx->Hint.AllowDrawFrg == GL_FALSE &&
4223 ctx->Hint.AllowDrawMem == GL_FALSE);
4224 break;
4225 case GL_ALWAYS_SOFT_HINT_PGI:
4226 *params = (ctx->Hint.AllowDrawWin == GL_TRUE &&
4227 ctx->Hint.AllowDrawFrg == GL_TRUE &&
4228 ctx->Hint.AllowDrawMem == GL_TRUE);
4229 break;
4230 case GL_ALLOW_DRAW_OBJ_HINT_PGI:
4231 *params = GL_TRUE;
4232 break;
4233 case GL_ALLOW_DRAW_WIN_HINT_PGI:
4234 *params = ctx->Hint.AllowDrawWin;
4235 break;
4236 case GL_ALLOW_DRAW_FRG_HINT_PGI:
4237 *params = ctx->Hint.AllowDrawFrg;
4238 break;
4239 case GL_ALLOW_DRAW_MEM_HINT_PGI:
4240 *params = ctx->Hint.AllowDrawMem;
4241 break;
4242 case GL_CLIP_NEAR_HINT_PGI:
4243 case GL_CLIP_FAR_HINT_PGI:
4244 *params = GL_TRUE;
4245 break;
4246 case GL_WIDE_LINE_HINT_PGI:
4247 *params = GL_DONT_CARE;
4248 break;
4249 case GL_BACK_NORMALS_HINT_PGI:
4250 *params = (GL_TRUE);
4251 break;
4252 case GL_NATIVE_GRAPHICS_HANDLE_PGI:
4253 *params = 0;
4254 break;
4255
4256 /* GL_EXT_compiled_vertex_array */
4257 case GL_ARRAY_ELEMENT_LOCK_FIRST_EXT:
4258 *params = ctx->Array.LockFirst;
4259 break;
4260 case GL_ARRAY_ELEMENT_LOCK_COUNT_EXT:
4261 *params = ctx->Array.LockCount;
4262 break;
4263
4264 /* GL_ARB_transpose_matrix */
4265 case GL_TRANSPOSE_COLOR_MATRIX_ARB:
4266 /* don't have a color matrix */
4267 break;
4268 case GL_TRANSPOSE_MODELVIEW_MATRIX_ARB:
4269 {
4270 GLfloat tm[16];
4271 GLuint i;
4272 gl_matrix_transposef(tm, ctx->ModelView.m);
4273 for (i=0;i<16;i++) {
4274 params[i] = (GLint) tm[i];
4275 }
4276 }
4277 break;
4278 case GL_TRANSPOSE_PROJECTION_MATRIX_ARB:
4279 {
4280 GLfloat tm[16];
4281 GLuint i;
4282 gl_matrix_transposef(tm, ctx->ProjectionMatrix.m);
4283 for (i=0;i<16;i++) {
4284 params[i] = (GLint) tm[i];
4285 }
4286 }
4287 break;
4288 case GL_TRANSPOSE_TEXTURE_MATRIX_ARB:
4289 {
4290 GLfloat tm[16];
4291 GLuint i;
4292 gl_matrix_transposef(tm, ctx->TextureMatrix[texTransformUnit].m);
4293 for (i=0;i<16;i++) {
4294 params[i] = (GLint) tm[i];
4295 }
4296 }
4297 break;
4298
4299 /* GL_HP_occlusion_test */
4300 case GL_OCCLUSION_TEST_HP:
4301 if (ctx->Extensions.HaveHpOcclusionTest) {
4302 *params = (GLint) ctx->Depth.OcclusionTest;
4303 }
4304 else {
4305 gl_error( ctx, GL_INVALID_ENUM, "glGetIntegerv" );
4306 }
4307 return;
4308 case GL_OCCLUSION_TEST_RESULT_HP:
4309 if (ctx->Extensions.HaveHpOcclusionTest) {
4310 if (ctx->Depth.OcclusionTest)
4311 *params = (GLint) ctx->OcclusionResult;
4312 else
4313 *params = (GLint) ctx->OcclusionResultSaved;
4314 /* reset flag now */
4315 ctx->OcclusionResult = GL_FALSE;
4316 ctx->OcclusionResultSaved = GL_FALSE;
4317 }
4318 else {
4319 gl_error( ctx, GL_INVALID_ENUM, "glGetIntegerv" );
4320 }
4321 return;
4322
4323 /* GL_SGIS_pixel_texture */
4324 case GL_PIXEL_TEXTURE_SGIS:
4325 *params = (GLint) ctx->Pixel.PixelTextureEnabled;
4326 break;
4327
4328 /* GL_SGIX_pixel_texture */
4329 case GL_PIXEL_TEX_GEN_SGIX:
4330 *params = (GLint) ctx->Pixel.PixelTextureEnabled;
4331 break;
4332 case GL_PIXEL_TEX_GEN_MODE_SGIX:
4333 *params = (GLint) pixel_texgen_mode(ctx);
4334 break;
4335
4336 /* GL_SGI_color_matrix (also in 1.2 imaging) */
4337 case GL_COLOR_MATRIX_SGI:
4338 for (i=0;i<16;i++) {
4339 params[i] = (GLint) ctx->ColorMatrix.m[i];
4340 }
4341 break;
4342 case GL_COLOR_MATRIX_STACK_DEPTH_SGI:
4343 *params = ctx->ColorStackDepth + 1;
4344 break;
4345 case GL_MAX_COLOR_MATRIX_STACK_DEPTH_SGI:
4346 *params = MAX_COLOR_STACK_DEPTH;
4347 break;
4348 case GL_POST_COLOR_MATRIX_RED_SCALE_SGI:
4349 *params = (GLint) ctx->Pixel.PostColorMatrixScale[0];
4350 break;
4351 case GL_POST_COLOR_MATRIX_GREEN_SCALE_SGI:
4352 *params = (GLint) ctx->Pixel.PostColorMatrixScale[1];
4353 break;
4354 case GL_POST_COLOR_MATRIX_BLUE_SCALE_SGI:
4355 *params = (GLint) ctx->Pixel.PostColorMatrixScale[2];
4356 break;
4357 case GL_POST_COLOR_MATRIX_ALPHA_SCALE_SGI:
4358 *params = (GLint) ctx->Pixel.PostColorMatrixScale[3];
4359 break;
4360 case GL_POST_COLOR_MATRIX_RED_BIAS_SGI:
4361 *params = (GLint) ctx->Pixel.PostColorMatrixBias[0];
4362 break;
4363 case GL_POST_COLOR_MATRIX_GREEN_BIAS_SGI:
4364 *params = (GLint) ctx->Pixel.PostColorMatrixBias[1];
4365 break;
4366 case GL_POST_COLOR_MATRIX_BLUE_BIAS_SGI:
4367 *params = (GLint) ctx->Pixel.PostColorMatrixBias[2];
4368 break;
4369 case GL_POST_COLOR_MATRIX_ALPHA_BIAS_SGI:
4370 *params = (GLint) ctx->Pixel.PostColorMatrixBias[3];
4371 break;
4372
4373 /* GL_EXT_convolution (also in 1.2 imaging) */
4374 case GL_MAX_CONVOLUTION_WIDTH:
4375 *params = ctx->Const.MaxConvolutionWidth;
4376 break;
4377 case GL_MAX_CONVOLUTION_HEIGHT:
4378 *params = ctx->Const.MaxConvolutionHeight;
4379 break;
4380 case GL_POST_CONVOLUTION_RED_SCALE_EXT:
4381 *params = (GLint) ctx->Pixel.PostConvolutionScale[0];
4382 break;
4383 case GL_POST_CONVOLUTION_GREEN_SCALE_EXT:
4384 *params = (GLint) ctx->Pixel.PostConvolutionScale[1];
4385 break;
4386 case GL_POST_CONVOLUTION_BLUE_SCALE_EXT:
4387 *params = (GLint) ctx->Pixel.PostConvolutionScale[2];
4388 break;
4389 case GL_POST_CONVOLUTION_ALPHA_SCALE_EXT:
4390 *params = (GLint) ctx->Pixel.PostConvolutionScale[3];
4391 break;
4392 case GL_POST_CONVOLUTION_RED_BIAS_EXT:
4393 *params = (GLint) ctx->Pixel.PostConvolutionBias[0];
4394 break;
4395 case GL_POST_CONVOLUTION_GREEN_BIAS_EXT:
4396 *params = (GLint) ctx->Pixel.PostConvolutionBias[1];
4397 break;
4398 case GL_POST_CONVOLUTION_BLUE_BIAS_EXT:
4399 *params = (GLint) ctx->Pixel.PostConvolutionBias[2];
4400 break;
4401 case GL_POST_CONVOLUTION_ALPHA_BIAS_EXT:
4402 *params = (GLint) ctx->Pixel.PostConvolutionBias[2];
4403 break;
4404
4405 /* GL_SGI_color_table (also in 1.2 imaging */
4406 case GL_COLOR_TABLE_SGI:
4407 *params = (GLint) ctx->Pixel.ColorTableEnabled;
4408 break;
4409 case GL_POST_CONVOLUTION_COLOR_TABLE_SGI:
4410 *params = (GLint) ctx->Pixel.PostConvolutionColorTableEnabled;
4411 break;
4412 case GL_POST_COLOR_MATRIX_COLOR_TABLE_SGI:
4413 *params = (GLint) ctx->Pixel.PostColorMatrixColorTableEnabled;
4414 break;
4415
4416 default:
4417 gl_error( ctx, GL_INVALID_ENUM, "glGetIntegerv" );
4418 }
4419 }
4420
4421
4422
4423 void
4424 _mesa_GetPointerv( GLenum pname, GLvoid **params )
4425 {
4426 GET_CURRENT_CONTEXT(ctx);
4427 GLuint texUnit = ctx->Texture.CurrentUnit;
4428 /*GLuint texTransformUnit = ctx->Texture.CurrentTransformUnit;*/
4429
4430 if (MESA_VERBOSE & VERBOSE_API)
4431 fprintf(stderr, "glGetPointerv %s\n", gl_lookup_enum_by_nr(pname));
4432
4433 switch (pname) {
4434 case GL_VERTEX_ARRAY_POINTER:
4435 *params = ctx->Array.Vertex.Ptr;
4436 break;
4437 case GL_NORMAL_ARRAY_POINTER:
4438 *params = ctx->Array.Normal.Ptr;
4439 break;
4440 case GL_COLOR_ARRAY_POINTER:
4441 *params = ctx->Array.Color.Ptr;
4442 break;
4443 case GL_INDEX_ARRAY_POINTER:
4444 *params = ctx->Array.Index.Ptr;
4445 break;
4446 case GL_TEXTURE_COORD_ARRAY_POINTER:
4447 *params = ctx->Array.TexCoord[texUnit].Ptr;
4448 break;
4449 case GL_EDGE_FLAG_ARRAY_POINTER:
4450 *params = ctx->Array.EdgeFlag.Ptr;
4451 break;
4452 case GL_FEEDBACK_BUFFER_POINTER:
4453 *params = ctx->Feedback.Buffer;
4454 break;
4455 case GL_SELECTION_BUFFER_POINTER:
4456 *params = ctx->Select.Buffer;
4457 break;
4458 default:
4459 gl_error( ctx, GL_INVALID_ENUM, "glGetPointerv" );
4460 return;
4461 }
4462 }
4463
4464
4465
4466 const GLubyte *
4467 _mesa_GetString( GLenum name )
4468 {
4469 GET_CURRENT_CONTEXT(ctx);
4470 static char *vendor = "Brian Paul";
4471 static char *renderer = "Mesa";
4472 static char *version = "1.2 Mesa 3.3 beta";
4473
4474 ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH_WITH_RETVAL(ctx, "glGetString", 0);
4475
4476 /* this is a required driver function */
4477 assert(ctx->Driver.GetString);
4478 {
4479 const GLubyte *str = (*ctx->Driver.GetString)(ctx, name);
4480 if (str)
4481 return str;
4482
4483 switch (name) {
4484 case GL_VENDOR:
4485 return (const GLubyte *) vendor;
4486 case GL_RENDERER:
4487 return (const GLubyte *) renderer;
4488 case GL_VERSION:
4489 return (const GLubyte *) version;
4490 case GL_EXTENSIONS:
4491 return (GLubyte *) gl_extensions_get_string( ctx );
4492 default:
4493 gl_error( ctx, GL_INVALID_ENUM, "glGetString" );
4494 return (GLubyte *) 0;
4495 }
4496 }
4497 }
4498
4499
4500 /*
4501 * Execute a glGetError command
4502 */
4503 GLenum
4504 _mesa_GetError( void )
4505 {
4506 GET_CURRENT_CONTEXT(ctx);
4507
4508 GLenum e = ctx->ErrorValue;
4509
4510 ASSERT_OUTSIDE_BEGIN_END_WITH_RETVAL( ctx, "glGetError", (GLenum) 0);
4511
4512 if (MESA_VERBOSE & VERBOSE_API)
4513 fprintf(stderr, "glGetError <-- %s\n", gl_lookup_enum_by_nr(e));
4514
4515 ctx->ErrorValue = (GLenum) GL_NO_ERROR;
4516 return e;
4517 }
4518