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_nogl(DWORD state, IWineD3DStateBlockImpl *stateblock) {
  33     /* Used for states which are not mapped to a gl state as-is, but used somehow different,
  34      * e.g as a parameter for drawing, or which are unimplemented in windows d3d
  35      */
  36     if(STATE_IS_RENDER(state)) {
  37         WINED3DRENDERSTATETYPE RenderState = state - STATE_RENDER(0);
  38         TRACE("(%s,%d) no direct mapping to gl\n", debug_d3drenderstate(RenderState), stateblock->renderState[RenderState]);
  39     } else {
  40         /* Shouldn't have an unknown type here */
  41         FIXME("%d no direct mapping to gl of state with unknown type\n", state);
  42     }
  43 }
  44
  45 static void state_undefined(DWORD state, IWineD3DStateBlockImpl *stateblock) {
  46     /* Print a WARN, this allows the stateblock code to loop over all states to generate a display
  47      * list without causing confusing terminal output. Deliberately no special debug name here
  48      * because its undefined.
  49      */
  50     WARN("undefined state %d\n", state);
  51 }
  52
  53 static void state_fillmode(DWORD state, IWineD3DStateBlockImpl *stateblock) {
  54     D3DFILLMODE Value = stateblock->renderState[WINED3DRS_FILLMODE];
  55
  56     switch(Value) {
  57         case D3DFILL_POINT:
  58             glPolygonMode(GL_FRONT_AND_BACK, GL_POINT);
  59             checkGLcall("glPolygonMode(GL_FRONT_AND_BACK, GL_POINT)");
  60             break;
  61         case D3DFILL_WIREFRAME:
  62             glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
  63             checkGLcall("glPolygonMode(GL_FRONT_AND_BACK, GL_LINE)");
  64             break;
  65         case D3DFILL_SOLID:
  66             glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
  67             checkGLcall("glPolygonMode(GL_FRONT_AND_BACK, GL_FILL)");
  68             break;
  69         default:
  70             FIXME("Unrecognized WINED3DRS_FILLMODE value %d\n", Value);
  71     }
  72 }
  73
  74 static void state_lighting(DWORD state, IWineD3DStateBlockImpl *stateblock) {
  75     BOOL normals;
  76
  77     /* Lighting is only enabled if Vertex normals are passed by the application,
  78      * but lighting does not affect the stream sources, so it is not grouped for performance reasons.
  79      * This state reads the decoded vertex decl, so if it is dirty don't do anything. The
  80      * vertex declaration appplying function calls this function for updating
  81      */
  82
  83         if(isStateDirty(stateblock->wineD3DDevice, STATE_VDECL)) {
  84                 return;
  85         }
  86
  87     normals = stateblock->wineD3DDevice->strided_streams.u.s.normal.lpData != NULL ||
  88               stateblock->wineD3DDevice->strided_streams.u.s.normal.VBO != 0;
  89
  90     if (stateblock->renderState[WINED3DRS_LIGHTING] && normals) {
  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
 222     /* GL_LINE_SMOOTH needs GL_BLEND to work, according to the red book, and special blending params */
 223     if (stateblock->renderState[WINED3DRS_ALPHABLENDENABLE]      ||
 224         stateblock->renderState[WINED3DRS_EDGEANTIALIAS]         ||
 225         stateblock->renderState[WINED3DRS_ANTIALIASEDLINEENABLE]) {
 226         glEnable(GL_BLEND);
 227         checkGLcall("glEnable GL_BLEND");
 228     } else {
 229         glDisable(GL_BLEND);
 230         checkGLcall("glDisable GL_BLEND");
 231         /* Nothing more to do - get out */
 232         return;
 233     };
 234
 235     switch (stateblock->renderState[WINED3DRS_SRCBLEND]) {
 236         case WINED3DBLEND_ZERO               : srcBlend = GL_ZERO;  break;
 237         case WINED3DBLEND_ONE                : srcBlend = GL_ONE;  break;
 238         case WINED3DBLEND_SRCCOLOR           : srcBlend = GL_SRC_COLOR;  break;
 239         case WINED3DBLEND_INVSRCCOLOR        : srcBlend = GL_ONE_MINUS_SRC_COLOR;  break;
 240         case WINED3DBLEND_SRCALPHA           : srcBlend = GL_SRC_ALPHA;  break;
 241         case WINED3DBLEND_INVSRCALPHA        : srcBlend = GL_ONE_MINUS_SRC_ALPHA;  break;
 242         case WINED3DBLEND_DESTALPHA          : srcBlend = GL_DST_ALPHA;  break;
 243         case WINED3DBLEND_INVDESTALPHA       : srcBlend = GL_ONE_MINUS_DST_ALPHA;  break;
 244         case WINED3DBLEND_DESTCOLOR          : srcBlend = GL_DST_COLOR;  break;
 245         case WINED3DBLEND_INVDESTCOLOR       : srcBlend = GL_ONE_MINUS_DST_COLOR;  break;
 246         case WINED3DBLEND_SRCALPHASAT        : srcBlend = GL_SRC_ALPHA_SATURATE;  break;
 247
 248         case WINED3DBLEND_BOTHSRCALPHA       : srcBlend = GL_SRC_ALPHA;
 249             dstBlend = GL_SRC_ALPHA;
 250             break;
 251
 252         case WINED3DBLEND_BOTHINVSRCALPHA    : srcBlend = GL_ONE_MINUS_SRC_ALPHA;
 253             dstBlend = GL_ONE_MINUS_SRC_ALPHA;
 254             break;
 255
 256         case WINED3DBLEND_BLENDFACTOR        : srcBlend = GL_CONSTANT_COLOR;   break;
 257         case WINED3DBLEND_INVBLENDFACTOR     : srcBlend = GL_ONE_MINUS_CONSTANT_COLOR;  break;
 258         default:
 259             FIXME("Unrecognized src blend value %d\n", stateblock->renderState[WINED3DRS_SRCBLEND]);
 260     }
 261
 262     switch (stateblock->renderState[WINED3DRS_DESTBLEND]) {
 263         case WINED3DBLEND_ZERO               : dstBlend = GL_ZERO;  break;
 264         case WINED3DBLEND_ONE                : dstBlend = GL_ONE;  break;
 265         case WINED3DBLEND_SRCCOLOR           : dstBlend = GL_SRC_COLOR;  break;
 266         case WINED3DBLEND_INVSRCCOLOR        : dstBlend = GL_ONE_MINUS_SRC_COLOR;  break;
 267         case WINED3DBLEND_SRCALPHA           : dstBlend = GL_SRC_ALPHA;  break;
 268         case WINED3DBLEND_INVSRCALPHA        : dstBlend = GL_ONE_MINUS_SRC_ALPHA;  break;
 269         case WINED3DBLEND_DESTALPHA          : dstBlend = GL_DST_ALPHA;  break;
 270         case WINED3DBLEND_INVDESTALPHA       : dstBlend = GL_ONE_MINUS_DST_ALPHA;  break;
 271         case WINED3DBLEND_DESTCOLOR          : dstBlend = GL_DST_COLOR;  break;
 272         case WINED3DBLEND_INVDESTCOLOR       : dstBlend = GL_ONE_MINUS_DST_COLOR;  break;
 273         case WINED3DBLEND_SRCALPHASAT        : dstBlend = GL_SRC_ALPHA_SATURATE;  break;
 274
 275         case WINED3DBLEND_BOTHSRCALPHA       : dstBlend = GL_SRC_ALPHA;
 276             srcBlend = GL_SRC_ALPHA;
 277             break;
 278
 279         case WINED3DBLEND_BOTHINVSRCALPHA    : dstBlend = GL_ONE_MINUS_SRC_ALPHA;
 280             srcBlend = GL_ONE_MINUS_SRC_ALPHA;
 281             break;
 282
 283         case D3DBLEND_BLENDFACTOR        : dstBlend = GL_CONSTANT_COLOR;   break;
 284         case D3DBLEND_INVBLENDFACTOR     : dstBlend = GL_ONE_MINUS_CONSTANT_COLOR;  break;
 285         default:
 286             FIXME("Unrecognized dst blend value %d\n", stateblock->renderState[WINED3DRS_DESTBLEND]);
 287     }
 288
 289     if(stateblock->renderState[WINED3DRS_EDGEANTIALIAS] ||
 290        stateblock->renderState[WINED3DRS_ANTIALIASEDLINEENABLE]) {
 291         glEnable(GL_LINE_SMOOTH);
 292         checkGLcall("glEnable(GL_LINE_SMOOTH)");
 293         if(srcBlend != GL_SRC_ALPHA) {
 294             FIXME("WINED3DRS_EDGEANTIALIAS enabled, but incompatible src blending param - what to do?\n");
 295             srcBlend = GL_SRC_ALPHA;
 296         }
 297         if(dstBlend != GL_ONE_MINUS_SRC_ALPHA) {
 298             FIXME("WINED3DRS_EDGEANTIALIAS enabled, but incompatible dst blending param - what to do?\n");
 299             dstBlend = GL_ONE_MINUS_SRC_ALPHA;
 300         }
 301     } else {
 302         glDisable(GL_LINE_SMOOTH);
 303         checkGLcall("glDisable(GL_LINE_SMOOTH)");
 304     }
 305
 306     TRACE("glBlendFunc src=%x, dst=%x\n", srcBlend, dstBlend);
 307     glBlendFunc(srcBlend, dstBlend);
 308     checkGLcall("glBlendFunc");
 309
 310     /* TODO: Remove when state management done */
 311     stateblock->wineD3DDevice->dstBlend = dstBlend;
 312     stateblock->wineD3DDevice->srcBlend = srcBlend;
 313 }
 314
 315 static void state_blendfactor(DWORD state, IWineD3DStateBlockImpl *stateblock) {
 316     float col[4];
 317
 318     TRACE("Setting BlendFactor to %d\n", stateblock->renderState[WINED3DRS_BLENDFACTOR]);
 319     D3DCOLORTOGLFLOAT4(stateblock->renderState[WINED3DRS_BLENDFACTOR], col);
 320     glBlendColor (col[0],col[1],col[2],col[3]);
 321     checkGLcall("glBlendColor");
 322 }
 323
 324 static void state_alpha(DWORD state, IWineD3DStateBlockImpl *stateblock) {
 325     int glParm = 0;
 326     float ref;
 327     BOOL enable_ckey = FALSE;
 328
 329     IWineD3DSurfaceImpl *surf;
 330
 331     /* Find out if the texture on the first stage has a ckey set
 332      * The alpha state func reads the texture settings, even though alpha and texture are not grouped
 333      * together. This is to avoid making a huge alpha+texture+texture stage+ckey block due to the hardly
 334      * used WINED3DRS_COLORKEYENABLE state(which is d3d <= 3 only). The texture function will call alpha
 335      * in case it finds some texture+colorkeyenable combination which needs extra care.
 336      */
 337     if(stateblock->textures[0]) {
 338         surf = (IWineD3DSurfaceImpl *) ((IWineD3DTextureImpl *)stateblock->textures[0])->surfaces[0];
 339         if(surf->CKeyFlags & DDSD_CKSRCBLT) enable_ckey = TRUE;
 340     }
 341
 342     if (stateblock->renderState[WINED3DRS_ALPHATESTENABLE] ||
 343         (stateblock->renderState[WINED3DRS_COLORKEYENABLE] && enable_ckey)) {
 344         glEnable(GL_ALPHA_TEST);
 345         checkGLcall("glEnable GL_ALPHA_TEST");
 346     } else {
 347         glDisable(GL_ALPHA_TEST);
 348         checkGLcall("glDisable GL_ALPHA_TEST");
 349         /* Alpha test is disabled, don't bother setting the params - it will happen on the next
 350          * enable call
 351          */
 352         return;
 353     }
 354
 355     if(stateblock->renderState[WINED3DRS_COLORKEYENABLE] && enable_ckey) {
 356         glParm = GL_NOTEQUAL;
 357         ref = 0.0;
 358     } else {
 359         ref = ((float) stateblock->renderState[WINED3DRS_ALPHAREF]) / 255.0f;
 360         glParm = CompareFunc(stateblock->renderState[WINED3DRS_ALPHAFUNC]);
 361     }
 362     if(glParm) {
 363         stateblock->wineD3DDevice->alphafunc = glParm; /* Remove when state management done */
 364         glAlphaFunc(glParm, ref);
 365         checkGLcall("glAlphaFunc");
 366     }
 367     /* TODO: Some texture blending operations seem to affect the alpha test */
 368 }
 369
 370 static void state_clipping(DWORD state, IWineD3DStateBlockImpl *stateblock) {
 371     DWORD enable  = 0xFFFFFFFF;
 372     DWORD disable = 0x00000000;
 373
 374     /* TODO: Keep track of previously enabled clipplanes to avoid unneccessary resetting
 375      * of already set values
 376      */
 377
 378     /* If enabling / disabling all
 379      * TODO: Is this correct? Doesn't D3DRS_CLIPPING disable clipping on the viewport frustrum?
 380      */
 381     if (stateblock->renderState[WINED3DRS_CLIPPING]) {
 382         enable  = stateblock->renderState[WINED3DRS_CLIPPLANEENABLE];
 383         disable = ~stateblock->renderState[WINED3DRS_CLIPPLANEENABLE];
 384     } else {
 385         disable = 0xffffffff;
 386         enable  = 0x00;
 387     }
 388
 389     if (enable & WINED3DCLIPPLANE0)  { glEnable(GL_CLIP_PLANE0);  checkGLcall("glEnable(clip plane 0)"); }
 390     if (enable & WINED3DCLIPPLANE1)  { glEnable(GL_CLIP_PLANE1);  checkGLcall("glEnable(clip plane 1)"); }
 391     if (enable & WINED3DCLIPPLANE2)  { glEnable(GL_CLIP_PLANE2);  checkGLcall("glEnable(clip plane 2)"); }
 392     if (enable & WINED3DCLIPPLANE3)  { glEnable(GL_CLIP_PLANE3);  checkGLcall("glEnable(clip plane 3)"); }
 393     if (enable & WINED3DCLIPPLANE4)  { glEnable(GL_CLIP_PLANE4);  checkGLcall("glEnable(clip plane 4)"); }
 394     if (enable & WINED3DCLIPPLANE5)  { glEnable(GL_CLIP_PLANE5);  checkGLcall("glEnable(clip plane 5)"); }
 395
 396     if (disable & WINED3DCLIPPLANE0) { glDisable(GL_CLIP_PLANE0); checkGLcall("glDisable(clip plane 0)"); }
 397     if (disable & WINED3DCLIPPLANE1) { glDisable(GL_CLIP_PLANE1); checkGLcall("glDisable(clip plane 1)"); }
 398     if (disable & WINED3DCLIPPLANE2) { glDisable(GL_CLIP_PLANE2); checkGLcall("glDisable(clip plane 2)"); }
 399     if (disable & WINED3DCLIPPLANE3) { glDisable(GL_CLIP_PLANE3); checkGLcall("glDisable(clip plane 3)"); }
 400     if (disable & WINED3DCLIPPLANE4) { glDisable(GL_CLIP_PLANE4); checkGLcall("glDisable(clip plane 4)"); }
 401     if (disable & WINED3DCLIPPLANE5) { glDisable(GL_CLIP_PLANE5); checkGLcall("glDisable(clip plane 5)"); }
 402
 403     /** update clipping status */
 404     if (enable) {
 405         stateblock->clip_status.ClipUnion = 0;
 406         stateblock->clip_status.ClipIntersection = 0xFFFFFFFF;
 407     } else {
 408         stateblock->clip_status.ClipUnion = 0;
 409         stateblock->clip_status.ClipIntersection = 0;
 410     }
 411 }
 412
 413 static void state_blendop(DWORD state, IWineD3DStateBlockImpl *stateblock) {
 414     int glParm = GL_FUNC_ADD;
 415
 416     if(!GL_SUPPORT(EXT_BLEND_MINMAX)) {
 417         WARN("Unsupported in local OpenGL implementation: glBlendEquation\n");
 418         return;
 419     }
 420
 421     switch ((WINED3DBLENDOP) stateblock->renderState[WINED3DRS_BLENDOP]) {
 422         case WINED3DBLENDOP_ADD              : glParm = GL_FUNC_ADD;              break;
 423         case WINED3DBLENDOP_SUBTRACT         : glParm = GL_FUNC_SUBTRACT;         break;
 424         case WINED3DBLENDOP_REVSUBTRACT      : glParm = GL_FUNC_REVERSE_SUBTRACT; break;
 425         case WINED3DBLENDOP_MIN              : glParm = GL_MIN;                   break;
 426         case WINED3DBLENDOP_MAX              : glParm = GL_MAX;                   break;
 427         default:
 428             FIXME("Unrecognized/Unhandled D3DBLENDOP value %d\n", stateblock->renderState[WINED3DRS_BLENDOP]);
 429     }
 430
 431     TRACE("glBlendEquation(%x)\n", glParm);
 432     GL_EXTCALL(glBlendEquation(glParm));
 433     checkGLcall("glBlendEquation");
 434 }
 435
 436 static void
 437 state_specularenable(DWORD state, IWineD3DStateBlockImpl *stateblock) {
 438     /* Originally this used glLightModeli(GL_LIGHT_MODEL_COLOR_CONTROL,GL_SEPARATE_SPECULAR_COLOR)
 439      * and (GL_LIGHT_MODEL_COLOR_CONTROL,GL_SINGLE_COLOR) to swap between enabled/disabled
 440      * specular color. This is wrong:
 441      * Separate specular color means the specular colour is maintained separately, whereas
 442      * single color means it is merged in. However in both cases they are being used to
 443      * some extent.
 444      * To disable specular color, set it explicitly to black and turn off GL_COLOR_SUM_EXT
 445      * NOTE: If not supported don't give FIXMEs the impact is really minimal and very few people are
 446      * running 1.4 yet!
 447      *
 448      *
 449      * If register combiners are enabled, enabling / disabling GL_COLOR_SUM has no effect.
 450      * Instead, we need to setup the FinalCombiner properly.
 451      *
 452      * The default setup for the FinalCombiner is:
 453      *
 454      * <variable>       <input>                             <mapping>               <usage>
 455      * GL_VARIABLE_A_NV GL_FOG,                             GL_UNSIGNED_IDENTITY_NV GL_ALPHA
 456      * GL_VARIABLE_B_NV GL_SPARE0_PLUS_SECONDARY_COLOR_NV   GL_UNSIGNED_IDENTITY_NV GL_RGB
 457      * GL_VARIABLE_C_NV GL_FOG                              GL_UNSIGNED_IDENTITY_NV GL_RGB
 458      * GL_VARIABLE_D_NV GL_ZERO                             GL_UNSIGNED_IDENTITY_NV GL_RGB
 459      * GL_VARIABLE_E_NV GL_ZERO                             GL_UNSIGNED_IDENTITY_NV GL_RGB
 460      * GL_VARIABLE_F_NV GL_ZERO                             GL_UNSIGNED_IDENTITY_NV GL_RGB
 461      * GL_VARIABLE_G_NV GL_SPARE0_NV                        GL_UNSIGNED_IDENTITY_NV GL_ALPHA
 462      *
 463      * That's pretty much fine as it is, except for variable B, which needs to take
 464      * either GL_SPARE0_PLUS_SECONDARY_COLOR_NV or GL_SPARE0_NV, depending on
 465      * whether WINED3DRS_SPECULARENABLE is enabled or not.
 466      */
 467
 468     TRACE("Setting specular enable state\n");
 469     /* TODO: Add to the material setting functions */
 470     if (stateblock->renderState[WINED3DRS_SPECULARENABLE]) {
 471         glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, (float*) &stateblock->material.Specular);
 472         checkGLcall("glMaterialfv");
 473         if (GL_SUPPORT(EXT_SECONDARY_COLOR)) {
 474             glEnable(GL_COLOR_SUM_EXT);
 475         } else {
 476             TRACE("Specular colors cannot be enabled in this version of opengl\n");
 477         }
 478         checkGLcall("glEnable(GL_COLOR_SUM)");
 479
 480         if (GL_SUPPORT(NV_REGISTER_COMBINERS)) {
 481             GL_EXTCALL(glFinalCombinerInputNV(GL_VARIABLE_B_NV, GL_SPARE0_PLUS_SECONDARY_COLOR_NV, GL_UNSIGNED_IDENTITY_NV, GL_RGB));
 482             checkGLcall("glFinalCombinerInputNV()");
 483         }
 484     } else {
 485         float black[4] = {0.0f, 0.0f, 0.0f, 0.0f};
 486
 487         /* for the case of enabled lighting: */
 488         glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, &black[0]);
 489         checkGLcall("glMaterialfv");
 490
 491         /* for the case of disabled lighting: */
 492         if (GL_SUPPORT(EXT_SECONDARY_COLOR)) {
 493             glDisable(GL_COLOR_SUM_EXT);
 494         } else {
 495             TRACE("Specular colors cannot be disabled in this version of opengl\n");
 496         }
 497         checkGLcall("glDisable(GL_COLOR_SUM)");
 498
 499         if (GL_SUPPORT(NV_REGISTER_COMBINERS)) {
 500             GL_EXTCALL(glFinalCombinerInputNV(GL_VARIABLE_B_NV, GL_SPARE0_NV, GL_UNSIGNED_IDENTITY_NV, GL_RGB));
 501             checkGLcall("glFinalCombinerInputNV()");
 502         }
 503     }
 504 }
 505
 506 static void state_texfactor(DWORD state, IWineD3DStateBlockImpl *stateblock) {
 507     unsigned int i;
 508
 509     /* Note the texture color applies to all textures whereas
 510      * GL_TEXTURE_ENV_COLOR applies to active only
 511      */
 512     float col[4];
 513     D3DCOLORTOGLFLOAT4(stateblock->renderState[WINED3DRS_TEXTUREFACTOR], col);
 514
 515     if (!GL_SUPPORT(NV_REGISTER_COMBINERS)) {
 516         /* And now the default texture color as well */
 517         for (i = 0; i < GL_LIMITS(texture_stages); i++) {
 518             /* Note the WINED3DRS value applies to all textures, but GL has one
 519              * per texture, so apply it now ready to be used!
 520              */
 521             if (GL_SUPPORT(ARB_MULTITEXTURE)) {
 522                 GL_EXTCALL(glActiveTextureARB(GL_TEXTURE0_ARB + i));
 523                 checkGLcall("glActiveTextureARB");
 524             } else if (i>0) {
 525                 FIXME("Program using multiple concurrent textures which this opengl implementation doesn't support\n");
 526             }
 527
 528             glTexEnvfv(GL_TEXTURE_ENV, GL_TEXTURE_ENV_COLOR, &col[0]);
 529             checkGLcall("glTexEnvfv(GL_TEXTURE_ENV, GL_TEXTURE_ENV_COLOR, color);");
 530         }
 531     } else {
 532         GL_EXTCALL(glCombinerParameterfvNV(GL_CONSTANT_COLOR0_NV, &col[0]));
 533     }
 534 }
 535
 536 static void
 537 renderstate_stencil_twosided(IWineD3DStateBlockImpl *stateblock, GLint face, GLint func, GLint ref, GLuint mask, GLint stencilFail, GLint depthFail, GLint stencilPass ) {
 538 #if 0 /* Don't use OpenGL 2.0 calls for now */
 539             if(GL_EXTCALL(glStencilFuncSeparate) && GL_EXTCALL(glStencilOpSeparate)) {
 540                 GL_EXTCALL(glStencilFuncSeparate(face, func, ref, mask));
 541                 checkGLcall("glStencilFuncSeparate(...)");
 542                 GL_EXTCALL(glStencilOpSeparate(face, stencilFail, depthFail, stencilPass));
 543                 checkGLcall("glStencilOpSeparate(...)");
 544         }
 545             else
 546 #endif
 547     if(GL_SUPPORT(EXT_STENCIL_TWO_SIDE)) {
 548         glEnable(GL_STENCIL_TEST_TWO_SIDE_EXT);
 549         checkGLcall("glEnable(GL_STENCIL_TEST_TWO_SIDE_EXT)");
 550         GL_EXTCALL(glActiveStencilFaceEXT(face));
 551         checkGLcall("glActiveStencilFaceEXT(...)");
 552         glStencilFunc(func, ref, mask);
 553         checkGLcall("glStencilFunc(...)");
 554         glStencilOp(stencilFail, depthFail, stencilPass);
 555         checkGLcall("glStencilOp(...)");
 556     } else if(GL_SUPPORT(ATI_SEPARATE_STENCIL)) {
 557         GL_EXTCALL(glStencilFuncSeparateATI(face, func, ref, mask));
 558         checkGLcall("glStencilFuncSeparateATI(...)");
 559         GL_EXTCALL(glStencilOpSeparateATI(face, stencilFail, depthFail, stencilPass));
 560         checkGLcall("glStencilOpSeparateATI(...)");
 561     } else {
 562         ERR("Separate (two sided) stencil not supported on this version of opengl. Caps weren't honored?\n");
 563     }
 564 }
 565
 566 static void
 567 state_stencil(DWORD state, IWineD3DStateBlockImpl *stateblock) {
 568     DWORD onesided_enable = FALSE;
 569     DWORD twosided_enable = FALSE;
 570     GLint func = GL_ALWAYS;
 571     GLint func_ccw = GL_ALWAYS;
 572     GLint ref = 0;
 573     GLuint mask = 0;
 574     GLint stencilFail = GL_KEEP;
 575     GLint depthFail = GL_KEEP;
 576     GLint stencilPass = GL_KEEP;
 577     GLint stencilFail_ccw = GL_KEEP;
 578     GLint depthFail_ccw = GL_KEEP;
 579     GLint stencilPass_ccw = GL_KEEP;
 580
 581     if( stateblock->set.renderState[WINED3DRS_STENCILENABLE] )
 582         onesided_enable = stateblock->renderState[WINED3DRS_STENCILENABLE];
 583     if( stateblock->set.renderState[WINED3DRS_TWOSIDEDSTENCILMODE] )
 584         twosided_enable = stateblock->renderState[WINED3DRS_TWOSIDEDSTENCILMODE];
 585     if( stateblock->set.renderState[WINED3DRS_STENCILFUNC] )
 586         if( !( func = CompareFunc(stateblock->renderState[WINED3DRS_STENCILFUNC]) ) )
 587             func = GL_ALWAYS;
 588     if( stateblock->set.renderState[WINED3DRS_CCW_STENCILFUNC] )
 589         if( !( func_ccw = CompareFunc(stateblock->renderState[WINED3DRS_CCW_STENCILFUNC]) ) )
 590             func = GL_ALWAYS;
 591     if( stateblock->set.renderState[WINED3DRS_STENCILREF] )
 592         ref = stateblock->renderState[WINED3DRS_STENCILREF];
 593     if( stateblock->set.renderState[WINED3DRS_STENCILMASK] )
 594         mask = stateblock->renderState[WINED3DRS_STENCILMASK];
 595     if( stateblock->set.renderState[WINED3DRS_STENCILFAIL] )
 596         stencilFail = StencilOp(stateblock->renderState[WINED3DRS_STENCILFAIL]);
 597     if( stateblock->set.renderState[WINED3DRS_STENCILZFAIL] )
 598         depthFail = StencilOp(stateblock->renderState[WINED3DRS_STENCILZFAIL]);
 599     if( stateblock->set.renderState[WINED3DRS_STENCILPASS] )
 600         stencilPass = StencilOp(stateblock->renderState[WINED3DRS_STENCILPASS]);
 601     if( stateblock->set.renderState[WINED3DRS_CCW_STENCILFAIL] )
 602         stencilFail_ccw = StencilOp(stateblock->renderState[WINED3DRS_CCW_STENCILFAIL]);
 603     if( stateblock->set.renderState[WINED3DRS_CCW_STENCILZFAIL] )
 604         depthFail_ccw = StencilOp(stateblock->renderState[WINED3DRS_CCW_STENCILZFAIL]);
 605     if( stateblock->set.renderState[WINED3DRS_CCW_STENCILPASS] )
 606         stencilPass_ccw = StencilOp(stateblock->renderState[WINED3DRS_CCW_STENCILPASS]);
 607
 608     TRACE("(onesided %d, twosided %d, ref %x, mask %x,  \
 609             GL_FRONT: func: %x, fail %x, zfail %x, zpass %x  \
 610             GL_BACK: func: %x, fail %x, zfail %x, zpass %x )\n",
 611     onesided_enable, twosided_enable, ref, mask,
 612     func, stencilFail, depthFail, stencilPass,
 613     func_ccw, stencilFail_ccw, depthFail_ccw, stencilPass_ccw);
 614
 615     if (twosided_enable) {
 616         renderstate_stencil_twosided(stateblock, GL_FRONT, func, ref, mask, stencilFail, depthFail, stencilPass);
 617         renderstate_stencil_twosided(stateblock, GL_BACK, func_ccw, ref, mask, stencilFail_ccw, depthFail_ccw, stencilPass_ccw);
 618     } else {
 619         if (onesided_enable) {
 620             glEnable(GL_STENCIL_TEST);
 621             checkGLcall("glEnable GL_STENCIL_TEST");
 622             glStencilFunc(func, ref, mask);
 623             checkGLcall("glStencilFunc(...)");
 624             glStencilOp(stencilFail, depthFail, stencilPass);
 625             checkGLcall("glStencilOp(...)");
 626         } else {
 627             glDisable(GL_STENCIL_TEST);
 628             checkGLcall("glDisable GL_STENCIL_TEST");
 629         }
 630     }
 631 }
 632
 633 static void state_stencilwrite(DWORD state, IWineD3DStateBlockImpl *stateblock) {
 634     glStencilMask(stateblock->renderState[WINED3DRS_STENCILWRITEMASK]);
 635     checkGLcall("glStencilMask");
 636 }
 637
 638 static void state_fog(DWORD state, IWineD3DStateBlockImpl *stateblock) {
 639     /* TODO: Put this into the vertex type block once that is in the state table */
 640     BOOL fogenable = stateblock->renderState[WINED3DRS_FOGENABLE];
 641     float fogstart, fogend;
 642
 643     union {
 644         DWORD d;
 645         float f;
 646     } tmpvalue;
 647
 648     if (!fogenable) {
 649         /* No fog? Disable it, and we're done :-) */
 650         glDisable(GL_FOG);
 651         checkGLcall("glDisable GL_FOG");
 652     }
 653
 654     tmpvalue.d = stateblock->renderState[WINED3DRS_FOGSTART];
 655     fogstart = tmpvalue.f;
 656     tmpvalue.d = stateblock->renderState[WINED3DRS_FOGEND];
 657     fogend = tmpvalue.f;
 658
 659     /* Activate when vertex shaders are in the state table */
 660     if(stateblock->vertexShader && ((IWineD3DVertexShaderImpl *)stateblock->vertexShader)->baseShader.function &&
 661        ((IWineD3DVertexShaderImpl *)stateblock->vertexShader)->usesFog) {
 662         glFogi(GL_FOG_MODE, GL_LINEAR);
 663         checkGLcall("glFogi(GL_FOG_MODE, GL_LINEAR)");
 664         fogstart = 1.0;
 665         fogend = 0.0;
 666         stateblock->wineD3DDevice->last_was_foggy_shader = TRUE;
 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         stateblock->wineD3DDevice->last_was_foggy_shader = FALSE;
 675
 676         switch (stateblock->renderState[WINED3DRS_FOGVERTEXMODE]) {
 677             /* Processed vertices have their fog factor stored in the specular value. Fall too the none case.
 678              * If we are drawing untransformed vertices atm, d3ddevice_set_ortho will update the fog
 679              */
 680             case D3DFOG_EXP:  {
 681                 if(!stateblock->wineD3DDevice->last_was_rhw) {
 682                     glFogi(GL_FOG_MODE, GL_EXP);
 683                     checkGLcall("glFogi(GL_FOG_MODE, GL_EXP");
 684                     if(GL_SUPPORT(EXT_FOG_COORD)) {
 685                         glFogi(GL_FOG_COORDINATE_SOURCE_EXT, GL_FRAGMENT_DEPTH_EXT);
 686                         checkGLcall("glFogi(GL_FOG_COORDINATE_SOURCE_EXT, GL_FRAGMENT_DEPTH_EXT");
 687                     }
 688                     break;
 689                 }
 690             }
 691             case D3DFOG_EXP2: {
 692                 if(!stateblock->wineD3DDevice->last_was_rhw) {
 693                     glFogi(GL_FOG_MODE, GL_EXP2);
 694                     checkGLcall("glFogi(GL_FOG_MODE, GL_EXP2");
 695                     if(GL_SUPPORT(EXT_FOG_COORD)) {
 696                         glFogi(GL_FOG_COORDINATE_SOURCE_EXT, GL_FRAGMENT_DEPTH_EXT);
 697                         checkGLcall("glFogi(GL_FOG_COORDINATE_SOURCE_EXT, GL_FRAGMENT_DEPTH_EXT");
 698                     }
 699                     break;
 700                 }
 701             }
 702             case D3DFOG_LINEAR: {
 703                 if(!stateblock->wineD3DDevice->last_was_rhw) {
 704                     glFogi(GL_FOG_MODE, GL_LINEAR);
 705                     checkGLcall("glFogi(GL_FOG_MODE, GL_LINEAR");
 706                     if(GL_SUPPORT(EXT_FOG_COORD)) {
 707                         glFogi(GL_FOG_COORDINATE_SOURCE_EXT, GL_FRAGMENT_DEPTH_EXT);
 708                         checkGLcall("glFogi(GL_FOG_COORDINATE_SOURCE_EXT, GL_FRAGMENT_DEPTH_EXT");
 709                     }
 710                     break;
 711                 }
 712             }
 713             case D3DFOG_NONE: {
 714                 /* Both are none? According to msdn the alpha channel of the specular
 715                  * color contains a fog factor. Set it in drawStridedSlow.
 716                  * Same happens with Vertexfog on transformed vertices
 717                  */
 718                 if(GL_SUPPORT(EXT_FOG_COORD)) {
 719                     glFogi(GL_FOG_COORDINATE_SOURCE_EXT, GL_FOG_COORDINATE_EXT);
 720                     checkGLcall("glFogi(GL_FOG_COORDINATE_SOURCE_EXT, GL_FOG_COORDINATE_EXT)\n");
 721                     glFogi(GL_FOG_MODE, GL_LINEAR);
 722                     checkGLcall("glFogi(GL_FOG_MODE, GL_LINEAR)");
 723                     fogstart = 0xff;
 724                     fogend = 0x0;
 725                 } else {
 726                     /* Disable GL fog, handle this in software in drawStridedSlow */
 727                     fogenable = FALSE;
 728                 }
 729                 break;
 730             }
 731             default: FIXME("Unexpected WINED3DRS_FOGVERTEXMODE %d\n", stateblock->renderState[WINED3DRS_FOGVERTEXMODE]);
 732         }
 733     } else {
 734         glHint(GL_FOG_HINT, GL_NICEST);
 735         checkGLcall("glHint(GL_FOG_HINT, GL_NICEST)");
 736         stateblock->wineD3DDevice->last_was_foggy_shader = FALSE;
 737
 738         switch (stateblock->renderState[WINED3DRS_FOGTABLEMODE]) {
 739             case D3DFOG_EXP:
 740                 glFogi(GL_FOG_MODE, GL_EXP);
 741                 checkGLcall("glFogi(GL_FOG_MODE, GL_EXP");
 742                 if(GL_SUPPORT(EXT_FOG_COORD)) {
 743                     glFogi(GL_FOG_COORDINATE_SOURCE_EXT, GL_FRAGMENT_DEPTH_EXT);
 744                     checkGLcall("glFogi(GL_FOG_COORDINATE_SOURCE_EXT, GL_FRAGMENT_DEPTH_EXT");
 745                 }
 746                 break;
 747
 748             case D3DFOG_EXP2:
 749                 glFogi(GL_FOG_MODE, GL_EXP2);
 750                 checkGLcall("glFogi(GL_FOG_MODE, GL_EXP2");
 751                 if(GL_SUPPORT(EXT_FOG_COORD)) {
 752                     glFogi(GL_FOG_COORDINATE_SOURCE_EXT, GL_FRAGMENT_DEPTH_EXT);
 753                     checkGLcall("glFogi(GL_FOG_COORDINATE_SOURCE_EXT, GL_FRAGMENT_DEPTH_EXT");
 754                 }
 755                 break;
 756
 757             case D3DFOG_LINEAR:
 758                 glFogi(GL_FOG_MODE, GL_LINEAR);
 759                 checkGLcall("glFogi(GL_FOG_MODE, GL_LINEAR");
 760                 if(GL_SUPPORT(EXT_FOG_COORD)) {
 761                     glFogi(GL_FOG_COORDINATE_SOURCE_EXT, GL_FRAGMENT_DEPTH_EXT);
 762                     checkGLcall("glFogi(GL_FOG_COORDINATE_SOURCE_EXT, GL_FRAGMENT_DEPTH_EXT");
 763                 }
 764                 break;
 765
 766             case D3DFOG_NONE:   /* Won't happen */
 767             default:
 768                 FIXME("Unexpected WINED3DRS_FOGTABLEMODE %d\n", stateblock->renderState[WINED3DRS_FOGTABLEMODE]);
 769         }
 770     }
 771
 772     if(fogenable) {
 773         glEnable(GL_FOG);
 774         checkGLcall("glEnable GL_FOG");
 775
 776         glFogfv(GL_FOG_START, &fogstart);
 777         checkGLcall("glFogf(GL_FOG_START, fogstart");
 778         TRACE("Fog Start == %f\n", fogstart);
 779
 780         glFogfv(GL_FOG_END, &fogend);
 781         checkGLcall("glFogf(GL_FOG_END, fogend");
 782         TRACE("Fog End == %f\n", fogend);
 783     } else {
 784         glDisable(GL_FOG);
 785         checkGLcall("glDisable GL_FOG");
 786     }
 787
 788     if (GL_SUPPORT(NV_FOG_DISTANCE)) {
 789         glFogi(GL_FOG_DISTANCE_MODE_NV, GL_EYE_PLANE_ABSOLUTE_NV);
 790     }
 791 }
 792
 793 static void state_fogcolor(DWORD state, IWineD3DStateBlockImpl *stateblock) {
 794     float col[4];
 795     D3DCOLORTOGLFLOAT4(stateblock->renderState[WINED3DRS_FOGCOLOR], col);
 796     /* Set the default alpha blend color */
 797     glFogfv(GL_FOG_COLOR, &col[0]);
 798     checkGLcall("glFog GL_FOG_COLOR");
 799 }
 800
 801 static void state_fogdensity(DWORD state, IWineD3DStateBlockImpl *stateblock) {
 802     union {
 803         DWORD d;
 804         float f;
 805     } tmpvalue;
 806     tmpvalue.d = stateblock->renderState[WINED3DRS_FOGDENSITY];
 807     glFogfv(GL_FOG_DENSITY, &tmpvalue.f);
 808     checkGLcall("glFogf(GL_FOG_DENSITY, (float) Value)");
 809 }
 810
 811 /* TODO: Merge with primitive type + init_materials()!! */
 812 static void state_colormat(DWORD state, IWineD3DStateBlockImpl *stateblock) {
 813     GLenum Parm = GL_AMBIENT_AND_DIFFUSE;
 814
 815     if (stateblock->renderState[WINED3DRS_COLORVERTEX]) {
 816         TRACE("diff %d, amb %d, emis %d, spec %d\n",
 817               stateblock->renderState[WINED3DRS_DIFFUSEMATERIALSOURCE],
 818               stateblock->renderState[WINED3DRS_AMBIENTMATERIALSOURCE],
 819               stateblock->renderState[WINED3DRS_EMISSIVEMATERIALSOURCE],
 820               stateblock->renderState[WINED3DRS_SPECULARMATERIALSOURCE]);
 821
 822         if (stateblock->renderState[WINED3DRS_DIFFUSEMATERIALSOURCE] == D3DMCS_COLOR1) {
 823             if (stateblock->renderState[WINED3DRS_AMBIENTMATERIALSOURCE] == D3DMCS_COLOR1) {
 824                 Parm = GL_AMBIENT_AND_DIFFUSE;
 825             } else {
 826                 Parm = GL_DIFFUSE;
 827             }
 828         } else if (stateblock->renderState[WINED3DRS_AMBIENTMATERIALSOURCE] == D3DMCS_COLOR1) {
 829             Parm = GL_AMBIENT;
 830         } else if (stateblock->renderState[WINED3DRS_EMISSIVEMATERIALSOURCE] == D3DMCS_COLOR1) {
 831             Parm = GL_EMISSION;
 832         } else if (stateblock->renderState[WINED3DRS_SPECULARMATERIALSOURCE] == D3DMCS_COLOR1) {
 833             Parm = GL_SPECULAR;
 834         } else {
 835             Parm = -1;
 836         }
 837
 838         if (Parm == -1) {
 839             if (stateblock->wineD3DDevice->tracking_color != DISABLED_TRACKING) stateblock->wineD3DDevice->tracking_color = NEEDS_DISABLE;
 840         } else {
 841             stateblock->wineD3DDevice->tracking_color = NEEDS_TRACKING;
 842             stateblock->wineD3DDevice->tracking_parm  = Parm;
 843         }
 844
 845     } else {
 846         if (stateblock->wineD3DDevice->tracking_color != DISABLED_TRACKING) stateblock->wineD3DDevice->tracking_color = NEEDS_DISABLE;
 847     }
 848 }
 849
 850 static void state_linepattern(DWORD state, IWineD3DStateBlockImpl *stateblock) {
 851     union {
 852         DWORD                 d;
 853         WINED3DLINEPATTERN    lp;
 854     } tmppattern;
 855     tmppattern.d = stateblock->renderState[WINED3DRS_LINEPATTERN];
 856
 857     TRACE("Line pattern: repeat %d bits %x\n", tmppattern.lp.wRepeatFactor, tmppattern.lp.wLinePattern);
 858
 859     if (tmppattern.lp.wRepeatFactor) {
 860         glLineStipple(tmppattern.lp.wRepeatFactor, tmppattern.lp.wLinePattern);
 861         checkGLcall("glLineStipple(repeat, linepattern)");
 862         glEnable(GL_LINE_STIPPLE);
 863         checkGLcall("glEnable(GL_LINE_STIPPLE);");
 864     } else {
 865         glDisable(GL_LINE_STIPPLE);
 866         checkGLcall("glDisable(GL_LINE_STIPPLE);");
 867     }
 868 }
 869
 870 static void state_zbias(DWORD state, IWineD3DStateBlockImpl *stateblock) {
 871     union {
 872         DWORD d;
 873         float f;
 874     } tmpvalue;
 875
 876     if (stateblock->renderState[WINED3DRS_ZBIAS]) {
 877         tmpvalue.d = stateblock->renderState[WINED3DRS_ZBIAS];
 878         TRACE("ZBias value %f\n", tmpvalue.f);
 879         glPolygonOffset(0, -tmpvalue.f);
 880         checkGLcall("glPolygonOffset(0, -Value)");
 881         glEnable(GL_POLYGON_OFFSET_FILL);
 882         checkGLcall("glEnable(GL_POLYGON_OFFSET_FILL);");
 883         glEnable(GL_POLYGON_OFFSET_LINE);
 884         checkGLcall("glEnable(GL_POLYGON_OFFSET_LINE);");
 885         glEnable(GL_POLYGON_OFFSET_POINT);
 886         checkGLcall("glEnable(GL_POLYGON_OFFSET_POINT);");
 887     } else {
 888         glDisable(GL_POLYGON_OFFSET_FILL);
 889         checkGLcall("glDisable(GL_POLYGON_OFFSET_FILL);");
 890         glDisable(GL_POLYGON_OFFSET_LINE);
 891         checkGLcall("glDisable(GL_POLYGON_OFFSET_LINE);");
 892         glDisable(GL_POLYGON_OFFSET_POINT);
 893         checkGLcall("glDisable(GL_POLYGON_OFFSET_POINT);");
 894     }
 895 }
 896
 897
 898 static void state_normalize(DWORD state, IWineD3DStateBlockImpl *stateblock) {
 899     if (stateblock->renderState[WINED3DRS_NORMALIZENORMALS]) {
 900         glEnable(GL_NORMALIZE);
 901         checkGLcall("glEnable(GL_NORMALIZE);");
 902     } else {
 903         glDisable(GL_NORMALIZE);
 904         checkGLcall("glDisable(GL_NORMALIZE);");
 905     }
 906 }
 907
 908 static void state_psize(DWORD state, IWineD3DStateBlockImpl *stateblock) {
 909     union {
 910         DWORD d;
 911         float f;
 912     } tmpvalue;
 913
 914     /* FIXME: check that pointSize isn't outside glGetFloatv( GL_POINT_SIZE_MAX_ARB, &maxSize ); or -ve */
 915     tmpvalue.d = stateblock->renderState[WINED3DRS_POINTSIZE];
 916     TRACE("Set point size to %f\n", tmpvalue.f);
 917     glPointSize(tmpvalue.f);
 918     checkGLcall("glPointSize(...);");
 919 }
 920
 921 static void state_psizemin(DWORD state, IWineD3DStateBlockImpl *stateblock) {
 922     union {
 923         DWORD d;
 924         float f;
 925     } tmpvalue;
 926
 927     if(GL_SUPPORT(ARB_POINT_PARAMETERS)) {
 928         tmpvalue.d = stateblock->renderState[WINED3DRS_POINTSIZE_MIN];
 929         GL_EXTCALL(glPointParameterfARB)(GL_POINT_SIZE_MIN_ARB, tmpvalue.f);
 930         checkGLcall("glPointParameterfARB(...");
 931     }
 932     else if(GL_SUPPORT(EXT_POINT_PARAMETERS)) {
 933         tmpvalue.d = stateblock->renderState[WINED3DRS_POINTSIZE_MIN];
 934         GL_EXTCALL(glPointParameterfEXT)(GL_POINT_SIZE_MIN_EXT, tmpvalue.f);
 935         checkGLcall("glPointParameterfEXT(...);");
 936     } else {
 937         FIXME("WINED3DRS_POINTSIZE_MIN not supported on this opengl\n");
 938     }
 939 }
 940
 941 static void state_psizemax(DWORD state, IWineD3DStateBlockImpl *stateblock) {
 942     union {
 943         DWORD d;
 944         float f;
 945     } tmpvalue;
 946
 947     if(GL_SUPPORT(ARB_POINT_PARAMETERS)) {
 948         tmpvalue.d = stateblock->renderState[WINED3DRS_POINTSIZE_MAX];
 949         GL_EXTCALL(glPointParameterfARB)(GL_POINT_SIZE_MAX_ARB, tmpvalue.f);
 950         checkGLcall("glPointParameterfARB(...");
 951     }
 952     else if(GL_SUPPORT(EXT_POINT_PARAMETERS)) {
 953         tmpvalue.d = stateblock->renderState[WINED3DRS_POINTSIZE_MAX];
 954         GL_EXTCALL(glPointParameterfEXT)(GL_POINT_SIZE_MAX_EXT, tmpvalue.f);
 955         checkGLcall("glPointParameterfEXT(...);");
 956     } else {
 957         FIXME("WINED3DRS_POINTSIZE_MAX not supported on this opengl\n");
 958     }
 959 }
 960
 961 static void state_pscale(DWORD state, IWineD3DStateBlockImpl *stateblock) {
 962     /* TODO: Group this with the viewport */
 963     /*
 964      * POINTSCALEENABLE controls how point size value is treated. If set to
 965      * true, the point size is scaled with respect to height of viewport.
 966      * When set to false point size is in pixels.
 967      *
 968      * http://msdn.microsoft.com/library/en-us/directx9_c/point_sprites.asp
 969      */
 970
 971     /* Default values */
 972     GLfloat att[3] = {1.0f, 0.0f, 0.0f};
 973
 974     /*
 975      * Minimum valid point size for OpenGL is 1.0f. For Direct3D it is 0.0f.
 976      * This means that OpenGL will clamp really small point sizes to 1.0f.
 977      * To correct for this we need to multiply by the scale factor when sizes
 978      * are less than 1.0f. scale_factor =  1.0f / point_size.
 979      */
 980     GLfloat pointSize = *((float*)&stateblock->renderState[WINED3DRS_POINTSIZE]);
 981     if(pointSize > 0.0f) {
 982         GLfloat scaleFactor;
 983
 984         if(pointSize < 1.0f) {
 985             scaleFactor = pointSize * pointSize;
 986         } else {
 987             scaleFactor = 1.0f;
 988         }
 989
 990         if(stateblock->renderState[WINED3DRS_POINTSCALEENABLE]) {
 991             att[0] = *((float*)&stateblock->renderState[WINED3DRS_POINTSCALE_A]) /
 992                     (stateblock->viewport.Height * stateblock->viewport.Height * scaleFactor);
 993             att[1] = *((float*)&stateblock->renderState[WINED3DRS_POINTSCALE_B]) /
 994                     (stateblock->viewport.Height * stateblock->viewport.Height * scaleFactor);
 995             att[2] = *((float*)&stateblock->renderState[WINED3DRS_POINTSCALE_C]) /
 996                     (stateblock->viewport.Height * stateblock->viewport.Height * scaleFactor);
 997         }
 998     }
 999
1000     if(GL_SUPPORT(ARB_POINT_PARAMETERS)) {
1001         GL_EXTCALL(glPointParameterfvARB)(GL_POINT_DISTANCE_ATTENUATION_ARB, att);
1002         checkGLcall("glPointParameterfvARB(GL_DISTANCE_ATTENUATION_ARB, ...");
1003     }
1004     else if(GL_SUPPORT(EXT_POINT_PARAMETERS)) {
1005         GL_EXTCALL(glPointParameterfvEXT)(GL_DISTANCE_ATTENUATION_EXT, att);
1006         checkGLcall("glPointParameterfvEXT(GL_DISTANCE_ATTENUATION_EXT, ...");
1007     } else {
1008         TRACE("POINT_PARAMETERS not supported in this version of opengl\n");
1009     }
1010 }
1011
1012 static void state_colorwrite(DWORD state, IWineD3DStateBlockImpl *stateblock) {
1013     DWORD Value = stateblock->renderState[WINED3DRS_COLORWRITEENABLE];
1014
1015     TRACE("Color mask: r(%d) g(%d) b(%d) a(%d)\n",
1016         Value & D3DCOLORWRITEENABLE_RED   ? 1 : 0,
1017         Value & D3DCOLORWRITEENABLE_GREEN ? 1 : 0,
1018         Value & D3DCOLORWRITEENABLE_BLUE  ? 1 : 0,
1019         Value & D3DCOLORWRITEENABLE_ALPHA ? 1 : 0);
1020     glColorMask(Value & D3DCOLORWRITEENABLE_RED   ? GL_TRUE : GL_FALSE,
1021                 Value & D3DCOLORWRITEENABLE_GREEN ? GL_TRUE : GL_FALSE,
1022                 Value & D3DCOLORWRITEENABLE_BLUE  ? GL_TRUE : GL_FALSE,
1023                 Value & D3DCOLORWRITEENABLE_ALPHA ? GL_TRUE : GL_FALSE);
1024     checkGLcall("glColorMask(...)");
1025
1026     /* depends on WINED3DRS_COLORWRITEENABLE. */
1027     if(stateblock->renderState[WINED3DRS_COLORWRITEENABLE1] != 0x0000000F ||
1028        stateblock->renderState[WINED3DRS_COLORWRITEENABLE2] != 0x0000000F ||
1029        stateblock->renderState[WINED3DRS_COLORWRITEENABLE3] != 0x0000000F ) {
1030         ERR("(WINED3DRS_COLORWRITEENABLE1/2/3,%d,%d,%d) not yet implemented. Missing of cap D3DPMISCCAPS_INDEPENDENTWRITEMASKS wasn't honored?\n",
1031             stateblock->renderState[WINED3DRS_COLORWRITEENABLE1],
1032             stateblock->renderState[WINED3DRS_COLORWRITEENABLE2],
1033             stateblock->renderState[WINED3DRS_COLORWRITEENABLE3]);
1034     }
1035 }
1036
1037 static void state_localviewer(DWORD state, IWineD3DStateBlockImpl *stateblock) {
1038     if(stateblock->renderState[WINED3DRS_LOCALVIEWER]) {
1039         glLightModeli(GL_LIGHT_MODEL_LOCAL_VIEWER, 1);
1040         checkGLcall("glLightModeli(GL_LIGHT_MODEL_LOCAL_VIEWER, 1)");
1041     } else {
1042         glLightModeli(GL_LIGHT_MODEL_LOCAL_VIEWER, 0);
1043         checkGLcall("glLightModeli(GL_LIGHT_MODEL_LOCAL_VIEWER, 0)");
1044     }
1045 }
1046
1047 static void state_lastpixel(DWORD state, IWineD3DStateBlockImpl *stateblock) {
1048     if(stateblock->renderState[WINED3DRS_LASTPIXEL]) {
1049         TRACE("Last Pixel Drawing Enabled\n");
1050     } else {
1051         FIXME("Last Pixel Drawing Disabled, not handled yet\n");
1052     }
1053 }
1054
1055 static void state_pointsprite(DWORD state, IWineD3DStateBlockImpl *stateblock) {
1056     unsigned int i;
1057     int val;
1058
1059     /* TODO: NV_POINT_SPRITE */
1060     if (!GL_SUPPORT(ARB_POINT_SPRITE)) {
1061         TRACE("Point sprites not supported\n");
1062         return;
1063     }
1064
1065     if (stateblock->renderState[WINED3DRS_POINTSPRITEENABLE]) {
1066         val = GL_TRUE;
1067     } else {
1068         val = GL_FALSE;
1069     }
1070
1071     for (i = 0; i < GL_LIMITS(texture_stages); i++) {
1072         /* Note the WINED3DRS value applies to all textures, but GL has one
1073          * per texture, so apply it now ready to be used!
1074          */
1075         if (GL_SUPPORT(ARB_MULTITEXTURE)) {
1076             GL_EXTCALL(glActiveTextureARB(GL_TEXTURE0_ARB + i));
1077             checkGLcall("glActiveTextureARB");
1078         } else if (i==1) {
1079             FIXME("Program using multiple concurrent textures which this opengl implementation doesn't support\n");
1080             break;
1081         }
1082
1083         glTexEnvi(GL_POINT_SPRITE_ARB, GL_COORD_REPLACE_ARB, val);
1084         checkGLcall((val?"glTexEnvi(GL_POINT_SPRITE, GL_COORD_REPLACE, GL_TRUE)":
1085                          "glTexEnvi(GL_POINT_SPRITE, GL_COORD_REPLACE, GL_FALSE)"));
1086     }
1087 }
1088
1089 static void state_wrap(DWORD state, IWineD3DStateBlockImpl *stateblock) {
1090     /**
1091      http://www.cosc.brocku.ca/Offerings/3P98/course/lectures/texture/
1092      http://msdn.microsoft.com/archive/default.asp?url=/archive/en-us/directx9_c/directx/graphics/programmingguide/FixedFunction/Textures/texturewrapping.asp
1093      http://www.gamedev.net/reference/programming/features/rendererdll3/page2.asp
1094      Descussion that ways to turn on WRAPing to solve an opengl conversion problem.
1095      http://www.flipcode.org/cgi-bin/fcmsg.cgi?thread_show=10248
1096
1097      so far as I can tell, wrapping and texture-coordinate generate go hand in hand,
1098      */
1099     TRACE("Stub\n");
1100     if(stateblock->renderState[WINED3DRS_WRAP0] ||
1101        stateblock->renderState[WINED3DRS_WRAP1] ||
1102        stateblock->renderState[WINED3DRS_WRAP2] ||
1103        stateblock->renderState[WINED3DRS_WRAP3] ||
1104        stateblock->renderState[WINED3DRS_WRAP4] ||
1105        stateblock->renderState[WINED3DRS_WRAP5] ||
1106        stateblock->renderState[WINED3DRS_WRAP6] ||
1107        stateblock->renderState[WINED3DRS_WRAP7] ||
1108        stateblock->renderState[WINED3DRS_WRAP8] ||
1109        stateblock->renderState[WINED3DRS_WRAP9] ||
1110        stateblock->renderState[WINED3DRS_WRAP10] ||
1111        stateblock->renderState[WINED3DRS_WRAP11] ||
1112        stateblock->renderState[WINED3DRS_WRAP12] ||
1113        stateblock->renderState[WINED3DRS_WRAP13] ||
1114        stateblock->renderState[WINED3DRS_WRAP14] ||
1115        stateblock->renderState[WINED3DRS_WRAP15] ) {
1116         ERR("(WINED3DRS_WRAP0) Texture wraping not yet supported\n");
1117     }
1118 }
1119
1120 static void state_multisampleaa(DWORD state, IWineD3DStateBlockImpl *stateblock) {
1121     if( GL_SUPPORT(ARB_MULTISAMPLE) ) {
1122         if(stateblock->renderState[WINED3DRS_MULTISAMPLEANTIALIAS]) {
1123             glEnable(GL_MULTISAMPLE_ARB);
1124             checkGLcall("glEnable(GL_MULTISAMPLE_ARB)");
1125         } else {
1126             glDisable(GL_MULTISAMPLE_ARB);
1127             checkGLcall("glDisable(GL_MULTISAMPLE_ARB)");
1128         }
1129     } else {
1130         if(stateblock->renderState[WINED3DRS_MULTISAMPLEANTIALIAS]) {
1131             ERR("Multisample antialiasing not supported by gl\n");
1132         }
1133     }
1134 }
1135
1136 static void state_scissor(DWORD state, IWineD3DStateBlockImpl *stateblock) {
1137     if(stateblock->renderState[WINED3DRS_SCISSORTESTENABLE]) {
1138         glEnable(GL_SCISSOR_TEST);
1139         checkGLcall("glEnable(GL_SCISSOR_TEST)");
1140     } else {
1141         glDisable(GL_SCISSOR_TEST);
1142         checkGLcall("glDisable(GL_SCISSOR_TEST)");
1143     }
1144 }
1145
1146 static void state_depthbias(DWORD state, IWineD3DStateBlockImpl *stateblock) {
1147     union {
1148         DWORD d;
1149         float f;
1150     } tmpvalue;
1151
1152     if(stateblock->renderState[WINED3DRS_SLOPESCALEDEPTHBIAS] ||
1153        stateblock->renderState[WINED3DRS_DEPTHBIAS]) {
1154         tmpvalue.d = stateblock->renderState[WINED3DRS_SLOPESCALEDEPTHBIAS];
1155         glEnable(GL_POLYGON_OFFSET_FILL);
1156         checkGLcall("glEnable(GL_POLYGON_OFFSET_FILL)");
1157         glPolygonOffset(tmpvalue.f, *((float*)&stateblock->renderState[WINED3DRS_DEPTHBIAS]));
1158         checkGLcall("glPolygonOffset(...)");
1159     } else {
1160         glDisable(GL_POLYGON_OFFSET_FILL);
1161         checkGLcall("glDisable(GL_POLYGON_OFFSET_FILL)");
1162     }
1163 }
1164
1165 static void state_perspective(DWORD state, IWineD3DStateBlockImpl *stateblock) {
1166     if (stateblock->renderState[WINED3DRS_TEXTUREPERSPECTIVE]) {
1167         glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);
1168         checkGLcall("glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST)");
1169     } else {
1170         glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_FASTEST);
1171         checkGLcall("glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_FASTEST)");
1172     }
1173 }
1174
1175 static void state_stippledalpha(DWORD state, IWineD3DStateBlockImpl *stateblock) {
1176     TRACE("Stub\n");
1177     if (stateblock->renderState[WINED3DRS_STIPPLEDALPHA])
1178         ERR(" Stippled Alpha not supported yet.\n");
1179 }
1180
1181 static void state_antialias(DWORD state, IWineD3DStateBlockImpl *stateblock) {
1182     TRACE("Stub\n");
1183     if (stateblock->renderState[WINED3DRS_ANTIALIAS])
1184         ERR(" Antialias not supported yet.\n");
1185 }
1186
1187 static void state_multisampmask(DWORD state, IWineD3DStateBlockImpl *stateblock) {
1188     TRACE("Stub\n");
1189     if (stateblock->renderState[WINED3DRS_MULTISAMPLEMASK] != 0xFFFFFFFF)
1190         ERR("(WINED3DRS_MULTISAMPLEMASK,%d) not yet implemented\n", stateblock->renderState[WINED3DRS_MULTISAMPLEMASK]);
1191 }
1192
1193 static void state_patchedgestyle(DWORD state, IWineD3DStateBlockImpl *stateblock) {
1194     TRACE("Stub\n");
1195     if (stateblock->renderState[WINED3DRS_PATCHEDGESTYLE] != D3DPATCHEDGE_DISCRETE)
1196         ERR("(WINED3DRS_PATCHEDGESTYLE,%d) not yet implemented\n", stateblock->renderState[WINED3DRS_PATCHEDGESTYLE]);
1197 }
1198
1199 static void state_patchsegments(DWORD state, IWineD3DStateBlockImpl *stateblock) {
1200     union {
1201         DWORD d;
1202         float f;
1203     } tmpvalue;
1204     tmpvalue.f = 1.0f;
1205
1206     TRACE("Stub\n");
1207     if (stateblock->renderState[WINED3DRS_PATCHSEGMENTS] != tmpvalue.d)
1208         ERR("(WINED3DRS_PATCHSEGMENTS,%d) not yet implemented\n", tmpvalue.d);
1209 }
1210
1211 static void state_positiondegree(DWORD state, IWineD3DStateBlockImpl *stateblock) {
1212     TRACE("Stub\n");
1213     if (stateblock->renderState[WINED3DRS_POSITIONDEGREE] != D3DDEGREE_CUBIC)
1214         ERR("(WINED3DRS_POSITIONDEGREE,%d) not yet implemented\n", stateblock->renderState[WINED3DRS_POSITIONDEGREE]);
1215 }
1216
1217 static void state_normaldegree(DWORD state, IWineD3DStateBlockImpl *stateblock) {
1218     TRACE("Stub\n");
1219     if (stateblock->renderState[WINED3DRS_NORMALDEGREE] != D3DDEGREE_LINEAR)
1220         ERR("(WINED3DRS_NORMALDEGREE,%d) not yet implemented\n", stateblock->renderState[WINED3DRS_NORMALDEGREE]);
1221 }
1222
1223 static void state_tessellation(DWORD state, IWineD3DStateBlockImpl *stateblock) {
1224     TRACE("Stub\n");
1225     if(stateblock->renderState[WINED3DRS_ENABLEADAPTIVETESSELLATION])
1226         FIXME("(WINED3DRS_ENABLEADAPTIVETESSELLATION,%d) not yet implemented\n", stateblock->renderState[WINED3DRS_ENABLEADAPTIVETESSELLATION]);
1227 }
1228
1229
1230 static void state_srgbwrite(DWORD state, IWineD3DStateBlockImpl *stateblock) {
1231     if(stateblock->renderState[WINED3DRS_SRGBWRITEENABLE])
1232         ERR("Render state WINED3DRS_SRGBWRITEENABLE not yet implemented\n");
1233 }
1234
1235 static void state_seperateblend(DWORD state, IWineD3DStateBlockImpl *stateblock) {
1236     TRACE("Stub\n");
1237     if(stateblock->renderState[WINED3DRS_SEPARATEALPHABLENDENABLE])
1238         FIXME("(WINED3DRS_SEPARATEALPHABLENDENABLE,%d) not yet implemented\n", stateblock->renderState[WINED3DRS_SEPARATEALPHABLENDENABLE]);
1239 }
1240
1241 static void state_wrapu(DWORD state, IWineD3DStateBlockImpl *stateblock) {
1242     if(stateblock->renderState[WINED3DRS_WRAPU]) {
1243         FIXME("Render state WINED3DRS_WRAPU not implemented yet\n");
1244     }
1245 }
1246
1247 static void state_wrapv(DWORD state, IWineD3DStateBlockImpl *stateblock) {
1248     if(stateblock->renderState[WINED3DRS_WRAPV]) {
1249         FIXME("Render state WINED3DRS_WRAPV not implemented yet\n");
1250     }
1251 }
1252
1253 static void state_monoenable(DWORD state, IWineD3DStateBlockImpl *stateblock) {
1254     if(stateblock->renderState[WINED3DRS_MONOENABLE]) {
1255         FIXME("Render state WINED3DRS_MONOENABLE not implemented yet\n");
1256     }
1257 }
1258
1259 static void state_rop2(DWORD state, IWineD3DStateBlockImpl *stateblock) {
1260     if(stateblock->renderState[WINED3DRS_ROP2]) {
1261         FIXME("Render state WINED3DRS_ROP2 not implemented yet\n");
1262     }
1263 }
1264
1265 static void state_planemask(DWORD state, IWineD3DStateBlockImpl *stateblock) {
1266     if(stateblock->renderState[WINED3DRS_PLANEMASK]) {
1267         FIXME("Render state WINED3DRS_PLANEMASK not implemented yet\n");
1268     }
1269 }
1270
1271 static void state_subpixel(DWORD state, IWineD3DStateBlockImpl *stateblock) {
1272     if(stateblock->renderState[WINED3DRS_SUBPIXEL]) {
1273         FIXME("Render state WINED3DRS_SUBPIXEL not implemented yet\n");
1274     }
1275 }
1276
1277 static void state_subpixelx(DWORD state, IWineD3DStateBlockImpl *stateblock) {
1278     if(stateblock->renderState[WINED3DRS_SUBPIXELX]) {
1279         FIXME("Render state WINED3DRS_SUBPIXELX not implemented yet\n");
1280     }
1281 }
1282
1283 static void state_stippleenable(DWORD state, IWineD3DStateBlockImpl *stateblock) {
1284     if(stateblock->renderState[WINED3DRS_STIPPLEENABLE]) {
1285         FIXME("Render state WINED3DRS_STIPPLEENABLE not implemented yet\n");
1286     }
1287 }
1288
1289 static void state_bordercolor(DWORD state, IWineD3DStateBlockImpl *stateblock) {
1290     if(stateblock->renderState[WINED3DRS_BORDERCOLOR]) {
1291         FIXME("Render state WINED3DRS_BORDERCOLOR not implemented yet\n");
1292     }
1293 }
1294
1295 static void state_mipmaplodbias(DWORD state, IWineD3DStateBlockImpl *stateblock) {
1296     if(stateblock->renderState[WINED3DRS_MIPMAPLODBIAS]) {
1297         FIXME("Render state WINED3DRS_MIPMAPLODBIAS not implemented yet\n");
1298     }
1299 }
1300
1301 static void state_anisotropy(DWORD state, IWineD3DStateBlockImpl *stateblock) {
1302     if(stateblock->renderState[WINED3DRS_ANISOTROPY]) {
1303         FIXME("Render state WINED3DRS_ANISOTROPY not implemented yet\n");
1304     }
1305 }
1306
1307 static void state_flushbatch(DWORD state, IWineD3DStateBlockImpl *stateblock) {
1308     if(stateblock->renderState[WINED3DRS_FLUSHBATCH]) {
1309         FIXME("Render state WINED3DRS_FLUSHBATCH not implemented yet\n");
1310     }
1311 }
1312
1313 static void state_translucentsi(DWORD state, IWineD3DStateBlockImpl *stateblock) {
1314     if(stateblock->renderState[WINED3DRS_TRANSLUCENTSORTINDEPENDENT]) {
1315         FIXME("Render state WINED3DRS_TRANSLUCENTSORTINDEPENDENT not implemented yet\n");
1316     }
1317 }
1318
1319 static void state_extents(DWORD state, IWineD3DStateBlockImpl *stateblock) {
1320     if(stateblock->renderState[WINED3DRS_EXTENTS]) {
1321         FIXME("Render state WINED3DRS_EXTENTS not implemented yet\n");
1322     }
1323 }
1324
1325 static void state_ckeyblend(DWORD state, IWineD3DStateBlockImpl *stateblock) {
1326     if(stateblock->renderState[WINED3DRS_COLORKEYBLENDENABLE]) {
1327         FIXME("Render state WINED3DRS_COLORKEYBLENDENABLE not implemented yet\n");
1328     }
1329 }
1330
1331 /* Activates the texture dimension according to the bound D3D texture.
1332  * Does not care for the colorop or correct gl texture unit(when using nvrc)
1333  * Requires the caller to activate the correct unit before
1334  */
1335 static void activate_dimensions(DWORD stage, IWineD3DStateBlockImpl *stateblock) {
1336     if(stateblock->textures[stage]) {
1337         glDisable(GL_TEXTURE_1D);
1338         checkGLcall("glDisable(GL_TEXTURE_1D)");
1339         switch(stateblock->textureDimensions[stage]) {
1340             case GL_TEXTURE_2D:
1341                 glDisable(GL_TEXTURE_3D);
1342                 checkGLcall("glDisable(GL_TEXTURE_3D)");
1343                 glDisable(GL_TEXTURE_CUBE_MAP_ARB);
1344                 checkGLcall("glDisable(GL_TEXTURE_CUBE_MAP_ARB)");
1345                 glEnable(GL_TEXTURE_2D);
1346                 checkGLcall("glEnable(GL_TEXTURE_2D)");
1347                 break;
1348             case GL_TEXTURE_3D:
1349                 glDisable(GL_TEXTURE_CUBE_MAP_ARB);
1350                 checkGLcall("glDisable(GL_TEXTURE_CUBE_MAP_ARB)");
1351                 glDisable(GL_TEXTURE_2D);
1352                 checkGLcall("glDisable(GL_TEXTURE_2D)");
1353                 glEnable(GL_TEXTURE_3D);
1354                 checkGLcall("glEnable(GL_TEXTURE_3D)");
1355                 break;
1356             case GL_TEXTURE_CUBE_MAP_ARB:
1357                 glDisable(GL_TEXTURE_2D);
1358                 checkGLcall("glDisable(GL_TEXTURE_2D)");
1359                 glDisable(GL_TEXTURE_3D);
1360                 checkGLcall("glDisable(GL_TEXTURE_3D)");
1361                 glEnable(GL_TEXTURE_CUBE_MAP_ARB);
1362                 checkGLcall("glEnable(GL_TEXTURE_CUBE_MAP_ARB)");
1363                 break;
1364         }
1365     } else {
1366         glDisable(GL_TEXTURE_2D);
1367         checkGLcall("glDisable(GL_TEXTURE_2D)");
1368         glDisable(GL_TEXTURE_3D);
1369         checkGLcall("glDisable(GL_TEXTURE_3D)");
1370         glDisable(GL_TEXTURE_CUBE_MAP_ARB);
1371         checkGLcall("glDisable(GL_TEXTURE_CUBE_MAP_ARB)");
1372         glEnable(GL_TEXTURE_1D);
1373         checkGLcall("glEnable(GL_TEXTURE_1D)");
1374         /* Binding textures is done by samplers. A dummy texture will be bound */
1375     }
1376 }
1377
1378 static void tex_colorop(DWORD state, IWineD3DStateBlockImpl *stateblock) {
1379     DWORD stage = (state - STATE_TEXTURESTAGE(0, 0)) / WINED3D_HIGHEST_TEXTURE_STATE;
1380     DWORD mapped_stage = stateblock->wineD3DDevice->texUnitMap[stage];
1381
1382     TRACE("Setting color op for stage %d\n", stage);
1383
1384     if (stateblock->pixelShader && stateblock->wineD3DDevice->ps_selected_mode != SHADER_NONE &&
1385         ((IWineD3DPixelShaderImpl *)stateblock->pixelShader)->baseShader.function) {
1386         /* Using a pixel shader? Don't care for anything here, the shader applying does it */
1387         return;
1388     }
1389
1390     if (stage != mapped_stage) WARN("Using non 1:1 mapping: %d -> %d!\n", stage, mapped_stage);
1391
1392     if (mapped_stage != -1) {
1393         if (GL_SUPPORT(ARB_MULTITEXTURE)) {
1394             if (mapped_stage >= GL_LIMITS(sampler_stages)) {
1395                 if (stateblock->textureState[stage][WINED3DTSS_COLOROP] != WINED3DTOP_DISABLE &&
1396                         stateblock->textureState[stage][WINED3DTSS_COLOROP] != 0) {
1397                     FIXME("Attempt to enable unsupported stage!\n");
1398                 }
1399                 return;
1400             }
1401             GL_EXTCALL(glActiveTextureARB(GL_TEXTURE0_ARB + mapped_stage));
1402             checkGLcall("glActiveTextureARB");
1403         } else if (stage > 0) {
1404             WARN("Program using multiple concurrent textures which this opengl implementation doesn't support\n");
1405             return;
1406         }
1407     }
1408
1409     if (GL_SUPPORT(NV_REGISTER_COMBINERS)) {
1410         if(stateblock->lowest_disabled_stage > 0) {
1411             glEnable(GL_REGISTER_COMBINERS_NV);
1412             GL_EXTCALL(glCombinerParameteriNV(GL_NUM_GENERAL_COMBINERS_NV, stateblock->lowest_disabled_stage));
1413         } else {
1414             glDisable(GL_REGISTER_COMBINERS_NV);
1415         }
1416     }
1417     if(stage >= stateblock->lowest_disabled_stage) {
1418         TRACE("Stage disabled\n");
1419         if (mapped_stage != -1) {
1420             /* Disable everything here */
1421             glDisable(GL_TEXTURE_1D);
1422             checkGLcall("glDisable(GL_TEXTURE_1D)");
1423             glDisable(GL_TEXTURE_2D);
1424             checkGLcall("glDisable(GL_TEXTURE_2D)");
1425             glDisable(GL_TEXTURE_3D);
1426             checkGLcall("glDisable(GL_TEXTURE_3D)");
1427             glDisable(GL_TEXTURE_CUBE_MAP_ARB);
1428             checkGLcall("glDisable(GL_TEXTURE_CUBE_MAP_ARB)");
1429         }
1430         /* All done */
1431         return;
1432     }
1433
1434     if (mapped_stage != -1) activate_dimensions(stage, stateblock);
1435
1436     /* Set the texture combiners */
1437     if (GL_SUPPORT(NV_REGISTER_COMBINERS)) {
1438         set_tex_op_nvrc((IWineD3DDevice *)stateblock->wineD3DDevice, FALSE, stage,
1439                          stateblock->textureState[stage][WINED3DTSS_COLOROP],
1440                          stateblock->textureState[stage][WINED3DTSS_COLORARG1],
1441                          stateblock->textureState[stage][WINED3DTSS_COLORARG2],
1442                          stateblock->textureState[stage][WINED3DTSS_COLORARG0],
1443                          mapped_stage);
1444     } else {
1445         set_tex_op((IWineD3DDevice *)stateblock->wineD3DDevice, FALSE, stage,
1446                     stateblock->textureState[stage][WINED3DTSS_COLOROP],
1447                     stateblock->textureState[stage][WINED3DTSS_COLORARG1],
1448                     stateblock->textureState[stage][WINED3DTSS_COLORARG2],
1449                     stateblock->textureState[stage][WINED3DTSS_COLORARG0]);
1450     }
1451 }
1452
1453 static void tex_alphaop(DWORD state, IWineD3DStateBlockImpl *stateblock) {
1454     DWORD stage = (state - STATE_TEXTURESTAGE(0, 0)) / WINED3D_HIGHEST_TEXTURE_STATE;
1455     DWORD mapped_stage = stateblock->wineD3DDevice->texUnitMap[stage];
1456
1457     TRACE("Setting alpha op for stage %d\n", stage);
1458     /* Do not care for enabled / disabled stages, just assign the settigns. colorop disables / enables required stuff */
1459     if (mapped_stage != -1) {
1460         if (GL_SUPPORT(ARB_MULTITEXTURE)) {
1461             if (stage >= GL_LIMITS(sampler_stages)) {
1462                 if (stateblock->textureState[stage][WINED3DTSS_COLOROP] != WINED3DTOP_DISABLE &&
1463                         stateblock->textureState[stage][WINED3DTSS_COLOROP] != 0) {
1464                     FIXME("Attempt to enable unsupported stage!\n");
1465                 }
1466                 return;
1467             }
1468             GL_EXTCALL(glActiveTextureARB(GL_TEXTURE0_ARB + mapped_stage));
1469             checkGLcall("glActiveTextureARB");
1470         } else if (stage > 0) {
1471             /* We can't do anything here */
1472             WARN("Program using multiple concurrent textures which this opengl implementation doesn't support\n");
1473             return;
1474         }
1475     }
1476
1477     TRACE("Setting alpha op for stage %d\n", stage);
1478     if (GL_SUPPORT(NV_REGISTER_COMBINERS)) {
1479         set_tex_op_nvrc((IWineD3DDevice *)stateblock->wineD3DDevice, TRUE, stage,
1480                          stateblock->textureState[stage][WINED3DTSS_ALPHAOP],
1481                          stateblock->textureState[stage][WINED3DTSS_ALPHAARG1],
1482                          stateblock->textureState[stage][WINED3DTSS_ALPHAARG2],
1483                          stateblock->textureState[stage][WINED3DTSS_ALPHAARG0],
1484                          mapped_stage);
1485     } else {
1486         set_tex_op((IWineD3DDevice *)stateblock->wineD3DDevice, TRUE, stage, stateblock->textureState[stage][WINED3DTSS_ALPHAOP],
1487                     stateblock->textureState[stage][WINED3DTSS_ALPHAARG1],
1488                     stateblock->textureState[stage][WINED3DTSS_ALPHAARG2],
1489                     stateblock->textureState[stage][WINED3DTSS_ALPHAARG0]);
1490     }
1491 }
1492
1493 static void transform_texture(DWORD state, IWineD3DStateBlockImpl *stateblock) {
1494     DWORD texUnit = state - STATE_TRANSFORM(WINED3DTS_TEXTURE0);
1495
1496     if (GL_SUPPORT(ARB_MULTITEXTURE)) {
1497         if(texUnit >= GL_LIMITS(sampler_stages)) {
1498             return;
1499         }
1500         GL_EXTCALL(glActiveTextureARB(GL_TEXTURE0_ARB + stateblock->wineD3DDevice->texUnitMap[texUnit]));
1501         checkGLcall("glActiveTextureARB");
1502     } else if (texUnit > 0) {
1503         /* We can't do anything here */
1504         WARN("Program using multiple concurrent textures which this opengl implementation doesn't support\n");
1505         return;
1506     }
1507
1508     set_texture_matrix((float *)&stateblock->transforms[WINED3DTS_TEXTURE0 + texUnit].u.m[0][0],
1509                         stateblock->textureState[texUnit][WINED3DTSS_TEXTURETRANSFORMFLAGS],
1510                         (stateblock->textureState[texUnit][WINED3DTSS_TEXCOORDINDEX] & 0xFFFF0000) != WINED3DTSS_TCI_PASSTHRU);
1511
1512 }
1513
1514 static void tex_coordindex(DWORD state, IWineD3DStateBlockImpl *stateblock) {
1515     DWORD stage = (state - STATE_TEXTURESTAGE(0, 0)) / WINED3D_HIGHEST_TEXTURE_STATE;
1516     DWORD mapped_stage = stateblock->wineD3DDevice->texUnitMap[stage];
1517
1518     if (mapped_stage == -1) {
1519         TRACE("No texture unit mapped to stage %d. Skipping texture coordinates.\n", stage);
1520         return;
1521     }
1522
1523     if (GL_SUPPORT(ARB_MULTITEXTURE)) {
1524         if(stage >= GL_LIMITS(sampler_stages)) {
1525             return;
1526         }
1527         GL_EXTCALL(glActiveTextureARB(GL_TEXTURE0_ARB + mapped_stage));
1528         checkGLcall("glActiveTextureARB");
1529     } else if (stage > 0) {
1530         /* We can't do anything here */
1531         WARN("Program using multiple concurrent textures which this opengl implementation doesn't support\n");
1532         return;
1533     }
1534
1535     /* Values 0-7 are indexes into the FVF tex coords - See comments in DrawPrimitive
1536      *
1537      * FIXME: From MSDN: The WINED3DTSS_TCI_* flags are mutually exclusive. If you include
1538      * one flag, you can still specify an index value, which the system uses to
1539      * determine the texture wrapping mode.
1540      * eg. SetTextureStageState( 0, WINED3DTSS_TEXCOORDINDEX, WINED3DTSS_TCI_CAMERASPACEPOSITION | 1 );
1541      * means use the vertex position (camera-space) as the input texture coordinates
1542      * for this texture stage, and the wrap mode set in the WINED3DRS_WRAP1 render
1543      * state. We do not (yet) support the WINED3DRENDERSTATE_WRAPx values, nor tie them up
1544      * to the TEXCOORDINDEX value
1545      */
1546
1547     /*
1548      * Be careful the value of the mask 0xF0000 come from d3d8types.h infos
1549      */
1550     switch (stateblock->textureState[stage][WINED3DTSS_TEXCOORDINDEX] & 0xFFFF0000) {
1551     case WINED3DTSS_TCI_PASSTHRU:
1552         /*Use the specified texture coordinates contained within the vertex format. This value resolves to zero.*/
1553         glDisable(GL_TEXTURE_GEN_S);
1554         glDisable(GL_TEXTURE_GEN_T);
1555         glDisable(GL_TEXTURE_GEN_R);
1556         glDisable(GL_TEXTURE_GEN_Q);
1557         checkGLcall("glDisable(GL_TEXTURE_GEN_S,T,R,Q)");
1558         break;
1559
1560     case WINED3DTSS_TCI_CAMERASPACEPOSITION:
1561         /* CameraSpacePosition means use the vertex position, transformed to camera space,
1562          * as the input texture coordinates for this stage's texture transformation. This
1563          * equates roughly to EYE_LINEAR
1564          */
1565         {
1566             float s_plane[] = { 1.0, 0.0, 0.0, 0.0 };
1567             float t_plane[] = { 0.0, 1.0, 0.0, 0.0 };
1568             float r_plane[] = { 0.0, 0.0, 1.0, 0.0 };
1569             float q_plane[] = { 0.0, 0.0, 0.0, 1.0 };
1570             TRACE("WINED3DTSS_TCI_CAMERASPACEPOSITION - Set eye plane\n");
1571
1572             glMatrixMode(GL_MODELVIEW);
1573             glPushMatrix();
1574             glLoadIdentity();
1575             glTexGenfv(GL_S, GL_EYE_PLANE, s_plane);
1576             glTexGenfv(GL_T, GL_EYE_PLANE, t_plane);
1577             glTexGenfv(GL_R, GL_EYE_PLANE, r_plane);
1578             glTexGenfv(GL_Q, GL_EYE_PLANE, q_plane);
1579             glPopMatrix();
1580
1581             TRACE("WINED3DTSS_TCI_CAMERASPACEPOSITION - Set GL_TEXTURE_GEN_x and GL_x, GL_TEXTURE_GEN_MODE, GL_EYE_LINEAR\n");
1582             glEnable(GL_TEXTURE_GEN_S);
1583             checkGLcall("glEnable(GL_TEXTURE_GEN_S);");
1584             glTexGeni(GL_S, GL_TEXTURE_GEN_MODE, GL_EYE_LINEAR);
1585             checkGLcall("glTexGeni(GL_S, GL_TEXTURE_GEN_MODE, GL_EYE_LINEAR)");
1586             glEnable(GL_TEXTURE_GEN_T);
1587             checkGLcall("glEnable(GL_TEXTURE_GEN_T);");
1588             glTexGeni(GL_T, GL_TEXTURE_GEN_MODE, GL_EYE_LINEAR);
1589             checkGLcall("glTexGeni(GL_T, GL_TEXTURE_GEN_MODE, GL_EYE_LINEAR)");
1590             glEnable(GL_TEXTURE_GEN_R);
1591             checkGLcall("glEnable(GL_TEXTURE_GEN_R);");
1592             glTexGeni(GL_R, GL_TEXTURE_GEN_MODE, GL_EYE_LINEAR);
1593             checkGLcall("glTexGeni(GL_R, GL_TEXTURE_GEN_MODE, GL_EYE_LINEAR)");
1594         }
1595         break;
1596
1597     case WINED3DTSS_TCI_CAMERASPACENORMAL:
1598         {
1599             if (GL_SUPPORT(NV_TEXGEN_REFLECTION)) {
1600                 float s_plane[] = { 1.0, 0.0, 0.0, 0.0 };
1601                 float t_plane[] = { 0.0, 1.0, 0.0, 0.0 };
1602                 float r_plane[] = { 0.0, 0.0, 1.0, 0.0 };
1603                 float q_plane[] = { 0.0, 0.0, 0.0, 1.0 };
1604                 TRACE("WINED3DTSS_TCI_CAMERASPACENORMAL - Set eye plane\n");
1605
1606                 glMatrixMode(GL_MODELVIEW);
1607                 glPushMatrix();
1608                 glLoadIdentity();
1609                 glTexGenfv(GL_S, GL_EYE_PLANE, s_plane);
1610                 glTexGenfv(GL_T, GL_EYE_PLANE, t_plane);
1611                 glTexGenfv(GL_R, GL_EYE_PLANE, r_plane);
1612                 glTexGenfv(GL_Q, GL_EYE_PLANE, q_plane);
1613                 glPopMatrix();
1614
1615                 glEnable(GL_TEXTURE_GEN_S);
1616                 checkGLcall("glEnable(GL_TEXTURE_GEN_S);");
1617                 glTexGeni(GL_S, GL_TEXTURE_GEN_MODE, GL_NORMAL_MAP_NV);
1618                 checkGLcall("glTexGeni(GL_S, GL_TEXTURE_GEN_MODE, GL_NORMAL_MAP_NV)");
1619                 glEnable(GL_TEXTURE_GEN_T);
1620                 checkGLcall("glEnable(GL_TEXTURE_GEN_T);");
1621                 glTexGeni(GL_T, GL_TEXTURE_GEN_MODE, GL_NORMAL_MAP_NV);
1622                 checkGLcall("glTexGeni(GL_T, GL_TEXTURE_GEN_MODE, GL_NORMAL_MAP_NV)");
1623                 glEnable(GL_TEXTURE_GEN_R);
1624                 checkGLcall("glEnable(GL_TEXTURE_GEN_R);");
1625                 glTexGeni(GL_R, GL_TEXTURE_GEN_MODE, GL_NORMAL_MAP_NV);
1626                 checkGLcall("glTexGeni(GL_R, GL_TEXTURE_GEN_MODE, GL_NORMAL_MAP_NV)");
1627             }
1628         }
1629         break;
1630
1631     case WINED3DTSS_TCI_CAMERASPACEREFLECTIONVECTOR:
1632         {
1633             if (GL_SUPPORT(NV_TEXGEN_REFLECTION)) {
1634             float s_plane[] = { 1.0, 0.0, 0.0, 0.0 };
1635             float t_plane[] = { 0.0, 1.0, 0.0, 0.0 };
1636             float r_plane[] = { 0.0, 0.0, 1.0, 0.0 };
1637             float q_plane[] = { 0.0, 0.0, 0.0, 1.0 };
1638             TRACE("WINED3DTSS_TCI_CAMERASPACEREFLECTIONVECTOR - Set eye plane\n");
1639
1640             glMatrixMode(GL_MODELVIEW);
1641             glPushMatrix();
1642             glLoadIdentity();
1643             glTexGenfv(GL_S, GL_EYE_PLANE, s_plane);
1644             glTexGenfv(GL_T, GL_EYE_PLANE, t_plane);
1645             glTexGenfv(GL_R, GL_EYE_PLANE, r_plane);
1646             glTexGenfv(GL_Q, GL_EYE_PLANE, q_plane);
1647             glPopMatrix();
1648
1649             glEnable(GL_TEXTURE_GEN_S);
1650             checkGLcall("glEnable(GL_TEXTURE_GEN_S);");
1651             glTexGeni(GL_S, GL_TEXTURE_GEN_MODE, GL_REFLECTION_MAP_NV);
1652             checkGLcall("glTexGeni(GL_S, GL_TEXTURE_GEN_MODE, GL_REFLECTION_MAP_NV)");
1653             glEnable(GL_TEXTURE_GEN_T);
1654             checkGLcall("glEnable(GL_TEXTURE_GEN_T);");
1655             glTexGeni(GL_T, GL_TEXTURE_GEN_MODE, GL_REFLECTION_MAP_NV);
1656             checkGLcall("glTexGeni(GL_T, GL_TEXTURE_GEN_MODE, GL_REFLECTION_MAP_NV)");
1657             glEnable(GL_TEXTURE_GEN_R);
1658             checkGLcall("glEnable(GL_TEXTURE_GEN_R);");
1659             glTexGeni(GL_R, GL_TEXTURE_GEN_MODE, GL_REFLECTION_MAP_NV);
1660             checkGLcall("glTexGeni(GL_R, GL_TEXTURE_GEN_MODE, GL_REFLECTION_MAP_NV)");
1661             }
1662         }
1663         break;
1664
1665     /* Unhandled types: */
1666     default:
1667         /* Todo: */
1668         /* ? disable GL_TEXTURE_GEN_n ? */
1669         glDisable(GL_TEXTURE_GEN_S);
1670         glDisable(GL_TEXTURE_GEN_T);
1671         glDisable(GL_TEXTURE_GEN_R);
1672         glDisable(GL_TEXTURE_GEN_Q);
1673         FIXME("Unhandled WINED3DTSS_TEXCOORDINDEX %x\n", stateblock->textureState[stage][WINED3DTSS_TEXCOORDINDEX]);
1674         break;
1675     }
1676
1677     /* Update the texture matrix */
1678     if(!isStateDirty(stateblock->wineD3DDevice, STATE_TRANSFORM(WINED3DTS_TEXTURE0 + stage))) {
1679         transform_texture(STATE_TRANSFORM(WINED3DTS_TEXTURE0 + stage), stateblock);
1680     }
1681 }
1682
1683 static void tex_bumpenvlscale(DWORD state, IWineD3DStateBlockImpl *stateblock) {
1684     DWORD stage = (state - STATE_TEXTURESTAGE(0, 0)) / WINED3D_HIGHEST_TEXTURE_STATE;
1685     union {
1686         DWORD d;
1687         float f;
1688     } tmpvalue;
1689
1690     tmpvalue.d = stateblock->textureState[stage][WINED3DTSS_BUMPENVLSCALE];
1691     if(tmpvalue.f != 0.0) {
1692         ERR("WINED3DTSS_BUMPENVLSCALE not supported yet\n");
1693     }
1694 }
1695
1696 static void tex_bumpenvloffset(DWORD state, IWineD3DStateBlockImpl *stateblock) {
1697     DWORD stage = (state - STATE_TEXTURESTAGE(0, 0)) / WINED3D_HIGHEST_TEXTURE_STATE;
1698     union {
1699         DWORD d;
1700         float f;
1701     } tmpvalue;
1702
1703     tmpvalue.d = stateblock->textureState[stage][WINED3DTSS_BUMPENVLOFFSET];
1704     if(tmpvalue.f != 0.0) {
1705         ERR("WINED3DTSS_BUMPENVLOFFSET not supported yet\n");
1706     }
1707 }
1708
1709 static void tex_resultarg(DWORD state, IWineD3DStateBlockImpl *stateblock) {
1710     DWORD stage = (state - STATE_TEXTURESTAGE(0, 0)) / WINED3D_HIGHEST_TEXTURE_STATE;
1711
1712     if(stateblock->textureState[stage][WINED3DTSS_RESULTARG] != D3DTA_CURRENT) {
1713         ERR("WINED3DTSS_RESULTARG not supported yet\n");
1714     }
1715 }
1716
1717 static void sampler(DWORD state, IWineD3DStateBlockImpl *stateblock) {
1718     DWORD sampler = state - STATE_SAMPLER(0);
1719     DWORD mapped_stage = stateblock->wineD3DDevice->texUnitMap[sampler];
1720     union {
1721         float f;
1722         DWORD d;
1723     } tmpvalue;
1724
1725     TRACE("Sampler: %d\n", sampler);
1726     /* Enabling and disabling texture dimensions is done by texture stage state / pixel shader setup, this function
1727      * only has to bind textures and set the per texture states
1728      */
1729
1730     if (mapped_stage == -1) {
1731         TRACE("No sampler mapped to stage %d. Returning.\n", sampler);
1732         return;
1733     }
1734
1735     if (GL_SUPPORT(ARB_MULTITEXTURE)) {
1736         if(sampler >= GL_LIMITS(sampler_stages)) {
1737             return;
1738         }
1739         GL_EXTCALL(glActiveTextureARB(GL_TEXTURE0_ARB + mapped_stage));
1740         checkGLcall("glActiveTextureARB");
1741     } else if (sampler > 0) {
1742         /* We can't do anything here */
1743         WARN("Program using multiple concurrent textures which this opengl implementation doesn't support\n");
1744         return;
1745     }
1746
1747     if(stateblock->textures[sampler]) {
1748
1749         /* NP2 textures need the texture matrix set properly for the stage */
1750         if(wined3d_settings.nonpower2_mode == NP2_NATIVE && sampler < MAX_TEXTURES - 1 &&
1751            stateblock->textureDimensions[sampler] == GL_TEXTURE_2D &&
1752            (((IWineD3DTextureImpl *) stateblock->textures[sampler])->pow2scalingFactorX != 1.0 ||
1753             ((IWineD3DTextureImpl *) stateblock->textures[sampler])->pow2scalingFactorY != 1.0 ) ) {
1754             transform_texture(STATE_TRANSFORM(WINED3DTS_TEXTURE0 + stateblock->wineD3DDevice->texUnitMap[sampler]), stateblock);
1755         }
1756
1757         IWineD3DBaseTexture_PreLoad((IWineD3DBaseTexture *) stateblock->textures[sampler]);
1758         IWineD3DBaseTexture_ApplyStateChanges(stateblock->textures[sampler], stateblock->textureState[sampler], stateblock->samplerState[sampler]);
1759
1760         if (GL_SUPPORT(EXT_TEXTURE_LOD_BIAS)) {
1761             tmpvalue.d = stateblock->samplerState[sampler][WINED3DSAMP_MIPMAPLODBIAS];
1762             glTexEnvf(GL_TEXTURE_FILTER_CONTROL_EXT,
1763                       GL_TEXTURE_LOD_BIAS_EXT,
1764                       tmpvalue.f);
1765             checkGLcall("glTexEnvi GL_TEXTURE_LOD_BIAS_EXT ...");
1766         }
1767
1768         if (stateblock->wineD3DDevice->ps_selected_mode != SHADER_NONE && stateblock->pixelShader &&
1769             ((IWineD3DPixelShaderImpl *)stateblock->pixelShader)->baseShader.function) {
1770             /* Using a pixel shader? Verify the sampler types */
1771
1772             /* Make sure that the texture dimensions are enabled. I don't have to disable the other
1773              * dimensions because the shader knows from which texture type to sample from. For the sake of
1774              * debugging all dimensions could be enabled and a texture with some ugly pink bound to the unused
1775              * dimensions. This should make wrong sampling sources visible :-)
1776              */
1777             glEnable(stateblock->textureDimensions[sampler]);
1778             checkGLcall("glEnable(stateblock->textureDimensions[sampler])");
1779         } else if(sampler < stateblock->lowest_disabled_stage) {
1780             activate_dimensions(sampler, stateblock);
1781
1782             if(stateblock->renderState[WINED3DRS_COLORKEYENABLE] && sampler == 0) {
1783                 /* If color keying is enabled update the alpha test, it depends on the existence
1784                  * of a color key in stage 0
1785                  */
1786                 state_alpha(WINED3DRS_COLORKEYENABLE, stateblock);
1787             }
1788         }
1789     } else if(sampler < GL_LIMITS(texture_stages)) {
1790         if(sampler < stateblock->lowest_disabled_stage) {
1791             /* TODO: Check if the colorop is dirty to do that job
1792              * TODO: What should I do with pixel shaders here ???
1793              */
1794             activate_dimensions(sampler, stateblock);
1795         } /* Otherwise tex_colorop disables the stage */
1796         glBindTexture(GL_TEXTURE_1D, stateblock->wineD3DDevice->dummyTextureName[sampler]);
1797         checkGLcall("glBindTexture(GL_TEXTURE_1D, stateblock->wineD3DDevice->dummyTextureName[sampler])");
1798     }
1799 }
1800
1801 static void pixelshader(DWORD state, IWineD3DStateBlockImpl *stateblock) {
1802     int i;
1803
1804     if(stateblock->pixelShader && ((IWineD3DPixelShaderImpl *) stateblock->pixelShader)->baseShader.function != NULL) {
1805         if(!stateblock->wineD3DDevice->last_was_pshader) {
1806             /* Former draw without a pixel shader, some samplers
1807              * may be disabled because of WINED3DTSS_COLOROP = WINED3DTOP_DISABLE
1808              * make sure to enable them
1809              */
1810             for(i=0; i < MAX_SAMPLERS; i++) {
1811                 if(!isStateDirty(stateblock->wineD3DDevice, STATE_SAMPLER(i))) {
1812                     sampler(STATE_SAMPLER(i), stateblock);
1813                 }
1814             }
1815         } else {
1816            /* Otherwise all samplers were activated by the code above in earlier draws, or by sampler()
1817             * if a different texture was bound. I don't have to do anything.
1818             */
1819         }
1820
1821         /* Compile and bind the shader */
1822         IWineD3DPixelShader_CompileShader(stateblock->pixelShader);
1823
1824 #if 0
1825         /* Can't do that here right now, because glsl shaders depend on having both pixel and vertex shader
1826          * setup at the same time. The shader_select call will be done by drawprim until vertex shaders are
1827          * moved to the state table too
1828          */
1829         stateblock->wineD3DDevice->shader_backend->shader_select(
1830                 (IWineD3DDevice *) stateblock->wineD3DDevice,
1831                 TRUE,
1832                 !stateblock->vertexShader ? FALSE : ((IWineD3DVertexShaderImpl *) stateblock->vertexShader)->baseShader.function != NULL);
1833 #endif
1834         stateblock->wineD3DDevice->last_was_pshader = TRUE;
1835     } else {
1836         /* Disabled the pixel shader - color ops weren't applied
1837          * while it was enabled, so re-apply them.
1838          */
1839         for(i=0; i < MAX_TEXTURES; i++) {
1840             if(!isStateDirty(stateblock->wineD3DDevice, STATE_TEXTURESTAGE(i, WINED3DTSS_COLOROP))) {
1841                 tex_colorop(STATE_TEXTURESTAGE(i, WINED3DTSS_COLOROP), stateblock);
1842             }
1843         }
1844         stateblock->wineD3DDevice->last_was_pshader = FALSE;
1845
1846 #if 0
1847         stateblock->wineD3DDevice->shader_backend->shader_select(
1848                 (IWineD3DDevice *) stateblock->wineD3DDevice,
1849                 FALSE,
1850                 !stateblock->vertexShader ? FALSE : ((IWineD3DVertexShaderImpl *) stateblock->vertexShader)->baseShader.function != NULL);
1851 #endif
1852     }
1853 }
1854
1855 static void transform_world(DWORD state, IWineD3DStateBlockImpl *stateblock) {
1856     /* This function is called by transform_view below if the view matrix was changed too
1857      *
1858      * Deliberately no check if the vertex declaration is dirty because the vdecl state
1859      * does not always update the world matrix, only on a switch between transformed
1860      * and untrannsformed draws. It *may* happen that the world matrix is set 2 times during one
1861      * draw, but that should be rather rare and cheaper in total.
1862      */
1863     glMatrixMode(GL_MODELVIEW);
1864     checkGLcall("glMatrixMode");
1865
1866     if(stateblock->wineD3DDevice->last_was_rhw) {
1867         glLoadIdentity();
1868         checkGLcall("glLoadIdentity()");
1869     } else {
1870         /* In the general case, the view matrix is the identity matrix */
1871         if (stateblock->wineD3DDevice->view_ident) {
1872             glLoadMatrixf((float *) &stateblock->transforms[WINED3DTS_WORLDMATRIX(0)].u.m[0][0]);
1873             checkGLcall("glLoadMatrixf");
1874         } else {
1875             glLoadMatrixf((float *) &stateblock->transforms[WINED3DTS_VIEW].u.m[0][0]);
1876             checkGLcall("glLoadMatrixf");
1877             glMultMatrixf((float *) &stateblock->transforms[WINED3DTS_WORLDMATRIX(0)].u.m[0][0]);
1878             checkGLcall("glMultMatrixf");
1879         }
1880     }
1881 }
1882
1883 static void transform_view(DWORD state, IWineD3DStateBlockImpl *stateblock) {
1884     unsigned int k;
1885
1886     /* If we are changing the View matrix, reset the light and clipping planes to the new view
1887      * NOTE: We have to reset the positions even if the light/plane is not currently
1888      *       enabled, since the call to enable it will not reset the position.
1889      * NOTE2: Apparently texture transforms do NOT need reapplying
1890      */
1891
1892     PLIGHTINFOEL *lightChain = NULL;
1893
1894     glMatrixMode(GL_MODELVIEW);
1895     checkGLcall("glMatrixMode(GL_MODELVIEW)");
1896     glLoadMatrixf((float *)(float *) &stateblock->transforms[WINED3DTS_VIEW].u.m[0][0]);
1897     checkGLcall("glLoadMatrixf(...)");
1898
1899     /* Reset lights. TODO: Call light apply func */
1900     lightChain = stateblock->lights;
1901     while (lightChain && lightChain->glIndex != -1) {
1902         glLightfv(GL_LIGHT0 + lightChain->glIndex, GL_POSITION, lightChain->lightPosn);
1903         checkGLcall("glLightfv posn");
1904         glLightfv(GL_LIGHT0 + lightChain->glIndex, GL_SPOT_DIRECTION, lightChain->lightDirn);
1905         checkGLcall("glLightfv dirn");
1906         lightChain = lightChain->next;
1907     }
1908
1909     /* Reset Clipping Planes if clipping is enabled. TODO: Call clipplane apply func */
1910     for (k = 0; k < GL_LIMITS(clipplanes); k++) {
1911         glClipPlane(GL_CLIP_PLANE0 + k, stateblock->clipplane[k]);
1912         checkGLcall("glClipPlane");
1913     }
1914
1915     if(stateblock->wineD3DDevice->last_was_rhw) {
1916         glLoadIdentity();
1917         checkGLcall("glLoadIdentity()");
1918         /* No need to update the world matrix, the identity is fine */
1919         return;
1920     }
1921
1922     /* Call the world matrix state, this will apply the combined WORLD + VIEW matrix
1923      * No need to do it here if the state is scheduled for update.
1924      */
1925     if(!isStateDirty(stateblock->wineD3DDevice, STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(0)))) {
1926         transform_world(STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(0)), stateblock);
1927     }
1928 }
1929
1930 static void transform_worldex(DWORD state, IWineD3DStateBlockImpl *stateBlock) {
1931         WARN("World matrix 1 - 255 not supported yet\n");
1932 }
1933
1934 static const GLfloat invymat[16] = {
1935     1.0f, 0.0f, 0.0f, 0.0f,
1936     0.0f, -1.0f, 0.0f, 0.0f,
1937     0.0f, 0.0f, 1.0f, 0.0f,
1938     0.0f, 0.0f, 0.0f, 1.0f};
1939
1940 static void transform_projection(DWORD state, IWineD3DStateBlockImpl *stateblock) {
1941     glMatrixMode(GL_PROJECTION);
1942     checkGLcall("glMatrixMode(GL_PROJECTION)");
1943     glLoadIdentity();
1944     checkGLcall("glLoadIdentity");
1945
1946     if(stateblock->wineD3DDevice->last_was_rhw) {
1947         double X, Y, height, width, minZ, maxZ;
1948
1949         X      = stateblock->viewport.X;
1950         Y      = stateblock->viewport.Y;
1951         height = stateblock->viewport.Height;
1952         width  = stateblock->viewport.Width;
1953         minZ   = stateblock->viewport.MinZ;
1954         maxZ   = stateblock->viewport.MaxZ;
1955
1956         if(!stateblock->wineD3DDevice->untransformed) {
1957             /* Transformed vertices are supposed to bypass the whole transform pipeline including
1958              * frustum clipping. This can't be done in opengl, so this code adjusts the Z range to
1959              * suppress depth clipping. This can be done because it is an orthogonal projection and
1960              * the Z coordinate does not affect the size of the primitives
1961              */
1962             TRACE("Calling glOrtho with %f, %f, %f, %f\n", width, height, -minZ, -maxZ);
1963             glOrtho(X, X + width, Y + height, Y, -minZ, -maxZ);
1964         } else {
1965             /* If the app mixes transformed and untransformed primitives we can't use the coordinate system
1966              * trick above because this would mess up transformed and untransformed Z order. Pass the z position
1967              * unmodified to opengl.
1968              *
1969              * If the app depends on mixed types and disabled clipping we're out of luck without a pipeline
1970              * replacement shader.
1971              */
1972             TRACE("Calling glOrtho with %f, %f, %f, %f\n", width, height, 1.0, -1.0);
1973             glOrtho(X, X + width, Y + height, Y, 1.0, -1.0);
1974         }
1975         checkGLcall("glOrtho");
1976
1977         /* Window Coord 0 is the middle of the first pixel, so translate by 3/8 pixels */
1978         glTranslatef(0.375, 0.375, 0);
1979         checkGLcall("glTranslatef(0.375, 0.375, 0)");
1980         /* D3D texture coordinates are flipped compared to OpenGL ones, so
1981          * render everything upside down when rendering offscreen. */
1982         if (stateblock->wineD3DDevice->render_offscreen) {
1983             glMultMatrixf(invymat);
1984             checkGLcall("glMultMatrixf(invymat)");
1985         }
1986     } else {
1987         /* The rule is that the window coordinate 0 does not correspond to the
1988             beginning of the first pixel, but the center of the first pixel.
1989             As a consequence if you want to correctly draw one line exactly from
1990             the left to the right end of the viewport (with all matrices set to
1991             be identity), the x coords of both ends of the line would be not
1992             -1 and 1 respectively but (-1-1/viewport_widh) and (1-1/viewport_width)
1993             instead.                                                               */
1994         glTranslatef(0.9 / stateblock->viewport.Width, -0.9 / stateblock->viewport.Height, 0);
1995         checkGLcall("glTranslatef (0.9 / width, -0.9 / height, 0)");
1996
1997         /* D3D texture coordinates are flipped compared to OpenGL ones, so
1998             * render everything upside down when rendering offscreen. */
1999         if (stateblock->wineD3DDevice->render_offscreen) {
2000             glMultMatrixf(invymat);
2001             checkGLcall("glMultMatrixf(invymat)");
2002         }
2003         glMultMatrixf((float *) &stateblock->transforms[WINED3DTS_PROJECTION].u.m[0][0]);
2004         checkGLcall("glLoadMatrixf");
2005     }
2006 }
2007
2008 /* Helper for vertexdeclaration() */
2009 static inline void handleStreams(IWineD3DStateBlockImpl *stateblock, BOOL useVertexShaderFunction) {
2010     IWineD3DDeviceImpl *device = stateblock->wineD3DDevice;
2011
2012     if(device->up_strided) {
2013         /* Note: this is a ddraw fixed-function code path */
2014         TRACE("================ Strided Input ===================\n");
2015         memcpy(&device->strided_streams, device->up_strided, sizeof(device->strided_streams));
2016     } else if (stateblock->vertexDecl || stateblock->vertexShader) {
2017         /* Note: This is a fixed function or shader codepath.
2018          * This means it must handle both types of strided data.
2019          * Shaders must go through here to zero the strided data, even if they
2020          * don't set any declaration at all
2021          */
2022         TRACE("================ Vertex Declaration  ===================\n");
2023         memset(&device->strided_streams, 0, sizeof(device->strided_streams));
2024
2025         if (stateblock->vertexDecl != NULL ||
2026             ((IWineD3DVertexShaderImpl *)stateblock->vertexShader)->vertexDeclaration != NULL) {
2027
2028             primitiveDeclarationConvertToStridedData((IWineD3DDevice *) device, useVertexShaderFunction,
2029                 &device->strided_streams, &device->streamFixedUp);
2030         }
2031     } else {
2032         /* Note: This codepath is not reachable from d3d9 (see fvf->decl9 conversion)
2033          * It is reachable through d3d8, but only for fixed-function.
2034          * It will not work properly for shaders.
2035          */
2036         TRACE("================ FVF ===================\n");
2037         memset(&device->strided_streams, 0, sizeof(device->strided_streams));
2038         primitiveConvertToStridedData((IWineD3DDevice *) device, &device->strided_streams,
2039                                                                            &device->streamFixedUp);
2040      }
2041 }
2042
2043 static void vertexdeclaration(DWORD state, IWineD3DStateBlockImpl *stateblock) {
2044     BOOL useVertexShaderFunction = FALSE, updateFog = FALSE;
2045     BOOL transformed;
2046     /* Some stuff is in the device until we have per context tracking */
2047     IWineD3DDeviceImpl *device = stateblock->wineD3DDevice;
2048     BOOL wasrhw = device->last_was_rhw;
2049
2050     device->streamFixedUp = FALSE;
2051
2052     /* Shaders can be implemented using ARB_PROGRAM, GLSL, or software -
2053      * here simply check whether a shader was set, or the user disabled shaders
2054      */
2055     if (device->vs_selected_mode != SHADER_NONE && stateblock->vertexShader &&
2056        ((IWineD3DVertexShaderImpl *)stateblock->vertexShader)->baseShader.function != NULL) {
2057         useVertexShaderFunction = TRUE;
2058
2059         if(((IWineD3DVertexShaderImpl *)stateblock->vertexShader)->usesFog != device->last_was_foggy_shader) {
2060             updateFog = TRUE;
2061         }
2062     } else if(device->last_was_foggy_shader) {
2063         updateFog = TRUE;
2064     }
2065
2066     handleStreams(stateblock, useVertexShaderFunction);
2067
2068     /* Do I have to use ? TRUE : FALSE ? Or can I rely on 15==15 beeing equal to TRUE(=1)? */
2069     transformed = ((device->strided_streams.u.s.position.lpData != NULL ||
2070                     device->strided_streams.u.s.position.VBO != 0) &&
2071                     device->strided_streams.u.s.position_transformed) ? TRUE : FALSE;
2072
2073     if(transformed != device->last_was_rhw && !useVertexShaderFunction) {
2074         updateFog = TRUE;
2075     }
2076
2077     /* Reapply lighting if it is not sheduled for reapplication already */
2078     if(!isStateDirty(device, STATE_RENDER(WINED3DRS_LIGHTING))) {
2079         state_lighting(STATE_RENDER(WINED3DRS_LIGHTING), stateblock);
2080     }
2081
2082     if (!useVertexShaderFunction && transformed) {
2083         stateblock->wineD3DDevice->last_was_rhw = TRUE;
2084     } else {
2085
2086         /* Untransformed, so relies on the view and projection matrices */
2087         device->last_was_rhw = FALSE;
2088         /* This turns off the Z scale trick to 'disable' viewport frustum clipping in rhw mode*/
2089         device->untransformed = TRUE;
2090
2091         /* Todo for sw shaders: Vertex Shader output is already transformed, so set up identity matrices
2092          * Not needed as long as only hw shaders are supported
2093          */
2094
2095         /* This sets the shader output position correction constants.
2096          * TODO: Move to the viewport state
2097          */
2098         if (useVertexShaderFunction) {
2099             device->posFixup[1] = device->render_offscreen ? -1.0 : 1.0;
2100         }
2101     }
2102
2103     /* Don't have to apply the matrices when vertex shaders are used. When vshaders are turned
2104      * off this function will be called again anyway to make sure they're properly set
2105      */
2106     if(!useVertexShaderFunction) {
2107         /* TODO: Move this mainly to the viewport state and only apply when the vp has changed
2108          * or transformed / untransformed was switched
2109          */
2110        if(wasrhw != device->last_was_rhw &&
2111           !isStateDirty(stateblock->wineD3DDevice, STATE_TRANSFORM(WINED3DTS_PROJECTION)) &&
2112           !isStateDirty(stateblock->wineD3DDevice, STATE_VIEWPORT)) {
2113             transform_projection(STATE_TRANSFORM(WINED3DTS_PROJECTION), stateblock);
2114         }
2115         /* World matrix needs reapplication here only if we're switching between rhw and non-rhw
2116          * mode.
2117          *
2118          * If a vertex shader is used, the world matrix changed and then vertex shader unbound
2119          * this check will fail and the matrix not applied again. This is OK because a simple
2120          * world matrix change reapplies the matrix - These checks here are only to satisfy the
2121          * needs of the vertex declaration.
2122          *
2123          * World and view matrix go into the same gl matrix, so only apply them when neither is
2124          * dirty
2125          */
2126         if(transformed != wasrhw &&
2127            !isStateDirty(stateblock->wineD3DDevice, STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(0))) &&
2128            !isStateDirty(stateblock->wineD3DDevice, STATE_TRANSFORM(WINED3DTS_VIEW))) {
2129             transform_world(STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(0)), stateblock);
2130         }
2131       }
2132
2133     if(updateFog) {
2134     state_fog(STATE_RENDER(WINED3DRS_FOGENABLE), stateblock);
2135     }
2136 }
2137
2138 static void viewport(DWORD state, IWineD3DStateBlockImpl *stateblock) {
2139     glDepthRange(stateblock->viewport.MinZ, stateblock->viewport.MaxZ);
2140     checkGLcall("glDepthRange");
2141     /* Note: GL requires lower left, DirectX supplies upper left */
2142     /* TODO: replace usage of renderTarget with context management */
2143     glViewport(stateblock->viewport.X,
2144                (((IWineD3DSurfaceImpl *)stateblock->wineD3DDevice->render_targets[0])->currentDesc.Height - (stateblock->viewport.Y + stateblock->viewport.Height)),
2145                stateblock->viewport.Width, stateblock->viewport.Height);
2146
2147     checkGLcall("glViewport");
2148
2149     stateblock->wineD3DDevice->posFixup[2] = 0.9 / stateblock->viewport.Width;
2150     stateblock->wineD3DDevice->posFixup[3] = -0.9 / stateblock->viewport.Height;
2151     if(!isStateDirty(stateblock->wineD3DDevice, STATE_TRANSFORM(D3DTS_PROJECTION))) {
2152         transform_projection(STATE_TRANSFORM(D3DTS_PROJECTION), stateblock);
2153     }
2154
2155 }
2156
2157 const struct StateEntry StateTable[] =
2158 {
2159       /* State name                                         representative,                                     apply function */
2160     { /* 0,  Undefined                              */      0,                                                  state_undefined     },
2161     { /* 1,  WINED3DRS_TEXTUREHANDLE                */      0 /* Handled in ddraw */,                           state_undefined     },
2162     { /* 2,  WINED3DRS_ANTIALIAS                    */      STATE_RENDER(WINED3DRS_ANTIALIAS),                  state_antialias     },
2163     { /* 3,  WINED3DRS_TEXTUREADDRESS               */      0 /* Handled in ddraw */,                           state_undefined     },
2164     { /* 4,  WINED3DRS_TEXTUREPERSPECTIVE           */      STATE_RENDER(WINED3DRS_TEXTUREPERSPECTIVE),         state_perspective   },
2165     { /* 5,  WINED3DRS_WRAPU                        */      STATE_RENDER(WINED3DRS_WRAPU),                      state_wrapu         },
2166     { /* 6,  WINED3DRS_WRAPV                        */      STATE_RENDER(WINED3DRS_WRAPV),                      state_wrapv         },
2167     { /* 7,  WINED3DRS_ZENABLE                      */      STATE_RENDER(WINED3DRS_ZENABLE),                    state_zenable       },
2168     { /* 8,  WINED3DRS_FILLMODE                     */      STATE_RENDER(WINED3DRS_FILLMODE),                   state_fillmode      },
2169     { /* 9,  WINED3DRS_SHADEMODE                    */      STATE_RENDER(WINED3DRS_SHADEMODE),                  state_shademode     },
2170     { /* 10, WINED3DRS_LINEPATTERN                  */      STATE_RENDER(WINED3DRS_LINEPATTERN),                state_linepattern   },
2171     { /* 11, WINED3DRS_MONOENABLE                   */      STATE_RENDER(WINED3DRS_MONOENABLE),                 state_monoenable    },
2172     { /* 12, WINED3DRS_ROP2                         */      STATE_RENDER(WINED3DRS_ROP2),                       state_rop2          },
2173     { /* 13, WINED3DRS_PLANEMASK                    */      STATE_RENDER(WINED3DRS_PLANEMASK),                  state_planemask     },
2174     { /* 14, WINED3DRS_ZWRITEENABLE                 */      STATE_RENDER(WINED3DRS_ZWRITEENABLE),               state_zwritenable   },
2175     { /* 15, WINED3DRS_ALPHATESTENABLE              */      STATE_RENDER(WINED3DRS_ALPHATESTENABLE),            state_alpha         },
2176     { /* 16, WINED3DRS_LASTPIXEL                    */      STATE_RENDER(WINED3DRS_LASTPIXEL),                  state_lastpixel     },
2177     { /* 17, WINED3DRS_TEXTUREMAG                   */      0 /* Handled in ddraw */,                           state_undefined     },
2178     { /* 18, WINED3DRS_TEXTUREMIN                   */      0 /* Handled in ddraw */,                           state_undefined     },
2179     { /* 19, WINED3DRS_SRCBLEND                     */      STATE_RENDER(WINED3DRS_ALPHABLENDENABLE),           state_blend         },
2180     { /* 20, WINED3DRS_DESTBLEND                    */      STATE_RENDER(WINED3DRS_ALPHABLENDENABLE),           state_blend         },
2181     { /* 21, WINED3DRS_TEXTUREMAPBLEND              */      0 /* Handled in ddraw */,                           state_undefined     },
2182     { /* 22, WINED3DRS_CULLMODE                     */      STATE_RENDER(WINED3DRS_CULLMODE),                   state_cullmode      },
2183     { /* 23, WINED3DRS_ZFUNC                        */      STATE_RENDER(WINED3DRS_ZFUNC),                      state_zfunc         },
2184     { /* 24, WINED3DRS_ALPHAREF                     */      STATE_RENDER(WINED3DRS_ALPHATESTENABLE),            state_alpha         },
2185     { /* 25, WINED3DRS_ALPHAFUNC                    */      STATE_RENDER(WINED3DRS_ALPHATESTENABLE),            state_alpha         },
2186     { /* 26, WINED3DRS_DITHERENABLE                 */      STATE_RENDER(WINED3DRS_DITHERENABLE),               state_ditherenable  },
2187     { /* 27, WINED3DRS_ALPHABLENDENABLE             */      STATE_RENDER(WINED3DRS_ALPHABLENDENABLE),           state_blend         },
2188     { /* 28, WINED3DRS_FOGENABLE                    */      STATE_RENDER(WINED3DRS_FOGENABLE),                  state_fog           },
2189     { /* 29, WINED3DRS_SPECULARENABLE               */      STATE_RENDER(WINED3DRS_SPECULARENABLE),             state_specularenable},
2190     { /* 30, WINED3DRS_ZVISIBLE                     */      0 /* Not supported according to the msdn */,        state_nogl          },
2191     { /* 31, WINED3DRS_SUBPIXEL                     */      STATE_RENDER(WINED3DRS_SUBPIXEL),                   state_subpixel      },
2192     { /* 32, WINED3DRS_SUBPIXELX                    */      STATE_RENDER(WINED3DRS_SUBPIXELX),                  state_subpixelx     },
2193     { /* 33, WINED3DRS_STIPPLEDALPHA                */      STATE_RENDER(WINED3DRS_STIPPLEDALPHA),              state_stippledalpha },
2194     { /* 34, WINED3DRS_FOGCOLOR                     */      STATE_RENDER(WINED3DRS_FOGCOLOR),                   state_fogcolor      },
2195     { /* 35, WINED3DRS_FOGTABLEMODE                 */      STATE_RENDER(WINED3DRS_FOGENABLE),                  state_fog           },
2196     { /* 36, WINED3DRS_FOGSTART                     */      STATE_RENDER(WINED3DRS_FOGENABLE),                  state_fog           },
2197     { /* 37, WINED3DRS_FOGEND                       */      STATE_RENDER(WINED3DRS_FOGENABLE),                  state_fog           },
2198     { /* 38, WINED3DRS_FOGDENSITY                   */      STATE_RENDER(WINED3DRS_FOGDENSITY),                 state_fogdensity    },
2199     { /* 39, WINED3DRS_STIPPLEENABLE                */      STATE_RENDER(WINED3DRS_STIPPLEENABLE),              state_stippleenable },
2200     { /* 40, WINED3DRS_EDGEANTIALIAS                */      STATE_RENDER(WINED3DRS_ALPHABLENDENABLE),           state_blend         },
2201     { /* 41, WINED3DRS_COLORKEYENABLE               */      STATE_RENDER(WINED3DRS_ALPHATESTENABLE),            state_alpha         },
2202     { /* 42, undefined                              */      0,                                                  state_undefined     },
2203     { /* 43, WINED3DRS_BORDERCOLOR                  */      STATE_RENDER(WINED3DRS_BORDERCOLOR),                state_bordercolor   },
2204     { /* 44, WINED3DRS_TEXTUREADDRESSU              */      0, /* Handled in ddraw */                           state_undefined     },
2205     { /* 45, WINED3DRS_TEXTUREADDRESSV              */      0, /* Handled in ddraw */                           state_undefined     },
2206     { /* 46, WINED3DRS_MIPMAPLODBIAS                */      STATE_RENDER(WINED3DRS_MIPMAPLODBIAS),              state_mipmaplodbias },
2207     { /* 47, WINED3DRS_ZBIAS                        */      STATE_RENDER(WINED3DRS_ZBIAS),                      state_zbias         },
2208     { /* 48, WINED3DRS_RANGEFOGENABLE               */      0,                                                  state_nogl          },
2209     { /* 49, WINED3DRS_ANISOTROPY                   */      STATE_RENDER(WINED3DRS_ANISOTROPY),                 state_anisotropy    },
2210     { /* 50, WINED3DRS_FLUSHBATCH                   */      STATE_RENDER(WINED3DRS_FLUSHBATCH),                 state_flushbatch    },
2211     { /* 51, WINED3DRS_TRANSLUCENTSORTINDEPENDENT   */      STATE_RENDER(WINED3DRS_TRANSLUCENTSORTINDEPENDENT), state_translucentsi },
2212     { /* 52, WINED3DRS_STENCILENABLE                */      STATE_RENDER(WINED3DRS_STENCILENABLE),              state_stencil       },
2213     { /* 53, WINED3DRS_STENCILFAIL                  */      STATE_RENDER(WINED3DRS_STENCILENABLE),              state_stencil       },
2214     { /* 54, WINED3DRS_STENCILZFAIL                 */      STATE_RENDER(WINED3DRS_STENCILENABLE),              state_stencil       },
2215     { /* 55, WINED3DRS_STENCILPASS                  */      STATE_RENDER(WINED3DRS_STENCILENABLE),              state_stencil       },
2216     { /* 56, WINED3DRS_STENCILFUNC                  */      STATE_RENDER(WINED3DRS_STENCILENABLE),              state_stencil       },
2217     { /* 57, WINED3DRS_STENCILREF                   */      STATE_RENDER(WINED3DRS_STENCILENABLE),              state_stencil       },
2218     { /* 58, WINED3DRS_STENCILMASK                  */      STATE_RENDER(WINED3DRS_STENCILENABLE),              state_stencil       },
2219     { /* 59, WINED3DRS_STENCILWRITEMASK             */      STATE_RENDER(WINED3DRS_STENCILWRITEMASK),           state_stencilwrite  },
2220     { /* 60, WINED3DRS_TEXTUREFACTOR                */      STATE_RENDER(WINED3DRS_TEXTUREFACTOR),              state_texfactor     },
2221     { /* 61, Undefined                              */      0,                                                  state_undefined     },
2222     { /* 62, Undefined                              */      0,                                                  state_undefined     },
2223     { /* 63, Undefined                              */      0,                                                  state_undefined     },
2224     { /* 64, WINED3DRS_STIPPLEPATTERN00             */      0 /* Obsolete, should be handled by ddraw */,       state_undefined     },
2225     { /* 65, WINED3DRS_STIPPLEPATTERN01             */      0 /* Obsolete, should he handled by ddraw */,       state_undefined     },
2226     { /* 66, WINED3DRS_STIPPLEPATTERN02             */      0 /* Obsolete, should be handled by ddraw */,       state_undefined     },
2227     { /* 67, WINED3DRS_STIPPLEPATTERN03             */      0 /* Obsolete, should be handled by ddraw */,       state_undefined     },
2228     { /* 68, WINED3DRS_STIPPLEPATTERN04             */      0 /* Obsolete, should be handled by ddraw */,       state_undefined     },
2229     { /* 69, WINED3DRS_STIPPLEPATTERN05             */      0 /* Obsolete, should be handled by ddraw */,       state_undefined     },
2230     { /* 70, WINED3DRS_STIPPLEPATTERN06             */      0 /* Obsolete, should be handled by ddraw */,       state_undefined     },
2231     { /* 71, WINED3DRS_STIPPLEPATTERN07             */      0 /* Obsolete, should be handled by ddraw */,       state_undefined     },
2232     { /* 72, WINED3DRS_STIPPLEPATTERN08             */      0 /* Obsolete, should be handled by ddraw */,       state_undefined     },
2233     { /* 73, WINED3DRS_STIPPLEPATTERN09             */      0 /* Obsolete, should be handled by ddraw */,       state_undefined     },
2234     { /* 74, WINED3DRS_STIPPLEPATTERN10             */      0 /* Obsolete, should be handled by ddraw */,       state_undefined     },
2235     { /* 75, WINED3DRS_STIPPLEPATTERN11             */      0 /* Obsolete, should be handled by ddraw */,       state_undefined     },
2236     { /* 76, WINED3DRS_STIPPLEPATTERN12             */      0 /* Obsolete, should be handled by ddraw */,       state_undefined     },
2237     { /* 77, WINED3DRS_STIPPLEPATTERN13             */      0 /* Obsolete, should be handled by ddraw */,       state_undefined     },
2238     { /* 78, WINED3DRS_STIPPLEPATTERN14             */      0 /* Obsolete, should be handled by ddraw */,       state_undefined     },
2239     { /* 79, WINED3DRS_STIPPLEPATTERN15             */      0 /* Obsolete, should be handled by ddraw */,       state_undefined     },
2240     { /* 80, WINED3DRS_STIPPLEPATTERN16             */      0 /* Obsolete, should be handled by ddraw */,       state_undefined     },
2241     { /* 81, WINED3DRS_STIPPLEPATTERN17             */      0 /* Obsolete, should be handled by ddraw */,       state_undefined     },
2242     { /* 82, WINED3DRS_STIPPLEPATTERN18             */      0 /* Obsolete, should be handled by ddraw */,       state_undefined     },
2243     { /* 83, WINED3DRS_STIPPLEPATTERN19             */      0 /* Obsolete, should be handled by ddraw */,       state_undefined     },
2244     { /* 84, WINED3DRS_STIPPLEPATTERN20             */      0 /* Obsolete, should be handled by ddraw */,       state_undefined     },
2245     { /* 85, WINED3DRS_STIPPLEPATTERN21             */      0 /* Obsolete, should be handled by ddraw */,       state_undefined     },
2246     { /* 86, WINED3DRS_STIPPLEPATTERN22             */      0 /* Obsolete, should be handled by ddraw */,       state_undefined     },
2247     { /* 87, WINED3DRS_STIPPLEPATTERN23             */      0 /* Obsolete, should be handled by ddraw */,       state_undefined     },
2248     { /* 88, WINED3DRS_STIPPLEPATTERN24             */      0 /* Obsolete, should be handled by ddraw */,       state_undefined     },
2249     { /* 89, WINED3DRS_STIPPLEPATTERN25             */      0 /* Obsolete, should be handled by ddraw */,       state_undefined     },
2250     { /* 90, WINED3DRS_STIPPLEPATTERN26             */      0 /* Obsolete, should be handled by ddraw */,       state_undefined     },
2251     { /* 91, WINED3DRS_STIPPLEPATTERN27             */      0 /* Obsolete, should be handled by ddraw */,       state_undefined     },
2252     { /* 92, WINED3DRS_STIPPLEPATTERN28             */      0 /* Obsolete, should be handled by ddraw */,       state_undefined     },
2253     { /* 93, WINED3DRS_STIPPLEPATTERN29             */      0 /* Obsolete, should be handled by ddraw */,       state_undefined     },
2254     { /* 94, WINED3DRS_STIPPLEPATTERN30             */      0 /* Obsolete, should be handled by ddraw */,       state_undefined     },
2255     { /* 95, WINED3DRS_STIPPLEPATTERN31             */      0 /* Obsolete, should be handled by ddraw */,       state_undefined     },
2256     { /* 96, Undefined                              */      0,                                                  state_undefined     },
2257     { /* 97, Undefined                              */      0,                                                  state_undefined     },
2258     { /* 98, Undefined                              */      0,                                                  state_undefined     },
2259     { /* 99, Undefined                              */      0,                                                  state_undefined     },
2260     { /*100, Undefined                              */      0,                                                  state_undefined     },
2261     { /*101, Undefined                              */      0,                                                  state_undefined     },
2262     { /*102, Undefined                              */      0,                                                  state_undefined     },
2263     { /*103, Undefined                              */      0,                                                  state_undefined     },
2264     { /*104, Undefined                              */      0,                                                  state_undefined     },
2265     { /*105, Undefined                              */      0,                                                  state_undefined     },
2266     { /*106, Undefined                              */      0,                                                  state_undefined     },
2267     { /*107, Undefined                              */      0,                                                  state_undefined     },
2268     { /*108, Undefined                              */      0,                                                  state_undefined     },
2269     { /*109, Undefined                              */      0,                                                  state_undefined     },
2270     { /*110, Undefined                              */      0,                                                  state_undefined     },
2271     { /*111, Undefined                              */      0,                                                  state_undefined     },
2272     { /*112, Undefined                              */      0,                                                  state_undefined     },
2273     { /*113, Undefined                              */      0,                                                  state_undefined     },
2274     { /*114, Undefined                              */      0,                                                  state_undefined     },
2275     { /*115, Undefined                              */      0,                                                  state_undefined     },
2276     { /*116, Undefined                              */      0,                                                  state_undefined     },
2277     { /*117, Undefined                              */      0,                                                  state_undefined     },
2278     { /*118, Undefined                              */      0,                                                  state_undefined     },
2279     { /*119, Undefined                              */      0,                                                  state_undefined     },
2280     { /*120, Undefined                              */      0,                                                  state_undefined     },
2281     { /*121, Undefined                              */      0,                                                  state_undefined     },
2282     { /*122, Undefined                              */      0,                                                  state_undefined     },
2283     { /*123, Undefined                              */      0,                                                  state_undefined     },
2284     { /*124, Undefined                              */      0,                                                  state_undefined     },
2285     { /*125, Undefined                              */      0,                                                  state_undefined     },
2286     { /*126, Undefined                              */      0,                                                  state_undefined     },
2287     { /*127, Undefined                              */      0,                                                  state_undefined     },
2288     /* Big hole ends */
2289     { /*128, WINED3DRS_WRAP0                        */      STATE_RENDER(WINED3DRS_WRAP0),                      state_wrap          },
2290     { /*129, WINED3DRS_WRAP1                        */      STATE_RENDER(WINED3DRS_WRAP0),                      state_wrap          },
2291     { /*130, WINED3DRS_WRAP2                        */      STATE_RENDER(WINED3DRS_WRAP0),                      state_wrap          },
2292     { /*131, WINED3DRS_WRAP3                        */      STATE_RENDER(WINED3DRS_WRAP0),                      state_wrap          },
2293     { /*132, WINED3DRS_WRAP4                        */      STATE_RENDER(WINED3DRS_WRAP0),                      state_wrap          },
2294     { /*133, WINED3DRS_WRAP5                        */      STATE_RENDER(WINED3DRS_WRAP0),                      state_wrap          },
2295     { /*134, WINED3DRS_WRAP6                        */      STATE_RENDER(WINED3DRS_WRAP0),                      state_wrap          },
2296     { /*135, WINED3DRS_WRAP7                        */      STATE_RENDER(WINED3DRS_WRAP0),                      state_wrap          },
2297     { /*136, WINED3DRS_CLIPPING                     */      STATE_RENDER(WINED3DRS_CLIPPING),                   state_clipping      },
2298     { /*137, WINED3DRS_LIGHTING                     */      STATE_RENDER(WINED3DRS_LIGHTING),                   state_lighting      },
2299     { /*138, WINED3DRS_EXTENTS                      */      STATE_RENDER(WINED3DRS_EXTENTS),                    state_extents       },
2300     { /*139, WINED3DRS_AMBIENT                      */      STATE_RENDER(WINED3DRS_AMBIENT),                    state_ambient       },
2301     { /*140, WINED3DRS_FOGVERTEXMODE                */      STATE_RENDER(WINED3DRS_FOGENABLE),                  state_fog           },
2302     { /*141, WINED3DRS_COLORVERTEX                  */      STATE_RENDER(WINED3DRS_COLORVERTEX),                state_colormat      },
2303     { /*142, WINED3DRS_LOCALVIEWER                  */      STATE_RENDER(WINED3DRS_LOCALVIEWER),                state_localviewer   },
2304     { /*143, WINED3DRS_NORMALIZENORMALS             */      STATE_RENDER(WINED3DRS_NORMALIZENORMALS),           state_normalize     },
2305     { /*144, WINED3DRS_COLORKEYBLENDENABLE          */      STATE_RENDER(WINED3DRS_COLORKEYBLENDENABLE),        state_ckeyblend     },
2306     { /*145, WINED3DRS_DIFFUSEMATERIALSOURCE        */      STATE_RENDER(WINED3DRS_COLORVERTEX),                state_colormat      },
2307     { /*146, WINED3DRS_SPECULARMATERIALSOURCE       */      STATE_RENDER(WINED3DRS_COLORVERTEX),                state_colormat      },
2308     { /*147, WINED3DRS_AMBIENTMATERIALSOURCE        */      STATE_RENDER(WINED3DRS_COLORVERTEX),                state_colormat      },
2309     { /*148, WINED3DRS_EMISSIVEMATERIALSOURCE       */      STATE_RENDER(WINED3DRS_COLORVERTEX),                state_colormat      },
2310     { /*149, Undefined                              */      0,                                                  state_undefined     },
2311     { /*150, Undefined                              */      0,                                                  state_undefined     },
2312     { /*151, WINED3DRS_VERTEXBLEND                  */      0,                                                  state_nogl          },
2313     { /*152, WINED3DRS_CLIPPLANEENABLE              */      STATE_RENDER(WINED3DRS_CLIPPING),                   state_clipping      },
2314     { /*153, WINED3DRS_SOFTWAREVERTEXPROCESSING     */      0,                                                  state_nogl          },
2315     { /*154, WINED3DRS_POINTSIZE                    */      STATE_RENDER(WINED3DRS_POINTSIZE),                  state_psize         },
2316     { /*155, WINED3DRS_POINTSIZE_MIN                */      STATE_RENDER(WINED3DRS_POINTSIZE_MIN),              state_psizemin      },
2317     { /*156, WINED3DRS_POINTSPRITEENABLE            */      STATE_RENDER(WINED3DRS_POINTSPRITEENABLE),          state_pointsprite   },
2318     { /*157, WINED3DRS_POINTSCALEENABLE             */      STATE_RENDER(WINED3DRS_POINTSCALEENABLE),           state_pscale        },
2319     { /*158, WINED3DRS_POINTSCALE_A                 */      STATE_RENDER(WINED3DRS_POINTSCALEENABLE),           state_pscale        },
2320     { /*159, WINED3DRS_POINTSCALE_B                 */      STATE_RENDER(WINED3DRS_POINTSCALEENABLE),           state_pscale        },
2321     { /*160, WINED3DRS_POINTSCALE_C                 */      STATE_RENDER(WINED3DRS_POINTSCALEENABLE),           state_pscale        },
2322     { /*161, WINED3DRS_MULTISAMPLEANTIALIAS         */      STATE_RENDER(WINED3DRS_MULTISAMPLEANTIALIAS),       state_multisampleaa },
2323     { /*162, WINED3DRS_MULTISAMPLEMASK              */      STATE_RENDER(WINED3DRS_MULTISAMPLEMASK),            state_multisampmask },
2324     { /*163, WINED3DRS_PATCHEDGESTYLE               */      STATE_RENDER(WINED3DRS_PATCHEDGESTYLE),             state_patchedgestyle},
2325     { /*164, WINED3DRS_PATCHSEGMENTS                */      STATE_RENDER(WINED3DRS_PATCHSEGMENTS),              state_patchsegments },
2326     { /*165, WINED3DRS_DEBUGMONITORTOKEN            */      STATE_RENDER(WINED3DRS_DEBUGMONITORTOKEN),          state_nogl          },
2327     { /*166, WINED3DRS_POINTSIZE_MAX                */      STATE_RENDER(WINED3DRS_POINTSIZE_MAX),              state_psizemax      },
2328     { /*167, WINED3DRS_INDEXEDVERTEXBLENDENABLE     */      0,                                                  state_nogl          },
2329     { /*168, WINED3DRS_COLORWRITEENABLE             */      STATE_RENDER(WINED3DRS_COLORWRITEENABLE),           state_colorwrite    },
2330     { /*169, Undefined                              */      0,                                                  state_undefined     },
2331     { /*170, WINED3DRS_TWEENFACTOR                  */      0,                                                  state_nogl          },
2332     { /*171, WINED3DRS_BLENDOP                      */      STATE_RENDER(WINED3DRS_BLENDOP),                    state_blendop       },
2333     { /*172, WINED3DRS_POSITIONDEGREE               */      STATE_RENDER(WINED3DRS_POSITIONDEGREE),             state_positiondegree},
2334     { /*173, WINED3DRS_NORMALDEGREE                 */      STATE_RENDER(WINED3DRS_NORMALDEGREE),               state_normaldegree  },
2335       /*172, WINED3DRS_POSITIONORDER                */      /* Value assigned to 2 state names */
2336       /*173, WINED3DRS_NORMALORDER                  */      /* Value assigned to 2 state names */
2337     { /*174, WINED3DRS_SCISSORTESTENABLE            */      STATE_RENDER(WINED3DRS_SCISSORTESTENABLE),          state_scissor       },
2338     { /*175, WINED3DRS_SLOPESCALEDEPTHBIAS          */      STATE_RENDER(WINED3DRS_DEPTHBIAS),                  state_depthbias     },
2339     { /*176, WINED3DRS_ANTIALIASEDLINEENABLE        */      STATE_RENDER(WINED3DRS_ALPHABLENDENABLE),           state_blend         },
2340     { /*177, undefined                              */      0,                                                  state_undefined     },
2341     { /*178, WINED3DRS_MINTESSELLATIONLEVEL         */      STATE_RENDER(WINED3DRS_ENABLEADAPTIVETESSELLATION), state_tessellation  },
2342     { /*179, WINED3DRS_MAXTESSELLATIONLEVEL         */      STATE_RENDER(WINED3DRS_ENABLEADAPTIVETESSELLATION), state_tessellation  },
2343     { /*180, WINED3DRS_ADAPTIVETESS_X               */      STATE_RENDER(WINED3DRS_ENABLEADAPTIVETESSELLATION), state_tessellation  },
2344     { /*181, WINED3DRS_ADAPTIVETESS_Y               */      STATE_RENDER(WINED3DRS_ENABLEADAPTIVETESSELLATION), state_tessellation  },
2345     { /*182, WINED3DRS_ADAPTIVETESS_Z               */      STATE_RENDER(WINED3DRS_ENABLEADAPTIVETESSELLATION), state_tessellation  },
2346     { /*183, WINED3DRS_ADAPTIVETESS_W               */      STATE_RENDER(WINED3DRS_ENABLEADAPTIVETESSELLATION), state_tessellation  },
2347     { /*184, WINED3DRS_ENABLEADAPTIVETESSELLATION   */      STATE_RENDER(WINED3DRS_ENABLEADAPTIVETESSELLATION), state_tessellation  },
2348     { /*185, WINED3DRS_TWOSIDEDSTENCILMODE          */      STATE_RENDER(WINED3DRS_STENCILENABLE),              state_stencil       },
2349     { /*186, WINED3DRS_CCW_STENCILFAIL              */      STATE_RENDER(WINED3DRS_STENCILENABLE),              state_stencil       },
2350     { /*187, WINED3DRS_CCW_STENCILZFAIL             */      STATE_RENDER(WINED3DRS_STENCILENABLE),              state_stencil       },
2351     { /*188, WINED3DRS_CCW_STENCILPASS              */      STATE_RENDER(WINED3DRS_STENCILENABLE),              state_stencil       },
2352     { /*189, WINED3DRS_CCW_STENCILFUNC              */      STATE_RENDER(WINED3DRS_STENCILENABLE),              state_stencil       },
2353     { /*190, WINED3DRS_COLORWRITEENABLE1            */      STATE_RENDER(WINED3DRS_COLORWRITEENABLE),           state_colorwrite    },
2354     { /*191, WINED3DRS_COLORWRITEENABLE2            */      STATE_RENDER(WINED3DRS_COLORWRITEENABLE),           state_colorwrite    },
2355     { /*192, WINED3DRS_COLORWRITEENABLE3            */      STATE_RENDER(WINED3DRS_COLORWRITEENABLE),           state_colorwrite    },
2356     { /*193, WINED3DRS_BLENDFACTOR                  */      STATE_RENDER(WINED3DRS_BLENDFACTOR),                state_blendfactor   },
2357     { /*194, WINED3DRS_SRGBWRITEENABLE              */      STATE_RENDER(WINED3DRS_SRGBWRITEENABLE),            state_srgbwrite     },
2358     { /*195, WINED3DRS_DEPTHBIAS                    */      STATE_RENDER(WINED3DRS_DEPTHBIAS),                  state_depthbias     },
2359     { /*196, undefined                              */      0,                                                  state_undefined     },
2360     { /*197, undefined                              */      0,                                                  state_undefined     },
2361     { /*198, WINED3DRS_WRAP8                        */      STATE_RENDER(WINED3DRS_WRAP0),                      state_wrap          },
2362     { /*199, WINED3DRS_WRAP9                        */      STATE_RENDER(WINED3DRS_WRAP0),                      state_wrap          },
2363     { /*200, WINED3DRS_WRAP10                       */      STATE_RENDER(WINED3DRS_WRAP0),                      state_wrap          },
2364     { /*201, WINED3DRS_WRAP11                       */      STATE_RENDER(WINED3DRS_WRAP0),                      state_wrap          },
2365     { /*202, WINED3DRS_WRAP12                       */      STATE_RENDER(WINED3DRS_WRAP0),                      state_wrap          },
2366     { /*203, WINED3DRS_WRAP13                       */      STATE_RENDER(WINED3DRS_WRAP0),                      state_wrap          },
2367     { /*204, WINED3DRS_WRAP14                       */      STATE_RENDER(WINED3DRS_WRAP0),                      state_wrap          },
2368     { /*205, WINED3DRS_WRAP15                       */      STATE_RENDER(WINED3DRS_WRAP0),                      state_wrap          },
2369     { /*206, WINED3DRS_SEPARATEALPHABLENDENABLE     */      STATE_RENDER(WINED3DRS_SEPARATEALPHABLENDENABLE),   state_seperateblend },
2370     { /*207, WINED3DRS_SRCBLENDALPHA                */      STATE_RENDER(WINED3DRS_SEPARATEALPHABLENDENABLE),   state_seperateblend },
2371     { /*208, WINED3DRS_DESTBLENDALPHA               */      STATE_RENDER(WINED3DRS_SEPARATEALPHABLENDENABLE),   state_seperateblend },
2372     { /*209, WINED3DRS_BLENDOPALPHA                 */      STATE_RENDER(WINED3DRS_SEPARATEALPHABLENDENABLE),   state_seperateblend },
2373     /* Texture stage states */
2374     { /*0, 01, WINED3DTSS_COLOROP                   */      STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP),          tex_colorop         },
2375     { /*0, 02, WINED3DTSS_COLORARG1                 */      STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP),          tex_colorop         },
2376     { /*0, 03, WINED3DTSS_COLORARG2                 */      STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP),          tex_colorop         },
2377     { /*0, 04, WINED3DTSS_ALPHAOP                   */      STATE_TEXTURESTAGE(0, WINED3DTSS_ALPHAOP),          tex_alphaop         },
2378     { /*0, 05, WINED3DTSS_ALPHAARG1                 */      STATE_TEXTURESTAGE(0, WINED3DTSS_ALPHAOP),          tex_alphaop         },
2379     { /*0, 06, WINED3DTSS_ALPHAARG2                 */      STATE_TEXTURESTAGE(0, WINED3DTSS_ALPHAOP),          tex_alphaop         },
2380     { /*0, 07, WINED3DTSS_BUMPENVMAT00              */      STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP),          tex_colorop         },
2381     { /*0, 08, WINED3DTSS_BUMPENVMAT01              */      STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP),          tex_colorop         },
2382     { /*0, 09, WINED3DTSS_BUMPENVMAT10              */      STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP),          tex_colorop         },
2383     { /*0, 10, WINED3DTSS_BUMPENVMAT11              */      STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP),          tex_colorop         },
2384     { /*0, 11, WINED3DTSS_TEXCOORDINDEX             */      STATE_TEXTURESTAGE(0, WINED3DTSS_TEXCOORDINDEX),    tex_coordindex      },
2385     { /*0, 12, WINED3DTSS_ADDRESS                   */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
2386     { /*0, 13, WINED3DTSS_ADDRESSU                  */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
2387     { /*0, 14, WINED3DTSS_ADDRESSV                  */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
2388     { /*0, 15, WINED3DTSS_BORDERCOLOR               */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
2389     { /*0, 16, WINED3DTSS_MAGFILTER                 */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
2390     { /*0, 17, WINED3DTSS_MINFILTER                 */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
2391     { /*0, 18, WINED3DTSS_MIPFILTER                 */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
2392     { /*0, 19, WINED3DTSS_MIPMAPLODBIAS             */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
2393     { /*0, 20, WINED3DTSS_MAXMIPLEVEL               */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
2394     { /*0, 21, WINED3DTSS_MAXANISOTROPY             */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
2395     { /*0, 22, WINED3DTSS_BUMPENVLSCALE             */      STATE_TEXTURESTAGE(0, WINED3DTSS_BUMPENVLSCALE),    tex_bumpenvlscale   },
2396     { /*0, 23, WINED3DTSS_BUMPENVLOFFSET            */      STATE_TEXTURESTAGE(0, WINED3DTSS_BUMPENVLOFFSET),   tex_bumpenvloffset  },
2397     { /*0, 24, WINED3DTSS_TEXTURETRANSFORMFLAGS     */      STATE_TRANSFORM(WINED3DTS_TEXTURE0),                transform_texture   },
2398     { /*0, 25, WINED3DTSS_ADDRESSW                  */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
2399     { /*0, 26, WINED3DTSS_COLORARG0                 */      STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP),          tex_colorop         },
2400     { /*0, 27, WINED3DTSS_ALPHAARG0                 */      STATE_TEXTURESTAGE(0, WINED3DTSS_ALPHAOP),          tex_alphaop         },
2401     { /*0, 28, WINED3DTSS_RESULTARG                 */      STATE_TEXTURESTAGE(0, WINED3DTSS_RESULTARG),        tex_resultarg       },
2402     { /*0, 29, undefined                            */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
2403     { /*0, 30, undefined                            */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
2404     { /*0, 31, undefined                            */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
2405     { /*0, 32, WINED3DTSS_CONSTANT                  */      0 /* As long as we don't support D3DTA_CONSTANT */, state_nogl          },
2406
2407     { /*1, 01, WINED3DTSS_COLOROP                   */      STATE_TEXTURESTAGE(1, WINED3DTSS_COLOROP),          tex_colorop         },
2408     { /*1, 02, WINED3DTSS_COLORARG1                 */      STATE_TEXTURESTAGE(1, WINED3DTSS_COLOROP),          tex_colorop         },
2409     { /*1, 03, WINED3DTSS_COLORARG2                 */      STATE_TEXTURESTAGE(1, WINED3DTSS_COLOROP),          tex_colorop         },
2410     { /*1, 04, WINED3DTSS_ALPHAOP                   */      STATE_TEXTURESTAGE(1, WINED3DTSS_ALPHAOP),          tex_alphaop         },
2411     { /*1, 05, WINED3DTSS_ALPHAARG1                 */      STATE_TEXTURESTAGE(1, WINED3DTSS_ALPHAOP),          tex_alphaop         },
2412     { /*1, 06, WINED3DTSS_ALPHAARG2                 */      STATE_TEXTURESTAGE(1, WINED3DTSS_ALPHAOP),          tex_alphaop         },
2413     { /*1, 07, WINED3DTSS_BUMPENVMAT00              */      STATE_TEXTURESTAGE(1, WINED3DTSS_COLOROP),          tex_colorop         },
2414     { /*1, 08, WINED3DTSS_BUMPENVMAT01              */      STATE_TEXTURESTAGE(1, WINED3DTSS_COLOROP),          tex_colorop         },
2415     { /*1, 09, WINED3DTSS_BUMPENVMAT10              */      STATE_TEXTURESTAGE(1, WINED3DTSS_COLOROP),          tex_colorop         },
2416     { /*1, 10, WINED3DTSS_BUMPENVMAT11              */      STATE_TEXTURESTAGE(1, WINED3DTSS_COLOROP),          tex_colorop         },
2417     { /*1, 11, WINED3DTSS_TEXCOORDINDEX             */      STATE_TEXTURESTAGE(1, WINED3DTSS_TEXCOORDINDEX),    tex_coordindex      },
2418     { /*1, 12, WINED3DTSS_ADDRESS                   */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
2419     { /*1, 13, WINED3DTSS_ADDRESSU                  */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
2420     { /*1, 14, WINED3DTSS_ADDRESSV                  */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
2421     { /*1, 15, WINED3DTSS_BORDERCOLOR               */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
2422     { /*1, 16, WINED3DTSS_MAGFILTER                 */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
2423     { /*1, 17, WINED3DTSS_MINFILTER                 */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
2424     { /*1, 18, WINED3DTSS_MIPFILTER                 */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
2425     { /*1, 19, WINED3DTSS_MIPMAPLODBIAS             */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
2426     { /*1, 20, WINED3DTSS_MAXMIPLEVEL               */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
2427     { /*1, 21, WINED3DTSS_MAXANISOTROPY             */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
2428     { /*1, 22, WINED3DTSS_BUMPENVLSCALE             */      STATE_TEXTURESTAGE(1, WINED3DTSS_BUMPENVLSCALE),    tex_bumpenvlscale   },
2429     { /*1, 23, WINED3DTSS_BUMPENVLOFFSET            */      STATE_TEXTURESTAGE(1, WINED3DTSS_BUMPENVLOFFSET),   tex_bumpenvloffset  },
2430     { /*1, 24, WINED3DTSS_TEXTURETRANSFORMFLAGS     */      STATE_TRANSFORM(WINED3DTS_TEXTURE1),                transform_texture   },
2431     { /*1, 25, WINED3DTSS_ADDRESSW                  */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
2432     { /*1, 26, WINED3DTSS_COLORARG0                 */      STATE_TEXTURESTAGE(1, WINED3DTSS_COLOROP),          tex_colorop         },
2433     { /*1, 27, WINED3DTSS_ALPHAARG0                 */      STATE_TEXTURESTAGE(1, WINED3DTSS_ALPHAOP),          tex_alphaop         },
2434     { /*1, 28, WINED3DTSS_RESULTARG                 */      STATE_TEXTURESTAGE(1, WINED3DTSS_RESULTARG),        tex_resultarg       },
2435     { /*1, 29, undefined                            */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
2436     { /*1, 30, undefined                            */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
2437     { /*1, 31, undefined                            */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
2438     { /*1, 32, WINED3DTSS_CONSTANT                  */      0 /* As long as we don't support D3DTA_CONSTANT */, state_nogl          },
2439
2440     { /*2, 01, WINED3DTSS_COLOROP                   */      STATE_TEXTURESTAGE(2, WINED3DTSS_COLOROP),          tex_colorop         },
2441     { /*2, 02, WINED3DTSS_COLORARG1                 */      STATE_TEXTURESTAGE(2, WINED3DTSS_COLOROP),          tex_colorop         },
2442     { /*2, 03, WINED3DTSS_COLORARG2                 */      STATE_TEXTURESTAGE(2, WINED3DTSS_COLOROP),          tex_colorop         },
2443     { /*2, 04, WINED3DTSS_ALPHAOP                   */      STATE_TEXTURESTAGE(2, WINED3DTSS_ALPHAOP),          tex_alphaop         },
2444     { /*2, 05, WINED3DTSS_ALPHAARG1                 */      STATE_TEXTURESTAGE(2, WINED3DTSS_ALPHAOP),          tex_alphaop         },
2445     { /*2, 06, WINED3DTSS_ALPHAARG2                 */      STATE_TEXTURESTAGE(2, WINED3DTSS_ALPHAOP),          tex_alphaop         },
2446     { /*2, 07, WINED3DTSS_BUMPENVMAT00              */      STATE_TEXTURESTAGE(2, WINED3DTSS_COLOROP),          tex_colorop         },
2447     { /*2, 08, WINED3DTSS_BUMPENVMAT01              */      STATE_TEXTURESTAGE(2, WINED3DTSS_COLOROP),          tex_colorop         },
2448     { /*2, 09, WINED3DTSS_BUMPENVMAT10              */      STATE_TEXTURESTAGE(2, WINED3DTSS_COLOROP),          tex_colorop         },
2449     { /*2, 10, WINED3DTSS_BUMPENVMAT11              */      STATE_TEXTURESTAGE(2, WINED3DTSS_COLOROP),          tex_colorop         },
2450     { /*2, 11, WINED3DTSS_TEXCOORDINDEX             */      STATE_TEXTURESTAGE(2, WINED3DTSS_TEXCOORDINDEX),    tex_coordindex      },
2451     { /*2, 12, WINED3DTSS_ADDRESS                   */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
2452     { /*2, 13, WINED3DTSS_ADDRESSU                  */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
2453     { /*2, 14, WINED3DTSS_ADDRESSV                  */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
2454     { /*2, 15, WINED3DTSS_BORDERCOLOR               */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
2455     { /*2, 16, WINED3DTSS_MAGFILTER                 */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
2456     { /*2, 17, WINED3DTSS_MINFILTER                 */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
2457     { /*2, 18, WINED3DTSS_MIPFILTER                 */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
2458     { /*2, 19, WINED3DTSS_MIPMAPLODBIAS             */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
2459     { /*2, 20, WINED3DTSS_MAXMIPLEVEL               */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
2460     { /*2, 21, WINED3DTSS_MAXANISOTROPY             */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
2461     { /*2, 22, WINED3DTSS_BUMPENVLSCALE             */      STATE_TEXTURESTAGE(2, WINED3DTSS_BUMPENVLSCALE),    tex_bumpenvlscale   },
2462     { /*2, 23, WINED3DTSS_BUMPENVLOFFSET            */      STATE_TEXTURESTAGE(2, WINED3DTSS_BUMPENVLOFFSET),   tex_bumpenvloffset  },
2463     { /*2, 24, WINED3DTSS_TEXTURETRANSFORMFLAGS     */      STATE_TRANSFORM(WINED3DTS_TEXTURE2),                transform_texture   },
2464     { /*2, 25, WINED3DTSS_ADDRESSW                  */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
2465     { /*2, 26, WINED3DTSS_COLORARG0                 */      STATE_TEXTURESTAGE(2, WINED3DTSS_COLOROP),          tex_colorop         },
2466     { /*2, 27, WINED3DTSS_ALPHAARG0                 */      STATE_TEXTURESTAGE(2, WINED3DTSS_ALPHAOP),          tex_alphaop         },
2467     { /*2, 28, WINED3DTSS_RESULTARG                 */      STATE_TEXTURESTAGE(2, WINED3DTSS_RESULTARG),        tex_resultarg       },
2468     { /*2, 29, undefined                            */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
2469     { /*2, 30, undefined                            */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
2470     { /*2, 31, undefined                            */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
2471     { /*2, 32, WINED3DTSS_CONSTANT                  */      0 /* As long as we don't support D3DTA_CONSTANT */, state_nogl          },
2472
2473     { /*3, 01, WINED3DTSS_COLOROP                   */      STATE_TEXTURESTAGE(3, WINED3DTSS_COLOROP),          tex_colorop         },
2474     { /*3, 02, WINED3DTSS_COLORARG1                 */      STATE_TEXTURESTAGE(3, WINED3DTSS_COLOROP),          tex_colorop         },
2475     { /*3, 03, WINED3DTSS_COLORARG2                 */      STATE_TEXTURESTAGE(3, WINED3DTSS_COLOROP),          tex_colorop         },
2476     { /*3, 04, WINED3DTSS_ALPHAOP                   */      STATE_TEXTURESTAGE(3, WINED3DTSS_ALPHAOP),          tex_alphaop         },
2477     { /*3, 05, WINED3DTSS_ALPHAARG1                 */      STATE_TEXTURESTAGE(3, WINED3DTSS_ALPHAOP),          tex_alphaop         },
2478     { /*3, 06, WINED3DTSS_ALPHAARG2                 */      STATE_TEXTURESTAGE(3, WINED3DTSS_ALPHAOP),          tex_alphaop         },
2479     { /*3, 07, WINED3DTSS_BUMPENVMAT00              */      STATE_TEXTURESTAGE(3, WINED3DTSS_COLOROP),          tex_colorop         },
2480     { /*3, 08, WINED3DTSS_BUMPENVMAT01              */      STATE_TEXTURESTAGE(3, WINED3DTSS_COLOROP),          tex_colorop         },
2481     { /*3, 09, WINED3DTSS_BUMPENVMAT10              */      STATE_TEXTURESTAGE(3, WINED3DTSS_COLOROP),          tex_colorop         },
2482     { /*3, 10, WINED3DTSS_BUMPENVMAT11              */      STATE_TEXTURESTAGE(3, WINED3DTSS_COLOROP),          tex_colorop         },
2483     { /*3, 11, WINED3DTSS_TEXCOORDINDEX             */      STATE_TEXTURESTAGE(3, WINED3DTSS_TEXCOORDINDEX),    tex_coordindex      },
2484     { /*3, 12, WINED3DTSS_ADDRESS                   */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
2485     { /*3, 13, WINED3DTSS_ADDRESSU                  */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
2486     { /*3, 14, WINED3DTSS_ADDRESSV                  */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
2487     { /*3, 15, WINED3DTSS_BORDERCOLOR               */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
2488     { /*3, 16, WINED3DTSS_MAGFILTER                 */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
2489     { /*3, 17, WINED3DTSS_MINFILTER                 */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
2490     { /*3, 18, WINED3DTSS_MIPFILTER                 */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
2491     { /*3, 19, WINED3DTSS_MIPMAPLODBIAS             */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
2492     { /*3, 20, WINED3DTSS_MAXMIPLEVEL               */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
2493     { /*3, 21, WINED3DTSS_MAXANISOTROPY             */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
2494     { /*3, 22, WINED3DTSS_BUMPENVLSCALE             */      STATE_TEXTURESTAGE(3, WINED3DTSS_BUMPENVLSCALE),    tex_bumpenvlscale   },
2495     { /*3, 23, WINED3DTSS_BUMPENVLOFFSET            */      STATE_TEXTURESTAGE(3, WINED3DTSS_BUMPENVLOFFSET),   tex_bumpenvloffset  },
2496     { /*3, 24, WINED3DTSS_TEXTURETRANSFORMFLAGS     */      STATE_TRANSFORM(WINED3DTS_TEXTURE3),                transform_texture   },
2497     { /*3, 25, WINED3DTSS_ADDRESSW                  */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
2498     { /*3, 26, WINED3DTSS_COLORARG0                 */      STATE_TEXTURESTAGE(3, WINED3DTSS_COLOROP),          tex_colorop         },
2499     { /*3, 27, WINED3DTSS_ALPHAARG0                 */      STATE_TEXTURESTAGE(3, WINED3DTSS_ALPHAOP),          tex_alphaop         },
2500     { /*3, 28, WINED3DTSS_RESULTARG                 */      STATE_TEXTURESTAGE(3, WINED3DTSS_RESULTARG),        tex_resultarg       },
2501     { /*3, 29, undefined                            */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
2502     { /*3, 30, undefined                            */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
2503     { /*3, 31, undefined                            */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
2504     { /*3, 32, WINED3DTSS_CONSTANT                  */      0 /* As long as we don't support D3DTA_CONSTANT */, state_nogl          },
2505
2506     { /*4, 01, WINED3DTSS_COLOROP                   */      STATE_TEXTURESTAGE(4, WINED3DTSS_COLOROP),          tex_colorop         },
2507     { /*4, 02, WINED3DTSS_COLORARG1                 */      STATE_TEXTURESTAGE(4, WINED3DTSS_COLOROP),          tex_colorop         },
2508     { /*4, 03, WINED3DTSS_COLORARG2                 */      STATE_TEXTURESTAGE(4, WINED3DTSS_COLOROP),          tex_colorop         },
2509     { /*4, 04, WINED3DTSS_ALPHAOP                   */      STATE_TEXTURESTAGE(4, WINED3DTSS_ALPHAOP),          tex_alphaop         },
2510     { /*4, 05, WINED3DTSS_ALPHAARG1                 */      STATE_TEXTURESTAGE(4, WINED3DTSS_ALPHAOP),          tex_alphaop         },
2511     { /*4, 06, WINED3DTSS_ALPHAARG2                 */      STATE_TEXTURESTAGE(4, WINED3DTSS_ALPHAOP),          tex_alphaop         },
2512     { /*4, 07, WINED3DTSS_BUMPENVMAT00              */      STATE_TEXTURESTAGE(4, WINED3DTSS_COLOROP),          state_undefined     },
2513     { /*4, 08, WINED3DTSS_BUMPENVMAT01              */      STATE_TEXTURESTAGE(4, WINED3DTSS_COLOROP),          state_undefined     },
2514     { /*4, 09, WINED3DTSS_BUMPENVMAT10              */      STATE_TEXTURESTAGE(4, WINED3DTSS_COLOROP),          state_undefined     },
2515     { /*4, 10, WINED3DTSS_BUMPENVMAT11              */      STATE_TEXTURESTAGE(4, WINED3DTSS_COLOROP),          state_undefined     },
2516     { /*4, 11, WINED3DTSS_TEXCOORDINDEX             */      STATE_TEXTURESTAGE(4, WINED3DTSS_TEXCOORDINDEX),    tex_coordindex      },
2517     { /*4, 12, WINED3DTSS_ADDRESS                   */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
2518     { /*4, 13, WINED3DTSS_ADDRESSU                  */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
2519     { /*4, 14, WINED3DTSS_ADDRESSV                  */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
2520     { /*4, 15, WINED3DTSS_BORDERCOLOR               */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
2521     { /*4, 16, WINED3DTSS_MAGFILTER                 */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
2522     { /*4, 17, WINED3DTSS_MINFILTER                 */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
2523     { /*4, 18, WINED3DTSS_MIPFILTER                 */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
2524     { /*4, 19, WINED3DTSS_MIPMAPLODBIAS             */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
2525     { /*4, 20, WINED3DTSS_MAXMIPLEVEL               */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
2526     { /*4, 21, WINED3DTSS_MAXANISOTROPY             */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
2527     { /*4, 22, WINED3DTSS_BUMPENVLSCALE             */      STATE_TEXTURESTAGE(4, WINED3DTSS_BUMPENVLSCALE),    tex_bumpenvlscale   },
2528     { /*4, 23, WINED3DTSS_BUMPENVLOFFSET            */      STATE_TEXTURESTAGE(4, WINED3DTSS_BUMPENVLOFFSET),   tex_bumpenvloffset  },
2529     { /*4, 24, WINED3DTSS_TEXTURETRANSFORMFLAGS     */      STATE_TRANSFORM(WINED3DTS_TEXTURE4),                transform_texture   },
2530     { /*4, 25, WINED3DTSS_ADDRESSW                  */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
2531     { /*4, 26, WINED3DTSS_COLORARG0                 */      STATE_TEXTURESTAGE(4, WINED3DTSS_COLOROP),          tex_colorop         },
2532     { /*4, 27, WINED3DTSS_ALPHAARG0                 */      STATE_TEXTURESTAGE(4, WINED3DTSS_ALPHAOP),          tex_alphaop         },
2533     { /*4, 28, WINED3DTSS_RESULTARG                 */      STATE_TEXTURESTAGE(4, WINED3DTSS_RESULTARG),        tex_resultarg       },
2534     { /*4, 29, undefined                            */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
2535     { /*4, 30, undefined                            */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
2536     { /*4, 31, undefined                            */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
2537     { /*4, 32, WINED3DTSS_CONSTANT                  */      0 /* As long as we don't support D3DTA_CONSTANT */, state_nogl          },
2538
2539     { /*5, 01, WINED3DTSS_COLOROP                   */      STATE_TEXTURESTAGE(5, WINED3DTSS_COLOROP),          tex_colorop         },
2540     { /*5, 02, WINED3DTSS_COLORARG1                 */      STATE_TEXTURESTAGE(5, WINED3DTSS_COLOROP),          tex_colorop         },
2541     { /*5, 03, WINED3DTSS_COLORARG2                 */      STATE_TEXTURESTAGE(5, WINED3DTSS_COLOROP),          tex_colorop         },
2542     { /*5, 04, WINED3DTSS_ALPHAOP                   */      STATE_TEXTURESTAGE(5, WINED3DTSS_ALPHAOP),          tex_alphaop         },
2543     { /*5, 05, WINED3DTSS_ALPHAARG1                 */      STATE_TEXTURESTAGE(5, WINED3DTSS_ALPHAOP),          tex_alphaop         },
2544     { /*5, 06, WINED3DTSS_ALPHAARG2                 */      STATE_TEXTURESTAGE(5, WINED3DTSS_ALPHAOP),          tex_alphaop         },
2545     { /*5, 07, WINED3DTSS_BUMPENVMAT00              */      STATE_TEXTURESTAGE(5, WINED3DTSS_COLOROP),          tex_colorop         },
2546     { /*5, 08, WINED3DTSS_BUMPENVMAT01              */      STATE_TEXTURESTAGE(5, WINED3DTSS_COLOROP),          tex_colorop         },
2547     { /*5, 09, WINED3DTSS_BUMPENVMAT10              */      STATE_TEXTURESTAGE(5, WINED3DTSS_COLOROP),          tex_colorop         },
2548     { /*5, 10, WINED3DTSS_BUMPENVMAT11              */      STATE_TEXTURESTAGE(5, WINED3DTSS_COLOROP),          tex_colorop         },
2549     { /*5, 11, WINED3DTSS_TEXCOORDINDEX             */      STATE_TEXTURESTAGE(5, WINED3DTSS_TEXCOORDINDEX),    tex_coordindex      },
2550     { /*5, 12, WINED3DTSS_ADDRESS                   */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
2551     { /*5, 13, WINED3DTSS_ADDRESSU                  */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
2552     { /*5, 14, WINED3DTSS_ADDRESSV                  */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
2553     { /*5, 15, WINED3DTSS_BORDERCOLOR               */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
2554     { /*5, 16, WINED3DTSS_MAGFILTER                 */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
2555     { /*5, 17, WINED3DTSS_MINFILTER                 */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
2556     { /*5, 18, WINED3DTSS_MIPFILTER                 */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
2557     { /*5, 19, WINED3DTSS_MIPMAPLODBIAS             */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
2558     { /*5, 20, WINED3DTSS_MAXMIPLEVEL               */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
2559     { /*5, 21, WINED3DTSS_MAXANISOTROPY             */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
2560     { /*5, 22, WINED3DTSS_BUMPENVLSCALE             */      STATE_TEXTURESTAGE(5, WINED3DTSS_BUMPENVLSCALE),    tex_bumpenvlscale   },
2561     { /*5, 23, WINED3DTSS_BUMPENVLOFFSET            */      STATE_TEXTURESTAGE(5, WINED3DTSS_BUMPENVLOFFSET),   tex_bumpenvloffset  },
2562     { /*5, 24, WINED3DTSS_TEXTURETRANSFORMFLAGS     */      STATE_TRANSFORM(WINED3DTS_TEXTURE5),                transform_texture   },
2563     { /*5, 25, WINED3DTSS_ADDRESSW                  */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
2564     { /*5, 26, WINED3DTSS_COLORARG0                 */      STATE_TEXTURESTAGE(5, WINED3DTSS_COLOROP),          tex_colorop         },
2565     { /*5, 27, WINED3DTSS_ALPHAARG0                 */      STATE_TEXTURESTAGE(5, WINED3DTSS_ALPHAOP),          tex_alphaop         },
2566     { /*5, 28, WINED3DTSS_RESULTARG                 */      STATE_TEXTURESTAGE(5, WINED3DTSS_RESULTARG),        tex_resultarg       },
2567     { /*5, 29, undefined                            */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
2568     { /*5, 30, undefined                            */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
2569     { /*5, 31, undefined                            */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
2570     { /*5, 32, WINED3DTSS_CONSTANT                  */      0 /* As long as we don't support D3DTA_CONSTANT */, state_nogl          },
2571
2572     { /*6, 01, WINED3DTSS_COLOROP                   */      STATE_TEXTURESTAGE(6, WINED3DTSS_COLOROP),          tex_colorop         },
2573     { /*6, 02, WINED3DTSS_COLORARG1                 */      STATE_TEXTURESTAGE(6, WINED3DTSS_COLOROP),          tex_colorop         },
2574     { /*6, 03, WINED3DTSS_COLORARG2                 */      STATE_TEXTURESTAGE(6, WINED3DTSS_COLOROP),          tex_colorop         },
2575     { /*6, 04, WINED3DTSS_ALPHAOP                   */      STATE_TEXTURESTAGE(6, WINED3DTSS_ALPHAOP),          tex_alphaop         },
2576     { /*6, 05, WINED3DTSS_ALPHAARG1                 */      STATE_TEXTURESTAGE(6, WINED3DTSS_ALPHAOP),          tex_alphaop         },
2577     { /*6, 06, WINED3DTSS_ALPHAARG2                 */      STATE_TEXTURESTAGE(6, WINED3DTSS_ALPHAOP),          tex_alphaop         },
2578     { /*6, 07, WINED3DTSS_BUMPENVMAT00              */      STATE_TEXTURESTAGE(6, WINED3DTSS_COLOROP),          tex_colorop         },
2579     { /*6, 08, WINED3DTSS_BUMPENVMAT01              */      STATE_TEXTURESTAGE(6, WINED3DTSS_COLOROP),          tex_colorop         },
2580     { /*6, 09, WINED3DTSS_BUMPENVMAT10              */      STATE_TEXTURESTAGE(6, WINED3DTSS_COLOROP),          tex_colorop         },
2581     { /*6, 10, WINED3DTSS_BUMPENVMAT11              */      STATE_TEXTURESTAGE(6, WINED3DTSS_COLOROP),          tex_colorop         },
2582     { /*6, 11, WINED3DTSS_TEXCOORDINDEX             */      STATE_TEXTURESTAGE(6, WINED3DTSS_TEXCOORDINDEX),    tex_coordindex      },
2583     { /*6, 12, WINED3DTSS_ADDRESS                   */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
2584     { /*6, 13, WINED3DTSS_ADDRESSU                  */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
2585     { /*6, 14, WINED3DTSS_ADDRESSV                  */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
2586     { /*6, 15, WINED3DTSS_BORDERCOLOR               */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
2587     { /*6, 16, WINED3DTSS_MAGFILTER                 */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
2588     { /*6, 17, WINED3DTSS_MINFILTER                 */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
2589     { /*6, 18, WINED3DTSS_MIPFILTER                 */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
2590     { /*6, 19, WINED3DTSS_MIPMAPLODBIAS             */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
2591     { /*6, 20, WINED3DTSS_MAXMIPLEVEL               */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
2592     { /*6, 21, WINED3DTSS_MAXANISOTROPY             */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
2593     { /*6, 22, WINED3DTSS_BUMPENVLSCALE             */      STATE_TEXTURESTAGE(6, WINED3DTSS_BUMPENVLSCALE),    tex_bumpenvlscale   },
2594     { /*6, 23, WINED3DTSS_BUMPENVLOFFSET            */      STATE_TEXTURESTAGE(6, WINED3DTSS_BUMPENVLOFFSET),   tex_bumpenvloffset  },
2595     { /*6, 24, WINED3DTSS_TEXTURETRANSFORMFLAGS     */      STATE_TRANSFORM(WINED3DTS_TEXTURE6),                transform_texture   },
2596     { /*6, 25, WINED3DTSS_ADDRESSW                  */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
2597     { /*6, 26, WINED3DTSS_COLORARG0                 */      STATE_TEXTURESTAGE(6, WINED3DTSS_COLOROP),          tex_colorop         },
2598     { /*6, 27, WINED3DTSS_ALPHAARG0                 */      STATE_TEXTURESTAGE(6, WINED3DTSS_ALPHAOP),          tex_alphaop         },
2599     { /*6, 28, WINED3DTSS_RESULTARG                 */      STATE_TEXTURESTAGE(6, WINED3DTSS_RESULTARG),        tex_resultarg       },
2600     { /*6, 29, undefined                            */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
2601     { /*6, 30, undefined                            */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
2602     { /*6, 31, undefined                            */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
2603     { /*6, 32, WINED3DTSS_CONSTANT                  */      0 /* As long as we don't support D3DTA_CONSTANT */, state_nogl          },
2604
2605     { /*7, 01, WINED3DTSS_COLOROP                   */      STATE_TEXTURESTAGE(7, WINED3DTSS_COLOROP),          tex_colorop         },
2606     { /*7, 02, WINED3DTSS_COLORARG1                 */      STATE_TEXTURESTAGE(7, WINED3DTSS_COLOROP),          tex_colorop         },
2607     { /*7, 03, WINED3DTSS_COLORARG2                 */      STATE_TEXTURESTAGE(7, WINED3DTSS_COLOROP),          tex_colorop         },
2608     { /*7, 04, WINED3DTSS_ALPHAOP                   */      STATE_TEXTURESTAGE(7, WINED3DTSS_ALPHAOP),          tex_alphaop         },
2609     { /*7, 05, WINED3DTSS_ALPHAARG1                 */      STATE_TEXTURESTAGE(7, WINED3DTSS_ALPHAOP),          tex_alphaop         },
2610     { /*7, 06, WINED3DTSS_ALPHAARG2                 */      STATE_TEXTURESTAGE(7, WINED3DTSS_ALPHAOP),          tex_alphaop         },
2611     { /*7, 07, WINED3DTSS_BUMPENVMAT00              */      STATE_TEXTURESTAGE(7, WINED3DTSS_COLOROP),          tex_colorop         },
2612     { /*7, 08, WINED3DTSS_BUMPENVMAT01              */      STATE_TEXTURESTAGE(7, WINED3DTSS_COLOROP),          tex_colorop         },
2613     { /*7, 09, WINED3DTSS_BUMPENVMAT10              */      STATE_TEXTURESTAGE(7, WINED3DTSS_COLOROP),          tex_colorop         },
2614     { /*7, 10, WINED3DTSS_BUMPENVMAT11              */      STATE_TEXTURESTAGE(7, WINED3DTSS_COLOROP),          tex_colorop         },
2615     { /*7, 11, WINED3DTSS_TEXCOORDINDEX             */      STATE_TEXTURESTAGE(7, WINED3DTSS_TEXCOORDINDEX),    tex_coordindex      },
2616     { /*7, 12, WINED3DTSS_ADDRESS                   */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
2617     { /*7, 13, WINED3DTSS_ADDRESSU                  */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
2618     { /*7, 14, WINED3DTSS_ADDRESSV                  */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
2619     { /*7, 15, WINED3DTSS_BORDERCOLOR               */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
2620     { /*7, 16, WINED3DTSS_MAGFILTER                 */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
2621     { /*7, 17, WINED3DTSS_MINFILTER                 */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
2622     { /*7, 18, WINED3DTSS_MIPFILTER                 */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
2623     { /*7, 19, WINED3DTSS_MIPMAPLODBIAS             */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
2624     { /*7, 20, WINED3DTSS_MAXMIPLEVEL               */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
2625     { /*7, 21, WINED3DTSS_MAXANISOTROPY             */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
2626     { /*7, 22, WINED3DTSS_BUMPENVLSCALE             */      STATE_TEXTURESTAGE(7, WINED3DTSS_BUMPENVLSCALE),    tex_bumpenvlscale   },
2627     { /*7, 23, WINED3DTSS_BUMPENVLOFFSET            */      STATE_TEXTURESTAGE(7, WINED3DTSS_BUMPENVLOFFSET),   tex_bumpenvloffset  },
2628     { /*7, 24, WINED3DTSS_TEXTURETRANSFORMFLAGS     */      STATE_TRANSFORM(WINED3DTS_TEXTURE7),                transform_texture   },
2629     { /*7, 25, WINED3DTSS_ADDRESSW                  */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
2630     { /*7, 26, WINED3DTSS_COLORARG0                 */      STATE_TEXTURESTAGE(7, WINED3DTSS_COLOROP),          tex_colorop         },
2631     { /*7, 27, WINED3DTSS_ALPHAARG0                 */      STATE_TEXTURESTAGE(7, WINED3DTSS_ALPHAOP),          tex_alphaop         },
2632     { /*7, 28, WINED3DTSS_RESULTARG                 */      STATE_TEXTURESTAGE(7, WINED3DTSS_RESULTARG),        tex_resultarg       },
2633     { /*7, 29, undefined                            */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
2634     { /*7, 30, undefined                            */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
2635     { /*7, 31, undefined                            */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
2636     { /*7, 32, WINED3DTSS_CONSTANT                  */      0 /* As long as we don't support D3DTA_CONSTANT */, state_nogl          },
2637     /* Sampler states */
2638     { /* 0, Sampler 0                               */      STATE_SAMPLER(0),                                   sampler             },
2639     { /* 1, Sampler 1                               */      STATE_SAMPLER(1),                                   sampler             },
2640     { /* 2, Sampler 2                               */      STATE_SAMPLER(2),                                   sampler             },
2641     { /* 3, Sampler 3                               */      STATE_SAMPLER(3),                                   sampler             },
2642     { /* 4, Sampler 3                               */      STATE_SAMPLER(4),                                   sampler             },
2643     { /* 5, Sampler 5                               */      STATE_SAMPLER(5),                                   sampler             },
2644     { /* 6, Sampler 6                               */      STATE_SAMPLER(6),                                   sampler             },
2645     { /* 7, Sampler 7                               */      STATE_SAMPLER(7),                                   sampler             },
2646     { /* 8, Sampler 8                               */      STATE_SAMPLER(8),                                   sampler             },
2647     { /* 9, Sampler 9                               */      STATE_SAMPLER(9),                                   sampler             },
2648     { /*10, Sampler 10                              */      STATE_SAMPLER(10),                                  sampler             },
2649     { /*11, Sampler 11                              */      STATE_SAMPLER(11),                                  sampler             },
2650     { /*12, Sampler 12                              */      STATE_SAMPLER(12),                                  sampler             },
2651     { /*13, Sampler 13                              */      STATE_SAMPLER(13),                                  sampler             },
2652     { /*14, Sampler 14                              */      STATE_SAMPLER(14),                                  sampler             },
2653     { /*15, Sampler 15                              */      STATE_SAMPLER(15),                                  sampler             },
2654     /* Pixel shader */
2655     { /*  , Pixel Shader                            */      STATE_PIXELSHADER,                                  pixelshader         },
2656       /* Transform states follow                    */
2657     { /*  1, undefined                              */      0,                                                  state_undefined     },
2658     { /*  2, WINED3DTS_VIEW                         */      STATE_TRANSFORM(WINED3DTS_VIEW),                    transform_view      },
2659     { /*  3, WINED3DTS_PROJECTION                   */      STATE_TRANSFORM(WINED3DTS_PROJECTION),              transform_projection},
2660     { /*  4, undefined                              */      0,                                                  state_undefined     },
2661     { /*  5, undefined                              */      0,                                                  state_undefined     },
2662     { /*  6, undefined                              */      0,                                                  state_undefined     },
2663     { /*  7, undefined                              */      0,                                                  state_undefined     },
2664     { /*  8, undefined                              */      0,                                                  state_undefined     },
2665     { /*  9, undefined                              */      0,                                                  state_undefined     },
2666     { /* 10, undefined                              */      0,                                                  state_undefined     },
2667     { /* 11, undefined                              */      0,                                                  state_undefined     },
2668     { /* 12, undefined                              */      0,                                                  state_undefined     },
2669     { /* 13, undefined                              */      0,                                                  state_undefined     },
2670     { /* 14, undefined                              */      0,                                                  state_undefined     },
2671     { /* 15, undefined                              */      0,                                                  state_undefined     },
2672     { /* 16, WINED3DTS_TEXTURE0                     */      STATE_TRANSFORM(WINED3DTS_TEXTURE0),                transform_texture   },
2673     { /* 17, WINED3DTS_TEXTURE1                     */      STATE_TRANSFORM(WINED3DTS_TEXTURE1),                transform_texture   },
2674     { /* 18, WINED3DTS_TEXTURE2                     */      STATE_TRANSFORM(WINED3DTS_TEXTURE2),                transform_texture   },
2675     { /* 19, WINED3DTS_TEXTURE3                     */      STATE_TRANSFORM(WINED3DTS_TEXTURE3),                transform_texture   },
2676     { /* 20, WINED3DTS_TEXTURE4                     */      STATE_TRANSFORM(WINED3DTS_TEXTURE4),                transform_texture   },
2677     { /* 21, WINED3DTS_TEXTURE5                     */      STATE_TRANSFORM(WINED3DTS_TEXTURE5),                transform_texture   },
2678     { /* 22, WINED3DTS_TEXTURE6                     */      STATE_TRANSFORM(WINED3DTS_TEXTURE6),                transform_texture   },
2679     { /* 23, WINED3DTS_TEXTURE7                     */      STATE_TRANSFORM(WINED3DTS_TEXTURE7),                transform_texture   },
2680       /* A huge gap between TEXTURE7 and WORLDMATRIX(0) :-( But entries are needed to catch then if a broken app sets them */
2681     { /* 24, undefined                              */      0,                                                  state_undefined     },
2682     { /* 25, undefined                              */      0,                                                  state_undefined     },
2683     { /* 26, undefined                              */      0,                                                  state_undefined     },
2684     { /* 27, undefined                              */      0,                                                  state_undefined     },
2685     { /* 28, undefined                              */      0,                                                  state_undefined     },
2686     { /* 29, undefined                              */      0,                                                  state_undefined     },
2687     { /* 30, undefined                              */      0,                                                  state_undefined     },
2688     { /* 31, undefined                              */      0,                                                  state_undefined     },
2689     { /* 32, undefined                              */      0,                                                  state_undefined     },
2690     { /* 33, undefined                              */      0,                                                  state_undefined     },
2691     { /* 34, undefined                              */      0,                                                  state_undefined     },
2692     { /* 35, undefined                              */      0,                                                  state_undefined     },
2693     { /* 36, undefined                              */      0,                                                  state_undefined     },
2694     { /* 37, undefined                              */      0,                                                  state_undefined     },
2695     { /* 38, undefined                              */      0,                                                  state_undefined     },
2696     { /* 39, undefined                              */      0,                                                  state_undefined     },
2697     { /* 40, undefined                              */      0,                                                  state_undefined     },
2698     { /* 41, undefined                              */      0,                                                  state_undefined     },
2699     { /* 42, undefined                              */      0,                                                  state_undefined     },
2700     { /* 43, undefined                              */      0,                                                  state_undefined     },
2701     { /* 44, undefined                              */      0,                                                  state_undefined     },
2702     { /* 45, undefined                              */      0,                                                  state_undefined     },
2703     { /* 46, undefined                              */      0,                                                  state_undefined     },
2704     { /* 47, undefined                              */      0,                                                  state_undefined     },
2705     { /* 48, undefined                              */      0,                                                  state_undefined     },
2706     { /* 49, undefined                              */      0,                                                  state_undefined     },
2707     { /* 50, undefined                              */      0,                                                  state_undefined     },
2708     { /* 51, undefined                              */      0,                                                  state_undefined     },
2709     { /* 52, undefined                              */      0,                                                  state_undefined     },
2710     { /* 53, undefined                              */      0,                                                  state_undefined     },
2711     { /* 54, undefined                              */      0,                                                  state_undefined     },
2712     { /* 55, undefined                              */      0,                                                  state_undefined     },
2713     { /* 56, undefined                              */      0,                                                  state_undefined     },
2714     { /* 57, undefined                              */      0,                                                  state_undefined     },
2715     { /* 58, undefined                              */      0,                                                  state_undefined     },
2716     { /* 59, undefined                              */      0,                                                  state_undefined     },
2717     { /* 60, undefined                              */      0,                                                  state_undefined     },
2718     { /* 61, undefined                              */      0,                                                  state_undefined     },
2719     { /* 62, undefined                              */      0,                                                  state_undefined     },
2720     { /* 63, undefined                              */      0,                                                  state_undefined     },
2721     { /* 64, undefined                              */      0,                                                  state_undefined     },
2722     { /* 65, undefined                              */      0,                                                  state_undefined     },
2723     { /* 66, undefined                              */      0,                                                  state_undefined     },
2724     { /* 67, undefined                              */      0,                                                  state_undefined     },
2725     { /* 68, undefined                              */      0,                                                  state_undefined     },
2726     { /* 69, undefined                              */      0,                                                  state_undefined     },
2727     { /* 70, undefined                              */      0,                                                  state_undefined     },
2728     { /* 71, undefined                              */      0,                                                  state_undefined     },
2729     { /* 72, undefined                              */      0,                                                  state_undefined     },
2730     { /* 73, undefined                              */      0,                                                  state_undefined     },
2731     { /* 74, undefined                              */      0,                                                  state_undefined     },
2732     { /* 75, undefined                              */      0,                                                  state_undefined     },
2733     { /* 76, undefined                              */      0,                                                  state_undefined     },
2734     { /* 77, undefined                              */      0,                                                  state_undefined     },
2735     { /* 78, undefined                              */      0,                                                  state_undefined     },
2736     { /* 79, undefined                              */      0,                                                  state_undefined     },
2737     { /* 80, undefined                              */      0,                                                  state_undefined     },
2738     { /* 81, undefined                              */      0,                                                  state_undefined     },
2739     { /* 82, undefined                              */      0,                                                  state_undefined     },
2740     { /* 83, undefined                              */      0,                                                  state_undefined     },
2741     { /* 84, undefined                              */      0,                                                  state_undefined     },
2742     { /* 85, undefined                              */      0,                                                  state_undefined     },
2743     { /* 86, undefined                              */      0,                                                  state_undefined     },
2744     { /* 87, undefined                              */      0,                                                  state_undefined     },
2745     { /* 88, undefined                              */      0,                                                  state_undefined     },
2746     { /* 89, undefined                              */      0,                                                  state_undefined     },
2747     { /* 90, undefined                              */      0,                                                  state_undefined     },
2748     { /* 91, undefined                              */      0,                                                  state_undefined     },
2749     { /* 92, undefined                              */      0,                                                  state_undefined     },
2750     { /* 93, undefined                              */      0,                                                  state_undefined     },
2751     { /* 94, undefined                              */      0,                                                  state_undefined     },
2752     { /* 95, undefined                              */      0,                                                  state_undefined     },
2753     { /* 96, undefined                              */      0,                                                  state_undefined     },
2754     { /* 97, undefined                              */      0,                                                  state_undefined     },
2755     { /* 98, undefined                              */      0,                                                  state_undefined     },
2756     { /* 99, undefined                              */      0,                                                  state_undefined     },
2757     { /*100, undefined                              */      0,                                                  state_undefined     },
2758     { /*101, undefined                              */      0,                                                  state_undefined     },
2759     { /*102, undefined                              */      0,                                                  state_undefined     },
2760     { /*103, undefined                              */      0,                                                  state_undefined     },
2761     { /*104, undefined                              */      0,                                                  state_undefined     },
2762     { /*105, undefined                              */      0,                                                  state_undefined     },
2763     { /*106, undefined                              */      0,                                                  state_undefined     },
2764     { /*107, undefined                              */      0,                                                  state_undefined     },
2765     { /*108, undefined                              */      0,                                                  state_undefined     },
2766     { /*109, undefined                              */      0,                                                  state_undefined     },
2767     { /*110, undefined                              */      0,                                                  state_undefined     },
2768     { /*111, undefined                              */      0,                                                  state_undefined     },
2769     { /*112, undefined                              */      0,                                                  state_undefined     },
2770     { /*113, undefined                              */      0,                                                  state_undefined     },
2771     { /*114, undefined                              */      0,                                                  state_undefined     },
2772     { /*115, undefined                              */      0,                                                  state_undefined     },
2773     { /*116, undefined                              */      0,                                                  state_undefined     },
2774     { /*117, undefined                              */      0,                                                  state_undefined     },
2775     { /*118, undefined                              */      0,                                                  state_undefined     },
2776     { /*119, undefined                              */      0,                                                  state_undefined     },
2777     { /*120, undefined                              */      0,                                                  state_undefined     },
2778     { /*121, undefined                              */      0,                                                  state_undefined     },
2779     { /*122, undefined                              */      0,                                                  state_undefined     },
2780     { /*123, undefined                              */      0,                                                  state_undefined     },
2781     { /*124, undefined                              */      0,                                                  state_undefined     },
2782     { /*125, undefined                              */      0,                                                  state_undefined     },
2783     { /*126, undefined                              */      0,                                                  state_undefined     },
2784     { /*127, undefined                              */      0,                                                  state_undefined     },
2785     { /*128, undefined                              */      0,                                                  state_undefined     },
2786     { /*129, undefined                              */      0,                                                  state_undefined     },
2787     { /*130, undefined                              */      0,                                                  state_undefined     },
2788     { /*131, undefined                              */      0,                                                  state_undefined     },
2789     { /*132, undefined                              */      0,                                                  state_undefined     },
2790     { /*133, undefined                              */      0,                                                  state_undefined     },
2791     { /*134, undefined                              */      0,                                                  state_undefined     },
2792     { /*135, undefined                              */      0,                                                  state_undefined     },
2793     { /*136, undefined                              */      0,                                                  state_undefined     },
2794     { /*137, undefined                              */      0,                                                  state_undefined     },
2795     { /*138, undefined                              */      0,                                                  state_undefined     },
2796     { /*139, undefined                              */      0,                                                  state_undefined     },
2797     { /*140, undefined                              */      0,                                                  state_undefined     },
2798     { /*141, undefined                              */      0,                                                  state_undefined     },
2799     { /*142, undefined                              */      0,                                                  state_undefined     },
2800     { /*143, undefined                              */      0,                                                  state_undefined     },
2801     { /*144, undefined                              */      0,                                                  state_undefined     },
2802     { /*145, undefined                              */      0,                                                  state_undefined     },
2803     { /*146, undefined                              */      0,                                                  state_undefined     },
2804     { /*147, undefined                              */      0,                                                  state_undefined     },
2805     { /*148, undefined                              */      0,                                                  state_undefined     },
2806     { /*149, undefined                              */      0,                                                  state_undefined     },
2807     { /*150, undefined                              */      0,                                                  state_undefined     },
2808     { /*151, undefined                              */      0,                                                  state_undefined     },
2809     { /*152, undefined                              */      0,                                                  state_undefined     },
2810     { /*153, undefined                              */      0,                                                  state_undefined     },
2811     { /*154, undefined                              */      0,                                                  state_undefined     },
2812     { /*155, undefined                              */      0,                                                  state_undefined     },
2813     { /*156, undefined                              */      0,                                                  state_undefined     },
2814     { /*157, undefined                              */      0,                                                  state_undefined     },
2815     { /*158, undefined                              */      0,                                                  state_undefined     },
2816     { /*159, undefined                              */      0,                                                  state_undefined     },
2817     { /*160, undefined                              */      0,                                                  state_undefined     },
2818     { /*161, undefined                              */      0,                                                  state_undefined     },
2819     { /*162, undefined                              */      0,                                                  state_undefined     },
2820     { /*163, undefined                              */      0,                                                  state_undefined     },
2821     { /*164, undefined                              */      0,                                                  state_undefined     },
2822     { /*165, undefined                              */      0,                                                  state_undefined     },
2823     { /*166, undefined                              */      0,                                                  state_undefined     },
2824     { /*167, undefined                              */      0,                                                  state_undefined     },
2825     { /*168, undefined                              */      0,                                                  state_undefined     },
2826     { /*169, undefined                              */      0,                                                  state_undefined     },
2827     { /*170, undefined                              */      0,                                                  state_undefined     },
2828     { /*171, undefined                              */      0,                                                  state_undefined     },
2829     { /*172, undefined                              */      0,                                                  state_undefined     },
2830     { /*173, undefined                              */      0,                                                  state_undefined     },
2831     { /*174, undefined                              */      0,                                                  state_undefined     },
2832     { /*175, undefined                              */      0,                                                  state_undefined     },
2833     { /*176, undefined                              */      0,                                                  state_undefined     },
2834     { /*177, undefined                              */      0,                                                  state_undefined     },
2835     { /*178, undefined                              */      0,                                                  state_undefined     },
2836     { /*179, undefined                              */      0,                                                  state_undefined     },
2837     { /*180, undefined                              */      0,                                                  state_undefined     },
2838     { /*181, undefined                              */      0,                                                  state_undefined     },
2839     { /*182, undefined                              */      0,                                                  state_undefined     },
2840     { /*183, undefined                              */      0,                                                  state_undefined     },
2841     { /*184, undefined                              */      0,                                                  state_undefined     },
2842     { /*185, undefined                              */      0,                                                  state_undefined     },
2843     { /*186, undefined                              */      0,                                                  state_undefined     },
2844     { /*187, undefined                              */      0,                                                  state_undefined     },
2845     { /*188, undefined                              */      0,                                                  state_undefined     },
2846     { /*189, undefined                              */      0,                                                  state_undefined     },
2847     { /*190, undefined                              */      0,                                                  state_undefined     },
2848     { /*191, undefined                              */      0,                                                  state_undefined     },
2849     { /*192, undefined                              */      0,                                                  state_undefined     },
2850     { /*193, undefined                              */      0,                                                  state_undefined     },
2851     { /*194, undefined                              */      0,                                                  state_undefined     },
2852     { /*195, undefined                              */      0,                                                  state_undefined     },
2853     { /*196, undefined                              */      0,                                                  state_undefined     },
2854     { /*197, undefined                              */      0,                                                  state_undefined     },
2855     { /*198, undefined                              */      0,                                                  state_undefined     },
2856     { /*199, undefined                              */      0,                                                  state_undefined     },
2857     { /*200, undefined                              */      0,                                                  state_undefined     },
2858     { /*201, undefined                              */      0,                                                  state_undefined     },
2859     { /*202, undefined                              */      0,                                                  state_undefined     },
2860     { /*203, undefined                              */      0,                                                  state_undefined     },
2861     { /*204, undefined                              */      0,                                                  state_undefined     },
2862     { /*205, undefined                              */      0,                                                  state_undefined     },
2863     { /*206, undefined                              */      0,                                                  state_undefined     },
2864     { /*207, undefined                              */      0,                                                  state_undefined     },
2865     { /*208, undefined                              */      0,                                                  state_undefined     },
2866     { /*209, undefined                              */      0,                                                  state_undefined     },
2867     { /*210, undefined                              */      0,                                                  state_undefined     },
2868     { /*211, undefined                              */      0,                                                  state_undefined     },
2869     { /*212, undefined                              */      0,                                                  state_undefined     },
2870     { /*213, undefined                              */      0,                                                  state_undefined     },
2871     { /*214, undefined                              */      0,                                                  state_undefined     },
2872     { /*215, undefined                              */      0,                                                  state_undefined     },
2873     { /*216, undefined                              */      0,                                                  state_undefined     },
2874     { /*217, undefined                              */      0,                                                  state_undefined     },
2875     { /*218, undefined                              */      0,                                                  state_undefined     },
2876     { /*219, undefined                              */      0,                                                  state_undefined     },
2877     { /*220, undefined                              */      0,                                                  state_undefined     },
2878     { /*221, undefined                              */      0,                                                  state_undefined     },
2879     { /*222, undefined                              */      0,                                                  state_undefined     },
2880     { /*223, undefined                              */      0,                                                  state_undefined     },
2881     { /*224, undefined                              */      0,                                                  state_undefined     },
2882     { /*225, undefined                              */      0,                                                  state_undefined     },
2883     { /*226, undefined                              */      0,                                                  state_undefined     },
2884     { /*227, undefined                              */      0,                                                  state_undefined     },
2885     { /*228, undefined                              */      0,                                                  state_undefined     },
2886     { /*229, undefined                              */      0,                                                  state_undefined     },
2887     { /*230, undefined                              */      0,                                                  state_undefined     },
2888     { /*231, undefined                              */      0,                                                  state_undefined     },
2889     { /*232, undefined                              */      0,                                                  state_undefined     },
2890     { /*233, undefined                              */      0,                                                  state_undefined     },
2891     { /*234, undefined                              */      0,                                                  state_undefined     },
2892     { /*235, undefined                              */      0,                                                  state_undefined     },
2893     { /*236, undefined                              */      0,                                                  state_undefined     },
2894     { /*237, undefined                              */      0,                                                  state_undefined     },
2895     { /*238, undefined                              */      0,                                                  state_undefined     },
2896     { /*239, undefined                              */      0,                                                  state_undefined     },
2897     { /*240, undefined                              */      0,                                                  state_undefined     },
2898     { /*241, undefined                              */      0,                                                  state_undefined     },
2899     { /*242, undefined                              */      0,                                                  state_undefined     },
2900     { /*243, undefined                              */      0,                                                  state_undefined     },
2901     { /*244, undefined                              */      0,                                                  state_undefined     },
2902     { /*245, undefined                              */      0,                                                  state_undefined     },
2903     { /*246, undefined                              */      0,                                                  state_undefined     },
2904     { /*247, undefined                              */      0,                                                  state_undefined     },
2905     { /*248, undefined                              */      0,                                                  state_undefined     },
2906     { /*249, undefined                              */      0,                                                  state_undefined     },
2907     { /*250, undefined                              */      0,                                                  state_undefined     },
2908     { /*251, undefined                              */      0,                                                  state_undefined     },
2909     { /*252, undefined                              */      0,                                                  state_undefined     },
2910     { /*253, undefined                              */      0,                                                  state_undefined     },
2911     { /*254, undefined                              */      0,                                                  state_undefined     },
2912     { /*255, undefined                              */      0,                                                  state_undefined     },
2913       /* End huge gap */
2914     { /*256, WINED3DTS_WORLDMATRIX(0)               */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(0)),          transform_world     },
2915     { /*257, WINED3DTS_WORLDMATRIX(1)               */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(1)),          transform_worldex   },
2916     { /*258, WINED3DTS_WORLDMATRIX(2)               */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(2)),          transform_worldex   },
2917     { /*259, WINED3DTS_WORLDMATRIX(3)               */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(3)),          transform_worldex   },
2918     { /*260, WINED3DTS_WORLDMATRIX(4)               */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(4)),          transform_worldex   },
2919     { /*261, WINED3DTS_WORLDMATRIX(5)               */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(5)),          transform_worldex   },
2920     { /*262, WINED3DTS_WORLDMATRIX(6)               */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(6)),          transform_worldex   },
2921     { /*263, WINED3DTS_WORLDMATRIX(7)               */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(7)),          transform_worldex   },
2922     { /*264, WINED3DTS_WORLDMATRIX(8)               */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(8)),          transform_worldex   },
2923     { /*265, WINED3DTS_WORLDMATRIX(9)               */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(9)),          transform_worldex   },
2924     { /*266, WINED3DTS_WORLDMATRIX(10)              */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(10)),         transform_worldex   },
2925     { /*267, WINED3DTS_WORLDMATRIX(11)              */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(11)),         transform_worldex   },
2926     { /*268, WINED3DTS_WORLDMATRIX(12)              */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(12)),         transform_worldex   },
2927     { /*269, WINED3DTS_WORLDMATRIX(13)              */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(13)),         transform_worldex   },
2928     { /*270, WINED3DTS_WORLDMATRIX(14)              */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(14)),         transform_worldex   },
2929     { /*271, WINED3DTS_WORLDMATRIX(15)              */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(15)),         transform_worldex   },
2930     { /*272, WINED3DTS_WORLDMATRIX(16)              */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(16)),         transform_worldex   },
2931     { /*273, WINED3DTS_WORLDMATRIX(17)              */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(17)),         transform_worldex   },
2932     { /*274, WINED3DTS_WORLDMATRIX(18)              */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(18)),         transform_worldex   },
2933     { /*275, WINED3DTS_WORLDMATRIX(19)              */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(19)),         transform_worldex   },
2934     { /*276, WINED3DTS_WORLDMATRIX(20)              */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(20)),         transform_worldex   },
2935     { /*277, WINED3DTS_WORLDMATRIX(21)              */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(21)),         transform_worldex   },
2936     { /*278, WINED3DTS_WORLDMATRIX(22)              */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(22)),         transform_worldex   },
2937     { /*279, WINED3DTS_WORLDMATRIX(23)              */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(23)),         transform_worldex   },
2938     { /*280, WINED3DTS_WORLDMATRIX(24)              */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(24)),         transform_worldex   },
2939     { /*281, WINED3DTS_WORLDMATRIX(25)              */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(25)),         transform_worldex   },
2940     { /*282, WINED3DTS_WORLDMATRIX(26)              */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(26)),         transform_worldex   },
2941     { /*283, WINED3DTS_WORLDMATRIX(27)              */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(27)),         transform_worldex   },
2942     { /*284, WINED3DTS_WORLDMATRIX(28)              */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(28)),         transform_worldex   },
2943     { /*285, WINED3DTS_WORLDMATRIX(29)              */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(29)),         transform_worldex   },
2944     { /*286, WINED3DTS_WORLDMATRIX(30)              */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(30)),         transform_worldex   },
2945     { /*287, WINED3DTS_WORLDMATRIX(31)              */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(31)),         transform_worldex   },
2946     { /*288, WINED3DTS_WORLDMATRIX(32)              */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(32)),         transform_worldex   },
2947     { /*289, WINED3DTS_WORLDMATRIX(33)              */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(33)),         transform_worldex   },
2948     { /*290, WINED3DTS_WORLDMATRIX(34)              */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(34)),         transform_worldex   },
2949     { /*291, WINED3DTS_WORLDMATRIX(35)              */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(35)),         transform_worldex   },
2950     { /*292, WINED3DTS_WORLDMATRIX(36)              */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(36)),         transform_worldex   },
2951     { /*293, WINED3DTS_WORLDMATRIX(37)              */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(37)),         transform_worldex   },
2952     { /*294, WINED3DTS_WORLDMATRIX(38)              */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(38)),         transform_worldex   },
2953     { /*295, WINED3DTS_WORLDMATRIX(39)              */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(39)),         transform_worldex   },
2954     { /*296, WINED3DTS_WORLDMATRIX(40)              */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(40)),         transform_worldex   },
2955     { /*297, WINED3DTS_WORLDMATRIX(41)              */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(41)),         transform_worldex   },
2956     { /*298, WINED3DTS_WORLDMATRIX(42)              */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(42)),         transform_worldex   },
2957     { /*299, WINED3DTS_WORLDMATRIX(43)              */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(43)),         transform_worldex   },
2958     { /*300, WINED3DTS_WORLDMATRIX(44)              */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(44)),         transform_worldex   },
2959     { /*301, WINED3DTS_WORLDMATRIX(45)              */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(45)),         transform_worldex   },
2960     { /*302, WINED3DTS_WORLDMATRIX(46)              */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(46)),         transform_worldex   },
2961     { /*303, WINED3DTS_WORLDMATRIX(47)              */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(47)),         transform_worldex   },
2962     { /*304, WINED3DTS_WORLDMATRIX(48)              */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(48)),         transform_worldex   },
2963     { /*305, WINED3DTS_WORLDMATRIX(49)              */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(49)),         transform_worldex   },
2964     { /*306, WINED3DTS_WORLDMATRIX(50)              */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(50)),         transform_worldex   },
2965     { /*307, WINED3DTS_WORLDMATRIX(51)              */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(51)),         transform_worldex   },
2966     { /*308, WINED3DTS_WORLDMATRIX(52)              */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(52)),         transform_worldex   },
2967     { /*309, WINED3DTS_WORLDMATRIX(53)              */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(53)),         transform_worldex   },
2968     { /*310, WINED3DTS_WORLDMATRIX(54)              */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(54)),         transform_worldex   },
2969     { /*311, WINED3DTS_WORLDMATRIX(55)              */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(55)),         transform_worldex   },
2970     { /*312, WINED3DTS_WORLDMATRIX(56)              */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(56)),         transform_worldex   },
2971     { /*313, WINED3DTS_WORLDMATRIX(57)              */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(57)),         transform_worldex   },
2972     { /*314, WINED3DTS_WORLDMATRIX(58)              */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(58)),         transform_worldex   },
2973     { /*315, WINED3DTS_WORLDMATRIX(59)              */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(59)),         transform_worldex   },
2974     { /*316, WINED3DTS_WORLDMATRIX(60)              */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(60)),         transform_worldex   },
2975     { /*317, WINED3DTS_WORLDMATRIX(61)              */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(61)),         transform_worldex   },
2976     { /*318, WINED3DTS_WORLDMATRIX(62)              */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(62)),         transform_worldex   },
2977     { /*319, WINED3DTS_WORLDMATRIX(63)              */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(63)),         transform_worldex   },
2978     { /*320, WINED3DTS_WORLDMATRIX(64)              */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(64)),         transform_worldex   },
2979     { /*321, WINED3DTS_WORLDMATRIX(65)              */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(65)),         transform_worldex   },
2980     { /*322, WINED3DTS_WORLDMATRIX(66)              */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(66)),         transform_worldex   },
2981     { /*323, WINED3DTS_WORLDMATRIX(67)              */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(67)),         transform_worldex   },
2982     { /*324, WINED3DTS_WORLDMATRIX(68)              */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(68)),         transform_worldex   },
2983     { /*325, WINED3DTS_WORLDMATRIX(68)              */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(69)),         transform_worldex   },
2984     { /*326, WINED3DTS_WORLDMATRIX(70)              */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(70)),         transform_worldex   },
2985     { /*327, WINED3DTS_WORLDMATRIX(71)              */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(71)),         transform_worldex   },
2986     { /*328, WINED3DTS_WORLDMATRIX(72)              */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(72)),         transform_worldex   },
2987     { /*329, WINED3DTS_WORLDMATRIX(73)              */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(73)),         transform_worldex   },
2988     { /*330, WINED3DTS_WORLDMATRIX(74)              */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(74)),         transform_worldex   },
2989     { /*331, WINED3DTS_WORLDMATRIX(75)              */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(75)),         transform_worldex   },
2990     { /*332, WINED3DTS_WORLDMATRIX(76)              */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(76)),         transform_worldex   },
2991     { /*333, WINED3DTS_WORLDMATRIX(77)              */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(77)),         transform_worldex   },
2992     { /*334, WINED3DTS_WORLDMATRIX(78)              */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(78)),         transform_worldex   },
2993     { /*335, WINED3DTS_WORLDMATRIX(79)              */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(79)),         transform_worldex   },
2994     { /*336, WINED3DTS_WORLDMATRIX(80)              */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(80)),         transform_worldex   },
2995     { /*337, WINED3DTS_WORLDMATRIX(81)              */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(81)),         transform_worldex   },
2996     { /*338, WINED3DTS_WORLDMATRIX(82)              */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(82)),         transform_worldex   },
2997     { /*339, WINED3DTS_WORLDMATRIX(83)              */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(83)),         transform_worldex   },
2998     { /*340, WINED3DTS_WORLDMATRIX(84)              */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(84)),         transform_worldex   },
2999     { /*341, WINED3DTS_WORLDMATRIX(85)              */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(85)),         transform_worldex   },
3000     { /*341, WINED3DTS_WORLDMATRIX(86)              */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(86)),         transform_worldex   },
3001     { /*343, WINED3DTS_WORLDMATRIX(87)              */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(87)),         transform_worldex   },
3002     { /*344, WINED3DTS_WORLDMATRIX(88)              */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(88)),         transform_worldex   },
3003     { /*345, WINED3DTS_WORLDMATRIX(89)              */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(89)),         transform_worldex   },
3004     { /*346, WINED3DTS_WORLDMATRIX(90)              */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(90)),         transform_worldex   },
3005     { /*347, WINED3DTS_WORLDMATRIX(91)              */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(91)),         transform_worldex   },
3006     { /*348, WINED3DTS_WORLDMATRIX(92)              */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(92)),         transform_worldex   },
3007     { /*349, WINED3DTS_WORLDMATRIX(93)              */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(93)),         transform_worldex   },
3008     { /*350, WINED3DTS_WORLDMATRIX(94)              */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(94)),         transform_worldex   },
3009     { /*351, WINED3DTS_WORLDMATRIX(95)              */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(95)),         transform_worldex   },
3010     { /*352, WINED3DTS_WORLDMATRIX(96)              */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(96)),         transform_worldex   },
3011     { /*353, WINED3DTS_WORLDMATRIX(97)              */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(97)),         transform_worldex   },
3012     { /*354, WINED3DTS_WORLDMATRIX(98)              */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(98)),         transform_worldex   },
3013     { /*355, WINED3DTS_WORLDMATRIX(99)              */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(99)),         transform_worldex   },
3014     { /*356, WINED3DTS_WORLDMATRIX(100)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(100)),        transform_worldex   },
3015     { /*357, WINED3DTS_WORLDMATRIX(101)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(101)),        transform_worldex   },
3016     { /*358, WINED3DTS_WORLDMATRIX(102)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(102)),        transform_worldex   },
3017     { /*359, WINED3DTS_WORLDMATRIX(103)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(103)),        transform_worldex   },
3018     { /*360, WINED3DTS_WORLDMATRIX(104)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(104)),        transform_worldex   },
3019     { /*361, WINED3DTS_WORLDMATRIX(105)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(105)),        transform_worldex   },
3020     { /*362, WINED3DTS_WORLDMATRIX(106)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(106)),        transform_worldex   },
3021     { /*363, WINED3DTS_WORLDMATRIX(107)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(107)),        transform_worldex   },
3022     { /*364, WINED3DTS_WORLDMATRIX(108)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(108)),        transform_worldex   },
3023     { /*365, WINED3DTS_WORLDMATRIX(109)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(109)),        transform_worldex   },
3024     { /*366, WINED3DTS_WORLDMATRIX(110)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(110)),        transform_worldex   },
3025     { /*367, WINED3DTS_WORLDMATRIX(111)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(111)),        transform_worldex   },
3026     { /*368, WINED3DTS_WORLDMATRIX(112)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(112)),        transform_worldex   },
3027     { /*369, WINED3DTS_WORLDMATRIX(113)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(113)),        transform_worldex   },
3028     { /*370, WINED3DTS_WORLDMATRIX(114)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(114)),        transform_worldex   },
3029     { /*371, WINED3DTS_WORLDMATRIX(115)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(115)),        transform_worldex   },
3030     { /*372, WINED3DTS_WORLDMATRIX(116)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(116)),        transform_worldex   },
3031     { /*373, WINED3DTS_WORLDMATRIX(117)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(117)),        transform_worldex   },
3032     { /*374, WINED3DTS_WORLDMATRIX(118)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(118)),        transform_worldex   },
3033     { /*375, WINED3DTS_WORLDMATRIX(119)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(119)),        transform_worldex   },
3034     { /*376, WINED3DTS_WORLDMATRIX(120)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(120)),        transform_worldex   },
3035     { /*377, WINED3DTS_WORLDMATRIX(121)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(121)),        transform_worldex   },
3036     { /*378, WINED3DTS_WORLDMATRIX(122)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(122)),        transform_worldex   },
3037     { /*379, WINED3DTS_WORLDMATRIX(123)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(123)),        transform_worldex   },
3038     { /*380, WINED3DTS_WORLDMATRIX(124)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(124)),        transform_worldex   },
3039     { /*381, WINED3DTS_WORLDMATRIX(125)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(125)),        transform_worldex   },
3040     { /*382, WINED3DTS_WORLDMATRIX(126)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(126)),        transform_worldex   },
3041     { /*383, WINED3DTS_WORLDMATRIX(127)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(127)),        transform_worldex   },
3042     { /*384, WINED3DTS_WORLDMATRIX(128)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(128)),        transform_worldex   },
3043     { /*385, WINED3DTS_WORLDMATRIX(129)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(129)),        transform_worldex   },
3044     { /*386, WINED3DTS_WORLDMATRIX(130)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(130)),        transform_worldex   },
3045     { /*387, WINED3DTS_WORLDMATRIX(131)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(131)),        transform_worldex   },
3046     { /*388, WINED3DTS_WORLDMATRIX(132)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(132)),        transform_worldex   },
3047     { /*389, WINED3DTS_WORLDMATRIX(133)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(133)),        transform_worldex   },
3048     { /*390, WINED3DTS_WORLDMATRIX(134)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(134)),        transform_worldex   },
3049     { /*391, WINED3DTS_WORLDMATRIX(135)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(135)),        transform_worldex   },
3050     { /*392, WINED3DTS_WORLDMATRIX(136)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(136)),        transform_worldex   },
3051     { /*393, WINED3DTS_WORLDMATRIX(137)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(137)),        transform_worldex   },
3052     { /*394, WINED3DTS_WORLDMATRIX(138)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(138)),        transform_worldex   },
3053     { /*395, WINED3DTS_WORLDMATRIX(139)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(139)),        transform_worldex   },
3054     { /*396, WINED3DTS_WORLDMATRIX(140)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(140)),        transform_worldex   },
3055     { /*397, WINED3DTS_WORLDMATRIX(141)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(141)),        transform_worldex   },
3056     { /*398, WINED3DTS_WORLDMATRIX(142)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(142)),        transform_worldex   },
3057     { /*399, WINED3DTS_WORLDMATRIX(143)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(143)),        transform_worldex   },
3058     { /*400, WINED3DTS_WORLDMATRIX(144)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(144)),        transform_worldex   },
3059     { /*401, WINED3DTS_WORLDMATRIX(145)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(145)),        transform_worldex   },
3060     { /*402, WINED3DTS_WORLDMATRIX(146)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(146)),        transform_worldex   },
3061     { /*403, WINED3DTS_WORLDMATRIX(147)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(147)),        transform_worldex   },
3062     { /*404, WINED3DTS_WORLDMATRIX(148)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(148)),        transform_worldex   },
3063     { /*405, WINED3DTS_WORLDMATRIX(149)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(149)),        transform_worldex   },
3064     { /*406, WINED3DTS_WORLDMATRIX(150)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(150)),        transform_worldex   },
3065     { /*407, WINED3DTS_WORLDMATRIX(151)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(151)),        transform_worldex   },
3066     { /*408, WINED3DTS_WORLDMATRIX(152)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(152)),        transform_worldex   },
3067     { /*409, WINED3DTS_WORLDMATRIX(153)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(153)),        transform_worldex   },
3068     { /*410, WINED3DTS_WORLDMATRIX(154)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(154)),        transform_worldex   },
3069     { /*411, WINED3DTS_WORLDMATRIX(155)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(155)),        transform_worldex   },
3070     { /*412, WINED3DTS_WORLDMATRIX(156)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(156)),        transform_worldex   },
3071     { /*413, WINED3DTS_WORLDMATRIX(157)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(157)),        transform_worldex   },
3072     { /*414, WINED3DTS_WORLDMATRIX(158)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(158)),        transform_worldex   },
3073     { /*415, WINED3DTS_WORLDMATRIX(159)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(159)),        transform_worldex   },
3074     { /*416, WINED3DTS_WORLDMATRIX(160)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(160)),        transform_worldex   },
3075     { /*417, WINED3DTS_WORLDMATRIX(161)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(161)),        transform_worldex   },
3076     { /*418, WINED3DTS_WORLDMATRIX(162)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(162)),        transform_worldex   },
3077     { /*419, WINED3DTS_WORLDMATRIX(163)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(163)),        transform_worldex   },
3078     { /*420, WINED3DTS_WORLDMATRIX(164)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(164)),        transform_worldex   },
3079     { /*421, WINED3DTS_WORLDMATRIX(165)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(165)),        transform_worldex   },
3080     { /*422, WINED3DTS_WORLDMATRIX(166)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(166)),        transform_worldex   },
3081     { /*423, WINED3DTS_WORLDMATRIX(167)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(167)),        transform_worldex   },
3082     { /*424, WINED3DTS_WORLDMATRIX(168)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(168)),        transform_worldex   },
3083     { /*425, WINED3DTS_WORLDMATRIX(168)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(169)),        transform_worldex   },
3084     { /*426, WINED3DTS_WORLDMATRIX(170)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(170)),        transform_worldex   },
3085     { /*427, WINED3DTS_WORLDMATRIX(171)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(171)),        transform_worldex   },
3086     { /*428, WINED3DTS_WORLDMATRIX(172)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(172)),        transform_worldex   },
3087     { /*429, WINED3DTS_WORLDMATRIX(173)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(173)),        transform_worldex   },
3088     { /*430, WINED3DTS_WORLDMATRIX(174)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(174)),        transform_worldex   },
3089     { /*431, WINED3DTS_WORLDMATRIX(175)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(175)),        transform_worldex   },
3090     { /*432, WINED3DTS_WORLDMATRIX(176)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(176)),        transform_worldex   },
3091     { /*433, WINED3DTS_WORLDMATRIX(177)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(177)),        transform_worldex   },
3092     { /*434, WINED3DTS_WORLDMATRIX(178)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(178)),        transform_worldex   },
3093     { /*435, WINED3DTS_WORLDMATRIX(179)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(179)),        transform_worldex   },
3094     { /*436, WINED3DTS_WORLDMATRIX(180)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(180)),        transform_worldex   },
3095     { /*437, WINED3DTS_WORLDMATRIX(181)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(181)),        transform_worldex   },
3096     { /*438, WINED3DTS_WORLDMATRIX(182)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(182)),        transform_worldex   },
3097     { /*439, WINED3DTS_WORLDMATRIX(183)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(183)),        transform_worldex   },
3098     { /*440, WINED3DTS_WORLDMATRIX(184)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(184)),        transform_worldex   },
3099     { /*441, WINED3DTS_WORLDMATRIX(185)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(185)),        transform_worldex   },
3100     { /*441, WINED3DTS_WORLDMATRIX(186)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(186)),        transform_worldex   },
3101     { /*443, WINED3DTS_WORLDMATRIX(187)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(187)),        transform_worldex   },
3102     { /*444, WINED3DTS_WORLDMATRIX(188)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(188)),        transform_worldex   },
3103     { /*445, WINED3DTS_WORLDMATRIX(189)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(189)),        transform_worldex   },
3104     { /*446, WINED3DTS_WORLDMATRIX(190)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(190)),        transform_worldex   },
3105     { /*447, WINED3DTS_WORLDMATRIX(191)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(191)),        transform_worldex   },
3106     { /*448, WINED3DTS_WORLDMATRIX(192)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(192)),        transform_worldex   },
3107     { /*449, WINED3DTS_WORLDMATRIX(193)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(193)),        transform_worldex   },
3108     { /*450, WINED3DTS_WORLDMATRIX(194)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(194)),        transform_worldex   },
3109     { /*451, WINED3DTS_WORLDMATRIX(195)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(195)),        transform_worldex   },
3110     { /*452, WINED3DTS_WORLDMATRIX(196)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(196)),        transform_worldex   },
3111     { /*453, WINED3DTS_WORLDMATRIX(197)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(197)),        transform_worldex   },
3112     { /*454, WINED3DTS_WORLDMATRIX(198)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(198)),        transform_worldex   },
3113     { /*455, WINED3DTS_WORLDMATRIX(199)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(199)),        transform_worldex   },
3114     { /*356, WINED3DTS_WORLDMATRIX(200)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(200)),        transform_worldex   },
3115     { /*457, WINED3DTS_WORLDMATRIX(201)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(201)),        transform_worldex   },
3116     { /*458, WINED3DTS_WORLDMATRIX(202)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(202)),        transform_worldex   },
3117     { /*459, WINED3DTS_WORLDMATRIX(203)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(203)),        transform_worldex   },
3118     { /*460, WINED3DTS_WORLDMATRIX(204)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(204)),        transform_worldex   },
3119     { /*461, WINED3DTS_WORLDMATRIX(205)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(205)),        transform_worldex   },
3120     { /*462, WINED3DTS_WORLDMATRIX(206)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(206)),        transform_worldex   },
3121     { /*463, WINED3DTS_WORLDMATRIX(207)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(207)),        transform_worldex   },
3122     { /*464, WINED3DTS_WORLDMATRIX(208)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(208)),        transform_worldex   },
3123     { /*465, WINED3DTS_WORLDMATRIX(209)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(209)),        transform_worldex   },
3124     { /*466, WINED3DTS_WORLDMATRIX(210)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(210)),        transform_worldex   },
3125     { /*467, WINED3DTS_WORLDMATRIX(211)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(211)),        transform_worldex   },
3126     { /*468, WINED3DTS_WORLDMATRIX(212)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(212)),        transform_worldex   },
3127     { /*469, WINED3DTS_WORLDMATRIX(213)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(213)),        transform_worldex   },
3128     { /*470, WINED3DTS_WORLDMATRIX(214)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(214)),        transform_worldex   },
3129     { /*471, WINED3DTS_WORLDMATRIX(215)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(215)),        transform_worldex   },
3130     { /*472, WINED3DTS_WORLDMATRIX(216)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(216)),        transform_worldex   },
3131     { /*473, WINED3DTS_WORLDMATRIX(217)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(217)),        transform_worldex   },
3132     { /*474, WINED3DTS_WORLDMATRIX(218)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(218)),        transform_worldex   },
3133     { /*475, WINED3DTS_WORLDMATRIX(219)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(219)),        transform_worldex   },
3134     { /*476, WINED3DTS_WORLDMATRIX(220)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(220)),        transform_worldex   },
3135     { /*477, WINED3DTS_WORLDMATRIX(221)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(221)),        transform_worldex   },
3136     { /*478, WINED3DTS_WORLDMATRIX(222)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(222)),        transform_worldex   },
3137     { /*479, WINED3DTS_WORLDMATRIX(223)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(223)),        transform_worldex   },
3138     { /*480, WINED3DTS_WORLDMATRIX(224)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(224)),        transform_worldex   },
3139     { /*481, WINED3DTS_WORLDMATRIX(225)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(225)),        transform_worldex   },
3140     { /*482, WINED3DTS_WORLDMATRIX(226)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(226)),        transform_worldex   },
3141     { /*483, WINED3DTS_WORLDMATRIX(227)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(227)),        transform_worldex   },
3142     { /*484, WINED3DTS_WORLDMATRIX(228)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(228)),        transform_worldex   },
3143     { /*485, WINED3DTS_WORLDMATRIX(229)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(229)),        transform_worldex   },
3144     { /*486, WINED3DTS_WORLDMATRIX(230)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(230)),        transform_worldex   },
3145     { /*487, WINED3DTS_WORLDMATRIX(231)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(231)),        transform_worldex   },
3146     { /*488, WINED3DTS_WORLDMATRIX(232)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(232)),        transform_worldex   },
3147     { /*489, WINED3DTS_WORLDMATRIX(233)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(233)),        transform_worldex   },
3148     { /*490, WINED3DTS_WORLDMATRIX(234)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(234)),        transform_worldex   },
3149     { /*491, WINED3DTS_WORLDMATRIX(235)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(235)),        transform_worldex   },
3150     { /*492, WINED3DTS_WORLDMATRIX(236)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(236)),        transform_worldex   },
3151     { /*493, WINED3DTS_WORLDMATRIX(237)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(237)),        transform_worldex   },
3152     { /*494, WINED3DTS_WORLDMATRIX(238)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(238)),        transform_worldex   },
3153     { /*495, WINED3DTS_WORLDMATRIX(239)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(239)),        transform_worldex   },
3154     { /*496, WINED3DTS_WORLDMATRIX(240)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(240)),        transform_worldex   },
3155     { /*497, WINED3DTS_WORLDMATRIX(241)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(241)),        transform_worldex   },
3156     { /*498, WINED3DTS_WORLDMATRIX(242)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(242)),        transform_worldex   },
3157     { /*499, WINED3DTS_WORLDMATRIX(243)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(243)),        transform_worldex   },
3158     { /*500, WINED3DTS_WORLDMATRIX(244)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(244)),        transform_worldex   },
3159     { /*501, WINED3DTS_WORLDMATRIX(245)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(245)),        transform_worldex   },
3160     { /*502, WINED3DTS_WORLDMATRIX(246)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(246)),        transform_worldex   },
3161     { /*503, WINED3DTS_WORLDMATRIX(247)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(247)),        transform_worldex   },
3162     { /*504, WINED3DTS_WORLDMATRIX(248)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(248)),        transform_worldex   },
3163     { /*505, WINED3DTS_WORLDMATRIX(249)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(249)),        transform_worldex   },
3164     { /*506, WINED3DTS_WORLDMATRIX(250)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(250)),        transform_worldex   },
3165     { /*507, WINED3DTS_WORLDMATRIX(251)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(251)),        transform_worldex   },
3166     { /*508, WINED3DTS_WORLDMATRIX(252)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(252)),        transform_worldex   },
3167     { /*509, WINED3DTS_WORLDMATRIX(253)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(253)),        transform_worldex   },
3168     { /*510, WINED3DTS_WORLDMATRIX(254)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(254)),        transform_worldex   },
3169     { /*511, WINED3DTS_WORLDMATRIX(255)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(255)),        transform_worldex   },
3170       /* Various Vertex states follow */
3171     { /*   , STATE_STREAMSRC                        */      STATE_VDECL,                                        vertexdeclaration   },
3172     { /*   , STATE_VDECL                            */      STATE_VDECL,                                        vertexdeclaration   },
3173     { /*   , STATE_VSHADER                          */      STATE_VDECL,                                        vertexdeclaration   },
3174     { /*   , STATE_VIEWPORT                         */      STATE_VIEWPORT,                                     viewport            },
3175
3176 };