projects / mesa.git / blob
? search:


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