Context Navigation

source: trunk/src/opengl/mesa/get.c@ 2962

Visit:

Last change on this file since 2962 was 2962, checked in by jeroen, 25 years ago
* empty log message *
File size: 118.2 KB

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

Note: See TracBrowser for help on using the repository browser.

Download in other formats: