projects / mesa.git / blob
? search:


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