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     if (TRACE_ON(d3d_shader)) shader_trace_init(pFunction, This->baseShader.shader_ins);
 439
 440     /* Initialize immediate constant lists */
 441     list_init(&This->baseShader.constantsF);
 442     list_init(&This->baseShader.constantsB);
 443     list_init(&This->baseShader.constantsI);
 444
 445     /* Second pass: figure out registers used, semantics, etc.. */
 446     This->min_rel_offset = GL_LIMITS(vshader_constantsF);
 447     This->max_rel_offset = 0;
 448     memset(reg_maps, 0, sizeof(shader_reg_maps));
 449     hr = shader_get_registers_used((IWineD3DBaseShader*) This, reg_maps,
 450             This->semantics_in, This->semantics_out, pFunction);
 451     if (hr != WINED3D_OK) return hr;
 452
 453     vshader_set_limits(This);
 454
 455     This->baseShader.shader_mode = deviceImpl->vs_selected_mode;
 456
 457     if(deviceImpl->vs_selected_mode == SHADER_ARB &&
 458        (GLINFO_LOCATION).arb_vs_offset_limit      &&
 459        This->min_rel_offset <= This->max_rel_offset) {
 460
 461         if(This->max_rel_offset - This->min_rel_offset > 127) {
 462             FIXME("The difference between the minimum and maximum relative offset is > 127\n");
 463             FIXME("Which this OpenGL implementation does not support. Try using GLSL\n");
 464             FIXME("Min: %d, Max: %d\n", This->min_rel_offset, This->max_rel_offset);
 465         } else if(This->max_rel_offset - This->min_rel_offset > 63) {
 466             This->rel_offset = This->min_rel_offset + 63;
 467         } else if(This->max_rel_offset > 63) {
 468             This->rel_offset = This->min_rel_offset;
 469         } else {
 470             This->rel_offset = 0;
 471         }
 472     }
 473     This->baseShader.load_local_constsF = This->baseShader.reg_maps.usesrelconstF && !list_empty(&This->baseShader.constantsF);
 474
 475     /* copy the function ... because it will certainly be released by application */
 476     if (NULL != pFunction) {
 477         void *function;
 478
 479         function = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, This->baseShader.functionLength);
 480         if (!function) return E_OUTOFMEMORY;
 481         memcpy(function, pFunction, This->baseShader.functionLength);
 482         This->baseShader.function = function;
 483     } else {
 484         This->baseShader.function = NULL;
 485     }
 486
 487     return WINED3D_OK;
 488 }
 489
 490 /* Preload semantics for d3d8 shaders */
 491 static void WINAPI IWineD3DVertexShaderImpl_FakeSemantics(IWineD3DVertexShader *iface, IWineD3DVertexDeclaration *vertex_declaration) {
 492     IWineD3DVertexShaderImpl *This =(IWineD3DVertexShaderImpl *)iface;
 493     IWineD3DVertexDeclarationImpl* vdecl = (IWineD3DVertexDeclarationImpl*)vertex_declaration;
 494
 495     int i;
 496     for (i = 0; i < vdecl->declarationWNumElements - 1; ++i) {
 497         const WINED3DVERTEXELEMENT *element = vdecl->pDeclarationWine + i;
 498         vshader_set_input(This, element->Reg, element->Usage, element->UsageIndex);
 499     }
 500 }
 501
 502 /* Set local constants for d3d8 shaders */
 503 static HRESULT WINAPI IWIneD3DVertexShaderImpl_SetLocalConstantsF(IWineD3DVertexShader *iface,
 504         UINT start_idx, const float *src_data, UINT count) {
 505     IWineD3DVertexShaderImpl *This =(IWineD3DVertexShaderImpl *)iface;
 506     UINT i, end_idx;
 507
 508     TRACE("(%p) : start_idx %u, src_data %p, count %u\n", This, start_idx, src_data, count);
 509
 510     end_idx = start_idx + count;
 511     if (end_idx > GL_LIMITS(vshader_constantsF)) {
 512         WARN("end_idx %u > float constants limit %u\n", end_idx, GL_LIMITS(vshader_constantsF));
 513         end_idx = GL_LIMITS(vshader_constantsF);
 514     }
 515
 516     for (i = start_idx; i < end_idx; ++i) {
 517         local_constant* lconst = HeapAlloc(GetProcessHeap(), 0, sizeof(local_constant));
 518         if (!lconst) return E_OUTOFMEMORY;
 519
 520         lconst->idx = i;
 521         memcpy(lconst->value, src_data + (i - start_idx) * 4 /* 4 components */, 4 * sizeof(float));
 522         list_add_head(&This->baseShader.constantsF, &lconst->entry);
 523     }
 524
 525     return WINED3D_OK;
 526 }
 527
 528 static inline BOOL swizzled_attribs_differ(IWineD3DVertexShaderImpl *This, IWineD3DVertexDeclarationImpl *vdecl) {
 529     UINT i, j, k;
 530     BOOL found;
 531
 532     DWORD usage_token;
 533     DWORD usage;
 534     DWORD usage_idx;
 535
 536     for(i = 0; i < vdecl->declarationWNumElements; i++) {
 537         /* Ignore tesselated streams and the termination entry(position0, stream 255, unused) */
 538         if(vdecl->pDeclarationWine[i].Stream >= MAX_STREAMS ||
 539            vdecl->pDeclarationWine[i].Type == WINED3DDECLTYPE_UNUSED) continue;
 540
 541         for(j = 0; j < MAX_ATTRIBS; j++) {
 542             if(!This->baseShader.reg_maps.attributes[j]) continue;
 543
 544             usage_token = This->semantics_in[j].usage;
 545             usage = (usage_token & WINED3DSP_DCL_USAGE_MASK) >> WINED3DSP_DCL_USAGE_SHIFT;
 546             usage_idx = (usage_token & WINED3DSP_DCL_USAGEINDEX_MASK) >> WINED3DSP_DCL_USAGEINDEX_SHIFT;
 547
 548             if(vdecl->pDeclarationWine[i].Usage != usage ||
 549                vdecl->pDeclarationWine[i].UsageIndex != usage_idx) {
 550                 continue;
 551             }
 552
 553             found = FALSE;
 554             for(k = 0; k < This->num_swizzled_attribs; k++) {
 555                 if(This->swizzled_attribs[k].usage == usage &&
 556                     This->swizzled_attribs[k].idx == usage_idx) {
 557                     found = TRUE;
 558                 }
 559             }
 560             if(!found && vdecl->pDeclarationWine[i].Type == WINED3DDECLTYPE_D3DCOLOR) {
 561                 TRACE("Attribute %s%d is D3DCOLOR now but wasn't before\n",
 562                       debug_d3ddeclusage(usage), usage_idx);
 563                 return TRUE;
 564             }
 565             if( found && vdecl->pDeclarationWine[i].Type != WINED3DDECLTYPE_D3DCOLOR) {
 566                 TRACE("Attribute %s%d was D3DCOLOR before but is not any more\n",
 567                       debug_d3ddeclusage(usage), usage_idx);
 568                 return TRUE;
 569             }
 570         }
 571     }
 572     return FALSE;
 573 }
 574
 575 HRESULT IWineD3DVertexShaderImpl_CompileShader(IWineD3DVertexShader *iface) {
 576     IWineD3DVertexShaderImpl *This = (IWineD3DVertexShaderImpl *)iface;
 577     IWineD3DVertexDeclarationImpl *vdecl;
 578     CONST DWORD *function = This->baseShader.function;
 579     IWineD3DDeviceImpl *deviceImpl = (IWineD3DDeviceImpl *) This->baseShader.device;
 580
 581     TRACE("(%p) : function %p\n", iface, function);
 582
 583     /* We're already compiled. */
 584     if (This->baseShader.is_compiled) {
 585         vdecl = (IWineD3DVertexDeclarationImpl *) deviceImpl->stateBlock->vertexDecl;
 586
 587         if(This->num_swizzled_attribs != vdecl->num_swizzled_attribs ||
 588            memcmp(This->swizzled_attribs, vdecl->swizzled_attribs, sizeof(vdecl->swizzled_attribs[0]) * This->num_swizzled_attribs) != 0) {
 589
 590             /* The swizzled attributes differ between shader and declaration. This doesn't necessarily mean
 591              * we have to recompile, but we have to take a deeper look at see if the attribs that differ
 592              * are declared in the decl and used in the shader
 593              */
 594             if(swizzled_attribs_differ(This, vdecl)) {
 595                 WARN("Recompiling vertex shader %p due to D3DCOLOR input changes\n", This);
 596                 goto recompile;
 597             }
 598             WARN("Swizzled attribute validation required an expensive comparison\n");
 599         }
 600
 601         return WINED3D_OK;
 602
 603         recompile:
 604         if(This->recompile_count < 50) {
 605             This->recompile_count++;
 606         } else {
 607             FIXME("Vertexshader %p recompiled more than 50 times\n", This);
 608         }
 609
 610         deviceImpl->shader_backend->shader_destroy((IWineD3DBaseShader *) iface);
 611     }
 612
 613     /* We don't need to compile */
 614     if (!function) {
 615         This->baseShader.is_compiled = TRUE;
 616         return WINED3D_OK;
 617     }
 618
 619     /* Generate the HW shader */
 620     TRACE("(%p) : Generating hardware program\n", This);
 621     IWineD3DVertexShaderImpl_GenerateShader(iface, &This->baseShader.reg_maps, function);
 622
 623     This->baseShader.is_compiled = TRUE;
 624
 625     return WINED3D_OK;
 626 }
 627
 628 const IWineD3DVertexShaderVtbl IWineD3DVertexShader_Vtbl =
 629 {
 630     /*** IUnknown methods ***/
 631     IWineD3DVertexShaderImpl_QueryInterface,
 632     IWineD3DVertexShaderImpl_AddRef,
 633     IWineD3DVertexShaderImpl_Release,
 634     /*** IWineD3DBase methods ***/
 635     IWineD3DVertexShaderImpl_GetParent,
 636     /*** IWineD3DBaseShader methods ***/
 637     IWineD3DVertexShaderImpl_SetFunction,
 638     /*** IWineD3DVertexShader methods ***/
 639     IWineD3DVertexShaderImpl_GetDevice,
 640     IWineD3DVertexShaderImpl_GetFunction,
 641     IWineD3DVertexShaderImpl_FakeSemantics,
 642     IWIneD3DVertexShaderImpl_SetLocalConstantsF
 643 };