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