dlls/wined3d/state.c

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