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