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