Google Git
Sign in
goma / wine / c88efeef056eab7a21825d6eef7907b3b7069530 / . / dlls / wined3d / state.c
blob: 02c22b6ff1c3eefae3b04ede1b99de3a000c6c2d [file] [log] [blame]
Stefan Dösingerc0268c72006-12-05 23:36:10 +0100[diff] [blame]1/*
2 * Direct3D state management
3 *
4 * Copyright 2006 Stefan Dösinger for CodeWeavers
5 *
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
10 *
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
15 *
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
19 */
20
21#include "config.h"
22#include <stdio.h>
23#ifdef HAVE_FLOAT_H
24# include <float.h>
25#endif
26#include "wined3d_private.h"
27
28WINE_DEFAULT_DEBUG_CHANNEL(d3d);
29
30static void state_unknown(DWORD state, IWineD3DStateBlockImpl *stateblock) {
Stefan Dösinger2a24e842006-12-06 13:22:12 +0100[diff] [blame]31 /* State which does exist, but wined3d doesn't know about */
32 if(STATE_IS_RENDER(state)) {
33 WINED3DRENDERSTATETYPE RenderState = state - STATE_RENDER(0);
34 FIXME("(%s, %d) Unknown renderstate\n", debug_d3drenderstate(RenderState), stateblock->renderState[RenderState]);
35 } else {
36 FIXME("(%d) Unknown state with unknown type\n", state);
37 }
38}
39
40static void state_nogl(DWORD state, IWineD3DStateBlockImpl *stateblock) {
41 /* Used for states which are not mapped to a gl state as-is, but used somehow different,
42 * e.g as a parameter for drawing, or which are unimplemented in windows d3d
43 */
44 if(STATE_IS_RENDER(state)) {
45 WINED3DRENDERSTATETYPE RenderState = state - STATE_RENDER(0);
46 TRACE("(%s,%d) no direct mapping to gl\n", debug_d3drenderstate(RenderState), stateblock->renderState[RenderState]);
47 } else {
48 /* Shouldn't have an unknown type here */
49 FIXME("%d no direct mapping to gl of state with unknown type\n", state);
50 }
51}
52
53static void state_undefined(DWORD state, IWineD3DStateBlockImpl *stateblock) {
54 /* Print a WARN, this allows the stateblock code to loop over all states to generate a display
55 * list without causing confusing terminal output. Deliberately no special debug name here
56 * because its undefined.
57 */
58 WARN("undefined state %d\n", state);
Stefan Dösingerc0268c72006-12-05 23:36:10 +0100[diff] [blame]59}
60
Stefan Dösingerde963202006-12-05 23:45:35 +0100[diff] [blame]61static void state_fillmode(DWORD state, IWineD3DStateBlockImpl *stateblock) {
62 D3DFILLMODE Value = stateblock->renderState[WINED3DRS_FILLMODE];
63
64 switch(Value) {
65 case D3DFILL_POINT:
66 glPolygonMode(GL_FRONT_AND_BACK, GL_POINT);
67 checkGLcall("glPolygonMode(GL_FRONT_AND_BACK, GL_POINT)");
68 break;
69 case D3DFILL_WIREFRAME:
70 glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
71 checkGLcall("glPolygonMode(GL_FRONT_AND_BACK, GL_LINE)");
72 break;
73 case D3DFILL_SOLID:
74 glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
75 checkGLcall("glPolygonMode(GL_FRONT_AND_BACK, GL_FILL)");
76 break;
77 default:
78 FIXME("Unrecognized WINED3DRS_FILLMODE value %d\n", Value);
79 }
80}
81
Stefan Dösinger53e78892006-12-08 01:39:55 +0100[diff] [blame]82static void state_lighting(DWORD state, IWineD3DStateBlockImpl *stateblock) {
83
84 /* TODO: Lighting is only enabled if Vertex normals are passed by the application,
85 * so merge the lighting render state with the vertex declaration once it is available
86 */
87
88 if (stateblock->renderState[WINED3DRS_LIGHTING]) {
89 glEnable(GL_LIGHTING);
90 checkGLcall("glEnable GL_LIGHTING");
91 } else {
92 glDisable(GL_LIGHTING);
93 checkGLcall("glDisable GL_LIGHTING");
94 }
95}
96
Stefan Dösingerbb564dc2006-12-08 01:40:51 +0100[diff] [blame]97static void state_zenable(DWORD state, IWineD3DStateBlockImpl *stateblock) {
98 switch ((WINED3DZBUFFERTYPE) stateblock->renderState[WINED3DRS_ZENABLE]) {
99 case WINED3DZB_FALSE:
100 glDisable(GL_DEPTH_TEST);
101 checkGLcall("glDisable GL_DEPTH_TEST");
102 break;
103 case WINED3DZB_TRUE:
104 glEnable(GL_DEPTH_TEST);
105 checkGLcall("glEnable GL_DEPTH_TEST");
106 break;
107 case WINED3DZB_USEW:
108 glEnable(GL_DEPTH_TEST);
109 checkGLcall("glEnable GL_DEPTH_TEST");
110 FIXME("W buffer is not well handled\n");
111 break;
112 default:
113 FIXME("Unrecognized D3DZBUFFERTYPE value %d\n", stateblock->renderState[WINED3DRS_ZENABLE]);
114 }
115}
116
Stefan Dösingere4b4c042006-12-08 01:41:43 +0100[diff] [blame]117static void state_cullmode(DWORD state, IWineD3DStateBlockImpl *stateblock) {
118 /* TODO: Put this into the offscreen / onscreen rendering block due to device->render_offscreen */
119
120 /* If we are culling "back faces with clockwise vertices" then
121 set front faces to be counter clockwise and enable culling
122 of back faces */
123 switch ((WINED3DCULL) stateblock->renderState[WINED3DRS_CULLMODE]) {
124 case WINED3DCULL_NONE:
125 glDisable(GL_CULL_FACE);
126 checkGLcall("glDisable GL_CULL_FACE");
127 break;
128 case WINED3DCULL_CW:
129 glEnable(GL_CULL_FACE);
130 checkGLcall("glEnable GL_CULL_FACE");
131 if (stateblock->wineD3DDevice->render_offscreen) {
132 glFrontFace(GL_CW);
133 checkGLcall("glFrontFace GL_CW");
134 } else {
135 glFrontFace(GL_CCW);
136 checkGLcall("glFrontFace GL_CCW");
137 }
138 glCullFace(GL_BACK);
139 break;
140 case WINED3DCULL_CCW:
141 glEnable(GL_CULL_FACE);
142 checkGLcall("glEnable GL_CULL_FACE");
143 if (stateblock->wineD3DDevice->render_offscreen) {
144 glFrontFace(GL_CCW);
145 checkGLcall("glFrontFace GL_CCW");
146 } else {
147 glFrontFace(GL_CW);
148 checkGLcall("glFrontFace GL_CW");
149 }
150 glCullFace(GL_BACK);
151 break;
152 default:
153 FIXME("Unrecognized/Unhandled WINED3DCULL value %d\n", stateblock->renderState[WINED3DRS_CULLMODE]);
154 }
155}
156
Stefan Dösinger68f10822006-12-08 01:42:16 +0100[diff] [blame]157static void state_shademode(DWORD state, IWineD3DStateBlockImpl *stateblock) {
158 switch ((WINED3DSHADEMODE) stateblock->renderState[WINED3DRS_SHADEMODE]) {
159 case WINED3DSHADE_FLAT:
160 glShadeModel(GL_FLAT);
161 checkGLcall("glShadeModel(GL_FLAT)");
162 break;
163 case WINED3DSHADE_GOURAUD:
164 glShadeModel(GL_SMOOTH);
165 checkGLcall("glShadeModel(GL_SMOOTH)");
166 break;
167 case WINED3DSHADE_PHONG:
168 FIXME("WINED3DSHADE_PHONG isn't supported\n");
169 break;
170 default:
171 FIXME("Unrecognized/Unhandled WINED3DSHADEMODE value %d\n", stateblock->renderState[WINED3DRS_SHADEMODE]);
172 }
173}
174
Stefan Dösingerbb622e82006-12-08 01:42:43 +0100[diff] [blame]175static void state_ditherenable(DWORD state, IWineD3DStateBlockImpl *stateblock) {
176 if (stateblock->renderState[WINED3DRS_DITHERENABLE]) {
177 glEnable(GL_DITHER);
178 checkGLcall("glEnable GL_DITHER");
179 } else {
180 glDisable(GL_DITHER);
181 checkGLcall("glDisable GL_DITHER");
182 }
183}
184
Stefan Dösinger8879c7d2006-12-08 01:43:25 +0100[diff] [blame]185static void state_zwritenable(DWORD state, IWineD3DStateBlockImpl *stateblock) {
186 /* TODO: Test if in d3d z writing is enabled even if ZENABLE is off. If yes,
187 * this has to be merged with ZENABLE and ZFUNC
188 */
189 if (stateblock->renderState[WINED3DRS_ZWRITEENABLE]) {
190 glDepthMask(1);
191 checkGLcall("glDepthMask(1)");
192 } else {
193 glDepthMask(0);
194 checkGLcall("glDepthMask(0)");
195 }
196}
197
Stefan Dösinger2ac48e82006-12-08 01:44:55 +0100[diff] [blame]198static void state_zfunc(DWORD state, IWineD3DStateBlockImpl *stateblock) {
199 int glParm = CompareFunc(stateblock->renderState[WINED3DRS_ZFUNC]);
200
201 if(glParm) {
202 glDepthFunc(glParm);
203 checkGLcall("glDepthFunc");
204 }
205}
206
Stefan Dösinger28cc3c82006-12-08 01:45:26 +0100[diff] [blame]207static void state_ambient(DWORD state, IWineD3DStateBlockImpl *stateblock) {
208 float col[4];
209 D3DCOLORTOGLFLOAT4(stateblock->renderState[WINED3DRS_AMBIENT], col);
210
211 TRACE("Setting ambient to (%f,%f,%f,%f)\n", col[0], col[1], col[2], col[3]);
212 glLightModelfv(GL_LIGHT_MODEL_AMBIENT, col);
213 checkGLcall("glLightModel for MODEL_AMBIENT");
214}
215
Stefan Dösinger1f07e4a2006-12-08 01:51:11 +0100[diff] [blame]216static void state_blend(DWORD state, IWineD3DStateBlockImpl *stateblock) {
217 int srcBlend = GL_ZERO;
218 int dstBlend = GL_ZERO;
219 float col[4];
220
221 /* GL_LINE_SMOOTH needs GL_BLEND to work, according to the red book, and special blending params */
222 /* TODO: Is enabling blending really affected by the blendfactor??? */
223 if (stateblock->renderState[WINED3DRS_ALPHABLENDENABLE] ||
224 stateblock->renderState[WINED3DRS_EDGEANTIALIAS] ||
225 stateblock->renderState[WINED3DRS_ANTIALIASEDLINEENABLE] ||
226 stateblock->renderState[WINED3DRS_BLENDFACTOR] != 0xFFFFFFFF) {
227 glEnable(GL_BLEND);
228 checkGLcall("glEnable GL_BLEND");
229 } else {
230 glDisable(GL_BLEND);
231 checkGLcall("glDisable GL_BLEND");
232 /* Nothing more to do - get out */
233 return;
234 };
235
236 switch (stateblock->renderState[WINED3DRS_SRCBLEND]) {
237 case WINED3DBLEND_ZERO : srcBlend = GL_ZERO; break;
238 case WINED3DBLEND_ONE : srcBlend = GL_ONE; break;
239 case WINED3DBLEND_SRCCOLOR : srcBlend = GL_SRC_COLOR; break;
240 case WINED3DBLEND_INVSRCCOLOR : srcBlend = GL_ONE_MINUS_SRC_COLOR; break;
241 case WINED3DBLEND_SRCALPHA : srcBlend = GL_SRC_ALPHA; break;
242 case WINED3DBLEND_INVSRCALPHA : srcBlend = GL_ONE_MINUS_SRC_ALPHA; break;
243 case WINED3DBLEND_DESTALPHA : srcBlend = GL_DST_ALPHA; break;
244 case WINED3DBLEND_INVDESTALPHA : srcBlend = GL_ONE_MINUS_DST_ALPHA; break;
245 case WINED3DBLEND_DESTCOLOR : srcBlend = GL_DST_COLOR; break;
246 case WINED3DBLEND_INVDESTCOLOR : srcBlend = GL_ONE_MINUS_DST_COLOR; break;
247 case WINED3DBLEND_SRCALPHASAT : srcBlend = GL_SRC_ALPHA_SATURATE; break;
248
249 case WINED3DBLEND_BOTHSRCALPHA : srcBlend = GL_SRC_ALPHA;
250 dstBlend = GL_SRC_ALPHA;
251 break;
252
253 case WINED3DBLEND_BOTHINVSRCALPHA : srcBlend = GL_ONE_MINUS_SRC_ALPHA;
254 dstBlend = GL_ONE_MINUS_SRC_ALPHA;
255 break;
256
257 case WINED3DBLEND_BLENDFACTOR : srcBlend = GL_CONSTANT_COLOR; break;
258 case WINED3DBLEND_INVBLENDFACTOR : srcBlend = GL_ONE_MINUS_CONSTANT_COLOR; break;
259 default:
260 FIXME("Unrecognized src blend value %d\n", stateblock->renderState[WINED3DRS_SRCBLEND]);
261 }
262
263 switch (stateblock->renderState[WINED3DRS_DESTBLEND]) {
264 case WINED3DBLEND_ZERO : dstBlend = GL_ZERO; break;
265 case WINED3DBLEND_ONE : dstBlend = GL_ONE; break;
266 case WINED3DBLEND_SRCCOLOR : dstBlend = GL_SRC_COLOR; break;
267 case WINED3DBLEND_INVSRCCOLOR : dstBlend = GL_ONE_MINUS_SRC_COLOR; break;
268 case WINED3DBLEND_SRCALPHA : dstBlend = GL_SRC_ALPHA; break;
269 case WINED3DBLEND_INVSRCALPHA : dstBlend = GL_ONE_MINUS_SRC_ALPHA; break;
270 case WINED3DBLEND_DESTALPHA : dstBlend = GL_DST_ALPHA; break;
271 case WINED3DBLEND_INVDESTALPHA : dstBlend = GL_ONE_MINUS_DST_ALPHA; break;
272 case WINED3DBLEND_DESTCOLOR : dstBlend = GL_DST_COLOR; break;
273 case WINED3DBLEND_INVDESTCOLOR : dstBlend = GL_ONE_MINUS_DST_COLOR; break;
274 case WINED3DBLEND_SRCALPHASAT : dstBlend = GL_SRC_ALPHA_SATURATE; break;
275
276 case WINED3DBLEND_BOTHSRCALPHA : dstBlend = GL_SRC_ALPHA;
277 srcBlend = GL_SRC_ALPHA;
278 break;
279
280 case WINED3DBLEND_BOTHINVSRCALPHA : dstBlend = GL_ONE_MINUS_SRC_ALPHA;
281 srcBlend = GL_ONE_MINUS_SRC_ALPHA;
282 break;
283
284 case D3DBLEND_BLENDFACTOR : dstBlend = GL_CONSTANT_COLOR; break;
285 case D3DBLEND_INVBLENDFACTOR : dstBlend = GL_ONE_MINUS_CONSTANT_COLOR; break;
286 default:
287 FIXME("Unrecognized dst blend value %d\n", stateblock->renderState[WINED3DRS_DESTBLEND]);
288 }
289
290 if(stateblock->renderState[WINED3DRS_EDGEANTIALIAS] ||
291 stateblock->renderState[WINED3DRS_ANTIALIASEDLINEENABLE]) {
292 glEnable(GL_LINE_SMOOTH);
293 checkGLcall("glEnable(GL_LINE_SMOOTH)");
294 if(srcBlend != GL_SRC_ALPHA) {
295 FIXME("WINED3DRS_EDGEANTIALIAS enabled, but incompatible src blending param - what to do?\n");
296 srcBlend = GL_SRC_ALPHA;
297 }
298 if(dstBlend != GL_ONE_MINUS_SRC_ALPHA) {
299 FIXME("WINED3DRS_EDGEANTIALIAS enabled, but incompatible dst blending param - what to do?\n");
300 dstBlend = GL_ONE_MINUS_SRC_ALPHA;
301 }
302 } else {
303 glDisable(GL_LINE_SMOOTH);
304 checkGLcall("glDisable(GL_LINE_SMOOTH)");
305 }
306
307 TRACE("glBlendFunc src=%x, dst=%x\n", srcBlend, dstBlend);
308 glBlendFunc(srcBlend, dstBlend);
309 checkGLcall("glBlendFunc");
310
311 /* TODO: Remove when state management done */
312 stateblock->wineD3DDevice->dstBlend = dstBlend;
313 stateblock->wineD3DDevice->srcBlend = srcBlend;
314
315 TRACE("Setting BlendFactor to %d\n", stateblock->renderState[WINED3DRS_BLENDFACTOR]);
316 D3DCOLORTOGLFLOAT4(stateblock->renderState[WINED3DRS_BLENDFACTOR], col);
317 glBlendColor (col[0],col[1],col[2],col[3]);
318 checkGLcall("glBlendColor");
319}
320
Stefan Dösingerc88efee2006-12-08 20:21:32 +0100[diff] [blame^]321static void state_alpha(DWORD state, IWineD3DStateBlockImpl *stateblock) {
322 int glParm = 0;
323 float ref;
324 BOOL enable_ckey = FALSE;
325
326 IWineD3DSurfaceImpl *surf;
327
328 /* Find out if the texture on the first stage has a ckey set
329 * The alpha state func reads the texture settings, even though alpha and texture are not grouped
330 * together. This is to avoid making a huge alpha+texture+texture stage+ckey block due to the hardly
331 * used WINED3DRS_COLORKEYENABLE state(which is d3d <= 3 only). The texture function will call alpha
332 * in case it finds some texture+colorkeyenable combination which needs extra care.
333 */
334 if(stateblock->textures[0]) {
335 surf = (IWineD3DSurfaceImpl *) ((IWineD3DTextureImpl *)stateblock->textures[0])->surfaces[0];
336 if(surf->CKeyFlags & DDSD_CKSRCBLT) enable_ckey = TRUE;
337 }
338
339 if (stateblock->renderState[WINED3DRS_ALPHATESTENABLE] ||
340 (stateblock->renderState[WINED3DRS_COLORKEYENABLE] && enable_ckey)) {
341 glEnable(GL_ALPHA_TEST);
342 checkGLcall("glEnable GL_ALPHA_TEST");
343 } else {
344 glDisable(GL_ALPHA_TEST);
345 checkGLcall("glDisable GL_ALPHA_TEST");
346 /* Alpha test is disabled, don't bother setting the params - it will happen on the next
347 * enable call
348 */
349 return;
350 }
351
352 if(stateblock->renderState[WINED3DRS_COLORKEYENABLE] && enable_ckey) {
353 glParm = GL_NOTEQUAL;
354 ref = 0.0;
355 } else {
356 ref = ((float) stateblock->renderState[WINED3DRS_ALPHAREF]) / 255.0f;
357 glParm = CompareFunc(stateblock->renderState[WINED3DRS_ALPHAFUNC]);
358 }
359 if(glParm) {
360 stateblock->wineD3DDevice->alphafunc = glParm; /* Remove when state management done */
361 glAlphaFunc(glParm, ref);
362 checkGLcall("glAlphaFunc");
363 }
364 /* TODO: Some texture blending operations seem to affect the alpha test */
365}
366
Stefan Dösingerc0268c72006-12-05 23:36:10 +0100[diff] [blame]367const struct StateEntry StateTable[] =
368{
369 /* State name representative, apply function */
Stefan Dösinger2a24e842006-12-06 13:22:12 +0100[diff] [blame]370 { /* 0, Undefined */ 0, state_undefined },
371 { /* 1, WINED3DRS_TEXTUREHANDLE */ 0 /* Handled in ddraw */, state_undefined },
372 { /* 2, WINED3DRS_ANTIALIAS */ STATE_RENDER(WINED3DRS_ANTIALIAS), state_unknown },
373 { /* 3, WINED3DRS_TEXTUREADDRESS */ 0 /* Handled in ddraw */, state_undefined },
374 { /* 4, WINED3DRS_TEXTUREPERSPECTIVE */ STATE_RENDER(WINED3DRS_TEXTUREPERSPECTIVE), state_unknown },
375 { /* 5, WINED3DRS_WRAPU */ STATE_RENDER(WINED3DRS_WRAPU), state_unknown },
376 { /* 6, WINED3DRS_WRAPV */ STATE_RENDER(WINED3DRS_WRAPV), state_unknown },
Stefan Dösingerbb564dc2006-12-08 01:40:51 +0100[diff] [blame]377 { /* 7, WINED3DRS_ZENABLE */ STATE_RENDER(WINED3DRS_ZENABLE), state_zenable },
Stefan Dösingerde963202006-12-05 23:45:35 +0100[diff] [blame]378 { /* 8, WINED3DRS_FILLMODE */ STATE_RENDER(WINED3DRS_FILLMODE), state_fillmode },
Stefan Dösinger68f10822006-12-08 01:42:16 +0100[diff] [blame]379 { /* 9, WINED3DRS_SHADEMODE */ STATE_RENDER(WINED3DRS_SHADEMODE), state_shademode },
Stefan Dösinger2a24e842006-12-06 13:22:12 +0100[diff] [blame]380 { /* 10, WINED3DRS_LINEPATTERN */ STATE_RENDER(WINED3DRS_LINEPATTERN), state_unknown },
381 { /* 11, WINED3DRS_MONOENABLE */ STATE_RENDER(WINED3DRS_MONOENABLE), state_unknown },
382 { /* 12, WINED3DRS_ROP2 */ STATE_RENDER(WINED3DRS_ROP2), state_unknown },
383 { /* 13, WINED3DRS_PLANEMASK */ STATE_RENDER(WINED3DRS_PLANEMASK), state_unknown },
Stefan Dösinger8879c7d2006-12-08 01:43:25 +0100[diff] [blame]384 { /* 14, WINED3DRS_ZWRITEENABLE */ STATE_RENDER(WINED3DRS_ZWRITEENABLE), state_zwritenable },
Stefan Dösingerc88efee2006-12-08 20:21:32 +0100[diff] [blame^]385 { /* 15, WINED3DRS_ALPHATESTENABLE */ STATE_RENDER(WINED3DRS_ALPHATESTENABLE), state_alpha },
Stefan Dösinger2a24e842006-12-06 13:22:12 +0100[diff] [blame]386 { /* 16, WINED3DRS_LASTPIXEL */ STATE_RENDER(WINED3DRS_LASTPIXEL), state_unknown },
387 { /* 17, WINED3DRS_TEXTUREMAG */ 0 /* Handled in ddraw */, state_undefined },
388 { /* 18, WINED3DRS_TEXTUREMIN */ 0 /* Handled in ddraw */, state_undefined },
Stefan Dösinger1f07e4a2006-12-08 01:51:11 +0100[diff] [blame]389 { /* 19, WINED3DRS_SRCBLEND */ STATE_RENDER(WINED3DRS_ALPHABLENDENABLE), state_blend },
390 { /* 20, WINED3DRS_DESTBLEND */ STATE_RENDER(WINED3DRS_ALPHABLENDENABLE), state_blend },
Stefan Dösinger2a24e842006-12-06 13:22:12 +0100[diff] [blame]391 { /* 21, WINED3DRS_TEXTUREMAPBLEND */ 0 /* Handled in ddraw */, state_undefined },
Stefan Dösingere4b4c042006-12-08 01:41:43 +0100[diff] [blame]392 { /* 22, WINED3DRS_CULLMODE */ STATE_RENDER(WINED3DRS_CULLMODE), state_cullmode },
Stefan Dösinger2ac48e82006-12-08 01:44:55 +0100[diff] [blame]393 { /* 23, WINED3DRS_ZFUNC */ STATE_RENDER(WINED3DRS_ZFUNC), state_zfunc },
Stefan Dösingerc88efee2006-12-08 20:21:32 +0100[diff] [blame^]394 { /* 24, WINED3DRS_ALPHAREF */ STATE_RENDER(WINED3DRS_ALPHATESTENABLE), state_alpha },
395 { /* 25, WINED3DRS_ALPHAFUNC */ STATE_RENDER(WINED3DRS_ALPHATESTENABLE), state_alpha },
Stefan Dösingerbb622e82006-12-08 01:42:43 +0100[diff] [blame]396 { /* 26, WINED3DRS_DITHERENABLE */ STATE_RENDER(WINED3DRS_DITHERENABLE), state_ditherenable },
Stefan Dösinger1f07e4a2006-12-08 01:51:11 +0100[diff] [blame]397 { /* 27, WINED3DRS_ALPHABLENDENABLE */ STATE_RENDER(WINED3DRS_ALPHABLENDENABLE), state_blend },
Stefan Dösinger2a24e842006-12-06 13:22:12 +0100[diff] [blame]398 { /* 28, WINED3DRS_FOGENABLE */ STATE_RENDER(WINED3DRS_FOGENABLE), state_unknown },
399 { /* 29, WINED3DRS_SPECULARENABLE */ STATE_RENDER(WINED3DRS_SPECULARENABLE), state_unknown },
400 { /* 30, WINED3DRS_ZVISIBLE */ 0 /* Not supported according to the msdn */, state_nogl },
401 { /* 31, WINED3DRS_SUBPIXEL */ STATE_RENDER(WINED3DRS_SUBPIXEL), state_unknown },
402 { /* 32, WINED3DRS_SUBPIXELX */ STATE_RENDER(WINED3DRS_SUBPIXELX), state_unknown },
403 { /* 33, WINED3DRS_STIPPLEDALPHA */ STATE_RENDER(WINED3DRS_STIPPLEDALPHA), state_unknown },
404 { /* 34, WINED3DRS_FOGCOLOR */ STATE_RENDER(WINED3DRS_FOGCOLOR), state_unknown },
405 { /* 35, WINED3DRS_FOGTABLEMODE */ STATE_RENDER(WINED3DRS_FOGENABLE)/*vertex type*/, state_unknown },
406 { /* 36, WINED3DRS_FOGSTART */ STATE_RENDER(WINED3DRS_FOGENABLE), state_unknown },
407 { /* 37, WINED3DRS_FOGEND */ STATE_RENDER(WINED3DRS_FOGENABLE), state_unknown },
408 { /* 38, WINED3DRS_FOGDENSITY */ STATE_RENDER(WINED3DRS_FOGDENSITY), state_unknown },
409 { /* 39, WINED3DRS_STIPPLEENABLE */ STATE_RENDER(WINED3DRS_STIPPLEENABLE), state_unknown },
Stefan Dösinger1f07e4a2006-12-08 01:51:11 +0100[diff] [blame]410 { /* 40, WINED3DRS_EDGEANTIALIAS */ STATE_RENDER(WINED3DRS_ALPHABLENDENABLE), state_blend },
Stefan Dösingerc88efee2006-12-08 20:21:32 +0100[diff] [blame^]411 { /* 41, WINED3DRS_COLORKEYENABLE */ STATE_RENDER(WINED3DRS_ALPHATESTENABLE), state_alpha },
Stefan Dösinger2a24e842006-12-06 13:22:12 +0100[diff] [blame]412 { /* 42, undefined */ 0, state_undefined },
413 { /* 43, WINED3DRS_BORDERCOLOR */ STATE_RENDER(WINED3DRS_BORDERCOLOR), state_unknown },
414 { /* 44, WINED3DRS_TEXTUREADDRESSU */ 0, /* Handled in ddraw */ state_undefined },
415 { /* 45, WINED3DRS_TEXTUREADDRESSV */ 0, /* Handled in ddraw */ state_undefined },
416 { /* 46, WINED3DRS_MIPMAPLODBIAS */ STATE_RENDER(WINED3DRS_MIPMAPLODBIAS), state_unknown },
417 { /* 47, WINED3DRS_ZBIAS */ STATE_RENDER(WINED3DRS_ZBIAS), state_unknown },
418 { /* 48, WINED3DRS_RANGEFOGENABLE */ STATE_RENDER(WINED3DRS_RANGEFOGENABLE), state_unknown },
419 { /* 49, WINED3DRS_ANISOTROPY */ STATE_RENDER(WINED3DRS_ANISOTROPY), state_unknown },
420 { /* 50, WINED3DRS_FLUSHBATCH */ STATE_RENDER(WINED3DRS_FLUSHBATCH), state_unknown },
421 { /* 51, WINED3DRS_TRANSLUCENTSORTINDEPENDENT */ STATE_RENDER(WINED3DRS_TRANSLUCENTSORTINDEPENDENT), state_unknown },
422 { /* 52, WINED3DRS_STENCILENABLE */ STATE_RENDER(WINED3DRS_STENCILENABLE), state_unknown },
423 { /* 53, WINED3DRS_STENCILFAIL */ STATE_RENDER(WINED3DRS_STENCILENABLE), state_unknown },
424 { /* 54, WINED3DRS_STENCILZFAIL */ STATE_RENDER(WINED3DRS_STENCILENABLE), state_unknown },
425 { /* 55, WINED3DRS_STENCILPASS */ STATE_RENDER(WINED3DRS_STENCILENABLE), state_unknown },
426 { /* 56, WINED3DRS_STENCILFUNC */ STATE_RENDER(WINED3DRS_STENCILENABLE), state_unknown },
427 { /* 57, WINED3DRS_STENCILREF */ STATE_RENDER(WINED3DRS_STENCILENABLE), state_unknown },
428 { /* 58, WINED3DRS_STENCILMASK */ STATE_RENDER(WINED3DRS_STENCILENABLE), state_unknown },
429 { /* 59, WINED3DRS_STENCILWRITEMASK */ STATE_RENDER(WINED3DRS_STENCILWRITEMASK), state_unknown },
430 { /* 60, WINED3DRS_TEXTUREFACTOR */ STATE_RENDER(WINED3DRS_TEXTUREFACTOR), state_unknown },
431 /* A BIG hole. If wanted, 'fixed' states like the vertex type or the bound shaders can be put here */
432 { /* 61, Undefined */ 0, state_undefined },
433 { /* 62, Undefined */ 0, state_undefined },
434 { /* 63, Undefined */ 0, state_undefined },
435 { /* 64, Undefined */ 0, state_undefined },
436 { /* 65, Undefined */ 0, state_undefined },
437 { /* 66, Undefined */ 0, state_undefined },
438 { /* 67, Undefined */ 0, state_undefined },
439 { /* 68, Undefined */ 0, state_undefined },
440 { /* 69, Undefined */ 0, state_undefined },
441 { /* 70, Undefined */ 0, state_undefined },
442 { /* 71, Undefined */ 0, state_undefined },
443 { /* 72, Undefined */ 0, state_undefined },
444 { /* 73, Undefined */ 0, state_undefined },
445 { /* 74, Undefined */ 0, state_undefined },
446 { /* 75, Undefined */ 0, state_undefined },
447 { /* 76, Undefined */ 0, state_undefined },
448 { /* 77, Undefined */ 0, state_undefined },
449 { /* 78, Undefined */ 0, state_undefined },
450 { /* 79, Undefined */ 0, state_undefined },
451 { /* 80, Undefined */ 0, state_undefined },
452 { /* 81, Undefined */ 0, state_undefined },
453 { /* 82, Undefined */ 0, state_undefined },
454 { /* 83, Undefined */ 0, state_undefined },
455 { /* 84, Undefined */ 0, state_undefined },
456 { /* 85, Undefined */ 0, state_undefined },
457 { /* 86, Undefined */ 0, state_undefined },
458 { /* 87, Undefined */ 0, state_undefined },
459 { /* 88, Undefined */ 0, state_undefined },
460 { /* 89, Undefined */ 0, state_undefined },
461 { /* 90, Undefined */ 0, state_undefined },
462 { /* 91, Undefined */ 0, state_undefined },
463 { /* 92, Undefined */ 0, state_undefined },
464 { /* 93, Undefined */ 0, state_undefined },
465 { /* 94, Undefined */ 0, state_undefined },
466 { /* 95, Undefined */ 0, state_undefined },
467 { /* 96, Undefined */ 0, state_undefined },
468 { /* 97, Undefined */ 0, state_undefined },
469 { /* 98, Undefined */ 0, state_undefined },
470 { /* 99, Undefined */ 0, state_undefined },
471 { /*100, Undefined */ 0, state_undefined },
472 { /*101, Undefined */ 0, state_undefined },
473 { /*102, Undefined */ 0, state_undefined },
474 { /*103, Undefined */ 0, state_undefined },
475 { /*104, Undefined */ 0, state_undefined },
476 { /*105, Undefined */ 0, state_undefined },
477 { /*106, Undefined */ 0, state_undefined },
478 { /*107, Undefined */ 0, state_undefined },
479 { /*108, Undefined */ 0, state_undefined },
480 { /*109, Undefined */ 0, state_undefined },
481 { /*110, Undefined */ 0, state_undefined },
482 { /*111, Undefined */ 0, state_undefined },
483 { /*112, Undefined */ 0, state_undefined },
484 { /*113, Undefined */ 0, state_undefined },
485 { /*114, Undefined */ 0, state_undefined },
486 { /*115, Undefined */ 0, state_undefined },
487 { /*116, Undefined */ 0, state_undefined },
488 { /*117, Undefined */ 0, state_undefined },
489 { /*118, Undefined */ 0, state_undefined },
490 { /*119, Undefined */ 0, state_undefined },
491 { /*120, Undefined */ 0, state_undefined },
492 { /*121, Undefined */ 0, state_undefined },
493 { /*122, Undefined */ 0, state_undefined },
494 { /*123, Undefined */ 0, state_undefined },
495 { /*124, Undefined */ 0, state_undefined },
496 { /*125, Undefined */ 0, state_undefined },
497 { /*126, Undefined */ 0, state_undefined },
498 { /*127, Undefined */ 0, state_undefined },
499 /* Big hole ends */
500 { /*128, WINED3DRS_WRAP0 */ STATE_RENDER(WINED3DRS_WRAP0), state_unknown },
501 { /*129, WINED3DRS_WRAP1 */ STATE_RENDER(WINED3DRS_WRAP0), state_unknown },
502 { /*130, WINED3DRS_WRAP2 */ STATE_RENDER(WINED3DRS_WRAP0), state_unknown },
503 { /*131, WINED3DRS_WRAP3 */ STATE_RENDER(WINED3DRS_WRAP0), state_unknown },
504 { /*132, WINED3DRS_WRAP4 */ STATE_RENDER(WINED3DRS_WRAP0), state_unknown },
505 { /*133, WINED3DRS_WRAP5 */ STATE_RENDER(WINED3DRS_WRAP0), state_unknown },
506 { /*134, WINED3DRS_WRAP6 */ STATE_RENDER(WINED3DRS_WRAP0), state_unknown },
507 { /*135, WINED3DRS_WRAP7 */ STATE_RENDER(WINED3DRS_WRAP0), state_unknown },
508 { /*136, WINED3DRS_CLIPPING */ STATE_RENDER(WINED3DRS_CLIPPING), state_unknown },
Stefan Dösinger53e78892006-12-08 01:39:55 +0100[diff] [blame]509 { /*137, WINED3DRS_LIGHTING */ STATE_RENDER(WINED3DRS_LIGHTING) /* Vertex decl! */,state_lighting },
Stefan Dösinger2a24e842006-12-06 13:22:12 +0100[diff] [blame]510 { /*138, WINED3DRS_EXTENTS */ STATE_RENDER(WINED3DRS_EXTENTS), state_unknown },
Stefan Dösinger28cc3c82006-12-08 01:45:26 +0100[diff] [blame]511 { /*139, WINED3DRS_AMBIENT */ STATE_RENDER(WINED3DRS_AMBIENT), state_ambient },
Stefan Dösinger2a24e842006-12-06 13:22:12 +0100[diff] [blame]512 { /*140, WINED3DRS_FOGVERTEXMODE */ STATE_RENDER(WINED3DRS_FOGENABLE), state_unknown },
513 { /*141, WINED3DRS_COLORVERTEX */ STATE_RENDER(WINED3DRS_COLORVERTEX), state_unknown },
514 { /*142, WINED3DRS_LOCALVIEWER */ STATE_RENDER(WINED3DRS_LOCALVIEWER), state_unknown },
515 { /*143, WINED3DRS_NORMALIZENORMALS */ STATE_RENDER(WINED3DRS_NORMALIZENORMALS), state_unknown },
516 { /*144, WINED3DRS_COLORKEYBLENDENABLE */ STATE_RENDER(WINED3DRS_COLORKEYBLENDENABLE), state_unknown },
517 { /*145, WINED3DRS_DIFFUSEMATERIALSOURCE */ STATE_RENDER(WINED3DRS_COLORVERTEX), state_unknown },
518 { /*146, WINED3DRS_SPECULARMATERIALSOURCE */ STATE_RENDER(WINED3DRS_COLORVERTEX), state_unknown },
519 { /*147, WINED3DRS_AMBIENTMATERIALSOURCE */ STATE_RENDER(WINED3DRS_COLORVERTEX), state_unknown },
520 { /*148, WINED3DRS_EMISSIVEMATERIALSOURCE */ STATE_RENDER(WINED3DRS_COLORVERTEX), state_unknown },
521 { /*149, Undefined */ 0, state_undefined },
522 { /*150, Undefined */ 0, state_undefined },
523 { /*151, WINED3DRS_VERTEXBLEND */ 0, state_nogl },
524 { /*152, WINED3DRS_CLIPPLANEENABLE */ STATE_RENDER(WINED3DRS_CLIPPING), state_unknown },
525 { /*153, WINED3DRS_SOFTWAREVERTEXPROCESSING */ 0, state_nogl },
526 { /*154, WINED3DRS_POINTSIZE */ STATE_RENDER(WINED3DRS_POINTSIZE), state_unknown },
527 { /*155, WINED3DRS_POINTSIZE_MIN */ STATE_RENDER(WINED3DRS_POINTSIZE_MIN), state_unknown },
528 { /*156, WINED3DRS_POINTSPRITEENABLE */ STATE_RENDER(WINED3DRS_POINTSPRITEENABLE), state_unknown },
529 { /*157, WINED3DRS_POINTSCALEENABLE */ STATE_RENDER(WINED3DRS_POINTSCALEENABLE), state_unknown },
530 { /*158, WINED3DRS_POINTSCALE_A */ STATE_RENDER(WINED3DRS_POINTSCALEENABLE), state_unknown },
531 { /*159, WINED3DRS_POINTSCALE_B */ STATE_RENDER(WINED3DRS_POINTSCALEENABLE), state_unknown },
532 { /*160, WINED3DRS_POINTSCALE_C */ STATE_RENDER(WINED3DRS_POINTSCALEENABLE), state_unknown },
533 { /*161, WINED3DRS_MULTISAMPLEANTIALIAS */ STATE_RENDER(WINED3DRS_MULTISAMPLEANTIALIAS), state_unknown },
534 { /*162, WINED3DRS_MULTISAMPLEMASK */ STATE_RENDER(WINED3DRS_MULTISAMPLEMASK), state_unknown },
535 { /*163, WINED3DRS_PATCHEDGESTYLE */ STATE_RENDER(WINED3DRS_PATCHEDGESTYLE), state_unknown },
536 { /*164, WINED3DRS_PATCHSEGMENTS */ STATE_RENDER(WINED3DRS_PATCHSEGMENTS), state_unknown },
537 { /*165, WINED3DRS_DEBUGMONITORTOKEN */ STATE_RENDER(WINED3DRS_DEBUGMONITORTOKEN), state_unknown },
538 { /*166, WINED3DRS_POINTSIZE_MAX */ STATE_RENDER(WINED3DRS_POINTSIZE_MAX), state_unknown },
539 { /*167, WINED3DRS_INDEXEDVERTEXBLENDENABLE */ STATE_RENDER(WINED3DRS_INDEXEDVERTEXBLENDENABLE), state_unknown },
540 { /*168, WINED3DRS_COLORWRITEENABLE */ STATE_RENDER(WINED3DRS_COLORWRITEENABLE), state_unknown },
541 { /*169, Undefined */ 0, state_undefined },
542 { /*170, WINED3DRS_TWEENFACTOR */ 0, state_nogl },
543 { /*171, WINED3DRS_BLENDOP */ STATE_RENDER(WINED3DRS_BLENDOP), state_unknown },
544 { /*172, WINED3DRS_POSITIONDEGREE */ STATE_RENDER(WINED3DRS_POSITIONDEGREE), state_unknown },
545 { /*173, WINED3DRS_NORMALDEGREE */ STATE_RENDER(WINED3DRS_NORMALDEGREE), state_unknown },
546 /*172, WINED3DRS_POSITIONORDER */ /* Value assigned to 2 state names */
547 /*173, WINED3DRS_NORMALORDER */ /* Value assigned to 2 state names */
548 { /*174, WINED3DRS_SCISSORTESTENABLE */ STATE_RENDER(WINED3DRS_SCISSORTESTENABLE), state_unknown },
549 { /*175, WINED3DRS_SLOPESCALEDEPTHBIAS */ STATE_RENDER(WINED3DRS_DEPTHBIAS), state_unknown },
Stefan Dösinger1f07e4a2006-12-08 01:51:11 +0100[diff] [blame]550 { /*176, WINED3DRS_ANTIALIASEDLINEENABLE */ STATE_RENDER(WINED3DRS_ALPHABLENDENABLE), state_blend },
Stefan Dösinger2a24e842006-12-06 13:22:12 +0100[diff] [blame]551 { /*177, undefined */ 0, state_undefined },
552 { /*178, WINED3DRS_MINTESSELLATIONLEVEL */ STATE_RENDER(WINED3DRS_ENABLEADAPTIVETESSELLATION), state_unknown },
553 { /*179, WINED3DRS_MAXTESSELLATIONLEVEL */ STATE_RENDER(WINED3DRS_ENABLEADAPTIVETESSELLATION), state_unknown },
554 { /*180, WINED3DRS_ADAPTIVETESS_X */ STATE_RENDER(WINED3DRS_ENABLEADAPTIVETESSELLATION), state_unknown },
555 { /*181, WINED3DRS_ADAPTIVETESS_Y */ STATE_RENDER(WINED3DRS_ENABLEADAPTIVETESSELLATION), state_unknown },
556 { /*182, WINED3DRS_ADAPTIVETESS_Z */ STATE_RENDER(WINED3DRS_ENABLEADAPTIVETESSELLATION), state_unknown },
557 { /*183, WINED3DRS_ADAPTIVETESS_W */ STATE_RENDER(WINED3DRS_ENABLEADAPTIVETESSELLATION), state_unknown },
558 { /*184, WINED3DRS_ENABLEADAPTIVETESSELLATION */ STATE_RENDER(WINED3DRS_ENABLEADAPTIVETESSELLATION), state_unknown },
559 { /*185, WINED3DRS_TWOSIDEDSTENCILMODE */ STATE_RENDER(WINED3DRS_STENCILENABLE), state_unknown },
560 { /*186, WINED3DRS_CCW_STENCILFAIL */ STATE_RENDER(WINED3DRS_STENCILENABLE), state_unknown },
561 { /*187, WINED3DRS_CCW_STENCILZFAIL */ STATE_RENDER(WINED3DRS_STENCILENABLE), state_unknown },
562 { /*188, WINED3DRS_CCW_STENCILPASS */ STATE_RENDER(WINED3DRS_STENCILENABLE), state_unknown },
563 { /*189, WINED3DRS_CCW_STENCILFUNC */ STATE_RENDER(WINED3DRS_STENCILENABLE), state_unknown },
564 { /*190, WINED3DRS_COLORWRITEENABLE1 */ STATE_RENDER(WINED3DRS_COLORWRITEENABLE), state_unknown },
565 { /*191, WINED3DRS_COLORWRITEENABLE2 */ STATE_RENDER(WINED3DRS_COLORWRITEENABLE), state_unknown },
566 { /*192, WINED3DRS_COLORWRITEENABLE3 */ STATE_RENDER(WINED3DRS_COLORWRITEENABLE), state_unknown },
Stefan Dösinger1f07e4a2006-12-08 01:51:11 +0100[diff] [blame]567 { /*193, WINED3DRS_BLENDFACTOR */ STATE_RENDER(WINED3DRS_ALPHABLENDENABLE), state_blend },
Stefan Dösinger2a24e842006-12-06 13:22:12 +0100[diff] [blame]568 { /*194, WINED3DRS_SRGBWRITEENABLE */ 0, state_nogl },
569 { /*195, WINED3DRS_DEPTHBIAS */ STATE_RENDER(WINED3DRS_DEPTHBIAS), state_unknown },
570 { /*196, undefined */ 0, state_undefined },
571 { /*197, undefined */ 0, state_undefined },
572 { /*198, WINED3DRS_WRAP8 */ STATE_RENDER(WINED3DRS_WRAP0), state_unknown },
573 { /*199, WINED3DRS_WRAP9 */ STATE_RENDER(WINED3DRS_WRAP0), state_unknown },
574 { /*200, WINED3DRS_WRAP10 */ STATE_RENDER(WINED3DRS_WRAP0), state_unknown },
575 { /*201, WINED3DRS_WRAP11 */ STATE_RENDER(WINED3DRS_WRAP0), state_unknown },
576 { /*202, WINED3DRS_WRAP12 */ STATE_RENDER(WINED3DRS_WRAP0), state_unknown },
577 { /*203, WINED3DRS_WRAP13 */ STATE_RENDER(WINED3DRS_WRAP0), state_unknown },
578 { /*204, WINED3DRS_WRAP14 */ STATE_RENDER(WINED3DRS_WRAP0), state_unknown },
579 { /*205, WINED3DRS_WRAP15 */ STATE_RENDER(WINED3DRS_WRAP0), state_unknown },
580 { /*206, WINED3DRS_SEPARATEALPHABLENDENABLE */ STATE_RENDER(WINED3DRS_SEPARATEALPHABLENDENABLE), state_unknown },
581 { /*207, WINED3DRS_SRCBLENDALPHA */ STATE_RENDER(WINED3DRS_SEPARATEALPHABLENDENABLE), state_unknown },
582 { /*208, WINED3DRS_DESTBLENDALPHA */ STATE_RENDER(WINED3DRS_SEPARATEALPHABLENDENABLE), state_unknown },
583 { /*209, WINED3DRS_BLENDOPALPHA */ STATE_RENDER(WINED3DRS_SEPARATEALPHABLENDENABLE), state_unknown },
Stefan Dösingerc0268c72006-12-05 23:36:10 +0100[diff] [blame]584};