git.oblomov.eu Git - wine/blob - dlls/wined3d/state.c

   1 /*
   2  * Direct3D state management
   3  *
   4  * Copyright 2006 Stefan Dösinger for CodeWeavers
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  19  */
  20
  21 #include "config.h"
  22 #include <stdio.h>
  23 #ifdef HAVE_FLOAT_H
  24 # include <float.h>
  25 #endif
  26 #include "wined3d_private.h"
  27
  28 WINE_DEFAULT_DEBUG_CHANNEL(d3d);
  29
  30 #define GLINFO_LOCATION ((IWineD3DImpl *)(stateblock->wineD3DDevice->wineD3D))->gl_info
  31
  32 static void state_nogl(DWORD state, IWineD3DStateBlockImpl *stateblock) {
  33     /* Used for states which are not mapped to a gl state as-is, but used somehow different,
  34      * e.g as a parameter for drawing, or which are unimplemented in windows d3d
  35      */
  36     if(STATE_IS_RENDER(state)) {
  37         WINED3DRENDERSTATETYPE RenderState = state - STATE_RENDER(0);
  38         TRACE("(%s,%d) no direct mapping to gl\n", debug_d3drenderstate(RenderState), stateblock->renderState[RenderState]);
  39     } else {
  40         /* Shouldn't have an unknown type here */
  41         FIXME("%d no direct mapping to gl of state with unknown type\n", state);
  42     }
  43 }
  44
  45 static void state_undefined(DWORD state, IWineD3DStateBlockImpl *stateblock) {
  46     /* Print a WARN, this allows the stateblock code to loop over all states to generate a display
  47      * list without causing confusing terminal output. Deliberately no special debug name here
  48      * because its undefined.
  49      */
  50     WARN("undefined state %d\n", state);
  51 }
  52
  53 static void state_fillmode(DWORD state, IWineD3DStateBlockImpl *stateblock) {
  54     D3DFILLMODE Value = stateblock->renderState[WINED3DRS_FILLMODE];
  55
  56     switch(Value) {
  57         case D3DFILL_POINT:
  58             glPolygonMode(GL_FRONT_AND_BACK, GL_POINT);
  59             checkGLcall("glPolygonMode(GL_FRONT_AND_BACK, GL_POINT)");
  60             break;
  61         case D3DFILL_WIREFRAME:
  62             glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
  63             checkGLcall("glPolygonMode(GL_FRONT_AND_BACK, GL_LINE)");
  64             break;
  65         case D3DFILL_SOLID:
  66             glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
  67             checkGLcall("glPolygonMode(GL_FRONT_AND_BACK, GL_FILL)");
  68             break;
  69         default:
  70             FIXME("Unrecognized WINED3DRS_FILLMODE value %d\n", Value);
  71     }
  72 }
  73
  74 static void state_lighting(DWORD state, IWineD3DStateBlockImpl *stateblock) {
  75
  76     /* TODO: Lighting is only enabled if Vertex normals are passed by the application,
  77      * so merge the lighting render state with the vertex declaration once it is available
  78      */
  79
  80     if (stateblock->renderState[WINED3DRS_LIGHTING]) {
  81         glEnable(GL_LIGHTING);
  82         checkGLcall("glEnable GL_LIGHTING");
  83     } else {
  84         glDisable(GL_LIGHTING);
  85         checkGLcall("glDisable GL_LIGHTING");
  86     }
  87 }
  88
  89 static void state_zenable(DWORD state, IWineD3DStateBlockImpl *stateblock) {
  90     switch ((WINED3DZBUFFERTYPE) stateblock->renderState[WINED3DRS_ZENABLE]) {
  91         case WINED3DZB_FALSE:
  92             glDisable(GL_DEPTH_TEST);
  93             checkGLcall("glDisable GL_DEPTH_TEST");
  94             break;
  95         case WINED3DZB_TRUE:
  96             glEnable(GL_DEPTH_TEST);
  97             checkGLcall("glEnable GL_DEPTH_TEST");
  98             break;
  99         case WINED3DZB_USEW:
 100             glEnable(GL_DEPTH_TEST);
 101             checkGLcall("glEnable GL_DEPTH_TEST");
 102             FIXME("W buffer is not well handled\n");
 103             break;
 104         default:
 105             FIXME("Unrecognized D3DZBUFFERTYPE value %d\n", stateblock->renderState[WINED3DRS_ZENABLE]);
 106     }
 107 }
 108
 109 static void state_cullmode(DWORD state, IWineD3DStateBlockImpl *stateblock) {
 110     /* TODO: Put this into the offscreen / onscreen rendering block due to device->render_offscreen */
 111
 112     /* If we are culling "back faces with clockwise vertices" then
 113        set front faces to be counter clockwise and enable culling
 114        of back faces                                               */
 115     switch ((WINED3DCULL) stateblock->renderState[WINED3DRS_CULLMODE]) {
 116         case WINED3DCULL_NONE:
 117             glDisable(GL_CULL_FACE);
 118             checkGLcall("glDisable GL_CULL_FACE");
 119             break;
 120         case WINED3DCULL_CW:
 121             glEnable(GL_CULL_FACE);
 122             checkGLcall("glEnable GL_CULL_FACE");
 123             if (stateblock->wineD3DDevice->render_offscreen) {
 124                 glFrontFace(GL_CW);
 125                 checkGLcall("glFrontFace GL_CW");
 126             } else {
 127                 glFrontFace(GL_CCW);
 128                 checkGLcall("glFrontFace GL_CCW");
 129             }
 130             glCullFace(GL_BACK);
 131             break;
 132         case WINED3DCULL_CCW:
 133             glEnable(GL_CULL_FACE);
 134             checkGLcall("glEnable GL_CULL_FACE");
 135             if (stateblock->wineD3DDevice->render_offscreen) {
 136                 glFrontFace(GL_CCW);
 137                 checkGLcall("glFrontFace GL_CCW");
 138             } else {
 139                 glFrontFace(GL_CW);
 140                 checkGLcall("glFrontFace GL_CW");
 141             }
 142             glCullFace(GL_BACK);
 143             break;
 144         default:
 145             FIXME("Unrecognized/Unhandled WINED3DCULL value %d\n", stateblock->renderState[WINED3DRS_CULLMODE]);
 146     }
 147 }
 148
 149 static void state_shademode(DWORD state, IWineD3DStateBlockImpl *stateblock) {
 150     switch ((WINED3DSHADEMODE) stateblock->renderState[WINED3DRS_SHADEMODE]) {
 151         case WINED3DSHADE_FLAT:
 152             glShadeModel(GL_FLAT);
 153             checkGLcall("glShadeModel(GL_FLAT)");
 154             break;
 155         case WINED3DSHADE_GOURAUD:
 156             glShadeModel(GL_SMOOTH);
 157             checkGLcall("glShadeModel(GL_SMOOTH)");
 158             break;
 159         case WINED3DSHADE_PHONG:
 160             FIXME("WINED3DSHADE_PHONG isn't supported\n");
 161             break;
 162         default:
 163             FIXME("Unrecognized/Unhandled WINED3DSHADEMODE value %d\n", stateblock->renderState[WINED3DRS_SHADEMODE]);
 164     }
 165 }
 166
 167 static void state_ditherenable(DWORD state, IWineD3DStateBlockImpl *stateblock) {
 168     if (stateblock->renderState[WINED3DRS_DITHERENABLE]) {
 169         glEnable(GL_DITHER);
 170         checkGLcall("glEnable GL_DITHER");
 171     } else {
 172         glDisable(GL_DITHER);
 173         checkGLcall("glDisable GL_DITHER");
 174     }
 175 }
 176
 177 static void state_zwritenable(DWORD state, IWineD3DStateBlockImpl *stateblock) {
 178     /* TODO: Test if in d3d z writing is enabled even if ZENABLE is off. If yes,
 179      * this has to be merged with ZENABLE and ZFUNC
 180      */
 181     if (stateblock->renderState[WINED3DRS_ZWRITEENABLE]) {
 182         glDepthMask(1);
 183         checkGLcall("glDepthMask(1)");
 184     } else {
 185         glDepthMask(0);
 186         checkGLcall("glDepthMask(0)");
 187     }
 188 }
 189
 190 static void state_zfunc(DWORD state, IWineD3DStateBlockImpl *stateblock) {
 191     int glParm = CompareFunc(stateblock->renderState[WINED3DRS_ZFUNC]);
 192
 193     if(glParm) {
 194         glDepthFunc(glParm);
 195         checkGLcall("glDepthFunc");
 196     }
 197 }
 198
 199 static void state_ambient(DWORD state, IWineD3DStateBlockImpl *stateblock) {
 200     float col[4];
 201     D3DCOLORTOGLFLOAT4(stateblock->renderState[WINED3DRS_AMBIENT], col);
 202
 203     TRACE("Setting ambient to (%f,%f,%f,%f)\n", col[0], col[1], col[2], col[3]);
 204     glLightModelfv(GL_LIGHT_MODEL_AMBIENT, col);
 205     checkGLcall("glLightModel for MODEL_AMBIENT");
 206 }
 207
 208 static void state_blend(DWORD state, IWineD3DStateBlockImpl *stateblock) {
 209     int srcBlend = GL_ZERO;
 210     int dstBlend = GL_ZERO;
 211     float col[4];
 212
 213     /* GL_LINE_SMOOTH needs GL_BLEND to work, according to the red book, and special blending params */
 214     /* TODO: Is enabling blending really affected by the blendfactor??? */
 215     if (stateblock->renderState[WINED3DRS_ALPHABLENDENABLE]      ||
 216         stateblock->renderState[WINED3DRS_EDGEANTIALIAS]         ||
 217         stateblock->renderState[WINED3DRS_ANTIALIASEDLINEENABLE] ||
 218         stateblock->renderState[WINED3DRS_BLENDFACTOR] != 0xFFFFFFFF) {
 219         glEnable(GL_BLEND);
 220         checkGLcall("glEnable GL_BLEND");
 221     } else {
 222         glDisable(GL_BLEND);
 223         checkGLcall("glDisable GL_BLEND");
 224         /* Nothing more to do - get out */
 225         return;
 226     };
 227
 228     switch (stateblock->renderState[WINED3DRS_SRCBLEND]) {
 229         case WINED3DBLEND_ZERO               : srcBlend = GL_ZERO;  break;
 230         case WINED3DBLEND_ONE                : srcBlend = GL_ONE;  break;
 231         case WINED3DBLEND_SRCCOLOR           : srcBlend = GL_SRC_COLOR;  break;
 232         case WINED3DBLEND_INVSRCCOLOR        : srcBlend = GL_ONE_MINUS_SRC_COLOR;  break;
 233         case WINED3DBLEND_SRCALPHA           : srcBlend = GL_SRC_ALPHA;  break;
 234         case WINED3DBLEND_INVSRCALPHA        : srcBlend = GL_ONE_MINUS_SRC_ALPHA;  break;
 235         case WINED3DBLEND_DESTALPHA          : srcBlend = GL_DST_ALPHA;  break;
 236         case WINED3DBLEND_INVDESTALPHA       : srcBlend = GL_ONE_MINUS_DST_ALPHA;  break;
 237         case WINED3DBLEND_DESTCOLOR          : srcBlend = GL_DST_COLOR;  break;
 238         case WINED3DBLEND_INVDESTCOLOR       : srcBlend = GL_ONE_MINUS_DST_COLOR;  break;
 239         case WINED3DBLEND_SRCALPHASAT        : srcBlend = GL_SRC_ALPHA_SATURATE;  break;
 240
 241         case WINED3DBLEND_BOTHSRCALPHA       : srcBlend = GL_SRC_ALPHA;
 242             dstBlend = GL_SRC_ALPHA;
 243             break;
 244
 245         case WINED3DBLEND_BOTHINVSRCALPHA    : srcBlend = GL_ONE_MINUS_SRC_ALPHA;
 246             dstBlend = GL_ONE_MINUS_SRC_ALPHA;
 247             break;
 248
 249         case WINED3DBLEND_BLENDFACTOR        : srcBlend = GL_CONSTANT_COLOR;   break;
 250         case WINED3DBLEND_INVBLENDFACTOR     : srcBlend = GL_ONE_MINUS_CONSTANT_COLOR;  break;
 251         default:
 252             FIXME("Unrecognized src blend value %d\n", stateblock->renderState[WINED3DRS_SRCBLEND]);
 253     }
 254
 255     switch (stateblock->renderState[WINED3DRS_DESTBLEND]) {
 256         case WINED3DBLEND_ZERO               : dstBlend = GL_ZERO;  break;
 257         case WINED3DBLEND_ONE                : dstBlend = GL_ONE;  break;
 258         case WINED3DBLEND_SRCCOLOR           : dstBlend = GL_SRC_COLOR;  break;
 259         case WINED3DBLEND_INVSRCCOLOR        : dstBlend = GL_ONE_MINUS_SRC_COLOR;  break;
 260         case WINED3DBLEND_SRCALPHA           : dstBlend = GL_SRC_ALPHA;  break;
 261         case WINED3DBLEND_INVSRCALPHA        : dstBlend = GL_ONE_MINUS_SRC_ALPHA;  break;
 262         case WINED3DBLEND_DESTALPHA          : dstBlend = GL_DST_ALPHA;  break;
 263         case WINED3DBLEND_INVDESTALPHA       : dstBlend = GL_ONE_MINUS_DST_ALPHA;  break;
 264         case WINED3DBLEND_DESTCOLOR          : dstBlend = GL_DST_COLOR;  break;
 265         case WINED3DBLEND_INVDESTCOLOR       : dstBlend = GL_ONE_MINUS_DST_COLOR;  break;
 266         case WINED3DBLEND_SRCALPHASAT        : dstBlend = GL_SRC_ALPHA_SATURATE;  break;
 267
 268         case WINED3DBLEND_BOTHSRCALPHA       : dstBlend = GL_SRC_ALPHA;
 269             srcBlend = GL_SRC_ALPHA;
 270             break;
 271
 272         case WINED3DBLEND_BOTHINVSRCALPHA    : dstBlend = GL_ONE_MINUS_SRC_ALPHA;
 273             srcBlend = GL_ONE_MINUS_SRC_ALPHA;
 274             break;
 275
 276         case D3DBLEND_BLENDFACTOR        : dstBlend = GL_CONSTANT_COLOR;   break;
 277         case D3DBLEND_INVBLENDFACTOR     : dstBlend = GL_ONE_MINUS_CONSTANT_COLOR;  break;
 278         default:
 279             FIXME("Unrecognized dst blend value %d\n", stateblock->renderState[WINED3DRS_DESTBLEND]);
 280     }
 281
 282     if(stateblock->renderState[WINED3DRS_EDGEANTIALIAS] ||
 283        stateblock->renderState[WINED3DRS_ANTIALIASEDLINEENABLE]) {
 284         glEnable(GL_LINE_SMOOTH);
 285         checkGLcall("glEnable(GL_LINE_SMOOTH)");
 286         if(srcBlend != GL_SRC_ALPHA) {
 287             FIXME("WINED3DRS_EDGEANTIALIAS enabled, but incompatible src blending param - what to do?\n");
 288             srcBlend = GL_SRC_ALPHA;
 289         }
 290         if(dstBlend != GL_ONE_MINUS_SRC_ALPHA) {
 291             FIXME("WINED3DRS_EDGEANTIALIAS enabled, but incompatible dst blending param - what to do?\n");
 292             dstBlend = GL_ONE_MINUS_SRC_ALPHA;
 293         }
 294     } else {
 295         glDisable(GL_LINE_SMOOTH);
 296         checkGLcall("glDisable(GL_LINE_SMOOTH)");
 297     }
 298
 299     TRACE("glBlendFunc src=%x, dst=%x\n", srcBlend, dstBlend);
 300     glBlendFunc(srcBlend, dstBlend);
 301     checkGLcall("glBlendFunc");
 302
 303     /* TODO: Remove when state management done */
 304     stateblock->wineD3DDevice->dstBlend = dstBlend;
 305     stateblock->wineD3DDevice->srcBlend = srcBlend;
 306
 307     TRACE("Setting BlendFactor to %d\n", stateblock->renderState[WINED3DRS_BLENDFACTOR]);
 308     D3DCOLORTOGLFLOAT4(stateblock->renderState[WINED3DRS_BLENDFACTOR], col);
 309     glBlendColor (col[0],col[1],col[2],col[3]);
 310     checkGLcall("glBlendColor");
 311 }
 312
 313 static void state_alpha(DWORD state, IWineD3DStateBlockImpl *stateblock) {
 314     int glParm = 0;
 315     float ref;
 316     BOOL enable_ckey = FALSE;
 317
 318     IWineD3DSurfaceImpl *surf;
 319
 320     /* Find out if the texture on the first stage has a ckey set
 321      * The alpha state func reads the texture settings, even though alpha and texture are not grouped
 322      * together. This is to avoid making a huge alpha+texture+texture stage+ckey block due to the hardly
 323      * used WINED3DRS_COLORKEYENABLE state(which is d3d <= 3 only). The texture function will call alpha
 324      * in case it finds some texture+colorkeyenable combination which needs extra care.
 325      */
 326     if(stateblock->textures[0]) {
 327         surf = (IWineD3DSurfaceImpl *) ((IWineD3DTextureImpl *)stateblock->textures[0])->surfaces[0];
 328         if(surf->CKeyFlags & DDSD_CKSRCBLT) enable_ckey = TRUE;
 329     }
 330
 331     if (stateblock->renderState[WINED3DRS_ALPHATESTENABLE] ||
 332         (stateblock->renderState[WINED3DRS_COLORKEYENABLE] && enable_ckey)) {
 333         glEnable(GL_ALPHA_TEST);
 334         checkGLcall("glEnable GL_ALPHA_TEST");
 335     } else {
 336         glDisable(GL_ALPHA_TEST);
 337         checkGLcall("glDisable GL_ALPHA_TEST");
 338         /* Alpha test is disabled, don't bother setting the params - it will happen on the next
 339          * enable call
 340          */
 341         return;
 342     }
 343
 344     if(stateblock->renderState[WINED3DRS_COLORKEYENABLE] && enable_ckey) {
 345         glParm = GL_NOTEQUAL;
 346         ref = 0.0;
 347     } else {
 348         ref = ((float) stateblock->renderState[WINED3DRS_ALPHAREF]) / 255.0f;
 349         glParm = CompareFunc(stateblock->renderState[WINED3DRS_ALPHAFUNC]);
 350     }
 351     if(glParm) {
 352         stateblock->wineD3DDevice->alphafunc = glParm; /* Remove when state management done */
 353         glAlphaFunc(glParm, ref);
 354         checkGLcall("glAlphaFunc");
 355     }
 356     /* TODO: Some texture blending operations seem to affect the alpha test */
 357 }
 358
 359 static void state_clipping(DWORD state, IWineD3DStateBlockImpl *stateblock) {
 360     DWORD enable  = 0xFFFFFFFF;
 361     DWORD disable = 0x00000000;
 362
 363     /* TODO: Keep track of previously enabled clipplanes to avoid unneccessary resetting
 364      * of already set values
 365      */
 366
 367     /* If enabling / disabling all
 368      * TODO: Is this correct? Doesn't D3DRS_CLIPPING disable clipping on the viewport frustrum?
 369      */
 370     if (stateblock->renderState[WINED3DRS_CLIPPING]) {
 371         enable  = stateblock->renderState[WINED3DRS_CLIPPLANEENABLE];
 372         disable = ~stateblock->renderState[WINED3DRS_CLIPPLANEENABLE];
 373     } else {
 374         disable = 0xffffffff;
 375         enable  = 0x00;
 376     }
 377
 378     if (enable & WINED3DCLIPPLANE0)  { glEnable(GL_CLIP_PLANE0);  checkGLcall("glEnable(clip plane 0)"); }
 379     if (enable & WINED3DCLIPPLANE1)  { glEnable(GL_CLIP_PLANE1);  checkGLcall("glEnable(clip plane 1)"); }
 380     if (enable & WINED3DCLIPPLANE2)  { glEnable(GL_CLIP_PLANE2);  checkGLcall("glEnable(clip plane 2)"); }
 381     if (enable & WINED3DCLIPPLANE3)  { glEnable(GL_CLIP_PLANE3);  checkGLcall("glEnable(clip plane 3)"); }
 382     if (enable & WINED3DCLIPPLANE4)  { glEnable(GL_CLIP_PLANE4);  checkGLcall("glEnable(clip plane 4)"); }
 383     if (enable & WINED3DCLIPPLANE5)  { glEnable(GL_CLIP_PLANE5);  checkGLcall("glEnable(clip plane 5)"); }
 384
 385     if (disable & WINED3DCLIPPLANE0) { glDisable(GL_CLIP_PLANE0); checkGLcall("glDisable(clip plane 0)"); }
 386     if (disable & WINED3DCLIPPLANE1) { glDisable(GL_CLIP_PLANE1); checkGLcall("glDisable(clip plane 1)"); }
 387     if (disable & WINED3DCLIPPLANE2) { glDisable(GL_CLIP_PLANE2); checkGLcall("glDisable(clip plane 2)"); }
 388     if (disable & WINED3DCLIPPLANE3) { glDisable(GL_CLIP_PLANE3); checkGLcall("glDisable(clip plane 3)"); }
 389     if (disable & WINED3DCLIPPLANE4) { glDisable(GL_CLIP_PLANE4); checkGLcall("glDisable(clip plane 4)"); }
 390     if (disable & WINED3DCLIPPLANE5) { glDisable(GL_CLIP_PLANE5); checkGLcall("glDisable(clip plane 5)"); }
 391
 392     /** update clipping status */
 393     if (enable) {
 394         stateblock->clip_status.ClipUnion = 0;
 395         stateblock->clip_status.ClipIntersection = 0xFFFFFFFF;
 396     } else {
 397         stateblock->clip_status.ClipUnion = 0;
 398         stateblock->clip_status.ClipIntersection = 0;
 399     }
 400 }
 401
 402 static void state_blendop(DWORD state, IWineD3DStateBlockImpl *stateblock) {
 403     int glParm = GL_FUNC_ADD;
 404
 405     if(!GL_SUPPORT(EXT_BLEND_MINMAX)) {
 406         WARN("Unsupported in local OpenGL implementation: glBlendEquation\n");
 407         return;
 408     }
 409
 410     switch ((WINED3DBLENDOP) stateblock->renderState[WINED3DRS_BLENDOP]) {
 411         case WINED3DBLENDOP_ADD              : glParm = GL_FUNC_ADD;              break;
 412         case WINED3DBLENDOP_SUBTRACT         : glParm = GL_FUNC_SUBTRACT;         break;
 413         case WINED3DBLENDOP_REVSUBTRACT      : glParm = GL_FUNC_REVERSE_SUBTRACT; break;
 414         case WINED3DBLENDOP_MIN              : glParm = GL_MIN;                   break;
 415         case WINED3DBLENDOP_MAX              : glParm = GL_MAX;                   break;
 416         default:
 417             FIXME("Unrecognized/Unhandled D3DBLENDOP value %d\n", stateblock->renderState[WINED3DRS_BLENDOP]);
 418     }
 419
 420     TRACE("glBlendEquation(%x)\n", glParm);
 421     GL_EXTCALL(glBlendEquation(glParm));
 422     checkGLcall("glBlendEquation");
 423 }
 424
 425 static void
 426 state_specularenable(DWORD state, IWineD3DStateBlockImpl *stateblock) {
 427     /* Originally this used glLightModeli(GL_LIGHT_MODEL_COLOR_CONTROL,GL_SEPARATE_SPECULAR_COLOR)
 428      * and (GL_LIGHT_MODEL_COLOR_CONTROL,GL_SINGLE_COLOR) to swap between enabled/disabled
 429      * specular color. This is wrong:
 430      * Separate specular color means the specular colour is maintained separately, whereas
 431      * single color means it is merged in. However in both cases they are being used to
 432      * some extent.
 433      * To disable specular color, set it explicitly to black and turn off GL_COLOR_SUM_EXT
 434      * NOTE: If not supported don't give FIXMEs the impact is really minimal and very few people are
 435      * running 1.4 yet!
 436      *
 437      *
 438      * If register combiners are enabled, enabling / disabling GL_COLOR_SUM has no effect.
 439      * Instead, we need to setup the FinalCombiner properly.
 440      *
 441      * The default setup for the FinalCombiner is:
 442      *
 443      * <variable>       <input>                             <mapping>               <usage>
 444      * GL_VARIABLE_A_NV GL_FOG,                             GL_UNSIGNED_IDENTITY_NV GL_ALPHA
 445      * GL_VARIABLE_B_NV GL_SPARE0_PLUS_SECONDARY_COLOR_NV   GL_UNSIGNED_IDENTITY_NV GL_RGB
 446      * GL_VARIABLE_C_NV GL_FOG                              GL_UNSIGNED_IDENTITY_NV GL_RGB
 447      * GL_VARIABLE_D_NV GL_ZERO                             GL_UNSIGNED_IDENTITY_NV GL_RGB
 448      * GL_VARIABLE_E_NV GL_ZERO                             GL_UNSIGNED_IDENTITY_NV GL_RGB
 449      * GL_VARIABLE_F_NV GL_ZERO                             GL_UNSIGNED_IDENTITY_NV GL_RGB
 450      * GL_VARIABLE_G_NV GL_SPARE0_NV                        GL_UNSIGNED_IDENTITY_NV GL_ALPHA
 451      *
 452      * That's pretty much fine as it is, except for variable B, which needs to take
 453      * either GL_SPARE0_PLUS_SECONDARY_COLOR_NV or GL_SPARE0_NV, depending on
 454      * whether WINED3DRS_SPECULARENABLE is enabled or not.
 455      */
 456
 457     TRACE("Setting specular enable state\n");
 458     /* TODO: Add to the material setting functions */
 459     if (stateblock->renderState[WINED3DRS_SPECULARENABLE]) {
 460         glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, (float*) &stateblock->material.Specular);
 461         checkGLcall("glMaterialfv");
 462         if (GL_SUPPORT(EXT_SECONDARY_COLOR)) {
 463             glEnable(GL_COLOR_SUM_EXT);
 464         } else {
 465             TRACE("Specular colors cannot be enabled in this version of opengl\n");
 466         }
 467         checkGLcall("glEnable(GL_COLOR_SUM)");
 468
 469         if (GL_SUPPORT(NV_REGISTER_COMBINERS)) {
 470             GL_EXTCALL(glFinalCombinerInputNV(GL_VARIABLE_B_NV, GL_SPARE0_PLUS_SECONDARY_COLOR_NV, GL_UNSIGNED_IDENTITY_NV, GL_RGB));
 471             checkGLcall("glFinalCombinerInputNV()");
 472         }
 473     } else {
 474         float black[4] = {0.0f, 0.0f, 0.0f, 0.0f};
 475
 476         /* for the case of enabled lighting: */
 477         glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, &black[0]);
 478         checkGLcall("glMaterialfv");
 479
 480         /* for the case of disabled lighting: */
 481         if (GL_SUPPORT(EXT_SECONDARY_COLOR)) {
 482             glDisable(GL_COLOR_SUM_EXT);
 483         } else {
 484             TRACE("Specular colors cannot be disabled in this version of opengl\n");
 485         }
 486         checkGLcall("glDisable(GL_COLOR_SUM)");
 487
 488         if (GL_SUPPORT(NV_REGISTER_COMBINERS)) {
 489             GL_EXTCALL(glFinalCombinerInputNV(GL_VARIABLE_B_NV, GL_SPARE0_NV, GL_UNSIGNED_IDENTITY_NV, GL_RGB));
 490             checkGLcall("glFinalCombinerInputNV()");
 491         }
 492     }
 493 }
 494
 495 static void state_texfactor(DWORD state, IWineD3DStateBlockImpl *stateblock) {
 496     unsigned int i;
 497
 498     /* Note the texture color applies to all textures whereas
 499      * GL_TEXTURE_ENV_COLOR applies to active only
 500      */
 501     float col[4];
 502     D3DCOLORTOGLFLOAT4(stateblock->renderState[WINED3DRS_TEXTUREFACTOR], col);
 503
 504     if (!GL_SUPPORT(NV_REGISTER_COMBINERS)) {
 505         /* And now the default texture color as well */
 506         for (i = 0; i < GL_LIMITS(texture_stages); i++) {
 507             /* Note the WINED3DRS value applies to all textures, but GL has one
 508              * per texture, so apply it now ready to be used!
 509              */
 510             if (GL_SUPPORT(ARB_MULTITEXTURE)) {
 511                 GL_EXTCALL(glActiveTextureARB(GL_TEXTURE0_ARB + i));
 512                 checkGLcall("glActiveTextureARB");
 513             } else if (i>0) {
 514                 FIXME("Program using multiple concurrent textures which this opengl implementation doesn't support\n");
 515             }
 516
 517             glTexEnvfv(GL_TEXTURE_ENV, GL_TEXTURE_ENV_COLOR, &col[0]);
 518             checkGLcall("glTexEnvfv(GL_TEXTURE_ENV, GL_TEXTURE_ENV_COLOR, color);");
 519         }
 520     } else {
 521         GL_EXTCALL(glCombinerParameterfvNV(GL_CONSTANT_COLOR0_NV, &col[0]));
 522     }
 523 }
 524
 525 static void
 526 renderstate_stencil_twosided(IWineD3DStateBlockImpl *stateblock, GLint face, GLint func, GLint ref, GLuint mask, GLint stencilFail, GLint depthFail, GLint stencilPass ) {
 527 #if 0 /* Don't use OpenGL 2.0 calls for now */
 528             if(GL_EXTCALL(glStencilFuncSeparate) && GL_EXTCALL(glStencilOpSeparate)) {
 529                 GL_EXTCALL(glStencilFuncSeparate(face, func, ref, mask));
 530                 checkGLcall("glStencilFuncSeparate(...)");
 531                 GL_EXTCALL(glStencilOpSeparate(face, stencilFail, depthFail, stencilPass));
 532                 checkGLcall("glStencilOpSeparate(...)");
 533         }
 534             else
 535 #endif
 536     if(GL_SUPPORT(EXT_STENCIL_TWO_SIDE)) {
 537         glEnable(GL_STENCIL_TEST_TWO_SIDE_EXT);
 538         checkGLcall("glEnable(GL_STENCIL_TEST_TWO_SIDE_EXT)");
 539         GL_EXTCALL(glActiveStencilFaceEXT(face));
 540         checkGLcall("glActiveStencilFaceEXT(...)");
 541         glStencilFunc(func, ref, mask);
 542         checkGLcall("glStencilFunc(...)");
 543         glStencilOp(stencilFail, depthFail, stencilPass);
 544         checkGLcall("glStencilOp(...)");
 545     } else if(GL_SUPPORT(ATI_SEPARATE_STENCIL)) {
 546         GL_EXTCALL(glStencilFuncSeparateATI(face, func, ref, mask));
 547         checkGLcall("glStencilFuncSeparateATI(...)");
 548         GL_EXTCALL(glStencilOpSeparateATI(face, stencilFail, depthFail, stencilPass));
 549         checkGLcall("glStencilOpSeparateATI(...)");
 550     } else {
 551         ERR("Separate (two sided) stencil not supported on this version of opengl. Caps weren't honored?\n");
 552     }
 553 }
 554
 555 static void
 556 state_stencil(DWORD state, IWineD3DStateBlockImpl *stateblock) {
 557     DWORD onesided_enable = FALSE;
 558     DWORD twosided_enable = FALSE;
 559     GLint func = GL_ALWAYS;
 560     GLint func_ccw = GL_ALWAYS;
 561     GLint ref = 0;
 562     GLuint mask = 0;
 563     GLint stencilFail = GL_KEEP;
 564     GLint depthFail = GL_KEEP;
 565     GLint stencilPass = GL_KEEP;
 566     GLint stencilFail_ccw = GL_KEEP;
 567     GLint depthFail_ccw = GL_KEEP;
 568     GLint stencilPass_ccw = GL_KEEP;
 569
 570     if( stateblock->set.renderState[WINED3DRS_STENCILENABLE] )
 571         onesided_enable = stateblock->renderState[WINED3DRS_STENCILENABLE];
 572     if( stateblock->set.renderState[WINED3DRS_TWOSIDEDSTENCILMODE] )
 573         twosided_enable = stateblock->renderState[WINED3DRS_TWOSIDEDSTENCILMODE];
 574     if( stateblock->set.renderState[WINED3DRS_STENCILFUNC] )
 575         if( !( func = CompareFunc(stateblock->renderState[WINED3DRS_STENCILFUNC]) ) )
 576             func = GL_ALWAYS;
 577     if( stateblock->set.renderState[WINED3DRS_CCW_STENCILFUNC] )
 578         if( !( func_ccw = CompareFunc(stateblock->renderState[WINED3DRS_CCW_STENCILFUNC]) ) )
 579             func = GL_ALWAYS;
 580     if( stateblock->set.renderState[WINED3DRS_STENCILREF] )
 581         ref = stateblock->renderState[WINED3DRS_STENCILREF];
 582     if( stateblock->set.renderState[WINED3DRS_STENCILMASK] )
 583         mask = stateblock->renderState[WINED3DRS_STENCILMASK];
 584     if( stateblock->set.renderState[WINED3DRS_STENCILFAIL] )
 585         stencilFail = StencilOp(stateblock->renderState[WINED3DRS_STENCILFAIL]);
 586     if( stateblock->set.renderState[WINED3DRS_STENCILZFAIL] )
 587         depthFail = StencilOp(stateblock->renderState[WINED3DRS_STENCILZFAIL]);
 588     if( stateblock->set.renderState[WINED3DRS_STENCILPASS] )
 589         stencilPass = StencilOp(stateblock->renderState[WINED3DRS_STENCILPASS]);
 590     if( stateblock->set.renderState[WINED3DRS_CCW_STENCILFAIL] )
 591         stencilFail_ccw = StencilOp(stateblock->renderState[WINED3DRS_CCW_STENCILFAIL]);
 592     if( stateblock->set.renderState[WINED3DRS_CCW_STENCILZFAIL] )
 593         depthFail_ccw = StencilOp(stateblock->renderState[WINED3DRS_CCW_STENCILZFAIL]);
 594     if( stateblock->set.renderState[WINED3DRS_CCW_STENCILPASS] )
 595         stencilPass_ccw = StencilOp(stateblock->renderState[WINED3DRS_CCW_STENCILPASS]);
 596
 597     TRACE("(onesided %d, twosided %d, ref %x, mask %x,  \
 598             GL_FRONT: func: %x, fail %x, zfail %x, zpass %x  \
 599             GL_BACK: func: %x, fail %x, zfail %x, zpass %x )\n",
 600     onesided_enable, twosided_enable, ref, mask,
 601     func, stencilFail, depthFail, stencilPass,
 602     func_ccw, stencilFail_ccw, depthFail_ccw, stencilPass_ccw);
 603
 604     if (twosided_enable) {
 605         renderstate_stencil_twosided(stateblock, GL_FRONT, func, ref, mask, stencilFail, depthFail, stencilPass);
 606         renderstate_stencil_twosided(stateblock, GL_BACK, func_ccw, ref, mask, stencilFail_ccw, depthFail_ccw, stencilPass_ccw);
 607     } else {
 608         if (onesided_enable) {
 609             glEnable(GL_STENCIL_TEST);
 610             checkGLcall("glEnable GL_STENCIL_TEST");
 611             glStencilFunc(func, ref, mask);
 612             checkGLcall("glStencilFunc(...)");
 613             glStencilOp(stencilFail, depthFail, stencilPass);
 614             checkGLcall("glStencilOp(...)");
 615         } else {
 616             glDisable(GL_STENCIL_TEST);
 617             checkGLcall("glDisable GL_STENCIL_TEST");
 618         }
 619     }
 620 }
 621
 622 static void state_stencilwrite(DWORD state, IWineD3DStateBlockImpl *stateblock) {
 623     glStencilMask(stateblock->renderState[WINED3DRS_STENCILWRITEMASK]);
 624     checkGLcall("glStencilMask");
 625 }
 626
 627 static void state_fog(DWORD state, IWineD3DStateBlockImpl *stateblock) {
 628     /* TODO: Put this into the vertex type block once that is in the state table */
 629     BOOL fogenable = stateblock->renderState[WINED3DRS_FOGENABLE];
 630     float fogstart, fogend;
 631
 632     union {
 633         DWORD d;
 634         float f;
 635     } tmpvalue;
 636
 637     if (!fogenable) {
 638         /* No fog? Disable it, and we're done :-) */
 639         glDisable(GL_FOG);
 640         checkGLcall("glDisable GL_FOG");
 641     }
 642
 643     tmpvalue.d = stateblock->renderState[WINED3DRS_FOGSTART];
 644     fogstart = tmpvalue.f;
 645     tmpvalue.d = stateblock->renderState[WINED3DRS_FOGEND];
 646     fogend = tmpvalue.f;
 647
 648 #if 0
 649     /* Activate when vertex shaders are in the state table */
 650     if(stateblock->vertexShader && ((IWineD3DVertexShaderImpl *)stateblock->vertexShader)->baseShader.function &&
 651        ((IWineD3DVertexShaderImpl *)stateblock->vertexShader)->usesFog) {
 652         glFogi(GL_FOG_MODE, GL_LINEAR);
 653         checkGLcall("glFogi(GL_FOG_MODE, GL_LINEAR)");
 654         fogstart = 1.0;
 655         fogend = 0.0;
 656         stateblock->wineD3DDevice->last_was_foggy_shader = TRUE;
 657     }
 658 #endif
 659
 660     /* DX 7 sdk: "If both render states(vertex and table fog) are set to valid modes,
 661      * the system will apply only pixel(=table) fog effects."
 662      */
 663     /* else */ if(stateblock->renderState[WINED3DRS_FOGTABLEMODE] == D3DFOG_NONE) {
 664         glHint(GL_FOG_HINT, GL_FASTEST);
 665         checkGLcall("glHint(GL_FOG_HINT, GL_FASTEST)");
 666 #if 0
 667         stateblock->wineD3DDevice->last_was_foggy_shader = FALSE;
 668 #endif
 669         switch (stateblock->renderState[WINED3DRS_FOGVERTEXMODE]) {
 670             /* Processed vertices have their fog factor stored in the specular value. Fall too the none case.
 671              * If we are drawing untransformed vertices atm, d3ddevice_set_ortho will update the fog
 672              */
 673             case D3DFOG_EXP:  {
 674                 if(!stateblock->wineD3DDevice->last_was_rhw) {
 675                     glFogi(GL_FOG_MODE, GL_EXP);
 676                     checkGLcall("glFogi(GL_FOG_MODE, GL_EXP");
 677                     if(GL_SUPPORT(EXT_FOG_COORD)) {
 678                         glFogi(GL_FOG_COORDINATE_SOURCE_EXT, GL_FRAGMENT_DEPTH_EXT);
 679                         checkGLcall("glFogi(GL_FOG_COORDINATE_SOURCE_EXT, GL_FRAGMENT_DEPTH_EXT");
 680                     }
 681                     break;
 682                 }
 683             }
 684             case D3DFOG_EXP2: {
 685                 if(!stateblock->wineD3DDevice->last_was_rhw) {
 686                     glFogi(GL_FOG_MODE, GL_EXP2);
 687                     checkGLcall("glFogi(GL_FOG_MODE, GL_EXP2");
 688                     if(GL_SUPPORT(EXT_FOG_COORD)) {
 689                         glFogi(GL_FOG_COORDINATE_SOURCE_EXT, GL_FRAGMENT_DEPTH_EXT);
 690                         checkGLcall("glFogi(GL_FOG_COORDINATE_SOURCE_EXT, GL_FRAGMENT_DEPTH_EXT");
 691                     }
 692                     break;
 693                 }
 694             }
 695             case D3DFOG_LINEAR: {
 696                 if(!stateblock->wineD3DDevice->last_was_rhw) {
 697                     glFogi(GL_FOG_MODE, GL_LINEAR);
 698                     checkGLcall("glFogi(GL_FOG_MODE, GL_LINEAR");
 699                     if(GL_SUPPORT(EXT_FOG_COORD)) {
 700                         glFogi(GL_FOG_COORDINATE_SOURCE_EXT, GL_FRAGMENT_DEPTH_EXT);
 701                         checkGLcall("glFogi(GL_FOG_COORDINATE_SOURCE_EXT, GL_FRAGMENT_DEPTH_EXT");
 702                     }
 703                     break;
 704                 }
 705             }
 706             case D3DFOG_NONE: {
 707                 /* Both are none? According to msdn the alpha channel of the specular
 708                  * color contains a fog factor. Set it in drawStridedSlow.
 709                  * Same happens with Vertexfog on transformed vertices
 710                  */
 711                 if(GL_SUPPORT(EXT_FOG_COORD)) {
 712                     glFogi(GL_FOG_COORDINATE_SOURCE_EXT, GL_FOG_COORDINATE_EXT);
 713                     checkGLcall("glFogi(GL_FOG_COORDINATE_SOURCE_EXT, GL_FOG_COORDINATE_EXT)\n");
 714                     glFogi(GL_FOG_MODE, GL_LINEAR);
 715                     checkGLcall("glFogi(GL_FOG_MODE, GL_LINEAR)");
 716                     fogstart = 0xff;
 717                     fogend = 0x0;
 718                 } else {
 719                     /* Disable GL fog, handle this in software in drawStridedSlow */
 720                     fogenable = FALSE;
 721                 }
 722                 break;
 723             }
 724             default: FIXME("Unexpected WINED3DRS_FOGVERTEXMODE %d\n", stateblock->renderState[WINED3DRS_FOGVERTEXMODE]);
 725         }
 726     } else {
 727         glHint(GL_FOG_HINT, GL_NICEST);
 728         checkGLcall("glHint(GL_FOG_HINT, GL_NICEST)");
 729 #if 0
 730         stateblock->wineD3DDevice->last_was_foggy_shader = FALSE;
 731 #endif
 732         switch (stateblock->renderState[WINED3DRS_FOGTABLEMODE]) {
 733             case D3DFOG_EXP:
 734                 glFogi(GL_FOG_MODE, GL_EXP);
 735                 checkGLcall("glFogi(GL_FOG_MODE, GL_EXP");
 736                 if(GL_SUPPORT(EXT_FOG_COORD)) {
 737                     glFogi(GL_FOG_COORDINATE_SOURCE_EXT, GL_FRAGMENT_DEPTH_EXT);
 738                     checkGLcall("glFogi(GL_FOG_COORDINATE_SOURCE_EXT, GL_FRAGMENT_DEPTH_EXT");
 739                 }
 740                 break;
 741
 742             case D3DFOG_EXP2:
 743                 glFogi(GL_FOG_MODE, GL_EXP2);
 744                 checkGLcall("glFogi(GL_FOG_MODE, GL_EXP2");
 745                 if(GL_SUPPORT(EXT_FOG_COORD)) {
 746                     glFogi(GL_FOG_COORDINATE_SOURCE_EXT, GL_FRAGMENT_DEPTH_EXT);
 747                     checkGLcall("glFogi(GL_FOG_COORDINATE_SOURCE_EXT, GL_FRAGMENT_DEPTH_EXT");
 748                 }
 749                 break;
 750
 751             case D3DFOG_LINEAR:
 752                 glFogi(GL_FOG_MODE, GL_LINEAR);
 753                 checkGLcall("glFogi(GL_FOG_MODE, GL_LINEAR");
 754                 if(GL_SUPPORT(EXT_FOG_COORD)) {
 755                     glFogi(GL_FOG_COORDINATE_SOURCE_EXT, GL_FRAGMENT_DEPTH_EXT);
 756                     checkGLcall("glFogi(GL_FOG_COORDINATE_SOURCE_EXT, GL_FRAGMENT_DEPTH_EXT");
 757                 }
 758                 break;
 759
 760             case D3DFOG_NONE:   /* Won't happen */
 761             default:
 762                 FIXME("Unexpected WINED3DRS_FOGTABLEMODE %d\n", stateblock->renderState[WINED3DRS_FOGTABLEMODE]);
 763         }
 764     }
 765
 766     if(fogenable) {
 767         glEnable(GL_FOG);
 768         checkGLcall("glEnable GL_FOG");
 769
 770         glFogfv(GL_FOG_START, &fogstart);
 771         checkGLcall("glFogf(GL_FOG_START, fogstart");
 772         TRACE("Fog Start == %f\n", fogstart);
 773
 774         glFogfv(GL_FOG_END, &fogend);
 775         checkGLcall("glFogf(GL_FOG_END, fogend");
 776         TRACE("Fog End == %f\n", fogend);
 777     } else {
 778         glDisable(GL_FOG);
 779         checkGLcall("glDisable GL_FOG");
 780     }
 781
 782     if (GL_SUPPORT(NV_FOG_DISTANCE)) {
 783         glFogi(GL_FOG_DISTANCE_MODE_NV, GL_EYE_PLANE_ABSOLUTE_NV);
 784     }
 785 }
 786
 787 static void state_fogcolor(DWORD state, IWineD3DStateBlockImpl *stateblock) {
 788     float col[4];
 789     D3DCOLORTOGLFLOAT4(stateblock->renderState[WINED3DRS_FOGCOLOR], col);
 790     /* Set the default alpha blend color */
 791     glFogfv(GL_FOG_COLOR, &col[0]);
 792     checkGLcall("glFog GL_FOG_COLOR");
 793 }
 794
 795 static void state_fogdensity(DWORD state, IWineD3DStateBlockImpl *stateblock) {
 796     union {
 797         DWORD d;
 798         float f;
 799     } tmpvalue;
 800     tmpvalue.d = stateblock->renderState[WINED3DRS_FOGDENSITY];
 801     glFogfv(GL_FOG_DENSITY, &tmpvalue.f);
 802     checkGLcall("glFogf(GL_FOG_DENSITY, (float) Value)");
 803 }
 804
 805 /* TODO: Merge with primitive type + init_materials()!! */
 806 static void state_colormat(DWORD state, IWineD3DStateBlockImpl *stateblock) {
 807     GLenum Parm = GL_AMBIENT_AND_DIFFUSE;
 808
 809     if (stateblock->renderState[WINED3DRS_COLORVERTEX]) {
 810         TRACE("diff %d, amb %d, emis %d, spec %d\n",
 811               stateblock->renderState[WINED3DRS_DIFFUSEMATERIALSOURCE],
 812               stateblock->renderState[WINED3DRS_AMBIENTMATERIALSOURCE],
 813               stateblock->renderState[WINED3DRS_EMISSIVEMATERIALSOURCE],
 814               stateblock->renderState[WINED3DRS_SPECULARMATERIALSOURCE]);
 815
 816         if (stateblock->renderState[WINED3DRS_DIFFUSEMATERIALSOURCE] == D3DMCS_COLOR1) {
 817             if (stateblock->renderState[WINED3DRS_AMBIENTMATERIALSOURCE] == D3DMCS_COLOR1) {
 818                 Parm = GL_AMBIENT_AND_DIFFUSE;
 819             } else {
 820                 Parm = GL_DIFFUSE;
 821             }
 822         } else if (stateblock->renderState[WINED3DRS_AMBIENTMATERIALSOURCE] == D3DMCS_COLOR1) {
 823             Parm = GL_AMBIENT;
 824         } else if (stateblock->renderState[WINED3DRS_EMISSIVEMATERIALSOURCE] == D3DMCS_COLOR1) {
 825             Parm = GL_EMISSION;
 826         } else if (stateblock->renderState[WINED3DRS_SPECULARMATERIALSOURCE] == D3DMCS_COLOR1) {
 827             Parm = GL_SPECULAR;
 828         } else {
 829             Parm = -1;
 830         }
 831
 832         if (Parm == -1) {
 833             if (stateblock->wineD3DDevice->tracking_color != DISABLED_TRACKING) stateblock->wineD3DDevice->tracking_color = NEEDS_DISABLE;
 834         } else {
 835             stateblock->wineD3DDevice->tracking_color = NEEDS_TRACKING;
 836             stateblock->wineD3DDevice->tracking_parm  = Parm;
 837         }
 838
 839     } else {
 840         if (stateblock->wineD3DDevice->tracking_color != DISABLED_TRACKING) stateblock->wineD3DDevice->tracking_color = NEEDS_DISABLE;
 841     }
 842 }
 843
 844 static void state_linepattern(DWORD state, IWineD3DStateBlockImpl *stateblock) {
 845     union {
 846         DWORD                 d;
 847         WINED3DLINEPATTERN    lp;
 848     } tmppattern;
 849     tmppattern.d = stateblock->renderState[WINED3DRS_LINEPATTERN];
 850
 851     TRACE("Line pattern: repeat %d bits %x\n", tmppattern.lp.wRepeatFactor, tmppattern.lp.wLinePattern);
 852
 853     if (tmppattern.lp.wRepeatFactor) {
 854         glLineStipple(tmppattern.lp.wRepeatFactor, tmppattern.lp.wLinePattern);
 855         checkGLcall("glLineStipple(repeat, linepattern)");
 856         glEnable(GL_LINE_STIPPLE);
 857         checkGLcall("glEnable(GL_LINE_STIPPLE);");
 858     } else {
 859         glDisable(GL_LINE_STIPPLE);
 860         checkGLcall("glDisable(GL_LINE_STIPPLE);");
 861     }
 862 }
 863
 864 static void state_zbias(DWORD state, IWineD3DStateBlockImpl *stateblock) {
 865     union {
 866         DWORD d;
 867         float f;
 868     } tmpvalue;
 869
 870     if (stateblock->renderState[WINED3DRS_ZBIAS]) {
 871         tmpvalue.d = stateblock->renderState[WINED3DRS_ZBIAS];
 872         TRACE("ZBias value %f\n", tmpvalue.f);
 873         glPolygonOffset(0, -tmpvalue.f);
 874         checkGLcall("glPolygonOffset(0, -Value)");
 875         glEnable(GL_POLYGON_OFFSET_FILL);
 876         checkGLcall("glEnable(GL_POLYGON_OFFSET_FILL);");
 877         glEnable(GL_POLYGON_OFFSET_LINE);
 878         checkGLcall("glEnable(GL_POLYGON_OFFSET_LINE);");
 879         glEnable(GL_POLYGON_OFFSET_POINT);
 880         checkGLcall("glEnable(GL_POLYGON_OFFSET_POINT);");
 881     } else {
 882         glDisable(GL_POLYGON_OFFSET_FILL);
 883         checkGLcall("glDisable(GL_POLYGON_OFFSET_FILL);");
 884         glDisable(GL_POLYGON_OFFSET_LINE);
 885         checkGLcall("glDisable(GL_POLYGON_OFFSET_LINE);");
 886         glDisable(GL_POLYGON_OFFSET_POINT);
 887         checkGLcall("glDisable(GL_POLYGON_OFFSET_POINT);");
 888     }
 889 }
 890
 891
 892 static void state_normalize(DWORD state, IWineD3DStateBlockImpl *stateblock) {
 893     if (stateblock->renderState[WINED3DRS_NORMALIZENORMALS]) {
 894         glEnable(GL_NORMALIZE);
 895         checkGLcall("glEnable(GL_NORMALIZE);");
 896     } else {
 897         glDisable(GL_NORMALIZE);
 898         checkGLcall("glDisable(GL_NORMALIZE);");
 899     }
 900 }
 901
 902 static void state_psize(DWORD state, IWineD3DStateBlockImpl *stateblock) {
 903     union {
 904         DWORD d;
 905         float f;
 906     } tmpvalue;
 907
 908     /* FIXME: check that pointSize isn't outside glGetFloatv( GL_POINT_SIZE_MAX_ARB, &maxSize ); or -ve */
 909     tmpvalue.d = stateblock->renderState[WINED3DRS_POINTSIZE];
 910     TRACE("Set point size to %f\n", tmpvalue.f);
 911     glPointSize(tmpvalue.f);
 912     checkGLcall("glPointSize(...);");
 913 }
 914
 915 static void state_psizemin(DWORD state, IWineD3DStateBlockImpl *stateblock) {
 916     union {
 917         DWORD d;
 918         float f;
 919     } tmpvalue;
 920
 921     if (GL_SUPPORT(EXT_POINT_PARAMETERS)) {
 922         tmpvalue.d = stateblock->renderState[WINED3DRS_POINTSIZE_MIN];
 923         GL_EXTCALL(glPointParameterfEXT)(GL_POINT_SIZE_MIN_EXT, tmpvalue.f);
 924         checkGLcall("glPointParameterfEXT(...);");
 925     } else {
 926         FIXME("WINED3DRS_POINTSIZE_MIN not supported on this opengl\n");
 927     }
 928 }
 929
 930 static void state_psizemax(DWORD state, IWineD3DStateBlockImpl *stateblock) {
 931     union {
 932         DWORD d;
 933         float f;
 934     } tmpvalue;
 935
 936     if (GL_SUPPORT(EXT_POINT_PARAMETERS)) {
 937         tmpvalue.d = stateblock->renderState[WINED3DRS_POINTSIZE_MAX];
 938         GL_EXTCALL(glPointParameterfEXT)(GL_POINT_SIZE_MAX_EXT, tmpvalue.f);
 939         checkGLcall("glPointParameterfEXT(...);");
 940     } else {
 941         FIXME("WINED3DRS_POINTSIZE_MAX not supported on this opengl\n");
 942     }
 943 }
 944
 945 static void state_pscale(DWORD state, IWineD3DStateBlockImpl *stateblock) {
 946     /* TODO: Group this with the viewport */
 947     /*
 948      * POINTSCALEENABLE controls how point size value is treated. If set to
 949      * true, the point size is scaled with respect to height of viewport.
 950      * When set to false point size is in pixels.
 951      *
 952      * http://msdn.microsoft.com/library/en-us/directx9_c/point_sprites.asp
 953      */
 954
 955     /* Default values */
 956     GLfloat att[3] = {1.0f, 0.0f, 0.0f};
 957
 958     /*
 959      * Minimum valid point size for OpenGL is 1.0f. For Direct3D it is 0.0f.
 960      * This means that OpenGL will clamp really small point sizes to 1.0f.
 961      * To correct for this we need to multiply by the scale factor when sizes
 962      * are less than 1.0f. scale_factor =  1.0f / point_size.
 963      */
 964     GLfloat pointSize = *((float*)&stateblock->renderState[WINED3DRS_POINTSIZE]);
 965     if(pointSize > 0.0f) {
 966         GLfloat scaleFactor;
 967
 968         if(pointSize < 1.0f) {
 969             scaleFactor = pointSize * pointSize;
 970         } else {
 971             scaleFactor = 1.0f;
 972         }
 973
 974         if(stateblock->renderState[WINED3DRS_POINTSCALEENABLE]) {
 975             att[0] = *((float*)&stateblock->renderState[WINED3DRS_POINTSCALE_A]) /
 976                     (stateblock->viewport.Height * stateblock->viewport.Height * scaleFactor);
 977             att[1] = *((float*)&stateblock->renderState[WINED3DRS_POINTSCALE_B]) /
 978                     (stateblock->viewport.Height * stateblock->viewport.Height * scaleFactor);
 979             att[2] = *((float*)&stateblock->renderState[WINED3DRS_POINTSCALE_C]) /
 980                     (stateblock->viewport.Height * stateblock->viewport.Height * scaleFactor);
 981         }
 982     }
 983
 984     if(GL_SUPPORT(ARB_POINT_PARAMETERS)) {
 985         GL_EXTCALL(glPointParameterfvARB)(GL_POINT_DISTANCE_ATTENUATION_ARB, att);
 986         checkGLcall("glPointParameterfvARB(GL_DISTANCE_ATTENUATION_ARB, ...");
 987     }
 988     else if(GL_SUPPORT(EXT_POINT_PARAMETERS)) {
 989         GL_EXTCALL(glPointParameterfvEXT)(GL_DISTANCE_ATTENUATION_EXT, att);
 990         checkGLcall("glPointParameterfvEXT(GL_DISTANCE_ATTENUATION_EXT, ...");
 991     } else {
 992         TRACE("POINT_PARAMETERS not supported in this version of opengl\n");
 993     }
 994 }
 995
 996 static void state_colorwrite(DWORD state, IWineD3DStateBlockImpl *stateblock) {
 997     DWORD Value = stateblock->renderState[WINED3DRS_COLORWRITEENABLE];
 998
 999     TRACE("Color mask: r(%d) g(%d) b(%d) a(%d)\n",
1000         Value & D3DCOLORWRITEENABLE_RED   ? 1 : 0,
1001         Value & D3DCOLORWRITEENABLE_GREEN ? 1 : 0,
1002         Value & D3DCOLORWRITEENABLE_BLUE  ? 1 : 0,
1003         Value & D3DCOLORWRITEENABLE_ALPHA ? 1 : 0);
1004     glColorMask(Value & D3DCOLORWRITEENABLE_RED   ? GL_TRUE : GL_FALSE,
1005                 Value & D3DCOLORWRITEENABLE_GREEN ? GL_TRUE : GL_FALSE,
1006                 Value & D3DCOLORWRITEENABLE_BLUE  ? GL_TRUE : GL_FALSE,
1007                 Value & D3DCOLORWRITEENABLE_ALPHA ? GL_TRUE : GL_FALSE);
1008     checkGLcall("glColorMask(...)");
1009
1010     /* depends on WINED3DRS_COLORWRITEENABLE. */
1011     if(stateblock->renderState[WINED3DRS_COLORWRITEENABLE1] != 0x0000000F ||
1012        stateblock->renderState[WINED3DRS_COLORWRITEENABLE2] != 0x0000000F ||
1013        stateblock->renderState[WINED3DRS_COLORWRITEENABLE3] != 0x0000000F ) {
1014         ERR("(WINED3DRS_COLORWRITEENABLE1/2/3,%d,%d,%d) not yet implemented. Missing of cap D3DPMISCCAPS_INDEPENDENTWRITEMASKS wasn't honored?\n",
1015             stateblock->renderState[WINED3DRS_COLORWRITEENABLE1],
1016             stateblock->renderState[WINED3DRS_COLORWRITEENABLE2],
1017             stateblock->renderState[WINED3DRS_COLORWRITEENABLE3]);
1018     }
1019 }
1020
1021 static void state_localviewer(DWORD state, IWineD3DStateBlockImpl *stateblock) {
1022     if(stateblock->renderState[WINED3DRS_LOCALVIEWER]) {
1023         glLightModeli(GL_LIGHT_MODEL_LOCAL_VIEWER, 1);
1024         checkGLcall("glLightModeli(GL_LIGHT_MODEL_LOCAL_VIEWER, 1)");
1025     } else {
1026         glLightModeli(GL_LIGHT_MODEL_LOCAL_VIEWER, 0);
1027         checkGLcall("glLightModeli(GL_LIGHT_MODEL_LOCAL_VIEWER, 0)");
1028     }
1029 }
1030
1031 static void state_lastpixel(DWORD state, IWineD3DStateBlockImpl *stateblock) {
1032     if(stateblock->renderState[WINED3DRS_LASTPIXEL]) {
1033         TRACE("Last Pixel Drawing Enabled\n");
1034     } else {
1035         FIXME("Last Pixel Drawing Disabled, not handled yet\n");
1036     }
1037 }
1038
1039 static void state_pointsprite(DWORD state, IWineD3DStateBlockImpl *stateblock) {
1040     /* TODO: NV_POINT_SPRITE */
1041     if (!GL_SUPPORT(ARB_POINT_SPRITE)) {
1042         TRACE("Point sprites not supported\n");
1043         return;
1044     }
1045
1046     /*
1047      * Point sprites are always enabled. Value controls texture coordinate
1048      * replacement mode. Must be set true for point sprites to use
1049      * textures.
1050      */
1051     glEnable(GL_POINT_SPRITE_ARB);
1052     checkGLcall("glEnable(GL_POINT_SPRITE_ARB)");
1053
1054     if (stateblock->renderState[WINED3DRS_POINTSPRITEENABLE]) {
1055         glTexEnvf(GL_POINT_SPRITE_ARB, GL_COORD_REPLACE_ARB, TRUE);
1056         checkGLcall("glTexEnvf(GL_POINT_SPRITE, GL_COORD_REPLACE, TRUE)");
1057     } else {
1058         glTexEnvf(GL_POINT_SPRITE_ARB, GL_COORD_REPLACE_ARB, FALSE);
1059         checkGLcall("glTexEnvf(GL_POINT_SPRITE, GL_COORD_REPLACE, FALSE)");
1060     }
1061 }
1062
1063 static void state_wrap(DWORD state, IWineD3DStateBlockImpl *stateblock) {
1064     /**
1065      http://www.cosc.brocku.ca/Offerings/3P98/course/lectures/texture/
1066      http://msdn.microsoft.com/archive/default.asp?url=/archive/en-us/directx9_c/directx/graphics/programmingguide/FixedFunction/Textures/texturewrapping.asp
1067      http://www.gamedev.net/reference/programming/features/rendererdll3/page2.asp
1068      Descussion that ways to turn on WRAPing to solve an opengl conversion problem.
1069      http://www.flipcode.org/cgi-bin/fcmsg.cgi?thread_show=10248
1070
1071      so far as I can tell, wrapping and texture-coordinate generate go hand in hand,
1072      */
1073     TRACE("Stub\n");
1074     if(stateblock->renderState[WINED3DRS_WRAP0] ||
1075        stateblock->renderState[WINED3DRS_WRAP1] ||
1076        stateblock->renderState[WINED3DRS_WRAP2] ||
1077        stateblock->renderState[WINED3DRS_WRAP3] ||
1078        stateblock->renderState[WINED3DRS_WRAP4] ||
1079        stateblock->renderState[WINED3DRS_WRAP5] ||
1080        stateblock->renderState[WINED3DRS_WRAP6] ||
1081        stateblock->renderState[WINED3DRS_WRAP7] ||
1082        stateblock->renderState[WINED3DRS_WRAP8] ||
1083        stateblock->renderState[WINED3DRS_WRAP9] ||
1084        stateblock->renderState[WINED3DRS_WRAP10] ||
1085        stateblock->renderState[WINED3DRS_WRAP11] ||
1086        stateblock->renderState[WINED3DRS_WRAP12] ||
1087        stateblock->renderState[WINED3DRS_WRAP13] ||
1088        stateblock->renderState[WINED3DRS_WRAP14] ||
1089        stateblock->renderState[WINED3DRS_WRAP15] ) {
1090         ERR("(WINED3DRS_WRAP0) Texture wraping not yet supported\n");
1091     }
1092 }
1093
1094 static void state_multisampleaa(DWORD state, IWineD3DStateBlockImpl *stateblock) {
1095     if( GL_SUPPORT(ARB_MULTISAMPLE) ) {
1096         if(stateblock->renderState[WINED3DRS_MULTISAMPLEANTIALIAS]) {
1097             glEnable(GL_MULTISAMPLE_ARB);
1098             checkGLcall("glEnable(GL_MULTISAMPLE_ARB)");
1099         } else {
1100             glDisable(GL_MULTISAMPLE_ARB);
1101             checkGLcall("glDisable(GL_MULTISAMPLE_ARB)");
1102         }
1103     } else {
1104         if(stateblock->renderState[WINED3DRS_MULTISAMPLEANTIALIAS]) {
1105             ERR("Multisample antialiasing not supported by gl\n");
1106         }
1107     }
1108 }
1109
1110 static void state_scissor(DWORD state, IWineD3DStateBlockImpl *stateblock) {
1111     if(stateblock->renderState[WINED3DRS_SCISSORTESTENABLE]) {
1112         glEnable(GL_SCISSOR_TEST);
1113         checkGLcall("glEnable(GL_SCISSOR_TEST)");
1114     } else {
1115         glDisable(GL_SCISSOR_TEST);
1116         checkGLcall("glDisable(GL_SCISSOR_TEST)");
1117     }
1118 }
1119
1120 static void state_depthbias(DWORD state, IWineD3DStateBlockImpl *stateblock) {
1121     union {
1122         DWORD d;
1123         float f;
1124     } tmpvalue;
1125
1126     if(stateblock->renderState[WINED3DRS_SLOPESCALEDEPTHBIAS] ||
1127        stateblock->renderState[WINED3DRS_DEPTHBIAS]) {
1128         tmpvalue.d = stateblock->renderState[WINED3DRS_SLOPESCALEDEPTHBIAS];
1129         glEnable(GL_POLYGON_OFFSET_FILL);
1130         checkGLcall("glEnable(GL_POLYGON_OFFSET_FILL)");
1131         glPolygonOffset(tmpvalue.f, *((float*)&stateblock->renderState[WINED3DRS_DEPTHBIAS]));
1132         checkGLcall("glPolygonOffset(...)");
1133     } else {
1134         glDisable(GL_POLYGON_OFFSET_FILL);
1135         checkGLcall("glDisable(GL_POLYGON_OFFSET_FILL)");
1136     }
1137 }
1138
1139 static void state_perspective(DWORD state, IWineD3DStateBlockImpl *stateblock) {
1140     if (stateblock->renderState[WINED3DRS_TEXTUREPERSPECTIVE]) {
1141         glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);
1142         checkGLcall("glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST)");
1143     } else {
1144         glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_FASTEST);
1145         checkGLcall("glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_FASTEST)");
1146     }
1147 }
1148
1149 static void state_stippledalpha(DWORD state, IWineD3DStateBlockImpl *stateblock) {
1150     TRACE("Stub\n");
1151     if (stateblock->renderState[WINED3DRS_STIPPLEDALPHA])
1152         ERR(" Stippled Alpha not supported yet.\n");
1153 }
1154
1155 static void state_antialias(DWORD state, IWineD3DStateBlockImpl *stateblock) {
1156     TRACE("Stub\n");
1157     if (stateblock->renderState[WINED3DRS_ANTIALIAS])
1158         ERR(" Antialias not supported yet.\n");
1159 }
1160
1161 static void state_multisampmask(DWORD state, IWineD3DStateBlockImpl *stateblock) {
1162     TRACE("Stub\n");
1163     if (stateblock->renderState[WINED3DRS_MULTISAMPLEMASK] != 0xFFFFFFFF)
1164         ERR("(WINED3DRS_MULTISAMPLEMASK,%d) not yet implemented\n", stateblock->renderState[WINED3DRS_MULTISAMPLEMASK]);
1165 }
1166
1167 static void state_patchedgestyle(DWORD state, IWineD3DStateBlockImpl *stateblock) {
1168     TRACE("Stub\n");
1169     if (stateblock->renderState[WINED3DRS_PATCHEDGESTYLE] != D3DPATCHEDGE_DISCRETE)
1170         ERR("(WINED3DRS_PATCHEDGESTYLE,%d) not yet implemented\n", stateblock->renderState[WINED3DRS_PATCHEDGESTYLE]);
1171 }
1172
1173 static void state_patchsegments(DWORD state, IWineD3DStateBlockImpl *stateblock) {
1174     union {
1175         DWORD d;
1176         float f;
1177     } tmpvalue;
1178     tmpvalue.f = 1.0f;
1179
1180     TRACE("Stub\n");
1181     if (stateblock->renderState[WINED3DRS_PATCHSEGMENTS] != tmpvalue.d)
1182         ERR("(WINED3DRS_PATCHSEGMENTS,%d) not yet implemented\n", tmpvalue.d);
1183 }
1184
1185 static void state_positiondegree(DWORD state, IWineD3DStateBlockImpl *stateblock) {
1186     TRACE("Stub\n");
1187     if (stateblock->renderState[WINED3DRS_POSITIONDEGREE] != D3DDEGREE_CUBIC)
1188         ERR("(WINED3DRS_POSITIONDEGREE,%d) not yet implemented\n", stateblock->renderState[WINED3DRS_POSITIONDEGREE]);
1189 }
1190
1191 static void state_normaldegree(DWORD state, IWineD3DStateBlockImpl *stateblock) {
1192     TRACE("Stub\n");
1193     if (stateblock->renderState[WINED3DRS_NORMALDEGREE] != D3DDEGREE_LINEAR)
1194         ERR("(WINED3DRS_NORMALDEGREE,%d) not yet implemented\n", stateblock->renderState[WINED3DRS_NORMALDEGREE]);
1195 }
1196
1197 static void state_tessellation(DWORD state, IWineD3DStateBlockImpl *stateblock) {
1198     TRACE("Stub\n");
1199     if(stateblock->renderState[WINED3DRS_ENABLEADAPTIVETESSELLATION])
1200         FIXME("(WINED3DRS_ENABLEADAPTIVETESSELLATION,%d) not yet implemented\n", stateblock->renderState[WINED3DRS_ENABLEADAPTIVETESSELLATION]);
1201 }
1202
1203
1204 static void state_srgbwrite(DWORD state, IWineD3DStateBlockImpl *stateblock) {
1205     if(stateblock->renderState[WINED3DRS_SRGBWRITEENABLE])
1206         ERR("Render state WINED3DRS_SRGBWRITEENABLE not yet implemented\n");
1207 }
1208
1209 static void state_seperateblend(DWORD state, IWineD3DStateBlockImpl *stateblock) {
1210     TRACE("Stub\n");
1211     if(stateblock->renderState[WINED3DRS_SEPARATEALPHABLENDENABLE])
1212         FIXME("(WINED3DRS_SEPARATEALPHABLENDENABLE,%d) not yet implemented\n", stateblock->renderState[WINED3DRS_SEPARATEALPHABLENDENABLE]);
1213 }
1214
1215 static void state_wrapu(DWORD state, IWineD3DStateBlockImpl *stateblock) {
1216     if(stateblock->renderState[WINED3DRS_WRAPU]) {
1217         FIXME("Render state WINED3DRS_WRAPU not implemented yet\n");
1218     }
1219 }
1220
1221 static void state_wrapv(DWORD state, IWineD3DStateBlockImpl *stateblock) {
1222     if(stateblock->renderState[WINED3DRS_WRAPV]) {
1223         FIXME("Render state WINED3DRS_WRAPV not implemented yet\n");
1224     }
1225 }
1226
1227 static void state_monoenable(DWORD state, IWineD3DStateBlockImpl *stateblock) {
1228     if(stateblock->renderState[WINED3DRS_MONOENABLE]) {
1229         FIXME("Render state WINED3DRS_MONOENABLE not implemented yet\n");
1230     }
1231 }
1232
1233 static void state_rop2(DWORD state, IWineD3DStateBlockImpl *stateblock) {
1234     if(stateblock->renderState[WINED3DRS_ROP2]) {
1235         FIXME("Render state WINED3DRS_ROP2 not implemented yet\n");
1236     }
1237 }
1238
1239 static void state_planemask(DWORD state, IWineD3DStateBlockImpl *stateblock) {
1240     if(stateblock->renderState[WINED3DRS_PLANEMASK]) {
1241         FIXME("Render state WINED3DRS_PLANEMASK not implemented yet\n");
1242     }
1243 }
1244
1245 static void state_subpixel(DWORD state, IWineD3DStateBlockImpl *stateblock) {
1246     if(stateblock->renderState[WINED3DRS_SUBPIXEL]) {
1247         FIXME("Render state WINED3DRS_SUBPIXEL not implemented yet\n");
1248     }
1249 }
1250
1251 static void state_subpixelx(DWORD state, IWineD3DStateBlockImpl *stateblock) {
1252     if(stateblock->renderState[WINED3DRS_SUBPIXELX]) {
1253         FIXME("Render state WINED3DRS_SUBPIXELX not implemented yet\n");
1254     }
1255 }
1256
1257 static void state_stippleenable(DWORD state, IWineD3DStateBlockImpl *stateblock) {
1258     if(stateblock->renderState[WINED3DRS_STIPPLEENABLE]) {
1259         FIXME("Render state WINED3DRS_STIPPLEENABLE not implemented yet\n");
1260     }
1261 }
1262
1263 static void state_bordercolor(DWORD state, IWineD3DStateBlockImpl *stateblock) {
1264     if(stateblock->renderState[WINED3DRS_BORDERCOLOR]) {
1265         FIXME("Render state WINED3DRS_BORDERCOLOR not implemented yet\n");
1266     }
1267 }
1268
1269 static void state_mipmaplodbias(DWORD state, IWineD3DStateBlockImpl *stateblock) {
1270     if(stateblock->renderState[WINED3DRS_MIPMAPLODBIAS]) {
1271         FIXME("Render state WINED3DRS_MIPMAPLODBIAS not implemented yet\n");
1272     }
1273 }
1274
1275 static void state_anisotropy(DWORD state, IWineD3DStateBlockImpl *stateblock) {
1276     if(stateblock->renderState[WINED3DRS_ANISOTROPY]) {
1277         FIXME("Render state WINED3DRS_ANISOTROPY not implemented yet\n");
1278     }
1279 }
1280
1281 static void state_flushbatch(DWORD state, IWineD3DStateBlockImpl *stateblock) {
1282     if(stateblock->renderState[WINED3DRS_FLUSHBATCH]) {
1283         FIXME("Render state WINED3DRS_FLUSHBATCH not implemented yet\n");
1284     }
1285 }
1286
1287 static void state_translucentsi(DWORD state, IWineD3DStateBlockImpl *stateblock) {
1288     if(stateblock->renderState[WINED3DRS_TRANSLUCENTSORTINDEPENDENT]) {
1289         FIXME("Render state WINED3DRS_TRANSLUCENTSORTINDEPENDENT not implemented yet\n");
1290     }
1291 }
1292
1293 static void state_extents(DWORD state, IWineD3DStateBlockImpl *stateblock) {
1294     if(stateblock->renderState[WINED3DRS_EXTENTS]) {
1295         FIXME("Render state WINED3DRS_EXTENTS not implemented yet\n");
1296     }
1297 }
1298
1299 static void state_ckeyblend(DWORD state, IWineD3DStateBlockImpl *stateblock) {
1300     if(stateblock->renderState[WINED3DRS_COLORKEYBLENDENABLE]) {
1301         FIXME("Render state WINED3DRS_COLORKEYBLENDENABLE not implemented yet\n");
1302     }
1303 }
1304
1305 /* Activates the texture dimension according to the bound D3D texture.
1306  * Does not care for the colorop or correct gl texture unit(when using nvrc)
1307  * Requires the caller to activate the correct unit before
1308  */
1309 static void activate_dimensions(DWORD stage, IWineD3DStateBlockImpl *stateblock) {
1310     if(stateblock->textures[stage]) {
1311         glDisable(GL_TEXTURE_1D);
1312         checkGLcall("glDisable(GL_TEXTURE_1D)");
1313         switch(stateblock->textureDimensions[stage]) {
1314             case GL_TEXTURE_2D:
1315                 glDisable(GL_TEXTURE_3D);
1316                 checkGLcall("glDisable(GL_TEXTURE_3D)");
1317                 glDisable(GL_TEXTURE_CUBE_MAP_ARB);
1318                 checkGLcall("glDisable(GL_TEXTURE_CUBE_MAP_ARB)");
1319                 glEnable(GL_TEXTURE_2D);
1320                 checkGLcall("glEnable(GL_TEXTURE_2D)");
1321                 break;
1322             case GL_TEXTURE_3D:
1323                 glDisable(GL_TEXTURE_CUBE_MAP_ARB);
1324                 checkGLcall("glDisable(GL_TEXTURE_CUBE_MAP_ARB)");
1325                 glDisable(GL_TEXTURE_2D);
1326                 checkGLcall("glDisable(GL_TEXTURE_2D)");
1327                 glEnable(GL_TEXTURE_3D);
1328                 checkGLcall("glEnable(GL_TEXTURE_3D)");
1329                 break;
1330             case GL_TEXTURE_CUBE_MAP_ARB:
1331                 glDisable(GL_TEXTURE_2D);
1332                 checkGLcall("glDisable(GL_TEXTURE_2D)");
1333                 glDisable(GL_TEXTURE_3D);
1334                 checkGLcall("glDisable(GL_TEXTURE_3D)");
1335                 glEnable(GL_TEXTURE_CUBE_MAP_ARB);
1336                 checkGLcall("glEnable(GL_TEXTURE_CUBE_MAP_ARB)");
1337                 break;
1338         }
1339     } else {
1340         glDisable(GL_TEXTURE_2D);
1341         checkGLcall("glDisable(GL_TEXTURE_2D)");
1342         glDisable(GL_TEXTURE_3D);
1343         checkGLcall("glDisable(GL_TEXTURE_3D)");
1344         glDisable(GL_TEXTURE_CUBE_MAP_ARB);
1345         checkGLcall("glDisable(GL_TEXTURE_CUBE_MAP_ARB)");
1346         glEnable(GL_TEXTURE_1D);
1347         checkGLcall("glEnable(GL_TEXTURE_1D)");
1348         /* Binding textures is done by samplers. A dummy texture will be bound */
1349     }
1350 }
1351
1352 static void tex_colorop(DWORD state, IWineD3DStateBlockImpl *stateblock) {
1353     DWORD stage = (state - STATE_TEXTURESTAGE(0, 0)) / WINED3D_HIGHEST_TEXTURE_STATE;
1354
1355     TRACE("Setting color op for stage %d\n", stage);
1356
1357     if (stateblock->pixelShader && stateblock->wineD3DDevice->ps_selected_mode != SHADER_NONE &&
1358         ((IWineD3DPixelShaderImpl *)stateblock->pixelShader)->baseShader.function) {
1359         /* Using a pixel shader? Don't care for anything here, the shader applying does it */
1360         return;
1361     }
1362
1363     if (GL_SUPPORT(ARB_MULTITEXTURE)) {
1364         /* TODO: register combiners! */
1365         if(stage != stateblock->wineD3DDevice->texUnitMap[stage]) ERR("Foo: %d is %d!\n", stage, stateblock->wineD3DDevice->texUnitMap[stage]);
1366         if(stateblock->wineD3DDevice->texUnitMap[stage] >= GL_LIMITS(sampler_stages)) {
1367             if(stateblock->textureState[stage][WINED3DTSS_COLOROP] != WINED3DTOP_DISABLE &&
1368               stateblock->textureState[stage][WINED3DTSS_COLOROP] != 0) {
1369                 FIXME("Attempt to enable unsupported stage!\n");
1370             }
1371             return;
1372         }
1373         GL_EXTCALL(glActiveTextureARB(GL_TEXTURE0_ARB + stateblock->wineD3DDevice->texUnitMap[stage]));
1374         checkGLcall("glActiveTextureARB");
1375     } else if (stage > 0) {
1376         WARN("Program using multiple concurrent textures which this opengl implementation doesn't support\n");
1377         return;
1378     }
1379
1380     if (GL_SUPPORT(NV_REGISTER_COMBINERS)) {
1381         if(stateblock->lowest_disabled_stage > 0) {
1382             glEnable(GL_REGISTER_COMBINERS_NV);
1383             GL_EXTCALL(glCombinerParameteriNV(GL_NUM_GENERAL_COMBINERS_NV, stateblock->lowest_disabled_stage));
1384         } else {
1385             glDisable(GL_REGISTER_COMBINERS_NV);
1386         }
1387     }
1388     if(stage >= stateblock->lowest_disabled_stage) {
1389         TRACE("Stage disabled\n");
1390         /* Disable everything here */
1391         glDisable(GL_TEXTURE_1D);
1392         checkGLcall("glDisable(GL_TEXTURE_1D)");
1393         glDisable(GL_TEXTURE_2D);
1394         checkGLcall("glDisable(GL_TEXTURE_2D)");
1395         glDisable(GL_TEXTURE_3D);
1396         checkGLcall("glDisable(GL_TEXTURE_3D)");
1397         glDisable(GL_TEXTURE_CUBE_MAP_ARB);
1398         checkGLcall("glDisable(GL_TEXTURE_CUBE_MAP_ARB)");
1399         /* All done */
1400         return;
1401     }
1402
1403     activate_dimensions(stage, stateblock);
1404
1405     /* Set the texture combiners */
1406     if (GL_SUPPORT(NV_REGISTER_COMBINERS)) {
1407         set_tex_op_nvrc((IWineD3DDevice *)stateblock->wineD3DDevice, FALSE, stage,
1408                          stateblock->textureState[stage][WINED3DTSS_COLOROP],
1409                          stateblock->textureState[stage][WINED3DTSS_COLORARG1],
1410                          stateblock->textureState[stage][WINED3DTSS_COLORARG2],
1411                          stateblock->textureState[stage][WINED3DTSS_COLORARG0],
1412                          stateblock->wineD3DDevice->texUnitMap[stage]);
1413     } else {
1414         set_tex_op((IWineD3DDevice *)stateblock->wineD3DDevice, FALSE, stage,
1415                     stateblock->textureState[stage][WINED3DTSS_COLOROP],
1416                     stateblock->textureState[stage][WINED3DTSS_COLORARG1],
1417                     stateblock->textureState[stage][WINED3DTSS_COLORARG2],
1418                     stateblock->textureState[stage][WINED3DTSS_COLORARG0]);
1419     }
1420 }
1421
1422 static void tex_alphaop(DWORD state, IWineD3DStateBlockImpl *stateblock) {
1423     DWORD stage = (state - STATE_TEXTURESTAGE(0, 0)) / WINED3D_HIGHEST_TEXTURE_STATE;
1424
1425     TRACE("Setting alpha op for stage %d\n", stage);
1426     /* Do not care for enabled / disabled stages, just assign the settigns. colorop disables / enables required stuff */
1427     if (GL_SUPPORT(ARB_MULTITEXTURE)) {
1428         /* TODO: register combiners! */
1429         if(stage >= GL_LIMITS(sampler_stages)) {
1430             if(stateblock->textureState[stage][WINED3DTSS_COLOROP] != WINED3DTOP_DISABLE &&
1431               stateblock->textureState[stage][WINED3DTSS_COLOROP] != 0) {
1432                 FIXME("Attempt to enable unsupported stage!\n");
1433             }
1434             return;
1435         }
1436         GL_EXTCALL(glActiveTextureARB(GL_TEXTURE0_ARB + stateblock->wineD3DDevice->texUnitMap[stage]));
1437         checkGLcall("glActiveTextureARB");
1438     } else if (stage > 0) {
1439         /* We can't do anything here */
1440         WARN("Program using multiple concurrent textures which this opengl implementation doesn't support\n");
1441         return;
1442     }
1443
1444     TRACE("Setting alpha op for stage %d\n", stage);
1445     if (GL_SUPPORT(NV_REGISTER_COMBINERS)) {
1446         set_tex_op_nvrc((IWineD3DDevice *)stateblock->wineD3DDevice, TRUE, stage,
1447                          stateblock->textureState[stage][WINED3DTSS_ALPHAOP],
1448                          stateblock->textureState[stage][WINED3DTSS_ALPHAARG1],
1449                          stateblock->textureState[stage][WINED3DTSS_ALPHAARG2],
1450                          stateblock->textureState[stage][WINED3DTSS_ALPHAARG0],
1451                          stateblock->wineD3DDevice->texUnitMap[stage]);
1452     } else {
1453         set_tex_op((IWineD3DDevice *)stateblock->wineD3DDevice, TRUE, stage, stateblock->textureState[stage][WINED3DTSS_ALPHAOP],
1454                     stateblock->textureState[stage][WINED3DTSS_ALPHAARG1],
1455                     stateblock->textureState[stage][WINED3DTSS_ALPHAARG2],
1456                     stateblock->textureState[stage][WINED3DTSS_ALPHAARG0]);
1457     }
1458 }
1459
1460 static void tex_coordindex(DWORD state, IWineD3DStateBlockImpl *stateblock) {
1461     DWORD stage = (state - STATE_TEXTURESTAGE(0, 0)) / WINED3D_HIGHEST_TEXTURE_STATE;
1462
1463     if (GL_SUPPORT(ARB_MULTITEXTURE)) {
1464         /* TODO: register combiners! */
1465         if(stage >= GL_LIMITS(sampler_stages)) {
1466             return;
1467         }
1468         GL_EXTCALL(glActiveTextureARB(GL_TEXTURE0_ARB + stateblock->wineD3DDevice->texUnitMap[stage]));
1469         checkGLcall("glActiveTextureARB");
1470     } else if (stage > 0) {
1471         /* We can't do anything here */
1472         WARN("Program using multiple concurrent textures which this opengl implementation doesn't support\n");
1473         return;
1474     }
1475
1476     /* Values 0-7 are indexes into the FVF tex coords - See comments in DrawPrimitive
1477      *
1478      * FIXME: From MSDN: The WINED3DTSS_TCI_* flags are mutually exclusive. If you include
1479      * one flag, you can still specify an index value, which the system uses to
1480      * determine the texture wrapping mode.
1481      * eg. SetTextureStageState( 0, WINED3DTSS_TEXCOORDINDEX, WINED3DTSS_TCI_CAMERASPACEPOSITION | 1 );
1482      * means use the vertex position (camera-space) as the input texture coordinates
1483      * for this texture stage, and the wrap mode set in the WINED3DRS_WRAP1 render
1484      * state. We do not (yet) support the WINED3DRENDERSTATE_WRAPx values, nor tie them up
1485      * to the TEXCOORDINDEX value
1486      */
1487
1488     /*
1489      * Be careful the value of the mask 0xF0000 come from d3d8types.h infos
1490      */
1491     switch (stateblock->textureState[stage][WINED3DTSS_TEXCOORDINDEX] & 0xFFFF0000) {
1492     case WINED3DTSS_TCI_PASSTHRU:
1493         /*Use the specified texture coordinates contained within the vertex format. This value resolves to zero.*/
1494         glDisable(GL_TEXTURE_GEN_S);
1495         glDisable(GL_TEXTURE_GEN_T);
1496         glDisable(GL_TEXTURE_GEN_R);
1497         glDisable(GL_TEXTURE_GEN_Q);
1498         checkGLcall("glDisable(GL_TEXTURE_GEN_S,T,R,Q)");
1499         break;
1500
1501     case WINED3DTSS_TCI_CAMERASPACEPOSITION:
1502         /* CameraSpacePosition means use the vertex position, transformed to camera space,
1503          * as the input texture coordinates for this stage's texture transformation. This
1504          * equates roughly to EYE_LINEAR
1505          */
1506         {
1507             float s_plane[] = { 1.0, 0.0, 0.0, 0.0 };
1508             float t_plane[] = { 0.0, 1.0, 0.0, 0.0 };
1509             float r_plane[] = { 0.0, 0.0, 1.0, 0.0 };
1510             float q_plane[] = { 0.0, 0.0, 0.0, 1.0 };
1511             TRACE("WINED3DTSS_TCI_CAMERASPACEPOSITION - Set eye plane\n");
1512
1513             glMatrixMode(GL_MODELVIEW);
1514             glPushMatrix();
1515             glLoadIdentity();
1516             glTexGenfv(GL_S, GL_EYE_PLANE, s_plane);
1517             glTexGenfv(GL_T, GL_EYE_PLANE, t_plane);
1518             glTexGenfv(GL_R, GL_EYE_PLANE, r_plane);
1519             glTexGenfv(GL_Q, GL_EYE_PLANE, q_plane);
1520             glPopMatrix();
1521
1522             TRACE("WINED3DTSS_TCI_CAMERASPACEPOSITION - Set GL_TEXTURE_GEN_x and GL_x, GL_TEXTURE_GEN_MODE, GL_EYE_LINEAR\n");
1523             glEnable(GL_TEXTURE_GEN_S);
1524             checkGLcall("glEnable(GL_TEXTURE_GEN_S);");
1525             glTexGeni(GL_S, GL_TEXTURE_GEN_MODE, GL_EYE_LINEAR);
1526             checkGLcall("glTexGeni(GL_S, GL_TEXTURE_GEN_MODE, GL_EYE_LINEAR)");
1527             glEnable(GL_TEXTURE_GEN_T);
1528             checkGLcall("glEnable(GL_TEXTURE_GEN_T);");
1529             glTexGeni(GL_T, GL_TEXTURE_GEN_MODE, GL_EYE_LINEAR);
1530             checkGLcall("glTexGeni(GL_T, GL_TEXTURE_GEN_MODE, GL_EYE_LINEAR)");
1531             glEnable(GL_TEXTURE_GEN_R);
1532             checkGLcall("glEnable(GL_TEXTURE_GEN_R);");
1533             glTexGeni(GL_R, GL_TEXTURE_GEN_MODE, GL_EYE_LINEAR);
1534             checkGLcall("glTexGeni(GL_R, GL_TEXTURE_GEN_MODE, GL_EYE_LINEAR)");
1535         }
1536         break;
1537
1538     case WINED3DTSS_TCI_CAMERASPACENORMAL:
1539         {
1540             if (GL_SUPPORT(NV_TEXGEN_REFLECTION)) {
1541                 float s_plane[] = { 1.0, 0.0, 0.0, 0.0 };
1542                 float t_plane[] = { 0.0, 1.0, 0.0, 0.0 };
1543                 float r_plane[] = { 0.0, 0.0, 1.0, 0.0 };
1544                 float q_plane[] = { 0.0, 0.0, 0.0, 1.0 };
1545                 TRACE("WINED3DTSS_TCI_CAMERASPACENORMAL - Set eye plane\n");
1546
1547                 glMatrixMode(GL_MODELVIEW);
1548                 glPushMatrix();
1549                 glLoadIdentity();
1550                 glTexGenfv(GL_S, GL_EYE_PLANE, s_plane);
1551                 glTexGenfv(GL_T, GL_EYE_PLANE, t_plane);
1552                 glTexGenfv(GL_R, GL_EYE_PLANE, r_plane);
1553                 glTexGenfv(GL_Q, GL_EYE_PLANE, q_plane);
1554                 glPopMatrix();
1555
1556                 glEnable(GL_TEXTURE_GEN_S);
1557                 checkGLcall("glEnable(GL_TEXTURE_GEN_S);");
1558                 glTexGeni(GL_S, GL_TEXTURE_GEN_MODE, GL_NORMAL_MAP_NV);
1559                 checkGLcall("glTexGeni(GL_S, GL_TEXTURE_GEN_MODE, GL_NORMAL_MAP_NV)");
1560                 glEnable(GL_TEXTURE_GEN_T);
1561                 checkGLcall("glEnable(GL_TEXTURE_GEN_T);");
1562                 glTexGeni(GL_T, GL_TEXTURE_GEN_MODE, GL_NORMAL_MAP_NV);
1563                 checkGLcall("glTexGeni(GL_T, GL_TEXTURE_GEN_MODE, GL_NORMAL_MAP_NV)");
1564                 glEnable(GL_TEXTURE_GEN_R);
1565                 checkGLcall("glEnable(GL_TEXTURE_GEN_R);");
1566                 glTexGeni(GL_R, GL_TEXTURE_GEN_MODE, GL_NORMAL_MAP_NV);
1567                 checkGLcall("glTexGeni(GL_R, GL_TEXTURE_GEN_MODE, GL_NORMAL_MAP_NV)");
1568             }
1569         }
1570         break;
1571
1572     case WINED3DTSS_TCI_CAMERASPACEREFLECTIONVECTOR:
1573         {
1574             if (GL_SUPPORT(NV_TEXGEN_REFLECTION)) {
1575             float s_plane[] = { 1.0, 0.0, 0.0, 0.0 };
1576             float t_plane[] = { 0.0, 1.0, 0.0, 0.0 };
1577             float r_plane[] = { 0.0, 0.0, 1.0, 0.0 };
1578             float q_plane[] = { 0.0, 0.0, 0.0, 1.0 };
1579             TRACE("WINED3DTSS_TCI_CAMERASPACEREFLECTIONVECTOR - Set eye plane\n");
1580
1581             glMatrixMode(GL_MODELVIEW);
1582             glPushMatrix();
1583             glLoadIdentity();
1584             glTexGenfv(GL_S, GL_EYE_PLANE, s_plane);
1585             glTexGenfv(GL_T, GL_EYE_PLANE, t_plane);
1586             glTexGenfv(GL_R, GL_EYE_PLANE, r_plane);
1587             glTexGenfv(GL_Q, GL_EYE_PLANE, q_plane);
1588             glPopMatrix();
1589
1590             glEnable(GL_TEXTURE_GEN_S);
1591             checkGLcall("glEnable(GL_TEXTURE_GEN_S);");
1592             glTexGeni(GL_S, GL_TEXTURE_GEN_MODE, GL_REFLECTION_MAP_NV);
1593             checkGLcall("glTexGeni(GL_S, GL_TEXTURE_GEN_MODE, GL_REFLECTION_MAP_NV)");
1594             glEnable(GL_TEXTURE_GEN_T);
1595             checkGLcall("glEnable(GL_TEXTURE_GEN_T);");
1596             glTexGeni(GL_T, GL_TEXTURE_GEN_MODE, GL_REFLECTION_MAP_NV);
1597             checkGLcall("glTexGeni(GL_T, GL_TEXTURE_GEN_MODE, GL_REFLECTION_MAP_NV)");
1598             glEnable(GL_TEXTURE_GEN_R);
1599             checkGLcall("glEnable(GL_TEXTURE_GEN_R);");
1600             glTexGeni(GL_R, GL_TEXTURE_GEN_MODE, GL_REFLECTION_MAP_NV);
1601             checkGLcall("glTexGeni(GL_R, GL_TEXTURE_GEN_MODE, GL_REFLECTION_MAP_NV)");
1602             }
1603         }
1604         break;
1605
1606     /* Unhandled types: */
1607     default:
1608         /* Todo: */
1609         /* ? disable GL_TEXTURE_GEN_n ? */
1610         glDisable(GL_TEXTURE_GEN_S);
1611         glDisable(GL_TEXTURE_GEN_T);
1612         glDisable(GL_TEXTURE_GEN_R);
1613         glDisable(GL_TEXTURE_GEN_Q);
1614         FIXME("Unhandled WINED3DTSS_TEXCOORDINDEX %x\n", stateblock->textureState[stage][WINED3DTSS_TEXCOORDINDEX]);
1615         break;
1616     }
1617 }
1618
1619 static void tex_bumpenvlscale(DWORD state, IWineD3DStateBlockImpl *stateblock) {
1620     DWORD stage = (state - STATE_TEXTURESTAGE(0, 0)) / WINED3D_HIGHEST_TEXTURE_STATE;
1621     union {
1622         DWORD d;
1623         float f;
1624     } tmpvalue;
1625
1626     tmpvalue.d = stateblock->textureState[stage][WINED3DTSS_BUMPENVLSCALE];
1627     if(tmpvalue.f != 0.0) {
1628         ERR("WINED3DTSS_BUMPENVLSCALE not supported yet\n");
1629     }
1630 }
1631
1632 static void tex_bumpenvloffset(DWORD state, IWineD3DStateBlockImpl *stateblock) {
1633     DWORD stage = (state - STATE_TEXTURESTAGE(0, 0)) / WINED3D_HIGHEST_TEXTURE_STATE;
1634     union {
1635         DWORD d;
1636         float f;
1637     } tmpvalue;
1638
1639     tmpvalue.d = stateblock->textureState[stage][WINED3DTSS_BUMPENVLOFFSET];
1640     if(tmpvalue.f != 0.0) {
1641         ERR("WINED3DTSS_BUMPENVLOFFSET not supported yet\n");
1642     }
1643 }
1644
1645 static void tex_resultarg(DWORD state, IWineD3DStateBlockImpl *stateblock) {
1646     DWORD stage = (state - STATE_TEXTURESTAGE(0, 0)) / WINED3D_HIGHEST_TEXTURE_STATE;
1647
1648     if(stateblock->textureState[stage][WINED3DTSS_RESULTARG] != D3DTA_CURRENT) {
1649         ERR("WINED3DTSS_RESULTARG not supported yet\n");
1650     }
1651 }
1652
1653 static void sampler(DWORD state, IWineD3DStateBlockImpl *stateblock) {
1654     DWORD sampler = state - STATE_SAMPLER(0);
1655
1656     TRACE("Sampler: %d\n", sampler);
1657     /* Enabling and disabling texture dimensions is done by texture stage state / pixel shader setup, this function
1658      * only has to bind textures and set the per texture states
1659      */
1660     if (GL_SUPPORT(ARB_MULTITEXTURE)) {
1661         /* TODO: register combiners! */
1662         if(sampler >= GL_LIMITS(sampler_stages)) {
1663             return;
1664         }
1665         GL_EXTCALL(glActiveTextureARB(GL_TEXTURE0_ARB + stateblock->wineD3DDevice->texUnitMap[sampler]));
1666         checkGLcall("glActiveTextureARB");
1667     } else if (sampler > 0) {
1668         /* We can't do anything here */
1669         WARN("Program using multiple concurrent textures which this opengl implementation doesn't support\n");
1670         return;
1671     }
1672
1673     if(stateblock->textures[sampler]) {
1674         IWineD3DBaseTexture_PreLoad((IWineD3DBaseTexture *) stateblock->textures[sampler]);
1675         IWineD3DDevice_SetupTextureStates((IWineD3DDevice *)stateblock->wineD3DDevice, sampler, sampler, REAPPLY_ALPHAOP);
1676         IWineD3DBaseTexture_ApplyStateChanges(stateblock->textures[sampler], stateblock->textureState[sampler], stateblock->samplerState[sampler]);
1677
1678         if (stateblock->wineD3DDevice->ps_selected_mode != SHADER_NONE && stateblock->pixelShader &&
1679             ((IWineD3DPixelShaderImpl *)stateblock->pixelShader)->baseShader.function) {
1680             /* Using a pixel shader? Verify the sampler types */
1681
1682             /* Make sure that the texture dimensions are enabled. I don't have to disable the other
1683              * dimensions because the shader knows from which texture type to sample from. For the sake of
1684              * debugging all dimensions could be enabled and a texture with some ugly pink bound to the unused
1685              * dimensions. This should make wrong sampling sources visible :-)
1686              */
1687             glEnable(stateblock->textureDimensions[sampler]);
1688             checkGLcall("glEnable(stateblock->textureDimensions[sampler])");
1689         } else if(sampler < stateblock->lowest_disabled_stage) {
1690             activate_dimensions(sampler, stateblock);
1691
1692             if(stateblock->renderState[WINED3DRS_COLORKEYENABLE] && sampler == 0) {
1693                 /* If color keying is enabled update the alpha test, it depends on the existance
1694                  * of a color key in stage 0
1695                  */
1696                 state_alpha(WINED3DRS_COLORKEYENABLE, stateblock);
1697             }
1698         }
1699     } else if(sampler < GL_LIMITS(texture_stages)) {
1700         if(sampler < stateblock->lowest_disabled_stage) {
1701             /* TODO: Check if the colorop is dirty to do that job
1702              * TODO: What should I do with pixel shaders here ???
1703              */
1704             activate_dimensions(sampler, stateblock);
1705         } /* Otherwise tex_colorop disables the stage */
1706         glBindTexture(GL_TEXTURE_1D, stateblock->wineD3DDevice->dummyTextureName[sampler]);
1707         checkGLcall("glBindTexture(GL_TEXTURE_1D, stateblock->wineD3DDevice->dummyTextureName[sampler])");
1708     }
1709 }
1710
1711 static void pixelshader(DWORD state, IWineD3DStateBlockImpl *stateblock) {
1712     int i;
1713
1714     if(stateblock->pixelShader && ((IWineD3DPixelShaderImpl *) stateblock->pixelShader)->baseShader.function != NULL) {
1715         if(!stateblock->wineD3DDevice->last_was_pshader) {
1716             /* Former draw without a pixel shader, some samplers
1717              * may be disabled because of WINED3DTSS_COLOROP = WINED3DTOP_DISABLE
1718              * make sure to enable them
1719              */
1720             for(i=0; i < MAX_SAMPLERS; i++) {
1721                 if(!isStateDirty(stateblock->wineD3DDevice, STATE_SAMPLER(i))) {
1722                     sampler(STATE_SAMPLER(i), stateblock);
1723                 }
1724             }
1725         } else {
1726            /* Otherwise all samplers were activated by the code above in earlier draws, or by sampler()
1727             * if a different texture was bound. I don't have to do anything.
1728             */
1729         }
1730
1731         /* Compile and bind the shader */
1732         IWineD3DPixelShader_CompileShader(stateblock->pixelShader);
1733
1734 #if 0
1735         /* Can't do that here right now, because glsl shaders depend on having both pixel and vertex shader
1736          * setup at the same time. The shader_select call will be done by drawprim until vertex shaders are
1737          * moved to the state table too
1738          */
1739         stateblock->wineD3DDevice->shader_backend->shader_select(
1740                 (IWineD3DDevice *) stateblock->wineD3DDevice,
1741                 TRUE,
1742                 !stateblock->vertexShader ? FALSE : ((IWineD3DVertexShaderImpl *) stateblock->vertexShader)->baseShader.function != NULL);
1743 #endif
1744         stateblock->wineD3DDevice->last_was_pshader = TRUE;
1745     } else {
1746         /* Disabled the pixel shader - color ops weren't applied
1747          * while it was enabled, so re-apply them.
1748          */
1749         for(i=0; i < MAX_TEXTURES; i++) {
1750             if(!isStateDirty(stateblock->wineD3DDevice, STATE_TEXTURESTAGE(i, WINED3DTSS_COLOROP))) {
1751                 tex_colorop(STATE_TEXTURESTAGE(i, WINED3DTSS_COLOROP), stateblock);
1752             }
1753         }
1754         stateblock->wineD3DDevice->last_was_pshader = FALSE;
1755
1756 #if 0
1757         stateblock->wineD3DDevice->shader_backend->shader_select(
1758                 (IWineD3DDevice *) stateblock->wineD3DDevice,
1759                 FALSE,
1760                 !stateblock->vertexShader ? FALSE : ((IWineD3DVertexShaderImpl *) stateblock->vertexShader)->baseShader.function != NULL);
1761 #endif
1762     }
1763 }
1764
1765 const struct StateEntry StateTable[] =
1766 {
1767       /* State name                                         representative,                                     apply function */
1768     { /* 0,  Undefined                              */      0,                                                  state_undefined     },
1769     { /* 1,  WINED3DRS_TEXTUREHANDLE                */      0 /* Handled in ddraw */,                           state_undefined     },
1770     { /* 2,  WINED3DRS_ANTIALIAS                    */      STATE_RENDER(WINED3DRS_ANTIALIAS),                  state_antialias     },
1771     { /* 3,  WINED3DRS_TEXTUREADDRESS               */      0 /* Handled in ddraw */,                           state_undefined     },
1772     { /* 4,  WINED3DRS_TEXTUREPERSPECTIVE           */      STATE_RENDER(WINED3DRS_TEXTUREPERSPECTIVE),         state_perspective   },
1773     { /* 5,  WINED3DRS_WRAPU                        */      STATE_RENDER(WINED3DRS_WRAPU),                      state_wrapu         },
1774     { /* 6,  WINED3DRS_WRAPV                        */      STATE_RENDER(WINED3DRS_WRAPV),                      state_wrapv         },
1775     { /* 7,  WINED3DRS_ZENABLE                      */      STATE_RENDER(WINED3DRS_ZENABLE),                    state_zenable       },
1776     { /* 8,  WINED3DRS_FILLMODE                     */      STATE_RENDER(WINED3DRS_FILLMODE),                   state_fillmode      },
1777     { /* 9,  WINED3DRS_SHADEMODE                    */      STATE_RENDER(WINED3DRS_SHADEMODE),                  state_shademode     },
1778     { /* 10, WINED3DRS_LINEPATTERN                  */      STATE_RENDER(WINED3DRS_LINEPATTERN),                state_linepattern   },
1779     { /* 11, WINED3DRS_MONOENABLE                   */      STATE_RENDER(WINED3DRS_MONOENABLE),                 state_monoenable    },
1780     { /* 12, WINED3DRS_ROP2                         */      STATE_RENDER(WINED3DRS_ROP2),                       state_rop2          },
1781     { /* 13, WINED3DRS_PLANEMASK                    */      STATE_RENDER(WINED3DRS_PLANEMASK),                  state_planemask     },
1782     { /* 14, WINED3DRS_ZWRITEENABLE                 */      STATE_RENDER(WINED3DRS_ZWRITEENABLE),               state_zwritenable   },
1783     { /* 15, WINED3DRS_ALPHATESTENABLE              */      STATE_RENDER(WINED3DRS_ALPHATESTENABLE),            state_alpha         },
1784     { /* 16, WINED3DRS_LASTPIXEL                    */      STATE_RENDER(WINED3DRS_LASTPIXEL),                  state_lastpixel     },
1785     { /* 17, WINED3DRS_TEXTUREMAG                   */      0 /* Handled in ddraw */,                           state_undefined     },
1786     { /* 18, WINED3DRS_TEXTUREMIN                   */      0 /* Handled in ddraw */,                           state_undefined     },
1787     { /* 19, WINED3DRS_SRCBLEND                     */      STATE_RENDER(WINED3DRS_ALPHABLENDENABLE),           state_blend         },
1788     { /* 20, WINED3DRS_DESTBLEND                    */      STATE_RENDER(WINED3DRS_ALPHABLENDENABLE),           state_blend         },
1789     { /* 21, WINED3DRS_TEXTUREMAPBLEND              */      0 /* Handled in ddraw */,                           state_undefined     },
1790     { /* 22, WINED3DRS_CULLMODE                     */      STATE_RENDER(WINED3DRS_CULLMODE),                   state_cullmode      },
1791     { /* 23, WINED3DRS_ZFUNC                        */      STATE_RENDER(WINED3DRS_ZFUNC),                      state_zfunc         },
1792     { /* 24, WINED3DRS_ALPHAREF                     */      STATE_RENDER(WINED3DRS_ALPHATESTENABLE),            state_alpha         },
1793     { /* 25, WINED3DRS_ALPHAFUNC                    */      STATE_RENDER(WINED3DRS_ALPHATESTENABLE),            state_alpha         },
1794     { /* 26, WINED3DRS_DITHERENABLE                 */      STATE_RENDER(WINED3DRS_DITHERENABLE),               state_ditherenable  },
1795     { /* 27, WINED3DRS_ALPHABLENDENABLE             */      STATE_RENDER(WINED3DRS_ALPHABLENDENABLE),           state_blend         },
1796     { /* 28, WINED3DRS_FOGENABLE                    */      STATE_RENDER(WINED3DRS_FOGENABLE),                  state_fog           },
1797     { /* 29, WINED3DRS_SPECULARENABLE               */      STATE_RENDER(WINED3DRS_SPECULARENABLE),             state_specularenable},
1798     { /* 30, WINED3DRS_ZVISIBLE                     */      0 /* Not supported according to the msdn */,        state_nogl          },
1799     { /* 31, WINED3DRS_SUBPIXEL                     */      STATE_RENDER(WINED3DRS_SUBPIXEL),                   state_subpixel      },
1800     { /* 32, WINED3DRS_SUBPIXELX                    */      STATE_RENDER(WINED3DRS_SUBPIXELX),                  state_subpixelx     },
1801     { /* 33, WINED3DRS_STIPPLEDALPHA                */      STATE_RENDER(WINED3DRS_STIPPLEDALPHA),              state_stippledalpha },
1802     { /* 34, WINED3DRS_FOGCOLOR                     */      STATE_RENDER(WINED3DRS_FOGCOLOR),                   state_fogcolor      },
1803     { /* 35, WINED3DRS_FOGTABLEMODE                 */      STATE_RENDER(WINED3DRS_FOGENABLE),                  state_fog           },
1804     { /* 36, WINED3DRS_FOGSTART                     */      STATE_RENDER(WINED3DRS_FOGENABLE),                  state_fog           },
1805     { /* 37, WINED3DRS_FOGEND                       */      STATE_RENDER(WINED3DRS_FOGENABLE),                  state_fog           },
1806     { /* 38, WINED3DRS_FOGDENSITY                   */      STATE_RENDER(WINED3DRS_FOGDENSITY),                 state_fogdensity    },
1807     { /* 39, WINED3DRS_STIPPLEENABLE                */      STATE_RENDER(WINED3DRS_STIPPLEENABLE),              state_stippleenable },
1808     { /* 40, WINED3DRS_EDGEANTIALIAS                */      STATE_RENDER(WINED3DRS_ALPHABLENDENABLE),           state_blend         },
1809     { /* 41, WINED3DRS_COLORKEYENABLE               */      STATE_RENDER(WINED3DRS_ALPHATESTENABLE),            state_alpha         },
1810     { /* 42, undefined                              */      0,                                                  state_undefined     },
1811     { /* 43, WINED3DRS_BORDERCOLOR                  */      STATE_RENDER(WINED3DRS_BORDERCOLOR),                state_bordercolor   },
1812     { /* 44, WINED3DRS_TEXTUREADDRESSU              */      0, /* Handled in ddraw */                           state_undefined     },
1813     { /* 45, WINED3DRS_TEXTUREADDRESSV              */      0, /* Handled in ddraw */                           state_undefined     },
1814     { /* 46, WINED3DRS_MIPMAPLODBIAS                */      STATE_RENDER(WINED3DRS_MIPMAPLODBIAS),              state_mipmaplodbias },
1815     { /* 47, WINED3DRS_ZBIAS                        */      STATE_RENDER(WINED3DRS_ZBIAS),                      state_zbias         },
1816     { /* 48, WINED3DRS_RANGEFOGENABLE               */      0,                                                  state_nogl          },
1817     { /* 49, WINED3DRS_ANISOTROPY                   */      STATE_RENDER(WINED3DRS_ANISOTROPY),                 state_anisotropy    },
1818     { /* 50, WINED3DRS_FLUSHBATCH                   */      STATE_RENDER(WINED3DRS_FLUSHBATCH),                 state_flushbatch    },
1819     { /* 51, WINED3DRS_TRANSLUCENTSORTINDEPENDENT   */      STATE_RENDER(WINED3DRS_TRANSLUCENTSORTINDEPENDENT), state_translucentsi },
1820     { /* 52, WINED3DRS_STENCILENABLE                */      STATE_RENDER(WINED3DRS_STENCILENABLE),              state_stencil       },
1821     { /* 53, WINED3DRS_STENCILFAIL                  */      STATE_RENDER(WINED3DRS_STENCILENABLE),              state_stencil       },
1822     { /* 54, WINED3DRS_STENCILZFAIL                 */      STATE_RENDER(WINED3DRS_STENCILENABLE),              state_stencil       },
1823     { /* 55, WINED3DRS_STENCILPASS                  */      STATE_RENDER(WINED3DRS_STENCILENABLE),              state_stencil       },
1824     { /* 56, WINED3DRS_STENCILFUNC                  */      STATE_RENDER(WINED3DRS_STENCILENABLE),              state_stencil       },
1825     { /* 57, WINED3DRS_STENCILREF                   */      STATE_RENDER(WINED3DRS_STENCILENABLE),              state_stencil       },
1826     { /* 58, WINED3DRS_STENCILMASK                  */      STATE_RENDER(WINED3DRS_STENCILENABLE),              state_stencil       },
1827     { /* 59, WINED3DRS_STENCILWRITEMASK             */      STATE_RENDER(WINED3DRS_STENCILWRITEMASK),           state_stencilwrite  },
1828     { /* 60, WINED3DRS_TEXTUREFACTOR                */      STATE_RENDER(WINED3DRS_TEXTUREFACTOR),              state_texfactor     },
1829     { /* 61, Undefined                              */      0,                                                  state_undefined     },
1830     { /* 62, Undefined                              */      0,                                                  state_undefined     },
1831     { /* 63, Undefined                              */      0,                                                  state_undefined     },
1832     { /* 64, WINED3DRS_STIPPLEPATTERN00             */      0 /* Obsolete, should be handled by ddraw */,       state_undefined     },
1833     { /* 65, WINED3DRS_STIPPLEPATTERN01             */      0 /* Obsolete, should he handled by ddraw */,       state_undefined     },
1834     { /* 66, WINED3DRS_STIPPLEPATTERN02             */      0 /* Obsolete, should be handled by ddraw */,       state_undefined     },
1835     { /* 67, WINED3DRS_STIPPLEPATTERN03             */      0 /* Obsolete, should be handled by ddraw */,       state_undefined     },
1836     { /* 68, WINED3DRS_STIPPLEPATTERN04             */      0 /* Obsolete, should be handled by ddraw */,       state_undefined     },
1837     { /* 69, WINED3DRS_STIPPLEPATTERN05             */      0 /* Obsolete, should be handled by ddraw */,       state_undefined     },
1838     { /* 70, WINED3DRS_STIPPLEPATTERN06             */      0 /* Obsolete, should be handled by ddraw */,       state_undefined     },
1839     { /* 71, WINED3DRS_STIPPLEPATTERN07             */      0 /* Obsolete, should be handled by ddraw */,       state_undefined     },
1840     { /* 72, WINED3DRS_STIPPLEPATTERN08             */      0 /* Obsolete, should be handled by ddraw */,       state_undefined     },
1841     { /* 73, WINED3DRS_STIPPLEPATTERN09             */      0 /* Obsolete, should be handled by ddraw */,       state_undefined     },
1842     { /* 74, WINED3DRS_STIPPLEPATTERN10             */      0 /* Obsolete, should be handled by ddraw */,       state_undefined     },
1843     { /* 75, WINED3DRS_STIPPLEPATTERN11             */      0 /* Obsolete, should be handled by ddraw */,       state_undefined     },
1844     { /* 76, WINED3DRS_STIPPLEPATTERN12             */      0 /* Obsolete, should be handled by ddraw */,       state_undefined     },
1845     { /* 77, WINED3DRS_STIPPLEPATTERN13             */      0 /* Obsolete, should be handled by ddraw */,       state_undefined     },
1846     { /* 78, WINED3DRS_STIPPLEPATTERN14             */      0 /* Obsolete, should be handled by ddraw */,       state_undefined     },
1847     { /* 79, WINED3DRS_STIPPLEPATTERN15             */      0 /* Obsolete, should be handled by ddraw */,       state_undefined     },
1848     { /* 80, WINED3DRS_STIPPLEPATTERN16             */      0 /* Obsolete, should be handled by ddraw */,       state_undefined     },
1849     { /* 81, WINED3DRS_STIPPLEPATTERN17             */      0 /* Obsolete, should be handled by ddraw */,       state_undefined     },
1850     { /* 82, WINED3DRS_STIPPLEPATTERN18             */      0 /* Obsolete, should be handled by ddraw */,       state_undefined     },
1851     { /* 83, WINED3DRS_STIPPLEPATTERN19             */      0 /* Obsolete, should be handled by ddraw */,       state_undefined     },
1852     { /* 84, WINED3DRS_STIPPLEPATTERN20             */      0 /* Obsolete, should be handled by ddraw */,       state_undefined     },
1853     { /* 85, WINED3DRS_STIPPLEPATTERN21             */      0 /* Obsolete, should be handled by ddraw */,       state_undefined     },
1854     { /* 86, WINED3DRS_STIPPLEPATTERN22             */      0 /* Obsolete, should be handled by ddraw */,       state_undefined     },
1855     { /* 87, WINED3DRS_STIPPLEPATTERN23             */      0 /* Obsolete, should be handled by ddraw */,       state_undefined     },
1856     { /* 88, WINED3DRS_STIPPLEPATTERN24             */      0 /* Obsolete, should be handled by ddraw */,       state_undefined     },
1857     { /* 89, WINED3DRS_STIPPLEPATTERN25             */      0 /* Obsolete, should be handled by ddraw */,       state_undefined     },
1858     { /* 90, WINED3DRS_STIPPLEPATTERN26             */      0 /* Obsolete, should be handled by ddraw */,       state_undefined     },
1859     { /* 91, WINED3DRS_STIPPLEPATTERN27             */      0 /* Obsolete, should be handled by ddraw */,       state_undefined     },
1860     { /* 92, WINED3DRS_STIPPLEPATTERN28             */      0 /* Obsolete, should be handled by ddraw */,       state_undefined     },
1861     { /* 93, WINED3DRS_STIPPLEPATTERN29             */      0 /* Obsolete, should be handled by ddraw */,       state_undefined     },
1862     { /* 94, WINED3DRS_STIPPLEPATTERN30             */      0 /* Obsolete, should be handled by ddraw */,       state_undefined     },
1863     { /* 95, WINED3DRS_STIPPLEPATTERN31             */      0 /* Obsolete, should be handled by ddraw */,       state_undefined     },
1864     { /* 96, Undefined                              */      0,                                                  state_undefined     },
1865     { /* 97, Undefined                              */      0,                                                  state_undefined     },
1866     { /* 98, Undefined                              */      0,                                                  state_undefined     },
1867     { /* 99, Undefined                              */      0,                                                  state_undefined     },
1868     { /*100, Undefined                              */      0,                                                  state_undefined     },
1869     { /*101, Undefined                              */      0,                                                  state_undefined     },
1870     { /*102, Undefined                              */      0,                                                  state_undefined     },
1871     { /*103, Undefined                              */      0,                                                  state_undefined     },
1872     { /*104, Undefined                              */      0,                                                  state_undefined     },
1873     { /*105, Undefined                              */      0,                                                  state_undefined     },
1874     { /*106, Undefined                              */      0,                                                  state_undefined     },
1875     { /*107, Undefined                              */      0,                                                  state_undefined     },
1876     { /*108, Undefined                              */      0,                                                  state_undefined     },
1877     { /*109, Undefined                              */      0,                                                  state_undefined     },
1878     { /*110, Undefined                              */      0,                                                  state_undefined     },
1879     { /*111, Undefined                              */      0,                                                  state_undefined     },
1880     { /*112, Undefined                              */      0,                                                  state_undefined     },
1881     { /*113, Undefined                              */      0,                                                  state_undefined     },
1882     { /*114, Undefined                              */      0,                                                  state_undefined     },
1883     { /*115, Undefined                              */      0,                                                  state_undefined     },
1884     { /*116, Undefined                              */      0,                                                  state_undefined     },
1885     { /*117, Undefined                              */      0,                                                  state_undefined     },
1886     { /*118, Undefined                              */      0,                                                  state_undefined     },
1887     { /*119, Undefined                              */      0,                                                  state_undefined     },
1888     { /*120, Undefined                              */      0,                                                  state_undefined     },
1889     { /*121, Undefined                              */      0,                                                  state_undefined     },
1890     { /*122, Undefined                              */      0,                                                  state_undefined     },
1891     { /*123, Undefined                              */      0,                                                  state_undefined     },
1892     { /*124, Undefined                              */      0,                                                  state_undefined     },
1893     { /*125, Undefined                              */      0,                                                  state_undefined     },
1894     { /*126, Undefined                              */      0,                                                  state_undefined     },
1895     { /*127, Undefined                              */      0,                                                  state_undefined     },
1896     /* Big hole ends */
1897     { /*128, WINED3DRS_WRAP0                        */      STATE_RENDER(WINED3DRS_WRAP0),                      state_wrap          },
1898     { /*129, WINED3DRS_WRAP1                        */      STATE_RENDER(WINED3DRS_WRAP0),                      state_wrap          },
1899     { /*130, WINED3DRS_WRAP2                        */      STATE_RENDER(WINED3DRS_WRAP0),                      state_wrap          },
1900     { /*131, WINED3DRS_WRAP3                        */      STATE_RENDER(WINED3DRS_WRAP0),                      state_wrap          },
1901     { /*132, WINED3DRS_WRAP4                        */      STATE_RENDER(WINED3DRS_WRAP0),                      state_wrap          },
1902     { /*133, WINED3DRS_WRAP5                        */      STATE_RENDER(WINED3DRS_WRAP0),                      state_wrap          },
1903     { /*134, WINED3DRS_WRAP6                        */      STATE_RENDER(WINED3DRS_WRAP0),                      state_wrap          },
1904     { /*135, WINED3DRS_WRAP7                        */      STATE_RENDER(WINED3DRS_WRAP0),                      state_wrap          },
1905     { /*136, WINED3DRS_CLIPPING                     */      STATE_RENDER(WINED3DRS_CLIPPING),                   state_clipping      },
1906     { /*137, WINED3DRS_LIGHTING                     */      STATE_RENDER(WINED3DRS_LIGHTING) /* Vertex decl! */,state_lighting      },
1907     { /*138, WINED3DRS_EXTENTS                      */      STATE_RENDER(WINED3DRS_EXTENTS),                    state_extents       },
1908     { /*139, WINED3DRS_AMBIENT                      */      STATE_RENDER(WINED3DRS_AMBIENT),                    state_ambient       },
1909     { /*140, WINED3DRS_FOGVERTEXMODE                */      STATE_RENDER(WINED3DRS_FOGENABLE),                  state_fog           },
1910     { /*141, WINED3DRS_COLORVERTEX                  */      STATE_RENDER(WINED3DRS_COLORVERTEX),                state_colormat      },
1911     { /*142, WINED3DRS_LOCALVIEWER                  */      STATE_RENDER(WINED3DRS_LOCALVIEWER),                state_localviewer   },
1912     { /*143, WINED3DRS_NORMALIZENORMALS             */      STATE_RENDER(WINED3DRS_NORMALIZENORMALS),           state_normalize     },
1913     { /*144, WINED3DRS_COLORKEYBLENDENABLE          */      STATE_RENDER(WINED3DRS_COLORKEYBLENDENABLE),        state_ckeyblend     },
1914     { /*145, WINED3DRS_DIFFUSEMATERIALSOURCE        */      STATE_RENDER(WINED3DRS_COLORVERTEX),                state_colormat      },
1915     { /*146, WINED3DRS_SPECULARMATERIALSOURCE       */      STATE_RENDER(WINED3DRS_COLORVERTEX),                state_colormat      },
1916     { /*147, WINED3DRS_AMBIENTMATERIALSOURCE        */      STATE_RENDER(WINED3DRS_COLORVERTEX),                state_colormat      },
1917     { /*148, WINED3DRS_EMISSIVEMATERIALSOURCE       */      STATE_RENDER(WINED3DRS_COLORVERTEX),                state_colormat      },
1918     { /*149, Undefined                              */      0,                                                  state_undefined     },
1919     { /*150, Undefined                              */      0,                                                  state_undefined     },
1920     { /*151, WINED3DRS_VERTEXBLEND                  */      0,                                                  state_nogl          },
1921     { /*152, WINED3DRS_CLIPPLANEENABLE              */      STATE_RENDER(WINED3DRS_CLIPPING),                   state_clipping      },
1922     { /*153, WINED3DRS_SOFTWAREVERTEXPROCESSING     */      0,                                                  state_nogl          },
1923     { /*154, WINED3DRS_POINTSIZE                    */      STATE_RENDER(WINED3DRS_POINTSIZE),                  state_psize         },
1924     { /*155, WINED3DRS_POINTSIZE_MIN                */      STATE_RENDER(WINED3DRS_POINTSIZE_MIN),              state_psizemin      },
1925     { /*156, WINED3DRS_POINTSPRITEENABLE            */      STATE_RENDER(WINED3DRS_POINTSPRITEENABLE),          state_pointsprite   },
1926     { /*157, WINED3DRS_POINTSCALEENABLE             */      STATE_RENDER(WINED3DRS_POINTSCALEENABLE),           state_pscale        },
1927     { /*158, WINED3DRS_POINTSCALE_A                 */      STATE_RENDER(WINED3DRS_POINTSCALEENABLE),           state_pscale        },
1928     { /*159, WINED3DRS_POINTSCALE_B                 */      STATE_RENDER(WINED3DRS_POINTSCALEENABLE),           state_pscale        },
1929     { /*160, WINED3DRS_POINTSCALE_C                 */      STATE_RENDER(WINED3DRS_POINTSCALEENABLE),           state_pscale        },
1930     { /*161, WINED3DRS_MULTISAMPLEANTIALIAS         */      STATE_RENDER(WINED3DRS_MULTISAMPLEANTIALIAS),       state_multisampleaa },
1931     { /*162, WINED3DRS_MULTISAMPLEMASK              */      STATE_RENDER(WINED3DRS_MULTISAMPLEMASK),            state_multisampmask },
1932     { /*163, WINED3DRS_PATCHEDGESTYLE               */      STATE_RENDER(WINED3DRS_PATCHEDGESTYLE),             state_patchedgestyle},
1933     { /*164, WINED3DRS_PATCHSEGMENTS                */      STATE_RENDER(WINED3DRS_PATCHSEGMENTS),              state_patchsegments },
1934     { /*165, WINED3DRS_DEBUGMONITORTOKEN            */      STATE_RENDER(WINED3DRS_DEBUGMONITORTOKEN),          state_nogl          },
1935     { /*166, WINED3DRS_POINTSIZE_MAX                */      STATE_RENDER(WINED3DRS_POINTSIZE_MAX),              state_psizemax      },
1936     { /*167, WINED3DRS_INDEXEDVERTEXBLENDENABLE     */      0,                                                  state_nogl          },
1937     { /*168, WINED3DRS_COLORWRITEENABLE             */      STATE_RENDER(WINED3DRS_COLORWRITEENABLE),           state_colorwrite    },
1938     { /*169, Undefined                              */      0,                                                  state_undefined     },
1939     { /*170, WINED3DRS_TWEENFACTOR                  */      0,                                                  state_nogl          },
1940     { /*171, WINED3DRS_BLENDOP                      */      STATE_RENDER(WINED3DRS_BLENDOP),                    state_blendop       },
1941     { /*172, WINED3DRS_POSITIONDEGREE               */      STATE_RENDER(WINED3DRS_POSITIONDEGREE),             state_positiondegree},
1942     { /*173, WINED3DRS_NORMALDEGREE                 */      STATE_RENDER(WINED3DRS_NORMALDEGREE),               state_normaldegree  },
1943       /*172, WINED3DRS_POSITIONORDER                */      /* Value assigned to 2 state names */
1944       /*173, WINED3DRS_NORMALORDER                  */      /* Value assigned to 2 state names */
1945     { /*174, WINED3DRS_SCISSORTESTENABLE            */      STATE_RENDER(WINED3DRS_SCISSORTESTENABLE),          state_scissor       },
1946     { /*175, WINED3DRS_SLOPESCALEDEPTHBIAS          */      STATE_RENDER(WINED3DRS_DEPTHBIAS),                  state_depthbias     },
1947     { /*176, WINED3DRS_ANTIALIASEDLINEENABLE        */      STATE_RENDER(WINED3DRS_ALPHABLENDENABLE),           state_blend         },
1948     { /*177, undefined                              */      0,                                                  state_undefined     },
1949     { /*178, WINED3DRS_MINTESSELLATIONLEVEL         */      STATE_RENDER(WINED3DRS_ENABLEADAPTIVETESSELLATION), state_tessellation  },
1950     { /*179, WINED3DRS_MAXTESSELLATIONLEVEL         */      STATE_RENDER(WINED3DRS_ENABLEADAPTIVETESSELLATION), state_tessellation  },
1951     { /*180, WINED3DRS_ADAPTIVETESS_X               */      STATE_RENDER(WINED3DRS_ENABLEADAPTIVETESSELLATION), state_tessellation  },
1952     { /*181, WINED3DRS_ADAPTIVETESS_Y               */      STATE_RENDER(WINED3DRS_ENABLEADAPTIVETESSELLATION), state_tessellation  },
1953     { /*182, WINED3DRS_ADAPTIVETESS_Z               */      STATE_RENDER(WINED3DRS_ENABLEADAPTIVETESSELLATION), state_tessellation  },
1954     { /*183, WINED3DRS_ADAPTIVETESS_W               */      STATE_RENDER(WINED3DRS_ENABLEADAPTIVETESSELLATION), state_tessellation  },
1955     { /*184, WINED3DRS_ENABLEADAPTIVETESSELLATION   */      STATE_RENDER(WINED3DRS_ENABLEADAPTIVETESSELLATION), state_tessellation  },
1956     { /*185, WINED3DRS_TWOSIDEDSTENCILMODE          */      STATE_RENDER(WINED3DRS_STENCILENABLE),              state_stencil       },
1957     { /*186, WINED3DRS_CCW_STENCILFAIL              */      STATE_RENDER(WINED3DRS_STENCILENABLE),              state_stencil       },
1958     { /*187, WINED3DRS_CCW_STENCILZFAIL             */      STATE_RENDER(WINED3DRS_STENCILENABLE),              state_stencil       },
1959     { /*188, WINED3DRS_CCW_STENCILPASS              */      STATE_RENDER(WINED3DRS_STENCILENABLE),              state_stencil       },
1960     { /*189, WINED3DRS_CCW_STENCILFUNC              */      STATE_RENDER(WINED3DRS_STENCILENABLE),              state_stencil       },
1961     { /*190, WINED3DRS_COLORWRITEENABLE1            */      STATE_RENDER(WINED3DRS_COLORWRITEENABLE),           state_colorwrite    },
1962     { /*191, WINED3DRS_COLORWRITEENABLE2            */      STATE_RENDER(WINED3DRS_COLORWRITEENABLE),           state_colorwrite    },
1963     { /*192, WINED3DRS_COLORWRITEENABLE3            */      STATE_RENDER(WINED3DRS_COLORWRITEENABLE),           state_colorwrite    },
1964     { /*193, WINED3DRS_BLENDFACTOR                  */      STATE_RENDER(WINED3DRS_ALPHABLENDENABLE),           state_blend         },
1965     { /*194, WINED3DRS_SRGBWRITEENABLE              */      STATE_RENDER(WINED3DRS_SRGBWRITEENABLE),            state_srgbwrite     },
1966     { /*195, WINED3DRS_DEPTHBIAS                    */      STATE_RENDER(WINED3DRS_DEPTHBIAS),                  state_depthbias     },
1967     { /*196, undefined                              */      0,                                                  state_undefined     },
1968     { /*197, undefined                              */      0,                                                  state_undefined     },
1969     { /*198, WINED3DRS_WRAP8                        */      STATE_RENDER(WINED3DRS_WRAP0),                      state_wrap          },
1970     { /*199, WINED3DRS_WRAP9                        */      STATE_RENDER(WINED3DRS_WRAP0),                      state_wrap          },
1971     { /*200, WINED3DRS_WRAP10                       */      STATE_RENDER(WINED3DRS_WRAP0),                      state_wrap          },
1972     { /*201, WINED3DRS_WRAP11                       */      STATE_RENDER(WINED3DRS_WRAP0),                      state_wrap          },
1973     { /*202, WINED3DRS_WRAP12                       */      STATE_RENDER(WINED3DRS_WRAP0),                      state_wrap          },
1974     { /*203, WINED3DRS_WRAP13                       */      STATE_RENDER(WINED3DRS_WRAP0),                      state_wrap          },
1975     { /*204, WINED3DRS_WRAP14                       */      STATE_RENDER(WINED3DRS_WRAP0),                      state_wrap          },
1976     { /*205, WINED3DRS_WRAP15                       */      STATE_RENDER(WINED3DRS_WRAP0),                      state_wrap          },
1977     { /*206, WINED3DRS_SEPARATEALPHABLENDENABLE     */      STATE_RENDER(WINED3DRS_SEPARATEALPHABLENDENABLE),   state_seperateblend },
1978     { /*207, WINED3DRS_SRCBLENDALPHA                */      STATE_RENDER(WINED3DRS_SEPARATEALPHABLENDENABLE),   state_seperateblend },
1979     { /*208, WINED3DRS_DESTBLENDALPHA               */      STATE_RENDER(WINED3DRS_SEPARATEALPHABLENDENABLE),   state_seperateblend },
1980     { /*209, WINED3DRS_BLENDOPALPHA                 */      STATE_RENDER(WINED3DRS_SEPARATEALPHABLENDENABLE),   state_seperateblend },
1981     /* Texture stage states */
1982     { /*0, 01, WINED3DTSS_COLOROP                   */      STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP),          tex_colorop         },
1983     { /*0, 02, WINED3DTSS_COLORARG1                 */      STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP),          tex_colorop         },
1984     { /*0, 03, WINED3DTSS_COLORARG2                 */      STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP),          tex_colorop         },
1985     { /*0, 04, WINED3DTSS_ALPHAOP                   */      STATE_TEXTURESTAGE(0, WINED3DTSS_ALPHAOP),          tex_alphaop         },
1986     { /*0, 05, WINED3DTSS_ALPHAARG1                 */      STATE_TEXTURESTAGE(0, WINED3DTSS_ALPHAOP),          tex_alphaop         },
1987     { /*0, 06, WINED3DTSS_ALPHAARG2                 */      STATE_TEXTURESTAGE(0, WINED3DTSS_ALPHAOP),          tex_alphaop         },
1988     { /*0, 07, WINED3DTSS_BUMPENVMAT00              */      STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP),          tex_colorop         },
1989     { /*0, 08, WINED3DTSS_BUMPENVMAT01              */      STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP),          tex_colorop         },
1990     { /*0, 09, WINED3DTSS_BUMPENVMAT10              */      STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP),          tex_colorop         },
1991     { /*0, 10, WINED3DTSS_BUMPENVMAT11              */      STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP),          tex_colorop         },
1992     { /*0, 11, WINED3DTSS_TEXCOORDINDEX             */      STATE_TEXTURESTAGE(0, WINED3DTSS_TEXCOORDINDEX),    tex_coordindex      },
1993     { /*0, 12, WINED3DTSS_ADDRESS                   */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
1994     { /*0, 13, WINED3DTSS_ADDRESSU                  */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
1995     { /*0, 14, WINED3DTSS_ADDRESSV                  */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
1996     { /*0, 15, WINED3DTSS_BORDERCOLOR               */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
1997     { /*0, 16, WINED3DTSS_MAGFILTER                 */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
1998     { /*0, 17, WINED3DTSS_MINFILTER                 */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
1999     { /*0, 18, WINED3DTSS_MIPFILTER                 */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
2000     { /*0, 19, WINED3DTSS_MIPMAPLODBIAS             */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
2001     { /*0, 20, WINED3DTSS_MAXMIPLEVEL               */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
2002     { /*0, 21, WINED3DTSS_MAXANISOTROPY             */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
2003     { /*0, 22, WINED3DTSS_BUMPENVLSCALE             */      STATE_TEXTURESTAGE(0, WINED3DTSS_BUMPENVLSCALE),    tex_bumpenvlscale   },
2004     { /*0, 23, WINED3DTSS_BUMPENVLOFFSET            */      STATE_TEXTURESTAGE(0, WINED3DTSS_BUMPENVLOFFSET),   tex_bumpenvloffset  },
2005     { /*0, 24, WINED3DTSS_TEXTURETRANSFORMFLAGS     */      0 /* for now, later stream sources */,              state_nogl          },
2006     { /*0, 25, WINED3DTSS_ADDRESSW                  */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
2007     { /*0, 26, WINED3DTSS_COLORARG0                 */      STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP),          tex_colorop         },
2008     { /*0, 27, WINED3DTSS_ALPHAARG0                 */      STATE_TEXTURESTAGE(0, WINED3DTSS_ALPHAOP),          tex_alphaop         },
2009     { /*0, 28, WINED3DTSS_RESULTARG                 */      STATE_TEXTURESTAGE(0, WINED3DTSS_RESULTARG),        tex_resultarg       },
2010     { /*0, 29, undefined                            */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
2011     { /*0, 30, undefined                            */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
2012     { /*0, 31, undefined                            */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
2013     { /*0, 32, WINED3DTSS_CONSTANT                  */      0 /* As long as we don't support D3DTA_CONSTANT */, state_nogl          },
2014
2015     { /*1, 01, WINED3DTSS_COLOROP                   */      STATE_TEXTURESTAGE(1, WINED3DTSS_COLOROP),          tex_colorop         },
2016     { /*1, 02, WINED3DTSS_COLORARG1                 */      STATE_TEXTURESTAGE(1, WINED3DTSS_COLOROP),          tex_colorop         },
2017     { /*1, 03, WINED3DTSS_COLORARG2                 */      STATE_TEXTURESTAGE(1, WINED3DTSS_COLOROP),          tex_colorop         },
2018     { /*1, 04, WINED3DTSS_ALPHAOP                   */      STATE_TEXTURESTAGE(1, WINED3DTSS_ALPHAOP),          tex_alphaop         },
2019     { /*1, 05, WINED3DTSS_ALPHAARG1                 */      STATE_TEXTURESTAGE(1, WINED3DTSS_ALPHAOP),          tex_alphaop         },
2020     { /*1, 06, WINED3DTSS_ALPHAARG2                 */      STATE_TEXTURESTAGE(1, WINED3DTSS_ALPHAOP),          tex_alphaop         },
2021     { /*1, 07, WINED3DTSS_BUMPENVMAT00              */      STATE_TEXTURESTAGE(1, WINED3DTSS_COLOROP),          tex_colorop         },
2022     { /*1, 08, WINED3DTSS_BUMPENVMAT01              */      STATE_TEXTURESTAGE(1, WINED3DTSS_COLOROP),          tex_colorop         },
2023     { /*1, 09, WINED3DTSS_BUMPENVMAT10              */      STATE_TEXTURESTAGE(1, WINED3DTSS_COLOROP),          tex_colorop         },
2024     { /*1, 10, WINED3DTSS_BUMPENVMAT11              */      STATE_TEXTURESTAGE(1, WINED3DTSS_COLOROP),          tex_colorop         },
2025     { /*1, 11, WINED3DTSS_TEXCOORDINDEX             */      STATE_TEXTURESTAGE(1, WINED3DTSS_TEXCOORDINDEX),    tex_coordindex      },
2026     { /*1, 12, WINED3DTSS_ADDRESS                   */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
2027     { /*1, 13, WINED3DTSS_ADDRESSU                  */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
2028     { /*1, 14, WINED3DTSS_ADDRESSV                  */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
2029     { /*1, 15, WINED3DTSS_BORDERCOLOR               */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
2030     { /*1, 16, WINED3DTSS_MAGFILTER                 */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
2031     { /*1, 17, WINED3DTSS_MINFILTER                 */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
2032     { /*1, 18, WINED3DTSS_MIPFILTER                 */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
2033     { /*1, 19, WINED3DTSS_MIPMAPLODBIAS             */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
2034     { /*1, 20, WINED3DTSS_MAXMIPLEVEL               */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
2035     { /*1, 21, WINED3DTSS_MAXANISOTROPY             */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
2036     { /*1, 22, WINED3DTSS_BUMPENVLSCALE             */      STATE_TEXTURESTAGE(1, WINED3DTSS_BUMPENVLSCALE),    tex_bumpenvlscale   },
2037     { /*1, 23, WINED3DTSS_BUMPENVLOFFSET            */      STATE_TEXTURESTAGE(1, WINED3DTSS_BUMPENVLOFFSET),   tex_bumpenvloffset  },
2038     { /*1, 24, WINED3DTSS_TEXTURETRANSFORMFLAGS     */      0 /* for now, later stream sources */,              state_nogl          },
2039     { /*1, 25, WINED3DTSS_ADDRESSW                  */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
2040     { /*1, 26, WINED3DTSS_COLORARG0                 */      STATE_TEXTURESTAGE(1, WINED3DTSS_COLOROP),          tex_colorop         },
2041     { /*1, 27, WINED3DTSS_ALPHAARG0                 */      STATE_TEXTURESTAGE(1, WINED3DTSS_ALPHAOP),          tex_alphaop         },
2042     { /*1, 28, WINED3DTSS_RESULTARG                 */      STATE_TEXTURESTAGE(1, WINED3DTSS_RESULTARG),        tex_resultarg       },
2043     { /*1, 29, undefined                            */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
2044     { /*1, 30, undefined                            */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
2045     { /*1, 31, undefined                            */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
2046     { /*1, 32, WINED3DTSS_CONSTANT                  */      0 /* As long as we don't support D3DTA_CONSTANT */, state_nogl          },
2047
2048     { /*2, 01, WINED3DTSS_COLOROP                   */      STATE_TEXTURESTAGE(2, WINED3DTSS_COLOROP),          tex_colorop         },
2049     { /*2, 02, WINED3DTSS_COLORARG1                 */      STATE_TEXTURESTAGE(2, WINED3DTSS_COLOROP),          tex_colorop         },
2050     { /*2, 03, WINED3DTSS_COLORARG2                 */      STATE_TEXTURESTAGE(2, WINED3DTSS_COLOROP),          tex_colorop         },
2051     { /*2, 04, WINED3DTSS_ALPHAOP                   */      STATE_TEXTURESTAGE(2, WINED3DTSS_ALPHAOP),          tex_alphaop         },
2052     { /*2, 05, WINED3DTSS_ALPHAARG1                 */      STATE_TEXTURESTAGE(2, WINED3DTSS_ALPHAOP),          tex_alphaop         },
2053     { /*2, 06, WINED3DTSS_ALPHAARG2                 */      STATE_TEXTURESTAGE(2, WINED3DTSS_ALPHAOP),          tex_alphaop         },
2054     { /*2, 07, WINED3DTSS_BUMPENVMAT00              */      STATE_TEXTURESTAGE(2, WINED3DTSS_COLOROP),          tex_colorop         },
2055     { /*2, 08, WINED3DTSS_BUMPENVMAT01              */      STATE_TEXTURESTAGE(2, WINED3DTSS_COLOROP),          tex_colorop         },
2056     { /*2, 09, WINED3DTSS_BUMPENVMAT10              */      STATE_TEXTURESTAGE(2, WINED3DTSS_COLOROP),          tex_colorop         },
2057     { /*2, 10, WINED3DTSS_BUMPENVMAT11              */      STATE_TEXTURESTAGE(2, WINED3DTSS_COLOROP),          tex_colorop         },
2058     { /*2, 11, WINED3DTSS_TEXCOORDINDEX             */      STATE_TEXTURESTAGE(2, WINED3DTSS_TEXCOORDINDEX),    tex_coordindex      },
2059     { /*2, 12, WINED3DTSS_ADDRESS                   */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
2060     { /*2, 13, WINED3DTSS_ADDRESSU                  */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
2061     { /*2, 14, WINED3DTSS_ADDRESSV                  */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
2062     { /*2, 15, WINED3DTSS_BORDERCOLOR               */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
2063     { /*2, 16, WINED3DTSS_MAGFILTER                 */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
2064     { /*2, 17, WINED3DTSS_MINFILTER                 */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
2065     { /*2, 18, WINED3DTSS_MIPFILTER                 */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
2066     { /*2, 19, WINED3DTSS_MIPMAPLODBIAS             */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
2067     { /*2, 20, WINED3DTSS_MAXMIPLEVEL               */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
2068     { /*2, 21, WINED3DTSS_MAXANISOTROPY             */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
2069     { /*2, 22, WINED3DTSS_BUMPENVLSCALE             */      STATE_TEXTURESTAGE(2, WINED3DTSS_BUMPENVLSCALE),    tex_bumpenvlscale   },
2070     { /*2, 23, WINED3DTSS_BUMPENVLOFFSET            */      STATE_TEXTURESTAGE(2, WINED3DTSS_BUMPENVLOFFSET),   tex_bumpenvloffset  },
2071     { /*2, 24, WINED3DTSS_TEXTURETRANSFORMFLAGS     */      0 /* for now, later stream sources */,              state_nogl          },
2072     { /*2, 25, WINED3DTSS_ADDRESSW                  */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
2073     { /*2, 26, WINED3DTSS_COLORARG0                 */      STATE_TEXTURESTAGE(2, WINED3DTSS_COLOROP),          tex_colorop         },
2074     { /*2, 27, WINED3DTSS_ALPHAARG0                 */      STATE_TEXTURESTAGE(2, WINED3DTSS_ALPHAOP),          tex_alphaop         },
2075     { /*2, 28, WINED3DTSS_RESULTARG                 */      STATE_TEXTURESTAGE(2, WINED3DTSS_RESULTARG),        tex_resultarg       },
2076     { /*2, 29, undefined                            */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
2077     { /*2, 30, undefined                            */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
2078     { /*2, 31, undefined                            */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
2079     { /*2, 32, WINED3DTSS_CONSTANT                  */      0 /* As long as we don't support D3DTA_CONSTANT */, state_nogl          },
2080
2081     { /*3, 01, WINED3DTSS_COLOROP                   */      STATE_TEXTURESTAGE(3, WINED3DTSS_COLOROP),          tex_colorop         },
2082     { /*3, 02, WINED3DTSS_COLORARG1                 */      STATE_TEXTURESTAGE(3, WINED3DTSS_COLOROP),          tex_colorop         },
2083     { /*3, 03, WINED3DTSS_COLORARG2                 */      STATE_TEXTURESTAGE(3, WINED3DTSS_COLOROP),          tex_colorop         },
2084     { /*3, 04, WINED3DTSS_ALPHAOP                   */      STATE_TEXTURESTAGE(3, WINED3DTSS_ALPHAOP),          tex_alphaop         },
2085     { /*3, 05, WINED3DTSS_ALPHAARG1                 */      STATE_TEXTURESTAGE(3, WINED3DTSS_ALPHAOP),          tex_alphaop         },
2086     { /*3, 06, WINED3DTSS_ALPHAARG2                 */      STATE_TEXTURESTAGE(3, WINED3DTSS_ALPHAOP),          tex_alphaop         },
2087     { /*3, 07, WINED3DTSS_BUMPENVMAT00              */      STATE_TEXTURESTAGE(3, WINED3DTSS_COLOROP),          tex_colorop         },
2088     { /*3, 08, WINED3DTSS_BUMPENVMAT01              */      STATE_TEXTURESTAGE(3, WINED3DTSS_COLOROP),          tex_colorop         },
2089     { /*3, 09, WINED3DTSS_BUMPENVMAT10              */      STATE_TEXTURESTAGE(3, WINED3DTSS_COLOROP),          tex_colorop         },
2090     { /*3, 10, WINED3DTSS_BUMPENVMAT11              */      STATE_TEXTURESTAGE(3, WINED3DTSS_COLOROP),          tex_colorop         },
2091     { /*3, 11, WINED3DTSS_TEXCOORDINDEX             */      STATE_TEXTURESTAGE(3, WINED3DTSS_TEXCOORDINDEX),    tex_coordindex      },
2092     { /*3, 12, WINED3DTSS_ADDRESS                   */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
2093     { /*3, 13, WINED3DTSS_ADDRESSU                  */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
2094     { /*3, 14, WINED3DTSS_ADDRESSV                  */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
2095     { /*3, 15, WINED3DTSS_BORDERCOLOR               */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
2096     { /*3, 16, WINED3DTSS_MAGFILTER                 */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
2097     { /*3, 17, WINED3DTSS_MINFILTER                 */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
2098     { /*3, 18, WINED3DTSS_MIPFILTER                 */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
2099     { /*3, 19, WINED3DTSS_MIPMAPLODBIAS             */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
2100     { /*3, 20, WINED3DTSS_MAXMIPLEVEL               */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
2101     { /*3, 21, WINED3DTSS_MAXANISOTROPY             */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
2102     { /*3, 22, WINED3DTSS_BUMPENVLSCALE             */      STATE_TEXTURESTAGE(3, WINED3DTSS_BUMPENVLSCALE),    tex_bumpenvlscale   },
2103     { /*3, 23, WINED3DTSS_BUMPENVLOFFSET            */      STATE_TEXTURESTAGE(3, WINED3DTSS_BUMPENVLOFFSET),   tex_bumpenvloffset  },
2104     { /*3, 24, WINED3DTSS_TEXTURETRANSFORMFLAGS     */      0 /* for now, later stream sources */,              state_nogl          },
2105     { /*3, 25, WINED3DTSS_ADDRESSW                  */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
2106     { /*3, 26, WINED3DTSS_COLORARG0                 */      STATE_TEXTURESTAGE(3, WINED3DTSS_COLOROP),          tex_colorop         },
2107     { /*3, 27, WINED3DTSS_ALPHAARG0                 */      STATE_TEXTURESTAGE(3, WINED3DTSS_ALPHAOP),          tex_alphaop         },
2108     { /*3, 28, WINED3DTSS_RESULTARG                 */      STATE_TEXTURESTAGE(3, WINED3DTSS_RESULTARG),        tex_resultarg       },
2109     { /*3, 29, undefined                            */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
2110     { /*3, 30, undefined                            */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
2111     { /*3, 31, undefined                            */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
2112     { /*3, 32, WINED3DTSS_CONSTANT                  */      0 /* As long as we don't support D3DTA_CONSTANT */, state_nogl          },
2113
2114     { /*4, 01, WINED3DTSS_COLOROP                   */      STATE_TEXTURESTAGE(4, WINED3DTSS_COLOROP),          tex_colorop         },
2115     { /*4, 02, WINED3DTSS_COLORARG1                 */      STATE_TEXTURESTAGE(4, WINED3DTSS_COLOROP),          tex_colorop         },
2116     { /*4, 03, WINED3DTSS_COLORARG2                 */      STATE_TEXTURESTAGE(4, WINED3DTSS_COLOROP),          tex_colorop         },
2117     { /*4, 04, WINED3DTSS_ALPHAOP                   */      STATE_TEXTURESTAGE(4, WINED3DTSS_ALPHAOP),          tex_alphaop         },
2118     { /*4, 05, WINED3DTSS_ALPHAARG1                 */      STATE_TEXTURESTAGE(4, WINED3DTSS_ALPHAOP),          tex_alphaop         },
2119     { /*4, 06, WINED3DTSS_ALPHAARG2                 */      STATE_TEXTURESTAGE(4, WINED3DTSS_ALPHAOP),          tex_alphaop         },
2120     { /*4, 07, WINED3DTSS_BUMPENVMAT00              */      STATE_TEXTURESTAGE(4, WINED3DTSS_COLOROP),          state_undefined     },
2121     { /*4, 08, WINED3DTSS_BUMPENVMAT01              */      STATE_TEXTURESTAGE(4, WINED3DTSS_COLOROP),          state_undefined     },
2122     { /*4, 09, WINED3DTSS_BUMPENVMAT10              */      STATE_TEXTURESTAGE(4, WINED3DTSS_COLOROP),          state_undefined     },
2123     { /*4, 10, WINED3DTSS_BUMPENVMAT11              */      STATE_TEXTURESTAGE(4, WINED3DTSS_COLOROP),          state_undefined     },
2124     { /*4, 11, WINED3DTSS_TEXCOORDINDEX             */      STATE_TEXTURESTAGE(4, WINED3DTSS_TEXCOORDINDEX),    tex_coordindex      },
2125     { /*4, 12, WINED3DTSS_ADDRESS                   */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
2126     { /*4, 13, WINED3DTSS_ADDRESSU                  */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
2127     { /*4, 14, WINED3DTSS_ADDRESSV                  */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
2128     { /*4, 15, WINED3DTSS_BORDERCOLOR               */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
2129     { /*4, 16, WINED3DTSS_MAGFILTER                 */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
2130     { /*4, 17, WINED3DTSS_MINFILTER                 */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
2131     { /*4, 18, WINED3DTSS_MIPFILTER                 */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
2132     { /*4, 19, WINED3DTSS_MIPMAPLODBIAS             */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
2133     { /*4, 20, WINED3DTSS_MAXMIPLEVEL               */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
2134     { /*4, 21, WINED3DTSS_MAXANISOTROPY             */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
2135     { /*4, 22, WINED3DTSS_BUMPENVLSCALE             */      STATE_TEXTURESTAGE(4, WINED3DTSS_BUMPENVLSCALE),    tex_bumpenvlscale   },
2136     { /*4, 23, WINED3DTSS_BUMPENVLOFFSET            */      STATE_TEXTURESTAGE(4, WINED3DTSS_BUMPENVLOFFSET),   tex_bumpenvloffset  },
2137     { /*4, 24, WINED3DTSS_TEXTURETRANSFORMFLAGS     */      0 /* for now, later stream sources */,              state_nogl          },
2138     { /*4, 25, WINED3DTSS_ADDRESSW                  */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
2139     { /*4, 26, WINED3DTSS_COLORARG0                 */      STATE_TEXTURESTAGE(4, WINED3DTSS_COLOROP),          tex_colorop         },
2140     { /*4, 27, WINED3DTSS_ALPHAARG0                 */      STATE_TEXTURESTAGE(4, WINED3DTSS_ALPHAOP),          tex_alphaop         },
2141     { /*4, 28, WINED3DTSS_RESULTARG                 */      STATE_TEXTURESTAGE(4, WINED3DTSS_RESULTARG),        tex_resultarg       },
2142     { /*4, 29, undefined                            */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
2143     { /*4, 30, undefined                            */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
2144     { /*4, 31, undefined                            */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
2145     { /*4, 32, WINED3DTSS_CONSTANT                  */      0 /* As long as we don't support D3DTA_CONSTANT */, state_nogl          },
2146
2147     { /*5, 01, WINED3DTSS_COLOROP                   */      STATE_TEXTURESTAGE(5, WINED3DTSS_COLOROP),          tex_colorop         },
2148     { /*5, 02, WINED3DTSS_COLORARG1                 */      STATE_TEXTURESTAGE(5, WINED3DTSS_COLOROP),          tex_colorop         },
2149     { /*5, 03, WINED3DTSS_COLORARG2                 */      STATE_TEXTURESTAGE(5, WINED3DTSS_COLOROP),          tex_colorop         },
2150     { /*5, 04, WINED3DTSS_ALPHAOP                   */      STATE_TEXTURESTAGE(5, WINED3DTSS_ALPHAOP),          tex_alphaop         },
2151     { /*5, 05, WINED3DTSS_ALPHAARG1                 */      STATE_TEXTURESTAGE(5, WINED3DTSS_ALPHAOP),          tex_alphaop         },
2152     { /*5, 06, WINED3DTSS_ALPHAARG2                 */      STATE_TEXTURESTAGE(5, WINED3DTSS_ALPHAOP),          tex_alphaop         },
2153     { /*5, 07, WINED3DTSS_BUMPENVMAT00              */      STATE_TEXTURESTAGE(5, WINED3DTSS_COLOROP),          tex_colorop         },
2154     { /*5, 08, WINED3DTSS_BUMPENVMAT01              */      STATE_TEXTURESTAGE(5, WINED3DTSS_COLOROP),          tex_colorop         },
2155     { /*5, 09, WINED3DTSS_BUMPENVMAT10              */      STATE_TEXTURESTAGE(5, WINED3DTSS_COLOROP),          tex_colorop         },
2156     { /*5, 10, WINED3DTSS_BUMPENVMAT11              */      STATE_TEXTURESTAGE(5, WINED3DTSS_COLOROP),          tex_colorop         },
2157     { /*5, 11, WINED3DTSS_TEXCOORDINDEX             */      STATE_TEXTURESTAGE(5, WINED3DTSS_TEXCOORDINDEX),    tex_coordindex      },
2158     { /*5, 12, WINED3DTSS_ADDRESS                   */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
2159     { /*5, 13, WINED3DTSS_ADDRESSU                  */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
2160     { /*5, 14, WINED3DTSS_ADDRESSV                  */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
2161     { /*5, 15, WINED3DTSS_BORDERCOLOR               */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
2162     { /*5, 16, WINED3DTSS_MAGFILTER                 */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
2163     { /*5, 17, WINED3DTSS_MINFILTER                 */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
2164     { /*5, 18, WINED3DTSS_MIPFILTER                 */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
2165     { /*5, 19, WINED3DTSS_MIPMAPLODBIAS             */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
2166     { /*5, 20, WINED3DTSS_MAXMIPLEVEL               */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
2167     { /*5, 21, WINED3DTSS_MAXANISOTROPY             */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
2168     { /*5, 22, WINED3DTSS_BUMPENVLSCALE             */      STATE_TEXTURESTAGE(5, WINED3DTSS_BUMPENVLSCALE),    tex_bumpenvlscale   },
2169     { /*5, 23, WINED3DTSS_BUMPENVLOFFSET            */      STATE_TEXTURESTAGE(5, WINED3DTSS_BUMPENVLOFFSET),   tex_bumpenvloffset  },
2170     { /*5, 24, WINED3DTSS_TEXTURETRANSFORMFLAGS     */      0 /* for now, later stream sources */,              state_nogl          },
2171     { /*5, 25, WINED3DTSS_ADDRESSW                  */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
2172     { /*5, 26, WINED3DTSS_COLORARG0                 */      STATE_TEXTURESTAGE(5, WINED3DTSS_COLOROP),          tex_colorop         },
2173     { /*5, 27, WINED3DTSS_ALPHAARG0                 */      STATE_TEXTURESTAGE(5, WINED3DTSS_ALPHAOP),          tex_alphaop         },
2174     { /*5, 28, WINED3DTSS_RESULTARG                 */      STATE_TEXTURESTAGE(5, WINED3DTSS_RESULTARG),        tex_resultarg       },
2175     { /*5, 29, undefined                            */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
2176     { /*5, 30, undefined                            */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
2177     { /*5, 31, undefined                            */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
2178     { /*5, 32, WINED3DTSS_CONSTANT                  */      0 /* As long as we don't support D3DTA_CONSTANT */, state_nogl          },
2179
2180     { /*6, 01, WINED3DTSS_COLOROP                   */      STATE_TEXTURESTAGE(6, WINED3DTSS_COLOROP),          tex_colorop         },
2181     { /*6, 02, WINED3DTSS_COLORARG1                 */      STATE_TEXTURESTAGE(6, WINED3DTSS_COLOROP),          tex_colorop         },
2182     { /*6, 03, WINED3DTSS_COLORARG2                 */      STATE_TEXTURESTAGE(6, WINED3DTSS_COLOROP),          tex_colorop         },
2183     { /*6, 04, WINED3DTSS_ALPHAOP                   */      STATE_TEXTURESTAGE(6, WINED3DTSS_ALPHAOP),          tex_alphaop         },
2184     { /*6, 05, WINED3DTSS_ALPHAARG1                 */      STATE_TEXTURESTAGE(6, WINED3DTSS_ALPHAOP),          tex_alphaop         },
2185     { /*6, 06, WINED3DTSS_ALPHAARG2                 */      STATE_TEXTURESTAGE(6, WINED3DTSS_ALPHAOP),          tex_alphaop         },
2186     { /*6, 07, WINED3DTSS_BUMPENVMAT00              */      STATE_TEXTURESTAGE(6, WINED3DTSS_COLOROP),          tex_colorop         },
2187     { /*6, 08, WINED3DTSS_BUMPENVMAT01              */      STATE_TEXTURESTAGE(6, WINED3DTSS_COLOROP),          tex_colorop         },
2188     { /*6, 09, WINED3DTSS_BUMPENVMAT10              */      STATE_TEXTURESTAGE(6, WINED3DTSS_COLOROP),          tex_colorop         },
2189     { /*6, 10, WINED3DTSS_BUMPENVMAT11              */      STATE_TEXTURESTAGE(6, WINED3DTSS_COLOROP),          tex_colorop         },
2190     { /*6, 11, WINED3DTSS_TEXCOORDINDEX             */      STATE_TEXTURESTAGE(6, WINED3DTSS_TEXCOORDINDEX),    tex_coordindex      },
2191     { /*6, 12, WINED3DTSS_ADDRESS                   */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
2192     { /*6, 13, WINED3DTSS_ADDRESSU                  */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
2193     { /*6, 14, WINED3DTSS_ADDRESSV                  */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
2194     { /*6, 15, WINED3DTSS_BORDERCOLOR               */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
2195     { /*6, 16, WINED3DTSS_MAGFILTER                 */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
2196     { /*6, 17, WINED3DTSS_MINFILTER                 */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
2197     { /*6, 18, WINED3DTSS_MIPFILTER                 */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
2198     { /*6, 19, WINED3DTSS_MIPMAPLODBIAS             */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
2199     { /*6, 20, WINED3DTSS_MAXMIPLEVEL               */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
2200     { /*6, 21, WINED3DTSS_MAXANISOTROPY             */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
2201     { /*6, 22, WINED3DTSS_BUMPENVLSCALE             */      STATE_TEXTURESTAGE(6, WINED3DTSS_BUMPENVLSCALE),    tex_bumpenvlscale   },
2202     { /*6, 23, WINED3DTSS_BUMPENVLOFFSET            */      STATE_TEXTURESTAGE(6, WINED3DTSS_BUMPENVLOFFSET),   tex_bumpenvloffset  },
2203     { /*6, 24, WINED3DTSS_TEXTURETRANSFORMFLAGS     */      0 /* for now, later stream sources */,              state_nogl          },
2204     { /*6, 25, WINED3DTSS_ADDRESSW                  */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
2205     { /*6, 26, WINED3DTSS_COLORARG0                 */      STATE_TEXTURESTAGE(6, WINED3DTSS_COLOROP),          tex_colorop         },
2206     { /*6, 27, WINED3DTSS_ALPHAARG0                 */      STATE_TEXTURESTAGE(6, WINED3DTSS_ALPHAOP),          tex_alphaop         },
2207     { /*6, 28, WINED3DTSS_RESULTARG                 */      STATE_TEXTURESTAGE(6, WINED3DTSS_RESULTARG),        tex_resultarg       },
2208     { /*6, 29, undefined                            */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
2209     { /*6, 30, undefined                            */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
2210     { /*6, 31, undefined                            */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
2211     { /*6, 32, WINED3DTSS_CONSTANT                  */      0 /* As long as we don't support D3DTA_CONSTANT */, state_nogl          },
2212
2213     { /*7, 01, WINED3DTSS_COLOROP                   */      STATE_TEXTURESTAGE(7, WINED3DTSS_COLOROP),          tex_colorop         },
2214     { /*7, 02, WINED3DTSS_COLORARG1                 */      STATE_TEXTURESTAGE(7, WINED3DTSS_COLOROP),          tex_colorop         },
2215     { /*7, 03, WINED3DTSS_COLORARG2                 */      STATE_TEXTURESTAGE(7, WINED3DTSS_COLOROP),          tex_colorop         },
2216     { /*7, 04, WINED3DTSS_ALPHAOP                   */      STATE_TEXTURESTAGE(7, WINED3DTSS_ALPHAOP),          tex_alphaop         },
2217     { /*7, 05, WINED3DTSS_ALPHAARG1                 */      STATE_TEXTURESTAGE(7, WINED3DTSS_ALPHAOP),          tex_alphaop         },
2218     { /*7, 06, WINED3DTSS_ALPHAARG2                 */      STATE_TEXTURESTAGE(7, WINED3DTSS_ALPHAOP),          tex_alphaop         },
2219     { /*7, 07, WINED3DTSS_BUMPENVMAT00              */      STATE_TEXTURESTAGE(7, WINED3DTSS_COLOROP),          tex_colorop         },
2220     { /*7, 08, WINED3DTSS_BUMPENVMAT01              */      STATE_TEXTURESTAGE(7, WINED3DTSS_COLOROP),          tex_colorop         },
2221     { /*7, 09, WINED3DTSS_BUMPENVMAT10              */      STATE_TEXTURESTAGE(7, WINED3DTSS_COLOROP),          tex_colorop         },
2222     { /*7, 10, WINED3DTSS_BUMPENVMAT11              */      STATE_TEXTURESTAGE(7, WINED3DTSS_COLOROP),          tex_colorop         },
2223     { /*7, 11, WINED3DTSS_TEXCOORDINDEX             */      STATE_TEXTURESTAGE(7, WINED3DTSS_TEXCOORDINDEX),    tex_coordindex      },
2224     { /*7, 12, WINED3DTSS_ADDRESS                   */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
2225     { /*7, 13, WINED3DTSS_ADDRESSU                  */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
2226     { /*7, 14, WINED3DTSS_ADDRESSV                  */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
2227     { /*7, 15, WINED3DTSS_BORDERCOLOR               */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
2228     { /*7, 16, WINED3DTSS_MAGFILTER                 */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
2229     { /*7, 17, WINED3DTSS_MINFILTER                 */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
2230     { /*7, 18, WINED3DTSS_MIPFILTER                 */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
2231     { /*7, 19, WINED3DTSS_MIPMAPLODBIAS             */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
2232     { /*7, 20, WINED3DTSS_MAXMIPLEVEL               */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
2233     { /*7, 21, WINED3DTSS_MAXANISOTROPY             */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
2234     { /*7, 22, WINED3DTSS_BUMPENVLSCALE             */      STATE_TEXTURESTAGE(7, WINED3DTSS_BUMPENVLSCALE),    tex_bumpenvlscale   },
2235     { /*7, 23, WINED3DTSS_BUMPENVLOFFSET            */      STATE_TEXTURESTAGE(7, WINED3DTSS_BUMPENVLOFFSET),   tex_bumpenvloffset  },
2236     { /*7, 24, WINED3DTSS_TEXTURETRANSFORMFLAGS     */      0 /* for now, later stream sources */,              state_nogl          },
2237     { /*7, 25, WINED3DTSS_ADDRESSW                  */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
2238     { /*7, 26, WINED3DTSS_COLORARG0                 */      STATE_TEXTURESTAGE(7, WINED3DTSS_COLOROP),          tex_colorop         },
2239     { /*7, 27, WINED3DTSS_ALPHAARG0                 */      STATE_TEXTURESTAGE(7, WINED3DTSS_ALPHAOP),          tex_alphaop         },
2240     { /*7, 28, WINED3DTSS_RESULTARG                 */      STATE_TEXTURESTAGE(7, WINED3DTSS_RESULTARG),        tex_resultarg       },
2241     { /*7, 29, undefined                            */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
2242     { /*7, 30, undefined                            */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
2243     { /*7, 31, undefined                            */      0 /* -> sampler state in ddraw / d3d8 */,           state_undefined     },
2244     { /*7, 32, WINED3DTSS_CONSTANT                  */      0 /* As long as we don't support D3DTA_CONSTANT */, state_nogl          },
2245     /* Sampler states */
2246     { /* 0, Sampler 0                               */      STATE_SAMPLER(0),                                   sampler             },
2247     { /* 1, Sampler 1                               */      STATE_SAMPLER(1),                                   sampler             },
2248     { /* 2, Sampler 2                               */      STATE_SAMPLER(2),                                   sampler             },
2249     { /* 3, Sampler 3                               */      STATE_SAMPLER(3),                                   sampler             },
2250     { /* 4, Sampler 3                               */      STATE_SAMPLER(4),                                   sampler             },
2251     { /* 5, Sampler 5                               */      STATE_SAMPLER(5),                                   sampler             },
2252     { /* 6, Sampler 6                               */      STATE_SAMPLER(6),                                   sampler             },
2253     { /* 7, Sampler 7                               */      STATE_SAMPLER(7),                                   sampler             },
2254     { /* 8, Sampler 8                               */      STATE_SAMPLER(8),                                   sampler             },
2255     { /* 9, Sampler 9                               */      STATE_SAMPLER(9),                                   sampler             },
2256     { /*10, Sampler 10                              */      STATE_SAMPLER(10),                                  sampler             },
2257     { /*11, Sampler 11                              */      STATE_SAMPLER(11),                                  sampler             },
2258     { /*12, Sampler 12                              */      STATE_SAMPLER(12),                                  sampler             },
2259     { /*13, Sampler 13                              */      STATE_SAMPLER(13),                                  sampler             },
2260     { /*14, Sampler 14                              */      STATE_SAMPLER(14),                                  sampler             },
2261     { /*15, Sampler 15                              */      STATE_SAMPLER(15),                                  sampler             },
2262     /* Pixel shader */
2263     { /*  , Pixel Shader                            */      STATE_PIXELSHADER,                                  pixelshader         },
2264 };