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