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