state_texdiff.c@ 16939

Last change on this file since 16939 was 15532, checked in by vboxsync, 16 years ago
crOpenGL: export to OSE
Property svn:eol-style set to `native` Property svn:keywords set to `Id`
File size: 59.3 KB

Line
1	/* Copyright (c) 2001, Stanford University
2	* All rights reserved
3	*
4	* See the file LICENSE.txt for information on redistributing this software.
5	*/
6
7	#include "state.h"
8	#include "state/cr_statetypes.h"
9	#include "state/cr_texture.h"
10	#include "cr_hash.h"
11	#include "cr_string.h"
12	#include "cr_mem.h"
13	#include "cr_version.h"
14	#include "state_internals.h"
15
16
17	#define UNIMPLEMENTED() crStateError(__LINE__,__FILE__,GL_INVALID_OPERATION, "Unimplemented something or other" )
18
19
20	#if 0 /* NOT USED??? */
21	void crStateTextureObjSwitchCallback( unsigned long key, void data1, void data2 )
22	{
23	CRTextureObj tobj = (CRTextureObj ) data1;
24	CRContext fromCtx = (CRContext ) data2;
25	unsigned int i = 0;
26	unsigned int j = 0;
27	CRbitvalue *bitID = fromCtx->bitid;
28	CRbitvalue nbitID[CR_MAX_BITARRAY];
29
30	for (j=0;j<CR_MAX_BITARRAY;j++)
31	nbitID[j] = ~bitID[j];
32
33	if (!tobj) return;
34
35	FILLDIRTY(tobj->dirty);
36	FILLDIRTY(tobj->imageBit);
37
38	for (i = 0; i < fromCtx->limits.maxTextureUnits; i++)
39	{
40	int j;
41
42	FILLDIRTY(tobj->paramsBit[i]);
43
44	switch (tobj->target)
45	{
46	case GL_TEXTURE_1D:
47	case GL_TEXTURE_2D:
48	for (j = 0; j <= fromCtx->texture.maxLevel; j++)
49	{
50	CRTextureLevel *tl = &(tobj->level[j]);
51	FILLDIRTY(tl->dirty);
52	}
53	break;
54	#ifdef CR_OPENGL_VERSION_1_2
55	case GL_TEXTURE_3D:
56	#endif
57	for (j = 0; j <= fromCtx->texture.max3DLevel; j++)
58	{
59	CRTextureLevel *tl = &(tobj->level[j]);
60	FILLDIRTY(tl->dirty);
61	}
62	break;
63	#ifdef CR_ARB_texture_cube_map
64	case GL_TEXTURE_CUBE_MAP_ARB:
65	for (j = 0; j <= fromCtx->texture.maxCubeMapLevel; j++)
66	{
67	CRTextureLevel *tl;
68	/* Positive X */
69	tl = &(tobj->level[j]);
70	FILLDIRTY(tl->dirty);
71	/* Negative X */
72	tl = &(tobj->negativeXlevel[j]);
73	FILLDIRTY(tl->dirty);
74	/* Positive Y */
75	tl = &(tobj->positiveYlevel[j]);
76	FILLDIRTY(tl->dirty);
77	/* Negative Y */
78	tl = &(tobj->negativeYlevel[j]);
79	FILLDIRTY(tl->dirty);
80	/* Positive Z */
81	tl = &(tobj->positiveZlevel[j]);
82	FILLDIRTY(tl->dirty);
83	/* Negative Z */
84	tl = &(tobj->negativeZlevel[j]);
85	FILLDIRTY(tl->dirty);
86	}
87	break;
88	#endif
89	default:
90	UNIMPLEMENTED();
91	}
92	}
93	}
94	#endif
95
96
97	void crStateTextureSwitch( CRTextureBits tb, CRbitvalue bitID,
98	CRContext fromCtx, CRContext toCtx )
99	{
100	CRTextureState *from = &(fromCtx->texture);
101	const CRTextureState *to = &(toCtx->texture);
102	unsigned int i,j;
103	glAble able[2];
104	CRbitvalue nbitID[CR_MAX_BITARRAY];
105	unsigned int activeUnit = (unsigned int) -1;
106
107	for (j=0;j<CR_MAX_BITARRAY;j++)
108	nbitID[j] = ~bitID[j];
109	able[0] = diff_api.Disable;
110	able[1] = diff_api.Enable;
111
112	for (i = 0; i < fromCtx->limits.maxTextureUnits; i++)
113	{
114	if (CHECKDIRTY(tb->enable[i], bitID))
115	{
116	if (activeUnit != i) {
117	diff_api.ActiveTextureARB( i + GL_TEXTURE0_ARB );
118	activeUnit = i;
119	}
120	if (from->unit[i].enabled1D != to->unit[i].enabled1D)
121	{
122	able[to->unit[i].enabled1D](GL_TEXTURE_1D);
123	FILLDIRTY(tb->enable[i]);
124	FILLDIRTY(tb->dirty);
125	}
126	if (from->unit[i].enabled2D != to->unit[i].enabled2D)
127	{
128	able[to->unit[i].enabled2D](GL_TEXTURE_2D);
129	FILLDIRTY(tb->enable[i]);
130	FILLDIRTY(tb->dirty);
131	}
132	#ifdef CR_OPENGL_VERSION_1_2
133	if (from->unit[i].enabled3D != to->unit[i].enabled3D)
134	{
135	able[to->unit[i].enabled3D](GL_TEXTURE_3D);
136	FILLDIRTY(tb->enable[i]);
137	FILLDIRTY(tb->dirty);
138	}
139	#endif
140	#ifdef CR_ARB_texture_cube_map
141	if (fromCtx->extensions.ARB_texture_cube_map &&
142	from->unit[i].enabledCubeMap != to->unit[i].enabledCubeMap)
143	{
144	able[to->unit[i].enabledCubeMap](GL_TEXTURE_CUBE_MAP_ARB);
145	FILLDIRTY(tb->enable[i]);
146	FILLDIRTY(tb->dirty);
147	}
148	#endif
149	#ifdef CR_NV_texture_rectangle
150	if (fromCtx->extensions.NV_texture_rectangle &&
151	from->unit[i].enabledRect != to->unit[i].enabledRect)
152	{
153	able[to->unit[i].enabledRect](GL_TEXTURE_RECTANGLE_NV);
154	FILLDIRTY(tb->enable[i]);
155	FILLDIRTY(tb->dirty);
156	}
157	#endif
158	if (from->unit[i].textureGen.s != to->unit[i].textureGen.s \|\|
159	from->unit[i].textureGen.t != to->unit[i].textureGen.t \|\|
160	from->unit[i].textureGen.r != to->unit[i].textureGen.r \|\|
161	from->unit[i].textureGen.q != to->unit[i].textureGen.q)
162	{
163	able[to->unit[i].textureGen.s](GL_TEXTURE_GEN_S);
164	able[to->unit[i].textureGen.t](GL_TEXTURE_GEN_T);
165	able[to->unit[i].textureGen.r](GL_TEXTURE_GEN_R);
166	able[to->unit[i].textureGen.q](GL_TEXTURE_GEN_Q);
167	FILLDIRTY(tb->enable[i]);
168	FILLDIRTY(tb->dirty);
169	}
170	CLEARDIRTY(tb->enable[i], nbitID);
171	}
172
173	/*
174	** A thought on switching with textures:
175	** Since we are only performing a switch
176	** and not a sync, we won't need to
177	** update individual textures, just
178	** the bindings....
179	*/
180
181	if (CHECKDIRTY(tb->current[i], bitID))
182	{
183	if (activeUnit != i) {
184	diff_api.ActiveTextureARB( i + GL_TEXTURE0_ARB );
185	activeUnit = i;
186	}
187	if (from->unit[i].currentTexture1D->name != to->unit[i].currentTexture1D->name)
188	{
189	diff_api.BindTexture(GL_TEXTURE_1D, to->unit[i].currentTexture1D->name);
190	FILLDIRTY(tb->current[i]);
191	FILLDIRTY(tb->dirty);
192	}
193	if (from->unit[i].currentTexture2D->name != to->unit[i].currentTexture2D->name)
194	{
195	diff_api.BindTexture(GL_TEXTURE_2D, to->unit[i].currentTexture2D->name);
196	FILLDIRTY(tb->current[i]);
197	FILLDIRTY(tb->dirty);
198	}
199	#ifdef CR_OPENGL_VERSION_1_2
200	if (from->unit[i].currentTexture3D->name != to->unit[i].currentTexture3D->name) {
201	diff_api.BindTexture(GL_TEXTURE_3D, to->unit[i].currentTexture3D->name);
202	FILLDIRTY(tb->current[i]);
203	FILLDIRTY(tb->dirty);
204	}
205	#endif
206	#ifdef CR_ARB_texture_cube_map
207	if (fromCtx->extensions.ARB_texture_cube_map &&
208	from->unit[i].currentTextureCubeMap->name != to->unit[i].currentTextureCubeMap->name) {
209	diff_api.BindTexture(GL_TEXTURE_CUBE_MAP_ARB, to->unit[i].currentTextureCubeMap->name);
210	FILLDIRTY(tb->current[i]);
211	FILLDIRTY(tb->dirty);
212	}
213	#endif
214	#ifdef CR_NV_texture_rectangle
215	if (fromCtx->extensions.NV_texture_rectangle &&
216	from->unit[i].currentTextureRect->name != to->unit[i].currentTextureRect->name) {
217	diff_api.BindTexture(GL_TEXTURE_RECTANGLE_NV, to->unit[i].currentTextureRect->name);
218	FILLDIRTY(tb->current[i]);
219	FILLDIRTY(tb->dirty);
220	}
221	#endif
222	}
223
224	if (CHECKDIRTY(tb->objGen[i], bitID))
225	{
226	if (activeUnit != i) {
227	diff_api.ActiveTextureARB( i + GL_TEXTURE0_ARB );
228	activeUnit = i;
229	}
230	if (from->unit[i].objSCoeff.x != to->unit[i].objSCoeff.x \|\|
231	from->unit[i].objSCoeff.y != to->unit[i].objSCoeff.y \|\|
232	from->unit[i].objSCoeff.z != to->unit[i].objSCoeff.z \|\|
233	from->unit[i].objSCoeff.w != to->unit[i].objSCoeff.w)
234	{
235	GLfloat f[4];
236	f[0] = to->unit[i].objSCoeff.x;
237	f[1] = to->unit[i].objSCoeff.y;
238	f[2] = to->unit[i].objSCoeff.z;
239	f[3] = to->unit[i].objSCoeff.w;
240	diff_api.TexGenfv (GL_S, GL_OBJECT_PLANE, (const GLfloat *) f);
241	FILLDIRTY(tb->objGen[i]);
242	FILLDIRTY(tb->dirty);
243	}
244	if (from->unit[i].objTCoeff.x != to->unit[i].objTCoeff.x \|\|
245	from->unit[i].objTCoeff.y != to->unit[i].objTCoeff.y \|\|
246	from->unit[i].objTCoeff.z != to->unit[i].objTCoeff.z \|\|
247	from->unit[i].objTCoeff.w != to->unit[i].objTCoeff.w) {
248	GLfloat f[4];
249	f[0] = to->unit[i].objTCoeff.x;
250	f[1] = to->unit[i].objTCoeff.y;
251	f[2] = to->unit[i].objTCoeff.z;
252	f[3] = to->unit[i].objTCoeff.w;
253	diff_api.TexGenfv (GL_T, GL_OBJECT_PLANE, (const GLfloat *) f);
254	FILLDIRTY(tb->objGen[i]);
255	FILLDIRTY(tb->dirty);
256	}
257	if (from->unit[i].objRCoeff.x != to->unit[i].objRCoeff.x \|\|
258	from->unit[i].objRCoeff.y != to->unit[i].objRCoeff.y \|\|
259	from->unit[i].objRCoeff.z != to->unit[i].objRCoeff.z \|\|
260	from->unit[i].objRCoeff.w != to->unit[i].objRCoeff.w) {
261	GLfloat f[4];
262	f[0] = to->unit[i].objRCoeff.x;
263	f[1] = to->unit[i].objRCoeff.y;
264	f[2] = to->unit[i].objRCoeff.z;
265	f[3] = to->unit[i].objRCoeff.w;
266	diff_api.TexGenfv (GL_R, GL_OBJECT_PLANE, (const GLfloat *) f);
267	FILLDIRTY(tb->objGen[i]);
268	FILLDIRTY(tb->dirty);
269	}
270	if (from->unit[i].objQCoeff.x != to->unit[i].objQCoeff.x \|\|
271	from->unit[i].objQCoeff.y != to->unit[i].objQCoeff.y \|\|
272	from->unit[i].objQCoeff.z != to->unit[i].objQCoeff.z \|\|
273	from->unit[i].objQCoeff.w != to->unit[i].objQCoeff.w) {
274	GLfloat f[4];
275	f[0] = to->unit[i].objQCoeff.x;
276	f[1] = to->unit[i].objQCoeff.y;
277	f[2] = to->unit[i].objQCoeff.z;
278	f[3] = to->unit[i].objQCoeff.w;
279	diff_api.TexGenfv (GL_Q, GL_OBJECT_PLANE, (const GLfloat *) f);
280	FILLDIRTY(tb->objGen[i]);
281	FILLDIRTY(tb->dirty);
282	}
283	CLEARDIRTY(tb->objGen[i], nbitID);
284	}
285	if (CHECKDIRTY(tb->eyeGen[i], bitID))
286	{
287	if (activeUnit != i) {
288	diff_api.ActiveTextureARB( i + GL_TEXTURE0_ARB );
289	activeUnit = i;
290	}
291	diff_api.MatrixMode(GL_MODELVIEW);
292	diff_api.PushMatrix();
293	diff_api.LoadIdentity();
294	if (from->unit[i].eyeSCoeff.x != to->unit[i].eyeSCoeff.x \|\|
295	from->unit[i].eyeSCoeff.y != to->unit[i].eyeSCoeff.y \|\|
296	from->unit[i].eyeSCoeff.z != to->unit[i].eyeSCoeff.z \|\|
297	from->unit[i].eyeSCoeff.w != to->unit[i].eyeSCoeff.w) {
298	GLfloat f[4];
299	f[0] = to->unit[i].eyeSCoeff.x;
300	f[1] = to->unit[i].eyeSCoeff.y;
301	f[2] = to->unit[i].eyeSCoeff.z;
302	f[3] = to->unit[i].eyeSCoeff.w;
303	diff_api.TexGenfv (GL_S, GL_EYE_PLANE, (const GLfloat *) f);
304	FILLDIRTY(tb->eyeGen[i]);
305	FILLDIRTY(tb->dirty);
306	}
307	if (from->unit[i].eyeTCoeff.x != to->unit[i].eyeTCoeff.x \|\|
308	from->unit[i].eyeTCoeff.y != to->unit[i].eyeTCoeff.y \|\|
309	from->unit[i].eyeTCoeff.z != to->unit[i].eyeTCoeff.z \|\|
310	from->unit[i].eyeTCoeff.w != to->unit[i].eyeTCoeff.w) {
311	GLfloat f[4];
312	f[0] = to->unit[i].eyeTCoeff.x;
313	f[1] = to->unit[i].eyeTCoeff.y;
314	f[2] = to->unit[i].eyeTCoeff.z;
315	f[3] = to->unit[i].eyeTCoeff.w;
316	diff_api.TexGenfv (GL_T, GL_EYE_PLANE, (const GLfloat *) f);
317	FILLDIRTY(tb->eyeGen[i]);
318	FILLDIRTY(tb->dirty);
319	}
320	if (from->unit[i].eyeRCoeff.x != to->unit[i].eyeRCoeff.x \|\|
321	from->unit[i].eyeRCoeff.y != to->unit[i].eyeRCoeff.y \|\|
322	from->unit[i].eyeRCoeff.z != to->unit[i].eyeRCoeff.z \|\|
323	from->unit[i].eyeRCoeff.w != to->unit[i].eyeRCoeff.w) {
324	GLfloat f[4];
325	f[0] = to->unit[i].eyeRCoeff.x;
326	f[1] = to->unit[i].eyeRCoeff.y;
327	f[2] = to->unit[i].eyeRCoeff.z;
328	f[3] = to->unit[i].eyeRCoeff.w;
329	diff_api.TexGenfv (GL_R, GL_EYE_PLANE, (const GLfloat *) f);
330	FILLDIRTY(tb->eyeGen[i]);
331	FILLDIRTY(tb->dirty);
332	}
333	if (from->unit[i].eyeQCoeff.x != to->unit[i].eyeQCoeff.x \|\|
334	from->unit[i].eyeQCoeff.y != to->unit[i].eyeQCoeff.y \|\|
335	from->unit[i].eyeQCoeff.z != to->unit[i].eyeQCoeff.z \|\|
336	from->unit[i].eyeQCoeff.w != to->unit[i].eyeQCoeff.w) {
337	GLfloat f[4];
338	f[0] = to->unit[i].eyeQCoeff.x;
339	f[1] = to->unit[i].eyeQCoeff.y;
340	f[2] = to->unit[i].eyeQCoeff.z;
341	f[3] = to->unit[i].eyeQCoeff.w;
342	diff_api.TexGenfv (GL_Q, GL_EYE_PLANE, (const GLfloat *) f);
343	FILLDIRTY(tb->eyeGen[i]);
344	FILLDIRTY(tb->dirty);
345	}
346	diff_api.PopMatrix();
347	CLEARDIRTY(tb->eyeGen[i], nbitID);
348	}
349	if (CHECKDIRTY(tb->genMode[i], bitID))
350	{
351	if (activeUnit != i) {
352	diff_api.ActiveTextureARB( i + GL_TEXTURE0_ARB );
353	activeUnit = i;
354	}
355	if (from->unit[i].gen.s != to->unit[i].gen.s \|\|
356	from->unit[i].gen.t != to->unit[i].gen.t \|\|
357	from->unit[i].gen.r != to->unit[i].gen.r \|\|
358	from->unit[i].gen.q != to->unit[i].gen.q)
359	{
360	diff_api.TexGeni (GL_S, GL_TEXTURE_GEN_MODE, to->unit[i].gen.s);
361	diff_api.TexGeni (GL_T, GL_TEXTURE_GEN_MODE, to->unit[i].gen.t);
362	diff_api.TexGeni (GL_R, GL_TEXTURE_GEN_MODE, to->unit[i].gen.r);
363	diff_api.TexGeni (GL_Q, GL_TEXTURE_GEN_MODE, to->unit[i].gen.q);
364	FILLDIRTY(tb->genMode[i]);
365	FILLDIRTY(tb->dirty);
366	}
367	CLEARDIRTY(tb->genMode[i], nbitID);
368	}
369	CLEARDIRTY(tb->dirty, nbitID);
370
371	/* Texture enviroment */
372	if (CHECKDIRTY(tb->envBit[i], bitID))
373	{
374	if (activeUnit != i) {
375	diff_api.ActiveTextureARB( i + GL_TEXTURE0_ARB );
376	activeUnit = i;
377	}
378	if (from->unit[i].envMode != to->unit[i].envMode)
379	{
380	diff_api.TexEnvi (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, to->unit[i].envMode);
381	FILLDIRTY(tb->envBit[i]);
382	FILLDIRTY(tb->dirty);
383	}
384	if (from->unit[i].envColor.r != to->unit[i].envColor.r \|\|
385	from->unit[i].envColor.g != to->unit[i].envColor.g \|\|
386	from->unit[i].envColor.b != to->unit[i].envColor.b \|\|
387	from->unit[i].envColor.a != to->unit[i].envColor.a)
388	{
389	GLfloat f[4];
390	f[0] = to->unit[i].envColor.r;
391	f[1] = to->unit[i].envColor.g;
392	f[2] = to->unit[i].envColor.b;
393	f[3] = to->unit[i].envColor.a;
394	diff_api.TexEnvfv (GL_TEXTURE_ENV, GL_TEXTURE_ENV_COLOR, (const GLfloat *) f);
395	FILLDIRTY(tb->envBit[i]);
396	FILLDIRTY(tb->dirty);
397	}
398	if (from->unit[i].combineModeRGB != to->unit[i].combineModeRGB)
399	{
400	diff_api.TexEnvi(GL_TEXTURE_ENV, GL_COMBINE_RGB_ARB, to->unit[i].combineModeRGB);
401	FILLDIRTY(tb->envBit[i]);
402	FILLDIRTY(tb->dirty);
403	}
404	if (from->unit[i].combineModeA != to->unit[i].combineModeA)
405	{
406	diff_api.TexEnvi(GL_TEXTURE_ENV, GL_COMBINE_ALPHA_ARB, to->unit[i].combineModeA);
407	FILLDIRTY(tb->envBit[i]);
408	FILLDIRTY(tb->dirty);
409	}
410	if (from->unit[i].combineSourceRGB[0] != to->unit[i].combineSourceRGB[0])
411	{
412	diff_api.TexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_RGB_ARB, to->unit[i].combineSourceRGB[0]);
413	FILLDIRTY(tb->envBit[i]);
414	FILLDIRTY(tb->dirty);
415	}
416	if (from->unit[i].combineSourceRGB[1] != to->unit[i].combineSourceRGB[1])
417	{
418	diff_api.TexEnvi(GL_TEXTURE_ENV, GL_SOURCE1_RGB_ARB, to->unit[i].combineSourceRGB[1]);
419	FILLDIRTY(tb->envBit[i]);
420	FILLDIRTY(tb->dirty);
421	}
422	if (from->unit[i].combineSourceRGB[2] != to->unit[i].combineSourceRGB[2])
423	{
424	diff_api.TexEnvi(GL_TEXTURE_ENV, GL_SOURCE2_RGB_ARB, to->unit[i].combineSourceRGB[2]);
425	FILLDIRTY(tb->envBit[i]);
426	FILLDIRTY(tb->dirty);
427	}
428	if (from->unit[i].combineSourceA[0] != to->unit[i].combineSourceA[0])
429	{
430	diff_api.TexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_ALPHA_ARB, to->unit[i].combineSourceA[0]);
431	FILLDIRTY(tb->envBit[i]);
432	FILLDIRTY(tb->dirty);
433	}
434	if (from->unit[i].combineSourceA[1] != to->unit[i].combineSourceA[1])
435	{
436	diff_api.TexEnvi(GL_TEXTURE_ENV, GL_SOURCE1_ALPHA_ARB, to->unit[i].combineSourceA[1]);
437	FILLDIRTY(tb->envBit[i]);
438	FILLDIRTY(tb->dirty);
439	}
440	if (from->unit[i].combineSourceA[2] != to->unit[i].combineSourceA[2])
441	{
442	diff_api.TexEnvi(GL_TEXTURE_ENV, GL_SOURCE2_ALPHA_ARB, to->unit[i].combineSourceA[2]);
443	FILLDIRTY(tb->envBit[i]);
444	FILLDIRTY(tb->dirty);
445	}
446	if (from->unit[i].combineOperandRGB[0] != to->unit[i].combineOperandRGB[0])
447	{
448	diff_api.TexEnvi(GL_TEXTURE_ENV, GL_OPERAND0_RGB_ARB, to->unit[i].combineOperandRGB[0]);
449	FILLDIRTY(tb->envBit[i]);
450	FILLDIRTY(tb->dirty);
451	}
452	if (from->unit[i].combineOperandRGB[1] != to->unit[i].combineOperandRGB[1])
453	{
454	diff_api.TexEnvi(GL_TEXTURE_ENV, GL_OPERAND1_RGB_ARB, to->unit[i].combineOperandRGB[1]);
455	FILLDIRTY(tb->envBit[i]);
456	FILLDIRTY(tb->dirty);
457	}
458	if (from->unit[i].combineOperandRGB[2] != to->unit[i].combineOperandRGB[2])
459	{
460	diff_api.TexEnvi(GL_TEXTURE_ENV, GL_OPERAND2_RGB_ARB, to->unit[i].combineOperandRGB[2]);
461	FILLDIRTY(tb->envBit[i]);
462	FILLDIRTY(tb->dirty);
463	}
464	if (from->unit[i].combineOperandA[0] != to->unit[i].combineOperandA[0])
465	{
466	diff_api.TexEnvi(GL_TEXTURE_ENV, GL_OPERAND0_ALPHA_ARB, to->unit[i].combineOperandA[0]);
467	FILLDIRTY(tb->envBit[i]);
468	FILLDIRTY(tb->dirty);
469	}
470	if (from->unit[i].combineOperandA[1] != to->unit[i].combineOperandA[1])
471	{
472	diff_api.TexEnvi(GL_TEXTURE_ENV, GL_OPERAND1_ALPHA_ARB, to->unit[i].combineOperandA[1]);
473	FILLDIRTY(tb->envBit[i]);
474	FILLDIRTY(tb->dirty);
475	}
476	if (from->unit[i].combineOperandA[2] != to->unit[i].combineOperandA[2])
477	{
478	diff_api.TexEnvi(GL_TEXTURE_ENV, GL_OPERAND2_ALPHA_ARB, to->unit[i].combineOperandA[2]);
479	FILLDIRTY(tb->envBit[i]);
480	FILLDIRTY(tb->dirty);
481	}
482	if (from->unit[i].combineScaleRGB != to->unit[i].combineScaleRGB)
483	{
484	diff_api.TexEnvf(GL_TEXTURE_ENV, GL_RGB_SCALE_ARB, to->unit[i].combineScaleRGB);
485	FILLDIRTY(tb->envBit[i]);
486	FILLDIRTY(tb->dirty);
487	}
488	if (from->unit[i].combineScaleA != to->unit[i].combineScaleA)
489	{
490	diff_api.TexEnvf(GL_TEXTURE_ENV, GL_ALPHA_SCALE, to->unit[i].combineScaleA);
491	FILLDIRTY(tb->envBit[i]);
492	FILLDIRTY(tb->dirty);
493	}
494	CLEARDIRTY(tb->envBit[i], nbitID);
495	}
496	}
497
498	/* Resend texture images */
499	if (toCtx->texture.bResyncNeeded)
500	{
501	toCtx->texture.bResyncNeeded = GL_FALSE;
502
503	crStateDiffAllTextureObjects(toCtx, bitID, GL_TRUE);
504	}
505
506	/* After possible fiddling put them back now */
507	if (activeUnit != toCtx->texture.curTextureUnit) {
508	diff_api.ActiveTextureARB( toCtx->texture.curTextureUnit + GL_TEXTURE0_ARB );
509	}
510	diff_api.MatrixMode(toCtx->transform.matrixMode);
511	}
512
513
514	/*
515	* Check the dirty bits for the specified texture on a given unit to
516	* determine if any of its images are dirty.
517	* Return: 1 -- dirty, 0 -- clean
518	*/
519	int crStateTextureCheckDirtyImages(CRContext from, CRContext to, GLenum target, int textureUnit)
520	{
521	CRContext *g = GetCurrentContext();
522	CRTextureState *tsto;
523	CRbitvalue *bitID;
524	CRTextureObj *tobj = NULL;
525	int maxLevel = 0, i;
526	int face, numFaces;
527
528	CRASSERT(to);
529	CRASSERT(from);
530
531	tsto = &(to->texture);
532	bitID = from->bitid;
533
534	CRASSERT(tsto);
535
536	switch(target)
537	{
538	case GL_TEXTURE_1D:
539	tobj = tsto->unit[textureUnit].currentTexture1D;
540	maxLevel = tsto->maxLevel;
541	break;
542	case GL_TEXTURE_2D:
543	tobj = tsto->unit[textureUnit].currentTexture2D;
544	maxLevel = tsto->maxLevel;
545	break;
546	#ifdef CR_OPENGL_VERSION_1_2
547	case GL_TEXTURE_3D:
548	tobj = tsto->unit[textureUnit].currentTexture3D;
549	maxLevel = tsto->max3DLevel;
550	break;
551	#endif
552	#ifdef CR_ARB_texture_cube_map
553	case GL_TEXTURE_CUBE_MAP:
554	if (g->extensions.ARB_texture_cube_map) {
555	tobj = tsto->unit[textureUnit].currentTextureCubeMap;
556	maxLevel = tsto->maxCubeMapLevel;
557	}
558	break;
559	#endif
560	#ifdef CR_NV_texture_rectangle
561	case GL_TEXTURE_RECTANGLE_NV:
562	if (g->extensions.NV_texture_rectangle) {
563	tobj = tsto->unit[textureUnit].currentTextureRect;
564	maxLevel = 1;
565	}
566	break;
567	#endif
568	default:
569	crError("Bad texture target in crStateTextureCheckDirtyImages()");
570	return 0;
571	}
572
573	if (!tobj)
574	{
575	return 0;
576	}
577
578	numFaces = (target == GL_TEXTURE_CUBE_MAP) ? 6 : 1;
579
580	for (face = 0; face < numFaces; face++) {
581	for (i = 0; i < maxLevel; i++) {
582	if (CHECKDIRTY(tobj->level[face][i].dirty, bitID))
583	return 1;
584	}
585	}
586
587	return 0;
588	}
589
590
591	/*
592	* Do texture state differencing for the given texture object.
593	*/
594	void
595	crStateTextureObjectDiff(CRContext *fromCtx,
596	const CRbitvalue bitID, const CRbitvalue nbitID,
597	CRTextureObj *tobj, GLboolean alwaysDirty)
598	{
599	CRTextureState *from = &(fromCtx->texture);
600	glAble able[2];
601	int u = 0; /* always use texture unit 0 for diff'ing */
602
603	able[0] = diff_api.Disable;
604	able[1] = diff_api.Enable;
605
606	#if 0
607	/* XXX disabling this code fixed Wes Bethel's problem with missing/white
608	* textures. Setting the active texture unit here can screw up the
609	* current texture object bindings.
610	*/
611	/* Set active texture unit, and bind this texture object */
612	if (from->curTextureUnit != u) {
613	diff_api.ActiveTextureARB( u + GL_TEXTURE0_ARB );
614	from->curTextureUnit = u;
615	}
616	#endif
617
618	diff_api.BindTexture( tobj->target, tobj->name );
619
620	if (alwaysDirty \|\| CHECKDIRTY(tobj->paramsBit[u], bitID))
621	{
622	GLfloat f[4];
623	f[0] = tobj->borderColor.r;
624	f[1] = tobj->borderColor.g;
625	f[2] = tobj->borderColor.b;
626	f[3] = tobj->borderColor.a;
627	diff_api.TexParameteri(tobj->target, GL_TEXTURE_BASE_LEVEL, tobj->baseLevel);
628	diff_api.TexParameteri(tobj->target, GL_TEXTURE_MAX_LEVEL, tobj->maxLevel);
629	diff_api.TexParameteri(tobj->target, GL_TEXTURE_MIN_FILTER, tobj->minFilter);
630	diff_api.TexParameteri(tobj->target, GL_TEXTURE_MAG_FILTER, tobj->magFilter);
631	diff_api.TexParameteri(tobj->target, GL_TEXTURE_WRAP_S, tobj->wrapS);
632	diff_api.TexParameteri(tobj->target, GL_TEXTURE_WRAP_T, tobj->wrapT);
633	#ifdef CR_OPENGL_VERSION_1_2
634	diff_api.TexParameteri(tobj->target, GL_TEXTURE_WRAP_R, tobj->wrapR);
635	diff_api.TexParameterf(tobj->target, GL_TEXTURE_PRIORITY, tobj->priority);
636	#endif
637	diff_api.TexParameterfv(tobj->target, GL_TEXTURE_BORDER_COLOR, (const GLfloat *) f);
638	#ifdef CR_EXT_texture_filter_anisotropic
639	if (fromCtx->extensions.EXT_texture_filter_anisotropic) {
640	diff_api.TexParameterf(tobj->target, GL_TEXTURE_MAX_ANISOTROPY_EXT, tobj->maxAnisotropy);
641	}
642	#endif
643	#ifdef CR_ARB_depth_texture
644	if (fromCtx->extensions.ARB_depth_texture)
645	diff_api.TexParameteri(tobj->target, GL_DEPTH_TEXTURE_MODE_ARB, tobj->depthMode);
646	#endif
647	#ifdef CR_ARB_shadow
648	if (fromCtx->extensions.ARB_shadow) {
649	diff_api.TexParameteri(tobj->target, GL_TEXTURE_COMPARE_MODE_ARB, tobj->compareMode);
650	diff_api.TexParameteri(tobj->target, GL_TEXTURE_COMPARE_FUNC_ARB, tobj->compareFunc);
651	}
652	#endif
653	#ifdef CR_ARB_shadow_ambient
654	if (fromCtx->extensions.ARB_shadow_ambient) {
655	diff_api.TexParameterf(tobj->target, GL_TEXTURE_COMPARE_FAIL_VALUE_ARB, tobj->compareFailValue);
656	}
657	#endif
658	#ifdef CR_SGIS_generate_mipmap
659	if (fromCtx->extensions.SGIS_generate_mipmap) {
660	diff_api.TexParameteri(tobj->target, GL_GENERATE_MIPMAP_SGIS, tobj->generateMipmap);
661	}
662	#endif
663	if (!alwaysDirty)
664	CLEARDIRTY(tobj->paramsBit[u], nbitID);
665	}
666
667	/* now, if the texture images are dirty */
668	if (alwaysDirty \|\| CHECKDIRTY(tobj->imageBit, bitID))
669	{
670	int lvl;
671	int face;
672
673	switch (tobj->target)
674	{
675	case GL_TEXTURE_1D:
676	for (lvl = 0; lvl <= from->maxLevel; lvl++)
677	{
678	CRTextureLevel *tl = &(tobj->level[0][lvl]);
679	if (alwaysDirty \|\| CHECKDIRTY(tl->dirty, bitID))
680	{
681	if (tl->generateMipmap) {
682	diff_api.TexParameteri(GL_TEXTURE_2D, GL_GENERATE_MIPMAP_SGIS, 1);
683	}
684	if (tl->compressed) {
685	diff_api.CompressedTexImage1DARB(GL_TEXTURE_1D, lvl,
686	tl->internalFormat, tl->width,
687	tl->border, tl->bytes, tl->img);
688	}
689	else {
690	/* alignment must be one */
691	diff_api.PixelStorei(GL_UNPACK_ROW_LENGTH, 0);
692	diff_api.PixelStorei(GL_UNPACK_SKIP_PIXELS, 0);
693	diff_api.PixelStorei(GL_UNPACK_SKIP_ROWS, 0);
694	diff_api.PixelStorei(GL_UNPACK_ALIGNMENT, 1);
695	if (tl->generateMipmap) {
696	diff_api.TexParameteri(GL_TEXTURE_1D, GL_GENERATE_MIPMAP_SGIS, 1);
697	}
698	diff_api.TexImage1D(GL_TEXTURE_1D, lvl,
699	tl->internalFormat,
700	tl->width, tl->border,
701	tl->format, tl->type, tl->img);
702	}
703	if (!alwaysDirty)
704	CLEARDIRTY(tl->dirty, nbitID);
705	}
706	}
707	break;
708	case GL_TEXTURE_2D:
709	for (lvl = 0; lvl <= from->maxLevel; lvl++)
710	{
711	CRTextureLevel *tl = &(tobj->level[0][lvl]);
712	if (alwaysDirty \|\| CHECKDIRTY(tl->dirty, bitID))
713	{
714	if (tl->generateMipmap) {
715	diff_api.TexParameteri(GL_TEXTURE_2D, GL_GENERATE_MIPMAP_SGIS, 1);
716	}
717	if (tl->compressed) {
718	diff_api.CompressedTexImage2DARB(GL_TEXTURE_2D, lvl,
719	tl->internalFormat, tl->width,
720	tl->height, tl->border,
721	tl->bytes, tl->img);
722	}
723	else {
724	/* alignment must be one */
725	diff_api.PixelStorei(GL_UNPACK_ROW_LENGTH, 0);
726	diff_api.PixelStorei(GL_UNPACK_SKIP_PIXELS, 0);
727	diff_api.PixelStorei(GL_UNPACK_SKIP_ROWS, 0);
728	diff_api.PixelStorei(GL_UNPACK_ALIGNMENT, 1);
729	diff_api.TexImage2D(GL_TEXTURE_2D, lvl,
730	tl->internalFormat,
731	tl->width, tl->height, tl->border,
732	tl->format, tl->type, tl->img);
733	}
734	if (!alwaysDirty)
735	CLEARDIRTY(tl->dirty, nbitID);
736	}
737	}
738	break;
739	#ifdef CR_OPENGL_VERSION_1_2
740	case GL_TEXTURE_3D:
741	for (lvl = 0; lvl <= from->max3DLevel; lvl++)
742	{
743	CRTextureLevel *tl = &(tobj->level[0][lvl]);
744	if (alwaysDirty \|\| CHECKDIRTY(tl->dirty, bitID))
745	{
746	if (tl->generateMipmap) {
747	diff_api.TexParameteri(GL_TEXTURE_3D, GL_GENERATE_MIPMAP_SGIS, 1);
748	}
749	if (tl->compressed) {
750	diff_api.CompressedTexImage3DARB(GL_TEXTURE_3D, lvl,
751	tl->internalFormat, tl->width,
752	tl->height, tl->depth,
753	tl->border, tl->bytes, tl->img);
754	}
755	else {
756	/* alignment must be one */
757	diff_api.PixelStorei(GL_UNPACK_ROW_LENGTH, 0);
758	diff_api.PixelStorei(GL_UNPACK_SKIP_PIXELS, 0);
759	diff_api.PixelStorei(GL_UNPACK_SKIP_ROWS, 0);
760	diff_api.PixelStorei(GL_UNPACK_ALIGNMENT, 1);
761	diff_api.TexImage3D(GL_TEXTURE_3D, lvl,
762	tl->internalFormat,
763	tl->width, tl->height, tl->depth,
764	tl->border, tl->format,
765	tl->type, tl->img);
766	}
767	if (!alwaysDirty)
768	CLEARDIRTY(tl->dirty, nbitID);
769	}
770	}
771	break;
772	#endif
773	#ifdef CR_NV_texture_rectangle
774	case GL_TEXTURE_RECTANGLE_NV:
775	/* only one level */
776	for (lvl = 0; lvl <= from->maxRectLevel; lvl++)
777	{
778	CRTextureLevel *tl = &(tobj->level[0][lvl]);
779	if (alwaysDirty \|\| CHECKDIRTY(tl->dirty, bitID))
780	{
781	if (tl->compressed) {
782	diff_api.CompressedTexImage2DARB(GL_TEXTURE_RECTANGLE_NV, lvl,
783	tl->internalFormat, tl->width,
784	tl->height, tl->border,
785	tl->bytes, tl->img);
786	}
787	else {
788	/* alignment must be one */
789	diff_api.PixelStorei(GL_UNPACK_ROW_LENGTH, 0);
790	diff_api.PixelStorei(GL_UNPACK_SKIP_PIXELS, 0);
791	diff_api.PixelStorei(GL_UNPACK_SKIP_ROWS, 0);
792	diff_api.PixelStorei(GL_UNPACK_ALIGNMENT, 1);
793	diff_api.TexImage2D(GL_TEXTURE_RECTANGLE_NV, lvl,
794	tl->internalFormat,
795	tl->width, tl->height, tl->border,
796	tl->format, tl->type, tl->img);
797	}
798	if (!alwaysDirty)
799	CLEARDIRTY(tl->dirty, nbitID);
800	}
801	}
802	break;
803	#endif
804	#ifdef CR_ARB_texture_cube_map
805	case GL_TEXTURE_CUBE_MAP_ARB:
806	for (face = 0; face < 6; face++)
807	{
808	const GLenum target = GL_TEXTURE_CUBE_MAP_POSITIVE_X + face;
809	for (lvl = 0; lvl <= from->maxCubeMapLevel; lvl++)
810	{
811	CRTextureLevel *tl = &(tobj->level[face][lvl]);
812	if (alwaysDirty \|\| CHECKDIRTY(tl->dirty, bitID))
813	{
814	if (tl->generateMipmap) {
815	diff_api.TexParameteri(GL_TEXTURE_CUBE_MAP_ARB,
816	GL_GENERATE_MIPMAP_SGIS, 1);
817	}
818	if (tl->compressed) {
819	diff_api.CompressedTexImage2DARB(target,
820	lvl, tl->internalFormat,
821	tl->width, tl->height,
822	tl->border, tl->bytes, tl->img);
823	}
824	else {
825	/* alignment must be one */
826	diff_api.PixelStorei(GL_UNPACK_ROW_LENGTH, 0);
827	diff_api.PixelStorei(GL_UNPACK_SKIP_PIXELS, 0);
828	diff_api.PixelStorei(GL_UNPACK_SKIP_ROWS, 0);
829	diff_api.PixelStorei(GL_UNPACK_ALIGNMENT, 1);
830	diff_api.TexImage2D(target, lvl,
831	tl->internalFormat,
832	tl->width, tl->height, tl->border,
833	tl->format, tl->type, tl->img);
834	}
835	if (!alwaysDirty)
836	CLEARDIRTY(tl->dirty, nbitID);
837	}
838	} /* for lvl */
839	} /* for face */
840	break;
841	#endif
842	default:
843	UNIMPLEMENTED();
844
845	} /* switch */
846	} /* if (CHECKDIRTY(tobj->imageBit, bitID)) */
847	}
848
849
850
851	void
852	crStateTextureDiff( CRTextureBits tb, CRbitvalue bitID,
853	CRContext fromCtx, CRContext toCtx )
854	{
855	CRTextureState *from = &(fromCtx->texture);
856	CRTextureState *to = &(toCtx->texture);
857	unsigned int u, t, j;
858	glAble able[2];
859	CRbitvalue nbitID[CR_MAX_BITARRAY];
860	const GLboolean haveFragProg = fromCtx->extensions.ARB_fragment_program \|\| fromCtx->extensions.NV_fragment_program;
861
862	for (j=0;j<CR_MAX_BITARRAY;j++)
863	nbitID[j] = ~bitID[j];
864
865	able[0] = diff_api.Disable;
866	able[1] = diff_api.Enable;
867
868	/* loop over texture units */
869	for (u = 0; u < fromCtx->limits.maxTextureUnits; u++)
870	{
871	CRTextureObj **fromBinding = NULL;
872	CRTextureObj *tobj;
873
874	/* take care of enables/disables */
875	if (CHECKDIRTY(tb->enable[u], bitID))
876	{
877
878	/* Activate texture unit u if needed */
879	if (fromCtx->texture.curTextureUnit != u) {
880	diff_api.ActiveTextureARB( GL_TEXTURE0_ARB + u);
881	fromCtx->texture.curTextureUnit = u;
882	}
883
884	if (from->unit[u].enabled1D != to->unit[u].enabled1D)
885	{
886	able[to->unit[u].enabled1D](GL_TEXTURE_1D);
887	from->unit[u].enabled1D = to->unit[u].enabled1D;
888	}
889	if (from->unit[u].enabled2D != to->unit[u].enabled2D)
890	{
891	able[to->unit[u].enabled2D](GL_TEXTURE_2D);
892	from->unit[u].enabled2D = to->unit[u].enabled2D;
893	}
894	#ifdef CR_OPENGL_VERSION_1_2
895	if (from->unit[u].enabled3D != to->unit[u].enabled3D)
896	{
897	able[to->unit[u].enabled3D](GL_TEXTURE_3D);
898	from->unit[u].enabled3D = to->unit[u].enabled3D;
899	}
900	#endif
901	#ifdef CR_ARB_texture_cube_map
902	if (fromCtx->extensions.ARB_texture_cube_map &&
903	from->unit[u].enabledCubeMap != to->unit[u].enabledCubeMap)
904	{
905	able[to->unit[u].enabledCubeMap](GL_TEXTURE_CUBE_MAP_ARB);
906	from->unit[u].enabledCubeMap = to->unit[u].enabledCubeMap;
907	}
908	#endif
909	#ifdef CR_NV_texture_rectangle
910	if (fromCtx->extensions.NV_texture_rectangle &&
911	from->unit[u].enabledRect != to->unit[u].enabledRect)
912	{
913	able[to->unit[u].enabledRect](GL_TEXTURE_RECTANGLE_NV);
914	from->unit[u].enabledRect = to->unit[u].enabledRect;
915	}
916	#endif
917
918	/* texgen enables */
919	if (from->unit[u].textureGen.s != to->unit[u].textureGen.s \|\|
920	from->unit[u].textureGen.t != to->unit[u].textureGen.t \|\|
921	from->unit[u].textureGen.r != to->unit[u].textureGen.r \|\|
922	from->unit[u].textureGen.q != to->unit[u].textureGen.q)
923	{
924	able[to->unit[u].textureGen.s](GL_TEXTURE_GEN_S);
925	able[to->unit[u].textureGen.t](GL_TEXTURE_GEN_T);
926	able[to->unit[u].textureGen.r](GL_TEXTURE_GEN_R);
927	able[to->unit[u].textureGen.q](GL_TEXTURE_GEN_Q);
928	from->unit[u].textureGen = to->unit[u].textureGen;
929	}
930	CLEARDIRTY(tb->enable[u], nbitID);
931	}
932
933
934	/* Texgen coefficients */
935	if (CHECKDIRTY(tb->objGen[u], bitID))
936	{
937	if (fromCtx->texture.curTextureUnit != u) {
938	diff_api.ActiveTextureARB( u + GL_TEXTURE0_ARB );
939	fromCtx->texture.curTextureUnit = u;
940	}
941	if (from->unit[u].objSCoeff.x != to->unit[u].objSCoeff.x \|\|
942	from->unit[u].objSCoeff.y != to->unit[u].objSCoeff.y \|\|
943	from->unit[u].objSCoeff.z != to->unit[u].objSCoeff.z \|\|
944	from->unit[u].objSCoeff.w != to->unit[u].objSCoeff.w)
945	{
946	GLfloat f[4];
947	f[0] = to->unit[u].objSCoeff.x;
948	f[1] = to->unit[u].objSCoeff.y;
949	f[2] = to->unit[u].objSCoeff.z;
950	f[3] = to->unit[u].objSCoeff.w;
951	diff_api.TexGenfv (GL_S, GL_OBJECT_PLANE, (const GLfloat *) f);
952	from->unit[u].objSCoeff = to->unit[u].objSCoeff;
953	}
954	if (from->unit[u].objTCoeff.x != to->unit[u].objTCoeff.x \|\|
955	from->unit[u].objTCoeff.y != to->unit[u].objTCoeff.y \|\|
956	from->unit[u].objTCoeff.z != to->unit[u].objTCoeff.z \|\|
957	from->unit[u].objTCoeff.w != to->unit[u].objTCoeff.w)
958	{
959	GLfloat f[4];
960	f[0] = to->unit[u].objTCoeff.x;
961	f[1] = to->unit[u].objTCoeff.y;
962	f[2] = to->unit[u].objTCoeff.z;
963	f[3] = to->unit[u].objTCoeff.w;
964	diff_api.TexGenfv (GL_T, GL_OBJECT_PLANE, (const GLfloat *) f);
965	from->unit[u].objTCoeff = to->unit[u].objTCoeff;
966	}
967	if (from->unit[u].objRCoeff.x != to->unit[u].objRCoeff.x \|\|
968	from->unit[u].objRCoeff.y != to->unit[u].objRCoeff.y \|\|
969	from->unit[u].objRCoeff.z != to->unit[u].objRCoeff.z \|\|
970	from->unit[u].objRCoeff.w != to->unit[u].objRCoeff.w)
971	{
972	GLfloat f[4];
973	f[0] = to->unit[u].objRCoeff.x;
974	f[1] = to->unit[u].objRCoeff.y;
975	f[2] = to->unit[u].objRCoeff.z;
976	f[3] = to->unit[u].objRCoeff.w;
977	diff_api.TexGenfv (GL_R, GL_OBJECT_PLANE, (const GLfloat *) f);
978	from->unit[u].objRCoeff = to->unit[u].objRCoeff;
979	}
980	if (from->unit[u].objQCoeff.x != to->unit[u].objQCoeff.x \|\|
981	from->unit[u].objQCoeff.y != to->unit[u].objQCoeff.y \|\|
982	from->unit[u].objQCoeff.z != to->unit[u].objQCoeff.z \|\|
983	from->unit[u].objQCoeff.w != to->unit[u].objQCoeff.w)
984	{
985	GLfloat f[4];
986	f[0] = to->unit[u].objQCoeff.x;
987	f[1] = to->unit[u].objQCoeff.y;
988	f[2] = to->unit[u].objQCoeff.z;
989	f[3] = to->unit[u].objQCoeff.w;
990	diff_api.TexGenfv (GL_Q, GL_OBJECT_PLANE, (const GLfloat *) f);
991	from->unit[u].objQCoeff = to->unit[u].objQCoeff;
992	}
993	CLEARDIRTY(tb->objGen[u], nbitID);
994	}
995	if (CHECKDIRTY(tb->eyeGen[u], bitID))
996	{
997	if (fromCtx->texture.curTextureUnit != u) {
998	diff_api.ActiveTextureARB( u + GL_TEXTURE0_ARB );
999	fromCtx->texture.curTextureUnit = u;
1000	}
1001	if (fromCtx->transform.matrixMode != GL_MODELVIEW) {
1002	diff_api.MatrixMode(GL_MODELVIEW);
1003	fromCtx->transform.matrixMode = GL_MODELVIEW;
1004	}
1005	diff_api.PushMatrix();
1006	diff_api.LoadIdentity();
1007	if (from->unit[u].eyeSCoeff.x != to->unit[u].eyeSCoeff.x \|\|
1008	from->unit[u].eyeSCoeff.y != to->unit[u].eyeSCoeff.y \|\|
1009	from->unit[u].eyeSCoeff.z != to->unit[u].eyeSCoeff.z \|\|
1010	from->unit[u].eyeSCoeff.w != to->unit[u].eyeSCoeff.w)
1011	{
1012	GLfloat f[4];
1013	f[0] = to->unit[u].eyeSCoeff.x;
1014	f[1] = to->unit[u].eyeSCoeff.y;
1015	f[2] = to->unit[u].eyeSCoeff.z;
1016	f[3] = to->unit[u].eyeSCoeff.w;
1017	diff_api.TexGenfv (GL_S, GL_EYE_PLANE, (const GLfloat *) f);
1018	from->unit[u].eyeSCoeff = to->unit[u].eyeSCoeff;
1019	}
1020	if (from->unit[u].eyeTCoeff.x != to->unit[u].eyeTCoeff.x \|\|
1021	from->unit[u].eyeTCoeff.y != to->unit[u].eyeTCoeff.y \|\|
1022	from->unit[u].eyeTCoeff.z != to->unit[u].eyeTCoeff.z \|\|
1023	from->unit[u].eyeTCoeff.w != to->unit[u].eyeTCoeff.w)
1024	{
1025	GLfloat f[4];
1026	f[0] = to->unit[u].eyeTCoeff.x;
1027	f[1] = to->unit[u].eyeTCoeff.y;
1028	f[2] = to->unit[u].eyeTCoeff.z;
1029	f[3] = to->unit[u].eyeTCoeff.w;
1030	diff_api.TexGenfv (GL_T, GL_EYE_PLANE, (const GLfloat *) f);
1031	from->unit[u].eyeTCoeff = to->unit[u].eyeTCoeff;
1032	}
1033	if (from->unit[u].eyeRCoeff.x != to->unit[u].eyeRCoeff.x \|\|
1034	from->unit[u].eyeRCoeff.y != to->unit[u].eyeRCoeff.y \|\|
1035	from->unit[u].eyeRCoeff.z != to->unit[u].eyeRCoeff.z \|\|
1036	from->unit[u].eyeRCoeff.w != to->unit[u].eyeRCoeff.w)
1037	{
1038	GLfloat f[4];
1039	f[0] = to->unit[u].eyeRCoeff.x;
1040	f[1] = to->unit[u].eyeRCoeff.y;
1041	f[2] = to->unit[u].eyeRCoeff.z;
1042	f[3] = to->unit[u].eyeRCoeff.w;
1043	diff_api.TexGenfv (GL_R, GL_EYE_PLANE, (const GLfloat *) f);
1044	from->unit[u].eyeRCoeff = to->unit[u].eyeRCoeff;
1045	}
1046	if (from->unit[u].eyeQCoeff.x != to->unit[u].eyeQCoeff.x \|\|
1047	from->unit[u].eyeQCoeff.y != to->unit[u].eyeQCoeff.y \|\|
1048	from->unit[u].eyeQCoeff.z != to->unit[u].eyeQCoeff.z \|\|
1049	from->unit[u].eyeQCoeff.w != to->unit[u].eyeQCoeff.w)
1050	{
1051	GLfloat f[4];
1052	f[0] = to->unit[u].eyeQCoeff.x;
1053	f[1] = to->unit[u].eyeQCoeff.y;
1054	f[2] = to->unit[u].eyeQCoeff.z;
1055	f[3] = to->unit[u].eyeQCoeff.w;
1056	diff_api.TexGenfv (GL_Q, GL_EYE_PLANE, (const GLfloat *) f);
1057	from->unit[u].eyeQCoeff = to->unit[u].eyeQCoeff;
1058	}
1059	diff_api.PopMatrix();
1060	CLEARDIRTY(tb->eyeGen[u], nbitID);
1061	}
1062	if (CHECKDIRTY(tb->genMode[u], bitID))
1063	{
1064	if (fromCtx->texture.curTextureUnit != u) {
1065	diff_api.ActiveTextureARB( u + GL_TEXTURE0_ARB );
1066	fromCtx->texture.curTextureUnit = u;
1067	}
1068	if (from->unit[u].gen.s != to->unit[u].gen.s \|\|
1069	from->unit[u].gen.t != to->unit[u].gen.t \|\|
1070	from->unit[u].gen.r != to->unit[u].gen.r \|\|
1071	from->unit[u].gen.q != to->unit[u].gen.q)
1072	{
1073	diff_api.TexGeni (GL_S, GL_TEXTURE_GEN_MODE, to->unit[u].gen.s);
1074	diff_api.TexGeni (GL_T, GL_TEXTURE_GEN_MODE, to->unit[u].gen.t);
1075	diff_api.TexGeni (GL_R, GL_TEXTURE_GEN_MODE, to->unit[u].gen.r);
1076	diff_api.TexGeni (GL_Q, GL_TEXTURE_GEN_MODE, to->unit[u].gen.q);
1077	from->unit[u].gen = to->unit[u].gen;
1078	}
1079	CLEARDIRTY(tb->genMode[u], nbitID);
1080	}
1081
1082	/* Texture enviroment */
1083	if (CHECKDIRTY(tb->envBit[u], bitID))
1084	{
1085	if (from->unit[u].envMode != to->unit[u].envMode)
1086	{
1087	diff_api.TexEnvi (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, to->unit[u].envMode);
1088	from->unit[u].envMode = to->unit[u].envMode;
1089	}
1090	if (from->unit[u].envColor.r != to->unit[u].envColor.r \|\|
1091	from->unit[u].envColor.g != to->unit[u].envColor.g \|\|
1092	from->unit[u].envColor.b != to->unit[u].envColor.b \|\|
1093	from->unit[u].envColor.a != to->unit[u].envColor.a)
1094	{
1095	GLfloat f[4];
1096	f[0] = to->unit[u].envColor.r;
1097	f[1] = to->unit[u].envColor.g;
1098	f[2] = to->unit[u].envColor.b;
1099	f[3] = to->unit[u].envColor.a;
1100	diff_api.TexEnvfv (GL_TEXTURE_ENV, GL_TEXTURE_ENV_COLOR, (const GLfloat *) f);
1101	from->unit[u].envColor = to->unit[u].envColor;
1102	}
1103	#ifdef CR_ARB_texture_env_combine
1104	if (from->unit[u].combineModeRGB != to->unit[u].combineModeRGB)
1105	{
1106	diff_api.TexEnvi(GL_TEXTURE_ENV, GL_COMBINE_RGB_ARB, to->unit[u].combineModeRGB);
1107	from->unit[u].combineModeRGB = to->unit[u].combineModeRGB;
1108	}
1109	if (from->unit[u].combineModeA != to->unit[u].combineModeA)
1110	{
1111	diff_api.TexEnvi(GL_TEXTURE_ENV, GL_COMBINE_ALPHA_ARB, to->unit[u].combineModeA);
1112	from->unit[u].combineModeA = to->unit[u].combineModeA;
1113	}
1114	if (from->unit[u].combineSourceRGB[0] != to->unit[u].combineSourceRGB[0])
1115	{
1116	diff_api.TexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_RGB_ARB, to->unit[u].combineSourceRGB[0]);
1117	from->unit[u].combineSourceRGB[0] = to->unit[u].combineSourceRGB[0];
1118	}
1119	if (from->unit[u].combineSourceRGB[1] != to->unit[u].combineSourceRGB[1])
1120	{
1121	diff_api.TexEnvi(GL_TEXTURE_ENV, GL_SOURCE1_RGB_ARB, to->unit[u].combineSourceRGB[1]);
1122	from->unit[u].combineSourceRGB[1] = to->unit[u].combineSourceRGB[1];
1123	}
1124	if (from->unit[u].combineSourceRGB[2] != to->unit[u].combineSourceRGB[2])
1125	{
1126	diff_api.TexEnvi(GL_TEXTURE_ENV, GL_SOURCE2_RGB_ARB, to->unit[u].combineSourceRGB[2]);
1127	from->unit[u].combineSourceRGB[2] = to->unit[u].combineSourceRGB[2];
1128	}
1129	if (from->unit[u].combineSourceA[0] != to->unit[u].combineSourceA[0])
1130	{
1131	diff_api.TexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_ALPHA_ARB, to->unit[u].combineSourceA[0]);
1132	from->unit[u].combineSourceA[0] = to->unit[u].combineSourceA[0];
1133	}
1134	if (from->unit[u].combineSourceA[1] != to->unit[u].combineSourceA[1])
1135	{
1136	diff_api.TexEnvi(GL_TEXTURE_ENV, GL_SOURCE1_ALPHA_ARB, to->unit[u].combineSourceA[1]);
1137	from->unit[u].combineSourceA[1] = to->unit[u].combineSourceA[1];
1138	}
1139	if (from->unit[u].combineSourceA[2] != to->unit[u].combineSourceA[2])
1140	{
1141	diff_api.TexEnvi(GL_TEXTURE_ENV, GL_SOURCE2_ALPHA_ARB, to->unit[u].combineSourceA[2]);
1142	from->unit[u].combineSourceA[2] = to->unit[u].combineSourceA[2];
1143	}
1144	if (from->unit[u].combineOperandRGB[0] != to->unit[u].combineOperandRGB[0])
1145	{
1146	diff_api.TexEnvi(GL_TEXTURE_ENV, GL_OPERAND0_RGB_ARB, to->unit[u].combineOperandRGB[0]);
1147	from->unit[u].combineOperandRGB[0] = to->unit[u].combineOperandRGB[0];
1148	}
1149	if (from->unit[u].combineOperandRGB[1] != to->unit[u].combineOperandRGB[1])
1150	{
1151	diff_api.TexEnvi(GL_TEXTURE_ENV, GL_OPERAND1_RGB_ARB, to->unit[u].combineOperandRGB[1]);
1152	from->unit[u].combineOperandRGB[1] = to->unit[u].combineOperandRGB[1];
1153	}
1154	if (from->unit[u].combineOperandRGB[2] != to->unit[u].combineOperandRGB[2])
1155	{
1156	diff_api.TexEnvi(GL_TEXTURE_ENV, GL_OPERAND2_RGB_ARB, to->unit[u].combineOperandRGB[2]);
1157	from->unit[u].combineOperandRGB[2] = to->unit[u].combineOperandRGB[2];
1158	}
1159	if (from->unit[u].combineOperandA[0] != to->unit[u].combineOperandA[0])
1160	{
1161	diff_api.TexEnvi(GL_TEXTURE_ENV, GL_OPERAND0_ALPHA_ARB, to->unit[u].combineOperandA[0]);
1162	from->unit[u].combineOperandA[0] = to->unit[u].combineOperandA[0];
1163	}
1164	if (from->unit[u].combineOperandA[1] != to->unit[u].combineOperandA[1])
1165	{
1166	diff_api.TexEnvi(GL_TEXTURE_ENV, GL_OPERAND1_ALPHA_ARB, to->unit[u].combineOperandA[1]);
1167	from->unit[u].combineOperandA[1] = to->unit[u].combineOperandA[1];
1168	}
1169	if (from->unit[u].combineOperandA[2] != to->unit[u].combineOperandA[2])
1170	{
1171	diff_api.TexEnvi(GL_TEXTURE_ENV, GL_OPERAND2_ALPHA_ARB, to->unit[u].combineOperandA[2]);
1172	from->unit[u].combineOperandA[2] = to->unit[u].combineOperandA[2];
1173	}
1174	if (from->unit[u].combineScaleRGB != to->unit[u].combineScaleRGB)
1175	{
1176	diff_api.TexEnvf(GL_TEXTURE_ENV, GL_RGB_SCALE_ARB, to->unit[u].combineScaleRGB);
1177	from->unit[u].combineScaleRGB = to->unit[u].combineScaleRGB;
1178	}
1179	if (from->unit[u].combineScaleA != to->unit[u].combineScaleA)
1180	{
1181	diff_api.TexEnvf(GL_TEXTURE_ENV, GL_ALPHA_SCALE, to->unit[u].combineScaleA);
1182	from->unit[u].combineScaleA = to->unit[u].combineScaleA;
1183	}
1184	#endif
1185	#if CR_EXT_texture_lod_bias
1186	if (from->unit[u].lodBias != to->unit[u].lodBias)
1187	{
1188	diff_api.TexEnvf(GL_TEXTURE_FILTER_CONTROL_EXT, GL_TEXTURE_LOD_BIAS_EXT, to->unit[u].lodBias);
1189	from->unit[u].lodBias = to->unit[u].lodBias;
1190	}
1191	#endif
1192	CLEARDIRTY(tb->envBit[u], nbitID);
1193	}
1194
1195	/* loop over texture targets */
1196	for (t = 0; t < 5; t++)
1197	{
1198	tobj = NULL;
1199
1200	switch (t) {
1201	case 0:
1202	if (to->unit[u].enabled1D \|\| haveFragProg) {
1203	tobj = to->unit[u].currentTexture1D;
1204	fromBinding = &(from->unit[u].currentTexture1D);
1205	}
1206	break;
1207	case 1:
1208	if (to->unit[u].enabled2D \|\| haveFragProg) {
1209	tobj = to->unit[u].currentTexture2D;
1210	fromBinding = &(from->unit[u].currentTexture2D);
1211	}
1212	break;
1213	#ifdef CR_OPENGL_VERSION_1_2
1214	case 2:
1215	if (to->unit[u].enabled3D \|\| haveFragProg) {
1216	tobj = to->unit[u].currentTexture3D;
1217	fromBinding = &(from->unit[u].currentTexture3D);
1218	}
1219	break;
1220	#endif
1221	#ifdef CR_ARB_texture_cube_map
1222	case 3:
1223	if (fromCtx->extensions.ARB_texture_cube_map &&
1224	(to->unit[u].enabledCubeMap \|\| haveFragProg)) {
1225	tobj = to->unit[u].currentTextureCubeMap;
1226	fromBinding = &(from->unit[u].currentTextureCubeMap);
1227	}
1228	break;
1229	#endif
1230	#ifdef CR_NV_texture_rectangle
1231	case 4:
1232	if (fromCtx->extensions.NV_texture_rectangle &&
1233	(to->unit[u].enabledRect \|\| haveFragProg)) {
1234	tobj = to->unit[u].currentTextureRect;
1235	fromBinding = &(from->unit[u].currentTextureRect);
1236	}
1237	break;
1238	#endif
1239	default:
1240	/* maybe don't support cube maps or rects */
1241	continue;
1242	}
1243
1244	if (!tobj) {
1245	continue; /* with next target */
1246	}
1247
1248	/* Activate texture unit u if needed */
1249	if (fromCtx->texture.curTextureUnit != u) {
1250	diff_api.ActiveTextureARB( GL_TEXTURE0_ARB + u);
1251	fromCtx->texture.curTextureUnit = u;
1252	}
1253
1254	/* bind this texture if needed */
1255	if (CHECKDIRTY(tb->current[u], bitID))
1256	{
1257	if (*fromBinding != tobj)
1258	{
1259	diff_api.BindTexture(tobj->target, tobj->name);
1260	*fromBinding = tobj;
1261	}
1262	}
1263
1264	/* now, if the texture object is dirty */
1265	if (CHECKDIRTY(tobj->dirty, bitID))
1266	{
1267	crStateTextureObjectDiff(fromCtx, bitID, nbitID, tobj, GL_FALSE);
1268	}
1269	CLEARDIRTY(tobj->dirty, nbitID);
1270
1271	} /* loop over targets */
1272
1273	CLEARDIRTY(tb->current[u], nbitID);
1274
1275	} /* loop over units */
1276
1277	/* After possible fiddling with the active unit, put it back now */
1278	if (fromCtx->texture.curTextureUnit != toCtx->texture.curTextureUnit) {
1279	diff_api.ActiveTextureARB( toCtx->texture.curTextureUnit + GL_TEXTURE0_ARB );
1280	fromCtx->texture.curTextureUnit = toCtx->texture.curTextureUnit;
1281	}
1282	if (fromCtx->transform.matrixMode != toCtx->transform.matrixMode) {
1283	diff_api.MatrixMode(toCtx->transform.matrixMode);
1284	fromCtx->transform.matrixMode = toCtx->transform.matrixMode;
1285	}
1286
1287	CLEARDIRTY(tb->dirty, nbitID);
1288	}
1289
1290
1291
1292	struct callback_info
1293	{
1294	CRbitvalue bitID, nbitID;
1295	CRContext *g;
1296	GLboolean bForceUpdate;
1297	};
1298
1299
1300	/* Called by crHashtableWalk() below */
1301	static void
1302	DiffTextureObjectCallback( unsigned long key, void texObj , void cbData)
1303	{
1304	struct callback_info info = (struct callback_info ) cbData;
1305	CRTextureObj tobj = (CRTextureObj ) texObj;
1306	/*
1307	printf(" Checking %d 0x%x bitid=0x%x\n",tobj->name, tobj->dirty[0], info->bitID[0]);
1308	*/
1309	if (info->bForceUpdate \|\| CHECKDIRTY(tobj->dirty, info->bitID)) {
1310	/*
1311	printf(" Found Dirty! %d\n", tobj->name);
1312	*/
1313	crStateTextureObjectDiff(info->g, info->bitID, info->nbitID, tobj, info->bForceUpdate);
1314	CLEARDIRTY(tobj->dirty, info->nbitID);
1315	}
1316	}
1317
1318
1319	/*
1320	* This isn't used right now, but will be used in the future to fix some
1321	* potential display list problems. Specifically, if glBindTexture is
1322	* in a display list, we have to be sure that all outstanding texture object
1323	* updates are resolved before the list is called. If we don't, we may
1324	* wind up binding texture objects that are stale.
1325	*/
1326	void
1327	crStateDiffAllTextureObjects( CRContext g, CRbitvalue bitID, GLboolean bForceUpdate )
1328	{
1329	CRbitvalue nbitID[CR_MAX_BITARRAY];
1330	struct callback_info info;
1331	int j;
1332	int origUnit, orig1D, orig2D, orig3D, origCube, origRect;
1333
1334	for (j = 0; j < CR_MAX_BITARRAY; j++)
1335	nbitID[j] = ~bitID[j];
1336
1337	info.bitID = bitID;
1338	info.nbitID = nbitID;
1339	info.g = g;
1340	info.bForceUpdate = bForceUpdate;
1341
1342	/* save current texture bindings */
1343	origUnit = g->texture.curTextureUnit;
1344	orig1D = g->texture.unit[0].currentTexture1D->name;
1345	orig2D = g->texture.unit[0].currentTexture2D->name;
1346	orig3D = g->texture.unit[0].currentTexture3D->name;
1347	#ifdef CR_ARB_texture_cube_map
1348	origCube = g->texture.unit[0].currentTextureCubeMap->name;
1349	#endif
1350	#ifdef CR_NV_texture_rectangle
1351	origRect = g->texture.unit[0].currentTextureRect->name;
1352	#endif
1353
1354	/* use texture unit 0 for updates */
1355	diff_api.ActiveTextureARB(GL_TEXTURE0_ARB);
1356
1357	/* diff all the textures */
1358	crHashtableWalk(g->shared->textureTable, DiffTextureObjectCallback, (void *) &info);
1359
1360	/* default ones */
1361	crStateTextureObjectDiff(g, bitID, nbitID, &g->texture.base1D, GL_TRUE);
1362	crStateTextureObjectDiff(g, bitID, nbitID, &g->texture.base2D, GL_TRUE);
1363	crStateTextureObjectDiff(g, bitID, nbitID, &g->texture.base3D, GL_TRUE);
1364	crStateTextureObjectDiff(g, bitID, nbitID, &g->texture.proxy1D, GL_TRUE);
1365	crStateTextureObjectDiff(g, bitID, nbitID, &g->texture.proxy2D, GL_TRUE);
1366	crStateTextureObjectDiff(g, bitID, nbitID, &g->texture.proxy3D, GL_TRUE);
1367	#ifdef CR_ARB_texture_cube_map
1368	crStateTextureObjectDiff(g, bitID, nbitID, &g->texture.baseCubeMap, GL_TRUE);
1369	crStateTextureObjectDiff(g, bitID, nbitID, &g->texture.proxyCubeMap, GL_TRUE);
1370	#endif
1371	#ifdef CR_NV_texture_rectangle
1372	if (g->extensions.NV_texture_rectangle)
1373	{
1374	crStateTextureObjectDiff(g, bitID, nbitID, &g->texture.baseRect, GL_TRUE);
1375	crStateTextureObjectDiff(g, bitID, nbitID, &g->texture.proxyRect, GL_TRUE);
1376	}
1377	#endif
1378
1379	/* restore bindings */
1380	diff_api.ActiveTextureARB(GL_TEXTURE0_ARB + origUnit);
1381	diff_api.BindTexture(GL_TEXTURE_1D, orig1D);
1382	diff_api.BindTexture(GL_TEXTURE_2D, orig2D);
1383	diff_api.BindTexture(GL_TEXTURE_3D, orig3D);
1384	#ifdef CR_ARB_texture_cube_map
1385	diff_api.BindTexture(GL_TEXTURE_CUBE_MAP_ARB, origCube);
1386	#endif
1387	#ifdef CR_NV_texture_rectangle
1388	diff_api.BindTexture(GL_TEXTURE_RECTANGLE_NV, origRect);
1389	#endif
1390	}

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

source: vbox/trunk/src/VBox/GuestHost/OpenGL/state_tracker/state_texdiff.c@ 16939

Download in other formats: