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