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 static void state_unknown(DWORD state, IWineD3DStateBlockImpl *stateblock) {
  31     /* State which does exist, but wined3d doesn't know about */
  32     if(STATE_IS_RENDER(state)) {
  33         WINED3DRENDERSTATETYPE RenderState = state - STATE_RENDER(0);
  34         FIXME("(%s, %d) Unknown renderstate\n", debug_d3drenderstate(RenderState), stateblock->renderState[RenderState]);
  35     } else {
  36         FIXME("(%d) Unknown state with unknown type\n", state);
  37     }
  38 }
  39
  40 static void state_nogl(DWORD state, IWineD3DStateBlockImpl *stateblock) {
  41     /* Used for states which are not mapped to a gl state as-is, but used somehow different,
  42      * e.g as a parameter for drawing, or which are unimplemented in windows d3d
  43      */
  44     if(STATE_IS_RENDER(state)) {
  45         WINED3DRENDERSTATETYPE RenderState = state - STATE_RENDER(0);
  46         TRACE("(%s,%d) no direct mapping to gl\n", debug_d3drenderstate(RenderState), stateblock->renderState[RenderState]);
  47     } else {
  48         /* Shouldn't have an unknown type here */
  49         FIXME("%d no direct mapping to gl of state with unknown type\n", state);
  50     }
  51 }
  52
  53 static void state_undefined(DWORD state, IWineD3DStateBlockImpl *stateblock) {
  54     /* Print a WARN, this allows the stateblock code to loop over all states to generate a display
  55      * list without causing confusing terminal output. Deliberately no special debug name here
  56      * because its undefined.
  57      */
  58     WARN("undefined state %d\n", state);
  59 }
  60
  61 static void state_fillmode(DWORD state, IWineD3DStateBlockImpl *stateblock) {
  62     D3DFILLMODE Value = stateblock->renderState[WINED3DRS_FILLMODE];
  63
  64     switch(Value) {
  65         case D3DFILL_POINT:
  66             glPolygonMode(GL_FRONT_AND_BACK, GL_POINT);
  67             checkGLcall("glPolygonMode(GL_FRONT_AND_BACK, GL_POINT)");
  68             break;
  69         case D3DFILL_WIREFRAME:
  70             glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
  71             checkGLcall("glPolygonMode(GL_FRONT_AND_BACK, GL_LINE)");
  72             break;
  73         case D3DFILL_SOLID:
  74             glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
  75             checkGLcall("glPolygonMode(GL_FRONT_AND_BACK, GL_FILL)");
  76             break;
  77         default:
  78             FIXME("Unrecognized WINED3DRS_FILLMODE value %d\n", Value);
  79     }
  80 }
  81
  82 static void state_lighting(DWORD state, IWineD3DStateBlockImpl *stateblock) {
  83
  84     /* TODO: Lighting is only enabled if Vertex normals are passed by the application,
  85      * so merge the lighting render state with the vertex declaration once it is available
  86      */
  87
  88     if (stateblock->renderState[WINED3DRS_LIGHTING]) {
  89         glEnable(GL_LIGHTING);
  90         checkGLcall("glEnable GL_LIGHTING");
  91     } else {
  92         glDisable(GL_LIGHTING);
  93         checkGLcall("glDisable GL_LIGHTING");
  94     }
  95 }
  96
  97 static void state_zenable(DWORD state, IWineD3DStateBlockImpl *stateblock) {
  98     switch ((WINED3DZBUFFERTYPE) stateblock->renderState[WINED3DRS_ZENABLE]) {
  99         case WINED3DZB_FALSE:
 100             glDisable(GL_DEPTH_TEST);
 101             checkGLcall("glDisable GL_DEPTH_TEST");
 102             break;
 103         case WINED3DZB_TRUE:
 104             glEnable(GL_DEPTH_TEST);
 105             checkGLcall("glEnable GL_DEPTH_TEST");
 106             break;
 107         case WINED3DZB_USEW:
 108             glEnable(GL_DEPTH_TEST);
 109             checkGLcall("glEnable GL_DEPTH_TEST");
 110             FIXME("W buffer is not well handled\n");
 111             break;
 112         default:
 113             FIXME("Unrecognized D3DZBUFFERTYPE value %d\n", stateblock->renderState[WINED3DRS_ZENABLE]);
 114     }
 115 }
 116
 117 static void state_cullmode(DWORD state, IWineD3DStateBlockImpl *stateblock) {
 118     /* TODO: Put this into the offscreen / onscreen rendering block due to device->render_offscreen */
 119
 120     /* If we are culling "back faces with clockwise vertices" then
 121        set front faces to be counter clockwise and enable culling
 122        of back faces                                               */
 123     switch ((WINED3DCULL) stateblock->renderState[WINED3DRS_CULLMODE]) {
 124         case WINED3DCULL_NONE:
 125             glDisable(GL_CULL_FACE);
 126             checkGLcall("glDisable GL_CULL_FACE");
 127             break;
 128         case WINED3DCULL_CW:
 129             glEnable(GL_CULL_FACE);
 130             checkGLcall("glEnable GL_CULL_FACE");
 131             if (stateblock->wineD3DDevice->render_offscreen) {
 132                 glFrontFace(GL_CW);
 133                 checkGLcall("glFrontFace GL_CW");
 134             } else {
 135                 glFrontFace(GL_CCW);
 136                 checkGLcall("glFrontFace GL_CCW");
 137             }
 138             glCullFace(GL_BACK);
 139             break;
 140         case WINED3DCULL_CCW:
 141             glEnable(GL_CULL_FACE);
 142             checkGLcall("glEnable GL_CULL_FACE");
 143             if (stateblock->wineD3DDevice->render_offscreen) {
 144                 glFrontFace(GL_CCW);
 145                 checkGLcall("glFrontFace GL_CCW");
 146             } else {
 147                 glFrontFace(GL_CW);
 148                 checkGLcall("glFrontFace GL_CW");
 149             }
 150             glCullFace(GL_BACK);
 151             break;
 152         default:
 153             FIXME("Unrecognized/Unhandled WINED3DCULL value %d\n", stateblock->renderState[WINED3DRS_CULLMODE]);
 154     }
 155 }
 156
 157 static void state_shademode(DWORD state, IWineD3DStateBlockImpl *stateblock) {
 158     switch ((WINED3DSHADEMODE) stateblock->renderState[WINED3DRS_SHADEMODE]) {
 159         case WINED3DSHADE_FLAT:
 160             glShadeModel(GL_FLAT);
 161             checkGLcall("glShadeModel(GL_FLAT)");
 162             break;
 163         case WINED3DSHADE_GOURAUD:
 164             glShadeModel(GL_SMOOTH);
 165             checkGLcall("glShadeModel(GL_SMOOTH)");
 166             break;
 167         case WINED3DSHADE_PHONG:
 168             FIXME("WINED3DSHADE_PHONG isn't supported\n");
 169             break;
 170         default:
 171             FIXME("Unrecognized/Unhandled WINED3DSHADEMODE value %d\n", stateblock->renderState[WINED3DRS_SHADEMODE]);
 172     }
 173 }
 174
 175 static void state_ditherenable(DWORD state, IWineD3DStateBlockImpl *stateblock) {
 176     if (stateblock->renderState[WINED3DRS_DITHERENABLE]) {
 177         glEnable(GL_DITHER);
 178         checkGLcall("glEnable GL_DITHER");
 179     } else {
 180         glDisable(GL_DITHER);
 181         checkGLcall("glDisable GL_DITHER");
 182     }
 183 }
 184
 185 static void state_zwritenable(DWORD state, IWineD3DStateBlockImpl *stateblock) {
 186     /* TODO: Test if in d3d z writing is enabled even if ZENABLE is off. If yes,
 187      * this has to be merged with ZENABLE and ZFUNC
 188      */
 189     if (stateblock->renderState[WINED3DRS_ZWRITEENABLE]) {
 190         glDepthMask(1);
 191         checkGLcall("glDepthMask(1)");
 192     } else {
 193         glDepthMask(0);
 194         checkGLcall("glDepthMask(0)");
 195     }
 196 }
 197
 198 static void state_zfunc(DWORD state, IWineD3DStateBlockImpl *stateblock) {
 199     int glParm = CompareFunc(stateblock->renderState[WINED3DRS_ZFUNC]);
 200
 201     if(glParm) {
 202         glDepthFunc(glParm);
 203         checkGLcall("glDepthFunc");
 204     }
 205 }
 206
 207 const struct StateEntry StateTable[] =
 208 {
 209       /* State name                                         representative,                                     apply function */
 210     { /* 0,  Undefined                              */      0,                                                  state_undefined     },
 211     { /* 1,  WINED3DRS_TEXTUREHANDLE                */      0 /* Handled in ddraw */,                           state_undefined     },
 212     { /* 2,  WINED3DRS_ANTIALIAS                    */      STATE_RENDER(WINED3DRS_ANTIALIAS),                  state_unknown       },
 213     { /* 3,  WINED3DRS_TEXTUREADDRESS               */      0 /* Handled in ddraw */,                           state_undefined     },
 214     { /* 4,  WINED3DRS_TEXTUREPERSPECTIVE           */      STATE_RENDER(WINED3DRS_TEXTUREPERSPECTIVE),         state_unknown       },
 215     { /* 5,  WINED3DRS_WRAPU                        */      STATE_RENDER(WINED3DRS_WRAPU),                      state_unknown       },
 216     { /* 6,  WINED3DRS_WRAPV                        */      STATE_RENDER(WINED3DRS_WRAPV),                      state_unknown       },
 217     { /* 7,  WINED3DRS_ZENABLE                      */      STATE_RENDER(WINED3DRS_ZENABLE),                    state_zenable       },
 218     { /* 8,  WINED3DRS_FILLMODE                     */      STATE_RENDER(WINED3DRS_FILLMODE),                   state_fillmode      },
 219     { /* 9,  WINED3DRS_SHADEMODE                    */      STATE_RENDER(WINED3DRS_SHADEMODE),                  state_shademode     },
 220     { /* 10, WINED3DRS_LINEPATTERN                  */      STATE_RENDER(WINED3DRS_LINEPATTERN),                state_unknown       },
 221     { /* 11, WINED3DRS_MONOENABLE                   */      STATE_RENDER(WINED3DRS_MONOENABLE),                 state_unknown       },
 222     { /* 12, WINED3DRS_ROP2                         */      STATE_RENDER(WINED3DRS_ROP2),                       state_unknown       },
 223     { /* 13, WINED3DRS_PLANEMASK                    */      STATE_RENDER(WINED3DRS_PLANEMASK),                  state_unknown       },
 224     { /* 14, WINED3DRS_ZWRITEENABLE                 */      STATE_RENDER(WINED3DRS_ZWRITEENABLE),               state_zwritenable   },
 225     { /* 15, WINED3DRS_ALPHATESTENABLE              */      STATE_RENDER(WINED3DRS_ALPHATESTENABLE),            state_unknown       },
 226     { /* 16, WINED3DRS_LASTPIXEL                    */      STATE_RENDER(WINED3DRS_LASTPIXEL),                  state_unknown       },
 227     { /* 17, WINED3DRS_TEXTUREMAG                   */      0 /* Handled in ddraw */,                           state_undefined     },
 228     { /* 18, WINED3DRS_TEXTUREMIN                   */      0 /* Handled in ddraw */,                           state_undefined     },
 229     { /* 19, WINED3DRS_SRCBLEND                     */      STATE_RENDER(WINED3DRS_ALPHABLENDENABLE),           state_unknown       },
 230     { /* 20, WINED3DRS_DESTBLEND                    */      STATE_RENDER(WINED3DRS_ALPHABLENDENABLE),           state_unknown       },
 231     { /* 21, WINED3DRS_TEXTUREMAPBLEND              */      0 /* Handled in ddraw */,                           state_undefined     },
 232     { /* 22, WINED3DRS_CULLMODE                     */      STATE_RENDER(WINED3DRS_CULLMODE),                   state_cullmode      },
 233     { /* 23, WINED3DRS_ZFUNC                        */      STATE_RENDER(WINED3DRS_ZFUNC),                      state_zfunc         },
 234     { /* 24, WINED3DRS_ALPHAREF                     */      STATE_RENDER(WINED3DRS_ALPHATESTENABLE),            state_unknown       },
 235     { /* 25, WINED3DRS_ALPHAFUNC                    */      STATE_RENDER(WINED3DRS_ALPHATESTENABLE),            state_unknown       },
 236     { /* 26, WINED3DRS_DITHERENABLE                 */      STATE_RENDER(WINED3DRS_DITHERENABLE),               state_ditherenable  },
 237     { /* 27, WINED3DRS_ALPHABLENDENABLE             */      STATE_RENDER(WINED3DRS_ALPHABLENDENABLE),           state_unknown       },
 238     { /* 28, WINED3DRS_FOGENABLE                    */      STATE_RENDER(WINED3DRS_FOGENABLE),                  state_unknown       },
 239     { /* 29, WINED3DRS_SPECULARENABLE               */      STATE_RENDER(WINED3DRS_SPECULARENABLE),             state_unknown       },
 240     { /* 30, WINED3DRS_ZVISIBLE                     */      0 /* Not supported according to the msdn */,        state_nogl          },
 241     { /* 31, WINED3DRS_SUBPIXEL                     */      STATE_RENDER(WINED3DRS_SUBPIXEL),                   state_unknown       },
 242     { /* 32, WINED3DRS_SUBPIXELX                    */      STATE_RENDER(WINED3DRS_SUBPIXELX),                  state_unknown       },
 243     { /* 33, WINED3DRS_STIPPLEDALPHA                */      STATE_RENDER(WINED3DRS_STIPPLEDALPHA),              state_unknown       },
 244     { /* 34, WINED3DRS_FOGCOLOR                     */      STATE_RENDER(WINED3DRS_FOGCOLOR),                   state_unknown       },
 245     { /* 35, WINED3DRS_FOGTABLEMODE                 */      STATE_RENDER(WINED3DRS_FOGENABLE)/*vertex type*/,   state_unknown       },
 246     { /* 36, WINED3DRS_FOGSTART                     */      STATE_RENDER(WINED3DRS_FOGENABLE),                  state_unknown       },
 247     { /* 37, WINED3DRS_FOGEND                       */      STATE_RENDER(WINED3DRS_FOGENABLE),                  state_unknown       },
 248     { /* 38, WINED3DRS_FOGDENSITY                   */      STATE_RENDER(WINED3DRS_FOGDENSITY),                 state_unknown       },
 249     { /* 39, WINED3DRS_STIPPLEENABLE                */      STATE_RENDER(WINED3DRS_STIPPLEENABLE),              state_unknown       },
 250     { /* 40, WINED3DRS_EDGEANTIALIAS                */      STATE_RENDER(WINED3DRS_ALPHABLENDENABLE),           state_unknown       },
 251     { /* 41, WINED3DRS_COLORKEYENABLE               */      STATE_RENDER(WINED3DRS_ALPHATESTENABLE),            state_unknown       },
 252     { /* 42, undefined                              */      0,                                                  state_undefined     },
 253     { /* 43, WINED3DRS_BORDERCOLOR                  */      STATE_RENDER(WINED3DRS_BORDERCOLOR),                state_unknown       },
 254     { /* 44, WINED3DRS_TEXTUREADDRESSU              */      0, /* Handled in ddraw */                           state_undefined     },
 255     { /* 45, WINED3DRS_TEXTUREADDRESSV              */      0, /* Handled in ddraw */                           state_undefined     },
 256     { /* 46, WINED3DRS_MIPMAPLODBIAS                */      STATE_RENDER(WINED3DRS_MIPMAPLODBIAS),              state_unknown       },
 257     { /* 47, WINED3DRS_ZBIAS                        */      STATE_RENDER(WINED3DRS_ZBIAS),                      state_unknown       },
 258     { /* 48, WINED3DRS_RANGEFOGENABLE               */      STATE_RENDER(WINED3DRS_RANGEFOGENABLE),             state_unknown       },
 259     { /* 49, WINED3DRS_ANISOTROPY                   */      STATE_RENDER(WINED3DRS_ANISOTROPY),                 state_unknown       },
 260     { /* 50, WINED3DRS_FLUSHBATCH                   */      STATE_RENDER(WINED3DRS_FLUSHBATCH),                 state_unknown       },
 261     { /* 51, WINED3DRS_TRANSLUCENTSORTINDEPENDENT   */      STATE_RENDER(WINED3DRS_TRANSLUCENTSORTINDEPENDENT), state_unknown       },
 262     { /* 52, WINED3DRS_STENCILENABLE                */      STATE_RENDER(WINED3DRS_STENCILENABLE),              state_unknown       },
 263     { /* 53, WINED3DRS_STENCILFAIL                  */      STATE_RENDER(WINED3DRS_STENCILENABLE),              state_unknown       },
 264     { /* 54, WINED3DRS_STENCILZFAIL                 */      STATE_RENDER(WINED3DRS_STENCILENABLE),              state_unknown       },
 265     { /* 55, WINED3DRS_STENCILPASS                  */      STATE_RENDER(WINED3DRS_STENCILENABLE),              state_unknown       },
 266     { /* 56, WINED3DRS_STENCILFUNC                  */      STATE_RENDER(WINED3DRS_STENCILENABLE),              state_unknown       },
 267     { /* 57, WINED3DRS_STENCILREF                   */      STATE_RENDER(WINED3DRS_STENCILENABLE),              state_unknown       },
 268     { /* 58, WINED3DRS_STENCILMASK                  */      STATE_RENDER(WINED3DRS_STENCILENABLE),              state_unknown       },
 269     { /* 59, WINED3DRS_STENCILWRITEMASK             */      STATE_RENDER(WINED3DRS_STENCILWRITEMASK),           state_unknown       },
 270     { /* 60, WINED3DRS_TEXTUREFACTOR                */      STATE_RENDER(WINED3DRS_TEXTUREFACTOR),              state_unknown       },
 271     /* A BIG hole. If wanted, 'fixed' states like the vertex type or the bound shaders can be put here */
 272     { /* 61, Undefined                              */      0,                                                  state_undefined     },
 273     { /* 62, Undefined                              */      0,                                                  state_undefined     },
 274     { /* 63, Undefined                              */      0,                                                  state_undefined     },
 275     { /* 64, Undefined                              */      0,                                                  state_undefined     },
 276     { /* 65, Undefined                              */      0,                                                  state_undefined     },
 277     { /* 66, Undefined                              */      0,                                                  state_undefined     },
 278     { /* 67, Undefined                              */      0,                                                  state_undefined     },
 279     { /* 68, Undefined                              */      0,                                                  state_undefined     },
 280     { /* 69, Undefined                              */      0,                                                  state_undefined     },
 281     { /* 70, Undefined                              */      0,                                                  state_undefined     },
 282     { /* 71, Undefined                              */      0,                                                  state_undefined     },
 283     { /* 72, Undefined                              */      0,                                                  state_undefined     },
 284     { /* 73, Undefined                              */      0,                                                  state_undefined     },
 285     { /* 74, Undefined                              */      0,                                                  state_undefined     },
 286     { /* 75, Undefined                              */      0,                                                  state_undefined     },
 287     { /* 76, Undefined                              */      0,                                                  state_undefined     },
 288     { /* 77, Undefined                              */      0,                                                  state_undefined     },
 289     { /* 78, Undefined                              */      0,                                                  state_undefined     },
 290     { /* 79, Undefined                              */      0,                                                  state_undefined     },
 291     { /* 80, Undefined                              */      0,                                                  state_undefined     },
 292     { /* 81, Undefined                              */      0,                                                  state_undefined     },
 293     { /* 82, Undefined                              */      0,                                                  state_undefined     },
 294     { /* 83, Undefined                              */      0,                                                  state_undefined     },
 295     { /* 84, Undefined                              */      0,                                                  state_undefined     },
 296     { /* 85, Undefined                              */      0,                                                  state_undefined     },
 297     { /* 86, Undefined                              */      0,                                                  state_undefined     },
 298     { /* 87, Undefined                              */      0,                                                  state_undefined     },
 299     { /* 88, Undefined                              */      0,                                                  state_undefined     },
 300     { /* 89, Undefined                              */      0,                                                  state_undefined     },
 301     { /* 90, Undefined                              */      0,                                                  state_undefined     },
 302     { /* 91, Undefined                              */      0,                                                  state_undefined     },
 303     { /* 92, Undefined                              */      0,                                                  state_undefined     },
 304     { /* 93, Undefined                              */      0,                                                  state_undefined     },
 305     { /* 94, Undefined                              */      0,                                                  state_undefined     },
 306     { /* 95, Undefined                              */      0,                                                  state_undefined     },
 307     { /* 96, Undefined                              */      0,                                                  state_undefined     },
 308     { /* 97, Undefined                              */      0,                                                  state_undefined     },
 309     { /* 98, Undefined                              */      0,                                                  state_undefined     },
 310     { /* 99, Undefined                              */      0,                                                  state_undefined     },
 311     { /*100, Undefined                              */      0,                                                  state_undefined     },
 312     { /*101, Undefined                              */      0,                                                  state_undefined     },
 313     { /*102, Undefined                              */      0,                                                  state_undefined     },
 314     { /*103, Undefined                              */      0,                                                  state_undefined     },
 315     { /*104, Undefined                              */      0,                                                  state_undefined     },
 316     { /*105, Undefined                              */      0,                                                  state_undefined     },
 317     { /*106, Undefined                              */      0,                                                  state_undefined     },
 318     { /*107, Undefined                              */      0,                                                  state_undefined     },
 319     { /*108, Undefined                              */      0,                                                  state_undefined     },
 320     { /*109, Undefined                              */      0,                                                  state_undefined     },
 321     { /*110, Undefined                              */      0,                                                  state_undefined     },
 322     { /*111, Undefined                              */      0,                                                  state_undefined     },
 323     { /*112, Undefined                              */      0,                                                  state_undefined     },
 324     { /*113, Undefined                              */      0,                                                  state_undefined     },
 325     { /*114, Undefined                              */      0,                                                  state_undefined     },
 326     { /*115, Undefined                              */      0,                                                  state_undefined     },
 327     { /*116, Undefined                              */      0,                                                  state_undefined     },
 328     { /*117, Undefined                              */      0,                                                  state_undefined     },
 329     { /*118, Undefined                              */      0,                                                  state_undefined     },
 330     { /*119, Undefined                              */      0,                                                  state_undefined     },
 331     { /*120, Undefined                              */      0,                                                  state_undefined     },
 332     { /*121, Undefined                              */      0,                                                  state_undefined     },
 333     { /*122, Undefined                              */      0,                                                  state_undefined     },
 334     { /*123, Undefined                              */      0,                                                  state_undefined     },
 335     { /*124, Undefined                              */      0,                                                  state_undefined     },
 336     { /*125, Undefined                              */      0,                                                  state_undefined     },
 337     { /*126, Undefined                              */      0,                                                  state_undefined     },
 338     { /*127, Undefined                              */      0,                                                  state_undefined     },
 339     /* Big hole ends */
 340     { /*128, WINED3DRS_WRAP0                        */      STATE_RENDER(WINED3DRS_WRAP0),                      state_unknown       },
 341     { /*129, WINED3DRS_WRAP1                        */      STATE_RENDER(WINED3DRS_WRAP0),                      state_unknown       },
 342     { /*130, WINED3DRS_WRAP2                        */      STATE_RENDER(WINED3DRS_WRAP0),                      state_unknown       },
 343     { /*131, WINED3DRS_WRAP3                        */      STATE_RENDER(WINED3DRS_WRAP0),                      state_unknown       },
 344     { /*132, WINED3DRS_WRAP4                        */      STATE_RENDER(WINED3DRS_WRAP0),                      state_unknown       },
 345     { /*133, WINED3DRS_WRAP5                        */      STATE_RENDER(WINED3DRS_WRAP0),                      state_unknown       },
 346     { /*134, WINED3DRS_WRAP6                        */      STATE_RENDER(WINED3DRS_WRAP0),                      state_unknown       },
 347     { /*135, WINED3DRS_WRAP7                        */      STATE_RENDER(WINED3DRS_WRAP0),                      state_unknown       },
 348     { /*136, WINED3DRS_CLIPPING                     */      STATE_RENDER(WINED3DRS_CLIPPING),                   state_unknown       },
 349     { /*137, WINED3DRS_LIGHTING                     */      STATE_RENDER(WINED3DRS_LIGHTING) /* Vertex decl! */,state_lighting      },
 350     { /*138, WINED3DRS_EXTENTS                      */      STATE_RENDER(WINED3DRS_EXTENTS),                    state_unknown       },
 351     { /*139, WINED3DRS_AMBIENT                      */      STATE_RENDER(WINED3DRS_AMBIENT),                    state_unknown       },
 352     { /*140, WINED3DRS_FOGVERTEXMODE                */      STATE_RENDER(WINED3DRS_FOGENABLE),                  state_unknown       },
 353     { /*141, WINED3DRS_COLORVERTEX                  */      STATE_RENDER(WINED3DRS_COLORVERTEX),                state_unknown       },
 354     { /*142, WINED3DRS_LOCALVIEWER                  */      STATE_RENDER(WINED3DRS_LOCALVIEWER),                state_unknown       },
 355     { /*143, WINED3DRS_NORMALIZENORMALS             */      STATE_RENDER(WINED3DRS_NORMALIZENORMALS),           state_unknown       },
 356     { /*144, WINED3DRS_COLORKEYBLENDENABLE          */      STATE_RENDER(WINED3DRS_COLORKEYBLENDENABLE),        state_unknown       },
 357     { /*145, WINED3DRS_DIFFUSEMATERIALSOURCE        */      STATE_RENDER(WINED3DRS_COLORVERTEX),                state_unknown       },
 358     { /*146, WINED3DRS_SPECULARMATERIALSOURCE       */      STATE_RENDER(WINED3DRS_COLORVERTEX),                state_unknown       },
 359     { /*147, WINED3DRS_AMBIENTMATERIALSOURCE        */      STATE_RENDER(WINED3DRS_COLORVERTEX),                state_unknown       },
 360     { /*148, WINED3DRS_EMISSIVEMATERIALSOURCE       */      STATE_RENDER(WINED3DRS_COLORVERTEX),                state_unknown       },
 361     { /*149, Undefined                              */      0,                                                  state_undefined     },
 362     { /*150, Undefined                              */      0,                                                  state_undefined     },
 363     { /*151, WINED3DRS_VERTEXBLEND                  */      0,                                                  state_nogl          },
 364     { /*152, WINED3DRS_CLIPPLANEENABLE              */      STATE_RENDER(WINED3DRS_CLIPPING),                   state_unknown       },
 365     { /*153, WINED3DRS_SOFTWAREVERTEXPROCESSING     */      0,                                                  state_nogl          },
 366     { /*154, WINED3DRS_POINTSIZE                    */      STATE_RENDER(WINED3DRS_POINTSIZE),                  state_unknown       },
 367     { /*155, WINED3DRS_POINTSIZE_MIN                */      STATE_RENDER(WINED3DRS_POINTSIZE_MIN),              state_unknown       },
 368     { /*156, WINED3DRS_POINTSPRITEENABLE            */      STATE_RENDER(WINED3DRS_POINTSPRITEENABLE),          state_unknown       },
 369     { /*157, WINED3DRS_POINTSCALEENABLE             */      STATE_RENDER(WINED3DRS_POINTSCALEENABLE),           state_unknown       },
 370     { /*158, WINED3DRS_POINTSCALE_A                 */      STATE_RENDER(WINED3DRS_POINTSCALEENABLE),           state_unknown       },
 371     { /*159, WINED3DRS_POINTSCALE_B                 */      STATE_RENDER(WINED3DRS_POINTSCALEENABLE),           state_unknown       },
 372     { /*160, WINED3DRS_POINTSCALE_C                 */      STATE_RENDER(WINED3DRS_POINTSCALEENABLE),           state_unknown       },
 373     { /*161, WINED3DRS_MULTISAMPLEANTIALIAS         */      STATE_RENDER(WINED3DRS_MULTISAMPLEANTIALIAS),       state_unknown       },
 374     { /*162, WINED3DRS_MULTISAMPLEMASK              */      STATE_RENDER(WINED3DRS_MULTISAMPLEMASK),            state_unknown       },
 375     { /*163, WINED3DRS_PATCHEDGESTYLE               */      STATE_RENDER(WINED3DRS_PATCHEDGESTYLE),             state_unknown       },
 376     { /*164, WINED3DRS_PATCHSEGMENTS                */      STATE_RENDER(WINED3DRS_PATCHSEGMENTS),              state_unknown       },
 377     { /*165, WINED3DRS_DEBUGMONITORTOKEN            */      STATE_RENDER(WINED3DRS_DEBUGMONITORTOKEN),          state_unknown       },
 378     { /*166, WINED3DRS_POINTSIZE_MAX                */      STATE_RENDER(WINED3DRS_POINTSIZE_MAX),              state_unknown       },
 379     { /*167, WINED3DRS_INDEXEDVERTEXBLENDENABLE     */      STATE_RENDER(WINED3DRS_INDEXEDVERTEXBLENDENABLE),   state_unknown       },
 380     { /*168, WINED3DRS_COLORWRITEENABLE             */      STATE_RENDER(WINED3DRS_COLORWRITEENABLE),           state_unknown       },
 381     { /*169, Undefined                              */      0,                                                  state_undefined     },
 382     { /*170, WINED3DRS_TWEENFACTOR                  */      0,                                                  state_nogl          },
 383     { /*171, WINED3DRS_BLENDOP                      */      STATE_RENDER(WINED3DRS_BLENDOP),                    state_unknown       },
 384     { /*172, WINED3DRS_POSITIONDEGREE               */      STATE_RENDER(WINED3DRS_POSITIONDEGREE),             state_unknown       },
 385     { /*173, WINED3DRS_NORMALDEGREE                 */      STATE_RENDER(WINED3DRS_NORMALDEGREE),               state_unknown       },
 386       /*172, WINED3DRS_POSITIONORDER                */      /* Value assigned to 2 state names */
 387       /*173, WINED3DRS_NORMALORDER                  */      /* Value assigned to 2 state names */
 388     { /*174, WINED3DRS_SCISSORTESTENABLE            */      STATE_RENDER(WINED3DRS_SCISSORTESTENABLE),          state_unknown       },
 389     { /*175, WINED3DRS_SLOPESCALEDEPTHBIAS          */      STATE_RENDER(WINED3DRS_DEPTHBIAS),                  state_unknown       },
 390     { /*176, WINED3DRS_ANTIALIASEDLINEENABLE        */      STATE_RENDER(WINED3DRS_ALPHABLENDENABLE),           state_unknown       },
 391     { /*177, undefined                              */      0,                                                  state_undefined     },
 392     { /*178, WINED3DRS_MINTESSELLATIONLEVEL         */      STATE_RENDER(WINED3DRS_ENABLEADAPTIVETESSELLATION), state_unknown       },
 393     { /*179, WINED3DRS_MAXTESSELLATIONLEVEL         */      STATE_RENDER(WINED3DRS_ENABLEADAPTIVETESSELLATION), state_unknown       },
 394     { /*180, WINED3DRS_ADAPTIVETESS_X               */      STATE_RENDER(WINED3DRS_ENABLEADAPTIVETESSELLATION), state_unknown       },
 395     { /*181, WINED3DRS_ADAPTIVETESS_Y               */      STATE_RENDER(WINED3DRS_ENABLEADAPTIVETESSELLATION), state_unknown       },
 396     { /*182, WINED3DRS_ADAPTIVETESS_Z               */      STATE_RENDER(WINED3DRS_ENABLEADAPTIVETESSELLATION), state_unknown       },
 397     { /*183, WINED3DRS_ADAPTIVETESS_W               */      STATE_RENDER(WINED3DRS_ENABLEADAPTIVETESSELLATION), state_unknown       },
 398     { /*184, WINED3DRS_ENABLEADAPTIVETESSELLATION   */      STATE_RENDER(WINED3DRS_ENABLEADAPTIVETESSELLATION), state_unknown       },
 399     { /*185, WINED3DRS_TWOSIDEDSTENCILMODE          */      STATE_RENDER(WINED3DRS_STENCILENABLE),              state_unknown       },
 400     { /*186, WINED3DRS_CCW_STENCILFAIL              */      STATE_RENDER(WINED3DRS_STENCILENABLE),              state_unknown       },
 401     { /*187, WINED3DRS_CCW_STENCILZFAIL             */      STATE_RENDER(WINED3DRS_STENCILENABLE),              state_unknown       },
 402     { /*188, WINED3DRS_CCW_STENCILPASS              */      STATE_RENDER(WINED3DRS_STENCILENABLE),              state_unknown       },
 403     { /*189, WINED3DRS_CCW_STENCILFUNC              */      STATE_RENDER(WINED3DRS_STENCILENABLE),              state_unknown       },
 404     { /*190, WINED3DRS_COLORWRITEENABLE1            */      STATE_RENDER(WINED3DRS_COLORWRITEENABLE),           state_unknown       },
 405     { /*191, WINED3DRS_COLORWRITEENABLE2            */      STATE_RENDER(WINED3DRS_COLORWRITEENABLE),           state_unknown       },
 406     { /*192, WINED3DRS_COLORWRITEENABLE3            */      STATE_RENDER(WINED3DRS_COLORWRITEENABLE),           state_unknown       },
 407     { /*193, WINED3DRS_BLENDFACTOR                  */      STATE_RENDER(WINED3DRS_ALPHABLENDENABLE),           state_unknown       },
 408     { /*194, WINED3DRS_SRGBWRITEENABLE              */      0,                                                  state_nogl          },
 409     { /*195, WINED3DRS_DEPTHBIAS                    */      STATE_RENDER(WINED3DRS_DEPTHBIAS),                  state_unknown       },
 410     { /*196, undefined                              */      0,                                                  state_undefined     },
 411     { /*197, undefined                              */      0,                                                  state_undefined     },
 412     { /*198, WINED3DRS_WRAP8                        */      STATE_RENDER(WINED3DRS_WRAP0),                      state_unknown       },
 413     { /*199, WINED3DRS_WRAP9                        */      STATE_RENDER(WINED3DRS_WRAP0),                      state_unknown       },
 414     { /*200, WINED3DRS_WRAP10                       */      STATE_RENDER(WINED3DRS_WRAP0),                      state_unknown       },
 415     { /*201, WINED3DRS_WRAP11                       */      STATE_RENDER(WINED3DRS_WRAP0),                      state_unknown       },
 416     { /*202, WINED3DRS_WRAP12                       */      STATE_RENDER(WINED3DRS_WRAP0),                      state_unknown       },
 417     { /*203, WINED3DRS_WRAP13                       */      STATE_RENDER(WINED3DRS_WRAP0),                      state_unknown       },
 418     { /*204, WINED3DRS_WRAP14                       */      STATE_RENDER(WINED3DRS_WRAP0),                      state_unknown       },
 419     { /*205, WINED3DRS_WRAP15                       */      STATE_RENDER(WINED3DRS_WRAP0),                      state_unknown       },
 420     { /*206, WINED3DRS_SEPARATEALPHABLENDENABLE     */      STATE_RENDER(WINED3DRS_SEPARATEALPHABLENDENABLE),   state_unknown       },
 421     { /*207, WINED3DRS_SRCBLENDALPHA                */      STATE_RENDER(WINED3DRS_SEPARATEALPHABLENDENABLE),   state_unknown       },
 422     { /*208, WINED3DRS_DESTBLENDALPHA               */      STATE_RENDER(WINED3DRS_SEPARATEALPHABLENDENABLE),   state_unknown       },
 423     { /*209, WINED3DRS_BLENDOPALPHA                 */      STATE_RENDER(WINED3DRS_SEPARATEALPHABLENDENABLE),   state_unknown       },
 424 };