projects / reactos.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
[CRT] Remove useless #undef abort from process.h
[reactos.git] / dll / opengl / mesa / get.c
1 /* $Id: get.c,v 1.19 1998/02/04 05:00:28 brianp Exp $ */
2
3 /*
4 * Mesa 3-D graphics library
5 * Version: 2.6
6 * Copyright (C) 1995-1997 Brian Paul
7 *
8 * This library is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU Library General Public
10 * License as published by the Free Software Foundation; either
11 * version 2 of the License, or (at your option) any later version.
12 *
13 * This library is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 * Library General Public License for more details.
17 *
18 * You should have received a copy of the GNU Library General Public
19 * License along with this library; if not, write to the Free
20 * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
21 */
22
23
24 /*
25 * $Log: get.c,v $
26 * Revision 1.19 1998/02/04 05:00:28 brianp
27 * more casts for Amiga StormC
28 *
29 * Revision 1.18 1998/02/03 23:45:02 brianp
30 * added casts to prevent warnings with Amiga StormC compiler
31 *
32 * Revision 1.17 1997/12/06 18:06:50 brianp
33 * moved several static display list vars into GLcontext
34 *
35 * Revision 1.16 1997/10/29 01:29:09 brianp
36 * added GL_EXT_point_parameters extension from Daniel Barrero
37 *
38 * Revision 1.15 1997/10/16 01:59:08 brianp
39 * added GL_EXT_shared_texture_palette extension
40 *
41 * Revision 1.14 1997/07/24 01:25:18 brianp
42 * changed precompiled header symbol from PCH to PC_HEADER
43 *
44 * Revision 1.13 1997/06/20 02:00:27 brianp
45 * replaced Current.IntColor with Current.ByteColor
46 *
47 * Revision 1.12 1997/05/28 03:24:54 brianp
48 * added precompiled header (PCH) support
49 *
50 * Revision 1.11 1997/05/26 21:13:42 brianp
51 * rewrite code for GL_RED/GREEN/BLUE/ALPHA_BITS
52 *
53 * Revision 1.10 1997/04/26 04:33:11 brianp
54 * glGet(accum, stencil, depth bits) always returned non-zero values- wrong
55 *
56 * Revision 1.9 1997/03/11 00:57:38 brianp
57 * removed redundant GL_POLYGON_OFFSET_FACTOR_EXT cases
58 *
59 * Revision 1.8 1997/02/10 21:15:59 brianp
60 * renamed GL_TEXTURE_BINDING_3D_EXT to GL_TEXTURE_3D_BINDING_EXT
61 *
62 * Revision 1.7 1997/02/09 19:53:43 brianp
63 * now use TEXTURE_xD enable constants
64 *
65 * Revision 1.6 1997/02/09 18:49:23 brianp
66 * added GL_EXT_texture3D support
67 *
68 * Revision 1.5 1997/01/30 21:05:20 brianp
69 * moved in gl_GetPointerv() from varray.c
70 * added some missing GLenums to the glGet*() functions
71 *
72 * Revision 1.4 1997/01/28 22:13:42 brianp
73 * now there's separate state for CI and RGBA logic op enabled
74 *
75 * Revision 1.3 1996/10/11 03:43:34 brianp
76 * replaced old texture _EXT symbols
77 * added GL_EXT_polygon_offset stuff
78 *
79 * Revision 1.2 1996/09/15 14:17:30 brianp
80 * now use GLframebuffer and GLvisual
81 *
82 * Revision 1.1 1996/09/13 01:38:16 brianp
83 * Initial revision
84 *
85 */
86
87
88 #ifdef PC_HEADER
89 #include "all.h"
90 #else
91 #include <string.h>
92 #include "context.h"
93 #include "get.h"
94 #include "dlist.h"
95 #include "macros.h"
96 #include "types.h"
97 #endif
98
99
100
101 #define FLOAT_TO_BOOL(X) ( (X)==0.0F ? GL_FALSE : GL_TRUE )
102 #define INT_TO_BOOL(I) ( (I)==0 ? GL_FALSE : GL_TRUE )
103 #define ENUM_TO_BOOL(E) ( (E)==0 ? GL_FALSE : GL_TRUE )
104
105 #ifdef SPECIALCAST
106 /* Needed for an Amiga compiler */
107 #define ENUM_TO_FLOAT(X) ((GLfloat)(GLint)(X))
108 #define ENUM_TO_DOUBLE(X) ((GLdouble)(GLint)(X))
109 #else
110 /* all other compilers */
111 #define ENUM_TO_FLOAT(X) ((GLfloat)(X))
112 #define ENUM_TO_DOUBLE(X) ((GLdouble)(X))
113 #endif
114
115
116
117 void gl_GetBooleanv( GLcontext *ctx, GLenum pname, GLboolean *params )
118 {
119 GLuint i;
120
121 if (INSIDE_BEGIN_END(ctx)) {
122 gl_error( ctx, GL_INVALID_OPERATION, "glGetBooleanv" );
123 return;
124 }
125
126 switch (pname) {
127 case GL_ACCUM_RED_BITS:
128 case GL_ACCUM_GREEN_BITS:
129 case GL_ACCUM_BLUE_BITS:
130 case GL_ACCUM_ALPHA_BITS:
131 *params = INT_TO_BOOL(ctx->Visual->AccumBits);
132 break;
133 case GL_ACCUM_CLEAR_VALUE:
134 params[0] = FLOAT_TO_BOOL(ctx->Accum.ClearColor[0]);
135 params[1] = FLOAT_TO_BOOL(ctx->Accum.ClearColor[1]);
136 params[2] = FLOAT_TO_BOOL(ctx->Accum.ClearColor[2]);
137 params[3] = FLOAT_TO_BOOL(ctx->Accum.ClearColor[3]);
138 break;
139 case GL_ALPHA_BIAS:
140 *params = FLOAT_TO_BOOL(ctx->Pixel.AlphaBias);
141 break;
142 case GL_ALPHA_BITS:
143 *params = INT_TO_BOOL(ctx->Visual->AlphaBits);
144 break;
145 case GL_ALPHA_SCALE:
146 *params = FLOAT_TO_BOOL(ctx->Pixel.AlphaScale);
147 break;
148 case GL_ALPHA_TEST:
149 *params = ctx->Color.AlphaEnabled;
150 break;
151 case GL_ALPHA_TEST_FUNC:
152 *params = ENUM_TO_BOOL(ctx->Color.AlphaFunc);
153 break;
154 case GL_ALPHA_TEST_REF:
155 *params = FLOAT_TO_BOOL(ctx->Color.AlphaRef);
156 break;
157 case GL_ATTRIB_STACK_DEPTH:
158 *params = INT_TO_BOOL(ctx->AttribStackDepth);
159 break;
160 case GL_AUTO_NORMAL:
161 *params = ctx->Eval.AutoNormal;
162 break;
163 case GL_AUX_BUFFERS:
164 *params = (NUM_AUX_BUFFERS) ? GL_TRUE : GL_FALSE;
165 break;
166 case GL_BLEND:
167 *params = ctx->Color.BlendEnabled;
168 break;
169 case GL_BLEND_DST:
170 *params = ENUM_TO_BOOL(ctx->Color.BlendDst);
171 break;
172 case GL_BLEND_SRC:
173 *params = ENUM_TO_BOOL(ctx->Color.BlendSrc);
174 break;
175 case GL_BLUE_BIAS:
176 *params = FLOAT_TO_BOOL(ctx->Pixel.BlueBias);
177 break;
178 case GL_BLUE_BITS:
179 *params = INT_TO_BOOL( ctx->Visual->BlueBits );
180 break;
181 case GL_BLUE_SCALE:
182 *params = FLOAT_TO_BOOL(ctx->Pixel.BlueScale);
183 break;
184 case GL_CLIENT_ATTRIB_STACK_DEPTH:
185 *params = INT_TO_BOOL(ctx->ClientAttribStackDepth);
186 break;
187 case GL_CLIP_PLANE0:
188 case GL_CLIP_PLANE1:
189 case GL_CLIP_PLANE2:
190 case GL_CLIP_PLANE3:
191 case GL_CLIP_PLANE4:
192 case GL_CLIP_PLANE5:
193 *params = ctx->Transform.ClipEnabled[pname-GL_CLIP_PLANE0];
194 break;
195 case GL_COLOR_CLEAR_VALUE:
196 params[0] = FLOAT_TO_BOOL(ctx->Color.ClearColor[0]);
197 params[1] = FLOAT_TO_BOOL(ctx->Color.ClearColor[1]);
198 params[2] = FLOAT_TO_BOOL(ctx->Color.ClearColor[2]);
199 params[3] = FLOAT_TO_BOOL(ctx->Color.ClearColor[3]);
200 break;
201 case GL_COLOR_MATERIAL:
202 *params = ctx->Light.ColorMaterialEnabled;
203 break;
204 case GL_COLOR_MATERIAL_FACE:
205 *params = ENUM_TO_BOOL(ctx->Light.ColorMaterialFace);
206 break;
207 case GL_COLOR_MATERIAL_PARAMETER:
208 *params = ENUM_TO_BOOL(ctx->Light.ColorMaterialMode);
209 break;
210 case GL_COLOR_WRITEMASK:
211 params[0] = (ctx->Color.ColorMask & 8) ? GL_TRUE : GL_FALSE;
212 params[1] = (ctx->Color.ColorMask & 4) ? GL_TRUE : GL_FALSE;
213 params[2] = (ctx->Color.ColorMask & 2) ? GL_TRUE : GL_FALSE;
214 params[3] = (ctx->Color.ColorMask & 1) ? GL_TRUE : GL_FALSE;
215 break;
216 case GL_CULL_FACE:
217 *params = ctx->Polygon.CullFlag;
218 break;
219 case GL_CULL_FACE_MODE:
220 *params = ENUM_TO_BOOL(ctx->Polygon.CullFaceMode);
221 break;
222 case GL_CURRENT_COLOR:
223 params[0] = INT_TO_BOOL(ctx->Current.ByteColor[0]);
224 params[1] = INT_TO_BOOL(ctx->Current.ByteColor[1]);
225 params[2] = INT_TO_BOOL(ctx->Current.ByteColor[2]);
226 params[3] = INT_TO_BOOL(ctx->Current.ByteColor[3]);
227 break;
228 case GL_CURRENT_INDEX:
229 *params = INT_TO_BOOL(ctx->Current.Index);
230 break;
231 case GL_CURRENT_NORMAL:
232 params[0] = FLOAT_TO_BOOL(ctx->Current.Normal[0]);
233 params[1] = FLOAT_TO_BOOL(ctx->Current.Normal[1]);
234 params[2] = FLOAT_TO_BOOL(ctx->Current.Normal[2]);
235 break;
236 case GL_CURRENT_RASTER_COLOR:
237 params[0] = FLOAT_TO_BOOL(ctx->Current.RasterColor[0]);
238 params[1] = FLOAT_TO_BOOL(ctx->Current.RasterColor[1]);
239 params[2] = FLOAT_TO_BOOL(ctx->Current.RasterColor[2]);
240 params[3] = FLOAT_TO_BOOL(ctx->Current.RasterColor[3]);
241 break;
242 case GL_CURRENT_RASTER_DISTANCE:
243 *params = FLOAT_TO_BOOL(ctx->Current.RasterDistance);
244 break;
245 case GL_CURRENT_RASTER_INDEX:
246 *params = FLOAT_TO_BOOL(ctx->Current.RasterIndex);
247 break;
248 case GL_CURRENT_RASTER_POSITION:
249 params[0] = FLOAT_TO_BOOL(ctx->Current.RasterPos[0]);
250 params[1] = FLOAT_TO_BOOL(ctx->Current.RasterPos[1]);
251 params[2] = FLOAT_TO_BOOL(ctx->Current.RasterPos[2]);
252 params[3] = FLOAT_TO_BOOL(ctx->Current.RasterPos[3]);
253 break;
254 case GL_CURRENT_RASTER_TEXTURE_COORDS:
255 params[0] = FLOAT_TO_BOOL(ctx->Current.RasterTexCoord[0]);
256 params[1] = FLOAT_TO_BOOL(ctx->Current.RasterTexCoord[1]);
257 params[2] = FLOAT_TO_BOOL(ctx->Current.RasterTexCoord[2]);
258 params[3] = FLOAT_TO_BOOL(ctx->Current.RasterTexCoord[3]);
259 break;
260 case GL_CURRENT_RASTER_POSITION_VALID:
261 *params = ctx->Current.RasterPosValid;
262 break;
263 case GL_CURRENT_TEXTURE_COORDS:
264 params[0] = FLOAT_TO_BOOL(ctx->Current.TexCoord[0]);
265 params[1] = FLOAT_TO_BOOL(ctx->Current.TexCoord[1]);
266 params[2] = FLOAT_TO_BOOL(ctx->Current.TexCoord[2]);
267 params[3] = FLOAT_TO_BOOL(ctx->Current.TexCoord[3]);
268 break;
269 case GL_DEPTH_BIAS:
270 *params = FLOAT_TO_BOOL(ctx->Pixel.DepthBias);
271 break;
272 case GL_DEPTH_BITS:
273 *params = INT_TO_BOOL(ctx->Visual->DepthBits);
274 break;
275 case GL_DEPTH_CLEAR_VALUE:
276 *params = FLOAT_TO_BOOL(ctx->Depth.Clear);
277 break;
278 case GL_DEPTH_FUNC:
279 *params = ENUM_TO_BOOL(ctx->Depth.Func);
280 break;
281 case GL_DEPTH_RANGE:
282 params[0] = FLOAT_TO_BOOL(ctx->Viewport.Near);
283 params[1] = FLOAT_TO_BOOL(ctx->Viewport.Far);
284 break;
285 case GL_DEPTH_SCALE:
286 *params = FLOAT_TO_BOOL(ctx->Pixel.DepthScale);
287 break;
288 case GL_DEPTH_TEST:
289 *params = ctx->Depth.Test;
290 break;
291 case GL_DEPTH_WRITEMASK:
292 *params = ctx->Depth.Mask;
293 break;
294 case GL_DITHER:
295 *params = ctx->Color.DitherFlag;
296 break;
297 case GL_DOUBLEBUFFER:
298 *params = ctx->Visual->DBflag;
299 break;
300 case GL_DRAW_BUFFER:
301 *params = ENUM_TO_BOOL(ctx->Color.DrawBuffer);
302 break;
303 case GL_EDGE_FLAG:
304 *params = ctx->Current.EdgeFlag;
305 break;
306 case GL_FEEDBACK_BUFFER_SIZE:
307 /* TODO: is this right? Or, return number of entries in buffer? */
308 *params = INT_TO_BOOL(ctx->Feedback.BufferSize);
309 break;
310 case GL_FEEDBACK_BUFFER_TYPE:
311 *params = INT_TO_BOOL(ctx->Feedback.Type);
312 break;
313 case GL_FOG:
314 *params = ctx->Fog.Enabled;
315 break;
316 case GL_FOG_COLOR:
317 params[0] = FLOAT_TO_BOOL(ctx->Fog.Color[0]);
318 params[1] = FLOAT_TO_BOOL(ctx->Fog.Color[1]);
319 params[2] = FLOAT_TO_BOOL(ctx->Fog.Color[2]);
320 params[3] = FLOAT_TO_BOOL(ctx->Fog.Color[3]);
321 break;
322 case GL_FOG_DENSITY:
323 *params = FLOAT_TO_BOOL(ctx->Fog.Density);
324 break;
325 case GL_FOG_END:
326 *params = FLOAT_TO_BOOL(ctx->Fog.End);
327 break;
328 case GL_FOG_HINT:
329 *params = ENUM_TO_BOOL(ctx->Hint.Fog);
330 break;
331 case GL_FOG_INDEX:
332 *params = FLOAT_TO_BOOL(ctx->Fog.Index);
333 break;
334 case GL_FOG_MODE:
335 *params = ENUM_TO_BOOL(ctx->Fog.Mode);
336 break;
337 case GL_FOG_START:
338 *params = FLOAT_TO_BOOL(ctx->Fog.End);
339 break;
340 case GL_FRONT_FACE:
341 *params = ENUM_TO_BOOL(ctx->Polygon.FrontFace);
342 break;
343 case GL_GREEN_BIAS:
344 *params = FLOAT_TO_BOOL(ctx->Pixel.GreenBias);
345 break;
346 case GL_GREEN_BITS:
347 *params = INT_TO_BOOL( ctx->Visual->GreenBits );
348 break;
349 case GL_GREEN_SCALE:
350 *params = FLOAT_TO_BOOL(ctx->Pixel.GreenScale);
351 break;
352 case GL_INDEX_BITS:
353 *params = INT_TO_BOOL( ctx->Visual->IndexBits );
354 break;
355 case GL_INDEX_CLEAR_VALUE:
356 *params = INT_TO_BOOL(ctx->Color.ClearIndex);
357 break;
358 case GL_INDEX_MODE:
359 *params = ctx->Visual->RGBAflag ? GL_FALSE : GL_TRUE;
360 break;
361 case GL_INDEX_OFFSET:
362 *params = INT_TO_BOOL(ctx->Pixel.IndexOffset);
363 break;
364 case GL_INDEX_SHIFT:
365 *params = INT_TO_BOOL(ctx->Pixel.IndexShift);
366 break;
367 case GL_INDEX_WRITEMASK:
368 *params = INT_TO_BOOL(ctx->Color.IndexMask);
369 break;
370 case GL_LIGHT0:
371 case GL_LIGHT1:
372 case GL_LIGHT2:
373 case GL_LIGHT3:
374 case GL_LIGHT4:
375 case GL_LIGHT5:
376 case GL_LIGHT6:
377 case GL_LIGHT7:
378 *params = ctx->Light.Light[pname-GL_LIGHT0].Enabled;
379 break;
380 case GL_LIGHTING:
381 *params = ctx->Light.Enabled;
382 break;
383 case GL_LIGHT_MODEL_AMBIENT:
384 params[0] = FLOAT_TO_BOOL(ctx->Light.Model.Ambient[0]);
385 params[1] = FLOAT_TO_BOOL(ctx->Light.Model.Ambient[1]);
386 params[2] = FLOAT_TO_BOOL(ctx->Light.Model.Ambient[2]);
387 params[3] = FLOAT_TO_BOOL(ctx->Light.Model.Ambient[3]);
388 break;
389 case GL_LIGHT_MODEL_LOCAL_VIEWER:
390 *params = ctx->Light.Model.LocalViewer;
391 break;
392 case GL_LIGHT_MODEL_TWO_SIDE:
393 *params = ctx->Light.Model.TwoSide;
394 break;
395 case GL_LINE_SMOOTH:
396 *params = ctx->Line.SmoothFlag;
397 break;
398 case GL_LINE_SMOOTH_HINT:
399 *params = ENUM_TO_BOOL(ctx->Hint.LineSmooth);
400 break;
401 case GL_LINE_STIPPLE:
402 *params = ctx->Line.StippleFlag;
403 break;
404 case GL_LINE_STIPPLE_PATTERN:
405 *params = INT_TO_BOOL(ctx->Line.StipplePattern);
406 break;
407 case GL_LINE_STIPPLE_REPEAT:
408 *params = INT_TO_BOOL(ctx->Line.StippleFactor);
409 break;
410 case GL_LINE_WIDTH:
411 *params = FLOAT_TO_BOOL(ctx->Line.Width);
412 break;
413 case GL_LINE_WIDTH_GRANULARITY:
414 *params = FLOAT_TO_BOOL(LINE_WIDTH_GRANULARITY);
415 break;
416 case GL_LINE_WIDTH_RANGE:
417 params[0] = FLOAT_TO_BOOL(MIN_LINE_WIDTH);
418 params[1] = FLOAT_TO_BOOL(MAX_LINE_WIDTH);
419 break;
420 case GL_LIST_BASE:
421 *params = INT_TO_BOOL(ctx->List.ListBase);
422 break;
423 case GL_LIST_INDEX:
424 *params = INT_TO_BOOL( ctx->CurrentListNum );
425 break;
426 case GL_LIST_MODE:
427 *params = ENUM_TO_BOOL( ctx->ExecuteFlag
428 ? GL_COMPILE_AND_EXECUTE : GL_COMPILE );
429 break;
430 case GL_INDEX_LOGIC_OP:
431 *params = ctx->Color.IndexLogicOpEnabled;
432 break;
433 case GL_COLOR_LOGIC_OP:
434 *params = ctx->Color.ColorLogicOpEnabled;
435 break;
436 case GL_LOGIC_OP_MODE:
437 *params = ENUM_TO_BOOL(ctx->Color.LogicOp);
438 break;
439 case GL_MAP1_COLOR_4:
440 *params = ctx->Eval.Map1Color4;
441 break;
442 case GL_MAP1_GRID_DOMAIN:
443 params[0] = FLOAT_TO_BOOL(ctx->Eval.MapGrid1u1);
444 params[1] = FLOAT_TO_BOOL(ctx->Eval.MapGrid1u2);
445 break;
446 case GL_MAP1_GRID_SEGMENTS:
447 *params = INT_TO_BOOL(ctx->Eval.MapGrid1un);
448 break;
449 case GL_MAP1_INDEX:
450 *params = ctx->Eval.Map1Index;
451 break;
452 case GL_MAP1_NORMAL:
453 *params = ctx->Eval.Map1Normal;
454 break;
455 case GL_MAP1_TEXTURE_COORD_1:
456 *params = ctx->Eval.Map1TextureCoord1;
457 break;
458 case GL_MAP1_TEXTURE_COORD_2:
459 *params = ctx->Eval.Map1TextureCoord2;
460 break;
461 case GL_MAP1_TEXTURE_COORD_3:
462 *params = ctx->Eval.Map1TextureCoord3;
463 break;
464 case GL_MAP1_TEXTURE_COORD_4:
465 *params = ctx->Eval.Map1TextureCoord4;
466 break;
467 case GL_MAP1_VERTEX_3:
468 *params = ctx->Eval.Map1Vertex3;
469 break;
470 case GL_MAP1_VERTEX_4:
471 *params = ctx->Eval.Map1Vertex4;
472 break;
473 case GL_MAP2_COLOR_4:
474 *params = ctx->Eval.Map2Color4;
475 break;
476 case GL_MAP2_GRID_DOMAIN:
477 params[0] = FLOAT_TO_BOOL(ctx->Eval.MapGrid2u1);
478 params[1] = FLOAT_TO_BOOL(ctx->Eval.MapGrid2u2);
479 params[2] = FLOAT_TO_BOOL(ctx->Eval.MapGrid2v1);
480 params[3] = FLOAT_TO_BOOL(ctx->Eval.MapGrid2v2);
481 break;
482 case GL_MAP2_GRID_SEGMENTS:
483 params[0] = INT_TO_BOOL(ctx->Eval.MapGrid2un);
484 params[1] = INT_TO_BOOL(ctx->Eval.MapGrid2vn);
485 break;
486 case GL_MAP2_INDEX:
487 *params = ctx->Eval.Map2Index;
488 break;
489 case GL_MAP2_NORMAL:
490 *params = ctx->Eval.Map2Normal;
491 break;
492 case GL_MAP2_TEXTURE_COORD_1:
493 *params = ctx->Eval.Map2TextureCoord1;
494 break;
495 case GL_MAP2_TEXTURE_COORD_2:
496 *params = ctx->Eval.Map2TextureCoord2;
497 break;
498 case GL_MAP2_TEXTURE_COORD_3:
499 *params = ctx->Eval.Map2TextureCoord3;
500 break;
501 case GL_MAP2_TEXTURE_COORD_4:
502 *params = ctx->Eval.Map2TextureCoord4;
503 break;
504 case GL_MAP2_VERTEX_3:
505 *params = ctx->Eval.Map2Vertex3;
506 break;
507 case GL_MAP2_VERTEX_4:
508 *params = ctx->Eval.Map2Vertex4;
509 break;
510 case GL_MAP_COLOR:
511 *params = ctx->Pixel.MapColorFlag;
512 break;
513 case GL_MAP_STENCIL:
514 *params = ctx->Pixel.MapStencilFlag;
515 break;
516 case GL_MATRIX_MODE:
517 *params = ENUM_TO_BOOL( ctx->Transform.MatrixMode );
518 break;
519 case GL_MAX_ATTRIB_STACK_DEPTH:
520 *params = INT_TO_BOOL(MAX_ATTRIB_STACK_DEPTH);
521 break;
522 case GL_MAX_CLIENT_ATTRIB_STACK_DEPTH:
523 *params = INT_TO_BOOL( MAX_CLIENT_ATTRIB_STACK_DEPTH);
524 break;
525 case GL_MAX_CLIP_PLANES:
526 *params = INT_TO_BOOL(MAX_CLIP_PLANES);
527 break;
528 case GL_MAX_EVAL_ORDER:
529 *params = INT_TO_BOOL(MAX_EVAL_ORDER);
530 break;
531 case GL_MAX_LIGHTS:
532 *params = INT_TO_BOOL(MAX_LIGHTS);
533 break;
534 case GL_MAX_LIST_NESTING:
535 *params = INT_TO_BOOL(MAX_LIST_NESTING);
536 break;
537 case GL_MAX_MODELVIEW_STACK_DEPTH:
538 *params = INT_TO_BOOL(MAX_MODELVIEW_STACK_DEPTH);
539 break;
540 case GL_MAX_NAME_STACK_DEPTH:
541 *params = INT_TO_BOOL(MAX_NAME_STACK_DEPTH);
542 break;
543 case GL_MAX_PIXEL_MAP_TABLE:
544 *params = INT_TO_BOOL(MAX_PIXEL_MAP_TABLE);
545 break;
546 case GL_MAX_PROJECTION_STACK_DEPTH:
547 *params = INT_TO_BOOL(MAX_PROJECTION_STACK_DEPTH);
548 break;
549 case GL_MAX_TEXTURE_SIZE:
550 *params = INT_TO_BOOL(MAX_TEXTURE_SIZE);
551 break;
552 case GL_MAX_TEXTURE_STACK_DEPTH:
553 *params = INT_TO_BOOL(MAX_TEXTURE_STACK_DEPTH);
554 break;
555 case GL_MAX_VIEWPORT_DIMS:
556 params[0] = INT_TO_BOOL(MAX_WIDTH);
557 params[1] = INT_TO_BOOL(MAX_HEIGHT);
558 break;
559 case GL_MODELVIEW_MATRIX:
560 for (i=0;i<16;i++) {
561 params[i] = FLOAT_TO_BOOL(ctx->ModelViewMatrix[i]);
562 }
563 break;
564 case GL_MODELVIEW_STACK_DEPTH:
565 *params = INT_TO_BOOL(ctx->ModelViewStackDepth);
566 break;
567 case GL_NAME_STACK_DEPTH:
568 *params = INT_TO_BOOL(ctx->Select.NameStackDepth);
569 break;
570 case GL_NORMALIZE:
571 *params = ctx->Transform.Normalize;
572 break;
573 case GL_PACK_ALIGNMENT:
574 *params = INT_TO_BOOL(ctx->Pack.Alignment);
575 break;
576 case GL_PACK_LSB_FIRST:
577 *params = ctx->Pack.LsbFirst;
578 break;
579 case GL_PACK_ROW_LENGTH:
580 *params = INT_TO_BOOL(ctx->Pack.RowLength);
581 break;
582 case GL_PACK_SKIP_PIXELS:
583 *params = INT_TO_BOOL(ctx->Pack.SkipPixels);
584 break;
585 case GL_PACK_SKIP_ROWS:
586 *params = INT_TO_BOOL(ctx->Pack.SkipRows);
587 break;
588 case GL_PACK_SWAP_BYTES:
589 *params = ctx->Pack.SwapBytes;
590 break;
591 case GL_PERSPECTIVE_CORRECTION_HINT:
592 *params = ENUM_TO_BOOL(ctx->Hint.PerspectiveCorrection);
593 break;
594 case GL_PIXEL_MAP_A_TO_A_SIZE:
595 *params = INT_TO_BOOL(ctx->Pixel.MapAtoAsize);
596 break;
597 case GL_PIXEL_MAP_B_TO_B_SIZE:
598 *params = INT_TO_BOOL(ctx->Pixel.MapBtoBsize);
599 break;
600 case GL_PIXEL_MAP_G_TO_G_SIZE:
601 *params = INT_TO_BOOL(ctx->Pixel.MapGtoGsize);
602 break;
603 case GL_PIXEL_MAP_I_TO_A_SIZE:
604 *params = INT_TO_BOOL(ctx->Pixel.MapItoAsize);
605 break;
606 case GL_PIXEL_MAP_I_TO_B_SIZE:
607 *params = INT_TO_BOOL(ctx->Pixel.MapItoBsize);
608 break;
609 case GL_PIXEL_MAP_I_TO_G_SIZE:
610 *params = INT_TO_BOOL(ctx->Pixel.MapItoGsize);
611 break;
612 case GL_PIXEL_MAP_I_TO_I_SIZE:
613 *params = INT_TO_BOOL(ctx->Pixel.MapItoIsize);
614 break;
615 case GL_PIXEL_MAP_I_TO_R_SIZE:
616 *params = INT_TO_BOOL(ctx->Pixel.MapItoRsize);
617 break;
618 case GL_PIXEL_MAP_R_TO_R_SIZE:
619 *params = INT_TO_BOOL(ctx->Pixel.MapRtoRsize);
620 break;
621 case GL_PIXEL_MAP_S_TO_S_SIZE:
622 *params = INT_TO_BOOL(ctx->Pixel.MapStoSsize);
623 break;
624 case GL_POINT_SIZE:
625 *params = FLOAT_TO_BOOL(ctx->Point.Size );
626 break;
627 case GL_POINT_SIZE_GRANULARITY:
628 *params = FLOAT_TO_BOOL(POINT_SIZE_GRANULARITY );
629 break;
630 case GL_POINT_SIZE_RANGE:
631 params[0] = FLOAT_TO_BOOL(MIN_POINT_SIZE );
632 params[1] = FLOAT_TO_BOOL(MAX_POINT_SIZE );
633 break;
634 case GL_POINT_SMOOTH:
635 *params = ctx->Point.SmoothFlag;
636 break;
637 case GL_POINT_SMOOTH_HINT:
638 *params = ENUM_TO_BOOL(ctx->Hint.PointSmooth);
639 break;
640 case GL_POLYGON_MODE:
641 params[0] = ENUM_TO_BOOL(ctx->Polygon.FrontMode);
642 params[1] = ENUM_TO_BOOL(ctx->Polygon.BackMode);
643 break;
644 #ifdef GL_EXT_polygon_offset
645 case GL_POLYGON_OFFSET_BIAS_EXT:
646 *params = FLOAT_TO_BOOL( ctx->Polygon.OffsetUnits );
647 break;
648 #endif
649 case GL_POLYGON_OFFSET_FACTOR:
650 *params = FLOAT_TO_BOOL( ctx->Polygon.OffsetFactor );
651 break;
652 case GL_POLYGON_OFFSET_UNITS:
653 *params = FLOAT_TO_BOOL( ctx->Polygon.OffsetUnits );
654 break;
655 case GL_POLYGON_SMOOTH:
656 *params = ctx->Polygon.SmoothFlag;
657 break;
658 case GL_POLYGON_SMOOTH_HINT:
659 *params = ENUM_TO_BOOL(ctx->Hint.PolygonSmooth);
660 break;
661 case GL_POLYGON_STIPPLE:
662 *params = ctx->Polygon.StippleFlag;
663 break;
664 case GL_PROJECTION_MATRIX:
665 for (i=0;i<16;i++) {
666 params[i] = FLOAT_TO_BOOL(ctx->ProjectionMatrix[i]);
667 }
668 break;
669 case GL_PROJECTION_STACK_DEPTH:
670 *params = INT_TO_BOOL(ctx->ProjectionStackDepth);
671 break;
672 case GL_READ_BUFFER:
673 *params = ENUM_TO_BOOL(ctx->Pixel.ReadBuffer);
674 break;
675 case GL_RED_BIAS:
676 *params = FLOAT_TO_BOOL(ctx->Pixel.RedBias);
677 break;
678 case GL_RED_BITS:
679 *params = INT_TO_BOOL( ctx->Visual->RedBits );
680 break;
681 case GL_RED_SCALE:
682 *params = FLOAT_TO_BOOL(ctx->Pixel.RedScale);
683 break;
684 case GL_RENDER_MODE:
685 *params = ENUM_TO_BOOL(ctx->RenderMode);
686 break;
687 case GL_RGBA_MODE:
688 *params = ctx->Visual->RGBAflag;
689 break;
690 case GL_SCISSOR_BOX:
691 params[0] = INT_TO_BOOL(ctx->Scissor.X);
692 params[1] = INT_TO_BOOL(ctx->Scissor.Y);
693 params[2] = INT_TO_BOOL(ctx->Scissor.Width);
694 params[3] = INT_TO_BOOL(ctx->Scissor.Height);
695 break;
696 case GL_SCISSOR_TEST:
697 *params = ctx->Scissor.Enabled;
698 break;
699 case GL_SHADE_MODEL:
700 *params = ENUM_TO_BOOL(ctx->Light.ShadeModel);
701 break;
702 case GL_STENCIL_BITS:
703 *params = INT_TO_BOOL(ctx->Visual->StencilBits);
704 break;
705 case GL_STENCIL_CLEAR_VALUE:
706 *params = INT_TO_BOOL(ctx->Stencil.Clear);
707 break;
708 case GL_STENCIL_FAIL:
709 *params = ENUM_TO_BOOL(ctx->Stencil.FailFunc);
710 break;
711 case GL_STENCIL_FUNC:
712 *params = ENUM_TO_BOOL(ctx->Stencil.Function);
713 break;
714 case GL_STENCIL_PASS_DEPTH_FAIL:
715 *params = ENUM_TO_BOOL(ctx->Stencil.ZFailFunc);
716 break;
717 case GL_STENCIL_PASS_DEPTH_PASS:
718 *params = ENUM_TO_BOOL(ctx->Stencil.ZPassFunc);
719 break;
720 case GL_STENCIL_REF:
721 *params = INT_TO_BOOL(ctx->Stencil.Ref);
722 break;
723 case GL_STENCIL_TEST:
724 *params = ctx->Stencil.Enabled;
725 break;
726 case GL_STENCIL_VALUE_MASK:
727 *params = INT_TO_BOOL(ctx->Stencil.ValueMask);
728 break;
729 case GL_STENCIL_WRITEMASK:
730 *params = INT_TO_BOOL(ctx->Stencil.WriteMask);
731 break;
732 case GL_STEREO:
733 *params = GL_FALSE; /* TODO */
734 break;
735 case GL_SUBPIXEL_BITS:
736 *params = INT_TO_BOOL(0); /* TODO */
737 break;
738 case GL_TEXTURE_1D:
739 *params = (ctx->Texture.Enabled & TEXTURE_1D) ? GL_TRUE : GL_FALSE;
740 break;
741 case GL_TEXTURE_2D:
742 *params = (ctx->Texture.Enabled & TEXTURE_2D) ? GL_TRUE : GL_FALSE;
743 break;
744 case GL_TEXTURE_ENV_COLOR:
745 params[0] = FLOAT_TO_BOOL(ctx->Texture.EnvColor[0]);
746 params[1] = FLOAT_TO_BOOL(ctx->Texture.EnvColor[1]);
747 params[2] = FLOAT_TO_BOOL(ctx->Texture.EnvColor[2]);
748 params[3] = FLOAT_TO_BOOL(ctx->Texture.EnvColor[3]);
749 break;
750 case GL_TEXTURE_ENV_MODE:
751 *params = ENUM_TO_BOOL(ctx->Texture.EnvMode);
752 break;
753 case GL_TEXTURE_GEN_S:
754 *params = (ctx->Texture.TexGenEnabled & S_BIT) ? GL_TRUE : GL_FALSE;
755 break;
756 case GL_TEXTURE_GEN_T:
757 *params = (ctx->Texture.TexGenEnabled & T_BIT) ? GL_TRUE : GL_FALSE;
758 break;
759 case GL_TEXTURE_GEN_R:
760 *params = (ctx->Texture.TexGenEnabled & R_BIT) ? GL_TRUE : GL_FALSE;
761 break;
762 case GL_TEXTURE_GEN_Q:
763 *params = (ctx->Texture.TexGenEnabled & Q_BIT) ? GL_TRUE : GL_FALSE;
764 break;
765 case GL_TEXTURE_MATRIX:
766 for (i=0;i<16;i++) {
767 params[i] = FLOAT_TO_BOOL(ctx->TextureMatrix[i]);
768 }
769 break;
770 case GL_TEXTURE_STACK_DEPTH:
771 *params = INT_TO_BOOL(ctx->TextureStackDepth);
772 break;
773 case GL_UNPACK_ALIGNMENT:
774 *params = INT_TO_BOOL(ctx->Unpack.Alignment);
775 break;
776 case GL_UNPACK_LSB_FIRST:
777 *params = ctx->Unpack.LsbFirst;
778 break;
779 case GL_UNPACK_ROW_LENGTH:
780 *params = INT_TO_BOOL(ctx->Unpack.RowLength);
781 break;
782 case GL_UNPACK_SKIP_PIXELS:
783 *params = INT_TO_BOOL(ctx->Unpack.SkipPixels);
784 break;
785 case GL_UNPACK_SKIP_ROWS:
786 *params = INT_TO_BOOL(ctx->Unpack.SkipRows);
787 break;
788 case GL_UNPACK_SWAP_BYTES:
789 *params = ctx->Unpack.SwapBytes;
790 break;
791 case GL_VIEWPORT:
792 params[0] = INT_TO_BOOL(ctx->Viewport.X);
793 params[1] = INT_TO_BOOL(ctx->Viewport.Y);
794 params[2] = INT_TO_BOOL(ctx->Viewport.Width);
795 params[3] = INT_TO_BOOL(ctx->Viewport.Height);
796 break;
797 case GL_ZOOM_X:
798 *params = FLOAT_TO_BOOL(ctx->Pixel.ZoomX);
799 break;
800 case GL_ZOOM_Y:
801 *params = FLOAT_TO_BOOL(ctx->Pixel.ZoomY);
802 break;
803 case GL_VERTEX_ARRAY_SIZE:
804 *params = INT_TO_BOOL(ctx->Array.VertexSize);
805 break;
806 case GL_VERTEX_ARRAY_TYPE:
807 *params = ENUM_TO_BOOL(ctx->Array.VertexType);
808 break;
809 case GL_VERTEX_ARRAY_STRIDE:
810 *params = INT_TO_BOOL(ctx->Array.VertexStride);
811 break;
812 case GL_VERTEX_ARRAY_COUNT_EXT:
813 *params = INT_TO_BOOL(0);
814 break;
815 case GL_NORMAL_ARRAY_TYPE:
816 *params = ENUM_TO_BOOL(ctx->Array.NormalType);
817 break;
818 case GL_NORMAL_ARRAY_STRIDE:
819 *params = INT_TO_BOOL(ctx->Array.NormalStride);
820 break;
821 case GL_NORMAL_ARRAY_COUNT_EXT:
822 *params = INT_TO_BOOL(0);
823 break;
824 case GL_COLOR_ARRAY_SIZE:
825 *params = INT_TO_BOOL(ctx->Array.ColorSize);
826 break;
827 case GL_COLOR_ARRAY_TYPE:
828 *params = ENUM_TO_BOOL(ctx->Array.ColorType);
829 break;
830 case GL_COLOR_ARRAY_STRIDE:
831 *params = INT_TO_BOOL(ctx->Array.ColorStride);
832 break;
833 case GL_COLOR_ARRAY_COUNT_EXT:
834 *params = INT_TO_BOOL(0);
835 break;
836 case GL_INDEX_ARRAY_TYPE:
837 *params = ENUM_TO_BOOL(ctx->Array.IndexType);
838 break;
839 case GL_INDEX_ARRAY_STRIDE:
840 *params = INT_TO_BOOL(ctx->Array.IndexStride);
841 break;
842 case GL_INDEX_ARRAY_COUNT_EXT:
843 *params = INT_TO_BOOL(0);
844 break;
845 case GL_TEXTURE_COORD_ARRAY_SIZE:
846 *params = INT_TO_BOOL(ctx->Array.TexCoordSize);
847 break;
848 case GL_TEXTURE_COORD_ARRAY_TYPE:
849 *params = ENUM_TO_BOOL(ctx->Array.TexCoordType);
850 break;
851 case GL_TEXTURE_COORD_ARRAY_STRIDE:
852 *params = INT_TO_BOOL(ctx->Array.TexCoordStride);
853 break;
854 case GL_TEXTURE_COORD_ARRAY_COUNT_EXT:
855 *params = INT_TO_BOOL(0);
856 break;
857 case GL_EDGE_FLAG_ARRAY_STRIDE:
858 *params = INT_TO_BOOL(ctx->Array.EdgeFlagStride);
859 break;
860 case GL_EDGE_FLAG_ARRAY_EXT:
861 *params = INT_TO_BOOL(0);
862 break;
863 case GL_TEXTURE_BINDING_1D:
864 *params = INT_TO_BOOL(ctx->Texture.Current1D->Name);
865 break;
866 case GL_TEXTURE_BINDING_2D:
867 *params = INT_TO_BOOL(ctx->Texture.Current2D->Name);
868 break;
869 case GL_TEXTURE_3D_BINDING_EXT:
870 *params = INT_TO_BOOL(ctx->Texture.Current2D->Name);
871 break;
872 default:
873 gl_error( ctx, GL_INVALID_ENUM, "glGetBooleanv" );
874 }
875 }
876
877
878
879
880 void gl_GetDoublev( GLcontext *ctx, GLenum pname, GLdouble *params )
881 {
882 GLuint i;
883
884 if (INSIDE_BEGIN_END(ctx)) {
885 gl_error( ctx, GL_INVALID_OPERATION, "glGetDoublev" );
886 return;
887 }
888
889 switch (pname) {
890 case GL_ACCUM_RED_BITS:
891 case GL_ACCUM_GREEN_BITS:
892 case GL_ACCUM_BLUE_BITS:
893 case GL_ACCUM_ALPHA_BITS:
894 *params = (GLdouble) ctx->Visual->AccumBits;
895 break;
896 case GL_ACCUM_CLEAR_VALUE:
897 params[0] = (GLdouble) ctx->Accum.ClearColor[0];
898 params[1] = (GLdouble) ctx->Accum.ClearColor[1];
899 params[2] = (GLdouble) ctx->Accum.ClearColor[2];
900 params[3] = (GLdouble) ctx->Accum.ClearColor[3];
901 break;
902 case GL_ALPHA_BIAS:
903 *params = (GLdouble) ctx->Pixel.AlphaBias;
904 break;
905 case GL_ALPHA_BITS:
906 *params = (GLdouble) ctx->Visual->AlphaBits;
907 break;
908 case GL_ALPHA_SCALE:
909 *params = (GLdouble) ctx->Pixel.AlphaScale;
910 break;
911 case GL_ALPHA_TEST:
912 *params = (GLdouble) ctx->Color.AlphaEnabled;
913 break;
914 case GL_ALPHA_TEST_FUNC:
915 *params = ENUM_TO_DOUBLE(ctx->Color.AlphaFunc);
916 break;
917 case GL_ALPHA_TEST_REF:
918 *params = (GLdouble) ctx->Color.AlphaRef;
919 break;
920 case GL_ATTRIB_STACK_DEPTH:
921 *params = (GLdouble ) ctx->AttribStackDepth;
922 break;
923 case GL_AUTO_NORMAL:
924 *params = (GLdouble) ctx->Eval.AutoNormal;
925 break;
926 case GL_AUX_BUFFERS:
927 *params = (GLdouble) NUM_AUX_BUFFERS;
928 break;
929 case GL_BLEND:
930 *params = (GLdouble) ctx->Color.BlendEnabled;
931 break;
932 case GL_BLEND_DST:
933 *params = ENUM_TO_DOUBLE(ctx->Color.BlendDst);
934 break;
935 case GL_BLEND_SRC:
936 *params = ENUM_TO_DOUBLE(ctx->Color.BlendSrc);
937 break;
938 case GL_BLUE_BIAS:
939 *params = (GLdouble) ctx->Pixel.BlueBias;
940 break;
941 case GL_BLUE_BITS:
942 *params = (GLdouble) ctx->Visual->BlueBits;
943 break;
944 case GL_BLUE_SCALE:
945 *params = (GLdouble) ctx->Pixel.BlueScale;
946 break;
947 case GL_CLIENT_ATTRIB_STACK_DEPTH:
948 *params = (GLdouble) ctx->ClientAttribStackDepth;
949 break;
950 case GL_CLIP_PLANE0:
951 case GL_CLIP_PLANE1:
952 case GL_CLIP_PLANE2:
953 case GL_CLIP_PLANE3:
954 case GL_CLIP_PLANE4:
955 case GL_CLIP_PLANE5:
956 *params = (GLdouble) ctx->Transform.ClipEnabled[pname-GL_CLIP_PLANE0];
957 break;
958 case GL_COLOR_CLEAR_VALUE:
959 params[0] = (GLdouble) ctx->Color.ClearColor[0];
960 params[1] = (GLdouble) ctx->Color.ClearColor[1];
961 params[2] = (GLdouble) ctx->Color.ClearColor[2];
962 params[3] = (GLdouble) ctx->Color.ClearColor[3];
963 break;
964 case GL_COLOR_MATERIAL:
965 *params = (GLdouble) ctx->Light.ColorMaterialEnabled;
966 break;
967 case GL_COLOR_MATERIAL_FACE:
968 *params = ENUM_TO_DOUBLE(ctx->Light.ColorMaterialFace);
969 break;
970 case GL_COLOR_MATERIAL_PARAMETER:
971 *params = ENUM_TO_DOUBLE(ctx->Light.ColorMaterialMode);
972 break;
973 case GL_COLOR_WRITEMASK:
974 params[0] = (ctx->Color.ColorMask & 8) ? 1.0 : 0.0;
975 params[1] = (ctx->Color.ColorMask & 4) ? 1.0 : 0.0;
976 params[2] = (ctx->Color.ColorMask & 2) ? 1.0 : 0.0;
977 params[3] = (ctx->Color.ColorMask & 1) ? 1.0 : 0.0;
978 break;
979 case GL_CULL_FACE:
980 *params = (GLdouble) ctx->Polygon.CullFlag;
981 break;
982 case GL_CULL_FACE_MODE:
983 *params = ENUM_TO_DOUBLE(ctx->Polygon.CullFaceMode);
984 break;
985 case GL_CURRENT_COLOR:
986 params[0] = ctx->Current.ByteColor[0] * ctx->Visual->InvRedScale;
987 params[1] = ctx->Current.ByteColor[1] * ctx->Visual->InvGreenScale;
988 params[2] = ctx->Current.ByteColor[2] * ctx->Visual->InvBlueScale;
989 params[3] = ctx->Current.ByteColor[3] * ctx->Visual->InvAlphaScale;
990 break;
991 case GL_CURRENT_INDEX:
992 *params = (GLdouble) ctx->Current.Index;
993 break;
994 case GL_CURRENT_NORMAL:
995 params[0] = (GLdouble) ctx->Current.Normal[0];
996 params[1] = (GLdouble) ctx->Current.Normal[1];
997 params[2] = (GLdouble) ctx->Current.Normal[2];
998 break;
999 case GL_CURRENT_RASTER_COLOR:
1000 params[0] = (GLdouble) ctx->Current.RasterColor[0];
1001 params[1] = (GLdouble) ctx->Current.RasterColor[1];
1002 params[2] = (GLdouble) ctx->Current.RasterColor[2];
1003 params[3] = (GLdouble) ctx->Current.RasterColor[3];
1004 break;
1005 case GL_CURRENT_RASTER_DISTANCE:
1006 params[0] = (GLdouble) ctx->Current.RasterDistance;
1007 break;
1008 case GL_CURRENT_RASTER_INDEX:
1009 *params = (GLdouble) ctx->Current.RasterIndex;
1010 break;
1011 case GL_CURRENT_RASTER_POSITION:
1012 params[0] = (GLdouble) ctx->Current.RasterPos[0];
1013 params[1] = (GLdouble) ctx->Current.RasterPos[1];
1014 params[2] = (GLdouble) ctx->Current.RasterPos[2];
1015 params[3] = (GLdouble) ctx->Current.RasterPos[3];
1016 break;
1017 case GL_CURRENT_RASTER_TEXTURE_COORDS:
1018 params[0] = (GLdouble) ctx->Current.RasterTexCoord[0];
1019 params[1] = (GLdouble) ctx->Current.RasterTexCoord[1];
1020 params[2] = (GLdouble) ctx->Current.RasterTexCoord[2];
1021 params[3] = (GLdouble) ctx->Current.RasterTexCoord[3];
1022 break;
1023 case GL_CURRENT_RASTER_POSITION_VALID:
1024 *params = (GLdouble) ctx->Current.RasterPosValid;
1025 break;
1026 case GL_CURRENT_TEXTURE_COORDS:
1027 params[0] = (GLdouble) ctx->Current.TexCoord[0];
1028 params[1] = (GLdouble) ctx->Current.TexCoord[1];
1029 params[2] = (GLdouble) ctx->Current.TexCoord[2];
1030 params[3] = (GLdouble) ctx->Current.TexCoord[3];
1031 break;
1032 case GL_DEPTH_BIAS:
1033 *params = (GLdouble) ctx->Pixel.DepthBias;
1034 break;
1035 case GL_DEPTH_BITS:
1036 *params = (GLdouble) ctx->Visual->DepthBits;
1037 break;
1038 case GL_DEPTH_CLEAR_VALUE:
1039 *params = (GLdouble) ctx->Depth.Clear;
1040 break;
1041 case GL_DEPTH_FUNC:
1042 *params = ENUM_TO_DOUBLE(ctx->Depth.Func);
1043 break;
1044 case GL_DEPTH_RANGE:
1045 params[0] = (GLdouble) ctx->Viewport.Near;
1046 params[1] = (GLdouble) ctx->Viewport.Far;
1047 break;
1048 case GL_DEPTH_SCALE:
1049 *params = (GLdouble) ctx->Pixel.DepthScale;
1050 break;
1051 case GL_DEPTH_TEST:
1052 *params = (GLdouble) ctx->Depth.Test;
1053 break;
1054 case GL_DEPTH_WRITEMASK:
1055 *params = (GLdouble) ctx->Depth.Mask;
1056 break;
1057 case GL_DITHER:
1058 *params = (GLdouble) ctx->Color.DitherFlag;
1059 break;
1060 case GL_DOUBLEBUFFER:
1061 *params = (GLdouble) ctx->Visual->DBflag;
1062 break;
1063 case GL_DRAW_BUFFER:
1064 *params = ENUM_TO_DOUBLE(ctx->Color.DrawBuffer);
1065 break;
1066 case GL_EDGE_FLAG:
1067 *params = (GLdouble) ctx->Current.EdgeFlag;
1068 break;
1069 case GL_FEEDBACK_BUFFER_SIZE:
1070 /* TODO: is this right? Or, return number of entries in buffer? */
1071 *params = (GLdouble) ctx->Feedback.BufferSize;
1072 break;
1073 case GL_FEEDBACK_BUFFER_TYPE:
1074 *params = ENUM_TO_DOUBLE(ctx->Feedback.Type);
1075 break;
1076 case GL_FOG:
1077 *params = (GLdouble) ctx->Fog.Enabled;
1078 break;
1079 case GL_FOG_COLOR:
1080 params[0] = (GLdouble) ctx->Fog.Color[0];
1081 params[1] = (GLdouble) ctx->Fog.Color[1];
1082 params[2] = (GLdouble) ctx->Fog.Color[2];
1083 params[3] = (GLdouble) ctx->Fog.Color[3];
1084 break;
1085 case GL_FOG_DENSITY:
1086 *params = (GLdouble) ctx->Fog.Density;
1087 break;
1088 case GL_FOG_END:
1089 *params = (GLdouble) ctx->Fog.End;
1090 break;
1091 case GL_FOG_HINT:
1092 *params = ENUM_TO_DOUBLE(ctx->Hint.Fog);
1093 break;
1094 case GL_FOG_INDEX:
1095 *params = (GLdouble) ctx->Fog.Index;
1096 break;
1097 case GL_FOG_MODE:
1098 *params = ENUM_TO_DOUBLE(ctx->Fog.Mode);
1099 break;
1100 case GL_FOG_START:
1101 *params = (GLdouble) ctx->Fog.Start;
1102 break;
1103 case GL_FRONT_FACE:
1104 *params = ENUM_TO_DOUBLE(ctx->Polygon.FrontFace);
1105 break;
1106 case GL_GREEN_BIAS:
1107 *params = (GLdouble) ctx->Pixel.GreenBias;
1108 break;
1109 case GL_GREEN_BITS:
1110 *params = (GLdouble) ctx->Visual->GreenBits;
1111 break;
1112 case GL_GREEN_SCALE:
1113 *params = (GLdouble) ctx->Pixel.GreenScale;
1114 break;
1115 case GL_INDEX_BITS:
1116 *params = (GLdouble) ctx->Visual->IndexBits;
1117 break;
1118 case GL_INDEX_CLEAR_VALUE:
1119 *params = (GLdouble) ctx->Color.ClearIndex;
1120 break;
1121 case GL_INDEX_MODE:
1122 *params = ctx->Visual->RGBAflag ? 0.0 : 1.0;
1123 break;
1124 case GL_INDEX_OFFSET:
1125 *params = (GLdouble) ctx->Pixel.IndexOffset;
1126 break;
1127 case GL_INDEX_SHIFT:
1128 *params = (GLdouble) ctx->Pixel.IndexShift;
1129 break;
1130 case GL_INDEX_WRITEMASK:
1131 *params = (GLdouble) ctx->Color.IndexMask;
1132 break;
1133 case GL_LIGHT0:
1134 case GL_LIGHT1:
1135 case GL_LIGHT2:
1136 case GL_LIGHT3:
1137 case GL_LIGHT4:
1138 case GL_LIGHT5:
1139 case GL_LIGHT6:
1140 case GL_LIGHT7:
1141 *params = (GLdouble) ctx->Light.Light[pname-GL_LIGHT0].Enabled;
1142 break;
1143 case GL_LIGHTING:
1144 *params = (GLdouble) ctx->Light.Enabled;
1145 break;
1146 case GL_LIGHT_MODEL_AMBIENT:
1147 params[0] = (GLdouble) ctx->Light.Model.Ambient[0];
1148 params[1] = (GLdouble) ctx->Light.Model.Ambient[1];
1149 params[2] = (GLdouble) ctx->Light.Model.Ambient[2];
1150 params[3] = (GLdouble) ctx->Light.Model.Ambient[3];
1151 break;
1152 case GL_LIGHT_MODEL_LOCAL_VIEWER:
1153 *params = (GLdouble) ctx->Light.Model.LocalViewer;
1154 break;
1155 case GL_LIGHT_MODEL_TWO_SIDE:
1156 *params = (GLdouble) ctx->Light.Model.TwoSide;
1157 break;
1158 case GL_LINE_SMOOTH:
1159 *params = (GLdouble) ctx->Line.SmoothFlag;
1160 break;
1161 case GL_LINE_SMOOTH_HINT:
1162 *params = ENUM_TO_DOUBLE(ctx->Hint.LineSmooth);
1163 break;
1164 case GL_LINE_STIPPLE:
1165 *params = (GLdouble) ctx->Line.StippleFlag;
1166 break;
1167 case GL_LINE_STIPPLE_PATTERN:
1168 *params = (GLdouble) ctx->Line.StipplePattern;
1169 break;
1170 case GL_LINE_STIPPLE_REPEAT:
1171 *params = (GLdouble) ctx->Line.StippleFactor;
1172 break;
1173 case GL_LINE_WIDTH:
1174 *params = (GLdouble) ctx->Line.Width;
1175 break;
1176 case GL_LINE_WIDTH_GRANULARITY:
1177 *params = (GLdouble) LINE_WIDTH_GRANULARITY;
1178 break;
1179 case GL_LINE_WIDTH_RANGE:
1180 params[0] = (GLdouble) MIN_LINE_WIDTH;
1181 params[1] = (GLdouble) MAX_LINE_WIDTH;
1182 break;
1183 case GL_LIST_BASE:
1184 *params = (GLdouble) ctx->List.ListBase;
1185 break;
1186 case GL_LIST_INDEX:
1187 *params = (GLdouble) ctx->CurrentListNum;
1188 break;
1189 case GL_LIST_MODE:
1190 *params = ctx->ExecuteFlag ? ENUM_TO_DOUBLE(GL_COMPILE_AND_EXECUTE)
1191 : ENUM_TO_DOUBLE(GL_COMPILE);
1192 break;
1193 case GL_INDEX_LOGIC_OP:
1194 *params = (GLdouble) ctx->Color.IndexLogicOpEnabled;
1195 break;
1196 case GL_COLOR_LOGIC_OP:
1197 *params = (GLdouble) ctx->Color.ColorLogicOpEnabled;
1198 break;
1199 case GL_LOGIC_OP_MODE:
1200 *params = ENUM_TO_DOUBLE(ctx->Color.LogicOp);
1201 break;
1202 case GL_MAP1_COLOR_4:
1203 *params = (GLdouble) ctx->Eval.Map1Color4;
1204 break;
1205 case GL_MAP1_GRID_DOMAIN:
1206 params[0] = (GLdouble) ctx->Eval.MapGrid1u1;
1207 params[1] = (GLdouble) ctx->Eval.MapGrid1u2;
1208 break;
1209 case GL_MAP1_GRID_SEGMENTS:
1210 *params = (GLdouble) ctx->Eval.MapGrid1un;
1211 break;
1212 case GL_MAP1_INDEX:
1213 *params = (GLdouble) ctx->Eval.Map1Index;
1214 break;
1215 case GL_MAP1_NORMAL:
1216 *params = (GLdouble) ctx->Eval.Map1Normal;
1217 break;
1218 case GL_MAP1_TEXTURE_COORD_1:
1219 *params = (GLdouble) ctx->Eval.Map1TextureCoord1;
1220 break;
1221 case GL_MAP1_TEXTURE_COORD_2:
1222 *params = (GLdouble) ctx->Eval.Map1TextureCoord2;
1223 break;
1224 case GL_MAP1_TEXTURE_COORD_3:
1225 *params = (GLdouble) ctx->Eval.Map1TextureCoord3;
1226 break;
1227 case GL_MAP1_TEXTURE_COORD_4:
1228 *params = (GLdouble) ctx->Eval.Map1TextureCoord4;
1229 break;
1230 case GL_MAP1_VERTEX_3:
1231 *params = (GLdouble) ctx->Eval.Map1Vertex3;
1232 break;
1233 case GL_MAP1_VERTEX_4:
1234 *params = (GLdouble) ctx->Eval.Map1Vertex4;
1235 break;
1236 case GL_MAP2_COLOR_4:
1237 *params = (GLdouble) ctx->Eval.Map2Color4;
1238 break;
1239 case GL_MAP2_GRID_DOMAIN:
1240 params[0] = (GLdouble) ctx->Eval.MapGrid2u1;
1241 params[1] = (GLdouble) ctx->Eval.MapGrid2u2;
1242 params[2] = (GLdouble) ctx->Eval.MapGrid2v1;
1243 params[3] = (GLdouble) ctx->Eval.MapGrid2v2;
1244 break;
1245 case GL_MAP2_GRID_SEGMENTS:
1246 params[0] = (GLdouble) ctx->Eval.MapGrid2un;
1247 params[1] = (GLdouble) ctx->Eval.MapGrid2vn;
1248 break;
1249 case GL_MAP2_INDEX:
1250 *params = (GLdouble) ctx->Eval.Map2Index;
1251 break;
1252 case GL_MAP2_NORMAL:
1253 *params = (GLdouble) ctx->Eval.Map2Normal;
1254 break;
1255 case GL_MAP2_TEXTURE_COORD_1:
1256 *params = (GLdouble) ctx->Eval.Map2TextureCoord1;
1257 break;
1258 case GL_MAP2_TEXTURE_COORD_2:
1259 *params = (GLdouble) ctx->Eval.Map2TextureCoord2;
1260 break;
1261 case GL_MAP2_TEXTURE_COORD_3:
1262 *params = (GLdouble) ctx->Eval.Map2TextureCoord3;
1263 break;
1264 case GL_MAP2_TEXTURE_COORD_4:
1265 *params = (GLdouble) ctx->Eval.Map2TextureCoord4;
1266 break;
1267 case GL_MAP2_VERTEX_3:
1268 *params = (GLdouble) ctx->Eval.Map2Vertex3;
1269 break;
1270 case GL_MAP2_VERTEX_4:
1271 *params = (GLdouble) ctx->Eval.Map2Vertex4;
1272 break;
1273 case GL_MAP_COLOR:
1274 *params = (GLdouble) ctx->Pixel.MapColorFlag;
1275 break;
1276 case GL_MAP_STENCIL:
1277 *params = (GLdouble) ctx->Pixel.MapStencilFlag;
1278 break;
1279 case GL_MATRIX_MODE:
1280 *params = ENUM_TO_DOUBLE(ctx->Transform.MatrixMode);
1281 break;
1282 case GL_MAX_ATTRIB_STACK_DEPTH:
1283 *params = (GLdouble) MAX_ATTRIB_STACK_DEPTH;
1284 break;
1285 case GL_MAX_CLIENT_ATTRIB_STACK_DEPTH:
1286 *params = (GLdouble) MAX_CLIENT_ATTRIB_STACK_DEPTH;
1287 break;
1288 case GL_MAX_CLIP_PLANES:
1289 *params = (GLdouble) MAX_CLIP_PLANES;
1290 break;
1291 case GL_MAX_EVAL_ORDER:
1292 *params = (GLdouble) MAX_EVAL_ORDER;
1293 break;
1294 case GL_MAX_LIGHTS:
1295 *params = (GLdouble) MAX_LIGHTS;
1296 break;
1297 case GL_MAX_LIST_NESTING:
1298 *params = (GLdouble) MAX_LIST_NESTING;
1299 break;
1300 case GL_MAX_MODELVIEW_STACK_DEPTH:
1301 *params = (GLdouble) MAX_MODELVIEW_STACK_DEPTH;
1302 break;
1303 case GL_MAX_NAME_STACK_DEPTH:
1304 *params = (GLdouble) MAX_NAME_STACK_DEPTH;
1305 break;
1306 case GL_MAX_PIXEL_MAP_TABLE:
1307 *params = (GLdouble) MAX_PIXEL_MAP_TABLE;
1308 break;
1309 case GL_MAX_PROJECTION_STACK_DEPTH:
1310 *params = (GLdouble) MAX_PROJECTION_STACK_DEPTH;
1311 break;
1312 case GL_MAX_TEXTURE_SIZE:
1313 *params = (GLdouble) MAX_TEXTURE_SIZE;
1314 break;
1315 case GL_MAX_TEXTURE_STACK_DEPTH:
1316 *params = (GLdouble) MAX_TEXTURE_STACK_DEPTH;
1317 break;
1318 case GL_MAX_VIEWPORT_DIMS:
1319 params[0] = (GLdouble) MAX_WIDTH;
1320 params[1] = (GLdouble) MAX_HEIGHT;
1321 break;
1322 case GL_MODELVIEW_MATRIX:
1323 for (i=0;i<16;i++) {
1324 params[i] = (GLdouble) ctx->ModelViewMatrix[i];
1325 }
1326 break;
1327 case GL_MODELVIEW_STACK_DEPTH:
1328 *params = (GLdouble) ctx->ModelViewStackDepth;
1329 break;
1330 case GL_NAME_STACK_DEPTH:
1331 *params = (GLdouble) ctx->Select.NameStackDepth;
1332 break;
1333 case GL_NORMALIZE:
1334 *params = (GLdouble) ctx->Transform.Normalize;
1335 break;
1336 case GL_PACK_ALIGNMENT:
1337 *params = (GLdouble) ctx->Pack.Alignment;
1338 break;
1339 case GL_PACK_LSB_FIRST:
1340 *params = (GLdouble) ctx->Pack.LsbFirst;
1341 break;
1342 case GL_PACK_ROW_LENGTH:
1343 *params = (GLdouble) ctx->Pack.RowLength;
1344 break;
1345 case GL_PACK_SKIP_PIXELS:
1346 *params = (GLdouble) ctx->Pack.SkipPixels;
1347 break;
1348 case GL_PACK_SKIP_ROWS:
1349 *params = (GLdouble) ctx->Pack.SkipRows;
1350 break;
1351 case GL_PACK_SWAP_BYTES:
1352 *params = (GLdouble) ctx->Pack.SwapBytes;
1353 break;
1354 case GL_PERSPECTIVE_CORRECTION_HINT:
1355 *params = ENUM_TO_DOUBLE(ctx->Hint.PerspectiveCorrection);
1356 break;
1357 case GL_PIXEL_MAP_A_TO_A_SIZE:
1358 *params = (GLdouble) ctx->Pixel.MapAtoAsize;
1359 break;
1360 case GL_PIXEL_MAP_B_TO_B_SIZE:
1361 *params = (GLdouble) ctx->Pixel.MapBtoBsize;
1362 break;
1363 case GL_PIXEL_MAP_G_TO_G_SIZE:
1364 *params = (GLdouble) ctx->Pixel.MapGtoGsize;
1365 break;
1366 case GL_PIXEL_MAP_I_TO_A_SIZE:
1367 *params = (GLdouble) ctx->Pixel.MapItoAsize;
1368 break;
1369 case GL_PIXEL_MAP_I_TO_B_SIZE:
1370 *params = (GLdouble) ctx->Pixel.MapItoBsize;
1371 break;
1372 case GL_PIXEL_MAP_I_TO_G_SIZE:
1373 *params = (GLdouble) ctx->Pixel.MapItoGsize;
1374 break;
1375 case GL_PIXEL_MAP_I_TO_I_SIZE:
1376 *params = (GLdouble) ctx->Pixel.MapItoIsize;
1377 break;
1378 case GL_PIXEL_MAP_I_TO_R_SIZE:
1379 *params = (GLdouble) ctx->Pixel.MapItoRsize;
1380 break;
1381 case GL_PIXEL_MAP_R_TO_R_SIZE:
1382 *params = (GLdouble) ctx->Pixel.MapRtoRsize;
1383 break;
1384 case GL_PIXEL_MAP_S_TO_S_SIZE:
1385 *params = (GLdouble) ctx->Pixel.MapStoSsize;
1386 break;
1387 case GL_POINT_SIZE:
1388 *params = (GLdouble) ctx->Point.Size;
1389 break;
1390 case GL_POINT_SIZE_GRANULARITY:
1391 *params = (GLdouble) POINT_SIZE_GRANULARITY;
1392 break;
1393 case GL_POINT_SIZE_RANGE:
1394 params[0] = (GLdouble) MIN_POINT_SIZE;
1395 params[1] = (GLdouble) MAX_POINT_SIZE;
1396 break;
1397 case GL_POINT_SMOOTH:
1398 *params = (GLdouble) ctx->Point.SmoothFlag;
1399 break;
1400 case GL_POINT_SMOOTH_HINT:
1401 *params = ENUM_TO_DOUBLE(ctx->Hint.PointSmooth);
1402 break;
1403 case GL_POLYGON_MODE:
1404 params[0] = ENUM_TO_DOUBLE(ctx->Polygon.FrontMode);
1405 params[1] = ENUM_TO_DOUBLE(ctx->Polygon.BackMode);
1406 break;
1407 #ifdef GL_EXT_polygon_offset
1408 case GL_POLYGON_OFFSET_BIAS_EXT:
1409 *params = (GLdouble) ctx->Polygon.OffsetUnits;
1410 break;
1411 #endif
1412 case GL_POLYGON_OFFSET_FACTOR:
1413 *params = (GLdouble) ctx->Polygon.OffsetFactor;
1414 break;
1415 case GL_POLYGON_OFFSET_UNITS:
1416 *params = (GLdouble) ctx->Polygon.OffsetUnits;
1417 break;
1418 case GL_POLYGON_SMOOTH:
1419 *params = (GLdouble) ctx->Polygon.SmoothFlag;
1420 break;
1421 case GL_POLYGON_SMOOTH_HINT:
1422 *params = ENUM_TO_DOUBLE(ctx->Hint.PolygonSmooth);
1423 break;
1424 case GL_POLYGON_STIPPLE:
1425 for (i=0;i<32;i++) { /* RIGHT? */
1426 params[i] = (GLdouble) ctx->PolygonStipple[i];
1427 }
1428 break;
1429 case GL_PROJECTION_MATRIX:
1430 for (i=0;i<16;i++) {
1431 params[i] = (GLdouble) ctx->ProjectionMatrix[i];
1432 }
1433 break;
1434 case GL_PROJECTION_STACK_DEPTH:
1435 *params = (GLdouble) ctx->ProjectionStackDepth;
1436 break;
1437 case GL_READ_BUFFER:
1438 *params = ENUM_TO_DOUBLE(ctx->Pixel.ReadBuffer);
1439 break;
1440 case GL_RED_BIAS:
1441 *params = (GLdouble) ctx->Pixel.RedBias;
1442 break;
1443 case GL_RED_BITS:
1444 *params = (GLdouble) ctx->Visual->RedBits;
1445 break;
1446 case GL_RED_SCALE:
1447 *params = (GLdouble) ctx->Pixel.RedScale;
1448 break;
1449 case GL_RENDER_MODE:
1450 *params = ENUM_TO_DOUBLE(ctx->RenderMode);
1451 break;
1452 case GL_RGBA_MODE:
1453 *params = (GLdouble) ctx->Visual->RGBAflag;
1454 break;
1455 case GL_SCISSOR_BOX:
1456 params[0] = (GLdouble) ctx->Scissor.X;
1457 params[1] = (GLdouble) ctx->Scissor.Y;
1458 params[2] = (GLdouble) ctx->Scissor.Width;
1459 params[3] = (GLdouble) ctx->Scissor.Height;
1460 break;
1461 case GL_SCISSOR_TEST:
1462 *params = (GLdouble) ctx->Scissor.Enabled;
1463 break;
1464 case GL_SHADE_MODEL:
1465 *params = ENUM_TO_DOUBLE(ctx->Light.ShadeModel);
1466 break;
1467 case GL_STENCIL_BITS:
1468 *params = (GLdouble) ctx->Visual->StencilBits;
1469 break;
1470 case GL_STENCIL_CLEAR_VALUE:
1471 *params = (GLdouble) ctx->Stencil.Clear;
1472 break;
1473 case GL_STENCIL_FAIL:
1474 *params = ENUM_TO_DOUBLE(ctx->Stencil.FailFunc);
1475 break;
1476 case GL_STENCIL_FUNC:
1477 *params = ENUM_TO_DOUBLE(ctx->Stencil.Function);
1478 break;
1479 case GL_STENCIL_PASS_DEPTH_FAIL:
1480 *params = ENUM_TO_DOUBLE(ctx->Stencil.ZFailFunc);
1481 break;
1482 case GL_STENCIL_PASS_DEPTH_PASS:
1483 *params = ENUM_TO_DOUBLE(ctx->Stencil.ZPassFunc);
1484 break;
1485 case GL_STENCIL_REF:
1486 *params = (GLdouble) ctx->Stencil.Ref;
1487 break;
1488 case GL_STENCIL_TEST:
1489 *params = (GLdouble) ctx->Stencil.Enabled;
1490 break;
1491 case GL_STENCIL_VALUE_MASK:
1492 *params = (GLdouble) ctx->Stencil.ValueMask;
1493 break;
1494 case GL_STENCIL_WRITEMASK:
1495 *params = (GLdouble) ctx->Stencil.WriteMask;
1496 break;
1497 case GL_STEREO:
1498 *params = 0.0; /* TODO */
1499 break;
1500 case GL_SUBPIXEL_BITS:
1501 *params = 0.0; /* TODO */
1502 break;
1503 case GL_TEXTURE_1D:
1504 *params = (ctx->Texture.Enabled & TEXTURE_1D) ? 1.0 : 0.0;
1505 break;
1506 case GL_TEXTURE_2D:
1507 *params = (ctx->Texture.Enabled & TEXTURE_2D) ? 1.0 : 0.0;
1508 break;
1509 case GL_TEXTURE_ENV_COLOR:
1510 params[0] = (GLdouble) ctx->Texture.EnvColor[0];
1511 params[1] = (GLdouble) ctx->Texture.EnvColor[1];
1512 params[2] = (GLdouble) ctx->Texture.EnvColor[2];
1513 params[3] = (GLdouble) ctx->Texture.EnvColor[3];
1514 break;
1515 case GL_TEXTURE_ENV_MODE:
1516 *params = ENUM_TO_DOUBLE(ctx->Texture.EnvMode);
1517 break;
1518 case GL_TEXTURE_GEN_S:
1519 *params = (ctx->Texture.TexGenEnabled & S_BIT) ? 1.0 : 0.0;
1520 break;
1521 case GL_TEXTURE_GEN_T:
1522 *params = (ctx->Texture.TexGenEnabled & T_BIT) ? 1.0 : 0.0;
1523 break;
1524 case GL_TEXTURE_GEN_R:
1525 *params = (ctx->Texture.TexGenEnabled & R_BIT) ? 1.0 : 0.0;
1526 break;
1527 case GL_TEXTURE_GEN_Q:
1528 *params = (ctx->Texture.TexGenEnabled & Q_BIT) ? 1.0 : 0.0;
1529 break;
1530 case GL_TEXTURE_MATRIX:
1531 for (i=0;i<16;i++) {
1532 params[i] = (GLdouble) ctx->TextureMatrix[i];
1533 }
1534 break;
1535 case GL_TEXTURE_STACK_DEPTH:
1536 *params = (GLdouble) ctx->TextureStackDepth;
1537 break;
1538 case GL_UNPACK_ALIGNMENT:
1539 *params = (GLdouble) ctx->Unpack.Alignment;
1540 break;
1541 case GL_UNPACK_LSB_FIRST:
1542 *params = (GLdouble) ctx->Unpack.LsbFirst;
1543 break;
1544 case GL_UNPACK_ROW_LENGTH:
1545 *params = (GLdouble) ctx->Unpack.RowLength;
1546 break;
1547 case GL_UNPACK_SKIP_PIXELS:
1548 *params = (GLdouble) ctx->Unpack.SkipPixels;
1549 break;
1550 case GL_UNPACK_SKIP_ROWS:
1551 *params = (GLdouble) ctx->Unpack.SkipRows;
1552 break;
1553 case GL_UNPACK_SWAP_BYTES:
1554 *params = (GLdouble) ctx->Unpack.SwapBytes;
1555 break;
1556 case GL_VIEWPORT:
1557 params[0] = (GLdouble) ctx->Viewport.X;
1558 params[1] = (GLdouble) ctx->Viewport.Y;
1559 params[2] = (GLdouble) ctx->Viewport.Width;
1560 params[3] = (GLdouble) ctx->Viewport.Height;
1561 break;
1562 case GL_ZOOM_X:
1563 *params = (GLdouble) ctx->Pixel.ZoomX;
1564 break;
1565 case GL_ZOOM_Y:
1566 *params = (GLdouble) ctx->Pixel.ZoomY;
1567 break;
1568 case GL_VERTEX_ARRAY_SIZE:
1569 *params = (GLdouble) ctx->Array.VertexSize;
1570 break;
1571 case GL_VERTEX_ARRAY_TYPE:
1572 *params = ENUM_TO_DOUBLE(ctx->Array.VertexType);
1573 break;
1574 case GL_VERTEX_ARRAY_STRIDE:
1575 *params = (GLdouble) ctx->Array.VertexStride;
1576 break;
1577 case GL_VERTEX_ARRAY_COUNT_EXT:
1578 *params = 0.0;
1579 break;
1580 case GL_NORMAL_ARRAY_TYPE:
1581 *params = ENUM_TO_DOUBLE(ctx->Array.NormalType);
1582 break;
1583 case GL_NORMAL_ARRAY_STRIDE:
1584 *params = (GLdouble) ctx->Array.NormalStride;
1585 break;
1586 case GL_NORMAL_ARRAY_COUNT_EXT:
1587 *params = 0.0;
1588 break;
1589 case GL_COLOR_ARRAY_SIZE:
1590 *params = (GLdouble) ctx->Array.ColorSize;
1591 break;
1592 case GL_COLOR_ARRAY_TYPE:
1593 *params = ENUM_TO_DOUBLE(ctx->Array.ColorType);
1594 break;
1595 case GL_COLOR_ARRAY_STRIDE:
1596 *params = (GLdouble) ctx->Array.ColorStride;
1597 break;
1598 case GL_COLOR_ARRAY_COUNT_EXT:
1599 *params = 0.0;
1600 break;
1601 case GL_INDEX_ARRAY_TYPE:
1602 *params = ENUM_TO_DOUBLE(ctx->Array.IndexType);
1603 break;
1604 case GL_INDEX_ARRAY_STRIDE:
1605 *params = (GLdouble) ctx->Array.IndexStride;
1606 break;
1607 case GL_INDEX_ARRAY_COUNT_EXT:
1608 *params = 0.0;
1609 break;
1610 case GL_TEXTURE_COORD_ARRAY_SIZE:
1611 *params = (GLdouble) ctx->Array.TexCoordSize;
1612 break;
1613 case GL_TEXTURE_COORD_ARRAY_TYPE:
1614 *params = ENUM_TO_DOUBLE(ctx->Array.TexCoordType);
1615 break;
1616 case GL_TEXTURE_COORD_ARRAY_STRIDE:
1617 *params = (GLdouble) ctx->Array.TexCoordStride;
1618 break;
1619 case GL_TEXTURE_COORD_ARRAY_COUNT_EXT:
1620 *params = 0.0;
1621 break;
1622 case GL_EDGE_FLAG_ARRAY_STRIDE:
1623 *params = (GLdouble) ctx->Array.EdgeFlagStride;
1624 break;
1625 case GL_EDGE_FLAG_ARRAY_COUNT_EXT:
1626 *params = 0.0;
1627 break;
1628 case GL_TEXTURE_BINDING_1D:
1629 *params = (GLdouble) ctx->Texture.Current1D->Name;
1630 break;
1631 case GL_TEXTURE_BINDING_2D:
1632 *params = (GLdouble) ctx->Texture.Current2D->Name;
1633 break;
1634
1635 default:
1636 gl_error( ctx, GL_INVALID_ENUM, "glGetDoublev" );
1637 }
1638 }
1639
1640
1641
1642
1643 void gl_GetFloatv( GLcontext *ctx, GLenum pname, GLfloat *params )
1644 {
1645 GLuint i;
1646
1647 if (INSIDE_BEGIN_END(ctx)) {
1648 gl_error( ctx, GL_INVALID_OPERATION, "glGetFloatv" );
1649 return;
1650 }
1651 switch (pname) {
1652 case GL_ACCUM_RED_BITS:
1653 case GL_ACCUM_GREEN_BITS:
1654 case GL_ACCUM_BLUE_BITS:
1655 case GL_ACCUM_ALPHA_BITS:
1656 *params = (GLfloat) ctx->Visual->AccumBits;
1657 break;
1658 case GL_ACCUM_CLEAR_VALUE:
1659 params[0] = ctx->Accum.ClearColor[0];
1660 params[1] = ctx->Accum.ClearColor[1];
1661 params[2] = ctx->Accum.ClearColor[2];
1662 params[3] = ctx->Accum.ClearColor[3];
1663 break;
1664 case GL_ALPHA_BIAS:
1665 *params = ctx->Pixel.AlphaBias;
1666 break;
1667 case GL_ALPHA_BITS:
1668 *params = (GLfloat) ctx->Visual->AlphaBits;
1669 break;
1670 case GL_ALPHA_SCALE:
1671 *params = ctx->Pixel.AlphaScale;
1672 break;
1673 case GL_ALPHA_TEST:
1674 *params = (GLfloat) ctx->Color.AlphaEnabled;
1675 break;
1676 case GL_ALPHA_TEST_FUNC:
1677 *params = ENUM_TO_FLOAT(ctx->Color.AlphaFunc);
1678 break;
1679 case GL_ALPHA_TEST_REF:
1680 *params = (GLfloat) ctx->Color.AlphaRef;
1681 break;
1682 case GL_ATTRIB_STACK_DEPTH:
1683 *params = (GLfloat ) ctx->AttribStackDepth;
1684 break;
1685 case GL_AUTO_NORMAL:
1686 *params = (GLfloat) ctx->Eval.AutoNormal;
1687 break;
1688 case GL_AUX_BUFFERS:
1689 *params = (GLfloat) NUM_AUX_BUFFERS;
1690 break;
1691 case GL_BLEND:
1692 *params = (GLfloat) ctx->Color.BlendEnabled;
1693 break;
1694 case GL_BLEND_DST:
1695 *params = ENUM_TO_FLOAT(ctx->Color.BlendDst);
1696 break;
1697 case GL_BLEND_SRC:
1698 *params = ENUM_TO_FLOAT(ctx->Color.BlendSrc);
1699 break;
1700 case GL_BLUE_BIAS:
1701 *params = ctx->Pixel.BlueBias;
1702 break;
1703 case GL_BLUE_BITS:
1704 *params = (GLfloat) ctx->Visual->BlueBits;
1705 break;
1706 case GL_BLUE_SCALE:
1707 *params = ctx->Pixel.BlueScale;
1708 break;
1709 case GL_CLIENT_ATTRIB_STACK_DEPTH:
1710 *params = (GLfloat) ctx->ClientAttribStackDepth;
1711 break;
1712 case GL_CLIP_PLANE0:
1713 case GL_CLIP_PLANE1:
1714 case GL_CLIP_PLANE2:
1715 case GL_CLIP_PLANE3:
1716 case GL_CLIP_PLANE4:
1717 case GL_CLIP_PLANE5:
1718 *params = (GLfloat) ctx->Transform.ClipEnabled[pname-GL_CLIP_PLANE0];
1719 break;
1720 case GL_COLOR_CLEAR_VALUE:
1721 params[0] = (GLfloat) ctx->Color.ClearColor[0];
1722 params[1] = (GLfloat) ctx->Color.ClearColor[1];
1723 params[2] = (GLfloat) ctx->Color.ClearColor[2];
1724 params[3] = (GLfloat) ctx->Color.ClearColor[3];
1725 break;
1726 case GL_COLOR_MATERIAL:
1727 *params = (GLfloat) ctx->Light.ColorMaterialEnabled;
1728 break;
1729 case GL_COLOR_MATERIAL_FACE:
1730 *params = ENUM_TO_FLOAT(ctx->Light.ColorMaterialFace);
1731 break;
1732 case GL_COLOR_MATERIAL_PARAMETER:
1733 *params = ENUM_TO_FLOAT(ctx->Light.ColorMaterialMode);
1734 break;
1735 case GL_COLOR_WRITEMASK:
1736 params[0] = (ctx->Color.ColorMask & 8) ? 1.0F : 0.0F;
1737 params[1] = (ctx->Color.ColorMask & 4) ? 1.0F : 0.0F;
1738 params[2] = (ctx->Color.ColorMask & 2) ? 1.0F : 0.0F;
1739 params[3] = (ctx->Color.ColorMask & 1) ? 1.0F : 0.0F;
1740 break;
1741 case GL_CULL_FACE:
1742 *params = (GLfloat) ctx->Polygon.CullFlag;
1743 break;
1744 case GL_CULL_FACE_MODE:
1745 *params = ENUM_TO_FLOAT(ctx->Polygon.CullFaceMode);
1746 break;
1747 case GL_CURRENT_COLOR:
1748 params[0] = ctx->Current.ByteColor[0] * ctx->Visual->InvRedScale;
1749 params[1] = ctx->Current.ByteColor[1] * ctx->Visual->InvGreenScale;
1750 params[2] = ctx->Current.ByteColor[2] * ctx->Visual->InvBlueScale;
1751 params[3] = ctx->Current.ByteColor[3] * ctx->Visual->InvAlphaScale;
1752 break;
1753 case GL_CURRENT_INDEX:
1754 *params = (GLfloat) ctx->Current.Index;
1755 break;
1756 case GL_CURRENT_NORMAL:
1757 params[0] = ctx->Current.Normal[0];
1758 params[1] = ctx->Current.Normal[1];
1759 params[2] = ctx->Current.Normal[2];
1760 break;
1761 case GL_CURRENT_RASTER_COLOR:
1762 params[0] = ctx->Current.RasterColor[0];
1763 params[1] = ctx->Current.RasterColor[1];
1764 params[2] = ctx->Current.RasterColor[2];
1765 params[3] = ctx->Current.RasterColor[3];
1766 break;
1767 case GL_CURRENT_RASTER_DISTANCE:
1768 params[0] = ctx->Current.RasterDistance;
1769 break;
1770 case GL_CURRENT_RASTER_INDEX:
1771 *params = (GLfloat) ctx->Current.RasterIndex;
1772 break;
1773 case GL_CURRENT_RASTER_POSITION:
1774 params[0] = ctx->Current.RasterPos[0];
1775 params[1] = ctx->Current.RasterPos[1];
1776 params[2] = ctx->Current.RasterPos[2];
1777 params[3] = ctx->Current.RasterPos[3];
1778 break;
1779 case GL_CURRENT_RASTER_TEXTURE_COORDS:
1780 params[0] = ctx->Current.RasterTexCoord[0];
1781 params[1] = ctx->Current.RasterTexCoord[1];
1782 params[2] = ctx->Current.RasterTexCoord[2];
1783 params[3] = ctx->Current.RasterTexCoord[3];
1784 break;
1785 case GL_CURRENT_RASTER_POSITION_VALID:
1786 *params = (GLfloat) ctx->Current.RasterPosValid;
1787 break;
1788 case GL_CURRENT_TEXTURE_COORDS:
1789 params[0] = (GLfloat) ctx->Current.TexCoord[0];
1790 params[1] = (GLfloat) ctx->Current.TexCoord[1];
1791 params[2] = (GLfloat) ctx->Current.TexCoord[2];
1792 params[3] = (GLfloat) ctx->Current.TexCoord[3];
1793 break;
1794 case GL_DEPTH_BIAS:
1795 *params = (GLfloat) ctx->Pixel.DepthBias;
1796 break;
1797 case GL_DEPTH_BITS:
1798 *params = (GLfloat) ctx->Visual->DepthBits;
1799 break;
1800 case GL_DEPTH_CLEAR_VALUE:
1801 *params = (GLfloat) ctx->Depth.Clear;
1802 break;
1803 case GL_DEPTH_FUNC:
1804 *params = ENUM_TO_FLOAT(ctx->Depth.Func);
1805 break;
1806 case GL_DEPTH_RANGE:
1807 params[0] = (GLfloat) ctx->Viewport.Near;
1808 params[1] = (GLfloat) ctx->Viewport.Far;
1809 break;
1810 case GL_DEPTH_SCALE:
1811 *params = (GLfloat) ctx->Pixel.DepthScale;
1812 break;
1813 case GL_DEPTH_TEST:
1814 *params = (GLfloat) ctx->Depth.Test;
1815 break;
1816 case GL_DEPTH_WRITEMASK:
1817 *params = (GLfloat) ctx->Depth.Mask;
1818 break;
1819 case GL_DITHER:
1820 *params = (GLfloat) ctx->Color.DitherFlag;
1821 break;
1822 case GL_DOUBLEBUFFER:
1823 *params = (GLfloat) ctx->Visual->DBflag;
1824 break;
1825 case GL_DRAW_BUFFER:
1826 *params = ENUM_TO_FLOAT(ctx->Color.DrawBuffer);
1827 break;
1828 case GL_EDGE_FLAG:
1829 *params = (GLfloat) ctx->Current.EdgeFlag;
1830 break;
1831 case GL_FEEDBACK_BUFFER_SIZE:
1832 /* TODO: is this right? Or, return number of entries in buffer? */
1833 *params = (GLfloat) ctx->Feedback.BufferSize;
1834 break;
1835 case GL_FEEDBACK_BUFFER_TYPE:
1836 *params = ENUM_TO_FLOAT(ctx->Feedback.Type);
1837 break;
1838 case GL_FOG:
1839 *params = (GLfloat) ctx->Fog.Enabled;
1840 break;
1841 case GL_FOG_COLOR:
1842 params[0] = ctx->Fog.Color[0];
1843 params[1] = ctx->Fog.Color[1];
1844 params[2] = ctx->Fog.Color[2];
1845 params[3] = ctx->Fog.Color[3];
1846 break;
1847 case GL_FOG_DENSITY:
1848 *params = ctx->Fog.Density;
1849 break;
1850 case GL_FOG_END:
1851 *params = ctx->Fog.End;
1852 break;
1853 case GL_FOG_HINT:
1854 *params = ENUM_TO_FLOAT(ctx->Hint.Fog);
1855 break;
1856 case GL_FOG_INDEX:
1857 *params = ctx->Fog.Index;
1858 break;
1859 case GL_FOG_MODE:
1860 *params = ENUM_TO_FLOAT(ctx->Fog.Mode);
1861 break;
1862 case GL_FOG_START:
1863 *params = ctx->Fog.Start;
1864 break;
1865 case GL_FRONT_FACE:
1866 *params = ENUM_TO_FLOAT(ctx->Polygon.FrontFace);
1867 break;
1868 case GL_GREEN_BIAS:
1869 *params = (GLfloat) ctx->Pixel.GreenBias;
1870 break;
1871 case GL_GREEN_BITS:
1872 *params = (GLfloat) ctx->Visual->GreenBits;
1873 break;
1874 case GL_GREEN_SCALE:
1875 *params = (GLfloat) ctx->Pixel.GreenScale;
1876 break;
1877 case GL_INDEX_BITS:
1878 *params = (GLfloat) ctx->Visual->IndexBits;
1879 break;
1880 case GL_INDEX_CLEAR_VALUE:
1881 *params = (GLfloat) ctx->Color.ClearIndex;
1882 break;
1883 case GL_INDEX_MODE:
1884 *params = ctx->Visual->RGBAflag ? 0.0F : 1.0F;
1885 break;
1886 case GL_INDEX_OFFSET:
1887 *params = (GLfloat) ctx->Pixel.IndexOffset;
1888 break;
1889 case GL_INDEX_SHIFT:
1890 *params = (GLfloat) ctx->Pixel.IndexShift;
1891 break;
1892 case GL_INDEX_WRITEMASK:
1893 *params = (GLfloat) ctx->Color.IndexMask;
1894 break;
1895 case GL_LIGHT0:
1896 case GL_LIGHT1:
1897 case GL_LIGHT2:
1898 case GL_LIGHT3:
1899 case GL_LIGHT4:
1900 case GL_LIGHT5:
1901 case GL_LIGHT6:
1902 case GL_LIGHT7:
1903 *params = (GLfloat) ctx->Light.Light[pname-GL_LIGHT0].Enabled;
1904 break;
1905 case GL_LIGHTING:
1906 *params = (GLfloat) ctx->Light.Enabled;
1907 break;
1908 case GL_LIGHT_MODEL_AMBIENT:
1909 params[0] = ctx->Light.Model.Ambient[0];
1910 params[1] = ctx->Light.Model.Ambient[1];
1911 params[2] = ctx->Light.Model.Ambient[2];
1912 params[3] = ctx->Light.Model.Ambient[3];
1913 break;
1914 case GL_LIGHT_MODEL_LOCAL_VIEWER:
1915 *params = (GLfloat) ctx->Light.Model.LocalViewer;
1916 break;
1917 case GL_LIGHT_MODEL_TWO_SIDE:
1918 *params = (GLfloat) ctx->Light.Model.TwoSide;
1919 break;
1920 case GL_LINE_SMOOTH:
1921 *params = (GLfloat) ctx->Line.SmoothFlag;
1922 break;
1923 case GL_LINE_SMOOTH_HINT:
1924 *params = ENUM_TO_FLOAT(ctx->Hint.LineSmooth);
1925 break;
1926 case GL_LINE_STIPPLE:
1927 *params = (GLfloat) ctx->Line.StippleFlag;
1928 break;
1929 case GL_LINE_STIPPLE_PATTERN:
1930 *params = (GLfloat) ctx->Line.StipplePattern;
1931 break;
1932 case GL_LINE_STIPPLE_REPEAT:
1933 *params = (GLfloat) ctx->Line.StippleFactor;
1934 break;
1935 case GL_LINE_WIDTH:
1936 *params = (GLfloat) ctx->Line.Width;
1937 break;
1938 case GL_LINE_WIDTH_GRANULARITY:
1939 *params = (GLfloat) LINE_WIDTH_GRANULARITY;
1940 break;
1941 case GL_LINE_WIDTH_RANGE:
1942 params[0] = (GLfloat) MIN_LINE_WIDTH;
1943 params[1] = (GLfloat) MAX_LINE_WIDTH;
1944 break;
1945 case GL_LIST_BASE:
1946 *params = (GLfloat) ctx->List.ListBase;
1947 break;
1948 case GL_LIST_INDEX:
1949 *params = (GLfloat) ctx->CurrentListNum;
1950 break;
1951 case GL_LIST_MODE:
1952 *params = ctx->ExecuteFlag ? ENUM_TO_FLOAT(GL_COMPILE_AND_EXECUTE)
1953 : ENUM_TO_FLOAT(GL_COMPILE);
1954 break;
1955 case GL_INDEX_LOGIC_OP:
1956 *params = (GLfloat) ctx->Color.IndexLogicOpEnabled;
1957 break;
1958 case GL_COLOR_LOGIC_OP:
1959 *params = (GLfloat) ctx->Color.ColorLogicOpEnabled;
1960 break;
1961 case GL_LOGIC_OP_MODE:
1962 *params = ENUM_TO_FLOAT(ctx->Color.LogicOp);
1963 break;
1964 case GL_MAP1_COLOR_4:
1965 *params = (GLfloat) ctx->Eval.Map1Color4;
1966 break;
1967 case GL_MAP1_GRID_DOMAIN:
1968 params[0] = ctx->Eval.MapGrid1u1;
1969 params[1] = ctx->Eval.MapGrid1u2;
1970 break;
1971 case GL_MAP1_GRID_SEGMENTS:
1972 *params = (GLfloat) ctx->Eval.MapGrid1un;
1973 break;
1974 case GL_MAP1_INDEX:
1975 *params = (GLfloat) ctx->Eval.Map1Index;
1976 break;
1977 case GL_MAP1_NORMAL:
1978 *params = (GLfloat) ctx->Eval.Map1Normal;
1979 break;
1980 case GL_MAP1_TEXTURE_COORD_1:
1981 *params = (GLfloat) ctx->Eval.Map1TextureCoord1;
1982 break;
1983 case GL_MAP1_TEXTURE_COORD_2:
1984 *params = (GLfloat) ctx->Eval.Map1TextureCoord2;
1985 break;
1986 case GL_MAP1_TEXTURE_COORD_3:
1987 *params = (GLfloat) ctx->Eval.Map1TextureCoord3;
1988 break;
1989 case GL_MAP1_TEXTURE_COORD_4:
1990 *params = (GLfloat) ctx->Eval.Map1TextureCoord4;
1991 break;
1992 case GL_MAP1_VERTEX_3:
1993 *params = (GLfloat) ctx->Eval.Map1Vertex3;
1994 break;
1995 case GL_MAP1_VERTEX_4:
1996 *params = (GLfloat) ctx->Eval.Map1Vertex4;
1997 break;
1998 case GL_MAP2_COLOR_4:
1999 *params = (GLfloat) ctx->Eval.Map2Color4;
2000 break;
2001 case GL_MAP2_GRID_DOMAIN:
2002 params[0] = ctx->Eval.MapGrid2u1;
2003 params[1] = ctx->Eval.MapGrid2u2;
2004 params[2] = ctx->Eval.MapGrid2v1;
2005 params[3] = ctx->Eval.MapGrid2v2;
2006 break;
2007 case GL_MAP2_GRID_SEGMENTS:
2008 params[0] = (GLfloat) ctx->Eval.MapGrid2un;
2009 params[1] = (GLfloat) ctx->Eval.MapGrid2vn;
2010 break;
2011 case GL_MAP2_INDEX:
2012 *params = (GLfloat) ctx->Eval.Map2Index;
2013 break;
2014 case GL_MAP2_NORMAL:
2015 *params = (GLfloat) ctx->Eval.Map2Normal;
2016 break;
2017 case GL_MAP2_TEXTURE_COORD_1:
2018 *params = ctx->Eval.Map2TextureCoord1;
2019 break;
2020 case GL_MAP2_TEXTURE_COORD_2:
2021 *params = ctx->Eval.Map2TextureCoord2;
2022 break;
2023 case GL_MAP2_TEXTURE_COORD_3:
2024 *params = ctx->Eval.Map2TextureCoord3;
2025 break;
2026 case GL_MAP2_TEXTURE_COORD_4:
2027 *params = ctx->Eval.Map2TextureCoord4;
2028 break;
2029 case GL_MAP2_VERTEX_3:
2030 *params = (GLfloat) ctx->Eval.Map2Vertex3;
2031 break;
2032 case GL_MAP2_VERTEX_4:
2033 *params = (GLfloat) ctx->Eval.Map2Vertex4;
2034 break;
2035 case GL_MAP_COLOR:
2036 *params = (GLfloat) ctx->Pixel.MapColorFlag;
2037 break;
2038 case GL_MAP_STENCIL:
2039 *params = (GLfloat) ctx->Pixel.MapStencilFlag;
2040 break;
2041 case GL_MATRIX_MODE:
2042 *params = ENUM_TO_FLOAT(ctx->Transform.MatrixMode);
2043 break;
2044 case GL_MAX_ATTRIB_STACK_DEPTH:
2045 *params = (GLfloat) MAX_ATTRIB_STACK_DEPTH;
2046 break;
2047 case GL_MAX_CLIENT_ATTRIB_STACK_DEPTH:
2048 *params = (GLfloat) MAX_CLIENT_ATTRIB_STACK_DEPTH;
2049 break;
2050 case GL_MAX_CLIP_PLANES:
2051 *params = (GLfloat) MAX_CLIP_PLANES;
2052 break;
2053 case GL_MAX_EVAL_ORDER:
2054 *params = (GLfloat) MAX_EVAL_ORDER;
2055 break;
2056 case GL_MAX_LIGHTS:
2057 *params = (GLfloat) MAX_LIGHTS;
2058 break;
2059 case GL_MAX_LIST_NESTING:
2060 *params = (GLfloat) MAX_LIST_NESTING;
2061 break;
2062 case GL_MAX_MODELVIEW_STACK_DEPTH:
2063 *params = (GLfloat) MAX_MODELVIEW_STACK_DEPTH;
2064 break;
2065 case GL_MAX_NAME_STACK_DEPTH:
2066 *params = (GLfloat) MAX_NAME_STACK_DEPTH;
2067 break;
2068 case GL_MAX_PIXEL_MAP_TABLE:
2069 *params = (GLfloat) MAX_PIXEL_MAP_TABLE;
2070 break;
2071 case GL_MAX_PROJECTION_STACK_DEPTH:
2072 *params = (GLfloat) MAX_PROJECTION_STACK_DEPTH;
2073 break;
2074 case GL_MAX_TEXTURE_SIZE:
2075 *params = (GLfloat) MAX_TEXTURE_SIZE;
2076 break;
2077 case GL_MAX_TEXTURE_STACK_DEPTH:
2078 *params = (GLfloat) MAX_TEXTURE_STACK_DEPTH;
2079 break;
2080 case GL_MAX_VIEWPORT_DIMS:
2081 params[0] = (GLfloat) MAX_WIDTH;
2082 params[1] = (GLfloat) MAX_HEIGHT;
2083 break;
2084 case GL_MODELVIEW_MATRIX:
2085 for (i=0;i<16;i++) {
2086 params[i] = ctx->ModelViewMatrix[i];
2087 }
2088 break;
2089 case GL_MODELVIEW_STACK_DEPTH:
2090 *params = (GLfloat) ctx->ModelViewStackDepth;
2091 break;
2092 case GL_NAME_STACK_DEPTH:
2093 *params = (GLfloat) ctx->Select.NameStackDepth;
2094 break;
2095 case GL_NORMALIZE:
2096 *params = (GLfloat) ctx->Transform.Normalize;
2097 break;
2098 case GL_PACK_ALIGNMENT:
2099 *params = (GLfloat) ctx->Pack.Alignment;
2100 break;
2101 case GL_PACK_LSB_FIRST:
2102 *params = (GLfloat) ctx->Pack.LsbFirst;
2103 break;
2104 case GL_PACK_ROW_LENGTH:
2105 *params = (GLfloat) ctx->Pack.RowLength;
2106 break;
2107 case GL_PACK_SKIP_PIXELS:
2108 *params = (GLfloat) ctx->Pack.SkipPixels;
2109 break;
2110 case GL_PACK_SKIP_ROWS:
2111 *params = (GLfloat) ctx->Pack.SkipRows;
2112 break;
2113 case GL_PACK_SWAP_BYTES:
2114 *params = (GLfloat) ctx->Pack.SwapBytes;
2115 break;
2116 case GL_PERSPECTIVE_CORRECTION_HINT:
2117 *params = ENUM_TO_FLOAT(ctx->Hint.PerspectiveCorrection);
2118 break;
2119 case GL_PIXEL_MAP_A_TO_A_SIZE:
2120 *params = (GLfloat) ctx->Pixel.MapAtoAsize;
2121 break;
2122 case GL_PIXEL_MAP_B_TO_B_SIZE:
2123 *params = (GLfloat) ctx->Pixel.MapBtoBsize;
2124 break;
2125 case GL_PIXEL_MAP_G_TO_G_SIZE:
2126 *params = (GLfloat) ctx->Pixel.MapGtoGsize;
2127 break;
2128 case GL_PIXEL_MAP_I_TO_A_SIZE:
2129 *params = (GLfloat) ctx->Pixel.MapItoAsize;
2130 break;
2131 case GL_PIXEL_MAP_I_TO_B_SIZE:
2132 *params = (GLfloat) ctx->Pixel.MapItoBsize;
2133 break;
2134 case GL_PIXEL_MAP_I_TO_G_SIZE:
2135 *params = (GLfloat) ctx->Pixel.MapItoGsize;
2136 break;
2137 case GL_PIXEL_MAP_I_TO_I_SIZE:
2138 *params = (GLfloat) ctx->Pixel.MapItoIsize;
2139 break;
2140 case GL_PIXEL_MAP_I_TO_R_SIZE:
2141 *params = (GLfloat) ctx->Pixel.MapItoRsize;
2142 break;
2143 case GL_PIXEL_MAP_R_TO_R_SIZE:
2144 *params = (GLfloat) ctx->Pixel.MapRtoRsize;
2145 break;
2146 case GL_PIXEL_MAP_S_TO_S_SIZE:
2147 *params = (GLfloat) ctx->Pixel.MapStoSsize;
2148 break;
2149 case GL_POINT_SIZE:
2150 *params = (GLfloat) ctx->Point.Size;
2151 break;
2152 case GL_POINT_SIZE_GRANULARITY:
2153 *params = (GLfloat) POINT_SIZE_GRANULARITY;
2154 break;
2155 case GL_POINT_SIZE_RANGE:
2156 params[0] = (GLfloat) MIN_POINT_SIZE;
2157 params[1] = (GLfloat) MAX_POINT_SIZE;
2158 break;
2159 case GL_POINT_SMOOTH:
2160 *params = (GLfloat) ctx->Point.SmoothFlag;
2161 break;
2162 case GL_POINT_SMOOTH_HINT:
2163 *params = ENUM_TO_FLOAT(ctx->Hint.PointSmooth);
2164 break;
2165 case GL_POLYGON_MODE:
2166 params[0] = ENUM_TO_FLOAT(ctx->Polygon.FrontMode);
2167 params[1] = ENUM_TO_FLOAT(ctx->Polygon.BackMode);
2168 break;
2169 #ifdef GL_EXT_polygon_offset
2170 case GL_POLYGON_OFFSET_BIAS_EXT:
2171 *params = ctx->Polygon.OffsetUnits;
2172 break;
2173 #endif
2174 case GL_POLYGON_OFFSET_FACTOR:
2175 *params = ctx->Polygon.OffsetFactor;
2176 break;
2177 case GL_POLYGON_OFFSET_UNITS:
2178 *params = ctx->Polygon.OffsetUnits;
2179 break;
2180 case GL_POLYGON_SMOOTH:
2181 *params = (GLfloat) ctx->Polygon.SmoothFlag;
2182 break;
2183 case GL_POLYGON_SMOOTH_HINT:
2184 *params = ENUM_TO_FLOAT(ctx->Hint.PolygonSmooth);
2185 break;
2186 case GL_POLYGON_STIPPLE:
2187 for (i=0;i<32;i++) { /* RIGHT? */
2188 params[i] = (GLfloat) ctx->PolygonStipple[i];
2189 }
2190 break;
2191 case GL_PROJECTION_MATRIX:
2192 for (i=0;i<16;i++) {
2193 params[i] = ctx->ProjectionMatrix[i];
2194 }
2195 break;
2196 case GL_PROJECTION_STACK_DEPTH:
2197 *params = (GLfloat) ctx->ProjectionStackDepth;
2198 break;
2199 case GL_READ_BUFFER:
2200 *params = ENUM_TO_FLOAT(ctx->Pixel.ReadBuffer);
2201 break;
2202 case GL_RED_BIAS:
2203 *params = ctx->Pixel.RedBias;
2204 break;
2205 case GL_RED_BITS:
2206 *params = (GLfloat) ctx->Visual->RedBits;
2207 break;
2208 case GL_RED_SCALE:
2209 *params = ctx->Pixel.RedScale;
2210 break;
2211 case GL_RENDER_MODE:
2212 *params = ENUM_TO_FLOAT(ctx->RenderMode);
2213 break;
2214 case GL_RGBA_MODE:
2215 *params = (GLfloat) ctx->Visual->RGBAflag;
2216 break;
2217 case GL_SCISSOR_BOX:
2218 params[0] = (GLfloat) ctx->Scissor.X;
2219 params[1] = (GLfloat) ctx->Scissor.Y;
2220 params[2] = (GLfloat) ctx->Scissor.Width;
2221 params[3] = (GLfloat) ctx->Scissor.Height;
2222 break;
2223 case GL_SCISSOR_TEST:
2224 *params = (GLfloat) ctx->Scissor.Enabled;
2225 break;
2226 case GL_SHADE_MODEL:
2227 *params = ENUM_TO_FLOAT(ctx->Light.ShadeModel);
2228 break;
2229 case GL_STENCIL_BITS:
2230 *params = (GLfloat) ctx->Visual->StencilBits;
2231 break;
2232 case GL_STENCIL_CLEAR_VALUE:
2233 *params = (GLfloat) ctx->Stencil.Clear;
2234 break;
2235 case GL_STENCIL_FAIL:
2236 *params = ENUM_TO_FLOAT(ctx->Stencil.FailFunc);
2237 break;
2238 case GL_STENCIL_FUNC:
2239 *params = ENUM_TO_FLOAT(ctx->Stencil.Function);
2240 break;
2241 case GL_STENCIL_PASS_DEPTH_FAIL:
2242 *params = ENUM_TO_FLOAT(ctx->Stencil.ZFailFunc);
2243 break;
2244 case GL_STENCIL_PASS_DEPTH_PASS:
2245 *params = ENUM_TO_FLOAT(ctx->Stencil.ZPassFunc);
2246 break;
2247 case GL_STENCIL_REF:
2248 *params = (GLfloat) ctx->Stencil.Ref;
2249 break;
2250 case GL_STENCIL_TEST:
2251 *params = (GLfloat) ctx->Stencil.Enabled;
2252 break;
2253 case GL_STENCIL_VALUE_MASK:
2254 *params = (GLfloat) ctx->Stencil.ValueMask;
2255 break;
2256 case GL_STENCIL_WRITEMASK:
2257 *params = (GLfloat) ctx->Stencil.WriteMask;
2258 break;
2259 case GL_STEREO:
2260 *params = 0.0F; /* TODO */
2261 break;
2262 case GL_SUBPIXEL_BITS:
2263 *params = 0.0F; /* TODO */
2264 break;
2265 case GL_TEXTURE_1D:
2266 *params = (ctx->Texture.Enabled & TEXTURE_1D) ? 1.0 : 0.0;
2267 break;
2268 case GL_TEXTURE_2D:
2269 *params = (ctx->Texture.Enabled & TEXTURE_2D) ? 1.0 : 0.0;
2270 break;
2271 case GL_TEXTURE_ENV_COLOR:
2272 params[0] = ctx->Texture.EnvColor[0];
2273 params[1] = ctx->Texture.EnvColor[1];
2274 params[2] = ctx->Texture.EnvColor[2];
2275 params[3] = ctx->Texture.EnvColor[3];
2276 break;
2277 case GL_TEXTURE_ENV_MODE:
2278 *params = ENUM_TO_FLOAT(ctx->Texture.EnvMode);
2279 break;
2280 case GL_TEXTURE_GEN_S:
2281 *params = (ctx->Texture.TexGenEnabled & S_BIT) ? 1.0 : 0.0;
2282 break;
2283 case GL_TEXTURE_GEN_T:
2284 *params = (ctx->Texture.TexGenEnabled & T_BIT) ? 1.0 : 0.0;
2285 break;
2286 case GL_TEXTURE_GEN_R:
2287 *params = (ctx->Texture.TexGenEnabled & R_BIT) ? 1.0 : 0.0;
2288 break;
2289 case GL_TEXTURE_GEN_Q:
2290 *params = (ctx->Texture.TexGenEnabled & Q_BIT) ? 1.0 : 0.0;
2291 break;
2292 case GL_TEXTURE_MATRIX:
2293 for (i=0;i<16;i++) {
2294 params[i] = ctx->TextureMatrix[i];
2295 }
2296 break;
2297 case GL_TEXTURE_STACK_DEPTH:
2298 *params = (GLfloat) ctx->TextureStackDepth;
2299 break;
2300 case GL_UNPACK_ALIGNMENT:
2301 *params = (GLfloat) ctx->Unpack.Alignment;
2302 break;
2303 case GL_UNPACK_LSB_FIRST:
2304 *params = (GLfloat) ctx->Unpack.LsbFirst;
2305 break;
2306 case GL_UNPACK_ROW_LENGTH:
2307 *params = (GLfloat) ctx->Unpack.RowLength;
2308 break;
2309 case GL_UNPACK_SKIP_PIXELS:
2310 *params = (GLfloat) ctx->Unpack.SkipPixels;
2311 break;
2312 case GL_UNPACK_SKIP_ROWS:
2313 *params = (GLfloat) ctx->Unpack.SkipRows;
2314 break;
2315 case GL_UNPACK_SWAP_BYTES:
2316 *params = (GLfloat) ctx->Unpack.SwapBytes;
2317 break;
2318 case GL_VIEWPORT:
2319 params[0] = (GLfloat) ctx->Viewport.X;
2320 params[1] = (GLfloat) ctx->Viewport.Y;
2321 params[2] = (GLfloat) ctx->Viewport.Width;
2322 params[3] = (GLfloat) ctx->Viewport.Height;
2323 break;
2324 case GL_ZOOM_X:
2325 *params = (GLfloat) ctx->Pixel.ZoomX;
2326 break;
2327 case GL_ZOOM_Y:
2328 *params = (GLfloat) ctx->Pixel.ZoomY;
2329 break;
2330 case GL_VERTEX_ARRAY_SIZE:
2331 *params = (GLfloat) ctx->Array.VertexSize;
2332 break;
2333 case GL_VERTEX_ARRAY_TYPE:
2334 *params = ENUM_TO_FLOAT(ctx->Array.VertexType);
2335 break;
2336 case GL_VERTEX_ARRAY_STRIDE:
2337 *params = (GLfloat) ctx->Array.VertexStride;
2338 break;
2339 case GL_VERTEX_ARRAY_COUNT_EXT:
2340 *params = 0.0;
2341 break;
2342 case GL_NORMAL_ARRAY_TYPE:
2343 *params = ENUM_TO_FLOAT(ctx->Array.NormalType);
2344 break;
2345 case GL_NORMAL_ARRAY_STRIDE:
2346 *params = (GLfloat) ctx->Array.NormalStride;
2347 break;
2348 case GL_NORMAL_ARRAY_COUNT_EXT:
2349 *params = 0.0;
2350 break;
2351 case GL_COLOR_ARRAY_SIZE:
2352 *params = (GLfloat) ctx->Array.ColorSize;
2353 break;
2354 case GL_COLOR_ARRAY_TYPE:
2355 *params = ENUM_TO_FLOAT(ctx->Array.ColorType);
2356 break;
2357 case GL_COLOR_ARRAY_STRIDE:
2358 *params = (GLfloat) ctx->Array.ColorStride;
2359 break;
2360 case GL_COLOR_ARRAY_COUNT_EXT:
2361 *params = 0.0;
2362 break;
2363 case GL_INDEX_ARRAY_TYPE:
2364 *params = ENUM_TO_FLOAT(ctx->Array.IndexType);
2365 break;
2366 case GL_INDEX_ARRAY_STRIDE:
2367 *params = (GLfloat) ctx->Array.IndexStride;
2368 break;
2369 case GL_INDEX_ARRAY_COUNT_EXT:
2370 *params = 0.0;
2371 break;
2372 case GL_TEXTURE_COORD_ARRAY_SIZE:
2373 *params = (GLfloat) ctx->Array.TexCoordSize;
2374 break;
2375 case GL_TEXTURE_COORD_ARRAY_TYPE:
2376 *params = ENUM_TO_FLOAT(ctx->Array.TexCoordType);
2377 break;
2378 case GL_TEXTURE_COORD_ARRAY_STRIDE:
2379 *params = (GLfloat) ctx->Array.TexCoordStride;
2380 break;
2381 case GL_TEXTURE_COORD_ARRAY_COUNT_EXT:
2382 *params = 0.0;
2383 break;
2384 case GL_EDGE_FLAG_ARRAY_STRIDE:
2385 *params = (GLfloat) ctx->Array.EdgeFlagStride;
2386 break;
2387 case GL_EDGE_FLAG_ARRAY_COUNT_EXT:
2388 *params = 0.0;
2389 break;
2390 case GL_TEXTURE_BINDING_1D:
2391 *params = (GLfloat) ctx->Texture.Current1D->Name;
2392 break;
2393 case GL_TEXTURE_BINDING_2D:
2394 *params = (GLfloat) ctx->Texture.Current2D->Name;
2395 break;
2396 case GL_TEXTURE_3D_BINDING_EXT:
2397 *params = (GLfloat) ctx->Texture.Current2D->Name;
2398 break;
2399
2400 default:
2401 gl_error( ctx, GL_INVALID_ENUM, "glGetFloatv" );
2402 }
2403 }
2404
2405
2406
2407
2408 void gl_GetIntegerv( GLcontext *ctx, GLenum pname, GLint *params )
2409 {
2410 GLuint i;
2411
2412 if (INSIDE_BEGIN_END(ctx)) {
2413 gl_error( ctx, GL_INVALID_OPERATION, "glGetIntegerv" );
2414 return;
2415 }
2416 switch (pname) {
2417 case GL_ACCUM_RED_BITS:
2418 case GL_ACCUM_GREEN_BITS:
2419 case GL_ACCUM_BLUE_BITS:
2420 case GL_ACCUM_ALPHA_BITS:
2421 *params = (GLint) ctx->Visual->AccumBits;
2422 break;
2423 case GL_ACCUM_CLEAR_VALUE:
2424 params[0] = FLOAT_TO_INT( ctx->Accum.ClearColor[0] );
2425 params[1] = FLOAT_TO_INT( ctx->Accum.ClearColor[1] );
2426 params[2] = FLOAT_TO_INT( ctx->Accum.ClearColor[2] );
2427 params[3] = FLOAT_TO_INT( ctx->Accum.ClearColor[3] );
2428 break;
2429 case GL_ALPHA_BIAS:
2430 *params = (GLint) ctx->Pixel.AlphaBias;
2431 break;
2432 case GL_ALPHA_BITS:
2433 *params = ctx->Visual->AlphaBits;
2434 break;
2435 case GL_ALPHA_SCALE:
2436 *params = (GLint) ctx->Pixel.AlphaScale;
2437 break;
2438 case GL_ALPHA_TEST:
2439 *params = (GLint) ctx->Color.AlphaEnabled;
2440 break;
2441 case GL_ALPHA_TEST_REF:
2442 *params = FLOAT_TO_INT( ctx->Color.AlphaRef );
2443 break;
2444 case GL_ALPHA_TEST_FUNC:
2445 *params = (GLint) ctx->Color.AlphaFunc;
2446 break;
2447 case GL_ATTRIB_STACK_DEPTH:
2448 *params = (GLint) ctx->AttribStackDepth;
2449 break;
2450 case GL_AUTO_NORMAL:
2451 *params = (GLint) ctx->Eval.AutoNormal;
2452 break;
2453 case GL_AUX_BUFFERS:
2454 *params = (GLint) NUM_AUX_BUFFERS;
2455 break;
2456 case GL_BLEND:
2457 *params = (GLint) ctx->Color.BlendEnabled;
2458 break;
2459 case GL_BLEND_DST:
2460 *params = (GLint) ctx->Color.BlendDst;
2461 break;
2462 case GL_BLEND_SRC:
2463 *params = (GLint) ctx->Color.BlendSrc;
2464 break;
2465 case GL_BLUE_BIAS:
2466 *params = (GLint) ctx->Pixel.BlueBias;
2467 break;
2468 case GL_BLUE_BITS:
2469 *params = (GLint) ctx->Visual->BlueBits;
2470 break;
2471 case GL_BLUE_SCALE:
2472 *params = (GLint) ctx->Pixel.BlueScale;
2473 break;
2474 case GL_CLIENT_ATTRIB_STACK_DEPTH:
2475 *params = ctx->ClientAttribStackDepth;
2476 break;
2477 case GL_CLIP_PLANE0:
2478 case GL_CLIP_PLANE1:
2479 case GL_CLIP_PLANE2:
2480 case GL_CLIP_PLANE3:
2481 case GL_CLIP_PLANE4:
2482 case GL_CLIP_PLANE5:
2483 i = (GLint) (pname - GL_CLIP_PLANE0);
2484 *params = (GLint) ctx->Transform.ClipEnabled[i];
2485 break;
2486 case GL_COLOR_CLEAR_VALUE:
2487 params[0] = FLOAT_TO_INT( ctx->Color.ClearColor[0] );
2488 params[1] = FLOAT_TO_INT( ctx->Color.ClearColor[1] );
2489 params[2] = FLOAT_TO_INT( ctx->Color.ClearColor[2] );
2490 params[3] = FLOAT_TO_INT( ctx->Color.ClearColor[3] );
2491 break;
2492 case GL_COLOR_MATERIAL:
2493 *params = (GLint) ctx->Light.ColorMaterialEnabled;
2494 break;
2495 case GL_COLOR_MATERIAL_FACE:
2496 *params = (GLint) ctx->Light.ColorMaterialFace;
2497 break;
2498 case GL_COLOR_MATERIAL_PARAMETER:
2499 *params = (GLint) ctx->Light.ColorMaterialMode;
2500 break;
2501 case GL_COLOR_WRITEMASK:
2502 params[0] = (ctx->Color.ColorMask & 8) ? 1 : 0;
2503 params[1] = (ctx->Color.ColorMask & 4) ? 1 : 0;
2504 params[2] = (ctx->Color.ColorMask & 2) ? 1 : 0;
2505 params[3] = (ctx->Color.ColorMask & 1) ? 1 : 0;
2506 break;
2507 case GL_CULL_FACE:
2508 *params = (GLint) ctx->Polygon.CullFlag;
2509 break;
2510 case GL_CULL_FACE_MODE:
2511 *params = (GLint) ctx->Polygon.CullFaceMode;
2512 break;
2513 case GL_CURRENT_COLOR:
2514 params[0] = FLOAT_TO_INT( (ctx->Current.ByteColor[0]*ctx->Visual->InvRedScale) );
2515 params[1] = FLOAT_TO_INT( (ctx->Current.ByteColor[1]*ctx->Visual->InvGreenScale) );
2516 params[2] = FLOAT_TO_INT( (ctx->Current.ByteColor[2]*ctx->Visual->InvBlueScale) );
2517 params[3] = FLOAT_TO_INT( (ctx->Current.ByteColor[3]*ctx->Visual->InvAlphaScale) );
2518 break;
2519 case GL_CURRENT_INDEX:
2520 *params = (GLint) ctx->Current.Index;
2521 break;
2522 case GL_CURRENT_NORMAL:
2523 params[0] = FLOAT_TO_INT( ctx->Current.Normal[0] );
2524 params[1] = FLOAT_TO_INT( ctx->Current.Normal[1] );
2525 params[2] = FLOAT_TO_INT( ctx->Current.Normal[2] );
2526 break;
2527 case GL_CURRENT_RASTER_COLOR:
2528 params[0] = FLOAT_TO_INT( ctx->Current.RasterColor[0] );
2529 params[1] = FLOAT_TO_INT( ctx->Current.RasterColor[1] );
2530 params[2] = FLOAT_TO_INT( ctx->Current.RasterColor[2] );
2531 params[3] = FLOAT_TO_INT( ctx->Current.RasterColor[3] );
2532 break;
2533 case GL_CURRENT_RASTER_DISTANCE:
2534 params[0] = (GLint) ctx->Current.RasterDistance;
2535 break;
2536 case GL_CURRENT_RASTER_INDEX:
2537 *params = (GLint) ctx->Current.RasterIndex;
2538 break;
2539 case GL_CURRENT_RASTER_POSITION:
2540 params[0] = (GLint) ctx->Current.RasterPos[0];
2541 params[1] = (GLint) ctx->Current.RasterPos[1];
2542 params[2] = (GLint) ctx->Current.RasterPos[2];
2543 params[3] = (GLint) ctx->Current.RasterPos[3];
2544 break;
2545 case GL_CURRENT_RASTER_TEXTURE_COORDS:
2546 params[0] = (GLint) ctx->Current.RasterTexCoord[0];
2547 params[1] = (GLint) ctx->Current.RasterTexCoord[1];
2548 params[2] = (GLint) ctx->Current.RasterTexCoord[2];
2549 params[3] = (GLint) ctx->Current.RasterTexCoord[3];
2550 break;
2551 case GL_CURRENT_RASTER_POSITION_VALID:
2552 *params = (GLint) ctx->Current.RasterPosValid;
2553 break;
2554 case GL_CURRENT_TEXTURE_COORDS:
2555 params[0] = (GLint) ctx->Current.TexCoord[0];
2556 params[1] = (GLint) ctx->Current.TexCoord[1];
2557 params[2] = (GLint) ctx->Current.TexCoord[2];
2558 params[3] = (GLint) ctx->Current.TexCoord[3];
2559 break;
2560 case GL_DEPTH_BIAS:
2561 *params = (GLint) ctx->Pixel.DepthBias;
2562 break;
2563 case GL_DEPTH_BITS:
2564 *params = ctx->Visual->DepthBits;
2565 break;
2566 case GL_DEPTH_CLEAR_VALUE:
2567 *params = (GLint) ctx->Depth.Clear;
2568 break;
2569 case GL_DEPTH_FUNC:
2570 *params = (GLint) ctx->Depth.Func;
2571 break;
2572 case GL_DEPTH_RANGE:
2573 params[0] = (GLint) ctx->Viewport.Near;
2574 params[1] = (GLint) ctx->Viewport.Far;
2575 break;
2576 case GL_DEPTH_SCALE:
2577 *params = (GLint) ctx->Pixel.DepthScale;
2578 break;
2579 case GL_DEPTH_TEST:
2580 *params = (GLint) ctx->Depth.Test;
2581 break;
2582 case GL_DEPTH_WRITEMASK:
2583 *params = (GLint) ctx->Depth.Mask;
2584 break;
2585 case GL_DITHER:
2586 *params = (GLint) ctx->Color.DitherFlag;
2587 break;
2588 case GL_DOUBLEBUFFER:
2589 *params = (GLint) ctx->Visual->DBflag;
2590 break;
2591 case GL_DRAW_BUFFER:
2592 *params = (GLint) ctx->Color.DrawBuffer;
2593 break;
2594 case GL_EDGE_FLAG:
2595 *params = (GLint) ctx->Current.EdgeFlag;
2596 break;
2597 case GL_FEEDBACK_BUFFER_SIZE:
2598 /* TODO: is this right? Or, return number of entries in buffer? */
2599 *params = ctx->Feedback.BufferSize;
2600 break;
2601 case GL_FEEDBACK_BUFFER_TYPE:
2602 *params = ctx->Feedback.Type;
2603 break;
2604 case GL_FOG:
2605 *params = (GLint) ctx->Fog.Enabled;
2606 break;
2607 case GL_FOG_COLOR:
2608 params[0] = FLOAT_TO_INT( ctx->Fog.Color[0] );
2609 params[1] = FLOAT_TO_INT( ctx->Fog.Color[1] );
2610 params[2] = FLOAT_TO_INT( ctx->Fog.Color[2] );
2611 params[3] = FLOAT_TO_INT( ctx->Fog.Color[3] );
2612 break;
2613 case GL_FOG_DENSITY:
2614 *params = (GLint) ctx->Fog.Density;
2615 break;
2616 case GL_FOG_END:
2617 *params = (GLint) ctx->Fog.End;
2618 break;
2619 case GL_FOG_HINT:
2620 *params = (GLint) ctx->Hint.Fog;
2621 break;
2622 case GL_FOG_INDEX:
2623 *params = (GLint) ctx->Fog.Index;
2624 break;
2625 case GL_FOG_MODE:
2626 *params = (GLint) ctx->Fog.Mode;
2627 break;
2628 case GL_FOG_START:
2629 *params = (GLint) ctx->Fog.Start;
2630 break;
2631 case GL_FRONT_FACE:
2632 *params = (GLint) ctx->Polygon.FrontFace;
2633 break;
2634 case GL_GREEN_BIAS:
2635 *params = (GLint) ctx->Pixel.GreenBias;
2636 break;
2637 case GL_GREEN_BITS:
2638 *params = (GLint) ctx->Visual->GreenBits;
2639 break;
2640 case GL_GREEN_SCALE:
2641 *params = (GLint) ctx->Pixel.GreenScale;
2642 break;
2643 case GL_INDEX_BITS:
2644 *params = (GLint) ctx->Visual->IndexBits;
2645 break;
2646 case GL_INDEX_CLEAR_VALUE:
2647 *params = (GLint) ctx->Color.ClearIndex;
2648 break;
2649 case GL_INDEX_MODE:
2650 *params = ctx->Visual->RGBAflag ? 0 : 1;
2651 break;
2652 case GL_INDEX_OFFSET:
2653 *params = ctx->Pixel.IndexOffset;
2654 break;
2655 case GL_INDEX_SHIFT:
2656 *params = ctx->Pixel.IndexShift;
2657 break;
2658 case GL_INDEX_WRITEMASK:
2659 *params = (GLint) ctx->Color.IndexMask;
2660 break;
2661 case GL_LIGHT0:
2662 case GL_LIGHT1:
2663 case GL_LIGHT2:
2664 case GL_LIGHT3:
2665 case GL_LIGHT4:
2666 case GL_LIGHT5:
2667 case GL_LIGHT6:
2668 case GL_LIGHT7:
2669 *params = (GLint) ctx->Light.Light[pname-GL_LIGHT0].Enabled;
2670 break;
2671 case GL_LIGHTING:
2672 *params = (GLint) ctx->Light.Enabled;
2673 break;
2674 case GL_LIGHT_MODEL_AMBIENT:
2675 params[0] = FLOAT_TO_INT( ctx->Light.Model.Ambient[0] );
2676 params[1] = FLOAT_TO_INT( ctx->Light.Model.Ambient[1] );
2677 params[2] = FLOAT_TO_INT( ctx->Light.Model.Ambient[2] );
2678 params[3] = FLOAT_TO_INT( ctx->Light.Model.Ambient[3] );
2679 break;
2680 case GL_LIGHT_MODEL_LOCAL_VIEWER:
2681 *params = (GLint) ctx->Light.Model.LocalViewer;
2682 break;
2683 case GL_LIGHT_MODEL_TWO_SIDE:
2684 *params = (GLint) ctx->Light.Model.TwoSide;
2685 break;
2686 case GL_LINE_SMOOTH:
2687 *params = (GLint) ctx->Line.SmoothFlag;
2688 break;
2689 case GL_LINE_SMOOTH_HINT:
2690 *params = (GLint) ctx->Hint.LineSmooth;
2691 break;
2692 case GL_LINE_STIPPLE:
2693 *params = (GLint) ctx->Line.StippleFlag;
2694 break;
2695 case GL_LINE_STIPPLE_PATTERN:
2696 *params = (GLint) ctx->Line.StipplePattern;
2697 break;
2698 case GL_LINE_STIPPLE_REPEAT:
2699 *params = (GLint) ctx->Line.StippleFactor;
2700 break;
2701 case GL_LINE_WIDTH:
2702 *params = (GLint) ctx->Line.Width;
2703 break;
2704 case GL_LINE_WIDTH_GRANULARITY:
2705 *params = (GLint) LINE_WIDTH_GRANULARITY;
2706 break;
2707 case GL_LINE_WIDTH_RANGE:
2708 params[0] = (GLint) MIN_LINE_WIDTH;
2709 params[1] = (GLint) MAX_LINE_WIDTH;
2710 break;
2711 case GL_LIST_BASE:
2712 *params = (GLint) ctx->List.ListBase;
2713 break;
2714 case GL_LIST_INDEX:
2715 *params = (GLint) ctx->CurrentListNum;
2716 break;
2717 case GL_LIST_MODE:
2718 *params = ctx->ExecuteFlag ? (GLint) GL_COMPILE_AND_EXECUTE
2719 : (GLint) GL_COMPILE;
2720 break;
2721 case GL_INDEX_LOGIC_OP:
2722 *params = (GLint) ctx->Color.IndexLogicOpEnabled;
2723 break;
2724 case GL_COLOR_LOGIC_OP:
2725 *params = (GLint) ctx->Color.ColorLogicOpEnabled;
2726 break;
2727 case GL_LOGIC_OP_MODE:
2728 *params = (GLint) ctx->Color.LogicOp;
2729 break;
2730 case GL_MAP1_COLOR_4:
2731 *params = (GLint) ctx->Eval.Map1Color4;
2732 break;
2733 case GL_MAP1_GRID_DOMAIN:
2734 params[0] = (GLint) ctx->Eval.MapGrid1u1;
2735 params[1] = (GLint) ctx->Eval.MapGrid1u2;
2736 break;
2737 case GL_MAP1_GRID_SEGMENTS:
2738 *params = (GLint) ctx->Eval.MapGrid1un;
2739 break;
2740 case GL_MAP1_INDEX:
2741 *params = (GLint) ctx->Eval.Map1Index;
2742 break;
2743 case GL_MAP1_NORMAL:
2744 *params = (GLint) ctx->Eval.Map1Normal;
2745 break;
2746 case GL_MAP1_TEXTURE_COORD_1:
2747 *params = (GLint) ctx->Eval.Map1TextureCoord1;
2748 break;
2749 case GL_MAP1_TEXTURE_COORD_2:
2750 *params = (GLint) ctx->Eval.Map1TextureCoord2;
2751 break;
2752 case GL_MAP1_TEXTURE_COORD_3:
2753 *params = (GLint) ctx->Eval.Map1TextureCoord3;
2754 break;
2755 case GL_MAP1_TEXTURE_COORD_4:
2756 *params = (GLint) ctx->Eval.Map1TextureCoord4;
2757 break;
2758 case GL_MAP1_VERTEX_3:
2759 *params = (GLint) ctx->Eval.Map1Vertex3;
2760 break;
2761 case GL_MAP1_VERTEX_4:
2762 *params = (GLint) ctx->Eval.Map1Vertex4;
2763 break;
2764 case GL_MAP2_COLOR_4:
2765 *params = (GLint) ctx->Eval.Map2Color4;
2766 break;
2767 case GL_MAP2_GRID_DOMAIN:
2768 params[0] = (GLint) ctx->Eval.MapGrid2u1;
2769 params[1] = (GLint) ctx->Eval.MapGrid2u2;
2770 params[2] = (GLint) ctx->Eval.MapGrid2v1;
2771 params[3] = (GLint) ctx->Eval.MapGrid2v2;
2772 break;
2773 case GL_MAP2_GRID_SEGMENTS:
2774 params[0] = (GLint) ctx->Eval.MapGrid2un;
2775 params[1] = (GLint) ctx->Eval.MapGrid2vn;
2776 break;
2777 case GL_MAP2_INDEX:
2778 *params = (GLint) ctx->Eval.Map2Index;
2779 break;
2780 case GL_MAP2_NORMAL:
2781 *params = (GLint) ctx->Eval.Map2Normal;
2782 break;
2783 case GL_MAP2_TEXTURE_COORD_1:
2784 *params = (GLint) ctx->Eval.Map2TextureCoord1;
2785 break;
2786 case GL_MAP2_TEXTURE_COORD_2:
2787 *params = (GLint) ctx->Eval.Map2TextureCoord2;
2788 break;
2789 case GL_MAP2_TEXTURE_COORD_3:
2790 *params = (GLint) ctx->Eval.Map2TextureCoord3;
2791 break;
2792 case GL_MAP2_TEXTURE_COORD_4:
2793 *params = (GLint) ctx->Eval.Map2TextureCoord4;
2794 break;
2795 case GL_MAP2_VERTEX_3:
2796 *params = (GLint) ctx->Eval.Map2Vertex3;
2797 break;
2798 case GL_MAP2_VERTEX_4:
2799 *params = (GLint) ctx->Eval.Map2Vertex4;
2800 break;
2801 case GL_MAP_COLOR:
2802 *params = (GLint) ctx->Pixel.MapColorFlag;
2803 break;
2804 case GL_MAP_STENCIL:
2805 *params = (GLint) ctx->Pixel.MapStencilFlag;
2806 break;
2807 case GL_MATRIX_MODE:
2808 *params = (GLint) ctx->Transform.MatrixMode;
2809 break;
2810 case GL_MAX_ATTRIB_STACK_DEPTH:
2811 *params = (GLint) MAX_ATTRIB_STACK_DEPTH;
2812 break;
2813 case GL_MAX_CLIENT_ATTRIB_STACK_DEPTH:
2814 *params = (GLint) MAX_CLIENT_ATTRIB_STACK_DEPTH;
2815 break;
2816 case GL_MAX_CLIP_PLANES:
2817 *params = (GLint) MAX_CLIP_PLANES;
2818 break;
2819 case GL_MAX_EVAL_ORDER:
2820 *params = (GLint) MAX_EVAL_ORDER;
2821 break;
2822 case GL_MAX_LIGHTS:
2823 *params = (GLint) MAX_LIGHTS;
2824 break;
2825 case GL_MAX_LIST_NESTING:
2826 *params = (GLint) MAX_LIST_NESTING;
2827 break;
2828 case GL_MAX_MODELVIEW_STACK_DEPTH:
2829 *params = (GLint) MAX_MODELVIEW_STACK_DEPTH;
2830 break;
2831 case GL_MAX_NAME_STACK_DEPTH:
2832 *params = (GLint) MAX_NAME_STACK_DEPTH;
2833 break;
2834 case GL_MAX_PIXEL_MAP_TABLE:
2835 *params = (GLint) MAX_PIXEL_MAP_TABLE;
2836 break;
2837 case GL_MAX_PROJECTION_STACK_DEPTH:
2838 *params = (GLint) MAX_PROJECTION_STACK_DEPTH;
2839 break;
2840 case GL_MAX_TEXTURE_SIZE:
2841 *params = (GLint) MAX_TEXTURE_SIZE;
2842 break;
2843 case GL_MAX_TEXTURE_STACK_DEPTH:
2844 *params = (GLint) MAX_TEXTURE_STACK_DEPTH;
2845 break;
2846 case GL_MAX_VIEWPORT_DIMS:
2847 params[0] = (GLint) MAX_WIDTH;
2848 params[1] = (GLint) MAX_HEIGHT;
2849 break;
2850 case GL_MODELVIEW_MATRIX:
2851 for (i=0;i<16;i++) {
2852 params[i] = (GLint) ctx->ModelViewMatrix[i];
2853 }
2854 break;
2855 case GL_MODELVIEW_STACK_DEPTH:
2856 *params = (GLint) ctx->ModelViewStackDepth;
2857 break;
2858 case GL_NAME_STACK_DEPTH:
2859 *params = (GLint) ctx->Select.NameStackDepth;
2860 break;
2861 case GL_NORMALIZE:
2862 *params = (GLint) ctx->Transform.Normalize;
2863 break;
2864 case GL_PACK_ALIGNMENT:
2865 *params = ctx->Pack.Alignment;
2866 break;
2867 case GL_PACK_LSB_FIRST:
2868 *params = (GLint) ctx->Pack.LsbFirst;
2869 break;
2870 case GL_PACK_ROW_LENGTH:
2871 *params = ctx->Pack.RowLength;
2872 break;
2873 case GL_PACK_SKIP_PIXELS:
2874 *params = ctx->Pack.SkipPixels;
2875 break;
2876 case GL_PACK_SKIP_ROWS:
2877 *params = ctx->Pack.SkipRows;
2878 break;
2879 case GL_PACK_SWAP_BYTES:
2880 *params = (GLint) ctx->Pack.SwapBytes;
2881 break;
2882 case GL_PERSPECTIVE_CORRECTION_HINT:
2883 *params = (GLint) ctx->Hint.PerspectiveCorrection;
2884 break;
2885 case GL_PIXEL_MAP_A_TO_A_SIZE:
2886 *params = ctx->Pixel.MapAtoAsize;
2887 break;
2888 case GL_PIXEL_MAP_B_TO_B_SIZE:
2889 *params = ctx->Pixel.MapBtoBsize;
2890 break;
2891 case GL_PIXEL_MAP_G_TO_G_SIZE:
2892 *params = ctx->Pixel.MapGtoGsize;
2893 break;
2894 case GL_PIXEL_MAP_I_TO_A_SIZE:
2895 *params = ctx->Pixel.MapItoAsize;
2896 break;
2897 case GL_PIXEL_MAP_I_TO_B_SIZE:
2898 *params = ctx->Pixel.MapItoBsize;
2899 break;
2900 case GL_PIXEL_MAP_I_TO_G_SIZE:
2901 *params = ctx->Pixel.MapItoGsize;
2902 break;
2903 case GL_PIXEL_MAP_I_TO_I_SIZE:
2904 *params = ctx->Pixel.MapItoIsize;
2905 break;
2906 case GL_PIXEL_MAP_I_TO_R_SIZE:
2907 *params = ctx->Pixel.MapItoRsize;
2908 break;
2909 case GL_PIXEL_MAP_R_TO_R_SIZE:
2910 *params = ctx->Pixel.MapRtoRsize;
2911 break;
2912 case GL_PIXEL_MAP_S_TO_S_SIZE:
2913 *params = ctx->Pixel.MapStoSsize;
2914 break;
2915 case GL_POINT_SIZE:
2916 *params = (GLint) ctx->Point.Size;
2917 break;
2918 case GL_POINT_SIZE_GRANULARITY:
2919 *params = (GLint) POINT_SIZE_GRANULARITY;
2920 break;
2921 case GL_POINT_SIZE_RANGE:
2922 params[0] = (GLint) MIN_POINT_SIZE;
2923 params[1] = (GLint) MAX_POINT_SIZE;
2924 break;
2925 case GL_POINT_SMOOTH:
2926 *params = (GLint) ctx->Point.SmoothFlag;
2927 break;
2928 case GL_POINT_SMOOTH_HINT:
2929 *params = (GLint) ctx->Hint.PointSmooth;
2930 break;
2931 case GL_POLYGON_MODE:
2932 params[0] = (GLint) ctx->Polygon.FrontMode;
2933 params[1] = (GLint) ctx->Polygon.BackMode;
2934 break;
2935 #ifdef GL_EXT_polygon_offset
2936 case GL_POLYGON_OFFSET_BIAS_EXT:
2937 *params = (GLint) ctx->Polygon.OffsetUnits;
2938 break;
2939 #endif
2940 case GL_POLYGON_OFFSET_FACTOR:
2941 *params = (GLint) ctx->Polygon.OffsetFactor;
2942 break;
2943 case GL_POLYGON_OFFSET_UNITS:
2944 *params = (GLint) ctx->Polygon.OffsetUnits;
2945 break;
2946 case GL_POLYGON_SMOOTH:
2947 *params = (GLint) ctx->Polygon.SmoothFlag;
2948 break;
2949 case GL_POLYGON_SMOOTH_HINT:
2950 *params = (GLint) ctx->Hint.PolygonSmooth;
2951 break;
2952 case GL_POLYGON_STIPPLE:
2953 for (i=0;i<32;i++) { /* RIGHT? */
2954 params[i] = (GLint) ctx->PolygonStipple[i];
2955 }
2956 break;
2957 case GL_PROJECTION_MATRIX:
2958 for (i=0;i<16;i++) {
2959 params[i] = (GLint) ctx->ProjectionMatrix[i];
2960 }
2961 break;
2962 case GL_PROJECTION_STACK_DEPTH:
2963 *params = (GLint) ctx->ProjectionStackDepth;
2964 break;
2965 case GL_READ_BUFFER:
2966 *params = (GLint) ctx->Pixel.ReadBuffer;
2967 break;
2968 case GL_RED_BIAS:
2969 *params = (GLint) ctx->Pixel.RedBias;
2970 break;
2971 case GL_RED_BITS:
2972 *params = (GLint) ctx->Visual->RedBits;
2973 break;
2974 case GL_RED_SCALE:
2975 *params = (GLint) ctx->Pixel.RedScale;
2976 break;
2977 case GL_RENDER_MODE:
2978 *params = (GLint) ctx->RenderMode;
2979 break;
2980 case GL_RGBA_MODE:
2981 *params = (GLint) ctx->Visual->RGBAflag;
2982 break;
2983 case GL_SCISSOR_BOX:
2984 params[0] = (GLint) ctx->Scissor.X;
2985 params[1] = (GLint) ctx->Scissor.Y;
2986 params[2] = (GLint) ctx->Scissor.Width;
2987 params[3] = (GLint) ctx->Scissor.Height;
2988 break;
2989 case GL_SCISSOR_TEST:
2990 *params = (GLint) ctx->Scissor.Enabled;
2991 break;
2992 case GL_SHADE_MODEL:
2993 *params = (GLint) ctx->Light.ShadeModel;
2994 break;
2995 case GL_STENCIL_BITS:
2996 *params = ctx->Visual->StencilBits;
2997 break;
2998 case GL_STENCIL_CLEAR_VALUE:
2999 *params = (GLint) ctx->Stencil.Clear;
3000 break;
3001 case GL_STENCIL_FAIL:
3002 *params = (GLint) ctx->Stencil.FailFunc;
3003 break;
3004 case GL_STENCIL_FUNC:
3005 *params = (GLint) ctx->Stencil.Function;
3006 break;
3007 case GL_STENCIL_PASS_DEPTH_FAIL:
3008 *params = (GLint) ctx->Stencil.ZFailFunc;
3009 break;
3010 case GL_STENCIL_PASS_DEPTH_PASS:
3011 *params = (GLint) ctx->Stencil.ZPassFunc;
3012 break;
3013 case GL_STENCIL_REF:
3014 *params = (GLint) ctx->Stencil.Ref;
3015 break;
3016 case GL_STENCIL_TEST:
3017 *params = (GLint) ctx->Stencil.Enabled;
3018 break;
3019 case GL_STENCIL_VALUE_MASK:
3020 *params = (GLint) ctx->Stencil.ValueMask;
3021 break;
3022 case GL_STENCIL_WRITEMASK:
3023 *params = (GLint) ctx->Stencil.WriteMask;
3024 break;
3025 case GL_STEREO:
3026 *params = 0; /* TODO */
3027 break;
3028 case GL_SUBPIXEL_BITS:
3029 *params = 0; /* TODO */
3030 break;
3031 case GL_TEXTURE_1D:
3032 *params = (ctx->Texture.Enabled & TEXTURE_1D) ? 1.0 : 0.0;
3033 break;
3034 case GL_TEXTURE_2D:
3035 *params = (ctx->Texture.Enabled & TEXTURE_2D) ? 1.0 : 0.0;
3036 break;
3037 case GL_TEXTURE_ENV_COLOR:
3038 params[0] = FLOAT_TO_INT( ctx->Texture.EnvColor[0] );
3039 params[1] = FLOAT_TO_INT( ctx->Texture.EnvColor[1] );
3040 params[2] = FLOAT_TO_INT( ctx->Texture.EnvColor[2] );
3041 params[3] = FLOAT_TO_INT( ctx->Texture.EnvColor[3] );
3042 break;
3043 case GL_TEXTURE_ENV_MODE:
3044 *params = (GLint) ctx->Texture.EnvMode;
3045 break;
3046 case GL_TEXTURE_GEN_S:
3047 *params = (ctx->Texture.TexGenEnabled & S_BIT) ? 1 : 0;
3048 break;
3049 case GL_TEXTURE_GEN_T:
3050 *params = (ctx->Texture.TexGenEnabled & T_BIT) ? 1 : 0;
3051 break;
3052 case GL_TEXTURE_GEN_R:
3053 *params = (ctx->Texture.TexGenEnabled & R_BIT) ? 1 : 0;
3054 break;
3055 case GL_TEXTURE_GEN_Q:
3056 *params = (ctx->Texture.TexGenEnabled & Q_BIT) ? 1 : 0;
3057 break;
3058 case GL_TEXTURE_MATRIX:
3059 for (i=0;i<16;i++) {
3060 params[i] = (GLint) ctx->TextureMatrix[i];
3061 }
3062 break;
3063 case GL_TEXTURE_STACK_DEPTH:
3064 *params = (GLint) ctx->TextureStackDepth;
3065 break;
3066 case GL_UNPACK_ALIGNMENT:
3067 *params = ctx->Unpack.Alignment;
3068 break;
3069 case GL_UNPACK_LSB_FIRST:
3070 *params = (GLint) ctx->Unpack.LsbFirst;
3071 break;
3072 case GL_UNPACK_ROW_LENGTH:
3073 *params = ctx->Unpack.RowLength;
3074 break;
3075 case GL_UNPACK_SKIP_PIXELS:
3076 *params = ctx->Unpack.SkipPixels;
3077 break;
3078 case GL_UNPACK_SKIP_ROWS:
3079 *params = ctx->Unpack.SkipRows;
3080 break;
3081 case GL_UNPACK_SWAP_BYTES:
3082 *params = (GLint) ctx->Unpack.SwapBytes;
3083 break;
3084 case GL_VIEWPORT:
3085 params[0] = (GLint) ctx->Viewport.X;
3086 params[1] = (GLint) ctx->Viewport.Y;
3087 params[2] = (GLint) ctx->Viewport.Width;
3088 params[3] = (GLint) ctx->Viewport.Height;
3089 break;
3090 case GL_ZOOM_X:
3091 *params = (GLint) ctx->Pixel.ZoomX;
3092 break;
3093 case GL_ZOOM_Y:
3094 *params = (GLint) ctx->Pixel.ZoomY;
3095 break;
3096 case GL_VERTEX_ARRAY_SIZE:
3097 *params = ctx->Array.VertexSize;
3098 break;
3099 case GL_VERTEX_ARRAY_TYPE:
3100 *params = ctx->Array.VertexType;
3101 break;
3102 case GL_VERTEX_ARRAY_STRIDE:
3103 *params = ctx->Array.VertexStride;
3104 break;
3105 case GL_VERTEX_ARRAY_COUNT_EXT:
3106 *params = 0;
3107 break;
3108 case GL_NORMAL_ARRAY_TYPE:
3109 *params = ctx->Array.NormalType;
3110 break;
3111 case GL_NORMAL_ARRAY_STRIDE:
3112 *params = ctx->Array.NormalStride;
3113 break;
3114 case GL_NORMAL_ARRAY_COUNT_EXT:
3115 *params = 0;
3116 break;
3117 case GL_COLOR_ARRAY_SIZE:
3118 *params = ctx->Array.ColorSize;
3119 break;
3120 case GL_COLOR_ARRAY_TYPE:
3121 *params = ctx->Array.ColorType;
3122 break;
3123 case GL_COLOR_ARRAY_STRIDE:
3124 *params = ctx->Array.ColorStride;
3125 break;
3126 case GL_COLOR_ARRAY_COUNT_EXT:
3127 *params = 0;
3128 break;
3129 case GL_INDEX_ARRAY_TYPE:
3130 *params = ctx->Array.IndexType;
3131 break;
3132 case GL_INDEX_ARRAY_STRIDE:
3133 *params = ctx->Array.IndexStride;
3134 break;
3135 case GL_INDEX_ARRAY_COUNT_EXT:
3136 *params = 0;
3137 break;
3138 case GL_TEXTURE_COORD_ARRAY_SIZE:
3139 *params = ctx->Array.TexCoordSize;
3140 break;
3141 case GL_TEXTURE_COORD_ARRAY_TYPE:
3142 *params = ctx->Array.TexCoordType;
3143 break;
3144 case GL_TEXTURE_COORD_ARRAY_STRIDE:
3145 *params = ctx->Array.TexCoordStride;
3146 break;
3147 case GL_TEXTURE_COORD_ARRAY_COUNT_EXT:
3148 *params = 0;
3149 break;
3150 case GL_EDGE_FLAG_ARRAY_STRIDE:
3151 *params = ctx->Array.EdgeFlagStride;
3152 break;
3153 case GL_EDGE_FLAG_ARRAY_COUNT_EXT:
3154 *params = 0;
3155 break;
3156 case GL_TEXTURE_BINDING_1D:
3157 *params = ctx->Texture.Current1D->Name;
3158 break;
3159 case GL_TEXTURE_BINDING_2D:
3160 *params = ctx->Texture.Current2D->Name;
3161 break;
3162
3163 default:
3164 gl_error( ctx, GL_INVALID_ENUM, "glGetIntegerv" );
3165 }
3166 }
3167
3168
3169
3170 void gl_GetPointerv( GLcontext *ctx, GLenum pname, GLvoid **params )
3171 {
3172 switch (pname) {
3173 case GL_VERTEX_ARRAY_POINTER:
3174 *params = ctx->Array.VertexPtr;
3175 break;
3176 case GL_NORMAL_ARRAY_POINTER:
3177 *params = ctx->Array.NormalPtr;
3178 break;
3179 case GL_COLOR_ARRAY_POINTER:
3180 *params = ctx->Array.ColorPtr;
3181 break;
3182 case GL_INDEX_ARRAY_POINTER:
3183 *params = ctx->Array.IndexPtr;
3184 break;
3185 case GL_TEXTURE_COORD_ARRAY_POINTER:
3186 *params = ctx->Array.TexCoordPtr;
3187 break;
3188 case GL_EDGE_FLAG_ARRAY_POINTER:
3189 *params = ctx->Array.EdgeFlagPtr;
3190 break;
3191 case GL_FEEDBACK_BUFFER_POINTER:
3192 *params = ctx->Feedback.Buffer;
3193 break;
3194 default:
3195 gl_error( ctx, GL_INVALID_ENUM, "glGetPointerv" );
3196 return;
3197 }
3198 }
A free Windows-compatible Operating System