dlls/wined3d/state.c

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