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