2 * Direct3D state management
4 * Copyright 2006 Stefan Dösinger for CodeWeavers
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.
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.
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
26 #include "wined3d_private.h"
28 WINE_DEFAULT_DEBUG_CHANNEL(d3d);
30 #define GLINFO_LOCATION ((IWineD3DImpl *)(stateblock->wineD3DDevice->wineD3D))->gl_info
32 static void state_unknown(DWORD state, IWineD3DStateBlockImpl *stateblock) {
33 /* State which does exist, but wined3d doesn't know about */
34 if(STATE_IS_RENDER(state)) {
35 WINED3DRENDERSTATETYPE RenderState = state - STATE_RENDER(0);
36 FIXME("(%s, %d) Unknown renderstate\n", debug_d3drenderstate(RenderState), stateblock->renderState[RenderState]);
38 FIXME("(%d) Unknown state with unknown type\n", state);
42 static void state_nogl(DWORD state, IWineD3DStateBlockImpl *stateblock) {
43 /* Used for states which are not mapped to a gl state as-is, but used somehow different,
44 * e.g as a parameter for drawing, or which are unimplemented in windows d3d
46 if(STATE_IS_RENDER(state)) {
47 WINED3DRENDERSTATETYPE RenderState = state - STATE_RENDER(0);
48 TRACE("(%s,%d) no direct mapping to gl\n", debug_d3drenderstate(RenderState), stateblock->renderState[RenderState]);
50 /* Shouldn't have an unknown type here */
51 FIXME("%d no direct mapping to gl of state with unknown type\n", state);
55 static void state_undefined(DWORD state, IWineD3DStateBlockImpl *stateblock) {
56 /* Print a WARN, this allows the stateblock code to loop over all states to generate a display
57 * list without causing confusing terminal output. Deliberately no special debug name here
58 * because its undefined.
60 WARN("undefined state %d\n", state);
63 static void state_fillmode(DWORD state, IWineD3DStateBlockImpl *stateblock) {
64 D3DFILLMODE Value = stateblock->renderState[WINED3DRS_FILLMODE];
68 glPolygonMode(GL_FRONT_AND_BACK, GL_POINT);
69 checkGLcall("glPolygonMode(GL_FRONT_AND_BACK, GL_POINT)");
71 case D3DFILL_WIREFRAME:
72 glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
73 checkGLcall("glPolygonMode(GL_FRONT_AND_BACK, GL_LINE)");
76 glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
77 checkGLcall("glPolygonMode(GL_FRONT_AND_BACK, GL_FILL)");
80 FIXME("Unrecognized WINED3DRS_FILLMODE value %d\n", Value);
84 static void state_lighting(DWORD state, IWineD3DStateBlockImpl *stateblock) {
86 /* TODO: Lighting is only enabled if Vertex normals are passed by the application,
87 * so merge the lighting render state with the vertex declaration once it is available
90 if (stateblock->renderState[WINED3DRS_LIGHTING]) {
91 glEnable(GL_LIGHTING);
92 checkGLcall("glEnable GL_LIGHTING");
94 glDisable(GL_LIGHTING);
95 checkGLcall("glDisable GL_LIGHTING");
99 static void state_zenable(DWORD state, IWineD3DStateBlockImpl *stateblock) {
100 switch ((WINED3DZBUFFERTYPE) stateblock->renderState[WINED3DRS_ZENABLE]) {
101 case WINED3DZB_FALSE:
102 glDisable(GL_DEPTH_TEST);
103 checkGLcall("glDisable GL_DEPTH_TEST");
106 glEnable(GL_DEPTH_TEST);
107 checkGLcall("glEnable GL_DEPTH_TEST");
110 glEnable(GL_DEPTH_TEST);
111 checkGLcall("glEnable GL_DEPTH_TEST");
112 FIXME("W buffer is not well handled\n");
115 FIXME("Unrecognized D3DZBUFFERTYPE value %d\n", stateblock->renderState[WINED3DRS_ZENABLE]);
119 static void state_cullmode(DWORD state, IWineD3DStateBlockImpl *stateblock) {
120 /* TODO: Put this into the offscreen / onscreen rendering block due to device->render_offscreen */
122 /* If we are culling "back faces with clockwise vertices" then
123 set front faces to be counter clockwise and enable culling
125 switch ((WINED3DCULL) stateblock->renderState[WINED3DRS_CULLMODE]) {
126 case WINED3DCULL_NONE:
127 glDisable(GL_CULL_FACE);
128 checkGLcall("glDisable GL_CULL_FACE");
131 glEnable(GL_CULL_FACE);
132 checkGLcall("glEnable GL_CULL_FACE");
133 if (stateblock->wineD3DDevice->render_offscreen) {
135 checkGLcall("glFrontFace GL_CW");
138 checkGLcall("glFrontFace GL_CCW");
142 case WINED3DCULL_CCW:
143 glEnable(GL_CULL_FACE);
144 checkGLcall("glEnable GL_CULL_FACE");
145 if (stateblock->wineD3DDevice->render_offscreen) {
147 checkGLcall("glFrontFace GL_CCW");
150 checkGLcall("glFrontFace GL_CW");
155 FIXME("Unrecognized/Unhandled WINED3DCULL value %d\n", stateblock->renderState[WINED3DRS_CULLMODE]);
159 static void state_shademode(DWORD state, IWineD3DStateBlockImpl *stateblock) {
160 switch ((WINED3DSHADEMODE) stateblock->renderState[WINED3DRS_SHADEMODE]) {
161 case WINED3DSHADE_FLAT:
162 glShadeModel(GL_FLAT);
163 checkGLcall("glShadeModel(GL_FLAT)");
165 case WINED3DSHADE_GOURAUD:
166 glShadeModel(GL_SMOOTH);
167 checkGLcall("glShadeModel(GL_SMOOTH)");
169 case WINED3DSHADE_PHONG:
170 FIXME("WINED3DSHADE_PHONG isn't supported\n");
173 FIXME("Unrecognized/Unhandled WINED3DSHADEMODE value %d\n", stateblock->renderState[WINED3DRS_SHADEMODE]);
177 static void state_ditherenable(DWORD state, IWineD3DStateBlockImpl *stateblock) {
178 if (stateblock->renderState[WINED3DRS_DITHERENABLE]) {
180 checkGLcall("glEnable GL_DITHER");
182 glDisable(GL_DITHER);
183 checkGLcall("glDisable GL_DITHER");
187 static void state_zwritenable(DWORD state, IWineD3DStateBlockImpl *stateblock) {
188 /* TODO: Test if in d3d z writing is enabled even if ZENABLE is off. If yes,
189 * this has to be merged with ZENABLE and ZFUNC
191 if (stateblock->renderState[WINED3DRS_ZWRITEENABLE]) {
193 checkGLcall("glDepthMask(1)");
196 checkGLcall("glDepthMask(0)");
200 static void state_zfunc(DWORD state, IWineD3DStateBlockImpl *stateblock) {
201 int glParm = CompareFunc(stateblock->renderState[WINED3DRS_ZFUNC]);
205 checkGLcall("glDepthFunc");
209 static void state_ambient(DWORD state, IWineD3DStateBlockImpl *stateblock) {
211 D3DCOLORTOGLFLOAT4(stateblock->renderState[WINED3DRS_AMBIENT], col);
213 TRACE("Setting ambient to (%f,%f,%f,%f)\n", col[0], col[1], col[2], col[3]);
214 glLightModelfv(GL_LIGHT_MODEL_AMBIENT, col);
215 checkGLcall("glLightModel for MODEL_AMBIENT");
218 static void state_blend(DWORD state, IWineD3DStateBlockImpl *stateblock) {
219 int srcBlend = GL_ZERO;
220 int dstBlend = GL_ZERO;
223 /* GL_LINE_SMOOTH needs GL_BLEND to work, according to the red book, and special blending params */
224 /* TODO: Is enabling blending really affected by the blendfactor??? */
225 if (stateblock->renderState[WINED3DRS_ALPHABLENDENABLE] ||
226 stateblock->renderState[WINED3DRS_EDGEANTIALIAS] ||
227 stateblock->renderState[WINED3DRS_ANTIALIASEDLINEENABLE] ||
228 stateblock->renderState[WINED3DRS_BLENDFACTOR] != 0xFFFFFFFF) {
230 checkGLcall("glEnable GL_BLEND");
233 checkGLcall("glDisable GL_BLEND");
234 /* Nothing more to do - get out */
238 switch (stateblock->renderState[WINED3DRS_SRCBLEND]) {
239 case WINED3DBLEND_ZERO : srcBlend = GL_ZERO; break;
240 case WINED3DBLEND_ONE : srcBlend = GL_ONE; break;
241 case WINED3DBLEND_SRCCOLOR : srcBlend = GL_SRC_COLOR; break;
242 case WINED3DBLEND_INVSRCCOLOR : srcBlend = GL_ONE_MINUS_SRC_COLOR; break;
243 case WINED3DBLEND_SRCALPHA : srcBlend = GL_SRC_ALPHA; break;
244 case WINED3DBLEND_INVSRCALPHA : srcBlend = GL_ONE_MINUS_SRC_ALPHA; break;
245 case WINED3DBLEND_DESTALPHA : srcBlend = GL_DST_ALPHA; break;
246 case WINED3DBLEND_INVDESTALPHA : srcBlend = GL_ONE_MINUS_DST_ALPHA; break;
247 case WINED3DBLEND_DESTCOLOR : srcBlend = GL_DST_COLOR; break;
248 case WINED3DBLEND_INVDESTCOLOR : srcBlend = GL_ONE_MINUS_DST_COLOR; break;
249 case WINED3DBLEND_SRCALPHASAT : srcBlend = GL_SRC_ALPHA_SATURATE; break;
251 case WINED3DBLEND_BOTHSRCALPHA : srcBlend = GL_SRC_ALPHA;
252 dstBlend = GL_SRC_ALPHA;
255 case WINED3DBLEND_BOTHINVSRCALPHA : srcBlend = GL_ONE_MINUS_SRC_ALPHA;
256 dstBlend = GL_ONE_MINUS_SRC_ALPHA;
259 case WINED3DBLEND_BLENDFACTOR : srcBlend = GL_CONSTANT_COLOR; break;
260 case WINED3DBLEND_INVBLENDFACTOR : srcBlend = GL_ONE_MINUS_CONSTANT_COLOR; break;
262 FIXME("Unrecognized src blend value %d\n", stateblock->renderState[WINED3DRS_SRCBLEND]);
265 switch (stateblock->renderState[WINED3DRS_DESTBLEND]) {
266 case WINED3DBLEND_ZERO : dstBlend = GL_ZERO; break;
267 case WINED3DBLEND_ONE : dstBlend = GL_ONE; break;
268 case WINED3DBLEND_SRCCOLOR : dstBlend = GL_SRC_COLOR; break;
269 case WINED3DBLEND_INVSRCCOLOR : dstBlend = GL_ONE_MINUS_SRC_COLOR; break;
270 case WINED3DBLEND_SRCALPHA : dstBlend = GL_SRC_ALPHA; break;
271 case WINED3DBLEND_INVSRCALPHA : dstBlend = GL_ONE_MINUS_SRC_ALPHA; break;
272 case WINED3DBLEND_DESTALPHA : dstBlend = GL_DST_ALPHA; break;
273 case WINED3DBLEND_INVDESTALPHA : dstBlend = GL_ONE_MINUS_DST_ALPHA; break;
274 case WINED3DBLEND_DESTCOLOR : dstBlend = GL_DST_COLOR; break;
275 case WINED3DBLEND_INVDESTCOLOR : dstBlend = GL_ONE_MINUS_DST_COLOR; break;
276 case WINED3DBLEND_SRCALPHASAT : dstBlend = GL_SRC_ALPHA_SATURATE; break;
278 case WINED3DBLEND_BOTHSRCALPHA : dstBlend = GL_SRC_ALPHA;
279 srcBlend = GL_SRC_ALPHA;
282 case WINED3DBLEND_BOTHINVSRCALPHA : dstBlend = GL_ONE_MINUS_SRC_ALPHA;
283 srcBlend = GL_ONE_MINUS_SRC_ALPHA;
286 case D3DBLEND_BLENDFACTOR : dstBlend = GL_CONSTANT_COLOR; break;
287 case D3DBLEND_INVBLENDFACTOR : dstBlend = GL_ONE_MINUS_CONSTANT_COLOR; break;
289 FIXME("Unrecognized dst blend value %d\n", stateblock->renderState[WINED3DRS_DESTBLEND]);
292 if(stateblock->renderState[WINED3DRS_EDGEANTIALIAS] ||
293 stateblock->renderState[WINED3DRS_ANTIALIASEDLINEENABLE]) {
294 glEnable(GL_LINE_SMOOTH);
295 checkGLcall("glEnable(GL_LINE_SMOOTH)");
296 if(srcBlend != GL_SRC_ALPHA) {
297 FIXME("WINED3DRS_EDGEANTIALIAS enabled, but incompatible src blending param - what to do?\n");
298 srcBlend = GL_SRC_ALPHA;
300 if(dstBlend != GL_ONE_MINUS_SRC_ALPHA) {
301 FIXME("WINED3DRS_EDGEANTIALIAS enabled, but incompatible dst blending param - what to do?\n");
302 dstBlend = GL_ONE_MINUS_SRC_ALPHA;
305 glDisable(GL_LINE_SMOOTH);
306 checkGLcall("glDisable(GL_LINE_SMOOTH)");
309 TRACE("glBlendFunc src=%x, dst=%x\n", srcBlend, dstBlend);
310 glBlendFunc(srcBlend, dstBlend);
311 checkGLcall("glBlendFunc");
313 /* TODO: Remove when state management done */
314 stateblock->wineD3DDevice->dstBlend = dstBlend;
315 stateblock->wineD3DDevice->srcBlend = srcBlend;
317 TRACE("Setting BlendFactor to %d\n", stateblock->renderState[WINED3DRS_BLENDFACTOR]);
318 D3DCOLORTOGLFLOAT4(stateblock->renderState[WINED3DRS_BLENDFACTOR], col);
319 glBlendColor (col[0],col[1],col[2],col[3]);
320 checkGLcall("glBlendColor");
323 static void state_alpha(DWORD state, IWineD3DStateBlockImpl *stateblock) {
326 BOOL enable_ckey = FALSE;
328 IWineD3DSurfaceImpl *surf;
330 /* Find out if the texture on the first stage has a ckey set
331 * The alpha state func reads the texture settings, even though alpha and texture are not grouped
332 * together. This is to avoid making a huge alpha+texture+texture stage+ckey block due to the hardly
333 * used WINED3DRS_COLORKEYENABLE state(which is d3d <= 3 only). The texture function will call alpha
334 * in case it finds some texture+colorkeyenable combination which needs extra care.
336 if(stateblock->textures[0]) {
337 surf = (IWineD3DSurfaceImpl *) ((IWineD3DTextureImpl *)stateblock->textures[0])->surfaces[0];
338 if(surf->CKeyFlags & DDSD_CKSRCBLT) enable_ckey = TRUE;
341 if (stateblock->renderState[WINED3DRS_ALPHATESTENABLE] ||
342 (stateblock->renderState[WINED3DRS_COLORKEYENABLE] && enable_ckey)) {
343 glEnable(GL_ALPHA_TEST);
344 checkGLcall("glEnable GL_ALPHA_TEST");
346 glDisable(GL_ALPHA_TEST);
347 checkGLcall("glDisable GL_ALPHA_TEST");
348 /* Alpha test is disabled, don't bother setting the params - it will happen on the next
354 if(stateblock->renderState[WINED3DRS_COLORKEYENABLE] && enable_ckey) {
355 glParm = GL_NOTEQUAL;
358 ref = ((float) stateblock->renderState[WINED3DRS_ALPHAREF]) / 255.0f;
359 glParm = CompareFunc(stateblock->renderState[WINED3DRS_ALPHAFUNC]);
362 stateblock->wineD3DDevice->alphafunc = glParm; /* Remove when state management done */
363 glAlphaFunc(glParm, ref);
364 checkGLcall("glAlphaFunc");
366 /* TODO: Some texture blending operations seem to affect the alpha test */
369 static void state_clipping(DWORD state, IWineD3DStateBlockImpl *stateblock) {
370 DWORD enable = 0xFFFFFFFF;
371 DWORD disable = 0x00000000;
373 /* TODO: Keep track of previously enabled clipplanes to avoid unneccessary resetting
374 * of already set values
377 /* If enabling / disabling all
378 * TODO: Is this correct? Doesn't D3DRS_CLIPPING disable clipping on the viewport frustrum?
380 if (stateblock->renderState[WINED3DRS_CLIPPING]) {
381 enable = stateblock->renderState[WINED3DRS_CLIPPLANEENABLE];
382 disable = ~stateblock->renderState[WINED3DRS_CLIPPLANEENABLE];
384 disable = 0xffffffff;
388 if (enable & WINED3DCLIPPLANE0) { glEnable(GL_CLIP_PLANE0); checkGLcall("glEnable(clip plane 0)"); }
389 if (enable & WINED3DCLIPPLANE1) { glEnable(GL_CLIP_PLANE1); checkGLcall("glEnable(clip plane 1)"); }
390 if (enable & WINED3DCLIPPLANE2) { glEnable(GL_CLIP_PLANE2); checkGLcall("glEnable(clip plane 2)"); }
391 if (enable & WINED3DCLIPPLANE3) { glEnable(GL_CLIP_PLANE3); checkGLcall("glEnable(clip plane 3)"); }
392 if (enable & WINED3DCLIPPLANE4) { glEnable(GL_CLIP_PLANE4); checkGLcall("glEnable(clip plane 4)"); }
393 if (enable & WINED3DCLIPPLANE5) { glEnable(GL_CLIP_PLANE5); checkGLcall("glEnable(clip plane 5)"); }
395 if (disable & WINED3DCLIPPLANE0) { glDisable(GL_CLIP_PLANE0); checkGLcall("glDisable(clip plane 0)"); }
396 if (disable & WINED3DCLIPPLANE1) { glDisable(GL_CLIP_PLANE1); checkGLcall("glDisable(clip plane 1)"); }
397 if (disable & WINED3DCLIPPLANE2) { glDisable(GL_CLIP_PLANE2); checkGLcall("glDisable(clip plane 2)"); }
398 if (disable & WINED3DCLIPPLANE3) { glDisable(GL_CLIP_PLANE3); checkGLcall("glDisable(clip plane 3)"); }
399 if (disable & WINED3DCLIPPLANE4) { glDisable(GL_CLIP_PLANE4); checkGLcall("glDisable(clip plane 4)"); }
400 if (disable & WINED3DCLIPPLANE5) { glDisable(GL_CLIP_PLANE5); checkGLcall("glDisable(clip plane 5)"); }
402 /** update clipping status */
404 stateblock->clip_status.ClipUnion = 0;
405 stateblock->clip_status.ClipIntersection = 0xFFFFFFFF;
407 stateblock->clip_status.ClipUnion = 0;
408 stateblock->clip_status.ClipIntersection = 0;
412 static void state_blendop(DWORD state, IWineD3DStateBlockImpl *stateblock) {
413 int glParm = GL_FUNC_ADD;
415 if(!GL_SUPPORT(EXT_BLEND_MINMAX)) {
416 WARN("Unsupported in local OpenGL implementation: glBlendEquation\n");
420 switch ((WINED3DBLENDOP) stateblock->renderState[WINED3DRS_BLENDOP]) {
421 case WINED3DBLENDOP_ADD : glParm = GL_FUNC_ADD; break;
422 case WINED3DBLENDOP_SUBTRACT : glParm = GL_FUNC_SUBTRACT; break;
423 case WINED3DBLENDOP_REVSUBTRACT : glParm = GL_FUNC_REVERSE_SUBTRACT; break;
424 case WINED3DBLENDOP_MIN : glParm = GL_MIN; break;
425 case WINED3DBLENDOP_MAX : glParm = GL_MAX; break;
427 FIXME("Unrecognized/Unhandled D3DBLENDOP value %d\n", stateblock->renderState[WINED3DRS_BLENDOP]);
430 TRACE("glBlendEquation(%x)\n", glParm);
431 GL_EXTCALL(glBlendEquation(glParm));
432 checkGLcall("glBlendEquation");
435 const struct StateEntry StateTable[] =
437 /* State name representative, apply function */
438 { /* 0, Undefined */ 0, state_undefined },
439 { /* 1, WINED3DRS_TEXTUREHANDLE */ 0 /* Handled in ddraw */, state_undefined },
440 { /* 2, WINED3DRS_ANTIALIAS */ STATE_RENDER(WINED3DRS_ANTIALIAS), state_unknown },
441 { /* 3, WINED3DRS_TEXTUREADDRESS */ 0 /* Handled in ddraw */, state_undefined },
442 { /* 4, WINED3DRS_TEXTUREPERSPECTIVE */ STATE_RENDER(WINED3DRS_TEXTUREPERSPECTIVE), state_unknown },
443 { /* 5, WINED3DRS_WRAPU */ STATE_RENDER(WINED3DRS_WRAPU), state_unknown },
444 { /* 6, WINED3DRS_WRAPV */ STATE_RENDER(WINED3DRS_WRAPV), state_unknown },
445 { /* 7, WINED3DRS_ZENABLE */ STATE_RENDER(WINED3DRS_ZENABLE), state_zenable },
446 { /* 8, WINED3DRS_FILLMODE */ STATE_RENDER(WINED3DRS_FILLMODE), state_fillmode },
447 { /* 9, WINED3DRS_SHADEMODE */ STATE_RENDER(WINED3DRS_SHADEMODE), state_shademode },
448 { /* 10, WINED3DRS_LINEPATTERN */ STATE_RENDER(WINED3DRS_LINEPATTERN), state_unknown },
449 { /* 11, WINED3DRS_MONOENABLE */ STATE_RENDER(WINED3DRS_MONOENABLE), state_unknown },
450 { /* 12, WINED3DRS_ROP2 */ STATE_RENDER(WINED3DRS_ROP2), state_unknown },
451 { /* 13, WINED3DRS_PLANEMASK */ STATE_RENDER(WINED3DRS_PLANEMASK), state_unknown },
452 { /* 14, WINED3DRS_ZWRITEENABLE */ STATE_RENDER(WINED3DRS_ZWRITEENABLE), state_zwritenable },
453 { /* 15, WINED3DRS_ALPHATESTENABLE */ STATE_RENDER(WINED3DRS_ALPHATESTENABLE), state_alpha },
454 { /* 16, WINED3DRS_LASTPIXEL */ STATE_RENDER(WINED3DRS_LASTPIXEL), state_unknown },
455 { /* 17, WINED3DRS_TEXTUREMAG */ 0 /* Handled in ddraw */, state_undefined },
456 { /* 18, WINED3DRS_TEXTUREMIN */ 0 /* Handled in ddraw */, state_undefined },
457 { /* 19, WINED3DRS_SRCBLEND */ STATE_RENDER(WINED3DRS_ALPHABLENDENABLE), state_blend },
458 { /* 20, WINED3DRS_DESTBLEND */ STATE_RENDER(WINED3DRS_ALPHABLENDENABLE), state_blend },
459 { /* 21, WINED3DRS_TEXTUREMAPBLEND */ 0 /* Handled in ddraw */, state_undefined },
460 { /* 22, WINED3DRS_CULLMODE */ STATE_RENDER(WINED3DRS_CULLMODE), state_cullmode },
461 { /* 23, WINED3DRS_ZFUNC */ STATE_RENDER(WINED3DRS_ZFUNC), state_zfunc },
462 { /* 24, WINED3DRS_ALPHAREF */ STATE_RENDER(WINED3DRS_ALPHATESTENABLE), state_alpha },
463 { /* 25, WINED3DRS_ALPHAFUNC */ STATE_RENDER(WINED3DRS_ALPHATESTENABLE), state_alpha },
464 { /* 26, WINED3DRS_DITHERENABLE */ STATE_RENDER(WINED3DRS_DITHERENABLE), state_ditherenable },
465 { /* 27, WINED3DRS_ALPHABLENDENABLE */ STATE_RENDER(WINED3DRS_ALPHABLENDENABLE), state_blend },
466 { /* 28, WINED3DRS_FOGENABLE */ STATE_RENDER(WINED3DRS_FOGENABLE), state_unknown },
467 { /* 29, WINED3DRS_SPECULARENABLE */ STATE_RENDER(WINED3DRS_SPECULARENABLE), state_unknown },
468 { /* 30, WINED3DRS_ZVISIBLE */ 0 /* Not supported according to the msdn */, state_nogl },
469 { /* 31, WINED3DRS_SUBPIXEL */ STATE_RENDER(WINED3DRS_SUBPIXEL), state_unknown },
470 { /* 32, WINED3DRS_SUBPIXELX */ STATE_RENDER(WINED3DRS_SUBPIXELX), state_unknown },
471 { /* 33, WINED3DRS_STIPPLEDALPHA */ STATE_RENDER(WINED3DRS_STIPPLEDALPHA), state_unknown },
472 { /* 34, WINED3DRS_FOGCOLOR */ STATE_RENDER(WINED3DRS_FOGCOLOR), state_unknown },
473 { /* 35, WINED3DRS_FOGTABLEMODE */ STATE_RENDER(WINED3DRS_FOGENABLE)/*vertex type*/, state_unknown },
474 { /* 36, WINED3DRS_FOGSTART */ STATE_RENDER(WINED3DRS_FOGENABLE), state_unknown },
475 { /* 37, WINED3DRS_FOGEND */ STATE_RENDER(WINED3DRS_FOGENABLE), state_unknown },
476 { /* 38, WINED3DRS_FOGDENSITY */ STATE_RENDER(WINED3DRS_FOGDENSITY), state_unknown },
477 { /* 39, WINED3DRS_STIPPLEENABLE */ STATE_RENDER(WINED3DRS_STIPPLEENABLE), state_unknown },
478 { /* 40, WINED3DRS_EDGEANTIALIAS */ STATE_RENDER(WINED3DRS_ALPHABLENDENABLE), state_blend },
479 { /* 41, WINED3DRS_COLORKEYENABLE */ STATE_RENDER(WINED3DRS_ALPHATESTENABLE), state_alpha },
480 { /* 42, undefined */ 0, state_undefined },
481 { /* 43, WINED3DRS_BORDERCOLOR */ STATE_RENDER(WINED3DRS_BORDERCOLOR), state_unknown },
482 { /* 44, WINED3DRS_TEXTUREADDRESSU */ 0, /* Handled in ddraw */ state_undefined },
483 { /* 45, WINED3DRS_TEXTUREADDRESSV */ 0, /* Handled in ddraw */ state_undefined },
484 { /* 46, WINED3DRS_MIPMAPLODBIAS */ STATE_RENDER(WINED3DRS_MIPMAPLODBIAS), state_unknown },
485 { /* 47, WINED3DRS_ZBIAS */ STATE_RENDER(WINED3DRS_ZBIAS), state_unknown },
486 { /* 48, WINED3DRS_RANGEFOGENABLE */ STATE_RENDER(WINED3DRS_RANGEFOGENABLE), state_unknown },
487 { /* 49, WINED3DRS_ANISOTROPY */ STATE_RENDER(WINED3DRS_ANISOTROPY), state_unknown },
488 { /* 50, WINED3DRS_FLUSHBATCH */ STATE_RENDER(WINED3DRS_FLUSHBATCH), state_unknown },
489 { /* 51, WINED3DRS_TRANSLUCENTSORTINDEPENDENT */ STATE_RENDER(WINED3DRS_TRANSLUCENTSORTINDEPENDENT), state_unknown },
490 { /* 52, WINED3DRS_STENCILENABLE */ STATE_RENDER(WINED3DRS_STENCILENABLE), state_unknown },
491 { /* 53, WINED3DRS_STENCILFAIL */ STATE_RENDER(WINED3DRS_STENCILENABLE), state_unknown },
492 { /* 54, WINED3DRS_STENCILZFAIL */ STATE_RENDER(WINED3DRS_STENCILENABLE), state_unknown },
493 { /* 55, WINED3DRS_STENCILPASS */ STATE_RENDER(WINED3DRS_STENCILENABLE), state_unknown },
494 { /* 56, WINED3DRS_STENCILFUNC */ STATE_RENDER(WINED3DRS_STENCILENABLE), state_unknown },
495 { /* 57, WINED3DRS_STENCILREF */ STATE_RENDER(WINED3DRS_STENCILENABLE), state_unknown },
496 { /* 58, WINED3DRS_STENCILMASK */ STATE_RENDER(WINED3DRS_STENCILENABLE), state_unknown },
497 { /* 59, WINED3DRS_STENCILWRITEMASK */ STATE_RENDER(WINED3DRS_STENCILWRITEMASK), state_unknown },
498 { /* 60, WINED3DRS_TEXTUREFACTOR */ STATE_RENDER(WINED3DRS_TEXTUREFACTOR), state_unknown },
499 /* A BIG hole. If wanted, 'fixed' states like the vertex type or the bound shaders can be put here */
500 { /* 61, Undefined */ 0, state_undefined },
501 { /* 62, Undefined */ 0, state_undefined },
502 { /* 63, Undefined */ 0, state_undefined },
503 { /* 64, Undefined */ 0, state_undefined },
504 { /* 65, Undefined */ 0, state_undefined },
505 { /* 66, Undefined */ 0, state_undefined },
506 { /* 67, Undefined */ 0, state_undefined },
507 { /* 68, Undefined */ 0, state_undefined },
508 { /* 69, Undefined */ 0, state_undefined },
509 { /* 70, Undefined */ 0, state_undefined },
510 { /* 71, Undefined */ 0, state_undefined },
511 { /* 72, Undefined */ 0, state_undefined },
512 { /* 73, Undefined */ 0, state_undefined },
513 { /* 74, Undefined */ 0, state_undefined },
514 { /* 75, Undefined */ 0, state_undefined },
515 { /* 76, Undefined */ 0, state_undefined },
516 { /* 77, Undefined */ 0, state_undefined },
517 { /* 78, Undefined */ 0, state_undefined },
518 { /* 79, Undefined */ 0, state_undefined },
519 { /* 80, Undefined */ 0, state_undefined },
520 { /* 81, Undefined */ 0, state_undefined },
521 { /* 82, Undefined */ 0, state_undefined },
522 { /* 83, Undefined */ 0, state_undefined },
523 { /* 84, Undefined */ 0, state_undefined },
524 { /* 85, Undefined */ 0, state_undefined },
525 { /* 86, Undefined */ 0, state_undefined },
526 { /* 87, Undefined */ 0, state_undefined },
527 { /* 88, Undefined */ 0, state_undefined },
528 { /* 89, Undefined */ 0, state_undefined },
529 { /* 90, Undefined */ 0, state_undefined },
530 { /* 91, Undefined */ 0, state_undefined },
531 { /* 92, Undefined */ 0, state_undefined },
532 { /* 93, Undefined */ 0, state_undefined },
533 { /* 94, Undefined */ 0, state_undefined },
534 { /* 95, Undefined */ 0, state_undefined },
535 { /* 96, Undefined */ 0, state_undefined },
536 { /* 97, Undefined */ 0, state_undefined },
537 { /* 98, Undefined */ 0, state_undefined },
538 { /* 99, Undefined */ 0, state_undefined },
539 { /*100, Undefined */ 0, state_undefined },
540 { /*101, Undefined */ 0, state_undefined },
541 { /*102, Undefined */ 0, state_undefined },
542 { /*103, Undefined */ 0, state_undefined },
543 { /*104, Undefined */ 0, state_undefined },
544 { /*105, Undefined */ 0, state_undefined },
545 { /*106, Undefined */ 0, state_undefined },
546 { /*107, Undefined */ 0, state_undefined },
547 { /*108, Undefined */ 0, state_undefined },
548 { /*109, Undefined */ 0, state_undefined },
549 { /*110, Undefined */ 0, state_undefined },
550 { /*111, Undefined */ 0, state_undefined },
551 { /*112, Undefined */ 0, state_undefined },
552 { /*113, Undefined */ 0, state_undefined },
553 { /*114, Undefined */ 0, state_undefined },
554 { /*115, Undefined */ 0, state_undefined },
555 { /*116, Undefined */ 0, state_undefined },
556 { /*117, Undefined */ 0, state_undefined },
557 { /*118, Undefined */ 0, state_undefined },
558 { /*119, Undefined */ 0, state_undefined },
559 { /*120, Undefined */ 0, state_undefined },
560 { /*121, Undefined */ 0, state_undefined },
561 { /*122, Undefined */ 0, state_undefined },
562 { /*123, Undefined */ 0, state_undefined },
563 { /*124, Undefined */ 0, state_undefined },
564 { /*125, Undefined */ 0, state_undefined },
565 { /*126, Undefined */ 0, state_undefined },
566 { /*127, Undefined */ 0, state_undefined },
568 { /*128, WINED3DRS_WRAP0 */ STATE_RENDER(WINED3DRS_WRAP0), state_unknown },
569 { /*129, WINED3DRS_WRAP1 */ STATE_RENDER(WINED3DRS_WRAP0), state_unknown },
570 { /*130, WINED3DRS_WRAP2 */ STATE_RENDER(WINED3DRS_WRAP0), state_unknown },
571 { /*131, WINED3DRS_WRAP3 */ STATE_RENDER(WINED3DRS_WRAP0), state_unknown },
572 { /*132, WINED3DRS_WRAP4 */ STATE_RENDER(WINED3DRS_WRAP0), state_unknown },
573 { /*133, WINED3DRS_WRAP5 */ STATE_RENDER(WINED3DRS_WRAP0), state_unknown },
574 { /*134, WINED3DRS_WRAP6 */ STATE_RENDER(WINED3DRS_WRAP0), state_unknown },
575 { /*135, WINED3DRS_WRAP7 */ STATE_RENDER(WINED3DRS_WRAP0), state_unknown },
576 { /*136, WINED3DRS_CLIPPING */ STATE_RENDER(WINED3DRS_CLIPPING), state_clipping },
577 { /*137, WINED3DRS_LIGHTING */ STATE_RENDER(WINED3DRS_LIGHTING) /* Vertex decl! */,state_lighting },
578 { /*138, WINED3DRS_EXTENTS */ STATE_RENDER(WINED3DRS_EXTENTS), state_unknown },
579 { /*139, WINED3DRS_AMBIENT */ STATE_RENDER(WINED3DRS_AMBIENT), state_ambient },
580 { /*140, WINED3DRS_FOGVERTEXMODE */ STATE_RENDER(WINED3DRS_FOGENABLE), state_unknown },
581 { /*141, WINED3DRS_COLORVERTEX */ STATE_RENDER(WINED3DRS_COLORVERTEX), state_unknown },
582 { /*142, WINED3DRS_LOCALVIEWER */ STATE_RENDER(WINED3DRS_LOCALVIEWER), state_unknown },
583 { /*143, WINED3DRS_NORMALIZENORMALS */ STATE_RENDER(WINED3DRS_NORMALIZENORMALS), state_unknown },
584 { /*144, WINED3DRS_COLORKEYBLENDENABLE */ STATE_RENDER(WINED3DRS_COLORKEYBLENDENABLE), state_unknown },
585 { /*145, WINED3DRS_DIFFUSEMATERIALSOURCE */ STATE_RENDER(WINED3DRS_COLORVERTEX), state_unknown },
586 { /*146, WINED3DRS_SPECULARMATERIALSOURCE */ STATE_RENDER(WINED3DRS_COLORVERTEX), state_unknown },
587 { /*147, WINED3DRS_AMBIENTMATERIALSOURCE */ STATE_RENDER(WINED3DRS_COLORVERTEX), state_unknown },
588 { /*148, WINED3DRS_EMISSIVEMATERIALSOURCE */ STATE_RENDER(WINED3DRS_COLORVERTEX), state_unknown },
589 { /*149, Undefined */ 0, state_undefined },
590 { /*150, Undefined */ 0, state_undefined },
591 { /*151, WINED3DRS_VERTEXBLEND */ 0, state_nogl },
592 { /*152, WINED3DRS_CLIPPLANEENABLE */ STATE_RENDER(WINED3DRS_CLIPPING), state_clipping },
593 { /*153, WINED3DRS_SOFTWAREVERTEXPROCESSING */ 0, state_nogl },
594 { /*154, WINED3DRS_POINTSIZE */ STATE_RENDER(WINED3DRS_POINTSIZE), state_unknown },
595 { /*155, WINED3DRS_POINTSIZE_MIN */ STATE_RENDER(WINED3DRS_POINTSIZE_MIN), state_unknown },
596 { /*156, WINED3DRS_POINTSPRITEENABLE */ STATE_RENDER(WINED3DRS_POINTSPRITEENABLE), state_unknown },
597 { /*157, WINED3DRS_POINTSCALEENABLE */ STATE_RENDER(WINED3DRS_POINTSCALEENABLE), state_unknown },
598 { /*158, WINED3DRS_POINTSCALE_A */ STATE_RENDER(WINED3DRS_POINTSCALEENABLE), state_unknown },
599 { /*159, WINED3DRS_POINTSCALE_B */ STATE_RENDER(WINED3DRS_POINTSCALEENABLE), state_unknown },
600 { /*160, WINED3DRS_POINTSCALE_C */ STATE_RENDER(WINED3DRS_POINTSCALEENABLE), state_unknown },
601 { /*161, WINED3DRS_MULTISAMPLEANTIALIAS */ STATE_RENDER(WINED3DRS_MULTISAMPLEANTIALIAS), state_unknown },
602 { /*162, WINED3DRS_MULTISAMPLEMASK */ STATE_RENDER(WINED3DRS_MULTISAMPLEMASK), state_unknown },
603 { /*163, WINED3DRS_PATCHEDGESTYLE */ STATE_RENDER(WINED3DRS_PATCHEDGESTYLE), state_unknown },
604 { /*164, WINED3DRS_PATCHSEGMENTS */ STATE_RENDER(WINED3DRS_PATCHSEGMENTS), state_unknown },
605 { /*165, WINED3DRS_DEBUGMONITORTOKEN */ STATE_RENDER(WINED3DRS_DEBUGMONITORTOKEN), state_unknown },
606 { /*166, WINED3DRS_POINTSIZE_MAX */ STATE_RENDER(WINED3DRS_POINTSIZE_MAX), state_unknown },
607 { /*167, WINED3DRS_INDEXEDVERTEXBLENDENABLE */ STATE_RENDER(WINED3DRS_INDEXEDVERTEXBLENDENABLE), state_unknown },
608 { /*168, WINED3DRS_COLORWRITEENABLE */ STATE_RENDER(WINED3DRS_COLORWRITEENABLE), state_unknown },
609 { /*169, Undefined */ 0, state_undefined },
610 { /*170, WINED3DRS_TWEENFACTOR */ 0, state_nogl },
611 { /*171, WINED3DRS_BLENDOP */ STATE_RENDER(WINED3DRS_BLENDOP), state_blendop },
612 { /*172, WINED3DRS_POSITIONDEGREE */ STATE_RENDER(WINED3DRS_POSITIONDEGREE), state_unknown },
613 { /*173, WINED3DRS_NORMALDEGREE */ STATE_RENDER(WINED3DRS_NORMALDEGREE), state_unknown },
614 /*172, WINED3DRS_POSITIONORDER */ /* Value assigned to 2 state names */
615 /*173, WINED3DRS_NORMALORDER */ /* Value assigned to 2 state names */
616 { /*174, WINED3DRS_SCISSORTESTENABLE */ STATE_RENDER(WINED3DRS_SCISSORTESTENABLE), state_unknown },
617 { /*175, WINED3DRS_SLOPESCALEDEPTHBIAS */ STATE_RENDER(WINED3DRS_DEPTHBIAS), state_unknown },
618 { /*176, WINED3DRS_ANTIALIASEDLINEENABLE */ STATE_RENDER(WINED3DRS_ALPHABLENDENABLE), state_blend },
619 { /*177, undefined */ 0, state_undefined },
620 { /*178, WINED3DRS_MINTESSELLATIONLEVEL */ STATE_RENDER(WINED3DRS_ENABLEADAPTIVETESSELLATION), state_unknown },
621 { /*179, WINED3DRS_MAXTESSELLATIONLEVEL */ STATE_RENDER(WINED3DRS_ENABLEADAPTIVETESSELLATION), state_unknown },
622 { /*180, WINED3DRS_ADAPTIVETESS_X */ STATE_RENDER(WINED3DRS_ENABLEADAPTIVETESSELLATION), state_unknown },
623 { /*181, WINED3DRS_ADAPTIVETESS_Y */ STATE_RENDER(WINED3DRS_ENABLEADAPTIVETESSELLATION), state_unknown },
624 { /*182, WINED3DRS_ADAPTIVETESS_Z */ STATE_RENDER(WINED3DRS_ENABLEADAPTIVETESSELLATION), state_unknown },
625 { /*183, WINED3DRS_ADAPTIVETESS_W */ STATE_RENDER(WINED3DRS_ENABLEADAPTIVETESSELLATION), state_unknown },
626 { /*184, WINED3DRS_ENABLEADAPTIVETESSELLATION */ STATE_RENDER(WINED3DRS_ENABLEADAPTIVETESSELLATION), state_unknown },
627 { /*185, WINED3DRS_TWOSIDEDSTENCILMODE */ STATE_RENDER(WINED3DRS_STENCILENABLE), state_unknown },
628 { /*186, WINED3DRS_CCW_STENCILFAIL */ STATE_RENDER(WINED3DRS_STENCILENABLE), state_unknown },
629 { /*187, WINED3DRS_CCW_STENCILZFAIL */ STATE_RENDER(WINED3DRS_STENCILENABLE), state_unknown },
630 { /*188, WINED3DRS_CCW_STENCILPASS */ STATE_RENDER(WINED3DRS_STENCILENABLE), state_unknown },
631 { /*189, WINED3DRS_CCW_STENCILFUNC */ STATE_RENDER(WINED3DRS_STENCILENABLE), state_unknown },
632 { /*190, WINED3DRS_COLORWRITEENABLE1 */ STATE_RENDER(WINED3DRS_COLORWRITEENABLE), state_unknown },
633 { /*191, WINED3DRS_COLORWRITEENABLE2 */ STATE_RENDER(WINED3DRS_COLORWRITEENABLE), state_unknown },
634 { /*192, WINED3DRS_COLORWRITEENABLE3 */ STATE_RENDER(WINED3DRS_COLORWRITEENABLE), state_unknown },
635 { /*193, WINED3DRS_BLENDFACTOR */ STATE_RENDER(WINED3DRS_ALPHABLENDENABLE), state_blend },
636 { /*194, WINED3DRS_SRGBWRITEENABLE */ 0, state_nogl },
637 { /*195, WINED3DRS_DEPTHBIAS */ STATE_RENDER(WINED3DRS_DEPTHBIAS), state_unknown },
638 { /*196, undefined */ 0, state_undefined },
639 { /*197, undefined */ 0, state_undefined },
640 { /*198, WINED3DRS_WRAP8 */ STATE_RENDER(WINED3DRS_WRAP0), state_unknown },
641 { /*199, WINED3DRS_WRAP9 */ STATE_RENDER(WINED3DRS_WRAP0), state_unknown },
642 { /*200, WINED3DRS_WRAP10 */ STATE_RENDER(WINED3DRS_WRAP0), state_unknown },
643 { /*201, WINED3DRS_WRAP11 */ STATE_RENDER(WINED3DRS_WRAP0), state_unknown },
644 { /*202, WINED3DRS_WRAP12 */ STATE_RENDER(WINED3DRS_WRAP0), state_unknown },
645 { /*203, WINED3DRS_WRAP13 */ STATE_RENDER(WINED3DRS_WRAP0), state_unknown },
646 { /*204, WINED3DRS_WRAP14 */ STATE_RENDER(WINED3DRS_WRAP0), state_unknown },
647 { /*205, WINED3DRS_WRAP15 */ STATE_RENDER(WINED3DRS_WRAP0), state_unknown },
648 { /*206, WINED3DRS_SEPARATEALPHABLENDENABLE */ STATE_RENDER(WINED3DRS_SEPARATEALPHABLENDENABLE), state_unknown },
649 { /*207, WINED3DRS_SRCBLENDALPHA */ STATE_RENDER(WINED3DRS_SEPARATEALPHABLENDENABLE), state_unknown },
650 { /*208, WINED3DRS_DESTBLENDALPHA */ STATE_RENDER(WINED3DRS_SEPARATEALPHABLENDENABLE), state_unknown },
651 { /*209, WINED3DRS_BLENDOPALPHA */ STATE_RENDER(WINED3DRS_SEPARATEALPHABLENDENABLE), state_unknown },