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

   1 /*
   2  * Direct3D state management
   3  *
   4  * Copyright 2002 Lionel Ulmer
   5  * Copyright 2002-2005 Jason Edmeades
   6  * Copyright 2003-2004 Raphael Junqueira
   7  * Copyright 2004 Christian Costa
   8  * Copyright 2005 Oliver Stieber
   9  * Copyright 2006 Henri Verbeet
  10  * Copyright 2006-2008 Stefan Dösinger for CodeWeavers
  11  *
  12  * This library is free software; you can redistribute it and/or
  13  * modify it under the terms of the GNU Lesser General Public
  14  * License as published by the Free Software Foundation; either
  15  * version 2.1 of the License, or (at your option) any later version.
  16  *
  17  * This library is distributed in the hope that it will be useful,
  18  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  19  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  20  * Lesser General Public License for more details.
  21  *
  22  * You should have received a copy of the GNU Lesser General Public
  23  * License along with this library; if not, write to the Free Software
  24  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  25  */
  26
  27 #include "config.h"
  28 #include <stdio.h>
  29 #ifdef HAVE_FLOAT_H
  30 # include <float.h>
  31 #endif
  32 #include "wined3d_private.h"
  33
  34 WINE_DEFAULT_DEBUG_CHANNEL(d3d);
  35 WINE_DECLARE_DEBUG_CHANNEL(d3d_shader);
  36
  37 #define GLINFO_LOCATION stateblock->wineD3DDevice->adapter->gl_info
  38
  39 static void state_blendop(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context);
  40
  41 static void state_nogl(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
  42     /* Used for states which are not mapped to a gl state as-is, but used somehow different,
  43      * e.g as a parameter for drawing, or which are unimplemented in windows d3d
  44      */
  45     if(STATE_IS_RENDER(state)) {
  46         WINED3DRENDERSTATETYPE RenderState = state - STATE_RENDER(0);
  47         TRACE("(%s,%d) no direct mapping to gl\n", debug_d3drenderstate(RenderState), stateblock->renderState[RenderState]);
  48     } else {
  49         /* Shouldn't have an unknown type here */
  50         FIXME("%d no direct mapping to gl of state with unknown type\n", state);
  51     }
  52 }
  53
  54 static void state_undefined(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
  55     /* Print a WARN, this allows the stateblock code to loop over all states to generate a display
  56      * list without causing confusing terminal output. Deliberately no special debug name here
  57      * because its undefined.
  58      */
  59     WARN("undefined state %d\n", state);
  60 }
  61
  62 static void state_fillmode(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
  63     WINED3DFILLMODE Value = stateblock->renderState[WINED3DRS_FILLMODE];
  64
  65     switch(Value) {
  66         case WINED3DFILL_POINT:
  67             glPolygonMode(GL_FRONT_AND_BACK, GL_POINT);
  68             checkGLcall("glPolygonMode(GL_FRONT_AND_BACK, GL_POINT)");
  69             break;
  70         case WINED3DFILL_WIREFRAME:
  71             glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
  72             checkGLcall("glPolygonMode(GL_FRONT_AND_BACK, GL_LINE)");
  73             break;
  74         case WINED3DFILL_SOLID:
  75             glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
  76             checkGLcall("glPolygonMode(GL_FRONT_AND_BACK, GL_FILL)");
  77             break;
  78         default:
  79             FIXME("Unrecognized WINED3DRS_FILLMODE value %d\n", Value);
  80     }
  81 }
  82
  83 static void state_lighting(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
  84     BOOL transformed;
  85
  86     /* Lighting is not enabled if transformed vertices are drawn
  87      * but lighting does not affect the stream sources, so it is not grouped for performance reasons.
  88      * This state reads the decoded vertex declaration, so if it is dirty don't do anything. The
  89      * vertex declaration applying function calls this function for updating
  90      */
  91
  92     if(isStateDirty(context, STATE_VDECL)) {
  93         return;
  94     }
  95
  96     transformed = ((stateblock->wineD3DDevice->strided_streams.u.s.position.lpData != NULL ||
  97                     stateblock->wineD3DDevice->strided_streams.u.s.position.VBO != 0) &&
  98                     stateblock->wineD3DDevice->strided_streams.u.s.position_transformed) ? TRUE : FALSE;
  99
 100     if (stateblock->renderState[WINED3DRS_LIGHTING] && !transformed) {
 101         glEnable(GL_LIGHTING);
 102         checkGLcall("glEnable GL_LIGHTING");
 103     } else {
 104         glDisable(GL_LIGHTING);
 105         checkGLcall("glDisable GL_LIGHTING");
 106     }
 107 }
 108
 109 static void state_zenable(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
 110     /* No z test without depth stencil buffers */
 111     if(stateblock->wineD3DDevice->stencilBufferTarget == NULL) {
 112         TRACE("No Z buffer - disabling depth test\n");
 113         glDisable(GL_DEPTH_TEST); /* This also disables z writing in gl */
 114         checkGLcall("glDisable GL_DEPTH_TEST");
 115         return;
 116     }
 117
 118     switch ((WINED3DZBUFFERTYPE) stateblock->renderState[WINED3DRS_ZENABLE]) {
 119         case WINED3DZB_FALSE:
 120             glDisable(GL_DEPTH_TEST);
 121             checkGLcall("glDisable GL_DEPTH_TEST");
 122             break;
 123         case WINED3DZB_TRUE:
 124             glEnable(GL_DEPTH_TEST);
 125             checkGLcall("glEnable GL_DEPTH_TEST");
 126             break;
 127         case WINED3DZB_USEW:
 128             glEnable(GL_DEPTH_TEST);
 129             checkGLcall("glEnable GL_DEPTH_TEST");
 130             FIXME("W buffer is not well handled\n");
 131             break;
 132         default:
 133             FIXME("Unrecognized D3DZBUFFERTYPE value %d\n", stateblock->renderState[WINED3DRS_ZENABLE]);
 134     }
 135 }
 136
 137 static void state_cullmode(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
 138     /* glFrontFace() is set in context.c at context init and on an offscreen / onscreen rendering
 139      * switch
 140      */
 141     switch ((WINED3DCULL) stateblock->renderState[WINED3DRS_CULLMODE]) {
 142         case WINED3DCULL_NONE:
 143             glDisable(GL_CULL_FACE);
 144             checkGLcall("glDisable GL_CULL_FACE");
 145             break;
 146         case WINED3DCULL_CW:
 147             glEnable(GL_CULL_FACE);
 148             checkGLcall("glEnable GL_CULL_FACE");
 149             glCullFace(GL_FRONT);
 150             checkGLcall("glCullFace(GL_FRONT)");
 151             break;
 152         case WINED3DCULL_CCW:
 153             glEnable(GL_CULL_FACE);
 154             checkGLcall("glEnable GL_CULL_FACE");
 155             glCullFace(GL_BACK);
 156             checkGLcall("glCullFace(GL_BACK)");
 157             break;
 158         default:
 159             FIXME("Unrecognized/Unhandled WINED3DCULL value %d\n", stateblock->renderState[WINED3DRS_CULLMODE]);
 160     }
 161 }
 162
 163 static void state_shademode(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
 164     switch ((WINED3DSHADEMODE) stateblock->renderState[WINED3DRS_SHADEMODE]) {
 165         case WINED3DSHADE_FLAT:
 166             glShadeModel(GL_FLAT);
 167             checkGLcall("glShadeModel(GL_FLAT)");
 168             break;
 169         case WINED3DSHADE_GOURAUD:
 170             glShadeModel(GL_SMOOTH);
 171             checkGLcall("glShadeModel(GL_SMOOTH)");
 172             break;
 173         case WINED3DSHADE_PHONG:
 174             FIXME("WINED3DSHADE_PHONG isn't supported\n");
 175             break;
 176         default:
 177             FIXME("Unrecognized/Unhandled WINED3DSHADEMODE value %d\n", stateblock->renderState[WINED3DRS_SHADEMODE]);
 178     }
 179 }
 180
 181 static void state_ditherenable(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
 182     if (stateblock->renderState[WINED3DRS_DITHERENABLE]) {
 183         glEnable(GL_DITHER);
 184         checkGLcall("glEnable GL_DITHER");
 185     } else {
 186         glDisable(GL_DITHER);
 187         checkGLcall("glDisable GL_DITHER");
 188     }
 189 }
 190
 191 static void state_zwritenable(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
 192     /* TODO: Test if in d3d z writing is enabled even if ZENABLE is off. If yes,
 193      * this has to be merged with ZENABLE and ZFUNC
 194      */
 195     if (stateblock->renderState[WINED3DRS_ZWRITEENABLE]) {
 196         glDepthMask(1);
 197         checkGLcall("glDepthMask(1)");
 198     } else {
 199         glDepthMask(0);
 200         checkGLcall("glDepthMask(0)");
 201     }
 202 }
 203
 204 static void state_zfunc(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
 205     int glParm = CompareFunc(stateblock->renderState[WINED3DRS_ZFUNC]);
 206
 207     if(glParm) {
 208         if(glParm == GL_EQUAL || glParm == GL_NOTEQUAL) {
 209             static BOOL once = FALSE;
 210             /* There are a few issues with this: First, our inability to
 211              * select a proper Z depth, most of the time we're stuck with
 212              * D24S8, even if the app selects D32 or D16. There seem to be
 213              * some other precision problems which have to be debugged to
 214              * make NOTEQUAL and EQUAL work properly
 215              */
 216             if(!once) {
 217                 once = TRUE;
 218                 FIXME("D3DCMP_NOTEQUAL and D3DCMP_EQUAL do not work correctly yet\n");
 219             }
 220         }
 221
 222         glDepthFunc(glParm);
 223         checkGLcall("glDepthFunc");
 224     }
 225 }
 226
 227 static void state_ambient(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
 228     float col[4];
 229     D3DCOLORTOGLFLOAT4(stateblock->renderState[WINED3DRS_AMBIENT], col);
 230
 231     TRACE("Setting ambient to (%f,%f,%f,%f)\n", col[0], col[1], col[2], col[3]);
 232     glLightModelfv(GL_LIGHT_MODEL_AMBIENT, col);
 233     checkGLcall("glLightModel for MODEL_AMBIENT");
 234 }
 235
 236 static void state_blend(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
 237     int srcBlend = GL_ZERO;
 238     int dstBlend = GL_ZERO;
 239     const StaticPixelFormatDesc *rtFormat;
 240     IWineD3DSurfaceImpl *target = (IWineD3DSurfaceImpl *) stateblock->wineD3DDevice->render_targets[0];
 241
 242     /* GL_LINE_SMOOTH needs GL_BLEND to work, according to the red book, and special blending params */
 243     if (stateblock->renderState[WINED3DRS_ALPHABLENDENABLE]      ||
 244         stateblock->renderState[WINED3DRS_EDGEANTIALIAS]         ||
 245         stateblock->renderState[WINED3DRS_ANTIALIASEDLINEENABLE]) {
 246         const GlPixelFormatDesc *glDesc;
 247         getFormatDescEntry(target->resource.format, &GLINFO_LOCATION, &glDesc);
 248
 249         /* Disable blending in all cases even without pixelshaders. With blending on we could face a big performance penalty.
 250          * The d3d9 visual test confirms the behavior. */
 251         if(!(glDesc->Flags & WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING)) {
 252             glDisable(GL_BLEND);
 253             checkGLcall("glDisable GL_BLEND");
 254             return;
 255         } else {
 256             glEnable(GL_BLEND);
 257             checkGLcall("glEnable GL_BLEND");
 258         }
 259     } else {
 260         glDisable(GL_BLEND);
 261         checkGLcall("glDisable GL_BLEND");
 262         /* Nothing more to do - get out */
 263         return;
 264     };
 265
 266     switch (stateblock->renderState[WINED3DRS_DESTBLEND]) {
 267         case WINED3DBLEND_ZERO               : dstBlend = GL_ZERO;  break;
 268         case WINED3DBLEND_ONE                : dstBlend = GL_ONE;  break;
 269         case WINED3DBLEND_SRCCOLOR           : dstBlend = GL_SRC_COLOR;  break;
 270         case WINED3DBLEND_INVSRCCOLOR        : dstBlend = GL_ONE_MINUS_SRC_COLOR;  break;
 271         case WINED3DBLEND_SRCALPHA           : dstBlend = GL_SRC_ALPHA;  break;
 272         case WINED3DBLEND_INVSRCALPHA        : dstBlend = GL_ONE_MINUS_SRC_ALPHA;  break;
 273         case WINED3DBLEND_DESTCOLOR          : dstBlend = GL_DST_COLOR;  break;
 274         case WINED3DBLEND_INVDESTCOLOR       : dstBlend = GL_ONE_MINUS_DST_COLOR;  break;
 275
 276         /* To compensate the lack of format switching with backbuffer offscreen rendering,
 277          * and with onscreen rendering, we modify the alpha test parameters for (INV)DESTALPHA
 278          * if the render target doesn't support alpha blending. A nonexistent alpha channel
 279          * returns 1.0, so D3DBLEND_DESTALPHA is GL_ONE, and D3DBLEND_INVDESTALPHA is GL_ZERO
 280          */
 281         case WINED3DBLEND_DESTALPHA          :
 282             rtFormat = getFormatDescEntry(target->resource.format, NULL, NULL);
 283             dstBlend = rtFormat->alphaMask ? GL_DST_ALPHA : GL_ONE;
 284             break;
 285         case WINED3DBLEND_INVDESTALPHA       :
 286             rtFormat = getFormatDescEntry(target->resource.format, NULL, NULL);
 287             dstBlend = rtFormat->alphaMask ? GL_ONE_MINUS_DST_ALPHA : GL_ZERO;
 288             break;
 289
 290         case WINED3DBLEND_SRCALPHASAT        :
 291             dstBlend = GL_SRC_ALPHA_SATURATE;
 292             WARN("Application uses SRCALPHASAT as dest blend factor, expect problems\n");
 293             break;
 294
 295         /* WINED3DBLEND_BOTHSRCALPHA and WINED3DBLEND_BOTHINVSRCALPHA are legacy source blending
 296          * values which are still valid up to d3d9. They should not occur as dest blend values
 297          */
 298         case WINED3DBLEND_BOTHSRCALPHA       : dstBlend = GL_SRC_ALPHA;
 299             srcBlend = GL_SRC_ALPHA;
 300             FIXME("WINED3DRS_DESTBLEND = WINED3DBLEND_BOTHSRCALPHA, what to do?\n");
 301             break;
 302
 303         case WINED3DBLEND_BOTHINVSRCALPHA    : dstBlend = GL_ONE_MINUS_SRC_ALPHA;
 304             srcBlend = GL_ONE_MINUS_SRC_ALPHA;
 305             FIXME("WINED3DRS_DESTBLEND = WINED3DBLEND_BOTHINVSRCALPHA, what to do?\n");
 306             break;
 307
 308         case WINED3DBLEND_BLENDFACTOR        : dstBlend = GL_CONSTANT_COLOR;   break;
 309         case WINED3DBLEND_INVBLENDFACTOR     : dstBlend = GL_ONE_MINUS_CONSTANT_COLOR;  break;
 310         default:
 311             FIXME("Unrecognized dst blend value %d\n", stateblock->renderState[WINED3DRS_DESTBLEND]);
 312     }
 313
 314     switch (stateblock->renderState[WINED3DRS_SRCBLEND]) {
 315         case WINED3DBLEND_ZERO               : srcBlend = GL_ZERO;  break;
 316         case WINED3DBLEND_ONE                : srcBlend = GL_ONE;  break;
 317         case WINED3DBLEND_SRCCOLOR           : srcBlend = GL_SRC_COLOR;  break;
 318         case WINED3DBLEND_INVSRCCOLOR        : srcBlend = GL_ONE_MINUS_SRC_COLOR;  break;
 319         case WINED3DBLEND_SRCALPHA           : srcBlend = GL_SRC_ALPHA;  break;
 320         case WINED3DBLEND_INVSRCALPHA        : srcBlend = GL_ONE_MINUS_SRC_ALPHA;  break;
 321         case WINED3DBLEND_DESTCOLOR          : srcBlend = GL_DST_COLOR;  break;
 322         case WINED3DBLEND_INVDESTCOLOR       : srcBlend = GL_ONE_MINUS_DST_COLOR;  break;
 323         case WINED3DBLEND_SRCALPHASAT        : srcBlend = GL_SRC_ALPHA_SATURATE;  break;
 324
 325         case WINED3DBLEND_DESTALPHA          :
 326             rtFormat = getFormatDescEntry(target->resource.format, NULL, NULL);
 327             srcBlend = rtFormat->alphaMask ? GL_DST_ALPHA : GL_ONE;
 328             break;
 329         case WINED3DBLEND_INVDESTALPHA       :
 330             rtFormat = getFormatDescEntry(target->resource.format, NULL, NULL);
 331             srcBlend = rtFormat->alphaMask ? GL_ONE_MINUS_DST_ALPHA : GL_ZERO;
 332             break;
 333
 334         case WINED3DBLEND_BOTHSRCALPHA       : srcBlend = GL_SRC_ALPHA;
 335             dstBlend = GL_ONE_MINUS_SRC_ALPHA;
 336             break;
 337
 338         case WINED3DBLEND_BOTHINVSRCALPHA    : srcBlend = GL_ONE_MINUS_SRC_ALPHA;
 339             dstBlend = GL_SRC_ALPHA;
 340             break;
 341
 342         case WINED3DBLEND_BLENDFACTOR        : srcBlend = GL_CONSTANT_COLOR;   break;
 343         case WINED3DBLEND_INVBLENDFACTOR     : srcBlend = GL_ONE_MINUS_CONSTANT_COLOR;  break;
 344         default:
 345             FIXME("Unrecognized src blend value %d\n", stateblock->renderState[WINED3DRS_SRCBLEND]);
 346     }
 347
 348     if(stateblock->renderState[WINED3DRS_EDGEANTIALIAS] ||
 349        stateblock->renderState[WINED3DRS_ANTIALIASEDLINEENABLE]) {
 350         glEnable(GL_LINE_SMOOTH);
 351         checkGLcall("glEnable(GL_LINE_SMOOTH)");
 352         if(srcBlend != GL_SRC_ALPHA) {
 353             WARN("WINED3DRS_EDGEANTIALIAS enabled, but unexpected src blending param\n");
 354         }
 355         if(dstBlend != GL_ONE_MINUS_SRC_ALPHA && dstBlend != GL_ONE) {
 356             WARN("WINED3DRS_EDGEANTIALIAS enabled, but unexpected dst blending param\n");
 357         }
 358     } else {
 359         glDisable(GL_LINE_SMOOTH);
 360         checkGLcall("glDisable(GL_LINE_SMOOTH)");
 361     }
 362
 363     /* Re-apply BLENDOP(ALPHA) because of a possible SEPARATEALPHABLENDENABLE change */
 364     if(!isStateDirty(context, STATE_RENDER(WINED3DRS_BLENDOP))) {
 365         state_blendop(STATE_RENDER(WINED3DRS_BLENDOPALPHA), stateblock, context);
 366     }
 367
 368     if(stateblock->renderState[WINED3DRS_SEPARATEALPHABLENDENABLE]) {
 369         int srcBlendAlpha = GL_ZERO;
 370         int dstBlendAlpha = GL_ZERO;
 371
 372         /* Separate alpha blending requires GL_EXT_blend_function_separate, so make sure it is around */
 373         if(!GL_SUPPORT(EXT_BLEND_FUNC_SEPARATE)) {
 374             WARN("Unsupported in local OpenGL implementation: glBlendFuncSeparateEXT\n");
 375             return;
 376         }
 377
 378         switch (stateblock->renderState[WINED3DRS_DESTBLENDALPHA]) {
 379             case WINED3DBLEND_ZERO               : dstBlendAlpha = GL_ZERO;  break;
 380             case WINED3DBLEND_ONE                : dstBlendAlpha = GL_ONE;  break;
 381             case WINED3DBLEND_SRCCOLOR           : dstBlendAlpha = GL_SRC_COLOR;  break;
 382             case WINED3DBLEND_INVSRCCOLOR        : dstBlendAlpha = GL_ONE_MINUS_SRC_COLOR;  break;
 383             case WINED3DBLEND_SRCALPHA           : dstBlendAlpha = GL_SRC_ALPHA;  break;
 384             case WINED3DBLEND_INVSRCALPHA        : dstBlendAlpha = GL_ONE_MINUS_SRC_ALPHA;  break;
 385             case WINED3DBLEND_DESTCOLOR          : dstBlendAlpha = GL_DST_COLOR;  break;
 386             case WINED3DBLEND_INVDESTCOLOR       : dstBlendAlpha = GL_ONE_MINUS_DST_COLOR;  break;
 387             case WINED3DBLEND_DESTALPHA          : dstBlendAlpha = GL_DST_ALPHA;  break;
 388             case WINED3DBLEND_INVDESTALPHA       : dstBlendAlpha = GL_DST_ALPHA;  break;
 389             case WINED3DBLEND_SRCALPHASAT        :
 390                 dstBlend = GL_SRC_ALPHA_SATURATE;
 391                 WARN("Application uses SRCALPHASAT as dest blend factor, expect problems\n");
 392                 break;
 393             /* WINED3DBLEND_BOTHSRCALPHA and WINED3DBLEND_BOTHINVSRCALPHA are legacy source blending
 394             * values which are still valid up to d3d9. They should not occur as dest blend values
 395             */
 396             case WINED3DBLEND_BOTHSRCALPHA       :
 397                 dstBlendAlpha = GL_SRC_ALPHA;
 398                 srcBlendAlpha = GL_SRC_ALPHA;
 399                 FIXME("WINED3DRS_DESTBLENDALPHA = WINED3DBLEND_BOTHSRCALPHA, what to do?\n");
 400                 break;
 401             case WINED3DBLEND_BOTHINVSRCALPHA    :
 402                 dstBlendAlpha = GL_ONE_MINUS_SRC_ALPHA;
 403                 srcBlendAlpha = GL_ONE_MINUS_SRC_ALPHA;
 404                 FIXME("WINED3DRS_DESTBLENDALPHA = WINED3DBLEND_BOTHINVSRCALPHA, what to do?\n");
 405                 break;
 406             case WINED3DBLEND_BLENDFACTOR        : dstBlendAlpha = GL_CONSTANT_COLOR;   break;
 407             case WINED3DBLEND_INVBLENDFACTOR     : dstBlendAlpha = GL_ONE_MINUS_CONSTANT_COLOR;  break;
 408             default:
 409                 FIXME("Unrecognized dst blend alpha value %d\n", stateblock->renderState[WINED3DRS_DESTBLENDALPHA]);
 410         }
 411
 412         switch (stateblock->renderState[WINED3DRS_SRCBLENDALPHA]) {
 413             case WINED3DBLEND_ZERO               : srcBlendAlpha = GL_ZERO;  break;
 414             case WINED3DBLEND_ONE                : srcBlendAlpha = GL_ONE;  break;
 415             case WINED3DBLEND_SRCCOLOR           : srcBlendAlpha = GL_SRC_COLOR;  break;
 416             case WINED3DBLEND_INVSRCCOLOR        : srcBlendAlpha = GL_ONE_MINUS_SRC_COLOR;  break;
 417             case WINED3DBLEND_SRCALPHA           : srcBlendAlpha = GL_SRC_ALPHA;  break;
 418             case WINED3DBLEND_INVSRCALPHA        : srcBlendAlpha = GL_ONE_MINUS_SRC_ALPHA;  break;
 419             case WINED3DBLEND_DESTCOLOR          : srcBlendAlpha = GL_DST_COLOR;  break;
 420             case WINED3DBLEND_INVDESTCOLOR       : srcBlendAlpha = GL_ONE_MINUS_DST_COLOR;  break;
 421             case WINED3DBLEND_SRCALPHASAT        : srcBlendAlpha = GL_SRC_ALPHA_SATURATE;  break;
 422             case WINED3DBLEND_DESTALPHA          : srcBlendAlpha = GL_DST_ALPHA;  break;
 423             case WINED3DBLEND_INVDESTALPHA       : srcBlendAlpha = GL_DST_ALPHA;  break;
 424             case WINED3DBLEND_BOTHSRCALPHA       :
 425                 srcBlendAlpha = GL_SRC_ALPHA;
 426                 dstBlendAlpha = GL_ONE_MINUS_SRC_ALPHA;
 427                 break;
 428             case WINED3DBLEND_BOTHINVSRCALPHA    :
 429                 srcBlendAlpha = GL_ONE_MINUS_SRC_ALPHA;
 430                 dstBlendAlpha = GL_SRC_ALPHA;
 431                 break;
 432             case WINED3DBLEND_BLENDFACTOR        : srcBlendAlpha = GL_CONSTANT_COLOR;   break;
 433             case WINED3DBLEND_INVBLENDFACTOR     : srcBlendAlpha = GL_ONE_MINUS_CONSTANT_COLOR;  break;
 434             default:
 435                 FIXME("Unrecognized src blend alpha value %d\n", stateblock->renderState[WINED3DRS_SRCBLENDALPHA]);
 436         }
 437
 438         GL_EXTCALL(glBlendFuncSeparateEXT(srcBlend, dstBlend, srcBlendAlpha, dstBlendAlpha));
 439         checkGLcall("glBlendFuncSeparateEXT");
 440     } else {
 441         TRACE("glBlendFunc src=%x, dst=%x\n", srcBlend, dstBlend);
 442         glBlendFunc(srcBlend, dstBlend);
 443         checkGLcall("glBlendFunc");
 444     }
 445
 446     /* colorkey fixup for stage 0 alphaop depends on WINED3DRS_ALPHABLENDENABLE state,
 447         so it may need updating */
 448     if (stateblock->renderState[WINED3DRS_COLORKEYENABLE]) {
 449         const struct StateEntry *StateTable = stateblock->wineD3DDevice->StateTable;
 450         StateTable[STATE_TEXTURESTAGE(0, WINED3DTSS_ALPHAOP)].apply(STATE_TEXTURESTAGE(0, WINED3DTSS_ALPHAOP), stateblock, context);
 451     }
 452 }
 453
 454 static void state_blendfactor(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
 455     float col[4];
 456
 457     if(!GL_SUPPORT(EXT_BLEND_COLOR)) {
 458         WARN("Unsupported in local OpenGL implementation: glBlendColorEXT\n");
 459         return;
 460     }
 461
 462     TRACE("Setting BlendFactor to %d\n", stateblock->renderState[WINED3DRS_BLENDFACTOR]);
 463     D3DCOLORTOGLFLOAT4(stateblock->renderState[WINED3DRS_BLENDFACTOR], col);
 464     GL_EXTCALL(glBlendColorEXT (col[0],col[1],col[2],col[3]));
 465     checkGLcall("glBlendColor");
 466 }
 467
 468 static void state_alpha(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
 469     int glParm = 0;
 470     float ref;
 471     BOOL enable_ckey = FALSE;
 472
 473     IWineD3DSurfaceImpl *surf;
 474
 475     /* Find out if the texture on the first stage has a ckey set
 476      * The alpha state func reads the texture settings, even though alpha and texture are not grouped
 477      * together. This is to avoid making a huge alpha+texture+texture stage+ckey block due to the hardly
 478      * used WINED3DRS_COLORKEYENABLE state(which is d3d <= 3 only). The texture function will call alpha
 479      * in case it finds some texture+colorkeyenable combination which needs extra care.
 480      */
 481     if(stateblock->textures[0] && (
 482        stateblock->textureDimensions[0] == GL_TEXTURE_2D ||
 483        stateblock->textureDimensions[0] == GL_TEXTURE_RECTANGLE_ARB)) {
 484         surf = (IWineD3DSurfaceImpl *) ((IWineD3DTextureImpl *)stateblock->textures[0])->surfaces[0];
 485
 486         if(surf->CKeyFlags & WINEDDSD_CKSRCBLT) {
 487             const StaticPixelFormatDesc *fmt = getFormatDescEntry(surf->resource.format, NULL, NULL);
 488             /* The surface conversion does not do color keying conversion for surfaces that have an alpha
 489              * channel on their own. Likewise, the alpha test shouldn't be set up for color keying if the
 490              * surface has alpha bits
 491              */
 492             if(fmt->alphaMask == 0x00000000) {
 493                 enable_ckey = TRUE;
 494             }
 495         }
 496     }
 497
 498     if(enable_ckey || context->last_was_ckey) {
 499         const struct StateEntry *StateTable = stateblock->wineD3DDevice->StateTable;
 500         StateTable[STATE_TEXTURESTAGE(0, WINED3DTSS_ALPHAOP)].apply(STATE_TEXTURESTAGE(0, WINED3DTSS_ALPHAOP), stateblock, context);
 501     }
 502     context->last_was_ckey = enable_ckey;
 503
 504     if (stateblock->renderState[WINED3DRS_ALPHATESTENABLE] ||
 505         (stateblock->renderState[WINED3DRS_COLORKEYENABLE] && enable_ckey)) {
 506         glEnable(GL_ALPHA_TEST);
 507         checkGLcall("glEnable GL_ALPHA_TEST");
 508     } else {
 509         glDisable(GL_ALPHA_TEST);
 510         checkGLcall("glDisable GL_ALPHA_TEST");
 511         /* Alpha test is disabled, don't bother setting the params - it will happen on the next
 512          * enable call
 513          */
 514         return;
 515     }
 516
 517     if(stateblock->renderState[WINED3DRS_COLORKEYENABLE] && enable_ckey) {
 518         glParm = GL_NOTEQUAL;
 519         ref = 0.0;
 520     } else {
 521         ref = ((float) stateblock->renderState[WINED3DRS_ALPHAREF]) / 255.0f;
 522         glParm = CompareFunc(stateblock->renderState[WINED3DRS_ALPHAFUNC]);
 523     }
 524     if(glParm) {
 525         glAlphaFunc(glParm, ref);
 526         checkGLcall("glAlphaFunc");
 527     }
 528 }
 529
 530 static void state_clipping(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
 531     DWORD enable  = 0xFFFFFFFF;
 532     DWORD disable = 0x00000000;
 533
 534     if (use_vs(stateblock->wineD3DDevice)) {
 535         /* The spec says that opengl clipping planes are disabled when using shaders. Direct3D planes aren't,
 536          * so that is an issue. The MacOS ATI driver keeps clipping planes activated with shaders in some
 537          * conditions I got sick of tracking down. The shader state handler disables all clip planes because
 538          * of that - don't do anything here and keep them disabled
 539          */
 540         if(stateblock->renderState[WINED3DRS_CLIPPLANEENABLE]) {
 541             static BOOL warned = FALSE;
 542             if(!warned) {
 543                 FIXME("Clipping not supported with vertex shaders\n");
 544                 warned = TRUE;
 545             }
 546         }
 547         return;
 548     }
 549
 550     /* TODO: Keep track of previously enabled clipplanes to avoid unnecessary resetting
 551      * of already set values
 552      */
 553
 554     /* If enabling / disabling all
 555      * TODO: Is this correct? Doesn't D3DRS_CLIPPING disable clipping on the viewport frustrum?
 556      */
 557     if (stateblock->renderState[WINED3DRS_CLIPPING]) {
 558         enable  = stateblock->renderState[WINED3DRS_CLIPPLANEENABLE];
 559         disable = ~stateblock->renderState[WINED3DRS_CLIPPLANEENABLE];
 560         if(GL_SUPPORT(NV_DEPTH_CLAMP)) {
 561             glDisable(GL_DEPTH_CLAMP_NV);
 562             checkGLcall("glDisable(GL_DEPTH_CLAMP_NV)");
 563         }
 564     } else {
 565         disable = 0xffffffff;
 566         enable  = 0x00;
 567         if(GL_SUPPORT(NV_DEPTH_CLAMP)) {
 568             glEnable(GL_DEPTH_CLAMP_NV);
 569             checkGLcall("glEnable(GL_DEPTH_CLAMP_NV)");
 570         }
 571     }
 572
 573     if (enable & WINED3DCLIPPLANE0)  { glEnable(GL_CLIP_PLANE0);  checkGLcall("glEnable(clip plane 0)"); }
 574     if (enable & WINED3DCLIPPLANE1)  { glEnable(GL_CLIP_PLANE1);  checkGLcall("glEnable(clip plane 1)"); }
 575     if (enable & WINED3DCLIPPLANE2)  { glEnable(GL_CLIP_PLANE2);  checkGLcall("glEnable(clip plane 2)"); }
 576     if (enable & WINED3DCLIPPLANE3)  { glEnable(GL_CLIP_PLANE3);  checkGLcall("glEnable(clip plane 3)"); }
 577     if (enable & WINED3DCLIPPLANE4)  { glEnable(GL_CLIP_PLANE4);  checkGLcall("glEnable(clip plane 4)"); }
 578     if (enable & WINED3DCLIPPLANE5)  { glEnable(GL_CLIP_PLANE5);  checkGLcall("glEnable(clip plane 5)"); }
 579
 580     if (disable & WINED3DCLIPPLANE0) { glDisable(GL_CLIP_PLANE0); checkGLcall("glDisable(clip plane 0)"); }
 581     if (disable & WINED3DCLIPPLANE1) { glDisable(GL_CLIP_PLANE1); checkGLcall("glDisable(clip plane 1)"); }
 582     if (disable & WINED3DCLIPPLANE2) { glDisable(GL_CLIP_PLANE2); checkGLcall("glDisable(clip plane 2)"); }
 583     if (disable & WINED3DCLIPPLANE3) { glDisable(GL_CLIP_PLANE3); checkGLcall("glDisable(clip plane 3)"); }
 584     if (disable & WINED3DCLIPPLANE4) { glDisable(GL_CLIP_PLANE4); checkGLcall("glDisable(clip plane 4)"); }
 585     if (disable & WINED3DCLIPPLANE5) { glDisable(GL_CLIP_PLANE5); checkGLcall("glDisable(clip plane 5)"); }
 586
 587     /** update clipping status */
 588     if (enable) {
 589         stateblock->clip_status.ClipUnion = 0;
 590         stateblock->clip_status.ClipIntersection = 0xFFFFFFFF;
 591     } else {
 592         stateblock->clip_status.ClipUnion = 0;
 593         stateblock->clip_status.ClipIntersection = 0;
 594     }
 595 }
 596
 597 static void state_blendop(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
 598     int blendEquation = GL_FUNC_ADD;
 599     int blendEquationAlpha = GL_FUNC_ADD;
 600
 601     if(!GL_SUPPORT(EXT_BLEND_MINMAX)) {
 602         WARN("Unsupported in local OpenGL implementation: glBlendEquation\n");
 603         return;
 604     }
 605
 606     /* BLENDOPALPHA requires GL_EXT_blend_equation_separate, so make sure it is around */
 607     if(stateblock->renderState[WINED3DRS_BLENDOPALPHA] && !GL_SUPPORT(EXT_BLEND_EQUATION_SEPARATE)) {
 608         WARN("Unsupported in local OpenGL implementation: glBlendEquationSeparateEXT\n");
 609         return;
 610     }
 611
 612     switch ((WINED3DBLENDOP) stateblock->renderState[WINED3DRS_BLENDOP]) {
 613         case WINED3DBLENDOP_ADD              : blendEquation = GL_FUNC_ADD;              break;
 614         case WINED3DBLENDOP_SUBTRACT         : blendEquation = GL_FUNC_SUBTRACT;         break;
 615         case WINED3DBLENDOP_REVSUBTRACT      : blendEquation = GL_FUNC_REVERSE_SUBTRACT; break;
 616         case WINED3DBLENDOP_MIN              : blendEquation = GL_MIN;                   break;
 617         case WINED3DBLENDOP_MAX              : blendEquation = GL_MAX;                   break;
 618         default:
 619             FIXME("Unrecognized/Unhandled D3DBLENDOP value %d\n", stateblock->renderState[WINED3DRS_BLENDOP]);
 620     }
 621
 622     switch ((WINED3DBLENDOP) stateblock->renderState[WINED3DRS_BLENDOPALPHA]) {
 623         case WINED3DBLENDOP_ADD              : blendEquationAlpha = GL_FUNC_ADD;              break;
 624         case WINED3DBLENDOP_SUBTRACT         : blendEquationAlpha = GL_FUNC_SUBTRACT;         break;
 625         case WINED3DBLENDOP_REVSUBTRACT      : blendEquationAlpha = GL_FUNC_REVERSE_SUBTRACT; break;
 626         case WINED3DBLENDOP_MIN              : blendEquationAlpha = GL_MIN;                   break;
 627         case WINED3DBLENDOP_MAX              : blendEquationAlpha = GL_MAX;                   break;
 628         default:
 629             FIXME("Unrecognized/Unhandled D3DBLENDOP value %d\n", stateblock->renderState[WINED3DRS_BLENDOPALPHA]);
 630     }
 631
 632     if(stateblock->renderState[WINED3DRS_SEPARATEALPHABLENDENABLE]) {
 633         TRACE("glBlendEquationSeparateEXT(%x, %x)\n", blendEquation, blendEquationAlpha);
 634         GL_EXTCALL(glBlendEquationSeparateEXT(blendEquation, blendEquationAlpha));
 635         checkGLcall("glBlendEquationSeparateEXT");
 636     } else {
 637         TRACE("glBlendEquation(%x)\n", blendEquation);
 638         GL_EXTCALL(glBlendEquationEXT(blendEquation));
 639         checkGLcall("glBlendEquation");
 640     }
 641 }
 642
 643 static void
 644 state_specularenable(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
 645     /* Originally this used glLightModeli(GL_LIGHT_MODEL_COLOR_CONTROL,GL_SEPARATE_SPECULAR_COLOR)
 646      * and (GL_LIGHT_MODEL_COLOR_CONTROL,GL_SINGLE_COLOR) to swap between enabled/disabled
 647      * specular color. This is wrong:
 648      * Separate specular color means the specular colour is maintained separately, whereas
 649      * single color means it is merged in. However in both cases they are being used to
 650      * some extent.
 651      * To disable specular color, set it explicitly to black and turn off GL_COLOR_SUM_EXT
 652      * NOTE: If not supported don't give FIXMEs the impact is really minimal and very few people are
 653      * running 1.4 yet!
 654      *
 655      *
 656      * If register combiners are enabled, enabling / disabling GL_COLOR_SUM has no effect.
 657      * Instead, we need to setup the FinalCombiner properly.
 658      *
 659      * The default setup for the FinalCombiner is:
 660      *
 661      * <variable>       <input>                             <mapping>               <usage>
 662      * GL_VARIABLE_A_NV GL_FOG,                             GL_UNSIGNED_IDENTITY_NV GL_ALPHA
 663      * GL_VARIABLE_B_NV GL_SPARE0_PLUS_SECONDARY_COLOR_NV   GL_UNSIGNED_IDENTITY_NV GL_RGB
 664      * GL_VARIABLE_C_NV GL_FOG                              GL_UNSIGNED_IDENTITY_NV GL_RGB
 665      * GL_VARIABLE_D_NV GL_ZERO                             GL_UNSIGNED_IDENTITY_NV GL_RGB
 666      * GL_VARIABLE_E_NV GL_ZERO                             GL_UNSIGNED_IDENTITY_NV GL_RGB
 667      * GL_VARIABLE_F_NV GL_ZERO                             GL_UNSIGNED_IDENTITY_NV GL_RGB
 668      * GL_VARIABLE_G_NV GL_SPARE0_NV                        GL_UNSIGNED_IDENTITY_NV GL_ALPHA
 669      *
 670      * That's pretty much fine as it is, except for variable B, which needs to take
 671      * either GL_SPARE0_PLUS_SECONDARY_COLOR_NV or GL_SPARE0_NV, depending on
 672      * whether WINED3DRS_SPECULARENABLE is enabled or not.
 673      */
 674
 675     TRACE("Setting specular enable state and materials\n");
 676     if (stateblock->renderState[WINED3DRS_SPECULARENABLE]) {
 677         glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, (float*) &stateblock->material.Specular);
 678         checkGLcall("glMaterialfv");
 679
 680         if(stateblock->material.Power > GL_LIMITS(shininess)) {
 681             /* glMaterialf man page says that the material says that GL_SHININESS must be between 0.0
 682              * and 128.0, although in d3d neither -1 nor 129 produce an error. GL_NV_max_light_exponent
 683              * allows bigger values. If the extension is supported, GL_LIMITS(shininess) contains the
 684              * value reported by the extension, otherwise 128. For values > GL_LIMITS(shininess) clamp
 685              * them, it should be safe to do so without major visual distortions.
 686              */
 687             WARN("Material power = %f, limit %f\n", stateblock->material.Power, GL_LIMITS(shininess));
 688             glMaterialf(GL_FRONT_AND_BACK, GL_SHININESS, GL_LIMITS(shininess));
 689         } else {
 690             glMaterialf(GL_FRONT_AND_BACK, GL_SHININESS, stateblock->material.Power);
 691         }
 692         checkGLcall("glMaterialf(GL_SHININESS)");
 693
 694         if (GL_SUPPORT(EXT_SECONDARY_COLOR)) {
 695             glEnable(GL_COLOR_SUM_EXT);
 696         } else {
 697             TRACE("Specular colors cannot be enabled in this version of opengl\n");
 698         }
 699         checkGLcall("glEnable(GL_COLOR_SUM)");
 700
 701         if (GL_SUPPORT(NV_REGISTER_COMBINERS)) {
 702             GL_EXTCALL(glFinalCombinerInputNV(GL_VARIABLE_B_NV, GL_SPARE0_PLUS_SECONDARY_COLOR_NV, GL_UNSIGNED_IDENTITY_NV, GL_RGB));
 703             checkGLcall("glFinalCombinerInputNV()");
 704         }
 705     } else {
 706         float black[4] = {0.0f, 0.0f, 0.0f, 0.0f};
 707
 708         /* for the case of enabled lighting: */
 709         glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, &black[0]);
 710         checkGLcall("glMaterialfv");
 711
 712         /* for the case of disabled lighting: */
 713         if (GL_SUPPORT(EXT_SECONDARY_COLOR)) {
 714             glDisable(GL_COLOR_SUM_EXT);
 715         } else {
 716             TRACE("Specular colors cannot be disabled in this version of opengl\n");
 717         }
 718         checkGLcall("glDisable(GL_COLOR_SUM)");
 719
 720         if (GL_SUPPORT(NV_REGISTER_COMBINERS)) {
 721             GL_EXTCALL(glFinalCombinerInputNV(GL_VARIABLE_B_NV, GL_SPARE0_NV, GL_UNSIGNED_IDENTITY_NV, GL_RGB));
 722             checkGLcall("glFinalCombinerInputNV()");
 723         }
 724     }
 725
 726     TRACE("(%p) : Diffuse (%f,%f,%f,%f)\n", stateblock->wineD3DDevice, stateblock->material.Diffuse.r, stateblock->material.Diffuse.g,
 727           stateblock->material.Diffuse.b, stateblock->material.Diffuse.a);
 728     TRACE("(%p) : Ambient (%f,%f,%f,%f)\n", stateblock->wineD3DDevice, stateblock->material.Ambient.r, stateblock->material.Ambient.g,
 729           stateblock->material.Ambient.b, stateblock->material.Ambient.a);
 730     TRACE("(%p) : Specular (%f,%f,%f,%f)\n", stateblock->wineD3DDevice, stateblock->material.Specular.r, stateblock->material.Specular.g,
 731           stateblock->material.Specular.b, stateblock->material.Specular.a);
 732     TRACE("(%p) : Emissive (%f,%f,%f,%f)\n", stateblock->wineD3DDevice, stateblock->material.Emissive.r, stateblock->material.Emissive.g,
 733           stateblock->material.Emissive.b, stateblock->material.Emissive.a);
 734
 735     glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT, (float*) &stateblock->material.Ambient);
 736     checkGLcall("glMaterialfv(GL_AMBIENT)");
 737     glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, (float*) &stateblock->material.Diffuse);
 738     checkGLcall("glMaterialfv(GL_DIFFUSE)");
 739     glMaterialfv(GL_FRONT_AND_BACK, GL_EMISSION, (float*) &stateblock->material.Emissive);
 740     checkGLcall("glMaterialfv(GL_EMISSION)");
 741 }
 742
 743 static void state_texfactor(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
 744     unsigned int i;
 745
 746     /* Note the texture color applies to all textures whereas
 747      * GL_TEXTURE_ENV_COLOR applies to active only
 748      */
 749     float col[4];
 750     D3DCOLORTOGLFLOAT4(stateblock->renderState[WINED3DRS_TEXTUREFACTOR], col);
 751
 752     if (!GL_SUPPORT(NV_REGISTER_COMBINERS)) {
 753         /* And now the default texture color as well */
 754         for (i = 0; i < GL_LIMITS(texture_stages); i++) {
 755             /* Note the WINED3DRS value applies to all textures, but GL has one
 756              * per texture, so apply it now ready to be used!
 757              */
 758             if (GL_SUPPORT(ARB_MULTITEXTURE)) {
 759                 GL_EXTCALL(glActiveTextureARB(GL_TEXTURE0_ARB + i));
 760                 checkGLcall("glActiveTextureARB");
 761             } else if (i>0) {
 762                 FIXME("Program using multiple concurrent textures which this opengl implementation doesn't support\n");
 763             }
 764
 765             glTexEnvfv(GL_TEXTURE_ENV, GL_TEXTURE_ENV_COLOR, &col[0]);
 766             checkGLcall("glTexEnvfv(GL_TEXTURE_ENV, GL_TEXTURE_ENV_COLOR, color);");
 767         }
 768     } else {
 769         GL_EXTCALL(glCombinerParameterfvNV(GL_CONSTANT_COLOR0_NV, &col[0]));
 770     }
 771 }
 772
 773 static void
 774 renderstate_stencil_twosided(IWineD3DStateBlockImpl *stateblock, GLint face, GLint func, GLint ref, GLuint mask, GLint stencilFail, GLint depthFail, GLint stencilPass ) {
 775     glEnable(GL_STENCIL_TEST_TWO_SIDE_EXT);
 776     checkGLcall("glEnable(GL_STENCIL_TEST_TWO_SIDE_EXT)");
 777     GL_EXTCALL(glActiveStencilFaceEXT(face));
 778     checkGLcall("glActiveStencilFaceEXT(...)");
 779     glStencilFunc(func, ref, mask);
 780     checkGLcall("glStencilFunc(...)");
 781     glStencilOp(stencilFail, depthFail, stencilPass);
 782     checkGLcall("glStencilOp(...)");
 783 }
 784
 785 static void
 786 state_stencil(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
 787     DWORD onesided_enable = FALSE;
 788     DWORD twosided_enable = FALSE;
 789     GLint func = GL_ALWAYS;
 790     GLint func_ccw = GL_ALWAYS;
 791     GLint ref = 0;
 792     GLuint mask = 0;
 793     GLint stencilFail = GL_KEEP;
 794     GLint depthFail = GL_KEEP;
 795     GLint stencilPass = GL_KEEP;
 796     GLint stencilFail_ccw = GL_KEEP;
 797     GLint depthFail_ccw = GL_KEEP;
 798     GLint stencilPass_ccw = GL_KEEP;
 799
 800     /* No stencil test without a stencil buffer */
 801     if(stateblock->wineD3DDevice->stencilBufferTarget == NULL) {
 802         glDisable(GL_STENCIL_TEST);
 803         checkGLcall("glDisable GL_STENCIL_TEST");
 804         return;
 805     }
 806
 807     onesided_enable = stateblock->renderState[WINED3DRS_STENCILENABLE];
 808     twosided_enable = stateblock->renderState[WINED3DRS_TWOSIDEDSTENCILMODE];
 809     if( !( func = CompareFunc(stateblock->renderState[WINED3DRS_STENCILFUNC]) ) )
 810         func = GL_ALWAYS;
 811     if( !( func_ccw = CompareFunc(stateblock->renderState[WINED3DRS_CCW_STENCILFUNC]) ) )
 812         func_ccw = GL_ALWAYS;
 813     ref = stateblock->renderState[WINED3DRS_STENCILREF];
 814     mask = stateblock->renderState[WINED3DRS_STENCILMASK];
 815     stencilFail = StencilOp(stateblock->renderState[WINED3DRS_STENCILFAIL]);
 816     depthFail = StencilOp(stateblock->renderState[WINED3DRS_STENCILZFAIL]);
 817     stencilPass = StencilOp(stateblock->renderState[WINED3DRS_STENCILPASS]);
 818     stencilFail_ccw = StencilOp(stateblock->renderState[WINED3DRS_CCW_STENCILFAIL]);
 819     depthFail_ccw = StencilOp(stateblock->renderState[WINED3DRS_CCW_STENCILZFAIL]);
 820     stencilPass_ccw = StencilOp(stateblock->renderState[WINED3DRS_CCW_STENCILPASS]);
 821
 822     TRACE("(onesided %d, twosided %d, ref %x, mask %x, "
 823           "GL_FRONT: func: %x, fail %x, zfail %x, zpass %x "
 824           "GL_BACK: func: %x, fail %x, zfail %x, zpass %x )\n",
 825     onesided_enable, twosided_enable, ref, mask,
 826     func, stencilFail, depthFail, stencilPass,
 827     func_ccw, stencilFail_ccw, depthFail_ccw, stencilPass_ccw);
 828
 829     if (twosided_enable && onesided_enable) {
 830         glEnable(GL_STENCIL_TEST);
 831         checkGLcall("glEnable GL_STENCIL_TEST");
 832
 833         if(GL_SUPPORT(EXT_STENCIL_TWO_SIDE)) {
 834             /* Apply back first, then front. This function calls glActiveStencilFaceEXT,
 835              * which has an effect on the code below too. If we apply the front face
 836              * afterwards, we are sure that the active stencil face is set to front,
 837              * and other stencil functions which do not use two sided stencil do not have
 838              * to set it back
 839              */
 840             renderstate_stencil_twosided(stateblock, GL_BACK, func_ccw, ref, mask,
 841                                          stencilFail_ccw, depthFail_ccw, stencilPass_ccw);
 842             renderstate_stencil_twosided(stateblock, GL_FRONT, func, ref, mask,
 843                                          stencilFail, depthFail, stencilPass);
 844         } else if(GL_SUPPORT(ATI_SEPARATE_STENCIL)) {
 845             GL_EXTCALL(glStencilFuncSeparateATI(func, func_ccw, ref, mask));
 846             checkGLcall("glStencilFuncSeparateATI(...)");
 847             GL_EXTCALL(glStencilOpSeparateATI(GL_FRONT, stencilFail, depthFail, stencilPass));
 848             checkGLcall("glStencilOpSeparateATI(GL_FRONT, ...)");
 849             GL_EXTCALL(glStencilOpSeparateATI(GL_BACK, stencilFail_ccw, depthFail_ccw, stencilPass_ccw));
 850             checkGLcall("glStencilOpSeparateATI(GL_BACK, ...)");
 851         } else {
 852             ERR("Separate (two sided) stencil not supported on this version of opengl. Caps weren't honored?\n");
 853         }
 854     } else if(onesided_enable) {
 855         if(GL_SUPPORT(EXT_STENCIL_TWO_SIDE)) {
 856             glDisable(GL_STENCIL_TEST_TWO_SIDE_EXT);
 857             checkGLcall("glDisable(GL_STENCIL_TEST_TWO_SIDE_EXT)");
 858         }
 859
 860         /* This code disables the ATI extension as well, since the standard stencil functions are equal
 861          * to calling the ATI functions with GL_FRONT_AND_BACK as face parameter
 862          */
 863         glEnable(GL_STENCIL_TEST);
 864         checkGLcall("glEnable GL_STENCIL_TEST");
 865         glStencilFunc(func, ref, mask);
 866         checkGLcall("glStencilFunc(...)");
 867         glStencilOp(stencilFail, depthFail, stencilPass);
 868         checkGLcall("glStencilOp(...)");
 869     } else {
 870         glDisable(GL_STENCIL_TEST);
 871         checkGLcall("glDisable GL_STENCIL_TEST");
 872     }
 873 }
 874
 875 static void state_stencilwrite(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
 876     DWORD mask;
 877
 878     if(stateblock->wineD3DDevice->stencilBufferTarget) {
 879         mask = stateblock->renderState[WINED3DRS_STENCILWRITEMASK];
 880     } else {
 881         mask = 0;
 882     }
 883
 884     if(GL_SUPPORT(EXT_STENCIL_TWO_SIDE)) {
 885         GL_EXTCALL(glActiveStencilFaceEXT(GL_BACK));
 886         checkGLcall("glActiveStencilFaceEXT(GL_BACK)");
 887         glStencilMask(mask);
 888         checkGLcall("glStencilMask");
 889         GL_EXTCALL(glActiveStencilFaceEXT(GL_FRONT));
 890         checkGLcall("glActiveStencilFaceEXT(GL_FRONT)");
 891         glStencilMask(mask);
 892     } else {
 893         glStencilMask(mask);
 894     }
 895     checkGLcall("glStencilMask");
 896 }
 897
 898 static void state_fog(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
 899     BOOL fogenable = stateblock->renderState[WINED3DRS_FOGENABLE];
 900     BOOL is_ps3 = use_ps(stateblock->wineD3DDevice)
 901                   && ((IWineD3DPixelShaderImpl *)stateblock->pixelShader)->baseShader.hex_version >= WINED3DPS_VERSION(3,0);
 902     float fogstart, fogend;
 903
 904     union {
 905         DWORD d;
 906         float f;
 907     } tmpvalue;
 908
 909     if (!fogenable) {
 910         /* No fog? Disable it, and we're done :-) */
 911         glDisable(GL_FOG);
 912         checkGLcall("glDisable GL_FOG");
 913         if( use_ps(stateblock->wineD3DDevice)
 914                 && ((IWineD3DPixelShaderImpl *)stateblock->pixelShader)->baseShader.hex_version < WINED3DPS_VERSION(3,0) ) {
 915             /* disable fog in the pixel shader
 916              * NOTE: For pixel shader, GL_FOG_START and GL_FOG_END don't hold fog start s and end e but
 917              * -1/(e-s) and e/(e-s) respectively.
 918              */
 919             glFogf(GL_FOG_START, 0.0f);
 920             checkGLcall("glFogf(GL_FOG_START, fogstart)");
 921             glFogf(GL_FOG_END, 1.0f);
 922             checkGLcall("glFogf(GL_FOG_END, fogend)");
 923         }
 924         return;
 925     }
 926
 927     tmpvalue.d = stateblock->renderState[WINED3DRS_FOGSTART];
 928     fogstart = tmpvalue.f;
 929     tmpvalue.d = stateblock->renderState[WINED3DRS_FOGEND];
 930     fogend = tmpvalue.f;
 931
 932     /* Fog Rules:
 933      *
 934      * With fixed function vertex processing, Direct3D knows 2 different fog input sources.
 935      * It can use the Z value of the vertex, or the alpha component of the specular color.
 936      * This depends on the fog vertex, fog table and the vertex declaration. If the Z value
 937      * is used, fogstart, fogend and the equation type are used, otherwise linear fog with
 938      * start = 255, end = 0 is used. Obviously the msdn is not very clear on that.
 939      *
 940      * FOGTABLEMODE != NONE:
 941      *  The Z value is used, with the equation specified, no matter what vertex type.
 942      *
 943      * FOGTABLEMODE == NONE, FOGVERTEXMODE != NONE, untransformed:
 944      *  Per vertex fog is calculated using the specified fog equation and the parameters
 945      *
 946      * FOGTABLEMODE == NONE, FOGVERTEXMODE != NONE, transformed, OR
 947      * FOGTABLEMODE == NONE, FOGVERTEXMODE == NONE, untransformed:
 948      *  Linear fog with start = 255.0, end = 0.0, input comes from the specular color
 949      *
 950      *
 951      * Rules for vertex fog with shaders:
 952      *
 953      * When mixing fixed function functionality with the programmable pipeline, D3D expects
 954      * the fog computation to happen during transformation while openGL expects it to happen
 955      * during rasterization. Also, prior to pixel shader 3.0 D3D handles fog blending after
 956      * the pixel shader while openGL always expects the pixel shader to handle the blending.
 957      * To solve this problem, WineD3D does:
 958      * 1) implement a linear fog equation and fog blending at the end of every pre 3.0 pixel
 959      * shader,
 960      * and 2) disables the fog computation (in either the fixed function or programmable
 961      * rasterizer) if using a vertex program.
 962      *
 963      *
 964      * If a fogtablemode and a fogvertexmode are specified, table fog is applied (with or
 965      * without shaders).
 966      */
 967
 968     if( is_ps3 ) {
 969         if( !use_vs(stateblock->wineD3DDevice)
 970                 && stateblock->renderState[WINED3DRS_FOGTABLEMODE] == WINED3DFOG_NONE ) {
 971             FIXME("Implement vertex fog for pixel shader >= 3.0 and fixed function pipeline\n");
 972         }
 973     }
 974
 975     if (use_vs(stateblock->wineD3DDevice)
 976             && ((IWineD3DVertexShaderImpl *)stateblock->vertexShader)->baseShader.reg_maps.fog) {
 977         if( stateblock->renderState[WINED3DRS_FOGTABLEMODE] != WINED3DFOG_NONE ) {
 978             if(!is_ps3) FIXME("Implement table fog for foggy vertex shader\n");
 979             /* Disable fog */
 980             fogenable = FALSE;
 981         } else {
 982             /* Set fog computation in the rasterizer to pass through the value (just blend it) */
 983             glFogi(GL_FOG_MODE, GL_LINEAR);
 984             checkGLcall("glFogi(GL_FOG_MODE, GL_LINEAR)");
 985             fogstart = 1.0;
 986             fogend = 0.0;
 987         }
 988
 989         if(GL_SUPPORT(EXT_FOG_COORD) && context->fog_coord) {
 990             glFogi(GL_FOG_COORDINATE_SOURCE_EXT, GL_FRAGMENT_DEPTH_EXT);
 991             checkGLcall("glFogi(GL_FOG_COORDINATE_SOURCE_EXT, GL_FRAGMENT_DEPTH_EXT)");
 992             context->fog_coord = FALSE;
 993         }
 994         context->last_was_foggy_shader = TRUE;
 995     }
 996     else if( use_ps(stateblock->wineD3DDevice) ) {
 997         /* NOTE: For pixel shader, GL_FOG_START and GL_FOG_END don't hold fog start s and end e but
 998          * -1/(e-s) and e/(e-s) respectively to simplify fog computation in the shader.
 999          */
1000         WINED3DFOGMODE mode;
1001         context->last_was_foggy_shader = FALSE;
1002
1003         /* If both fogmodes are set use the table fog mode */
1004         if(stateblock->renderState[WINED3DRS_FOGTABLEMODE] == WINED3DFOG_NONE)
1005             mode = stateblock->renderState[WINED3DRS_FOGVERTEXMODE];
1006         else
1007             mode = stateblock->renderState[WINED3DRS_FOGTABLEMODE];
1008
1009         switch (mode) {
1010             case WINED3DFOG_EXP:
1011             case WINED3DFOG_EXP2:
1012                 if(!is_ps3) FIXME("Implement non linear fog for pixel shader < 3.0\n");
1013                 /* Disable fog */
1014                 fogenable = FALSE;
1015                 break;
1016
1017             case WINED3DFOG_LINEAR:
1018                 fogstart = -1.0f/(fogend-fogstart);
1019                 fogend *= -fogstart;
1020                 break;
1021
1022             case WINED3DFOG_NONE:
1023                 if(!is_ps3) FIXME("Implement software vertex fog for pixel shader < 3.0\n");
1024                 /* Disable fog */
1025                 fogenable = FALSE;
1026                 break;
1027             default: FIXME("Unexpected WINED3DRS_FOGVERTEXMODE %d\n", stateblock->renderState[WINED3DRS_FOGVERTEXMODE]);
1028         }
1029
1030         if(GL_SUPPORT(EXT_FOG_COORD) && context->fog_coord) {
1031             glFogi(GL_FOG_COORDINATE_SOURCE_EXT, GL_FRAGMENT_DEPTH_EXT);
1032             checkGLcall("glFogi(GL_FOG_COORDINATE_SOURCE_EXT, GL_FRAGMENT_DEPTH_EXT)");
1033             context->fog_coord = FALSE;
1034         }
1035     }
1036     /* DX 7 sdk: "If both render states(vertex and table fog) are set to valid modes,
1037      * the system will apply only pixel(=table) fog effects."
1038      */
1039     else if(stateblock->renderState[WINED3DRS_FOGTABLEMODE] == WINED3DFOG_NONE) {
1040         glHint(GL_FOG_HINT, GL_FASTEST);
1041         checkGLcall("glHint(GL_FOG_HINT, GL_FASTEST)");
1042         context->last_was_foggy_shader = FALSE;
1043
1044         switch (stateblock->renderState[WINED3DRS_FOGVERTEXMODE]) {
1045             /* If processed vertices are used, fall through to the NONE case */
1046             case WINED3DFOG_EXP:  {
1047                 if(!context->last_was_rhw) {
1048                     glFogi(GL_FOG_MODE, GL_EXP);
1049                     checkGLcall("glFogi(GL_FOG_MODE, GL_EXP)");
1050                     if(GL_SUPPORT(EXT_FOG_COORD) && context->fog_coord) {
1051                         glFogi(GL_FOG_COORDINATE_SOURCE_EXT, GL_FRAGMENT_DEPTH_EXT);
1052                         checkGLcall("glFogi(GL_FOG_COORDINATE_SOURCE_EXT, GL_FRAGMENT_DEPTH_EXT)");
1053                         context->fog_coord = FALSE;
1054                     }
1055                     break;
1056                 }
1057             }
1058             case WINED3DFOG_EXP2: {
1059                 if(!context->last_was_rhw) {
1060                     glFogi(GL_FOG_MODE, GL_EXP2);
1061                     checkGLcall("glFogi(GL_FOG_MODE, GL_EXP2)");
1062                     if(GL_SUPPORT(EXT_FOG_COORD) && context->fog_coord) {
1063                         glFogi(GL_FOG_COORDINATE_SOURCE_EXT, GL_FRAGMENT_DEPTH_EXT);
1064                         checkGLcall("glFogi(GL_FOG_COORDINATE_SOURCE_EXT, GL_FRAGMENT_DEPTH_EXT)");
1065                         context->fog_coord = FALSE;
1066                     }
1067                     break;
1068                 }
1069             }
1070             case WINED3DFOG_LINEAR: {
1071                 if(!context->last_was_rhw) {
1072                     glFogi(GL_FOG_MODE, GL_LINEAR);
1073                     checkGLcall("glFogi(GL_FOG_MODE, GL_LINEAR)");
1074                     if(GL_SUPPORT(EXT_FOG_COORD) && context->fog_coord) {
1075                         glFogi(GL_FOG_COORDINATE_SOURCE_EXT, GL_FRAGMENT_DEPTH_EXT);
1076                         checkGLcall("glFogi(GL_FOG_COORDINATE_SOURCE_EXT, GL_FRAGMENT_DEPTH_EXT)");
1077                         context->fog_coord = FALSE;
1078                     }
1079                     break;
1080                 }
1081             }
1082             case WINED3DFOG_NONE: {
1083                 /* Both are none? According to msdn the alpha channel of the specular
1084                  * color contains a fog factor. Set it in drawStridedSlow.
1085                  * Same happens with Vertexfog on transformed vertices
1086                  */
1087                 if(GL_SUPPORT(EXT_FOG_COORD)) {
1088                     if(context->fog_coord == FALSE) {
1089                         glFogi(GL_FOG_COORDINATE_SOURCE_EXT, GL_FOG_COORDINATE_EXT);
1090                         checkGLcall("glFogi(GL_FOG_COORDINATE_SOURCE_EXT, GL_FOG_COORDINATE_EXT)");
1091                         context->fog_coord = TRUE;
1092                     }
1093                     glFogi(GL_FOG_MODE, GL_LINEAR);
1094                     checkGLcall("glFogi(GL_FOG_MODE, GL_LINEAR)");
1095                     fogstart = 0xff;
1096                     fogend = 0x0;
1097                 } else {
1098                     /* Disable GL fog, handle this in software in drawStridedSlow */
1099                     fogenable = FALSE;
1100                 }
1101                 break;
1102             }
1103             default: FIXME("Unexpected WINED3DRS_FOGVERTEXMODE %d\n", stateblock->renderState[WINED3DRS_FOGVERTEXMODE]);
1104         }
1105     } else {
1106         glHint(GL_FOG_HINT, GL_NICEST);
1107         checkGLcall("glHint(GL_FOG_HINT, GL_NICEST)");
1108         context->last_was_foggy_shader = FALSE;
1109
1110         switch (stateblock->renderState[WINED3DRS_FOGTABLEMODE]) {
1111             case WINED3DFOG_EXP:
1112                 glFogi(GL_FOG_MODE, GL_EXP);
1113                 checkGLcall("glFogi(GL_FOG_MODE, GL_EXP)");
1114                 if(GL_SUPPORT(EXT_FOG_COORD) && context->fog_coord) {
1115                     glFogi(GL_FOG_COORDINATE_SOURCE_EXT, GL_FRAGMENT_DEPTH_EXT);
1116                     checkGLcall("glFogi(GL_FOG_COORDINATE_SOURCE_EXT, GL_FRAGMENT_DEPTH_EXT)");
1117                     context->fog_coord = FALSE;
1118                 }
1119                 break;
1120
1121             case WINED3DFOG_EXP2:
1122                 glFogi(GL_FOG_MODE, GL_EXP2);
1123                 checkGLcall("glFogi(GL_FOG_MODE, GL_EXP2)");
1124                 if(GL_SUPPORT(EXT_FOG_COORD) && context->fog_coord) {
1125                     glFogi(GL_FOG_COORDINATE_SOURCE_EXT, GL_FRAGMENT_DEPTH_EXT);
1126                     checkGLcall("glFogi(GL_FOG_COORDINATE_SOURCE_EXT, GL_FRAGMENT_DEPTH_EXT)");
1127                     context->fog_coord = FALSE;
1128                 }
1129                 break;
1130
1131             case WINED3DFOG_LINEAR:
1132                 glFogi(GL_FOG_MODE, GL_LINEAR);
1133                 checkGLcall("glFogi(GL_FOG_MODE, GL_LINEAR)");
1134                 if(GL_SUPPORT(EXT_FOG_COORD) && context->fog_coord) {
1135                     glFogi(GL_FOG_COORDINATE_SOURCE_EXT, GL_FRAGMENT_DEPTH_EXT);
1136                     checkGLcall("glFogi(GL_FOG_COORDINATE_SOURCE_EXT, GL_FRAGMENT_DEPTH_EXT)");
1137                     context->fog_coord = FALSE;
1138                 }
1139                 break;
1140
1141             case WINED3DFOG_NONE:   /* Won't happen */
1142             default:
1143                 FIXME("Unexpected WINED3DRS_FOGTABLEMODE %d\n", stateblock->renderState[WINED3DRS_FOGTABLEMODE]);
1144         }
1145     }
1146
1147     if(fogenable) {
1148         glEnable(GL_FOG);
1149         checkGLcall("glEnable GL_FOG");
1150
1151         if(fogstart != fogend)
1152         {
1153             glFogfv(GL_FOG_START, &fogstart);
1154             checkGLcall("glFogf(GL_FOG_START, fogstart)");
1155             TRACE("Fog Start == %f\n", fogstart);
1156
1157             glFogfv(GL_FOG_END, &fogend);
1158             checkGLcall("glFogf(GL_FOG_END, fogend)");
1159             TRACE("Fog End == %f\n", fogend);
1160         }
1161         else
1162         {
1163             glFogf(GL_FOG_START, -1.0 / 0.0);
1164             checkGLcall("glFogf(GL_FOG_START, fogstart)");
1165             TRACE("Fog Start == %f\n", fogstart);
1166
1167             glFogf(GL_FOG_END, 0.0);
1168             checkGLcall("glFogf(GL_FOG_END, fogend)");
1169             TRACE("Fog End == %f\n", fogend);
1170         }
1171     } else {
1172         glDisable(GL_FOG);
1173         checkGLcall("glDisable GL_FOG");
1174         if( use_ps(stateblock->wineD3DDevice) ) {
1175             /* disable fog in the pixel shader
1176              * NOTE: For pixel shader, GL_FOG_START and GL_FOG_END don't hold fog start s and end e but
1177              * -1/(e-s) and e/(e-s) respectively.
1178              */
1179             glFogf(GL_FOG_START, 0.0f);
1180             checkGLcall("glFogf(GL_FOG_START, fogstart)");
1181             glFogf(GL_FOG_END, 1.0f);
1182             checkGLcall("glFogf(GL_FOG_END, fogend)");
1183         }
1184     }
1185 }
1186
1187 static void state_rangefog(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
1188     if(stateblock->renderState[WINED3DRS_RANGEFOGENABLE]) {
1189         if (GL_SUPPORT(NV_FOG_DISTANCE)) {
1190             glFogi(GL_FOG_DISTANCE_MODE_NV, GL_EYE_RADIAL_NV);
1191             checkGLcall("glFogi(GL_FOG_DISTANCE_MODE_NV, GL_EYE_RADIAL_NV)");
1192         } else {
1193             WARN("Range fog enabled, but not supported by this opengl implementation\n");
1194         }
1195     } else {
1196         if (GL_SUPPORT(NV_FOG_DISTANCE)) {
1197             glFogi(GL_FOG_DISTANCE_MODE_NV, GL_EYE_PLANE_ABSOLUTE_NV);
1198             checkGLcall("glFogi(GL_FOG_DISTANCE_MODE_NV, GL_EYE_PLANE_ABSOLUTE_NV)");
1199         }
1200     }
1201 }
1202
1203 static void state_fogcolor(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
1204     float col[4];
1205     D3DCOLORTOGLFLOAT4(stateblock->renderState[WINED3DRS_FOGCOLOR], col);
1206     glFogfv(GL_FOG_COLOR, &col[0]);
1207     checkGLcall("glFog GL_FOG_COLOR");
1208 }
1209
1210 static void state_fogdensity(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
1211     union {
1212         DWORD d;
1213         float f;
1214     } tmpvalue;
1215     tmpvalue.d = stateblock->renderState[WINED3DRS_FOGDENSITY];
1216     glFogfv(GL_FOG_DENSITY, &tmpvalue.f);
1217     checkGLcall("glFogf(GL_FOG_DENSITY, (float) Value)");
1218 }
1219
1220 /* TODO: Merge with primitive type + init_materials()!! */
1221 static void state_colormat(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
1222     IWineD3DDeviceImpl *device = stateblock->wineD3DDevice;
1223     GLenum Parm = 0;
1224     WineDirect3DStridedData *diffuse = &device->strided_streams.u.s.diffuse;
1225     BOOL isDiffuseSupplied;
1226
1227     /* Depends on the decoded vertex declaration to read the existence of diffuse data.
1228      * The vertex declaration will call this function if the fixed function pipeline is used.
1229      */
1230
1231     if(isStateDirty(context, STATE_VDECL)) {
1232         return;
1233     }
1234
1235     isDiffuseSupplied = diffuse->lpData || diffuse->VBO;
1236
1237     context->num_untracked_materials = 0;
1238     if (isDiffuseSupplied && stateblock->renderState[WINED3DRS_COLORVERTEX]) {
1239         TRACE("diff %d, amb %d, emis %d, spec %d\n",
1240               stateblock->renderState[WINED3DRS_DIFFUSEMATERIALSOURCE],
1241               stateblock->renderState[WINED3DRS_AMBIENTMATERIALSOURCE],
1242               stateblock->renderState[WINED3DRS_EMISSIVEMATERIALSOURCE],
1243               stateblock->renderState[WINED3DRS_SPECULARMATERIALSOURCE]);
1244
1245         if (stateblock->renderState[WINED3DRS_DIFFUSEMATERIALSOURCE] == WINED3DMCS_COLOR1) {
1246             if (stateblock->renderState[WINED3DRS_AMBIENTMATERIALSOURCE] == WINED3DMCS_COLOR1) {
1247                 Parm = GL_AMBIENT_AND_DIFFUSE;
1248             } else {
1249                 Parm = GL_DIFFUSE;
1250             }
1251             if(stateblock->renderState[WINED3DRS_EMISSIVEMATERIALSOURCE] == WINED3DMCS_COLOR1) {
1252                 context->untracked_materials[context->num_untracked_materials] = GL_EMISSION;
1253                 context->num_untracked_materials++;
1254             }
1255             if(stateblock->renderState[WINED3DRS_SPECULARMATERIALSOURCE] == WINED3DMCS_COLOR1) {
1256                 context->untracked_materials[context->num_untracked_materials] = GL_SPECULAR;
1257                 context->num_untracked_materials++;
1258             }
1259         } else if (stateblock->renderState[WINED3DRS_AMBIENTMATERIALSOURCE] == WINED3DMCS_COLOR1) {
1260             Parm = GL_AMBIENT;
1261             if(stateblock->renderState[WINED3DRS_EMISSIVEMATERIALSOURCE] == WINED3DMCS_COLOR1) {
1262                 context->untracked_materials[context->num_untracked_materials] = GL_EMISSION;
1263                 context->num_untracked_materials++;
1264             }
1265             if(stateblock->renderState[WINED3DRS_SPECULARMATERIALSOURCE] == WINED3DMCS_COLOR1) {
1266                 context->untracked_materials[context->num_untracked_materials] = GL_SPECULAR;
1267                 context->num_untracked_materials++;
1268             }
1269         } else if (stateblock->renderState[WINED3DRS_EMISSIVEMATERIALSOURCE] == WINED3DMCS_COLOR1) {
1270             Parm = GL_EMISSION;
1271             if(stateblock->renderState[WINED3DRS_SPECULARMATERIALSOURCE] == WINED3DMCS_COLOR1) {
1272                 context->untracked_materials[context->num_untracked_materials] = GL_SPECULAR;
1273                 context->num_untracked_materials++;
1274             }
1275         } else if (stateblock->renderState[WINED3DRS_SPECULARMATERIALSOURCE] == WINED3DMCS_COLOR1) {
1276             Parm = GL_SPECULAR;
1277         }
1278     }
1279
1280     /* Nothing changed, return. */
1281     if (Parm == context->tracking_parm) return;
1282
1283     if(!Parm) {
1284         glDisable(GL_COLOR_MATERIAL);
1285         checkGLcall("glDisable GL_COLOR_MATERIAL");
1286     } else {
1287         glColorMaterial(GL_FRONT_AND_BACK, Parm);
1288         checkGLcall("glColorMaterial(GL_FRONT_AND_BACK, Parm)");
1289         glEnable(GL_COLOR_MATERIAL);
1290         checkGLcall("glEnable(GL_COLOR_MATERIAL)");
1291     }
1292
1293     /* Apparently calls to glMaterialfv are ignored for properties we're
1294      * tracking with glColorMaterial, so apply those here. */
1295     switch (context->tracking_parm) {
1296         case GL_AMBIENT_AND_DIFFUSE:
1297             glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT, (float*)&device->updateStateBlock->material.Ambient);
1298             glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, (float*)&device->updateStateBlock->material.Diffuse);
1299             checkGLcall("glMaterialfv");
1300             break;
1301
1302         case GL_DIFFUSE:
1303             glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, (float*)&device->updateStateBlock->material.Diffuse);
1304             checkGLcall("glMaterialfv");
1305             break;
1306
1307         case GL_AMBIENT:
1308             glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT, (float*)&device->updateStateBlock->material.Ambient);
1309             checkGLcall("glMaterialfv");
1310             break;
1311
1312         case GL_EMISSION:
1313             glMaterialfv(GL_FRONT_AND_BACK, GL_EMISSION, (float*)&device->updateStateBlock->material.Emissive);
1314             checkGLcall("glMaterialfv");
1315             break;
1316
1317         case GL_SPECULAR:
1318             /* Only change material color if specular is enabled, otherwise it is set to black */
1319             if (device->stateBlock->renderState[WINED3DRS_SPECULARENABLE]) {
1320                 glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, (float*)&device->updateStateBlock->material.Specular);
1321                 checkGLcall("glMaterialfv");
1322             } else {
1323                 float black[4] = {0.0f, 0.0f, 0.0f, 0.0f};
1324                 glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, &black[0]);
1325                 checkGLcall("glMaterialfv");
1326             }
1327             break;
1328     }
1329
1330     context->tracking_parm = Parm;
1331 }
1332
1333 static void state_linepattern(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
1334     union {
1335         DWORD                 d;
1336         WINED3DLINEPATTERN    lp;
1337     } tmppattern;
1338     tmppattern.d = stateblock->renderState[WINED3DRS_LINEPATTERN];
1339
1340     TRACE("Line pattern: repeat %d bits %x\n", tmppattern.lp.wRepeatFactor, tmppattern.lp.wLinePattern);
1341
1342     if (tmppattern.lp.wRepeatFactor) {
1343         glLineStipple(tmppattern.lp.wRepeatFactor, tmppattern.lp.wLinePattern);
1344         checkGLcall("glLineStipple(repeat, linepattern)");
1345         glEnable(GL_LINE_STIPPLE);
1346         checkGLcall("glEnable(GL_LINE_STIPPLE);");
1347     } else {
1348         glDisable(GL_LINE_STIPPLE);
1349         checkGLcall("glDisable(GL_LINE_STIPPLE);");
1350     }
1351 }
1352
1353 static void state_zbias(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
1354     union {
1355         DWORD d;
1356         float f;
1357     } tmpvalue;
1358
1359     if (stateblock->renderState[WINED3DRS_ZBIAS]) {
1360         tmpvalue.d = stateblock->renderState[WINED3DRS_ZBIAS];
1361         TRACE("ZBias value %f\n", tmpvalue.f);
1362         glPolygonOffset(0, -tmpvalue.f);
1363         checkGLcall("glPolygonOffset(0, -Value)");
1364         glEnable(GL_POLYGON_OFFSET_FILL);
1365         checkGLcall("glEnable(GL_POLYGON_OFFSET_FILL);");
1366         glEnable(GL_POLYGON_OFFSET_LINE);
1367         checkGLcall("glEnable(GL_POLYGON_OFFSET_LINE);");
1368         glEnable(GL_POLYGON_OFFSET_POINT);
1369         checkGLcall("glEnable(GL_POLYGON_OFFSET_POINT);");
1370     } else {
1371         glDisable(GL_POLYGON_OFFSET_FILL);
1372         checkGLcall("glDisable(GL_POLYGON_OFFSET_FILL);");
1373         glDisable(GL_POLYGON_OFFSET_LINE);
1374         checkGLcall("glDisable(GL_POLYGON_OFFSET_LINE);");
1375         glDisable(GL_POLYGON_OFFSET_POINT);
1376         checkGLcall("glDisable(GL_POLYGON_OFFSET_POINT);");
1377     }
1378 }
1379
1380
1381 static void state_normalize(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
1382     if(isStateDirty(context, STATE_VDECL)) {
1383         return;
1384     }
1385     /* Without vertex normals, we set the current normal to 0/0/0 to remove the diffuse factor
1386      * from the opengl lighting equation, as d3d does. Normalization of 0/0/0 can lead to a division
1387      * by zero and is not properly defined in opengl, so avoid it
1388      */
1389     if (stateblock->renderState[WINED3DRS_NORMALIZENORMALS] && (
1390         stateblock->wineD3DDevice->strided_streams.u.s.normal.lpData ||
1391         stateblock->wineD3DDevice->strided_streams.u.s.normal.VBO)) {
1392         glEnable(GL_NORMALIZE);
1393         checkGLcall("glEnable(GL_NORMALIZE);");
1394     } else {
1395         glDisable(GL_NORMALIZE);
1396         checkGLcall("glDisable(GL_NORMALIZE);");
1397     }
1398 }
1399
1400 static void state_psizemin(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
1401     union {
1402         DWORD d;
1403         float f;
1404     } tmpvalue;
1405
1406     tmpvalue.d = stateblock->renderState[WINED3DRS_POINTSIZE_MIN];
1407     if(GL_SUPPORT(ARB_POINT_PARAMETERS)) {
1408         GL_EXTCALL(glPointParameterfARB)(GL_POINT_SIZE_MIN_ARB, tmpvalue.f);
1409         checkGLcall("glPointParameterfARB(...)");
1410     }
1411     else if(GL_SUPPORT(EXT_POINT_PARAMETERS)) {
1412         GL_EXTCALL(glPointParameterfEXT)(GL_POINT_SIZE_MIN_EXT, tmpvalue.f);
1413         checkGLcall("glPointParameterfEXT(...)");
1414     } else if(tmpvalue.f != 1.0) {
1415         FIXME("WINED3DRS_POINTSIZE_MIN not supported on this opengl, value is %f\n", tmpvalue.f);
1416     }
1417 }
1418
1419 static void state_psizemax(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
1420     union {
1421         DWORD d;
1422         float f;
1423     } tmpvalue;
1424
1425     tmpvalue.d = stateblock->renderState[WINED3DRS_POINTSIZE_MAX];
1426     if(GL_SUPPORT(ARB_POINT_PARAMETERS)) {
1427         GL_EXTCALL(glPointParameterfARB)(GL_POINT_SIZE_MAX_ARB, tmpvalue.f);
1428         checkGLcall("glPointParameterfARB(...)");
1429     }
1430     else if(GL_SUPPORT(EXT_POINT_PARAMETERS)) {
1431         GL_EXTCALL(glPointParameterfEXT)(GL_POINT_SIZE_MAX_EXT, tmpvalue.f);
1432         checkGLcall("glPointParameterfEXT(...)");
1433     } else if(tmpvalue.f != 64.0) {
1434         FIXME("WINED3DRS_POINTSIZE_MAX not supported on this opengl, value is %f\n", tmpvalue.f);
1435     }
1436 }
1437
1438 static void state_pscale(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
1439     /* TODO: Group this with the viewport */
1440     /*
1441      * POINTSCALEENABLE controls how point size value is treated. If set to
1442      * true, the point size is scaled with respect to height of viewport.
1443      * When set to false point size is in pixels.
1444      */
1445
1446     /* Default values */
1447     GLfloat att[3] = {1.0f, 0.0f, 0.0f};
1448     union {
1449         DWORD d;
1450         float f;
1451     } pointSize, A, B, C;
1452
1453     pointSize.d = stateblock->renderState[WINED3DRS_POINTSIZE];
1454     A.d = stateblock->renderState[WINED3DRS_POINTSCALE_A];
1455     B.d = stateblock->renderState[WINED3DRS_POINTSCALE_B];
1456     C.d = stateblock->renderState[WINED3DRS_POINTSCALE_C];
1457
1458     if(stateblock->renderState[WINED3DRS_POINTSCALEENABLE]) {
1459         GLfloat scaleFactor;
1460         float h = stateblock->viewport.Height;
1461
1462         if(pointSize.f < GL_LIMITS(pointsizemin)) {
1463             /*
1464              * Minimum valid point size for OpenGL is driver specific. For Direct3D it is
1465              * 0.0f. This means that OpenGL will clamp really small point sizes to the
1466              * driver minimum. To correct for this we need to multiply by the scale factor when sizes
1467              * are less than 1.0f. scale_factor =  1.0f / point_size.
1468              */
1469             scaleFactor = pointSize.f / GL_LIMITS(pointsizemin);
1470             /* Clamp the point size, don't rely on the driver to do it. MacOS says min point size
1471              * is 1.0, but then accepts points below that and draws too small points
1472              */
1473             pointSize.f = GL_LIMITS(pointsizemin);
1474         } else if(pointSize.f > GL_LIMITS(pointsize)) {
1475             /* gl already scales the input to glPointSize,
1476              * d3d scales the result after the point size scale.
1477              * If the point size is bigger than the max size, use the
1478              * scaling to scale it bigger, and set the gl point size to max
1479              */
1480             scaleFactor = pointSize.f / GL_LIMITS(pointsize);
1481             TRACE("scale: %f\n", scaleFactor);
1482             pointSize.f = GL_LIMITS(pointsize);
1483         } else {
1484             scaleFactor = 1.0f;
1485         }
1486         scaleFactor = pow(h * scaleFactor, 2);
1487
1488         att[0] = A.f / scaleFactor;
1489         att[1] = B.f / scaleFactor;
1490         att[2] = C.f / scaleFactor;
1491     }
1492
1493     if(GL_SUPPORT(ARB_POINT_PARAMETERS)) {
1494         GL_EXTCALL(glPointParameterfvARB)(GL_POINT_DISTANCE_ATTENUATION_ARB, att);
1495         checkGLcall("glPointParameterfvARB(GL_DISTANCE_ATTENUATION_ARB, ...)");
1496     }
1497     else if(GL_SUPPORT(EXT_POINT_PARAMETERS)) {
1498         GL_EXTCALL(glPointParameterfvEXT)(GL_DISTANCE_ATTENUATION_EXT, att);
1499         checkGLcall("glPointParameterfvEXT(GL_DISTANCE_ATTENUATION_EXT, ...)");
1500     } else if(stateblock->renderState[WINED3DRS_POINTSCALEENABLE]) {
1501         WARN("POINT_PARAMETERS not supported in this version of opengl\n");
1502     }
1503
1504     glPointSize(pointSize.f);
1505     checkGLcall("glPointSize(...);");
1506 }
1507
1508 static void state_colorwrite(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
1509     DWORD Value = stateblock->renderState[WINED3DRS_COLORWRITEENABLE];
1510
1511     TRACE("Color mask: r(%d) g(%d) b(%d) a(%d)\n",
1512         Value & WINED3DCOLORWRITEENABLE_RED   ? 1 : 0,
1513         Value & WINED3DCOLORWRITEENABLE_GREEN ? 1 : 0,
1514         Value & WINED3DCOLORWRITEENABLE_BLUE  ? 1 : 0,
1515         Value & WINED3DCOLORWRITEENABLE_ALPHA ? 1 : 0);
1516     glColorMask(Value & WINED3DCOLORWRITEENABLE_RED   ? GL_TRUE : GL_FALSE,
1517                 Value & WINED3DCOLORWRITEENABLE_GREEN ? GL_TRUE : GL_FALSE,
1518                 Value & WINED3DCOLORWRITEENABLE_BLUE  ? GL_TRUE : GL_FALSE,
1519                 Value & WINED3DCOLORWRITEENABLE_ALPHA ? GL_TRUE : GL_FALSE);
1520     checkGLcall("glColorMask(...)");
1521
1522     /* depends on WINED3DRS_COLORWRITEENABLE. */
1523     if(stateblock->renderState[WINED3DRS_COLORWRITEENABLE1] != 0x0000000F ||
1524        stateblock->renderState[WINED3DRS_COLORWRITEENABLE2] != 0x0000000F ||
1525        stateblock->renderState[WINED3DRS_COLORWRITEENABLE3] != 0x0000000F ) {
1526         ERR("(WINED3DRS_COLORWRITEENABLE1/2/3,%d,%d,%d) not yet implemented. Missing of cap D3DPMISCCAPS_INDEPENDENTWRITEMASKS wasn't honored?\n",
1527             stateblock->renderState[WINED3DRS_COLORWRITEENABLE1],
1528             stateblock->renderState[WINED3DRS_COLORWRITEENABLE2],
1529             stateblock->renderState[WINED3DRS_COLORWRITEENABLE3]);
1530     }
1531 }
1532
1533 static void state_localviewer(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
1534     if(stateblock->renderState[WINED3DRS_LOCALVIEWER]) {
1535         glLightModeli(GL_LIGHT_MODEL_LOCAL_VIEWER, 1);
1536         checkGLcall("glLightModeli(GL_LIGHT_MODEL_LOCAL_VIEWER, 1)");
1537     } else {
1538         glLightModeli(GL_LIGHT_MODEL_LOCAL_VIEWER, 0);
1539         checkGLcall("glLightModeli(GL_LIGHT_MODEL_LOCAL_VIEWER, 0)");
1540     }
1541 }
1542
1543 static void state_lastpixel(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
1544     if(stateblock->renderState[WINED3DRS_LASTPIXEL]) {
1545         TRACE("Last Pixel Drawing Enabled\n");
1546     } else {
1547         static BOOL first = TRUE;
1548         if(first) {
1549             FIXME("Last Pixel Drawing Disabled, not handled yet\n");
1550             first = FALSE;
1551         } else {
1552             TRACE("Last Pixel Drawing Disabled, not handled yet\n");
1553         }
1554     }
1555 }
1556
1557 static void state_pointsprite(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
1558     /* TODO: NV_POINT_SPRITE */
1559     if (!GL_SUPPORT(ARB_POINT_SPRITE)) {
1560         TRACE("Point sprites not supported\n");
1561         return;
1562     }
1563
1564     if (stateblock->renderState[WINED3DRS_POINTSPRITEENABLE]) {
1565         glEnable(GL_POINT_SPRITE_ARB);
1566         checkGLcall("glEnable(GL_POINT_SPRITE_ARB)");
1567     } else {
1568         glDisable(GL_POINT_SPRITE_ARB);
1569         checkGLcall("glDisable(GL_POINT_SPRITE_ARB)");
1570     }
1571 }
1572
1573 static void state_wrap(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
1574     /**
1575      http://www.cosc.brocku.ca/Offerings/3P98/course/lectures/texture/
1576      http://www.gamedev.net/reference/programming/features/rendererdll3/page2.asp
1577      Discussion on the ways to turn on WRAPing to solve an OpenGL conversion problem.
1578      http://www.flipcode.org/cgi-bin/fcmsg.cgi?thread_show=10248
1579
1580      so far as I can tell, wrapping and texture-coordinate generate go hand in hand,
1581      */
1582     TRACE("Stub\n");
1583     if(stateblock->renderState[WINED3DRS_WRAP0] ||
1584        stateblock->renderState[WINED3DRS_WRAP1] ||
1585        stateblock->renderState[WINED3DRS_WRAP2] ||
1586        stateblock->renderState[WINED3DRS_WRAP3] ||
1587        stateblock->renderState[WINED3DRS_WRAP4] ||
1588        stateblock->renderState[WINED3DRS_WRAP5] ||
1589        stateblock->renderState[WINED3DRS_WRAP6] ||
1590        stateblock->renderState[WINED3DRS_WRAP7] ||
1591        stateblock->renderState[WINED3DRS_WRAP8] ||
1592        stateblock->renderState[WINED3DRS_WRAP9] ||
1593        stateblock->renderState[WINED3DRS_WRAP10] ||
1594        stateblock->renderState[WINED3DRS_WRAP11] ||
1595        stateblock->renderState[WINED3DRS_WRAP12] ||
1596        stateblock->renderState[WINED3DRS_WRAP13] ||
1597        stateblock->renderState[WINED3DRS_WRAP14] ||
1598        stateblock->renderState[WINED3DRS_WRAP15] ) {
1599         FIXME("(WINED3DRS_WRAP0) Texture wraping not yet supported\n");
1600     }
1601 }
1602
1603 static void state_multisampleaa(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
1604     if( GL_SUPPORT(ARB_MULTISAMPLE) ) {
1605         if(stateblock->renderState[WINED3DRS_MULTISAMPLEANTIALIAS]) {
1606             glEnable(GL_MULTISAMPLE_ARB);
1607             checkGLcall("glEnable(GL_MULTISAMPLE_ARB)");
1608         } else {
1609             glDisable(GL_MULTISAMPLE_ARB);
1610             checkGLcall("glDisable(GL_MULTISAMPLE_ARB)");
1611         }
1612     } else {
1613         if(stateblock->renderState[WINED3DRS_MULTISAMPLEANTIALIAS]) {
1614             WARN("Multisample antialiasing not supported by gl\n");
1615         }
1616     }
1617 }
1618
1619 static void state_scissor(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
1620     if(stateblock->renderState[WINED3DRS_SCISSORTESTENABLE]) {
1621         glEnable(GL_SCISSOR_TEST);
1622         checkGLcall("glEnable(GL_SCISSOR_TEST)");
1623     } else {
1624         glDisable(GL_SCISSOR_TEST);
1625         checkGLcall("glDisable(GL_SCISSOR_TEST)");
1626     }
1627 }
1628
1629 static void state_depthbias(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
1630     union {
1631         DWORD d;
1632         float f;
1633     } tmpvalue;
1634
1635     if(stateblock->renderState[WINED3DRS_SLOPESCALEDEPTHBIAS] ||
1636        stateblock->renderState[WINED3DRS_DEPTHBIAS]) {
1637         tmpvalue.d = stateblock->renderState[WINED3DRS_SLOPESCALEDEPTHBIAS];
1638         glEnable(GL_POLYGON_OFFSET_FILL);
1639         checkGLcall("glEnable(GL_POLYGON_OFFSET_FILL)");
1640         glPolygonOffset(tmpvalue.f, *((float*)&stateblock->renderState[WINED3DRS_DEPTHBIAS]));
1641         checkGLcall("glPolygonOffset(...)");
1642     } else {
1643         glDisable(GL_POLYGON_OFFSET_FILL);
1644         checkGLcall("glDisable(GL_POLYGON_OFFSET_FILL)");
1645     }
1646 }
1647
1648 static void state_perspective(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
1649     if (stateblock->renderState[WINED3DRS_TEXTUREPERSPECTIVE]) {
1650         glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);
1651         checkGLcall("glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST)");
1652     } else {
1653         glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_FASTEST);
1654         checkGLcall("glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_FASTEST)");
1655     }
1656 }
1657
1658 static void state_stippledalpha(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
1659     TRACE("Stub\n");
1660     if (stateblock->renderState[WINED3DRS_STIPPLEDALPHA])
1661         FIXME(" Stippled Alpha not supported yet.\n");
1662 }
1663
1664 static void state_antialias(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
1665     TRACE("Stub\n");
1666     if (stateblock->renderState[WINED3DRS_ANTIALIAS])
1667         FIXME(" Antialias not supported yet.\n");
1668 }
1669
1670 static void state_multisampmask(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
1671     TRACE("Stub\n");
1672     if (stateblock->renderState[WINED3DRS_MULTISAMPLEMASK] != 0xFFFFFFFF)
1673         FIXME("(WINED3DRS_MULTISAMPLEMASK,%d) not yet implemented\n", stateblock->renderState[WINED3DRS_MULTISAMPLEMASK]);
1674 }
1675
1676 static void state_patchedgestyle(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
1677     TRACE("Stub\n");
1678     if (stateblock->renderState[WINED3DRS_PATCHEDGESTYLE] != WINED3DPATCHEDGE_DISCRETE)
1679         FIXME("(WINED3DRS_PATCHEDGESTYLE,%d) not yet implemented\n", stateblock->renderState[WINED3DRS_PATCHEDGESTYLE]);
1680 }
1681
1682 static void state_patchsegments(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
1683     union {
1684         DWORD d;
1685         float f;
1686     } tmpvalue;
1687     tmpvalue.f = 1.0f;
1688
1689     TRACE("Stub\n");
1690     if (stateblock->renderState[WINED3DRS_PATCHSEGMENTS] != tmpvalue.d)
1691     {
1692         static BOOL displayed = FALSE;
1693
1694         tmpvalue.d = stateblock->renderState[WINED3DRS_PATCHSEGMENTS];
1695         if(!displayed)
1696             FIXME("(WINED3DRS_PATCHSEGMENTS,%f) not yet implemented\n", tmpvalue.f);
1697
1698         displayed = TRUE;
1699     }
1700 }
1701
1702 static void state_positiondegree(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
1703     TRACE("Stub\n");
1704     if (stateblock->renderState[WINED3DRS_POSITIONDEGREE] != WINED3DDEGREE_CUBIC)
1705         FIXME("(WINED3DRS_POSITIONDEGREE,%d) not yet implemented\n", stateblock->renderState[WINED3DRS_POSITIONDEGREE]);
1706 }
1707
1708 static void state_normaldegree(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
1709     TRACE("Stub\n");
1710     if (stateblock->renderState[WINED3DRS_NORMALDEGREE] != WINED3DDEGREE_LINEAR)
1711         FIXME("(WINED3DRS_NORMALDEGREE,%d) not yet implemented\n", stateblock->renderState[WINED3DRS_NORMALDEGREE]);
1712 }
1713
1714 static void state_tessellation(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
1715     TRACE("Stub\n");
1716     if(stateblock->renderState[WINED3DRS_ENABLEADAPTIVETESSELLATION])
1717         FIXME("(WINED3DRS_ENABLEADAPTIVETESSELLATION,%d) not yet implemented\n", stateblock->renderState[WINED3DRS_ENABLEADAPTIVETESSELLATION]);
1718 }
1719
1720 static void state_wrapu(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
1721     if(stateblock->renderState[WINED3DRS_WRAPU]) {
1722         FIXME("Render state WINED3DRS_WRAPU not implemented yet\n");
1723     }
1724 }
1725
1726 static void state_wrapv(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
1727     if(stateblock->renderState[WINED3DRS_WRAPV]) {
1728         FIXME("Render state WINED3DRS_WRAPV not implemented yet\n");
1729     }
1730 }
1731
1732 static void state_monoenable(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
1733     if(stateblock->renderState[WINED3DRS_MONOENABLE]) {
1734         FIXME("Render state WINED3DRS_MONOENABLE not implemented yet\n");
1735     }
1736 }
1737
1738 static void state_rop2(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
1739     if(stateblock->renderState[WINED3DRS_ROP2]) {
1740         FIXME("Render state WINED3DRS_ROP2 not implemented yet\n");
1741     }
1742 }
1743
1744 static void state_planemask(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
1745     if(stateblock->renderState[WINED3DRS_PLANEMASK]) {
1746         FIXME("Render state WINED3DRS_PLANEMASK not implemented yet\n");
1747     }
1748 }
1749
1750 static void state_subpixel(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
1751     if(stateblock->renderState[WINED3DRS_SUBPIXEL]) {
1752         FIXME("Render state WINED3DRS_SUBPIXEL not implemented yet\n");
1753     }
1754 }
1755
1756 static void state_subpixelx(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
1757     if(stateblock->renderState[WINED3DRS_SUBPIXELX]) {
1758         FIXME("Render state WINED3DRS_SUBPIXELX not implemented yet\n");
1759     }
1760 }
1761
1762 static void state_stippleenable(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
1763     if(stateblock->renderState[WINED3DRS_STIPPLEENABLE]) {
1764         FIXME("Render state WINED3DRS_STIPPLEENABLE not implemented yet\n");
1765     }
1766 }
1767
1768 static void state_bordercolor(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
1769     if(stateblock->renderState[WINED3DRS_BORDERCOLOR]) {
1770         FIXME("Render state WINED3DRS_BORDERCOLOR not implemented yet\n");
1771     }
1772 }
1773
1774 static void state_mipmaplodbias(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
1775     if(stateblock->renderState[WINED3DRS_MIPMAPLODBIAS]) {
1776         FIXME("Render state WINED3DRS_MIPMAPLODBIAS not implemented yet\n");
1777     }
1778 }
1779
1780 static void state_anisotropy(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
1781     if(stateblock->renderState[WINED3DRS_ANISOTROPY]) {
1782         FIXME("Render state WINED3DRS_ANISOTROPY not implemented yet\n");
1783     }
1784 }
1785
1786 static void state_flushbatch(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
1787     if(stateblock->renderState[WINED3DRS_FLUSHBATCH]) {
1788         FIXME("Render state WINED3DRS_FLUSHBATCH not implemented yet\n");
1789     }
1790 }
1791
1792 static void state_translucentsi(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
1793     if(stateblock->renderState[WINED3DRS_TRANSLUCENTSORTINDEPENDENT]) {
1794         FIXME("Render state WINED3DRS_TRANSLUCENTSORTINDEPENDENT not implemented yet\n");
1795     }
1796 }
1797
1798 static void state_extents(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
1799     if(stateblock->renderState[WINED3DRS_EXTENTS]) {
1800         FIXME("Render state WINED3DRS_EXTENTS not implemented yet\n");
1801     }
1802 }
1803
1804 static void state_ckeyblend(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
1805     if(stateblock->renderState[WINED3DRS_COLORKEYBLENDENABLE]) {
1806         FIXME("Render state WINED3DRS_COLORKEYBLENDENABLE not implemented yet\n");
1807     }
1808 }
1809
1810 static void tex_colorop(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
1811     DWORD stage = (state - STATE_TEXTURESTAGE(0, 0)) / WINED3D_HIGHEST_TEXTURE_STATE;
1812     DWORD mapped_stage = stateblock->wineD3DDevice->texUnitMap[stage];
1813     BOOL tex_used = stateblock->wineD3DDevice->fixed_function_usage_map[stage];
1814
1815     TRACE("Setting color op for stage %d\n", stage);
1816
1817     if (stateblock->pixelShader && stateblock->wineD3DDevice->ps_selected_mode != SHADER_NONE &&
1818         ((IWineD3DPixelShaderImpl *)stateblock->pixelShader)->baseShader.function) {
1819         /* Using a pixel shader? Don't care for anything here, the shader applying does it */
1820         return;
1821     }
1822
1823     if (stage != mapped_stage) WARN("Using non 1:1 mapping: %d -> %d!\n", stage, mapped_stage);
1824
1825     if (mapped_stage != -1) {
1826         if (GL_SUPPORT(ARB_MULTITEXTURE)) {
1827             if (tex_used && mapped_stage >= GL_LIMITS(textures)) {
1828                 FIXME("Attempt to enable unsupported stage!\n");
1829                 return;
1830             }
1831             GL_EXTCALL(glActiveTextureARB(GL_TEXTURE0_ARB + mapped_stage));
1832             checkGLcall("glActiveTextureARB");
1833         } else if (stage > 0) {
1834             WARN("Program using multiple concurrent textures which this opengl implementation doesn't support\n");
1835             return;
1836         }
1837     }
1838
1839     if (GL_SUPPORT(NV_REGISTER_COMBINERS)) {
1840         if(stateblock->lowest_disabled_stage > 0) {
1841             glEnable(GL_REGISTER_COMBINERS_NV);
1842             GL_EXTCALL(glCombinerParameteriNV(GL_NUM_GENERAL_COMBINERS_NV, stateblock->lowest_disabled_stage));
1843         } else {
1844             glDisable(GL_REGISTER_COMBINERS_NV);
1845         }
1846     }
1847     if(stage >= stateblock->lowest_disabled_stage) {
1848         TRACE("Stage disabled\n");
1849         if (mapped_stage != -1) {
1850             /* Disable everything here */
1851             glDisable(GL_TEXTURE_2D);
1852             checkGLcall("glDisable(GL_TEXTURE_2D)");
1853             glDisable(GL_TEXTURE_3D);
1854             checkGLcall("glDisable(GL_TEXTURE_3D)");
1855             if(GL_SUPPORT(ARB_TEXTURE_CUBE_MAP)) {
1856                 glDisable(GL_TEXTURE_CUBE_MAP_ARB);
1857                 checkGLcall("glDisable(GL_TEXTURE_CUBE_MAP_ARB)");
1858             }
1859             if(GL_SUPPORT(ARB_TEXTURE_RECTANGLE)) {
1860                 glDisable(GL_TEXTURE_RECTANGLE_ARB);
1861                 checkGLcall("glDisable(GL_TEXTURE_RECTANGLE_ARB)");
1862             }
1863             if(GL_SUPPORT(NV_TEXTURE_SHADER2) && mapped_stage < GL_LIMITS(textures)) {
1864                 glTexEnvi(GL_TEXTURE_SHADER_NV, GL_SHADER_OPERATION_NV, GL_NONE);
1865             }
1866         }
1867         /* All done */
1868         return;
1869     }
1870
1871     /* The sampler will also activate the correct texture dimensions, so no need to do it here
1872      * if the sampler for this stage is dirty
1873      */
1874     if(!isStateDirty(context, STATE_SAMPLER(stage))) {
1875         if (tex_used) texture_activate_dimensions(stage, stateblock, context);
1876     }
1877
1878     /* Set the texture combiners */
1879     if (GL_SUPPORT(NV_REGISTER_COMBINERS)) {
1880         set_tex_op_nvrc((IWineD3DDevice *)stateblock->wineD3DDevice, FALSE, stage,
1881                          stateblock->textureState[stage][WINED3DTSS_COLOROP],
1882                          stateblock->textureState[stage][WINED3DTSS_COLORARG1],
1883                          stateblock->textureState[stage][WINED3DTSS_COLORARG2],
1884                          stateblock->textureState[stage][WINED3DTSS_COLORARG0],
1885                          mapped_stage,
1886                          stateblock->textureState[stage][WINED3DTSS_RESULTARG]);
1887
1888         /* In register combiners bump mapping is done in the stage AFTER the one that has the bump map operation set,
1889          * thus the texture shader may have to be updated
1890          */
1891         if(GL_SUPPORT(NV_TEXTURE_SHADER2)) {
1892             BOOL usesBump = (stateblock->textureState[stage][WINED3DTSS_COLOROP] == WINED3DTOP_BUMPENVMAPLUMINANCE ||
1893                              stateblock->textureState[stage][WINED3DTSS_COLOROP] == WINED3DTOP_BUMPENVMAP) ? TRUE : FALSE;
1894             BOOL usedBump = (context->texShaderBumpMap & 1 << (stage + 1)) ? TRUE : FALSE;
1895             if(usesBump != usedBump) {
1896                 GL_EXTCALL(glActiveTextureARB(GL_TEXTURE0_ARB + mapped_stage + 1));
1897                 checkGLcall("glActiveTextureARB");
1898                 texture_activate_dimensions(stage + 1, stateblock, context);
1899                 GL_EXTCALL(glActiveTextureARB(GL_TEXTURE0_ARB + mapped_stage));
1900                 checkGLcall("glActiveTextureARB");
1901             }
1902         }
1903     } else {
1904         set_tex_op((IWineD3DDevice *)stateblock->wineD3DDevice, FALSE, stage,
1905                     stateblock->textureState[stage][WINED3DTSS_COLOROP],
1906                     stateblock->textureState[stage][WINED3DTSS_COLORARG1],
1907                     stateblock->textureState[stage][WINED3DTSS_COLORARG2],
1908                     stateblock->textureState[stage][WINED3DTSS_COLORARG0]);
1909     }
1910 }
1911
1912 static void tex_alphaop(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
1913     DWORD stage = (state - STATE_TEXTURESTAGE(0, 0)) / WINED3D_HIGHEST_TEXTURE_STATE;
1914     DWORD mapped_stage = stateblock->wineD3DDevice->texUnitMap[stage];
1915     BOOL tex_used = stateblock->wineD3DDevice->fixed_function_usage_map[stage];
1916     DWORD op, arg1, arg2, arg0;
1917
1918     TRACE("Setting alpha op for stage %d\n", stage);
1919     /* Do not care for enabled / disabled stages, just assign the settings. colorop disables / enables required stuff */
1920     if (mapped_stage != -1) {
1921         if (GL_SUPPORT(ARB_MULTITEXTURE)) {
1922             if (tex_used && mapped_stage >= GL_LIMITS(textures)) {
1923                 FIXME("Attempt to enable unsupported stage!\n");
1924                 return;
1925             }
1926             GL_EXTCALL(glActiveTextureARB(GL_TEXTURE0_ARB + mapped_stage));
1927             checkGLcall("glActiveTextureARB");
1928         } else if (stage > 0) {
1929             /* We can't do anything here */
1930             WARN("Program using multiple concurrent textures which this opengl implementation doesn't support\n");
1931             return;
1932         }
1933     }
1934
1935     op = stateblock->textureState[stage][WINED3DTSS_ALPHAOP];
1936     arg1 = stateblock->textureState[stage][WINED3DTSS_ALPHAARG1];
1937     arg2 = stateblock->textureState[stage][WINED3DTSS_ALPHAARG2];
1938     arg0 = stateblock->textureState[stage][WINED3DTSS_ALPHAARG0];
1939
1940     if(stateblock->renderState[WINED3DRS_COLORKEYENABLE] && stage == 0 &&
1941        stateblock->textures[0] &&
1942        (stateblock->textureDimensions[0] == GL_TEXTURE_2D || stateblock->textureDimensions[0] == GL_TEXTURE_RECTANGLE_ARB)) {
1943         IWineD3DSurfaceImpl *surf = (IWineD3DSurfaceImpl *) ((IWineD3DTextureImpl *) stateblock->textures[0])->surfaces[0];
1944
1945         if(surf->CKeyFlags & WINEDDSD_CKSRCBLT &&
1946            getFormatDescEntry(surf->resource.format, NULL, NULL)->alphaMask == 0x00000000) {
1947
1948             /* Color keying needs to pass alpha values from the texture through to have the alpha test work properly.
1949              * On the other hand applications can still use texture combiners apparently. This code takes care that apps
1950              * cannot remove the texture's alpha channel entirely.
1951              *
1952              * The fixup is required for Prince of Persia 3D(prison bars), while Moto racer 2 requires D3DTOP_MODULATE to work
1953              * on color keyed surfaces. Aliens vs Predator 1 uses color keyed textures and alpha component of diffuse color to
1954              * draw things like translucent text and perform other blending effects.
1955              *
1956              * Aliens vs Predator 1 relies on diffuse alpha having an effect, so it cannot be ignored. To provide the
1957              * behavior expected by the game, while emulating the colorkey, diffuse alpha must be modulated with texture alpha.
1958              * OTOH, Moto racer 2 at some points sets alphaop/alphaarg to SELECTARG/CURRENT, yet puts garbage in diffuse alpha
1959              * (zeroes). This works on native, because the game disables alpha test and alpha blending. Alpha test is overwritten by
1960              * wine's for purposes of color-keying though, so this will lead to missing geometry if texture alpha is modulated
1961              * (pixels fail alpha test). To get around this, ALPHABLENDENABLE state is checked: if the app enables alpha blending,
1962              * it can be expected to provide meaningful values in diffuse alpha, so it should be modulated with texture alpha;
1963              * otherwise, selecting diffuse alpha is ignored in favour of texture alpha.
1964
1965              * What to do with multitexturing? So far no app has been found that uses color keying with multitexturing
1966              */
1967             if(op == WINED3DTOP_DISABLE) {
1968                 arg1 = WINED3DTA_TEXTURE;
1969                 op = WINED3DTOP_SELECTARG1;
1970             }
1971             else if(op == WINED3DTOP_SELECTARG1 && arg1 != WINED3DTA_TEXTURE) {
1972                 if (stateblock->renderState[WINED3DRS_ALPHABLENDENABLE]) {
1973                     arg2 = WINED3DTA_TEXTURE;
1974                     op = WINED3DTOP_MODULATE;
1975                 }
1976                 else arg1 = WINED3DTA_TEXTURE;
1977             }
1978             else if(op == WINED3DTOP_SELECTARG2 && arg2 != WINED3DTA_TEXTURE) {
1979                 if (stateblock->renderState[WINED3DRS_ALPHABLENDENABLE]) {
1980                     arg1 = WINED3DTA_TEXTURE;
1981                     op = WINED3DTOP_MODULATE;
1982                 }
1983                 else arg2 = WINED3DTA_TEXTURE;
1984             }
1985         }
1986     }
1987
1988     TRACE("Setting alpha op for stage %d\n", stage);
1989     if (GL_SUPPORT(NV_REGISTER_COMBINERS)) {
1990         set_tex_op_nvrc((IWineD3DDevice *)stateblock->wineD3DDevice, TRUE, stage,
1991                          op, arg1, arg2, arg0,
1992                          mapped_stage,
1993                          stateblock->textureState[stage][WINED3DTSS_RESULTARG]);
1994     } else {
1995         set_tex_op((IWineD3DDevice *)stateblock->wineD3DDevice, TRUE, stage,
1996                     op, arg1, arg2, arg0);
1997     }
1998 }
1999
2000 static void transform_texture(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
2001     DWORD texUnit = state - STATE_TRANSFORM(WINED3DTS_TEXTURE0);
2002     DWORD mapped_stage = stateblock->wineD3DDevice->texUnitMap[texUnit];
2003     BOOL generated;
2004
2005     /* Ignore this when a vertex shader is used, or if the streams aren't sorted out yet */
2006     if(use_vs(stateblock->wineD3DDevice) ||
2007        isStateDirty(context, STATE_VDECL)) {
2008         TRACE("Using a vertex shader, or stream sources not sorted out yet, skipping\n");
2009         return;
2010     }
2011
2012     if (mapped_stage == -1) return;
2013
2014     if (GL_SUPPORT(ARB_MULTITEXTURE)) {
2015         if(mapped_stage >= GL_LIMITS(textures)) {
2016             return;
2017         }
2018         GL_EXTCALL(glActiveTextureARB(GL_TEXTURE0_ARB + mapped_stage));
2019         checkGLcall("glActiveTextureARB");
2020     } else if (mapped_stage > 0) {
2021         /* We can't do anything here */
2022         WARN("Program using multiple concurrent textures which this opengl implementation doesn't support\n");
2023         return;
2024     }
2025     generated = (stateblock->textureState[texUnit][WINED3DTSS_TEXCOORDINDEX] & 0xFFFF0000) != WINED3DTSS_TCI_PASSTHRU;
2026
2027     set_texture_matrix(&stateblock->transforms[WINED3DTS_TEXTURE0 + texUnit].u.m[0][0],
2028                         stateblock->textureState[texUnit][WINED3DTSS_TEXTURETRANSFORMFLAGS],
2029                         generated,
2030                         context->last_was_rhw,
2031                         stateblock->wineD3DDevice->strided_streams.u.s.texCoords[texUnit].dwStride ?
2032                             stateblock->wineD3DDevice->strided_streams.u.s.texCoords[texUnit].dwType:
2033                             WINED3DDECLTYPE_UNUSED);
2034
2035     /* The sampler applying function calls us if this changes */
2036     if(context->lastWasPow2Texture[texUnit] && stateblock->textures[texUnit]) {
2037         if(generated) {
2038             FIXME("Non-power2 texture being used with generated texture coords\n");
2039         }
2040         TRACE("Non power two matrix multiply fixup\n");
2041         glMultMatrixf(((IWineD3DTextureImpl *) stateblock->textures[texUnit])->baseTexture.pow2Matrix);
2042     }
2043 }
2044
2045 static void unloadTexCoords(IWineD3DStateBlockImpl *stateblock) {
2046     int texture_idx;
2047
2048     for (texture_idx = 0; texture_idx < GL_LIMITS(texture_stages); ++texture_idx) {
2049         GL_EXTCALL(glClientActiveTextureARB(GL_TEXTURE0_ARB + texture_idx));
2050         glDisableClientState(GL_TEXTURE_COORD_ARRAY);
2051     }
2052 }
2053
2054 static void loadTexCoords(IWineD3DStateBlockImpl *stateblock, WineDirect3DVertexStridedData *sd, GLint *curVBO) {
2055     UINT *offset = stateblock->streamOffset;
2056     unsigned int mapped_stage = 0;
2057     unsigned int textureNo = 0;
2058
2059     /* The code below uses glClientActiveTexture and glMultiTexCoord* which are all part of the GL_ARB_multitexture extension. */
2060     /* Abort if we don't support the extension. */
2061     if (!GL_SUPPORT(ARB_MULTITEXTURE)) {
2062         FIXME("Program using multiple concurrent textures which this opengl implementation doesn't support\n");
2063         return;
2064     }
2065
2066     for (textureNo = 0; textureNo < GL_LIMITS(texture_stages); ++textureNo) {
2067         int coordIdx = stateblock->textureState[textureNo][WINED3DTSS_TEXCOORDINDEX];
2068
2069         mapped_stage = stateblock->wineD3DDevice->texUnitMap[textureNo];
2070         if (mapped_stage == -1) continue;
2071
2072         if (coordIdx < MAX_TEXTURES && (sd->u.s.texCoords[coordIdx].lpData || sd->u.s.texCoords[coordIdx].VBO)) {
2073             TRACE("Setting up texture %u, idx %d, cordindx %u, data %p\n",
2074                     textureNo, mapped_stage, coordIdx, sd->u.s.texCoords[coordIdx].lpData);
2075
2076             if (*curVBO != sd->u.s.texCoords[coordIdx].VBO) {
2077                 GL_EXTCALL(glBindBufferARB(GL_ARRAY_BUFFER_ARB, sd->u.s.texCoords[coordIdx].VBO));
2078                 checkGLcall("glBindBufferARB");
2079                 *curVBO = sd->u.s.texCoords[coordIdx].VBO;
2080             }
2081
2082             GL_EXTCALL(glClientActiveTextureARB(GL_TEXTURE0_ARB + mapped_stage));
2083             checkGLcall("glClientActiveTextureARB");
2084
2085             /* The coords to supply depend completely on the fvf / vertex shader */
2086             glTexCoordPointer(
2087                     WINED3D_ATR_SIZE(sd->u.s.texCoords[coordIdx].dwType),
2088                     WINED3D_ATR_GLTYPE(sd->u.s.texCoords[coordIdx].dwType),
2089                     sd->u.s.texCoords[coordIdx].dwStride,
2090                     sd->u.s.texCoords[coordIdx].lpData + stateblock->loadBaseVertexIndex * sd->u.s.texCoords[coordIdx].dwStride + offset[sd->u.s.texCoords[coordIdx].streamNo]);
2091             glEnableClientState(GL_TEXTURE_COORD_ARRAY);
2092         } else {
2093             GL_EXTCALL(glMultiTexCoord4fARB(GL_TEXTURE0_ARB + mapped_stage, 0, 0, 0, 1));
2094         }
2095     }
2096     if (GL_SUPPORT(NV_REGISTER_COMBINERS)) {
2097         /* The number of the mapped stages increases monotonically, so it's fine to use the last used one */
2098         for (textureNo = mapped_stage + 1; textureNo < GL_LIMITS(textures); ++textureNo) {
2099             GL_EXTCALL(glMultiTexCoord4fARB(GL_TEXTURE0_ARB + textureNo, 0, 0, 0, 1));
2100         }
2101     }
2102 }
2103
2104 static void tex_coordindex(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
2105     DWORD stage = (state - STATE_TEXTURESTAGE(0, 0)) / WINED3D_HIGHEST_TEXTURE_STATE;
2106     DWORD mapped_stage = stateblock->wineD3DDevice->texUnitMap[stage];
2107
2108     if (mapped_stage == -1) {
2109         TRACE("No texture unit mapped to stage %d. Skipping texture coordinates.\n", stage);
2110         return;
2111     }
2112
2113     if (GL_SUPPORT(ARB_MULTITEXTURE)) {
2114         if(mapped_stage >= GL_LIMITS(fragment_samplers)) {
2115             return;
2116         }
2117         GL_EXTCALL(glActiveTextureARB(GL_TEXTURE0_ARB + mapped_stage));
2118         checkGLcall("glActiveTextureARB");
2119     } else if (stage > 0) {
2120         /* We can't do anything here */
2121         WARN("Program using multiple concurrent textures which this opengl implementation doesn't support\n");
2122         return;
2123     }
2124
2125     /* Values 0-7 are indexes into the FVF tex coords - See comments in DrawPrimitive
2126      *
2127      * FIXME: From MSDN: The WINED3DTSS_TCI_* flags are mutually exclusive. If you include
2128      * one flag, you can still specify an index value, which the system uses to
2129      * determine the texture wrapping mode.
2130      * eg. SetTextureStageState( 0, WINED3DTSS_TEXCOORDINDEX, WINED3DTSS_TCI_CAMERASPACEPOSITION | 1 );
2131      * means use the vertex position (camera-space) as the input texture coordinates
2132      * for this texture stage, and the wrap mode set in the WINED3DRS_WRAP1 render
2133      * state. We do not (yet) support the WINED3DRENDERSTATE_WRAPx values, nor tie them up
2134      * to the TEXCOORDINDEX value
2135      */
2136
2137     /*
2138      * Be careful the value of the mask 0xF0000 come from d3d8types.h infos
2139      */
2140     switch (stateblock->textureState[stage][WINED3DTSS_TEXCOORDINDEX] & 0xFFFF0000) {
2141     case WINED3DTSS_TCI_PASSTHRU:
2142         /*Use the specified texture coordinates contained within the vertex format. This value resolves to zero.*/
2143         glDisable(GL_TEXTURE_GEN_S);
2144         glDisable(GL_TEXTURE_GEN_T);
2145         glDisable(GL_TEXTURE_GEN_R);
2146         glDisable(GL_TEXTURE_GEN_Q);
2147         checkGLcall("glDisable(GL_TEXTURE_GEN_S,T,R,Q)");
2148         break;
2149
2150     case WINED3DTSS_TCI_CAMERASPACEPOSITION:
2151         /* CameraSpacePosition means use the vertex position, transformed to camera space,
2152          * as the input texture coordinates for this stage's texture transformation. This
2153          * equates roughly to EYE_LINEAR
2154          */
2155         {
2156             float s_plane[] = { 1.0, 0.0, 0.0, 0.0 };
2157             float t_plane[] = { 0.0, 1.0, 0.0, 0.0 };
2158             float r_plane[] = { 0.0, 0.0, 1.0, 0.0 };
2159             float q_plane[] = { 0.0, 0.0, 0.0, 1.0 };
2160             TRACE("WINED3DTSS_TCI_CAMERASPACEPOSITION - Set eye plane\n");
2161
2162             glMatrixMode(GL_MODELVIEW);
2163             glPushMatrix();
2164             glLoadIdentity();
2165             glTexGenfv(GL_S, GL_EYE_PLANE, s_plane);
2166             glTexGenfv(GL_T, GL_EYE_PLANE, t_plane);
2167             glTexGenfv(GL_R, GL_EYE_PLANE, r_plane);
2168             glTexGenfv(GL_Q, GL_EYE_PLANE, q_plane);
2169             glPopMatrix();
2170
2171             TRACE("WINED3DTSS_TCI_CAMERASPACEPOSITION - Set GL_TEXTURE_GEN_x and GL_x, GL_TEXTURE_GEN_MODE, GL_EYE_LINEAR\n");
2172             glEnable(GL_TEXTURE_GEN_S);
2173             checkGLcall("glEnable(GL_TEXTURE_GEN_S)");
2174             glTexGeni(GL_S, GL_TEXTURE_GEN_MODE, GL_EYE_LINEAR);
2175             checkGLcall("glTexGeni(GL_S, GL_TEXTURE_GEN_MODE, GL_EYE_LINEAR)");
2176             glEnable(GL_TEXTURE_GEN_T);
2177             checkGLcall("glEnable(GL_TEXTURE_GEN_T)");
2178             glTexGeni(GL_T, GL_TEXTURE_GEN_MODE, GL_EYE_LINEAR);
2179             checkGLcall("glTexGeni(GL_T, GL_TEXTURE_GEN_MODE, GL_EYE_LINEAR)");
2180             glEnable(GL_TEXTURE_GEN_R);
2181             checkGLcall("glEnable(GL_TEXTURE_GEN_R)");
2182             glTexGeni(GL_R, GL_TEXTURE_GEN_MODE, GL_EYE_LINEAR);
2183             checkGLcall("glTexGeni(GL_R, GL_TEXTURE_GEN_MODE, GL_EYE_LINEAR)");
2184         }
2185         break;
2186
2187     case WINED3DTSS_TCI_CAMERASPACENORMAL:
2188         {
2189             if (GL_SUPPORT(NV_TEXGEN_REFLECTION)) {
2190                 float s_plane[] = { 1.0, 0.0, 0.0, 0.0 };
2191                 float t_plane[] = { 0.0, 1.0, 0.0, 0.0 };
2192                 float r_plane[] = { 0.0, 0.0, 1.0, 0.0 };
2193                 float q_plane[] = { 0.0, 0.0, 0.0, 1.0 };
2194                 TRACE("WINED3DTSS_TCI_CAMERASPACENORMAL - Set eye plane\n");
2195
2196                 glMatrixMode(GL_MODELVIEW);
2197                 glPushMatrix();
2198                 glLoadIdentity();
2199                 glTexGenfv(GL_S, GL_EYE_PLANE, s_plane);
2200                 glTexGenfv(GL_T, GL_EYE_PLANE, t_plane);
2201                 glTexGenfv(GL_R, GL_EYE_PLANE, r_plane);
2202                 glTexGenfv(GL_Q, GL_EYE_PLANE, q_plane);
2203                 glPopMatrix();
2204
2205                 glEnable(GL_TEXTURE_GEN_S);
2206                 checkGLcall("glEnable(GL_TEXTURE_GEN_S)");
2207                 glTexGeni(GL_S, GL_TEXTURE_GEN_MODE, GL_NORMAL_MAP_NV);
2208                 checkGLcall("glTexGeni(GL_S, GL_TEXTURE_GEN_MODE, GL_NORMAL_MAP_NV)");
2209                 glEnable(GL_TEXTURE_GEN_T);
2210                 checkGLcall("glEnable(GL_TEXTURE_GEN_T)");
2211                 glTexGeni(GL_T, GL_TEXTURE_GEN_MODE, GL_NORMAL_MAP_NV);
2212                 checkGLcall("glTexGeni(GL_T, GL_TEXTURE_GEN_MODE, GL_NORMAL_MAP_NV)");
2213                 glEnable(GL_TEXTURE_GEN_R);
2214                 checkGLcall("glEnable(GL_TEXTURE_GEN_R)");
2215                 glTexGeni(GL_R, GL_TEXTURE_GEN_MODE, GL_NORMAL_MAP_NV);
2216                 checkGLcall("glTexGeni(GL_R, GL_TEXTURE_GEN_MODE, GL_NORMAL_MAP_NV)");
2217             }
2218         }
2219         break;
2220
2221     case WINED3DTSS_TCI_CAMERASPACEREFLECTIONVECTOR:
2222         {
2223             if (GL_SUPPORT(NV_TEXGEN_REFLECTION)) {
2224             float s_plane[] = { 1.0, 0.0, 0.0, 0.0 };
2225             float t_plane[] = { 0.0, 1.0, 0.0, 0.0 };
2226             float r_plane[] = { 0.0, 0.0, 1.0, 0.0 };
2227             float q_plane[] = { 0.0, 0.0, 0.0, 1.0 };
2228             TRACE("WINED3DTSS_TCI_CAMERASPACEREFLECTIONVECTOR - Set eye plane\n");
2229
2230             glMatrixMode(GL_MODELVIEW);
2231             glPushMatrix();
2232             glLoadIdentity();
2233             glTexGenfv(GL_S, GL_EYE_PLANE, s_plane);
2234             glTexGenfv(GL_T, GL_EYE_PLANE, t_plane);
2235             glTexGenfv(GL_R, GL_EYE_PLANE, r_plane);
2236             glTexGenfv(GL_Q, GL_EYE_PLANE, q_plane);
2237             glPopMatrix();
2238
2239             glEnable(GL_TEXTURE_GEN_S);
2240             checkGLcall("glEnable(GL_TEXTURE_GEN_S)");
2241             glTexGeni(GL_S, GL_TEXTURE_GEN_MODE, GL_REFLECTION_MAP_NV);
2242             checkGLcall("glTexGeni(GL_S, GL_TEXTURE_GEN_MODE, GL_REFLECTION_MAP_NV)");
2243             glEnable(GL_TEXTURE_GEN_T);
2244             checkGLcall("glEnable(GL_TEXTURE_GEN_T)");
2245             glTexGeni(GL_T, GL_TEXTURE_GEN_MODE, GL_REFLECTION_MAP_NV);
2246             checkGLcall("glTexGeni(GL_T, GL_TEXTURE_GEN_MODE, GL_REFLECTION_MAP_NV)");
2247             glEnable(GL_TEXTURE_GEN_R);
2248             checkGLcall("glEnable(GL_TEXTURE_GEN_R)");
2249             glTexGeni(GL_R, GL_TEXTURE_GEN_MODE, GL_REFLECTION_MAP_NV);
2250             checkGLcall("glTexGeni(GL_R, GL_TEXTURE_GEN_MODE, GL_REFLECTION_MAP_NV)");
2251             }
2252         }
2253         break;
2254
2255     /* Unhandled types: */
2256     default:
2257         /* Todo: */
2258         /* ? disable GL_TEXTURE_GEN_n ? */
2259         glDisable(GL_TEXTURE_GEN_S);
2260         glDisable(GL_TEXTURE_GEN_T);
2261         glDisable(GL_TEXTURE_GEN_R);
2262         glDisable(GL_TEXTURE_GEN_Q);
2263         FIXME("Unhandled WINED3DTSS_TEXCOORDINDEX %x\n", stateblock->textureState[stage][WINED3DTSS_TEXCOORDINDEX]);
2264         break;
2265     }
2266
2267     /* Update the texture matrix */
2268     if(!isStateDirty(context, STATE_TRANSFORM(WINED3DTS_TEXTURE0 + stage))) {
2269         transform_texture(STATE_TRANSFORM(WINED3DTS_TEXTURE0 + stage), stateblock, context);
2270     }
2271
2272     if(!isStateDirty(context, STATE_VDECL) && context->namedArraysLoaded) {
2273         /* Reload the arrays if we are using fixed function arrays to reflect the selected coord input
2274          * source. Call loadTexCoords directly because there is no need to reparse the vertex declaration
2275          * and do all the things linked to it
2276          * TODO: Tidy that up to reload only the arrays of the changed unit
2277          */
2278         GLint curVBO = GL_SUPPORT(ARB_VERTEX_BUFFER_OBJECT) ? -1 : 0;
2279
2280         unloadTexCoords(stateblock);
2281         loadTexCoords(stateblock, &stateblock->wineD3DDevice->strided_streams, &curVBO);
2282     }
2283 }
2284
2285 static void shaderconstant(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
2286     IWineD3DDeviceImpl *device = stateblock->wineD3DDevice;
2287
2288     /* Vertex and pixel shader states will call a shader upload, don't do anything as long one of them
2289      * has an update pending
2290      */
2291     if(isStateDirty(context, STATE_VDECL) ||
2292        isStateDirty(context, STATE_PIXELSHADER)) {
2293        return;
2294     }
2295
2296     device->shader_backend->shader_load_constants((IWineD3DDevice *) device, use_ps(device), use_vs(device));
2297 }
2298
2299 static void tex_bumpenvlscale(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
2300     DWORD stage = (state - STATE_TEXTURESTAGE(0, 0)) / WINED3D_HIGHEST_TEXTURE_STATE;
2301     union {
2302         DWORD d;
2303         float f;
2304     } tmpvalue;
2305
2306     if(stateblock->pixelShader && stage != 0 &&
2307        ((IWineD3DPixelShaderImpl *) stateblock->pixelShader)->baseShader.reg_maps.luminanceparams[stage]) {
2308         /* The pixel shader has to know the luminance scale. Do a constants update if it
2309          * isn't scheduled anyway
2310          */
2311         if(!isStateDirty(context, STATE_PIXELSHADERCONSTANT) &&
2312            !isStateDirty(context, STATE_PIXELSHADER)) {
2313             shaderconstant(STATE_PIXELSHADERCONSTANT, stateblock, context);
2314         }
2315     }
2316
2317     tmpvalue.d = stateblock->textureState[stage][WINED3DTSS_BUMPENVLSCALE];
2318     if(tmpvalue.f != 0.0) {
2319         FIXME("WINED3DTSS_BUMPENVLSCALE not supported yet\n");
2320     }
2321 }
2322
2323 static void tex_bumpenvloffset(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
2324     DWORD stage = (state - STATE_TEXTURESTAGE(0, 0)) / WINED3D_HIGHEST_TEXTURE_STATE;
2325     union {
2326         DWORD d;
2327         float f;
2328     } tmpvalue;
2329
2330     if(stateblock->pixelShader && stage != 0 &&
2331        ((IWineD3DPixelShaderImpl *) stateblock->pixelShader)->baseShader.reg_maps.luminanceparams[stage]) {
2332         /* The pixel shader has to know the luminance offset. Do a constants update if it
2333          * isn't scheduled anyway
2334          */
2335         if(!isStateDirty(context, STATE_PIXELSHADERCONSTANT) &&
2336            !isStateDirty(context, STATE_PIXELSHADER)) {
2337             shaderconstant(STATE_PIXELSHADERCONSTANT, stateblock, context);
2338         }
2339     }
2340
2341     tmpvalue.d = stateblock->textureState[stage][WINED3DTSS_BUMPENVLOFFSET];
2342     if(tmpvalue.f != 0.0) {
2343         FIXME("WINED3DTSS_BUMPENVLOFFSET not supported yet\n");
2344     }
2345 }
2346
2347 static void sampler(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
2348     DWORD sampler = state - STATE_SAMPLER(0);
2349     DWORD mapped_stage = stateblock->wineD3DDevice->texUnitMap[sampler];
2350     union {
2351         float f;
2352         DWORD d;
2353     } tmpvalue;
2354
2355     TRACE("Sampler: %d\n", sampler);
2356     /* Enabling and disabling texture dimensions is done by texture stage state / pixel shader setup, this function
2357      * only has to bind textures and set the per texture states
2358      */
2359
2360     if (mapped_stage == -1) {
2361         TRACE("No sampler mapped to stage %d. Returning.\n", sampler);
2362         return;
2363     }
2364
2365     if (GL_SUPPORT(ARB_MULTITEXTURE)) {
2366         if (mapped_stage >= GL_LIMITS(combined_samplers)) {
2367             return;
2368         }
2369         GL_EXTCALL(glActiveTextureARB(GL_TEXTURE0_ARB + mapped_stage));
2370         checkGLcall("glActiveTextureARB");
2371     } else if (sampler > 0) {
2372         /* We can't do anything here */
2373         WARN("Program using multiple concurrent textures which this opengl implementation doesn't support\n");
2374         return;
2375     }
2376
2377     if(stateblock->textures[sampler]) {
2378         BOOL texIsPow2 = FALSE;
2379
2380         /* The fixed function np2 texture emulation uses the texture matrix to fix up the coordinates
2381          * IWineD3DBaseTexture::ApplyStateChanges multiplies the set matrix with a fixup matrix. Before the
2382          * scaling is reapplied or removed, the texture matrix has to be reapplied
2383          */
2384         if(!GL_SUPPORT(ARB_TEXTURE_NON_POWER_OF_TWO) && sampler < MAX_TEXTURES) {
2385             if(stateblock->textureDimensions[sampler] == GL_TEXTURE_2D ||
2386                stateblock->textureDimensions[sampler] == GL_TEXTURE_RECTANGLE_ARB) {
2387                 if(((IWineD3DTextureImpl *) stateblock->textures[sampler])->baseTexture.pow2Matrix[0] != 1.0 ||
2388                    ((IWineD3DTextureImpl *) stateblock->textures[sampler])->baseTexture.pow2Matrix[5] != 1.0 ) {
2389                     texIsPow2 = TRUE;
2390                 }
2391             } else if(stateblock->textureDimensions[sampler] == GL_TEXTURE_CUBE_MAP_ARB) {
2392                 if(((IWineD3DCubeTextureImpl *) stateblock->textures[sampler])->baseTexture.pow2Matrix[0] != 1.0) {
2393                     texIsPow2 = TRUE;
2394                 }
2395             }
2396
2397             if(texIsPow2 || context->lastWasPow2Texture[sampler]) {
2398                 context->lastWasPow2Texture[sampler] = texIsPow2;
2399                 transform_texture(STATE_TRANSFORM(WINED3DTS_TEXTURE0 + stateblock->wineD3DDevice->texUnitMap[sampler]), stateblock, context);
2400             }
2401         }
2402
2403         IWineD3DBaseTexture_PreLoad(stateblock->textures[sampler]);
2404         IWineD3DBaseTexture_ApplyStateChanges(stateblock->textures[sampler], stateblock->textureState[sampler], stateblock->samplerState[sampler]);
2405
2406         if (GL_SUPPORT(EXT_TEXTURE_LOD_BIAS)) {
2407             tmpvalue.d = stateblock->samplerState[sampler][WINED3DSAMP_MIPMAPLODBIAS];
2408             glTexEnvf(GL_TEXTURE_FILTER_CONTROL_EXT,
2409                       GL_TEXTURE_LOD_BIAS_EXT,
2410                       tmpvalue.f);
2411             checkGLcall("glTexEnvi(GL_TEXTURE_LOD_BIAS_EXT, ...)");
2412         }
2413
2414         if (stateblock->wineD3DDevice->ps_selected_mode != SHADER_NONE && stateblock->pixelShader &&
2415             ((IWineD3DPixelShaderImpl *)stateblock->pixelShader)->baseShader.function) {
2416             /* Using a pixel shader? Verify the sampler types */
2417
2418             /* Make sure that the texture dimensions are enabled. I don't have to disable the other
2419              * dimensions because the shader knows from which texture type to sample from. For the sake of
2420              * debugging all dimensions could be enabled and a texture with some ugly pink bound to the unused
2421              * dimensions. This should make wrong sampling sources visible :-)
2422              */
2423             glEnable(stateblock->textureDimensions[sampler]);
2424             checkGLcall("glEnable(stateblock->textureDimensions[sampler])");
2425         } else if(sampler < stateblock->lowest_disabled_stage) {
2426             if(!isStateDirty(context, STATE_TEXTURESTAGE(sampler, WINED3DTSS_COLOROP))) {
2427                 texture_activate_dimensions(sampler, stateblock, context);
2428             }
2429
2430             if(stateblock->renderState[WINED3DRS_COLORKEYENABLE] && sampler == 0) {
2431                 /* If color keying is enabled update the alpha test, it depends on the existence
2432                  * of a color key in stage 0
2433                  */
2434                 state_alpha(WINED3DRS_COLORKEYENABLE, stateblock, context);
2435             }
2436         }
2437     } else if(mapped_stage < GL_LIMITS(textures)) {
2438         if(sampler < stateblock->lowest_disabled_stage) {
2439             /* TODO: What should I do with pixel shaders here ??? */
2440             if(!isStateDirty(context, STATE_TEXTURESTAGE(sampler, WINED3DTSS_COLOROP))) {
2441                 texture_activate_dimensions(sampler, stateblock, context);
2442             }
2443
2444             if(stateblock->renderState[WINED3DRS_COLORKEYENABLE] && sampler == 0) {
2445                 /* If color keying is enabled update the alpha test, it depends on the existence
2446                 * of a color key in stage 0
2447                 */
2448                 state_alpha(WINED3DRS_COLORKEYENABLE, stateblock, context);
2449             }
2450         } /* Otherwise tex_colorop disables the stage */
2451         glBindTexture(GL_TEXTURE_2D, stateblock->wineD3DDevice->dummyTextureName[sampler]);
2452         checkGLcall("glBindTexture(GL_TEXTURE_2D, stateblock->wineD3DDevice->dummyTextureName[sampler])");
2453     }
2454 }
2455
2456 static void pixelshader(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
2457     IWineD3DDeviceImpl *device = stateblock->wineD3DDevice;
2458     BOOL use_pshader = use_ps(device);
2459     BOOL use_vshader = use_vs(device);
2460     BOOL update_fog = FALSE;
2461     int i;
2462
2463     if (use_pshader) {
2464         if(!context->last_was_pshader) {
2465             /* Former draw without a pixel shader, some samplers
2466              * may be disabled because of WINED3DTSS_COLOROP = WINED3DTOP_DISABLE
2467              * make sure to enable them
2468              */
2469             for(i=0; i < MAX_FRAGMENT_SAMPLERS; i++) {
2470                 if(!isStateDirty(context, STATE_SAMPLER(i))) {
2471                     sampler(STATE_SAMPLER(i), stateblock, context);
2472                 }
2473             }
2474             update_fog = TRUE;
2475         } else {
2476            /* Otherwise all samplers were activated by the code above in earlier draws, or by sampler()
2477             * if a different texture was bound. I don't have to do anything.
2478             */
2479         }
2480
2481         /* Compile and bind the shader */
2482         IWineD3DPixelShader_CompileShader(stateblock->pixelShader);
2483     } else {
2484         /* Disabled the pixel shader - color ops weren't applied
2485          * while it was enabled, so re-apply them.
2486          */
2487         for(i=0; i < MAX_TEXTURES; i++) {
2488             if(!isStateDirty(context, STATE_TEXTURESTAGE(i, WINED3DTSS_COLOROP))) {
2489                 tex_colorop(STATE_TEXTURESTAGE(i, WINED3DTSS_COLOROP), stateblock, context);
2490             }
2491         }
2492         if(context->last_was_pshader)
2493             update_fog = TRUE;
2494     }
2495
2496     if(!isStateDirty(context, device->StateTable[STATE_VSHADER].representative)) {
2497         device->shader_backend->shader_select((IWineD3DDevice *)stateblock->wineD3DDevice, use_pshader, use_vshader);
2498
2499         if (!isStateDirty(context, STATE_VERTEXSHADERCONSTANT) && (use_vshader || use_pshader)) {
2500             shaderconstant(STATE_VERTEXSHADERCONSTANT, stateblock, context);
2501         }
2502     }
2503
2504     if(update_fog)
2505         state_fog(state, stateblock, context);
2506
2507     context->last_was_pshader = use_pshader;
2508 }
2509
2510 static void tex_bumpenvmat(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
2511     DWORD stage = (state - STATE_TEXTURESTAGE(0, 0)) / WINED3D_HIGHEST_TEXTURE_STATE;
2512     float mat[2][2];
2513     if(stateblock->pixelShader && stage != 0 &&
2514        ((IWineD3DPixelShaderImpl *) stateblock->pixelShader)->baseShader.reg_maps.bumpmat[stage]) {
2515         /* The pixel shader has to know the bump env matrix. Do a constants update if it isn't scheduled
2516          * anyway
2517          */
2518         if(!isStateDirty(context, STATE_PIXELSHADERCONSTANT) &&
2519            !isStateDirty(context, STATE_PIXELSHADER)) {
2520             shaderconstant(STATE_PIXELSHADERCONSTANT, stateblock, context);
2521         }
2522     }
2523
2524     if(GL_SUPPORT(ATI_ENVMAP_BUMPMAP)) {
2525         if(stage >= GL_LIMITS(texture_stages)) {
2526             WARN("Bump env matrix of unsupported stage set\n");
2527         } else if(GL_SUPPORT(ARB_MULTITEXTURE)) {
2528             GL_EXTCALL(glActiveTextureARB(GL_TEXTURE0_ARB + stage));
2529             checkGLcall("GL_EXTCALL(glActiveTextureARB(GL_TEXTURE0_ARB + stage))");
2530         }
2531         mat[0][0] = *((float *) &stateblock->textureState[stage][WINED3DTSS_BUMPENVMAT00]);
2532         mat[1][0] = *((float *) &stateblock->textureState[stage][WINED3DTSS_BUMPENVMAT01]);
2533         mat[0][1] = *((float *) &stateblock->textureState[stage][WINED3DTSS_BUMPENVMAT10]);
2534         mat[1][1] = *((float *) &stateblock->textureState[stage][WINED3DTSS_BUMPENVMAT11]);
2535         GL_EXTCALL(glTexBumpParameterfvATI(GL_BUMP_ROT_MATRIX_ATI, (float *) mat));
2536         checkGLcall("glTexBumpParameterfvATI");
2537     } else if(GL_SUPPORT(NV_TEXTURE_SHADER2)) {
2538         /* Direct3D sets the matrix in the stage reading the perturbation map. The result is used to
2539          * offset the destination stage(always stage + 1 in d3d). In GL_NV_texture_shader, the bump
2540          * map offsetting is done in the stage reading the bump mapped texture, and the perturbation
2541          * map is read from a specified source stage(always stage - 1 for d3d). Thus set the matrix
2542          * for stage + 1. Keep the nvrc tex unit mapping in mind too
2543          */
2544         DWORD mapped_stage = stateblock->wineD3DDevice->texUnitMap[stage + 1];
2545
2546         if(mapped_stage < GL_LIMITS(textures)) {
2547             GL_EXTCALL(glActiveTextureARB(GL_TEXTURE0_ARB + mapped_stage));
2548             checkGLcall("GL_EXTCALL(glActiveTextureARB(GL_TEXTURE0_ARB + mapped_stage))");
2549
2550             /* We can't just pass a pointer to the stateblock to GL due to the different matrix
2551              * format(column major vs row major)
2552              */
2553             mat[0][0] = *((float *) &stateblock->textureState[stage][WINED3DTSS_BUMPENVMAT00]);
2554             mat[1][0] = *((float *) &stateblock->textureState[stage][WINED3DTSS_BUMPENVMAT01]);
2555             mat[0][1] = *((float *) &stateblock->textureState[stage][WINED3DTSS_BUMPENVMAT10]);
2556             mat[1][1] = *((float *) &stateblock->textureState[stage][WINED3DTSS_BUMPENVMAT11]);
2557             glTexEnvfv(GL_TEXTURE_SHADER_NV, GL_OFFSET_TEXTURE_MATRIX_NV, (float *) mat);
2558             checkGLcall("glTexEnvfv(GL_TEXTURE_SHADER_NV, GL_OFFSET_TEXTURE_MATRIX_NV, mat)");
2559         }
2560     }
2561 }
2562
2563 static void transform_world(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
2564     /* This function is called by transform_view below if the view matrix was changed too
2565      *
2566      * Deliberately no check if the vertex declaration is dirty because the vdecl state
2567      * does not always update the world matrix, only on a switch between transformed
2568      * and untransformed draws. It *may* happen that the world matrix is set 2 times during one
2569      * draw, but that should be rather rare and cheaper in total.
2570      */
2571     glMatrixMode(GL_MODELVIEW);
2572     checkGLcall("glMatrixMode");
2573
2574     if(context->last_was_rhw) {
2575         glLoadIdentity();
2576         checkGLcall("glLoadIdentity()");
2577     } else {
2578         /* In the general case, the view matrix is the identity matrix */
2579         if (stateblock->wineD3DDevice->view_ident) {
2580             glLoadMatrixf(&stateblock->transforms[WINED3DTS_WORLDMATRIX(0)].u.m[0][0]);
2581             checkGLcall("glLoadMatrixf");
2582         } else {
2583             glLoadMatrixf(&stateblock->transforms[WINED3DTS_VIEW].u.m[0][0]);
2584             checkGLcall("glLoadMatrixf");
2585             glMultMatrixf(&stateblock->transforms[WINED3DTS_WORLDMATRIX(0)].u.m[0][0]);
2586             checkGLcall("glMultMatrixf");
2587         }
2588     }
2589 }
2590
2591 static void clipplane(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
2592     UINT index = state - STATE_CLIPPLANE(0);
2593
2594     if(isStateDirty(context, STATE_TRANSFORM(WINED3DTS_VIEW)) || index >= GL_LIMITS(clipplanes)) {
2595         return;
2596     }
2597
2598     /* Clip Plane settings are affected by the model view in OpenGL, the View transform in direct3d */
2599     glMatrixMode(GL_MODELVIEW);
2600     glPushMatrix();
2601     glLoadMatrixf(&stateblock->transforms[WINED3DTS_VIEW].u.m[0][0]);
2602
2603     TRACE("Clipplane [%f,%f,%f,%f]\n",
2604           stateblock->clipplane[index][0],
2605           stateblock->clipplane[index][1],
2606           stateblock->clipplane[index][2],
2607           stateblock->clipplane[index][3]);
2608     glClipPlane(GL_CLIP_PLANE0 + index, stateblock->clipplane[index]);
2609     checkGLcall("glClipPlane");
2610
2611     glPopMatrix();
2612 }
2613
2614 static void transform_worldex(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
2615     UINT matrix = state - STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(0));
2616     GLenum glMat;
2617     TRACE("Setting world matrix %d\n", matrix);
2618
2619     if(matrix >= GL_LIMITS(blends)) {
2620         WARN("Unsupported blend matrix set\n");
2621         return;
2622     } else if(isStateDirty(context, STATE_TRANSFORM(WINED3DTS_VIEW))) {
2623         return;
2624     }
2625
2626     /* GL_MODELVIEW0_ARB:  0x1700
2627      * GL_MODELVIEW1_ARB:  0x0x850a
2628      * GL_MODELVIEW2_ARB:  0x8722
2629      * GL_MODELVIEW3_ARB:  0x8723
2630      * etc
2631      * GL_MODELVIEW31_ARB: 0x873F
2632      */
2633     if(matrix == 1) glMat = GL_MODELVIEW1_ARB;
2634     else glMat = GL_MODELVIEW2_ARB - 2 + matrix;
2635
2636     glMatrixMode(glMat);
2637     checkGLcall("glMatrixMode(glMat)");
2638
2639     /* World matrix 0 is multiplied with the view matrix because d3d uses 3 matrices while gl uses only 2. To avoid
2640      * weighting the view matrix incorrectly it has to be multiplied into every gl modelview matrix
2641      */
2642     if(stateblock->wineD3DDevice->view_ident) {
2643         glLoadMatrixf(&stateblock->transforms[WINED3DTS_WORLDMATRIX(matrix)].u.m[0][0]);
2644         checkGLcall("glLoadMatrixf")
2645     } else {
2646         glLoadMatrixf(&stateblock->transforms[WINED3DTS_VIEW].u.m[0][0]);
2647         checkGLcall("glLoadMatrixf")
2648         glMultMatrixf(&stateblock->transforms[WINED3DTS_WORLDMATRIX(matrix)].u.m[0][0]);
2649         checkGLcall("glMultMatrixf")
2650     }
2651 }
2652
2653 static void state_vertexblend(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
2654     WINED3DVERTEXBLENDFLAGS val = stateblock->renderState[WINED3DRS_VERTEXBLEND];
2655
2656     switch(val) {
2657         case WINED3DVBF_1WEIGHTS:
2658         case WINED3DVBF_2WEIGHTS:
2659         case WINED3DVBF_3WEIGHTS:
2660             if(GL_SUPPORT(ARB_VERTEX_BLEND)) {
2661                 glEnable(GL_VERTEX_BLEND_ARB);
2662                 checkGLcall("glEnable(GL_VERTEX_BLEND_ARB)");
2663
2664                 /* D3D adds one more matrix which has weight (1 - sum(weights)). This is enabled at context
2665                  * creation with enabling GL_WEIGHT_SUM_UNITY_ARB.
2666                  */
2667                 GL_EXTCALL(glVertexBlendARB(stateblock->renderState[WINED3DRS_VERTEXBLEND] + 1));
2668
2669                 if(!stateblock->wineD3DDevice->vertexBlendUsed) {
2670                     int i;
2671                     for(i = 1; i < GL_LIMITS(blends); i++) {
2672                         if(!isStateDirty(context, STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(i)))) {
2673                             transform_worldex(STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(i)), stateblock, context);
2674                         }
2675                     }
2676                     stateblock->wineD3DDevice->vertexBlendUsed = TRUE;
2677                 }
2678             } else {
2679                 static BOOL once = FALSE;
2680                 if(!once) {
2681                     once = TRUE;
2682                     /* TODO: Implement vertex blending in drawStridedSlow */
2683                     FIXME("Vertex blending enabled, but not supported by hardware\n");
2684                 }
2685             }
2686             break;
2687
2688         case WINED3DVBF_DISABLE:
2689         case WINED3DVBF_0WEIGHTS: /* for Indexed vertex blending - not supported */
2690             if(GL_SUPPORT(ARB_VERTEX_BLEND)) {
2691                 glDisable(GL_VERTEX_BLEND_ARB);
2692                 checkGLcall("glDisable(GL_VERTEX_BLEND_ARB)");
2693             } else {
2694                 TRACE("Vertex blending disabled\n");
2695             }
2696             break;
2697
2698         case WINED3DVBF_TWEENING:
2699             /* Just set the vertex weight for weight 0, enable vertex blending and hope the app doesn't have
2700              * vertex weights in the vertices?
2701              * For now we don't report that as supported, so a warn should suffice
2702              */
2703             WARN("Tweening not supported yet\n");
2704             break;
2705     }
2706 }
2707
2708 static void transform_view(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
2709     unsigned int k;
2710
2711     /* If we are changing the View matrix, reset the light and clipping planes to the new view
2712      * NOTE: We have to reset the positions even if the light/plane is not currently
2713      *       enabled, since the call to enable it will not reset the position.
2714      * NOTE2: Apparently texture transforms do NOT need reapplying
2715      */
2716
2717     PLIGHTINFOEL *light = NULL;
2718
2719     glMatrixMode(GL_MODELVIEW);
2720     checkGLcall("glMatrixMode(GL_MODELVIEW)");
2721     glLoadMatrixf(&stateblock->transforms[WINED3DTS_VIEW].u.m[0][0]);
2722     checkGLcall("glLoadMatrixf(...)");
2723
2724     /* Reset lights. TODO: Call light apply func */
2725     for(k = 0; k < stateblock->wineD3DDevice->maxConcurrentLights; k++) {
2726         light = stateblock->activeLights[k];
2727         if(!light) continue;
2728         glLightfv(GL_LIGHT0 + light->glIndex, GL_POSITION, light->lightPosn);
2729         checkGLcall("glLightfv posn");
2730         glLightfv(GL_LIGHT0 + light->glIndex, GL_SPOT_DIRECTION, light->lightDirn);
2731         checkGLcall("glLightfv dirn");
2732     }
2733
2734     /* Reset Clipping Planes  */
2735     for (k = 0; k < GL_LIMITS(clipplanes); k++) {
2736         if(!isStateDirty(context, STATE_CLIPPLANE(k))) {
2737             clipplane(STATE_CLIPPLANE(k), stateblock, context);
2738         }
2739     }
2740
2741     if(context->last_was_rhw) {
2742         glLoadIdentity();
2743         checkGLcall("glLoadIdentity()");
2744         /* No need to update the world matrix, the identity is fine */
2745         return;
2746     }
2747
2748     /* Call the world matrix state, this will apply the combined WORLD + VIEW matrix
2749      * No need to do it here if the state is scheduled for update.
2750      */
2751     if(!isStateDirty(context, STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(0)))) {
2752         transform_world(STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(0)), stateblock, context);
2753     }
2754
2755     /* Avoid looping over a number of matrices if the app never used the functionality */
2756     if(stateblock->wineD3DDevice->vertexBlendUsed) {
2757         for(k = 1; k < GL_LIMITS(blends); k++) {
2758             if(!isStateDirty(context, STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(k)))) {
2759                 transform_worldex(STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(k)), stateblock, context);
2760             }
2761         }
2762     }
2763 }
2764
2765 static void transform_projection(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
2766     glMatrixMode(GL_PROJECTION);
2767     checkGLcall("glMatrixMode(GL_PROJECTION)");
2768     glLoadIdentity();
2769     checkGLcall("glLoadIdentity");
2770
2771     if(context->last_was_rhw) {
2772         double X, Y, height, width, minZ, maxZ;
2773
2774         X      = stateblock->viewport.X;
2775         Y      = stateblock->viewport.Y;
2776         height = stateblock->viewport.Height;
2777         width  = stateblock->viewport.Width;
2778         minZ   = stateblock->viewport.MinZ;
2779         maxZ   = stateblock->viewport.MaxZ;
2780
2781         if(!stateblock->wineD3DDevice->untransformed) {
2782             /* Transformed vertices are supposed to bypass the whole transform pipeline including
2783              * frustum clipping. This can't be done in opengl, so this code adjusts the Z range to
2784              * suppress depth clipping. This can be done because it is an orthogonal projection and
2785              * the Z coordinate does not affect the size of the primitives. Half Life 1 and Prince of
2786              * Persia 3D need this.
2787              *
2788              * Note that using minZ and maxZ here doesn't entirely fix the problem, since view frustum
2789              * clipping is still enabled, but it seems to fix it for all apps tested so far. A minor
2790              * problem can be witnessed in half-life 1 engine based games, the weapon is clipped close
2791              * to the viewer.
2792              *
2793              * Also note that this breaks z comparison against z values filled in with clear,
2794              * but no app depending on that and disabled clipping has been found yet. Comparing
2795              * primitives against themselves works, so the Z buffer is still intact for normal hidden
2796              * surface removal.
2797              *
2798              * We could disable clipping entirely by setting the near to infinity and far to -infinity,
2799              * but this would break Z buffer operation. Raising the range to something less than
2800              * infinity would help a bit at the cost of Z precision, but it wouldn't eliminate the
2801              * problem either.
2802              */
2803             TRACE("Calling glOrtho with %f, %f, %f, %f\n", width, height, -minZ, -maxZ);
2804             if(stateblock->wineD3DDevice->render_offscreen) {
2805                 glOrtho(X, X + width, -Y, -Y - height, -minZ, -maxZ);
2806             } else {
2807                 glOrtho(X, X + width, Y + height, Y, -minZ, -maxZ);
2808             }
2809         } else {
2810             /* If the app mixes transformed and untransformed primitives we can't use the coordinate system
2811              * trick above because this would mess up transformed and untransformed Z order. Pass the z position
2812              * unmodified to opengl.
2813              *
2814              * If the app depends on mixed types and disabled clipping we're out of luck without a pipeline
2815              * replacement shader.
2816              */
2817             TRACE("Calling glOrtho with %f, %f, %f, %f\n", width, height, 1.0, -1.0);
2818             if(stateblock->wineD3DDevice->render_offscreen) {
2819                 glOrtho(X, X + width, -Y, -Y - height, 0.0, -1.0);
2820             } else {
2821                 glOrtho(X, X + width, Y + height, Y, 0.0, -1.0);
2822             }
2823         }
2824         checkGLcall("glOrtho");
2825
2826         /* Window Coord 0 is the middle of the first pixel, so translate by 1/2 pixels */
2827         glTranslatef(0.5, 0.5, 0);
2828         checkGLcall("glTranslatef(0.5, 0.5, 0)");
2829         /* D3D texture coordinates are flipped compared to OpenGL ones, so
2830          * render everything upside down when rendering offscreen. */
2831         if (stateblock->wineD3DDevice->render_offscreen) {
2832             glScalef(1.0, -1.0, 1.0);
2833             checkGLcall("glScalef");
2834         }
2835     } else {
2836         /* The rule is that the window coordinate 0 does not correspond to the
2837             beginning of the first pixel, but the center of the first pixel.
2838             As a consequence if you want to correctly draw one line exactly from
2839             the left to the right end of the viewport (with all matrices set to
2840             be identity), the x coords of both ends of the line would be not
2841             -1 and 1 respectively but (-1-1/viewport_widh) and (1-1/viewport_width)
2842             instead.
2843
2844             1.0 / Width is used because the coord range goes from -1.0 to 1.0, then we
2845             divide by the Width/Height, so we need the half range(1.0) to translate by
2846             half a pixel.
2847
2848             The other fun is that d3d's output z range after the transformation is [0;1],
2849             but opengl's is [-1;1]. Since the z buffer is in range [0;1] for both, gl
2850             scales [-1;1] to [0;1]. This would mean that we end up in [0.5;1] and loose a lot
2851             of Z buffer precision and the clear values do not match in the z test. Thus scale
2852             [0;1] to [-1;1], so when gl undoes that we utilize the full z range
2853          */
2854         glTranslatef(1.0 / stateblock->viewport.Width, -1.0/ stateblock->viewport.Height, -1.0);
2855         checkGLcall("glTranslatef (1.0 / width, -1.0 / height, -1.0)");
2856         if (stateblock->wineD3DDevice->render_offscreen) {
2857             /* D3D texture coordinates are flipped compared to OpenGL ones, so
2858              * render everything upside down when rendering offscreen. */
2859             glScalef(1.0, -1.0, 2.0);
2860         } else {
2861             glScalef(1.0, 1.0, 2.0);
2862         }
2863         checkGLcall("glScalef");
2864
2865         glMultMatrixf(&stateblock->transforms[WINED3DTS_PROJECTION].u.m[0][0]);
2866         checkGLcall("glLoadMatrixf");
2867     }
2868 }
2869
2870 /* This should match any arrays loaded in loadVertexData.
2871  * stateblock impl is required for GL_SUPPORT
2872  * TODO: Only load / unload arrays if we have to.
2873  */
2874 static inline void unloadVertexData(IWineD3DStateBlockImpl *stateblock) {
2875     glDisableClientState(GL_VERTEX_ARRAY);
2876     glDisableClientState(GL_NORMAL_ARRAY);
2877     glDisableClientState(GL_COLOR_ARRAY);
2878     if (GL_SUPPORT(EXT_SECONDARY_COLOR)) {
2879         glDisableClientState(GL_SECONDARY_COLOR_ARRAY_EXT);
2880     }
2881     if (GL_SUPPORT(ARB_VERTEX_BLEND)) {
2882         glDisableClientState(GL_WEIGHT_ARRAY_ARB);
2883     } else if (GL_SUPPORT(EXT_VERTEX_WEIGHTING)) {
2884         glDisableClientState(GL_VERTEX_WEIGHT_ARRAY_EXT);
2885     }
2886     unloadTexCoords(stateblock);
2887 }
2888
2889 /* This should match any arrays loaded in loadNumberedArrays
2890  * TODO: Only load / unload arrays if we have to.
2891  */
2892 static inline void unloadNumberedArrays(IWineD3DStateBlockImpl *stateblock) {
2893     /* disable any attribs (this is the same for both GLSL and ARB modes) */
2894     GLint maxAttribs = 16;
2895     int i;
2896
2897     /* Leave all the attribs disabled */
2898     glGetIntegerv(GL_MAX_VERTEX_ATTRIBS_ARB, &maxAttribs);
2899     /* MESA does not support it right not */
2900     if (glGetError() != GL_NO_ERROR)
2901         maxAttribs = 16;
2902     for (i = 0; i < maxAttribs; ++i) {
2903         GL_EXTCALL(glDisableVertexAttribArrayARB(i));
2904         checkGLcall("glDisableVertexAttribArrayARB(reg)");
2905         /* Some Windows drivers(NV GF 7) use the latest value that was used when drawing with the now
2906          * deactivated stream disabled, some other drivers(ATI, NV GF 8) set the undefined values to 0x00.
2907          * Let's set them to 0x00 to avoid hitting some undefined aspects of OpenGL. All that is really
2908          * important here is the glDisableVertexAttribArrayARB call above. The test shows that the refrast
2909          * keeps dereferencing the pointers, which would cause crashes in some games like Half Life 2: Episode Two.
2910          */
2911         GL_EXTCALL(glVertexAttrib4NubARB(i, 0, 0, 0, 0));
2912         checkGLcall("glVertexAttrib4NubARB(i, 0, 0, 0, 0)");
2913     }
2914 }
2915
2916 static inline void loadNumberedArrays(IWineD3DStateBlockImpl *stateblock, WineDirect3DVertexStridedData *strided) {
2917     GLint curVBO = GL_SUPPORT(ARB_VERTEX_BUFFER_OBJECT) ? -1 : 0;
2918     int i;
2919     UINT *offset = stateblock->streamOffset;
2920     IWineD3DVertexBufferImpl *vb;
2921     DWORD_PTR shift_index;
2922
2923     /* Default to no instancing */
2924     stateblock->wineD3DDevice->instancedDraw = FALSE;
2925
2926     for (i = 0; i < MAX_ATTRIBS; i++) {
2927
2928         if (!strided->u.input[i].lpData && !strided->u.input[i].VBO)
2929             continue;
2930
2931         /* Do not load instance data. It will be specified using glTexCoord by drawprim */
2932         if(stateblock->streamFlags[strided->u.input[i].streamNo] & WINED3DSTREAMSOURCE_INSTANCEDATA) {
2933             GL_EXTCALL(glDisableVertexAttribArrayARB(i));
2934             stateblock->wineD3DDevice->instancedDraw = TRUE;
2935             continue;
2936         }
2937
2938         TRACE_(d3d_shader)("Loading array %u [VBO=%u]\n", i, strided->u.input[i].VBO);
2939
2940         if(strided->u.input[i].dwStride) {
2941             if(curVBO != strided->u.input[i].VBO) {
2942                 GL_EXTCALL(glBindBufferARB(GL_ARRAY_BUFFER_ARB, strided->u.input[i].VBO));
2943                 checkGLcall("glBindBufferARB");
2944                 curVBO = strided->u.input[i].VBO;
2945             }
2946             vb = (IWineD3DVertexBufferImpl *) stateblock->streamSource[strided->u.input[i].streamNo];
2947             /* Use the VBO to find out if a vertex buffer exists, not the vb pointer. vb can point to a
2948              * user pointer data blob. In that case curVBO will be 0. If there is a vertex buffer but no
2949              * vbo we won't be load converted attributes anyway
2950              */
2951             if(curVBO && vb->conv_shift) {
2952                 TRACE("Loading attribute from shifted buffer\n");
2953                 TRACE("Attrib %d has original stride %d, new stride %d\n", i, strided->u.input[i].dwStride, vb->conv_stride);
2954                 TRACE("Original offset %p, additional offset 0x%08x\n",strided->u.input[i].lpData, vb->conv_shift[(DWORD_PTR) strided->u.input[i].lpData]);
2955                 TRACE("Opengl type %x\n", WINED3D_ATR_GLTYPE(strided->u.input[i].dwType));
2956                 shift_index = ((DWORD_PTR) strided->u.input[i].lpData + offset[strided->u.input[i].streamNo]);
2957                 shift_index = shift_index % strided->u.input[i].dwStride;
2958                 GL_EXTCALL(glVertexAttribPointerARB(i,
2959                                 WINED3D_ATR_SIZE(strided->u.input[i].dwType),
2960                                 WINED3D_ATR_GLTYPE(strided->u.input[i].dwType),
2961                                 WINED3D_ATR_NORMALIZED(strided->u.input[i].dwType),
2962                                 vb->conv_stride,
2963
2964                                 strided->u.input[i].lpData + vb->conv_shift[shift_index] +
2965                                 stateblock->loadBaseVertexIndex * strided->u.input[i].dwStride +
2966                                 offset[strided->u.input[i].streamNo]));
2967
2968             } else {
2969                 GL_EXTCALL(glVertexAttribPointerARB(i,
2970                                 WINED3D_ATR_SIZE(strided->u.input[i].dwType),
2971                                 WINED3D_ATR_GLTYPE(strided->u.input[i].dwType),
2972                                 WINED3D_ATR_NORMALIZED(strided->u.input[i].dwType),
2973                                 strided->u.input[i].dwStride,
2974
2975                                 strided->u.input[i].lpData +
2976                                 stateblock->loadBaseVertexIndex * strided->u.input[i].dwStride +
2977                                 offset[strided->u.input[i].streamNo]) );
2978                 }
2979             GL_EXTCALL(glEnableVertexAttribArrayARB(i));
2980         } else {
2981             /* Stride = 0 means always the same values. glVertexAttribPointerARB doesn't do that. Instead disable the pointer and
2982              * set up the attribute statically. But we have to figure out the system memory address.
2983              */
2984             BYTE *ptr = strided->u.input[i].lpData + offset[strided->u.input[i].streamNo];
2985             if(strided->u.input[i].VBO) {
2986                 vb = (IWineD3DVertexBufferImpl *) stateblock->streamSource[strided->u.input[i].streamNo];
2987                 ptr += (long) vb->resource.allocatedMemory;
2988             }
2989             GL_EXTCALL(glDisableVertexAttribArrayARB(i));
2990
2991             switch(strided->u.input[i].dwType) {
2992                 case WINED3DDECLTYPE_FLOAT1:
2993                     GL_EXTCALL(glVertexAttrib1fvARB(i, (float *) ptr));
2994                     break;
2995                 case WINED3DDECLTYPE_FLOAT2:
2996                     GL_EXTCALL(glVertexAttrib2fvARB(i, (float *) ptr));
2997                     break;
2998                 case WINED3DDECLTYPE_FLOAT3:
2999                     GL_EXTCALL(glVertexAttrib3fvARB(i, (float *) ptr));
3000                     break;
3001                 case WINED3DDECLTYPE_FLOAT4:
3002                     GL_EXTCALL(glVertexAttrib4fvARB(i, (float *) ptr));
3003                     break;
3004
3005                 case WINED3DDECLTYPE_UBYTE4:
3006                     GL_EXTCALL(glVertexAttrib4NubvARB(i, ptr));
3007                     break;
3008                 case WINED3DDECLTYPE_UBYTE4N:
3009                 case WINED3DDECLTYPE_D3DCOLOR:
3010                     GL_EXTCALL(glVertexAttrib4NubvARB(i, ptr));
3011                     break;
3012
3013                 case WINED3DDECLTYPE_SHORT2:
3014                     GL_EXTCALL(glVertexAttrib4svARB(i, (GLshort *) ptr));
3015                     break;
3016                 case WINED3DDECLTYPE_SHORT4:
3017                     GL_EXTCALL(glVertexAttrib4svARB(i, (GLshort *) ptr));
3018                     break;
3019
3020                 case WINED3DDECLTYPE_SHORT2N:
3021                 {
3022                     GLshort s[4] = {((short *) ptr)[0], ((short *) ptr)[1], 0, 1};
3023                     GL_EXTCALL(glVertexAttrib4NsvARB(i, s));
3024                     break;
3025                 }
3026                 case WINED3DDECLTYPE_USHORT2N:
3027                 {
3028                     GLushort s[4] = {((unsigned short *) ptr)[0], ((unsigned short *) ptr)[1], 0, 1};
3029                     GL_EXTCALL(glVertexAttrib4NusvARB(i, s));
3030                     break;
3031                 }
3032                 case WINED3DDECLTYPE_SHORT4N:
3033                     GL_EXTCALL(glVertexAttrib4NsvARB(i, (GLshort *) ptr));
3034                     break;
3035                 case WINED3DDECLTYPE_USHORT4N:
3036                     GL_EXTCALL(glVertexAttrib4NusvARB(i, (GLushort *) ptr));
3037                     break;
3038
3039                 case WINED3DDECLTYPE_UDEC3:
3040                     FIXME("Unsure about WINED3DDECLTYPE_UDEC3\n");
3041                     /*glVertexAttrib3usvARB(i, (GLushort *) ptr); Does not exist */
3042                     break;
3043                 case WINED3DDECLTYPE_DEC3N:
3044                     FIXME("Unsure about WINED3DDECLTYPE_DEC3N\n");
3045                     /*glVertexAttrib3NusvARB(i, (GLushort *) ptr); Does not exist */
3046                     break;
3047
3048                 case WINED3DDECLTYPE_FLOAT16_2:
3049                     /* Are those 16 bit floats. C doesn't have a 16 bit float type. I could read the single bits and calculate a 4
3050                      * byte float according to the IEEE standard
3051                      */
3052                     FIXME("Unsupported WINED3DDECLTYPE_FLOAT16_2\n");
3053                     break;
3054                 case WINED3DDECLTYPE_FLOAT16_4:
3055                     FIXME("Unsupported WINED3DDECLTYPE_FLOAT16_4\n");
3056                     break;
3057
3058                 case WINED3DDECLTYPE_UNUSED:
3059                 default:
3060                     ERR("Unexpected declaration in stride 0 attributes\n");
3061                     break;
3062
3063             }
3064         }
3065     }
3066     checkGLcall("Loading numbered arrays");
3067 }
3068
3069 /* Used from 2 different functions, and too big to justify making it inlined */
3070 static void loadVertexData(IWineD3DStateBlockImpl *stateblock, WineDirect3DVertexStridedData *sd) {
3071     UINT *offset = stateblock->streamOffset;
3072     GLint curVBO = GL_SUPPORT(ARB_VERTEX_BUFFER_OBJECT) ? -1 : 0;
3073
3074     TRACE("Using fast vertex array code\n");
3075
3076     /* This is fixed function pipeline only, and the fixed function pipeline doesn't do instancing */
3077     stateblock->wineD3DDevice->instancedDraw = FALSE;
3078
3079     /* Blend Data ---------------------------------------------- */
3080     if( (sd->u.s.blendWeights.lpData) || (sd->u.s.blendWeights.VBO) ||
3081         (sd->u.s.blendMatrixIndices.lpData) || (sd->u.s.blendMatrixIndices.VBO) ) {
3082
3083         if (GL_SUPPORT(ARB_VERTEX_BLEND)) {
3084             TRACE("Blend %d %p %d\n", WINED3D_ATR_SIZE(sd->u.s.blendWeights.dwType),
3085                 sd->u.s.blendWeights.lpData + stateblock->loadBaseVertexIndex * sd->u.s.blendWeights.dwStride, sd->u.s.blendWeights.dwStride + offset[sd->u.s.blendWeights.streamNo]);
3086
3087             glEnableClientState(GL_WEIGHT_ARRAY_ARB);
3088             checkGLcall("glEnableClientState(GL_WEIGHT_ARRAY_ARB)");
3089
3090             GL_EXTCALL(glVertexBlendARB(WINED3D_ATR_SIZE(sd->u.s.blendWeights.dwType) + 1));
3091
3092             VTRACE(("glWeightPointerARB(%d, GL_FLOAT, %d, %p)\n",
3093                 WINED3D_ATR_SIZE(sd->u.s.blendWeights.dwType) ,
3094                 sd->u.s.blendWeights.dwStride,
3095                 sd->u.s.blendWeights.lpData + stateblock->loadBaseVertexIndex * sd->u.s.blendWeights.dwStride + offset[sd->u.s.blendWeights.streamNo]));
3096
3097             if(curVBO != sd->u.s.blendWeights.VBO) {
3098                 GL_EXTCALL(glBindBufferARB(GL_ARRAY_BUFFER_ARB, sd->u.s.blendWeights.VBO));
3099                 checkGLcall("glBindBufferARB");
3100                 curVBO = sd->u.s.blendWeights.VBO;
3101             }
3102
3103             GL_EXTCALL(glWeightPointerARB)(
3104                 WINED3D_ATR_SIZE(sd->u.s.blendWeights.dwType),
3105                 WINED3D_ATR_GLTYPE(sd->u.s.blendWeights.dwType),
3106                 sd->u.s.blendWeights.dwStride,
3107                 sd->u.s.blendWeights.lpData + stateblock->loadBaseVertexIndex * sd->u.s.blendWeights.dwStride + offset[sd->u.s.blendWeights.streamNo]);
3108
3109             checkGLcall("glWeightPointerARB");
3110
3111             if((sd->u.s.blendMatrixIndices.lpData) || (sd->u.s.blendMatrixIndices.VBO)){
3112                 static BOOL showfixme = TRUE;
3113                 if(showfixme){
3114                     FIXME("blendMatrixIndices support\n");
3115                     showfixme = FALSE;
3116                 }
3117             }
3118         } else if (GL_SUPPORT(EXT_VERTEX_WEIGHTING)) {
3119             /* FIXME("TODO\n");*/
3120 #if 0
3121
3122             GL_EXTCALL(glVertexWeightPointerEXT)(
3123                 WINED3D_ATR_SIZE(sd->u.s.blendWeights.dwType),
3124                 WINED3D_ATR_GLTYPE(sd->u.s.blendWeights.dwType),
3125                 sd->u.s.blendWeights.dwStride,
3126                 sd->u.s.blendWeights.lpData + stateblock->loadBaseVertexIndex * sd->u.s.blendWeights.dwStride);
3127             checkGLcall("glVertexWeightPointerEXT(numBlends, ...)");
3128             glEnableClientState(GL_VERTEX_WEIGHT_ARRAY_EXT);
3129             checkGLcall("glEnableClientState(GL_VERTEX_WEIGHT_ARRAY_EXT)");
3130 #endif
3131
3132         } else {
3133             /* TODO: support blends in drawStridedSlow
3134              * No need to write a FIXME here, this is done after the general vertex decl decoding
3135              */
3136             WARN("unsupported blending in openGl\n");
3137         }
3138     } else {
3139         if (GL_SUPPORT(ARB_VERTEX_BLEND)) {
3140             static const GLbyte one = 1;
3141             GL_EXTCALL(glWeightbvARB(1, &one));
3142             checkGLcall("glWeightivARB(GL_LIMITS(blends), weights)");
3143         }
3144     }
3145
3146 #if 0 /* FOG  ----------------------------------------------*/
3147     if (sd->u.s.fog.lpData || sd->u.s.fog.VBO) {
3148         /* TODO: fog*/
3149     if (GL_SUPPORT(EXT_FOG_COORD) {
3150              glEnableClientState(GL_FOG_COORDINATE_EXT);
3151             (GL_EXTCALL)(FogCoordPointerEXT)(
3152                 WINED3D_ATR_GLTYPE(sd->u.s.fog.dwType),
3153                 sd->u.s.fog.dwStride,
3154                 sd->u.s.fog.lpData + stateblock->loadBaseVertexIndex * sd->u.s.fog.dwStride);
3155         } else {
3156             /* don't bother falling back to 'slow' as we don't support software FOG yet. */
3157             /* FIXME: fixme once */
3158             TRACE("Hardware support for FOG is not avaiable, FOG disabled.\n");
3159         }
3160     } else {
3161         if (GL_SUPPRT(EXT_FOR_COORD) {
3162              /* make sure fog is disabled */
3163              glDisableClientState(GL_FOG_COORDINATE_EXT);
3164         }
3165     }
3166 #endif
3167
3168 #if 0 /* tangents  ----------------------------------------------*/
3169     if (sd->u.s.tangent.lpData || sd->u.s.tangent.VBO ||
3170         sd->u.s.binormal.lpData || sd->u.s.binormal.VBO) {
3171         /* TODO: tangents*/
3172         if (GL_SUPPORT(EXT_COORDINATE_FRAME) {
3173             if (sd->u.s.tangent.lpData || sd->u.s.tangent.VBO) {
3174                 glEnable(GL_TANGENT_ARRAY_EXT);
3175                 (GL_EXTCALL)(TangentPointerEXT)(
3176                     WINED3D_ATR_GLTYPE(sd->u.s.tangent.dwType),
3177                     sd->u.s.tangent.dwStride,
3178                     sd->u.s.tangent.lpData + stateblock->loadBaseVertexIndex * sd->u.s.tangent.dwStride);
3179             } else {
3180                     glDisable(GL_TANGENT_ARRAY_EXT);
3181             }
3182             if (sd->u.s.binormal.lpData || sd->u.s.binormal.VBO) {
3183                     glEnable(GL_BINORMAL_ARRAY_EXT);
3184                     (GL_EXTCALL)(BinormalPointerEXT)(
3185                         WINED3D_ATR_GLTYPE(sd->u.s.binormal.dwType),
3186                         sd->u.s.binormal.dwStride,
3187                         sd->u.s.binormal.lpData + stateblock->loadBaseVertexIndex * sd->u.s.binormal.dwStride);
3188             } else{
3189                     glDisable(GL_BINORMAL_ARRAY_EXT);
3190             }
3191
3192         } else {
3193             /* don't bother falling back to 'slow' as we don't support software tangents and binormals yet . */
3194             /* FIXME: fixme once */
3195             TRACE("Hardware support for tangents and binormals is not avaiable, tangents and binormals disabled.\n");
3196         }
3197     } else {
3198         if (GL_SUPPORT(EXT_COORDINATE_FRAME) {
3199              /* make sure fog is disabled */
3200              glDisable(GL_TANGENT_ARRAY_EXT);
3201              glDisable(GL_BINORMAL_ARRAY_EXT);
3202         }
3203     }
3204 #endif
3205
3206     /* Point Size ----------------------------------------------*/
3207     if (sd->u.s.pSize.lpData || sd->u.s.pSize.VBO) {
3208
3209         /* no such functionality in the fixed function GL pipeline */
3210         TRACE("Cannot change ptSize here in openGl\n");
3211         /* TODO: Implement this function in using shaders if they are available */
3212
3213     }
3214
3215     /* Vertex Pointers -----------------------------------------*/
3216     if (sd->u.s.position.lpData != NULL || sd->u.s.position.VBO != 0) {
3217         /* Note dwType == float3 or float4 == 2 or 3 */
3218         VTRACE(("glVertexPointer(%d, GL_FLOAT, %d, %p)\n",
3219                 sd->u.s.position.dwStride,
3220                 sd->u.s.position.dwType + 1,
3221                 sd->u.s.position.lpData));
3222
3223         if(curVBO != sd->u.s.position.VBO) {
3224             GL_EXTCALL(glBindBufferARB(GL_ARRAY_BUFFER_ARB, sd->u.s.position.VBO));
3225             checkGLcall("glBindBufferARB");
3226             curVBO = sd->u.s.position.VBO;
3227         }
3228
3229         /* min(WINED3D_ATR_SIZE(position),3) to Disable RHW mode as 'w' coord
3230            handling for rhw mode should not impact screen position whereas in GL it does.
3231            This may result in very slightly distorted textures in rhw mode.
3232            There's always the other option of fixing the view matrix to
3233            prevent w from having any effect.
3234
3235            This only applies to user pointer sources, in VBOs the vertices are fixed up
3236          */
3237         if(sd->u.s.position.VBO == 0) {
3238             glVertexPointer(3 /* min(WINED3D_ATR_SIZE(sd->u.s.position.dwType),3) */,
3239                 WINED3D_ATR_GLTYPE(sd->u.s.position.dwType),
3240                 sd->u.s.position.dwStride, sd->u.s.position.lpData + stateblock->loadBaseVertexIndex * sd->u.s.position.dwStride + offset[sd->u.s.position.streamNo]);
3241         } else {
3242             glVertexPointer(
3243                 WINED3D_ATR_SIZE(sd->u.s.position.dwType),
3244                 WINED3D_ATR_GLTYPE(sd->u.s.position.dwType),
3245                 sd->u.s.position.dwStride, sd->u.s.position.lpData + stateblock->loadBaseVertexIndex * sd->u.s.position.dwStride + offset[sd->u.s.position.streamNo]);
3246         }
3247         checkGLcall("glVertexPointer(...)");
3248         glEnableClientState(GL_VERTEX_ARRAY);
3249         checkGLcall("glEnableClientState(GL_VERTEX_ARRAY)");
3250     }
3251
3252     /* Normals -------------------------------------------------*/
3253     if (sd->u.s.normal.lpData || sd->u.s.normal.VBO) {
3254         /* Note dwType == float3 or float4 == 2 or 3 */
3255         VTRACE(("glNormalPointer(GL_FLOAT, %d, %p)\n",
3256                 sd->u.s.normal.dwStride,
3257                 sd->u.s.normal.lpData));
3258         if(curVBO != sd->u.s.normal.VBO) {
3259             GL_EXTCALL(glBindBufferARB(GL_ARRAY_BUFFER_ARB, sd->u.s.normal.VBO));
3260             checkGLcall("glBindBufferARB");
3261             curVBO = sd->u.s.normal.VBO;
3262         }
3263         glNormalPointer(
3264             WINED3D_ATR_GLTYPE(sd->u.s.normal.dwType),
3265             sd->u.s.normal.dwStride,
3266             sd->u.s.normal.lpData + stateblock->loadBaseVertexIndex * sd->u.s.normal.dwStride + offset[sd->u.s.normal.streamNo]);
3267         checkGLcall("glNormalPointer(...)");
3268         glEnableClientState(GL_NORMAL_ARRAY);
3269         checkGLcall("glEnableClientState(GL_NORMAL_ARRAY)");
3270
3271     } else {
3272         glNormal3f(0, 0, 0);
3273         checkGLcall("glNormal3f(0, 0, 0)");
3274     }
3275
3276     /* Diffuse Colour --------------------------------------------*/
3277     /*  WARNING: Data here MUST be in RGBA format, so cannot      */
3278     /*     go directly into fast mode from app pgm, because       */
3279     /*     directx requires data in BGRA format.                  */
3280     /* currently fixupVertices swizzles the format, but this isn't*/
3281     /* very practical when using VBOs                             */
3282     /* NOTE: Unless we write a vertex shader to swizzle the colour*/
3283     /* , or the user doesn't care and wants the speed advantage   */
3284
3285     if (sd->u.s.diffuse.lpData || sd->u.s.diffuse.VBO) {
3286         /* Note dwType == float3 or float4 == 2 or 3 */
3287         VTRACE(("glColorPointer(4, GL_UNSIGNED_BYTE, %d, %p)\n",
3288                 sd->u.s.diffuse.dwStride,
3289                 sd->u.s.diffuse.lpData));
3290
3291         if(curVBO != sd->u.s.diffuse.VBO) {
3292             GL_EXTCALL(glBindBufferARB(GL_ARRAY_BUFFER_ARB, sd->u.s.diffuse.VBO));
3293             checkGLcall("glBindBufferARB");
3294             curVBO = sd->u.s.diffuse.VBO;
3295         }
3296
3297         glColorPointer(WINED3D_ATR_SIZE(sd->u.s.diffuse.dwType),
3298                        WINED3D_ATR_GLTYPE(sd->u.s.diffuse.dwType),
3299                        sd->u.s.diffuse.dwStride,
3300                        sd->u.s.diffuse.lpData + stateblock->loadBaseVertexIndex * sd->u.s.diffuse.dwStride + offset[sd->u.s.diffuse.streamNo]);
3301         checkGLcall("glColorPointer(4, GL_UNSIGNED_BYTE, ...)");
3302         glEnableClientState(GL_COLOR_ARRAY);
3303         checkGLcall("glEnableClientState(GL_COLOR_ARRAY)");
3304
3305     } else {
3306         glColor4f(1.0f, 1.0f, 1.0f, 1.0f);
3307         checkGLcall("glColor4f(1, 1, 1, 1)");
3308     }
3309
3310     /* Specular Colour ------------------------------------------*/
3311     if (sd->u.s.specular.lpData || sd->u.s.specular.VBO) {
3312         TRACE("setting specular colour\n");
3313         /* Note dwType == float3 or float4 == 2 or 3 */
3314         VTRACE(("glSecondaryColorPointer(4, GL_UNSIGNED_BYTE, %d, %p)\n",
3315                 sd->u.s.specular.dwStride,
3316                 sd->u.s.specular.lpData));
3317         if (GL_SUPPORT(EXT_SECONDARY_COLOR)) {
3318             if(curVBO != sd->u.s.specular.VBO) {
3319                 GL_EXTCALL(glBindBufferARB(GL_ARRAY_BUFFER_ARB, sd->u.s.specular.VBO));
3320                 checkGLcall("glBindBufferARB");
3321                 curVBO = sd->u.s.specular.VBO;
3322             }
3323             GL_EXTCALL(glSecondaryColorPointerEXT)(WINED3D_ATR_SIZE(sd->u.s.specular.dwType),
3324                                                    WINED3D_ATR_GLTYPE(sd->u.s.specular.dwType),
3325                                                    sd->u.s.specular.dwStride,
3326                                                    sd->u.s.specular.lpData + stateblock->loadBaseVertexIndex * sd->u.s.specular.dwStride + offset[sd->u.s.specular.streamNo]);
3327             vcheckGLcall("glSecondaryColorPointerEXT(4, GL_UNSIGNED_BYTE, ...)");
3328             glEnableClientState(GL_SECONDARY_COLOR_ARRAY_EXT);
3329             vcheckGLcall("glEnableClientState(GL_SECONDARY_COLOR_ARRAY_EXT)");
3330         } else {
3331
3332         /* Missing specular color is not critical, no warnings */
3333         VTRACE(("Specular colour is not supported in this GL implementation\n"));
3334         }
3335
3336     } else {
3337         if (GL_SUPPORT(EXT_SECONDARY_COLOR)) {
3338             GL_EXTCALL(glSecondaryColor3fEXT)(0, 0, 0);
3339             checkGLcall("glSecondaryColor3fEXT(0, 0, 0)");
3340         } else {
3341
3342             /* Missing specular color is not critical, no warnings */
3343             VTRACE(("Specular colour is not supported in this GL implementation\n"));
3344         }
3345     }
3346
3347     /* Texture coords -------------------------------------------*/
3348     loadTexCoords(stateblock, sd, &curVBO);
3349 }
3350
3351 static inline void drawPrimitiveTraceDataLocations(
3352     WineDirect3DVertexStridedData *dataLocations) {
3353
3354     /* Dump out what parts we have supplied */
3355     TRACE("Strided Data:\n");
3356     TRACE_STRIDED((dataLocations), position);
3357     TRACE_STRIDED((dataLocations), blendWeights);
3358     TRACE_STRIDED((dataLocations), blendMatrixIndices);
3359     TRACE_STRIDED((dataLocations), normal);
3360     TRACE_STRIDED((dataLocations), pSize);
3361     TRACE_STRIDED((dataLocations), diffuse);
3362     TRACE_STRIDED((dataLocations), specular);
3363     TRACE_STRIDED((dataLocations), texCoords[0]);
3364     TRACE_STRIDED((dataLocations), texCoords[1]);
3365     TRACE_STRIDED((dataLocations), texCoords[2]);
3366     TRACE_STRIDED((dataLocations), texCoords[3]);
3367     TRACE_STRIDED((dataLocations), texCoords[4]);
3368     TRACE_STRIDED((dataLocations), texCoords[5]);
3369     TRACE_STRIDED((dataLocations), texCoords[6]);
3370     TRACE_STRIDED((dataLocations), texCoords[7]);
3371     TRACE_STRIDED((dataLocations), position2);
3372     TRACE_STRIDED((dataLocations), normal2);
3373     TRACE_STRIDED((dataLocations), tangent);
3374     TRACE_STRIDED((dataLocations), binormal);
3375     TRACE_STRIDED((dataLocations), tessFactor);
3376     TRACE_STRIDED((dataLocations), fog);
3377     TRACE_STRIDED((dataLocations), depth);
3378     TRACE_STRIDED((dataLocations), sample);
3379
3380     return;
3381 }
3382
3383 static void streamsrc(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
3384     IWineD3DDeviceImpl *device = stateblock->wineD3DDevice;
3385     BOOL fixup = FALSE;
3386     WineDirect3DVertexStridedData *dataLocations = &device->strided_streams;
3387     BOOL useVertexShaderFunction;
3388
3389     if (device->vs_selected_mode != SHADER_NONE && stateblock->vertexShader &&
3390         ((IWineD3DVertexShaderImpl *)stateblock->vertexShader)->baseShader.function != NULL) {
3391         useVertexShaderFunction = TRUE;
3392     } else {
3393         useVertexShaderFunction = FALSE;
3394     }
3395
3396
3397     if(device->up_strided) {
3398         /* Note: this is a ddraw fixed-function code path */
3399         TRACE("================ Strided Input ===================\n");
3400         memcpy(dataLocations, device->up_strided, sizeof(*dataLocations));
3401
3402         if(TRACE_ON(d3d)) {
3403             drawPrimitiveTraceDataLocations(dataLocations);
3404         }
3405     } else {
3406         /* Note: This is a fixed function or shader codepath.
3407          * This means it must handle both types of strided data.
3408          * Shaders must go through here to zero the strided data, even if they
3409          * don't set any declaration at all
3410          */
3411         TRACE("================ Vertex Declaration  ===================\n");
3412         memset(dataLocations, 0, sizeof(*dataLocations));
3413         primitiveDeclarationConvertToStridedData((IWineD3DDevice *) device,
3414                 useVertexShaderFunction, dataLocations, &fixup);
3415     }
3416
3417     if (dataLocations->u.s.position_transformed) {
3418         useVertexShaderFunction = FALSE;
3419     }
3420
3421     /* Unload the old arrays before loading the new ones to get old junk out */
3422     if(context->numberedArraysLoaded) {
3423         unloadNumberedArrays(stateblock);
3424         context->numberedArraysLoaded = FALSE;
3425     }
3426     if(context->namedArraysLoaded) {
3427         unloadVertexData(stateblock);
3428         context->namedArraysLoaded = FALSE;
3429     }
3430
3431     if(useVertexShaderFunction) {
3432         if(((IWineD3DVertexDeclarationImpl *) stateblock->vertexDecl)->half_float_conv_needed && !fixup) {
3433             TRACE("Using drawStridedSlow with vertex shaders for FLOAT16 conversion\n");
3434             device->useDrawStridedSlow = TRUE;
3435             context->numberedArraysLoaded = FALSE;
3436         } else {
3437             TRACE("Loading numbered arrays\n");
3438             loadNumberedArrays(stateblock, dataLocations);
3439             device->useDrawStridedSlow = FALSE;
3440             context->numberedArraysLoaded = TRUE;
3441         }
3442     } else if (fixup ||
3443                (dataLocations->u.s.pSize.lpData == NULL &&
3444                 dataLocations->u.s.diffuse.lpData == NULL &&
3445                 dataLocations->u.s.specular.lpData == NULL)) {
3446         /* Load the vertex data using named arrays */
3447         TRACE("Loading vertex data\n");
3448         loadVertexData(stateblock, dataLocations);
3449         device->useDrawStridedSlow = FALSE;
3450         context->namedArraysLoaded = TRUE;
3451     } else {
3452         TRACE("Not loading vertex data\n");
3453         device->useDrawStridedSlow = TRUE;
3454     }
3455
3456 /* Generate some fixme's if unsupported functionality is being used */
3457 #define BUFFER_OR_DATA(_attribute) dataLocations->u.s._attribute.lpData
3458     /* TODO: Either support missing functionality in fixupVertices or by creating a shader to replace the pipeline. */
3459     if (!useVertexShaderFunction && (BUFFER_OR_DATA(position2) || BUFFER_OR_DATA(normal2))) {
3460         FIXME("Tweening is only valid with vertex shaders\n");
3461     }
3462     if (!useVertexShaderFunction && (BUFFER_OR_DATA(tangent) || BUFFER_OR_DATA(binormal))) {
3463         FIXME("Tangent and binormal bump mapping is only valid with vertex shaders\n");
3464     }
3465     if (!useVertexShaderFunction && (BUFFER_OR_DATA(tessFactor) || BUFFER_OR_DATA(fog) || BUFFER_OR_DATA(depth) || BUFFER_OR_DATA(sample))) {
3466         FIXME("Extended attributes are only valid with vertex shaders\n");
3467     }
3468 #undef BUFFER_OR_DATA
3469 }
3470
3471 static void vertexdeclaration(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
3472     BOOL useVertexShaderFunction = FALSE, updateFog = FALSE;
3473     BOOL usePixelShaderFunction = stateblock->wineD3DDevice->ps_selected_mode != SHADER_NONE && stateblock->pixelShader
3474             && ((IWineD3DPixelShaderImpl *)stateblock->pixelShader)->baseShader.function;
3475     BOOL transformed;
3476     /* Some stuff is in the device until we have per context tracking */
3477     IWineD3DDeviceImpl *device = stateblock->wineD3DDevice;
3478     BOOL wasrhw = context->last_was_rhw;
3479
3480     /* Shaders can be implemented using ARB_PROGRAM, GLSL, or software -
3481      * here simply check whether a shader was set, or the user disabled shaders
3482      */
3483     if (use_vs(device)) {
3484         useVertexShaderFunction = TRUE;
3485
3486         if(((IWineD3DVertexShaderImpl *)stateblock->vertexShader)->baseShader.reg_maps.fog != context->last_was_foggy_shader) {
3487             updateFog = TRUE;
3488         }
3489     } else if(context->last_was_foggy_shader) {
3490         updateFog = TRUE;
3491     }
3492
3493     transformed = device->strided_streams.u.s.position_transformed;
3494     if (transformed) useVertexShaderFunction = FALSE;
3495
3496     if(transformed != context->last_was_rhw && !useVertexShaderFunction) {
3497         updateFog = TRUE;
3498     }
3499
3500     /* Reapply lighting if it is not scheduled for reapplication already */
3501     if(!isStateDirty(context, STATE_RENDER(WINED3DRS_LIGHTING))) {
3502         state_lighting(STATE_RENDER(WINED3DRS_LIGHTING), stateblock, context);
3503     }
3504
3505     if (transformed) {
3506         context->last_was_rhw = TRUE;
3507     } else {
3508
3509         /* Untransformed, so relies on the view and projection matrices */
3510         context->last_was_rhw = FALSE;
3511         /* This turns off the Z scale trick to 'disable' viewport frustum clipping in rhw mode*/
3512         device->untransformed = TRUE;
3513
3514         /* Todo for sw shaders: Vertex Shader output is already transformed, so set up identity matrices
3515          * Not needed as long as only hw shaders are supported
3516          */
3517
3518         /* This sets the shader output position correction constants.
3519          * TODO: Move to the viewport state
3520          */
3521         if (useVertexShaderFunction) {
3522             device->posFixup[1] = device->render_offscreen ? -1.0 : 1.0;
3523             device->posFixup[3] = -device->posFixup[1] / stateblock->viewport.Height;
3524         }
3525     }
3526
3527     /* Don't have to apply the matrices when vertex shaders are used. When vshaders are turned
3528      * off this function will be called again anyway to make sure they're properly set
3529      */
3530     if(!useVertexShaderFunction) {
3531         /* TODO: Move this mainly to the viewport state and only apply when the vp has changed
3532          * or transformed / untransformed was switched
3533          */
3534        if(wasrhw != context->last_was_rhw &&
3535           !isStateDirty(context, STATE_TRANSFORM(WINED3DTS_PROJECTION)) &&
3536           !isStateDirty(context, STATE_VIEWPORT)) {
3537             transform_projection(STATE_TRANSFORM(WINED3DTS_PROJECTION), stateblock, context);
3538         }
3539         /* World matrix needs reapplication here only if we're switching between rhw and non-rhw
3540          * mode.
3541          *
3542          * If a vertex shader is used, the world matrix changed and then vertex shader unbound
3543          * this check will fail and the matrix not applied again. This is OK because a simple
3544          * world matrix change reapplies the matrix - These checks here are only to satisfy the
3545          * needs of the vertex declaration.
3546          *
3547          * World and view matrix go into the same gl matrix, so only apply them when neither is
3548          * dirty
3549          */
3550         if(transformed != wasrhw &&
3551            !isStateDirty(context, STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(0))) &&
3552            !isStateDirty(context, STATE_TRANSFORM(WINED3DTS_VIEW))) {
3553             transform_world(STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(0)), stateblock, context);
3554         }
3555
3556         if(!isStateDirty(context, STATE_RENDER(WINED3DRS_COLORVERTEX))) {
3557             state_colormat(STATE_RENDER(WINED3DRS_COLORVERTEX), stateblock, context);
3558         }
3559
3560         if(context->last_was_vshader && !isStateDirty(context, STATE_RENDER(WINED3DRS_CLIPPLANEENABLE))) {
3561             state_clipping(STATE_RENDER(WINED3DRS_CLIPPLANEENABLE), stateblock, context);
3562         }
3563         if(!isStateDirty(context, STATE_RENDER(WINED3DRS_NORMALIZENORMALS))) {
3564             state_normalize(STATE_RENDER(WINED3DRS_NORMALIZENORMALS), stateblock, context);
3565         }
3566     } else {
3567         /* We compile the shader here because we need the vertex declaration
3568          * in order to determine if we need to do any swizzling for D3DCOLOR
3569          * registers. If the shader is already compiled this call will do nothing. */
3570         IWineD3DVertexShader_CompileShader(stateblock->vertexShader);
3571
3572         if(!context->last_was_vshader) {
3573             int i;
3574             static BOOL warned = FALSE;
3575             /* Disable all clip planes to get defined results on all drivers. See comment in the
3576              * state_clipping state handler
3577              */
3578             for(i = 0; i < GL_LIMITS(clipplanes); i++) {
3579                 glDisable(GL_CLIP_PLANE0 + i);
3580                 checkGLcall("glDisable(GL_CLIP_PLANE0 + i)");
3581             }
3582
3583             if(!warned && stateblock->renderState[WINED3DRS_CLIPPLANEENABLE]) {
3584                 FIXME("Clipping not supported with vertex shaders\n");
3585                 warned = TRUE;
3586             }
3587             if(wasrhw) {
3588                 /* Apply the transform matrices when switching from rhw drawing to vertex shaders. Vertex
3589                  * shaders themselves do not need it, but the matrices are not reapplied automatically when
3590                  * switching back from vertex shaders to fixed function processing. So make sure we leave the
3591                  * fixed function vertex processing states back in a sane state before switching to shaders
3592                  */
3593                 if(!isStateDirty(context, STATE_TRANSFORM(WINED3DTS_PROJECTION))) {
3594                     transform_projection(STATE_TRANSFORM(WINED3DTS_PROJECTION), stateblock, context);
3595                 }
3596                 if(!isStateDirty(context, STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(0)))) {
3597                     transform_world(STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(0)), stateblock, context);
3598                 }
3599             }
3600         }
3601     }
3602
3603     /* Vertex and pixel shaders are applied together for now, so let the last dirty state do the
3604      * application
3605      */
3606     if (!isStateDirty(context, STATE_PIXELSHADER)) {
3607         device->shader_backend->shader_select((IWineD3DDevice *)device, usePixelShaderFunction, useVertexShaderFunction);
3608
3609         if (!isStateDirty(context, STATE_VERTEXSHADERCONSTANT) && (useVertexShaderFunction || usePixelShaderFunction)) {
3610             shaderconstant(STATE_VERTEXSHADERCONSTANT, stateblock, context);
3611         }
3612     }
3613
3614     context->last_was_vshader = useVertexShaderFunction;
3615
3616     if(updateFog) {
3617         state_fog(STATE_RENDER(WINED3DRS_FOGENABLE), stateblock, context);
3618     }
3619     if(!useVertexShaderFunction) {
3620         int i;
3621         for(i = 0; i < MAX_TEXTURES; i++) {
3622             if(!isStateDirty(context, STATE_TRANSFORM(WINED3DTS_TEXTURE0 + i))) {
3623                 transform_texture(STATE_TRANSFORM(WINED3DTS_TEXTURE0 + i), stateblock, context);
3624             }
3625         }
3626     }
3627 }
3628
3629 static void viewport_miscpart(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
3630     UINT width, height;
3631     IWineD3DSurfaceImpl *target;
3632
3633     glDepthRange(stateblock->viewport.MinZ, stateblock->viewport.MaxZ);
3634     checkGLcall("glDepthRange");
3635     /* Note: GL requires lower left, DirectX supplies upper left. This is reversed when using offscreen rendering
3636      */
3637     if(stateblock->wineD3DDevice->render_offscreen) {
3638         glViewport(stateblock->viewport.X,
3639                    stateblock->viewport.Y,
3640                    stateblock->viewport.Width, stateblock->viewport.Height);
3641     } else {
3642         target = (IWineD3DSurfaceImpl *) stateblock->wineD3DDevice->render_targets[0];
3643         target->get_drawable_size(target, &width, &height);
3644
3645         glViewport(stateblock->viewport.X,
3646                    (height - (stateblock->viewport.Y + stateblock->viewport.Height)),
3647                    stateblock->viewport.Width, stateblock->viewport.Height);
3648     }
3649
3650     checkGLcall("glViewport");
3651 }
3652
3653 static void viewport_vertexpart(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
3654     stateblock->wineD3DDevice->posFixup[2] = 1.0 / stateblock->viewport.Width;
3655     stateblock->wineD3DDevice->posFixup[3] = -stateblock->wineD3DDevice->posFixup[1] / stateblock->viewport.Height;
3656     if(!isStateDirty(context, STATE_TRANSFORM(WINED3DTS_PROJECTION))) {
3657         transform_projection(STATE_TRANSFORM(WINED3DTS_PROJECTION), stateblock, context);
3658     }
3659     if(!isStateDirty(context, STATE_RENDER(WINED3DRS_POINTSCALEENABLE))) {
3660         state_pscale(STATE_RENDER(WINED3DRS_POINTSCALEENABLE), stateblock, context);
3661     }
3662 }
3663
3664 static void light(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
3665     UINT Index = state - STATE_ACTIVELIGHT(0);
3666     PLIGHTINFOEL *lightInfo = stateblock->activeLights[Index];
3667
3668     if(!lightInfo) {
3669         glDisable(GL_LIGHT0 + Index);
3670         checkGLcall("glDisable(GL_LIGHT0 + Index)");
3671     } else {
3672         float quad_att;
3673         float colRGBA[] = {0.0, 0.0, 0.0, 0.0};
3674
3675         /* Light settings are affected by the model view in OpenGL, the View transform in direct3d*/
3676         glMatrixMode(GL_MODELVIEW);
3677         glPushMatrix();
3678         glLoadMatrixf(&stateblock->transforms[WINED3DTS_VIEW].u.m[0][0]);
3679
3680         /* Diffuse: */
3681         colRGBA[0] = lightInfo->OriginalParms.Diffuse.r;
3682         colRGBA[1] = lightInfo->OriginalParms.Diffuse.g;
3683         colRGBA[2] = lightInfo->OriginalParms.Diffuse.b;
3684         colRGBA[3] = lightInfo->OriginalParms.Diffuse.a;
3685         glLightfv(GL_LIGHT0 + Index, GL_DIFFUSE, colRGBA);
3686         checkGLcall("glLightfv");
3687
3688         /* Specular */
3689         colRGBA[0] = lightInfo->OriginalParms.Specular.r;
3690         colRGBA[1] = lightInfo->OriginalParms.Specular.g;
3691         colRGBA[2] = lightInfo->OriginalParms.Specular.b;
3692         colRGBA[3] = lightInfo->OriginalParms.Specular.a;
3693         glLightfv(GL_LIGHT0 + Index, GL_SPECULAR, colRGBA);
3694         checkGLcall("glLightfv");
3695
3696         /* Ambient */
3697         colRGBA[0] = lightInfo->OriginalParms.Ambient.r;
3698         colRGBA[1] = lightInfo->OriginalParms.Ambient.g;
3699         colRGBA[2] = lightInfo->OriginalParms.Ambient.b;
3700         colRGBA[3] = lightInfo->OriginalParms.Ambient.a;
3701         glLightfv(GL_LIGHT0 + Index, GL_AMBIENT, colRGBA);
3702         checkGLcall("glLightfv");
3703
3704         if ((lightInfo->OriginalParms.Range *lightInfo->OriginalParms.Range) >= FLT_MIN) {
3705             quad_att = 1.4/(lightInfo->OriginalParms.Range *lightInfo->OriginalParms.Range);
3706         } else {
3707             quad_att = 0; /*  0 or  MAX?  (0 seems to be ok) */
3708         }
3709
3710         /* Do not assign attenuation values for lights that do not use them. D3D apps are free to pass any junk,
3711          * but gl drivers use them and may crash due to bad Attenuation values. Need for Speed most wanted sets
3712          * Attenuation0 to NaN and crashes in the gl lib
3713          */
3714
3715         switch (lightInfo->OriginalParms.Type) {
3716             case WINED3DLIGHT_POINT:
3717                 /* Position */
3718                 glLightfv(GL_LIGHT0 + Index, GL_POSITION, &lightInfo->lightPosn[0]);
3719                 checkGLcall("glLightfv");
3720                 glLightf(GL_LIGHT0 + Index, GL_SPOT_CUTOFF, lightInfo->cutoff);
3721                 checkGLcall("glLightf");
3722                 /* Attenuation - Are these right? guessing... */
3723                 glLightf(GL_LIGHT0 + Index, GL_CONSTANT_ATTENUATION,  lightInfo->OriginalParms.Attenuation0);
3724                 checkGLcall("glLightf");
3725                 glLightf(GL_LIGHT0 + Index, GL_LINEAR_ATTENUATION,    lightInfo->OriginalParms.Attenuation1);
3726                 checkGLcall("glLightf");
3727                 if (quad_att < lightInfo->OriginalParms.Attenuation2) quad_att = lightInfo->OriginalParms.Attenuation2;
3728                 glLightf(GL_LIGHT0 + Index, GL_QUADRATIC_ATTENUATION, quad_att);
3729                 checkGLcall("glLightf");
3730                 /* FIXME: Range */
3731                 break;
3732
3733             case WINED3DLIGHT_SPOT:
3734                 /* Position */
3735                 glLightfv(GL_LIGHT0 + Index, GL_POSITION, &lightInfo->lightPosn[0]);
3736                 checkGLcall("glLightfv");
3737                 /* Direction */
3738                 glLightfv(GL_LIGHT0 + Index, GL_SPOT_DIRECTION, &lightInfo->lightDirn[0]);
3739                 checkGLcall("glLightfv");
3740                 glLightf(GL_LIGHT0 + Index, GL_SPOT_EXPONENT, lightInfo->exponent);
3741                 checkGLcall("glLightf");
3742                 glLightf(GL_LIGHT0 + Index, GL_SPOT_CUTOFF, lightInfo->cutoff);
3743                 checkGLcall("glLightf");
3744                 /* Attenuation - Are these right? guessing... */
3745                 glLightf(GL_LIGHT0 + Index, GL_CONSTANT_ATTENUATION,  lightInfo->OriginalParms.Attenuation0);
3746                 checkGLcall("glLightf");
3747                 glLightf(GL_LIGHT0 + Index, GL_LINEAR_ATTENUATION,    lightInfo->OriginalParms.Attenuation1);
3748                 checkGLcall("glLightf");
3749                 if (quad_att < lightInfo->OriginalParms.Attenuation2) quad_att = lightInfo->OriginalParms.Attenuation2;
3750                 glLightf(GL_LIGHT0 + Index, GL_QUADRATIC_ATTENUATION, quad_att);
3751                 checkGLcall("glLightf");
3752                 /* FIXME: Range */
3753                 break;
3754
3755             case WINED3DLIGHT_DIRECTIONAL:
3756                 /* Direction */
3757                 glLightfv(GL_LIGHT0 + Index, GL_POSITION, &lightInfo->lightPosn[0]); /* Note gl uses w position of 0 for direction! */
3758                 checkGLcall("glLightfv");
3759                 glLightf(GL_LIGHT0 + Index, GL_SPOT_CUTOFF, lightInfo->cutoff);
3760                 checkGLcall("glLightf");
3761                 glLightf(GL_LIGHT0 + Index, GL_SPOT_EXPONENT, 0.0f);
3762                 checkGLcall("glLightf");
3763                 break;
3764
3765             default:
3766                 FIXME("Unrecognized light type %d\n", lightInfo->OriginalParms.Type);
3767         }
3768
3769         /* Restore the modelview matrix */
3770         glPopMatrix();
3771
3772         glEnable(GL_LIGHT0 + Index);
3773         checkGLcall("glEnable(GL_LIGHT0 + Index)");
3774     }
3775
3776     return;
3777 }
3778
3779 static void scissorrect(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
3780     RECT *pRect = &stateblock->scissorRect;
3781     UINT height;
3782     UINT width;
3783     IWineD3DSurfaceImpl *target = (IWineD3DSurfaceImpl *) stateblock->wineD3DDevice->render_targets[0];
3784
3785     target->get_drawable_size(target, &width, &height);
3786     /* Warning: glScissor uses window coordinates, not viewport coordinates, so our viewport correction does not apply
3787      * Warning2: Even in windowed mode the coords are relative to the window, not the screen
3788      */
3789     TRACE("(%p) Setting new Scissor Rect to %d:%d-%d:%d\n", stateblock->wineD3DDevice, pRect->left, pRect->bottom - height,
3790           pRect->right - pRect->left, pRect->bottom - pRect->top);
3791
3792     if (stateblock->wineD3DDevice->render_offscreen) {
3793         glScissor(pRect->left, pRect->top, pRect->right - pRect->left, pRect->bottom - pRect->top);
3794     } else {
3795         glScissor(pRect->left, height - pRect->bottom, pRect->right - pRect->left, pRect->bottom - pRect->top);
3796     }
3797     checkGLcall("glScissor");
3798 }
3799
3800 static void indexbuffer(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
3801     if(GL_SUPPORT(ARB_VERTEX_BUFFER_OBJECT)) {
3802         if(stateblock->streamIsUP || stateblock->pIndexData == NULL ) {
3803             GL_EXTCALL(glBindBufferARB(GL_ELEMENT_ARRAY_BUFFER_ARB, 0));
3804         } else {
3805             IWineD3DIndexBufferImpl *ib = (IWineD3DIndexBufferImpl *) stateblock->pIndexData;
3806             GL_EXTCALL(glBindBufferARB(GL_ELEMENT_ARRAY_BUFFER_ARB, ib->vbo));
3807         }
3808     }
3809 }
3810
3811 static void frontface(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
3812     if(stateblock->wineD3DDevice->render_offscreen) {
3813         glFrontFace(GL_CCW);
3814         checkGLcall("glFrontFace(GL_CCW)");
3815     } else {
3816         glFrontFace(GL_CW);
3817         checkGLcall("glFrontFace(GL_CW)");
3818     }
3819 }
3820
3821 const struct StateEntry FFPStateTable[] =
3822 {
3823       /* State name                                         representative,                                     apply function */
3824     { /* 0,  Undefined                              */      0,                                                  state_undefined     },
3825     { /* 1,  WINED3DRS_TEXTUREHANDLE                */      0 /* Handled in ddraw */,                           state_undefined     },
3826     { /* 2,  WINED3DRS_ANTIALIAS                    */      STATE_RENDER(WINED3DRS_ANTIALIAS),                  NULL                },
3827     { /* 3,  WINED3DRS_TEXTUREADDRESS               */      0 /* Handled in ddraw */,                           state_undefined     },
3828     { /* 4,  WINED3DRS_TEXTUREPERSPECTIVE           */      STATE_RENDER(WINED3DRS_TEXTUREPERSPECTIVE),         NULL                },
3829     { /* 5,  WINED3DRS_WRAPU                        */      STATE_RENDER(WINED3DRS_WRAPU),                      NULL                },
3830     { /* 6,  WINED3DRS_WRAPV                        */      STATE_RENDER(WINED3DRS_WRAPV),                      NULL                },
3831     { /* 7,  WINED3DRS_ZENABLE                      */      STATE_RENDER(WINED3DRS_ZENABLE),                    NULL                },
3832     { /* 8,  WINED3DRS_FILLMODE                     */      STATE_RENDER(WINED3DRS_FILLMODE),                   NULL                },
3833     { /* 9,  WINED3DRS_SHADEMODE                    */      STATE_RENDER(WINED3DRS_SHADEMODE),                  NULL                },
3834     { /* 10, WINED3DRS_LINEPATTERN                  */      STATE_RENDER(WINED3DRS_LINEPATTERN),                NULL                },
3835     { /* 11, WINED3DRS_MONOENABLE                   */      STATE_RENDER(WINED3DRS_MONOENABLE),                 NULL                },
3836     { /* 12, WINED3DRS_ROP2                         */      STATE_RENDER(WINED3DRS_ROP2),                       NULL                },
3837     { /* 13, WINED3DRS_PLANEMASK                    */      STATE_RENDER(WINED3DRS_PLANEMASK),                  NULL                },
3838     { /* 14, WINED3DRS_ZWRITEENABLE                 */      STATE_RENDER(WINED3DRS_ZWRITEENABLE),               NULL                },
3839     { /* 15, WINED3DRS_ALPHATESTENABLE              */      STATE_RENDER(WINED3DRS_ALPHATESTENABLE),            NULL                },
3840     { /* 16, WINED3DRS_LASTPIXEL                    */      STATE_RENDER(WINED3DRS_LASTPIXEL),                  NULL                },
3841     { /* 17, WINED3DRS_TEXTUREMAG                   */      0 /* Handled in ddraw */,                           state_undefined     },
3842     { /* 18, WINED3DRS_TEXTUREMIN                   */      0 /* Handled in ddraw */,                           state_undefined     },
3843     { /* 19, WINED3DRS_SRCBLEND                     */      STATE_RENDER(WINED3DRS_ALPHABLENDENABLE),           NULL                },
3844     { /* 20, WINED3DRS_DESTBLEND                    */      STATE_RENDER(WINED3DRS_ALPHABLENDENABLE),           NULL                },
3845     { /* 21, WINED3DRS_TEXTUREMAPBLEND              */      0 /* Handled in ddraw */,                           state_undefined     },
3846     { /* 22, WINED3DRS_CULLMODE                     */      STATE_RENDER(WINED3DRS_CULLMODE),                   NULL                },
3847     { /* 23, WINED3DRS_ZFUNC                        */      STATE_RENDER(WINED3DRS_ZFUNC),                      NULL                },
3848     { /* 24, WINED3DRS_ALPHAREF                     */      STATE_RENDER(WINED3DRS_ALPHATESTENABLE),            NULL                },
3849     { /* 25, WINED3DRS_ALPHAFUNC                    */      STATE_RENDER(WINED3DRS_ALPHATESTENABLE),            NULL                },
3850     { /* 26, WINED3DRS_DITHERENABLE                 */      STATE_RENDER(WINED3DRS_DITHERENABLE),               NULL                },
3851     { /* 27, WINED3DRS_ALPHABLENDENABLE             */      STATE_RENDER(WINED3DRS_ALPHABLENDENABLE),           NULL                },
3852     { /* 28, WINED3DRS_FOGENABLE                    */      STATE_RENDER(WINED3DRS_FOGENABLE),                  NULL                },
3853     { /* 29, WINED3DRS_SPECULARENABLE               */      STATE_RENDER(WINED3DRS_SPECULARENABLE),             NULL                },
3854     { /* 30, WINED3DRS_ZVISIBLE                     */      0 /* Not supported according to the msdn */,        state_nogl          },
3855     { /* 31, WINED3DRS_SUBPIXEL                     */      STATE_RENDER(WINED3DRS_SUBPIXEL),                   NULL                },
3856     { /* 32, WINED3DRS_SUBPIXELX                    */      STATE_RENDER(WINED3DRS_SUBPIXELX),                  NULL                },
3857     { /* 33, WINED3DRS_STIPPLEDALPHA                */      STATE_RENDER(WINED3DRS_STIPPLEDALPHA),              NULL                },
3858     { /* 34, WINED3DRS_FOGCOLOR                     */      STATE_RENDER(WINED3DRS_FOGCOLOR),                   NULL                },
3859     { /* 35, WINED3DRS_FOGTABLEMODE                 */      STATE_RENDER(WINED3DRS_FOGENABLE),                  NULL                },
3860     { /* 36, WINED3DRS_FOGSTART                     */      STATE_RENDER(WINED3DRS_FOGENABLE),                  NULL                },
3861     { /* 37, WINED3DRS_FOGEND                       */      STATE_RENDER(WINED3DRS_FOGENABLE),                  NULL                },
3862     { /* 38, WINED3DRS_FOGDENSITY                   */      STATE_RENDER(WINED3DRS_FOGDENSITY),                 NULL                },
3863     { /* 39, WINED3DRS_STIPPLEENABLE                */      STATE_RENDER(WINED3DRS_STIPPLEENABLE),              NULL                },
3864     { /* 40, WINED3DRS_EDGEANTIALIAS                */      STATE_RENDER(WINED3DRS_ALPHABLENDENABLE),           NULL                },
3865     { /* 41, WINED3DRS_COLORKEYENABLE               */      STATE_RENDER(WINED3DRS_ALPHATESTENABLE),            NULL                },
3866     { /* 42, undefined                              */      0,                                                  state_undefined     },
3867     { /* 43, WINED3DRS_BORDERCOLOR                  */      STATE_RENDER(WINED3DRS_BORDERCOLOR),                NULL                },
3868     { /* 44, WINED3DRS_TEXTUREADDRESSU              */      0, /* Handled in ddraw */                           state_undefined     },
3869     { /* 45, WINED3DRS_TEXTUREADDRESSV              */      0, /* Handled in ddraw */                           state_undefined     },
3870     { /* 46, WINED3DRS_MIPMAPLODBIAS                */      STATE_RENDER(WINED3DRS_MIPMAPLODBIAS),              NULL                },
3871     { /* 47, WINED3DRS_ZBIAS                        */      STATE_RENDER(WINED3DRS_ZBIAS),                      NULL                },
3872     { /* 48, WINED3DRS_RANGEFOGENABLE               */      STATE_RENDER(WINED3DRS_RANGEFOGENABLE),             NULL                },
3873     { /* 49, WINED3DRS_ANISOTROPY                   */      STATE_RENDER(WINED3DRS_ANISOTROPY),                 NULL                },
3874     { /* 50, WINED3DRS_FLUSHBATCH                   */      STATE_RENDER(WINED3DRS_FLUSHBATCH),                 NULL                },
3875     { /* 51, WINED3DRS_TRANSLUCENTSORTINDEPENDENT   */      STATE_RENDER(WINED3DRS_TRANSLUCENTSORTINDEPENDENT), NULL                },
3876     { /* 52, WINED3DRS_STENCILENABLE                */      STATE_RENDER(WINED3DRS_STENCILENABLE),              NULL                },
3877     { /* 53, WINED3DRS_STENCILFAIL                  */      STATE_RENDER(WINED3DRS_STENCILENABLE),              NULL                },
3878     { /* 54, WINED3DRS_STENCILZFAIL                 */      STATE_RENDER(WINED3DRS_STENCILENABLE),              NULL                },
3879     { /* 55, WINED3DRS_STENCILPASS                  */      STATE_RENDER(WINED3DRS_STENCILENABLE),              NULL                },
3880     { /* 56, WINED3DRS_STENCILFUNC                  */      STATE_RENDER(WINED3DRS_STENCILENABLE),              NULL                },
3881     { /* 57, WINED3DRS_STENCILREF                   */      STATE_RENDER(WINED3DRS_STENCILENABLE),              NULL                },
3882     { /* 58, WINED3DRS_STENCILMASK                  */      STATE_RENDER(WINED3DRS_STENCILENABLE),              NULL                },
3883     { /* 59, WINED3DRS_STENCILWRITEMASK             */      STATE_RENDER(WINED3DRS_STENCILWRITEMASK),           NULL                },
3884     { /* 60, WINED3DRS_TEXTUREFACTOR                */      STATE_RENDER(WINED3DRS_TEXTUREFACTOR),              NULL                },
3885     { /* 61, Undefined                              */      0,                                                  state_undefined     },
3886     { /* 62, Undefined                              */      0,                                                  state_undefined     },
3887     { /* 63, Undefined                              */      0,                                                  state_undefined     },
3888     { /* 64, WINED3DRS_STIPPLEPATTERN00             */      0 /* Obsolete, should be handled by ddraw */,       state_undefined     },
3889     { /* 65, WINED3DRS_STIPPLEPATTERN01             */      0 /* Obsolete, should he handled by ddraw */,       state_undefined     },
3890     { /* 66, WINED3DRS_STIPPLEPATTERN02             */      0 /* Obsolete, should be handled by ddraw */,       state_undefined     },
3891     { /* 67, WINED3DRS_STIPPLEPATTERN03             */      0 /* Obsolete, should be handled by ddraw */,       state_undefined     },
3892     { /* 68, WINED3DRS_STIPPLEPATTERN04             */      0 /* Obsolete, should be handled by ddraw */,       state_undefined     },
3893     { /* 69, WINED3DRS_STIPPLEPATTERN05             */      0 /* Obsolete, should be handled by ddraw */,       state_undefined     },
3894     { /* 70, WINED3DRS_STIPPLEPATTERN06             */      0 /* Obsolete, should be handled by ddraw */,       state_undefined     },
3895     { /* 71, WINED3DRS_STIPPLEPATTERN07             */      0 /* Obsolete, should be handled by ddraw */,       state_undefined     },
3896     { /* 72, WINED3DRS_STIPPLEPATTERN08             */      0 /* Obsolete, should be handled by ddraw */,       state_undefined     },
3897     { /* 73, WINED3DRS_STIPPLEPATTERN09             */      0 /* Obsolete, should be handled by ddraw */,       state_undefined     },
3898     { /* 74, WINED3DRS_STIPPLEPATTERN10             */      0 /* Obsolete, should be handled by ddraw */,       state_undefined     },
3899     { /* 75, WINED3DRS_STIPPLEPATTERN11             */      0 /* Obsolete, should be handled by ddraw */,       state_undefined     },
3900     { /* 76, WINED3DRS_STIPPLEPATTERN12             */      0 /* Obsolete, should be handled by ddraw */,       state_undefined     },
3901     { /* 77, WINED3DRS_STIPPLEPATTERN13             */      0 /* Obsolete, should be handled by ddraw */,       state_undefined     },
3902     { /* 78, WINED3DRS_STIPPLEPATTERN14             */      0 /* Obsolete, should be handled by ddraw */,       state_undefined     },
3903     { /* 79, WINED3DRS_STIPPLEPATTERN15             */      0 /* Obsolete, should be handled by ddraw */,       state_undefined     },
3904     { /* 80, WINED3DRS_STIPPLEPATTERN16             */      0 /* Obsolete, should be handled by ddraw */,       state_undefined     },
3905     { /* 81, WINED3DRS_STIPPLEPATTERN17             */      0 /* Obsolete, should be handled by ddraw */,       state_undefined     },
3906     { /* 82, WINED3DRS_STIPPLEPATTERN18             */      0 /* Obsolete, should be handled by ddraw */,       state_undefined     },
3907     { /* 83, WINED3DRS_STIPPLEPATTERN19             */      0 /* Obsolete, should be handled by ddraw */,       state_undefined     },
3908     { /* 84, WINED3DRS_STIPPLEPATTERN20             */      0 /* Obsolete, should be handled by ddraw */,       state_undefined     },
3909     { /* 85, WINED3DRS_STIPPLEPATTERN21             */      0 /* Obsolete, should be handled by ddraw */,       state_undefined     },
3910     { /* 86, WINED3DRS_STIPPLEPATTERN22             */      0 /* Obsolete, should be handled by ddraw */,       state_undefined     },
3911     { /* 87, WINED3DRS_STIPPLEPATTERN23             */      0 /* Obsolete, should be handled by ddraw */,       state_undefined     },
3912     { /* 88, WINED3DRS_STIPPLEPATTERN24             */      0 /* Obsolete, should be handled by ddraw */,       state_undefined     },
3913     { /* 89, WINED3DRS_STIPPLEPATTERN25             */      0 /* Obsolete, should be handled by ddraw */,       state_undefined     },
3914     { /* 90, WINED3DRS_STIPPLEPATTERN26             */      0 /* Obsolete, should be handled by ddraw */,       state_undefined     },
3915     { /* 91, WINED3DRS_STIPPLEPATTERN27             */      0 /* Obsolete, should be handled by ddraw */,       state_undefined     },
3916     { /* 92, WINED3DRS_STIPPLEPATTERN28             */      0 /* Obsolete, should be handled by ddraw */,       state_undefined     },
3917     { /* 93, WINED3DRS_STIPPLEPATTERN29             */      0 /* Obsolete, should be handled by ddraw */,       state_undefined     },
3918     { /* 94, WINED3DRS_STIPPLEPATTERN30             */      0 /* Obsolete, should be handled by ddraw */,       state_undefined     },
3919     { /* 95, WINED3DRS_STIPPLEPATTERN31             */      0 /* Obsolete, should be handled by ddraw */,       state_undefined     },
3920     { /* 96, Undefined                              */      0,                                                  state_undefined     },
3921     { /* 97, Undefined                              */      0,                                                  state_undefined     },
3922     { /* 98, Undefined                              */      0,                                                  state_undefined     },
3923     { /* 99, Undefined                              */      0,                                                  state_undefined     },
3924     { /*100, Undefined                              */      0,                                                  state_undefined     },
3925     { /*101, Undefined                              */      0,                                                  state_undefined     },
3926     { /*102, Undefined                              */      0,                                                  state_undefined     },
3927     { /*103, Undefined                              */      0,                                                  state_undefined     },
3928     { /*104, Undefined                              */      0,                                                  state_undefined     },
3929     { /*105, Undefined                              */      0,                                                  state_undefined     },
3930     { /*106, Undefined                              */      0,                                                  state_undefined     },
3931     { /*107, Undefined                              */      0,                                                  state_undefined     },
3932     { /*108, Undefined                              */      0,                                                  state_undefined     },
3933     { /*109, Undefined                              */      0,                                                  state_undefined     },
3934     { /*110, Undefined                              */      0,                                                  state_undefined     },
3935     { /*111, Undefined                              */      0,                                                  state_undefined     },
3936     { /*112, Undefined                              */      0,                                                  state_undefined     },
3937     { /*113, Undefined                              */      0,                                                  state_undefined     },
3938     { /*114, Undefined                              */      0,                                                  state_undefined     },
3939     { /*115, Undefined                              */      0,                                                  state_undefined     },
3940     { /*116, Undefined                              */      0,                                                  state_undefined     },
3941     { /*117, Undefined                              */      0,                                                  state_undefined     },
3942     { /*118, Undefined                              */      0,                                                  state_undefined     },
3943     { /*119, Undefined                              */      0,                                                  state_undefined     },
3944     { /*120, Undefined                              */      0,                                                  state_undefined     },
3945     { /*121, Undefined                              */      0,                                                  state_undefined     },
3946     { /*122, Undefined                              */      0,                                                  state_undefined     },
3947     { /*123, Undefined                              */      0,                                                  state_undefined     },
3948     { /*124, Undefined                              */      0,                                                  state_undefined     },
3949     { /*125, Undefined                              */      0,                                                  state_undefined     },
3950     { /*126, Undefined                              */      0,                                                  state_undefined     },
3951     { /*127, Undefined                              */      0,                                                  state_undefined     },
3952     /* Big hole ends */
3953     { /*128, WINED3DRS_WRAP0                        */      STATE_RENDER(WINED3DRS_WRAP0),                      state_wrap          },
3954     { /*129, WINED3DRS_WRAP1                        */      STATE_RENDER(WINED3DRS_WRAP0),                      state_wrap          },
3955     { /*130, WINED3DRS_WRAP2                        */      STATE_RENDER(WINED3DRS_WRAP0),                      state_wrap          },
3956     { /*131, WINED3DRS_WRAP3                        */      STATE_RENDER(WINED3DRS_WRAP0),                      state_wrap          },
3957     { /*132, WINED3DRS_WRAP4                        */      STATE_RENDER(WINED3DRS_WRAP0),                      state_wrap          },
3958     { /*133, WINED3DRS_WRAP5                        */      STATE_RENDER(WINED3DRS_WRAP0),                      state_wrap          },
3959     { /*134, WINED3DRS_WRAP6                        */      STATE_RENDER(WINED3DRS_WRAP0),                      state_wrap          },
3960     { /*135, WINED3DRS_WRAP7                        */      STATE_RENDER(WINED3DRS_WRAP0),                      state_wrap          },
3961     { /*136, WINED3DRS_CLIPPING                     */      STATE_RENDER(WINED3DRS_CLIPPING),                   state_clipping      },
3962     { /*137, WINED3DRS_LIGHTING                     */      STATE_RENDER(WINED3DRS_LIGHTING),                   state_lighting      },
3963     { /*138, WINED3DRS_EXTENTS                      */      STATE_RENDER(WINED3DRS_EXTENTS),                    state_extents       },
3964     { /*139, WINED3DRS_AMBIENT                      */      STATE_RENDER(WINED3DRS_AMBIENT),                    state_ambient       },
3965     { /*140, WINED3DRS_FOGVERTEXMODE                */      STATE_RENDER(WINED3DRS_FOGENABLE),                  NULL                },
3966     { /*141, WINED3DRS_COLORVERTEX                  */      STATE_RENDER(WINED3DRS_COLORVERTEX),                state_colormat      },
3967     { /*142, WINED3DRS_LOCALVIEWER                  */      STATE_RENDER(WINED3DRS_LOCALVIEWER),                state_localviewer   },
3968     { /*143, WINED3DRS_NORMALIZENORMALS             */      STATE_RENDER(WINED3DRS_NORMALIZENORMALS),           state_normalize     },
3969     { /*144, WINED3DRS_COLORKEYBLENDENABLE          */      STATE_RENDER(WINED3DRS_COLORKEYBLENDENABLE),        state_ckeyblend     },
3970     { /*145, WINED3DRS_DIFFUSEMATERIALSOURCE        */      STATE_RENDER(WINED3DRS_COLORVERTEX),                state_colormat      },
3971     { /*146, WINED3DRS_SPECULARMATERIALSOURCE       */      STATE_RENDER(WINED3DRS_COLORVERTEX),                state_colormat      },
3972     { /*147, WINED3DRS_AMBIENTMATERIALSOURCE        */      STATE_RENDER(WINED3DRS_COLORVERTEX),                state_colormat      },
3973     { /*148, WINED3DRS_EMISSIVEMATERIALSOURCE       */      STATE_RENDER(WINED3DRS_COLORVERTEX),                state_colormat      },
3974     { /*149, Undefined                              */      0,                                                  state_undefined     },
3975     { /*150, Undefined                              */      0,                                                  state_undefined     },
3976     { /*151, WINED3DRS_VERTEXBLEND                  */      STATE_RENDER(WINED3DRS_VERTEXBLEND),                state_vertexblend   },
3977     { /*152, WINED3DRS_CLIPPLANEENABLE              */      STATE_RENDER(WINED3DRS_CLIPPING),                   state_clipping      },
3978     { /*153, WINED3DRS_SOFTWAREVERTEXPROCESSING     */      0,                                                  state_nogl          },
3979     { /*154, WINED3DRS_POINTSIZE                    */      STATE_RENDER(WINED3DRS_POINTSCALEENABLE),           state_pscale        },
3980     { /*155, WINED3DRS_POINTSIZE_MIN                */      STATE_RENDER(WINED3DRS_POINTSIZE_MIN),              state_psizemin      },
3981     { /*156, WINED3DRS_POINTSPRITEENABLE            */      STATE_RENDER(WINED3DRS_POINTSPRITEENABLE),          state_pointsprite   },
3982     { /*157, WINED3DRS_POINTSCALEENABLE             */      STATE_RENDER(WINED3DRS_POINTSCALEENABLE),           state_pscale        },
3983     { /*158, WINED3DRS_POINTSCALE_A                 */      STATE_RENDER(WINED3DRS_POINTSCALEENABLE),           state_pscale        },
3984     { /*159, WINED3DRS_POINTSCALE_B                 */      STATE_RENDER(WINED3DRS_POINTSCALEENABLE),           state_pscale        },
3985     { /*160, WINED3DRS_POINTSCALE_C                 */      STATE_RENDER(WINED3DRS_POINTSCALEENABLE),           state_pscale        },
3986     { /*161, WINED3DRS_MULTISAMPLEANTIALIAS         */      STATE_RENDER(WINED3DRS_MULTISAMPLEANTIALIAS),       state_multisampleaa },
3987     { /*162, WINED3DRS_MULTISAMPLEMASK              */      STATE_RENDER(WINED3DRS_MULTISAMPLEMASK),            state_multisampmask },
3988     { /*163, WINED3DRS_PATCHEDGESTYLE               */      STATE_RENDER(WINED3DRS_PATCHEDGESTYLE),             state_patchedgestyle},
3989     { /*164, WINED3DRS_PATCHSEGMENTS                */      STATE_RENDER(WINED3DRS_PATCHSEGMENTS),              state_patchsegments },
3990     { /*165, WINED3DRS_DEBUGMONITORTOKEN            */      STATE_RENDER(WINED3DRS_DEBUGMONITORTOKEN),          state_nogl          },
3991     { /*166, WINED3DRS_POINTSIZE_MAX                */      STATE_RENDER(WINED3DRS_POINTSIZE_MAX),              state_psizemax      },
3992     { /*167, WINED3DRS_INDEXEDVERTEXBLENDENABLE     */      0,                                                  state_nogl          },
3993     { /*168, WINED3DRS_COLORWRITEENABLE             */      STATE_RENDER(WINED3DRS_COLORWRITEENABLE),           state_colorwrite    },
3994     { /*169, Undefined                              */      0,                                                  state_undefined     },
3995     { /*170, WINED3DRS_TWEENFACTOR                  */      0,                                                  state_nogl          },
3996     { /*171, WINED3DRS_BLENDOP                      */      STATE_RENDER(WINED3DRS_BLENDOP),                    state_blendop       },
3997     { /*172, WINED3DRS_POSITIONDEGREE               */      STATE_RENDER(WINED3DRS_POSITIONDEGREE),             state_positiondegree},
3998     { /*173, WINED3DRS_NORMALDEGREE                 */      STATE_RENDER(WINED3DRS_NORMALDEGREE),               state_normaldegree  },
3999       /*172, WINED3DRS_POSITIONORDER                */      /* Value assigned to 2 state names */
4000       /*173, WINED3DRS_NORMALORDER                  */      /* Value assigned to 2 state names */
4001     { /*174, WINED3DRS_SCISSORTESTENABLE            */      STATE_RENDER(WINED3DRS_SCISSORTESTENABLE),          state_scissor       },
4002     { /*175, WINED3DRS_SLOPESCALEDEPTHBIAS          */      STATE_RENDER(WINED3DRS_DEPTHBIAS),                  state_depthbias     },
4003     { /*176, WINED3DRS_ANTIALIASEDLINEENABLE        */      STATE_RENDER(WINED3DRS_ALPHABLENDENABLE),           NULL                },
4004     { /*177, undefined                              */      0,                                                  state_undefined     },
4005     { /*178, WINED3DRS_MINTESSELLATIONLEVEL         */      STATE_RENDER(WINED3DRS_ENABLEADAPTIVETESSELLATION), state_tessellation  },
4006     { /*179, WINED3DRS_MAXTESSELLATIONLEVEL         */      STATE_RENDER(WINED3DRS_ENABLEADAPTIVETESSELLATION), state_tessellation  },
4007     { /*180, WINED3DRS_ADAPTIVETESS_X               */      STATE_RENDER(WINED3DRS_ENABLEADAPTIVETESSELLATION), state_tessellation  },
4008     { /*181, WINED3DRS_ADAPTIVETESS_Y               */      STATE_RENDER(WINED3DRS_ENABLEADAPTIVETESSELLATION), state_tessellation  },
4009     { /*182, WINED3DRS_ADAPTIVETESS_Z               */      STATE_RENDER(WINED3DRS_ENABLEADAPTIVETESSELLATION), state_tessellation  },
4010     { /*183, WINED3DRS_ADAPTIVETESS_W               */      STATE_RENDER(WINED3DRS_ENABLEADAPTIVETESSELLATION), state_tessellation  },
4011     { /*184, WINED3DRS_ENABLEADAPTIVETESSELLATION   */      STATE_RENDER(WINED3DRS_ENABLEADAPTIVETESSELLATION), state_tessellation  },
4012     { /*185, WINED3DRS_TWOSIDEDSTENCILMODE          */      STATE_RENDER(WINED3DRS_STENCILENABLE),              NULL                },
4013     { /*186, WINED3DRS_CCW_STENCILFAIL              */      STATE_RENDER(WINED3DRS_STENCILENABLE),              NULL                },
4014     { /*187, WINED3DRS_CCW_STENCILZFAIL             */      STATE_RENDER(WINED3DRS_STENCILENABLE),              NULL                },
4015     { /*188, WINED3DRS_CCW_STENCILPASS              */      STATE_RENDER(WINED3DRS_STENCILENABLE),              NULL                },
4016     { /*189, WINED3DRS_CCW_STENCILFUNC              */      STATE_RENDER(WINED3DRS_STENCILENABLE),              NULL                },
4017     { /*190, WINED3DRS_COLORWRITEENABLE1            */      STATE_RENDER(WINED3DRS_COLORWRITEENABLE),           state_colorwrite    },
4018     { /*191, WINED3DRS_COLORWRITEENABLE2            */      STATE_RENDER(WINED3DRS_COLORWRITEENABLE),           state_colorwrite    },
4019     { /*192, WINED3DRS_COLORWRITEENABLE3            */      STATE_RENDER(WINED3DRS_COLORWRITEENABLE),           state_colorwrite    },
4020     { /*193, WINED3DRS_BLENDFACTOR                  */      STATE_RENDER(WINED3DRS_BLENDFACTOR),                state_blendfactor   },
4021     { /*194, WINED3DRS_SRGBWRITEENABLE              */      STATE_PIXELSHADER,                                  pixelshader         },
4022     { /*195, WINED3DRS_DEPTHBIAS                    */      STATE_RENDER(WINED3DRS_DEPTHBIAS),                  state_depthbias     },
4023     { /*196, undefined                              */      0,                                                  state_undefined     },
4024     { /*197, undefined                              */      0,                                                  state_undefined     },
4025     { /*198, WINED3DRS_WRAP8                        */      STATE_RENDER(WINED3DRS_WRAP0),                      state_wrap          },
4026     { /*199, WINED3DRS_WRAP9                        */      STATE_RENDER(WINED3DRS_WRAP0),                      state_wrap          },
4027     { /*200, WINED3DRS_WRAP10                       */      STATE_RENDER(WINED3DRS_WRAP0),                      state_wrap          },
4028     { /*201, WINED3DRS_WRAP11                       */      STATE_RENDER(WINED3DRS_WRAP0),                      state_wrap          },
4029     { /*202, WINED3DRS_WRAP12                       */      STATE_RENDER(WINED3DRS_WRAP0),                      state_wrap          },
4030     { /*203, WINED3DRS_WRAP13                       */      STATE_RENDER(WINED3DRS_WRAP0),                      state_wrap          },
4031     { /*204, WINED3DRS_WRAP14                       */      STATE_RENDER(WINED3DRS_WRAP0),                      state_wrap          },
4032     { /*205, WINED3DRS_WRAP15                       */      STATE_RENDER(WINED3DRS_WRAP0),                      state_wrap          },
4033     { /*206, WINED3DRS_SEPARATEALPHABLENDENABLE     */      STATE_RENDER(WINED3DRS_ALPHABLENDENABLE),           NULL                },
4034     { /*207, WINED3DRS_SRCBLENDALPHA                */      STATE_RENDER(WINED3DRS_ALPHABLENDENABLE),           NULL                },
4035     { /*208, WINED3DRS_DESTBLENDALPHA               */      STATE_RENDER(WINED3DRS_ALPHABLENDENABLE),           NULL                },
4036     { /*209, WINED3DRS_BLENDOPALPHA                 */      STATE_RENDER(WINED3DRS_ALPHABLENDENABLE),           NULL                },
4037     /* Texture stage states */
4038     { /*0, 01, WINED3DTSS_COLOROP                   */      STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP),          NULL                },
4039     { /*0, 02, WINED3DTSS_COLORARG1                 */      STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP),          NULL                },
4040     { /*0, 03, WINED3DTSS_COLORARG2                 */      STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP),          NULL                },
4041     { /*0, 04, WINED3DTSS_ALPHAOP                   */      STATE_TEXTURESTAGE(0, WINED3DTSS_ALPHAOP),          NULL                },
4042     { /*0, 05, WINED3DTSS_ALPHAARG1                 */      STATE_TEXTURESTAGE(0, WINED3DTSS_ALPHAOP),          NULL                },
4043     { /*0, 06, WINED3DTSS_ALPHAARG2                 */      STATE_TEXTURESTAGE(0, WINED3DTSS_ALPHAOP),          NULL                },
4044     { /*0, 07, WINED3DTSS_BUMPENVMAT00              */      STATE_TEXTURESTAGE(0, WINED3DTSS_BUMPENVMAT00),     NULL                },
4045     { /*0, 08, WINED3DTSS_BUMPENVMAT01              */      STATE_TEXTURESTAGE(0, WINED3DTSS_BUMPENVMAT00),     NULL                },
4046     { /*0, 09, WINED3DTSS_BUMPENVMAT10              */      STATE_TEXTURESTAGE(0, WINED3DTSS_BUMPENVMAT00),     NULL                },
4047     { /*0, 10, WINED3DTSS_BUMPENVMAT11              */      STATE_TEXTURESTAGE(0, WINED3DTSS_BUMPENVMAT00),     NULL                },
4048     { /*0, 11, WINED3DTSS_TEXCOORDINDEX             */      STATE_TEXTURESTAGE(0, WINED3DTSS_TEXCOORDINDEX),    NULL                },
4049     { /*0, 12, WINED3DTSS_ADDRESS                   */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
4050     { /*0, 13, WINED3DTSS_ADDRESSU                  */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
4051     { /*0, 14, WINED3DTSS_ADDRESSV                  */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
4052     { /*0, 15, WINED3DTSS_BORDERCOLOR               */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
4053     { /*0, 16, WINED3DTSS_MAGFILTER                 */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
4054     { /*0, 17, WINED3DTSS_MINFILTER                 */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
4055     { /*0, 18, WINED3DTSS_MIPFILTER                 */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
4056     { /*0, 19, WINED3DTSS_MIPMAPLODBIAS             */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
4057     { /*0, 20, WINED3DTSS_MAXMIPLEVEL               */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
4058     { /*0, 21, WINED3DTSS_MAXANISOTROPY             */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
4059     { /*0, 22, WINED3DTSS_BUMPENVLSCALE             */      STATE_TEXTURESTAGE(0, WINED3DTSS_BUMPENVLSCALE),    NULL                },
4060     { /*0, 23, WINED3DTSS_BUMPENVLOFFSET            */      STATE_TEXTURESTAGE(0, WINED3DTSS_BUMPENVLOFFSET),   NULL                },
4061     { /*0, 24, WINED3DTSS_TEXTURETRANSFORMFLAGS     */      STATE_TRANSFORM(WINED3DTS_TEXTURE0),                NULL                },
4062     { /*0, 25, WINED3DTSS_ADDRESSW                  */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
4063     { /*0, 26, WINED3DTSS_COLORARG0                 */      STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP),          NULL                },
4064     { /*0, 27, WINED3DTSS_ALPHAARG0                 */      STATE_TEXTURESTAGE(0, WINED3DTSS_ALPHAOP),          NULL                },
4065     { /*0, 28, WINED3DTSS_RESULTARG                 */      STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP),          NULL                },
4066     { /*0, 29, undefined                            */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
4067     { /*0, 30, undefined                            */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
4068     { /*0, 31, undefined                            */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
4069     { /*0, 32, WINED3DTSS_CONSTANT                  */      0 /* As long as we don't support D3DTA_CONSTANT */, state_nogl          },
4070
4071     { /*1, 01, WINED3DTSS_COLOROP                   */      STATE_TEXTURESTAGE(1, WINED3DTSS_COLOROP),          NULL                },
4072     { /*1, 02, WINED3DTSS_COLORARG1                 */      STATE_TEXTURESTAGE(1, WINED3DTSS_COLOROP),          NULL                },
4073     { /*1, 03, WINED3DTSS_COLORARG2                 */      STATE_TEXTURESTAGE(1, WINED3DTSS_COLOROP),          NULL                },
4074     { /*1, 04, WINED3DTSS_ALPHAOP                   */      STATE_TEXTURESTAGE(1, WINED3DTSS_ALPHAOP),          NULL                },
4075     { /*1, 05, WINED3DTSS_ALPHAARG1                 */      STATE_TEXTURESTAGE(1, WINED3DTSS_ALPHAOP),          NULL                },
4076     { /*1, 06, WINED3DTSS_ALPHAARG2                 */      STATE_TEXTURESTAGE(1, WINED3DTSS_ALPHAOP),          NULL                },
4077     { /*1, 07, WINED3DTSS_BUMPENVMAT00              */      STATE_TEXTURESTAGE(1, WINED3DTSS_BUMPENVMAT00),     NULL                },
4078     { /*1, 08, WINED3DTSS_BUMPENVMAT01              */      STATE_TEXTURESTAGE(1, WINED3DTSS_BUMPENVMAT00),     NULL                },
4079     { /*1, 09, WINED3DTSS_BUMPENVMAT10              */      STATE_TEXTURESTAGE(1, WINED3DTSS_BUMPENVMAT00),     NULL                },
4080     { /*1, 10, WINED3DTSS_BUMPENVMAT11              */      STATE_TEXTURESTAGE(1, WINED3DTSS_BUMPENVMAT00),     NULL                },
4081     { /*1, 11, WINED3DTSS_TEXCOORDINDEX             */      STATE_TEXTURESTAGE(1, WINED3DTSS_TEXCOORDINDEX),    NULL                },
4082     { /*1, 12, WINED3DTSS_ADDRESS                   */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
4083     { /*1, 13, WINED3DTSS_ADDRESSU                  */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
4084     { /*1, 14, WINED3DTSS_ADDRESSV                  */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
4085     { /*1, 15, WINED3DTSS_BORDERCOLOR               */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
4086     { /*1, 16, WINED3DTSS_MAGFILTER                 */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
4087     { /*1, 17, WINED3DTSS_MINFILTER                 */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
4088     { /*1, 18, WINED3DTSS_MIPFILTER                 */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
4089     { /*1, 19, WINED3DTSS_MIPMAPLODBIAS             */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
4090     { /*1, 20, WINED3DTSS_MAXMIPLEVEL               */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
4091     { /*1, 21, WINED3DTSS_MAXANISOTROPY             */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
4092     { /*1, 22, WINED3DTSS_BUMPENVLSCALE             */      STATE_TEXTURESTAGE(1, WINED3DTSS_BUMPENVLSCALE),    NULL                },
4093     { /*1, 23, WINED3DTSS_BUMPENVLOFFSET            */      STATE_TEXTURESTAGE(1, WINED3DTSS_BUMPENVLOFFSET),   NULL                },
4094     { /*1, 24, WINED3DTSS_TEXTURETRANSFORMFLAGS     */      STATE_TRANSFORM(WINED3DTS_TEXTURE1),                NULL                },
4095     { /*1, 25, WINED3DTSS_ADDRESSW                  */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
4096     { /*1, 26, WINED3DTSS_COLORARG0                 */      STATE_TEXTURESTAGE(1, WINED3DTSS_COLOROP),          NULL                },
4097     { /*1, 27, WINED3DTSS_ALPHAARG0                 */      STATE_TEXTURESTAGE(1, WINED3DTSS_ALPHAOP),          NULL                },
4098     { /*0, 28, WINED3DTSS_RESULTARG                 */      STATE_TEXTURESTAGE(1, WINED3DTSS_COLOROP),          NULL                },
4099     { /*1, 29, undefined                            */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
4100     { /*1, 30, undefined                            */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
4101     { /*1, 31, undefined                            */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
4102     { /*1, 32, WINED3DTSS_CONSTANT                  */      0 /* As long as we don't support D3DTA_CONSTANT */, state_nogl          },
4103
4104     { /*2, 01, WINED3DTSS_COLOROP                   */      STATE_TEXTURESTAGE(2, WINED3DTSS_COLOROP),          NULL                },
4105     { /*2, 02, WINED3DTSS_COLORARG1                 */      STATE_TEXTURESTAGE(2, WINED3DTSS_COLOROP),          NULL                },
4106     { /*2, 03, WINED3DTSS_COLORARG2                 */      STATE_TEXTURESTAGE(2, WINED3DTSS_COLOROP),          NULL                },
4107     { /*2, 04, WINED3DTSS_ALPHAOP                   */      STATE_TEXTURESTAGE(2, WINED3DTSS_ALPHAOP),          NULL                },
4108     { /*2, 05, WINED3DTSS_ALPHAARG1                 */      STATE_TEXTURESTAGE(2, WINED3DTSS_ALPHAOP),          NULL                },
4109     { /*2, 06, WINED3DTSS_ALPHAARG2                 */      STATE_TEXTURESTAGE(2, WINED3DTSS_ALPHAOP),          NULL                },
4110     { /*2, 07, WINED3DTSS_BUMPENVMAT00              */      STATE_TEXTURESTAGE(2, WINED3DTSS_BUMPENVMAT00),     NULL                },
4111     { /*2, 08, WINED3DTSS_BUMPENVMAT01              */      STATE_TEXTURESTAGE(2, WINED3DTSS_BUMPENVMAT00),     NULL                },
4112     { /*2, 09, WINED3DTSS_BUMPENVMAT10              */      STATE_TEXTURESTAGE(2, WINED3DTSS_BUMPENVMAT00),     NULL                },
4113     { /*2, 10, WINED3DTSS_BUMPENVMAT11              */      STATE_TEXTURESTAGE(2, WINED3DTSS_BUMPENVMAT00),     NULL                },
4114     { /*2, 11, WINED3DTSS_TEXCOORDINDEX             */      STATE_TEXTURESTAGE(2, WINED3DTSS_TEXCOORDINDEX),    NULL                },
4115     { /*2, 12, WINED3DTSS_ADDRESS                   */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
4116     { /*2, 13, WINED3DTSS_ADDRESSU                  */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
4117     { /*2, 14, WINED3DTSS_ADDRESSV                  */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
4118     { /*2, 15, WINED3DTSS_BORDERCOLOR               */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
4119     { /*2, 16, WINED3DTSS_MAGFILTER                 */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
4120     { /*2, 17, WINED3DTSS_MINFILTER                 */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
4121     { /*2, 18, WINED3DTSS_MIPFILTER                 */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
4122     { /*2, 19, WINED3DTSS_MIPMAPLODBIAS             */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
4123     { /*2, 20, WINED3DTSS_MAXMIPLEVEL               */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
4124     { /*2, 21, WINED3DTSS_MAXANISOTROPY             */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
4125     { /*2, 22, WINED3DTSS_BUMPENVLSCALE             */      STATE_TEXTURESTAGE(2, WINED3DTSS_BUMPENVLSCALE),    NULL                },
4126     { /*2, 23, WINED3DTSS_BUMPENVLOFFSET            */      STATE_TEXTURESTAGE(2, WINED3DTSS_BUMPENVLOFFSET),   NULL                },
4127     { /*2, 24, WINED3DTSS_TEXTURETRANSFORMFLAGS     */      STATE_TRANSFORM(WINED3DTS_TEXTURE2),                NULL                },
4128     { /*2, 25, WINED3DTSS_ADDRESSW                  */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
4129     { /*2, 26, WINED3DTSS_COLORARG0                 */      STATE_TEXTURESTAGE(2, WINED3DTSS_COLOROP),          NULL                },
4130     { /*2, 27, WINED3DTSS_ALPHAARG0                 */      STATE_TEXTURESTAGE(2, WINED3DTSS_ALPHAOP),          NULL                },
4131     { /*0, 28, WINED3DTSS_RESULTARG                 */      STATE_TEXTURESTAGE(2, WINED3DTSS_COLOROP),          NULL                },
4132     { /*2, 29, undefined                            */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
4133     { /*2, 30, undefined                            */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
4134     { /*2, 31, undefined                            */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
4135     { /*2, 32, WINED3DTSS_CONSTANT                  */      0 /* As long as we don't support D3DTA_CONSTANT */, NULL                },
4136
4137     { /*3, 01, WINED3DTSS_COLOROP                   */      STATE_TEXTURESTAGE(3, WINED3DTSS_COLOROP),          NULL                },
4138     { /*3, 02, WINED3DTSS_COLORARG1                 */      STATE_TEXTURESTAGE(3, WINED3DTSS_COLOROP),          NULL                },
4139     { /*3, 03, WINED3DTSS_COLORARG2                 */      STATE_TEXTURESTAGE(3, WINED3DTSS_COLOROP),          NULL                },
4140     { /*3, 04, WINED3DTSS_ALPHAOP                   */      STATE_TEXTURESTAGE(3, WINED3DTSS_ALPHAOP),          NULL                },
4141     { /*3, 05, WINED3DTSS_ALPHAARG1                 */      STATE_TEXTURESTAGE(3, WINED3DTSS_ALPHAOP),          NULL                },
4142     { /*3, 06, WINED3DTSS_ALPHAARG2                 */      STATE_TEXTURESTAGE(3, WINED3DTSS_ALPHAOP),          NULL                },
4143     { /*3, 07, WINED3DTSS_BUMPENVMAT00              */      STATE_TEXTURESTAGE(3, WINED3DTSS_BUMPENVMAT00),     NULL                },
4144     { /*3, 08, WINED3DTSS_BUMPENVMAT01              */      STATE_TEXTURESTAGE(3, WINED3DTSS_BUMPENVMAT00),     NULL                },
4145     { /*3, 09, WINED3DTSS_BUMPENVMAT10              */      STATE_TEXTURESTAGE(3, WINED3DTSS_BUMPENVMAT00),     NULL                },
4146     { /*3, 10, WINED3DTSS_BUMPENVMAT11              */      STATE_TEXTURESTAGE(3, WINED3DTSS_BUMPENVMAT00),     NULL                },
4147     { /*3, 11, WINED3DTSS_TEXCOORDINDEX             */      STATE_TEXTURESTAGE(3, WINED3DTSS_TEXCOORDINDEX),    NULL                },
4148     { /*3, 12, WINED3DTSS_ADDRESS                   */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
4149     { /*3, 13, WINED3DTSS_ADDRESSU                  */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
4150     { /*3, 14, WINED3DTSS_ADDRESSV                  */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
4151     { /*3, 15, WINED3DTSS_BORDERCOLOR               */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
4152     { /*3, 16, WINED3DTSS_MAGFILTER                 */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
4153     { /*3, 17, WINED3DTSS_MINFILTER                 */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
4154     { /*3, 18, WINED3DTSS_MIPFILTER                 */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
4155     { /*3, 19, WINED3DTSS_MIPMAPLODBIAS             */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
4156     { /*3, 20, WINED3DTSS_MAXMIPLEVEL               */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
4157     { /*3, 21, WINED3DTSS_MAXANISOTROPY             */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
4158     { /*3, 22, WINED3DTSS_BUMPENVLSCALE             */      STATE_TEXTURESTAGE(3, WINED3DTSS_BUMPENVLSCALE),    NULL                },
4159     { /*3, 23, WINED3DTSS_BUMPENVLOFFSET            */      STATE_TEXTURESTAGE(3, WINED3DTSS_BUMPENVLOFFSET),   NULL                },
4160     { /*3, 24, WINED3DTSS_TEXTURETRANSFORMFLAGS     */      STATE_TRANSFORM(WINED3DTS_TEXTURE3),                NULL                },
4161     { /*3, 25, WINED3DTSS_ADDRESSW                  */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
4162     { /*3, 26, WINED3DTSS_COLORARG0                 */      STATE_TEXTURESTAGE(3, WINED3DTSS_COLOROP),          NULL                },
4163     { /*3, 27, WINED3DTSS_ALPHAARG0                 */      STATE_TEXTURESTAGE(3, WINED3DTSS_ALPHAOP),          NULL                },
4164     { /*0, 28, WINED3DTSS_RESULTARG                 */      STATE_TEXTURESTAGE(3, WINED3DTSS_COLOROP),          NULL                },
4165     { /*3, 29, undefined                            */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
4166     { /*3, 30, undefined                            */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
4167     { /*3, 31, undefined                            */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
4168     { /*3, 32, WINED3DTSS_CONSTANT                  */      0 /* As long as we don't support D3DTA_CONSTANT */, NULL                },
4169
4170     { /*4, 01, WINED3DTSS_COLOROP                   */      STATE_TEXTURESTAGE(4, WINED3DTSS_COLOROP),          NULL                },
4171     { /*4, 02, WINED3DTSS_COLORARG1                 */      STATE_TEXTURESTAGE(4, WINED3DTSS_COLOROP),          NULL                },
4172     { /*4, 03, WINED3DTSS_COLORARG2                 */      STATE_TEXTURESTAGE(4, WINED3DTSS_COLOROP),          NULL                },
4173     { /*4, 04, WINED3DTSS_ALPHAOP                   */      STATE_TEXTURESTAGE(4, WINED3DTSS_ALPHAOP),          NULL                },
4174     { /*4, 05, WINED3DTSS_ALPHAARG1                 */      STATE_TEXTURESTAGE(4, WINED3DTSS_ALPHAOP),          NULL                },
4175     { /*4, 06, WINED3DTSS_ALPHAARG2                 */      STATE_TEXTURESTAGE(4, WINED3DTSS_ALPHAOP),          NULL                },
4176     { /*4, 07, WINED3DTSS_BUMPENVMAT00              */      STATE_TEXTURESTAGE(4, WINED3DTSS_BUMPENVMAT00),     NULL                },
4177     { /*4, 08, WINED3DTSS_BUMPENVMAT01              */      STATE_TEXTURESTAGE(4, WINED3DTSS_BUMPENVMAT00),     NULL                },
4178     { /*4, 09, WINED3DTSS_BUMPENVMAT10              */      STATE_TEXTURESTAGE(4, WINED3DTSS_BUMPENVMAT00),     NULL                },
4179     { /*4, 10, WINED3DTSS_BUMPENVMAT11              */      STATE_TEXTURESTAGE(4, WINED3DTSS_BUMPENVMAT00),     NULL                },
4180     { /*4, 11, WINED3DTSS_TEXCOORDINDEX             */      STATE_TEXTURESTAGE(4, WINED3DTSS_TEXCOORDINDEX),    NULL                },
4181     { /*4, 12, WINED3DTSS_ADDRESS                   */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
4182     { /*4, 13, WINED3DTSS_ADDRESSU                  */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
4183     { /*4, 14, WINED3DTSS_ADDRESSV                  */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
4184     { /*4, 15, WINED3DTSS_BORDERCOLOR               */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
4185     { /*4, 16, WINED3DTSS_MAGFILTER                 */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
4186     { /*4, 17, WINED3DTSS_MINFILTER                 */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
4187     { /*4, 18, WINED3DTSS_MIPFILTER                 */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
4188     { /*4, 19, WINED3DTSS_MIPMAPLODBIAS             */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
4189     { /*4, 20, WINED3DTSS_MAXMIPLEVEL               */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
4190     { /*4, 21, WINED3DTSS_MAXANISOTROPY             */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
4191     { /*4, 22, WINED3DTSS_BUMPENVLSCALE             */      STATE_TEXTURESTAGE(4, WINED3DTSS_BUMPENVLSCALE),    NULL                },
4192     { /*4, 23, WINED3DTSS_BUMPENVLOFFSET            */      STATE_TEXTURESTAGE(4, WINED3DTSS_BUMPENVLOFFSET),   NULL                },
4193     { /*4, 24, WINED3DTSS_TEXTURETRANSFORMFLAGS     */      STATE_TRANSFORM(WINED3DTS_TEXTURE4),                NULL                },
4194     { /*4, 25, WINED3DTSS_ADDRESSW                  */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
4195     { /*4, 26, WINED3DTSS_COLORARG0                 */      STATE_TEXTURESTAGE(4, WINED3DTSS_COLOROP),          NULL                },
4196     { /*4, 27, WINED3DTSS_ALPHAARG0                 */      STATE_TEXTURESTAGE(4, WINED3DTSS_ALPHAOP),          NULL                },
4197     { /*0, 28, WINED3DTSS_RESULTARG                 */      STATE_TEXTURESTAGE(4, WINED3DTSS_COLOROP),          NULL                },
4198     { /*4, 29, undefined                            */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
4199     { /*4, 30, undefined                            */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
4200     { /*4, 31, undefined                            */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
4201     { /*4, 32, WINED3DTSS_CONSTANT                  */      0 /* As long as we don't support D3DTA_CONSTANT */, NULL                },
4202
4203     { /*5, 01, WINED3DTSS_COLOROP                   */      STATE_TEXTURESTAGE(5, WINED3DTSS_COLOROP),          NULL                },
4204     { /*5, 02, WINED3DTSS_COLORARG1                 */      STATE_TEXTURESTAGE(5, WINED3DTSS_COLOROP),          NULL                },
4205     { /*5, 03, WINED3DTSS_COLORARG2                 */      STATE_TEXTURESTAGE(5, WINED3DTSS_COLOROP),          NULL                },
4206     { /*5, 04, WINED3DTSS_ALPHAOP                   */      STATE_TEXTURESTAGE(5, WINED3DTSS_ALPHAOP),          NULL                },
4207     { /*5, 05, WINED3DTSS_ALPHAARG1                 */      STATE_TEXTURESTAGE(5, WINED3DTSS_ALPHAOP),          NULL                },
4208     { /*5, 06, WINED3DTSS_ALPHAARG2                 */      STATE_TEXTURESTAGE(5, WINED3DTSS_ALPHAOP),          NULL                },
4209     { /*5, 07, WINED3DTSS_BUMPENVMAT00              */      STATE_TEXTURESTAGE(5, WINED3DTSS_BUMPENVMAT00),     NULL                },
4210     { /*5, 08, WINED3DTSS_BUMPENVMAT01              */      STATE_TEXTURESTAGE(5, WINED3DTSS_BUMPENVMAT00),     NULL                },
4211     { /*5, 09, WINED3DTSS_BUMPENVMAT10              */      STATE_TEXTURESTAGE(5, WINED3DTSS_BUMPENVMAT00),     NULL                },
4212     { /*5, 10, WINED3DTSS_BUMPENVMAT11              */      STATE_TEXTURESTAGE(5, WINED3DTSS_BUMPENVMAT00),     NULL                },
4213     { /*5, 11, WINED3DTSS_TEXCOORDINDEX             */      STATE_TEXTURESTAGE(5, WINED3DTSS_TEXCOORDINDEX),    NULL                },
4214     { /*5, 12, WINED3DTSS_ADDRESS                   */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
4215     { /*5, 13, WINED3DTSS_ADDRESSU                  */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
4216     { /*5, 14, WINED3DTSS_ADDRESSV                  */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
4217     { /*5, 15, WINED3DTSS_BORDERCOLOR               */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
4218     { /*5, 16, WINED3DTSS_MAGFILTER                 */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
4219     { /*5, 17, WINED3DTSS_MINFILTER                 */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
4220     { /*5, 18, WINED3DTSS_MIPFILTER                 */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
4221     { /*5, 19, WINED3DTSS_MIPMAPLODBIAS             */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
4222     { /*5, 20, WINED3DTSS_MAXMIPLEVEL               */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
4223     { /*5, 21, WINED3DTSS_MAXANISOTROPY             */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
4224     { /*5, 22, WINED3DTSS_BUMPENVLSCALE             */      STATE_TEXTURESTAGE(5, WINED3DTSS_BUMPENVLSCALE),    NULL                },
4225     { /*5, 23, WINED3DTSS_BUMPENVLOFFSET            */      STATE_TEXTURESTAGE(5, WINED3DTSS_BUMPENVLOFFSET),   NULL                },
4226     { /*5, 24, WINED3DTSS_TEXTURETRANSFORMFLAGS     */      STATE_TRANSFORM(WINED3DTS_TEXTURE5),                NULL                },
4227     { /*5, 25, WINED3DTSS_ADDRESSW                  */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
4228     { /*5, 26, WINED3DTSS_COLORARG0                 */      STATE_TEXTURESTAGE(5, WINED3DTSS_COLOROP),          NULL                },
4229     { /*5, 27, WINED3DTSS_ALPHAARG0                 */      STATE_TEXTURESTAGE(5, WINED3DTSS_ALPHAOP),          NULL                },
4230     { /*0, 28, WINED3DTSS_RESULTARG                 */      STATE_TEXTURESTAGE(5, WINED3DTSS_COLOROP),          NULL                },
4231     { /*5, 29, undefined                            */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
4232     { /*5, 30, undefined                            */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
4233     { /*5, 31, undefined                            */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
4234     { /*5, 32, WINED3DTSS_CONSTANT                  */      0 /* As long as we don't support D3DTA_CONSTANT */, NULL                },
4235
4236     { /*6, 01, WINED3DTSS_COLOROP                   */      STATE_TEXTURESTAGE(6, WINED3DTSS_COLOROP),          NULL                },
4237     { /*6, 02, WINED3DTSS_COLORARG1                 */      STATE_TEXTURESTAGE(6, WINED3DTSS_COLOROP),          NULL                },
4238     { /*6, 03, WINED3DTSS_COLORARG2                 */      STATE_TEXTURESTAGE(6, WINED3DTSS_COLOROP),          NULL                },
4239     { /*6, 04, WINED3DTSS_ALPHAOP                   */      STATE_TEXTURESTAGE(6, WINED3DTSS_ALPHAOP),          NULL                },
4240     { /*6, 05, WINED3DTSS_ALPHAARG1                 */      STATE_TEXTURESTAGE(6, WINED3DTSS_ALPHAOP),          NULL                },
4241     { /*6, 06, WINED3DTSS_ALPHAARG2                 */      STATE_TEXTURESTAGE(6, WINED3DTSS_ALPHAOP),          NULL                },
4242     { /*6, 07, WINED3DTSS_BUMPENVMAT00              */      STATE_TEXTURESTAGE(6, WINED3DTSS_BUMPENVMAT00),     NULL                },
4243     { /*6, 08, WINED3DTSS_BUMPENVMAT01              */      STATE_TEXTURESTAGE(6, WINED3DTSS_BUMPENVMAT00),     NULL                },
4244     { /*6, 09, WINED3DTSS_BUMPENVMAT10              */      STATE_TEXTURESTAGE(6, WINED3DTSS_BUMPENVMAT00),     NULL                },
4245     { /*6, 10, WINED3DTSS_BUMPENVMAT11              */      STATE_TEXTURESTAGE(6, WINED3DTSS_BUMPENVMAT00),     NULL                },
4246     { /*6, 11, WINED3DTSS_TEXCOORDINDEX             */      STATE_TEXTURESTAGE(6, WINED3DTSS_TEXCOORDINDEX),    NULL                },
4247     { /*6, 12, WINED3DTSS_ADDRESS                   */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
4248     { /*6, 13, WINED3DTSS_ADDRESSU                  */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
4249     { /*6, 14, WINED3DTSS_ADDRESSV                  */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
4250     { /*6, 15, WINED3DTSS_BORDERCOLOR               */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
4251     { /*6, 16, WINED3DTSS_MAGFILTER                 */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
4252     { /*6, 17, WINED3DTSS_MINFILTER                 */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
4253     { /*6, 18, WINED3DTSS_MIPFILTER                 */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
4254     { /*6, 19, WINED3DTSS_MIPMAPLODBIAS             */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
4255     { /*6, 20, WINED3DTSS_MAXMIPLEVEL               */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
4256     { /*6, 21, WINED3DTSS_MAXANISOTROPY             */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
4257     { /*6, 22, WINED3DTSS_BUMPENVLSCALE             */      STATE_TEXTURESTAGE(6, WINED3DTSS_BUMPENVLSCALE),    NULL                },
4258     { /*6, 23, WINED3DTSS_BUMPENVLOFFSET            */      STATE_TEXTURESTAGE(6, WINED3DTSS_BUMPENVLOFFSET),   NULL                },
4259     { /*6, 24, WINED3DTSS_TEXTURETRANSFORMFLAGS     */      STATE_TRANSFORM(WINED3DTS_TEXTURE6),                NULL                },
4260     { /*6, 25, WINED3DTSS_ADDRESSW                  */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
4261     { /*6, 26, WINED3DTSS_COLORARG0                 */      STATE_TEXTURESTAGE(6, WINED3DTSS_COLOROP),          NULL                },
4262     { /*6, 27, WINED3DTSS_ALPHAARG0                 */      STATE_TEXTURESTAGE(6, WINED3DTSS_ALPHAOP),          NULL                },
4263     { /*0, 28, WINED3DTSS_RESULTARG                 */      STATE_TEXTURESTAGE(6, WINED3DTSS_COLOROP),          NULL                },
4264     { /*6, 29, undefined                            */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
4265     { /*6, 30, undefined                            */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
4266     { /*6, 31, undefined                            */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
4267     { /*6, 32, WINED3DTSS_CONSTANT                  */      0 /* As long as we don't support D3DTA_CONSTANT */, NULL                },
4268
4269     { /*7, 01, WINED3DTSS_COLOROP                   */      STATE_TEXTURESTAGE(7, WINED3DTSS_COLOROP),          NULL                },
4270     { /*7, 02, WINED3DTSS_COLORARG1                 */      STATE_TEXTURESTAGE(7, WINED3DTSS_COLOROP),          NULL                },
4271     { /*7, 03, WINED3DTSS_COLORARG2                 */      STATE_TEXTURESTAGE(7, WINED3DTSS_COLOROP),          NULL                },
4272     { /*7, 04, WINED3DTSS_ALPHAOP                   */      STATE_TEXTURESTAGE(7, WINED3DTSS_ALPHAOP),          NULL                },
4273     { /*7, 05, WINED3DTSS_ALPHAARG1                 */      STATE_TEXTURESTAGE(7, WINED3DTSS_ALPHAOP),          NULL                },
4274     { /*7, 06, WINED3DTSS_ALPHAARG2                 */      STATE_TEXTURESTAGE(7, WINED3DTSS_ALPHAOP),          NULL                },
4275     { /*7, 07, WINED3DTSS_BUMPENVMAT00              */      STATE_TEXTURESTAGE(7, WINED3DTSS_BUMPENVMAT00),     NULL                },
4276     { /*7, 08, WINED3DTSS_BUMPENVMAT01              */      STATE_TEXTURESTAGE(7, WINED3DTSS_BUMPENVMAT00),     NULL                },
4277     { /*7, 09, WINED3DTSS_BUMPENVMAT10              */      STATE_TEXTURESTAGE(7, WINED3DTSS_BUMPENVMAT00),     NULL                },
4278     { /*7, 10, WINED3DTSS_BUMPENVMAT11              */      STATE_TEXTURESTAGE(7, WINED3DTSS_BUMPENVMAT00),     NULL                },
4279     { /*7, 11, WINED3DTSS_TEXCOORDINDEX             */      STATE_TEXTURESTAGE(7, WINED3DTSS_TEXCOORDINDEX),    NULL                },
4280     { /*7, 12, WINED3DTSS_ADDRESS                   */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
4281     { /*7, 13, WINED3DTSS_ADDRESSU                  */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
4282     { /*7, 14, WINED3DTSS_ADDRESSV                  */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
4283     { /*7, 15, WINED3DTSS_BORDERCOLOR               */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
4284     { /*7, 16, WINED3DTSS_MAGFILTER                 */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
4285     { /*7, 17, WINED3DTSS_MINFILTER                 */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
4286     { /*7, 18, WINED3DTSS_MIPFILTER                 */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
4287     { /*7, 19, WINED3DTSS_MIPMAPLODBIAS             */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
4288     { /*7, 20, WINED3DTSS_MAXMIPLEVEL               */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
4289     { /*7, 21, WINED3DTSS_MAXANISOTROPY             */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
4290     { /*7, 22, WINED3DTSS_BUMPENVLSCALE             */      STATE_TEXTURESTAGE(7, WINED3DTSS_BUMPENVLSCALE),    NULL                },
4291     { /*7, 23, WINED3DTSS_BUMPENVLOFFSET            */      STATE_TEXTURESTAGE(7, WINED3DTSS_BUMPENVLOFFSET),   NULL                },
4292     { /*7, 24, WINED3DTSS_TEXTURETRANSFORMFLAGS     */      STATE_TRANSFORM(WINED3DTS_TEXTURE7),                NULL                },
4293     { /*7, 25, WINED3DTSS_ADDRESSW                  */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
4294     { /*7, 26, WINED3DTSS_COLORARG0                 */      STATE_TEXTURESTAGE(7, WINED3DTSS_COLOROP),          NULL                },
4295     { /*7, 27, WINED3DTSS_ALPHAARG0                 */      STATE_TEXTURESTAGE(7, WINED3DTSS_ALPHAOP),          NULL                },
4296     { /*0, 28, WINED3DTSS_RESULTARG                 */      STATE_TEXTURESTAGE(7, WINED3DTSS_COLOROP),          NULL                },
4297     { /*7, 29, undefined                            */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
4298     { /*7, 30, undefined                            */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
4299     { /*7, 31, undefined                            */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
4300     { /*7, 32, WINED3DTSS_CONSTANT                  */      0 /* As long as we don't support D3DTA_CONSTANT */, NULL                },
4301     /* Sampler states */
4302     { /* 0, Sampler 0                               */      STATE_SAMPLER(0),                                   sampler             },
4303     { /* 1, Sampler 1                               */      STATE_SAMPLER(1),                                   sampler             },
4304     { /* 2, Sampler 2                               */      STATE_SAMPLER(2),                                   sampler             },
4305     { /* 3, Sampler 3                               */      STATE_SAMPLER(3),                                   sampler             },
4306     { /* 4, Sampler 3                               */      STATE_SAMPLER(4),                                   sampler             },
4307     { /* 5, Sampler 5                               */      STATE_SAMPLER(5),                                   sampler             },
4308     { /* 6, Sampler 6                               */      STATE_SAMPLER(6),                                   sampler             },
4309     { /* 7, Sampler 7                               */      STATE_SAMPLER(7),                                   sampler             },
4310     { /* 8, Sampler 8                               */      STATE_SAMPLER(8),                                   sampler             },
4311     { /* 9, Sampler 9                               */      STATE_SAMPLER(9),                                   sampler             },
4312     { /*10, Sampler 10                              */      STATE_SAMPLER(10),                                  sampler             },
4313     { /*11, Sampler 11                              */      STATE_SAMPLER(11),                                  sampler             },
4314     { /*12, Sampler 12                              */      STATE_SAMPLER(12),                                  sampler             },
4315     { /*13, Sampler 13                              */      STATE_SAMPLER(13),                                  sampler             },
4316     { /*14, Sampler 14                              */      STATE_SAMPLER(14),                                  sampler             },
4317     { /*15, Sampler 15                              */      STATE_SAMPLER(15),                                  sampler             },
4318     { /*16, Vertex sampler 0                        */      STATE_SAMPLER(16),                                  sampler             },
4319     { /*17, Vertex sampler 1                        */      STATE_SAMPLER(17),                                  sampler             },
4320     { /*18, Vertex sampler 2                        */      STATE_SAMPLER(18),                                  sampler             },
4321     { /*19, Vertex sampler 3                        */      STATE_SAMPLER(19),                                  sampler             },
4322     /* Pixel shader */
4323     { /*  , Pixel Shader                            */      STATE_PIXELSHADER,                                  NULL                },
4324       /* Transform states follow                    */
4325     { /*  1, undefined                              */      0,                                                  state_undefined     },
4326     { /*  2, WINED3DTS_VIEW                         */      STATE_TRANSFORM(WINED3DTS_VIEW),                    NULL                },
4327     { /*  3, WINED3DTS_PROJECTION                   */      STATE_TRANSFORM(WINED3DTS_PROJECTION),              NULL                },
4328     { /*  4, undefined                              */      0,                                                  state_undefined     },
4329     { /*  5, undefined                              */      0,                                                  state_undefined     },
4330     { /*  6, undefined                              */      0,                                                  state_undefined     },
4331     { /*  7, undefined                              */      0,                                                  state_undefined     },
4332     { /*  8, undefined                              */      0,                                                  state_undefined     },
4333     { /*  9, undefined                              */      0,                                                  state_undefined     },
4334     { /* 10, undefined                              */      0,                                                  state_undefined     },
4335     { /* 11, undefined                              */      0,                                                  state_undefined     },
4336     { /* 12, undefined                              */      0,                                                  state_undefined     },
4337     { /* 13, undefined                              */      0,                                                  state_undefined     },
4338     { /* 14, undefined                              */      0,                                                  state_undefined     },
4339     { /* 15, undefined                              */      0,                                                  state_undefined     },
4340     { /* 16, WINED3DTS_TEXTURE0                     */      STATE_TRANSFORM(WINED3DTS_TEXTURE0),                NULL                },
4341     { /* 17, WINED3DTS_TEXTURE1                     */      STATE_TRANSFORM(WINED3DTS_TEXTURE1),                NULL                },
4342     { /* 18, WINED3DTS_TEXTURE2                     */      STATE_TRANSFORM(WINED3DTS_TEXTURE2),                NULL                },
4343     { /* 19, WINED3DTS_TEXTURE3                     */      STATE_TRANSFORM(WINED3DTS_TEXTURE3),                NULL                },
4344     { /* 20, WINED3DTS_TEXTURE4                     */      STATE_TRANSFORM(WINED3DTS_TEXTURE4),                NULL                },
4345     { /* 21, WINED3DTS_TEXTURE5                     */      STATE_TRANSFORM(WINED3DTS_TEXTURE5),                NULL                },
4346     { /* 22, WINED3DTS_TEXTURE6                     */      STATE_TRANSFORM(WINED3DTS_TEXTURE6),                NULL                },
4347     { /* 23, WINED3DTS_TEXTURE7                     */      STATE_TRANSFORM(WINED3DTS_TEXTURE7),                NULL                },
4348       /* A huge gap between TEXTURE7 and WORLDMATRIX(0) :-( But entries are needed to catch then if a broken app sets them */
4349     { /* 24, undefined                              */      0,                                                  state_undefined     },
4350     { /* 25, undefined                              */      0,                                                  state_undefined     },
4351     { /* 26, undefined                              */      0,                                                  state_undefined     },
4352     { /* 27, undefined                              */      0,                                                  state_undefined     },
4353     { /* 28, undefined                              */      0,                                                  state_undefined     },
4354     { /* 29, undefined                              */      0,                                                  state_undefined     },
4355     { /* 30, undefined                              */      0,                                                  state_undefined     },
4356     { /* 31, undefined                              */      0,                                                  state_undefined     },
4357     { /* 32, undefined                              */      0,                                                  state_undefined     },
4358     { /* 33, undefined                              */      0,                                                  state_undefined     },
4359     { /* 34, undefined                              */      0,                                                  state_undefined     },
4360     { /* 35, undefined                              */      0,                                                  state_undefined     },
4361     { /* 36, undefined                              */      0,                                                  state_undefined     },
4362     { /* 37, undefined                              */      0,                                                  state_undefined     },
4363     { /* 38, undefined                              */      0,                                                  state_undefined     },
4364     { /* 39, undefined                              */      0,                                                  state_undefined     },
4365     { /* 40, undefined                              */      0,                                                  state_undefined     },
4366     { /* 41, undefined                              */      0,                                                  state_undefined     },
4367     { /* 42, undefined                              */      0,                                                  state_undefined     },
4368     { /* 43, undefined                              */      0,                                                  state_undefined     },
4369     { /* 44, undefined                              */      0,                                                  state_undefined     },
4370     { /* 45, undefined                              */      0,                                                  state_undefined     },
4371     { /* 46, undefined                              */      0,                                                  state_undefined     },
4372     { /* 47, undefined                              */      0,                                                  state_undefined     },
4373     { /* 48, undefined                              */      0,                                                  state_undefined     },
4374     { /* 49, undefined                              */      0,                                                  state_undefined     },
4375     { /* 50, undefined                              */      0,                                                  state_undefined     },
4376     { /* 51, undefined                              */      0,                                                  state_undefined     },
4377     { /* 52, undefined                              */      0,                                                  state_undefined     },
4378     { /* 53, undefined                              */      0,                                                  state_undefined     },
4379     { /* 54, undefined                              */      0,                                                  state_undefined     },
4380     { /* 55, undefined                              */      0,                                                  state_undefined     },
4381     { /* 56, undefined                              */      0,                                                  state_undefined     },
4382     { /* 57, undefined                              */      0,                                                  state_undefined     },
4383     { /* 58, undefined                              */      0,                                                  state_undefined     },
4384     { /* 59, undefined                              */      0,                                                  state_undefined     },
4385     { /* 60, undefined                              */      0,                                                  state_undefined     },
4386     { /* 61, undefined                              */      0,                                                  state_undefined     },
4387     { /* 62, undefined                              */      0,                                                  state_undefined     },
4388     { /* 63, undefined                              */      0,                                                  state_undefined     },
4389     { /* 64, undefined                              */      0,                                                  state_undefined     },
4390     { /* 65, undefined                              */      0,                                                  state_undefined     },
4391     { /* 66, undefined                              */      0,                                                  state_undefined     },
4392     { /* 67, undefined                              */      0,                                                  state_undefined     },
4393     { /* 68, undefined                              */      0,                                                  state_undefined     },
4394     { /* 69, undefined                              */      0,                                                  state_undefined     },
4395     { /* 70, undefined                              */      0,                                                  state_undefined     },
4396     { /* 71, undefined                              */      0,                                                  state_undefined     },
4397     { /* 72, undefined                              */      0,                                                  state_undefined     },
4398     { /* 73, undefined                              */      0,                                                  state_undefined     },
4399     { /* 74, undefined                              */      0,                                                  state_undefined     },
4400     { /* 75, undefined                              */      0,                                                  state_undefined     },
4401     { /* 76, undefined                              */      0,                                                  state_undefined     },
4402     { /* 77, undefined                              */      0,                                                  state_undefined     },
4403     { /* 78, undefined                              */      0,                                                  state_undefined     },
4404     { /* 79, undefined                              */      0,                                                  state_undefined     },
4405     { /* 80, undefined                              */      0,                                                  state_undefined     },
4406     { /* 81, undefined                              */      0,                                                  state_undefined     },
4407     { /* 82, undefined                              */      0,                                                  state_undefined     },
4408     { /* 83, undefined                              */      0,                                                  state_undefined     },
4409     { /* 84, undefined                              */      0,                                                  state_undefined     },
4410     { /* 85, undefined                              */      0,                                                  state_undefined     },
4411     { /* 86, undefined                              */      0,                                                  state_undefined     },
4412     { /* 87, undefined                              */      0,                                                  state_undefined     },
4413     { /* 88, undefined                              */      0,                                                  state_undefined     },
4414     { /* 89, undefined                              */      0,                                                  state_undefined     },
4415     { /* 90, undefined                              */      0,                                                  state_undefined     },
4416     { /* 91, undefined                              */      0,                                                  state_undefined     },
4417     { /* 92, undefined                              */      0,                                                  state_undefined     },
4418     { /* 93, undefined                              */      0,                                                  state_undefined     },
4419     { /* 94, undefined                              */      0,                                                  state_undefined     },
4420     { /* 95, undefined                              */      0,                                                  state_undefined     },
4421     { /* 96, undefined                              */      0,                                                  state_undefined     },
4422     { /* 97, undefined                              */      0,                                                  state_undefined     },
4423     { /* 98, undefined                              */      0,                                                  state_undefined     },
4424     { /* 99, undefined                              */      0,                                                  state_undefined     },
4425     { /*100, undefined                              */      0,                                                  state_undefined     },
4426     { /*101, undefined                              */      0,                                                  state_undefined     },
4427     { /*102, undefined                              */      0,                                                  state_undefined     },
4428     { /*103, undefined                              */      0,                                                  state_undefined     },
4429     { /*104, undefined                              */      0,                                                  state_undefined     },
4430     { /*105, undefined                              */      0,                                                  state_undefined     },
4431     { /*106, undefined                              */      0,                                                  state_undefined     },
4432     { /*107, undefined                              */      0,                                                  state_undefined     },
4433     { /*108, undefined                              */      0,                                                  state_undefined     },
4434     { /*109, undefined                              */      0,                                                  state_undefined     },
4435     { /*110, undefined                              */      0,                                                  state_undefined     },
4436     { /*111, undefined                              */      0,                                                  state_undefined     },
4437     { /*112, undefined                              */      0,                                                  state_undefined     },
4438     { /*113, undefined                              */      0,                                                  state_undefined     },
4439     { /*114, undefined                              */      0,                                                  state_undefined     },
4440     { /*115, undefined                              */      0,                                                  state_undefined     },
4441     { /*116, undefined                              */      0,                                                  state_undefined     },
4442     { /*117, undefined                              */      0,                                                  state_undefined     },
4443     { /*118, undefined                              */      0,                                                  state_undefined     },
4444     { /*119, undefined                              */      0,                                                  state_undefined     },
4445     { /*120, undefined                              */      0,                                                  state_undefined     },
4446     { /*121, undefined                              */      0,                                                  state_undefined     },
4447     { /*122, undefined                              */      0,                                                  state_undefined     },
4448     { /*123, undefined                              */      0,                                                  state_undefined     },
4449     { /*124, undefined                              */      0,                                                  state_undefined     },
4450     { /*125, undefined                              */      0,                                                  state_undefined     },
4451     { /*126, undefined                              */      0,                                                  state_undefined     },
4452     { /*127, undefined                              */      0,                                                  state_undefined     },
4453     { /*128, undefined                              */      0,                                                  state_undefined     },
4454     { /*129, undefined                              */      0,                                                  state_undefined     },
4455     { /*130, undefined                              */      0,                                                  state_undefined     },
4456     { /*131, undefined                              */      0,                                                  state_undefined     },
4457     { /*132, undefined                              */      0,                                                  state_undefined     },
4458     { /*133, undefined                              */      0,                                                  state_undefined     },
4459     { /*134, undefined                              */      0,                                                  state_undefined     },
4460     { /*135, undefined                              */      0,                                                  state_undefined     },
4461     { /*136, undefined                              */      0,                                                  state_undefined     },
4462     { /*137, undefined                              */      0,                                                  state_undefined     },
4463     { /*138, undefined                              */      0,                                                  state_undefined     },
4464     { /*139, undefined                              */      0,                                                  state_undefined     },
4465     { /*140, undefined                              */      0,                                                  state_undefined     },
4466     { /*141, undefined                              */      0,                                                  state_undefined     },
4467     { /*142, undefined                              */      0,                                                  state_undefined     },
4468     { /*143, undefined                              */      0,                                                  state_undefined     },
4469     { /*144, undefined                              */      0,                                                  state_undefined     },
4470     { /*145, undefined                              */      0,                                                  state_undefined     },
4471     { /*146, undefined                              */      0,                                                  state_undefined     },
4472     { /*147, undefined                              */      0,                                                  state_undefined     },
4473     { /*148, undefined                              */      0,                                                  state_undefined     },
4474     { /*149, undefined                              */      0,                                                  state_undefined     },
4475     { /*150, undefined                              */      0,                                                  state_undefined     },
4476     { /*151, undefined                              */      0,                                                  state_undefined     },
4477     { /*152, undefined                              */      0,                                                  state_undefined     },
4478     { /*153, undefined                              */      0,                                                  state_undefined     },
4479     { /*154, undefined                              */      0,                                                  state_undefined     },
4480     { /*155, undefined                              */      0,                                                  state_undefined     },
4481     { /*156, undefined                              */      0,                                                  state_undefined     },
4482     { /*157, undefined                              */      0,                                                  state_undefined     },
4483     { /*158, undefined                              */      0,                                                  state_undefined     },
4484     { /*159, undefined                              */      0,                                                  state_undefined     },
4485     { /*160, undefined                              */      0,                                                  state_undefined     },
4486     { /*161, undefined                              */      0,                                                  state_undefined     },
4487     { /*162, undefined                              */      0,                                                  state_undefined     },
4488     { /*163, undefined                              */      0,                                                  state_undefined     },
4489     { /*164, undefined                              */      0,                                                  state_undefined     },
4490     { /*165, undefined                              */      0,                                                  state_undefined     },
4491     { /*166, undefined                              */      0,                                                  state_undefined     },
4492     { /*167, undefined                              */      0,                                                  state_undefined     },
4493     { /*168, undefined                              */      0,                                                  state_undefined     },
4494     { /*169, undefined                              */      0,                                                  state_undefined     },
4495     { /*170, undefined                              */      0,                                                  state_undefined     },
4496     { /*171, undefined                              */      0,                                                  state_undefined     },
4497     { /*172, undefined                              */      0,                                                  state_undefined     },
4498     { /*173, undefined                              */      0,                                                  state_undefined     },
4499     { /*174, undefined                              */      0,                                                  state_undefined     },
4500     { /*175, undefined                              */      0,                                                  state_undefined     },
4501     { /*176, undefined                              */      0,                                                  state_undefined     },
4502     { /*177, undefined                              */      0,                                                  state_undefined     },
4503     { /*178, undefined                              */      0,                                                  state_undefined     },
4504     { /*179, undefined                              */      0,                                                  state_undefined     },
4505     { /*180, undefined                              */      0,                                                  state_undefined     },
4506     { /*181, undefined                              */      0,                                                  state_undefined     },
4507     { /*182, undefined                              */      0,                                                  state_undefined     },
4508     { /*183, undefined                              */      0,                                                  state_undefined     },
4509     { /*184, undefined                              */      0,                                                  state_undefined     },
4510     { /*185, undefined                              */      0,                                                  state_undefined     },
4511     { /*186, undefined                              */      0,                                                  state_undefined     },
4512     { /*187, undefined                              */      0,                                                  state_undefined     },
4513     { /*188, undefined                              */      0,                                                  state_undefined     },
4514     { /*189, undefined                              */      0,                                                  state_undefined     },
4515     { /*190, undefined                              */      0,                                                  state_undefined     },
4516     { /*191, undefined                              */      0,                                                  state_undefined     },
4517     { /*192, undefined                              */      0,                                                  state_undefined     },
4518     { /*193, undefined                              */      0,                                                  state_undefined     },
4519     { /*194, undefined                              */      0,                                                  state_undefined     },
4520     { /*195, undefined                              */      0,                                                  state_undefined     },
4521     { /*196, undefined                              */      0,                                                  state_undefined     },
4522     { /*197, undefined                              */      0,                                                  state_undefined     },
4523     { /*198, undefined                              */      0,                                                  state_undefined     },
4524     { /*199, undefined                              */      0,                                                  state_undefined     },
4525     { /*200, undefined                              */      0,                                                  state_undefined     },
4526     { /*201, undefined                              */      0,                                                  state_undefined     },
4527     { /*202, undefined                              */      0,                                                  state_undefined     },
4528     { /*203, undefined                              */      0,                                                  state_undefined     },
4529     { /*204, undefined                              */      0,                                                  state_undefined     },
4530     { /*205, undefined                              */      0,                                                  state_undefined     },
4531     { /*206, undefined                              */      0,                                                  state_undefined     },
4532     { /*207, undefined                              */      0,                                                  state_undefined     },
4533     { /*208, undefined                              */      0,                                                  state_undefined     },
4534     { /*209, undefined                              */      0,                                                  state_undefined     },
4535     { /*210, undefined                              */      0,                                                  state_undefined     },
4536     { /*211, undefined                              */      0,                                                  state_undefined     },
4537     { /*212, undefined                              */      0,                                                  state_undefined     },
4538     { /*213, undefined                              */      0,                                                  state_undefined     },
4539     { /*214, undefined                              */      0,                                                  state_undefined     },
4540     { /*215, undefined                              */      0,                                                  state_undefined     },
4541     { /*216, undefined                              */      0,                                                  state_undefined     },
4542     { /*217, undefined                              */      0,                                                  state_undefined     },
4543     { /*218, undefined                              */      0,                                                  state_undefined     },
4544     { /*219, undefined                              */      0,                                                  state_undefined     },
4545     { /*220, undefined                              */      0,                                                  state_undefined     },
4546     { /*221, undefined                              */      0,                                                  state_undefined     },
4547     { /*222, undefined                              */      0,                                                  state_undefined     },
4548     { /*223, undefined                              */      0,                                                  state_undefined     },
4549     { /*224, undefined                              */      0,                                                  state_undefined     },
4550     { /*225, undefined                              */      0,                                                  state_undefined     },
4551     { /*226, undefined                              */      0,                                                  state_undefined     },
4552     { /*227, undefined                              */      0,                                                  state_undefined     },
4553     { /*228, undefined                              */      0,                                                  state_undefined     },
4554     { /*229, undefined                              */      0,                                                  state_undefined     },
4555     { /*230, undefined                              */      0,                                                  state_undefined     },
4556     { /*231, undefined                              */      0,                                                  state_undefined     },
4557     { /*232, undefined                              */      0,                                                  state_undefined     },
4558     { /*233, undefined                              */      0,                                                  state_undefined     },
4559     { /*234, undefined                              */      0,                                                  state_undefined     },
4560     { /*235, undefined                              */      0,                                                  state_undefined     },
4561     { /*236, undefined                              */      0,                                                  state_undefined     },
4562     { /*237, undefined                              */      0,                                                  state_undefined     },
4563     { /*238, undefined                              */      0,                                                  state_undefined     },
4564     { /*239, undefined                              */      0,                                                  state_undefined     },
4565     { /*240, undefined                              */      0,                                                  state_undefined     },
4566     { /*241, undefined                              */      0,                                                  state_undefined     },
4567     { /*242, undefined                              */      0,                                                  state_undefined     },
4568     { /*243, undefined                              */      0,                                                  state_undefined     },
4569     { /*244, undefined                              */      0,                                                  state_undefined     },
4570     { /*245, undefined                              */      0,                                                  state_undefined     },
4571     { /*246, undefined                              */      0,                                                  state_undefined     },
4572     { /*247, undefined                              */      0,                                                  state_undefined     },
4573     { /*248, undefined                              */      0,                                                  state_undefined     },
4574     { /*249, undefined                              */      0,                                                  state_undefined     },
4575     { /*250, undefined                              */      0,                                                  state_undefined     },
4576     { /*251, undefined                              */      0,                                                  state_undefined     },
4577     { /*252, undefined                              */      0,                                                  state_undefined     },
4578     { /*253, undefined                              */      0,                                                  state_undefined     },
4579     { /*254, undefined                              */      0,                                                  state_undefined     },
4580     { /*255, undefined                              */      0,                                                  state_undefined     },
4581       /* End huge gap */
4582     { /*256, WINED3DTS_WORLDMATRIX(0)               */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(0)),          NULL                },
4583     { /*257, WINED3DTS_WORLDMATRIX(1)               */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(1)),          NULL                },
4584     { /*258, WINED3DTS_WORLDMATRIX(2)               */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(2)),          NULL                },
4585     { /*259, WINED3DTS_WORLDMATRIX(3)               */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(3)),          NULL                },
4586     { /*260, WINED3DTS_WORLDMATRIX(4)               */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(4)),          NULL                },
4587     { /*261, WINED3DTS_WORLDMATRIX(5)               */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(5)),          NULL                },
4588     { /*262, WINED3DTS_WORLDMATRIX(6)               */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(6)),          NULL                },
4589     { /*263, WINED3DTS_WORLDMATRIX(7)               */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(7)),          NULL                },
4590     { /*264, WINED3DTS_WORLDMATRIX(8)               */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(8)),          NULL                },
4591     { /*265, WINED3DTS_WORLDMATRIX(9)               */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(9)),          NULL                },
4592     { /*266, WINED3DTS_WORLDMATRIX(10)              */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(10)),         NULL                },
4593     { /*267, WINED3DTS_WORLDMATRIX(11)              */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(11)),         NULL                },
4594     { /*268, WINED3DTS_WORLDMATRIX(12)              */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(12)),         NULL                },
4595     { /*269, WINED3DTS_WORLDMATRIX(13)              */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(13)),         NULL                },
4596     { /*270, WINED3DTS_WORLDMATRIX(14)              */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(14)),         NULL                },
4597     { /*271, WINED3DTS_WORLDMATRIX(15)              */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(15)),         NULL                },
4598     { /*272, WINED3DTS_WORLDMATRIX(16)              */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(16)),         NULL                },
4599     { /*273, WINED3DTS_WORLDMATRIX(17)              */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(17)),         NULL                },
4600     { /*274, WINED3DTS_WORLDMATRIX(18)              */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(18)),         NULL                },
4601     { /*275, WINED3DTS_WORLDMATRIX(19)              */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(19)),         NULL                },
4602     { /*276, WINED3DTS_WORLDMATRIX(20)              */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(20)),         NULL                },
4603     { /*277, WINED3DTS_WORLDMATRIX(21)              */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(21)),         NULL                },
4604     { /*278, WINED3DTS_WORLDMATRIX(22)              */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(22)),         NULL                },
4605     { /*279, WINED3DTS_WORLDMATRIX(23)              */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(23)),         NULL                },
4606     { /*280, WINED3DTS_WORLDMATRIX(24)              */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(24)),         NULL                },
4607     { /*281, WINED3DTS_WORLDMATRIX(25)              */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(25)),         NULL                },
4608     { /*282, WINED3DTS_WORLDMATRIX(26)              */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(26)),         NULL                },
4609     { /*283, WINED3DTS_WORLDMATRIX(27)              */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(27)),         NULL                },
4610     { /*284, WINED3DTS_WORLDMATRIX(28)              */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(28)),         NULL                },
4611     { /*285, WINED3DTS_WORLDMATRIX(29)              */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(29)),         NULL                },
4612     { /*286, WINED3DTS_WORLDMATRIX(30)              */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(30)),         NULL                },
4613     { /*287, WINED3DTS_WORLDMATRIX(31)              */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(31)),         NULL                },
4614     { /*288, WINED3DTS_WORLDMATRIX(32)              */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(32)),         NULL                },
4615     { /*289, WINED3DTS_WORLDMATRIX(33)              */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(33)),         NULL                },
4616     { /*290, WINED3DTS_WORLDMATRIX(34)              */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(34)),         NULL                },
4617     { /*291, WINED3DTS_WORLDMATRIX(35)              */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(35)),         NULL                },
4618     { /*292, WINED3DTS_WORLDMATRIX(36)              */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(36)),         NULL                },
4619     { /*293, WINED3DTS_WORLDMATRIX(37)              */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(37)),         NULL                },
4620     { /*294, WINED3DTS_WORLDMATRIX(38)              */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(38)),         NULL                },
4621     { /*295, WINED3DTS_WORLDMATRIX(39)              */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(39)),         NULL                },
4622     { /*296, WINED3DTS_WORLDMATRIX(40)              */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(40)),         NULL                },
4623     { /*297, WINED3DTS_WORLDMATRIX(41)              */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(41)),         NULL                },
4624     { /*298, WINED3DTS_WORLDMATRIX(42)              */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(42)),         NULL                },
4625     { /*299, WINED3DTS_WORLDMATRIX(43)              */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(43)),         NULL                },
4626     { /*300, WINED3DTS_WORLDMATRIX(44)              */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(44)),         NULL                },
4627     { /*301, WINED3DTS_WORLDMATRIX(45)              */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(45)),         NULL                },
4628     { /*302, WINED3DTS_WORLDMATRIX(46)              */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(46)),         NULL                },
4629     { /*303, WINED3DTS_WORLDMATRIX(47)              */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(47)),         NULL                },
4630     { /*304, WINED3DTS_WORLDMATRIX(48)              */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(48)),         NULL                },
4631     { /*305, WINED3DTS_WORLDMATRIX(49)              */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(49)),         NULL                },
4632     { /*306, WINED3DTS_WORLDMATRIX(50)              */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(50)),         NULL                },
4633     { /*307, WINED3DTS_WORLDMATRIX(51)              */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(51)),         NULL                },
4634     { /*308, WINED3DTS_WORLDMATRIX(52)              */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(52)),         NULL                },
4635     { /*309, WINED3DTS_WORLDMATRIX(53)              */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(53)),         NULL                },
4636     { /*310, WINED3DTS_WORLDMATRIX(54)              */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(54)),         NULL                },
4637     { /*311, WINED3DTS_WORLDMATRIX(55)              */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(55)),         NULL                },
4638     { /*312, WINED3DTS_WORLDMATRIX(56)              */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(56)),         NULL                },
4639     { /*313, WINED3DTS_WORLDMATRIX(57)              */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(57)),         NULL                },
4640     { /*314, WINED3DTS_WORLDMATRIX(58)              */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(58)),         NULL                },
4641     { /*315, WINED3DTS_WORLDMATRIX(59)              */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(59)),         NULL                },
4642     { /*316, WINED3DTS_WORLDMATRIX(60)              */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(60)),         NULL                },
4643     { /*317, WINED3DTS_WORLDMATRIX(61)              */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(61)),         NULL                },
4644     { /*318, WINED3DTS_WORLDMATRIX(62)              */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(62)),         NULL                },
4645     { /*319, WINED3DTS_WORLDMATRIX(63)              */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(63)),         NULL                },
4646     { /*320, WINED3DTS_WORLDMATRIX(64)              */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(64)),         NULL                },
4647     { /*321, WINED3DTS_WORLDMATRIX(65)              */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(65)),         NULL                },
4648     { /*322, WINED3DTS_WORLDMATRIX(66)              */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(66)),         NULL                },
4649     { /*323, WINED3DTS_WORLDMATRIX(67)              */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(67)),         NULL                },
4650     { /*324, WINED3DTS_WORLDMATRIX(68)              */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(68)),         NULL                },
4651     { /*325, WINED3DTS_WORLDMATRIX(68)              */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(69)),         NULL                },
4652     { /*326, WINED3DTS_WORLDMATRIX(70)              */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(70)),         NULL                },
4653     { /*327, WINED3DTS_WORLDMATRIX(71)              */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(71)),         NULL                },
4654     { /*328, WINED3DTS_WORLDMATRIX(72)              */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(72)),         NULL                },
4655     { /*329, WINED3DTS_WORLDMATRIX(73)              */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(73)),         NULL                },
4656     { /*330, WINED3DTS_WORLDMATRIX(74)              */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(74)),         NULL                },
4657     { /*331, WINED3DTS_WORLDMATRIX(75)              */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(75)),         NULL                },
4658     { /*332, WINED3DTS_WORLDMATRIX(76)              */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(76)),         NULL                },
4659     { /*333, WINED3DTS_WORLDMATRIX(77)              */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(77)),         NULL                },
4660     { /*334, WINED3DTS_WORLDMATRIX(78)              */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(78)),         NULL                },
4661     { /*335, WINED3DTS_WORLDMATRIX(79)              */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(79)),         NULL                },
4662     { /*336, WINED3DTS_WORLDMATRIX(80)              */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(80)),         NULL                },
4663     { /*337, WINED3DTS_WORLDMATRIX(81)              */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(81)),         NULL                },
4664     { /*338, WINED3DTS_WORLDMATRIX(82)              */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(82)),         NULL                },
4665     { /*339, WINED3DTS_WORLDMATRIX(83)              */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(83)),         NULL                },
4666     { /*340, WINED3DTS_WORLDMATRIX(84)              */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(84)),         NULL                },
4667     { /*341, WINED3DTS_WORLDMATRIX(85)              */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(85)),         NULL                },
4668     { /*341, WINED3DTS_WORLDMATRIX(86)              */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(86)),         NULL                },
4669     { /*343, WINED3DTS_WORLDMATRIX(87)              */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(87)),         NULL                },
4670     { /*344, WINED3DTS_WORLDMATRIX(88)              */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(88)),         NULL                },
4671     { /*345, WINED3DTS_WORLDMATRIX(89)              */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(89)),         NULL                },
4672     { /*346, WINED3DTS_WORLDMATRIX(90)              */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(90)),         NULL                },
4673     { /*347, WINED3DTS_WORLDMATRIX(91)              */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(91)),         NULL                },
4674     { /*348, WINED3DTS_WORLDMATRIX(92)              */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(92)),         NULL                },
4675     { /*349, WINED3DTS_WORLDMATRIX(93)              */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(93)),         NULL                },
4676     { /*350, WINED3DTS_WORLDMATRIX(94)              */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(94)),         NULL                },
4677     { /*351, WINED3DTS_WORLDMATRIX(95)              */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(95)),         NULL                },
4678     { /*352, WINED3DTS_WORLDMATRIX(96)              */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(96)),         NULL                },
4679     { /*353, WINED3DTS_WORLDMATRIX(97)              */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(97)),         NULL                },
4680     { /*354, WINED3DTS_WORLDMATRIX(98)              */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(98)),         NULL                },
4681     { /*355, WINED3DTS_WORLDMATRIX(99)              */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(99)),         NULL                },
4682     { /*356, WINED3DTS_WORLDMATRIX(100)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(100)),        NULL                },
4683     { /*357, WINED3DTS_WORLDMATRIX(101)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(101)),        NULL                },
4684     { /*358, WINED3DTS_WORLDMATRIX(102)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(102)),        NULL                },
4685     { /*359, WINED3DTS_WORLDMATRIX(103)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(103)),        NULL                },
4686     { /*360, WINED3DTS_WORLDMATRIX(104)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(104)),        NULL                },
4687     { /*361, WINED3DTS_WORLDMATRIX(105)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(105)),        NULL                },
4688     { /*362, WINED3DTS_WORLDMATRIX(106)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(106)),        NULL                },
4689     { /*363, WINED3DTS_WORLDMATRIX(107)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(107)),        NULL                },
4690     { /*364, WINED3DTS_WORLDMATRIX(108)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(108)),        NULL                },
4691     { /*365, WINED3DTS_WORLDMATRIX(109)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(109)),        NULL                },
4692     { /*366, WINED3DTS_WORLDMATRIX(110)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(110)),        NULL                },
4693     { /*367, WINED3DTS_WORLDMATRIX(111)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(111)),        NULL                },
4694     { /*368, WINED3DTS_WORLDMATRIX(112)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(112)),        NULL                },
4695     { /*369, WINED3DTS_WORLDMATRIX(113)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(113)),        NULL                },
4696     { /*370, WINED3DTS_WORLDMATRIX(114)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(114)),        NULL                },
4697     { /*371, WINED3DTS_WORLDMATRIX(115)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(115)),        NULL                },
4698     { /*372, WINED3DTS_WORLDMATRIX(116)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(116)),        NULL                },
4699     { /*373, WINED3DTS_WORLDMATRIX(117)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(117)),        NULL                },
4700     { /*374, WINED3DTS_WORLDMATRIX(118)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(118)),        NULL                },
4701     { /*375, WINED3DTS_WORLDMATRIX(119)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(119)),        NULL                },
4702     { /*376, WINED3DTS_WORLDMATRIX(120)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(120)),        NULL                },
4703     { /*377, WINED3DTS_WORLDMATRIX(121)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(121)),        NULL                },
4704     { /*378, WINED3DTS_WORLDMATRIX(122)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(122)),        NULL                },
4705     { /*379, WINED3DTS_WORLDMATRIX(123)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(123)),        NULL                },
4706     { /*380, WINED3DTS_WORLDMATRIX(124)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(124)),        NULL                },
4707     { /*381, WINED3DTS_WORLDMATRIX(125)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(125)),        NULL                },
4708     { /*382, WINED3DTS_WORLDMATRIX(126)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(126)),        NULL                },
4709     { /*383, WINED3DTS_WORLDMATRIX(127)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(127)),        NULL                },
4710     { /*384, WINED3DTS_WORLDMATRIX(128)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(128)),        NULL                },
4711     { /*385, WINED3DTS_WORLDMATRIX(129)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(129)),        NULL                },
4712     { /*386, WINED3DTS_WORLDMATRIX(130)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(130)),        NULL                },
4713     { /*387, WINED3DTS_WORLDMATRIX(131)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(131)),        NULL                },
4714     { /*388, WINED3DTS_WORLDMATRIX(132)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(132)),        NULL                },
4715     { /*389, WINED3DTS_WORLDMATRIX(133)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(133)),        NULL                },
4716     { /*390, WINED3DTS_WORLDMATRIX(134)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(134)),        NULL                },
4717     { /*391, WINED3DTS_WORLDMATRIX(135)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(135)),        NULL                },
4718     { /*392, WINED3DTS_WORLDMATRIX(136)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(136)),        NULL                },
4719     { /*393, WINED3DTS_WORLDMATRIX(137)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(137)),        NULL                },
4720     { /*394, WINED3DTS_WORLDMATRIX(138)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(138)),        NULL                },
4721     { /*395, WINED3DTS_WORLDMATRIX(139)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(139)),        NULL                },
4722     { /*396, WINED3DTS_WORLDMATRIX(140)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(140)),        NULL                },
4723     { /*397, WINED3DTS_WORLDMATRIX(141)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(141)),        NULL                },
4724     { /*398, WINED3DTS_WORLDMATRIX(142)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(142)),        NULL                },
4725     { /*399, WINED3DTS_WORLDMATRIX(143)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(143)),        NULL                },
4726     { /*400, WINED3DTS_WORLDMATRIX(144)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(144)),        NULL                },
4727     { /*401, WINED3DTS_WORLDMATRIX(145)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(145)),        NULL                },
4728     { /*402, WINED3DTS_WORLDMATRIX(146)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(146)),        NULL                },
4729     { /*403, WINED3DTS_WORLDMATRIX(147)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(147)),        NULL                },
4730     { /*404, WINED3DTS_WORLDMATRIX(148)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(148)),        NULL                },
4731     { /*405, WINED3DTS_WORLDMATRIX(149)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(149)),        NULL                },
4732     { /*406, WINED3DTS_WORLDMATRIX(150)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(150)),        NULL                },
4733     { /*407, WINED3DTS_WORLDMATRIX(151)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(151)),        NULL                },
4734     { /*408, WINED3DTS_WORLDMATRIX(152)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(152)),        NULL                },
4735     { /*409, WINED3DTS_WORLDMATRIX(153)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(153)),        NULL                },
4736     { /*410, WINED3DTS_WORLDMATRIX(154)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(154)),        NULL                },
4737     { /*411, WINED3DTS_WORLDMATRIX(155)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(155)),        NULL                },
4738     { /*412, WINED3DTS_WORLDMATRIX(156)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(156)),        NULL                },
4739     { /*413, WINED3DTS_WORLDMATRIX(157)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(157)),        NULL                },
4740     { /*414, WINED3DTS_WORLDMATRIX(158)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(158)),        NULL                },
4741     { /*415, WINED3DTS_WORLDMATRIX(159)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(159)),        NULL                },
4742     { /*416, WINED3DTS_WORLDMATRIX(160)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(160)),        NULL                },
4743     { /*417, WINED3DTS_WORLDMATRIX(161)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(161)),        NULL                },
4744     { /*418, WINED3DTS_WORLDMATRIX(162)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(162)),        NULL                },
4745     { /*419, WINED3DTS_WORLDMATRIX(163)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(163)),        NULL                },
4746     { /*420, WINED3DTS_WORLDMATRIX(164)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(164)),        NULL                },
4747     { /*421, WINED3DTS_WORLDMATRIX(165)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(165)),        NULL                },
4748     { /*422, WINED3DTS_WORLDMATRIX(166)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(166)),        NULL                },
4749     { /*423, WINED3DTS_WORLDMATRIX(167)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(167)),        NULL                },
4750     { /*424, WINED3DTS_WORLDMATRIX(168)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(168)),        NULL                },
4751     { /*425, WINED3DTS_WORLDMATRIX(168)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(169)),        NULL                },
4752     { /*426, WINED3DTS_WORLDMATRIX(170)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(170)),        NULL                },
4753     { /*427, WINED3DTS_WORLDMATRIX(171)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(171)),        NULL                },
4754     { /*428, WINED3DTS_WORLDMATRIX(172)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(172)),        NULL                },
4755     { /*429, WINED3DTS_WORLDMATRIX(173)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(173)),        NULL                },
4756     { /*430, WINED3DTS_WORLDMATRIX(174)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(174)),        NULL                },
4757     { /*431, WINED3DTS_WORLDMATRIX(175)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(175)),        NULL                },
4758     { /*432, WINED3DTS_WORLDMATRIX(176)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(176)),        NULL                },
4759     { /*433, WINED3DTS_WORLDMATRIX(177)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(177)),        NULL                },
4760     { /*434, WINED3DTS_WORLDMATRIX(178)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(178)),        NULL                },
4761     { /*435, WINED3DTS_WORLDMATRIX(179)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(179)),        NULL                },
4762     { /*436, WINED3DTS_WORLDMATRIX(180)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(180)),        NULL                },
4763     { /*437, WINED3DTS_WORLDMATRIX(181)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(181)),        NULL                },
4764     { /*438, WINED3DTS_WORLDMATRIX(182)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(182)),        NULL                },
4765     { /*439, WINED3DTS_WORLDMATRIX(183)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(183)),        NULL                },
4766     { /*440, WINED3DTS_WORLDMATRIX(184)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(184)),        NULL                },
4767     { /*441, WINED3DTS_WORLDMATRIX(185)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(185)),        NULL                },
4768     { /*441, WINED3DTS_WORLDMATRIX(186)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(186)),        NULL                },
4769     { /*443, WINED3DTS_WORLDMATRIX(187)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(187)),        NULL                },
4770     { /*444, WINED3DTS_WORLDMATRIX(188)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(188)),        NULL                },
4771     { /*445, WINED3DTS_WORLDMATRIX(189)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(189)),        NULL                },
4772     { /*446, WINED3DTS_WORLDMATRIX(190)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(190)),        NULL                },
4773     { /*447, WINED3DTS_WORLDMATRIX(191)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(191)),        NULL                },
4774     { /*448, WINED3DTS_WORLDMATRIX(192)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(192)),        NULL                },
4775     { /*449, WINED3DTS_WORLDMATRIX(193)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(193)),        NULL                },
4776     { /*450, WINED3DTS_WORLDMATRIX(194)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(194)),        NULL                },
4777     { /*451, WINED3DTS_WORLDMATRIX(195)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(195)),        NULL                },
4778     { /*452, WINED3DTS_WORLDMATRIX(196)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(196)),        NULL                },
4779     { /*453, WINED3DTS_WORLDMATRIX(197)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(197)),        NULL                },
4780     { /*454, WINED3DTS_WORLDMATRIX(198)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(198)),        NULL                },
4781     { /*455, WINED3DTS_WORLDMATRIX(199)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(199)),        NULL                },
4782     { /*356, WINED3DTS_WORLDMATRIX(200)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(200)),        NULL                },
4783     { /*457, WINED3DTS_WORLDMATRIX(201)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(201)),        NULL                },
4784     { /*458, WINED3DTS_WORLDMATRIX(202)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(202)),        NULL                },
4785     { /*459, WINED3DTS_WORLDMATRIX(203)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(203)),        NULL                },
4786     { /*460, WINED3DTS_WORLDMATRIX(204)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(204)),        NULL                },
4787     { /*461, WINED3DTS_WORLDMATRIX(205)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(205)),        NULL                },
4788     { /*462, WINED3DTS_WORLDMATRIX(206)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(206)),        NULL                },
4789     { /*463, WINED3DTS_WORLDMATRIX(207)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(207)),        NULL                },
4790     { /*464, WINED3DTS_WORLDMATRIX(208)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(208)),        NULL                },
4791     { /*465, WINED3DTS_WORLDMATRIX(209)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(209)),        NULL                },
4792     { /*466, WINED3DTS_WORLDMATRIX(210)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(210)),        NULL                },
4793     { /*467, WINED3DTS_WORLDMATRIX(211)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(211)),        NULL                },
4794     { /*468, WINED3DTS_WORLDMATRIX(212)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(212)),        NULL                },
4795     { /*469, WINED3DTS_WORLDMATRIX(213)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(213)),        NULL                },
4796     { /*470, WINED3DTS_WORLDMATRIX(214)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(214)),        NULL                },
4797     { /*471, WINED3DTS_WORLDMATRIX(215)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(215)),        NULL                },
4798     { /*472, WINED3DTS_WORLDMATRIX(216)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(216)),        NULL                },
4799     { /*473, WINED3DTS_WORLDMATRIX(217)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(217)),        NULL                },
4800     { /*474, WINED3DTS_WORLDMATRIX(218)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(218)),        NULL                },
4801     { /*475, WINED3DTS_WORLDMATRIX(219)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(219)),        NULL                },
4802     { /*476, WINED3DTS_WORLDMATRIX(220)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(220)),        NULL                },
4803     { /*477, WINED3DTS_WORLDMATRIX(221)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(221)),        NULL                },
4804     { /*478, WINED3DTS_WORLDMATRIX(222)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(222)),        NULL                },
4805     { /*479, WINED3DTS_WORLDMATRIX(223)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(223)),        NULL                },
4806     { /*480, WINED3DTS_WORLDMATRIX(224)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(224)),        NULL                },
4807     { /*481, WINED3DTS_WORLDMATRIX(225)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(225)),        NULL                },
4808     { /*482, WINED3DTS_WORLDMATRIX(226)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(226)),        NULL                },
4809     { /*483, WINED3DTS_WORLDMATRIX(227)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(227)),        NULL                },
4810     { /*484, WINED3DTS_WORLDMATRIX(228)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(228)),        NULL                },
4811     { /*485, WINED3DTS_WORLDMATRIX(229)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(229)),        NULL                },
4812     { /*486, WINED3DTS_WORLDMATRIX(230)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(230)),        NULL                },
4813     { /*487, WINED3DTS_WORLDMATRIX(231)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(231)),        NULL                },
4814     { /*488, WINED3DTS_WORLDMATRIX(232)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(232)),        NULL                },
4815     { /*489, WINED3DTS_WORLDMATRIX(233)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(233)),        NULL                },
4816     { /*490, WINED3DTS_WORLDMATRIX(234)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(234)),        NULL                },
4817     { /*491, WINED3DTS_WORLDMATRIX(235)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(235)),        NULL                },
4818     { /*492, WINED3DTS_WORLDMATRIX(236)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(236)),        NULL                },
4819     { /*493, WINED3DTS_WORLDMATRIX(237)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(237)),        NULL                },
4820     { /*494, WINED3DTS_WORLDMATRIX(238)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(238)),        NULL                },
4821     { /*495, WINED3DTS_WORLDMATRIX(239)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(239)),        NULL                },
4822     { /*496, WINED3DTS_WORLDMATRIX(240)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(240)),        NULL                },
4823     { /*497, WINED3DTS_WORLDMATRIX(241)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(241)),        NULL                },
4824     { /*498, WINED3DTS_WORLDMATRIX(242)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(242)),        NULL                },
4825     { /*499, WINED3DTS_WORLDMATRIX(243)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(243)),        NULL                },
4826     { /*500, WINED3DTS_WORLDMATRIX(244)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(244)),        NULL                },
4827     { /*501, WINED3DTS_WORLDMATRIX(245)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(245)),        NULL                },
4828     { /*502, WINED3DTS_WORLDMATRIX(246)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(246)),        NULL                },
4829     { /*503, WINED3DTS_WORLDMATRIX(247)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(247)),        NULL                },
4830     { /*504, WINED3DTS_WORLDMATRIX(248)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(248)),        NULL                },
4831     { /*505, WINED3DTS_WORLDMATRIX(249)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(249)),        NULL                },
4832     { /*506, WINED3DTS_WORLDMATRIX(250)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(250)),        NULL                },
4833     { /*507, WINED3DTS_WORLDMATRIX(251)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(251)),        NULL                },
4834     { /*508, WINED3DTS_WORLDMATRIX(252)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(252)),        NULL                },
4835     { /*509, WINED3DTS_WORLDMATRIX(253)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(253)),        NULL                },
4836     { /*510, WINED3DTS_WORLDMATRIX(254)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(254)),        NULL                },
4837     { /*511, WINED3DTS_WORLDMATRIX(255)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(255)),        NULL                },
4838       /* Various Vertex states follow */
4839     { /*   , STATE_STREAMSRC                        */      STATE_VDECL,                                        NULL                },
4840     { /*   , STATE_INDEXBUFFER                      */      STATE_INDEXBUFFER,                                  NULL                },
4841     { /*   , STATE_VDECL                            */      STATE_VDECL,                                        NULL                },
4842     { /*   , STATE_VSHADER                          */      STATE_VDECL,                                        NULL                },
4843     { /*   , STATE_VIEWPORT                         */      STATE_VIEWPORT,                                     NULL                },
4844     { /*   , STATE_VERTEXSHADERCONSTANT             */      STATE_VERTEXSHADERCONSTANT,                         NULL                },
4845     { /*   , STATE_PIXELSHADERCONSTANT              */      STATE_VERTEXSHADERCONSTANT,                         NULL                },
4846       /* Lights */
4847     { /*   , STATE_ACTIVELIGHT(0)                   */      STATE_ACTIVELIGHT(0),                               NULL                },
4848     { /*   , STATE_ACTIVELIGHT(1)                   */      STATE_ACTIVELIGHT(1),                               NULL                },
4849     { /*   , STATE_ACTIVELIGHT(2)                   */      STATE_ACTIVELIGHT(2),                               NULL                },
4850     { /*   , STATE_ACTIVELIGHT(3)                   */      STATE_ACTIVELIGHT(3),                               NULL                },
4851     { /*   , STATE_ACTIVELIGHT(4)                   */      STATE_ACTIVELIGHT(4),                               NULL                },
4852     { /*   , STATE_ACTIVELIGHT(5)                   */      STATE_ACTIVELIGHT(5),                               NULL                },
4853     { /*   , STATE_ACTIVELIGHT(6)                   */      STATE_ACTIVELIGHT(6),                               NULL                },
4854     { /*   , STATE_ACTIVELIGHT(7)                   */      STATE_ACTIVELIGHT(7),                               NULL                },
4855
4856     { /* Scissor rect                               */      STATE_SCISSORRECT,                                  NULL                },
4857       /* Clip planes */
4858     { /* STATE_CLIPPLANE(0)                         */      STATE_CLIPPLANE(0),                                 NULL                },
4859     { /* STATE_CLIPPLANE(1)                         */      STATE_CLIPPLANE(1),                                 NULL                },
4860     { /* STATE_CLIPPLANE(2)                         */      STATE_CLIPPLANE(2),                                 NULL                },
4861     { /* STATE_CLIPPLANE(3)                         */      STATE_CLIPPLANE(3),                                 NULL                },
4862     { /* STATE_CLIPPLANE(4)                         */      STATE_CLIPPLANE(4),                                 NULL                },
4863     { /* STATE_CLIPPLANE(5)                         */      STATE_CLIPPLANE(5),                                 NULL                },
4864     { /* STATE_CLIPPLANE(6)                         */      STATE_CLIPPLANE(6),                                 NULL                },
4865     { /* STATE_CLIPPLANE(7)                         */      STATE_CLIPPLANE(7),                                 NULL                },
4866     { /* STATE_CLIPPLANE(8)                         */      STATE_CLIPPLANE(8),                                 NULL                },
4867     { /* STATE_CLIPPLANE(9)                         */      STATE_CLIPPLANE(9),                                 NULL                },
4868     { /* STATE_CLIPPLANE(10)                        */      STATE_CLIPPLANE(10),                                NULL                },
4869     { /* STATE_CLIPPLANE(11)                        */      STATE_CLIPPLANE(11),                                NULL                },
4870     { /* STATE_CLIPPLANE(12)                        */      STATE_CLIPPLANE(12),                                NULL                },
4871     { /* STATE_CLIPPLANE(13)                        */      STATE_CLIPPLANE(13),                                NULL                },
4872     { /* STATE_CLIPPLANE(14)                        */      STATE_CLIPPLANE(14),                                NULL                },
4873     { /* STATE_CLIPPLANE(15)                        */      STATE_CLIPPLANE(15),                                NULL                },
4874     { /* STATE_CLIPPLANE(16)                        */      STATE_CLIPPLANE(16),                                NULL                },
4875     { /* STATE_CLIPPLANE(17)                        */      STATE_CLIPPLANE(17),                                NULL                },
4876     { /* STATE_CLIPPLANE(18)                        */      STATE_CLIPPLANE(18),                                NULL                },
4877     { /* STATE_CLIPPLANE(19)                        */      STATE_CLIPPLANE(19),                                NULL                },
4878     { /* STATE_CLIPPLANE(20)                        */      STATE_CLIPPLANE(20),                                NULL                },
4879     { /* STATE_CLIPPLANE(21)                        */      STATE_CLIPPLANE(21),                                NULL                },
4880     { /* STATE_CLIPPLANE(22)                        */      STATE_CLIPPLANE(22),                                NULL                },
4881     { /* STATE_CLIPPLANE(23)                        */      STATE_CLIPPLANE(23),                                NULL                },
4882     { /* STATE_CLIPPLANE(24)                        */      STATE_CLIPPLANE(24),                                NULL                },
4883     { /* STATE_CLIPPLANE(25)                        */      STATE_CLIPPLANE(25),                                NULL                },
4884     { /* STATE_CLIPPLANE(26)                        */      STATE_CLIPPLANE(26),                                NULL                },
4885     { /* STATE_CLIPPLANE(27)                        */      STATE_CLIPPLANE(27),                                NULL                },
4886     { /* STATE_CLIPPLANE(28)                        */      STATE_CLIPPLANE(28),                                NULL                },
4887     { /* STATE_CLIPPLANE(29)                        */      STATE_CLIPPLANE(29),                                NULL                },
4888     { /* STATE_CLIPPLANE(30)                        */      STATE_CLIPPLANE(30),                                NULL                },
4889     { /* STATE_CLIPPLANE(31)                        */      STATE_CLIPPLANE(31),                                NULL                },
4890
4891     { /* STATE_MATERIAL                             */      STATE_RENDER(WINED3DRS_SPECULARENABLE),             NULL                },
4892     { /* STATE_FRONTFACE                            */      STATE_FRONTFACE,                                    NULL                },
4893 };
4894
4895 const struct StateEntryTemplate misc_state_template[] = {
4896     { STATE_RENDER(WINED3DRS_SRCBLEND),                   { STATE_RENDER(WINED3DRS_ALPHABLENDENABLE),           state_blend         }},
4897     { STATE_RENDER(WINED3DRS_DESTBLEND),                  { STATE_RENDER(WINED3DRS_ALPHABLENDENABLE),           state_blend         }},
4898     { STATE_RENDER(WINED3DRS_ALPHABLENDENABLE),           { STATE_RENDER(WINED3DRS_ALPHABLENDENABLE),           state_blend         }},
4899     { STATE_RENDER(WINED3DRS_EDGEANTIALIAS),              { STATE_RENDER(WINED3DRS_ALPHABLENDENABLE),           state_blend         }},
4900     { STATE_RENDER(WINED3DRS_ANTIALIASEDLINEENABLE),      { STATE_RENDER(WINED3DRS_ALPHABLENDENABLE),           state_blend         }},
4901     { STATE_RENDER(WINED3DRS_SEPARATEALPHABLENDENABLE),   { STATE_RENDER(WINED3DRS_ALPHABLENDENABLE),           state_blend         }},
4902     { STATE_RENDER(WINED3DRS_SRCBLENDALPHA),              { STATE_RENDER(WINED3DRS_ALPHABLENDENABLE),           state_blend         }},
4903     { STATE_RENDER(WINED3DRS_DESTBLENDALPHA),             { STATE_RENDER(WINED3DRS_ALPHABLENDENABLE),           state_blend         }},
4904     { STATE_RENDER(WINED3DRS_DESTBLENDALPHA),             { STATE_RENDER(WINED3DRS_ALPHABLENDENABLE),           state_blend         }},
4905     { STATE_RENDER(WINED3DRS_BLENDOPALPHA),               { STATE_RENDER(WINED3DRS_ALPHABLENDENABLE),           state_blend         }},
4906     { STATE_STREAMSRC,                                    { STATE_VDECL,                                        streamsrc           }},
4907     { STATE_VDECL,                                        { STATE_VDECL,                                        streamsrc           }},
4908     { STATE_FRONTFACE,                                    { STATE_FRONTFACE,                                    frontface           }},
4909     { STATE_SCISSORRECT,                                  { STATE_SCISSORRECT,                                  scissorrect         }},
4910     /* TODO: Move shader constant loading to vertex and fragment pipeline repectively, as soon as the pshader and
4911      * vshader loadings are untied from each other
4912      */
4913     { STATE_VERTEXSHADERCONSTANT,                         { STATE_VERTEXSHADERCONSTANT,                         shaderconstant      }},
4914     { STATE_PIXELSHADERCONSTANT,                          { STATE_VERTEXSHADERCONSTANT,                         shaderconstant      }},
4915
4916     { STATE_VIEWPORT,                                     { STATE_VIEWPORT,                                     viewport_miscpart   }},
4917     { STATE_INDEXBUFFER,                                  { STATE_INDEXBUFFER,                                  indexbuffer         }},
4918     { STATE_RENDER(WINED3DRS_ANTIALIAS),                  { STATE_RENDER(WINED3DRS_ANTIALIAS),                  state_antialias     }},
4919     { STATE_RENDER(WINED3DRS_TEXTUREPERSPECTIVE),         { STATE_RENDER(WINED3DRS_TEXTUREPERSPECTIVE),         state_perspective   }},
4920     { STATE_RENDER(WINED3DRS_ZENABLE),                    { STATE_RENDER(WINED3DRS_ZENABLE),                    state_zenable       }},
4921     { STATE_RENDER(WINED3DRS_WRAPU),                      { STATE_RENDER(WINED3DRS_WRAPU),                      state_wrapu         }},
4922     { STATE_RENDER(WINED3DRS_WRAPV),                      { STATE_RENDER(WINED3DRS_WRAPV),                      state_wrapv         }},
4923     { STATE_RENDER(WINED3DRS_FILLMODE),                   { STATE_RENDER(WINED3DRS_FILLMODE),                   state_fillmode      }},
4924     { STATE_RENDER(WINED3DRS_SHADEMODE),                  { STATE_RENDER(WINED3DRS_SHADEMODE),                  state_shademode     }},
4925     { STATE_RENDER(WINED3DRS_LINEPATTERN),                { STATE_RENDER(WINED3DRS_LINEPATTERN),                state_linepattern   }},
4926     { STATE_RENDER(WINED3DRS_MONOENABLE),                 { STATE_RENDER(WINED3DRS_MONOENABLE),                 state_monoenable    }},
4927     { STATE_RENDER(WINED3DRS_ROP2),                       { STATE_RENDER(WINED3DRS_ROP2),                       state_rop2          }},
4928     { STATE_RENDER(WINED3DRS_PLANEMASK),                  { STATE_RENDER(WINED3DRS_PLANEMASK),                  state_planemask     }},
4929     { STATE_RENDER(WINED3DRS_ZWRITEENABLE),               { STATE_RENDER(WINED3DRS_ZWRITEENABLE),               state_zwritenable   }},
4930     { STATE_RENDER(WINED3DRS_ALPHATESTENABLE),            { STATE_RENDER(WINED3DRS_ALPHATESTENABLE),            state_alpha         }},
4931     { STATE_RENDER(WINED3DRS_ALPHAREF),                   { STATE_RENDER(WINED3DRS_ALPHATESTENABLE),            state_alpha         }},
4932     { STATE_RENDER(WINED3DRS_ALPHAFUNC),                  { STATE_RENDER(WINED3DRS_ALPHATESTENABLE),            state_alpha         }},
4933     { STATE_RENDER(WINED3DRS_COLORKEYENABLE),             { STATE_RENDER(WINED3DRS_ALPHATESTENABLE),            state_alpha         }},
4934     { STATE_RENDER(WINED3DRS_LASTPIXEL),                  { STATE_RENDER(WINED3DRS_LASTPIXEL),                  state_lastpixel     }},
4935     { STATE_RENDER(WINED3DRS_CULLMODE),                   { STATE_RENDER(WINED3DRS_CULLMODE),                   state_cullmode      }},
4936     { STATE_RENDER(WINED3DRS_ZFUNC),                      { STATE_RENDER(WINED3DRS_ZFUNC),                      state_zfunc         }},
4937     { STATE_RENDER(WINED3DRS_DITHERENABLE),               { STATE_RENDER(WINED3DRS_DITHERENABLE),               state_ditherenable  }},
4938     { STATE_RENDER(WINED3DRS_SUBPIXEL),                   { STATE_RENDER(WINED3DRS_SUBPIXEL),                   state_subpixel      }},
4939     { STATE_RENDER(WINED3DRS_SUBPIXELX),                  { STATE_RENDER(WINED3DRS_SUBPIXELX),                  state_subpixelx     }},
4940     { STATE_RENDER(WINED3DRS_STIPPLEDALPHA),              { STATE_RENDER(WINED3DRS_STIPPLEDALPHA),              state_stippledalpha }},
4941     { STATE_RENDER(WINED3DRS_ZBIAS),                      { STATE_RENDER(WINED3DRS_ZBIAS),                      state_zbias         }},
4942     { STATE_RENDER(WINED3DRS_STIPPLEENABLE),              { STATE_RENDER(WINED3DRS_STIPPLEENABLE),              state_stippleenable }},
4943     { STATE_RENDER(WINED3DRS_MIPMAPLODBIAS),              { STATE_RENDER(WINED3DRS_MIPMAPLODBIAS),              state_mipmaplodbias }},
4944     { STATE_RENDER(WINED3DRS_ANISOTROPY),                 { STATE_RENDER(WINED3DRS_ANISOTROPY),                 state_anisotropy    }},
4945     { STATE_RENDER(WINED3DRS_FLUSHBATCH),                 { STATE_RENDER(WINED3DRS_FLUSHBATCH),                 state_flushbatch    }},
4946     { STATE_RENDER(WINED3DRS_TRANSLUCENTSORTINDEPENDENT), { STATE_RENDER(WINED3DRS_TRANSLUCENTSORTINDEPENDENT), state_translucentsi }},
4947     { STATE_RENDER(WINED3DRS_STENCILENABLE),              { STATE_RENDER(WINED3DRS_STENCILENABLE),              state_stencil       }},
4948     { STATE_RENDER(WINED3DRS_STENCILFAIL),                { STATE_RENDER(WINED3DRS_STENCILENABLE),              state_stencil       }},
4949     { STATE_RENDER(WINED3DRS_STENCILZFAIL),               { STATE_RENDER(WINED3DRS_STENCILENABLE),              state_stencil       }},
4950     { STATE_RENDER(WINED3DRS_STENCILPASS),                { STATE_RENDER(WINED3DRS_STENCILENABLE),              state_stencil       }},
4951     { STATE_RENDER(WINED3DRS_STENCILFUNC),                { STATE_RENDER(WINED3DRS_STENCILENABLE),              state_stencil       }},
4952     { STATE_RENDER(WINED3DRS_STENCILREF),                 { STATE_RENDER(WINED3DRS_STENCILENABLE),              state_stencil       }},
4953     { STATE_RENDER(WINED3DRS_STENCILMASK),                { STATE_RENDER(WINED3DRS_STENCILENABLE),              state_stencil       }},
4954     { STATE_RENDER(WINED3DRS_STENCILWRITEMASK),           { STATE_RENDER(WINED3DRS_STENCILWRITEMASK),           state_stencilwrite  }},
4955     { STATE_RENDER(WINED3DRS_TWOSIDEDSTENCILMODE),        { STATE_RENDER(WINED3DRS_STENCILENABLE),              state_stencil       }},
4956     { STATE_RENDER(WINED3DRS_CCW_STENCILFAIL),            { STATE_RENDER(WINED3DRS_STENCILENABLE),              state_stencil       }},
4957     { STATE_RENDER(WINED3DRS_CCW_STENCILZFAIL),           { STATE_RENDER(WINED3DRS_STENCILENABLE),              state_stencil       }},
4958     { STATE_RENDER(WINED3DRS_CCW_STENCILPASS),            { STATE_RENDER(WINED3DRS_STENCILENABLE),              state_stencil       }},
4959     { STATE_RENDER(WINED3DRS_CCW_STENCILFUNC),            { STATE_RENDER(WINED3DRS_STENCILENABLE),              state_stencil       }},
4960     {0 /* Terminate */,                                   { 0,                                                  0                   }},
4961 };
4962
4963 const struct StateEntryTemplate ffp_vertexstate_template[] = {
4964     { STATE_VDECL,                                        { STATE_VDECL,                                        vertexdeclaration   }},
4965     { STATE_VSHADER,                                      { STATE_VDECL,                                        vertexdeclaration   }},
4966     { STATE_MATERIAL,                                     { STATE_RENDER(WINED3DRS_SPECULARENABLE),             state_specularenable}},
4967     { STATE_RENDER(WINED3DRS_SPECULARENABLE),             { STATE_RENDER(WINED3DRS_SPECULARENABLE),             state_specularenable}},
4968       /* Clip planes */
4969     { STATE_CLIPPLANE(0),                                 { STATE_CLIPPLANE(0),                                 clipplane           }},
4970     { STATE_CLIPPLANE(1),                                 { STATE_CLIPPLANE(1),                                 clipplane           }},
4971     { STATE_CLIPPLANE(2),                                 { STATE_CLIPPLANE(2),                                 clipplane           }},
4972     { STATE_CLIPPLANE(3),                                 { STATE_CLIPPLANE(3),                                 clipplane           }},
4973     { STATE_CLIPPLANE(4),                                 { STATE_CLIPPLANE(4),                                 clipplane           }},
4974     { STATE_CLIPPLANE(5),                                 { STATE_CLIPPLANE(5),                                 clipplane           }},
4975     { STATE_CLIPPLANE(6),                                 { STATE_CLIPPLANE(6),                                 clipplane           }},
4976     { STATE_CLIPPLANE(7),                                 { STATE_CLIPPLANE(7),                                 clipplane           }},
4977     { STATE_CLIPPLANE(8),                                 { STATE_CLIPPLANE(8),                                 clipplane           }},
4978     { STATE_CLIPPLANE(9),                                 { STATE_CLIPPLANE(9),                                 clipplane           }},
4979     { STATE_CLIPPLANE(10),                                { STATE_CLIPPLANE(10),                                clipplane           }},
4980     { STATE_CLIPPLANE(11),                                { STATE_CLIPPLANE(11),                                clipplane           }},
4981     { STATE_CLIPPLANE(12),                                { STATE_CLIPPLANE(12),                                clipplane           }},
4982     { STATE_CLIPPLANE(13),                                { STATE_CLIPPLANE(13),                                clipplane           }},
4983     { STATE_CLIPPLANE(14),                                { STATE_CLIPPLANE(14),                                clipplane           }},
4984     { STATE_CLIPPLANE(15),                                { STATE_CLIPPLANE(15),                                clipplane           }},
4985     { STATE_CLIPPLANE(16),                                { STATE_CLIPPLANE(16),                                clipplane           }},
4986     { STATE_CLIPPLANE(17),                                { STATE_CLIPPLANE(17),                                clipplane           }},
4987     { STATE_CLIPPLANE(18),                                { STATE_CLIPPLANE(18),                                clipplane           }},
4988     { STATE_CLIPPLANE(19),                                { STATE_CLIPPLANE(19),                                clipplane           }},
4989     { STATE_CLIPPLANE(20),                                { STATE_CLIPPLANE(20),                                clipplane           }},
4990     { STATE_CLIPPLANE(21),                                { STATE_CLIPPLANE(21),                                clipplane           }},
4991     { STATE_CLIPPLANE(22),                                { STATE_CLIPPLANE(22),                                clipplane           }},
4992     { STATE_CLIPPLANE(23),                                { STATE_CLIPPLANE(23),                                clipplane           }},
4993     { STATE_CLIPPLANE(24),                                { STATE_CLIPPLANE(24),                                clipplane           }},
4994     { STATE_CLIPPLANE(25),                                { STATE_CLIPPLANE(25),                                clipplane           }},
4995     { STATE_CLIPPLANE(26),                                { STATE_CLIPPLANE(26),                                clipplane           }},
4996     { STATE_CLIPPLANE(27),                                { STATE_CLIPPLANE(27),                                clipplane           }},
4997     { STATE_CLIPPLANE(28),                                { STATE_CLIPPLANE(28),                                clipplane           }},
4998     { STATE_CLIPPLANE(29),                                { STATE_CLIPPLANE(29),                                clipplane           }},
4999     { STATE_CLIPPLANE(30),                                { STATE_CLIPPLANE(30),                                clipplane           }},
5000     { STATE_CLIPPLANE(31),                                { STATE_CLIPPLANE(31),                                clipplane           }},
5001       /* Lights */
5002     { STATE_ACTIVELIGHT(0),                               { STATE_ACTIVELIGHT(0),                               light               }},
5003     { STATE_ACTIVELIGHT(1),                               { STATE_ACTIVELIGHT(1),                               light               }},
5004     { STATE_ACTIVELIGHT(2),                               { STATE_ACTIVELIGHT(2),                               light               }},
5005     { STATE_ACTIVELIGHT(3),                               { STATE_ACTIVELIGHT(3),                               light               }},
5006     { STATE_ACTIVELIGHT(4),                               { STATE_ACTIVELIGHT(4),                               light               }},
5007     { STATE_ACTIVELIGHT(5),                               { STATE_ACTIVELIGHT(5),                               light               }},
5008     { STATE_ACTIVELIGHT(6),                               { STATE_ACTIVELIGHT(6),                               light               }},
5009     { STATE_ACTIVELIGHT(7),                               { STATE_ACTIVELIGHT(7),                               light               }},
5010     /* Viewport */
5011     { STATE_VIEWPORT,                                     { STATE_VIEWPORT,                                     viewport_vertexpart }},
5012       /* Transform states follow                    */
5013     { STATE_TRANSFORM(WINED3DTS_VIEW),                    { STATE_TRANSFORM(WINED3DTS_VIEW),                    transform_view      }},
5014     { STATE_TRANSFORM(WINED3DTS_PROJECTION),              { STATE_TRANSFORM(WINED3DTS_PROJECTION),              transform_projection}},
5015     { STATE_TRANSFORM(WINED3DTS_TEXTURE0),                { STATE_TRANSFORM(WINED3DTS_TEXTURE0),                transform_texture   }},
5016     { STATE_TRANSFORM(WINED3DTS_TEXTURE1),                { STATE_TRANSFORM(WINED3DTS_TEXTURE1),                transform_texture   }},
5017     { STATE_TRANSFORM(WINED3DTS_TEXTURE2),                { STATE_TRANSFORM(WINED3DTS_TEXTURE2),                transform_texture   }},
5018     { STATE_TRANSFORM(WINED3DTS_TEXTURE3),                { STATE_TRANSFORM(WINED3DTS_TEXTURE3),                transform_texture   }},
5019     { STATE_TRANSFORM(WINED3DTS_TEXTURE4),                { STATE_TRANSFORM(WINED3DTS_TEXTURE4),                transform_texture   }},
5020     { STATE_TRANSFORM(WINED3DTS_TEXTURE5),                { STATE_TRANSFORM(WINED3DTS_TEXTURE5),                transform_texture   }},
5021     { STATE_TRANSFORM(WINED3DTS_TEXTURE6),                { STATE_TRANSFORM(WINED3DTS_TEXTURE6),                transform_texture   }},
5022     { STATE_TRANSFORM(WINED3DTS_TEXTURE7),                { STATE_TRANSFORM(WINED3DTS_TEXTURE7),                transform_texture   }},
5023     { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(  0)),        { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(  0)),        transform_world     }},
5024     { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(  1)),        { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(  1)),        transform_world     }},
5025     { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(  2)),        { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(  2)),        transform_world     }},
5026     { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(  3)),        { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(  3)),        transform_world     }},
5027     { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(  4)),        { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(  4)),        transform_world     }},
5028     { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(  5)),        { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(  5)),        transform_world     }},
5029     { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(  6)),        { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(  6)),        transform_world     }},
5030     { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(  7)),        { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(  7)),        transform_world     }},
5031     { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(  8)),        { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(  8)),        transform_world     }},
5032     { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(  9)),        { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(  9)),        transform_world     }},
5033     { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 10)),        { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 10)),        transform_world     }},
5034     { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 11)),        { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 11)),        transform_world     }},
5035     { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 12)),        { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 12)),        transform_world     }},
5036     { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 13)),        { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 13)),        transform_world     }},
5037     { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 14)),        { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 14)),        transform_world     }},
5038     { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 15)),        { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 15)),        transform_world     }},
5039     { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 16)),        { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 16)),        transform_world     }},
5040     { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 17)),        { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 17)),        transform_world     }},
5041     { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 18)),        { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 18)),        transform_world     }},
5042     { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 19)),        { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 19)),        transform_world     }},
5043     { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 20)),        { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 20)),        transform_world     }},
5044     { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 21)),        { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 21)),        transform_world     }},
5045     { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 22)),        { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 22)),        transform_world     }},
5046     { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 23)),        { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 23)),        transform_world     }},
5047     { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 24)),        { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 24)),        transform_world     }},
5048     { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 25)),        { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 25)),        transform_world     }},
5049     { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 26)),        { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 26)),        transform_world     }},
5050     { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 27)),        { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 27)),        transform_world     }},
5051     { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 28)),        { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 28)),        transform_world     }},
5052     { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 29)),        { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 29)),        transform_world     }},
5053     { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 30)),        { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 30)),        transform_world     }},
5054     { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 31)),        { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 31)),        transform_world     }},
5055     { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 32)),        { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 32)),        transform_world     }},
5056     { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 33)),        { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 33)),        transform_world     }},
5057     { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 34)),        { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 34)),        transform_world     }},
5058     { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 35)),        { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 35)),        transform_world     }},
5059     { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 36)),        { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 36)),        transform_world     }},
5060     { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 37)),        { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 37)),        transform_world     }},
5061     { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 38)),        { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 38)),        transform_world     }},
5062     { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 39)),        { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 39)),        transform_world     }},
5063     { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 40)),        { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 40)),        transform_world     }},
5064     { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 41)),        { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 41)),        transform_world     }},
5065     { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 42)),        { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 42)),        transform_world     }},
5066     { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 43)),        { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 43)),        transform_world     }},
5067     { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 44)),        { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 44)),        transform_world     }},
5068     { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 45)),        { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 45)),        transform_world     }},
5069     { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 46)),        { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 46)),        transform_world     }},
5070     { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 47)),        { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 47)),        transform_world     }},
5071     { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 48)),        { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 48)),        transform_world     }},
5072     { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 49)),        { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 49)),        transform_world     }},
5073     { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 50)),        { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 50)),        transform_world     }},
5074     { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 51)),        { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 51)),        transform_world     }},
5075     { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 52)),        { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 52)),        transform_world     }},
5076     { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 53)),        { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 53)),        transform_world     }},
5077     { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 54)),        { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 54)),        transform_world     }},
5078     { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 55)),        { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 55)),        transform_world     }},
5079     { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 56)),        { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 56)),        transform_world     }},
5080     { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 57)),        { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 57)),        transform_world     }},
5081     { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 58)),        { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 58)),        transform_world     }},
5082     { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 59)),        { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 59)),        transform_world     }},
5083     { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 60)),        { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 60)),        transform_world     }},
5084     { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 61)),        { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 61)),        transform_world     }},
5085     { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 62)),        { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 62)),        transform_world     }},
5086     { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 63)),        { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 63)),        transform_world     }},
5087     { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 64)),        { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 64)),        transform_world     }},
5088     { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 65)),        { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 65)),        transform_world     }},
5089     { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 66)),        { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 66)),        transform_world     }},
5090     { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 67)),        { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 67)),        transform_world     }},
5091     { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 68)),        { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 68)),        transform_world     }},
5092     { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 69)),        { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 69)),        transform_world     }},
5093     { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 70)),        { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 70)),        transform_world     }},
5094     { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 71)),        { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 71)),        transform_world     }},
5095     { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 72)),        { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 72)),        transform_world     }},
5096     { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 73)),        { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 73)),        transform_world     }},
5097     { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 74)),        { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 74)),        transform_world     }},
5098     { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 75)),        { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 75)),        transform_world     }},
5099     { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 76)),        { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 76)),        transform_world     }},
5100     { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 77)),        { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 77)),        transform_world     }},
5101     { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 78)),        { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 78)),        transform_world     }},
5102     { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 79)),        { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 79)),        transform_world     }},
5103     { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 80)),        { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 80)),        transform_world     }},
5104     { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 81)),        { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 81)),        transform_world     }},
5105     { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 82)),        { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 82)),        transform_world     }},
5106     { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 83)),        { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 83)),        transform_world     }},
5107     { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 84)),        { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 84)),        transform_world     }},
5108     { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 85)),        { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 85)),        transform_world     }},
5109     { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 86)),        { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 86)),        transform_world     }},
5110     { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 87)),        { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 87)),        transform_world     }},
5111     { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 88)),        { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 88)),        transform_world     }},
5112     { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 89)),        { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 89)),        transform_world     }},
5113     { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 90)),        { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 90)),        transform_world     }},
5114     { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 91)),        { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 91)),        transform_world     }},
5115     { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 92)),        { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 92)),        transform_world     }},
5116     { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 93)),        { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 93)),        transform_world     }},
5117     { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 94)),        { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 94)),        transform_world     }},
5118     { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 95)),        { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 95)),        transform_world     }},
5119     { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 96)),        { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 96)),        transform_world     }},
5120     { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 97)),        { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 97)),        transform_world     }},
5121     { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 98)),        { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 98)),        transform_world     }},
5122     { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 99)),        { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 99)),        transform_world     }},
5123     { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(100)),        { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(100)),        transform_world     }},
5124     { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(101)),        { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(101)),        transform_world     }},
5125     { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(102)),        { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(102)),        transform_world     }},
5126     { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(103)),        { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(103)),        transform_world     }},
5127     { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(104)),        { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(104)),        transform_world     }},
5128     { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(105)),        { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(105)),        transform_world     }},
5129     { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(106)),        { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(106)),        transform_world     }},
5130     { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(107)),        { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(107)),        transform_world     }},
5131     { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(108)),        { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(108)),        transform_world     }},
5132     { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(109)),        { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(109)),        transform_world     }},
5133     { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(110)),        { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(110)),        transform_world     }},
5134     { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(111)),        { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(111)),        transform_world     }},
5135     { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(112)),        { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(112)),        transform_world     }},
5136     { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(113)),        { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(113)),        transform_world     }},
5137     { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(114)),        { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(114)),        transform_world     }},
5138     { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(115)),        { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(115)),        transform_world     }},
5139     { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(116)),        { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(116)),        transform_world     }},
5140     { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(117)),        { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(117)),        transform_world     }},
5141     { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(118)),        { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(118)),        transform_world     }},
5142     { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(119)),        { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(119)),        transform_world     }},
5143     { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(120)),        { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(120)),        transform_world     }},
5144     { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(121)),        { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(121)),        transform_world     }},
5145     { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(122)),        { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(122)),        transform_world     }},
5146     { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(123)),        { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(123)),        transform_world     }},
5147     { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(124)),        { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(124)),        transform_world     }},
5148     { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(125)),        { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(125)),        transform_world     }},
5149     { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(126)),        { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(126)),        transform_world     }},
5150     { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(127)),        { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(127)),        transform_world     }},
5151     { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(128)),        { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(128)),        transform_world     }},
5152     { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(129)),        { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(129)),        transform_world     }},
5153     { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(130)),        { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(130)),        transform_world     }},
5154     { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(131)),        { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(131)),        transform_world     }},
5155     { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(132)),        { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(132)),        transform_world     }},
5156     { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(133)),        { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(133)),        transform_world     }},
5157     { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(134)),        { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(134)),        transform_world     }},
5158     { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(135)),        { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(135)),        transform_world     }},
5159     { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(136)),        { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(136)),        transform_world     }},
5160     { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(137)),        { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(137)),        transform_world     }},
5161     { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(138)),        { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(138)),        transform_world     }},
5162     { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(139)),        { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(139)),        transform_world     }},
5163     { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(140)),        { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(140)),        transform_world     }},
5164     { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(141)),        { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(141)),        transform_world     }},
5165     { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(142)),        { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(142)),        transform_world     }},
5166     { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(143)),        { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(143)),        transform_world     }},
5167     { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(144)),        { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(144)),        transform_world     }},
5168     { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(145)),        { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(145)),        transform_world     }},
5169     { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(146)),        { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(146)),        transform_world     }},
5170     { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(147)),        { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(147)),        transform_world     }},
5171     { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(148)),        { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(148)),        transform_world     }},
5172     { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(149)),        { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(149)),        transform_world     }},
5173     { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(150)),        { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(150)),        transform_world     }},
5174     { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(151)),        { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(151)),        transform_world     }},
5175     { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(152)),        { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(152)),        transform_world     }},
5176     { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(153)),        { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(153)),        transform_world     }},
5177     { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(154)),        { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(154)),        transform_world     }},
5178     { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(155)),        { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(155)),        transform_world     }},
5179     { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(156)),        { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(156)),        transform_world     }},
5180     { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(157)),        { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(157)),        transform_world     }},
5181     { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(158)),        { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(158)),        transform_world     }},
5182     { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(159)),        { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(159)),        transform_world     }},
5183     { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(160)),        { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(160)),        transform_world     }},
5184     { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(161)),        { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(161)),        transform_world     }},
5185     { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(162)),        { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(162)),        transform_world     }},
5186     { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(163)),        { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(163)),        transform_world     }},
5187     { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(164)),        { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(164)),        transform_world     }},
5188     { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(165)),        { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(165)),        transform_world     }},
5189     { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(166)),        { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(166)),        transform_world     }},
5190     { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(167)),        { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(167)),        transform_world     }},
5191     { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(168)),        { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(168)),        transform_world     }},
5192     { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(169)),        { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(169)),        transform_world     }},
5193     { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(170)),        { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(170)),        transform_world     }},
5194     { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(171)),        { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(171)),        transform_world     }},
5195     { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(172)),        { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(172)),        transform_world     }},
5196     { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(173)),        { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(173)),        transform_world     }},
5197     { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(174)),        { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(174)),        transform_world     }},
5198     { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(175)),        { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(175)),        transform_world     }},
5199     { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(176)),        { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(176)),        transform_world     }},
5200     { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(177)),        { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(177)),        transform_world     }},
5201     { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(178)),        { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(178)),        transform_world     }},
5202     { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(179)),        { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(179)),        transform_world     }},
5203     { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(180)),        { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(180)),        transform_world     }},
5204     { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(181)),        { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(181)),        transform_world     }},
5205     { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(182)),        { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(182)),        transform_world     }},
5206     { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(183)),        { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(183)),        transform_world     }},
5207     { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(184)),        { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(184)),        transform_world     }},
5208     { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(185)),        { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(185)),        transform_world     }},
5209     { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(186)),        { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(186)),        transform_world     }},
5210     { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(187)),        { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(187)),        transform_world     }},
5211     { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(188)),        { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(188)),        transform_world     }},
5212     { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(189)),        { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(189)),        transform_world     }},
5213     { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(190)),        { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(190)),        transform_world     }},
5214     { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(191)),        { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(191)),        transform_world     }},
5215     { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(192)),        { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(192)),        transform_world     }},
5216     { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(193)),        { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(193)),        transform_world     }},
5217     { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(194)),        { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(194)),        transform_world     }},
5218     { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(195)),        { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(195)),        transform_world     }},
5219     { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(196)),        { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(196)),        transform_world     }},
5220     { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(197)),        { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(197)),        transform_world     }},
5221     { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(198)),        { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(198)),        transform_world     }},
5222     { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(199)),        { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(199)),        transform_world     }},
5223     { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(200)),        { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(200)),        transform_world     }},
5224     { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(201)),        { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(201)),        transform_world     }},
5225     { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(202)),        { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(202)),        transform_world     }},
5226     { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(203)),        { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(203)),        transform_world     }},
5227     { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(204)),        { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(204)),        transform_world     }},
5228     { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(205)),        { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(205)),        transform_world     }},
5229     { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(206)),        { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(206)),        transform_world     }},
5230     { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(207)),        { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(207)),        transform_world     }},
5231     { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(208)),        { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(208)),        transform_world     }},
5232     { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(209)),        { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(209)),        transform_world     }},
5233     { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(210)),        { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(210)),        transform_world     }},
5234     { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(211)),        { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(211)),        transform_world     }},
5235     { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(212)),        { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(212)),        transform_world     }},
5236     { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(213)),        { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(213)),        transform_world     }},
5237     { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(214)),        { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(214)),        transform_world     }},
5238     { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(215)),        { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(215)),        transform_world     }},
5239     { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(216)),        { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(216)),        transform_world     }},
5240     { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(217)),        { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(217)),        transform_world     }},
5241     { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(218)),        { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(218)),        transform_world     }},
5242     { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(219)),        { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(219)),        transform_world     }},
5243     { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(220)),        { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(220)),        transform_world     }},
5244     { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(221)),        { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(221)),        transform_world     }},
5245     { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(222)),        { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(222)),        transform_world     }},
5246     { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(223)),        { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(223)),        transform_world     }},
5247     { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(224)),        { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(224)),        transform_world     }},
5248     { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(225)),        { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(225)),        transform_world     }},
5249     { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(226)),        { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(226)),        transform_world     }},
5250     { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(227)),        { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(227)),        transform_world     }},
5251     { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(228)),        { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(228)),        transform_world     }},
5252     { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(229)),        { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(229)),        transform_world     }},
5253     { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(230)),        { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(230)),        transform_world     }},
5254     { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(231)),        { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(231)),        transform_world     }},
5255     { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(232)),        { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(232)),        transform_world     }},
5256     { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(233)),        { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(233)),        transform_world     }},
5257     { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(234)),        { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(234)),        transform_world     }},
5258     { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(235)),        { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(235)),        transform_world     }},
5259     { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(236)),        { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(236)),        transform_world     }},
5260     { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(237)),        { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(237)),        transform_world     }},
5261     { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(238)),        { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(238)),        transform_world     }},
5262     { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(239)),        { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(239)),        transform_world     }},
5263     { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(240)),        { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(240)),        transform_world     }},
5264     { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(241)),        { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(241)),        transform_world     }},
5265     { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(242)),        { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(242)),        transform_world     }},
5266     { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(243)),        { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(243)),        transform_world     }},
5267     { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(244)),        { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(244)),        transform_world     }},
5268     { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(245)),        { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(245)),        transform_world     }},
5269     { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(246)),        { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(246)),        transform_world     }},
5270     { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(247)),        { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(247)),        transform_world     }},
5271     { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(248)),        { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(248)),        transform_world     }},
5272     { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(249)),        { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(249)),        transform_world     }},
5273     { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(250)),        { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(250)),        transform_world     }},
5274     { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(251)),        { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(251)),        transform_world     }},
5275     { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(252)),        { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(252)),        transform_world     }},
5276     { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(253)),        { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(253)),        transform_world     }},
5277     { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(254)),        { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(254)),        transform_world     }},
5278     { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(255)),        { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(255)),        transform_world     }},
5279     { STATE_TEXTURESTAGE(0,WINED3DTSS_TEXTURETRANSFORMFLAGS),{STATE_TRANSFORM(WINED3DTS_TEXTURE0),              transform_texture   }},
5280     { STATE_TEXTURESTAGE(1,WINED3DTSS_TEXTURETRANSFORMFLAGS),{STATE_TRANSFORM(WINED3DTS_TEXTURE1),              transform_texture   }},
5281     { STATE_TEXTURESTAGE(2,WINED3DTSS_TEXTURETRANSFORMFLAGS),{STATE_TRANSFORM(WINED3DTS_TEXTURE2),              transform_texture   }},
5282     { STATE_TEXTURESTAGE(3,WINED3DTSS_TEXTURETRANSFORMFLAGS),{STATE_TRANSFORM(WINED3DTS_TEXTURE3),              transform_texture   }},
5283     { STATE_TEXTURESTAGE(4,WINED3DTSS_TEXTURETRANSFORMFLAGS),{STATE_TRANSFORM(WINED3DTS_TEXTURE4),              transform_texture   }},
5284     { STATE_TEXTURESTAGE(5,WINED3DTSS_TEXTURETRANSFORMFLAGS),{STATE_TRANSFORM(WINED3DTS_TEXTURE5),              transform_texture   }},
5285     { STATE_TEXTURESTAGE(6,WINED3DTSS_TEXTURETRANSFORMFLAGS),{STATE_TRANSFORM(WINED3DTS_TEXTURE6),              transform_texture   }},
5286     { STATE_TEXTURESTAGE(7,WINED3DTSS_TEXTURETRANSFORMFLAGS),{STATE_TRANSFORM(WINED3DTS_TEXTURE7),              transform_texture   }},
5287       /* Fog */
5288     { STATE_RENDER(WINED3DRS_FOGENABLE),                  { STATE_RENDER(WINED3DRS_FOGENABLE),                  state_fog           }},
5289     { STATE_RENDER(WINED3DRS_FOGTABLEMODE),               { STATE_RENDER(WINED3DRS_FOGENABLE),                  state_fog           }},
5290     { STATE_RENDER(WINED3DRS_FOGSTART),                   { STATE_RENDER(WINED3DRS_FOGENABLE),                  state_fog           }},
5291     { STATE_RENDER(WINED3DRS_FOGEND),                     { STATE_RENDER(WINED3DRS_FOGENABLE),                  state_fog           }},
5292     { STATE_RENDER(WINED3DRS_FOGVERTEXMODE),              { STATE_RENDER(WINED3DRS_FOGENABLE),                  state_fog           }},
5293     { STATE_RENDER(WINED3DRS_FOGCOLOR),                   { STATE_RENDER(WINED3DRS_FOGCOLOR),                   state_fogcolor      }},
5294     { STATE_RENDER(WINED3DRS_FOGDENSITY),                 { STATE_RENDER(WINED3DRS_FOGDENSITY),                 state_fogdensity    }},
5295     { STATE_RENDER(WINED3DRS_RANGEFOGENABLE),             { STATE_RENDER(WINED3DRS_RANGEFOGENABLE),             state_rangefog      }},
5296     {0 /* Terminate */,                                   { 0,                                                  0                   }},
5297 };
5298
5299 const struct StateEntryTemplate ffp_fragmentstate_template[] = {
5300     { STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP),          { STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP),          tex_colorop         }},
5301     { STATE_TEXTURESTAGE(0, WINED3DTSS_COLORARG1),        { STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP),          tex_colorop         }},
5302     { STATE_TEXTURESTAGE(0, WINED3DTSS_COLORARG2),        { STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP),          tex_colorop         }},
5303     { STATE_TEXTURESTAGE(0, WINED3DTSS_ALPHAOP),          { STATE_TEXTURESTAGE(0, WINED3DTSS_ALPHAOP),          tex_alphaop         }},
5304     { STATE_TEXTURESTAGE(0, WINED3DTSS_ALPHAARG1),        { STATE_TEXTURESTAGE(0, WINED3DTSS_ALPHAOP),          tex_alphaop         }},
5305     { STATE_TEXTURESTAGE(0, WINED3DTSS_ALPHAARG2),        { STATE_TEXTURESTAGE(0, WINED3DTSS_ALPHAOP),          tex_alphaop         }},
5306     { STATE_TEXTURESTAGE(0, WINED3DTSS_BUMPENVMAT00),     { STATE_TEXTURESTAGE(0, WINED3DTSS_BUMPENVMAT00),     tex_bumpenvmat      }},
5307     { STATE_TEXTURESTAGE(0, WINED3DTSS_BUMPENVMAT01),     { STATE_TEXTURESTAGE(0, WINED3DTSS_BUMPENVMAT00),     tex_bumpenvmat      }},
5308     { STATE_TEXTURESTAGE(0, WINED3DTSS_BUMPENVMAT10),     { STATE_TEXTURESTAGE(0, WINED3DTSS_BUMPENVMAT00),     tex_bumpenvmat      }},
5309     { STATE_TEXTURESTAGE(0, WINED3DTSS_BUMPENVMAT11),     { STATE_TEXTURESTAGE(0, WINED3DTSS_BUMPENVMAT00),     tex_bumpenvmat      }},
5310     { STATE_TEXTURESTAGE(0, WINED3DTSS_TEXCOORDINDEX),    { STATE_TEXTURESTAGE(0, WINED3DTSS_TEXCOORDINDEX),    tex_coordindex      }},
5311     { STATE_TEXTURESTAGE(0, WINED3DTSS_BUMPENVLSCALE),    { STATE_TEXTURESTAGE(0, WINED3DTSS_BUMPENVLSCALE),    tex_bumpenvlscale   }},
5312     { STATE_TEXTURESTAGE(0, WINED3DTSS_BUMPENVLOFFSET),   { STATE_TEXTURESTAGE(0, WINED3DTSS_BUMPENVLOFFSET),   tex_bumpenvloffset  }},
5313     { STATE_TEXTURESTAGE(0, WINED3DTSS_COLORARG0),        { STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP),          tex_colorop         }},
5314     { STATE_TEXTURESTAGE(0, WINED3DTSS_ALPHAARG0),        { STATE_TEXTURESTAGE(0, WINED3DTSS_ALPHAOP),          tex_alphaop         }},
5315     { STATE_TEXTURESTAGE(0, WINED3DTSS_RESULTARG),        { STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP),          tex_colorop         }},
5316     { STATE_TEXTURESTAGE(0, WINED3DTSS_CONSTANT),         { 0 /* As long as we don't support D3DTA_CONSTANT */, state_nogl          }},
5317     { STATE_TEXTURESTAGE(1, WINED3DTSS_COLOROP),          { STATE_TEXTURESTAGE(1, WINED3DTSS_COLOROP),          tex_colorop         }},
5318     { STATE_TEXTURESTAGE(1, WINED3DTSS_COLORARG1),        { STATE_TEXTURESTAGE(1, WINED3DTSS_COLOROP),          tex_colorop         }},
5319     { STATE_TEXTURESTAGE(1, WINED3DTSS_COLORARG2),        { STATE_TEXTURESTAGE(1, WINED3DTSS_COLOROP),          tex_colorop         }},
5320     { STATE_TEXTURESTAGE(1, WINED3DTSS_ALPHAOP),          { STATE_TEXTURESTAGE(1, WINED3DTSS_ALPHAOP),          tex_alphaop         }},
5321     { STATE_TEXTURESTAGE(1, WINED3DTSS_ALPHAARG1),        { STATE_TEXTURESTAGE(1, WINED3DTSS_ALPHAOP),          tex_alphaop         }},
5322     { STATE_TEXTURESTAGE(1, WINED3DTSS_ALPHAARG2),        { STATE_TEXTURESTAGE(1, WINED3DTSS_ALPHAOP),          tex_alphaop         }},
5323     { STATE_TEXTURESTAGE(1, WINED3DTSS_BUMPENVMAT00),     { STATE_TEXTURESTAGE(1, WINED3DTSS_BUMPENVMAT00),     tex_bumpenvmat      }},
5324     { STATE_TEXTURESTAGE(1, WINED3DTSS_BUMPENVMAT01),     { STATE_TEXTURESTAGE(1, WINED3DTSS_BUMPENVMAT00),     tex_bumpenvmat      }},
5325     { STATE_TEXTURESTAGE(1, WINED3DTSS_BUMPENVMAT10),     { STATE_TEXTURESTAGE(1, WINED3DTSS_BUMPENVMAT00),     tex_bumpenvmat      }},
5326     { STATE_TEXTURESTAGE(1, WINED3DTSS_BUMPENVMAT11),     { STATE_TEXTURESTAGE(1, WINED3DTSS_BUMPENVMAT00),     tex_bumpenvmat      }},
5327     { STATE_TEXTURESTAGE(1, WINED3DTSS_TEXCOORDINDEX),    { STATE_TEXTURESTAGE(1, WINED3DTSS_TEXCOORDINDEX),    tex_coordindex      }},
5328     { STATE_TEXTURESTAGE(1, WINED3DTSS_BUMPENVLSCALE),    { STATE_TEXTURESTAGE(1, WINED3DTSS_BUMPENVLSCALE),    tex_bumpenvlscale   }},
5329     { STATE_TEXTURESTAGE(1, WINED3DTSS_BUMPENVLOFFSET),   { STATE_TEXTURESTAGE(1, WINED3DTSS_BUMPENVLOFFSET),   tex_bumpenvloffset  }},
5330     { STATE_TEXTURESTAGE(1, WINED3DTSS_COLORARG0),        { STATE_TEXTURESTAGE(1, WINED3DTSS_COLOROP),          tex_colorop         }},
5331     { STATE_TEXTURESTAGE(1, WINED3DTSS_ALPHAARG0),        { STATE_TEXTURESTAGE(1, WINED3DTSS_ALPHAOP),          tex_alphaop         }},
5332     { STATE_TEXTURESTAGE(1, WINED3DTSS_RESULTARG),        { STATE_TEXTURESTAGE(1, WINED3DTSS_COLOROP),          tex_colorop         }},
5333     { STATE_TEXTURESTAGE(1, WINED3DTSS_CONSTANT),         { 0 /* As long as we don't support D3DTA_CONSTANT */, state_nogl          }},
5334     { STATE_TEXTURESTAGE(2, WINED3DTSS_COLOROP),          { STATE_TEXTURESTAGE(2, WINED3DTSS_COLOROP),          tex_colorop         }},
5335     { STATE_TEXTURESTAGE(2, WINED3DTSS_COLORARG1),        { STATE_TEXTURESTAGE(2, WINED3DTSS_COLOROP),          tex_colorop         }},
5336     { STATE_TEXTURESTAGE(2, WINED3DTSS_COLORARG2),        { STATE_TEXTURESTAGE(2, WINED3DTSS_COLOROP),          tex_colorop         }},
5337     { STATE_TEXTURESTAGE(2, WINED3DTSS_ALPHAOP),          { STATE_TEXTURESTAGE(2, WINED3DTSS_ALPHAOP),          tex_alphaop         }},
5338     { STATE_TEXTURESTAGE(2, WINED3DTSS_ALPHAARG1),        { STATE_TEXTURESTAGE(2, WINED3DTSS_ALPHAOP),          tex_alphaop         }},
5339     { STATE_TEXTURESTAGE(2, WINED3DTSS_ALPHAARG2),        { STATE_TEXTURESTAGE(2, WINED3DTSS_ALPHAOP),          tex_alphaop         }},
5340     { STATE_TEXTURESTAGE(2, WINED3DTSS_BUMPENVMAT00),     { STATE_TEXTURESTAGE(2, WINED3DTSS_BUMPENVMAT00),     tex_bumpenvmat      }},
5341     { STATE_TEXTURESTAGE(2, WINED3DTSS_BUMPENVMAT01),     { STATE_TEXTURESTAGE(2, WINED3DTSS_BUMPENVMAT00),     tex_bumpenvmat      }},
5342     { STATE_TEXTURESTAGE(2, WINED3DTSS_BUMPENVMAT10),     { STATE_TEXTURESTAGE(2, WINED3DTSS_BUMPENVMAT00),     tex_bumpenvmat      }},
5343     { STATE_TEXTURESTAGE(2, WINED3DTSS_BUMPENVMAT11),     { STATE_TEXTURESTAGE(2, WINED3DTSS_BUMPENVMAT00),     tex_bumpenvmat      }},
5344     { STATE_TEXTURESTAGE(2, WINED3DTSS_TEXCOORDINDEX),    { STATE_TEXTURESTAGE(2, WINED3DTSS_TEXCOORDINDEX),    tex_coordindex      }},
5345     { STATE_TEXTURESTAGE(2, WINED3DTSS_BUMPENVLSCALE),    { STATE_TEXTURESTAGE(2, WINED3DTSS_BUMPENVLSCALE),    tex_bumpenvlscale   }},
5346     { STATE_TEXTURESTAGE(2, WINED3DTSS_BUMPENVLOFFSET),   { STATE_TEXTURESTAGE(2, WINED3DTSS_BUMPENVLOFFSET),   tex_bumpenvloffset  }},
5347     { STATE_TEXTURESTAGE(2, WINED3DTSS_COLORARG0),        { STATE_TEXTURESTAGE(2, WINED3DTSS_COLOROP),          tex_colorop         }},
5348     { STATE_TEXTURESTAGE(2, WINED3DTSS_ALPHAARG0),        { STATE_TEXTURESTAGE(2, WINED3DTSS_ALPHAOP),          tex_alphaop         }},
5349     { STATE_TEXTURESTAGE(2, WINED3DTSS_RESULTARG),        { STATE_TEXTURESTAGE(2, WINED3DTSS_COLOROP),          tex_colorop         }},
5350     { STATE_TEXTURESTAGE(2, WINED3DTSS_CONSTANT),         { 0 /* As long as we don't support D3DTA_CONSTANT */, state_nogl          }},
5351     { STATE_TEXTURESTAGE(3, WINED3DTSS_COLOROP),          { STATE_TEXTURESTAGE(3, WINED3DTSS_COLOROP),          tex_colorop         }},
5352     { STATE_TEXTURESTAGE(3, WINED3DTSS_COLORARG1),        { STATE_TEXTURESTAGE(3, WINED3DTSS_COLOROP),          tex_colorop         }},
5353     { STATE_TEXTURESTAGE(3, WINED3DTSS_COLORARG2),        { STATE_TEXTURESTAGE(3, WINED3DTSS_COLOROP),          tex_colorop         }},
5354     { STATE_TEXTURESTAGE(3, WINED3DTSS_ALPHAOP),          { STATE_TEXTURESTAGE(3, WINED3DTSS_ALPHAOP),          tex_alphaop         }},
5355     { STATE_TEXTURESTAGE(3, WINED3DTSS_ALPHAARG1),        { STATE_TEXTURESTAGE(3, WINED3DTSS_ALPHAOP),          tex_alphaop         }},
5356     { STATE_TEXTURESTAGE(3, WINED3DTSS_ALPHAARG2),        { STATE_TEXTURESTAGE(3, WINED3DTSS_ALPHAOP),          tex_alphaop         }},
5357     { STATE_TEXTURESTAGE(3, WINED3DTSS_BUMPENVMAT00),     { STATE_TEXTURESTAGE(3, WINED3DTSS_BUMPENVMAT00),     tex_bumpenvmat      }},
5358     { STATE_TEXTURESTAGE(3, WINED3DTSS_BUMPENVMAT01),     { STATE_TEXTURESTAGE(3, WINED3DTSS_BUMPENVMAT00),     tex_bumpenvmat      }},
5359     { STATE_TEXTURESTAGE(3, WINED3DTSS_BUMPENVMAT10),     { STATE_TEXTURESTAGE(3, WINED3DTSS_BUMPENVMAT00),     tex_bumpenvmat      }},
5360     { STATE_TEXTURESTAGE(3, WINED3DTSS_BUMPENVMAT11),     { STATE_TEXTURESTAGE(3, WINED3DTSS_BUMPENVMAT00),     tex_bumpenvmat      }},
5361     { STATE_TEXTURESTAGE(3, WINED3DTSS_TEXCOORDINDEX),    { STATE_TEXTURESTAGE(3, WINED3DTSS_TEXCOORDINDEX),    tex_coordindex      }},
5362     { STATE_TEXTURESTAGE(3, WINED3DTSS_BUMPENVLSCALE),    { STATE_TEXTURESTAGE(3, WINED3DTSS_BUMPENVLSCALE),    tex_bumpenvlscale   }},
5363     { STATE_TEXTURESTAGE(3, WINED3DTSS_BUMPENVLOFFSET),   { STATE_TEXTURESTAGE(3, WINED3DTSS_BUMPENVLOFFSET),   tex_bumpenvloffset  }},
5364     { STATE_TEXTURESTAGE(3, WINED3DTSS_COLORARG0),        { STATE_TEXTURESTAGE(3, WINED3DTSS_COLOROP),          tex_colorop         }},
5365     { STATE_TEXTURESTAGE(3, WINED3DTSS_ALPHAARG0),        { STATE_TEXTURESTAGE(3, WINED3DTSS_ALPHAOP),          tex_alphaop         }},
5366     { STATE_TEXTURESTAGE(3, WINED3DTSS_RESULTARG),        { STATE_TEXTURESTAGE(3, WINED3DTSS_COLOROP),          tex_colorop         }},
5367     { STATE_TEXTURESTAGE(3, WINED3DTSS_CONSTANT),         { 0 /* As long as we don't support D3DTA_CONSTANT */, state_nogl          }},
5368     { STATE_TEXTURESTAGE(4, WINED3DTSS_COLOROP),          { STATE_TEXTURESTAGE(4, WINED3DTSS_COLOROP),          tex_colorop         }},
5369     { STATE_TEXTURESTAGE(4, WINED3DTSS_COLORARG1),        { STATE_TEXTURESTAGE(4, WINED3DTSS_COLOROP),          tex_colorop         }},
5370     { STATE_TEXTURESTAGE(4, WINED3DTSS_COLORARG2),        { STATE_TEXTURESTAGE(4, WINED3DTSS_COLOROP),          tex_colorop         }},
5371     { STATE_TEXTURESTAGE(4, WINED3DTSS_ALPHAOP),          { STATE_TEXTURESTAGE(4, WINED3DTSS_ALPHAOP),          tex_alphaop         }},
5372     { STATE_TEXTURESTAGE(4, WINED3DTSS_ALPHAARG1),        { STATE_TEXTURESTAGE(4, WINED3DTSS_ALPHAOP),          tex_alphaop         }},
5373     { STATE_TEXTURESTAGE(4, WINED3DTSS_ALPHAARG2),        { STATE_TEXTURESTAGE(4, WINED3DTSS_ALPHAOP),          tex_alphaop         }},
5374     { STATE_TEXTURESTAGE(4, WINED3DTSS_BUMPENVMAT00),     { STATE_TEXTURESTAGE(4, WINED3DTSS_BUMPENVMAT00),     tex_bumpenvmat      }},
5375     { STATE_TEXTURESTAGE(4, WINED3DTSS_BUMPENVMAT01),     { STATE_TEXTURESTAGE(4, WINED3DTSS_BUMPENVMAT00),     tex_bumpenvmat      }},
5376     { STATE_TEXTURESTAGE(4, WINED3DTSS_BUMPENVMAT10),     { STATE_TEXTURESTAGE(4, WINED3DTSS_BUMPENVMAT00),     tex_bumpenvmat      }},
5377     { STATE_TEXTURESTAGE(4, WINED3DTSS_BUMPENVMAT11),     { STATE_TEXTURESTAGE(4, WINED3DTSS_BUMPENVMAT00),     tex_bumpenvmat      }},
5378     { STATE_TEXTURESTAGE(4, WINED3DTSS_TEXCOORDINDEX),    { STATE_TEXTURESTAGE(4, WINED3DTSS_TEXCOORDINDEX),    tex_coordindex      }},
5379     { STATE_TEXTURESTAGE(4, WINED3DTSS_BUMPENVLSCALE),    { STATE_TEXTURESTAGE(4, WINED3DTSS_BUMPENVLSCALE),    tex_bumpenvlscale   }},
5380     { STATE_TEXTURESTAGE(4, WINED3DTSS_BUMPENVLOFFSET),   { STATE_TEXTURESTAGE(4, WINED3DTSS_BUMPENVLOFFSET),   tex_bumpenvloffset  }},
5381     { STATE_TEXTURESTAGE(4, WINED3DTSS_COLORARG0),        { STATE_TEXTURESTAGE(4, WINED3DTSS_COLOROP),          tex_colorop         }},
5382     { STATE_TEXTURESTAGE(4, WINED3DTSS_ALPHAARG0),        { STATE_TEXTURESTAGE(4, WINED3DTSS_ALPHAOP),          tex_alphaop         }},
5383     { STATE_TEXTURESTAGE(4, WINED3DTSS_RESULTARG),        { STATE_TEXTURESTAGE(4, WINED3DTSS_COLOROP),          tex_colorop         }},
5384     { STATE_TEXTURESTAGE(4, WINED3DTSS_CONSTANT),         { 0 /* As long as we don't support D3DTA_CONSTANT */, state_nogl          }},
5385     { STATE_TEXTURESTAGE(5, WINED3DTSS_COLOROP),          { STATE_TEXTURESTAGE(5, WINED3DTSS_COLOROP),          tex_colorop         }},
5386     { STATE_TEXTURESTAGE(5, WINED3DTSS_COLORARG1),        { STATE_TEXTURESTAGE(5, WINED3DTSS_COLOROP),          tex_colorop         }},
5387     { STATE_TEXTURESTAGE(5, WINED3DTSS_COLORARG2),        { STATE_TEXTURESTAGE(5, WINED3DTSS_COLOROP),          tex_colorop         }},
5388     { STATE_TEXTURESTAGE(5, WINED3DTSS_ALPHAOP),          { STATE_TEXTURESTAGE(5, WINED3DTSS_ALPHAOP),          tex_alphaop         }},
5389     { STATE_TEXTURESTAGE(5, WINED3DTSS_ALPHAARG1),        { STATE_TEXTURESTAGE(5, WINED3DTSS_ALPHAOP),          tex_alphaop         }},
5390     { STATE_TEXTURESTAGE(5, WINED3DTSS_ALPHAARG2),        { STATE_TEXTURESTAGE(5, WINED3DTSS_ALPHAOP),          tex_alphaop         }},
5391     { STATE_TEXTURESTAGE(5, WINED3DTSS_BUMPENVMAT00),     { STATE_TEXTURESTAGE(5, WINED3DTSS_BUMPENVMAT00),     tex_bumpenvmat      }},
5392     { STATE_TEXTURESTAGE(5, WINED3DTSS_BUMPENVMAT01),     { STATE_TEXTURESTAGE(5, WINED3DTSS_BUMPENVMAT00),     tex_bumpenvmat      }},
5393     { STATE_TEXTURESTAGE(5, WINED3DTSS_BUMPENVMAT10),     { STATE_TEXTURESTAGE(5, WINED3DTSS_BUMPENVMAT00),     tex_bumpenvmat      }},
5394     { STATE_TEXTURESTAGE(5, WINED3DTSS_BUMPENVMAT11),     { STATE_TEXTURESTAGE(5, WINED3DTSS_BUMPENVMAT00),     tex_bumpenvmat      }},
5395     { STATE_TEXTURESTAGE(5, WINED3DTSS_TEXCOORDINDEX),    { STATE_TEXTURESTAGE(5, WINED3DTSS_TEXCOORDINDEX),    tex_coordindex      }},
5396     { STATE_TEXTURESTAGE(5, WINED3DTSS_BUMPENVLSCALE),    { STATE_TEXTURESTAGE(5, WINED3DTSS_BUMPENVLSCALE),    tex_bumpenvlscale   }},
5397     { STATE_TEXTURESTAGE(5, WINED3DTSS_BUMPENVLOFFSET),   { STATE_TEXTURESTAGE(5, WINED3DTSS_BUMPENVLOFFSET),   tex_bumpenvloffset  }},
5398     { STATE_TEXTURESTAGE(5, WINED3DTSS_COLORARG0),        { STATE_TEXTURESTAGE(5, WINED3DTSS_COLOROP),          tex_colorop         }},
5399     { STATE_TEXTURESTAGE(5, WINED3DTSS_ALPHAARG0),        { STATE_TEXTURESTAGE(5, WINED3DTSS_ALPHAOP),          tex_alphaop         }},
5400     { STATE_TEXTURESTAGE(5, WINED3DTSS_RESULTARG),        { STATE_TEXTURESTAGE(5, WINED3DTSS_COLOROP),          tex_colorop         }},
5401     { STATE_TEXTURESTAGE(5, WINED3DTSS_CONSTANT),         { 0 /* As long as we don't support D3DTA_CONSTANT */, state_nogl          }},
5402     { STATE_TEXTURESTAGE(6, WINED3DTSS_COLOROP),          { STATE_TEXTURESTAGE(6, WINED3DTSS_COLOROP),          tex_colorop         }},
5403     { STATE_TEXTURESTAGE(6, WINED3DTSS_COLORARG1),        { STATE_TEXTURESTAGE(6, WINED3DTSS_COLOROP),          tex_colorop         }},
5404     { STATE_TEXTURESTAGE(6, WINED3DTSS_COLORARG2),        { STATE_TEXTURESTAGE(6, WINED3DTSS_COLOROP),          tex_colorop         }},
5405     { STATE_TEXTURESTAGE(6, WINED3DTSS_ALPHAOP),          { STATE_TEXTURESTAGE(6, WINED3DTSS_ALPHAOP),          tex_alphaop         }},
5406     { STATE_TEXTURESTAGE(6, WINED3DTSS_ALPHAARG1),        { STATE_TEXTURESTAGE(6, WINED3DTSS_ALPHAOP),          tex_alphaop         }},
5407     { STATE_TEXTURESTAGE(6, WINED3DTSS_ALPHAARG2),        { STATE_TEXTURESTAGE(6, WINED3DTSS_ALPHAOP),          tex_alphaop         }},
5408     { STATE_TEXTURESTAGE(6, WINED3DTSS_BUMPENVMAT00),     { STATE_TEXTURESTAGE(6, WINED3DTSS_BUMPENVMAT00),     tex_bumpenvmat      }},
5409     { STATE_TEXTURESTAGE(6, WINED3DTSS_BUMPENVMAT01),     { STATE_TEXTURESTAGE(6, WINED3DTSS_BUMPENVMAT00),     tex_bumpenvmat      }},
5410     { STATE_TEXTURESTAGE(6, WINED3DTSS_BUMPENVMAT10),     { STATE_TEXTURESTAGE(6, WINED3DTSS_BUMPENVMAT00),     tex_bumpenvmat      }},
5411     { STATE_TEXTURESTAGE(6, WINED3DTSS_BUMPENVMAT11),     { STATE_TEXTURESTAGE(6, WINED3DTSS_BUMPENVMAT00),     tex_bumpenvmat      }},
5412     { STATE_TEXTURESTAGE(6, WINED3DTSS_TEXCOORDINDEX),    { STATE_TEXTURESTAGE(6, WINED3DTSS_TEXCOORDINDEX),    tex_coordindex      }},
5413     { STATE_TEXTURESTAGE(6, WINED3DTSS_BUMPENVLSCALE),    { STATE_TEXTURESTAGE(6, WINED3DTSS_BUMPENVLSCALE),    tex_bumpenvlscale   }},
5414     { STATE_TEXTURESTAGE(6, WINED3DTSS_BUMPENVLOFFSET),   { STATE_TEXTURESTAGE(6, WINED3DTSS_BUMPENVLOFFSET),   tex_bumpenvloffset  }},
5415     { STATE_TEXTURESTAGE(6, WINED3DTSS_COLORARG0),        { STATE_TEXTURESTAGE(6, WINED3DTSS_COLOROP),          tex_colorop         }},
5416     { STATE_TEXTURESTAGE(6, WINED3DTSS_ALPHAARG0),        { STATE_TEXTURESTAGE(6, WINED3DTSS_ALPHAOP),          tex_alphaop         }},
5417     { STATE_TEXTURESTAGE(6, WINED3DTSS_RESULTARG),        { STATE_TEXTURESTAGE(6, WINED3DTSS_COLOROP),          tex_colorop         }},
5418     { STATE_TEXTURESTAGE(6, WINED3DTSS_CONSTANT),         { 0 /* As long as we don't support D3DTA_CONSTANT */, state_nogl          }},
5419     { STATE_TEXTURESTAGE(7, WINED3DTSS_COLOROP),          { STATE_TEXTURESTAGE(7, WINED3DTSS_COLOROP),          tex_colorop         }},
5420     { STATE_TEXTURESTAGE(7, WINED3DTSS_COLORARG1),        { STATE_TEXTURESTAGE(7, WINED3DTSS_COLOROP),          tex_colorop         }},
5421     { STATE_TEXTURESTAGE(7, WINED3DTSS_COLORARG2),        { STATE_TEXTURESTAGE(7, WINED3DTSS_COLOROP),          tex_colorop         }},
5422     { STATE_TEXTURESTAGE(7, WINED3DTSS_ALPHAOP),          { STATE_TEXTURESTAGE(7, WINED3DTSS_ALPHAOP),          tex_alphaop         }},
5423     { STATE_TEXTURESTAGE(7, WINED3DTSS_ALPHAARG1),        { STATE_TEXTURESTAGE(7, WINED3DTSS_ALPHAOP),          tex_alphaop         }},
5424     { STATE_TEXTURESTAGE(7, WINED3DTSS_ALPHAARG2),        { STATE_TEXTURESTAGE(7, WINED3DTSS_ALPHAOP),          tex_alphaop         }},
5425     { STATE_TEXTURESTAGE(7, WINED3DTSS_BUMPENVMAT00),     { STATE_TEXTURESTAGE(7, WINED3DTSS_BUMPENVMAT00),     tex_bumpenvmat      }},
5426     { STATE_TEXTURESTAGE(7, WINED3DTSS_BUMPENVMAT01),     { STATE_TEXTURESTAGE(7, WINED3DTSS_BUMPENVMAT00),     tex_bumpenvmat      }},
5427     { STATE_TEXTURESTAGE(7, WINED3DTSS_BUMPENVMAT10),     { STATE_TEXTURESTAGE(7, WINED3DTSS_BUMPENVMAT00),     tex_bumpenvmat      }},
5428     { STATE_TEXTURESTAGE(7, WINED3DTSS_BUMPENVMAT11),     { STATE_TEXTURESTAGE(7, WINED3DTSS_BUMPENVMAT00),     tex_bumpenvmat      }},
5429     { STATE_TEXTURESTAGE(7, WINED3DTSS_TEXCOORDINDEX),    { STATE_TEXTURESTAGE(7, WINED3DTSS_TEXCOORDINDEX),    tex_coordindex      }},
5430     { STATE_TEXTURESTAGE(7, WINED3DTSS_BUMPENVLSCALE),    { STATE_TEXTURESTAGE(7, WINED3DTSS_BUMPENVLSCALE),    tex_bumpenvlscale   }},
5431     { STATE_TEXTURESTAGE(7, WINED3DTSS_BUMPENVLOFFSET),   { STATE_TEXTURESTAGE(7, WINED3DTSS_BUMPENVLOFFSET),   tex_bumpenvloffset  }},
5432     { STATE_TEXTURESTAGE(7, WINED3DTSS_COLORARG0),        { STATE_TEXTURESTAGE(7, WINED3DTSS_COLOROP),          tex_colorop         }},
5433     { STATE_TEXTURESTAGE(7, WINED3DTSS_ALPHAARG0),        { STATE_TEXTURESTAGE(7, WINED3DTSS_ALPHAOP),          tex_alphaop         }},
5434     { STATE_TEXTURESTAGE(7, WINED3DTSS_RESULTARG),        { STATE_TEXTURESTAGE(7, WINED3DTSS_COLOROP),          tex_colorop         }},
5435     { STATE_TEXTURESTAGE(7, WINED3DTSS_CONSTANT),         { 0 /* As long as we don't support D3DTA_CONSTANT */, state_nogl          }},
5436     { STATE_PIXELSHADER,                                  { STATE_PIXELSHADER,                                  pixelshader         }},
5437     { STATE_RENDER(WINED3DRS_BORDERCOLOR),                { STATE_RENDER(WINED3DRS_BORDERCOLOR),                state_bordercolor   }},
5438     { STATE_RENDER(WINED3DRS_TEXTUREFACTOR),              { STATE_RENDER(WINED3DRS_TEXTUREFACTOR),              state_texfactor     }},
5439     {0 /* Terminate */,                                   { 0,                                                  0                   }},
5440 };
5441
5442 static int num_handlers(APPLYSTATEFUNC *funcs) {
5443     unsigned int i;
5444     for(i = 0; funcs[i]; i++);
5445     return i;
5446 }
5447
5448 static void multistate_apply_2(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
5449     stateblock->wineD3DDevice->multistate_funcs[state][0](state, stateblock, context);
5450     stateblock->wineD3DDevice->multistate_funcs[state][1](state, stateblock, context);
5451 }
5452
5453 static void multistate_apply_3(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
5454     stateblock->wineD3DDevice->multistate_funcs[state][0](state, stateblock, context);
5455     stateblock->wineD3DDevice->multistate_funcs[state][1](state, stateblock, context);
5456     stateblock->wineD3DDevice->multistate_funcs[state][2](state, stateblock, context);
5457 }
5458
5459 void compile_state_table(struct StateEntry *StateTable,
5460                          APPLYSTATEFUNC **dev_multistate_funcs,
5461                          const struct StateEntryTemplate *vertex,
5462                          const struct StateEntryTemplate *fragment,
5463                          const struct StateEntryTemplate *misc) {
5464     unsigned int i, type, handlers;
5465     APPLYSTATEFUNC multistate_funcs[STATE_HIGHEST + 1][3];
5466     const struct StateEntryTemplate *cur;
5467
5468     /* TODO: Remove this once all states are provided by templates */
5469     BOOL set[STATE_HIGHEST + 1];
5470     memset(set, 0, sizeof(set));
5471
5472     memset(multistate_funcs, 0, sizeof(multistate_funcs));
5473
5474     for(i = 0; i < STATE_HIGHEST + 1; i++) {
5475         StateTable[i].representative = 0;
5476         StateTable[i].apply = state_undefined;
5477     }
5478
5479     for(type = 0; type < 3; type++) {
5480         /* This switch decides the order in which the states are applied */
5481         switch(type) {
5482             case 0: cur = misc; break;
5483             case 1: cur = fragment; break;
5484             case 2: cur = vertex; break;
5485             default: cur = NULL; /* Stupid compiler */
5486         }
5487         if(!cur) continue;
5488
5489         for(i = 0; cur[i].state; i++) {
5490             set[cur[i].state] = TRUE; /* TODO: Remove when done with the move */
5491             handlers = num_handlers(multistate_funcs[cur[i].state]);
5492             multistate_funcs[cur[i].state][handlers] = cur[i].content.apply;
5493             switch(handlers) {
5494                 case 0:
5495                     StateTable[cur[i].state].apply = cur[i].content.apply;
5496                     break;
5497                 case 1:
5498                     StateTable[cur[i].state].apply = multistate_apply_2;
5499                     dev_multistate_funcs[cur[i].state] = HeapAlloc(GetProcessHeap(),
5500                                                                    0,
5501                                                                    sizeof(**dev_multistate_funcs) * 2);
5502                     dev_multistate_funcs[cur[i].state][0] = multistate_funcs[cur[i].state][0];
5503                     dev_multistate_funcs[cur[i].state][1] = multistate_funcs[cur[i].state][1];
5504                     break;
5505                 case 2:
5506                     StateTable[cur[i].state].apply = multistate_apply_3;
5507                     HeapFree(GetProcessHeap(), 0, multistate_funcs[cur[i].state]);
5508                     dev_multistate_funcs[cur[i].state] = HeapAlloc(GetProcessHeap(),
5509                                                                    0,
5510                                                                    sizeof(**dev_multistate_funcs) * 3);
5511                     dev_multistate_funcs[cur[i].state][0] = multistate_funcs[cur[i].state][0];
5512                     dev_multistate_funcs[cur[i].state][1] = multistate_funcs[cur[i].state][1];
5513                     dev_multistate_funcs[cur[i].state][2] = multistate_funcs[cur[i].state][2];
5514                     break;
5515                 default:
5516                     ERR("Unexpected amount of state handlers for state %u: %u\n",
5517                         cur[i].state, handlers + 1);
5518             }
5519
5520             if(StateTable[cur[i].state].representative &&
5521             StateTable[cur[i].state].representative != cur[i].content.representative) {
5522                 FIXME("State %u has different representatives in different pipeline parts\n",
5523                     cur[i].state);
5524             }
5525             StateTable[cur[i].state].representative = cur[i].content.representative;
5526         }
5527     }
5528
5529     /* TODO Remove this after the state move is done */
5530     for(i = 0; i < STATE_HIGHEST + 1; i++) {
5531         if(set[i]) continue;
5532         StateTable[i] = FFPStateTable[i];
5533     }
5534 }