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