WebSVN – Kolibri OS – Blame – /programs/develop/libraries/Mesa/src/mesa/main/get.c

Rev	Author	Line No.	Line
1901	serge	1	/*
		2	* Copyright (C) 2010 Brian Paul All Rights Reserved.
		3	* Copyright (C) 2010 Intel Corporation
		4	*
		5	* Permission is hereby granted, free of charge, to any person obtaining a
		6	* copy of this software and associated documentation files (the "Software"),
		7	* to deal in the Software without restriction, including without limitation
		8	* the rights to use, copy, modify, merge, publish, distribute, sublicense,
		9	* and/or sell copies of the Software, and to permit persons to whom the
		10	* Software is furnished to do so, subject to the following conditions:
		11	*
		12	* The above copyright notice and this permission notice shall be included
		13	* in all copies or substantial portions of the Software.
		14	*
		15	* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
		16	* OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
		17	* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
		18	* BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
		19	* AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
		20	* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
		21	*
		22	* Author: Kristian Høgsberg
		23	*/
		24
		25	#include "glheader.h"
		26	#include "context.h"
		27	#include "enable.h"
		28	#include "enums.h"
		29	#include "extensions.h"
		30	#include "get.h"
		31	#include "macros.h"
		32	#include "mtypes.h"
		33	#include "state.h"
		34	#include "texcompress.h"
		35	#include "framebuffer.h"
		36
		37	/* This is a table driven implemetation of the glGet*v() functions.
		38	* The basic idea is that most getters just look up an int somewhere
		39	* in struct gl_context and then convert it to a bool or float according to
		40	* which of glGetIntegerv() glGetBooleanv() etc is being called.
		41	* Instead of generating code to do this, we can just record the enum
		42	* value and the offset into struct gl_context in an array of structs. Then
		43	* in glGet*(), we lookup the struct for the enum in question, and use
		44	* the offset to get the int we need.
		45	*
		46	* Sometimes we need to look up a float, a boolean, a bit in a
		47	* bitfield, a matrix or other types instead, so we need to track the
		48	* type of the value in struct gl_context. And sometimes the value isn't in
		49	* struct gl_context but in the drawbuffer, the array object, current texture
		50	* unit, or maybe it's a computed value. So we need to also track
		51	* where or how to find the value. Finally, we sometimes need to
		52	* check that one of a number of extensions are enabled, the GL
		53	* version or flush or call _mesa_update_state(). This is done by
		54	* attaching optional extra information to the value description
		55	* struct, it's sort of like an array of opcodes that describe extra
		56	* checks or actions.
		57	*
		58	* Putting all this together we end up with struct value_desc below,
		59	* and with a couple of macros to help, the table of struct value_desc
		60	* is about as concise as the specification in the old python script.
		61	*/
		62
		63	#undef CONST
		64
		65	#define FLOAT_TO_BOOLEAN(X) ( (X) ? GL_TRUE : GL_FALSE )
		66	#define FLOAT_TO_FIXED(F) ( ((F) * 65536.0f > INT_MAX) ? INT_MAX : \
		67	((F) * 65536.0f < INT_MIN) ? INT_MIN : \
		68	(GLint) ((F) * 65536.0f) )
		69
		70	#define INT_TO_BOOLEAN(I) ( (I) ? GL_TRUE : GL_FALSE )
		71	#define INT_TO_FIXED(I) ( ((I) > SHRT_MAX) ? INT_MAX : \
		72	((I) < SHRT_MIN) ? INT_MIN : \
		73	(GLint) ((I) * 65536) )
		74
		75	#define INT64_TO_BOOLEAN(I) ( (I) ? GL_TRUE : GL_FALSE )
		76	#define INT64_TO_INT(I) ( (GLint)((I > INT_MAX) ? INT_MAX : ((I < INT_MIN) ? INT_MIN : (I))) )
		77
		78	#define BOOLEAN_TO_INT(B) ( (GLint) (B) )
		79	#define BOOLEAN_TO_INT64(B) ( (GLint64) (B) )
		80	#define BOOLEAN_TO_FLOAT(B) ( (B) ? 1.0F : 0.0F )
		81	#define BOOLEAN_TO_FIXED(B) ( (GLint) ((B) ? 1 : 0) << 16 )
		82
		83	#define ENUM_TO_INT64(E) ( (GLint64) (E) )
		84	#define ENUM_TO_FIXED(E) (E)
		85
		86	enum value_type {
		87	TYPE_INVALID,
		88	TYPE_API_MASK,
		89	TYPE_INT,
		90	TYPE_INT_2,
		91	TYPE_INT_3,
		92	TYPE_INT_4,
		93	TYPE_INT_N,
		94	TYPE_INT64,
		95	TYPE_ENUM,
		96	TYPE_ENUM_2,
		97	TYPE_BOOLEAN,
		98	TYPE_BIT_0,
		99	TYPE_BIT_1,
		100	TYPE_BIT_2,
		101	TYPE_BIT_3,
		102	TYPE_BIT_4,
		103	TYPE_BIT_5,
		104	TYPE_FLOAT,
		105	TYPE_FLOAT_2,
		106	TYPE_FLOAT_3,
		107	TYPE_FLOAT_4,
		108	TYPE_FLOATN,
		109	TYPE_FLOATN_2,
		110	TYPE_FLOATN_3,
		111	TYPE_FLOATN_4,
		112	TYPE_DOUBLEN,
		113	TYPE_MATRIX,
		114	TYPE_MATRIX_T,
		115	TYPE_CONST
		116	};
		117
		118	enum value_location {
		119	LOC_BUFFER,
		120	LOC_CONTEXT,
		121	LOC_ARRAY,
		122	LOC_TEXUNIT,
		123	LOC_CUSTOM
		124	};
		125
		126	enum value_extra {
		127	EXTRA_END = 0x8000,
		128	EXTRA_VERSION_30,
		129	EXTRA_VERSION_31,
		130	EXTRA_VERSION_32,
		131	EXTRA_VERSION_ES2,
		132	EXTRA_NEW_BUFFERS,
		133	EXTRA_VALID_DRAW_BUFFER,
		134	EXTRA_VALID_TEXTURE_UNIT,
		135	EXTRA_FLUSH_CURRENT,
		136	};
		137
		138	#define NO_EXTRA NULL
		139	#define NO_OFFSET 0
		140
		141	struct value_desc {
		142	GLenum pname;
		143	GLubyte location; /*< enum value_location /
		144	GLubyte type; /*< enum value_type /
		145	int offset;
		146	const int *extra;
		147	};
		148
		149	union value {
		150	GLfloat value_float;
		151	GLfloat value_float_4[4];
		152	GLmatrix *value_matrix;
		153	GLint value_int;
		154	GLint value_int_4[4];
		155	GLint64 value_int64;
		156	GLenum value_enum;
		157
		158	/* Sigh, see GL_COMPRESSED_TEXTURE_FORMATS_ARB handling */
		159	struct {
		160	GLint n, ints[100];
		161	} value_int_n;
		162	GLboolean value_bool;
		163	};
		164
		165	#define BUFFER_FIELD(field, type) \
		166	LOC_BUFFER, type, offsetof(struct gl_framebuffer, field)
		167	#define CONTEXT_FIELD(field, type) \
		168	LOC_CONTEXT, type, offsetof(struct gl_context, field)
		169	#define ARRAY_FIELD(field, type) \
		170	LOC_ARRAY, type, offsetof(struct gl_array_object, field)
		171	#define CONST(value) \
		172	LOC_CONTEXT, TYPE_CONST, value
		173
		174	#define BUFFER_INT(field) BUFFER_FIELD(field, TYPE_INT)
		175	#define BUFFER_ENUM(field) BUFFER_FIELD(field, TYPE_ENUM)
		176	#define BUFFER_BOOL(field) BUFFER_FIELD(field, TYPE_BOOLEAN)
		177
		178	#define CONTEXT_INT(field) CONTEXT_FIELD(field, TYPE_INT)
		179	#define CONTEXT_INT2(field) CONTEXT_FIELD(field, TYPE_INT_2)
		180	#define CONTEXT_INT64(field) CONTEXT_FIELD(field, TYPE_INT64)
		181	#define CONTEXT_ENUM(field) CONTEXT_FIELD(field, TYPE_ENUM)
		182	#define CONTEXT_ENUM2(field) CONTEXT_FIELD(field, TYPE_ENUM_2)
		183	#define CONTEXT_BOOL(field) CONTEXT_FIELD(field, TYPE_BOOLEAN)
		184	#define CONTEXT_BIT0(field) CONTEXT_FIELD(field, TYPE_BIT_0)
		185	#define CONTEXT_BIT1(field) CONTEXT_FIELD(field, TYPE_BIT_1)
		186	#define CONTEXT_BIT2(field) CONTEXT_FIELD(field, TYPE_BIT_2)
		187	#define CONTEXT_BIT3(field) CONTEXT_FIELD(field, TYPE_BIT_3)
		188	#define CONTEXT_BIT4(field) CONTEXT_FIELD(field, TYPE_BIT_4)
		189	#define CONTEXT_BIT5(field) CONTEXT_FIELD(field, TYPE_BIT_5)
		190	#define CONTEXT_FLOAT(field) CONTEXT_FIELD(field, TYPE_FLOAT)
		191	#define CONTEXT_FLOAT2(field) CONTEXT_FIELD(field, TYPE_FLOAT_2)
		192	#define CONTEXT_FLOAT3(field) CONTEXT_FIELD(field, TYPE_FLOAT_3)
		193	#define CONTEXT_FLOAT4(field) CONTEXT_FIELD(field, TYPE_FLOAT_4)
		194	#define CONTEXT_MATRIX(field) CONTEXT_FIELD(field, TYPE_MATRIX)
		195	#define CONTEXT_MATRIX_T(field) CONTEXT_FIELD(field, TYPE_MATRIX_T)
		196
		197	#define ARRAY_INT(field) ARRAY_FIELD(field, TYPE_INT)
		198	#define ARRAY_ENUM(field) ARRAY_FIELD(field, TYPE_ENUM)
		199	#define ARRAY_BOOL(field) ARRAY_FIELD(field, TYPE_BOOLEAN)
		200
		201	#define EXT(f) \
		202	offsetof(struct gl_extensions, f)
		203
		204	#define EXTRA_EXT(e) \
		205	static const int extra_##e[] = { \
		206	EXT(e), EXTRA_END \
		207	}
		208
		209	#define EXTRA_EXT2(e1, e2) \
		210	static const int extra_##e1##_##e2[] = { \
		211	EXT(e1), EXT(e2), EXTRA_END \
		212	}
		213
		214	/* The 'extra' mechanism is a way to specify extra checks (such as
		215	* extensions or specific gl versions) or actions (flush current, new
		216	* buffers) that we need to do before looking up an enum. We need to
		217	* declare them all up front so we can refer to them in the value_desc
		218	* structs below. */
		219
		220	static const int extra_new_buffers[] = {
		221	EXTRA_NEW_BUFFERS,
		222	EXTRA_END
		223	};
		224
		225	static const int extra_valid_draw_buffer[] = {
		226	EXTRA_VALID_DRAW_BUFFER,
		227	EXTRA_END
		228	};
		229
		230	static const int extra_valid_texture_unit[] = {
		231	EXTRA_VALID_TEXTURE_UNIT,
		232	EXTRA_END
		233	};
		234
		235	static const int extra_flush_current_valid_texture_unit[] = {
		236	EXTRA_FLUSH_CURRENT,
		237	EXTRA_VALID_TEXTURE_UNIT,
		238	EXTRA_END
		239	};
		240
		241	static const int extra_flush_current[] = {
		242	EXTRA_FLUSH_CURRENT,
		243	EXTRA_END
		244	};
		245
		246	static const int extra_new_buffers_OES_read_format[] = {
		247	EXTRA_NEW_BUFFERS,
		248	EXT(OES_read_format),
		249	EXTRA_END
		250	};
		251
		252	static const int extra_EXT_secondary_color_flush_current[] = {
		253	EXT(EXT_secondary_color),
		254	EXTRA_FLUSH_CURRENT,
		255	EXTRA_END
		256	};
		257
		258	static const int extra_EXT_fog_coord_flush_current[] = {
		259	EXT(EXT_fog_coord),
		260	EXTRA_FLUSH_CURRENT,
		261	EXTRA_END
		262	};
		263
		264	static const int extra_EXT_texture_integer[] = {
		265	EXT(EXT_texture_integer),
		266	EXTRA_END
		267	};
		268
		269	static const int extra_EXT_gpu_shader4[] = {
		270	EXT(EXT_gpu_shader4),
		271	EXTRA_END
		272	};
		273
		274
		275	EXTRA_EXT(ARB_ES2_compatibility);
		276	EXTRA_EXT(ARB_multitexture);
		277	EXTRA_EXT(ARB_texture_cube_map);
		278	EXTRA_EXT(MESA_texture_array);
		279	EXTRA_EXT2(EXT_secondary_color, ARB_vertex_program);
		280	EXTRA_EXT(EXT_secondary_color);
		281	EXTRA_EXT(EXT_fog_coord);
		282	EXTRA_EXT(EXT_texture_lod_bias);
		283	EXTRA_EXT(EXT_texture_filter_anisotropic);
		284	EXTRA_EXT(IBM_rasterpos_clip);
		285	EXTRA_EXT(NV_point_sprite);
		286	EXTRA_EXT(SGIS_generate_mipmap);
		287	EXTRA_EXT(NV_vertex_program);
		288	EXTRA_EXT(NV_fragment_program);
		289	EXTRA_EXT(NV_texture_rectangle);
		290	EXTRA_EXT(EXT_stencil_two_side);
		291	EXTRA_EXT(NV_light_max_exponent);
		292	EXTRA_EXT(SGI_texture_color_table);
		293	EXTRA_EXT(EXT_depth_bounds_test);
		294	EXTRA_EXT(ARB_depth_clamp);
		295	EXTRA_EXT(ATI_fragment_shader);
		296	EXTRA_EXT(EXT_framebuffer_blit);
		297	EXTRA_EXT(ARB_shader_objects);
		298	EXTRA_EXT(EXT_provoking_vertex);
		299	EXTRA_EXT(ARB_fragment_shader);
		300	EXTRA_EXT(ARB_fragment_program);
		301	EXTRA_EXT2(ARB_framebuffer_object, EXT_framebuffer_multisample);
		302	EXTRA_EXT(EXT_framebuffer_object);
		303	EXTRA_EXT(APPLE_vertex_array_object);
		304	EXTRA_EXT(ARB_seamless_cube_map);
		305	EXTRA_EXT(EXT_compiled_vertex_array);
		306	EXTRA_EXT(ARB_sync);
		307	EXTRA_EXT(ARB_vertex_shader);
		308	EXTRA_EXT(EXT_transform_feedback);
		309	EXTRA_EXT(ARB_transform_feedback2);
		310	EXTRA_EXT(EXT_pixel_buffer_object);
		311	EXTRA_EXT(ARB_vertex_program);
		312	EXTRA_EXT2(NV_point_sprite, ARB_point_sprite);
		313	EXTRA_EXT2(ARB_fragment_program, NV_fragment_program);
		314	EXTRA_EXT2(ARB_vertex_program, NV_vertex_program);
		315	EXTRA_EXT2(ARB_vertex_program, ARB_fragment_program);
		316	EXTRA_EXT(ARB_vertex_buffer_object);
		317	EXTRA_EXT(ARB_geometry_shader4);
		318	EXTRA_EXT(ARB_copy_buffer);
		319
		320	static const int
		321	extra_ARB_vertex_program_ARB_fragment_program_NV_vertex_program[] = {
		322	EXT(ARB_vertex_program),
		323	EXT(ARB_fragment_program),
		324	EXT(NV_vertex_program),
		325	EXTRA_END
		326	};
		327
		328	static const int
		329	extra_NV_vertex_program_ARB_vertex_program_ARB_fragment_program_NV_vertex_program[] = {
		330	EXT(NV_vertex_program),
		331	EXT(ARB_vertex_program),
		332	EXT(ARB_fragment_program),
		333	EXT(NV_vertex_program),
		334	EXTRA_END
		335	};
		336
		337	static const int
		338	extra_NV_primitive_restart[] = {
		339	EXT(NV_primitive_restart),
		340	EXTRA_END
		341	};
		342
		343	static const int extra_version_30[] = { EXTRA_VERSION_30, EXTRA_END };
		344	static const int extra_version_31[] = { EXTRA_VERSION_31, EXTRA_END };
		345	static const int extra_version_32[] = { EXTRA_VERSION_32, EXTRA_END };
		346
		347	static const int
		348	extra_ARB_vertex_program_version_es2[] = {
		349	EXT(ARB_vertex_program),
		350	EXTRA_VERSION_ES2,
		351	EXTRA_END
		352	};
		353
		354	#define API_OPENGL_BIT (1 << API_OPENGL)
		355	#define API_OPENGLES_BIT (1 << API_OPENGLES)
		356	#define API_OPENGLES2_BIT (1 << API_OPENGLES2)
		357
		358	/* This is the big table describing all the enums we accept in
		359	* glGet*v(). The table is partitioned into six parts: enums
		360	* understood by all GL APIs (OpenGL, GLES and GLES2), enums shared
		361	* between OpenGL and GLES, enums exclusive to GLES, etc for the
		362	* remaining combinations. When we add the enums to the hash table in
		363	* _mesa_init_get_hash(), we only add the enums for the API we're
		364	* instantiating and the different sections are guarded by #if
		365	* FEATURE_GL etc to make sure we only compile in the enums we may
		366	* need. */
		367
		368	static const struct value_desc values[] = {
		369	/* Enums shared between OpenGL, GLES1 and GLES2 */
		370	{ 0, 0, TYPE_API_MASK,
		371	API_OPENGL_BIT \| API_OPENGLES_BIT \| API_OPENGLES2_BIT, NO_EXTRA},
		372	{ GL_ALPHA_BITS, BUFFER_INT(Visual.alphaBits), extra_new_buffers },
		373	{ GL_BLEND, CONTEXT_BIT0(Color.BlendEnabled), NO_EXTRA },
		374	{ GL_BLEND_SRC, CONTEXT_ENUM(Color.BlendSrcRGB), NO_EXTRA },
		375	{ GL_BLUE_BITS, BUFFER_INT(Visual.blueBits), extra_new_buffers },
		376	{ GL_COLOR_CLEAR_VALUE, CONTEXT_FIELD(Color.ClearColor[0], TYPE_FLOATN_4), NO_EXTRA },
		377	{ GL_COLOR_WRITEMASK, LOC_CUSTOM, TYPE_INT_4, 0, NO_EXTRA },
		378	{ GL_CULL_FACE, CONTEXT_BOOL(Polygon.CullFlag), NO_EXTRA },
		379	{ GL_CULL_FACE_MODE, CONTEXT_ENUM(Polygon.CullFaceMode), NO_EXTRA },
		380	{ GL_DEPTH_BITS, BUFFER_INT(Visual.depthBits), NO_EXTRA },
		381	{ GL_DEPTH_CLEAR_VALUE, CONTEXT_FIELD(Depth.Clear, TYPE_DOUBLEN), NO_EXTRA },
		382	{ GL_DEPTH_FUNC, CONTEXT_ENUM(Depth.Func), NO_EXTRA },
		383	{ GL_DEPTH_RANGE, CONTEXT_FIELD(Viewport.Near, TYPE_FLOATN_2), NO_EXTRA },
		384	{ GL_DEPTH_TEST, CONTEXT_BOOL(Depth.Test), NO_EXTRA },
		385	{ GL_DEPTH_WRITEMASK, CONTEXT_BOOL(Depth.Mask), NO_EXTRA },
		386	{ GL_DITHER, CONTEXT_BOOL(Color.DitherFlag), NO_EXTRA },
		387	{ GL_FRONT_FACE, CONTEXT_ENUM(Polygon.FrontFace), NO_EXTRA },
		388	{ GL_GREEN_BITS, BUFFER_INT(Visual.greenBits), extra_new_buffers },
		389	{ GL_LINE_WIDTH, CONTEXT_FLOAT(Line.Width), NO_EXTRA },
		390	{ GL_ALIASED_LINE_WIDTH_RANGE, CONTEXT_FLOAT2(Const.MinLineWidth), NO_EXTRA },
		391	{ GL_MAX_ELEMENTS_VERTICES, CONTEXT_INT(Const.MaxArrayLockSize), NO_EXTRA },
		392	{ GL_MAX_ELEMENTS_INDICES, CONTEXT_INT(Const.MaxArrayLockSize), NO_EXTRA },
		393	{ GL_MAX_TEXTURE_SIZE, LOC_CUSTOM, TYPE_INT,
		394	offsetof(struct gl_context, Const.MaxTextureLevels), NO_EXTRA },
		395	{ GL_MAX_VIEWPORT_DIMS, CONTEXT_INT2(Const.MaxViewportWidth), NO_EXTRA },
		396	{ GL_PACK_ALIGNMENT, CONTEXT_INT(Pack.Alignment), NO_EXTRA },
		397	{ GL_ALIASED_POINT_SIZE_RANGE, CONTEXT_FLOAT2(Const.MinPointSize), NO_EXTRA },
		398	{ GL_POLYGON_OFFSET_FACTOR, CONTEXT_FLOAT(Polygon.OffsetFactor ), NO_EXTRA },
		399	{ GL_POLYGON_OFFSET_UNITS, CONTEXT_FLOAT(Polygon.OffsetUnits ), NO_EXTRA },
		400	{ GL_POLYGON_OFFSET_FILL, CONTEXT_BOOL(Polygon.OffsetFill), NO_EXTRA },
		401	{ GL_RED_BITS, BUFFER_INT(Visual.redBits), extra_new_buffers },
		402	{ GL_SCISSOR_BOX, LOC_CUSTOM, TYPE_INT_4, 0, NO_EXTRA },
		403	{ GL_SCISSOR_TEST, CONTEXT_BOOL(Scissor.Enabled), NO_EXTRA },
		404	{ GL_STENCIL_BITS, BUFFER_INT(Visual.stencilBits), NO_EXTRA },
		405	{ GL_STENCIL_CLEAR_VALUE, CONTEXT_INT(Stencil.Clear), NO_EXTRA },
		406	{ GL_STENCIL_FAIL, LOC_CUSTOM, TYPE_ENUM, NO_OFFSET, NO_EXTRA },
		407	{ GL_STENCIL_FUNC, LOC_CUSTOM, TYPE_ENUM, NO_OFFSET, NO_EXTRA },
		408	{ GL_STENCIL_PASS_DEPTH_FAIL, LOC_CUSTOM, TYPE_ENUM, NO_OFFSET, NO_EXTRA },
		409	{ GL_STENCIL_PASS_DEPTH_PASS, LOC_CUSTOM, TYPE_ENUM, NO_OFFSET, NO_EXTRA },
		410	{ GL_STENCIL_REF, LOC_CUSTOM, TYPE_INT, NO_OFFSET, NO_EXTRA },
		411	{ GL_STENCIL_TEST, CONTEXT_BOOL(Stencil.Enabled), NO_EXTRA },
		412	{ GL_STENCIL_VALUE_MASK, LOC_CUSTOM, TYPE_INT, NO_OFFSET, NO_EXTRA },
		413	{ GL_STENCIL_WRITEMASK, LOC_CUSTOM, TYPE_INT, NO_OFFSET, NO_EXTRA },
		414	{ GL_SUBPIXEL_BITS, CONTEXT_INT(Const.SubPixelBits), NO_EXTRA },
		415	{ GL_TEXTURE_BINDING_2D, LOC_CUSTOM, TYPE_INT, TEXTURE_2D_INDEX, NO_EXTRA },
		416	{ GL_UNPACK_ALIGNMENT, CONTEXT_INT(Unpack.Alignment), NO_EXTRA },
		417	{ GL_VIEWPORT, LOC_CUSTOM, TYPE_INT_4, 0, NO_EXTRA },
		418
		419	/* GL_ARB_multitexture */
		420	{ GL_ACTIVE_TEXTURE_ARB,
		421	LOC_CUSTOM, TYPE_INT, 0, extra_ARB_multitexture },
		422
		423	/* Note that all the OES_* extensions require that the Mesa "struct
		424	* gl_extensions" include a member with the name of the extension.
		425	* That structure does not yet include OES extensions (and we're
		426	* not sure whether it will). If it does, all the OES_*
		427	* extensions below should mark the dependency. */
		428
		429	/* GL_ARB_texture_cube_map */
		430	{ GL_TEXTURE_BINDING_CUBE_MAP_ARB, LOC_CUSTOM, TYPE_INT,
		431	TEXTURE_CUBE_INDEX, extra_ARB_texture_cube_map },
		432	{ GL_MAX_CUBE_MAP_TEXTURE_SIZE_ARB, LOC_CUSTOM, TYPE_INT,
		433	offsetof(struct gl_context, Const.MaxCubeTextureLevels),
		434	extra_ARB_texture_cube_map }, /* XXX: OES_texture_cube_map */
		435
		436	/* XXX: OES_blend_subtract */
		437	{ GL_BLEND_SRC_RGB_EXT, CONTEXT_ENUM(Color.BlendSrcRGB), NO_EXTRA },
		438	{ GL_BLEND_DST_RGB_EXT, CONTEXT_ENUM(Color.BlendDstRGB), NO_EXTRA },
		439	{ GL_BLEND_SRC_ALPHA_EXT, CONTEXT_ENUM(Color.BlendSrcA), NO_EXTRA },
		440	{ GL_BLEND_DST_ALPHA_EXT, CONTEXT_ENUM(Color.BlendDstA), NO_EXTRA },
		441
		442	/* GL_BLEND_EQUATION_RGB, which is what we're really after, is
		443	* defined identically to GL_BLEND_EQUATION. */
		444	{ GL_BLEND_EQUATION, CONTEXT_ENUM(Color.BlendEquationRGB), NO_EXTRA },
		445	{ GL_BLEND_EQUATION_ALPHA_EXT, CONTEXT_ENUM(Color.BlendEquationA), NO_EXTRA },
		446
		447	/* GL_ARB_texture_compression */
		448	{ GL_NUM_COMPRESSED_TEXTURE_FORMATS_ARB, LOC_CUSTOM, TYPE_INT, 0, NO_EXTRA },
		449	{ GL_COMPRESSED_TEXTURE_FORMATS_ARB, LOC_CUSTOM, TYPE_INT_N, 0, NO_EXTRA },
		450
		451	/* GL_ARB_multisample */
		452	{ GL_SAMPLE_ALPHA_TO_COVERAGE_ARB,
		453	CONTEXT_BOOL(Multisample.SampleAlphaToCoverage), NO_EXTRA },
		454	{ GL_SAMPLE_COVERAGE_ARB, CONTEXT_BOOL(Multisample.SampleCoverage), NO_EXTRA },
		455	{ GL_SAMPLE_COVERAGE_VALUE_ARB,
		456	CONTEXT_FLOAT(Multisample.SampleCoverageValue), NO_EXTRA },
		457	{ GL_SAMPLE_COVERAGE_INVERT_ARB,
		458	CONTEXT_BOOL(Multisample.SampleCoverageInvert), NO_EXTRA },
		459	{ GL_SAMPLE_BUFFERS_ARB, BUFFER_INT(Visual.sampleBuffers), NO_EXTRA },
		460	{ GL_SAMPLES_ARB, BUFFER_INT(Visual.samples), NO_EXTRA },
		461
		462	/* GL_SGIS_generate_mipmap */
		463	{ GL_GENERATE_MIPMAP_HINT_SGIS, CONTEXT_ENUM(Hint.GenerateMipmap),
		464	extra_SGIS_generate_mipmap },
		465
		466	/* GL_ARB_vertex_buffer_object */
		467	{ GL_ARRAY_BUFFER_BINDING_ARB, LOC_CUSTOM, TYPE_INT, 0, NO_EXTRA },
		468
		469	/* GL_ARB_vertex_buffer_object */
		470	/* GL_WEIGHT_ARRAY_BUFFER_BINDING_ARB - not supported */
		471	{ GL_ELEMENT_ARRAY_BUFFER_BINDING_ARB, LOC_CUSTOM, TYPE_INT, 0,
		472	extra_ARB_vertex_buffer_object },
		473
		474	/* GL_ARB_copy_buffer */
		475	{ GL_COPY_READ_BUFFER, LOC_CUSTOM, TYPE_INT, 0, extra_ARB_copy_buffer },
		476	{ GL_COPY_WRITE_BUFFER, LOC_CUSTOM, TYPE_INT, 0, extra_ARB_copy_buffer },
		477
		478	/* GL_OES_read_format */
		479	{ GL_IMPLEMENTATION_COLOR_READ_TYPE_OES, LOC_CUSTOM, TYPE_INT, 0,
		480	extra_new_buffers_OES_read_format },
		481	{ GL_IMPLEMENTATION_COLOR_READ_FORMAT_OES, LOC_CUSTOM, TYPE_INT, 0,
		482	extra_new_buffers_OES_read_format },
		483
		484	/* GL_EXT_framebuffer_object */
		485	{ GL_FRAMEBUFFER_BINDING_EXT, BUFFER_INT(Name),
		486	extra_EXT_framebuffer_object },
		487	{ GL_RENDERBUFFER_BINDING_EXT, LOC_CUSTOM, TYPE_INT, 0,
		488	extra_EXT_framebuffer_object },
		489	{ GL_MAX_RENDERBUFFER_SIZE_EXT, CONTEXT_INT(Const.MaxRenderbufferSize),
		490	extra_EXT_framebuffer_object },
		491
		492	/* This entry isn't spec'ed for GLES 2, but is needed for Mesa's
		493	* GLSL: */
		494	{ GL_MAX_CLIP_PLANES, CONTEXT_INT(Const.MaxClipPlanes), NO_EXTRA },
		495
		496	#if FEATURE_GL \|\| FEATURE_ES1
		497	/* Enums in OpenGL and GLES1 */
		498	{ 0, 0, TYPE_API_MASK, API_OPENGL_BIT \| API_OPENGLES_BIT, NO_EXTRA },
		499	{ GL_LIGHT0, CONTEXT_BOOL(Light.Light[0].Enabled), NO_EXTRA },
		500	{ GL_LIGHT1, CONTEXT_BOOL(Light.Light[1].Enabled), NO_EXTRA },
		501	{ GL_LIGHT2, CONTEXT_BOOL(Light.Light[2].Enabled), NO_EXTRA },
		502	{ GL_LIGHT3, CONTEXT_BOOL(Light.Light[3].Enabled), NO_EXTRA },
		503	{ GL_LIGHT4, CONTEXT_BOOL(Light.Light[4].Enabled), NO_EXTRA },
		504	{ GL_LIGHT5, CONTEXT_BOOL(Light.Light[5].Enabled), NO_EXTRA },
		505	{ GL_LIGHT6, CONTEXT_BOOL(Light.Light[6].Enabled), NO_EXTRA },
		506	{ GL_LIGHT7, CONTEXT_BOOL(Light.Light[7].Enabled), NO_EXTRA },
		507	{ GL_LIGHTING, CONTEXT_BOOL(Light.Enabled), NO_EXTRA },
		508	{ GL_LIGHT_MODEL_AMBIENT,
		509	CONTEXT_FIELD(Light.Model.Ambient[0], TYPE_FLOATN_4), NO_EXTRA },
		510	{ GL_LIGHT_MODEL_TWO_SIDE, CONTEXT_BOOL(Light.Model.TwoSide), NO_EXTRA },
		511	{ GL_ALPHA_TEST, CONTEXT_BOOL(Color.AlphaEnabled), NO_EXTRA },
		512	{ GL_ALPHA_TEST_FUNC, CONTEXT_ENUM(Color.AlphaFunc), NO_EXTRA },
		513	{ GL_ALPHA_TEST_REF, CONTEXT_FIELD(Color.AlphaRef, TYPE_FLOATN), NO_EXTRA },
		514	{ GL_BLEND_DST, CONTEXT_ENUM(Color.BlendDstRGB), NO_EXTRA },
		515	{ GL_CLIP_PLANE0, CONTEXT_BIT0(Transform.ClipPlanesEnabled), NO_EXTRA },
		516	{ GL_CLIP_PLANE1, CONTEXT_BIT1(Transform.ClipPlanesEnabled), NO_EXTRA },
		517	{ GL_CLIP_PLANE2, CONTEXT_BIT2(Transform.ClipPlanesEnabled), NO_EXTRA },
		518	{ GL_CLIP_PLANE3, CONTEXT_BIT3(Transform.ClipPlanesEnabled), NO_EXTRA },
		519	{ GL_CLIP_PLANE4, CONTEXT_BIT4(Transform.ClipPlanesEnabled), NO_EXTRA },
		520	{ GL_CLIP_PLANE5, CONTEXT_BIT5(Transform.ClipPlanesEnabled), NO_EXTRA },
		521	{ GL_COLOR_MATERIAL, CONTEXT_BOOL(Light.ColorMaterialEnabled), NO_EXTRA },
		522	{ GL_CURRENT_COLOR,
		523	CONTEXT_FIELD(Current.Attrib[VERT_ATTRIB_COLOR0][0], TYPE_FLOATN_4),
		524	extra_flush_current },
		525	{ GL_CURRENT_NORMAL,
		526	CONTEXT_FIELD(Current.Attrib[VERT_ATTRIB_NORMAL][0], TYPE_FLOATN_3),
		527	extra_flush_current },
		528	{ GL_CURRENT_TEXTURE_COORDS, LOC_CUSTOM, TYPE_FLOAT_4, 0,
		529	extra_flush_current_valid_texture_unit },
		530	{ GL_DISTANCE_ATTENUATION_EXT, CONTEXT_FLOAT3(Point.Params[0]), NO_EXTRA },
		531	{ GL_FOG, CONTEXT_BOOL(Fog.Enabled), NO_EXTRA },
		532	{ GL_FOG_COLOR, CONTEXT_FIELD(Fog.Color[0], TYPE_FLOATN_4), NO_EXTRA },
		533	{ GL_FOG_DENSITY, CONTEXT_FLOAT(Fog.Density), NO_EXTRA },
		534	{ GL_FOG_END, CONTEXT_FLOAT(Fog.End), NO_EXTRA },
		535	{ GL_FOG_HINT, CONTEXT_ENUM(Hint.Fog), NO_EXTRA },
		536	{ GL_FOG_MODE, CONTEXT_ENUM(Fog.Mode), NO_EXTRA },
		537	{ GL_FOG_START, CONTEXT_FLOAT(Fog.Start), NO_EXTRA },
		538	{ GL_LINE_SMOOTH, CONTEXT_BOOL(Line.SmoothFlag), NO_EXTRA },
		539	{ GL_LINE_SMOOTH_HINT, CONTEXT_ENUM(Hint.LineSmooth), NO_EXTRA },
		540	{ GL_LINE_WIDTH_RANGE, CONTEXT_FLOAT2(Const.MinLineWidthAA), NO_EXTRA },
		541	{ GL_COLOR_LOGIC_OP, CONTEXT_BOOL(Color.ColorLogicOpEnabled), NO_EXTRA },
		542	{ GL_LOGIC_OP_MODE, CONTEXT_ENUM(Color.LogicOp), NO_EXTRA },
		543	{ GL_MATRIX_MODE, CONTEXT_ENUM(Transform.MatrixMode), NO_EXTRA },
		544	{ GL_MAX_MODELVIEW_STACK_DEPTH, CONST(MAX_MODELVIEW_STACK_DEPTH), NO_EXTRA },
		545	{ GL_MAX_PROJECTION_STACK_DEPTH, CONST(MAX_PROJECTION_STACK_DEPTH), NO_EXTRA },
		546	{ GL_MAX_TEXTURE_STACK_DEPTH, CONST(MAX_TEXTURE_STACK_DEPTH), NO_EXTRA },
		547	{ GL_MODELVIEW_MATRIX, CONTEXT_MATRIX(ModelviewMatrixStack.Top), NO_EXTRA },
		548	{ GL_MODELVIEW_STACK_DEPTH, LOC_CUSTOM, TYPE_INT,
		549	offsetof(struct gl_context, ModelviewMatrixStack.Depth), NO_EXTRA },
		550	{ GL_NORMALIZE, CONTEXT_BOOL(Transform.Normalize), NO_EXTRA },
		551	{ GL_PACK_SKIP_IMAGES_EXT, CONTEXT_INT(Pack.SkipImages), NO_EXTRA },
		552	{ GL_PERSPECTIVE_CORRECTION_HINT, CONTEXT_ENUM(Hint.PerspectiveCorrection), NO_EXTRA },
		553	{ GL_POINT_SIZE, CONTEXT_FLOAT(Point.Size), NO_EXTRA },
		554	{ GL_POINT_SIZE_RANGE, CONTEXT_FLOAT2(Const.MinPointSizeAA), NO_EXTRA },
		555	{ GL_POINT_SMOOTH, CONTEXT_BOOL(Point.SmoothFlag), NO_EXTRA },
		556	{ GL_POINT_SMOOTH_HINT, CONTEXT_ENUM(Hint.PointSmooth), NO_EXTRA },
		557	{ GL_POINT_SIZE_MIN_EXT, CONTEXT_FLOAT(Point.MinSize), NO_EXTRA },
		558	{ GL_POINT_SIZE_MAX_EXT, CONTEXT_FLOAT(Point.MaxSize), NO_EXTRA },
		559	{ GL_POINT_FADE_THRESHOLD_SIZE_EXT, CONTEXT_FLOAT(Point.Threshold), NO_EXTRA },
		560	{ GL_PROJECTION_MATRIX, CONTEXT_MATRIX(ProjectionMatrixStack.Top), NO_EXTRA },
		561	{ GL_PROJECTION_STACK_DEPTH, LOC_CUSTOM, TYPE_INT,
		562	offsetof(struct gl_context, ProjectionMatrixStack.Depth), NO_EXTRA },
		563	{ GL_RESCALE_NORMAL, CONTEXT_BOOL(Transform.RescaleNormals), NO_EXTRA },
		564	{ GL_SHADE_MODEL, CONTEXT_ENUM(Light.ShadeModel), NO_EXTRA },
		565	{ GL_TEXTURE_2D, LOC_CUSTOM, TYPE_BOOLEAN, 0, NO_EXTRA },
		566	{ GL_TEXTURE_MATRIX, LOC_CUSTOM, TYPE_MATRIX, 0, extra_valid_texture_unit },
		567	{ GL_TEXTURE_STACK_DEPTH, LOC_CUSTOM, TYPE_INT, 0,
		568	extra_valid_texture_unit },
		569
		570	{ GL_VERTEX_ARRAY, ARRAY_BOOL(Vertex.Enabled), NO_EXTRA },
		571	{ GL_VERTEX_ARRAY_SIZE, ARRAY_INT(Vertex.Size), NO_EXTRA },
		572	{ GL_VERTEX_ARRAY_TYPE, ARRAY_ENUM(Vertex.Type), NO_EXTRA },
		573	{ GL_VERTEX_ARRAY_STRIDE, ARRAY_INT(Vertex.Stride), NO_EXTRA },
		574	{ GL_NORMAL_ARRAY, ARRAY_ENUM(Normal.Enabled), NO_EXTRA },
		575	{ GL_NORMAL_ARRAY_TYPE, ARRAY_ENUM(Normal.Type), NO_EXTRA },
		576	{ GL_NORMAL_ARRAY_STRIDE, ARRAY_INT(Normal.Stride), NO_EXTRA },
		577	{ GL_COLOR_ARRAY, ARRAY_BOOL(Color.Enabled), NO_EXTRA },
		578	{ GL_COLOR_ARRAY_SIZE, ARRAY_INT(Color.Size), NO_EXTRA },
		579	{ GL_COLOR_ARRAY_TYPE, ARRAY_ENUM(Color.Type), NO_EXTRA },
		580	{ GL_COLOR_ARRAY_STRIDE, ARRAY_INT(Color.Stride), NO_EXTRA },
		581	{ GL_TEXTURE_COORD_ARRAY,
		582	LOC_CUSTOM, TYPE_BOOLEAN, offsetof(struct gl_client_array, Enabled), NO_EXTRA },
		583	{ GL_TEXTURE_COORD_ARRAY_SIZE,
		584	LOC_CUSTOM, TYPE_BOOLEAN, offsetof(struct gl_client_array, Size), NO_EXTRA },
		585	{ GL_TEXTURE_COORD_ARRAY_TYPE,
		586	LOC_CUSTOM, TYPE_BOOLEAN, offsetof(struct gl_client_array, Type), NO_EXTRA },
		587	{ GL_TEXTURE_COORD_ARRAY_STRIDE,
		588	LOC_CUSTOM, TYPE_BOOLEAN, offsetof(struct gl_client_array, Stride), NO_EXTRA },
		589
		590	/* GL_ARB_ES2_compatibility */
		591	{ GL_SHADER_COMPILER, CONST(1), extra_ARB_ES2_compatibility },
		592	{ GL_MAX_VARYING_VECTORS, CONTEXT_INT(Const.MaxVarying),
		593	extra_ARB_ES2_compatibility },
		594	{ GL_MAX_VERTEX_UNIFORM_VECTORS, LOC_CUSTOM, TYPE_INT, 0,
		595	extra_ARB_ES2_compatibility },
		596	{ GL_MAX_FRAGMENT_UNIFORM_VECTORS, LOC_CUSTOM, TYPE_INT, 0,
		597	extra_ARB_ES2_compatibility },
		598
		599	/* GL_ARB_multitexture */
		600	{ GL_MAX_TEXTURE_UNITS_ARB,
		601	CONTEXT_INT(Const.MaxTextureUnits), extra_ARB_multitexture },
		602	{ GL_CLIENT_ACTIVE_TEXTURE_ARB,
		603	LOC_CUSTOM, TYPE_INT, 0, extra_ARB_multitexture },
		604
		605	/* GL_ARB_texture_cube_map */
		606	{ GL_TEXTURE_CUBE_MAP_ARB, LOC_CUSTOM, TYPE_BOOLEAN, 0, NO_EXTRA },
		607	/* S, T, and R are always set at the same time */
		608	{ GL_TEXTURE_GEN_STR_OES, LOC_TEXUNIT, TYPE_BIT_0,
		609	offsetof(struct gl_texture_unit, TexGenEnabled), NO_EXTRA },
		610
		611	/* GL_ARB_multisample */
		612	{ GL_MULTISAMPLE_ARB, CONTEXT_BOOL(Multisample.Enabled), NO_EXTRA },
		613	{ GL_SAMPLE_ALPHA_TO_ONE_ARB, CONTEXT_BOOL(Multisample.SampleAlphaToOne), NO_EXTRA },
		614
		615	/* GL_ARB_vertex_buffer_object */
		616	{ GL_VERTEX_ARRAY_BUFFER_BINDING_ARB, LOC_CUSTOM, TYPE_INT,
		617	offsetof(struct gl_array_object, Vertex.BufferObj), NO_EXTRA },
		618	{ GL_NORMAL_ARRAY_BUFFER_BINDING_ARB, LOC_CUSTOM, TYPE_INT,
		619	offsetof(struct gl_array_object, Normal.BufferObj), NO_EXTRA },
		620	{ GL_COLOR_ARRAY_BUFFER_BINDING_ARB, LOC_CUSTOM, TYPE_INT,
		621	offsetof(struct gl_array_object, Color.BufferObj), NO_EXTRA },
		622	{ GL_TEXTURE_COORD_ARRAY_BUFFER_BINDING_ARB, LOC_CUSTOM, TYPE_INT, NO_OFFSET, NO_EXTRA },
		623
		624	/* GL_OES_point_sprite */
		625	{ GL_POINT_SPRITE_NV,
		626	CONTEXT_BOOL(Point.PointSprite),
		627	extra_NV_point_sprite_ARB_point_sprite },
		628
		629	/* GL_ARB_fragment_shader */
		630	{ GL_MAX_FRAGMENT_UNIFORM_COMPONENTS_ARB,
		631	CONTEXT_INT(Const.FragmentProgram.MaxUniformComponents),
		632	extra_ARB_fragment_shader },
		633
		634	/* GL_ARB_vertex_shader */
		635	{ GL_MAX_VERTEX_UNIFORM_COMPONENTS_ARB,
		636	CONTEXT_INT(Const.VertexProgram.MaxUniformComponents),
		637	extra_ARB_vertex_shader },
		638	{ GL_MAX_VARYING_FLOATS_ARB, LOC_CUSTOM, TYPE_INT, 0,
		639	extra_ARB_vertex_shader },
		640
		641	/* GL_EXT_texture_lod_bias */
		642	{ GL_MAX_TEXTURE_LOD_BIAS_EXT, CONTEXT_FLOAT(Const.MaxTextureLodBias),
		643	extra_EXT_texture_lod_bias },
		644
		645	/* GL_EXT_texture_filter_anisotropic */
		646	{ GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT,
		647	CONTEXT_FLOAT(Const.MaxTextureMaxAnisotropy),
		648	extra_EXT_texture_filter_anisotropic },
		649	#endif /* FEATURE_GL \|\| FEATURE_ES1 */
		650
		651	#if FEATURE_ES1
		652	{ 0, 0, TYPE_API_MASK, API_OPENGLES_BIT },
		653	/* XXX: OES_matrix_get */
		654	{ GL_MODELVIEW_MATRIX_FLOAT_AS_INT_BITS_OES },
		655	{ GL_PROJECTION_MATRIX_FLOAT_AS_INT_BITS_OES },
		656	{ GL_TEXTURE_MATRIX_FLOAT_AS_INT_BITS_OES },
		657
		658	/* OES_point_size_array */
		659	{ GL_POINT_SIZE_ARRAY_OES, ARRAY_FIELD(PointSize.Enabled, TYPE_BOOLEAN) },
		660	{ GL_POINT_SIZE_ARRAY_TYPE_OES, ARRAY_FIELD(PointSize.Type, TYPE_ENUM) },
		661	{ GL_POINT_SIZE_ARRAY_STRIDE_OES, ARRAY_FIELD(PointSize.Stride, TYPE_INT) },
		662	{ GL_POINT_SIZE_ARRAY_BUFFER_BINDING_OES, LOC_CUSTOM, TYPE_INT, 0 },
		663	#endif /* FEATURE_ES1 */
		664
		665	#if FEATURE_GL \|\| FEATURE_ES2
		666	{ 0, 0, TYPE_API_MASK, API_OPENGL_BIT \| API_OPENGLES2_BIT, NO_EXTRA },
		667	/* This entry isn't spec'ed for GLES 2, but is needed for Mesa's GLSL: */
		668	{ GL_MAX_LIGHTS, CONTEXT_INT(Const.MaxLights), NO_EXTRA },
		669	{ GL_MAX_TEXTURE_COORDS_ARB, /* == GL_MAX_TEXTURE_COORDS_NV */
		670	CONTEXT_INT(Const.MaxTextureCoordUnits),
		671	extra_ARB_fragment_program_NV_fragment_program },
		672
		673	/* GL_ARB_draw_buffers */
		674	{ GL_MAX_DRAW_BUFFERS_ARB, CONTEXT_INT(Const.MaxDrawBuffers), NO_EXTRA },
		675
		676	{ GL_BLEND_COLOR_EXT, CONTEXT_FIELD(Color.BlendColor[0], TYPE_FLOATN_4), NO_EXTRA },
		677	/* GL_ARB_fragment_program */
		678	{ GL_MAX_TEXTURE_IMAGE_UNITS_ARB, /* == GL_MAX_TEXTURE_IMAGE_UNITS_NV */
		679	CONTEXT_INT(Const.MaxTextureImageUnits),
		680	extra_ARB_fragment_program_NV_fragment_program },
		681	{ GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS_ARB,
		682	CONTEXT_INT(Const.MaxVertexTextureImageUnits), extra_ARB_vertex_shader },
		683	{ GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS_ARB,
		684	CONTEXT_INT(Const.MaxCombinedTextureImageUnits),
		685	extra_ARB_vertex_shader },
		686
		687	/* GL_ARB_shader_objects
		688	* Actually, this token isn't part of GL_ARB_shader_objects, but is
		689	* close enough for now. */
		690	{ GL_CURRENT_PROGRAM, LOC_CUSTOM, TYPE_INT, 0, extra_ARB_shader_objects },
		691
		692	/* OpenGL 2.0 */
		693	{ GL_STENCIL_BACK_FUNC, CONTEXT_ENUM(Stencil.Function[1]), NO_EXTRA },
		694	{ GL_STENCIL_BACK_VALUE_MASK, CONTEXT_INT(Stencil.ValueMask[1]), NO_EXTRA },
		695	{ GL_STENCIL_BACK_WRITEMASK, CONTEXT_INT(Stencil.WriteMask[1]), NO_EXTRA },
		696	{ GL_STENCIL_BACK_REF, CONTEXT_INT(Stencil.Ref[1]), NO_EXTRA },
		697	{ GL_STENCIL_BACK_FAIL, CONTEXT_ENUM(Stencil.FailFunc[1]), NO_EXTRA },
		698	{ GL_STENCIL_BACK_PASS_DEPTH_FAIL, CONTEXT_ENUM(Stencil.ZFailFunc[1]), NO_EXTRA },
		699	{ GL_STENCIL_BACK_PASS_DEPTH_PASS, CONTEXT_ENUM(Stencil.ZPassFunc[1]), NO_EXTRA },
		700
		701	{ GL_MAX_VERTEX_ATTRIBS_ARB,
		702	CONTEXT_INT(Const.VertexProgram.MaxAttribs),
		703	extra_ARB_vertex_program_version_es2 },
		704
		705	/* OES_texture_3D */
		706	{ GL_TEXTURE_BINDING_3D, LOC_CUSTOM, TYPE_INT, TEXTURE_3D_INDEX, NO_EXTRA },
		707	{ GL_MAX_3D_TEXTURE_SIZE, LOC_CUSTOM, TYPE_INT,
		708	offsetof(struct gl_context, Const.Max3DTextureLevels), NO_EXTRA },
		709
		710	/* GL_ARB_fragment_program/OES_standard_derivatives */
		711	{ GL_FRAGMENT_SHADER_DERIVATIVE_HINT_ARB,
		712	CONTEXT_ENUM(Hint.FragmentShaderDerivative), extra_ARB_fragment_shader },
		713	#endif /* FEATURE_GL \|\| FEATURE_ES2 */
		714
		715	#if FEATURE_ES2
		716	/* Enums unique to OpenGL ES 2.0 */
		717	{ 0, 0, TYPE_API_MASK, API_OPENGLES2_BIT, NO_EXTRA },
		718	{ GL_MAX_FRAGMENT_UNIFORM_VECTORS, LOC_CUSTOM, TYPE_INT, 0, NO_EXTRA },
		719	{ GL_MAX_VARYING_VECTORS, CONTEXT_INT(Const.MaxVarying), NO_EXTRA },
		720	{ GL_MAX_VERTEX_UNIFORM_VECTORS, LOC_CUSTOM, TYPE_INT, 0, NO_EXTRA },
		721	{ GL_SHADER_COMPILER, CONST(1), NO_EXTRA },
		722	/* OES_get_program_binary */
		723	{ GL_NUM_SHADER_BINARY_FORMATS, CONST(0), NO_EXTRA },
		724	{ GL_SHADER_BINARY_FORMATS, CONST(0), NO_EXTRA },
		725	#endif /* FEATURE_ES2 */
		726
		727	#if FEATURE_GL
		728	/* Remaining enums are only in OpenGL */
		729	{ 0, 0, TYPE_API_MASK, API_OPENGL_BIT, NO_EXTRA },
		730	{ GL_ACCUM_RED_BITS, BUFFER_INT(Visual.accumRedBits), NO_EXTRA },
		731	{ GL_ACCUM_GREEN_BITS, BUFFER_INT(Visual.accumGreenBits), NO_EXTRA },
		732	{ GL_ACCUM_BLUE_BITS, BUFFER_INT(Visual.accumBlueBits), NO_EXTRA },
		733	{ GL_ACCUM_ALPHA_BITS, BUFFER_INT(Visual.accumAlphaBits), NO_EXTRA },
		734	{ GL_ACCUM_CLEAR_VALUE, CONTEXT_FIELD(Accum.ClearColor[0], TYPE_FLOATN_4), NO_EXTRA },
		735	{ GL_ALPHA_BIAS, CONTEXT_FLOAT(Pixel.AlphaBias), NO_EXTRA },
		736	{ GL_ALPHA_SCALE, CONTEXT_FLOAT(Pixel.AlphaScale), NO_EXTRA },
		737	{ GL_ATTRIB_STACK_DEPTH, CONTEXT_INT(AttribStackDepth), NO_EXTRA },
		738	{ GL_AUTO_NORMAL, CONTEXT_BOOL(Eval.AutoNormal), NO_EXTRA },
		739	{ GL_AUX_BUFFERS, BUFFER_INT(Visual.numAuxBuffers), NO_EXTRA },
		740	{ GL_BLUE_BIAS, CONTEXT_FLOAT(Pixel.BlueBias), NO_EXTRA },
		741	{ GL_BLUE_SCALE, CONTEXT_FLOAT(Pixel.BlueScale), NO_EXTRA },
		742	{ GL_CLIENT_ATTRIB_STACK_DEPTH, CONTEXT_INT(ClientAttribStackDepth), NO_EXTRA },
		743	{ GL_COLOR_MATERIAL_FACE, CONTEXT_ENUM(Light.ColorMaterialFace), NO_EXTRA },
		744	{ GL_COLOR_MATERIAL_PARAMETER, CONTEXT_ENUM(Light.ColorMaterialMode), NO_EXTRA },
		745	{ GL_CURRENT_INDEX,
		746	CONTEXT_FLOAT(Current.Attrib[VERT_ATTRIB_COLOR_INDEX][0]),
		747	extra_flush_current },
		748	{ GL_CURRENT_RASTER_COLOR,
		749	CONTEXT_FIELD(Current.RasterColor[0], TYPE_FLOATN_4), NO_EXTRA },
		750	{ GL_CURRENT_RASTER_DISTANCE, CONTEXT_FLOAT(Current.RasterDistance), NO_EXTRA },
		751	{ GL_CURRENT_RASTER_INDEX, CONST(1), NO_EXTRA },
		752	{ GL_CURRENT_RASTER_POSITION, CONTEXT_FLOAT4(Current.RasterPos[0]), NO_EXTRA },
		753	{ GL_CURRENT_RASTER_SECONDARY_COLOR,
		754	CONTEXT_FIELD(Current.RasterSecondaryColor[0], TYPE_FLOATN_4), NO_EXTRA },
		755	{ GL_CURRENT_RASTER_TEXTURE_COORDS, LOC_CUSTOM, TYPE_FLOAT_4, 0,
		756	extra_valid_texture_unit },
		757	{ GL_CURRENT_RASTER_POSITION_VALID, CONTEXT_BOOL(Current.RasterPosValid), NO_EXTRA },
		758	{ GL_DEPTH_BIAS, CONTEXT_FLOAT(Pixel.DepthBias), NO_EXTRA },
		759	{ GL_DEPTH_SCALE, CONTEXT_FLOAT(Pixel.DepthScale), NO_EXTRA },
		760	{ GL_DOUBLEBUFFER, BUFFER_INT(Visual.doubleBufferMode), NO_EXTRA },
		761	{ GL_DRAW_BUFFER, BUFFER_ENUM(ColorDrawBuffer[0]), NO_EXTRA },
		762	{ GL_EDGE_FLAG, LOC_CUSTOM, TYPE_BOOLEAN, 0, NO_EXTRA },
		763	{ GL_FEEDBACK_BUFFER_SIZE, CONTEXT_INT(Feedback.BufferSize), NO_EXTRA },
		764	{ GL_FEEDBACK_BUFFER_TYPE, CONTEXT_ENUM(Feedback.Type), NO_EXTRA },
		765	{ GL_FOG_INDEX, CONTEXT_FLOAT(Fog.Index), NO_EXTRA },
		766	{ GL_GREEN_BIAS, CONTEXT_FLOAT(Pixel.GreenBias), NO_EXTRA },
		767	{ GL_GREEN_SCALE, CONTEXT_FLOAT(Pixel.GreenScale), NO_EXTRA },
		768	{ GL_INDEX_BITS, BUFFER_INT(Visual.indexBits), extra_new_buffers },
		769	{ GL_INDEX_CLEAR_VALUE, CONTEXT_INT(Color.ClearIndex), NO_EXTRA },
		770	{ GL_INDEX_MODE, CONST(0) , NO_EXTRA},
		771	{ GL_INDEX_OFFSET, CONTEXT_INT(Pixel.IndexOffset), NO_EXTRA },
		772	{ GL_INDEX_SHIFT, CONTEXT_INT(Pixel.IndexShift), NO_EXTRA },
		773	{ GL_INDEX_WRITEMASK, CONTEXT_INT(Color.IndexMask), NO_EXTRA },
		774	{ GL_LIGHT_MODEL_COLOR_CONTROL, CONTEXT_ENUM(Light.Model.ColorControl), NO_EXTRA },
		775	{ GL_LIGHT_MODEL_LOCAL_VIEWER, CONTEXT_BOOL(Light.Model.LocalViewer), NO_EXTRA },
		776	{ GL_LINE_STIPPLE, CONTEXT_BOOL(Line.StippleFlag), NO_EXTRA },
		777	{ GL_LINE_STIPPLE_PATTERN, LOC_CUSTOM, TYPE_INT, 0, NO_EXTRA },
		778	{ GL_LINE_STIPPLE_REPEAT, CONTEXT_INT(Line.StippleFactor), NO_EXTRA },
		779	{ GL_LINE_WIDTH_GRANULARITY, CONTEXT_FLOAT(Const.LineWidthGranularity), NO_EXTRA },
		780	{ GL_LIST_BASE, CONTEXT_INT(List.ListBase), NO_EXTRA },
		781	{ GL_LIST_INDEX, LOC_CUSTOM, TYPE_INT, 0, NO_EXTRA },
		782	{ GL_LIST_MODE, LOC_CUSTOM, TYPE_ENUM, 0, NO_EXTRA },
		783	{ GL_INDEX_LOGIC_OP, CONTEXT_BOOL(Color.IndexLogicOpEnabled), NO_EXTRA },
		784	{ GL_MAP1_COLOR_4, CONTEXT_BOOL(Eval.Map1Color4), NO_EXTRA },
		785	{ GL_MAP1_GRID_DOMAIN, CONTEXT_FLOAT2(Eval.MapGrid1u1), NO_EXTRA },
		786	{ GL_MAP1_GRID_SEGMENTS, CONTEXT_INT(Eval.MapGrid1un), NO_EXTRA },
		787	{ GL_MAP1_INDEX, CONTEXT_BOOL(Eval.Map1Index), NO_EXTRA },
		788	{ GL_MAP1_NORMAL, CONTEXT_BOOL(Eval.Map1Normal), NO_EXTRA },
		789	{ GL_MAP1_TEXTURE_COORD_1, CONTEXT_BOOL(Eval.Map1TextureCoord1), NO_EXTRA },
		790	{ GL_MAP1_TEXTURE_COORD_2, CONTEXT_BOOL(Eval.Map1TextureCoord2), NO_EXTRA },
		791	{ GL_MAP1_TEXTURE_COORD_3, CONTEXT_BOOL(Eval.Map1TextureCoord3), NO_EXTRA },
		792	{ GL_MAP1_TEXTURE_COORD_4, CONTEXT_BOOL(Eval.Map1TextureCoord4), NO_EXTRA },
		793	{ GL_MAP1_VERTEX_3, CONTEXT_BOOL(Eval.Map1Vertex3), NO_EXTRA },
		794	{ GL_MAP1_VERTEX_4, CONTEXT_BOOL(Eval.Map1Vertex4), NO_EXTRA },
		795	{ GL_MAP2_COLOR_4, CONTEXT_BOOL(Eval.Map2Color4), NO_EXTRA },
		796	{ GL_MAP2_GRID_DOMAIN, LOC_CUSTOM, TYPE_FLOAT_4, 0, NO_EXTRA },
		797	{ GL_MAP2_GRID_SEGMENTS, CONTEXT_INT2(Eval.MapGrid2un), NO_EXTRA },
		798	{ GL_MAP2_INDEX, CONTEXT_BOOL(Eval.Map2Index), NO_EXTRA },
		799	{ GL_MAP2_NORMAL, CONTEXT_BOOL(Eval.Map2Normal), NO_EXTRA },
		800	{ GL_MAP2_TEXTURE_COORD_1, CONTEXT_BOOL(Eval.Map2TextureCoord1), NO_EXTRA },
		801	{ GL_MAP2_TEXTURE_COORD_2, CONTEXT_BOOL(Eval.Map2TextureCoord2), NO_EXTRA },
		802	{ GL_MAP2_TEXTURE_COORD_3, CONTEXT_BOOL(Eval.Map2TextureCoord3), NO_EXTRA },
		803	{ GL_MAP2_TEXTURE_COORD_4, CONTEXT_BOOL(Eval.Map2TextureCoord4), NO_EXTRA },
		804	{ GL_MAP2_VERTEX_3, CONTEXT_BOOL(Eval.Map2Vertex3), NO_EXTRA },
		805	{ GL_MAP2_VERTEX_4, CONTEXT_BOOL(Eval.Map2Vertex4), NO_EXTRA },
		806	{ GL_MAP_COLOR, CONTEXT_BOOL(Pixel.MapColorFlag), NO_EXTRA },
		807	{ GL_MAP_STENCIL, CONTEXT_BOOL(Pixel.MapStencilFlag), NO_EXTRA },
		808	{ GL_MAX_ATTRIB_STACK_DEPTH, CONST(MAX_ATTRIB_STACK_DEPTH), NO_EXTRA },
		809	{ GL_MAX_CLIENT_ATTRIB_STACK_DEPTH, CONST(MAX_CLIENT_ATTRIB_STACK_DEPTH), NO_EXTRA },
		810
		811	{ GL_MAX_EVAL_ORDER, CONST(MAX_EVAL_ORDER), NO_EXTRA },
		812	{ GL_MAX_LIST_NESTING, CONST(MAX_LIST_NESTING), NO_EXTRA },
		813	{ GL_MAX_NAME_STACK_DEPTH, CONST(MAX_NAME_STACK_DEPTH), NO_EXTRA },
		814	{ GL_MAX_PIXEL_MAP_TABLE, CONST(MAX_PIXEL_MAP_TABLE), NO_EXTRA },
		815	{ GL_NAME_STACK_DEPTH, CONTEXT_INT(Select.NameStackDepth), NO_EXTRA },
		816	{ GL_PACK_LSB_FIRST, CONTEXT_BOOL(Pack.LsbFirst), NO_EXTRA },
		817	{ GL_PACK_ROW_LENGTH, CONTEXT_INT(Pack.RowLength), NO_EXTRA },
		818	{ GL_PACK_SKIP_PIXELS, CONTEXT_INT(Pack.SkipPixels), NO_EXTRA },
		819	{ GL_PACK_SKIP_ROWS, CONTEXT_INT(Pack.SkipRows), NO_EXTRA },
		820	{ GL_PACK_SWAP_BYTES, CONTEXT_BOOL(Pack.SwapBytes), NO_EXTRA },
		821	{ GL_PACK_IMAGE_HEIGHT_EXT, CONTEXT_INT(Pack.ImageHeight), NO_EXTRA },
		822	{ GL_PACK_INVERT_MESA, CONTEXT_BOOL(Pack.Invert), NO_EXTRA },
		823	{ GL_PIXEL_MAP_A_TO_A_SIZE, CONTEXT_INT(PixelMaps.AtoA.Size), NO_EXTRA },
		824	{ GL_PIXEL_MAP_B_TO_B_SIZE, CONTEXT_INT(PixelMaps.BtoB.Size), NO_EXTRA },
		825	{ GL_PIXEL_MAP_G_TO_G_SIZE, CONTEXT_INT(PixelMaps.GtoG.Size), NO_EXTRA },
		826	{ GL_PIXEL_MAP_I_TO_A_SIZE, CONTEXT_INT(PixelMaps.ItoA.Size), NO_EXTRA },
		827	{ GL_PIXEL_MAP_I_TO_B_SIZE, CONTEXT_INT(PixelMaps.ItoB.Size), NO_EXTRA },
		828	{ GL_PIXEL_MAP_I_TO_G_SIZE, CONTEXT_INT(PixelMaps.ItoG.Size), NO_EXTRA },
		829	{ GL_PIXEL_MAP_I_TO_I_SIZE, CONTEXT_INT(PixelMaps.ItoI.Size), NO_EXTRA },
		830	{ GL_PIXEL_MAP_I_TO_R_SIZE, CONTEXT_INT(PixelMaps.ItoR.Size), NO_EXTRA },
		831	{ GL_PIXEL_MAP_R_TO_R_SIZE, CONTEXT_INT(PixelMaps.RtoR.Size), NO_EXTRA },
		832	{ GL_PIXEL_MAP_S_TO_S_SIZE, CONTEXT_INT(PixelMaps.StoS.Size), NO_EXTRA },
		833	{ GL_POINT_SIZE_GRANULARITY, CONTEXT_FLOAT(Const.PointSizeGranularity), NO_EXTRA },
		834	{ GL_POLYGON_MODE, CONTEXT_ENUM2(Polygon.FrontMode), NO_EXTRA },
		835	{ GL_POLYGON_OFFSET_BIAS_EXT, CONTEXT_FLOAT(Polygon.OffsetUnits), NO_EXTRA },
		836	{ GL_POLYGON_OFFSET_POINT, CONTEXT_BOOL(Polygon.OffsetPoint), NO_EXTRA },
		837	{ GL_POLYGON_OFFSET_LINE, CONTEXT_BOOL(Polygon.OffsetLine), NO_EXTRA },
		838	{ GL_POLYGON_SMOOTH, CONTEXT_BOOL(Polygon.SmoothFlag), NO_EXTRA },
		839	{ GL_POLYGON_SMOOTH_HINT, CONTEXT_ENUM(Hint.PolygonSmooth), NO_EXTRA },
		840	{ GL_POLYGON_STIPPLE, CONTEXT_BOOL(Polygon.StippleFlag), NO_EXTRA },
		841	{ GL_READ_BUFFER, LOC_CUSTOM, TYPE_ENUM, NO_OFFSET, NO_EXTRA },
		842	{ GL_RED_BIAS, CONTEXT_FLOAT(Pixel.RedBias), NO_EXTRA },
		843	{ GL_RED_SCALE, CONTEXT_FLOAT(Pixel.RedScale), NO_EXTRA },
		844	{ GL_RENDER_MODE, CONTEXT_ENUM(RenderMode), NO_EXTRA },
		845	{ GL_RGBA_MODE, CONST(1), NO_EXTRA },
		846	{ GL_SELECTION_BUFFER_SIZE, CONTEXT_INT(Select.BufferSize), NO_EXTRA },
		847	{ GL_SHARED_TEXTURE_PALETTE_EXT, CONTEXT_BOOL(Texture.SharedPalette), NO_EXTRA },
		848
		849	{ GL_STEREO, BUFFER_INT(Visual.stereoMode), NO_EXTRA },
		850
		851	{ GL_TEXTURE_1D, LOC_CUSTOM, TYPE_BOOLEAN, NO_OFFSET, NO_EXTRA },
		852	{ GL_TEXTURE_3D, LOC_CUSTOM, TYPE_BOOLEAN, NO_OFFSET, NO_EXTRA },
		853	{ GL_TEXTURE_1D_ARRAY_EXT, LOC_CUSTOM, TYPE_BOOLEAN, NO_OFFSET, NO_EXTRA },
		854	{ GL_TEXTURE_2D_ARRAY_EXT, LOC_CUSTOM, TYPE_BOOLEAN, NO_OFFSET, NO_EXTRA },
		855
		856	{ GL_TEXTURE_BINDING_1D, LOC_CUSTOM, TYPE_INT, TEXTURE_1D_INDEX, NO_EXTRA },
		857	{ GL_TEXTURE_BINDING_1D_ARRAY, LOC_CUSTOM, TYPE_INT,
		858	TEXTURE_1D_ARRAY_INDEX, extra_MESA_texture_array },
		859	{ GL_TEXTURE_BINDING_2D_ARRAY, LOC_CUSTOM, TYPE_INT,
		860	TEXTURE_1D_ARRAY_INDEX, extra_MESA_texture_array },
		861	{ GL_MAX_ARRAY_TEXTURE_LAYERS_EXT,
		862	CONTEXT_INT(Const.MaxArrayTextureLayers), extra_MESA_texture_array },
		863
		864	{ GL_TEXTURE_GEN_S, LOC_TEXUNIT, TYPE_BIT_0,
		865	offsetof(struct gl_texture_unit, TexGenEnabled), NO_EXTRA },
		866	{ GL_TEXTURE_GEN_T, LOC_TEXUNIT, TYPE_BIT_1,
		867	offsetof(struct gl_texture_unit, TexGenEnabled), NO_EXTRA },
		868	{ GL_TEXTURE_GEN_R, LOC_TEXUNIT, TYPE_BIT_2,
		869	offsetof(struct gl_texture_unit, TexGenEnabled), NO_EXTRA },
		870	{ GL_TEXTURE_GEN_Q, LOC_TEXUNIT, TYPE_BIT_3,
		871	offsetof(struct gl_texture_unit, TexGenEnabled), NO_EXTRA },
		872	{ GL_UNPACK_LSB_FIRST, CONTEXT_BOOL(Unpack.LsbFirst), NO_EXTRA },
		873	{ GL_UNPACK_ROW_LENGTH, CONTEXT_INT(Unpack.RowLength), NO_EXTRA },
		874	{ GL_UNPACK_SKIP_PIXELS, CONTEXT_INT(Unpack.SkipPixels), NO_EXTRA },
		875	{ GL_UNPACK_SKIP_ROWS, CONTEXT_INT(Unpack.SkipRows), NO_EXTRA },
		876	{ GL_UNPACK_SWAP_BYTES, CONTEXT_BOOL(Unpack.SwapBytes), NO_EXTRA },
		877	{ GL_UNPACK_SKIP_IMAGES_EXT, CONTEXT_INT(Unpack.SkipImages), NO_EXTRA },
		878	{ GL_UNPACK_IMAGE_HEIGHT_EXT, CONTEXT_INT(Unpack.ImageHeight), NO_EXTRA },
		879	{ GL_UNPACK_CLIENT_STORAGE_APPLE, CONTEXT_BOOL(Unpack.ClientStorage), NO_EXTRA },
		880	{ GL_ZOOM_X, CONTEXT_FLOAT(Pixel.ZoomX), NO_EXTRA },
		881	{ GL_ZOOM_Y, CONTEXT_FLOAT(Pixel.ZoomY), NO_EXTRA },
		882
		883	/* Vertex arrays */
		884	{ GL_VERTEX_ARRAY_COUNT_EXT, CONST(0), NO_EXTRA },
		885	{ GL_NORMAL_ARRAY_COUNT_EXT, CONST(0), NO_EXTRA },
		886	{ GL_COLOR_ARRAY_COUNT_EXT, CONST(0), NO_EXTRA },
		887	{ GL_INDEX_ARRAY, ARRAY_BOOL(Index.Enabled), NO_EXTRA },
		888	{ GL_INDEX_ARRAY_TYPE, ARRAY_ENUM(Index.Type), NO_EXTRA },
		889	{ GL_INDEX_ARRAY_STRIDE, ARRAY_INT(Index.Stride), NO_EXTRA },
		890	{ GL_INDEX_ARRAY_COUNT_EXT, CONST(0), NO_EXTRA },
		891	{ GL_TEXTURE_COORD_ARRAY_COUNT_EXT, CONST(0), NO_EXTRA },
		892	{ GL_EDGE_FLAG_ARRAY, ARRAY_BOOL(EdgeFlag.Enabled), NO_EXTRA },
		893	{ GL_EDGE_FLAG_ARRAY_STRIDE, ARRAY_INT(EdgeFlag.Stride), NO_EXTRA },
		894	{ GL_EDGE_FLAG_ARRAY_COUNT_EXT, CONST(0), NO_EXTRA },
		895
		896	/* GL_ARB_texture_compression */
		897	{ GL_TEXTURE_COMPRESSION_HINT_ARB, CONTEXT_INT(Hint.TextureCompression), NO_EXTRA },
		898
		899	/* GL_EXT_compiled_vertex_array */
		900	{ GL_ARRAY_ELEMENT_LOCK_FIRST_EXT, CONTEXT_INT(Array.LockFirst),
		901	extra_EXT_compiled_vertex_array },
		902	{ GL_ARRAY_ELEMENT_LOCK_COUNT_EXT, CONTEXT_INT(Array.LockCount),
		903	extra_EXT_compiled_vertex_array },
		904
		905	/* GL_ARB_transpose_matrix */
		906	{ GL_TRANSPOSE_MODELVIEW_MATRIX_ARB,
		907	CONTEXT_MATRIX_T(ModelviewMatrixStack), NO_EXTRA },
		908	{ GL_TRANSPOSE_PROJECTION_MATRIX_ARB,
		909	CONTEXT_MATRIX_T(ProjectionMatrixStack.Top), NO_EXTRA },
		910	{ GL_TRANSPOSE_TEXTURE_MATRIX_ARB, CONTEXT_MATRIX_T(TextureMatrixStack), NO_EXTRA },
		911
		912	/* GL_SGI_texture_color_table */
		913	{ GL_TEXTURE_COLOR_TABLE_SGI, LOC_TEXUNIT, TYPE_BOOLEAN,
		914	offsetof(struct gl_texture_unit, ColorTableEnabled),
		915	extra_SGI_texture_color_table },
		916
		917	/* GL_EXT_secondary_color */
		918	{ GL_COLOR_SUM_EXT, CONTEXT_BOOL(Fog.ColorSumEnabled),
		919	extra_EXT_secondary_color_ARB_vertex_program },
		920	{ GL_CURRENT_SECONDARY_COLOR_EXT,
		921	CONTEXT_FIELD(Current.Attrib[VERT_ATTRIB_COLOR1][0], TYPE_FLOATN_4),
		922	extra_EXT_secondary_color_flush_current },
		923	{ GL_SECONDARY_COLOR_ARRAY_EXT, ARRAY_BOOL(SecondaryColor.Enabled),
		924	extra_EXT_secondary_color },
		925	{ GL_SECONDARY_COLOR_ARRAY_TYPE_EXT, ARRAY_ENUM(SecondaryColor.Type),
		926	extra_EXT_secondary_color },
		927	{ GL_SECONDARY_COLOR_ARRAY_STRIDE_EXT, ARRAY_INT(SecondaryColor.Stride),
		928	extra_EXT_secondary_color },
		929	{ GL_SECONDARY_COLOR_ARRAY_SIZE_EXT, ARRAY_INT(SecondaryColor.Size),
		930	extra_EXT_secondary_color },
		931
		932	/* GL_EXT_fog_coord */
		933	{ GL_CURRENT_FOG_COORDINATE_EXT,
		934	CONTEXT_FLOAT(Current.Attrib[VERT_ATTRIB_FOG][0]),
		935	extra_EXT_fog_coord_flush_current },
		936	{ GL_FOG_COORDINATE_ARRAY_EXT, ARRAY_BOOL(FogCoord.Enabled),
		937	extra_EXT_fog_coord },
		938	{ GL_FOG_COORDINATE_ARRAY_TYPE_EXT, ARRAY_ENUM(FogCoord.Type),
		939	extra_EXT_fog_coord },
		940	{ GL_FOG_COORDINATE_ARRAY_STRIDE_EXT, ARRAY_INT(FogCoord.Stride),
		941	extra_EXT_fog_coord },
		942	{ GL_FOG_COORDINATE_SOURCE_EXT, CONTEXT_ENUM(Fog.FogCoordinateSource),
		943	extra_EXT_fog_coord },
		944
		945	/* GL_IBM_rasterpos_clip */
		946	{ GL_RASTER_POSITION_UNCLIPPED_IBM,
		947	CONTEXT_BOOL(Transform.RasterPositionUnclipped),
		948	extra_IBM_rasterpos_clip },
		949
		950	/* GL_NV_point_sprite */
		951	{ GL_POINT_SPRITE_R_MODE_NV,
		952	CONTEXT_ENUM(Point.SpriteRMode), extra_NV_point_sprite },
		953	{ GL_POINT_SPRITE_COORD_ORIGIN, CONTEXT_ENUM(Point.SpriteOrigin),
		954	extra_NV_point_sprite_ARB_point_sprite },
		955
		956	/* GL_NV_vertex_program */
		957	{ GL_VERTEX_PROGRAM_BINDING_NV, LOC_CUSTOM, TYPE_INT, 0,
		958	extra_NV_vertex_program },
		959	{ GL_VERTEX_ATTRIB_ARRAY0_NV, ARRAY_BOOL(VertexAttrib[0].Enabled),
		960	extra_NV_vertex_program },
		961	{ GL_VERTEX_ATTRIB_ARRAY1_NV, ARRAY_BOOL(VertexAttrib[1].Enabled),
		962	extra_NV_vertex_program },
		963	{ GL_VERTEX_ATTRIB_ARRAY2_NV, ARRAY_BOOL(VertexAttrib[2].Enabled),
		964	extra_NV_vertex_program },
		965	{ GL_VERTEX_ATTRIB_ARRAY3_NV, ARRAY_BOOL(VertexAttrib[3].Enabled),
		966	extra_NV_vertex_program },
		967	{ GL_VERTEX_ATTRIB_ARRAY4_NV, ARRAY_BOOL(VertexAttrib[4].Enabled),
		968	extra_NV_vertex_program },
		969	{ GL_VERTEX_ATTRIB_ARRAY5_NV, ARRAY_BOOL(VertexAttrib[5].Enabled),
		970	extra_NV_vertex_program },
		971	{ GL_VERTEX_ATTRIB_ARRAY6_NV, ARRAY_BOOL(VertexAttrib[6].Enabled),
		972	extra_NV_vertex_program },
		973	{ GL_VERTEX_ATTRIB_ARRAY7_NV, ARRAY_BOOL(VertexAttrib[7].Enabled),
		974	extra_NV_vertex_program },
		975	{ GL_VERTEX_ATTRIB_ARRAY8_NV, ARRAY_BOOL(VertexAttrib[8].Enabled),
		976	extra_NV_vertex_program },
		977	{ GL_VERTEX_ATTRIB_ARRAY9_NV, ARRAY_BOOL(VertexAttrib[9].Enabled),
		978	extra_NV_vertex_program },
		979	{ GL_VERTEX_ATTRIB_ARRAY10_NV, ARRAY_BOOL(VertexAttrib[10].Enabled),
		980	extra_NV_vertex_program },
		981	{ GL_VERTEX_ATTRIB_ARRAY11_NV, ARRAY_BOOL(VertexAttrib[11].Enabled),
		982	extra_NV_vertex_program },
		983	{ GL_VERTEX_ATTRIB_ARRAY12_NV, ARRAY_BOOL(VertexAttrib[12].Enabled),
		984	extra_NV_vertex_program },
		985	{ GL_VERTEX_ATTRIB_ARRAY13_NV, ARRAY_BOOL(VertexAttrib[13].Enabled),
		986	extra_NV_vertex_program },
		987	{ GL_VERTEX_ATTRIB_ARRAY14_NV, ARRAY_BOOL(VertexAttrib[14].Enabled),
		988	extra_NV_vertex_program },
		989	{ GL_VERTEX_ATTRIB_ARRAY15_NV, ARRAY_BOOL(VertexAttrib[15].Enabled),
		990	extra_NV_vertex_program },
		991	{ GL_MAP1_VERTEX_ATTRIB0_4_NV, CONTEXT_BOOL(Eval.Map1Attrib[0]),
		992	extra_NV_vertex_program },
		993	{ GL_MAP1_VERTEX_ATTRIB1_4_NV, CONTEXT_BOOL(Eval.Map1Attrib[1]),
		994	extra_NV_vertex_program },
		995	{ GL_MAP1_VERTEX_ATTRIB2_4_NV, CONTEXT_BOOL(Eval.Map1Attrib[2]),
		996	extra_NV_vertex_program },
		997	{ GL_MAP1_VERTEX_ATTRIB3_4_NV, CONTEXT_BOOL(Eval.Map1Attrib[3]),
		998	extra_NV_vertex_program },
		999	{ GL_MAP1_VERTEX_ATTRIB4_4_NV, CONTEXT_BOOL(Eval.Map1Attrib[4]),
		1000	extra_NV_vertex_program },
		1001	{ GL_MAP1_VERTEX_ATTRIB5_4_NV, CONTEXT_BOOL(Eval.Map1Attrib[5]),
		1002	extra_NV_vertex_program },
		1003	{ GL_MAP1_VERTEX_ATTRIB6_4_NV, CONTEXT_BOOL(Eval.Map1Attrib[6]),
		1004	extra_NV_vertex_program },
		1005	{ GL_MAP1_VERTEX_ATTRIB7_4_NV, CONTEXT_BOOL(Eval.Map1Attrib[7]),
		1006	extra_NV_vertex_program },
		1007	{ GL_MAP1_VERTEX_ATTRIB8_4_NV, CONTEXT_BOOL(Eval.Map1Attrib[8]),
		1008	extra_NV_vertex_program },
		1009	{ GL_MAP1_VERTEX_ATTRIB9_4_NV, CONTEXT_BOOL(Eval.Map1Attrib[9]),
		1010	extra_NV_vertex_program },
		1011	{ GL_MAP1_VERTEX_ATTRIB10_4_NV, CONTEXT_BOOL(Eval.Map1Attrib[10]),
		1012	extra_NV_vertex_program },
		1013	{ GL_MAP1_VERTEX_ATTRIB11_4_NV, CONTEXT_BOOL(Eval.Map1Attrib[11]),
		1014	extra_NV_vertex_program },
		1015	{ GL_MAP1_VERTEX_ATTRIB12_4_NV, CONTEXT_BOOL(Eval.Map1Attrib[12]),
		1016	extra_NV_vertex_program },
		1017	{ GL_MAP1_VERTEX_ATTRIB13_4_NV, CONTEXT_BOOL(Eval.Map1Attrib[13]),
		1018	extra_NV_vertex_program },
		1019	{ GL_MAP1_VERTEX_ATTRIB14_4_NV, CONTEXT_BOOL(Eval.Map1Attrib[14]),
		1020	extra_NV_vertex_program },
		1021	{ GL_MAP1_VERTEX_ATTRIB15_4_NV, CONTEXT_BOOL(Eval.Map1Attrib[15]),
		1022	extra_NV_vertex_program },
		1023
		1024	/* GL_NV_fragment_program */
		1025	{ GL_FRAGMENT_PROGRAM_NV, CONTEXT_BOOL(FragmentProgram.Enabled),
		1026	extra_NV_fragment_program },
		1027	{ GL_FRAGMENT_PROGRAM_BINDING_NV, LOC_CUSTOM, TYPE_INT, 0,
		1028	extra_NV_fragment_program },
		1029	{ GL_MAX_FRAGMENT_PROGRAM_LOCAL_PARAMETERS_NV,
		1030	CONST(MAX_NV_FRAGMENT_PROGRAM_PARAMS),
		1031	extra_NV_fragment_program },
		1032
		1033	/* GL_NV_texture_rectangle */
		1034	{ GL_TEXTURE_RECTANGLE_NV,
		1035	LOC_CUSTOM, TYPE_BOOLEAN, 0, extra_NV_texture_rectangle },
		1036	{ GL_TEXTURE_BINDING_RECTANGLE_NV,
		1037	LOC_CUSTOM, TYPE_INT, TEXTURE_RECT_INDEX, extra_NV_texture_rectangle },
		1038	{ GL_MAX_RECTANGLE_TEXTURE_SIZE_NV,
		1039	CONTEXT_INT(Const.MaxTextureRectSize), extra_NV_texture_rectangle },
		1040
		1041	/* GL_EXT_stencil_two_side */
		1042	{ GL_STENCIL_TEST_TWO_SIDE_EXT, CONTEXT_BOOL(Stencil.TestTwoSide),
		1043	extra_EXT_stencil_two_side },
		1044	{ GL_ACTIVE_STENCIL_FACE_EXT, LOC_CUSTOM, TYPE_ENUM, NO_OFFSET, NO_EXTRA },
		1045
		1046	/* GL_NV_light_max_exponent */
		1047	{ GL_MAX_SHININESS_NV, CONTEXT_FLOAT(Const.MaxShininess),
		1048	extra_NV_light_max_exponent },
		1049	{ GL_MAX_SPOT_EXPONENT_NV, CONTEXT_FLOAT(Const.MaxSpotExponent),
		1050	extra_NV_light_max_exponent },
		1051
		1052	/* GL_NV_primitive_restart */
		1053	{ GL_PRIMITIVE_RESTART_NV, CONTEXT_BOOL(Array.PrimitiveRestart),
		1054	extra_NV_primitive_restart },
		1055	{ GL_PRIMITIVE_RESTART_INDEX_NV, CONTEXT_INT(Array.RestartIndex),
		1056	extra_NV_primitive_restart },
		1057
		1058	/* GL_ARB_vertex_buffer_object */
		1059	{ GL_INDEX_ARRAY_BUFFER_BINDING_ARB, LOC_CUSTOM, TYPE_INT,
		1060	offsetof(struct gl_array_object, Index.BufferObj), NO_EXTRA },
		1061	{ GL_EDGE_FLAG_ARRAY_BUFFER_BINDING_ARB, LOC_CUSTOM, TYPE_INT,
		1062	offsetof(struct gl_array_object, EdgeFlag.BufferObj), NO_EXTRA },
		1063	{ GL_SECONDARY_COLOR_ARRAY_BUFFER_BINDING_ARB, LOC_CUSTOM, TYPE_INT,
		1064	offsetof(struct gl_array_object, SecondaryColor.BufferObj), NO_EXTRA },
		1065	{ GL_FOG_COORDINATE_ARRAY_BUFFER_BINDING_ARB, LOC_CUSTOM, TYPE_INT,
		1066	offsetof(struct gl_array_object, FogCoord.BufferObj), NO_EXTRA },
		1067
		1068	/* GL_EXT_pixel_buffer_object */
		1069	{ GL_PIXEL_PACK_BUFFER_BINDING_EXT, LOC_CUSTOM, TYPE_INT, 0,
		1070	extra_EXT_pixel_buffer_object },
		1071	{ GL_PIXEL_UNPACK_BUFFER_BINDING_EXT, LOC_CUSTOM, TYPE_INT, 0,
		1072	extra_EXT_pixel_buffer_object },
		1073
		1074	/* GL_ARB_vertex_program */
		1075	{ GL_VERTEX_PROGRAM_ARB, /* == GL_VERTEX_PROGRAM_NV */
		1076	CONTEXT_BOOL(VertexProgram.Enabled),
		1077	extra_ARB_vertex_program_NV_vertex_program },
		1078	{ GL_VERTEX_PROGRAM_POINT_SIZE_ARB, /* == GL_VERTEX_PROGRAM_POINT_SIZE_NV*/
		1079	CONTEXT_BOOL(VertexProgram.PointSizeEnabled),
		1080	extra_ARB_vertex_program_NV_vertex_program },
		1081	{ GL_VERTEX_PROGRAM_TWO_SIDE_ARB, /* == GL_VERTEX_PROGRAM_TWO_SIDE_NV */
		1082	CONTEXT_BOOL(VertexProgram.TwoSideEnabled),
		1083	extra_ARB_vertex_program_NV_vertex_program },
		1084	{ GL_MAX_PROGRAM_MATRIX_STACK_DEPTH_ARB, /* == GL_MAX_TRACK_MATRIX_STACK_DEPTH_NV */
		1085	CONTEXT_INT(Const.MaxProgramMatrixStackDepth),
		1086	extra_ARB_vertex_program_ARB_fragment_program_NV_vertex_program },
		1087	{ GL_MAX_PROGRAM_MATRICES_ARB, /* == GL_MAX_TRACK_MATRICES_NV */
		1088	CONTEXT_INT(Const.MaxProgramMatrices),
		1089	extra_ARB_vertex_program_ARB_fragment_program_NV_vertex_program },
		1090	{ GL_CURRENT_MATRIX_STACK_DEPTH_ARB, /* == GL_CURRENT_MATRIX_STACK_DEPTH_NV */
		1091	LOC_CUSTOM, TYPE_INT, 0,
		1092	extra_ARB_vertex_program_ARB_fragment_program_NV_vertex_program },
		1093
		1094	{ GL_CURRENT_MATRIX_ARB, /* == GL_CURRENT_MATRIX_NV */
		1095	LOC_CUSTOM, TYPE_MATRIX, 0,
		1096	extra_ARB_vertex_program_ARB_fragment_program_NV_vertex_program },
		1097	{ GL_TRANSPOSE_CURRENT_MATRIX_ARB, /* == GL_CURRENT_MATRIX_NV */
		1098	LOC_CUSTOM, TYPE_MATRIX, 0,
		1099	extra_ARB_vertex_program_ARB_fragment_program },
		1100
		1101	{ GL_PROGRAM_ERROR_POSITION_ARB, /* == GL_PROGRAM_ERROR_POSITION_NV */
		1102	CONTEXT_INT(Program.ErrorPos),
		1103	extra_NV_vertex_program_ARB_vertex_program_ARB_fragment_program_NV_vertex_program },
		1104
		1105	/* GL_ARB_fragment_program */
		1106	{ GL_FRAGMENT_PROGRAM_ARB, CONTEXT_BOOL(FragmentProgram.Enabled),
		1107	extra_ARB_fragment_program },
		1108
		1109	/* GL_EXT_depth_bounds_test */
		1110	{ GL_DEPTH_BOUNDS_TEST_EXT, CONTEXT_BOOL(Depth.BoundsTest),
		1111	extra_EXT_depth_bounds_test },
		1112	{ GL_DEPTH_BOUNDS_EXT, CONTEXT_FLOAT2(Depth.BoundsMin),
		1113	extra_EXT_depth_bounds_test },
		1114
		1115	/* GL_ARB_depth_clamp*/
		1116	{ GL_DEPTH_CLAMP, CONTEXT_BOOL(Transform.DepthClamp),
		1117	extra_ARB_depth_clamp },
		1118
		1119	/* GL_ARB_draw_buffers */
		1120	{ GL_DRAW_BUFFER0_ARB, BUFFER_ENUM(ColorDrawBuffer[0]), NO_EXTRA },
		1121	{ GL_DRAW_BUFFER1_ARB, BUFFER_ENUM(ColorDrawBuffer[1]),
		1122	extra_valid_draw_buffer },
		1123	{ GL_DRAW_BUFFER2_ARB, BUFFER_ENUM(ColorDrawBuffer[2]),
		1124	extra_valid_draw_buffer },
		1125	{ GL_DRAW_BUFFER3_ARB, BUFFER_ENUM(ColorDrawBuffer[3]),
		1126	extra_valid_draw_buffer },
		1127	{ GL_DRAW_BUFFER4_ARB, BUFFER_ENUM(ColorDrawBuffer[4]),
		1128	extra_valid_draw_buffer },
		1129	{ GL_DRAW_BUFFER5_ARB, BUFFER_ENUM(ColorDrawBuffer[5]),
		1130	extra_valid_draw_buffer },
		1131	{ GL_DRAW_BUFFER6_ARB, BUFFER_ENUM(ColorDrawBuffer[6]),
		1132	extra_valid_draw_buffer },
		1133	{ GL_DRAW_BUFFER7_ARB, BUFFER_ENUM(ColorDrawBuffer[7]),
		1134	extra_valid_draw_buffer },
		1135
		1136	/* GL_ATI_fragment_shader */
		1137	{ GL_NUM_FRAGMENT_REGISTERS_ATI, CONST(6), extra_ATI_fragment_shader },
		1138	{ GL_NUM_FRAGMENT_CONSTANTS_ATI, CONST(8), extra_ATI_fragment_shader },
		1139	{ GL_NUM_PASSES_ATI, CONST(2), extra_ATI_fragment_shader },
		1140	{ GL_NUM_INSTRUCTIONS_PER_PASS_ATI, CONST(8), extra_ATI_fragment_shader },
		1141	{ GL_NUM_INSTRUCTIONS_TOTAL_ATI, CONST(16), extra_ATI_fragment_shader },
		1142	{ GL_COLOR_ALPHA_PAIRING_ATI, CONST(GL_TRUE), extra_ATI_fragment_shader },
		1143	{ GL_NUM_LOOPBACK_COMPONENTS_ATI, CONST(3), extra_ATI_fragment_shader },
		1144	{ GL_NUM_INPUT_INTERPOLATOR_COMPONENTS_ATI,
		1145	CONST(3), extra_ATI_fragment_shader },
		1146
		1147	/* GL_EXT_framebuffer_object */
		1148	{ GL_MAX_COLOR_ATTACHMENTS_EXT, CONTEXT_INT(Const.MaxColorAttachments),
		1149	extra_EXT_framebuffer_object },
		1150
		1151	/* GL_EXT_framebuffer_blit
		1152	* NOTE: GL_DRAW_FRAMEBUFFER_BINDING_EXT == GL_FRAMEBUFFER_BINDING_EXT */
		1153	{ GL_READ_FRAMEBUFFER_BINDING_EXT, LOC_CUSTOM, TYPE_INT, 0,
		1154	extra_EXT_framebuffer_blit },
		1155
		1156	/* GL_EXT_provoking_vertex */
		1157	{ GL_PROVOKING_VERTEX_EXT,
		1158	CONTEXT_BOOL(Light.ProvokingVertex), extra_EXT_provoking_vertex },
		1159	{ GL_QUADS_FOLLOW_PROVOKING_VERTEX_CONVENTION_EXT,
		1160	CONTEXT_BOOL(Const.QuadsFollowProvokingVertexConvention),
		1161	extra_EXT_provoking_vertex },
		1162
		1163	/* GL_ARB_framebuffer_object */
		1164	{ GL_MAX_SAMPLES, CONTEXT_INT(Const.MaxSamples),
		1165	extra_ARB_framebuffer_object_EXT_framebuffer_multisample },
		1166
		1167	/* GL_APPLE_vertex_array_object */
		1168	{ GL_VERTEX_ARRAY_BINDING_APPLE, ARRAY_INT(Name),
		1169	extra_APPLE_vertex_array_object },
		1170
		1171	/* GL_ARB_seamless_cube_map */
		1172	{ GL_TEXTURE_CUBE_MAP_SEAMLESS,
		1173	CONTEXT_BOOL(Texture.CubeMapSeamless), extra_ARB_seamless_cube_map },
		1174
		1175	/* GL_ARB_sync */
		1176	{ GL_MAX_SERVER_WAIT_TIMEOUT,
		1177	CONTEXT_INT64(Const.MaxServerWaitTimeout), extra_ARB_sync },
		1178
		1179	/* GL_EXT_texture_integer */
		1180	{ GL_RGBA_INTEGER_MODE_EXT, BUFFER_BOOL(_IntegerColor),
		1181	extra_EXT_texture_integer },
		1182
		1183	/* GL_EXT_transform_feedback */
		1184	{ GL_TRANSFORM_FEEDBACK_BUFFER_BINDING, LOC_CUSTOM, TYPE_INT, 0,
		1185	extra_EXT_transform_feedback },
		1186	{ GL_RASTERIZER_DISCARD, CONTEXT_BOOL(TransformFeedback.RasterDiscard),
		1187	extra_EXT_transform_feedback },
		1188	{ GL_MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS,
		1189	CONTEXT_INT(Const.MaxTransformFeedbackInterleavedComponents),
		1190	extra_EXT_transform_feedback },
		1191	{ GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS,
		1192	CONTEXT_INT(Const.MaxTransformFeedbackSeparateAttribs),
		1193	extra_EXT_transform_feedback },
		1194	{ GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS,
		1195	CONTEXT_INT(Const.MaxTransformFeedbackSeparateComponents),
		1196	extra_EXT_transform_feedback },
		1197
		1198	/* GL_ARB_transform_feedback2 */
		1199	{ GL_TRANSFORM_FEEDBACK_BUFFER_PAUSED, LOC_CUSTOM, TYPE_BOOLEAN, 0,
		1200	extra_ARB_transform_feedback2 },
		1201	{ GL_TRANSFORM_FEEDBACK_BUFFER_ACTIVE, LOC_CUSTOM, TYPE_BOOLEAN, 0,
		1202	extra_ARB_transform_feedback2 },
		1203	{ GL_TRANSFORM_FEEDBACK_BINDING, LOC_CUSTOM, TYPE_INT, 0,
		1204	extra_ARB_transform_feedback2 },
		1205
		1206	/* GL_ARB_geometry_shader4 */
		1207	{ GL_MAX_GEOMETRY_TEXTURE_IMAGE_UNITS_ARB,
		1208	CONTEXT_INT(Const.GeometryProgram.MaxGeometryTextureImageUnits),
		1209	extra_ARB_geometry_shader4 },
		1210	{ GL_MAX_GEOMETRY_OUTPUT_VERTICES_ARB,
		1211	CONTEXT_INT(Const.GeometryProgram.MaxGeometryOutputVertices),
		1212	extra_ARB_geometry_shader4 },
		1213	{ GL_MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS_ARB,
		1214	CONTEXT_INT(Const.GeometryProgram.MaxGeometryTotalOutputComponents),
		1215	extra_ARB_geometry_shader4 },
		1216	{ GL_MAX_GEOMETRY_UNIFORM_COMPONENTS_ARB,
		1217	CONTEXT_INT(Const.GeometryProgram.MaxGeometryUniformComponents),
		1218	extra_ARB_geometry_shader4 },
		1219	{ GL_MAX_GEOMETRY_VARYING_COMPONENTS_ARB,
		1220	CONTEXT_INT(Const.GeometryProgram.MaxGeometryVaryingComponents),
		1221	extra_ARB_geometry_shader4 },
		1222	{ GL_MAX_VERTEX_VARYING_COMPONENTS_ARB,
		1223	CONTEXT_INT(Const.GeometryProgram.MaxVertexVaryingComponents),
		1224	extra_ARB_geometry_shader4 },
		1225
		1226	/* GL_EXT_gpu_shader4 / GL 3.0 */
		1227	{ GL_MIN_PROGRAM_TEXEL_OFFSET,
		1228	CONTEXT_INT(Const.MinProgramTexelOffset),
		1229	extra_EXT_gpu_shader4 },
		1230	{ GL_MAX_PROGRAM_TEXEL_OFFSET,
		1231	CONTEXT_INT(Const.MaxProgramTexelOffset),
		1232	extra_EXT_gpu_shader4 },
		1233
		1234	/* GL 3.0 */
		1235	{ GL_NUM_EXTENSIONS, LOC_CUSTOM, TYPE_INT, 0, extra_version_30 },
		1236	{ GL_MAJOR_VERSION, CONTEXT_INT(VersionMajor), extra_version_30 },
		1237	{ GL_MINOR_VERSION, CONTEXT_INT(VersionMinor), extra_version_30 },
		1238	{ GL_CONTEXT_FLAGS, CONTEXT_INT(Const.ContextFlags), extra_version_30 },
		1239
		1240	/* GL 3.1 */
		1241	/* NOTE: different enum values for GL_PRIMITIVE_RESTART_NV
		1242	* vs. GL_PRIMITIVE_RESTART!
		1243	*/
		1244	{ GL_PRIMITIVE_RESTART, CONTEXT_BOOL(Array.PrimitiveRestart),
		1245	extra_version_31 },
		1246	{ GL_PRIMITIVE_RESTART_INDEX, CONTEXT_INT(Array.RestartIndex),
		1247	extra_version_31 },
		1248
		1249
		1250	/* GL 3.2 */
		1251	{ GL_CONTEXT_PROFILE_MASK, CONTEXT_INT(Const.ProfileMask),
		1252	extra_version_32 },
		1253	#endif /* FEATURE_GL */
		1254	};
		1255
		1256	/* All we need now is a way to look up the value struct from the enum.
		1257	* The code generated by gcc for the old generated big switch
		1258	* statement is a big, balanced, open coded if/else tree, essentially
		1259	* an unrolled binary search. It would be natural to sort the new
		1260	* enum table and use bsearch(), but we will use a read-only hash
		1261	* table instead. bsearch() has a nice guaranteed worst case
		1262	* performance, but we're also guaranteed to hit that worst case
		1263	* (log2(n) iterations) for about half the enums. Instead, using an
		1264	* open addressing hash table, we can find the enum on the first try
		1265	* for 80% of the enums, 1 collision for 10% and never more than 5
		1266	* collisions for any enum (typical numbers). And the code is very
		1267	* simple, even though it feels a little magic. */
		1268
		1269	static unsigned short table[1024];
		1270	static const int prime_factor = 89, prime_step = 281;
		1271
		1272	#ifdef GET_DEBUG
		1273	static void
		1274	print_table_stats(void)
		1275	{
		1276	int i, j, collisions[11], count, hash, mask;
		1277	const struct value_desc *d;
		1278
		1279	count = 0;
		1280	mask = Elements(table) - 1;
		1281	memset(collisions, 0, sizeof collisions);
		1282
		1283	for (i = 0; i < Elements(table); i++) {
		1284	if (!table[i])
		1285	continue;
		1286	count++;
		1287	d = &values[table[i]];
		1288	hash = (d->pname * prime_factor);
		1289	j = 0;
		1290	while (1) {
		1291	if (values[table[hash & mask]].pname == d->pname)
		1292	break;
		1293	hash += prime_step;
		1294	j++;
		1295	}
		1296
		1297	if (j < 10)
		1298	collisions[j]++;
		1299	else
		1300	collisions[10]++;
		1301	}
		1302
		1303	printf("number of enums: %d (total %d)\n", count, Elements(values));
		1304	for (i = 0; i < Elements(collisions) - 1; i++)
		1305	if (collisions[i] > 0)
		1306	printf(" %d enums with %d %scollisions\n",
		1307	collisions[i], i, i == 10 ? "or more " : "");
		1308	}
		1309	#endif
		1310
		1311	/**
		1312	* Initialize the enum hash for a given API
		1313	*
		1314	* This is called from one_time_init() to insert the enum values that
		1315	* are valid for the API in question into the enum hash table.
		1316	*
		1317	* \param the current context, for determining the API in question
		1318	*/
		1319	void _mesa_init_get_hash(struct gl_context *ctx)
		1320	{
		1321	int i, hash, index, mask;
		1322	int api_mask = 0, api_bit;
		1323
		1324	mask = Elements(table) - 1;
		1325	api_bit = 1 << ctx->API;
		1326
		1327	for (i = 0; i < Elements(values); i++) {
		1328	if (values[i].type == TYPE_API_MASK) {
		1329	api_mask = values[i].offset;
		1330	continue;
		1331	}
		1332	if (!(api_mask & api_bit))
		1333	continue;
		1334
		1335	hash = (values[i].pname * prime_factor) & mask;
		1336	while (1) {
		1337	index = hash & mask;
		1338	if (!table[index]) {
		1339	table[index] = i;
		1340	break;
		1341	}
		1342	hash += prime_step;
		1343	}
		1344	}
		1345
		1346	#ifdef GET_DEBUG
		1347	print_table_stats();
		1348	#endif
		1349	}
		1350
		1351	/**
		1352	* Handle irregular enums
		1353	*
		1354	* Some values don't conform to the "well-known type at context
		1355	* pointer + offset" pattern, so we have this function to catch all
		1356	* the corner cases. Typically, it's a computed value or a one-off
		1357	* pointer to a custom struct or something.
		1358	*
		1359	* In this case we can't return a pointer to the value, so we'll have
		1360	* to use the temporary variable 'v' declared back in the calling
		1361	* glGet*v() function to store the result.
		1362	*
		1363	* \param ctx the current context
		1364	* \param d the struct value_desc that describes the enum
		1365	* \param v pointer to the tmp declared in the calling glGet*v() function
		1366	*/
		1367	static void
		1368	find_custom_value(struct gl_context ctx, const struct value_desc d, union value *v)
		1369	{
		1370	struct gl_buffer_object *buffer_obj;
		1371	struct gl_client_array *array;
		1372	GLuint unit, *p;
		1373
		1374	switch (d->pname) {
		1375	case GL_TEXTURE_1D:
		1376	case GL_TEXTURE_2D:
		1377	case GL_TEXTURE_3D:
		1378	case GL_TEXTURE_1D_ARRAY_EXT:
		1379	case GL_TEXTURE_2D_ARRAY_EXT:
		1380	case GL_TEXTURE_CUBE_MAP_ARB:
		1381	case GL_TEXTURE_RECTANGLE_NV:
		1382	v->value_bool = _mesa_IsEnabled(d->pname);
		1383	break;
		1384
		1385	case GL_LINE_STIPPLE_PATTERN:
		1386	/* This is the only GLushort, special case it here by promoting
		1387	* to an int rather than introducing a new type. */
		1388	v->value_int = ctx->Line.StipplePattern;
		1389	break;
		1390
		1391	case GL_CURRENT_RASTER_TEXTURE_COORDS:
		1392	unit = ctx->Texture.CurrentUnit;
		1393	v->value_float_4[0] = ctx->Current.RasterTexCoords[unit][0];
		1394	v->value_float_4[1] = ctx->Current.RasterTexCoords[unit][1];
		1395	v->value_float_4[2] = ctx->Current.RasterTexCoords[unit][2];
		1396	v->value_float_4[3] = ctx->Current.RasterTexCoords[unit][3];
		1397	break;
		1398
		1399	case GL_CURRENT_TEXTURE_COORDS:
		1400	unit = ctx->Texture.CurrentUnit;
		1401	v->value_float_4[0] = ctx->Current.Attrib[VERT_ATTRIB_TEX0 + unit][0];
		1402	v->value_float_4[1] = ctx->Current.Attrib[VERT_ATTRIB_TEX0 + unit][1];
		1403	v->value_float_4[2] = ctx->Current.Attrib[VERT_ATTRIB_TEX0 + unit][2];
		1404	v->value_float_4[3] = ctx->Current.Attrib[VERT_ATTRIB_TEX0 + unit][3];
		1405	break;
		1406
		1407	case GL_COLOR_WRITEMASK:
		1408	v->value_int_4[0] = ctx->Color.ColorMask[0][RCOMP] ? 1 : 0;
		1409	v->value_int_4[1] = ctx->Color.ColorMask[0][GCOMP] ? 1 : 0;
		1410	v->value_int_4[2] = ctx->Color.ColorMask[0][BCOMP] ? 1 : 0;
		1411	v->value_int_4[3] = ctx->Color.ColorMask[0][ACOMP] ? 1 : 0;
		1412	break;
		1413
		1414	case GL_EDGE_FLAG:
		1415	v->value_bool = ctx->Current.Attrib[VERT_ATTRIB_EDGEFLAG][0] == 1.0;
		1416	break;
		1417
		1418	case GL_READ_BUFFER:
		1419	v->value_enum = ctx->ReadBuffer->ColorReadBuffer;
		1420	break;
		1421
		1422	case GL_MAP2_GRID_DOMAIN:
		1423	v->value_float_4[0] = ctx->Eval.MapGrid2u1;
		1424	v->value_float_4[1] = ctx->Eval.MapGrid2u2;
		1425	v->value_float_4[2] = ctx->Eval.MapGrid2v1;
		1426	v->value_float_4[3] = ctx->Eval.MapGrid2v2;
		1427	break;
		1428
		1429	case GL_TEXTURE_STACK_DEPTH:
		1430	unit = ctx->Texture.CurrentUnit;
		1431	v->value_int = ctx->TextureMatrixStack[unit].Depth + 1;
		1432	break;
		1433	case GL_TEXTURE_MATRIX:
		1434	unit = ctx->Texture.CurrentUnit;
		1435	v->value_matrix = ctx->TextureMatrixStack[unit].Top;
		1436	break;
		1437
		1438	case GL_TEXTURE_COORD_ARRAY:
		1439	case GL_TEXTURE_COORD_ARRAY_SIZE:
		1440	case GL_TEXTURE_COORD_ARRAY_TYPE:
		1441	case GL_TEXTURE_COORD_ARRAY_STRIDE:
		1442	array = &ctx->Array.ArrayObj->TexCoord[ctx->Array.ActiveTexture];
		1443	v->value_int = (GLuint ) ((char *) array + d->offset);
		1444	break;
		1445
		1446	case GL_ACTIVE_TEXTURE_ARB:
		1447	v->value_int = GL_TEXTURE0_ARB + ctx->Texture.CurrentUnit;
		1448	break;
		1449	case GL_CLIENT_ACTIVE_TEXTURE_ARB:
		1450	v->value_int = GL_TEXTURE0_ARB + ctx->Array.ActiveTexture;
		1451	break;
		1452
		1453	case GL_MODELVIEW_STACK_DEPTH:
		1454	case GL_PROJECTION_STACK_DEPTH:
		1455	v->value_int = (GLint ) ((char *) ctx + d->offset) + 1;
		1456	break;
		1457
		1458	case GL_MAX_TEXTURE_SIZE:
		1459	case GL_MAX_3D_TEXTURE_SIZE:
		1460	case GL_MAX_CUBE_MAP_TEXTURE_SIZE_ARB:
		1461	p = (GLuint ) ((char ) ctx + d->offset);
		1462	v->value_int = 1 << (*p - 1);
		1463	break;
		1464
		1465	case GL_SCISSOR_BOX:
		1466	v->value_int_4[0] = ctx->Scissor.X;
		1467	v->value_int_4[1] = ctx->Scissor.Y;
		1468	v->value_int_4[2] = ctx->Scissor.Width;
		1469	v->value_int_4[3] = ctx->Scissor.Height;
		1470	break;
		1471
		1472	case GL_LIST_INDEX:
		1473	v->value_int =
		1474	ctx->ListState.CurrentList ? ctx->ListState.CurrentList->Name : 0;
		1475	break;
		1476	case GL_LIST_MODE:
		1477	if (!ctx->CompileFlag)
		1478	v->value_enum = 0;
		1479	else if (ctx->ExecuteFlag)
		1480	v->value_enum = GL_COMPILE_AND_EXECUTE;
		1481	else
		1482	v->value_enum = GL_COMPILE;
		1483	break;
		1484
		1485	case GL_VIEWPORT:
		1486	v->value_int_4[0] = ctx->Viewport.X;
		1487	v->value_int_4[1] = ctx->Viewport.Y;
		1488	v->value_int_4[2] = ctx->Viewport.Width;
		1489	v->value_int_4[3] = ctx->Viewport.Height;
		1490	break;
		1491
		1492	case GL_ACTIVE_STENCIL_FACE_EXT:
		1493	v->value_enum = ctx->Stencil.ActiveFace ? GL_BACK : GL_FRONT;
		1494	break;
		1495
		1496	case GL_STENCIL_FAIL:
		1497	v->value_enum = ctx->Stencil.FailFunc[ctx->Stencil.ActiveFace];
		1498	break;
		1499	case GL_STENCIL_FUNC:
		1500	v->value_enum = ctx->Stencil.Function[ctx->Stencil.ActiveFace];
		1501	break;
		1502	case GL_STENCIL_PASS_DEPTH_FAIL:
		1503	v->value_enum = ctx->Stencil.ZFailFunc[ctx->Stencil.ActiveFace];
		1504	break;
		1505	case GL_STENCIL_PASS_DEPTH_PASS:
		1506	v->value_enum = ctx->Stencil.ZPassFunc[ctx->Stencil.ActiveFace];
		1507	break;
		1508	case GL_STENCIL_REF:
		1509	v->value_int = ctx->Stencil.Ref[ctx->Stencil.ActiveFace];
		1510	break;
		1511	case GL_STENCIL_VALUE_MASK:
		1512	v->value_int = ctx->Stencil.ValueMask[ctx->Stencil.ActiveFace];
		1513	break;
		1514	case GL_STENCIL_WRITEMASK:
		1515	v->value_int = ctx->Stencil.WriteMask[ctx->Stencil.ActiveFace];
		1516	break;
		1517
		1518	case GL_NUM_EXTENSIONS:
		1519	v->value_int = _mesa_get_extension_count(ctx);
		1520	break;
		1521
		1522	case GL_IMPLEMENTATION_COLOR_READ_TYPE_OES:
		1523	v->value_int = _mesa_get_color_read_type(ctx);
		1524	break;
		1525	case GL_IMPLEMENTATION_COLOR_READ_FORMAT_OES:
		1526	v->value_int = _mesa_get_color_read_format(ctx);
		1527	break;
		1528
		1529	case GL_CURRENT_MATRIX_STACK_DEPTH_ARB:
		1530	v->value_int = ctx->CurrentStack->Depth + 1;
		1531	break;
		1532	case GL_CURRENT_MATRIX_ARB:
		1533	case GL_TRANSPOSE_CURRENT_MATRIX_ARB:
		1534	v->value_matrix = ctx->CurrentStack->Top;
		1535	break;
		1536
		1537	case GL_NUM_COMPRESSED_TEXTURE_FORMATS_ARB:
		1538	v->value_int = _mesa_get_compressed_formats(ctx, NULL, GL_FALSE);
		1539	break;
		1540	case GL_COMPRESSED_TEXTURE_FORMATS_ARB:
		1541	v->value_int_n.n =
		1542	_mesa_get_compressed_formats(ctx, v->value_int_n.ints, GL_FALSE);
		1543	ASSERT(v->value_int_n.n <= 100);
		1544	break;
		1545
		1546	case GL_MAX_VARYING_FLOATS_ARB:
		1547	v->value_int = ctx->Const.MaxVarying * 4;
		1548	break;
		1549
		1550	/* Various object names */
		1551
		1552	case GL_TEXTURE_BINDING_1D:
		1553	case GL_TEXTURE_BINDING_2D:
		1554	case GL_TEXTURE_BINDING_3D:
		1555	case GL_TEXTURE_BINDING_1D_ARRAY_EXT:
		1556	case GL_TEXTURE_BINDING_2D_ARRAY_EXT:
		1557	case GL_TEXTURE_BINDING_CUBE_MAP_ARB:
		1558	case GL_TEXTURE_BINDING_RECTANGLE_NV:
		1559	unit = ctx->Texture.CurrentUnit;
		1560	v->value_int =
		1561	ctx->Texture.Unit[unit].CurrentTex[d->offset]->Name;
		1562	break;
		1563
		1564	/* GL_ARB_vertex_buffer_object */
		1565	case GL_VERTEX_ARRAY_BUFFER_BINDING_ARB:
		1566	case GL_NORMAL_ARRAY_BUFFER_BINDING_ARB:
		1567	case GL_COLOR_ARRAY_BUFFER_BINDING_ARB:
		1568	case GL_INDEX_ARRAY_BUFFER_BINDING_ARB:
		1569	case GL_EDGE_FLAG_ARRAY_BUFFER_BINDING_ARB:
		1570	case GL_SECONDARY_COLOR_ARRAY_BUFFER_BINDING_ARB:
		1571	case GL_FOG_COORDINATE_ARRAY_BUFFER_BINDING_ARB:
		1572	buffer_obj = (struct gl_buffer_object *)
		1573	((char *) ctx->Array.ArrayObj + d->offset);
		1574	v->value_int = buffer_obj->Name;
		1575	break;
		1576	case GL_ARRAY_BUFFER_BINDING_ARB:
		1577	v->value_int = ctx->Array.ArrayBufferObj->Name;
		1578	break;
		1579	case GL_TEXTURE_COORD_ARRAY_BUFFER_BINDING_ARB:
		1580	v->value_int =
		1581	ctx->Array.ArrayObj->TexCoord[ctx->Array.ActiveTexture].BufferObj->Name;
		1582	break;
		1583	case GL_ELEMENT_ARRAY_BUFFER_BINDING_ARB:
		1584	v->value_int = ctx->Array.ElementArrayBufferObj->Name;
		1585	break;
		1586
		1587	/* ARB_copy_buffer */
		1588	case GL_COPY_READ_BUFFER:
		1589	v->value_int = ctx->CopyReadBuffer->Name;
		1590	break;
		1591	case GL_COPY_WRITE_BUFFER:
		1592	v->value_int = ctx->CopyWriteBuffer->Name;
		1593	break;
		1594
		1595	case GL_FRAGMENT_PROGRAM_BINDING_NV:
		1596	v->value_int =
		1597	ctx->FragmentProgram.Current ? ctx->FragmentProgram.Current->Base.Id : 0;
		1598	break;
		1599	case GL_VERTEX_PROGRAM_BINDING_NV:
		1600	v->value_int =
		1601	ctx->VertexProgram.Current ? ctx->VertexProgram.Current->Base.Id : 0;
		1602	break;
		1603	case GL_PIXEL_PACK_BUFFER_BINDING_EXT:
		1604	v->value_int = ctx->Pack.BufferObj->Name;
		1605	break;
		1606	case GL_PIXEL_UNPACK_BUFFER_BINDING_EXT:
		1607	v->value_int = ctx->Unpack.BufferObj->Name;
		1608	break;
		1609	case GL_TRANSFORM_FEEDBACK_BUFFER_BINDING:
		1610	v->value_int = ctx->TransformFeedback.CurrentBuffer->Name;
		1611	break;
		1612	case GL_TRANSFORM_FEEDBACK_BUFFER_PAUSED:
		1613	v->value_int = ctx->TransformFeedback.CurrentObject->Paused;
		1614	break;
		1615	case GL_TRANSFORM_FEEDBACK_BUFFER_ACTIVE:
		1616	v->value_int = ctx->TransformFeedback.CurrentObject->Active;
		1617	break;
		1618	case GL_TRANSFORM_FEEDBACK_BINDING:
		1619	v->value_int = ctx->TransformFeedback.CurrentObject->Name;
		1620	break;
		1621	case GL_CURRENT_PROGRAM:
		1622	v->value_int =
		1623	ctx->Shader.ActiveProgram ? ctx->Shader.ActiveProgram->Name : 0;
		1624	break;
		1625	case GL_READ_FRAMEBUFFER_BINDING_EXT:
		1626	v->value_int = ctx->ReadBuffer->Name;
		1627	break;
		1628	case GL_RENDERBUFFER_BINDING_EXT:
		1629	v->value_int =
		1630	ctx->CurrentRenderbuffer ? ctx->CurrentRenderbuffer->Name : 0;
		1631	break;
		1632	case GL_POINT_SIZE_ARRAY_BUFFER_BINDING_OES:
		1633	v->value_int = ctx->Array.ArrayObj->PointSize.BufferObj->Name;
		1634	break;
		1635
		1636	case GL_MAX_VERTEX_UNIFORM_VECTORS:
		1637	v->value_int = ctx->Const.VertexProgram.MaxUniformComponents / 4;
		1638	break;
		1639
		1640	case GL_MAX_FRAGMENT_UNIFORM_VECTORS:
		1641	v->value_int = ctx->Const.FragmentProgram.MaxUniformComponents / 4;
		1642	break;
		1643	}
		1644	}
		1645
		1646	/**
		1647	* Check extra constraints on a struct value_desc descriptor
		1648	*
		1649	* If a struct value_desc has a non-NULL extra pointer, it means that
		1650	* there are a number of extra constraints to check or actions to
		1651	* perform. The extras is just an integer array where each integer
		1652	* encode different constraints or actions.
		1653	*
		1654	* \param ctx current context
		1655	* \param func name of calling glGet*v() function for error reporting
		1656	* \param d the struct value_desc that has the extra constraints
		1657	*
		1658	* \return GL_FALSE if one of the constraints was not satisfied,
		1659	* otherwise GL_TRUE.
		1660	*/
		1661	static GLboolean
		1662	check_extra(struct gl_context ctx, const char func, const struct value_desc *d)
		1663	{
		1664	const GLuint version = ctx->VersionMajor * 10 + ctx->VersionMinor;
		1665	int total, enabled;
		1666	const int *e;
		1667
		1668	total = 0;
		1669	enabled = 0;
		1670	for (e = d->extra; *e != EXTRA_END; e++)
		1671	switch (*e) {
		1672	case EXTRA_VERSION_30:
		1673	if (version >= 30) {
		1674	total++;
		1675	enabled++;
		1676	}
		1677	break;
		1678	case EXTRA_VERSION_31:
		1679	if (version >= 31) {
		1680	total++;
		1681	enabled++;
		1682	}
		1683	break;
		1684	case EXTRA_VERSION_32:
		1685	if (version >= 32) {
		1686	total++;
		1687	enabled++;
		1688	}
		1689	break;
		1690	case EXTRA_VERSION_ES2:
		1691	if (ctx->API == API_OPENGLES2) {
		1692	total++;
		1693	enabled++;
		1694	}
		1695	break;
		1696	case EXTRA_NEW_BUFFERS:
		1697	if (ctx->NewState & _NEW_BUFFERS)
		1698	_mesa_update_state(ctx);
		1699	break;
		1700	case EXTRA_FLUSH_CURRENT:
		1701	FLUSH_CURRENT(ctx, 0);
		1702	break;
		1703	case EXTRA_VALID_DRAW_BUFFER:
		1704	if (d->pname - GL_DRAW_BUFFER0_ARB >= ctx->Const.MaxDrawBuffers) {
		1705	_mesa_error(ctx, GL_INVALID_OPERATION, "%s(draw buffer %u)",
		1706	func, d->pname - GL_DRAW_BUFFER0_ARB);
		1707	return GL_FALSE;
		1708	}
		1709	break;
		1710	case EXTRA_VALID_TEXTURE_UNIT:
		1711	if (ctx->Texture.CurrentUnit >= ctx->Const.MaxTextureCoordUnits) {
		1712	_mesa_error(ctx, GL_INVALID_OPERATION, "%s(texture %u)",
		1713	func, ctx->Texture.CurrentUnit);
		1714	return GL_FALSE;
		1715	}
		1716	break;
		1717	case EXTRA_END:
		1718	break;
		1719	default: /* e is a offset into the extension struct /
		1720	total++;
		1721	if ((GLboolean ) ((char ) &ctx->Extensions + e))
		1722	enabled++;
		1723	break;
		1724	}
		1725
		1726	if (total > 0 && enabled == 0) {
		1727	_mesa_error(ctx, GL_INVALID_ENUM, "%s(pname=%s)", func,
		1728	_mesa_lookup_enum_by_nr(d->pname));
		1729	return GL_FALSE;
		1730	}
		1731
		1732	return GL_TRUE;
		1733	}
		1734
		1735	static const struct value_desc error_value =
		1736	{ 0, 0, TYPE_INVALID, NO_OFFSET, NO_EXTRA };
		1737
		1738	/**
		1739	* Find the struct value_desc corresponding to the enum 'pname'.
		1740	*
		1741	* We hash the enum value to get an index into the 'table' array,
		1742	* which holds the index in the 'values' array of struct value_desc.
		1743	* Once we've found the entry, we do the extra checks, if any, then
		1744	* look up the value and return a pointer to it.
		1745	*
		1746	* If the value has to be computed (for example, it's the result of a
		1747	* function call or we need to add 1 to it), we use the tmp 'v' to
		1748	* store the result.
		1749	*
		1750	* \param func name of glGet*v() func for error reporting
		1751	* \param pname the enum value we're looking up
		1752	* \param p is were we return the pointer to the value
		1753	* \param v a tmp union value variable in the calling glGet*v() function
		1754	*
		1755	* \return the struct value_desc corresponding to the enum or a struct
		1756	* value_desc of TYPE_INVALID if not found. This lets the calling
		1757	* glGet*v() function jump right into a switch statement and
		1758	* handle errors there instead of having to check for NULL.
		1759	*/
		1760	static const struct value_desc *
		1761	find_value(const char func, GLenum pname, void p, union value v)
		1762	{
		1763	GET_CURRENT_CONTEXT(ctx);
		1764	struct gl_texture_unit *unit;
		1765	int mask, hash;
		1766	const struct value_desc *d;
		1767
		1768	mask = Elements(table) - 1;
		1769	hash = (pname * prime_factor);
		1770	while (1) {
		1771	d = &values[table[hash & mask]];
		1772
		1773	/* If the enum isn't valid, the hash walk ends with index 0,
		1774	* which is the API mask entry at the beginning of values[]. */
		1775	if (unlikely(d->type == TYPE_API_MASK)) {
		1776	_mesa_error(ctx, GL_INVALID_ENUM, "%s(pname=%s)", func,
		1777	_mesa_lookup_enum_by_nr(pname));
		1778	return &error_value;
		1779	}
		1780
		1781	if (likely(d->pname == pname))
		1782	break;
		1783
		1784	hash += prime_step;
		1785	}
		1786
		1787	if (unlikely(d->extra && !check_extra(ctx, func, d)))
		1788	return &error_value;
		1789
		1790	switch (d->location) {
		1791	case LOC_BUFFER:
		1792	p = ((char ) ctx->DrawBuffer + d->offset);
		1793	return d;
		1794	case LOC_CONTEXT:
		1795	p = ((char ) ctx + d->offset);
		1796	return d;
		1797	case LOC_ARRAY:
		1798	p = ((char ) ctx->Array.ArrayObj + d->offset);
		1799	return d;
		1800	case LOC_TEXUNIT:
		1801	unit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
		1802	p = ((char ) unit + d->offset);
		1803	return d;
		1804	case LOC_CUSTOM:
		1805	find_custom_value(ctx, d, v);
		1806	*p = v;
		1807	return d;
		1808	default:
		1809	assert(0);
		1810	break;
		1811	}
		1812
		1813	/* silence warning */
		1814	return &error_value;
		1815	}
		1816
		1817	static const int transpose[] = {
		1818	0, 4, 8, 12,
		1819	1, 5, 9, 13,
		1820	2, 6, 10, 14,
		1821	3, 7, 11, 15
		1822	};
		1823
		1824	void GLAPIENTRY
		1825	_mesa_GetBooleanv(GLenum pname, GLboolean *params)
		1826	{
		1827	const struct value_desc *d;
		1828	union value v;
		1829	GLmatrix *m;
		1830	int shift, i;
		1831	void *p;
		1832
		1833	d = find_value("glGetBooleanv", pname, &p, &v);
		1834	switch (d->type) {
		1835	case TYPE_INVALID:
		1836	break;
		1837	case TYPE_CONST:
		1838	params[0] = INT_TO_BOOLEAN(d->offset);
		1839	break;
		1840
		1841	case TYPE_FLOAT_4:
		1842	case TYPE_FLOATN_4:
		1843	params[3] = FLOAT_TO_BOOLEAN(((GLfloat *) p)[3]);
		1844	case TYPE_FLOAT_3:
		1845	case TYPE_FLOATN_3:
		1846	params[2] = FLOAT_TO_BOOLEAN(((GLfloat *) p)[2]);
		1847	case TYPE_FLOAT_2:
		1848	case TYPE_FLOATN_2:
		1849	params[1] = FLOAT_TO_BOOLEAN(((GLfloat *) p)[1]);
		1850	case TYPE_FLOAT:
		1851	case TYPE_FLOATN:
		1852	params[0] = FLOAT_TO_BOOLEAN(((GLfloat *) p)[0]);
		1853	break;
		1854
		1855	case TYPE_DOUBLEN:
		1856	params[0] = FLOAT_TO_BOOLEAN(((GLdouble *) p)[0]);
		1857	break;
		1858
		1859	case TYPE_INT_4:
		1860	params[3] = INT_TO_BOOLEAN(((GLint *) p)[3]);
		1861	case TYPE_INT_3:
		1862	params[2] = INT_TO_BOOLEAN(((GLint *) p)[2]);
		1863	case TYPE_INT_2:
		1864	case TYPE_ENUM_2:
		1865	params[1] = INT_TO_BOOLEAN(((GLint *) p)[1]);
		1866	case TYPE_INT:
		1867	case TYPE_ENUM:
		1868	params[0] = INT_TO_BOOLEAN(((GLint *) p)[0]);
		1869	break;
		1870
		1871	case TYPE_INT_N:
		1872	for (i = 0; i < v.value_int_n.n; i++)
		1873	params[i] = INT_TO_BOOLEAN(v.value_int_n.ints[i]);
		1874	break;
		1875
		1876	case TYPE_INT64:
		1877	params[0] = INT64_TO_BOOLEAN(((GLint64 *) p)[0]);
		1878	break;
		1879
		1880	case TYPE_BOOLEAN:
		1881	params[0] = ((GLboolean*) p)[0];
		1882	break;
		1883
		1884	case TYPE_MATRIX:
		1885	m = (GLmatrix *) p;
		1886	for (i = 0; i < 16; i++)
		1887	params[i] = FLOAT_TO_BOOLEAN(m->m[i]);
		1888	break;
		1889
		1890	case TYPE_MATRIX_T:
		1891	m = (GLmatrix *) p;
		1892	for (i = 0; i < 16; i++)
		1893	params[i] = FLOAT_TO_BOOLEAN(m->m[transpose[i]]);
		1894	break;
		1895
		1896	case TYPE_BIT_0:
		1897	case TYPE_BIT_1:
		1898	case TYPE_BIT_2:
		1899	case TYPE_BIT_3:
		1900	case TYPE_BIT_4:
		1901	case TYPE_BIT_5:
		1902	shift = d->type - TYPE_BIT_0;
		1903	params[0] = ((GLbitfield ) p >> shift) & 1;
		1904	break;
		1905	}
		1906	}
		1907
		1908	void GLAPIENTRY
		1909	_mesa_GetFloatv(GLenum pname, GLfloat *params)
		1910	{
		1911	const struct value_desc *d;
		1912	union value v;
		1913	GLmatrix *m;
		1914	int shift, i;
		1915	void *p;
		1916
		1917	d = find_value("glGetFloatv", pname, &p, &v);
		1918	switch (d->type) {
		1919	case TYPE_INVALID:
		1920	break;
		1921	case TYPE_CONST:
		1922	params[0] = (GLfloat) d->offset;
		1923	break;
		1924
		1925	case TYPE_FLOAT_4:
		1926	case TYPE_FLOATN_4:
		1927	params[3] = ((GLfloat *) p)[3];
		1928	case TYPE_FLOAT_3:
		1929	case TYPE_FLOATN_3:
		1930	params[2] = ((GLfloat *) p)[2];
		1931	case TYPE_FLOAT_2:
		1932	case TYPE_FLOATN_2:
		1933	params[1] = ((GLfloat *) p)[1];
		1934	case TYPE_FLOAT:
		1935	case TYPE_FLOATN:
		1936	params[0] = ((GLfloat *) p)[0];
		1937	break;
		1938
		1939	case TYPE_DOUBLEN:
		1940	params[0] = ((GLdouble *) p)[0];
		1941	break;
		1942
		1943	case TYPE_INT_4:
		1944	params[3] = (GLfloat) (((GLint *) p)[3]);
		1945	case TYPE_INT_3:
		1946	params[2] = (GLfloat) (((GLint *) p)[2]);
		1947	case TYPE_INT_2:
		1948	case TYPE_ENUM_2:
		1949	params[1] = (GLfloat) (((GLint *) p)[1]);
		1950	case TYPE_INT:
		1951	case TYPE_ENUM:
		1952	params[0] = (GLfloat) (((GLint *) p)[0]);
		1953	break;
		1954
		1955	case TYPE_INT_N:
		1956	for (i = 0; i < v.value_int_n.n; i++)
		1957	params[i] = INT_TO_FLOAT(v.value_int_n.ints[i]);
		1958	break;
		1959
		1960	case TYPE_INT64:
		1961	params[0] = ((GLint64 *) p)[0];
		1962	break;
		1963
		1964	case TYPE_BOOLEAN:
		1965	params[0] = BOOLEAN_TO_FLOAT((GLboolean) p);
		1966	break;
		1967
		1968	case TYPE_MATRIX:
		1969	m = (GLmatrix *) p;
		1970	for (i = 0; i < 16; i++)
		1971	params[i] = m->m[i];
		1972	break;
		1973
		1974	case TYPE_MATRIX_T:
		1975	m = (GLmatrix *) p;
		1976	for (i = 0; i < 16; i++)
		1977	params[i] = m->m[transpose[i]];
		1978	break;
		1979
		1980	case TYPE_BIT_0:
		1981	case TYPE_BIT_1:
		1982	case TYPE_BIT_2:
		1983	case TYPE_BIT_3:
		1984	case TYPE_BIT_4:
		1985	case TYPE_BIT_5:
		1986	shift = d->type - TYPE_BIT_0;
		1987	params[0] = BOOLEAN_TO_FLOAT(((GLbitfield ) p >> shift) & 1);
		1988	break;
		1989	}
		1990	}
		1991
		1992	void GLAPIENTRY
		1993	_mesa_GetIntegerv(GLenum pname, GLint *params)
		1994	{
		1995	const struct value_desc *d;
		1996	union value v;
		1997	GLmatrix *m;
		1998	int shift, i;
		1999	void *p;
		2000
		2001	d = find_value("glGetIntegerv", pname, &p, &v);
		2002	switch (d->type) {
		2003	case TYPE_INVALID:
		2004	break;
		2005	case TYPE_CONST:
		2006	params[0] = d->offset;
		2007	break;
		2008
		2009	case TYPE_FLOAT_4:
		2010	params[3] = IROUND(((GLfloat *) p)[3]);
		2011	case TYPE_FLOAT_3:
		2012	params[2] = IROUND(((GLfloat *) p)[2]);
		2013	case TYPE_FLOAT_2:
		2014	params[1] = IROUND(((GLfloat *) p)[1]);
		2015	case TYPE_FLOAT:
		2016	params[0] = IROUND(((GLfloat *) p)[0]);
		2017	break;
		2018
		2019	case TYPE_FLOATN_4:
		2020	params[3] = FLOAT_TO_INT(((GLfloat *) p)[3]);
		2021	case TYPE_FLOATN_3:
		2022	params[2] = FLOAT_TO_INT(((GLfloat *) p)[2]);
		2023	case TYPE_FLOATN_2:
		2024	params[1] = FLOAT_TO_INT(((GLfloat *) p)[1]);
		2025	case TYPE_FLOATN:
		2026	params[0] = FLOAT_TO_INT(((GLfloat *) p)[0]);
		2027	break;
		2028
		2029	case TYPE_DOUBLEN:
		2030	params[0] = FLOAT_TO_INT(((GLdouble *) p)[0]);
		2031	break;
		2032
		2033	case TYPE_INT_4:
		2034	params[3] = ((GLint *) p)[3];
		2035	case TYPE_INT_3:
		2036	params[2] = ((GLint *) p)[2];
		2037	case TYPE_INT_2:
		2038	case TYPE_ENUM_2:
		2039	params[1] = ((GLint *) p)[1];
		2040	case TYPE_INT:
		2041	case TYPE_ENUM:
		2042	params[0] = ((GLint *) p)[0];
		2043	break;
		2044
		2045	case TYPE_INT_N:
		2046	for (i = 0; i < v.value_int_n.n; i++)
		2047	params[i] = v.value_int_n.ints[i];
		2048	break;
		2049
		2050	case TYPE_INT64:
		2051	params[0] = INT64_TO_INT(((GLint64 *) p)[0]);
		2052	break;
		2053
		2054	case TYPE_BOOLEAN:
		2055	params[0] = BOOLEAN_TO_INT((GLboolean) p);
		2056	break;
		2057
		2058	case TYPE_MATRIX:
		2059	m = (GLmatrix *) p;
		2060	for (i = 0; i < 16; i++)
		2061	params[i] = FLOAT_TO_INT(m->m[i]);
		2062	break;
		2063
		2064	case TYPE_MATRIX_T:
		2065	m = (GLmatrix *) p;
		2066	for (i = 0; i < 16; i++)
		2067	params[i] = FLOAT_TO_INT(m->m[transpose[i]]);
		2068	break;
		2069
		2070	case TYPE_BIT_0:
		2071	case TYPE_BIT_1:
		2072	case TYPE_BIT_2:
		2073	case TYPE_BIT_3:
		2074	case TYPE_BIT_4:
		2075	case TYPE_BIT_5:
		2076	shift = d->type - TYPE_BIT_0;
		2077	params[0] = ((GLbitfield ) p >> shift) & 1;
		2078	break;
		2079	}
		2080	}
		2081
		2082	#if FEATURE_ARB_sync
		2083	void GLAPIENTRY
		2084	_mesa_GetInteger64v(GLenum pname, GLint64 *params)
		2085	{
		2086	const struct value_desc *d;
		2087	union value v;
		2088	GLmatrix *m;
		2089	int shift, i;
		2090	void *p;
		2091
		2092	d = find_value("glGetInteger64v", pname, &p, &v);
		2093	switch (d->type) {
		2094	case TYPE_INVALID:
		2095	break;
		2096	case TYPE_CONST:
		2097	params[0] = d->offset;
		2098	break;
		2099
		2100	case TYPE_FLOAT_4:
		2101	params[3] = IROUND64(((GLfloat *) p)[3]);
		2102	case TYPE_FLOAT_3:
		2103	params[2] = IROUND64(((GLfloat *) p)[2]);
		2104	case TYPE_FLOAT_2:
		2105	params[1] = IROUND64(((GLfloat *) p)[1]);
		2106	case TYPE_FLOAT:
		2107	params[0] = IROUND64(((GLfloat *) p)[0]);
		2108	break;
		2109
		2110	case TYPE_FLOATN_4:
		2111	params[3] = FLOAT_TO_INT64(((GLfloat *) p)[3]);
		2112	case TYPE_FLOATN_3:
		2113	params[2] = FLOAT_TO_INT64(((GLfloat *) p)[2]);
		2114	case TYPE_FLOATN_2:
		2115	params[1] = FLOAT_TO_INT64(((GLfloat *) p)[1]);
		2116	case TYPE_FLOATN:
		2117	params[0] = FLOAT_TO_INT64(((GLfloat *) p)[0]);
		2118	break;
		2119
		2120	case TYPE_DOUBLEN:
		2121	params[0] = FLOAT_TO_INT64(((GLdouble *) p)[0]);
		2122	break;
		2123
		2124	case TYPE_INT_4:
		2125	params[3] = ((GLint *) p)[3];
		2126	case TYPE_INT_3:
		2127	params[2] = ((GLint *) p)[2];
		2128	case TYPE_INT_2:
		2129	case TYPE_ENUM_2:
		2130	params[1] = ((GLint *) p)[1];
		2131	case TYPE_INT:
		2132	case TYPE_ENUM:
		2133	params[0] = ((GLint *) p)[0];
		2134	break;
		2135
		2136	case TYPE_INT_N:
		2137	for (i = 0; i < v.value_int_n.n; i++)
		2138	params[i] = INT_TO_BOOLEAN(v.value_int_n.ints[i]);
		2139	break;
		2140
		2141	case TYPE_INT64:
		2142	params[0] = ((GLint64 *) p)[0];
		2143	break;
		2144
		2145	case TYPE_BOOLEAN:
		2146	params[0] = ((GLboolean*) p)[0];
		2147	break;
		2148
		2149	case TYPE_MATRIX:
		2150	m = (GLmatrix *) p;
		2151	for (i = 0; i < 16; i++)
		2152	params[i] = FLOAT_TO_INT64(m->m[i]);
		2153	break;
		2154
		2155	case TYPE_MATRIX_T:
		2156	m = (GLmatrix *) p;
		2157	for (i = 0; i < 16; i++)
		2158	params[i] = FLOAT_TO_INT64(m->m[transpose[i]]);
		2159	break;
		2160
		2161	case TYPE_BIT_0:
		2162	case TYPE_BIT_1:
		2163	case TYPE_BIT_2:
		2164	case TYPE_BIT_3:
		2165	case TYPE_BIT_4:
		2166	case TYPE_BIT_5:
		2167	shift = d->type - TYPE_BIT_0;
		2168	params[0] = ((GLbitfield ) p >> shift) & 1;
		2169	break;
		2170	}
		2171	}
		2172	#endif /* FEATURE_ARB_sync */
		2173
		2174	void GLAPIENTRY
		2175	_mesa_GetDoublev(GLenum pname, GLdouble *params)
		2176	{
		2177	const struct value_desc *d;
		2178	union value v;
		2179	GLmatrix *m;
		2180	int shift, i;
		2181	void *p;
		2182
		2183	d = find_value("glGetDoublev", pname, &p, &v);
		2184	switch (d->type) {
		2185	case TYPE_INVALID:
		2186	break;
		2187	case TYPE_CONST:
		2188	params[0] = d->offset;
		2189	break;
		2190
		2191	case TYPE_FLOAT_4:
		2192	case TYPE_FLOATN_4:
		2193	params[3] = ((GLfloat *) p)[3];
		2194	case TYPE_FLOAT_3:
		2195	case TYPE_FLOATN_3:
		2196	params[2] = ((GLfloat *) p)[2];
		2197	case TYPE_FLOAT_2:
		2198	case TYPE_FLOATN_2:
		2199	params[1] = ((GLfloat *) p)[1];
		2200	case TYPE_FLOAT:
		2201	case TYPE_FLOATN:
		2202	params[0] = ((GLfloat *) p)[0];
		2203	break;
		2204
		2205	case TYPE_DOUBLEN:
		2206	params[0] = ((GLdouble *) p)[0];
		2207	break;
		2208
		2209	case TYPE_INT_4:
		2210	params[3] = ((GLint *) p)[3];
		2211	case TYPE_INT_3:
		2212	params[2] = ((GLint *) p)[2];
		2213	case TYPE_INT_2:
		2214	case TYPE_ENUM_2:
		2215	params[1] = ((GLint *) p)[1];
		2216	case TYPE_INT:
		2217	case TYPE_ENUM:
		2218	params[0] = ((GLint *) p)[0];
		2219	break;
		2220
		2221	case TYPE_INT_N:
		2222	for (i = 0; i < v.value_int_n.n; i++)
		2223	params[i] = v.value_int_n.ints[i];
		2224	break;
		2225
		2226	case TYPE_INT64:
		2227	params[0] = ((GLint64 *) p)[0];
		2228	break;
		2229
		2230	case TYPE_BOOLEAN:
		2231	params[0] = (GLboolean) p;
		2232	break;
		2233
		2234	case TYPE_MATRIX:
		2235	m = (GLmatrix *) p;
		2236	for (i = 0; i < 16; i++)
		2237	params[i] = m->m[i];
		2238	break;
		2239
		2240	case TYPE_MATRIX_T:
		2241	m = (GLmatrix *) p;
		2242	for (i = 0; i < 16; i++)
		2243	params[i] = m->m[transpose[i]];
		2244	break;
		2245
		2246	case TYPE_BIT_0:
		2247	case TYPE_BIT_1:
		2248	case TYPE_BIT_2:
		2249	case TYPE_BIT_3:
		2250	case TYPE_BIT_4:
		2251	case TYPE_BIT_5:
		2252	shift = d->type - TYPE_BIT_0;
		2253	params[0] = ((GLbitfield ) p >> shift) & 1;
		2254	break;
		2255	}
		2256	}
		2257
		2258	static enum value_type
		2259	find_value_indexed(const char func, GLenum pname, int index, union value v)
		2260	{
		2261	GET_CURRENT_CONTEXT(ctx);
		2262
		2263	switch (pname) {
		2264
		2265	case GL_BLEND:
		2266	if (index >= ctx->Const.MaxDrawBuffers)
		2267	goto invalid_value;
		2268	if (!ctx->Extensions.EXT_draw_buffers2)
		2269	goto invalid_enum;
		2270	v->value_int = (ctx->Color.BlendEnabled >> index) & 1;
		2271	return TYPE_INT;
		2272
		2273	case GL_COLOR_WRITEMASK:
		2274	if (index >= ctx->Const.MaxDrawBuffers)
		2275	goto invalid_value;
		2276	if (!ctx->Extensions.EXT_draw_buffers2)
		2277	goto invalid_enum;
		2278	v->value_int_4[0] = ctx->Color.ColorMask[index][RCOMP] ? 1 : 0;
		2279	v->value_int_4[1] = ctx->Color.ColorMask[index][GCOMP] ? 1 : 0;
		2280	v->value_int_4[2] = ctx->Color.ColorMask[index][BCOMP] ? 1 : 0;
		2281	v->value_int_4[3] = ctx->Color.ColorMask[index][ACOMP] ? 1 : 0;
		2282	return TYPE_INT_4;
		2283
		2284	case GL_TRANSFORM_FEEDBACK_BUFFER_START:
		2285	if (index >= ctx->Const.MaxTransformFeedbackSeparateAttribs)
		2286	goto invalid_value;
		2287	if (!ctx->Extensions.EXT_transform_feedback)
		2288	goto invalid_enum;
		2289	v->value_int64 = ctx->TransformFeedback.CurrentObject->Offset[index];
		2290	return TYPE_INT64;
		2291
		2292	case GL_TRANSFORM_FEEDBACK_BUFFER_SIZE:
		2293	if (index >= ctx->Const.MaxTransformFeedbackSeparateAttribs)
		2294	goto invalid_value;
		2295	if (!ctx->Extensions.EXT_transform_feedback)
		2296	goto invalid_enum;
		2297	v->value_int64 = ctx->TransformFeedback.CurrentObject->Size[index];
		2298	return TYPE_INT64;
		2299
		2300	case GL_TRANSFORM_FEEDBACK_BUFFER_BINDING:
		2301	if (index >= ctx->Const.MaxTransformFeedbackSeparateAttribs)
		2302	goto invalid_value;
		2303	if (!ctx->Extensions.EXT_transform_feedback)
		2304	goto invalid_enum;
		2305	v->value_int = ctx->TransformFeedback.CurrentObject->Buffers[index]->Name;
		2306	return TYPE_INT;
		2307	}
		2308
		2309	invalid_enum:
		2310	_mesa_error(ctx, GL_INVALID_ENUM, "%s(pname=%s)", func,
		2311	_mesa_lookup_enum_by_nr(pname));
		2312	return TYPE_INVALID;
		2313	invalid_value:
		2314	_mesa_error(ctx, GL_INVALID_VALUE, "%s(pname=%s)", func,
		2315	_mesa_lookup_enum_by_nr(pname));
		2316	return TYPE_INVALID;
		2317	}
		2318
		2319	void GLAPIENTRY
		2320	_mesa_GetBooleanIndexedv( GLenum pname, GLuint index, GLboolean *params )
		2321	{
		2322	union value v;
		2323	enum value_type type =
		2324	find_value_indexed("glGetBooleanIndexedv", pname, index, &v);
		2325
		2326	switch (type) {
		2327	case TYPE_INT:
		2328	params[0] = INT_TO_BOOLEAN(v.value_int);
		2329	break;
		2330	case TYPE_INT_4:
		2331	params[0] = INT_TO_BOOLEAN(v.value_int_4[0]);
		2332	params[1] = INT_TO_BOOLEAN(v.value_int_4[1]);
		2333	params[2] = INT_TO_BOOLEAN(v.value_int_4[2]);
		2334	params[3] = INT_TO_BOOLEAN(v.value_int_4[3]);
		2335	break;
		2336	case TYPE_INT64:
		2337	params[0] = INT64_TO_BOOLEAN(v.value_int);
		2338	break;
		2339	default:
		2340	; /* nothing - GL error was recorded */
		2341	}
		2342	}
		2343
		2344	void GLAPIENTRY
		2345	_mesa_GetIntegerIndexedv( GLenum pname, GLuint index, GLint *params )
		2346	{
		2347	union value v;
		2348	enum value_type type =
		2349	find_value_indexed("glGetIntegerIndexedv", pname, index, &v);
		2350
		2351	switch (type) {
		2352	case TYPE_INT:
		2353	params[0] = v.value_int;
		2354	break;
		2355	case TYPE_INT_4:
		2356	params[0] = v.value_int_4[0];
		2357	params[1] = v.value_int_4[1];
		2358	params[2] = v.value_int_4[2];
		2359	params[3] = v.value_int_4[3];
		2360	break;
		2361	case TYPE_INT64:
		2362	params[0] = INT64_TO_INT(v.value_int);
		2363	break;
		2364	default:
		2365	; /* nothing - GL error was recorded */
		2366	}
		2367	}
		2368
		2369	#if FEATURE_ARB_sync
		2370	void GLAPIENTRY
		2371	_mesa_GetInteger64Indexedv( GLenum pname, GLuint index, GLint64 *params )
		2372	{
		2373	union value v;
		2374	enum value_type type =
		2375	find_value_indexed("glGetIntegerIndexedv", pname, index, &v);
		2376
		2377	switch (type) {
		2378	case TYPE_INT:
		2379	params[0] = v.value_int;
		2380	break;
		2381	case TYPE_INT_4:
		2382	params[0] = v.value_int_4[0];
		2383	params[1] = v.value_int_4[1];
		2384	params[2] = v.value_int_4[2];
		2385	params[3] = v.value_int_4[3];
		2386	break;
		2387	case TYPE_INT64:
		2388	params[0] = v.value_int;
		2389	break;
		2390	default:
		2391	; /* nothing - GL error was recorded */
		2392	}
		2393	}
		2394	#endif /* FEATURE_ARB_sync */
		2395
		2396	#if FEATURE_ES1
		2397	void GLAPIENTRY
		2398	_mesa_GetFixedv(GLenum pname, GLfixed *params)
		2399	{
		2400	const struct value_desc *d;
		2401	union value v;
		2402	GLmatrix *m;
		2403	int shift, i;
		2404	void *p;
		2405
		2406	d = find_value("glGetDoublev", pname, &p, &v);
		2407	switch (d->type) {
		2408	case TYPE_INVALID:
		2409	break;
		2410	case TYPE_CONST:
		2411	params[0] = INT_TO_FIXED(d->offset);
		2412	break;
		2413
		2414	case TYPE_FLOAT_4:
		2415	case TYPE_FLOATN_4:
		2416	params[3] = FLOAT_TO_FIXED(((GLfloat *) p)[3]);
		2417	case TYPE_FLOAT_3:
		2418	case TYPE_FLOATN_3:
		2419	params[2] = FLOAT_TO_FIXED(((GLfloat *) p)[2]);
		2420	case TYPE_FLOAT_2:
		2421	case TYPE_FLOATN_2:
		2422	params[1] = FLOAT_TO_FIXED(((GLfloat *) p)[1]);
		2423	case TYPE_FLOAT:
		2424	case TYPE_FLOATN:
		2425	params[0] = FLOAT_TO_FIXED(((GLfloat *) p)[0]);
		2426	break;
		2427
		2428	case TYPE_DOUBLEN:
		2429	params[0] = FLOAT_TO_FIXED(((GLdouble *) p)[0]);
		2430	break;
		2431
		2432	case TYPE_INT_4:
		2433	params[3] = INT_TO_FIXED(((GLint *) p)[3]);
		2434	case TYPE_INT_3:
		2435	params[2] = INT_TO_FIXED(((GLint *) p)[2]);
		2436	case TYPE_INT_2:
		2437	case TYPE_ENUM_2:
		2438	params[1] = INT_TO_FIXED(((GLint *) p)[1]);
		2439	case TYPE_INT:
		2440	case TYPE_ENUM:
		2441	params[0] = INT_TO_FIXED(((GLint *) p)[0]);
		2442	break;
		2443
		2444	case TYPE_INT_N:
		2445	for (i = 0; i < v.value_int_n.n; i++)
		2446	params[i] = INT_TO_FIXED(v.value_int_n.ints[i]);
		2447	break;
		2448
		2449	case TYPE_INT64:
		2450	params[0] = ((GLint64 *) p)[0];
		2451	break;
		2452
		2453	case TYPE_BOOLEAN:
		2454	params[0] = BOOLEAN_TO_FIXED(((GLboolean*) p)[0]);
		2455	break;
		2456
		2457	case TYPE_MATRIX:
		2458	m = (GLmatrix *) p;
		2459	for (i = 0; i < 16; i++)
		2460	params[i] = FLOAT_TO_FIXED(m->m[i]);
		2461	break;
		2462
		2463	case TYPE_MATRIX_T:
		2464	m = (GLmatrix *) p;
		2465	for (i = 0; i < 16; i++)
		2466	params[i] = FLOAT_TO_FIXED(m->m[transpose[i]]);
		2467	break;
		2468
		2469	case TYPE_BIT_0:
		2470	case TYPE_BIT_1:
		2471	case TYPE_BIT_2:
		2472	case TYPE_BIT_3:
		2473	case TYPE_BIT_4:
		2474	case TYPE_BIT_5:
		2475	shift = d->type - TYPE_BIT_0;
		2476	params[0] = BOOLEAN_TO_FIXED(((GLbitfield ) p >> shift) & 1);
		2477	break;
		2478	}
		2479	}
		2480	#endif

Subversion Repositories Kolibri OS

(root)/programs/develop/libraries/Mesa/src/mesa/main/get.c – Rev 2348