dlls/wined3d/state.c

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