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