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