WebSVN - shark - Blame - Rev 55 - /shark/trunk/ports/mesa/src/texstate.c

Rev	Author	Line No.	Line
55	pj	1	/* $Id: texstate.c,v 1.1 2003-02-28 11:42:05 pj Exp $ */
		2
		3	/*
		4	* Mesa 3-D graphics library
		5	* Version: 5.0
		6	*
		7	* Copyright (C) 1999-2002 Brian Paul All Rights Reserved.
		8	*
		9	* Permission is hereby granted, free of charge, to any person obtaining a
		10	* copy of this software and associated documentation files (the "Software"),
		11	* to deal in the Software without restriction, including without limitation
		12	* the rights to use, copy, modify, merge, publish, distribute, sublicense,
		13	* and/or sell copies of the Software, and to permit persons to whom the
		14	* Software is furnished to do so, subject to the following conditions:
		15	*
		16	* The above copyright notice and this permission notice shall be included
		17	* in all copies or substantial portions of the Software.
		18	*
		19	* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
		20	* OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
		21	* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
		22	* BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
		23	* AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
		24	* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
		25	*/
		26
		27
		28	#include "glheader.h"
		29	#include "colormac.h"
		30	#include "context.h"
		31	#include "enums.h"
		32	#include "extensions.h"
		33	#include "macros.h"
		34	#include "texobj.h"
		35	#include "teximage.h"
		36	#include "texstate.h"
		37	#include "mtypes.h"
		38	#include "math/m_xform.h"
		39	#include "math/m_matrix.h"
		40
		41
		42
		43	#ifdef SPECIALCAST
		44	/* Needed for an Amiga compiler */
		45	#define ENUM_TO_FLOAT(X) ((GLfloat)(GLint)(X))
		46	#define ENUM_TO_DOUBLE(X) ((GLdouble)(GLint)(X))
		47	#else
		48	/* all other compilers */
		49	#define ENUM_TO_FLOAT(X) ((GLfloat)(X))
		50	#define ENUM_TO_DOUBLE(X) ((GLdouble)(X))
		51	#endif
		52
		53
		54
		55	void
		56	_mesa_copy_texture_state( const GLcontext src, GLcontext dst )
		57	{
		58	GLuint i;
		59
		60	ASSERT(src);
		61	ASSERT(dst);
		62
		63	dst->Texture.CurrentUnit = src->Texture.CurrentUnit;
		64	dst->Texture._GenFlags = src->Texture._GenFlags;
		65	dst->Texture._TexGenEnabled = src->Texture._TexGenEnabled;
		66	dst->Texture._TexMatEnabled = src->Texture._TexMatEnabled;
		67	dst->Texture.SharedPalette = src->Texture.SharedPalette;
		68
		69	/* per-unit state */
		70	for (i = 0; i < src->Const.MaxTextureUnits; i++) {
		71	dst->Texture.Unit[i].Enabled = src->Texture.Unit[i].Enabled;
		72	dst->Texture.Unit[i].EnvMode = src->Texture.Unit[i].EnvMode;
		73	COPY_4V(dst->Texture.Unit[i].EnvColor, src->Texture.Unit[i].EnvColor);
		74	dst->Texture.Unit[i].TexGenEnabled = src->Texture.Unit[i].TexGenEnabled;
		75	dst->Texture.Unit[i].GenModeS = src->Texture.Unit[i].GenModeS;
		76	dst->Texture.Unit[i].GenModeT = src->Texture.Unit[i].GenModeT;
		77	dst->Texture.Unit[i].GenModeR = src->Texture.Unit[i].GenModeR;
		78	dst->Texture.Unit[i].GenModeQ = src->Texture.Unit[i].GenModeQ;
		79	dst->Texture.Unit[i]._GenBitS = src->Texture.Unit[i]._GenBitS;
		80	dst->Texture.Unit[i]._GenBitT = src->Texture.Unit[i]._GenBitT;
		81	dst->Texture.Unit[i]._GenBitR = src->Texture.Unit[i]._GenBitR;
		82	dst->Texture.Unit[i]._GenBitQ = src->Texture.Unit[i]._GenBitQ;
		83	dst->Texture.Unit[i]._GenFlags = src->Texture.Unit[i]._GenFlags;
		84	COPY_4V(dst->Texture.Unit[i].ObjectPlaneS, src->Texture.Unit[i].ObjectPlaneS);
		85	COPY_4V(dst->Texture.Unit[i].ObjectPlaneT, src->Texture.Unit[i].ObjectPlaneT);
		86	COPY_4V(dst->Texture.Unit[i].ObjectPlaneR, src->Texture.Unit[i].ObjectPlaneR);
		87	COPY_4V(dst->Texture.Unit[i].ObjectPlaneQ, src->Texture.Unit[i].ObjectPlaneQ);
		88	COPY_4V(dst->Texture.Unit[i].EyePlaneS, src->Texture.Unit[i].EyePlaneS);
		89	COPY_4V(dst->Texture.Unit[i].EyePlaneT, src->Texture.Unit[i].EyePlaneT);
		90	COPY_4V(dst->Texture.Unit[i].EyePlaneR, src->Texture.Unit[i].EyePlaneR);
		91	COPY_4V(dst->Texture.Unit[i].EyePlaneQ, src->Texture.Unit[i].EyePlaneQ);
		92	dst->Texture.Unit[i].LodBias = src->Texture.Unit[i].LodBias;
		93
		94	/* GL_EXT_texture_env_combine */
		95	dst->Texture.Unit[i].CombineModeRGB = src->Texture.Unit[i].CombineModeRGB;
		96	dst->Texture.Unit[i].CombineModeA = src->Texture.Unit[i].CombineModeA;
		97	COPY_3V(dst->Texture.Unit[i].CombineSourceRGB, src->Texture.Unit[i].CombineSourceRGB);
		98	COPY_3V(dst->Texture.Unit[i].CombineSourceA, src->Texture.Unit[i].CombineSourceA);
		99	COPY_3V(dst->Texture.Unit[i].CombineOperandRGB, src->Texture.Unit[i].CombineOperandRGB);
		100	COPY_3V(dst->Texture.Unit[i].CombineOperandA, src->Texture.Unit[i].CombineOperandA);
		101	dst->Texture.Unit[i].CombineScaleShiftRGB = src->Texture.Unit[i].CombineScaleShiftRGB;
		102	dst->Texture.Unit[i].CombineScaleShiftA = src->Texture.Unit[i].CombineScaleShiftA;
		103
		104	/* texture object state */
		105	_mesa_copy_texture_object(dst->Texture.Unit[i].Current1D,
		106	src->Texture.Unit[i].Current1D);
		107	_mesa_copy_texture_object(dst->Texture.Unit[i].Current2D,
		108	src->Texture.Unit[i].Current2D);
		109	_mesa_copy_texture_object(dst->Texture.Unit[i].Current3D,
		110	src->Texture.Unit[i].Current3D);
		111	_mesa_copy_texture_object(dst->Texture.Unit[i].CurrentCubeMap,
		112	src->Texture.Unit[i].CurrentCubeMap);
		113	_mesa_copy_texture_object(dst->Texture.Unit[i].CurrentRect,
		114	src->Texture.Unit[i].CurrentRect);
		115	}
		116	}
		117
		118
		119	/**********************************************************************/
		120	/* Texture Environment */
		121	/**********************************************************************/
		122
		123
		124	void
		125	_mesa_TexEnvfv( GLenum target, GLenum pname, const GLfloat *param )
		126	{
		127	GET_CURRENT_CONTEXT(ctx);
		128	struct gl_texture_unit *texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
		129	ASSERT_OUTSIDE_BEGIN_END(ctx);
		130
		131	#define TE_ERROR(errCode, msg, value) \
		132	_mesa_error(ctx, errCode, msg, _mesa_lookup_enum_by_nr(value));
		133
		134	if (target == GL_TEXTURE_ENV) {
		135	switch (pname) {
		136	case GL_TEXTURE_ENV_MODE:
		137	{
		138	const GLenum mode = (GLenum) (GLint) *param;
		139	if (mode == GL_MODULATE \|\|
		140	mode == GL_BLEND \|\|
		141	mode == GL_DECAL \|\|
		142	mode == GL_REPLACE \|\|
		143	(mode == GL_ADD && ctx->Extensions.EXT_texture_env_add) \|\|
		144	(mode == GL_COMBINE_EXT &&
		145	(ctx->Extensions.EXT_texture_env_combine \|\|
		146	ctx->Extensions.ARB_texture_env_combine))) {
		147	/* legal */
		148	if (texUnit->EnvMode == mode)
		149	return;
		150	FLUSH_VERTICES(ctx, _NEW_TEXTURE);
		151	texUnit->EnvMode = mode;
		152	}
		153	else {
		154	TE_ERROR(GL_INVALID_ENUM, "glTexEnv(param=%s)", mode);
		155	return;
		156	}
		157	}
		158	break;
		159	case GL_TEXTURE_ENV_COLOR:
		160	{
		161	GLfloat tmp[4];
		162	tmp[0] = CLAMP( param[0], 0.0F, 1.0F );
		163	tmp[1] = CLAMP( param[1], 0.0F, 1.0F );
		164	tmp[2] = CLAMP( param[2], 0.0F, 1.0F );
		165	tmp[3] = CLAMP( param[3], 0.0F, 1.0F );
		166	if (TEST_EQ_4V(tmp, texUnit->EnvColor))
		167	return;
		168	FLUSH_VERTICES(ctx, _NEW_TEXTURE);
		169	COPY_4FV(texUnit->EnvColor, tmp);
		170	}
		171	break;
		172	case GL_COMBINE_RGB_EXT:
		173	if (ctx->Extensions.EXT_texture_env_combine \|\|
		174	ctx->Extensions.ARB_texture_env_combine) {
		175	const GLenum mode = (GLenum) (GLint) *param;
		176	switch (mode) {
		177	case GL_REPLACE:
		178	case GL_MODULATE:
		179	case GL_ADD:
		180	case GL_ADD_SIGNED_EXT:
		181	case GL_INTERPOLATE_EXT:
		182	/* OK */
		183	break;
		184	case GL_SUBTRACT_ARB:
		185	if (!ctx->Extensions.ARB_texture_env_combine) {
		186	TE_ERROR(GL_INVALID_ENUM, "glTexEnv(param=%s)", mode);
		187	return;
		188	}
		189	break;
		190	case GL_DOT3_RGB_EXT:
		191	case GL_DOT3_RGBA_EXT:
		192	if (!ctx->Extensions.EXT_texture_env_dot3) {
		193	TE_ERROR(GL_INVALID_ENUM, "glTexEnv(param=%s)", mode);
		194	return;
		195	}
		196	break;
		197	case GL_DOT3_RGB_ARB:
		198	case GL_DOT3_RGBA_ARB:
		199	if (!ctx->Extensions.ARB_texture_env_dot3) {
		200	TE_ERROR(GL_INVALID_ENUM, "glTexEnv(param=%s)", mode);
		201	return;
		202	}
		203	break;
		204	default:
		205	TE_ERROR(GL_INVALID_ENUM, "glTexEnv(param=%s)", mode);
		206	return;
		207	}
		208	if (texUnit->CombineModeRGB == mode)
		209	return;
		210	FLUSH_VERTICES(ctx, _NEW_TEXTURE);
		211	texUnit->CombineModeRGB = mode;
		212	}
		213	else {
		214	TE_ERROR(GL_INVALID_ENUM, "glTexEnv(pname=%s)", pname);
		215	return;
		216	}
		217	break;
		218	case GL_COMBINE_ALPHA_EXT:
		219	if (ctx->Extensions.EXT_texture_env_combine \|\|
		220	ctx->Extensions.ARB_texture_env_combine) {
		221	const GLenum mode = (GLenum) (GLint) *param;
		222	if (mode == GL_REPLACE \|\|
		223	mode == GL_MODULATE \|\|
		224	mode == GL_ADD \|\|
		225	mode == GL_ADD_SIGNED_EXT \|\|
		226	mode == GL_INTERPOLATE_EXT \|\|
		227	(mode == GL_SUBTRACT_ARB &&
		228	ctx->Extensions.ARB_texture_env_combine)) {
		229	/* legal */
		230	if (texUnit->CombineModeA == mode)
		231	return;
		232	FLUSH_VERTICES(ctx, _NEW_TEXTURE);
		233	texUnit->CombineModeA = mode;
		234	}
		235	else {
		236	TE_ERROR(GL_INVALID_ENUM, "glTexEnv(param=%s)", mode);
		237	return;
		238	}
		239	}
		240	else {
		241	TE_ERROR(GL_INVALID_ENUM, "glTexEnv(pname=%s)", pname);
		242	return;
		243	}
		244	break;
		245	case GL_SOURCE0_RGB_EXT:
		246	case GL_SOURCE1_RGB_EXT:
		247	case GL_SOURCE2_RGB_EXT:
		248	if (ctx->Extensions.EXT_texture_env_combine \|\|
		249	ctx->Extensions.ARB_texture_env_combine) {
		250	const GLenum source = (GLenum) (GLint) *param;
		251	const GLuint s = pname - GL_SOURCE0_RGB_EXT;
		252	if (source == GL_TEXTURE \|\|
		253	source == GL_CONSTANT_EXT \|\|
		254	source == GL_PRIMARY_COLOR_EXT \|\|
		255	source == GL_PREVIOUS_EXT \|\|
		256	(ctx->Extensions.ARB_texture_env_crossbar &&
		257	source >= GL_TEXTURE0_ARB &&
		258	source < GL_TEXTURE0_ARB + ctx->Const.MaxTextureUnits)) {
		259	/* legal */
		260	if (texUnit->CombineSourceRGB[s] == source)
		261	return;
		262	FLUSH_VERTICES(ctx, _NEW_TEXTURE);
		263	texUnit->CombineSourceRGB[s] = source;
		264	}
		265	else {
		266	TE_ERROR(GL_INVALID_ENUM, "glTexEnv(param=%s)", source);
		267	return;
		268	}
		269	}
		270	else {
		271	TE_ERROR(GL_INVALID_ENUM, "glTexEnv(pname=%s)", pname);
		272	return;
		273	}
		274	break;
		275	case GL_SOURCE0_ALPHA_EXT:
		276	case GL_SOURCE1_ALPHA_EXT:
		277	case GL_SOURCE2_ALPHA_EXT:
		278	if (ctx->Extensions.EXT_texture_env_combine \|\|
		279	ctx->Extensions.ARB_texture_env_combine) {
		280	const GLenum source = (GLenum) (GLint) *param;
		281	const GLuint s = pname - GL_SOURCE0_ALPHA_EXT;
		282	if (source == GL_TEXTURE \|\|
		283	source == GL_CONSTANT_EXT \|\|
		284	source == GL_PRIMARY_COLOR_EXT \|\|
		285	source == GL_PREVIOUS_EXT \|\|
		286	(ctx->Extensions.ARB_texture_env_crossbar &&
		287	source >= GL_TEXTURE0_ARB &&
		288	source < GL_TEXTURE0_ARB + ctx->Const.MaxTextureUnits)) {
		289	/* legal */
		290	if (texUnit->CombineSourceA[s] == source)
		291	return;
		292	FLUSH_VERTICES(ctx, _NEW_TEXTURE);
		293	texUnit->CombineSourceA[s] = source;
		294	}
		295	else {
		296	TE_ERROR(GL_INVALID_ENUM, "glTexEnv(param=%s)", source);
		297	return;
		298	}
		299	}
		300	else {
		301	TE_ERROR(GL_INVALID_ENUM, "glTexEnv(pname=%s)", pname);
		302	return;
		303	}
		304	break;
		305	case GL_OPERAND0_RGB_EXT:
		306	case GL_OPERAND1_RGB_EXT:
		307	if (ctx->Extensions.EXT_texture_env_combine \|\|
		308	ctx->Extensions.ARB_texture_env_combine) {
		309	const GLenum operand = (GLenum) (GLint) *param;
		310	const GLuint s = pname - GL_OPERAND0_RGB_EXT;
		311	switch (operand) {
		312	case GL_SRC_COLOR:
		313	case GL_ONE_MINUS_SRC_COLOR:
		314	case GL_SRC_ALPHA:
		315	case GL_ONE_MINUS_SRC_ALPHA:
		316	if (texUnit->CombineOperandRGB[s] == operand)
		317	return;
		318	FLUSH_VERTICES(ctx, _NEW_TEXTURE);
		319	texUnit->CombineOperandRGB[s] = operand;
		320	break;
		321	default:
		322	TE_ERROR(GL_INVALID_ENUM, "glTexEnv(param=%s)", operand);
		323	return;
		324	}
		325	}
		326	else {
		327	TE_ERROR(GL_INVALID_ENUM, "glTexEnv(pname=%s)", pname);
		328	return;
		329	}
		330	break;
		331	case GL_OPERAND0_ALPHA_EXT:
		332	case GL_OPERAND1_ALPHA_EXT:
		333	if (ctx->Extensions.EXT_texture_env_combine \|\|
		334	ctx->Extensions.ARB_texture_env_combine) {
		335	const GLenum operand = (GLenum) (GLint) *param;
		336	switch (operand) {
		337	case GL_SRC_ALPHA:
		338	case GL_ONE_MINUS_SRC_ALPHA:
		339	if (texUnit->CombineOperandA[pname-GL_OPERAND0_ALPHA_EXT] ==
		340	operand)
		341	return;
		342	FLUSH_VERTICES(ctx, _NEW_TEXTURE);
		343	texUnit->CombineOperandA[pname-GL_OPERAND0_ALPHA_EXT] = operand;
		344	break;
		345	default:
		346	TE_ERROR(GL_INVALID_ENUM, "glTexEnv(param=%s)", operand);
		347	return;
		348	}
		349	}
		350	else {
		351	TE_ERROR(GL_INVALID_ENUM, "glTexEnv(pname=%s)", pname);
		352	return;
		353	}
		354	break;
		355	case GL_OPERAND2_RGB_EXT:
		356	if (ctx->Extensions.EXT_texture_env_combine \|\|
		357	ctx->Extensions.ARB_texture_env_combine) {
		358	const GLenum operand = (GLenum) (GLint) *param;
		359	switch (operand) {
		360	case GL_SRC_COLOR: /* ARB combine only */
		361	case GL_ONE_MINUS_SRC_COLOR: /* ARB combine only */
		362	case GL_SRC_ALPHA:
		363	case GL_ONE_MINUS_SRC_ALPHA: /* ARB combine only */
		364	if (texUnit->CombineOperandRGB[2] == operand)
		365	return;
		366	FLUSH_VERTICES(ctx, _NEW_TEXTURE);
		367	texUnit->CombineOperandRGB[2] = operand;
		368	default:
		369	TE_ERROR(GL_INVALID_ENUM, "glTexEnv(param=%s)", operand);
		370	return;
		371	}
		372	}
		373	else {
		374	TE_ERROR(GL_INVALID_ENUM, "glTexEnv(pname=%s)", pname);
		375	return;
		376	}
		377	break;
		378	case GL_OPERAND2_ALPHA_EXT:
		379	if (ctx->Extensions.EXT_texture_env_combine \|\|
		380	ctx->Extensions.ARB_texture_env_combine) {
		381	const GLenum operand = (GLenum) (GLint) *param;
		382	switch (operand) {
		383	case GL_SRC_ALPHA:
		384	case GL_ONE_MINUS_SRC_ALPHA: /* ARB combine only */
		385	if (texUnit->CombineOperandA[2] == operand)
		386	return;
		387	FLUSH_VERTICES(ctx, _NEW_TEXTURE);
		388	texUnit->CombineOperandA[2] = operand;
		389	break;
		390	default:
		391	TE_ERROR(GL_INVALID_ENUM, "glTexEnv(param=%s)", operand);
		392	return;
		393	}
		394	}
		395	else {
		396	TE_ERROR(GL_INVALID_ENUM, "glTexEnv(pname=%s)", pname);
		397	return;
		398	}
		399	break;
		400	case GL_RGB_SCALE_EXT:
		401	if (ctx->Extensions.EXT_texture_env_combine \|\|
		402	ctx->Extensions.ARB_texture_env_combine) {
		403	GLuint newshift;
		404	if (*param == 1.0) {
		405	newshift = 0;
		406	}
		407	else if (*param == 2.0) {
		408	newshift = 1;
		409	}
		410	else if (*param == 4.0) {
		411	newshift = 2;
		412	}
		413	else {
		414	_mesa_error( ctx, GL_INVALID_VALUE,
		415	"glTexEnv(GL_RGB_SCALE not 1, 2 or 4)" );
		416	return;
		417	}
		418	if (texUnit->CombineScaleShiftRGB == newshift)
		419	return;
		420	FLUSH_VERTICES(ctx, _NEW_TEXTURE);
		421	texUnit->CombineScaleShiftRGB = newshift;
		422	}
		423	else {
		424	TE_ERROR(GL_INVALID_ENUM, "glTexEnv(pname=%s)", pname);
		425	return;
		426	}
		427	break;
		428	case GL_ALPHA_SCALE:
		429	if (ctx->Extensions.EXT_texture_env_combine \|\|
		430	ctx->Extensions.ARB_texture_env_combine) {
		431	GLuint newshift;
		432	if (*param == 1.0) {
		433	newshift = 0;
		434	}
		435	else if (*param == 2.0) {
		436	newshift = 1;
		437	}
		438	else if (*param == 4.0) {
		439	newshift = 2;
		440	}
		441	else {
		442	_mesa_error( ctx, GL_INVALID_VALUE,
		443	"glTexEnv(GL_ALPHA_SCALE not 1, 2 or 4)" );
		444	return;
		445	}
		446	if (texUnit->CombineScaleShiftA == newshift)
		447	return;
		448	FLUSH_VERTICES(ctx, _NEW_TEXTURE);
		449	texUnit->CombineScaleShiftA = newshift;
		450	}
		451	else {
		452	TE_ERROR(GL_INVALID_ENUM, "glTexEnv(pname=%s)", pname);
		453	return;
		454	}
		455	break;
		456	default:
		457	_mesa_error( ctx, GL_INVALID_ENUM, "glTexEnv(pname)" );
		458	return;
		459	}
		460	}
		461	else if (target == GL_TEXTURE_FILTER_CONTROL_EXT) {
		462	/* GL_EXT_texture_lod_bias */
		463	if (!ctx->Extensions.EXT_texture_lod_bias) {
		464	_mesa_error( ctx, GL_INVALID_ENUM, "glTexEnv(target=0x%x)", target );
		465	return;
		466	}
		467	if (pname == GL_TEXTURE_LOD_BIAS_EXT) {
		468	if (texUnit->LodBias == param[0])
		469	return;
		470	FLUSH_VERTICES(ctx, _NEW_TEXTURE);
		471	texUnit->LodBias = CLAMP(param[0], -ctx->Const.MaxTextureLodBias,
		472	ctx->Const.MaxTextureLodBias);
		473	}
		474	else {
		475	TE_ERROR(GL_INVALID_ENUM, "glTexEnv(pname=%s)", pname);
		476	return;
		477	}
		478	}
		479	else if (target == GL_POINT_SPRITE_NV) {
		480	/* GL_NV_point_sprite */
		481	if (!ctx->Extensions.NV_point_sprite) {
		482	_mesa_error( ctx, GL_INVALID_ENUM, "glTexEnv(target=0x%x)", target );
		483	return;
		484	}
		485	if (pname == GL_COORD_REPLACE_NV) {
		486	const GLenum value = (GLenum) param[0];
		487	if (value == GL_TRUE \|\| value == GL_FALSE) {
		488	/* It's kind of weird to set point state via glTexEnv,
		489	* but that's what the spec calls for.
		490	*/
		491	const GLboolean state = (GLboolean) value;
		492	if (ctx->Point.CoordReplace[ctx->Texture.CurrentUnit] == state)
		493	return;
		494	FLUSH_VERTICES(ctx, _NEW_POINT);
		495	ctx->Point.CoordReplace[ctx->Texture.CurrentUnit] = state;
		496	}
		497	else {
		498	_mesa_error( ctx, GL_INVALID_VALUE, "glTexEnv(param=0x%x)", value);
		499	return;
		500	}
		501	}
		502	else {
		503	_mesa_error( ctx, GL_INVALID_ENUM, "glTexEnv(pname=0x%x)", pname );
		504	return;
		505	}
		506	}
		507	else {
		508	_mesa_error( ctx, GL_INVALID_ENUM, "glTexEnv(target=0x%x)",target );
		509	return;
		510	}
		511
		512	if (MESA_VERBOSE&(VERBOSE_API\|VERBOSE_TEXTURE))
		513	_mesa_debug(ctx, "glTexEnv %s %s %.1f(%s) ...\n",
		514	_mesa_lookup_enum_by_nr(target),
		515	_mesa_lookup_enum_by_nr(pname),
		516	*param,
		517	_mesa_lookup_enum_by_nr((GLenum) (GLint) *param));
		518
		519	/* Tell device driver about the new texture environment */
		520	if (ctx->Driver.TexEnv) {
		521	(*ctx->Driver.TexEnv)( ctx, target, pname, param );
		522	}
		523	}
		524
		525
		526	void
		527	_mesa_TexEnvf( GLenum target, GLenum pname, GLfloat param )
		528	{
		529	_mesa_TexEnvfv( target, pname, &param );
		530	}
		531
		532
		533
		534	void
		535	_mesa_TexEnvi( GLenum target, GLenum pname, GLint param )
		536	{
		537	GLfloat p[4];
		538	p[0] = (GLfloat) param;
		539	p[1] = p[2] = p[3] = 0.0;
		540	_mesa_TexEnvfv( target, pname, p );
		541	}
		542
		543
		544	void
		545	_mesa_TexEnviv( GLenum target, GLenum pname, const GLint *param )
		546	{
		547	GLfloat p[4];
		548	if (pname == GL_TEXTURE_ENV_COLOR) {
		549	p[0] = INT_TO_FLOAT( param[0] );
		550	p[1] = INT_TO_FLOAT( param[1] );
		551	p[2] = INT_TO_FLOAT( param[2] );
		552	p[3] = INT_TO_FLOAT( param[3] );
		553	}
		554	else {
		555	p[0] = (GLfloat) param[0];
		556	p[1] = p[2] = p[3] = 0; /* init to zero, just to be safe */
		557	}
		558	_mesa_TexEnvfv( target, pname, p );
		559	}
		560
		561
		562	void
		563	_mesa_GetTexEnvfv( GLenum target, GLenum pname, GLfloat *params )
		564	{
		565	GET_CURRENT_CONTEXT(ctx);
		566	const struct gl_texture_unit *texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
		567	ASSERT_OUTSIDE_BEGIN_END(ctx);
		568
		569	if (target == GL_TEXTURE_ENV) {
		570	switch (pname) {
		571	case GL_TEXTURE_ENV_MODE:
		572	*params = ENUM_TO_FLOAT(texUnit->EnvMode);
		573	break;
		574	case GL_TEXTURE_ENV_COLOR:
		575	COPY_4FV( params, texUnit->EnvColor );
		576	break;
		577	case GL_COMBINE_RGB_EXT:
		578	if (ctx->Extensions.EXT_texture_env_combine \|\|
		579	ctx->Extensions.ARB_texture_env_combine) {
		580	*params = (GLfloat) texUnit->CombineModeRGB;
		581	}
		582	else {
		583	_mesa_error(ctx, GL_INVALID_ENUM, "glGetTexEnvfv(pname)");
		584	}
		585	break;
		586	case GL_COMBINE_ALPHA_EXT:
		587	if (ctx->Extensions.EXT_texture_env_combine \|\|
		588	ctx->Extensions.ARB_texture_env_combine) {
		589	*params = (GLfloat) texUnit->CombineModeA;
		590	}
		591	else {
		592	_mesa_error(ctx, GL_INVALID_ENUM, "glGetTexEnvfv(pname)");
		593	}
		594	break;
		595	case GL_SOURCE0_RGB_EXT:
		596	if (ctx->Extensions.EXT_texture_env_combine \|\|
		597	ctx->Extensions.ARB_texture_env_combine) {
		598	*params = (GLfloat) texUnit->CombineSourceRGB[0];
		599	}
		600	else {
		601	_mesa_error(ctx, GL_INVALID_ENUM, "glGetTexEnvfv(pname)");
		602	}
		603	break;
		604	case GL_SOURCE1_RGB_EXT:
		605	if (ctx->Extensions.EXT_texture_env_combine \|\|
		606	ctx->Extensions.ARB_texture_env_combine) {
		607	*params = (GLfloat) texUnit->CombineSourceRGB[1];
		608	}
		609	else {
		610	_mesa_error(ctx, GL_INVALID_ENUM, "glGetTexEnvfv(pname)");
		611	}
		612	break;
		613	case GL_SOURCE2_RGB_EXT:
		614	if (ctx->Extensions.EXT_texture_env_combine \|\|
		615	ctx->Extensions.ARB_texture_env_combine) {
		616	*params = (GLfloat) texUnit->CombineSourceRGB[2];
		617	}
		618	else {
		619	_mesa_error(ctx, GL_INVALID_ENUM, "glGetTexEnvfv(pname)");
		620	}
		621	break;
		622	case GL_SOURCE0_ALPHA_EXT:
		623	if (ctx->Extensions.EXT_texture_env_combine \|\|
		624	ctx->Extensions.ARB_texture_env_combine) {
		625	*params = (GLfloat) texUnit->CombineSourceA[0];
		626	}
		627	else {
		628	_mesa_error(ctx, GL_INVALID_ENUM, "glGetTexEnvfv(pname)");
		629	}
		630	break;
		631	case GL_SOURCE1_ALPHA_EXT:
		632	if (ctx->Extensions.EXT_texture_env_combine \|\|
		633	ctx->Extensions.ARB_texture_env_combine) {
		634	*params = (GLfloat) texUnit->CombineSourceA[1];
		635	}
		636	else {
		637	_mesa_error(ctx, GL_INVALID_ENUM, "glGetTexEnvfv(pname)");
		638	}
		639	break;
		640	case GL_SOURCE2_ALPHA_EXT:
		641	if (ctx->Extensions.EXT_texture_env_combine \|\|
		642	ctx->Extensions.ARB_texture_env_combine) {
		643	*params = (GLfloat) texUnit->CombineSourceA[2];
		644	}
		645	else {
		646	_mesa_error(ctx, GL_INVALID_ENUM, "glGetTexEnvfv(pname)");
		647	}
		648	break;
		649	case GL_OPERAND0_RGB_EXT:
		650	if (ctx->Extensions.EXT_texture_env_combine \|\|
		651	ctx->Extensions.ARB_texture_env_combine) {
		652	*params = (GLfloat) texUnit->CombineOperandRGB[0];
		653	}
		654	else {
		655	_mesa_error(ctx, GL_INVALID_ENUM, "glGetTexEnvfv(pname)");
		656	}
		657	break;
		658	case GL_OPERAND1_RGB_EXT:
		659	if (ctx->Extensions.EXT_texture_env_combine \|\|
		660	ctx->Extensions.ARB_texture_env_combine) {
		661	*params = (GLfloat) texUnit->CombineOperandRGB[1];
		662	}
		663	else {
		664	_mesa_error(ctx, GL_INVALID_ENUM, "glGetTexEnvfv(pname)");
		665	}
		666	break;
		667	case GL_OPERAND2_RGB_EXT:
		668	if (ctx->Extensions.EXT_texture_env_combine \|\|
		669	ctx->Extensions.ARB_texture_env_combine) {
		670	*params = (GLfloat) texUnit->CombineOperandRGB[2];
		671	}
		672	else {
		673	_mesa_error(ctx, GL_INVALID_ENUM, "glGetTexEnvfv(pname)");
		674	}
		675	break;
		676	case GL_OPERAND0_ALPHA_EXT:
		677	if (ctx->Extensions.EXT_texture_env_combine \|\|
		678	ctx->Extensions.ARB_texture_env_combine) {
		679	*params = (GLfloat) texUnit->CombineOperandA[0];
		680	}
		681	else {
		682	_mesa_error(ctx, GL_INVALID_ENUM, "glGetTexEnvfv(pname)");
		683	}
		684	break;
		685	case GL_OPERAND1_ALPHA_EXT:
		686	if (ctx->Extensions.EXT_texture_env_combine \|\|
		687	ctx->Extensions.ARB_texture_env_combine) {
		688	*params = (GLfloat) texUnit->CombineOperandA[1];
		689	}
		690	else {
		691	_mesa_error(ctx, GL_INVALID_ENUM, "glGetTexEnvfv(pname)");
		692	}
		693	break;
		694	case GL_OPERAND2_ALPHA_EXT:
		695	if (ctx->Extensions.EXT_texture_env_combine \|\|
		696	ctx->Extensions.ARB_texture_env_combine) {
		697	*params = (GLfloat) texUnit->CombineOperandA[2];
		698	}
		699	else {
		700	_mesa_error(ctx, GL_INVALID_ENUM, "glGetTexEnvfv(pname)");
		701	}
		702	break;
		703	case GL_RGB_SCALE_EXT:
		704	if (ctx->Extensions.EXT_texture_env_combine \|\|
		705	ctx->Extensions.ARB_texture_env_combine) {
		706	if (texUnit->CombineScaleShiftRGB == 0)
		707	*params = 1.0;
		708	else if (texUnit->CombineScaleShiftRGB == 1)
		709	*params = 2.0;
		710	else
		711	*params = 4.0;
		712	}
		713	else {
		714	_mesa_error(ctx, GL_INVALID_ENUM, "glGetTexEnvfv(pname)");
		715	return;
		716	}
		717	break;
		718	case GL_ALPHA_SCALE:
		719	if (ctx->Extensions.EXT_texture_env_combine \|\|
		720	ctx->Extensions.ARB_texture_env_combine) {
		721	if (texUnit->CombineScaleShiftA == 0)
		722	*params = 1.0;
		723	else if (texUnit->CombineScaleShiftA == 1)
		724	*params = 2.0;
		725	else
		726	*params = 4.0;
		727	}
		728	else {
		729	_mesa_error(ctx, GL_INVALID_ENUM, "glGetTexEnvfv(pname)");
		730	return;
		731	}
		732	break;
		733	default:
		734	_mesa_error( ctx, GL_INVALID_ENUM, "glGetTexEnvfv(pname)" );
		735	}
		736	}
		737	else if (target == GL_TEXTURE_FILTER_CONTROL_EXT) {
		738	/* GL_EXT_texture_lod_bias */
		739	if (!ctx->Extensions.EXT_texture_lod_bias) {
		740	_mesa_error( ctx, GL_INVALID_ENUM, "glGetTexEnvfv(target)" );
		741	return;
		742	}
		743	if (pname == GL_TEXTURE_LOD_BIAS_EXT) {
		744	*params = texUnit->LodBias;
		745	}
		746	else {
		747	_mesa_error( ctx, GL_INVALID_ENUM, "glGetTexEnvfv(pname)" );
		748	return;
		749	}
		750	}
		751	else if (target == GL_POINT_SPRITE_NV) {
		752	/* GL_NV_point_sprite */
		753	if (!ctx->Extensions.NV_point_sprite) {
		754	_mesa_error( ctx, GL_INVALID_ENUM, "glGetTexEnvfv(target)" );
		755	return;
		756	}
		757	if (pname == GL_COORD_REPLACE_NV) {
		758	*params = (GLfloat) ctx->Point.CoordReplace[ctx->Texture.CurrentUnit];
		759	}
		760	else {
		761	_mesa_error( ctx, GL_INVALID_ENUM, "glGetTexEnvfv(pname)" );
		762	return;
		763	}
		764	}
		765	else {
		766	_mesa_error( ctx, GL_INVALID_ENUM, "glGetTexEnvfv(target)" );
		767	return;
		768	}
		769	}
		770
		771
		772	void
		773	_mesa_GetTexEnviv( GLenum target, GLenum pname, GLint *params )
		774	{
		775	GET_CURRENT_CONTEXT(ctx);
		776	const struct gl_texture_unit *texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
		777	ASSERT_OUTSIDE_BEGIN_END(ctx);
		778
		779	if (target == GL_TEXTURE_ENV) {
		780	switch (pname) {
		781	case GL_TEXTURE_ENV_MODE:
		782	*params = (GLint) texUnit->EnvMode;
		783	break;
		784	case GL_TEXTURE_ENV_COLOR:
		785	params[0] = FLOAT_TO_INT( texUnit->EnvColor[0] );
		786	params[1] = FLOAT_TO_INT( texUnit->EnvColor[1] );
		787	params[2] = FLOAT_TO_INT( texUnit->EnvColor[2] );
		788	params[3] = FLOAT_TO_INT( texUnit->EnvColor[3] );
		789	break;
		790	case GL_COMBINE_RGB_EXT:
		791	if (ctx->Extensions.EXT_texture_env_combine \|\|
		792	ctx->Extensions.ARB_texture_env_combine) {
		793	*params = (GLint) texUnit->CombineModeRGB;
		794	}
		795	else {
		796	_mesa_error(ctx, GL_INVALID_ENUM, "glGetTexEnviv(pname)");
		797	}
		798	break;
		799	case GL_COMBINE_ALPHA_EXT:
		800	if (ctx->Extensions.EXT_texture_env_combine \|\|
		801	ctx->Extensions.ARB_texture_env_combine) {
		802	*params = (GLint) texUnit->CombineModeA;
		803	}
		804	else {
		805	_mesa_error(ctx, GL_INVALID_ENUM, "glGetTexEnviv(pname)");
		806	}
		807	break;
		808	case GL_SOURCE0_RGB_EXT:
		809	if (ctx->Extensions.EXT_texture_env_combine \|\|
		810	ctx->Extensions.ARB_texture_env_combine) {
		811	*params = (GLint) texUnit->CombineSourceRGB[0];
		812	}
		813	else {
		814	_mesa_error(ctx, GL_INVALID_ENUM, "glGetTexEnviv(pname)");
		815	}
		816	break;
		817	case GL_SOURCE1_RGB_EXT:
		818	if (ctx->Extensions.EXT_texture_env_combine \|\|
		819	ctx->Extensions.ARB_texture_env_combine) {
		820	*params = (GLint) texUnit->CombineSourceRGB[1];
		821	}
		822	else {
		823	_mesa_error(ctx, GL_INVALID_ENUM, "glGetTexEnviv(pname)");
		824	}
		825	break;
		826	case GL_SOURCE2_RGB_EXT:
		827	if (ctx->Extensions.EXT_texture_env_combine \|\|
		828	ctx->Extensions.ARB_texture_env_combine) {
		829	*params = (GLint) texUnit->CombineSourceRGB[2];
		830	}
		831	else {
		832	_mesa_error(ctx, GL_INVALID_ENUM, "glGetTexEnviv(pname)");
		833	}
		834	break;
		835	case GL_SOURCE0_ALPHA_EXT:
		836	if (ctx->Extensions.EXT_texture_env_combine \|\|
		837	ctx->Extensions.ARB_texture_env_combine) {
		838	*params = (GLint) texUnit->CombineSourceA[0];
		839	}
		840	else {
		841	_mesa_error(ctx, GL_INVALID_ENUM, "glGetTexEnviv(pname)");
		842	}
		843	break;
		844	case GL_SOURCE1_ALPHA_EXT:
		845	if (ctx->Extensions.EXT_texture_env_combine \|\|
		846	ctx->Extensions.ARB_texture_env_combine) {
		847	*params = (GLint) texUnit->CombineSourceA[1];
		848	}
		849	else {
		850	_mesa_error(ctx, GL_INVALID_ENUM, "glGetTexEnviv(pname)");
		851	}
		852	break;
		853	case GL_SOURCE2_ALPHA_EXT:
		854	if (ctx->Extensions.EXT_texture_env_combine \|\|
		855	ctx->Extensions.ARB_texture_env_combine) {
		856	*params = (GLint) texUnit->CombineSourceA[2];
		857	}
		858	else {
		859	_mesa_error(ctx, GL_INVALID_ENUM, "glGetTexEnviv(pname)");
		860	}
		861	break;
		862	case GL_OPERAND0_RGB_EXT:
		863	if (ctx->Extensions.EXT_texture_env_combine \|\|
		864	ctx->Extensions.ARB_texture_env_combine) {
		865	*params = (GLint) texUnit->CombineOperandRGB[0];
		866	}
		867	else {
		868	_mesa_error(ctx, GL_INVALID_ENUM, "glGetTexEnviv(pname)");
		869	}
		870	break;
		871	case GL_OPERAND1_RGB_EXT:
		872	if (ctx->Extensions.EXT_texture_env_combine \|\|
		873	ctx->Extensions.ARB_texture_env_combine) {
		874	*params = (GLint) texUnit->CombineOperandRGB[1];
		875	}
		876	else {
		877	_mesa_error(ctx, GL_INVALID_ENUM, "glGetTexEnviv(pname)");
		878	}
		879	break;
		880	case GL_OPERAND2_RGB_EXT:
		881	if (ctx->Extensions.EXT_texture_env_combine \|\|
		882	ctx->Extensions.ARB_texture_env_combine) {
		883	*params = (GLint) texUnit->CombineOperandRGB[2];
		884	}
		885	else {
		886	_mesa_error(ctx, GL_INVALID_ENUM, "glGetTexEnviv(pname)");
		887	}
		888	break;
		889	case GL_OPERAND0_ALPHA_EXT:
		890	if (ctx->Extensions.EXT_texture_env_combine \|\|
		891	ctx->Extensions.ARB_texture_env_combine) {
		892	*params = (GLint) texUnit->CombineOperandA[0];
		893	}
		894	else {
		895	_mesa_error(ctx, GL_INVALID_ENUM, "glGetTexEnviv(pname)");
		896	}
		897	break;
		898	case GL_OPERAND1_ALPHA_EXT:
		899	if (ctx->Extensions.EXT_texture_env_combine \|\|
		900	ctx->Extensions.ARB_texture_env_combine) {
		901	*params = (GLint) texUnit->CombineOperandA[1];
		902	}
		903	else {
		904	_mesa_error(ctx, GL_INVALID_ENUM, "glGetTexEnviv(pname)");
		905	}
		906	break;
		907	case GL_OPERAND2_ALPHA_EXT:
		908	if (ctx->Extensions.EXT_texture_env_combine \|\|
		909	ctx->Extensions.ARB_texture_env_combine) {
		910	*params = (GLint) texUnit->CombineOperandA[2];
		911	}
		912	else {
		913	_mesa_error(ctx, GL_INVALID_ENUM, "glGetTexEnviv(pname)");
		914	}
		915	break;
		916	case GL_RGB_SCALE_EXT:
		917	if (ctx->Extensions.EXT_texture_env_combine \|\|
		918	ctx->Extensions.ARB_texture_env_combine) {
		919	if (texUnit->CombineScaleShiftRGB == 0)
		920	*params = 1;
		921	else if (texUnit->CombineScaleShiftRGB == 1)
		922	*params = 2;
		923	else
		924	*params = 4;
		925	}
		926	else {
		927	_mesa_error(ctx, GL_INVALID_ENUM, "glGetTexEnviv(pname)");
		928	return;
		929	}
		930	break;
		931	case GL_ALPHA_SCALE:
		932	if (ctx->Extensions.EXT_texture_env_combine \|\|
		933	ctx->Extensions.ARB_texture_env_combine) {
		934	if (texUnit->CombineScaleShiftA == 0)
		935	*params = 1;
		936	else if (texUnit->CombineScaleShiftA == 1)
		937	*params = 2;
		938	else
		939	*params = 4;
		940	}
		941	else {
		942	_mesa_error(ctx, GL_INVALID_ENUM, "glGetTexEnviv(pname)");
		943	return;
		944	}
		945	break;
		946	default:
		947	_mesa_error( ctx, GL_INVALID_ENUM, "glGetTexEnviv(pname)" );
		948	}
		949	}
		950	else if (target == GL_TEXTURE_FILTER_CONTROL_EXT) {
		951	/* GL_EXT_texture_lod_bias */
		952	if (!ctx->Extensions.EXT_texture_lod_bias) {
		953	_mesa_error( ctx, GL_INVALID_ENUM, "glGetTexEnviv(target)" );
		954	return;
		955	}
		956	if (pname == GL_TEXTURE_LOD_BIAS_EXT) {
		957	*params = (GLint) texUnit->LodBias;
		958	}
		959	else {
		960	_mesa_error( ctx, GL_INVALID_ENUM, "glGetTexEnviv(pname)" );
		961	return;
		962	}
		963	}
		964	else if (target == GL_POINT_SPRITE_NV) {
		965	/* GL_NV_point_sprite */
		966	if (!ctx->Extensions.NV_point_sprite) {
		967	_mesa_error( ctx, GL_INVALID_ENUM, "glGetTexEnviv(target)" );
		968	return;
		969	}
		970	if (pname == GL_COORD_REPLACE_NV) {
		971	*params = (GLint) ctx->Point.CoordReplace[ctx->Texture.CurrentUnit];
		972	}
		973	else {
		974	_mesa_error( ctx, GL_INVALID_ENUM, "glGetTexEnviv(pname)" );
		975	return;
		976	}
		977	}
		978	else {
		979	_mesa_error( ctx, GL_INVALID_ENUM, "glGetTexEnviv(target)" );
		980	return;
		981	}
		982	}
		983
		984
		985
		986
		987	/**********************************************************************/
		988	/* Texture Parameters */
		989	/**********************************************************************/
		990
		991
		992	void
		993	_mesa_TexParameterf( GLenum target, GLenum pname, GLfloat param )
		994	{
		995	_mesa_TexParameterfv(target, pname, &param);
		996	}
		997
		998
		999	void
		1000	_mesa_TexParameterfv( GLenum target, GLenum pname, const GLfloat *params )
		1001	{
		1002	GET_CURRENT_CONTEXT(ctx);
		1003	struct gl_texture_unit *texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
		1004	GLenum eparam = (GLenum) (GLint) params[0];
		1005	struct gl_texture_object *texObj;
		1006	ASSERT_OUTSIDE_BEGIN_END(ctx);
		1007
		1008	if (MESA_VERBOSE&(VERBOSE_API\|VERBOSE_TEXTURE))
		1009	_mesa_debug(ctx, "texPARAM %s %s %d...\n",
		1010	_mesa_lookup_enum_by_nr(target),
		1011	_mesa_lookup_enum_by_nr(pname),
		1012	eparam);
		1013
		1014
		1015	switch (target) {
		1016	case GL_TEXTURE_1D:
		1017	texObj = texUnit->Current1D;
		1018	break;
		1019	case GL_TEXTURE_2D:
		1020	texObj = texUnit->Current2D;
		1021	break;
		1022	case GL_TEXTURE_3D_EXT:
		1023	texObj = texUnit->Current3D;
		1024	break;
		1025	case GL_TEXTURE_CUBE_MAP_ARB:
		1026	if (!ctx->Extensions.ARB_texture_cube_map) {
		1027	_mesa_error( ctx, GL_INVALID_ENUM, "glTexParameter(target)" );
		1028	return;
		1029	}
		1030	texObj = texUnit->CurrentCubeMap;
		1031	break;
		1032	case GL_TEXTURE_RECTANGLE_NV:
		1033	if (!ctx->Extensions.NV_texture_rectangle) {
		1034	_mesa_error( ctx, GL_INVALID_ENUM, "glTexParameter(target)" );
		1035	return;
		1036	}
		1037	texObj = texUnit->CurrentRect;
		1038	break;
		1039	default:
		1040	_mesa_error( ctx, GL_INVALID_ENUM, "glTexParameter(target)" );
		1041	return;
		1042	}
		1043
		1044	switch (pname) {
		1045	case GL_TEXTURE_MIN_FILTER:
		1046	/* A small optimization */
		1047	if (texObj->MinFilter == eparam)
		1048	return;
		1049	if (eparam==GL_NEAREST \|\| eparam==GL_LINEAR) {
		1050	FLUSH_VERTICES(ctx, _NEW_TEXTURE);
		1051	texObj->MinFilter = eparam;
		1052	}
		1053	else if ((eparam==GL_NEAREST_MIPMAP_NEAREST \|\|
		1054	eparam==GL_LINEAR_MIPMAP_NEAREST \|\|
		1055	eparam==GL_NEAREST_MIPMAP_LINEAR \|\|
		1056	eparam==GL_LINEAR_MIPMAP_LINEAR) &&
		1057	texObj->Target != GL_TEXTURE_RECTANGLE_NV) {
		1058	FLUSH_VERTICES(ctx, _NEW_TEXTURE);
		1059	texObj->MinFilter = eparam;
		1060	}
		1061	else {
		1062	_mesa_error( ctx, GL_INVALID_VALUE, "glTexParameter(param)" );
		1063	return;
		1064	}
		1065	break;
		1066	case GL_TEXTURE_MAG_FILTER:
		1067	/* A small optimization */
		1068	if (texObj->MagFilter == eparam)
		1069	return;
		1070
		1071	if (eparam==GL_NEAREST \|\| eparam==GL_LINEAR) {
		1072	FLUSH_VERTICES(ctx, _NEW_TEXTURE);
		1073	texObj->MagFilter = eparam;
		1074	}
		1075	else {
		1076	_mesa_error( ctx, GL_INVALID_VALUE, "glTexParameter(param)" );
		1077	return;
		1078	}
		1079	break;
		1080	case GL_TEXTURE_WRAP_S:
		1081	if (texObj->WrapS == eparam)
		1082	return;
		1083	if (eparam == GL_CLAMP \|\| eparam == GL_CLAMP_TO_EDGE \|\|
		1084	(eparam == GL_CLAMP_TO_BORDER_ARB &&
		1085	ctx->Extensions.ARB_texture_border_clamp)) {
		1086	/* any texture target */
		1087	FLUSH_VERTICES(ctx, _NEW_TEXTURE);
		1088	texObj->WrapS = eparam;
		1089	}
		1090	else if (texObj->Target != GL_TEXTURE_RECTANGLE_NV &&
		1091	(eparam == GL_REPEAT \|\|
		1092	(eparam == GL_MIRRORED_REPEAT_ARB &&
		1093	ctx->Extensions.ARB_texture_mirrored_repeat) \|\|
		1094	(eparam == GL_MIRROR_CLAMP_ATI &&
		1095	ctx->Extensions.ATI_texture_mirror_once) \|\|
		1096	(eparam == GL_MIRROR_CLAMP_TO_EDGE_ATI &&
		1097	ctx->Extensions.ATI_texture_mirror_once))) {
		1098	/* non-rectangle texture */
		1099	FLUSH_VERTICES(ctx, _NEW_TEXTURE);
		1100	texObj->WrapS = eparam;
		1101	}
		1102	else {
		1103	_mesa_error( ctx, GL_INVALID_VALUE, "glTexParameter(param)" );
		1104	return;
		1105	}
		1106	break;
		1107	case GL_TEXTURE_WRAP_T:
		1108	if (texObj->WrapT == eparam)
		1109	return;
		1110	if (eparam == GL_CLAMP \|\| eparam == GL_CLAMP_TO_EDGE \|\|
		1111	(eparam == GL_CLAMP_TO_BORDER_ARB &&
		1112	ctx->Extensions.ARB_texture_border_clamp)) {
		1113	/* any texture target */
		1114	FLUSH_VERTICES(ctx, _NEW_TEXTURE);
		1115	texObj->WrapT = eparam;
		1116	}
		1117	else if (texObj->Target != GL_TEXTURE_RECTANGLE_NV &&
		1118	(eparam == GL_REPEAT \|\|
		1119	(eparam == GL_MIRRORED_REPEAT_ARB &&
		1120	ctx->Extensions.ARB_texture_mirrored_repeat) \|\|
		1121	(eparam == GL_MIRROR_CLAMP_ATI &&
		1122	ctx->Extensions.ATI_texture_mirror_once) \|\|
		1123	(eparam == GL_MIRROR_CLAMP_TO_EDGE_ATI &&
		1124	ctx->Extensions.ATI_texture_mirror_once))) {
		1125	/* non-rectangle texture */
		1126	FLUSH_VERTICES(ctx, _NEW_TEXTURE);
		1127	texObj->WrapT = eparam;
		1128	}
		1129	else {
		1130	_mesa_error( ctx, GL_INVALID_VALUE, "glTexParameter(param)" );
		1131	return;
		1132	}
		1133	break;
		1134	case GL_TEXTURE_WRAP_R_EXT:
		1135	if (texObj->WrapR == eparam)
		1136	return;
		1137	if (eparam == GL_CLAMP \|\| eparam == GL_CLAMP_TO_EDGE \|\|
		1138	(eparam == GL_CLAMP_TO_BORDER_ARB &&
		1139	ctx->Extensions.ARB_texture_border_clamp)) {
		1140	/* any texture target */
		1141	FLUSH_VERTICES(ctx, _NEW_TEXTURE);
		1142	texObj->WrapR = eparam;
		1143	}
		1144	else if (texObj->Target != GL_TEXTURE_RECTANGLE_NV &&
		1145	(eparam == GL_REPEAT \|\|
		1146	(eparam == GL_MIRRORED_REPEAT_ARB &&
		1147	ctx->Extensions.ARB_texture_mirrored_repeat) \|\|
		1148	(eparam == GL_MIRROR_CLAMP_ATI &&
		1149	ctx->Extensions.ATI_texture_mirror_once) \|\|
		1150	(eparam == GL_MIRROR_CLAMP_TO_EDGE_ATI &&
		1151	ctx->Extensions.ATI_texture_mirror_once))) {
		1152	/* non-rectangle texture */
		1153	FLUSH_VERTICES(ctx, _NEW_TEXTURE);
		1154	texObj->WrapR = eparam;
		1155	}
		1156	else {
		1157	_mesa_error( ctx, GL_INVALID_VALUE, "glTexParameter(param)" );
		1158	}
		1159	break;
		1160	case GL_TEXTURE_BORDER_COLOR:
		1161	FLUSH_VERTICES(ctx, _NEW_TEXTURE);
		1162	texObj->BorderColor[RCOMP] = params[0];
		1163	texObj->BorderColor[GCOMP] = params[1];
		1164	texObj->BorderColor[BCOMP] = params[2];
		1165	texObj->BorderColor[ACOMP] = params[3];
		1166	UNCLAMPED_FLOAT_TO_CHAN(texObj->_BorderChan[RCOMP], params[0]);
		1167	UNCLAMPED_FLOAT_TO_CHAN(texObj->_BorderChan[GCOMP], params[1]);
		1168	UNCLAMPED_FLOAT_TO_CHAN(texObj->_BorderChan[BCOMP], params[2]);
		1169	UNCLAMPED_FLOAT_TO_CHAN(texObj->_BorderChan[ACOMP], params[3]);
		1170	break;
		1171	case GL_TEXTURE_MIN_LOD:
		1172	if (texObj->MinLod == params[0])
		1173	return;
		1174	FLUSH_VERTICES(ctx, _NEW_TEXTURE);
		1175	texObj->MinLod = params[0];
		1176	break;
		1177	case GL_TEXTURE_MAX_LOD:
		1178	if (texObj->MaxLod == params[0])
		1179	return;
		1180	FLUSH_VERTICES(ctx, _NEW_TEXTURE);
		1181	texObj->MaxLod = params[0];
		1182	break;
		1183	case GL_TEXTURE_BASE_LEVEL:
		1184	if (params[0] < 0.0) {
		1185	_mesa_error(ctx, GL_INVALID_VALUE, "glTexParameter(param)" );
		1186	return;
		1187	}
		1188	if (target == GL_TEXTURE_RECTANGLE_NV && params[0] != 0.0) {
		1189	_mesa_error(ctx, GL_INVALID_VALUE, "glTexParameter(param)" );
		1190	return;
		1191	}
		1192	FLUSH_VERTICES(ctx, _NEW_TEXTURE);
		1193	texObj->BaseLevel = (GLint) params[0];
		1194	break;
		1195	case GL_TEXTURE_MAX_LEVEL:
		1196	if (params[0] < 0.0) {
		1197	_mesa_error(ctx, GL_INVALID_VALUE, "glTexParameter(param)" );
		1198	return;
		1199	}
		1200	FLUSH_VERTICES(ctx, _NEW_TEXTURE);
		1201	texObj->MaxLevel = (GLint) params[0];
		1202	break;
		1203	case GL_TEXTURE_PRIORITY:
		1204	FLUSH_VERTICES(ctx, _NEW_TEXTURE);
		1205	texObj->Priority = CLAMP( params[0], 0.0F, 1.0F );
		1206	break;
		1207	case GL_TEXTURE_MAX_ANISOTROPY_EXT:
		1208	if (ctx->Extensions.EXT_texture_filter_anisotropic) {
		1209	if (params[0] < 1.0) {
		1210	_mesa_error(ctx, GL_INVALID_VALUE, "glTexParameter(param)" );
		1211	return;
		1212	}
		1213	FLUSH_VERTICES(ctx, _NEW_TEXTURE);
		1214	texObj->MaxAnisotropy = params[0];
		1215	}
		1216	else {
		1217	_mesa_error(ctx, GL_INVALID_ENUM,
		1218	"glTexParameter(pname=GL_TEXTURE_MAX_ANISOTROPY_EXT)");
		1219	return;
		1220	}
		1221	break;
		1222	case GL_TEXTURE_COMPARE_SGIX:
		1223	if (ctx->Extensions.SGIX_shadow) {
		1224	FLUSH_VERTICES(ctx, _NEW_TEXTURE);
		1225	texObj->CompareFlag = params[0] ? GL_TRUE : GL_FALSE;
		1226	}
		1227	else {
		1228	_mesa_error(ctx, GL_INVALID_ENUM,
		1229	"glTexParameter(pname=GL_TEXTURE_COMPARE_SGIX)");
		1230	return;
		1231	}
		1232	break;
		1233	case GL_TEXTURE_COMPARE_OPERATOR_SGIX:
		1234	if (ctx->Extensions.SGIX_shadow) {
		1235	GLenum op = (GLenum) params[0];
		1236	if (op == GL_TEXTURE_LEQUAL_R_SGIX \|\|
		1237	op == GL_TEXTURE_GEQUAL_R_SGIX) {
		1238	FLUSH_VERTICES(ctx, _NEW_TEXTURE);
		1239	texObj->CompareOperator = op;
		1240	}
		1241	else {
		1242	_mesa_error(ctx, GL_INVALID_ENUM, "glTexParameter(param)");
		1243	}
		1244	}
		1245	else {
		1246	_mesa_error(ctx, GL_INVALID_ENUM,
		1247	"glTexParameter(pname=GL_TEXTURE_COMPARE_OPERATOR_SGIX)");
		1248	return;
		1249	}
		1250	break;
		1251	case GL_SHADOW_AMBIENT_SGIX: /* aka GL_TEXTURE_COMPARE_FAIL_VALUE_ARB */
		1252	if (ctx->Extensions.SGIX_shadow_ambient) {
		1253	FLUSH_VERTICES(ctx, _NEW_TEXTURE);
		1254	texObj->ShadowAmbient = CLAMP(params[0], 0.0F, 1.0F);
		1255	}
		1256	else {
		1257	_mesa_error(ctx, GL_INVALID_ENUM,
		1258	"glTexParameter(pname=GL_SHADOW_AMBIENT_SGIX)");
		1259	return;
		1260	}
		1261	break;
		1262	case GL_GENERATE_MIPMAP_SGIS:
		1263	if (ctx->Extensions.SGIS_generate_mipmap) {
		1264	texObj->GenerateMipmap = params[0] ? GL_TRUE : GL_FALSE;
		1265	}
		1266	else {
		1267	_mesa_error(ctx, GL_INVALID_ENUM,
		1268	"glTexParameter(pname=GL_GENERATE_MIPMAP_SGIS)");
		1269	return;
		1270	}
		1271	break;
		1272	case GL_TEXTURE_COMPARE_MODE_ARB:
		1273	if (ctx->Extensions.ARB_shadow) {
		1274	const GLenum mode = (GLenum) params[0];
		1275	if (mode == GL_NONE \|\| mode == GL_COMPARE_R_TO_TEXTURE_ARB) {
		1276	FLUSH_VERTICES(ctx, _NEW_TEXTURE);
		1277	texObj->CompareMode = mode;
		1278	}
		1279	else {
		1280	_mesa_error(ctx, GL_INVALID_ENUM,
		1281	"glTexParameter(bad GL_TEXTURE_COMPARE_MODE_ARB)");
		1282	return;
		1283	}
		1284	}
		1285	else {
		1286	_mesa_error(ctx, GL_INVALID_ENUM,
		1287	"glTexParameter(pname=GL_TEXTURE_COMPARE_MODE_ARB)");
		1288	return;
		1289	}
		1290	break;
		1291	case GL_TEXTURE_COMPARE_FUNC_ARB:
		1292	if (ctx->Extensions.ARB_shadow) {
		1293	const GLenum func = (GLenum) params[0];
		1294	if (func == GL_LEQUAL \|\| func == GL_GEQUAL) {
		1295	FLUSH_VERTICES(ctx, _NEW_TEXTURE);
		1296	texObj->CompareFunc = func;
		1297	}
		1298	else if (ctx->Extensions.EXT_shadow_funcs &&
		1299	(func == GL_EQUAL \|\|
		1300	func == GL_NOTEQUAL \|\|
		1301	func == GL_LESS \|\|
		1302	func == GL_GREATER \|\|
		1303	func == GL_ALWAYS \|\|
		1304	func == GL_NEVER)) {
		1305	FLUSH_VERTICES(ctx, _NEW_TEXTURE);
		1306	texObj->CompareFunc = func;
		1307	}
		1308	else {
		1309	_mesa_error(ctx, GL_INVALID_ENUM,
		1310	"glTexParameter(bad GL_TEXTURE_COMPARE_FUNC_ARB)");
		1311	return;
		1312	}
		1313	}
		1314	else {
		1315	_mesa_error(ctx, GL_INVALID_ENUM,
		1316	"glTexParameter(pname=GL_TEXTURE_COMPARE_FUNC_ARB)");
		1317	return;
		1318	}
		1319	break;
		1320	case GL_DEPTH_TEXTURE_MODE_ARB:
		1321	if (ctx->Extensions.ARB_depth_texture) {
		1322	const GLenum result = (GLenum) params[0];
		1323	if (result == GL_LUMINANCE \|\| result == GL_INTENSITY
		1324	\|\| result == GL_ALPHA) {
		1325	FLUSH_VERTICES(ctx, _NEW_TEXTURE);
		1326	texObj->DepthMode = result;
		1327	}
		1328	else {
		1329	_mesa_error(ctx, GL_INVALID_ENUM,
		1330	"glTexParameter(bad GL_DEPTH_TEXTURE_MODE_ARB)");
		1331	return;
		1332	}
		1333	}
		1334	else {
		1335	_mesa_error(ctx, GL_INVALID_ENUM,
		1336	"glTexParameter(pname=GL_DEPTH_TEXTURE_MODE_ARB)");
		1337	return;
		1338	}
		1339	break;
		1340
		1341	default:
		1342	_mesa_error(ctx, GL_INVALID_ENUM,
		1343	"glTexParameter(pname=0x%x)", pname);
		1344	return;
		1345	}
		1346
		1347	texObj->Complete = GL_FALSE;
		1348
		1349	if (ctx->Driver.TexParameter) {
		1350	(*ctx->Driver.TexParameter)( ctx, target, texObj, pname, params );
		1351	}
		1352	}
		1353
		1354
		1355	void
		1356	_mesa_TexParameteri( GLenum target, GLenum pname, GLint param )
		1357	{
		1358	GLfloat fparam[4];
		1359	fparam[0] = (GLfloat) param;
		1360	fparam[1] = fparam[2] = fparam[3] = 0.0;
		1361	_mesa_TexParameterfv(target, pname, fparam);
		1362	}
		1363
		1364
		1365	void
		1366	_mesa_TexParameteriv( GLenum target, GLenum pname, const GLint *params )
		1367	{
		1368	GLfloat fparam[4];
		1369	if (pname == GL_TEXTURE_BORDER_COLOR) {
		1370	fparam[0] = INT_TO_FLOAT(params[0]);
		1371	fparam[1] = INT_TO_FLOAT(params[1]);
		1372	fparam[2] = INT_TO_FLOAT(params[2]);
		1373	fparam[3] = INT_TO_FLOAT(params[3]);
		1374	}
		1375	else {
		1376	fparam[0] = (GLfloat) params[0];
		1377	fparam[1] = fparam[2] = fparam[3] = 0.0F;
		1378	}
		1379	_mesa_TexParameterfv(target, pname, fparam);
		1380	}
		1381
		1382
		1383	void
		1384	_mesa_GetTexLevelParameterfv( GLenum target, GLint level,
		1385	GLenum pname, GLfloat *params )
		1386	{
		1387	GLint iparam;
		1388	_mesa_GetTexLevelParameteriv( target, level, pname, &iparam );
		1389	*params = (GLfloat) iparam;
		1390	}
		1391
		1392
		1393	static GLuint
		1394	tex_image_dimensions(GLcontext *ctx, GLenum target)
		1395	{
		1396	switch (target) {
		1397	case GL_TEXTURE_1D:
		1398	case GL_PROXY_TEXTURE_1D:
		1399	return 1;
		1400	case GL_TEXTURE_2D:
		1401	case GL_PROXY_TEXTURE_2D:
		1402	return 2;
		1403	case GL_TEXTURE_3D:
		1404	case GL_PROXY_TEXTURE_3D:
		1405	return 3;
		1406	case GL_TEXTURE_CUBE_MAP_ARB:
		1407	case GL_PROXY_TEXTURE_CUBE_MAP_ARB:
		1408	case GL_TEXTURE_CUBE_MAP_POSITIVE_X_ARB:
		1409	case GL_TEXTURE_CUBE_MAP_NEGATIVE_X_ARB:
		1410	case GL_TEXTURE_CUBE_MAP_POSITIVE_Y_ARB:
		1411	case GL_TEXTURE_CUBE_MAP_NEGATIVE_Y_ARB:
		1412	case GL_TEXTURE_CUBE_MAP_POSITIVE_Z_ARB:
		1413	case GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_ARB:
		1414	return ctx->Extensions.ARB_texture_cube_map ? 2 : 0;
		1415	case GL_TEXTURE_RECTANGLE_NV:
		1416	case GL_PROXY_TEXTURE_RECTANGLE_NV:
		1417	return ctx->Extensions.NV_texture_rectangle ? 2 : 0;
		1418	default:
		1419	_mesa_problem(ctx, "bad target in _mesa_tex_target_dimensions()");
		1420	return 0;
		1421	}
		1422	}
		1423
		1424
		1425	void
		1426	_mesa_GetTexLevelParameteriv( GLenum target, GLint level,
		1427	GLenum pname, GLint *params )
		1428	{
		1429	GET_CURRENT_CONTEXT(ctx);
		1430	const struct gl_texture_unit *texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
		1431	const struct gl_texture_image *img = NULL;
		1432	GLuint dimensions;
		1433	GLboolean isProxy;
		1434	GLint maxLevels;
		1435	ASSERT_OUTSIDE_BEGIN_END(ctx);
		1436
		1437	/* this will catch bad target values */
		1438	dimensions = tex_image_dimensions(ctx, target); /* 1, 2 or 3 */
		1439	if (dimensions == 0) {
		1440	_mesa_error(ctx, GL_INVALID_ENUM, "glGetTexLevelParameter[if]v(target)");
		1441	return;
		1442	}
		1443
		1444	switch (target) {
		1445	case GL_TEXTURE_1D:
		1446	case GL_PROXY_TEXTURE_1D:
		1447	case GL_TEXTURE_2D:
		1448	case GL_PROXY_TEXTURE_2D:
		1449	maxLevels = ctx->Const.MaxTextureLevels;
		1450	break;
		1451	case GL_TEXTURE_3D:
		1452	case GL_PROXY_TEXTURE_3D:
		1453	maxLevels = ctx->Const.Max3DTextureLevels;
		1454	break;
		1455	case GL_TEXTURE_CUBE_MAP_POSITIVE_X_ARB:
		1456	case GL_TEXTURE_CUBE_MAP_NEGATIVE_X_ARB:
		1457	case GL_TEXTURE_CUBE_MAP_POSITIVE_Y_ARB:
		1458	case GL_TEXTURE_CUBE_MAP_NEGATIVE_Y_ARB:
		1459	case GL_TEXTURE_CUBE_MAP_POSITIVE_Z_ARB:
		1460	case GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_ARB:
		1461	case GL_PROXY_TEXTURE_CUBE_MAP_ARB:
		1462	maxLevels = ctx->Const.MaxCubeTextureLevels;
		1463	break;
		1464	case GL_TEXTURE_RECTANGLE_NV:
		1465	case GL_PROXY_TEXTURE_RECTANGLE_NV:
		1466	maxLevels = 1;
		1467	break;
		1468	default:
		1469	_mesa_problem(ctx, "switch in _mesa_GetTexLevelParameter");
		1470	return;
		1471	}
		1472
		1473	if (level < 0 \|\| level >= maxLevels) {
		1474	_mesa_error( ctx, GL_INVALID_VALUE, "glGetTexLevelParameter[if]v" );
		1475	return;
		1476	}
		1477
		1478	img = _mesa_select_tex_image(ctx, texUnit, target, level);
		1479	if (!img \|\| !img->TexFormat) {
		1480	/* undefined texture image */
		1481	if (pname == GL_TEXTURE_COMPONENTS)
		1482	*params = 1;
		1483	else
		1484	*params = 0;
		1485	return;
		1486	}
		1487
		1488	isProxy = (target == GL_PROXY_TEXTURE_1D) \|\|
		1489	(target == GL_PROXY_TEXTURE_2D) \|\|
		1490	(target == GL_PROXY_TEXTURE_3D) \|\|
		1491	(target == GL_PROXY_TEXTURE_CUBE_MAP_ARB) \|\|
		1492	(target == GL_PROXY_TEXTURE_RECTANGLE_NV);
		1493
		1494	switch (pname) {
		1495	case GL_TEXTURE_WIDTH:
		1496	*params = img->Width;
		1497	return;
		1498	case GL_TEXTURE_HEIGHT:
		1499	*params = img->Height;
		1500	return;
		1501	case GL_TEXTURE_DEPTH:
		1502	*params = img->Depth;
		1503	return;
		1504	case GL_TEXTURE_INTERNAL_FORMAT:
		1505	*params = img->IntFormat;
		1506	return;
		1507	case GL_TEXTURE_BORDER:
		1508	*params = img->Border;
		1509	return;
		1510	case GL_TEXTURE_RED_SIZE:
		1511	if (img->Format == GL_RGB \|\| img->Format == GL_RGBA)
		1512	*params = img->TexFormat->RedBits;
		1513	else
		1514	*params = 0;
		1515	return;
		1516	case GL_TEXTURE_GREEN_SIZE:
		1517	if (img->Format == GL_RGB \|\| img->Format == GL_RGBA)
		1518	*params = img->TexFormat->GreenBits;
		1519	else
		1520	*params = 0;
		1521	return;
		1522	case GL_TEXTURE_BLUE_SIZE:
		1523	if (img->Format == GL_RGB \|\| img->Format == GL_RGBA)
		1524	*params = img->TexFormat->BlueBits;
		1525	else
		1526	*params = 0;
		1527	return;
		1528	case GL_TEXTURE_ALPHA_SIZE:
		1529	if (img->Format == GL_ALPHA \|\| img->Format == GL_LUMINANCE_ALPHA \|\|
		1530	img->Format == GL_RGBA)
		1531	*params = img->TexFormat->AlphaBits;
		1532	else
		1533	*params = 0;
		1534	return;
		1535	case GL_TEXTURE_INTENSITY_SIZE:
		1536	if (img->Format != GL_INTENSITY)
		1537	*params = 0;
		1538	else if (img->TexFormat->IntensityBits > 0)
		1539	*params = img->TexFormat->IntensityBits;
		1540	else /* intensity probably stored as rgb texture */
		1541	*params = MIN2(img->TexFormat->RedBits, img->TexFormat->GreenBits);
		1542	return;
		1543	case GL_TEXTURE_LUMINANCE_SIZE:
		1544	if (img->Format != GL_LUMINANCE &&
		1545	img->Format != GL_LUMINANCE_ALPHA)
		1546	*params = 0;
		1547	else if (img->TexFormat->LuminanceBits > 0)
		1548	*params = img->TexFormat->LuminanceBits;
		1549	else /* luminance probably stored as rgb texture */
		1550	*params = MIN2(img->TexFormat->RedBits, img->TexFormat->GreenBits);
		1551	return;
		1552	case GL_TEXTURE_INDEX_SIZE_EXT:
		1553	if (img->Format == GL_COLOR_INDEX)
		1554	*params = img->TexFormat->IndexBits;
		1555	else
		1556	*params = 0;
		1557	return;
		1558	case GL_DEPTH_BITS:
		1559	/* XXX this isn't in the GL_SGIX_depth_texture spec
		1560	* but seems appropriate.
		1561	*/
		1562	if (ctx->Extensions.SGIX_depth_texture)
		1563	*params = img->TexFormat->DepthBits;
		1564	else
		1565	_mesa_error(ctx, GL_INVALID_ENUM,
		1566	"glGetTexLevelParameter[if]v(pname)");
		1567	return;
		1568
		1569	/* GL_ARB_texture_compression */
		1570	case GL_TEXTURE_COMPRESSED_IMAGE_SIZE_ARB:
		1571	if (ctx->Extensions.ARB_texture_compression) {
		1572	if (img->IsCompressed && !isProxy)
		1573	*params = img->CompressedSize;
		1574	else
		1575	_mesa_error(ctx, GL_INVALID_OPERATION,
		1576	"glGetTexLevelParameter[if]v(pname)");
		1577	}
		1578	else {
		1579	_mesa_error(ctx, GL_INVALID_ENUM,
		1580	"glGetTexLevelParameter[if]v(pname)");
		1581	}
		1582	return;
		1583	case GL_TEXTURE_COMPRESSED_ARB:
		1584	if (ctx->Extensions.ARB_texture_compression) {
		1585	*params = (GLint) img->IsCompressed;
		1586	}
		1587	else {
		1588	_mesa_error(ctx, GL_INVALID_ENUM,
		1589	"glGetTexLevelParameter[if]v(pname)");
		1590	}
		1591	return;
		1592
		1593	default:
		1594	_mesa_error(ctx, GL_INVALID_ENUM,
		1595	"glGetTexLevelParameter[if]v(pname)");
		1596	}
		1597	}
		1598
		1599
		1600
		1601	void
		1602	_mesa_GetTexParameterfv( GLenum target, GLenum pname, GLfloat *params )
		1603	{
		1604	GET_CURRENT_CONTEXT(ctx);
		1605	struct gl_texture_unit *texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
		1606	struct gl_texture_object *obj;
		1607	ASSERT_OUTSIDE_BEGIN_END(ctx);
		1608
		1609	obj = _mesa_select_tex_object(ctx, texUnit, target);
		1610	if (!obj) {
		1611	_mesa_error(ctx, GL_INVALID_ENUM, "glGetTexParameterfv(target)");
		1612	return;
		1613	}
		1614
		1615	switch (pname) {
		1616	case GL_TEXTURE_MAG_FILTER:
		1617	*params = ENUM_TO_FLOAT(obj->MagFilter);
		1618	return;
		1619	case GL_TEXTURE_MIN_FILTER:
		1620	*params = ENUM_TO_FLOAT(obj->MinFilter);
		1621	return;
		1622	case GL_TEXTURE_WRAP_S:
		1623	*params = ENUM_TO_FLOAT(obj->WrapS);
		1624	return;
		1625	case GL_TEXTURE_WRAP_T:
		1626	*params = ENUM_TO_FLOAT(obj->WrapT);
		1627	return;
		1628	case GL_TEXTURE_WRAP_R_EXT:
		1629	*params = ENUM_TO_FLOAT(obj->WrapR);
		1630	return;
		1631	case GL_TEXTURE_BORDER_COLOR:
		1632	params[0] = CLAMP(obj->BorderColor[0], 0.0F, 1.0F);
		1633	params[1] = CLAMP(obj->BorderColor[1], 0.0F, 1.0F);
		1634	params[2] = CLAMP(obj->BorderColor[2], 0.0F, 1.0F);
		1635	params[3] = CLAMP(obj->BorderColor[3], 0.0F, 1.0F);
		1636	return;
		1637	case GL_TEXTURE_RESIDENT:
		1638	{
		1639	GLboolean resident;
		1640	if (ctx->Driver.IsTextureResident)
		1641	resident = ctx->Driver.IsTextureResident(ctx, obj);
		1642	else
		1643	resident = GL_TRUE;
		1644	*params = ENUM_TO_FLOAT(resident);
		1645	}
		1646	return;
		1647	case GL_TEXTURE_PRIORITY:
		1648	*params = obj->Priority;
		1649	return;
		1650	case GL_TEXTURE_MIN_LOD:
		1651	*params = obj->MinLod;
		1652	return;
		1653	case GL_TEXTURE_MAX_LOD:
		1654	*params = obj->MaxLod;
		1655	return;
		1656	case GL_TEXTURE_BASE_LEVEL:
		1657	*params = (GLfloat) obj->BaseLevel;
		1658	return;
		1659	case GL_TEXTURE_MAX_LEVEL:
		1660	*params = (GLfloat) obj->MaxLevel;
		1661	return;
		1662	case GL_TEXTURE_MAX_ANISOTROPY_EXT:
		1663	if (ctx->Extensions.EXT_texture_filter_anisotropic) {
		1664	*params = obj->MaxAnisotropy;
		1665	return;
		1666	}
		1667	break;
		1668	case GL_TEXTURE_COMPARE_SGIX:
		1669	if (ctx->Extensions.SGIX_shadow) {
		1670	*params = (GLfloat) obj->CompareFlag;
		1671	return;
		1672	}
		1673	break;
		1674	case GL_TEXTURE_COMPARE_OPERATOR_SGIX:
		1675	if (ctx->Extensions.SGIX_shadow) {
		1676	*params = (GLfloat) obj->CompareOperator;
		1677	return;
		1678	}
		1679	break;
		1680	case GL_SHADOW_AMBIENT_SGIX: /* aka GL_TEXTURE_COMPARE_FAIL_VALUE_ARB */
		1681	if (ctx->Extensions.SGIX_shadow_ambient) {
		1682	*params = obj->ShadowAmbient;
		1683	return;
		1684	}
		1685	break;
		1686	case GL_GENERATE_MIPMAP_SGIS:
		1687	if (ctx->Extensions.SGIS_generate_mipmap) {
		1688	*params = (GLfloat) obj->GenerateMipmap;
		1689	return;
		1690	}
		1691	break;
		1692	case GL_TEXTURE_COMPARE_MODE_ARB:
		1693	if (ctx->Extensions.ARB_shadow) {
		1694	*params = (GLfloat) obj->CompareMode;
		1695	return;
		1696	}
		1697	break;
		1698	case GL_TEXTURE_COMPARE_FUNC_ARB:
		1699	if (ctx->Extensions.ARB_shadow) {
		1700	*params = (GLfloat) obj->CompareFunc;
		1701	return;
		1702	}
		1703	break;
		1704	case GL_DEPTH_TEXTURE_MODE_ARB:
		1705	if (ctx->Extensions.ARB_depth_texture) {
		1706	*params = (GLfloat) obj->DepthMode;
		1707	return;
		1708	}
		1709	break;
		1710	default:
		1711	; /* silence warnings */
		1712	}
		1713	/* If we get here, pname was an unrecognized enum */
		1714	_mesa_error( ctx, GL_INVALID_ENUM, "glGetTexParameterfv(pname)" );
		1715	}
		1716
		1717
		1718	void
		1719	_mesa_GetTexParameteriv( GLenum target, GLenum pname, GLint *params )
		1720	{
		1721	GET_CURRENT_CONTEXT(ctx);
		1722	struct gl_texture_unit *texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
		1723	struct gl_texture_object *obj;
		1724	ASSERT_OUTSIDE_BEGIN_END(ctx);
		1725
		1726	obj = _mesa_select_tex_object(ctx, texUnit, target);
		1727	if (!obj) {
		1728	_mesa_error(ctx, GL_INVALID_ENUM, "glGetTexParameteriv(target)");
		1729	return;
		1730	}
		1731
		1732	switch (pname) {
		1733	case GL_TEXTURE_MAG_FILTER:
		1734	*params = (GLint) obj->MagFilter;
		1735	return;
		1736	case GL_TEXTURE_MIN_FILTER:
		1737	*params = (GLint) obj->MinFilter;
		1738	return;
		1739	case GL_TEXTURE_WRAP_S:
		1740	*params = (GLint) obj->WrapS;
		1741	return;
		1742	case GL_TEXTURE_WRAP_T:
		1743	*params = (GLint) obj->WrapT;
		1744	return;
		1745	case GL_TEXTURE_WRAP_R_EXT:
		1746	*params = (GLint) obj->WrapR;
		1747	return;
		1748	case GL_TEXTURE_BORDER_COLOR:
		1749	{
		1750	GLfloat b[4];
		1751	b[0] = CLAMP(obj->BorderColor[0], 0.0F, 1.0F);
		1752	b[1] = CLAMP(obj->BorderColor[1], 0.0F, 1.0F);
		1753	b[2] = CLAMP(obj->BorderColor[2], 0.0F, 1.0F);
		1754	b[3] = CLAMP(obj->BorderColor[3], 0.0F, 1.0F);
		1755	params[0] = FLOAT_TO_INT(b[0]);
		1756	params[1] = FLOAT_TO_INT(b[1]);
		1757	params[2] = FLOAT_TO_INT(b[2]);
		1758	params[3] = FLOAT_TO_INT(b[3]);
		1759	}
		1760	return;
		1761	case GL_TEXTURE_RESIDENT:
		1762	{
		1763	GLboolean resident;
		1764	if (ctx->Driver.IsTextureResident)
		1765	resident = ctx->Driver.IsTextureResident(ctx, obj);
		1766	else
		1767	resident = GL_TRUE;
		1768	*params = (GLint) resident;
		1769	}
		1770	return;
		1771	case GL_TEXTURE_PRIORITY:
		1772	*params = (GLint) obj->Priority;
		1773	return;
		1774	case GL_TEXTURE_MIN_LOD:
		1775	*params = (GLint) obj->MinLod;
		1776	return;
		1777	case GL_TEXTURE_MAX_LOD:
		1778	*params = (GLint) obj->MaxLod;
		1779	return;
		1780	case GL_TEXTURE_BASE_LEVEL:
		1781	*params = obj->BaseLevel;
		1782	return;
		1783	case GL_TEXTURE_MAX_LEVEL:
		1784	*params = obj->MaxLevel;
		1785	return;
		1786	case GL_TEXTURE_MAX_ANISOTROPY_EXT:
		1787	if (ctx->Extensions.EXT_texture_filter_anisotropic) {
		1788	*params = (GLint) obj->MaxAnisotropy;
		1789	return;
		1790	}
		1791	break;
		1792	case GL_TEXTURE_COMPARE_SGIX:
		1793	if (ctx->Extensions.SGIX_shadow) {
		1794	*params = (GLint) obj->CompareFlag;
		1795	return;
		1796	}
		1797	break;
		1798	case GL_TEXTURE_COMPARE_OPERATOR_SGIX:
		1799	if (ctx->Extensions.SGIX_shadow) {
		1800	*params = (GLint) obj->CompareOperator;
		1801	return;
		1802	}
		1803	break;
		1804	case GL_SHADOW_AMBIENT_SGIX: /* aka GL_TEXTURE_COMPARE_FAIL_VALUE_ARB */
		1805	if (ctx->Extensions.SGIX_shadow_ambient) {
		1806	*params = (GLint) FLOAT_TO_INT(obj->ShadowAmbient);
		1807	return;
		1808	}
		1809	break;
		1810	case GL_GENERATE_MIPMAP_SGIS:
		1811	if (ctx->Extensions.SGIS_generate_mipmap) {
		1812	*params = (GLint) obj->GenerateMipmap;
		1813	return;
		1814	}
		1815	break;
		1816	case GL_TEXTURE_COMPARE_MODE_ARB:
		1817	if (ctx->Extensions.ARB_shadow) {
		1818	*params = (GLint) obj->CompareMode;
		1819	return;
		1820	}
		1821	break;
		1822	case GL_TEXTURE_COMPARE_FUNC_ARB:
		1823	if (ctx->Extensions.ARB_shadow) {
		1824	*params = (GLint) obj->CompareFunc;
		1825	return;
		1826	}
		1827	break;
		1828	case GL_DEPTH_TEXTURE_MODE_ARB:
		1829	if (ctx->Extensions.ARB_depth_texture) {
		1830	*params = (GLint) obj->DepthMode;
		1831	return;
		1832	}
		1833	break;
		1834	default:
		1835	; /* silence warnings */
		1836	}
		1837	/* If we get here, pname was an unrecognized enum */
		1838	_mesa_error( ctx, GL_INVALID_ENUM, "glGetTexParameteriv(pname)" );
		1839	}
		1840
		1841
		1842
		1843
		1844	/**********************************************************************/
		1845	/* Texture Coord Generation */
		1846	/**********************************************************************/
		1847
		1848
		1849	void
		1850	_mesa_TexGenfv( GLenum coord, GLenum pname, const GLfloat *params )
		1851	{
		1852	GET_CURRENT_CONTEXT(ctx);
		1853	GLuint tUnit = ctx->Texture.CurrentUnit;
		1854	struct gl_texture_unit *texUnit = &ctx->Texture.Unit[tUnit];
		1855	ASSERT_OUTSIDE_BEGIN_END(ctx);
		1856
		1857	if (MESA_VERBOSE&(VERBOSE_API\|VERBOSE_TEXTURE))
		1858	_mesa_debug(ctx, "texGEN %s %s %x...\n",
		1859	_mesa_lookup_enum_by_nr(coord),
		1860	_mesa_lookup_enum_by_nr(pname),
		1861	(int )params);
		1862
		1863	switch (coord) {
		1864	case GL_S:
		1865	if (pname==GL_TEXTURE_GEN_MODE) {
		1866	GLenum mode = (GLenum) (GLint) *params;
		1867	GLuint bits;
		1868	switch (mode) {
		1869	case GL_OBJECT_LINEAR:
		1870	bits = TEXGEN_OBJ_LINEAR;
		1871	break;
		1872	case GL_EYE_LINEAR:
		1873	bits = TEXGEN_EYE_LINEAR;
		1874	break;
		1875	case GL_REFLECTION_MAP_NV:
		1876	bits = TEXGEN_REFLECTION_MAP_NV;
		1877	break;
		1878	case GL_NORMAL_MAP_NV:
		1879	bits = TEXGEN_NORMAL_MAP_NV;
		1880	break;
		1881	case GL_SPHERE_MAP:
		1882	bits = TEXGEN_SPHERE_MAP;
		1883	break;
		1884	default:
		1885	_mesa_error( ctx, GL_INVALID_ENUM, "glTexGenfv(param)" );
		1886	return;
		1887	}
		1888	if (texUnit->GenModeS == mode)
		1889	return;
		1890	FLUSH_VERTICES(ctx, _NEW_TEXTURE);
		1891	texUnit->GenModeS = mode;
		1892	texUnit->_GenBitS = bits;
		1893	}
		1894	else if (pname==GL_OBJECT_PLANE) {
		1895	if (TEST_EQ_4V(texUnit->ObjectPlaneS, params))
		1896	return;
		1897	FLUSH_VERTICES(ctx, _NEW_TEXTURE);
		1898	texUnit->ObjectPlaneS[0] = params[0];
		1899	texUnit->ObjectPlaneS[1] = params[1];
		1900	texUnit->ObjectPlaneS[2] = params[2];
		1901	texUnit->ObjectPlaneS[3] = params[3];
		1902	}
		1903	else if (pname==GL_EYE_PLANE) {
		1904	GLfloat tmp[4];
		1905
		1906	/* Transform plane equation by the inverse modelview matrix */
		1907	if (ctx->ModelviewMatrixStack.Top->flags & MAT_DIRTY_INVERSE) {
		1908	_math_matrix_analyse( ctx->ModelviewMatrixStack.Top );
		1909	}
		1910	_mesa_transform_vector( tmp, params, ctx->ModelviewMatrixStack.Top->inv );
		1911	if (TEST_EQ_4V(texUnit->EyePlaneS, tmp))
		1912	return;
		1913	FLUSH_VERTICES(ctx, _NEW_TEXTURE);
		1914	COPY_4FV(texUnit->EyePlaneS, tmp);
		1915	}
		1916	else {
		1917	_mesa_error( ctx, GL_INVALID_ENUM, "glTexGenfv(pname)" );
		1918	return;
		1919	}
		1920	break;
		1921	case GL_T:
		1922	if (pname==GL_TEXTURE_GEN_MODE) {
		1923	GLenum mode = (GLenum) (GLint) *params;
		1924	GLuint bitt;
		1925	switch (mode) {
		1926	case GL_OBJECT_LINEAR:
		1927	bitt = TEXGEN_OBJ_LINEAR;
		1928	break;
		1929	case GL_EYE_LINEAR:
		1930	bitt = TEXGEN_EYE_LINEAR;
		1931	break;
		1932	case GL_REFLECTION_MAP_NV:
		1933	bitt = TEXGEN_REFLECTION_MAP_NV;
		1934	break;
		1935	case GL_NORMAL_MAP_NV:
		1936	bitt = TEXGEN_NORMAL_MAP_NV;
		1937	break;
		1938	case GL_SPHERE_MAP:
		1939	bitt = TEXGEN_SPHERE_MAP;
		1940	break;
		1941	default:
		1942	_mesa_error( ctx, GL_INVALID_ENUM, "glTexGenfv(param)" );
		1943	return;
		1944	}
		1945	if (texUnit->GenModeT == mode)
		1946	return;
		1947	FLUSH_VERTICES(ctx, _NEW_TEXTURE);
		1948	texUnit->GenModeT = mode;
		1949	texUnit->_GenBitT = bitt;
		1950	}
		1951	else if (pname==GL_OBJECT_PLANE) {
		1952	if (TEST_EQ_4V(texUnit->ObjectPlaneT, params))
		1953	return;
		1954	FLUSH_VERTICES(ctx, _NEW_TEXTURE);
		1955	texUnit->ObjectPlaneT[0] = params[0];
		1956	texUnit->ObjectPlaneT[1] = params[1];
		1957	texUnit->ObjectPlaneT[2] = params[2];
		1958	texUnit->ObjectPlaneT[3] = params[3];
		1959	}
		1960	else if (pname==GL_EYE_PLANE) {
		1961	GLfloat tmp[4];
		1962	/* Transform plane equation by the inverse modelview matrix */
		1963	if (ctx->ModelviewMatrixStack.Top->flags & MAT_DIRTY_INVERSE) {
		1964	_math_matrix_analyse( ctx->ModelviewMatrixStack.Top );
		1965	}
		1966	_mesa_transform_vector( tmp, params, ctx->ModelviewMatrixStack.Top->inv );
		1967	if (TEST_EQ_4V(texUnit->EyePlaneT, tmp))
		1968	return;
		1969	FLUSH_VERTICES(ctx, _NEW_TEXTURE);
		1970	COPY_4FV(texUnit->EyePlaneT, tmp);
		1971	}
		1972	else {
		1973	_mesa_error( ctx, GL_INVALID_ENUM, "glTexGenfv(pname)" );
		1974	return;
		1975	}
		1976	break;
		1977	case GL_R:
		1978	if (pname==GL_TEXTURE_GEN_MODE) {
		1979	GLenum mode = (GLenum) (GLint) *params;
		1980	GLuint bitr;
		1981	switch (mode) {
		1982	case GL_OBJECT_LINEAR:
		1983	bitr = TEXGEN_OBJ_LINEAR;
		1984	break;
		1985	case GL_REFLECTION_MAP_NV:
		1986	bitr = TEXGEN_REFLECTION_MAP_NV;
		1987	break;
		1988	case GL_NORMAL_MAP_NV:
		1989	bitr = TEXGEN_NORMAL_MAP_NV;
		1990	break;
		1991	case GL_EYE_LINEAR:
		1992	bitr = TEXGEN_EYE_LINEAR;
		1993	break;
		1994	default:
		1995	_mesa_error( ctx, GL_INVALID_ENUM, "glTexGenfv(param)" );
		1996	return;
		1997	}
		1998	if (texUnit->GenModeR == mode)
		1999	return;
		2000	FLUSH_VERTICES(ctx, _NEW_TEXTURE);
		2001	texUnit->GenModeR = mode;
		2002	texUnit->_GenBitR = bitr;
		2003	}
		2004	else if (pname==GL_OBJECT_PLANE) {
		2005	if (TEST_EQ_4V(texUnit->ObjectPlaneR, params))
		2006	return;
		2007	FLUSH_VERTICES(ctx, _NEW_TEXTURE);
		2008	texUnit->ObjectPlaneR[0] = params[0];
		2009	texUnit->ObjectPlaneR[1] = params[1];
		2010	texUnit->ObjectPlaneR[2] = params[2];
		2011	texUnit->ObjectPlaneR[3] = params[3];
		2012	}
		2013	else if (pname==GL_EYE_PLANE) {
		2014	GLfloat tmp[4];
		2015	/* Transform plane equation by the inverse modelview matrix */
		2016	if (ctx->ModelviewMatrixStack.Top->flags & MAT_DIRTY_INVERSE) {
		2017	_math_matrix_analyse( ctx->ModelviewMatrixStack.Top );
		2018	}
		2019	_mesa_transform_vector( tmp, params, ctx->ModelviewMatrixStack.Top->inv );
		2020	if (TEST_EQ_4V(texUnit->EyePlaneR, tmp))
		2021	return;
		2022	FLUSH_VERTICES(ctx, _NEW_TEXTURE);
		2023	COPY_4FV(texUnit->EyePlaneR, tmp);
		2024	}
		2025	else {
		2026	_mesa_error( ctx, GL_INVALID_ENUM, "glTexGenfv(pname)" );
		2027	return;
		2028	}
		2029	break;
		2030	case GL_Q:
		2031	if (pname==GL_TEXTURE_GEN_MODE) {
		2032	GLenum mode = (GLenum) (GLint) *params;
		2033	GLuint bitq;
		2034	switch (mode) {
		2035	case GL_OBJECT_LINEAR:
		2036	bitq = TEXGEN_OBJ_LINEAR;
		2037	break;
		2038	case GL_EYE_LINEAR:
		2039	bitq = TEXGEN_EYE_LINEAR;
		2040	break;
		2041	default:
		2042	_mesa_error( ctx, GL_INVALID_ENUM, "glTexGenfv(param)" );
		2043	return;
		2044	}
		2045	if (texUnit->GenModeQ == mode)
		2046	return;
		2047	FLUSH_VERTICES(ctx, _NEW_TEXTURE);
		2048	texUnit->GenModeQ = mode;
		2049	texUnit->_GenBitQ = bitq;
		2050	}
		2051	else if (pname==GL_OBJECT_PLANE) {
		2052	if (TEST_EQ_4V(texUnit->ObjectPlaneQ, params))
		2053	return;
		2054	FLUSH_VERTICES(ctx, _NEW_TEXTURE);
		2055	texUnit->ObjectPlaneQ[0] = params[0];
		2056	texUnit->ObjectPlaneQ[1] = params[1];
		2057	texUnit->ObjectPlaneQ[2] = params[2];
		2058	texUnit->ObjectPlaneQ[3] = params[3];
		2059	}
		2060	else if (pname==GL_EYE_PLANE) {
		2061	GLfloat tmp[4];
		2062	/* Transform plane equation by the inverse modelview matrix */
		2063	if (ctx->ModelviewMatrixStack.Top->flags & MAT_DIRTY_INVERSE) {
		2064	_math_matrix_analyse( ctx->ModelviewMatrixStack.Top );
		2065	}
		2066	_mesa_transform_vector( tmp, params, ctx->ModelviewMatrixStack.Top->inv );
		2067	if (TEST_EQ_4V(texUnit->EyePlaneQ, tmp))
		2068	return;
		2069	FLUSH_VERTICES(ctx, _NEW_TEXTURE);
		2070	COPY_4FV(texUnit->EyePlaneQ, tmp);
		2071	}
		2072	else {
		2073	_mesa_error( ctx, GL_INVALID_ENUM, "glTexGenfv(pname)" );
		2074	return;
		2075	}
		2076	break;
		2077	default:
		2078	_mesa_error( ctx, GL_INVALID_ENUM, "glTexGenfv(coord)" );
		2079	return;
		2080	}
		2081
		2082	if (ctx->Driver.TexGen)
		2083	ctx->Driver.TexGen( ctx, coord, pname, params );
		2084	}
		2085
		2086
		2087	void
		2088	_mesa_TexGeniv(GLenum coord, GLenum pname, const GLint *params )
		2089	{
		2090	GLfloat p[4];
		2091	p[0] = (GLfloat) params[0];
		2092	p[1] = (GLfloat) params[1];
		2093	p[2] = (GLfloat) params[2];
		2094	p[3] = (GLfloat) params[3];
		2095	_mesa_TexGenfv(coord, pname, p);
		2096	}
		2097
		2098
		2099	void
		2100	_mesa_TexGend(GLenum coord, GLenum pname, GLdouble param )
		2101	{
		2102	GLfloat p = (GLfloat) param;
		2103	_mesa_TexGenfv( coord, pname, &p );
		2104	}
		2105
		2106
		2107	void
		2108	_mesa_TexGendv(GLenum coord, GLenum pname, const GLdouble *params )
		2109	{
		2110	GLfloat p[4];
		2111	p[0] = (GLfloat) params[0];
		2112	p[1] = (GLfloat) params[1];
		2113	p[2] = (GLfloat) params[2];
		2114	p[3] = (GLfloat) params[3];
		2115	_mesa_TexGenfv( coord, pname, p );
		2116	}
		2117
		2118
		2119	void
		2120	_mesa_TexGenf( GLenum coord, GLenum pname, GLfloat param )
		2121	{
		2122	_mesa_TexGenfv(coord, pname, &param);
		2123	}
		2124
		2125
		2126	void
		2127	_mesa_TexGeni( GLenum coord, GLenum pname, GLint param )
		2128	{
		2129	_mesa_TexGeniv( coord, pname, &param );
		2130	}
		2131
		2132
		2133
		2134	void
		2135	_mesa_GetTexGendv( GLenum coord, GLenum pname, GLdouble *params )
		2136	{
		2137	GET_CURRENT_CONTEXT(ctx);
		2138	GLuint tUnit = ctx->Texture.CurrentUnit;
		2139	struct gl_texture_unit *texUnit = &ctx->Texture.Unit[tUnit];
		2140	ASSERT_OUTSIDE_BEGIN_END(ctx);
		2141
		2142	switch (coord) {
		2143	case GL_S:
		2144	if (pname==GL_TEXTURE_GEN_MODE) {
		2145	params[0] = ENUM_TO_DOUBLE(texUnit->GenModeS);
		2146	}
		2147	else if (pname==GL_OBJECT_PLANE) {
		2148	COPY_4V( params, texUnit->ObjectPlaneS );
		2149	}
		2150	else if (pname==GL_EYE_PLANE) {
		2151	COPY_4V( params, texUnit->EyePlaneS );
		2152	}
		2153	else {
		2154	_mesa_error( ctx, GL_INVALID_ENUM, "glGetTexGendv(pname)" );
		2155	return;
		2156	}
		2157	break;
		2158	case GL_T:
		2159	if (pname==GL_TEXTURE_GEN_MODE) {
		2160	params[0] = ENUM_TO_DOUBLE(texUnit->GenModeT);
		2161	}
		2162	else if (pname==GL_OBJECT_PLANE) {
		2163	COPY_4V( params, texUnit->ObjectPlaneT );
		2164	}
		2165	else if (pname==GL_EYE_PLANE) {
		2166	COPY_4V( params, texUnit->EyePlaneT );
		2167	}
		2168	else {
		2169	_mesa_error( ctx, GL_INVALID_ENUM, "glGetTexGendv(pname)" );
		2170	return;
		2171	}
		2172	break;
		2173	case GL_R:
		2174	if (pname==GL_TEXTURE_GEN_MODE) {
		2175	params[0] = ENUM_TO_DOUBLE(texUnit->GenModeR);
		2176	}
		2177	else if (pname==GL_OBJECT_PLANE) {
		2178	COPY_4V( params, texUnit->ObjectPlaneR );
		2179	}
		2180	else if (pname==GL_EYE_PLANE) {
		2181	COPY_4V( params, texUnit->EyePlaneR );
		2182	}
		2183	else {
		2184	_mesa_error( ctx, GL_INVALID_ENUM, "glGetTexGendv(pname)" );
		2185	return;
		2186	}
		2187	break;
		2188	case GL_Q:
		2189	if (pname==GL_TEXTURE_GEN_MODE) {
		2190	params[0] = ENUM_TO_DOUBLE(texUnit->GenModeQ);
		2191	}
		2192	else if (pname==GL_OBJECT_PLANE) {
		2193	COPY_4V( params, texUnit->ObjectPlaneQ );
		2194	}
		2195	else if (pname==GL_EYE_PLANE) {
		2196	COPY_4V( params, texUnit->EyePlaneQ );
		2197	}
		2198	else {
		2199	_mesa_error( ctx, GL_INVALID_ENUM, "glGetTexGendv(pname)" );
		2200	return;
		2201	}
		2202	break;
		2203	default:
		2204	_mesa_error( ctx, GL_INVALID_ENUM, "glGetTexGendv(coord)" );
		2205	return;
		2206	}
		2207	}
		2208
		2209
		2210
		2211	void
		2212	_mesa_GetTexGenfv( GLenum coord, GLenum pname, GLfloat *params )
		2213	{
		2214	GET_CURRENT_CONTEXT(ctx);
		2215	GLuint tUnit = ctx->Texture.CurrentUnit;
		2216	struct gl_texture_unit *texUnit = &ctx->Texture.Unit[tUnit];
		2217	ASSERT_OUTSIDE_BEGIN_END(ctx);
		2218
		2219	switch (coord) {
		2220	case GL_S:
		2221	if (pname==GL_TEXTURE_GEN_MODE) {
		2222	params[0] = ENUM_TO_FLOAT(texUnit->GenModeS);
		2223	}
		2224	else if (pname==GL_OBJECT_PLANE) {
		2225	COPY_4V( params, texUnit->ObjectPlaneS );
		2226	}
		2227	else if (pname==GL_EYE_PLANE) {
		2228	COPY_4V( params, texUnit->EyePlaneS );
		2229	}
		2230	else {
		2231	_mesa_error( ctx, GL_INVALID_ENUM, "glGetTexGenfv(pname)" );
		2232	return;
		2233	}
		2234	break;
		2235	case GL_T:
		2236	if (pname==GL_TEXTURE_GEN_MODE) {
		2237	params[0] = ENUM_TO_FLOAT(texUnit->GenModeT);
		2238	}
		2239	else if (pname==GL_OBJECT_PLANE) {
		2240	COPY_4V( params, texUnit->ObjectPlaneT );
		2241	}
		2242	else if (pname==GL_EYE_PLANE) {
		2243	COPY_4V( params, texUnit->EyePlaneT );
		2244	}
		2245	else {
		2246	_mesa_error( ctx, GL_INVALID_ENUM, "glGetTexGenfv(pname)" );
		2247	return;
		2248	}
		2249	break;
		2250	case GL_R:
		2251	if (pname==GL_TEXTURE_GEN_MODE) {
		2252	params[0] = ENUM_TO_FLOAT(texUnit->GenModeR);
		2253	}
		2254	else if (pname==GL_OBJECT_PLANE) {
		2255	COPY_4V( params, texUnit->ObjectPlaneR );
		2256	}
		2257	else if (pname==GL_EYE_PLANE) {
		2258	COPY_4V( params, texUnit->EyePlaneR );
		2259	}
		2260	else {
		2261	_mesa_error( ctx, GL_INVALID_ENUM, "glGetTexGenfv(pname)" );
		2262	return;
		2263	}
		2264	break;
		2265	case GL_Q:
		2266	if (pname==GL_TEXTURE_GEN_MODE) {
		2267	params[0] = ENUM_TO_FLOAT(texUnit->GenModeQ);
		2268	}
		2269	else if (pname==GL_OBJECT_PLANE) {
		2270	COPY_4V( params, texUnit->ObjectPlaneQ );
		2271	}
		2272	else if (pname==GL_EYE_PLANE) {
		2273	COPY_4V( params, texUnit->EyePlaneQ );
		2274	}
		2275	else {
		2276	_mesa_error( ctx, GL_INVALID_ENUM, "glGetTexGenfv(pname)" );
		2277	return;
		2278	}
		2279	break;
		2280	default:
		2281	_mesa_error( ctx, GL_INVALID_ENUM, "glGetTexGenfv(coord)" );
		2282	return;
		2283	}
		2284	}
		2285
		2286
		2287
		2288	void
		2289	_mesa_GetTexGeniv( GLenum coord, GLenum pname, GLint *params )
		2290	{
		2291	GET_CURRENT_CONTEXT(ctx);
		2292	GLuint tUnit = ctx->Texture.CurrentUnit;
		2293	struct gl_texture_unit *texUnit = &ctx->Texture.Unit[tUnit];
		2294	ASSERT_OUTSIDE_BEGIN_END(ctx);
		2295
		2296	switch (coord) {
		2297	case GL_S:
		2298	if (pname==GL_TEXTURE_GEN_MODE) {
		2299	params[0] = texUnit->GenModeS;
		2300	}
		2301	else if (pname==GL_OBJECT_PLANE) {
		2302	params[0] = (GLint) texUnit->ObjectPlaneS[0];
		2303	params[1] = (GLint) texUnit->ObjectPlaneS[1];
		2304	params[2] = (GLint) texUnit->ObjectPlaneS[2];
		2305	params[3] = (GLint) texUnit->ObjectPlaneS[3];
		2306	}
		2307	else if (pname==GL_EYE_PLANE) {
		2308	params[0] = (GLint) texUnit->EyePlaneS[0];
		2309	params[1] = (GLint) texUnit->EyePlaneS[1];
		2310	params[2] = (GLint) texUnit->EyePlaneS[2];
		2311	params[3] = (GLint) texUnit->EyePlaneS[3];
		2312	}
		2313	else {
		2314	_mesa_error( ctx, GL_INVALID_ENUM, "glGetTexGeniv(pname)" );
		2315	return;
		2316	}
		2317	break;
		2318	case GL_T:
		2319	if (pname==GL_TEXTURE_GEN_MODE) {
		2320	params[0] = texUnit->GenModeT;
		2321	}
		2322	else if (pname==GL_OBJECT_PLANE) {
		2323	params[0] = (GLint) texUnit->ObjectPlaneT[0];
		2324	params[1] = (GLint) texUnit->ObjectPlaneT[1];
		2325	params[2] = (GLint) texUnit->ObjectPlaneT[2];
		2326	params[3] = (GLint) texUnit->ObjectPlaneT[3];
		2327	}
		2328	else if (pname==GL_EYE_PLANE) {
		2329	params[0] = (GLint) texUnit->EyePlaneT[0];
		2330	params[1] = (GLint) texUnit->EyePlaneT[1];
		2331	params[2] = (GLint) texUnit->EyePlaneT[2];
		2332	params[3] = (GLint) texUnit->EyePlaneT[3];
		2333	}
		2334	else {
		2335	_mesa_error( ctx, GL_INVALID_ENUM, "glGetTexGeniv(pname)" );
		2336	return;
		2337	}
		2338	break;
		2339	case GL_R:
		2340	if (pname==GL_TEXTURE_GEN_MODE) {
		2341	params[0] = texUnit->GenModeR;
		2342	}
		2343	else if (pname==GL_OBJECT_PLANE) {
		2344	params[0] = (GLint) texUnit->ObjectPlaneR[0];
		2345	params[1] = (GLint) texUnit->ObjectPlaneR[1];
		2346	params[2] = (GLint) texUnit->ObjectPlaneR[2];
		2347	params[3] = (GLint) texUnit->ObjectPlaneR[3];
		2348	}
		2349	else if (pname==GL_EYE_PLANE) {
		2350	params[0] = (GLint) texUnit->EyePlaneR[0];
		2351	params[1] = (GLint) texUnit->EyePlaneR[1];
		2352	params[2] = (GLint) texUnit->EyePlaneR[2];
		2353	params[3] = (GLint) texUnit->EyePlaneR[3];
		2354	}
		2355	else {
		2356	_mesa_error( ctx, GL_INVALID_ENUM, "glGetTexGeniv(pname)" );
		2357	return;
		2358	}
		2359	break;
		2360	case GL_Q:
		2361	if (pname==GL_TEXTURE_GEN_MODE) {
		2362	params[0] = texUnit->GenModeQ;
		2363	}
		2364	else if (pname==GL_OBJECT_PLANE) {
		2365	params[0] = (GLint) texUnit->ObjectPlaneQ[0];
		2366	params[1] = (GLint) texUnit->ObjectPlaneQ[1];
		2367	params[2] = (GLint) texUnit->ObjectPlaneQ[2];
		2368	params[3] = (GLint) texUnit->ObjectPlaneQ[3];
		2369	}
		2370	else if (pname==GL_EYE_PLANE) {
		2371	params[0] = (GLint) texUnit->EyePlaneQ[0];
		2372	params[1] = (GLint) texUnit->EyePlaneQ[1];
		2373	params[2] = (GLint) texUnit->EyePlaneQ[2];
		2374	params[3] = (GLint) texUnit->EyePlaneQ[3];
		2375	}
		2376	else {
		2377	_mesa_error( ctx, GL_INVALID_ENUM, "glGetTexGeniv(pname)" );
		2378	return;
		2379	}
		2380	break;
		2381	default:
		2382	_mesa_error( ctx, GL_INVALID_ENUM, "glGetTexGeniv(coord)" );
		2383	return;
		2384	}
		2385	}
		2386
		2387
		2388	/* GL_ARB_multitexture */
		2389	void
		2390	_mesa_ActiveTextureARB( GLenum target )
		2391	{
		2392	GET_CURRENT_CONTEXT(ctx);
		2393	GLuint texUnit = target - GL_TEXTURE0_ARB;
		2394	ASSERT_OUTSIDE_BEGIN_END(ctx);
		2395
		2396	if (MESA_VERBOSE & (VERBOSE_API\|VERBOSE_TEXTURE))
		2397	_mesa_debug(ctx, "glActiveTexture %s\n",
		2398	_mesa_lookup_enum_by_nr(target));
		2399
		2400	if (texUnit > ctx->Const.MaxTextureUnits) {
		2401	_mesa_error(ctx, GL_INVALID_ENUM, "glActiveTextureARB(target)");
		2402	return;
		2403	}
		2404
		2405	FLUSH_VERTICES(ctx, _NEW_TEXTURE);
		2406	ctx->Texture.CurrentUnit = texUnit;
		2407	if (ctx->Driver.ActiveTexture) {
		2408	(*ctx->Driver.ActiveTexture)( ctx, (GLuint) texUnit );
		2409	}
		2410	}
		2411
		2412
		2413	/* GL_ARB_multitexture */
		2414	void
		2415	_mesa_ClientActiveTextureARB( GLenum target )
		2416	{
		2417	GET_CURRENT_CONTEXT(ctx);
		2418	GLuint texUnit = target - GL_TEXTURE0_ARB;
		2419	ASSERT_OUTSIDE_BEGIN_END(ctx);
		2420
		2421	if (texUnit > ctx->Const.MaxTextureUnits) {
		2422	_mesa_error(ctx, GL_INVALID_ENUM, "glClientActiveTextureARB(target)");
		2423	return;
		2424	}
		2425
		2426	FLUSH_VERTICES(ctx, _NEW_ARRAY);
		2427	ctx->Array.ActiveTexture = texUnit;
		2428	}
		2429
		2430
		2431
		2432	/**********************************************************************/
		2433	/* Pixel Texgen Extensions */
		2434	/**********************************************************************/
		2435
		2436	void
		2437	_mesa_PixelTexGenSGIX(GLenum mode)
		2438	{
		2439	GLenum newRgbSource, newAlphaSource;
		2440	GET_CURRENT_CONTEXT(ctx);
		2441	ASSERT_OUTSIDE_BEGIN_END(ctx);
		2442
		2443	switch (mode) {
		2444	case GL_NONE:
		2445	newRgbSource = GL_PIXEL_GROUP_COLOR_SGIS;
		2446	newAlphaSource = GL_PIXEL_GROUP_COLOR_SGIS;
		2447	break;
		2448	case GL_ALPHA:
		2449	newRgbSource = GL_PIXEL_GROUP_COLOR_SGIS;
		2450	newAlphaSource = GL_CURRENT_RASTER_COLOR;
		2451	break;
		2452	case GL_RGB:
		2453	newRgbSource = GL_CURRENT_RASTER_COLOR;
		2454	newAlphaSource = GL_PIXEL_GROUP_COLOR_SGIS;
		2455	break;
		2456	case GL_RGBA:
		2457	newRgbSource = GL_CURRENT_RASTER_COLOR;
		2458	newAlphaSource = GL_CURRENT_RASTER_COLOR;
		2459	break;
		2460	default:
		2461	_mesa_error(ctx, GL_INVALID_ENUM, "glPixelTexGenSGIX(mode)");
		2462	return;
		2463	}
		2464
		2465	if (newRgbSource == ctx->Pixel.FragmentRgbSource &&
		2466	newAlphaSource == ctx->Pixel.FragmentAlphaSource)
		2467	return;
		2468
		2469	FLUSH_VERTICES(ctx, _NEW_PIXEL);
		2470	ctx->Pixel.FragmentRgbSource = newRgbSource;
		2471	ctx->Pixel.FragmentAlphaSource = newAlphaSource;
		2472	}
		2473
		2474
		2475	void
		2476	_mesa_PixelTexGenParameterfSGIS(GLenum target, GLfloat value)
		2477	{
		2478	_mesa_PixelTexGenParameteriSGIS(target, (GLint) value);
		2479	}
		2480
		2481
		2482	void
		2483	_mesa_PixelTexGenParameterfvSGIS(GLenum target, const GLfloat *value)
		2484	{
		2485	_mesa_PixelTexGenParameteriSGIS(target, (GLint) *value);
		2486	}
		2487
		2488
		2489	void
		2490	_mesa_PixelTexGenParameteriSGIS(GLenum target, GLint value)
		2491	{
		2492	GET_CURRENT_CONTEXT(ctx);
		2493	ASSERT_OUTSIDE_BEGIN_END(ctx);
		2494
		2495	if (value != GL_CURRENT_RASTER_COLOR && value != GL_PIXEL_GROUP_COLOR_SGIS) {
		2496	_mesa_error(ctx, GL_INVALID_ENUM, "glPixelTexGenParameterSGIS(value)");
		2497	return;
		2498	}
		2499
		2500	switch (target) {
		2501	case GL_PIXEL_FRAGMENT_RGB_SOURCE_SGIS:
		2502	if (ctx->Pixel.FragmentRgbSource == (GLenum) value)
		2503	return;
		2504	FLUSH_VERTICES(ctx, _NEW_PIXEL);
		2505	ctx->Pixel.FragmentRgbSource = (GLenum) value;
		2506	break;
		2507	case GL_PIXEL_FRAGMENT_ALPHA_SOURCE_SGIS:
		2508	if (ctx->Pixel.FragmentAlphaSource == (GLenum) value)
		2509	return;
		2510	FLUSH_VERTICES(ctx, _NEW_PIXEL);
		2511	ctx->Pixel.FragmentAlphaSource = (GLenum) value;
		2512	break;
		2513	default:
		2514	_mesa_error(ctx, GL_INVALID_ENUM, "glPixelTexGenParameterSGIS(target)");
		2515	return;
		2516	}
		2517	}
		2518
		2519
		2520	void
		2521	_mesa_PixelTexGenParameterivSGIS(GLenum target, const GLint *value)
		2522	{
		2523	_mesa_PixelTexGenParameteriSGIS(target, *value);
		2524	}
		2525
		2526
		2527	void
		2528	_mesa_GetPixelTexGenParameterfvSGIS(GLenum target, GLfloat *value)
		2529	{
		2530	GET_CURRENT_CONTEXT(ctx);
		2531	ASSERT_OUTSIDE_BEGIN_END(ctx);
		2532
		2533	if (target == GL_PIXEL_FRAGMENT_RGB_SOURCE_SGIS) {
		2534	*value = (GLfloat) ctx->Pixel.FragmentRgbSource;
		2535	}
		2536	else if (target == GL_PIXEL_FRAGMENT_ALPHA_SOURCE_SGIS) {
		2537	*value = (GLfloat) ctx->Pixel.FragmentAlphaSource;
		2538	}
		2539	else {
		2540	_mesa_error(ctx, GL_INVALID_ENUM, "glGetPixelTexGenParameterfvSGIS(target)");
		2541	}
		2542	}
		2543
		2544
		2545	void
		2546	_mesa_GetPixelTexGenParameterivSGIS(GLenum target, GLint *value)
		2547	{
		2548	GET_CURRENT_CONTEXT(ctx);
		2549	ASSERT_OUTSIDE_BEGIN_END(ctx);
		2550
		2551	if (target == GL_PIXEL_FRAGMENT_RGB_SOURCE_SGIS) {
		2552	*value = (GLint) ctx->Pixel.FragmentRgbSource;
		2553	}
		2554	else if (target == GL_PIXEL_FRAGMENT_ALPHA_SOURCE_SGIS) {
		2555	*value = (GLint) ctx->Pixel.FragmentAlphaSource;
		2556	}
		2557	else {
		2558	_mesa_error(ctx, GL_INVALID_ENUM, "glGetPixelTexGenParameterivSGIS(target)");
		2559	}
		2560	}

Subversion Repositories shark

(root)/shark/trunk/ports/mesa/src/texstate.c - Rev 55