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 #if 0 /* FIXME: Use the buffer that is held by the device, this is ok since fixups will be skipped for software shaders
 329         it also requires entering a critical section but cuts down the runtime footprint of wined3d and any memory fragmentation that may occur... */
 330     if (This->device->fixupVertexBufferSize < SHADER_PGMSIZE) {
 331         HeapFree(GetProcessHeap(), 0, This->fixupVertexBuffer);
 332         This->fixupVertexBuffer = HeapAlloc(GetProcessHeap() , 0, SHADER_PGMSIZE);
 333         This->fixupVertexBufferSize = PGMSIZE;
 334         This->fixupVertexBuffer[0] = 0;
 335     }
 336     buffer.buffer = This->device->fixupVertexBuffer;
 337 #else
 338     buffer.buffer = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, SHADER_PGMSIZE);
 339 #endif
 340     buffer.bsize = 0;
 341     buffer.lineNo = 0;
 342     buffer.newline = TRUE;
 343
 344     ((IWineD3DDeviceImpl *)This->baseShader.device)->shader_backend->shader_generate_vshader(iface, &buffer);
 345
 346 #if 1 /* if were using the data buffer of device then we don't need to free it */
 347   HeapFree(GetProcessHeap(), 0, buffer.buffer);
 348 #endif
 349 }
 350
 351 /* *******************************************
 352    IWineD3DVertexShader IUnknown parts follow
 353    ******************************************* */
 354 static HRESULT  WINAPI IWineD3DVertexShaderImpl_QueryInterface(IWineD3DVertexShader *iface, REFIID riid, LPVOID *ppobj) {
 355     return IWineD3DBaseShaderImpl_QueryInterface((IWineD3DBaseShader *) iface, riid, ppobj);
 356 }
 357
 358 static ULONG  WINAPI IWineD3DVertexShaderImpl_AddRef(IWineD3DVertexShader *iface) {
 359     return IWineD3DBaseShaderImpl_AddRef((IWineD3DBaseShader *) iface);
 360 }
 361
 362 static ULONG WINAPI IWineD3DVertexShaderImpl_Release(IWineD3DVertexShader *iface) {
 363     return IWineD3DBaseShaderImpl_Release((IWineD3DBaseShader *) iface);
 364 }
 365
 366 /* *******************************************
 367    IWineD3DVertexShader IWineD3DVertexShader parts follow
 368    ******************************************* */
 369
 370 static HRESULT WINAPI IWineD3DVertexShaderImpl_GetParent(IWineD3DVertexShader *iface, IUnknown** parent){
 371     IWineD3DVertexShaderImpl *This = (IWineD3DVertexShaderImpl *)iface;
 372
 373     *parent = This->parent;
 374     IUnknown_AddRef(*parent);
 375     TRACE("(%p) : returning %p\n", This, *parent);
 376     return WINED3D_OK;
 377 }
 378
 379 static HRESULT WINAPI IWineD3DVertexShaderImpl_GetDevice(IWineD3DVertexShader* iface, IWineD3DDevice **pDevice){
 380     IWineD3DVertexShaderImpl *This = (IWineD3DVertexShaderImpl *)iface;
 381     IWineD3DDevice_AddRef(This->baseShader.device);
 382     *pDevice = This->baseShader.device;
 383     TRACE("(%p) returning %p\n", This, *pDevice);
 384     return WINED3D_OK;
 385 }
 386
 387 static HRESULT WINAPI IWineD3DVertexShaderImpl_GetFunction(IWineD3DVertexShader* impl, VOID* pData, UINT* pSizeOfData) {
 388     IWineD3DVertexShaderImpl *This = (IWineD3DVertexShaderImpl *)impl;
 389     TRACE("(%p) : pData(%p), pSizeOfData(%p)\n", This, pData, pSizeOfData);
 390
 391     if (NULL == pData) {
 392         *pSizeOfData = This->baseShader.functionLength;
 393         return WINED3D_OK;
 394     }
 395     if (*pSizeOfData < This->baseShader.functionLength) {
 396         /* MSDN claims (for d3d8 at least) that if *pSizeOfData is smaller
 397          * than the required size we should write the required size and
 398          * return D3DERR_MOREDATA. That's not actually true. */
 399         return WINED3DERR_INVALIDCALL;
 400     }
 401     if (NULL == This->baseShader.function) { /* no function defined */
 402         TRACE("(%p) : GetFunction no User Function defined using NULL to %p\n", This, pData);
 403         (*(DWORD **) pData) = NULL;
 404     } else {
 405         if(This->baseShader.functionLength == 0){
 406
 407         }
 408         TRACE("(%p) : GetFunction copying to %p\n", This, pData);
 409         memcpy(pData, This->baseShader.function, This->baseShader.functionLength);
 410     }
 411     return WINED3D_OK;
 412 }
 413
 414 /* Note that for vertex shaders CompileShader isn't called until the
 415  * shader is first used. The reason for this is that we need the vertex
 416  * declaration the shader will be used with in order to determine if
 417  * the data in a register is of type D3DCOLOR, and needs swizzling. */
 418 static HRESULT WINAPI IWineD3DVertexShaderImpl_SetFunction(IWineD3DVertexShader *iface, CONST DWORD *pFunction) {
 419
 420     IWineD3DVertexShaderImpl *This =(IWineD3DVertexShaderImpl *)iface;
 421     IWineD3DDeviceImpl *deviceImpl = (IWineD3DDeviceImpl *) This->baseShader.device;
 422     HRESULT hr;
 423     shader_reg_maps *reg_maps = &This->baseShader.reg_maps;
 424
 425     TRACE("(%p) : pFunction %p\n", iface, pFunction);
 426
 427     /* First pass: trace shader */
 428     shader_trace_init((IWineD3DBaseShader*) This, pFunction);
 429     vshader_set_limits(This);
 430
 431     /* Initialize immediate constant lists */
 432     list_init(&This->baseShader.constantsF);
 433     list_init(&This->baseShader.constantsB);
 434     list_init(&This->baseShader.constantsI);
 435
 436     /* Second pass: figure out registers used, semantics, etc.. */
 437     This->min_rel_offset = GL_LIMITS(vshader_constantsF);
 438     This->max_rel_offset = 0;
 439     memset(reg_maps, 0, sizeof(shader_reg_maps));
 440     hr = shader_get_registers_used((IWineD3DBaseShader*) This, reg_maps,
 441        This->semantics_in, This->semantics_out, pFunction, NULL);
 442     if (hr != WINED3D_OK) return hr;
 443
 444     This->baseShader.shader_mode = deviceImpl->vs_selected_mode;
 445
 446     if(deviceImpl->vs_selected_mode == SHADER_ARB &&
 447        (GLINFO_LOCATION).arb_vs_offset_limit      &&
 448        This->min_rel_offset <= This->max_rel_offset) {
 449
 450         if(This->max_rel_offset - This->min_rel_offset > 127) {
 451             FIXME("The difference between the minimum and maximum relative offset is > 127\n");
 452             FIXME("Which this OpenGL implementation does not support. Try using GLSL\n");
 453             FIXME("Min: %d, Max: %d\n", This->min_rel_offset, This->max_rel_offset);
 454         } else if(This->max_rel_offset - This->min_rel_offset > 63) {
 455             This->rel_offset = This->min_rel_offset + 63;
 456         } else if(This->max_rel_offset > 63) {
 457             This->rel_offset = This->min_rel_offset;
 458         } else {
 459             This->rel_offset = 0;
 460         }
 461     }
 462     This->baseShader.load_local_constsF = This->baseShader.reg_maps.usesrelconstF && !list_empty(&This->baseShader.constantsF);
 463
 464     /* copy the function ... because it will certainly be released by application */
 465     if (NULL != pFunction) {
 466         void *function;
 467
 468         function = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, This->baseShader.functionLength);
 469         if (!function) return E_OUTOFMEMORY;
 470         memcpy(function, pFunction, This->baseShader.functionLength);
 471         This->baseShader.function = function;
 472     } else {
 473         This->baseShader.function = NULL;
 474     }
 475
 476     return WINED3D_OK;
 477 }
 478
 479 /* Preload semantics for d3d8 shaders */
 480 static void WINAPI IWineD3DVertexShaderImpl_FakeSemantics(IWineD3DVertexShader *iface, IWineD3DVertexDeclaration *vertex_declaration) {
 481     IWineD3DVertexShaderImpl *This =(IWineD3DVertexShaderImpl *)iface;
 482     IWineD3DVertexDeclarationImpl* vdecl = (IWineD3DVertexDeclarationImpl*)vertex_declaration;
 483
 484     int i;
 485     for (i = 0; i < vdecl->declarationWNumElements - 1; ++i) {
 486         const WINED3DVERTEXELEMENT *element = vdecl->pDeclarationWine + i;
 487         vshader_set_input(This, element->Reg, element->Usage, element->UsageIndex);
 488     }
 489 }
 490
 491 /* Set local constants for d3d8 shaders */
 492 static HRESULT WINAPI IWIneD3DVertexShaderImpl_SetLocalConstantsF(IWineD3DVertexShader *iface,
 493         UINT start_idx, const float *src_data, UINT count) {
 494     IWineD3DVertexShaderImpl *This =(IWineD3DVertexShaderImpl *)iface;
 495     UINT i, end_idx;
 496
 497     TRACE("(%p) : start_idx %u, src_data %p, count %u\n", This, start_idx, src_data, count);
 498
 499     end_idx = start_idx + count;
 500     if (end_idx > GL_LIMITS(vshader_constantsF)) {
 501         WARN("end_idx %u > float constants limit %u\n", end_idx, GL_LIMITS(vshader_constantsF));
 502         end_idx = GL_LIMITS(vshader_constantsF);
 503     }
 504
 505     for (i = start_idx; i < end_idx; ++i) {
 506         local_constant* lconst = HeapAlloc(GetProcessHeap(), 0, sizeof(local_constant));
 507         if (!lconst) return E_OUTOFMEMORY;
 508
 509         lconst->idx = i;
 510         memcpy(lconst->value, src_data + (i - start_idx) * 4 /* 4 components */, 4 * sizeof(float));
 511         list_add_head(&This->baseShader.constantsF, &lconst->entry);
 512     }
 513
 514     return WINED3D_OK;
 515 }
 516
 517 static inline BOOL swizzled_attribs_differ(IWineD3DVertexShaderImpl *This, IWineD3DVertexDeclarationImpl *vdecl) {
 518     UINT i, j, k;
 519     BOOL found;
 520
 521     DWORD usage_token;
 522     DWORD usage;
 523     DWORD usage_idx;
 524
 525     for(i = 0; i < vdecl->declarationWNumElements; i++) {
 526         /* Ignore tesselated streams and the termination entry(position0, stream 255, unused) */
 527         if(vdecl->pDeclarationWine[i].Stream >= MAX_STREAMS ||
 528            vdecl->pDeclarationWine[i].Type == WINED3DDECLTYPE_UNUSED) continue;
 529
 530         for(j = 0; j < MAX_ATTRIBS; j++) {
 531             if(!This->baseShader.reg_maps.attributes[j]) continue;
 532
 533             usage_token = This->semantics_in[j].usage;
 534             usage = (usage_token & WINED3DSP_DCL_USAGE_MASK) >> WINED3DSP_DCL_USAGE_SHIFT;
 535             usage_idx = (usage_token & WINED3DSP_DCL_USAGEINDEX_MASK) >> WINED3DSP_DCL_USAGEINDEX_SHIFT;
 536
 537             if(vdecl->pDeclarationWine[i].Usage != usage ||
 538                vdecl->pDeclarationWine[i].UsageIndex != usage_idx) {
 539                 continue;
 540             }
 541
 542             found = FALSE;
 543             for(k = 0; k < This->num_swizzled_attribs; k++) {
 544                 if(This->swizzled_attribs[k].usage == usage &&
 545                     This->swizzled_attribs[k].idx == usage_idx) {
 546                     found = TRUE;
 547                 }
 548             }
 549             if(!found && vdecl->pDeclarationWine[i].Type == WINED3DDECLTYPE_D3DCOLOR) {
 550                 TRACE("Attribute %s%d is D3DCOLOR now but wasn't before\n",
 551                       debug_d3ddeclusage(usage), usage_idx);
 552                 return TRUE;
 553             }
 554             if( found && vdecl->pDeclarationWine[i].Type != WINED3DDECLTYPE_D3DCOLOR) {
 555                 TRACE("Attribute %s%d was D3DCOLOR before but is not any more\n",
 556                       debug_d3ddeclusage(usage), usage_idx);
 557                 return TRUE;
 558             }
 559         }
 560     }
 561     return FALSE;
 562 }
 563
 564 HRESULT IWineD3DVertexShaderImpl_CompileShader(IWineD3DVertexShader *iface) {
 565     IWineD3DVertexShaderImpl *This = (IWineD3DVertexShaderImpl *)iface;
 566     IWineD3DVertexDeclarationImpl *vdecl;
 567     CONST DWORD *function = This->baseShader.function;
 568     IWineD3DDeviceImpl *deviceImpl = (IWineD3DDeviceImpl *) This->baseShader.device;
 569
 570     TRACE("(%p) : function %p\n", iface, function);
 571
 572     /* We're already compiled. */
 573     if (This->baseShader.is_compiled) {
 574         vdecl = (IWineD3DVertexDeclarationImpl *) deviceImpl->stateBlock->vertexDecl;
 575
 576         if(This->num_swizzled_attribs != vdecl->num_swizzled_attribs ||
 577            memcmp(This->swizzled_attribs, vdecl->swizzled_attribs, sizeof(vdecl->swizzled_attribs[0]) * This->num_swizzled_attribs) != 0) {
 578
 579             /* The swizzled attributes differ between shader and declaration. This doesn't necessarily mean
 580              * we have to recompile, but we have to take a deeper look at see if the attribs that differ
 581              * are declared in the decl and used in the shader
 582              */
 583             if(swizzled_attribs_differ(This, vdecl)) {
 584                 WARN("Recompiling vertex shader %p due to D3DCOLOR input changes\n", This);
 585                 goto recompile;
 586             }
 587             WARN("Swizzled attribute validation required an expensive comparison\n");
 588         }
 589
 590         return WINED3D_OK;
 591
 592         recompile:
 593         if(This->recompile_count < 50) {
 594             This->recompile_count++;
 595         } else {
 596             FIXME("Vertexshader %p recompiled more than 50 times\n", This);
 597         }
 598
 599         deviceImpl->shader_backend->shader_destroy((IWineD3DBaseShader *) iface);
 600     }
 601
 602     /* We don't need to compile */
 603     if (!function) {
 604         This->baseShader.is_compiled = TRUE;
 605         return WINED3D_OK;
 606     }
 607
 608     /* Generate the HW shader */
 609     TRACE("(%p) : Generating hardware program\n", This);
 610     IWineD3DVertexShaderImpl_GenerateShader(iface, &This->baseShader.reg_maps, function);
 611
 612     This->baseShader.is_compiled = TRUE;
 613
 614     return WINED3D_OK;
 615 }
 616
 617 const IWineD3DVertexShaderVtbl IWineD3DVertexShader_Vtbl =
 618 {
 619     /*** IUnknown methods ***/
 620     IWineD3DVertexShaderImpl_QueryInterface,
 621     IWineD3DVertexShaderImpl_AddRef,
 622     IWineD3DVertexShaderImpl_Release,
 623     /*** IWineD3DBase methods ***/
 624     IWineD3DVertexShaderImpl_GetParent,
 625     /*** IWineD3DBaseShader methods ***/
 626     IWineD3DVertexShaderImpl_SetFunction,
 627     /*** IWineD3DVertexShader methods ***/
 628     IWineD3DVertexShaderImpl_GetDevice,
 629     IWineD3DVertexShaderImpl_GetFunction,
 630     IWineD3DVertexShaderImpl_FakeSemantics,
 631     IWIneD3DVertexShaderImpl_SetLocalConstantsF
 632 };