state.c@ 20817

Last change on this file since 20817 was 20612, checked in by vboxsync, 16 years ago
crOpenGL: update wine to 1.1.23
Property svn:eol-style set to `native`
File size: 336.0 KB

Line
1	/*
2	* Direct3D state management
3	*
4	* Copyright 2002 Lionel Ulmer
5	* Copyright 2002-2005 Jason Edmeades
6	* Copyright 2003-2004 Raphael Junqueira
7	* Copyright 2004 Christian Costa
8	* Copyright 2005 Oliver Stieber
9	* Copyright 2006 Henri Verbeet
10	* Copyright 2006-2008 Stefan Dösinger for CodeWeavers
11	*
12	* This library is free software; you can redistribute it and/or
13	* modify it under the terms of the GNU Lesser General Public
14	* License as published by the Free Software Foundation; either
15	* version 2.1 of the License, or (at your option) any later version.
16	*
17	* This library is distributed in the hope that it will be useful,
18	* but WITHOUT ANY WARRANTY; without even the implied warranty of
19	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
20	* Lesser General Public License for more details.
21	*
22	* You should have received a copy of the GNU Lesser General Public
23	* License along with this library; if not, write to the Free Software
24	* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
25	*/
26
27	/*
28	* Sun LGPL Disclaimer: For the avoidance of doubt, except that if any license choice
29	* other than GPL or LGPL is available it will apply instead, Sun elects to use only
30	* the Lesser General Public License version 2.1 (LGPLv2) at this time for any software where
31	* a choice of LGPL license versions is made available with the language indicating
32	* that LGPLv2 or any later version may be used, or where a choice of which version
33	* of the LGPL is applied is otherwise unspecified.
34	*/
35
36	#include "config.h"
37	#include <stdio.h>
38	#ifdef HAVE_FLOAT_H
39	/* GL locking for state handlers is done by the caller. */
40
41	# include <float.h>
42	#endif
43	#include "wined3d_private.h"
44
45	WINE_DEFAULT_DEBUG_CHANNEL(d3d);
46	WINE_DECLARE_DEBUG_CHANNEL(d3d_shader);
47
48	#define GLINFO_LOCATION stateblock->wineD3DDevice->adapter->gl_info
49
50	static void state_blendop(DWORD state, IWineD3DStateBlockImpl stateblock, WineD3DContext context);
51
52	static void state_nogl(DWORD state, IWineD3DStateBlockImpl stateblock, WineD3DContext context) {
53	/* Used for states which are not mapped to a gl state as-is, but used somehow different,
54	* e.g as a parameter for drawing, or which are unimplemented in windows d3d
55	*/
56	if(STATE_IS_RENDER(state)) {
57	WINED3DRENDERSTATETYPE RenderState = state - STATE_RENDER(0);
58	TRACE("(%s,%d) no direct mapping to gl\n", debug_d3drenderstate(RenderState), stateblock->renderState[RenderState]);
59	} else {
60	/* Shouldn't have an unknown type here */
61	FIXME("%d no direct mapping to gl of state with unknown type\n", state);
62	}
63	}
64
65	static void state_undefined(DWORD state, IWineD3DStateBlockImpl stateblock, WineD3DContext context) {
66	/* Print a WARN, this allows the stateblock code to loop over all states to generate a display
67	* list without causing confusing terminal output. Deliberately no special debug name here
68	* because its undefined.
69	*/
70	WARN("undefined state %d\n", state);
71	}
72
73	static void state_fillmode(DWORD state, IWineD3DStateBlockImpl stateblock, WineD3DContext context) {
74	WINED3DFILLMODE Value = stateblock->renderState[WINED3DRS_FILLMODE];
75
76	switch(Value) {
77	case WINED3DFILL_POINT:
78	glPolygonMode(GL_FRONT_AND_BACK, GL_POINT);
79	checkGLcall("glPolygonMode(GL_FRONT_AND_BACK, GL_POINT)");
80	break;
81	case WINED3DFILL_WIREFRAME:
82	glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
83	checkGLcall("glPolygonMode(GL_FRONT_AND_BACK, GL_LINE)");
84	break;
85	case WINED3DFILL_SOLID:
86	glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
87	checkGLcall("glPolygonMode(GL_FRONT_AND_BACK, GL_FILL)");
88	break;
89	default:
90	FIXME("Unrecognized WINED3DRS_FILLMODE value %d\n", Value);
91	}
92	}
93
94	static void state_lighting(DWORD state, IWineD3DStateBlockImpl stateblock, WineD3DContext context) {
95	/* Lighting is not enabled if transformed vertices are drawn
96	* but lighting does not affect the stream sources, so it is not grouped for performance reasons.
97	* This state reads the decoded vertex declaration, so if it is dirty don't do anything. The
98	* vertex declaration applying function calls this function for updating
99	*/
100
101	if(isStateDirty(context, STATE_VDECL)) {
102	return;
103	}
104
105	if (stateblock->renderState[WINED3DRS_LIGHTING]
106	&& !stateblock->wineD3DDevice->strided_streams.position_transformed)
107	{
108	glEnable(GL_LIGHTING);
109	checkGLcall("glEnable GL_LIGHTING");
110	} else {
111	glDisable(GL_LIGHTING);
112	checkGLcall("glDisable GL_LIGHTING");
113	}
114	}
115
116	static void state_zenable(DWORD state, IWineD3DStateBlockImpl stateblock, WineD3DContext context) {
117	/* No z test without depth stencil buffers */
118	if(stateblock->wineD3DDevice->stencilBufferTarget == NULL) {
119	TRACE("No Z buffer - disabling depth test\n");
120	glDisable(GL_DEPTH_TEST); /* This also disables z writing in gl */
121	checkGLcall("glDisable GL_DEPTH_TEST");
122	return;
123	}
124
125	switch ((WINED3DZBUFFERTYPE) stateblock->renderState[WINED3DRS_ZENABLE]) {
126	case WINED3DZB_FALSE:
127	glDisable(GL_DEPTH_TEST);
128	checkGLcall("glDisable GL_DEPTH_TEST");
129	break;
130	case WINED3DZB_TRUE:
131	glEnable(GL_DEPTH_TEST);
132	checkGLcall("glEnable GL_DEPTH_TEST");
133	break;
134	case WINED3DZB_USEW:
135	glEnable(GL_DEPTH_TEST);
136	checkGLcall("glEnable GL_DEPTH_TEST");
137	FIXME("W buffer is not well handled\n");
138	break;
139	default:
140	FIXME("Unrecognized D3DZBUFFERTYPE value %d\n", stateblock->renderState[WINED3DRS_ZENABLE]);
141	}
142	}
143
144	static void state_cullmode(DWORD state, IWineD3DStateBlockImpl stateblock, WineD3DContext context) {
145	/* glFrontFace() is set in context.c at context init and on an offscreen / onscreen rendering
146	* switch
147	*/
148	switch ((WINED3DCULL) stateblock->renderState[WINED3DRS_CULLMODE]) {
149	case WINED3DCULL_NONE:
150	glDisable(GL_CULL_FACE);
151	checkGLcall("glDisable GL_CULL_FACE");
152	break;
153	case WINED3DCULL_CW:
154	glEnable(GL_CULL_FACE);
155	checkGLcall("glEnable GL_CULL_FACE");
156	glCullFace(GL_FRONT);
157	checkGLcall("glCullFace(GL_FRONT)");
158	break;
159	case WINED3DCULL_CCW:
160	glEnable(GL_CULL_FACE);
161	checkGLcall("glEnable GL_CULL_FACE");
162	glCullFace(GL_BACK);
163	checkGLcall("glCullFace(GL_BACK)");
164	break;
165	default:
166	FIXME("Unrecognized/Unhandled WINED3DCULL value %d\n", stateblock->renderState[WINED3DRS_CULLMODE]);
167	}
168	}
169
170	static void state_shademode(DWORD state, IWineD3DStateBlockImpl stateblock, WineD3DContext context) {
171	switch ((WINED3DSHADEMODE) stateblock->renderState[WINED3DRS_SHADEMODE]) {
172	case WINED3DSHADE_FLAT:
173	glShadeModel(GL_FLAT);
174	checkGLcall("glShadeModel(GL_FLAT)");
175	break;
176	case WINED3DSHADE_GOURAUD:
177	glShadeModel(GL_SMOOTH);
178	checkGLcall("glShadeModel(GL_SMOOTH)");
179	break;
180	case WINED3DSHADE_PHONG:
181	FIXME("WINED3DSHADE_PHONG isn't supported\n");
182	break;
183	default:
184	FIXME("Unrecognized/Unhandled WINED3DSHADEMODE value %d\n", stateblock->renderState[WINED3DRS_SHADEMODE]);
185	}
186	}
187
188	static void state_ditherenable(DWORD state, IWineD3DStateBlockImpl stateblock, WineD3DContext context) {
189	if (stateblock->renderState[WINED3DRS_DITHERENABLE]) {
190	glEnable(GL_DITHER);
191	checkGLcall("glEnable GL_DITHER");
192	} else {
193	glDisable(GL_DITHER);
194	checkGLcall("glDisable GL_DITHER");
195	}
196	}
197
198	static void state_zwritenable(DWORD state, IWineD3DStateBlockImpl stateblock, WineD3DContext context) {
199	/* TODO: Test if in d3d z writing is enabled even if ZENABLE is off. If yes,
200	* this has to be merged with ZENABLE and ZFUNC
201	*/
202	if (stateblock->renderState[WINED3DRS_ZWRITEENABLE]) {
203	glDepthMask(1);
204	checkGLcall("glDepthMask(1)");
205	} else {
206	glDepthMask(0);
207	checkGLcall("glDepthMask(0)");
208	}
209	}
210
211	static void state_zfunc(DWORD state, IWineD3DStateBlockImpl stateblock, WineD3DContext context) {
212	int glParm = CompareFunc(stateblock->renderState[WINED3DRS_ZFUNC]);
213
214	if(glParm) {
215	if(glParm == GL_EQUAL \|\| glParm == GL_NOTEQUAL) {
216	static BOOL once = FALSE;
217	/* There are a few issues with this: First, our inability to
218	* select a proper Z depth, most of the time we're stuck with
219	* D24S8, even if the app selects D32 or D16. There seem to be
220	* some other precision problems which have to be debugged to
221	* make NOTEQUAL and EQUAL work properly
222	*/
223	if(!once) {
224	once = TRUE;
225	FIXME("D3DCMP_NOTEQUAL and D3DCMP_EQUAL do not work correctly yet\n");
226	}
227	}
228
229	glDepthFunc(glParm);
230	checkGLcall("glDepthFunc");
231	}
232	}
233
234	static void state_ambient(DWORD state, IWineD3DStateBlockImpl stateblock, WineD3DContext context) {
235	float col[4];
236	D3DCOLORTOGLFLOAT4(stateblock->renderState[WINED3DRS_AMBIENT], col);
237
238	TRACE("Setting ambient to (%f,%f,%f,%f)\n", col[0], col[1], col[2], col[3]);
239	glLightModelfv(GL_LIGHT_MODEL_AMBIENT, col);
240	checkGLcall("glLightModel for MODEL_AMBIENT");
241	}
242
243	static void state_blend(DWORD state, IWineD3DStateBlockImpl stateblock, WineD3DContext context) {
244	int srcBlend = GL_ZERO;
245	int dstBlend = GL_ZERO;
246	IWineD3DSurfaceImpl target = (IWineD3DSurfaceImpl ) stateblock->wineD3DDevice->render_targets[0];
247
248	/* GL_LINE_SMOOTH needs GL_BLEND to work, according to the red book, and special blending params */
249	if (stateblock->renderState[WINED3DRS_ALPHABLENDENABLE] \|\|
250	stateblock->renderState[WINED3DRS_EDGEANTIALIAS] \|\|
251	stateblock->renderState[WINED3DRS_ANTIALIASEDLINEENABLE]) {
252
253	/* Disable blending in all cases even without pixelshaders. With blending on we could face a big performance penalty.
254	* The d3d9 visual test confirms the behavior. */
255	if (!(target->resource.format_desc->Flags & WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING))
256	{
257	glDisable(GL_BLEND);
258	checkGLcall("glDisable GL_BLEND");
259	return;
260	} else {
261	glEnable(GL_BLEND);
262	checkGLcall("glEnable GL_BLEND");
263	}
264	} else {
265	glDisable(GL_BLEND);
266	checkGLcall("glDisable GL_BLEND");
267	/* Nothing more to do - get out */
268	return;
269	};
270
271	switch (stateblock->renderState[WINED3DRS_DESTBLEND]) {
272	case WINED3DBLEND_ZERO : dstBlend = GL_ZERO; break;
273	case WINED3DBLEND_ONE : dstBlend = GL_ONE; break;
274	case WINED3DBLEND_SRCCOLOR : dstBlend = GL_SRC_COLOR; break;
275	case WINED3DBLEND_INVSRCCOLOR : dstBlend = GL_ONE_MINUS_SRC_COLOR; break;
276	case WINED3DBLEND_SRCALPHA : dstBlend = GL_SRC_ALPHA; break;
277	case WINED3DBLEND_INVSRCALPHA : dstBlend = GL_ONE_MINUS_SRC_ALPHA; break;
278	case WINED3DBLEND_DESTCOLOR : dstBlend = GL_DST_COLOR; break;
279	case WINED3DBLEND_INVDESTCOLOR : dstBlend = GL_ONE_MINUS_DST_COLOR; break;
280
281	/* To compensate the lack of format switching with backbuffer offscreen rendering,
282	* and with onscreen rendering, we modify the alpha test parameters for (INV)DESTALPHA
283	* if the render target doesn't support alpha blending. A nonexistent alpha channel
284	* returns 1.0, so D3DBLEND_DESTALPHA is GL_ONE, and D3DBLEND_INVDESTALPHA is GL_ZERO
285	*/
286	case WINED3DBLEND_DESTALPHA :
287	dstBlend = target->resource.format_desc->alpha_mask ? GL_DST_ALPHA : GL_ONE;
288	break;
289	case WINED3DBLEND_INVDESTALPHA :
290	dstBlend = target->resource.format_desc->alpha_mask ? GL_ONE_MINUS_DST_ALPHA : GL_ZERO;
291	break;
292
293	case WINED3DBLEND_SRCALPHASAT :
294	dstBlend = GL_SRC_ALPHA_SATURATE;
295	WARN("Application uses SRCALPHASAT as dest blend factor, expect problems\n");
296	break;
297
298	/* WINED3DBLEND_BOTHSRCALPHA and WINED3DBLEND_BOTHINVSRCALPHA are legacy source blending
299	* values which are still valid up to d3d9. They should not occur as dest blend values
300	*/
301	case WINED3DBLEND_BOTHSRCALPHA : dstBlend = GL_SRC_ALPHA;
302	srcBlend = GL_SRC_ALPHA;
303	FIXME("WINED3DRS_DESTBLEND = WINED3DBLEND_BOTHSRCALPHA, what to do?\n");
304	break;
305
306	case WINED3DBLEND_BOTHINVSRCALPHA : dstBlend = GL_ONE_MINUS_SRC_ALPHA;
307	srcBlend = GL_ONE_MINUS_SRC_ALPHA;
308	FIXME("WINED3DRS_DESTBLEND = WINED3DBLEND_BOTHINVSRCALPHA, what to do?\n");
309	break;
310
311	case WINED3DBLEND_BLENDFACTOR : dstBlend = GL_CONSTANT_COLOR; break;
312	case WINED3DBLEND_INVBLENDFACTOR : dstBlend = GL_ONE_MINUS_CONSTANT_COLOR; break;
313	default:
314	FIXME("Unrecognized dst blend value %d\n", stateblock->renderState[WINED3DRS_DESTBLEND]);
315	}
316
317	switch (stateblock->renderState[WINED3DRS_SRCBLEND]) {
318	case WINED3DBLEND_ZERO : srcBlend = GL_ZERO; break;
319	case WINED3DBLEND_ONE : srcBlend = GL_ONE; break;
320	case WINED3DBLEND_SRCCOLOR : srcBlend = GL_SRC_COLOR; break;
321	case WINED3DBLEND_INVSRCCOLOR : srcBlend = GL_ONE_MINUS_SRC_COLOR; break;
322	case WINED3DBLEND_SRCALPHA : srcBlend = GL_SRC_ALPHA; break;
323	case WINED3DBLEND_INVSRCALPHA : srcBlend = GL_ONE_MINUS_SRC_ALPHA; break;
324	case WINED3DBLEND_DESTCOLOR : srcBlend = GL_DST_COLOR; break;
325	case WINED3DBLEND_INVDESTCOLOR : srcBlend = GL_ONE_MINUS_DST_COLOR; break;
326	case WINED3DBLEND_SRCALPHASAT : srcBlend = GL_SRC_ALPHA_SATURATE; break;
327
328	case WINED3DBLEND_DESTALPHA :
329	srcBlend = target->resource.format_desc->alpha_mask ? GL_DST_ALPHA : GL_ONE;
330	break;
331	case WINED3DBLEND_INVDESTALPHA :
332	srcBlend = target->resource.format_desc->alpha_mask ? GL_ONE_MINUS_DST_ALPHA : GL_ZERO;
333	break;
334
335	case WINED3DBLEND_BOTHSRCALPHA : srcBlend = GL_SRC_ALPHA;
336	dstBlend = GL_ONE_MINUS_SRC_ALPHA;
337	break;
338
339	case WINED3DBLEND_BOTHINVSRCALPHA : srcBlend = GL_ONE_MINUS_SRC_ALPHA;
340	dstBlend = GL_SRC_ALPHA;
341	break;
342
343	case WINED3DBLEND_BLENDFACTOR : srcBlend = GL_CONSTANT_COLOR; break;
344	case WINED3DBLEND_INVBLENDFACTOR : srcBlend = GL_ONE_MINUS_CONSTANT_COLOR; break;
345	default:
346	FIXME("Unrecognized src blend value %d\n", stateblock->renderState[WINED3DRS_SRCBLEND]);
347	}
348
349	if(stateblock->renderState[WINED3DRS_EDGEANTIALIAS] \|\|
350	stateblock->renderState[WINED3DRS_ANTIALIASEDLINEENABLE]) {
351	glEnable(GL_LINE_SMOOTH);
352	checkGLcall("glEnable(GL_LINE_SMOOTH)");
353	if(srcBlend != GL_SRC_ALPHA) {
354	WARN("WINED3DRS_EDGEANTIALIAS enabled, but unexpected src blending param\n");
355	}
356	if(dstBlend != GL_ONE_MINUS_SRC_ALPHA && dstBlend != GL_ONE) {
357	WARN("WINED3DRS_EDGEANTIALIAS enabled, but unexpected dst blending param\n");
358	}
359	} else {
360	glDisable(GL_LINE_SMOOTH);
361	checkGLcall("glDisable(GL_LINE_SMOOTH)");
362	}
363
364	/* Re-apply BLENDOP(ALPHA) because of a possible SEPARATEALPHABLENDENABLE change */
365	if(!isStateDirty(context, STATE_RENDER(WINED3DRS_BLENDOP))) {
366	state_blendop(STATE_RENDER(WINED3DRS_BLENDOPALPHA), stateblock, context);
367	}
368
369	if(stateblock->renderState[WINED3DRS_SEPARATEALPHABLENDENABLE]) {
370	int srcBlendAlpha = GL_ZERO;
371	int dstBlendAlpha = GL_ZERO;
372
373	/* Separate alpha blending requires GL_EXT_blend_function_separate, so make sure it is around */
374	if(!GL_SUPPORT(EXT_BLEND_FUNC_SEPARATE)) {
375	WARN("Unsupported in local OpenGL implementation: glBlendFuncSeparateEXT\n");
376	return;
377	}
378
379	switch (stateblock->renderState[WINED3DRS_DESTBLENDALPHA]) {
380	case WINED3DBLEND_ZERO : dstBlendAlpha = GL_ZERO; break;
381	case WINED3DBLEND_ONE : dstBlendAlpha = GL_ONE; break;
382	case WINED3DBLEND_SRCCOLOR : dstBlendAlpha = GL_SRC_COLOR; break;
383	case WINED3DBLEND_INVSRCCOLOR : dstBlendAlpha = GL_ONE_MINUS_SRC_COLOR; break;
384	case WINED3DBLEND_SRCALPHA : dstBlendAlpha = GL_SRC_ALPHA; break;
385	case WINED3DBLEND_INVSRCALPHA : dstBlendAlpha = GL_ONE_MINUS_SRC_ALPHA; break;
386	case WINED3DBLEND_DESTCOLOR : dstBlendAlpha = GL_DST_COLOR; break;
387	case WINED3DBLEND_INVDESTCOLOR : dstBlendAlpha = GL_ONE_MINUS_DST_COLOR; break;
388	case WINED3DBLEND_DESTALPHA : dstBlendAlpha = GL_DST_ALPHA; break;
389	case WINED3DBLEND_INVDESTALPHA : dstBlendAlpha = GL_DST_ALPHA; break;
390	case WINED3DBLEND_SRCALPHASAT :
391	dstBlend = GL_SRC_ALPHA_SATURATE;
392	WARN("Application uses SRCALPHASAT as dest blend factor, expect problems\n");
393	break;
394	/* WINED3DBLEND_BOTHSRCALPHA and WINED3DBLEND_BOTHINVSRCALPHA are legacy source blending
395	* values which are still valid up to d3d9. They should not occur as dest blend values
396	*/
397	case WINED3DBLEND_BOTHSRCALPHA :
398	dstBlendAlpha = GL_SRC_ALPHA;
399	srcBlendAlpha = GL_SRC_ALPHA;
400	FIXME("WINED3DRS_DESTBLENDALPHA = WINED3DBLEND_BOTHSRCALPHA, what to do?\n");
401	break;
402	case WINED3DBLEND_BOTHINVSRCALPHA :
403	dstBlendAlpha = GL_ONE_MINUS_SRC_ALPHA;
404	srcBlendAlpha = GL_ONE_MINUS_SRC_ALPHA;
405	FIXME("WINED3DRS_DESTBLENDALPHA = WINED3DBLEND_BOTHINVSRCALPHA, what to do?\n");
406	break;
407	case WINED3DBLEND_BLENDFACTOR : dstBlendAlpha = GL_CONSTANT_COLOR; break;
408	case WINED3DBLEND_INVBLENDFACTOR : dstBlendAlpha = GL_ONE_MINUS_CONSTANT_COLOR; break;
409	default:
410	FIXME("Unrecognized dst blend alpha value %d\n", stateblock->renderState[WINED3DRS_DESTBLENDALPHA]);
411	}
412
413	switch (stateblock->renderState[WINED3DRS_SRCBLENDALPHA]) {
414	case WINED3DBLEND_ZERO : srcBlendAlpha = GL_ZERO; break;
415	case WINED3DBLEND_ONE : srcBlendAlpha = GL_ONE; break;
416	case WINED3DBLEND_SRCCOLOR : srcBlendAlpha = GL_SRC_COLOR; break;
417	case WINED3DBLEND_INVSRCCOLOR : srcBlendAlpha = GL_ONE_MINUS_SRC_COLOR; break;
418	case WINED3DBLEND_SRCALPHA : srcBlendAlpha = GL_SRC_ALPHA; break;
419	case WINED3DBLEND_INVSRCALPHA : srcBlendAlpha = GL_ONE_MINUS_SRC_ALPHA; break;
420	case WINED3DBLEND_DESTCOLOR : srcBlendAlpha = GL_DST_COLOR; break;
421	case WINED3DBLEND_INVDESTCOLOR : srcBlendAlpha = GL_ONE_MINUS_DST_COLOR; break;
422	case WINED3DBLEND_SRCALPHASAT : srcBlendAlpha = GL_SRC_ALPHA_SATURATE; break;
423	case WINED3DBLEND_DESTALPHA : srcBlendAlpha = GL_DST_ALPHA; break;
424	case WINED3DBLEND_INVDESTALPHA : srcBlendAlpha = GL_DST_ALPHA; break;
425	case WINED3DBLEND_BOTHSRCALPHA :
426	srcBlendAlpha = GL_SRC_ALPHA;
427	dstBlendAlpha = GL_ONE_MINUS_SRC_ALPHA;
428	break;
429	case WINED3DBLEND_BOTHINVSRCALPHA :
430	srcBlendAlpha = GL_ONE_MINUS_SRC_ALPHA;
431	dstBlendAlpha = GL_SRC_ALPHA;
432	break;
433	case WINED3DBLEND_BLENDFACTOR : srcBlendAlpha = GL_CONSTANT_COLOR; break;
434	case WINED3DBLEND_INVBLENDFACTOR : srcBlendAlpha = GL_ONE_MINUS_CONSTANT_COLOR; break;
435	default:
436	FIXME("Unrecognized src blend alpha value %d\n", stateblock->renderState[WINED3DRS_SRCBLENDALPHA]);
437	}
438
439	GL_EXTCALL(glBlendFuncSeparateEXT(srcBlend, dstBlend, srcBlendAlpha, dstBlendAlpha));
440	checkGLcall("glBlendFuncSeparateEXT");
441	} else {
442	TRACE("glBlendFunc src=%x, dst=%x\n", srcBlend, dstBlend);
443	glBlendFunc(srcBlend, dstBlend);
444	checkGLcall("glBlendFunc");
445	}
446
447	/* colorkey fixup for stage 0 alphaop depends on WINED3DRS_ALPHABLENDENABLE state,
448	so it may need updating */
449	if (stateblock->renderState[WINED3DRS_COLORKEYENABLE]) {
450	const struct StateEntry *StateTable = stateblock->wineD3DDevice->StateTable;
451	StateTable[STATE_TEXTURESTAGE(0, WINED3DTSS_ALPHAOP)].apply(STATE_TEXTURESTAGE(0, WINED3DTSS_ALPHAOP), stateblock, context);
452	}
453	}
454
455	static void state_blendfactor_w(DWORD state, IWineD3DStateBlockImpl stateblock, WineD3DContext context) {
456	WARN("Unsupported in local OpenGL implementation: glBlendColorEXT\n");
457	}
458
459	static void state_blendfactor(DWORD state, IWineD3DStateBlockImpl stateblock, WineD3DContext context) {
460	float col[4];
461
462	TRACE("Setting BlendFactor to %d\n", stateblock->renderState[WINED3DRS_BLENDFACTOR]);
463	D3DCOLORTOGLFLOAT4(stateblock->renderState[WINED3DRS_BLENDFACTOR], col);
464	GL_EXTCALL(glBlendColorEXT (col[0],col[1],col[2],col[3]));
465	checkGLcall("glBlendColor");
466	}
467
468	static void state_alpha(DWORD state, IWineD3DStateBlockImpl stateblock, WineD3DContext context) {
469	int glParm = 0;
470	float ref;
471	BOOL enable_ckey = FALSE;
472
473	TRACE("state %#x, stateblock %p, context %p\n", state, stateblock, context);
474
475	/* Find out if the texture on the first stage has a ckey set
476	* The alpha state func reads the texture settings, even though alpha and texture are not grouped
477	* together. This is to avoid making a huge alpha+texture+texture stage+ckey block due to the hardly
478	* used WINED3DRS_COLORKEYENABLE state(which is d3d <= 3 only). The texture function will call alpha
479	* in case it finds some texture+colorkeyenable combination which needs extra care.
480	*/
481	if (stateblock->textures[0])
482	{
483	UINT texture_dimensions = IWineD3DBaseTexture_GetTextureDimensions(stateblock->textures[0]);
484
485	if (texture_dimensions == GL_TEXTURE_2D \|\| texture_dimensions == GL_TEXTURE_RECTANGLE_ARB)
486	{
487	IWineD3DSurfaceImpl *surf;
488
489	surf = (IWineD3DSurfaceImpl ) ((IWineD3DTextureImpl )stateblock->textures[0])->surfaces[0];
490
491	if (surf->CKeyFlags & WINEDDSD_CKSRCBLT)
492	{
493	/* The surface conversion does not do color keying conversion for surfaces that have an alpha
494	* channel on their own. Likewise, the alpha test shouldn't be set up for color keying if the
495	* surface has alpha bits */
496	if (!surf->resource.format_desc->alpha_mask) enable_ckey = TRUE;
497	}
498	}
499	}
500
501	if(enable_ckey \|\| context->last_was_ckey) {
502	const struct StateEntry *StateTable = stateblock->wineD3DDevice->StateTable;
503	StateTable[STATE_TEXTURESTAGE(0, WINED3DTSS_ALPHAOP)].apply(STATE_TEXTURESTAGE(0, WINED3DTSS_ALPHAOP), stateblock, context);
504	}
505	context->last_was_ckey = enable_ckey;
506
507	if (stateblock->renderState[WINED3DRS_ALPHATESTENABLE] \|\|
508	(stateblock->renderState[WINED3DRS_COLORKEYENABLE] && enable_ckey)) {
509	glEnable(GL_ALPHA_TEST);
510	checkGLcall("glEnable GL_ALPHA_TEST");
511	} else {
512	glDisable(GL_ALPHA_TEST);
513	checkGLcall("glDisable GL_ALPHA_TEST");
514	/* Alpha test is disabled, don't bother setting the params - it will happen on the next
515	* enable call
516	*/
517	return;
518	}
519
520	if(stateblock->renderState[WINED3DRS_COLORKEYENABLE] && enable_ckey) {
521	glParm = GL_NOTEQUAL;
522	ref = 0.0;
523	} else {
524	ref = ((float) stateblock->renderState[WINED3DRS_ALPHAREF]) / 255.0f;
525	glParm = CompareFunc(stateblock->renderState[WINED3DRS_ALPHAFUNC]);
526	}
527	if(glParm) {
528	glAlphaFunc(glParm, ref);
529	checkGLcall("glAlphaFunc");
530	}
531	}
532
533	static void state_clipping(DWORD state, IWineD3DStateBlockImpl stateblock, WineD3DContext context) {
534	DWORD enable = 0xFFFFFFFF;
535	DWORD disable = 0x00000000;
536
537	if (!stateblock->wineD3DDevice->vs_clipping && use_vs(stateblock))
538	{
539	/* The spec says that opengl clipping planes are disabled when using shaders. Direct3D planes aren't,
540	* so that is an issue. The MacOS ATI driver keeps clipping planes activated with shaders in some
541	* conditions I got sick of tracking down. The shader state handler disables all clip planes because
542	* of that - don't do anything here and keep them disabled
543	*/
544	if(stateblock->renderState[WINED3DRS_CLIPPLANEENABLE]) {
545	static BOOL warned = FALSE;
546	if(!warned) {
547	FIXME("Clipping not supported with vertex shaders\n");
548	warned = TRUE;
549	}
550	}
551	return;
552	}
553
554	/* TODO: Keep track of previously enabled clipplanes to avoid unnecessary resetting
555	* of already set values
556	*/
557
558	/* If enabling / disabling all
559	* TODO: Is this correct? Doesn't D3DRS_CLIPPING disable clipping on the viewport frustrum?
560	*/
561	if (stateblock->renderState[WINED3DRS_CLIPPING]) {
562	enable = stateblock->renderState[WINED3DRS_CLIPPLANEENABLE];
563	disable = ~stateblock->renderState[WINED3DRS_CLIPPLANEENABLE];
564	if(GL_SUPPORT(NV_DEPTH_CLAMP)) {
565	glDisable(GL_DEPTH_CLAMP_NV);
566	checkGLcall("glDisable(GL_DEPTH_CLAMP_NV)");
567	}
568	} else {
569	disable = 0xffffffff;
570	enable = 0x00;
571	if(GL_SUPPORT(NV_DEPTH_CLAMP)) {
572	glEnable(GL_DEPTH_CLAMP_NV);
573	checkGLcall("glEnable(GL_DEPTH_CLAMP_NV)");
574	}
575	}
576
577	if (enable & WINED3DCLIPPLANE0) { glEnable(GL_CLIP_PLANE0); checkGLcall("glEnable(clip plane 0)"); }
578	if (enable & WINED3DCLIPPLANE1) { glEnable(GL_CLIP_PLANE1); checkGLcall("glEnable(clip plane 1)"); }
579	if (enable & WINED3DCLIPPLANE2) { glEnable(GL_CLIP_PLANE2); checkGLcall("glEnable(clip plane 2)"); }
580	if (enable & WINED3DCLIPPLANE3) { glEnable(GL_CLIP_PLANE3); checkGLcall("glEnable(clip plane 3)"); }
581	if (enable & WINED3DCLIPPLANE4) { glEnable(GL_CLIP_PLANE4); checkGLcall("glEnable(clip plane 4)"); }
582	if (enable & WINED3DCLIPPLANE5) { glEnable(GL_CLIP_PLANE5); checkGLcall("glEnable(clip plane 5)"); }
583
584	if (disable & WINED3DCLIPPLANE0) { glDisable(GL_CLIP_PLANE0); checkGLcall("glDisable(clip plane 0)"); }
585	if (disable & WINED3DCLIPPLANE1) { glDisable(GL_CLIP_PLANE1); checkGLcall("glDisable(clip plane 1)"); }
586	if (disable & WINED3DCLIPPLANE2) { glDisable(GL_CLIP_PLANE2); checkGLcall("glDisable(clip plane 2)"); }
587	if (disable & WINED3DCLIPPLANE3) { glDisable(GL_CLIP_PLANE3); checkGLcall("glDisable(clip plane 3)"); }
588	if (disable & WINED3DCLIPPLANE4) { glDisable(GL_CLIP_PLANE4); checkGLcall("glDisable(clip plane 4)"); }
589	if (disable & WINED3DCLIPPLANE5) { glDisable(GL_CLIP_PLANE5); checkGLcall("glDisable(clip plane 5)"); }
590
591	/** update clipping status */
592	if (enable) {
593	stateblock->clip_status.ClipUnion = 0;
594	stateblock->clip_status.ClipIntersection = 0xFFFFFFFF;
595	} else {
596	stateblock->clip_status.ClipUnion = 0;
597	stateblock->clip_status.ClipIntersection = 0;
598	}
599	}
600
601	static void state_blendop_w(DWORD state, IWineD3DStateBlockImpl stateblock, WineD3DContext context) {
602	WARN("Unsupported in local OpenGL implementation: glBlendEquation\n");
603	}
604
605	static void state_blendop(DWORD state, IWineD3DStateBlockImpl stateblock, WineD3DContext context) {
606	int blendEquation = GL_FUNC_ADD;
607	int blendEquationAlpha = GL_FUNC_ADD;
608
609	/* BLENDOPALPHA requires GL_EXT_blend_equation_separate, so make sure it is around */
610	if(stateblock->renderState[WINED3DRS_BLENDOPALPHA] && !GL_SUPPORT(EXT_BLEND_EQUATION_SEPARATE)) {
611	WARN("Unsupported in local OpenGL implementation: glBlendEquationSeparateEXT\n");
612	return;
613	}
614
615	switch ((WINED3DBLENDOP) stateblock->renderState[WINED3DRS_BLENDOP]) {
616	case WINED3DBLENDOP_ADD : blendEquation = GL_FUNC_ADD; break;
617	case WINED3DBLENDOP_SUBTRACT : blendEquation = GL_FUNC_SUBTRACT; break;
618	case WINED3DBLENDOP_REVSUBTRACT : blendEquation = GL_FUNC_REVERSE_SUBTRACT; break;
619	case WINED3DBLENDOP_MIN : blendEquation = GL_MIN; break;
620	case WINED3DBLENDOP_MAX : blendEquation = GL_MAX; break;
621	default:
622	FIXME("Unrecognized/Unhandled D3DBLENDOP value %d\n", stateblock->renderState[WINED3DRS_BLENDOP]);
623	}
624
625	switch ((WINED3DBLENDOP) stateblock->renderState[WINED3DRS_BLENDOPALPHA]) {
626	case WINED3DBLENDOP_ADD : blendEquationAlpha = GL_FUNC_ADD; break;
627	case WINED3DBLENDOP_SUBTRACT : blendEquationAlpha = GL_FUNC_SUBTRACT; break;
628	case WINED3DBLENDOP_REVSUBTRACT : blendEquationAlpha = GL_FUNC_REVERSE_SUBTRACT; break;
629	case WINED3DBLENDOP_MIN : blendEquationAlpha = GL_MIN; break;
630	case WINED3DBLENDOP_MAX : blendEquationAlpha = GL_MAX; break;
631	default:
632	FIXME("Unrecognized/Unhandled D3DBLENDOP value %d\n", stateblock->renderState[WINED3DRS_BLENDOPALPHA]);
633	}
634
635	if(stateblock->renderState[WINED3DRS_SEPARATEALPHABLENDENABLE]) {
636	TRACE("glBlendEquationSeparateEXT(%x, %x)\n", blendEquation, blendEquationAlpha);
637	GL_EXTCALL(glBlendEquationSeparateEXT(blendEquation, blendEquationAlpha));
638	checkGLcall("glBlendEquationSeparateEXT");
639	} else {
640	TRACE("glBlendEquation(%x)\n", blendEquation);
641	GL_EXTCALL(glBlendEquationEXT(blendEquation));
642	checkGLcall("glBlendEquation");
643	}
644	}
645
646	static void
647	state_specularenable(DWORD state, IWineD3DStateBlockImpl stateblock, WineD3DContext context) {
648	/* Originally this used glLightModeli(GL_LIGHT_MODEL_COLOR_CONTROL,GL_SEPARATE_SPECULAR_COLOR)
649	* and (GL_LIGHT_MODEL_COLOR_CONTROL,GL_SINGLE_COLOR) to swap between enabled/disabled
650	* specular color. This is wrong:
651	* Separate specular color means the specular colour is maintained separately, whereas
652	* single color means it is merged in. However in both cases they are being used to
653	* some extent.
654	* To disable specular color, set it explicitly to black and turn off GL_COLOR_SUM_EXT
655	* NOTE: If not supported don't give FIXMEs the impact is really minimal and very few people are
656	* running 1.4 yet!
657	*
658	*
659	* If register combiners are enabled, enabling / disabling GL_COLOR_SUM has no effect.
660	* Instead, we need to setup the FinalCombiner properly.
661	*
662	* The default setup for the FinalCombiner is:
663	*
664	* <variable> <input> <mapping> <usage>
665	* GL_VARIABLE_A_NV GL_FOG, GL_UNSIGNED_IDENTITY_NV GL_ALPHA
666	* GL_VARIABLE_B_NV GL_SPARE0_PLUS_SECONDARY_COLOR_NV GL_UNSIGNED_IDENTITY_NV GL_RGB
667	* GL_VARIABLE_C_NV GL_FOG GL_UNSIGNED_IDENTITY_NV GL_RGB
668	* GL_VARIABLE_D_NV GL_ZERO GL_UNSIGNED_IDENTITY_NV GL_RGB
669	* GL_VARIABLE_E_NV GL_ZERO GL_UNSIGNED_IDENTITY_NV GL_RGB
670	* GL_VARIABLE_F_NV GL_ZERO GL_UNSIGNED_IDENTITY_NV GL_RGB
671	* GL_VARIABLE_G_NV GL_SPARE0_NV GL_UNSIGNED_IDENTITY_NV GL_ALPHA
672	*
673	* That's pretty much fine as it is, except for variable B, which needs to take
674	* either GL_SPARE0_PLUS_SECONDARY_COLOR_NV or GL_SPARE0_NV, depending on
675	* whether WINED3DRS_SPECULARENABLE is enabled or not.
676	*/
677
678	TRACE("Setting specular enable state and materials\n");
679	if (stateblock->renderState[WINED3DRS_SPECULARENABLE]) {
680	glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, (float*) &stateblock->material.Specular);
681	checkGLcall("glMaterialfv");
682
683	if(stateblock->material.Power > GL_LIMITS(shininess)) {
684	/* glMaterialf man page says that the material says that GL_SHININESS must be between 0.0
685	* and 128.0, although in d3d neither -1 nor 129 produce an error. GL_NV_max_light_exponent
686	* allows bigger values. If the extension is supported, GL_LIMITS(shininess) contains the
687	* value reported by the extension, otherwise 128. For values > GL_LIMITS(shininess) clamp
688	* them, it should be safe to do so without major visual distortions.
689	*/
690	WARN("Material power = %f, limit %f\n", stateblock->material.Power, GL_LIMITS(shininess));
691	glMaterialf(GL_FRONT_AND_BACK, GL_SHININESS, GL_LIMITS(shininess));
692	} else {
693	glMaterialf(GL_FRONT_AND_BACK, GL_SHININESS, stateblock->material.Power);
694	}
695	checkGLcall("glMaterialf(GL_SHININESS)");
696
697	if (GL_SUPPORT(EXT_SECONDARY_COLOR)) {
698	glEnable(GL_COLOR_SUM_EXT);
699	} else {
700	TRACE("Specular colors cannot be enabled in this version of opengl\n");
701	}
702	checkGLcall("glEnable(GL_COLOR_SUM)");
703
704	if (GL_SUPPORT(NV_REGISTER_COMBINERS)) {
705	GL_EXTCALL(glFinalCombinerInputNV(GL_VARIABLE_B_NV, GL_SPARE0_PLUS_SECONDARY_COLOR_NV, GL_UNSIGNED_IDENTITY_NV, GL_RGB));
706	checkGLcall("glFinalCombinerInputNV()");
707	}
708	} else {
709	static const GLfloat black[] = {0.0f, 0.0f, 0.0f, 0.0f};
710
711	/* for the case of enabled lighting: */
712	glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, &black[0]);
713	checkGLcall("glMaterialfv");
714
715	/* for the case of disabled lighting: */
716	if (GL_SUPPORT(EXT_SECONDARY_COLOR)) {
717	glDisable(GL_COLOR_SUM_EXT);
718	} else {
719	TRACE("Specular colors cannot be disabled in this version of opengl\n");
720	}
721	checkGLcall("glDisable(GL_COLOR_SUM)");
722
723	if (GL_SUPPORT(NV_REGISTER_COMBINERS)) {
724	GL_EXTCALL(glFinalCombinerInputNV(GL_VARIABLE_B_NV, GL_SPARE0_NV, GL_UNSIGNED_IDENTITY_NV, GL_RGB));
725	checkGLcall("glFinalCombinerInputNV()");
726	}
727	}
728
729	TRACE("(%p) : Diffuse (%f,%f,%f,%f)\n", stateblock->wineD3DDevice, stateblock->material.Diffuse.r, stateblock->material.Diffuse.g,
730	stateblock->material.Diffuse.b, stateblock->material.Diffuse.a);
731	TRACE("(%p) : Ambient (%f,%f,%f,%f)\n", stateblock->wineD3DDevice, stateblock->material.Ambient.r, stateblock->material.Ambient.g,
732	stateblock->material.Ambient.b, stateblock->material.Ambient.a);
733	TRACE("(%p) : Specular (%f,%f,%f,%f)\n", stateblock->wineD3DDevice, stateblock->material.Specular.r, stateblock->material.Specular.g,
734	stateblock->material.Specular.b, stateblock->material.Specular.a);
735	TRACE("(%p) : Emissive (%f,%f,%f,%f)\n", stateblock->wineD3DDevice, stateblock->material.Emissive.r, stateblock->material.Emissive.g,
736	stateblock->material.Emissive.b, stateblock->material.Emissive.a);
737
738	glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT, (float*) &stateblock->material.Ambient);
739	checkGLcall("glMaterialfv(GL_AMBIENT)");
740	glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, (float*) &stateblock->material.Diffuse);
741	checkGLcall("glMaterialfv(GL_DIFFUSE)");
742	glMaterialfv(GL_FRONT_AND_BACK, GL_EMISSION, (float*) &stateblock->material.Emissive);
743	checkGLcall("glMaterialfv(GL_EMISSION)");
744	}
745
746	static void state_texfactor(DWORD state, IWineD3DStateBlockImpl stateblock, WineD3DContext context) {
747	unsigned int i;
748
749	/* Note the texture color applies to all textures whereas
750	* GL_TEXTURE_ENV_COLOR applies to active only
751	*/
752	float col[4];
753	D3DCOLORTOGLFLOAT4(stateblock->renderState[WINED3DRS_TEXTUREFACTOR], col);
754
755	/* And now the default texture color as well */
756	for (i = 0; i < GL_LIMITS(texture_stages); i++) {
757	/* Note the WINED3DRS value applies to all textures, but GL has one
758	* per texture, so apply it now ready to be used!
759	*/
760	GL_EXTCALL(glActiveTextureARB(GL_TEXTURE0_ARB + i));
761	checkGLcall("glActiveTextureARB");
762
763	glTexEnvfv(GL_TEXTURE_ENV, GL_TEXTURE_ENV_COLOR, &col[0]);
764	checkGLcall("glTexEnvfv(GL_TEXTURE_ENV, GL_TEXTURE_ENV_COLOR, color);");
765	}
766	}
767
768	static void
769	renderstate_stencil_twosided(IWineD3DStateBlockImpl *stateblock, GLint face, GLint func, GLint ref, GLuint mask, GLint stencilFail, GLint depthFail, GLint stencilPass ) {
770	glEnable(GL_STENCIL_TEST_TWO_SIDE_EXT);
771	checkGLcall("glEnable(GL_STENCIL_TEST_TWO_SIDE_EXT)");
772	GL_EXTCALL(glActiveStencilFaceEXT(face));
773	checkGLcall("glActiveStencilFaceEXT(...)");
774	glStencilFunc(func, ref, mask);
775	checkGLcall("glStencilFunc(...)");
776	glStencilOp(stencilFail, depthFail, stencilPass);
777	checkGLcall("glStencilOp(...)");
778	}
779
780	static void
781	state_stencil(DWORD state, IWineD3DStateBlockImpl stateblock, WineD3DContext context) {
782	DWORD onesided_enable = FALSE;
783	DWORD twosided_enable = FALSE;
784	GLint func = GL_ALWAYS;
785	GLint func_ccw = GL_ALWAYS;
786	GLint ref = 0;
787	GLuint mask = 0;
788	GLint stencilFail = GL_KEEP;
789	GLint depthFail = GL_KEEP;
790	GLint stencilPass = GL_KEEP;
791	GLint stencilFail_ccw = GL_KEEP;
792	GLint depthFail_ccw = GL_KEEP;
793	GLint stencilPass_ccw = GL_KEEP;
794
795	/* No stencil test without a stencil buffer */
796	if(stateblock->wineD3DDevice->stencilBufferTarget == NULL) {
797	glDisable(GL_STENCIL_TEST);
798	checkGLcall("glDisable GL_STENCIL_TEST");
799	return;
800	}
801
802	onesided_enable = stateblock->renderState[WINED3DRS_STENCILENABLE];
803	twosided_enable = stateblock->renderState[WINED3DRS_TWOSIDEDSTENCILMODE];
804	if( !( func = CompareFunc(stateblock->renderState[WINED3DRS_STENCILFUNC]) ) )
805	func = GL_ALWAYS;
806	if( !( func_ccw = CompareFunc(stateblock->renderState[WINED3DRS_CCW_STENCILFUNC]) ) )
807	func_ccw = GL_ALWAYS;
808	ref = stateblock->renderState[WINED3DRS_STENCILREF];
809	mask = stateblock->renderState[WINED3DRS_STENCILMASK];
810	stencilFail = StencilOp(stateblock->renderState[WINED3DRS_STENCILFAIL]);
811	depthFail = StencilOp(stateblock->renderState[WINED3DRS_STENCILZFAIL]);
812	stencilPass = StencilOp(stateblock->renderState[WINED3DRS_STENCILPASS]);
813	stencilFail_ccw = StencilOp(stateblock->renderState[WINED3DRS_CCW_STENCILFAIL]);
814	depthFail_ccw = StencilOp(stateblock->renderState[WINED3DRS_CCW_STENCILZFAIL]);
815	stencilPass_ccw = StencilOp(stateblock->renderState[WINED3DRS_CCW_STENCILPASS]);
816
817	TRACE("(onesided %d, twosided %d, ref %x, mask %x, "
818	"GL_FRONT: func: %x, fail %x, zfail %x, zpass %x "
819	"GL_BACK: func: %x, fail %x, zfail %x, zpass %x )\n",
820	onesided_enable, twosided_enable, ref, mask,
821	func, stencilFail, depthFail, stencilPass,
822	func_ccw, stencilFail_ccw, depthFail_ccw, stencilPass_ccw);
823
824	if (twosided_enable && onesided_enable) {
825	glEnable(GL_STENCIL_TEST);
826	checkGLcall("glEnable GL_STENCIL_TEST");
827
828	if(GL_SUPPORT(EXT_STENCIL_TWO_SIDE)) {
829	/* Apply back first, then front. This function calls glActiveStencilFaceEXT,
830	* which has an effect on the code below too. If we apply the front face
831	* afterwards, we are sure that the active stencil face is set to front,
832	* and other stencil functions which do not use two sided stencil do not have
833	* to set it back
834	*/
835	renderstate_stencil_twosided(stateblock, GL_BACK, func_ccw, ref, mask,
836	stencilFail_ccw, depthFail_ccw, stencilPass_ccw);
837	renderstate_stencil_twosided(stateblock, GL_FRONT, func, ref, mask,
838	stencilFail, depthFail, stencilPass);
839	} else if(GL_SUPPORT(ATI_SEPARATE_STENCIL)) {
840	GL_EXTCALL(glStencilFuncSeparateATI(func, func_ccw, ref, mask));
841	checkGLcall("glStencilFuncSeparateATI(...)");
842	GL_EXTCALL(glStencilOpSeparateATI(GL_FRONT, stencilFail, depthFail, stencilPass));
843	checkGLcall("glStencilOpSeparateATI(GL_FRONT, ...)");
844	GL_EXTCALL(glStencilOpSeparateATI(GL_BACK, stencilFail_ccw, depthFail_ccw, stencilPass_ccw));
845	checkGLcall("glStencilOpSeparateATI(GL_BACK, ...)");
846	} else {
847	ERR("Separate (two sided) stencil not supported on this version of opengl. Caps weren't honored?\n");
848	}
849	} else if(onesided_enable) {
850	if(GL_SUPPORT(EXT_STENCIL_TWO_SIDE)) {
851	glDisable(GL_STENCIL_TEST_TWO_SIDE_EXT);
852	checkGLcall("glDisable(GL_STENCIL_TEST_TWO_SIDE_EXT)");
853	}
854
855	/* This code disables the ATI extension as well, since the standard stencil functions are equal
856	* to calling the ATI functions with GL_FRONT_AND_BACK as face parameter
857	*/
858	glEnable(GL_STENCIL_TEST);
859	checkGLcall("glEnable GL_STENCIL_TEST");
860	glStencilFunc(func, ref, mask);
861	checkGLcall("glStencilFunc(...)");
862	glStencilOp(stencilFail, depthFail, stencilPass);
863	checkGLcall("glStencilOp(...)");
864	} else {
865	glDisable(GL_STENCIL_TEST);
866	checkGLcall("glDisable GL_STENCIL_TEST");
867	}
868	}
869
870	static void state_stencilwrite2s(DWORD state, IWineD3DStateBlockImpl stateblock, WineD3DContext context) {
871	DWORD mask;
872
873	if(stateblock->wineD3DDevice->stencilBufferTarget) {
874	mask = stateblock->renderState[WINED3DRS_STENCILWRITEMASK];
875	} else {
876	mask = 0;
877	}
878
879	GL_EXTCALL(glActiveStencilFaceEXT(GL_BACK));
880	checkGLcall("glActiveStencilFaceEXT(GL_BACK)");
881	glStencilMask(mask);
882	checkGLcall("glStencilMask");
883	GL_EXTCALL(glActiveStencilFaceEXT(GL_FRONT));
884	checkGLcall("glActiveStencilFaceEXT(GL_FRONT)");
885	glStencilMask(mask);
886	}
887
888	static void state_stencilwrite(DWORD state, IWineD3DStateBlockImpl stateblock, WineD3DContext context) {
889	DWORD mask;
890
891	if(stateblock->wineD3DDevice->stencilBufferTarget) {
892	mask = stateblock->renderState[WINED3DRS_STENCILWRITEMASK];
893	} else {
894	mask = 0;
895	}
896
897	glStencilMask(mask);
898	checkGLcall("glStencilMask");
899	}
900
901	static void state_fog_vertexpart(DWORD state, IWineD3DStateBlockImpl stateblock, WineD3DContext context) {
902
903	TRACE("state %#x, stateblock %p, context %p\n", state, stateblock, context);
904
905	if (!stateblock->renderState[WINED3DRS_FOGENABLE]) return;
906
907	/* Table fog on: Never use fog coords, and use per-fragment fog */
908	if(stateblock->renderState[WINED3DRS_FOGTABLEMODE] != WINED3DFOG_NONE) {
909	glHint(GL_FOG_HINT, GL_NICEST);
910	if(context->fog_coord) {
911	glFogi(GL_FOG_COORDINATE_SOURCE_EXT, GL_FRAGMENT_DEPTH_EXT);
912	checkGLcall("glFogi(GL_FOG_COORDINATE_SOURCE_EXT, GL_FRAGMENT_DEPTH_EXT)");
913	context->fog_coord = FALSE;
914	}
915	return;
916	}
917
918	/* Otherwise use per-vertex fog in any case */
919	glHint(GL_FOG_HINT, GL_FASTEST);
920
921	if(stateblock->renderState[WINED3DRS_FOGVERTEXMODE] == WINED3DFOG_NONE \|\| context->last_was_rhw) {
922	/* No fog at all, or transformed vertices: Use fog coord */
923	if(!context->fog_coord) {
924	glFogi(GL_FOG_COORDINATE_SOURCE_EXT, GL_FOG_COORDINATE_EXT);
925	checkGLcall("glFogi(GL_FOG_COORDINATE_SOURCE_EXT, GL_FOG_COORDINATE_EXT)");
926	context->fog_coord = TRUE;
927	}
928	} else {
929	/* Otherwise, use the fragment depth */
930	if(context->fog_coord) {
931	glFogi(GL_FOG_COORDINATE_SOURCE_EXT, GL_FRAGMENT_DEPTH_EXT);
932	checkGLcall("glFogi(GL_FOG_COORDINATE_SOURCE_EXT, GL_FRAGMENT_DEPTH_EXT)");
933	context->fog_coord = FALSE;
934	}
935	}
936	}
937
938	void state_fogstartend(DWORD state, IWineD3DStateBlockImpl stateblock, WineD3DContext context) {
939	float fogstart, fogend;
940	union {
941	DWORD d;
942	float f;
943	} tmpvalue;
944
945	switch(context->fog_source) {
946	case FOGSOURCE_VS:
947	fogstart = 1.0;
948	fogend = 0.0;
949	break;
950
951	case FOGSOURCE_COORD:
952	fogstart = 255.0;
953	fogend = 0.0;
954	break;
955
956	case FOGSOURCE_FFP:
957	tmpvalue.d = stateblock->renderState[WINED3DRS_FOGSTART];
958	fogstart = tmpvalue.f;
959	tmpvalue.d = stateblock->renderState[WINED3DRS_FOGEND];
960	fogend = tmpvalue.f;
961	/* In GL, fogstart == fogend disables fog, in D3D everything's fogged.*/
962	if(fogstart == fogend) {
963	unsigned long fNegInf = 0xff800000;
964	fogstart = (float)(&fNegInf); /* -1.0/0.0 */
965	fogend = 0.0;
966	}
967	break;
968
969	default:
970	/* This should not happen.context->fog_source is set in wined3d, not the app.
971	* Still this is needed to make the compiler happy
972	*/
973	ERR("Unexpected fog coordinate source\n");
974	fogstart = 0.0;
975	fogend = 0.0;
976	}
977
978	glFogf(GL_FOG_START, fogstart);
979	checkGLcall("glFogf(GL_FOG_START, fogstart)");
980	TRACE("Fog Start == %f\n", fogstart);
981
982	glFogf(GL_FOG_END, fogend);
983	checkGLcall("glFogf(GL_FOG_END, fogend)");
984	TRACE("Fog End == %f\n", fogend);
985	}
986
987	void state_fog_fragpart(DWORD state, IWineD3DStateBlockImpl stateblock, WineD3DContext context) {
988	enum fogsource new_source;
989
990	TRACE("state %#x, stateblock %p, context %p\n", state, stateblock, context);
991
992	if (!stateblock->renderState[WINED3DRS_FOGENABLE]) {
993	/* No fog? Disable it, and we're done :-) */
994	glDisableWINE(GL_FOG);
995	checkGLcall("glDisable GL_FOG");
996	return;
997	}
998
999	/* Fog Rules:
1000	*
1001	* With fixed function vertex processing, Direct3D knows 2 different fog input sources.
1002	* It can use the Z value of the vertex, or the alpha component of the specular color.
1003	* This depends on the fog vertex, fog table and the vertex declaration. If the Z value
1004	* is used, fogstart, fogend and the equation type are used, otherwise linear fog with
1005	* start = 255, end = 0 is used. Obviously the msdn is not very clear on that.
1006	*
1007	* FOGTABLEMODE != NONE:
1008	* The Z value is used, with the equation specified, no matter what vertex type.
1009	*
1010	* FOGTABLEMODE == NONE, FOGVERTEXMODE != NONE, untransformed:
1011	* Per vertex fog is calculated using the specified fog equation and the parameters
1012	*
1013	* FOGTABLEMODE == NONE, FOGVERTEXMODE != NONE, transformed, OR
1014	* FOGTABLEMODE == NONE, FOGVERTEXMODE == NONE, untransformed:
1015	* Linear fog with start = 255.0, end = 0.0, input comes from the specular color
1016	*
1017	*
1018	* Rules for vertex fog with shaders:
1019	*
1020	* When mixing fixed function functionality with the programmable pipeline, D3D expects
1021	* the fog computation to happen during transformation while openGL expects it to happen
1022	* during rasterization. Also, prior to pixel shader 3.0 D3D handles fog blending after
1023	* the pixel shader while openGL always expects the pixel shader to handle the blending.
1024	* To solve this problem, WineD3D does:
1025	* 1) implement a linear fog equation and fog blending at the end of every pre 3.0 pixel
1026	* shader,
1027	* and 2) disables the fog computation (in either the fixed function or programmable
1028	* rasterizer) if using a vertex program.
1029	*
1030	* D3D shaders can provide an explicit fog coordinate. This fog coordinate is used with
1031	* D3DRS_FOGTABLEMODE==D3DFOG_NONE. The FOGVERTEXMODE is ignored, d3d always uses linear
1032	* fog with start=1.0 and end=0.0 in this case. This is similar to fog coordinates in
1033	* the specular color, a vertex shader counts as pretransformed geometry in this case.
1034	* There are some GL differences between specular fog coords and vertex shaders though.
1035	*
1036	* With table fog the vertex shader fog coordinate is ignored.
1037	*
1038	* If a fogtablemode and a fogvertexmode are specified, table fog is applied (with or
1039	* without shaders).
1040	*/
1041
1042	/* DX 7 sdk: "If both render states(vertex and table fog) are set to valid modes,
1043	* the system will apply only pixel(=table) fog effects."
1044	*/
1045	if(stateblock->renderState[WINED3DRS_FOGTABLEMODE] == WINED3DFOG_NONE) {
1046	if(use_vs(stateblock)) {
1047	glFogi(GL_FOG_MODE, GL_LINEAR);
1048	checkGLcall("glFogi(GL_FOG_MODE, GL_LINEAR)");
1049	new_source = FOGSOURCE_VS;
1050	} else {
1051	switch (stateblock->renderState[WINED3DRS_FOGVERTEXMODE]) {
1052	/* If processed vertices are used, fall through to the NONE case */
1053	case WINED3DFOG_EXP:
1054	if(!context->last_was_rhw) {
1055	glFogi(GL_FOG_MODE, GL_EXP);
1056	checkGLcall("glFogi(GL_FOG_MODE, GL_EXP)");
1057	new_source = FOGSOURCE_FFP;
1058	break;
1059	}
1060	/* drop through */
1061
1062	case WINED3DFOG_EXP2:
1063	if(!context->last_was_rhw) {
1064	glFogi(GL_FOG_MODE, GL_EXP2);
1065	checkGLcall("glFogi(GL_FOG_MODE, GL_EXP2)");
1066	new_source = FOGSOURCE_FFP;
1067	break;
1068	}
1069	/* drop through */
1070
1071	case WINED3DFOG_LINEAR:
1072	if(!context->last_was_rhw) {
1073	glFogi(GL_FOG_MODE, GL_LINEAR);
1074	checkGLcall("glFogi(GL_FOG_MODE, GL_LINEAR)");
1075	new_source = FOGSOURCE_FFP;
1076	break;
1077	}
1078	/* drop through */
1079
1080	case WINED3DFOG_NONE:
1081	/* Both are none? According to msdn the alpha channel of the specular
1082	* color contains a fog factor. Set it in drawStridedSlow.
1083	* Same happens with Vertexfog on transformed vertices
1084	*/
1085	new_source = FOGSOURCE_COORD;
1086	glFogi(GL_FOG_MODE, GL_LINEAR);
1087	checkGLcall("glFogi(GL_FOG_MODE, GL_LINEAR)");
1088	break;
1089
1090	default:
1091	FIXME("Unexpected WINED3DRS_FOGVERTEXMODE %d\n", stateblock->renderState[WINED3DRS_FOGVERTEXMODE]);
1092	new_source = FOGSOURCE_FFP; /* Make the compiler happy */
1093	}
1094	}
1095	} else {
1096	new_source = FOGSOURCE_FFP;
1097
1098	switch (stateblock->renderState[WINED3DRS_FOGTABLEMODE]) {
1099	case WINED3DFOG_EXP:
1100	glFogi(GL_FOG_MODE, GL_EXP);
1101	checkGLcall("glFogi(GL_FOG_MODE, GL_EXP)");
1102	break;
1103
1104	case WINED3DFOG_EXP2:
1105	glFogi(GL_FOG_MODE, GL_EXP2);
1106	checkGLcall("glFogi(GL_FOG_MODE, GL_EXP2)");
1107	break;
1108
1109	case WINED3DFOG_LINEAR:
1110	glFogi(GL_FOG_MODE, GL_LINEAR);
1111	checkGLcall("glFogi(GL_FOG_MODE, GL_LINEAR)");
1112	break;
1113
1114	case WINED3DFOG_NONE: /* Won't happen */
1115	default:
1116	FIXME("Unexpected WINED3DRS_FOGTABLEMODE %d\n", stateblock->renderState[WINED3DRS_FOGTABLEMODE]);
1117	}
1118	}
1119
1120	glEnableWINE(GL_FOG);
1121	checkGLcall("glEnable GL_FOG");
1122	if(new_source != context->fog_source) {
1123	context->fog_source = new_source;
1124	state_fogstartend(STATE_RENDER(WINED3DRS_FOGSTART), stateblock, context);
1125	}
1126	}
1127
1128	static void state_rangefog_w(DWORD state, IWineD3DStateBlockImpl stateblock, WineD3DContext context) {
1129	if(stateblock->renderState[WINED3DRS_RANGEFOGENABLE]) {
1130	WARN("Range fog enabled, but not supported by this opengl implementation\n");
1131	}
1132	}
1133
1134	static void state_rangefog(DWORD state, IWineD3DStateBlockImpl stateblock, WineD3DContext context) {
1135	if(stateblock->renderState[WINED3DRS_RANGEFOGENABLE]) {
1136	glFogi(GL_FOG_DISTANCE_MODE_NV, GL_EYE_RADIAL_NV);
1137	checkGLcall("glFogi(GL_FOG_DISTANCE_MODE_NV, GL_EYE_RADIAL_NV)");
1138	} else {
1139	glFogi(GL_FOG_DISTANCE_MODE_NV, GL_EYE_PLANE_ABSOLUTE_NV);
1140	checkGLcall("glFogi(GL_FOG_DISTANCE_MODE_NV, GL_EYE_PLANE_ABSOLUTE_NV)");
1141	}
1142	}
1143
1144	void state_fogcolor(DWORD state, IWineD3DStateBlockImpl stateblock, WineD3DContext context) {
1145	float col[4];
1146	D3DCOLORTOGLFLOAT4(stateblock->renderState[WINED3DRS_FOGCOLOR], col);
1147	glFogfv(GL_FOG_COLOR, &col[0]);
1148	checkGLcall("glFog GL_FOG_COLOR");
1149	}
1150
1151	void state_fogdensity(DWORD state, IWineD3DStateBlockImpl stateblock, WineD3DContext context) {
1152	union {
1153	DWORD d;
1154	float f;
1155	} tmpvalue;
1156	tmpvalue.d = stateblock->renderState[WINED3DRS_FOGDENSITY];
1157	glFogfv(GL_FOG_DENSITY, &tmpvalue.f);
1158	checkGLcall("glFogf(GL_FOG_DENSITY, (float) Value)");
1159	}
1160
1161	static void state_colormat(DWORD state, IWineD3DStateBlockImpl stateblock, WineD3DContext context) {
1162	IWineD3DDeviceImpl *device = stateblock->wineD3DDevice;
1163	GLenum Parm = 0;
1164	const struct wined3d_stream_info_element *diffuse = &device->strided_streams.elements[WINED3D_FFP_DIFFUSE];
1165	BOOL isDiffuseSupplied;
1166
1167	/* Depends on the decoded vertex declaration to read the existence of diffuse data.
1168	* The vertex declaration will call this function if the fixed function pipeline is used.
1169	*/
1170
1171	if(isStateDirty(context, STATE_VDECL)) {
1172	return;
1173	}
1174
1175	isDiffuseSupplied = diffuse->data \|\| diffuse->buffer_object;
1176
1177	context->num_untracked_materials = 0;
1178	if (isDiffuseSupplied && stateblock->renderState[WINED3DRS_COLORVERTEX]) {
1179	TRACE("diff %d, amb %d, emis %d, spec %d\n",
1180	stateblock->renderState[WINED3DRS_DIFFUSEMATERIALSOURCE],
1181	stateblock->renderState[WINED3DRS_AMBIENTMATERIALSOURCE],
1182	stateblock->renderState[WINED3DRS_EMISSIVEMATERIALSOURCE],
1183	stateblock->renderState[WINED3DRS_SPECULARMATERIALSOURCE]);
1184
1185	if (stateblock->renderState[WINED3DRS_DIFFUSEMATERIALSOURCE] == WINED3DMCS_COLOR1) {
1186	if (stateblock->renderState[WINED3DRS_AMBIENTMATERIALSOURCE] == WINED3DMCS_COLOR1) {
1187	Parm = GL_AMBIENT_AND_DIFFUSE;
1188	} else {
1189	Parm = GL_DIFFUSE;
1190	}
1191	if(stateblock->renderState[WINED3DRS_EMISSIVEMATERIALSOURCE] == WINED3DMCS_COLOR1) {
1192	context->untracked_materials[context->num_untracked_materials] = GL_EMISSION;
1193	context->num_untracked_materials++;
1194	}
1195	if(stateblock->renderState[WINED3DRS_SPECULARMATERIALSOURCE] == WINED3DMCS_COLOR1) {
1196	context->untracked_materials[context->num_untracked_materials] = GL_SPECULAR;
1197	context->num_untracked_materials++;
1198	}
1199	} else if (stateblock->renderState[WINED3DRS_AMBIENTMATERIALSOURCE] == WINED3DMCS_COLOR1) {
1200	Parm = GL_AMBIENT;
1201	if(stateblock->renderState[WINED3DRS_EMISSIVEMATERIALSOURCE] == WINED3DMCS_COLOR1) {
1202	context->untracked_materials[context->num_untracked_materials] = GL_EMISSION;
1203	context->num_untracked_materials++;
1204	}
1205	if(stateblock->renderState[WINED3DRS_SPECULARMATERIALSOURCE] == WINED3DMCS_COLOR1) {
1206	context->untracked_materials[context->num_untracked_materials] = GL_SPECULAR;
1207	context->num_untracked_materials++;
1208	}
1209	} else if (stateblock->renderState[WINED3DRS_EMISSIVEMATERIALSOURCE] == WINED3DMCS_COLOR1) {
1210	Parm = GL_EMISSION;
1211	if(stateblock->renderState[WINED3DRS_SPECULARMATERIALSOURCE] == WINED3DMCS_COLOR1) {
1212	context->untracked_materials[context->num_untracked_materials] = GL_SPECULAR;
1213	context->num_untracked_materials++;
1214	}
1215	} else if (stateblock->renderState[WINED3DRS_SPECULARMATERIALSOURCE] == WINED3DMCS_COLOR1) {
1216	Parm = GL_SPECULAR;
1217	}
1218	}
1219
1220	/* Nothing changed, return. */
1221	if (Parm == context->tracking_parm) return;
1222
1223	if(!Parm) {
1224	glDisable(GL_COLOR_MATERIAL);
1225	checkGLcall("glDisable GL_COLOR_MATERIAL");
1226	} else {
1227	glColorMaterial(GL_FRONT_AND_BACK, Parm);
1228	checkGLcall("glColorMaterial(GL_FRONT_AND_BACK, Parm)");
1229	glEnable(GL_COLOR_MATERIAL);
1230	checkGLcall("glEnable(GL_COLOR_MATERIAL)");
1231	}
1232
1233	/* Apparently calls to glMaterialfv are ignored for properties we're
1234	* tracking with glColorMaterial, so apply those here. */
1235	switch (context->tracking_parm) {
1236	case GL_AMBIENT_AND_DIFFUSE:
1237	glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT, (float*)&device->updateStateBlock->material.Ambient);
1238	glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, (float*)&device->updateStateBlock->material.Diffuse);
1239	checkGLcall("glMaterialfv");
1240	break;
1241
1242	case GL_DIFFUSE:
1243	glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, (float*)&device->updateStateBlock->material.Diffuse);
1244	checkGLcall("glMaterialfv");
1245	break;
1246
1247	case GL_AMBIENT:
1248	glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT, (float*)&device->updateStateBlock->material.Ambient);
1249	checkGLcall("glMaterialfv");
1250	break;
1251
1252	case GL_EMISSION:
1253	glMaterialfv(GL_FRONT_AND_BACK, GL_EMISSION, (float*)&device->updateStateBlock->material.Emissive);
1254	checkGLcall("glMaterialfv");
1255	break;
1256
1257	case GL_SPECULAR:
1258	/* Only change material color if specular is enabled, otherwise it is set to black */
1259	if (device->stateBlock->renderState[WINED3DRS_SPECULARENABLE]) {
1260	glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, (float*)&device->updateStateBlock->material.Specular);
1261	checkGLcall("glMaterialfv");
1262	} else {
1263	static const GLfloat black[] = {0.0f, 0.0f, 0.0f, 0.0f};
1264	glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, &black[0]);
1265	checkGLcall("glMaterialfv");
1266	}
1267	break;
1268	}
1269
1270	context->tracking_parm = Parm;
1271	}
1272
1273	static void state_linepattern(DWORD state, IWineD3DStateBlockImpl stateblock, WineD3DContext context) {
1274	union {
1275	DWORD d;
1276	WINED3DLINEPATTERN lp;
1277	} tmppattern;
1278	tmppattern.d = stateblock->renderState[WINED3DRS_LINEPATTERN];
1279
1280	TRACE("Line pattern: repeat %d bits %x\n", tmppattern.lp.wRepeatFactor, tmppattern.lp.wLinePattern);
1281
1282	if (tmppattern.lp.wRepeatFactor) {
1283	glLineStipple(tmppattern.lp.wRepeatFactor, tmppattern.lp.wLinePattern);
1284	checkGLcall("glLineStipple(repeat, linepattern)");
1285	glEnable(GL_LINE_STIPPLE);
1286	checkGLcall("glEnable(GL_LINE_STIPPLE);");
1287	} else {
1288	glDisable(GL_LINE_STIPPLE);
1289	checkGLcall("glDisable(GL_LINE_STIPPLE);");
1290	}
1291	}
1292
1293	static void state_zbias(DWORD state, IWineD3DStateBlockImpl stateblock, WineD3DContext context) {
1294	union {
1295	DWORD d;
1296	float f;
1297	} tmpvalue;
1298
1299	if (stateblock->renderState[WINED3DRS_ZBIAS]) {
1300	tmpvalue.d = stateblock->renderState[WINED3DRS_ZBIAS];
1301	TRACE("ZBias value %f\n", tmpvalue.f);
1302	glPolygonOffset(0, -tmpvalue.f);
1303	checkGLcall("glPolygonOffset(0, -Value)");
1304	glEnable(GL_POLYGON_OFFSET_FILL);
1305	checkGLcall("glEnable(GL_POLYGON_OFFSET_FILL);");
1306	glEnable(GL_POLYGON_OFFSET_LINE);
1307	checkGLcall("glEnable(GL_POLYGON_OFFSET_LINE);");
1308	glEnable(GL_POLYGON_OFFSET_POINT);
1309	checkGLcall("glEnable(GL_POLYGON_OFFSET_POINT);");
1310	} else {
1311	glDisable(GL_POLYGON_OFFSET_FILL);
1312	checkGLcall("glDisable(GL_POLYGON_OFFSET_FILL);");
1313	glDisable(GL_POLYGON_OFFSET_LINE);
1314	checkGLcall("glDisable(GL_POLYGON_OFFSET_LINE);");
1315	glDisable(GL_POLYGON_OFFSET_POINT);
1316	checkGLcall("glDisable(GL_POLYGON_OFFSET_POINT);");
1317	}
1318	}
1319
1320
1321	static void state_normalize(DWORD state, IWineD3DStateBlockImpl stateblock, WineD3DContext context) {
1322	if(isStateDirty(context, STATE_VDECL)) {
1323	return;
1324	}
1325	/* Without vertex normals, we set the current normal to 0/0/0 to remove the diffuse factor
1326	* from the opengl lighting equation, as d3d does. Normalization of 0/0/0 can lead to a division
1327	* by zero and is not properly defined in opengl, so avoid it
1328	*/
1329	if (stateblock->renderState[WINED3DRS_NORMALIZENORMALS]
1330	&& (stateblock->wineD3DDevice->strided_streams.elements[WINED3D_FFP_NORMAL].data
1331	\|\| stateblock->wineD3DDevice->strided_streams.elements[WINED3D_FFP_NORMAL].buffer_object))
1332	{
1333	glEnable(GL_NORMALIZE);
1334	checkGLcall("glEnable(GL_NORMALIZE);");
1335	} else {
1336	glDisable(GL_NORMALIZE);
1337	checkGLcall("glDisable(GL_NORMALIZE);");
1338	}
1339	}
1340
1341	static void state_psizemin_w(DWORD state, IWineD3DStateBlockImpl stateblock, WineD3DContext context) {
1342	union {
1343	DWORD d;
1344	float f;
1345	} tmpvalue;
1346
1347	tmpvalue.d = stateblock->renderState[WINED3DRS_POINTSIZE_MIN];
1348	if(tmpvalue.f != 1.0) {
1349	FIXME("WINED3DRS_POINTSIZE_MIN not supported on this opengl, value is %f\n", tmpvalue.f);
1350	}
1351	tmpvalue.d = stateblock->renderState[WINED3DRS_POINTSIZE_MAX];
1352	if(tmpvalue.f != 64.0) {
1353	FIXME("WINED3DRS_POINTSIZE_MAX not supported on this opengl, value is %f\n", tmpvalue.f);
1354	}
1355
1356	}
1357
1358	static void state_psizemin_ext(DWORD state, IWineD3DStateBlockImpl stateblock, WineD3DContext context) {
1359	union {
1360	DWORD d;
1361	float f;
1362	} min, max;
1363
1364	min.d = stateblock->renderState[WINED3DRS_POINTSIZE_MIN];
1365	max.d = stateblock->renderState[WINED3DRS_POINTSIZE_MAX];
1366
1367	/* Max point size trumps min point size */
1368	if(min.f > max.f) {
1369	min.f = max.f;
1370	}
1371
1372	GL_EXTCALL(glPointParameterfEXT)(GL_POINT_SIZE_MIN_EXT, min.f);
1373	checkGLcall("glPointParameterfEXT(...)");
1374	GL_EXTCALL(glPointParameterfEXT)(GL_POINT_SIZE_MAX_EXT, max.f);
1375	checkGLcall("glPointParameterfEXT(...)");
1376	}
1377
1378	static void state_psizemin_arb(DWORD state, IWineD3DStateBlockImpl stateblock, WineD3DContext context) {
1379	union {
1380	DWORD d;
1381	float f;
1382	} min, max;
1383
1384	min.d = stateblock->renderState[WINED3DRS_POINTSIZE_MIN];
1385	max.d = stateblock->renderState[WINED3DRS_POINTSIZE_MAX];
1386
1387	/* Max point size trumps min point size */
1388	if(min.f > max.f) {
1389	min.f = max.f;
1390	}
1391
1392	GL_EXTCALL(glPointParameterfARB)(GL_POINT_SIZE_MIN_ARB, min.f);
1393	checkGLcall("glPointParameterfARB(...)");
1394	GL_EXTCALL(glPointParameterfARB)(GL_POINT_SIZE_MAX_ARB, max.f);
1395	checkGLcall("glPointParameterfARB(...)");
1396	}
1397
1398	static void state_pscale(DWORD state, IWineD3DStateBlockImpl stateblock, WineD3DContext context) {
1399	/* TODO: Group this with the viewport */
1400	/*
1401	* POINTSCALEENABLE controls how point size value is treated. If set to
1402	* true, the point size is scaled with respect to height of viewport.
1403	* When set to false point size is in pixels.
1404	*/
1405
1406	/* Default values */
1407	GLfloat att[3] = {1.0f, 0.0f, 0.0f};
1408	union {
1409	DWORD d;
1410	float f;
1411	} pointSize, A, B, C;
1412
1413	pointSize.d = stateblock->renderState[WINED3DRS_POINTSIZE];
1414	A.d = stateblock->renderState[WINED3DRS_POINTSCALE_A];
1415	B.d = stateblock->renderState[WINED3DRS_POINTSCALE_B];
1416	C.d = stateblock->renderState[WINED3DRS_POINTSCALE_C];
1417
1418	if(stateblock->renderState[WINED3DRS_POINTSCALEENABLE]) {
1419	GLfloat scaleFactor;
1420	float h = stateblock->viewport.Height;
1421
1422	if(pointSize.f < GL_LIMITS(pointsizemin)) {
1423	/*
1424	* Minimum valid point size for OpenGL is driver specific. For Direct3D it is
1425	* 0.0f. This means that OpenGL will clamp really small point sizes to the
1426	* driver minimum. To correct for this we need to multiply by the scale factor when sizes
1427	* are less than 1.0f. scale_factor = 1.0f / point_size.
1428	*/
1429	scaleFactor = pointSize.f / GL_LIMITS(pointsizemin);
1430	/* Clamp the point size, don't rely on the driver to do it. MacOS says min point size
1431	* is 1.0, but then accepts points below that and draws too small points
1432	*/
1433	pointSize.f = GL_LIMITS(pointsizemin);
1434	} else if(pointSize.f > GL_LIMITS(pointsize)) {
1435	/* gl already scales the input to glPointSize,
1436	* d3d scales the result after the point size scale.
1437	* If the point size is bigger than the max size, use the
1438	* scaling to scale it bigger, and set the gl point size to max
1439	*/
1440	scaleFactor = pointSize.f / GL_LIMITS(pointsize);
1441	TRACE("scale: %f\n", scaleFactor);
1442	pointSize.f = GL_LIMITS(pointsize);
1443	} else {
1444	scaleFactor = 1.0f;
1445	}
1446	scaleFactor = pow(h * scaleFactor, 2);
1447
1448	att[0] = A.f / scaleFactor;
1449	att[1] = B.f / scaleFactor;
1450	att[2] = C.f / scaleFactor;
1451	}
1452
1453	if(GL_SUPPORT(ARB_POINT_PARAMETERS)) {
1454	GL_EXTCALL(glPointParameterfvARB)(GL_POINT_DISTANCE_ATTENUATION_ARB, att);
1455	checkGLcall("glPointParameterfvARB(GL_DISTANCE_ATTENUATION_ARB, ...)");
1456	}
1457	else if(GL_SUPPORT(EXT_POINT_PARAMETERS)) {
1458	GL_EXTCALL(glPointParameterfvEXT)(GL_DISTANCE_ATTENUATION_EXT, att);
1459	checkGLcall("glPointParameterfvEXT(GL_DISTANCE_ATTENUATION_EXT, ...)");
1460	} else if(stateblock->renderState[WINED3DRS_POINTSCALEENABLE]) {
1461	WARN("POINT_PARAMETERS not supported in this version of opengl\n");
1462	}
1463
1464	glPointSize(pointSize.f);
1465	checkGLcall("glPointSize(...);");
1466	}
1467
1468	static void state_colorwrite(DWORD state, IWineD3DStateBlockImpl stateblock, WineD3DContext context) {
1469	DWORD Value = stateblock->renderState[WINED3DRS_COLORWRITEENABLE];
1470
1471	TRACE("Color mask: r(%d) g(%d) b(%d) a(%d)\n",
1472	Value & WINED3DCOLORWRITEENABLE_RED ? 1 : 0,
1473	Value & WINED3DCOLORWRITEENABLE_GREEN ? 1 : 0,
1474	Value & WINED3DCOLORWRITEENABLE_BLUE ? 1 : 0,
1475	Value & WINED3DCOLORWRITEENABLE_ALPHA ? 1 : 0);
1476	glColorMask(Value & WINED3DCOLORWRITEENABLE_RED ? GL_TRUE : GL_FALSE,
1477	Value & WINED3DCOLORWRITEENABLE_GREEN ? GL_TRUE : GL_FALSE,
1478	Value & WINED3DCOLORWRITEENABLE_BLUE ? GL_TRUE : GL_FALSE,
1479	Value & WINED3DCOLORWRITEENABLE_ALPHA ? GL_TRUE : GL_FALSE);
1480	checkGLcall("glColorMask(...)");
1481
1482	/* depends on WINED3DRS_COLORWRITEENABLE. */
1483	if(stateblock->renderState[WINED3DRS_COLORWRITEENABLE1] != 0x0000000F \|\|
1484	stateblock->renderState[WINED3DRS_COLORWRITEENABLE2] != 0x0000000F \|\|
1485	stateblock->renderState[WINED3DRS_COLORWRITEENABLE3] != 0x0000000F ) {
1486	ERR("(WINED3DRS_COLORWRITEENABLE1/2/3,%d,%d,%d) not yet implemented. Missing of cap D3DPMISCCAPS_INDEPENDENTWRITEMASKS wasn't honored?\n",
1487	stateblock->renderState[WINED3DRS_COLORWRITEENABLE1],
1488	stateblock->renderState[WINED3DRS_COLORWRITEENABLE2],
1489	stateblock->renderState[WINED3DRS_COLORWRITEENABLE3]);
1490	}
1491	}
1492
1493	static void state_localviewer(DWORD state, IWineD3DStateBlockImpl stateblock, WineD3DContext context) {
1494	if(stateblock->renderState[WINED3DRS_LOCALVIEWER]) {
1495	glLightModeli(GL_LIGHT_MODEL_LOCAL_VIEWER, 1);
1496	checkGLcall("glLightModeli(GL_LIGHT_MODEL_LOCAL_VIEWER, 1)");
1497	} else {
1498	glLightModeli(GL_LIGHT_MODEL_LOCAL_VIEWER, 0);
1499	checkGLcall("glLightModeli(GL_LIGHT_MODEL_LOCAL_VIEWER, 0)");
1500	}
1501	}
1502
1503	static void state_lastpixel(DWORD state, IWineD3DStateBlockImpl stateblock, WineD3DContext context) {
1504	if(stateblock->renderState[WINED3DRS_LASTPIXEL]) {
1505	TRACE("Last Pixel Drawing Enabled\n");
1506	} else {
1507	static BOOL warned;
1508	if (!warned) {
1509	FIXME("Last Pixel Drawing Disabled, not handled yet\n");
1510	warned = TRUE;
1511	} else {
1512	TRACE("Last Pixel Drawing Disabled, not handled yet\n");
1513	}
1514	}
1515	}
1516
1517	static void state_pointsprite_w(DWORD state, IWineD3DStateBlockImpl stateblock, WineD3DContext context) {
1518	BOOL warned = FALSE;
1519	/* TODO: NV_POINT_SPRITE */
1520	if (!warned && stateblock->renderState[WINED3DRS_POINTSPRITEENABLE]) {
1521	/* A FIXME, not a WARN because point sprites should be software emulated if not supported by HW */
1522	FIXME("Point sprites not supported\n");
1523	warned = TRUE;
1524	}
1525	}
1526
1527	static void state_pointsprite(DWORD state, IWineD3DStateBlockImpl stateblock, WineD3DContext context) {
1528	if (stateblock->renderState[WINED3DRS_POINTSPRITEENABLE]) {
1529	BOOL warned = FALSE;
1530	if(GL_LIMITS(point_sprite_units) < GL_LIMITS(textures) && !warned) {
1531	if(use_ps(stateblock) \|\| stateblock->lowest_disabled_stage > GL_LIMITS(point_sprite_units)) {
1532	FIXME("The app uses point sprite texture coordinates on more units than supported by the driver\n");
1533	warned = TRUE;
1534	}
1535	}
1536
1537	glEnable(GL_POINT_SPRITE_ARB);
1538	checkGLcall("glEnable(GL_POINT_SPRITE_ARB)");
1539	} else {
1540	glDisable(GL_POINT_SPRITE_ARB);
1541	checkGLcall("glDisable(GL_POINT_SPRITE_ARB)");
1542	}
1543	}
1544
1545	static void state_wrap(DWORD state, IWineD3DStateBlockImpl stateblock, WineD3DContext context) {
1546	/**
1547	http://www.cosc.brocku.ca/Offerings/3P98/course/lectures/texture/
1548	http://www.gamedev.net/reference/programming/features/rendererdll3/page2.asp
1549	Discussion on the ways to turn on WRAPing to solve an OpenGL conversion problem.
1550	http://www.flipcode.org/cgi-bin/fcmsg.cgi?thread_show=10248
1551
1552	so far as I can tell, wrapping and texture-coordinate generate go hand in hand,
1553	*/
1554	TRACE("Stub\n");
1555	if(stateblock->renderState[WINED3DRS_WRAP0] \|\|
1556	stateblock->renderState[WINED3DRS_WRAP1] \|\|
1557	stateblock->renderState[WINED3DRS_WRAP2] \|\|
1558	stateblock->renderState[WINED3DRS_WRAP3] \|\|
1559	stateblock->renderState[WINED3DRS_WRAP4] \|\|
1560	stateblock->renderState[WINED3DRS_WRAP5] \|\|
1561	stateblock->renderState[WINED3DRS_WRAP6] \|\|
1562	stateblock->renderState[WINED3DRS_WRAP7] \|\|
1563	stateblock->renderState[WINED3DRS_WRAP8] \|\|
1564	stateblock->renderState[WINED3DRS_WRAP9] \|\|
1565	stateblock->renderState[WINED3DRS_WRAP10] \|\|
1566	stateblock->renderState[WINED3DRS_WRAP11] \|\|
1567	stateblock->renderState[WINED3DRS_WRAP12] \|\|
1568	stateblock->renderState[WINED3DRS_WRAP13] \|\|
1569	stateblock->renderState[WINED3DRS_WRAP14] \|\|
1570	stateblock->renderState[WINED3DRS_WRAP15] ) {
1571	FIXME("(WINED3DRS_WRAP0) Texture wraping not yet supported\n");
1572	}
1573	}
1574
1575	static void state_msaa_w(DWORD state, IWineD3DStateBlockImpl stateblock, WineD3DContext context) {
1576	if(stateblock->renderState[WINED3DRS_MULTISAMPLEANTIALIAS]) {
1577	WARN("Multisample antialiasing not supported by gl\n");
1578	}
1579	}
1580
1581	static void state_msaa(DWORD state, IWineD3DStateBlockImpl stateblock, WineD3DContext context) {
1582	if(stateblock->renderState[WINED3DRS_MULTISAMPLEANTIALIAS]) {
1583	glEnable(GL_MULTISAMPLE_ARB);
1584	checkGLcall("glEnable(GL_MULTISAMPLE_ARB)");
1585	} else {
1586	glDisable(GL_MULTISAMPLE_ARB);
1587	checkGLcall("glDisable(GL_MULTISAMPLE_ARB)");
1588	}
1589	}
1590
1591	static void state_scissor(DWORD state, IWineD3DStateBlockImpl stateblock, WineD3DContext context) {
1592	if(stateblock->renderState[WINED3DRS_SCISSORTESTENABLE]) {
1593	glEnable(GL_SCISSOR_TEST);
1594	checkGLcall("glEnable(GL_SCISSOR_TEST)");
1595	} else {
1596	glDisable(GL_SCISSOR_TEST);
1597	checkGLcall("glDisable(GL_SCISSOR_TEST)");
1598	}
1599	}
1600
1601	static void state_depthbias(DWORD state, IWineD3DStateBlockImpl stateblock, WineD3DContext context) {
1602	union {
1603	DWORD d;
1604	float f;
1605	} tmpvalue;
1606
1607	if(stateblock->renderState[WINED3DRS_SLOPESCALEDEPTHBIAS] \|\|
1608	stateblock->renderState[WINED3DRS_DEPTHBIAS]) {
1609	tmpvalue.d = stateblock->renderState[WINED3DRS_SLOPESCALEDEPTHBIAS];
1610	glEnable(GL_POLYGON_OFFSET_FILL);
1611	checkGLcall("glEnable(GL_POLYGON_OFFSET_FILL)");
1612	glPolygonOffset(tmpvalue.f, ((float)&stateblock->renderState[WINED3DRS_DEPTHBIAS]));
1613	checkGLcall("glPolygonOffset(...)");
1614	} else {
1615	glDisable(GL_POLYGON_OFFSET_FILL);
1616	checkGLcall("glDisable(GL_POLYGON_OFFSET_FILL)");
1617	}
1618	}
1619
1620	static void state_perspective(DWORD state, IWineD3DStateBlockImpl stateblock, WineD3DContext context) {
1621	if (stateblock->renderState[WINED3DRS_TEXTUREPERSPECTIVE]) {
1622	glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);
1623	checkGLcall("glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST)");
1624	} else {
1625	glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_FASTEST);
1626	checkGLcall("glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_FASTEST)");
1627	}
1628	}
1629
1630	static void state_stippledalpha(DWORD state, IWineD3DStateBlockImpl stateblock, WineD3DContext context) {
1631	TRACE("Stub\n");
1632	if (stateblock->renderState[WINED3DRS_STIPPLEDALPHA])
1633	FIXME(" Stippled Alpha not supported yet.\n");
1634	}
1635
1636	static void state_antialias(DWORD state, IWineD3DStateBlockImpl stateblock, WineD3DContext context) {
1637	TRACE("Stub\n");
1638	if (stateblock->renderState[WINED3DRS_ANTIALIAS])
1639	FIXME(" Antialias not supported yet.\n");
1640	}
1641
1642	static void state_multisampmask(DWORD state, IWineD3DStateBlockImpl stateblock, WineD3DContext context) {
1643	TRACE("Stub\n");
1644	if (stateblock->renderState[WINED3DRS_MULTISAMPLEMASK] != 0xFFFFFFFF)
1645	FIXME("(WINED3DRS_MULTISAMPLEMASK,%d) not yet implemented\n", stateblock->renderState[WINED3DRS_MULTISAMPLEMASK]);
1646	}
1647
1648	static void state_patchedgestyle(DWORD state, IWineD3DStateBlockImpl stateblock, WineD3DContext context) {
1649	TRACE("Stub\n");
1650	if (stateblock->renderState[WINED3DRS_PATCHEDGESTYLE] != WINED3DPATCHEDGE_DISCRETE)
1651	FIXME("(WINED3DRS_PATCHEDGESTYLE,%d) not yet implemented\n", stateblock->renderState[WINED3DRS_PATCHEDGESTYLE]);
1652	}
1653
1654	static void state_patchsegments(DWORD state, IWineD3DStateBlockImpl stateblock, WineD3DContext context) {
1655	union {
1656	DWORD d;
1657	float f;
1658	} tmpvalue;
1659	tmpvalue.f = 1.0f;
1660
1661	TRACE("Stub\n");
1662	if (stateblock->renderState[WINED3DRS_PATCHSEGMENTS] != tmpvalue.d)
1663	{
1664	static BOOL displayed = FALSE;
1665
1666	tmpvalue.d = stateblock->renderState[WINED3DRS_PATCHSEGMENTS];
1667	if(!displayed)
1668	FIXME("(WINED3DRS_PATCHSEGMENTS,%f) not yet implemented\n", tmpvalue.f);
1669
1670	displayed = TRUE;
1671	}
1672	}
1673
1674	static void state_positiondegree(DWORD state, IWineD3DStateBlockImpl stateblock, WineD3DContext context) {
1675	TRACE("Stub\n");
1676	if (stateblock->renderState[WINED3DRS_POSITIONDEGREE] != WINED3DDEGREE_CUBIC)
1677	FIXME("(WINED3DRS_POSITIONDEGREE,%d) not yet implemented\n", stateblock->renderState[WINED3DRS_POSITIONDEGREE]);
1678	}
1679
1680	static void state_normaldegree(DWORD state, IWineD3DStateBlockImpl stateblock, WineD3DContext context) {
1681	TRACE("Stub\n");
1682	if (stateblock->renderState[WINED3DRS_NORMALDEGREE] != WINED3DDEGREE_LINEAR)
1683	FIXME("(WINED3DRS_NORMALDEGREE,%d) not yet implemented\n", stateblock->renderState[WINED3DRS_NORMALDEGREE]);
1684	}
1685
1686	static void state_tessellation(DWORD state, IWineD3DStateBlockImpl stateblock, WineD3DContext context) {
1687	TRACE("Stub\n");
1688	if(stateblock->renderState[WINED3DRS_ENABLEADAPTIVETESSELLATION])
1689	FIXME("(WINED3DRS_ENABLEADAPTIVETESSELLATION,%d) not yet implemented\n", stateblock->renderState[WINED3DRS_ENABLEADAPTIVETESSELLATION]);
1690	}
1691
1692	static void state_wrapu(DWORD state, IWineD3DStateBlockImpl stateblock, WineD3DContext context) {
1693	if(stateblock->renderState[WINED3DRS_WRAPU]) {
1694	FIXME("Render state WINED3DRS_WRAPU not implemented yet\n");
1695	}
1696	}
1697
1698	static void state_wrapv(DWORD state, IWineD3DStateBlockImpl stateblock, WineD3DContext context) {
1699	if(stateblock->renderState[WINED3DRS_WRAPV]) {
1700	FIXME("Render state WINED3DRS_WRAPV not implemented yet\n");
1701	}
1702	}
1703
1704	static void state_monoenable(DWORD state, IWineD3DStateBlockImpl stateblock, WineD3DContext context) {
1705	if(stateblock->renderState[WINED3DRS_MONOENABLE]) {
1706	FIXME("Render state WINED3DRS_MONOENABLE not implemented yet\n");
1707	}
1708	}
1709
1710	static void state_rop2(DWORD state, IWineD3DStateBlockImpl stateblock, WineD3DContext context) {
1711	if(stateblock->renderState[WINED3DRS_ROP2]) {
1712	FIXME("Render state WINED3DRS_ROP2 not implemented yet\n");
1713	}
1714	}
1715
1716	static void state_planemask(DWORD state, IWineD3DStateBlockImpl stateblock, WineD3DContext context) {
1717	if(stateblock->renderState[WINED3DRS_PLANEMASK]) {
1718	FIXME("Render state WINED3DRS_PLANEMASK not implemented yet\n");
1719	}
1720	}
1721
1722	static void state_subpixel(DWORD state, IWineD3DStateBlockImpl stateblock, WineD3DContext context) {
1723	if(stateblock->renderState[WINED3DRS_SUBPIXEL]) {
1724	FIXME("Render state WINED3DRS_SUBPIXEL not implemented yet\n");
1725	}
1726	}
1727
1728	static void state_subpixelx(DWORD state, IWineD3DStateBlockImpl stateblock, WineD3DContext context) {
1729	if(stateblock->renderState[WINED3DRS_SUBPIXELX]) {
1730	FIXME("Render state WINED3DRS_SUBPIXELX not implemented yet\n");
1731	}
1732	}
1733
1734	static void state_stippleenable(DWORD state, IWineD3DStateBlockImpl stateblock, WineD3DContext context) {
1735	if(stateblock->renderState[WINED3DRS_STIPPLEENABLE]) {
1736	FIXME("Render state WINED3DRS_STIPPLEENABLE not implemented yet\n");
1737	}
1738	}
1739
1740	static void state_bordercolor(DWORD state, IWineD3DStateBlockImpl stateblock, WineD3DContext context) {
1741	if(stateblock->renderState[WINED3DRS_BORDERCOLOR]) {
1742	FIXME("Render state WINED3DRS_BORDERCOLOR not implemented yet\n");
1743	}
1744	}
1745
1746	static void state_mipmaplodbias(DWORD state, IWineD3DStateBlockImpl stateblock, WineD3DContext context) {
1747	if(stateblock->renderState[WINED3DRS_MIPMAPLODBIAS]) {
1748	FIXME("Render state WINED3DRS_MIPMAPLODBIAS not implemented yet\n");
1749	}
1750	}
1751
1752	static void state_anisotropy(DWORD state, IWineD3DStateBlockImpl stateblock, WineD3DContext context) {
1753	if(stateblock->renderState[WINED3DRS_ANISOTROPY]) {
1754	FIXME("Render state WINED3DRS_ANISOTROPY not implemented yet\n");
1755	}
1756	}
1757
1758	static void state_flushbatch(DWORD state, IWineD3DStateBlockImpl stateblock, WineD3DContext context) {
1759	if(stateblock->renderState[WINED3DRS_FLUSHBATCH]) {
1760	FIXME("Render state WINED3DRS_FLUSHBATCH not implemented yet\n");
1761	}
1762	}
1763
1764	static void state_translucentsi(DWORD state, IWineD3DStateBlockImpl stateblock, WineD3DContext context) {
1765	if(stateblock->renderState[WINED3DRS_TRANSLUCENTSORTINDEPENDENT]) {
1766	FIXME("Render state WINED3DRS_TRANSLUCENTSORTINDEPENDENT not implemented yet\n");
1767	}
1768	}
1769
1770	static void state_extents(DWORD state, IWineD3DStateBlockImpl stateblock, WineD3DContext context) {
1771	if(stateblock->renderState[WINED3DRS_EXTENTS]) {
1772	FIXME("Render state WINED3DRS_EXTENTS not implemented yet\n");
1773	}
1774	}
1775
1776	static void state_ckeyblend(DWORD state, IWineD3DStateBlockImpl stateblock, WineD3DContext context) {
1777	if(stateblock->renderState[WINED3DRS_COLORKEYBLENDENABLE]) {
1778	FIXME("Render state WINED3DRS_COLORKEYBLENDENABLE not implemented yet\n");
1779	}
1780	}
1781
1782	/* Set texture operations up - The following avoids lots of ifdefs in this routine!*/
1783	#if defined (GL_VERSION_1_3)
1784	# define useext(A) A
1785	#elif defined (GL_EXT_texture_env_combine)
1786	# define useext(A) A##_EXT
1787	#elif defined (GL_ARB_texture_env_combine)
1788	# define useext(A) A##_ARB
1789	#endif
1790
1791	static void get_src_and_opr(DWORD arg, BOOL is_alpha, GLenum* source, GLenum* operand) {
1792	/* The WINED3DTA_ALPHAREPLICATE flag specifies the alpha component of the
1793	* input should be used for all input components. The WINED3DTA_COMPLEMENT
1794	* flag specifies the complement of the input should be used. */
1795	BOOL from_alpha = is_alpha \|\| arg & WINED3DTA_ALPHAREPLICATE;
1796	BOOL complement = arg & WINED3DTA_COMPLEMENT;
1797
1798	/* Calculate the operand */
1799	if (complement) {
1800	if (from_alpha) *operand = GL_ONE_MINUS_SRC_ALPHA;
1801	else *operand = GL_ONE_MINUS_SRC_COLOR;
1802	} else {
1803	if (from_alpha) *operand = GL_SRC_ALPHA;
1804	else *operand = GL_SRC_COLOR;
1805	}
1806
1807	/* Calculate the source */
1808	switch (arg & WINED3DTA_SELECTMASK) {
1809	case WINED3DTA_CURRENT: *source = GL_PREVIOUS_EXT; break;
1810	case WINED3DTA_DIFFUSE: *source = GL_PRIMARY_COLOR_EXT; break;
1811	case WINED3DTA_TEXTURE: *source = GL_TEXTURE; break;
1812	case WINED3DTA_TFACTOR: *source = GL_CONSTANT_EXT; break;
1813	case WINED3DTA_SPECULAR:
1814	/*
1815	* According to the GL_ARB_texture_env_combine specs, SPECULAR is
1816	* 'Secondary color' and isn't supported until base GL supports it
1817	* There is no concept of temp registers as far as I can tell
1818	*/
1819	FIXME("Unhandled texture arg WINED3DTA_SPECULAR\n");
1820	*source = GL_TEXTURE;
1821	break;
1822	default:
1823	FIXME("Unrecognized texture arg %#x\n", arg);
1824	*source = GL_TEXTURE;
1825	break;
1826	}
1827	}
1828
1829	/* Setup the texture operations texture stage states */
1830	static void set_tex_op(IWineD3DDevice *iface, BOOL isAlpha, int Stage, WINED3DTEXTUREOP op, DWORD arg1, DWORD arg2, DWORD arg3)
1831	{
1832	GLenum src1, src2, src3;
1833	GLenum opr1, opr2, opr3;
1834	GLenum comb_target;
1835	GLenum src0_target, src1_target, src2_target;
1836	GLenum opr0_target, opr1_target, opr2_target;
1837	GLenum scal_target;
1838	GLenum opr=0, invopr, src3_target, opr3_target;
1839	BOOL Handled = FALSE;
1840	IWineD3DDeviceImpl This = (IWineD3DDeviceImpl )iface;
1841	IWineD3DStateBlockImpl stateblock = This->stateBlock; / for GLINFO_LOCATION */
1842
1843	TRACE("Alpha?(%d), Stage:%d Op(%s), a1(%d), a2(%d), a3(%d)\n", isAlpha, Stage, debug_d3dtop(op), arg1, arg2, arg3);
1844
1845	/* This is called by a state handler which has the gl lock held and a context for the thread */
1846
1847	/* Note: Operations usually involve two ars, src0 and src1 and are operations of
1848	the form (a1 <operation> a2). However, some of the more complex operations
1849	take 3 parameters. Instead of the (sensible) addition of a3, Microsoft added
1850	in a third parameter called a0. Therefore these are operations of the form
1851	a0 <operation> a1 <operation> a2, i.e., the new parameter goes to the front.
1852
1853	However, below we treat the new (a0) parameter as src2/opr2, so in the actual
1854	functions below, expect their syntax to differ slightly to those listed in the
1855	manuals, i.e., replace arg1 with arg3, arg2 with arg1 and arg3 with arg2
1856	This affects WINED3DTOP_MULTIPLYADD and WINED3DTOP_LERP */
1857
1858	if (isAlpha) {
1859	comb_target = useext(GL_COMBINE_ALPHA);
1860	src0_target = useext(GL_SOURCE0_ALPHA);
1861	src1_target = useext(GL_SOURCE1_ALPHA);
1862	src2_target = useext(GL_SOURCE2_ALPHA);
1863	opr0_target = useext(GL_OPERAND0_ALPHA);
1864	opr1_target = useext(GL_OPERAND1_ALPHA);
1865	opr2_target = useext(GL_OPERAND2_ALPHA);
1866	scal_target = GL_ALPHA_SCALE;
1867	}
1868	else {
1869	comb_target = useext(GL_COMBINE_RGB);
1870	src0_target = useext(GL_SOURCE0_RGB);
1871	src1_target = useext(GL_SOURCE1_RGB);
1872	src2_target = useext(GL_SOURCE2_RGB);
1873	opr0_target = useext(GL_OPERAND0_RGB);
1874	opr1_target = useext(GL_OPERAND1_RGB);
1875	opr2_target = useext(GL_OPERAND2_RGB);
1876	scal_target = useext(GL_RGB_SCALE);
1877	}
1878
1879	/* If a texture stage references an invalid texture unit the stage just
1880	* passes through the result from the previous stage */
1881	if (is_invalid_op(This, Stage, op, arg1, arg2, arg3)) {
1882	arg1 = WINED3DTA_CURRENT;
1883	op = WINED3DTOP_SELECTARG1;
1884	}
1885
1886	if (isAlpha && This->stateBlock->textures[Stage] == NULL && arg1 == WINED3DTA_TEXTURE) {
1887	get_src_and_opr(WINED3DTA_DIFFUSE, isAlpha, &src1, &opr1);
1888	} else {
1889	get_src_and_opr(arg1, isAlpha, &src1, &opr1);
1890	}
1891	get_src_and_opr(arg2, isAlpha, &src2, &opr2);
1892	get_src_and_opr(arg3, isAlpha, &src3, &opr3);
1893
1894	TRACE("ct(%x), 1:(%x,%x), 2:(%x,%x), 3:(%x,%x)\n", comb_target, src1, opr1, src2, opr2, src3, opr3);
1895
1896	Handled = TRUE; /* Assume will be handled */
1897
1898	/* Other texture operations require special extensions: */
1899	if (GL_SUPPORT(NV_TEXTURE_ENV_COMBINE4)) {
1900	if (isAlpha) {
1901	opr = GL_SRC_ALPHA;
1902	invopr = GL_ONE_MINUS_SRC_ALPHA;
1903	src3_target = GL_SOURCE3_ALPHA_NV;
1904	opr3_target = GL_OPERAND3_ALPHA_NV;
1905	} else {
1906	opr = GL_SRC_COLOR;
1907	invopr = GL_ONE_MINUS_SRC_COLOR;
1908	src3_target = GL_SOURCE3_RGB_NV;
1909	opr3_target = GL_OPERAND3_RGB_NV;
1910	}
1911	switch (op) {
1912	case WINED3DTOP_DISABLE: /* Only for alpha */
1913	glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_ADD);
1914	checkGLcall("GL_TEXTURE_ENV, comb_target, GL_REPLACE");
1915	glTexEnvi(GL_TEXTURE_ENV, src0_target, GL_PREVIOUS_EXT);
1916	checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
1917	glTexEnvi(GL_TEXTURE_ENV, opr0_target, GL_SRC_ALPHA);
1918	checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
1919	glTexEnvi(GL_TEXTURE_ENV, src1_target, GL_ZERO);
1920	checkGLcall("GL_TEXTURE_ENV, src1_target, GL_ZERO");
1921	glTexEnvi(GL_TEXTURE_ENV, opr1_target, invopr);
1922	checkGLcall("GL_TEXTURE_ENV, opr1_target, invopr");
1923	glTexEnvi(GL_TEXTURE_ENV, src2_target, GL_ZERO);
1924	checkGLcall("GL_TEXTURE_ENV, src2_target, GL_ZERO");
1925	glTexEnvi(GL_TEXTURE_ENV, opr2_target, opr);
1926	checkGLcall("GL_TEXTURE_ENV, opr2_target, opr");
1927	glTexEnvi(GL_TEXTURE_ENV, src3_target, GL_ZERO);
1928	checkGLcall("GL_TEXTURE_ENV, src3_target, GL_ZERO");
1929	glTexEnvi(GL_TEXTURE_ENV, opr3_target, opr);
1930	checkGLcall("GL_TEXTURE_ENV, opr3_target, opr");
1931	break;
1932	case WINED3DTOP_SELECTARG1: /* = a1 * 1 + 0 * 0 */
1933	case WINED3DTOP_SELECTARG2: /* = a2 * 1 + 0 * 0 */
1934	glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_ADD);
1935	checkGLcall("GL_TEXTURE_ENV, comb_target, GL_ADD");
1936	if (op == WINED3DTOP_SELECTARG1) {
1937	glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
1938	checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
1939	glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr1);
1940	checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
1941	} else {
1942	glTexEnvi(GL_TEXTURE_ENV, src0_target, src2);
1943	checkGLcall("GL_TEXTURE_ENV, src0_target, src2");
1944	glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr2);
1945	checkGLcall("GL_TEXTURE_ENV, opr0_target, opr2");
1946	}
1947	glTexEnvi(GL_TEXTURE_ENV, src1_target, GL_ZERO);
1948	checkGLcall("GL_TEXTURE_ENV, src1_target, GL_ZERO");
1949	glTexEnvi(GL_TEXTURE_ENV, opr1_target, invopr);
1950	checkGLcall("GL_TEXTURE_ENV, opr1_target, invopr");
1951	glTexEnvi(GL_TEXTURE_ENV, src2_target, GL_ZERO);
1952	checkGLcall("GL_TEXTURE_ENV, src2_target, GL_ZERO");
1953	glTexEnvi(GL_TEXTURE_ENV, opr2_target, opr);
1954	checkGLcall("GL_TEXTURE_ENV, opr2_target, opr");
1955	glTexEnvi(GL_TEXTURE_ENV, src3_target, GL_ZERO);
1956	checkGLcall("GL_TEXTURE_ENV, src3_target, GL_ZERO");
1957	glTexEnvi(GL_TEXTURE_ENV, opr3_target, opr);
1958	checkGLcall("GL_TEXTURE_ENV, opr3_target, opr");
1959	break;
1960
1961	case WINED3DTOP_MODULATE:
1962	glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_ADD);
1963	checkGLcall("GL_TEXTURE_ENV, comb_target, GL_ADD"); /* Add = a0a1 + a2a3 */
1964	glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
1965	checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
1966	glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr1);
1967	checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
1968	glTexEnvi(GL_TEXTURE_ENV, src1_target, src2);
1969	checkGLcall("GL_TEXTURE_ENV, src1_target, GL_ZERO");
1970	glTexEnvi(GL_TEXTURE_ENV, opr1_target, opr2);
1971	checkGLcall("GL_TEXTURE_ENV, opr1_target, invopr");
1972	glTexEnvi(GL_TEXTURE_ENV, src2_target, GL_ZERO);
1973	checkGLcall("GL_TEXTURE_ENV, src2_target, src2");
1974	glTexEnvi(GL_TEXTURE_ENV, opr2_target, opr);
1975	checkGLcall("GL_TEXTURE_ENV, opr2_target, opr2");
1976	glTexEnvi(GL_TEXTURE_ENV, src3_target, GL_ZERO);
1977	checkGLcall("GL_TEXTURE_ENV, src3_target, GL_ZERO");
1978	glTexEnvi(GL_TEXTURE_ENV, opr3_target, opr);
1979	checkGLcall("GL_TEXTURE_ENV, opr3_target, opr1");
1980	glTexEnvi(GL_TEXTURE_ENV, scal_target, 1);
1981	checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
1982	break;
1983	case WINED3DTOP_MODULATE2X:
1984	glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_ADD);
1985	checkGLcall("GL_TEXTURE_ENV, comb_target, GL_ADD"); /* Add = a0a1 + a2a3 */
1986	glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
1987	checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
1988	glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr1);
1989	checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
1990	glTexEnvi(GL_TEXTURE_ENV, src1_target, src2);
1991	checkGLcall("GL_TEXTURE_ENV, src1_target, GL_ZERO");
1992	glTexEnvi(GL_TEXTURE_ENV, opr1_target, opr2);
1993	checkGLcall("GL_TEXTURE_ENV, opr1_target, invopr");
1994	glTexEnvi(GL_TEXTURE_ENV, src2_target, GL_ZERO);
1995	checkGLcall("GL_TEXTURE_ENV, src2_target, src2");
1996	glTexEnvi(GL_TEXTURE_ENV, opr2_target, opr);
1997	checkGLcall("GL_TEXTURE_ENV, opr2_target, opr2");
1998	glTexEnvi(GL_TEXTURE_ENV, src3_target, GL_ZERO);
1999	checkGLcall("GL_TEXTURE_ENV, src3_target, GL_ZERO");
2000	glTexEnvi(GL_TEXTURE_ENV, opr3_target, opr);
2001	checkGLcall("GL_TEXTURE_ENV, opr3_target, opr1");
2002	glTexEnvi(GL_TEXTURE_ENV, scal_target, 2);
2003	checkGLcall("GL_TEXTURE_ENV, scal_target, 2");
2004	break;
2005	case WINED3DTOP_MODULATE4X:
2006	glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_ADD);
2007	checkGLcall("GL_TEXTURE_ENV, comb_target, GL_ADD"); /* Add = a0a1 + a2a3 */
2008	glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
2009	checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
2010	glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr1);
2011	checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
2012	glTexEnvi(GL_TEXTURE_ENV, src1_target, src2);
2013	checkGLcall("GL_TEXTURE_ENV, src1_target, GL_ZERO");
2014	glTexEnvi(GL_TEXTURE_ENV, opr1_target, opr2);
2015	checkGLcall("GL_TEXTURE_ENV, opr1_target, invopr");
2016	glTexEnvi(GL_TEXTURE_ENV, src2_target, GL_ZERO);
2017	checkGLcall("GL_TEXTURE_ENV, src2_target, src2");
2018	glTexEnvi(GL_TEXTURE_ENV, opr2_target, opr);
2019	checkGLcall("GL_TEXTURE_ENV, opr2_target, opr2");
2020	glTexEnvi(GL_TEXTURE_ENV, src3_target, GL_ZERO);
2021	checkGLcall("GL_TEXTURE_ENV, src3_target, GL_ZERO");
2022	glTexEnvi(GL_TEXTURE_ENV, opr3_target, opr);
2023	checkGLcall("GL_TEXTURE_ENV, opr3_target, opr1");
2024	glTexEnvi(GL_TEXTURE_ENV, scal_target, 4);
2025	checkGLcall("GL_TEXTURE_ENV, scal_target, 4");
2026	break;
2027
2028	case WINED3DTOP_ADD:
2029	glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_ADD);
2030	checkGLcall("GL_TEXTURE_ENV, comb_target, GL_ADD");
2031	glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
2032	checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
2033	glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr1);
2034	checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
2035	glTexEnvi(GL_TEXTURE_ENV, src1_target, GL_ZERO);
2036	checkGLcall("GL_TEXTURE_ENV, src1_target, GL_ZERO");
2037	glTexEnvi(GL_TEXTURE_ENV, opr1_target, invopr);
2038	checkGLcall("GL_TEXTURE_ENV, opr1_target, invopr");
2039	glTexEnvi(GL_TEXTURE_ENV, src2_target, src2);
2040	checkGLcall("GL_TEXTURE_ENV, src2_target, src2");
2041	glTexEnvi(GL_TEXTURE_ENV, opr2_target, opr2);
2042	checkGLcall("GL_TEXTURE_ENV, opr2_target, opr2");
2043	glTexEnvi(GL_TEXTURE_ENV, src3_target, GL_ZERO);
2044	checkGLcall("GL_TEXTURE_ENV, src3_target, GL_ZERO");
2045	glTexEnvi(GL_TEXTURE_ENV, opr3_target, invopr);
2046	checkGLcall("GL_TEXTURE_ENV, opr3_target, invopr");
2047	glTexEnvi(GL_TEXTURE_ENV, scal_target, 1);
2048	checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
2049	break;
2050
2051	case WINED3DTOP_ADDSIGNED:
2052	glTexEnvi(GL_TEXTURE_ENV, comb_target, useext(GL_ADD_SIGNED));
2053	checkGLcall("GL_TEXTURE_ENV, comb_target, useext(GL_ADD_SIGNED)");
2054	glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
2055	checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
2056	glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr1);
2057	checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
2058	glTexEnvi(GL_TEXTURE_ENV, src1_target, GL_ZERO);
2059	checkGLcall("GL_TEXTURE_ENV, src1_target, GL_ZERO");
2060	glTexEnvi(GL_TEXTURE_ENV, opr1_target, invopr);
2061	checkGLcall("GL_TEXTURE_ENV, opr1_target, invopr");
2062	glTexEnvi(GL_TEXTURE_ENV, src2_target, src2);
2063	checkGLcall("GL_TEXTURE_ENV, src2_target, src2");
2064	glTexEnvi(GL_TEXTURE_ENV, opr2_target, opr2);
2065	checkGLcall("GL_TEXTURE_ENV, opr2_target, opr2");
2066	glTexEnvi(GL_TEXTURE_ENV, src3_target, GL_ZERO);
2067	checkGLcall("GL_TEXTURE_ENV, src3_target, GL_ZERO");
2068	glTexEnvi(GL_TEXTURE_ENV, opr3_target, invopr);
2069	checkGLcall("GL_TEXTURE_ENV, opr3_target, invopr");
2070	glTexEnvi(GL_TEXTURE_ENV, scal_target, 1);
2071	checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
2072	break;
2073
2074	case WINED3DTOP_ADDSIGNED2X:
2075	glTexEnvi(GL_TEXTURE_ENV, comb_target, useext(GL_ADD_SIGNED));
2076	checkGLcall("GL_TEXTURE_ENV, comb_target, useext(GL_ADD_SIGNED)");
2077	glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
2078	checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
2079	glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr1);
2080	checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
2081	glTexEnvi(GL_TEXTURE_ENV, src1_target, GL_ZERO);
2082	checkGLcall("GL_TEXTURE_ENV, src1_target, GL_ZERO");
2083	glTexEnvi(GL_TEXTURE_ENV, opr1_target, invopr);
2084	checkGLcall("GL_TEXTURE_ENV, opr1_target, invopr");
2085	glTexEnvi(GL_TEXTURE_ENV, src2_target, src2);
2086	checkGLcall("GL_TEXTURE_ENV, src2_target, src2");
2087	glTexEnvi(GL_TEXTURE_ENV, opr2_target, opr2);
2088	checkGLcall("GL_TEXTURE_ENV, opr2_target, opr2");
2089	glTexEnvi(GL_TEXTURE_ENV, src3_target, GL_ZERO);
2090	checkGLcall("GL_TEXTURE_ENV, src3_target, GL_ZERO");
2091	glTexEnvi(GL_TEXTURE_ENV, opr3_target, invopr);
2092	checkGLcall("GL_TEXTURE_ENV, opr3_target, invopr");
2093	glTexEnvi(GL_TEXTURE_ENV, scal_target, 2);
2094	checkGLcall("GL_TEXTURE_ENV, scal_target, 2");
2095	break;
2096
2097	case WINED3DTOP_ADDSMOOTH:
2098	glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_ADD);
2099	checkGLcall("GL_TEXTURE_ENV, comb_target, GL_ADD");
2100	glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
2101	checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
2102	glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr1);
2103	checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
2104	glTexEnvi(GL_TEXTURE_ENV, src1_target, GL_ZERO);
2105	checkGLcall("GL_TEXTURE_ENV, src1_target, GL_ZERO");
2106	glTexEnvi(GL_TEXTURE_ENV, opr1_target, invopr);
2107	checkGLcall("GL_TEXTURE_ENV, opr1_target, invopr");
2108	glTexEnvi(GL_TEXTURE_ENV, src2_target, src2);
2109	checkGLcall("GL_TEXTURE_ENV, src2_target, src2");
2110	glTexEnvi(GL_TEXTURE_ENV, opr2_target, opr2);
2111	checkGLcall("GL_TEXTURE_ENV, opr2_target, opr2");
2112	glTexEnvi(GL_TEXTURE_ENV, src3_target, src1);
2113	checkGLcall("GL_TEXTURE_ENV, src3_target, src1");
2114	switch (opr1) {
2115	case GL_SRC_COLOR: opr = GL_ONE_MINUS_SRC_COLOR; break;
2116	case GL_ONE_MINUS_SRC_COLOR: opr = GL_SRC_COLOR; break;
2117	case GL_SRC_ALPHA: opr = GL_ONE_MINUS_SRC_ALPHA; break;
2118	case GL_ONE_MINUS_SRC_ALPHA: opr = GL_SRC_ALPHA; break;
2119	}
2120	glTexEnvi(GL_TEXTURE_ENV, opr3_target, opr);
2121	checkGLcall("GL_TEXTURE_ENV, opr3_target, opr");
2122	glTexEnvi(GL_TEXTURE_ENV, scal_target, 1);
2123	checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
2124	break;
2125
2126	case WINED3DTOP_BLENDDIFFUSEALPHA:
2127	glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_ADD);
2128	checkGLcall("GL_TEXTURE_ENV, comb_target, GL_ADD");
2129	glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
2130	checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
2131	glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr1);
2132	checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
2133	glTexEnvi(GL_TEXTURE_ENV, src1_target, useext(GL_PRIMARY_COLOR));
2134	checkGLcall("GL_TEXTURE_ENV, src1_target, useext(GL_PRIMARY_COLOR)");
2135	glTexEnvi(GL_TEXTURE_ENV, opr1_target, invopr);
2136	checkGLcall("GL_TEXTURE_ENV, opr1_target, invopr");
2137	glTexEnvi(GL_TEXTURE_ENV, src2_target, src2);
2138	checkGLcall("GL_TEXTURE_ENV, src2_target, src2");
2139	glTexEnvi(GL_TEXTURE_ENV, opr2_target, opr2);
2140	checkGLcall("GL_TEXTURE_ENV, opr2_target, opr2");
2141	glTexEnvi(GL_TEXTURE_ENV, src3_target, useext(GL_PRIMARY_COLOR));
2142	checkGLcall("GL_TEXTURE_ENV, src3_target, useext(GL_PRIMARY_COLOR)");
2143	glTexEnvi(GL_TEXTURE_ENV, opr3_target, GL_ONE_MINUS_SRC_ALPHA);
2144	checkGLcall("GL_TEXTURE_ENV, opr3_target, GL_ONE_MINUS_SRC_ALPHA");
2145	glTexEnvi(GL_TEXTURE_ENV, scal_target, 1);
2146	checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
2147	break;
2148	case WINED3DTOP_BLENDTEXTUREALPHA:
2149	glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_ADD);
2150	checkGLcall("GL_TEXTURE_ENV, comb_target, GL_ADD");
2151	glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
2152	checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
2153	glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr1);
2154	checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
2155	glTexEnvi(GL_TEXTURE_ENV, src1_target, GL_TEXTURE);
2156	checkGLcall("GL_TEXTURE_ENV, src1_target, GL_TEXTURE");
2157	glTexEnvi(GL_TEXTURE_ENV, opr1_target, invopr);
2158	checkGLcall("GL_TEXTURE_ENV, opr1_target, invopr");
2159	glTexEnvi(GL_TEXTURE_ENV, src2_target, src2);
2160	checkGLcall("GL_TEXTURE_ENV, src2_target, src2");
2161	glTexEnvi(GL_TEXTURE_ENV, opr2_target, opr2);
2162	checkGLcall("GL_TEXTURE_ENV, opr2_target, opr2");
2163	glTexEnvi(GL_TEXTURE_ENV, src3_target, GL_TEXTURE);
2164	checkGLcall("GL_TEXTURE_ENV, src3_target, GL_TEXTURE");
2165	glTexEnvi(GL_TEXTURE_ENV, opr3_target, GL_ONE_MINUS_SRC_ALPHA);
2166	checkGLcall("GL_TEXTURE_ENV, opr3_target, GL_ONE_MINUS_SRC_ALPHA");
2167	glTexEnvi(GL_TEXTURE_ENV, scal_target, 1);
2168	checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
2169	break;
2170	case WINED3DTOP_BLENDFACTORALPHA:
2171	glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_ADD);
2172	checkGLcall("GL_TEXTURE_ENV, comb_target, GL_ADD");
2173	glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
2174	checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
2175	glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr1);
2176	checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
2177	glTexEnvi(GL_TEXTURE_ENV, src1_target, useext(GL_CONSTANT));
2178	checkGLcall("GL_TEXTURE_ENV, src1_target, useext(GL_CONSTANT)");
2179	glTexEnvi(GL_TEXTURE_ENV, opr1_target, invopr);
2180	checkGLcall("GL_TEXTURE_ENV, opr1_target, invopr");
2181	glTexEnvi(GL_TEXTURE_ENV, src2_target, src2);
2182	checkGLcall("GL_TEXTURE_ENV, src2_target, src2");
2183	glTexEnvi(GL_TEXTURE_ENV, opr2_target, opr2);
2184	checkGLcall("GL_TEXTURE_ENV, opr2_target, opr2");
2185	glTexEnvi(GL_TEXTURE_ENV, src3_target, useext(GL_CONSTANT));
2186	checkGLcall("GL_TEXTURE_ENV, src3_target, useext(GL_CONSTANT)");
2187	glTexEnvi(GL_TEXTURE_ENV, opr3_target, GL_ONE_MINUS_SRC_ALPHA);
2188	checkGLcall("GL_TEXTURE_ENV, opr3_target, GL_ONE_MINUS_SRC_ALPHA");
2189	glTexEnvi(GL_TEXTURE_ENV, scal_target, 1);
2190	checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
2191	break;
2192	case WINED3DTOP_BLENDTEXTUREALPHAPM:
2193	glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_ADD);
2194	checkGLcall("GL_TEXTURE_ENV, comb_target, GL_ADD");
2195	glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
2196	checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
2197	glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr1);
2198	checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
2199	glTexEnvi(GL_TEXTURE_ENV, src1_target, GL_ZERO);
2200	checkGLcall("GL_TEXTURE_ENV, src1_target, GL_ZERO");
2201	glTexEnvi(GL_TEXTURE_ENV, opr1_target, invopr);
2202	checkGLcall("GL_TEXTURE_ENV, opr1_target, invopr");
2203	glTexEnvi(GL_TEXTURE_ENV, src2_target, src2);
2204	checkGLcall("GL_TEXTURE_ENV, src2_target, src2");
2205	glTexEnvi(GL_TEXTURE_ENV, opr2_target, opr2);
2206	checkGLcall("GL_TEXTURE_ENV, opr2_target, opr2");
2207	glTexEnvi(GL_TEXTURE_ENV, src3_target, GL_TEXTURE);
2208	checkGLcall("GL_TEXTURE_ENV, src3_target, GL_TEXTURE");
2209	glTexEnvi(GL_TEXTURE_ENV, opr3_target, GL_ONE_MINUS_SRC_ALPHA);
2210	checkGLcall("GL_TEXTURE_ENV, opr3_target, GL_ONE_MINUS_SRC_ALPHA");
2211	glTexEnvi(GL_TEXTURE_ENV, scal_target, 1);
2212	checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
2213	break;
2214	case WINED3DTOP_MODULATEALPHA_ADDCOLOR:
2215	glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_ADD);
2216	checkGLcall("GL_TEXTURE_ENV, comb_target, GL_ADD"); /* Add = a0a1 + a2a3 */
2217	glTexEnvi(GL_TEXTURE_ENV, src0_target, src1); /* a0 = src1/opr1 */
2218	checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
2219	glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr1);
2220	checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1"); /* a1 = 1 (see docs) */
2221	glTexEnvi(GL_TEXTURE_ENV, src1_target, GL_ZERO);
2222	checkGLcall("GL_TEXTURE_ENV, src1_target, GL_ZERO");
2223	glTexEnvi(GL_TEXTURE_ENV, opr1_target, invopr);
2224	checkGLcall("GL_TEXTURE_ENV, opr1_target, invopr");
2225	glTexEnvi(GL_TEXTURE_ENV, src2_target, src2); /* a2 = arg2 */
2226	checkGLcall("GL_TEXTURE_ENV, src2_target, src2");
2227	glTexEnvi(GL_TEXTURE_ENV, opr2_target, opr2);
2228	checkGLcall("GL_TEXTURE_ENV, opr2_target, opr2"); /* a3 = src1 alpha */
2229	glTexEnvi(GL_TEXTURE_ENV, src3_target, src1);
2230	checkGLcall("GL_TEXTURE_ENV, src3_target, src1");
2231	switch (opr) {
2232	case GL_SRC_COLOR: opr = GL_SRC_ALPHA; break;
2233	case GL_ONE_MINUS_SRC_COLOR: opr = GL_ONE_MINUS_SRC_ALPHA; break;
2234	}
2235	glTexEnvi(GL_TEXTURE_ENV, opr3_target, opr);
2236	checkGLcall("GL_TEXTURE_ENV, opr3_target, opr");
2237	glTexEnvi(GL_TEXTURE_ENV, scal_target, 1);
2238	checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
2239	break;
2240	case WINED3DTOP_MODULATECOLOR_ADDALPHA:
2241	glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_ADD);
2242	checkGLcall("GL_TEXTURE_ENV, comb_target, GL_ADD");
2243	glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
2244	checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
2245	glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr1);
2246	checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
2247	glTexEnvi(GL_TEXTURE_ENV, src1_target, src2);
2248	checkGLcall("GL_TEXTURE_ENV, src1_target, src2");
2249	glTexEnvi(GL_TEXTURE_ENV, opr1_target, opr2);
2250	checkGLcall("GL_TEXTURE_ENV, opr1_target, opr2");
2251	glTexEnvi(GL_TEXTURE_ENV, src2_target, src1);
2252	checkGLcall("GL_TEXTURE_ENV, src2_target, src1");
2253	switch (opr1) {
2254	case GL_SRC_COLOR: opr = GL_SRC_ALPHA; break;
2255	case GL_ONE_MINUS_SRC_COLOR: opr = GL_ONE_MINUS_SRC_ALPHA; break;
2256	}
2257	glTexEnvi(GL_TEXTURE_ENV, opr2_target, opr);
2258	checkGLcall("GL_TEXTURE_ENV, opr2_target, opr");
2259	glTexEnvi(GL_TEXTURE_ENV, src3_target, GL_ZERO);
2260	checkGLcall("GL_TEXTURE_ENV, src3_target, GL_ZERO");
2261	glTexEnvi(GL_TEXTURE_ENV, opr3_target, invopr);
2262	checkGLcall("GL_TEXTURE_ENV, opr3_target, invopr");
2263	glTexEnvi(GL_TEXTURE_ENV, scal_target, 1);
2264	checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
2265	break;
2266	case WINED3DTOP_MODULATEINVALPHA_ADDCOLOR:
2267	glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_ADD);
2268	checkGLcall("GL_TEXTURE_ENV, comb_target, GL_ADD");
2269	glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
2270	checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
2271	glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr1);
2272	checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
2273	glTexEnvi(GL_TEXTURE_ENV, src1_target, GL_ZERO);
2274	checkGLcall("GL_TEXTURE_ENV, src1_target, GL_ZERO");
2275	glTexEnvi(GL_TEXTURE_ENV, opr1_target, invopr);
2276	checkGLcall("GL_TEXTURE_ENV, opr1_target, invopr");
2277	glTexEnvi(GL_TEXTURE_ENV, src2_target, src2);
2278	checkGLcall("GL_TEXTURE_ENV, src2_target, src2");
2279	glTexEnvi(GL_TEXTURE_ENV, opr2_target, opr2);
2280	checkGLcall("GL_TEXTURE_ENV, opr2_target, opr2");
2281	glTexEnvi(GL_TEXTURE_ENV, src3_target, src1);
2282	checkGLcall("GL_TEXTURE_ENV, src3_target, src1");
2283	switch (opr1) {
2284	case GL_SRC_COLOR: opr = GL_ONE_MINUS_SRC_ALPHA; break;
2285	case GL_ONE_MINUS_SRC_COLOR: opr = GL_SRC_ALPHA; break;
2286	case GL_SRC_ALPHA: opr = GL_ONE_MINUS_SRC_ALPHA; break;
2287	case GL_ONE_MINUS_SRC_ALPHA: opr = GL_SRC_ALPHA; break;
2288	}
2289	glTexEnvi(GL_TEXTURE_ENV, opr3_target, opr);
2290	checkGLcall("GL_TEXTURE_ENV, opr3_target, opr");
2291	glTexEnvi(GL_TEXTURE_ENV, scal_target, 1);
2292	checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
2293	break;
2294	case WINED3DTOP_MODULATEINVCOLOR_ADDALPHA:
2295	glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_ADD);
2296	checkGLcall("GL_TEXTURE_ENV, comb_target, GL_ADD");
2297	glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
2298	checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
2299	switch (opr1) {
2300	case GL_SRC_COLOR: opr = GL_ONE_MINUS_SRC_COLOR; break;
2301	case GL_ONE_MINUS_SRC_COLOR: opr = GL_SRC_COLOR; break;
2302	case GL_SRC_ALPHA: opr = GL_ONE_MINUS_SRC_ALPHA; break;
2303	case GL_ONE_MINUS_SRC_ALPHA: opr = GL_SRC_ALPHA; break;
2304	}
2305	glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr);
2306	checkGLcall("GL_TEXTURE_ENV, opr0_target, opr");
2307	glTexEnvi(GL_TEXTURE_ENV, src1_target, src2);
2308	checkGLcall("GL_TEXTURE_ENV, src1_target, src2");
2309	glTexEnvi(GL_TEXTURE_ENV, opr1_target, opr2);
2310	checkGLcall("GL_TEXTURE_ENV, opr1_target, opr2");
2311	glTexEnvi(GL_TEXTURE_ENV, src2_target, src1);
2312	checkGLcall("GL_TEXTURE_ENV, src2_target, src1");
2313	switch (opr1) {
2314	case GL_SRC_COLOR: opr = GL_SRC_ALPHA; break;
2315	case GL_ONE_MINUS_SRC_COLOR: opr = GL_ONE_MINUS_SRC_ALPHA; break;
2316	}
2317	glTexEnvi(GL_TEXTURE_ENV, opr2_target, opr);
2318	checkGLcall("GL_TEXTURE_ENV, opr2_target, opr");
2319	glTexEnvi(GL_TEXTURE_ENV, src3_target, GL_ZERO);
2320	checkGLcall("GL_TEXTURE_ENV, src3_target, GL_ZERO");
2321	glTexEnvi(GL_TEXTURE_ENV, opr3_target, invopr);
2322	checkGLcall("GL_TEXTURE_ENV, opr3_target, invopr");
2323	glTexEnvi(GL_TEXTURE_ENV, scal_target, 1);
2324	checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
2325	break;
2326	case WINED3DTOP_MULTIPLYADD:
2327	glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_ADD);
2328	checkGLcall("GL_TEXTURE_ENV, comb_target, GL_ADD");
2329	glTexEnvi(GL_TEXTURE_ENV, src0_target, src3);
2330	checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
2331	glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr3);
2332	checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
2333	glTexEnvi(GL_TEXTURE_ENV, src1_target, GL_ZERO);
2334	checkGLcall("GL_TEXTURE_ENV, src1_target, GL_ZERO");
2335	glTexEnvi(GL_TEXTURE_ENV, opr1_target, invopr);
2336	checkGLcall("GL_TEXTURE_ENV, opr1_target, invopr");
2337	glTexEnvi(GL_TEXTURE_ENV, src2_target, src1);
2338	checkGLcall("GL_TEXTURE_ENV, src2_target, src2");
2339	glTexEnvi(GL_TEXTURE_ENV, opr2_target, opr1);
2340	checkGLcall("GL_TEXTURE_ENV, opr2_target, opr2");
2341	glTexEnvi(GL_TEXTURE_ENV, src3_target, src2);
2342	checkGLcall("GL_TEXTURE_ENV, src3_target, src3");
2343	glTexEnvi(GL_TEXTURE_ENV, opr3_target, opr2);
2344	checkGLcall("GL_TEXTURE_ENV, opr3_target, opr3");
2345	glTexEnvi(GL_TEXTURE_ENV, scal_target, 1);
2346	checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
2347	break;
2348
2349	case WINED3DTOP_BUMPENVMAP:
2350	{
2351	}
2352
2353	case WINED3DTOP_BUMPENVMAPLUMINANCE:
2354	FIXME("Implement bump environment mapping in GL_NV_texture_env_combine4 path\n");
2355
2356	default:
2357	Handled = FALSE;
2358	}
2359	if (Handled) {
2360	glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE4_NV);
2361	checkGLcall("GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE4_NV");
2362
2363	return;
2364	}
2365	} /* GL_NV_texture_env_combine4 */
2366
2367	Handled = TRUE; /* Again, assume handled */
2368	switch (op) {
2369	case WINED3DTOP_DISABLE: /* Only for alpha */
2370	glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_REPLACE);
2371	checkGLcall("GL_TEXTURE_ENV, comb_target, GL_REPLACE");
2372	glTexEnvi(GL_TEXTURE_ENV, src0_target, GL_PREVIOUS_EXT);
2373	checkGLcall("GL_TEXTURE_ENV, src0_target, GL_PREVIOUS_EXT");
2374	glTexEnvi(GL_TEXTURE_ENV, opr0_target, GL_SRC_ALPHA);
2375	checkGLcall("GL_TEXTURE_ENV, opr0_target, GL_SRC_ALPHA");
2376	glTexEnvi(GL_TEXTURE_ENV, scal_target, 1);
2377	checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
2378	break;
2379	case WINED3DTOP_SELECTARG1:
2380	glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_REPLACE);
2381	checkGLcall("GL_TEXTURE_ENV, comb_target, GL_REPLACE");
2382	glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
2383	checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
2384	glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr1);
2385	checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
2386	glTexEnvi(GL_TEXTURE_ENV, scal_target, 1);
2387	checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
2388	break;
2389	case WINED3DTOP_SELECTARG2:
2390	glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_REPLACE);
2391	checkGLcall("GL_TEXTURE_ENV, comb_target, GL_REPLACE");
2392	glTexEnvi(GL_TEXTURE_ENV, src0_target, src2);
2393	checkGLcall("GL_TEXTURE_ENV, src0_target, src2");
2394	glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr2);
2395	checkGLcall("GL_TEXTURE_ENV, opr0_target, opr2");
2396	glTexEnvi(GL_TEXTURE_ENV, scal_target, 1);
2397	checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
2398	break;
2399	case WINED3DTOP_MODULATE:
2400	glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_MODULATE);
2401	checkGLcall("GL_TEXTURE_ENV, comb_target, GL_MODULATE");
2402	glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
2403	checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
2404	glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr1);
2405	checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
2406	glTexEnvi(GL_TEXTURE_ENV, src1_target, src2);
2407	checkGLcall("GL_TEXTURE_ENV, src1_target, src2");
2408	glTexEnvi(GL_TEXTURE_ENV, opr1_target, opr2);
2409	checkGLcall("GL_TEXTURE_ENV, opr1_target, opr2");
2410	glTexEnvi(GL_TEXTURE_ENV, scal_target, 1);
2411	checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
2412	break;
2413	case WINED3DTOP_MODULATE2X:
2414	glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_MODULATE);
2415	checkGLcall("GL_TEXTURE_ENV, comb_target, GL_MODULATE");
2416	glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
2417	checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
2418	glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr1);
2419	checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
2420	glTexEnvi(GL_TEXTURE_ENV, src1_target, src2);
2421	checkGLcall("GL_TEXTURE_ENV, src1_target, src2");
2422	glTexEnvi(GL_TEXTURE_ENV, opr1_target, opr2);
2423	checkGLcall("GL_TEXTURE_ENV, opr1_target, opr2");
2424	glTexEnvi(GL_TEXTURE_ENV, scal_target, 2);
2425	checkGLcall("GL_TEXTURE_ENV, scal_target, 2");
2426	break;
2427	case WINED3DTOP_MODULATE4X:
2428	glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_MODULATE);
2429	checkGLcall("GL_TEXTURE_ENV, comb_target, GL_MODULATE");
2430	glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
2431	checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
2432	glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr1);
2433	checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
2434	glTexEnvi(GL_TEXTURE_ENV, src1_target, src2);
2435	checkGLcall("GL_TEXTURE_ENV, src1_target, src2");
2436	glTexEnvi(GL_TEXTURE_ENV, opr1_target, opr2);
2437	checkGLcall("GL_TEXTURE_ENV, opr1_target, opr2");
2438	glTexEnvi(GL_TEXTURE_ENV, scal_target, 4);
2439	checkGLcall("GL_TEXTURE_ENV, scal_target, 4");
2440	break;
2441	case WINED3DTOP_ADD:
2442	glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_ADD);
2443	checkGLcall("GL_TEXTURE_ENV, comb_target, GL_ADD");
2444	glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
2445	checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
2446	glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr1);
2447	checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
2448	glTexEnvi(GL_TEXTURE_ENV, src1_target, src2);
2449	checkGLcall("GL_TEXTURE_ENV, src1_target, src2");
2450	glTexEnvi(GL_TEXTURE_ENV, opr1_target, opr2);
2451	checkGLcall("GL_TEXTURE_ENV, opr1_target, opr2");
2452	glTexEnvi(GL_TEXTURE_ENV, scal_target, 1);
2453	checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
2454	break;
2455	case WINED3DTOP_ADDSIGNED:
2456	glTexEnvi(GL_TEXTURE_ENV, comb_target, useext(GL_ADD_SIGNED));
2457	checkGLcall("GL_TEXTURE_ENV, comb_target, useext((GL_ADD_SIGNED)");
2458	glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
2459	checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
2460	glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr1);
2461	checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
2462	glTexEnvi(GL_TEXTURE_ENV, src1_target, src2);
2463	checkGLcall("GL_TEXTURE_ENV, src1_target, src2");
2464	glTexEnvi(GL_TEXTURE_ENV, opr1_target, opr2);
2465	checkGLcall("GL_TEXTURE_ENV, opr1_target, opr2");
2466	glTexEnvi(GL_TEXTURE_ENV, scal_target, 1);
2467	checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
2468	break;
2469	case WINED3DTOP_ADDSIGNED2X:
2470	glTexEnvi(GL_TEXTURE_ENV, comb_target, useext(GL_ADD_SIGNED));
2471	checkGLcall("GL_TEXTURE_ENV, comb_target, useext(GL_ADD_SIGNED)");
2472	glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
2473	checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
2474	glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr1);
2475	checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
2476	glTexEnvi(GL_TEXTURE_ENV, src1_target, src2);
2477	checkGLcall("GL_TEXTURE_ENV, src1_target, src2");
2478	glTexEnvi(GL_TEXTURE_ENV, opr1_target, opr2);
2479	checkGLcall("GL_TEXTURE_ENV, opr1_target, opr2");
2480	glTexEnvi(GL_TEXTURE_ENV, scal_target, 2);
2481	checkGLcall("GL_TEXTURE_ENV, scal_target, 2");
2482	break;
2483	case WINED3DTOP_SUBTRACT:
2484	if (GL_SUPPORT(ARB_TEXTURE_ENV_COMBINE)) {
2485	glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_SUBTRACT);
2486	checkGLcall("GL_TEXTURE_ENV, comb_target, useext(GL_SUBTRACT)");
2487	glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
2488	checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
2489	glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr1);
2490	checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
2491	glTexEnvi(GL_TEXTURE_ENV, src1_target, src2);
2492	checkGLcall("GL_TEXTURE_ENV, src1_target, src2");
2493	glTexEnvi(GL_TEXTURE_ENV, opr1_target, opr2);
2494	checkGLcall("GL_TEXTURE_ENV, opr1_target, opr2");
2495	glTexEnvi(GL_TEXTURE_ENV, scal_target, 1);
2496	checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
2497	} else {
2498	FIXME("This version of opengl does not support GL_SUBTRACT\n");
2499	}
2500	break;
2501
2502	case WINED3DTOP_BLENDDIFFUSEALPHA:
2503	glTexEnvi(GL_TEXTURE_ENV, comb_target, useext(GL_INTERPOLATE));
2504	checkGLcall("GL_TEXTURE_ENV, comb_target, useext(GL_INTERPOLATE)");
2505	glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
2506	checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
2507	glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr1);
2508	checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
2509	glTexEnvi(GL_TEXTURE_ENV, src1_target, src2);
2510	checkGLcall("GL_TEXTURE_ENV, src1_target, src2");
2511	glTexEnvi(GL_TEXTURE_ENV, opr1_target, opr2);
2512	checkGLcall("GL_TEXTURE_ENV, opr1_target, opr2");
2513	glTexEnvi(GL_TEXTURE_ENV, src2_target, useext(GL_PRIMARY_COLOR));
2514	checkGLcall("GL_TEXTURE_ENV, src2_target, GL_PRIMARY_COLOR");
2515	glTexEnvi(GL_TEXTURE_ENV, opr2_target, GL_SRC_ALPHA);
2516	checkGLcall("GL_TEXTURE_ENV, opr2_target, GL_SRC_ALPHA");
2517	glTexEnvi(GL_TEXTURE_ENV, scal_target, 1);
2518	checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
2519	break;
2520	case WINED3DTOP_BLENDTEXTUREALPHA:
2521	glTexEnvi(GL_TEXTURE_ENV, comb_target, useext(GL_INTERPOLATE));
2522	checkGLcall("GL_TEXTURE_ENV, comb_target, useext(GL_INTERPOLATE)");
2523	glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
2524	checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
2525	glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr1);
2526	checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
2527	glTexEnvi(GL_TEXTURE_ENV, src1_target, src2);
2528	checkGLcall("GL_TEXTURE_ENV, src1_target, src2");
2529	glTexEnvi(GL_TEXTURE_ENV, opr1_target, opr2);
2530	checkGLcall("GL_TEXTURE_ENV, opr1_target, opr2");
2531	glTexEnvi(GL_TEXTURE_ENV, src2_target, GL_TEXTURE);
2532	checkGLcall("GL_TEXTURE_ENV, src2_target, GL_TEXTURE");
2533	glTexEnvi(GL_TEXTURE_ENV, opr2_target, GL_SRC_ALPHA);
2534	checkGLcall("GL_TEXTURE_ENV, opr2_target, GL_SRC_ALPHA");
2535	glTexEnvi(GL_TEXTURE_ENV, scal_target, 1);
2536	checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
2537	break;
2538	case WINED3DTOP_BLENDFACTORALPHA:
2539	glTexEnvi(GL_TEXTURE_ENV, comb_target, useext(GL_INTERPOLATE));
2540	checkGLcall("GL_TEXTURE_ENV, comb_target, useext(GL_INTERPOLATE)");
2541	glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
2542	checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
2543	glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr1);
2544	checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
2545	glTexEnvi(GL_TEXTURE_ENV, src1_target, src2);
2546	checkGLcall("GL_TEXTURE_ENV, src1_target, src2");
2547	glTexEnvi(GL_TEXTURE_ENV, opr1_target, opr2);
2548	checkGLcall("GL_TEXTURE_ENV, opr1_target, opr2");
2549	glTexEnvi(GL_TEXTURE_ENV, src2_target, useext(GL_CONSTANT));
2550	checkGLcall("GL_TEXTURE_ENV, src2_target, GL_CONSTANT");
2551	glTexEnvi(GL_TEXTURE_ENV, opr2_target, GL_SRC_ALPHA);
2552	checkGLcall("GL_TEXTURE_ENV, opr2_target, GL_SRC_ALPHA");
2553	glTexEnvi(GL_TEXTURE_ENV, scal_target, 1);
2554	checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
2555	break;
2556	case WINED3DTOP_BLENDCURRENTALPHA:
2557	glTexEnvi(GL_TEXTURE_ENV, comb_target, useext(GL_INTERPOLATE));
2558	checkGLcall("GL_TEXTURE_ENV, comb_target, useext(GL_INTERPOLATE)");
2559	glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
2560	checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
2561	glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr1);
2562	checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
2563	glTexEnvi(GL_TEXTURE_ENV, src1_target, src2);
2564	checkGLcall("GL_TEXTURE_ENV, src1_target, src2");
2565	glTexEnvi(GL_TEXTURE_ENV, opr1_target, opr2);
2566	checkGLcall("GL_TEXTURE_ENV, opr1_target, opr2");
2567	glTexEnvi(GL_TEXTURE_ENV, src2_target, useext(GL_PREVIOUS));
2568	checkGLcall("GL_TEXTURE_ENV, src2_target, GL_PREVIOUS");
2569	glTexEnvi(GL_TEXTURE_ENV, opr2_target, GL_SRC_ALPHA);
2570	checkGLcall("GL_TEXTURE_ENV, opr2_target, GL_SRC_ALPHA");
2571	glTexEnvi(GL_TEXTURE_ENV, scal_target, 1);
2572	checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
2573	break;
2574	case WINED3DTOP_DOTPRODUCT3:
2575	if (GL_SUPPORT(ARB_TEXTURE_ENV_DOT3)) {
2576	glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_DOT3_RGBA_ARB);
2577	checkGLcall("GL_TEXTURE_ENV, comb_target, GL_DOT3_RGBA_ARB");
2578	} else if (GL_SUPPORT(EXT_TEXTURE_ENV_DOT3)) {
2579	glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_DOT3_RGBA_EXT);
2580	checkGLcall("GL_TEXTURE_ENV, comb_target, GL_DOT3_RGBA_EXT");
2581	} else {
2582	FIXME("This version of opengl does not support GL_DOT3\n");
2583	}
2584	glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
2585	checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
2586	glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr1);
2587	checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
2588	glTexEnvi(GL_TEXTURE_ENV, src1_target, src2);
2589	checkGLcall("GL_TEXTURE_ENV, src1_target, src2");
2590	glTexEnvi(GL_TEXTURE_ENV, opr1_target, opr2);
2591	checkGLcall("GL_TEXTURE_ENV, opr1_target, opr2");
2592	glTexEnvi(GL_TEXTURE_ENV, scal_target, 1);
2593	checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
2594	break;
2595	case WINED3DTOP_LERP:
2596	glTexEnvi(GL_TEXTURE_ENV, comb_target, useext(GL_INTERPOLATE));
2597	checkGLcall("GL_TEXTURE_ENV, comb_target, useext(GL_INTERPOLATE)");
2598	glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
2599	checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
2600	glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr1);
2601	checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
2602	glTexEnvi(GL_TEXTURE_ENV, src1_target, src2);
2603	checkGLcall("GL_TEXTURE_ENV, src1_target, src2");
2604	glTexEnvi(GL_TEXTURE_ENV, opr1_target, opr2);
2605	checkGLcall("GL_TEXTURE_ENV, opr1_target, opr2");
2606	glTexEnvi(GL_TEXTURE_ENV, src2_target, src3);
2607	checkGLcall("GL_TEXTURE_ENV, src2_target, src3");
2608	glTexEnvi(GL_TEXTURE_ENV, opr2_target, opr3);
2609	checkGLcall("GL_TEXTURE_ENV, opr2_target, opr3");
2610	glTexEnvi(GL_TEXTURE_ENV, scal_target, 1);
2611	checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
2612	break;
2613	case WINED3DTOP_ADDSMOOTH:
2614	if (GL_SUPPORT(ATI_TEXTURE_ENV_COMBINE3)) {
2615	glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_MODULATE_ADD_ATI);
2616	checkGLcall("GL_TEXTURE_ENV, comb_target, GL_MODULATE_ADD_ATI");
2617	glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
2618	checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
2619	switch (opr1) {
2620	case GL_SRC_COLOR: opr = GL_ONE_MINUS_SRC_COLOR; break;
2621	case GL_ONE_MINUS_SRC_COLOR: opr = GL_SRC_COLOR; break;
2622	case GL_SRC_ALPHA: opr = GL_ONE_MINUS_SRC_ALPHA; break;
2623	case GL_ONE_MINUS_SRC_ALPHA: opr = GL_SRC_ALPHA; break;
2624	}
2625	glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr);
2626	checkGLcall("GL_TEXTURE_ENV, opr0_target, opr");
2627	glTexEnvi(GL_TEXTURE_ENV, src1_target, src1);
2628	checkGLcall("GL_TEXTURE_ENV, src1_target, src1");
2629	glTexEnvi(GL_TEXTURE_ENV, opr1_target, opr1);
2630	checkGLcall("GL_TEXTURE_ENV, opr1_target, opr1");
2631	glTexEnvi(GL_TEXTURE_ENV, src2_target, src2);
2632	checkGLcall("GL_TEXTURE_ENV, src2_target, src2");
2633	glTexEnvi(GL_TEXTURE_ENV, opr2_target, opr2);
2634	checkGLcall("GL_TEXTURE_ENV, opr2_target, opr2");
2635	glTexEnvi(GL_TEXTURE_ENV, scal_target, 1);
2636	checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
2637	} else
2638	Handled = FALSE;
2639	break;
2640	case WINED3DTOP_BLENDTEXTUREALPHAPM:
2641	if (GL_SUPPORT(ATI_TEXTURE_ENV_COMBINE3)) {
2642	glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_MODULATE_ADD_ATI);
2643	checkGLcall("GL_TEXTURE_ENV, comb_target, GL_MODULATE_ADD_ATI");
2644	glTexEnvi(GL_TEXTURE_ENV, src0_target, GL_TEXTURE);
2645	checkGLcall("GL_TEXTURE_ENV, src0_target, GL_TEXTURE");
2646	glTexEnvi(GL_TEXTURE_ENV, opr0_target, GL_ONE_MINUS_SRC_ALPHA);
2647	checkGLcall("GL_TEXTURE_ENV, opr0_target, GL_ONE_MINUS_SRC_APHA");
2648	glTexEnvi(GL_TEXTURE_ENV, src1_target, src1);
2649	checkGLcall("GL_TEXTURE_ENV, src1_target, src1");
2650	glTexEnvi(GL_TEXTURE_ENV, opr1_target, opr1);
2651	checkGLcall("GL_TEXTURE_ENV, opr1_target, opr1");
2652	glTexEnvi(GL_TEXTURE_ENV, src2_target, src2);
2653	checkGLcall("GL_TEXTURE_ENV, src2_target, src2");
2654	glTexEnvi(GL_TEXTURE_ENV, opr2_target, opr2);
2655	checkGLcall("GL_TEXTURE_ENV, opr2_target, opr2");
2656	glTexEnvi(GL_TEXTURE_ENV, scal_target, 1);
2657	checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
2658	} else
2659	Handled = FALSE;
2660	break;
2661	case WINED3DTOP_MODULATEALPHA_ADDCOLOR:
2662	if (GL_SUPPORT(ATI_TEXTURE_ENV_COMBINE3)) {
2663	glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_MODULATE_ADD_ATI);
2664	checkGLcall("GL_TEXTURE_ENV, comb_target, GL_MODULATE_ADD_ATI");
2665	glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
2666	checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
2667	switch (opr1) {
2668	case GL_SRC_COLOR: opr = GL_SRC_ALPHA; break;
2669	case GL_ONE_MINUS_SRC_COLOR: opr = GL_ONE_MINUS_SRC_ALPHA; break;
2670	case GL_SRC_ALPHA: opr = GL_SRC_ALPHA; break;
2671	case GL_ONE_MINUS_SRC_ALPHA: opr = GL_ONE_MINUS_SRC_ALPHA; break;
2672	}
2673	glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr);
2674	checkGLcall("GL_TEXTURE_ENV, opr0_target, opr");
2675	glTexEnvi(GL_TEXTURE_ENV, src1_target, src1);
2676	checkGLcall("GL_TEXTURE_ENV, src1_target, src1");
2677	glTexEnvi(GL_TEXTURE_ENV, opr1_target, opr1);
2678	checkGLcall("GL_TEXTURE_ENV, opr1_target, opr1");
2679	glTexEnvi(GL_TEXTURE_ENV, src2_target, src2);
2680	checkGLcall("GL_TEXTURE_ENV, src2_target, src2");
2681	glTexEnvi(GL_TEXTURE_ENV, opr2_target, opr2);
2682	checkGLcall("GL_TEXTURE_ENV, opr2_target, opr2");
2683	glTexEnvi(GL_TEXTURE_ENV, scal_target, 1);
2684	checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
2685	} else
2686	Handled = FALSE;
2687	break;
2688	case WINED3DTOP_MODULATECOLOR_ADDALPHA:
2689	if (GL_SUPPORT(ATI_TEXTURE_ENV_COMBINE3)) {
2690	glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_MODULATE_ADD_ATI);
2691	checkGLcall("GL_TEXTURE_ENV, comb_target, GL_MODULATE_ADD_ATI");
2692	glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
2693	checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
2694	glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr1);
2695	checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
2696	glTexEnvi(GL_TEXTURE_ENV, src1_target, src1);
2697	checkGLcall("GL_TEXTURE_ENV, src1_target, src1");
2698	switch (opr1) {
2699	case GL_SRC_COLOR: opr = GL_SRC_ALPHA; break;
2700	case GL_ONE_MINUS_SRC_COLOR: opr = GL_ONE_MINUS_SRC_ALPHA; break;
2701	case GL_SRC_ALPHA: opr = GL_SRC_ALPHA; break;
2702	case GL_ONE_MINUS_SRC_ALPHA: opr = GL_ONE_MINUS_SRC_ALPHA; break;
2703	}
2704	glTexEnvi(GL_TEXTURE_ENV, opr1_target, opr);
2705	checkGLcall("GL_TEXTURE_ENV, opr1_target, opr");
2706	glTexEnvi(GL_TEXTURE_ENV, src2_target, src2);
2707	checkGLcall("GL_TEXTURE_ENV, src2_target, src2");
2708	glTexEnvi(GL_TEXTURE_ENV, opr2_target, opr2);
2709	checkGLcall("GL_TEXTURE_ENV, opr2_target, opr2");
2710	glTexEnvi(GL_TEXTURE_ENV, scal_target, 1);
2711	checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
2712	} else
2713	Handled = FALSE;
2714	break;
2715	case WINED3DTOP_MODULATEINVALPHA_ADDCOLOR:
2716	if (GL_SUPPORT(ATI_TEXTURE_ENV_COMBINE3)) {
2717	glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_MODULATE_ADD_ATI);
2718	checkGLcall("GL_TEXTURE_ENV, comb_target, GL_MODULATE_ADD_ATI");
2719	glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
2720	checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
2721	switch (opr1) {
2722	case GL_SRC_COLOR: opr = GL_ONE_MINUS_SRC_ALPHA; break;
2723	case GL_ONE_MINUS_SRC_COLOR: opr = GL_SRC_ALPHA; break;
2724	case GL_SRC_ALPHA: opr = GL_ONE_MINUS_SRC_ALPHA; break;
2725	case GL_ONE_MINUS_SRC_ALPHA: opr = GL_SRC_ALPHA; break;
2726	}
2727	glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr);
2728	checkGLcall("GL_TEXTURE_ENV, opr0_target, opr");
2729	glTexEnvi(GL_TEXTURE_ENV, src1_target, src1);
2730	checkGLcall("GL_TEXTURE_ENV, src1_target, src1");
2731	glTexEnvi(GL_TEXTURE_ENV, opr1_target, opr1);
2732	checkGLcall("GL_TEXTURE_ENV, opr1_target, opr1");
2733	glTexEnvi(GL_TEXTURE_ENV, src2_target, src2);
2734	checkGLcall("GL_TEXTURE_ENV, src2_target, src2");
2735	glTexEnvi(GL_TEXTURE_ENV, opr2_target, opr2);
2736	checkGLcall("GL_TEXTURE_ENV, opr2_target, opr2");
2737	glTexEnvi(GL_TEXTURE_ENV, scal_target, 1);
2738	checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
2739	} else
2740	Handled = FALSE;
2741	break;
2742	case WINED3DTOP_MODULATEINVCOLOR_ADDALPHA:
2743	if (GL_SUPPORT(ATI_TEXTURE_ENV_COMBINE3)) {
2744	glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_MODULATE_ADD_ATI);
2745	checkGLcall("GL_TEXTURE_ENV, comb_target, GL_MODULATE_ADD_ATI");
2746	glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
2747	checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
2748	switch (opr1) {
2749	case GL_SRC_COLOR: opr = GL_ONE_MINUS_SRC_COLOR; break;
2750	case GL_ONE_MINUS_SRC_COLOR: opr = GL_SRC_COLOR; break;
2751	case GL_SRC_ALPHA: opr = GL_ONE_MINUS_SRC_ALPHA; break;
2752	case GL_ONE_MINUS_SRC_ALPHA: opr = GL_SRC_ALPHA; break;
2753	}
2754	glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr);
2755	checkGLcall("GL_TEXTURE_ENV, opr0_target, opr");
2756	glTexEnvi(GL_TEXTURE_ENV, src1_target, src1);
2757	checkGLcall("GL_TEXTURE_ENV, src1_target, src1");
2758	switch (opr1) {
2759	case GL_SRC_COLOR: opr = GL_SRC_ALPHA; break;
2760	case GL_ONE_MINUS_SRC_COLOR: opr = GL_ONE_MINUS_SRC_ALPHA; break;
2761	case GL_SRC_ALPHA: opr = GL_SRC_ALPHA; break;
2762	case GL_ONE_MINUS_SRC_ALPHA: opr = GL_ONE_MINUS_SRC_ALPHA; break;
2763	}
2764	glTexEnvi(GL_TEXTURE_ENV, opr1_target, opr);
2765	checkGLcall("GL_TEXTURE_ENV, opr1_target, opr");
2766	glTexEnvi(GL_TEXTURE_ENV, src2_target, src2);
2767	checkGLcall("GL_TEXTURE_ENV, src2_target, src2");
2768	glTexEnvi(GL_TEXTURE_ENV, opr2_target, opr2);
2769	checkGLcall("GL_TEXTURE_ENV, opr2_target, opr2");
2770	glTexEnvi(GL_TEXTURE_ENV, scal_target, 1);
2771	checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
2772	} else
2773	Handled = FALSE;
2774	break;
2775	case WINED3DTOP_MULTIPLYADD:
2776	if (GL_SUPPORT(ATI_TEXTURE_ENV_COMBINE3)) {
2777	glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_MODULATE_ADD_ATI);
2778	checkGLcall("GL_TEXTURE_ENV, comb_target, GL_MODULATE_ADD_ATI");
2779	glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
2780	checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
2781	glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr1);
2782	checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
2783	glTexEnvi(GL_TEXTURE_ENV, src1_target, src3);
2784	checkGLcall("GL_TEXTURE_ENV, src1_target, src3");
2785	glTexEnvi(GL_TEXTURE_ENV, opr1_target, opr3);
2786	checkGLcall("GL_TEXTURE_ENV, opr1_target, opr3");
2787	glTexEnvi(GL_TEXTURE_ENV, src2_target, src2);
2788	checkGLcall("GL_TEXTURE_ENV, src2_target, src2");
2789	glTexEnvi(GL_TEXTURE_ENV, opr2_target, opr2);
2790	checkGLcall("GL_TEXTURE_ENV, opr2_target, opr2");
2791	glTexEnvi(GL_TEXTURE_ENV, scal_target, 1);
2792	checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
2793	} else
2794	Handled = FALSE;
2795	break;
2796	case WINED3DTOP_BUMPENVMAPLUMINANCE:
2797	case WINED3DTOP_BUMPENVMAP:
2798	if(GL_SUPPORT(NV_TEXTURE_SHADER2)) {
2799	/* Technically texture shader support without register combiners is possible, but not expected to occur
2800	* on real world cards, so for now a fixme should be enough
2801	*/
2802	FIXME("Implement bump mapping with GL_NV_texture_shader in non register combiner path\n");
2803	}
2804	default:
2805	Handled = FALSE;
2806	}
2807
2808	if (Handled) {
2809	BOOL combineOK = TRUE;
2810	if (GL_SUPPORT(NV_TEXTURE_ENV_COMBINE4)) {
2811	DWORD op2;
2812
2813	if (isAlpha) {
2814	op2 = This->stateBlock->textureState[Stage][WINED3DTSS_COLOROP];
2815	} else {
2816	op2 = This->stateBlock->textureState[Stage][WINED3DTSS_ALPHAOP];
2817	}
2818
2819	/* Note: If COMBINE4 in effect can't go back to combine! */
2820	switch (op2) {
2821	case WINED3DTOP_ADDSMOOTH:
2822	case WINED3DTOP_BLENDTEXTUREALPHAPM:
2823	case WINED3DTOP_MODULATEALPHA_ADDCOLOR:
2824	case WINED3DTOP_MODULATECOLOR_ADDALPHA:
2825	case WINED3DTOP_MODULATEINVALPHA_ADDCOLOR:
2826	case WINED3DTOP_MODULATEINVCOLOR_ADDALPHA:
2827	case WINED3DTOP_MULTIPLYADD:
2828	/* Ignore those implemented in both cases */
2829	switch (op) {
2830	case WINED3DTOP_SELECTARG1:
2831	case WINED3DTOP_SELECTARG2:
2832	combineOK = FALSE;
2833	Handled = FALSE;
2834	break;
2835	default:
2836	FIXME("Can't use COMBINE4 and COMBINE together, thisop=%s, otherop=%s, isAlpha(%d)\n", debug_d3dtop(op), debug_d3dtop(op2), isAlpha);
2837	return;
2838	}
2839	}
2840	}
2841
2842	if (combineOK) {
2843	glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, useext(GL_COMBINE));
2844	checkGLcall("GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, useext(GL_COMBINE)");
2845
2846	return;
2847	}
2848	}
2849
2850	/* After all the extensions, if still unhandled, report fixme */
2851	FIXME("Unhandled texture operation %s\n", debug_d3dtop(op));
2852	}
2853
2854
2855	static void tex_colorop(DWORD state, IWineD3DStateBlockImpl stateblock, WineD3DContext context) {
2856	DWORD stage = (state - STATE_TEXTURESTAGE(0, 0)) / (WINED3D_HIGHEST_TEXTURE_STATE + 1);
2857	DWORD mapped_stage = stateblock->wineD3DDevice->texUnitMap[stage];
2858	BOOL tex_used = stateblock->wineD3DDevice->fixed_function_usage_map & (1 << stage);
2859
2860	TRACE("Setting color op for stage %d\n", stage);
2861
2862	/* Using a pixel shader? Don't care for anything here, the shader applying does it */
2863	if (use_ps(stateblock)) return;
2864
2865	if (stage != mapped_stage) WARN("Using non 1:1 mapping: %d -> %d!\n", stage, mapped_stage);
2866
2867	if (mapped_stage != WINED3D_UNMAPPED_STAGE)
2868	{
2869	if (tex_used && mapped_stage >= GL_LIMITS(textures)) {
2870	FIXME("Attempt to enable unsupported stage!\n");
2871	return;
2872	}
2873	GL_EXTCALL(glActiveTextureARB(GL_TEXTURE0_ARB + mapped_stage));
2874	checkGLcall("glActiveTextureARB");
2875	}
2876
2877	if(stage >= stateblock->lowest_disabled_stage) {
2878	TRACE("Stage disabled\n");
2879	if (mapped_stage != WINED3D_UNMAPPED_STAGE)
2880	{
2881	/* Disable everything here */
2882	glDisable(GL_TEXTURE_2D);
2883	checkGLcall("glDisable(GL_TEXTURE_2D)");
2884	glDisable(GL_TEXTURE_3D);
2885	checkGLcall("glDisable(GL_TEXTURE_3D)");
2886	if(GL_SUPPORT(ARB_TEXTURE_CUBE_MAP)) {
2887	glDisable(GL_TEXTURE_CUBE_MAP_ARB);
2888	checkGLcall("glDisable(GL_TEXTURE_CUBE_MAP_ARB)");
2889	}
2890	if(GL_SUPPORT(ARB_TEXTURE_RECTANGLE)) {
2891	glDisable(GL_TEXTURE_RECTANGLE_ARB);
2892	checkGLcall("glDisable(GL_TEXTURE_RECTANGLE_ARB)");
2893	}
2894	}
2895	/* All done */
2896	return;
2897	}
2898
2899	/* The sampler will also activate the correct texture dimensions, so no need to do it here
2900	* if the sampler for this stage is dirty
2901	*/
2902	if(!isStateDirty(context, STATE_SAMPLER(stage))) {
2903	if (tex_used) texture_activate_dimensions(stage, stateblock, context);
2904	}
2905
2906	set_tex_op((IWineD3DDevice *)stateblock->wineD3DDevice, FALSE, stage,
2907	stateblock->textureState[stage][WINED3DTSS_COLOROP],
2908	stateblock->textureState[stage][WINED3DTSS_COLORARG1],
2909	stateblock->textureState[stage][WINED3DTSS_COLORARG2],
2910	stateblock->textureState[stage][WINED3DTSS_COLORARG0]);
2911	}
2912
2913	void tex_alphaop(DWORD state, IWineD3DStateBlockImpl stateblock, WineD3DContext context) {
2914	DWORD stage = (state - STATE_TEXTURESTAGE(0, 0)) / (WINED3D_HIGHEST_TEXTURE_STATE + 1);
2915	DWORD mapped_stage = stateblock->wineD3DDevice->texUnitMap[stage];
2916	BOOL tex_used = stateblock->wineD3DDevice->fixed_function_usage_map & (1 << stage);
2917	DWORD op, arg1, arg2, arg0;
2918
2919	TRACE("Setting alpha op for stage %d\n", stage);
2920	/* Do not care for enabled / disabled stages, just assign the settings. colorop disables / enables required stuff */
2921	if (mapped_stage != WINED3D_UNMAPPED_STAGE)
2922	{
2923	if (tex_used && mapped_stage >= GL_LIMITS(textures)) {
2924	FIXME("Attempt to enable unsupported stage!\n");
2925	return;
2926	}
2927	GL_EXTCALL(glActiveTextureARB(GL_TEXTURE0_ARB + mapped_stage));
2928	checkGLcall("glActiveTextureARB");
2929	}
2930
2931	op = stateblock->textureState[stage][WINED3DTSS_ALPHAOP];
2932	arg1 = stateblock->textureState[stage][WINED3DTSS_ALPHAARG1];
2933	arg2 = stateblock->textureState[stage][WINED3DTSS_ALPHAARG2];
2934	arg0 = stateblock->textureState[stage][WINED3DTSS_ALPHAARG0];
2935
2936	if (stateblock->renderState[WINED3DRS_COLORKEYENABLE] && stage == 0 && stateblock->textures[0])
2937	{
2938	UINT texture_dimensions = IWineD3DBaseTexture_GetTextureDimensions(stateblock->textures[0]);
2939
2940	if (texture_dimensions == GL_TEXTURE_2D \|\| texture_dimensions == GL_TEXTURE_RECTANGLE_ARB)
2941	{
2942	IWineD3DSurfaceImpl *surf;
2943
2944	surf = (IWineD3DSurfaceImpl ) ((IWineD3DTextureImpl ) stateblock->textures[0])->surfaces[0];
2945
2946	if (surf->CKeyFlags & WINEDDSD_CKSRCBLT && !surf->resource.format_desc->alpha_mask)
2947	{
2948	/* Color keying needs to pass alpha values from the texture through to have the alpha test work
2949	* properly. On the other hand applications can still use texture combiners apparently. This code
2950	* takes care that apps cannot remove the texture's alpha channel entirely.
2951	*
2952	* The fixup is required for Prince of Persia 3D(prison bars), while Moto racer 2 requires
2953	* D3DTOP_MODULATE to work on color keyed surfaces. Aliens vs Predator 1 uses color keyed textures
2954	* and alpha component of diffuse color to draw things like translucent text and perform other
2955	* blending effects.
2956	*
2957	* Aliens vs Predator 1 relies on diffuse alpha having an effect, so it cannot be ignored. To
2958	* provide the behavior expected by the game, while emulating the colorkey, diffuse alpha must be
2959	* modulated with texture alpha. OTOH, Moto racer 2 at some points sets alphaop/alphaarg to
2960	* SELECTARG/CURRENT, yet puts garbage in diffuse alpha (zeroes). This works on native, because the
2961	* game disables alpha test and alpha blending. Alpha test is overwritten by wine's for purposes of
2962	* color-keying though, so this will lead to missing geometry if texture alpha is modulated (pixels
2963	* fail alpha test). To get around this, ALPHABLENDENABLE state is checked: if the app enables alpha
2964	* blending, it can be expected to provide meaningful values in diffuse alpha, so it should be
2965	* modulated with texture alpha; otherwise, selecting diffuse alpha is ignored in favour of texture
2966	* alpha.
2967	*
2968	* What to do with multitexturing? So far no app has been found that uses color keying with
2969	* multitexturing */
2970	if (op == WINED3DTOP_DISABLE)
2971	{
2972	arg1 = WINED3DTA_TEXTURE;
2973	op = WINED3DTOP_SELECTARG1;
2974	}
2975	else if(op == WINED3DTOP_SELECTARG1 && arg1 != WINED3DTA_TEXTURE)
2976	{
2977	if (stateblock->renderState[WINED3DRS_ALPHABLENDENABLE])
2978	{
2979	arg2 = WINED3DTA_TEXTURE;
2980	op = WINED3DTOP_MODULATE;
2981	}
2982	else arg1 = WINED3DTA_TEXTURE;
2983	}
2984	else if(op == WINED3DTOP_SELECTARG2 && arg2 != WINED3DTA_TEXTURE)
2985	{
2986	if (stateblock->renderState[WINED3DRS_ALPHABLENDENABLE])
2987	{
2988	arg1 = WINED3DTA_TEXTURE;
2989	op = WINED3DTOP_MODULATE;
2990	}
2991	else arg2 = WINED3DTA_TEXTURE;
2992	}
2993	}
2994	}
2995	}
2996
2997	/* tex_alphaop is shared between the ffp and nvrc because the difference only comes down to
2998	* this if block here, and the other code(color keying, texture unit selection) are the same
2999	*/
3000	TRACE("Setting alpha op for stage %d\n", stage);
3001	if (GL_SUPPORT(NV_REGISTER_COMBINERS)) {
3002	set_tex_op_nvrc((IWineD3DDevice *)stateblock->wineD3DDevice, TRUE, stage,
3003	op, arg1, arg2, arg0,
3004	mapped_stage,
3005	stateblock->textureState[stage][WINED3DTSS_RESULTARG]);
3006	} else {
3007	set_tex_op((IWineD3DDevice *)stateblock->wineD3DDevice, TRUE, stage,
3008	op, arg1, arg2, arg0);
3009	}
3010	}
3011
3012	static void transform_texture(DWORD state, IWineD3DStateBlockImpl stateblock, WineD3DContext context) {
3013	DWORD texUnit = (state - STATE_TEXTURESTAGE(0, 0)) / (WINED3D_HIGHEST_TEXTURE_STATE + 1);
3014	DWORD mapped_stage = stateblock->wineD3DDevice->texUnitMap[texUnit];
3015	BOOL generated;
3016	int coordIdx;
3017
3018	/* Ignore this when a vertex shader is used, or if the streams aren't sorted out yet */
3019	if (use_vs(stateblock) \|\| isStateDirty(context, STATE_VDECL))
3020	{
3021	TRACE("Using a vertex shader, or stream sources not sorted out yet, skipping\n");
3022	return;
3023	}
3024
3025	if (mapped_stage == WINED3D_UNMAPPED_STAGE) return;
3026
3027	if(mapped_stage >= GL_LIMITS(textures)) {
3028	return;
3029	}
3030	GL_EXTCALL(glActiveTextureARB(GL_TEXTURE0_ARB + mapped_stage));
3031	checkGLcall("glActiveTextureARB");
3032	generated = (stateblock->textureState[texUnit][WINED3DTSS_TEXCOORDINDEX] & 0xFFFF0000) != WINED3DTSS_TCI_PASSTHRU;
3033	coordIdx = min(stateblock->textureState[texUnit][WINED3DTSS_TEXCOORDINDEX & 0x0000FFFF], MAX_TEXTURES - 1);
3034
3035	set_texture_matrix(&stateblock->transforms[WINED3DTS_TEXTURE0 + texUnit].u.m[0][0],
3036	stateblock->textureState[texUnit][WINED3DTSS_TEXTURETRANSFORMFLAGS], generated, context->last_was_rhw,
3037	stateblock->wineD3DDevice->strided_streams.elements[WINED3D_FFP_TEXCOORD0 + coordIdx].stride
3038	? stateblock->wineD3DDevice->strided_streams.elements[WINED3D_FFP_TEXCOORD0 + coordIdx].format_desc->format
3039	: WINED3DFMT_UNKNOWN,
3040	stateblock->wineD3DDevice->frag_pipe->ffp_proj_control);
3041
3042	/* The sampler applying function calls us if this changes */
3043	if ((context->lastWasPow2Texture & (1 << texUnit)) && stateblock->textures[texUnit])
3044	{
3045	if(generated) {
3046	FIXME("Non-power2 texture being used with generated texture coords\n");
3047	}
3048	/* NP2 texcoord fixup is implemented for pixelshaders (currently only in GLSL backend) so
3049	only enable the fixed-function-pipeline fixup via pow2Matrix when no PS is used. */
3050	if (!use_ps(stateblock)) {
3051	TRACE("Non power two matrix multiply fixup\n");
3052	glMultMatrixf(((IWineD3DTextureImpl *) stateblock->textures[texUnit])->baseTexture.pow2Matrix);
3053	}
3054	}
3055	}
3056
3057	static void unloadTexCoords(IWineD3DStateBlockImpl *stateblock) {
3058	unsigned int texture_idx;
3059
3060	for (texture_idx = 0; texture_idx < GL_LIMITS(texture_stages); ++texture_idx) {
3061	GL_EXTCALL(glClientActiveTextureARB(GL_TEXTURE0_ARB + texture_idx));
3062	glDisableClientState(GL_TEXTURE_COORD_ARRAY);
3063	}
3064	}
3065
3066	static void loadTexCoords(IWineD3DStateBlockImpl stateblock, const struct wined3d_stream_info si, GLuint *curVBO)
3067	{
3068	const UINT *offset = stateblock->streamOffset;
3069	unsigned int mapped_stage = 0;
3070	unsigned int textureNo = 0;
3071
3072	for (textureNo = 0; textureNo < GL_LIMITS(texture_stages); ++textureNo) {
3073	int coordIdx = stateblock->textureState[textureNo][WINED3DTSS_TEXCOORDINDEX];
3074	const struct wined3d_stream_info_element *e;
3075
3076	mapped_stage = stateblock->wineD3DDevice->texUnitMap[textureNo];
3077	if (mapped_stage == WINED3D_UNMAPPED_STAGE) continue;
3078
3079	e = &si->elements[WINED3D_FFP_TEXCOORD0 + coordIdx];
3080	if (coordIdx < MAX_TEXTURES && (e->data \|\| e->buffer_object))
3081	{
3082	TRACE("Setting up texture %u, idx %d, cordindx %u, data %p\n",
3083	textureNo, mapped_stage, coordIdx, e->data);
3084
3085	if (*curVBO != e->buffer_object)
3086	{
3087	GL_EXTCALL(glBindBufferARB(GL_ARRAY_BUFFER_ARB, e->buffer_object));
3088	checkGLcall("glBindBufferARB");
3089	*curVBO = e->buffer_object;
3090	}
3091
3092	GL_EXTCALL(glClientActiveTextureARB(GL_TEXTURE0_ARB + mapped_stage));
3093	checkGLcall("glClientActiveTextureARB");
3094
3095	/* The coords to supply depend completely on the fvf / vertex shader */
3096	glTexCoordPointer(e->format_desc->gl_vtx_format, e->format_desc->gl_vtx_type, e->stride,
3097	e->data + stateblock->loadBaseVertexIndex * e->stride + offset[e->stream_idx]);
3098	glEnableClientState(GL_TEXTURE_COORD_ARRAY);
3099	} else {
3100	GL_EXTCALL(glMultiTexCoord4fARB(GL_TEXTURE0_ARB + mapped_stage, 0, 0, 0, 1));
3101	}
3102	}
3103	if (GL_SUPPORT(NV_REGISTER_COMBINERS)) {
3104	/* The number of the mapped stages increases monotonically, so it's fine to use the last used one */
3105	for (textureNo = mapped_stage + 1; textureNo < GL_LIMITS(textures); ++textureNo) {
3106	GL_EXTCALL(glMultiTexCoord4fARB(GL_TEXTURE0_ARB + textureNo, 0, 0, 0, 1));
3107	}
3108	}
3109
3110	checkGLcall("loadTexCoords");
3111	}
3112
3113	static void tex_coordindex(DWORD state, IWineD3DStateBlockImpl stateblock, WineD3DContext context) {
3114	DWORD stage = (state - STATE_TEXTURESTAGE(0, 0)) / (WINED3D_HIGHEST_TEXTURE_STATE + 1);
3115	DWORD mapped_stage = stateblock->wineD3DDevice->texUnitMap[stage];
3116	static const GLfloat s_plane[] = { 1.0, 0.0, 0.0, 0.0 };
3117	static const GLfloat t_plane[] = { 0.0, 1.0, 0.0, 0.0 };
3118	static const GLfloat r_plane[] = { 0.0, 0.0, 1.0, 0.0 };
3119	static const GLfloat q_plane[] = { 0.0, 0.0, 0.0, 1.0 };
3120
3121	if (mapped_stage == WINED3D_UNMAPPED_STAGE)
3122	{
3123	TRACE("No texture unit mapped to stage %d. Skipping texture coordinates.\n", stage);
3124	return;
3125	}
3126
3127	if(mapped_stage >= GL_LIMITS(fragment_samplers)) {
3128	WARN("stage %u not mapped to a valid texture unit (%u)\n", stage, mapped_stage);
3129	return;
3130	}
3131	GL_EXTCALL(glActiveTextureARB(GL_TEXTURE0_ARB + mapped_stage));
3132	checkGLcall("glActiveTextureARB");
3133
3134	/* Values 0-7 are indexes into the FVF tex coords - See comments in DrawPrimitive
3135	*
3136	* FIXME: When using generated texture coordinates, the index value is used to specify the wrapping mode.
3137	* eg. SetTextureStageState( 0, WINED3DTSS_TEXCOORDINDEX, WINED3DTSS_TCI_CAMERASPACEPOSITION \| 1 );
3138	* means use the vertex position (camera-space) as the input texture coordinates
3139	* for this texture stage, and the wrap mode set in the WINED3DRS_WRAP1 render
3140	* state. We do not (yet) support the WINED3DRENDERSTATE_WRAPx values, nor tie them up
3141	* to the TEXCOORDINDEX value
3142	*/
3143	switch (stateblock->textureState[stage][WINED3DTSS_TEXCOORDINDEX] & 0xffff0000)
3144	{
3145	case WINED3DTSS_TCI_PASSTHRU:
3146	/* Use the specified texture coordinates contained within the
3147	* vertex format. This value resolves to zero. */
3148	glDisable(GL_TEXTURE_GEN_S);
3149	glDisable(GL_TEXTURE_GEN_T);
3150	glDisable(GL_TEXTURE_GEN_R);
3151	glDisable(GL_TEXTURE_GEN_Q);
3152	checkGLcall("WINED3DTSS_TCI_PASSTHRU - Disable texgen.");
3153	break;
3154
3155	case WINED3DTSS_TCI_CAMERASPACEPOSITION:
3156	/* CameraSpacePosition means use the vertex position, transformed to camera space,
3157	* as the input texture coordinates for this stage's texture transformation. This
3158	* equates roughly to EYE_LINEAR */
3159
3160	glMatrixMode(GL_MODELVIEW);
3161	glPushMatrix();
3162	glLoadIdentity();
3163	glTexGenfv(GL_S, GL_EYE_PLANE, s_plane);
3164	glTexGenfv(GL_T, GL_EYE_PLANE, t_plane);
3165	glTexGenfv(GL_R, GL_EYE_PLANE, r_plane);
3166	glTexGenfv(GL_Q, GL_EYE_PLANE, q_plane);
3167	glPopMatrix();
3168	checkGLcall("WINED3DTSS_TCI_CAMERASPACEPOSITION - Set eye plane.");
3169
3170	glTexGeni(GL_S, GL_TEXTURE_GEN_MODE, GL_EYE_LINEAR);
3171	glTexGeni(GL_T, GL_TEXTURE_GEN_MODE, GL_EYE_LINEAR);
3172	glTexGeni(GL_R, GL_TEXTURE_GEN_MODE, GL_EYE_LINEAR);
3173	checkGLcall("WINED3DTSS_TCI_CAMERASPACEPOSITION - Set texgen mode.");
3174
3175	glEnable(GL_TEXTURE_GEN_S);
3176	glEnable(GL_TEXTURE_GEN_T);
3177	glEnable(GL_TEXTURE_GEN_R);
3178	checkGLcall("WINED3DTSS_TCI_CAMERASPACEPOSITION - Enable texgen.");
3179
3180	break;
3181
3182	case WINED3DTSS_TCI_CAMERASPACENORMAL:
3183	/* Note that NV_TEXGEN_REFLECTION support is implied when
3184	* ARB_TEXTURE_CUBE_MAP is supported */
3185	if (!GL_SUPPORT(NV_TEXGEN_REFLECTION))
3186	{
3187	FIXME("WINED3DTSS_TCI_CAMERASPACENORMAL not supported.\n");
3188	break;
3189	}
3190
3191	glMatrixMode(GL_MODELVIEW);
3192	glPushMatrix();
3193	glLoadIdentity();
3194	glTexGenfv(GL_S, GL_EYE_PLANE, s_plane);
3195	glTexGenfv(GL_T, GL_EYE_PLANE, t_plane);
3196	glTexGenfv(GL_R, GL_EYE_PLANE, r_plane);
3197	glTexGenfv(GL_Q, GL_EYE_PLANE, q_plane);
3198	glPopMatrix();
3199	checkGLcall("WINED3DTSS_TCI_CAMERASPACENORMAL - Set eye plane.");
3200
3201	glTexGeni(GL_S, GL_TEXTURE_GEN_MODE, GL_NORMAL_MAP_NV);
3202	glTexGeni(GL_T, GL_TEXTURE_GEN_MODE, GL_NORMAL_MAP_NV);
3203	glTexGeni(GL_R, GL_TEXTURE_GEN_MODE, GL_NORMAL_MAP_NV);
3204	checkGLcall("WINED3DTSS_TCI_CAMERASPACENORMAL - Set texgen mode.");
3205
3206	glEnable(GL_TEXTURE_GEN_S);
3207	glEnable(GL_TEXTURE_GEN_T);
3208	glEnable(GL_TEXTURE_GEN_R);
3209	checkGLcall("WINED3DTSS_TCI_CAMERASPACENORMAL - Enable texgen.");
3210
3211	break;
3212
3213	case WINED3DTSS_TCI_CAMERASPACEREFLECTIONVECTOR:
3214	/* Note that NV_TEXGEN_REFLECTION support is implied when
3215	* ARB_TEXTURE_CUBE_MAP is supported */
3216	if (!GL_SUPPORT(NV_TEXGEN_REFLECTION))
3217	{
3218	FIXME("WINED3DTSS_TCI_CAMERASPACEREFLECTIONVECTOR not supported.\n");
3219	break;
3220	}
3221
3222	glMatrixMode(GL_MODELVIEW);
3223	glPushMatrix();
3224	glLoadIdentity();
3225	glTexGenfv(GL_S, GL_EYE_PLANE, s_plane);
3226	glTexGenfv(GL_T, GL_EYE_PLANE, t_plane);
3227	glTexGenfv(GL_R, GL_EYE_PLANE, r_plane);
3228	glTexGenfv(GL_Q, GL_EYE_PLANE, q_plane);
3229	glPopMatrix();
3230	checkGLcall("WINED3DTSS_TCI_CAMERASPACEREFLECTIONVECTOR - Set eye plane.");
3231
3232	glTexGeni(GL_S, GL_TEXTURE_GEN_MODE, GL_REFLECTION_MAP_NV);
3233	glTexGeni(GL_T, GL_TEXTURE_GEN_MODE, GL_REFLECTION_MAP_NV);
3234	glTexGeni(GL_R, GL_TEXTURE_GEN_MODE, GL_REFLECTION_MAP_NV);
3235	checkGLcall("WINED3DTSS_TCI_CAMERASPACEREFLECTIONVECTOR - Set texgen mode.");
3236
3237	glEnable(GL_TEXTURE_GEN_S);
3238	glEnable(GL_TEXTURE_GEN_T);
3239	glEnable(GL_TEXTURE_GEN_R);
3240	checkGLcall("WINED3DTSS_TCI_CAMERASPACEREFLECTIONVECTOR - Enable texgen.");
3241
3242	break;
3243
3244	case WINED3DTSS_TCI_SPHEREMAP:
3245	glTexGeni(GL_S, GL_TEXTURE_GEN_MODE, GL_SPHERE_MAP);
3246	glTexGeni(GL_T, GL_TEXTURE_GEN_MODE, GL_SPHERE_MAP);
3247	checkGLcall("WINED3DTSS_TCI_SPHEREMAP - Set texgen mode.");
3248
3249	glEnable(GL_TEXTURE_GEN_S);
3250	glEnable(GL_TEXTURE_GEN_T);
3251	glDisable(GL_TEXTURE_GEN_R);
3252	checkGLcall("WINED3DTSS_TCI_SPHEREMAP - Enable texgen.");
3253
3254	break;
3255
3256	default:
3257	FIXME("Unhandled WINED3DTSS_TEXCOORDINDEX %#x\n",
3258	stateblock->textureState[stage][WINED3DTSS_TEXCOORDINDEX]);
3259	glDisable(GL_TEXTURE_GEN_S);
3260	glDisable(GL_TEXTURE_GEN_T);
3261	glDisable(GL_TEXTURE_GEN_R);
3262	glDisable(GL_TEXTURE_GEN_Q);
3263	checkGLcall("Disable texgen.");
3264
3265	break;
3266	}
3267
3268	/* Update the texture matrix */
3269	if(!isStateDirty(context, STATE_TRANSFORM(WINED3DTS_TEXTURE0 + stage))) {
3270	transform_texture(STATE_TEXTURESTAGE(stage, WINED3DTSS_TEXTURETRANSFORMFLAGS), stateblock, context);
3271	}
3272
3273	if(!isStateDirty(context, STATE_VDECL) && context->namedArraysLoaded) {
3274	/* Reload the arrays if we are using fixed function arrays to reflect the selected coord input
3275	* source. Call loadTexCoords directly because there is no need to reparse the vertex declaration
3276	* and do all the things linked to it
3277	* TODO: Tidy that up to reload only the arrays of the changed unit
3278	*/
3279	GLuint curVBO = GL_SUPPORT(ARB_VERTEX_BUFFER_OBJECT) ? ~0U : 0;
3280
3281	unloadTexCoords(stateblock);
3282	loadTexCoords(stateblock, &stateblock->wineD3DDevice->strided_streams, &curVBO);
3283	}
3284	}
3285
3286	static void shaderconstant(DWORD state, IWineD3DStateBlockImpl stateblock, WineD3DContext context) {
3287	IWineD3DDeviceImpl *device = stateblock->wineD3DDevice;
3288
3289	/* Vertex and pixel shader states will call a shader upload, don't do anything as long one of them
3290	* has an update pending
3291	*/
3292	if(isStateDirty(context, STATE_VDECL) \|\|
3293	isStateDirty(context, STATE_PIXELSHADER)) {
3294	return;
3295	}
3296
3297	device->shader_backend->shader_load_constants((IWineD3DDevice *)device, use_ps(stateblock), use_vs(stateblock));
3298	}
3299
3300	static void tex_bumpenvlscale(DWORD state, IWineD3DStateBlockImpl stateblock, WineD3DContext context) {
3301	DWORD stage = (state - STATE_TEXTURESTAGE(0, 0)) / (WINED3D_HIGHEST_TEXTURE_STATE + 1);
3302
3303	if(stateblock->pixelShader && stage != 0 &&
3304	((IWineD3DPixelShaderImpl *) stateblock->pixelShader)->baseShader.reg_maps.luminanceparams[stage]) {
3305	/* The pixel shader has to know the luminance scale. Do a constants update if it
3306	* isn't scheduled anyway
3307	*/
3308	if(!isStateDirty(context, STATE_PIXELSHADERCONSTANT) &&
3309	!isStateDirty(context, STATE_PIXELSHADER)) {
3310	shaderconstant(STATE_PIXELSHADERCONSTANT, stateblock, context);
3311	}
3312	}
3313	}
3314
3315	static void sampler_texmatrix(DWORD state, IWineD3DStateBlockImpl stateblock, WineD3DContext context) {
3316	const DWORD sampler = state - STATE_SAMPLER(0);
3317	IWineD3DBaseTexture *texture = stateblock->textures[sampler];
3318
3319	TRACE("state %#x, stateblock %p, context %p\n", state, stateblock, context);
3320
3321	if(!texture) return;
3322	/* The fixed function np2 texture emulation uses the texture matrix to fix up the coordinates
3323	* basetexture_apply_state_changes() multiplies the set matrix with a fixup matrix. Before the
3324	* scaling is reapplied or removed, the texture matrix has to be reapplied
3325	*
3326	* The mapped stage is already active because the sampler() function below, which is part of the
3327	* misc pipeline
3328	*/
3329	if(sampler < MAX_TEXTURES) {
3330	const BOOL texIsPow2 = !((IWineD3DBaseTextureImpl *)texture)->baseTexture.pow2Matrix_identity;
3331
3332	if (texIsPow2 \|\| (context->lastWasPow2Texture & (1 << sampler)))
3333	{
3334	if (texIsPow2) context->lastWasPow2Texture \|= 1 << sampler;
3335	else context->lastWasPow2Texture &= ~(1 << sampler);
3336	transform_texture(STATE_TEXTURESTAGE(stateblock->wineD3DDevice->texUnitMap[sampler], WINED3DTSS_TEXTURETRANSFORMFLAGS), stateblock, context);
3337	}
3338	}
3339	}
3340
3341	static void sampler(DWORD state, IWineD3DStateBlockImpl stateblock, WineD3DContext context) {
3342	DWORD sampler = state - STATE_SAMPLER(0);
3343	DWORD mapped_stage = stateblock->wineD3DDevice->texUnitMap[sampler];
3344	union {
3345	float f;
3346	DWORD d;
3347	} tmpvalue;
3348
3349	TRACE("Sampler: %d\n", sampler);
3350	/* Enabling and disabling texture dimensions is done by texture stage state / pixel shader setup, this function
3351	* only has to bind textures and set the per texture states
3352	*/
3353
3354	if (mapped_stage == WINED3D_UNMAPPED_STAGE)
3355	{
3356	TRACE("No sampler mapped to stage %d. Returning.\n", sampler);
3357	return;
3358	}
3359
3360	if (mapped_stage >= GL_LIMITS(combined_samplers)) {
3361	return;
3362	}
3363	GL_EXTCALL(glActiveTextureARB(GL_TEXTURE0_ARB + mapped_stage));
3364	checkGLcall("glActiveTextureARB");
3365
3366	if(stateblock->textures[sampler]) {
3367	BOOL srgb = stateblock->samplerState[sampler][WINED3DSAMP_SRGBTEXTURE];
3368	IWineD3DBaseTextureImpl tex_impl = (IWineD3DBaseTextureImpl ) stateblock->textures[sampler];
3369	tex_impl->baseTexture.internal_preload(stateblock->textures[sampler], srgb ? SRGB_SRGB : SRGB_RGB);
3370	IWineD3DBaseTexture_BindTexture(stateblock->textures[sampler], srgb);
3371	basetexture_apply_state_changes(stateblock->textures[sampler],
3372	stateblock->textureState[sampler], stateblock->samplerState[sampler]);
3373
3374	if (GL_SUPPORT(EXT_TEXTURE_LOD_BIAS)) {
3375	tmpvalue.d = stateblock->samplerState[sampler][WINED3DSAMP_MIPMAPLODBIAS];
3376	glTexEnvf(GL_TEXTURE_FILTER_CONTROL_EXT,
3377	GL_TEXTURE_LOD_BIAS_EXT,
3378	tmpvalue.f);
3379	checkGLcall("glTexEnvi(GL_TEXTURE_LOD_BIAS_EXT, ...)");
3380	}
3381
3382	if (!use_ps(stateblock) && sampler < stateblock->lowest_disabled_stage)
3383	{
3384	if(stateblock->renderState[WINED3DRS_COLORKEYENABLE] && sampler == 0) {
3385	/* If color keying is enabled update the alpha test, it depends on the existence
3386	* of a color key in stage 0
3387	*/
3388	state_alpha(WINED3DRS_COLORKEYENABLE, stateblock, context);
3389	}
3390	}
3391
3392	/* Trigger shader constant reloading (for NP2 texcoord fixup)
3393	* Only do this if pshaders are used (note: fixup is currently only implemented in GLSL). */
3394	if (!tex_impl->baseTexture.pow2Matrix_identity) {
3395	IWineD3DDeviceImpl* d3ddevice = stateblock->wineD3DDevice;
3396	d3ddevice->shader_backend->shader_load_np2fixup_constants(
3397	(IWineD3DDevice*)d3ddevice, use_ps(stateblock), use_vs(stateblock));
3398	}
3399	} else if(mapped_stage < GL_LIMITS(textures)) {
3400	if(sampler < stateblock->lowest_disabled_stage) {
3401	/* TODO: What should I do with pixel shaders here ??? */
3402	if(stateblock->renderState[WINED3DRS_COLORKEYENABLE] && sampler == 0) {
3403	/* If color keying is enabled update the alpha test, it depends on the existence
3404	* of a color key in stage 0
3405	*/
3406	state_alpha(WINED3DRS_COLORKEYENABLE, stateblock, context);
3407	}
3408	} /* Otherwise tex_colorop disables the stage */
3409	glBindTexture(GL_TEXTURE_2D, stateblock->wineD3DDevice->dummyTextureName[sampler]);
3410	checkGLcall("glBindTexture(GL_TEXTURE_2D, stateblock->wineD3DDevice->dummyTextureName[sampler])");
3411	}
3412	}
3413
3414	void apply_pixelshader(DWORD state, IWineD3DStateBlockImpl stateblock, WineD3DContext context) {
3415	IWineD3DDeviceImpl *device = stateblock->wineD3DDevice;
3416	BOOL use_pshader = use_ps(stateblock);
3417	BOOL use_vshader = use_vs(stateblock);
3418	int i;
3419
3420	if (use_pshader) {
3421	if(!context->last_was_pshader) {
3422	/* Former draw without a pixel shader, some samplers
3423	* may be disabled because of WINED3DTSS_COLOROP = WINED3DTOP_DISABLE
3424	* make sure to enable them
3425	*/
3426	for(i=0; i < MAX_FRAGMENT_SAMPLERS; i++) {
3427	if(!isStateDirty(context, STATE_SAMPLER(i))) {
3428	sampler(STATE_SAMPLER(i), stateblock, context);
3429	}
3430	}
3431	context->last_was_pshader = TRUE;
3432	} else {
3433	/* Otherwise all samplers were activated by the code above in earlier draws, or by sampler()
3434	* if a different texture was bound. I don't have to do anything.
3435	*/
3436	}
3437	} else {
3438	/* Disabled the pixel shader - color ops weren't applied
3439	* while it was enabled, so re-apply them.
3440	*/
3441	for(i=0; i < MAX_TEXTURES; i++) {
3442	if(!isStateDirty(context, STATE_TEXTURESTAGE(i, WINED3DTSS_COLOROP))) {
3443	device->StateTable[STATE_TEXTURESTAGE(i, WINED3DTSS_COLOROP)].apply
3444	(STATE_TEXTURESTAGE(i, WINED3DTSS_COLOROP), stateblock, context);
3445	}
3446	}
3447	context->last_was_pshader = FALSE;
3448	}
3449
3450	if(!isStateDirty(context, device->StateTable[STATE_VSHADER].representative)) {
3451	device->shader_backend->shader_select((IWineD3DDevice *)stateblock->wineD3DDevice, use_pshader, use_vshader);
3452
3453	if (!isStateDirty(context, STATE_VERTEXSHADERCONSTANT) && (use_vshader \|\| use_pshader)) {
3454	shaderconstant(STATE_VERTEXSHADERCONSTANT, stateblock, context);
3455	}
3456	}
3457	}
3458
3459	static void shader_bumpenvmat(DWORD state, IWineD3DStateBlockImpl stateblock, WineD3DContext context) {
3460	DWORD stage = (state - STATE_TEXTURESTAGE(0, 0)) / (WINED3D_HIGHEST_TEXTURE_STATE + 1);
3461	if(stateblock->pixelShader && stage != 0 &&
3462	((IWineD3DPixelShaderImpl *) stateblock->pixelShader)->baseShader.reg_maps.bumpmat[stage]) {
3463	/* The pixel shader has to know the bump env matrix. Do a constants update if it isn't scheduled
3464	* anyway
3465	*/
3466	if(!isStateDirty(context, STATE_PIXELSHADERCONSTANT) &&
3467	!isStateDirty(context, STATE_PIXELSHADER)) {
3468	shaderconstant(STATE_PIXELSHADERCONSTANT, stateblock, context);
3469	}
3470	}
3471	}
3472
3473	static void transform_world(DWORD state, IWineD3DStateBlockImpl stateblock, WineD3DContext context) {
3474	/* This function is called by transform_view below if the view matrix was changed too
3475	*
3476	* Deliberately no check if the vertex declaration is dirty because the vdecl state
3477	* does not always update the world matrix, only on a switch between transformed
3478	* and untransformed draws. It may happen that the world matrix is set 2 times during one
3479	* draw, but that should be rather rare and cheaper in total.
3480	*/
3481	glMatrixMode(GL_MODELVIEW);
3482	checkGLcall("glMatrixMode");
3483
3484	if(context->last_was_rhw) {
3485	glLoadIdentity();
3486	checkGLcall("glLoadIdentity()");
3487	} else {
3488	/* In the general case, the view matrix is the identity matrix */
3489	if (stateblock->wineD3DDevice->view_ident) {
3490	glLoadMatrixf(&stateblock->transforms[WINED3DTS_WORLDMATRIX(0)].u.m[0][0]);
3491	checkGLcall("glLoadMatrixf");
3492	} else {
3493	glLoadMatrixf(&stateblock->transforms[WINED3DTS_VIEW].u.m[0][0]);
3494	checkGLcall("glLoadMatrixf");
3495	glMultMatrixf(&stateblock->transforms[WINED3DTS_WORLDMATRIX(0)].u.m[0][0]);
3496	checkGLcall("glMultMatrixf");
3497	}
3498	}
3499	}
3500
3501	static void clipplane(DWORD state, IWineD3DStateBlockImpl stateblock, WineD3DContext context) {
3502	UINT index = state - STATE_CLIPPLANE(0);
3503
3504	if(isStateDirty(context, STATE_TRANSFORM(WINED3DTS_VIEW)) \|\| index >= GL_LIMITS(clipplanes)) {
3505	return;
3506	}
3507
3508	/* Clip Plane settings are affected by the model view in OpenGL, the View transform in direct3d */
3509	if(!use_vs(stateblock)) {
3510	glMatrixMode(GL_MODELVIEW);
3511	glPushMatrix();
3512	glLoadMatrixf(&stateblock->transforms[WINED3DTS_VIEW].u.m[0][0]);
3513	} else {
3514	/* with vertex shaders, clip planes are not transformed in direct3d,
3515	* in OpenGL they are still transformed by the model view.
3516	* Use this to swap the y coordinate if necessary
3517	*/
3518	glMatrixMode(GL_MODELVIEW);
3519	glPushMatrix();
3520	glLoadIdentity();
3521	if(stateblock->wineD3DDevice->render_offscreen) {
3522	glScalef(1.0, -1.0, 1.0);
3523	}
3524	}
3525
3526	TRACE("Clipplane [%f,%f,%f,%f]\n",
3527	stateblock->clipplane[index][0],
3528	stateblock->clipplane[index][1],
3529	stateblock->clipplane[index][2],
3530	stateblock->clipplane[index][3]);
3531	glClipPlane(GL_CLIP_PLANE0 + index, stateblock->clipplane[index]);
3532	checkGLcall("glClipPlane");
3533
3534	glPopMatrix();
3535	}
3536
3537	static void transform_worldex(DWORD state, IWineD3DStateBlockImpl stateblock, WineD3DContext context) {
3538	UINT matrix = state - STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(0));
3539	GLenum glMat;
3540	TRACE("Setting world matrix %d\n", matrix);
3541
3542	if(matrix >= GL_LIMITS(blends)) {
3543	WARN("Unsupported blend matrix set\n");
3544	return;
3545	} else if(isStateDirty(context, STATE_TRANSFORM(WINED3DTS_VIEW))) {
3546	return;
3547	}
3548
3549	/* GL_MODELVIEW0_ARB: 0x1700
3550	* GL_MODELVIEW1_ARB: 0x850a
3551	* GL_MODELVIEW2_ARB: 0x8722
3552	* GL_MODELVIEW3_ARB: 0x8723
3553	* etc
3554	* GL_MODELVIEW31_ARB: 0x873F
3555	*/
3556	if(matrix == 1) glMat = GL_MODELVIEW1_ARB;
3557	else glMat = GL_MODELVIEW2_ARB - 2 + matrix;
3558
3559	glMatrixMode(glMat);
3560	checkGLcall("glMatrixMode(glMat)");
3561
3562	/* World matrix 0 is multiplied with the view matrix because d3d uses 3 matrices while gl uses only 2. To avoid
3563	* weighting the view matrix incorrectly it has to be multiplied into every gl modelview matrix
3564	*/
3565	if(stateblock->wineD3DDevice->view_ident) {
3566	glLoadMatrixf(&stateblock->transforms[WINED3DTS_WORLDMATRIX(matrix)].u.m[0][0]);
3567	checkGLcall("glLoadMatrixf");
3568	} else {
3569	glLoadMatrixf(&stateblock->transforms[WINED3DTS_VIEW].u.m[0][0]);
3570	checkGLcall("glLoadMatrixf");
3571	glMultMatrixf(&stateblock->transforms[WINED3DTS_WORLDMATRIX(matrix)].u.m[0][0]);
3572	checkGLcall("glMultMatrixf");
3573	}
3574	}
3575
3576	static void state_vertexblend_w(DWORD state, IWineD3DStateBlockImpl stateblock, WineD3DContext context) {
3577	static BOOL once = FALSE;
3578
3579	switch(stateblock->renderState[WINED3DRS_VERTEXBLEND]) {
3580	case WINED3DVBF_1WEIGHTS:
3581	case WINED3DVBF_2WEIGHTS:
3582	case WINED3DVBF_3WEIGHTS:
3583	if(!once) {
3584	once = TRUE;
3585	/* TODO: Implement vertex blending in drawStridedSlow */
3586	FIXME("Vertex blending enabled, but not supported by hardware\n");
3587	}
3588	break;
3589
3590	case WINED3DVBF_TWEENING:
3591	WARN("Tweening not supported yet\n");
3592	}
3593	}
3594
3595	static void state_vertexblend(DWORD state, IWineD3DStateBlockImpl stateblock, WineD3DContext context) {
3596	WINED3DVERTEXBLENDFLAGS val = stateblock->renderState[WINED3DRS_VERTEXBLEND];
3597
3598	switch(val) {
3599	case WINED3DVBF_1WEIGHTS:
3600	case WINED3DVBF_2WEIGHTS:
3601	case WINED3DVBF_3WEIGHTS:
3602	glEnable(GL_VERTEX_BLEND_ARB);
3603	checkGLcall("glEnable(GL_VERTEX_BLEND_ARB)");
3604
3605	/* D3D adds one more matrix which has weight (1 - sum(weights)). This is enabled at context
3606	* creation with enabling GL_WEIGHT_SUM_UNITY_ARB.
3607	*/
3608	GL_EXTCALL(glVertexBlendARB(stateblock->renderState[WINED3DRS_VERTEXBLEND] + 1));
3609
3610	if(!stateblock->wineD3DDevice->vertexBlendUsed) {
3611	unsigned int i;
3612	for(i = 1; i < GL_LIMITS(blends); i++) {
3613	if(!isStateDirty(context, STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(i)))) {
3614	transform_worldex(STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(i)), stateblock, context);
3615	}
3616	}
3617	stateblock->wineD3DDevice->vertexBlendUsed = TRUE;
3618	}
3619	break;
3620
3621	case WINED3DVBF_DISABLE:
3622	case WINED3DVBF_0WEIGHTS: /* for Indexed vertex blending - not supported */
3623	glDisable(GL_VERTEX_BLEND_ARB);
3624	checkGLcall("glDisable(GL_VERTEX_BLEND_ARB)");
3625	break;
3626
3627	case WINED3DVBF_TWEENING:
3628	/* Just set the vertex weight for weight 0, enable vertex blending and hope the app doesn't have
3629	* vertex weights in the vertices?
3630	* For now we don't report that as supported, so a warn should suffice
3631	*/
3632	WARN("Tweening not supported yet\n");
3633	break;
3634	}
3635	}
3636
3637	static void transform_view(DWORD state, IWineD3DStateBlockImpl stateblock, WineD3DContext context) {
3638	unsigned int k;
3639
3640	/* If we are changing the View matrix, reset the light and clipping planes to the new view
3641	* NOTE: We have to reset the positions even if the light/plane is not currently
3642	* enabled, since the call to enable it will not reset the position.
3643	* NOTE2: Apparently texture transforms do NOT need reapplying
3644	*/
3645
3646	const PLIGHTINFOEL *light = NULL;
3647
3648	glMatrixMode(GL_MODELVIEW);
3649	checkGLcall("glMatrixMode(GL_MODELVIEW)");
3650	glLoadMatrixf(&stateblock->transforms[WINED3DTS_VIEW].u.m[0][0]);
3651	checkGLcall("glLoadMatrixf(...)");
3652
3653	/* Reset lights. TODO: Call light apply func */
3654	for(k = 0; k < stateblock->wineD3DDevice->maxConcurrentLights; k++) {
3655	light = stateblock->activeLights[k];
3656	if(!light) continue;
3657	glLightfv(GL_LIGHT0 + light->glIndex, GL_POSITION, light->lightPosn);
3658	checkGLcall("glLightfv posn");
3659	glLightfv(GL_LIGHT0 + light->glIndex, GL_SPOT_DIRECTION, light->lightDirn);
3660	checkGLcall("glLightfv dirn");
3661	}
3662
3663	/* Reset Clipping Planes */
3664	for (k = 0; k < GL_LIMITS(clipplanes); k++) {
3665	if(!isStateDirty(context, STATE_CLIPPLANE(k))) {
3666	clipplane(STATE_CLIPPLANE(k), stateblock, context);
3667	}
3668	}
3669
3670	if(context->last_was_rhw) {
3671	glLoadIdentity();
3672	checkGLcall("glLoadIdentity()");
3673	/* No need to update the world matrix, the identity is fine */
3674	return;
3675	}
3676
3677	/* Call the world matrix state, this will apply the combined WORLD + VIEW matrix
3678	* No need to do it here if the state is scheduled for update.
3679	*/
3680	if(!isStateDirty(context, STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(0)))) {
3681	transform_world(STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(0)), stateblock, context);
3682	}
3683
3684	/* Avoid looping over a number of matrices if the app never used the functionality */
3685	if(stateblock->wineD3DDevice->vertexBlendUsed) {
3686	for(k = 1; k < GL_LIMITS(blends); k++) {
3687	if(!isStateDirty(context, STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(k)))) {
3688	transform_worldex(STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(k)), stateblock, context);
3689	}
3690	}
3691	}
3692	}
3693
3694	static void transform_projection(DWORD state, IWineD3DStateBlockImpl stateblock, WineD3DContext context) {
3695	glMatrixMode(GL_PROJECTION);
3696	checkGLcall("glMatrixMode(GL_PROJECTION)");
3697	glLoadIdentity();
3698	checkGLcall("glLoadIdentity");
3699
3700	if(context->last_was_rhw) {
3701	double X, Y, height, width, minZ, maxZ;
3702
3703	X = stateblock->viewport.X;
3704	Y = stateblock->viewport.Y;
3705	height = stateblock->viewport.Height;
3706	width = stateblock->viewport.Width;
3707	minZ = stateblock->viewport.MinZ;
3708	maxZ = stateblock->viewport.MaxZ;
3709
3710	if(!stateblock->wineD3DDevice->untransformed) {
3711	/* Transformed vertices are supposed to bypass the whole transform pipeline including
3712	* frustum clipping. This can't be done in opengl, so this code adjusts the Z range to
3713	* suppress depth clipping. This can be done because it is an orthogonal projection and
3714	* the Z coordinate does not affect the size of the primitives. Half Life 1 and Prince of
3715	* Persia 3D need this.
3716	*
3717	* Note that using minZ and maxZ here doesn't entirely fix the problem, since view frustum
3718	* clipping is still enabled, but it seems to fix it for all apps tested so far. A minor
3719	* problem can be witnessed in half-life 1 engine based games, the weapon is clipped close
3720	* to the viewer.
3721	*
3722	* Also note that this breaks z comparison against z values filled in with clear,
3723	* but no app depending on that and disabled clipping has been found yet. Comparing
3724	* primitives against themselves works, so the Z buffer is still intact for normal hidden
3725	* surface removal.
3726	*
3727	* We could disable clipping entirely by setting the near to infinity and far to -infinity,
3728	* but this would break Z buffer operation. Raising the range to something less than
3729	* infinity would help a bit at the cost of Z precision, but it wouldn't eliminate the
3730	* problem either.
3731	*/
3732	TRACE("Calling glOrtho with %f, %f, %f, %f\n", width, height, -minZ, -maxZ);
3733	if(stateblock->wineD3DDevice->render_offscreen) {
3734	glOrtho(X, X + width, -Y, -Y - height, -minZ, -maxZ);
3735	} else {
3736	glOrtho(X, X + width, Y + height, Y, -minZ, -maxZ);
3737	}
3738	} else {
3739	/* If the app mixes transformed and untransformed primitives we can't use the coordinate system
3740	* trick above because this would mess up transformed and untransformed Z order. Pass the z position
3741	* unmodified to opengl.
3742	*
3743	* If the app depends on mixed types and disabled clipping we're out of luck without a pipeline
3744	* replacement shader.
3745	*/
3746	TRACE("Calling glOrtho with %f, %f, %f, %f\n", width, height, 1.0, -1.0);
3747	if(stateblock->wineD3DDevice->render_offscreen) {
3748	glOrtho(X, X + width, -Y, -Y - height, 0.0, -1.0);
3749	} else {
3750	glOrtho(X, X + width, Y + height, Y, 0.0, -1.0);
3751	}
3752	}
3753	checkGLcall("glOrtho");
3754
3755	/* Window Coord 0 is the middle of the first pixel, so translate by 1/2 pixels */
3756	glTranslatef(0.5, 0.5, 0);
3757	checkGLcall("glTranslatef(0.5, 0.5, 0)");
3758	/* D3D texture coordinates are flipped compared to OpenGL ones, so
3759	* render everything upside down when rendering offscreen. */
3760	if (stateblock->wineD3DDevice->render_offscreen) {
3761	glScalef(1.0, -1.0, 1.0);
3762	checkGLcall("glScalef");
3763	}
3764	} else {
3765	/* The rule is that the window coordinate 0 does not correspond to the
3766	beginning of the first pixel, but the center of the first pixel.
3767	As a consequence if you want to correctly draw one line exactly from
3768	the left to the right end of the viewport (with all matrices set to
3769	be identity), the x coords of both ends of the line would be not
3770	-1 and 1 respectively but (-1-1/viewport_widh) and (1-1/viewport_width)
3771	instead.
3772
3773	1.0 / Width is used because the coord range goes from -1.0 to 1.0, then we
3774	divide by the Width/Height, so we need the half range(1.0) to translate by
3775	half a pixel.
3776
3777	The other fun is that d3d's output z range after the transformation is [0;1],
3778	but opengl's is [-1;1]. Since the z buffer is in range [0;1] for both, gl
3779	scales [-1;1] to [0;1]. This would mean that we end up in [0.5;1] and loose a lot
3780	of Z buffer precision and the clear values do not match in the z test. Thus scale
3781	[0;1] to [-1;1], so when gl undoes that we utilize the full z range
3782	*/
3783
3784	/*
3785	* Careful with the order of operations here, we're essentially working backwards:
3786	* x = x + 1/w;
3787	* y = (y - 1/h) * flip;
3788	* z = z * 2 - 1;
3789	*
3790	* Becomes:
3791	* glTranslatef(0.0, 0.0, -1.0);
3792	* glScalef(1.0, 1.0, 2.0);
3793	*
3794	* glScalef(1.0, flip, 1.0);
3795	* glTranslatef(1/w, -1/h, 0.0);
3796	*
3797	* This is equivalent to:
3798	* glTranslatef(1/w, -flip/h, -1.0)
3799	* glScalef(1.0, flip, 2.0);
3800	*/
3801
3802	if (stateblock->wineD3DDevice->render_offscreen) {
3803	/* D3D texture coordinates are flipped compared to OpenGL ones, so
3804	* render everything upside down when rendering offscreen. */
3805	glTranslatef(1.0 / stateblock->viewport.Width, 1.0 / stateblock->viewport.Height, -1.0);
3806	checkGLcall("glTranslatef(1.0 / width, 1.0 / height, -1.0)");
3807	glScalef(1.0, -1.0, 2.0);
3808	} else {
3809	glTranslatef(1.0 / stateblock->viewport.Width, -1.0 / stateblock->viewport.Height, -1.0);
3810	checkGLcall("glTranslatef(1.0 / width, -1.0 / height, -1.0)");
3811	glScalef(1.0, 1.0, 2.0);
3812	}
3813	checkGLcall("glScalef");
3814
3815	glMultMatrixf(&stateblock->transforms[WINED3DTS_PROJECTION].u.m[0][0]);
3816	checkGLcall("glLoadMatrixf");
3817	}
3818	}
3819
3820	/* This should match any arrays loaded in loadVertexData.
3821	* stateblock impl is required for GL_SUPPORT
3822	* TODO: Only load / unload arrays if we have to.
3823	*/
3824	static inline void unloadVertexData(IWineD3DStateBlockImpl *stateblock) {
3825	glDisableClientState(GL_VERTEX_ARRAY);
3826	glDisableClientState(GL_NORMAL_ARRAY);
3827	glDisableClientState(GL_COLOR_ARRAY);
3828	if (GL_SUPPORT(EXT_SECONDARY_COLOR)) {
3829	glDisableClientState(GL_SECONDARY_COLOR_ARRAY_EXT);
3830	}
3831	if (GL_SUPPORT(ARB_VERTEX_BLEND)) {
3832	glDisableClientState(GL_WEIGHT_ARRAY_ARB);
3833	}
3834	unloadTexCoords(stateblock);
3835	}
3836
3837	static inline void unload_numbered_array(IWineD3DStateBlockImpl stateblock, WineD3DContext context, int i)
3838	{
3839	GL_EXTCALL(glDisableVertexAttribArrayARB(i));
3840	checkGLcall("glDisableVertexAttribArrayARB(reg)");
3841	/* Some Windows drivers(NV GF 7) use the latest value that was used when drawing with the now
3842	* deactivated stream disabled, some other drivers(ATI, NV GF 8) set the undefined values to 0x00.
3843	* Let's set them to 0x00 to avoid hitting some undefined aspects of OpenGL. All that is really
3844	* important here is the glDisableVertexAttribArrayARB call above. The test shows that the refrast
3845	* keeps dereferencing the pointers, which would cause crashes in some games like Half Life 2: Episode Two.
3846	*/
3847	GL_EXTCALL(glVertexAttrib4NubARB(i, 0, 0, 0, 0));
3848	checkGLcall("glVertexAttrib4NubARB(i, 0, 0, 0, 0)");
3849
3850	context->numbered_array_mask &= ~(1 << i);
3851	}
3852
3853	/* This should match any arrays loaded in loadNumberedArrays
3854	* TODO: Only load / unload arrays if we have to.
3855	*/
3856	static inline void unloadNumberedArrays(IWineD3DStateBlockImpl stateblock, WineD3DContext context)
3857	{
3858	/* disable any attribs (this is the same for both GLSL and ARB modes) */
3859	GLint maxAttribs = 16;
3860	int i;
3861
3862	/* Leave all the attribs disabled */
3863	glGetIntegerv(GL_MAX_VERTEX_ATTRIBS_ARB, &maxAttribs);
3864	/* MESA does not support it right not */
3865	if (glGetError() != GL_NO_ERROR)
3866	maxAttribs = 16;
3867	for (i = 0; i < maxAttribs; ++i) {
3868	unload_numbered_array(stateblock, context, i);
3869	}
3870	}
3871
3872	static inline void loadNumberedArrays(IWineD3DStateBlockImpl *stateblock,
3873	const struct wined3d_stream_info stream_info, WineD3DContext context)
3874	{
3875	GLuint curVBO = GL_SUPPORT(ARB_VERTEX_BUFFER_OBJECT) ? ~0U : 0;
3876	int i;
3877	const UINT *offset = stateblock->streamOffset;
3878	struct wined3d_buffer *vb;
3879	DWORD_PTR shift_index;
3880
3881	/* Default to no instancing */
3882	stateblock->wineD3DDevice->instancedDraw = FALSE;
3883
3884	for (i = 0; i < MAX_ATTRIBS; i++) {
3885	if (!(stream_info->use_map & (1 << i)))
3886	{
3887	if (context->numbered_array_mask & (1 << i)) unload_numbered_array(stateblock, context, i);
3888	continue;
3889	}
3890
3891	/* Do not load instance data. It will be specified using glTexCoord by drawprim */
3892	if (stateblock->streamFlags[stream_info->elements[i].stream_idx] & WINED3DSTREAMSOURCE_INSTANCEDATA)
3893	{
3894	if (context->numbered_array_mask & (1 << i)) unload_numbered_array(stateblock, context, i);
3895	stateblock->wineD3DDevice->instancedDraw = TRUE;
3896	continue;
3897	}
3898
3899	TRACE_(d3d_shader)("Loading array %u [VBO=%u]\n", i, stream_info->elements[i].buffer_object);
3900
3901	if (stream_info->elements[i].stride)
3902	{
3903	if (curVBO != stream_info->elements[i].buffer_object)
3904	{
3905	GL_EXTCALL(glBindBufferARB(GL_ARRAY_BUFFER_ARB, stream_info->elements[i].buffer_object));
3906	checkGLcall("glBindBufferARB");
3907	curVBO = stream_info->elements[i].buffer_object;
3908	}
3909	vb = (struct wined3d_buffer *)stateblock->streamSource[stream_info->elements[i].stream_idx];
3910	/* Use the VBO to find out if a vertex buffer exists, not the vb pointer. vb can point to a
3911	* user pointer data blob. In that case curVBO will be 0. If there is a vertex buffer but no
3912	* vbo we won't be load converted attributes anyway
3913	*/
3914	if (curVBO && vb->conversion_shift)
3915	{
3916	TRACE("Loading attribute from shifted buffer\n");
3917	TRACE("Attrib %d has original stride %d, new stride %d\n",
3918	i, stream_info->elements[i].stride, vb->conversion_stride);
3919	TRACE("Original offset %p, additional offset 0x%08x\n",
3920	stream_info->elements[i].data, vb->conversion_shift[(DWORD_PTR)stream_info->elements[i].data]);
3921	TRACE("Opengl type %#x\n", stream_info->elements[i].format_desc->gl_vtx_type);
3922	shift_index = ((DWORD_PTR)stream_info->elements[i].data + offset[stream_info->elements[i].stream_idx]);
3923	shift_index = shift_index % stream_info->elements[i].stride;
3924	GL_EXTCALL(glVertexAttribPointerARB(i, stream_info->elements[i].format_desc->gl_vtx_format,
3925	stream_info->elements[i].format_desc->gl_vtx_type,
3926	stream_info->elements[i].format_desc->gl_normalized,
3927	vb->conversion_stride, stream_info->elements[i].data + vb->conversion_shift[shift_index]
3928	+ stateblock->loadBaseVertexIndex * stream_info->elements[i].stride
3929	+ offset[stream_info->elements[i].stream_idx]));
3930
3931	} else {
3932	GL_EXTCALL(glVertexAttribPointerARB(i, stream_info->elements[i].format_desc->gl_vtx_format,
3933	stream_info->elements[i].format_desc->gl_vtx_type,
3934	stream_info->elements[i].format_desc->gl_normalized,
3935	stream_info->elements[i].stride, stream_info->elements[i].data
3936	+ stateblock->loadBaseVertexIndex * stream_info->elements[i].stride
3937	+ offset[stream_info->elements[i].stream_idx]));
3938	}
3939
3940	if (!(context->numbered_array_mask & (1 << i)))
3941	{
3942	GL_EXTCALL(glEnableVertexAttribArrayARB(i));
3943	context->numbered_array_mask \|= (1 << i);
3944	}
3945	} else {
3946	/* Stride = 0 means always the same values. glVertexAttribPointerARB doesn't do that. Instead disable the pointer and
3947	* set up the attribute statically. But we have to figure out the system memory address.
3948	*/
3949	const BYTE *ptr = stream_info->elements[i].data + offset[stream_info->elements[i].stream_idx];
3950	if (stream_info->elements[i].buffer_object)
3951	{
3952	vb = (struct wined3d_buffer *)stateblock->streamSource[stream_info->elements[i].stream_idx];
3953	ptr += (long) buffer_get_sysmem(vb);
3954	}
3955
3956	if (context->numbered_array_mask & (1 << i)) unload_numbered_array(stateblock, context, i);
3957
3958	switch (stream_info->elements[i].format_desc->format)
3959	{
3960	case WINED3DFMT_R32_FLOAT:
3961	GL_EXTCALL(glVertexAttrib1fvARB(i, (const GLfloat *)ptr));
3962	break;
3963	case WINED3DFMT_R32G32_FLOAT:
3964	GL_EXTCALL(glVertexAttrib2fvARB(i, (const GLfloat *)ptr));
3965	break;
3966	case WINED3DFMT_R32G32B32_FLOAT:
3967	GL_EXTCALL(glVertexAttrib3fvARB(i, (const GLfloat *)ptr));
3968	break;
3969	case WINED3DFMT_R32G32B32A32_FLOAT:
3970	GL_EXTCALL(glVertexAttrib4fvARB(i, (const GLfloat *)ptr));
3971	break;
3972
3973	case WINED3DFMT_R8G8B8A8_UINT:
3974	GL_EXTCALL(glVertexAttrib4NubvARB(i, ptr));
3975	break;
3976	case WINED3DFMT_A8R8G8B8:
3977	if (GL_SUPPORT(EXT_VERTEX_ARRAY_BGRA))
3978	{
3979	const DWORD src = (const DWORD )ptr;
3980	DWORD c = *src & 0xff00ff00;
3981	c \|= (*src & 0xff0000) >> 16;
3982	c \|= (*src & 0xff) << 16;
3983	GL_EXTCALL(glVertexAttrib4NubvARB(i, (GLubyte *)&c));
3984	break;
3985	}
3986	/* else fallthrough */
3987	case WINED3DFMT_R8G8B8A8_UNORM:
3988	GL_EXTCALL(glVertexAttrib4NubvARB(i, ptr));
3989	break;
3990
3991	case WINED3DFMT_R16G16_SINT:
3992	GL_EXTCALL(glVertexAttrib4svARB(i, (const GLshort *)ptr));
3993	break;
3994	case WINED3DFMT_R16G16B16A16_SINT:
3995	GL_EXTCALL(glVertexAttrib4svARB(i, (const GLshort *)ptr));
3996	break;
3997
3998	case WINED3DFMT_R16G16_SNORM:
3999	{
4000	const GLshort s[4] = {((const GLshort )ptr)[0], ((const GLshort )ptr)[1], 0, 1};
4001	GL_EXTCALL(glVertexAttrib4NsvARB(i, s));
4002	break;
4003	}
4004	case WINED3DFMT_R16G16_UNORM:
4005	{
4006	const GLushort s[4] = {((const GLushort )ptr)[0], ((const GLushort )ptr)[1], 0, 1};
4007	GL_EXTCALL(glVertexAttrib4NusvARB(i, s));
4008	break;
4009	}
4010	case WINED3DFMT_R16G16B16A16_SNORM:
4011	GL_EXTCALL(glVertexAttrib4NsvARB(i, (const GLshort *)ptr));
4012	break;
4013	case WINED3DFMT_R16G16B16A16_UNORM:
4014	GL_EXTCALL(glVertexAttrib4NusvARB(i, (const GLushort *)ptr));
4015	break;
4016
4017	case WINED3DFMT_R10G10B10A2_UINT:
4018	FIXME("Unsure about WINED3DDECLTYPE_UDEC3\n");
4019	/glVertexAttrib3usvARB(i, (const GLushort )ptr); Does not exist */
4020	break;
4021	case WINED3DFMT_R10G10B10A2_SNORM:
4022	FIXME("Unsure about WINED3DDECLTYPE_DEC3N\n");
4023	/glVertexAttrib3NusvARB(i, (const GLushort )ptr); Does not exist */
4024	break;
4025
4026	case WINED3DFMT_R16G16_FLOAT:
4027	/* Are those 16 bit floats. C doesn't have a 16 bit float type. I could read the single bits and calculate a 4
4028	* byte float according to the IEEE standard
4029	*/
4030	FIXME("Unsupported WINED3DDECLTYPE_FLOAT16_2\n");
4031	break;
4032	case WINED3DFMT_R16G16B16A16_FLOAT:
4033	FIXME("Unsupported WINED3DDECLTYPE_FLOAT16_4\n");
4034	break;
4035
4036	default:
4037	ERR("Unexpected declaration in stride 0 attributes\n");
4038	break;
4039
4040	}
4041	}
4042	}
4043	checkGLcall("Loading numbered arrays");
4044	}
4045
4046	/* Used from 2 different functions, and too big to justify making it inlined */
4047	static void loadVertexData(IWineD3DStateBlockImpl stateblock, const struct wined3d_stream_info si)
4048	{
4049	const UINT *offset = stateblock->streamOffset;
4050	GLuint curVBO = GL_SUPPORT(ARB_VERTEX_BUFFER_OBJECT) ? ~0U : 0;
4051	const struct wined3d_stream_info_element *e;
4052
4053	TRACE("Using fast vertex array code\n");
4054
4055	/* This is fixed function pipeline only, and the fixed function pipeline doesn't do instancing */
4056	stateblock->wineD3DDevice->instancedDraw = FALSE;
4057
4058	/* Blend Data ---------------------------------------------- */
4059	e = &si->elements[WINED3D_FFP_BLENDWEIGHT];
4060	if (e->data \|\| e->buffer_object
4061	\|\| si->elements[WINED3D_FFP_BLENDINDICES].data
4062	\|\| si->elements[WINED3D_FFP_BLENDINDICES].buffer_object)
4063	{
4064	if (GL_SUPPORT(ARB_VERTEX_BLEND)) {
4065	TRACE("Blend %d %p %d\n", e->format_desc->component_count,
4066	e->data + stateblock->loadBaseVertexIndex * e->stride, e->stride + offset[e->stream_idx]);
4067
4068	glEnableClientState(GL_WEIGHT_ARRAY_ARB);
4069	checkGLcall("glEnableClientState(GL_WEIGHT_ARRAY_ARB)");
4070
4071	GL_EXTCALL(glVertexBlendARB(e->format_desc->component_count + 1));
4072
4073	VTRACE(("glWeightPointerARB(%d, GL_FLOAT, %d, %p)\n",
4074	WINED3D_ATR_FORMAT(sd->u.s.blendWeights.dwType) ,
4075	sd->u.s.blendWeights.dwStride,
4076	sd->u.s.blendWeights.lpData + stateblock->loadBaseVertexIndex * sd->u.s.blendWeights.dwStride + offset[sd->u.s.blendWeights.streamNo]));
4077
4078	if (curVBO != e->buffer_object)
4079	{
4080	GL_EXTCALL(glBindBufferARB(GL_ARRAY_BUFFER_ARB, e->buffer_object));
4081	checkGLcall("glBindBufferARB");
4082	curVBO = e->buffer_object;
4083	}
4084
4085	GL_EXTCALL(glWeightPointerARB)(e->format_desc->gl_vtx_format, e->format_desc->gl_vtx_type, e->stride,
4086	e->data + stateblock->loadBaseVertexIndex * e->stride + offset[e->stream_idx]);
4087
4088	checkGLcall("glWeightPointerARB");
4089
4090	if (si->elements[WINED3D_FFP_BLENDINDICES].data
4091	\|\| (si->elements[WINED3D_FFP_BLENDINDICES].buffer_object))
4092	{
4093	static BOOL warned;
4094	if (!warned)
4095	{
4096	FIXME("blendMatrixIndices support\n");
4097	warned = TRUE;
4098	}
4099	}
4100	} else {
4101	/* TODO: support blends in drawStridedSlow
4102	* No need to write a FIXME here, this is done after the general vertex decl decoding
4103	*/
4104	WARN("unsupported blending in openGl\n");
4105	}
4106	} else {
4107	if (GL_SUPPORT(ARB_VERTEX_BLEND)) {
4108	static const GLbyte one = 1;
4109	GL_EXTCALL(glWeightbvARB(1, &one));
4110	checkGLcall("glWeightivARB(GL_LIMITS(blends), weights)");
4111	}
4112	}
4113
4114	/* Point Size ----------------------------------------------*/
4115	e = &si->elements[WINED3D_FFP_PSIZE];
4116	if (e->data \|\| e->buffer_object)
4117	{
4118	/* no such functionality in the fixed function GL pipeline */
4119	TRACE("Cannot change ptSize here in openGl\n");
4120	/* TODO: Implement this function in using shaders if they are available */
4121	}
4122
4123	/* Vertex Pointers -----------------------------------------*/
4124	e = &si->elements[WINED3D_FFP_POSITION];
4125	if (e->data \|\| e->buffer_object)
4126	{
4127	VTRACE(("glVertexPointer(%d, GL_FLOAT, %d, %p)\n", e->stride, e->size, e->data));
4128
4129	if (curVBO != e->buffer_object)
4130	{
4131	GL_EXTCALL(glBindBufferARB(GL_ARRAY_BUFFER_ARB, e->buffer_object));
4132	checkGLcall("glBindBufferARB");
4133	curVBO = e->buffer_object;
4134	}
4135
4136	/* min(WINED3D_ATR_FORMAT(position),3) to Disable RHW mode as 'w' coord
4137	handling for rhw mode should not impact screen position whereas in GL it does.
4138	This may result in very slightly distorted textures in rhw mode.
4139	There's always the other option of fixing the view matrix to
4140	prevent w from having any effect.
4141
4142	This only applies to user pointer sources, in VBOs the vertices are fixed up
4143	*/
4144	if (!e->buffer_object)
4145	{
4146	glVertexPointer(3 /* min(e->format_desc->gl_vtx_format, 3) */, e->format_desc->gl_vtx_type, e->stride,
4147	e->data + stateblock->loadBaseVertexIndex * e->stride + offset[e->stream_idx]);
4148	} else {
4149	glVertexPointer(e->format_desc->gl_vtx_format, e->format_desc->gl_vtx_type, e->stride,
4150	e->data + stateblock->loadBaseVertexIndex * e->stride + offset[e->stream_idx]);
4151	}
4152	checkGLcall("glVertexPointer(...)");
4153	glEnableClientState(GL_VERTEX_ARRAY);
4154	checkGLcall("glEnableClientState(GL_VERTEX_ARRAY)");
4155	}
4156
4157	/* Normals -------------------------------------------------*/
4158	e = &si->elements[WINED3D_FFP_NORMAL];
4159	if (e->data \|\| e->buffer_object)
4160	{
4161	VTRACE(("glNormalPointer(GL_FLOAT, %d, %p)\n", e->stride, e->data));
4162	if (curVBO != e->buffer_object)
4163	{
4164	GL_EXTCALL(glBindBufferARB(GL_ARRAY_BUFFER_ARB, e->buffer_object));
4165	checkGLcall("glBindBufferARB");
4166	curVBO = e->buffer_object;
4167	}
4168	glNormalPointer(e->format_desc->gl_vtx_type, e->stride,
4169	e->data + stateblock->loadBaseVertexIndex * e->stride + offset[e->stream_idx]);
4170	checkGLcall("glNormalPointer(...)");
4171	glEnableClientState(GL_NORMAL_ARRAY);
4172	checkGLcall("glEnableClientState(GL_NORMAL_ARRAY)");
4173
4174	} else {
4175	glNormal3f(0, 0, 0);
4176	checkGLcall("glNormal3f(0, 0, 0)");
4177	}
4178
4179	/* Diffuse Colour --------------------------------------------*/
4180	/* WARNING: Data here MUST be in RGBA format, so cannot */
4181	/* go directly into fast mode from app pgm, because */
4182	/* directx requires data in BGRA format. */
4183	/* currently fixupVertices swizzles the format, but this isn't*/
4184	/* very practical when using VBOs */
4185	/* NOTE: Unless we write a vertex shader to swizzle the colour*/
4186	/* , or the user doesn't care and wants the speed advantage */
4187
4188	e = &si->elements[WINED3D_FFP_DIFFUSE];
4189	if (e->data \|\| e->buffer_object)
4190	{
4191	VTRACE(("glColorPointer(4, GL_UNSIGNED_BYTE, %d, %p)\n", e->stride, e->data));
4192
4193	if (curVBO != e->buffer_object)
4194	{
4195	GL_EXTCALL(glBindBufferARB(GL_ARRAY_BUFFER_ARB, e->buffer_object));
4196	checkGLcall("glBindBufferARB");
4197	curVBO = e->buffer_object;
4198	}
4199
4200	glColorPointer(e->format_desc->gl_vtx_format, e->format_desc->gl_vtx_type, e->stride,
4201	e->data + stateblock->loadBaseVertexIndex * e->stride + offset[e->stream_idx]);
4202	checkGLcall("glColorPointer(4, GL_UNSIGNED_BYTE, ...)");
4203	glEnableClientState(GL_COLOR_ARRAY);
4204	checkGLcall("glEnableClientState(GL_COLOR_ARRAY)");
4205
4206	} else {
4207	glColor4f(1.0f, 1.0f, 1.0f, 1.0f);
4208	checkGLcall("glColor4f(1, 1, 1, 1)");
4209	}
4210
4211	/* Specular Colour ------------------------------------------*/
4212	e = &si->elements[WINED3D_FFP_SPECULAR];
4213	if (e->data \|\| e->buffer_object)
4214	{
4215	TRACE("setting specular colour\n");
4216	VTRACE(("glSecondaryColorPointer(4, GL_UNSIGNED_BYTE, %d, %p)\n", e->stride, e->data));
4217
4218	if (GL_SUPPORT(EXT_SECONDARY_COLOR)) {
4219	if (curVBO != e->buffer_object)
4220	{
4221	GL_EXTCALL(glBindBufferARB(GL_ARRAY_BUFFER_ARB, e->buffer_object));
4222	checkGLcall("glBindBufferARB");
4223	curVBO = e->buffer_object;
4224	}
4225	GL_EXTCALL(glSecondaryColorPointerEXT)(e->format_desc->gl_vtx_format, e->format_desc->gl_vtx_type,
4226	e->stride, e->data + stateblock->loadBaseVertexIndex * e->stride + offset[e->stream_idx]);
4227	checkGLcall("glSecondaryColorPointerEXT(4, GL_UNSIGNED_BYTE, ...)");
4228	glEnableClientState(GL_SECONDARY_COLOR_ARRAY_EXT);
4229	checkGLcall("glEnableClientState(GL_SECONDARY_COLOR_ARRAY_EXT)");
4230	} else {
4231
4232	/* Missing specular color is not critical, no warnings */
4233	VTRACE(("Specular colour is not supported in this GL implementation\n"));
4234	}
4235
4236	} else {
4237	if (GL_SUPPORT(EXT_SECONDARY_COLOR)) {
4238	GL_EXTCALL(glSecondaryColor3fEXT)(0, 0, 0);
4239	checkGLcall("glSecondaryColor3fEXT(0, 0, 0)");
4240	} else {
4241
4242	/* Missing specular color is not critical, no warnings */
4243	VTRACE(("Specular colour is not supported in this GL implementation\n"));
4244	}
4245	}
4246
4247	/* Texture coords -------------------------------------------*/
4248	loadTexCoords(stateblock, si, &curVBO);
4249	}
4250
4251	static inline void drawPrimitiveTraceDataLocations(const struct wined3d_stream_info *dataLocations)
4252	{
4253	/* Dump out what parts we have supplied */
4254	TRACE("Strided Data:\n");
4255	TRACE_STRIDED((dataLocations), WINED3D_FFP_POSITION);
4256	TRACE_STRIDED((dataLocations), WINED3D_FFP_BLENDWEIGHT);
4257	TRACE_STRIDED((dataLocations), WINED3D_FFP_BLENDINDICES);
4258	TRACE_STRIDED((dataLocations), WINED3D_FFP_NORMAL);
4259	TRACE_STRIDED((dataLocations), WINED3D_FFP_PSIZE);
4260	TRACE_STRIDED((dataLocations), WINED3D_FFP_DIFFUSE);
4261	TRACE_STRIDED((dataLocations), WINED3D_FFP_SPECULAR);
4262	TRACE_STRIDED((dataLocations), WINED3D_FFP_TEXCOORD0);
4263	TRACE_STRIDED((dataLocations), WINED3D_FFP_TEXCOORD1);
4264	TRACE_STRIDED((dataLocations), WINED3D_FFP_TEXCOORD2);
4265	TRACE_STRIDED((dataLocations), WINED3D_FFP_TEXCOORD3);
4266	TRACE_STRIDED((dataLocations), WINED3D_FFP_TEXCOORD4);
4267	TRACE_STRIDED((dataLocations), WINED3D_FFP_TEXCOORD5);
4268	TRACE_STRIDED((dataLocations), WINED3D_FFP_TEXCOORD6);
4269	TRACE_STRIDED((dataLocations), WINED3D_FFP_TEXCOORD7);
4270
4271	return;
4272	}
4273
4274	static void streamsrc(DWORD state, IWineD3DStateBlockImpl stateblock, WineD3DContext context) {
4275	IWineD3DDeviceImpl *device = stateblock->wineD3DDevice;
4276	BOOL fixup = FALSE;
4277	struct wined3d_stream_info *dataLocations = &device->strided_streams;
4278	BOOL useVertexShaderFunction;
4279	BOOL load_numbered = FALSE;
4280	BOOL load_named = FALSE;
4281
4282	useVertexShaderFunction = (device->vs_selected_mode != SHADER_NONE && stateblock->vertexShader) ? TRUE : FALSE;
4283
4284	if(device->up_strided) {
4285	/* Note: this is a ddraw fixed-function code path */
4286	TRACE("================ Strided Input ===================\n");
4287	device_stream_info_from_strided(device, device->up_strided, dataLocations);
4288
4289	if(TRACE_ON(d3d)) {
4290	drawPrimitiveTraceDataLocations(dataLocations);
4291	}
4292	} else {
4293	/* Note: This is a fixed function or shader codepath.
4294	* This means it must handle both types of strided data.
4295	* Shaders must go through here to zero the strided data, even if they
4296	* don't set any declaration at all
4297	*/
4298	TRACE("================ Vertex Declaration ===================\n");
4299	device_stream_info_from_declaration(device, useVertexShaderFunction, dataLocations, &fixup);
4300	}
4301
4302	if (dataLocations->position_transformed) useVertexShaderFunction = FALSE;
4303
4304	if(useVertexShaderFunction) {
4305	if(((IWineD3DVertexDeclarationImpl *) stateblock->vertexDecl)->half_float_conv_needed && !fixup) {
4306	TRACE("Using drawStridedSlow with vertex shaders for FLOAT16 conversion\n");
4307	device->useDrawStridedSlow = TRUE;
4308	} else {
4309	load_numbered = TRUE;
4310	device->useDrawStridedSlow = FALSE;
4311	}
4312	}
4313	else if (fixup \|\| (!dataLocations->elements[WINED3D_FFP_PSIZE].data
4314	&& !dataLocations->position_transformed
4315	&& (GL_SUPPORT(EXT_VERTEX_ARRAY_BGRA)
4316	\|\| (!dataLocations->elements[WINED3D_FFP_DIFFUSE].data
4317	&& !dataLocations->elements[WINED3D_FFP_SPECULAR].data))))
4318	{
4319	/* Load the vertex data using named arrays */
4320	load_named = TRUE;
4321	device->useDrawStridedSlow = FALSE;
4322	} else {
4323	TRACE("Not loading vertex data\n");
4324	device->useDrawStridedSlow = TRUE;
4325	}
4326
4327	if (context->numberedArraysLoaded && !load_numbered)
4328	{
4329	unloadNumberedArrays(stateblock, context);
4330	context->numberedArraysLoaded = FALSE;
4331	context->numbered_array_mask = 0;
4332	}
4333	else if (context->namedArraysLoaded)
4334	{
4335	unloadVertexData(stateblock);
4336	context->namedArraysLoaded = FALSE;
4337	}
4338
4339	if (load_numbered)
4340	{
4341	TRACE("Loading numbered arrays\n");
4342	loadNumberedArrays(stateblock, dataLocations, context);
4343	context->numberedArraysLoaded = TRUE;
4344	}
4345	else if (load_named)
4346	{
4347	TRACE("Loading vertex data\n");
4348	loadVertexData(stateblock, dataLocations);
4349	context->namedArraysLoaded = TRUE;
4350	}
4351	}
4352
4353	static void vertexdeclaration(DWORD state, IWineD3DStateBlockImpl stateblock, WineD3DContext context) {
4354	BOOL updateFog = FALSE;
4355	BOOL useVertexShaderFunction = use_vs(stateblock);
4356	BOOL usePixelShaderFunction = use_ps(stateblock);
4357	BOOL transformed;
4358	/* Some stuff is in the device until we have per context tracking */
4359	IWineD3DDeviceImpl *device = stateblock->wineD3DDevice;
4360	BOOL wasrhw = context->last_was_rhw;
4361	unsigned int i;
4362
4363	transformed = device->strided_streams.position_transformed;
4364	if(transformed != context->last_was_rhw && !useVertexShaderFunction) {
4365	updateFog = TRUE;
4366	}
4367
4368	/* Reapply lighting if it is not scheduled for reapplication already */
4369	if(!isStateDirty(context, STATE_RENDER(WINED3DRS_LIGHTING))) {
4370	state_lighting(STATE_RENDER(WINED3DRS_LIGHTING), stateblock, context);
4371	}
4372
4373	if (transformed) {
4374	context->last_was_rhw = TRUE;
4375	} else {
4376
4377	/* Untransformed, so relies on the view and projection matrices */
4378	context->last_was_rhw = FALSE;
4379	/* This turns off the Z scale trick to 'disable' viewport frustum clipping in rhw mode*/
4380	device->untransformed = TRUE;
4381
4382	/* Todo for sw shaders: Vertex Shader output is already transformed, so set up identity matrices
4383	* Not needed as long as only hw shaders are supported
4384	*/
4385
4386	/* This sets the shader output position correction constants.
4387	* TODO: Move to the viewport state
4388	*/
4389	if (useVertexShaderFunction) {
4390	device->posFixup[1] = device->render_offscreen ? -1.0 : 1.0;
4391	device->posFixup[3] = -device->posFixup[1] / stateblock->viewport.Height;
4392	}
4393	}
4394
4395	/* Don't have to apply the matrices when vertex shaders are used. When vshaders are turned
4396	* off this function will be called again anyway to make sure they're properly set
4397	*/
4398	if(!useVertexShaderFunction) {
4399	/* TODO: Move this mainly to the viewport state and only apply when the vp has changed
4400	* or transformed / untransformed was switched
4401	*/
4402	if(wasrhw != context->last_was_rhw &&
4403	!isStateDirty(context, STATE_TRANSFORM(WINED3DTS_PROJECTION)) &&
4404	!isStateDirty(context, STATE_VIEWPORT)) {
4405	transform_projection(STATE_TRANSFORM(WINED3DTS_PROJECTION), stateblock, context);
4406	}
4407	/* World matrix needs reapplication here only if we're switching between rhw and non-rhw
4408	* mode.
4409	*
4410	* If a vertex shader is used, the world matrix changed and then vertex shader unbound
4411	* this check will fail and the matrix not applied again. This is OK because a simple
4412	* world matrix change reapplies the matrix - These checks here are only to satisfy the
4413	* needs of the vertex declaration.
4414	*
4415	* World and view matrix go into the same gl matrix, so only apply them when neither is
4416	* dirty
4417	*/
4418	if(transformed != wasrhw &&
4419	!isStateDirty(context, STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(0))) &&
4420	!isStateDirty(context, STATE_TRANSFORM(WINED3DTS_VIEW))) {
4421	transform_world(STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(0)), stateblock, context);
4422	}
4423
4424	if(!isStateDirty(context, STATE_RENDER(WINED3DRS_COLORVERTEX))) {
4425	state_colormat(STATE_RENDER(WINED3DRS_COLORVERTEX), stateblock, context);
4426	}
4427
4428	if(context->last_was_vshader) {
4429	updateFog = TRUE;
4430	if(!device->vs_clipping && !isStateDirty(context, STATE_RENDER(WINED3DRS_CLIPPLANEENABLE))) {
4431	state_clipping(STATE_RENDER(WINED3DRS_CLIPPLANEENABLE), stateblock, context);
4432	}
4433	for(i = 0; i < GL_LIMITS(clipplanes); i++) {
4434	clipplane(STATE_CLIPPLANE(i), stateblock, context);
4435	}
4436	}
4437	if(!isStateDirty(context, STATE_RENDER(WINED3DRS_NORMALIZENORMALS))) {
4438	state_normalize(STATE_RENDER(WINED3DRS_NORMALIZENORMALS), stateblock, context);
4439	}
4440	} else {
4441	if(!context->last_was_vshader) {
4442	static BOOL warned = FALSE;
4443	if(!device->vs_clipping) {
4444	/* Disable all clip planes to get defined results on all drivers. See comment in the
4445	* state_clipping state handler
4446	*/
4447	for(i = 0; i < GL_LIMITS(clipplanes); i++) {
4448	glDisable(GL_CLIP_PLANE0 + i);
4449	checkGLcall("glDisable(GL_CLIP_PLANE0 + i)");
4450	}
4451
4452	if(!warned && stateblock->renderState[WINED3DRS_CLIPPLANEENABLE]) {
4453	FIXME("Clipping not supported with vertex shaders\n");
4454	warned = TRUE;
4455	}
4456	}
4457	if(wasrhw) {
4458	/* Apply the transform matrices when switching from rhw drawing to vertex shaders. Vertex
4459	* shaders themselves do not need it, but the matrices are not reapplied automatically when
4460	* switching back from vertex shaders to fixed function processing. So make sure we leave the
4461	* fixed function vertex processing states back in a sane state before switching to shaders
4462	*/
4463	if(!isStateDirty(context, STATE_TRANSFORM(WINED3DTS_PROJECTION))) {
4464	transform_projection(STATE_TRANSFORM(WINED3DTS_PROJECTION), stateblock, context);
4465	}
4466	if(!isStateDirty(context, STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(0)))) {
4467	transform_world(STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(0)), stateblock, context);
4468	}
4469	}
4470	updateFog = TRUE;
4471
4472	/* Vertex shader clipping ignores the view matrix. Update all clipplanes
4473	* (Note: ARB shaders can read the clip planes for clipping emulation even if
4474	* device->vs_clipping is false.
4475	*/
4476	for(i = 0; i < GL_LIMITS(clipplanes); i++) {
4477	clipplane(STATE_CLIPPLANE(i), stateblock, context);
4478	}
4479	}
4480	}
4481
4482	/* Vertex and pixel shaders are applied together for now, so let the last dirty state do the
4483	* application
4484	*/
4485	if (!isStateDirty(context, STATE_PIXELSHADER)) {
4486	device->shader_backend->shader_select((IWineD3DDevice *)device, usePixelShaderFunction, useVertexShaderFunction);
4487
4488	if (!isStateDirty(context, STATE_VERTEXSHADERCONSTANT) && (useVertexShaderFunction \|\| usePixelShaderFunction)) {
4489	shaderconstant(STATE_VERTEXSHADERCONSTANT, stateblock, context);
4490	}
4491	}
4492
4493	context->last_was_vshader = useVertexShaderFunction;
4494
4495	if(updateFog) {
4496	device->StateTable[STATE_RENDER(WINED3DRS_FOGVERTEXMODE)].apply(STATE_RENDER(WINED3DRS_FOGVERTEXMODE), stateblock, context);
4497	}
4498	if(!useVertexShaderFunction) {
4499	int i;
4500	for(i = 0; i < MAX_TEXTURES; i++) {
4501	if(!isStateDirty(context, STATE_TRANSFORM(WINED3DTS_TEXTURE0 + i))) {
4502	transform_texture(STATE_TEXTURESTAGE(i, WINED3DTSS_TEXTURETRANSFORMFLAGS), stateblock, context);
4503	}
4504	}
4505	}
4506	}
4507
4508	static void viewport_miscpart(DWORD state, IWineD3DStateBlockImpl stateblock, WineD3DContext context) {
4509	UINT width, height;
4510	IWineD3DSurfaceImpl *target;
4511
4512	glDepthRange(stateblock->viewport.MinZ, stateblock->viewport.MaxZ);
4513	checkGLcall("glDepthRange");
4514	/* Note: GL requires lower left, DirectX supplies upper left. This is reversed when using offscreen rendering
4515	*/
4516	if(stateblock->wineD3DDevice->render_offscreen) {
4517	glViewport(stateblock->viewport.X,
4518	stateblock->viewport.Y,
4519	stateblock->viewport.Width, stateblock->viewport.Height);
4520	} else {
4521	target = (IWineD3DSurfaceImpl *) stateblock->wineD3DDevice->render_targets[0];
4522	target->get_drawable_size(target, &width, &height);
4523
4524	glViewport(stateblock->viewport.X,
4525	(height - (stateblock->viewport.Y + stateblock->viewport.Height)),
4526	stateblock->viewport.Width, stateblock->viewport.Height);
4527	}
4528
4529	checkGLcall("glViewport");
4530	}
4531
4532	static void viewport_vertexpart(DWORD state, IWineD3DStateBlockImpl stateblock, WineD3DContext context) {
4533	stateblock->wineD3DDevice->posFixup[2] = 1.0 / stateblock->viewport.Width;
4534	stateblock->wineD3DDevice->posFixup[3] = -stateblock->wineD3DDevice->posFixup[1] / stateblock->viewport.Height;
4535	if(!isStateDirty(context, STATE_TRANSFORM(WINED3DTS_PROJECTION))) {
4536	transform_projection(STATE_TRANSFORM(WINED3DTS_PROJECTION), stateblock, context);
4537	}
4538	if(!isStateDirty(context, STATE_RENDER(WINED3DRS_POINTSCALEENABLE))) {
4539	state_pscale(STATE_RENDER(WINED3DRS_POINTSCALEENABLE), stateblock, context);
4540	}
4541	}
4542
4543	static void light(DWORD state, IWineD3DStateBlockImpl stateblock, WineD3DContext context) {
4544	UINT Index = state - STATE_ACTIVELIGHT(0);
4545	const PLIGHTINFOEL *lightInfo = stateblock->activeLights[Index];
4546
4547	if(!lightInfo) {
4548	glDisable(GL_LIGHT0 + Index);
4549	checkGLcall("glDisable(GL_LIGHT0 + Index)");
4550	} else {
4551	float quad_att;
4552	float colRGBA[] = {0.0, 0.0, 0.0, 0.0};
4553
4554	/* Light settings are affected by the model view in OpenGL, the View transform in direct3d*/
4555	glMatrixMode(GL_MODELVIEW);
4556	glPushMatrix();
4557	glLoadMatrixf(&stateblock->transforms[WINED3DTS_VIEW].u.m[0][0]);
4558
4559	/* Diffuse: */
4560	colRGBA[0] = lightInfo->OriginalParms.Diffuse.r;
4561	colRGBA[1] = lightInfo->OriginalParms.Diffuse.g;
4562	colRGBA[2] = lightInfo->OriginalParms.Diffuse.b;
4563	colRGBA[3] = lightInfo->OriginalParms.Diffuse.a;
4564	glLightfv(GL_LIGHT0 + Index, GL_DIFFUSE, colRGBA);
4565	checkGLcall("glLightfv");
4566
4567	/* Specular */
4568	colRGBA[0] = lightInfo->OriginalParms.Specular.r;
4569	colRGBA[1] = lightInfo->OriginalParms.Specular.g;
4570	colRGBA[2] = lightInfo->OriginalParms.Specular.b;
4571	colRGBA[3] = lightInfo->OriginalParms.Specular.a;
4572	glLightfv(GL_LIGHT0 + Index, GL_SPECULAR, colRGBA);
4573	checkGLcall("glLightfv");
4574
4575	/* Ambient */
4576	colRGBA[0] = lightInfo->OriginalParms.Ambient.r;
4577	colRGBA[1] = lightInfo->OriginalParms.Ambient.g;
4578	colRGBA[2] = lightInfo->OriginalParms.Ambient.b;
4579	colRGBA[3] = lightInfo->OriginalParms.Ambient.a;
4580	glLightfv(GL_LIGHT0 + Index, GL_AMBIENT, colRGBA);
4581	checkGLcall("glLightfv");
4582
4583	if ((lightInfo->OriginalParms.Range *lightInfo->OriginalParms.Range) >= FLT_MIN) {
4584	quad_att = 1.4/(lightInfo->OriginalParms.Range *lightInfo->OriginalParms.Range);
4585	} else {
4586	quad_att = 0; /* 0 or MAX? (0 seems to be ok) */
4587	}
4588
4589	/* Do not assign attenuation values for lights that do not use them. D3D apps are free to pass any junk,
4590	* but gl drivers use them and may crash due to bad Attenuation values. Need for Speed most wanted sets
4591	* Attenuation0 to NaN and crashes in the gl lib
4592	*/
4593
4594	switch (lightInfo->OriginalParms.Type) {
4595	case WINED3DLIGHT_POINT:
4596	/* Position */
4597	glLightfv(GL_LIGHT0 + Index, GL_POSITION, &lightInfo->lightPosn[0]);
4598	checkGLcall("glLightfv");
4599	glLightf(GL_LIGHT0 + Index, GL_SPOT_CUTOFF, lightInfo->cutoff);
4600	checkGLcall("glLightf");
4601	/* Attenuation - Are these right? guessing... */
4602	glLightf(GL_LIGHT0 + Index, GL_CONSTANT_ATTENUATION, lightInfo->OriginalParms.Attenuation0);
4603	checkGLcall("glLightf");
4604	glLightf(GL_LIGHT0 + Index, GL_LINEAR_ATTENUATION, lightInfo->OriginalParms.Attenuation1);
4605	checkGLcall("glLightf");
4606	if (quad_att < lightInfo->OriginalParms.Attenuation2) quad_att = lightInfo->OriginalParms.Attenuation2;
4607	glLightf(GL_LIGHT0 + Index, GL_QUADRATIC_ATTENUATION, quad_att);
4608	checkGLcall("glLightf");
4609	/* FIXME: Range */
4610	break;
4611
4612	case WINED3DLIGHT_SPOT:
4613	/* Position */
4614	glLightfv(GL_LIGHT0 + Index, GL_POSITION, &lightInfo->lightPosn[0]);
4615	checkGLcall("glLightfv");
4616	/* Direction */
4617	glLightfv(GL_LIGHT0 + Index, GL_SPOT_DIRECTION, &lightInfo->lightDirn[0]);
4618	checkGLcall("glLightfv");
4619	glLightf(GL_LIGHT0 + Index, GL_SPOT_EXPONENT, lightInfo->exponent);
4620	checkGLcall("glLightf");
4621	glLightf(GL_LIGHT0 + Index, GL_SPOT_CUTOFF, lightInfo->cutoff);
4622	checkGLcall("glLightf");
4623	/* Attenuation - Are these right? guessing... */
4624	glLightf(GL_LIGHT0 + Index, GL_CONSTANT_ATTENUATION, lightInfo->OriginalParms.Attenuation0);
4625	checkGLcall("glLightf");
4626	glLightf(GL_LIGHT0 + Index, GL_LINEAR_ATTENUATION, lightInfo->OriginalParms.Attenuation1);
4627	checkGLcall("glLightf");
4628	if (quad_att < lightInfo->OriginalParms.Attenuation2) quad_att = lightInfo->OriginalParms.Attenuation2;
4629	glLightf(GL_LIGHT0 + Index, GL_QUADRATIC_ATTENUATION, quad_att);
4630	checkGLcall("glLightf");
4631	/* FIXME: Range */
4632	break;
4633
4634	case WINED3DLIGHT_DIRECTIONAL:
4635	/* Direction */
4636	glLightfv(GL_LIGHT0 + Index, GL_POSITION, &lightInfo->lightPosn[0]); /* Note gl uses w position of 0 for direction! */
4637	checkGLcall("glLightfv");
4638	glLightf(GL_LIGHT0 + Index, GL_SPOT_CUTOFF, lightInfo->cutoff);
4639	checkGLcall("glLightf");
4640	glLightf(GL_LIGHT0 + Index, GL_SPOT_EXPONENT, 0.0f);
4641	checkGLcall("glLightf");
4642	break;
4643
4644	default:
4645	FIXME("Unrecognized light type %d\n", lightInfo->OriginalParms.Type);
4646	}
4647
4648	/* Restore the modelview matrix */
4649	glPopMatrix();
4650
4651	glEnable(GL_LIGHT0 + Index);
4652	checkGLcall("glEnable(GL_LIGHT0 + Index)");
4653	}
4654
4655	return;
4656	}
4657
4658	static void scissorrect(DWORD state, IWineD3DStateBlockImpl stateblock, WineD3DContext context) {
4659	RECT *pRect = &stateblock->scissorRect;
4660	UINT height;
4661	UINT width;
4662	IWineD3DSurfaceImpl target = (IWineD3DSurfaceImpl ) stateblock->wineD3DDevice->render_targets[0];
4663
4664	target->get_drawable_size(target, &width, &height);
4665	/* Warning: glScissor uses window coordinates, not viewport coordinates, so our viewport correction does not apply
4666	* Warning2: Even in windowed mode the coords are relative to the window, not the screen
4667	*/
4668	TRACE("(%p) Setting new Scissor Rect to %d:%d-%d:%d\n", stateblock->wineD3DDevice, pRect->left, pRect->bottom - height,
4669	pRect->right - pRect->left, pRect->bottom - pRect->top);
4670
4671	if (stateblock->wineD3DDevice->render_offscreen) {
4672	glScissor(pRect->left, pRect->top, pRect->right - pRect->left, pRect->bottom - pRect->top);
4673	} else {
4674	glScissor(pRect->left, height - pRect->bottom, pRect->right - pRect->left, pRect->bottom - pRect->top);
4675	}
4676	checkGLcall("glScissor");
4677	}
4678
4679	static void indexbuffer(DWORD state, IWineD3DStateBlockImpl stateblock, WineD3DContext context) {
4680	if(stateblock->streamIsUP \|\| stateblock->pIndexData == NULL ) {
4681	GL_EXTCALL(glBindBufferARB(GL_ELEMENT_ARRAY_BUFFER_ARB, 0));
4682	} else {
4683	struct wined3d_buffer ib = (struct wined3d_buffer ) stateblock->pIndexData;
4684	GL_EXTCALL(glBindBufferARB(GL_ELEMENT_ARRAY_BUFFER_ARB, ib->buffer_object));
4685	}
4686	}
4687
4688	static void frontface(DWORD state, IWineD3DStateBlockImpl stateblock, WineD3DContext context) {
4689	if(stateblock->wineD3DDevice->render_offscreen) {
4690	glFrontFace(GL_CCW);
4691	checkGLcall("glFrontFace(GL_CCW)");
4692	} else {
4693	glFrontFace(GL_CW);
4694	checkGLcall("glFrontFace(GL_CW)");
4695	}
4696	}
4697
4698	const struct StateEntryTemplate misc_state_template[] = {
4699	{ STATE_RENDER(WINED3DRS_SRCBLEND), { STATE_RENDER(WINED3DRS_ALPHABLENDENABLE), state_blend }, WINED3D_GL_EXT_NONE },
4700	{ STATE_RENDER(WINED3DRS_DESTBLEND), { STATE_RENDER(WINED3DRS_ALPHABLENDENABLE), state_blend }, WINED3D_GL_EXT_NONE },
4701	{ STATE_RENDER(WINED3DRS_ALPHABLENDENABLE), { STATE_RENDER(WINED3DRS_ALPHABLENDENABLE), state_blend }, WINED3D_GL_EXT_NONE },
4702	{ STATE_RENDER(WINED3DRS_EDGEANTIALIAS), { STATE_RENDER(WINED3DRS_ALPHABLENDENABLE), state_blend }, WINED3D_GL_EXT_NONE },
4703	{ STATE_RENDER(WINED3DRS_ANTIALIASEDLINEENABLE), { STATE_RENDER(WINED3DRS_ALPHABLENDENABLE), state_blend }, WINED3D_GL_EXT_NONE },
4704	{ STATE_RENDER(WINED3DRS_SEPARATEALPHABLENDENABLE), { STATE_RENDER(WINED3DRS_ALPHABLENDENABLE), state_blend }, WINED3D_GL_EXT_NONE },
4705	{ STATE_RENDER(WINED3DRS_SRCBLENDALPHA), { STATE_RENDER(WINED3DRS_ALPHABLENDENABLE), state_blend }, WINED3D_GL_EXT_NONE },
4706	{ STATE_RENDER(WINED3DRS_DESTBLENDALPHA), { STATE_RENDER(WINED3DRS_ALPHABLENDENABLE), state_blend }, WINED3D_GL_EXT_NONE },
4707	{ STATE_RENDER(WINED3DRS_DESTBLENDALPHA), { STATE_RENDER(WINED3DRS_ALPHABLENDENABLE), state_blend }, WINED3D_GL_EXT_NONE },
4708	{ STATE_RENDER(WINED3DRS_BLENDOPALPHA), { STATE_RENDER(WINED3DRS_ALPHABLENDENABLE), state_blend }, WINED3D_GL_EXT_NONE },
4709	{ STATE_STREAMSRC, { STATE_VDECL, streamsrc }, WINED3D_GL_EXT_NONE },
4710	{ STATE_VDECL, { STATE_VDECL, streamsrc }, WINED3D_GL_EXT_NONE },
4711	{ STATE_FRONTFACE, { STATE_FRONTFACE, frontface }, WINED3D_GL_EXT_NONE },
4712	{ STATE_SCISSORRECT, { STATE_SCISSORRECT, scissorrect }, WINED3D_GL_EXT_NONE },
4713	/* TODO: Move shader constant loading to vertex and fragment pipeline repectively, as soon as the pshader and
4714	* vshader loadings are untied from each other
4715	*/
4716	{ STATE_VERTEXSHADERCONSTANT, { STATE_VERTEXSHADERCONSTANT, shaderconstant }, WINED3D_GL_EXT_NONE },
4717	{ STATE_PIXELSHADERCONSTANT, { STATE_VERTEXSHADERCONSTANT, shaderconstant }, WINED3D_GL_EXT_NONE },
4718	{ STATE_TEXTURESTAGE(0, WINED3DTSS_BUMPENVMAT00), { STATE_TEXTURESTAGE(0, WINED3DTSS_BUMPENVMAT00), shader_bumpenvmat }, WINED3D_GL_EXT_NONE },
4719	{ STATE_TEXTURESTAGE(0, WINED3DTSS_BUMPENVMAT01), { STATE_TEXTURESTAGE(0, WINED3DTSS_BUMPENVMAT00), shader_bumpenvmat }, WINED3D_GL_EXT_NONE },
4720	{ STATE_TEXTURESTAGE(0, WINED3DTSS_BUMPENVMAT10), { STATE_TEXTURESTAGE(0, WINED3DTSS_BUMPENVMAT00), shader_bumpenvmat }, WINED3D_GL_EXT_NONE },
4721	{ STATE_TEXTURESTAGE(0, WINED3DTSS_BUMPENVMAT11), { STATE_TEXTURESTAGE(0, WINED3DTSS_BUMPENVMAT00), shader_bumpenvmat }, WINED3D_GL_EXT_NONE },
4722	{ STATE_TEXTURESTAGE(1, WINED3DTSS_BUMPENVMAT00), { STATE_TEXTURESTAGE(1, WINED3DTSS_BUMPENVMAT00), shader_bumpenvmat }, WINED3D_GL_EXT_NONE },
4723	{ STATE_TEXTURESTAGE(1, WINED3DTSS_BUMPENVMAT01), { STATE_TEXTURESTAGE(1, WINED3DTSS_BUMPENVMAT00), shader_bumpenvmat }, WINED3D_GL_EXT_NONE },
4724	{ STATE_TEXTURESTAGE(1, WINED3DTSS_BUMPENVMAT10), { STATE_TEXTURESTAGE(1, WINED3DTSS_BUMPENVMAT00), shader_bumpenvmat }, WINED3D_GL_EXT_NONE },
4725	{ STATE_TEXTURESTAGE(1, WINED3DTSS_BUMPENVMAT11), { STATE_TEXTURESTAGE(1, WINED3DTSS_BUMPENVMAT00), shader_bumpenvmat }, WINED3D_GL_EXT_NONE },
4726	{ STATE_TEXTURESTAGE(2, WINED3DTSS_BUMPENVMAT00), { STATE_TEXTURESTAGE(2, WINED3DTSS_BUMPENVMAT00), shader_bumpenvmat }, WINED3D_GL_EXT_NONE },
4727	{ STATE_TEXTURESTAGE(2, WINED3DTSS_BUMPENVMAT01), { STATE_TEXTURESTAGE(2, WINED3DTSS_BUMPENVMAT00), shader_bumpenvmat }, WINED3D_GL_EXT_NONE },
4728	{ STATE_TEXTURESTAGE(2, WINED3DTSS_BUMPENVMAT10), { STATE_TEXTURESTAGE(2, WINED3DTSS_BUMPENVMAT00), shader_bumpenvmat }, WINED3D_GL_EXT_NONE },
4729	{ STATE_TEXTURESTAGE(2, WINED3DTSS_BUMPENVMAT11), { STATE_TEXTURESTAGE(2, WINED3DTSS_BUMPENVMAT00), shader_bumpenvmat }, WINED3D_GL_EXT_NONE },
4730	{ STATE_TEXTURESTAGE(3, WINED3DTSS_BUMPENVMAT00), { STATE_TEXTURESTAGE(3, WINED3DTSS_BUMPENVMAT00), shader_bumpenvmat }, WINED3D_GL_EXT_NONE },
4731	{ STATE_TEXTURESTAGE(3, WINED3DTSS_BUMPENVMAT01), { STATE_TEXTURESTAGE(3, WINED3DTSS_BUMPENVMAT00), shader_bumpenvmat }, WINED3D_GL_EXT_NONE },
4732	{ STATE_TEXTURESTAGE(3, WINED3DTSS_BUMPENVMAT10), { STATE_TEXTURESTAGE(3, WINED3DTSS_BUMPENVMAT00), shader_bumpenvmat }, WINED3D_GL_EXT_NONE },
4733	{ STATE_TEXTURESTAGE(3, WINED3DTSS_BUMPENVMAT11), { STATE_TEXTURESTAGE(3, WINED3DTSS_BUMPENVMAT00), shader_bumpenvmat }, WINED3D_GL_EXT_NONE },
4734	{ STATE_TEXTURESTAGE(4, WINED3DTSS_BUMPENVMAT00), { STATE_TEXTURESTAGE(4, WINED3DTSS_BUMPENVMAT00), shader_bumpenvmat }, WINED3D_GL_EXT_NONE },
4735	{ STATE_TEXTURESTAGE(4, WINED3DTSS_BUMPENVMAT01), { STATE_TEXTURESTAGE(4, WINED3DTSS_BUMPENVMAT00), shader_bumpenvmat }, WINED3D_GL_EXT_NONE },
4736	{ STATE_TEXTURESTAGE(4, WINED3DTSS_BUMPENVMAT10), { STATE_TEXTURESTAGE(4, WINED3DTSS_BUMPENVMAT00), shader_bumpenvmat }, WINED3D_GL_EXT_NONE },
4737	{ STATE_TEXTURESTAGE(4, WINED3DTSS_BUMPENVMAT11), { STATE_TEXTURESTAGE(4, WINED3DTSS_BUMPENVMAT00), shader_bumpenvmat }, WINED3D_GL_EXT_NONE },
4738	{ STATE_TEXTURESTAGE(5, WINED3DTSS_BUMPENVMAT00), { STATE_TEXTURESTAGE(5, WINED3DTSS_BUMPENVMAT00), shader_bumpenvmat }, WINED3D_GL_EXT_NONE },
4739	{ STATE_TEXTURESTAGE(5, WINED3DTSS_BUMPENVMAT01), { STATE_TEXTURESTAGE(5, WINED3DTSS_BUMPENVMAT00), shader_bumpenvmat }, WINED3D_GL_EXT_NONE },
4740	{ STATE_TEXTURESTAGE(5, WINED3DTSS_BUMPENVMAT10), { STATE_TEXTURESTAGE(5, WINED3DTSS_BUMPENVMAT00), shader_bumpenvmat }, WINED3D_GL_EXT_NONE },
4741	{ STATE_TEXTURESTAGE(5, WINED3DTSS_BUMPENVMAT11), { STATE_TEXTURESTAGE(5, WINED3DTSS_BUMPENVMAT00), shader_bumpenvmat }, WINED3D_GL_EXT_NONE },
4742	{ STATE_TEXTURESTAGE(6, WINED3DTSS_BUMPENVMAT00), { STATE_TEXTURESTAGE(6, WINED3DTSS_BUMPENVMAT00), shader_bumpenvmat }, WINED3D_GL_EXT_NONE },
4743	{ STATE_TEXTURESTAGE(6, WINED3DTSS_BUMPENVMAT01), { STATE_TEXTURESTAGE(6, WINED3DTSS_BUMPENVMAT00), shader_bumpenvmat }, WINED3D_GL_EXT_NONE },
4744	{ STATE_TEXTURESTAGE(6, WINED3DTSS_BUMPENVMAT10), { STATE_TEXTURESTAGE(6, WINED3DTSS_BUMPENVMAT00), shader_bumpenvmat }, WINED3D_GL_EXT_NONE },
4745	{ STATE_TEXTURESTAGE(6, WINED3DTSS_BUMPENVMAT11), { STATE_TEXTURESTAGE(6, WINED3DTSS_BUMPENVMAT00), shader_bumpenvmat }, WINED3D_GL_EXT_NONE },
4746	{ STATE_TEXTURESTAGE(7, WINED3DTSS_BUMPENVMAT00), { STATE_TEXTURESTAGE(7, WINED3DTSS_BUMPENVMAT00), shader_bumpenvmat }, WINED3D_GL_EXT_NONE },
4747	{ STATE_TEXTURESTAGE(7, WINED3DTSS_BUMPENVMAT01), { STATE_TEXTURESTAGE(7, WINED3DTSS_BUMPENVMAT00), shader_bumpenvmat }, WINED3D_GL_EXT_NONE },
4748	{ STATE_TEXTURESTAGE(7, WINED3DTSS_BUMPENVMAT10), { STATE_TEXTURESTAGE(7, WINED3DTSS_BUMPENVMAT00), shader_bumpenvmat }, WINED3D_GL_EXT_NONE },
4749	{ STATE_TEXTURESTAGE(7, WINED3DTSS_BUMPENVMAT11), { STATE_TEXTURESTAGE(7, WINED3DTSS_BUMPENVMAT00), shader_bumpenvmat }, WINED3D_GL_EXT_NONE },
4750	{ STATE_TEXTURESTAGE(0, WINED3DTSS_BUMPENVLSCALE), { STATE_TEXTURESTAGE(0, WINED3DTSS_BUMPENVLSCALE), tex_bumpenvlscale }, WINED3D_GL_EXT_NONE },
4751	{ STATE_TEXTURESTAGE(0, WINED3DTSS_BUMPENVLOFFSET), { STATE_TEXTURESTAGE(0, WINED3DTSS_BUMPENVLSCALE), tex_bumpenvlscale }, WINED3D_GL_EXT_NONE },
4752	{ STATE_TEXTURESTAGE(1, WINED3DTSS_BUMPENVLSCALE), { STATE_TEXTURESTAGE(1, WINED3DTSS_BUMPENVLSCALE), tex_bumpenvlscale }, WINED3D_GL_EXT_NONE },
4753	{ STATE_TEXTURESTAGE(1, WINED3DTSS_BUMPENVLOFFSET), { STATE_TEXTURESTAGE(1, WINED3DTSS_BUMPENVLSCALE), tex_bumpenvlscale }, WINED3D_GL_EXT_NONE },
4754	{ STATE_TEXTURESTAGE(2, WINED3DTSS_BUMPENVLSCALE), { STATE_TEXTURESTAGE(2, WINED3DTSS_BUMPENVLSCALE), tex_bumpenvlscale }, WINED3D_GL_EXT_NONE },
4755	{ STATE_TEXTURESTAGE(2, WINED3DTSS_BUMPENVLOFFSET), { STATE_TEXTURESTAGE(2, WINED3DTSS_BUMPENVLSCALE), tex_bumpenvlscale }, WINED3D_GL_EXT_NONE },
4756	{ STATE_TEXTURESTAGE(3, WINED3DTSS_BUMPENVLSCALE), { STATE_TEXTURESTAGE(3, WINED3DTSS_BUMPENVLSCALE), tex_bumpenvlscale }, WINED3D_GL_EXT_NONE },
4757	{ STATE_TEXTURESTAGE(3, WINED3DTSS_BUMPENVLOFFSET), { STATE_TEXTURESTAGE(3, WINED3DTSS_BUMPENVLSCALE), tex_bumpenvlscale }, WINED3D_GL_EXT_NONE },
4758	{ STATE_TEXTURESTAGE(4, WINED3DTSS_BUMPENVLSCALE), { STATE_TEXTURESTAGE(4, WINED3DTSS_BUMPENVLSCALE), tex_bumpenvlscale }, WINED3D_GL_EXT_NONE },
4759	{ STATE_TEXTURESTAGE(4, WINED3DTSS_BUMPENVLOFFSET), { STATE_TEXTURESTAGE(4, WINED3DTSS_BUMPENVLSCALE), tex_bumpenvlscale }, WINED3D_GL_EXT_NONE },
4760	{ STATE_TEXTURESTAGE(5, WINED3DTSS_BUMPENVLSCALE), { STATE_TEXTURESTAGE(5, WINED3DTSS_BUMPENVLSCALE), tex_bumpenvlscale }, WINED3D_GL_EXT_NONE },
4761	{ STATE_TEXTURESTAGE(5, WINED3DTSS_BUMPENVLOFFSET), { STATE_TEXTURESTAGE(5, WINED3DTSS_BUMPENVLSCALE), tex_bumpenvlscale }, WINED3D_GL_EXT_NONE },
4762	{ STATE_TEXTURESTAGE(6, WINED3DTSS_BUMPENVLSCALE), { STATE_TEXTURESTAGE(6, WINED3DTSS_BUMPENVLSCALE), tex_bumpenvlscale }, WINED3D_GL_EXT_NONE },
4763	{ STATE_TEXTURESTAGE(6, WINED3DTSS_BUMPENVLOFFSET), { STATE_TEXTURESTAGE(6, WINED3DTSS_BUMPENVLSCALE), tex_bumpenvlscale }, WINED3D_GL_EXT_NONE },
4764	{ STATE_TEXTURESTAGE(7, WINED3DTSS_BUMPENVLSCALE), { STATE_TEXTURESTAGE(7, WINED3DTSS_BUMPENVLSCALE), tex_bumpenvlscale }, WINED3D_GL_EXT_NONE },
4765	{ STATE_TEXTURESTAGE(7, WINED3DTSS_BUMPENVLOFFSET), { STATE_TEXTURESTAGE(7, WINED3DTSS_BUMPENVLSCALE), tex_bumpenvlscale }, WINED3D_GL_EXT_NONE },
4766
4767	{ STATE_VIEWPORT, { STATE_VIEWPORT, viewport_miscpart }, WINED3D_GL_EXT_NONE },
4768	{ STATE_INDEXBUFFER, { STATE_INDEXBUFFER, indexbuffer }, ARB_VERTEX_BUFFER_OBJECT },
4769	{ STATE_RENDER(WINED3DRS_ANTIALIAS), { STATE_RENDER(WINED3DRS_ANTIALIAS), state_antialias }, WINED3D_GL_EXT_NONE },
4770	{ STATE_RENDER(WINED3DRS_TEXTUREPERSPECTIVE), { STATE_RENDER(WINED3DRS_TEXTUREPERSPECTIVE), state_perspective }, WINED3D_GL_EXT_NONE },
4771	{ STATE_RENDER(WINED3DRS_ZENABLE), { STATE_RENDER(WINED3DRS_ZENABLE), state_zenable }, WINED3D_GL_EXT_NONE },
4772	{ STATE_RENDER(WINED3DRS_WRAPU), { STATE_RENDER(WINED3DRS_WRAPU), state_wrapu }, WINED3D_GL_EXT_NONE },
4773	{ STATE_RENDER(WINED3DRS_WRAPV), { STATE_RENDER(WINED3DRS_WRAPV), state_wrapv }, WINED3D_GL_EXT_NONE },
4774	{ STATE_RENDER(WINED3DRS_FILLMODE), { STATE_RENDER(WINED3DRS_FILLMODE), state_fillmode }, WINED3D_GL_EXT_NONE },
4775	{ STATE_RENDER(WINED3DRS_SHADEMODE), { STATE_RENDER(WINED3DRS_SHADEMODE), state_shademode }, WINED3D_GL_EXT_NONE },
4776	{ STATE_RENDER(WINED3DRS_LINEPATTERN), { STATE_RENDER(WINED3DRS_LINEPATTERN), state_linepattern }, WINED3D_GL_EXT_NONE },
4777	{ STATE_RENDER(WINED3DRS_MONOENABLE), { STATE_RENDER(WINED3DRS_MONOENABLE), state_monoenable }, WINED3D_GL_EXT_NONE },
4778	{ STATE_RENDER(WINED3DRS_ROP2), { STATE_RENDER(WINED3DRS_ROP2), state_rop2 }, WINED3D_GL_EXT_NONE },
4779	{ STATE_RENDER(WINED3DRS_PLANEMASK), { STATE_RENDER(WINED3DRS_PLANEMASK), state_planemask }, WINED3D_GL_EXT_NONE },
4780	{ STATE_RENDER(WINED3DRS_ZWRITEENABLE), { STATE_RENDER(WINED3DRS_ZWRITEENABLE), state_zwritenable }, WINED3D_GL_EXT_NONE },
4781	{ STATE_RENDER(WINED3DRS_ALPHATESTENABLE), { STATE_RENDER(WINED3DRS_ALPHATESTENABLE), state_alpha }, WINED3D_GL_EXT_NONE },
4782	{ STATE_RENDER(WINED3DRS_ALPHAREF), { STATE_RENDER(WINED3DRS_ALPHATESTENABLE), state_alpha }, WINED3D_GL_EXT_NONE },
4783	{ STATE_RENDER(WINED3DRS_ALPHAFUNC), { STATE_RENDER(WINED3DRS_ALPHATESTENABLE), state_alpha }, WINED3D_GL_EXT_NONE },
4784	{ STATE_RENDER(WINED3DRS_COLORKEYENABLE), { STATE_RENDER(WINED3DRS_ALPHATESTENABLE), state_alpha }, WINED3D_GL_EXT_NONE },
4785	{ STATE_RENDER(WINED3DRS_LASTPIXEL), { STATE_RENDER(WINED3DRS_LASTPIXEL), state_lastpixel }, WINED3D_GL_EXT_NONE },
4786	{ STATE_RENDER(WINED3DRS_CULLMODE), { STATE_RENDER(WINED3DRS_CULLMODE), state_cullmode }, WINED3D_GL_EXT_NONE },
4787	{ STATE_RENDER(WINED3DRS_ZFUNC), { STATE_RENDER(WINED3DRS_ZFUNC), state_zfunc }, WINED3D_GL_EXT_NONE },
4788	{ STATE_RENDER(WINED3DRS_DITHERENABLE), { STATE_RENDER(WINED3DRS_DITHERENABLE), state_ditherenable }, WINED3D_GL_EXT_NONE },
4789	{ STATE_RENDER(WINED3DRS_SUBPIXEL), { STATE_RENDER(WINED3DRS_SUBPIXEL), state_subpixel }, WINED3D_GL_EXT_NONE },
4790	{ STATE_RENDER(WINED3DRS_SUBPIXELX), { STATE_RENDER(WINED3DRS_SUBPIXELX), state_subpixelx }, WINED3D_GL_EXT_NONE },
4791	{ STATE_RENDER(WINED3DRS_STIPPLEDALPHA), { STATE_RENDER(WINED3DRS_STIPPLEDALPHA), state_stippledalpha }, WINED3D_GL_EXT_NONE },
4792	{ STATE_RENDER(WINED3DRS_ZBIAS), { STATE_RENDER(WINED3DRS_ZBIAS), state_zbias }, WINED3D_GL_EXT_NONE },
4793	{ STATE_RENDER(WINED3DRS_STIPPLEENABLE), { STATE_RENDER(WINED3DRS_STIPPLEENABLE), state_stippleenable }, WINED3D_GL_EXT_NONE },
4794	{ STATE_RENDER(WINED3DRS_MIPMAPLODBIAS), { STATE_RENDER(WINED3DRS_MIPMAPLODBIAS), state_mipmaplodbias }, WINED3D_GL_EXT_NONE },
4795	{ STATE_RENDER(WINED3DRS_ANISOTROPY), { STATE_RENDER(WINED3DRS_ANISOTROPY), state_anisotropy }, WINED3D_GL_EXT_NONE },
4796	{ STATE_RENDER(WINED3DRS_FLUSHBATCH), { STATE_RENDER(WINED3DRS_FLUSHBATCH), state_flushbatch }, WINED3D_GL_EXT_NONE },
4797	{ STATE_RENDER(WINED3DRS_TRANSLUCENTSORTINDEPENDENT), { STATE_RENDER(WINED3DRS_TRANSLUCENTSORTINDEPENDENT), state_translucentsi }, WINED3D_GL_EXT_NONE },
4798	{ STATE_RENDER(WINED3DRS_STENCILENABLE), { STATE_RENDER(WINED3DRS_STENCILENABLE), state_stencil }, WINED3D_GL_EXT_NONE },
4799	{ STATE_RENDER(WINED3DRS_STENCILFAIL), { STATE_RENDER(WINED3DRS_STENCILENABLE), state_stencil }, WINED3D_GL_EXT_NONE },
4800	{ STATE_RENDER(WINED3DRS_STENCILZFAIL), { STATE_RENDER(WINED3DRS_STENCILENABLE), state_stencil }, WINED3D_GL_EXT_NONE },
4801	{ STATE_RENDER(WINED3DRS_STENCILPASS), { STATE_RENDER(WINED3DRS_STENCILENABLE), state_stencil }, WINED3D_GL_EXT_NONE },
4802	{ STATE_RENDER(WINED3DRS_STENCILFUNC), { STATE_RENDER(WINED3DRS_STENCILENABLE), state_stencil }, WINED3D_GL_EXT_NONE },
4803	{ STATE_RENDER(WINED3DRS_STENCILREF), { STATE_RENDER(WINED3DRS_STENCILENABLE), state_stencil }, WINED3D_GL_EXT_NONE },
4804	{ STATE_RENDER(WINED3DRS_STENCILMASK), { STATE_RENDER(WINED3DRS_STENCILENABLE), state_stencil }, WINED3D_GL_EXT_NONE },
4805	{ STATE_RENDER(WINED3DRS_STENCILWRITEMASK), { STATE_RENDER(WINED3DRS_STENCILWRITEMASK), state_stencilwrite2s}, EXT_STENCIL_TWO_SIDE },
4806	{ STATE_RENDER(WINED3DRS_STENCILWRITEMASK), { STATE_RENDER(WINED3DRS_STENCILWRITEMASK), state_stencilwrite }, WINED3D_GL_EXT_NONE },
4807	{ STATE_RENDER(WINED3DRS_TWOSIDEDSTENCILMODE), { STATE_RENDER(WINED3DRS_STENCILENABLE), state_stencil }, WINED3D_GL_EXT_NONE },
4808	{ STATE_RENDER(WINED3DRS_CCW_STENCILFAIL), { STATE_RENDER(WINED3DRS_STENCILENABLE), state_stencil }, WINED3D_GL_EXT_NONE },
4809	{ STATE_RENDER(WINED3DRS_CCW_STENCILZFAIL), { STATE_RENDER(WINED3DRS_STENCILENABLE), state_stencil }, WINED3D_GL_EXT_NONE },
4810	{ STATE_RENDER(WINED3DRS_CCW_STENCILPASS), { STATE_RENDER(WINED3DRS_STENCILENABLE), state_stencil }, WINED3D_GL_EXT_NONE },
4811	{ STATE_RENDER(WINED3DRS_CCW_STENCILFUNC), { STATE_RENDER(WINED3DRS_STENCILENABLE), state_stencil }, WINED3D_GL_EXT_NONE },
4812	{ STATE_RENDER(WINED3DRS_WRAP0), { STATE_RENDER(WINED3DRS_WRAP0), state_wrap }, WINED3D_GL_EXT_NONE },
4813	{ STATE_RENDER(WINED3DRS_WRAP1), { STATE_RENDER(WINED3DRS_WRAP0), state_wrap }, WINED3D_GL_EXT_NONE },
4814	{ STATE_RENDER(WINED3DRS_WRAP2), { STATE_RENDER(WINED3DRS_WRAP0), state_wrap }, WINED3D_GL_EXT_NONE },
4815	{ STATE_RENDER(WINED3DRS_WRAP3), { STATE_RENDER(WINED3DRS_WRAP0), state_wrap }, WINED3D_GL_EXT_NONE },
4816	{ STATE_RENDER(WINED3DRS_WRAP4), { STATE_RENDER(WINED3DRS_WRAP0), state_wrap }, WINED3D_GL_EXT_NONE },
4817	{ STATE_RENDER(WINED3DRS_WRAP5), { STATE_RENDER(WINED3DRS_WRAP0), state_wrap }, WINED3D_GL_EXT_NONE },
4818	{ STATE_RENDER(WINED3DRS_WRAP6), { STATE_RENDER(WINED3DRS_WRAP0), state_wrap }, WINED3D_GL_EXT_NONE },
4819	{ STATE_RENDER(WINED3DRS_WRAP7), { STATE_RENDER(WINED3DRS_WRAP0), state_wrap }, WINED3D_GL_EXT_NONE },
4820	{ STATE_RENDER(WINED3DRS_WRAP8), { STATE_RENDER(WINED3DRS_WRAP0), state_wrap }, WINED3D_GL_EXT_NONE },
4821	{ STATE_RENDER(WINED3DRS_WRAP9), { STATE_RENDER(WINED3DRS_WRAP0), state_wrap }, WINED3D_GL_EXT_NONE },
4822	{ STATE_RENDER(WINED3DRS_WRAP10), { STATE_RENDER(WINED3DRS_WRAP0), state_wrap }, WINED3D_GL_EXT_NONE },
4823	{ STATE_RENDER(WINED3DRS_WRAP11), { STATE_RENDER(WINED3DRS_WRAP0), state_wrap }, WINED3D_GL_EXT_NONE },
4824	{ STATE_RENDER(WINED3DRS_WRAP12), { STATE_RENDER(WINED3DRS_WRAP0), state_wrap }, WINED3D_GL_EXT_NONE },
4825	{ STATE_RENDER(WINED3DRS_WRAP13), { STATE_RENDER(WINED3DRS_WRAP0), state_wrap }, WINED3D_GL_EXT_NONE },
4826	{ STATE_RENDER(WINED3DRS_WRAP14), { STATE_RENDER(WINED3DRS_WRAP0), state_wrap }, WINED3D_GL_EXT_NONE },
4827	{ STATE_RENDER(WINED3DRS_WRAP15), { STATE_RENDER(WINED3DRS_WRAP0), state_wrap }, WINED3D_GL_EXT_NONE },
4828	{ STATE_RENDER(WINED3DRS_EXTENTS), { STATE_RENDER(WINED3DRS_EXTENTS), state_extents }, WINED3D_GL_EXT_NONE },
4829	{ STATE_RENDER(WINED3DRS_COLORKEYBLENDENABLE), { STATE_RENDER(WINED3DRS_COLORKEYBLENDENABLE), state_ckeyblend }, WINED3D_GL_EXT_NONE },
4830	{ STATE_RENDER(WINED3DRS_PATCHEDGESTYLE), { STATE_RENDER(WINED3DRS_PATCHEDGESTYLE), state_patchedgestyle}, WINED3D_GL_EXT_NONE },
4831	{ STATE_RENDER(WINED3DRS_PATCHSEGMENTS), { STATE_RENDER(WINED3DRS_PATCHSEGMENTS), state_patchsegments }, WINED3D_GL_EXT_NONE },
4832	{ STATE_RENDER(WINED3DRS_POSITIONDEGREE), { STATE_RENDER(WINED3DRS_POSITIONDEGREE), state_positiondegree}, WINED3D_GL_EXT_NONE },
4833	{ STATE_RENDER(WINED3DRS_NORMALDEGREE), { STATE_RENDER(WINED3DRS_NORMALDEGREE), state_normaldegree }, WINED3D_GL_EXT_NONE },
4834	{ STATE_RENDER(WINED3DRS_MINTESSELLATIONLEVEL), { STATE_RENDER(WINED3DRS_ENABLEADAPTIVETESSELLATION), state_tessellation }, WINED3D_GL_EXT_NONE },
4835	{ STATE_RENDER(WINED3DRS_MAXTESSELLATIONLEVEL), { STATE_RENDER(WINED3DRS_ENABLEADAPTIVETESSELLATION), state_tessellation }, WINED3D_GL_EXT_NONE },
4836	{ STATE_RENDER(WINED3DRS_ADAPTIVETESS_X), { STATE_RENDER(WINED3DRS_ENABLEADAPTIVETESSELLATION), state_tessellation }, WINED3D_GL_EXT_NONE },
4837	{ STATE_RENDER(WINED3DRS_ADAPTIVETESS_Y), { STATE_RENDER(WINED3DRS_ENABLEADAPTIVETESSELLATION), state_tessellation }, WINED3D_GL_EXT_NONE },
4838	{ STATE_RENDER(WINED3DRS_ADAPTIVETESS_Z), { STATE_RENDER(WINED3DRS_ENABLEADAPTIVETESSELLATION), state_tessellation }, WINED3D_GL_EXT_NONE },
4839	{ STATE_RENDER(WINED3DRS_ADAPTIVETESS_W), { STATE_RENDER(WINED3DRS_ENABLEADAPTIVETESSELLATION), state_tessellation }, WINED3D_GL_EXT_NONE },
4840	{ STATE_RENDER(WINED3DRS_ENABLEADAPTIVETESSELLATION), { STATE_RENDER(WINED3DRS_ENABLEADAPTIVETESSELLATION), state_tessellation }, WINED3D_GL_EXT_NONE },
4841	{ STATE_RENDER(WINED3DRS_MULTISAMPLEANTIALIAS), { STATE_RENDER(WINED3DRS_MULTISAMPLEANTIALIAS), state_msaa }, ARB_MULTISAMPLE },
4842	{ STATE_RENDER(WINED3DRS_MULTISAMPLEANTIALIAS), { STATE_RENDER(WINED3DRS_MULTISAMPLEANTIALIAS), state_msaa_w }, WINED3D_GL_EXT_NONE },
4843	{ STATE_RENDER(WINED3DRS_MULTISAMPLEMASK), { STATE_RENDER(WINED3DRS_MULTISAMPLEMASK), state_multisampmask }, WINED3D_GL_EXT_NONE },
4844	{ STATE_RENDER(WINED3DRS_COLORWRITEENABLE), { STATE_RENDER(WINED3DRS_COLORWRITEENABLE), state_colorwrite }, WINED3D_GL_EXT_NONE },
4845	{ STATE_RENDER(WINED3DRS_BLENDOP), { STATE_RENDER(WINED3DRS_BLENDOP), state_blendop }, EXT_BLEND_MINMAX },
4846	{ STATE_RENDER(WINED3DRS_BLENDOP), { STATE_RENDER(WINED3DRS_BLENDOP), state_blendop_w }, WINED3D_GL_EXT_NONE },
4847	{ STATE_RENDER(WINED3DRS_SCISSORTESTENABLE), { STATE_RENDER(WINED3DRS_SCISSORTESTENABLE), state_scissor }, WINED3D_GL_EXT_NONE },
4848	{ STATE_RENDER(WINED3DRS_SLOPESCALEDEPTHBIAS), { STATE_RENDER(WINED3DRS_DEPTHBIAS), state_depthbias }, WINED3D_GL_EXT_NONE },
4849	{ STATE_RENDER(WINED3DRS_COLORWRITEENABLE1), { STATE_RENDER(WINED3DRS_COLORWRITEENABLE), state_colorwrite }, WINED3D_GL_EXT_NONE },
4850	{ STATE_RENDER(WINED3DRS_COLORWRITEENABLE2), { STATE_RENDER(WINED3DRS_COLORWRITEENABLE), state_colorwrite }, WINED3D_GL_EXT_NONE },
4851	{ STATE_RENDER(WINED3DRS_COLORWRITEENABLE3), { STATE_RENDER(WINED3DRS_COLORWRITEENABLE), state_colorwrite }, WINED3D_GL_EXT_NONE },
4852	{ STATE_RENDER(WINED3DRS_BLENDFACTOR), { STATE_RENDER(WINED3DRS_BLENDFACTOR), state_blendfactor }, EXT_BLEND_COLOR },
4853	{ STATE_RENDER(WINED3DRS_BLENDFACTOR), { STATE_RENDER(WINED3DRS_BLENDFACTOR), state_blendfactor_w }, WINED3D_GL_EXT_NONE },
4854	{ STATE_RENDER(WINED3DRS_DEPTHBIAS), { STATE_RENDER(WINED3DRS_DEPTHBIAS), state_depthbias }, WINED3D_GL_EXT_NONE },
4855	/* Samplers */
4856	{ STATE_SAMPLER(0), { STATE_SAMPLER(0), sampler }, WINED3D_GL_EXT_NONE },
4857	{ STATE_SAMPLER(1), { STATE_SAMPLER(1), sampler }, WINED3D_GL_EXT_NONE },
4858	{ STATE_SAMPLER(2), { STATE_SAMPLER(2), sampler }, WINED3D_GL_EXT_NONE },
4859	{ STATE_SAMPLER(3), { STATE_SAMPLER(3), sampler }, WINED3D_GL_EXT_NONE },
4860	{ STATE_SAMPLER(4), { STATE_SAMPLER(4), sampler }, WINED3D_GL_EXT_NONE },
4861	{ STATE_SAMPLER(5), { STATE_SAMPLER(5), sampler }, WINED3D_GL_EXT_NONE },
4862	{ STATE_SAMPLER(6), { STATE_SAMPLER(6), sampler }, WINED3D_GL_EXT_NONE },
4863	{ STATE_SAMPLER(7), { STATE_SAMPLER(7), sampler }, WINED3D_GL_EXT_NONE },
4864	{ STATE_SAMPLER(8), { STATE_SAMPLER(8), sampler }, WINED3D_GL_EXT_NONE },
4865	{ STATE_SAMPLER(9), { STATE_SAMPLER(9), sampler }, WINED3D_GL_EXT_NONE },
4866	{ STATE_SAMPLER(10), { STATE_SAMPLER(10), sampler }, WINED3D_GL_EXT_NONE },
4867	{ STATE_SAMPLER(11), { STATE_SAMPLER(11), sampler }, WINED3D_GL_EXT_NONE },
4868	{ STATE_SAMPLER(12), { STATE_SAMPLER(12), sampler }, WINED3D_GL_EXT_NONE },
4869	{ STATE_SAMPLER(13), { STATE_SAMPLER(13), sampler }, WINED3D_GL_EXT_NONE },
4870	{ STATE_SAMPLER(14), { STATE_SAMPLER(14), sampler }, WINED3D_GL_EXT_NONE },
4871	{ STATE_SAMPLER(15), { STATE_SAMPLER(15), sampler }, WINED3D_GL_EXT_NONE },
4872	{ STATE_SAMPLER(16), /* Vertex sampler 0 */ { STATE_SAMPLER(16), sampler }, WINED3D_GL_EXT_NONE },
4873	{ STATE_SAMPLER(17), /* Vertex sampler 1 */ { STATE_SAMPLER(17), sampler }, WINED3D_GL_EXT_NONE },
4874	{ STATE_SAMPLER(18), /* Vertex sampler 2 */ { STATE_SAMPLER(18), sampler }, WINED3D_GL_EXT_NONE },
4875	{ STATE_SAMPLER(19), /* Vertex sampler 3 */ { STATE_SAMPLER(19), sampler }, WINED3D_GL_EXT_NONE },
4876	{0 /* Terminate */, { 0, 0 }, WINED3D_GL_EXT_NONE },
4877	};
4878
4879	const struct StateEntryTemplate ffp_vertexstate_template[] = {
4880	{ STATE_VDECL, { STATE_VDECL, vertexdeclaration }, WINED3D_GL_EXT_NONE },
4881	{ STATE_VSHADER, { STATE_VDECL, vertexdeclaration }, WINED3D_GL_EXT_NONE },
4882	{ STATE_MATERIAL, { STATE_RENDER(WINED3DRS_SPECULARENABLE), state_specularenable}, WINED3D_GL_EXT_NONE },
4883	{ STATE_RENDER(WINED3DRS_SPECULARENABLE), { STATE_RENDER(WINED3DRS_SPECULARENABLE), state_specularenable}, WINED3D_GL_EXT_NONE },
4884	/* Clip planes */
4885	{ STATE_CLIPPLANE(0), { STATE_CLIPPLANE(0), clipplane }, WINED3D_GL_EXT_NONE },
4886	{ STATE_CLIPPLANE(1), { STATE_CLIPPLANE(1), clipplane }, WINED3D_GL_EXT_NONE },
4887	{ STATE_CLIPPLANE(2), { STATE_CLIPPLANE(2), clipplane }, WINED3D_GL_EXT_NONE },
4888	{ STATE_CLIPPLANE(3), { STATE_CLIPPLANE(3), clipplane }, WINED3D_GL_EXT_NONE },
4889	{ STATE_CLIPPLANE(4), { STATE_CLIPPLANE(4), clipplane }, WINED3D_GL_EXT_NONE },
4890	{ STATE_CLIPPLANE(5), { STATE_CLIPPLANE(5), clipplane }, WINED3D_GL_EXT_NONE },
4891	{ STATE_CLIPPLANE(6), { STATE_CLIPPLANE(6), clipplane }, WINED3D_GL_EXT_NONE },
4892	{ STATE_CLIPPLANE(7), { STATE_CLIPPLANE(7), clipplane }, WINED3D_GL_EXT_NONE },
4893	{ STATE_CLIPPLANE(8), { STATE_CLIPPLANE(8), clipplane }, WINED3D_GL_EXT_NONE },
4894	{ STATE_CLIPPLANE(9), { STATE_CLIPPLANE(9), clipplane }, WINED3D_GL_EXT_NONE },
4895	{ STATE_CLIPPLANE(10), { STATE_CLIPPLANE(10), clipplane }, WINED3D_GL_EXT_NONE },
4896	{ STATE_CLIPPLANE(11), { STATE_CLIPPLANE(11), clipplane }, WINED3D_GL_EXT_NONE },
4897	{ STATE_CLIPPLANE(12), { STATE_CLIPPLANE(12), clipplane }, WINED3D_GL_EXT_NONE },
4898	{ STATE_CLIPPLANE(13), { STATE_CLIPPLANE(13), clipplane }, WINED3D_GL_EXT_NONE },
4899	{ STATE_CLIPPLANE(14), { STATE_CLIPPLANE(14), clipplane }, WINED3D_GL_EXT_NONE },
4900	{ STATE_CLIPPLANE(15), { STATE_CLIPPLANE(15), clipplane }, WINED3D_GL_EXT_NONE },
4901	{ STATE_CLIPPLANE(16), { STATE_CLIPPLANE(16), clipplane }, WINED3D_GL_EXT_NONE },
4902	{ STATE_CLIPPLANE(17), { STATE_CLIPPLANE(17), clipplane }, WINED3D_GL_EXT_NONE },
4903	{ STATE_CLIPPLANE(18), { STATE_CLIPPLANE(18), clipplane }, WINED3D_GL_EXT_NONE },
4904	{ STATE_CLIPPLANE(19), { STATE_CLIPPLANE(19), clipplane }, WINED3D_GL_EXT_NONE },
4905	{ STATE_CLIPPLANE(20), { STATE_CLIPPLANE(20), clipplane }, WINED3D_GL_EXT_NONE },
4906	{ STATE_CLIPPLANE(21), { STATE_CLIPPLANE(21), clipplane }, WINED3D_GL_EXT_NONE },
4907	{ STATE_CLIPPLANE(22), { STATE_CLIPPLANE(22), clipplane }, WINED3D_GL_EXT_NONE },
4908	{ STATE_CLIPPLANE(23), { STATE_CLIPPLANE(23), clipplane }, WINED3D_GL_EXT_NONE },
4909	{ STATE_CLIPPLANE(24), { STATE_CLIPPLANE(24), clipplane }, WINED3D_GL_EXT_NONE },
4910	{ STATE_CLIPPLANE(25), { STATE_CLIPPLANE(25), clipplane }, WINED3D_GL_EXT_NONE },
4911	{ STATE_CLIPPLANE(26), { STATE_CLIPPLANE(26), clipplane }, WINED3D_GL_EXT_NONE },
4912	{ STATE_CLIPPLANE(27), { STATE_CLIPPLANE(27), clipplane }, WINED3D_GL_EXT_NONE },
4913	{ STATE_CLIPPLANE(28), { STATE_CLIPPLANE(28), clipplane }, WINED3D_GL_EXT_NONE },
4914	{ STATE_CLIPPLANE(29), { STATE_CLIPPLANE(29), clipplane }, WINED3D_GL_EXT_NONE },
4915	{ STATE_CLIPPLANE(30), { STATE_CLIPPLANE(30), clipplane }, WINED3D_GL_EXT_NONE },
4916	{ STATE_CLIPPLANE(31), { STATE_CLIPPLANE(31), clipplane }, WINED3D_GL_EXT_NONE },
4917	/* Lights */
4918	{ STATE_ACTIVELIGHT(0), { STATE_ACTIVELIGHT(0), light }, WINED3D_GL_EXT_NONE },
4919	{ STATE_ACTIVELIGHT(1), { STATE_ACTIVELIGHT(1), light }, WINED3D_GL_EXT_NONE },
4920	{ STATE_ACTIVELIGHT(2), { STATE_ACTIVELIGHT(2), light }, WINED3D_GL_EXT_NONE },
4921	{ STATE_ACTIVELIGHT(3), { STATE_ACTIVELIGHT(3), light }, WINED3D_GL_EXT_NONE },
4922	{ STATE_ACTIVELIGHT(4), { STATE_ACTIVELIGHT(4), light }, WINED3D_GL_EXT_NONE },
4923	{ STATE_ACTIVELIGHT(5), { STATE_ACTIVELIGHT(5), light }, WINED3D_GL_EXT_NONE },
4924	{ STATE_ACTIVELIGHT(6), { STATE_ACTIVELIGHT(6), light }, WINED3D_GL_EXT_NONE },
4925	{ STATE_ACTIVELIGHT(7), { STATE_ACTIVELIGHT(7), light }, WINED3D_GL_EXT_NONE },
4926	/* Viewport */
4927	{ STATE_VIEWPORT, { STATE_VIEWPORT, viewport_vertexpart }, WINED3D_GL_EXT_NONE },
4928	/* Transform states follow */
4929	{ STATE_TRANSFORM(WINED3DTS_VIEW), { STATE_TRANSFORM(WINED3DTS_VIEW), transform_view }, WINED3D_GL_EXT_NONE },
4930	{ STATE_TRANSFORM(WINED3DTS_PROJECTION), { STATE_TRANSFORM(WINED3DTS_PROJECTION), transform_projection}, WINED3D_GL_EXT_NONE },
4931	{ STATE_TRANSFORM(WINED3DTS_TEXTURE0), { STATE_TEXTURESTAGE(0,WINED3DTSS_TEXTURETRANSFORMFLAGS), transform_texture }, WINED3D_GL_EXT_NONE },
4932	{ STATE_TRANSFORM(WINED3DTS_TEXTURE1), { STATE_TEXTURESTAGE(1,WINED3DTSS_TEXTURETRANSFORMFLAGS), transform_texture }, WINED3D_GL_EXT_NONE },
4933	{ STATE_TRANSFORM(WINED3DTS_TEXTURE2), { STATE_TEXTURESTAGE(2,WINED3DTSS_TEXTURETRANSFORMFLAGS), transform_texture }, WINED3D_GL_EXT_NONE },
4934	{ STATE_TRANSFORM(WINED3DTS_TEXTURE3), { STATE_TEXTURESTAGE(3,WINED3DTSS_TEXTURETRANSFORMFLAGS), transform_texture }, WINED3D_GL_EXT_NONE },
4935	{ STATE_TRANSFORM(WINED3DTS_TEXTURE4), { STATE_TEXTURESTAGE(4,WINED3DTSS_TEXTURETRANSFORMFLAGS), transform_texture }, WINED3D_GL_EXT_NONE },
4936	{ STATE_TRANSFORM(WINED3DTS_TEXTURE5), { STATE_TEXTURESTAGE(5,WINED3DTSS_TEXTURETRANSFORMFLAGS), transform_texture }, WINED3D_GL_EXT_NONE },
4937	{ STATE_TRANSFORM(WINED3DTS_TEXTURE6), { STATE_TEXTURESTAGE(6,WINED3DTSS_TEXTURETRANSFORMFLAGS), transform_texture }, WINED3D_GL_EXT_NONE },
4938	{ STATE_TRANSFORM(WINED3DTS_TEXTURE7), { STATE_TEXTURESTAGE(7,WINED3DTSS_TEXTURETRANSFORMFLAGS), transform_texture }, WINED3D_GL_EXT_NONE },
4939	{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 0)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 0)), transform_world }, WINED3D_GL_EXT_NONE },
4940	{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 1)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 1)), transform_worldex }, WINED3D_GL_EXT_NONE },
4941	{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 2)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 2)), transform_worldex }, WINED3D_GL_EXT_NONE },
4942	{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 3)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 3)), transform_worldex }, WINED3D_GL_EXT_NONE },
4943	{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 4)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 4)), transform_worldex }, WINED3D_GL_EXT_NONE },
4944	{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 5)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 5)), transform_worldex }, WINED3D_GL_EXT_NONE },
4945	{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 6)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 6)), transform_worldex }, WINED3D_GL_EXT_NONE },
4946	{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 7)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 7)), transform_worldex }, WINED3D_GL_EXT_NONE },
4947	{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 8)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 8)), transform_worldex }, WINED3D_GL_EXT_NONE },
4948	{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 9)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 9)), transform_worldex }, WINED3D_GL_EXT_NONE },
4949	{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 10)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 10)), transform_worldex }, WINED3D_GL_EXT_NONE },
4950	{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 11)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 11)), transform_worldex }, WINED3D_GL_EXT_NONE },
4951	{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 12)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 12)), transform_worldex }, WINED3D_GL_EXT_NONE },
4952	{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 13)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 13)), transform_worldex }, WINED3D_GL_EXT_NONE },
4953	{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 14)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 14)), transform_worldex }, WINED3D_GL_EXT_NONE },
4954	{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 15)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 15)), transform_worldex }, WINED3D_GL_EXT_NONE },
4955	{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 16)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 16)), transform_worldex }, WINED3D_GL_EXT_NONE },
4956	{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 17)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 17)), transform_worldex }, WINED3D_GL_EXT_NONE },
4957	{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 18)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 18)), transform_worldex }, WINED3D_GL_EXT_NONE },
4958	{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 19)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 19)), transform_worldex }, WINED3D_GL_EXT_NONE },
4959	{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 20)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 20)), transform_worldex }, WINED3D_GL_EXT_NONE },
4960	{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 21)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 21)), transform_worldex }, WINED3D_GL_EXT_NONE },
4961	{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 22)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 22)), transform_worldex }, WINED3D_GL_EXT_NONE },
4962	{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 23)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 23)), transform_worldex }, WINED3D_GL_EXT_NONE },
4963	{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 24)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 24)), transform_worldex }, WINED3D_GL_EXT_NONE },
4964	{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 25)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 25)), transform_worldex }, WINED3D_GL_EXT_NONE },
4965	{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 26)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 26)), transform_worldex }, WINED3D_GL_EXT_NONE },
4966	{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 27)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 27)), transform_worldex }, WINED3D_GL_EXT_NONE },
4967	{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 28)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 28)), transform_worldex }, WINED3D_GL_EXT_NONE },
4968	{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 29)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 29)), transform_worldex }, WINED3D_GL_EXT_NONE },
4969	{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 30)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 30)), transform_worldex }, WINED3D_GL_EXT_NONE },
4970	{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 31)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 31)), transform_worldex }, WINED3D_GL_EXT_NONE },
4971	{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 32)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 32)), transform_worldex }, WINED3D_GL_EXT_NONE },
4972	{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 33)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 33)), transform_worldex }, WINED3D_GL_EXT_NONE },
4973	{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 34)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 34)), transform_worldex }, WINED3D_GL_EXT_NONE },
4974	{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 35)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 35)), transform_worldex }, WINED3D_GL_EXT_NONE },
4975	{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 36)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 36)), transform_worldex }, WINED3D_GL_EXT_NONE },
4976	{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 37)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 37)), transform_worldex }, WINED3D_GL_EXT_NONE },
4977	{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 38)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 38)), transform_worldex }, WINED3D_GL_EXT_NONE },
4978	{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 39)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 39)), transform_worldex }, WINED3D_GL_EXT_NONE },
4979	{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 40)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 40)), transform_worldex }, WINED3D_GL_EXT_NONE },
4980	{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 41)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 41)), transform_worldex }, WINED3D_GL_EXT_NONE },
4981	{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 42)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 42)), transform_worldex }, WINED3D_GL_EXT_NONE },
4982	{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 43)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 43)), transform_worldex }, WINED3D_GL_EXT_NONE },
4983	{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 44)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 44)), transform_worldex }, WINED3D_GL_EXT_NONE },
4984	{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 45)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 45)), transform_worldex }, WINED3D_GL_EXT_NONE },
4985	{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 46)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 46)), transform_worldex }, WINED3D_GL_EXT_NONE },
4986	{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 47)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 47)), transform_worldex }, WINED3D_GL_EXT_NONE },
4987	{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 48)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 48)), transform_worldex }, WINED3D_GL_EXT_NONE },
4988	{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 49)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 49)), transform_worldex }, WINED3D_GL_EXT_NONE },
4989	{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 50)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 50)), transform_worldex }, WINED3D_GL_EXT_NONE },
4990	{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 51)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 51)), transform_worldex }, WINED3D_GL_EXT_NONE },
4991	{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 52)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 52)), transform_worldex }, WINED3D_GL_EXT_NONE },
4992	{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 53)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 53)), transform_worldex }, WINED3D_GL_EXT_NONE },
4993	{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 54)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 54)), transform_worldex }, WINED3D_GL_EXT_NONE },
4994	{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 55)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 55)), transform_worldex }, WINED3D_GL_EXT_NONE },
4995	{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 56)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 56)), transform_worldex }, WINED3D_GL_EXT_NONE },
4996	{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 57)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 57)), transform_worldex }, WINED3D_GL_EXT_NONE },
4997	{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 58)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 58)), transform_worldex }, WINED3D_GL_EXT_NONE },
4998	{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 59)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 59)), transform_worldex }, WINED3D_GL_EXT_NONE },
4999	{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 60)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 60)), transform_worldex }, WINED3D_GL_EXT_NONE },
5000	{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 61)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 61)), transform_worldex }, WINED3D_GL_EXT_NONE },
5001	{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 62)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 62)), transform_worldex }, WINED3D_GL_EXT_NONE },
5002	{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 63)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 63)), transform_worldex }, WINED3D_GL_EXT_NONE },
5003	{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 64)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 64)), transform_worldex }, WINED3D_GL_EXT_NONE },
5004	{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 65)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 65)), transform_worldex }, WINED3D_GL_EXT_NONE },
5005	{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 66)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 66)), transform_worldex }, WINED3D_GL_EXT_NONE },
5006	{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 67)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 67)), transform_worldex }, WINED3D_GL_EXT_NONE },
5007	{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 68)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 68)), transform_worldex }, WINED3D_GL_EXT_NONE },
5008	{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 69)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 69)), transform_worldex }, WINED3D_GL_EXT_NONE },
5009	{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 70)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 70)), transform_worldex }, WINED3D_GL_EXT_NONE },
5010	{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 71)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 71)), transform_worldex }, WINED3D_GL_EXT_NONE },
5011	{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 72)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 72)), transform_worldex }, WINED3D_GL_EXT_NONE },
5012	{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 73)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 73)), transform_worldex }, WINED3D_GL_EXT_NONE },
5013	{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 74)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 74)), transform_worldex }, WINED3D_GL_EXT_NONE },
5014	{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 75)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 75)), transform_worldex }, WINED3D_GL_EXT_NONE },
5015	{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 76)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 76)), transform_worldex }, WINED3D_GL_EXT_NONE },
5016	{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 77)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 77)), transform_worldex }, WINED3D_GL_EXT_NONE },
5017	{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 78)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 78)), transform_worldex }, WINED3D_GL_EXT_NONE },
5018	{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 79)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 79)), transform_worldex }, WINED3D_GL_EXT_NONE },
5019	{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 80)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 80)), transform_worldex }, WINED3D_GL_EXT_NONE },
5020	{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 81)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 81)), transform_worldex }, WINED3D_GL_EXT_NONE },
5021	{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 82)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 82)), transform_worldex }, WINED3D_GL_EXT_NONE },
5022	{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 83)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 83)), transform_worldex }, WINED3D_GL_EXT_NONE },
5023	{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 84)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 84)), transform_worldex }, WINED3D_GL_EXT_NONE },
5024	{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 85)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 85)), transform_worldex }, WINED3D_GL_EXT_NONE },
5025	{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 86)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 86)), transform_worldex }, WINED3D_GL_EXT_NONE },
5026	{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 87)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 87)), transform_worldex }, WINED3D_GL_EXT_NONE },
5027	{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 88)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 88)), transform_worldex }, WINED3D_GL_EXT_NONE },
5028	{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 89)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 89)), transform_worldex }, WINED3D_GL_EXT_NONE },
5029	{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 90)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 90)), transform_worldex }, WINED3D_GL_EXT_NONE },
5030	{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 91)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 91)), transform_worldex }, WINED3D_GL_EXT_NONE },
5031	{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 92)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 92)), transform_worldex }, WINED3D_GL_EXT_NONE },
5032	{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 93)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 93)), transform_worldex }, WINED3D_GL_EXT_NONE },
5033	{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 94)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 94)), transform_worldex }, WINED3D_GL_EXT_NONE },
5034	{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 95)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 95)), transform_worldex }, WINED3D_GL_EXT_NONE },
5035	{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 96)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 96)), transform_worldex }, WINED3D_GL_EXT_NONE },
5036	{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 97)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 97)), transform_worldex }, WINED3D_GL_EXT_NONE },
5037	{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 98)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 98)), transform_worldex }, WINED3D_GL_EXT_NONE },
5038	{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 99)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 99)), transform_worldex }, WINED3D_GL_EXT_NONE },
5039	{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(100)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(100)), transform_worldex }, WINED3D_GL_EXT_NONE },
5040	{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(101)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(101)), transform_worldex }, WINED3D_GL_EXT_NONE },
5041	{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(102)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(102)), transform_worldex }, WINED3D_GL_EXT_NONE },
5042	{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(103)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(103)), transform_worldex }, WINED3D_GL_EXT_NONE },
5043	{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(104)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(104)), transform_worldex }, WINED3D_GL_EXT_NONE },
5044	{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(105)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(105)), transform_worldex }, WINED3D_GL_EXT_NONE },
5045	{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(106)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(106)), transform_worldex }, WINED3D_GL_EXT_NONE },
5046	{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(107)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(107)), transform_worldex }, WINED3D_GL_EXT_NONE },
5047	{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(108)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(108)), transform_worldex }, WINED3D_GL_EXT_NONE },
5048	{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(109)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(109)), transform_worldex }, WINED3D_GL_EXT_NONE },
5049	{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(110)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(110)), transform_worldex }, WINED3D_GL_EXT_NONE },
5050	{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(111)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(111)), transform_worldex }, WINED3D_GL_EXT_NONE },
5051	{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(112)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(112)), transform_worldex }, WINED3D_GL_EXT_NONE },
5052	{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(113)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(113)), transform_worldex }, WINED3D_GL_EXT_NONE },
5053	{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(114)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(114)), transform_worldex }, WINED3D_GL_EXT_NONE },
5054	{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(115)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(115)), transform_worldex }, WINED3D_GL_EXT_NONE },
5055	{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(116)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(116)), transform_worldex }, WINED3D_GL_EXT_NONE },
5056	{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(117)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(117)), transform_worldex }, WINED3D_GL_EXT_NONE },
5057	{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(118)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(118)), transform_worldex }, WINED3D_GL_EXT_NONE },
5058	{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(119)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(119)), transform_worldex }, WINED3D_GL_EXT_NONE },
5059	{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(120)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(120)), transform_worldex }, WINED3D_GL_EXT_NONE },
5060	{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(121)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(121)), transform_worldex }, WINED3D_GL_EXT_NONE },
5061	{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(122)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(122)), transform_worldex }, WINED3D_GL_EXT_NONE },
5062	{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(123)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(123)), transform_worldex }, WINED3D_GL_EXT_NONE },
5063	{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(124)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(124)), transform_worldex }, WINED3D_GL_EXT_NONE },
5064	{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(125)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(125)), transform_worldex }, WINED3D_GL_EXT_NONE },
5065	{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(126)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(126)), transform_worldex }, WINED3D_GL_EXT_NONE },
5066	{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(127)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(127)), transform_worldex }, WINED3D_GL_EXT_NONE },
5067	{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(128)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(128)), transform_worldex }, WINED3D_GL_EXT_NONE },
5068	{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(129)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(129)), transform_worldex }, WINED3D_GL_EXT_NONE },
5069	{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(130)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(130)), transform_worldex }, WINED3D_GL_EXT_NONE },
5070	{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(131)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(131)), transform_worldex }, WINED3D_GL_EXT_NONE },
5071	{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(132)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(132)), transform_worldex }, WINED3D_GL_EXT_NONE },
5072	{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(133)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(133)), transform_worldex }, WINED3D_GL_EXT_NONE },
5073	{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(134)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(134)), transform_worldex }, WINED3D_GL_EXT_NONE },
5074	{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(135)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(135)), transform_worldex }, WINED3D_GL_EXT_NONE },
5075	{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(136)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(136)), transform_worldex }, WINED3D_GL_EXT_NONE },
5076	{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(137)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(137)), transform_worldex }, WINED3D_GL_EXT_NONE },
5077	{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(138)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(138)), transform_worldex }, WINED3D_GL_EXT_NONE },
5078	{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(139)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(139)), transform_worldex }, WINED3D_GL_EXT_NONE },
5079	{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(140)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(140)), transform_worldex }, WINED3D_GL_EXT_NONE },
5080	{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(141)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(141)), transform_worldex }, WINED3D_GL_EXT_NONE },
5081	{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(142)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(142)), transform_worldex }, WINED3D_GL_EXT_NONE },
5082	{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(143)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(143)), transform_worldex }, WINED3D_GL_EXT_NONE },
5083	{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(144)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(144)), transform_worldex }, WINED3D_GL_EXT_NONE },
5084	{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(145)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(145)), transform_worldex }, WINED3D_GL_EXT_NONE },
5085	{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(146)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(146)), transform_worldex }, WINED3D_GL_EXT_NONE },
5086	{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(147)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(147)), transform_worldex }, WINED3D_GL_EXT_NONE },
5087	{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(148)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(148)), transform_worldex }, WINED3D_GL_EXT_NONE },
5088	{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(149)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(149)), transform_worldex }, WINED3D_GL_EXT_NONE },
5089	{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(150)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(150)), transform_worldex }, WINED3D_GL_EXT_NONE },
5090	{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(151)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(151)), transform_worldex }, WINED3D_GL_EXT_NONE },
5091	{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(152)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(152)), transform_worldex }, WINED3D_GL_EXT_NONE },
5092	{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(153)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(153)), transform_worldex }, WINED3D_GL_EXT_NONE },
5093	{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(154)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(154)), transform_worldex }, WINED3D_GL_EXT_NONE },
5094	{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(155)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(155)), transform_worldex }, WINED3D_GL_EXT_NONE },
5095	{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(156)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(156)), transform_worldex }, WINED3D_GL_EXT_NONE },
5096	{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(157)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(157)), transform_worldex }, WINED3D_GL_EXT_NONE },
5097	{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(158)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(158)), transform_worldex }, WINED3D_GL_EXT_NONE },
5098	{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(159)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(159)), transform_worldex }, WINED3D_GL_EXT_NONE },
5099	{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(160)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(160)), transform_worldex }, WINED3D_GL_EXT_NONE },
5100	{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(161)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(161)), transform_worldex }, WINED3D_GL_EXT_NONE },
5101	{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(162)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(162)), transform_worldex }, WINED3D_GL_EXT_NONE },
5102	{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(163)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(163)), transform_worldex }, WINED3D_GL_EXT_NONE },
5103	{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(164)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(164)), transform_worldex }, WINED3D_GL_EXT_NONE },
5104	{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(165)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(165)), transform_worldex }, WINED3D_GL_EXT_NONE },
5105	{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(166)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(166)), transform_worldex }, WINED3D_GL_EXT_NONE },
5106	{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(167)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(167)), transform_worldex }, WINED3D_GL_EXT_NONE },
5107	{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(168)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(168)), transform_worldex }, WINED3D_GL_EXT_NONE },
5108	{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(169)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(169)), transform_worldex }, WINED3D_GL_EXT_NONE },
5109	{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(170)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(170)), transform_worldex }, WINED3D_GL_EXT_NONE },
5110	{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(171)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(171)), transform_worldex }, WINED3D_GL_EXT_NONE },
5111	{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(172)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(172)), transform_worldex }, WINED3D_GL_EXT_NONE },
5112	{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(173)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(173)), transform_worldex }, WINED3D_GL_EXT_NONE },
5113	{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(174)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(174)), transform_worldex }, WINED3D_GL_EXT_NONE },
5114	{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(175)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(175)), transform_worldex }, WINED3D_GL_EXT_NONE },
5115	{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(176)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(176)), transform_worldex }, WINED3D_GL_EXT_NONE },
5116	{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(177)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(177)), transform_worldex }, WINED3D_GL_EXT_NONE },
5117	{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(178)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(178)), transform_worldex }, WINED3D_GL_EXT_NONE },
5118	{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(179)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(179)), transform_worldex }, WINED3D_GL_EXT_NONE },
5119	{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(180)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(180)), transform_worldex }, WINED3D_GL_EXT_NONE },
5120	{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(181)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(181)), transform_worldex }, WINED3D_GL_EXT_NONE },
5121	{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(182)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(182)), transform_worldex }, WINED3D_GL_EXT_NONE },
5122	{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(183)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(183)), transform_worldex }, WINED3D_GL_EXT_NONE },
5123	{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(184)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(184)), transform_worldex }, WINED3D_GL_EXT_NONE },
5124	{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(185)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(185)), transform_worldex }, WINED3D_GL_EXT_NONE },
5125	{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(186)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(186)), transform_worldex }, WINED3D_GL_EXT_NONE },
5126	{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(187)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(187)), transform_worldex }, WINED3D_GL_EXT_NONE },
5127	{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(188)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(188)), transform_worldex }, WINED3D_GL_EXT_NONE },
5128	{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(189)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(189)), transform_worldex }, WINED3D_GL_EXT_NONE },
5129	{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(190)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(190)), transform_worldex }, WINED3D_GL_EXT_NONE },
5130	{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(191)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(191)), transform_worldex }, WINED3D_GL_EXT_NONE },
5131	{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(192)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(192)), transform_worldex }, WINED3D_GL_EXT_NONE },
5132	{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(193)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(193)), transform_worldex }, WINED3D_GL_EXT_NONE },
5133	{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(194)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(194)), transform_worldex }, WINED3D_GL_EXT_NONE },
5134	{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(195)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(195)), transform_worldex }, WINED3D_GL_EXT_NONE },
5135	{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(196)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(196)), transform_worldex }, WINED3D_GL_EXT_NONE },
5136	{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(197)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(197)), transform_worldex }, WINED3D_GL_EXT_NONE },
5137	{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(198)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(198)), transform_worldex }, WINED3D_GL_EXT_NONE },
5138	{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(199)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(199)), transform_worldex }, WINED3D_GL_EXT_NONE },
5139	{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(200)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(200)), transform_worldex }, WINED3D_GL_EXT_NONE },
5140	{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(201)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(201)), transform_worldex }, WINED3D_GL_EXT_NONE },
5141	{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(202)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(202)), transform_worldex }, WINED3D_GL_EXT_NONE },
5142	{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(203)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(203)), transform_worldex }, WINED3D_GL_EXT_NONE },
5143	{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(204)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(204)), transform_worldex }, WINED3D_GL_EXT_NONE },
5144	{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(205)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(205)), transform_worldex }, WINED3D_GL_EXT_NONE },
5145	{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(206)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(206)), transform_worldex }, WINED3D_GL_EXT_NONE },
5146	{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(207)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(207)), transform_worldex }, WINED3D_GL_EXT_NONE },
5147	{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(208)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(208)), transform_worldex }, WINED3D_GL_EXT_NONE },
5148	{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(209)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(209)), transform_worldex }, WINED3D_GL_EXT_NONE },
5149	{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(210)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(210)), transform_worldex }, WINED3D_GL_EXT_NONE },
5150	{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(211)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(211)), transform_worldex }, WINED3D_GL_EXT_NONE },
5151	{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(212)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(212)), transform_worldex }, WINED3D_GL_EXT_NONE },
5152	{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(213)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(213)), transform_worldex }, WINED3D_GL_EXT_NONE },
5153	{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(214)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(214)), transform_worldex }, WINED3D_GL_EXT_NONE },
5154	{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(215)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(215)), transform_worldex }, WINED3D_GL_EXT_NONE },
5155	{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(216)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(216)), transform_worldex }, WINED3D_GL_EXT_NONE },
5156	{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(217)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(217)), transform_worldex }, WINED3D_GL_EXT_NONE },
5157	{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(218)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(218)), transform_worldex }, WINED3D_GL_EXT_NONE },
5158	{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(219)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(219)), transform_worldex }, WINED3D_GL_EXT_NONE },
5159	{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(220)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(220)), transform_worldex }, WINED3D_GL_EXT_NONE },
5160	{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(221)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(221)), transform_worldex }, WINED3D_GL_EXT_NONE },
5161	{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(222)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(222)), transform_worldex }, WINED3D_GL_EXT_NONE },
5162	{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(223)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(223)), transform_worldex }, WINED3D_GL_EXT_NONE },
5163	{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(224)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(224)), transform_worldex }, WINED3D_GL_EXT_NONE },
5164	{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(225)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(225)), transform_worldex }, WINED3D_GL_EXT_NONE },
5165	{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(226)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(226)), transform_worldex }, WINED3D_GL_EXT_NONE },
5166	{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(227)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(227)), transform_worldex }, WINED3D_GL_EXT_NONE },
5167	{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(228)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(228)), transform_worldex }, WINED3D_GL_EXT_NONE },
5168	{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(229)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(229)), transform_worldex }, WINED3D_GL_EXT_NONE },
5169	{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(230)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(230)), transform_worldex }, WINED3D_GL_EXT_NONE },
5170	{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(231)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(231)), transform_worldex }, WINED3D_GL_EXT_NONE },
5171	{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(232)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(232)), transform_worldex }, WINED3D_GL_EXT_NONE },
5172	{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(233)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(233)), transform_worldex }, WINED3D_GL_EXT_NONE },
5173	{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(234)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(234)), transform_worldex }, WINED3D_GL_EXT_NONE },
5174	{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(235)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(235)), transform_worldex }, WINED3D_GL_EXT_NONE },
5175	{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(236)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(236)), transform_worldex }, WINED3D_GL_EXT_NONE },
5176	{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(237)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(237)), transform_worldex }, WINED3D_GL_EXT_NONE },
5177	{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(238)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(238)), transform_worldex }, WINED3D_GL_EXT_NONE },
5178	{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(239)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(239)), transform_worldex }, WINED3D_GL_EXT_NONE },
5179	{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(240)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(240)), transform_worldex }, WINED3D_GL_EXT_NONE },
5180	{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(241)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(241)), transform_worldex }, WINED3D_GL_EXT_NONE },
5181	{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(242)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(242)), transform_worldex }, WINED3D_GL_EXT_NONE },
5182	{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(243)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(243)), transform_worldex }, WINED3D_GL_EXT_NONE },
5183	{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(244)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(244)), transform_worldex }, WINED3D_GL_EXT_NONE },
5184	{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(245)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(245)), transform_worldex }, WINED3D_GL_EXT_NONE },
5185	{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(246)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(246)), transform_worldex }, WINED3D_GL_EXT_NONE },
5186	{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(247)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(247)), transform_worldex }, WINED3D_GL_EXT_NONE },
5187	{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(248)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(248)), transform_worldex }, WINED3D_GL_EXT_NONE },
5188	{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(249)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(249)), transform_worldex }, WINED3D_GL_EXT_NONE },
5189	{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(250)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(250)), transform_worldex }, WINED3D_GL_EXT_NONE },
5190	{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(251)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(251)), transform_worldex }, WINED3D_GL_EXT_NONE },
5191	{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(252)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(252)), transform_worldex }, WINED3D_GL_EXT_NONE },
5192	{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(253)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(253)), transform_worldex }, WINED3D_GL_EXT_NONE },
5193	{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(254)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(254)), transform_worldex }, WINED3D_GL_EXT_NONE },
5194	{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(255)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(255)), transform_worldex }, WINED3D_GL_EXT_NONE },
5195	{ STATE_TEXTURESTAGE(0,WINED3DTSS_TEXTURETRANSFORMFLAGS),{STATE_TEXTURESTAGE(0,WINED3DTSS_TEXTURETRANSFORMFLAGS),transform_texture }, WINED3D_GL_EXT_NONE },
5196	{ STATE_TEXTURESTAGE(1,WINED3DTSS_TEXTURETRANSFORMFLAGS),{STATE_TEXTURESTAGE(1,WINED3DTSS_TEXTURETRANSFORMFLAGS),transform_texture }, WINED3D_GL_EXT_NONE },
5197	{ STATE_TEXTURESTAGE(2,WINED3DTSS_TEXTURETRANSFORMFLAGS),{STATE_TEXTURESTAGE(2,WINED3DTSS_TEXTURETRANSFORMFLAGS),transform_texture }, WINED3D_GL_EXT_NONE },
5198	{ STATE_TEXTURESTAGE(3,WINED3DTSS_TEXTURETRANSFORMFLAGS),{STATE_TEXTURESTAGE(3,WINED3DTSS_TEXTURETRANSFORMFLAGS),transform_texture }, WINED3D_GL_EXT_NONE },
5199	{ STATE_TEXTURESTAGE(4,WINED3DTSS_TEXTURETRANSFORMFLAGS),{STATE_TEXTURESTAGE(4,WINED3DTSS_TEXTURETRANSFORMFLAGS),transform_texture }, WINED3D_GL_EXT_NONE },
5200	{ STATE_TEXTURESTAGE(5,WINED3DTSS_TEXTURETRANSFORMFLAGS),{STATE_TEXTURESTAGE(5,WINED3DTSS_TEXTURETRANSFORMFLAGS),transform_texture }, WINED3D_GL_EXT_NONE },
5201	{ STATE_TEXTURESTAGE(6,WINED3DTSS_TEXTURETRANSFORMFLAGS),{STATE_TEXTURESTAGE(6,WINED3DTSS_TEXTURETRANSFORMFLAGS),transform_texture }, WINED3D_GL_EXT_NONE },
5202	{ STATE_TEXTURESTAGE(7,WINED3DTSS_TEXTURETRANSFORMFLAGS),{STATE_TEXTURESTAGE(7,WINED3DTSS_TEXTURETRANSFORMFLAGS),transform_texture }, WINED3D_GL_EXT_NONE },
5203	{ STATE_TEXTURESTAGE(0, WINED3DTSS_TEXCOORDINDEX), { STATE_TEXTURESTAGE(0, WINED3DTSS_TEXCOORDINDEX), tex_coordindex }, WINED3D_GL_EXT_NONE },
5204	{ STATE_TEXTURESTAGE(1, WINED3DTSS_TEXCOORDINDEX), { STATE_TEXTURESTAGE(1, WINED3DTSS_TEXCOORDINDEX), tex_coordindex }, WINED3D_GL_EXT_NONE },
5205	{ STATE_TEXTURESTAGE(2, WINED3DTSS_TEXCOORDINDEX), { STATE_TEXTURESTAGE(2, WINED3DTSS_TEXCOORDINDEX), tex_coordindex }, WINED3D_GL_EXT_NONE },
5206	{ STATE_TEXTURESTAGE(3, WINED3DTSS_TEXCOORDINDEX), { STATE_TEXTURESTAGE(3, WINED3DTSS_TEXCOORDINDEX), tex_coordindex }, WINED3D_GL_EXT_NONE },
5207	{ STATE_TEXTURESTAGE(4, WINED3DTSS_TEXCOORDINDEX), { STATE_TEXTURESTAGE(4, WINED3DTSS_TEXCOORDINDEX), tex_coordindex }, WINED3D_GL_EXT_NONE },
5208	{ STATE_TEXTURESTAGE(5, WINED3DTSS_TEXCOORDINDEX), { STATE_TEXTURESTAGE(5, WINED3DTSS_TEXCOORDINDEX), tex_coordindex }, WINED3D_GL_EXT_NONE },
5209	{ STATE_TEXTURESTAGE(6, WINED3DTSS_TEXCOORDINDEX), { STATE_TEXTURESTAGE(6, WINED3DTSS_TEXCOORDINDEX), tex_coordindex }, WINED3D_GL_EXT_NONE },
5210	{ STATE_TEXTURESTAGE(7, WINED3DTSS_TEXCOORDINDEX), { STATE_TEXTURESTAGE(7, WINED3DTSS_TEXCOORDINDEX), tex_coordindex }, WINED3D_GL_EXT_NONE },
5211	/* Fog */
5212	{ STATE_RENDER(WINED3DRS_FOGENABLE), { STATE_RENDER(WINED3DRS_FOGENABLE), state_fog_vertexpart}, WINED3D_GL_EXT_NONE },
5213	{ STATE_RENDER(WINED3DRS_FOGTABLEMODE), { STATE_RENDER(WINED3DRS_FOGENABLE), state_fog_vertexpart}, WINED3D_GL_EXT_NONE },
5214	{ STATE_RENDER(WINED3DRS_FOGVERTEXMODE), { STATE_RENDER(WINED3DRS_FOGENABLE), state_fog_vertexpart}, WINED3D_GL_EXT_NONE },
5215	{ STATE_RENDER(WINED3DRS_RANGEFOGENABLE), { STATE_RENDER(WINED3DRS_RANGEFOGENABLE), state_rangefog }, NV_FOG_DISTANCE },
5216	{ STATE_RENDER(WINED3DRS_RANGEFOGENABLE), { STATE_RENDER(WINED3DRS_RANGEFOGENABLE), state_rangefog_w }, WINED3D_GL_EXT_NONE },
5217	{ STATE_RENDER(WINED3DRS_CLIPPING), { STATE_RENDER(WINED3DRS_CLIPPING), state_clipping }, WINED3D_GL_EXT_NONE },
5218	{ STATE_RENDER(WINED3DRS_CLIPPLANEENABLE), { STATE_RENDER(WINED3DRS_CLIPPING), state_clipping }, WINED3D_GL_EXT_NONE },
5219	{ STATE_RENDER(WINED3DRS_LIGHTING), { STATE_RENDER(WINED3DRS_LIGHTING), state_lighting }, WINED3D_GL_EXT_NONE },
5220	{ STATE_RENDER(WINED3DRS_AMBIENT), { STATE_RENDER(WINED3DRS_AMBIENT), state_ambient }, WINED3D_GL_EXT_NONE },
5221	{ STATE_RENDER(WINED3DRS_COLORVERTEX), { STATE_RENDER(WINED3DRS_COLORVERTEX), state_colormat }, WINED3D_GL_EXT_NONE },
5222	{ STATE_RENDER(WINED3DRS_LOCALVIEWER), { STATE_RENDER(WINED3DRS_LOCALVIEWER), state_localviewer }, WINED3D_GL_EXT_NONE },
5223	{ STATE_RENDER(WINED3DRS_NORMALIZENORMALS), { STATE_RENDER(WINED3DRS_NORMALIZENORMALS), state_normalize }, WINED3D_GL_EXT_NONE },
5224	{ STATE_RENDER(WINED3DRS_DIFFUSEMATERIALSOURCE), { STATE_RENDER(WINED3DRS_COLORVERTEX), state_colormat }, WINED3D_GL_EXT_NONE },
5225	{ STATE_RENDER(WINED3DRS_SPECULARMATERIALSOURCE), { STATE_RENDER(WINED3DRS_COLORVERTEX), state_colormat }, WINED3D_GL_EXT_NONE },
5226	{ STATE_RENDER(WINED3DRS_AMBIENTMATERIALSOURCE), { STATE_RENDER(WINED3DRS_COLORVERTEX), state_colormat }, WINED3D_GL_EXT_NONE },
5227	{ STATE_RENDER(WINED3DRS_EMISSIVEMATERIALSOURCE), { STATE_RENDER(WINED3DRS_COLORVERTEX), state_colormat }, WINED3D_GL_EXT_NONE },
5228	{ STATE_RENDER(WINED3DRS_VERTEXBLEND), { STATE_RENDER(WINED3DRS_VERTEXBLEND), state_vertexblend }, ARB_VERTEX_BLEND },
5229	{ STATE_RENDER(WINED3DRS_VERTEXBLEND), { STATE_RENDER(WINED3DRS_VERTEXBLEND), state_vertexblend_w }, WINED3D_GL_EXT_NONE },
5230	{ STATE_RENDER(WINED3DRS_POINTSIZE), { STATE_RENDER(WINED3DRS_POINTSCALEENABLE), state_pscale }, WINED3D_GL_EXT_NONE },
5231	{ STATE_RENDER(WINED3DRS_POINTSIZE_MIN), { STATE_RENDER(WINED3DRS_POINTSIZE_MIN), state_psizemin_arb }, ARB_POINT_PARAMETERS },
5232	{ STATE_RENDER(WINED3DRS_POINTSIZE_MIN), { STATE_RENDER(WINED3DRS_POINTSIZE_MIN), state_psizemin_ext }, EXT_POINT_PARAMETERS },
5233	{ STATE_RENDER(WINED3DRS_POINTSIZE_MIN), { STATE_RENDER(WINED3DRS_POINTSIZE_MIN), state_psizemin_w }, WINED3D_GL_EXT_NONE },
5234	{ STATE_RENDER(WINED3DRS_POINTSPRITEENABLE), { STATE_RENDER(WINED3DRS_POINTSPRITEENABLE), state_pointsprite }, ARB_POINT_SPRITE },
5235	{ STATE_RENDER(WINED3DRS_POINTSPRITEENABLE), { STATE_RENDER(WINED3DRS_POINTSPRITEENABLE), state_pointsprite_w }, WINED3D_GL_EXT_NONE },
5236	{ STATE_RENDER(WINED3DRS_POINTSCALEENABLE), { STATE_RENDER(WINED3DRS_POINTSCALEENABLE), state_pscale }, WINED3D_GL_EXT_NONE },
5237	{ STATE_RENDER(WINED3DRS_POINTSCALE_A), { STATE_RENDER(WINED3DRS_POINTSCALEENABLE), state_pscale }, WINED3D_GL_EXT_NONE },
5238	{ STATE_RENDER(WINED3DRS_POINTSCALE_B), { STATE_RENDER(WINED3DRS_POINTSCALEENABLE), state_pscale }, WINED3D_GL_EXT_NONE },
5239	{ STATE_RENDER(WINED3DRS_POINTSCALE_C), { STATE_RENDER(WINED3DRS_POINTSCALEENABLE), state_pscale }, WINED3D_GL_EXT_NONE },
5240	{ STATE_RENDER(WINED3DRS_POINTSIZE_MAX), { STATE_RENDER(WINED3DRS_POINTSIZE_MIN), state_psizemin_arb }, ARB_POINT_PARAMETERS },
5241	{ STATE_RENDER(WINED3DRS_POINTSIZE_MAX), { STATE_RENDER(WINED3DRS_POINTSIZE_MIN), state_psizemin_ext }, EXT_POINT_PARAMETERS },
5242	{ STATE_RENDER(WINED3DRS_POINTSIZE_MAX), { STATE_RENDER(WINED3DRS_POINTSIZE_MIN), state_psizemin_w }, WINED3D_GL_EXT_NONE },
5243	/* Samplers for NP2 texture matrix adjustions. They are not needed if GL_ARB_texture_non_power_of_two is supported,
5244	* so register a NULL state handler in that case to get the vertex part of sampler() skipped(VTF is handled in the misc states.
5245	* otherwise, register sampler_texmatrix, which takes care of updating the texture matrix
5246	*/
5247	{ STATE_SAMPLER(0), { 0, NULL }, ARB_TEXTURE_NON_POWER_OF_TWO },
5248	{ STATE_SAMPLER(0), { 0, NULL }, WINE_NORMALIZED_TEXRECT },
5249	{ STATE_SAMPLER(0), { STATE_SAMPLER(0), sampler_texmatrix }, WINED3D_GL_EXT_NONE },
5250	{ STATE_SAMPLER(1), { 0, NULL }, ARB_TEXTURE_NON_POWER_OF_TWO },
5251	{ STATE_SAMPLER(1), { 0, NULL }, WINE_NORMALIZED_TEXRECT },
5252	{ STATE_SAMPLER(1), { STATE_SAMPLER(1), sampler_texmatrix }, WINED3D_GL_EXT_NONE },
5253	{ STATE_SAMPLER(2), { 0, NULL }, ARB_TEXTURE_NON_POWER_OF_TWO },
5254	{ STATE_SAMPLER(2), { 0, NULL }, WINE_NORMALIZED_TEXRECT },
5255	{ STATE_SAMPLER(2), { STATE_SAMPLER(2), sampler_texmatrix }, WINED3D_GL_EXT_NONE },
5256	{ STATE_SAMPLER(3), { 0, NULL }, ARB_TEXTURE_NON_POWER_OF_TWO },
5257	{ STATE_SAMPLER(3), { 0, NULL }, WINE_NORMALIZED_TEXRECT },
5258	{ STATE_SAMPLER(3), { STATE_SAMPLER(3), sampler_texmatrix }, WINED3D_GL_EXT_NONE },
5259	{ STATE_SAMPLER(4), { 0, NULL }, ARB_TEXTURE_NON_POWER_OF_TWO },
5260	{ STATE_SAMPLER(4), { 0, NULL }, WINE_NORMALIZED_TEXRECT },
5261	{ STATE_SAMPLER(4), { STATE_SAMPLER(4), sampler_texmatrix }, WINED3D_GL_EXT_NONE },
5262	{ STATE_SAMPLER(5), { 0, NULL }, ARB_TEXTURE_NON_POWER_OF_TWO },
5263	{ STATE_SAMPLER(5), { 0, NULL }, WINE_NORMALIZED_TEXRECT },
5264	{ STATE_SAMPLER(5), { STATE_SAMPLER(5), sampler_texmatrix }, WINED3D_GL_EXT_NONE },
5265	{ STATE_SAMPLER(6), { 0, NULL }, ARB_TEXTURE_NON_POWER_OF_TWO },
5266	{ STATE_SAMPLER(6), { 0, NULL }, WINE_NORMALIZED_TEXRECT },
5267	{ STATE_SAMPLER(6), { STATE_SAMPLER(6), sampler_texmatrix }, WINED3D_GL_EXT_NONE },
5268	{ STATE_SAMPLER(7), { 0, NULL }, ARB_TEXTURE_NON_POWER_OF_TWO },
5269	{ STATE_SAMPLER(7), { 0, NULL }, WINE_NORMALIZED_TEXRECT },
5270	{ STATE_SAMPLER(7), { STATE_SAMPLER(7), sampler_texmatrix }, WINED3D_GL_EXT_NONE },
5271	{0 /* Terminate */, { 0, 0 }, WINED3D_GL_EXT_NONE },
5272	};
5273
5274	static const struct StateEntryTemplate ffp_fragmentstate_template[] = {
5275	{ STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP), { STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP), tex_colorop }, WINED3D_GL_EXT_NONE },
5276	{ STATE_TEXTURESTAGE(0, WINED3DTSS_COLORARG1), { STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP), tex_colorop }, WINED3D_GL_EXT_NONE },
5277	{ STATE_TEXTURESTAGE(0, WINED3DTSS_COLORARG2), { STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP), tex_colorop }, WINED3D_GL_EXT_NONE },
5278	{ STATE_TEXTURESTAGE(0, WINED3DTSS_ALPHAOP), { STATE_TEXTURESTAGE(0, WINED3DTSS_ALPHAOP), tex_alphaop }, WINED3D_GL_EXT_NONE },
5279	{ STATE_TEXTURESTAGE(0, WINED3DTSS_ALPHAARG1), { STATE_TEXTURESTAGE(0, WINED3DTSS_ALPHAOP), tex_alphaop }, WINED3D_GL_EXT_NONE },
5280	{ STATE_TEXTURESTAGE(0, WINED3DTSS_ALPHAARG2), { STATE_TEXTURESTAGE(0, WINED3DTSS_ALPHAOP), tex_alphaop }, WINED3D_GL_EXT_NONE },
5281	{ STATE_TEXTURESTAGE(0, WINED3DTSS_COLORARG0), { STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP), tex_colorop }, WINED3D_GL_EXT_NONE },
5282	{ STATE_TEXTURESTAGE(0, WINED3DTSS_ALPHAARG0), { STATE_TEXTURESTAGE(0, WINED3DTSS_ALPHAOP), tex_alphaop }, WINED3D_GL_EXT_NONE },
5283	{ STATE_TEXTURESTAGE(0, WINED3DTSS_RESULTARG), { STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP), tex_colorop }, WINED3D_GL_EXT_NONE },
5284	{ STATE_TEXTURESTAGE(0, WINED3DTSS_CONSTANT), { 0 /* As long as we don't support D3DTA_CONSTANT */, state_nogl }, WINED3D_GL_EXT_NONE },
5285	{ STATE_TEXTURESTAGE(1, WINED3DTSS_COLOROP), { STATE_TEXTURESTAGE(1, WINED3DTSS_COLOROP), tex_colorop }, WINED3D_GL_EXT_NONE },
5286	{ STATE_TEXTURESTAGE(1, WINED3DTSS_COLORARG1), { STATE_TEXTURESTAGE(1, WINED3DTSS_COLOROP), tex_colorop }, WINED3D_GL_EXT_NONE },
5287	{ STATE_TEXTURESTAGE(1, WINED3DTSS_COLORARG2), { STATE_TEXTURESTAGE(1, WINED3DTSS_COLOROP), tex_colorop }, WINED3D_GL_EXT_NONE },
5288	{ STATE_TEXTURESTAGE(1, WINED3DTSS_ALPHAOP), { STATE_TEXTURESTAGE(1, WINED3DTSS_ALPHAOP), tex_alphaop }, WINED3D_GL_EXT_NONE },
5289	{ STATE_TEXTURESTAGE(1, WINED3DTSS_ALPHAARG1), { STATE_TEXTURESTAGE(1, WINED3DTSS_ALPHAOP), tex_alphaop }, WINED3D_GL_EXT_NONE },
5290	{ STATE_TEXTURESTAGE(1, WINED3DTSS_ALPHAARG2), { STATE_TEXTURESTAGE(1, WINED3DTSS_ALPHAOP), tex_alphaop }, WINED3D_GL_EXT_NONE },
5291	{ STATE_TEXTURESTAGE(1, WINED3DTSS_COLORARG0), { STATE_TEXTURESTAGE(1, WINED3DTSS_COLOROP), tex_colorop }, WINED3D_GL_EXT_NONE },
5292	{ STATE_TEXTURESTAGE(1, WINED3DTSS_ALPHAARG0), { STATE_TEXTURESTAGE(1, WINED3DTSS_ALPHAOP), tex_alphaop }, WINED3D_GL_EXT_NONE },
5293	{ STATE_TEXTURESTAGE(1, WINED3DTSS_RESULTARG), { STATE_TEXTURESTAGE(1, WINED3DTSS_COLOROP), tex_colorop }, WINED3D_GL_EXT_NONE },
5294	{ STATE_TEXTURESTAGE(1, WINED3DTSS_CONSTANT), { 0 /* As long as we don't support D3DTA_CONSTANT */, state_nogl }, WINED3D_GL_EXT_NONE },
5295	{ STATE_TEXTURESTAGE(2, WINED3DTSS_COLOROP), { STATE_TEXTURESTAGE(2, WINED3DTSS_COLOROP), tex_colorop }, WINED3D_GL_EXT_NONE },
5296	{ STATE_TEXTURESTAGE(2, WINED3DTSS_COLORARG1), { STATE_TEXTURESTAGE(2, WINED3DTSS_COLOROP), tex_colorop }, WINED3D_GL_EXT_NONE },
5297	{ STATE_TEXTURESTAGE(2, WINED3DTSS_COLORARG2), { STATE_TEXTURESTAGE(2, WINED3DTSS_COLOROP), tex_colorop }, WINED3D_GL_EXT_NONE },
5298	{ STATE_TEXTURESTAGE(2, WINED3DTSS_ALPHAOP), { STATE_TEXTURESTAGE(2, WINED3DTSS_ALPHAOP), tex_alphaop }, WINED3D_GL_EXT_NONE },
5299	{ STATE_TEXTURESTAGE(2, WINED3DTSS_ALPHAARG1), { STATE_TEXTURESTAGE(2, WINED3DTSS_ALPHAOP), tex_alphaop }, WINED3D_GL_EXT_NONE },
5300	{ STATE_TEXTURESTAGE(2, WINED3DTSS_ALPHAARG2), { STATE_TEXTURESTAGE(2, WINED3DTSS_ALPHAOP), tex_alphaop }, WINED3D_GL_EXT_NONE },
5301	{ STATE_TEXTURESTAGE(2, WINED3DTSS_COLORARG0), { STATE_TEXTURESTAGE(2, WINED3DTSS_COLOROP), tex_colorop }, WINED3D_GL_EXT_NONE },
5302	{ STATE_TEXTURESTAGE(2, WINED3DTSS_ALPHAARG0), { STATE_TEXTURESTAGE(2, WINED3DTSS_ALPHAOP), tex_alphaop }, WINED3D_GL_EXT_NONE },
5303	{ STATE_TEXTURESTAGE(2, WINED3DTSS_RESULTARG), { STATE_TEXTURESTAGE(2, WINED3DTSS_COLOROP), tex_colorop }, WINED3D_GL_EXT_NONE },
5304	{ STATE_TEXTURESTAGE(2, WINED3DTSS_CONSTANT), { 0 /* As long as we don't support D3DTA_CONSTANT */, state_nogl }, WINED3D_GL_EXT_NONE },
5305	{ STATE_TEXTURESTAGE(3, WINED3DTSS_COLOROP), { STATE_TEXTURESTAGE(3, WINED3DTSS_COLOROP), tex_colorop }, WINED3D_GL_EXT_NONE },
5306	{ STATE_TEXTURESTAGE(3, WINED3DTSS_COLORARG1), { STATE_TEXTURESTAGE(3, WINED3DTSS_COLOROP), tex_colorop }, WINED3D_GL_EXT_NONE },
5307	{ STATE_TEXTURESTAGE(3, WINED3DTSS_COLORARG2), { STATE_TEXTURESTAGE(3, WINED3DTSS_COLOROP), tex_colorop }, WINED3D_GL_EXT_NONE },
5308	{ STATE_TEXTURESTAGE(3, WINED3DTSS_ALPHAOP), { STATE_TEXTURESTAGE(3, WINED3DTSS_ALPHAOP), tex_alphaop }, WINED3D_GL_EXT_NONE },
5309	{ STATE_TEXTURESTAGE(3, WINED3DTSS_ALPHAARG1), { STATE_TEXTURESTAGE(3, WINED3DTSS_ALPHAOP), tex_alphaop }, WINED3D_GL_EXT_NONE },
5310	{ STATE_TEXTURESTAGE(3, WINED3DTSS_ALPHAARG2), { STATE_TEXTURESTAGE(3, WINED3DTSS_ALPHAOP), tex_alphaop }, WINED3D_GL_EXT_NONE },
5311	{ STATE_TEXTURESTAGE(3, WINED3DTSS_COLORARG0), { STATE_TEXTURESTAGE(3, WINED3DTSS_COLOROP), tex_colorop }, WINED3D_GL_EXT_NONE },
5312	{ STATE_TEXTURESTAGE(3, WINED3DTSS_ALPHAARG0), { STATE_TEXTURESTAGE(3, WINED3DTSS_ALPHAOP), tex_alphaop }, WINED3D_GL_EXT_NONE },
5313	{ STATE_TEXTURESTAGE(3, WINED3DTSS_RESULTARG), { STATE_TEXTURESTAGE(3, WINED3DTSS_COLOROP), tex_colorop }, WINED3D_GL_EXT_NONE },
5314	{ STATE_TEXTURESTAGE(3, WINED3DTSS_CONSTANT), { 0 /* As long as we don't support D3DTA_CONSTANT */, state_nogl }, WINED3D_GL_EXT_NONE },
5315	{ STATE_TEXTURESTAGE(4, WINED3DTSS_COLOROP), { STATE_TEXTURESTAGE(4, WINED3DTSS_COLOROP), tex_colorop }, WINED3D_GL_EXT_NONE },
5316	{ STATE_TEXTURESTAGE(4, WINED3DTSS_COLORARG1), { STATE_TEXTURESTAGE(4, WINED3DTSS_COLOROP), tex_colorop }, WINED3D_GL_EXT_NONE },
5317	{ STATE_TEXTURESTAGE(4, WINED3DTSS_COLORARG2), { STATE_TEXTURESTAGE(4, WINED3DTSS_COLOROP), tex_colorop }, WINED3D_GL_EXT_NONE },
5318	{ STATE_TEXTURESTAGE(4, WINED3DTSS_ALPHAOP), { STATE_TEXTURESTAGE(4, WINED3DTSS_ALPHAOP), tex_alphaop }, WINED3D_GL_EXT_NONE },
5319	{ STATE_TEXTURESTAGE(4, WINED3DTSS_ALPHAARG1), { STATE_TEXTURESTAGE(4, WINED3DTSS_ALPHAOP), tex_alphaop }, WINED3D_GL_EXT_NONE },
5320	{ STATE_TEXTURESTAGE(4, WINED3DTSS_ALPHAARG2), { STATE_TEXTURESTAGE(4, WINED3DTSS_ALPHAOP), tex_alphaop }, WINED3D_GL_EXT_NONE },
5321	{ STATE_TEXTURESTAGE(4, WINED3DTSS_COLORARG0), { STATE_TEXTURESTAGE(4, WINED3DTSS_COLOROP), tex_colorop }, WINED3D_GL_EXT_NONE },
5322	{ STATE_TEXTURESTAGE(4, WINED3DTSS_ALPHAARG0), { STATE_TEXTURESTAGE(4, WINED3DTSS_ALPHAOP), tex_alphaop }, WINED3D_GL_EXT_NONE },
5323	{ STATE_TEXTURESTAGE(4, WINED3DTSS_RESULTARG), { STATE_TEXTURESTAGE(4, WINED3DTSS_COLOROP), tex_colorop }, WINED3D_GL_EXT_NONE },
5324	{ STATE_TEXTURESTAGE(4, WINED3DTSS_CONSTANT), { 0 /* As long as we don't support D3DTA_CONSTANT */, state_nogl }, WINED3D_GL_EXT_NONE },
5325	{ STATE_TEXTURESTAGE(5, WINED3DTSS_COLOROP), { STATE_TEXTURESTAGE(5, WINED3DTSS_COLOROP), tex_colorop }, WINED3D_GL_EXT_NONE },
5326	{ STATE_TEXTURESTAGE(5, WINED3DTSS_COLORARG1), { STATE_TEXTURESTAGE(5, WINED3DTSS_COLOROP), tex_colorop }, WINED3D_GL_EXT_NONE },
5327	{ STATE_TEXTURESTAGE(5, WINED3DTSS_COLORARG2), { STATE_TEXTURESTAGE(5, WINED3DTSS_COLOROP), tex_colorop }, WINED3D_GL_EXT_NONE },
5328	{ STATE_TEXTURESTAGE(5, WINED3DTSS_ALPHAOP), { STATE_TEXTURESTAGE(5, WINED3DTSS_ALPHAOP), tex_alphaop }, WINED3D_GL_EXT_NONE },
5329	{ STATE_TEXTURESTAGE(5, WINED3DTSS_ALPHAARG1), { STATE_TEXTURESTAGE(5, WINED3DTSS_ALPHAOP), tex_alphaop }, WINED3D_GL_EXT_NONE },
5330	{ STATE_TEXTURESTAGE(5, WINED3DTSS_ALPHAARG2), { STATE_TEXTURESTAGE(5, WINED3DTSS_ALPHAOP), tex_alphaop }, WINED3D_GL_EXT_NONE },
5331	{ STATE_TEXTURESTAGE(5, WINED3DTSS_COLORARG0), { STATE_TEXTURESTAGE(5, WINED3DTSS_COLOROP), tex_colorop }, WINED3D_GL_EXT_NONE },
5332	{ STATE_TEXTURESTAGE(5, WINED3DTSS_ALPHAARG0), { STATE_TEXTURESTAGE(5, WINED3DTSS_ALPHAOP), tex_alphaop }, WINED3D_GL_EXT_NONE },
5333	{ STATE_TEXTURESTAGE(5, WINED3DTSS_RESULTARG), { STATE_TEXTURESTAGE(5, WINED3DTSS_COLOROP), tex_colorop }, WINED3D_GL_EXT_NONE },
5334	{ STATE_TEXTURESTAGE(5, WINED3DTSS_CONSTANT), { 0 /* As long as we don't support D3DTA_CONSTANT */, state_nogl }, WINED3D_GL_EXT_NONE },
5335	{ STATE_TEXTURESTAGE(6, WINED3DTSS_COLOROP), { STATE_TEXTURESTAGE(6, WINED3DTSS_COLOROP), tex_colorop }, WINED3D_GL_EXT_NONE },
5336	{ STATE_TEXTURESTAGE(6, WINED3DTSS_COLORARG1), { STATE_TEXTURESTAGE(6, WINED3DTSS_COLOROP), tex_colorop }, WINED3D_GL_EXT_NONE },
5337	{ STATE_TEXTURESTAGE(6, WINED3DTSS_COLORARG2), { STATE_TEXTURESTAGE(6, WINED3DTSS_COLOROP), tex_colorop }, WINED3D_GL_EXT_NONE },
5338	{ STATE_TEXTURESTAGE(6, WINED3DTSS_ALPHAOP), { STATE_TEXTURESTAGE(6, WINED3DTSS_ALPHAOP), tex_alphaop }, WINED3D_GL_EXT_NONE },
5339	{ STATE_TEXTURESTAGE(6, WINED3DTSS_ALPHAARG1), { STATE_TEXTURESTAGE(6, WINED3DTSS_ALPHAOP), tex_alphaop }, WINED3D_GL_EXT_NONE },
5340	{ STATE_TEXTURESTAGE(6, WINED3DTSS_ALPHAARG2), { STATE_TEXTURESTAGE(6, WINED3DTSS_ALPHAOP), tex_alphaop }, WINED3D_GL_EXT_NONE },
5341	{ STATE_TEXTURESTAGE(6, WINED3DTSS_COLORARG0), { STATE_TEXTURESTAGE(6, WINED3DTSS_COLOROP), tex_colorop }, WINED3D_GL_EXT_NONE },
5342	{ STATE_TEXTURESTAGE(6, WINED3DTSS_ALPHAARG0), { STATE_TEXTURESTAGE(6, WINED3DTSS_ALPHAOP), tex_alphaop }, WINED3D_GL_EXT_NONE },
5343	{ STATE_TEXTURESTAGE(6, WINED3DTSS_RESULTARG), { STATE_TEXTURESTAGE(6, WINED3DTSS_COLOROP), tex_colorop }, WINED3D_GL_EXT_NONE },
5344	{ STATE_TEXTURESTAGE(6, WINED3DTSS_CONSTANT), { 0 /* As long as we don't support D3DTA_CONSTANT */, state_nogl }, WINED3D_GL_EXT_NONE },
5345	{ STATE_TEXTURESTAGE(7, WINED3DTSS_COLOROP), { STATE_TEXTURESTAGE(7, WINED3DTSS_COLOROP), tex_colorop }, WINED3D_GL_EXT_NONE },
5346	{ STATE_TEXTURESTAGE(7, WINED3DTSS_COLORARG1), { STATE_TEXTURESTAGE(7, WINED3DTSS_COLOROP), tex_colorop }, WINED3D_GL_EXT_NONE },
5347	{ STATE_TEXTURESTAGE(7, WINED3DTSS_COLORARG2), { STATE_TEXTURESTAGE(7, WINED3DTSS_COLOROP), tex_colorop }, WINED3D_GL_EXT_NONE },
5348	{ STATE_TEXTURESTAGE(7, WINED3DTSS_ALPHAOP), { STATE_TEXTURESTAGE(7, WINED3DTSS_ALPHAOP), tex_alphaop }, WINED3D_GL_EXT_NONE },
5349	{ STATE_TEXTURESTAGE(7, WINED3DTSS_ALPHAARG1), { STATE_TEXTURESTAGE(7, WINED3DTSS_ALPHAOP), tex_alphaop }, WINED3D_GL_EXT_NONE },
5350	{ STATE_TEXTURESTAGE(7, WINED3DTSS_ALPHAARG2), { STATE_TEXTURESTAGE(7, WINED3DTSS_ALPHAOP), tex_alphaop }, WINED3D_GL_EXT_NONE },
5351	{ STATE_TEXTURESTAGE(7, WINED3DTSS_COLORARG0), { STATE_TEXTURESTAGE(7, WINED3DTSS_COLOROP), tex_colorop }, WINED3D_GL_EXT_NONE },
5352	{ STATE_TEXTURESTAGE(7, WINED3DTSS_ALPHAARG0), { STATE_TEXTURESTAGE(7, WINED3DTSS_ALPHAOP), tex_alphaop }, WINED3D_GL_EXT_NONE },
5353	{ STATE_TEXTURESTAGE(7, WINED3DTSS_RESULTARG), { STATE_TEXTURESTAGE(7, WINED3DTSS_COLOROP), tex_colorop }, WINED3D_GL_EXT_NONE },
5354	{ STATE_TEXTURESTAGE(7, WINED3DTSS_CONSTANT), { 0 /* As long as we don't support D3DTA_CONSTANT */, state_nogl }, WINED3D_GL_EXT_NONE },
5355	{ STATE_PIXELSHADER, { STATE_PIXELSHADER, apply_pixelshader }, WINED3D_GL_EXT_NONE },
5356	{ STATE_RENDER(WINED3DRS_SRGBWRITEENABLE), { STATE_PIXELSHADER, apply_pixelshader }, WINED3D_GL_EXT_NONE },
5357	{ STATE_RENDER(WINED3DRS_BORDERCOLOR), { STATE_RENDER(WINED3DRS_BORDERCOLOR), state_bordercolor }, WINED3D_GL_EXT_NONE },
5358	{ STATE_RENDER(WINED3DRS_TEXTUREFACTOR), { STATE_RENDER(WINED3DRS_TEXTUREFACTOR), state_texfactor }, WINED3D_GL_EXT_NONE },
5359	{ STATE_RENDER(WINED3DRS_FOGCOLOR), { STATE_RENDER(WINED3DRS_FOGCOLOR), state_fogcolor }, WINED3D_GL_EXT_NONE },
5360	{ STATE_RENDER(WINED3DRS_FOGDENSITY), { STATE_RENDER(WINED3DRS_FOGDENSITY), state_fogdensity }, WINED3D_GL_EXT_NONE },
5361	{ STATE_RENDER(WINED3DRS_FOGENABLE), { STATE_RENDER(WINED3DRS_FOGENABLE), state_fog_fragpart }, WINED3D_GL_EXT_NONE },
5362	{ STATE_RENDER(WINED3DRS_FOGTABLEMODE), { STATE_RENDER(WINED3DRS_FOGENABLE), state_fog_fragpart }, WINED3D_GL_EXT_NONE },
5363	{ STATE_RENDER(WINED3DRS_FOGVERTEXMODE), { STATE_RENDER(WINED3DRS_FOGENABLE), state_fog_fragpart }, WINED3D_GL_EXT_NONE },
5364	{ STATE_RENDER(WINED3DRS_FOGSTART), { STATE_RENDER(WINED3DRS_FOGSTART), state_fogstartend }, WINED3D_GL_EXT_NONE },
5365	{ STATE_RENDER(WINED3DRS_FOGEND), { STATE_RENDER(WINED3DRS_FOGSTART), state_fogstartend }, WINED3D_GL_EXT_NONE },
5366	{ STATE_SAMPLER(0), { STATE_SAMPLER(0), sampler_texdim }, WINED3D_GL_EXT_NONE },
5367	{ STATE_SAMPLER(1), { STATE_SAMPLER(1), sampler_texdim }, WINED3D_GL_EXT_NONE },
5368	{ STATE_SAMPLER(2), { STATE_SAMPLER(2), sampler_texdim }, WINED3D_GL_EXT_NONE },
5369	{ STATE_SAMPLER(3), { STATE_SAMPLER(3), sampler_texdim }, WINED3D_GL_EXT_NONE },
5370	{ STATE_SAMPLER(4), { STATE_SAMPLER(4), sampler_texdim }, WINED3D_GL_EXT_NONE },
5371	{ STATE_SAMPLER(5), { STATE_SAMPLER(5), sampler_texdim }, WINED3D_GL_EXT_NONE },
5372	{ STATE_SAMPLER(6), { STATE_SAMPLER(6), sampler_texdim }, WINED3D_GL_EXT_NONE },
5373	{ STATE_SAMPLER(7), { STATE_SAMPLER(7), sampler_texdim }, WINED3D_GL_EXT_NONE },
5374	{0 /* Terminate */, { 0, 0 }, WINED3D_GL_EXT_NONE },
5375	};
5376	#undef GLINFO_LOCATION
5377
5378	#define GLINFO_LOCATION (*gl_info)
5379	static void ffp_enable(IWineD3DDevice *iface, BOOL enable) { }
5380
5381	static void ffp_fragment_get_caps(WINED3DDEVTYPE devtype, const WineD3D_GL_Info gl_info, struct fragment_caps pCaps)
5382	{
5383	pCaps->TextureOpCaps = WINED3DTEXOPCAPS_ADD \|
5384	WINED3DTEXOPCAPS_ADDSIGNED \|
5385	WINED3DTEXOPCAPS_ADDSIGNED2X \|
5386	WINED3DTEXOPCAPS_MODULATE \|
5387	WINED3DTEXOPCAPS_MODULATE2X \|
5388	WINED3DTEXOPCAPS_MODULATE4X \|
5389	WINED3DTEXOPCAPS_SELECTARG1 \|
5390	WINED3DTEXOPCAPS_SELECTARG2 \|
5391	WINED3DTEXOPCAPS_DISABLE;
5392
5393	if (GL_SUPPORT(ARB_TEXTURE_ENV_COMBINE) \|\|
5394	GL_SUPPORT(EXT_TEXTURE_ENV_COMBINE) \|\|
5395	GL_SUPPORT(NV_TEXTURE_ENV_COMBINE4)) {
5396	pCaps->TextureOpCaps \|= WINED3DTEXOPCAPS_BLENDDIFFUSEALPHA \|
5397	WINED3DTEXOPCAPS_BLENDTEXTUREALPHA \|
5398	WINED3DTEXOPCAPS_BLENDFACTORALPHA \|
5399	WINED3DTEXOPCAPS_BLENDCURRENTALPHA \|
5400	WINED3DTEXOPCAPS_LERP \|
5401	WINED3DTEXOPCAPS_SUBTRACT;
5402	}
5403	if (GL_SUPPORT(ATI_TEXTURE_ENV_COMBINE3) \|\|
5404	GL_SUPPORT(NV_TEXTURE_ENV_COMBINE4)) {
5405	pCaps->TextureOpCaps \|= WINED3DTEXOPCAPS_ADDSMOOTH \|
5406	WINED3DTEXOPCAPS_MULTIPLYADD \|
5407	WINED3DTEXOPCAPS_MODULATEALPHA_ADDCOLOR \|
5408	WINED3DTEXOPCAPS_MODULATECOLOR_ADDALPHA \|
5409	WINED3DTEXOPCAPS_BLENDTEXTUREALPHAPM;
5410	}
5411	if (GL_SUPPORT(ARB_TEXTURE_ENV_DOT3))
5412	pCaps->TextureOpCaps \|= WINED3DTEXOPCAPS_DOTPRODUCT3;
5413
5414	pCaps->MaxTextureBlendStages = GL_LIMITS(texture_stages);
5415	pCaps->MaxSimultaneousTextures = GL_LIMITS(textures);
5416	}
5417
5418	static HRESULT ffp_fragment_alloc(IWineD3DDevice *iface) { return WINED3D_OK; }
5419	static void ffp_fragment_free(IWineD3DDevice *iface) {}
5420	static BOOL ffp_color_fixup_supported(struct color_fixup_desc fixup)
5421	{
5422	if (TRACE_ON(d3d))
5423	{
5424	TRACE("Checking support for fixup:\n");
5425	dump_color_fixup_desc(fixup);
5426	}
5427
5428	/* We only support identity conversions. */
5429	if (is_identity_fixup(fixup))
5430	{
5431	TRACE("[OK]\n");
5432	return TRUE;
5433	}
5434
5435	TRACE("[FAILED]\n");
5436	return FALSE;
5437	}
5438
5439	const struct fragment_pipeline ffp_fragment_pipeline = {
5440	ffp_enable,
5441	ffp_fragment_get_caps,
5442	ffp_fragment_alloc,
5443	ffp_fragment_free,
5444	ffp_color_fixup_supported,
5445	ffp_fragmentstate_template,
5446	FALSE /* we cannot disable projected textures. The vertex pipe has to do it */
5447	};
5448
5449	static unsigned int num_handlers(const APPLYSTATEFUNC *funcs)
5450	{
5451	unsigned int i;
5452	for(i = 0; funcs[i]; i++);
5453	return i;
5454	}
5455
5456	static void multistate_apply_2(DWORD state, IWineD3DStateBlockImpl stateblock, WineD3DContext context) {
5457	stateblock->wineD3DDevice->multistate_funcs[state][0](state, stateblock, context);
5458	stateblock->wineD3DDevice->multistate_funcs[state][1](state, stateblock, context);
5459	}
5460
5461	static void multistate_apply_3(DWORD state, IWineD3DStateBlockImpl stateblock, WineD3DContext context) {
5462	stateblock->wineD3DDevice->multistate_funcs[state][0](state, stateblock, context);
5463	stateblock->wineD3DDevice->multistate_funcs[state][1](state, stateblock, context);
5464	stateblock->wineD3DDevice->multistate_funcs[state][2](state, stateblock, context);
5465	}
5466
5467	HRESULT compile_state_table(struct StateEntry StateTable, APPLYSTATEFUNC *dev_multistate_funcs,
5468	const WineD3D_GL_Info gl_info, const struct StateEntryTemplate vertex,
5469	const struct fragment_pipeline fragment, const struct StateEntryTemplate misc)
5470	{
5471	unsigned int i, type, handlers;
5472	APPLYSTATEFUNC multistate_funcs[STATE_HIGHEST + 1][3];
5473	const struct StateEntryTemplate *cur;
5474	BOOL set[STATE_HIGHEST + 1];
5475
5476	memset(multistate_funcs, 0, sizeof(multistate_funcs));
5477
5478	for(i = 0; i < STATE_HIGHEST + 1; i++) {
5479	StateTable[i].representative = 0;
5480	StateTable[i].apply = state_undefined;
5481	}
5482
5483	for(type = 0; type < 3; type++) {
5484	/* This switch decides the order in which the states are applied */
5485	switch(type) {
5486	case 0: cur = misc; break;
5487	case 1: cur = fragment->states; break;
5488	case 2: cur = vertex; break;
5489	default: cur = NULL; /* Stupid compiler */
5490	}
5491	if(!cur) continue;
5492
5493	/* GL extension filtering should not prevent multiple handlers being applied from different
5494	* pipeline parts
5495	*/
5496	memset(set, 0, sizeof(set));
5497
5498	for(i = 0; cur[i].state; i++) {
5499	APPLYSTATEFUNC *funcs_array;
5500
5501	/* Only use the first matching state with the available extension from one template.
5502	* e.g.
5503	* {D3DRS_FOOBAR, {D3DRS_FOOBAR, func1}, XYZ_FANCY},
5504	* {D3DRS_FOOBAR, {D3DRS_FOOBAR, func2}, 0 }
5505	*
5506	* if GL_XYZ_fancy is supported, ignore the 2nd line
5507	*/
5508	if(set[cur[i].state]) continue;
5509	/* Skip state lines depending on unsupported extensions */
5510	if (!GL_SUPPORT(cur[i].extension)) continue;
5511	set[cur[i].state] = TRUE;
5512	/* In some cases having an extension means that nothing has to be
5513	* done for a state, e.g. if GL_ARB_texture_non_power_of_two is
5514	* supported, the texture coordinate fixup can be ignored. If the
5515	* apply function is used, mark the state set(done above) to prevent
5516	* applying later lines, but do not record anything in the state
5517	* table
5518	*/
5519	if(!cur[i].content.apply) continue;
5520
5521	handlers = num_handlers(multistate_funcs[cur[i].state]);
5522	multistate_funcs[cur[i].state][handlers] = cur[i].content.apply;
5523	switch(handlers) {
5524	case 0:
5525	StateTable[cur[i].state].apply = cur[i].content.apply;
5526	break;
5527	case 1:
5528	StateTable[cur[i].state].apply = multistate_apply_2;
5529	dev_multistate_funcs[cur[i].state] = HeapAlloc(GetProcessHeap(),
5530	0,
5531	sizeof(*dev_multistate_funcs) 2);
5532	if (!dev_multistate_funcs[cur[i].state]) {
5533	goto out_of_mem;
5534	}
5535
5536	dev_multistate_funcs[cur[i].state][0] = multistate_funcs[cur[i].state][0];
5537	dev_multistate_funcs[cur[i].state][1] = multistate_funcs[cur[i].state][1];
5538	break;
5539	case 2:
5540	StateTable[cur[i].state].apply = multistate_apply_3;
5541	funcs_array = HeapReAlloc(GetProcessHeap(),
5542	0,
5543	dev_multistate_funcs[cur[i].state],
5544	sizeof(*dev_multistate_funcs) 3);
5545	if (!funcs_array) {
5546	goto out_of_mem;
5547	}
5548
5549	dev_multistate_funcs[cur[i].state] = funcs_array;
5550	dev_multistate_funcs[cur[i].state][2] = multistate_funcs[cur[i].state][2];
5551	break;
5552	default:
5553	ERR("Unexpected amount of state handlers for state %u: %u\n",
5554	cur[i].state, handlers + 1);
5555	}
5556
5557	if(StateTable[cur[i].state].representative &&
5558	StateTable[cur[i].state].representative != cur[i].content.representative) {
5559	FIXME("State %u has different representatives in different pipeline parts\n",
5560	cur[i].state);
5561	}
5562	StateTable[cur[i].state].representative = cur[i].content.representative;
5563	}
5564	}
5565
5566	return WINED3D_OK;
5567
5568	out_of_mem:
5569	for (i = 0; i <= STATE_HIGHEST; ++i) {
5570	HeapFree(GetProcessHeap(), 0, dev_multistate_funcs[i]);
5571	}
5572
5573	memset(dev_multistate_funcs, 0, (STATE_HIGHEST + 1)sizeof(dev_multistate_funcs));
5574
5575	return E_OUTOFMEMORY;
5576	}
5577	#undef GLINFO_LOCATION

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

source: vbox/trunk/src/VBox/Additions/WINNT/Graphics/Wine/wined3d/state.c@ 20817

Download in other formats: