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