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

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