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