dlls/wined3d/vertexshader.c

   1 /*
   2  * shaders implementation
   3  *
   4  * Copyright 2002-2003 Jason Edmeades
   5  * Copyright 2002-2003 Raphael Junqueira
   6  * Copyright 2004 Christian Costa
   7  * Copyright 2005 Oliver Stieber
   8  * Copyright 2006 Ivan Gyurdiev
   9  * Copyright 2007-2008 Stefan Dösinger for CodeWeavers
  10  *
  11  * This library is free software; you can redistribute it and/or
  12  * modify it under the terms of the GNU Lesser General Public
  13  * License as published by the Free Software Foundation; either
  14  * version 2.1 of the License, or (at your option) any later version.
  15  *
  16  * This library is distributed in the hope that it will be useful,
  17  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  18  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  19  * Lesser General Public License for more details.
  20  *
  21  * You should have received a copy of the GNU Lesser General Public
  22  * License along with this library; if not, write to the Free Software
  23  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  24  */
  25
  26 #include "config.h"
  27
  28 #include <math.h>
  29 #include <stdio.h>
  30
  31 #include "wined3d_private.h"
  32
  33 WINE_DEFAULT_DEBUG_CHANNEL(d3d_shader);
  34
  35 #define GLINFO_LOCATION ((IWineD3DDeviceImpl *)This->baseShader.device)->adapter->gl_info
  36
  37 /* TODO: Vertex and Pixel shaders are almost identical, the only exception being the way that some of the data is looked up or the availability of some of the data i.e. some instructions are only valid for pshaders and some for vshaders
  38 because of this the bulk of the software pipeline can be shared between pixel and vertex shaders... and it wouldn't surprise me if the program can be cross compiled using a large body of shared code */
  39
  40 #define GLNAME_REQUIRE_GLSL  ((const char *)1)
  41
  42 CONST SHADER_OPCODE IWineD3DVertexShaderImpl_shader_ins[] = {
  43     /* This table is not order or position dependent. */
  44
  45     /* Arithmetic */
  46     {WINED3DSIO_NOP,     "nop",     "NOP",               0, 0, WINED3DSIH_NOP,     0,                      0                     },
  47     {WINED3DSIO_MOV,     "mov",     "MOV",               1, 2, WINED3DSIH_MOV,     0,                      0                     },
  48     {WINED3DSIO_MOVA,    "mova",    NULL,                1, 2, WINED3DSIH_MOVA,    WINED3DVS_VERSION(2,0), -1                    },
  49     {WINED3DSIO_ADD,     "add",     "ADD",               1, 3, WINED3DSIH_ADD,     0,                      0                     },
  50     {WINED3DSIO_SUB,     "sub",     "SUB",               1, 3, WINED3DSIH_SUB,     0,                      0                     },
  51     {WINED3DSIO_MAD,     "mad",     "MAD",               1, 4, WINED3DSIH_MAD,     0,                      0                     },
  52     {WINED3DSIO_MUL,     "mul",     "MUL",               1, 3, WINED3DSIH_MUL,     0,                      0                     },
  53     {WINED3DSIO_RCP,     "rcp",     "RCP",               1, 2, WINED3DSIH_RCP,     0,                      0                     },
  54     {WINED3DSIO_RSQ,     "rsq",     "RSQ",               1, 2, WINED3DSIH_RSQ,     0,                      0                     },
  55     {WINED3DSIO_DP3,     "dp3",     "DP3",               1, 3, WINED3DSIH_DP3,     0,                      0                     },
  56     {WINED3DSIO_DP4,     "dp4",     "DP4",               1, 3, WINED3DSIH_DP4,     0,                      0                     },
  57     {WINED3DSIO_MIN,     "min",     "MIN",               1, 3, WINED3DSIH_MIN,     0,                      0                     },
  58     {WINED3DSIO_MAX,     "max",     "MAX",               1, 3, WINED3DSIH_MAX,     0,                      0                     },
  59     {WINED3DSIO_SLT,     "slt",     "SLT",               1, 3, WINED3DSIH_SLT,     0,                      0                     },
  60     {WINED3DSIO_SGE,     "sge",     "SGE",               1, 3, WINED3DSIH_SGE,     0,                      0                     },
  61     {WINED3DSIO_ABS,     "abs",     "ABS",               1, 2, WINED3DSIH_ABS,     0,                      0                     },
  62     {WINED3DSIO_EXP,     "exp",     "EX2",               1, 2, WINED3DSIH_EXP,     0,                      0                     },
  63     {WINED3DSIO_LOG,     "log",     "LG2",               1, 2, WINED3DSIH_LOG,     0,                      0                     },
  64     {WINED3DSIO_EXPP,    "expp",    "EXP",               1, 2, WINED3DSIH_EXPP,    0,                      0                     },
  65     {WINED3DSIO_LOGP,    "logp",    "LOG",               1, 2, WINED3DSIH_LOGP,    0,                      0                     },
  66     {WINED3DSIO_LIT,     "lit",     "LIT",               1, 2, WINED3DSIH_LIT,     0,                      0                     },
  67     {WINED3DSIO_DST,     "dst",     "DST",               1, 3, WINED3DSIH_DST,     0,                      0                     },
  68     {WINED3DSIO_LRP,     "lrp",     "LRP",               1, 4, WINED3DSIH_LRP,     0,                      0                     },
  69     {WINED3DSIO_FRC,     "frc",     "FRC",               1, 2, WINED3DSIH_FRC,     0,                      0                     },
  70     {WINED3DSIO_POW,     "pow",     "POW",               1, 3, WINED3DSIH_POW,     0,                      0                     },
  71     {WINED3DSIO_CRS,     "crs",     "XPD",               1, 3, WINED3DSIH_CRS,     0,                      0                     },
  72     /* TODO: sng can possibly be performed a  s
  73         RCP tmp, vec
  74         MUL out, tmp, vec*/
  75     {WINED3DSIO_SGN,     "sgn",     NULL,                1, 2, WINED3DSIH_SGN,     0,                      0                     },
  76     {WINED3DSIO_NRM,     "nrm",     NULL,                1, 2, WINED3DSIH_NRM,     0,                      0                     },
  77     {WINED3DSIO_SINCOS,  "sincos",  NULL,                1, 4, WINED3DSIH_SINCOS,  WINED3DVS_VERSION(2,0), WINED3DVS_VERSION(2,1)},
  78     {WINED3DSIO_SINCOS,  "sincos",  "SCS",               1, 2, WINED3DSIH_SINCOS,  WINED3DVS_VERSION(3,0), -1                    },
  79     /* Matrix */
  80     {WINED3DSIO_M4x4,    "m4x4",    "undefined",         1, 3, WINED3DSIH_M4x4,    0,                      0                     },
  81     {WINED3DSIO_M4x3,    "m4x3",    "undefined",         1, 3, WINED3DSIH_M4x3,    0,                      0                     },
  82     {WINED3DSIO_M3x4,    "m3x4",    "undefined",         1, 3, WINED3DSIH_M3x4,    0,                      0                     },
  83     {WINED3DSIO_M3x3,    "m3x3",    "undefined",         1, 3, WINED3DSIH_M3x3,    0,                      0                     },
  84     {WINED3DSIO_M3x2,    "m3x2",    "undefined",         1, 3, WINED3DSIH_M3x2,    0,                      0                     },
  85     /* Declare registers */
  86     {WINED3DSIO_DCL,     "dcl",     NULL,                0, 2, WINED3DSIH_DCL,     0,                      0                     },
  87     /* Constant definitions */
  88     {WINED3DSIO_DEF,     "def",     NULL,                1, 5, WINED3DSIH_DEF,     0,                      0                     },
  89     {WINED3DSIO_DEFB,    "defb",    GLNAME_REQUIRE_GLSL, 1, 2, WINED3DSIH_DEFB,    0,                      0                     },
  90     {WINED3DSIO_DEFI,    "defi",    GLNAME_REQUIRE_GLSL, 1, 5, WINED3DSIH_DEFI,    0,                      0                     },
  91     /* Flow control - requires GLSL or software shaders */
  92     {WINED3DSIO_REP ,    "rep",     NULL,                0, 1, WINED3DSIH_REP,     WINED3DVS_VERSION(2,0), -1                    },
  93     {WINED3DSIO_ENDREP,  "endrep",  NULL,                0, 0, WINED3DSIH_ENDREP,  WINED3DVS_VERSION(2,0), -1                    },
  94     {WINED3DSIO_IF,      "if",      NULL,                0, 1, WINED3DSIH_IF,      WINED3DVS_VERSION(2,0), -1                    },
  95     {WINED3DSIO_IFC,     "ifc",     NULL,                0, 2, WINED3DSIH_IFC,     WINED3DVS_VERSION(2,1), -1                    },
  96     {WINED3DSIO_ELSE,    "else",    NULL,                0, 0, WINED3DSIH_ELSE,    WINED3DVS_VERSION(2,0), -1                    },
  97     {WINED3DSIO_ENDIF,   "endif",   NULL,                0, 0, WINED3DSIH_ENDIF,   WINED3DVS_VERSION(2,0), -1                    },
  98     {WINED3DSIO_BREAK,   "break",   NULL,                0, 0, WINED3DSIH_BREAK,   WINED3DVS_VERSION(2,1), -1                    },
  99     {WINED3DSIO_BREAKC,  "breakc",  NULL,                0, 2, WINED3DSIH_BREAKC,  WINED3DVS_VERSION(2,1), -1                    },
 100     {WINED3DSIO_BREAKP,  "breakp",  GLNAME_REQUIRE_GLSL, 0, 1, WINED3DSIH_BREAKP,  0,                      0                     },
 101     {WINED3DSIO_CALL,    "call",    NULL,                0, 1, WINED3DSIH_CALL,    WINED3DVS_VERSION(2,0), -1                    },
 102     {WINED3DSIO_CALLNZ,  "callnz",  NULL,                0, 2, WINED3DSIH_CALLNZ,  WINED3DVS_VERSION(2,0), -1                    },
 103     {WINED3DSIO_LOOP,    "loop",    NULL,                0, 2, WINED3DSIH_LOOP,    WINED3DVS_VERSION(2,0), -1                    },
 104     {WINED3DSIO_RET,     "ret",     NULL,                0, 0, WINED3DSIH_RET,     WINED3DVS_VERSION(2,0), -1                    },
 105     {WINED3DSIO_ENDLOOP, "endloop", NULL,                0, 0, WINED3DSIH_ENDLOOP, WINED3DVS_VERSION(2,0), -1                    },
 106     {WINED3DSIO_LABEL,   "label",   NULL,                0, 1, WINED3DSIH_LABEL,   WINED3DVS_VERSION(2,0), -1                    },
 107
 108     {WINED3DSIO_SETP,    "setp",    GLNAME_REQUIRE_GLSL, 1, 3, WINED3DSIH_SETP,    0,                      0                     },
 109     {WINED3DSIO_TEXLDL,  "texldl",  NULL,                1, 3, WINED3DSIH_TEXLDL,  WINED3DVS_VERSION(3,0), -1                    },
 110     {0,                  NULL,      NULL,                0, 0, 0,                  0,                      0                     }
 111 };
 112
 113 static void vshader_set_limits(
 114       IWineD3DVertexShaderImpl *This) {
 115
 116       This->baseShader.limits.texcoord = 0;
 117       This->baseShader.limits.attributes = 16;
 118       This->baseShader.limits.packed_input = 0;
 119
 120       /* Must match D3DCAPS9.MaxVertexShaderConst: at least 256 for vs_2_0 */
 121       This->baseShader.limits.constant_float = GL_LIMITS(vshader_constantsF);
 122
 123       switch (This->baseShader.hex_version) {
 124           case WINED3DVS_VERSION(1,0):
 125           case WINED3DVS_VERSION(1,1):
 126                    This->baseShader.limits.temporary = 12;
 127                    This->baseShader.limits.constant_bool = 0;
 128                    This->baseShader.limits.constant_int = 0;
 129                    This->baseShader.limits.address = 1;
 130                    This->baseShader.limits.packed_output = 0;
 131                    This->baseShader.limits.sampler = 0;
 132                    This->baseShader.limits.label = 0;
 133                    break;
 134
 135           case WINED3DVS_VERSION(2,0):
 136           case WINED3DVS_VERSION(2,1):
 137                    This->baseShader.limits.temporary = 12;
 138                    This->baseShader.limits.constant_bool = 16;
 139                    This->baseShader.limits.constant_int = 16;
 140                    This->baseShader.limits.address = 1;
 141                    This->baseShader.limits.packed_output = 0;
 142                    This->baseShader.limits.sampler = 0;
 143                    This->baseShader.limits.label = 16;
 144                    break;
 145
 146           case WINED3DVS_VERSION(3,0):
 147                    This->baseShader.limits.temporary = 32;
 148                    This->baseShader.limits.constant_bool = 32;
 149                    This->baseShader.limits.constant_int = 32;
 150                    This->baseShader.limits.address = 1;
 151                    This->baseShader.limits.packed_output = 12;
 152                    This->baseShader.limits.sampler = 4;
 153                    This->baseShader.limits.label = 16; /* FIXME: 2048 */
 154                    break;
 155
 156           default: This->baseShader.limits.temporary = 12;
 157                    This->baseShader.limits.constant_bool = 16;
 158                    This->baseShader.limits.constant_int = 16;
 159                    This->baseShader.limits.address = 1;
 160                    This->baseShader.limits.packed_output = 0;
 161                    This->baseShader.limits.sampler = 0;
 162                    This->baseShader.limits.label = 16;
 163                    FIXME("Unrecognized vertex shader version %#x\n",
 164                        This->baseShader.hex_version);
 165       }
 166 }
 167
 168 /* This is an internal function,
 169  * used to create fake semantics for shaders
 170  * that don't have them - d3d8 shaders where the declaration
 171  * stores the register for each input
 172  */
 173 static void vshader_set_input(
 174     IWineD3DVertexShaderImpl* This,
 175     unsigned int regnum,
 176     BYTE usage, BYTE usage_idx) {
 177
 178     /* Fake usage: set reserved bit, usage, usage_idx */
 179     DWORD usage_token = (0x1 << 31) |
 180         (usage << WINED3DSP_DCL_USAGE_SHIFT) | (usage_idx << WINED3DSP_DCL_USAGEINDEX_SHIFT);
 181
 182     /* Fake register; set reserved bit, regnum, type: input, wmask: all */
 183     DWORD reg_token = (0x1 << 31) |
 184         WINED3DSP_WRITEMASK_ALL | (WINED3DSPR_INPUT << WINED3DSP_REGTYPE_SHIFT) | regnum;
 185
 186     This->semantics_in[regnum].usage = usage_token;
 187     This->semantics_in[regnum].reg = reg_token;
 188 }
 189
 190 static BOOL match_usage(BYTE usage1, BYTE usage_idx1, BYTE usage2, BYTE usage_idx2) {
 191     if (usage_idx1 != usage_idx2) return FALSE;
 192     if (usage1 == usage2) return TRUE;
 193     if (usage1 == WINED3DDECLUSAGE_POSITION && usage2 == WINED3DDECLUSAGE_POSITIONT) return TRUE;
 194     if (usage2 == WINED3DDECLUSAGE_POSITION && usage1 == WINED3DDECLUSAGE_POSITIONT) return TRUE;
 195
 196     return FALSE;
 197 }
 198
 199 BOOL vshader_get_input(
 200     IWineD3DVertexShader* iface,
 201     BYTE usage_req, BYTE usage_idx_req,
 202     unsigned int* regnum) {
 203
 204     IWineD3DVertexShaderImpl* This = (IWineD3DVertexShaderImpl*) iface;
 205     int i;
 206
 207     for (i = 0; i < MAX_ATTRIBS; i++) {
 208         DWORD usage_token = This->semantics_in[i].usage;
 209         DWORD usage = (usage_token & WINED3DSP_DCL_USAGE_MASK) >> WINED3DSP_DCL_USAGE_SHIFT;
 210         DWORD usage_idx = (usage_token & WINED3DSP_DCL_USAGEINDEX_MASK) >> WINED3DSP_DCL_USAGEINDEX_SHIFT;
 211
 212         if (usage_token && match_usage(usage, usage_idx, usage_req, usage_idx_req)) {
 213             *regnum = i;
 214             return TRUE;
 215         }
 216     }
 217     return FALSE;
 218 }
 219
 220 BOOL vshader_input_is_color(
 221     IWineD3DVertexShader* iface,
 222     unsigned int regnum) {
 223
 224     IWineD3DVertexShaderImpl* This = (IWineD3DVertexShaderImpl*) iface;
 225
 226     DWORD usage_token = This->semantics_in[regnum].usage;
 227     DWORD usage = (usage_token & WINED3DSP_DCL_USAGE_MASK) >> WINED3DSP_DCL_USAGE_SHIFT;
 228     DWORD usage_idx = (usage_token & WINED3DSP_DCL_USAGEINDEX_MASK) >> WINED3DSP_DCL_USAGEINDEX_SHIFT;
 229
 230     int i;
 231
 232     for(i = 0; i < This->num_swizzled_attribs; i++) {
 233         if(This->swizzled_attribs[i].usage == usage &&
 234            This->swizzled_attribs[i].idx == usage_idx) {
 235             return TRUE;
 236         }
 237     }
 238     return FALSE;
 239 }
 240
 241 static inline void find_swizzled_attribs(IWineD3DVertexDeclaration *declaration, IWineD3DVertexShaderImpl *This) {
 242     UINT num = 0, i, j;
 243     UINT numoldswizzles = This->num_swizzled_attribs;
 244     IWineD3DVertexDeclarationImpl *decl = (IWineD3DVertexDeclarationImpl *) declaration;
 245
 246     DWORD usage_token, usage, usage_idx;
 247     BOOL found;
 248
 249     attrib_declaration oldswizzles[sizeof(This->swizzled_attribs) / sizeof(This->swizzled_attribs[0])];
 250
 251     /* Back up the old swizzles to keep attributes that are undefined in the current declaration */
 252     memcpy(oldswizzles, This->swizzled_attribs, sizeof(oldswizzles));
 253
 254     memset(This->swizzled_attribs, 0, sizeof(This->swizzled_attribs[0]) * MAX_ATTRIBS);
 255
 256     for(i = 0; i < decl->num_swizzled_attribs; i++) {
 257         for(j = 0; j < MAX_ATTRIBS; j++) {
 258
 259             if(!This->baseShader.reg_maps.attributes[j]) continue;
 260
 261             usage_token = This->semantics_in[j].usage;
 262             usage = (usage_token & WINED3DSP_DCL_USAGE_MASK) >> WINED3DSP_DCL_USAGE_SHIFT;
 263             usage_idx = (usage_token & WINED3DSP_DCL_USAGEINDEX_MASK) >> WINED3DSP_DCL_USAGEINDEX_SHIFT;
 264
 265             if(decl->swizzled_attribs[i].usage == usage &&
 266                decl->swizzled_attribs[i].idx == usage_idx) {
 267                 This->swizzled_attribs[num].usage = usage;
 268                 This->swizzled_attribs[num].idx = usage_idx;
 269                 num++;
 270             }
 271         }
 272     }
 273
 274     /* Add previously converted attributes back in if they are not defined in the current declaration */
 275     for(i = 0; i < numoldswizzles; i++) {
 276
 277         found = FALSE;
 278         for(j = 0; j < decl->declarationWNumElements; j++) {
 279             if(oldswizzles[i].usage == decl->pDeclarationWine[j].Usage &&
 280                oldswizzles[i].idx == decl->pDeclarationWine[j].UsageIndex) {
 281                 found = TRUE;
 282             }
 283         }
 284         if(found) {
 285             /* This previously converted attribute is declared in the current declaration. Either it is
 286              * already in the new array, or it should not be there. Skip it
 287              */
 288             continue;
 289         }
 290         /* We have a previously swizzled attribute that is not defined by the current vertex declaration.
 291          * Insert it into the new conversion array to keep it in the old defined state. Otherwise we end up
 292          * recompiling if the old decl is used again because undefined attributes are reset to no swizzling.
 293          * In the reverse way(attribute was not swizzled and is not declared in new declaration) the attrib
 294          * stays unswizzled as well because it isn't found in the oldswizzles array
 295          */
 296         for(j = 0; j < num; j++) {
 297             if(oldswizzles[i].usage > This->swizzled_attribs[j].usage || (
 298                oldswizzles[i].usage == This->swizzled_attribs[j].usage &&
 299                oldswizzles[i].idx > This->swizzled_attribs[j].idx)) {
 300                 memmove(&This->swizzled_attribs[j + 1], &This->swizzled_attribs[j],
 301                          sizeof(This->swizzled_attribs) - (sizeof(This->swizzled_attribs[0]) * (j + 1)));
 302                 break;
 303             }
 304         }
 305         This->swizzled_attribs[j].usage = oldswizzles[i].usage;
 306         This->swizzled_attribs[j].idx = oldswizzles[i].idx;
 307         num++;
 308     }
 309
 310     TRACE("New swizzled attributes array\n");
 311     for(i = 0; i < num; i++) {
 312         TRACE("%d: %s(%d), %d\n", i, debug_d3ddeclusage(This->swizzled_attribs[i].usage),
 313               This->swizzled_attribs[i].usage, This->swizzled_attribs[i].idx);
 314     }
 315     This->num_swizzled_attribs = num;
 316 }
 317 /** Generate a vertex shader string using either GL_VERTEX_PROGRAM_ARB
 318     or GLSL and send it to the card */
 319 static void IWineD3DVertexShaderImpl_GenerateShader(IWineD3DVertexShader *iface,
 320         const struct shader_reg_maps* reg_maps, const DWORD *pFunction)
 321 {
 322     IWineD3DVertexShaderImpl *This = (IWineD3DVertexShaderImpl *)iface;
 323     IWineD3DVertexDeclaration *decl = ((IWineD3DDeviceImpl *) This->baseShader.device)->stateBlock->vertexDecl;
 324     SHADER_BUFFER buffer;
 325
 326     find_swizzled_attribs(decl, This);
 327
 328     shader_buffer_init(&buffer);
 329     ((IWineD3DDeviceImpl *)This->baseShader.device)->shader_backend->shader_generate_vshader(iface, &buffer);
 330     shader_buffer_free(&buffer);
 331 }
 332
 333 /* *******************************************
 334    IWineD3DVertexShader IUnknown parts follow
 335    ******************************************* */
 336 static HRESULT  WINAPI IWineD3DVertexShaderImpl_QueryInterface(IWineD3DVertexShader *iface, REFIID riid, LPVOID *ppobj) {
 337     TRACE("iface %p, riid %s, ppobj %p\n", iface, debugstr_guid(riid), ppobj);
 338
 339     if (IsEqualGUID(riid, &IID_IWineD3DVertexShader)
 340             || IsEqualGUID(riid, &IID_IWineD3DBaseShader)
 341             || IsEqualGUID(riid, &IID_IWineD3DBase)
 342             || IsEqualGUID(riid, &IID_IUnknown))
 343     {
 344         IUnknown_AddRef(iface);
 345         *ppobj = iface;
 346         return S_OK;
 347     }
 348
 349     WARN("%s not implemented, returning E_NOINTERFACE\n", debugstr_guid(riid));
 350
 351     *ppobj = NULL;
 352     return E_NOINTERFACE;
 353 }
 354
 355 static ULONG  WINAPI IWineD3DVertexShaderImpl_AddRef(IWineD3DVertexShader *iface) {
 356     IWineD3DVertexShaderImpl *This = (IWineD3DVertexShaderImpl *)iface;
 357     ULONG refcount = InterlockedIncrement(&This->baseShader.ref);
 358
 359     TRACE("%p increasing refcount to %u\n", This, refcount);
 360
 361     return refcount;
 362 }
 363
 364 static ULONG WINAPI IWineD3DVertexShaderImpl_Release(IWineD3DVertexShader *iface) {
 365     IWineD3DVertexShaderImpl *This = (IWineD3DVertexShaderImpl *)iface;
 366     ULONG refcount = InterlockedDecrement(&This->baseShader.ref);
 367
 368     TRACE("%p decreasing refcount to %u\n", This, refcount);
 369
 370     if (!refcount)
 371     {
 372         shader_cleanup((IWineD3DBaseShader *)iface);
 373         HeapFree(GetProcessHeap(), 0, This);
 374     }
 375
 376     return refcount;
 377 }
 378
 379 /* *******************************************
 380    IWineD3DVertexShader IWineD3DVertexShader parts follow
 381    ******************************************* */
 382
 383 static HRESULT WINAPI IWineD3DVertexShaderImpl_GetParent(IWineD3DVertexShader *iface, IUnknown** parent){
 384     IWineD3DVertexShaderImpl *This = (IWineD3DVertexShaderImpl *)iface;
 385
 386     *parent = This->parent;
 387     IUnknown_AddRef(*parent);
 388     TRACE("(%p) : returning %p\n", This, *parent);
 389     return WINED3D_OK;
 390 }
 391
 392 static HRESULT WINAPI IWineD3DVertexShaderImpl_GetDevice(IWineD3DVertexShader* iface, IWineD3DDevice **pDevice){
 393     IWineD3DVertexShaderImpl *This = (IWineD3DVertexShaderImpl *)iface;
 394     IWineD3DDevice_AddRef(This->baseShader.device);
 395     *pDevice = This->baseShader.device;
 396     TRACE("(%p) returning %p\n", This, *pDevice);
 397     return WINED3D_OK;
 398 }
 399
 400 static HRESULT WINAPI IWineD3DVertexShaderImpl_GetFunction(IWineD3DVertexShader* impl, VOID* pData, UINT* pSizeOfData) {
 401     IWineD3DVertexShaderImpl *This = (IWineD3DVertexShaderImpl *)impl;
 402     TRACE("(%p) : pData(%p), pSizeOfData(%p)\n", This, pData, pSizeOfData);
 403
 404     if (NULL == pData) {
 405         *pSizeOfData = This->baseShader.functionLength;
 406         return WINED3D_OK;
 407     }
 408     if (*pSizeOfData < This->baseShader.functionLength) {
 409         /* MSDN claims (for d3d8 at least) that if *pSizeOfData is smaller
 410          * than the required size we should write the required size and
 411          * return D3DERR_MOREDATA. That's not actually true. */
 412         return WINED3DERR_INVALIDCALL;
 413     }
 414     if (NULL == This->baseShader.function) { /* no function defined */
 415         TRACE("(%p) : GetFunction no User Function defined using NULL to %p\n", This, pData);
 416         (*(DWORD **) pData) = NULL;
 417     } else {
 418         TRACE("(%p) : GetFunction copying to %p\n", This, pData);
 419         memcpy(pData, This->baseShader.function, This->baseShader.functionLength);
 420     }
 421     return WINED3D_OK;
 422 }
 423
 424 /* Note that for vertex shaders CompileShader isn't called until the
 425  * shader is first used. The reason for this is that we need the vertex
 426  * declaration the shader will be used with in order to determine if
 427  * the data in a register is of type D3DCOLOR, and needs swizzling. */
 428 static HRESULT WINAPI IWineD3DVertexShaderImpl_SetFunction(IWineD3DVertexShader *iface, CONST DWORD *pFunction) {
 429
 430     IWineD3DVertexShaderImpl *This =(IWineD3DVertexShaderImpl *)iface;
 431     IWineD3DDeviceImpl *deviceImpl = (IWineD3DDeviceImpl *) This->baseShader.device;
 432     HRESULT hr;
 433     shader_reg_maps *reg_maps = &This->baseShader.reg_maps;
 434
 435     TRACE("(%p) : pFunction %p\n", iface, pFunction);
 436
 437     /* First pass: trace shader */
 438     shader_trace_init((IWineD3DBaseShader*) This, pFunction);
 439     vshader_set_limits(This);
 440
 441     /* Initialize immediate constant lists */
 442     list_init(&This->baseShader.constantsF);
 443     list_init(&This->baseShader.constantsB);
 444     list_init(&This->baseShader.constantsI);
 445
 446     /* Second pass: figure out registers used, semantics, etc.. */
 447     This->min_rel_offset = GL_LIMITS(vshader_constantsF);
 448     This->max_rel_offset = 0;
 449     memset(reg_maps, 0, sizeof(shader_reg_maps));
 450     hr = shader_get_registers_used((IWineD3DBaseShader*) This, reg_maps,
 451        This->semantics_in, This->semantics_out, pFunction, NULL);
 452     if (hr != WINED3D_OK) return hr;
 453
 454     This->baseShader.shader_mode = deviceImpl->vs_selected_mode;
 455
 456     if(deviceImpl->vs_selected_mode == SHADER_ARB &&
 457        (GLINFO_LOCATION).arb_vs_offset_limit      &&
 458        This->min_rel_offset <= This->max_rel_offset) {
 459
 460         if(This->max_rel_offset - This->min_rel_offset > 127) {
 461             FIXME("The difference between the minimum and maximum relative offset is > 127\n");
 462             FIXME("Which this OpenGL implementation does not support. Try using GLSL\n");
 463             FIXME("Min: %d, Max: %d\n", This->min_rel_offset, This->max_rel_offset);
 464         } else if(This->max_rel_offset - This->min_rel_offset > 63) {
 465             This->rel_offset = This->min_rel_offset + 63;
 466         } else if(This->max_rel_offset > 63) {
 467             This->rel_offset = This->min_rel_offset;
 468         } else {
 469             This->rel_offset = 0;
 470         }
 471     }
 472     This->baseShader.load_local_constsF = This->baseShader.reg_maps.usesrelconstF && !list_empty(&This->baseShader.constantsF);
 473
 474     /* copy the function ... because it will certainly be released by application */
 475     if (NULL != pFunction) {
 476         void *function;
 477
 478         function = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, This->baseShader.functionLength);
 479         if (!function) return E_OUTOFMEMORY;
 480         memcpy(function, pFunction, This->baseShader.functionLength);
 481         This->baseShader.function = function;
 482     } else {
 483         This->baseShader.function = NULL;
 484     }
 485
 486     return WINED3D_OK;
 487 }
 488
 489 /* Preload semantics for d3d8 shaders */
 490 static void WINAPI IWineD3DVertexShaderImpl_FakeSemantics(IWineD3DVertexShader *iface, IWineD3DVertexDeclaration *vertex_declaration) {
 491     IWineD3DVertexShaderImpl *This =(IWineD3DVertexShaderImpl *)iface;
 492     IWineD3DVertexDeclarationImpl* vdecl = (IWineD3DVertexDeclarationImpl*)vertex_declaration;
 493
 494     int i;
 495     for (i = 0; i < vdecl->declarationWNumElements - 1; ++i) {
 496         const WINED3DVERTEXELEMENT *element = vdecl->pDeclarationWine + i;
 497         vshader_set_input(This, element->Reg, element->Usage, element->UsageIndex);
 498     }
 499 }
 500
 501 /* Set local constants for d3d8 shaders */
 502 static HRESULT WINAPI IWIneD3DVertexShaderImpl_SetLocalConstantsF(IWineD3DVertexShader *iface,
 503         UINT start_idx, const float *src_data, UINT count) {
 504     IWineD3DVertexShaderImpl *This =(IWineD3DVertexShaderImpl *)iface;
 505     UINT i, end_idx;
 506
 507     TRACE("(%p) : start_idx %u, src_data %p, count %u\n", This, start_idx, src_data, count);
 508
 509     end_idx = start_idx + count;
 510     if (end_idx > GL_LIMITS(vshader_constantsF)) {
 511         WARN("end_idx %u > float constants limit %u\n", end_idx, GL_LIMITS(vshader_constantsF));
 512         end_idx = GL_LIMITS(vshader_constantsF);
 513     }
 514
 515     for (i = start_idx; i < end_idx; ++i) {
 516         local_constant* lconst = HeapAlloc(GetProcessHeap(), 0, sizeof(local_constant));
 517         if (!lconst) return E_OUTOFMEMORY;
 518
 519         lconst->idx = i;
 520         memcpy(lconst->value, src_data + (i - start_idx) * 4 /* 4 components */, 4 * sizeof(float));
 521         list_add_head(&This->baseShader.constantsF, &lconst->entry);
 522     }
 523
 524     return WINED3D_OK;
 525 }
 526
 527 static inline BOOL swizzled_attribs_differ(IWineD3DVertexShaderImpl *This, IWineD3DVertexDeclarationImpl *vdecl) {
 528     UINT i, j, k;
 529     BOOL found;
 530
 531     DWORD usage_token;
 532     DWORD usage;
 533     DWORD usage_idx;
 534
 535     for(i = 0; i < vdecl->declarationWNumElements; i++) {
 536         /* Ignore tesselated streams and the termination entry(position0, stream 255, unused) */
 537         if(vdecl->pDeclarationWine[i].Stream >= MAX_STREAMS ||
 538            vdecl->pDeclarationWine[i].Type == WINED3DDECLTYPE_UNUSED) continue;
 539
 540         for(j = 0; j < MAX_ATTRIBS; j++) {
 541             if(!This->baseShader.reg_maps.attributes[j]) continue;
 542
 543             usage_token = This->semantics_in[j].usage;
 544             usage = (usage_token & WINED3DSP_DCL_USAGE_MASK) >> WINED3DSP_DCL_USAGE_SHIFT;
 545             usage_idx = (usage_token & WINED3DSP_DCL_USAGEINDEX_MASK) >> WINED3DSP_DCL_USAGEINDEX_SHIFT;
 546
 547             if(vdecl->pDeclarationWine[i].Usage != usage ||
 548                vdecl->pDeclarationWine[i].UsageIndex != usage_idx) {
 549                 continue;
 550             }
 551
 552             found = FALSE;
 553             for(k = 0; k < This->num_swizzled_attribs; k++) {
 554                 if(This->swizzled_attribs[k].usage == usage &&
 555                     This->swizzled_attribs[k].idx == usage_idx) {
 556                     found = TRUE;
 557                 }
 558             }
 559             if(!found && vdecl->pDeclarationWine[i].Type == WINED3DDECLTYPE_D3DCOLOR) {
 560                 TRACE("Attribute %s%d is D3DCOLOR now but wasn't before\n",
 561                       debug_d3ddeclusage(usage), usage_idx);
 562                 return TRUE;
 563             }
 564             if( found && vdecl->pDeclarationWine[i].Type != WINED3DDECLTYPE_D3DCOLOR) {
 565                 TRACE("Attribute %s%d was D3DCOLOR before but is not any more\n",
 566                       debug_d3ddeclusage(usage), usage_idx);
 567                 return TRUE;
 568             }
 569         }
 570     }
 571     return FALSE;
 572 }
 573
 574 HRESULT IWineD3DVertexShaderImpl_CompileShader(IWineD3DVertexShader *iface) {
 575     IWineD3DVertexShaderImpl *This = (IWineD3DVertexShaderImpl *)iface;
 576     IWineD3DVertexDeclarationImpl *vdecl;
 577     CONST DWORD *function = This->baseShader.function;
 578     IWineD3DDeviceImpl *deviceImpl = (IWineD3DDeviceImpl *) This->baseShader.device;
 579
 580     TRACE("(%p) : function %p\n", iface, function);
 581
 582     /* We're already compiled. */
 583     if (This->baseShader.is_compiled) {
 584         vdecl = (IWineD3DVertexDeclarationImpl *) deviceImpl->stateBlock->vertexDecl;
 585
 586         if(This->num_swizzled_attribs != vdecl->num_swizzled_attribs ||
 587            memcmp(This->swizzled_attribs, vdecl->swizzled_attribs, sizeof(vdecl->swizzled_attribs[0]) * This->num_swizzled_attribs) != 0) {
 588
 589             /* The swizzled attributes differ between shader and declaration. This doesn't necessarily mean
 590              * we have to recompile, but we have to take a deeper look at see if the attribs that differ
 591              * are declared in the decl and used in the shader
 592              */
 593             if(swizzled_attribs_differ(This, vdecl)) {
 594                 WARN("Recompiling vertex shader %p due to D3DCOLOR input changes\n", This);
 595                 goto recompile;
 596             }
 597             WARN("Swizzled attribute validation required an expensive comparison\n");
 598         }
 599
 600         return WINED3D_OK;
 601
 602         recompile:
 603         if(This->recompile_count < 50) {
 604             This->recompile_count++;
 605         } else {
 606             FIXME("Vertexshader %p recompiled more than 50 times\n", This);
 607         }
 608
 609         deviceImpl->shader_backend->shader_destroy((IWineD3DBaseShader *) iface);
 610     }
 611
 612     /* We don't need to compile */
 613     if (!function) {
 614         This->baseShader.is_compiled = TRUE;
 615         return WINED3D_OK;
 616     }
 617
 618     /* Generate the HW shader */
 619     TRACE("(%p) : Generating hardware program\n", This);
 620     IWineD3DVertexShaderImpl_GenerateShader(iface, &This->baseShader.reg_maps, function);
 621
 622     This->baseShader.is_compiled = TRUE;
 623
 624     return WINED3D_OK;
 625 }
 626
 627 const IWineD3DVertexShaderVtbl IWineD3DVertexShader_Vtbl =
 628 {
 629     /*** IUnknown methods ***/
 630     IWineD3DVertexShaderImpl_QueryInterface,
 631     IWineD3DVertexShaderImpl_AddRef,
 632     IWineD3DVertexShaderImpl_Release,
 633     /*** IWineD3DBase methods ***/
 634     IWineD3DVertexShaderImpl_GetParent,
 635     /*** IWineD3DBaseShader methods ***/
 636     IWineD3DVertexShaderImpl_SetFunction,
 637     /*** IWineD3DVertexShader methods ***/
 638     IWineD3DVertexShaderImpl_GetDevice,
 639     IWineD3DVertexShaderImpl_GetFunction,
 640     IWineD3DVertexShaderImpl_FakeSemantics,
 641     IWIneD3DVertexShaderImpl_SetLocalConstantsF
 642 };