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