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