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-2007 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 ((IWineD3DImpl *)(stateblock->wineD3DDevice->wineD3D))->gl_info
  38
  39 static void state_nogl(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
  40     /* Used for states which are not mapped to a gl state as-is, but used somehow different,
  41      * e.g as a parameter for drawing, or which are unimplemented in windows d3d
  42      */
  43     if(STATE_IS_RENDER(state)) {
  44         WINED3DRENDERSTATETYPE RenderState = state - STATE_RENDER(0);
  45         TRACE("(%s,%d) no direct mapping to gl\n", debug_d3drenderstate(RenderState), stateblock->renderState[RenderState]);
  46     } else {
  47         /* Shouldn't have an unknown type here */
  48         FIXME("%d no direct mapping to gl of state with unknown type\n", state);
  49     }
  50 }
  51
  52 static void state_undefined(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
  53     /* Print a WARN, this allows the stateblock code to loop over all states to generate a display
  54      * list without causing confusing terminal output. Deliberately no special debug name here
  55      * because its undefined.
  56      */
  57     WARN("undefined state %d\n", state);
  58 }
  59
  60 static void state_fillmode(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
  61     D3DFILLMODE Value = stateblock->renderState[WINED3DRS_FILLMODE];
  62
  63     switch(Value) {
  64         case D3DFILL_POINT:
  65             glPolygonMode(GL_FRONT_AND_BACK, GL_POINT);
  66             checkGLcall("glPolygonMode(GL_FRONT_AND_BACK, GL_POINT)");
  67             break;
  68         case D3DFILL_WIREFRAME:
  69             glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
  70             checkGLcall("glPolygonMode(GL_FRONT_AND_BACK, GL_LINE)");
  71             break;
  72         case D3DFILL_SOLID:
  73             glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
  74             checkGLcall("glPolygonMode(GL_FRONT_AND_BACK, GL_FILL)");
  75             break;
  76         default:
  77             FIXME("Unrecognized WINED3DRS_FILLMODE value %d\n", Value);
  78     }
  79 }
  80
  81 static void state_lighting(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
  82     BOOL normals;
  83
  84     /* Lighting is only enabled if Vertex normals are passed by the application,
  85      * but lighting does not affect the stream sources, so it is not grouped for performance reasons.
  86      * This state reads the decoded vertex decl, so if it is dirty don't do anything. The
  87      * vertex declaration appplying function calls this function for updating
  88      */
  89
  90     if(isStateDirty(context, STATE_VDECL)) {
  91         return;
  92     }
  93
  94     normals = stateblock->wineD3DDevice->strided_streams.u.s.normal.lpData != NULL ||
  95               stateblock->wineD3DDevice->strided_streams.u.s.normal.VBO != 0;
  96
  97     if (stateblock->renderState[WINED3DRS_LIGHTING] && normals) {
  98         glEnable(GL_LIGHTING);
  99         checkGLcall("glEnable GL_LIGHTING");
 100     } else {
 101         glDisable(GL_LIGHTING);
 102         checkGLcall("glDisable GL_LIGHTING");
 103     }
 104 }
 105
 106 static void state_zenable(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
 107     switch ((WINED3DZBUFFERTYPE) stateblock->renderState[WINED3DRS_ZENABLE]) {
 108         case WINED3DZB_FALSE:
 109             glDisable(GL_DEPTH_TEST);
 110             checkGLcall("glDisable GL_DEPTH_TEST");
 111             break;
 112         case WINED3DZB_TRUE:
 113             glEnable(GL_DEPTH_TEST);
 114             checkGLcall("glEnable GL_DEPTH_TEST");
 115             break;
 116         case WINED3DZB_USEW:
 117             glEnable(GL_DEPTH_TEST);
 118             checkGLcall("glEnable GL_DEPTH_TEST");
 119             FIXME("W buffer is not well handled\n");
 120             break;
 121         default:
 122             FIXME("Unrecognized D3DZBUFFERTYPE value %d\n", stateblock->renderState[WINED3DRS_ZENABLE]);
 123     }
 124 }
 125
 126 static void state_cullmode(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
 127     /* TODO: Put this into the offscreen / onscreen rendering block due to device->render_offscreen */
 128
 129     /* If we are culling "back faces with clockwise vertices" then
 130        set front faces to be counter clockwise and enable culling
 131        of back faces                                               */
 132     switch ((WINED3DCULL) stateblock->renderState[WINED3DRS_CULLMODE]) {
 133         case WINED3DCULL_NONE:
 134             glDisable(GL_CULL_FACE);
 135             checkGLcall("glDisable GL_CULL_FACE");
 136             break;
 137         case WINED3DCULL_CW:
 138             glEnable(GL_CULL_FACE);
 139             checkGLcall("glEnable GL_CULL_FACE");
 140             if (stateblock->wineD3DDevice->render_offscreen) {
 141                 glFrontFace(GL_CW);
 142                 checkGLcall("glFrontFace GL_CW");
 143             } else {
 144                 glFrontFace(GL_CCW);
 145                 checkGLcall("glFrontFace GL_CCW");
 146             }
 147             glCullFace(GL_BACK);
 148             break;
 149         case WINED3DCULL_CCW:
 150             glEnable(GL_CULL_FACE);
 151             checkGLcall("glEnable GL_CULL_FACE");
 152             if (stateblock->wineD3DDevice->render_offscreen) {
 153                 glFrontFace(GL_CCW);
 154                 checkGLcall("glFrontFace GL_CCW");
 155             } else {
 156                 glFrontFace(GL_CW);
 157                 checkGLcall("glFrontFace GL_CW");
 158             }
 159             glCullFace(GL_BACK);
 160             break;
 161         default:
 162             FIXME("Unrecognized/Unhandled WINED3DCULL value %d\n", stateblock->renderState[WINED3DRS_CULLMODE]);
 163     }
 164 }
 165
 166 static void state_shademode(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
 167     switch ((WINED3DSHADEMODE) stateblock->renderState[WINED3DRS_SHADEMODE]) {
 168         case WINED3DSHADE_FLAT:
 169             glShadeModel(GL_FLAT);
 170             checkGLcall("glShadeModel(GL_FLAT)");
 171             break;
 172         case WINED3DSHADE_GOURAUD:
 173             glShadeModel(GL_SMOOTH);
 174             checkGLcall("glShadeModel(GL_SMOOTH)");
 175             break;
 176         case WINED3DSHADE_PHONG:
 177             FIXME("WINED3DSHADE_PHONG isn't supported\n");
 178             break;
 179         default:
 180             FIXME("Unrecognized/Unhandled WINED3DSHADEMODE value %d\n", stateblock->renderState[WINED3DRS_SHADEMODE]);
 181     }
 182 }
 183
 184 static void state_ditherenable(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
 185     if (stateblock->renderState[WINED3DRS_DITHERENABLE]) {
 186         glEnable(GL_DITHER);
 187         checkGLcall("glEnable GL_DITHER");
 188     } else {
 189         glDisable(GL_DITHER);
 190         checkGLcall("glDisable GL_DITHER");
 191     }
 192 }
 193
 194 static void state_zwritenable(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
 195     /* TODO: Test if in d3d z writing is enabled even if ZENABLE is off. If yes,
 196      * this has to be merged with ZENABLE and ZFUNC
 197      */
 198     if (stateblock->renderState[WINED3DRS_ZWRITEENABLE]) {
 199         glDepthMask(1);
 200         checkGLcall("glDepthMask(1)");
 201     } else {
 202         glDepthMask(0);
 203         checkGLcall("glDepthMask(0)");
 204     }
 205 }
 206
 207 static void state_zfunc(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
 208     int glParm = CompareFunc(stateblock->renderState[WINED3DRS_ZFUNC]);
 209
 210     if(glParm) {
 211         glDepthFunc(glParm);
 212         checkGLcall("glDepthFunc");
 213     }
 214 }
 215
 216 static void state_ambient(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
 217     float col[4];
 218     D3DCOLORTOGLFLOAT4(stateblock->renderState[WINED3DRS_AMBIENT], col);
 219
 220     TRACE("Setting ambient to (%f,%f,%f,%f)\n", col[0], col[1], col[2], col[3]);
 221     glLightModelfv(GL_LIGHT_MODEL_AMBIENT, col);
 222     checkGLcall("glLightModel for MODEL_AMBIENT");
 223 }
 224
 225 static void state_blend(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
 226     int srcBlend = GL_ZERO;
 227     int dstBlend = GL_ZERO;
 228
 229     /* GL_LINE_SMOOTH needs GL_BLEND to work, according to the red book, and special blending params */
 230     if (stateblock->renderState[WINED3DRS_ALPHABLENDENABLE]      ||
 231         stateblock->renderState[WINED3DRS_EDGEANTIALIAS]         ||
 232         stateblock->renderState[WINED3DRS_ANTIALIASEDLINEENABLE]) {
 233         glEnable(GL_BLEND);
 234         checkGLcall("glEnable GL_BLEND");
 235     } else {
 236         glDisable(GL_BLEND);
 237         checkGLcall("glDisable GL_BLEND");
 238         /* Nothing more to do - get out */
 239         return;
 240     };
 241
 242     switch (stateblock->renderState[WINED3DRS_SRCBLEND]) {
 243         case WINED3DBLEND_ZERO               : srcBlend = GL_ZERO;  break;
 244         case WINED3DBLEND_ONE                : srcBlend = GL_ONE;  break;
 245         case WINED3DBLEND_SRCCOLOR           : srcBlend = GL_SRC_COLOR;  break;
 246         case WINED3DBLEND_INVSRCCOLOR        : srcBlend = GL_ONE_MINUS_SRC_COLOR;  break;
 247         case WINED3DBLEND_SRCALPHA           : srcBlend = GL_SRC_ALPHA;  break;
 248         case WINED3DBLEND_INVSRCALPHA        : srcBlend = GL_ONE_MINUS_SRC_ALPHA;  break;
 249         case WINED3DBLEND_DESTALPHA          : srcBlend = GL_DST_ALPHA;  break;
 250         case WINED3DBLEND_INVDESTALPHA       : srcBlend = GL_ONE_MINUS_DST_ALPHA;  break;
 251         case WINED3DBLEND_DESTCOLOR          : srcBlend = GL_DST_COLOR;  break;
 252         case WINED3DBLEND_INVDESTCOLOR       : srcBlend = GL_ONE_MINUS_DST_COLOR;  break;
 253         case WINED3DBLEND_SRCALPHASAT        : srcBlend = GL_SRC_ALPHA_SATURATE;  break;
 254
 255         case WINED3DBLEND_BOTHSRCALPHA       : srcBlend = GL_SRC_ALPHA;
 256             dstBlend = GL_SRC_ALPHA;
 257             break;
 258
 259         case WINED3DBLEND_BOTHINVSRCALPHA    : srcBlend = GL_ONE_MINUS_SRC_ALPHA;
 260             dstBlend = GL_ONE_MINUS_SRC_ALPHA;
 261             break;
 262
 263         case WINED3DBLEND_BLENDFACTOR        : srcBlend = GL_CONSTANT_COLOR;   break;
 264         case WINED3DBLEND_INVBLENDFACTOR     : srcBlend = GL_ONE_MINUS_CONSTANT_COLOR;  break;
 265         default:
 266             FIXME("Unrecognized src blend value %d\n", stateblock->renderState[WINED3DRS_SRCBLEND]);
 267     }
 268
 269     switch (stateblock->renderState[WINED3DRS_DESTBLEND]) {
 270         case WINED3DBLEND_ZERO               : dstBlend = GL_ZERO;  break;
 271         case WINED3DBLEND_ONE                : dstBlend = GL_ONE;  break;
 272         case WINED3DBLEND_SRCCOLOR           : dstBlend = GL_SRC_COLOR;  break;
 273         case WINED3DBLEND_INVSRCCOLOR        : dstBlend = GL_ONE_MINUS_SRC_COLOR;  break;
 274         case WINED3DBLEND_SRCALPHA           : dstBlend = GL_SRC_ALPHA;  break;
 275         case WINED3DBLEND_INVSRCALPHA        : dstBlend = GL_ONE_MINUS_SRC_ALPHA;  break;
 276         case WINED3DBLEND_DESTALPHA          : dstBlend = GL_DST_ALPHA;  break;
 277         case WINED3DBLEND_INVDESTALPHA       : dstBlend = GL_ONE_MINUS_DST_ALPHA;  break;
 278         case WINED3DBLEND_DESTCOLOR          : dstBlend = GL_DST_COLOR;  break;
 279         case WINED3DBLEND_INVDESTCOLOR       : dstBlend = GL_ONE_MINUS_DST_COLOR;  break;
 280         case WINED3DBLEND_SRCALPHASAT        : dstBlend = GL_SRC_ALPHA_SATURATE;  break;
 281
 282         case WINED3DBLEND_BOTHSRCALPHA       : dstBlend = GL_SRC_ALPHA;
 283             srcBlend = GL_SRC_ALPHA;
 284             break;
 285
 286         case WINED3DBLEND_BOTHINVSRCALPHA    : dstBlend = GL_ONE_MINUS_SRC_ALPHA;
 287             srcBlend = GL_ONE_MINUS_SRC_ALPHA;
 288             break;
 289
 290         case D3DBLEND_BLENDFACTOR        : dstBlend = GL_CONSTANT_COLOR;   break;
 291         case D3DBLEND_INVBLENDFACTOR     : dstBlend = GL_ONE_MINUS_CONSTANT_COLOR;  break;
 292         default:
 293             FIXME("Unrecognized dst blend value %d\n", stateblock->renderState[WINED3DRS_DESTBLEND]);
 294     }
 295
 296     if(stateblock->renderState[WINED3DRS_EDGEANTIALIAS] ||
 297        stateblock->renderState[WINED3DRS_ANTIALIASEDLINEENABLE]) {
 298         glEnable(GL_LINE_SMOOTH);
 299         checkGLcall("glEnable(GL_LINE_SMOOTH)");
 300         if(srcBlend != GL_SRC_ALPHA) {
 301             FIXME("WINED3DRS_EDGEANTIALIAS enabled, but incompatible src blending param - what to do?\n");
 302             srcBlend = GL_SRC_ALPHA;
 303         }
 304         if(dstBlend != GL_ONE_MINUS_SRC_ALPHA) {
 305             FIXME("WINED3DRS_EDGEANTIALIAS enabled, but incompatible dst blending param - what to do?\n");
 306             dstBlend = GL_ONE_MINUS_SRC_ALPHA;
 307         }
 308     } else {
 309         glDisable(GL_LINE_SMOOTH);
 310         checkGLcall("glDisable(GL_LINE_SMOOTH)");
 311     }
 312
 313     TRACE("glBlendFunc src=%x, dst=%x\n", srcBlend, dstBlend);
 314     glBlendFunc(srcBlend, dstBlend);
 315     checkGLcall("glBlendFunc");
 316 }
 317
 318 static void state_blendfactor(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
 319     float col[4];
 320
 321     TRACE("Setting BlendFactor to %d\n", stateblock->renderState[WINED3DRS_BLENDFACTOR]);
 322     D3DCOLORTOGLFLOAT4(stateblock->renderState[WINED3DRS_BLENDFACTOR], col);
 323     glBlendColor (col[0],col[1],col[2],col[3]);
 324     checkGLcall("glBlendColor");
 325 }
 326
 327 static void state_alpha(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
 328     int glParm = 0;
 329     float ref;
 330     BOOL enable_ckey = FALSE;
 331
 332     IWineD3DSurfaceImpl *surf;
 333
 334     /* Find out if the texture on the first stage has a ckey set
 335      * The alpha state func reads the texture settings, even though alpha and texture are not grouped
 336      * together. This is to avoid making a huge alpha+texture+texture stage+ckey block due to the hardly
 337      * used WINED3DRS_COLORKEYENABLE state(which is d3d <= 3 only). The texture function will call alpha
 338      * in case it finds some texture+colorkeyenable combination which needs extra care.
 339      */
 340     if(stateblock->textures[0]) {
 341         surf = (IWineD3DSurfaceImpl *) ((IWineD3DTextureImpl *)stateblock->textures[0])->surfaces[0];
 342         if(surf->CKeyFlags & DDSD_CKSRCBLT) enable_ckey = TRUE;
 343     }
 344
 345     if (stateblock->renderState[WINED3DRS_ALPHATESTENABLE] ||
 346         (stateblock->renderState[WINED3DRS_COLORKEYENABLE] && enable_ckey)) {
 347         glEnable(GL_ALPHA_TEST);
 348         checkGLcall("glEnable GL_ALPHA_TEST");
 349     } else {
 350         glDisable(GL_ALPHA_TEST);
 351         checkGLcall("glDisable GL_ALPHA_TEST");
 352         /* Alpha test is disabled, don't bother setting the params - it will happen on the next
 353          * enable call
 354          */
 355         return;
 356     }
 357
 358     if(stateblock->renderState[WINED3DRS_COLORKEYENABLE] && enable_ckey) {
 359         glParm = GL_NOTEQUAL;
 360         ref = 0.0;
 361     } else {
 362         ref = ((float) stateblock->renderState[WINED3DRS_ALPHAREF]) / 255.0f;
 363         glParm = CompareFunc(stateblock->renderState[WINED3DRS_ALPHAFUNC]);
 364     }
 365     if(glParm) {
 366         glAlphaFunc(glParm, ref);
 367         checkGLcall("glAlphaFunc");
 368     }
 369     /* TODO: Some texture blending operations seem to affect the alpha test */
 370 }
 371
 372 static void state_clipping(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
 373     DWORD enable  = 0xFFFFFFFF;
 374     DWORD disable = 0x00000000;
 375
 376     /* TODO: Keep track of previously enabled clipplanes to avoid unneccessary resetting
 377      * of already set values
 378      */
 379
 380     /* If enabling / disabling all
 381      * TODO: Is this correct? Doesn't D3DRS_CLIPPING disable clipping on the viewport frustrum?
 382      */
 383     if (stateblock->renderState[WINED3DRS_CLIPPING]) {
 384         enable  = stateblock->renderState[WINED3DRS_CLIPPLANEENABLE];
 385         disable = ~stateblock->renderState[WINED3DRS_CLIPPLANEENABLE];
 386     } else {
 387         disable = 0xffffffff;
 388         enable  = 0x00;
 389     }
 390
 391     if (enable & WINED3DCLIPPLANE0)  { glEnable(GL_CLIP_PLANE0);  checkGLcall("glEnable(clip plane 0)"); }
 392     if (enable & WINED3DCLIPPLANE1)  { glEnable(GL_CLIP_PLANE1);  checkGLcall("glEnable(clip plane 1)"); }
 393     if (enable & WINED3DCLIPPLANE2)  { glEnable(GL_CLIP_PLANE2);  checkGLcall("glEnable(clip plane 2)"); }
 394     if (enable & WINED3DCLIPPLANE3)  { glEnable(GL_CLIP_PLANE3);  checkGLcall("glEnable(clip plane 3)"); }
 395     if (enable & WINED3DCLIPPLANE4)  { glEnable(GL_CLIP_PLANE4);  checkGLcall("glEnable(clip plane 4)"); }
 396     if (enable & WINED3DCLIPPLANE5)  { glEnable(GL_CLIP_PLANE5);  checkGLcall("glEnable(clip plane 5)"); }
 397
 398     if (disable & WINED3DCLIPPLANE0) { glDisable(GL_CLIP_PLANE0); checkGLcall("glDisable(clip plane 0)"); }
 399     if (disable & WINED3DCLIPPLANE1) { glDisable(GL_CLIP_PLANE1); checkGLcall("glDisable(clip plane 1)"); }
 400     if (disable & WINED3DCLIPPLANE2) { glDisable(GL_CLIP_PLANE2); checkGLcall("glDisable(clip plane 2)"); }
 401     if (disable & WINED3DCLIPPLANE3) { glDisable(GL_CLIP_PLANE3); checkGLcall("glDisable(clip plane 3)"); }
 402     if (disable & WINED3DCLIPPLANE4) { glDisable(GL_CLIP_PLANE4); checkGLcall("glDisable(clip plane 4)"); }
 403     if (disable & WINED3DCLIPPLANE5) { glDisable(GL_CLIP_PLANE5); checkGLcall("glDisable(clip plane 5)"); }
 404
 405     /** update clipping status */
 406     if (enable) {
 407         stateblock->clip_status.ClipUnion = 0;
 408         stateblock->clip_status.ClipIntersection = 0xFFFFFFFF;
 409     } else {
 410         stateblock->clip_status.ClipUnion = 0;
 411         stateblock->clip_status.ClipIntersection = 0;
 412     }
 413 }
 414
 415 static void state_blendop(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
 416     int glParm = GL_FUNC_ADD;
 417
 418     if(!GL_SUPPORT(EXT_BLEND_MINMAX)) {
 419         WARN("Unsupported in local OpenGL implementation: glBlendEquation\n");
 420         return;
 421     }
 422
 423     switch ((WINED3DBLENDOP) stateblock->renderState[WINED3DRS_BLENDOP]) {
 424         case WINED3DBLENDOP_ADD              : glParm = GL_FUNC_ADD;              break;
 425         case WINED3DBLENDOP_SUBTRACT         : glParm = GL_FUNC_SUBTRACT;         break;
 426         case WINED3DBLENDOP_REVSUBTRACT      : glParm = GL_FUNC_REVERSE_SUBTRACT; break;
 427         case WINED3DBLENDOP_MIN              : glParm = GL_MIN;                   break;
 428         case WINED3DBLENDOP_MAX              : glParm = GL_MAX;                   break;
 429         default:
 430             FIXME("Unrecognized/Unhandled D3DBLENDOP value %d\n", stateblock->renderState[WINED3DRS_BLENDOP]);
 431     }
 432
 433     TRACE("glBlendEquation(%x)\n", glParm);
 434     GL_EXTCALL(glBlendEquation(glParm));
 435     checkGLcall("glBlendEquation");
 436 }
 437
 438 static void
 439 state_specularenable(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
 440     /* Originally this used glLightModeli(GL_LIGHT_MODEL_COLOR_CONTROL,GL_SEPARATE_SPECULAR_COLOR)
 441      * and (GL_LIGHT_MODEL_COLOR_CONTROL,GL_SINGLE_COLOR) to swap between enabled/disabled
 442      * specular color. This is wrong:
 443      * Separate specular color means the specular colour is maintained separately, whereas
 444      * single color means it is merged in. However in both cases they are being used to
 445      * some extent.
 446      * To disable specular color, set it explicitly to black and turn off GL_COLOR_SUM_EXT
 447      * NOTE: If not supported don't give FIXMEs the impact is really minimal and very few people are
 448      * running 1.4 yet!
 449      *
 450      *
 451      * If register combiners are enabled, enabling / disabling GL_COLOR_SUM has no effect.
 452      * Instead, we need to setup the FinalCombiner properly.
 453      *
 454      * The default setup for the FinalCombiner is:
 455      *
 456      * <variable>       <input>                             <mapping>               <usage>
 457      * GL_VARIABLE_A_NV GL_FOG,                             GL_UNSIGNED_IDENTITY_NV GL_ALPHA
 458      * GL_VARIABLE_B_NV GL_SPARE0_PLUS_SECONDARY_COLOR_NV   GL_UNSIGNED_IDENTITY_NV GL_RGB
 459      * GL_VARIABLE_C_NV GL_FOG                              GL_UNSIGNED_IDENTITY_NV GL_RGB
 460      * GL_VARIABLE_D_NV GL_ZERO                             GL_UNSIGNED_IDENTITY_NV GL_RGB
 461      * GL_VARIABLE_E_NV GL_ZERO                             GL_UNSIGNED_IDENTITY_NV GL_RGB
 462      * GL_VARIABLE_F_NV GL_ZERO                             GL_UNSIGNED_IDENTITY_NV GL_RGB
 463      * GL_VARIABLE_G_NV GL_SPARE0_NV                        GL_UNSIGNED_IDENTITY_NV GL_ALPHA
 464      *
 465      * That's pretty much fine as it is, except for variable B, which needs to take
 466      * either GL_SPARE0_PLUS_SECONDARY_COLOR_NV or GL_SPARE0_NV, depending on
 467      * whether WINED3DRS_SPECULARENABLE is enabled or not.
 468      */
 469
 470     TRACE("Setting specular enable state\n");
 471     /* TODO: Add to the material setting functions */
 472     if (stateblock->renderState[WINED3DRS_SPECULARENABLE]) {
 473         glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, (float*) &stateblock->material.Specular);
 474         checkGLcall("glMaterialfv");
 475         if (GL_SUPPORT(EXT_SECONDARY_COLOR)) {
 476             glEnable(GL_COLOR_SUM_EXT);
 477         } else {
 478             TRACE("Specular colors cannot be enabled in this version of opengl\n");
 479         }
 480         checkGLcall("glEnable(GL_COLOR_SUM)");
 481
 482         if (GL_SUPPORT(NV_REGISTER_COMBINERS)) {
 483             GL_EXTCALL(glFinalCombinerInputNV(GL_VARIABLE_B_NV, GL_SPARE0_PLUS_SECONDARY_COLOR_NV, GL_UNSIGNED_IDENTITY_NV, GL_RGB));
 484             checkGLcall("glFinalCombinerInputNV()");
 485         }
 486     } else {
 487         float black[4] = {0.0f, 0.0f, 0.0f, 0.0f};
 488
 489         /* for the case of enabled lighting: */
 490         glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, &black[0]);
 491         checkGLcall("glMaterialfv");
 492
 493         /* for the case of disabled lighting: */
 494         if (GL_SUPPORT(EXT_SECONDARY_COLOR)) {
 495             glDisable(GL_COLOR_SUM_EXT);
 496         } else {
 497             TRACE("Specular colors cannot be disabled in this version of opengl\n");
 498         }
 499         checkGLcall("glDisable(GL_COLOR_SUM)");
 500
 501         if (GL_SUPPORT(NV_REGISTER_COMBINERS)) {
 502             GL_EXTCALL(glFinalCombinerInputNV(GL_VARIABLE_B_NV, GL_SPARE0_NV, GL_UNSIGNED_IDENTITY_NV, GL_RGB));
 503             checkGLcall("glFinalCombinerInputNV()");
 504         }
 505     }
 506 }
 507
 508 static void state_texfactor(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
 509     unsigned int i;
 510
 511     /* Note the texture color applies to all textures whereas
 512      * GL_TEXTURE_ENV_COLOR applies to active only
 513      */
 514     float col[4];
 515     D3DCOLORTOGLFLOAT4(stateblock->renderState[WINED3DRS_TEXTUREFACTOR], col);
 516
 517     if (!GL_SUPPORT(NV_REGISTER_COMBINERS)) {
 518         /* And now the default texture color as well */
 519         for (i = 0; i < GL_LIMITS(texture_stages); i++) {
 520             /* Note the WINED3DRS value applies to all textures, but GL has one
 521              * per texture, so apply it now ready to be used!
 522              */
 523             if (GL_SUPPORT(ARB_MULTITEXTURE)) {
 524                 GL_EXTCALL(glActiveTextureARB(GL_TEXTURE0_ARB + i));
 525                 checkGLcall("glActiveTextureARB");
 526             } else if (i>0) {
 527                 FIXME("Program using multiple concurrent textures which this opengl implementation doesn't support\n");
 528             }
 529
 530             glTexEnvfv(GL_TEXTURE_ENV, GL_TEXTURE_ENV_COLOR, &col[0]);
 531             checkGLcall("glTexEnvfv(GL_TEXTURE_ENV, GL_TEXTURE_ENV_COLOR, color);");
 532         }
 533     } else {
 534         GL_EXTCALL(glCombinerParameterfvNV(GL_CONSTANT_COLOR0_NV, &col[0]));
 535     }
 536 }
 537
 538 static void
 539 renderstate_stencil_twosided(IWineD3DStateBlockImpl *stateblock, GLint face, GLint func, GLint ref, GLuint mask, GLint stencilFail, GLint depthFail, GLint stencilPass ) {
 540 #if 0 /* Don't use OpenGL 2.0 calls for now */
 541             if(GL_EXTCALL(glStencilFuncSeparate) && GL_EXTCALL(glStencilOpSeparate)) {
 542                 GL_EXTCALL(glStencilFuncSeparate(face, func, ref, mask));
 543                 checkGLcall("glStencilFuncSeparate(...)");
 544                 GL_EXTCALL(glStencilOpSeparate(face, stencilFail, depthFail, stencilPass));
 545                 checkGLcall("glStencilOpSeparate(...)");
 546         }
 547             else
 548 #endif
 549     if(GL_SUPPORT(EXT_STENCIL_TWO_SIDE)) {
 550         glEnable(GL_STENCIL_TEST_TWO_SIDE_EXT);
 551         checkGLcall("glEnable(GL_STENCIL_TEST_TWO_SIDE_EXT)");
 552         GL_EXTCALL(glActiveStencilFaceEXT(face));
 553         checkGLcall("glActiveStencilFaceEXT(...)");
 554         glStencilFunc(func, ref, mask);
 555         checkGLcall("glStencilFunc(...)");
 556         glStencilOp(stencilFail, depthFail, stencilPass);
 557         checkGLcall("glStencilOp(...)");
 558     } else if(GL_SUPPORT(ATI_SEPARATE_STENCIL)) {
 559         GL_EXTCALL(glStencilFuncSeparateATI(face, func, ref, mask));
 560         checkGLcall("glStencilFuncSeparateATI(...)");
 561         GL_EXTCALL(glStencilOpSeparateATI(face, stencilFail, depthFail, stencilPass));
 562         checkGLcall("glStencilOpSeparateATI(...)");
 563     } else {
 564         ERR("Separate (two sided) stencil not supported on this version of opengl. Caps weren't honored?\n");
 565     }
 566 }
 567
 568 static void
 569 state_stencil(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
 570     DWORD onesided_enable = FALSE;
 571     DWORD twosided_enable = FALSE;
 572     GLint func = GL_ALWAYS;
 573     GLint func_ccw = GL_ALWAYS;
 574     GLint ref = 0;
 575     GLuint mask = 0;
 576     GLint stencilFail = GL_KEEP;
 577     GLint depthFail = GL_KEEP;
 578     GLint stencilPass = GL_KEEP;
 579     GLint stencilFail_ccw = GL_KEEP;
 580     GLint depthFail_ccw = GL_KEEP;
 581     GLint stencilPass_ccw = GL_KEEP;
 582
 583     if( stateblock->set.renderState[WINED3DRS_STENCILENABLE] )
 584         onesided_enable = stateblock->renderState[WINED3DRS_STENCILENABLE];
 585     if( stateblock->set.renderState[WINED3DRS_TWOSIDEDSTENCILMODE] )
 586         twosided_enable = stateblock->renderState[WINED3DRS_TWOSIDEDSTENCILMODE];
 587     if( stateblock->set.renderState[WINED3DRS_STENCILFUNC] )
 588         if( !( func = CompareFunc(stateblock->renderState[WINED3DRS_STENCILFUNC]) ) )
 589             func = GL_ALWAYS;
 590     if( stateblock->set.renderState[WINED3DRS_CCW_STENCILFUNC] )
 591         if( !( func_ccw = CompareFunc(stateblock->renderState[WINED3DRS_CCW_STENCILFUNC]) ) )
 592             func = GL_ALWAYS;
 593     if( stateblock->set.renderState[WINED3DRS_STENCILREF] )
 594         ref = stateblock->renderState[WINED3DRS_STENCILREF];
 595     if( stateblock->set.renderState[WINED3DRS_STENCILMASK] )
 596         mask = stateblock->renderState[WINED3DRS_STENCILMASK];
 597     if( stateblock->set.renderState[WINED3DRS_STENCILFAIL] )
 598         stencilFail = StencilOp(stateblock->renderState[WINED3DRS_STENCILFAIL]);
 599     if( stateblock->set.renderState[WINED3DRS_STENCILZFAIL] )
 600         depthFail = StencilOp(stateblock->renderState[WINED3DRS_STENCILZFAIL]);
 601     if( stateblock->set.renderState[WINED3DRS_STENCILPASS] )
 602         stencilPass = StencilOp(stateblock->renderState[WINED3DRS_STENCILPASS]);
 603     if( stateblock->set.renderState[WINED3DRS_CCW_STENCILFAIL] )
 604         stencilFail_ccw = StencilOp(stateblock->renderState[WINED3DRS_CCW_STENCILFAIL]);
 605     if( stateblock->set.renderState[WINED3DRS_CCW_STENCILZFAIL] )
 606         depthFail_ccw = StencilOp(stateblock->renderState[WINED3DRS_CCW_STENCILZFAIL]);
 607     if( stateblock->set.renderState[WINED3DRS_CCW_STENCILPASS] )
 608         stencilPass_ccw = StencilOp(stateblock->renderState[WINED3DRS_CCW_STENCILPASS]);
 609
 610     TRACE("(onesided %d, twosided %d, ref %x, mask %x, "
 611           "GL_FRONT: func: %x, fail %x, zfail %x, zpass %x "
 612           "GL_BACK: func: %x, fail %x, zfail %x, zpass %x )\n",
 613     onesided_enable, twosided_enable, ref, mask,
 614     func, stencilFail, depthFail, stencilPass,
 615     func_ccw, stencilFail_ccw, depthFail_ccw, stencilPass_ccw);
 616
 617     if (twosided_enable) {
 618         renderstate_stencil_twosided(stateblock, GL_FRONT, func, ref, mask, stencilFail, depthFail, stencilPass);
 619         renderstate_stencil_twosided(stateblock, GL_BACK, func_ccw, ref, mask, stencilFail_ccw, depthFail_ccw, stencilPass_ccw);
 620     } else {
 621         if (onesided_enable) {
 622             glEnable(GL_STENCIL_TEST);
 623             checkGLcall("glEnable GL_STENCIL_TEST");
 624             glStencilFunc(func, ref, mask);
 625             checkGLcall("glStencilFunc(...)");
 626             glStencilOp(stencilFail, depthFail, stencilPass);
 627             checkGLcall("glStencilOp(...)");
 628         } else {
 629             glDisable(GL_STENCIL_TEST);
 630             checkGLcall("glDisable GL_STENCIL_TEST");
 631         }
 632     }
 633 }
 634
 635 static void state_stencilwrite(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
 636     glStencilMask(stateblock->renderState[WINED3DRS_STENCILWRITEMASK]);
 637     checkGLcall("glStencilMask");
 638 }
 639
 640 static void state_fog(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
 641     /* TODO: Put this into the vertex type block once that is in the state table */
 642     BOOL fogenable = stateblock->renderState[WINED3DRS_FOGENABLE];
 643     float fogstart, fogend;
 644
 645     union {
 646         DWORD d;
 647         float f;
 648     } tmpvalue;
 649
 650     if (!fogenable) {
 651         /* No fog? Disable it, and we're done :-) */
 652         glDisable(GL_FOG);
 653         checkGLcall("glDisable GL_FOG");
 654     }
 655
 656     tmpvalue.d = stateblock->renderState[WINED3DRS_FOGSTART];
 657     fogstart = tmpvalue.f;
 658     tmpvalue.d = stateblock->renderState[WINED3DRS_FOGEND];
 659     fogend = tmpvalue.f;
 660
 661     /* Activate when vertex shaders are in the state table */
 662     if(stateblock->vertexShader && ((IWineD3DVertexShaderImpl *)stateblock->vertexShader)->baseShader.function &&
 663        ((IWineD3DVertexShaderImpl *)stateblock->vertexShader)->usesFog) {
 664         glFogi(GL_FOG_MODE, GL_LINEAR);
 665         checkGLcall("glFogi(GL_FOG_MODE, GL_LINEAR)");
 666         fogstart = 1.0;
 667         fogend = 0.0;
 668         context->last_was_foggy_shader = TRUE;
 669     }
 670     /* DX 7 sdk: "If both render states(vertex and table fog) are set to valid modes,
 671      * the system will apply only pixel(=table) fog effects."
 672      */
 673     else if(stateblock->renderState[WINED3DRS_FOGTABLEMODE] == D3DFOG_NONE) {
 674         glHint(GL_FOG_HINT, GL_FASTEST);
 675         checkGLcall("glHint(GL_FOG_HINT, GL_FASTEST)");
 676         context->last_was_foggy_shader = FALSE;
 677
 678         switch (stateblock->renderState[WINED3DRS_FOGVERTEXMODE]) {
 679             /* Processed vertices have their fog factor stored in the specular value. Fall too the none case.
 680              * If we are drawing untransformed vertices atm, d3ddevice_set_ortho will update the fog
 681              */
 682             case D3DFOG_EXP:  {
 683                 if(!context->last_was_rhw) {
 684                     glFogi(GL_FOG_MODE, GL_EXP);
 685                     checkGLcall("glFogi(GL_FOG_MODE, GL_EXP");
 686                     if(GL_SUPPORT(EXT_FOG_COORD)) {
 687                         glFogi(GL_FOG_COORDINATE_SOURCE_EXT, GL_FRAGMENT_DEPTH_EXT);
 688                         checkGLcall("glFogi(GL_FOG_COORDINATE_SOURCE_EXT, GL_FRAGMENT_DEPTH_EXT");
 689                     }
 690                     break;
 691                 }
 692             }
 693             case D3DFOG_EXP2: {
 694                 if(!context->last_was_rhw) {
 695                     glFogi(GL_FOG_MODE, GL_EXP2);
 696                     checkGLcall("glFogi(GL_FOG_MODE, GL_EXP2");
 697                     if(GL_SUPPORT(EXT_FOG_COORD)) {
 698                         glFogi(GL_FOG_COORDINATE_SOURCE_EXT, GL_FRAGMENT_DEPTH_EXT);
 699                         checkGLcall("glFogi(GL_FOG_COORDINATE_SOURCE_EXT, GL_FRAGMENT_DEPTH_EXT");
 700                     }
 701                     break;
 702                 }
 703             }
 704             case D3DFOG_LINEAR: {
 705                 if(!context->last_was_rhw) {
 706                     glFogi(GL_FOG_MODE, GL_LINEAR);
 707                     checkGLcall("glFogi(GL_FOG_MODE, GL_LINEAR");
 708                     if(GL_SUPPORT(EXT_FOG_COORD)) {
 709                         glFogi(GL_FOG_COORDINATE_SOURCE_EXT, GL_FRAGMENT_DEPTH_EXT);
 710                         checkGLcall("glFogi(GL_FOG_COORDINATE_SOURCE_EXT, GL_FRAGMENT_DEPTH_EXT");
 711                     }
 712                     break;
 713                 }
 714             }
 715             case D3DFOG_NONE: {
 716                 /* Both are none? According to msdn the alpha channel of the specular
 717                  * color contains a fog factor. Set it in drawStridedSlow.
 718                  * Same happens with Vertexfog on transformed vertices
 719                  */
 720                 if(GL_SUPPORT(EXT_FOG_COORD)) {
 721                     glFogi(GL_FOG_COORDINATE_SOURCE_EXT, GL_FOG_COORDINATE_EXT);
 722                     checkGLcall("glFogi(GL_FOG_COORDINATE_SOURCE_EXT, GL_FOG_COORDINATE_EXT)\n");
 723                     glFogi(GL_FOG_MODE, GL_LINEAR);
 724                     checkGLcall("glFogi(GL_FOG_MODE, GL_LINEAR)");
 725                     fogstart = 0xff;
 726                     fogend = 0x0;
 727                 } else {
 728                     /* Disable GL fog, handle this in software in drawStridedSlow */
 729                     fogenable = FALSE;
 730                 }
 731                 break;
 732             }
 733             default: FIXME("Unexpected WINED3DRS_FOGVERTEXMODE %d\n", stateblock->renderState[WINED3DRS_FOGVERTEXMODE]);
 734         }
 735     } else {
 736         glHint(GL_FOG_HINT, GL_NICEST);
 737         checkGLcall("glHint(GL_FOG_HINT, GL_NICEST)");
 738         context->last_was_foggy_shader = FALSE;
 739
 740         switch (stateblock->renderState[WINED3DRS_FOGTABLEMODE]) {
 741             case D3DFOG_EXP:
 742                 glFogi(GL_FOG_MODE, GL_EXP);
 743                 checkGLcall("glFogi(GL_FOG_MODE, GL_EXP");
 744                 if(GL_SUPPORT(EXT_FOG_COORD)) {
 745                     glFogi(GL_FOG_COORDINATE_SOURCE_EXT, GL_FRAGMENT_DEPTH_EXT);
 746                     checkGLcall("glFogi(GL_FOG_COORDINATE_SOURCE_EXT, GL_FRAGMENT_DEPTH_EXT");
 747                 }
 748                 break;
 749
 750             case D3DFOG_EXP2:
 751                 glFogi(GL_FOG_MODE, GL_EXP2);
 752                 checkGLcall("glFogi(GL_FOG_MODE, GL_EXP2");
 753                 if(GL_SUPPORT(EXT_FOG_COORD)) {
 754                     glFogi(GL_FOG_COORDINATE_SOURCE_EXT, GL_FRAGMENT_DEPTH_EXT);
 755                     checkGLcall("glFogi(GL_FOG_COORDINATE_SOURCE_EXT, GL_FRAGMENT_DEPTH_EXT");
 756                 }
 757                 break;
 758
 759             case D3DFOG_LINEAR:
 760                 glFogi(GL_FOG_MODE, GL_LINEAR);
 761                 checkGLcall("glFogi(GL_FOG_MODE, GL_LINEAR");
 762                 if(GL_SUPPORT(EXT_FOG_COORD)) {
 763                     glFogi(GL_FOG_COORDINATE_SOURCE_EXT, GL_FRAGMENT_DEPTH_EXT);
 764                     checkGLcall("glFogi(GL_FOG_COORDINATE_SOURCE_EXT, GL_FRAGMENT_DEPTH_EXT");
 765                 }
 766                 break;
 767
 768             case D3DFOG_NONE:   /* Won't happen */
 769             default:
 770                 FIXME("Unexpected WINED3DRS_FOGTABLEMODE %d\n", stateblock->renderState[WINED3DRS_FOGTABLEMODE]);
 771         }
 772     }
 773
 774     if(fogenable) {
 775         glEnable(GL_FOG);
 776         checkGLcall("glEnable GL_FOG");
 777
 778         glFogfv(GL_FOG_START, &fogstart);
 779         checkGLcall("glFogf(GL_FOG_START, fogstart");
 780         TRACE("Fog Start == %f\n", fogstart);
 781
 782         glFogfv(GL_FOG_END, &fogend);
 783         checkGLcall("glFogf(GL_FOG_END, fogend");
 784         TRACE("Fog End == %f\n", fogend);
 785     } else {
 786         glDisable(GL_FOG);
 787         checkGLcall("glDisable GL_FOG");
 788     }
 789
 790     if (GL_SUPPORT(NV_FOG_DISTANCE)) {
 791         glFogi(GL_FOG_DISTANCE_MODE_NV, GL_EYE_PLANE_ABSOLUTE_NV);
 792     }
 793 }
 794
 795 static void state_fogcolor(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
 796     float col[4];
 797     D3DCOLORTOGLFLOAT4(stateblock->renderState[WINED3DRS_FOGCOLOR], col);
 798     /* Set the default alpha blend color */
 799     glFogfv(GL_FOG_COLOR, &col[0]);
 800     checkGLcall("glFog GL_FOG_COLOR");
 801 }
 802
 803 static void state_fogdensity(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
 804     union {
 805         DWORD d;
 806         float f;
 807     } tmpvalue;
 808     tmpvalue.d = stateblock->renderState[WINED3DRS_FOGDENSITY];
 809     glFogfv(GL_FOG_DENSITY, &tmpvalue.f);
 810     checkGLcall("glFogf(GL_FOG_DENSITY, (float) Value)");
 811 }
 812
 813 /* TODO: Merge with primitive type + init_materials()!! */
 814 static void state_colormat(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
 815     IWineD3DDeviceImpl *device = (IWineD3DDeviceImpl *)stateblock->wineD3DDevice;
 816     GLenum Parm = 0;
 817     WineDirect3DStridedData *diffuse = &device->strided_streams.u.s.diffuse;
 818     BOOL isDiffuseSupplied;
 819
 820     /* Depends on the decoded vertex declaration to read the existance of diffuse data.
 821      * The vertex declaration will call this function if the fixed function pipeline is used.
 822      */
 823
 824     if(isStateDirty(context, STATE_VDECL)) {
 825         return;
 826     }
 827
 828     isDiffuseSupplied = diffuse->lpData || diffuse->VBO;
 829
 830     if (isDiffuseSupplied && stateblock->renderState[WINED3DRS_COLORVERTEX]) {
 831         TRACE("diff %d, amb %d, emis %d, spec %d\n",
 832               stateblock->renderState[WINED3DRS_DIFFUSEMATERIALSOURCE],
 833               stateblock->renderState[WINED3DRS_AMBIENTMATERIALSOURCE],
 834               stateblock->renderState[WINED3DRS_EMISSIVEMATERIALSOURCE],
 835               stateblock->renderState[WINED3DRS_SPECULARMATERIALSOURCE]);
 836
 837         if (stateblock->renderState[WINED3DRS_DIFFUSEMATERIALSOURCE] == D3DMCS_COLOR1) {
 838             if (stateblock->renderState[WINED3DRS_AMBIENTMATERIALSOURCE] == D3DMCS_COLOR1) {
 839                 Parm = GL_AMBIENT_AND_DIFFUSE;
 840             } else {
 841                 Parm = GL_DIFFUSE;
 842             }
 843         } else if (stateblock->renderState[WINED3DRS_AMBIENTMATERIALSOURCE] == D3DMCS_COLOR1) {
 844             Parm = GL_AMBIENT;
 845         } else if (stateblock->renderState[WINED3DRS_EMISSIVEMATERIALSOURCE] == D3DMCS_COLOR1) {
 846             Parm = GL_EMISSION;
 847         } else if (stateblock->renderState[WINED3DRS_SPECULARMATERIALSOURCE] == D3DMCS_COLOR1) {
 848             Parm = GL_SPECULAR;
 849         }
 850     }
 851
 852     /* Nothing changed, return. */
 853     if (Parm == context->tracking_parm) return;
 854
 855     if(!Parm) {
 856         glDisable(GL_COLOR_MATERIAL);
 857         checkGLcall("glDisable GL_COLOR_MATERIAL");
 858     } else {
 859         glColorMaterial(GL_FRONT_AND_BACK, Parm);
 860         checkGLcall("glColorMaterial(GL_FRONT_AND_BACK, Parm)");
 861         glEnable(GL_COLOR_MATERIAL);
 862         checkGLcall("glEnable(GL_COLOR_MATERIAL)");
 863     }
 864
 865     /* Apparently calls to glMaterialfv are ignored for properties we're
 866      * tracking with glColorMaterial, so apply those here. */
 867     switch (context->tracking_parm) {
 868         case GL_AMBIENT_AND_DIFFUSE:
 869             glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT, (float*)&device->updateStateBlock->material.Ambient);
 870             glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, (float*)&device->updateStateBlock->material.Diffuse);
 871             checkGLcall("glMaterialfv");
 872             break;
 873
 874         case GL_DIFFUSE:
 875             glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, (float*)&device->updateStateBlock->material.Diffuse);
 876             checkGLcall("glMaterialfv");
 877             break;
 878
 879         case GL_AMBIENT:
 880             glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT, (float*)&device->updateStateBlock->material.Ambient);
 881             checkGLcall("glMaterialfv");
 882             break;
 883
 884         case GL_EMISSION:
 885             glMaterialfv(GL_FRONT_AND_BACK, GL_EMISSION, (float*)&device->updateStateBlock->material.Emissive);
 886             checkGLcall("glMaterialfv");
 887             break;
 888
 889         case GL_SPECULAR:
 890             /* Only change material color if specular is enabled, otherwise it is set to black */
 891             if (device->stateBlock->renderState[WINED3DRS_SPECULARENABLE]) {
 892                 glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, (float*)&device->updateStateBlock->material.Specular);
 893                 checkGLcall("glMaterialfv");
 894             } else {
 895                 float black[4] = {0.0f, 0.0f, 0.0f, 0.0f};
 896                 glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, &black[0]);
 897                 checkGLcall("glMaterialfv");
 898             }
 899             break;
 900     }
 901
 902     context->tracking_parm = Parm;
 903 }
 904
 905 static void state_linepattern(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
 906     union {
 907         DWORD                 d;
 908         WINED3DLINEPATTERN    lp;
 909     } tmppattern;
 910     tmppattern.d = stateblock->renderState[WINED3DRS_LINEPATTERN];
 911
 912     TRACE("Line pattern: repeat %d bits %x\n", tmppattern.lp.wRepeatFactor, tmppattern.lp.wLinePattern);
 913
 914     if (tmppattern.lp.wRepeatFactor) {
 915         glLineStipple(tmppattern.lp.wRepeatFactor, tmppattern.lp.wLinePattern);
 916         checkGLcall("glLineStipple(repeat, linepattern)");
 917         glEnable(GL_LINE_STIPPLE);
 918         checkGLcall("glEnable(GL_LINE_STIPPLE);");
 919     } else {
 920         glDisable(GL_LINE_STIPPLE);
 921         checkGLcall("glDisable(GL_LINE_STIPPLE);");
 922     }
 923 }
 924
 925 static void state_zbias(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
 926     union {
 927         DWORD d;
 928         float f;
 929     } tmpvalue;
 930
 931     if (stateblock->renderState[WINED3DRS_ZBIAS]) {
 932         tmpvalue.d = stateblock->renderState[WINED3DRS_ZBIAS];
 933         TRACE("ZBias value %f\n", tmpvalue.f);
 934         glPolygonOffset(0, -tmpvalue.f);
 935         checkGLcall("glPolygonOffset(0, -Value)");
 936         glEnable(GL_POLYGON_OFFSET_FILL);
 937         checkGLcall("glEnable(GL_POLYGON_OFFSET_FILL);");
 938         glEnable(GL_POLYGON_OFFSET_LINE);
 939         checkGLcall("glEnable(GL_POLYGON_OFFSET_LINE);");
 940         glEnable(GL_POLYGON_OFFSET_POINT);
 941         checkGLcall("glEnable(GL_POLYGON_OFFSET_POINT);");
 942     } else {
 943         glDisable(GL_POLYGON_OFFSET_FILL);
 944         checkGLcall("glDisable(GL_POLYGON_OFFSET_FILL);");
 945         glDisable(GL_POLYGON_OFFSET_LINE);
 946         checkGLcall("glDisable(GL_POLYGON_OFFSET_LINE);");
 947         glDisable(GL_POLYGON_OFFSET_POINT);
 948         checkGLcall("glDisable(GL_POLYGON_OFFSET_POINT);");
 949     }
 950 }
 951
 952
 953 static void state_normalize(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
 954     if (stateblock->renderState[WINED3DRS_NORMALIZENORMALS]) {
 955         glEnable(GL_NORMALIZE);
 956         checkGLcall("glEnable(GL_NORMALIZE);");
 957     } else {
 958         glDisable(GL_NORMALIZE);
 959         checkGLcall("glDisable(GL_NORMALIZE);");
 960     }
 961 }
 962
 963 static void state_psize(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
 964     union {
 965         DWORD d;
 966         float f;
 967     } tmpvalue;
 968
 969     /* FIXME: check that pointSize isn't outside glGetFloatv( GL_POINT_SIZE_MAX_ARB, &maxSize ); or -ve */
 970     tmpvalue.d = stateblock->renderState[WINED3DRS_POINTSIZE];
 971     TRACE("Set point size to %f\n", tmpvalue.f);
 972     glPointSize(tmpvalue.f);
 973     checkGLcall("glPointSize(...);");
 974 }
 975
 976 static void state_psizemin(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
 977     union {
 978         DWORD d;
 979         float f;
 980     } tmpvalue;
 981
 982     tmpvalue.d = stateblock->renderState[WINED3DRS_POINTSIZE_MIN];
 983     if(GL_SUPPORT(ARB_POINT_PARAMETERS)) {
 984         GL_EXTCALL(glPointParameterfARB)(GL_POINT_SIZE_MIN_ARB, tmpvalue.f);
 985         checkGLcall("glPointParameterfARB(...");
 986     }
 987     else if(GL_SUPPORT(EXT_POINT_PARAMETERS)) {
 988         GL_EXTCALL(glPointParameterfEXT)(GL_POINT_SIZE_MIN_EXT, tmpvalue.f);
 989         checkGLcall("glPointParameterfEXT(...);");
 990     } else if(tmpvalue.f != 1.0) {
 991         FIXME("WINED3DRS_POINTSIZE_MIN not supported on this opengl, value is %f\n", tmpvalue.f);
 992     }
 993 }
 994
 995 static void state_psizemax(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
 996     union {
 997         DWORD d;
 998         float f;
 999     } tmpvalue;
1000
1001     tmpvalue.d = stateblock->renderState[WINED3DRS_POINTSIZE_MAX];
1002     if(GL_SUPPORT(ARB_POINT_PARAMETERS)) {
1003         GL_EXTCALL(glPointParameterfARB)(GL_POINT_SIZE_MAX_ARB, tmpvalue.f);
1004         checkGLcall("glPointParameterfARB(...");
1005     }
1006     else if(GL_SUPPORT(EXT_POINT_PARAMETERS)) {
1007         GL_EXTCALL(glPointParameterfEXT)(GL_POINT_SIZE_MAX_EXT, tmpvalue.f);
1008         checkGLcall("glPointParameterfEXT(...);");
1009     } else if(tmpvalue.f != 64.0) {
1010         FIXME("WINED3DRS_POINTSIZE_MAX not supported on this opengl, value is %f\n", tmpvalue.f);
1011     }
1012 }
1013
1014 static void state_pscale(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
1015     /* TODO: Group this with the viewport */
1016     /*
1017      * POINTSCALEENABLE controls how point size value is treated. If set to
1018      * true, the point size is scaled with respect to height of viewport.
1019      * When set to false point size is in pixels.
1020      *
1021      * http://msdn.microsoft.com/library/en-us/directx9_c/point_sprites.asp
1022      */
1023
1024     /* Default values */
1025     GLfloat att[3] = {1.0f, 0.0f, 0.0f};
1026
1027     /*
1028      * Minimum valid point size for OpenGL is 1.0f. For Direct3D it is 0.0f.
1029      * This means that OpenGL will clamp really small point sizes to 1.0f.
1030      * To correct for this we need to multiply by the scale factor when sizes
1031      * are less than 1.0f. scale_factor =  1.0f / point_size.
1032      */
1033     GLfloat pointSize = *((float*)&stateblock->renderState[WINED3DRS_POINTSIZE]);
1034     if(pointSize > 0.0f) {
1035         GLfloat scaleFactor;
1036
1037         if(pointSize < 1.0f) {
1038             scaleFactor = pointSize * pointSize;
1039         } else {
1040             scaleFactor = 1.0f;
1041         }
1042
1043         if(stateblock->renderState[WINED3DRS_POINTSCALEENABLE]) {
1044             att[0] = *((float*)&stateblock->renderState[WINED3DRS_POINTSCALE_A]) /
1045                     (stateblock->viewport.Height * stateblock->viewport.Height * scaleFactor);
1046             att[1] = *((float*)&stateblock->renderState[WINED3DRS_POINTSCALE_B]) /
1047                     (stateblock->viewport.Height * stateblock->viewport.Height * scaleFactor);
1048             att[2] = *((float*)&stateblock->renderState[WINED3DRS_POINTSCALE_C]) /
1049                     (stateblock->viewport.Height * stateblock->viewport.Height * scaleFactor);
1050         }
1051     }
1052
1053     if(GL_SUPPORT(ARB_POINT_PARAMETERS)) {
1054         GL_EXTCALL(glPointParameterfvARB)(GL_POINT_DISTANCE_ATTENUATION_ARB, att);
1055         checkGLcall("glPointParameterfvARB(GL_DISTANCE_ATTENUATION_ARB, ...");
1056     }
1057     else if(GL_SUPPORT(EXT_POINT_PARAMETERS)) {
1058         GL_EXTCALL(glPointParameterfvEXT)(GL_DISTANCE_ATTENUATION_EXT, att);
1059         checkGLcall("glPointParameterfvEXT(GL_DISTANCE_ATTENUATION_EXT, ...");
1060     } else {
1061         TRACE("POINT_PARAMETERS not supported in this version of opengl\n");
1062     }
1063 }
1064
1065 static void state_colorwrite(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
1066     DWORD Value = stateblock->renderState[WINED3DRS_COLORWRITEENABLE];
1067
1068     TRACE("Color mask: r(%d) g(%d) b(%d) a(%d)\n",
1069         Value & D3DCOLORWRITEENABLE_RED   ? 1 : 0,
1070         Value & D3DCOLORWRITEENABLE_GREEN ? 1 : 0,
1071         Value & D3DCOLORWRITEENABLE_BLUE  ? 1 : 0,
1072         Value & D3DCOLORWRITEENABLE_ALPHA ? 1 : 0);
1073     glColorMask(Value & D3DCOLORWRITEENABLE_RED   ? GL_TRUE : GL_FALSE,
1074                 Value & D3DCOLORWRITEENABLE_GREEN ? GL_TRUE : GL_FALSE,
1075                 Value & D3DCOLORWRITEENABLE_BLUE  ? GL_TRUE : GL_FALSE,
1076                 Value & D3DCOLORWRITEENABLE_ALPHA ? GL_TRUE : GL_FALSE);
1077     checkGLcall("glColorMask(...)");
1078
1079     /* depends on WINED3DRS_COLORWRITEENABLE. */
1080     if(stateblock->renderState[WINED3DRS_COLORWRITEENABLE1] != 0x0000000F ||
1081        stateblock->renderState[WINED3DRS_COLORWRITEENABLE2] != 0x0000000F ||
1082        stateblock->renderState[WINED3DRS_COLORWRITEENABLE3] != 0x0000000F ) {
1083         ERR("(WINED3DRS_COLORWRITEENABLE1/2/3,%d,%d,%d) not yet implemented. Missing of cap D3DPMISCCAPS_INDEPENDENTWRITEMASKS wasn't honored?\n",
1084             stateblock->renderState[WINED3DRS_COLORWRITEENABLE1],
1085             stateblock->renderState[WINED3DRS_COLORWRITEENABLE2],
1086             stateblock->renderState[WINED3DRS_COLORWRITEENABLE3]);
1087     }
1088 }
1089
1090 static void state_localviewer(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
1091     if(stateblock->renderState[WINED3DRS_LOCALVIEWER]) {
1092         glLightModeli(GL_LIGHT_MODEL_LOCAL_VIEWER, 1);
1093         checkGLcall("glLightModeli(GL_LIGHT_MODEL_LOCAL_VIEWER, 1)");
1094     } else {
1095         glLightModeli(GL_LIGHT_MODEL_LOCAL_VIEWER, 0);
1096         checkGLcall("glLightModeli(GL_LIGHT_MODEL_LOCAL_VIEWER, 0)");
1097     }
1098 }
1099
1100 static void state_lastpixel(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
1101     if(stateblock->renderState[WINED3DRS_LASTPIXEL]) {
1102         TRACE("Last Pixel Drawing Enabled\n");
1103     } else {
1104         FIXME("Last Pixel Drawing Disabled, not handled yet\n");
1105     }
1106 }
1107
1108 static void state_pointsprite(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
1109     unsigned int i;
1110     int val;
1111
1112     /* TODO: NV_POINT_SPRITE */
1113     if (!GL_SUPPORT(ARB_POINT_SPRITE)) {
1114         TRACE("Point sprites not supported\n");
1115         return;
1116     }
1117
1118     if (stateblock->renderState[WINED3DRS_POINTSPRITEENABLE]) {
1119         val = GL_TRUE;
1120     } else {
1121         val = GL_FALSE;
1122     }
1123
1124     for (i = 0; i < GL_LIMITS(texture_stages); i++) {
1125         /* Note the WINED3DRS value applies to all textures, but GL has one
1126          * per texture, so apply it now ready to be used!
1127          */
1128         if (GL_SUPPORT(ARB_MULTITEXTURE)) {
1129             GL_EXTCALL(glActiveTextureARB(GL_TEXTURE0_ARB + i));
1130             checkGLcall("glActiveTextureARB");
1131         } else if (i==1) {
1132             FIXME("Program using multiple concurrent textures which this opengl implementation doesn't support\n");
1133             break;
1134         }
1135
1136         glTexEnvi(GL_POINT_SPRITE_ARB, GL_COORD_REPLACE_ARB, val);
1137         checkGLcall((val?"glTexEnvi(GL_POINT_SPRITE, GL_COORD_REPLACE, GL_TRUE)":
1138                          "glTexEnvi(GL_POINT_SPRITE, GL_COORD_REPLACE, GL_FALSE)"));
1139     }
1140 }
1141
1142 static void state_wrap(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
1143     /**
1144      http://www.cosc.brocku.ca/Offerings/3P98/course/lectures/texture/
1145      http://msdn.microsoft.com/archive/default.asp?url=/archive/en-us/directx9_c/directx/graphics/programmingguide/FixedFunction/Textures/texturewrapping.asp
1146      http://www.gamedev.net/reference/programming/features/rendererdll3/page2.asp
1147      Descussion that ways to turn on WRAPing to solve an opengl conversion problem.
1148      http://www.flipcode.org/cgi-bin/fcmsg.cgi?thread_show=10248
1149
1150      so far as I can tell, wrapping and texture-coordinate generate go hand in hand,
1151      */
1152     TRACE("Stub\n");
1153     if(stateblock->renderState[WINED3DRS_WRAP0] ||
1154        stateblock->renderState[WINED3DRS_WRAP1] ||
1155        stateblock->renderState[WINED3DRS_WRAP2] ||
1156        stateblock->renderState[WINED3DRS_WRAP3] ||
1157        stateblock->renderState[WINED3DRS_WRAP4] ||
1158        stateblock->renderState[WINED3DRS_WRAP5] ||
1159        stateblock->renderState[WINED3DRS_WRAP6] ||
1160        stateblock->renderState[WINED3DRS_WRAP7] ||
1161        stateblock->renderState[WINED3DRS_WRAP8] ||
1162        stateblock->renderState[WINED3DRS_WRAP9] ||
1163        stateblock->renderState[WINED3DRS_WRAP10] ||
1164        stateblock->renderState[WINED3DRS_WRAP11] ||
1165        stateblock->renderState[WINED3DRS_WRAP12] ||
1166        stateblock->renderState[WINED3DRS_WRAP13] ||
1167        stateblock->renderState[WINED3DRS_WRAP14] ||
1168        stateblock->renderState[WINED3DRS_WRAP15] ) {
1169         ERR("(WINED3DRS_WRAP0) Texture wraping not yet supported\n");
1170     }
1171 }
1172
1173 static void state_multisampleaa(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
1174     if( GL_SUPPORT(ARB_MULTISAMPLE) ) {
1175         if(stateblock->renderState[WINED3DRS_MULTISAMPLEANTIALIAS]) {
1176             glEnable(GL_MULTISAMPLE_ARB);
1177             checkGLcall("glEnable(GL_MULTISAMPLE_ARB)");
1178         } else {
1179             glDisable(GL_MULTISAMPLE_ARB);
1180             checkGLcall("glDisable(GL_MULTISAMPLE_ARB)");
1181         }
1182     } else {
1183         if(stateblock->renderState[WINED3DRS_MULTISAMPLEANTIALIAS]) {
1184             ERR("Multisample antialiasing not supported by gl\n");
1185         }
1186     }
1187 }
1188
1189 static void state_scissor(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
1190     if(stateblock->renderState[WINED3DRS_SCISSORTESTENABLE]) {
1191         glEnable(GL_SCISSOR_TEST);
1192         checkGLcall("glEnable(GL_SCISSOR_TEST)");
1193     } else {
1194         glDisable(GL_SCISSOR_TEST);
1195         checkGLcall("glDisable(GL_SCISSOR_TEST)");
1196     }
1197 }
1198
1199 static void state_depthbias(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
1200     union {
1201         DWORD d;
1202         float f;
1203     } tmpvalue;
1204
1205     if(stateblock->renderState[WINED3DRS_SLOPESCALEDEPTHBIAS] ||
1206        stateblock->renderState[WINED3DRS_DEPTHBIAS]) {
1207         tmpvalue.d = stateblock->renderState[WINED3DRS_SLOPESCALEDEPTHBIAS];
1208         glEnable(GL_POLYGON_OFFSET_FILL);
1209         checkGLcall("glEnable(GL_POLYGON_OFFSET_FILL)");
1210         glPolygonOffset(tmpvalue.f, *((float*)&stateblock->renderState[WINED3DRS_DEPTHBIAS]));
1211         checkGLcall("glPolygonOffset(...)");
1212     } else {
1213         glDisable(GL_POLYGON_OFFSET_FILL);
1214         checkGLcall("glDisable(GL_POLYGON_OFFSET_FILL)");
1215     }
1216 }
1217
1218 static void state_perspective(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
1219     if (stateblock->renderState[WINED3DRS_TEXTUREPERSPECTIVE]) {
1220         glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);
1221         checkGLcall("glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST)");
1222     } else {
1223         glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_FASTEST);
1224         checkGLcall("glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_FASTEST)");
1225     }
1226 }
1227
1228 static void state_stippledalpha(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
1229     TRACE("Stub\n");
1230     if (stateblock->renderState[WINED3DRS_STIPPLEDALPHA])
1231         ERR(" Stippled Alpha not supported yet.\n");
1232 }
1233
1234 static void state_antialias(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
1235     TRACE("Stub\n");
1236     if (stateblock->renderState[WINED3DRS_ANTIALIAS])
1237         ERR(" Antialias not supported yet.\n");
1238 }
1239
1240 static void state_multisampmask(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
1241     TRACE("Stub\n");
1242     if (stateblock->renderState[WINED3DRS_MULTISAMPLEMASK] != 0xFFFFFFFF)
1243         ERR("(WINED3DRS_MULTISAMPLEMASK,%d) not yet implemented\n", stateblock->renderState[WINED3DRS_MULTISAMPLEMASK]);
1244 }
1245
1246 static void state_patchedgestyle(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
1247     TRACE("Stub\n");
1248     if (stateblock->renderState[WINED3DRS_PATCHEDGESTYLE] != D3DPATCHEDGE_DISCRETE)
1249         ERR("(WINED3DRS_PATCHEDGESTYLE,%d) not yet implemented\n", stateblock->renderState[WINED3DRS_PATCHEDGESTYLE]);
1250 }
1251
1252 static void state_patchsegments(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
1253     union {
1254         DWORD d;
1255         float f;
1256     } tmpvalue;
1257     tmpvalue.f = 1.0f;
1258
1259     TRACE("Stub\n");
1260     if (stateblock->renderState[WINED3DRS_PATCHSEGMENTS] != tmpvalue.d)
1261         ERR("(WINED3DRS_PATCHSEGMENTS,%d) not yet implemented\n", tmpvalue.d);
1262 }
1263
1264 static void state_positiondegree(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
1265     TRACE("Stub\n");
1266     if (stateblock->renderState[WINED3DRS_POSITIONDEGREE] != D3DDEGREE_CUBIC)
1267         ERR("(WINED3DRS_POSITIONDEGREE,%d) not yet implemented\n", stateblock->renderState[WINED3DRS_POSITIONDEGREE]);
1268 }
1269
1270 static void state_normaldegree(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
1271     TRACE("Stub\n");
1272     if (stateblock->renderState[WINED3DRS_NORMALDEGREE] != D3DDEGREE_LINEAR)
1273         ERR("(WINED3DRS_NORMALDEGREE,%d) not yet implemented\n", stateblock->renderState[WINED3DRS_NORMALDEGREE]);
1274 }
1275
1276 static void state_tessellation(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
1277     TRACE("Stub\n");
1278     if(stateblock->renderState[WINED3DRS_ENABLEADAPTIVETESSELLATION])
1279         FIXME("(WINED3DRS_ENABLEADAPTIVETESSELLATION,%d) not yet implemented\n", stateblock->renderState[WINED3DRS_ENABLEADAPTIVETESSELLATION]);
1280 }
1281
1282
1283 static void state_srgbwrite(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
1284     if(stateblock->renderState[WINED3DRS_SRGBWRITEENABLE])
1285         ERR("Render state WINED3DRS_SRGBWRITEENABLE not yet implemented\n");
1286 }
1287
1288 static void state_seperateblend(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
1289     TRACE("Stub\n");
1290     if(stateblock->renderState[WINED3DRS_SEPARATEALPHABLENDENABLE])
1291         FIXME("(WINED3DRS_SEPARATEALPHABLENDENABLE,%d) not yet implemented\n", stateblock->renderState[WINED3DRS_SEPARATEALPHABLENDENABLE]);
1292 }
1293
1294 static void state_wrapu(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
1295     if(stateblock->renderState[WINED3DRS_WRAPU]) {
1296         FIXME("Render state WINED3DRS_WRAPU not implemented yet\n");
1297     }
1298 }
1299
1300 static void state_wrapv(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
1301     if(stateblock->renderState[WINED3DRS_WRAPV]) {
1302         FIXME("Render state WINED3DRS_WRAPV not implemented yet\n");
1303     }
1304 }
1305
1306 static void state_monoenable(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
1307     if(stateblock->renderState[WINED3DRS_MONOENABLE]) {
1308         FIXME("Render state WINED3DRS_MONOENABLE not implemented yet\n");
1309     }
1310 }
1311
1312 static void state_rop2(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
1313     if(stateblock->renderState[WINED3DRS_ROP2]) {
1314         FIXME("Render state WINED3DRS_ROP2 not implemented yet\n");
1315     }
1316 }
1317
1318 static void state_planemask(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
1319     if(stateblock->renderState[WINED3DRS_PLANEMASK]) {
1320         FIXME("Render state WINED3DRS_PLANEMASK not implemented yet\n");
1321     }
1322 }
1323
1324 static void state_subpixel(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
1325     if(stateblock->renderState[WINED3DRS_SUBPIXEL]) {
1326         FIXME("Render state WINED3DRS_SUBPIXEL not implemented yet\n");
1327     }
1328 }
1329
1330 static void state_subpixelx(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
1331     if(stateblock->renderState[WINED3DRS_SUBPIXELX]) {
1332         FIXME("Render state WINED3DRS_SUBPIXELX not implemented yet\n");
1333     }
1334 }
1335
1336 static void state_stippleenable(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
1337     if(stateblock->renderState[WINED3DRS_STIPPLEENABLE]) {
1338         FIXME("Render state WINED3DRS_STIPPLEENABLE not implemented yet\n");
1339     }
1340 }
1341
1342 static void state_bordercolor(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
1343     if(stateblock->renderState[WINED3DRS_BORDERCOLOR]) {
1344         FIXME("Render state WINED3DRS_BORDERCOLOR not implemented yet\n");
1345     }
1346 }
1347
1348 static void state_mipmaplodbias(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
1349     if(stateblock->renderState[WINED3DRS_MIPMAPLODBIAS]) {
1350         FIXME("Render state WINED3DRS_MIPMAPLODBIAS not implemented yet\n");
1351     }
1352 }
1353
1354 static void state_anisotropy(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
1355     if(stateblock->renderState[WINED3DRS_ANISOTROPY]) {
1356         FIXME("Render state WINED3DRS_ANISOTROPY not implemented yet\n");
1357     }
1358 }
1359
1360 static void state_flushbatch(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
1361     if(stateblock->renderState[WINED3DRS_FLUSHBATCH]) {
1362         FIXME("Render state WINED3DRS_FLUSHBATCH not implemented yet\n");
1363     }
1364 }
1365
1366 static void state_translucentsi(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
1367     if(stateblock->renderState[WINED3DRS_TRANSLUCENTSORTINDEPENDENT]) {
1368         FIXME("Render state WINED3DRS_TRANSLUCENTSORTINDEPENDENT not implemented yet\n");
1369     }
1370 }
1371
1372 static void state_extents(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
1373     if(stateblock->renderState[WINED3DRS_EXTENTS]) {
1374         FIXME("Render state WINED3DRS_EXTENTS not implemented yet\n");
1375     }
1376 }
1377
1378 static void state_ckeyblend(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
1379     if(stateblock->renderState[WINED3DRS_COLORKEYBLENDENABLE]) {
1380         FIXME("Render state WINED3DRS_COLORKEYBLENDENABLE not implemented yet\n");
1381     }
1382 }
1383
1384 /* Activates the texture dimension according to the bound D3D texture.
1385  * Does not care for the colorop or correct gl texture unit(when using nvrc)
1386  * Requires the caller to activate the correct unit before
1387  */
1388 static void activate_dimensions(DWORD stage, IWineD3DStateBlockImpl *stateblock) {
1389     if(stateblock->textures[stage]) {
1390         glDisable(GL_TEXTURE_1D);
1391         checkGLcall("glDisable(GL_TEXTURE_1D)");
1392         switch(stateblock->textureDimensions[stage]) {
1393             case GL_TEXTURE_2D:
1394                 glDisable(GL_TEXTURE_3D);
1395                 checkGLcall("glDisable(GL_TEXTURE_3D)");
1396                 glDisable(GL_TEXTURE_CUBE_MAP_ARB);
1397                 checkGLcall("glDisable(GL_TEXTURE_CUBE_MAP_ARB)");
1398                 glEnable(GL_TEXTURE_2D);
1399                 checkGLcall("glEnable(GL_TEXTURE_2D)");
1400                 break;
1401             case GL_TEXTURE_3D:
1402                 glDisable(GL_TEXTURE_CUBE_MAP_ARB);
1403                 checkGLcall("glDisable(GL_TEXTURE_CUBE_MAP_ARB)");
1404                 glDisable(GL_TEXTURE_2D);
1405                 checkGLcall("glDisable(GL_TEXTURE_2D)");
1406                 glEnable(GL_TEXTURE_3D);
1407                 checkGLcall("glEnable(GL_TEXTURE_3D)");
1408                 break;
1409             case GL_TEXTURE_CUBE_MAP_ARB:
1410                 glDisable(GL_TEXTURE_2D);
1411                 checkGLcall("glDisable(GL_TEXTURE_2D)");
1412                 glDisable(GL_TEXTURE_3D);
1413                 checkGLcall("glDisable(GL_TEXTURE_3D)");
1414                 glEnable(GL_TEXTURE_CUBE_MAP_ARB);
1415                 checkGLcall("glEnable(GL_TEXTURE_CUBE_MAP_ARB)");
1416                 break;
1417         }
1418     } else {
1419         glDisable(GL_TEXTURE_2D);
1420         checkGLcall("glDisable(GL_TEXTURE_2D)");
1421         glDisable(GL_TEXTURE_3D);
1422         checkGLcall("glDisable(GL_TEXTURE_3D)");
1423         glDisable(GL_TEXTURE_CUBE_MAP_ARB);
1424         checkGLcall("glDisable(GL_TEXTURE_CUBE_MAP_ARB)");
1425         glEnable(GL_TEXTURE_1D);
1426         checkGLcall("glEnable(GL_TEXTURE_1D)");
1427         /* Binding textures is done by samplers. A dummy texture will be bound */
1428     }
1429 }
1430
1431 static void tex_colorop(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
1432     DWORD stage = (state - STATE_TEXTURESTAGE(0, 0)) / WINED3D_HIGHEST_TEXTURE_STATE;
1433     DWORD mapped_stage = stateblock->wineD3DDevice->texUnitMap[stage];
1434
1435     TRACE("Setting color op for stage %d\n", stage);
1436
1437     if (stateblock->pixelShader && stateblock->wineD3DDevice->ps_selected_mode != SHADER_NONE &&
1438         ((IWineD3DPixelShaderImpl *)stateblock->pixelShader)->baseShader.function) {
1439         /* Using a pixel shader? Don't care for anything here, the shader applying does it */
1440         return;
1441     }
1442
1443     if (stage != mapped_stage) WARN("Using non 1:1 mapping: %d -> %d!\n", stage, mapped_stage);
1444
1445     if (mapped_stage != -1) {
1446         if (GL_SUPPORT(ARB_MULTITEXTURE)) {
1447             if (mapped_stage >= GL_LIMITS(sampler_stages)) {
1448                 if (stateblock->textureState[stage][WINED3DTSS_COLOROP] != WINED3DTOP_DISABLE &&
1449                         stateblock->textureState[stage][WINED3DTSS_COLOROP] != 0) {
1450                     FIXME("Attempt to enable unsupported stage!\n");
1451                 }
1452                 return;
1453             }
1454             GL_EXTCALL(glActiveTextureARB(GL_TEXTURE0_ARB + mapped_stage));
1455             checkGLcall("glActiveTextureARB");
1456         } else if (stage > 0) {
1457             WARN("Program using multiple concurrent textures which this opengl implementation doesn't support\n");
1458             return;
1459         }
1460     }
1461
1462     if (GL_SUPPORT(NV_REGISTER_COMBINERS)) {
1463         if(stateblock->lowest_disabled_stage > 0) {
1464             glEnable(GL_REGISTER_COMBINERS_NV);
1465             GL_EXTCALL(glCombinerParameteriNV(GL_NUM_GENERAL_COMBINERS_NV, stateblock->lowest_disabled_stage));
1466         } else {
1467             glDisable(GL_REGISTER_COMBINERS_NV);
1468         }
1469     }
1470     if(stage >= stateblock->lowest_disabled_stage) {
1471         TRACE("Stage disabled\n");
1472         if (mapped_stage != -1) {
1473             /* Disable everything here */
1474             glDisable(GL_TEXTURE_1D);
1475             checkGLcall("glDisable(GL_TEXTURE_1D)");
1476             glDisable(GL_TEXTURE_2D);
1477             checkGLcall("glDisable(GL_TEXTURE_2D)");
1478             glDisable(GL_TEXTURE_3D);
1479             checkGLcall("glDisable(GL_TEXTURE_3D)");
1480             glDisable(GL_TEXTURE_CUBE_MAP_ARB);
1481             checkGLcall("glDisable(GL_TEXTURE_CUBE_MAP_ARB)");
1482         }
1483         /* All done */
1484         return;
1485     }
1486
1487     /* The sampler will also activate the correct texture dimensions, so no need to do it here
1488      * if the sampler for this stage is dirty
1489      */
1490     if(!isStateDirty(context, STATE_SAMPLER(stage))) {
1491         if (mapped_stage != -1) activate_dimensions(stage, stateblock);
1492     }
1493
1494     /* Set the texture combiners */
1495     if (GL_SUPPORT(NV_REGISTER_COMBINERS)) {
1496         set_tex_op_nvrc((IWineD3DDevice *)stateblock->wineD3DDevice, FALSE, stage,
1497                          stateblock->textureState[stage][WINED3DTSS_COLOROP],
1498                          stateblock->textureState[stage][WINED3DTSS_COLORARG1],
1499                          stateblock->textureState[stage][WINED3DTSS_COLORARG2],
1500                          stateblock->textureState[stage][WINED3DTSS_COLORARG0],
1501                          mapped_stage);
1502     } else {
1503         set_tex_op((IWineD3DDevice *)stateblock->wineD3DDevice, FALSE, stage,
1504                     stateblock->textureState[stage][WINED3DTSS_COLOROP],
1505                     stateblock->textureState[stage][WINED3DTSS_COLORARG1],
1506                     stateblock->textureState[stage][WINED3DTSS_COLORARG2],
1507                     stateblock->textureState[stage][WINED3DTSS_COLORARG0]);
1508     }
1509 }
1510
1511 static void tex_alphaop(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
1512     DWORD stage = (state - STATE_TEXTURESTAGE(0, 0)) / WINED3D_HIGHEST_TEXTURE_STATE;
1513     DWORD mapped_stage = stateblock->wineD3DDevice->texUnitMap[stage];
1514
1515     TRACE("Setting alpha op for stage %d\n", stage);
1516     /* Do not care for enabled / disabled stages, just assign the settigns. colorop disables / enables required stuff */
1517     if (mapped_stage != -1) {
1518         if (GL_SUPPORT(ARB_MULTITEXTURE)) {
1519             if (stage >= GL_LIMITS(sampler_stages)) {
1520                 if (stateblock->textureState[stage][WINED3DTSS_COLOROP] != WINED3DTOP_DISABLE &&
1521                         stateblock->textureState[stage][WINED3DTSS_COLOROP] != 0) {
1522                     FIXME("Attempt to enable unsupported stage!\n");
1523                 }
1524                 return;
1525             }
1526             GL_EXTCALL(glActiveTextureARB(GL_TEXTURE0_ARB + mapped_stage));
1527             checkGLcall("glActiveTextureARB");
1528         } else if (stage > 0) {
1529             /* We can't do anything here */
1530             WARN("Program using multiple concurrent textures which this opengl implementation doesn't support\n");
1531             return;
1532         }
1533     }
1534
1535     TRACE("Setting alpha op for stage %d\n", stage);
1536     if (GL_SUPPORT(NV_REGISTER_COMBINERS)) {
1537         set_tex_op_nvrc((IWineD3DDevice *)stateblock->wineD3DDevice, TRUE, stage,
1538                          stateblock->textureState[stage][WINED3DTSS_ALPHAOP],
1539                          stateblock->textureState[stage][WINED3DTSS_ALPHAARG1],
1540                          stateblock->textureState[stage][WINED3DTSS_ALPHAARG2],
1541                          stateblock->textureState[stage][WINED3DTSS_ALPHAARG0],
1542                          mapped_stage);
1543     } else {
1544         set_tex_op((IWineD3DDevice *)stateblock->wineD3DDevice, TRUE, stage, stateblock->textureState[stage][WINED3DTSS_ALPHAOP],
1545                     stateblock->textureState[stage][WINED3DTSS_ALPHAARG1],
1546                     stateblock->textureState[stage][WINED3DTSS_ALPHAARG2],
1547                     stateblock->textureState[stage][WINED3DTSS_ALPHAARG0]);
1548     }
1549 }
1550
1551 static void transform_texture(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
1552     DWORD texUnit = state - STATE_TRANSFORM(WINED3DTS_TEXTURE0);
1553
1554     if (GL_SUPPORT(ARB_MULTITEXTURE)) {
1555         if(texUnit >= GL_LIMITS(sampler_stages)) {
1556             return;
1557         }
1558         GL_EXTCALL(glActiveTextureARB(GL_TEXTURE0_ARB + stateblock->wineD3DDevice->texUnitMap[texUnit]));
1559         checkGLcall("glActiveTextureARB");
1560     } else if (texUnit > 0) {
1561         /* We can't do anything here */
1562         WARN("Program using multiple concurrent textures which this opengl implementation doesn't support\n");
1563         return;
1564     }
1565
1566     set_texture_matrix((float *)&stateblock->transforms[WINED3DTS_TEXTURE0 + texUnit].u.m[0][0],
1567                         stateblock->textureState[texUnit][WINED3DTSS_TEXTURETRANSFORMFLAGS],
1568                         (stateblock->textureState[texUnit][WINED3DTSS_TEXCOORDINDEX] & 0xFFFF0000) != WINED3DTSS_TCI_PASSTHRU);
1569
1570 }
1571
1572 static void loadVertexData(IWineD3DStateBlockImpl *stateblock, WineDirect3DVertexStridedData *sd);
1573
1574 static void tex_coordindex(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
1575     DWORD stage = (state - STATE_TEXTURESTAGE(0, 0)) / WINED3D_HIGHEST_TEXTURE_STATE;
1576     DWORD mapped_stage = stateblock->wineD3DDevice->texUnitMap[stage];
1577
1578     if (mapped_stage == -1) {
1579         TRACE("No texture unit mapped to stage %d. Skipping texture coordinates.\n", stage);
1580         return;
1581     }
1582
1583     if (GL_SUPPORT(ARB_MULTITEXTURE)) {
1584         if(stage >= GL_LIMITS(sampler_stages)) {
1585             return;
1586         }
1587         GL_EXTCALL(glActiveTextureARB(GL_TEXTURE0_ARB + mapped_stage));
1588         checkGLcall("glActiveTextureARB");
1589     } else if (stage > 0) {
1590         /* We can't do anything here */
1591         WARN("Program using multiple concurrent textures which this opengl implementation doesn't support\n");
1592         return;
1593     }
1594
1595     /* Values 0-7 are indexes into the FVF tex coords - See comments in DrawPrimitive
1596      *
1597      * FIXME: From MSDN: The WINED3DTSS_TCI_* flags are mutually exclusive. If you include
1598      * one flag, you can still specify an index value, which the system uses to
1599      * determine the texture wrapping mode.
1600      * eg. SetTextureStageState( 0, WINED3DTSS_TEXCOORDINDEX, WINED3DTSS_TCI_CAMERASPACEPOSITION | 1 );
1601      * means use the vertex position (camera-space) as the input texture coordinates
1602      * for this texture stage, and the wrap mode set in the WINED3DRS_WRAP1 render
1603      * state. We do not (yet) support the WINED3DRENDERSTATE_WRAPx values, nor tie them up
1604      * to the TEXCOORDINDEX value
1605      */
1606
1607     /*
1608      * Be careful the value of the mask 0xF0000 come from d3d8types.h infos
1609      */
1610     switch (stateblock->textureState[stage][WINED3DTSS_TEXCOORDINDEX] & 0xFFFF0000) {
1611     case WINED3DTSS_TCI_PASSTHRU:
1612         /*Use the specified texture coordinates contained within the vertex format. This value resolves to zero.*/
1613         glDisable(GL_TEXTURE_GEN_S);
1614         glDisable(GL_TEXTURE_GEN_T);
1615         glDisable(GL_TEXTURE_GEN_R);
1616         glDisable(GL_TEXTURE_GEN_Q);
1617         checkGLcall("glDisable(GL_TEXTURE_GEN_S,T,R,Q)");
1618         break;
1619
1620     case WINED3DTSS_TCI_CAMERASPACEPOSITION:
1621         /* CameraSpacePosition means use the vertex position, transformed to camera space,
1622          * as the input texture coordinates for this stage's texture transformation. This
1623          * equates roughly to EYE_LINEAR
1624          */
1625         {
1626             float s_plane[] = { 1.0, 0.0, 0.0, 0.0 };
1627             float t_plane[] = { 0.0, 1.0, 0.0, 0.0 };
1628             float r_plane[] = { 0.0, 0.0, 1.0, 0.0 };
1629             float q_plane[] = { 0.0, 0.0, 0.0, 1.0 };
1630             TRACE("WINED3DTSS_TCI_CAMERASPACEPOSITION - Set eye plane\n");
1631
1632             glMatrixMode(GL_MODELVIEW);
1633             glPushMatrix();
1634             glLoadIdentity();
1635             glTexGenfv(GL_S, GL_EYE_PLANE, s_plane);
1636             glTexGenfv(GL_T, GL_EYE_PLANE, t_plane);
1637             glTexGenfv(GL_R, GL_EYE_PLANE, r_plane);
1638             glTexGenfv(GL_Q, GL_EYE_PLANE, q_plane);
1639             glPopMatrix();
1640
1641             TRACE("WINED3DTSS_TCI_CAMERASPACEPOSITION - Set GL_TEXTURE_GEN_x and GL_x, GL_TEXTURE_GEN_MODE, GL_EYE_LINEAR\n");
1642             glEnable(GL_TEXTURE_GEN_S);
1643             checkGLcall("glEnable(GL_TEXTURE_GEN_S);");
1644             glTexGeni(GL_S, GL_TEXTURE_GEN_MODE, GL_EYE_LINEAR);
1645             checkGLcall("glTexGeni(GL_S, GL_TEXTURE_GEN_MODE, GL_EYE_LINEAR)");
1646             glEnable(GL_TEXTURE_GEN_T);
1647             checkGLcall("glEnable(GL_TEXTURE_GEN_T);");
1648             glTexGeni(GL_T, GL_TEXTURE_GEN_MODE, GL_EYE_LINEAR);
1649             checkGLcall("glTexGeni(GL_T, GL_TEXTURE_GEN_MODE, GL_EYE_LINEAR)");
1650             glEnable(GL_TEXTURE_GEN_R);
1651             checkGLcall("glEnable(GL_TEXTURE_GEN_R);");
1652             glTexGeni(GL_R, GL_TEXTURE_GEN_MODE, GL_EYE_LINEAR);
1653             checkGLcall("glTexGeni(GL_R, GL_TEXTURE_GEN_MODE, GL_EYE_LINEAR)");
1654         }
1655         break;
1656
1657     case WINED3DTSS_TCI_CAMERASPACENORMAL:
1658         {
1659             if (GL_SUPPORT(NV_TEXGEN_REFLECTION)) {
1660                 float s_plane[] = { 1.0, 0.0, 0.0, 0.0 };
1661                 float t_plane[] = { 0.0, 1.0, 0.0, 0.0 };
1662                 float r_plane[] = { 0.0, 0.0, 1.0, 0.0 };
1663                 float q_plane[] = { 0.0, 0.0, 0.0, 1.0 };
1664                 TRACE("WINED3DTSS_TCI_CAMERASPACENORMAL - Set eye plane\n");
1665
1666                 glMatrixMode(GL_MODELVIEW);
1667                 glPushMatrix();
1668                 glLoadIdentity();
1669                 glTexGenfv(GL_S, GL_EYE_PLANE, s_plane);
1670                 glTexGenfv(GL_T, GL_EYE_PLANE, t_plane);
1671                 glTexGenfv(GL_R, GL_EYE_PLANE, r_plane);
1672                 glTexGenfv(GL_Q, GL_EYE_PLANE, q_plane);
1673                 glPopMatrix();
1674
1675                 glEnable(GL_TEXTURE_GEN_S);
1676                 checkGLcall("glEnable(GL_TEXTURE_GEN_S);");
1677                 glTexGeni(GL_S, GL_TEXTURE_GEN_MODE, GL_NORMAL_MAP_NV);
1678                 checkGLcall("glTexGeni(GL_S, GL_TEXTURE_GEN_MODE, GL_NORMAL_MAP_NV)");
1679                 glEnable(GL_TEXTURE_GEN_T);
1680                 checkGLcall("glEnable(GL_TEXTURE_GEN_T);");
1681                 glTexGeni(GL_T, GL_TEXTURE_GEN_MODE, GL_NORMAL_MAP_NV);
1682                 checkGLcall("glTexGeni(GL_T, GL_TEXTURE_GEN_MODE, GL_NORMAL_MAP_NV)");
1683                 glEnable(GL_TEXTURE_GEN_R);
1684                 checkGLcall("glEnable(GL_TEXTURE_GEN_R);");
1685                 glTexGeni(GL_R, GL_TEXTURE_GEN_MODE, GL_NORMAL_MAP_NV);
1686                 checkGLcall("glTexGeni(GL_R, GL_TEXTURE_GEN_MODE, GL_NORMAL_MAP_NV)");
1687             }
1688         }
1689         break;
1690
1691     case WINED3DTSS_TCI_CAMERASPACEREFLECTIONVECTOR:
1692         {
1693             if (GL_SUPPORT(NV_TEXGEN_REFLECTION)) {
1694             float s_plane[] = { 1.0, 0.0, 0.0, 0.0 };
1695             float t_plane[] = { 0.0, 1.0, 0.0, 0.0 };
1696             float r_plane[] = { 0.0, 0.0, 1.0, 0.0 };
1697             float q_plane[] = { 0.0, 0.0, 0.0, 1.0 };
1698             TRACE("WINED3DTSS_TCI_CAMERASPACEREFLECTIONVECTOR - Set eye plane\n");
1699
1700             glMatrixMode(GL_MODELVIEW);
1701             glPushMatrix();
1702             glLoadIdentity();
1703             glTexGenfv(GL_S, GL_EYE_PLANE, s_plane);
1704             glTexGenfv(GL_T, GL_EYE_PLANE, t_plane);
1705             glTexGenfv(GL_R, GL_EYE_PLANE, r_plane);
1706             glTexGenfv(GL_Q, GL_EYE_PLANE, q_plane);
1707             glPopMatrix();
1708
1709             glEnable(GL_TEXTURE_GEN_S);
1710             checkGLcall("glEnable(GL_TEXTURE_GEN_S);");
1711             glTexGeni(GL_S, GL_TEXTURE_GEN_MODE, GL_REFLECTION_MAP_NV);
1712             checkGLcall("glTexGeni(GL_S, GL_TEXTURE_GEN_MODE, GL_REFLECTION_MAP_NV)");
1713             glEnable(GL_TEXTURE_GEN_T);
1714             checkGLcall("glEnable(GL_TEXTURE_GEN_T);");
1715             glTexGeni(GL_T, GL_TEXTURE_GEN_MODE, GL_REFLECTION_MAP_NV);
1716             checkGLcall("glTexGeni(GL_T, GL_TEXTURE_GEN_MODE, GL_REFLECTION_MAP_NV)");
1717             glEnable(GL_TEXTURE_GEN_R);
1718             checkGLcall("glEnable(GL_TEXTURE_GEN_R);");
1719             glTexGeni(GL_R, GL_TEXTURE_GEN_MODE, GL_REFLECTION_MAP_NV);
1720             checkGLcall("glTexGeni(GL_R, GL_TEXTURE_GEN_MODE, GL_REFLECTION_MAP_NV)");
1721             }
1722         }
1723         break;
1724
1725     /* Unhandled types: */
1726     default:
1727         /* Todo: */
1728         /* ? disable GL_TEXTURE_GEN_n ? */
1729         glDisable(GL_TEXTURE_GEN_S);
1730         glDisable(GL_TEXTURE_GEN_T);
1731         glDisable(GL_TEXTURE_GEN_R);
1732         glDisable(GL_TEXTURE_GEN_Q);
1733         FIXME("Unhandled WINED3DTSS_TEXCOORDINDEX %x\n", stateblock->textureState[stage][WINED3DTSS_TEXCOORDINDEX]);
1734         break;
1735     }
1736
1737     /* Update the texture matrix */
1738     if(!isStateDirty(context, STATE_TRANSFORM(WINED3DTS_TEXTURE0 + stage))) {
1739         transform_texture(STATE_TRANSFORM(WINED3DTS_TEXTURE0 + stage), stateblock, context);
1740     }
1741
1742     if(!isStateDirty(context, STATE_VDECL) && context->namedArraysLoaded) {
1743         /* Reload the arrays if we are using fixed function arrays to reflect the selected coord input
1744          * source. Call loadVertexData directly because there is no need to reparse the vertex declaration
1745          * and do all the things linked to it
1746          * TODO: Tidy that up to reload only the arrays of the changed unit
1747          */
1748         loadVertexData(stateblock, &stateblock->wineD3DDevice->strided_streams);
1749     }
1750 }
1751
1752 static void tex_bumpenvlscale(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
1753     DWORD stage = (state - STATE_TEXTURESTAGE(0, 0)) / WINED3D_HIGHEST_TEXTURE_STATE;
1754     union {
1755         DWORD d;
1756         float f;
1757     } tmpvalue;
1758
1759     tmpvalue.d = stateblock->textureState[stage][WINED3DTSS_BUMPENVLSCALE];
1760     if(tmpvalue.f != 0.0) {
1761         ERR("WINED3DTSS_BUMPENVLSCALE not supported yet\n");
1762     }
1763 }
1764
1765 static void tex_bumpenvloffset(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
1766     DWORD stage = (state - STATE_TEXTURESTAGE(0, 0)) / WINED3D_HIGHEST_TEXTURE_STATE;
1767     union {
1768         DWORD d;
1769         float f;
1770     } tmpvalue;
1771
1772     tmpvalue.d = stateblock->textureState[stage][WINED3DTSS_BUMPENVLOFFSET];
1773     if(tmpvalue.f != 0.0) {
1774         ERR("WINED3DTSS_BUMPENVLOFFSET not supported yet\n");
1775     }
1776 }
1777
1778 static void tex_resultarg(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
1779     DWORD stage = (state - STATE_TEXTURESTAGE(0, 0)) / WINED3D_HIGHEST_TEXTURE_STATE;
1780
1781     if(stage >= GL_LIMITS(texture_stages)) {
1782         return;
1783     }
1784
1785     if(stateblock->textureState[stage][WINED3DTSS_RESULTARG] != D3DTA_CURRENT) {
1786         ERR("WINED3DTSS_RESULTARG not supported yet\n");
1787     }
1788 }
1789
1790 static void sampler(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
1791     DWORD sampler = state - STATE_SAMPLER(0);
1792     DWORD mapped_stage = stateblock->wineD3DDevice->texUnitMap[sampler];
1793     union {
1794         float f;
1795         DWORD d;
1796     } tmpvalue;
1797
1798     TRACE("Sampler: %d\n", sampler);
1799     /* Enabling and disabling texture dimensions is done by texture stage state / pixel shader setup, this function
1800      * only has to bind textures and set the per texture states
1801      */
1802
1803     if (mapped_stage == -1) {
1804         TRACE("No sampler mapped to stage %d. Returning.\n", sampler);
1805         return;
1806     }
1807
1808     if (GL_SUPPORT(ARB_MULTITEXTURE)) {
1809         if(sampler >= GL_LIMITS(sampler_stages)) {
1810             return;
1811         }
1812         GL_EXTCALL(glActiveTextureARB(GL_TEXTURE0_ARB + mapped_stage));
1813         checkGLcall("glActiveTextureARB");
1814     } else if (sampler > 0) {
1815         /* We can't do anything here */
1816         WARN("Program using multiple concurrent textures which this opengl implementation doesn't support\n");
1817         return;
1818     }
1819
1820     if(stateblock->textures[sampler]) {
1821         BOOL texIsPow2 = FALSE;
1822
1823         /* The fixed function np2 texture emulation uses the texture matrix to fix up the coordinates
1824          * IWineD3DBaseTexture::ApplyStateChanges multiplies the set matrix with a fixup matrix. Before the
1825          * scaling is reapplied or removed, the texture matrix has to be reapplied
1826          */
1827         if(!GL_SUPPORT(ARB_TEXTURE_NON_POWER_OF_TWO) && sampler < MAX_TEXTURES) {
1828             if(stateblock->textureDimensions[sampler] == GL_TEXTURE_2D) {
1829                 if(((IWineD3DTextureImpl *) stateblock->textures[sampler])->pow2scalingFactorX != 1.0 ||
1830                    ((IWineD3DTextureImpl *) stateblock->textures[sampler])->pow2scalingFactorY != 1.0 ) {
1831                     texIsPow2 = TRUE;
1832                 }
1833             } else if(stateblock->textureDimensions[sampler] == GL_TEXTURE_CUBE_MAP_ARB) {
1834                 if(((IWineD3DCubeTextureImpl *) stateblock->textures[sampler])->pow2scalingFactor != 1.0) {
1835                     texIsPow2 = TRUE;
1836                 }
1837             }
1838
1839             if(texIsPow2 || context->lastWasPow2Texture[sampler]) {
1840                 transform_texture(STATE_TRANSFORM(WINED3DTS_TEXTURE0 + stateblock->wineD3DDevice->texUnitMap[sampler]), stateblock, context);
1841                 context->lastWasPow2Texture[sampler] = texIsPow2;
1842             }
1843         }
1844
1845         IWineD3DBaseTexture_PreLoad((IWineD3DBaseTexture *) stateblock->textures[sampler]);
1846         IWineD3DBaseTexture_ApplyStateChanges(stateblock->textures[sampler], stateblock->textureState[sampler], stateblock->samplerState[sampler]);
1847
1848         if (GL_SUPPORT(EXT_TEXTURE_LOD_BIAS)) {
1849             tmpvalue.d = stateblock->samplerState[sampler][WINED3DSAMP_MIPMAPLODBIAS];
1850             glTexEnvf(GL_TEXTURE_FILTER_CONTROL_EXT,
1851                       GL_TEXTURE_LOD_BIAS_EXT,
1852                       tmpvalue.f);
1853             checkGLcall("glTexEnvi GL_TEXTURE_LOD_BIAS_EXT ...");
1854         }
1855
1856         if (stateblock->wineD3DDevice->ps_selected_mode != SHADER_NONE && stateblock->pixelShader &&
1857             ((IWineD3DPixelShaderImpl *)stateblock->pixelShader)->baseShader.function) {
1858             /* Using a pixel shader? Verify the sampler types */
1859
1860             /* Make sure that the texture dimensions are enabled. I don't have to disable the other
1861              * dimensions because the shader knows from which texture type to sample from. For the sake of
1862              * debugging all dimensions could be enabled and a texture with some ugly pink bound to the unused
1863              * dimensions. This should make wrong sampling sources visible :-)
1864              */
1865             glEnable(stateblock->textureDimensions[sampler]);
1866             checkGLcall("glEnable(stateblock->textureDimensions[sampler])");
1867         } else if(sampler < stateblock->lowest_disabled_stage) {
1868             if(!isStateDirty(context, STATE_TEXTURESTAGE(sampler, WINED3DTSS_COLOROP))) {
1869                 activate_dimensions(sampler, stateblock);
1870             }
1871
1872             if(stateblock->renderState[WINED3DRS_COLORKEYENABLE] && sampler == 0) {
1873                 /* If color keying is enabled update the alpha test, it depends on the existence
1874                  * of a color key in stage 0
1875                  */
1876                 state_alpha(WINED3DRS_COLORKEYENABLE, stateblock, context);
1877             }
1878         }
1879     } else if(sampler < GL_LIMITS(texture_stages)) {
1880         if(sampler < stateblock->lowest_disabled_stage) {
1881             /* TODO: What should I do with pixel shaders here ??? */
1882             if(!isStateDirty(context, STATE_TEXTURESTAGE(sampler, WINED3DTSS_COLOROP))) {
1883                 activate_dimensions(sampler, stateblock);
1884             }
1885         } /* Otherwise tex_colorop disables the stage */
1886         glBindTexture(GL_TEXTURE_1D, stateblock->wineD3DDevice->dummyTextureName[sampler]);
1887         checkGLcall("glBindTexture(GL_TEXTURE_1D, stateblock->wineD3DDevice->dummyTextureName[sampler])");
1888     }
1889 }
1890
1891 static void shaderconstant(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
1892     IWineD3DDeviceImpl *device = stateblock->wineD3DDevice;
1893
1894     /* Vertex and pixel shader states will call a shader upload, don't do anything as long one of them
1895      * has an update pending
1896      */
1897     if(isStateDirty(context, STATE_VDECL) ||
1898        isStateDirty(context, STATE_PIXELSHADER)) {
1899        return;
1900     }
1901
1902     device->shader_backend->shader_load_constants((IWineD3DDevice *) device,
1903         stateblock->pixelShader && ((IWineD3DPixelShaderImpl *)stateblock->pixelShader)->baseShader.function,
1904         stateblock->vertexShader && ((IWineD3DVertexShaderImpl *)stateblock->vertexShader)->baseShader.function);
1905 }
1906
1907 static void pixelshader(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
1908     BOOL use_ps = stateblock->pixelShader && ((IWineD3DPixelShaderImpl *)stateblock->pixelShader)->baseShader.function != NULL;
1909     BOOL use_vs = stateblock->vertexShader && ((IWineD3DVertexShaderImpl *)stateblock->vertexShader)->baseShader.function != NULL;
1910     int i;
1911
1912     if (use_ps) {
1913         if(!context->last_was_pshader) {
1914             /* Former draw without a pixel shader, some samplers
1915              * may be disabled because of WINED3DTSS_COLOROP = WINED3DTOP_DISABLE
1916              * make sure to enable them
1917              */
1918             for(i=0; i < MAX_SAMPLERS; i++) {
1919                 if(!isStateDirty(context, STATE_SAMPLER(i))) {
1920                     sampler(STATE_SAMPLER(i), stateblock, context);
1921                 }
1922             }
1923         } else {
1924            /* Otherwise all samplers were activated by the code above in earlier draws, or by sampler()
1925             * if a different texture was bound. I don't have to do anything.
1926             */
1927         }
1928
1929         /* Compile and bind the shader */
1930         IWineD3DPixelShader_CompileShader(stateblock->pixelShader);
1931     } else {
1932         /* Disabled the pixel shader - color ops weren't applied
1933          * while it was enabled, so re-apply them.
1934          */
1935         for(i=0; i < MAX_TEXTURES; i++) {
1936             if(!isStateDirty(context, STATE_TEXTURESTAGE(i, WINED3DTSS_COLOROP))) {
1937                 tex_colorop(STATE_TEXTURESTAGE(i, WINED3DTSS_COLOROP), stateblock, context);
1938             }
1939         }
1940     }
1941
1942     if(!isStateDirty(context, StateTable[STATE_VSHADER].representative)) {
1943         stateblock->wineD3DDevice->shader_backend->shader_select((IWineD3DDevice *)stateblock->wineD3DDevice, use_ps, use_vs);
1944
1945         if(!isStateDirty(context, STATE_VERTEXSHADERCONSTANT) && (use_vs || use_ps)) {
1946             shaderconstant(STATE_VERTEXSHADERCONSTANT, stateblock, context);
1947         }
1948     }
1949
1950     context->last_was_pshader = use_ps;
1951 }
1952
1953 static void transform_world(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
1954     /* This function is called by transform_view below if the view matrix was changed too
1955      *
1956      * Deliberately no check if the vertex declaration is dirty because the vdecl state
1957      * does not always update the world matrix, only on a switch between transformed
1958      * and untrannsformed draws. It *may* happen that the world matrix is set 2 times during one
1959      * draw, but that should be rather rare and cheaper in total.
1960      */
1961     glMatrixMode(GL_MODELVIEW);
1962     checkGLcall("glMatrixMode");
1963
1964     if(context->last_was_rhw) {
1965         glLoadIdentity();
1966         checkGLcall("glLoadIdentity()");
1967     } else {
1968         /* In the general case, the view matrix is the identity matrix */
1969         if (stateblock->wineD3DDevice->view_ident) {
1970             glLoadMatrixf((float *) &stateblock->transforms[WINED3DTS_WORLDMATRIX(0)].u.m[0][0]);
1971             checkGLcall("glLoadMatrixf");
1972         } else {
1973             glLoadMatrixf((float *) &stateblock->transforms[WINED3DTS_VIEW].u.m[0][0]);
1974             checkGLcall("glLoadMatrixf");
1975             glMultMatrixf((float *) &stateblock->transforms[WINED3DTS_WORLDMATRIX(0)].u.m[0][0]);
1976             checkGLcall("glMultMatrixf");
1977         }
1978     }
1979 }
1980
1981 static void transform_view(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
1982     unsigned int k;
1983
1984     /* If we are changing the View matrix, reset the light and clipping planes to the new view
1985      * NOTE: We have to reset the positions even if the light/plane is not currently
1986      *       enabled, since the call to enable it will not reset the position.
1987      * NOTE2: Apparently texture transforms do NOT need reapplying
1988      */
1989
1990     PLIGHTINFOEL *light = NULL;
1991
1992     glMatrixMode(GL_MODELVIEW);
1993     checkGLcall("glMatrixMode(GL_MODELVIEW)");
1994     glLoadMatrixf((float *)(float *) &stateblock->transforms[WINED3DTS_VIEW].u.m[0][0]);
1995     checkGLcall("glLoadMatrixf(...)");
1996
1997     /* Reset lights. TODO: Call light apply func */
1998     for(k = 0; k < stateblock->wineD3DDevice->maxConcurrentLights; k++) {
1999         light = stateblock->activeLights[k];
2000         if(!light) continue;
2001         glLightfv(GL_LIGHT0 + light->glIndex, GL_POSITION, light->lightPosn);
2002         checkGLcall("glLightfv posn");
2003         glLightfv(GL_LIGHT0 + light->glIndex, GL_SPOT_DIRECTION, light->lightDirn);
2004         checkGLcall("glLightfv dirn");
2005     }
2006
2007     /* Reset Clipping Planes if clipping is enabled. TODO: Call clipplane apply func */
2008     for (k = 0; k < GL_LIMITS(clipplanes); k++) {
2009         glClipPlane(GL_CLIP_PLANE0 + k, stateblock->clipplane[k]);
2010         checkGLcall("glClipPlane");
2011     }
2012
2013     if(context->last_was_rhw) {
2014         glLoadIdentity();
2015         checkGLcall("glLoadIdentity()");
2016         /* No need to update the world matrix, the identity is fine */
2017         return;
2018     }
2019
2020     /* Call the world matrix state, this will apply the combined WORLD + VIEW matrix
2021      * No need to do it here if the state is scheduled for update.
2022      */
2023     if(!isStateDirty(context, STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(0)))) {
2024         transform_world(STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(0)), stateblock, context);
2025     }
2026 }
2027
2028 static void transform_worldex(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
2029     WARN("World matrix 1 - 255 not supported yet\n");
2030 }
2031
2032 static const GLfloat invymat[16] = {
2033     1.0f, 0.0f, 0.0f, 0.0f,
2034     0.0f, -1.0f, 0.0f, 0.0f,
2035     0.0f, 0.0f, 1.0f, 0.0f,
2036     0.0f, 0.0f, 0.0f, 1.0f};
2037
2038 static void transform_projection(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
2039     glMatrixMode(GL_PROJECTION);
2040     checkGLcall("glMatrixMode(GL_PROJECTION)");
2041     glLoadIdentity();
2042     checkGLcall("glLoadIdentity");
2043
2044     if(context->last_was_rhw) {
2045         double X, Y, height, width, minZ, maxZ;
2046
2047         X      = stateblock->viewport.X;
2048         Y      = stateblock->viewport.Y;
2049         height = stateblock->viewport.Height;
2050         width  = stateblock->viewport.Width;
2051         minZ   = stateblock->viewport.MinZ;
2052         maxZ   = stateblock->viewport.MaxZ;
2053
2054         if(!stateblock->wineD3DDevice->untransformed) {
2055             /* Transformed vertices are supposed to bypass the whole transform pipeline including
2056              * frustum clipping. This can't be done in opengl, so this code adjusts the Z range to
2057              * suppress depth clipping. This can be done because it is an orthogonal projection and
2058              * the Z coordinate does not affect the size of the primitives
2059              */
2060             TRACE("Calling glOrtho with %f, %f, %f, %f\n", width, height, -minZ, -maxZ);
2061             glOrtho(X, X + width, Y + height, Y, -minZ, -maxZ);
2062         } else {
2063             /* If the app mixes transformed and untransformed primitives we can't use the coordinate system
2064              * trick above because this would mess up transformed and untransformed Z order. Pass the z position
2065              * unmodified to opengl.
2066              *
2067              * If the app depends on mixed types and disabled clipping we're out of luck without a pipeline
2068              * replacement shader.
2069              */
2070             TRACE("Calling glOrtho with %f, %f, %f, %f\n", width, height, 1.0, -1.0);
2071             glOrtho(X, X + width, Y + height, Y, 1.0, -1.0);
2072         }
2073         checkGLcall("glOrtho");
2074
2075         /* Window Coord 0 is the middle of the first pixel, so translate by 3/8 pixels */
2076         glTranslatef(0.375, 0.375, 0);
2077         checkGLcall("glTranslatef(0.375, 0.375, 0)");
2078         /* D3D texture coordinates are flipped compared to OpenGL ones, so
2079          * render everything upside down when rendering offscreen. */
2080         if (stateblock->wineD3DDevice->render_offscreen) {
2081             glMultMatrixf(invymat);
2082             checkGLcall("glMultMatrixf(invymat)");
2083         }
2084     } else {
2085         /* The rule is that the window coordinate 0 does not correspond to the
2086             beginning of the first pixel, but the center of the first pixel.
2087             As a consequence if you want to correctly draw one line exactly from
2088             the left to the right end of the viewport (with all matrices set to
2089             be identity), the x coords of both ends of the line would be not
2090             -1 and 1 respectively but (-1-1/viewport_widh) and (1-1/viewport_width)
2091             instead.                                                               */
2092         glTranslatef(0.9 / stateblock->viewport.Width, -0.9 / stateblock->viewport.Height, 0);
2093         checkGLcall("glTranslatef (0.9 / width, -0.9 / height, 0)");
2094
2095         /* D3D texture coordinates are flipped compared to OpenGL ones, so
2096             * render everything upside down when rendering offscreen. */
2097         if (stateblock->wineD3DDevice->render_offscreen) {
2098             glMultMatrixf(invymat);
2099             checkGLcall("glMultMatrixf(invymat)");
2100         }
2101         glMultMatrixf((float *) &stateblock->transforms[WINED3DTS_PROJECTION].u.m[0][0]);
2102         checkGLcall("glLoadMatrixf");
2103     }
2104 }
2105
2106 /* This should match any arrays loaded in loadVertexData.
2107  * stateblock impl is required for GL_SUPPORT
2108  * TODO: Only load / unload arrays if we have to.
2109  */
2110 static inline void unloadVertexData(IWineD3DStateBlockImpl *stateblock) {
2111     int texture_idx;
2112
2113     glDisableClientState(GL_VERTEX_ARRAY);
2114     glDisableClientState(GL_NORMAL_ARRAY);
2115     glDisableClientState(GL_COLOR_ARRAY);
2116     if (GL_SUPPORT(EXT_SECONDARY_COLOR)) {
2117         glDisableClientState(GL_SECONDARY_COLOR_ARRAY_EXT);
2118     }
2119     for (texture_idx = 0; texture_idx < GL_LIMITS(textures); ++texture_idx) {
2120         GL_EXTCALL(glClientActiveTextureARB(GL_TEXTURE0_ARB + texture_idx));
2121         glDisableClientState(GL_TEXTURE_COORD_ARRAY);
2122     }
2123 }
2124
2125 /* This should match any arrays loaded in loadNumberedArrays
2126  * TODO: Only load / unload arrays if we have to.
2127  */
2128 static inline void unloadNumberedArrays(IWineD3DStateBlockImpl *stateblock) {
2129     /* disable any attribs (this is the same for both GLSL and ARB modes) */
2130     GLint maxAttribs;
2131     int i;
2132
2133     /* Leave all the attribs disabled */
2134     glGetIntegerv(GL_MAX_VERTEX_ATTRIBS_ARB, &maxAttribs);
2135     /* MESA does not support it right not */
2136     if (glGetError() != GL_NO_ERROR)
2137         maxAttribs = 16;
2138     for (i = 0; i < maxAttribs; ++i) {
2139         GL_EXTCALL(glDisableVertexAttribArrayARB(i));
2140         checkGLcall("glDisableVertexAttribArrayARB(reg);");
2141     }
2142 }
2143
2144 static inline void loadNumberedArrays(IWineD3DStateBlockImpl *stateblock, WineDirect3DVertexStridedData *strided) {
2145     GLint curVBO = GL_SUPPORT(ARB_VERTEX_BUFFER_OBJECT) ? -1 : 0;
2146     int i;
2147     UINT *offset = stateblock->streamOffset;
2148
2149     for (i = 0; i < MAX_ATTRIBS; i++) {
2150
2151         if (!strided->u.input[i].lpData && !strided->u.input[i].VBO)
2152             continue;
2153
2154         TRACE_(d3d_shader)("Loading array %u [VBO=%u]\n", i, strided->u.input[i].VBO);
2155
2156         if(strided->u.input[i].dwStride) {
2157             if(curVBO != strided->u.input[i].VBO) {
2158                 GL_EXTCALL(glBindBufferARB(GL_ARRAY_BUFFER_ARB, strided->u.input[i].VBO));
2159                 checkGLcall("glBindBufferARB");
2160                 curVBO = strided->u.input[i].VBO;
2161             }
2162             GL_EXTCALL(glVertexAttribPointerARB(i,
2163                             WINED3D_ATR_SIZE(strided->u.input[i].dwType),
2164                             WINED3D_ATR_GLTYPE(strided->u.input[i].dwType),
2165                             WINED3D_ATR_NORMALIZED(strided->u.input[i].dwType),
2166                             strided->u.input[i].dwStride,
2167                             strided->u.input[i].lpData + stateblock->loadBaseVertexIndex * strided->u.input[i].dwStride + offset[strided->u.input[i].streamNo]) );
2168             GL_EXTCALL(glEnableVertexAttribArrayARB(i));
2169         } else {
2170             /* Stride = 0 means always the same values. glVertexAttribPointerARB doesn't do that. Instead disable the pointer and
2171              * set up the attribute statically. But we have to figure out the system memory address.
2172              */
2173             BYTE *ptr = strided->u.input[i].lpData + offset[strided->u.input[i].streamNo];
2174             if(strided->u.input[i].VBO) {
2175                 IWineD3DVertexBufferImpl *vb = (IWineD3DVertexBufferImpl *) stateblock->streamSource[strided->u.input[i].streamNo];
2176                 ptr += (long) vb->resource.allocatedMemory;
2177             }
2178             GL_EXTCALL(glDisableVertexAttribArrayARB(i));
2179
2180             switch(strided->u.input[i].dwType) {
2181                 case WINED3DDECLTYPE_FLOAT1:
2182                     GL_EXTCALL(glVertexAttrib1fvARB(i, (float *) ptr));
2183                     break;
2184                 case WINED3DDECLTYPE_FLOAT2:
2185                     GL_EXTCALL(glVertexAttrib2fvARB(i, (float *) ptr));
2186                     break;
2187                 case WINED3DDECLTYPE_FLOAT3:
2188                     GL_EXTCALL(glVertexAttrib3fvARB(i, (float *) ptr));
2189                     break;
2190                 case WINED3DDECLTYPE_FLOAT4:
2191                     GL_EXTCALL(glVertexAttrib4fvARB(i, (float *) ptr));
2192                     break;
2193
2194                 case WINED3DDECLTYPE_UBYTE4:
2195                     GL_EXTCALL(glVertexAttrib4NubvARB(i, ptr));
2196                     break;
2197                 case WINED3DDECLTYPE_UBYTE4N:
2198                 case WINED3DDECLTYPE_D3DCOLOR:
2199                     GL_EXTCALL(glVertexAttrib4NubvARB(i, ptr));
2200                     break;
2201
2202                 case WINED3DDECLTYPE_SHORT2:
2203                     GL_EXTCALL(glVertexAttrib4svARB(i, (GLshort *) ptr));
2204                     break;
2205                 case WINED3DDECLTYPE_SHORT4:
2206                     GL_EXTCALL(glVertexAttrib4svARB(i, (GLshort *) ptr));
2207                     break;
2208
2209                 case WINED3DDECLTYPE_SHORT2N:
2210                 {
2211                     GLshort s[4] = {((short *) ptr)[0], ((short *) ptr)[1], 0, 1};
2212                     GL_EXTCALL(glVertexAttrib4NsvARB(i, s));
2213                     break;
2214                 }
2215                 case WINED3DDECLTYPE_USHORT2N:
2216                 {
2217                     GLushort s[4] = {((unsigned short *) ptr)[0], ((unsigned short *) ptr)[1], 0, 1};
2218                     GL_EXTCALL(glVertexAttrib4NusvARB(i, s));
2219                     break;
2220                 }
2221                 case WINED3DDECLTYPE_SHORT4N:
2222                     GL_EXTCALL(glVertexAttrib4NsvARB(i, (GLshort *) ptr));
2223                     break;
2224                 case WINED3DDECLTYPE_USHORT4N:
2225                     GL_EXTCALL(glVertexAttrib4NusvARB(i, (GLushort *) ptr));
2226                     break;
2227
2228                 case WINED3DDECLTYPE_UDEC3:
2229                     FIXME("Unsure about WINED3DDECLTYPE_UDEC3\n");
2230                     /*glVertexAttrib3usvARB(instancedData[j], (GLushort *) ptr); Does not exist */
2231                     break;
2232                 case WINED3DDECLTYPE_DEC3N:
2233                     FIXME("Unsure about WINED3DDECLTYPE_DEC3N\n");
2234                     /*glVertexAttrib3NusvARB(instancedData[j], (GLushort *) ptr); Does not exist */
2235                     break;
2236
2237                 case WINED3DDECLTYPE_FLOAT16_2:
2238                     /* Are those 16 bit floats. C doesn't have a 16 bit float type. I could read the single bits and calculate a 4
2239                      * byte float according to the IEEE standard
2240                      */
2241                     FIXME("Unsupported WINED3DDECLTYPE_FLOAT16_2\n");
2242                     break;
2243                 case WINED3DDECLTYPE_FLOAT16_4:
2244                     FIXME("Unsupported WINED3DDECLTYPE_FLOAT16_4\n");
2245                     break;
2246
2247                 case WINED3DDECLTYPE_UNUSED:
2248                 default:
2249                     ERR("Unexpected declaration in stride 0 attributes\n");
2250                     break;
2251
2252             }
2253         }
2254     }
2255 }
2256
2257 /* Used from 2 different functions, and too big to justify making it inlined */
2258 static void loadVertexData(IWineD3DStateBlockImpl *stateblock, WineDirect3DVertexStridedData *sd) {
2259     unsigned int textureNo   = 0;
2260     unsigned int texture_idx = 0;
2261     UINT *offset = stateblock->streamOffset;
2262     GLint curVBO = GL_SUPPORT(ARB_VERTEX_BUFFER_OBJECT) ? -1 : 0;
2263
2264     TRACE("Using fast vertex array code\n");
2265     /* Blend Data ---------------------------------------------- */
2266     if( (sd->u.s.blendWeights.lpData) || (sd->u.s.blendWeights.VBO) ||
2267         (sd->u.s.blendMatrixIndices.lpData) || (sd->u.s.blendMatrixIndices.VBO) ) {
2268
2269
2270         if (GL_SUPPORT(ARB_VERTEX_BLEND)) {
2271
2272 #if 1
2273             glEnableClientState(GL_WEIGHT_ARRAY_ARB);
2274             checkGLcall("glEnableClientState(GL_WEIGHT_ARRAY_ARB)");
2275 #endif
2276
2277             TRACE("Blend %d %p %d\n", WINED3D_ATR_SIZE(sd->u.s.blendWeights.dwType),
2278                 sd->u.s.blendWeights.lpData + stateblock->loadBaseVertexIndex * sd->u.s.blendWeights.dwStride, sd->u.s.blendWeights.dwStride + offset[sd->u.s.blendWeights.streamNo]);
2279             /* FIXME("TODO\n");*/
2280             /* Note dwType == float3 or float4 == 2 or 3 */
2281
2282 #if 0
2283             /* with this on, the normals appear to be being modified,
2284                but the vertices aren't being translated as they should be
2285                Maybe the world matrix aren't being setup properly? */
2286             glVertexBlendARB(WINED3D_ATR_SIZE(sd->u.s.blendWeights.dwType) + 1);
2287 #endif
2288
2289
2290             VTRACE(("glWeightPointerARB(%d, GL_FLOAT, %d, %p)\n",
2291                 WINED3D_ATR_SIZE(sd->u.s.blendWeights.dwType) ,
2292                 sd->u.s.blendWeights.dwStride,
2293                 sd->u.s.blendWeights.lpData + stateblock->loadBaseVertexIndex * sd->u.s.blendWeights.dwStride + offset[sd->u.s.blendWeights.streamNo]));
2294
2295             if(curVBO != sd->u.s.blendWeights.VBO) {
2296                 GL_EXTCALL(glBindBufferARB(GL_ARRAY_BUFFER_ARB, sd->u.s.blendWeights.VBO));
2297                 checkGLcall("glBindBufferARB");
2298                 curVBO = sd->u.s.blendWeights.VBO;
2299             }
2300
2301             GL_EXTCALL(glWeightPointerARB)(
2302                 WINED3D_ATR_SIZE(sd->u.s.blendWeights.dwType),
2303                 WINED3D_ATR_GLTYPE(sd->u.s.blendWeights.dwType),
2304                 sd->u.s.blendWeights.dwStride,
2305                 sd->u.s.blendWeights.lpData + stateblock->loadBaseVertexIndex * sd->u.s.blendWeights.dwStride + offset[sd->u.s.blendWeights.streamNo]);
2306
2307             checkGLcall("glWeightPointerARB");
2308
2309             if((sd->u.s.blendMatrixIndices.lpData) || (sd->u.s.blendMatrixIndices.VBO)){
2310                 static BOOL showfixme = TRUE;
2311                 if(showfixme){
2312                     FIXME("blendMatrixIndices support\n");
2313                     showfixme = FALSE;
2314                 }
2315             }
2316
2317         } else if (GL_SUPPORT(EXT_VERTEX_WEIGHTING)) {
2318             /* FIXME("TODO\n");*/
2319 #if 0
2320
2321             GL_EXTCALL(glVertexWeightPointerEXT)(
2322                 WINED3D_ATR_SIZE(sd->u.s.blendWeights.dwType),
2323                 WINED3D_ATR_GLTYPE(sd->u.s.blendWeights.dwType),
2324                 sd->u.s.blendWeights.dwStride,
2325                 sd->u.s.blendWeights.lpData + stateblock->loadBaseVertexIndex * sd->u.s.blendWeights.dwStride);
2326             checkGLcall("glVertexWeightPointerEXT(numBlends, ...)");
2327             glEnableClientState(GL_VERTEX_WEIGHT_ARRAY_EXT);
2328             checkGLcall("glEnableClientState(GL_VERTEX_WEIGHT_ARRAY_EXT)");
2329 #endif
2330
2331         } else {
2332             /* TODO: support blends in fixupVertices */
2333             FIXME("unsupported blending in openGl\n");
2334         }
2335     } else {
2336         if (GL_SUPPORT(ARB_VERTEX_BLEND)) {
2337 #if 0    /* TODO: Vertex blending */
2338             glDisable(GL_VERTEX_BLEND_ARB);
2339 #endif
2340             TRACE("ARB_VERTEX_BLEND\n");
2341         } else if (GL_SUPPORT(EXT_VERTEX_WEIGHTING)) {
2342             TRACE(" EXT_VERTEX_WEIGHTING\n");
2343             glDisableClientState(GL_VERTEX_WEIGHT_ARRAY_EXT);
2344             checkGLcall("glDisableClientState(GL_VERTEX_WEIGHT_ARRAY_EXT)");
2345
2346         }
2347     }
2348
2349 #if 0 /* FOG  ----------------------------------------------*/
2350     if (sd->u.s.fog.lpData || sd->u.s.fog.VBO) {
2351         /* TODO: fog*/
2352     if (GL_SUPPORT(EXT_FOG_COORD) {
2353              glEnableClientState(GL_FOG_COORDINATE_EXT);
2354             (GL_EXTCALL)(FogCoordPointerEXT)(
2355                 WINED3D_ATR_GLTYPE(sd->u.s.fog.dwType),
2356                 sd->u.s.fog.dwStride,
2357                 sd->u.s.fog.lpData + stateblock->loadBaseVertexIndex * sd->u.s.fog.dwStride);
2358         } else {
2359             /* don't bother falling back to 'slow' as we don't support software FOG yet. */
2360             /* FIXME: fixme once */
2361             TRACE("Hardware support for FOG is not avaiable, FOG disabled.\n");
2362         }
2363     } else {
2364         if (GL_SUPPRT(EXT_FOR_COORD) {
2365              /* make sure fog is disabled */
2366              glDisableClientState(GL_FOG_COORDINATE_EXT);
2367         }
2368     }
2369 #endif
2370
2371 #if 0 /* tangents  ----------------------------------------------*/
2372     if (sd->u.s.tangent.lpData || sd->u.s.tangent.VBO ||
2373         sd->u.s.binormal.lpData || sd->u.s.binormal.VBO) {
2374         /* TODO: tangents*/
2375         if (GL_SUPPORT(EXT_COORDINATE_FRAME) {
2376             if (sd->u.s.tangent.lpData || sd->u.s.tangent.VBO) {
2377                 glEnable(GL_TANGENT_ARRAY_EXT);
2378                 (GL_EXTCALL)(TangentPointerEXT)(
2379                     WINED3D_ATR_GLTYPE(sd->u.s.tangent.dwType),
2380                     sd->u.s.tangent.dwStride,
2381                     sd->u.s.tangent.lpData + stateblock->loadBaseVertexIndex * sd->u.s.tangent.dwStride);
2382             } else {
2383                     glDisable(GL_TANGENT_ARRAY_EXT);
2384             }
2385             if (sd->u.s.binormal.lpData || sd->u.s.binormal.VBO) {
2386                     glEnable(GL_BINORMAL_ARRAY_EXT);
2387                     (GL_EXTCALL)(BinormalPointerEXT)(
2388                         WINED3D_ATR_GLTYPE(sd->u.s.binormal.dwType),
2389                         sd->u.s.binormal.dwStride,
2390                         sd->u.s.binormal.lpData + stateblock->loadBaseVertexIndex * sd->u.s.binormal.dwStride);
2391             } else{
2392                     glDisable(GL_BINORMAL_ARRAY_EXT);
2393             }
2394
2395         } else {
2396             /* don't bother falling back to 'slow' as we don't support software tangents and binormals yet . */
2397             /* FIXME: fixme once */
2398             TRACE("Hardware support for tangents and binormals is not avaiable, tangents and binormals disabled.\n");
2399         }
2400     } else {
2401         if (GL_SUPPORT(EXT_COORDINATE_FRAME) {
2402              /* make sure fog is disabled */
2403              glDisable(GL_TANGENT_ARRAY_EXT);
2404              glDisable(GL_BINORMAL_ARRAY_EXT);
2405         }
2406     }
2407 #endif
2408
2409     /* Point Size ----------------------------------------------*/
2410     if (sd->u.s.pSize.lpData || sd->u.s.pSize.VBO) {
2411
2412         /* no such functionality in the fixed function GL pipeline */
2413         TRACE("Cannot change ptSize here in openGl\n");
2414         /* TODO: Implement this function in using shaders if they are available */
2415
2416     }
2417
2418     /* Vertex Pointers -----------------------------------------*/
2419     if (sd->u.s.position.lpData != NULL || sd->u.s.position.VBO != 0) {
2420         /* Note dwType == float3 or float4 == 2 or 3 */
2421         VTRACE(("glVertexPointer(%d, GL_FLOAT, %d, %p)\n",
2422                 sd->u.s.position.dwStride,
2423                 sd->u.s.position.dwType + 1,
2424                 sd->u.s.position.lpData));
2425
2426         if(curVBO != sd->u.s.position.VBO) {
2427             GL_EXTCALL(glBindBufferARB(GL_ARRAY_BUFFER_ARB, sd->u.s.position.VBO));
2428             checkGLcall("glBindBufferARB");
2429             curVBO = sd->u.s.position.VBO;
2430         }
2431
2432         /* min(WINED3D_ATR_SIZE(position),3) to Disable RHW mode as 'w' coord
2433            handling for rhw mode should not impact screen position whereas in GL it does.
2434            This may  result in very slightly distored textures in rhw mode, but
2435            a very minimal different. There's always the other option of
2436            fixing the view matrix to prevent w from having any effect
2437
2438            This only applies to user pointer sources, in VBOs the vertices are fixed up
2439          */
2440         if(sd->u.s.position.VBO == 0) {
2441             glVertexPointer(3 /* min(WINED3D_ATR_SIZE(sd->u.s.position.dwType),3) */,
2442                 WINED3D_ATR_GLTYPE(sd->u.s.position.dwType),
2443                 sd->u.s.position.dwStride, sd->u.s.position.lpData + stateblock->loadBaseVertexIndex * sd->u.s.position.dwStride + offset[sd->u.s.position.streamNo]);
2444         } else {
2445             glVertexPointer(
2446                 WINED3D_ATR_SIZE(sd->u.s.position.dwType),
2447                 WINED3D_ATR_GLTYPE(sd->u.s.position.dwType),
2448                 sd->u.s.position.dwStride, sd->u.s.position.lpData + stateblock->loadBaseVertexIndex * sd->u.s.position.dwStride + offset[sd->u.s.position.streamNo]);
2449         }
2450         checkGLcall("glVertexPointer(...)");
2451         glEnableClientState(GL_VERTEX_ARRAY);
2452         checkGLcall("glEnableClientState(GL_VERTEX_ARRAY)");
2453
2454     } else {
2455         glDisableClientState(GL_VERTEX_ARRAY);
2456         checkGLcall("glDisableClientState(GL_VERTEX_ARRAY)");
2457     }
2458
2459     /* Normals -------------------------------------------------*/
2460     if (sd->u.s.normal.lpData || sd->u.s.normal.VBO) {
2461         /* Note dwType == float3 or float4 == 2 or 3 */
2462         VTRACE(("glNormalPointer(GL_FLOAT, %d, %p)\n",
2463                 sd->u.s.normal.dwStride,
2464                 sd->u.s.normal.lpData));
2465         if(curVBO != sd->u.s.normal.VBO) {
2466             GL_EXTCALL(glBindBufferARB(GL_ARRAY_BUFFER_ARB, sd->u.s.normal.VBO));
2467             checkGLcall("glBindBufferARB");
2468             curVBO = sd->u.s.normal.VBO;
2469         }
2470         glNormalPointer(
2471             WINED3D_ATR_GLTYPE(sd->u.s.normal.dwType),
2472             sd->u.s.normal.dwStride,
2473             sd->u.s.normal.lpData + stateblock->loadBaseVertexIndex * sd->u.s.normal.dwStride + offset[sd->u.s.normal.streamNo]);
2474         checkGLcall("glNormalPointer(...)");
2475         glEnableClientState(GL_NORMAL_ARRAY);
2476         checkGLcall("glEnableClientState(GL_NORMAL_ARRAY)");
2477
2478     } else {
2479         glDisableClientState(GL_NORMAL_ARRAY);
2480         checkGLcall("glDisableClientState(GL_NORMAL_ARRAY)");
2481         glNormal3f(0, 0, 1);
2482         checkGLcall("glNormal3f(0, 0, 1)");
2483     }
2484
2485     /* Diffuse Colour --------------------------------------------*/
2486     /*  WARNING: Data here MUST be in RGBA format, so cannot      */
2487     /*     go directly into fast mode from app pgm, because       */
2488     /*     directx requires data in BGRA format.                  */
2489     /* currently fixupVertices swizels the format, but this isn't */
2490     /* very practical when using VBOS                             */
2491     /* NOTE: Unless we write a vertex shader to swizel the colour */
2492     /* , or the user doesn't care and wants the speed advantage   */
2493
2494     if (sd->u.s.diffuse.lpData || sd->u.s.diffuse.VBO) {
2495         /* Note dwType == float3 or float4 == 2 or 3 */
2496         VTRACE(("glColorPointer(4, GL_UNSIGNED_BYTE, %d, %p)\n",
2497                 sd->u.s.diffuse.dwStride,
2498                 sd->u.s.diffuse.lpData));
2499
2500         if(curVBO != sd->u.s.diffuse.VBO) {
2501             GL_EXTCALL(glBindBufferARB(GL_ARRAY_BUFFER_ARB, sd->u.s.diffuse.VBO));
2502             checkGLcall("glBindBufferARB");
2503             curVBO = sd->u.s.diffuse.VBO;
2504         }
2505         glColorPointer(4, GL_UNSIGNED_BYTE,
2506                        sd->u.s.diffuse.dwStride,
2507                        sd->u.s.diffuse.lpData + stateblock->loadBaseVertexIndex * sd->u.s.diffuse.dwStride + offset[sd->u.s.diffuse.streamNo]);
2508         checkGLcall("glColorPointer(4, GL_UNSIGNED_BYTE, ...)");
2509         glEnableClientState(GL_COLOR_ARRAY);
2510         checkGLcall("glEnableClientState(GL_COLOR_ARRAY)");
2511
2512     } else {
2513         glDisableClientState(GL_COLOR_ARRAY);
2514         checkGLcall("glDisableClientState(GL_COLOR_ARRAY)");
2515         glColor4f(1.0f, 1.0f, 1.0f, 1.0f);
2516         checkGLcall("glColor4f(1, 1, 1, 1)");
2517     }
2518
2519     /* Specular Colour ------------------------------------------*/
2520     if (sd->u.s.specular.lpData || sd->u.s.specular.VBO) {
2521         TRACE("setting specular colour\n");
2522         /* Note dwType == float3 or float4 == 2 or 3 */
2523         VTRACE(("glSecondaryColorPointer(4, GL_UNSIGNED_BYTE, %d, %p)\n",
2524                 sd->u.s.specular.dwStride,
2525                 sd->u.s.specular.lpData));
2526         if (GL_SUPPORT(EXT_SECONDARY_COLOR)) {
2527             if(curVBO != sd->u.s.specular.VBO) {
2528                 GL_EXTCALL(glBindBufferARB(GL_ARRAY_BUFFER_ARB, sd->u.s.specular.VBO));
2529                 checkGLcall("glBindBufferARB");
2530                 curVBO = sd->u.s.specular.VBO;
2531             }
2532             GL_EXTCALL(glSecondaryColorPointerEXT)(4, GL_UNSIGNED_BYTE,
2533                                                    sd->u.s.specular.dwStride,
2534                                                    sd->u.s.specular.lpData + stateblock->loadBaseVertexIndex * sd->u.s.specular.dwStride + offset[sd->u.s.specular.streamNo]);
2535             vcheckGLcall("glSecondaryColorPointerEXT(4, GL_UNSIGNED_BYTE, ...)");
2536             glEnableClientState(GL_SECONDARY_COLOR_ARRAY_EXT);
2537             vcheckGLcall("glEnableClientState(GL_SECONDARY_COLOR_ARRAY_EXT)");
2538         } else {
2539
2540         /* Missing specular color is not critical, no warnings */
2541         VTRACE(("Specular colour is not supported in this GL implementation\n"));
2542         }
2543
2544     } else {
2545         if (GL_SUPPORT(EXT_SECONDARY_COLOR)) {
2546
2547             glDisableClientState(GL_SECONDARY_COLOR_ARRAY_EXT);
2548             checkGLcall("glDisableClientState(GL_SECONDARY_COLOR_ARRAY_EXT)");
2549             GL_EXTCALL(glSecondaryColor3fEXT)(0, 0, 0);
2550             checkGLcall("glSecondaryColor3fEXT(0, 0, 0)");
2551         } else {
2552
2553             /* Missing specular color is not critical, no warnings */
2554             VTRACE(("Specular colour is not supported in this GL implementation\n"));
2555         }
2556     }
2557
2558     /* Texture coords -------------------------------------------*/
2559
2560     for (textureNo = 0, texture_idx = 0; textureNo < GL_LIMITS(texture_stages); ++textureNo) {
2561         /* The code below uses glClientActiveTexture and glMultiTexCoord* which are all part of the GL_ARB_multitexture extension. */
2562         /* Abort if we don't support the extension. */
2563         if (!GL_SUPPORT(ARB_MULTITEXTURE)) {
2564             FIXME("Program using multiple concurrent textures which this opengl implementation doesn't support\n");
2565             continue;
2566         }
2567
2568         if (/*!GL_SUPPORT(NV_REGISTER_COMBINERS) || stateblock->textures[textureNo]*/ TRUE) {
2569             /* Select the correct texture stage */
2570             GL_EXTCALL(glClientActiveTextureARB(GL_TEXTURE0_ARB + texture_idx));
2571         }
2572
2573         if (stateblock->textures[textureNo] != NULL) {
2574             int coordIdx = stateblock->textureState[textureNo][WINED3DTSS_TEXCOORDINDEX];
2575
2576             if (coordIdx >= MAX_TEXTURES) {
2577                 VTRACE(("tex: %d - Skip tex coords, as being system generated\n", textureNo));
2578                 glDisableClientState(GL_TEXTURE_COORD_ARRAY);
2579                 GL_EXTCALL(glMultiTexCoord4fARB(GL_TEXTURE0_ARB + texture_idx, 0, 0, 0, 1));
2580
2581             } else if (sd->u.s.texCoords[coordIdx].lpData == NULL && sd->u.s.texCoords[coordIdx].VBO == 0) {
2582                 VTRACE(("Bound texture but no texture coordinates supplied, so skipping\n"));
2583                 glDisableClientState(GL_TEXTURE_COORD_ARRAY);
2584                 GL_EXTCALL(glMultiTexCoord4fARB(GL_TEXTURE0_ARB + texture_idx, 0, 0, 0, 1));
2585
2586             } else {
2587                 TRACE("Setting up texture %u, idx %d, cordindx %u, data %p\n",
2588                       textureNo, texture_idx, coordIdx, sd->u.s.texCoords[coordIdx].lpData);
2589                 if(curVBO != sd->u.s.texCoords[coordIdx].VBO) {
2590                     GL_EXTCALL(glBindBufferARB(GL_ARRAY_BUFFER_ARB, sd->u.s.texCoords[coordIdx].VBO));
2591                     checkGLcall("glBindBufferARB");
2592                     curVBO = sd->u.s.texCoords[coordIdx].VBO;
2593                 }
2594                 /* The coords to supply depend completely on the fvf / vertex shader */
2595                 glTexCoordPointer(
2596                     WINED3D_ATR_SIZE(sd->u.s.texCoords[coordIdx].dwType),
2597                     WINED3D_ATR_GLTYPE(sd->u.s.texCoords[coordIdx].dwType),
2598                     sd->u.s.texCoords[coordIdx].dwStride,
2599                     sd->u.s.texCoords[coordIdx].lpData + stateblock->loadBaseVertexIndex * sd->u.s.texCoords[coordIdx].dwStride + offset[sd->u.s.texCoords[coordIdx].streamNo]);
2600                 glEnableClientState(GL_TEXTURE_COORD_ARRAY);
2601             }
2602         } else if (!GL_SUPPORT(NV_REGISTER_COMBINERS)) {
2603             glDisableClientState(GL_TEXTURE_COORD_ARRAY);
2604             GL_EXTCALL(glMultiTexCoord4fARB(GL_TEXTURE0_ARB + textureNo, 0, 0, 0, 1));
2605         }
2606         if (/*!GL_SUPPORT(NV_REGISTER_COMBINERS) || stateblock->textures[textureNo]*/ TRUE) ++texture_idx;
2607     }
2608     if (GL_SUPPORT(NV_REGISTER_COMBINERS)) {
2609         for (textureNo = texture_idx; textureNo < GL_LIMITS(textures); ++textureNo) {
2610             GL_EXTCALL(glClientActiveTextureARB(GL_TEXTURE0_ARB + textureNo));
2611             glDisableClientState(GL_TEXTURE_COORD_ARRAY);
2612             GL_EXTCALL(glMultiTexCoord4fARB(GL_TEXTURE0_ARB + textureNo, 0, 0, 0, 1));
2613         }
2614     }
2615 }
2616
2617 inline void drawPrimitiveTraceDataLocations(
2618     WineDirect3DVertexStridedData *dataLocations) {
2619
2620     /* Dump out what parts we have supplied */
2621     TRACE("Strided Data:\n");
2622     TRACE_STRIDED((dataLocations), position);
2623     TRACE_STRIDED((dataLocations), blendWeights);
2624     TRACE_STRIDED((dataLocations), blendMatrixIndices);
2625     TRACE_STRIDED((dataLocations), normal);
2626     TRACE_STRIDED((dataLocations), pSize);
2627     TRACE_STRIDED((dataLocations), diffuse);
2628     TRACE_STRIDED((dataLocations), specular);
2629     TRACE_STRIDED((dataLocations), texCoords[0]);
2630     TRACE_STRIDED((dataLocations), texCoords[1]);
2631     TRACE_STRIDED((dataLocations), texCoords[2]);
2632     TRACE_STRIDED((dataLocations), texCoords[3]);
2633     TRACE_STRIDED((dataLocations), texCoords[4]);
2634     TRACE_STRIDED((dataLocations), texCoords[5]);
2635     TRACE_STRIDED((dataLocations), texCoords[6]);
2636     TRACE_STRIDED((dataLocations), texCoords[7]);
2637     TRACE_STRIDED((dataLocations), position2);
2638     TRACE_STRIDED((dataLocations), normal2);
2639     TRACE_STRIDED((dataLocations), tangent);
2640     TRACE_STRIDED((dataLocations), binormal);
2641     TRACE_STRIDED((dataLocations), tessFactor);
2642     TRACE_STRIDED((dataLocations), fog);
2643     TRACE_STRIDED((dataLocations), depth);
2644     TRACE_STRIDED((dataLocations), sample);
2645
2646     return;
2647 }
2648
2649 /* Helper for vertexdeclaration() */
2650 static inline void handleStreams(IWineD3DStateBlockImpl *stateblock, BOOL useVertexShaderFunction, WineD3DContext *context) {
2651     IWineD3DDeviceImpl *device = stateblock->wineD3DDevice;
2652     BOOL fixup = FALSE;
2653     WineDirect3DVertexStridedData *dataLocations = &device->strided_streams;
2654
2655     if(device->up_strided) {
2656         /* Note: this is a ddraw fixed-function code path */
2657         TRACE("================ Strided Input ===================\n");
2658         memcpy(dataLocations, device->up_strided, sizeof(*dataLocations));
2659
2660         if(TRACE_ON(d3d)) {
2661             drawPrimitiveTraceDataLocations(dataLocations);
2662         }
2663     } else if (stateblock->vertexDecl || stateblock->vertexShader) {
2664         /* Note: This is a fixed function or shader codepath.
2665          * This means it must handle both types of strided data.
2666          * Shaders must go through here to zero the strided data, even if they
2667          * don't set any declaration at all
2668          */
2669         TRACE("================ Vertex Declaration  ===================\n");
2670         memset(dataLocations, 0, sizeof(*dataLocations));
2671
2672         if (stateblock->vertexDecl) {
2673             primitiveDeclarationConvertToStridedData((IWineD3DDevice *) device, useVertexShaderFunction,
2674                 dataLocations, &fixup);
2675         }
2676     } else {
2677         /* Note: This codepath is not reachable from d3d9 (see fvf->decl9 conversion)
2678          * It is reachable through d3d8, but only for fixed-function.
2679          * It will not work properly for shaders.
2680          */
2681         TRACE("================ FVF ===================\n");
2682         memset(dataLocations, 0, sizeof(*dataLocations));
2683         primitiveConvertToStridedData((IWineD3DDevice *) device, dataLocations, &fixup);
2684         if(TRACE_ON(d3d)) {
2685             drawPrimitiveTraceDataLocations(dataLocations);
2686         }
2687      }
2688
2689     /* Unload the old arrays before loading the new ones to get old junk out */
2690     if(context->numberedArraysLoaded) {
2691         unloadNumberedArrays(stateblock);
2692         context->numberedArraysLoaded = FALSE;
2693     }
2694     if(context->namedArraysLoaded) {
2695         unloadVertexData(stateblock);
2696         context->namedArraysLoaded = FALSE;
2697     }
2698
2699     if(useVertexShaderFunction) {
2700         TRACE("Loading numbered arrays\n");
2701         loadNumberedArrays(stateblock, dataLocations);
2702         device->useDrawStridedSlow = FALSE;
2703         context->numberedArraysLoaded = TRUE;
2704     } else if (fixup ||
2705                (dataLocations->u.s.pSize.lpData == NULL &&
2706                 dataLocations->u.s.diffuse.lpData == NULL &&
2707                 dataLocations->u.s.specular.lpData == NULL)) {
2708         /* Load the vertex data using named arrays */
2709         TRACE("Loading vertex data\n");
2710         loadVertexData(stateblock, dataLocations);
2711         device->useDrawStridedSlow = FALSE;
2712         context->namedArraysLoaded = TRUE;
2713     } else {
2714         TRACE("Not loading vertex data\n");
2715         device->useDrawStridedSlow = TRUE;
2716     }
2717
2718 /* Generate some fixme's if unsupported functionality is being used */
2719 #define BUFFER_OR_DATA(_attribute) dataLocations->u.s._attribute.lpData
2720     /* TODO: Either support missing functionality in fixupVertices or by creating a shader to replace the pipeline. */
2721     if (!useVertexShaderFunction && (BUFFER_OR_DATA(blendMatrixIndices) || BUFFER_OR_DATA(blendWeights))) {
2722         FIXME("Blending data is only valid with vertex shaders %p %p\n",dataLocations->u.s.blendWeights.lpData,dataLocations->u.s.blendWeights.lpData);
2723     }
2724     if (!useVertexShaderFunction && (BUFFER_OR_DATA(position2) || BUFFER_OR_DATA(normal2))) {
2725         FIXME("Tweening is only valid with vertex shaders\n");
2726     }
2727     if (!useVertexShaderFunction && (BUFFER_OR_DATA(tangent) || BUFFER_OR_DATA(binormal))) {
2728         FIXME("Tangent and binormal bump mapping is only valid with vertex shaders\n");
2729     }
2730     if (!useVertexShaderFunction && (BUFFER_OR_DATA(tessFactor) || BUFFER_OR_DATA(fog) || BUFFER_OR_DATA(depth) || BUFFER_OR_DATA(sample))) {
2731         FIXME("Extended attributes are only valid with vertex shaders\n");
2732     }
2733 #undef BUFFER_OR_DATA
2734 }
2735
2736 static void vertexdeclaration(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
2737     BOOL useVertexShaderFunction = FALSE, updateFog = FALSE;
2738     BOOL usePixelShaderFunction = stateblock->wineD3DDevice->ps_selected_mode != SHADER_NONE && stateblock->pixelShader
2739             && ((IWineD3DPixelShaderImpl *)stateblock->pixelShader)->baseShader.function;
2740     BOOL transformed;
2741     /* Some stuff is in the device until we have per context tracking */
2742     IWineD3DDeviceImpl *device = stateblock->wineD3DDevice;
2743     BOOL wasrhw = context->last_was_rhw;
2744
2745     /* Shaders can be implemented using ARB_PROGRAM, GLSL, or software -
2746      * here simply check whether a shader was set, or the user disabled shaders
2747      */
2748     if (device->vs_selected_mode != SHADER_NONE && stateblock->vertexShader &&
2749        ((IWineD3DVertexShaderImpl *)stateblock->vertexShader)->baseShader.function != NULL) {
2750         useVertexShaderFunction = TRUE;
2751
2752         if(((IWineD3DVertexShaderImpl *)stateblock->vertexShader)->usesFog != context->last_was_foggy_shader) {
2753             updateFog = TRUE;
2754         }
2755     } else if(context->last_was_foggy_shader) {
2756         updateFog = TRUE;
2757     }
2758
2759     handleStreams(stateblock, useVertexShaderFunction, context);
2760
2761     /* Do I have to use ? TRUE : FALSE ? Or can I rely on 15==15 being equal to TRUE(=1)? */
2762     transformed = ((device->strided_streams.u.s.position.lpData != NULL ||
2763                     device->strided_streams.u.s.position.VBO != 0) &&
2764                     device->strided_streams.u.s.position_transformed) ? TRUE : FALSE;
2765
2766     if(transformed != context->last_was_rhw && !useVertexShaderFunction) {
2767         updateFog = TRUE;
2768     }
2769
2770     /* Reapply lighting if it is not sheduled for reapplication already */
2771     if(!isStateDirty(context, STATE_RENDER(WINED3DRS_LIGHTING))) {
2772         state_lighting(STATE_RENDER(WINED3DRS_LIGHTING), stateblock, context);
2773     }
2774
2775     if (!useVertexShaderFunction && transformed) {
2776         context->last_was_rhw = TRUE;
2777     } else {
2778
2779         /* Untransformed, so relies on the view and projection matrices */
2780         context->last_was_rhw = FALSE;
2781         /* This turns off the Z scale trick to 'disable' viewport frustum clipping in rhw mode*/
2782         device->untransformed = TRUE;
2783
2784         /* Todo for sw shaders: Vertex Shader output is already transformed, so set up identity matrices
2785          * Not needed as long as only hw shaders are supported
2786          */
2787
2788         /* This sets the shader output position correction constants.
2789          * TODO: Move to the viewport state
2790          */
2791         if (useVertexShaderFunction) {
2792             device->posFixup[1] = device->render_offscreen ? -1.0 : 1.0;
2793         }
2794     }
2795
2796     /* Don't have to apply the matrices when vertex shaders are used. When vshaders are turned
2797      * off this function will be called again anyway to make sure they're properly set
2798      */
2799     if(!useVertexShaderFunction) {
2800         /* TODO: Move this mainly to the viewport state and only apply when the vp has changed
2801          * or transformed / untransformed was switched
2802          */
2803        if(wasrhw != context->last_was_rhw &&
2804           !isStateDirty(context, STATE_TRANSFORM(WINED3DTS_PROJECTION)) &&
2805           !isStateDirty(context, STATE_VIEWPORT)) {
2806             transform_projection(STATE_TRANSFORM(WINED3DTS_PROJECTION), stateblock, context);
2807         }
2808         /* World matrix needs reapplication here only if we're switching between rhw and non-rhw
2809          * mode.
2810          *
2811          * If a vertex shader is used, the world matrix changed and then vertex shader unbound
2812          * this check will fail and the matrix not applied again. This is OK because a simple
2813          * world matrix change reapplies the matrix - These checks here are only to satisfy the
2814          * needs of the vertex declaration.
2815          *
2816          * World and view matrix go into the same gl matrix, so only apply them when neither is
2817          * dirty
2818          */
2819         if(transformed != wasrhw &&
2820            !isStateDirty(context, STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(0))) &&
2821            !isStateDirty(context, STATE_TRANSFORM(WINED3DTS_VIEW))) {
2822             transform_world(STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(0)), stateblock, context);
2823         }
2824
2825         if(!isStateDirty(context, STATE_RENDER(WINED3DRS_COLORVERTEX))) {
2826             state_colormat(STATE_RENDER(WINED3DRS_COLORVERTEX), stateblock, context);
2827         }
2828     } else {
2829         /* We compile the shader here because we need the vertex declaration
2830          * in order to determine if we need to do any swizzling for D3DCOLOR
2831          * registers. If the shader is already compiled this call will do nothing. */
2832         IWineD3DVertexShader_CompileShader(stateblock->vertexShader);
2833     }
2834
2835     /* Vertex and pixel shaders are applied together for now, so let the last dirty state do the
2836      * application
2837      */
2838     if (!isStateDirty(context, STATE_PIXELSHADER)) {
2839         device->shader_backend->shader_select((IWineD3DDevice *)device, usePixelShaderFunction, useVertexShaderFunction);
2840
2841         if (!isStateDirty(context, STATE_VERTEXSHADERCONSTANT) && (useVertexShaderFunction || usePixelShaderFunction)) {
2842             shaderconstant(STATE_VERTEXSHADERCONSTANT, stateblock, context);
2843         }
2844     }
2845
2846     context->last_was_vshader = useVertexShaderFunction;
2847
2848     if(updateFog) {
2849         state_fog(STATE_RENDER(WINED3DRS_FOGENABLE), stateblock, context);
2850     }
2851 }
2852
2853 static void viewport(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
2854     glDepthRange(stateblock->viewport.MinZ, stateblock->viewport.MaxZ);
2855     checkGLcall("glDepthRange");
2856     /* Note: GL requires lower left, DirectX supplies upper left */
2857     /* TODO: replace usage of renderTarget with context management */
2858     glViewport(stateblock->viewport.X,
2859                (((IWineD3DSurfaceImpl *)stateblock->wineD3DDevice->render_targets[0])->currentDesc.Height - (stateblock->viewport.Y + stateblock->viewport.Height)),
2860                stateblock->viewport.Width, stateblock->viewport.Height);
2861
2862     checkGLcall("glViewport");
2863
2864     stateblock->wineD3DDevice->posFixup[2] = 0.9 / stateblock->viewport.Width;
2865     stateblock->wineD3DDevice->posFixup[3] = -0.9 / stateblock->viewport.Height;
2866     if(!isStateDirty(context, STATE_TRANSFORM(D3DTS_PROJECTION))) {
2867         transform_projection(STATE_TRANSFORM(D3DTS_PROJECTION), stateblock, context);
2868     }
2869
2870 }
2871
2872 static void light(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
2873     UINT Index = state - STATE_ACTIVELIGHT(0);
2874     PLIGHTINFOEL *lightInfo = stateblock->activeLights[Index];
2875
2876     if(!lightInfo) {
2877         glDisable(GL_LIGHT0 + Index);
2878         checkGLcall("glDisable(GL_LIGHT0 + Index)");
2879     } else {
2880         float quad_att;
2881         float colRGBA[] = {0.0, 0.0, 0.0, 0.0};
2882
2883         /* Light settings are affected by the model view in OpenGL, the View transform in direct3d*/
2884         glMatrixMode(GL_MODELVIEW);
2885         glPushMatrix();
2886         glLoadMatrixf((float *)&stateblock->transforms[WINED3DTS_VIEW].u.m[0][0]);
2887
2888         /* Diffuse: */
2889         colRGBA[0] = lightInfo->OriginalParms.Diffuse.r;
2890         colRGBA[1] = lightInfo->OriginalParms.Diffuse.g;
2891         colRGBA[2] = lightInfo->OriginalParms.Diffuse.b;
2892         colRGBA[3] = lightInfo->OriginalParms.Diffuse.a;
2893         glLightfv(GL_LIGHT0 + Index, GL_DIFFUSE, colRGBA);
2894         checkGLcall("glLightfv");
2895
2896         /* Specular */
2897         colRGBA[0] = lightInfo->OriginalParms.Specular.r;
2898         colRGBA[1] = lightInfo->OriginalParms.Specular.g;
2899         colRGBA[2] = lightInfo->OriginalParms.Specular.b;
2900         colRGBA[3] = lightInfo->OriginalParms.Specular.a;
2901         glLightfv(GL_LIGHT0 + Index, GL_SPECULAR, colRGBA);
2902         checkGLcall("glLightfv");
2903
2904         /* Ambient */
2905         colRGBA[0] = lightInfo->OriginalParms.Ambient.r;
2906         colRGBA[1] = lightInfo->OriginalParms.Ambient.g;
2907         colRGBA[2] = lightInfo->OriginalParms.Ambient.b;
2908         colRGBA[3] = lightInfo->OriginalParms.Ambient.a;
2909         glLightfv(GL_LIGHT0 + Index, GL_AMBIENT, colRGBA);
2910         checkGLcall("glLightfv");
2911
2912         /* Attenuation - Are these right? guessing... */
2913         glLightf(GL_LIGHT0 + Index, GL_CONSTANT_ATTENUATION,  lightInfo->OriginalParms.Attenuation0);
2914         checkGLcall("glLightf");
2915         glLightf(GL_LIGHT0 + Index, GL_LINEAR_ATTENUATION,    lightInfo->OriginalParms.Attenuation1);
2916         checkGLcall("glLightf");
2917
2918         if ((lightInfo->OriginalParms.Range *lightInfo->OriginalParms.Range) >= FLT_MIN) {
2919             quad_att = 1.4/(lightInfo->OriginalParms.Range *lightInfo->OriginalParms.Range);
2920         } else {
2921             quad_att = 0; /*  0 or  MAX?  (0 seems to be ok) */
2922         }
2923
2924         if (quad_att < lightInfo->OriginalParms.Attenuation2) quad_att = lightInfo->OriginalParms.Attenuation2;
2925         glLightf(GL_LIGHT0 + Index, GL_QUADRATIC_ATTENUATION, quad_att);
2926         checkGLcall("glLightf");
2927
2928         switch (lightInfo->OriginalParms.Type) {
2929             case WINED3DLIGHT_POINT:
2930                 /* Position */
2931                 glLightfv(GL_LIGHT0 + Index, GL_POSITION, &lightInfo->lightPosn[0]);
2932                 checkGLcall("glLightfv");
2933                 glLightf(GL_LIGHT0 + Index, GL_SPOT_CUTOFF, lightInfo->cutoff);
2934                 checkGLcall("glLightf");
2935                 /* FIXME: Range */
2936                 break;
2937
2938             case WINED3DLIGHT_SPOT:
2939                 /* Position */
2940                 glLightfv(GL_LIGHT0 + Index, GL_POSITION, &lightInfo->lightPosn[0]);
2941                 checkGLcall("glLightfv");
2942                 /* Direction */
2943                 glLightfv(GL_LIGHT0 + Index, GL_SPOT_DIRECTION, &lightInfo->lightDirn[0]);
2944                 checkGLcall("glLightfv");
2945                 glLightf(GL_LIGHT0 + Index, GL_SPOT_EXPONENT, lightInfo->exponent);
2946                 checkGLcall("glLightf");
2947                 glLightf(GL_LIGHT0 + Index, GL_SPOT_CUTOFF, lightInfo->cutoff);
2948                 checkGLcall("glLightf");
2949                 /* FIXME: Range */
2950                 break;
2951
2952             case WINED3DLIGHT_DIRECTIONAL:
2953                 /* Direction */
2954                 glLightfv(GL_LIGHT0 + Index, GL_POSITION, &lightInfo->lightPosn[0]); /* Note gl uses w position of 0 for direction! */
2955                 checkGLcall("glLightfv");
2956                 glLightf(GL_LIGHT0 + Index, GL_SPOT_CUTOFF, lightInfo->cutoff);
2957                 checkGLcall("glLightf");
2958                 glLightf(GL_LIGHT0 + Index, GL_SPOT_EXPONENT, 0.0f);
2959                 checkGLcall("glLightf");
2960                 break;
2961
2962             default:
2963                 FIXME("Unrecognized light type %d\n", lightInfo->OriginalParms.Type);
2964         }
2965
2966         /* Restore the modelview matrix */
2967         glPopMatrix();
2968
2969         glEnable(GL_LIGHT0 + Index);
2970         checkGLcall("glEnable(GL_LIGHT0 + Index)");
2971     }
2972
2973     return;
2974 }
2975
2976 const struct StateEntry StateTable[] =
2977 {
2978       /* State name                                         representative,                                     apply function */
2979     { /* 0,  Undefined                              */      0,                                                  state_undefined     },
2980     { /* 1,  WINED3DRS_TEXTUREHANDLE                */      0 /* Handled in ddraw */,                           state_undefined     },
2981     { /* 2,  WINED3DRS_ANTIALIAS                    */      STATE_RENDER(WINED3DRS_ANTIALIAS),                  state_antialias     },
2982     { /* 3,  WINED3DRS_TEXTUREADDRESS               */      0 /* Handled in ddraw */,                           state_undefined     },
2983     { /* 4,  WINED3DRS_TEXTUREPERSPECTIVE           */      STATE_RENDER(WINED3DRS_TEXTUREPERSPECTIVE),         state_perspective   },
2984     { /* 5,  WINED3DRS_WRAPU                        */      STATE_RENDER(WINED3DRS_WRAPU),                      state_wrapu         },
2985     { /* 6,  WINED3DRS_WRAPV                        */      STATE_RENDER(WINED3DRS_WRAPV),                      state_wrapv         },
2986     { /* 7,  WINED3DRS_ZENABLE                      */      STATE_RENDER(WINED3DRS_ZENABLE),                    state_zenable       },
2987     { /* 8,  WINED3DRS_FILLMODE                     */      STATE_RENDER(WINED3DRS_FILLMODE),                   state_fillmode      },
2988     { /* 9,  WINED3DRS_SHADEMODE                    */      STATE_RENDER(WINED3DRS_SHADEMODE),                  state_shademode     },
2989     { /* 10, WINED3DRS_LINEPATTERN                  */      STATE_RENDER(WINED3DRS_LINEPATTERN),                state_linepattern   },
2990     { /* 11, WINED3DRS_MONOENABLE                   */      STATE_RENDER(WINED3DRS_MONOENABLE),                 state_monoenable    },
2991     { /* 12, WINED3DRS_ROP2                         */      STATE_RENDER(WINED3DRS_ROP2),                       state_rop2          },
2992     { /* 13, WINED3DRS_PLANEMASK                    */      STATE_RENDER(WINED3DRS_PLANEMASK),                  state_planemask     },
2993     { /* 14, WINED3DRS_ZWRITEENABLE                 */      STATE_RENDER(WINED3DRS_ZWRITEENABLE),               state_zwritenable   },
2994     { /* 15, WINED3DRS_ALPHATESTENABLE              */      STATE_RENDER(WINED3DRS_ALPHATESTENABLE),            state_alpha         },
2995     { /* 16, WINED3DRS_LASTPIXEL                    */      STATE_RENDER(WINED3DRS_LASTPIXEL),                  state_lastpixel     },
2996     { /* 17, WINED3DRS_TEXTUREMAG                   */      0 /* Handled in ddraw */,                           state_undefined     },
2997     { /* 18, WINED3DRS_TEXTUREMIN                   */      0 /* Handled in ddraw */,                           state_undefined     },
2998     { /* 19, WINED3DRS_SRCBLEND                     */      STATE_RENDER(WINED3DRS_ALPHABLENDENABLE),           state_blend         },
2999     { /* 20, WINED3DRS_DESTBLEND                    */      STATE_RENDER(WINED3DRS_ALPHABLENDENABLE),           state_blend         },
3000     { /* 21, WINED3DRS_TEXTUREMAPBLEND              */      0 /* Handled in ddraw */,                           state_undefined     },
3001     { /* 22, WINED3DRS_CULLMODE                     */      STATE_RENDER(WINED3DRS_CULLMODE),                   state_cullmode      },
3002     { /* 23, WINED3DRS_ZFUNC                        */      STATE_RENDER(WINED3DRS_ZFUNC),                      state_zfunc         },
3003     { /* 24, WINED3DRS_ALPHAREF                     */      STATE_RENDER(WINED3DRS_ALPHATESTENABLE),            state_alpha         },
3004     { /* 25, WINED3DRS_ALPHAFUNC                    */      STATE_RENDER(WINED3DRS_ALPHATESTENABLE),            state_alpha         },
3005     { /* 26, WINED3DRS_DITHERENABLE                 */      STATE_RENDER(WINED3DRS_DITHERENABLE),               state_ditherenable  },
3006     { /* 27, WINED3DRS_ALPHABLENDENABLE             */      STATE_RENDER(WINED3DRS_ALPHABLENDENABLE),           state_blend         },
3007     { /* 28, WINED3DRS_FOGENABLE                    */      STATE_RENDER(WINED3DRS_FOGENABLE),                  state_fog           },
3008     { /* 29, WINED3DRS_SPECULARENABLE               */      STATE_RENDER(WINED3DRS_SPECULARENABLE),             state_specularenable},
3009     { /* 30, WINED3DRS_ZVISIBLE                     */      0 /* Not supported according to the msdn */,        state_nogl          },
3010     { /* 31, WINED3DRS_SUBPIXEL                     */      STATE_RENDER(WINED3DRS_SUBPIXEL),                   state_subpixel      },
3011     { /* 32, WINED3DRS_SUBPIXELX                    */      STATE_RENDER(WINED3DRS_SUBPIXELX),                  state_subpixelx     },
3012     { /* 33, WINED3DRS_STIPPLEDALPHA                */      STATE_RENDER(WINED3DRS_STIPPLEDALPHA),              state_stippledalpha },
3013     { /* 34, WINED3DRS_FOGCOLOR                     */      STATE_RENDER(WINED3DRS_FOGCOLOR),                   state_fogcolor      },
3014     { /* 35, WINED3DRS_FOGTABLEMODE                 */      STATE_RENDER(WINED3DRS_FOGENABLE),                  state_fog           },
3015     { /* 36, WINED3DRS_FOGSTART                     */      STATE_RENDER(WINED3DRS_FOGENABLE),                  state_fog           },
3016     { /* 37, WINED3DRS_FOGEND                       */      STATE_RENDER(WINED3DRS_FOGENABLE),                  state_fog           },
3017     { /* 38, WINED3DRS_FOGDENSITY                   */      STATE_RENDER(WINED3DRS_FOGDENSITY),                 state_fogdensity    },
3018     { /* 39, WINED3DRS_STIPPLEENABLE                */      STATE_RENDER(WINED3DRS_STIPPLEENABLE),              state_stippleenable },
3019     { /* 40, WINED3DRS_EDGEANTIALIAS                */      STATE_RENDER(WINED3DRS_ALPHABLENDENABLE),           state_blend         },
3020     { /* 41, WINED3DRS_COLORKEYENABLE               */      STATE_RENDER(WINED3DRS_ALPHATESTENABLE),            state_alpha         },
3021     { /* 42, undefined                              */      0,                                                  state_undefined     },
3022     { /* 43, WINED3DRS_BORDERCOLOR                  */      STATE_RENDER(WINED3DRS_BORDERCOLOR),                state_bordercolor   },
3023     { /* 44, WINED3DRS_TEXTUREADDRESSU              */      0, /* Handled in ddraw */                           state_undefined     },
3024     { /* 45, WINED3DRS_TEXTUREADDRESSV              */      0, /* Handled in ddraw */                           state_undefined     },
3025     { /* 46, WINED3DRS_MIPMAPLODBIAS                */      STATE_RENDER(WINED3DRS_MIPMAPLODBIAS),              state_mipmaplodbias },
3026     { /* 47, WINED3DRS_ZBIAS                        */      STATE_RENDER(WINED3DRS_ZBIAS),                      state_zbias         },
3027     { /* 48, WINED3DRS_RANGEFOGENABLE               */      0,                                                  state_nogl          },
3028     { /* 49, WINED3DRS_ANISOTROPY                   */      STATE_RENDER(WINED3DRS_ANISOTROPY),                 state_anisotropy    },
3029     { /* 50, WINED3DRS_FLUSHBATCH                   */      STATE_RENDER(WINED3DRS_FLUSHBATCH),                 state_flushbatch    },
3030     { /* 51, WINED3DRS_TRANSLUCENTSORTINDEPENDENT   */      STATE_RENDER(WINED3DRS_TRANSLUCENTSORTINDEPENDENT), state_translucentsi },
3031     { /* 52, WINED3DRS_STENCILENABLE                */      STATE_RENDER(WINED3DRS_STENCILENABLE),              state_stencil       },
3032     { /* 53, WINED3DRS_STENCILFAIL                  */      STATE_RENDER(WINED3DRS_STENCILENABLE),              state_stencil       },
3033     { /* 54, WINED3DRS_STENCILZFAIL                 */      STATE_RENDER(WINED3DRS_STENCILENABLE),              state_stencil       },
3034     { /* 55, WINED3DRS_STENCILPASS                  */      STATE_RENDER(WINED3DRS_STENCILENABLE),              state_stencil       },
3035     { /* 56, WINED3DRS_STENCILFUNC                  */      STATE_RENDER(WINED3DRS_STENCILENABLE),              state_stencil       },
3036     { /* 57, WINED3DRS_STENCILREF                   */      STATE_RENDER(WINED3DRS_STENCILENABLE),              state_stencil       },
3037     { /* 58, WINED3DRS_STENCILMASK                  */      STATE_RENDER(WINED3DRS_STENCILENABLE),              state_stencil       },
3038     { /* 59, WINED3DRS_STENCILWRITEMASK             */      STATE_RENDER(WINED3DRS_STENCILWRITEMASK),           state_stencilwrite  },
3039     { /* 60, WINED3DRS_TEXTUREFACTOR                */      STATE_RENDER(WINED3DRS_TEXTUREFACTOR),              state_texfactor     },
3040     { /* 61, Undefined                              */      0,                                                  state_undefined     },
3041     { /* 62, Undefined                              */      0,                                                  state_undefined     },
3042     { /* 63, Undefined                              */      0,                                                  state_undefined     },
3043     { /* 64, WINED3DRS_STIPPLEPATTERN00             */      0 /* Obsolete, should be handled by ddraw */,       state_undefined     },
3044     { /* 65, WINED3DRS_STIPPLEPATTERN01             */      0 /* Obsolete, should he handled by ddraw */,       state_undefined     },
3045     { /* 66, WINED3DRS_STIPPLEPATTERN02             */      0 /* Obsolete, should be handled by ddraw */,       state_undefined     },
3046     { /* 67, WINED3DRS_STIPPLEPATTERN03             */      0 /* Obsolete, should be handled by ddraw */,       state_undefined     },
3047     { /* 68, WINED3DRS_STIPPLEPATTERN04             */      0 /* Obsolete, should be handled by ddraw */,       state_undefined     },
3048     { /* 69, WINED3DRS_STIPPLEPATTERN05             */      0 /* Obsolete, should be handled by ddraw */,       state_undefined     },
3049     { /* 70, WINED3DRS_STIPPLEPATTERN06             */      0 /* Obsolete, should be handled by ddraw */,       state_undefined     },
3050     { /* 71, WINED3DRS_STIPPLEPATTERN07             */      0 /* Obsolete, should be handled by ddraw */,       state_undefined     },
3051     { /* 72, WINED3DRS_STIPPLEPATTERN08             */      0 /* Obsolete, should be handled by ddraw */,       state_undefined     },
3052     { /* 73, WINED3DRS_STIPPLEPATTERN09             */      0 /* Obsolete, should be handled by ddraw */,       state_undefined     },
3053     { /* 74, WINED3DRS_STIPPLEPATTERN10             */      0 /* Obsolete, should be handled by ddraw */,       state_undefined     },
3054     { /* 75, WINED3DRS_STIPPLEPATTERN11             */      0 /* Obsolete, should be handled by ddraw */,       state_undefined     },
3055     { /* 76, WINED3DRS_STIPPLEPATTERN12             */      0 /* Obsolete, should be handled by ddraw */,       state_undefined     },
3056     { /* 77, WINED3DRS_STIPPLEPATTERN13             */      0 /* Obsolete, should be handled by ddraw */,       state_undefined     },
3057     { /* 78, WINED3DRS_STIPPLEPATTERN14             */      0 /* Obsolete, should be handled by ddraw */,       state_undefined     },
3058     { /* 79, WINED3DRS_STIPPLEPATTERN15             */      0 /* Obsolete, should be handled by ddraw */,       state_undefined     },
3059     { /* 80, WINED3DRS_STIPPLEPATTERN16             */      0 /* Obsolete, should be handled by ddraw */,       state_undefined     },
3060     { /* 81, WINED3DRS_STIPPLEPATTERN17             */      0 /* Obsolete, should be handled by ddraw */,       state_undefined     },
3061     { /* 82, WINED3DRS_STIPPLEPATTERN18             */      0 /* Obsolete, should be handled by ddraw */,       state_undefined     },
3062     { /* 83, WINED3DRS_STIPPLEPATTERN19             */      0 /* Obsolete, should be handled by ddraw */,       state_undefined     },
3063     { /* 84, WINED3DRS_STIPPLEPATTERN20             */      0 /* Obsolete, should be handled by ddraw */,       state_undefined     },
3064     { /* 85, WINED3DRS_STIPPLEPATTERN21             */      0 /* Obsolete, should be handled by ddraw */,       state_undefined     },
3065     { /* 86, WINED3DRS_STIPPLEPATTERN22             */      0 /* Obsolete, should be handled by ddraw */,       state_undefined     },
3066     { /* 87, WINED3DRS_STIPPLEPATTERN23             */      0 /* Obsolete, should be handled by ddraw */,       state_undefined     },
3067     { /* 88, WINED3DRS_STIPPLEPATTERN24             */      0 /* Obsolete, should be handled by ddraw */,       state_undefined     },
3068     { /* 89, WINED3DRS_STIPPLEPATTERN25             */      0 /* Obsolete, should be handled by ddraw */,       state_undefined     },
3069     { /* 90, WINED3DRS_STIPPLEPATTERN26             */      0 /* Obsolete, should be handled by ddraw */,       state_undefined     },
3070     { /* 91, WINED3DRS_STIPPLEPATTERN27             */      0 /* Obsolete, should be handled by ddraw */,       state_undefined     },
3071     { /* 92, WINED3DRS_STIPPLEPATTERN28             */      0 /* Obsolete, should be handled by ddraw */,       state_undefined     },
3072     { /* 93, WINED3DRS_STIPPLEPATTERN29             */      0 /* Obsolete, should be handled by ddraw */,       state_undefined     },
3073     { /* 94, WINED3DRS_STIPPLEPATTERN30             */      0 /* Obsolete, should be handled by ddraw */,       state_undefined     },
3074     { /* 95, WINED3DRS_STIPPLEPATTERN31             */      0 /* Obsolete, should be handled by ddraw */,       state_undefined     },
3075     { /* 96, Undefined                              */      0,                                                  state_undefined     },
3076     { /* 97, Undefined                              */      0,                                                  state_undefined     },
3077     { /* 98, Undefined                              */      0,                                                  state_undefined     },
3078     { /* 99, Undefined                              */      0,                                                  state_undefined     },
3079     { /*100, Undefined                              */      0,                                                  state_undefined     },
3080     { /*101, Undefined                              */      0,                                                  state_undefined     },
3081     { /*102, Undefined                              */      0,                                                  state_undefined     },
3082     { /*103, Undefined                              */      0,                                                  state_undefined     },
3083     { /*104, Undefined                              */      0,                                                  state_undefined     },
3084     { /*105, Undefined                              */      0,                                                  state_undefined     },
3085     { /*106, Undefined                              */      0,                                                  state_undefined     },
3086     { /*107, Undefined                              */      0,                                                  state_undefined     },
3087     { /*108, Undefined                              */      0,                                                  state_undefined     },
3088     { /*109, Undefined                              */      0,                                                  state_undefined     },
3089     { /*110, Undefined                              */      0,                                                  state_undefined     },
3090     { /*111, Undefined                              */      0,                                                  state_undefined     },
3091     { /*112, Undefined                              */      0,                                                  state_undefined     },
3092     { /*113, Undefined                              */      0,                                                  state_undefined     },
3093     { /*114, Undefined                              */      0,                                                  state_undefined     },
3094     { /*115, Undefined                              */      0,                                                  state_undefined     },
3095     { /*116, Undefined                              */      0,                                                  state_undefined     },
3096     { /*117, Undefined                              */      0,                                                  state_undefined     },
3097     { /*118, Undefined                              */      0,                                                  state_undefined     },
3098     { /*119, Undefined                              */      0,                                                  state_undefined     },
3099     { /*120, Undefined                              */      0,                                                  state_undefined     },
3100     { /*121, Undefined                              */      0,                                                  state_undefined     },
3101     { /*122, Undefined                              */      0,                                                  state_undefined     },
3102     { /*123, Undefined                              */      0,                                                  state_undefined     },
3103     { /*124, Undefined                              */      0,                                                  state_undefined     },
3104     { /*125, Undefined                              */      0,                                                  state_undefined     },
3105     { /*126, Undefined                              */      0,                                                  state_undefined     },
3106     { /*127, Undefined                              */      0,                                                  state_undefined     },
3107     /* Big hole ends */
3108     { /*128, WINED3DRS_WRAP0                        */      STATE_RENDER(WINED3DRS_WRAP0),                      state_wrap          },
3109     { /*129, WINED3DRS_WRAP1                        */      STATE_RENDER(WINED3DRS_WRAP0),                      state_wrap          },
3110     { /*130, WINED3DRS_WRAP2                        */      STATE_RENDER(WINED3DRS_WRAP0),                      state_wrap          },
3111     { /*131, WINED3DRS_WRAP3                        */      STATE_RENDER(WINED3DRS_WRAP0),                      state_wrap          },
3112     { /*132, WINED3DRS_WRAP4                        */      STATE_RENDER(WINED3DRS_WRAP0),                      state_wrap          },
3113     { /*133, WINED3DRS_WRAP5                        */      STATE_RENDER(WINED3DRS_WRAP0),                      state_wrap          },
3114     { /*134, WINED3DRS_WRAP6                        */      STATE_RENDER(WINED3DRS_WRAP0),                      state_wrap          },
3115     { /*135, WINED3DRS_WRAP7                        */      STATE_RENDER(WINED3DRS_WRAP0),                      state_wrap          },
3116     { /*136, WINED3DRS_CLIPPING                     */      STATE_RENDER(WINED3DRS_CLIPPING),                   state_clipping      },
3117     { /*137, WINED3DRS_LIGHTING                     */      STATE_RENDER(WINED3DRS_LIGHTING),                   state_lighting      },
3118     { /*138, WINED3DRS_EXTENTS                      */      STATE_RENDER(WINED3DRS_EXTENTS),                    state_extents       },
3119     { /*139, WINED3DRS_AMBIENT                      */      STATE_RENDER(WINED3DRS_AMBIENT),                    state_ambient       },
3120     { /*140, WINED3DRS_FOGVERTEXMODE                */      STATE_RENDER(WINED3DRS_FOGENABLE),                  state_fog           },
3121     { /*141, WINED3DRS_COLORVERTEX                  */      STATE_RENDER(WINED3DRS_COLORVERTEX),                state_colormat      },
3122     { /*142, WINED3DRS_LOCALVIEWER                  */      STATE_RENDER(WINED3DRS_LOCALVIEWER),                state_localviewer   },
3123     { /*143, WINED3DRS_NORMALIZENORMALS             */      STATE_RENDER(WINED3DRS_NORMALIZENORMALS),           state_normalize     },
3124     { /*144, WINED3DRS_COLORKEYBLENDENABLE          */      STATE_RENDER(WINED3DRS_COLORKEYBLENDENABLE),        state_ckeyblend     },
3125     { /*145, WINED3DRS_DIFFUSEMATERIALSOURCE        */      STATE_RENDER(WINED3DRS_COLORVERTEX),                state_colormat      },
3126     { /*146, WINED3DRS_SPECULARMATERIALSOURCE       */      STATE_RENDER(WINED3DRS_COLORVERTEX),                state_colormat      },
3127     { /*147, WINED3DRS_AMBIENTMATERIALSOURCE        */      STATE_RENDER(WINED3DRS_COLORVERTEX),                state_colormat      },
3128     { /*148, WINED3DRS_EMISSIVEMATERIALSOURCE       */      STATE_RENDER(WINED3DRS_COLORVERTEX),                state_colormat      },
3129     { /*149, Undefined                              */      0,                                                  state_undefined     },
3130     { /*150, Undefined                              */      0,                                                  state_undefined     },
3131     { /*151, WINED3DRS_VERTEXBLEND                  */      0,                                                  state_nogl          },
3132     { /*152, WINED3DRS_CLIPPLANEENABLE              */      STATE_RENDER(WINED3DRS_CLIPPING),                   state_clipping      },
3133     { /*153, WINED3DRS_SOFTWAREVERTEXPROCESSING     */      0,                                                  state_nogl          },
3134     { /*154, WINED3DRS_POINTSIZE                    */      STATE_RENDER(WINED3DRS_POINTSIZE),                  state_psize         },
3135     { /*155, WINED3DRS_POINTSIZE_MIN                */      STATE_RENDER(WINED3DRS_POINTSIZE_MIN),              state_psizemin      },
3136     { /*156, WINED3DRS_POINTSPRITEENABLE            */      STATE_RENDER(WINED3DRS_POINTSPRITEENABLE),          state_pointsprite   },
3137     { /*157, WINED3DRS_POINTSCALEENABLE             */      STATE_RENDER(WINED3DRS_POINTSCALEENABLE),           state_pscale        },
3138     { /*158, WINED3DRS_POINTSCALE_A                 */      STATE_RENDER(WINED3DRS_POINTSCALEENABLE),           state_pscale        },
3139     { /*159, WINED3DRS_POINTSCALE_B                 */      STATE_RENDER(WINED3DRS_POINTSCALEENABLE),           state_pscale        },
3140     { /*160, WINED3DRS_POINTSCALE_C                 */      STATE_RENDER(WINED3DRS_POINTSCALEENABLE),           state_pscale        },
3141     { /*161, WINED3DRS_MULTISAMPLEANTIALIAS         */      STATE_RENDER(WINED3DRS_MULTISAMPLEANTIALIAS),       state_multisampleaa },
3142     { /*162, WINED3DRS_MULTISAMPLEMASK              */      STATE_RENDER(WINED3DRS_MULTISAMPLEMASK),            state_multisampmask },
3143     { /*163, WINED3DRS_PATCHEDGESTYLE               */      STATE_RENDER(WINED3DRS_PATCHEDGESTYLE),             state_patchedgestyle},
3144     { /*164, WINED3DRS_PATCHSEGMENTS                */      STATE_RENDER(WINED3DRS_PATCHSEGMENTS),              state_patchsegments },
3145     { /*165, WINED3DRS_DEBUGMONITORTOKEN            */      STATE_RENDER(WINED3DRS_DEBUGMONITORTOKEN),          state_nogl          },
3146     { /*166, WINED3DRS_POINTSIZE_MAX                */      STATE_RENDER(WINED3DRS_POINTSIZE_MAX),              state_psizemax      },
3147     { /*167, WINED3DRS_INDEXEDVERTEXBLENDENABLE     */      0,                                                  state_nogl          },
3148     { /*168, WINED3DRS_COLORWRITEENABLE             */      STATE_RENDER(WINED3DRS_COLORWRITEENABLE),           state_colorwrite    },
3149     { /*169, Undefined                              */      0,                                                  state_undefined     },
3150     { /*170, WINED3DRS_TWEENFACTOR                  */      0,                                                  state_nogl          },
3151     { /*171, WINED3DRS_BLENDOP                      */      STATE_RENDER(WINED3DRS_BLENDOP),                    state_blendop       },
3152     { /*172, WINED3DRS_POSITIONDEGREE               */      STATE_RENDER(WINED3DRS_POSITIONDEGREE),             state_positiondegree},
3153     { /*173, WINED3DRS_NORMALDEGREE                 */      STATE_RENDER(WINED3DRS_NORMALDEGREE),               state_normaldegree  },
3154       /*172, WINED3DRS_POSITIONORDER                */      /* Value assigned to 2 state names */
3155       /*173, WINED3DRS_NORMALORDER                  */      /* Value assigned to 2 state names */
3156     { /*174, WINED3DRS_SCISSORTESTENABLE            */      STATE_RENDER(WINED3DRS_SCISSORTESTENABLE),          state_scissor       },
3157     { /*175, WINED3DRS_SLOPESCALEDEPTHBIAS          */      STATE_RENDER(WINED3DRS_DEPTHBIAS),                  state_depthbias     },
3158     { /*176, WINED3DRS_ANTIALIASEDLINEENABLE        */      STATE_RENDER(WINED3DRS_ALPHABLENDENABLE),           state_blend         },
3159     { /*177, undefined                              */      0,                                                  state_undefined     },
3160     { /*178, WINED3DRS_MINTESSELLATIONLEVEL         */      STATE_RENDER(WINED3DRS_ENABLEADAPTIVETESSELLATION), state_tessellation  },
3161     { /*179, WINED3DRS_MAXTESSELLATIONLEVEL         */      STATE_RENDER(WINED3DRS_ENABLEADAPTIVETESSELLATION), state_tessellation  },
3162     { /*180, WINED3DRS_ADAPTIVETESS_X               */      STATE_RENDER(WINED3DRS_ENABLEADAPTIVETESSELLATION), state_tessellation  },
3163     { /*181, WINED3DRS_ADAPTIVETESS_Y               */      STATE_RENDER(WINED3DRS_ENABLEADAPTIVETESSELLATION), state_tessellation  },
3164     { /*182, WINED3DRS_ADAPTIVETESS_Z               */      STATE_RENDER(WINED3DRS_ENABLEADAPTIVETESSELLATION), state_tessellation  },
3165     { /*183, WINED3DRS_ADAPTIVETESS_W               */      STATE_RENDER(WINED3DRS_ENABLEADAPTIVETESSELLATION), state_tessellation  },
3166     { /*184, WINED3DRS_ENABLEADAPTIVETESSELLATION   */      STATE_RENDER(WINED3DRS_ENABLEADAPTIVETESSELLATION), state_tessellation  },
3167     { /*185, WINED3DRS_TWOSIDEDSTENCILMODE          */      STATE_RENDER(WINED3DRS_STENCILENABLE),              state_stencil       },
3168     { /*186, WINED3DRS_CCW_STENCILFAIL              */      STATE_RENDER(WINED3DRS_STENCILENABLE),              state_stencil       },
3169     { /*187, WINED3DRS_CCW_STENCILZFAIL             */      STATE_RENDER(WINED3DRS_STENCILENABLE),              state_stencil       },
3170     { /*188, WINED3DRS_CCW_STENCILPASS              */      STATE_RENDER(WINED3DRS_STENCILENABLE),              state_stencil       },
3171     { /*189, WINED3DRS_CCW_STENCILFUNC              */      STATE_RENDER(WINED3DRS_STENCILENABLE),              state_stencil       },
3172     { /*190, WINED3DRS_COLORWRITEENABLE1            */      STATE_RENDER(WINED3DRS_COLORWRITEENABLE),           state_colorwrite    },
3173     { /*191, WINED3DRS_COLORWRITEENABLE2            */      STATE_RENDER(WINED3DRS_COLORWRITEENABLE),           state_colorwrite    },
3174     { /*192, WINED3DRS_COLORWRITEENABLE3            */      STATE_RENDER(WINED3DRS_COLORWRITEENABLE),           state_colorwrite    },
3175     { /*193, WINED3DRS_BLENDFACTOR                  */      STATE_RENDER(WINED3DRS_BLENDFACTOR),                state_blendfactor   },
3176     { /*194, WINED3DRS_SRGBWRITEENABLE              */      STATE_RENDER(WINED3DRS_SRGBWRITEENABLE),            state_srgbwrite     },
3177     { /*195, WINED3DRS_DEPTHBIAS                    */      STATE_RENDER(WINED3DRS_DEPTHBIAS),                  state_depthbias     },
3178     { /*196, undefined                              */      0,                                                  state_undefined     },
3179     { /*197, undefined                              */      0,                                                  state_undefined     },
3180     { /*198, WINED3DRS_WRAP8                        */      STATE_RENDER(WINED3DRS_WRAP0),                      state_wrap          },
3181     { /*199, WINED3DRS_WRAP9                        */      STATE_RENDER(WINED3DRS_WRAP0),                      state_wrap          },
3182     { /*200, WINED3DRS_WRAP10                       */      STATE_RENDER(WINED3DRS_WRAP0),                      state_wrap          },
3183     { /*201, WINED3DRS_WRAP11                       */      STATE_RENDER(WINED3DRS_WRAP0),                      state_wrap          },
3184     { /*202, WINED3DRS_WRAP12                       */      STATE_RENDER(WINED3DRS_WRAP0),                      state_wrap          },
3185     { /*203, WINED3DRS_WRAP13                       */      STATE_RENDER(WINED3DRS_WRAP0),                      state_wrap          },
3186     { /*204, WINED3DRS_WRAP14                       */      STATE_RENDER(WINED3DRS_WRAP0),                      state_wrap          },
3187     { /*205, WINED3DRS_WRAP15                       */      STATE_RENDER(WINED3DRS_WRAP0),                      state_wrap          },
3188     { /*206, WINED3DRS_SEPARATEALPHABLENDENABLE     */      STATE_RENDER(WINED3DRS_SEPARATEALPHABLENDENABLE),   state_seperateblend },
3189     { /*207, WINED3DRS_SRCBLENDALPHA                */      STATE_RENDER(WINED3DRS_SEPARATEALPHABLENDENABLE),   state_seperateblend },
3190     { /*208, WINED3DRS_DESTBLENDALPHA               */      STATE_RENDER(WINED3DRS_SEPARATEALPHABLENDENABLE),   state_seperateblend },
3191     { /*209, WINED3DRS_BLENDOPALPHA                 */      STATE_RENDER(WINED3DRS_SEPARATEALPHABLENDENABLE),   state_seperateblend },
3192     /* Texture stage states */
3193     { /*0, 01, WINED3DTSS_COLOROP                   */      STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP),          tex_colorop         },
3194     { /*0, 02, WINED3DTSS_COLORARG1                 */      STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP),          tex_colorop         },
3195     { /*0, 03, WINED3DTSS_COLORARG2                 */      STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP),          tex_colorop         },
3196     { /*0, 04, WINED3DTSS_ALPHAOP                   */      STATE_TEXTURESTAGE(0, WINED3DTSS_ALPHAOP),          tex_alphaop         },
3197     { /*0, 05, WINED3DTSS_ALPHAARG1                 */      STATE_TEXTURESTAGE(0, WINED3DTSS_ALPHAOP),          tex_alphaop         },
3198     { /*0, 06, WINED3DTSS_ALPHAARG2                 */      STATE_TEXTURESTAGE(0, WINED3DTSS_ALPHAOP),          tex_alphaop         },
3199     { /*0, 07, WINED3DTSS_BUMPENVMAT00              */      STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP),          tex_colorop         },
3200     { /*0, 08, WINED3DTSS_BUMPENVMAT01              */      STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP),          tex_colorop         },
3201     { /*0, 09, WINED3DTSS_BUMPENVMAT10              */      STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP),          tex_colorop         },
3202     { /*0, 10, WINED3DTSS_BUMPENVMAT11              */      STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP),          tex_colorop         },
3203     { /*0, 11, WINED3DTSS_TEXCOORDINDEX             */      STATE_TEXTURESTAGE(0, WINED3DTSS_TEXCOORDINDEX),    tex_coordindex      },
3204     { /*0, 12, WINED3DTSS_ADDRESS                   */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
3205     { /*0, 13, WINED3DTSS_ADDRESSU                  */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
3206     { /*0, 14, WINED3DTSS_ADDRESSV                  */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
3207     { /*0, 15, WINED3DTSS_BORDERCOLOR               */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
3208     { /*0, 16, WINED3DTSS_MAGFILTER                 */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
3209     { /*0, 17, WINED3DTSS_MINFILTER                 */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
3210     { /*0, 18, WINED3DTSS_MIPFILTER                 */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
3211     { /*0, 19, WINED3DTSS_MIPMAPLODBIAS             */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
3212     { /*0, 20, WINED3DTSS_MAXMIPLEVEL               */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
3213     { /*0, 21, WINED3DTSS_MAXANISOTROPY             */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
3214     { /*0, 22, WINED3DTSS_BUMPENVLSCALE             */      STATE_TEXTURESTAGE(0, WINED3DTSS_BUMPENVLSCALE),    tex_bumpenvlscale   },
3215     { /*0, 23, WINED3DTSS_BUMPENVLOFFSET            */      STATE_TEXTURESTAGE(0, WINED3DTSS_BUMPENVLOFFSET),   tex_bumpenvloffset  },
3216     { /*0, 24, WINED3DTSS_TEXTURETRANSFORMFLAGS     */      STATE_TRANSFORM(WINED3DTS_TEXTURE0),                transform_texture   },
3217     { /*0, 25, WINED3DTSS_ADDRESSW                  */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
3218     { /*0, 26, WINED3DTSS_COLORARG0                 */      STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP),          tex_colorop         },
3219     { /*0, 27, WINED3DTSS_ALPHAARG0                 */      STATE_TEXTURESTAGE(0, WINED3DTSS_ALPHAOP),          tex_alphaop         },
3220     { /*0, 28, WINED3DTSS_RESULTARG                 */      STATE_TEXTURESTAGE(0, WINED3DTSS_RESULTARG),        tex_resultarg       },
3221     { /*0, 29, undefined                            */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
3222     { /*0, 30, undefined                            */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
3223     { /*0, 31, undefined                            */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
3224     { /*0, 32, WINED3DTSS_CONSTANT                  */      0 /* As long as we don't support D3DTA_CONSTANT */, state_nogl          },
3225
3226     { /*1, 01, WINED3DTSS_COLOROP                   */      STATE_TEXTURESTAGE(1, WINED3DTSS_COLOROP),          tex_colorop         },
3227     { /*1, 02, WINED3DTSS_COLORARG1                 */      STATE_TEXTURESTAGE(1, WINED3DTSS_COLOROP),          tex_colorop         },
3228     { /*1, 03, WINED3DTSS_COLORARG2                 */      STATE_TEXTURESTAGE(1, WINED3DTSS_COLOROP),          tex_colorop         },
3229     { /*1, 04, WINED3DTSS_ALPHAOP                   */      STATE_TEXTURESTAGE(1, WINED3DTSS_ALPHAOP),          tex_alphaop         },
3230     { /*1, 05, WINED3DTSS_ALPHAARG1                 */      STATE_TEXTURESTAGE(1, WINED3DTSS_ALPHAOP),          tex_alphaop         },
3231     { /*1, 06, WINED3DTSS_ALPHAARG2                 */      STATE_TEXTURESTAGE(1, WINED3DTSS_ALPHAOP),          tex_alphaop         },
3232     { /*1, 07, WINED3DTSS_BUMPENVMAT00              */      STATE_TEXTURESTAGE(1, WINED3DTSS_COLOROP),          tex_colorop         },
3233     { /*1, 08, WINED3DTSS_BUMPENVMAT01              */      STATE_TEXTURESTAGE(1, WINED3DTSS_COLOROP),          tex_colorop         },
3234     { /*1, 09, WINED3DTSS_BUMPENVMAT10              */      STATE_TEXTURESTAGE(1, WINED3DTSS_COLOROP),          tex_colorop         },
3235     { /*1, 10, WINED3DTSS_BUMPENVMAT11              */      STATE_TEXTURESTAGE(1, WINED3DTSS_COLOROP),          tex_colorop         },
3236     { /*1, 11, WINED3DTSS_TEXCOORDINDEX             */      STATE_TEXTURESTAGE(1, WINED3DTSS_TEXCOORDINDEX),    tex_coordindex      },
3237     { /*1, 12, WINED3DTSS_ADDRESS                   */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
3238     { /*1, 13, WINED3DTSS_ADDRESSU                  */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
3239     { /*1, 14, WINED3DTSS_ADDRESSV                  */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
3240     { /*1, 15, WINED3DTSS_BORDERCOLOR               */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
3241     { /*1, 16, WINED3DTSS_MAGFILTER                 */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
3242     { /*1, 17, WINED3DTSS_MINFILTER                 */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
3243     { /*1, 18, WINED3DTSS_MIPFILTER                 */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
3244     { /*1, 19, WINED3DTSS_MIPMAPLODBIAS             */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
3245     { /*1, 20, WINED3DTSS_MAXMIPLEVEL               */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
3246     { /*1, 21, WINED3DTSS_MAXANISOTROPY             */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
3247     { /*1, 22, WINED3DTSS_BUMPENVLSCALE             */      STATE_TEXTURESTAGE(1, WINED3DTSS_BUMPENVLSCALE),    tex_bumpenvlscale   },
3248     { /*1, 23, WINED3DTSS_BUMPENVLOFFSET            */      STATE_TEXTURESTAGE(1, WINED3DTSS_BUMPENVLOFFSET),   tex_bumpenvloffset  },
3249     { /*1, 24, WINED3DTSS_TEXTURETRANSFORMFLAGS     */      STATE_TRANSFORM(WINED3DTS_TEXTURE1),                transform_texture   },
3250     { /*1, 25, WINED3DTSS_ADDRESSW                  */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
3251     { /*1, 26, WINED3DTSS_COLORARG0                 */      STATE_TEXTURESTAGE(1, WINED3DTSS_COLOROP),          tex_colorop         },
3252     { /*1, 27, WINED3DTSS_ALPHAARG0                 */      STATE_TEXTURESTAGE(1, WINED3DTSS_ALPHAOP),          tex_alphaop         },
3253     { /*1, 28, WINED3DTSS_RESULTARG                 */      STATE_TEXTURESTAGE(1, WINED3DTSS_RESULTARG),        tex_resultarg       },
3254     { /*1, 29, undefined                            */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
3255     { /*1, 30, undefined                            */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
3256     { /*1, 31, undefined                            */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
3257     { /*1, 32, WINED3DTSS_CONSTANT                  */      0 /* As long as we don't support D3DTA_CONSTANT */, state_nogl          },
3258
3259     { /*2, 01, WINED3DTSS_COLOROP                   */      STATE_TEXTURESTAGE(2, WINED3DTSS_COLOROP),          tex_colorop         },
3260     { /*2, 02, WINED3DTSS_COLORARG1                 */      STATE_TEXTURESTAGE(2, WINED3DTSS_COLOROP),          tex_colorop         },
3261     { /*2, 03, WINED3DTSS_COLORARG2                 */      STATE_TEXTURESTAGE(2, WINED3DTSS_COLOROP),          tex_colorop         },
3262     { /*2, 04, WINED3DTSS_ALPHAOP                   */      STATE_TEXTURESTAGE(2, WINED3DTSS_ALPHAOP),          tex_alphaop         },
3263     { /*2, 05, WINED3DTSS_ALPHAARG1                 */      STATE_TEXTURESTAGE(2, WINED3DTSS_ALPHAOP),          tex_alphaop         },
3264     { /*2, 06, WINED3DTSS_ALPHAARG2                 */      STATE_TEXTURESTAGE(2, WINED3DTSS_ALPHAOP),          tex_alphaop         },
3265     { /*2, 07, WINED3DTSS_BUMPENVMAT00              */      STATE_TEXTURESTAGE(2, WINED3DTSS_COLOROP),          tex_colorop         },
3266     { /*2, 08, WINED3DTSS_BUMPENVMAT01              */      STATE_TEXTURESTAGE(2, WINED3DTSS_COLOROP),          tex_colorop         },
3267     { /*2, 09, WINED3DTSS_BUMPENVMAT10              */      STATE_TEXTURESTAGE(2, WINED3DTSS_COLOROP),          tex_colorop         },
3268     { /*2, 10, WINED3DTSS_BUMPENVMAT11              */      STATE_TEXTURESTAGE(2, WINED3DTSS_COLOROP),          tex_colorop         },
3269     { /*2, 11, WINED3DTSS_TEXCOORDINDEX             */      STATE_TEXTURESTAGE(2, WINED3DTSS_TEXCOORDINDEX),    tex_coordindex      },
3270     { /*2, 12, WINED3DTSS_ADDRESS                   */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
3271     { /*2, 13, WINED3DTSS_ADDRESSU                  */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
3272     { /*2, 14, WINED3DTSS_ADDRESSV                  */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
3273     { /*2, 15, WINED3DTSS_BORDERCOLOR               */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
3274     { /*2, 16, WINED3DTSS_MAGFILTER                 */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
3275     { /*2, 17, WINED3DTSS_MINFILTER                 */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
3276     { /*2, 18, WINED3DTSS_MIPFILTER                 */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
3277     { /*2, 19, WINED3DTSS_MIPMAPLODBIAS             */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
3278     { /*2, 20, WINED3DTSS_MAXMIPLEVEL               */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
3279     { /*2, 21, WINED3DTSS_MAXANISOTROPY             */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
3280     { /*2, 22, WINED3DTSS_BUMPENVLSCALE             */      STATE_TEXTURESTAGE(2, WINED3DTSS_BUMPENVLSCALE),    tex_bumpenvlscale   },
3281     { /*2, 23, WINED3DTSS_BUMPENVLOFFSET            */      STATE_TEXTURESTAGE(2, WINED3DTSS_BUMPENVLOFFSET),   tex_bumpenvloffset  },
3282     { /*2, 24, WINED3DTSS_TEXTURETRANSFORMFLAGS     */      STATE_TRANSFORM(WINED3DTS_TEXTURE2),                transform_texture   },
3283     { /*2, 25, WINED3DTSS_ADDRESSW                  */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
3284     { /*2, 26, WINED3DTSS_COLORARG0                 */      STATE_TEXTURESTAGE(2, WINED3DTSS_COLOROP),          tex_colorop         },
3285     { /*2, 27, WINED3DTSS_ALPHAARG0                 */      STATE_TEXTURESTAGE(2, WINED3DTSS_ALPHAOP),          tex_alphaop         },
3286     { /*2, 28, WINED3DTSS_RESULTARG                 */      STATE_TEXTURESTAGE(2, WINED3DTSS_RESULTARG),        tex_resultarg       },
3287     { /*2, 29, undefined                            */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
3288     { /*2, 30, undefined                            */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
3289     { /*2, 31, undefined                            */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
3290     { /*2, 32, WINED3DTSS_CONSTANT                  */      0 /* As long as we don't support D3DTA_CONSTANT */, state_nogl          },
3291
3292     { /*3, 01, WINED3DTSS_COLOROP                   */      STATE_TEXTURESTAGE(3, WINED3DTSS_COLOROP),          tex_colorop         },
3293     { /*3, 02, WINED3DTSS_COLORARG1                 */      STATE_TEXTURESTAGE(3, WINED3DTSS_COLOROP),          tex_colorop         },
3294     { /*3, 03, WINED3DTSS_COLORARG2                 */      STATE_TEXTURESTAGE(3, WINED3DTSS_COLOROP),          tex_colorop         },
3295     { /*3, 04, WINED3DTSS_ALPHAOP                   */      STATE_TEXTURESTAGE(3, WINED3DTSS_ALPHAOP),          tex_alphaop         },
3296     { /*3, 05, WINED3DTSS_ALPHAARG1                 */      STATE_TEXTURESTAGE(3, WINED3DTSS_ALPHAOP),          tex_alphaop         },
3297     { /*3, 06, WINED3DTSS_ALPHAARG2                 */      STATE_TEXTURESTAGE(3, WINED3DTSS_ALPHAOP),          tex_alphaop         },
3298     { /*3, 07, WINED3DTSS_BUMPENVMAT00              */      STATE_TEXTURESTAGE(3, WINED3DTSS_COLOROP),          tex_colorop         },
3299     { /*3, 08, WINED3DTSS_BUMPENVMAT01              */      STATE_TEXTURESTAGE(3, WINED3DTSS_COLOROP),          tex_colorop         },
3300     { /*3, 09, WINED3DTSS_BUMPENVMAT10              */      STATE_TEXTURESTAGE(3, WINED3DTSS_COLOROP),          tex_colorop         },
3301     { /*3, 10, WINED3DTSS_BUMPENVMAT11              */      STATE_TEXTURESTAGE(3, WINED3DTSS_COLOROP),          tex_colorop         },
3302     { /*3, 11, WINED3DTSS_TEXCOORDINDEX             */      STATE_TEXTURESTAGE(3, WINED3DTSS_TEXCOORDINDEX),    tex_coordindex      },
3303     { /*3, 12, WINED3DTSS_ADDRESS                   */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
3304     { /*3, 13, WINED3DTSS_ADDRESSU                  */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
3305     { /*3, 14, WINED3DTSS_ADDRESSV                  */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
3306     { /*3, 15, WINED3DTSS_BORDERCOLOR               */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
3307     { /*3, 16, WINED3DTSS_MAGFILTER                 */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
3308     { /*3, 17, WINED3DTSS_MINFILTER                 */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
3309     { /*3, 18, WINED3DTSS_MIPFILTER                 */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
3310     { /*3, 19, WINED3DTSS_MIPMAPLODBIAS             */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
3311     { /*3, 20, WINED3DTSS_MAXMIPLEVEL               */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
3312     { /*3, 21, WINED3DTSS_MAXANISOTROPY             */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
3313     { /*3, 22, WINED3DTSS_BUMPENVLSCALE             */      STATE_TEXTURESTAGE(3, WINED3DTSS_BUMPENVLSCALE),    tex_bumpenvlscale   },
3314     { /*3, 23, WINED3DTSS_BUMPENVLOFFSET            */      STATE_TEXTURESTAGE(3, WINED3DTSS_BUMPENVLOFFSET),   tex_bumpenvloffset  },
3315     { /*3, 24, WINED3DTSS_TEXTURETRANSFORMFLAGS     */      STATE_TRANSFORM(WINED3DTS_TEXTURE3),                transform_texture   },
3316     { /*3, 25, WINED3DTSS_ADDRESSW                  */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
3317     { /*3, 26, WINED3DTSS_COLORARG0                 */      STATE_TEXTURESTAGE(3, WINED3DTSS_COLOROP),          tex_colorop         },
3318     { /*3, 27, WINED3DTSS_ALPHAARG0                 */      STATE_TEXTURESTAGE(3, WINED3DTSS_ALPHAOP),          tex_alphaop         },
3319     { /*3, 28, WINED3DTSS_RESULTARG                 */      STATE_TEXTURESTAGE(3, WINED3DTSS_RESULTARG),        tex_resultarg       },
3320     { /*3, 29, undefined                            */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
3321     { /*3, 30, undefined                            */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
3322     { /*3, 31, undefined                            */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
3323     { /*3, 32, WINED3DTSS_CONSTANT                  */      0 /* As long as we don't support D3DTA_CONSTANT */, state_nogl          },
3324
3325     { /*4, 01, WINED3DTSS_COLOROP                   */      STATE_TEXTURESTAGE(4, WINED3DTSS_COLOROP),          tex_colorop         },
3326     { /*4, 02, WINED3DTSS_COLORARG1                 */      STATE_TEXTURESTAGE(4, WINED3DTSS_COLOROP),          tex_colorop         },
3327     { /*4, 03, WINED3DTSS_COLORARG2                 */      STATE_TEXTURESTAGE(4, WINED3DTSS_COLOROP),          tex_colorop         },
3328     { /*4, 04, WINED3DTSS_ALPHAOP                   */      STATE_TEXTURESTAGE(4, WINED3DTSS_ALPHAOP),          tex_alphaop         },
3329     { /*4, 05, WINED3DTSS_ALPHAARG1                 */      STATE_TEXTURESTAGE(4, WINED3DTSS_ALPHAOP),          tex_alphaop         },
3330     { /*4, 06, WINED3DTSS_ALPHAARG2                 */      STATE_TEXTURESTAGE(4, WINED3DTSS_ALPHAOP),          tex_alphaop         },
3331     { /*4, 07, WINED3DTSS_BUMPENVMAT00              */      STATE_TEXTURESTAGE(4, WINED3DTSS_COLOROP),          state_undefined     },
3332     { /*4, 08, WINED3DTSS_BUMPENVMAT01              */      STATE_TEXTURESTAGE(4, WINED3DTSS_COLOROP),          state_undefined     },
3333     { /*4, 09, WINED3DTSS_BUMPENVMAT10              */      STATE_TEXTURESTAGE(4, WINED3DTSS_COLOROP),          state_undefined     },
3334     { /*4, 10, WINED3DTSS_BUMPENVMAT11              */      STATE_TEXTURESTAGE(4, WINED3DTSS_COLOROP),          state_undefined     },
3335     { /*4, 11, WINED3DTSS_TEXCOORDINDEX             */      STATE_TEXTURESTAGE(4, WINED3DTSS_TEXCOORDINDEX),    tex_coordindex      },
3336     { /*4, 12, WINED3DTSS_ADDRESS                   */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
3337     { /*4, 13, WINED3DTSS_ADDRESSU                  */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
3338     { /*4, 14, WINED3DTSS_ADDRESSV                  */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
3339     { /*4, 15, WINED3DTSS_BORDERCOLOR               */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
3340     { /*4, 16, WINED3DTSS_MAGFILTER                 */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
3341     { /*4, 17, WINED3DTSS_MINFILTER                 */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
3342     { /*4, 18, WINED3DTSS_MIPFILTER                 */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
3343     { /*4, 19, WINED3DTSS_MIPMAPLODBIAS             */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
3344     { /*4, 20, WINED3DTSS_MAXMIPLEVEL               */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
3345     { /*4, 21, WINED3DTSS_MAXANISOTROPY             */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
3346     { /*4, 22, WINED3DTSS_BUMPENVLSCALE             */      STATE_TEXTURESTAGE(4, WINED3DTSS_BUMPENVLSCALE),    tex_bumpenvlscale   },
3347     { /*4, 23, WINED3DTSS_BUMPENVLOFFSET            */      STATE_TEXTURESTAGE(4, WINED3DTSS_BUMPENVLOFFSET),   tex_bumpenvloffset  },
3348     { /*4, 24, WINED3DTSS_TEXTURETRANSFORMFLAGS     */      STATE_TRANSFORM(WINED3DTS_TEXTURE4),                transform_texture   },
3349     { /*4, 25, WINED3DTSS_ADDRESSW                  */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
3350     { /*4, 26, WINED3DTSS_COLORARG0                 */      STATE_TEXTURESTAGE(4, WINED3DTSS_COLOROP),          tex_colorop         },
3351     { /*4, 27, WINED3DTSS_ALPHAARG0                 */      STATE_TEXTURESTAGE(4, WINED3DTSS_ALPHAOP),          tex_alphaop         },
3352     { /*4, 28, WINED3DTSS_RESULTARG                 */      STATE_TEXTURESTAGE(4, WINED3DTSS_RESULTARG),        tex_resultarg       },
3353     { /*4, 29, undefined                            */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
3354     { /*4, 30, undefined                            */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
3355     { /*4, 31, undefined                            */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
3356     { /*4, 32, WINED3DTSS_CONSTANT                  */      0 /* As long as we don't support D3DTA_CONSTANT */, state_nogl          },
3357
3358     { /*5, 01, WINED3DTSS_COLOROP                   */      STATE_TEXTURESTAGE(5, WINED3DTSS_COLOROP),          tex_colorop         },
3359     { /*5, 02, WINED3DTSS_COLORARG1                 */      STATE_TEXTURESTAGE(5, WINED3DTSS_COLOROP),          tex_colorop         },
3360     { /*5, 03, WINED3DTSS_COLORARG2                 */      STATE_TEXTURESTAGE(5, WINED3DTSS_COLOROP),          tex_colorop         },
3361     { /*5, 04, WINED3DTSS_ALPHAOP                   */      STATE_TEXTURESTAGE(5, WINED3DTSS_ALPHAOP),          tex_alphaop         },
3362     { /*5, 05, WINED3DTSS_ALPHAARG1                 */      STATE_TEXTURESTAGE(5, WINED3DTSS_ALPHAOP),          tex_alphaop         },
3363     { /*5, 06, WINED3DTSS_ALPHAARG2                 */      STATE_TEXTURESTAGE(5, WINED3DTSS_ALPHAOP),          tex_alphaop         },
3364     { /*5, 07, WINED3DTSS_BUMPENVMAT00              */      STATE_TEXTURESTAGE(5, WINED3DTSS_COLOROP),          tex_colorop         },
3365     { /*5, 08, WINED3DTSS_BUMPENVMAT01              */      STATE_TEXTURESTAGE(5, WINED3DTSS_COLOROP),          tex_colorop         },
3366     { /*5, 09, WINED3DTSS_BUMPENVMAT10              */      STATE_TEXTURESTAGE(5, WINED3DTSS_COLOROP),          tex_colorop         },
3367     { /*5, 10, WINED3DTSS_BUMPENVMAT11              */      STATE_TEXTURESTAGE(5, WINED3DTSS_COLOROP),          tex_colorop         },
3368     { /*5, 11, WINED3DTSS_TEXCOORDINDEX             */      STATE_TEXTURESTAGE(5, WINED3DTSS_TEXCOORDINDEX),    tex_coordindex      },
3369     { /*5, 12, WINED3DTSS_ADDRESS                   */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
3370     { /*5, 13, WINED3DTSS_ADDRESSU                  */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
3371     { /*5, 14, WINED3DTSS_ADDRESSV                  */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
3372     { /*5, 15, WINED3DTSS_BORDERCOLOR               */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
3373     { /*5, 16, WINED3DTSS_MAGFILTER                 */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
3374     { /*5, 17, WINED3DTSS_MINFILTER                 */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
3375     { /*5, 18, WINED3DTSS_MIPFILTER                 */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
3376     { /*5, 19, WINED3DTSS_MIPMAPLODBIAS             */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
3377     { /*5, 20, WINED3DTSS_MAXMIPLEVEL               */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
3378     { /*5, 21, WINED3DTSS_MAXANISOTROPY             */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
3379     { /*5, 22, WINED3DTSS_BUMPENVLSCALE             */      STATE_TEXTURESTAGE(5, WINED3DTSS_BUMPENVLSCALE),    tex_bumpenvlscale   },
3380     { /*5, 23, WINED3DTSS_BUMPENVLOFFSET            */      STATE_TEXTURESTAGE(5, WINED3DTSS_BUMPENVLOFFSET),   tex_bumpenvloffset  },
3381     { /*5, 24, WINED3DTSS_TEXTURETRANSFORMFLAGS     */      STATE_TRANSFORM(WINED3DTS_TEXTURE5),                transform_texture   },
3382     { /*5, 25, WINED3DTSS_ADDRESSW                  */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
3383     { /*5, 26, WINED3DTSS_COLORARG0                 */      STATE_TEXTURESTAGE(5, WINED3DTSS_COLOROP),          tex_colorop         },
3384     { /*5, 27, WINED3DTSS_ALPHAARG0                 */      STATE_TEXTURESTAGE(5, WINED3DTSS_ALPHAOP),          tex_alphaop         },
3385     { /*5, 28, WINED3DTSS_RESULTARG                 */      STATE_TEXTURESTAGE(5, WINED3DTSS_RESULTARG),        tex_resultarg       },
3386     { /*5, 29, undefined                            */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
3387     { /*5, 30, undefined                            */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
3388     { /*5, 31, undefined                            */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
3389     { /*5, 32, WINED3DTSS_CONSTANT                  */      0 /* As long as we don't support D3DTA_CONSTANT */, state_nogl          },
3390
3391     { /*6, 01, WINED3DTSS_COLOROP                   */      STATE_TEXTURESTAGE(6, WINED3DTSS_COLOROP),          tex_colorop         },
3392     { /*6, 02, WINED3DTSS_COLORARG1                 */      STATE_TEXTURESTAGE(6, WINED3DTSS_COLOROP),          tex_colorop         },
3393     { /*6, 03, WINED3DTSS_COLORARG2                 */      STATE_TEXTURESTAGE(6, WINED3DTSS_COLOROP),          tex_colorop         },
3394     { /*6, 04, WINED3DTSS_ALPHAOP                   */      STATE_TEXTURESTAGE(6, WINED3DTSS_ALPHAOP),          tex_alphaop         },
3395     { /*6, 05, WINED3DTSS_ALPHAARG1                 */      STATE_TEXTURESTAGE(6, WINED3DTSS_ALPHAOP),          tex_alphaop         },
3396     { /*6, 06, WINED3DTSS_ALPHAARG2                 */      STATE_TEXTURESTAGE(6, WINED3DTSS_ALPHAOP),          tex_alphaop         },
3397     { /*6, 07, WINED3DTSS_BUMPENVMAT00              */      STATE_TEXTURESTAGE(6, WINED3DTSS_COLOROP),          tex_colorop         },
3398     { /*6, 08, WINED3DTSS_BUMPENVMAT01              */      STATE_TEXTURESTAGE(6, WINED3DTSS_COLOROP),          tex_colorop         },
3399     { /*6, 09, WINED3DTSS_BUMPENVMAT10              */      STATE_TEXTURESTAGE(6, WINED3DTSS_COLOROP),          tex_colorop         },
3400     { /*6, 10, WINED3DTSS_BUMPENVMAT11              */      STATE_TEXTURESTAGE(6, WINED3DTSS_COLOROP),          tex_colorop         },
3401     { /*6, 11, WINED3DTSS_TEXCOORDINDEX             */      STATE_TEXTURESTAGE(6, WINED3DTSS_TEXCOORDINDEX),    tex_coordindex      },
3402     { /*6, 12, WINED3DTSS_ADDRESS                   */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
3403     { /*6, 13, WINED3DTSS_ADDRESSU                  */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
3404     { /*6, 14, WINED3DTSS_ADDRESSV                  */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
3405     { /*6, 15, WINED3DTSS_BORDERCOLOR               */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
3406     { /*6, 16, WINED3DTSS_MAGFILTER                 */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
3407     { /*6, 17, WINED3DTSS_MINFILTER                 */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
3408     { /*6, 18, WINED3DTSS_MIPFILTER                 */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
3409     { /*6, 19, WINED3DTSS_MIPMAPLODBIAS             */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
3410     { /*6, 20, WINED3DTSS_MAXMIPLEVEL               */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
3411     { /*6, 21, WINED3DTSS_MAXANISOTROPY             */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
3412     { /*6, 22, WINED3DTSS_BUMPENVLSCALE             */      STATE_TEXTURESTAGE(6, WINED3DTSS_BUMPENVLSCALE),    tex_bumpenvlscale   },
3413     { /*6, 23, WINED3DTSS_BUMPENVLOFFSET            */      STATE_TEXTURESTAGE(6, WINED3DTSS_BUMPENVLOFFSET),   tex_bumpenvloffset  },
3414     { /*6, 24, WINED3DTSS_TEXTURETRANSFORMFLAGS     */      STATE_TRANSFORM(WINED3DTS_TEXTURE6),                transform_texture   },
3415     { /*6, 25, WINED3DTSS_ADDRESSW                  */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
3416     { /*6, 26, WINED3DTSS_COLORARG0                 */      STATE_TEXTURESTAGE(6, WINED3DTSS_COLOROP),          tex_colorop         },
3417     { /*6, 27, WINED3DTSS_ALPHAARG0                 */      STATE_TEXTURESTAGE(6, WINED3DTSS_ALPHAOP),          tex_alphaop         },
3418     { /*6, 28, WINED3DTSS_RESULTARG                 */      STATE_TEXTURESTAGE(6, WINED3DTSS_RESULTARG),        tex_resultarg       },
3419     { /*6, 29, undefined                            */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
3420     { /*6, 30, undefined                            */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
3421     { /*6, 31, undefined                            */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
3422     { /*6, 32, WINED3DTSS_CONSTANT                  */      0 /* As long as we don't support D3DTA_CONSTANT */, state_nogl          },
3423
3424     { /*7, 01, WINED3DTSS_COLOROP                   */      STATE_TEXTURESTAGE(7, WINED3DTSS_COLOROP),          tex_colorop         },
3425     { /*7, 02, WINED3DTSS_COLORARG1                 */      STATE_TEXTURESTAGE(7, WINED3DTSS_COLOROP),          tex_colorop         },
3426     { /*7, 03, WINED3DTSS_COLORARG2                 */      STATE_TEXTURESTAGE(7, WINED3DTSS_COLOROP),          tex_colorop         },
3427     { /*7, 04, WINED3DTSS_ALPHAOP                   */      STATE_TEXTURESTAGE(7, WINED3DTSS_ALPHAOP),          tex_alphaop         },
3428     { /*7, 05, WINED3DTSS_ALPHAARG1                 */      STATE_TEXTURESTAGE(7, WINED3DTSS_ALPHAOP),          tex_alphaop         },
3429     { /*7, 06, WINED3DTSS_ALPHAARG2                 */      STATE_TEXTURESTAGE(7, WINED3DTSS_ALPHAOP),          tex_alphaop         },
3430     { /*7, 07, WINED3DTSS_BUMPENVMAT00              */      STATE_TEXTURESTAGE(7, WINED3DTSS_COLOROP),          tex_colorop         },
3431     { /*7, 08, WINED3DTSS_BUMPENVMAT01              */      STATE_TEXTURESTAGE(7, WINED3DTSS_COLOROP),          tex_colorop         },
3432     { /*7, 09, WINED3DTSS_BUMPENVMAT10              */      STATE_TEXTURESTAGE(7, WINED3DTSS_COLOROP),          tex_colorop         },
3433     { /*7, 10, WINED3DTSS_BUMPENVMAT11              */      STATE_TEXTURESTAGE(7, WINED3DTSS_COLOROP),          tex_colorop         },
3434     { /*7, 11, WINED3DTSS_TEXCOORDINDEX             */      STATE_TEXTURESTAGE(7, WINED3DTSS_TEXCOORDINDEX),    tex_coordindex      },
3435     { /*7, 12, WINED3DTSS_ADDRESS                   */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
3436     { /*7, 13, WINED3DTSS_ADDRESSU                  */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
3437     { /*7, 14, WINED3DTSS_ADDRESSV                  */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
3438     { /*7, 15, WINED3DTSS_BORDERCOLOR               */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
3439     { /*7, 16, WINED3DTSS_MAGFILTER                 */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
3440     { /*7, 17, WINED3DTSS_MINFILTER                 */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
3441     { /*7, 18, WINED3DTSS_MIPFILTER                 */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
3442     { /*7, 19, WINED3DTSS_MIPMAPLODBIAS             */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
3443     { /*7, 20, WINED3DTSS_MAXMIPLEVEL               */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
3444     { /*7, 21, WINED3DTSS_MAXANISOTROPY             */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
3445     { /*7, 22, WINED3DTSS_BUMPENVLSCALE             */      STATE_TEXTURESTAGE(7, WINED3DTSS_BUMPENVLSCALE),    tex_bumpenvlscale   },
3446     { /*7, 23, WINED3DTSS_BUMPENVLOFFSET            */      STATE_TEXTURESTAGE(7, WINED3DTSS_BUMPENVLOFFSET),   tex_bumpenvloffset  },
3447     { /*7, 24, WINED3DTSS_TEXTURETRANSFORMFLAGS     */      STATE_TRANSFORM(WINED3DTS_TEXTURE7),                transform_texture   },
3448     { /*7, 25, WINED3DTSS_ADDRESSW                  */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
3449     { /*7, 26, WINED3DTSS_COLORARG0                 */      STATE_TEXTURESTAGE(7, WINED3DTSS_COLOROP),          tex_colorop         },
3450     { /*7, 27, WINED3DTSS_ALPHAARG0                 */      STATE_TEXTURESTAGE(7, WINED3DTSS_ALPHAOP),          tex_alphaop         },
3451     { /*7, 28, WINED3DTSS_RESULTARG                 */      STATE_TEXTURESTAGE(7, WINED3DTSS_RESULTARG),        tex_resultarg       },
3452     { /*7, 29, undefined                            */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
3453     { /*7, 30, undefined                            */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
3454     { /*7, 31, undefined                            */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
3455     { /*7, 32, WINED3DTSS_CONSTANT                  */      0 /* As long as we don't support D3DTA_CONSTANT */, state_nogl          },
3456     /* Sampler states */
3457     { /* 0, Sampler 0                               */      STATE_SAMPLER(0),                                   sampler             },
3458     { /* 1, Sampler 1                               */      STATE_SAMPLER(1),                                   sampler             },
3459     { /* 2, Sampler 2                               */      STATE_SAMPLER(2),                                   sampler             },
3460     { /* 3, Sampler 3                               */      STATE_SAMPLER(3),                                   sampler             },
3461     { /* 4, Sampler 3                               */      STATE_SAMPLER(4),                                   sampler             },
3462     { /* 5, Sampler 5                               */      STATE_SAMPLER(5),                                   sampler             },
3463     { /* 6, Sampler 6                               */      STATE_SAMPLER(6),                                   sampler             },
3464     { /* 7, Sampler 7                               */      STATE_SAMPLER(7),                                   sampler             },
3465     { /* 8, Sampler 8                               */      STATE_SAMPLER(8),                                   sampler             },
3466     { /* 9, Sampler 9                               */      STATE_SAMPLER(9),                                   sampler             },
3467     { /*10, Sampler 10                              */      STATE_SAMPLER(10),                                  sampler             },
3468     { /*11, Sampler 11                              */      STATE_SAMPLER(11),                                  sampler             },
3469     { /*12, Sampler 12                              */      STATE_SAMPLER(12),                                  sampler             },
3470     { /*13, Sampler 13                              */      STATE_SAMPLER(13),                                  sampler             },
3471     { /*14, Sampler 14                              */      STATE_SAMPLER(14),                                  sampler             },
3472     { /*15, Sampler 15                              */      STATE_SAMPLER(15),                                  sampler             },
3473     /* Pixel shader */
3474     { /*  , Pixel Shader                            */      STATE_PIXELSHADER,                                  pixelshader         },
3475       /* Transform states follow                    */
3476     { /*  1, undefined                              */      0,                                                  state_undefined     },
3477     { /*  2, WINED3DTS_VIEW                         */      STATE_TRANSFORM(WINED3DTS_VIEW),                    transform_view      },
3478     { /*  3, WINED3DTS_PROJECTION                   */      STATE_TRANSFORM(WINED3DTS_PROJECTION),              transform_projection},
3479     { /*  4, undefined                              */      0,                                                  state_undefined     },
3480     { /*  5, undefined                              */      0,                                                  state_undefined     },
3481     { /*  6, undefined                              */      0,                                                  state_undefined     },
3482     { /*  7, undefined                              */      0,                                                  state_undefined     },
3483     { /*  8, undefined                              */      0,                                                  state_undefined     },
3484     { /*  9, undefined                              */      0,                                                  state_undefined     },
3485     { /* 10, undefined                              */      0,                                                  state_undefined     },
3486     { /* 11, undefined                              */      0,                                                  state_undefined     },
3487     { /* 12, undefined                              */      0,                                                  state_undefined     },
3488     { /* 13, undefined                              */      0,                                                  state_undefined     },
3489     { /* 14, undefined                              */      0,                                                  state_undefined     },
3490     { /* 15, undefined                              */      0,                                                  state_undefined     },
3491     { /* 16, WINED3DTS_TEXTURE0                     */      STATE_TRANSFORM(WINED3DTS_TEXTURE0),                transform_texture   },
3492     { /* 17, WINED3DTS_TEXTURE1                     */      STATE_TRANSFORM(WINED3DTS_TEXTURE1),                transform_texture   },
3493     { /* 18, WINED3DTS_TEXTURE2                     */      STATE_TRANSFORM(WINED3DTS_TEXTURE2),                transform_texture   },
3494     { /* 19, WINED3DTS_TEXTURE3                     */      STATE_TRANSFORM(WINED3DTS_TEXTURE3),                transform_texture   },
3495     { /* 20, WINED3DTS_TEXTURE4                     */      STATE_TRANSFORM(WINED3DTS_TEXTURE4),                transform_texture   },
3496     { /* 21, WINED3DTS_TEXTURE5                     */      STATE_TRANSFORM(WINED3DTS_TEXTURE5),                transform_texture   },
3497     { /* 22, WINED3DTS_TEXTURE6                     */      STATE_TRANSFORM(WINED3DTS_TEXTURE6),                transform_texture   },
3498     { /* 23, WINED3DTS_TEXTURE7                     */      STATE_TRANSFORM(WINED3DTS_TEXTURE7),                transform_texture   },
3499       /* A huge gap between TEXTURE7 and WORLDMATRIX(0) :-( But entries are needed to catch then if a broken app sets them */
3500     { /* 24, undefined                              */      0,                                                  state_undefined     },
3501     { /* 25, undefined                              */      0,                                                  state_undefined     },
3502     { /* 26, undefined                              */      0,                                                  state_undefined     },
3503     { /* 27, undefined                              */      0,                                                  state_undefined     },
3504     { /* 28, undefined                              */      0,                                                  state_undefined     },
3505     { /* 29, undefined                              */      0,                                                  state_undefined     },
3506     { /* 30, undefined                              */      0,                                                  state_undefined     },
3507     { /* 31, undefined                              */      0,                                                  state_undefined     },
3508     { /* 32, undefined                              */      0,                                                  state_undefined     },
3509     { /* 33, undefined                              */      0,                                                  state_undefined     },
3510     { /* 34, undefined                              */      0,                                                  state_undefined     },
3511     { /* 35, undefined                              */      0,                                                  state_undefined     },
3512     { /* 36, undefined                              */      0,                                                  state_undefined     },
3513     { /* 37, undefined                              */      0,                                                  state_undefined     },
3514     { /* 38, undefined                              */      0,                                                  state_undefined     },
3515     { /* 39, undefined                              */      0,                                                  state_undefined     },
3516     { /* 40, undefined                              */      0,                                                  state_undefined     },
3517     { /* 41, undefined                              */      0,                                                  state_undefined     },
3518     { /* 42, undefined                              */      0,                                                  state_undefined     },
3519     { /* 43, undefined                              */      0,                                                  state_undefined     },
3520     { /* 44, undefined                              */      0,                                                  state_undefined     },
3521     { /* 45, undefined                              */      0,                                                  state_undefined     },
3522     { /* 46, undefined                              */      0,                                                  state_undefined     },
3523     { /* 47, undefined                              */      0,                                                  state_undefined     },
3524     { /* 48, undefined                              */      0,                                                  state_undefined     },
3525     { /* 49, undefined                              */      0,                                                  state_undefined     },
3526     { /* 50, undefined                              */      0,                                                  state_undefined     },
3527     { /* 51, undefined                              */      0,                                                  state_undefined     },
3528     { /* 52, undefined                              */      0,                                                  state_undefined     },
3529     { /* 53, undefined                              */      0,                                                  state_undefined     },
3530     { /* 54, undefined                              */      0,                                                  state_undefined     },
3531     { /* 55, undefined                              */      0,                                                  state_undefined     },
3532     { /* 56, undefined                              */      0,                                                  state_undefined     },
3533     { /* 57, undefined                              */      0,                                                  state_undefined     },
3534     { /* 58, undefined                              */      0,                                                  state_undefined     },
3535     { /* 59, undefined                              */      0,                                                  state_undefined     },
3536     { /* 60, undefined                              */      0,                                                  state_undefined     },
3537     { /* 61, undefined                              */      0,                                                  state_undefined     },
3538     { /* 62, undefined                              */      0,                                                  state_undefined     },
3539     { /* 63, undefined                              */      0,                                                  state_undefined     },
3540     { /* 64, undefined                              */      0,                                                  state_undefined     },
3541     { /* 65, undefined                              */      0,                                                  state_undefined     },
3542     { /* 66, undefined                              */      0,                                                  state_undefined     },
3543     { /* 67, undefined                              */      0,                                                  state_undefined     },
3544     { /* 68, undefined                              */      0,                                                  state_undefined     },
3545     { /* 69, undefined                              */      0,                                                  state_undefined     },
3546     { /* 70, undefined                              */      0,                                                  state_undefined     },
3547     { /* 71, undefined                              */      0,                                                  state_undefined     },
3548     { /* 72, undefined                              */      0,                                                  state_undefined     },
3549     { /* 73, undefined                              */      0,                                                  state_undefined     },
3550     { /* 74, undefined                              */      0,                                                  state_undefined     },
3551     { /* 75, undefined                              */      0,                                                  state_undefined     },
3552     { /* 76, undefined                              */      0,                                                  state_undefined     },
3553     { /* 77, undefined                              */      0,                                                  state_undefined     },
3554     { /* 78, undefined                              */      0,                                                  state_undefined     },
3555     { /* 79, undefined                              */      0,                                                  state_undefined     },
3556     { /* 80, undefined                              */      0,                                                  state_undefined     },
3557     { /* 81, undefined                              */      0,                                                  state_undefined     },
3558     { /* 82, undefined                              */      0,                                                  state_undefined     },
3559     { /* 83, undefined                              */      0,                                                  state_undefined     },
3560     { /* 84, undefined                              */      0,                                                  state_undefined     },
3561     { /* 85, undefined                              */      0,                                                  state_undefined     },
3562     { /* 86, undefined                              */      0,                                                  state_undefined     },
3563     { /* 87, undefined                              */      0,                                                  state_undefined     },
3564     { /* 88, undefined                              */      0,                                                  state_undefined     },
3565     { /* 89, undefined                              */      0,                                                  state_undefined     },
3566     { /* 90, undefined                              */      0,                                                  state_undefined     },
3567     { /* 91, undefined                              */      0,                                                  state_undefined     },
3568     { /* 92, undefined                              */      0,                                                  state_undefined     },
3569     { /* 93, undefined                              */      0,                                                  state_undefined     },
3570     { /* 94, undefined                              */      0,                                                  state_undefined     },
3571     { /* 95, undefined                              */      0,                                                  state_undefined     },
3572     { /* 96, undefined                              */      0,                                                  state_undefined     },
3573     { /* 97, undefined                              */      0,                                                  state_undefined     },
3574     { /* 98, undefined                              */      0,                                                  state_undefined     },
3575     { /* 99, undefined                              */      0,                                                  state_undefined     },
3576     { /*100, undefined                              */      0,                                                  state_undefined     },
3577     { /*101, undefined                              */      0,                                                  state_undefined     },
3578     { /*102, undefined                              */      0,                                                  state_undefined     },
3579     { /*103, undefined                              */      0,                                                  state_undefined     },
3580     { /*104, undefined                              */      0,                                                  state_undefined     },
3581     { /*105, undefined                              */      0,                                                  state_undefined     },
3582     { /*106, undefined                              */      0,                                                  state_undefined     },
3583     { /*107, undefined                              */      0,                                                  state_undefined     },
3584     { /*108, undefined                              */      0,                                                  state_undefined     },
3585     { /*109, undefined                              */      0,                                                  state_undefined     },
3586     { /*110, undefined                              */      0,                                                  state_undefined     },
3587     { /*111, undefined                              */      0,                                                  state_undefined     },
3588     { /*112, undefined                              */      0,                                                  state_undefined     },
3589     { /*113, undefined                              */      0,                                                  state_undefined     },
3590     { /*114, undefined                              */      0,                                                  state_undefined     },
3591     { /*115, undefined                              */      0,                                                  state_undefined     },
3592     { /*116, undefined                              */      0,                                                  state_undefined     },
3593     { /*117, undefined                              */      0,                                                  state_undefined     },
3594     { /*118, undefined                              */      0,                                                  state_undefined     },
3595     { /*119, undefined                              */      0,                                                  state_undefined     },
3596     { /*120, undefined                              */      0,                                                  state_undefined     },
3597     { /*121, undefined                              */      0,                                                  state_undefined     },
3598     { /*122, undefined                              */      0,                                                  state_undefined     },
3599     { /*123, undefined                              */      0,                                                  state_undefined     },
3600     { /*124, undefined                              */      0,                                                  state_undefined     },
3601     { /*125, undefined                              */      0,                                                  state_undefined     },
3602     { /*126, undefined                              */      0,                                                  state_undefined     },
3603     { /*127, undefined                              */      0,                                                  state_undefined     },
3604     { /*128, undefined                              */      0,                                                  state_undefined     },
3605     { /*129, undefined                              */      0,                                                  state_undefined     },
3606     { /*130, undefined                              */      0,                                                  state_undefined     },
3607     { /*131, undefined                              */      0,                                                  state_undefined     },
3608     { /*132, undefined                              */      0,                                                  state_undefined     },
3609     { /*133, undefined                              */      0,                                                  state_undefined     },
3610     { /*134, undefined                              */      0,                                                  state_undefined     },
3611     { /*135, undefined                              */      0,                                                  state_undefined     },
3612     { /*136, undefined                              */      0,                                                  state_undefined     },
3613     { /*137, undefined                              */      0,                                                  state_undefined     },
3614     { /*138, undefined                              */      0,                                                  state_undefined     },
3615     { /*139, undefined                              */      0,                                                  state_undefined     },
3616     { /*140, undefined                              */      0,                                                  state_undefined     },
3617     { /*141, undefined                              */      0,                                                  state_undefined     },
3618     { /*142, undefined                              */      0,                                                  state_undefined     },
3619     { /*143, undefined                              */      0,                                                  state_undefined     },
3620     { /*144, undefined                              */      0,                                                  state_undefined     },
3621     { /*145, undefined                              */      0,                                                  state_undefined     },
3622     { /*146, undefined                              */      0,                                                  state_undefined     },
3623     { /*147, undefined                              */      0,                                                  state_undefined     },
3624     { /*148, undefined                              */      0,                                                  state_undefined     },
3625     { /*149, undefined                              */      0,                                                  state_undefined     },
3626     { /*150, undefined                              */      0,                                                  state_undefined     },
3627     { /*151, undefined                              */      0,                                                  state_undefined     },
3628     { /*152, undefined                              */      0,                                                  state_undefined     },
3629     { /*153, undefined                              */      0,                                                  state_undefined     },
3630     { /*154, undefined                              */      0,                                                  state_undefined     },
3631     { /*155, undefined                              */      0,                                                  state_undefined     },
3632     { /*156, undefined                              */      0,                                                  state_undefined     },
3633     { /*157, undefined                              */      0,                                                  state_undefined     },
3634     { /*158, undefined                              */      0,                                                  state_undefined     },
3635     { /*159, undefined                              */      0,                                                  state_undefined     },
3636     { /*160, undefined                              */      0,                                                  state_undefined     },
3637     { /*161, undefined                              */      0,                                                  state_undefined     },
3638     { /*162, undefined                              */      0,                                                  state_undefined     },
3639     { /*163, undefined                              */      0,                                                  state_undefined     },
3640     { /*164, undefined                              */      0,                                                  state_undefined     },
3641     { /*165, undefined                              */      0,                                                  state_undefined     },
3642     { /*166, undefined                              */      0,                                                  state_undefined     },
3643     { /*167, undefined                              */      0,                                                  state_undefined     },
3644     { /*168, undefined                              */      0,                                                  state_undefined     },
3645     { /*169, undefined                              */      0,                                                  state_undefined     },
3646     { /*170, undefined                              */      0,                                                  state_undefined     },
3647     { /*171, undefined                              */      0,                                                  state_undefined     },
3648     { /*172, undefined                              */      0,                                                  state_undefined     },
3649     { /*173, undefined                              */      0,                                                  state_undefined     },
3650     { /*174, undefined                              */      0,                                                  state_undefined     },
3651     { /*175, undefined                              */      0,                                                  state_undefined     },
3652     { /*176, undefined                              */      0,                                                  state_undefined     },
3653     { /*177, undefined                              */      0,                                                  state_undefined     },
3654     { /*178, undefined                              */      0,                                                  state_undefined     },
3655     { /*179, undefined                              */      0,                                                  state_undefined     },
3656     { /*180, undefined                              */      0,                                                  state_undefined     },
3657     { /*181, undefined                              */      0,                                                  state_undefined     },
3658     { /*182, undefined                              */      0,                                                  state_undefined     },
3659     { /*183, undefined                              */      0,                                                  state_undefined     },
3660     { /*184, undefined                              */      0,                                                  state_undefined     },
3661     { /*185, undefined                              */      0,                                                  state_undefined     },
3662     { /*186, undefined                              */      0,                                                  state_undefined     },
3663     { /*187, undefined                              */      0,                                                  state_undefined     },
3664     { /*188, undefined                              */      0,                                                  state_undefined     },
3665     { /*189, undefined                              */      0,                                                  state_undefined     },
3666     { /*190, undefined                              */      0,                                                  state_undefined     },
3667     { /*191, undefined                              */      0,                                                  state_undefined     },
3668     { /*192, undefined                              */      0,                                                  state_undefined     },
3669     { /*193, undefined                              */      0,                                                  state_undefined     },
3670     { /*194, undefined                              */      0,                                                  state_undefined     },
3671     { /*195, undefined                              */      0,                                                  state_undefined     },
3672     { /*196, undefined                              */      0,                                                  state_undefined     },
3673     { /*197, undefined                              */      0,                                                  state_undefined     },
3674     { /*198, undefined                              */      0,                                                  state_undefined     },
3675     { /*199, undefined                              */      0,                                                  state_undefined     },
3676     { /*200, undefined                              */      0,                                                  state_undefined     },
3677     { /*201, undefined                              */      0,                                                  state_undefined     },
3678     { /*202, undefined                              */      0,                                                  state_undefined     },
3679     { /*203, undefined                              */      0,                                                  state_undefined     },
3680     { /*204, undefined                              */      0,                                                  state_undefined     },
3681     { /*205, undefined                              */      0,                                                  state_undefined     },
3682     { /*206, undefined                              */      0,                                                  state_undefined     },
3683     { /*207, undefined                              */      0,                                                  state_undefined     },
3684     { /*208, undefined                              */      0,                                                  state_undefined     },
3685     { /*209, undefined                              */      0,                                                  state_undefined     },
3686     { /*210, undefined                              */      0,                                                  state_undefined     },
3687     { /*211, undefined                              */      0,                                                  state_undefined     },
3688     { /*212, undefined                              */      0,                                                  state_undefined     },
3689     { /*213, undefined                              */      0,                                                  state_undefined     },
3690     { /*214, undefined                              */      0,                                                  state_undefined     },
3691     { /*215, undefined                              */      0,                                                  state_undefined     },
3692     { /*216, undefined                              */      0,                                                  state_undefined     },
3693     { /*217, undefined                              */      0,                                                  state_undefined     },
3694     { /*218, undefined                              */      0,                                                  state_undefined     },
3695     { /*219, undefined                              */      0,                                                  state_undefined     },
3696     { /*220, undefined                              */      0,                                                  state_undefined     },
3697     { /*221, undefined                              */      0,                                                  state_undefined     },
3698     { /*222, undefined                              */      0,                                                  state_undefined     },
3699     { /*223, undefined                              */      0,                                                  state_undefined     },
3700     { /*224, undefined                              */      0,                                                  state_undefined     },
3701     { /*225, undefined                              */      0,                                                  state_undefined     },
3702     { /*226, undefined                              */      0,                                                  state_undefined     },
3703     { /*227, undefined                              */      0,                                                  state_undefined     },
3704     { /*228, undefined                              */      0,                                                  state_undefined     },
3705     { /*229, undefined                              */      0,                                                  state_undefined     },
3706     { /*230, undefined                              */      0,                                                  state_undefined     },
3707     { /*231, undefined                              */      0,                                                  state_undefined     },
3708     { /*232, undefined                              */      0,                                                  state_undefined     },
3709     { /*233, undefined                              */      0,                                                  state_undefined     },
3710     { /*234, undefined                              */      0,                                                  state_undefined     },
3711     { /*235, undefined                              */      0,                                                  state_undefined     },
3712     { /*236, undefined                              */      0,                                                  state_undefined     },
3713     { /*237, undefined                              */      0,                                                  state_undefined     },
3714     { /*238, undefined                              */      0,                                                  state_undefined     },
3715     { /*239, undefined                              */      0,                                                  state_undefined     },
3716     { /*240, undefined                              */      0,                                                  state_undefined     },
3717     { /*241, undefined                              */      0,                                                  state_undefined     },
3718     { /*242, undefined                              */      0,                                                  state_undefined     },
3719     { /*243, undefined                              */      0,                                                  state_undefined     },
3720     { /*244, undefined                              */      0,                                                  state_undefined     },
3721     { /*245, undefined                              */      0,                                                  state_undefined     },
3722     { /*246, undefined                              */      0,                                                  state_undefined     },
3723     { /*247, undefined                              */      0,                                                  state_undefined     },
3724     { /*248, undefined                              */      0,                                                  state_undefined     },
3725     { /*249, undefined                              */      0,                                                  state_undefined     },
3726     { /*250, undefined                              */      0,                                                  state_undefined     },
3727     { /*251, undefined                              */      0,                                                  state_undefined     },
3728     { /*252, undefined                              */      0,                                                  state_undefined     },
3729     { /*253, undefined                              */      0,                                                  state_undefined     },
3730     { /*254, undefined                              */      0,                                                  state_undefined     },
3731     { /*255, undefined                              */      0,                                                  state_undefined     },
3732       /* End huge gap */
3733     { /*256, WINED3DTS_WORLDMATRIX(0)               */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(0)),          transform_world     },
3734     { /*257, WINED3DTS_WORLDMATRIX(1)               */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(1)),          transform_worldex   },
3735     { /*258, WINED3DTS_WORLDMATRIX(2)               */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(2)),          transform_worldex   },
3736     { /*259, WINED3DTS_WORLDMATRIX(3)               */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(3)),          transform_worldex   },
3737     { /*260, WINED3DTS_WORLDMATRIX(4)               */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(4)),          transform_worldex   },
3738     { /*261, WINED3DTS_WORLDMATRIX(5)               */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(5)),          transform_worldex   },
3739     { /*262, WINED3DTS_WORLDMATRIX(6)               */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(6)),          transform_worldex   },
3740     { /*263, WINED3DTS_WORLDMATRIX(7)               */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(7)),          transform_worldex   },
3741     { /*264, WINED3DTS_WORLDMATRIX(8)               */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(8)),          transform_worldex   },
3742     { /*265, WINED3DTS_WORLDMATRIX(9)               */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(9)),          transform_worldex   },
3743     { /*266, WINED3DTS_WORLDMATRIX(10)              */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(10)),         transform_worldex   },
3744     { /*267, WINED3DTS_WORLDMATRIX(11)              */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(11)),         transform_worldex   },
3745     { /*268, WINED3DTS_WORLDMATRIX(12)              */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(12)),         transform_worldex   },
3746     { /*269, WINED3DTS_WORLDMATRIX(13)              */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(13)),         transform_worldex   },
3747     { /*270, WINED3DTS_WORLDMATRIX(14)              */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(14)),         transform_worldex   },
3748     { /*271, WINED3DTS_WORLDMATRIX(15)              */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(15)),         transform_worldex   },
3749     { /*272, WINED3DTS_WORLDMATRIX(16)              */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(16)),         transform_worldex   },
3750     { /*273, WINED3DTS_WORLDMATRIX(17)              */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(17)),         transform_worldex   },
3751     { /*274, WINED3DTS_WORLDMATRIX(18)              */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(18)),         transform_worldex   },
3752     { /*275, WINED3DTS_WORLDMATRIX(19)              */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(19)),         transform_worldex   },
3753     { /*276, WINED3DTS_WORLDMATRIX(20)              */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(20)),         transform_worldex   },
3754     { /*277, WINED3DTS_WORLDMATRIX(21)              */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(21)),         transform_worldex   },
3755     { /*278, WINED3DTS_WORLDMATRIX(22)              */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(22)),         transform_worldex   },
3756     { /*279, WINED3DTS_WORLDMATRIX(23)              */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(23)),         transform_worldex   },
3757     { /*280, WINED3DTS_WORLDMATRIX(24)              */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(24)),         transform_worldex   },
3758     { /*281, WINED3DTS_WORLDMATRIX(25)              */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(25)),         transform_worldex   },
3759     { /*282, WINED3DTS_WORLDMATRIX(26)              */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(26)),         transform_worldex   },
3760     { /*283, WINED3DTS_WORLDMATRIX(27)              */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(27)),         transform_worldex   },
3761     { /*284, WINED3DTS_WORLDMATRIX(28)              */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(28)),         transform_worldex   },
3762     { /*285, WINED3DTS_WORLDMATRIX(29)              */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(29)),         transform_worldex   },
3763     { /*286, WINED3DTS_WORLDMATRIX(30)              */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(30)),         transform_worldex   },
3764     { /*287, WINED3DTS_WORLDMATRIX(31)              */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(31)),         transform_worldex   },
3765     { /*288, WINED3DTS_WORLDMATRIX(32)              */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(32)),         transform_worldex   },
3766     { /*289, WINED3DTS_WORLDMATRIX(33)              */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(33)),         transform_worldex   },
3767     { /*290, WINED3DTS_WORLDMATRIX(34)              */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(34)),         transform_worldex   },
3768     { /*291, WINED3DTS_WORLDMATRIX(35)              */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(35)),         transform_worldex   },
3769     { /*292, WINED3DTS_WORLDMATRIX(36)              */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(36)),         transform_worldex   },
3770     { /*293, WINED3DTS_WORLDMATRIX(37)              */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(37)),         transform_worldex   },
3771     { /*294, WINED3DTS_WORLDMATRIX(38)              */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(38)),         transform_worldex   },
3772     { /*295, WINED3DTS_WORLDMATRIX(39)              */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(39)),         transform_worldex   },
3773     { /*296, WINED3DTS_WORLDMATRIX(40)              */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(40)),         transform_worldex   },
3774     { /*297, WINED3DTS_WORLDMATRIX(41)              */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(41)),         transform_worldex   },
3775     { /*298, WINED3DTS_WORLDMATRIX(42)              */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(42)),         transform_worldex   },
3776     { /*299, WINED3DTS_WORLDMATRIX(43)              */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(43)),         transform_worldex   },
3777     { /*300, WINED3DTS_WORLDMATRIX(44)              */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(44)),         transform_worldex   },
3778     { /*301, WINED3DTS_WORLDMATRIX(45)              */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(45)),         transform_worldex   },
3779     { /*302, WINED3DTS_WORLDMATRIX(46)              */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(46)),         transform_worldex   },
3780     { /*303, WINED3DTS_WORLDMATRIX(47)              */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(47)),         transform_worldex   },
3781     { /*304, WINED3DTS_WORLDMATRIX(48)              */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(48)),         transform_worldex   },
3782     { /*305, WINED3DTS_WORLDMATRIX(49)              */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(49)),         transform_worldex   },
3783     { /*306, WINED3DTS_WORLDMATRIX(50)              */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(50)),         transform_worldex   },
3784     { /*307, WINED3DTS_WORLDMATRIX(51)              */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(51)),         transform_worldex   },
3785     { /*308, WINED3DTS_WORLDMATRIX(52)              */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(52)),         transform_worldex   },
3786     { /*309, WINED3DTS_WORLDMATRIX(53)              */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(53)),         transform_worldex   },
3787     { /*310, WINED3DTS_WORLDMATRIX(54)              */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(54)),         transform_worldex   },
3788     { /*311, WINED3DTS_WORLDMATRIX(55)              */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(55)),         transform_worldex   },
3789     { /*312, WINED3DTS_WORLDMATRIX(56)              */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(56)),         transform_worldex   },
3790     { /*313, WINED3DTS_WORLDMATRIX(57)              */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(57)),         transform_worldex   },
3791     { /*314, WINED3DTS_WORLDMATRIX(58)              */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(58)),         transform_worldex   },
3792     { /*315, WINED3DTS_WORLDMATRIX(59)              */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(59)),         transform_worldex   },
3793     { /*316, WINED3DTS_WORLDMATRIX(60)              */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(60)),         transform_worldex   },
3794     { /*317, WINED3DTS_WORLDMATRIX(61)              */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(61)),         transform_worldex   },
3795     { /*318, WINED3DTS_WORLDMATRIX(62)              */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(62)),         transform_worldex   },
3796     { /*319, WINED3DTS_WORLDMATRIX(63)              */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(63)),         transform_worldex   },
3797     { /*320, WINED3DTS_WORLDMATRIX(64)              */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(64)),         transform_worldex   },
3798     { /*321, WINED3DTS_WORLDMATRIX(65)              */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(65)),         transform_worldex   },
3799     { /*322, WINED3DTS_WORLDMATRIX(66)              */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(66)),         transform_worldex   },
3800     { /*323, WINED3DTS_WORLDMATRIX(67)              */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(67)),         transform_worldex   },
3801     { /*324, WINED3DTS_WORLDMATRIX(68)              */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(68)),         transform_worldex   },
3802     { /*325, WINED3DTS_WORLDMATRIX(68)              */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(69)),         transform_worldex   },
3803     { /*326, WINED3DTS_WORLDMATRIX(70)              */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(70)),         transform_worldex   },
3804     { /*327, WINED3DTS_WORLDMATRIX(71)              */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(71)),         transform_worldex   },
3805     { /*328, WINED3DTS_WORLDMATRIX(72)              */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(72)),         transform_worldex   },
3806     { /*329, WINED3DTS_WORLDMATRIX(73)              */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(73)),         transform_worldex   },
3807     { /*330, WINED3DTS_WORLDMATRIX(74)              */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(74)),         transform_worldex   },
3808     { /*331, WINED3DTS_WORLDMATRIX(75)              */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(75)),         transform_worldex   },
3809     { /*332, WINED3DTS_WORLDMATRIX(76)              */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(76)),         transform_worldex   },
3810     { /*333, WINED3DTS_WORLDMATRIX(77)              */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(77)),         transform_worldex   },
3811     { /*334, WINED3DTS_WORLDMATRIX(78)              */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(78)),         transform_worldex   },
3812     { /*335, WINED3DTS_WORLDMATRIX(79)              */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(79)),         transform_worldex   },
3813     { /*336, WINED3DTS_WORLDMATRIX(80)              */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(80)),         transform_worldex   },
3814     { /*337, WINED3DTS_WORLDMATRIX(81)              */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(81)),         transform_worldex   },
3815     { /*338, WINED3DTS_WORLDMATRIX(82)              */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(82)),         transform_worldex   },
3816     { /*339, WINED3DTS_WORLDMATRIX(83)              */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(83)),         transform_worldex   },
3817     { /*340, WINED3DTS_WORLDMATRIX(84)              */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(84)),         transform_worldex   },
3818     { /*341, WINED3DTS_WORLDMATRIX(85)              */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(85)),         transform_worldex   },
3819     { /*341, WINED3DTS_WORLDMATRIX(86)              */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(86)),         transform_worldex   },
3820     { /*343, WINED3DTS_WORLDMATRIX(87)              */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(87)),         transform_worldex   },
3821     { /*344, WINED3DTS_WORLDMATRIX(88)              */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(88)),         transform_worldex   },
3822     { /*345, WINED3DTS_WORLDMATRIX(89)              */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(89)),         transform_worldex   },
3823     { /*346, WINED3DTS_WORLDMATRIX(90)              */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(90)),         transform_worldex   },
3824     { /*347, WINED3DTS_WORLDMATRIX(91)              */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(91)),         transform_worldex   },
3825     { /*348, WINED3DTS_WORLDMATRIX(92)              */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(92)),         transform_worldex   },
3826     { /*349, WINED3DTS_WORLDMATRIX(93)              */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(93)),         transform_worldex   },
3827     { /*350, WINED3DTS_WORLDMATRIX(94)              */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(94)),         transform_worldex   },
3828     { /*351, WINED3DTS_WORLDMATRIX(95)              */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(95)),         transform_worldex   },
3829     { /*352, WINED3DTS_WORLDMATRIX(96)              */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(96)),         transform_worldex   },
3830     { /*353, WINED3DTS_WORLDMATRIX(97)              */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(97)),         transform_worldex   },
3831     { /*354, WINED3DTS_WORLDMATRIX(98)              */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(98)),         transform_worldex   },
3832     { /*355, WINED3DTS_WORLDMATRIX(99)              */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(99)),         transform_worldex   },
3833     { /*356, WINED3DTS_WORLDMATRIX(100)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(100)),        transform_worldex   },
3834     { /*357, WINED3DTS_WORLDMATRIX(101)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(101)),        transform_worldex   },
3835     { /*358, WINED3DTS_WORLDMATRIX(102)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(102)),        transform_worldex   },
3836     { /*359, WINED3DTS_WORLDMATRIX(103)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(103)),        transform_worldex   },
3837     { /*360, WINED3DTS_WORLDMATRIX(104)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(104)),        transform_worldex   },
3838     { /*361, WINED3DTS_WORLDMATRIX(105)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(105)),        transform_worldex   },
3839     { /*362, WINED3DTS_WORLDMATRIX(106)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(106)),        transform_worldex   },
3840     { /*363, WINED3DTS_WORLDMATRIX(107)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(107)),        transform_worldex   },
3841     { /*364, WINED3DTS_WORLDMATRIX(108)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(108)),        transform_worldex   },
3842     { /*365, WINED3DTS_WORLDMATRIX(109)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(109)),        transform_worldex   },
3843     { /*366, WINED3DTS_WORLDMATRIX(110)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(110)),        transform_worldex   },
3844     { /*367, WINED3DTS_WORLDMATRIX(111)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(111)),        transform_worldex   },
3845     { /*368, WINED3DTS_WORLDMATRIX(112)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(112)),        transform_worldex   },
3846     { /*369, WINED3DTS_WORLDMATRIX(113)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(113)),        transform_worldex   },
3847     { /*370, WINED3DTS_WORLDMATRIX(114)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(114)),        transform_worldex   },
3848     { /*371, WINED3DTS_WORLDMATRIX(115)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(115)),        transform_worldex   },
3849     { /*372, WINED3DTS_WORLDMATRIX(116)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(116)),        transform_worldex   },
3850     { /*373, WINED3DTS_WORLDMATRIX(117)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(117)),        transform_worldex   },
3851     { /*374, WINED3DTS_WORLDMATRIX(118)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(118)),        transform_worldex   },
3852     { /*375, WINED3DTS_WORLDMATRIX(119)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(119)),        transform_worldex   },
3853     { /*376, WINED3DTS_WORLDMATRIX(120)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(120)),        transform_worldex   },
3854     { /*377, WINED3DTS_WORLDMATRIX(121)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(121)),        transform_worldex   },
3855     { /*378, WINED3DTS_WORLDMATRIX(122)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(122)),        transform_worldex   },
3856     { /*379, WINED3DTS_WORLDMATRIX(123)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(123)),        transform_worldex   },
3857     { /*380, WINED3DTS_WORLDMATRIX(124)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(124)),        transform_worldex   },
3858     { /*381, WINED3DTS_WORLDMATRIX(125)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(125)),        transform_worldex   },
3859     { /*382, WINED3DTS_WORLDMATRIX(126)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(126)),        transform_worldex   },
3860     { /*383, WINED3DTS_WORLDMATRIX(127)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(127)),        transform_worldex   },
3861     { /*384, WINED3DTS_WORLDMATRIX(128)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(128)),        transform_worldex   },
3862     { /*385, WINED3DTS_WORLDMATRIX(129)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(129)),        transform_worldex   },
3863     { /*386, WINED3DTS_WORLDMATRIX(130)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(130)),        transform_worldex   },
3864     { /*387, WINED3DTS_WORLDMATRIX(131)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(131)),        transform_worldex   },
3865     { /*388, WINED3DTS_WORLDMATRIX(132)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(132)),        transform_worldex   },
3866     { /*389, WINED3DTS_WORLDMATRIX(133)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(133)),        transform_worldex   },
3867     { /*390, WINED3DTS_WORLDMATRIX(134)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(134)),        transform_worldex   },
3868     { /*391, WINED3DTS_WORLDMATRIX(135)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(135)),        transform_worldex   },
3869     { /*392, WINED3DTS_WORLDMATRIX(136)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(136)),        transform_worldex   },
3870     { /*393, WINED3DTS_WORLDMATRIX(137)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(137)),        transform_worldex   },
3871     { /*394, WINED3DTS_WORLDMATRIX(138)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(138)),        transform_worldex   },
3872     { /*395, WINED3DTS_WORLDMATRIX(139)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(139)),        transform_worldex   },
3873     { /*396, WINED3DTS_WORLDMATRIX(140)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(140)),        transform_worldex   },
3874     { /*397, WINED3DTS_WORLDMATRIX(141)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(141)),        transform_worldex   },
3875     { /*398, WINED3DTS_WORLDMATRIX(142)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(142)),        transform_worldex   },
3876     { /*399, WINED3DTS_WORLDMATRIX(143)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(143)),        transform_worldex   },
3877     { /*400, WINED3DTS_WORLDMATRIX(144)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(144)),        transform_worldex   },
3878     { /*401, WINED3DTS_WORLDMATRIX(145)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(145)),        transform_worldex   },
3879     { /*402, WINED3DTS_WORLDMATRIX(146)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(146)),        transform_worldex   },
3880     { /*403, WINED3DTS_WORLDMATRIX(147)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(147)),        transform_worldex   },
3881     { /*404, WINED3DTS_WORLDMATRIX(148)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(148)),        transform_worldex   },
3882     { /*405, WINED3DTS_WORLDMATRIX(149)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(149)),        transform_worldex   },
3883     { /*406, WINED3DTS_WORLDMATRIX(150)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(150)),        transform_worldex   },
3884     { /*407, WINED3DTS_WORLDMATRIX(151)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(151)),        transform_worldex   },
3885     { /*408, WINED3DTS_WORLDMATRIX(152)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(152)),        transform_worldex   },
3886     { /*409, WINED3DTS_WORLDMATRIX(153)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(153)),        transform_worldex   },
3887     { /*410, WINED3DTS_WORLDMATRIX(154)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(154)),        transform_worldex   },
3888     { /*411, WINED3DTS_WORLDMATRIX(155)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(155)),        transform_worldex   },
3889     { /*412, WINED3DTS_WORLDMATRIX(156)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(156)),        transform_worldex   },
3890     { /*413, WINED3DTS_WORLDMATRIX(157)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(157)),        transform_worldex   },
3891     { /*414, WINED3DTS_WORLDMATRIX(158)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(158)),        transform_worldex   },
3892     { /*415, WINED3DTS_WORLDMATRIX(159)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(159)),        transform_worldex   },
3893     { /*416, WINED3DTS_WORLDMATRIX(160)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(160)),        transform_worldex   },
3894     { /*417, WINED3DTS_WORLDMATRIX(161)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(161)),        transform_worldex   },
3895     { /*418, WINED3DTS_WORLDMATRIX(162)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(162)),        transform_worldex   },
3896     { /*419, WINED3DTS_WORLDMATRIX(163)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(163)),        transform_worldex   },
3897     { /*420, WINED3DTS_WORLDMATRIX(164)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(164)),        transform_worldex   },
3898     { /*421, WINED3DTS_WORLDMATRIX(165)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(165)),        transform_worldex   },
3899     { /*422, WINED3DTS_WORLDMATRIX(166)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(166)),        transform_worldex   },
3900     { /*423, WINED3DTS_WORLDMATRIX(167)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(167)),        transform_worldex   },
3901     { /*424, WINED3DTS_WORLDMATRIX(168)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(168)),        transform_worldex   },
3902     { /*425, WINED3DTS_WORLDMATRIX(168)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(169)),        transform_worldex   },
3903     { /*426, WINED3DTS_WORLDMATRIX(170)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(170)),        transform_worldex   },
3904     { /*427, WINED3DTS_WORLDMATRIX(171)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(171)),        transform_worldex   },
3905     { /*428, WINED3DTS_WORLDMATRIX(172)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(172)),        transform_worldex   },
3906     { /*429, WINED3DTS_WORLDMATRIX(173)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(173)),        transform_worldex   },
3907     { /*430, WINED3DTS_WORLDMATRIX(174)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(174)),        transform_worldex   },
3908     { /*431, WINED3DTS_WORLDMATRIX(175)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(175)),        transform_worldex   },
3909     { /*432, WINED3DTS_WORLDMATRIX(176)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(176)),        transform_worldex   },
3910     { /*433, WINED3DTS_WORLDMATRIX(177)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(177)),        transform_worldex   },
3911     { /*434, WINED3DTS_WORLDMATRIX(178)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(178)),        transform_worldex   },
3912     { /*435, WINED3DTS_WORLDMATRIX(179)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(179)),        transform_worldex   },
3913     { /*436, WINED3DTS_WORLDMATRIX(180)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(180)),        transform_worldex   },
3914     { /*437, WINED3DTS_WORLDMATRIX(181)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(181)),        transform_worldex   },
3915     { /*438, WINED3DTS_WORLDMATRIX(182)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(182)),        transform_worldex   },
3916     { /*439, WINED3DTS_WORLDMATRIX(183)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(183)),        transform_worldex   },
3917     { /*440, WINED3DTS_WORLDMATRIX(184)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(184)),        transform_worldex   },
3918     { /*441, WINED3DTS_WORLDMATRIX(185)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(185)),        transform_worldex   },
3919     { /*441, WINED3DTS_WORLDMATRIX(186)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(186)),        transform_worldex   },
3920     { /*443, WINED3DTS_WORLDMATRIX(187)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(187)),        transform_worldex   },
3921     { /*444, WINED3DTS_WORLDMATRIX(188)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(188)),        transform_worldex   },
3922     { /*445, WINED3DTS_WORLDMATRIX(189)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(189)),        transform_worldex   },
3923     { /*446, WINED3DTS_WORLDMATRIX(190)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(190)),        transform_worldex   },
3924     { /*447, WINED3DTS_WORLDMATRIX(191)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(191)),        transform_worldex   },
3925     { /*448, WINED3DTS_WORLDMATRIX(192)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(192)),        transform_worldex   },
3926     { /*449, WINED3DTS_WORLDMATRIX(193)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(193)),        transform_worldex   },
3927     { /*450, WINED3DTS_WORLDMATRIX(194)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(194)),        transform_worldex   },
3928     { /*451, WINED3DTS_WORLDMATRIX(195)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(195)),        transform_worldex   },
3929     { /*452, WINED3DTS_WORLDMATRIX(196)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(196)),        transform_worldex   },
3930     { /*453, WINED3DTS_WORLDMATRIX(197)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(197)),        transform_worldex   },
3931     { /*454, WINED3DTS_WORLDMATRIX(198)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(198)),        transform_worldex   },
3932     { /*455, WINED3DTS_WORLDMATRIX(199)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(199)),        transform_worldex   },
3933     { /*356, WINED3DTS_WORLDMATRIX(200)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(200)),        transform_worldex   },
3934     { /*457, WINED3DTS_WORLDMATRIX(201)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(201)),        transform_worldex   },
3935     { /*458, WINED3DTS_WORLDMATRIX(202)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(202)),        transform_worldex   },
3936     { /*459, WINED3DTS_WORLDMATRIX(203)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(203)),        transform_worldex   },
3937     { /*460, WINED3DTS_WORLDMATRIX(204)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(204)),        transform_worldex   },
3938     { /*461, WINED3DTS_WORLDMATRIX(205)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(205)),        transform_worldex   },
3939     { /*462, WINED3DTS_WORLDMATRIX(206)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(206)),        transform_worldex   },
3940     { /*463, WINED3DTS_WORLDMATRIX(207)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(207)),        transform_worldex   },
3941     { /*464, WINED3DTS_WORLDMATRIX(208)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(208)),        transform_worldex   },
3942     { /*465, WINED3DTS_WORLDMATRIX(209)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(209)),        transform_worldex   },
3943     { /*466, WINED3DTS_WORLDMATRIX(210)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(210)),        transform_worldex   },
3944     { /*467, WINED3DTS_WORLDMATRIX(211)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(211)),        transform_worldex   },
3945     { /*468, WINED3DTS_WORLDMATRIX(212)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(212)),        transform_worldex   },
3946     { /*469, WINED3DTS_WORLDMATRIX(213)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(213)),        transform_worldex   },
3947     { /*470, WINED3DTS_WORLDMATRIX(214)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(214)),        transform_worldex   },
3948     { /*471, WINED3DTS_WORLDMATRIX(215)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(215)),        transform_worldex   },
3949     { /*472, WINED3DTS_WORLDMATRIX(216)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(216)),        transform_worldex   },
3950     { /*473, WINED3DTS_WORLDMATRIX(217)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(217)),        transform_worldex   },
3951     { /*474, WINED3DTS_WORLDMATRIX(218)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(218)),        transform_worldex   },
3952     { /*475, WINED3DTS_WORLDMATRIX(219)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(219)),        transform_worldex   },
3953     { /*476, WINED3DTS_WORLDMATRIX(220)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(220)),        transform_worldex   },
3954     { /*477, WINED3DTS_WORLDMATRIX(221)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(221)),        transform_worldex   },
3955     { /*478, WINED3DTS_WORLDMATRIX(222)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(222)),        transform_worldex   },
3956     { /*479, WINED3DTS_WORLDMATRIX(223)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(223)),        transform_worldex   },
3957     { /*480, WINED3DTS_WORLDMATRIX(224)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(224)),        transform_worldex   },
3958     { /*481, WINED3DTS_WORLDMATRIX(225)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(225)),        transform_worldex   },
3959     { /*482, WINED3DTS_WORLDMATRIX(226)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(226)),        transform_worldex   },
3960     { /*483, WINED3DTS_WORLDMATRIX(227)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(227)),        transform_worldex   },
3961     { /*484, WINED3DTS_WORLDMATRIX(228)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(228)),        transform_worldex   },
3962     { /*485, WINED3DTS_WORLDMATRIX(229)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(229)),        transform_worldex   },
3963     { /*486, WINED3DTS_WORLDMATRIX(230)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(230)),        transform_worldex   },
3964     { /*487, WINED3DTS_WORLDMATRIX(231)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(231)),        transform_worldex   },
3965     { /*488, WINED3DTS_WORLDMATRIX(232)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(232)),        transform_worldex   },
3966     { /*489, WINED3DTS_WORLDMATRIX(233)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(233)),        transform_worldex   },
3967     { /*490, WINED3DTS_WORLDMATRIX(234)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(234)),        transform_worldex   },
3968     { /*491, WINED3DTS_WORLDMATRIX(235)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(235)),        transform_worldex   },
3969     { /*492, WINED3DTS_WORLDMATRIX(236)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(236)),        transform_worldex   },
3970     { /*493, WINED3DTS_WORLDMATRIX(237)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(237)),        transform_worldex   },
3971     { /*494, WINED3DTS_WORLDMATRIX(238)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(238)),        transform_worldex   },
3972     { /*495, WINED3DTS_WORLDMATRIX(239)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(239)),        transform_worldex   },
3973     { /*496, WINED3DTS_WORLDMATRIX(240)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(240)),        transform_worldex   },
3974     { /*497, WINED3DTS_WORLDMATRIX(241)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(241)),        transform_worldex   },
3975     { /*498, WINED3DTS_WORLDMATRIX(242)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(242)),        transform_worldex   },
3976     { /*499, WINED3DTS_WORLDMATRIX(243)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(243)),        transform_worldex   },
3977     { /*500, WINED3DTS_WORLDMATRIX(244)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(244)),        transform_worldex   },
3978     { /*501, WINED3DTS_WORLDMATRIX(245)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(245)),        transform_worldex   },
3979     { /*502, WINED3DTS_WORLDMATRIX(246)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(246)),        transform_worldex   },
3980     { /*503, WINED3DTS_WORLDMATRIX(247)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(247)),        transform_worldex   },
3981     { /*504, WINED3DTS_WORLDMATRIX(248)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(248)),        transform_worldex   },
3982     { /*505, WINED3DTS_WORLDMATRIX(249)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(249)),        transform_worldex   },
3983     { /*506, WINED3DTS_WORLDMATRIX(250)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(250)),        transform_worldex   },
3984     { /*507, WINED3DTS_WORLDMATRIX(251)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(251)),        transform_worldex   },
3985     { /*508, WINED3DTS_WORLDMATRIX(252)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(252)),        transform_worldex   },
3986     { /*509, WINED3DTS_WORLDMATRIX(253)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(253)),        transform_worldex   },
3987     { /*510, WINED3DTS_WORLDMATRIX(254)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(254)),        transform_worldex   },
3988     { /*511, WINED3DTS_WORLDMATRIX(255)             */      STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(255)),        transform_worldex   },
3989       /* Various Vertex states follow */
3990     { /*   , STATE_STREAMSRC                        */      STATE_VDECL,                                        vertexdeclaration   },
3991     { /*   , STATE_VDECL                            */      STATE_VDECL,                                        vertexdeclaration   },
3992     { /*   , STATE_VSHADER                          */      STATE_VDECL,                                        vertexdeclaration   },
3993     { /*   , STATE_VIEWPORT                         */      STATE_VIEWPORT,                                     viewport            },
3994     { /*   , STATE_VERTEXSHADERCONSTANT             */      STATE_VERTEXSHADERCONSTANT,                         shaderconstant      },
3995     { /*   , STATE_PIXELSHADERCONSTANT              */      STATE_VERTEXSHADERCONSTANT,                         shaderconstant      },
3996       /* Lights */
3997     { /*   , STATE_ACTIVELIGHT(0)                   */      STATE_ACTIVELIGHT(0),                               light               },
3998     { /*   , STATE_ACTIVELIGHT(1)                   */      STATE_ACTIVELIGHT(1),                               light               },
3999     { /*   , STATE_ACTIVELIGHT(2)                   */      STATE_ACTIVELIGHT(2),                               light               },
4000     { /*   , STATE_ACTIVELIGHT(3)                   */      STATE_ACTIVELIGHT(3),                               light               },
4001     { /*   , STATE_ACTIVELIGHT(4)                   */      STATE_ACTIVELIGHT(4),                               light               },
4002     { /*   , STATE_ACTIVELIGHT(5)                   */      STATE_ACTIVELIGHT(5),                               light               },
4003     { /*   , STATE_ACTIVELIGHT(6)                   */      STATE_ACTIVELIGHT(6),                               light               },
4004     { /*   , STATE_ACTIVELIGHT(7)                   */      STATE_ACTIVELIGHT(7),                               light               },
4005 };