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

Rev	Author	Line No.	Line
1901	serge	1	/**
		2	* \file enable.c
		3	* Enable/disable/query GL capabilities.
		4	*/
		5
		6	/*
		7	* Mesa 3-D graphics library
		8	* Version: 7.0.3
		9	*
		10	* Copyright (C) 1999-2007 Brian Paul All Rights Reserved.
		11	*
		12	* Permission is hereby granted, free of charge, to any person obtaining a
		13	* copy of this software and associated documentation files (the "Software"),
		14	* to deal in the Software without restriction, including without limitation
		15	* the rights to use, copy, modify, merge, publish, distribute, sublicense,
		16	* and/or sell copies of the Software, and to permit persons to whom the
		17	* Software is furnished to do so, subject to the following conditions:
		18	*
		19	* The above copyright notice and this permission notice shall be included
		20	* in all copies or substantial portions of the Software.
		21	*
		22	* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
		23	* OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
		24	* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
		25	* BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
		26	* AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
		27	* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
		28	*/
		29
		30
		31	#include "glheader.h"
		32	#include "context.h"
		33	#include "enable.h"
		34	#include "light.h"
		35	#include "simple_list.h"
		36	#include "mtypes.h"
		37	#include "enums.h"
		38	#include "api_arrayelt.h"
		39	#include "texstate.h"
		40
		41
		42
		43	#define CHECK_EXTENSION(EXTNAME, CAP) \
		44	if (!ctx->Extensions.EXTNAME) { \
		45	goto invalid_enum_error; \
		46	}
		47
		48
		49	/**
		50	* Helper to enable/disable client-side state.
		51	*/
		52	static void
		53	client_state(struct gl_context *ctx, GLenum cap, GLboolean state)
		54	{
		55	struct gl_array_object *arrayObj = ctx->Array.ArrayObj;
		56	GLuint flag;
		57	GLboolean *var;
		58
		59	switch (cap) {
		60	case GL_VERTEX_ARRAY:
		61	var = &arrayObj->Vertex.Enabled;
		62	flag = _NEW_ARRAY_VERTEX;
		63	break;
		64	case GL_NORMAL_ARRAY:
		65	var = &arrayObj->Normal.Enabled;
		66	flag = _NEW_ARRAY_NORMAL;
		67	break;
		68	case GL_COLOR_ARRAY:
		69	var = &arrayObj->Color.Enabled;
		70	flag = _NEW_ARRAY_COLOR0;
		71	break;
		72	case GL_INDEX_ARRAY:
		73	var = &arrayObj->Index.Enabled;
		74	flag = _NEW_ARRAY_INDEX;
		75	break;
		76	case GL_TEXTURE_COORD_ARRAY:
		77	var = &arrayObj->TexCoord[ctx->Array.ActiveTexture].Enabled;
		78	flag = _NEW_ARRAY_TEXCOORD(ctx->Array.ActiveTexture);
		79	break;
		80	case GL_EDGE_FLAG_ARRAY:
		81	var = &arrayObj->EdgeFlag.Enabled;
		82	flag = _NEW_ARRAY_EDGEFLAG;
		83	break;
		84	case GL_FOG_COORDINATE_ARRAY_EXT:
		85	var = &arrayObj->FogCoord.Enabled;
		86	flag = _NEW_ARRAY_FOGCOORD;
		87	break;
		88	case GL_SECONDARY_COLOR_ARRAY_EXT:
		89	var = &arrayObj->SecondaryColor.Enabled;
		90	flag = _NEW_ARRAY_COLOR1;
		91	break;
		92
		93	#if FEATURE_point_size_array
		94	case GL_POINT_SIZE_ARRAY_OES:
		95	var = &arrayObj->PointSize.Enabled;
		96	flag = _NEW_ARRAY_POINT_SIZE;
		97	break;
		98	#endif
		99
		100	#if FEATURE_NV_vertex_program
		101	case GL_VERTEX_ATTRIB_ARRAY0_NV:
		102	case GL_VERTEX_ATTRIB_ARRAY1_NV:
		103	case GL_VERTEX_ATTRIB_ARRAY2_NV:
		104	case GL_VERTEX_ATTRIB_ARRAY3_NV:
		105	case GL_VERTEX_ATTRIB_ARRAY4_NV:
		106	case GL_VERTEX_ATTRIB_ARRAY5_NV:
		107	case GL_VERTEX_ATTRIB_ARRAY6_NV:
		108	case GL_VERTEX_ATTRIB_ARRAY7_NV:
		109	case GL_VERTEX_ATTRIB_ARRAY8_NV:
		110	case GL_VERTEX_ATTRIB_ARRAY9_NV:
		111	case GL_VERTEX_ATTRIB_ARRAY10_NV:
		112	case GL_VERTEX_ATTRIB_ARRAY11_NV:
		113	case GL_VERTEX_ATTRIB_ARRAY12_NV:
		114	case GL_VERTEX_ATTRIB_ARRAY13_NV:
		115	case GL_VERTEX_ATTRIB_ARRAY14_NV:
		116	case GL_VERTEX_ATTRIB_ARRAY15_NV:
		117	CHECK_EXTENSION(NV_vertex_program, cap);
		118	{
		119	GLint n = (GLint) cap - GL_VERTEX_ATTRIB_ARRAY0_NV;
		120	ASSERT(n < Elements(ctx->Array.ArrayObj->VertexAttrib));
		121	var = &arrayObj->VertexAttrib[n].Enabled;
		122	flag = _NEW_ARRAY_ATTRIB(n);
		123	}
		124	break;
		125	#endif /* FEATURE_NV_vertex_program */
		126
		127	/* GL_NV_primitive_restart */
		128	case GL_PRIMITIVE_RESTART_NV:
		129	if (!ctx->Extensions.NV_primitive_restart) {
		130	goto invalid_enum_error;
		131	}
		132	var = &ctx->Array.PrimitiveRestart;
		133	flag = 0;
		134	break;
		135
		136	default:
		137	goto invalid_enum_error;
		138	}
		139
		140	if (*var == state)
		141	return;
		142
		143	FLUSH_VERTICES(ctx, _NEW_ARRAY);
		144	ctx->Array.NewState \|= flag;
		145
		146	_ae_invalidate_state(ctx, _NEW_ARRAY);
		147
		148	*var = state;
		149
		150	if (state)
		151	ctx->Array.ArrayObj->_Enabled \|= flag;
		152	else
		153	ctx->Array.ArrayObj->_Enabled &= ~flag;
		154
		155	if (ctx->Driver.Enable) {
		156	ctx->Driver.Enable( ctx, cap, state );
		157	}
		158
		159	return;
		160
		161	invalid_enum_error:
		162	_mesa_error(ctx, GL_INVALID_ENUM, "gl%sClientState(0x%x)",
		163	state ? "Enable" : "Disable", cap);
		164	}
		165
		166
		167	/**
		168	* Enable GL capability.
		169	* \param cap state to enable/disable.
		170	*
		171	* Get's the current context, assures that we're outside glBegin()/glEnd() and
		172	* calls client_state().
		173	*/
		174	void GLAPIENTRY
		175	_mesa_EnableClientState( GLenum cap )
		176	{
		177	GET_CURRENT_CONTEXT(ctx);
		178	ASSERT_OUTSIDE_BEGIN_END(ctx);
		179	client_state( ctx, cap, GL_TRUE );
		180	}
		181
		182
		183	/**
		184	* Disable GL capability.
		185	* \param cap state to enable/disable.
		186	*
		187	* Get's the current context, assures that we're outside glBegin()/glEnd() and
		188	* calls client_state().
		189	*/
		190	void GLAPIENTRY
		191	_mesa_DisableClientState( GLenum cap )
		192	{
		193	GET_CURRENT_CONTEXT(ctx);
		194	ASSERT_OUTSIDE_BEGIN_END(ctx);
		195	client_state( ctx, cap, GL_FALSE );
		196	}
		197
		198
		199	#undef CHECK_EXTENSION
		200	#define CHECK_EXTENSION(EXTNAME, CAP) \
		201	if (!ctx->Extensions.EXTNAME) { \
		202	goto invalid_enum_error; \
		203	}
		204
		205	#define CHECK_EXTENSION2(EXT1, EXT2, CAP) \
		206	if (!ctx->Extensions.EXT1 && !ctx->Extensions.EXT2) { \
		207	goto invalid_enum_error; \
		208	}
		209
		210
		211
		212	/**
		213	* Return pointer to current texture unit for setting/getting coordinate
		214	* state.
		215	* Note that we'll set GL_INVALID_OPERATION if the active texture unit is
		216	* higher than the number of supported coordinate units. And we'll return NULL.
		217	*/
		218	static struct gl_texture_unit *
		219	get_texcoord_unit(struct gl_context *ctx)
		220	{
		221	if (ctx->Texture.CurrentUnit >= ctx->Const.MaxTextureCoordUnits) {
		222	_mesa_error(ctx, GL_INVALID_OPERATION, "glEnable/Disable(texcoord unit)");
		223	return NULL;
		224	}
		225	else {
		226	return &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
		227	}
		228	}
		229
		230
		231	/**
		232	* Helper function to enable or disable a texture target.
		233	* \param bit one of the TEXTURE_x_BIT values
		234	* \return GL_TRUE if state is changing or GL_FALSE if no change
		235	*/
		236	static GLboolean
		237	enable_texture(struct gl_context *ctx, GLboolean state, GLbitfield texBit)
		238	{
		239	struct gl_texture_unit *texUnit = _mesa_get_current_tex_unit(ctx);
		240	const GLbitfield newenabled = state
		241	? (texUnit->Enabled \| texBit) : (texUnit->Enabled & ~texBit);
		242
		243	if (texUnit->Enabled == newenabled)
		244	return GL_FALSE;
		245
		246	FLUSH_VERTICES(ctx, _NEW_TEXTURE);
		247	texUnit->Enabled = newenabled;
		248	return GL_TRUE;
		249	}
		250
		251
		252	/**
		253	* Helper function to enable or disable state.
		254	*
		255	* \param ctx GL context.
		256	* \param cap the state to enable/disable
		257	* \param state whether to enable or disable the specified capability.
		258	*
		259	* Updates the current context and flushes the vertices as needed. For
		260	* capabilities associated with extensions it verifies that those extensions
		261	* are effectivly present before updating. Notifies the driver via
		262	* dd_function_table::Enable.
		263	*/
		264	void
		265	_mesa_set_enable(struct gl_context *ctx, GLenum cap, GLboolean state)
		266	{
		267	if (MESA_VERBOSE & VERBOSE_API)
		268	_mesa_debug(ctx, "%s %s (newstate is %x)\n",
		269	state ? "glEnable" : "glDisable",
		270	_mesa_lookup_enum_by_nr(cap),
		271	ctx->NewState);
		272
		273	switch (cap) {
		274	case GL_ALPHA_TEST:
		275	if (ctx->Color.AlphaEnabled == state)
		276	return;
		277	FLUSH_VERTICES(ctx, _NEW_COLOR);
		278	ctx->Color.AlphaEnabled = state;
		279	break;
		280	case GL_AUTO_NORMAL:
		281	if (ctx->Eval.AutoNormal == state)
		282	return;
		283	FLUSH_VERTICES(ctx, _NEW_EVAL);
		284	ctx->Eval.AutoNormal = state;
		285	break;
		286	case GL_BLEND:
		287	{
		288	GLbitfield newEnabled = state * ((1 << ctx->Const.MaxDrawBuffers) - 1);
		289	if (newEnabled != ctx->Color.BlendEnabled) {
		290	FLUSH_VERTICES(ctx, _NEW_COLOR);
		291	ctx->Color.BlendEnabled = newEnabled;
		292	}
		293	}
		294	break;
		295	#if FEATURE_userclip
		296	case GL_CLIP_PLANE0:
		297	case GL_CLIP_PLANE1:
		298	case GL_CLIP_PLANE2:
		299	case GL_CLIP_PLANE3:
		300	case GL_CLIP_PLANE4:
		301	case GL_CLIP_PLANE5:
		302	{
		303	const GLuint p = cap - GL_CLIP_PLANE0;
		304
		305	if ((ctx->Transform.ClipPlanesEnabled & (1 << p)) == ((GLuint) state << p))
		306	return;
		307
		308	FLUSH_VERTICES(ctx, _NEW_TRANSFORM);
		309
		310	if (state) {
		311	ctx->Transform.ClipPlanesEnabled \|= (1 << p);
		312
		313	if (_math_matrix_is_dirty(ctx->ProjectionMatrixStack.Top))
		314	_math_matrix_analyse( ctx->ProjectionMatrixStack.Top );
		315
		316	/* This derived state also calculated in clip.c and
		317	* from _mesa_update_state() on changes to EyeUserPlane
		318	* and ctx->ProjectionMatrix respectively.
		319	*/
		320	_mesa_transform_vector( ctx->Transform._ClipUserPlane[p],
		321	ctx->Transform.EyeUserPlane[p],
		322	ctx->ProjectionMatrixStack.Top->inv );
		323	}
		324	else {
		325	ctx->Transform.ClipPlanesEnabled &= ~(1 << p);
		326	}
		327	}
		328	break;
		329	#endif
		330	case GL_COLOR_MATERIAL:
		331	if (ctx->Light.ColorMaterialEnabled == state)
		332	return;
		333	FLUSH_VERTICES(ctx, _NEW_LIGHT);
		334	FLUSH_CURRENT(ctx, 0);
		335	ctx->Light.ColorMaterialEnabled = state;
		336	if (state) {
		337	_mesa_update_color_material( ctx,
		338	ctx->Current.Attrib[VERT_ATTRIB_COLOR0] );
		339	}
		340	break;
		341	case GL_CULL_FACE:
		342	if (ctx->Polygon.CullFlag == state)
		343	return;
		344	FLUSH_VERTICES(ctx, _NEW_POLYGON);
		345	ctx->Polygon.CullFlag = state;
		346	break;
		347	case GL_DEPTH_TEST:
		348	if (ctx->Depth.Test == state)
		349	return;
		350	FLUSH_VERTICES(ctx, _NEW_DEPTH);
		351	ctx->Depth.Test = state;
		352	break;
		353	case GL_DITHER:
		354	if (ctx->NoDither) {
		355	state = GL_FALSE; /* MESA_NO_DITHER env var */
		356	}
		357	if (ctx->Color.DitherFlag == state)
		358	return;
		359	FLUSH_VERTICES(ctx, _NEW_COLOR);
		360	ctx->Color.DitherFlag = state;
		361	break;
		362	case GL_FOG:
		363	if (ctx->Fog.Enabled == state)
		364	return;
		365	FLUSH_VERTICES(ctx, _NEW_FOG);
		366	ctx->Fog.Enabled = state;
		367	break;
		368	case GL_LIGHT0:
		369	case GL_LIGHT1:
		370	case GL_LIGHT2:
		371	case GL_LIGHT3:
		372	case GL_LIGHT4:
		373	case GL_LIGHT5:
		374	case GL_LIGHT6:
		375	case GL_LIGHT7:
		376	if (ctx->Light.Light[cap-GL_LIGHT0].Enabled == state)
		377	return;
		378	FLUSH_VERTICES(ctx, _NEW_LIGHT);
		379	ctx->Light.Light[cap-GL_LIGHT0].Enabled = state;
		380	if (state) {
		381	insert_at_tail(&ctx->Light.EnabledList,
		382	&ctx->Light.Light[cap-GL_LIGHT0]);
		383	}
		384	else {
		385	remove_from_list(&ctx->Light.Light[cap-GL_LIGHT0]);
		386	}
		387	break;
		388	case GL_LIGHTING:
		389	if (ctx->Light.Enabled == state)
		390	return;
		391	FLUSH_VERTICES(ctx, _NEW_LIGHT);
		392	ctx->Light.Enabled = state;
		393	if (ctx->Light.Enabled && ctx->Light.Model.TwoSide)
		394	ctx->_TriangleCaps \|= DD_TRI_LIGHT_TWOSIDE;
		395	else
		396	ctx->_TriangleCaps &= ~DD_TRI_LIGHT_TWOSIDE;
		397	break;
		398	case GL_LINE_SMOOTH:
		399	if (ctx->Line.SmoothFlag == state)
		400	return;
		401	FLUSH_VERTICES(ctx, _NEW_LINE);
		402	ctx->Line.SmoothFlag = state;
		403	ctx->_TriangleCaps ^= DD_LINE_SMOOTH;
		404	break;
		405	case GL_LINE_STIPPLE:
		406	if (ctx->Line.StippleFlag == state)
		407	return;
		408	FLUSH_VERTICES(ctx, _NEW_LINE);
		409	ctx->Line.StippleFlag = state;
		410	ctx->_TriangleCaps ^= DD_LINE_STIPPLE;
		411	break;
		412	case GL_INDEX_LOGIC_OP:
		413	if (ctx->Color.IndexLogicOpEnabled == state)
		414	return;
		415	FLUSH_VERTICES(ctx, _NEW_COLOR);
		416	ctx->Color.IndexLogicOpEnabled = state;
		417	break;
		418	case GL_COLOR_LOGIC_OP:
		419	if (ctx->Color.ColorLogicOpEnabled == state)
		420	return;
		421	FLUSH_VERTICES(ctx, _NEW_COLOR);
		422	ctx->Color.ColorLogicOpEnabled = state;
		423	break;
		424	case GL_MAP1_COLOR_4:
		425	if (ctx->Eval.Map1Color4 == state)
		426	return;
		427	FLUSH_VERTICES(ctx, _NEW_EVAL);
		428	ctx->Eval.Map1Color4 = state;
		429	break;
		430	case GL_MAP1_INDEX:
		431	if (ctx->Eval.Map1Index == state)
		432	return;
		433	FLUSH_VERTICES(ctx, _NEW_EVAL);
		434	ctx->Eval.Map1Index = state;
		435	break;
		436	case GL_MAP1_NORMAL:
		437	if (ctx->Eval.Map1Normal == state)
		438	return;
		439	FLUSH_VERTICES(ctx, _NEW_EVAL);
		440	ctx->Eval.Map1Normal = state;
		441	break;
		442	case GL_MAP1_TEXTURE_COORD_1:
		443	if (ctx->Eval.Map1TextureCoord1 == state)
		444	return;
		445	FLUSH_VERTICES(ctx, _NEW_EVAL);
		446	ctx->Eval.Map1TextureCoord1 = state;
		447	break;
		448	case GL_MAP1_TEXTURE_COORD_2:
		449	if (ctx->Eval.Map1TextureCoord2 == state)
		450	return;
		451	FLUSH_VERTICES(ctx, _NEW_EVAL);
		452	ctx->Eval.Map1TextureCoord2 = state;
		453	break;
		454	case GL_MAP1_TEXTURE_COORD_3:
		455	if (ctx->Eval.Map1TextureCoord3 == state)
		456	return;
		457	FLUSH_VERTICES(ctx, _NEW_EVAL);
		458	ctx->Eval.Map1TextureCoord3 = state;
		459	break;
		460	case GL_MAP1_TEXTURE_COORD_4:
		461	if (ctx->Eval.Map1TextureCoord4 == state)
		462	return;
		463	FLUSH_VERTICES(ctx, _NEW_EVAL);
		464	ctx->Eval.Map1TextureCoord4 = state;
		465	break;
		466	case GL_MAP1_VERTEX_3:
		467	if (ctx->Eval.Map1Vertex3 == state)
		468	return;
		469	FLUSH_VERTICES(ctx, _NEW_EVAL);
		470	ctx->Eval.Map1Vertex3 = state;
		471	break;
		472	case GL_MAP1_VERTEX_4:
		473	if (ctx->Eval.Map1Vertex4 == state)
		474	return;
		475	FLUSH_VERTICES(ctx, _NEW_EVAL);
		476	ctx->Eval.Map1Vertex4 = state;
		477	break;
		478	case GL_MAP2_COLOR_4:
		479	if (ctx->Eval.Map2Color4 == state)
		480	return;
		481	FLUSH_VERTICES(ctx, _NEW_EVAL);
		482	ctx->Eval.Map2Color4 = state;
		483	break;
		484	case GL_MAP2_INDEX:
		485	if (ctx->Eval.Map2Index == state)
		486	return;
		487	FLUSH_VERTICES(ctx, _NEW_EVAL);
		488	ctx->Eval.Map2Index = state;
		489	break;
		490	case GL_MAP2_NORMAL:
		491	if (ctx->Eval.Map2Normal == state)
		492	return;
		493	FLUSH_VERTICES(ctx, _NEW_EVAL);
		494	ctx->Eval.Map2Normal = state;
		495	break;
		496	case GL_MAP2_TEXTURE_COORD_1:
		497	if (ctx->Eval.Map2TextureCoord1 == state)
		498	return;
		499	FLUSH_VERTICES(ctx, _NEW_EVAL);
		500	ctx->Eval.Map2TextureCoord1 = state;
		501	break;
		502	case GL_MAP2_TEXTURE_COORD_2:
		503	if (ctx->Eval.Map2TextureCoord2 == state)
		504	return;
		505	FLUSH_VERTICES(ctx, _NEW_EVAL);
		506	ctx->Eval.Map2TextureCoord2 = state;
		507	break;
		508	case GL_MAP2_TEXTURE_COORD_3:
		509	if (ctx->Eval.Map2TextureCoord3 == state)
		510	return;
		511	FLUSH_VERTICES(ctx, _NEW_EVAL);
		512	ctx->Eval.Map2TextureCoord3 = state;
		513	break;
		514	case GL_MAP2_TEXTURE_COORD_4:
		515	if (ctx->Eval.Map2TextureCoord4 == state)
		516	return;
		517	FLUSH_VERTICES(ctx, _NEW_EVAL);
		518	ctx->Eval.Map2TextureCoord4 = state;
		519	break;
		520	case GL_MAP2_VERTEX_3:
		521	if (ctx->Eval.Map2Vertex3 == state)
		522	return;
		523	FLUSH_VERTICES(ctx, _NEW_EVAL);
		524	ctx->Eval.Map2Vertex3 = state;
		525	break;
		526	case GL_MAP2_VERTEX_4:
		527	if (ctx->Eval.Map2Vertex4 == state)
		528	return;
		529	FLUSH_VERTICES(ctx, _NEW_EVAL);
		530	ctx->Eval.Map2Vertex4 = state;
		531	break;
		532	case GL_NORMALIZE:
		533	if (ctx->Transform.Normalize == state)
		534	return;
		535	FLUSH_VERTICES(ctx, _NEW_TRANSFORM);
		536	ctx->Transform.Normalize = state;
		537	break;
		538	case GL_POINT_SMOOTH:
		539	if (ctx->Point.SmoothFlag == state)
		540	return;
		541	FLUSH_VERTICES(ctx, _NEW_POINT);
		542	ctx->Point.SmoothFlag = state;
		543	ctx->_TriangleCaps ^= DD_POINT_SMOOTH;
		544	break;
		545	case GL_POLYGON_SMOOTH:
		546	if (ctx->Polygon.SmoothFlag == state)
		547	return;
		548	FLUSH_VERTICES(ctx, _NEW_POLYGON);
		549	ctx->Polygon.SmoothFlag = state;
		550	ctx->_TriangleCaps ^= DD_TRI_SMOOTH;
		551	break;
		552	case GL_POLYGON_STIPPLE:
		553	if (ctx->Polygon.StippleFlag == state)
		554	return;
		555	FLUSH_VERTICES(ctx, _NEW_POLYGON);
		556	ctx->Polygon.StippleFlag = state;
		557	ctx->_TriangleCaps ^= DD_TRI_STIPPLE;
		558	break;
		559	case GL_POLYGON_OFFSET_POINT:
		560	if (ctx->Polygon.OffsetPoint == state)
		561	return;
		562	FLUSH_VERTICES(ctx, _NEW_POLYGON);
		563	ctx->Polygon.OffsetPoint = state;
		564	break;
		565	case GL_POLYGON_OFFSET_LINE:
		566	if (ctx->Polygon.OffsetLine == state)
		567	return;
		568	FLUSH_VERTICES(ctx, _NEW_POLYGON);
		569	ctx->Polygon.OffsetLine = state;
		570	break;
		571	case GL_POLYGON_OFFSET_FILL:
		572	/case GL_POLYGON_OFFSET_EXT:/
		573	if (ctx->Polygon.OffsetFill == state)
		574	return;
		575	FLUSH_VERTICES(ctx, _NEW_POLYGON);
		576	ctx->Polygon.OffsetFill = state;
		577	break;
		578	case GL_RESCALE_NORMAL_EXT:
		579	if (ctx->Transform.RescaleNormals == state)
		580	return;
		581	FLUSH_VERTICES(ctx, _NEW_TRANSFORM);
		582	ctx->Transform.RescaleNormals = state;
		583	break;
		584	case GL_SCISSOR_TEST:
		585	if (ctx->Scissor.Enabled == state)
		586	return;
		587	FLUSH_VERTICES(ctx, _NEW_SCISSOR);
		588	ctx->Scissor.Enabled = state;
		589	break;
		590	case GL_SHARED_TEXTURE_PALETTE_EXT:
		591	if (ctx->Texture.SharedPalette == state)
		592	return;
		593	FLUSH_VERTICES(ctx, _NEW_TEXTURE);
		594	ctx->Texture.SharedPalette = state;
		595	break;
		596	case GL_STENCIL_TEST:
		597	if (ctx->Stencil.Enabled == state)
		598	return;
		599	FLUSH_VERTICES(ctx, _NEW_STENCIL);
		600	ctx->Stencil.Enabled = state;
		601	break;
		602	case GL_TEXTURE_1D:
		603	if (!enable_texture(ctx, state, TEXTURE_1D_BIT)) {
		604	return;
		605	}
		606	break;
		607	case GL_TEXTURE_2D:
		608	if (!enable_texture(ctx, state, TEXTURE_2D_BIT)) {
		609	return;
		610	}
		611	break;
		612	case GL_TEXTURE_3D:
		613	if (!enable_texture(ctx, state, TEXTURE_3D_BIT)) {
		614	return;
		615	}
		616	break;
		617	case GL_TEXTURE_GEN_Q:
		618	{
		619	struct gl_texture_unit *texUnit = get_texcoord_unit(ctx);
		620	if (texUnit) {
		621	GLuint newenabled = texUnit->TexGenEnabled & ~Q_BIT;
		622	if (state)
		623	newenabled \|= Q_BIT;
		624	if (texUnit->TexGenEnabled == newenabled)
		625	return;
		626	FLUSH_VERTICES(ctx, _NEW_TEXTURE);
		627	texUnit->TexGenEnabled = newenabled;
		628	}
		629	}
		630	break;
		631	case GL_TEXTURE_GEN_R:
		632	{
		633	struct gl_texture_unit *texUnit = get_texcoord_unit(ctx);
		634	if (texUnit) {
		635	GLuint newenabled = texUnit->TexGenEnabled & ~R_BIT;
		636	if (state)
		637	newenabled \|= R_BIT;
		638	if (texUnit->TexGenEnabled == newenabled)
		639	return;
		640	FLUSH_VERTICES(ctx, _NEW_TEXTURE);
		641	texUnit->TexGenEnabled = newenabled;
		642	}
		643	}
		644	break;
		645	case GL_TEXTURE_GEN_S:
		646	{
		647	struct gl_texture_unit *texUnit = get_texcoord_unit(ctx);
		648	if (texUnit) {
		649	GLuint newenabled = texUnit->TexGenEnabled & ~S_BIT;
		650	if (state)
		651	newenabled \|= S_BIT;
		652	if (texUnit->TexGenEnabled == newenabled)
		653	return;
		654	FLUSH_VERTICES(ctx, _NEW_TEXTURE);
		655	texUnit->TexGenEnabled = newenabled;
		656	}
		657	}
		658	break;
		659	case GL_TEXTURE_GEN_T:
		660	{
		661	struct gl_texture_unit *texUnit = get_texcoord_unit(ctx);
		662	if (texUnit) {
		663	GLuint newenabled = texUnit->TexGenEnabled & ~T_BIT;
		664	if (state)
		665	newenabled \|= T_BIT;
		666	if (texUnit->TexGenEnabled == newenabled)
		667	return;
		668	FLUSH_VERTICES(ctx, _NEW_TEXTURE);
		669	texUnit->TexGenEnabled = newenabled;
		670	}
		671	}
		672	break;
		673
		674	#if FEATURE_ES1
		675	case GL_TEXTURE_GEN_STR_OES:
		676	/* disable S, T, and R at the same time */
		677	{
		678	struct gl_texture_unit *texUnit = get_texcoord_unit(ctx);
		679	if (texUnit) {
		680	GLuint newenabled =
		681	texUnit->TexGenEnabled & ~STR_BITS;
		682	if (state)
		683	newenabled \|= STR_BITS;
		684	if (texUnit->TexGenEnabled == newenabled)
		685	return;
		686	FLUSH_VERTICES(ctx, _NEW_TEXTURE);
		687	texUnit->TexGenEnabled = newenabled;
		688	}
		689	}
		690	break;
		691	#endif
		692
		693	/*
		694	* CLIENT STATE!!!
		695	*/
		696	case GL_VERTEX_ARRAY:
		697	case GL_NORMAL_ARRAY:
		698	case GL_COLOR_ARRAY:
		699	case GL_INDEX_ARRAY:
		700	case GL_TEXTURE_COORD_ARRAY:
		701	case GL_EDGE_FLAG_ARRAY:
		702	case GL_FOG_COORDINATE_ARRAY_EXT:
		703	case GL_SECONDARY_COLOR_ARRAY_EXT:
		704	case GL_POINT_SIZE_ARRAY_OES:
		705	client_state( ctx, cap, state );
		706	return;
		707
		708	/* GL_SGI_texture_color_table */
		709	case GL_TEXTURE_COLOR_TABLE_SGI:
		710	CHECK_EXTENSION(SGI_texture_color_table, cap);
		711	if (ctx->Texture.Unit[ctx->Texture.CurrentUnit].ColorTableEnabled == state)
		712	return;
		713	FLUSH_VERTICES(ctx, _NEW_TEXTURE);
		714	ctx->Texture.Unit[ctx->Texture.CurrentUnit].ColorTableEnabled = state;
		715	break;
		716
		717	/* GL_ARB_texture_cube_map */
		718	case GL_TEXTURE_CUBE_MAP_ARB:
		719	CHECK_EXTENSION(ARB_texture_cube_map, cap);
		720	if (!enable_texture(ctx, state, TEXTURE_CUBE_BIT)) {
		721	return;
		722	}
		723	break;
		724
		725	/* GL_EXT_secondary_color */
		726	case GL_COLOR_SUM_EXT:
		727	CHECK_EXTENSION2(EXT_secondary_color, ARB_vertex_program, cap);
		728	if (ctx->Fog.ColorSumEnabled == state)
		729	return;
		730	FLUSH_VERTICES(ctx, _NEW_FOG);
		731	ctx->Fog.ColorSumEnabled = state;
		732	break;
		733
		734	/* GL_ARB_multisample */
		735	case GL_MULTISAMPLE_ARB:
		736	if (ctx->Multisample.Enabled == state)
		737	return;
		738	FLUSH_VERTICES(ctx, _NEW_MULTISAMPLE);
		739	ctx->Multisample.Enabled = state;
		740	break;
		741	case GL_SAMPLE_ALPHA_TO_COVERAGE_ARB:
		742	if (ctx->Multisample.SampleAlphaToCoverage == state)
		743	return;
		744	FLUSH_VERTICES(ctx, _NEW_MULTISAMPLE);
		745	ctx->Multisample.SampleAlphaToCoverage = state;
		746	break;
		747	case GL_SAMPLE_ALPHA_TO_ONE_ARB:
		748	if (ctx->Multisample.SampleAlphaToOne == state)
		749	return;
		750	FLUSH_VERTICES(ctx, _NEW_MULTISAMPLE);
		751	ctx->Multisample.SampleAlphaToOne = state;
		752	break;
		753	case GL_SAMPLE_COVERAGE_ARB:
		754	if (ctx->Multisample.SampleCoverage == state)
		755	return;
		756	FLUSH_VERTICES(ctx, _NEW_MULTISAMPLE);
		757	ctx->Multisample.SampleCoverage = state;
		758	break;
		759	case GL_SAMPLE_COVERAGE_INVERT_ARB:
		760	if (ctx->Multisample.SampleCoverageInvert == state)
		761	return;
		762	FLUSH_VERTICES(ctx, _NEW_MULTISAMPLE);
		763	ctx->Multisample.SampleCoverageInvert = state;
		764	break;
		765
		766	/* GL_IBM_rasterpos_clip */
		767	case GL_RASTER_POSITION_UNCLIPPED_IBM:
		768	CHECK_EXTENSION(IBM_rasterpos_clip, cap);
		769	if (ctx->Transform.RasterPositionUnclipped == state)
		770	return;
		771	FLUSH_VERTICES(ctx, _NEW_TRANSFORM);
		772	ctx->Transform.RasterPositionUnclipped = state;
		773	break;
		774
		775	/* GL_NV_point_sprite */
		776	case GL_POINT_SPRITE_NV:
		777	CHECK_EXTENSION2(NV_point_sprite, ARB_point_sprite, cap);
		778	if (ctx->Point.PointSprite == state)
		779	return;
		780	FLUSH_VERTICES(ctx, _NEW_POINT);
		781	ctx->Point.PointSprite = state;
		782	break;
		783
		784	#if FEATURE_NV_vertex_program \|\| FEATURE_ARB_vertex_program
		785	case GL_VERTEX_PROGRAM_ARB:
		786	CHECK_EXTENSION2(ARB_vertex_program, NV_vertex_program, cap);
		787	if (ctx->VertexProgram.Enabled == state)
		788	return;
		789	FLUSH_VERTICES(ctx, _NEW_PROGRAM);
		790	ctx->VertexProgram.Enabled = state;
		791	break;
		792	case GL_VERTEX_PROGRAM_POINT_SIZE_ARB:
		793	CHECK_EXTENSION2(ARB_vertex_program, NV_vertex_program, cap);
		794	if (ctx->VertexProgram.PointSizeEnabled == state)
		795	return;
		796	FLUSH_VERTICES(ctx, _NEW_PROGRAM);
		797	ctx->VertexProgram.PointSizeEnabled = state;
		798	break;
		799	case GL_VERTEX_PROGRAM_TWO_SIDE_ARB:
		800	CHECK_EXTENSION2(ARB_vertex_program, NV_vertex_program, cap);
		801	if (ctx->VertexProgram.TwoSideEnabled == state)
		802	return;
		803	FLUSH_VERTICES(ctx, _NEW_PROGRAM);
		804	ctx->VertexProgram.TwoSideEnabled = state;
		805	break;
		806	#endif
		807	#if FEATURE_NV_vertex_program
		808	case GL_MAP1_VERTEX_ATTRIB0_4_NV:
		809	case GL_MAP1_VERTEX_ATTRIB1_4_NV:
		810	case GL_MAP1_VERTEX_ATTRIB2_4_NV:
		811	case GL_MAP1_VERTEX_ATTRIB3_4_NV:
		812	case GL_MAP1_VERTEX_ATTRIB4_4_NV:
		813	case GL_MAP1_VERTEX_ATTRIB5_4_NV:
		814	case GL_MAP1_VERTEX_ATTRIB6_4_NV:
		815	case GL_MAP1_VERTEX_ATTRIB7_4_NV:
		816	case GL_MAP1_VERTEX_ATTRIB8_4_NV:
		817	case GL_MAP1_VERTEX_ATTRIB9_4_NV:
		818	case GL_MAP1_VERTEX_ATTRIB10_4_NV:
		819	case GL_MAP1_VERTEX_ATTRIB11_4_NV:
		820	case GL_MAP1_VERTEX_ATTRIB12_4_NV:
		821	case GL_MAP1_VERTEX_ATTRIB13_4_NV:
		822	case GL_MAP1_VERTEX_ATTRIB14_4_NV:
		823	case GL_MAP1_VERTEX_ATTRIB15_4_NV:
		824	CHECK_EXTENSION(NV_vertex_program, cap);
		825	{
		826	const GLuint map = (GLuint) (cap - GL_MAP1_VERTEX_ATTRIB0_4_NV);
		827	FLUSH_VERTICES(ctx, _NEW_EVAL);
		828	ctx->Eval.Map1Attrib[map] = state;
		829	}
		830	break;
		831	case GL_MAP2_VERTEX_ATTRIB0_4_NV:
		832	case GL_MAP2_VERTEX_ATTRIB1_4_NV:
		833	case GL_MAP2_VERTEX_ATTRIB2_4_NV:
		834	case GL_MAP2_VERTEX_ATTRIB3_4_NV:
		835	case GL_MAP2_VERTEX_ATTRIB4_4_NV:
		836	case GL_MAP2_VERTEX_ATTRIB5_4_NV:
		837	case GL_MAP2_VERTEX_ATTRIB6_4_NV:
		838	case GL_MAP2_VERTEX_ATTRIB7_4_NV:
		839	case GL_MAP2_VERTEX_ATTRIB8_4_NV:
		840	case GL_MAP2_VERTEX_ATTRIB9_4_NV:
		841	case GL_MAP2_VERTEX_ATTRIB10_4_NV:
		842	case GL_MAP2_VERTEX_ATTRIB11_4_NV:
		843	case GL_MAP2_VERTEX_ATTRIB12_4_NV:
		844	case GL_MAP2_VERTEX_ATTRIB13_4_NV:
		845	case GL_MAP2_VERTEX_ATTRIB14_4_NV:
		846	case GL_MAP2_VERTEX_ATTRIB15_4_NV:
		847	CHECK_EXTENSION(NV_vertex_program, cap);
		848	{
		849	const GLuint map = (GLuint) (cap - GL_MAP2_VERTEX_ATTRIB0_4_NV);
		850	FLUSH_VERTICES(ctx, _NEW_EVAL);
		851	ctx->Eval.Map2Attrib[map] = state;
		852	}
		853	break;
		854	#endif /* FEATURE_NV_vertex_program */
		855
		856	#if FEATURE_NV_fragment_program
		857	case GL_FRAGMENT_PROGRAM_NV:
		858	CHECK_EXTENSION(NV_fragment_program, cap);
		859	if (ctx->FragmentProgram.Enabled == state)
		860	return;
		861	FLUSH_VERTICES(ctx, _NEW_PROGRAM);
		862	ctx->FragmentProgram.Enabled = state;
		863	break;
		864	#endif /* FEATURE_NV_fragment_program */
		865
		866	/* GL_NV_texture_rectangle */
		867	case GL_TEXTURE_RECTANGLE_NV:
		868	CHECK_EXTENSION(NV_texture_rectangle, cap);
		869	if (!enable_texture(ctx, state, TEXTURE_RECT_BIT)) {
		870	return;
		871	}
		872	break;
		873
		874	/* GL_EXT_stencil_two_side */
		875	case GL_STENCIL_TEST_TWO_SIDE_EXT:
		876	CHECK_EXTENSION(EXT_stencil_two_side, cap);
		877	if (ctx->Stencil.TestTwoSide == state)
		878	return;
		879	FLUSH_VERTICES(ctx, _NEW_STENCIL);
		880	ctx->Stencil.TestTwoSide = state;
		881	if (state) {
		882	ctx->Stencil._BackFace = 2;
		883	ctx->_TriangleCaps \|= DD_TRI_TWOSTENCIL;
		884	} else {
		885	ctx->Stencil._BackFace = 1;
		886	ctx->_TriangleCaps &= ~DD_TRI_TWOSTENCIL;
		887	}
		888	break;
		889
		890	#if FEATURE_ARB_fragment_program
		891	case GL_FRAGMENT_PROGRAM_ARB:
		892	CHECK_EXTENSION(ARB_fragment_program, cap);
		893	if (ctx->FragmentProgram.Enabled == state)
		894	return;
		895	FLUSH_VERTICES(ctx, _NEW_PROGRAM);
		896	ctx->FragmentProgram.Enabled = state;
		897	break;
		898	#endif /* FEATURE_ARB_fragment_program */
		899
		900	/* GL_EXT_depth_bounds_test */
		901	case GL_DEPTH_BOUNDS_TEST_EXT:
		902	CHECK_EXTENSION(EXT_depth_bounds_test, cap);
		903	if (ctx->Depth.BoundsTest == state)
		904	return;
		905	FLUSH_VERTICES(ctx, _NEW_DEPTH);
		906	ctx->Depth.BoundsTest = state;
		907	break;
		908
		909	case GL_DEPTH_CLAMP:
		910	if (ctx->Transform.DepthClamp == state)
		911	return;
		912	CHECK_EXTENSION(ARB_depth_clamp, cap);
		913	FLUSH_VERTICES(ctx, _NEW_TRANSFORM);
		914	ctx->Transform.DepthClamp = state;
		915	break;
		916
		917	#if FEATURE_ATI_fragment_shader
		918	case GL_FRAGMENT_SHADER_ATI:
		919	CHECK_EXTENSION(ATI_fragment_shader, cap);
		920	if (ctx->ATIFragmentShader.Enabled == state)
		921	return;
		922	FLUSH_VERTICES(ctx, _NEW_PROGRAM);
		923	ctx->ATIFragmentShader.Enabled = state;
		924	break;
		925	#endif
		926
		927	/* GL_MESA_texture_array */
		928	case GL_TEXTURE_1D_ARRAY_EXT:
		929	CHECK_EXTENSION(MESA_texture_array, cap);
		930	if (!enable_texture(ctx, state, TEXTURE_1D_ARRAY_BIT)) {
		931	return;
		932	}
		933	break;
		934
		935	case GL_TEXTURE_2D_ARRAY_EXT:
		936	CHECK_EXTENSION(MESA_texture_array, cap);
		937	if (!enable_texture(ctx, state, TEXTURE_2D_ARRAY_BIT)) {
		938	return;
		939	}
		940	break;
		941
		942	case GL_TEXTURE_CUBE_MAP_SEAMLESS:
		943	CHECK_EXTENSION(ARB_seamless_cube_map, cap);
		944	ctx->Texture.CubeMapSeamless = state;
		945	break;
		946
		947	#if FEATURE_EXT_transform_feedback
		948	case GL_RASTERIZER_DISCARD:
		949	CHECK_EXTENSION(EXT_transform_feedback, cap);
		950	if (ctx->TransformFeedback.RasterDiscard != state) {
		951	ctx->TransformFeedback.RasterDiscard = state;
		952	FLUSH_VERTICES(ctx, _NEW_TRANSFORM);
		953	}
		954	break;
		955	#endif
		956
		957	/* GL 3.1 primitive restart. Note: this enum is different from
		958	* GL_PRIMITIVE_RESTART_NV (which is client state).
		959	*/
		960	case GL_PRIMITIVE_RESTART:
		961	if (ctx->VersionMajor * 10 + ctx->VersionMinor < 31) {
		962	goto invalid_enum_error;
		963	}
		964	if (ctx->Array.PrimitiveRestart != state) {
		965	FLUSH_VERTICES(ctx, _NEW_TRANSFORM);
		966	ctx->Array.PrimitiveRestart = state;
		967	}
		968	break;
		969
		970	default:
		971	goto invalid_enum_error;
		972	}
		973
		974	if (ctx->Driver.Enable) {
		975	ctx->Driver.Enable( ctx, cap, state );
		976	}
		977
		978	return;
		979
		980	invalid_enum_error:
		981	_mesa_error(ctx, GL_INVALID_ENUM, "gl%s(0x%x)",
		982	state ? "Enable" : "Disable", cap);
		983	}
		984
		985
		986	/**
		987	* Enable GL capability. Called by glEnable()
		988	* \param cap state to enable.
		989	*/
		990	void GLAPIENTRY
		991	_mesa_Enable( GLenum cap )
		992	{
		993	GET_CURRENT_CONTEXT(ctx);
		994	ASSERT_OUTSIDE_BEGIN_END(ctx);
		995
		996	_mesa_set_enable( ctx, cap, GL_TRUE );
		997	}
		998
		999
		1000	/**
		1001	* Disable GL capability. Called by glDisable()
		1002	* \param cap state to disable.
		1003	*/
		1004	void GLAPIENTRY
		1005	_mesa_Disable( GLenum cap )
		1006	{
		1007	GET_CURRENT_CONTEXT(ctx);
		1008	ASSERT_OUTSIDE_BEGIN_END(ctx);
		1009
		1010	_mesa_set_enable( ctx, cap, GL_FALSE );
		1011	}
		1012
		1013
		1014
		1015	/**
		1016	* Enable/disable an indexed state var.
		1017	*/
		1018	void
		1019	_mesa_set_enablei(struct gl_context *ctx, GLenum cap, GLuint index, GLboolean state)
		1020	{
		1021	ASSERT(state == 0 \|\| state == 1);
		1022	switch (cap) {
		1023	case GL_BLEND:
		1024	if (!ctx->Extensions.EXT_draw_buffers2) {
		1025	goto invalid_enum_error;
		1026	}
		1027	if (index >= ctx->Const.MaxDrawBuffers) {
		1028	_mesa_error(ctx, GL_INVALID_VALUE, "%s(index=%u)",
		1029	state ? "glEnableIndexed" : "glDisableIndexed", index);
		1030	return;
		1031	}
		1032	if (((ctx->Color.BlendEnabled >> index) & 1) != state) {
		1033	FLUSH_VERTICES(ctx, _NEW_COLOR);
		1034	if (state)
		1035	ctx->Color.BlendEnabled \|= (1 << index);
		1036	else
		1037	ctx->Color.BlendEnabled &= ~(1 << index);
		1038	}
		1039	break;
		1040	default:
		1041	goto invalid_enum_error;
		1042	}
		1043	return;
		1044
		1045	invalid_enum_error:
		1046	_mesa_error(ctx, GL_INVALID_ENUM, "%s(cap=%s)",
		1047	state ? "glEnablei" : "glDisablei",
		1048	_mesa_lookup_enum_by_nr(cap));
		1049	}
		1050
		1051
		1052	void GLAPIENTRY
		1053	_mesa_DisableIndexed( GLenum cap, GLuint index )
		1054	{
		1055	GET_CURRENT_CONTEXT(ctx);
		1056	ASSERT_OUTSIDE_BEGIN_END(ctx);
		1057	_mesa_set_enablei(ctx, cap, index, GL_FALSE);
		1058	}
		1059
		1060
		1061	void GLAPIENTRY
		1062	_mesa_EnableIndexed( GLenum cap, GLuint index )
		1063	{
		1064	GET_CURRENT_CONTEXT(ctx);
		1065	ASSERT_OUTSIDE_BEGIN_END(ctx);
		1066	_mesa_set_enablei(ctx, cap, index, GL_TRUE);
		1067	}
		1068
		1069
		1070	GLboolean GLAPIENTRY
		1071	_mesa_IsEnabledIndexed( GLenum cap, GLuint index )
		1072	{
		1073	GET_CURRENT_CONTEXT(ctx);
		1074	switch (cap) {
		1075	case GL_BLEND:
		1076	if (index >= ctx->Const.MaxDrawBuffers) {
		1077	_mesa_error(ctx, GL_INVALID_VALUE, "glIsEnabledIndexed(index=%u)",
		1078	index);
		1079	return GL_FALSE;
		1080	}
		1081	return (ctx->Color.BlendEnabled >> index) & 1;
		1082	default:
		1083	_mesa_error(ctx, GL_INVALID_ENUM, "glIsEnabledIndexed(cap=%s)",
		1084	_mesa_lookup_enum_by_nr(cap));
		1085	return GL_FALSE;
		1086	}
		1087	}
		1088
		1089
		1090
		1091
		1092	#undef CHECK_EXTENSION
		1093	#define CHECK_EXTENSION(EXTNAME) \
		1094	if (!ctx->Extensions.EXTNAME) { \
		1095	goto invalid_enum_error; \
		1096	}
		1097
		1098	#undef CHECK_EXTENSION2
		1099	#define CHECK_EXTENSION2(EXT1, EXT2) \
		1100	if (!ctx->Extensions.EXT1 && !ctx->Extensions.EXT2) { \
		1101	goto invalid_enum_error; \
		1102	}
		1103
		1104
		1105	/**
		1106	* Helper function to determine whether a texture target is enabled.
		1107	*/
		1108	static GLboolean
		1109	is_texture_enabled(struct gl_context *ctx, GLbitfield bit)
		1110	{
		1111	const struct gl_texture_unit *const texUnit =
		1112	&ctx->Texture.Unit[ctx->Texture.CurrentUnit];
		1113	return (texUnit->Enabled & bit) ? GL_TRUE : GL_FALSE;
		1114	}
		1115
		1116
		1117	/**
		1118	* Return simple enable/disable state.
		1119	*
		1120	* \param cap state variable to query.
		1121	*
		1122	* Returns the state of the specified capability from the current GL context.
		1123	* For the capabilities associated with extensions verifies that those
		1124	* extensions are effectively present before reporting.
		1125	*/
		1126	GLboolean GLAPIENTRY
		1127	_mesa_IsEnabled( GLenum cap )
		1128	{
		1129	GET_CURRENT_CONTEXT(ctx);
		1130	switch (cap) {
		1131	case GL_ALPHA_TEST:
		1132	return ctx->Color.AlphaEnabled;
		1133	case GL_AUTO_NORMAL:
		1134	return ctx->Eval.AutoNormal;
		1135	case GL_BLEND:
		1136	return ctx->Color.BlendEnabled & 1; /* return state for buffer[0] */
		1137	case GL_CLIP_PLANE0:
		1138	case GL_CLIP_PLANE1:
		1139	case GL_CLIP_PLANE2:
		1140	case GL_CLIP_PLANE3:
		1141	case GL_CLIP_PLANE4:
		1142	case GL_CLIP_PLANE5:
		1143	return (ctx->Transform.ClipPlanesEnabled >> (cap - GL_CLIP_PLANE0)) & 1;
		1144	case GL_COLOR_MATERIAL:
		1145	return ctx->Light.ColorMaterialEnabled;
		1146	case GL_CULL_FACE:
		1147	return ctx->Polygon.CullFlag;
		1148	case GL_DEPTH_TEST:
		1149	return ctx->Depth.Test;
		1150	case GL_DITHER:
		1151	return ctx->Color.DitherFlag;
		1152	case GL_FOG:
		1153	return ctx->Fog.Enabled;
		1154	case GL_LIGHTING:
		1155	return ctx->Light.Enabled;
		1156	case GL_LIGHT0:
		1157	case GL_LIGHT1:
		1158	case GL_LIGHT2:
		1159	case GL_LIGHT3:
		1160	case GL_LIGHT4:
		1161	case GL_LIGHT5:
		1162	case GL_LIGHT6:
		1163	case GL_LIGHT7:
		1164	return ctx->Light.Light[cap-GL_LIGHT0].Enabled;
		1165	case GL_LINE_SMOOTH:
		1166	return ctx->Line.SmoothFlag;
		1167	case GL_LINE_STIPPLE:
		1168	return ctx->Line.StippleFlag;
		1169	case GL_INDEX_LOGIC_OP:
		1170	return ctx->Color.IndexLogicOpEnabled;
		1171	case GL_COLOR_LOGIC_OP:
		1172	return ctx->Color.ColorLogicOpEnabled;
		1173	case GL_MAP1_COLOR_4:
		1174	return ctx->Eval.Map1Color4;
		1175	case GL_MAP1_INDEX:
		1176	return ctx->Eval.Map1Index;
		1177	case GL_MAP1_NORMAL:
		1178	return ctx->Eval.Map1Normal;
		1179	case GL_MAP1_TEXTURE_COORD_1:
		1180	return ctx->Eval.Map1TextureCoord1;
		1181	case GL_MAP1_TEXTURE_COORD_2:
		1182	return ctx->Eval.Map1TextureCoord2;
		1183	case GL_MAP1_TEXTURE_COORD_3:
		1184	return ctx->Eval.Map1TextureCoord3;
		1185	case GL_MAP1_TEXTURE_COORD_4:
		1186	return ctx->Eval.Map1TextureCoord4;
		1187	case GL_MAP1_VERTEX_3:
		1188	return ctx->Eval.Map1Vertex3;
		1189	case GL_MAP1_VERTEX_4:
		1190	return ctx->Eval.Map1Vertex4;
		1191	case GL_MAP2_COLOR_4:
		1192	return ctx->Eval.Map2Color4;
		1193	case GL_MAP2_INDEX:
		1194	return ctx->Eval.Map2Index;
		1195	case GL_MAP2_NORMAL:
		1196	return ctx->Eval.Map2Normal;
		1197	case GL_MAP2_TEXTURE_COORD_1:
		1198	return ctx->Eval.Map2TextureCoord1;
		1199	case GL_MAP2_TEXTURE_COORD_2:
		1200	return ctx->Eval.Map2TextureCoord2;
		1201	case GL_MAP2_TEXTURE_COORD_3:
		1202	return ctx->Eval.Map2TextureCoord3;
		1203	case GL_MAP2_TEXTURE_COORD_4:
		1204	return ctx->Eval.Map2TextureCoord4;
		1205	case GL_MAP2_VERTEX_3:
		1206	return ctx->Eval.Map2Vertex3;
		1207	case GL_MAP2_VERTEX_4:
		1208	return ctx->Eval.Map2Vertex4;
		1209	case GL_NORMALIZE:
		1210	return ctx->Transform.Normalize;
		1211	case GL_POINT_SMOOTH:
		1212	return ctx->Point.SmoothFlag;
		1213	case GL_POLYGON_SMOOTH:
		1214	return ctx->Polygon.SmoothFlag;
		1215	case GL_POLYGON_STIPPLE:
		1216	return ctx->Polygon.StippleFlag;
		1217	case GL_POLYGON_OFFSET_POINT:
		1218	return ctx->Polygon.OffsetPoint;
		1219	case GL_POLYGON_OFFSET_LINE:
		1220	return ctx->Polygon.OffsetLine;
		1221	case GL_POLYGON_OFFSET_FILL:
		1222	/case GL_POLYGON_OFFSET_EXT:/
		1223	return ctx->Polygon.OffsetFill;
		1224	case GL_RESCALE_NORMAL_EXT:
		1225	return ctx->Transform.RescaleNormals;
		1226	case GL_SCISSOR_TEST:
		1227	return ctx->Scissor.Enabled;
		1228	case GL_SHARED_TEXTURE_PALETTE_EXT:
		1229	return ctx->Texture.SharedPalette;
		1230	case GL_STENCIL_TEST:
		1231	return ctx->Stencil.Enabled;
		1232	case GL_TEXTURE_1D:
		1233	return is_texture_enabled(ctx, TEXTURE_1D_BIT);
		1234	case GL_TEXTURE_2D:
		1235	return is_texture_enabled(ctx, TEXTURE_2D_BIT);
		1236	case GL_TEXTURE_3D:
		1237	return is_texture_enabled(ctx, TEXTURE_3D_BIT);
		1238	case GL_TEXTURE_GEN_Q:
		1239	{
		1240	const struct gl_texture_unit *texUnit = get_texcoord_unit(ctx);
		1241	if (texUnit) {
		1242	return (texUnit->TexGenEnabled & Q_BIT) ? GL_TRUE : GL_FALSE;
		1243	}
		1244	}
		1245	return GL_FALSE;
		1246	case GL_TEXTURE_GEN_R:
		1247	{
		1248	const struct gl_texture_unit *texUnit = get_texcoord_unit(ctx);
		1249	if (texUnit) {
		1250	return (texUnit->TexGenEnabled & R_BIT) ? GL_TRUE : GL_FALSE;
		1251	}
		1252	}
		1253	return GL_FALSE;
		1254	case GL_TEXTURE_GEN_S:
		1255	{
		1256	const struct gl_texture_unit *texUnit = get_texcoord_unit(ctx);
		1257	if (texUnit) {
		1258	return (texUnit->TexGenEnabled & S_BIT) ? GL_TRUE : GL_FALSE;
		1259	}
		1260	}
		1261	return GL_FALSE;
		1262	case GL_TEXTURE_GEN_T:
		1263	{
		1264	const struct gl_texture_unit *texUnit = get_texcoord_unit(ctx);
		1265	if (texUnit) {
		1266	return (texUnit->TexGenEnabled & T_BIT) ? GL_TRUE : GL_FALSE;
		1267	}
		1268	}
		1269	return GL_FALSE;
		1270	#if FEATURE_ES1
		1271	case GL_TEXTURE_GEN_STR_OES:
		1272	{
		1273	const struct gl_texture_unit *texUnit = get_texcoord_unit(ctx);
		1274	if (texUnit) {
		1275	return (texUnit->TexGenEnabled & STR_BITS) == STR_BITS ? GL_TRUE : GL_FALSE;
		1276	}
		1277	}
		1278	#endif
		1279
		1280	/*
		1281	* CLIENT STATE!!!
		1282	*/
		1283	case GL_VERTEX_ARRAY:
		1284	return (ctx->Array.ArrayObj->Vertex.Enabled != 0);
		1285	case GL_NORMAL_ARRAY:
		1286	return (ctx->Array.ArrayObj->Normal.Enabled != 0);
		1287	case GL_COLOR_ARRAY:
		1288	return (ctx->Array.ArrayObj->Color.Enabled != 0);
		1289	case GL_INDEX_ARRAY:
		1290	return (ctx->Array.ArrayObj->Index.Enabled != 0);
		1291	case GL_TEXTURE_COORD_ARRAY:
		1292	return (ctx->Array.ArrayObj->TexCoord[ctx->Array.ActiveTexture].Enabled != 0);
		1293	case GL_EDGE_FLAG_ARRAY:
		1294	return (ctx->Array.ArrayObj->EdgeFlag.Enabled != 0);
		1295	case GL_FOG_COORDINATE_ARRAY_EXT:
		1296	CHECK_EXTENSION(EXT_fog_coord);
		1297	return (ctx->Array.ArrayObj->FogCoord.Enabled != 0);
		1298	case GL_SECONDARY_COLOR_ARRAY_EXT:
		1299	CHECK_EXTENSION(EXT_secondary_color);
		1300	return (ctx->Array.ArrayObj->SecondaryColor.Enabled != 0);
		1301	#if FEATURE_point_size_array
		1302	case GL_POINT_SIZE_ARRAY_OES:
		1303	return (ctx->Array.ArrayObj->PointSize.Enabled != 0);
		1304	#endif
		1305
		1306	/* GL_SGI_texture_color_table */
		1307	case GL_TEXTURE_COLOR_TABLE_SGI:
		1308	CHECK_EXTENSION(SGI_texture_color_table);
		1309	return ctx->Texture.Unit[ctx->Texture.CurrentUnit].ColorTableEnabled;
		1310
		1311	/* GL_ARB_texture_cube_map */
		1312	case GL_TEXTURE_CUBE_MAP_ARB:
		1313	CHECK_EXTENSION(ARB_texture_cube_map);
		1314	return is_texture_enabled(ctx, TEXTURE_CUBE_BIT);
		1315
		1316	/* GL_EXT_secondary_color */
		1317	case GL_COLOR_SUM_EXT:
		1318	CHECK_EXTENSION2(EXT_secondary_color, ARB_vertex_program);
		1319	return ctx->Fog.ColorSumEnabled;
		1320
		1321	/* GL_ARB_multisample */
		1322	case GL_MULTISAMPLE_ARB:
		1323	return ctx->Multisample.Enabled;
		1324	case GL_SAMPLE_ALPHA_TO_COVERAGE_ARB:
		1325	return ctx->Multisample.SampleAlphaToCoverage;
		1326	case GL_SAMPLE_ALPHA_TO_ONE_ARB:
		1327	return ctx->Multisample.SampleAlphaToOne;
		1328	case GL_SAMPLE_COVERAGE_ARB:
		1329	return ctx->Multisample.SampleCoverage;
		1330	case GL_SAMPLE_COVERAGE_INVERT_ARB:
		1331	return ctx->Multisample.SampleCoverageInvert;
		1332
		1333	/* GL_IBM_rasterpos_clip */
		1334	case GL_RASTER_POSITION_UNCLIPPED_IBM:
		1335	CHECK_EXTENSION(IBM_rasterpos_clip);
		1336	return ctx->Transform.RasterPositionUnclipped;
		1337
		1338	/* GL_NV_point_sprite */
		1339	case GL_POINT_SPRITE_NV:
		1340	CHECK_EXTENSION2(NV_point_sprite, ARB_point_sprite)
		1341	return ctx->Point.PointSprite;
		1342
		1343	#if FEATURE_NV_vertex_program \|\| FEATURE_ARB_vertex_program
		1344	case GL_VERTEX_PROGRAM_ARB:
		1345	CHECK_EXTENSION2(ARB_vertex_program, NV_vertex_program);
		1346	return ctx->VertexProgram.Enabled;
		1347	case GL_VERTEX_PROGRAM_POINT_SIZE_ARB:
		1348	CHECK_EXTENSION2(ARB_vertex_program, NV_vertex_program);
		1349	return ctx->VertexProgram.PointSizeEnabled;
		1350	case GL_VERTEX_PROGRAM_TWO_SIDE_ARB:
		1351	CHECK_EXTENSION2(ARB_vertex_program, NV_vertex_program);
		1352	return ctx->VertexProgram.TwoSideEnabled;
		1353	#endif
		1354	#if FEATURE_NV_vertex_program
		1355	case GL_VERTEX_ATTRIB_ARRAY0_NV:
		1356	case GL_VERTEX_ATTRIB_ARRAY1_NV:
		1357	case GL_VERTEX_ATTRIB_ARRAY2_NV:
		1358	case GL_VERTEX_ATTRIB_ARRAY3_NV:
		1359	case GL_VERTEX_ATTRIB_ARRAY4_NV:
		1360	case GL_VERTEX_ATTRIB_ARRAY5_NV:
		1361	case GL_VERTEX_ATTRIB_ARRAY6_NV:
		1362	case GL_VERTEX_ATTRIB_ARRAY7_NV:
		1363	case GL_VERTEX_ATTRIB_ARRAY8_NV:
		1364	case GL_VERTEX_ATTRIB_ARRAY9_NV:
		1365	case GL_VERTEX_ATTRIB_ARRAY10_NV:
		1366	case GL_VERTEX_ATTRIB_ARRAY11_NV:
		1367	case GL_VERTEX_ATTRIB_ARRAY12_NV:
		1368	case GL_VERTEX_ATTRIB_ARRAY13_NV:
		1369	case GL_VERTEX_ATTRIB_ARRAY14_NV:
		1370	case GL_VERTEX_ATTRIB_ARRAY15_NV:
		1371	CHECK_EXTENSION(NV_vertex_program);
		1372	{
		1373	GLint n = (GLint) cap - GL_VERTEX_ATTRIB_ARRAY0_NV;
		1374	ASSERT(n < Elements(ctx->Array.ArrayObj->VertexAttrib));
		1375	return (ctx->Array.ArrayObj->VertexAttrib[n].Enabled != 0);
		1376	}
		1377	case GL_MAP1_VERTEX_ATTRIB0_4_NV:
		1378	case GL_MAP1_VERTEX_ATTRIB1_4_NV:
		1379	case GL_MAP1_VERTEX_ATTRIB2_4_NV:
		1380	case GL_MAP1_VERTEX_ATTRIB3_4_NV:
		1381	case GL_MAP1_VERTEX_ATTRIB4_4_NV:
		1382	case GL_MAP1_VERTEX_ATTRIB5_4_NV:
		1383	case GL_MAP1_VERTEX_ATTRIB6_4_NV:
		1384	case GL_MAP1_VERTEX_ATTRIB7_4_NV:
		1385	case GL_MAP1_VERTEX_ATTRIB8_4_NV:
		1386	case GL_MAP1_VERTEX_ATTRIB9_4_NV:
		1387	case GL_MAP1_VERTEX_ATTRIB10_4_NV:
		1388	case GL_MAP1_VERTEX_ATTRIB11_4_NV:
		1389	case GL_MAP1_VERTEX_ATTRIB12_4_NV:
		1390	case GL_MAP1_VERTEX_ATTRIB13_4_NV:
		1391	case GL_MAP1_VERTEX_ATTRIB14_4_NV:
		1392	case GL_MAP1_VERTEX_ATTRIB15_4_NV:
		1393	CHECK_EXTENSION(NV_vertex_program);
		1394	{
		1395	const GLuint map = (GLuint) (cap - GL_MAP1_VERTEX_ATTRIB0_4_NV);
		1396	return ctx->Eval.Map1Attrib[map];
		1397	}
		1398	case GL_MAP2_VERTEX_ATTRIB0_4_NV:
		1399	case GL_MAP2_VERTEX_ATTRIB1_4_NV:
		1400	case GL_MAP2_VERTEX_ATTRIB2_4_NV:
		1401	case GL_MAP2_VERTEX_ATTRIB3_4_NV:
		1402	case GL_MAP2_VERTEX_ATTRIB4_4_NV:
		1403	case GL_MAP2_VERTEX_ATTRIB5_4_NV:
		1404	case GL_MAP2_VERTEX_ATTRIB6_4_NV:
		1405	case GL_MAP2_VERTEX_ATTRIB7_4_NV:
		1406	case GL_MAP2_VERTEX_ATTRIB8_4_NV:
		1407	case GL_MAP2_VERTEX_ATTRIB9_4_NV:
		1408	case GL_MAP2_VERTEX_ATTRIB10_4_NV:
		1409	case GL_MAP2_VERTEX_ATTRIB11_4_NV:
		1410	case GL_MAP2_VERTEX_ATTRIB12_4_NV:
		1411	case GL_MAP2_VERTEX_ATTRIB13_4_NV:
		1412	case GL_MAP2_VERTEX_ATTRIB14_4_NV:
		1413	case GL_MAP2_VERTEX_ATTRIB15_4_NV:
		1414	CHECK_EXTENSION(NV_vertex_program);
		1415	{
		1416	const GLuint map = (GLuint) (cap - GL_MAP2_VERTEX_ATTRIB0_4_NV);
		1417	return ctx->Eval.Map2Attrib[map];
		1418	}
		1419	#endif /* FEATURE_NV_vertex_program */
		1420
		1421	#if FEATURE_NV_fragment_program
		1422	case GL_FRAGMENT_PROGRAM_NV:
		1423	CHECK_EXTENSION(NV_fragment_program);
		1424	return ctx->FragmentProgram.Enabled;
		1425	#endif /* FEATURE_NV_fragment_program */
		1426
		1427	/* GL_NV_texture_rectangle */
		1428	case GL_TEXTURE_RECTANGLE_NV:
		1429	CHECK_EXTENSION(NV_texture_rectangle);
		1430	return is_texture_enabled(ctx, TEXTURE_RECT_BIT);
		1431
		1432	/* GL_EXT_stencil_two_side */
		1433	case GL_STENCIL_TEST_TWO_SIDE_EXT:
		1434	CHECK_EXTENSION(EXT_stencil_two_side);
		1435	return ctx->Stencil.TestTwoSide;
		1436
		1437	#if FEATURE_ARB_fragment_program
		1438	case GL_FRAGMENT_PROGRAM_ARB:
		1439	return ctx->FragmentProgram.Enabled;
		1440	#endif /* FEATURE_ARB_fragment_program */
		1441
		1442	/* GL_EXT_depth_bounds_test */
		1443	case GL_DEPTH_BOUNDS_TEST_EXT:
		1444	CHECK_EXTENSION(EXT_depth_bounds_test);
		1445	return ctx->Depth.BoundsTest;
		1446
		1447	/* GL_ARB_depth_clamp */
		1448	case GL_DEPTH_CLAMP:
		1449	CHECK_EXTENSION(ARB_depth_clamp);
		1450	return ctx->Transform.DepthClamp;
		1451
		1452	#if FEATURE_ATI_fragment_shader
		1453	case GL_FRAGMENT_SHADER_ATI:
		1454	CHECK_EXTENSION(ATI_fragment_shader);
		1455	return ctx->ATIFragmentShader.Enabled;
		1456	#endif /* FEATURE_ATI_fragment_shader */
		1457
		1458	case GL_TEXTURE_CUBE_MAP_SEAMLESS:
		1459	CHECK_EXTENSION(ARB_seamless_cube_map);
		1460	return ctx->Texture.CubeMapSeamless;
		1461
		1462	#if FEATURE_EXT_transform_feedback
		1463	case GL_RASTERIZER_DISCARD:
		1464	CHECK_EXTENSION(EXT_transform_feedback);
		1465	return ctx->TransformFeedback.RasterDiscard;
		1466	#endif
		1467
		1468	/* GL_NV_primitive_restart */
		1469	case GL_PRIMITIVE_RESTART_NV:
		1470	if (!ctx->Extensions.NV_primitive_restart) {
		1471	goto invalid_enum_error;
		1472	}
		1473	return ctx->Array.PrimitiveRestart;
		1474
		1475	/* GL 3.1 primitive restart */
		1476	case GL_PRIMITIVE_RESTART:
		1477	if (ctx->VersionMajor * 10 + ctx->VersionMinor < 31) {
		1478	goto invalid_enum_error;
		1479	}
		1480	return ctx->Array.PrimitiveRestart;
		1481
		1482	default:
		1483	goto invalid_enum_error;
		1484	}
		1485
		1486	return GL_FALSE;
		1487
		1488	invalid_enum_error:
		1489	_mesa_error(ctx, GL_INVALID_ENUM, "glIsEnabled(0x%x)", (int) cap);
		1490	return GL_FALSE;
		1491	}

Subversion Repositories Kolibri OS

(root)/programs/develop/libraries/Mesa/src/mesa/main/enable.c – Rev 4248