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