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