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