rsaenh: Use helper function to install keys.
[wine] / 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",     0, 0, WINED3DSIH_NOP,     0,                      0                     },
47     {WINED3DSIO_MOV,     "mov",     1, 2, WINED3DSIH_MOV,     0,                      0                     },
48     {WINED3DSIO_MOVA,    "mova",    1, 2, WINED3DSIH_MOVA,    WINED3DVS_VERSION(2,0), -1                    },
49     {WINED3DSIO_ADD,     "add",     1, 3, WINED3DSIH_ADD,     0,                      0                     },
50     {WINED3DSIO_SUB,     "sub",     1, 3, WINED3DSIH_SUB,     0,                      0                     },
51     {WINED3DSIO_MAD,     "mad",     1, 4, WINED3DSIH_MAD,     0,                      0                     },
52     {WINED3DSIO_MUL,     "mul",     1, 3, WINED3DSIH_MUL,     0,                      0                     },
53     {WINED3DSIO_RCP,     "rcp",     1, 2, WINED3DSIH_RCP,     0,                      0                     },
54     {WINED3DSIO_RSQ,     "rsq",     1, 2, WINED3DSIH_RSQ,     0,                      0                     },
55     {WINED3DSIO_DP3,     "dp3",     1, 3, WINED3DSIH_DP3,     0,                      0                     },
56     {WINED3DSIO_DP4,     "dp4",     1, 3, WINED3DSIH_DP4,     0,                      0                     },
57     {WINED3DSIO_MIN,     "min",     1, 3, WINED3DSIH_MIN,     0,                      0                     },
58     {WINED3DSIO_MAX,     "max",     1, 3, WINED3DSIH_MAX,     0,                      0                     },
59     {WINED3DSIO_SLT,     "slt",     1, 3, WINED3DSIH_SLT,     0,                      0                     },
60     {WINED3DSIO_SGE,     "sge",     1, 3, WINED3DSIH_SGE,     0,                      0                     },
61     {WINED3DSIO_ABS,     "abs",     1, 2, WINED3DSIH_ABS,     0,                      0                     },
62     {WINED3DSIO_EXP,     "exp",     1, 2, WINED3DSIH_EXP,     0,                      0                     },
63     {WINED3DSIO_LOG,     "log",     1, 2, WINED3DSIH_LOG,     0,                      0                     },
64     {WINED3DSIO_EXPP,    "expp",    1, 2, WINED3DSIH_EXPP,    0,                      0                     },
65     {WINED3DSIO_LOGP,    "logp",    1, 2, WINED3DSIH_LOGP,    0,                      0                     },
66     {WINED3DSIO_LIT,     "lit",     1, 2, WINED3DSIH_LIT,     0,                      0                     },
67     {WINED3DSIO_DST,     "dst",     1, 3, WINED3DSIH_DST,     0,                      0                     },
68     {WINED3DSIO_LRP,     "lrp",     1, 4, WINED3DSIH_LRP,     0,                      0                     },
69     {WINED3DSIO_FRC,     "frc",     1, 2, WINED3DSIH_FRC,     0,                      0                     },
70     {WINED3DSIO_POW,     "pow",     1, 3, WINED3DSIH_POW,     0,                      0                     },
71     {WINED3DSIO_CRS,     "crs",     1, 3, WINED3DSIH_CRS,     0,                      0                     },
72     /* TODO: sng can possibly be performed as
73         RCP tmp, vec
74         MUL out, tmp, vec*/
75     {WINED3DSIO_SGN,     "sgn",     1, 2, WINED3DSIH_SGN,     0,                      0                     },
76     {WINED3DSIO_NRM,     "nrm",     1, 2, WINED3DSIH_NRM,     0,                      0                     },
77     {WINED3DSIO_SINCOS,  "sincos",  1, 4, WINED3DSIH_SINCOS,  WINED3DVS_VERSION(2,0), WINED3DVS_VERSION(2,1)},
78     {WINED3DSIO_SINCOS,  "sincos",  1, 2, WINED3DSIH_SINCOS,  WINED3DVS_VERSION(3,0), -1                    },
79     /* Matrix */
80     {WINED3DSIO_M4x4,    "m4x4",    1, 3, WINED3DSIH_M4x4,    0,                      0                     },
81     {WINED3DSIO_M4x3,    "m4x3",    1, 3, WINED3DSIH_M4x3,    0,                      0                     },
82     {WINED3DSIO_M3x4,    "m3x4",    1, 3, WINED3DSIH_M3x4,    0,                      0                     },
83     {WINED3DSIO_M3x3,    "m3x3",    1, 3, WINED3DSIH_M3x3,    0,                      0                     },
84     {WINED3DSIO_M3x2,    "m3x2",    1, 3, WINED3DSIH_M3x2,    0,                      0                     },
85     /* Declare registers */
86     {WINED3DSIO_DCL,     "dcl",     0, 2, WINED3DSIH_DCL,     0,                      0                     },
87     /* Constant definitions */
88     {WINED3DSIO_DEF,     "def",     1, 5, WINED3DSIH_DEF,     0,                      0                     },
89     {WINED3DSIO_DEFB,    "defb",    1, 2, WINED3DSIH_DEFB,    0,                      0                     },
90     {WINED3DSIO_DEFI,    "defi",    1, 5, WINED3DSIH_DEFI,    0,                      0                     },
91     /* Flow control - requires GLSL or software shaders */
92     {WINED3DSIO_REP ,    "rep",     0, 1, WINED3DSIH_REP,     WINED3DVS_VERSION(2,0), -1                    },
93     {WINED3DSIO_ENDREP,  "endrep",  0, 0, WINED3DSIH_ENDREP,  WINED3DVS_VERSION(2,0), -1                    },
94     {WINED3DSIO_IF,      "if",      0, 1, WINED3DSIH_IF,      WINED3DVS_VERSION(2,0), -1                    },
95     {WINED3DSIO_IFC,     "ifc",     0, 2, WINED3DSIH_IFC,     WINED3DVS_VERSION(2,1), -1                    },
96     {WINED3DSIO_ELSE,    "else",    0, 0, WINED3DSIH_ELSE,    WINED3DVS_VERSION(2,0), -1                    },
97     {WINED3DSIO_ENDIF,   "endif",   0, 0, WINED3DSIH_ENDIF,   WINED3DVS_VERSION(2,0), -1                    },
98     {WINED3DSIO_BREAK,   "break",   0, 0, WINED3DSIH_BREAK,   WINED3DVS_VERSION(2,1), -1                    },
99     {WINED3DSIO_BREAKC,  "breakc",  0, 2, WINED3DSIH_BREAKC,  WINED3DVS_VERSION(2,1), -1                    },
100     {WINED3DSIO_BREAKP,  "breakp",  0, 1, WINED3DSIH_BREAKP,  0,                      0                     },
101     {WINED3DSIO_CALL,    "call",    0, 1, WINED3DSIH_CALL,    WINED3DVS_VERSION(2,0), -1                    },
102     {WINED3DSIO_CALLNZ,  "callnz",  0, 2, WINED3DSIH_CALLNZ,  WINED3DVS_VERSION(2,0), -1                    },
103     {WINED3DSIO_LOOP,    "loop",    0, 2, WINED3DSIH_LOOP,    WINED3DVS_VERSION(2,0), -1                    },
104     {WINED3DSIO_RET,     "ret",     0, 0, WINED3DSIH_RET,     WINED3DVS_VERSION(2,0), -1                    },
105     {WINED3DSIO_ENDLOOP, "endloop", 0, 0, WINED3DSIH_ENDLOOP, WINED3DVS_VERSION(2,0), -1                    },
106     {WINED3DSIO_LABEL,   "label",   0, 1, WINED3DSIH_LABEL,   WINED3DVS_VERSION(2,0), -1                    },
107
108     {WINED3DSIO_SETP,    "setp",    1, 3, WINED3DSIH_SETP,    0,                      0                     },
109     {WINED3DSIO_TEXLDL,  "texldl",  1, 3, WINED3DSIH_TEXLDL,  WINED3DVS_VERSION(3,0), -1                    },
110     {0,                  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.reg_maps.shader_version)
124       {
125           case WINED3DVS_VERSION(1,0):
126           case WINED3DVS_VERSION(1,1):
127                    This->baseShader.limits.temporary = 12;
128                    This->baseShader.limits.constant_bool = 0;
129                    This->baseShader.limits.constant_int = 0;
130                    This->baseShader.limits.address = 1;
131                    This->baseShader.limits.packed_output = 0;
132                    This->baseShader.limits.sampler = 0;
133                    This->baseShader.limits.label = 0;
134                    break;
135       
136           case WINED3DVS_VERSION(2,0):
137           case WINED3DVS_VERSION(2,1):
138                    This->baseShader.limits.temporary = 12;
139                    This->baseShader.limits.constant_bool = 16;
140                    This->baseShader.limits.constant_int = 16;
141                    This->baseShader.limits.address = 1;
142                    This->baseShader.limits.packed_output = 0;
143                    This->baseShader.limits.sampler = 0;
144                    This->baseShader.limits.label = 16;
145                    break;
146
147           case WINED3DVS_VERSION(3,0):
148                    This->baseShader.limits.temporary = 32;
149                    This->baseShader.limits.constant_bool = 32;
150                    This->baseShader.limits.constant_int = 32;
151                    This->baseShader.limits.address = 1;
152                    This->baseShader.limits.packed_output = 12;
153                    This->baseShader.limits.sampler = 4;
154                    This->baseShader.limits.label = 16; /* FIXME: 2048 */
155                    break;
156
157           default: This->baseShader.limits.temporary = 12;
158                    This->baseShader.limits.constant_bool = 16;
159                    This->baseShader.limits.constant_int = 16;
160                    This->baseShader.limits.address = 1;
161                    This->baseShader.limits.packed_output = 0;
162                    This->baseShader.limits.sampler = 0;
163                    This->baseShader.limits.label = 16;
164                    FIXME("Unrecognized vertex shader version %#x\n",
165                            This->baseShader.reg_maps.shader_version);
166       }
167 }
168
169 /* This is an internal function,
170  * used to create fake semantics for shaders
171  * that don't have them - d3d8 shaders where the declaration
172  * stores the register for each input
173  */
174 static void vshader_set_input(
175     IWineD3DVertexShaderImpl* This,
176     unsigned int regnum,
177     BYTE usage, BYTE usage_idx) {
178
179     /* Fake usage: set reserved bit, usage, usage_idx */
180     DWORD usage_token = (0x1 << 31) |
181         (usage << WINED3DSP_DCL_USAGE_SHIFT) | (usage_idx << WINED3DSP_DCL_USAGEINDEX_SHIFT);
182
183     /* Fake register; set reserved bit, regnum, type: input, wmask: all */
184     DWORD reg_token = (0x1 << 31) |
185         WINED3DSP_WRITEMASK_ALL | (WINED3DSPR_INPUT << WINED3DSP_REGTYPE_SHIFT) | regnum;
186
187     This->semantics_in[regnum].usage = usage_token;
188     This->semantics_in[regnum].reg = reg_token;
189 }
190
191 static BOOL match_usage(BYTE usage1, BYTE usage_idx1, BYTE usage2, BYTE usage_idx2) {
192     if (usage_idx1 != usage_idx2) return FALSE;
193     if (usage1 == usage2) return TRUE;
194     if (usage1 == WINED3DDECLUSAGE_POSITION && usage2 == WINED3DDECLUSAGE_POSITIONT) return TRUE;
195     if (usage2 == WINED3DDECLUSAGE_POSITION && usage1 == WINED3DDECLUSAGE_POSITIONT) return TRUE;
196
197     return FALSE;
198 }
199
200 BOOL vshader_get_input(
201     IWineD3DVertexShader* iface,
202     BYTE usage_req, BYTE usage_idx_req,
203     unsigned int* regnum) {
204
205     IWineD3DVertexShaderImpl* This = (IWineD3DVertexShaderImpl*) iface;
206     int i;
207
208     for (i = 0; i < MAX_ATTRIBS; i++) {
209         DWORD usage_token = This->semantics_in[i].usage;
210         DWORD usage = (usage_token & WINED3DSP_DCL_USAGE_MASK) >> WINED3DSP_DCL_USAGE_SHIFT;
211         DWORD usage_idx = (usage_token & WINED3DSP_DCL_USAGEINDEX_MASK) >> WINED3DSP_DCL_USAGEINDEX_SHIFT;
212
213         if (usage_token && match_usage(usage, usage_idx, usage_req, usage_idx_req)) {
214             *regnum = i;
215             return TRUE;
216         }
217     }
218     return FALSE;
219 }
220
221 /** Generate a vertex shader string using either GL_VERTEX_PROGRAM_ARB
222     or GLSL and send it to the card */
223 static void IWineD3DVertexShaderImpl_GenerateShader(IWineD3DVertexShader *iface,
224         const struct shader_reg_maps* reg_maps, const DWORD *pFunction)
225 {
226     IWineD3DVertexShaderImpl *This = (IWineD3DVertexShaderImpl *)iface;
227     SHADER_BUFFER buffer;
228
229     This->swizzle_map = ((IWineD3DDeviceImpl *)This->baseShader.device)->strided_streams.swizzle_map;
230
231     shader_buffer_init(&buffer);
232     ((IWineD3DDeviceImpl *)This->baseShader.device)->shader_backend->shader_generate_vshader(iface, &buffer);
233     shader_buffer_free(&buffer);
234 }
235
236 /* *******************************************
237    IWineD3DVertexShader IUnknown parts follow
238    ******************************************* */
239 static HRESULT  WINAPI IWineD3DVertexShaderImpl_QueryInterface(IWineD3DVertexShader *iface, REFIID riid, LPVOID *ppobj) {
240     TRACE("iface %p, riid %s, ppobj %p\n", iface, debugstr_guid(riid), ppobj);
241
242     if (IsEqualGUID(riid, &IID_IWineD3DVertexShader)
243             || IsEqualGUID(riid, &IID_IWineD3DBaseShader)
244             || IsEqualGUID(riid, &IID_IWineD3DBase)
245             || IsEqualGUID(riid, &IID_IUnknown))
246     {
247         IUnknown_AddRef(iface);
248         *ppobj = iface;
249         return S_OK;
250     }
251
252     WARN("%s not implemented, returning E_NOINTERFACE\n", debugstr_guid(riid));
253
254     *ppobj = NULL;
255     return E_NOINTERFACE;
256 }
257
258 static ULONG  WINAPI IWineD3DVertexShaderImpl_AddRef(IWineD3DVertexShader *iface) {
259     IWineD3DVertexShaderImpl *This = (IWineD3DVertexShaderImpl *)iface;
260     ULONG refcount = InterlockedIncrement(&This->baseShader.ref);
261
262     TRACE("%p increasing refcount to %u\n", This, refcount);
263
264     return refcount;
265 }
266
267 static ULONG WINAPI IWineD3DVertexShaderImpl_Release(IWineD3DVertexShader *iface) {
268     IWineD3DVertexShaderImpl *This = (IWineD3DVertexShaderImpl *)iface;
269     ULONG refcount = InterlockedDecrement(&This->baseShader.ref);
270
271     TRACE("%p decreasing refcount to %u\n", This, refcount);
272
273     if (!refcount)
274     {
275         shader_cleanup((IWineD3DBaseShader *)iface);
276         HeapFree(GetProcessHeap(), 0, This);
277     }
278
279     return refcount;
280 }
281
282 /* *******************************************
283    IWineD3DVertexShader IWineD3DVertexShader parts follow
284    ******************************************* */
285
286 static HRESULT WINAPI IWineD3DVertexShaderImpl_GetParent(IWineD3DVertexShader *iface, IUnknown** parent){
287     IWineD3DVertexShaderImpl *This = (IWineD3DVertexShaderImpl *)iface;
288     
289     *parent = This->parent;
290     IUnknown_AddRef(*parent);
291     TRACE("(%p) : returning %p\n", This, *parent);
292     return WINED3D_OK;
293 }
294
295 static HRESULT WINAPI IWineD3DVertexShaderImpl_GetDevice(IWineD3DVertexShader* iface, IWineD3DDevice **pDevice){
296     IWineD3DVertexShaderImpl *This = (IWineD3DVertexShaderImpl *)iface;
297     IWineD3DDevice_AddRef(This->baseShader.device);
298     *pDevice = This->baseShader.device;
299     TRACE("(%p) returning %p\n", This, *pDevice);
300     return WINED3D_OK;
301 }
302
303 static HRESULT WINAPI IWineD3DVertexShaderImpl_GetFunction(IWineD3DVertexShader* impl, VOID* pData, UINT* pSizeOfData) {
304     IWineD3DVertexShaderImpl *This = (IWineD3DVertexShaderImpl *)impl;
305     TRACE("(%p) : pData(%p), pSizeOfData(%p)\n", This, pData, pSizeOfData);
306
307     if (NULL == pData) {
308         *pSizeOfData = This->baseShader.functionLength;
309         return WINED3D_OK;
310     }
311     if (*pSizeOfData < This->baseShader.functionLength) {
312         /* MSDN claims (for d3d8 at least) that if *pSizeOfData is smaller
313          * than the required size we should write the required size and
314          * return D3DERR_MOREDATA. That's not actually true. */
315         return WINED3DERR_INVALIDCALL;
316     }
317
318     TRACE("(%p) : GetFunction copying to %p\n", This, pData);
319     memcpy(pData, This->baseShader.function, This->baseShader.functionLength);
320
321     return WINED3D_OK;
322 }
323
324 /* Note that for vertex shaders CompileShader isn't called until the
325  * shader is first used. The reason for this is that we need the vertex
326  * declaration the shader will be used with in order to determine if
327  * the data in a register is of type D3DCOLOR, and needs swizzling. */
328 static HRESULT WINAPI IWineD3DVertexShaderImpl_SetFunction(IWineD3DVertexShader *iface, CONST DWORD *pFunction) {
329
330     IWineD3DVertexShaderImpl *This =(IWineD3DVertexShaderImpl *)iface;
331     IWineD3DDeviceImpl *deviceImpl = (IWineD3DDeviceImpl *) This->baseShader.device;
332     HRESULT hr;
333     shader_reg_maps *reg_maps = &This->baseShader.reg_maps;
334
335     TRACE("(%p) : pFunction %p\n", iface, pFunction);
336
337     /* First pass: trace shader */
338     if (TRACE_ON(d3d_shader)) shader_trace_init(pFunction, This->baseShader.shader_ins);
339
340     /* Initialize immediate constant lists */
341     list_init(&This->baseShader.constantsF);
342     list_init(&This->baseShader.constantsB);
343     list_init(&This->baseShader.constantsI);
344
345     /* Second pass: figure out registers used, semantics, etc.. */
346     This->min_rel_offset = GL_LIMITS(vshader_constantsF);
347     This->max_rel_offset = 0;
348     memset(reg_maps, 0, sizeof(shader_reg_maps));
349     hr = shader_get_registers_used((IWineD3DBaseShader*) This, reg_maps,
350             This->semantics_in, This->semantics_out, pFunction);
351     if (hr != WINED3D_OK) return hr;
352
353     vshader_set_limits(This);
354
355     This->baseShader.shader_mode = deviceImpl->vs_selected_mode;
356
357     if(deviceImpl->vs_selected_mode == SHADER_ARB &&
358        (GLINFO_LOCATION).arb_vs_offset_limit      &&
359        This->min_rel_offset <= This->max_rel_offset) {
360
361         if(This->max_rel_offset - This->min_rel_offset > 127) {
362             FIXME("The difference between the minimum and maximum relative offset is > 127\n");
363             FIXME("Which this OpenGL implementation does not support. Try using GLSL\n");
364             FIXME("Min: %d, Max: %d\n", This->min_rel_offset, This->max_rel_offset);
365         } else if(This->max_rel_offset - This->min_rel_offset > 63) {
366             This->rel_offset = This->min_rel_offset + 63;
367         } else if(This->max_rel_offset > 63) {
368             This->rel_offset = This->min_rel_offset;
369         } else {
370             This->rel_offset = 0;
371         }
372     }
373     This->baseShader.load_local_constsF = This->baseShader.reg_maps.usesrelconstF && !list_empty(&This->baseShader.constantsF);
374
375     /* copy the function ... because it will certainly be released by application */
376     This->baseShader.function = HeapAlloc(GetProcessHeap(), 0, This->baseShader.functionLength);
377     if (!This->baseShader.function) return E_OUTOFMEMORY;
378     memcpy(This->baseShader.function, pFunction, This->baseShader.functionLength);
379
380     return WINED3D_OK;
381 }
382
383 /* Preload semantics for d3d8 shaders */
384 static void WINAPI IWineD3DVertexShaderImpl_FakeSemantics(IWineD3DVertexShader *iface, IWineD3DVertexDeclaration *vertex_declaration) {
385     IWineD3DVertexShaderImpl *This =(IWineD3DVertexShaderImpl *)iface;
386     IWineD3DVertexDeclarationImpl* vdecl = (IWineD3DVertexDeclarationImpl*)vertex_declaration;
387
388     int i;
389     for (i = 0; i < vdecl->declarationWNumElements - 1; ++i) {
390         const WINED3DVERTEXELEMENT *element = vdecl->pDeclarationWine + i;
391         vshader_set_input(This, element->Reg, element->Usage, element->UsageIndex);
392     }
393 }
394
395 /* Set local constants for d3d8 shaders */
396 static HRESULT WINAPI IWIneD3DVertexShaderImpl_SetLocalConstantsF(IWineD3DVertexShader *iface,
397         UINT start_idx, const float *src_data, UINT count) {
398     IWineD3DVertexShaderImpl *This =(IWineD3DVertexShaderImpl *)iface;
399     UINT i, end_idx;
400
401     TRACE("(%p) : start_idx %u, src_data %p, count %u\n", This, start_idx, src_data, count);
402
403     end_idx = start_idx + count;
404     if (end_idx > GL_LIMITS(vshader_constantsF)) {
405         WARN("end_idx %u > float constants limit %u\n", end_idx, GL_LIMITS(vshader_constantsF));
406         end_idx = GL_LIMITS(vshader_constantsF);
407     }
408
409     for (i = start_idx; i < end_idx; ++i) {
410         local_constant* lconst = HeapAlloc(GetProcessHeap(), 0, sizeof(local_constant));
411         if (!lconst) return E_OUTOFMEMORY;
412
413         lconst->idx = i;
414         memcpy(lconst->value, src_data + (i - start_idx) * 4 /* 4 components */, 4 * sizeof(float));
415         list_add_head(&This->baseShader.constantsF, &lconst->entry);
416     }
417
418     return WINED3D_OK;
419 }
420
421 HRESULT IWineD3DVertexShaderImpl_CompileShader(IWineD3DVertexShader *iface) {
422     IWineD3DVertexShaderImpl *This = (IWineD3DVertexShaderImpl *)iface;
423     CONST DWORD *function = This->baseShader.function;
424     IWineD3DDeviceImpl *deviceImpl = (IWineD3DDeviceImpl *) This->baseShader.device;
425
426     TRACE("(%p) : function %p\n", iface, function);
427
428     /* We're already compiled. */
429     if (This->baseShader.is_compiled) {
430         if ((This->swizzle_map & deviceImpl->strided_streams.use_map) != deviceImpl->strided_streams.swizzle_map)
431         {
432             WARN("Recompiling vertex shader %p due to D3DCOLOR input changes\n", This);
433             goto recompile;
434         }
435
436         return WINED3D_OK;
437
438         recompile:
439         if(This->recompile_count < 50) {
440             This->recompile_count++;
441         } else {
442             FIXME("Vertexshader %p recompiled more than 50 times\n", This);
443         }
444
445         deviceImpl->shader_backend->shader_destroy((IWineD3DBaseShader *) iface);
446     }
447
448     /* Generate the HW shader */
449     TRACE("(%p) : Generating hardware program\n", This);
450     IWineD3DVertexShaderImpl_GenerateShader(iface, &This->baseShader.reg_maps, function);
451
452     This->baseShader.is_compiled = TRUE;
453
454     return WINED3D_OK;
455 }
456
457 const IWineD3DVertexShaderVtbl IWineD3DVertexShader_Vtbl =
458 {
459     /*** IUnknown methods ***/
460     IWineD3DVertexShaderImpl_QueryInterface,
461     IWineD3DVertexShaderImpl_AddRef,
462     IWineD3DVertexShaderImpl_Release,
463     /*** IWineD3DBase methods ***/
464     IWineD3DVertexShaderImpl_GetParent,
465     /*** IWineD3DBaseShader methods ***/
466     IWineD3DVertexShaderImpl_SetFunction,
467     /*** IWineD3DVertexShader methods ***/
468     IWineD3DVertexShaderImpl_GetDevice,
469     IWineD3DVertexShaderImpl_GetFunction,
470     IWineD3DVertexShaderImpl_FakeSemantics,
471     IWIneD3DVertexShaderImpl_SetLocalConstantsF
472 };