projects / reactos.git / blob
? search:


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