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

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