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