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