git.oblomov.eu Git - wine/blob - dlls/wined3d/state.c

   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
  28 WINE_DEFAULT_DEBUG_CHANNEL(d3d);
  29
  30 #define GLINFO_LOCATION ((IWineD3DImpl *)(stateblock->wineD3DDevice->wineD3D))->gl_info
  31
  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]);
  37     } else {
  38         FIXME("(%d) Unknown state with unknown type\n", state);
  39     }
  40 }
  41
  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
  45      */
  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]);
  49     } else {
  50         /* Shouldn't have an unknown type here */
  51         FIXME("%d no direct mapping to gl of state with unknown type\n", state);
  52     }
  53 }
  54
  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.
  59      */
  60     WARN("undefined state %d\n", state);
  61 }
  62
  63 static void state_fillmode(DWORD state, IWineD3DStateBlockImpl *stateblock) {
  64     D3DFILLMODE Value = stateblock->renderState[WINED3DRS_FILLMODE];
  65
  66     switch(Value) {
  67         case D3DFILL_POINT:
  68             glPolygonMode(GL_FRONT_AND_BACK, GL_POINT);
  69             checkGLcall("glPolygonMode(GL_FRONT_AND_BACK, GL_POINT)");
  70             break;
  71         case D3DFILL_WIREFRAME:
  72             glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
  73             checkGLcall("glPolygonMode(GL_FRONT_AND_BACK, GL_LINE)");
  74             break;
  75         case D3DFILL_SOLID:
  76             glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
  77             checkGLcall("glPolygonMode(GL_FRONT_AND_BACK, GL_FILL)");
  78             break;
  79         default:
  80             FIXME("Unrecognized WINED3DRS_FILLMODE value %d\n", Value);
  81     }
  82 }
  83
  84 static void state_lighting(DWORD state, IWineD3DStateBlockImpl *stateblock) {
  85
  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
  88      */
  89
  90     if (stateblock->renderState[WINED3DRS_LIGHTING]) {
  91         glEnable(GL_LIGHTING);
  92         checkGLcall("glEnable GL_LIGHTING");
  93     } else {
  94         glDisable(GL_LIGHTING);
  95         checkGLcall("glDisable GL_LIGHTING");
  96     }
  97 }
  98
  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");
 104             break;
 105         case WINED3DZB_TRUE:
 106             glEnable(GL_DEPTH_TEST);
 107             checkGLcall("glEnable GL_DEPTH_TEST");
 108             break;
 109         case WINED3DZB_USEW:
 110             glEnable(GL_DEPTH_TEST);
 111             checkGLcall("glEnable GL_DEPTH_TEST");
 112             FIXME("W buffer is not well handled\n");
 113             break;
 114         default:
 115             FIXME("Unrecognized D3DZBUFFERTYPE value %d\n", stateblock->renderState[WINED3DRS_ZENABLE]);
 116     }
 117 }
 118
 119 static void state_cullmode(DWORD state, IWineD3DStateBlockImpl *stateblock) {
 120     /* TODO: Put this into the offscreen / onscreen rendering block due to device->render_offscreen */
 121
 122     /* If we are culling "back faces with clockwise vertices" then
 123        set front faces to be counter clockwise and enable culling
 124        of back faces                                               */
 125     switch ((WINED3DCULL) stateblock->renderState[WINED3DRS_CULLMODE]) {
 126         case WINED3DCULL_NONE:
 127             glDisable(GL_CULL_FACE);
 128             checkGLcall("glDisable GL_CULL_FACE");
 129             break;
 130         case WINED3DCULL_CW:
 131             glEnable(GL_CULL_FACE);
 132             checkGLcall("glEnable GL_CULL_FACE");
 133             if (stateblock->wineD3DDevice->render_offscreen) {
 134                 glFrontFace(GL_CW);
 135                 checkGLcall("glFrontFace GL_CW");
 136             } else {
 137                 glFrontFace(GL_CCW);
 138                 checkGLcall("glFrontFace GL_CCW");
 139             }
 140             glCullFace(GL_BACK);
 141             break;
 142         case WINED3DCULL_CCW:
 143             glEnable(GL_CULL_FACE);
 144             checkGLcall("glEnable GL_CULL_FACE");
 145             if (stateblock->wineD3DDevice->render_offscreen) {
 146                 glFrontFace(GL_CCW);
 147                 checkGLcall("glFrontFace GL_CCW");
 148             } else {
 149                 glFrontFace(GL_CW);
 150                 checkGLcall("glFrontFace GL_CW");
 151             }
 152             glCullFace(GL_BACK);
 153             break;
 154         default:
 155             FIXME("Unrecognized/Unhandled WINED3DCULL value %d\n", stateblock->renderState[WINED3DRS_CULLMODE]);
 156     }
 157 }
 158
 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)");
 164             break;
 165         case WINED3DSHADE_GOURAUD:
 166             glShadeModel(GL_SMOOTH);
 167             checkGLcall("glShadeModel(GL_SMOOTH)");
 168             break;
 169         case WINED3DSHADE_PHONG:
 170             FIXME("WINED3DSHADE_PHONG isn't supported\n");
 171             break;
 172         default:
 173             FIXME("Unrecognized/Unhandled WINED3DSHADEMODE value %d\n", stateblock->renderState[WINED3DRS_SHADEMODE]);
 174     }
 175 }
 176
 177 static void state_ditherenable(DWORD state, IWineD3DStateBlockImpl *stateblock) {
 178     if (stateblock->renderState[WINED3DRS_DITHERENABLE]) {
 179         glEnable(GL_DITHER);
 180         checkGLcall("glEnable GL_DITHER");
 181     } else {
 182         glDisable(GL_DITHER);
 183         checkGLcall("glDisable GL_DITHER");
 184     }
 185 }
 186
 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
 190      */
 191     if (stateblock->renderState[WINED3DRS_ZWRITEENABLE]) {
 192         glDepthMask(1);
 193         checkGLcall("glDepthMask(1)");
 194     } else {
 195         glDepthMask(0);
 196         checkGLcall("glDepthMask(0)");
 197     }
 198 }
 199
 200 static void state_zfunc(DWORD state, IWineD3DStateBlockImpl *stateblock) {
 201     int glParm = CompareFunc(stateblock->renderState[WINED3DRS_ZFUNC]);
 202
 203     if(glParm) {
 204         glDepthFunc(glParm);
 205         checkGLcall("glDepthFunc");
 206     }
 207 }
 208
 209 static void state_ambient(DWORD state, IWineD3DStateBlockImpl *stateblock) {
 210     float col[4];
 211     D3DCOLORTOGLFLOAT4(stateblock->renderState[WINED3DRS_AMBIENT], col);
 212
 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");
 216 }
 217
 218 static void state_blend(DWORD state, IWineD3DStateBlockImpl *stateblock) {
 219     int srcBlend = GL_ZERO;
 220     int dstBlend = GL_ZERO;
 221     float col[4];
 222
 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) {
 229         glEnable(GL_BLEND);
 230         checkGLcall("glEnable GL_BLEND");
 231     } else {
 232         glDisable(GL_BLEND);
 233         checkGLcall("glDisable GL_BLEND");
 234         /* Nothing more to do - get out */
 235         return;
 236     };
 237
 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;
 250
 251         case WINED3DBLEND_BOTHSRCALPHA       : srcBlend = GL_SRC_ALPHA;
 252             dstBlend = GL_SRC_ALPHA;
 253             break;
 254
 255         case WINED3DBLEND_BOTHINVSRCALPHA    : srcBlend = GL_ONE_MINUS_SRC_ALPHA;
 256             dstBlend = GL_ONE_MINUS_SRC_ALPHA;
 257             break;
 258
 259         case WINED3DBLEND_BLENDFACTOR        : srcBlend = GL_CONSTANT_COLOR;   break;
 260         case WINED3DBLEND_INVBLENDFACTOR     : srcBlend = GL_ONE_MINUS_CONSTANT_COLOR;  break;
 261         default:
 262             FIXME("Unrecognized src blend value %d\n", stateblock->renderState[WINED3DRS_SRCBLEND]);
 263     }
 264
 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;
 277
 278         case WINED3DBLEND_BOTHSRCALPHA       : dstBlend = GL_SRC_ALPHA;
 279             srcBlend = GL_SRC_ALPHA;
 280             break;
 281
 282         case WINED3DBLEND_BOTHINVSRCALPHA    : dstBlend = GL_ONE_MINUS_SRC_ALPHA;
 283             srcBlend = GL_ONE_MINUS_SRC_ALPHA;
 284             break;
 285
 286         case D3DBLEND_BLENDFACTOR        : dstBlend = GL_CONSTANT_COLOR;   break;
 287         case D3DBLEND_INVBLENDFACTOR     : dstBlend = GL_ONE_MINUS_CONSTANT_COLOR;  break;
 288         default:
 289             FIXME("Unrecognized dst blend value %d\n", stateblock->renderState[WINED3DRS_DESTBLEND]);
 290     }
 291
 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;
 299         }
 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;
 303         }
 304     } else {
 305         glDisable(GL_LINE_SMOOTH);
 306         checkGLcall("glDisable(GL_LINE_SMOOTH)");
 307     }
 308
 309     TRACE("glBlendFunc src=%x, dst=%x\n", srcBlend, dstBlend);
 310     glBlendFunc(srcBlend, dstBlend);
 311     checkGLcall("glBlendFunc");
 312
 313     /* TODO: Remove when state management done */
 314     stateblock->wineD3DDevice->dstBlend = dstBlend;
 315     stateblock->wineD3DDevice->srcBlend = srcBlend;
 316
 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");
 321 }
 322
 323 static void state_alpha(DWORD state, IWineD3DStateBlockImpl *stateblock) {
 324     int glParm = 0;
 325     float ref;
 326     BOOL enable_ckey = FALSE;
 327
 328     IWineD3DSurfaceImpl *surf;
 329
 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.
 335      */
 336     if(stateblock->textures[0]) {
 337         surf = (IWineD3DSurfaceImpl *) ((IWineD3DTextureImpl *)stateblock->textures[0])->surfaces[0];
 338         if(surf->CKeyFlags & DDSD_CKSRCBLT) enable_ckey = TRUE;
 339     }
 340
 341     if (stateblock->renderState[WINED3DRS_ALPHATESTENABLE] ||
 342         (stateblock->renderState[WINED3DRS_COLORKEYENABLE] && enable_ckey)) {
 343         glEnable(GL_ALPHA_TEST);
 344         checkGLcall("glEnable GL_ALPHA_TEST");
 345     } else {
 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
 349          * enable call
 350          */
 351         return;
 352     }
 353
 354     if(stateblock->renderState[WINED3DRS_COLORKEYENABLE] && enable_ckey) {
 355         glParm = GL_NOTEQUAL;
 356         ref = 0.0;
 357     } else {
 358         ref = ((float) stateblock->renderState[WINED3DRS_ALPHAREF]) / 255.0f;
 359         glParm = CompareFunc(stateblock->renderState[WINED3DRS_ALPHAFUNC]);
 360     }
 361     if(glParm) {
 362         stateblock->wineD3DDevice->alphafunc = glParm; /* Remove when state management done */
 363         glAlphaFunc(glParm, ref);
 364         checkGLcall("glAlphaFunc");
 365     }
 366     /* TODO: Some texture blending operations seem to affect the alpha test */
 367 }
 368
 369 static void state_clipping(DWORD state, IWineD3DStateBlockImpl *stateblock) {
 370     DWORD enable  = 0xFFFFFFFF;
 371     DWORD disable = 0x00000000;
 372
 373     /* TODO: Keep track of previously enabled clipplanes to avoid unneccessary resetting
 374      * of already set values
 375      */
 376
 377     /* If enabling / disabling all
 378      * TODO: Is this correct? Doesn't D3DRS_CLIPPING disable clipping on the viewport frustrum?
 379      */
 380     if (stateblock->renderState[WINED3DRS_CLIPPING]) {
 381         enable  = stateblock->renderState[WINED3DRS_CLIPPLANEENABLE];
 382         disable = ~stateblock->renderState[WINED3DRS_CLIPPLANEENABLE];
 383     } else {
 384         disable = 0xffffffff;
 385         enable  = 0x00;
 386     }
 387
 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)"); }
 394
 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)"); }
 401
 402     /** update clipping status */
 403     if (enable) {
 404         stateblock->clip_status.ClipUnion = 0;
 405         stateblock->clip_status.ClipIntersection = 0xFFFFFFFF;
 406     } else {
 407         stateblock->clip_status.ClipUnion = 0;
 408         stateblock->clip_status.ClipIntersection = 0;
 409     }
 410 }
 411
 412 static void state_blendop(DWORD state, IWineD3DStateBlockImpl *stateblock) {
 413     int glParm = GL_FUNC_ADD;
 414
 415     if(!GL_SUPPORT(EXT_BLEND_MINMAX)) {
 416         WARN("Unsupported in local OpenGL implementation: glBlendEquation\n");
 417         return;
 418     }
 419
 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;
 426         default:
 427             FIXME("Unrecognized/Unhandled D3DBLENDOP value %d\n", stateblock->renderState[WINED3DRS_BLENDOP]);
 428     }
 429
 430     TRACE("glBlendEquation(%x)\n", glParm);
 431     GL_EXTCALL(glBlendEquation(glParm));
 432     checkGLcall("glBlendEquation");
 433 }
 434
 435 static void
 436 state_specularenable(DWORD state, IWineD3DStateBlockImpl *stateblock) {
 437     /* Originally this used glLightModeli(GL_LIGHT_MODEL_COLOR_CONTROL,GL_SEPARATE_SPECULAR_COLOR)
 438      * and (GL_LIGHT_MODEL_COLOR_CONTROL,GL_SINGLE_COLOR) to swap between enabled/disabled
 439      * specular color. This is wrong:
 440      * Separate specular color means the specular colour is maintained separately, whereas
 441      * single color means it is merged in. However in both cases they are being used to
 442      * some extent.
 443      * To disable specular color, set it explicitly to black and turn off GL_COLOR_SUM_EXT
 444      * NOTE: If not supported don't give FIXMEs the impact is really minimal and very few people are
 445      * running 1.4 yet!
 446      *
 447      *
 448      * If register combiners are enabled, enabling / disabling GL_COLOR_SUM has no effect.
 449      * Instead, we need to setup the FinalCombiner properly.
 450      *
 451      * The default setup for the FinalCombiner is:
 452      *
 453      * <variable>       <input>                             <mapping>               <usage>
 454      * GL_VARIABLE_A_NV GL_FOG,                             GL_UNSIGNED_IDENTITY_NV GL_ALPHA
 455      * GL_VARIABLE_B_NV GL_SPARE0_PLUS_SECONDARY_COLOR_NV   GL_UNSIGNED_IDENTITY_NV GL_RGB
 456      * GL_VARIABLE_C_NV GL_FOG                              GL_UNSIGNED_IDENTITY_NV GL_RGB
 457      * GL_VARIABLE_D_NV GL_ZERO                             GL_UNSIGNED_IDENTITY_NV GL_RGB
 458      * GL_VARIABLE_E_NV GL_ZERO                             GL_UNSIGNED_IDENTITY_NV GL_RGB
 459      * GL_VARIABLE_F_NV GL_ZERO                             GL_UNSIGNED_IDENTITY_NV GL_RGB
 460      * GL_VARIABLE_G_NV GL_SPARE0_NV                        GL_UNSIGNED_IDENTITY_NV GL_ALPHA
 461      *
 462      * That's pretty much fine as it is, except for variable B, which needs to take
 463      * either GL_SPARE0_PLUS_SECONDARY_COLOR_NV or GL_SPARE0_NV, depending on
 464      * whether WINED3DRS_SPECULARENABLE is enabled or not.
 465      */
 466
 467     TRACE("Setting specular enable state\n");
 468     /* TODO: Add to the material setting functions */
 469     if (stateblock->renderState[WINED3DRS_SPECULARENABLE]) {
 470         glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, (float*) &stateblock->material.Specular);
 471         checkGLcall("glMaterialfv");
 472         if (GL_SUPPORT(EXT_SECONDARY_COLOR)) {
 473             glEnable(GL_COLOR_SUM_EXT);
 474         } else {
 475             TRACE("Specular colors cannot be enabled in this version of opengl\n");
 476         }
 477         checkGLcall("glEnable(GL_COLOR_SUM)");
 478
 479         if (GL_SUPPORT(NV_REGISTER_COMBINERS)) {
 480             GL_EXTCALL(glFinalCombinerInputNV(GL_VARIABLE_B_NV, GL_SPARE0_PLUS_SECONDARY_COLOR_NV, GL_UNSIGNED_IDENTITY_NV, GL_RGB));
 481             checkGLcall("glFinalCombinerInputNV()");
 482         }
 483     } else {
 484         float black[4] = {0.0f, 0.0f, 0.0f, 0.0f};
 485
 486         /* for the case of enabled lighting: */
 487         glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, &black[0]);
 488         checkGLcall("glMaterialfv");
 489
 490         /* for the case of disabled lighting: */
 491         if (GL_SUPPORT(EXT_SECONDARY_COLOR)) {
 492             glDisable(GL_COLOR_SUM_EXT);
 493         } else {
 494             TRACE("Specular colors cannot be disabled in this version of opengl\n");
 495         }
 496         checkGLcall("glDisable(GL_COLOR_SUM)");
 497
 498         if (GL_SUPPORT(NV_REGISTER_COMBINERS)) {
 499             GL_EXTCALL(glFinalCombinerInputNV(GL_VARIABLE_B_NV, GL_SPARE0_NV, GL_UNSIGNED_IDENTITY_NV, GL_RGB));
 500             checkGLcall("glFinalCombinerInputNV()");
 501         }
 502     }
 503 }
 504
 505 static void state_texfactor(DWORD state, IWineD3DStateBlockImpl *stateblock) {
 506     unsigned int i;
 507
 508     /* Note the texture color applies to all textures whereas
 509      * GL_TEXTURE_ENV_COLOR applies to active only
 510      */
 511     float col[4];
 512     D3DCOLORTOGLFLOAT4(stateblock->renderState[WINED3DRS_TEXTUREFACTOR], col);
 513
 514     if (!GL_SUPPORT(NV_REGISTER_COMBINERS)) {
 515         /* And now the default texture color as well */
 516         for (i = 0; i < GL_LIMITS(texture_stages); i++) {
 517             /* Note the WINED3DRS value applies to all textures, but GL has one
 518              * per texture, so apply it now ready to be used!
 519              */
 520             if (GL_SUPPORT(ARB_MULTITEXTURE)) {
 521                 GL_EXTCALL(glActiveTextureARB(GL_TEXTURE0_ARB + i));
 522                 checkGLcall("glActiveTextureARB");
 523             } else if (i>0) {
 524                 FIXME("Program using multiple concurrent textures which this opengl implementation doesn't support\n");
 525             }
 526
 527             glTexEnvfv(GL_TEXTURE_ENV, GL_TEXTURE_ENV_COLOR, &col[0]);
 528             checkGLcall("glTexEnvfv(GL_TEXTURE_ENV, GL_TEXTURE_ENV_COLOR, color);");
 529         }
 530     }
 531 }
 532
 533 static void
 534 renderstate_stencil_twosided(IWineD3DStateBlockImpl *stateblock, GLint face, GLint func, GLint ref, GLuint mask, GLint stencilFail, GLint depthFail, GLint stencilPass ) {
 535 #if 0 /* Don't use OpenGL 2.0 calls for now */
 536             if(GL_EXTCALL(glStencilFuncSeparate) && GL_EXTCALL(glStencilOpSeparate)) {
 537                 GL_EXTCALL(glStencilFuncSeparate(face, func, ref, mask));
 538                 checkGLcall("glStencilFuncSeparate(...)");
 539                 GL_EXTCALL(glStencilOpSeparate(face, stencilFail, depthFail, stencilPass));
 540                 checkGLcall("glStencilOpSeparate(...)");
 541         }
 542             else
 543 #endif
 544     if(GL_SUPPORT(EXT_STENCIL_TWO_SIDE)) {
 545         glEnable(GL_STENCIL_TEST_TWO_SIDE_EXT);
 546         checkGLcall("glEnable(GL_STENCIL_TEST_TWO_SIDE_EXT)");
 547         GL_EXTCALL(glActiveStencilFaceEXT(face));
 548         checkGLcall("glActiveStencilFaceEXT(...)");
 549         glStencilFunc(func, ref, mask);
 550         checkGLcall("glStencilFunc(...)");
 551         glStencilOp(stencilFail, depthFail, stencilPass);
 552         checkGLcall("glStencilOp(...)");
 553     } else if(GL_SUPPORT(ATI_SEPARATE_STENCIL)) {
 554         GL_EXTCALL(glStencilFuncSeparateATI(face, func, ref, mask));
 555         checkGLcall("glStencilFuncSeparateATI(...)");
 556         GL_EXTCALL(glStencilOpSeparateATI(face, stencilFail, depthFail, stencilPass));
 557         checkGLcall("glStencilOpSeparateATI(...)");
 558     } else {
 559         ERR("Separate (two sided) stencil not supported on this version of opengl. Caps weren't honored?\n");
 560     }
 561 }
 562
 563 static void
 564 state_stencil(DWORD state, IWineD3DStateBlockImpl *stateblock) {
 565     DWORD onesided_enable = FALSE;
 566     DWORD twosided_enable = FALSE;
 567     GLint func = GL_ALWAYS;
 568     GLint func_ccw = GL_ALWAYS;
 569     GLint ref = 0;
 570     GLuint mask = 0;
 571     GLint stencilFail = GL_KEEP;
 572     GLint depthFail = GL_KEEP;
 573     GLint stencilPass = GL_KEEP;
 574     GLint stencilFail_ccw = GL_KEEP;
 575     GLint depthFail_ccw = GL_KEEP;
 576     GLint stencilPass_ccw = GL_KEEP;
 577
 578     if( stateblock->set.renderState[WINED3DRS_STENCILENABLE] )
 579         onesided_enable = stateblock->renderState[WINED3DRS_STENCILENABLE];
 580     if( stateblock->set.renderState[WINED3DRS_TWOSIDEDSTENCILMODE] )
 581         twosided_enable = stateblock->renderState[WINED3DRS_TWOSIDEDSTENCILMODE];
 582     if( stateblock->set.renderState[WINED3DRS_STENCILFUNC] )
 583         if( !( func = CompareFunc(stateblock->renderState[WINED3DRS_STENCILFUNC]) ) )
 584             func = GL_ALWAYS;
 585     if( stateblock->set.renderState[WINED3DRS_CCW_STENCILFUNC] )
 586         if( !( func_ccw = CompareFunc(stateblock->renderState[WINED3DRS_CCW_STENCILFUNC]) ) )
 587             func = GL_ALWAYS;
 588     if( stateblock->set.renderState[WINED3DRS_STENCILREF] )
 589         ref = stateblock->renderState[WINED3DRS_STENCILREF];
 590     if( stateblock->set.renderState[WINED3DRS_STENCILMASK] )
 591         mask = stateblock->renderState[WINED3DRS_STENCILMASK];
 592     if( stateblock->set.renderState[WINED3DRS_STENCILFAIL] )
 593         stencilFail = StencilOp(stateblock->renderState[WINED3DRS_STENCILFAIL]);
 594     if( stateblock->set.renderState[WINED3DRS_STENCILZFAIL] )
 595         depthFail = StencilOp(stateblock->renderState[WINED3DRS_STENCILZFAIL]);
 596     if( stateblock->set.renderState[WINED3DRS_STENCILPASS] )
 597         stencilPass = StencilOp(stateblock->renderState[WINED3DRS_STENCILPASS]);
 598     if( stateblock->set.renderState[WINED3DRS_CCW_STENCILFAIL] )
 599         stencilFail_ccw = StencilOp(stateblock->renderState[WINED3DRS_CCW_STENCILFAIL]);
 600     if( stateblock->set.renderState[WINED3DRS_CCW_STENCILZFAIL] )
 601         depthFail_ccw = StencilOp(stateblock->renderState[WINED3DRS_CCW_STENCILZFAIL]);
 602     if( stateblock->set.renderState[WINED3DRS_CCW_STENCILPASS] )
 603         stencilPass_ccw = StencilOp(stateblock->renderState[WINED3DRS_CCW_STENCILPASS]);
 604
 605     TRACE("(onesided %d, twosided %d, ref %x, mask %x,  \
 606             GL_FRONT: func: %x, fail %x, zfail %x, zpass %x  \
 607             GL_BACK: func: %x, fail %x, zfail %x, zpass %x )\n",
 608     onesided_enable, twosided_enable, ref, mask,
 609     func, stencilFail, depthFail, stencilPass,
 610     func_ccw, stencilFail_ccw, depthFail_ccw, stencilPass_ccw);
 611
 612     if (twosided_enable) {
 613         renderstate_stencil_twosided(stateblock, GL_FRONT, func, ref, mask, stencilFail, depthFail, stencilPass);
 614         renderstate_stencil_twosided(stateblock, GL_BACK, func_ccw, ref, mask, stencilFail_ccw, depthFail_ccw, stencilPass_ccw);
 615     } else {
 616         if (onesided_enable) {
 617             glEnable(GL_STENCIL_TEST);
 618             checkGLcall("glEnable GL_STENCIL_TEST");
 619             glStencilFunc(func, ref, mask);
 620             checkGLcall("glStencilFunc(...)");
 621             glStencilOp(stencilFail, depthFail, stencilPass);
 622             checkGLcall("glStencilOp(...)");
 623         } else {
 624             glDisable(GL_STENCIL_TEST);
 625             checkGLcall("glDisable GL_STENCIL_TEST");
 626         }
 627     }
 628 }
 629
 630 static void state_stencilwrite(DWORD state, IWineD3DStateBlockImpl *stateblock) {
 631     glStencilMask(stateblock->renderState[WINED3DRS_STENCILWRITEMASK]);
 632     checkGLcall("glStencilMask");
 633 }
 634
 635 static void state_fog(DWORD state, IWineD3DStateBlockImpl *stateblock) {
 636     /* TODO: Put this into the vertex type block once that is in the state table */
 637     BOOL fogenable = stateblock->renderState[WINED3DRS_FOGENABLE];
 638     float fogstart, fogend;
 639
 640     union {
 641         DWORD d;
 642         float f;
 643     } tmpvalue;
 644
 645     if (!fogenable) {
 646         /* No fog? Disable it, and we're done :-) */
 647         glDisable(GL_FOG);
 648         checkGLcall("glDisable GL_FOG");
 649     }
 650
 651     tmpvalue.d = stateblock->renderState[WINED3DRS_FOGSTART];
 652     fogstart = tmpvalue.f;
 653     tmpvalue.d = stateblock->renderState[WINED3DRS_FOGEND];
 654     fogend = tmpvalue.f;
 655
 656 #if 0
 657     /* Activate when vertex shaders are in the state table */
 658     if(stateblock->vertexShader && ((IWineD3DVertexShaderImpl *)stateblock->vertexShader)->baseShader.function &&
 659        ((IWineD3DVertexShaderImpl *)stateblock->vertexShader)->usesFog) {
 660         glFogi(GL_FOG_MODE, GL_LINEAR);
 661         checkGLcall("glFogi(GL_FOG_MODE, GL_LINEAR)");
 662         fogstart = 1.0;
 663         fogend = 0.0;
 664         stateblock->wineD3DDevice->last_was_foggy_shader = TRUE;
 665     }
 666 #endif
 667
 668     /* DX 7 sdk: "If both render states(vertex and table fog) are set to valid modes,
 669      * the system will apply only pixel(=table) fog effects."
 670      */
 671     /* else */ if(stateblock->renderState[WINED3DRS_FOGTABLEMODE] == D3DFOG_NONE) {
 672         glHint(GL_FOG_HINT, GL_FASTEST);
 673         checkGLcall("glHint(GL_FOG_HINT, GL_FASTEST)");
 674 #if 0
 675         stateblock->wineD3DDevice->last_was_foggy_shader = FALSE;
 676 #endif
 677         switch (stateblock->renderState[WINED3DRS_FOGVERTEXMODE]) {
 678             /* Processed vertices have their fog factor stored in the specular value. Fall too the none case.
 679              * If we are drawing untransformed vertices atm, d3ddevice_set_ortho will update the fog
 680              */
 681             case D3DFOG_EXP:  {
 682                 if(!stateblock->wineD3DDevice->last_was_rhw) {
 683                     glFogi(GL_FOG_MODE, GL_EXP);
 684                     checkGLcall("glFogi(GL_FOG_MODE, GL_EXP");
 685                     if(GL_SUPPORT(EXT_FOG_COORD)) {
 686                         glFogi(GL_FOG_COORDINATE_SOURCE_EXT, GL_FRAGMENT_DEPTH_EXT);
 687                         checkGLcall("glFogi(GL_FOG_COORDINATE_SOURCE_EXT, GL_FRAGMENT_DEPTH_EXT");
 688                     }
 689                     break;
 690                 }
 691             }
 692             case D3DFOG_EXP2: {
 693                 if(!stateblock->wineD3DDevice->last_was_rhw) {
 694                     glFogi(GL_FOG_MODE, GL_EXP2);
 695                     checkGLcall("glFogi(GL_FOG_MODE, GL_EXP2");
 696                     if(GL_SUPPORT(EXT_FOG_COORD)) {
 697                         glFogi(GL_FOG_COORDINATE_SOURCE_EXT, GL_FRAGMENT_DEPTH_EXT);
 698                         checkGLcall("glFogi(GL_FOG_COORDINATE_SOURCE_EXT, GL_FRAGMENT_DEPTH_EXT");
 699                     }
 700                     break;
 701                 }
 702             }
 703             case D3DFOG_LINEAR: {
 704                 if(!stateblock->wineD3DDevice->last_was_rhw) {
 705                     glFogi(GL_FOG_MODE, GL_LINEAR);
 706                     checkGLcall("glFogi(GL_FOG_MODE, GL_LINEAR");
 707                     if(GL_SUPPORT(EXT_FOG_COORD)) {
 708                         glFogi(GL_FOG_COORDINATE_SOURCE_EXT, GL_FRAGMENT_DEPTH_EXT);
 709                         checkGLcall("glFogi(GL_FOG_COORDINATE_SOURCE_EXT, GL_FRAGMENT_DEPTH_EXT");
 710                     }
 711                     break;
 712                 }
 713             }
 714             case D3DFOG_NONE: {
 715                 /* Both are none? According to msdn the alpha channel of the specular
 716                  * color contains a fog factor. Set it in drawStridedSlow.
 717                  * Same happens with Vertexfog on transformed vertices
 718                  */
 719                 if(GL_SUPPORT(EXT_FOG_COORD)) {
 720                     glFogi(GL_FOG_COORDINATE_SOURCE_EXT, GL_FOG_COORDINATE_EXT);
 721                     checkGLcall("glFogi(GL_FOG_COORDINATE_SOURCE_EXT, GL_FOG_COORDINATE_EXT)\n");
 722                     glFogi(GL_FOG_MODE, GL_LINEAR);
 723                     checkGLcall("glFogi(GL_FOG_MODE, GL_LINEAR)");
 724                     fogstart = 0xff;
 725                     fogend = 0x0;
 726                 } else {
 727                     /* Disable GL fog, handle this in software in drawStridedSlow */
 728                     fogenable = FALSE;
 729                 }
 730                 break;
 731             }
 732             default: FIXME("Unexpected WINED3DRS_FOGVERTEXMODE %d\n", stateblock->renderState[WINED3DRS_FOGVERTEXMODE]);
 733         }
 734     } else {
 735         glHint(GL_FOG_HINT, GL_NICEST);
 736         checkGLcall("glHint(GL_FOG_HINT, GL_NICEST)");
 737 #if 0
 738         stateblock->wineD3DDevice->last_was_foggy_shader = FALSE;
 739 #endif
 740         switch (stateblock->renderState[WINED3DRS_FOGTABLEMODE]) {
 741             case D3DFOG_EXP:
 742                 glFogi(GL_FOG_MODE, GL_EXP);
 743                 checkGLcall("glFogi(GL_FOG_MODE, GL_EXP");
 744                 if(GL_SUPPORT(EXT_FOG_COORD)) {
 745                     glFogi(GL_FOG_COORDINATE_SOURCE_EXT, GL_FRAGMENT_DEPTH_EXT);
 746                     checkGLcall("glFogi(GL_FOG_COORDINATE_SOURCE_EXT, GL_FRAGMENT_DEPTH_EXT");
 747                 }
 748                 break;
 749
 750             case D3DFOG_EXP2:
 751                 glFogi(GL_FOG_MODE, GL_EXP2);
 752                 checkGLcall("glFogi(GL_FOG_MODE, GL_EXP2");
 753                 if(GL_SUPPORT(EXT_FOG_COORD)) {
 754                     glFogi(GL_FOG_COORDINATE_SOURCE_EXT, GL_FRAGMENT_DEPTH_EXT);
 755                     checkGLcall("glFogi(GL_FOG_COORDINATE_SOURCE_EXT, GL_FRAGMENT_DEPTH_EXT");
 756                 }
 757                 break;
 758
 759             case D3DFOG_LINEAR:
 760                 glFogi(GL_FOG_MODE, GL_LINEAR);
 761                 checkGLcall("glFogi(GL_FOG_MODE, GL_LINEAR");
 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
 768             case D3DFOG_NONE:   /* Won't happen */
 769             default:
 770                 FIXME("Unexpected WINED3DRS_FOGTABLEMODE %d\n", stateblock->renderState[WINED3DRS_FOGTABLEMODE]);
 771         }
 772     }
 773
 774     if(fogenable) {
 775         glEnable(GL_FOG);
 776         checkGLcall("glEnable GL_FOG");
 777
 778         glFogfv(GL_FOG_START, &fogstart);
 779         checkGLcall("glFogf(GL_FOG_START, fogstart");
 780         TRACE("Fog Start == %f\n", fogstart);
 781
 782         glFogfv(GL_FOG_END, &fogend);
 783         checkGLcall("glFogf(GL_FOG_END, fogend");
 784         TRACE("Fog End == %f\n", fogend);
 785     } else {
 786         glDisable(GL_FOG);
 787         checkGLcall("glDisable GL_FOG");
 788     }
 789
 790     if (GL_SUPPORT(NV_FOG_DISTANCE)) {
 791         glFogi(GL_FOG_DISTANCE_MODE_NV, GL_EYE_PLANE_ABSOLUTE_NV);
 792     }
 793 }
 794
 795 static void state_fogcolor(DWORD state, IWineD3DStateBlockImpl *stateblock) {
 796     float col[4];
 797     D3DCOLORTOGLFLOAT4(stateblock->renderState[WINED3DRS_FOGCOLOR], col);
 798     /* Set the default alpha blend color */
 799     glFogfv(GL_FOG_COLOR, &col[0]);
 800     checkGLcall("glFog GL_FOG_COLOR");
 801 }
 802
 803 static void state_fogdensity(DWORD state, IWineD3DStateBlockImpl *stateblock) {
 804     union {
 805         DWORD d;
 806         float f;
 807     } tmpvalue;
 808     tmpvalue.d = stateblock->renderState[WINED3DRS_FOGDENSITY];
 809     glFogfv(GL_FOG_DENSITY, &tmpvalue.f);
 810     checkGLcall("glFogf(GL_FOG_DENSITY, (float) Value)");
 811 }
 812
 813 /* TODO: Merge with primitive type + init_materials()!! */
 814 static void state_colormat(DWORD state, IWineD3DStateBlockImpl *stateblock) {
 815     GLenum Parm = GL_AMBIENT_AND_DIFFUSE;
 816
 817     if (stateblock->renderState[WINED3DRS_COLORVERTEX]) {
 818         TRACE("diff %d, amb %d, emis %d, spec %d\n",
 819               stateblock->renderState[WINED3DRS_DIFFUSEMATERIALSOURCE],
 820               stateblock->renderState[WINED3DRS_AMBIENTMATERIALSOURCE],
 821               stateblock->renderState[WINED3DRS_EMISSIVEMATERIALSOURCE],
 822               stateblock->renderState[WINED3DRS_SPECULARMATERIALSOURCE]);
 823
 824         if (stateblock->renderState[WINED3DRS_DIFFUSEMATERIALSOURCE] == D3DMCS_COLOR1) {
 825             if (stateblock->renderState[WINED3DRS_AMBIENTMATERIALSOURCE] == D3DMCS_COLOR1) {
 826                 Parm = GL_AMBIENT_AND_DIFFUSE;
 827             } else {
 828                 Parm = GL_DIFFUSE;
 829             }
 830         } else if (stateblock->renderState[WINED3DRS_AMBIENTMATERIALSOURCE] == D3DMCS_COLOR1) {
 831             Parm = GL_AMBIENT;
 832         } else if (stateblock->renderState[WINED3DRS_EMISSIVEMATERIALSOURCE] == D3DMCS_COLOR1) {
 833             Parm = GL_EMISSION;
 834         } else if (stateblock->renderState[WINED3DRS_SPECULARMATERIALSOURCE] == D3DMCS_COLOR1) {
 835             Parm = GL_SPECULAR;
 836         } else {
 837             Parm = -1;
 838         }
 839
 840         if (Parm == -1) {
 841             if (stateblock->wineD3DDevice->tracking_color != DISABLED_TRACKING) stateblock->wineD3DDevice->tracking_color = NEEDS_DISABLE;
 842         } else {
 843             stateblock->wineD3DDevice->tracking_color = NEEDS_TRACKING;
 844             stateblock->wineD3DDevice->tracking_parm  = Parm;
 845         }
 846
 847     } else {
 848         if (stateblock->wineD3DDevice->tracking_color != DISABLED_TRACKING) stateblock->wineD3DDevice->tracking_color = NEEDS_DISABLE;
 849     }
 850 }
 851
 852 static void state_linepattern(DWORD state, IWineD3DStateBlockImpl *stateblock) {
 853     union {
 854         DWORD                 d;
 855         WINED3DLINEPATTERN    lp;
 856     } tmppattern;
 857     tmppattern.d = stateblock->renderState[WINED3DRS_LINEPATTERN];
 858
 859     TRACE("Line pattern: repeat %d bits %x\n", tmppattern.lp.wRepeatFactor, tmppattern.lp.wLinePattern);
 860
 861     if (tmppattern.lp.wRepeatFactor) {
 862         glLineStipple(tmppattern.lp.wRepeatFactor, tmppattern.lp.wLinePattern);
 863         checkGLcall("glLineStipple(repeat, linepattern)");
 864         glEnable(GL_LINE_STIPPLE);
 865         checkGLcall("glEnable(GL_LINE_STIPPLE);");
 866     } else {
 867         glDisable(GL_LINE_STIPPLE);
 868         checkGLcall("glDisable(GL_LINE_STIPPLE);");
 869     }
 870 }
 871
 872 static void state_zbias(DWORD state, IWineD3DStateBlockImpl *stateblock) {
 873     union {
 874         DWORD d;
 875         float f;
 876     } tmpvalue;
 877
 878     if (stateblock->renderState[WINED3DRS_ZBIAS]) {
 879         tmpvalue.d = stateblock->renderState[WINED3DRS_ZBIAS];
 880         TRACE("ZBias value %f\n", tmpvalue.f);
 881         glPolygonOffset(0, -tmpvalue.f);
 882         checkGLcall("glPolygonOffset(0, -Value)");
 883         glEnable(GL_POLYGON_OFFSET_FILL);
 884         checkGLcall("glEnable(GL_POLYGON_OFFSET_FILL);");
 885         glEnable(GL_POLYGON_OFFSET_LINE);
 886         checkGLcall("glEnable(GL_POLYGON_OFFSET_LINE);");
 887         glEnable(GL_POLYGON_OFFSET_POINT);
 888         checkGLcall("glEnable(GL_POLYGON_OFFSET_POINT);");
 889     } else {
 890         glDisable(GL_POLYGON_OFFSET_FILL);
 891         checkGLcall("glDisable(GL_POLYGON_OFFSET_FILL);");
 892         glDisable(GL_POLYGON_OFFSET_LINE);
 893         checkGLcall("glDisable(GL_POLYGON_OFFSET_LINE);");
 894         glDisable(GL_POLYGON_OFFSET_POINT);
 895         checkGLcall("glDisable(GL_POLYGON_OFFSET_POINT);");
 896     }
 897 }
 898
 899 const struct StateEntry StateTable[] =
 900 {
 901       /* State name                                         representative,                                     apply function */
 902     { /* 0,  Undefined                              */      0,                                                  state_undefined     },
 903     { /* 1,  WINED3DRS_TEXTUREHANDLE                */      0 /* Handled in ddraw */,                           state_undefined     },
 904     { /* 2,  WINED3DRS_ANTIALIAS                    */      STATE_RENDER(WINED3DRS_ANTIALIAS),                  state_unknown       },
 905     { /* 3,  WINED3DRS_TEXTUREADDRESS               */      0 /* Handled in ddraw */,                           state_undefined     },
 906     { /* 4,  WINED3DRS_TEXTUREPERSPECTIVE           */      STATE_RENDER(WINED3DRS_TEXTUREPERSPECTIVE),         state_unknown       },
 907     { /* 5,  WINED3DRS_WRAPU                        */      STATE_RENDER(WINED3DRS_WRAPU),                      state_unknown       },
 908     { /* 6,  WINED3DRS_WRAPV                        */      STATE_RENDER(WINED3DRS_WRAPV),                      state_unknown       },
 909     { /* 7,  WINED3DRS_ZENABLE                      */      STATE_RENDER(WINED3DRS_ZENABLE),                    state_zenable       },
 910     { /* 8,  WINED3DRS_FILLMODE                     */      STATE_RENDER(WINED3DRS_FILLMODE),                   state_fillmode      },
 911     { /* 9,  WINED3DRS_SHADEMODE                    */      STATE_RENDER(WINED3DRS_SHADEMODE),                  state_shademode     },
 912     { /* 10, WINED3DRS_LINEPATTERN                  */      STATE_RENDER(WINED3DRS_LINEPATTERN),                state_linepattern   },
 913     { /* 11, WINED3DRS_MONOENABLE                   */      STATE_RENDER(WINED3DRS_MONOENABLE),                 state_unknown       },
 914     { /* 12, WINED3DRS_ROP2                         */      STATE_RENDER(WINED3DRS_ROP2),                       state_unknown       },
 915     { /* 13, WINED3DRS_PLANEMASK                    */      STATE_RENDER(WINED3DRS_PLANEMASK),                  state_unknown       },
 916     { /* 14, WINED3DRS_ZWRITEENABLE                 */      STATE_RENDER(WINED3DRS_ZWRITEENABLE),               state_zwritenable   },
 917     { /* 15, WINED3DRS_ALPHATESTENABLE              */      STATE_RENDER(WINED3DRS_ALPHATESTENABLE),            state_alpha         },
 918     { /* 16, WINED3DRS_LASTPIXEL                    */      STATE_RENDER(WINED3DRS_LASTPIXEL),                  state_unknown       },
 919     { /* 17, WINED3DRS_TEXTUREMAG                   */      0 /* Handled in ddraw */,                           state_undefined     },
 920     { /* 18, WINED3DRS_TEXTUREMIN                   */      0 /* Handled in ddraw */,                           state_undefined     },
 921     { /* 19, WINED3DRS_SRCBLEND                     */      STATE_RENDER(WINED3DRS_ALPHABLENDENABLE),           state_blend         },
 922     { /* 20, WINED3DRS_DESTBLEND                    */      STATE_RENDER(WINED3DRS_ALPHABLENDENABLE),           state_blend         },
 923     { /* 21, WINED3DRS_TEXTUREMAPBLEND              */      0 /* Handled in ddraw */,                           state_undefined     },
 924     { /* 22, WINED3DRS_CULLMODE                     */      STATE_RENDER(WINED3DRS_CULLMODE),                   state_cullmode      },
 925     { /* 23, WINED3DRS_ZFUNC                        */      STATE_RENDER(WINED3DRS_ZFUNC),                      state_zfunc         },
 926     { /* 24, WINED3DRS_ALPHAREF                     */      STATE_RENDER(WINED3DRS_ALPHATESTENABLE),            state_alpha         },
 927     { /* 25, WINED3DRS_ALPHAFUNC                    */      STATE_RENDER(WINED3DRS_ALPHATESTENABLE),            state_alpha         },
 928     { /* 26, WINED3DRS_DITHERENABLE                 */      STATE_RENDER(WINED3DRS_DITHERENABLE),               state_ditherenable  },
 929     { /* 27, WINED3DRS_ALPHABLENDENABLE             */      STATE_RENDER(WINED3DRS_ALPHABLENDENABLE),           state_blend         },
 930     { /* 28, WINED3DRS_FOGENABLE                    */      STATE_RENDER(WINED3DRS_FOGENABLE),                  state_fog           },
 931     { /* 29, WINED3DRS_SPECULARENABLE               */      STATE_RENDER(WINED3DRS_SPECULARENABLE),             state_specularenable},
 932     { /* 30, WINED3DRS_ZVISIBLE                     */      0 /* Not supported according to the msdn */,        state_nogl          },
 933     { /* 31, WINED3DRS_SUBPIXEL                     */      STATE_RENDER(WINED3DRS_SUBPIXEL),                   state_unknown       },
 934     { /* 32, WINED3DRS_SUBPIXELX                    */      STATE_RENDER(WINED3DRS_SUBPIXELX),                  state_unknown       },
 935     { /* 33, WINED3DRS_STIPPLEDALPHA                */      STATE_RENDER(WINED3DRS_STIPPLEDALPHA),              state_unknown       },
 936     { /* 34, WINED3DRS_FOGCOLOR                     */      STATE_RENDER(WINED3DRS_FOGCOLOR),                   state_fogcolor      },
 937     { /* 35, WINED3DRS_FOGTABLEMODE                 */      STATE_RENDER(WINED3DRS_FOGENABLE),                  state_fog           },
 938     { /* 36, WINED3DRS_FOGSTART                     */      STATE_RENDER(WINED3DRS_FOGENABLE),                  state_fog           },
 939     { /* 37, WINED3DRS_FOGEND                       */      STATE_RENDER(WINED3DRS_FOGENABLE),                  state_fog           },
 940     { /* 38, WINED3DRS_FOGDENSITY                   */      STATE_RENDER(WINED3DRS_FOGDENSITY),                 state_fogdensity    },
 941     { /* 39, WINED3DRS_STIPPLEENABLE                */      STATE_RENDER(WINED3DRS_STIPPLEENABLE),              state_unknown       },
 942     { /* 40, WINED3DRS_EDGEANTIALIAS                */      STATE_RENDER(WINED3DRS_ALPHABLENDENABLE),           state_blend         },
 943     { /* 41, WINED3DRS_COLORKEYENABLE               */      STATE_RENDER(WINED3DRS_ALPHATESTENABLE),            state_alpha         },
 944     { /* 42, undefined                              */      0,                                                  state_undefined     },
 945     { /* 43, WINED3DRS_BORDERCOLOR                  */      STATE_RENDER(WINED3DRS_BORDERCOLOR),                state_unknown       },
 946     { /* 44, WINED3DRS_TEXTUREADDRESSU              */      0, /* Handled in ddraw */                           state_undefined     },
 947     { /* 45, WINED3DRS_TEXTUREADDRESSV              */      0, /* Handled in ddraw */                           state_undefined     },
 948     { /* 46, WINED3DRS_MIPMAPLODBIAS                */      STATE_RENDER(WINED3DRS_MIPMAPLODBIAS),              state_unknown       },
 949     { /* 47, WINED3DRS_ZBIAS                        */      STATE_RENDER(WINED3DRS_ZBIAS),                      state_zbias         },
 950     { /* 48, WINED3DRS_RANGEFOGENABLE               */      0,                                                  state_nogl          },
 951     { /* 49, WINED3DRS_ANISOTROPY                   */      STATE_RENDER(WINED3DRS_ANISOTROPY),                 state_unknown       },
 952     { /* 50, WINED3DRS_FLUSHBATCH                   */      STATE_RENDER(WINED3DRS_FLUSHBATCH),                 state_unknown       },
 953     { /* 51, WINED3DRS_TRANSLUCENTSORTINDEPENDENT   */      STATE_RENDER(WINED3DRS_TRANSLUCENTSORTINDEPENDENT), state_unknown       },
 954     { /* 52, WINED3DRS_STENCILENABLE                */      STATE_RENDER(WINED3DRS_STENCILENABLE),              state_stencil       },
 955     { /* 53, WINED3DRS_STENCILFAIL                  */      STATE_RENDER(WINED3DRS_STENCILENABLE),              state_stencil       },
 956     { /* 54, WINED3DRS_STENCILZFAIL                 */      STATE_RENDER(WINED3DRS_STENCILENABLE),              state_stencil       },
 957     { /* 55, WINED3DRS_STENCILPASS                  */      STATE_RENDER(WINED3DRS_STENCILENABLE),              state_stencil       },
 958     { /* 56, WINED3DRS_STENCILFUNC                  */      STATE_RENDER(WINED3DRS_STENCILENABLE),              state_stencil       },
 959     { /* 57, WINED3DRS_STENCILREF                   */      STATE_RENDER(WINED3DRS_STENCILENABLE),              state_stencil       },
 960     { /* 58, WINED3DRS_STENCILMASK                  */      STATE_RENDER(WINED3DRS_STENCILENABLE),              state_stencil       },
 961     { /* 59, WINED3DRS_STENCILWRITEMASK             */      STATE_RENDER(WINED3DRS_STENCILWRITEMASK),           state_stencilwrite  },
 962     { /* 60, WINED3DRS_TEXTUREFACTOR                */      STATE_RENDER(WINED3DRS_TEXTUREFACTOR),              state_texfactor     },
 963     /* A BIG hole. If wanted, 'fixed' states like the vertex type or the bound shaders can be put here */
 964     { /* 61, Undefined                              */      0,                                                  state_undefined     },
 965     { /* 62, Undefined                              */      0,                                                  state_undefined     },
 966     { /* 63, Undefined                              */      0,                                                  state_undefined     },
 967     { /* 64, Undefined                              */      0,                                                  state_undefined     },
 968     { /* 65, Undefined                              */      0,                                                  state_undefined     },
 969     { /* 66, Undefined                              */      0,                                                  state_undefined     },
 970     { /* 67, Undefined                              */      0,                                                  state_undefined     },
 971     { /* 68, Undefined                              */      0,                                                  state_undefined     },
 972     { /* 69, Undefined                              */      0,                                                  state_undefined     },
 973     { /* 70, Undefined                              */      0,                                                  state_undefined     },
 974     { /* 71, Undefined                              */      0,                                                  state_undefined     },
 975     { /* 72, Undefined                              */      0,                                                  state_undefined     },
 976     { /* 73, Undefined                              */      0,                                                  state_undefined     },
 977     { /* 74, Undefined                              */      0,                                                  state_undefined     },
 978     { /* 75, Undefined                              */      0,                                                  state_undefined     },
 979     { /* 76, Undefined                              */      0,                                                  state_undefined     },
 980     { /* 77, Undefined                              */      0,                                                  state_undefined     },
 981     { /* 78, Undefined                              */      0,                                                  state_undefined     },
 982     { /* 79, Undefined                              */      0,                                                  state_undefined     },
 983     { /* 80, Undefined                              */      0,                                                  state_undefined     },
 984     { /* 81, Undefined                              */      0,                                                  state_undefined     },
 985     { /* 82, Undefined                              */      0,                                                  state_undefined     },
 986     { /* 83, Undefined                              */      0,                                                  state_undefined     },
 987     { /* 84, Undefined                              */      0,                                                  state_undefined     },
 988     { /* 85, Undefined                              */      0,                                                  state_undefined     },
 989     { /* 86, Undefined                              */      0,                                                  state_undefined     },
 990     { /* 87, Undefined                              */      0,                                                  state_undefined     },
 991     { /* 88, Undefined                              */      0,                                                  state_undefined     },
 992     { /* 89, Undefined                              */      0,                                                  state_undefined     },
 993     { /* 90, Undefined                              */      0,                                                  state_undefined     },
 994     { /* 91, Undefined                              */      0,                                                  state_undefined     },
 995     { /* 92, Undefined                              */      0,                                                  state_undefined     },
 996     { /* 93, Undefined                              */      0,                                                  state_undefined     },
 997     { /* 94, Undefined                              */      0,                                                  state_undefined     },
 998     { /* 95, Undefined                              */      0,                                                  state_undefined     },
 999     { /* 96, Undefined                              */      0,                                                  state_undefined     },
1000     { /* 97, Undefined                              */      0,                                                  state_undefined     },
1001     { /* 98, Undefined                              */      0,                                                  state_undefined     },
1002     { /* 99, Undefined                              */      0,                                                  state_undefined     },
1003     { /*100, Undefined                              */      0,                                                  state_undefined     },
1004     { /*101, Undefined                              */      0,                                                  state_undefined     },
1005     { /*102, Undefined                              */      0,                                                  state_undefined     },
1006     { /*103, Undefined                              */      0,                                                  state_undefined     },
1007     { /*104, Undefined                              */      0,                                                  state_undefined     },
1008     { /*105, Undefined                              */      0,                                                  state_undefined     },
1009     { /*106, Undefined                              */      0,                                                  state_undefined     },
1010     { /*107, Undefined                              */      0,                                                  state_undefined     },
1011     { /*108, Undefined                              */      0,                                                  state_undefined     },
1012     { /*109, Undefined                              */      0,                                                  state_undefined     },
1013     { /*110, Undefined                              */      0,                                                  state_undefined     },
1014     { /*111, Undefined                              */      0,                                                  state_undefined     },
1015     { /*112, Undefined                              */      0,                                                  state_undefined     },
1016     { /*113, Undefined                              */      0,                                                  state_undefined     },
1017     { /*114, Undefined                              */      0,                                                  state_undefined     },
1018     { /*115, Undefined                              */      0,                                                  state_undefined     },
1019     { /*116, Undefined                              */      0,                                                  state_undefined     },
1020     { /*117, Undefined                              */      0,                                                  state_undefined     },
1021     { /*118, Undefined                              */      0,                                                  state_undefined     },
1022     { /*119, Undefined                              */      0,                                                  state_undefined     },
1023     { /*120, Undefined                              */      0,                                                  state_undefined     },
1024     { /*121, Undefined                              */      0,                                                  state_undefined     },
1025     { /*122, Undefined                              */      0,                                                  state_undefined     },
1026     { /*123, Undefined                              */      0,                                                  state_undefined     },
1027     { /*124, Undefined                              */      0,                                                  state_undefined     },
1028     { /*125, Undefined                              */      0,                                                  state_undefined     },
1029     { /*126, Undefined                              */      0,                                                  state_undefined     },
1030     { /*127, Undefined                              */      0,                                                  state_undefined     },
1031     /* Big hole ends */
1032     { /*128, WINED3DRS_WRAP0                        */      STATE_RENDER(WINED3DRS_WRAP0),                      state_unknown       },
1033     { /*129, WINED3DRS_WRAP1                        */      STATE_RENDER(WINED3DRS_WRAP0),                      state_unknown       },
1034     { /*130, WINED3DRS_WRAP2                        */      STATE_RENDER(WINED3DRS_WRAP0),                      state_unknown       },
1035     { /*131, WINED3DRS_WRAP3                        */      STATE_RENDER(WINED3DRS_WRAP0),                      state_unknown       },
1036     { /*132, WINED3DRS_WRAP4                        */      STATE_RENDER(WINED3DRS_WRAP0),                      state_unknown       },
1037     { /*133, WINED3DRS_WRAP5                        */      STATE_RENDER(WINED3DRS_WRAP0),                      state_unknown       },
1038     { /*134, WINED3DRS_WRAP6                        */      STATE_RENDER(WINED3DRS_WRAP0),                      state_unknown       },
1039     { /*135, WINED3DRS_WRAP7                        */      STATE_RENDER(WINED3DRS_WRAP0),                      state_unknown       },
1040     { /*136, WINED3DRS_CLIPPING                     */      STATE_RENDER(WINED3DRS_CLIPPING),                   state_clipping      },
1041     { /*137, WINED3DRS_LIGHTING                     */      STATE_RENDER(WINED3DRS_LIGHTING) /* Vertex decl! */,state_lighting      },
1042     { /*138, WINED3DRS_EXTENTS                      */      STATE_RENDER(WINED3DRS_EXTENTS),                    state_unknown       },
1043     { /*139, WINED3DRS_AMBIENT                      */      STATE_RENDER(WINED3DRS_AMBIENT),                    state_ambient       },
1044     { /*140, WINED3DRS_FOGVERTEXMODE                */      STATE_RENDER(WINED3DRS_FOGENABLE),                  state_fog           },
1045     { /*141, WINED3DRS_COLORVERTEX                  */      STATE_RENDER(WINED3DRS_COLORVERTEX),                state_colormat      },
1046     { /*142, WINED3DRS_LOCALVIEWER                  */      STATE_RENDER(WINED3DRS_LOCALVIEWER),                state_unknown       },
1047     { /*143, WINED3DRS_NORMALIZENORMALS             */      STATE_RENDER(WINED3DRS_NORMALIZENORMALS),           state_unknown       },
1048     { /*144, WINED3DRS_COLORKEYBLENDENABLE          */      STATE_RENDER(WINED3DRS_COLORKEYBLENDENABLE),        state_unknown       },
1049     { /*145, WINED3DRS_DIFFUSEMATERIALSOURCE        */      STATE_RENDER(WINED3DRS_COLORVERTEX),                state_colormat      },
1050     { /*146, WINED3DRS_SPECULARMATERIALSOURCE       */      STATE_RENDER(WINED3DRS_COLORVERTEX),                state_colormat      },
1051     { /*147, WINED3DRS_AMBIENTMATERIALSOURCE        */      STATE_RENDER(WINED3DRS_COLORVERTEX),                state_colormat      },
1052     { /*148, WINED3DRS_EMISSIVEMATERIALSOURCE       */      STATE_RENDER(WINED3DRS_COLORVERTEX),                state_colormat      },
1053     { /*149, Undefined                              */      0,                                                  state_undefined     },
1054     { /*150, Undefined                              */      0,                                                  state_undefined     },
1055     { /*151, WINED3DRS_VERTEXBLEND                  */      0,                                                  state_nogl          },
1056     { /*152, WINED3DRS_CLIPPLANEENABLE              */      STATE_RENDER(WINED3DRS_CLIPPING),                   state_clipping      },
1057     { /*153, WINED3DRS_SOFTWAREVERTEXPROCESSING     */      0,                                                  state_nogl          },
1058     { /*154, WINED3DRS_POINTSIZE                    */      STATE_RENDER(WINED3DRS_POINTSIZE),                  state_unknown       },
1059     { /*155, WINED3DRS_POINTSIZE_MIN                */      STATE_RENDER(WINED3DRS_POINTSIZE_MIN),              state_unknown       },
1060     { /*156, WINED3DRS_POINTSPRITEENABLE            */      STATE_RENDER(WINED3DRS_POINTSPRITEENABLE),          state_unknown       },
1061     { /*157, WINED3DRS_POINTSCALEENABLE             */      STATE_RENDER(WINED3DRS_POINTSCALEENABLE),           state_unknown       },
1062     { /*158, WINED3DRS_POINTSCALE_A                 */      STATE_RENDER(WINED3DRS_POINTSCALEENABLE),           state_unknown       },
1063     { /*159, WINED3DRS_POINTSCALE_B                 */      STATE_RENDER(WINED3DRS_POINTSCALEENABLE),           state_unknown       },
1064     { /*160, WINED3DRS_POINTSCALE_C                 */      STATE_RENDER(WINED3DRS_POINTSCALEENABLE),           state_unknown       },
1065     { /*161, WINED3DRS_MULTISAMPLEANTIALIAS         */      STATE_RENDER(WINED3DRS_MULTISAMPLEANTIALIAS),       state_unknown       },
1066     { /*162, WINED3DRS_MULTISAMPLEMASK              */      STATE_RENDER(WINED3DRS_MULTISAMPLEMASK),            state_unknown       },
1067     { /*163, WINED3DRS_PATCHEDGESTYLE               */      STATE_RENDER(WINED3DRS_PATCHEDGESTYLE),             state_unknown       },
1068     { /*164, WINED3DRS_PATCHSEGMENTS                */      STATE_RENDER(WINED3DRS_PATCHSEGMENTS),              state_unknown       },
1069     { /*165, WINED3DRS_DEBUGMONITORTOKEN            */      STATE_RENDER(WINED3DRS_DEBUGMONITORTOKEN),          state_unknown       },
1070     { /*166, WINED3DRS_POINTSIZE_MAX                */      STATE_RENDER(WINED3DRS_POINTSIZE_MAX),              state_unknown       },
1071     { /*167, WINED3DRS_INDEXEDVERTEXBLENDENABLE     */      0,                                                  state_nogl          },
1072     { /*168, WINED3DRS_COLORWRITEENABLE             */      STATE_RENDER(WINED3DRS_COLORWRITEENABLE),           state_unknown       },
1073     { /*169, Undefined                              */      0,                                                  state_undefined     },
1074     { /*170, WINED3DRS_TWEENFACTOR                  */      0,                                                  state_nogl          },
1075     { /*171, WINED3DRS_BLENDOP                      */      STATE_RENDER(WINED3DRS_BLENDOP),                    state_blendop       },
1076     { /*172, WINED3DRS_POSITIONDEGREE               */      STATE_RENDER(WINED3DRS_POSITIONDEGREE),             state_unknown       },
1077     { /*173, WINED3DRS_NORMALDEGREE                 */      STATE_RENDER(WINED3DRS_NORMALDEGREE),               state_unknown       },
1078       /*172, WINED3DRS_POSITIONORDER                */      /* Value assigned to 2 state names */
1079       /*173, WINED3DRS_NORMALORDER                  */      /* Value assigned to 2 state names */
1080     { /*174, WINED3DRS_SCISSORTESTENABLE            */      STATE_RENDER(WINED3DRS_SCISSORTESTENABLE),          state_unknown       },
1081     { /*175, WINED3DRS_SLOPESCALEDEPTHBIAS          */      STATE_RENDER(WINED3DRS_DEPTHBIAS),                  state_unknown       },
1082     { /*176, WINED3DRS_ANTIALIASEDLINEENABLE        */      STATE_RENDER(WINED3DRS_ALPHABLENDENABLE),           state_blend         },
1083     { /*177, undefined                              */      0,                                                  state_undefined     },
1084     { /*178, WINED3DRS_MINTESSELLATIONLEVEL         */      STATE_RENDER(WINED3DRS_ENABLEADAPTIVETESSELLATION), state_unknown       },
1085     { /*179, WINED3DRS_MAXTESSELLATIONLEVEL         */      STATE_RENDER(WINED3DRS_ENABLEADAPTIVETESSELLATION), state_unknown       },
1086     { /*180, WINED3DRS_ADAPTIVETESS_X               */      STATE_RENDER(WINED3DRS_ENABLEADAPTIVETESSELLATION), state_unknown       },
1087     { /*181, WINED3DRS_ADAPTIVETESS_Y               */      STATE_RENDER(WINED3DRS_ENABLEADAPTIVETESSELLATION), state_unknown       },
1088     { /*182, WINED3DRS_ADAPTIVETESS_Z               */      STATE_RENDER(WINED3DRS_ENABLEADAPTIVETESSELLATION), state_unknown       },
1089     { /*183, WINED3DRS_ADAPTIVETESS_W               */      STATE_RENDER(WINED3DRS_ENABLEADAPTIVETESSELLATION), state_unknown       },
1090     { /*184, WINED3DRS_ENABLEADAPTIVETESSELLATION   */      STATE_RENDER(WINED3DRS_ENABLEADAPTIVETESSELLATION), state_unknown       },
1091     { /*185, WINED3DRS_TWOSIDEDSTENCILMODE          */      STATE_RENDER(WINED3DRS_STENCILENABLE),              state_stencil       },
1092     { /*186, WINED3DRS_CCW_STENCILFAIL              */      STATE_RENDER(WINED3DRS_STENCILENABLE),              state_stencil       },
1093     { /*187, WINED3DRS_CCW_STENCILZFAIL             */      STATE_RENDER(WINED3DRS_STENCILENABLE),              state_stencil       },
1094     { /*188, WINED3DRS_CCW_STENCILPASS              */      STATE_RENDER(WINED3DRS_STENCILENABLE),              state_stencil       },
1095     { /*189, WINED3DRS_CCW_STENCILFUNC              */      STATE_RENDER(WINED3DRS_STENCILENABLE),              state_stencil       },
1096     { /*190, WINED3DRS_COLORWRITEENABLE1            */      STATE_RENDER(WINED3DRS_COLORWRITEENABLE),           state_unknown       },
1097     { /*191, WINED3DRS_COLORWRITEENABLE2            */      STATE_RENDER(WINED3DRS_COLORWRITEENABLE),           state_unknown       },
1098     { /*192, WINED3DRS_COLORWRITEENABLE3            */      STATE_RENDER(WINED3DRS_COLORWRITEENABLE),           state_unknown       },
1099     { /*193, WINED3DRS_BLENDFACTOR                  */      STATE_RENDER(WINED3DRS_ALPHABLENDENABLE),           state_blend         },
1100     { /*194, WINED3DRS_SRGBWRITEENABLE              */      0,                                                  state_nogl          },
1101     { /*195, WINED3DRS_DEPTHBIAS                    */      STATE_RENDER(WINED3DRS_DEPTHBIAS),                  state_unknown       },
1102     { /*196, undefined                              */      0,                                                  state_undefined     },
1103     { /*197, undefined                              */      0,                                                  state_undefined     },
1104     { /*198, WINED3DRS_WRAP8                        */      STATE_RENDER(WINED3DRS_WRAP0),                      state_unknown       },
1105     { /*199, WINED3DRS_WRAP9                        */      STATE_RENDER(WINED3DRS_WRAP0),                      state_unknown       },
1106     { /*200, WINED3DRS_WRAP10                       */      STATE_RENDER(WINED3DRS_WRAP0),                      state_unknown       },
1107     { /*201, WINED3DRS_WRAP11                       */      STATE_RENDER(WINED3DRS_WRAP0),                      state_unknown       },
1108     { /*202, WINED3DRS_WRAP12                       */      STATE_RENDER(WINED3DRS_WRAP0),                      state_unknown       },
1109     { /*203, WINED3DRS_WRAP13                       */      STATE_RENDER(WINED3DRS_WRAP0),                      state_unknown       },
1110     { /*204, WINED3DRS_WRAP14                       */      STATE_RENDER(WINED3DRS_WRAP0),                      state_unknown       },
1111     { /*205, WINED3DRS_WRAP15                       */      STATE_RENDER(WINED3DRS_WRAP0),                      state_unknown       },
1112     { /*206, WINED3DRS_SEPARATEALPHABLENDENABLE     */      STATE_RENDER(WINED3DRS_SEPARATEALPHABLENDENABLE),   state_unknown       },
1113     { /*207, WINED3DRS_SRCBLENDALPHA                */      STATE_RENDER(WINED3DRS_SEPARATEALPHABLENDENABLE),   state_unknown       },
1114     { /*208, WINED3DRS_DESTBLENDALPHA               */      STATE_RENDER(WINED3DRS_SEPARATEALPHABLENDENABLE),   state_unknown       },
1115     { /*209, WINED3DRS_BLENDOPALPHA                 */      STATE_RENDER(WINED3DRS_SEPARATEALPHABLENDENABLE),   state_unknown       },
1116 };