Google Git
Sign in
goma / wine / 38d961a7499b341f930e667e6b738b8ed3c431d7 / . / dlls / wined3d / state.c
blob: efdd05de2c3d2d39746c705a8453756b7d8e75da [file] [log] [blame]
Stefan Dösingerc0268c72006-12-05 23:36:10 +0100[diff] [blame]1/*
2 * Direct3D state management
3 *
Stefan Dösinger7fd246e2007-01-10 11:38:00 +0100[diff] [blame]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-2007 Stefan Dösinger for CodeWeavers
Stefan Dösingerc0268c72006-12-05 23:36:10 +0100[diff] [blame]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
34WINE_DEFAULT_DEBUG_CHANNEL(d3d);
Stefan Dösingerd5f18e62007-01-06 18:11:21 +0100[diff] [blame]35WINE_DECLARE_DEBUG_CHANNEL(d3d_shader);
Stefan Dösingerc0268c72006-12-05 23:36:10 +0100[diff] [blame]36
Stefan Dösingerac261722006-12-08 20:21:43 +0100[diff] [blame]37#define GLINFO_LOCATION ((IWineD3DImpl *)(stateblock->wineD3DDevice->wineD3D))->gl_info
38
Stefan Dösingerc739c382007-02-12 19:18:22 +0100[diff] [blame]39static void state_nogl(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
Stefan Dösinger2a24e842006-12-06 13:22:12 +0100[diff] [blame]40 /* Used for states which are not mapped to a gl state as-is, but used somehow different,
41 * e.g as a parameter for drawing, or which are unimplemented in windows d3d
42 */
43 if(STATE_IS_RENDER(state)) {
44 WINED3DRENDERSTATETYPE RenderState = state - STATE_RENDER(0);
45 TRACE("(%s,%d) no direct mapping to gl\n", debug_d3drenderstate(RenderState), stateblock->renderState[RenderState]);
46 } else {
47 /* Shouldn't have an unknown type here */
48 FIXME("%d no direct mapping to gl of state with unknown type\n", state);
49 }
50}
51
Stefan Dösingerc739c382007-02-12 19:18:22 +0100[diff] [blame]52static void state_undefined(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
Stefan Dösinger2a24e842006-12-06 13:22:12 +0100[diff] [blame]53 /* Print a WARN, this allows the stateblock code to loop over all states to generate a display
54 * list without causing confusing terminal output. Deliberately no special debug name here
55 * because its undefined.
56 */
57 WARN("undefined state %d\n", state);
Stefan Dösingerc0268c72006-12-05 23:36:10 +0100[diff] [blame]58}
59
Stefan Dösingerc739c382007-02-12 19:18:22 +0100[diff] [blame]60static void state_fillmode(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
H. Verbeeta2fde7d2007-02-15 13:32:13 +0100[diff] [blame]61 WINED3DFILLMODE Value = stateblock->renderState[WINED3DRS_FILLMODE];
Stefan Dösingerde963202006-12-05 23:45:35 +0100[diff] [blame]62
63 switch(Value) {
H. Verbeeta2fde7d2007-02-15 13:32:13 +0100[diff] [blame]64 case WINED3DFILL_POINT:
Stefan Dösingerde963202006-12-05 23:45:35 +0100[diff] [blame]65 glPolygonMode(GL_FRONT_AND_BACK, GL_POINT);
66 checkGLcall("glPolygonMode(GL_FRONT_AND_BACK, GL_POINT)");
67 break;
H. Verbeeta2fde7d2007-02-15 13:32:13 +0100[diff] [blame]68 case WINED3DFILL_WIREFRAME:
Stefan Dösingerde963202006-12-05 23:45:35 +0100[diff] [blame]69 glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
70 checkGLcall("glPolygonMode(GL_FRONT_AND_BACK, GL_LINE)");
71 break;
H. Verbeeta2fde7d2007-02-15 13:32:13 +0100[diff] [blame]72 case WINED3DFILL_SOLID:
Stefan Dösingerde963202006-12-05 23:45:35 +0100[diff] [blame]73 glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
74 checkGLcall("glPolygonMode(GL_FRONT_AND_BACK, GL_FILL)");
75 break;
76 default:
77 FIXME("Unrecognized WINED3DRS_FILLMODE value %d\n", Value);
78 }
79}
80
Stefan Dösingerc739c382007-02-12 19:18:22 +0100[diff] [blame]81static void state_lighting(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
Stefan Dösinger266fc772007-02-16 19:08:34 +0100[diff] [blame]82 BOOL transformed;
Stefan Dösinger53e78892006-12-08 01:39:55 +0100[diff] [blame]83
Stefan Dösinger266fc772007-02-16 19:08:34 +0100[diff] [blame]84 /* Lighting is not enabled if transformed vertices are drawn
Stefan Dösingera0ff9822007-01-02 22:49:17 +0100[diff] [blame]85 * but lighting does not affect the stream sources, so it is not grouped for performance reasons.
86 * This state reads the decoded vertex decl, so if it is dirty don't do anything. The
87 * vertex declaration appplying function calls this function for updating
Stefan Dösinger53e78892006-12-08 01:39:55 +0100[diff] [blame]88 */
89
Stefan Dösinger380930d2007-02-12 19:18:31 +0100[diff] [blame]90 if(isStateDirty(context, STATE_VDECL)) {
Stefan Dösingerfe6165d2007-01-10 11:37:03 +0100[diff] [blame]91 return;
92 }
Stefan Dösingera0ff9822007-01-02 22:49:17 +0100[diff] [blame]93
Stefan Dösinger266fc772007-02-16 19:08:34 +0100[diff] [blame]94 transformed = ((stateblock->wineD3DDevice->strided_streams.u.s.position.lpData != NULL ||
95 stateblock->wineD3DDevice->strided_streams.u.s.position.VBO != 0) &&
96 stateblock->wineD3DDevice->strided_streams.u.s.position_transformed) ? TRUE : FALSE;
Stefan Dösingera0ff9822007-01-02 22:49:17 +0100[diff] [blame]97
Stefan Dösinger266fc772007-02-16 19:08:34 +0100[diff] [blame]98 if (stateblock->renderState[WINED3DRS_LIGHTING] && !transformed) {
Stefan Dösinger53e78892006-12-08 01:39:55 +0100[diff] [blame]99 glEnable(GL_LIGHTING);
100 checkGLcall("glEnable GL_LIGHTING");
101 } else {
102 glDisable(GL_LIGHTING);
103 checkGLcall("glDisable GL_LIGHTING");
104 }
105}
106
Stefan Dösingerc739c382007-02-12 19:18:22 +0100[diff] [blame]107static void state_zenable(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
Stefan Dösingerbb564dc2006-12-08 01:40:51 +0100[diff] [blame]108 switch ((WINED3DZBUFFERTYPE) stateblock->renderState[WINED3DRS_ZENABLE]) {
109 case WINED3DZB_FALSE:
110 glDisable(GL_DEPTH_TEST);
111 checkGLcall("glDisable GL_DEPTH_TEST");
112 break;
113 case WINED3DZB_TRUE:
114 glEnable(GL_DEPTH_TEST);
115 checkGLcall("glEnable GL_DEPTH_TEST");
116 break;
117 case WINED3DZB_USEW:
118 glEnable(GL_DEPTH_TEST);
119 checkGLcall("glEnable GL_DEPTH_TEST");
120 FIXME("W buffer is not well handled\n");
121 break;
122 default:
123 FIXME("Unrecognized D3DZBUFFERTYPE value %d\n", stateblock->renderState[WINED3DRS_ZENABLE]);
124 }
125}
126
Stefan Dösingerc739c382007-02-12 19:18:22 +0100[diff] [blame]127static void state_cullmode(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
Stefan Dösingere4b4c042006-12-08 01:41:43 +0100[diff] [blame]128 /* TODO: Put this into the offscreen / onscreen rendering block due to device->render_offscreen */
129
130 /* If we are culling "back faces with clockwise vertices" then
131 set front faces to be counter clockwise and enable culling
132 of back faces */
133 switch ((WINED3DCULL) stateblock->renderState[WINED3DRS_CULLMODE]) {
134 case WINED3DCULL_NONE:
135 glDisable(GL_CULL_FACE);
136 checkGLcall("glDisable GL_CULL_FACE");
137 break;
138 case WINED3DCULL_CW:
139 glEnable(GL_CULL_FACE);
140 checkGLcall("glEnable GL_CULL_FACE");
141 if (stateblock->wineD3DDevice->render_offscreen) {
142 glFrontFace(GL_CW);
143 checkGLcall("glFrontFace GL_CW");
144 } else {
145 glFrontFace(GL_CCW);
146 checkGLcall("glFrontFace GL_CCW");
147 }
148 glCullFace(GL_BACK);
149 break;
150 case WINED3DCULL_CCW:
151 glEnable(GL_CULL_FACE);
152 checkGLcall("glEnable GL_CULL_FACE");
153 if (stateblock->wineD3DDevice->render_offscreen) {
154 glFrontFace(GL_CCW);
155 checkGLcall("glFrontFace GL_CCW");
156 } else {
157 glFrontFace(GL_CW);
158 checkGLcall("glFrontFace GL_CW");
159 }
160 glCullFace(GL_BACK);
161 break;
162 default:
163 FIXME("Unrecognized/Unhandled WINED3DCULL value %d\n", stateblock->renderState[WINED3DRS_CULLMODE]);
164 }
165}
166
Stefan Dösingerc739c382007-02-12 19:18:22 +0100[diff] [blame]167static void state_shademode(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
Stefan Dösinger68f10822006-12-08 01:42:16 +0100[diff] [blame]168 switch ((WINED3DSHADEMODE) stateblock->renderState[WINED3DRS_SHADEMODE]) {
169 case WINED3DSHADE_FLAT:
170 glShadeModel(GL_FLAT);
171 checkGLcall("glShadeModel(GL_FLAT)");
172 break;
173 case WINED3DSHADE_GOURAUD:
174 glShadeModel(GL_SMOOTH);
175 checkGLcall("glShadeModel(GL_SMOOTH)");
176 break;
177 case WINED3DSHADE_PHONG:
178 FIXME("WINED3DSHADE_PHONG isn't supported\n");
179 break;
180 default:
181 FIXME("Unrecognized/Unhandled WINED3DSHADEMODE value %d\n", stateblock->renderState[WINED3DRS_SHADEMODE]);
182 }
183}
184
Stefan Dösingerc739c382007-02-12 19:18:22 +0100[diff] [blame]185static void state_ditherenable(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
Stefan Dösingerbb622e82006-12-08 01:42:43 +0100[diff] [blame]186 if (stateblock->renderState[WINED3DRS_DITHERENABLE]) {
187 glEnable(GL_DITHER);
188 checkGLcall("glEnable GL_DITHER");
189 } else {
190 glDisable(GL_DITHER);
191 checkGLcall("glDisable GL_DITHER");
192 }
193}
194
Stefan Dösingerc739c382007-02-12 19:18:22 +0100[diff] [blame]195static void state_zwritenable(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
Stefan Dösinger8879c7d2006-12-08 01:43:25 +0100[diff] [blame]196 /* TODO: Test if in d3d z writing is enabled even if ZENABLE is off. If yes,
197 * this has to be merged with ZENABLE and ZFUNC
198 */
199 if (stateblock->renderState[WINED3DRS_ZWRITEENABLE]) {
200 glDepthMask(1);
201 checkGLcall("glDepthMask(1)");
202 } else {
203 glDepthMask(0);
204 checkGLcall("glDepthMask(0)");
205 }
206}
207
Stefan Dösingerc739c382007-02-12 19:18:22 +0100[diff] [blame]208static void state_zfunc(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
Stefan Dösinger2ac48e82006-12-08 01:44:55 +0100[diff] [blame]209 int glParm = CompareFunc(stateblock->renderState[WINED3DRS_ZFUNC]);
210
211 if(glParm) {
212 glDepthFunc(glParm);
213 checkGLcall("glDepthFunc");
214 }
215}
216
Stefan Dösingerc739c382007-02-12 19:18:22 +0100[diff] [blame]217static void state_ambient(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
Alexandre Julliardbbfe1202006-12-29 11:35:57 +0100[diff] [blame]218 float col[4];
219 D3DCOLORTOGLFLOAT4(stateblock->renderState[WINED3DRS_AMBIENT], col);
Stefan Dösinger28cc3c82006-12-08 01:45:26 +0100[diff] [blame]220
Alexandre Julliardbbfe1202006-12-29 11:35:57 +0100[diff] [blame]221 TRACE("Setting ambient to (%f,%f,%f,%f)\n", col[0], col[1], col[2], col[3]);
222 glLightModelfv(GL_LIGHT_MODEL_AMBIENT, col);
Stefan Dösinger28cc3c82006-12-08 01:45:26 +0100[diff] [blame]223 checkGLcall("glLightModel for MODEL_AMBIENT");
224}
225
Stefan Dösingerc739c382007-02-12 19:18:22 +0100[diff] [blame]226static void state_blend(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
Stefan Dösinger1f07e4a2006-12-08 01:51:11 +0100[diff] [blame]227 int srcBlend = GL_ZERO;
228 int dstBlend = GL_ZERO;
Stefan Dösinger1f07e4a2006-12-08 01:51:11 +0100[diff] [blame]229
230 /* GL_LINE_SMOOTH needs GL_BLEND to work, according to the red book, and special blending params */
Stefan Dösinger1f07e4a2006-12-08 01:51:11 +0100[diff] [blame]231 if (stateblock->renderState[WINED3DRS_ALPHABLENDENABLE] ||
232 stateblock->renderState[WINED3DRS_EDGEANTIALIAS] ||
Stefan Dösingerd6245402006-12-25 18:46:59 +0100[diff] [blame]233 stateblock->renderState[WINED3DRS_ANTIALIASEDLINEENABLE]) {
Stefan Dösinger1f07e4a2006-12-08 01:51:11 +0100[diff] [blame]234 glEnable(GL_BLEND);
235 checkGLcall("glEnable GL_BLEND");
236 } else {
237 glDisable(GL_BLEND);
238 checkGLcall("glDisable GL_BLEND");
239 /* Nothing more to do - get out */
240 return;
241 };
242
243 switch (stateblock->renderState[WINED3DRS_SRCBLEND]) {
244 case WINED3DBLEND_ZERO : srcBlend = GL_ZERO; break;
245 case WINED3DBLEND_ONE : srcBlend = GL_ONE; break;
246 case WINED3DBLEND_SRCCOLOR : srcBlend = GL_SRC_COLOR; break;
247 case WINED3DBLEND_INVSRCCOLOR : srcBlend = GL_ONE_MINUS_SRC_COLOR; break;
248 case WINED3DBLEND_SRCALPHA : srcBlend = GL_SRC_ALPHA; break;
249 case WINED3DBLEND_INVSRCALPHA : srcBlend = GL_ONE_MINUS_SRC_ALPHA; break;
250 case WINED3DBLEND_DESTALPHA : srcBlend = GL_DST_ALPHA; break;
251 case WINED3DBLEND_INVDESTALPHA : srcBlend = GL_ONE_MINUS_DST_ALPHA; break;
252 case WINED3DBLEND_DESTCOLOR : srcBlend = GL_DST_COLOR; break;
253 case WINED3DBLEND_INVDESTCOLOR : srcBlend = GL_ONE_MINUS_DST_COLOR; break;
254 case WINED3DBLEND_SRCALPHASAT : srcBlend = GL_SRC_ALPHA_SATURATE; break;
255
256 case WINED3DBLEND_BOTHSRCALPHA : srcBlend = GL_SRC_ALPHA;
257 dstBlend = GL_SRC_ALPHA;
258 break;
259
260 case WINED3DBLEND_BOTHINVSRCALPHA : srcBlend = GL_ONE_MINUS_SRC_ALPHA;
261 dstBlend = GL_ONE_MINUS_SRC_ALPHA;
262 break;
263
264 case WINED3DBLEND_BLENDFACTOR : srcBlend = GL_CONSTANT_COLOR; break;
265 case WINED3DBLEND_INVBLENDFACTOR : srcBlend = GL_ONE_MINUS_CONSTANT_COLOR; break;
266 default:
267 FIXME("Unrecognized src blend value %d\n", stateblock->renderState[WINED3DRS_SRCBLEND]);
268 }
269
270 switch (stateblock->renderState[WINED3DRS_DESTBLEND]) {
271 case WINED3DBLEND_ZERO : dstBlend = GL_ZERO; break;
272 case WINED3DBLEND_ONE : dstBlend = GL_ONE; break;
273 case WINED3DBLEND_SRCCOLOR : dstBlend = GL_SRC_COLOR; break;
274 case WINED3DBLEND_INVSRCCOLOR : dstBlend = GL_ONE_MINUS_SRC_COLOR; break;
275 case WINED3DBLEND_SRCALPHA : dstBlend = GL_SRC_ALPHA; break;
276 case WINED3DBLEND_INVSRCALPHA : dstBlend = GL_ONE_MINUS_SRC_ALPHA; break;
277 case WINED3DBLEND_DESTALPHA : dstBlend = GL_DST_ALPHA; break;
278 case WINED3DBLEND_INVDESTALPHA : dstBlend = GL_ONE_MINUS_DST_ALPHA; break;
279 case WINED3DBLEND_DESTCOLOR : dstBlend = GL_DST_COLOR; break;
280 case WINED3DBLEND_INVDESTCOLOR : dstBlend = GL_ONE_MINUS_DST_COLOR; break;
281 case WINED3DBLEND_SRCALPHASAT : dstBlend = GL_SRC_ALPHA_SATURATE; break;
282
283 case WINED3DBLEND_BOTHSRCALPHA : dstBlend = GL_SRC_ALPHA;
284 srcBlend = GL_SRC_ALPHA;
285 break;
286
287 case WINED3DBLEND_BOTHINVSRCALPHA : dstBlend = GL_ONE_MINUS_SRC_ALPHA;
288 srcBlend = GL_ONE_MINUS_SRC_ALPHA;
289 break;
290
H. Verbeeta2fde7d2007-02-15 13:32:13 +0100[diff] [blame]291 case WINED3DBLEND_BLENDFACTOR : dstBlend = GL_CONSTANT_COLOR; break;
292 case WINED3DBLEND_INVBLENDFACTOR : dstBlend = GL_ONE_MINUS_CONSTANT_COLOR; break;
Stefan Dösinger1f07e4a2006-12-08 01:51:11 +0100[diff] [blame]293 default:
294 FIXME("Unrecognized dst blend value %d\n", stateblock->renderState[WINED3DRS_DESTBLEND]);
295 }
296
297 if(stateblock->renderState[WINED3DRS_EDGEANTIALIAS] ||
298 stateblock->renderState[WINED3DRS_ANTIALIASEDLINEENABLE]) {
299 glEnable(GL_LINE_SMOOTH);
300 checkGLcall("glEnable(GL_LINE_SMOOTH)");
301 if(srcBlend != GL_SRC_ALPHA) {
302 FIXME("WINED3DRS_EDGEANTIALIAS enabled, but incompatible src blending param - what to do?\n");
303 srcBlend = GL_SRC_ALPHA;
304 }
305 if(dstBlend != GL_ONE_MINUS_SRC_ALPHA) {
306 FIXME("WINED3DRS_EDGEANTIALIAS enabled, but incompatible dst blending param - what to do?\n");
307 dstBlend = GL_ONE_MINUS_SRC_ALPHA;
308 }
309 } else {
310 glDisable(GL_LINE_SMOOTH);
311 checkGLcall("glDisable(GL_LINE_SMOOTH)");
312 }
313
314 TRACE("glBlendFunc src=%x, dst=%x\n", srcBlend, dstBlend);
315 glBlendFunc(srcBlend, dstBlend);
316 checkGLcall("glBlendFunc");
Stefan Dösingerd6245402006-12-25 18:46:59 +0100[diff] [blame]317}
318
Stefan Dösingerc739c382007-02-12 19:18:22 +0100[diff] [blame]319static void state_blendfactor(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
Stefan Dösingerd6245402006-12-25 18:46:59 +0100[diff] [blame]320 float col[4];
Stefan Dösinger1f07e4a2006-12-08 01:51:11 +0100[diff] [blame]321
322 TRACE("Setting BlendFactor to %d\n", stateblock->renderState[WINED3DRS_BLENDFACTOR]);
323 D3DCOLORTOGLFLOAT4(stateblock->renderState[WINED3DRS_BLENDFACTOR], col);
324 glBlendColor (col[0],col[1],col[2],col[3]);
325 checkGLcall("glBlendColor");
326}
327
Stefan Dösingerc739c382007-02-12 19:18:22 +0100[diff] [blame]328static void state_alpha(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
Stefan Dösingerc88efee2006-12-08 20:21:32 +0100[diff] [blame]329 int glParm = 0;
330 float ref;
331 BOOL enable_ckey = FALSE;
332
333 IWineD3DSurfaceImpl *surf;
334
335 /* Find out if the texture on the first stage has a ckey set
336 * The alpha state func reads the texture settings, even though alpha and texture are not grouped
337 * together. This is to avoid making a huge alpha+texture+texture stage+ckey block due to the hardly
338 * used WINED3DRS_COLORKEYENABLE state(which is d3d <= 3 only). The texture function will call alpha
339 * in case it finds some texture+colorkeyenable combination which needs extra care.
340 */
Stefan Dösingerd4c4e5d2007-02-15 03:05:54 +0100[diff] [blame]341 if(stateblock->textures[0] && stateblock->textureDimensions[0] == GL_TEXTURE_2D) {
Stefan Dösingerc88efee2006-12-08 20:21:32 +0100[diff] [blame]342 surf = (IWineD3DSurfaceImpl *) ((IWineD3DTextureImpl *)stateblock->textures[0])->surfaces[0];
Stefan Dösingerd4c4e5d2007-02-15 03:05:54 +0100[diff] [blame]343
344 if(surf->CKeyFlags & DDSD_CKSRCBLT) {
345 const PixelFormatDesc *fmt = getFormatDescEntry(surf->resource.format);
346 /* The surface conversion does not do color keying conversion for surfaces that have an alpha
347 * channel on their own. Likewise, the alpha test shouldn't be set up for color keying if the
348 * surface has alpha bits
349 */
350 if(fmt->alphaMask == 0x00000000) {
351 enable_ckey = TRUE;
352 }
353 }
Stefan Dösingerc88efee2006-12-08 20:21:32 +0100[diff] [blame]354 }
355
Stefan Dösingerb3f96f42007-02-15 03:04:18 +0100[diff] [blame]356 if(enable_ckey || context->last_was_ckey) {
357 StateTable[STATE_TEXTURESTAGE(0, WINED3DTSS_ALPHAOP)].apply(STATE_TEXTURESTAGE(0, WINED3DTSS_ALPHAOP), stateblock, context);
358 }
359 context->last_was_ckey = enable_ckey;
360
Stefan Dösingerc88efee2006-12-08 20:21:32 +0100[diff] [blame]361 if (stateblock->renderState[WINED3DRS_ALPHATESTENABLE] ||
362 (stateblock->renderState[WINED3DRS_COLORKEYENABLE] && enable_ckey)) {
363 glEnable(GL_ALPHA_TEST);
364 checkGLcall("glEnable GL_ALPHA_TEST");
365 } else {
366 glDisable(GL_ALPHA_TEST);
367 checkGLcall("glDisable GL_ALPHA_TEST");
368 /* Alpha test is disabled, don't bother setting the params - it will happen on the next
369 * enable call
370 */
371 return;
372 }
373
374 if(stateblock->renderState[WINED3DRS_COLORKEYENABLE] && enable_ckey) {
375 glParm = GL_NOTEQUAL;
376 ref = 0.0;
377 } else {
378 ref = ((float) stateblock->renderState[WINED3DRS_ALPHAREF]) / 255.0f;
379 glParm = CompareFunc(stateblock->renderState[WINED3DRS_ALPHAFUNC]);
380 }
381 if(glParm) {
Stefan Dösingerc88efee2006-12-08 20:21:32 +0100[diff] [blame]382 glAlphaFunc(glParm, ref);
383 checkGLcall("glAlphaFunc");
384 }
Stefan Dösingerc88efee2006-12-08 20:21:32 +0100[diff] [blame]385}
386
Stefan Dösingerc739c382007-02-12 19:18:22 +0100[diff] [blame]387static void state_clipping(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
Stefan Dösinger89e999a2006-12-08 18:01:23 +0100[diff] [blame]388 DWORD enable = 0xFFFFFFFF;
389 DWORD disable = 0x00000000;
390
391 /* TODO: Keep track of previously enabled clipplanes to avoid unneccessary resetting
392 * of already set values
393 */
394
395 /* If enabling / disabling all
396 * TODO: Is this correct? Doesn't D3DRS_CLIPPING disable clipping on the viewport frustrum?
397 */
398 if (stateblock->renderState[WINED3DRS_CLIPPING]) {
399 enable = stateblock->renderState[WINED3DRS_CLIPPLANEENABLE];
400 disable = ~stateblock->renderState[WINED3DRS_CLIPPLANEENABLE];
401 } else {
402 disable = 0xffffffff;
403 enable = 0x00;
404 }
405
406 if (enable & WINED3DCLIPPLANE0) { glEnable(GL_CLIP_PLANE0); checkGLcall("glEnable(clip plane 0)"); }
407 if (enable & WINED3DCLIPPLANE1) { glEnable(GL_CLIP_PLANE1); checkGLcall("glEnable(clip plane 1)"); }
408 if (enable & WINED3DCLIPPLANE2) { glEnable(GL_CLIP_PLANE2); checkGLcall("glEnable(clip plane 2)"); }
409 if (enable & WINED3DCLIPPLANE3) { glEnable(GL_CLIP_PLANE3); checkGLcall("glEnable(clip plane 3)"); }
410 if (enable & WINED3DCLIPPLANE4) { glEnable(GL_CLIP_PLANE4); checkGLcall("glEnable(clip plane 4)"); }
411 if (enable & WINED3DCLIPPLANE5) { glEnable(GL_CLIP_PLANE5); checkGLcall("glEnable(clip plane 5)"); }
412
413 if (disable & WINED3DCLIPPLANE0) { glDisable(GL_CLIP_PLANE0); checkGLcall("glDisable(clip plane 0)"); }
414 if (disable & WINED3DCLIPPLANE1) { glDisable(GL_CLIP_PLANE1); checkGLcall("glDisable(clip plane 1)"); }
415 if (disable & WINED3DCLIPPLANE2) { glDisable(GL_CLIP_PLANE2); checkGLcall("glDisable(clip plane 2)"); }
416 if (disable & WINED3DCLIPPLANE3) { glDisable(GL_CLIP_PLANE3); checkGLcall("glDisable(clip plane 3)"); }
417 if (disable & WINED3DCLIPPLANE4) { glDisable(GL_CLIP_PLANE4); checkGLcall("glDisable(clip plane 4)"); }
418 if (disable & WINED3DCLIPPLANE5) { glDisable(GL_CLIP_PLANE5); checkGLcall("glDisable(clip plane 5)"); }
419
420 /** update clipping status */
421 if (enable) {
422 stateblock->clip_status.ClipUnion = 0;
423 stateblock->clip_status.ClipIntersection = 0xFFFFFFFF;
424 } else {
425 stateblock->clip_status.ClipUnion = 0;
426 stateblock->clip_status.ClipIntersection = 0;
427 }
428}
429
Stefan Dösingerc739c382007-02-12 19:18:22 +0100[diff] [blame]430static void state_blendop(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
Stefan Dösingerac261722006-12-08 20:21:43 +0100[diff] [blame]431 int glParm = GL_FUNC_ADD;
432
433 if(!GL_SUPPORT(EXT_BLEND_MINMAX)) {
434 WARN("Unsupported in local OpenGL implementation: glBlendEquation\n");
435 return;
436 }
437
438 switch ((WINED3DBLENDOP) stateblock->renderState[WINED3DRS_BLENDOP]) {
439 case WINED3DBLENDOP_ADD : glParm = GL_FUNC_ADD; break;
440 case WINED3DBLENDOP_SUBTRACT : glParm = GL_FUNC_SUBTRACT; break;
441 case WINED3DBLENDOP_REVSUBTRACT : glParm = GL_FUNC_REVERSE_SUBTRACT; break;
442 case WINED3DBLENDOP_MIN : glParm = GL_MIN; break;
443 case WINED3DBLENDOP_MAX : glParm = GL_MAX; break;
444 default:
445 FIXME("Unrecognized/Unhandled D3DBLENDOP value %d\n", stateblock->renderState[WINED3DRS_BLENDOP]);
446 }
447
448 TRACE("glBlendEquation(%x)\n", glParm);
449 GL_EXTCALL(glBlendEquation(glParm));
450 checkGLcall("glBlendEquation");
451}
452
Stefan Dösinger0772bb42006-12-08 18:38:30 +0100[diff] [blame]453static void
Stefan Dösingerc739c382007-02-12 19:18:22 +0100[diff] [blame]454state_specularenable(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
Stefan Dösinger0772bb42006-12-08 18:38:30 +0100[diff] [blame]455 /* Originally this used glLightModeli(GL_LIGHT_MODEL_COLOR_CONTROL,GL_SEPARATE_SPECULAR_COLOR)
456 * and (GL_LIGHT_MODEL_COLOR_CONTROL,GL_SINGLE_COLOR) to swap between enabled/disabled
457 * specular color. This is wrong:
458 * Separate specular color means the specular colour is maintained separately, whereas
459 * single color means it is merged in. However in both cases they are being used to
460 * some extent.
461 * To disable specular color, set it explicitly to black and turn off GL_COLOR_SUM_EXT
462 * NOTE: If not supported don't give FIXMEs the impact is really minimal and very few people are
463 * running 1.4 yet!
464 *
465 *
466 * If register combiners are enabled, enabling / disabling GL_COLOR_SUM has no effect.
467 * Instead, we need to setup the FinalCombiner properly.
468 *
469 * The default setup for the FinalCombiner is:
470 *
471 * <variable> <input> <mapping> <usage>
472 * GL_VARIABLE_A_NV GL_FOG, GL_UNSIGNED_IDENTITY_NV GL_ALPHA
473 * GL_VARIABLE_B_NV GL_SPARE0_PLUS_SECONDARY_COLOR_NV GL_UNSIGNED_IDENTITY_NV GL_RGB
474 * GL_VARIABLE_C_NV GL_FOG GL_UNSIGNED_IDENTITY_NV GL_RGB
475 * GL_VARIABLE_D_NV GL_ZERO GL_UNSIGNED_IDENTITY_NV GL_RGB
476 * GL_VARIABLE_E_NV GL_ZERO GL_UNSIGNED_IDENTITY_NV GL_RGB
477 * GL_VARIABLE_F_NV GL_ZERO GL_UNSIGNED_IDENTITY_NV GL_RGB
478 * GL_VARIABLE_G_NV GL_SPARE0_NV GL_UNSIGNED_IDENTITY_NV GL_ALPHA
479 *
480 * That's pretty much fine as it is, except for variable B, which needs to take
481 * either GL_SPARE0_PLUS_SECONDARY_COLOR_NV or GL_SPARE0_NV, depending on
482 * whether WINED3DRS_SPECULARENABLE is enabled or not.
483 */
484
485 TRACE("Setting specular enable state\n");
486 /* TODO: Add to the material setting functions */
487 if (stateblock->renderState[WINED3DRS_SPECULARENABLE]) {
488 glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, (float*) &stateblock->material.Specular);
489 checkGLcall("glMaterialfv");
490 if (GL_SUPPORT(EXT_SECONDARY_COLOR)) {
491 glEnable(GL_COLOR_SUM_EXT);
492 } else {
493 TRACE("Specular colors cannot be enabled in this version of opengl\n");
494 }
495 checkGLcall("glEnable(GL_COLOR_SUM)");
496
497 if (GL_SUPPORT(NV_REGISTER_COMBINERS)) {
498 GL_EXTCALL(glFinalCombinerInputNV(GL_VARIABLE_B_NV, GL_SPARE0_PLUS_SECONDARY_COLOR_NV, GL_UNSIGNED_IDENTITY_NV, GL_RGB));
499 checkGLcall("glFinalCombinerInputNV()");
500 }
501 } else {
502 float black[4] = {0.0f, 0.0f, 0.0f, 0.0f};
503
504 /* for the case of enabled lighting: */
505 glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, &black[0]);
506 checkGLcall("glMaterialfv");
507
508 /* for the case of disabled lighting: */
509 if (GL_SUPPORT(EXT_SECONDARY_COLOR)) {
510 glDisable(GL_COLOR_SUM_EXT);
511 } else {
512 TRACE("Specular colors cannot be disabled in this version of opengl\n");
513 }
514 checkGLcall("glDisable(GL_COLOR_SUM)");
515
516 if (GL_SUPPORT(NV_REGISTER_COMBINERS)) {
517 GL_EXTCALL(glFinalCombinerInputNV(GL_VARIABLE_B_NV, GL_SPARE0_NV, GL_UNSIGNED_IDENTITY_NV, GL_RGB));
518 checkGLcall("glFinalCombinerInputNV()");
519 }
520 }
521}
522
Stefan Dösingerc739c382007-02-12 19:18:22 +0100[diff] [blame]523static void state_texfactor(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
Stefan Dösinger287c6242006-12-08 18:37:17 +0100[diff] [blame]524 unsigned int i;
525
526 /* Note the texture color applies to all textures whereas
527 * GL_TEXTURE_ENV_COLOR applies to active only
528 */
Alexandre Julliardbbfe1202006-12-29 11:35:57 +0100[diff] [blame]529 float col[4];
530 D3DCOLORTOGLFLOAT4(stateblock->renderState[WINED3DRS_TEXTUREFACTOR], col);
Stefan Dösinger287c6242006-12-08 18:37:17 +0100[diff] [blame]531
532 if (!GL_SUPPORT(NV_REGISTER_COMBINERS)) {
533 /* And now the default texture color as well */
534 for (i = 0; i < GL_LIMITS(texture_stages); i++) {
535 /* Note the WINED3DRS value applies to all textures, but GL has one
536 * per texture, so apply it now ready to be used!
537 */
538 if (GL_SUPPORT(ARB_MULTITEXTURE)) {
539 GL_EXTCALL(glActiveTextureARB(GL_TEXTURE0_ARB + i));
540 checkGLcall("glActiveTextureARB");
541 } else if (i>0) {
542 FIXME("Program using multiple concurrent textures which this opengl implementation doesn't support\n");
543 }
544
Alexandre Julliardbbfe1202006-12-29 11:35:57 +0100[diff] [blame]545 glTexEnvfv(GL_TEXTURE_ENV, GL_TEXTURE_ENV_COLOR, &col[0]);
Stefan Dösinger287c6242006-12-08 18:37:17 +0100[diff] [blame]546 checkGLcall("glTexEnvfv(GL_TEXTURE_ENV, GL_TEXTURE_ENV_COLOR, color);");
547 }
Stefan Dösinger666b5072006-12-19 23:26:39 +0100[diff] [blame]548 } else {
Alexandre Julliardbbfe1202006-12-29 11:35:57 +0100[diff] [blame]549 GL_EXTCALL(glCombinerParameterfvNV(GL_CONSTANT_COLOR0_NV, &col[0]));
Stefan Dösinger287c6242006-12-08 18:37:17 +0100[diff] [blame]550 }
551}
552
Stefan Dösinger0d9ae202006-12-08 18:39:45 +0100[diff] [blame]553static void
554renderstate_stencil_twosided(IWineD3DStateBlockImpl *stateblock, GLint face, GLint func, GLint ref, GLuint mask, GLint stencilFail, GLint depthFail, GLint stencilPass ) {
555#if 0 /* Don't use OpenGL 2.0 calls for now */
556 if(GL_EXTCALL(glStencilFuncSeparate) && GL_EXTCALL(glStencilOpSeparate)) {
557 GL_EXTCALL(glStencilFuncSeparate(face, func, ref, mask));
558 checkGLcall("glStencilFuncSeparate(...)");
559 GL_EXTCALL(glStencilOpSeparate(face, stencilFail, depthFail, stencilPass));
560 checkGLcall("glStencilOpSeparate(...)");
561 }
562 else
563#endif
564 if(GL_SUPPORT(EXT_STENCIL_TWO_SIDE)) {
565 glEnable(GL_STENCIL_TEST_TWO_SIDE_EXT);
566 checkGLcall("glEnable(GL_STENCIL_TEST_TWO_SIDE_EXT)");
567 GL_EXTCALL(glActiveStencilFaceEXT(face));
568 checkGLcall("glActiveStencilFaceEXT(...)");
569 glStencilFunc(func, ref, mask);
570 checkGLcall("glStencilFunc(...)");
571 glStencilOp(stencilFail, depthFail, stencilPass);
572 checkGLcall("glStencilOp(...)");
573 } else if(GL_SUPPORT(ATI_SEPARATE_STENCIL)) {
574 GL_EXTCALL(glStencilFuncSeparateATI(face, func, ref, mask));
575 checkGLcall("glStencilFuncSeparateATI(...)");
576 GL_EXTCALL(glStencilOpSeparateATI(face, stencilFail, depthFail, stencilPass));
577 checkGLcall("glStencilOpSeparateATI(...)");
578 } else {
579 ERR("Separate (two sided) stencil not supported on this version of opengl. Caps weren't honored?\n");
580 }
581}
582
583static void
Stefan Dösingerc739c382007-02-12 19:18:22 +0100[diff] [blame]584state_stencil(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
Stefan Dösinger0d9ae202006-12-08 18:39:45 +0100[diff] [blame]585 DWORD onesided_enable = FALSE;
586 DWORD twosided_enable = FALSE;
587 GLint func = GL_ALWAYS;
588 GLint func_ccw = GL_ALWAYS;
589 GLint ref = 0;
590 GLuint mask = 0;
591 GLint stencilFail = GL_KEEP;
592 GLint depthFail = GL_KEEP;
593 GLint stencilPass = GL_KEEP;
594 GLint stencilFail_ccw = GL_KEEP;
595 GLint depthFail_ccw = GL_KEEP;
596 GLint stencilPass_ccw = GL_KEEP;
597
598 if( stateblock->set.renderState[WINED3DRS_STENCILENABLE] )
599 onesided_enable = stateblock->renderState[WINED3DRS_STENCILENABLE];
600 if( stateblock->set.renderState[WINED3DRS_TWOSIDEDSTENCILMODE] )
601 twosided_enable = stateblock->renderState[WINED3DRS_TWOSIDEDSTENCILMODE];
602 if( stateblock->set.renderState[WINED3DRS_STENCILFUNC] )
603 if( !( func = CompareFunc(stateblock->renderState[WINED3DRS_STENCILFUNC]) ) )
604 func = GL_ALWAYS;
605 if( stateblock->set.renderState[WINED3DRS_CCW_STENCILFUNC] )
606 if( !( func_ccw = CompareFunc(stateblock->renderState[WINED3DRS_CCW_STENCILFUNC]) ) )
607 func = GL_ALWAYS;
608 if( stateblock->set.renderState[WINED3DRS_STENCILREF] )
609 ref = stateblock->renderState[WINED3DRS_STENCILREF];
610 if( stateblock->set.renderState[WINED3DRS_STENCILMASK] )
611 mask = stateblock->renderState[WINED3DRS_STENCILMASK];
612 if( stateblock->set.renderState[WINED3DRS_STENCILFAIL] )
613 stencilFail = StencilOp(stateblock->renderState[WINED3DRS_STENCILFAIL]);
614 if( stateblock->set.renderState[WINED3DRS_STENCILZFAIL] )
615 depthFail = StencilOp(stateblock->renderState[WINED3DRS_STENCILZFAIL]);
616 if( stateblock->set.renderState[WINED3DRS_STENCILPASS] )
617 stencilPass = StencilOp(stateblock->renderState[WINED3DRS_STENCILPASS]);
618 if( stateblock->set.renderState[WINED3DRS_CCW_STENCILFAIL] )
619 stencilFail_ccw = StencilOp(stateblock->renderState[WINED3DRS_CCW_STENCILFAIL]);
620 if( stateblock->set.renderState[WINED3DRS_CCW_STENCILZFAIL] )
621 depthFail_ccw = StencilOp(stateblock->renderState[WINED3DRS_CCW_STENCILZFAIL]);
622 if( stateblock->set.renderState[WINED3DRS_CCW_STENCILPASS] )
623 stencilPass_ccw = StencilOp(stateblock->renderState[WINED3DRS_CCW_STENCILPASS]);
624
Michael Stefaniuc33af3c52007-01-09 23:42:26 +0100[diff] [blame]625 TRACE("(onesided %d, twosided %d, ref %x, mask %x, "
626 "GL_FRONT: func: %x, fail %x, zfail %x, zpass %x "
627 "GL_BACK: func: %x, fail %x, zfail %x, zpass %x )\n",
Stefan Dösinger0d9ae202006-12-08 18:39:45 +0100[diff] [blame]628 onesided_enable, twosided_enable, ref, mask,
629 func, stencilFail, depthFail, stencilPass,
630 func_ccw, stencilFail_ccw, depthFail_ccw, stencilPass_ccw);
631
632 if (twosided_enable) {
633 renderstate_stencil_twosided(stateblock, GL_FRONT, func, ref, mask, stencilFail, depthFail, stencilPass);
634 renderstate_stencil_twosided(stateblock, GL_BACK, func_ccw, ref, mask, stencilFail_ccw, depthFail_ccw, stencilPass_ccw);
635 } else {
636 if (onesided_enable) {
637 glEnable(GL_STENCIL_TEST);
638 checkGLcall("glEnable GL_STENCIL_TEST");
639 glStencilFunc(func, ref, mask);
640 checkGLcall("glStencilFunc(...)");
641 glStencilOp(stencilFail, depthFail, stencilPass);
642 checkGLcall("glStencilOp(...)");
643 } else {
644 glDisable(GL_STENCIL_TEST);
645 checkGLcall("glDisable GL_STENCIL_TEST");
646 }
647 }
648}
649
Stefan Dösingerc739c382007-02-12 19:18:22 +0100[diff] [blame]650static void state_stencilwrite(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
Stefan Dösinger8d724312006-12-08 18:41:05 +0100[diff] [blame]651 glStencilMask(stateblock->renderState[WINED3DRS_STENCILWRITEMASK]);
652 checkGLcall("glStencilMask");
653}
654
Stefan Dösingerc739c382007-02-12 19:18:22 +0100[diff] [blame]655static void state_fog(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
Stefan Dösinger61752732006-12-08 18:42:43 +0100[diff] [blame]656 /* TODO: Put this into the vertex type block once that is in the state table */
657 BOOL fogenable = stateblock->renderState[WINED3DRS_FOGENABLE];
658 float fogstart, fogend;
659
660 union {
661 DWORD d;
662 float f;
663 } tmpvalue;
664
665 if (!fogenable) {
666 /* No fog? Disable it, and we're done :-) */
667 glDisable(GL_FOG);
668 checkGLcall("glDisable GL_FOG");
Stefan Dösinger38d961a2007-02-25 23:58:14 +0100[diff] [blame^]669 return;
Stefan Dösinger61752732006-12-08 18:42:43 +0100[diff] [blame]670 }
671
672 tmpvalue.d = stateblock->renderState[WINED3DRS_FOGSTART];
673 fogstart = tmpvalue.f;
674 tmpvalue.d = stateblock->renderState[WINED3DRS_FOGEND];
675 fogend = tmpvalue.f;
676
Stefan Dösinger61752732006-12-08 18:42:43 +0100[diff] [blame]677 /* Activate when vertex shaders are in the state table */
678 if(stateblock->vertexShader && ((IWineD3DVertexShaderImpl *)stateblock->vertexShader)->baseShader.function &&
679 ((IWineD3DVertexShaderImpl *)stateblock->vertexShader)->usesFog) {
680 glFogi(GL_FOG_MODE, GL_LINEAR);
681 checkGLcall("glFogi(GL_FOG_MODE, GL_LINEAR)");
Vitaliy Margolen51ee7f42007-02-25 18:03:00 -0700[diff] [blame]682 if (stateblock->renderState[WINED3DRS_FOGTABLEMODE] == WINED3DFOG_NONE) {
683 fogstart = 1.0;
684 fogend = 0.0;
685 }
Stefan Dösingere6c9a072007-02-12 19:18:27 +0100[diff] [blame]686 context->last_was_foggy_shader = TRUE;
Stefan Dösinger61752732006-12-08 18:42:43 +0100[diff] [blame]687 }
Stefan Dösinger61752732006-12-08 18:42:43 +0100[diff] [blame]688 /* DX 7 sdk: "If both render states(vertex and table fog) are set to valid modes,
689 * the system will apply only pixel(=table) fog effects."
690 */
H. Verbeeta2fde7d2007-02-15 13:32:13 +0100[diff] [blame]691 else if(stateblock->renderState[WINED3DRS_FOGTABLEMODE] == WINED3DFOG_NONE) {
Stefan Dösinger61752732006-12-08 18:42:43 +0100[diff] [blame]692 glHint(GL_FOG_HINT, GL_FASTEST);
693 checkGLcall("glHint(GL_FOG_HINT, GL_FASTEST)");
Stefan Dösingere6c9a072007-02-12 19:18:27 +0100[diff] [blame]694 context->last_was_foggy_shader = FALSE;
Stefan Dösinger20de2002007-01-02 22:47:10 +0100[diff] [blame]695
Stefan Dösinger61752732006-12-08 18:42:43 +0100[diff] [blame]696 switch (stateblock->renderState[WINED3DRS_FOGVERTEXMODE]) {
697 /* Processed vertices have their fog factor stored in the specular value. Fall too the none case.
698 * If we are drawing untransformed vertices atm, d3ddevice_set_ortho will update the fog
699 */
H. Verbeeta2fde7d2007-02-15 13:32:13 +0100[diff] [blame]700 case WINED3DFOG_EXP: {
Stefan Dösingere6c9a072007-02-12 19:18:27 +0100[diff] [blame]701 if(!context->last_was_rhw) {
Stefan Dösinger61752732006-12-08 18:42:43 +0100[diff] [blame]702 glFogi(GL_FOG_MODE, GL_EXP);
703 checkGLcall("glFogi(GL_FOG_MODE, GL_EXP");
704 if(GL_SUPPORT(EXT_FOG_COORD)) {
705 glFogi(GL_FOG_COORDINATE_SOURCE_EXT, GL_FRAGMENT_DEPTH_EXT);
706 checkGLcall("glFogi(GL_FOG_COORDINATE_SOURCE_EXT, GL_FRAGMENT_DEPTH_EXT");
707 }
708 break;
709 }
710 }
H. Verbeeta2fde7d2007-02-15 13:32:13 +0100[diff] [blame]711 case WINED3DFOG_EXP2: {
Stefan Dösingere6c9a072007-02-12 19:18:27 +0100[diff] [blame]712 if(!context->last_was_rhw) {
Stefan Dösinger61752732006-12-08 18:42:43 +0100[diff] [blame]713 glFogi(GL_FOG_MODE, GL_EXP2);
714 checkGLcall("glFogi(GL_FOG_MODE, GL_EXP2");
715 if(GL_SUPPORT(EXT_FOG_COORD)) {
716 glFogi(GL_FOG_COORDINATE_SOURCE_EXT, GL_FRAGMENT_DEPTH_EXT);
717 checkGLcall("glFogi(GL_FOG_COORDINATE_SOURCE_EXT, GL_FRAGMENT_DEPTH_EXT");
718 }
719 break;
720 }
721 }
H. Verbeeta2fde7d2007-02-15 13:32:13 +0100[diff] [blame]722 case WINED3DFOG_LINEAR: {
Stefan Dösingere6c9a072007-02-12 19:18:27 +0100[diff] [blame]723 if(!context->last_was_rhw) {
Stefan Dösinger61752732006-12-08 18:42:43 +0100[diff] [blame]724 glFogi(GL_FOG_MODE, GL_LINEAR);
725 checkGLcall("glFogi(GL_FOG_MODE, GL_LINEAR");
726 if(GL_SUPPORT(EXT_FOG_COORD)) {
727 glFogi(GL_FOG_COORDINATE_SOURCE_EXT, GL_FRAGMENT_DEPTH_EXT);
728 checkGLcall("glFogi(GL_FOG_COORDINATE_SOURCE_EXT, GL_FRAGMENT_DEPTH_EXT");
729 }
730 break;
731 }
732 }
H. Verbeeta2fde7d2007-02-15 13:32:13 +0100[diff] [blame]733 case WINED3DFOG_NONE: {
Stefan Dösinger61752732006-12-08 18:42:43 +0100[diff] [blame]734 /* Both are none? According to msdn the alpha channel of the specular
735 * color contains a fog factor. Set it in drawStridedSlow.
736 * Same happens with Vertexfog on transformed vertices
737 */
738 if(GL_SUPPORT(EXT_FOG_COORD)) {
739 glFogi(GL_FOG_COORDINATE_SOURCE_EXT, GL_FOG_COORDINATE_EXT);
740 checkGLcall("glFogi(GL_FOG_COORDINATE_SOURCE_EXT, GL_FOG_COORDINATE_EXT)\n");
741 glFogi(GL_FOG_MODE, GL_LINEAR);
742 checkGLcall("glFogi(GL_FOG_MODE, GL_LINEAR)");
743 fogstart = 0xff;
744 fogend = 0x0;
745 } else {
746 /* Disable GL fog, handle this in software in drawStridedSlow */
747 fogenable = FALSE;
748 }
749 break;
750 }
751 default: FIXME("Unexpected WINED3DRS_FOGVERTEXMODE %d\n", stateblock->renderState[WINED3DRS_FOGVERTEXMODE]);
752 }
753 } else {
754 glHint(GL_FOG_HINT, GL_NICEST);
755 checkGLcall("glHint(GL_FOG_HINT, GL_NICEST)");
Stefan Dösingere6c9a072007-02-12 19:18:27 +0100[diff] [blame]756 context->last_was_foggy_shader = FALSE;
Stefan Dösinger20de2002007-01-02 22:47:10 +0100[diff] [blame]757
Stefan Dösinger61752732006-12-08 18:42:43 +0100[diff] [blame]758 switch (stateblock->renderState[WINED3DRS_FOGTABLEMODE]) {
H. Verbeeta2fde7d2007-02-15 13:32:13 +0100[diff] [blame]759 case WINED3DFOG_EXP:
Stefan Dösinger61752732006-12-08 18:42:43 +0100[diff] [blame]760 glFogi(GL_FOG_MODE, GL_EXP);
761 checkGLcall("glFogi(GL_FOG_MODE, GL_EXP");
762 if(GL_SUPPORT(EXT_FOG_COORD)) {
763 glFogi(GL_FOG_COORDINATE_SOURCE_EXT, GL_FRAGMENT_DEPTH_EXT);
764 checkGLcall("glFogi(GL_FOG_COORDINATE_SOURCE_EXT, GL_FRAGMENT_DEPTH_EXT");
765 }
766 break;
767
H. Verbeeta2fde7d2007-02-15 13:32:13 +0100[diff] [blame]768 case WINED3DFOG_EXP2:
Stefan Dösinger61752732006-12-08 18:42:43 +0100[diff] [blame]769 glFogi(GL_FOG_MODE, GL_EXP2);
770 checkGLcall("glFogi(GL_FOG_MODE, GL_EXP2");
771 if(GL_SUPPORT(EXT_FOG_COORD)) {
772 glFogi(GL_FOG_COORDINATE_SOURCE_EXT, GL_FRAGMENT_DEPTH_EXT);
773 checkGLcall("glFogi(GL_FOG_COORDINATE_SOURCE_EXT, GL_FRAGMENT_DEPTH_EXT");
774 }
775 break;
776
H. Verbeeta2fde7d2007-02-15 13:32:13 +0100[diff] [blame]777 case WINED3DFOG_LINEAR:
Stefan Dösinger61752732006-12-08 18:42:43 +0100[diff] [blame]778 glFogi(GL_FOG_MODE, GL_LINEAR);
779 checkGLcall("glFogi(GL_FOG_MODE, GL_LINEAR");
780 if(GL_SUPPORT(EXT_FOG_COORD)) {
781 glFogi(GL_FOG_COORDINATE_SOURCE_EXT, GL_FRAGMENT_DEPTH_EXT);
782 checkGLcall("glFogi(GL_FOG_COORDINATE_SOURCE_EXT, GL_FRAGMENT_DEPTH_EXT");
783 }
784 break;
785
H. Verbeeta2fde7d2007-02-15 13:32:13 +0100[diff] [blame]786 case WINED3DFOG_NONE: /* Won't happen */
Stefan Dösinger61752732006-12-08 18:42:43 +0100[diff] [blame]787 default:
788 FIXME("Unexpected WINED3DRS_FOGTABLEMODE %d\n", stateblock->renderState[WINED3DRS_FOGTABLEMODE]);
789 }
790 }
791
792 if(fogenable) {
793 glEnable(GL_FOG);
794 checkGLcall("glEnable GL_FOG");
795
796 glFogfv(GL_FOG_START, &fogstart);
797 checkGLcall("glFogf(GL_FOG_START, fogstart");
798 TRACE("Fog Start == %f\n", fogstart);
799
800 glFogfv(GL_FOG_END, &fogend);
801 checkGLcall("glFogf(GL_FOG_END, fogend");
802 TRACE("Fog End == %f\n", fogend);
803 } else {
804 glDisable(GL_FOG);
805 checkGLcall("glDisable GL_FOG");
806 }
807
808 if (GL_SUPPORT(NV_FOG_DISTANCE)) {
809 glFogi(GL_FOG_DISTANCE_MODE_NV, GL_EYE_PLANE_ABSOLUTE_NV);
810 }
811}
812
Stefan Dösingerc739c382007-02-12 19:18:22 +0100[diff] [blame]813static void state_fogcolor(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
Alexandre Julliardbbfe1202006-12-29 11:35:57 +0100[diff] [blame]814 float col[4];
815 D3DCOLORTOGLFLOAT4(stateblock->renderState[WINED3DRS_FOGCOLOR], col);
Stefan Dösingeraf935a22006-12-08 18:52:30 +0100[diff] [blame]816 /* Set the default alpha blend color */
Alexandre Julliardbbfe1202006-12-29 11:35:57 +0100[diff] [blame]817 glFogfv(GL_FOG_COLOR, &col[0]);
Stefan Dösingeraf935a22006-12-08 18:52:30 +0100[diff] [blame]818 checkGLcall("glFog GL_FOG_COLOR");
819}
820
Stefan Dösingerc739c382007-02-12 19:18:22 +0100[diff] [blame]821static void state_fogdensity(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
Stefan Dösingere53c2a92006-12-10 16:34:45 +0100[diff] [blame]822 union {
823 DWORD d;
824 float f;
825 } tmpvalue;
826 tmpvalue.d = stateblock->renderState[WINED3DRS_FOGDENSITY];
827 glFogfv(GL_FOG_DENSITY, &tmpvalue.f);
828 checkGLcall("glFogf(GL_FOG_DENSITY, (float) Value)");
829}
830
Stefan Dösinger81a1dce2006-12-10 22:44:18 +0100[diff] [blame]831/* TODO: Merge with primitive type + init_materials()!! */
Stefan Dösingerc739c382007-02-12 19:18:22 +0100[diff] [blame]832static void state_colormat(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
H. Verbeetd429ff52007-01-17 21:41:35 +0100[diff] [blame]833 IWineD3DDeviceImpl *device = (IWineD3DDeviceImpl *)stateblock->wineD3DDevice;
H. Verbeet612a74a2007-01-17 21:41:21 +0100[diff] [blame]834 GLenum Parm = 0;
H. Verbeetd429ff52007-01-17 21:41:35 +0100[diff] [blame]835 WineDirect3DStridedData *diffuse = &device->strided_streams.u.s.diffuse;
Stefan Dösinger9b492092007-01-10 11:26:12 +0100[diff] [blame]836 BOOL isDiffuseSupplied;
837
Francois Gouget536e7382007-02-14 16:22:07 +0100[diff] [blame]838 /* Depends on the decoded vertex declaration to read the existence of diffuse data.
Stefan Dösinger9b492092007-01-10 11:26:12 +0100[diff] [blame]839 * The vertex declaration will call this function if the fixed function pipeline is used.
840 */
Stefan Dösinger380930d2007-02-12 19:18:31 +0100[diff] [blame]841
842 if(isStateDirty(context, STATE_VDECL)) {
Stefan Dösinger9b492092007-01-10 11:26:12 +0100[diff] [blame]843 return;
844 }
845
846 isDiffuseSupplied = diffuse->lpData || diffuse->VBO;
Stefan Dösinger81a1dce2006-12-10 22:44:18 +0100[diff] [blame]847
H. Verbeet612a74a2007-01-17 21:41:21 +0100[diff] [blame]848 if (isDiffuseSupplied && stateblock->renderState[WINED3DRS_COLORVERTEX]) {
Stefan Dösinger81a1dce2006-12-10 22:44:18 +0100[diff] [blame]849 TRACE("diff %d, amb %d, emis %d, spec %d\n",
850 stateblock->renderState[WINED3DRS_DIFFUSEMATERIALSOURCE],
851 stateblock->renderState[WINED3DRS_AMBIENTMATERIALSOURCE],
852 stateblock->renderState[WINED3DRS_EMISSIVEMATERIALSOURCE],
853 stateblock->renderState[WINED3DRS_SPECULARMATERIALSOURCE]);
854
H. Verbeeta2fde7d2007-02-15 13:32:13 +0100[diff] [blame]855 if (stateblock->renderState[WINED3DRS_DIFFUSEMATERIALSOURCE] == WINED3DMCS_COLOR1) {
856 if (stateblock->renderState[WINED3DRS_AMBIENTMATERIALSOURCE] == WINED3DMCS_COLOR1) {
Stefan Dösinger81a1dce2006-12-10 22:44:18 +0100[diff] [blame]857 Parm = GL_AMBIENT_AND_DIFFUSE;
858 } else {
859 Parm = GL_DIFFUSE;
860 }
H. Verbeeta2fde7d2007-02-15 13:32:13 +0100[diff] [blame]861 } else if (stateblock->renderState[WINED3DRS_AMBIENTMATERIALSOURCE] == WINED3DMCS_COLOR1) {
Stefan Dösinger81a1dce2006-12-10 22:44:18 +0100[diff] [blame]862 Parm = GL_AMBIENT;
H. Verbeeta2fde7d2007-02-15 13:32:13 +0100[diff] [blame]863 } else if (stateblock->renderState[WINED3DRS_EMISSIVEMATERIALSOURCE] == WINED3DMCS_COLOR1) {
Stefan Dösinger81a1dce2006-12-10 22:44:18 +0100[diff] [blame]864 Parm = GL_EMISSION;
H. Verbeeta2fde7d2007-02-15 13:32:13 +0100[diff] [blame]865 } else if (stateblock->renderState[WINED3DRS_SPECULARMATERIALSOURCE] == WINED3DMCS_COLOR1) {
Stefan Dösinger81a1dce2006-12-10 22:44:18 +0100[diff] [blame]866 Parm = GL_SPECULAR;
Stefan Dösinger81a1dce2006-12-10 22:44:18 +0100[diff] [blame]867 }
Stefan Dösinger9b492092007-01-10 11:26:12 +0100[diff] [blame]868 }
Stefan Dösinger81a1dce2006-12-10 22:44:18 +0100[diff] [blame]869
H. Verbeetd429ff52007-01-17 21:41:35 +0100[diff] [blame]870 /* Nothing changed, return. */
Stefan Dösingere6c9a072007-02-12 19:18:27 +0100[diff] [blame]871 if (Parm == context->tracking_parm) return;
H. Verbeetd429ff52007-01-17 21:41:35 +0100[diff] [blame]872
H. Verbeet612a74a2007-01-17 21:41:21 +0100[diff] [blame]873 if(!Parm) {
Stefan Dösinger9b492092007-01-10 11:26:12 +0100[diff] [blame]874 glDisable(GL_COLOR_MATERIAL);
875 checkGLcall("glDisable GL_COLOR_MATERIAL");
Stefan Dösinger81a1dce2006-12-10 22:44:18 +0100[diff] [blame]876 } else {
Stefan Dösinger9b492092007-01-10 11:26:12 +0100[diff] [blame]877 glColorMaterial(GL_FRONT_AND_BACK, Parm);
878 checkGLcall("glColorMaterial(GL_FRONT_AND_BACK, Parm)");
879 glEnable(GL_COLOR_MATERIAL);
880 checkGLcall("glEnable(GL_COLOR_MATERIAL)");
Stefan Dösinger81a1dce2006-12-10 22:44:18 +0100[diff] [blame]881 }
H. Verbeetd429ff52007-01-17 21:41:35 +0100[diff] [blame]882
883 /* Apparently calls to glMaterialfv are ignored for properties we're
884 * tracking with glColorMaterial, so apply those here. */
Stefan Dösingere6c9a072007-02-12 19:18:27 +0100[diff] [blame]885 switch (context->tracking_parm) {
H. Verbeetd429ff52007-01-17 21:41:35 +0100[diff] [blame]886 case GL_AMBIENT_AND_DIFFUSE:
887 glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT, (float*)&device->updateStateBlock->material.Ambient);
888 glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, (float*)&device->updateStateBlock->material.Diffuse);
889 checkGLcall("glMaterialfv");
890 break;
891
892 case GL_DIFFUSE:
893 glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, (float*)&device->updateStateBlock->material.Diffuse);
894 checkGLcall("glMaterialfv");
895 break;
896
897 case GL_AMBIENT:
898 glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT, (float*)&device->updateStateBlock->material.Ambient);
899 checkGLcall("glMaterialfv");
900 break;
901
902 case GL_EMISSION:
903 glMaterialfv(GL_FRONT_AND_BACK, GL_EMISSION, (float*)&device->updateStateBlock->material.Emissive);
904 checkGLcall("glMaterialfv");
905 break;
906
907 case GL_SPECULAR:
908 /* Only change material color if specular is enabled, otherwise it is set to black */
909 if (device->stateBlock->renderState[WINED3DRS_SPECULARENABLE]) {
910 glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, (float*)&device->updateStateBlock->material.Specular);
911 checkGLcall("glMaterialfv");
912 } else {
913 float black[4] = {0.0f, 0.0f, 0.0f, 0.0f};
914 glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, &black[0]);
915 checkGLcall("glMaterialfv");
916 }
917 break;
918 }
919
Stefan Dösingere6c9a072007-02-12 19:18:27 +0100[diff] [blame]920 context->tracking_parm = Parm;
Stefan Dösinger81a1dce2006-12-10 22:44:18 +0100[diff] [blame]921}
922
Stefan Dösingerc739c382007-02-12 19:18:22 +0100[diff] [blame]923static void state_linepattern(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
Stefan Dösinger6a5d7df2006-12-10 23:20:01 +0100[diff] [blame]924 union {
925 DWORD d;
926 WINED3DLINEPATTERN lp;
927 } tmppattern;
928 tmppattern.d = stateblock->renderState[WINED3DRS_LINEPATTERN];
929
930 TRACE("Line pattern: repeat %d bits %x\n", tmppattern.lp.wRepeatFactor, tmppattern.lp.wLinePattern);
931
932 if (tmppattern.lp.wRepeatFactor) {
933 glLineStipple(tmppattern.lp.wRepeatFactor, tmppattern.lp.wLinePattern);
934 checkGLcall("glLineStipple(repeat, linepattern)");
935 glEnable(GL_LINE_STIPPLE);
936 checkGLcall("glEnable(GL_LINE_STIPPLE);");
937 } else {
938 glDisable(GL_LINE_STIPPLE);
939 checkGLcall("glDisable(GL_LINE_STIPPLE);");
940 }
941}
942
Stefan Dösingerc739c382007-02-12 19:18:22 +0100[diff] [blame]943static void state_zbias(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
Stefan Dösingerdd6f5a52006-12-10 23:19:57 +0100[diff] [blame]944 union {
945 DWORD d;
946 float f;
947 } tmpvalue;
948
949 if (stateblock->renderState[WINED3DRS_ZBIAS]) {
950 tmpvalue.d = stateblock->renderState[WINED3DRS_ZBIAS];
951 TRACE("ZBias value %f\n", tmpvalue.f);
952 glPolygonOffset(0, -tmpvalue.f);
953 checkGLcall("glPolygonOffset(0, -Value)");
954 glEnable(GL_POLYGON_OFFSET_FILL);
955 checkGLcall("glEnable(GL_POLYGON_OFFSET_FILL);");
956 glEnable(GL_POLYGON_OFFSET_LINE);
957 checkGLcall("glEnable(GL_POLYGON_OFFSET_LINE);");
958 glEnable(GL_POLYGON_OFFSET_POINT);
959 checkGLcall("glEnable(GL_POLYGON_OFFSET_POINT);");
960 } else {
961 glDisable(GL_POLYGON_OFFSET_FILL);
962 checkGLcall("glDisable(GL_POLYGON_OFFSET_FILL);");
963 glDisable(GL_POLYGON_OFFSET_LINE);
964 checkGLcall("glDisable(GL_POLYGON_OFFSET_LINE);");
965 glDisable(GL_POLYGON_OFFSET_POINT);
966 checkGLcall("glDisable(GL_POLYGON_OFFSET_POINT);");
967 }
968}
969
Stefan Dösinger2ea57672006-12-10 23:20:05 +0100[diff] [blame]970
Stefan Dösingerc739c382007-02-12 19:18:22 +0100[diff] [blame]971static void state_normalize(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
Stefan Dösinger2ea57672006-12-10 23:20:05 +0100[diff] [blame]972 if (stateblock->renderState[WINED3DRS_NORMALIZENORMALS]) {
973 glEnable(GL_NORMALIZE);
974 checkGLcall("glEnable(GL_NORMALIZE);");
975 } else {
976 glDisable(GL_NORMALIZE);
977 checkGLcall("glDisable(GL_NORMALIZE);");
978 }
979}
980
Stefan Dösingerc739c382007-02-12 19:18:22 +0100[diff] [blame]981static void state_psize(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
Stefan Dösinger0ec7c8b2006-12-10 23:20:09 +0100[diff] [blame]982 union {
983 DWORD d;
984 float f;
985 } tmpvalue;
986
987 /* FIXME: check that pointSize isn't outside glGetFloatv( GL_POINT_SIZE_MAX_ARB, &maxSize ); or -ve */
988 tmpvalue.d = stateblock->renderState[WINED3DRS_POINTSIZE];
989 TRACE("Set point size to %f\n", tmpvalue.f);
990 glPointSize(tmpvalue.f);
991 checkGLcall("glPointSize(...);");
992}
993
Stefan Dösingerc739c382007-02-12 19:18:22 +0100[diff] [blame]994static void state_psizemin(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
Stefan Dösinger51b41d92006-12-10 23:20:12 +0100[diff] [blame]995 union {
996 DWORD d;
997 float f;
998 } tmpvalue;
999
Stefan Dösinger953f8d72007-01-10 11:32:07 +0100[diff] [blame]1000 tmpvalue.d = stateblock->renderState[WINED3DRS_POINTSIZE_MIN];
Nick Burnsd9557152007-01-01 01:58:33 -0800[diff] [blame]1001 if(GL_SUPPORT(ARB_POINT_PARAMETERS)) {
Nick Burnsd9557152007-01-01 01:58:33 -0800[diff] [blame]1002 GL_EXTCALL(glPointParameterfARB)(GL_POINT_SIZE_MIN_ARB, tmpvalue.f);
1003 checkGLcall("glPointParameterfARB(...");
1004 }
1005 else if(GL_SUPPORT(EXT_POINT_PARAMETERS)) {
Stefan Dösinger51b41d92006-12-10 23:20:12 +0100[diff] [blame]1006 GL_EXTCALL(glPointParameterfEXT)(GL_POINT_SIZE_MIN_EXT, tmpvalue.f);
1007 checkGLcall("glPointParameterfEXT(...);");
Stefan Dösinger953f8d72007-01-10 11:32:07 +0100[diff] [blame]1008 } else if(tmpvalue.f != 1.0) {
1009 FIXME("WINED3DRS_POINTSIZE_MIN not supported on this opengl, value is %f\n", tmpvalue.f);
Stefan Dösinger51b41d92006-12-10 23:20:12 +0100[diff] [blame]1010 }
1011}
1012
Stefan Dösingerc739c382007-02-12 19:18:22 +0100[diff] [blame]1013static void state_psizemax(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
Stefan Dösinger9a0e4b52006-12-10 23:20:15 +0100[diff] [blame]1014 union {
1015 DWORD d;
1016 float f;
1017 } tmpvalue;
1018
Stefan Dösinger953f8d72007-01-10 11:32:07 +0100[diff] [blame]1019 tmpvalue.d = stateblock->renderState[WINED3DRS_POINTSIZE_MAX];
Nick Burnsd9557152007-01-01 01:58:33 -0800[diff] [blame]1020 if(GL_SUPPORT(ARB_POINT_PARAMETERS)) {
Nick Burnsd9557152007-01-01 01:58:33 -0800[diff] [blame]1021 GL_EXTCALL(glPointParameterfARB)(GL_POINT_SIZE_MAX_ARB, tmpvalue.f);
1022 checkGLcall("glPointParameterfARB(...");
1023 }
1024 else if(GL_SUPPORT(EXT_POINT_PARAMETERS)) {
Stefan Dösinger9a0e4b52006-12-10 23:20:15 +0100[diff] [blame]1025 GL_EXTCALL(glPointParameterfEXT)(GL_POINT_SIZE_MAX_EXT, tmpvalue.f);
1026 checkGLcall("glPointParameterfEXT(...);");
Stefan Dösinger953f8d72007-01-10 11:32:07 +0100[diff] [blame]1027 } else if(tmpvalue.f != 64.0) {
1028 FIXME("WINED3DRS_POINTSIZE_MAX not supported on this opengl, value is %f\n", tmpvalue.f);
Stefan Dösinger9a0e4b52006-12-10 23:20:15 +0100[diff] [blame]1029 }
1030}
1031
Stefan Dösingerc739c382007-02-12 19:18:22 +0100[diff] [blame]1032static void state_pscale(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
Stefan Dösingercaa371a2006-12-10 23:20:19 +0100[diff] [blame]1033 /* TODO: Group this with the viewport */
1034 /*
1035 * POINTSCALEENABLE controls how point size value is treated. If set to
1036 * true, the point size is scaled with respect to height of viewport.
1037 * When set to false point size is in pixels.
1038 *
1039 * http://msdn.microsoft.com/library/en-us/directx9_c/point_sprites.asp
1040 */
1041
1042 /* Default values */
1043 GLfloat att[3] = {1.0f, 0.0f, 0.0f};
1044
1045 /*
1046 * Minimum valid point size for OpenGL is 1.0f. For Direct3D it is 0.0f.
1047 * This means that OpenGL will clamp really small point sizes to 1.0f.
1048 * To correct for this we need to multiply by the scale factor when sizes
1049 * are less than 1.0f. scale_factor = 1.0f / point_size.
1050 */
1051 GLfloat pointSize = *((float*)&stateblock->renderState[WINED3DRS_POINTSIZE]);
1052 if(pointSize > 0.0f) {
1053 GLfloat scaleFactor;
1054
1055 if(pointSize < 1.0f) {
1056 scaleFactor = pointSize * pointSize;
1057 } else {
1058 scaleFactor = 1.0f;
1059 }
1060
1061 if(stateblock->renderState[WINED3DRS_POINTSCALEENABLE]) {
1062 att[0] = *((float*)&stateblock->renderState[WINED3DRS_POINTSCALE_A]) /
1063 (stateblock->viewport.Height * stateblock->viewport.Height * scaleFactor);
1064 att[1] = *((float*)&stateblock->renderState[WINED3DRS_POINTSCALE_B]) /
1065 (stateblock->viewport.Height * stateblock->viewport.Height * scaleFactor);
1066 att[2] = *((float*)&stateblock->renderState[WINED3DRS_POINTSCALE_C]) /
1067 (stateblock->viewport.Height * stateblock->viewport.Height * scaleFactor);
1068 }
1069 }
1070
1071 if(GL_SUPPORT(ARB_POINT_PARAMETERS)) {
1072 GL_EXTCALL(glPointParameterfvARB)(GL_POINT_DISTANCE_ATTENUATION_ARB, att);
1073 checkGLcall("glPointParameterfvARB(GL_DISTANCE_ATTENUATION_ARB, ...");
1074 }
1075 else if(GL_SUPPORT(EXT_POINT_PARAMETERS)) {
1076 GL_EXTCALL(glPointParameterfvEXT)(GL_DISTANCE_ATTENUATION_EXT, att);
1077 checkGLcall("glPointParameterfvEXT(GL_DISTANCE_ATTENUATION_EXT, ...");
1078 } else {
1079 TRACE("POINT_PARAMETERS not supported in this version of opengl\n");
1080 }
1081}
1082
Stefan Dösingerc739c382007-02-12 19:18:22 +0100[diff] [blame]1083static void state_colorwrite(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
Stefan Dösinger4c64b862006-12-10 23:20:22 +0100[diff] [blame]1084 DWORD Value = stateblock->renderState[WINED3DRS_COLORWRITEENABLE];
1085
1086 TRACE("Color mask: r(%d) g(%d) b(%d) a(%d)\n",
H. Verbeeta2fde7d2007-02-15 13:32:13 +0100[diff] [blame]1087 Value & WINED3DCOLORWRITEENABLE_RED ? 1 : 0,
1088 Value & WINED3DCOLORWRITEENABLE_GREEN ? 1 : 0,
1089 Value & WINED3DCOLORWRITEENABLE_BLUE ? 1 : 0,
1090 Value & WINED3DCOLORWRITEENABLE_ALPHA ? 1 : 0);
1091 glColorMask(Value & WINED3DCOLORWRITEENABLE_RED ? GL_TRUE : GL_FALSE,
1092 Value & WINED3DCOLORWRITEENABLE_GREEN ? GL_TRUE : GL_FALSE,
1093 Value & WINED3DCOLORWRITEENABLE_BLUE ? GL_TRUE : GL_FALSE,
1094 Value & WINED3DCOLORWRITEENABLE_ALPHA ? GL_TRUE : GL_FALSE);
Stefan Dösinger4c64b862006-12-10 23:20:22 +0100[diff] [blame]1095 checkGLcall("glColorMask(...)");
1096
1097 /* depends on WINED3DRS_COLORWRITEENABLE. */
1098 if(stateblock->renderState[WINED3DRS_COLORWRITEENABLE1] != 0x0000000F ||
1099 stateblock->renderState[WINED3DRS_COLORWRITEENABLE2] != 0x0000000F ||
1100 stateblock->renderState[WINED3DRS_COLORWRITEENABLE3] != 0x0000000F ) {
1101 ERR("(WINED3DRS_COLORWRITEENABLE1/2/3,%d,%d,%d) not yet implemented. Missing of cap D3DPMISCCAPS_INDEPENDENTWRITEMASKS wasn't honored?\n",
1102 stateblock->renderState[WINED3DRS_COLORWRITEENABLE1],
1103 stateblock->renderState[WINED3DRS_COLORWRITEENABLE2],
1104 stateblock->renderState[WINED3DRS_COLORWRITEENABLE3]);
1105 }
1106}
1107
Stefan Dösingerc739c382007-02-12 19:18:22 +0100[diff] [blame]1108static void state_localviewer(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
Stefan Dösinger580b9962006-12-10 23:20:26 +0100[diff] [blame]1109 if(stateblock->renderState[WINED3DRS_LOCALVIEWER]) {
1110 glLightModeli(GL_LIGHT_MODEL_LOCAL_VIEWER, 1);
1111 checkGLcall("glLightModeli(GL_LIGHT_MODEL_LOCAL_VIEWER, 1)");
1112 } else {
1113 glLightModeli(GL_LIGHT_MODEL_LOCAL_VIEWER, 0);
1114 checkGLcall("glLightModeli(GL_LIGHT_MODEL_LOCAL_VIEWER, 0)");
1115 }
1116}
1117
Stefan Dösingerc739c382007-02-12 19:18:22 +0100[diff] [blame]1118static void state_lastpixel(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
Stefan Dösingerc5344702006-12-10 23:20:29 +0100[diff] [blame]1119 if(stateblock->renderState[WINED3DRS_LASTPIXEL]) {
1120 TRACE("Last Pixel Drawing Enabled\n");
1121 } else {
1122 FIXME("Last Pixel Drawing Disabled, not handled yet\n");
1123 }
1124}
1125
Stefan Dösingerc739c382007-02-12 19:18:22 +0100[diff] [blame]1126static void state_pointsprite(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
Chris Robinsond8c67c32007-01-03 00:17:24 -0800[diff] [blame]1127 unsigned int i;
1128 int val;
1129
Stefan Dösinger920225d2006-12-10 23:20:36 +0100[diff] [blame]1130 /* TODO: NV_POINT_SPRITE */
1131 if (!GL_SUPPORT(ARB_POINT_SPRITE)) {
1132 TRACE("Point sprites not supported\n");
1133 return;
1134 }
1135
Stefan Dösinger920225d2006-12-10 23:20:36 +0100[diff] [blame]1136 if (stateblock->renderState[WINED3DRS_POINTSPRITEENABLE]) {
Chris Robinsond8c67c32007-01-03 00:17:24 -0800[diff] [blame]1137 val = GL_TRUE;
Stefan Dösinger920225d2006-12-10 23:20:36 +0100[diff] [blame]1138 } else {
Chris Robinsond8c67c32007-01-03 00:17:24 -0800[diff] [blame]1139 val = GL_FALSE;
1140 }
1141
1142 for (i = 0; i < GL_LIMITS(texture_stages); i++) {
1143 /* Note the WINED3DRS value applies to all textures, but GL has one
1144 * per texture, so apply it now ready to be used!
1145 */
1146 if (GL_SUPPORT(ARB_MULTITEXTURE)) {
1147 GL_EXTCALL(glActiveTextureARB(GL_TEXTURE0_ARB + i));
1148 checkGLcall("glActiveTextureARB");
1149 } else if (i==1) {
1150 FIXME("Program using multiple concurrent textures which this opengl implementation doesn't support\n");
1151 break;
1152 }
1153
1154 glTexEnvi(GL_POINT_SPRITE_ARB, GL_COORD_REPLACE_ARB, val);
1155 checkGLcall((val?"glTexEnvi(GL_POINT_SPRITE, GL_COORD_REPLACE, GL_TRUE)":
1156 "glTexEnvi(GL_POINT_SPRITE, GL_COORD_REPLACE, GL_FALSE)"));
Stefan Dösinger920225d2006-12-10 23:20:36 +0100[diff] [blame]1157 }
1158}
1159
Stefan Dösingerc739c382007-02-12 19:18:22 +0100[diff] [blame]1160static void state_wrap(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
Stefan Dösinger81dce712006-12-10 23:20:45 +0100[diff] [blame]1161 /**
1162 http://www.cosc.brocku.ca/Offerings/3P98/course/lectures/texture/
1163 http://msdn.microsoft.com/archive/default.asp?url=/archive/en-us/directx9_c/directx/graphics/programmingguide/FixedFunction/Textures/texturewrapping.asp
1164 http://www.gamedev.net/reference/programming/features/rendererdll3/page2.asp
1165 Descussion that ways to turn on WRAPing to solve an opengl conversion problem.
1166 http://www.flipcode.org/cgi-bin/fcmsg.cgi?thread_show=10248
1167
1168 so far as I can tell, wrapping and texture-coordinate generate go hand in hand,
1169 */
1170 TRACE("Stub\n");
1171 if(stateblock->renderState[WINED3DRS_WRAP0] ||
1172 stateblock->renderState[WINED3DRS_WRAP1] ||
1173 stateblock->renderState[WINED3DRS_WRAP2] ||
1174 stateblock->renderState[WINED3DRS_WRAP3] ||
1175 stateblock->renderState[WINED3DRS_WRAP4] ||
1176 stateblock->renderState[WINED3DRS_WRAP5] ||
1177 stateblock->renderState[WINED3DRS_WRAP6] ||
1178 stateblock->renderState[WINED3DRS_WRAP7] ||
1179 stateblock->renderState[WINED3DRS_WRAP8] ||
1180 stateblock->renderState[WINED3DRS_WRAP9] ||
1181 stateblock->renderState[WINED3DRS_WRAP10] ||
1182 stateblock->renderState[WINED3DRS_WRAP11] ||
1183 stateblock->renderState[WINED3DRS_WRAP12] ||
1184 stateblock->renderState[WINED3DRS_WRAP13] ||
1185 stateblock->renderState[WINED3DRS_WRAP14] ||
1186 stateblock->renderState[WINED3DRS_WRAP15] ) {
1187 ERR("(WINED3DRS_WRAP0) Texture wraping not yet supported\n");
1188 }
1189}
1190
Stefan Dösingerc739c382007-02-12 19:18:22 +0100[diff] [blame]1191static void state_multisampleaa(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
Stefan Dösinger0c1aba52006-12-10 23:20:40 +0100[diff] [blame]1192 if( GL_SUPPORT(ARB_MULTISAMPLE) ) {
1193 if(stateblock->renderState[WINED3DRS_MULTISAMPLEANTIALIAS]) {
1194 glEnable(GL_MULTISAMPLE_ARB);
1195 checkGLcall("glEnable(GL_MULTISAMPLE_ARB)");
1196 } else {
1197 glDisable(GL_MULTISAMPLE_ARB);
1198 checkGLcall("glDisable(GL_MULTISAMPLE_ARB)");
1199 }
1200 } else {
1201 if(stateblock->renderState[WINED3DRS_MULTISAMPLEANTIALIAS]) {
1202 ERR("Multisample antialiasing not supported by gl\n");
1203 }
1204 }
1205}
1206
Stefan Dösingerc739c382007-02-12 19:18:22 +0100[diff] [blame]1207static void state_scissor(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
Stefan Dösingerd7e55c22006-12-10 23:20:48 +0100[diff] [blame]1208 if(stateblock->renderState[WINED3DRS_SCISSORTESTENABLE]) {
1209 glEnable(GL_SCISSOR_TEST);
1210 checkGLcall("glEnable(GL_SCISSOR_TEST)");
1211 } else {
1212 glDisable(GL_SCISSOR_TEST);
1213 checkGLcall("glDisable(GL_SCISSOR_TEST)");
1214 }
1215}
1216
Stefan Dösingerc739c382007-02-12 19:18:22 +0100[diff] [blame]1217static void state_depthbias(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
Stefan Dösinger30cf5e42006-12-10 23:20:52 +0100[diff] [blame]1218 union {
1219 DWORD d;
1220 float f;
1221 } tmpvalue;
1222
1223 if(stateblock->renderState[WINED3DRS_SLOPESCALEDEPTHBIAS] ||
1224 stateblock->renderState[WINED3DRS_DEPTHBIAS]) {
1225 tmpvalue.d = stateblock->renderState[WINED3DRS_SLOPESCALEDEPTHBIAS];
1226 glEnable(GL_POLYGON_OFFSET_FILL);
1227 checkGLcall("glEnable(GL_POLYGON_OFFSET_FILL)");
1228 glPolygonOffset(tmpvalue.f, *((float*)&stateblock->renderState[WINED3DRS_DEPTHBIAS]));
1229 checkGLcall("glPolygonOffset(...)");
1230 } else {
1231 glDisable(GL_POLYGON_OFFSET_FILL);
1232 checkGLcall("glDisable(GL_POLYGON_OFFSET_FILL)");
1233 }
1234}
1235
Stefan Dösingerc739c382007-02-12 19:18:22 +0100[diff] [blame]1236static void state_perspective(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
Stefan Dösinger312be462006-12-10 23:20:56 +0100[diff] [blame]1237 if (stateblock->renderState[WINED3DRS_TEXTUREPERSPECTIVE]) {
1238 glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);
1239 checkGLcall("glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST)");
1240 } else {
1241 glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_FASTEST);
1242 checkGLcall("glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_FASTEST)");
1243 }
1244}
1245
Stefan Dösingerc739c382007-02-12 19:18:22 +0100[diff] [blame]1246static void state_stippledalpha(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
Stefan Dösinger2710be02006-12-10 23:20:59 +0100[diff] [blame]1247 TRACE("Stub\n");
1248 if (stateblock->renderState[WINED3DRS_STIPPLEDALPHA])
1249 ERR(" Stippled Alpha not supported yet.\n");
1250}
1251
Stefan Dösingerc739c382007-02-12 19:18:22 +0100[diff] [blame]1252static void state_antialias(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
Stefan Dösinger55a5b4c2006-12-10 23:21:03 +0100[diff] [blame]1253 TRACE("Stub\n");
1254 if (stateblock->renderState[WINED3DRS_ANTIALIAS])
1255 ERR(" Antialias not supported yet.\n");
1256}
1257
Stefan Dösingerc739c382007-02-12 19:18:22 +0100[diff] [blame]1258static void state_multisampmask(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
Stefan Dösingerd7b85492006-12-10 23:21:07 +0100[diff] [blame]1259 TRACE("Stub\n");
1260 if (stateblock->renderState[WINED3DRS_MULTISAMPLEMASK] != 0xFFFFFFFF)
1261 ERR("(WINED3DRS_MULTISAMPLEMASK,%d) not yet implemented\n", stateblock->renderState[WINED3DRS_MULTISAMPLEMASK]);
1262}
1263
Stefan Dösingerc739c382007-02-12 19:18:22 +0100[diff] [blame]1264static void state_patchedgestyle(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
Stefan Dösingere498a162006-12-10 23:21:10 +0100[diff] [blame]1265 TRACE("Stub\n");
H. Verbeeta2fde7d2007-02-15 13:32:13 +0100[diff] [blame]1266 if (stateblock->renderState[WINED3DRS_PATCHEDGESTYLE] != WINED3DPATCHEDGE_DISCRETE)
Stefan Dösingere498a162006-12-10 23:21:10 +0100[diff] [blame]1267 ERR("(WINED3DRS_PATCHEDGESTYLE,%d) not yet implemented\n", stateblock->renderState[WINED3DRS_PATCHEDGESTYLE]);
1268}
1269
Stefan Dösingerc739c382007-02-12 19:18:22 +0100[diff] [blame]1270static void state_patchsegments(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
Stefan Dösinger81974702006-12-10 23:21:14 +0100[diff] [blame]1271 union {
1272 DWORD d;
1273 float f;
1274 } tmpvalue;
1275 tmpvalue.f = 1.0f;
1276
1277 TRACE("Stub\n");
1278 if (stateblock->renderState[WINED3DRS_PATCHSEGMENTS] != tmpvalue.d)
1279 ERR("(WINED3DRS_PATCHSEGMENTS,%d) not yet implemented\n", tmpvalue.d);
1280}
1281
Stefan Dösingerc739c382007-02-12 19:18:22 +0100[diff] [blame]1282static void state_positiondegree(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
Stefan Dösinger052197a2006-12-10 23:21:21 +0100[diff] [blame]1283 TRACE("Stub\n");
H. Verbeeta2fde7d2007-02-15 13:32:13 +0100[diff] [blame]1284 if (stateblock->renderState[WINED3DRS_POSITIONDEGREE] != WINED3DDEGREE_CUBIC)
Stefan Dösinger052197a2006-12-10 23:21:21 +0100[diff] [blame]1285 ERR("(WINED3DRS_POSITIONDEGREE,%d) not yet implemented\n", stateblock->renderState[WINED3DRS_POSITIONDEGREE]);
1286}
1287
Stefan Dösingerc739c382007-02-12 19:18:22 +0100[diff] [blame]1288static void state_normaldegree(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
Stefan Dösinger3bb41772006-12-10 23:21:25 +0100[diff] [blame]1289 TRACE("Stub\n");
H. Verbeeta2fde7d2007-02-15 13:32:13 +0100[diff] [blame]1290 if (stateblock->renderState[WINED3DRS_NORMALDEGREE] != WINED3DDEGREE_LINEAR)
Stefan Dösinger3bb41772006-12-10 23:21:25 +0100[diff] [blame]1291 ERR("(WINED3DRS_NORMALDEGREE,%d) not yet implemented\n", stateblock->renderState[WINED3DRS_NORMALDEGREE]);
1292}
1293
Stefan Dösingerc739c382007-02-12 19:18:22 +0100[diff] [blame]1294static void state_tessellation(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
Stefan Dösingercd0d0a72006-12-10 23:21:27 +0100[diff] [blame]1295 TRACE("Stub\n");
1296 if(stateblock->renderState[WINED3DRS_ENABLEADAPTIVETESSELLATION])
1297 FIXME("(WINED3DRS_ENABLEADAPTIVETESSELLATION,%d) not yet implemented\n", stateblock->renderState[WINED3DRS_ENABLEADAPTIVETESSELLATION]);
1298}
1299
Stefan Dösinger8a5bf912006-12-10 23:13:38 +0100[diff] [blame]1300
Stefan Dösingerc739c382007-02-12 19:18:22 +0100[diff] [blame]1301static void state_srgbwrite(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
Stefan Dösinger8a5bf912006-12-10 23:13:38 +0100[diff] [blame]1302 if(stateblock->renderState[WINED3DRS_SRGBWRITEENABLE])
1303 ERR("Render state WINED3DRS_SRGBWRITEENABLE not yet implemented\n");
1304}
1305
Stefan Dösingerc739c382007-02-12 19:18:22 +0100[diff] [blame]1306static void state_seperateblend(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
Stefan Dösinger92460b92006-12-10 23:14:36 +0100[diff] [blame]1307 TRACE("Stub\n");
1308 if(stateblock->renderState[WINED3DRS_SEPARATEALPHABLENDENABLE])
1309 FIXME("(WINED3DRS_SEPARATEALPHABLENDENABLE,%d) not yet implemented\n", stateblock->renderState[WINED3DRS_SEPARATEALPHABLENDENABLE]);
1310}
1311
Stefan Dösingerc739c382007-02-12 19:18:22 +0100[diff] [blame]1312static void state_wrapu(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
Stefan Dösingerff077ec2006-12-15 20:02:13 +0100[diff] [blame]1313 if(stateblock->renderState[WINED3DRS_WRAPU]) {
1314 FIXME("Render state WINED3DRS_WRAPU not implemented yet\n");
1315 }
1316}
1317
Stefan Dösingerc739c382007-02-12 19:18:22 +0100[diff] [blame]1318static void state_wrapv(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
Stefan Dösingerff077ec2006-12-15 20:02:13 +0100[diff] [blame]1319 if(stateblock->renderState[WINED3DRS_WRAPV]) {
1320 FIXME("Render state WINED3DRS_WRAPV not implemented yet\n");
1321 }
1322}
1323
Stefan Dösingerc739c382007-02-12 19:18:22 +0100[diff] [blame]1324static void state_monoenable(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
Stefan Dösingerff077ec2006-12-15 20:02:13 +0100[diff] [blame]1325 if(stateblock->renderState[WINED3DRS_MONOENABLE]) {
1326 FIXME("Render state WINED3DRS_MONOENABLE not implemented yet\n");
1327 }
1328}
1329
Stefan Dösingerc739c382007-02-12 19:18:22 +0100[diff] [blame]1330static void state_rop2(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
Stefan Dösingerff077ec2006-12-15 20:02:13 +0100[diff] [blame]1331 if(stateblock->renderState[WINED3DRS_ROP2]) {
1332 FIXME("Render state WINED3DRS_ROP2 not implemented yet\n");
1333 }
1334}
1335
Stefan Dösingerc739c382007-02-12 19:18:22 +0100[diff] [blame]1336static void state_planemask(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
Stefan Dösingerff077ec2006-12-15 20:02:13 +0100[diff] [blame]1337 if(stateblock->renderState[WINED3DRS_PLANEMASK]) {
1338 FIXME("Render state WINED3DRS_PLANEMASK not implemented yet\n");
1339 }
1340}
1341
Stefan Dösingerc739c382007-02-12 19:18:22 +0100[diff] [blame]1342static void state_subpixel(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
Stefan Dösingerff077ec2006-12-15 20:02:13 +0100[diff] [blame]1343 if(stateblock->renderState[WINED3DRS_SUBPIXEL]) {
1344 FIXME("Render state WINED3DRS_SUBPIXEL not implemented yet\n");
1345 }
1346}
1347
Stefan Dösingerc739c382007-02-12 19:18:22 +0100[diff] [blame]1348static void state_subpixelx(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
Stefan Dösingerff077ec2006-12-15 20:02:13 +0100[diff] [blame]1349 if(stateblock->renderState[WINED3DRS_SUBPIXELX]) {
1350 FIXME("Render state WINED3DRS_SUBPIXELX not implemented yet\n");
1351 }
1352}
1353
Stefan Dösingerc739c382007-02-12 19:18:22 +0100[diff] [blame]1354static void state_stippleenable(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
Stefan Dösingerff077ec2006-12-15 20:02:13 +0100[diff] [blame]1355 if(stateblock->renderState[WINED3DRS_STIPPLEENABLE]) {
1356 FIXME("Render state WINED3DRS_STIPPLEENABLE not implemented yet\n");
1357 }
1358}
1359
Stefan Dösingerc739c382007-02-12 19:18:22 +0100[diff] [blame]1360static void state_bordercolor(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
Stefan Dösingerff077ec2006-12-15 20:02:13 +0100[diff] [blame]1361 if(stateblock->renderState[WINED3DRS_BORDERCOLOR]) {
1362 FIXME("Render state WINED3DRS_BORDERCOLOR not implemented yet\n");
1363 }
1364}
1365
Stefan Dösingerc739c382007-02-12 19:18:22 +0100[diff] [blame]1366static void state_mipmaplodbias(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
Stefan Dösingerff077ec2006-12-15 20:02:13 +0100[diff] [blame]1367 if(stateblock->renderState[WINED3DRS_MIPMAPLODBIAS]) {
1368 FIXME("Render state WINED3DRS_MIPMAPLODBIAS not implemented yet\n");
1369 }
1370}
1371
Stefan Dösingerc739c382007-02-12 19:18:22 +0100[diff] [blame]1372static void state_anisotropy(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
Stefan Dösingerff077ec2006-12-15 20:02:13 +0100[diff] [blame]1373 if(stateblock->renderState[WINED3DRS_ANISOTROPY]) {
1374 FIXME("Render state WINED3DRS_ANISOTROPY not implemented yet\n");
1375 }
1376}
1377
Stefan Dösingerc739c382007-02-12 19:18:22 +0100[diff] [blame]1378static void state_flushbatch(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
Stefan Dösingerff077ec2006-12-15 20:02:13 +0100[diff] [blame]1379 if(stateblock->renderState[WINED3DRS_FLUSHBATCH]) {
1380 FIXME("Render state WINED3DRS_FLUSHBATCH not implemented yet\n");
1381 }
1382}
1383
Stefan Dösingerc739c382007-02-12 19:18:22 +0100[diff] [blame]1384static void state_translucentsi(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
Stefan Dösingerff077ec2006-12-15 20:02:13 +0100[diff] [blame]1385 if(stateblock->renderState[WINED3DRS_TRANSLUCENTSORTINDEPENDENT]) {
1386 FIXME("Render state WINED3DRS_TRANSLUCENTSORTINDEPENDENT not implemented yet\n");
1387 }
1388}
1389
Stefan Dösingerc739c382007-02-12 19:18:22 +0100[diff] [blame]1390static void state_extents(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
Stefan Dösingerff077ec2006-12-15 20:02:13 +0100[diff] [blame]1391 if(stateblock->renderState[WINED3DRS_EXTENTS]) {
1392 FIXME("Render state WINED3DRS_EXTENTS not implemented yet\n");
1393 }
1394}
1395
Stefan Dösingerc739c382007-02-12 19:18:22 +0100[diff] [blame]1396static void state_ckeyblend(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
Stefan Dösingerff077ec2006-12-15 20:02:13 +0100[diff] [blame]1397 if(stateblock->renderState[WINED3DRS_COLORKEYBLENDENABLE]) {
1398 FIXME("Render state WINED3DRS_COLORKEYBLENDENABLE not implemented yet\n");
1399 }
1400}
1401
Stefan Dösinger762af472006-12-19 23:00:58 +0100[diff] [blame]1402/* Activates the texture dimension according to the bound D3D texture.
1403 * Does not care for the colorop or correct gl texture unit(when using nvrc)
1404 * Requires the caller to activate the correct unit before
1405 */
1406static void activate_dimensions(DWORD stage, IWineD3DStateBlockImpl *stateblock) {
1407 if(stateblock->textures[stage]) {
1408 glDisable(GL_TEXTURE_1D);
1409 checkGLcall("glDisable(GL_TEXTURE_1D)");
1410 switch(stateblock->textureDimensions[stage]) {
1411 case GL_TEXTURE_2D:
1412 glDisable(GL_TEXTURE_3D);
1413 checkGLcall("glDisable(GL_TEXTURE_3D)");
1414 glDisable(GL_TEXTURE_CUBE_MAP_ARB);
1415 checkGLcall("glDisable(GL_TEXTURE_CUBE_MAP_ARB)");
1416 glEnable(GL_TEXTURE_2D);
1417 checkGLcall("glEnable(GL_TEXTURE_2D)");
1418 break;
1419 case GL_TEXTURE_3D:
1420 glDisable(GL_TEXTURE_CUBE_MAP_ARB);
1421 checkGLcall("glDisable(GL_TEXTURE_CUBE_MAP_ARB)");
1422 glDisable(GL_TEXTURE_2D);
1423 checkGLcall("glDisable(GL_TEXTURE_2D)");
1424 glEnable(GL_TEXTURE_3D);
1425 checkGLcall("glEnable(GL_TEXTURE_3D)");
1426 break;
1427 case GL_TEXTURE_CUBE_MAP_ARB:
1428 glDisable(GL_TEXTURE_2D);
1429 checkGLcall("glDisable(GL_TEXTURE_2D)");
1430 glDisable(GL_TEXTURE_3D);
1431 checkGLcall("glDisable(GL_TEXTURE_3D)");
1432 glEnable(GL_TEXTURE_CUBE_MAP_ARB);
1433 checkGLcall("glEnable(GL_TEXTURE_CUBE_MAP_ARB)");
1434 break;
1435 }
1436 } else {
1437 glDisable(GL_TEXTURE_2D);
1438 checkGLcall("glDisable(GL_TEXTURE_2D)");
1439 glDisable(GL_TEXTURE_3D);
1440 checkGLcall("glDisable(GL_TEXTURE_3D)");
1441 glDisable(GL_TEXTURE_CUBE_MAP_ARB);
1442 checkGLcall("glDisable(GL_TEXTURE_CUBE_MAP_ARB)");
1443 glEnable(GL_TEXTURE_1D);
1444 checkGLcall("glEnable(GL_TEXTURE_1D)");
1445 /* Binding textures is done by samplers. A dummy texture will be bound */
1446 }
1447}
1448
Stefan Dösingerc739c382007-02-12 19:18:22 +0100[diff] [blame]1449static void tex_colorop(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
Stefan Dösinger762af472006-12-19 23:00:58 +0100[diff] [blame]1450 DWORD stage = (state - STATE_TEXTURESTAGE(0, 0)) / WINED3D_HIGHEST_TEXTURE_STATE;
H. Verbeet8c530332007-01-03 19:18:38 +0100[diff] [blame]1451 DWORD mapped_stage = stateblock->wineD3DDevice->texUnitMap[stage];
Stefan Dösinger762af472006-12-19 23:00:58 +0100[diff] [blame]1452
1453 TRACE("Setting color op for stage %d\n", stage);
1454
1455 if (stateblock->pixelShader && stateblock->wineD3DDevice->ps_selected_mode != SHADER_NONE &&
1456 ((IWineD3DPixelShaderImpl *)stateblock->pixelShader)->baseShader.function) {
1457 /* Using a pixel shader? Don't care for anything here, the shader applying does it */
1458 return;
1459 }
1460
H. Verbeet8c530332007-01-03 19:18:38 +0100[diff] [blame]1461 if (stage != mapped_stage) WARN("Using non 1:1 mapping: %d -> %d!\n", stage, mapped_stage);
1462
1463 if (mapped_stage != -1) {
1464 if (GL_SUPPORT(ARB_MULTITEXTURE)) {
1465 if (mapped_stage >= GL_LIMITS(sampler_stages)) {
1466 if (stateblock->textureState[stage][WINED3DTSS_COLOROP] != WINED3DTOP_DISABLE &&
1467 stateblock->textureState[stage][WINED3DTSS_COLOROP] != 0) {
1468 FIXME("Attempt to enable unsupported stage!\n");
1469 }
1470 return;
Stefan Dösinger762af472006-12-19 23:00:58 +0100[diff] [blame]1471 }
H. Verbeet8c530332007-01-03 19:18:38 +0100[diff] [blame]1472 GL_EXTCALL(glActiveTextureARB(GL_TEXTURE0_ARB + mapped_stage));
1473 checkGLcall("glActiveTextureARB");
1474 } else if (stage > 0) {
1475 WARN("Program using multiple concurrent textures which this opengl implementation doesn't support\n");
Stefan Dösinger762af472006-12-19 23:00:58 +0100[diff] [blame]1476 return;
1477 }
Stefan Dösinger762af472006-12-19 23:00:58 +0100[diff] [blame]1478 }
1479
1480 if (GL_SUPPORT(NV_REGISTER_COMBINERS)) {
1481 if(stateblock->lowest_disabled_stage > 0) {
1482 glEnable(GL_REGISTER_COMBINERS_NV);
1483 GL_EXTCALL(glCombinerParameteriNV(GL_NUM_GENERAL_COMBINERS_NV, stateblock->lowest_disabled_stage));
1484 } else {
1485 glDisable(GL_REGISTER_COMBINERS_NV);
1486 }
1487 }
1488 if(stage >= stateblock->lowest_disabled_stage) {
1489 TRACE("Stage disabled\n");
H. Verbeet8c530332007-01-03 19:18:38 +0100[diff] [blame]1490 if (mapped_stage != -1) {
1491 /* Disable everything here */
1492 glDisable(GL_TEXTURE_1D);
1493 checkGLcall("glDisable(GL_TEXTURE_1D)");
1494 glDisable(GL_TEXTURE_2D);
1495 checkGLcall("glDisable(GL_TEXTURE_2D)");
1496 glDisable(GL_TEXTURE_3D);
1497 checkGLcall("glDisable(GL_TEXTURE_3D)");
1498 glDisable(GL_TEXTURE_CUBE_MAP_ARB);
1499 checkGLcall("glDisable(GL_TEXTURE_CUBE_MAP_ARB)");
1500 }
Stefan Dösinger762af472006-12-19 23:00:58 +0100[diff] [blame]1501 /* All done */
1502 return;
1503 }
1504
Stefan Dösingerb07c48c2007-01-10 11:44:55 +0100[diff] [blame]1505 /* The sampler will also activate the correct texture dimensions, so no need to do it here
1506 * if the sampler for this stage is dirty
1507 */
Stefan Dösinger380930d2007-02-12 19:18:31 +0100[diff] [blame]1508 if(!isStateDirty(context, STATE_SAMPLER(stage))) {
Stefan Dösingerb07c48c2007-01-10 11:44:55 +0100[diff] [blame]1509 if (mapped_stage != -1) activate_dimensions(stage, stateblock);
1510 }
Stefan Dösinger762af472006-12-19 23:00:58 +0100[diff] [blame]1511
1512 /* Set the texture combiners */
1513 if (GL_SUPPORT(NV_REGISTER_COMBINERS)) {
1514 set_tex_op_nvrc((IWineD3DDevice *)stateblock->wineD3DDevice, FALSE, stage,
1515 stateblock->textureState[stage][WINED3DTSS_COLOROP],
1516 stateblock->textureState[stage][WINED3DTSS_COLORARG1],
1517 stateblock->textureState[stage][WINED3DTSS_COLORARG2],
1518 stateblock->textureState[stage][WINED3DTSS_COLORARG0],
H. Verbeet8c530332007-01-03 19:18:38 +0100[diff] [blame]1519 mapped_stage);
Stefan Dösinger762af472006-12-19 23:00:58 +0100[diff] [blame]1520 } else {
1521 set_tex_op((IWineD3DDevice *)stateblock->wineD3DDevice, FALSE, stage,
1522 stateblock->textureState[stage][WINED3DTSS_COLOROP],
1523 stateblock->textureState[stage][WINED3DTSS_COLORARG1],
1524 stateblock->textureState[stage][WINED3DTSS_COLORARG2],
1525 stateblock->textureState[stage][WINED3DTSS_COLORARG0]);
1526 }
1527}
1528
Stefan Dösingerc739c382007-02-12 19:18:22 +0100[diff] [blame]1529static void tex_alphaop(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
Stefan Dösingerbd6a6ad2006-12-19 23:03:37 +0100[diff] [blame]1530 DWORD stage = (state - STATE_TEXTURESTAGE(0, 0)) / WINED3D_HIGHEST_TEXTURE_STATE;
H. Verbeetc7fad602007-01-03 19:18:44 +0100[diff] [blame]1531 DWORD mapped_stage = stateblock->wineD3DDevice->texUnitMap[stage];
Stefan Dösingerb3f96f42007-02-15 03:04:18 +0100[diff] [blame]1532 DWORD op, arg1, arg2, arg0;
Stefan Dösingerbd6a6ad2006-12-19 23:03:37 +0100[diff] [blame]1533
1534 TRACE("Setting alpha op for stage %d\n", stage);
1535 /* Do not care for enabled / disabled stages, just assign the settigns. colorop disables / enables required stuff */
H. Verbeetc7fad602007-01-03 19:18:44 +0100[diff] [blame]1536 if (mapped_stage != -1) {
1537 if (GL_SUPPORT(ARB_MULTITEXTURE)) {
1538 if (stage >= GL_LIMITS(sampler_stages)) {
1539 if (stateblock->textureState[stage][WINED3DTSS_COLOROP] != WINED3DTOP_DISABLE &&
1540 stateblock->textureState[stage][WINED3DTSS_COLOROP] != 0) {
1541 FIXME("Attempt to enable unsupported stage!\n");
1542 }
1543 return;
Stefan Dösingerbd6a6ad2006-12-19 23:03:37 +0100[diff] [blame]1544 }
H. Verbeetc7fad602007-01-03 19:18:44 +0100[diff] [blame]1545 GL_EXTCALL(glActiveTextureARB(GL_TEXTURE0_ARB + mapped_stage));
1546 checkGLcall("glActiveTextureARB");
1547 } else if (stage > 0) {
1548 /* We can't do anything here */
1549 WARN("Program using multiple concurrent textures which this opengl implementation doesn't support\n");
Stefan Dösingerbd6a6ad2006-12-19 23:03:37 +0100[diff] [blame]1550 return;
1551 }
Stefan Dösingerbd6a6ad2006-12-19 23:03:37 +0100[diff] [blame]1552 }
1553
Stefan Dösingerb3f96f42007-02-15 03:04:18 +0100[diff] [blame]1554 op = stateblock->textureState[stage][WINED3DTSS_ALPHAOP];
1555 arg1 = stateblock->textureState[stage][WINED3DTSS_ALPHAARG1];
1556 arg2 = stateblock->textureState[stage][WINED3DTSS_ALPHAARG2];
1557 arg0 = stateblock->textureState[stage][WINED3DTSS_ALPHAARG0];
1558
1559 if(stateblock->renderState[WINED3DRS_COLORKEYENABLE] && stage == 0 &&
1560 stateblock->textures[0] && stateblock->textureDimensions[0] == GL_TEXTURE_2D) {
1561 IWineD3DSurfaceImpl *surf = (IWineD3DSurfaceImpl *) ((IWineD3DTextureImpl *) stateblock->textures[0])->surfaces[0];
1562
1563 if(surf->CKeyFlags & DDSD_CKSRCBLT &&
1564 getFormatDescEntry(surf->resource.format)->alphaMask == 0x00000000) {
1565
1566 /* Color keying needs to pass alpha values from the texture through to have the alpha test work properly.
1567 * On the other hand applications can still use texture combiners apparently. This code takes care that apps
1568 * cannot remove the texture's alpha channel entirely.
1569 *
1570 * The fixup is required for Prince of Persia 3D(prison bars), while Moto racer 2 requires D3DTOP_MODULATE to work
1571 * on color keyed surfaces.
1572 *
1573 * What to do with multitexturing? So far no app has been found that uses color keying with multitexturing
1574 */
1575 if(op == WINED3DTOP_DISABLE) op = WINED3DTOP_SELECTARG1;
1576 if(op == WINED3DTOP_SELECTARG1) arg1 = WINED3DTA_TEXTURE;
1577 else if(op == WINED3DTOP_SELECTARG2) arg2 = WINED3DTA_TEXTURE;
1578 }
1579 }
1580
Stefan Dösingerbd6a6ad2006-12-19 23:03:37 +0100[diff] [blame]1581 TRACE("Setting alpha op for stage %d\n", stage);
1582 if (GL_SUPPORT(NV_REGISTER_COMBINERS)) {
1583 set_tex_op_nvrc((IWineD3DDevice *)stateblock->wineD3DDevice, TRUE, stage,
Stefan Dösingerb3f96f42007-02-15 03:04:18 +0100[diff] [blame]1584 op, arg1, arg2, arg0,
H. Verbeetc7fad602007-01-03 19:18:44 +0100[diff] [blame]1585 mapped_stage);
Stefan Dösingerbd6a6ad2006-12-19 23:03:37 +0100[diff] [blame]1586 } else {
Stefan Dösingerb3f96f42007-02-15 03:04:18 +0100[diff] [blame]1587 set_tex_op((IWineD3DDevice *)stateblock->wineD3DDevice, TRUE, stage,
1588 op, arg1, arg2, arg0);
Stefan Dösingerbd6a6ad2006-12-19 23:03:37 +0100[diff] [blame]1589 }
1590}
1591
Stefan Dösingerc739c382007-02-12 19:18:22 +0100[diff] [blame]1592static void transform_texture(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
Stefan Dösingerc10efb32007-01-01 23:53:59 +0100[diff] [blame]1593 DWORD texUnit = state - STATE_TRANSFORM(WINED3DTS_TEXTURE0);
1594
1595 if (GL_SUPPORT(ARB_MULTITEXTURE)) {
1596 if(texUnit >= GL_LIMITS(sampler_stages)) {
1597 return;
1598 }
1599 GL_EXTCALL(glActiveTextureARB(GL_TEXTURE0_ARB + stateblock->wineD3DDevice->texUnitMap[texUnit]));
1600 checkGLcall("glActiveTextureARB");
1601 } else if (texUnit > 0) {
1602 /* We can't do anything here */
1603 WARN("Program using multiple concurrent textures which this opengl implementation doesn't support\n");
1604 return;
1605 }
1606
1607 set_texture_matrix((float *)&stateblock->transforms[WINED3DTS_TEXTURE0 + texUnit].u.m[0][0],
1608 stateblock->textureState[texUnit][WINED3DTSS_TEXTURETRANSFORMFLAGS],
1609 (stateblock->textureState[texUnit][WINED3DTSS_TEXCOORDINDEX] & 0xFFFF0000) != WINED3DTSS_TCI_PASSTHRU);
1610
1611}
1612
Stefan Dösingerd5f18e62007-01-06 18:11:21 +0100[diff] [blame]1613static void loadVertexData(IWineD3DStateBlockImpl *stateblock, WineDirect3DVertexStridedData *sd);
1614
Stefan Dösingerc739c382007-02-12 19:18:22 +0100[diff] [blame]1615static void tex_coordindex(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
Stefan Dösinger4e531402006-12-19 23:04:16 +0100[diff] [blame]1616 DWORD stage = (state - STATE_TEXTURESTAGE(0, 0)) / WINED3D_HIGHEST_TEXTURE_STATE;
H. Verbeetaced8de2007-01-03 19:18:51 +0100[diff] [blame]1617 DWORD mapped_stage = stateblock->wineD3DDevice->texUnitMap[stage];
1618
1619 if (mapped_stage == -1) {
1620 TRACE("No texture unit mapped to stage %d. Skipping texture coordinates.\n", stage);
1621 return;
1622 }
Stefan Dösinger4e531402006-12-19 23:04:16 +0100[diff] [blame]1623
1624 if (GL_SUPPORT(ARB_MULTITEXTURE)) {
Stefan Dösinger4e531402006-12-19 23:04:16 +0100[diff] [blame]1625 if(stage >= GL_LIMITS(sampler_stages)) {
1626 return;
1627 }
H. Verbeetaced8de2007-01-03 19:18:51 +0100[diff] [blame]1628 GL_EXTCALL(glActiveTextureARB(GL_TEXTURE0_ARB + mapped_stage));
Stefan Dösinger4e531402006-12-19 23:04:16 +0100[diff] [blame]1629 checkGLcall("glActiveTextureARB");
1630 } else if (stage > 0) {
1631 /* We can't do anything here */
1632 WARN("Program using multiple concurrent textures which this opengl implementation doesn't support\n");
1633 return;
1634 }
1635
1636 /* Values 0-7 are indexes into the FVF tex coords - See comments in DrawPrimitive
1637 *
1638 * FIXME: From MSDN: The WINED3DTSS_TCI_* flags are mutually exclusive. If you include
1639 * one flag, you can still specify an index value, which the system uses to
1640 * determine the texture wrapping mode.
1641 * eg. SetTextureStageState( 0, WINED3DTSS_TEXCOORDINDEX, WINED3DTSS_TCI_CAMERASPACEPOSITION | 1 );
1642 * means use the vertex position (camera-space) as the input texture coordinates
1643 * for this texture stage, and the wrap mode set in the WINED3DRS_WRAP1 render
1644 * state. We do not (yet) support the WINED3DRENDERSTATE_WRAPx values, nor tie them up
1645 * to the TEXCOORDINDEX value
1646 */
1647
1648 /*
1649 * Be careful the value of the mask 0xF0000 come from d3d8types.h infos
1650 */
1651 switch (stateblock->textureState[stage][WINED3DTSS_TEXCOORDINDEX] & 0xFFFF0000) {
1652 case WINED3DTSS_TCI_PASSTHRU:
1653 /*Use the specified texture coordinates contained within the vertex format. This value resolves to zero.*/
1654 glDisable(GL_TEXTURE_GEN_S);
1655 glDisable(GL_TEXTURE_GEN_T);
1656 glDisable(GL_TEXTURE_GEN_R);
1657 glDisable(GL_TEXTURE_GEN_Q);
1658 checkGLcall("glDisable(GL_TEXTURE_GEN_S,T,R,Q)");
1659 break;
1660
1661 case WINED3DTSS_TCI_CAMERASPACEPOSITION:
1662 /* CameraSpacePosition means use the vertex position, transformed to camera space,
1663 * as the input texture coordinates for this stage's texture transformation. This
1664 * equates roughly to EYE_LINEAR
1665 */
1666 {
1667 float s_plane[] = { 1.0, 0.0, 0.0, 0.0 };
1668 float t_plane[] = { 0.0, 1.0, 0.0, 0.0 };
1669 float r_plane[] = { 0.0, 0.0, 1.0, 0.0 };
1670 float q_plane[] = { 0.0, 0.0, 0.0, 1.0 };
1671 TRACE("WINED3DTSS_TCI_CAMERASPACEPOSITION - Set eye plane\n");
1672
1673 glMatrixMode(GL_MODELVIEW);
1674 glPushMatrix();
1675 glLoadIdentity();
1676 glTexGenfv(GL_S, GL_EYE_PLANE, s_plane);
1677 glTexGenfv(GL_T, GL_EYE_PLANE, t_plane);
1678 glTexGenfv(GL_R, GL_EYE_PLANE, r_plane);
1679 glTexGenfv(GL_Q, GL_EYE_PLANE, q_plane);
1680 glPopMatrix();
1681
1682 TRACE("WINED3DTSS_TCI_CAMERASPACEPOSITION - Set GL_TEXTURE_GEN_x and GL_x, GL_TEXTURE_GEN_MODE, GL_EYE_LINEAR\n");
1683 glEnable(GL_TEXTURE_GEN_S);
1684 checkGLcall("glEnable(GL_TEXTURE_GEN_S);");
1685 glTexGeni(GL_S, GL_TEXTURE_GEN_MODE, GL_EYE_LINEAR);
1686 checkGLcall("glTexGeni(GL_S, GL_TEXTURE_GEN_MODE, GL_EYE_LINEAR)");
1687 glEnable(GL_TEXTURE_GEN_T);
1688 checkGLcall("glEnable(GL_TEXTURE_GEN_T);");
1689 glTexGeni(GL_T, GL_TEXTURE_GEN_MODE, GL_EYE_LINEAR);
1690 checkGLcall("glTexGeni(GL_T, GL_TEXTURE_GEN_MODE, GL_EYE_LINEAR)");
1691 glEnable(GL_TEXTURE_GEN_R);
1692 checkGLcall("glEnable(GL_TEXTURE_GEN_R);");
1693 glTexGeni(GL_R, GL_TEXTURE_GEN_MODE, GL_EYE_LINEAR);
1694 checkGLcall("glTexGeni(GL_R, GL_TEXTURE_GEN_MODE, GL_EYE_LINEAR)");
1695 }
1696 break;
1697
1698 case WINED3DTSS_TCI_CAMERASPACENORMAL:
1699 {
1700 if (GL_SUPPORT(NV_TEXGEN_REFLECTION)) {
1701 float s_plane[] = { 1.0, 0.0, 0.0, 0.0 };
1702 float t_plane[] = { 0.0, 1.0, 0.0, 0.0 };
1703 float r_plane[] = { 0.0, 0.0, 1.0, 0.0 };
1704 float q_plane[] = { 0.0, 0.0, 0.0, 1.0 };
1705 TRACE("WINED3DTSS_TCI_CAMERASPACENORMAL - Set eye plane\n");
1706
1707 glMatrixMode(GL_MODELVIEW);
1708 glPushMatrix();
1709 glLoadIdentity();
1710 glTexGenfv(GL_S, GL_EYE_PLANE, s_plane);
1711 glTexGenfv(GL_T, GL_EYE_PLANE, t_plane);
1712 glTexGenfv(GL_R, GL_EYE_PLANE, r_plane);
1713 glTexGenfv(GL_Q, GL_EYE_PLANE, q_plane);
1714 glPopMatrix();
1715
1716 glEnable(GL_TEXTURE_GEN_S);
1717 checkGLcall("glEnable(GL_TEXTURE_GEN_S);");
1718 glTexGeni(GL_S, GL_TEXTURE_GEN_MODE, GL_NORMAL_MAP_NV);
1719 checkGLcall("glTexGeni(GL_S, GL_TEXTURE_GEN_MODE, GL_NORMAL_MAP_NV)");
1720 glEnable(GL_TEXTURE_GEN_T);
1721 checkGLcall("glEnable(GL_TEXTURE_GEN_T);");
1722 glTexGeni(GL_T, GL_TEXTURE_GEN_MODE, GL_NORMAL_MAP_NV);
1723 checkGLcall("glTexGeni(GL_T, GL_TEXTURE_GEN_MODE, GL_NORMAL_MAP_NV)");
1724 glEnable(GL_TEXTURE_GEN_R);
1725 checkGLcall("glEnable(GL_TEXTURE_GEN_R);");
1726 glTexGeni(GL_R, GL_TEXTURE_GEN_MODE, GL_NORMAL_MAP_NV);
1727 checkGLcall("glTexGeni(GL_R, GL_TEXTURE_GEN_MODE, GL_NORMAL_MAP_NV)");
1728 }
1729 }
1730 break;
1731
1732 case WINED3DTSS_TCI_CAMERASPACEREFLECTIONVECTOR:
1733 {
1734 if (GL_SUPPORT(NV_TEXGEN_REFLECTION)) {
1735 float s_plane[] = { 1.0, 0.0, 0.0, 0.0 };
1736 float t_plane[] = { 0.0, 1.0, 0.0, 0.0 };
1737 float r_plane[] = { 0.0, 0.0, 1.0, 0.0 };
1738 float q_plane[] = { 0.0, 0.0, 0.0, 1.0 };
1739 TRACE("WINED3DTSS_TCI_CAMERASPACEREFLECTIONVECTOR - Set eye plane\n");
1740
1741 glMatrixMode(GL_MODELVIEW);
1742 glPushMatrix();
1743 glLoadIdentity();
1744 glTexGenfv(GL_S, GL_EYE_PLANE, s_plane);
1745 glTexGenfv(GL_T, GL_EYE_PLANE, t_plane);
1746 glTexGenfv(GL_R, GL_EYE_PLANE, r_plane);
1747 glTexGenfv(GL_Q, GL_EYE_PLANE, q_plane);
1748 glPopMatrix();
1749
1750 glEnable(GL_TEXTURE_GEN_S);
1751 checkGLcall("glEnable(GL_TEXTURE_GEN_S);");
1752 glTexGeni(GL_S, GL_TEXTURE_GEN_MODE, GL_REFLECTION_MAP_NV);
1753 checkGLcall("glTexGeni(GL_S, GL_TEXTURE_GEN_MODE, GL_REFLECTION_MAP_NV)");
1754 glEnable(GL_TEXTURE_GEN_T);
1755 checkGLcall("glEnable(GL_TEXTURE_GEN_T);");
1756 glTexGeni(GL_T, GL_TEXTURE_GEN_MODE, GL_REFLECTION_MAP_NV);
1757 checkGLcall("glTexGeni(GL_T, GL_TEXTURE_GEN_MODE, GL_REFLECTION_MAP_NV)");
1758 glEnable(GL_TEXTURE_GEN_R);
1759 checkGLcall("glEnable(GL_TEXTURE_GEN_R);");
1760 glTexGeni(GL_R, GL_TEXTURE_GEN_MODE, GL_REFLECTION_MAP_NV);
1761 checkGLcall("glTexGeni(GL_R, GL_TEXTURE_GEN_MODE, GL_REFLECTION_MAP_NV)");
1762 }
1763 }
1764 break;
1765
1766 /* Unhandled types: */
1767 default:
1768 /* Todo: */
1769 /* ? disable GL_TEXTURE_GEN_n ? */
1770 glDisable(GL_TEXTURE_GEN_S);
1771 glDisable(GL_TEXTURE_GEN_T);
1772 glDisable(GL_TEXTURE_GEN_R);
1773 glDisable(GL_TEXTURE_GEN_Q);
1774 FIXME("Unhandled WINED3DTSS_TEXCOORDINDEX %x\n", stateblock->textureState[stage][WINED3DTSS_TEXCOORDINDEX]);
1775 break;
1776 }
Stefan Dösingerc10efb32007-01-01 23:53:59 +0100[diff] [blame]1777
1778 /* Update the texture matrix */
Stefan Dösinger380930d2007-02-12 19:18:31 +0100[diff] [blame]1779 if(!isStateDirty(context, STATE_TRANSFORM(WINED3DTS_TEXTURE0 + stage))) {
Stefan Dösingerc739c382007-02-12 19:18:22 +0100[diff] [blame]1780 transform_texture(STATE_TRANSFORM(WINED3DTS_TEXTURE0 + stage), stateblock, context);
Stefan Dösingerc10efb32007-01-01 23:53:59 +0100[diff] [blame]1781 }
Stefan Dösingerd5f18e62007-01-06 18:11:21 +0100[diff] [blame]1782
Stefan Dösinger380930d2007-02-12 19:18:31 +0100[diff] [blame]1783 if(!isStateDirty(context, STATE_VDECL) && context->namedArraysLoaded) {
Stefan Dösingerd5f18e62007-01-06 18:11:21 +0100[diff] [blame]1784 /* Reload the arrays if we are using fixed function arrays to reflect the selected coord input
1785 * source. Call loadVertexData directly because there is no need to reparse the vertex declaration
1786 * and do all the things linked to it
1787 * TODO: Tidy that up to reload only the arrays of the changed unit
1788 */
1789 loadVertexData(stateblock, &stateblock->wineD3DDevice->strided_streams);
1790 }
Stefan Dösinger4e531402006-12-19 23:04:16 +0100[diff] [blame]1791}
1792
Stefan Dösingerc739c382007-02-12 19:18:22 +0100[diff] [blame]1793static void tex_bumpenvlscale(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
Stefan Dösinger72a4f6e2006-12-19 23:05:08 +0100[diff] [blame]1794 DWORD stage = (state - STATE_TEXTURESTAGE(0, 0)) / WINED3D_HIGHEST_TEXTURE_STATE;
1795 union {
1796 DWORD d;
1797 float f;
1798 } tmpvalue;
1799
1800 tmpvalue.d = stateblock->textureState[stage][WINED3DTSS_BUMPENVLSCALE];
1801 if(tmpvalue.f != 0.0) {
1802 ERR("WINED3DTSS_BUMPENVLSCALE not supported yet\n");
1803 }
1804}
1805
Stefan Dösingerc739c382007-02-12 19:18:22 +0100[diff] [blame]1806static void tex_bumpenvloffset(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
Stefan Dösinger1021f642006-12-19 23:34:17 +0100[diff] [blame]1807 DWORD stage = (state - STATE_TEXTURESTAGE(0, 0)) / WINED3D_HIGHEST_TEXTURE_STATE;
1808 union {
1809 DWORD d;
1810 float f;
1811 } tmpvalue;
1812
1813 tmpvalue.d = stateblock->textureState[stage][WINED3DTSS_BUMPENVLOFFSET];
1814 if(tmpvalue.f != 0.0) {
1815 ERR("WINED3DTSS_BUMPENVLOFFSET not supported yet\n");
1816 }
1817}
1818
Stefan Dösingerc739c382007-02-12 19:18:22 +0100[diff] [blame]1819static void tex_resultarg(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
Stefan Dösinger63a8c3c2006-12-19 23:11:21 +0100[diff] [blame]1820 DWORD stage = (state - STATE_TEXTURESTAGE(0, 0)) / WINED3D_HIGHEST_TEXTURE_STATE;
1821
Stefan Dösinger60ea7602007-01-10 11:31:18 +0100[diff] [blame]1822 if(stage >= GL_LIMITS(texture_stages)) {
1823 return;
1824 }
1825
H. Verbeeta2fde7d2007-02-15 13:32:13 +0100[diff] [blame]1826 if(stateblock->textureState[stage][WINED3DTSS_RESULTARG] != WINED3DTA_CURRENT) {
Stefan Dösinger63a8c3c2006-12-19 23:11:21 +0100[diff] [blame]1827 ERR("WINED3DTSS_RESULTARG not supported yet\n");
1828 }
1829}
1830
Stefan Dösingerc739c382007-02-12 19:18:22 +0100[diff] [blame]1831static void sampler(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
Stefan Dösinger666b5072006-12-19 23:26:39 +0100[diff] [blame]1832 DWORD sampler = state - STATE_SAMPLER(0);
H. Verbeet7ae71a92007-01-03 19:18:59 +0100[diff] [blame]1833 DWORD mapped_stage = stateblock->wineD3DDevice->texUnitMap[sampler];
Stefan Dösinger197ec1c2007-01-02 00:07:55 +0100[diff] [blame]1834 union {
1835 float f;
1836 DWORD d;
1837 } tmpvalue;
Stefan Dösinger666b5072006-12-19 23:26:39 +0100[diff] [blame]1838
1839 TRACE("Sampler: %d\n", sampler);
1840 /* Enabling and disabling texture dimensions is done by texture stage state / pixel shader setup, this function
1841 * only has to bind textures and set the per texture states
1842 */
H. Verbeet7ae71a92007-01-03 19:18:59 +0100[diff] [blame]1843
1844 if (mapped_stage == -1) {
1845 TRACE("No sampler mapped to stage %d. Returning.\n", sampler);
1846 return;
1847 }
1848
Stefan Dösinger666b5072006-12-19 23:26:39 +0100[diff] [blame]1849 if (GL_SUPPORT(ARB_MULTITEXTURE)) {
Stefan Dösinger666b5072006-12-19 23:26:39 +0100[diff] [blame]1850 if(sampler >= GL_LIMITS(sampler_stages)) {
1851 return;
1852 }
H. Verbeet7ae71a92007-01-03 19:18:59 +0100[diff] [blame]1853 GL_EXTCALL(glActiveTextureARB(GL_TEXTURE0_ARB + mapped_stage));
Stefan Dösinger666b5072006-12-19 23:26:39 +0100[diff] [blame]1854 checkGLcall("glActiveTextureARB");
1855 } else if (sampler > 0) {
1856 /* We can't do anything here */
1857 WARN("Program using multiple concurrent textures which this opengl implementation doesn't support\n");
1858 return;
1859 }
1860
1861 if(stateblock->textures[sampler]) {
Stefan Dösinger577f8db2007-01-06 18:43:08 +0100[diff] [blame]1862 BOOL texIsPow2 = FALSE;
Stefan Dösingerc10efb32007-01-01 23:53:59 +0100[diff] [blame]1863
Stefan Dösinger577f8db2007-01-06 18:43:08 +0100[diff] [blame]1864 /* The fixed function np2 texture emulation uses the texture matrix to fix up the coordinates
1865 * IWineD3DBaseTexture::ApplyStateChanges multiplies the set matrix with a fixup matrix. Before the
1866 * scaling is reapplied or removed, the texture matrix has to be reapplied
1867 */
Stefan Dösingerb48dfb32007-02-13 20:21:48 +0100[diff] [blame]1868 if(!GL_SUPPORT(ARB_TEXTURE_NON_POWER_OF_TWO) && sampler < MAX_TEXTURES) {
Stefan Dösinger577f8db2007-01-06 18:43:08 +0100[diff] [blame]1869 if(stateblock->textureDimensions[sampler] == GL_TEXTURE_2D) {
1870 if(((IWineD3DTextureImpl *) stateblock->textures[sampler])->pow2scalingFactorX != 1.0 ||
1871 ((IWineD3DTextureImpl *) stateblock->textures[sampler])->pow2scalingFactorY != 1.0 ) {
1872 texIsPow2 = TRUE;
1873 }
1874 } else if(stateblock->textureDimensions[sampler] == GL_TEXTURE_CUBE_MAP_ARB) {
1875 if(((IWineD3DCubeTextureImpl *) stateblock->textures[sampler])->pow2scalingFactor != 1.0) {
1876 texIsPow2 = TRUE;
1877 }
1878 }
1879
Stefan Dösingere6c9a072007-02-12 19:18:27 +0100[diff] [blame]1880 if(texIsPow2 || context->lastWasPow2Texture[sampler]) {
Stefan Dösingerc739c382007-02-12 19:18:22 +0100[diff] [blame]1881 transform_texture(STATE_TRANSFORM(WINED3DTS_TEXTURE0 + stateblock->wineD3DDevice->texUnitMap[sampler]), stateblock, context);
Stefan Dösingere6c9a072007-02-12 19:18:27 +0100[diff] [blame]1882 context->lastWasPow2Texture[sampler] = texIsPow2;
Stefan Dösinger577f8db2007-01-06 18:43:08 +0100[diff] [blame]1883 }
Stefan Dösingerc10efb32007-01-01 23:53:59 +0100[diff] [blame]1884 }
1885
Stefan Dösinger666b5072006-12-19 23:26:39 +0100[diff] [blame]1886 IWineD3DBaseTexture_PreLoad((IWineD3DBaseTexture *) stateblock->textures[sampler]);
Stefan Dösinger666b5072006-12-19 23:26:39 +0100[diff] [blame]1887 IWineD3DBaseTexture_ApplyStateChanges(stateblock->textures[sampler], stateblock->textureState[sampler], stateblock->samplerState[sampler]);
1888
Stefan Dösinger197ec1c2007-01-02 00:07:55 +0100[diff] [blame]1889 if (GL_SUPPORT(EXT_TEXTURE_LOD_BIAS)) {
1890 tmpvalue.d = stateblock->samplerState[sampler][WINED3DSAMP_MIPMAPLODBIAS];
1891 glTexEnvf(GL_TEXTURE_FILTER_CONTROL_EXT,
1892 GL_TEXTURE_LOD_BIAS_EXT,
1893 tmpvalue.f);
1894 checkGLcall("glTexEnvi GL_TEXTURE_LOD_BIAS_EXT ...");
1895 }
1896
Stefan Dösinger666b5072006-12-19 23:26:39 +0100[diff] [blame]1897 if (stateblock->wineD3DDevice->ps_selected_mode != SHADER_NONE && stateblock->pixelShader &&
1898 ((IWineD3DPixelShaderImpl *)stateblock->pixelShader)->baseShader.function) {
1899 /* Using a pixel shader? Verify the sampler types */
1900
1901 /* Make sure that the texture dimensions are enabled. I don't have to disable the other
1902 * dimensions because the shader knows from which texture type to sample from. For the sake of
1903 * debugging all dimensions could be enabled and a texture with some ugly pink bound to the unused
1904 * dimensions. This should make wrong sampling sources visible :-)
1905 */
1906 glEnable(stateblock->textureDimensions[sampler]);
1907 checkGLcall("glEnable(stateblock->textureDimensions[sampler])");
1908 } else if(sampler < stateblock->lowest_disabled_stage) {
Stefan Dösinger380930d2007-02-12 19:18:31 +0100[diff] [blame]1909 if(!isStateDirty(context, STATE_TEXTURESTAGE(sampler, WINED3DTSS_COLOROP))) {
Stefan Dösingerb07c48c2007-01-10 11:44:55 +0100[diff] [blame]1910 activate_dimensions(sampler, stateblock);
1911 }
Stefan Dösinger666b5072006-12-19 23:26:39 +0100[diff] [blame]1912
1913 if(stateblock->renderState[WINED3DRS_COLORKEYENABLE] && sampler == 0) {
Francois Gougetbbb2b7f2007-01-04 10:47:11 +0100[diff] [blame]1914 /* If color keying is enabled update the alpha test, it depends on the existence
Stefan Dösinger666b5072006-12-19 23:26:39 +0100[diff] [blame]1915 * of a color key in stage 0
1916 */
Stefan Dösingerc739c382007-02-12 19:18:22 +0100[diff] [blame]1917 state_alpha(WINED3DRS_COLORKEYENABLE, stateblock, context);
Stefan Dösinger666b5072006-12-19 23:26:39 +0100[diff] [blame]1918 }
1919 }
1920 } else if(sampler < GL_LIMITS(texture_stages)) {
1921 if(sampler < stateblock->lowest_disabled_stage) {
Stefan Dösingerb07c48c2007-01-10 11:44:55 +0100[diff] [blame]1922 /* TODO: What should I do with pixel shaders here ??? */
Stefan Dösinger380930d2007-02-12 19:18:31 +0100[diff] [blame]1923 if(!isStateDirty(context, STATE_TEXTURESTAGE(sampler, WINED3DTSS_COLOROP))) {
Stefan Dösingerb07c48c2007-01-10 11:44:55 +0100[diff] [blame]1924 activate_dimensions(sampler, stateblock);
1925 }
Stefan Dösinger666b5072006-12-19 23:26:39 +0100[diff] [blame]1926 } /* Otherwise tex_colorop disables the stage */
1927 glBindTexture(GL_TEXTURE_1D, stateblock->wineD3DDevice->dummyTextureName[sampler]);
1928 checkGLcall("glBindTexture(GL_TEXTURE_1D, stateblock->wineD3DDevice->dummyTextureName[sampler])");
1929 }
1930}
1931
Stefan Dösingerc739c382007-02-12 19:18:22 +0100[diff] [blame]1932static void shaderconstant(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
Stefan Dösinger8e37fcd2007-01-06 18:17:27 +0100[diff] [blame]1933 IWineD3DDeviceImpl *device = stateblock->wineD3DDevice;
1934
1935 /* Vertex and pixel shader states will call a shader upload, don't do anything as long one of them
1936 * has an update pending
1937 */
Stefan Dösinger380930d2007-02-12 19:18:31 +0100[diff] [blame]1938 if(isStateDirty(context, STATE_VDECL) ||
1939 isStateDirty(context, STATE_PIXELSHADER)) {
Stefan Dösinger8e37fcd2007-01-06 18:17:27 +0100[diff] [blame]1940 return;
1941 }
1942
1943 device->shader_backend->shader_load_constants((IWineD3DDevice *) device,
1944 stateblock->pixelShader && ((IWineD3DPixelShaderImpl *)stateblock->pixelShader)->baseShader.function,
1945 stateblock->vertexShader && ((IWineD3DVertexShaderImpl *)stateblock->vertexShader)->baseShader.function);
1946}
1947
Stefan Dösingerc739c382007-02-12 19:18:22 +0100[diff] [blame]1948static void pixelshader(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
H. Verbeet2a309f52007-02-13 19:53:20 +0100[diff] [blame]1949 BOOL use_ps = stateblock->pixelShader && ((IWineD3DPixelShaderImpl *)stateblock->pixelShader)->baseShader.function != NULL;
1950 BOOL use_vs = stateblock->vertexShader && ((IWineD3DVertexShaderImpl *)stateblock->vertexShader)->baseShader.function != NULL;
Stefan Dösinger22e2a5a2006-12-19 23:22:19 +0100[diff] [blame]1951 int i;
1952
H. Verbeet2a309f52007-02-13 19:53:20 +0100[diff] [blame]1953 if (use_ps) {
Stefan Dösingere6c9a072007-02-12 19:18:27 +0100[diff] [blame]1954 if(!context->last_was_pshader) {
Stefan Dösinger22e2a5a2006-12-19 23:22:19 +0100[diff] [blame]1955 /* Former draw without a pixel shader, some samplers
1956 * may be disabled because of WINED3DTSS_COLOROP = WINED3DTOP_DISABLE
1957 * make sure to enable them
1958 */
1959 for(i=0; i < MAX_SAMPLERS; i++) {
Stefan Dösinger380930d2007-02-12 19:18:31 +0100[diff] [blame]1960 if(!isStateDirty(context, STATE_SAMPLER(i))) {
Stefan Dösingerc739c382007-02-12 19:18:22 +0100[diff] [blame]1961 sampler(STATE_SAMPLER(i), stateblock, context);
Stefan Dösinger22e2a5a2006-12-19 23:22:19 +0100[diff] [blame]1962 }
1963 }
1964 } else {
1965 /* Otherwise all samplers were activated by the code above in earlier draws, or by sampler()
1966 * if a different texture was bound. I don't have to do anything.
1967 */
1968 }
1969
1970 /* Compile and bind the shader */
1971 IWineD3DPixelShader_CompileShader(stateblock->pixelShader);
Stefan Dösinger22e2a5a2006-12-19 23:22:19 +0100[diff] [blame]1972 } else {
1973 /* Disabled the pixel shader - color ops weren't applied
1974 * while it was enabled, so re-apply them.
1975 */
1976 for(i=0; i < MAX_TEXTURES; i++) {
Stefan Dösinger380930d2007-02-12 19:18:31 +0100[diff] [blame]1977 if(!isStateDirty(context, STATE_TEXTURESTAGE(i, WINED3DTSS_COLOROP))) {
Stefan Dösingerc739c382007-02-12 19:18:22 +0100[diff] [blame]1978 tex_colorop(STATE_TEXTURESTAGE(i, WINED3DTSS_COLOROP), stateblock, context);
Stefan Dösinger22e2a5a2006-12-19 23:22:19 +0100[diff] [blame]1979 }
1980 }
H. Verbeet2a309f52007-02-13 19:53:20 +0100[diff] [blame]1981 }
Stefan Dösinger22e2a5a2006-12-19 23:22:19 +0100[diff] [blame]1982
H. Verbeet2a309f52007-02-13 19:53:20 +0100[diff] [blame]1983 if(!isStateDirty(context, StateTable[STATE_VSHADER].representative)) {
1984 stateblock->wineD3DDevice->shader_backend->shader_select((IWineD3DDevice *)stateblock->wineD3DDevice, use_ps, use_vs);
Stefan Dösinger8e37fcd2007-01-06 18:17:27 +0100[diff] [blame]1985
H. Verbeet2a309f52007-02-13 19:53:20 +0100[diff] [blame]1986 if(!isStateDirty(context, STATE_VERTEXSHADERCONSTANT) && (use_vs || use_ps)) {
1987 shaderconstant(STATE_VERTEXSHADERCONSTANT, stateblock, context);
Stefan Dösinger799770b2007-01-06 18:14:12 +0100[diff] [blame]1988 }
Stefan Dösinger22e2a5a2006-12-19 23:22:19 +0100[diff] [blame]1989 }
H. Verbeet2a309f52007-02-13 19:53:20 +0100[diff] [blame]1990
1991 context->last_was_pshader = use_ps;
Stefan Dösinger22e2a5a2006-12-19 23:22:19 +0100[diff] [blame]1992}
1993
Stefan Dösingerefbd6d62007-02-15 02:57:49 +0100[diff] [blame]1994static void tex_bumpenvmat(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
Stefan Dösinger49a49fc2007-02-15 03:05:17 +0100[diff] [blame]1995 DWORD stage = (state - STATE_TEXTURESTAGE(0, 0)) / WINED3D_HIGHEST_TEXTURE_STATE;
1996
1997 if(stateblock->pixelShader && stage != 0 &&
1998 ((IWineD3DPixelShaderImpl *) stateblock->pixelShader)->needsbumpmat == stage) {
1999 /* The pixel shader has to know the bump env matrix. Do a constants update if it isn't scheduled
2000 * anyway
2001 */
2002 if(!isStateDirty(context, STATE_PIXELSHADERCONSTANT) &&
2003 !isStateDirty(context, STATE_PIXELSHADER)) {
2004 shaderconstant(STATE_PIXELSHADERCONSTANT, stateblock, context);
2005 }
2006 }
Stefan Dösingerefbd6d62007-02-15 02:57:49 +0100[diff] [blame]2007}
2008
Stefan Dösingerc739c382007-02-12 19:18:22 +0100[diff] [blame]2009static void transform_world(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
Stefan Dösingere26e3ee2007-01-02 22:52:11 +0100[diff] [blame]2010 /* This function is called by transform_view below if the view matrix was changed too
2011 *
2012 * Deliberately no check if the vertex declaration is dirty because the vdecl state
2013 * does not always update the world matrix, only on a switch between transformed
2014 * and untrannsformed draws. It *may* happen that the world matrix is set 2 times during one
2015 * draw, but that should be rather rare and cheaper in total.
Stefan Dösinger5fa0f7f2007-01-02 22:47:39 +0100[diff] [blame]2016 */
Stefan Dösinger5fa0f7f2007-01-02 22:47:39 +0100[diff] [blame]2017 glMatrixMode(GL_MODELVIEW);
2018 checkGLcall("glMatrixMode");
2019
Stefan Dösingere6c9a072007-02-12 19:18:27 +0100[diff] [blame]2020 if(context->last_was_rhw) {
Stefan Dösingere26e3ee2007-01-02 22:52:11 +0100[diff] [blame]2021 glLoadIdentity();
2022 checkGLcall("glLoadIdentity()");
Stefan Dösinger5fa0f7f2007-01-02 22:47:39 +0100[diff] [blame]2023 } else {
Stefan Dösingere26e3ee2007-01-02 22:52:11 +0100[diff] [blame]2024 /* In the general case, the view matrix is the identity matrix */
2025 if (stateblock->wineD3DDevice->view_ident) {
2026 glLoadMatrixf((float *) &stateblock->transforms[WINED3DTS_WORLDMATRIX(0)].u.m[0][0]);
2027 checkGLcall("glLoadMatrixf");
2028 } else {
2029 glLoadMatrixf((float *) &stateblock->transforms[WINED3DTS_VIEW].u.m[0][0]);
2030 checkGLcall("glLoadMatrixf");
2031 glMultMatrixf((float *) &stateblock->transforms[WINED3DTS_WORLDMATRIX(0)].u.m[0][0]);
2032 checkGLcall("glMultMatrixf");
2033 }
Stefan Dösinger5fa0f7f2007-01-02 22:47:39 +0100[diff] [blame]2034 }
2035}
2036
Stefan Dösingerc739c382007-02-12 19:18:22 +0100[diff] [blame]2037static void transform_view(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
Stefan Dösingerf5fafab2007-01-02 00:48:58 +0100[diff] [blame]2038 unsigned int k;
2039
2040 /* If we are changing the View matrix, reset the light and clipping planes to the new view
2041 * NOTE: We have to reset the positions even if the light/plane is not currently
2042 * enabled, since the call to enable it will not reset the position.
2043 * NOTE2: Apparently texture transforms do NOT need reapplying
2044 */
2045
Stefan Dösingeracadf3f2007-02-14 17:46:54 +0100[diff] [blame]2046 PLIGHTINFOEL *light = NULL;
Stefan Dösingerf5fafab2007-01-02 00:48:58 +0100[diff] [blame]2047
2048 glMatrixMode(GL_MODELVIEW);
2049 checkGLcall("glMatrixMode(GL_MODELVIEW)");
Stefan Dösingerf5fafab2007-01-02 00:48:58 +0100[diff] [blame]2050 glLoadMatrixf((float *)(float *) &stateblock->transforms[WINED3DTS_VIEW].u.m[0][0]);
2051 checkGLcall("glLoadMatrixf(...)");
2052
2053 /* Reset lights. TODO: Call light apply func */
Stefan Dösingeracadf3f2007-02-14 17:46:54 +0100[diff] [blame]2054 for(k = 0; k < stateblock->wineD3DDevice->maxConcurrentLights; k++) {
2055 light = stateblock->activeLights[k];
2056 if(!light) continue;
2057 glLightfv(GL_LIGHT0 + light->glIndex, GL_POSITION, light->lightPosn);
Stefan Dösingerf5fafab2007-01-02 00:48:58 +0100[diff] [blame]2058 checkGLcall("glLightfv posn");
Stefan Dösingeracadf3f2007-02-14 17:46:54 +0100[diff] [blame]2059 glLightfv(GL_LIGHT0 + light->glIndex, GL_SPOT_DIRECTION, light->lightDirn);
Stefan Dösingerf5fafab2007-01-02 00:48:58 +0100[diff] [blame]2060 checkGLcall("glLightfv dirn");
Stefan Dösingerf5fafab2007-01-02 00:48:58 +0100[diff] [blame]2061 }
2062
2063 /* Reset Clipping Planes if clipping is enabled. TODO: Call clipplane apply func */
2064 for (k = 0; k < GL_LIMITS(clipplanes); k++) {
2065 glClipPlane(GL_CLIP_PLANE0 + k, stateblock->clipplane[k]);
2066 checkGLcall("glClipPlane");
2067 }
Stefan Dösinger20de2002007-01-02 22:47:10 +0100[diff] [blame]2068
Stefan Dösingere6c9a072007-02-12 19:18:27 +0100[diff] [blame]2069 if(context->last_was_rhw) {
Stefan Dösinger5fa0f7f2007-01-02 22:47:39 +0100[diff] [blame]2070 glLoadIdentity();
2071 checkGLcall("glLoadIdentity()");
2072 /* No need to update the world matrix, the identity is fine */
2073 return;
2074 }
2075
2076 /* Call the world matrix state, this will apply the combined WORLD + VIEW matrix
2077 * No need to do it here if the state is scheduled for update.
2078 */
Stefan Dösinger380930d2007-02-12 19:18:31 +0100[diff] [blame]2079 if(!isStateDirty(context, STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(0)))) {
Stefan Dösingerc739c382007-02-12 19:18:22 +0100[diff] [blame]2080 transform_world(STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(0)), stateblock, context);
Stefan Dösinger5fa0f7f2007-01-02 22:47:39 +0100[diff] [blame]2081 }
Stefan Dösingerf5fafab2007-01-02 00:48:58 +0100[diff] [blame]2082}
2083
Stefan Dösingerc739c382007-02-12 19:18:22 +0100[diff] [blame]2084static void transform_worldex(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
Stefan Dösingerfe6165d2007-01-10 11:37:03 +0100[diff] [blame]2085 WARN("World matrix 1 - 255 not supported yet\n");
Stefan Dösingera710f722007-01-02 00:25:51 +0100[diff] [blame]2086}
2087
Stefan Dösinger20de2002007-01-02 22:47:10 +0100[diff] [blame]2088static const GLfloat invymat[16] = {
2089 1.0f, 0.0f, 0.0f, 0.0f,
2090 0.0f, -1.0f, 0.0f, 0.0f,
2091 0.0f, 0.0f, 1.0f, 0.0f,
2092 0.0f, 0.0f, 0.0f, 1.0f};
2093
Stefan Dösingerc739c382007-02-12 19:18:22 +0100[diff] [blame]2094static void transform_projection(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
Stefan Dösinger82bd0792007-01-02 22:50:38 +0100[diff] [blame]2095 glMatrixMode(GL_PROJECTION);
2096 checkGLcall("glMatrixMode(GL_PROJECTION)");
2097 glLoadIdentity();
2098 checkGLcall("glLoadIdentity");
2099
Stefan Dösingere6c9a072007-02-12 19:18:27 +0100[diff] [blame]2100 if(context->last_was_rhw) {
Stefan Dösinger82bd0792007-01-02 22:50:38 +0100[diff] [blame]2101 double X, Y, height, width, minZ, maxZ;
2102
2103 X = stateblock->viewport.X;
2104 Y = stateblock->viewport.Y;
2105 height = stateblock->viewport.Height;
2106 width = stateblock->viewport.Width;
2107 minZ = stateblock->viewport.MinZ;
2108 maxZ = stateblock->viewport.MaxZ;
2109
2110 if(!stateblock->wineD3DDevice->untransformed) {
2111 /* Transformed vertices are supposed to bypass the whole transform pipeline including
2112 * frustum clipping. This can't be done in opengl, so this code adjusts the Z range to
2113 * suppress depth clipping. This can be done because it is an orthogonal projection and
2114 * the Z coordinate does not affect the size of the primitives
2115 */
2116 TRACE("Calling glOrtho with %f, %f, %f, %f\n", width, height, -minZ, -maxZ);
2117 glOrtho(X, X + width, Y + height, Y, -minZ, -maxZ);
2118 } else {
2119 /* If the app mixes transformed and untransformed primitives we can't use the coordinate system
2120 * trick above because this would mess up transformed and untransformed Z order. Pass the z position
2121 * unmodified to opengl.
2122 *
2123 * If the app depends on mixed types and disabled clipping we're out of luck without a pipeline
2124 * replacement shader.
2125 */
2126 TRACE("Calling glOrtho with %f, %f, %f, %f\n", width, height, 1.0, -1.0);
2127 glOrtho(X, X + width, Y + height, Y, 1.0, -1.0);
2128 }
2129 checkGLcall("glOrtho");
2130
2131 /* Window Coord 0 is the middle of the first pixel, so translate by 3/8 pixels */
2132 glTranslatef(0.375, 0.375, 0);
2133 checkGLcall("glTranslatef(0.375, 0.375, 0)");
2134 /* D3D texture coordinates are flipped compared to OpenGL ones, so
2135 * render everything upside down when rendering offscreen. */
2136 if (stateblock->wineD3DDevice->render_offscreen) {
2137 glMultMatrixf(invymat);
2138 checkGLcall("glMultMatrixf(invymat)");
2139 }
2140 } else {
2141 /* The rule is that the window coordinate 0 does not correspond to the
2142 beginning of the first pixel, but the center of the first pixel.
2143 As a consequence if you want to correctly draw one line exactly from
2144 the left to the right end of the viewport (with all matrices set to
2145 be identity), the x coords of both ends of the line would be not
2146 -1 and 1 respectively but (-1-1/viewport_widh) and (1-1/viewport_width)
2147 instead. */
2148 glTranslatef(0.9 / stateblock->viewport.Width, -0.9 / stateblock->viewport.Height, 0);
2149 checkGLcall("glTranslatef (0.9 / width, -0.9 / height, 0)");
2150
2151 /* D3D texture coordinates are flipped compared to OpenGL ones, so
2152 * render everything upside down when rendering offscreen. */
2153 if (stateblock->wineD3DDevice->render_offscreen) {
2154 glMultMatrixf(invymat);
2155 checkGLcall("glMultMatrixf(invymat)");
2156 }
2157 glMultMatrixf((float *) &stateblock->transforms[WINED3DTS_PROJECTION].u.m[0][0]);
2158 checkGLcall("glLoadMatrixf");
2159 }
2160}
2161
Stefan Dösingerd5f18e62007-01-06 18:11:21 +0100[diff] [blame]2162/* This should match any arrays loaded in loadVertexData.
2163 * stateblock impl is required for GL_SUPPORT
2164 * TODO: Only load / unload arrays if we have to.
2165 */
2166static inline void unloadVertexData(IWineD3DStateBlockImpl *stateblock) {
2167 int texture_idx;
2168
2169 glDisableClientState(GL_VERTEX_ARRAY);
2170 glDisableClientState(GL_NORMAL_ARRAY);
2171 glDisableClientState(GL_COLOR_ARRAY);
2172 if (GL_SUPPORT(EXT_SECONDARY_COLOR)) {
2173 glDisableClientState(GL_SECONDARY_COLOR_ARRAY_EXT);
2174 }
2175 for (texture_idx = 0; texture_idx < GL_LIMITS(textures); ++texture_idx) {
2176 GL_EXTCALL(glClientActiveTextureARB(GL_TEXTURE0_ARB + texture_idx));
2177 glDisableClientState(GL_TEXTURE_COORD_ARRAY);
2178 }
2179}
2180
2181/* This should match any arrays loaded in loadNumberedArrays
2182 * TODO: Only load / unload arrays if we have to.
2183 */
2184static inline void unloadNumberedArrays(IWineD3DStateBlockImpl *stateblock) {
2185 /* disable any attribs (this is the same for both GLSL and ARB modes) */
2186 GLint maxAttribs;
2187 int i;
2188
2189 /* Leave all the attribs disabled */
2190 glGetIntegerv(GL_MAX_VERTEX_ATTRIBS_ARB, &maxAttribs);
2191 /* MESA does not support it right not */
2192 if (glGetError() != GL_NO_ERROR)
2193 maxAttribs = 16;
2194 for (i = 0; i < maxAttribs; ++i) {
2195 GL_EXTCALL(glDisableVertexAttribArrayARB(i));
2196 checkGLcall("glDisableVertexAttribArrayARB(reg);");
2197 }
2198}
2199
2200static inline void loadNumberedArrays(IWineD3DStateBlockImpl *stateblock, WineDirect3DVertexStridedData *strided) {
2201 GLint curVBO = GL_SUPPORT(ARB_VERTEX_BUFFER_OBJECT) ? -1 : 0;
2202 int i;
Stefan Dösinger354fdae2007-01-17 00:06:34 +0100[diff] [blame]2203 UINT *offset = stateblock->streamOffset;
Stefan Dösingerd5f18e62007-01-06 18:11:21 +0100[diff] [blame]2204
Stefan Dösinger0feddcc2007-02-14 17:56:29 +0100[diff] [blame]2205 /* Default to no instancing */
2206 stateblock->wineD3DDevice->instancedDraw = FALSE;
2207
Stefan Dösingerd5f18e62007-01-06 18:11:21 +0100[diff] [blame]2208 for (i = 0; i < MAX_ATTRIBS; i++) {
2209
2210 if (!strided->u.input[i].lpData && !strided->u.input[i].VBO)
2211 continue;
2212
Stefan Dösinger0feddcc2007-02-14 17:56:29 +0100[diff] [blame]2213 /* Do not load instance data. It will be specified using glTexCoord by drawprim */
H. Verbeet498f9c52007-02-14 23:30:16 +0100[diff] [blame]2214 if(stateblock->streamFlags[strided->u.input[i].streamNo] & WINED3DSTREAMSOURCE_INSTANCEDATA) {
Stefan Dösinger0feddcc2007-02-14 17:56:29 +0100[diff] [blame]2215 GL_EXTCALL(glDisableVertexAttribArrayARB(i));
2216 stateblock->wineD3DDevice->instancedDraw = TRUE;
2217 continue;
2218 }
2219
Stefan Dösingerd5f18e62007-01-06 18:11:21 +0100[diff] [blame]2220 TRACE_(d3d_shader)("Loading array %u [VBO=%u]\n", i, strided->u.input[i].VBO);
2221
Stefan Dösinger93cd7ef2007-02-14 17:55:56 +0100[diff] [blame]2222 if(strided->u.input[i].dwStride) {
2223 if(curVBO != strided->u.input[i].VBO) {
2224 GL_EXTCALL(glBindBufferARB(GL_ARRAY_BUFFER_ARB, strided->u.input[i].VBO));
2225 checkGLcall("glBindBufferARB");
2226 curVBO = strided->u.input[i].VBO;
2227 }
2228 GL_EXTCALL(glVertexAttribPointerARB(i,
2229 WINED3D_ATR_SIZE(strided->u.input[i].dwType),
2230 WINED3D_ATR_GLTYPE(strided->u.input[i].dwType),
2231 WINED3D_ATR_NORMALIZED(strided->u.input[i].dwType),
2232 strided->u.input[i].dwStride,
2233 strided->u.input[i].lpData + stateblock->loadBaseVertexIndex * strided->u.input[i].dwStride + offset[strided->u.input[i].streamNo]) );
2234 GL_EXTCALL(glEnableVertexAttribArrayARB(i));
2235 } else {
2236 /* Stride = 0 means always the same values. glVertexAttribPointerARB doesn't do that. Instead disable the pointer and
2237 * set up the attribute statically. But we have to figure out the system memory address.
2238 */
2239 BYTE *ptr = strided->u.input[i].lpData + offset[strided->u.input[i].streamNo];
2240 if(strided->u.input[i].VBO) {
2241 IWineD3DVertexBufferImpl *vb = (IWineD3DVertexBufferImpl *) stateblock->streamSource[strided->u.input[i].streamNo];
2242 ptr += (long) vb->resource.allocatedMemory;
2243 }
2244 GL_EXTCALL(glDisableVertexAttribArrayARB(i));
2245
2246 switch(strided->u.input[i].dwType) {
2247 case WINED3DDECLTYPE_FLOAT1:
2248 GL_EXTCALL(glVertexAttrib1fvARB(i, (float *) ptr));
2249 break;
2250 case WINED3DDECLTYPE_FLOAT2:
2251 GL_EXTCALL(glVertexAttrib2fvARB(i, (float *) ptr));
2252 break;
2253 case WINED3DDECLTYPE_FLOAT3:
2254 GL_EXTCALL(glVertexAttrib3fvARB(i, (float *) ptr));
2255 break;
2256 case WINED3DDECLTYPE_FLOAT4:
2257 GL_EXTCALL(glVertexAttrib4fvARB(i, (float *) ptr));
2258 break;
2259
2260 case WINED3DDECLTYPE_UBYTE4:
2261 GL_EXTCALL(glVertexAttrib4NubvARB(i, ptr));
2262 break;
2263 case WINED3DDECLTYPE_UBYTE4N:
2264 case WINED3DDECLTYPE_D3DCOLOR:
2265 GL_EXTCALL(glVertexAttrib4NubvARB(i, ptr));
2266 break;
2267
2268 case WINED3DDECLTYPE_SHORT2:
2269 GL_EXTCALL(glVertexAttrib4svARB(i, (GLshort *) ptr));
2270 break;
2271 case WINED3DDECLTYPE_SHORT4:
2272 GL_EXTCALL(glVertexAttrib4svARB(i, (GLshort *) ptr));
2273 break;
2274
2275 case WINED3DDECLTYPE_SHORT2N:
2276 {
2277 GLshort s[4] = {((short *) ptr)[0], ((short *) ptr)[1], 0, 1};
2278 GL_EXTCALL(glVertexAttrib4NsvARB(i, s));
2279 break;
2280 }
2281 case WINED3DDECLTYPE_USHORT2N:
2282 {
2283 GLushort s[4] = {((unsigned short *) ptr)[0], ((unsigned short *) ptr)[1], 0, 1};
2284 GL_EXTCALL(glVertexAttrib4NusvARB(i, s));
2285 break;
2286 }
2287 case WINED3DDECLTYPE_SHORT4N:
2288 GL_EXTCALL(glVertexAttrib4NsvARB(i, (GLshort *) ptr));
2289 break;
2290 case WINED3DDECLTYPE_USHORT4N:
2291 GL_EXTCALL(glVertexAttrib4NusvARB(i, (GLushort *) ptr));
2292 break;
2293
2294 case WINED3DDECLTYPE_UDEC3:
2295 FIXME("Unsure about WINED3DDECLTYPE_UDEC3\n");
Stefan Dösinger0feddcc2007-02-14 17:56:29 +0100[diff] [blame]2296 /*glVertexAttrib3usvARB(i, (GLushort *) ptr); Does not exist */
Stefan Dösinger93cd7ef2007-02-14 17:55:56 +0100[diff] [blame]2297 break;
2298 case WINED3DDECLTYPE_DEC3N:
2299 FIXME("Unsure about WINED3DDECLTYPE_DEC3N\n");
Stefan Dösinger0feddcc2007-02-14 17:56:29 +0100[diff] [blame]2300 /*glVertexAttrib3NusvARB(i, (GLushort *) ptr); Does not exist */
Stefan Dösinger93cd7ef2007-02-14 17:55:56 +0100[diff] [blame]2301 break;
2302
2303 case WINED3DDECLTYPE_FLOAT16_2:
2304 /* Are those 16 bit floats. C doesn't have a 16 bit float type. I could read the single bits and calculate a 4
2305 * byte float according to the IEEE standard
2306 */
2307 FIXME("Unsupported WINED3DDECLTYPE_FLOAT16_2\n");
2308 break;
2309 case WINED3DDECLTYPE_FLOAT16_4:
2310 FIXME("Unsupported WINED3DDECLTYPE_FLOAT16_4\n");
2311 break;
2312
2313 case WINED3DDECLTYPE_UNUSED:
2314 default:
2315 ERR("Unexpected declaration in stride 0 attributes\n");
2316 break;
2317
2318 }
Stefan Dösingerd5f18e62007-01-06 18:11:21 +0100[diff] [blame]2319 }
Stefan Dösinger93cd7ef2007-02-14 17:55:56 +0100[diff] [blame]2320 }
Stefan Dösingerd5f18e62007-01-06 18:11:21 +0100[diff] [blame]2321}
2322
2323/* Used from 2 different functions, and too big to justify making it inlined */
2324static void loadVertexData(IWineD3DStateBlockImpl *stateblock, WineDirect3DVertexStridedData *sd) {
2325 unsigned int textureNo = 0;
2326 unsigned int texture_idx = 0;
Stefan Dösinger354fdae2007-01-17 00:06:34 +0100[diff] [blame]2327 UINT *offset = stateblock->streamOffset;
Stefan Dösingerd5f18e62007-01-06 18:11:21 +0100[diff] [blame]2328 GLint curVBO = GL_SUPPORT(ARB_VERTEX_BUFFER_OBJECT) ? -1 : 0;
2329
2330 TRACE("Using fast vertex array code\n");
Stefan Dösinger0feddcc2007-02-14 17:56:29 +0100[diff] [blame]2331
2332 /* This is fixed function pipeline only, and the fixed function pipeline doesn't do instancing */
2333 stateblock->wineD3DDevice->instancedDraw = FALSE;
2334
Stefan Dösingerd5f18e62007-01-06 18:11:21 +0100[diff] [blame]2335 /* Blend Data ---------------------------------------------- */
2336 if( (sd->u.s.blendWeights.lpData) || (sd->u.s.blendWeights.VBO) ||
2337 (sd->u.s.blendMatrixIndices.lpData) || (sd->u.s.blendMatrixIndices.VBO) ) {
2338
2339
2340 if (GL_SUPPORT(ARB_VERTEX_BLEND)) {
2341
2342#if 1
2343 glEnableClientState(GL_WEIGHT_ARRAY_ARB);
2344 checkGLcall("glEnableClientState(GL_WEIGHT_ARRAY_ARB)");
2345#endif
2346
2347 TRACE("Blend %d %p %d\n", WINED3D_ATR_SIZE(sd->u.s.blendWeights.dwType),
Stefan Dösinger354fdae2007-01-17 00:06:34 +0100[diff] [blame]2348 sd->u.s.blendWeights.lpData + stateblock->loadBaseVertexIndex * sd->u.s.blendWeights.dwStride, sd->u.s.blendWeights.dwStride + offset[sd->u.s.blendWeights.streamNo]);
Stefan Dösingerd5f18e62007-01-06 18:11:21 +0100[diff] [blame]2349 /* FIXME("TODO\n");*/
2350 /* Note dwType == float3 or float4 == 2 or 3 */
2351
2352#if 0
2353 /* with this on, the normals appear to be being modified,
2354 but the vertices aren't being translated as they should be
2355 Maybe the world matrix aren't being setup properly? */
2356 glVertexBlendARB(WINED3D_ATR_SIZE(sd->u.s.blendWeights.dwType) + 1);
2357#endif
2358
2359
2360 VTRACE(("glWeightPointerARB(%d, GL_FLOAT, %d, %p)\n",
2361 WINED3D_ATR_SIZE(sd->u.s.blendWeights.dwType) ,
2362 sd->u.s.blendWeights.dwStride,
Stefan Dösinger354fdae2007-01-17 00:06:34 +0100[diff] [blame]2363 sd->u.s.blendWeights.lpData + stateblock->loadBaseVertexIndex * sd->u.s.blendWeights.dwStride + offset[sd->u.s.blendWeights.streamNo]));
Stefan Dösingerd5f18e62007-01-06 18:11:21 +0100[diff] [blame]2364
2365 if(curVBO != sd->u.s.blendWeights.VBO) {
2366 GL_EXTCALL(glBindBufferARB(GL_ARRAY_BUFFER_ARB, sd->u.s.blendWeights.VBO));
2367 checkGLcall("glBindBufferARB");
2368 curVBO = sd->u.s.blendWeights.VBO;
2369 }
2370
2371 GL_EXTCALL(glWeightPointerARB)(
2372 WINED3D_ATR_SIZE(sd->u.s.blendWeights.dwType),
2373 WINED3D_ATR_GLTYPE(sd->u.s.blendWeights.dwType),
2374 sd->u.s.blendWeights.dwStride,
Stefan Dösinger354fdae2007-01-17 00:06:34 +0100[diff] [blame]2375 sd->u.s.blendWeights.lpData + stateblock->loadBaseVertexIndex * sd->u.s.blendWeights.dwStride + offset[sd->u.s.blendWeights.streamNo]);
Stefan Dösingerd5f18e62007-01-06 18:11:21 +0100[diff] [blame]2376
2377 checkGLcall("glWeightPointerARB");
2378
2379 if((sd->u.s.blendMatrixIndices.lpData) || (sd->u.s.blendMatrixIndices.VBO)){
2380 static BOOL showfixme = TRUE;
2381 if(showfixme){
2382 FIXME("blendMatrixIndices support\n");
2383 showfixme = FALSE;
2384 }
2385 }
2386
2387 } else if (GL_SUPPORT(EXT_VERTEX_WEIGHTING)) {
2388 /* FIXME("TODO\n");*/
2389#if 0
2390
2391 GL_EXTCALL(glVertexWeightPointerEXT)(
2392 WINED3D_ATR_SIZE(sd->u.s.blendWeights.dwType),
2393 WINED3D_ATR_GLTYPE(sd->u.s.blendWeights.dwType),
2394 sd->u.s.blendWeights.dwStride,
Stefan Dösinger09ab8122007-01-06 18:19:55 +0100[diff] [blame]2395 sd->u.s.blendWeights.lpData + stateblock->loadBaseVertexIndex * sd->u.s.blendWeights.dwStride);
Stefan Dösingerd5f18e62007-01-06 18:11:21 +0100[diff] [blame]2396 checkGLcall("glVertexWeightPointerEXT(numBlends, ...)");
2397 glEnableClientState(GL_VERTEX_WEIGHT_ARRAY_EXT);
2398 checkGLcall("glEnableClientState(GL_VERTEX_WEIGHT_ARRAY_EXT)");
2399#endif
2400
2401 } else {
Stefan Dösinger762e2272007-02-16 19:15:15 +0100[diff] [blame]2402 /* TODO: support blends in drawStridedSlow
2403 * No need to write a FIXME here, this is done after the general vertex decl decoding
2404 */
2405 WARN("unsupported blending in openGl\n");
Stefan Dösingerd5f18e62007-01-06 18:11:21 +0100[diff] [blame]2406 }
2407 } else {
2408 if (GL_SUPPORT(ARB_VERTEX_BLEND)) {
2409#if 0 /* TODO: Vertex blending */
2410 glDisable(GL_VERTEX_BLEND_ARB);
2411#endif
2412 TRACE("ARB_VERTEX_BLEND\n");
2413 } else if (GL_SUPPORT(EXT_VERTEX_WEIGHTING)) {
2414 TRACE(" EXT_VERTEX_WEIGHTING\n");
2415 glDisableClientState(GL_VERTEX_WEIGHT_ARRAY_EXT);
2416 checkGLcall("glDisableClientState(GL_VERTEX_WEIGHT_ARRAY_EXT)");
2417
2418 }
2419 }
2420
2421#if 0 /* FOG ----------------------------------------------*/
2422 if (sd->u.s.fog.lpData || sd->u.s.fog.VBO) {
2423 /* TODO: fog*/
2424 if (GL_SUPPORT(EXT_FOG_COORD) {
2425 glEnableClientState(GL_FOG_COORDINATE_EXT);
2426 (GL_EXTCALL)(FogCoordPointerEXT)(
2427 WINED3D_ATR_GLTYPE(sd->u.s.fog.dwType),
2428 sd->u.s.fog.dwStride,
Stefan Dösinger09ab8122007-01-06 18:19:55 +0100[diff] [blame]2429 sd->u.s.fog.lpData + stateblock->loadBaseVertexIndex * sd->u.s.fog.dwStride);
Stefan Dösingerd5f18e62007-01-06 18:11:21 +0100[diff] [blame]2430 } else {
2431 /* don't bother falling back to 'slow' as we don't support software FOG yet. */
2432 /* FIXME: fixme once */
2433 TRACE("Hardware support for FOG is not avaiable, FOG disabled.\n");
2434 }
2435 } else {
2436 if (GL_SUPPRT(EXT_FOR_COORD) {
2437 /* make sure fog is disabled */
2438 glDisableClientState(GL_FOG_COORDINATE_EXT);
2439 }
2440 }
2441#endif
2442
2443#if 0 /* tangents ----------------------------------------------*/
2444 if (sd->u.s.tangent.lpData || sd->u.s.tangent.VBO ||
2445 sd->u.s.binormal.lpData || sd->u.s.binormal.VBO) {
2446 /* TODO: tangents*/
2447 if (GL_SUPPORT(EXT_COORDINATE_FRAME) {
2448 if (sd->u.s.tangent.lpData || sd->u.s.tangent.VBO) {
2449 glEnable(GL_TANGENT_ARRAY_EXT);
2450 (GL_EXTCALL)(TangentPointerEXT)(
2451 WINED3D_ATR_GLTYPE(sd->u.s.tangent.dwType),
2452 sd->u.s.tangent.dwStride,
Stefan Dösinger09ab8122007-01-06 18:19:55 +0100[diff] [blame]2453 sd->u.s.tangent.lpData + stateblock->loadBaseVertexIndex * sd->u.s.tangent.dwStride);
Stefan Dösingerd5f18e62007-01-06 18:11:21 +0100[diff] [blame]2454 } else {
2455 glDisable(GL_TANGENT_ARRAY_EXT);
2456 }
2457 if (sd->u.s.binormal.lpData || sd->u.s.binormal.VBO) {
2458 glEnable(GL_BINORMAL_ARRAY_EXT);
2459 (GL_EXTCALL)(BinormalPointerEXT)(
2460 WINED3D_ATR_GLTYPE(sd->u.s.binormal.dwType),
2461 sd->u.s.binormal.dwStride,
Stefan Dösinger09ab8122007-01-06 18:19:55 +0100[diff] [blame]2462 sd->u.s.binormal.lpData + stateblock->loadBaseVertexIndex * sd->u.s.binormal.dwStride);
Stefan Dösingerd5f18e62007-01-06 18:11:21 +0100[diff] [blame]2463 } else{
2464 glDisable(GL_BINORMAL_ARRAY_EXT);
2465 }
2466
2467 } else {
2468 /* don't bother falling back to 'slow' as we don't support software tangents and binormals yet . */
2469 /* FIXME: fixme once */
2470 TRACE("Hardware support for tangents and binormals is not avaiable, tangents and binormals disabled.\n");
2471 }
2472 } else {
2473 if (GL_SUPPORT(EXT_COORDINATE_FRAME) {
2474 /* make sure fog is disabled */
2475 glDisable(GL_TANGENT_ARRAY_EXT);
2476 glDisable(GL_BINORMAL_ARRAY_EXT);
2477 }
2478 }
2479#endif
2480
2481 /* Point Size ----------------------------------------------*/
2482 if (sd->u.s.pSize.lpData || sd->u.s.pSize.VBO) {
2483
2484 /* no such functionality in the fixed function GL pipeline */
2485 TRACE("Cannot change ptSize here in openGl\n");
2486 /* TODO: Implement this function in using shaders if they are available */
2487
2488 }
2489
2490 /* Vertex Pointers -----------------------------------------*/
2491 if (sd->u.s.position.lpData != NULL || sd->u.s.position.VBO != 0) {
2492 /* Note dwType == float3 or float4 == 2 or 3 */
2493 VTRACE(("glVertexPointer(%d, GL_FLOAT, %d, %p)\n",
2494 sd->u.s.position.dwStride,
2495 sd->u.s.position.dwType + 1,
2496 sd->u.s.position.lpData));
2497
2498 if(curVBO != sd->u.s.position.VBO) {
2499 GL_EXTCALL(glBindBufferARB(GL_ARRAY_BUFFER_ARB, sd->u.s.position.VBO));
2500 checkGLcall("glBindBufferARB");
2501 curVBO = sd->u.s.position.VBO;
2502 }
2503
2504 /* min(WINED3D_ATR_SIZE(position),3) to Disable RHW mode as 'w' coord
2505 handling for rhw mode should not impact screen position whereas in GL it does.
2506 This may result in very slightly distored textures in rhw mode, but
2507 a very minimal different. There's always the other option of
2508 fixing the view matrix to prevent w from having any effect
2509
2510 This only applies to user pointer sources, in VBOs the vertices are fixed up
2511 */
2512 if(sd->u.s.position.VBO == 0) {
2513 glVertexPointer(3 /* min(WINED3D_ATR_SIZE(sd->u.s.position.dwType),3) */,
2514 WINED3D_ATR_GLTYPE(sd->u.s.position.dwType),
Stefan Dösinger354fdae2007-01-17 00:06:34 +0100[diff] [blame]2515 sd->u.s.position.dwStride, sd->u.s.position.lpData + stateblock->loadBaseVertexIndex * sd->u.s.position.dwStride + offset[sd->u.s.position.streamNo]);
Stefan Dösingerd5f18e62007-01-06 18:11:21 +0100[diff] [blame]2516 } else {
2517 glVertexPointer(
2518 WINED3D_ATR_SIZE(sd->u.s.position.dwType),
2519 WINED3D_ATR_GLTYPE(sd->u.s.position.dwType),
Stefan Dösinger354fdae2007-01-17 00:06:34 +0100[diff] [blame]2520 sd->u.s.position.dwStride, sd->u.s.position.lpData + stateblock->loadBaseVertexIndex * sd->u.s.position.dwStride + offset[sd->u.s.position.streamNo]);
Stefan Dösingerd5f18e62007-01-06 18:11:21 +0100[diff] [blame]2521 }
2522 checkGLcall("glVertexPointer(...)");
2523 glEnableClientState(GL_VERTEX_ARRAY);
2524 checkGLcall("glEnableClientState(GL_VERTEX_ARRAY)");
2525
2526 } else {
2527 glDisableClientState(GL_VERTEX_ARRAY);
2528 checkGLcall("glDisableClientState(GL_VERTEX_ARRAY)");
2529 }
2530
2531 /* Normals -------------------------------------------------*/
2532 if (sd->u.s.normal.lpData || sd->u.s.normal.VBO) {
2533 /* Note dwType == float3 or float4 == 2 or 3 */
2534 VTRACE(("glNormalPointer(GL_FLOAT, %d, %p)\n",
2535 sd->u.s.normal.dwStride,
2536 sd->u.s.normal.lpData));
2537 if(curVBO != sd->u.s.normal.VBO) {
2538 GL_EXTCALL(glBindBufferARB(GL_ARRAY_BUFFER_ARB, sd->u.s.normal.VBO));
2539 checkGLcall("glBindBufferARB");
2540 curVBO = sd->u.s.normal.VBO;
2541 }
2542 glNormalPointer(
2543 WINED3D_ATR_GLTYPE(sd->u.s.normal.dwType),
2544 sd->u.s.normal.dwStride,
Stefan Dösinger354fdae2007-01-17 00:06:34 +0100[diff] [blame]2545 sd->u.s.normal.lpData + stateblock->loadBaseVertexIndex * sd->u.s.normal.dwStride + offset[sd->u.s.normal.streamNo]);
Stefan Dösingerd5f18e62007-01-06 18:11:21 +0100[diff] [blame]2546 checkGLcall("glNormalPointer(...)");
2547 glEnableClientState(GL_NORMAL_ARRAY);
2548 checkGLcall("glEnableClientState(GL_NORMAL_ARRAY)");
2549
2550 } else {
2551 glDisableClientState(GL_NORMAL_ARRAY);
2552 checkGLcall("glDisableClientState(GL_NORMAL_ARRAY)");
2553 glNormal3f(0, 0, 1);
2554 checkGLcall("glNormal3f(0, 0, 1)");
2555 }
2556
2557 /* Diffuse Colour --------------------------------------------*/
2558 /* WARNING: Data here MUST be in RGBA format, so cannot */
2559 /* go directly into fast mode from app pgm, because */
2560 /* directx requires data in BGRA format. */
2561 /* currently fixupVertices swizels the format, but this isn't */
2562 /* very practical when using VBOS */
2563 /* NOTE: Unless we write a vertex shader to swizel the colour */
2564 /* , or the user doesn't care and wants the speed advantage */
2565
2566 if (sd->u.s.diffuse.lpData || sd->u.s.diffuse.VBO) {
2567 /* Note dwType == float3 or float4 == 2 or 3 */
2568 VTRACE(("glColorPointer(4, GL_UNSIGNED_BYTE, %d, %p)\n",
2569 sd->u.s.diffuse.dwStride,
2570 sd->u.s.diffuse.lpData));
2571
2572 if(curVBO != sd->u.s.diffuse.VBO) {
2573 GL_EXTCALL(glBindBufferARB(GL_ARRAY_BUFFER_ARB, sd->u.s.diffuse.VBO));
2574 checkGLcall("glBindBufferARB");
2575 curVBO = sd->u.s.diffuse.VBO;
2576 }
2577 glColorPointer(4, GL_UNSIGNED_BYTE,
2578 sd->u.s.diffuse.dwStride,
Stefan Dösinger354fdae2007-01-17 00:06:34 +0100[diff] [blame]2579 sd->u.s.diffuse.lpData + stateblock->loadBaseVertexIndex * sd->u.s.diffuse.dwStride + offset[sd->u.s.diffuse.streamNo]);
Stefan Dösingerd5f18e62007-01-06 18:11:21 +0100[diff] [blame]2580 checkGLcall("glColorPointer(4, GL_UNSIGNED_BYTE, ...)");
2581 glEnableClientState(GL_COLOR_ARRAY);
2582 checkGLcall("glEnableClientState(GL_COLOR_ARRAY)");
2583
2584 } else {
2585 glDisableClientState(GL_COLOR_ARRAY);
2586 checkGLcall("glDisableClientState(GL_COLOR_ARRAY)");
2587 glColor4f(1.0f, 1.0f, 1.0f, 1.0f);
2588 checkGLcall("glColor4f(1, 1, 1, 1)");
2589 }
2590
2591 /* Specular Colour ------------------------------------------*/
2592 if (sd->u.s.specular.lpData || sd->u.s.specular.VBO) {
2593 TRACE("setting specular colour\n");
2594 /* Note dwType == float3 or float4 == 2 or 3 */
2595 VTRACE(("glSecondaryColorPointer(4, GL_UNSIGNED_BYTE, %d, %p)\n",
2596 sd->u.s.specular.dwStride,
2597 sd->u.s.specular.lpData));
2598 if (GL_SUPPORT(EXT_SECONDARY_COLOR)) {
2599 if(curVBO != sd->u.s.specular.VBO) {
2600 GL_EXTCALL(glBindBufferARB(GL_ARRAY_BUFFER_ARB, sd->u.s.specular.VBO));
2601 checkGLcall("glBindBufferARB");
2602 curVBO = sd->u.s.specular.VBO;
2603 }
2604 GL_EXTCALL(glSecondaryColorPointerEXT)(4, GL_UNSIGNED_BYTE,
2605 sd->u.s.specular.dwStride,
Stefan Dösinger354fdae2007-01-17 00:06:34 +0100[diff] [blame]2606 sd->u.s.specular.lpData + stateblock->loadBaseVertexIndex * sd->u.s.specular.dwStride + offset[sd->u.s.specular.streamNo]);
Stefan Dösingerd5f18e62007-01-06 18:11:21 +0100[diff] [blame]2607 vcheckGLcall("glSecondaryColorPointerEXT(4, GL_UNSIGNED_BYTE, ...)");
2608 glEnableClientState(GL_SECONDARY_COLOR_ARRAY_EXT);
2609 vcheckGLcall("glEnableClientState(GL_SECONDARY_COLOR_ARRAY_EXT)");
2610 } else {
2611
2612 /* Missing specular color is not critical, no warnings */
2613 VTRACE(("Specular colour is not supported in this GL implementation\n"));
2614 }
2615
2616 } else {
2617 if (GL_SUPPORT(EXT_SECONDARY_COLOR)) {
2618
2619 glDisableClientState(GL_SECONDARY_COLOR_ARRAY_EXT);
2620 checkGLcall("glDisableClientState(GL_SECONDARY_COLOR_ARRAY_EXT)");
2621 GL_EXTCALL(glSecondaryColor3fEXT)(0, 0, 0);
2622 checkGLcall("glSecondaryColor3fEXT(0, 0, 0)");
2623 } else {
2624
2625 /* Missing specular color is not critical, no warnings */
2626 VTRACE(("Specular colour is not supported in this GL implementation\n"));
2627 }
2628 }
2629
2630 /* Texture coords -------------------------------------------*/
2631
2632 for (textureNo = 0, texture_idx = 0; textureNo < GL_LIMITS(texture_stages); ++textureNo) {
2633 /* The code below uses glClientActiveTexture and glMultiTexCoord* which are all part of the GL_ARB_multitexture extension. */
2634 /* Abort if we don't support the extension. */
2635 if (!GL_SUPPORT(ARB_MULTITEXTURE)) {
2636 FIXME("Program using multiple concurrent textures which this opengl implementation doesn't support\n");
2637 continue;
2638 }
2639
2640 if (/*!GL_SUPPORT(NV_REGISTER_COMBINERS) || stateblock->textures[textureNo]*/ TRUE) {
2641 /* Select the correct texture stage */
2642 GL_EXTCALL(glClientActiveTextureARB(GL_TEXTURE0_ARB + texture_idx));
2643 }
2644
2645 if (stateblock->textures[textureNo] != NULL) {
2646 int coordIdx = stateblock->textureState[textureNo][WINED3DTSS_TEXCOORDINDEX];
2647
2648 if (coordIdx >= MAX_TEXTURES) {
2649 VTRACE(("tex: %d - Skip tex coords, as being system generated\n", textureNo));
2650 glDisableClientState(GL_TEXTURE_COORD_ARRAY);
2651 GL_EXTCALL(glMultiTexCoord4fARB(GL_TEXTURE0_ARB + texture_idx, 0, 0, 0, 1));
2652
2653 } else if (sd->u.s.texCoords[coordIdx].lpData == NULL && sd->u.s.texCoords[coordIdx].VBO == 0) {
2654 VTRACE(("Bound texture but no texture coordinates supplied, so skipping\n"));
2655 glDisableClientState(GL_TEXTURE_COORD_ARRAY);
2656 GL_EXTCALL(glMultiTexCoord4fARB(GL_TEXTURE0_ARB + texture_idx, 0, 0, 0, 1));
2657
2658 } else {
2659 TRACE("Setting up texture %u, idx %d, cordindx %u, data %p\n",
2660 textureNo, texture_idx, coordIdx, sd->u.s.texCoords[coordIdx].lpData);
2661 if(curVBO != sd->u.s.texCoords[coordIdx].VBO) {
2662 GL_EXTCALL(glBindBufferARB(GL_ARRAY_BUFFER_ARB, sd->u.s.texCoords[coordIdx].VBO));
2663 checkGLcall("glBindBufferARB");
2664 curVBO = sd->u.s.texCoords[coordIdx].VBO;
2665 }
2666 /* The coords to supply depend completely on the fvf / vertex shader */
2667 glTexCoordPointer(
2668 WINED3D_ATR_SIZE(sd->u.s.texCoords[coordIdx].dwType),
2669 WINED3D_ATR_GLTYPE(sd->u.s.texCoords[coordIdx].dwType),
2670 sd->u.s.texCoords[coordIdx].dwStride,
Stefan Dösinger354fdae2007-01-17 00:06:34 +0100[diff] [blame]2671 sd->u.s.texCoords[coordIdx].lpData + stateblock->loadBaseVertexIndex * sd->u.s.texCoords[coordIdx].dwStride + offset[sd->u.s.texCoords[coordIdx].streamNo]);
Stefan Dösingerd5f18e62007-01-06 18:11:21 +0100[diff] [blame]2672 glEnableClientState(GL_TEXTURE_COORD_ARRAY);
2673 }
2674 } else if (!GL_SUPPORT(NV_REGISTER_COMBINERS)) {
2675 glDisableClientState(GL_TEXTURE_COORD_ARRAY);
2676 GL_EXTCALL(glMultiTexCoord4fARB(GL_TEXTURE0_ARB + textureNo, 0, 0, 0, 1));
2677 }
2678 if (/*!GL_SUPPORT(NV_REGISTER_COMBINERS) || stateblock->textures[textureNo]*/ TRUE) ++texture_idx;
2679 }
2680 if (GL_SUPPORT(NV_REGISTER_COMBINERS)) {
2681 for (textureNo = texture_idx; textureNo < GL_LIMITS(textures); ++textureNo) {
2682 GL_EXTCALL(glClientActiveTextureARB(GL_TEXTURE0_ARB + textureNo));
2683 glDisableClientState(GL_TEXTURE_COORD_ARRAY);
2684 GL_EXTCALL(glMultiTexCoord4fARB(GL_TEXTURE0_ARB + textureNo, 0, 0, 0, 1));
2685 }
2686 }
2687}
2688
Stefan Dösinger27bac242007-01-06 18:12:21 +0100[diff] [blame]2689inline void drawPrimitiveTraceDataLocations(
2690 WineDirect3DVertexStridedData *dataLocations) {
2691
2692 /* Dump out what parts we have supplied */
2693 TRACE("Strided Data:\n");
2694 TRACE_STRIDED((dataLocations), position);
2695 TRACE_STRIDED((dataLocations), blendWeights);
2696 TRACE_STRIDED((dataLocations), blendMatrixIndices);
2697 TRACE_STRIDED((dataLocations), normal);
2698 TRACE_STRIDED((dataLocations), pSize);
2699 TRACE_STRIDED((dataLocations), diffuse);
2700 TRACE_STRIDED((dataLocations), specular);
2701 TRACE_STRIDED((dataLocations), texCoords[0]);
2702 TRACE_STRIDED((dataLocations), texCoords[1]);
2703 TRACE_STRIDED((dataLocations), texCoords[2]);
2704 TRACE_STRIDED((dataLocations), texCoords[3]);
2705 TRACE_STRIDED((dataLocations), texCoords[4]);
2706 TRACE_STRIDED((dataLocations), texCoords[5]);
2707 TRACE_STRIDED((dataLocations), texCoords[6]);
2708 TRACE_STRIDED((dataLocations), texCoords[7]);
2709 TRACE_STRIDED((dataLocations), position2);
2710 TRACE_STRIDED((dataLocations), normal2);
2711 TRACE_STRIDED((dataLocations), tangent);
2712 TRACE_STRIDED((dataLocations), binormal);
2713 TRACE_STRIDED((dataLocations), tessFactor);
2714 TRACE_STRIDED((dataLocations), fog);
2715 TRACE_STRIDED((dataLocations), depth);
2716 TRACE_STRIDED((dataLocations), sample);
2717
2718 return;
2719}
2720
Stefan Dösinger51a98102007-01-04 00:13:15 +0100[diff] [blame]2721/* Helper for vertexdeclaration() */
Stefan Dösingere6c9a072007-02-12 19:18:27 +0100[diff] [blame]2722static inline void handleStreams(IWineD3DStateBlockImpl *stateblock, BOOL useVertexShaderFunction, WineD3DContext *context) {
Stefan Dösinger20de2002007-01-02 22:47:10 +0100[diff] [blame]2723 IWineD3DDeviceImpl *device = stateblock->wineD3DDevice;
Stefan Dösingerd5f18e62007-01-06 18:11:21 +0100[diff] [blame]2724 BOOL fixup = FALSE;
2725 WineDirect3DVertexStridedData *dataLocations = &device->strided_streams;
Stefan Dösinger20de2002007-01-02 22:47:10 +0100[diff] [blame]2726
2727 if(device->up_strided) {
Stefan Dösinger438c1722007-01-02 21:31:08 +0100[diff] [blame]2728 /* Note: this is a ddraw fixed-function code path */
2729 TRACE("================ Strided Input ===================\n");
Stefan Dösingerd5f18e62007-01-06 18:11:21 +0100[diff] [blame]2730 memcpy(dataLocations, device->up_strided, sizeof(*dataLocations));
Stefan Dösinger27bac242007-01-06 18:12:21 +0100[diff] [blame]2731
2732 if(TRACE_ON(d3d)) {
2733 drawPrimitiveTraceDataLocations(dataLocations);
2734 }
Stefan Dösinger51a98102007-01-04 00:13:15 +0100[diff] [blame]2735 } else if (stateblock->vertexDecl || stateblock->vertexShader) {
Stefan Dösinger438c1722007-01-02 21:31:08 +0100[diff] [blame]2736 /* Note: This is a fixed function or shader codepath.
2737 * This means it must handle both types of strided data.
2738 * Shaders must go through here to zero the strided data, even if they
2739 * don't set any declaration at all
2740 */
2741 TRACE("================ Vertex Declaration ===================\n");
Stefan Dösingerd5f18e62007-01-06 18:11:21 +0100[diff] [blame]2742 memset(dataLocations, 0, sizeof(*dataLocations));
Stefan Dösinger20de2002007-01-02 22:47:10 +0100[diff] [blame]2743
H. Verbeet32e5cac2007-02-13 23:12:29 +0100[diff] [blame]2744 if (stateblock->vertexDecl) {
Stefan Dösinger20de2002007-01-02 22:47:10 +0100[diff] [blame]2745 primitiveDeclarationConvertToStridedData((IWineD3DDevice *) device, useVertexShaderFunction,
Stefan Dösingerd5f18e62007-01-06 18:11:21 +0100[diff] [blame]2746 dataLocations, &fixup);
Stefan Dösinger438c1722007-01-02 21:31:08 +0100[diff] [blame]2747 }
2748 } else {
2749 /* Note: This codepath is not reachable from d3d9 (see fvf->decl9 conversion)
2750 * It is reachable through d3d8, but only for fixed-function.
2751 * It will not work properly for shaders.
2752 */
2753 TRACE("================ FVF ===================\n");
Stefan Dösingerd5f18e62007-01-06 18:11:21 +0100[diff] [blame]2754 memset(dataLocations, 0, sizeof(*dataLocations));
Stefan Dösingerfe6165d2007-01-10 11:37:03 +0100[diff] [blame]2755 primitiveConvertToStridedData((IWineD3DDevice *) device, dataLocations, &fixup);
Stefan Dösinger27bac242007-01-06 18:12:21 +0100[diff] [blame]2756 if(TRACE_ON(d3d)) {
2757 drawPrimitiveTraceDataLocations(dataLocations);
2758 }
Stefan Dösinger438c1722007-01-02 21:31:08 +0100[diff] [blame]2759 }
Stefan Dösingerd5f18e62007-01-06 18:11:21 +0100[diff] [blame]2760
2761 /* Unload the old arrays before loading the new ones to get old junk out */
Stefan Dösingere6c9a072007-02-12 19:18:27 +0100[diff] [blame]2762 if(context->numberedArraysLoaded) {
Stefan Dösingerd5f18e62007-01-06 18:11:21 +0100[diff] [blame]2763 unloadNumberedArrays(stateblock);
Stefan Dösingere6c9a072007-02-12 19:18:27 +0100[diff] [blame]2764 context->numberedArraysLoaded = FALSE;
Stefan Dösingerd5f18e62007-01-06 18:11:21 +0100[diff] [blame]2765 }
Stefan Dösingere6c9a072007-02-12 19:18:27 +0100[diff] [blame]2766 if(context->namedArraysLoaded) {
Stefan Dösingerd5f18e62007-01-06 18:11:21 +0100[diff] [blame]2767 unloadVertexData(stateblock);
Stefan Dösingere6c9a072007-02-12 19:18:27 +0100[diff] [blame]2768 context->namedArraysLoaded = FALSE;
Stefan Dösingerd5f18e62007-01-06 18:11:21 +0100[diff] [blame]2769 }
2770
2771 if(useVertexShaderFunction) {
2772 TRACE("Loading numbered arrays\n");
2773 loadNumberedArrays(stateblock, dataLocations);
2774 device->useDrawStridedSlow = FALSE;
Stefan Dösingere6c9a072007-02-12 19:18:27 +0100[diff] [blame]2775 context->numberedArraysLoaded = TRUE;
Stefan Dösingerd5f18e62007-01-06 18:11:21 +0100[diff] [blame]2776 } else if (fixup ||
2777 (dataLocations->u.s.pSize.lpData == NULL &&
2778 dataLocations->u.s.diffuse.lpData == NULL &&
2779 dataLocations->u.s.specular.lpData == NULL)) {
2780 /* Load the vertex data using named arrays */
2781 TRACE("Loading vertex data\n");
2782 loadVertexData(stateblock, dataLocations);
2783 device->useDrawStridedSlow = FALSE;
Stefan Dösingere6c9a072007-02-12 19:18:27 +0100[diff] [blame]2784 context->namedArraysLoaded = TRUE;
Stefan Dösingerd5f18e62007-01-06 18:11:21 +0100[diff] [blame]2785 } else {
2786 TRACE("Not loading vertex data\n");
2787 device->useDrawStridedSlow = TRUE;
2788 }
Stefan Dösinger7e314012007-01-06 18:13:21 +0100[diff] [blame]2789
2790/* Generate some fixme's if unsupported functionality is being used */
2791#define BUFFER_OR_DATA(_attribute) dataLocations->u.s._attribute.lpData
2792 /* TODO: Either support missing functionality in fixupVertices or by creating a shader to replace the pipeline. */
Stefan Dösinger762e2272007-02-16 19:15:15 +0100[diff] [blame]2793 if (!useVertexShaderFunction &&
2794 stateblock->renderState[WINED3DRS_VERTEXBLEND] &&
2795 (BUFFER_OR_DATA(blendMatrixIndices) || BUFFER_OR_DATA(blendWeights))) {
2796 FIXME("Vertex Blending is not implemented yet %p %p\n",dataLocations->u.s.blendWeights.lpData,dataLocations->u.s.blendWeights.lpData);
2797 /* TODO: Implement it using GL_ARB_vertex_blend or software emulation in drawStridedSlow */
Stefan Dösinger7e314012007-01-06 18:13:21 +0100[diff] [blame]2798 }
2799 if (!useVertexShaderFunction && (BUFFER_OR_DATA(position2) || BUFFER_OR_DATA(normal2))) {
2800 FIXME("Tweening is only valid with vertex shaders\n");
2801 }
2802 if (!useVertexShaderFunction && (BUFFER_OR_DATA(tangent) || BUFFER_OR_DATA(binormal))) {
2803 FIXME("Tangent and binormal bump mapping is only valid with vertex shaders\n");
2804 }
2805 if (!useVertexShaderFunction && (BUFFER_OR_DATA(tessFactor) || BUFFER_OR_DATA(fog) || BUFFER_OR_DATA(depth) || BUFFER_OR_DATA(sample))) {
2806 FIXME("Extended attributes are only valid with vertex shaders\n");
2807 }
2808#undef BUFFER_OR_DATA
Stefan Dösinger51a98102007-01-04 00:13:15 +0100[diff] [blame]2809}
2810
Stefan Dösingerc739c382007-02-12 19:18:22 +0100[diff] [blame]2811static void vertexdeclaration(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
Stefan Dösinger51a98102007-01-04 00:13:15 +0100[diff] [blame]2812 BOOL useVertexShaderFunction = FALSE, updateFog = FALSE;
H. Verbeet1636bc12007-02-13 19:53:11 +0100[diff] [blame]2813 BOOL usePixelShaderFunction = stateblock->wineD3DDevice->ps_selected_mode != SHADER_NONE && stateblock->pixelShader
2814 && ((IWineD3DPixelShaderImpl *)stateblock->pixelShader)->baseShader.function;
Stefan Dösinger51a98102007-01-04 00:13:15 +0100[diff] [blame]2815 BOOL transformed;
2816 /* Some stuff is in the device until we have per context tracking */
2817 IWineD3DDeviceImpl *device = stateblock->wineD3DDevice;
Stefan Dösingere6c9a072007-02-12 19:18:27 +0100[diff] [blame]2818 BOOL wasrhw = context->last_was_rhw;
Stefan Dösinger51a98102007-01-04 00:13:15 +0100[diff] [blame]2819
Stefan Dösinger51a98102007-01-04 00:13:15 +0100[diff] [blame]2820 /* Shaders can be implemented using ARB_PROGRAM, GLSL, or software -
2821 * here simply check whether a shader was set, or the user disabled shaders
2822 */
2823 if (device->vs_selected_mode != SHADER_NONE && stateblock->vertexShader &&
2824 ((IWineD3DVertexShaderImpl *)stateblock->vertexShader)->baseShader.function != NULL) {
2825 useVertexShaderFunction = TRUE;
2826
Stefan Dösingere6c9a072007-02-12 19:18:27 +0100[diff] [blame]2827 if(((IWineD3DVertexShaderImpl *)stateblock->vertexShader)->usesFog != context->last_was_foggy_shader) {
Stefan Dösinger51a98102007-01-04 00:13:15 +0100[diff] [blame]2828 updateFog = TRUE;
2829 }
Stefan Dösingere6c9a072007-02-12 19:18:27 +0100[diff] [blame]2830 } else if(context->last_was_foggy_shader) {
Stefan Dösinger51a98102007-01-04 00:13:15 +0100[diff] [blame]2831 updateFog = TRUE;
2832 }
2833
Stefan Dösingere6c9a072007-02-12 19:18:27 +0100[diff] [blame]2834 handleStreams(stateblock, useVertexShaderFunction, context);
Stefan Dösinger51a98102007-01-04 00:13:15 +0100[diff] [blame]2835
Francois Gougetb0bde6b2007-01-18 11:35:50 +0100[diff] [blame]2836 /* Do I have to use ? TRUE : FALSE ? Or can I rely on 15==15 being equal to TRUE(=1)? */
Stefan Dösinger20de2002007-01-02 22:47:10 +0100[diff] [blame]2837 transformed = ((device->strided_streams.u.s.position.lpData != NULL ||
2838 device->strided_streams.u.s.position.VBO != 0) &&
2839 device->strided_streams.u.s.position_transformed) ? TRUE : FALSE;
Stefan Dösinger20de2002007-01-02 22:47:10 +0100[diff] [blame]2840
Stefan Dösingere6c9a072007-02-12 19:18:27 +0100[diff] [blame]2841 if(transformed != context->last_was_rhw && !useVertexShaderFunction) {
Stefan Dösinger20de2002007-01-02 22:47:10 +0100[diff] [blame]2842 updateFog = TRUE;
2843 }
2844
Francois Gouget93494f22007-02-20 15:57:10 +0100[diff] [blame]2845 /* Reapply lighting if it is not scheduled for reapplication already */
Stefan Dösinger380930d2007-02-12 19:18:31 +0100[diff] [blame]2846 if(!isStateDirty(context, STATE_RENDER(WINED3DRS_LIGHTING))) {
Stefan Dösingerc739c382007-02-12 19:18:22 +0100[diff] [blame]2847 state_lighting(STATE_RENDER(WINED3DRS_LIGHTING), stateblock, context);
Stefan Dösinger20de2002007-01-02 22:47:10 +0100[diff] [blame]2848 }
2849
2850 if (!useVertexShaderFunction && transformed) {
Stefan Dösingere6c9a072007-02-12 19:18:27 +0100[diff] [blame]2851 context->last_was_rhw = TRUE;
Stefan Dösinger20de2002007-01-02 22:47:10 +0100[diff] [blame]2852 } else {
2853
2854 /* Untransformed, so relies on the view and projection matrices */
Stefan Dösingere6c9a072007-02-12 19:18:27 +0100[diff] [blame]2855 context->last_was_rhw = FALSE;
Stefan Dösinger5fa0f7f2007-01-02 22:47:39 +0100[diff] [blame]2856 /* This turns off the Z scale trick to 'disable' viewport frustum clipping in rhw mode*/
Stefan Dösinger20de2002007-01-02 22:47:10 +0100[diff] [blame]2857 device->untransformed = TRUE;
2858
Stefan Dösingere26e3ee2007-01-02 22:52:11 +0100[diff] [blame]2859 /* Todo for sw shaders: Vertex Shader output is already transformed, so set up identity matrices
2860 * Not needed as long as only hw shaders are supported
Stefan Dösinger5fa0f7f2007-01-02 22:47:39 +0100[diff] [blame]2861 */
Stefan Dösinger20de2002007-01-02 22:47:10 +0100[diff] [blame]2862
Stefan Dösingere26e3ee2007-01-02 22:52:11 +0100[diff] [blame]2863 /* This sets the shader output position correction constants.
2864 * TODO: Move to the viewport state
2865 */
Stefan Dösinger20de2002007-01-02 22:47:10 +0100[diff] [blame]2866 if (useVertexShaderFunction) {
2867 device->posFixup[1] = device->render_offscreen ? -1.0 : 1.0;
Stefan Dösinger20de2002007-01-02 22:47:10 +0100[diff] [blame]2868 }
Stefan Dösinger20de2002007-01-02 22:47:10 +0100[diff] [blame]2869 }
2870
Stefan Dösingere26e3ee2007-01-02 22:52:11 +0100[diff] [blame]2871 /* Don't have to apply the matrices when vertex shaders are used. When vshaders are turned
2872 * off this function will be called again anyway to make sure they're properly set
Stefan Dösinger82bd0792007-01-02 22:50:38 +0100[diff] [blame]2873 */
Stefan Dösingere26e3ee2007-01-02 22:52:11 +0100[diff] [blame]2874 if(!useVertexShaderFunction) {
2875 /* TODO: Move this mainly to the viewport state and only apply when the vp has changed
2876 * or transformed / untransformed was switched
2877 */
Stefan Dösingere6c9a072007-02-12 19:18:27 +0100[diff] [blame]2878 if(wasrhw != context->last_was_rhw &&
Stefan Dösinger380930d2007-02-12 19:18:31 +0100[diff] [blame]2879 !isStateDirty(context, STATE_TRANSFORM(WINED3DTS_PROJECTION)) &&
2880 !isStateDirty(context, STATE_VIEWPORT)) {
Stefan Dösingerc739c382007-02-12 19:18:22 +0100[diff] [blame]2881 transform_projection(STATE_TRANSFORM(WINED3DTS_PROJECTION), stateblock, context);
Stefan Dösingere26e3ee2007-01-02 22:52:11 +0100[diff] [blame]2882 }
2883 /* World matrix needs reapplication here only if we're switching between rhw and non-rhw
2884 * mode.
2885 *
2886 * If a vertex shader is used, the world matrix changed and then vertex shader unbound
2887 * this check will fail and the matrix not applied again. This is OK because a simple
2888 * world matrix change reapplies the matrix - These checks here are only to satisfy the
2889 * needs of the vertex declaration.
2890 *
2891 * World and view matrix go into the same gl matrix, so only apply them when neither is
2892 * dirty
2893 */
2894 if(transformed != wasrhw &&
Stefan Dösinger380930d2007-02-12 19:18:31 +0100[diff] [blame]2895 !isStateDirty(context, STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(0))) &&
2896 !isStateDirty(context, STATE_TRANSFORM(WINED3DTS_VIEW))) {
Stefan Dösingerc739c382007-02-12 19:18:22 +0100[diff] [blame]2897 transform_world(STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(0)), stateblock, context);
Stefan Dösingere26e3ee2007-01-02 22:52:11 +0100[diff] [blame]2898 }
Stefan Dösinger9b492092007-01-10 11:26:12 +0100[diff] [blame]2899
Stefan Dösinger380930d2007-02-12 19:18:31 +0100[diff] [blame]2900 if(!isStateDirty(context, STATE_RENDER(WINED3DRS_COLORVERTEX))) {
Stefan Dösingerc739c382007-02-12 19:18:22 +0100[diff] [blame]2901 state_colormat(STATE_RENDER(WINED3DRS_COLORVERTEX), stateblock, context);
Stefan Dösinger9b492092007-01-10 11:26:12 +0100[diff] [blame]2902 }
Stefan Dösingerd5f18e62007-01-06 18:11:21 +0100[diff] [blame]2903 } else {
2904 /* We compile the shader here because we need the vertex declaration
2905 * in order to determine if we need to do any swizzling for D3DCOLOR
2906 * registers. If the shader is already compiled this call will do nothing. */
2907 IWineD3DVertexShader_CompileShader(stateblock->vertexShader);
Stefan Dösinger8e37fcd2007-01-06 18:17:27 +0100[diff] [blame]2908 }
Stefan Dösinger799770b2007-01-06 18:14:12 +0100[diff] [blame]2909
H. Verbeet1636bc12007-02-13 19:53:11 +0100[diff] [blame]2910 /* Vertex and pixel shaders are applied together for now, so let the last dirty state do the
2911 * application
2912 */
2913 if (!isStateDirty(context, STATE_PIXELSHADER)) {
2914 device->shader_backend->shader_select((IWineD3DDevice *)device, usePixelShaderFunction, useVertexShaderFunction);
Stefan Dösinger799770b2007-01-06 18:14:12 +0100[diff] [blame]2915
H. Verbeet1636bc12007-02-13 19:53:11 +0100[diff] [blame]2916 if (!isStateDirty(context, STATE_VERTEXSHADERCONSTANT) && (useVertexShaderFunction || usePixelShaderFunction)) {
2917 shaderconstant(STATE_VERTEXSHADERCONSTANT, stateblock, context);
Stefan Dösinger799770b2007-01-06 18:14:12 +0100[diff] [blame]2918 }
Stefan Dösingerd5f18e62007-01-06 18:11:21 +0100[diff] [blame]2919 }
Stefan Dösinger82bd0792007-01-02 22:50:38 +0100[diff] [blame]2920
H. Verbeet1636bc12007-02-13 19:53:11 +0100[diff] [blame]2921 context->last_was_vshader = useVertexShaderFunction;
2922
Stefan Dösinger20de2002007-01-02 22:47:10 +0100[diff] [blame]2923 if(updateFog) {
Stefan Dösingerc739c382007-02-12 19:18:22 +0100[diff] [blame]2924 state_fog(STATE_RENDER(WINED3DRS_FOGENABLE), stateblock, context);
Stefan Dösinger20de2002007-01-02 22:47:10 +0100[diff] [blame]2925 }
Stefan Dösingeref1ebb62007-01-02 00:35:07 +0100[diff] [blame]2926}
2927
Stefan Dösingerc739c382007-02-12 19:18:22 +0100[diff] [blame]2928static void viewport(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
Stefan Dösinger0d700be2007-01-04 00:05:05 +0100[diff] [blame]2929 glDepthRange(stateblock->viewport.MinZ, stateblock->viewport.MaxZ);
2930 checkGLcall("glDepthRange");
2931 /* Note: GL requires lower left, DirectX supplies upper left */
2932 /* TODO: replace usage of renderTarget with context management */
2933 glViewport(stateblock->viewport.X,
2934 (((IWineD3DSurfaceImpl *)stateblock->wineD3DDevice->render_targets[0])->currentDesc.Height - (stateblock->viewport.Y + stateblock->viewport.Height)),
2935 stateblock->viewport.Width, stateblock->viewport.Height);
2936
2937 checkGLcall("glViewport");
2938
2939 stateblock->wineD3DDevice->posFixup[2] = 0.9 / stateblock->viewport.Width;
2940 stateblock->wineD3DDevice->posFixup[3] = -0.9 / stateblock->viewport.Height;
H. Verbeeta2fde7d2007-02-15 13:32:13 +0100[diff] [blame]2941 if(!isStateDirty(context, STATE_TRANSFORM(WINED3DTS_PROJECTION))) {
2942 transform_projection(STATE_TRANSFORM(WINED3DTS_PROJECTION), stateblock, context);
Stefan Dösinger0d700be2007-01-04 00:05:05 +0100[diff] [blame]2943 }
2944
2945}
2946
Stefan Dösinger174b6322007-02-14 17:48:52 +0100[diff] [blame]2947static void light(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
2948 UINT Index = state - STATE_ACTIVELIGHT(0);
2949 PLIGHTINFOEL *lightInfo = stateblock->activeLights[Index];
2950
2951 if(!lightInfo) {
2952 glDisable(GL_LIGHT0 + Index);
2953 checkGLcall("glDisable(GL_LIGHT0 + Index)");
2954 } else {
2955 float quad_att;
2956 float colRGBA[] = {0.0, 0.0, 0.0, 0.0};
2957
2958 /* Light settings are affected by the model view in OpenGL, the View transform in direct3d*/
2959 glMatrixMode(GL_MODELVIEW);
2960 glPushMatrix();
2961 glLoadMatrixf((float *)&stateblock->transforms[WINED3DTS_VIEW].u.m[0][0]);
2962
2963 /* Diffuse: */
2964 colRGBA[0] = lightInfo->OriginalParms.Diffuse.r;
2965 colRGBA[1] = lightInfo->OriginalParms.Diffuse.g;
2966 colRGBA[2] = lightInfo->OriginalParms.Diffuse.b;
2967 colRGBA[3] = lightInfo->OriginalParms.Diffuse.a;
2968 glLightfv(GL_LIGHT0 + Index, GL_DIFFUSE, colRGBA);
2969 checkGLcall("glLightfv");
2970
2971 /* Specular */
2972 colRGBA[0] = lightInfo->OriginalParms.Specular.r;
2973 colRGBA[1] = lightInfo->OriginalParms.Specular.g;
2974 colRGBA[2] = lightInfo->OriginalParms.Specular.b;
2975 colRGBA[3] = lightInfo->OriginalParms.Specular.a;
2976 glLightfv(GL_LIGHT0 + Index, GL_SPECULAR, colRGBA);
2977 checkGLcall("glLightfv");
2978
2979 /* Ambient */
2980 colRGBA[0] = lightInfo->OriginalParms.Ambient.r;
2981 colRGBA[1] = lightInfo->OriginalParms.Ambient.g;
2982 colRGBA[2] = lightInfo->OriginalParms.Ambient.b;
2983 colRGBA[3] = lightInfo->OriginalParms.Ambient.a;
2984 glLightfv(GL_LIGHT0 + Index, GL_AMBIENT, colRGBA);
2985 checkGLcall("glLightfv");
2986
Stefan Dösinger174b6322007-02-14 17:48:52 +0100[diff] [blame]2987 if ((lightInfo->OriginalParms.Range *lightInfo->OriginalParms.Range) >= FLT_MIN) {
2988 quad_att = 1.4/(lightInfo->OriginalParms.Range *lightInfo->OriginalParms.Range);
2989 } else {
2990 quad_att = 0; /* 0 or MAX? (0 seems to be ok) */
2991 }
2992
Stefan Dösinger76b7cac2007-02-20 22:43:13 +0100[diff] [blame]2993 /* Do not assign attenuation values for lights that do not use them. D3D apps are free to pass any junk,
2994 * but gl drivers use them and may crash due to bad Attenuation values. Need for Speed most wanted sets
2995 * Attenuation0 to NaN and crashes in the gl lib
2996 */
Stefan Dösinger174b6322007-02-14 17:48:52 +0100[diff] [blame]2997
2998 switch (lightInfo->OriginalParms.Type) {
2999 case WINED3DLIGHT_POINT:
3000 /* Position */
3001 glLightfv(GL_LIGHT0 + Index, GL_POSITION, &lightInfo->lightPosn[0]);
3002 checkGLcall("glLightfv");
3003 glLightf(GL_LIGHT0 + Index, GL_SPOT_CUTOFF, lightInfo->cutoff);
3004 checkGLcall("glLightf");
Stefan Dösinger76b7cac2007-02-20 22:43:13 +0100[diff] [blame]3005 /* Attenuation - Are these right? guessing... */
3006 glLightf(GL_LIGHT0 + Index, GL_CONSTANT_ATTENUATION, lightInfo->OriginalParms.Attenuation0);
3007 checkGLcall("glLightf");
3008 glLightf(GL_LIGHT0 + Index, GL_LINEAR_ATTENUATION, lightInfo->OriginalParms.Attenuation1);
3009 checkGLcall("glLightf");
3010 if (quad_att < lightInfo->OriginalParms.Attenuation2) quad_att = lightInfo->OriginalParms.Attenuation2;
3011 glLightf(GL_LIGHT0 + Index, GL_QUADRATIC_ATTENUATION, quad_att);
3012 checkGLcall("glLightf");
Stefan Dösinger174b6322007-02-14 17:48:52 +0100[diff] [blame]3013 /* FIXME: Range */
3014 break;
3015
3016 case WINED3DLIGHT_SPOT:
3017 /* Position */
3018 glLightfv(GL_LIGHT0 + Index, GL_POSITION, &lightInfo->lightPosn[0]);
3019 checkGLcall("glLightfv");
3020 /* Direction */
3021 glLightfv(GL_LIGHT0 + Index, GL_SPOT_DIRECTION, &lightInfo->lightDirn[0]);
3022 checkGLcall("glLightfv");
3023 glLightf(GL_LIGHT0 + Index, GL_SPOT_EXPONENT, lightInfo->exponent);
3024 checkGLcall("glLightf");
3025 glLightf(GL_LIGHT0 + Index, GL_SPOT_CUTOFF, lightInfo->cutoff);
3026 checkGLcall("glLightf");
Stefan Dösinger76b7cac2007-02-20 22:43:13 +0100[diff] [blame]3027 /* Attenuation - Are these right? guessing... */
3028 glLightf(GL_LIGHT0 + Index, GL_CONSTANT_ATTENUATION, lightInfo->OriginalParms.Attenuation0);
3029 checkGLcall("glLightf");
3030 glLightf(GL_LIGHT0 + Index, GL_LINEAR_ATTENUATION, lightInfo->OriginalParms.Attenuation1);
3031 checkGLcall("glLightf");
3032 if (quad_att < lightInfo->OriginalParms.Attenuation2) quad_att = lightInfo->OriginalParms.Attenuation2;
3033 glLightf(GL_LIGHT0 + Index, GL_QUADRATIC_ATTENUATION, quad_att);
3034 checkGLcall("glLightf");
Stefan Dösinger174b6322007-02-14 17:48:52 +0100[diff] [blame]3035 /* FIXME: Range */
3036 break;
3037
3038 case WINED3DLIGHT_DIRECTIONAL:
3039 /* Direction */
3040 glLightfv(GL_LIGHT0 + Index, GL_POSITION, &lightInfo->lightPosn[0]); /* Note gl uses w position of 0 for direction! */
3041 checkGLcall("glLightfv");
3042 glLightf(GL_LIGHT0 + Index, GL_SPOT_CUTOFF, lightInfo->cutoff);
3043 checkGLcall("glLightf");
3044 glLightf(GL_LIGHT0 + Index, GL_SPOT_EXPONENT, 0.0f);
3045 checkGLcall("glLightf");
3046 break;
3047
3048 default:
3049 FIXME("Unrecognized light type %d\n", lightInfo->OriginalParms.Type);
3050 }
3051
3052 /* Restore the modelview matrix */
3053 glPopMatrix();
3054
3055 glEnable(GL_LIGHT0 + Index);
3056 checkGLcall("glEnable(GL_LIGHT0 + Index)");
3057 }
3058
3059 return;
3060}
3061
Stefan Dösingerecfd4cb2007-02-19 15:25:16 +0100[diff] [blame]3062static void scissorrect(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
3063 IWineD3DSwapChainImpl *swapchain = (IWineD3DSwapChainImpl *) stateblock->wineD3DDevice->swapchains[0];
3064 RECT *pRect = &stateblock->scissorRect;
3065 RECT windowRect;
3066 UINT winHeight;
3067
3068 GetClientRect(swapchain->win_handle, &windowRect);
3069 /* Warning: glScissor uses window coordinates, not viewport coordinates, so our viewport correction does not apply
3070 * Warning2: Even in windowed mode the coords are relative to the window, not the screen
3071 */
3072 winHeight = windowRect.bottom - windowRect.top;
3073 TRACE("(%p) Setting new Scissor Rect to %d:%d-%d:%d\n", stateblock->wineD3DDevice, pRect->left, pRect->bottom - winHeight,
3074 pRect->right - pRect->left, pRect->bottom - pRect->top);
3075 glScissor(pRect->left, winHeight - pRect->bottom, pRect->right - pRect->left, pRect->bottom - pRect->top);
3076 checkGLcall("glScissor");
3077}
3078
Stefan Dösinger59ae2a52007-02-19 15:25:32 +0100[diff] [blame]3079static void indexbuffer(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
3080 if(GL_SUPPORT(ARB_VERTEX_BUFFER_OBJECT)) {
3081 if(stateblock->streamIsUP || stateblock->pIndexData == NULL ) {
3082 GL_EXTCALL(glBindBufferARB(GL_ELEMENT_ARRAY_BUFFER_ARB, 0));
3083 } else {
3084 IWineD3DIndexBufferImpl *ib = (IWineD3DIndexBufferImpl *) stateblock->pIndexData;
3085 GL_EXTCALL(glBindBufferARB(GL_ELEMENT_ARRAY_BUFFER_ARB, ib->vbo));
3086 }
3087 }
3088}
3089
Stefan Dösingerc0268c72006-12-05 23:36:10 +0100[diff] [blame]3090const struct StateEntry StateTable[] =
3091{
3092 /* State name representative, apply function */
Stefan Dösinger2a24e842006-12-06 13:22:12 +0100[diff] [blame]3093 { /* 0, Undefined */ 0, state_undefined },
3094 { /* 1, WINED3DRS_TEXTUREHANDLE */ 0 /* Handled in ddraw */, state_undefined },
Stefan Dösinger55a5b4c2006-12-10 23:21:03 +0100[diff] [blame]3095 { /* 2, WINED3DRS_ANTIALIAS */ STATE_RENDER(WINED3DRS_ANTIALIAS), state_antialias },
Stefan Dösinger2a24e842006-12-06 13:22:12 +0100[diff] [blame]3096 { /* 3, WINED3DRS_TEXTUREADDRESS */ 0 /* Handled in ddraw */, state_undefined },
Stefan Dösinger312be462006-12-10 23:20:56 +0100[diff] [blame]3097 { /* 4, WINED3DRS_TEXTUREPERSPECTIVE */ STATE_RENDER(WINED3DRS_TEXTUREPERSPECTIVE), state_perspective },
Stefan Dösingerff077ec2006-12-15 20:02:13 +0100[diff] [blame]3098 { /* 5, WINED3DRS_WRAPU */ STATE_RENDER(WINED3DRS_WRAPU), state_wrapu },
3099 { /* 6, WINED3DRS_WRAPV */ STATE_RENDER(WINED3DRS_WRAPV), state_wrapv },
Stefan Dösingerbb564dc2006-12-08 01:40:51 +0100[diff] [blame]3100 { /* 7, WINED3DRS_ZENABLE */ STATE_RENDER(WINED3DRS_ZENABLE), state_zenable },
Stefan Dösingerde963202006-12-05 23:45:35 +0100[diff] [blame]3101 { /* 8, WINED3DRS_FILLMODE */ STATE_RENDER(WINED3DRS_FILLMODE), state_fillmode },
Stefan Dösinger68f10822006-12-08 01:42:16 +0100[diff] [blame]3102 { /* 9, WINED3DRS_SHADEMODE */ STATE_RENDER(WINED3DRS_SHADEMODE), state_shademode },
Stefan Dösinger6a5d7df2006-12-10 23:20:01 +0100[diff] [blame]3103 { /* 10, WINED3DRS_LINEPATTERN */ STATE_RENDER(WINED3DRS_LINEPATTERN), state_linepattern },
Stefan Dösingerff077ec2006-12-15 20:02:13 +0100[diff] [blame]3104 { /* 11, WINED3DRS_MONOENABLE */ STATE_RENDER(WINED3DRS_MONOENABLE), state_monoenable },
3105 { /* 12, WINED3DRS_ROP2 */ STATE_RENDER(WINED3DRS_ROP2), state_rop2 },
3106 { /* 13, WINED3DRS_PLANEMASK */ STATE_RENDER(WINED3DRS_PLANEMASK), state_planemask },
Stefan Dösinger8879c7d2006-12-08 01:43:25 +0100[diff] [blame]3107 { /* 14, WINED3DRS_ZWRITEENABLE */ STATE_RENDER(WINED3DRS_ZWRITEENABLE), state_zwritenable },
Stefan Dösingerc88efee2006-12-08 20:21:32 +0100[diff] [blame]3108 { /* 15, WINED3DRS_ALPHATESTENABLE */ STATE_RENDER(WINED3DRS_ALPHATESTENABLE), state_alpha },
Stefan Dösingerc5344702006-12-10 23:20:29 +0100[diff] [blame]3109 { /* 16, WINED3DRS_LASTPIXEL */ STATE_RENDER(WINED3DRS_LASTPIXEL), state_lastpixel },
Stefan Dösinger2a24e842006-12-06 13:22:12 +0100[diff] [blame]3110 { /* 17, WINED3DRS_TEXTUREMAG */ 0 /* Handled in ddraw */, state_undefined },
3111 { /* 18, WINED3DRS_TEXTUREMIN */ 0 /* Handled in ddraw */, state_undefined },
Stefan Dösinger1f07e4a2006-12-08 01:51:11 +0100[diff] [blame]3112 { /* 19, WINED3DRS_SRCBLEND */ STATE_RENDER(WINED3DRS_ALPHABLENDENABLE), state_blend },
3113 { /* 20, WINED3DRS_DESTBLEND */ STATE_RENDER(WINED3DRS_ALPHABLENDENABLE), state_blend },
Stefan Dösinger2a24e842006-12-06 13:22:12 +0100[diff] [blame]3114 { /* 21, WINED3DRS_TEXTUREMAPBLEND */ 0 /* Handled in ddraw */, state_undefined },
Stefan Dösingere4b4c042006-12-08 01:41:43 +0100[diff] [blame]3115 { /* 22, WINED3DRS_CULLMODE */ STATE_RENDER(WINED3DRS_CULLMODE), state_cullmode },
Stefan Dösinger2ac48e82006-12-08 01:44:55 +0100[diff] [blame]3116 { /* 23, WINED3DRS_ZFUNC */ STATE_RENDER(WINED3DRS_ZFUNC), state_zfunc },
Stefan Dösingerc88efee2006-12-08 20:21:32 +0100[diff] [blame]3117 { /* 24, WINED3DRS_ALPHAREF */ STATE_RENDER(WINED3DRS_ALPHATESTENABLE), state_alpha },
3118 { /* 25, WINED3DRS_ALPHAFUNC */ STATE_RENDER(WINED3DRS_ALPHATESTENABLE), state_alpha },
Stefan Dösingerbb622e82006-12-08 01:42:43 +0100[diff] [blame]3119 { /* 26, WINED3DRS_DITHERENABLE */ STATE_RENDER(WINED3DRS_DITHERENABLE), state_ditherenable },
Stefan Dösinger1f07e4a2006-12-08 01:51:11 +0100[diff] [blame]3120 { /* 27, WINED3DRS_ALPHABLENDENABLE */ STATE_RENDER(WINED3DRS_ALPHABLENDENABLE), state_blend },
Stefan Dösinger61752732006-12-08 18:42:43 +0100[diff] [blame]3121 { /* 28, WINED3DRS_FOGENABLE */ STATE_RENDER(WINED3DRS_FOGENABLE), state_fog },
Stefan Dösinger0772bb42006-12-08 18:38:30 +0100[diff] [blame]3122 { /* 29, WINED3DRS_SPECULARENABLE */ STATE_RENDER(WINED3DRS_SPECULARENABLE), state_specularenable},
Stefan Dösinger2a24e842006-12-06 13:22:12 +0100[diff] [blame]3123 { /* 30, WINED3DRS_ZVISIBLE */ 0 /* Not supported according to the msdn */, state_nogl },
Stefan Dösingerff077ec2006-12-15 20:02:13 +0100[diff] [blame]3124 { /* 31, WINED3DRS_SUBPIXEL */ STATE_RENDER(WINED3DRS_SUBPIXEL), state_subpixel },
3125 { /* 32, WINED3DRS_SUBPIXELX */ STATE_RENDER(WINED3DRS_SUBPIXELX), state_subpixelx },
Stefan Dösinger2710be02006-12-10 23:20:59 +0100[diff] [blame]3126 { /* 33, WINED3DRS_STIPPLEDALPHA */ STATE_RENDER(WINED3DRS_STIPPLEDALPHA), state_stippledalpha },
Stefan Dösingeraf935a22006-12-08 18:52:30 +0100[diff] [blame]3127 { /* 34, WINED3DRS_FOGCOLOR */ STATE_RENDER(WINED3DRS_FOGCOLOR), state_fogcolor },
Stefan Dösinger61752732006-12-08 18:42:43 +0100[diff] [blame]3128 { /* 35, WINED3DRS_FOGTABLEMODE */ STATE_RENDER(WINED3DRS_FOGENABLE), state_fog },
3129 { /* 36, WINED3DRS_FOGSTART */ STATE_RENDER(WINED3DRS_FOGENABLE), state_fog },
3130 { /* 37, WINED3DRS_FOGEND */ STATE_RENDER(WINED3DRS_FOGENABLE), state_fog },
Stefan Dösingere53c2a92006-12-10 16:34:45 +0100[diff] [blame]3131 { /* 38, WINED3DRS_FOGDENSITY */ STATE_RENDER(WINED3DRS_FOGDENSITY), state_fogdensity },
Stefan Dösingerff077ec2006-12-15 20:02:13 +0100[diff] [blame]3132 { /* 39, WINED3DRS_STIPPLEENABLE */ STATE_RENDER(WINED3DRS_STIPPLEENABLE), state_stippleenable },
Stefan Dösinger1f07e4a2006-12-08 01:51:11 +0100[diff] [blame]3133 { /* 40, WINED3DRS_EDGEANTIALIAS */ STATE_RENDER(WINED3DRS_ALPHABLENDENABLE), state_blend },
Stefan Dösingerc88efee2006-12-08 20:21:32 +0100[diff] [blame]3134 { /* 41, WINED3DRS_COLORKEYENABLE */ STATE_RENDER(WINED3DRS_ALPHATESTENABLE), state_alpha },
Stefan Dösinger2a24e842006-12-06 13:22:12 +0100[diff] [blame]3135 { /* 42, undefined */ 0, state_undefined },
Stefan Dösingerff077ec2006-12-15 20:02:13 +0100[diff] [blame]3136 { /* 43, WINED3DRS_BORDERCOLOR */ STATE_RENDER(WINED3DRS_BORDERCOLOR), state_bordercolor },
Stefan Dösinger2a24e842006-12-06 13:22:12 +0100[diff] [blame]3137 { /* 44, WINED3DRS_TEXTUREADDRESSU */ 0, /* Handled in ddraw */ state_undefined },
3138 { /* 45, WINED3DRS_TEXTUREADDRESSV */ 0, /* Handled in ddraw */ state_undefined },
Stefan Dösingerff077ec2006-12-15 20:02:13 +0100[diff] [blame]3139 { /* 46, WINED3DRS_MIPMAPLODBIAS */ STATE_RENDER(WINED3DRS_MIPMAPLODBIAS), state_mipmaplodbias },
Stefan Dösingerdd6f5a52006-12-10 23:19:57 +0100[diff] [blame]3140 { /* 47, WINED3DRS_ZBIAS */ STATE_RENDER(WINED3DRS_ZBIAS), state_zbias },
Stefan Dösingerf2602482006-12-08 20:03:27 +0100[diff] [blame]3141 { /* 48, WINED3DRS_RANGEFOGENABLE */ 0, state_nogl },
Stefan Dösingerff077ec2006-12-15 20:02:13 +0100[diff] [blame]3142 { /* 49, WINED3DRS_ANISOTROPY */ STATE_RENDER(WINED3DRS_ANISOTROPY), state_anisotropy },
3143 { /* 50, WINED3DRS_FLUSHBATCH */ STATE_RENDER(WINED3DRS_FLUSHBATCH), state_flushbatch },
3144 { /* 51, WINED3DRS_TRANSLUCENTSORTINDEPENDENT */ STATE_RENDER(WINED3DRS_TRANSLUCENTSORTINDEPENDENT), state_translucentsi },
Stefan Dösinger0d9ae202006-12-08 18:39:45 +0100[diff] [blame]3145 { /* 52, WINED3DRS_STENCILENABLE */ STATE_RENDER(WINED3DRS_STENCILENABLE), state_stencil },
3146 { /* 53, WINED3DRS_STENCILFAIL */ STATE_RENDER(WINED3DRS_STENCILENABLE), state_stencil },
3147 { /* 54, WINED3DRS_STENCILZFAIL */ STATE_RENDER(WINED3DRS_STENCILENABLE), state_stencil },
3148 { /* 55, WINED3DRS_STENCILPASS */ STATE_RENDER(WINED3DRS_STENCILENABLE), state_stencil },
3149 { /* 56, WINED3DRS_STENCILFUNC */ STATE_RENDER(WINED3DRS_STENCILENABLE), state_stencil },
3150 { /* 57, WINED3DRS_STENCILREF */ STATE_RENDER(WINED3DRS_STENCILENABLE), state_stencil },
3151 { /* 58, WINED3DRS_STENCILMASK */ STATE_RENDER(WINED3DRS_STENCILENABLE), state_stencil },
Stefan Dösinger8d724312006-12-08 18:41:05 +0100[diff] [blame]3152 { /* 59, WINED3DRS_STENCILWRITEMASK */ STATE_RENDER(WINED3DRS_STENCILWRITEMASK), state_stencilwrite },
Stefan Dösinger287c6242006-12-08 18:37:17 +0100[diff] [blame]3153 { /* 60, WINED3DRS_TEXTUREFACTOR */ STATE_RENDER(WINED3DRS_TEXTUREFACTOR), state_texfactor },
Stefan Dösinger2a24e842006-12-06 13:22:12 +0100[diff] [blame]3154 { /* 61, Undefined */ 0, state_undefined },
3155 { /* 62, Undefined */ 0, state_undefined },
3156 { /* 63, Undefined */ 0, state_undefined },
Stefan Dösingerf661a822006-12-17 17:21:30 +0100[diff] [blame]3157 { /* 64, WINED3DRS_STIPPLEPATTERN00 */ 0 /* Obsolete, should be handled by ddraw */, state_undefined },
3158 { /* 65, WINED3DRS_STIPPLEPATTERN01 */ 0 /* Obsolete, should he handled by ddraw */, state_undefined },
3159 { /* 66, WINED3DRS_STIPPLEPATTERN02 */ 0 /* Obsolete, should be handled by ddraw */, state_undefined },
3160 { /* 67, WINED3DRS_STIPPLEPATTERN03 */ 0 /* Obsolete, should be handled by ddraw */, state_undefined },
3161 { /* 68, WINED3DRS_STIPPLEPATTERN04 */ 0 /* Obsolete, should be handled by ddraw */, state_undefined },
3162 { /* 69, WINED3DRS_STIPPLEPATTERN05 */ 0 /* Obsolete, should be handled by ddraw */, state_undefined },
3163 { /* 70, WINED3DRS_STIPPLEPATTERN06 */ 0 /* Obsolete, should be handled by ddraw */, state_undefined },
3164 { /* 71, WINED3DRS_STIPPLEPATTERN07 */ 0 /* Obsolete, should be handled by ddraw */, state_undefined },
3165 { /* 72, WINED3DRS_STIPPLEPATTERN08 */ 0 /* Obsolete, should be handled by ddraw */, state_undefined },
3166 { /* 73, WINED3DRS_STIPPLEPATTERN09 */ 0 /* Obsolete, should be handled by ddraw */, state_undefined },
3167 { /* 74, WINED3DRS_STIPPLEPATTERN10 */ 0 /* Obsolete, should be handled by ddraw */, state_undefined },
3168 { /* 75, WINED3DRS_STIPPLEPATTERN11 */ 0 /* Obsolete, should be handled by ddraw */, state_undefined },
3169 { /* 76, WINED3DRS_STIPPLEPATTERN12 */ 0 /* Obsolete, should be handled by ddraw */, state_undefined },
3170 { /* 77, WINED3DRS_STIPPLEPATTERN13 */ 0 /* Obsolete, should be handled by ddraw */, state_undefined },
3171 { /* 78, WINED3DRS_STIPPLEPATTERN14 */ 0 /* Obsolete, should be handled by ddraw */, state_undefined },
3172 { /* 79, WINED3DRS_STIPPLEPATTERN15 */ 0 /* Obsolete, should be handled by ddraw */, state_undefined },
3173 { /* 80, WINED3DRS_STIPPLEPATTERN16 */ 0 /* Obsolete, should be handled by ddraw */, state_undefined },
3174 { /* 81, WINED3DRS_STIPPLEPATTERN17 */ 0 /* Obsolete, should be handled by ddraw */, state_undefined },
3175 { /* 82, WINED3DRS_STIPPLEPATTERN18 */ 0 /* Obsolete, should be handled by ddraw */, state_undefined },
3176 { /* 83, WINED3DRS_STIPPLEPATTERN19 */ 0 /* Obsolete, should be handled by ddraw */, state_undefined },
3177 { /* 84, WINED3DRS_STIPPLEPATTERN20 */ 0 /* Obsolete, should be handled by ddraw */, state_undefined },
3178 { /* 85, WINED3DRS_STIPPLEPATTERN21 */ 0 /* Obsolete, should be handled by ddraw */, state_undefined },
3179 { /* 86, WINED3DRS_STIPPLEPATTERN22 */ 0 /* Obsolete, should be handled by ddraw */, state_undefined },
3180 { /* 87, WINED3DRS_STIPPLEPATTERN23 */ 0 /* Obsolete, should be handled by ddraw */, state_undefined },
3181 { /* 88, WINED3DRS_STIPPLEPATTERN24 */ 0 /* Obsolete, should be handled by ddraw */, state_undefined },
3182 { /* 89, WINED3DRS_STIPPLEPATTERN25 */ 0 /* Obsolete, should be handled by ddraw */, state_undefined },
3183 { /* 90, WINED3DRS_STIPPLEPATTERN26 */ 0 /* Obsolete, should be handled by ddraw */, state_undefined },
3184 { /* 91, WINED3DRS_STIPPLEPATTERN27 */ 0 /* Obsolete, should be handled by ddraw */, state_undefined },
3185 { /* 92, WINED3DRS_STIPPLEPATTERN28 */ 0 /* Obsolete, should be handled by ddraw */, state_undefined },
3186 { /* 93, WINED3DRS_STIPPLEPATTERN29 */ 0 /* Obsolete, should be handled by ddraw */, state_undefined },
3187 { /* 94, WINED3DRS_STIPPLEPATTERN30 */ 0 /* Obsolete, should be handled by ddraw */, state_undefined },
3188 { /* 95, WINED3DRS_STIPPLEPATTERN31 */ 0 /* Obsolete, should be handled by ddraw */, state_undefined },
Stefan Dösinger2a24e842006-12-06 13:22:12 +0100[diff] [blame]3189 { /* 96, Undefined */ 0, state_undefined },
3190 { /* 97, Undefined */ 0, state_undefined },
3191 { /* 98, Undefined */ 0, state_undefined },
3192 { /* 99, Undefined */ 0, state_undefined },
3193 { /*100, Undefined */ 0, state_undefined },
3194 { /*101, Undefined */ 0, state_undefined },
3195 { /*102, Undefined */ 0, state_undefined },
3196 { /*103, Undefined */ 0, state_undefined },
3197 { /*104, Undefined */ 0, state_undefined },
3198 { /*105, Undefined */ 0, state_undefined },
3199 { /*106, Undefined */ 0, state_undefined },
3200 { /*107, Undefined */ 0, state_undefined },
3201 { /*108, Undefined */ 0, state_undefined },
3202 { /*109, Undefined */ 0, state_undefined },
3203 { /*110, Undefined */ 0, state_undefined },
3204 { /*111, Undefined */ 0, state_undefined },
3205 { /*112, Undefined */ 0, state_undefined },
3206 { /*113, Undefined */ 0, state_undefined },
3207 { /*114, Undefined */ 0, state_undefined },
3208 { /*115, Undefined */ 0, state_undefined },
3209 { /*116, Undefined */ 0, state_undefined },
3210 { /*117, Undefined */ 0, state_undefined },
3211 { /*118, Undefined */ 0, state_undefined },
3212 { /*119, Undefined */ 0, state_undefined },
3213 { /*120, Undefined */ 0, state_undefined },
3214 { /*121, Undefined */ 0, state_undefined },
3215 { /*122, Undefined */ 0, state_undefined },
3216 { /*123, Undefined */ 0, state_undefined },
3217 { /*124, Undefined */ 0, state_undefined },
3218 { /*125, Undefined */ 0, state_undefined },
3219 { /*126, Undefined */ 0, state_undefined },
3220 { /*127, Undefined */ 0, state_undefined },
3221 /* Big hole ends */
Stefan Dösinger81dce712006-12-10 23:20:45 +0100[diff] [blame]3222 { /*128, WINED3DRS_WRAP0 */ STATE_RENDER(WINED3DRS_WRAP0), state_wrap },
3223 { /*129, WINED3DRS_WRAP1 */ STATE_RENDER(WINED3DRS_WRAP0), state_wrap },
3224 { /*130, WINED3DRS_WRAP2 */ STATE_RENDER(WINED3DRS_WRAP0), state_wrap },
3225 { /*131, WINED3DRS_WRAP3 */ STATE_RENDER(WINED3DRS_WRAP0), state_wrap },
3226 { /*132, WINED3DRS_WRAP4 */ STATE_RENDER(WINED3DRS_WRAP0), state_wrap },
3227 { /*133, WINED3DRS_WRAP5 */ STATE_RENDER(WINED3DRS_WRAP0), state_wrap },
3228 { /*134, WINED3DRS_WRAP6 */ STATE_RENDER(WINED3DRS_WRAP0), state_wrap },
3229 { /*135, WINED3DRS_WRAP7 */ STATE_RENDER(WINED3DRS_WRAP0), state_wrap },
Stefan Dösinger89e999a2006-12-08 18:01:23 +0100[diff] [blame]3230 { /*136, WINED3DRS_CLIPPING */ STATE_RENDER(WINED3DRS_CLIPPING), state_clipping },
Stefan Dösingera0ff9822007-01-02 22:49:17 +0100[diff] [blame]3231 { /*137, WINED3DRS_LIGHTING */ STATE_RENDER(WINED3DRS_LIGHTING), state_lighting },
Stefan Dösingerff077ec2006-12-15 20:02:13 +0100[diff] [blame]3232 { /*138, WINED3DRS_EXTENTS */ STATE_RENDER(WINED3DRS_EXTENTS), state_extents },
Stefan Dösinger28cc3c82006-12-08 01:45:26 +0100[diff] [blame]3233 { /*139, WINED3DRS_AMBIENT */ STATE_RENDER(WINED3DRS_AMBIENT), state_ambient },
Stefan Dösinger61752732006-12-08 18:42:43 +0100[diff] [blame]3234 { /*140, WINED3DRS_FOGVERTEXMODE */ STATE_RENDER(WINED3DRS_FOGENABLE), state_fog },
Stefan Dösinger81a1dce2006-12-10 22:44:18 +0100[diff] [blame]3235 { /*141, WINED3DRS_COLORVERTEX */ STATE_RENDER(WINED3DRS_COLORVERTEX), state_colormat },
Stefan Dösinger580b9962006-12-10 23:20:26 +0100[diff] [blame]3236 { /*142, WINED3DRS_LOCALVIEWER */ STATE_RENDER(WINED3DRS_LOCALVIEWER), state_localviewer },
Stefan Dösinger2ea57672006-12-10 23:20:05 +0100[diff] [blame]3237 { /*143, WINED3DRS_NORMALIZENORMALS */ STATE_RENDER(WINED3DRS_NORMALIZENORMALS), state_normalize },
Stefan Dösingerff077ec2006-12-15 20:02:13 +0100[diff] [blame]3238 { /*144, WINED3DRS_COLORKEYBLENDENABLE */ STATE_RENDER(WINED3DRS_COLORKEYBLENDENABLE), state_ckeyblend },
Stefan Dösinger81a1dce2006-12-10 22:44:18 +0100[diff] [blame]3239 { /*145, WINED3DRS_DIFFUSEMATERIALSOURCE */ STATE_RENDER(WINED3DRS_COLORVERTEX), state_colormat },
3240 { /*146, WINED3DRS_SPECULARMATERIALSOURCE */ STATE_RENDER(WINED3DRS_COLORVERTEX), state_colormat },
3241 { /*147, WINED3DRS_AMBIENTMATERIALSOURCE */ STATE_RENDER(WINED3DRS_COLORVERTEX), state_colormat },
3242 { /*148, WINED3DRS_EMISSIVEMATERIALSOURCE */ STATE_RENDER(WINED3DRS_COLORVERTEX), state_colormat },
Stefan Dösinger2a24e842006-12-06 13:22:12 +0100[diff] [blame]3243 { /*149, Undefined */ 0, state_undefined },
3244 { /*150, Undefined */ 0, state_undefined },
3245 { /*151, WINED3DRS_VERTEXBLEND */ 0, state_nogl },
Stefan Dösinger89e999a2006-12-08 18:01:23 +0100[diff] [blame]3246 { /*152, WINED3DRS_CLIPPLANEENABLE */ STATE_RENDER(WINED3DRS_CLIPPING), state_clipping },
Stefan Dösinger2a24e842006-12-06 13:22:12 +0100[diff] [blame]3247 { /*153, WINED3DRS_SOFTWAREVERTEXPROCESSING */ 0, state_nogl },
Stefan Dösinger0ec7c8b2006-12-10 23:20:09 +0100[diff] [blame]3248 { /*154, WINED3DRS_POINTSIZE */ STATE_RENDER(WINED3DRS_POINTSIZE), state_psize },
Stefan Dösinger51b41d92006-12-10 23:20:12 +0100[diff] [blame]3249 { /*155, WINED3DRS_POINTSIZE_MIN */ STATE_RENDER(WINED3DRS_POINTSIZE_MIN), state_psizemin },
Stefan Dösinger920225d2006-12-10 23:20:36 +0100[diff] [blame]3250 { /*156, WINED3DRS_POINTSPRITEENABLE */ STATE_RENDER(WINED3DRS_POINTSPRITEENABLE), state_pointsprite },
Stefan Dösingercaa371a2006-12-10 23:20:19 +0100[diff] [blame]3251 { /*157, WINED3DRS_POINTSCALEENABLE */ STATE_RENDER(WINED3DRS_POINTSCALEENABLE), state_pscale },
3252 { /*158, WINED3DRS_POINTSCALE_A */ STATE_RENDER(WINED3DRS_POINTSCALEENABLE), state_pscale },
3253 { /*159, WINED3DRS_POINTSCALE_B */ STATE_RENDER(WINED3DRS_POINTSCALEENABLE), state_pscale },
3254 { /*160, WINED3DRS_POINTSCALE_C */ STATE_RENDER(WINED3DRS_POINTSCALEENABLE), state_pscale },
Stefan Dösinger0c1aba52006-12-10 23:20:40 +0100[diff] [blame]3255 { /*161, WINED3DRS_MULTISAMPLEANTIALIAS */ STATE_RENDER(WINED3DRS_MULTISAMPLEANTIALIAS), state_multisampleaa },
Stefan Dösingerd7b85492006-12-10 23:21:07 +0100[diff] [blame]3256 { /*162, WINED3DRS_MULTISAMPLEMASK */ STATE_RENDER(WINED3DRS_MULTISAMPLEMASK), state_multisampmask },
Stefan Dösingerf154f542006-12-15 20:03:17 +0100[diff] [blame]3257 { /*163, WINED3DRS_PATCHEDGESTYLE */ STATE_RENDER(WINED3DRS_PATCHEDGESTYLE), state_patchedgestyle},
Stefan Dösinger81974702006-12-10 23:21:14 +0100[diff] [blame]3258 { /*164, WINED3DRS_PATCHSEGMENTS */ STATE_RENDER(WINED3DRS_PATCHSEGMENTS), state_patchsegments },
Stefan Dösingere25edbf2006-12-10 23:21:17 +0100[diff] [blame]3259 { /*165, WINED3DRS_DEBUGMONITORTOKEN */ STATE_RENDER(WINED3DRS_DEBUGMONITORTOKEN), state_nogl },
Stefan Dösinger9a0e4b52006-12-10 23:20:15 +0100[diff] [blame]3260 { /*166, WINED3DRS_POINTSIZE_MAX */ STATE_RENDER(WINED3DRS_POINTSIZE_MAX), state_psizemax },
Stefan Dösinger1328da02006-12-08 19:53:41 +0100[diff] [blame]3261 { /*167, WINED3DRS_INDEXEDVERTEXBLENDENABLE */ 0, state_nogl },
Stefan Dösinger4c64b862006-12-10 23:20:22 +0100[diff] [blame]3262 { /*168, WINED3DRS_COLORWRITEENABLE */ STATE_RENDER(WINED3DRS_COLORWRITEENABLE), state_colorwrite },
Stefan Dösinger2a24e842006-12-06 13:22:12 +0100[diff] [blame]3263 { /*169, Undefined */ 0, state_undefined },
3264 { /*170, WINED3DRS_TWEENFACTOR */ 0, state_nogl },
Stefan Dösingerac261722006-12-08 20:21:43 +0100[diff] [blame]3265 { /*171, WINED3DRS_BLENDOP */ STATE_RENDER(WINED3DRS_BLENDOP), state_blendop },
Stefan Dösinger052197a2006-12-10 23:21:21 +0100[diff] [blame]3266 { /*172, WINED3DRS_POSITIONDEGREE */ STATE_RENDER(WINED3DRS_POSITIONDEGREE), state_positiondegree},
Stefan Dösinger3bb41772006-12-10 23:21:25 +0100[diff] [blame]3267 { /*173, WINED3DRS_NORMALDEGREE */ STATE_RENDER(WINED3DRS_NORMALDEGREE), state_normaldegree },
Stefan Dösinger2a24e842006-12-06 13:22:12 +0100[diff] [blame]3268 /*172, WINED3DRS_POSITIONORDER */ /* Value assigned to 2 state names */
3269 /*173, WINED3DRS_NORMALORDER */ /* Value assigned to 2 state names */
Stefan Dösingerd7e55c22006-12-10 23:20:48 +0100[diff] [blame]3270 { /*174, WINED3DRS_SCISSORTESTENABLE */ STATE_RENDER(WINED3DRS_SCISSORTESTENABLE), state_scissor },
Stefan Dösinger30cf5e42006-12-10 23:20:52 +0100[diff] [blame]3271 { /*175, WINED3DRS_SLOPESCALEDEPTHBIAS */ STATE_RENDER(WINED3DRS_DEPTHBIAS), state_depthbias },
Stefan Dösinger1f07e4a2006-12-08 01:51:11 +0100[diff] [blame]3272 { /*176, WINED3DRS_ANTIALIASEDLINEENABLE */ STATE_RENDER(WINED3DRS_ALPHABLENDENABLE), state_blend },
Stefan Dösinger2a24e842006-12-06 13:22:12 +0100[diff] [blame]3273 { /*177, undefined */ 0, state_undefined },
Stefan Dösingercd0d0a72006-12-10 23:21:27 +0100[diff] [blame]3274 { /*178, WINED3DRS_MINTESSELLATIONLEVEL */ STATE_RENDER(WINED3DRS_ENABLEADAPTIVETESSELLATION), state_tessellation },
3275 { /*179, WINED3DRS_MAXTESSELLATIONLEVEL */ STATE_RENDER(WINED3DRS_ENABLEADAPTIVETESSELLATION), state_tessellation },
3276 { /*180, WINED3DRS_ADAPTIVETESS_X */ STATE_RENDER(WINED3DRS_ENABLEADAPTIVETESSELLATION), state_tessellation },
3277 { /*181, WINED3DRS_ADAPTIVETESS_Y */ STATE_RENDER(WINED3DRS_ENABLEADAPTIVETESSELLATION), state_tessellation },
3278 { /*182, WINED3DRS_ADAPTIVETESS_Z */ STATE_RENDER(WINED3DRS_ENABLEADAPTIVETESSELLATION), state_tessellation },
3279 { /*183, WINED3DRS_ADAPTIVETESS_W */ STATE_RENDER(WINED3DRS_ENABLEADAPTIVETESSELLATION), state_tessellation },
3280 { /*184, WINED3DRS_ENABLEADAPTIVETESSELLATION */ STATE_RENDER(WINED3DRS_ENABLEADAPTIVETESSELLATION), state_tessellation },
Stefan Dösinger0d9ae202006-12-08 18:39:45 +0100[diff] [blame]3281 { /*185, WINED3DRS_TWOSIDEDSTENCILMODE */ STATE_RENDER(WINED3DRS_STENCILENABLE), state_stencil },
3282 { /*186, WINED3DRS_CCW_STENCILFAIL */ STATE_RENDER(WINED3DRS_STENCILENABLE), state_stencil },
3283 { /*187, WINED3DRS_CCW_STENCILZFAIL */ STATE_RENDER(WINED3DRS_STENCILENABLE), state_stencil },
3284 { /*188, WINED3DRS_CCW_STENCILPASS */ STATE_RENDER(WINED3DRS_STENCILENABLE), state_stencil },
3285 { /*189, WINED3DRS_CCW_STENCILFUNC */ STATE_RENDER(WINED3DRS_STENCILENABLE), state_stencil },
Stefan Dösinger4c64b862006-12-10 23:20:22 +0100[diff] [blame]3286 { /*190, WINED3DRS_COLORWRITEENABLE1 */ STATE_RENDER(WINED3DRS_COLORWRITEENABLE), state_colorwrite },
3287 { /*191, WINED3DRS_COLORWRITEENABLE2 */ STATE_RENDER(WINED3DRS_COLORWRITEENABLE), state_colorwrite },
3288 { /*192, WINED3DRS_COLORWRITEENABLE3 */ STATE_RENDER(WINED3DRS_COLORWRITEENABLE), state_colorwrite },
Stefan Dösingerd6245402006-12-25 18:46:59 +0100[diff] [blame]3289 { /*193, WINED3DRS_BLENDFACTOR */ STATE_RENDER(WINED3DRS_BLENDFACTOR), state_blendfactor },
Stefan Dösinger8a5bf912006-12-10 23:13:38 +0100[diff] [blame]3290 { /*194, WINED3DRS_SRGBWRITEENABLE */ STATE_RENDER(WINED3DRS_SRGBWRITEENABLE), state_srgbwrite },
Stefan Dösinger30cf5e42006-12-10 23:20:52 +0100[diff] [blame]3291 { /*195, WINED3DRS_DEPTHBIAS */ STATE_RENDER(WINED3DRS_DEPTHBIAS), state_depthbias },
Stefan Dösinger2a24e842006-12-06 13:22:12 +0100[diff] [blame]3292 { /*196, undefined */ 0, state_undefined },
3293 { /*197, undefined */ 0, state_undefined },
Stefan Dösinger81dce712006-12-10 23:20:45 +0100[diff] [blame]3294 { /*198, WINED3DRS_WRAP8 */ STATE_RENDER(WINED3DRS_WRAP0), state_wrap },
3295 { /*199, WINED3DRS_WRAP9 */ STATE_RENDER(WINED3DRS_WRAP0), state_wrap },
3296 { /*200, WINED3DRS_WRAP10 */ STATE_RENDER(WINED3DRS_WRAP0), state_wrap },
3297 { /*201, WINED3DRS_WRAP11 */ STATE_RENDER(WINED3DRS_WRAP0), state_wrap },
3298 { /*202, WINED3DRS_WRAP12 */ STATE_RENDER(WINED3DRS_WRAP0), state_wrap },
3299 { /*203, WINED3DRS_WRAP13 */ STATE_RENDER(WINED3DRS_WRAP0), state_wrap },
3300 { /*204, WINED3DRS_WRAP14 */ STATE_RENDER(WINED3DRS_WRAP0), state_wrap },
3301 { /*205, WINED3DRS_WRAP15 */ STATE_RENDER(WINED3DRS_WRAP0), state_wrap },
Stefan Dösinger92460b92006-12-10 23:14:36 +0100[diff] [blame]3302 { /*206, WINED3DRS_SEPARATEALPHABLENDENABLE */ STATE_RENDER(WINED3DRS_SEPARATEALPHABLENDENABLE), state_seperateblend },
3303 { /*207, WINED3DRS_SRCBLENDALPHA */ STATE_RENDER(WINED3DRS_SEPARATEALPHABLENDENABLE), state_seperateblend },
3304 { /*208, WINED3DRS_DESTBLENDALPHA */ STATE_RENDER(WINED3DRS_SEPARATEALPHABLENDENABLE), state_seperateblend },
3305 { /*209, WINED3DRS_BLENDOPALPHA */ STATE_RENDER(WINED3DRS_SEPARATEALPHABLENDENABLE), state_seperateblend },
Stefan Dösinger569a2fa2006-12-19 22:43:49 +0100[diff] [blame]3306 /* Texture stage states */
Stefan Dösinger762af472006-12-19 23:00:58 +0100[diff] [blame]3307 { /*0, 01, WINED3DTSS_COLOROP */ STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP), tex_colorop },
3308 { /*0, 02, WINED3DTSS_COLORARG1 */ STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP), tex_colorop },
3309 { /*0, 03, WINED3DTSS_COLORARG2 */ STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP), tex_colorop },
Stefan Dösingerbd6a6ad2006-12-19 23:03:37 +0100[diff] [blame]3310 { /*0, 04, WINED3DTSS_ALPHAOP */ STATE_TEXTURESTAGE(0, WINED3DTSS_ALPHAOP), tex_alphaop },
3311 { /*0, 05, WINED3DTSS_ALPHAARG1 */ STATE_TEXTURESTAGE(0, WINED3DTSS_ALPHAOP), tex_alphaop },
3312 { /*0, 06, WINED3DTSS_ALPHAARG2 */ STATE_TEXTURESTAGE(0, WINED3DTSS_ALPHAOP), tex_alphaop },
Stefan Dösingerefbd6d62007-02-15 02:57:49 +0100[diff] [blame]3313 { /*0, 07, WINED3DTSS_BUMPENVMAT00 */ STATE_TEXTURESTAGE(0, WINED3DTSS_BUMPENVMAT00), tex_bumpenvmat },
3314 { /*0, 08, WINED3DTSS_BUMPENVMAT01 */ STATE_TEXTURESTAGE(0, WINED3DTSS_BUMPENVMAT00), tex_bumpenvmat },
3315 { /*0, 09, WINED3DTSS_BUMPENVMAT10 */ STATE_TEXTURESTAGE(0, WINED3DTSS_BUMPENVMAT00), tex_bumpenvmat },
3316 { /*0, 10, WINED3DTSS_BUMPENVMAT11 */ STATE_TEXTURESTAGE(0, WINED3DTSS_BUMPENVMAT00), tex_bumpenvmat },
Stefan Dösinger4e531402006-12-19 23:04:16 +0100[diff] [blame]3317 { /*0, 11, WINED3DTSS_TEXCOORDINDEX */ STATE_TEXTURESTAGE(0, WINED3DTSS_TEXCOORDINDEX), tex_coordindex },
Stefan Dösinger569a2fa2006-12-19 22:43:49 +0100[diff] [blame]3318 { /*0, 12, WINED3DTSS_ADDRESS */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
3319 { /*0, 13, WINED3DTSS_ADDRESSU */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
3320 { /*0, 14, WINED3DTSS_ADDRESSV */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
3321 { /*0, 15, WINED3DTSS_BORDERCOLOR */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
3322 { /*0, 16, WINED3DTSS_MAGFILTER */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
3323 { /*0, 17, WINED3DTSS_MINFILTER */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
3324 { /*0, 18, WINED3DTSS_MIPFILTER */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
3325 { /*0, 19, WINED3DTSS_MIPMAPLODBIAS */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
3326 { /*0, 20, WINED3DTSS_MAXMIPLEVEL */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
3327 { /*0, 21, WINED3DTSS_MAXANISOTROPY */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
Stefan Dösinger72a4f6e2006-12-19 23:05:08 +0100[diff] [blame]3328 { /*0, 22, WINED3DTSS_BUMPENVLSCALE */ STATE_TEXTURESTAGE(0, WINED3DTSS_BUMPENVLSCALE), tex_bumpenvlscale },
Stefan Dösinger1021f642006-12-19 23:34:17 +0100[diff] [blame]3329 { /*0, 23, WINED3DTSS_BUMPENVLOFFSET */ STATE_TEXTURESTAGE(0, WINED3DTSS_BUMPENVLOFFSET), tex_bumpenvloffset },
Stefan Dösingerc10efb32007-01-01 23:53:59 +0100[diff] [blame]3330 { /*0, 24, WINED3DTSS_TEXTURETRANSFORMFLAGS */ STATE_TRANSFORM(WINED3DTS_TEXTURE0), transform_texture },
Stefan Dösinger569a2fa2006-12-19 22:43:49 +0100[diff] [blame]3331 { /*0, 25, WINED3DTSS_ADDRESSW */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
Stefan Dösinger762af472006-12-19 23:00:58 +0100[diff] [blame]3332 { /*0, 26, WINED3DTSS_COLORARG0 */ STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP), tex_colorop },
Stefan Dösingerbd6a6ad2006-12-19 23:03:37 +0100[diff] [blame]3333 { /*0, 27, WINED3DTSS_ALPHAARG0 */ STATE_TEXTURESTAGE(0, WINED3DTSS_ALPHAOP), tex_alphaop },
Stefan Dösinger63a8c3c2006-12-19 23:11:21 +0100[diff] [blame]3334 { /*0, 28, WINED3DTSS_RESULTARG */ STATE_TEXTURESTAGE(0, WINED3DTSS_RESULTARG), tex_resultarg },
Stefan Dösinger569a2fa2006-12-19 22:43:49 +0100[diff] [blame]3335 { /*0, 29, undefined */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
3336 { /*0, 30, undefined */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
3337 { /*0, 31, undefined */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
Stefan Dösinger557b1fa2006-12-19 23:11:28 +0100[diff] [blame]3338 { /*0, 32, WINED3DTSS_CONSTANT */ 0 /* As long as we don't support D3DTA_CONSTANT */, state_nogl },
Stefan Dösinger569a2fa2006-12-19 22:43:49 +0100[diff] [blame]3339
Stefan Dösinger762af472006-12-19 23:00:58 +0100[diff] [blame]3340 { /*1, 01, WINED3DTSS_COLOROP */ STATE_TEXTURESTAGE(1, WINED3DTSS_COLOROP), tex_colorop },
3341 { /*1, 02, WINED3DTSS_COLORARG1 */ STATE_TEXTURESTAGE(1, WINED3DTSS_COLOROP), tex_colorop },
3342 { /*1, 03, WINED3DTSS_COLORARG2 */ STATE_TEXTURESTAGE(1, WINED3DTSS_COLOROP), tex_colorop },
Stefan Dösingerbd6a6ad2006-12-19 23:03:37 +0100[diff] [blame]3343 { /*1, 04, WINED3DTSS_ALPHAOP */ STATE_TEXTURESTAGE(1, WINED3DTSS_ALPHAOP), tex_alphaop },
3344 { /*1, 05, WINED3DTSS_ALPHAARG1 */ STATE_TEXTURESTAGE(1, WINED3DTSS_ALPHAOP), tex_alphaop },
3345 { /*1, 06, WINED3DTSS_ALPHAARG2 */ STATE_TEXTURESTAGE(1, WINED3DTSS_ALPHAOP), tex_alphaop },
Stefan Dösingerefbd6d62007-02-15 02:57:49 +0100[diff] [blame]3346 { /*1, 07, WINED3DTSS_BUMPENVMAT00 */ STATE_TEXTURESTAGE(1, WINED3DTSS_BUMPENVMAT00), tex_bumpenvmat },
3347 { /*1, 08, WINED3DTSS_BUMPENVMAT01 */ STATE_TEXTURESTAGE(1, WINED3DTSS_BUMPENVMAT00), tex_bumpenvmat },
3348 { /*1, 09, WINED3DTSS_BUMPENVMAT10 */ STATE_TEXTURESTAGE(1, WINED3DTSS_BUMPENVMAT00), tex_bumpenvmat },
3349 { /*1, 10, WINED3DTSS_BUMPENVMAT11 */ STATE_TEXTURESTAGE(1, WINED3DTSS_BUMPENVMAT00), tex_bumpenvmat },
Stefan Dösinger4e531402006-12-19 23:04:16 +0100[diff] [blame]3350 { /*1, 11, WINED3DTSS_TEXCOORDINDEX */ STATE_TEXTURESTAGE(1, WINED3DTSS_TEXCOORDINDEX), tex_coordindex },
Stefan Dösinger569a2fa2006-12-19 22:43:49 +0100[diff] [blame]3351 { /*1, 12, WINED3DTSS_ADDRESS */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
3352 { /*1, 13, WINED3DTSS_ADDRESSU */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
3353 { /*1, 14, WINED3DTSS_ADDRESSV */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
3354 { /*1, 15, WINED3DTSS_BORDERCOLOR */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
3355 { /*1, 16, WINED3DTSS_MAGFILTER */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
3356 { /*1, 17, WINED3DTSS_MINFILTER */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
3357 { /*1, 18, WINED3DTSS_MIPFILTER */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
3358 { /*1, 19, WINED3DTSS_MIPMAPLODBIAS */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
3359 { /*1, 20, WINED3DTSS_MAXMIPLEVEL */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
3360 { /*1, 21, WINED3DTSS_MAXANISOTROPY */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
Stefan Dösinger72a4f6e2006-12-19 23:05:08 +0100[diff] [blame]3361 { /*1, 22, WINED3DTSS_BUMPENVLSCALE */ STATE_TEXTURESTAGE(1, WINED3DTSS_BUMPENVLSCALE), tex_bumpenvlscale },
Stefan Dösinger1021f642006-12-19 23:34:17 +0100[diff] [blame]3362 { /*1, 23, WINED3DTSS_BUMPENVLOFFSET */ STATE_TEXTURESTAGE(1, WINED3DTSS_BUMPENVLOFFSET), tex_bumpenvloffset },
Stefan Dösingerc10efb32007-01-01 23:53:59 +0100[diff] [blame]3363 { /*1, 24, WINED3DTSS_TEXTURETRANSFORMFLAGS */ STATE_TRANSFORM(WINED3DTS_TEXTURE1), transform_texture },
Stefan Dösinger569a2fa2006-12-19 22:43:49 +0100[diff] [blame]3364 { /*1, 25, WINED3DTSS_ADDRESSW */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
Stefan Dösinger762af472006-12-19 23:00:58 +0100[diff] [blame]3365 { /*1, 26, WINED3DTSS_COLORARG0 */ STATE_TEXTURESTAGE(1, WINED3DTSS_COLOROP), tex_colorop },
Stefan Dösingerbd6a6ad2006-12-19 23:03:37 +0100[diff] [blame]3366 { /*1, 27, WINED3DTSS_ALPHAARG0 */ STATE_TEXTURESTAGE(1, WINED3DTSS_ALPHAOP), tex_alphaop },
Stefan Dösinger63a8c3c2006-12-19 23:11:21 +0100[diff] [blame]3367 { /*1, 28, WINED3DTSS_RESULTARG */ STATE_TEXTURESTAGE(1, WINED3DTSS_RESULTARG), tex_resultarg },
Stefan Dösinger569a2fa2006-12-19 22:43:49 +0100[diff] [blame]3368 { /*1, 29, undefined */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
3369 { /*1, 30, undefined */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
3370 { /*1, 31, undefined */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
Stefan Dösinger557b1fa2006-12-19 23:11:28 +0100[diff] [blame]3371 { /*1, 32, WINED3DTSS_CONSTANT */ 0 /* As long as we don't support D3DTA_CONSTANT */, state_nogl },
Stefan Dösinger569a2fa2006-12-19 22:43:49 +0100[diff] [blame]3372
Stefan Dösinger762af472006-12-19 23:00:58 +0100[diff] [blame]3373 { /*2, 01, WINED3DTSS_COLOROP */ STATE_TEXTURESTAGE(2, WINED3DTSS_COLOROP), tex_colorop },
3374 { /*2, 02, WINED3DTSS_COLORARG1 */ STATE_TEXTURESTAGE(2, WINED3DTSS_COLOROP), tex_colorop },
3375 { /*2, 03, WINED3DTSS_COLORARG2 */ STATE_TEXTURESTAGE(2, WINED3DTSS_COLOROP), tex_colorop },
Stefan Dösingerbd6a6ad2006-12-19 23:03:37 +0100[diff] [blame]3376 { /*2, 04, WINED3DTSS_ALPHAOP */ STATE_TEXTURESTAGE(2, WINED3DTSS_ALPHAOP), tex_alphaop },
3377 { /*2, 05, WINED3DTSS_ALPHAARG1 */ STATE_TEXTURESTAGE(2, WINED3DTSS_ALPHAOP), tex_alphaop },
3378 { /*2, 06, WINED3DTSS_ALPHAARG2 */ STATE_TEXTURESTAGE(2, WINED3DTSS_ALPHAOP), tex_alphaop },
Stefan Dösingerefbd6d62007-02-15 02:57:49 +0100[diff] [blame]3379 { /*2, 07, WINED3DTSS_BUMPENVMAT00 */ STATE_TEXTURESTAGE(2, WINED3DTSS_BUMPENVMAT00), tex_bumpenvmat },
3380 { /*2, 08, WINED3DTSS_BUMPENVMAT01 */ STATE_TEXTURESTAGE(2, WINED3DTSS_BUMPENVMAT00), tex_bumpenvmat },
3381 { /*2, 09, WINED3DTSS_BUMPENVMAT10 */ STATE_TEXTURESTAGE(2, WINED3DTSS_BUMPENVMAT00), tex_bumpenvmat },
3382 { /*2, 10, WINED3DTSS_BUMPENVMAT11 */ STATE_TEXTURESTAGE(2, WINED3DTSS_BUMPENVMAT00), tex_bumpenvmat },
Stefan Dösinger4e531402006-12-19 23:04:16 +0100[diff] [blame]3383 { /*2, 11, WINED3DTSS_TEXCOORDINDEX */ STATE_TEXTURESTAGE(2, WINED3DTSS_TEXCOORDINDEX), tex_coordindex },
Stefan Dösinger569a2fa2006-12-19 22:43:49 +0100[diff] [blame]3384 { /*2, 12, WINED3DTSS_ADDRESS */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
3385 { /*2, 13, WINED3DTSS_ADDRESSU */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
3386 { /*2, 14, WINED3DTSS_ADDRESSV */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
3387 { /*2, 15, WINED3DTSS_BORDERCOLOR */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
3388 { /*2, 16, WINED3DTSS_MAGFILTER */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
3389 { /*2, 17, WINED3DTSS_MINFILTER */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
3390 { /*2, 18, WINED3DTSS_MIPFILTER */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
3391 { /*2, 19, WINED3DTSS_MIPMAPLODBIAS */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
3392 { /*2, 20, WINED3DTSS_MAXMIPLEVEL */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
3393 { /*2, 21, WINED3DTSS_MAXANISOTROPY */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
Stefan Dösinger72a4f6e2006-12-19 23:05:08 +0100[diff] [blame]3394 { /*2, 22, WINED3DTSS_BUMPENVLSCALE */ STATE_TEXTURESTAGE(2, WINED3DTSS_BUMPENVLSCALE), tex_bumpenvlscale },
Stefan Dösinger1021f642006-12-19 23:34:17 +0100[diff] [blame]3395 { /*2, 23, WINED3DTSS_BUMPENVLOFFSET */ STATE_TEXTURESTAGE(2, WINED3DTSS_BUMPENVLOFFSET), tex_bumpenvloffset },
Stefan Dösingerc10efb32007-01-01 23:53:59 +0100[diff] [blame]3396 { /*2, 24, WINED3DTSS_TEXTURETRANSFORMFLAGS */ STATE_TRANSFORM(WINED3DTS_TEXTURE2), transform_texture },
Stefan Dösinger569a2fa2006-12-19 22:43:49 +0100[diff] [blame]3397 { /*2, 25, WINED3DTSS_ADDRESSW */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
Stefan Dösinger762af472006-12-19 23:00:58 +0100[diff] [blame]3398 { /*2, 26, WINED3DTSS_COLORARG0 */ STATE_TEXTURESTAGE(2, WINED3DTSS_COLOROP), tex_colorop },
Stefan Dösingerbd6a6ad2006-12-19 23:03:37 +0100[diff] [blame]3399 { /*2, 27, WINED3DTSS_ALPHAARG0 */ STATE_TEXTURESTAGE(2, WINED3DTSS_ALPHAOP), tex_alphaop },
Stefan Dösinger63a8c3c2006-12-19 23:11:21 +0100[diff] [blame]3400 { /*2, 28, WINED3DTSS_RESULTARG */ STATE_TEXTURESTAGE(2, WINED3DTSS_RESULTARG), tex_resultarg },
Stefan Dösinger569a2fa2006-12-19 22:43:49 +0100[diff] [blame]3401 { /*2, 29, undefined */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
3402 { /*2, 30, undefined */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
3403 { /*2, 31, undefined */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
Stefan Dösinger557b1fa2006-12-19 23:11:28 +0100[diff] [blame]3404 { /*2, 32, WINED3DTSS_CONSTANT */ 0 /* As long as we don't support D3DTA_CONSTANT */, state_nogl },
Stefan Dösinger569a2fa2006-12-19 22:43:49 +0100[diff] [blame]3405
Stefan Dösinger762af472006-12-19 23:00:58 +0100[diff] [blame]3406 { /*3, 01, WINED3DTSS_COLOROP */ STATE_TEXTURESTAGE(3, WINED3DTSS_COLOROP), tex_colorop },
3407 { /*3, 02, WINED3DTSS_COLORARG1 */ STATE_TEXTURESTAGE(3, WINED3DTSS_COLOROP), tex_colorop },
3408 { /*3, 03, WINED3DTSS_COLORARG2 */ STATE_TEXTURESTAGE(3, WINED3DTSS_COLOROP), tex_colorop },
Stefan Dösingerbd6a6ad2006-12-19 23:03:37 +0100[diff] [blame]3409 { /*3, 04, WINED3DTSS_ALPHAOP */ STATE_TEXTURESTAGE(3, WINED3DTSS_ALPHAOP), tex_alphaop },
3410 { /*3, 05, WINED3DTSS_ALPHAARG1 */ STATE_TEXTURESTAGE(3, WINED3DTSS_ALPHAOP), tex_alphaop },
3411 { /*3, 06, WINED3DTSS_ALPHAARG2 */ STATE_TEXTURESTAGE(3, WINED3DTSS_ALPHAOP), tex_alphaop },
Stefan Dösingerefbd6d62007-02-15 02:57:49 +0100[diff] [blame]3412 { /*3, 07, WINED3DTSS_BUMPENVMAT00 */ STATE_TEXTURESTAGE(3, WINED3DTSS_BUMPENVMAT00), tex_bumpenvmat },
3413 { /*3, 08, WINED3DTSS_BUMPENVMAT01 */ STATE_TEXTURESTAGE(3, WINED3DTSS_BUMPENVMAT00), tex_bumpenvmat },
3414 { /*3, 09, WINED3DTSS_BUMPENVMAT10 */ STATE_TEXTURESTAGE(3, WINED3DTSS_BUMPENVMAT00), tex_bumpenvmat },
3415 { /*3, 10, WINED3DTSS_BUMPENVMAT11 */ STATE_TEXTURESTAGE(3, WINED3DTSS_BUMPENVMAT00), tex_bumpenvmat },
Stefan Dösinger4e531402006-12-19 23:04:16 +0100[diff] [blame]3416 { /*3, 11, WINED3DTSS_TEXCOORDINDEX */ STATE_TEXTURESTAGE(3, WINED3DTSS_TEXCOORDINDEX), tex_coordindex },
Stefan Dösinger569a2fa2006-12-19 22:43:49 +0100[diff] [blame]3417 { /*3, 12, WINED3DTSS_ADDRESS */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
3418 { /*3, 13, WINED3DTSS_ADDRESSU */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
3419 { /*3, 14, WINED3DTSS_ADDRESSV */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
3420 { /*3, 15, WINED3DTSS_BORDERCOLOR */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
3421 { /*3, 16, WINED3DTSS_MAGFILTER */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
3422 { /*3, 17, WINED3DTSS_MINFILTER */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
3423 { /*3, 18, WINED3DTSS_MIPFILTER */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
3424 { /*3, 19, WINED3DTSS_MIPMAPLODBIAS */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
3425 { /*3, 20, WINED3DTSS_MAXMIPLEVEL */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
3426 { /*3, 21, WINED3DTSS_MAXANISOTROPY */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
Stefan Dösinger72a4f6e2006-12-19 23:05:08 +0100[diff] [blame]3427 { /*3, 22, WINED3DTSS_BUMPENVLSCALE */ STATE_TEXTURESTAGE(3, WINED3DTSS_BUMPENVLSCALE), tex_bumpenvlscale },
Stefan Dösinger1021f642006-12-19 23:34:17 +0100[diff] [blame]3428 { /*3, 23, WINED3DTSS_BUMPENVLOFFSET */ STATE_TEXTURESTAGE(3, WINED3DTSS_BUMPENVLOFFSET), tex_bumpenvloffset },
Stefan Dösingerc10efb32007-01-01 23:53:59 +0100[diff] [blame]3429 { /*3, 24, WINED3DTSS_TEXTURETRANSFORMFLAGS */ STATE_TRANSFORM(WINED3DTS_TEXTURE3), transform_texture },
Stefan Dösinger569a2fa2006-12-19 22:43:49 +0100[diff] [blame]3430 { /*3, 25, WINED3DTSS_ADDRESSW */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
Stefan Dösinger762af472006-12-19 23:00:58 +0100[diff] [blame]3431 { /*3, 26, WINED3DTSS_COLORARG0 */ STATE_TEXTURESTAGE(3, WINED3DTSS_COLOROP), tex_colorop },
Stefan Dösingerbd6a6ad2006-12-19 23:03:37 +0100[diff] [blame]3432 { /*3, 27, WINED3DTSS_ALPHAARG0 */ STATE_TEXTURESTAGE(3, WINED3DTSS_ALPHAOP), tex_alphaop },
Stefan Dösinger63a8c3c2006-12-19 23:11:21 +0100[diff] [blame]3433 { /*3, 28, WINED3DTSS_RESULTARG */ STATE_TEXTURESTAGE(3, WINED3DTSS_RESULTARG), tex_resultarg },
Stefan Dösinger569a2fa2006-12-19 22:43:49 +0100[diff] [blame]3434 { /*3, 29, undefined */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
3435 { /*3, 30, undefined */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
3436 { /*3, 31, undefined */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
Stefan Dösinger557b1fa2006-12-19 23:11:28 +0100[diff] [blame]3437 { /*3, 32, WINED3DTSS_CONSTANT */ 0 /* As long as we don't support D3DTA_CONSTANT */, state_nogl },
Stefan Dösinger569a2fa2006-12-19 22:43:49 +0100[diff] [blame]3438
Stefan Dösinger762af472006-12-19 23:00:58 +0100[diff] [blame]3439 { /*4, 01, WINED3DTSS_COLOROP */ STATE_TEXTURESTAGE(4, WINED3DTSS_COLOROP), tex_colorop },
3440 { /*4, 02, WINED3DTSS_COLORARG1 */ STATE_TEXTURESTAGE(4, WINED3DTSS_COLOROP), tex_colorop },
3441 { /*4, 03, WINED3DTSS_COLORARG2 */ STATE_TEXTURESTAGE(4, WINED3DTSS_COLOROP), tex_colorop },
Stefan Dösingerbd6a6ad2006-12-19 23:03:37 +0100[diff] [blame]3442 { /*4, 04, WINED3DTSS_ALPHAOP */ STATE_TEXTURESTAGE(4, WINED3DTSS_ALPHAOP), tex_alphaop },
3443 { /*4, 05, WINED3DTSS_ALPHAARG1 */ STATE_TEXTURESTAGE(4, WINED3DTSS_ALPHAOP), tex_alphaop },
3444 { /*4, 06, WINED3DTSS_ALPHAARG2 */ STATE_TEXTURESTAGE(4, WINED3DTSS_ALPHAOP), tex_alphaop },
Stefan Dösingerefbd6d62007-02-15 02:57:49 +0100[diff] [blame]3445 { /*4, 07, WINED3DTSS_BUMPENVMAT00 */ STATE_TEXTURESTAGE(4, WINED3DTSS_BUMPENVMAT00), tex_bumpenvmat },
3446 { /*4, 08, WINED3DTSS_BUMPENVMAT01 */ STATE_TEXTURESTAGE(4, WINED3DTSS_BUMPENVMAT00), tex_bumpenvmat },
3447 { /*4, 09, WINED3DTSS_BUMPENVMAT10 */ STATE_TEXTURESTAGE(4, WINED3DTSS_BUMPENVMAT00), tex_bumpenvmat },
3448 { /*4, 10, WINED3DTSS_BUMPENVMAT11 */ STATE_TEXTURESTAGE(4, WINED3DTSS_BUMPENVMAT00), tex_bumpenvmat },
Stefan Dösinger4e531402006-12-19 23:04:16 +0100[diff] [blame]3449 { /*4, 11, WINED3DTSS_TEXCOORDINDEX */ STATE_TEXTURESTAGE(4, WINED3DTSS_TEXCOORDINDEX), tex_coordindex },
Stefan Dösinger569a2fa2006-12-19 22:43:49 +0100[diff] [blame]3450 { /*4, 12, WINED3DTSS_ADDRESS */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
3451 { /*4, 13, WINED3DTSS_ADDRESSU */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
3452 { /*4, 14, WINED3DTSS_ADDRESSV */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
3453 { /*4, 15, WINED3DTSS_BORDERCOLOR */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
3454 { /*4, 16, WINED3DTSS_MAGFILTER */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
3455 { /*4, 17, WINED3DTSS_MINFILTER */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
3456 { /*4, 18, WINED3DTSS_MIPFILTER */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
3457 { /*4, 19, WINED3DTSS_MIPMAPLODBIAS */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
3458 { /*4, 20, WINED3DTSS_MAXMIPLEVEL */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
3459 { /*4, 21, WINED3DTSS_MAXANISOTROPY */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
Stefan Dösinger72a4f6e2006-12-19 23:05:08 +0100[diff] [blame]3460 { /*4, 22, WINED3DTSS_BUMPENVLSCALE */ STATE_TEXTURESTAGE(4, WINED3DTSS_BUMPENVLSCALE), tex_bumpenvlscale },
Stefan Dösinger1021f642006-12-19 23:34:17 +0100[diff] [blame]3461 { /*4, 23, WINED3DTSS_BUMPENVLOFFSET */ STATE_TEXTURESTAGE(4, WINED3DTSS_BUMPENVLOFFSET), tex_bumpenvloffset },
Stefan Dösingerc10efb32007-01-01 23:53:59 +0100[diff] [blame]3462 { /*4, 24, WINED3DTSS_TEXTURETRANSFORMFLAGS */ STATE_TRANSFORM(WINED3DTS_TEXTURE4), transform_texture },
Stefan Dösinger569a2fa2006-12-19 22:43:49 +0100[diff] [blame]3463 { /*4, 25, WINED3DTSS_ADDRESSW */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
Stefan Dösinger762af472006-12-19 23:00:58 +0100[diff] [blame]3464 { /*4, 26, WINED3DTSS_COLORARG0 */ STATE_TEXTURESTAGE(4, WINED3DTSS_COLOROP), tex_colorop },
Stefan Dösingerbd6a6ad2006-12-19 23:03:37 +0100[diff] [blame]3465 { /*4, 27, WINED3DTSS_ALPHAARG0 */ STATE_TEXTURESTAGE(4, WINED3DTSS_ALPHAOP), tex_alphaop },
Stefan Dösinger63a8c3c2006-12-19 23:11:21 +0100[diff] [blame]3466 { /*4, 28, WINED3DTSS_RESULTARG */ STATE_TEXTURESTAGE(4, WINED3DTSS_RESULTARG), tex_resultarg },
Stefan Dösinger569a2fa2006-12-19 22:43:49 +0100[diff] [blame]3467 { /*4, 29, undefined */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
3468 { /*4, 30, undefined */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
3469 { /*4, 31, undefined */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
Stefan Dösinger557b1fa2006-12-19 23:11:28 +0100[diff] [blame]3470 { /*4, 32, WINED3DTSS_CONSTANT */ 0 /* As long as we don't support D3DTA_CONSTANT */, state_nogl },
Stefan Dösinger569a2fa2006-12-19 22:43:49 +0100[diff] [blame]3471
Stefan Dösinger762af472006-12-19 23:00:58 +0100[diff] [blame]3472 { /*5, 01, WINED3DTSS_COLOROP */ STATE_TEXTURESTAGE(5, WINED3DTSS_COLOROP), tex_colorop },
3473 { /*5, 02, WINED3DTSS_COLORARG1 */ STATE_TEXTURESTAGE(5, WINED3DTSS_COLOROP), tex_colorop },
3474 { /*5, 03, WINED3DTSS_COLORARG2 */ STATE_TEXTURESTAGE(5, WINED3DTSS_COLOROP), tex_colorop },
Stefan Dösingerbd6a6ad2006-12-19 23:03:37 +0100[diff] [blame]3475 { /*5, 04, WINED3DTSS_ALPHAOP */ STATE_TEXTURESTAGE(5, WINED3DTSS_ALPHAOP), tex_alphaop },
3476 { /*5, 05, WINED3DTSS_ALPHAARG1 */ STATE_TEXTURESTAGE(5, WINED3DTSS_ALPHAOP), tex_alphaop },
3477 { /*5, 06, WINED3DTSS_ALPHAARG2 */ STATE_TEXTURESTAGE(5, WINED3DTSS_ALPHAOP), tex_alphaop },
Stefan Dösingerefbd6d62007-02-15 02:57:49 +0100[diff] [blame]3478 { /*5, 07, WINED3DTSS_BUMPENVMAT00 */ STATE_TEXTURESTAGE(5, WINED3DTSS_BUMPENVMAT00), tex_bumpenvmat },
3479 { /*5, 08, WINED3DTSS_BUMPENVMAT01 */ STATE_TEXTURESTAGE(5, WINED3DTSS_BUMPENVMAT00), tex_bumpenvmat },
3480 { /*5, 09, WINED3DTSS_BUMPENVMAT10 */ STATE_TEXTURESTAGE(5, WINED3DTSS_BUMPENVMAT00), tex_bumpenvmat },
3481 { /*5, 10, WINED3DTSS_BUMPENVMAT11 */ STATE_TEXTURESTAGE(5, WINED3DTSS_BUMPENVMAT00), tex_bumpenvmat },
Stefan Dösinger4e531402006-12-19 23:04:16 +0100[diff] [blame]3482 { /*5, 11, WINED3DTSS_TEXCOORDINDEX */ STATE_TEXTURESTAGE(5, WINED3DTSS_TEXCOORDINDEX), tex_coordindex },
Stefan Dösinger569a2fa2006-12-19 22:43:49 +0100[diff] [blame]3483 { /*5, 12, WINED3DTSS_ADDRESS */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
3484 { /*5, 13, WINED3DTSS_ADDRESSU */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
3485 { /*5, 14, WINED3DTSS_ADDRESSV */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
3486 { /*5, 15, WINED3DTSS_BORDERCOLOR */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
3487 { /*5, 16, WINED3DTSS_MAGFILTER */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
3488 { /*5, 17, WINED3DTSS_MINFILTER */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
3489 { /*5, 18, WINED3DTSS_MIPFILTER */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
3490 { /*5, 19, WINED3DTSS_MIPMAPLODBIAS */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
3491 { /*5, 20, WINED3DTSS_MAXMIPLEVEL */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
3492 { /*5, 21, WINED3DTSS_MAXANISOTROPY */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
Stefan Dösinger72a4f6e2006-12-19 23:05:08 +0100[diff] [blame]3493 { /*5, 22, WINED3DTSS_BUMPENVLSCALE */ STATE_TEXTURESTAGE(5, WINED3DTSS_BUMPENVLSCALE), tex_bumpenvlscale },
Stefan Dösinger1021f642006-12-19 23:34:17 +0100[diff] [blame]3494 { /*5, 23, WINED3DTSS_BUMPENVLOFFSET */ STATE_TEXTURESTAGE(5, WINED3DTSS_BUMPENVLOFFSET), tex_bumpenvloffset },
Stefan Dösingerc10efb32007-01-01 23:53:59 +0100[diff] [blame]3495 { /*5, 24, WINED3DTSS_TEXTURETRANSFORMFLAGS */ STATE_TRANSFORM(WINED3DTS_TEXTURE5), transform_texture },
Stefan Dösinger569a2fa2006-12-19 22:43:49 +0100[diff] [blame]3496 { /*5, 25, WINED3DTSS_ADDRESSW */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
Stefan Dösinger762af472006-12-19 23:00:58 +0100[diff] [blame]3497 { /*5, 26, WINED3DTSS_COLORARG0 */ STATE_TEXTURESTAGE(5, WINED3DTSS_COLOROP), tex_colorop },
Stefan Dösingerbd6a6ad2006-12-19 23:03:37 +0100[diff] [blame]3498 { /*5, 27, WINED3DTSS_ALPHAARG0 */ STATE_TEXTURESTAGE(5, WINED3DTSS_ALPHAOP), tex_alphaop },
Stefan Dösinger63a8c3c2006-12-19 23:11:21 +0100[diff] [blame]3499 { /*5, 28, WINED3DTSS_RESULTARG */ STATE_TEXTURESTAGE(5, WINED3DTSS_RESULTARG), tex_resultarg },
Stefan Dösinger569a2fa2006-12-19 22:43:49 +0100[diff] [blame]3500 { /*5, 29, undefined */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
3501 { /*5, 30, undefined */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
3502 { /*5, 31, undefined */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
Stefan Dösinger557b1fa2006-12-19 23:11:28 +0100[diff] [blame]3503 { /*5, 32, WINED3DTSS_CONSTANT */ 0 /* As long as we don't support D3DTA_CONSTANT */, state_nogl },
Stefan Dösinger569a2fa2006-12-19 22:43:49 +0100[diff] [blame]3504
Stefan Dösinger762af472006-12-19 23:00:58 +0100[diff] [blame]3505 { /*6, 01, WINED3DTSS_COLOROP */ STATE_TEXTURESTAGE(6, WINED3DTSS_COLOROP), tex_colorop },
3506 { /*6, 02, WINED3DTSS_COLORARG1 */ STATE_TEXTURESTAGE(6, WINED3DTSS_COLOROP), tex_colorop },
3507 { /*6, 03, WINED3DTSS_COLORARG2 */ STATE_TEXTURESTAGE(6, WINED3DTSS_COLOROP), tex_colorop },
Stefan Dösingerbd6a6ad2006-12-19 23:03:37 +0100[diff] [blame]3508 { /*6, 04, WINED3DTSS_ALPHAOP */ STATE_TEXTURESTAGE(6, WINED3DTSS_ALPHAOP), tex_alphaop },
3509 { /*6, 05, WINED3DTSS_ALPHAARG1 */ STATE_TEXTURESTAGE(6, WINED3DTSS_ALPHAOP), tex_alphaop },
3510 { /*6, 06, WINED3DTSS_ALPHAARG2 */ STATE_TEXTURESTAGE(6, WINED3DTSS_ALPHAOP), tex_alphaop },
Stefan Dösingerefbd6d62007-02-15 02:57:49 +0100[diff] [blame]3511 { /*6, 07, WINED3DTSS_BUMPENVMAT00 */ STATE_TEXTURESTAGE(6, WINED3DTSS_BUMPENVMAT00), tex_bumpenvmat },
3512 { /*6, 08, WINED3DTSS_BUMPENVMAT01 */ STATE_TEXTURESTAGE(6, WINED3DTSS_BUMPENVMAT00), tex_bumpenvmat },
3513 { /*6, 09, WINED3DTSS_BUMPENVMAT10 */ STATE_TEXTURESTAGE(6, WINED3DTSS_BUMPENVMAT00), tex_bumpenvmat },
3514 { /*6, 10, WINED3DTSS_BUMPENVMAT11 */ STATE_TEXTURESTAGE(6, WINED3DTSS_BUMPENVMAT00), tex_bumpenvmat },
Stefan Dösinger4e531402006-12-19 23:04:16 +0100[diff] [blame]3515 { /*6, 11, WINED3DTSS_TEXCOORDINDEX */ STATE_TEXTURESTAGE(6, WINED3DTSS_TEXCOORDINDEX), tex_coordindex },
Stefan Dösinger569a2fa2006-12-19 22:43:49 +0100[diff] [blame]3516 { /*6, 12, WINED3DTSS_ADDRESS */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
3517 { /*6, 13, WINED3DTSS_ADDRESSU */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
3518 { /*6, 14, WINED3DTSS_ADDRESSV */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
3519 { /*6, 15, WINED3DTSS_BORDERCOLOR */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
3520 { /*6, 16, WINED3DTSS_MAGFILTER */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
3521 { /*6, 17, WINED3DTSS_MINFILTER */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
3522 { /*6, 18, WINED3DTSS_MIPFILTER */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
3523 { /*6, 19, WINED3DTSS_MIPMAPLODBIAS */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
3524 { /*6, 20, WINED3DTSS_MAXMIPLEVEL */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
3525 { /*6, 21, WINED3DTSS_MAXANISOTROPY */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
Stefan Dösinger72a4f6e2006-12-19 23:05:08 +0100[diff] [blame]3526 { /*6, 22, WINED3DTSS_BUMPENVLSCALE */ STATE_TEXTURESTAGE(6, WINED3DTSS_BUMPENVLSCALE), tex_bumpenvlscale },
Stefan Dösinger1021f642006-12-19 23:34:17 +0100[diff] [blame]3527 { /*6, 23, WINED3DTSS_BUMPENVLOFFSET */ STATE_TEXTURESTAGE(6, WINED3DTSS_BUMPENVLOFFSET), tex_bumpenvloffset },
Stefan Dösingerc10efb32007-01-01 23:53:59 +0100[diff] [blame]3528 { /*6, 24, WINED3DTSS_TEXTURETRANSFORMFLAGS */ STATE_TRANSFORM(WINED3DTS_TEXTURE6), transform_texture },
Stefan Dösinger569a2fa2006-12-19 22:43:49 +0100[diff] [blame]3529 { /*6, 25, WINED3DTSS_ADDRESSW */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
Stefan Dösinger762af472006-12-19 23:00:58 +0100[diff] [blame]3530 { /*6, 26, WINED3DTSS_COLORARG0 */ STATE_TEXTURESTAGE(6, WINED3DTSS_COLOROP), tex_colorop },
Stefan Dösingerbd6a6ad2006-12-19 23:03:37 +0100[diff] [blame]3531 { /*6, 27, WINED3DTSS_ALPHAARG0 */ STATE_TEXTURESTAGE(6, WINED3DTSS_ALPHAOP), tex_alphaop },
Stefan Dösinger63a8c3c2006-12-19 23:11:21 +0100[diff] [blame]3532 { /*6, 28, WINED3DTSS_RESULTARG */ STATE_TEXTURESTAGE(6, WINED3DTSS_RESULTARG), tex_resultarg },
Stefan Dösinger569a2fa2006-12-19 22:43:49 +0100[diff] [blame]3533 { /*6, 29, undefined */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
3534 { /*6, 30, undefined */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
3535 { /*6, 31, undefined */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
Stefan Dösinger557b1fa2006-12-19 23:11:28 +0100[diff] [blame]3536 { /*6, 32, WINED3DTSS_CONSTANT */ 0 /* As long as we don't support D3DTA_CONSTANT */, state_nogl },
Stefan Dösinger569a2fa2006-12-19 22:43:49 +0100[diff] [blame]3537
Stefan Dösinger762af472006-12-19 23:00:58 +0100[diff] [blame]3538 { /*7, 01, WINED3DTSS_COLOROP */ STATE_TEXTURESTAGE(7, WINED3DTSS_COLOROP), tex_colorop },
3539 { /*7, 02, WINED3DTSS_COLORARG1 */ STATE_TEXTURESTAGE(7, WINED3DTSS_COLOROP), tex_colorop },
3540 { /*7, 03, WINED3DTSS_COLORARG2 */ STATE_TEXTURESTAGE(7, WINED3DTSS_COLOROP), tex_colorop },
Stefan Dösingerbd6a6ad2006-12-19 23:03:37 +0100[diff] [blame]3541 { /*7, 04, WINED3DTSS_ALPHAOP */ STATE_TEXTURESTAGE(7, WINED3DTSS_ALPHAOP), tex_alphaop },
3542 { /*7, 05, WINED3DTSS_ALPHAARG1 */ STATE_TEXTURESTAGE(7, WINED3DTSS_ALPHAOP), tex_alphaop },
3543 { /*7, 06, WINED3DTSS_ALPHAARG2 */ STATE_TEXTURESTAGE(7, WINED3DTSS_ALPHAOP), tex_alphaop },
Stefan Dösingerefbd6d62007-02-15 02:57:49 +0100[diff] [blame]3544 { /*7, 07, WINED3DTSS_BUMPENVMAT00 */ STATE_TEXTURESTAGE(7, WINED3DTSS_BUMPENVMAT00), tex_bumpenvmat },
3545 { /*7, 08, WINED3DTSS_BUMPENVMAT01 */ STATE_TEXTURESTAGE(7, WINED3DTSS_BUMPENVMAT00), tex_bumpenvmat },
3546 { /*7, 09, WINED3DTSS_BUMPENVMAT10 */ STATE_TEXTURESTAGE(7, WINED3DTSS_BUMPENVMAT00), tex_bumpenvmat },
3547 { /*7, 10, WINED3DTSS_BUMPENVMAT11 */ STATE_TEXTURESTAGE(7, WINED3DTSS_BUMPENVMAT00), tex_bumpenvmat },
Stefan Dösinger4e531402006-12-19 23:04:16 +0100[diff] [blame]3548 { /*7, 11, WINED3DTSS_TEXCOORDINDEX */ STATE_TEXTURESTAGE(7, WINED3DTSS_TEXCOORDINDEX), tex_coordindex },
Stefan Dösinger569a2fa2006-12-19 22:43:49 +0100[diff] [blame]3549 { /*7, 12, WINED3DTSS_ADDRESS */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
3550 { /*7, 13, WINED3DTSS_ADDRESSU */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
3551 { /*7, 14, WINED3DTSS_ADDRESSV */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
3552 { /*7, 15, WINED3DTSS_BORDERCOLOR */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
3553 { /*7, 16, WINED3DTSS_MAGFILTER */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
3554 { /*7, 17, WINED3DTSS_MINFILTER */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
3555 { /*7, 18, WINED3DTSS_MIPFILTER */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
3556 { /*7, 19, WINED3DTSS_MIPMAPLODBIAS */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
3557 { /*7, 20, WINED3DTSS_MAXMIPLEVEL */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
3558 { /*7, 21, WINED3DTSS_MAXANISOTROPY */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
Stefan Dösinger72a4f6e2006-12-19 23:05:08 +0100[diff] [blame]3559 { /*7, 22, WINED3DTSS_BUMPENVLSCALE */ STATE_TEXTURESTAGE(7, WINED3DTSS_BUMPENVLSCALE), tex_bumpenvlscale },
Stefan Dösinger1021f642006-12-19 23:34:17 +0100[diff] [blame]3560 { /*7, 23, WINED3DTSS_BUMPENVLOFFSET */ STATE_TEXTURESTAGE(7, WINED3DTSS_BUMPENVLOFFSET), tex_bumpenvloffset },
Stefan Dösingerc10efb32007-01-01 23:53:59 +0100[diff] [blame]3561 { /*7, 24, WINED3DTSS_TEXTURETRANSFORMFLAGS */ STATE_TRANSFORM(WINED3DTS_TEXTURE7), transform_texture },
Stefan Dösinger569a2fa2006-12-19 22:43:49 +0100[diff] [blame]3562 { /*7, 25, WINED3DTSS_ADDRESSW */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
Stefan Dösinger762af472006-12-19 23:00:58 +0100[diff] [blame]3563 { /*7, 26, WINED3DTSS_COLORARG0 */ STATE_TEXTURESTAGE(7, WINED3DTSS_COLOROP), tex_colorop },
Stefan Dösingerbd6a6ad2006-12-19 23:03:37 +0100[diff] [blame]3564 { /*7, 27, WINED3DTSS_ALPHAARG0 */ STATE_TEXTURESTAGE(7, WINED3DTSS_ALPHAOP), tex_alphaop },
Stefan Dösinger63a8c3c2006-12-19 23:11:21 +0100[diff] [blame]3565 { /*7, 28, WINED3DTSS_RESULTARG */ STATE_TEXTURESTAGE(7, WINED3DTSS_RESULTARG), tex_resultarg },
Stefan Dösinger569a2fa2006-12-19 22:43:49 +0100[diff] [blame]3566 { /*7, 29, undefined */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
3567 { /*7, 30, undefined */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
3568 { /*7, 31, undefined */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
Stefan Dösinger557b1fa2006-12-19 23:11:28 +0100[diff] [blame]3569 { /*7, 32, WINED3DTSS_CONSTANT */ 0 /* As long as we don't support D3DTA_CONSTANT */, state_nogl },
Stefan Dösinger2d1aeb42006-12-19 23:14:07 +0100[diff] [blame]3570 /* Sampler states */
Stefan Dösinger666b5072006-12-19 23:26:39 +0100[diff] [blame]3571 { /* 0, Sampler 0 */ STATE_SAMPLER(0), sampler },
3572 { /* 1, Sampler 1 */ STATE_SAMPLER(1), sampler },
3573 { /* 2, Sampler 2 */ STATE_SAMPLER(2), sampler },
3574 { /* 3, Sampler 3 */ STATE_SAMPLER(3), sampler },
3575 { /* 4, Sampler 3 */ STATE_SAMPLER(4), sampler },
3576 { /* 5, Sampler 5 */ STATE_SAMPLER(5), sampler },
3577 { /* 6, Sampler 6 */ STATE_SAMPLER(6), sampler },
3578 { /* 7, Sampler 7 */ STATE_SAMPLER(7), sampler },
3579 { /* 8, Sampler 8 */ STATE_SAMPLER(8), sampler },
3580 { /* 9, Sampler 9 */ STATE_SAMPLER(9), sampler },
3581 { /*10, Sampler 10 */ STATE_SAMPLER(10), sampler },
3582 { /*11, Sampler 11 */ STATE_SAMPLER(11), sampler },
3583 { /*12, Sampler 12 */ STATE_SAMPLER(12), sampler },
3584 { /*13, Sampler 13 */ STATE_SAMPLER(13), sampler },
3585 { /*14, Sampler 14 */ STATE_SAMPLER(14), sampler },
3586 { /*15, Sampler 15 */ STATE_SAMPLER(15), sampler },
Stefan Dösinger22e2a5a2006-12-19 23:22:19 +0100[diff] [blame]3587 /* Pixel shader */
3588 { /* , Pixel Shader */ STATE_PIXELSHADER, pixelshader },
Stefan Dösingerb58715e2006-12-28 18:57:16 +0100[diff] [blame]3589 /* Transform states follow */
3590 { /* 1, undefined */ 0, state_undefined },
Stefan Dösingerf5fafab2007-01-02 00:48:58 +0100[diff] [blame]3591 { /* 2, WINED3DTS_VIEW */ STATE_TRANSFORM(WINED3DTS_VIEW), transform_view },
Stefan Dösinger82bd0792007-01-02 22:50:38 +0100[diff] [blame]3592 { /* 3, WINED3DTS_PROJECTION */ STATE_TRANSFORM(WINED3DTS_PROJECTION), transform_projection},
Stefan Dösingerb58715e2006-12-28 18:57:16 +0100[diff] [blame]3593 { /* 4, undefined */ 0, state_undefined },
3594 { /* 5, undefined */ 0, state_undefined },
3595 { /* 6, undefined */ 0, state_undefined },
3596 { /* 7, undefined */ 0, state_undefined },
3597 { /* 8, undefined */ 0, state_undefined },
3598 { /* 9, undefined */ 0, state_undefined },
3599 { /* 10, undefined */ 0, state_undefined },
3600 { /* 11, undefined */ 0, state_undefined },
3601 { /* 12, undefined */ 0, state_undefined },
3602 { /* 13, undefined */ 0, state_undefined },
3603 { /* 14, undefined */ 0, state_undefined },
3604 { /* 15, undefined */ 0, state_undefined },
Stefan Dösingerc10efb32007-01-01 23:53:59 +0100[diff] [blame]3605 { /* 16, WINED3DTS_TEXTURE0 */ STATE_TRANSFORM(WINED3DTS_TEXTURE0), transform_texture },
3606 { /* 17, WINED3DTS_TEXTURE1 */ STATE_TRANSFORM(WINED3DTS_TEXTURE1), transform_texture },
3607 { /* 18, WINED3DTS_TEXTURE2 */ STATE_TRANSFORM(WINED3DTS_TEXTURE2), transform_texture },
3608 { /* 19, WINED3DTS_TEXTURE3 */ STATE_TRANSFORM(WINED3DTS_TEXTURE3), transform_texture },
3609 { /* 20, WINED3DTS_TEXTURE4 */ STATE_TRANSFORM(WINED3DTS_TEXTURE4), transform_texture },
3610 { /* 21, WINED3DTS_TEXTURE5 */ STATE_TRANSFORM(WINED3DTS_TEXTURE5), transform_texture },
3611 { /* 22, WINED3DTS_TEXTURE6 */ STATE_TRANSFORM(WINED3DTS_TEXTURE6), transform_texture },
3612 { /* 23, WINED3DTS_TEXTURE7 */ STATE_TRANSFORM(WINED3DTS_TEXTURE7), transform_texture },
Stefan Dösingerb58715e2006-12-28 18:57:16 +0100[diff] [blame]3613 /* A huge gap between TEXTURE7 and WORLDMATRIX(0) :-( But entries are needed to catch then if a broken app sets them */
3614 { /* 24, undefined */ 0, state_undefined },
3615 { /* 25, undefined */ 0, state_undefined },
3616 { /* 26, undefined */ 0, state_undefined },
3617 { /* 27, undefined */ 0, state_undefined },
3618 { /* 28, undefined */ 0, state_undefined },
3619 { /* 29, undefined */ 0, state_undefined },
3620 { /* 30, undefined */ 0, state_undefined },
3621 { /* 31, undefined */ 0, state_undefined },
3622 { /* 32, undefined */ 0, state_undefined },
3623 { /* 33, undefined */ 0, state_undefined },
3624 { /* 34, undefined */ 0, state_undefined },
3625 { /* 35, undefined */ 0, state_undefined },
3626 { /* 36, undefined */ 0, state_undefined },
3627 { /* 37, undefined */ 0, state_undefined },
3628 { /* 38, undefined */ 0, state_undefined },
3629 { /* 39, undefined */ 0, state_undefined },
3630 { /* 40, undefined */ 0, state_undefined },
3631 { /* 41, undefined */ 0, state_undefined },
3632 { /* 42, undefined */ 0, state_undefined },
3633 { /* 43, undefined */ 0, state_undefined },
3634 { /* 44, undefined */ 0, state_undefined },
3635 { /* 45, undefined */ 0, state_undefined },
3636 { /* 46, undefined */ 0, state_undefined },
3637 { /* 47, undefined */ 0, state_undefined },
3638 { /* 48, undefined */ 0, state_undefined },
3639 { /* 49, undefined */ 0, state_undefined },
3640 { /* 50, undefined */ 0, state_undefined },
3641 { /* 51, undefined */ 0, state_undefined },
3642 { /* 52, undefined */ 0, state_undefined },
3643 { /* 53, undefined */ 0, state_undefined },
3644 { /* 54, undefined */ 0, state_undefined },
3645 { /* 55, undefined */ 0, state_undefined },
3646 { /* 56, undefined */ 0, state_undefined },
3647 { /* 57, undefined */ 0, state_undefined },
3648 { /* 58, undefined */ 0, state_undefined },
3649 { /* 59, undefined */ 0, state_undefined },
3650 { /* 60, undefined */ 0, state_undefined },
3651 { /* 61, undefined */ 0, state_undefined },
3652 { /* 62, undefined */ 0, state_undefined },
3653 { /* 63, undefined */ 0, state_undefined },
3654 { /* 64, undefined */ 0, state_undefined },
3655 { /* 65, undefined */ 0, state_undefined },
3656 { /* 66, undefined */ 0, state_undefined },
3657 { /* 67, undefined */ 0, state_undefined },
3658 { /* 68, undefined */ 0, state_undefined },
3659 { /* 69, undefined */ 0, state_undefined },
3660 { /* 70, undefined */ 0, state_undefined },
3661 { /* 71, undefined */ 0, state_undefined },
3662 { /* 72, undefined */ 0, state_undefined },
3663 { /* 73, undefined */ 0, state_undefined },
3664 { /* 74, undefined */ 0, state_undefined },
3665 { /* 75, undefined */ 0, state_undefined },
3666 { /* 76, undefined */ 0, state_undefined },
3667 { /* 77, undefined */ 0, state_undefined },
3668 { /* 78, undefined */ 0, state_undefined },
3669 { /* 79, undefined */ 0, state_undefined },
3670 { /* 80, undefined */ 0, state_undefined },
3671 { /* 81, undefined */ 0, state_undefined },
3672 { /* 82, undefined */ 0, state_undefined },
3673 { /* 83, undefined */ 0, state_undefined },
3674 { /* 84, undefined */ 0, state_undefined },
3675 { /* 85, undefined */ 0, state_undefined },
3676 { /* 86, undefined */ 0, state_undefined },
3677 { /* 87, undefined */ 0, state_undefined },
3678 { /* 88, undefined */ 0, state_undefined },
3679 { /* 89, undefined */ 0, state_undefined },
3680 { /* 90, undefined */ 0, state_undefined },
3681 { /* 91, undefined */ 0, state_undefined },
3682 { /* 92, undefined */ 0, state_undefined },
3683 { /* 93, undefined */ 0, state_undefined },
3684 { /* 94, undefined */ 0, state_undefined },
3685 { /* 95, undefined */ 0, state_undefined },
3686 { /* 96, undefined */ 0, state_undefined },
3687 { /* 97, undefined */ 0, state_undefined },
3688 { /* 98, undefined */ 0, state_undefined },
3689 { /* 99, undefined */ 0, state_undefined },
3690 { /*100, undefined */ 0, state_undefined },
3691 { /*101, undefined */ 0, state_undefined },
3692 { /*102, undefined */ 0, state_undefined },
3693 { /*103, undefined */ 0, state_undefined },
3694 { /*104, undefined */ 0, state_undefined },
3695 { /*105, undefined */ 0, state_undefined },
3696 { /*106, undefined */ 0, state_undefined },
3697 { /*107, undefined */ 0, state_undefined },
3698 { /*108, undefined */ 0, state_undefined },
3699 { /*109, undefined */ 0, state_undefined },
3700 { /*110, undefined */ 0, state_undefined },
3701 { /*111, undefined */ 0, state_undefined },
3702 { /*112, undefined */ 0, state_undefined },
3703 { /*113, undefined */ 0, state_undefined },
3704 { /*114, undefined */ 0, state_undefined },
3705 { /*115, undefined */ 0, state_undefined },
3706 { /*116, undefined */ 0, state_undefined },
3707 { /*117, undefined */ 0, state_undefined },
3708 { /*118, undefined */ 0, state_undefined },
3709 { /*119, undefined */ 0, state_undefined },
3710 { /*120, undefined */ 0, state_undefined },
3711 { /*121, undefined */ 0, state_undefined },
3712 { /*122, undefined */ 0, state_undefined },
3713 { /*123, undefined */ 0, state_undefined },
3714 { /*124, undefined */ 0, state_undefined },
3715 { /*125, undefined */ 0, state_undefined },
3716 { /*126, undefined */ 0, state_undefined },
3717 { /*127, undefined */ 0, state_undefined },
3718 { /*128, undefined */ 0, state_undefined },
3719 { /*129, undefined */ 0, state_undefined },
3720 { /*130, undefined */ 0, state_undefined },
3721 { /*131, undefined */ 0, state_undefined },
3722 { /*132, undefined */ 0, state_undefined },
3723 { /*133, undefined */ 0, state_undefined },
3724 { /*134, undefined */ 0, state_undefined },
3725 { /*135, undefined */ 0, state_undefined },
3726 { /*136, undefined */ 0, state_undefined },
3727 { /*137, undefined */ 0, state_undefined },
3728 { /*138, undefined */ 0, state_undefined },
3729 { /*139, undefined */ 0, state_undefined },
3730 { /*140, undefined */ 0, state_undefined },
3731 { /*141, undefined */ 0, state_undefined },
3732 { /*142, undefined */ 0, state_undefined },
3733 { /*143, undefined */ 0, state_undefined },
3734 { /*144, undefined */ 0, state_undefined },
3735 { /*145, undefined */ 0, state_undefined },
3736 { /*146, undefined */ 0, state_undefined },
3737 { /*147, undefined */ 0, state_undefined },
3738 { /*148, undefined */ 0, state_undefined },
3739 { /*149, undefined */ 0, state_undefined },
3740 { /*150, undefined */ 0, state_undefined },
3741 { /*151, undefined */ 0, state_undefined },
3742 { /*152, undefined */ 0, state_undefined },
3743 { /*153, undefined */ 0, state_undefined },
3744 { /*154, undefined */ 0, state_undefined },
3745 { /*155, undefined */ 0, state_undefined },
3746 { /*156, undefined */ 0, state_undefined },
3747 { /*157, undefined */ 0, state_undefined },
3748 { /*158, undefined */ 0, state_undefined },
3749 { /*159, undefined */ 0, state_undefined },
3750 { /*160, undefined */ 0, state_undefined },
3751 { /*161, undefined */ 0, state_undefined },
3752 { /*162, undefined */ 0, state_undefined },
3753 { /*163, undefined */ 0, state_undefined },
3754 { /*164, undefined */ 0, state_undefined },
3755 { /*165, undefined */ 0, state_undefined },
3756 { /*166, undefined */ 0, state_undefined },
3757 { /*167, undefined */ 0, state_undefined },
3758 { /*168, undefined */ 0, state_undefined },
3759 { /*169, undefined */ 0, state_undefined },
3760 { /*170, undefined */ 0, state_undefined },
3761 { /*171, undefined */ 0, state_undefined },
3762 { /*172, undefined */ 0, state_undefined },
3763 { /*173, undefined */ 0, state_undefined },
3764 { /*174, undefined */ 0, state_undefined },
3765 { /*175, undefined */ 0, state_undefined },
3766 { /*176, undefined */ 0, state_undefined },
3767 { /*177, undefined */ 0, state_undefined },
3768 { /*178, undefined */ 0, state_undefined },
3769 { /*179, undefined */ 0, state_undefined },
3770 { /*180, undefined */ 0, state_undefined },
3771 { /*181, undefined */ 0, state_undefined },
3772 { /*182, undefined */ 0, state_undefined },
3773 { /*183, undefined */ 0, state_undefined },
3774 { /*184, undefined */ 0, state_undefined },
3775 { /*185, undefined */ 0, state_undefined },
3776 { /*186, undefined */ 0, state_undefined },
3777 { /*187, undefined */ 0, state_undefined },
3778 { /*188, undefined */ 0, state_undefined },
3779 { /*189, undefined */ 0, state_undefined },
3780 { /*190, undefined */ 0, state_undefined },
3781 { /*191, undefined */ 0, state_undefined },
3782 { /*192, undefined */ 0, state_undefined },
3783 { /*193, undefined */ 0, state_undefined },
3784 { /*194, undefined */ 0, state_undefined },
3785 { /*195, undefined */ 0, state_undefined },
3786 { /*196, undefined */ 0, state_undefined },
3787 { /*197, undefined */ 0, state_undefined },
3788 { /*198, undefined */ 0, state_undefined },
3789 { /*199, undefined */ 0, state_undefined },
3790 { /*200, undefined */ 0, state_undefined },
3791 { /*201, undefined */ 0, state_undefined },
3792 { /*202, undefined */ 0, state_undefined },
3793 { /*203, undefined */ 0, state_undefined },
3794 { /*204, undefined */ 0, state_undefined },
3795 { /*205, undefined */ 0, state_undefined },
3796 { /*206, undefined */ 0, state_undefined },
3797 { /*207, undefined */ 0, state_undefined },
3798 { /*208, undefined */ 0, state_undefined },
3799 { /*209, undefined */ 0, state_undefined },
3800 { /*210, undefined */ 0, state_undefined },
3801 { /*211, undefined */ 0, state_undefined },
3802 { /*212, undefined */ 0, state_undefined },
3803 { /*213, undefined */ 0, state_undefined },
3804 { /*214, undefined */ 0, state_undefined },
3805 { /*215, undefined */ 0, state_undefined },
3806 { /*216, undefined */ 0, state_undefined },
3807 { /*217, undefined */ 0, state_undefined },
3808 { /*218, undefined */ 0, state_undefined },
3809 { /*219, undefined */ 0, state_undefined },
3810 { /*220, undefined */ 0, state_undefined },
3811 { /*221, undefined */ 0, state_undefined },
3812 { /*222, undefined */ 0, state_undefined },
3813 { /*223, undefined */ 0, state_undefined },
3814 { /*224, undefined */ 0, state_undefined },
3815 { /*225, undefined */ 0, state_undefined },
3816 { /*226, undefined */ 0, state_undefined },
3817 { /*227, undefined */ 0, state_undefined },
3818 { /*228, undefined */ 0, state_undefined },
3819 { /*229, undefined */ 0, state_undefined },
3820 { /*230, undefined */ 0, state_undefined },
3821 { /*231, undefined */ 0, state_undefined },
3822 { /*232, undefined */ 0, state_undefined },
3823 { /*233, undefined */ 0, state_undefined },
3824 { /*234, undefined */ 0, state_undefined },
3825 { /*235, undefined */ 0, state_undefined },
3826 { /*236, undefined */ 0, state_undefined },
3827 { /*237, undefined */ 0, state_undefined },
3828 { /*238, undefined */ 0, state_undefined },
3829 { /*239, undefined */ 0, state_undefined },
3830 { /*240, undefined */ 0, state_undefined },
3831 { /*241, undefined */ 0, state_undefined },
3832 { /*242, undefined */ 0, state_undefined },
3833 { /*243, undefined */ 0, state_undefined },
3834 { /*244, undefined */ 0, state_undefined },
3835 { /*245, undefined */ 0, state_undefined },
3836 { /*246, undefined */ 0, state_undefined },
3837 { /*247, undefined */ 0, state_undefined },
3838 { /*248, undefined */ 0, state_undefined },
3839 { /*249, undefined */ 0, state_undefined },
3840 { /*250, undefined */ 0, state_undefined },
3841 { /*251, undefined */ 0, state_undefined },
3842 { /*252, undefined */ 0, state_undefined },
3843 { /*253, undefined */ 0, state_undefined },
3844 { /*254, undefined */ 0, state_undefined },
3845 { /*255, undefined */ 0, state_undefined },
3846 /* End huge gap */
Stefan Dösinger5fa0f7f2007-01-02 22:47:39 +0100[diff] [blame]3847 { /*256, WINED3DTS_WORLDMATRIX(0) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(0)), transform_world },
Stefan Dösingera710f722007-01-02 00:25:51 +0100[diff] [blame]3848 { /*257, WINED3DTS_WORLDMATRIX(1) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(1)), transform_worldex },
3849 { /*258, WINED3DTS_WORLDMATRIX(2) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(2)), transform_worldex },
3850 { /*259, WINED3DTS_WORLDMATRIX(3) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(3)), transform_worldex },
3851 { /*260, WINED3DTS_WORLDMATRIX(4) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(4)), transform_worldex },
3852 { /*261, WINED3DTS_WORLDMATRIX(5) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(5)), transform_worldex },
3853 { /*262, WINED3DTS_WORLDMATRIX(6) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(6)), transform_worldex },
3854 { /*263, WINED3DTS_WORLDMATRIX(7) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(7)), transform_worldex },
3855 { /*264, WINED3DTS_WORLDMATRIX(8) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(8)), transform_worldex },
3856 { /*265, WINED3DTS_WORLDMATRIX(9) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(9)), transform_worldex },
3857 { /*266, WINED3DTS_WORLDMATRIX(10) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(10)), transform_worldex },
3858 { /*267, WINED3DTS_WORLDMATRIX(11) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(11)), transform_worldex },
3859 { /*268, WINED3DTS_WORLDMATRIX(12) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(12)), transform_worldex },
3860 { /*269, WINED3DTS_WORLDMATRIX(13) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(13)), transform_worldex },
3861 { /*270, WINED3DTS_WORLDMATRIX(14) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(14)), transform_worldex },
3862 { /*271, WINED3DTS_WORLDMATRIX(15) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(15)), transform_worldex },
3863 { /*272, WINED3DTS_WORLDMATRIX(16) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(16)), transform_worldex },
3864 { /*273, WINED3DTS_WORLDMATRIX(17) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(17)), transform_worldex },
3865 { /*274, WINED3DTS_WORLDMATRIX(18) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(18)), transform_worldex },
3866 { /*275, WINED3DTS_WORLDMATRIX(19) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(19)), transform_worldex },
3867 { /*276, WINED3DTS_WORLDMATRIX(20) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(20)), transform_worldex },
3868 { /*277, WINED3DTS_WORLDMATRIX(21) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(21)), transform_worldex },
3869 { /*278, WINED3DTS_WORLDMATRIX(22) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(22)), transform_worldex },
3870 { /*279, WINED3DTS_WORLDMATRIX(23) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(23)), transform_worldex },
3871 { /*280, WINED3DTS_WORLDMATRIX(24) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(24)), transform_worldex },
3872 { /*281, WINED3DTS_WORLDMATRIX(25) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(25)), transform_worldex },
3873 { /*282, WINED3DTS_WORLDMATRIX(26) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(26)), transform_worldex },
3874 { /*283, WINED3DTS_WORLDMATRIX(27) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(27)), transform_worldex },
3875 { /*284, WINED3DTS_WORLDMATRIX(28) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(28)), transform_worldex },
3876 { /*285, WINED3DTS_WORLDMATRIX(29) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(29)), transform_worldex },
3877 { /*286, WINED3DTS_WORLDMATRIX(30) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(30)), transform_worldex },
3878 { /*287, WINED3DTS_WORLDMATRIX(31) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(31)), transform_worldex },
3879 { /*288, WINED3DTS_WORLDMATRIX(32) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(32)), transform_worldex },
3880 { /*289, WINED3DTS_WORLDMATRIX(33) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(33)), transform_worldex },
3881 { /*290, WINED3DTS_WORLDMATRIX(34) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(34)), transform_worldex },
3882 { /*291, WINED3DTS_WORLDMATRIX(35) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(35)), transform_worldex },
3883 { /*292, WINED3DTS_WORLDMATRIX(36) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(36)), transform_worldex },
3884 { /*293, WINED3DTS_WORLDMATRIX(37) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(37)), transform_worldex },
3885 { /*294, WINED3DTS_WORLDMATRIX(38) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(38)), transform_worldex },
3886 { /*295, WINED3DTS_WORLDMATRIX(39) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(39)), transform_worldex },
3887 { /*296, WINED3DTS_WORLDMATRIX(40) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(40)), transform_worldex },
3888 { /*297, WINED3DTS_WORLDMATRIX(41) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(41)), transform_worldex },
3889 { /*298, WINED3DTS_WORLDMATRIX(42) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(42)), transform_worldex },
3890 { /*299, WINED3DTS_WORLDMATRIX(43) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(43)), transform_worldex },
3891 { /*300, WINED3DTS_WORLDMATRIX(44) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(44)), transform_worldex },
3892 { /*301, WINED3DTS_WORLDMATRIX(45) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(45)), transform_worldex },
3893 { /*302, WINED3DTS_WORLDMATRIX(46) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(46)), transform_worldex },
3894 { /*303, WINED3DTS_WORLDMATRIX(47) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(47)), transform_worldex },
3895 { /*304, WINED3DTS_WORLDMATRIX(48) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(48)), transform_worldex },
3896 { /*305, WINED3DTS_WORLDMATRIX(49) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(49)), transform_worldex },
3897 { /*306, WINED3DTS_WORLDMATRIX(50) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(50)), transform_worldex },
3898 { /*307, WINED3DTS_WORLDMATRIX(51) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(51)), transform_worldex },
3899 { /*308, WINED3DTS_WORLDMATRIX(52) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(52)), transform_worldex },
3900 { /*309, WINED3DTS_WORLDMATRIX(53) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(53)), transform_worldex },
3901 { /*310, WINED3DTS_WORLDMATRIX(54) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(54)), transform_worldex },
3902 { /*311, WINED3DTS_WORLDMATRIX(55) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(55)), transform_worldex },
3903 { /*312, WINED3DTS_WORLDMATRIX(56) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(56)), transform_worldex },
3904 { /*313, WINED3DTS_WORLDMATRIX(57) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(57)), transform_worldex },
3905 { /*314, WINED3DTS_WORLDMATRIX(58) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(58)), transform_worldex },
3906 { /*315, WINED3DTS_WORLDMATRIX(59) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(59)), transform_worldex },
3907 { /*316, WINED3DTS_WORLDMATRIX(60) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(60)), transform_worldex },
3908 { /*317, WINED3DTS_WORLDMATRIX(61) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(61)), transform_worldex },
3909 { /*318, WINED3DTS_WORLDMATRIX(62) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(62)), transform_worldex },
3910 { /*319, WINED3DTS_WORLDMATRIX(63) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(63)), transform_worldex },
3911 { /*320, WINED3DTS_WORLDMATRIX(64) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(64)), transform_worldex },
3912 { /*321, WINED3DTS_WORLDMATRIX(65) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(65)), transform_worldex },
3913 { /*322, WINED3DTS_WORLDMATRIX(66) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(66)), transform_worldex },
3914 { /*323, WINED3DTS_WORLDMATRIX(67) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(67)), transform_worldex },
3915 { /*324, WINED3DTS_WORLDMATRIX(68) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(68)), transform_worldex },
3916 { /*325, WINED3DTS_WORLDMATRIX(68) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(69)), transform_worldex },
3917 { /*326, WINED3DTS_WORLDMATRIX(70) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(70)), transform_worldex },
3918 { /*327, WINED3DTS_WORLDMATRIX(71) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(71)), transform_worldex },
3919 { /*328, WINED3DTS_WORLDMATRIX(72) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(72)), transform_worldex },
3920 { /*329, WINED3DTS_WORLDMATRIX(73) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(73)), transform_worldex },
3921 { /*330, WINED3DTS_WORLDMATRIX(74) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(74)), transform_worldex },
3922 { /*331, WINED3DTS_WORLDMATRIX(75) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(75)), transform_worldex },
3923 { /*332, WINED3DTS_WORLDMATRIX(76) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(76)), transform_worldex },
3924 { /*333, WINED3DTS_WORLDMATRIX(77) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(77)), transform_worldex },
3925 { /*334, WINED3DTS_WORLDMATRIX(78) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(78)), transform_worldex },
3926 { /*335, WINED3DTS_WORLDMATRIX(79) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(79)), transform_worldex },
3927 { /*336, WINED3DTS_WORLDMATRIX(80) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(80)), transform_worldex },
3928 { /*337, WINED3DTS_WORLDMATRIX(81) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(81)), transform_worldex },
3929 { /*338, WINED3DTS_WORLDMATRIX(82) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(82)), transform_worldex },
3930 { /*339, WINED3DTS_WORLDMATRIX(83) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(83)), transform_worldex },
3931 { /*340, WINED3DTS_WORLDMATRIX(84) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(84)), transform_worldex },
3932 { /*341, WINED3DTS_WORLDMATRIX(85) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(85)), transform_worldex },
3933 { /*341, WINED3DTS_WORLDMATRIX(86) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(86)), transform_worldex },
3934 { /*343, WINED3DTS_WORLDMATRIX(87) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(87)), transform_worldex },
3935 { /*344, WINED3DTS_WORLDMATRIX(88) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(88)), transform_worldex },
3936 { /*345, WINED3DTS_WORLDMATRIX(89) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(89)), transform_worldex },
3937 { /*346, WINED3DTS_WORLDMATRIX(90) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(90)), transform_worldex },
3938 { /*347, WINED3DTS_WORLDMATRIX(91) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(91)), transform_worldex },
3939 { /*348, WINED3DTS_WORLDMATRIX(92) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(92)), transform_worldex },
3940 { /*349, WINED3DTS_WORLDMATRIX(93) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(93)), transform_worldex },
3941 { /*350, WINED3DTS_WORLDMATRIX(94) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(94)), transform_worldex },
3942 { /*351, WINED3DTS_WORLDMATRIX(95) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(95)), transform_worldex },
3943 { /*352, WINED3DTS_WORLDMATRIX(96) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(96)), transform_worldex },
3944 { /*353, WINED3DTS_WORLDMATRIX(97) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(97)), transform_worldex },
3945 { /*354, WINED3DTS_WORLDMATRIX(98) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(98)), transform_worldex },
3946 { /*355, WINED3DTS_WORLDMATRIX(99) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(99)), transform_worldex },
3947 { /*356, WINED3DTS_WORLDMATRIX(100) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(100)), transform_worldex },
3948 { /*357, WINED3DTS_WORLDMATRIX(101) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(101)), transform_worldex },
3949 { /*358, WINED3DTS_WORLDMATRIX(102) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(102)), transform_worldex },
3950 { /*359, WINED3DTS_WORLDMATRIX(103) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(103)), transform_worldex },
3951 { /*360, WINED3DTS_WORLDMATRIX(104) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(104)), transform_worldex },
3952 { /*361, WINED3DTS_WORLDMATRIX(105) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(105)), transform_worldex },
3953 { /*362, WINED3DTS_WORLDMATRIX(106) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(106)), transform_worldex },
3954 { /*363, WINED3DTS_WORLDMATRIX(107) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(107)), transform_worldex },
3955 { /*364, WINED3DTS_WORLDMATRIX(108) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(108)), transform_worldex },
3956 { /*365, WINED3DTS_WORLDMATRIX(109) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(109)), transform_worldex },
3957 { /*366, WINED3DTS_WORLDMATRIX(110) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(110)), transform_worldex },
3958 { /*367, WINED3DTS_WORLDMATRIX(111) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(111)), transform_worldex },
3959 { /*368, WINED3DTS_WORLDMATRIX(112) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(112)), transform_worldex },
3960 { /*369, WINED3DTS_WORLDMATRIX(113) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(113)), transform_worldex },
3961 { /*370, WINED3DTS_WORLDMATRIX(114) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(114)), transform_worldex },
3962 { /*371, WINED3DTS_WORLDMATRIX(115) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(115)), transform_worldex },
3963 { /*372, WINED3DTS_WORLDMATRIX(116) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(116)), transform_worldex },
3964 { /*373, WINED3DTS_WORLDMATRIX(117) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(117)), transform_worldex },
3965 { /*374, WINED3DTS_WORLDMATRIX(118) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(118)), transform_worldex },
3966 { /*375, WINED3DTS_WORLDMATRIX(119) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(119)), transform_worldex },
3967 { /*376, WINED3DTS_WORLDMATRIX(120) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(120)), transform_worldex },
3968 { /*377, WINED3DTS_WORLDMATRIX(121) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(121)), transform_worldex },
3969 { /*378, WINED3DTS_WORLDMATRIX(122) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(122)), transform_worldex },
3970 { /*379, WINED3DTS_WORLDMATRIX(123) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(123)), transform_worldex },
3971 { /*380, WINED3DTS_WORLDMATRIX(124) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(124)), transform_worldex },
3972 { /*381, WINED3DTS_WORLDMATRIX(125) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(125)), transform_worldex },
3973 { /*382, WINED3DTS_WORLDMATRIX(126) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(126)), transform_worldex },
3974 { /*383, WINED3DTS_WORLDMATRIX(127) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(127)), transform_worldex },
3975 { /*384, WINED3DTS_WORLDMATRIX(128) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(128)), transform_worldex },
3976 { /*385, WINED3DTS_WORLDMATRIX(129) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(129)), transform_worldex },
3977 { /*386, WINED3DTS_WORLDMATRIX(130) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(130)), transform_worldex },
3978 { /*387, WINED3DTS_WORLDMATRIX(131) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(131)), transform_worldex },
3979 { /*388, WINED3DTS_WORLDMATRIX(132) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(132)), transform_worldex },
3980 { /*389, WINED3DTS_WORLDMATRIX(133) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(133)), transform_worldex },
3981 { /*390, WINED3DTS_WORLDMATRIX(134) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(134)), transform_worldex },
3982 { /*391, WINED3DTS_WORLDMATRIX(135) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(135)), transform_worldex },
3983 { /*392, WINED3DTS_WORLDMATRIX(136) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(136)), transform_worldex },
3984 { /*393, WINED3DTS_WORLDMATRIX(137) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(137)), transform_worldex },
3985 { /*394, WINED3DTS_WORLDMATRIX(138) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(138)), transform_worldex },
3986 { /*395, WINED3DTS_WORLDMATRIX(139) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(139)), transform_worldex },
3987 { /*396, WINED3DTS_WORLDMATRIX(140) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(140)), transform_worldex },
3988 { /*397, WINED3DTS_WORLDMATRIX(141) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(141)), transform_worldex },
3989 { /*398, WINED3DTS_WORLDMATRIX(142) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(142)), transform_worldex },
3990 { /*399, WINED3DTS_WORLDMATRIX(143) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(143)), transform_worldex },
3991 { /*400, WINED3DTS_WORLDMATRIX(144) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(144)), transform_worldex },
3992 { /*401, WINED3DTS_WORLDMATRIX(145) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(145)), transform_worldex },
3993 { /*402, WINED3DTS_WORLDMATRIX(146) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(146)), transform_worldex },
3994 { /*403, WINED3DTS_WORLDMATRIX(147) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(147)), transform_worldex },
3995 { /*404, WINED3DTS_WORLDMATRIX(148) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(148)), transform_worldex },
3996 { /*405, WINED3DTS_WORLDMATRIX(149) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(149)), transform_worldex },
3997 { /*406, WINED3DTS_WORLDMATRIX(150) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(150)), transform_worldex },
3998 { /*407, WINED3DTS_WORLDMATRIX(151) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(151)), transform_worldex },
3999 { /*408, WINED3DTS_WORLDMATRIX(152) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(152)), transform_worldex },
4000 { /*409, WINED3DTS_WORLDMATRIX(153) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(153)), transform_worldex },
4001 { /*410, WINED3DTS_WORLDMATRIX(154) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(154)), transform_worldex },
4002 { /*411, WINED3DTS_WORLDMATRIX(155) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(155)), transform_worldex },
4003 { /*412, WINED3DTS_WORLDMATRIX(156) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(156)), transform_worldex },
4004 { /*413, WINED3DTS_WORLDMATRIX(157) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(157)), transform_worldex },
4005 { /*414, WINED3DTS_WORLDMATRIX(158) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(158)), transform_worldex },
4006 { /*415, WINED3DTS_WORLDMATRIX(159) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(159)), transform_worldex },
4007 { /*416, WINED3DTS_WORLDMATRIX(160) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(160)), transform_worldex },
4008 { /*417, WINED3DTS_WORLDMATRIX(161) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(161)), transform_worldex },
4009 { /*418, WINED3DTS_WORLDMATRIX(162) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(162)), transform_worldex },
4010 { /*419, WINED3DTS_WORLDMATRIX(163) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(163)), transform_worldex },
4011 { /*420, WINED3DTS_WORLDMATRIX(164) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(164)), transform_worldex },
4012 { /*421, WINED3DTS_WORLDMATRIX(165) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(165)), transform_worldex },
4013 { /*422, WINED3DTS_WORLDMATRIX(166) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(166)), transform_worldex },
4014 { /*423, WINED3DTS_WORLDMATRIX(167) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(167)), transform_worldex },
4015 { /*424, WINED3DTS_WORLDMATRIX(168) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(168)), transform_worldex },
4016 { /*425, WINED3DTS_WORLDMATRIX(168) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(169)), transform_worldex },
4017 { /*426, WINED3DTS_WORLDMATRIX(170) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(170)), transform_worldex },
4018 { /*427, WINED3DTS_WORLDMATRIX(171) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(171)), transform_worldex },
4019 { /*428, WINED3DTS_WORLDMATRIX(172) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(172)), transform_worldex },
4020 { /*429, WINED3DTS_WORLDMATRIX(173) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(173)), transform_worldex },
4021 { /*430, WINED3DTS_WORLDMATRIX(174) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(174)), transform_worldex },
4022 { /*431, WINED3DTS_WORLDMATRIX(175) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(175)), transform_worldex },
4023 { /*432, WINED3DTS_WORLDMATRIX(176) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(176)), transform_worldex },
4024 { /*433, WINED3DTS_WORLDMATRIX(177) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(177)), transform_worldex },
4025 { /*434, WINED3DTS_WORLDMATRIX(178) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(178)), transform_worldex },
4026 { /*435, WINED3DTS_WORLDMATRIX(179) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(179)), transform_worldex },
4027 { /*436, WINED3DTS_WORLDMATRIX(180) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(180)), transform_worldex },
4028 { /*437, WINED3DTS_WORLDMATRIX(181) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(181)), transform_worldex },
4029 { /*438, WINED3DTS_WORLDMATRIX(182) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(182)), transform_worldex },
4030 { /*439, WINED3DTS_WORLDMATRIX(183) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(183)), transform_worldex },
4031 { /*440, WINED3DTS_WORLDMATRIX(184) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(184)), transform_worldex },
4032 { /*441, WINED3DTS_WORLDMATRIX(185) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(185)), transform_worldex },
4033 { /*441, WINED3DTS_WORLDMATRIX(186) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(186)), transform_worldex },
4034 { /*443, WINED3DTS_WORLDMATRIX(187) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(187)), transform_worldex },
4035 { /*444, WINED3DTS_WORLDMATRIX(188) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(188)), transform_worldex },
4036 { /*445, WINED3DTS_WORLDMATRIX(189) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(189)), transform_worldex },
4037 { /*446, WINED3DTS_WORLDMATRIX(190) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(190)), transform_worldex },
4038 { /*447, WINED3DTS_WORLDMATRIX(191) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(191)), transform_worldex },
4039 { /*448, WINED3DTS_WORLDMATRIX(192) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(192)), transform_worldex },
4040 { /*449, WINED3DTS_WORLDMATRIX(193) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(193)), transform_worldex },
4041 { /*450, WINED3DTS_WORLDMATRIX(194) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(194)), transform_worldex },
4042 { /*451, WINED3DTS_WORLDMATRIX(195) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(195)), transform_worldex },
4043 { /*452, WINED3DTS_WORLDMATRIX(196) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(196)), transform_worldex },
4044 { /*453, WINED3DTS_WORLDMATRIX(197) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(197)), transform_worldex },
4045 { /*454, WINED3DTS_WORLDMATRIX(198) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(198)), transform_worldex },
4046 { /*455, WINED3DTS_WORLDMATRIX(199) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(199)), transform_worldex },
4047 { /*356, WINED3DTS_WORLDMATRIX(200) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(200)), transform_worldex },
4048 { /*457, WINED3DTS_WORLDMATRIX(201) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(201)), transform_worldex },
4049 { /*458, WINED3DTS_WORLDMATRIX(202) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(202)), transform_worldex },
4050 { /*459, WINED3DTS_WORLDMATRIX(203) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(203)), transform_worldex },
4051 { /*460, WINED3DTS_WORLDMATRIX(204) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(204)), transform_worldex },
4052 { /*461, WINED3DTS_WORLDMATRIX(205) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(205)), transform_worldex },
4053 { /*462, WINED3DTS_WORLDMATRIX(206) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(206)), transform_worldex },
4054 { /*463, WINED3DTS_WORLDMATRIX(207) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(207)), transform_worldex },
4055 { /*464, WINED3DTS_WORLDMATRIX(208) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(208)), transform_worldex },
4056 { /*465, WINED3DTS_WORLDMATRIX(209) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(209)), transform_worldex },
4057 { /*466, WINED3DTS_WORLDMATRIX(210) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(210)), transform_worldex },
4058 { /*467, WINED3DTS_WORLDMATRIX(211) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(211)), transform_worldex },
4059 { /*468, WINED3DTS_WORLDMATRIX(212) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(212)), transform_worldex },
4060 { /*469, WINED3DTS_WORLDMATRIX(213) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(213)), transform_worldex },
4061 { /*470, WINED3DTS_WORLDMATRIX(214) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(214)), transform_worldex },
4062 { /*471, WINED3DTS_WORLDMATRIX(215) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(215)), transform_worldex },
4063 { /*472, WINED3DTS_WORLDMATRIX(216) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(216)), transform_worldex },
4064 { /*473, WINED3DTS_WORLDMATRIX(217) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(217)), transform_worldex },
4065 { /*474, WINED3DTS_WORLDMATRIX(218) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(218)), transform_worldex },
4066 { /*475, WINED3DTS_WORLDMATRIX(219) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(219)), transform_worldex },
4067 { /*476, WINED3DTS_WORLDMATRIX(220) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(220)), transform_worldex },
4068 { /*477, WINED3DTS_WORLDMATRIX(221) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(221)), transform_worldex },
4069 { /*478, WINED3DTS_WORLDMATRIX(222) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(222)), transform_worldex },
4070 { /*479, WINED3DTS_WORLDMATRIX(223) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(223)), transform_worldex },
4071 { /*480, WINED3DTS_WORLDMATRIX(224) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(224)), transform_worldex },
4072 { /*481, WINED3DTS_WORLDMATRIX(225) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(225)), transform_worldex },
4073 { /*482, WINED3DTS_WORLDMATRIX(226) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(226)), transform_worldex },
4074 { /*483, WINED3DTS_WORLDMATRIX(227) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(227)), transform_worldex },
4075 { /*484, WINED3DTS_WORLDMATRIX(228) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(228)), transform_worldex },
4076 { /*485, WINED3DTS_WORLDMATRIX(229) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(229)), transform_worldex },
4077 { /*486, WINED3DTS_WORLDMATRIX(230) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(230)), transform_worldex },
4078 { /*487, WINED3DTS_WORLDMATRIX(231) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(231)), transform_worldex },
4079 { /*488, WINED3DTS_WORLDMATRIX(232) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(232)), transform_worldex },
4080 { /*489, WINED3DTS_WORLDMATRIX(233) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(233)), transform_worldex },
4081 { /*490, WINED3DTS_WORLDMATRIX(234) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(234)), transform_worldex },
4082 { /*491, WINED3DTS_WORLDMATRIX(235) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(235)), transform_worldex },
4083 { /*492, WINED3DTS_WORLDMATRIX(236) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(236)), transform_worldex },
4084 { /*493, WINED3DTS_WORLDMATRIX(237) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(237)), transform_worldex },
4085 { /*494, WINED3DTS_WORLDMATRIX(238) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(238)), transform_worldex },
4086 { /*495, WINED3DTS_WORLDMATRIX(239) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(239)), transform_worldex },
4087 { /*496, WINED3DTS_WORLDMATRIX(240) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(240)), transform_worldex },
4088 { /*497, WINED3DTS_WORLDMATRIX(241) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(241)), transform_worldex },
4089 { /*498, WINED3DTS_WORLDMATRIX(242) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(242)), transform_worldex },
4090 { /*499, WINED3DTS_WORLDMATRIX(243) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(243)), transform_worldex },
4091 { /*500, WINED3DTS_WORLDMATRIX(244) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(244)), transform_worldex },
4092 { /*501, WINED3DTS_WORLDMATRIX(245) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(245)), transform_worldex },
4093 { /*502, WINED3DTS_WORLDMATRIX(246) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(246)), transform_worldex },
4094 { /*503, WINED3DTS_WORLDMATRIX(247) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(247)), transform_worldex },
4095 { /*504, WINED3DTS_WORLDMATRIX(248) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(248)), transform_worldex },
4096 { /*505, WINED3DTS_WORLDMATRIX(249) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(249)), transform_worldex },
4097 { /*506, WINED3DTS_WORLDMATRIX(250) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(250)), transform_worldex },
4098 { /*507, WINED3DTS_WORLDMATRIX(251) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(251)), transform_worldex },
4099 { /*508, WINED3DTS_WORLDMATRIX(252) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(252)), transform_worldex },
4100 { /*509, WINED3DTS_WORLDMATRIX(253) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(253)), transform_worldex },
4101 { /*510, WINED3DTS_WORLDMATRIX(254) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(254)), transform_worldex },
4102 { /*511, WINED3DTS_WORLDMATRIX(255) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(255)), transform_worldex },
Stefan Dösingeref1ebb62007-01-02 00:35:07 +0100[diff] [blame]4103 /* Various Vertex states follow */
4104 { /* , STATE_STREAMSRC */ STATE_VDECL, vertexdeclaration },
Stefan Dösinger59ae2a52007-02-19 15:25:32 +0100[diff] [blame]4105 { /* , STATE_INDEXBUFFER */ STATE_INDEXBUFFER, indexbuffer },
Stefan Dösingeref1ebb62007-01-02 00:35:07 +0100[diff] [blame]4106 { /* , STATE_VDECL */ STATE_VDECL, vertexdeclaration },
4107 { /* , STATE_VSHADER */ STATE_VDECL, vertexdeclaration },
Stefan Dösinger0d700be2007-01-04 00:05:05 +0100[diff] [blame]4108 { /* , STATE_VIEWPORT */ STATE_VIEWPORT, viewport },
Stefan Dösinger8e37fcd2007-01-06 18:17:27 +0100[diff] [blame]4109 { /* , STATE_VERTEXSHADERCONSTANT */ STATE_VERTEXSHADERCONSTANT, shaderconstant },
4110 { /* , STATE_PIXELSHADERCONSTANT */ STATE_VERTEXSHADERCONSTANT, shaderconstant },
Stefan Dösinger174b6322007-02-14 17:48:52 +0100[diff] [blame]4111 /* Lights */
4112 { /* , STATE_ACTIVELIGHT(0) */ STATE_ACTIVELIGHT(0), light },
4113 { /* , STATE_ACTIVELIGHT(1) */ STATE_ACTIVELIGHT(1), light },
4114 { /* , STATE_ACTIVELIGHT(2) */ STATE_ACTIVELIGHT(2), light },
4115 { /* , STATE_ACTIVELIGHT(3) */ STATE_ACTIVELIGHT(3), light },
4116 { /* , STATE_ACTIVELIGHT(4) */ STATE_ACTIVELIGHT(4), light },
4117 { /* , STATE_ACTIVELIGHT(5) */ STATE_ACTIVELIGHT(5), light },
4118 { /* , STATE_ACTIVELIGHT(6) */ STATE_ACTIVELIGHT(6), light },
4119 { /* , STATE_ACTIVELIGHT(7) */ STATE_ACTIVELIGHT(7), light },
Stefan Dösingerecfd4cb2007-02-19 15:25:16 +0100[diff] [blame]4120
4121 { /* Scissor rect */ STATE_SCISSORRECT, scissorrect }
Stefan Dösingerc0268c72006-12-05 23:36:10 +0100[diff] [blame]4122};