Context Navigation

source: trunk/src/opengl/mesa/texstate.c

Visit:

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

Line
1	/* $Id: texstate.c,v 1.3 2000-05-23 20:40:56 jeroen Exp $ */
2
3	/*
4	* Mesa 3-D graphics library
5	* Version: 3.3
6	*
7	* Copyright (C) 1999 Brian Paul All Rights Reserved.
8	*
9	* Permission is hereby granted, free of charge, to any person obtaining a
10	* copy of this software and associated documentation files (the "Software"),
11	* to deal in the Software without restriction, including without limitation
12	* the rights to use, copy, modify, merge, publish, distribute, sublicense,
13	* and/or sell copies of the Software, and to permit persons to whom the
14	* Software is furnished to do so, subject to the following conditions:
15	*
16	* The above copyright notice and this permission notice shall be included
17	* in all copies or substantial portions of the Software.
18	*
19	* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
20	* OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
21	* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
22	* BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
23	* AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
24	* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
25	*/
26
27
28
29	#ifdef PC_HEADER
30	#include "all.h"
31	#else
32	#include "glheader.h"
33	#include "types.h"
34	#include "context.h"
35	#include "enums.h"
36	#include "extensions.h"
37	#include "macros.h"
38	#include "matrix.h"
39	#include "texobj.h"
40	#include "texstate.h"
41	#include "texture.h"
42	#include "xform.h"
43	#endif
44
45
46
47	#ifdef SPECIALCAST
48	/* Needed for an Amiga compiler */
49	#define ENUM_TO_FLOAT(X) ((GLfloat)(GLint)(X))
50	#define ENUM_TO_DOUBLE(X) ((GLdouble)(GLint)(X))
51	#else
52	/* all other compilers */
53	#define ENUM_TO_FLOAT(X) ((GLfloat)(X))
54	#define ENUM_TO_DOUBLE(X) ((GLdouble)(X))
55	#endif
56
57
58
59
60	/**********************************************************************/
61	/* Texture Environment */
62	/**********************************************************************/
63
64	void
65	_mesa_TexEnvfv( GLenum target, GLenum pname, const GLfloat *param )
66	{
67	GET_CURRENT_CONTEXT(ctx);
68	struct gl_texture_unit *texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
69
70	ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx, "glTexEnv");
71
72	if (target==GL_TEXTURE_ENV) {
73
74	if (pname==GL_TEXTURE_ENV_MODE) {
75	GLenum mode = (GLenum) (GLint) *param;
76	switch (mode) {
77	case GL_ADD:
78	if (!ctx->Extensions.HaveTextureEnvAdd) {
79	gl_error(ctx, GL_INVALID_ENUM, "glTexEnv(param)");
80	return;
81	}
82	/* FALL-THROUGH */
83	case GL_MODULATE:
84	case GL_BLEND:
85	case GL_DECAL:
86	case GL_REPLACE:
87	/* A small optimization for drivers */
88	if (texUnit->EnvMode == mode)
89	return;
90
91	if (MESA_VERBOSE & (VERBOSE_STATE\|VERBOSE_TEXTURE))
92	fprintf(stderr, "glTexEnv: old mode %s, new mode %s\n",
93	gl_lookup_enum_by_nr(texUnit->EnvMode),
94	gl_lookup_enum_by_nr(mode));
95
96	texUnit->EnvMode = mode;
97	ctx->NewState \|= NEW_TEXTURE_ENV;
98	break;
99	default:
100	gl_error( ctx, GL_INVALID_VALUE, "glTexEnv(param)" );
101	return;
102	}
103	}
104	else if (pname==GL_TEXTURE_ENV_COLOR) {
105	texUnit->EnvColor[0] = CLAMP( param[0], 0.0F, 1.0F );
106	texUnit->EnvColor[1] = CLAMP( param[1], 0.0F, 1.0F );
107	texUnit->EnvColor[2] = CLAMP( param[2], 0.0F, 1.0F );
108	texUnit->EnvColor[3] = CLAMP( param[3], 0.0F, 1.0F );
109	}
110	else {
111	gl_error( ctx, GL_INVALID_ENUM, "glTexEnv(pname)" );
112	return;
113	}
114
115	}
116	else if (target==GL_TEXTURE_FILTER_CONTROL_EXT) {
117
118	if (!ctx->Extensions.HaveTextureLodBias) {
119	gl_error( ctx, GL_INVALID_ENUM, "glTexEnv(param)" );
120	return;
121	}
122
123	if (pname==GL_TEXTURE_LOD_BIAS_EXT) {
124	texUnit->LodBias = param[0];
125	}
126	else {
127	gl_error( ctx, GL_INVALID_ENUM, "glTexEnv(pname)" );
128	return;
129	}
130
131	}
132	else {
133	gl_error( ctx, GL_INVALID_ENUM, "glTexEnv(target)" );
134	return;
135	}
136
137	if (MESA_VERBOSE&(VERBOSE_API\|VERBOSE_TEXTURE))
138	fprintf(stderr, "glTexEnv %s %s %.1f(%s) ...\n",
139	gl_lookup_enum_by_nr(target),
140	gl_lookup_enum_by_nr(pname),
141	*param,
142	gl_lookup_enum_by_nr((GLenum) (GLint) *param));
143
144	/* Tell device driver about the new texture environment */
145	if (ctx->Driver.TexEnv) {
146	(*ctx->Driver.TexEnv)( ctx, target, pname, param );
147	}
148
149	}
150
151
152	void
153	_mesa_TexEnvf( GLenum target, GLenum pname, GLfloat param )
154	{
155	_mesa_TexEnvfv( target, pname, &param );
156	}
157
158
159
160	void
161	_mesa_TexEnvi( GLenum target, GLenum pname, GLint param )
162	{
163	GLfloat p[4];
164	p[0] = (GLfloat) param;
165	p[1] = p[2] = p[3] = 0.0;
166	_mesa_TexEnvfv( target, pname, p );
167	}
168
169
170	void
171	_mesa_TexEnviv( GLenum target, GLenum pname, const GLint *param )
172	{
173	GLfloat p[4];
174	p[0] = INT_TO_FLOAT( param[0] );
175	p[1] = INT_TO_FLOAT( param[1] );
176	p[2] = INT_TO_FLOAT( param[2] );
177	p[3] = INT_TO_FLOAT( param[3] );
178	_mesa_TexEnvfv( target, pname, p );
179	}
180
181
182	void
183	_mesa_GetTexEnvfv( GLenum target, GLenum pname, GLfloat *params )
184	{
185	GET_CURRENT_CONTEXT(ctx);
186	struct gl_texture_unit *texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
187
188	ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx, "glGetTexEnvfv");
189
190	if (target!=GL_TEXTURE_ENV) {
191	gl_error( ctx, GL_INVALID_ENUM, "glGetTexEnvfv(target)" );
192	return;
193	}
194	switch (pname) {
195	case GL_TEXTURE_ENV_MODE:
196	*params = ENUM_TO_FLOAT(texUnit->EnvMode);
197	break;
198	case GL_TEXTURE_ENV_COLOR:
199	COPY_4FV( params, texUnit->EnvColor );
200	break;
201	default:
202	gl_error( ctx, GL_INVALID_ENUM, "glGetTexEnvfv(pname)" );
203	}
204	}
205
206
207	void
208	_mesa_GetTexEnviv( GLenum target, GLenum pname, GLint *params )
209	{
210	GET_CURRENT_CONTEXT(ctx);
211	struct gl_texture_unit *texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
212
213	ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx, "glGetTexEnviv");
214
215	if (target!=GL_TEXTURE_ENV) {
216	gl_error( ctx, GL_INVALID_ENUM, "glGetTexEnviv(target)" );
217	return;
218	}
219	switch (pname) {
220	case GL_TEXTURE_ENV_MODE:
221	*params = (GLint) texUnit->EnvMode;
222	break;
223	case GL_TEXTURE_ENV_COLOR:
224	params[0] = FLOAT_TO_INT( texUnit->EnvColor[0] );
225	params[1] = FLOAT_TO_INT( texUnit->EnvColor[1] );
226	params[2] = FLOAT_TO_INT( texUnit->EnvColor[2] );
227	params[3] = FLOAT_TO_INT( texUnit->EnvColor[3] );
228	break;
229	default:
230	gl_error( ctx, GL_INVALID_ENUM, "glGetTexEnviv(pname)" );
231	}
232	}
233
234
235
236
237	/**********************************************************************/
238	/* Texture Parameters */
239	/**********************************************************************/
240
241
242	void
243	_mesa_TexParameterf( GLenum target, GLenum pname, GLfloat param )
244	{
245	_mesa_TexParameterfv(target, pname, &param);
246	}
247
248
249	void
250	_mesa_TexParameterfv( GLenum target, GLenum pname, const GLfloat *params )
251	{
252	GET_CURRENT_CONTEXT(ctx);
253	struct gl_texture_unit *texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
254	GLenum eparam = (GLenum) (GLint) params[0];
255	struct gl_texture_object *texObj;
256
257	ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx, "glTexParameterfv");
258
259	if (MESA_VERBOSE&(VERBOSE_API\|VERBOSE_TEXTURE))
260	fprintf(stderr, "texPARAM %s %s %d...\n",
261	gl_lookup_enum_by_nr(target),
262	gl_lookup_enum_by_nr(pname),
263	eparam);
264
265
266	switch (target) {
267	case GL_TEXTURE_1D:
268	texObj = texUnit->CurrentD[1];
269	break;
270	case GL_TEXTURE_2D:
271	texObj = texUnit->CurrentD[2];
272	break;
273	case GL_TEXTURE_3D_EXT:
274	texObj = texUnit->CurrentD[3];
275	break;
276	default:
277	gl_error( ctx, GL_INVALID_ENUM, "glTexParameter(target)" );
278	return;
279	}
280
281	switch (pname) {
282	case GL_TEXTURE_MIN_FILTER:
283	/* A small optimization */
284	if (texObj->MinFilter == eparam)
285	return;
286
287	if (eparam==GL_NEAREST \|\| eparam==GL_LINEAR
288	\|\| eparam==GL_NEAREST_MIPMAP_NEAREST
289	\|\| eparam==GL_LINEAR_MIPMAP_NEAREST
290	\|\| eparam==GL_NEAREST_MIPMAP_LINEAR
291	\|\| eparam==GL_LINEAR_MIPMAP_LINEAR) {
292	texObj->MinFilter = eparam;
293	ctx->NewState \|= NEW_TEXTURING;
294	}
295	else {
296	gl_error( ctx, GL_INVALID_VALUE, "glTexParameter(param)" );
297	return;
298	}
299	break;
300	case GL_TEXTURE_MAG_FILTER:
301	/* A small optimization */
302	if (texObj->MagFilter == eparam)
303	return;
304
305	if (eparam==GL_NEAREST \|\| eparam==GL_LINEAR) {
306	texObj->MagFilter = eparam;
307	ctx->NewState \|= NEW_TEXTURING;
308	}
309	else {
310	gl_error( ctx, GL_INVALID_VALUE, "glTexParameter(param)" );
311	return;
312	}
313	break;
314	case GL_TEXTURE_WRAP_S:
315	if (texObj->WrapS == eparam)
316	return;
317
318	if (eparam==GL_CLAMP \|\| eparam==GL_REPEAT \|\| eparam==GL_CLAMP_TO_EDGE) {
319	texObj->WrapS = eparam;
320	ctx->NewState \|= NEW_TEXTURING;
321	}
322	else {
323	gl_error( ctx, GL_INVALID_VALUE, "glTexParameter(param)" );
324	return;
325	}
326	break;
327	case GL_TEXTURE_WRAP_T:
328	if (texObj->WrapT == eparam)
329	return;
330
331	if (eparam==GL_CLAMP \|\| eparam==GL_REPEAT \|\| eparam==GL_CLAMP_TO_EDGE) {
332	texObj->WrapT = eparam;
333	ctx->NewState \|= NEW_TEXTURING;
334	}
335	else {
336	gl_error( ctx, GL_INVALID_VALUE, "glTexParameter(param)" );
337	return;
338	}
339	break;
340	case GL_TEXTURE_WRAP_R_EXT:
341	if (texObj->WrapR == eparam)
342	return;
343
344	if (eparam==GL_CLAMP \|\| eparam==GL_REPEAT \|\| eparam==GL_CLAMP_TO_EDGE) {
345	texObj->WrapR = eparam;
346	ctx->NewState \|= NEW_TEXTURING;
347	}
348	else {
349	gl_error( ctx, GL_INVALID_VALUE, "glTexParameter(param)" );
350	}
351	break;
352	case GL_TEXTURE_BORDER_COLOR:
353	texObj->BorderColor[0] = (GLubyte) CLAMP((GLint)(params[0]*255.0), 0, 255);
354	texObj->BorderColor[1] = (GLubyte) CLAMP((GLint)(params[1]*255.0), 0, 255);
355	texObj->BorderColor[2] = (GLubyte) CLAMP((GLint)(params[2]*255.0), 0, 255);
356	texObj->BorderColor[3] = (GLubyte) CLAMP((GLint)(params[3]*255.0), 0, 255);
357	break;
358	case GL_TEXTURE_MIN_LOD:
359	texObj->MinLod = params[0];
360	ctx->NewState \|= NEW_TEXTURING;
361	break;
362	case GL_TEXTURE_MAX_LOD:
363	texObj->MaxLod = params[0];
364	ctx->NewState \|= NEW_TEXTURING;
365	break;
366	case GL_TEXTURE_BASE_LEVEL:
367	if (params[0] < 0.0) {
368	gl_error(ctx, GL_INVALID_VALUE, "glTexParameter(param)" );
369	return;
370	}
371	texObj->BaseLevel = (GLint) params[0];
372	ctx->NewState \|= NEW_TEXTURING;
373	break;
374	case GL_TEXTURE_MAX_LEVEL:
375	if (params[0] < 0.0) {
376	gl_error(ctx, GL_INVALID_VALUE, "glTexParameter(param)" );
377	return;
378	}
379	texObj->MaxLevel = (GLint) params[0];
380	ctx->NewState \|= NEW_TEXTURING;
381	break;
382	case GL_TEXTURE_PRIORITY:
383	/* (keithh@netcomuk.co.uk) */
384	texObj->Priority = CLAMP( params[0], 0.0F, 1.0F );
385	break;
386	default:
387	gl_error( ctx, GL_INVALID_ENUM, "glTexParameter(pname)" );
388	return;
389	}
390
391	gl_put_texobj_on_dirty_list( ctx, texObj );
392
393	if (ctx->Driver.TexParameter) {
394	(*ctx->Driver.TexParameter)( ctx, target, texObj, pname, params );
395	}
396	}
397
398
399	void
400	_mesa_TexParameteri( GLenum target, GLenum pname, const GLint param )
401	{
402	GLfloat fparam[4];
403	fparam[0] = (GLfloat) param;
404	fparam[1] = fparam[2] = fparam[3] = 0.0;
405	_mesa_TexParameterfv(target, pname, fparam);
406	}
407
408	void
409	_mesa_TexParameteriv( GLenum target, GLenum pname, const GLint *params )
410	{
411	GLfloat fparam[4];
412	fparam[0] = (GLfloat) params[0];
413	fparam[1] = fparam[2] = fparam[3] = 0.0;
414	_mesa_TexParameterfv(target, pname, fparam);
415	}
416
417
418	void
419	_mesa_GetTexLevelParameterfv( GLenum target, GLint level,
420	GLenum pname, GLfloat *params )
421	{
422	GLint iparam;
423	_mesa_GetTexLevelParameteriv( target, level, pname, &iparam );
424	*params = (GLfloat) iparam;
425	}
426
427
428
429	void
430	_mesa_GetTexLevelParameteriv( GLenum target, GLint level,
431	GLenum pname, GLint *params )
432	{
433	GET_CURRENT_CONTEXT(ctx);
434	const struct gl_texture_unit *texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
435	const struct gl_texture_image *img = NULL;
436	GLuint dimensions;
437
438	ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx, "glGetTexLevelParameter");
439
440	if (level < 0 \|\| level >= ctx->Const.MaxTextureLevels) {
441	gl_error( ctx, GL_INVALID_VALUE, "glGetTexLevelParameter[if]v" );
442	return;
443	}
444
445	switch (target) {
446	case GL_TEXTURE_1D:
447	img = texUnit->CurrentD[1]->Image[level];
448	dimensions = 1;
449	break;
450	case GL_TEXTURE_2D:
451	img = texUnit->CurrentD[2]->Image[level];
452	dimensions = 2;
453	break;
454	case GL_TEXTURE_3D:
455	img = texUnit->CurrentD[3]->Image[level];
456	dimensions = 3;
457	break;
458	case GL_PROXY_TEXTURE_1D:
459	img = ctx->Texture.Proxy1D->Image[level];
460	dimensions = 1;
461	break;
462	case GL_PROXY_TEXTURE_2D:
463	img = ctx->Texture.Proxy2D->Image[level];
464	dimensions = 2;
465	break;
466	case GL_PROXY_TEXTURE_3D:
467	img = ctx->Texture.Proxy3D->Image[level];
468	dimensions = 3;
469	break;
470	default:
471	gl_error(ctx, GL_INVALID_ENUM, "glGetTexLevelParameter[if]v(target)");
472	return;
473	}
474
475	if (!img) {
476	if (pname == GL_TEXTURE_COMPONENTS)
477	*params = 1;
478	else
479	*params = 0;
480	return;
481	}
482
483	switch (pname) {
484	case GL_TEXTURE_WIDTH:
485	*params = img->Width;
486	return;
487	case GL_TEXTURE_HEIGHT:
488	if (dimensions > 1) {
489	*params = img->Height;
490	}
491	else {
492	gl_error( ctx, GL_INVALID_ENUM,
493	"glGetTexLevelParameter[if]v(pname=GL_TEXTURE_HEIGHT)" );
494	}
495	return;
496	case GL_TEXTURE_DEPTH:
497	if (dimensions > 2) {
498	*params = img->Depth;
499	}
500	else {
501	gl_error( ctx, GL_INVALID_ENUM,
502	"glGetTexLevelParameter[if]v(pname=GL_TEXTURE_DEPTH)" );
503	}
504	return;
505	case GL_TEXTURE_COMPONENTS:
506	*params = img->IntFormat;
507	return;
508	case GL_TEXTURE_BORDER:
509	*params = img->Border;
510	return;
511	case GL_TEXTURE_RED_SIZE:
512	*params = img->RedBits;
513	return;
514	case GL_TEXTURE_GREEN_SIZE:
515	*params = img->GreenBits;
516	return;
517	case GL_TEXTURE_BLUE_SIZE:
518	*params = img->BlueBits;
519	return;
520	case GL_TEXTURE_ALPHA_SIZE:
521	*params = img->AlphaBits;
522	return;
523	case GL_TEXTURE_INTENSITY_SIZE:
524	*params = img->IntensityBits;
525	return;
526	case GL_TEXTURE_LUMINANCE_SIZE:
527	*params = img->LuminanceBits;
528	return;
529	case GL_TEXTURE_INDEX_SIZE_EXT:
530	*params = img->IndexBits;
531	return;
532	default:
533	gl_error( ctx, GL_INVALID_ENUM,
534	"glGetTexLevelParameter[if]v(pname)" );
535	}
536	}
537
538
539
540	void
541	_mesa_GetTexParameterfv( GLenum target, GLenum pname, GLfloat *params )
542	{
543	GET_CURRENT_CONTEXT(ctx);
544	struct gl_texture_unit *texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
545	struct gl_texture_object *obj;
546
547	ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx, "glGetTexParameterfv");
548
549	switch (target) {
550	case GL_TEXTURE_1D:
551	obj = texUnit->CurrentD[1];
552	break;
553	case GL_TEXTURE_2D:
554	obj = texUnit->CurrentD[2];
555	break;
556	case GL_TEXTURE_3D_EXT:
557	obj = texUnit->CurrentD[3];
558	break;
559	default:
560	gl_error(ctx, GL_INVALID_ENUM, "glGetTexParameterfv(target)");
561	return;
562	}
563
564	switch (pname) {
565	case GL_TEXTURE_MAG_FILTER:
566	*params = ENUM_TO_FLOAT(obj->MagFilter);
567	break;
568	case GL_TEXTURE_MIN_FILTER:
569	*params = ENUM_TO_FLOAT(obj->MinFilter);
570	break;
571	case GL_TEXTURE_WRAP_S:
572	*params = ENUM_TO_FLOAT(obj->WrapS);
573	break;
574	case GL_TEXTURE_WRAP_T:
575	*params = ENUM_TO_FLOAT(obj->WrapT);
576	break;
577	case GL_TEXTURE_WRAP_R_EXT:
578	*params = ENUM_TO_FLOAT(obj->WrapR);
579	break;
580	case GL_TEXTURE_BORDER_COLOR:
581	params[0] = obj->BorderColor[0] / 255.0F;
582	params[1] = obj->BorderColor[1] / 255.0F;
583	params[2] = obj->BorderColor[2] / 255.0F;
584	params[3] = obj->BorderColor[3] / 255.0F;
585	break;
586	case GL_TEXTURE_RESIDENT:
587	*params = ENUM_TO_FLOAT(GL_TRUE);
588	break;
589	case GL_TEXTURE_PRIORITY:
590	*params = obj->Priority;
591	break;
592	case GL_TEXTURE_MIN_LOD:
593	*params = obj->MinLod;
594	break;
595	case GL_TEXTURE_MAX_LOD:
596	*params = obj->MaxLod;
597	break;
598	case GL_TEXTURE_BASE_LEVEL:
599	*params = (GLfloat) obj->BaseLevel;
600	break;
601	case GL_TEXTURE_MAX_LEVEL:
602	*params = (GLfloat) obj->MaxLevel;
603	break;
604	default:
605	gl_error( ctx, GL_INVALID_ENUM, "glGetTexParameterfv(pname)" );
606	}
607	}
608
609
610	void
611	_mesa_GetTexParameteriv( GLenum target, GLenum pname, GLint *params )
612	{
613	GET_CURRENT_CONTEXT(ctx);
614	struct gl_texture_unit *texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
615	struct gl_texture_object *obj;
616
617	ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx, "glGetTexParameteriv");
618
619	switch (target) {
620	case GL_TEXTURE_1D:
621	obj = texUnit->CurrentD[1];
622	break;
623	case GL_TEXTURE_2D:
624	obj = texUnit->CurrentD[2];
625	break;
626	case GL_TEXTURE_3D_EXT:
627	obj = texUnit->CurrentD[3];
628	break;
629	default:
630	gl_error(ctx, GL_INVALID_ENUM, "glGetTexParameteriv(target)");
631	return;
632	}
633
634	switch (pname) {
635	case GL_TEXTURE_MAG_FILTER:
636	*params = (GLint) obj->MagFilter;
637	break;
638	case GL_TEXTURE_MIN_FILTER:
639	*params = (GLint) obj->MinFilter;
640	break;
641	case GL_TEXTURE_WRAP_S:
642	*params = (GLint) obj->WrapS;
643	break;
644	case GL_TEXTURE_WRAP_T:
645	*params = (GLint) obj->WrapT;
646	break;
647	case GL_TEXTURE_WRAP_R_EXT:
648	*params = (GLint) obj->WrapR;
649	break;
650	case GL_TEXTURE_BORDER_COLOR:
651	{
652	GLfloat color[4];
653	color[0] = obj->BorderColor[0] / 255.0F;
654	color[1] = obj->BorderColor[1] / 255.0F;
655	color[2] = obj->BorderColor[2] / 255.0F;
656	color[3] = obj->BorderColor[3] / 255.0F;
657	params[0] = FLOAT_TO_INT( color[0] );
658	params[1] = FLOAT_TO_INT( color[1] );
659	params[2] = FLOAT_TO_INT( color[2] );
660	params[3] = FLOAT_TO_INT( color[3] );
661	}
662	break;
663	case GL_TEXTURE_RESIDENT:
664	*params = (GLint) GL_TRUE;
665	break;
666	case GL_TEXTURE_PRIORITY:
667	*params = (GLint) obj->Priority;
668	break;
669	case GL_TEXTURE_MIN_LOD:
670	*params = (GLint) obj->MinLod;
671	break;
672	case GL_TEXTURE_MAX_LOD:
673	*params = (GLint) obj->MaxLod;
674	break;
675	case GL_TEXTURE_BASE_LEVEL:
676	*params = obj->BaseLevel;
677	break;
678	case GL_TEXTURE_MAX_LEVEL:
679	*params = obj->MaxLevel;
680	break;
681	default:
682	gl_error( ctx, GL_INVALID_ENUM, "glGetTexParameteriv(pname)" );
683	}
684	}
685
686
687
688
689	/**********************************************************************/
690	/* Texture Coord Generation */
691	/**********************************************************************/
692
693
694	void
695	_mesa_TexGenfv( GLenum coord, GLenum pname, const GLfloat *params )
696	{
697	GET_CURRENT_CONTEXT(ctx);
698	GLuint tUnit = ctx->Texture.CurrentTransformUnit;
699	struct gl_texture_unit *texUnit = &ctx->Texture.Unit[tUnit];
700	ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx, "glTexGenfv");
701
702	if (MESA_VERBOSE&(VERBOSE_API\|VERBOSE_TEXTURE))
703	fprintf(stderr, "texGEN %s %s %x...\n",
704	gl_lookup_enum_by_nr(coord),
705	gl_lookup_enum_by_nr(pname),
706	(int )params);
707
708	switch (coord) {
709	case GL_S:
710	if (pname==GL_TEXTURE_GEN_MODE) {
711	GLenum mode = (GLenum) (GLint) *params;
712	switch (mode) {
713	case GL_OBJECT_LINEAR:
714	texUnit->GenModeS = mode;
715	texUnit->GenBitS = TEXGEN_OBJ_LINEAR;
716	break;
717	case GL_EYE_LINEAR:
718	texUnit->GenModeS = mode;
719	texUnit->GenBitS = TEXGEN_EYE_LINEAR;
720	break;
721	case GL_REFLECTION_MAP_NV:
722	texUnit->GenModeS = mode;
723	texUnit->GenBitS = TEXGEN_REFLECTION_MAP_NV;
724	break;
725	case GL_NORMAL_MAP_NV:
726	texUnit->GenModeS = mode;
727	texUnit->GenBitS = TEXGEN_NORMAL_MAP_NV;
728	break;
729	case GL_SPHERE_MAP:
730	texUnit->GenModeS = mode;
731	texUnit->GenBitS = TEXGEN_SPHERE_MAP;
732	break;
733	default:
734	gl_error( ctx, GL_INVALID_ENUM, "glTexGenfv(param)" );
735	return;
736	}
737	}
738	else if (pname==GL_OBJECT_PLANE) {
739	texUnit->ObjectPlaneS[0] = params[0];
740	texUnit->ObjectPlaneS[1] = params[1];
741	texUnit->ObjectPlaneS[2] = params[2];
742	texUnit->ObjectPlaneS[3] = params[3];
743	}
744	else if (pname==GL_EYE_PLANE) {
745	/* Transform plane equation by the inverse modelview matrix */
746	if (ctx->ModelView.flags & MAT_DIRTY_INVERSE) {
747	gl_matrix_analyze( &ctx->ModelView );
748	}
749	gl_transform_vector( texUnit->EyePlaneS, params,
750	ctx->ModelView.inv );
751	}
752	else {
753	gl_error( ctx, GL_INVALID_ENUM, "glTexGenfv(pname)" );
754	return;
755	}
756	break;
757	case GL_T:
758	if (pname==GL_TEXTURE_GEN_MODE) {
759	GLenum mode = (GLenum) (GLint) *params;
760	switch(mode) {
761	case GL_OBJECT_LINEAR:
762	texUnit->GenModeT = GL_OBJECT_LINEAR;
763	texUnit->GenBitT = TEXGEN_OBJ_LINEAR;
764	break;
765	case GL_EYE_LINEAR:
766	texUnit->GenModeT = GL_EYE_LINEAR;
767	texUnit->GenBitT = TEXGEN_EYE_LINEAR;
768	break;
769	case GL_REFLECTION_MAP_NV:
770	texUnit->GenModeT = GL_REFLECTION_MAP_NV;
771	texUnit->GenBitT = TEXGEN_REFLECTION_MAP_NV;
772	break;
773	case GL_NORMAL_MAP_NV:
774	texUnit->GenModeT = GL_NORMAL_MAP_NV;
775	texUnit->GenBitT = TEXGEN_NORMAL_MAP_NV;
776	break;
777	case GL_SPHERE_MAP:
778	texUnit->GenModeT = GL_SPHERE_MAP;
779	texUnit->GenBitT = TEXGEN_SPHERE_MAP;
780	break;
781	default:
782	gl_error( ctx, GL_INVALID_ENUM, "glTexGenfv(param)" );
783	return;
784	}
785	}
786	else if (pname==GL_OBJECT_PLANE) {
787	texUnit->ObjectPlaneT[0] = params[0];
788	texUnit->ObjectPlaneT[1] = params[1];
789	texUnit->ObjectPlaneT[2] = params[2];
790	texUnit->ObjectPlaneT[3] = params[3];
791	}
792	else if (pname==GL_EYE_PLANE) {
793	/* Transform plane equation by the inverse modelview matrix */
794	if (ctx->ModelView.flags & MAT_DIRTY_INVERSE) {
795	gl_matrix_analyze( &ctx->ModelView );
796	}
797	gl_transform_vector( texUnit->EyePlaneT, params,
798	ctx->ModelView.inv );
799	}
800	else {
801	gl_error( ctx, GL_INVALID_ENUM, "glTexGenfv(pname)" );
802	return;
803	}
804	break;
805	case GL_R:
806	if (pname==GL_TEXTURE_GEN_MODE) {
807	GLenum mode = (GLenum) (GLint) *params;
808	switch (mode) {
809	case GL_OBJECT_LINEAR:
810	texUnit->GenModeR = GL_OBJECT_LINEAR;
811	texUnit->GenBitR = TEXGEN_OBJ_LINEAR;
812	break;
813	case GL_REFLECTION_MAP_NV:
814	texUnit->GenModeR = GL_REFLECTION_MAP_NV;
815	texUnit->GenBitR = TEXGEN_REFLECTION_MAP_NV;
816	break;
817	case GL_NORMAL_MAP_NV:
818	texUnit->GenModeR = GL_NORMAL_MAP_NV;
819	texUnit->GenBitR = TEXGEN_NORMAL_MAP_NV;
820	break;
821	case GL_EYE_LINEAR:
822	texUnit->GenModeR = GL_EYE_LINEAR;
823	texUnit->GenBitR = TEXGEN_EYE_LINEAR;
824	break;
825	default:
826	gl_error( ctx, GL_INVALID_ENUM, "glTexGenfv(param)" );
827	return;
828	}
829	}
830	else if (pname==GL_OBJECT_PLANE) {
831	texUnit->ObjectPlaneR[0] = params[0];
832	texUnit->ObjectPlaneR[1] = params[1];
833	texUnit->ObjectPlaneR[2] = params[2];
834	texUnit->ObjectPlaneR[3] = params[3];
835	}
836	else if (pname==GL_EYE_PLANE) {
837	/* Transform plane equation by the inverse modelview matrix */
838	if (ctx->ModelView.flags & MAT_DIRTY_INVERSE) {
839	gl_matrix_analyze( &ctx->ModelView );
840	}
841	gl_transform_vector( texUnit->EyePlaneR, params,
842	ctx->ModelView.inv );
843	}
844	else {
845	gl_error( ctx, GL_INVALID_ENUM, "glTexGenfv(pname)" );
846	return;
847	}
848	break;
849	case GL_Q:
850	if (pname==GL_TEXTURE_GEN_MODE) {
851	GLenum mode = (GLenum) (GLint) *params;
852	switch (mode) {
853	case GL_OBJECT_LINEAR:
854	texUnit->GenModeQ = GL_OBJECT_LINEAR;
855	texUnit->GenBitQ = TEXGEN_OBJ_LINEAR;
856	break;
857	case GL_EYE_LINEAR:
858	texUnit->GenModeQ = GL_EYE_LINEAR;
859	texUnit->GenBitQ = TEXGEN_EYE_LINEAR;
860	break;
861	default:
862	gl_error( ctx, GL_INVALID_ENUM, "glTexGenfv(param)" );
863	return;
864	}
865	}
866	else if (pname==GL_OBJECT_PLANE) {
867	texUnit->ObjectPlaneQ[0] = params[0];
868	texUnit->ObjectPlaneQ[1] = params[1];
869	texUnit->ObjectPlaneQ[2] = params[2];
870	texUnit->ObjectPlaneQ[3] = params[3];
871	}
872	else if (pname==GL_EYE_PLANE) {
873	/* Transform plane equation by the inverse modelview matrix */
874	if (ctx->ModelView.flags & MAT_DIRTY_INVERSE) {
875	gl_matrix_analyze( &ctx->ModelView );
876	}
877	gl_transform_vector( texUnit->EyePlaneQ, params,
878	ctx->ModelView.inv );
879	}
880	else {
881	gl_error( ctx, GL_INVALID_ENUM, "glTexGenfv(pname)" );
882	return;
883	}
884	break;
885	default:
886	gl_error( ctx, GL_INVALID_ENUM, "glTexGenfv(coord)" );
887	return;
888	}
889
890	ctx->NewState \|= NEW_TEXTURING;
891	}
892
893
894	void
895	_mesa_TexGeniv(GLenum coord, GLenum pname, const GLint *params )
896	{
897	GLfloat p[4];
898	p[0] = params[0];
899	p[1] = params[1];
900	p[2] = params[2];
901	p[3] = params[3];
902	_mesa_TexGenfv(coord, pname, p);
903	}
904
905
906	void
907	_mesa_TexGend(GLenum coord, GLenum pname, GLdouble param )
908	{
909	GLfloat p = (GLfloat) param;
910	_mesa_TexGenfv( coord, pname, &p );
911	}
912
913
914	void
915	_mesa_TexGendv(GLenum coord, GLenum pname, const GLdouble *params )
916	{
917	GLfloat p[4];
918	p[0] = params[0];
919	p[1] = params[1];
920	p[2] = params[2];
921	p[3] = params[3];
922	_mesa_TexGenfv( coord, pname, p );
923	}
924
925
926	void
927	_mesa_TexGenf( GLenum coord, GLenum pname, GLfloat param )
928	{
929	_mesa_TexGenfv(coord, pname, &param);
930	}
931
932
933	void
934	_mesa_TexGeni( GLenum coord, GLenum pname, GLint param )
935	{
936	_mesa_TexGeniv( coord, pname, &param );
937	}
938
939
940
941	void
942	_mesa_GetTexGendv( GLenum coord, GLenum pname, GLdouble *params )
943	{
944	GET_CURRENT_CONTEXT(ctx);
945	GLuint tUnit = ctx->Texture.CurrentTransformUnit;
946	struct gl_texture_unit *texUnit = &ctx->Texture.Unit[tUnit];
947
948	ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx, "glGetTexGendv");
949
950	switch( coord ) {
951	case GL_S:
952	if (pname==GL_TEXTURE_GEN_MODE) {
953	params[0] = ENUM_TO_DOUBLE(texUnit->GenModeS);
954	}
955	else if (pname==GL_OBJECT_PLANE) {
956	COPY_4V( params, texUnit->ObjectPlaneS );
957	}
958	else if (pname==GL_EYE_PLANE) {
959	COPY_4V( params, texUnit->EyePlaneS );
960	}
961	else {
962	gl_error( ctx, GL_INVALID_ENUM, "glGetTexGendv(pname)" );
963	return;
964	}
965	break;
966	case GL_T:
967	if (pname==GL_TEXTURE_GEN_MODE) {
968	params[0] = ENUM_TO_DOUBLE(texUnit->GenModeT);
969	}
970	else if (pname==GL_OBJECT_PLANE) {
971	COPY_4V( params, texUnit->ObjectPlaneT );
972	}
973	else if (pname==GL_EYE_PLANE) {
974	COPY_4V( params, texUnit->EyePlaneT );
975	}
976	else {
977	gl_error( ctx, GL_INVALID_ENUM, "glGetTexGendv(pname)" );
978	return;
979	}
980	break;
981	case GL_R:
982	if (pname==GL_TEXTURE_GEN_MODE) {
983	params[0] = ENUM_TO_DOUBLE(texUnit->GenModeR);
984	}
985	else if (pname==GL_OBJECT_PLANE) {
986	COPY_4V( params, texUnit->ObjectPlaneR );
987	}
988	else if (pname==GL_EYE_PLANE) {
989	COPY_4V( params, texUnit->EyePlaneR );
990	}
991	else {
992	gl_error( ctx, GL_INVALID_ENUM, "glGetTexGendv(pname)" );
993	return;
994	}
995	break;
996	case GL_Q:
997	if (pname==GL_TEXTURE_GEN_MODE) {
998	params[0] = ENUM_TO_DOUBLE(texUnit->GenModeQ);
999	}
1000	else if (pname==GL_OBJECT_PLANE) {
1001	COPY_4V( params, texUnit->ObjectPlaneQ );
1002	}
1003	else if (pname==GL_EYE_PLANE) {
1004	COPY_4V( params, texUnit->EyePlaneQ );
1005	}
1006	else {
1007	gl_error( ctx, GL_INVALID_ENUM, "glGetTexGendv(pname)" );
1008	return;
1009	}
1010	break;
1011	default:
1012	gl_error( ctx, GL_INVALID_ENUM, "glGetTexGendv(coord)" );
1013	return;
1014	}
1015	}
1016
1017
1018
1019	void
1020	_mesa_GetTexGenfv( GLenum coord, GLenum pname, GLfloat *params )
1021	{
1022	GET_CURRENT_CONTEXT(ctx);
1023	GLuint tUnit = ctx->Texture.CurrentTransformUnit;
1024	struct gl_texture_unit *texUnit = &ctx->Texture.Unit[tUnit];
1025
1026	ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx, "glGetTexGenfv");
1027
1028	switch( coord ) {
1029	case GL_S:
1030	if (pname==GL_TEXTURE_GEN_MODE) {
1031	params[0] = ENUM_TO_FLOAT(texUnit->GenModeS);
1032	}
1033	else if (pname==GL_OBJECT_PLANE) {
1034	COPY_4V( params, texUnit->ObjectPlaneS );
1035	}
1036	else if (pname==GL_EYE_PLANE) {
1037	COPY_4V( params, texUnit->EyePlaneS );
1038	}
1039	else {
1040	gl_error( ctx, GL_INVALID_ENUM, "glGetTexGenfv(pname)" );
1041	return;
1042	}
1043	break;
1044	case GL_T:
1045	if (pname==GL_TEXTURE_GEN_MODE) {
1046	params[0] = ENUM_TO_FLOAT(texUnit->GenModeT);
1047	}
1048	else if (pname==GL_OBJECT_PLANE) {
1049	COPY_4V( params, texUnit->ObjectPlaneT );
1050	}
1051	else if (pname==GL_EYE_PLANE) {
1052	COPY_4V( params, texUnit->EyePlaneT );
1053	}
1054	else {
1055	gl_error( ctx, GL_INVALID_ENUM, "glGetTexGenfv(pname)" );
1056	return;
1057	}
1058	break;
1059	case GL_R:
1060	if (pname==GL_TEXTURE_GEN_MODE) {
1061	params[0] = ENUM_TO_FLOAT(texUnit->GenModeR);
1062	}
1063	else if (pname==GL_OBJECT_PLANE) {
1064	COPY_4V( params, texUnit->ObjectPlaneR );
1065	}
1066	else if (pname==GL_EYE_PLANE) {
1067	COPY_4V( params, texUnit->EyePlaneR );
1068	}
1069	else {
1070	gl_error( ctx, GL_INVALID_ENUM, "glGetTexGenfv(pname)" );
1071	return;
1072	}
1073	break;
1074	case GL_Q:
1075	if (pname==GL_TEXTURE_GEN_MODE) {
1076	params[0] = ENUM_TO_FLOAT(texUnit->GenModeQ);
1077	}
1078	else if (pname==GL_OBJECT_PLANE) {
1079	COPY_4V( params, texUnit->ObjectPlaneQ );
1080	}
1081	else if (pname==GL_EYE_PLANE) {
1082	COPY_4V( params, texUnit->EyePlaneQ );
1083	}
1084	else {
1085	gl_error( ctx, GL_INVALID_ENUM, "glGetTexGenfv(pname)" );
1086	return;
1087	}
1088	break;
1089	default:
1090	gl_error( ctx, GL_INVALID_ENUM, "glGetTexGenfv(coord)" );
1091	return;
1092	}
1093	}
1094
1095
1096
1097	void
1098	_mesa_GetTexGeniv( GLenum coord, GLenum pname, GLint *params )
1099	{
1100	GET_CURRENT_CONTEXT(ctx);
1101	GLuint tUnit = ctx->Texture.CurrentTransformUnit;
1102	struct gl_texture_unit *texUnit = &ctx->Texture.Unit[tUnit];
1103
1104	ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx, "glGetTexGeniv");
1105
1106	switch( coord ) {
1107	case GL_S:
1108	if (pname==GL_TEXTURE_GEN_MODE) {
1109	params[0] = texUnit->GenModeS;
1110	}
1111	else if (pname==GL_OBJECT_PLANE) {
1112	params[0] = (GLint) texUnit->ObjectPlaneS[0];
1113	params[1] = (GLint) texUnit->ObjectPlaneS[1];
1114	params[2] = (GLint) texUnit->ObjectPlaneS[2];
1115	params[3] = (GLint) texUnit->ObjectPlaneS[3];
1116	}
1117	else if (pname==GL_EYE_PLANE) {
1118	params[0] = (GLint) texUnit->EyePlaneS[0];
1119	params[1] = (GLint) texUnit->EyePlaneS[1];
1120	params[2] = (GLint) texUnit->EyePlaneS[2];
1121	params[3] = (GLint) texUnit->EyePlaneS[3];
1122	}
1123	else {
1124	gl_error( ctx, GL_INVALID_ENUM, "glGetTexGeniv(pname)" );
1125	return;
1126	}
1127	break;
1128	case GL_T:
1129	if (pname==GL_TEXTURE_GEN_MODE) {
1130	params[0] = texUnit->GenModeT;
1131	}
1132	else if (pname==GL_OBJECT_PLANE) {
1133	params[0] = (GLint) texUnit->ObjectPlaneT[0];
1134	params[1] = (GLint) texUnit->ObjectPlaneT[1];
1135	params[2] = (GLint) texUnit->ObjectPlaneT[2];
1136	params[3] = (GLint) texUnit->ObjectPlaneT[3];
1137	}
1138	else if (pname==GL_EYE_PLANE) {
1139	params[0] = (GLint) texUnit->EyePlaneT[0];
1140	params[1] = (GLint) texUnit->EyePlaneT[1];
1141	params[2] = (GLint) texUnit->EyePlaneT[2];
1142	params[3] = (GLint) texUnit->EyePlaneT[3];
1143	}
1144	else {
1145	gl_error( ctx, GL_INVALID_ENUM, "glGetTexGeniv(pname)" );
1146	return;
1147	}
1148	break;
1149	case GL_R:
1150	if (pname==GL_TEXTURE_GEN_MODE) {
1151	params[0] = texUnit->GenModeR;
1152	}
1153	else if (pname==GL_OBJECT_PLANE) {
1154	params[0] = (GLint) texUnit->ObjectPlaneR[0];
1155	params[1] = (GLint) texUnit->ObjectPlaneR[1];
1156	params[2] = (GLint) texUnit->ObjectPlaneR[2];
1157	params[3] = (GLint) texUnit->ObjectPlaneR[3];
1158	}
1159	else if (pname==GL_EYE_PLANE) {
1160	params[0] = (GLint) texUnit->EyePlaneR[0];
1161	params[1] = (GLint) texUnit->EyePlaneR[1];
1162	params[2] = (GLint) texUnit->EyePlaneR[2];
1163	params[3] = (GLint) texUnit->EyePlaneR[3];
1164	}
1165	else {
1166	gl_error( ctx, GL_INVALID_ENUM, "glGetTexGeniv(pname)" );
1167	return;
1168	}
1169	break;
1170	case GL_Q:
1171	if (pname==GL_TEXTURE_GEN_MODE) {
1172	params[0] = texUnit->GenModeQ;
1173	}
1174	else if (pname==GL_OBJECT_PLANE) {
1175	params[0] = (GLint) texUnit->ObjectPlaneQ[0];
1176	params[1] = (GLint) texUnit->ObjectPlaneQ[1];
1177	params[2] = (GLint) texUnit->ObjectPlaneQ[2];
1178	params[3] = (GLint) texUnit->ObjectPlaneQ[3];
1179	}
1180	else if (pname==GL_EYE_PLANE) {
1181	params[0] = (GLint) texUnit->EyePlaneQ[0];
1182	params[1] = (GLint) texUnit->EyePlaneQ[1];
1183	params[2] = (GLint) texUnit->EyePlaneQ[2];
1184	params[3] = (GLint) texUnit->EyePlaneQ[3];
1185	}
1186	else {
1187	gl_error( ctx, GL_INVALID_ENUM, "glGetTexGeniv(pname)" );
1188	return;
1189	}
1190	break;
1191	default:
1192	gl_error( ctx, GL_INVALID_ENUM, "glGetTexGeniv(coord)" );
1193	return;
1194	}
1195	}
1196
1197
1198	/* GL_ARB_multitexture */
1199	void
1200	_mesa_ActiveTextureARB( GLenum target )
1201	{
1202	GET_CURRENT_CONTEXT(ctx);
1203	GLint maxUnits = ctx->Const.MaxTextureUnits;
1204
1205	ASSERT_OUTSIDE_BEGIN_END( ctx, "glActiveTextureARB" );
1206
1207	if (MESA_VERBOSE & (VERBOSE_API\|VERBOSE_TEXTURE))
1208	fprintf(stderr, "glActiveTexture %s\n",
1209	gl_lookup_enum_by_nr(target));
1210
1211	if (target >= GL_TEXTURE0_ARB && target < GL_TEXTURE0_ARB + maxUnits) {
1212	GLint texUnit = target - GL_TEXTURE0_ARB;
1213	ctx->Texture.CurrentUnit = texUnit;
1214	ctx->Texture.CurrentTransformUnit = texUnit;
1215	if (ctx->Driver.ActiveTexture) {
1216	(*ctx->Driver.ActiveTexture)( ctx, (GLuint) texUnit );
1217	}
1218	}
1219	else {
1220	gl_error(ctx, GL_INVALID_OPERATION, "glActiveTextureARB(target)");
1221	}
1222	}
1223
1224
1225	/* GL_ARB_multitexture */
1226	void
1227	_mesa_ClientActiveTextureARB( GLenum target )
1228	{
1229	GET_CURRENT_CONTEXT(ctx);
1230	GLint maxUnits = ctx->Const.MaxTextureUnits;
1231
1232	ASSERT_OUTSIDE_BEGIN_END( ctx, "glClientActiveTextureARB" );
1233
1234	if (target >= GL_TEXTURE0_ARB && target < GL_TEXTURE0_ARB + maxUnits) {
1235	GLint texUnit = target - GL_TEXTURE0_ARB;
1236	ctx->Array.ActiveTexture = texUnit;
1237	}
1238	else {
1239	gl_error(ctx, GL_INVALID_OPERATION, "glActiveTextureARB(target)");
1240	}
1241	}
1242
1243
1244
1245	/*
1246	* Put the given texture object into the list of dirty texture objects.
1247	* When a texture object is dirty we have to reexamine it for completeness
1248	* and perhaps choose a different texture sampling function.
1249	*/
1250	void gl_put_texobj_on_dirty_list( GLcontext ctx, struct gl_texture_object t )
1251	{
1252	ASSERT(ctx);
1253	ASSERT(t);
1254	/* Only insert if not already in the dirty list.
1255	* The Dirty flag is only set iff the texture object is in the dirty list.
1256	*/
1257	if (!t->Dirty) {
1258	ASSERT(t->NextDirty == NULL);
1259	t->Dirty = GL_TRUE;
1260	t->NextDirty = ctx->Shared->DirtyTexObjList;
1261	ctx->Shared->DirtyTexObjList = t;
1262	}
1263	#ifdef DEBUG
1264	else {
1265	/* make sure t is in the list */
1266	struct gl_texture_object *obj = ctx->Shared->DirtyTexObjList;
1267	while (obj) {
1268	if (obj == t) {
1269	return;
1270	}
1271	obj = obj->NextDirty;
1272	}
1273	gl_problem(ctx, "Error in gl_put_texobj_on_dirty_list");
1274	}
1275	#endif
1276	}
1277
1278
1279	/*
1280	* Remove a texture object from the dirty texture list.
1281	*/
1282	void gl_remove_texobj_from_dirty_list( struct gl_shared_state *shared,
1283	struct gl_texture_object *tObj )
1284	{
1285	struct gl_texture_object t, prev = NULL;
1286	ASSERT(shared);
1287	ASSERT(tObj);
1288	for (t = shared->DirtyTexObjList; t; t = t->NextDirty) {
1289	if (t == tObj) {
1290	if (prev) {
1291	prev->NextDirty = t->NextDirty;
1292	}
1293	else {
1294	shared->DirtyTexObjList = t->NextDirty;
1295	}
1296	return;
1297	}
1298	prev = t;
1299	}
1300	}
1301
1302
1303	/*
1304	* This is called by gl_update_state() if the NEW_TEXTURING bit in
1305	* ctx->NewState is set.
1306	*/
1307	void gl_update_dirty_texobjs( GLcontext *ctx )
1308	{
1309	struct gl_texture_object t, next;
1310	for (t = ctx->Shared->DirtyTexObjList; t; t = next) {
1311	next = t->NextDirty;
1312	gl_test_texture_object_completeness(ctx, t);
1313	gl_set_texture_sampler(t);
1314	t->NextDirty = NULL;
1315	t->Dirty = GL_FALSE;
1316	}
1317	ctx->Shared->DirtyTexObjList = NULL;
1318	}

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

Download in other formats: