?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
d3dx9: Implement ID3DXBaseEffect::SetBool().
[wine/multimedia.git] / dlls / d3dx9_36 / effect.c
blobc2be55839063ff73ac84d7fb58b2cb17c76f879a
1 /*
2 * Copyright 2010 Christian Costa
3 *
4 * This library is free software; you can redistribute it and/or
5 * modify it under the terms of the GNU Lesser General Public
6 * License as published by the Free Software Foundation; either
7 * version 2.1 of the License, or (at your option) any later version.
8 *
9 * This library is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12 * Lesser General Public License for more details.
13 *
14 * You should have received a copy of the GNU Lesser General Public
15 * License along with this library; if not, write to the Free Software
16 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
17 */
18
19 #include "config.h"
20 #include "wine/port.h"
21 #define NONAMELESSUNION
22 #include "wine/debug.h"
23 #include "wine/unicode.h"
24
25 #include "windef.h"
26 #include "wingdi.h"
27 #include "d3dx9_36_private.h"
28
29 /* Constants for special INT/FLOAT conversation */
30 #define INT_FLOAT_MULTI 255.0f
31 #define INT_FLOAT_MULTI_INVERSE (1/INT_FLOAT_MULTI)
32
33 WINE_DEFAULT_DEBUG_CHANNEL(d3dx);
34
35 static const struct ID3DXEffectVtbl ID3DXEffect_Vtbl;
36 static const struct ID3DXBaseEffectVtbl ID3DXBaseEffect_Vtbl;
37 static const struct ID3DXEffectCompilerVtbl ID3DXEffectCompiler_Vtbl;
38
39 enum STATE_CLASS
40 {
41 SC_LIGHTENABLE,
42 SC_FVF,
43 SC_LIGHT,
44 SC_MATERIAL,
45 SC_NPATCHMODE,
46 SC_PIXELSHADER,
47 SC_RENDERSTATE,
48 SC_SETSAMPLER,
49 SC_SAMPLERSTATE,
50 SC_TEXTURE,
51 SC_TEXTURESTAGE,
52 SC_TRANSFORM,
53 SC_VERTEXSHADER,
54 SC_SHADERCONST,
55 SC_UNKNOWN,
56 };
57
58 enum MATERIAL_TYPE
59 {
60 MT_DIFFUSE,
61 MT_AMBIENT,
62 MT_SPECULAR,
63 MT_EMISSIVE,
64 MT_POWER,
65 };
66
67 enum LIGHT_TYPE
68 {
69 LT_TYPE,
70 LT_DIFFUSE,
71 LT_SPECULAR,
72 LT_AMBIENT,
73 LT_POSITION,
74 LT_DIRECTION,
75 LT_RANGE,
76 LT_FALLOFF,
77 LT_ATTENUATION0,
78 LT_ATTENUATION1,
79 LT_ATTENUATION2,
80 LT_THETA,
81 LT_PHI,
82 };
83
84 enum SHADER_CONSTANT_TYPE
85 {
86 SCT_VSFLOAT,
87 SCT_VSBOOL,
88 SCT_VSINT,
89 SCT_PSFLOAT,
90 SCT_PSBOOL,
91 SCT_PSINT,
92 };
93
94 enum STATE_TYPE
95 {
96 ST_CONSTANT,
97 ST_PARAMETER,
98 ST_FXLC,
99 };
100
101 struct d3dx_parameter
102 {
103 char *name;
104 char *semantic;
105 void *data;
106 D3DXPARAMETER_CLASS class;
107 D3DXPARAMETER_TYPE type;
108 UINT rows;
109 UINT columns;
110 UINT element_count;
111 UINT annotation_count;
112 UINT member_count;
113 DWORD flags;
114 UINT bytes;
115
116 D3DXHANDLE *annotation_handles;
117 D3DXHANDLE *member_handles;
118 };
119
120 struct d3dx_state
121 {
122 UINT operation;
123 UINT index;
124 enum STATE_TYPE type;
125 D3DXHANDLE parameter;
126 };
127
128 struct d3dx_sampler
129 {
130 UINT state_count;
131 struct d3dx_state *states;
132 };
133
134 struct d3dx_pass
135 {
136 char *name;
137 UINT state_count;
138 UINT annotation_count;
139
140 struct d3dx_state *states;
141 D3DXHANDLE *annotation_handles;
142 };
143
144 struct d3dx_technique
145 {
146 char *name;
147 UINT pass_count;
148 UINT annotation_count;
149
150 D3DXHANDLE *annotation_handles;
151 D3DXHANDLE *pass_handles;
152 };
153
154 struct ID3DXBaseEffectImpl
155 {
156 ID3DXBaseEffect ID3DXBaseEffect_iface;
157 LONG ref;
158
159 struct ID3DXEffectImpl *effect;
160
161 UINT parameter_count;
162 UINT technique_count;
163
164 D3DXHANDLE *parameter_handles;
165 D3DXHANDLE *technique_handles;
166 };
167
168 struct ID3DXEffectImpl
169 {
170 ID3DXEffect ID3DXEffect_iface;
171 LONG ref;
172
173 LPD3DXEFFECTSTATEMANAGER manager;
174 LPDIRECT3DDEVICE9 device;
175 LPD3DXEFFECTPOOL pool;
176 D3DXHANDLE active_technique;
177 D3DXHANDLE active_pass;
178
179 ID3DXBaseEffect *base_effect;
180 };
181
182 struct ID3DXEffectCompilerImpl
183 {
184 ID3DXEffectCompiler ID3DXEffectCompiler_iface;
185 LONG ref;
186
187 ID3DXBaseEffect *base_effect;
188 };
189
190 static struct d3dx_parameter *get_parameter_by_name(struct ID3DXBaseEffectImpl *base,
191 struct d3dx_parameter *parameter, LPCSTR name);
192 static struct d3dx_parameter *get_parameter_annotation_by_name(struct d3dx_parameter *parameter, LPCSTR name);
193 static HRESULT d3dx9_parse_state(struct d3dx_state *state, const char *data, const char **ptr, D3DXHANDLE *objects);
194 static void free_parameter_state(D3DXHANDLE handle, BOOL element, BOOL child, enum STATE_TYPE st);
195
196 static const struct
197 {
198 enum STATE_CLASS class;
199 UINT op;
200 LPCSTR name;
201 }
202 state_table[] =
203 {
204 /* Render sates */
205 {SC_RENDERSTATE, D3DRS_ZENABLE, "D3DRS_ZENABLE"}, /* 0x0 */
206 {SC_RENDERSTATE, D3DRS_FILLMODE, "D3DRS_FILLMODE"},
207 {SC_RENDERSTATE, D3DRS_SHADEMODE, "D3DRS_SHADEMODE"},
208 {SC_RENDERSTATE, D3DRS_ZWRITEENABLE, "D3DRS_ZWRITEENABLE"},
209 {SC_RENDERSTATE, D3DRS_ALPHATESTENABLE, "D3DRS_ALPHATESTENABLE"},
210 {SC_RENDERSTATE, D3DRS_LASTPIXEL, "D3DRS_LASTPIXEL"},
211 {SC_RENDERSTATE, D3DRS_SRCBLEND, "D3DRS_SRCBLEND"},
212 {SC_RENDERSTATE, D3DRS_DESTBLEND, "D3DRS_DESTBLEND"},
213 {SC_RENDERSTATE, D3DRS_CULLMODE, "D3DRS_CULLMODE"},
214 {SC_RENDERSTATE, D3DRS_ZFUNC, "D3DRS_ZFUNC"},
215 {SC_RENDERSTATE, D3DRS_ALPHAREF, "D3DRS_ALPHAREF"},
216 {SC_RENDERSTATE, D3DRS_ALPHAFUNC, "D3DRS_ALPHAFUNC"},
217 {SC_RENDERSTATE, D3DRS_DITHERENABLE, "D3DRS_DITHERENABLE"},
218 {SC_RENDERSTATE, D3DRS_ALPHABLENDENABLE, "D3DRS_ALPHABLENDENABLE"},
219 {SC_RENDERSTATE, D3DRS_FOGENABLE, "D3DRS_FOGENABLE"},
220 {SC_RENDERSTATE, D3DRS_SPECULARENABLE, "D3DRS_SPECULARENABLE"},
221 {SC_RENDERSTATE, D3DRS_FOGCOLOR, "D3DRS_FOGCOLOR"}, /* 0x10 */
222 {SC_RENDERSTATE, D3DRS_FOGTABLEMODE, "D3DRS_FOGTABLEMODE"},
223 {SC_RENDERSTATE, D3DRS_FOGSTART, "D3DRS_FOGSTART"},
224 {SC_RENDERSTATE, D3DRS_FOGEND, "D3DRS_FOGEND"},
225 {SC_RENDERSTATE, D3DRS_FOGDENSITY, "D3DRS_FOGDENSITY"},
226 {SC_RENDERSTATE, D3DRS_RANGEFOGENABLE, "D3DRS_RANGEFOGENABLE"},
227 {SC_RENDERSTATE, D3DRS_STENCILENABLE, "D3DRS_STENCILENABLE"},
228 {SC_RENDERSTATE, D3DRS_STENCILFAIL, "D3DRS_STENCILFAIL"},
229 {SC_RENDERSTATE, D3DRS_STENCILZFAIL, "D3DRS_STENCILZFAIL"},
230 {SC_RENDERSTATE, D3DRS_STENCILPASS, "D3DRS_STENCILPASS"},
231 {SC_RENDERSTATE, D3DRS_STENCILFUNC, "D3DRS_STENCILFUNC"},
232 {SC_RENDERSTATE, D3DRS_STENCILREF, "D3DRS_STENCILREF"},
233 {SC_RENDERSTATE, D3DRS_STENCILMASK, "D3DRS_STENCILMASK"},
234 {SC_RENDERSTATE, D3DRS_STENCILWRITEMASK, "D3DRS_STENCILWRITEMASK"},
235 {SC_RENDERSTATE, D3DRS_TEXTUREFACTOR, "D3DRS_TEXTUREFACTOR"},
236 {SC_RENDERSTATE, D3DRS_WRAP0, "D3DRS_WRAP0"},
237 {SC_RENDERSTATE, D3DRS_WRAP1, "D3DRS_WRAP1"}, /* 0x20 */
238 {SC_RENDERSTATE, D3DRS_WRAP2, "D3DRS_WRAP2"},
239 {SC_RENDERSTATE, D3DRS_WRAP3, "D3DRS_WRAP3"},
240 {SC_RENDERSTATE, D3DRS_WRAP4, "D3DRS_WRAP4"},
241 {SC_RENDERSTATE, D3DRS_WRAP5, "D3DRS_WRAP5"},
242 {SC_RENDERSTATE, D3DRS_WRAP6, "D3DRS_WRAP6"},
243 {SC_RENDERSTATE, D3DRS_WRAP7, "D3DRS_WRAP7"},
244 {SC_RENDERSTATE, D3DRS_WRAP8, "D3DRS_WRAP8"},
245 {SC_RENDERSTATE, D3DRS_WRAP9, "D3DRS_WRAP9"},
246 {SC_RENDERSTATE, D3DRS_WRAP10, "D3DRS_WRAP10"},
247 {SC_RENDERSTATE, D3DRS_WRAP11, "D3DRS_WRAP11"},
248 {SC_RENDERSTATE, D3DRS_WRAP12, "D3DRS_WRAP12"},
249 {SC_RENDERSTATE, D3DRS_WRAP13, "D3DRS_WRAP13"},
250 {SC_RENDERSTATE, D3DRS_WRAP14, "D3DRS_WRAP14"},
251 {SC_RENDERSTATE, D3DRS_WRAP15, "D3DRS_WRAP15"},
252 {SC_RENDERSTATE, D3DRS_CLIPPING, "D3DRS_CLIPPING"},
253 {SC_RENDERSTATE, D3DRS_LIGHTING, "D3DRS_LIGHTING"}, /* 0x30 */
254 {SC_RENDERSTATE, D3DRS_AMBIENT, "D3DRS_AMBIENT"},
255 {SC_RENDERSTATE, D3DRS_FOGVERTEXMODE, "D3DRS_FOGVERTEXMODE"},
256 {SC_RENDERSTATE, D3DRS_COLORVERTEX, "D3DRS_COLORVERTEX"},
257 {SC_RENDERSTATE, D3DRS_LOCALVIEWER, "D3DRS_LOCALVIEWER"},
258 {SC_RENDERSTATE, D3DRS_NORMALIZENORMALS, "D3DRS_NORMALIZENORMALS"},
259 {SC_RENDERSTATE, D3DRS_DIFFUSEMATERIALSOURCE, "D3DRS_DIFFUSEMATERIALSOURCE"},
260 {SC_RENDERSTATE, D3DRS_SPECULARMATERIALSOURCE, "D3DRS_SPECULARMATERIALSOURCE"},
261 {SC_RENDERSTATE, D3DRS_AMBIENTMATERIALSOURCE, "D3DRS_AMBIENTMATERIALSOURCE"},
262 {SC_RENDERSTATE, D3DRS_EMISSIVEMATERIALSOURCE, "D3DRS_EMISSIVEMATERIALSOURCE"},
263 {SC_RENDERSTATE, D3DRS_VERTEXBLEND, "D3DRS_VERTEXBLEND"},
264 {SC_RENDERSTATE, D3DRS_CLIPPLANEENABLE, "D3DRS_CLIPPLANEENABLE"},
265 {SC_RENDERSTATE, D3DRS_POINTSIZE, "D3DRS_POINTSIZE"},
266 {SC_RENDERSTATE, D3DRS_POINTSIZE_MIN, "D3DRS_POINTSIZE_MIN"},
267 {SC_RENDERSTATE, D3DRS_POINTSIZE_MAX, "D3DRS_POINTSIZE_MAX"},
268 {SC_RENDERSTATE, D3DRS_POINTSPRITEENABLE, "D3DRS_POINTSPRITEENABLE"},
269 {SC_RENDERSTATE, D3DRS_POINTSCALEENABLE, "D3DRS_POINTSCALEENABLE"}, /* 0x40 */
270 {SC_RENDERSTATE, D3DRS_POINTSCALE_A, "D3DRS_POINTSCALE_A"},
271 {SC_RENDERSTATE, D3DRS_POINTSCALE_B, "D3DRS_POINTSCALE_B"},
272 {SC_RENDERSTATE, D3DRS_POINTSCALE_C, "D3DRS_POINTSCALE_C"},
273 {SC_RENDERSTATE, D3DRS_MULTISAMPLEANTIALIAS, "D3DRS_MULTISAMPLEANTIALIAS"},
274 {SC_RENDERSTATE, D3DRS_MULTISAMPLEMASK, "D3DRS_MULTISAMPLEMASK"},
275 {SC_RENDERSTATE, D3DRS_PATCHEDGESTYLE, "D3DRS_PATCHEDGESTYLE"},
276 {SC_RENDERSTATE, D3DRS_DEBUGMONITORTOKEN, "D3DRS_DEBUGMONITORTOKEN"},
277 {SC_RENDERSTATE, D3DRS_INDEXEDVERTEXBLENDENABLE, "D3DRS_INDEXEDVERTEXBLENDENABLE"},
278 {SC_RENDERSTATE, D3DRS_COLORWRITEENABLE, "D3DRS_COLORWRITEENABLE"},
279 {SC_RENDERSTATE, D3DRS_TWEENFACTOR, "D3DRS_TWEENFACTOR"},
280 {SC_RENDERSTATE, D3DRS_BLENDOP, "D3DRS_BLENDOP"},
281 {SC_RENDERSTATE, D3DRS_POSITIONDEGREE, "D3DRS_POSITIONDEGREE"},
282 {SC_RENDERSTATE, D3DRS_NORMALDEGREE, "D3DRS_NORMALDEGREE"},
283 {SC_RENDERSTATE, D3DRS_SCISSORTESTENABLE, "D3DRS_SCISSORTESTENABLE"},
284 {SC_RENDERSTATE, D3DRS_SLOPESCALEDEPTHBIAS, "D3DRS_SLOPESCALEDEPTHBIAS"},
285 {SC_RENDERSTATE, D3DRS_ANTIALIASEDLINEENABLE, "D3DRS_ANTIALIASEDLINEENABLE"}, /* 0x50 */
286 {SC_RENDERSTATE, D3DRS_MINTESSELLATIONLEVEL, "D3DRS_MINTESSELLATIONLEVEL"},
287 {SC_RENDERSTATE, D3DRS_MAXTESSELLATIONLEVEL, "D3DRS_MAXTESSELLATIONLEVEL"},
288 {SC_RENDERSTATE, D3DRS_ADAPTIVETESS_X, "D3DRS_ADAPTIVETESS_X"},
289 {SC_RENDERSTATE, D3DRS_ADAPTIVETESS_Y, "D3DRS_ADAPTIVETESS_Y"},
290 {SC_RENDERSTATE, D3DRS_ADAPTIVETESS_Z, "D3DRS_ADAPTIVETESS_Z"},
291 {SC_RENDERSTATE, D3DRS_ADAPTIVETESS_W, "D3DRS_ADAPTIVETESS_W"},
292 {SC_RENDERSTATE, D3DRS_ENABLEADAPTIVETESSELLATION, "D3DRS_ENABLEADAPTIVETESSELLATION"},
293 {SC_RENDERSTATE, D3DRS_TWOSIDEDSTENCILMODE, "D3DRS_TWOSIDEDSTENCILMODE"},
294 {SC_RENDERSTATE, D3DRS_CCW_STENCILFAIL, "D3DRS_CCW_STENCILFAIL"},
295 {SC_RENDERSTATE, D3DRS_CCW_STENCILZFAIL, "D3DRS_CCW_STENCILZFAIL"},
296 {SC_RENDERSTATE, D3DRS_CCW_STENCILPASS, "D3DRS_CCW_STENCILPASS"},
297 {SC_RENDERSTATE, D3DRS_CCW_STENCILFUNC, "D3DRS_CCW_STENCILFUNC"},
298 {SC_RENDERSTATE, D3DRS_COLORWRITEENABLE1, "D3DRS_COLORWRITEENABLE1"},
299 {SC_RENDERSTATE, D3DRS_COLORWRITEENABLE2, "D3DRS_COLORWRITEENABLE2"},
300 {SC_RENDERSTATE, D3DRS_COLORWRITEENABLE3, "D3DRS_COLORWRITEENABLE3"},
301 {SC_RENDERSTATE, D3DRS_BLENDFACTOR, "D3DRS_BLENDFACTOR"}, /* 0x60 */
302 {SC_RENDERSTATE, D3DRS_SRGBWRITEENABLE, "D3DRS_SRGBWRITEENABLE"},
303 {SC_RENDERSTATE, D3DRS_DEPTHBIAS, "D3DRS_DEPTHBIAS"},
304 {SC_RENDERSTATE, D3DRS_SEPARATEALPHABLENDENABLE, "D3DRS_SEPARATEALPHABLENDENABLE"},
305 {SC_RENDERSTATE, D3DRS_SRCBLENDALPHA, "D3DRS_SRCBLENDALPHA"},
306 {SC_RENDERSTATE, D3DRS_DESTBLENDALPHA, "D3DRS_DESTBLENDALPHA"},
307 {SC_RENDERSTATE, D3DRS_BLENDOPALPHA, "D3DRS_BLENDOPALPHA"},
308 /* Texture stages */
309 {SC_TEXTURESTAGE, D3DTSS_COLOROP, "D3DTSS_COLOROP"},
310 {SC_TEXTURESTAGE, D3DTSS_COLORARG0, "D3DTSS_COLORARG0"},
311 {SC_TEXTURESTAGE, D3DTSS_COLORARG1, "D3DTSS_COLORARG1"},
312 {SC_TEXTURESTAGE, D3DTSS_COLORARG2, "D3DTSS_COLORARG2"},
313 {SC_TEXTURESTAGE, D3DTSS_ALPHAOP, "D3DTSS_ALPHAOP"},
314 {SC_TEXTURESTAGE, D3DTSS_ALPHAARG0, "D3DTSS_ALPHAARG0"},
315 {SC_TEXTURESTAGE, D3DTSS_ALPHAARG1, "D3DTSS_ALPHAARG1"},
316 {SC_TEXTURESTAGE, D3DTSS_ALPHAARG2, "D3DTSS_ALPHAARG2"},
317 {SC_TEXTURESTAGE, D3DTSS_RESULTARG, "D3DTSS_RESULTARG"},
318 {SC_TEXTURESTAGE, D3DTSS_BUMPENVMAT00, "D3DTSS_BUMPENVMAT00"}, /* 0x70 */
319 {SC_TEXTURESTAGE, D3DTSS_BUMPENVMAT01, "D3DTSS_BUMPENVMAT01"},
320 {SC_TEXTURESTAGE, D3DTSS_BUMPENVMAT10, "D3DTSS_BUMPENVMAT10"},
321 {SC_TEXTURESTAGE, D3DTSS_BUMPENVMAT11, "D3DTSS_BUMPENVMAT11"},
322 {SC_TEXTURESTAGE, D3DTSS_TEXCOORDINDEX, "D3DTSS_TEXCOORDINDEX"},
323 {SC_TEXTURESTAGE, D3DTSS_BUMPENVLSCALE, "D3DTSS_BUMPENVLSCALE"},
324 {SC_TEXTURESTAGE, D3DTSS_BUMPENVLOFFSET, "D3DTSS_BUMPENVLOFFSET"},
325 {SC_TEXTURESTAGE, D3DTSS_TEXTURETRANSFORMFLAGS, "D3DTSS_TEXTURETRANSFORMFLAGS"},
326 /* */
327 {SC_UNKNOWN, 0, "UNKNOWN"},
328 /* NPatchMode */
329 {SC_NPATCHMODE, 0, "NPatchMode"},
330 /* */
331 {SC_UNKNOWN, 0, "UNKNOWN"},
332 /* Transform */
333 {SC_TRANSFORM, D3DTS_PROJECTION, "D3DTS_PROJECTION"},
334 {SC_TRANSFORM, D3DTS_VIEW, "D3DTS_VIEW"},
335 {SC_TRANSFORM, D3DTS_WORLD, "D3DTS_WORLD"},
336 {SC_TRANSFORM, D3DTS_TEXTURE0, "D3DTS_TEXTURE0"},
337 /* Material */
338 {SC_MATERIAL, MT_DIFFUSE, "MaterialDiffuse"},
339 {SC_MATERIAL, MT_AMBIENT, "MaterialAmbient"}, /* 0x80 */
340 {SC_MATERIAL, MT_SPECULAR, "MaterialSpecular"},
341 {SC_MATERIAL, MT_EMISSIVE, "MaterialEmissive"},
342 {SC_MATERIAL, MT_POWER, "MaterialPower"},
343 /* Light */
344 {SC_LIGHT, LT_TYPE, "LightType"},
345 {SC_LIGHT, LT_DIFFUSE, "LightDiffuse"},
346 {SC_LIGHT, LT_SPECULAR, "LightSpecular"},
347 {SC_LIGHT, LT_AMBIENT, "LightAmbient"},
348 {SC_LIGHT, LT_POSITION, "LightPosition"},
349 {SC_LIGHT, LT_DIRECTION, "LightDirection"},
350 {SC_LIGHT, LT_RANGE, "LightRange"},
351 {SC_LIGHT, LT_FALLOFF, "LightFallOff"},
352 {SC_LIGHT, LT_ATTENUATION0, "LightAttenuation0"},
353 {SC_LIGHT, LT_ATTENUATION1, "LightAttenuation1"},
354 {SC_LIGHT, LT_ATTENUATION2, "LightAttenuation2"},
355 {SC_LIGHT, LT_THETA, "LightTheta"},
356 {SC_LIGHT, LT_PHI, "LightPhi"}, /* 0x90 */
357 /* Ligthenable */
358 {SC_LIGHTENABLE, 0, "LightEnable"},
359 /* Vertexshader */
360 {SC_VERTEXSHADER, 0, "Vertexshader"},
361 /* Pixelshader */
362 {SC_PIXELSHADER, 0, "Pixelshader"},
363 /* Shader constants */
364 {SC_SHADERCONST, SCT_VSFLOAT, "VertexShaderConstantF"},
365 {SC_SHADERCONST, SCT_VSBOOL, "VertexShaderConstantB"},
366 {SC_SHADERCONST, SCT_VSINT, "VertexShaderConstantI"},
367 {SC_SHADERCONST, SCT_VSFLOAT, "VertexShaderConstant"},
368 {SC_SHADERCONST, SCT_VSFLOAT, "VertexShaderConstant1"},
369 {SC_SHADERCONST, SCT_VSFLOAT, "VertexShaderConstant2"},
370 {SC_SHADERCONST, SCT_VSFLOAT, "VertexShaderConstant3"},
371 {SC_SHADERCONST, SCT_VSFLOAT, "VertexShaderConstant4"},
372 {SC_SHADERCONST, SCT_PSFLOAT, "PixelShaderConstantF"},
373 {SC_SHADERCONST, SCT_PSBOOL, "PixelShaderConstantB"},
374 {SC_SHADERCONST, SCT_PSINT, "PixelShaderConstantI"},
375 {SC_SHADERCONST, SCT_PSFLOAT, "PixelShaderConstant"},
376 {SC_SHADERCONST, SCT_PSFLOAT, "PixelShaderConstant1"}, /* 0xa0 */
377 {SC_SHADERCONST, SCT_PSFLOAT, "PixelShaderConstant2"},
378 {SC_SHADERCONST, SCT_PSFLOAT, "PixelShaderConstant3"},
379 {SC_SHADERCONST, SCT_PSFLOAT, "PixelShaderConstant4"},
380 /* Texture */
381 {SC_TEXTURE, 0, "Texture"},
382 /* Sampler states */
383 {SC_SAMPLERSTATE, D3DSAMP_ADDRESSU, "AddressU"},
384 {SC_SAMPLERSTATE, D3DSAMP_ADDRESSV, "AddressV"},
385 {SC_SAMPLERSTATE, D3DSAMP_ADDRESSW, "AddressW"},
386 {SC_SAMPLERSTATE, D3DSAMP_BORDERCOLOR, "BorderColor"},
387 {SC_SAMPLERSTATE, D3DSAMP_MAGFILTER, "MagFilter"},
388 {SC_SAMPLERSTATE, D3DSAMP_MINFILTER, "MinFilter"},
389 {SC_SAMPLERSTATE, D3DSAMP_MIPFILTER, "MipFilter"},
390 {SC_SAMPLERSTATE, D3DSAMP_MIPMAPLODBIAS, "MipMapLodBias"},
391 {SC_SAMPLERSTATE, D3DSAMP_MAXMIPLEVEL, "MaxMipLevel"},
392 {SC_SAMPLERSTATE, D3DSAMP_MAXANISOTROPY, "MaxAnisotropy"},
393 {SC_SAMPLERSTATE, D3DSAMP_SRGBTEXTURE, "SRGBTexture"},
394 {SC_SAMPLERSTATE, D3DSAMP_ELEMENTINDEX, "ElementIndex"}, /* 0xb0 */
395 {SC_SAMPLERSTATE, D3DSAMP_DMAPOFFSET, "DMAPOffset"},
396 /* Set sampler */
397 {SC_SETSAMPLER, 0, "Sampler"},
398 };
399
400 static inline void read_dword(const char **ptr, DWORD *d)
401 {
402 memcpy(d, *ptr, sizeof(*d));
403 *ptr += sizeof(*d);
404 }
405
406 static void skip_dword_unknown(const char **ptr, unsigned int count)
407 {
408 unsigned int i;
409 DWORD d;
410
411 FIXME("Skipping %u unknown DWORDs:\n", count);
412 for (i = 0; i < count; ++i)
413 {
414 read_dword(ptr, &d);
415 FIXME("\t0x%08x\n", d);
416 }
417 }
418
419 static inline struct d3dx_parameter *get_parameter_struct(D3DXHANDLE handle)
420 {
421 return (struct d3dx_parameter *) handle;
422 }
423
424 static inline struct d3dx_pass *get_pass_struct(D3DXHANDLE handle)
425 {
426 return (struct d3dx_pass *) handle;
427 }
428
429 static inline struct d3dx_technique *get_technique_struct(D3DXHANDLE handle)
430 {
431 return (struct d3dx_technique *) handle;
432 }
433
434 static inline D3DXHANDLE get_parameter_handle(struct d3dx_parameter *parameter)
435 {
436 return (D3DXHANDLE) parameter;
437 }
438
439 static inline D3DXHANDLE get_technique_handle(struct d3dx_technique *technique)
440 {
441 return (D3DXHANDLE) technique;
442 }
443
444 static inline D3DXHANDLE get_pass_handle(struct d3dx_pass *pass)
445 {
446 return (D3DXHANDLE) pass;
447 }
448
449 static struct d3dx_technique *is_valid_technique(struct ID3DXBaseEffectImpl *base, D3DXHANDLE technique)
450 {
451 unsigned int i;
452
453 for (i = 0; i < base->technique_count; ++i)
454 {
455 if (base->technique_handles[i] == technique)
456 {
457 return get_technique_struct(technique);
458 }
459 }
460
461 return NULL;
462 }
463
464 static struct d3dx_pass *is_valid_pass(struct ID3DXBaseEffectImpl *base, D3DXHANDLE pass)
465 {
466 unsigned int i, k;
467
468 for (i = 0; i < base->technique_count; ++i)
469 {
470 struct d3dx_technique *technique = get_technique_struct(base->technique_handles[i]);
471
472 for (k = 0; k < technique->pass_count; ++k)
473 {
474 if (technique->pass_handles[k] == pass)
475 {
476 return get_pass_struct(pass);
477 }
478 }
479 }
480
481 return NULL;
482 }
483
484 static struct d3dx_parameter *is_valid_sub_parameter(struct d3dx_parameter *param, D3DXHANDLE parameter)
485 {
486 unsigned int i, count;
487 struct d3dx_parameter *p;
488
489 for (i = 0; i < param->annotation_count; ++i)
490 {
491 if (param->annotation_handles[i] == parameter)
492 {
493 return get_parameter_struct(parameter);
494 }
495
496 p = is_valid_sub_parameter(get_parameter_struct(param->annotation_handles[i]), parameter);
497 if (p) return p;
498 }
499
500 if (param->element_count) count = param->element_count;
501 else count = param->member_count;
502
503 for (i = 0; i < count; ++i)
504 {
505 if (param->member_handles[i] == parameter)
506 {
507 return get_parameter_struct(parameter);
508 }
509
510 p = is_valid_sub_parameter(get_parameter_struct(param->member_handles[i]), parameter);
511 if (p) return p;
512 }
513
514 return NULL;
515 }
516
517 static struct d3dx_parameter *is_valid_parameter(struct ID3DXBaseEffectImpl *base, D3DXHANDLE parameter)
518 {
519 unsigned int i, k, m;
520 struct d3dx_parameter *p;
521
522 for (i = 0; i < base->parameter_count; ++i)
523 {
524 if (base->parameter_handles[i] == parameter)
525 {
526 return get_parameter_struct(parameter);
527 }
528
529 p = is_valid_sub_parameter(get_parameter_struct(base->parameter_handles[i]), parameter);
530 if (p) return p;
531 }
532
533 for (i = 0; i < base->technique_count; ++i)
534 {
535 struct d3dx_technique *technique = get_technique_struct(base->technique_handles[i]);
536
537 for (k = 0; k < technique->pass_count; ++k)
538 {
539 struct d3dx_pass *pass = get_pass_struct(technique->pass_handles[k]);
540
541 for (m = 0; m < pass->annotation_count; ++m)
542 {
543 if (pass->annotation_handles[i] == parameter)
544 {
545 return get_parameter_struct(parameter);
546 }
547
548 p = is_valid_sub_parameter(get_parameter_struct(pass->annotation_handles[m]), parameter);
549 if (p) return p;
550 }
551 }
552
553 for (k = 0; k < technique->annotation_count; ++k)
554 {
555 if (technique->annotation_handles[k] == parameter)
556 {
557 return get_parameter_struct(parameter);
558 }
559
560 p = is_valid_sub_parameter(get_parameter_struct(technique->annotation_handles[k]), parameter);
561 if (p) return p;
562 }
563 }
564
565 return NULL;
566 }
567
568 static inline struct d3dx_parameter *get_valid_parameter(struct ID3DXBaseEffectImpl *base, D3DXHANDLE parameter)
569 {
570 struct d3dx_parameter *param = is_valid_parameter(base, parameter);
571
572 if (!param) param = get_parameter_by_name(base, NULL, parameter);
573
574 return param;
575 }
576
577 static void free_state(struct d3dx_state *state)
578 {
579 free_parameter_state(state->parameter, FALSE, FALSE, state->type);
580 }
581
582 static void free_sampler(struct d3dx_sampler *sampler)
583 {
584 UINT i;
585
586 for (i = 0; i < sampler->state_count; ++i)
587 {
588 free_state(&sampler->states[i]);
589 }
590 HeapFree(GetProcessHeap(), 0, sampler->states);
591 }
592
593 static void free_parameter(D3DXHANDLE handle, BOOL element, BOOL child)
594 {
595 free_parameter_state(handle, element, child, ST_CONSTANT);
596 }
597
598 static void free_parameter_state(D3DXHANDLE handle, BOOL element, BOOL child, enum STATE_TYPE st)
599 {
600 unsigned int i;
601 struct d3dx_parameter *param = get_parameter_struct(handle);
602
603 TRACE("Free parameter %p, name %s, type %s, child %s, state_type %x\n", param, param->name,
604 debug_d3dxparameter_type(param->type), child ? "yes" : "no", st);
605
606 if (!param)
607 {
608 return;
609 }
610
611 if (param->annotation_handles)
612 {
613 for (i = 0; i < param->annotation_count; ++i)
614 {
615 free_parameter(param->annotation_handles[i], FALSE, FALSE);
616 }
617 HeapFree(GetProcessHeap(), 0, param->annotation_handles);
618 }
619
620 if (param->member_handles)
621 {
622 unsigned int count;
623
624 if (param->element_count) count = param->element_count;
625 else count = param->member_count;
626
627 for (i = 0; i < count; ++i)
628 {
629 free_parameter(param->member_handles[i], param->element_count != 0, TRUE);
630 }
631 HeapFree(GetProcessHeap(), 0, param->member_handles);
632 }
633
634 if (param->class == D3DXPC_OBJECT && !param->element_count)
635 {
636 switch (param->type)
637 {
638 case D3DXPT_STRING:
639 HeapFree(GetProcessHeap(), 0, *(LPSTR *)param->data);
640 if (!child) HeapFree(GetProcessHeap(), 0, param->data);
641 break;
642
643 case D3DXPT_TEXTURE:
644 case D3DXPT_TEXTURE1D:
645 case D3DXPT_TEXTURE2D:
646 case D3DXPT_TEXTURE3D:
647 case D3DXPT_TEXTURECUBE:
648 case D3DXPT_PIXELSHADER:
649 case D3DXPT_VERTEXSHADER:
650 if (st == ST_CONSTANT)
651 {
652 if (*(IUnknown **)param->data) IUnknown_Release(*(IUnknown **)param->data);
653 }
654 else
655 {
656 HeapFree(GetProcessHeap(), 0, *(LPSTR *)param->data);
657 }
658 if (!child) HeapFree(GetProcessHeap(), 0, param->data);
659 break;
660
661 case D3DXPT_SAMPLER:
662 case D3DXPT_SAMPLER1D:
663 case D3DXPT_SAMPLER2D:
664 case D3DXPT_SAMPLER3D:
665 case D3DXPT_SAMPLERCUBE:
666 if (st == ST_CONSTANT)
667 {
668 free_sampler((struct d3dx_sampler *)param->data);
669 }
670 else
671 {
672 HeapFree(GetProcessHeap(), 0, *(LPSTR *)param->data);
673 }
674 /* samplers have always own data, so free that */
675 HeapFree(GetProcessHeap(), 0, param->data);
676 break;
677
678 default:
679 FIXME("Unhandled type %s\n", debug_d3dxparameter_type(param->type));
680 break;
681 }
682 }
683 else
684 {
685 if (!child)
686 {
687 if (st != ST_CONSTANT)
688 {
689 HeapFree(GetProcessHeap(), 0, *(LPSTR *)param->data);
690 }
691 HeapFree(GetProcessHeap(), 0, param->data);
692 }
693 }
694
695 /* only the parent has to release name and semantic */
696 if (!element)
697 {
698 HeapFree(GetProcessHeap(), 0, param->name);
699 HeapFree(GetProcessHeap(), 0, param->semantic);
700 }
701
702 HeapFree(GetProcessHeap(), 0, param);
703 }
704
705 static void free_pass(D3DXHANDLE handle)
706 {
707 unsigned int i;
708 struct d3dx_pass *pass = get_pass_struct(handle);
709
710 TRACE("Free pass %p\n", pass);
711
712 if (!pass)
713 {
714 return;
715 }
716
717 if (pass->annotation_handles)
718 {
719 for (i = 0; i < pass->annotation_count; ++i)
720 {
721 free_parameter(pass->annotation_handles[i], FALSE, FALSE);
722 }
723 HeapFree(GetProcessHeap(), 0, pass->annotation_handles);
724 }
725
726 if (pass->states)
727 {
728 for (i = 0; i < pass->state_count; ++i)
729 {
730 free_state(&pass->states[i]);
731 }
732 HeapFree(GetProcessHeap(), 0, pass->states);
733 }
734
735 HeapFree(GetProcessHeap(), 0, pass->name);
736 HeapFree(GetProcessHeap(), 0, pass);
737 }
738
739 static void free_technique(D3DXHANDLE handle)
740 {
741 unsigned int i;
742 struct d3dx_technique *technique = get_technique_struct(handle);
743
744 TRACE("Free technique %p\n", technique);
745
746 if (!technique)
747 {
748 return;
749 }
750
751 if (technique->annotation_handles)
752 {
753 for (i = 0; i < technique->annotation_count; ++i)
754 {
755 free_parameter(technique->annotation_handles[i], FALSE, FALSE);
756 }
757 HeapFree(GetProcessHeap(), 0, technique->annotation_handles);
758 }
759
760 if (technique->pass_handles)
761 {
762 for (i = 0; i < technique->pass_count; ++i)
763 {
764 free_pass(technique->pass_handles[i]);
765 }
766 HeapFree(GetProcessHeap(), 0, technique->pass_handles);
767 }
768
769 HeapFree(GetProcessHeap(), 0, technique->name);
770 HeapFree(GetProcessHeap(), 0, technique);
771 }
772
773 static void free_base_effect(struct ID3DXBaseEffectImpl *base)
774 {
775 unsigned int i;
776
777 TRACE("Free base effect %p\n", base);
778
779 if (base->parameter_handles)
780 {
781 for (i = 0; i < base->parameter_count; ++i)
782 {
783 free_parameter(base->parameter_handles[i], FALSE, FALSE);
784 }
785 HeapFree(GetProcessHeap(), 0, base->parameter_handles);
786 }
787
788 if (base->technique_handles)
789 {
790 for (i = 0; i < base->technique_count; ++i)
791 {
792 free_technique(base->technique_handles[i]);
793 }
794 HeapFree(GetProcessHeap(), 0, base->technique_handles);
795 }
796 }
797
798 static void free_effect(struct ID3DXEffectImpl *effect)
799 {
800 TRACE("Free effect %p\n", effect);
801
802 if (effect->base_effect)
803 {
804 effect->base_effect->lpVtbl->Release(effect->base_effect);
805 }
806
807 if (effect->pool)
808 {
809 effect->pool->lpVtbl->Release(effect->pool);
810 }
811
812 if (effect->manager)
813 {
814 IUnknown_Release(effect->manager);
815 }
816
817 IDirect3DDevice9_Release(effect->device);
818 }
819
820 static void free_effect_compiler(struct ID3DXEffectCompilerImpl *compiler)
821 {
822 TRACE("Free effect compiler %p\n", compiler);
823
824 if (compiler->base_effect)
825 {
826 compiler->base_effect->lpVtbl->Release(compiler->base_effect);
827 }
828 }
829
830 static INT get_int(D3DXPARAMETER_TYPE type, LPCVOID data)
831 {
832 INT i;
833
834 switch (type)
835 {
836 case D3DXPT_FLOAT:
837 i = *(FLOAT *)data;
838 break;
839
840 case D3DXPT_INT:
841 i = *(INT *)data;
842 break;
843
844 case D3DXPT_BOOL:
845 i = *(BOOL *)data;
846 break;
847
848 default:
849 i = 0;
850 FIXME("Unhandled type %s. This should not happen!\n", debug_d3dxparameter_type(type));
851 break;
852 }
853
854 return i;
855 }
856
857 inline static FLOAT get_float(D3DXPARAMETER_TYPE type, LPCVOID data)
858 {
859 FLOAT f;
860
861 switch (type)
862 {
863 case D3DXPT_FLOAT:
864 f = *(FLOAT *)data;
865 break;
866
867 case D3DXPT_INT:
868 f = *(INT *)data;
869 break;
870
871 case D3DXPT_BOOL:
872 f = *(BOOL *)data;
873 break;
874
875 default:
876 f = 0.0f;
877 FIXME("Unhandled type %s. This should not happen!\n", debug_d3dxparameter_type(type));
878 break;
879 }
880
881 return f;
882 }
883
884 static inline BOOL get_bool(LPCVOID data)
885 {
886 return (*(DWORD *)data) ? TRUE : FALSE;
887 }
888
889 static void get_vector(struct d3dx_parameter *param, D3DXVECTOR4 *vector)
890 {
891 vector->x = get_float(param->type, (float *)param->data);
892 vector->y = param->columns > 1 ? get_float(param->type, (float *)param->data + 1) : 0.0f;
893 vector->z = param->columns > 2 ? get_float(param->type, (float *)param->data + 2) : 0.0f;
894 vector->w = param->columns > 3 ? get_float(param->type, (float *)param->data + 3) : 0.0f;
895 }
896
897 static void set_number(LPVOID outdata, D3DXPARAMETER_TYPE outtype, LPCVOID indata, D3DXPARAMETER_TYPE intype)
898 {
899 TRACE("Changing from type %i to type %i\n", intype, outtype);
900
901 switch (outtype)
902 {
903 case D3DXPT_FLOAT:
904 *(FLOAT *)outdata = get_float(intype, indata);
905 break;
906
907 case D3DXPT_BOOL:
908 *(BOOL *)outdata = get_bool(indata);
909 break;
910
911 case D3DXPT_INT:
912 *(INT *)outdata = get_int(intype, indata);
913 break;
914
915 default:
916 FIXME("Error converting to type %i\n", outtype);
917 *(INT *)outdata = 0;
918 break;
919 }
920 }
921
922 static void get_matrix(struct d3dx_parameter *param, D3DXMATRIX *matrix)
923 {
924 unsigned int i, k;
925
926 for (i = 0; i < 4; ++i)
927 {
928 for (k = 0; k < 4; ++k)
929 {
930 if ((i < param->rows) && (k < param->columns))
931 matrix->u.m[i][k] = get_float(param->type, (float *)param->data + i * param->columns + k);
932 else
933 matrix->u.m[i][k] = 0.0f;
934 }
935 }
936 }
937
938 static struct d3dx_parameter *get_parameter_element_by_name(struct d3dx_parameter *parameter, LPCSTR name)
939 {
940 UINT element;
941 struct d3dx_parameter *temp_parameter;
942 LPCSTR part;
943
944 TRACE("parameter %p, name %s\n", parameter, debugstr_a(name));
945
946 if (!name || !*name) return parameter;
947
948 element = atoi(name);
949 part = strchr(name, ']') + 1;
950
951 if (parameter->element_count > element)
952 {
953 temp_parameter = get_parameter_struct(parameter->member_handles[element]);
954
955 switch (*part++)
956 {
957 case '.':
958 return get_parameter_by_name(NULL, temp_parameter, part);
959
960 case '@':
961 return get_parameter_annotation_by_name(temp_parameter, part);
962
963 case '\0':
964 TRACE("Returning parameter %p\n", temp_parameter);
965 return temp_parameter;
966
967 default:
968 FIXME("Unhandled case \"%c\"\n", *--part);
969 break;
970 }
971 }
972
973 TRACE("Parameter not found\n");
974 return NULL;
975 }
976
977 static struct d3dx_parameter *get_parameter_annotation_by_name(struct d3dx_parameter *parameter, LPCSTR name)
978 {
979 UINT i, length;
980 struct d3dx_parameter *temp_parameter;
981 LPCSTR part;
982
983 TRACE("parameter %p, name %s\n", parameter, debugstr_a(name));
984
985 if (!name || !*name) return parameter;
986
987 length = strcspn( name, "[.@" );
988 part = name + length;
989
990 for (i = 0; i < parameter->annotation_count; ++i)
991 {
992 temp_parameter = get_parameter_struct(parameter->annotation_handles[i]);
993
994 if (!strcmp(temp_parameter->name, name))
995 {
996 TRACE("Returning parameter %p\n", temp_parameter);
997 return temp_parameter;
998 }
999 else if (strlen(temp_parameter->name) == length && !strncmp(temp_parameter->name, name, length))
1000 {
1001 switch (*part++)
1002 {
1003 case '.':
1004 return get_parameter_by_name(NULL, temp_parameter, part);
1005
1006 case '[':
1007 return get_parameter_element_by_name(temp_parameter, part);
1008
1009 default:
1010 FIXME("Unhandled case \"%c\"\n", *--part);
1011 break;
1012 }
1013 }
1014 }
1015
1016 TRACE("Parameter not found\n");
1017 return NULL;
1018 }
1019
1020 static struct d3dx_parameter *get_parameter_by_name(struct ID3DXBaseEffectImpl *base,
1021 struct d3dx_parameter *parameter, LPCSTR name)
1022 {
1023 UINT i, count, length;
1024 struct d3dx_parameter *temp_parameter;
1025 D3DXHANDLE *handles;
1026 LPCSTR part;
1027
1028 TRACE("base %p, parameter %p, name %s\n", base, parameter, debugstr_a(name));
1029
1030 if (!name || !*name) return parameter;
1031
1032 if (!parameter)
1033 {
1034 count = base->parameter_count;
1035 handles = base->parameter_handles;
1036 }
1037 else
1038 {
1039 count = parameter->member_count;
1040 handles = parameter->member_handles;
1041 }
1042
1043 length = strcspn( name, "[.@" );
1044 part = name + length;
1045
1046 for (i = 0; i < count; i++)
1047 {
1048 temp_parameter = get_parameter_struct(handles[i]);
1049
1050 if (!strcmp(temp_parameter->name, name))
1051 {
1052 TRACE("Returning parameter %p\n", temp_parameter);
1053 return temp_parameter;
1054 }
1055 else if (strlen(temp_parameter->name) == length && !strncmp(temp_parameter->name, name, length))
1056 {
1057 switch (*part++)
1058 {
1059 case '.':
1060 return get_parameter_by_name(NULL, temp_parameter, part);
1061
1062 case '@':
1063 return get_parameter_annotation_by_name(temp_parameter, part);
1064
1065 case '[':
1066 return get_parameter_element_by_name(temp_parameter, part);
1067
1068 default:
1069 FIXME("Unhandled case \"%c\"\n", *--part);
1070 break;
1071 }
1072 }
1073 }
1074
1075 TRACE("Parameter not found\n");
1076 return NULL;
1077 }
1078
1079 static inline DWORD d3dx9_effect_version(DWORD major, DWORD minor)
1080 {
1081 return (0xfeff0000 | ((major) << 8) | (minor));
1082 }
1083
1084 static inline struct ID3DXBaseEffectImpl *impl_from_ID3DXBaseEffect(ID3DXBaseEffect *iface)
1085 {
1086 return CONTAINING_RECORD(iface, struct ID3DXBaseEffectImpl, ID3DXBaseEffect_iface);
1087 }
1088
1089 /*** IUnknown methods ***/
1090 static HRESULT WINAPI ID3DXBaseEffectImpl_QueryInterface(ID3DXBaseEffect *iface, REFIID riid, void **object)
1091 {
1092 struct ID3DXBaseEffectImpl *This = impl_from_ID3DXBaseEffect(iface);
1093
1094 TRACE("iface %p, riid %s, object %p\n", This, debugstr_guid(riid), object);
1095
1096 if (IsEqualGUID(riid, &IID_IUnknown) ||
1097 IsEqualGUID(riid, &IID_ID3DXBaseEffect))
1098 {
1099 This->ID3DXBaseEffect_iface.lpVtbl->AddRef(iface);
1100 *object = This;
1101 return S_OK;
1102 }
1103
1104 ERR("Interface %s not found\n", debugstr_guid(riid));
1105
1106 return E_NOINTERFACE;
1107 }
1108
1109 static ULONG WINAPI ID3DXBaseEffectImpl_AddRef(ID3DXBaseEffect *iface)
1110 {
1111 struct ID3DXBaseEffectImpl *This = impl_from_ID3DXBaseEffect(iface);
1112
1113 TRACE("iface %p: AddRef from %u\n", iface, This->ref);
1114
1115 return InterlockedIncrement(&This->ref);
1116 }
1117
1118 static ULONG WINAPI ID3DXBaseEffectImpl_Release(ID3DXBaseEffect *iface)
1119 {
1120 struct ID3DXBaseEffectImpl *This = impl_from_ID3DXBaseEffect(iface);
1121 ULONG ref = InterlockedDecrement(&This->ref);
1122
1123 TRACE("iface %p: Release from %u\n", iface, ref + 1);
1124
1125 if (!ref)
1126 {
1127 free_base_effect(This);
1128 HeapFree(GetProcessHeap(), 0, This);
1129 }
1130
1131 return ref;
1132 }
1133
1134 /*** ID3DXBaseEffect methods ***/
1135 static HRESULT WINAPI ID3DXBaseEffectImpl_GetDesc(ID3DXBaseEffect *iface, D3DXEFFECT_DESC *desc)
1136 {
1137 struct ID3DXBaseEffectImpl *This = impl_from_ID3DXBaseEffect(iface);
1138
1139 FIXME("iface %p, desc %p partial stub\n", This, desc);
1140
1141 if (!desc)
1142 {
1143 WARN("Invalid argument specified.\n");
1144 return D3DERR_INVALIDCALL;
1145 }
1146
1147 /* Todo: add creator and function count */
1148 desc->Creator = NULL;
1149 desc->Functions = 0;
1150 desc->Parameters = This->parameter_count;
1151 desc->Techniques = This->technique_count;
1152
1153 return D3D_OK;
1154 }
1155
1156 static HRESULT WINAPI ID3DXBaseEffectImpl_GetParameterDesc(ID3DXBaseEffect *iface, D3DXHANDLE parameter, D3DXPARAMETER_DESC *desc)
1157 {
1158 struct ID3DXBaseEffectImpl *This = impl_from_ID3DXBaseEffect(iface);
1159 struct d3dx_parameter *param = get_valid_parameter(This, parameter);
1160
1161 TRACE("iface %p, parameter %p, desc %p\n", This, parameter, desc);
1162
1163 if (!desc || !param)
1164 {
1165 WARN("Invalid argument specified.\n");
1166 return D3DERR_INVALIDCALL;
1167 }
1168
1169 desc->Name = param->name;
1170 desc->Semantic = param->semantic;
1171 desc->Class = param->class;
1172 desc->Type = param->type;
1173 desc->Rows = param->rows;
1174 desc->Columns = param->columns;
1175 desc->Elements = param->element_count;
1176 desc->Annotations = param->annotation_count;
1177 desc->StructMembers = param->member_count;
1178 desc->Flags = param->flags;
1179 desc->Bytes = param->bytes;
1180
1181 return D3D_OK;
1182 }
1183
1184 static HRESULT WINAPI ID3DXBaseEffectImpl_GetTechniqueDesc(ID3DXBaseEffect *iface, D3DXHANDLE technique, D3DXTECHNIQUE_DESC *desc)
1185 {
1186 struct ID3DXBaseEffectImpl *This = impl_from_ID3DXBaseEffect(iface);
1187 struct d3dx_technique *tech = technique ? is_valid_technique(This, technique) : get_technique_struct(This->technique_handles[0]);
1188
1189 TRACE("iface %p, technique %p, desc %p\n", This, technique, desc);
1190
1191 if (!desc || !tech)
1192 {
1193 WARN("Invalid argument specified.\n");
1194 return D3DERR_INVALIDCALL;
1195 }
1196
1197 desc->Name = tech->name;
1198 desc->Passes = tech->pass_count;
1199 desc->Annotations = tech->annotation_count;
1200
1201 return D3D_OK;
1202 }
1203
1204 static HRESULT WINAPI ID3DXBaseEffectImpl_GetPassDesc(ID3DXBaseEffect *iface, D3DXHANDLE pass, D3DXPASS_DESC *desc)
1205 {
1206 struct ID3DXBaseEffectImpl *This = impl_from_ID3DXBaseEffect(iface);
1207 struct d3dx_pass *p = is_valid_pass(This, pass);
1208
1209 TRACE("iface %p, pass %p, desc %p\n", This, pass, desc);
1210
1211 if (!desc || !p)
1212 {
1213 WARN("Invalid argument specified.\n");
1214 return D3DERR_INVALIDCALL;
1215 }
1216
1217 desc->Name = p->name;
1218 desc->Annotations = p->annotation_count;
1219
1220 FIXME("Pixel shader and vertex shader are not supported, yet.\n");
1221 desc->pVertexShaderFunction = NULL;
1222 desc->pPixelShaderFunction = NULL;
1223
1224 return D3D_OK;
1225 }
1226
1227 static HRESULT WINAPI ID3DXBaseEffectImpl_GetFunctionDesc(ID3DXBaseEffect *iface, D3DXHANDLE shader, D3DXFUNCTION_DESC *desc)
1228 {
1229 struct ID3DXBaseEffectImpl *This = impl_from_ID3DXBaseEffect(iface);
1230
1231 FIXME("iface %p, shader %p, desc %p stub\n", This, shader, desc);
1232
1233 return E_NOTIMPL;
1234 }
1235
1236 static D3DXHANDLE WINAPI ID3DXBaseEffectImpl_GetParameter(ID3DXBaseEffect *iface, D3DXHANDLE parameter, UINT index)
1237 {
1238 struct ID3DXBaseEffectImpl *This = impl_from_ID3DXBaseEffect(iface);
1239 struct d3dx_parameter *param = get_valid_parameter(This, parameter);
1240
1241 TRACE("iface %p, parameter %p, index %u\n", This, parameter, index);
1242
1243 if (!parameter)
1244 {
1245 if (index < This->parameter_count)
1246 {
1247 TRACE("Returning parameter %p\n", This->parameter_handles[index]);
1248 return This->parameter_handles[index];
1249 }
1250 }
1251 else
1252 {
1253 if (param && !param->element_count && index < param->member_count)
1254 {
1255 TRACE("Returning parameter %p\n", param->member_handles[index]);
1256 return param->member_handles[index];
1257 }
1258 }
1259
1260 WARN("Invalid argument specified.\n");
1261
1262 return NULL;
1263 }
1264
1265 static D3DXHANDLE WINAPI ID3DXBaseEffectImpl_GetParameterByName(ID3DXBaseEffect *iface, D3DXHANDLE parameter, LPCSTR name)
1266 {
1267 struct ID3DXBaseEffectImpl *This = impl_from_ID3DXBaseEffect(iface);
1268 struct d3dx_parameter *param = get_valid_parameter(This, parameter);
1269 D3DXHANDLE handle;
1270
1271 TRACE("iface %p, parameter %p, name %s\n", This, parameter, debugstr_a(name));
1272
1273 if (!name)
1274 {
1275 handle = get_parameter_handle(param);
1276 TRACE("Returning parameter %p\n", handle);
1277 return handle;
1278 }
1279
1280 handle = get_parameter_handle(get_parameter_by_name(This, param, name));
1281 TRACE("Returning parameter %p\n", handle);
1282
1283 return handle;
1284 }
1285
1286 static D3DXHANDLE WINAPI ID3DXBaseEffectImpl_GetParameterBySemantic(ID3DXBaseEffect *iface, D3DXHANDLE parameter, LPCSTR semantic)
1287 {
1288 struct ID3DXBaseEffectImpl *This = impl_from_ID3DXBaseEffect(iface);
1289 struct d3dx_parameter *param = get_valid_parameter(This, parameter);
1290 struct d3dx_parameter *temp_param;
1291 UINT i;
1292
1293 TRACE("iface %p, parameter %p, semantic %s\n", This, parameter, debugstr_a(semantic));
1294
1295 if (!parameter)
1296 {
1297 for (i = 0; i < This->parameter_count; ++i)
1298 {
1299 temp_param = get_parameter_struct(This->parameter_handles[i]);
1300
1301 if (!temp_param->semantic)
1302 {
1303 if (!semantic)
1304 {
1305 TRACE("Returning parameter %p\n", This->parameter_handles[i]);
1306 return This->parameter_handles[i];
1307 }
1308 continue;
1309 }
1310
1311 if (!strcasecmp(temp_param->semantic, semantic))
1312 {
1313 TRACE("Returning parameter %p\n", This->parameter_handles[i]);
1314 return This->parameter_handles[i];
1315 }
1316 }
1317 }
1318 else if (param)
1319 {
1320 for (i = 0; i < param->member_count; ++i)
1321 {
1322 temp_param = get_parameter_struct(param->member_handles[i]);
1323
1324 if (!temp_param->semantic)
1325 {
1326 if (!semantic)
1327 {
1328 TRACE("Returning parameter %p\n", param->member_handles[i]);
1329 return param->member_handles[i];
1330 }
1331 continue;
1332 }
1333
1334 if (!strcasecmp(temp_param->semantic, semantic))
1335 {
1336 TRACE("Returning parameter %p\n", param->member_handles[i]);
1337 return param->member_handles[i];
1338 }
1339 }
1340 }
1341
1342 WARN("Invalid argument specified\n");
1343
1344 return NULL;
1345 }
1346
1347 static D3DXHANDLE WINAPI ID3DXBaseEffectImpl_GetParameterElement(ID3DXBaseEffect *iface, D3DXHANDLE parameter, UINT index)
1348 {
1349 struct ID3DXBaseEffectImpl *This = impl_from_ID3DXBaseEffect(iface);
1350 struct d3dx_parameter *param = get_valid_parameter(This, parameter);
1351
1352 TRACE("iface %p, parameter %p, index %u\n", This, parameter, index);
1353
1354 if (!param)
1355 {
1356 if (index < This->parameter_count)
1357 {
1358 TRACE("Returning parameter %p\n", This->parameter_handles[index]);
1359 return This->parameter_handles[index];
1360 }
1361 }
1362 else
1363 {
1364 if (index < param->element_count)
1365 {
1366 TRACE("Returning parameter %p\n", param->member_handles[index]);
1367 return param->member_handles[index];
1368 }
1369 }
1370
1371 WARN("Invalid argument specified\n");
1372
1373 return NULL;
1374 }
1375
1376 static D3DXHANDLE WINAPI ID3DXBaseEffectImpl_GetTechnique(ID3DXBaseEffect *iface, UINT index)
1377 {
1378 struct ID3DXBaseEffectImpl *This = impl_from_ID3DXBaseEffect(iface);
1379
1380 TRACE("iface %p, index %u\n", This, index);
1381
1382 if (index >= This->technique_count)
1383 {
1384 WARN("Invalid argument specified.\n");
1385 return NULL;
1386 }
1387
1388 TRACE("Returning technique %p\n", This->technique_handles[index]);
1389
1390 return This->technique_handles[index];
1391 }
1392
1393 static D3DXHANDLE WINAPI ID3DXBaseEffectImpl_GetTechniqueByName(ID3DXBaseEffect *iface, LPCSTR name)
1394 {
1395 struct ID3DXBaseEffectImpl *This = impl_from_ID3DXBaseEffect(iface);
1396 unsigned int i;
1397
1398 TRACE("iface %p, name %s stub\n", This, debugstr_a(name));
1399
1400 if (!name)
1401 {
1402 WARN("Invalid argument specified.\n");
1403 return NULL;
1404 }
1405
1406 for (i = 0; i < This->technique_count; ++i)
1407 {
1408 struct d3dx_technique *tech = get_technique_struct(This->technique_handles[i]);
1409
1410 if (!strcmp(tech->name, name))
1411 {
1412 TRACE("Returning technique %p\n", This->technique_handles[i]);
1413 return This->technique_handles[i];
1414 }
1415 }
1416
1417 WARN("Invalid argument specified.\n");
1418
1419 return NULL;
1420 }
1421
1422 static D3DXHANDLE WINAPI ID3DXBaseEffectImpl_GetPass(ID3DXBaseEffect *iface, D3DXHANDLE technique, UINT index)
1423 {
1424 struct ID3DXBaseEffectImpl *This = impl_from_ID3DXBaseEffect(iface);
1425 struct d3dx_technique *tech = is_valid_technique(This, technique);
1426
1427 TRACE("iface %p, technique %p, index %u\n", This, technique, index);
1428
1429 if (!tech) tech = get_technique_struct(iface->lpVtbl->GetTechniqueByName(iface, technique));
1430
1431 if (tech && index < tech->pass_count)
1432 {
1433 TRACE("Returning pass %p\n", tech->pass_handles[index]);
1434 return tech->pass_handles[index];
1435 }
1436
1437 WARN("Invalid argument specified.\n");
1438
1439 return NULL;
1440 }
1441
1442 static D3DXHANDLE WINAPI ID3DXBaseEffectImpl_GetPassByName(ID3DXBaseEffect *iface, D3DXHANDLE technique, LPCSTR name)
1443 {
1444 struct ID3DXBaseEffectImpl *This = impl_from_ID3DXBaseEffect(iface);
1445 struct d3dx_technique *tech = is_valid_technique(This, technique);
1446
1447 TRACE("iface %p, technique %p, name %s\n", This, technique, debugstr_a(name));
1448
1449 if (!tech) tech = get_technique_struct(iface->lpVtbl->GetTechniqueByName(iface, technique));
1450
1451 if (tech && name)
1452 {
1453 unsigned int i;
1454
1455 for (i = 0; i < tech->pass_count; ++i)
1456 {
1457 struct d3dx_pass *pass = get_pass_struct(tech->pass_handles[i]);
1458
1459 if (!strcmp(pass->name, name))
1460 {
1461 TRACE("Returning pass %p\n", tech->pass_handles[i]);
1462 return tech->pass_handles[i];
1463 }
1464 }
1465 }
1466
1467 WARN("Invalid argument specified.\n");
1468
1469 return NULL;
1470 }
1471
1472 static D3DXHANDLE WINAPI ID3DXBaseEffectImpl_GetFunction(ID3DXBaseEffect *iface, UINT index)
1473 {
1474 struct ID3DXBaseEffectImpl *This = impl_from_ID3DXBaseEffect(iface);
1475
1476 FIXME("iface %p, index %u stub\n", This, index);
1477
1478 return NULL;
1479 }
1480
1481 static D3DXHANDLE WINAPI ID3DXBaseEffectImpl_GetFunctionByName(ID3DXBaseEffect *iface, LPCSTR name)
1482 {
1483 struct ID3DXBaseEffectImpl *This = impl_from_ID3DXBaseEffect(iface);
1484
1485 FIXME("iface %p, name %s stub\n", This, debugstr_a(name));
1486
1487 return NULL;
1488 }
1489
1490 static D3DXHANDLE WINAPI ID3DXBaseEffectImpl_GetAnnotation(ID3DXBaseEffect *iface, D3DXHANDLE object, UINT index)
1491 {
1492 struct ID3DXBaseEffectImpl *This = impl_from_ID3DXBaseEffect(iface);
1493 struct d3dx_parameter *param = get_valid_parameter(This, object);
1494 struct d3dx_pass *pass = is_valid_pass(This, object);
1495 struct d3dx_technique *technique = is_valid_technique(This, object);
1496 UINT annotation_count = 0;
1497 D3DXHANDLE *annotation_handles = NULL;
1498
1499 FIXME("iface %p, object %p, index %u partial stub\n", This, object, index);
1500
1501 if (pass)
1502 {
1503 annotation_count = pass->annotation_count;
1504 annotation_handles = pass->annotation_handles;
1505 }
1506 else if (technique)
1507 {
1508 annotation_count = technique->annotation_count;
1509 annotation_handles = technique->annotation_handles;
1510 }
1511 else if (param)
1512 {
1513 annotation_count = param->annotation_count;
1514 annotation_handles = param->annotation_handles;
1515 }
1516 /* Todo: add funcs */
1517
1518 if (index < annotation_count)
1519 {
1520 TRACE("Returning parameter %p\n", annotation_handles[index]);
1521 return annotation_handles[index];
1522 }
1523
1524 WARN("Invalid argument specified\n");
1525
1526 return NULL;
1527 }
1528
1529 static D3DXHANDLE WINAPI ID3DXBaseEffectImpl_GetAnnotationByName(ID3DXBaseEffect *iface, D3DXHANDLE object, LPCSTR name)
1530 {
1531 struct ID3DXBaseEffectImpl *This = impl_from_ID3DXBaseEffect(iface);
1532 struct d3dx_parameter *param = get_valid_parameter(This, object);
1533 struct d3dx_pass *pass = is_valid_pass(This, object);
1534 struct d3dx_technique *technique = is_valid_technique(This, object);
1535 UINT annotation_count = 0, i;
1536 D3DXHANDLE *annotation_handles = NULL;
1537
1538 FIXME("iface %p, object %p, name %s partial stub\n", This, object, debugstr_a(name));
1539
1540 if (!name)
1541 {
1542 WARN("Invalid argument specified\n");
1543 return NULL;
1544 }
1545
1546 if (pass)
1547 {
1548 annotation_count = pass->annotation_count;
1549 annotation_handles = pass->annotation_handles;
1550 }
1551 else if (technique)
1552 {
1553 annotation_count = technique->annotation_count;
1554 annotation_handles = technique->annotation_handles;
1555 }
1556 else if (param)
1557 {
1558 annotation_count = param->annotation_count;
1559 annotation_handles = param->annotation_handles;
1560 }
1561 /* Todo: add funcs */
1562
1563 for (i = 0; i < annotation_count; i++)
1564 {
1565 struct d3dx_parameter *anno = get_parameter_struct(annotation_handles[i]);
1566
1567 if (!strcmp(anno->name, name))
1568 {
1569 TRACE("Returning parameter %p\n", anno);
1570 return get_parameter_handle(anno);
1571 }
1572 }
1573
1574 WARN("Invalid argument specified\n");
1575
1576 return NULL;
1577 }
1578
1579 static HRESULT WINAPI ID3DXBaseEffectImpl_SetValue(ID3DXBaseEffect *iface, D3DXHANDLE parameter, LPCVOID data, UINT bytes)
1580 {
1581 struct ID3DXBaseEffectImpl *This = impl_from_ID3DXBaseEffect(iface);
1582
1583 FIXME("iface %p, parameter %p, data %p, bytes %u stub\n", This, parameter, data, bytes);
1584
1585 return E_NOTIMPL;
1586 }
1587
1588 static HRESULT WINAPI ID3DXBaseEffectImpl_GetValue(ID3DXBaseEffect *iface, D3DXHANDLE parameter, LPVOID data, UINT bytes)
1589 {
1590 struct ID3DXBaseEffectImpl *This = impl_from_ID3DXBaseEffect(iface);
1591 struct d3dx_parameter *param = get_valid_parameter(This, parameter);
1592
1593 TRACE("iface %p, parameter %p, data %p, bytes %u\n", This, parameter, data, bytes);
1594
1595 if (!param)
1596 {
1597 WARN("Invalid parameter %p specified\n", parameter);
1598 return D3DERR_INVALIDCALL;
1599 }
1600
1601 /* samplers don't touch data */
1602 if (param->class == D3DXPC_OBJECT && (param->type == D3DXPT_SAMPLER
1603 || param->type == D3DXPT_SAMPLER1D || param->type == D3DXPT_SAMPLER2D
1604 || param->type == D3DXPT_SAMPLER3D || param->type == D3DXPT_SAMPLERCUBE))
1605 {
1606 TRACE("Sampler: returning E_FAIL\n");
1607 return E_FAIL;
1608 }
1609
1610 if (data && param->bytes <= bytes)
1611 {
1612 TRACE("Type %s\n", debug_d3dxparameter_type(param->type));
1613
1614 switch (param->type)
1615 {
1616 case D3DXPT_VOID:
1617 case D3DXPT_BOOL:
1618 case D3DXPT_INT:
1619 case D3DXPT_FLOAT:
1620 case D3DXPT_STRING:
1621 break;
1622
1623 case D3DXPT_VERTEXSHADER:
1624 case D3DXPT_PIXELSHADER:
1625 case D3DXPT_TEXTURE:
1626 case D3DXPT_TEXTURE1D:
1627 case D3DXPT_TEXTURE2D:
1628 case D3DXPT_TEXTURE3D:
1629 case D3DXPT_TEXTURECUBE:
1630 {
1631 UINT i;
1632
1633 for (i = 0; i < (param->element_count ? param->element_count : 1); ++i)
1634 {
1635 IUnknown *unk = ((IUnknown **)param->data)[i];
1636 if (unk) IUnknown_AddRef(unk);
1637 }
1638 break;
1639 }
1640
1641 default:
1642 FIXME("Unhandled type %s\n", debug_d3dxparameter_type(param->type));
1643 break;
1644 }
1645
1646 TRACE("Copy %u bytes\n", param->bytes);
1647 memcpy(data, param->data, param->bytes);
1648 return D3D_OK;
1649 }
1650
1651 WARN("Invalid argument specified\n");
1652
1653 return D3DERR_INVALIDCALL;
1654 }
1655
1656 static HRESULT WINAPI ID3DXBaseEffectImpl_SetBool(ID3DXBaseEffect *iface, D3DXHANDLE parameter, BOOL b)
1657 {
1658 struct ID3DXBaseEffectImpl *This = impl_from_ID3DXBaseEffect(iface);
1659 struct d3dx_parameter *param = get_valid_parameter(This, parameter);
1660
1661 TRACE("iface %p, parameter %p, b %s\n", This, parameter, b ? "TRUE" : "FALSE");
1662
1663 if (param && !param->element_count && param->rows == 1 && param->columns == 1)
1664 {
1665 set_number(param->data, param->type, &b, D3DXPT_BOOL);
1666 return D3D_OK;
1667 }
1668
1669 WARN("Invalid argument specified\n");
1670
1671 return D3DERR_INVALIDCALL;
1672 }
1673
1674 static HRESULT WINAPI ID3DXBaseEffectImpl_GetBool(ID3DXBaseEffect *iface, D3DXHANDLE parameter, BOOL *b)
1675 {
1676 struct ID3DXBaseEffectImpl *This = impl_from_ID3DXBaseEffect(iface);
1677 struct d3dx_parameter *param = get_valid_parameter(This, parameter);
1678
1679 TRACE("iface %p, parameter %p, b %p\n", This, parameter, b);
1680
1681 if (b && param && !param->element_count && param->rows == 1 && param->columns == 1)
1682 {
1683 *b = get_bool(param->data);
1684 TRACE("Returning %s\n", *b ? "TRUE" : "FALSE");
1685 return D3D_OK;
1686 }
1687
1688 WARN("Invalid argument specified\n");
1689
1690 return D3DERR_INVALIDCALL;
1691 }
1692
1693 static HRESULT WINAPI ID3DXBaseEffectImpl_SetBoolArray(ID3DXBaseEffect *iface, D3DXHANDLE parameter, CONST BOOL *b, UINT count)
1694 {
1695 struct ID3DXBaseEffectImpl *This = impl_from_ID3DXBaseEffect(iface);
1696
1697 FIXME("iface %p, parameter %p, b %p, count %u stub\n", This, parameter, b, count);
1698
1699 return E_NOTIMPL;
1700 }
1701
1702 static HRESULT WINAPI ID3DXBaseEffectImpl_GetBoolArray(ID3DXBaseEffect *iface, D3DXHANDLE parameter, BOOL *b, UINT count)
1703 {
1704 struct ID3DXBaseEffectImpl *This = impl_from_ID3DXBaseEffect(iface);
1705 struct d3dx_parameter *param = get_valid_parameter(This, parameter);
1706
1707 TRACE("iface %p, parameter %p, b %p, count %u\n", This, parameter, b, count);
1708
1709 if (b && param && (param->class == D3DXPC_SCALAR
1710 || param->class == D3DXPC_VECTOR
1711 || param->class == D3DXPC_MATRIX_ROWS
1712 || param->class == D3DXPC_MATRIX_COLUMNS))
1713 {
1714 UINT i, size = min(count, param->bytes / sizeof(DWORD));
1715
1716 for (i = 0; i < size; ++i)
1717 {
1718 b[i] = get_bool((DWORD *)param->data + i);
1719 }
1720 return D3D_OK;
1721 }
1722
1723 WARN("Invalid argument specified\n");
1724
1725 return D3DERR_INVALIDCALL;
1726 }
1727
1728 static HRESULT WINAPI ID3DXBaseEffectImpl_SetInt(ID3DXBaseEffect *iface, D3DXHANDLE parameter, INT n)
1729 {
1730 struct ID3DXBaseEffectImpl *This = impl_from_ID3DXBaseEffect(iface);
1731 struct d3dx_parameter *param = get_valid_parameter(This, parameter);
1732
1733 TRACE("iface %p, parameter %p, n %i\n", This, parameter, n);
1734
1735 if (param && !param->element_count)
1736 {
1737 if (param->rows == 1 && param->columns == 1)
1738 {
1739 set_number(param->data, param->type, &n, D3DXPT_INT);
1740 return D3D_OK;
1741 }
1742
1743 /*
1744 * Split the value, if parameter is a vector with dimension 3 or 4.
1745 */
1746 if (param->type == D3DXPT_FLOAT &&
1747 ((param->class == D3DXPC_VECTOR && param->columns != 2) ||
1748 (param->class == D3DXPC_MATRIX_ROWS && param->rows != 2 && param->columns == 1)))
1749 {
1750 FLOAT tmp = ((n & 0xff0000) >> 16) * INT_FLOAT_MULTI_INVERSE;
1751 set_number((DWORD *)param->data, param->type, &tmp, D3DXPT_FLOAT);
1752
1753 tmp = ((n & 0xff00) >> 8) * INT_FLOAT_MULTI_INVERSE;
1754 set_number((DWORD *)param->data + 1, param->type, &tmp, D3DXPT_FLOAT);
1755
1756 tmp = (n & 0xff) * INT_FLOAT_MULTI_INVERSE;
1757 set_number((DWORD *)param->data + 2, param->type, &tmp, D3DXPT_FLOAT);
1758
1759 if (param->rows * param->columns > 3)
1760 {
1761 tmp = ((n & 0xff000000) >> 24) * INT_FLOAT_MULTI_INVERSE;
1762 set_number((DWORD *)param->data + 3, param->type, &tmp, D3DXPT_FLOAT);
1763 }
1764 return D3D_OK;
1765 }
1766 }
1767
1768 WARN("Invalid argument specified\n");
1769
1770 return D3DERR_INVALIDCALL;
1771 }
1772
1773 static HRESULT WINAPI ID3DXBaseEffectImpl_GetInt(ID3DXBaseEffect *iface, D3DXHANDLE parameter, INT *n)
1774 {
1775 struct ID3DXBaseEffectImpl *This = impl_from_ID3DXBaseEffect(iface);
1776 struct d3dx_parameter *param = get_valid_parameter(This, parameter);
1777
1778 TRACE("iface %p, parameter %p, n %p\n", This, parameter, n);
1779
1780 if (n && param && !param->element_count)
1781 {
1782 if (param->columns == 1 && param->rows == 1)
1783 {
1784 *n = get_int(param->type, param->data);
1785 TRACE("Returning %i\n", *n);
1786 return D3D_OK;
1787 }
1788
1789 if (param->type == D3DXPT_FLOAT &&
1790 ((param->class == D3DXPC_VECTOR && param->columns != 2)
1791 || (param->class == D3DXPC_MATRIX_ROWS && param->rows != 2 && param->columns == 1)))
1792 {
1793 /* all components (3,4) are clamped (0,255) and put in the INT */
1794 *n = (INT)(min(max(0.0f, *((FLOAT *)param->data + 2)), 1.0f) * INT_FLOAT_MULTI);
1795 *n += ((INT)(min(max(0.0f, *((FLOAT *)param->data + 1)), 1.0f) * INT_FLOAT_MULTI)) << 8;
1796 *n += ((INT)(min(max(0.0f, *((FLOAT *)param->data + 0)), 1.0f) * INT_FLOAT_MULTI)) << 16;
1797 if (param->columns * param->rows > 3)
1798 {
1799 *n += ((INT)(min(max(0.0f, *((FLOAT *)param->data + 3)), 1.0f) * INT_FLOAT_MULTI)) << 24;
1800 }
1801
1802 TRACE("Returning %i\n", *n);
1803 return D3D_OK;
1804 }
1805 }
1806
1807 WARN("Invalid argument specified\n");
1808
1809 return D3DERR_INVALIDCALL;
1810 }
1811
1812 static HRESULT WINAPI ID3DXBaseEffectImpl_SetIntArray(ID3DXBaseEffect *iface, D3DXHANDLE parameter, CONST INT *n, UINT count)
1813 {
1814 struct ID3DXBaseEffectImpl *This = impl_from_ID3DXBaseEffect(iface);
1815 struct d3dx_parameter *param = get_valid_parameter(This, parameter);
1816
1817 TRACE("iface %p, parameter %p, n %p, count %u\n", This, parameter, n, count);
1818
1819 if (param)
1820 {
1821 UINT i, size = min(count, param->bytes / sizeof(DWORD));
1822
1823 TRACE("Class %s\n", debug_d3dxparameter_class(param->class));
1824
1825 switch (param->class)
1826 {
1827 case D3DXPC_SCALAR:
1828 case D3DXPC_VECTOR:
1829 case D3DXPC_MATRIX_ROWS:
1830 for (i = 0; i < size; ++i)
1831 {
1832 set_number((DWORD *)param->data + i, param->type, &n[i], D3DXPT_INT);
1833 }
1834 return D3D_OK;
1835
1836 case D3DXPC_OBJECT:
1837 case D3DXPC_STRUCT:
1838 break;
1839
1840 default:
1841 FIXME("Unhandled class %s\n", debug_d3dxparameter_class(param->class));
1842 break;
1843 }
1844 }
1845
1846 WARN("Invalid argument specified\n");
1847
1848 return D3DERR_INVALIDCALL;
1849 }
1850
1851 static HRESULT WINAPI ID3DXBaseEffectImpl_GetIntArray(ID3DXBaseEffect *iface, D3DXHANDLE parameter, INT *n, UINT count)
1852 {
1853 struct ID3DXBaseEffectImpl *This = impl_from_ID3DXBaseEffect(iface);
1854 struct d3dx_parameter *param = get_valid_parameter(This, parameter);
1855
1856 TRACE("iface %p, parameter %p, n %p, count %u\n", This, parameter, n, count);
1857
1858 if (n && param && (param->class == D3DXPC_SCALAR
1859 || param->class == D3DXPC_VECTOR
1860 || param->class == D3DXPC_MATRIX_ROWS
1861 || param->class == D3DXPC_MATRIX_COLUMNS))
1862 {
1863 UINT i, size = min(count, param->bytes / sizeof(DWORD));
1864
1865 for (i = 0; i < size; ++i)
1866 {
1867 n[i] = get_int(param->type, (DWORD *)param->data + i);
1868 }
1869 return D3D_OK;
1870 }
1871
1872 WARN("Invalid argument specified\n");
1873
1874 return D3DERR_INVALIDCALL;
1875 }
1876
1877 static HRESULT WINAPI ID3DXBaseEffectImpl_SetFloat(ID3DXBaseEffect *iface, D3DXHANDLE parameter, FLOAT f)
1878 {
1879 struct ID3DXBaseEffectImpl *This = impl_from_ID3DXBaseEffect(iface);
1880 struct d3dx_parameter *param = get_valid_parameter(This, parameter);
1881
1882 TRACE("iface %p, parameter %p, f %f\n", This, parameter, f);
1883
1884 if (param && !param->element_count && param->rows == 1 && param->columns == 1)
1885 {
1886 set_number((DWORD *)param->data, param->type, &f, D3DXPT_FLOAT);
1887 return D3D_OK;
1888 }
1889
1890 WARN("Invalid argument specified\n");
1891
1892 return D3DERR_INVALIDCALL;
1893 }
1894
1895 static HRESULT WINAPI ID3DXBaseEffectImpl_GetFloat(ID3DXBaseEffect *iface, D3DXHANDLE parameter, FLOAT *f)
1896 {
1897 struct ID3DXBaseEffectImpl *This = impl_from_ID3DXBaseEffect(iface);
1898 struct d3dx_parameter *param = get_valid_parameter(This, parameter);
1899
1900 TRACE("iface %p, parameter %p, f %p\n", This, parameter, f);
1901
1902 if (f && param && !param->element_count && param->columns == 1 && param->rows == 1)
1903 {
1904 *f = get_float(param->type, (DWORD *)param->data);
1905 TRACE("Returning %f\n", *f);
1906 return D3D_OK;
1907 }
1908
1909 WARN("Invalid argument specified\n");
1910
1911 return D3DERR_INVALIDCALL;
1912 }
1913
1914 static HRESULT WINAPI ID3DXBaseEffectImpl_SetFloatArray(ID3DXBaseEffect *iface, D3DXHANDLE parameter, CONST FLOAT *f, UINT count)
1915 {
1916 struct ID3DXBaseEffectImpl *This = impl_from_ID3DXBaseEffect(iface);
1917 struct d3dx_parameter *param = get_valid_parameter(This, parameter);
1918
1919 TRACE("iface %p, parameter %p, f %p, count %u\n", This, parameter, f, count);
1920
1921 if (param)
1922 {
1923 UINT i, size = min(count, param->bytes / sizeof(DWORD));
1924
1925 TRACE("Class %s\n", debug_d3dxparameter_class(param->class));
1926
1927 switch (param->class)
1928 {
1929 case D3DXPC_SCALAR:
1930 case D3DXPC_VECTOR:
1931 case D3DXPC_MATRIX_ROWS:
1932 for (i = 0; i < size; ++i)
1933 {
1934 set_number((DWORD *)param->data + i, param->type, &f[i], D3DXPT_FLOAT);
1935 }
1936 return D3D_OK;
1937
1938 case D3DXPC_OBJECT:
1939 case D3DXPC_STRUCT:
1940 break;
1941
1942 default:
1943 FIXME("Unhandled class %s\n", debug_d3dxparameter_class(param->class));
1944 break;
1945 }
1946 }
1947
1948 WARN("Invalid argument specified\n");
1949
1950 return D3DERR_INVALIDCALL;
1951 }
1952
1953 static HRESULT WINAPI ID3DXBaseEffectImpl_GetFloatArray(ID3DXBaseEffect *iface, D3DXHANDLE parameter, FLOAT *f, UINT count)
1954 {
1955 struct ID3DXBaseEffectImpl *This = impl_from_ID3DXBaseEffect(iface);
1956 struct d3dx_parameter *param = get_valid_parameter(This, parameter);
1957
1958 TRACE("iface %p, parameter %p, f %p, count %u\n", This, parameter, f, count);
1959
1960 if (f && param && (param->class == D3DXPC_SCALAR
1961 || param->class == D3DXPC_VECTOR
1962 || param->class == D3DXPC_MATRIX_ROWS
1963 || param->class == D3DXPC_MATRIX_COLUMNS))
1964 {
1965 UINT i, size = min(count, param->bytes / sizeof(DWORD));
1966
1967 for (i = 0; i < size; ++i)
1968 {
1969 f[i] = get_float(param->type, (DWORD *)param->data + i);
1970 }
1971 return D3D_OK;
1972 }
1973
1974 WARN("Invalid argument specified\n");
1975
1976 return D3DERR_INVALIDCALL;
1977 }
1978
1979 static HRESULT WINAPI ID3DXBaseEffectImpl_SetVector(ID3DXBaseEffect* iface, D3DXHANDLE parameter, CONST D3DXVECTOR4* vector)
1980 {
1981 struct ID3DXBaseEffectImpl *This = impl_from_ID3DXBaseEffect(iface);
1982
1983 FIXME("iface %p, parameter %p, vector %p stub\n", This, parameter, vector);
1984
1985 return E_NOTIMPL;
1986 }
1987
1988 static HRESULT WINAPI ID3DXBaseEffectImpl_GetVector(ID3DXBaseEffect *iface, D3DXHANDLE parameter, D3DXVECTOR4 *vector)
1989 {
1990 struct ID3DXBaseEffectImpl *This = impl_from_ID3DXBaseEffect(iface);
1991
1992 FIXME("iface %p, parameter %p, vector %p stub\n", This, parameter, vector);
1993
1994 return E_NOTIMPL;
1995 }
1996
1997 static HRESULT WINAPI ID3DXBaseEffectImpl_SetVectorArray(ID3DXBaseEffect *iface, D3DXHANDLE parameter, CONST D3DXVECTOR4 *vector, UINT count)
1998 {
1999 struct ID3DXBaseEffectImpl *This = impl_from_ID3DXBaseEffect(iface);
2000
2001 FIXME("iface %p, parameter %p, vector %p, count %u stub\n", This, parameter, vector, count);
2002
2003 return E_NOTIMPL;
2004 }
2005
2006 static HRESULT WINAPI ID3DXBaseEffectImpl_GetVectorArray(ID3DXBaseEffect *iface, D3DXHANDLE parameter, D3DXVECTOR4 *vector, UINT count)
2007 {
2008 struct ID3DXBaseEffectImpl *This = impl_from_ID3DXBaseEffect(iface);
2009 struct d3dx_parameter *param = get_valid_parameter(This, parameter);
2010
2011 TRACE("iface %p, parameter %p, vector %p, count %u\n", This, parameter, vector, count);
2012
2013 if (!count) return D3D_OK;
2014
2015 if (vector && param && count <= param->element_count)
2016 {
2017 UINT i;
2018
2019 TRACE("Class %s\n", debug_d3dxparameter_class(param->class));
2020
2021 switch (param->class)
2022 {
2023 case D3DXPC_VECTOR:
2024 for (i = 0; i < count; ++i)
2025 {
2026 get_vector(get_parameter_struct(param->member_handles[i]), &vector[i]);
2027 }
2028 return D3D_OK;
2029
2030 case D3DXPC_SCALAR:
2031 case D3DXPC_MATRIX_ROWS:
2032 case D3DXPC_OBJECT:
2033 case D3DXPC_STRUCT:
2034 break;
2035
2036 default:
2037 FIXME("Unhandled class %s\n", debug_d3dxparameter_class(param->class));
2038 break;
2039 }
2040 }
2041
2042 WARN("Invalid argument specified\n");
2043
2044 return D3DERR_INVALIDCALL;
2045 }
2046
2047 static HRESULT WINAPI ID3DXBaseEffectImpl_SetMatrix(ID3DXBaseEffect *iface, D3DXHANDLE parameter, CONST D3DXMATRIX *matrix)
2048 {
2049 struct ID3DXBaseEffectImpl *This = impl_from_ID3DXBaseEffect(iface);
2050
2051 FIXME("iface %p, parameter %p, matrix %p stub\n", This, parameter, matrix);
2052
2053 return E_NOTIMPL;
2054 }
2055
2056 static HRESULT WINAPI ID3DXBaseEffectImpl_GetMatrix(ID3DXBaseEffect *iface, D3DXHANDLE parameter, D3DXMATRIX *matrix)
2057 {
2058 struct ID3DXBaseEffectImpl *This = impl_from_ID3DXBaseEffect(iface);
2059 struct d3dx_parameter *param = get_valid_parameter(This, parameter);
2060
2061 TRACE("iface %p, parameter %p, matrix %p\n", This, parameter, matrix);
2062
2063 if (matrix && param && !param->element_count)
2064 {
2065 TRACE("Class %s\n", debug_d3dxparameter_class(param->class));
2066
2067 switch (param->class)
2068 {
2069 case D3DXPC_MATRIX_ROWS:
2070 get_matrix(param, matrix);
2071 return D3D_OK;
2072
2073 case D3DXPC_SCALAR:
2074 case D3DXPC_VECTOR:
2075 case D3DXPC_OBJECT:
2076 case D3DXPC_STRUCT:
2077 break;
2078
2079 default:
2080 FIXME("Unhandled class %s\n", debug_d3dxparameter_class(param->class));
2081 break;
2082 }
2083 }
2084
2085 WARN("Invalid argument specified\n");
2086
2087 return D3DERR_INVALIDCALL;
2088 }
2089
2090 static HRESULT WINAPI ID3DXBaseEffectImpl_SetMatrixArray(ID3DXBaseEffect *iface, D3DXHANDLE parameter, CONST D3DXMATRIX *matrix, UINT count)
2091 {
2092 struct ID3DXBaseEffectImpl *This = impl_from_ID3DXBaseEffect(iface);
2093
2094 FIXME("iface %p, parameter %p, matrix %p, count %u stub\n", This, parameter, matrix, count);
2095
2096 return E_NOTIMPL;
2097 }
2098
2099 static HRESULT WINAPI ID3DXBaseEffectImpl_GetMatrixArray(ID3DXBaseEffect *iface, D3DXHANDLE parameter, D3DXMATRIX *matrix, UINT count)
2100 {
2101 struct ID3DXBaseEffectImpl *This = impl_from_ID3DXBaseEffect(iface);
2102 struct d3dx_parameter *param = get_valid_parameter(This, parameter);
2103
2104 TRACE("iface %p, parameter %p, matrix %p, count %u\n", This, parameter, matrix, count);
2105
2106 if (!count) return D3D_OK;
2107
2108 if (matrix && param && count <= param->element_count)
2109 {
2110 UINT i;
2111
2112 TRACE("Class %s\n", debug_d3dxparameter_class(param->class));
2113
2114 switch (param->class)
2115 {
2116 case D3DXPC_MATRIX_ROWS:
2117 for (i = 0; i < count; ++i)
2118 {
2119 get_matrix(get_parameter_struct(param->member_handles[i]), &matrix[i]);
2120 }
2121 return D3D_OK;
2122
2123 case D3DXPC_SCALAR:
2124 case D3DXPC_VECTOR:
2125 case D3DXPC_OBJECT:
2126 case D3DXPC_STRUCT:
2127 break;
2128
2129 default:
2130 FIXME("Unhandled class %s\n", debug_d3dxparameter_class(param->class));
2131 break;
2132 }
2133 }
2134
2135 WARN("Invalid argument specified\n");
2136
2137 return D3DERR_INVALIDCALL;
2138 }
2139
2140 static HRESULT WINAPI ID3DXBaseEffectImpl_SetMatrixPointerArray(ID3DXBaseEffect *iface, D3DXHANDLE parameter, CONST D3DXMATRIX **matrix, UINT count)
2141 {
2142 struct ID3DXBaseEffectImpl *This = impl_from_ID3DXBaseEffect(iface);
2143
2144 FIXME("iface %p, parameter %p, matrix %p, count %u stub\n", This, parameter, matrix, count);
2145
2146 return E_NOTIMPL;
2147 }
2148
2149 static HRESULT WINAPI ID3DXBaseEffectImpl_GetMatrixPointerArray(ID3DXBaseEffect *iface, D3DXHANDLE parameter, D3DXMATRIX **matrix, UINT count)
2150 {
2151 struct ID3DXBaseEffectImpl *This = impl_from_ID3DXBaseEffect(iface);
2152
2153 FIXME("iface %p, parameter %p, matrix %p, count %u stub\n", This, parameter, matrix, count);
2154
2155 return E_NOTIMPL;
2156 }
2157
2158 static HRESULT WINAPI ID3DXBaseEffectImpl_SetMatrixTranspose(ID3DXBaseEffect *iface, D3DXHANDLE parameter, CONST D3DXMATRIX *matrix)
2159 {
2160 struct ID3DXBaseEffectImpl *This = impl_from_ID3DXBaseEffect(iface);
2161
2162 FIXME("iface %p, parameter %p, matrix %p stub\n", This, parameter, matrix);
2163
2164 return E_NOTIMPL;
2165 }
2166
2167 static HRESULT WINAPI ID3DXBaseEffectImpl_GetMatrixTranspose(ID3DXBaseEffect *iface, D3DXHANDLE parameter, D3DXMATRIX *matrix)
2168 {
2169 struct ID3DXBaseEffectImpl *This = impl_from_ID3DXBaseEffect(iface);
2170 struct d3dx_parameter *param = get_valid_parameter(This, parameter);
2171 D3DXMATRIX m;
2172
2173 TRACE("iface %p, parameter %p, matrix %p\n", This, parameter, matrix);
2174
2175 if (matrix && param && !param->element_count)
2176 {
2177 TRACE("Class %s\n", debug_d3dxparameter_class(param->class));
2178
2179 switch (param->class)
2180 {
2181 case D3DXPC_SCALAR:
2182 case D3DXPC_VECTOR:
2183 get_matrix(param, matrix);
2184 return D3D_OK;
2185
2186 case D3DXPC_MATRIX_ROWS:
2187 get_matrix(param, &m);
2188 D3DXMatrixTranspose(matrix, &m);
2189 return D3D_OK;
2190
2191 case D3DXPC_OBJECT:
2192 case D3DXPC_STRUCT:
2193 break;
2194
2195 default:
2196 FIXME("Unhandled class %s\n", debug_d3dxparameter_class(param->class));
2197 break;
2198 }
2199 }
2200
2201 WARN("Invalid argument specified\n");
2202
2203 return D3DERR_INVALIDCALL;
2204 }
2205
2206 static HRESULT WINAPI ID3DXBaseEffectImpl_SetMatrixTransposeArray(ID3DXBaseEffect *iface, D3DXHANDLE parameter, CONST D3DXMATRIX *matrix, UINT count)
2207 {
2208 struct ID3DXBaseEffectImpl *This = impl_from_ID3DXBaseEffect(iface);
2209
2210 FIXME("iface %p, parameter %p, matrix %p, count %u stub\n", This, parameter, matrix, count);
2211
2212 return E_NOTIMPL;
2213 }
2214
2215 static HRESULT WINAPI ID3DXBaseEffectImpl_GetMatrixTransposeArray(ID3DXBaseEffect *iface, D3DXHANDLE parameter, D3DXMATRIX *matrix, UINT count)
2216 {
2217 struct ID3DXBaseEffectImpl *This = impl_from_ID3DXBaseEffect(iface);
2218 struct d3dx_parameter *param = get_valid_parameter(This, parameter);
2219
2220 TRACE("iface %p, parameter %p, matrix %p, count %u\n", This, parameter, matrix, count);
2221
2222 if (!count) return D3D_OK;
2223
2224 if (matrix && param && count <= param->element_count)
2225 {
2226 UINT i;
2227
2228 TRACE("Class %s\n", debug_d3dxparameter_class(param->class));
2229
2230 switch (param->class)
2231 {
2232 case D3DXPC_MATRIX_ROWS:
2233 for (i = 0; i < count; ++i)
2234 {
2235 D3DXMATRIX m;
2236
2237 get_matrix(get_parameter_struct(param->member_handles[i]), &m);
2238 D3DXMatrixTranspose(&matrix[i], &m);
2239 }
2240 return D3D_OK;
2241
2242 case D3DXPC_SCALAR:
2243 case D3DXPC_VECTOR:
2244 case D3DXPC_OBJECT:
2245 case D3DXPC_STRUCT:
2246 break;
2247
2248 default:
2249 FIXME("Unhandled class %s\n", debug_d3dxparameter_class(param->class));
2250 break;
2251 }
2252 }
2253
2254 WARN("Invalid argument specified\n");
2255
2256 return D3DERR_INVALIDCALL;
2257 }
2258
2259 static HRESULT WINAPI ID3DXBaseEffectImpl_SetMatrixTransposePointerArray(ID3DXBaseEffect *iface, D3DXHANDLE parameter, CONST D3DXMATRIX **matrix, UINT count)
2260 {
2261 struct ID3DXBaseEffectImpl *This = impl_from_ID3DXBaseEffect(iface);
2262
2263 FIXME("iface %p, parameter %p, matrix %p, count %u stub\n", This, parameter, matrix, count);
2264
2265 return E_NOTIMPL;
2266 }
2267
2268 static HRESULT WINAPI ID3DXBaseEffectImpl_GetMatrixTransposePointerArray(ID3DXBaseEffect *iface, D3DXHANDLE parameter, D3DXMATRIX **matrix, UINT count)
2269 {
2270 struct ID3DXBaseEffectImpl *This = impl_from_ID3DXBaseEffect(iface);
2271
2272 FIXME("iface %p, parameter %p, matrix %p, count %u stub\n", This, parameter, matrix, count);
2273
2274 return E_NOTIMPL;
2275 }
2276
2277 static HRESULT WINAPI ID3DXBaseEffectImpl_SetString(ID3DXBaseEffect *iface, D3DXHANDLE parameter, LPCSTR string)
2278 {
2279 struct ID3DXBaseEffectImpl *This = impl_from_ID3DXBaseEffect(iface);
2280
2281 FIXME("iface %p, parameter %p, string %p stub\n", This, parameter, string);
2282
2283 return E_NOTIMPL;
2284 }
2285
2286 static HRESULT WINAPI ID3DXBaseEffectImpl_GetString(ID3DXBaseEffect *iface, D3DXHANDLE parameter, LPCSTR *string)
2287 {
2288 struct ID3DXBaseEffectImpl *This = impl_from_ID3DXBaseEffect(iface);
2289 struct d3dx_parameter *param = get_valid_parameter(This, parameter);
2290
2291 TRACE("iface %p, parameter %p, string %p\n", This, parameter, string);
2292
2293 if (string && param && !param->element_count && param->type == D3DXPT_STRING)
2294 {
2295 *string = *(LPCSTR *)param->data;
2296 TRACE("Returning %s\n", debugstr_a(*string));
2297 return D3D_OK;
2298 }
2299
2300 WARN("Invalid argument specified\n");
2301
2302 return D3DERR_INVALIDCALL;
2303 }
2304
2305 static HRESULT WINAPI ID3DXBaseEffectImpl_SetTexture(ID3DXBaseEffect *iface, D3DXHANDLE parameter, LPDIRECT3DBASETEXTURE9 texture)
2306 {
2307 struct ID3DXBaseEffectImpl *This = impl_from_ID3DXBaseEffect(iface);
2308 struct d3dx_parameter *param = get_valid_parameter(This, parameter);
2309
2310 TRACE("iface %p, parameter %p, texture %p\n", This, parameter, texture);
2311
2312 if (param && !param->element_count &&
2313 (param->type == D3DXPT_TEXTURE || param->type == D3DXPT_TEXTURE1D
2314 || param->type == D3DXPT_TEXTURE2D || param->type == D3DXPT_TEXTURE3D
2315 || param->type == D3DXPT_TEXTURECUBE))
2316 {
2317 LPDIRECT3DBASETEXTURE9 oltexture = *(LPDIRECT3DBASETEXTURE9 *)param->data;
2318
2319 if (texture) IDirect3DBaseTexture9_AddRef(texture);
2320 if (oltexture) IDirect3DBaseTexture9_Release(oltexture);
2321
2322 *(LPDIRECT3DBASETEXTURE9 *)param->data = texture;
2323
2324 return D3D_OK;
2325 }
2326
2327 WARN("Invalid argument specified\n");
2328
2329 return D3DERR_INVALIDCALL;
2330 }
2331
2332 static HRESULT WINAPI ID3DXBaseEffectImpl_GetTexture(ID3DXBaseEffect *iface, D3DXHANDLE parameter, LPDIRECT3DBASETEXTURE9 *texture)
2333 {
2334 struct ID3DXBaseEffectImpl *This = impl_from_ID3DXBaseEffect(iface);
2335 struct d3dx_parameter *param = get_valid_parameter(This, parameter);
2336
2337 TRACE("iface %p, parameter %p, texture %p\n", This, parameter, texture);
2338
2339 if (texture && param && !param->element_count &&
2340 (param->type == D3DXPT_TEXTURE || param->type == D3DXPT_TEXTURE1D
2341 || param->type == D3DXPT_TEXTURE2D || param->type == D3DXPT_TEXTURE3D
2342 || param->type == D3DXPT_TEXTURECUBE))
2343 {
2344 *texture = *(LPDIRECT3DBASETEXTURE9 *)param->data;
2345 if (*texture) IDirect3DBaseTexture9_AddRef(*texture);
2346 TRACE("Returning %p\n", *texture);
2347 return D3D_OK;
2348 }
2349
2350 WARN("Invalid argument specified\n");
2351
2352 return D3DERR_INVALIDCALL;
2353 }
2354
2355 static HRESULT WINAPI ID3DXBaseEffectImpl_GetPixelShader(ID3DXBaseEffect *iface, D3DXHANDLE parameter, LPDIRECT3DPIXELSHADER9 *pshader)
2356 {
2357 struct ID3DXBaseEffectImpl *This = impl_from_ID3DXBaseEffect(iface);
2358 struct d3dx_parameter *param = get_valid_parameter(This, parameter);
2359
2360 TRACE("iface %p, parameter %p, pshader %p\n", This, parameter, pshader);
2361
2362 if (pshader && param && !param->element_count && param->type == D3DXPT_PIXELSHADER)
2363 {
2364 *pshader = *(LPDIRECT3DPIXELSHADER9 *)param->data;
2365 if (*pshader) IDirect3DPixelShader9_AddRef(*pshader);
2366 TRACE("Returning %p\n", *pshader);
2367 return D3D_OK;
2368 }
2369
2370 WARN("Invalid argument specified\n");
2371
2372 return D3DERR_INVALIDCALL;
2373 }
2374
2375 static HRESULT WINAPI ID3DXBaseEffectImpl_GetVertexShader(ID3DXBaseEffect *iface, D3DXHANDLE parameter, LPDIRECT3DVERTEXSHADER9 *vshader)
2376 {
2377 struct ID3DXBaseEffectImpl *This = impl_from_ID3DXBaseEffect(iface);
2378 struct d3dx_parameter *param = get_valid_parameter(This, parameter);
2379
2380 TRACE("iface %p, parameter %p, vshader %p\n", This, parameter, vshader);
2381
2382 if (vshader && param && !param->element_count && param->type == D3DXPT_VERTEXSHADER)
2383 {
2384 *vshader = *(LPDIRECT3DVERTEXSHADER9 *)param->data;
2385 if (*vshader) IDirect3DVertexShader9_AddRef(*vshader);
2386 TRACE("Returning %p\n", *vshader);
2387 return D3D_OK;
2388 }
2389
2390 WARN("Invalid argument specified\n");
2391
2392 return D3DERR_INVALIDCALL;
2393 }
2394
2395 static HRESULT WINAPI ID3DXBaseEffectImpl_SetArrayRange(ID3DXBaseEffect *iface, D3DXHANDLE parameter, UINT start, UINT end)
2396 {
2397 struct ID3DXBaseEffectImpl *This = impl_from_ID3DXBaseEffect(iface);
2398
2399 FIXME("iface %p, parameter %p, start %u, end %u stub\n", This, parameter, start, end);
2400
2401 return E_NOTIMPL;
2402 }
2403
2404 static const struct ID3DXBaseEffectVtbl ID3DXBaseEffect_Vtbl =
2405 {
2406 /*** IUnknown methods ***/
2407 ID3DXBaseEffectImpl_QueryInterface,
2408 ID3DXBaseEffectImpl_AddRef,
2409 ID3DXBaseEffectImpl_Release,
2410 /*** ID3DXBaseEffect methods ***/
2411 ID3DXBaseEffectImpl_GetDesc,
2412 ID3DXBaseEffectImpl_GetParameterDesc,
2413 ID3DXBaseEffectImpl_GetTechniqueDesc,
2414 ID3DXBaseEffectImpl_GetPassDesc,
2415 ID3DXBaseEffectImpl_GetFunctionDesc,
2416 ID3DXBaseEffectImpl_GetParameter,
2417 ID3DXBaseEffectImpl_GetParameterByName,
2418 ID3DXBaseEffectImpl_GetParameterBySemantic,
2419 ID3DXBaseEffectImpl_GetParameterElement,
2420 ID3DXBaseEffectImpl_GetTechnique,
2421 ID3DXBaseEffectImpl_GetTechniqueByName,
2422 ID3DXBaseEffectImpl_GetPass,
2423 ID3DXBaseEffectImpl_GetPassByName,
2424 ID3DXBaseEffectImpl_GetFunction,
2425 ID3DXBaseEffectImpl_GetFunctionByName,
2426 ID3DXBaseEffectImpl_GetAnnotation,
2427 ID3DXBaseEffectImpl_GetAnnotationByName,
2428 ID3DXBaseEffectImpl_SetValue,
2429 ID3DXBaseEffectImpl_GetValue,
2430 ID3DXBaseEffectImpl_SetBool,
2431 ID3DXBaseEffectImpl_GetBool,
2432 ID3DXBaseEffectImpl_SetBoolArray,
2433 ID3DXBaseEffectImpl_GetBoolArray,
2434 ID3DXBaseEffectImpl_SetInt,
2435 ID3DXBaseEffectImpl_GetInt,
2436 ID3DXBaseEffectImpl_SetIntArray,
2437 ID3DXBaseEffectImpl_GetIntArray,
2438 ID3DXBaseEffectImpl_SetFloat,
2439 ID3DXBaseEffectImpl_GetFloat,
2440 ID3DXBaseEffectImpl_SetFloatArray,
2441 ID3DXBaseEffectImpl_GetFloatArray,
2442 ID3DXBaseEffectImpl_SetVector,
2443 ID3DXBaseEffectImpl_GetVector,
2444 ID3DXBaseEffectImpl_SetVectorArray,
2445 ID3DXBaseEffectImpl_GetVectorArray,
2446 ID3DXBaseEffectImpl_SetMatrix,
2447 ID3DXBaseEffectImpl_GetMatrix,
2448 ID3DXBaseEffectImpl_SetMatrixArray,
2449 ID3DXBaseEffectImpl_GetMatrixArray,
2450 ID3DXBaseEffectImpl_SetMatrixPointerArray,
2451 ID3DXBaseEffectImpl_GetMatrixPointerArray,
2452 ID3DXBaseEffectImpl_SetMatrixTranspose,
2453 ID3DXBaseEffectImpl_GetMatrixTranspose,
2454 ID3DXBaseEffectImpl_SetMatrixTransposeArray,
2455 ID3DXBaseEffectImpl_GetMatrixTransposeArray,
2456 ID3DXBaseEffectImpl_SetMatrixTransposePointerArray,
2457 ID3DXBaseEffectImpl_GetMatrixTransposePointerArray,
2458 ID3DXBaseEffectImpl_SetString,
2459 ID3DXBaseEffectImpl_GetString,
2460 ID3DXBaseEffectImpl_SetTexture,
2461 ID3DXBaseEffectImpl_GetTexture,
2462 ID3DXBaseEffectImpl_GetPixelShader,
2463 ID3DXBaseEffectImpl_GetVertexShader,
2464 ID3DXBaseEffectImpl_SetArrayRange,
2465 };
2466
2467 static inline struct ID3DXEffectImpl *impl_from_ID3DXEffect(ID3DXEffect *iface)
2468 {
2469 return CONTAINING_RECORD(iface, struct ID3DXEffectImpl, ID3DXEffect_iface);
2470 }
2471
2472 /*** IUnknown methods ***/
2473 static HRESULT WINAPI ID3DXEffectImpl_QueryInterface(ID3DXEffect *iface, REFIID riid, void **object)
2474 {
2475 struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
2476
2477 TRACE("(%p)->(%s, %p)\n", This, debugstr_guid(riid), object);
2478
2479 if (IsEqualGUID(riid, &IID_IUnknown) ||
2480 IsEqualGUID(riid, &IID_ID3DXEffect))
2481 {
2482 This->ID3DXEffect_iface.lpVtbl->AddRef(iface);
2483 *object = This;
2484 return S_OK;
2485 }
2486
2487 ERR("Interface %s not found\n", debugstr_guid(riid));
2488
2489 return E_NOINTERFACE;
2490 }
2491
2492 static ULONG WINAPI ID3DXEffectImpl_AddRef(ID3DXEffect *iface)
2493 {
2494 struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
2495
2496 TRACE("(%p)->(): AddRef from %u\n", This, This->ref);
2497
2498 return InterlockedIncrement(&This->ref);
2499 }
2500
2501 static ULONG WINAPI ID3DXEffectImpl_Release(ID3DXEffect *iface)
2502 {
2503 struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
2504 ULONG ref = InterlockedDecrement(&This->ref);
2505
2506 TRACE("(%p)->(): Release from %u\n", This, ref + 1);
2507
2508 if (!ref)
2509 {
2510 free_effect(This);
2511 HeapFree(GetProcessHeap(), 0, This);
2512 }
2513
2514 return ref;
2515 }
2516
2517 /*** ID3DXBaseEffect methods ***/
2518 static HRESULT WINAPI ID3DXEffectImpl_GetDesc(ID3DXEffect *iface, D3DXEFFECT_DESC *desc)
2519 {
2520 struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
2521 ID3DXBaseEffect *base = This->base_effect;
2522
2523 TRACE("Forward iface %p, base %p\n", This, base);
2524
2525 return ID3DXBaseEffectImpl_GetDesc(base, desc);
2526 }
2527
2528 static HRESULT WINAPI ID3DXEffectImpl_GetParameterDesc(ID3DXEffect *iface, D3DXHANDLE parameter, D3DXPARAMETER_DESC *desc)
2529 {
2530 struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
2531 ID3DXBaseEffect *base = This->base_effect;
2532
2533 TRACE("Forward iface %p, base %p\n", This, base);
2534
2535 return ID3DXBaseEffectImpl_GetParameterDesc(base, parameter, desc);
2536 }
2537
2538 static HRESULT WINAPI ID3DXEffectImpl_GetTechniqueDesc(ID3DXEffect *iface, D3DXHANDLE technique, D3DXTECHNIQUE_DESC *desc)
2539 {
2540 struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
2541 ID3DXBaseEffect *base = This->base_effect;
2542
2543 TRACE("Forward iface %p, base %p\n", This, base);
2544
2545 return ID3DXBaseEffectImpl_GetTechniqueDesc(base, technique, desc);
2546 }
2547
2548 static HRESULT WINAPI ID3DXEffectImpl_GetPassDesc(ID3DXEffect *iface, D3DXHANDLE pass, D3DXPASS_DESC *desc)
2549 {
2550 struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
2551 ID3DXBaseEffect *base = This->base_effect;
2552
2553 TRACE("Forward iface %p, base %p\n", This, base);
2554
2555 return ID3DXBaseEffectImpl_GetPassDesc(base, pass, desc);
2556 }
2557
2558 static HRESULT WINAPI ID3DXEffectImpl_GetFunctionDesc(ID3DXEffect *iface, D3DXHANDLE shader, D3DXFUNCTION_DESC *desc)
2559 {
2560 struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
2561 ID3DXBaseEffect *base = This->base_effect;
2562
2563 TRACE("Forward iface %p, base %p\n", This, base);
2564
2565 return ID3DXBaseEffectImpl_GetFunctionDesc(base, shader, desc);
2566 }
2567
2568 static D3DXHANDLE WINAPI ID3DXEffectImpl_GetParameter(ID3DXEffect *iface, D3DXHANDLE parameter, UINT index)
2569 {
2570 struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
2571 ID3DXBaseEffect *base = This->base_effect;
2572
2573 TRACE("Forward iface %p, base %p\n", This, base);
2574
2575 return ID3DXBaseEffectImpl_GetParameter(base, parameter, index);
2576 }
2577
2578 static D3DXHANDLE WINAPI ID3DXEffectImpl_GetParameterByName(ID3DXEffect *iface, D3DXHANDLE parameter, LPCSTR name)
2579 {
2580 struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
2581 ID3DXBaseEffect *base = This->base_effect;
2582
2583 TRACE("Forward iface %p, base %p\n", This, base);
2584
2585 return ID3DXBaseEffectImpl_GetParameterByName(base, parameter, name);
2586 }
2587
2588 static D3DXHANDLE WINAPI ID3DXEffectImpl_GetParameterBySemantic(ID3DXEffect *iface, D3DXHANDLE parameter, LPCSTR semantic)
2589 {
2590 struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
2591 ID3DXBaseEffect *base = This->base_effect;
2592
2593 TRACE("Forward iface %p, base %p\n", This, base);
2594
2595 return ID3DXBaseEffectImpl_GetParameterBySemantic(base, parameter, semantic);
2596 }
2597
2598 static D3DXHANDLE WINAPI ID3DXEffectImpl_GetParameterElement(ID3DXEffect *iface, D3DXHANDLE parameter, UINT index)
2599 {
2600 struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
2601 ID3DXBaseEffect *base = This->base_effect;
2602
2603 TRACE("Forward iface %p, base %p\n", This, base);
2604
2605 return ID3DXBaseEffectImpl_GetParameterElement(base, parameter, index);
2606 }
2607
2608 static D3DXHANDLE WINAPI ID3DXEffectImpl_GetTechnique(ID3DXEffect *iface, UINT index)
2609 {
2610 struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
2611 ID3DXBaseEffect *base = This->base_effect;
2612
2613 TRACE("Forward iface %p, base %p\n", This, base);
2614
2615 return ID3DXBaseEffectImpl_GetTechnique(base, index);
2616 }
2617
2618 static D3DXHANDLE WINAPI ID3DXEffectImpl_GetTechniqueByName(ID3DXEffect *iface, LPCSTR name)
2619 {
2620 struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
2621 ID3DXBaseEffect *base = This->base_effect;
2622
2623 TRACE("Forward iface %p, base %p\n", This, base);
2624
2625 return ID3DXBaseEffectImpl_GetTechniqueByName(base, name);
2626 }
2627
2628 static D3DXHANDLE WINAPI ID3DXEffectImpl_GetPass(ID3DXEffect *iface, D3DXHANDLE technique, UINT index)
2629 {
2630 struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
2631 ID3DXBaseEffect *base = This->base_effect;
2632
2633 TRACE("Forward iface %p, base %p\n", This, base);
2634
2635 return ID3DXBaseEffectImpl_GetPass(base, technique, index);
2636 }
2637
2638 static D3DXHANDLE WINAPI ID3DXEffectImpl_GetPassByName(ID3DXEffect *iface, D3DXHANDLE technique, LPCSTR name)
2639 {
2640 struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
2641 ID3DXBaseEffect *base = This->base_effect;
2642
2643 TRACE("Forward iface %p, base %p\n", This, base);
2644
2645 return ID3DXBaseEffectImpl_GetPassByName(base, technique, name);
2646 }
2647
2648 static D3DXHANDLE WINAPI ID3DXEffectImpl_GetFunction(ID3DXEffect *iface, UINT index)
2649 {
2650 struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
2651 ID3DXBaseEffect *base = This->base_effect;
2652
2653 TRACE("Forward iface %p, base %p\n", This, base);
2654
2655 return ID3DXBaseEffectImpl_GetFunction(base, index);
2656 }
2657
2658 static D3DXHANDLE WINAPI ID3DXEffectImpl_GetFunctionByName(ID3DXEffect *iface, LPCSTR name)
2659 {
2660 struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
2661 ID3DXBaseEffect *base = This->base_effect;
2662
2663 TRACE("Forward iface %p, base %p\n", This, base);
2664
2665 return ID3DXBaseEffectImpl_GetFunctionByName(base, name);
2666 }
2667
2668 static D3DXHANDLE WINAPI ID3DXEffectImpl_GetAnnotation(ID3DXEffect *iface, D3DXHANDLE object, UINT index)
2669 {
2670 struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
2671 ID3DXBaseEffect *base = This->base_effect;
2672
2673 TRACE("Forward iface %p, base %p\n", This, base);
2674
2675 return ID3DXBaseEffectImpl_GetAnnotation(base, object, index);
2676 }
2677
2678 static D3DXHANDLE WINAPI ID3DXEffectImpl_GetAnnotationByName(ID3DXEffect *iface, D3DXHANDLE object, LPCSTR name)
2679 {
2680 struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
2681 ID3DXBaseEffect *base = This->base_effect;
2682
2683 TRACE("Forward iface %p, base %p\n", This, base);
2684
2685 return ID3DXBaseEffectImpl_GetAnnotationByName(base, object, name);
2686 }
2687
2688 static HRESULT WINAPI ID3DXEffectImpl_SetValue(ID3DXEffect *iface, D3DXHANDLE parameter, LPCVOID data, UINT bytes)
2689 {
2690 struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
2691 ID3DXBaseEffect *base = This->base_effect;
2692
2693 TRACE("Forward iface %p, base %p\n", This, base);
2694
2695 return ID3DXBaseEffectImpl_SetValue(base, parameter, data, bytes);
2696 }
2697
2698 static HRESULT WINAPI ID3DXEffectImpl_GetValue(ID3DXEffect *iface, D3DXHANDLE parameter, LPVOID data, UINT bytes)
2699 {
2700 struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
2701 ID3DXBaseEffect *base = This->base_effect;
2702
2703 TRACE("Forward iface %p, base %p\n", This, base);
2704
2705 return ID3DXBaseEffectImpl_GetValue(base, parameter, data, bytes);
2706 }
2707
2708 static HRESULT WINAPI ID3DXEffectImpl_SetBool(ID3DXEffect *iface, D3DXHANDLE parameter, BOOL b)
2709 {
2710 struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
2711 ID3DXBaseEffect *base = This->base_effect;
2712
2713 TRACE("Forward iface %p, base %p\n", This, base);
2714
2715 return ID3DXBaseEffectImpl_SetBool(base, parameter, b);
2716 }
2717
2718 static HRESULT WINAPI ID3DXEffectImpl_GetBool(ID3DXEffect *iface, D3DXHANDLE parameter, BOOL *b)
2719 {
2720 struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
2721 ID3DXBaseEffect *base = This->base_effect;
2722
2723 TRACE("Forward iface %p, base %p\n", This, base);
2724
2725 return ID3DXBaseEffectImpl_GetBool(base, parameter, b);
2726 }
2727
2728 static HRESULT WINAPI ID3DXEffectImpl_SetBoolArray(ID3DXEffect *iface, D3DXHANDLE parameter, CONST BOOL *b, UINT count)
2729 {
2730 struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
2731 ID3DXBaseEffect *base = This->base_effect;
2732
2733 TRACE("Forward iface %p, base %p\n", This, base);
2734
2735 return ID3DXBaseEffectImpl_SetBoolArray(base, parameter, b, count);
2736 }
2737
2738 static HRESULT WINAPI ID3DXEffectImpl_GetBoolArray(ID3DXEffect *iface, D3DXHANDLE parameter, BOOL *b, UINT count)
2739 {
2740 struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
2741 ID3DXBaseEffect *base = This->base_effect;
2742
2743 TRACE("Forward iface %p, base %p\n", This, base);
2744
2745 return ID3DXBaseEffectImpl_GetBoolArray(base, parameter, b, count);
2746 }
2747
2748 static HRESULT WINAPI ID3DXEffectImpl_SetInt(ID3DXEffect *iface, D3DXHANDLE parameter, INT n)
2749 {
2750 struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
2751 ID3DXBaseEffect *base = This->base_effect;
2752
2753 TRACE("Forward iface %p, base %p\n", This, base);
2754
2755 return ID3DXBaseEffectImpl_SetInt(base, parameter, n);
2756 }
2757
2758 static HRESULT WINAPI ID3DXEffectImpl_GetInt(ID3DXEffect *iface, D3DXHANDLE parameter, INT *n)
2759 {
2760 struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
2761 ID3DXBaseEffect *base = This->base_effect;
2762
2763 TRACE("Forward iface %p, base %p\n", This, base);
2764
2765 return ID3DXBaseEffectImpl_GetInt(base, parameter, n);
2766 }
2767
2768 static HRESULT WINAPI ID3DXEffectImpl_SetIntArray(ID3DXEffect *iface, D3DXHANDLE parameter, CONST INT *n, UINT count)
2769 {
2770 struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
2771 ID3DXBaseEffect *base = This->base_effect;
2772
2773 TRACE("Forward iface %p, base %p\n", This, base);
2774
2775 return ID3DXBaseEffectImpl_SetIntArray(base, parameter, n, count);
2776 }
2777
2778 static HRESULT WINAPI ID3DXEffectImpl_GetIntArray(ID3DXEffect *iface, D3DXHANDLE parameter, INT *n, UINT count)
2779 {
2780 struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
2781 ID3DXBaseEffect *base = This->base_effect;
2782
2783 TRACE("Forward iface %p, base %p\n", This, base);
2784
2785 return ID3DXBaseEffectImpl_GetIntArray(base, parameter, n, count);
2786 }
2787
2788 static HRESULT WINAPI ID3DXEffectImpl_SetFloat(ID3DXEffect *iface, D3DXHANDLE parameter, FLOAT f)
2789 {
2790 struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
2791 ID3DXBaseEffect *base = This->base_effect;
2792
2793 TRACE("Forward iface %p, base %p\n", This, base);
2794
2795 return ID3DXBaseEffectImpl_SetFloat(base, parameter, f);
2796 }
2797
2798 static HRESULT WINAPI ID3DXEffectImpl_GetFloat(ID3DXEffect *iface, D3DXHANDLE parameter, FLOAT *f)
2799 {
2800 struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
2801 ID3DXBaseEffect *base = This->base_effect;
2802
2803 TRACE("Forward iface %p, base %p\n", This, base);
2804
2805 return ID3DXBaseEffectImpl_GetFloat(base, parameter, f);
2806 }
2807
2808 static HRESULT WINAPI ID3DXEffectImpl_SetFloatArray(ID3DXEffect *iface, D3DXHANDLE parameter, CONST FLOAT *f, UINT count)
2809 {
2810 struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
2811 ID3DXBaseEffect *base = This->base_effect;
2812
2813 TRACE("Forward iface %p, base %p\n", This, base);
2814
2815 return ID3DXBaseEffectImpl_SetFloatArray(base, parameter, f, count);
2816 }
2817
2818 static HRESULT WINAPI ID3DXEffectImpl_GetFloatArray(ID3DXEffect *iface, D3DXHANDLE parameter, FLOAT *f, UINT count)
2819 {
2820 struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
2821 ID3DXBaseEffect *base = This->base_effect;
2822
2823 TRACE("Forward iface %p, base %p\n", This, base);
2824
2825 return ID3DXBaseEffectImpl_GetFloatArray(base, parameter, f, count);
2826 }
2827
2828 static HRESULT WINAPI ID3DXEffectImpl_SetVector(ID3DXEffect *iface, D3DXHANDLE parameter, CONST D3DXVECTOR4 *vector)
2829 {
2830 struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
2831 ID3DXBaseEffect *base = This->base_effect;
2832
2833 TRACE("Forward iface %p, base %p\n", This, base);
2834
2835 return ID3DXBaseEffectImpl_SetVector(base, parameter, vector);
2836 }
2837
2838 static HRESULT WINAPI ID3DXEffectImpl_GetVector(ID3DXEffect *iface, D3DXHANDLE parameter, D3DXVECTOR4 *vector)
2839 {
2840 struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
2841 ID3DXBaseEffect *base = This->base_effect;
2842
2843 TRACE("Forward iface %p, base %p\n", This, base);
2844
2845 return ID3DXBaseEffectImpl_GetVector(base, parameter, vector);
2846 }
2847
2848 static HRESULT WINAPI ID3DXEffectImpl_SetVectorArray(ID3DXEffect *iface, D3DXHANDLE parameter, CONST D3DXVECTOR4 *vector, UINT count)
2849 {
2850 struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
2851 ID3DXBaseEffect *base = This->base_effect;
2852
2853 TRACE("Forward iface %p, base %p\n", This, base);
2854
2855 return ID3DXBaseEffectImpl_SetVectorArray(base, parameter, vector, count);
2856 }
2857
2858 static HRESULT WINAPI ID3DXEffectImpl_GetVectorArray(ID3DXEffect *iface, D3DXHANDLE parameter, D3DXVECTOR4 *vector, UINT count)
2859 {
2860 struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
2861 ID3DXBaseEffect *base = This->base_effect;
2862
2863 TRACE("Forward iface %p, base %p\n", This, base);
2864
2865 return ID3DXBaseEffectImpl_GetVectorArray(base, parameter, vector, count);
2866 }
2867
2868 static HRESULT WINAPI ID3DXEffectImpl_SetMatrix(ID3DXEffect *iface, D3DXHANDLE parameter, CONST D3DXMATRIX *matrix)
2869 {
2870 struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
2871 ID3DXBaseEffect *base = This->base_effect;
2872
2873 TRACE("Forward iface %p, base %p\n", This, base);
2874
2875 return ID3DXBaseEffectImpl_SetMatrix(base, parameter, matrix);
2876 }
2877
2878 static HRESULT WINAPI ID3DXEffectImpl_GetMatrix(ID3DXEffect *iface, D3DXHANDLE parameter, D3DXMATRIX *matrix)
2879 {
2880 struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
2881 ID3DXBaseEffect *base = This->base_effect;
2882
2883 TRACE("Forward iface %p, base %p\n", This, base);
2884
2885 return ID3DXBaseEffectImpl_GetMatrix(base, parameter, matrix);
2886 }
2887
2888 static HRESULT WINAPI ID3DXEffectImpl_SetMatrixArray(ID3DXEffect *iface, D3DXHANDLE parameter, CONST D3DXMATRIX *matrix, UINT count)
2889 {
2890 struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
2891 ID3DXBaseEffect *base = This->base_effect;
2892
2893 TRACE("Forward iface %p, base %p\n", This, base);
2894
2895 return ID3DXBaseEffectImpl_SetMatrixArray(base, parameter, matrix, count);
2896 }
2897
2898 static HRESULT WINAPI ID3DXEffectImpl_GetMatrixArray(ID3DXEffect *iface, D3DXHANDLE parameter, D3DXMATRIX *matrix, UINT count)
2899 {
2900 struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
2901 ID3DXBaseEffect *base = This->base_effect;
2902
2903 TRACE("Forward iface %p, base %p\n", This, base);
2904
2905 return ID3DXBaseEffectImpl_GetMatrixArray(base, parameter, matrix, count);
2906 }
2907
2908 static HRESULT WINAPI ID3DXEffectImpl_SetMatrixPointerArray(ID3DXEffect *iface, D3DXHANDLE parameter, CONST D3DXMATRIX **matrix, UINT count)
2909 {
2910 struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
2911 ID3DXBaseEffect *base = This->base_effect;
2912
2913 TRACE("Forward iface %p, base %p\n", This, base);
2914
2915 return ID3DXBaseEffectImpl_SetMatrixPointerArray(base, parameter, matrix, count);
2916 }
2917
2918 static HRESULT WINAPI ID3DXEffectImpl_GetMatrixPointerArray(ID3DXEffect *iface, D3DXHANDLE parameter, D3DXMATRIX **matrix, UINT count)
2919 {
2920 struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
2921 ID3DXBaseEffect *base = This->base_effect;
2922
2923 TRACE("Forward iface %p, base %p\n", This, base);
2924
2925 return ID3DXBaseEffectImpl_GetMatrixPointerArray(base, parameter, matrix, count);
2926 }
2927
2928 static HRESULT WINAPI ID3DXEffectImpl_SetMatrixTranspose(ID3DXEffect *iface, D3DXHANDLE parameter, CONST D3DXMATRIX *matrix)
2929 {
2930 struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
2931 ID3DXBaseEffect *base = This->base_effect;
2932
2933 TRACE("Forward iface %p, base %p\n", This, base);
2934
2935 return ID3DXBaseEffectImpl_SetMatrixTranspose(base, parameter, matrix);
2936 }
2937
2938 static HRESULT WINAPI ID3DXEffectImpl_GetMatrixTranspose(ID3DXEffect *iface, D3DXHANDLE parameter, D3DXMATRIX *matrix)
2939 {
2940 struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
2941 ID3DXBaseEffect *base = This->base_effect;
2942
2943 TRACE("Forward iface %p, base %p\n", This, base);
2944
2945 return ID3DXBaseEffectImpl_GetMatrixTranspose(base, parameter, matrix);
2946 }
2947
2948 static HRESULT WINAPI ID3DXEffectImpl_SetMatrixTransposeArray(ID3DXEffect *iface, D3DXHANDLE parameter, CONST D3DXMATRIX *matrix, UINT count)
2949 {
2950 struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
2951 ID3DXBaseEffect *base = This->base_effect;
2952
2953 TRACE("Forward iface %p, base %p\n", This, base);
2954
2955 return ID3DXBaseEffectImpl_SetMatrixTransposeArray(base, parameter, matrix, count);
2956 }
2957
2958 static HRESULT WINAPI ID3DXEffectImpl_GetMatrixTransposeArray(ID3DXEffect *iface, D3DXHANDLE parameter, D3DXMATRIX *matrix, UINT count)
2959 {
2960 struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
2961 ID3DXBaseEffect *base = This->base_effect;
2962
2963 TRACE("Forward iface %p, base %p\n", This, base);
2964
2965 return ID3DXBaseEffectImpl_GetMatrixTransposeArray(base, parameter, matrix, count);
2966 }
2967
2968 static HRESULT WINAPI ID3DXEffectImpl_SetMatrixTransposePointerArray(ID3DXEffect *iface, D3DXHANDLE parameter, CONST D3DXMATRIX **matrix, UINT count)
2969 {
2970 struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
2971 ID3DXBaseEffect *base = This->base_effect;
2972
2973 TRACE("Forward iface %p, base %p\n", This, base);
2974
2975 return ID3DXBaseEffectImpl_SetMatrixTransposePointerArray(base, parameter, matrix, count);
2976 }
2977
2978 static HRESULT WINAPI ID3DXEffectImpl_GetMatrixTransposePointerArray(ID3DXEffect *iface, D3DXHANDLE parameter, D3DXMATRIX **matrix, UINT count)
2979 {
2980 struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
2981 ID3DXBaseEffect *base = This->base_effect;
2982
2983 TRACE("Forward iface %p, base %p\n", This, base);
2984
2985 return ID3DXBaseEffectImpl_GetMatrixTransposePointerArray(base, parameter, matrix, count);
2986 }
2987
2988 static HRESULT WINAPI ID3DXEffectImpl_SetString(ID3DXEffect *iface, D3DXHANDLE parameter, LPCSTR string)
2989 {
2990 struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
2991 ID3DXBaseEffect *base = This->base_effect;
2992
2993 TRACE("Forward iface %p, base %p\n", This, base);
2994
2995 return ID3DXBaseEffectImpl_SetString(base, parameter, string);
2996 }
2997
2998 static HRESULT WINAPI ID3DXEffectImpl_GetString(ID3DXEffect *iface, D3DXHANDLE parameter, LPCSTR *string)
2999 {
3000 struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
3001 ID3DXBaseEffect *base = This->base_effect;
3002
3003 TRACE("Forward iface %p, base %p\n", This, base);
3004
3005 return ID3DXBaseEffectImpl_GetString(base, parameter, string);
3006 }
3007
3008 static HRESULT WINAPI ID3DXEffectImpl_SetTexture(ID3DXEffect *iface, D3DXHANDLE parameter, LPDIRECT3DBASETEXTURE9 texture)
3009 {
3010 struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
3011 ID3DXBaseEffect *base = This->base_effect;
3012
3013 TRACE("Forward iface %p, base %p\n", This, base);
3014
3015 return ID3DXBaseEffectImpl_SetTexture(base, parameter, texture);
3016 }
3017
3018 static HRESULT WINAPI ID3DXEffectImpl_GetTexture(ID3DXEffect *iface, D3DXHANDLE parameter, LPDIRECT3DBASETEXTURE9 *texture)
3019 {
3020 struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
3021 ID3DXBaseEffect *base = This->base_effect;
3022
3023 TRACE("Forward iface %p, base %p\n", This, base);
3024
3025 return ID3DXBaseEffectImpl_GetTexture(base, parameter, texture);
3026 }
3027
3028 static HRESULT WINAPI ID3DXEffectImpl_GetPixelShader(ID3DXEffect *iface, D3DXHANDLE parameter, LPDIRECT3DPIXELSHADER9 *pshader)
3029 {
3030 struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
3031 ID3DXBaseEffect *base = This->base_effect;
3032
3033 TRACE("Forward iface %p, base %p\n", This, base);
3034
3035 return ID3DXBaseEffectImpl_GetPixelShader(base, parameter, pshader);
3036 }
3037
3038 static HRESULT WINAPI ID3DXEffectImpl_GetVertexShader(ID3DXEffect *iface, D3DXHANDLE parameter, LPDIRECT3DVERTEXSHADER9 *vshader)
3039 {
3040 struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
3041 ID3DXBaseEffect *base = This->base_effect;
3042
3043 TRACE("Forward iface %p, base %p\n", This, base);
3044
3045 return ID3DXBaseEffectImpl_GetVertexShader(base, parameter, vshader);
3046 }
3047
3048 static HRESULT WINAPI ID3DXEffectImpl_SetArrayRange(ID3DXEffect *iface, D3DXHANDLE parameter, UINT start, UINT end)
3049 {
3050 struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
3051 ID3DXBaseEffect *base = This->base_effect;
3052
3053 TRACE("Forward iface %p, base %p\n", This, base);
3054
3055 return ID3DXBaseEffectImpl_SetArrayRange(base, parameter, start, end);
3056 }
3057
3058 /*** ID3DXEffect methods ***/
3059 static HRESULT WINAPI ID3DXEffectImpl_GetPool(ID3DXEffect *iface, LPD3DXEFFECTPOOL *pool)
3060 {
3061 struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
3062
3063 TRACE("iface %p, pool %p\n", This, pool);
3064
3065 if (!pool)
3066 {
3067 WARN("Invalid argument supplied.\n");
3068 return D3DERR_INVALIDCALL;
3069 }
3070
3071 if (This->pool)
3072 {
3073 This->pool->lpVtbl->AddRef(This->pool);
3074 }
3075
3076 *pool = This->pool;
3077
3078 TRACE("Returning pool %p\n", *pool);
3079
3080 return S_OK;
3081 }
3082
3083 static HRESULT WINAPI ID3DXEffectImpl_SetTechnique(ID3DXEffect *iface, D3DXHANDLE technique)
3084 {
3085 struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
3086 struct ID3DXBaseEffectImpl *base = impl_from_ID3DXBaseEffect(This->base_effect);
3087 struct d3dx_technique *tech = is_valid_technique(base, technique);
3088
3089 TRACE("iface %p, technique %p\n", This, technique);
3090
3091 if (!tech) tech = get_technique_struct(iface->lpVtbl->GetTechniqueByName(iface, technique));
3092
3093 if (tech)
3094 {
3095 UINT i;
3096
3097 for (i = 0; i < base->technique_count; ++i)
3098 {
3099 struct d3dx_technique *t = get_technique_struct(base->technique_handles[i]);
3100
3101 if (tech == t)
3102 {
3103 This->active_technique = get_technique_handle(t);
3104 TRACE("Technique %u (%p)\n", i, tech);
3105 return D3D_OK;
3106 }
3107 }
3108 }
3109
3110 WARN("Invalid argument supplied.\n");
3111
3112 return D3DERR_INVALIDCALL;
3113 }
3114
3115 static D3DXHANDLE WINAPI ID3DXEffectImpl_GetCurrentTechnique(ID3DXEffect *iface)
3116 {
3117 struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
3118
3119 TRACE("iface %p\n", This);
3120
3121 return This->active_technique;
3122 }
3123
3124 static HRESULT WINAPI ID3DXEffectImpl_ValidateTechnique(ID3DXEffect* iface, D3DXHANDLE technique)
3125 {
3126 struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
3127
3128 FIXME("(%p)->(%p): stub\n", This, technique);
3129
3130 return D3D_OK;
3131 }
3132
3133 static HRESULT WINAPI ID3DXEffectImpl_FindNextValidTechnique(ID3DXEffect* iface, D3DXHANDLE technique, D3DXHANDLE* next_technique)
3134 {
3135 struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
3136
3137 FIXME("(%p)->(%p, %p): stub\n", This, technique, next_technique);
3138
3139 return E_NOTIMPL;
3140 }
3141
3142 static BOOL WINAPI ID3DXEffectImpl_IsParameterUsed(ID3DXEffect* iface, D3DXHANDLE parameter, D3DXHANDLE technique)
3143 {
3144 struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
3145
3146 FIXME("(%p)->(%p, %p): stub\n", This, parameter, technique);
3147
3148 return FALSE;
3149 }
3150
3151 static HRESULT WINAPI ID3DXEffectImpl_Begin(ID3DXEffect *iface, UINT *passes, DWORD flags)
3152 {
3153 struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
3154 struct d3dx_technique *technique = get_technique_struct(This->active_technique);
3155
3156 FIXME("iface %p, passes %p, flags %#x partial stub\n", This, passes, flags);
3157
3158 if (passes && technique)
3159 {
3160 if (This->manager || flags & D3DXFX_DONOTSAVESTATE)
3161 {
3162 TRACE("State capturing disabled.\n");
3163 }
3164 else
3165 {
3166 FIXME("State capturing not supported, yet!\n");
3167 }
3168
3169 *passes = technique->pass_count;
3170
3171 return D3D_OK;
3172 }
3173
3174 WARN("Invalid argument supplied.\n");
3175
3176 return D3DERR_INVALIDCALL;
3177 }
3178
3179 static HRESULT WINAPI ID3DXEffectImpl_BeginPass(ID3DXEffect *iface, UINT pass)
3180 {
3181 struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
3182 struct d3dx_technique *technique = get_technique_struct(This->active_technique);
3183
3184 TRACE("iface %p, pass %u\n", This, pass);
3185
3186 if (technique && pass < technique->pass_count && !This->active_pass)
3187 {
3188 This->active_pass = technique->pass_handles[pass];
3189
3190 FIXME("No states applied, yet!\n");
3191
3192 return D3D_OK;
3193 }
3194
3195 WARN("Invalid argument supplied.\n");
3196
3197 return D3DERR_INVALIDCALL;
3198 }
3199
3200 static HRESULT WINAPI ID3DXEffectImpl_CommitChanges(ID3DXEffect* iface)
3201 {
3202 struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
3203
3204 FIXME("(%p)->(): stub\n", This);
3205
3206 return E_NOTIMPL;
3207 }
3208
3209 static HRESULT WINAPI ID3DXEffectImpl_EndPass(ID3DXEffect *iface)
3210 {
3211 struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
3212
3213 TRACE("iface %p\n", This);
3214
3215 if (This->active_pass)
3216 {
3217 This->active_pass = NULL;
3218 return D3D_OK;
3219 }
3220
3221 WARN("Invalid call.\n");
3222
3223 return D3DERR_INVALIDCALL;
3224 }
3225
3226 static HRESULT WINAPI ID3DXEffectImpl_End(ID3DXEffect* iface)
3227 {
3228 struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
3229
3230 FIXME("(%p)->(): stub\n", This);
3231
3232 return E_NOTIMPL;
3233 }
3234
3235 static HRESULT WINAPI ID3DXEffectImpl_GetDevice(ID3DXEffect *iface, LPDIRECT3DDEVICE9 *device)
3236 {
3237 struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
3238
3239 TRACE("iface %p, device %p\n", This, device);
3240
3241 if (!device)
3242 {
3243 WARN("Invalid argument supplied.\n");
3244 return D3DERR_INVALIDCALL;
3245 }
3246
3247 IDirect3DDevice9_AddRef(This->device);
3248
3249 *device = This->device;
3250
3251 TRACE("Returning device %p\n", *device);
3252
3253 return S_OK;
3254 }
3255
3256 static HRESULT WINAPI ID3DXEffectImpl_OnLostDevice(ID3DXEffect* iface)
3257 {
3258 struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
3259
3260 FIXME("(%p)->(): stub\n", This);
3261
3262 return E_NOTIMPL;
3263 }
3264
3265 static HRESULT WINAPI ID3DXEffectImpl_OnResetDevice(ID3DXEffect* iface)
3266 {
3267 struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
3268
3269 FIXME("(%p)->(): stub\n", This);
3270
3271 return E_NOTIMPL;
3272 }
3273
3274 static HRESULT WINAPI ID3DXEffectImpl_SetStateManager(ID3DXEffect *iface, LPD3DXEFFECTSTATEMANAGER manager)
3275 {
3276 struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
3277
3278 TRACE("iface %p, manager %p\n", This, manager);
3279
3280 if (manager) IUnknown_AddRef(manager);
3281 if (This->manager) IUnknown_Release(This->manager);
3282
3283 This->manager = manager;
3284
3285 return D3D_OK;
3286 }
3287
3288 static HRESULT WINAPI ID3DXEffectImpl_GetStateManager(ID3DXEffect *iface, LPD3DXEFFECTSTATEMANAGER *manager)
3289 {
3290 struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
3291
3292 TRACE("iface %p, manager %p\n", This, manager);
3293
3294 if (!manager)
3295 {
3296 WARN("Invalid argument supplied.\n");
3297 return D3DERR_INVALIDCALL;
3298 }
3299
3300 if (This->manager) IUnknown_AddRef(This->manager);
3301 *manager = This->manager;
3302
3303 return D3D_OK;
3304 }
3305
3306 static HRESULT WINAPI ID3DXEffectImpl_BeginParameterBlock(ID3DXEffect* iface)
3307 {
3308 struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
3309
3310 FIXME("(%p)->(): stub\n", This);
3311
3312 return E_NOTIMPL;
3313 }
3314
3315 static D3DXHANDLE WINAPI ID3DXEffectImpl_EndParameterBlock(ID3DXEffect* iface)
3316 {
3317 struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
3318
3319 FIXME("(%p)->(): stub\n", This);
3320
3321 return NULL;
3322 }
3323
3324 static HRESULT WINAPI ID3DXEffectImpl_ApplyParameterBlock(ID3DXEffect* iface, D3DXHANDLE parameter_block)
3325 {
3326 struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
3327
3328 FIXME("(%p)->(%p): stub\n", This, parameter_block);
3329
3330 return E_NOTIMPL;
3331 }
3332
3333 static HRESULT WINAPI ID3DXEffectImpl_DeleteParameterBlock(ID3DXEffect* iface, D3DXHANDLE parameter_block)
3334 {
3335 struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
3336
3337 FIXME("(%p)->(%p): stub\n", This, parameter_block);
3338
3339 return E_NOTIMPL;
3340 }
3341
3342 static HRESULT WINAPI ID3DXEffectImpl_CloneEffect(ID3DXEffect* iface, LPDIRECT3DDEVICE9 device, LPD3DXEFFECT* effect)
3343 {
3344 struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
3345
3346 FIXME("(%p)->(%p, %p): stub\n", This, device, effect);
3347
3348 return E_NOTIMPL;
3349 }
3350
3351 static HRESULT WINAPI ID3DXEffectImpl_SetRawValue(ID3DXEffect* iface, D3DXHANDLE parameter, LPCVOID data, UINT byte_offset, UINT bytes)
3352 {
3353 struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
3354
3355 FIXME("(%p)->(%p, %p, %u, %u): stub\n", This, parameter, data, byte_offset, bytes);
3356
3357 return E_NOTIMPL;
3358 }
3359
3360 static const struct ID3DXEffectVtbl ID3DXEffect_Vtbl =
3361 {
3362 /*** IUnknown methods ***/
3363 ID3DXEffectImpl_QueryInterface,
3364 ID3DXEffectImpl_AddRef,
3365 ID3DXEffectImpl_Release,
3366 /*** ID3DXBaseEffect methods ***/
3367 ID3DXEffectImpl_GetDesc,
3368 ID3DXEffectImpl_GetParameterDesc,
3369 ID3DXEffectImpl_GetTechniqueDesc,
3370 ID3DXEffectImpl_GetPassDesc,
3371 ID3DXEffectImpl_GetFunctionDesc,
3372 ID3DXEffectImpl_GetParameter,
3373 ID3DXEffectImpl_GetParameterByName,
3374 ID3DXEffectImpl_GetParameterBySemantic,
3375 ID3DXEffectImpl_GetParameterElement,
3376 ID3DXEffectImpl_GetTechnique,
3377 ID3DXEffectImpl_GetTechniqueByName,
3378 ID3DXEffectImpl_GetPass,
3379 ID3DXEffectImpl_GetPassByName,
3380 ID3DXEffectImpl_GetFunction,
3381 ID3DXEffectImpl_GetFunctionByName,
3382 ID3DXEffectImpl_GetAnnotation,
3383 ID3DXEffectImpl_GetAnnotationByName,
3384 ID3DXEffectImpl_SetValue,
3385 ID3DXEffectImpl_GetValue,
3386 ID3DXEffectImpl_SetBool,
3387 ID3DXEffectImpl_GetBool,
3388 ID3DXEffectImpl_SetBoolArray,
3389 ID3DXEffectImpl_GetBoolArray,
3390 ID3DXEffectImpl_SetInt,
3391 ID3DXEffectImpl_GetInt,
3392 ID3DXEffectImpl_SetIntArray,
3393 ID3DXEffectImpl_GetIntArray,
3394 ID3DXEffectImpl_SetFloat,
3395 ID3DXEffectImpl_GetFloat,
3396 ID3DXEffectImpl_SetFloatArray,
3397 ID3DXEffectImpl_GetFloatArray,
3398 ID3DXEffectImpl_SetVector,
3399 ID3DXEffectImpl_GetVector,
3400 ID3DXEffectImpl_SetVectorArray,
3401 ID3DXEffectImpl_GetVectorArray,
3402 ID3DXEffectImpl_SetMatrix,
3403 ID3DXEffectImpl_GetMatrix,
3404 ID3DXEffectImpl_SetMatrixArray,
3405 ID3DXEffectImpl_GetMatrixArray,
3406 ID3DXEffectImpl_SetMatrixPointerArray,
3407 ID3DXEffectImpl_GetMatrixPointerArray,
3408 ID3DXEffectImpl_SetMatrixTranspose,
3409 ID3DXEffectImpl_GetMatrixTranspose,
3410 ID3DXEffectImpl_SetMatrixTransposeArray,
3411 ID3DXEffectImpl_GetMatrixTransposeArray,
3412 ID3DXEffectImpl_SetMatrixTransposePointerArray,
3413 ID3DXEffectImpl_GetMatrixTransposePointerArray,
3414 ID3DXEffectImpl_SetString,
3415 ID3DXEffectImpl_GetString,
3416 ID3DXEffectImpl_SetTexture,
3417 ID3DXEffectImpl_GetTexture,
3418 ID3DXEffectImpl_GetPixelShader,
3419 ID3DXEffectImpl_GetVertexShader,
3420 ID3DXEffectImpl_SetArrayRange,
3421 /*** ID3DXEffect methods ***/
3422 ID3DXEffectImpl_GetPool,
3423 ID3DXEffectImpl_SetTechnique,
3424 ID3DXEffectImpl_GetCurrentTechnique,
3425 ID3DXEffectImpl_ValidateTechnique,
3426 ID3DXEffectImpl_FindNextValidTechnique,
3427 ID3DXEffectImpl_IsParameterUsed,
3428 ID3DXEffectImpl_Begin,
3429 ID3DXEffectImpl_BeginPass,
3430 ID3DXEffectImpl_CommitChanges,
3431 ID3DXEffectImpl_EndPass,
3432 ID3DXEffectImpl_End,
3433 ID3DXEffectImpl_GetDevice,
3434 ID3DXEffectImpl_OnLostDevice,
3435 ID3DXEffectImpl_OnResetDevice,
3436 ID3DXEffectImpl_SetStateManager,
3437 ID3DXEffectImpl_GetStateManager,
3438 ID3DXEffectImpl_BeginParameterBlock,
3439 ID3DXEffectImpl_EndParameterBlock,
3440 ID3DXEffectImpl_ApplyParameterBlock,
3441 ID3DXEffectImpl_DeleteParameterBlock,
3442 ID3DXEffectImpl_CloneEffect,
3443 ID3DXEffectImpl_SetRawValue
3444 };
3445
3446 static inline struct ID3DXEffectCompilerImpl *impl_from_ID3DXEffectCompiler(ID3DXEffectCompiler *iface)
3447 {
3448 return CONTAINING_RECORD(iface, struct ID3DXEffectCompilerImpl, ID3DXEffectCompiler_iface);
3449 }
3450
3451 /*** IUnknown methods ***/
3452 static HRESULT WINAPI ID3DXEffectCompilerImpl_QueryInterface(ID3DXEffectCompiler *iface, REFIID riid, void **object)
3453 {
3454 struct ID3DXEffectCompilerImpl *This = impl_from_ID3DXEffectCompiler(iface);
3455
3456 TRACE("iface %p, riid %s, object %p\n", This, debugstr_guid(riid), object);
3457
3458 if (IsEqualGUID(riid, &IID_IUnknown) ||
3459 IsEqualGUID(riid, &IID_ID3DXEffectCompiler))
3460 {
3461 This->ID3DXEffectCompiler_iface.lpVtbl->AddRef(iface);
3462 *object = This;
3463 return S_OK;
3464 }
3465
3466 ERR("Interface %s not found\n", debugstr_guid(riid));
3467
3468 return E_NOINTERFACE;
3469 }
3470
3471 static ULONG WINAPI ID3DXEffectCompilerImpl_AddRef(ID3DXEffectCompiler *iface)
3472 {
3473 struct ID3DXEffectCompilerImpl *This = impl_from_ID3DXEffectCompiler(iface);
3474
3475 TRACE("iface %p: AddRef from %u\n", iface, This->ref);
3476
3477 return InterlockedIncrement(&This->ref);
3478 }
3479
3480 static ULONG WINAPI ID3DXEffectCompilerImpl_Release(ID3DXEffectCompiler *iface)
3481 {
3482 struct ID3DXEffectCompilerImpl *This = impl_from_ID3DXEffectCompiler(iface);
3483 ULONG ref = InterlockedDecrement(&This->ref);
3484
3485 TRACE("iface %p: Release from %u\n", iface, ref + 1);
3486
3487 if (!ref)
3488 {
3489 free_effect_compiler(This);
3490 HeapFree(GetProcessHeap(), 0, This);
3491 }
3492
3493 return ref;
3494 }
3495
3496 /*** ID3DXBaseEffect methods ***/
3497 static HRESULT WINAPI ID3DXEffectCompilerImpl_GetDesc(ID3DXEffectCompiler *iface, D3DXEFFECT_DESC *desc)
3498 {
3499 struct ID3DXEffectCompilerImpl *This = impl_from_ID3DXEffectCompiler(iface);
3500 ID3DXBaseEffect *base = This->base_effect;
3501
3502 TRACE("Forward iface %p, base %p\n", This, base);
3503
3504 return ID3DXBaseEffectImpl_GetDesc(base, desc);
3505 }
3506
3507 static HRESULT WINAPI ID3DXEffectCompilerImpl_GetParameterDesc(ID3DXEffectCompiler *iface, D3DXHANDLE parameter, D3DXPARAMETER_DESC *desc)
3508 {
3509 struct ID3DXEffectCompilerImpl *This = impl_from_ID3DXEffectCompiler(iface);
3510 ID3DXBaseEffect *base = This->base_effect;
3511
3512 TRACE("Forward iface %p, base %p\n", This, base);
3513
3514 return ID3DXBaseEffectImpl_GetParameterDesc(base, parameter, desc);
3515 }
3516
3517 static HRESULT WINAPI ID3DXEffectCompilerImpl_GetTechniqueDesc(ID3DXEffectCompiler *iface, D3DXHANDLE technique, D3DXTECHNIQUE_DESC *desc)
3518 {
3519 struct ID3DXEffectCompilerImpl *This = impl_from_ID3DXEffectCompiler(iface);
3520 ID3DXBaseEffect *base = This->base_effect;
3521
3522 TRACE("Forward iface %p, base %p\n", This, base);
3523
3524 return ID3DXBaseEffectImpl_GetTechniqueDesc(base, technique, desc);
3525 }
3526
3527 static HRESULT WINAPI ID3DXEffectCompilerImpl_GetPassDesc(ID3DXEffectCompiler *iface, D3DXHANDLE pass, D3DXPASS_DESC *desc)
3528 {
3529 struct ID3DXEffectCompilerImpl *This = impl_from_ID3DXEffectCompiler(iface);
3530 ID3DXBaseEffect *base = This->base_effect;
3531
3532 TRACE("Forward iface %p, base %p\n", This, base);
3533
3534 return ID3DXBaseEffectImpl_GetPassDesc(base, pass, desc);
3535 }
3536
3537 static HRESULT WINAPI ID3DXEffectCompilerImpl_GetFunctionDesc(ID3DXEffectCompiler *iface, D3DXHANDLE shader, D3DXFUNCTION_DESC *desc)
3538 {
3539 struct ID3DXEffectCompilerImpl *This = impl_from_ID3DXEffectCompiler(iface);
3540 ID3DXBaseEffect *base = This->base_effect;
3541
3542 TRACE("Forward iface %p, base %p\n", This, base);
3543
3544 return ID3DXBaseEffectImpl_GetFunctionDesc(base, shader, desc);
3545 }
3546
3547 static D3DXHANDLE WINAPI ID3DXEffectCompilerImpl_GetParameter(ID3DXEffectCompiler *iface, D3DXHANDLE parameter, UINT index)
3548 {
3549 struct ID3DXEffectCompilerImpl *This = impl_from_ID3DXEffectCompiler(iface);
3550 ID3DXBaseEffect *base = This->base_effect;
3551
3552 TRACE("Forward iface %p, base %p\n", This, base);
3553
3554 return ID3DXBaseEffectImpl_GetParameter(base, parameter, index);
3555 }
3556
3557 static D3DXHANDLE WINAPI ID3DXEffectCompilerImpl_GetParameterByName(ID3DXEffectCompiler *iface, D3DXHANDLE parameter, LPCSTR name)
3558 {
3559 struct ID3DXEffectCompilerImpl *This = impl_from_ID3DXEffectCompiler(iface);
3560 ID3DXBaseEffect *base = This->base_effect;
3561
3562 TRACE("Forward iface %p, base %p\n", This, base);
3563
3564 return ID3DXBaseEffectImpl_GetParameterByName(base, parameter, name);
3565 }
3566
3567 static D3DXHANDLE WINAPI ID3DXEffectCompilerImpl_GetParameterBySemantic(ID3DXEffectCompiler *iface, D3DXHANDLE parameter, LPCSTR semantic)
3568 {
3569 struct ID3DXEffectCompilerImpl *This = impl_from_ID3DXEffectCompiler(iface);
3570 ID3DXBaseEffect *base = This->base_effect;
3571
3572 TRACE("Forward iface %p, base %p\n", This, base);
3573
3574 return ID3DXBaseEffectImpl_GetParameterBySemantic(base, parameter, semantic);
3575 }
3576
3577 static D3DXHANDLE WINAPI ID3DXEffectCompilerImpl_GetParameterElement(ID3DXEffectCompiler *iface, D3DXHANDLE parameter, UINT index)
3578 {
3579 struct ID3DXEffectCompilerImpl *This = impl_from_ID3DXEffectCompiler(iface);
3580 ID3DXBaseEffect *base = This->base_effect;
3581
3582 TRACE("Forward iface %p, base %p\n", This, base);
3583
3584 return ID3DXBaseEffectImpl_GetParameterElement(base, parameter, index);
3585 }
3586
3587 static D3DXHANDLE WINAPI ID3DXEffectCompilerImpl_GetTechnique(ID3DXEffectCompiler *iface, UINT index)
3588 {
3589 struct ID3DXEffectCompilerImpl *This = impl_from_ID3DXEffectCompiler(iface);
3590 ID3DXBaseEffect *base = This->base_effect;
3591
3592 TRACE("Forward iface %p, base %p\n", This, base);
3593
3594 return ID3DXBaseEffectImpl_GetTechnique(base, index);
3595 }
3596
3597 static D3DXHANDLE WINAPI ID3DXEffectCompilerImpl_GetTechniqueByName(ID3DXEffectCompiler *iface, LPCSTR name)
3598 {
3599 struct ID3DXEffectCompilerImpl *This = impl_from_ID3DXEffectCompiler(iface);
3600 ID3DXBaseEffect *base = This->base_effect;
3601
3602 TRACE("Forward iface %p, base %p\n", This, base);
3603
3604 return ID3DXBaseEffectImpl_GetTechniqueByName(base, name);
3605 }
3606
3607 static D3DXHANDLE WINAPI ID3DXEffectCompilerImpl_GetPass(ID3DXEffectCompiler *iface, D3DXHANDLE technique, UINT index)
3608 {
3609 struct ID3DXEffectCompilerImpl *This = impl_from_ID3DXEffectCompiler(iface);
3610 ID3DXBaseEffect *base = This->base_effect;
3611
3612 TRACE("Forward iface %p, base %p\n", This, base);
3613
3614 return ID3DXBaseEffectImpl_GetPass(base, technique, index);
3615 }
3616
3617 static D3DXHANDLE WINAPI ID3DXEffectCompilerImpl_GetPassByName(ID3DXEffectCompiler *iface, D3DXHANDLE technique, LPCSTR name)
3618 {
3619 struct ID3DXEffectCompilerImpl *This = impl_from_ID3DXEffectCompiler(iface);
3620 ID3DXBaseEffect *base = This->base_effect;
3621
3622 TRACE("Forward iface %p, base %p\n", This, base);
3623
3624 return ID3DXBaseEffectImpl_GetPassByName(base, technique, name);
3625 }
3626
3627 static D3DXHANDLE WINAPI ID3DXEffectCompilerImpl_GetFunction(ID3DXEffectCompiler *iface, UINT index)
3628 {
3629 struct ID3DXEffectCompilerImpl *This = impl_from_ID3DXEffectCompiler(iface);
3630 ID3DXBaseEffect *base = This->base_effect;
3631
3632 TRACE("Forward iface %p, base %p\n", This, base);
3633
3634 return ID3DXBaseEffectImpl_GetFunction(base, index);
3635 }
3636
3637 static D3DXHANDLE WINAPI ID3DXEffectCompilerImpl_GetFunctionByName(ID3DXEffectCompiler *iface, LPCSTR name)
3638 {
3639 struct ID3DXEffectCompilerImpl *This = impl_from_ID3DXEffectCompiler(iface);
3640 ID3DXBaseEffect *base = This->base_effect;
3641
3642 TRACE("Forward iface %p, base %p\n", This, base);
3643
3644 return ID3DXBaseEffectImpl_GetFunctionByName(base, name);
3645 }
3646
3647 static D3DXHANDLE WINAPI ID3DXEffectCompilerImpl_GetAnnotation(ID3DXEffectCompiler *iface, D3DXHANDLE object, UINT index)
3648 {
3649 struct ID3DXEffectCompilerImpl *This = impl_from_ID3DXEffectCompiler(iface);
3650 ID3DXBaseEffect *base = This->base_effect;
3651
3652 TRACE("Forward iface %p, base %p\n", This, base);
3653
3654 return ID3DXBaseEffectImpl_GetAnnotation(base, object, index);
3655 }
3656
3657 static D3DXHANDLE WINAPI ID3DXEffectCompilerImpl_GetAnnotationByName(ID3DXEffectCompiler *iface, D3DXHANDLE object, LPCSTR name)
3658 {
3659 struct ID3DXEffectCompilerImpl *This = impl_from_ID3DXEffectCompiler(iface);
3660 ID3DXBaseEffect *base = This->base_effect;
3661
3662 TRACE("Forward iface %p, base %p\n", This, base);
3663
3664 return ID3DXBaseEffectImpl_GetAnnotationByName(base, object, name);
3665 }
3666
3667 static HRESULT WINAPI ID3DXEffectCompilerImpl_SetValue(ID3DXEffectCompiler *iface, D3DXHANDLE parameter, LPCVOID data, UINT bytes)
3668 {
3669 struct ID3DXEffectCompilerImpl *This = impl_from_ID3DXEffectCompiler(iface);
3670 ID3DXBaseEffect *base = This->base_effect;
3671
3672 TRACE("Forward iface %p, base %p\n", This, base);
3673
3674 return ID3DXBaseEffectImpl_SetValue(base, parameter, data, bytes);
3675 }
3676
3677 static HRESULT WINAPI ID3DXEffectCompilerImpl_GetValue(ID3DXEffectCompiler *iface, D3DXHANDLE parameter, LPVOID data, UINT bytes)
3678 {
3679 struct ID3DXEffectCompilerImpl *This = impl_from_ID3DXEffectCompiler(iface);
3680 ID3DXBaseEffect *base = This->base_effect;
3681
3682 TRACE("Forward iface %p, base %p\n", This, base);
3683
3684 return ID3DXBaseEffectImpl_GetValue(base, parameter, data, bytes);
3685 }
3686
3687 static HRESULT WINAPI ID3DXEffectCompilerImpl_SetBool(ID3DXEffectCompiler *iface, D3DXHANDLE parameter, BOOL b)
3688 {
3689 struct ID3DXEffectCompilerImpl *This = impl_from_ID3DXEffectCompiler(iface);
3690 ID3DXBaseEffect *base = This->base_effect;
3691
3692 TRACE("Forward iface %p, base %p\n", This, base);
3693
3694 return ID3DXBaseEffectImpl_SetBool(base, parameter, b);
3695 }
3696
3697 static HRESULT WINAPI ID3DXEffectCompilerImpl_GetBool(ID3DXEffectCompiler *iface, D3DXHANDLE parameter, BOOL *b)
3698 {
3699 struct ID3DXEffectCompilerImpl *This = impl_from_ID3DXEffectCompiler(iface);
3700 ID3DXBaseEffect *base = This->base_effect;
3701
3702 TRACE("Forward iface %p, base %p\n", This, base);
3703
3704 return ID3DXBaseEffectImpl_GetBool(base, parameter, b);
3705 }
3706
3707 static HRESULT WINAPI ID3DXEffectCompilerImpl_SetBoolArray(ID3DXEffectCompiler *iface, D3DXHANDLE parameter, CONST BOOL *b, UINT count)
3708 {
3709 struct ID3DXEffectCompilerImpl *This = impl_from_ID3DXEffectCompiler(iface);
3710 ID3DXBaseEffect *base = This->base_effect;
3711
3712 TRACE("Forward iface %p, base %p\n", This, base);
3713
3714 return ID3DXBaseEffectImpl_SetBoolArray(base, parameter, b, count);
3715 }
3716
3717 static HRESULT WINAPI ID3DXEffectCompilerImpl_GetBoolArray(ID3DXEffectCompiler *iface, D3DXHANDLE parameter, BOOL *b, UINT count)
3718 {
3719 struct ID3DXEffectCompilerImpl *This = impl_from_ID3DXEffectCompiler(iface);
3720 ID3DXBaseEffect *base = This->base_effect;
3721
3722 TRACE("Forward iface %p, base %p\n", This, base);
3723
3724 return ID3DXBaseEffectImpl_GetBoolArray(base, parameter, b, count);
3725 }
3726
3727 static HRESULT WINAPI ID3DXEffectCompilerImpl_SetInt(ID3DXEffectCompiler *iface, D3DXHANDLE parameter, INT n)
3728 {
3729 struct ID3DXEffectCompilerImpl *This = impl_from_ID3DXEffectCompiler(iface);
3730 ID3DXBaseEffect *base = This->base_effect;
3731
3732 TRACE("Forward iface %p, base %p\n", This, base);
3733
3734 return ID3DXBaseEffectImpl_SetInt(base, parameter, n);
3735 }
3736
3737 static HRESULT WINAPI ID3DXEffectCompilerImpl_GetInt(ID3DXEffectCompiler *iface, D3DXHANDLE parameter, INT *n)
3738 {
3739 struct ID3DXEffectCompilerImpl *This = impl_from_ID3DXEffectCompiler(iface);
3740 ID3DXBaseEffect *base = This->base_effect;
3741
3742 TRACE("Forward iface %p, base %p\n", This, base);
3743
3744 return ID3DXBaseEffectImpl_GetInt(base, parameter, n);
3745 }
3746
3747 static HRESULT WINAPI ID3DXEffectCompilerImpl_SetIntArray(ID3DXEffectCompiler *iface, D3DXHANDLE parameter, CONST INT *n, UINT count)
3748 {
3749 struct ID3DXEffectCompilerImpl *This = impl_from_ID3DXEffectCompiler(iface);
3750 ID3DXBaseEffect *base = This->base_effect;
3751
3752 TRACE("Forward iface %p, base %p\n", This, base);
3753
3754 return ID3DXBaseEffectImpl_SetIntArray(base, parameter, n, count);
3755 }
3756
3757 static HRESULT WINAPI ID3DXEffectCompilerImpl_GetIntArray(ID3DXEffectCompiler *iface, D3DXHANDLE parameter, INT *n, UINT count)
3758 {
3759 struct ID3DXEffectCompilerImpl *This = impl_from_ID3DXEffectCompiler(iface);
3760 ID3DXBaseEffect *base = This->base_effect;
3761
3762 TRACE("Forward iface %p, base %p\n", This, base);
3763
3764 return ID3DXBaseEffectImpl_GetIntArray(base, parameter, n, count);
3765 }
3766
3767 static HRESULT WINAPI ID3DXEffectCompilerImpl_SetFloat(ID3DXEffectCompiler *iface, D3DXHANDLE parameter, FLOAT f)
3768 {
3769 struct ID3DXEffectCompilerImpl *This = impl_from_ID3DXEffectCompiler(iface);
3770 ID3DXBaseEffect *base = This->base_effect;
3771
3772 TRACE("Forward iface %p, base %p\n", This, base);
3773
3774 return ID3DXBaseEffectImpl_SetFloat(base, parameter, f);
3775 }
3776
3777 static HRESULT WINAPI ID3DXEffectCompilerImpl_GetFloat(ID3DXEffectCompiler *iface, D3DXHANDLE parameter, FLOAT *f)
3778 {
3779 struct ID3DXEffectCompilerImpl *This = impl_from_ID3DXEffectCompiler(iface);
3780 ID3DXBaseEffect *base = This->base_effect;
3781
3782 TRACE("Forward iface %p, base %p\n", This, base);
3783
3784 return ID3DXBaseEffectImpl_GetFloat(base, parameter, f);
3785 }
3786
3787 static HRESULT WINAPI ID3DXEffectCompilerImpl_SetFloatArray(ID3DXEffectCompiler *iface, D3DXHANDLE parameter, CONST FLOAT *f, UINT count)
3788 {
3789 struct ID3DXEffectCompilerImpl *This = impl_from_ID3DXEffectCompiler(iface);
3790 ID3DXBaseEffect *base = This->base_effect;
3791
3792 TRACE("Forward iface %p, base %p\n", This, base);
3793
3794 return ID3DXBaseEffectImpl_SetFloatArray(base, parameter, f, count);
3795 }
3796
3797 static HRESULT WINAPI ID3DXEffectCompilerImpl_GetFloatArray(ID3DXEffectCompiler *iface, D3DXHANDLE parameter, FLOAT *f, UINT count)
3798 {
3799 struct ID3DXEffectCompilerImpl *This = impl_from_ID3DXEffectCompiler(iface);
3800 ID3DXBaseEffect *base = This->base_effect;
3801
3802 TRACE("Forward iface %p, base %p\n", This, base);
3803
3804 return ID3DXBaseEffectImpl_GetFloatArray(base, parameter, f, count);
3805 }
3806
3807 static HRESULT WINAPI ID3DXEffectCompilerImpl_SetVector(ID3DXEffectCompiler *iface, D3DXHANDLE parameter, CONST D3DXVECTOR4 *vector)
3808 {
3809 struct ID3DXEffectCompilerImpl *This = impl_from_ID3DXEffectCompiler(iface);
3810 ID3DXBaseEffect *base = This->base_effect;
3811
3812 TRACE("Forward iface %p, base %p\n", This, base);
3813
3814 return ID3DXBaseEffectImpl_SetVector(base, parameter, vector);
3815 }
3816
3817 static HRESULT WINAPI ID3DXEffectCompilerImpl_GetVector(ID3DXEffectCompiler *iface, D3DXHANDLE parameter, D3DXVECTOR4 *vector)
3818 {
3819 struct ID3DXEffectCompilerImpl *This = impl_from_ID3DXEffectCompiler(iface);
3820 ID3DXBaseEffect *base = This->base_effect;
3821
3822 TRACE("Forward iface %p, base %p\n", This, base);
3823
3824 return ID3DXBaseEffectImpl_GetVector(base, parameter, vector);
3825 }
3826
3827 static HRESULT WINAPI ID3DXEffectCompilerImpl_SetVectorArray(ID3DXEffectCompiler *iface, D3DXHANDLE parameter, CONST D3DXVECTOR4 *vector, UINT count)
3828 {
3829 struct ID3DXEffectCompilerImpl *This = impl_from_ID3DXEffectCompiler(iface);
3830 ID3DXBaseEffect *base = This->base_effect;
3831
3832 TRACE("Forward iface %p, base %p\n", This, base);
3833
3834 return ID3DXBaseEffectImpl_SetVectorArray(base, parameter, vector, count);
3835 }
3836
3837 static HRESULT WINAPI ID3DXEffectCompilerImpl_GetVectorArray(ID3DXEffectCompiler *iface, D3DXHANDLE parameter, D3DXVECTOR4 *vector, UINT count)
3838 {
3839 struct ID3DXEffectCompilerImpl *This = impl_from_ID3DXEffectCompiler(iface);
3840 ID3DXBaseEffect *base = This->base_effect;
3841
3842 TRACE("Forward iface %p, base %p\n", This, base);
3843
3844 return ID3DXBaseEffectImpl_GetVectorArray(base, parameter, vector, count);
3845 }
3846
3847 static HRESULT WINAPI ID3DXEffectCompilerImpl_SetMatrix(ID3DXEffectCompiler *iface, D3DXHANDLE parameter, CONST D3DXMATRIX *matrix)
3848 {
3849 struct ID3DXEffectCompilerImpl *This = impl_from_ID3DXEffectCompiler(iface);
3850 ID3DXBaseEffect *base = This->base_effect;
3851
3852 TRACE("Forward iface %p, base %p\n", This, base);
3853
3854 return ID3DXBaseEffectImpl_SetMatrix(base, parameter, matrix);
3855 }
3856
3857 static HRESULT WINAPI ID3DXEffectCompilerImpl_GetMatrix(ID3DXEffectCompiler *iface, D3DXHANDLE parameter, D3DXMATRIX *matrix)
3858 {
3859 struct ID3DXEffectCompilerImpl *This = impl_from_ID3DXEffectCompiler(iface);
3860 ID3DXBaseEffect *base = This->base_effect;
3861
3862 TRACE("Forward iface %p, base %p\n", This, base);
3863
3864 return ID3DXBaseEffectImpl_GetMatrix(base, parameter, matrix);
3865 }
3866
3867 static HRESULT WINAPI ID3DXEffectCompilerImpl_SetMatrixArray(ID3DXEffectCompiler *iface, D3DXHANDLE parameter, CONST D3DXMATRIX *matrix, UINT count)
3868 {
3869 struct ID3DXEffectCompilerImpl *This = impl_from_ID3DXEffectCompiler(iface);
3870 ID3DXBaseEffect *base = This->base_effect;
3871
3872 TRACE("Forward iface %p, base %p\n", This, base);
3873
3874 return ID3DXBaseEffectImpl_SetMatrixArray(base, parameter, matrix, count);
3875 }
3876
3877 static HRESULT WINAPI ID3DXEffectCompilerImpl_GetMatrixArray(ID3DXEffectCompiler *iface, D3DXHANDLE parameter, D3DXMATRIX *matrix, UINT count)
3878 {
3879 struct ID3DXEffectCompilerImpl *This = impl_from_ID3DXEffectCompiler(iface);
3880 ID3DXBaseEffect *base = This->base_effect;
3881
3882 TRACE("Forward iface %p, base %p\n", This, base);
3883
3884 return ID3DXBaseEffectImpl_GetMatrixArray(base, parameter, matrix, count);
3885 }
3886
3887 static HRESULT WINAPI ID3DXEffectCompilerImpl_SetMatrixPointerArray(ID3DXEffectCompiler *iface, D3DXHANDLE parameter, CONST D3DXMATRIX **matrix, UINT count)
3888 {
3889 struct ID3DXEffectCompilerImpl *This = impl_from_ID3DXEffectCompiler(iface);
3890 ID3DXBaseEffect *base = This->base_effect;
3891
3892 TRACE("Forward iface %p, base %p\n", This, base);
3893
3894 return ID3DXBaseEffectImpl_SetMatrixPointerArray(base, parameter, matrix, count);
3895 }
3896
3897 static HRESULT WINAPI ID3DXEffectCompilerImpl_GetMatrixPointerArray(ID3DXEffectCompiler *iface, D3DXHANDLE parameter, D3DXMATRIX **matrix, UINT count)
3898 {
3899 struct ID3DXEffectCompilerImpl *This = impl_from_ID3DXEffectCompiler(iface);
3900 ID3DXBaseEffect *base = This->base_effect;
3901
3902 TRACE("Forward iface %p, base %p\n", This, base);
3903
3904 return ID3DXBaseEffectImpl_GetMatrixPointerArray(base, parameter, matrix, count);
3905 }
3906
3907 static HRESULT WINAPI ID3DXEffectCompilerImpl_SetMatrixTranspose(ID3DXEffectCompiler *iface, D3DXHANDLE parameter, CONST D3DXMATRIX *matrix)
3908 {
3909 struct ID3DXEffectCompilerImpl *This = impl_from_ID3DXEffectCompiler(iface);
3910 ID3DXBaseEffect *base = This->base_effect;
3911
3912 TRACE("Forward iface %p, base %p\n", This, base);
3913
3914 return ID3DXBaseEffectImpl_SetMatrixTranspose(base, parameter, matrix);
3915 }
3916
3917 static HRESULT WINAPI ID3DXEffectCompilerImpl_GetMatrixTranspose(ID3DXEffectCompiler *iface, D3DXHANDLE parameter, D3DXMATRIX *matrix)
3918 {
3919 struct ID3DXEffectCompilerImpl *This = impl_from_ID3DXEffectCompiler(iface);
3920 ID3DXBaseEffect *base = This->base_effect;
3921
3922 TRACE("Forward iface %p, base %p\n", This, base);
3923
3924 return ID3DXBaseEffectImpl_GetMatrixTranspose(base, parameter, matrix);
3925 }
3926
3927 static HRESULT WINAPI ID3DXEffectCompilerImpl_SetMatrixTransposeArray(ID3DXEffectCompiler *iface, D3DXHANDLE parameter, CONST D3DXMATRIX *matrix, UINT count)
3928 {
3929 struct ID3DXEffectCompilerImpl *This = impl_from_ID3DXEffectCompiler(iface);
3930 ID3DXBaseEffect *base = This->base_effect;
3931
3932 TRACE("Forward iface %p, base %p\n", This, base);
3933
3934 return ID3DXBaseEffectImpl_SetMatrixTransposeArray(base, parameter, matrix, count);
3935 }
3936
3937 static HRESULT WINAPI ID3DXEffectCompilerImpl_GetMatrixTransposeArray(ID3DXEffectCompiler *iface, D3DXHANDLE parameter, D3DXMATRIX *matrix, UINT count)
3938 {
3939 struct ID3DXEffectCompilerImpl *This = impl_from_ID3DXEffectCompiler(iface);
3940 ID3DXBaseEffect *base = This->base_effect;
3941
3942 TRACE("Forward iface %p, base %p\n", This, base);
3943
3944 return ID3DXBaseEffectImpl_GetMatrixTransposeArray(base, parameter, matrix, count);
3945 }
3946
3947 static HRESULT WINAPI ID3DXEffectCompilerImpl_SetMatrixTransposePointerArray(ID3DXEffectCompiler *iface, D3DXHANDLE parameter, CONST D3DXMATRIX **matrix, UINT count)
3948 {
3949 struct ID3DXEffectCompilerImpl *This = impl_from_ID3DXEffectCompiler(iface);
3950 ID3DXBaseEffect *base = This->base_effect;
3951
3952 TRACE("Forward iface %p, base %p\n", This, base);
3953
3954 return ID3DXBaseEffectImpl_SetMatrixTransposePointerArray(base, parameter, matrix, count);
3955 }
3956
3957 static HRESULT WINAPI ID3DXEffectCompilerImpl_GetMatrixTransposePointerArray(ID3DXEffectCompiler *iface, D3DXHANDLE parameter, D3DXMATRIX **matrix, UINT count)
3958 {
3959 struct ID3DXEffectCompilerImpl *This = impl_from_ID3DXEffectCompiler(iface);
3960 ID3DXBaseEffect *base = This->base_effect;
3961
3962 TRACE("Forward iface %p, base %p\n", This, base);
3963
3964 return ID3DXBaseEffectImpl_GetMatrixTransposePointerArray(base, parameter, matrix, count);
3965 }
3966
3967 static HRESULT WINAPI ID3DXEffectCompilerImpl_SetString(ID3DXEffectCompiler *iface, D3DXHANDLE parameter, LPCSTR string)
3968 {
3969 struct ID3DXEffectCompilerImpl *This = impl_from_ID3DXEffectCompiler(iface);
3970 ID3DXBaseEffect *base = This->base_effect;
3971
3972 TRACE("Forward iface %p, base %p\n", This, base);
3973
3974 return ID3DXBaseEffectImpl_SetString(base, parameter, string);
3975 }
3976
3977 static HRESULT WINAPI ID3DXEffectCompilerImpl_GetString(ID3DXEffectCompiler *iface, D3DXHANDLE parameter, LPCSTR *string)
3978 {
3979 struct ID3DXEffectCompilerImpl *This = impl_from_ID3DXEffectCompiler(iface);
3980 ID3DXBaseEffect *base = This->base_effect;
3981
3982 TRACE("Forward iface %p, base %p\n", This, base);
3983
3984 return ID3DXBaseEffectImpl_GetString(base, parameter, string);
3985 }
3986
3987 static HRESULT WINAPI ID3DXEffectCompilerImpl_SetTexture(ID3DXEffectCompiler *iface, D3DXHANDLE parameter, LPDIRECT3DBASETEXTURE9 texture)
3988 {
3989 struct ID3DXEffectCompilerImpl *This = impl_from_ID3DXEffectCompiler(iface);
3990 ID3DXBaseEffect *base = This->base_effect;
3991
3992 TRACE("Forward iface %p, base %p\n", This, base);
3993
3994 return ID3DXBaseEffectImpl_SetTexture(base, parameter, texture);
3995 }
3996
3997 static HRESULT WINAPI ID3DXEffectCompilerImpl_GetTexture(ID3DXEffectCompiler *iface, D3DXHANDLE parameter, LPDIRECT3DBASETEXTURE9 *texture)
3998 {
3999 struct ID3DXEffectCompilerImpl *This = impl_from_ID3DXEffectCompiler(iface);
4000 ID3DXBaseEffect *base = This->base_effect;
4001
4002 TRACE("Forward iface %p, base %p\n", This, base);
4003
4004 return ID3DXBaseEffectImpl_GetTexture(base, parameter, texture);
4005 }
4006
4007 static HRESULT WINAPI ID3DXEffectCompilerImpl_GetPixelShader(ID3DXEffectCompiler *iface, D3DXHANDLE parameter, LPDIRECT3DPIXELSHADER9 *pshader)
4008 {
4009 struct ID3DXEffectCompilerImpl *This = impl_from_ID3DXEffectCompiler(iface);
4010 ID3DXBaseEffect *base = This->base_effect;
4011
4012 TRACE("Forward iface %p, base %p\n", This, base);
4013
4014 return ID3DXBaseEffectImpl_GetPixelShader(base, parameter, pshader);
4015 }
4016
4017 static HRESULT WINAPI ID3DXEffectCompilerImpl_GetVertexShader(ID3DXEffectCompiler *iface, D3DXHANDLE parameter, LPDIRECT3DVERTEXSHADER9 *vshader)
4018 {
4019 struct ID3DXEffectCompilerImpl *This = impl_from_ID3DXEffectCompiler(iface);
4020 ID3DXBaseEffect *base = This->base_effect;
4021
4022 TRACE("Forward iface %p, base %p\n", This, base);
4023
4024 return ID3DXBaseEffectImpl_GetVertexShader(base, parameter, vshader);
4025 }
4026
4027 static HRESULT WINAPI ID3DXEffectCompilerImpl_SetArrayRange(ID3DXEffectCompiler *iface, D3DXHANDLE parameter, UINT start, UINT end)
4028 {
4029 struct ID3DXEffectCompilerImpl *This = impl_from_ID3DXEffectCompiler(iface);
4030 ID3DXBaseEffect *base = This->base_effect;
4031
4032 TRACE("Forward iface %p, base %p\n", This, base);
4033
4034 return ID3DXBaseEffectImpl_SetArrayRange(base, parameter, start, end);
4035 }
4036
4037 /*** ID3DXEffectCompiler methods ***/
4038 static HRESULT WINAPI ID3DXEffectCompilerImpl_SetLiteral(ID3DXEffectCompiler *iface, D3DXHANDLE parameter, BOOL literal)
4039 {
4040 struct ID3DXEffectCompilerImpl *This = impl_from_ID3DXEffectCompiler(iface);
4041
4042 FIXME("iface %p, parameter %p, literal %u\n", This, parameter, literal);
4043
4044 return E_NOTIMPL;
4045 }
4046
4047 static HRESULT WINAPI ID3DXEffectCompilerImpl_GetLiteral(ID3DXEffectCompiler *iface, D3DXHANDLE parameter, BOOL *literal)
4048 {
4049 struct ID3DXEffectCompilerImpl *This = impl_from_ID3DXEffectCompiler(iface);
4050
4051 FIXME("iface %p, parameter %p, literal %p\n", This, parameter, literal);
4052
4053 return E_NOTIMPL;
4054 }
4055
4056 static HRESULT WINAPI ID3DXEffectCompilerImpl_CompileEffect(ID3DXEffectCompiler *iface, DWORD flags,
4057 LPD3DXBUFFER *effect, LPD3DXBUFFER *error_msgs)
4058 {
4059 struct ID3DXEffectCompilerImpl *This = impl_from_ID3DXEffectCompiler(iface);
4060
4061 FIXME("iface %p, flags %#x, effect %p, error_msgs %p stub\n", This, flags, effect, error_msgs);
4062
4063 return E_NOTIMPL;
4064 }
4065
4066 static HRESULT WINAPI ID3DXEffectCompilerImpl_CompileShader(ID3DXEffectCompiler *iface, D3DXHANDLE function,
4067 LPCSTR target, DWORD flags, LPD3DXBUFFER *shader, LPD3DXBUFFER *error_msgs, LPD3DXCONSTANTTABLE *constant_table)
4068 {
4069 struct ID3DXEffectCompilerImpl *This = impl_from_ID3DXEffectCompiler(iface);
4070
4071 FIXME("iface %p, function %p, target %p, flags %#x, shader %p, error_msgs %p, constant_table %p stub\n",
4072 This, function, target, flags, shader, error_msgs, constant_table);
4073
4074 return E_NOTIMPL;
4075 }
4076
4077 static const struct ID3DXEffectCompilerVtbl ID3DXEffectCompiler_Vtbl =
4078 {
4079 /*** IUnknown methods ***/
4080 ID3DXEffectCompilerImpl_QueryInterface,
4081 ID3DXEffectCompilerImpl_AddRef,
4082 ID3DXEffectCompilerImpl_Release,
4083 /*** ID3DXBaseEffect methods ***/
4084 ID3DXEffectCompilerImpl_GetDesc,
4085 ID3DXEffectCompilerImpl_GetParameterDesc,
4086 ID3DXEffectCompilerImpl_GetTechniqueDesc,
4087 ID3DXEffectCompilerImpl_GetPassDesc,
4088 ID3DXEffectCompilerImpl_GetFunctionDesc,
4089 ID3DXEffectCompilerImpl_GetParameter,
4090 ID3DXEffectCompilerImpl_GetParameterByName,
4091 ID3DXEffectCompilerImpl_GetParameterBySemantic,
4092 ID3DXEffectCompilerImpl_GetParameterElement,
4093 ID3DXEffectCompilerImpl_GetTechnique,
4094 ID3DXEffectCompilerImpl_GetTechniqueByName,
4095 ID3DXEffectCompilerImpl_GetPass,
4096 ID3DXEffectCompilerImpl_GetPassByName,
4097 ID3DXEffectCompilerImpl_GetFunction,
4098 ID3DXEffectCompilerImpl_GetFunctionByName,
4099 ID3DXEffectCompilerImpl_GetAnnotation,
4100 ID3DXEffectCompilerImpl_GetAnnotationByName,
4101 ID3DXEffectCompilerImpl_SetValue,
4102 ID3DXEffectCompilerImpl_GetValue,
4103 ID3DXEffectCompilerImpl_SetBool,
4104 ID3DXEffectCompilerImpl_GetBool,
4105 ID3DXEffectCompilerImpl_SetBoolArray,
4106 ID3DXEffectCompilerImpl_GetBoolArray,
4107 ID3DXEffectCompilerImpl_SetInt,
4108 ID3DXEffectCompilerImpl_GetInt,
4109 ID3DXEffectCompilerImpl_SetIntArray,
4110 ID3DXEffectCompilerImpl_GetIntArray,
4111 ID3DXEffectCompilerImpl_SetFloat,
4112 ID3DXEffectCompilerImpl_GetFloat,
4113 ID3DXEffectCompilerImpl_SetFloatArray,
4114 ID3DXEffectCompilerImpl_GetFloatArray,
4115 ID3DXEffectCompilerImpl_SetVector,
4116 ID3DXEffectCompilerImpl_GetVector,
4117 ID3DXEffectCompilerImpl_SetVectorArray,
4118 ID3DXEffectCompilerImpl_GetVectorArray,
4119 ID3DXEffectCompilerImpl_SetMatrix,
4120 ID3DXEffectCompilerImpl_GetMatrix,
4121 ID3DXEffectCompilerImpl_SetMatrixArray,
4122 ID3DXEffectCompilerImpl_GetMatrixArray,
4123 ID3DXEffectCompilerImpl_SetMatrixPointerArray,
4124 ID3DXEffectCompilerImpl_GetMatrixPointerArray,
4125 ID3DXEffectCompilerImpl_SetMatrixTranspose,
4126 ID3DXEffectCompilerImpl_GetMatrixTranspose,
4127 ID3DXEffectCompilerImpl_SetMatrixTransposeArray,
4128 ID3DXEffectCompilerImpl_GetMatrixTransposeArray,
4129 ID3DXEffectCompilerImpl_SetMatrixTransposePointerArray,
4130 ID3DXEffectCompilerImpl_GetMatrixTransposePointerArray,
4131 ID3DXEffectCompilerImpl_SetString,
4132 ID3DXEffectCompilerImpl_GetString,
4133 ID3DXEffectCompilerImpl_SetTexture,
4134 ID3DXEffectCompilerImpl_GetTexture,
4135 ID3DXEffectCompilerImpl_GetPixelShader,
4136 ID3DXEffectCompilerImpl_GetVertexShader,
4137 ID3DXEffectCompilerImpl_SetArrayRange,
4138 /*** ID3DXEffectCompiler methods ***/
4139 ID3DXEffectCompilerImpl_SetLiteral,
4140 ID3DXEffectCompilerImpl_GetLiteral,
4141 ID3DXEffectCompilerImpl_CompileEffect,
4142 ID3DXEffectCompilerImpl_CompileShader,
4143 };
4144
4145 static HRESULT d3dx9_parse_sampler(struct d3dx_sampler *sampler, const char *data, const char **ptr, D3DXHANDLE *objects)
4146 {
4147 HRESULT hr;
4148 UINT i;
4149 struct d3dx_state *states;
4150
4151 read_dword(ptr, &sampler->state_count);
4152 TRACE("Count: %u\n", sampler->state_count);
4153
4154 states = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*states) * sampler->state_count);
4155 if (!states)
4156 {
4157 ERR("Out of memory\n");
4158 return E_OUTOFMEMORY;
4159 }
4160
4161 for (i = 0; i < sampler->state_count; ++i)
4162 {
4163 hr = d3dx9_parse_state(&states[i], data, ptr, objects);
4164 if (hr != D3D_OK)
4165 {
4166 WARN("Failed to parse state\n");
4167 goto err_out;
4168 }
4169 }
4170
4171 sampler->states = states;
4172
4173 return D3D_OK;
4174
4175 err_out:
4176
4177 for (i = 0; i < sampler->state_count; ++i)
4178 {
4179 free_state(&states[i]);
4180 }
4181
4182 HeapFree(GetProcessHeap(), 0, states);
4183
4184 return hr;
4185 }
4186
4187 static HRESULT d3dx9_parse_value(struct d3dx_parameter *param, void *value, const char *data, const char **ptr, D3DXHANDLE *objects)
4188 {
4189 unsigned int i;
4190 HRESULT hr;
4191 UINT old_size = 0;
4192 DWORD id;
4193
4194 if (param->element_count)
4195 {
4196 param->data = value;
4197
4198 for (i = 0; i < param->element_count; ++i)
4199 {
4200 struct d3dx_parameter *member = get_parameter_struct(param->member_handles[i]);
4201
4202 hr = d3dx9_parse_value(member, value ? (char *)value + old_size : NULL, data, ptr, objects);
4203 if (hr != D3D_OK)
4204 {
4205 WARN("Failed to parse value\n");
4206 return hr;
4207 }
4208
4209 old_size += member->bytes;
4210 }
4211
4212 return D3D_OK;
4213 }
4214
4215 switch(param->class)
4216 {
4217 case D3DXPC_SCALAR:
4218 case D3DXPC_VECTOR:
4219 case D3DXPC_MATRIX_ROWS:
4220 case D3DXPC_MATRIX_COLUMNS:
4221 param->data = value;
4222 break;
4223
4224 case D3DXPC_STRUCT:
4225 param->data = value;
4226
4227 for (i = 0; i < param->member_count; ++i)
4228 {
4229 struct d3dx_parameter *member = get_parameter_struct(param->member_handles[i]);
4230
4231 hr = d3dx9_parse_value(member, (char *)value + old_size, data, ptr, objects);
4232 if (hr != D3D_OK)
4233 {
4234 WARN("Failed to parse value\n");
4235 return hr;
4236 }
4237
4238 old_size += member->bytes;
4239 }
4240 break;
4241
4242 case D3DXPC_OBJECT:
4243 switch (param->type)
4244 {
4245 case D3DXPT_STRING:
4246 case D3DXPT_TEXTURE:
4247 case D3DXPT_TEXTURE1D:
4248 case D3DXPT_TEXTURE2D:
4249 case D3DXPT_TEXTURE3D:
4250 case D3DXPT_TEXTURECUBE:
4251 case D3DXPT_PIXELSHADER:
4252 case D3DXPT_VERTEXSHADER:
4253 read_dword(ptr, &id);
4254 TRACE("Id: %u\n", id);
4255 objects[id] = get_parameter_handle(param);
4256 param->data = value;
4257 break;
4258
4259 case D3DXPT_SAMPLER:
4260 case D3DXPT_SAMPLER1D:
4261 case D3DXPT_SAMPLER2D:
4262 case D3DXPT_SAMPLER3D:
4263 case D3DXPT_SAMPLERCUBE:
4264 {
4265 struct d3dx_sampler *sampler;
4266
4267 sampler = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*sampler));
4268 if (!sampler)
4269 {
4270 ERR("Out of memory\n");
4271 return E_OUTOFMEMORY;
4272 }
4273
4274 hr = d3dx9_parse_sampler(sampler, data, ptr, objects);
4275 if (hr != D3D_OK)
4276 {
4277 HeapFree(GetProcessHeap(), 0, sampler);
4278 WARN("Failed to parse sampler\n");
4279 return hr;
4280 }
4281
4282 param->data = sampler;
4283 break;
4284 }
4285
4286 default:
4287 FIXME("Unhandled type %s\n", debug_d3dxparameter_type(param->type));
4288 break;
4289 }
4290 break;
4291
4292 default:
4293 FIXME("Unhandled class %s\n", debug_d3dxparameter_class(param->class));
4294 break;
4295 }
4296
4297 return D3D_OK;
4298 }
4299
4300 static HRESULT d3dx9_parse_init_value(struct d3dx_parameter *param, const char *data, const char *ptr, D3DXHANDLE *objects)
4301 {
4302 UINT size = param->bytes;
4303 HRESULT hr;
4304 void *value = NULL;
4305
4306 TRACE("param size: %u\n", size);
4307
4308 if (size)
4309 {
4310 value = HeapAlloc(GetProcessHeap(), 0, size);
4311 if (!value)
4312 {
4313 ERR("Failed to allocate data memory.\n");
4314 return E_OUTOFMEMORY;
4315 }
4316
4317 TRACE("Data: %s.\n", debugstr_an(ptr, size));
4318 memcpy(value, ptr, size);
4319 }
4320
4321 hr = d3dx9_parse_value(param, value, data, &ptr, objects);
4322 if (hr != D3D_OK)
4323 {
4324 WARN("Failed to parse value\n");
4325 HeapFree(GetProcessHeap(), 0, value);
4326 return hr;
4327 }
4328
4329 return D3D_OK;
4330 }
4331
4332 static HRESULT d3dx9_parse_name(char **name, const char *ptr)
4333 {
4334 DWORD size;
4335
4336 read_dword(&ptr, &size);
4337 TRACE("Name size: %#x\n", size);
4338
4339 if (!size)
4340 {
4341 return D3D_OK;
4342 }
4343
4344 *name = HeapAlloc(GetProcessHeap(), 0, size);
4345 if (!*name)
4346 {
4347 ERR("Failed to allocate name memory.\n");
4348 return E_OUTOFMEMORY;
4349 }
4350
4351 TRACE("Name: %s.\n", debugstr_an(ptr, size));
4352 memcpy(*name, ptr, size);
4353
4354 return D3D_OK;
4355 }
4356
4357 static HRESULT d3dx9_copy_data(char **str, const char **ptr)
4358 {
4359 DWORD size;
4360
4361 read_dword(ptr, &size);
4362 TRACE("Data size: %#x\n", size);
4363
4364 *str = HeapAlloc(GetProcessHeap(), 0, size);
4365 if (!*str)
4366 {
4367 ERR("Failed to allocate name memory.\n");
4368 return E_OUTOFMEMORY;
4369 }
4370
4371 TRACE("Data: %s.\n", debugstr_an(*ptr, size));
4372 memcpy(*str, *ptr, size);
4373
4374 *ptr += ((size + 3) & ~3);
4375
4376 return D3D_OK;
4377 }
4378
4379 static HRESULT d3dx9_parse_data(struct d3dx_parameter *param, const char **ptr, LPDIRECT3DDEVICE9 device)
4380 {
4381 DWORD size;
4382 HRESULT hr;
4383
4384 TRACE("Parse data for parameter %s, type %s\n", debugstr_a(param->name), debug_d3dxparameter_type(param->type));
4385
4386 read_dword(ptr, &size);
4387 TRACE("Data size: %#x\n", size);
4388
4389 if (!size)
4390 {
4391 TRACE("Size is 0\n");
4392 *(void **)param->data = NULL;
4393 return D3D_OK;
4394 }
4395
4396 switch (param->type)
4397 {
4398 case D3DXPT_STRING:
4399 /* re-read with size (sizeof(DWORD) = 4) */
4400 hr = d3dx9_parse_name((LPSTR *)param->data, *ptr - 4);
4401 if (hr != D3D_OK)
4402 {
4403 WARN("Failed to parse string data\n");
4404 return hr;
4405 }
4406 break;
4407
4408 case D3DXPT_VERTEXSHADER:
4409 hr = IDirect3DDevice9_CreateVertexShader(device, (DWORD *)*ptr, (LPDIRECT3DVERTEXSHADER9 *)param->data);
4410 if (hr != D3D_OK)
4411 {
4412 WARN("Failed to create vertex shader\n");
4413 return hr;
4414 }
4415 break;
4416
4417 case D3DXPT_PIXELSHADER:
4418 hr = IDirect3DDevice9_CreatePixelShader(device, (DWORD *)*ptr, (LPDIRECT3DPIXELSHADER9 *)param->data);
4419 if (hr != D3D_OK)
4420 {
4421 WARN("Failed to create pixel shader\n");
4422 return hr;
4423 }
4424 break;
4425
4426 default:
4427 FIXME("Unhandled type %s\n", debug_d3dxparameter_type(param->type));
4428 break;
4429 }
4430
4431
4432 *ptr += ((size + 3) & ~3);
4433
4434 return D3D_OK;
4435 }
4436
4437 static HRESULT d3dx9_parse_effect_typedef(struct d3dx_parameter *param, const char *data, const char **ptr,
4438 struct d3dx_parameter *parent, UINT flags)
4439 {
4440 DWORD offset;
4441 HRESULT hr;
4442 D3DXHANDLE *member_handles = NULL;
4443 UINT i;
4444
4445 param->flags = flags;
4446
4447 if (!parent)
4448 {
4449 read_dword(ptr, &param->type);
4450 TRACE("Type: %s\n", debug_d3dxparameter_type(param->type));
4451
4452 read_dword(ptr, &param->class);
4453 TRACE("Class: %s\n", debug_d3dxparameter_class(param->class));
4454
4455 read_dword(ptr, &offset);
4456 TRACE("Type name offset: %#x\n", offset);
4457 hr = d3dx9_parse_name(&param->name, data + offset);
4458 if (hr != D3D_OK)
4459 {
4460 WARN("Failed to parse name\n");
4461 goto err_out;
4462 }
4463
4464 read_dword(ptr, &offset);
4465 TRACE("Type semantic offset: %#x\n", offset);
4466 hr = d3dx9_parse_name(&param->semantic, data + offset);
4467 if (hr != D3D_OK)
4468 {
4469 WARN("Failed to parse semantic\n");
4470 goto err_out;
4471 }
4472
4473 read_dword(ptr, &param->element_count);
4474 TRACE("Elements: %u\n", param->element_count);
4475
4476 switch (param->class)
4477 {
4478 case D3DXPC_VECTOR:
4479 read_dword(ptr, &param->columns);
4480 TRACE("Columns: %u\n", param->columns);
4481
4482 read_dword(ptr, &param->rows);
4483 TRACE("Rows: %u\n", param->rows);
4484
4485 /* sizeof(DWORD) * rows * columns */
4486 param->bytes = 4 * param->rows * param->columns;
4487 break;
4488
4489 case D3DXPC_SCALAR:
4490 case D3DXPC_MATRIX_ROWS:
4491 case D3DXPC_MATRIX_COLUMNS:
4492 read_dword(ptr, &param->rows);
4493 TRACE("Rows: %u\n", param->rows);
4494
4495 read_dword(ptr, &param->columns);
4496 TRACE("Columns: %u\n", param->columns);
4497
4498 /* sizeof(DWORD) * rows * columns */
4499 param->bytes = 4 * param->rows * param->columns;
4500 break;
4501
4502 case D3DXPC_STRUCT:
4503 read_dword(ptr, &param->member_count);
4504 TRACE("Members: %u\n", param->member_count);
4505 break;
4506
4507 case D3DXPC_OBJECT:
4508 switch (param->type)
4509 {
4510 case D3DXPT_STRING:
4511 param->bytes = sizeof(LPCSTR);
4512 break;
4513
4514 case D3DXPT_PIXELSHADER:
4515 param->bytes = sizeof(LPDIRECT3DPIXELSHADER9);
4516 break;
4517
4518 case D3DXPT_VERTEXSHADER:
4519 param->bytes = sizeof(LPDIRECT3DVERTEXSHADER9);
4520 break;
4521
4522 case D3DXPT_TEXTURE:
4523 case D3DXPT_TEXTURE1D:
4524 case D3DXPT_TEXTURE2D:
4525 case D3DXPT_TEXTURE3D:
4526 case D3DXPT_TEXTURECUBE:
4527 param->bytes = sizeof(LPDIRECT3DBASETEXTURE9);
4528 break;
4529
4530 case D3DXPT_SAMPLER:
4531 case D3DXPT_SAMPLER1D:
4532 case D3DXPT_SAMPLER2D:
4533 case D3DXPT_SAMPLER3D:
4534 case D3DXPT_SAMPLERCUBE:
4535 param->bytes = 0;
4536 break;
4537
4538 default:
4539 FIXME("Unhandled type %s\n", debug_d3dxparameter_type(param->type));
4540 break;
4541 }
4542 break;
4543
4544 default:
4545 FIXME("Unhandled class %s\n", debug_d3dxparameter_class(param->class));
4546 break;
4547 }
4548 }
4549 else
4550 {
4551 /* elements */
4552 param->type = parent->type;
4553 param->class = parent->class;
4554 param->name = parent->name;
4555 param->semantic = parent->semantic;
4556 param->element_count = 0;
4557 param->annotation_count = 0;
4558 param->member_count = parent->member_count;
4559 param->bytes = parent->bytes;
4560 param->rows = parent->rows;
4561 param->columns = parent->columns;
4562 }
4563
4564 if (param->element_count)
4565 {
4566 unsigned int param_bytes = 0;
4567 const char *save_ptr = *ptr;
4568
4569 member_handles = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*member_handles) * param->element_count);
4570 if (!member_handles)
4571 {
4572 ERR("Out of memory\n");
4573 hr = E_OUTOFMEMORY;
4574 goto err_out;
4575 }
4576
4577 for (i = 0; i < param->element_count; ++i)
4578 {
4579 struct d3dx_parameter *member;
4580 *ptr = save_ptr;
4581
4582 member = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*member));
4583 if (!member)
4584 {
4585 ERR("Out of memory\n");
4586 hr = E_OUTOFMEMORY;
4587 goto err_out;
4588 }
4589
4590 member_handles[i] = get_parameter_handle(member);
4591
4592 hr = d3dx9_parse_effect_typedef(member, data, ptr, param, flags);
4593 if (hr != D3D_OK)
4594 {
4595 WARN("Failed to parse member\n");
4596 goto err_out;
4597 }
4598
4599 param_bytes += member->bytes;
4600 }
4601
4602 param->bytes = param_bytes;
4603 }
4604 else if (param->member_count)
4605 {
4606 member_handles = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*member_handles) * param->member_count);
4607 if (!member_handles)
4608 {
4609 ERR("Out of memory\n");
4610 hr = E_OUTOFMEMORY;
4611 goto err_out;
4612 }
4613
4614 for (i = 0; i < param->member_count; ++i)
4615 {
4616 struct d3dx_parameter *member;
4617
4618 member = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*member));
4619 if (!member)
4620 {
4621 ERR("Out of memory\n");
4622 hr = E_OUTOFMEMORY;
4623 goto err_out;
4624 }
4625
4626 member_handles[i] = get_parameter_handle(member);
4627
4628 hr = d3dx9_parse_effect_typedef(member, data, ptr, NULL, flags);
4629 if (hr != D3D_OK)
4630 {
4631 WARN("Failed to parse member\n");
4632 goto err_out;
4633 }
4634
4635 param->bytes += member->bytes;
4636 }
4637 }
4638
4639 param->member_handles = member_handles;
4640
4641 return D3D_OK;
4642
4643 err_out:
4644
4645 if (member_handles)
4646 {
4647 unsigned int count;
4648
4649 if (param->element_count) count = param->element_count;
4650 else count = param->member_count;
4651
4652 for (i = 0; i < count; ++i)
4653 {
4654 free_parameter(member_handles[i], param->element_count != 0, TRUE);
4655 }
4656 HeapFree(GetProcessHeap(), 0, member_handles);
4657 }
4658
4659 if (!parent)
4660 {
4661 HeapFree(GetProcessHeap(), 0, param->name);
4662 HeapFree(GetProcessHeap(), 0, param->semantic);
4663 }
4664 param->name = NULL;
4665 param->semantic = NULL;
4666
4667 return hr;
4668 }
4669
4670 static HRESULT d3dx9_parse_effect_annotation(struct d3dx_parameter *anno, const char *data, const char **ptr, D3DXHANDLE *objects)
4671 {
4672 DWORD offset;
4673 const char *ptr2;
4674 HRESULT hr;
4675
4676 anno->flags = D3DX_PARAMETER_ANNOTATION;
4677
4678 read_dword(ptr, &offset);
4679 TRACE("Typedef offset: %#x\n", offset);
4680 ptr2 = data + offset;
4681 hr = d3dx9_parse_effect_typedef(anno, data, &ptr2, NULL, D3DX_PARAMETER_ANNOTATION);
4682 if (hr != D3D_OK)
4683 {
4684 WARN("Failed to parse type definition\n");
4685 return hr;
4686 }
4687
4688 read_dword(ptr, &offset);
4689 TRACE("Value offset: %#x\n", offset);
4690 hr = d3dx9_parse_init_value(anno, data, data + offset, objects);
4691 if (hr != D3D_OK)
4692 {
4693 WARN("Failed to parse value\n");
4694 return hr;
4695 }
4696
4697 return D3D_OK;
4698 }
4699
4700 static HRESULT d3dx9_parse_state(struct d3dx_state *state, const char *data, const char **ptr, D3DXHANDLE *objects)
4701 {
4702 DWORD offset;
4703 const char *ptr2;
4704 HRESULT hr;
4705 struct d3dx_parameter *parameter;
4706
4707 parameter = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*parameter));
4708 if (!parameter)
4709 {
4710 ERR("Out of memory\n");
4711 return E_OUTOFMEMORY;
4712 }
4713
4714 state->type = ST_CONSTANT;
4715
4716 read_dword(ptr, &state->operation);
4717 TRACE("Operation: %#x (%s)\n", state->operation, state_table[state->operation].name);
4718
4719 read_dword(ptr, &state->index);
4720 TRACE("Index: %#x\n", state->index);
4721
4722 read_dword(ptr, &offset);
4723 TRACE("Typedef offset: %#x\n", offset);
4724 ptr2 = data + offset;
4725 hr = d3dx9_parse_effect_typedef(parameter, data, &ptr2, NULL, 0);
4726 if (hr != D3D_OK)
4727 {
4728 WARN("Failed to parse type definition\n");
4729 goto err_out;
4730 }
4731
4732 read_dword(ptr, &offset);
4733 TRACE("Value offset: %#x\n", offset);
4734 hr = d3dx9_parse_init_value(parameter, data, data + offset, objects);
4735 if (hr != D3D_OK)
4736 {
4737 WARN("Failed to parse value\n");
4738 goto err_out;
4739 }
4740
4741 state->parameter = get_parameter_handle(parameter);
4742
4743 return D3D_OK;
4744
4745 err_out:
4746
4747 free_parameter(get_parameter_handle(parameter), FALSE, FALSE);
4748
4749 return hr;
4750 }
4751
4752 static HRESULT d3dx9_parse_effect_parameter(struct d3dx_parameter *param, const char *data, const char **ptr, D3DXHANDLE *objects)
4753 {
4754 DWORD offset;
4755 HRESULT hr;
4756 unsigned int i;
4757 D3DXHANDLE *annotation_handles = NULL;
4758 const char *ptr2;
4759
4760 read_dword(ptr, &offset);
4761 TRACE("Typedef offset: %#x\n", offset);
4762 ptr2 = data + offset;
4763
4764 read_dword(ptr, &offset);
4765 TRACE("Value offset: %#x\n", offset);
4766
4767 read_dword(ptr, &param->flags);
4768 TRACE("Flags: %#x\n", param->flags);
4769
4770 read_dword(ptr, &param->annotation_count);
4771 TRACE("Annotation count: %u\n", param->annotation_count);
4772
4773 hr = d3dx9_parse_effect_typedef(param, data, &ptr2, NULL, param->flags);
4774 if (hr != D3D_OK)
4775 {
4776 WARN("Failed to parse type definition\n");
4777 return hr;
4778 }
4779
4780 hr = d3dx9_parse_init_value(param, data, data + offset, objects);
4781 if (hr != D3D_OK)
4782 {
4783 WARN("Failed to parse value\n");
4784 return hr;
4785 }
4786
4787 if (param->annotation_count)
4788 {
4789 annotation_handles = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*annotation_handles) * param->annotation_count);
4790 if (!annotation_handles)
4791 {
4792 ERR("Out of memory\n");
4793 hr = E_OUTOFMEMORY;
4794 goto err_out;
4795 }
4796
4797 for (i = 0; i < param->annotation_count; ++i)
4798 {
4799 struct d3dx_parameter *annotation;
4800
4801 annotation = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*annotation));
4802 if (!annotation)
4803 {
4804 ERR("Out of memory\n");
4805 hr = E_OUTOFMEMORY;
4806 goto err_out;
4807 }
4808
4809 annotation_handles[i] = get_parameter_handle(annotation);
4810
4811 hr = d3dx9_parse_effect_annotation(annotation, data, ptr, objects);
4812 if (hr != D3D_OK)
4813 {
4814 WARN("Failed to parse annotation\n");
4815 goto err_out;
4816 }
4817 }
4818 }
4819
4820 param->annotation_handles = annotation_handles;
4821
4822 return D3D_OK;
4823
4824 err_out:
4825
4826 if (annotation_handles)
4827 {
4828 for (i = 0; i < param->annotation_count; ++i)
4829 {
4830 free_parameter(annotation_handles[i], FALSE, FALSE);
4831 }
4832 HeapFree(GetProcessHeap(), 0, annotation_handles);
4833 }
4834
4835 return hr;
4836 }
4837
4838 static HRESULT d3dx9_parse_effect_pass(struct d3dx_pass *pass, const char *data, const char **ptr, D3DXHANDLE *objects)
4839 {
4840 DWORD offset;
4841 HRESULT hr;
4842 unsigned int i;
4843 D3DXHANDLE *annotation_handles = NULL;
4844 struct d3dx_state *states = NULL;
4845 char *name = NULL;
4846
4847 read_dword(ptr, &offset);
4848 TRACE("Pass name offset: %#x\n", offset);
4849 hr = d3dx9_parse_name(&name, data + offset);
4850 if (hr != D3D_OK)
4851 {
4852 WARN("Failed to parse name\n");
4853 goto err_out;
4854 }
4855
4856 read_dword(ptr, &pass->annotation_count);
4857 TRACE("Annotation count: %u\n", pass->annotation_count);
4858
4859 read_dword(ptr, &pass->state_count);
4860 TRACE("State count: %u\n", pass->state_count);
4861
4862 if (pass->annotation_count)
4863 {
4864 annotation_handles = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*annotation_handles) * pass->annotation_count);
4865 if (!annotation_handles)
4866 {
4867 ERR("Out of memory\n");
4868 hr = E_OUTOFMEMORY;
4869 goto err_out;
4870 }
4871
4872 for (i = 0; i < pass->annotation_count; ++i)
4873 {
4874 struct d3dx_parameter *annotation;
4875
4876 annotation = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*annotation));
4877 if (!annotation)
4878 {
4879 ERR("Out of memory\n");
4880 hr = E_OUTOFMEMORY;
4881 goto err_out;
4882 }
4883
4884 annotation_handles[i] = get_parameter_handle(annotation);
4885
4886 hr = d3dx9_parse_effect_annotation(annotation, data, ptr, objects);
4887 if (hr != D3D_OK)
4888 {
4889 WARN("Failed to parse annotations\n");
4890 goto err_out;
4891 }
4892 }
4893 }
4894
4895 if (pass->state_count)
4896 {
4897 states = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*states) * pass->state_count);
4898 if (!states)
4899 {
4900 ERR("Out of memory\n");
4901 hr = E_OUTOFMEMORY;
4902 goto err_out;
4903 }
4904
4905 for (i = 0; i < pass->state_count; ++i)
4906 {
4907 hr = d3dx9_parse_state(&states[i], data, ptr, objects);
4908 if (hr != D3D_OK)
4909 {
4910 WARN("Failed to parse annotations\n");
4911 goto err_out;
4912 }
4913 }
4914 }
4915
4916 pass->name = name;
4917 pass->annotation_handles = annotation_handles;
4918 pass->states = states;
4919
4920 return D3D_OK;
4921
4922 err_out:
4923
4924 if (annotation_handles)
4925 {
4926 for (i = 0; i < pass->annotation_count; ++i)
4927 {
4928 free_parameter(annotation_handles[i], FALSE, FALSE);
4929 }
4930 HeapFree(GetProcessHeap(), 0, annotation_handles);
4931 }
4932
4933 if (states)
4934 {
4935 for (i = 0; i < pass->state_count; ++i)
4936 {
4937 free_state(&states[i]);
4938 }
4939 HeapFree(GetProcessHeap(), 0, states);
4940 }
4941
4942 HeapFree(GetProcessHeap(), 0, name);
4943
4944 return hr;
4945 }
4946
4947 static HRESULT d3dx9_parse_effect_technique(struct d3dx_technique *technique, const char *data, const char **ptr, D3DXHANDLE *objects)
4948 {
4949 DWORD offset;
4950 HRESULT hr;
4951 unsigned int i;
4952 D3DXHANDLE *annotation_handles = NULL;
4953 D3DXHANDLE *pass_handles = NULL;
4954 char *name = NULL;
4955
4956 read_dword(ptr, &offset);
4957 TRACE("Technique name offset: %#x\n", offset);
4958 hr = d3dx9_parse_name(&name, data + offset);
4959 if (hr != D3D_OK)
4960 {
4961 WARN("Failed to parse name\n");
4962 goto err_out;
4963 }
4964
4965 read_dword(ptr, &technique->annotation_count);
4966 TRACE("Annotation count: %u\n", technique->annotation_count);
4967
4968 read_dword(ptr, &technique->pass_count);
4969 TRACE("Pass count: %u\n", technique->pass_count);
4970
4971 if (technique->annotation_count)
4972 {
4973 annotation_handles = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*annotation_handles) * technique->annotation_count);
4974 if (!annotation_handles)
4975 {
4976 ERR("Out of memory\n");
4977 hr = E_OUTOFMEMORY;
4978 goto err_out;
4979 }
4980
4981 for (i = 0; i < technique->annotation_count; ++i)
4982 {
4983 struct d3dx_parameter *annotation;
4984
4985 annotation = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*annotation));
4986 if (!annotation)
4987 {
4988 ERR("Out of memory\n");
4989 hr = E_OUTOFMEMORY;
4990 goto err_out;
4991 }
4992
4993 annotation_handles[i] = get_parameter_handle(annotation);
4994
4995 hr = d3dx9_parse_effect_annotation(annotation, data, ptr, objects);
4996 if (hr != D3D_OK)
4997 {
4998 WARN("Failed to parse annotations\n");
4999 goto err_out;
5000 }
5001 }
5002 }
5003
5004 if (technique->pass_count)
5005 {
5006 pass_handles = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*pass_handles) * technique->pass_count);
5007 if (!pass_handles)
5008 {
5009 ERR("Out of memory\n");
5010 hr = E_OUTOFMEMORY;
5011 goto err_out;
5012 }
5013
5014 for (i = 0; i < technique->pass_count; ++i)
5015 {
5016 struct d3dx_pass *pass;
5017
5018 pass = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*pass));
5019 if (!pass)
5020 {
5021 ERR("Out of memory\n");
5022 hr = E_OUTOFMEMORY;
5023 goto err_out;
5024 }
5025
5026 pass_handles[i] = get_pass_handle(pass);
5027
5028 hr = d3dx9_parse_effect_pass(pass, data, ptr, objects);
5029 if (hr != D3D_OK)
5030 {
5031 WARN("Failed to parse passes\n");
5032 goto err_out;
5033 }
5034 }
5035 }
5036
5037 technique->name = name;
5038 technique->pass_handles = pass_handles;
5039 technique->annotation_handles = annotation_handles;
5040
5041 return D3D_OK;
5042
5043 err_out:
5044
5045 if (pass_handles)
5046 {
5047 for (i = 0; i < technique->pass_count; ++i)
5048 {
5049 free_pass(pass_handles[i]);
5050 }
5051 HeapFree(GetProcessHeap(), 0, pass_handles);
5052 }
5053
5054 if (annotation_handles)
5055 {
5056 for (i = 0; i < technique->annotation_count; ++i)
5057 {
5058 free_parameter(annotation_handles[i], FALSE, FALSE);
5059 }
5060 HeapFree(GetProcessHeap(), 0, annotation_handles);
5061 }
5062
5063 HeapFree(GetProcessHeap(), 0, name);
5064
5065 return hr;
5066 }
5067
5068 static HRESULT d3dx9_parse_resource(struct ID3DXBaseEffectImpl *base, const char *data, const char **ptr)
5069 {
5070 DWORD technique_index;
5071 DWORD index, state_index, usage, element_index;
5072 struct d3dx_state *state;
5073 struct d3dx_parameter *param;
5074 HRESULT hr = E_FAIL;
5075
5076 read_dword(ptr, &technique_index);
5077 TRACE("techn: %u\n", technique_index);
5078
5079 read_dword(ptr, &index);
5080 TRACE("index: %u\n", index);
5081
5082 read_dword(ptr, &element_index);
5083 TRACE("element_index: %u\n", element_index);
5084
5085 read_dword(ptr, &state_index);
5086 TRACE("state_index: %u\n", state_index);
5087
5088 read_dword(ptr, &usage);
5089 TRACE("usage: %u\n", usage);
5090
5091 if (technique_index == 0xffffffff)
5092 {
5093 struct d3dx_parameter *parameter;
5094 struct d3dx_sampler *sampler;
5095
5096 if (index >= base->parameter_count)
5097 {
5098 FIXME("Index out of bounds: index %u >= parameter_count %u\n", index, base->parameter_count);
5099 return E_FAIL;
5100 }
5101
5102 parameter = get_parameter_struct(base->parameter_handles[index]);
5103 if (element_index != 0xffffffff)
5104 {
5105 if (element_index >= parameter->element_count && parameter->element_count != 0)
5106 {
5107 FIXME("Index out of bounds: element_index %u >= element_count %u\n", element_index, parameter->element_count);
5108 return E_FAIL;
5109 }
5110
5111 if (parameter->element_count != 0) parameter = get_parameter_struct(parameter->member_handles[element_index]);
5112 }
5113
5114 sampler = parameter->data;
5115 if (state_index >= sampler->state_count)
5116 {
5117 FIXME("Index out of bounds: state_index %u >= state_count %u\n", state_index, sampler->state_count);
5118 return E_FAIL;
5119 }
5120
5121 state = &sampler->states[state_index];
5122 }
5123 else
5124 {
5125 struct d3dx_technique *technique;
5126 struct d3dx_pass *pass;
5127
5128 if (technique_index >= base->technique_count)
5129 {
5130 FIXME("Index out of bounds: technique_index %u >= technique_count %u\n", technique_index, base->technique_count);
5131 return E_FAIL;
5132 }
5133
5134 technique = get_technique_struct(base->technique_handles[technique_index]);
5135 if (index >= technique->pass_count)
5136 {
5137 FIXME("Index out of bounds: index %u >= pass_count %u\n", index, technique->pass_count);
5138 return E_FAIL;
5139 }
5140
5141 pass = get_pass_struct(technique->pass_handles[index]);
5142 if (state_index >= pass->state_count)
5143 {
5144 FIXME("Index out of bounds: state_index %u >= state_count %u\n", state_index, pass->state_count);
5145 return E_FAIL;
5146 }
5147
5148 state = &pass->states[state_index];
5149 }
5150
5151 param = get_parameter_struct(state->parameter);
5152
5153 switch (usage)
5154 {
5155 case 0:
5156 TRACE("usage 0: type %s\n", debug_d3dxparameter_type(param->type));
5157 switch (param->type)
5158 {
5159 case D3DXPT_VERTEXSHADER:
5160 case D3DXPT_PIXELSHADER:
5161 state->type = ST_CONSTANT;
5162 hr = d3dx9_parse_data(param, ptr, base->effect->device);
5163 break;
5164
5165 case D3DXPT_BOOL:
5166 case D3DXPT_INT:
5167 case D3DXPT_FLOAT:
5168 case D3DXPT_STRING:
5169 state->type = ST_FXLC;
5170 hr = d3dx9_copy_data(param->data, ptr);
5171 break;
5172
5173 default:
5174 FIXME("Unhandled type %s\n", debug_d3dxparameter_type(param->type));
5175 break;
5176 }
5177 break;
5178
5179 case 1:
5180 state->type = ST_PARAMETER;
5181 hr = d3dx9_copy_data(param->data, ptr);
5182 if (hr == D3D_OK)
5183 {
5184 TRACE("Mapping to parameter %s\n", *(char **)param->data);
5185 }
5186 break;
5187
5188 default:
5189 FIXME("Unknown usage %x\n", usage);
5190 break;
5191 }
5192
5193 return hr;
5194 }
5195
5196 static HRESULT d3dx9_parse_effect(struct ID3DXBaseEffectImpl *base, const char *data, UINT data_size, DWORD start)
5197 {
5198 const char *ptr = data + start;
5199 D3DXHANDLE *parameter_handles = NULL;
5200 D3DXHANDLE *technique_handles = NULL;
5201 D3DXHANDLE *objects = NULL;
5202 UINT stringcount, objectcount, resourcecount;
5203 HRESULT hr;
5204 UINT i;
5205
5206 read_dword(&ptr, &base->parameter_count);
5207 TRACE("Parameter count: %u\n", base->parameter_count);
5208
5209 read_dword(&ptr, &base->technique_count);
5210 TRACE("Technique count: %u\n", base->technique_count);
5211
5212 skip_dword_unknown(&ptr, 1);
5213
5214 read_dword(&ptr, &objectcount);
5215 TRACE("Object count: %u\n", objectcount);
5216
5217 objects = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*objects) * objectcount);
5218 if (!objects)
5219 {
5220 ERR("Out of memory\n");
5221 hr = E_OUTOFMEMORY;
5222 goto err_out;
5223 }
5224
5225 if (base->parameter_count)
5226 {
5227 parameter_handles = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*parameter_handles) * base->parameter_count);
5228 if (!parameter_handles)
5229 {
5230 ERR("Out of memory\n");
5231 hr = E_OUTOFMEMORY;
5232 goto err_out;
5233 }
5234
5235 for (i = 0; i < base->parameter_count; ++i)
5236 {
5237 struct d3dx_parameter *parameter;
5238
5239 parameter = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*parameter));
5240 if (!parameter)
5241 {
5242 ERR("Out of memory\n");
5243 hr = E_OUTOFMEMORY;
5244 goto err_out;
5245 }
5246
5247 parameter_handles[i] = get_parameter_handle(parameter);
5248
5249 hr = d3dx9_parse_effect_parameter(parameter, data, &ptr, objects);
5250 if (hr != D3D_OK)
5251 {
5252 WARN("Failed to parse parameter\n");
5253 goto err_out;
5254 }
5255 }
5256 }
5257
5258 if (base->technique_count)
5259 {
5260 technique_handles = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*technique_handles) * base->technique_count);
5261 if (!technique_handles)
5262 {
5263 ERR("Out of memory\n");
5264 hr = E_OUTOFMEMORY;
5265 goto err_out;
5266 }
5267
5268 for (i = 0; i < base->technique_count; ++i)
5269 {
5270 struct d3dx_technique *technique;
5271
5272 technique = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*technique));
5273 if (!technique)
5274 {
5275 ERR("Out of memory\n");
5276 hr = E_OUTOFMEMORY;
5277 goto err_out;
5278 }
5279
5280 technique_handles[i] = get_technique_handle(technique);
5281
5282 hr = d3dx9_parse_effect_technique(technique, data, &ptr, objects);
5283 if (hr != D3D_OK)
5284 {
5285 WARN("Failed to parse technique\n");
5286 goto err_out;
5287 }
5288 }
5289 }
5290
5291 /* needed for further parsing */
5292 base->technique_handles = technique_handles;
5293 base->parameter_handles = parameter_handles;
5294
5295 read_dword(&ptr, &stringcount);
5296 TRACE("String count: %u\n", stringcount);
5297
5298 read_dword(&ptr, &resourcecount);
5299 TRACE("Resource count: %u\n", resourcecount);
5300
5301 for (i = 0; i < stringcount; ++i)
5302 {
5303 DWORD id;
5304 struct d3dx_parameter *param;
5305
5306 read_dword(&ptr, &id);
5307 TRACE("Id: %u\n", id);
5308
5309 param = get_parameter_struct(objects[id]);
5310
5311 hr = d3dx9_parse_data(param, &ptr, base->effect->device);
5312 if (hr != D3D_OK)
5313 {
5314 WARN("Failed to parse data\n");
5315 goto err_out;
5316 }
5317 }
5318
5319 for (i = 0; i < resourcecount; ++i)
5320 {
5321 TRACE("parse resource %u\n", i);
5322
5323 hr = d3dx9_parse_resource(base, data, &ptr);
5324 if (hr != D3D_OK)
5325 {
5326 WARN("Failed to parse data\n");
5327 goto err_out;
5328 }
5329 }
5330
5331 HeapFree(GetProcessHeap(), 0, objects);
5332
5333 return D3D_OK;
5334
5335 err_out:
5336
5337 if (technique_handles)
5338 {
5339 for (i = 0; i < base->technique_count; ++i)
5340 {
5341 free_technique(technique_handles[i]);
5342 }
5343 HeapFree(GetProcessHeap(), 0, technique_handles);
5344 }
5345
5346 if (parameter_handles)
5347 {
5348 for (i = 0; i < base->parameter_count; ++i)
5349 {
5350 free_parameter(parameter_handles[i], FALSE, FALSE);
5351 }
5352 HeapFree(GetProcessHeap(), 0, parameter_handles);
5353 }
5354
5355 base->technique_handles = NULL;
5356 base->parameter_handles = NULL;
5357
5358 HeapFree(GetProcessHeap(), 0, objects);
5359
5360 return hr;
5361 }
5362
5363 static HRESULT d3dx9_base_effect_init(struct ID3DXBaseEffectImpl *base,
5364 const char *data, SIZE_T data_size, struct ID3DXEffectImpl *effect)
5365 {
5366 DWORD tag, offset;
5367 const char *ptr = data;
5368 HRESULT hr;
5369
5370 TRACE("base %p, data %p, data_size %lu, effect %p\n", base, data, data_size, effect);
5371
5372 base->ID3DXBaseEffect_iface.lpVtbl = &ID3DXBaseEffect_Vtbl;
5373 base->ref = 1;
5374 base->effect = effect;
5375
5376 read_dword(&ptr, &tag);
5377 TRACE("Tag: %x\n", tag);
5378
5379 if (tag != d3dx9_effect_version(9, 1))
5380 {
5381 /* todo: compile hlsl ascii code */
5382 FIXME("HLSL ascii effects not supported, yet\n");
5383
5384 /* Show the start of the shader for debugging info. */
5385 TRACE("effect:\n%s\n", debugstr_an(data, data_size > 40 ? 40 : data_size));
5386 }
5387 else
5388 {
5389 read_dword(&ptr, &offset);
5390 TRACE("Offset: %x\n", offset);
5391
5392 hr = d3dx9_parse_effect(base, ptr, data_size, offset);
5393 if (hr != D3D_OK)
5394 {
5395 FIXME("Failed to parse effect.\n");
5396 return hr;
5397 }
5398 }
5399
5400 return D3D_OK;
5401 }
5402
5403 static HRESULT d3dx9_effect_init(struct ID3DXEffectImpl *effect, LPDIRECT3DDEVICE9 device,
5404 const char *data, SIZE_T data_size, LPD3DXEFFECTPOOL pool)
5405 {
5406 HRESULT hr;
5407 struct ID3DXBaseEffectImpl *object = NULL;
5408
5409 TRACE("effect %p, device %p, data %p, data_size %lu, pool %p\n", effect, device, data, data_size, pool);
5410
5411 effect->ID3DXEffect_iface.lpVtbl = &ID3DXEffect_Vtbl;
5412 effect->ref = 1;
5413
5414 if (pool) pool->lpVtbl->AddRef(pool);
5415 effect->pool = pool;
5416
5417 IDirect3DDevice9_AddRef(device);
5418 effect->device = device;
5419
5420 object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object));
5421 if (!object)
5422 {
5423 ERR("Out of memory\n");
5424 hr = E_OUTOFMEMORY;
5425 goto err_out;
5426 }
5427
5428 hr = d3dx9_base_effect_init(object, data, data_size, effect);
5429 if (hr != D3D_OK)
5430 {
5431 FIXME("Failed to parse effect.\n");
5432 goto err_out;
5433 }
5434
5435 effect->base_effect = &object->ID3DXBaseEffect_iface;
5436
5437 /* initialize defaults - check because of unsupported ascii effects */
5438 if (object->technique_handles)
5439 {
5440 effect->active_technique = object->technique_handles[0];
5441 effect->active_pass = NULL;
5442 }
5443
5444 return D3D_OK;
5445
5446 err_out:
5447
5448 HeapFree(GetProcessHeap(), 0, object);
5449 free_effect(effect);
5450
5451 return hr;
5452 }
5453
5454 HRESULT WINAPI D3DXCreateEffectEx(LPDIRECT3DDEVICE9 device,
5455 LPCVOID srcdata,
5456 UINT srcdatalen,
5457 CONST D3DXMACRO* defines,
5458 LPD3DXINCLUDE include,
5459 LPCSTR skip_constants,
5460 DWORD flags,
5461 LPD3DXEFFECTPOOL pool,
5462 LPD3DXEFFECT* effect,
5463 LPD3DXBUFFER* compilation_errors)
5464 {
5465 struct ID3DXEffectImpl *object;
5466 HRESULT hr;
5467
5468 FIXME("(%p, %p, %u, %p, %p, %p, %#x, %p, %p, %p): semi-stub\n", device, srcdata, srcdatalen, defines, include,
5469 skip_constants, flags, pool, effect, compilation_errors);
5470
5471 if (!device || !srcdata)
5472 return D3DERR_INVALIDCALL;
5473
5474 if (!srcdatalen)
5475 return E_FAIL;
5476
5477 /* Native dll allows effect to be null so just return D3D_OK after doing basic checks */
5478 if (!effect)
5479 return D3D_OK;
5480
5481 object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object));
5482 if (!object)
5483 {
5484 ERR("Out of memory\n");
5485 return E_OUTOFMEMORY;
5486 }
5487
5488 hr = d3dx9_effect_init(object, device, srcdata, srcdatalen, pool);
5489 if (FAILED(hr))
5490 {
5491 WARN("Failed to initialize shader reflection\n");
5492 HeapFree(GetProcessHeap(), 0, object);
5493 return hr;
5494 }
5495
5496 *effect = &object->ID3DXEffect_iface;
5497
5498 TRACE("Created ID3DXEffect %p\n", object);
5499
5500 return D3D_OK;
5501 }
5502
5503 HRESULT WINAPI D3DXCreateEffect(LPDIRECT3DDEVICE9 device,
5504 LPCVOID srcdata,
5505 UINT srcdatalen,
5506 CONST D3DXMACRO* defines,
5507 LPD3DXINCLUDE include,
5508 DWORD flags,
5509 LPD3DXEFFECTPOOL pool,
5510 LPD3DXEFFECT* effect,
5511 LPD3DXBUFFER* compilation_errors)
5512 {
5513 TRACE("(%p, %p, %u, %p, %p, %#x, %p, %p, %p): Forwarded to D3DXCreateEffectEx\n", device, srcdata, srcdatalen, defines,
5514 include, flags, pool, effect, compilation_errors);
5515
5516 return D3DXCreateEffectEx(device, srcdata, srcdatalen, defines, include, NULL, flags, pool, effect, compilation_errors);
5517 }
5518
5519 static HRESULT d3dx9_effect_compiler_init(struct ID3DXEffectCompilerImpl *compiler, const char *data, SIZE_T data_size)
5520 {
5521 HRESULT hr;
5522 struct ID3DXBaseEffectImpl *object = NULL;
5523
5524 TRACE("effect %p, data %p, data_size %lu\n", compiler, data, data_size);
5525
5526 compiler->ID3DXEffectCompiler_iface.lpVtbl = &ID3DXEffectCompiler_Vtbl;
5527 compiler->ref = 1;
5528
5529 object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object));
5530 if (!object)
5531 {
5532 ERR("Out of memory\n");
5533 hr = E_OUTOFMEMORY;
5534 goto err_out;
5535 }
5536
5537 hr = d3dx9_base_effect_init(object, data, data_size, NULL);
5538 if (hr != D3D_OK)
5539 {
5540 FIXME("Failed to parse effect.\n");
5541 goto err_out;
5542 }
5543
5544 compiler->base_effect = &object->ID3DXBaseEffect_iface;
5545
5546 return D3D_OK;
5547
5548 err_out:
5549
5550 HeapFree(GetProcessHeap(), 0, object);
5551 free_effect_compiler(compiler);
5552
5553 return hr;
5554 }
5555
5556 HRESULT WINAPI D3DXCreateEffectCompiler(LPCSTR srcdata,
5557 UINT srcdatalen,
5558 CONST D3DXMACRO *defines,
5559 LPD3DXINCLUDE include,
5560 DWORD flags,
5561 LPD3DXEFFECTCOMPILER *compiler,
5562 LPD3DXBUFFER *parse_errors)
5563 {
5564 struct ID3DXEffectCompilerImpl *object;
5565 HRESULT hr;
5566
5567 TRACE("srcdata %p, srcdatalen %u, defines %p, include %p, flags %#x, compiler %p, parse_errors %p\n",
5568 srcdata, srcdatalen, defines, include, flags, compiler, parse_errors);
5569
5570 if (!srcdata || !compiler)
5571 {
5572 WARN("Invalid arguments supplied\n");
5573 return D3DERR_INVALIDCALL;
5574 }
5575
5576 object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object));
5577 if (!object)
5578 {
5579 ERR("Out of memory\n");
5580 return E_OUTOFMEMORY;
5581 }
5582
5583 hr = d3dx9_effect_compiler_init(object, srcdata, srcdatalen);
5584 if (FAILED(hr))
5585 {
5586 WARN("Failed to initialize effect compiler\n");
5587 HeapFree(GetProcessHeap(), 0, object);
5588 return hr;
5589 }
5590
5591 *compiler = &object->ID3DXEffectCompiler_iface;
5592
5593 TRACE("Created ID3DXEffectCompiler %p\n", object);
5594
5595 return D3D_OK;
5596 }
5597
5598 static const struct ID3DXEffectPoolVtbl ID3DXEffectPool_Vtbl;
5599
5600 struct ID3DXEffectPoolImpl
5601 {
5602 ID3DXEffectPool ID3DXEffectPool_iface;
5603 LONG ref;
5604 };
5605
5606 static inline struct ID3DXEffectPoolImpl *impl_from_ID3DXEffectPool(ID3DXEffectPool *iface)
5607 {
5608 return CONTAINING_RECORD(iface, struct ID3DXEffectPoolImpl, ID3DXEffectPool_iface);
5609 }
5610
5611 /*** IUnknown methods ***/
5612 static HRESULT WINAPI ID3DXEffectPoolImpl_QueryInterface(ID3DXEffectPool *iface, REFIID riid, void **object)
5613 {
5614 struct ID3DXEffectPoolImpl *This = impl_from_ID3DXEffectPool(iface);
5615
5616 TRACE("(%p)->(%s, %p)\n", This, debugstr_guid(riid), object);
5617
5618 if (IsEqualGUID(riid, &IID_IUnknown) ||
5619 IsEqualGUID(riid, &IID_ID3DXEffectPool))
5620 {
5621 This->ID3DXEffectPool_iface.lpVtbl->AddRef(iface);
5622 *object = This;
5623 return S_OK;
5624 }
5625
5626 WARN("Interface %s not found\n", debugstr_guid(riid));
5627
5628 return E_NOINTERFACE;
5629 }
5630
5631 static ULONG WINAPI ID3DXEffectPoolImpl_AddRef(ID3DXEffectPool *iface)
5632 {
5633 struct ID3DXEffectPoolImpl *This = impl_from_ID3DXEffectPool(iface);
5634
5635 TRACE("(%p)->(): AddRef from %u\n", This, This->ref);
5636
5637 return InterlockedIncrement(&This->ref);
5638 }
5639
5640 static ULONG WINAPI ID3DXEffectPoolImpl_Release(ID3DXEffectPool *iface)
5641 {
5642 struct ID3DXEffectPoolImpl *This = impl_from_ID3DXEffectPool(iface);
5643 ULONG ref = InterlockedDecrement(&This->ref);
5644
5645 TRACE("(%p)->(): Release from %u\n", This, ref + 1);
5646
5647 if (!ref)
5648 HeapFree(GetProcessHeap(), 0, This);
5649
5650 return ref;
5651 }
5652
5653 static const struct ID3DXEffectPoolVtbl ID3DXEffectPool_Vtbl =
5654 {
5655 /*** IUnknown methods ***/
5656 ID3DXEffectPoolImpl_QueryInterface,
5657 ID3DXEffectPoolImpl_AddRef,
5658 ID3DXEffectPoolImpl_Release
5659 };
5660
5661 HRESULT WINAPI D3DXCreateEffectPool(LPD3DXEFFECTPOOL *pool)
5662 {
5663 struct ID3DXEffectPoolImpl *object;
5664
5665 TRACE("(%p)\n", pool);
5666
5667 if (!pool)
5668 return D3DERR_INVALIDCALL;
5669
5670 object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object));
5671 if (!object)
5672 {
5673 ERR("Out of memory\n");
5674 return E_OUTOFMEMORY;
5675 }
5676
5677 object->ID3DXEffectPool_iface.lpVtbl = &ID3DXEffectPool_Vtbl;
5678 object->ref = 1;
5679
5680 *pool = &object->ID3DXEffectPool_iface;
5681
5682 return S_OK;
5683 }
5684
5685 HRESULT WINAPI D3DXCreateEffectFromFileExW(LPDIRECT3DDEVICE9 device, LPCWSTR srcfile,
5686 const D3DXMACRO *defines, LPD3DXINCLUDE include, LPCSTR skipconstants, DWORD flags,
5687 LPD3DXEFFECTPOOL pool, LPD3DXEFFECT *effect, LPD3DXBUFFER *compilationerrors)
5688 {
5689 LPVOID buffer;
5690 HRESULT ret;
5691 DWORD size;
5692
5693 TRACE("(%s): relay\n", debugstr_w(srcfile));
5694
5695 if (!device || !srcfile)
5696 return D3DERR_INVALIDCALL;
5697
5698 ret = map_view_of_file(srcfile, &buffer, &size);
5699
5700 if (FAILED(ret))
5701 return D3DXERR_INVALIDDATA;
5702
5703 ret = D3DXCreateEffectEx(device, buffer, size, defines, include, skipconstants, flags, pool, effect, compilationerrors);
5704 UnmapViewOfFile(buffer);
5705
5706 return ret;
5707 }
5708
5709 HRESULT WINAPI D3DXCreateEffectFromFileExA(LPDIRECT3DDEVICE9 device, LPCSTR srcfile,
5710 const D3DXMACRO *defines, LPD3DXINCLUDE include, LPCSTR skipconstants, DWORD flags,
5711 LPD3DXEFFECTPOOL pool, LPD3DXEFFECT *effect, LPD3DXBUFFER *compilationerrors)
5712 {
5713 LPWSTR srcfileW;
5714 HRESULT ret;
5715 DWORD len;
5716
5717 TRACE("(void): relay\n");
5718
5719 if (!srcfile)
5720 return D3DERR_INVALIDCALL;
5721
5722 len = MultiByteToWideChar(CP_ACP, 0, srcfile, -1, NULL, 0);
5723 srcfileW = HeapAlloc(GetProcessHeap(), 0, len * sizeof(*srcfileW));
5724 MultiByteToWideChar(CP_ACP, 0, srcfile, -1, srcfileW, len);
5725
5726 ret = D3DXCreateEffectFromFileExW(device, srcfileW, defines, include, skipconstants, flags, pool, effect, compilationerrors);
5727 HeapFree(GetProcessHeap(), 0, srcfileW);
5728
5729 return ret;
5730 }
5731
5732 HRESULT WINAPI D3DXCreateEffectFromFileW(LPDIRECT3DDEVICE9 device, LPCWSTR srcfile,
5733 const D3DXMACRO *defines, LPD3DXINCLUDE include, DWORD flags, LPD3DXEFFECTPOOL pool,
5734 LPD3DXEFFECT *effect, LPD3DXBUFFER *compilationerrors)
5735 {
5736 TRACE("(void): relay\n");
5737 return D3DXCreateEffectFromFileExW(device, srcfile, defines, include, NULL, flags, pool, effect, compilationerrors);
5738 }
5739
5740 HRESULT WINAPI D3DXCreateEffectFromFileA(LPDIRECT3DDEVICE9 device, LPCSTR srcfile,
5741 const D3DXMACRO *defines, LPD3DXINCLUDE include, DWORD flags, LPD3DXEFFECTPOOL pool,
5742 LPD3DXEFFECT *effect, LPD3DXBUFFER *compilationerrors)
5743 {
5744 TRACE("(void): relay\n");
5745 return D3DXCreateEffectFromFileExA(device, srcfile, defines, include, NULL, flags, pool, effect, compilationerrors);
5746 }
5747
5748 HRESULT WINAPI D3DXCreateEffectFromResourceExW(LPDIRECT3DDEVICE9 device, HMODULE srcmodule, LPCWSTR srcresource,
5749 const D3DXMACRO *defines, LPD3DXINCLUDE include, LPCSTR skipconstants, DWORD flags,
5750 LPD3DXEFFECTPOOL pool, LPD3DXEFFECT *effect, LPD3DXBUFFER *compilationerrors)
5751 {
5752 HRSRC resinfo;
5753
5754 TRACE("(%p, %s): relay\n", srcmodule, debugstr_w(srcresource));
5755
5756 if (!device)
5757 return D3DERR_INVALIDCALL;
5758
5759 resinfo = FindResourceW(srcmodule, srcresource, (LPCWSTR) RT_RCDATA);
5760
5761 if (resinfo)
5762 {
5763 LPVOID buffer;
5764 HRESULT ret;
5765 DWORD size;
5766
5767 ret = load_resource_into_memory(srcmodule, resinfo, &buffer, &size);
5768
5769 if (FAILED(ret))
5770 return D3DXERR_INVALIDDATA;
5771
5772 return D3DXCreateEffectEx(device, buffer, size, defines, include, skipconstants, flags, pool, effect, compilationerrors);
5773 }
5774
5775 return D3DXERR_INVALIDDATA;
5776 }
5777
5778 HRESULT WINAPI D3DXCreateEffectFromResourceExA(LPDIRECT3DDEVICE9 device, HMODULE srcmodule, LPCSTR srcresource,
5779 const D3DXMACRO *defines, LPD3DXINCLUDE include, LPCSTR skipconstants, DWORD flags,
5780 LPD3DXEFFECTPOOL pool, LPD3DXEFFECT *effect, LPD3DXBUFFER *compilationerrors)
5781 {
5782 HRSRC resinfo;
5783
5784 TRACE("(%p, %s): relay\n", srcmodule, debugstr_a(srcresource));
5785
5786 if (!device)
5787 return D3DERR_INVALIDCALL;
5788
5789 resinfo = FindResourceA(srcmodule, srcresource, (LPCSTR) RT_RCDATA);
5790
5791 if (resinfo)
5792 {
5793 LPVOID buffer;
5794 HRESULT ret;
5795 DWORD size;
5796
5797 ret = load_resource_into_memory(srcmodule, resinfo, &buffer, &size);
5798
5799 if (FAILED(ret))
5800 return D3DXERR_INVALIDDATA;
5801
5802 return D3DXCreateEffectEx(device, buffer, size, defines, include, skipconstants, flags, pool, effect, compilationerrors);
5803 }
5804
5805 return D3DXERR_INVALIDDATA;
5806 }
5807
5808 HRESULT WINAPI D3DXCreateEffectFromResourceW(LPDIRECT3DDEVICE9 device, HMODULE srcmodule, LPCWSTR srcresource,
5809 const D3DXMACRO *defines, LPD3DXINCLUDE include, DWORD flags, LPD3DXEFFECTPOOL pool,
5810 LPD3DXEFFECT *effect, LPD3DXBUFFER *compilationerrors)
5811 {
5812 TRACE("(void): relay\n");
5813 return D3DXCreateEffectFromResourceExW(device, srcmodule, srcresource, defines, include, NULL, flags, pool, effect, compilationerrors);
5814 }
5815
5816 HRESULT WINAPI D3DXCreateEffectFromResourceA(LPDIRECT3DDEVICE9 device, HMODULE srcmodule, LPCSTR srcresource,
5817 const D3DXMACRO *defines, LPD3DXINCLUDE include, DWORD flags, LPD3DXEFFECTPOOL pool,
5818 LPD3DXEFFECT *effect, LPD3DXBUFFER *compilationerrors)
5819 {
5820 TRACE("(void): relay\n");
5821 return D3DXCreateEffectFromResourceExA(device, srcmodule, srcresource, defines, include, NULL, flags, pool, effect, compilationerrors);
5822 }
5823
5824 HRESULT WINAPI D3DXCreateEffectCompilerFromFileW(LPCWSTR srcfile, const D3DXMACRO *defines, LPD3DXINCLUDE include,
5825 DWORD flags, LPD3DXEFFECTCOMPILER *effectcompiler, LPD3DXBUFFER *parseerrors)
5826 {
5827 LPVOID buffer;
5828 HRESULT ret;
5829 DWORD size;
5830
5831 TRACE("(%s): relay\n", debugstr_w(srcfile));
5832
5833 if (!srcfile)
5834 return D3DERR_INVALIDCALL;
5835
5836 ret = map_view_of_file(srcfile, &buffer, &size);
5837
5838 if (FAILED(ret))
5839 return D3DXERR_INVALIDDATA;
5840
5841 ret = D3DXCreateEffectCompiler(buffer, size, defines, include, flags, effectcompiler, parseerrors);
5842 UnmapViewOfFile(buffer);
5843
5844 return ret;
5845 }
5846
5847 HRESULT WINAPI D3DXCreateEffectCompilerFromFileA(LPCSTR srcfile, const D3DXMACRO *defines, LPD3DXINCLUDE include,
5848 DWORD flags, LPD3DXEFFECTCOMPILER *effectcompiler, LPD3DXBUFFER *parseerrors)
5849 {
5850 LPWSTR srcfileW;
5851 HRESULT ret;
5852 DWORD len;
5853
5854 TRACE("(void): relay\n");
5855
5856 if (!srcfile)
5857 return D3DERR_INVALIDCALL;
5858
5859 len = MultiByteToWideChar(CP_ACP, 0, srcfile, -1, NULL, 0);
5860 srcfileW = HeapAlloc(GetProcessHeap(), 0, len * sizeof(*srcfileW));
5861 MultiByteToWideChar(CP_ACP, 0, srcfile, -1, srcfileW, len);
5862
5863 ret = D3DXCreateEffectCompilerFromFileW(srcfileW, defines, include, flags, effectcompiler, parseerrors);
5864 HeapFree(GetProcessHeap(), 0, srcfileW);
5865
5866 return ret;
5867 }
5868
5869 HRESULT WINAPI D3DXCreateEffectCompilerFromResourceA(HMODULE srcmodule, LPCSTR srcresource, const D3DXMACRO *defines,
5870 LPD3DXINCLUDE include, DWORD flags, LPD3DXEFFECTCOMPILER *effectcompiler, LPD3DXBUFFER *parseerrors)
5871 {
5872 HRSRC resinfo;
5873
5874 TRACE("(%p, %s): relay\n", srcmodule, debugstr_a(srcresource));
5875
5876 resinfo = FindResourceA(srcmodule, srcresource, (LPCSTR) RT_RCDATA);
5877
5878 if (resinfo)
5879 {
5880 LPVOID buffer;
5881 HRESULT ret;
5882 DWORD size;
5883
5884 ret = load_resource_into_memory(srcmodule, resinfo, &buffer, &size);
5885
5886 if (FAILED(ret))
5887 return D3DXERR_INVALIDDATA;
5888
5889 return D3DXCreateEffectCompiler(buffer, size, defines, include, flags, effectcompiler, parseerrors);
5890 }
5891
5892 return D3DXERR_INVALIDDATA;
5893 }
5894
5895 HRESULT WINAPI D3DXCreateEffectCompilerFromResourceW(HMODULE srcmodule, LPCWSTR srcresource, const D3DXMACRO *defines,
5896 LPD3DXINCLUDE include, DWORD flags, LPD3DXEFFECTCOMPILER *effectcompiler, LPD3DXBUFFER *parseerrors)
5897 {
5898 HRSRC resinfo;
5899
5900 TRACE("(%p, %s): relay\n", srcmodule, debugstr_w(srcresource));
5901
5902 resinfo = FindResourceW(srcmodule, srcresource, (LPCWSTR) RT_RCDATA);
5903
5904 if (resinfo)
5905 {
5906 LPVOID buffer;
5907 HRESULT ret;
5908 DWORD size;
5909
5910 ret = load_resource_into_memory(srcmodule, resinfo, &buffer, &size);
5911
5912 if (FAILED(ret))
5913 return D3DXERR_INVALIDDATA;
5914
5915 return D3DXCreateEffectCompiler(buffer, size, defines, include, flags, effectcompiler, parseerrors);
5916 }
5917
5918 return D3DXERR_INVALIDDATA;
5919 }
Maarten's multimedia branch