2 * Copyright 2010 Christian Costa
3 * Copyright 2011 Rico Schüller
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.
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.
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
21 #include "wine/port.h"
22 #define NONAMELESSUNION
23 #include "wine/debug.h"
24 #include "wine/unicode.h"
28 #include "d3dx9_36_private.h"
30 /* Constants for special INT/FLOAT conversation */
31 #define INT_FLOAT_MULTI 255.0f
32 #define INT_FLOAT_MULTI_INVERSE (1/INT_FLOAT_MULTI)
34 WINE_DEFAULT_DEBUG_CHANNEL(d3dx
);
81 enum SHADER_CONSTANT_TYPE
103 D3DXPARAMETER_CLASS
class;
104 D3DXPARAMETER_TYPE type
;
108 UINT annotation_count
;
114 struct d3dx_parameter
*annotations
;
115 struct d3dx_parameter
*members
;
122 struct d3dx_parameter
*param
;
129 enum STATE_TYPE type
;
130 struct d3dx_parameter
*parameter
;
136 struct d3dx_state
*states
;
143 UINT annotation_count
;
145 struct d3dx_state
*states
;
146 struct d3dx_parameter
*annotations
;
149 struct d3dx_technique
153 UINT annotation_count
;
155 struct d3dx_parameter
*annotations
;
156 struct d3dx_pass
*passes
;
159 struct d3dx9_base_effect
161 struct ID3DXEffectImpl
*effect
;
163 UINT parameter_count
;
164 UINT technique_count
;
167 struct d3dx_parameter
*parameters
;
168 struct d3dx_technique
*techniques
;
169 struct d3dx_object
*objects
;
172 struct ID3DXEffectImpl
174 ID3DXEffect ID3DXEffect_iface
;
177 struct d3dx9_base_effect base_effect
;
179 struct ID3DXEffectStateManager
*manager
;
180 struct IDirect3DDevice9
*device
;
181 struct ID3DXEffectPool
*pool
;
182 struct d3dx_technique
*active_technique
;
183 struct d3dx_pass
*active_pass
;
188 struct ID3DXEffectCompilerImpl
190 ID3DXEffectCompiler ID3DXEffectCompiler_iface
;
193 struct d3dx9_base_effect base_effect
;
196 static struct d3dx_parameter
*get_parameter_by_name(struct d3dx9_base_effect
*base
,
197 struct d3dx_parameter
*parameter
, const char *name
);
198 static struct d3dx_parameter
*get_annotation_by_name(UINT count
, struct d3dx_parameter
*parameters
,
200 static HRESULT
d3dx9_parse_state(struct d3dx_state
*state
, const char *data
, const char **ptr
,
201 struct d3dx_object
*objects
);
202 static void free_parameter(struct d3dx_parameter
*param
, BOOL element
, BOOL child
);
206 enum STATE_CLASS
class;
213 {SC_RENDERSTATE
, D3DRS_ZENABLE
, "D3DRS_ZENABLE"}, /* 0x0 */
214 {SC_RENDERSTATE
, D3DRS_FILLMODE
, "D3DRS_FILLMODE"},
215 {SC_RENDERSTATE
, D3DRS_SHADEMODE
, "D3DRS_SHADEMODE"},
216 {SC_RENDERSTATE
, D3DRS_ZWRITEENABLE
, "D3DRS_ZWRITEENABLE"},
217 {SC_RENDERSTATE
, D3DRS_ALPHATESTENABLE
, "D3DRS_ALPHATESTENABLE"},
218 {SC_RENDERSTATE
, D3DRS_LASTPIXEL
, "D3DRS_LASTPIXEL"},
219 {SC_RENDERSTATE
, D3DRS_SRCBLEND
, "D3DRS_SRCBLEND"},
220 {SC_RENDERSTATE
, D3DRS_DESTBLEND
, "D3DRS_DESTBLEND"},
221 {SC_RENDERSTATE
, D3DRS_CULLMODE
, "D3DRS_CULLMODE"},
222 {SC_RENDERSTATE
, D3DRS_ZFUNC
, "D3DRS_ZFUNC"},
223 {SC_RENDERSTATE
, D3DRS_ALPHAREF
, "D3DRS_ALPHAREF"},
224 {SC_RENDERSTATE
, D3DRS_ALPHAFUNC
, "D3DRS_ALPHAFUNC"},
225 {SC_RENDERSTATE
, D3DRS_DITHERENABLE
, "D3DRS_DITHERENABLE"},
226 {SC_RENDERSTATE
, D3DRS_ALPHABLENDENABLE
, "D3DRS_ALPHABLENDENABLE"},
227 {SC_RENDERSTATE
, D3DRS_FOGENABLE
, "D3DRS_FOGENABLE"},
228 {SC_RENDERSTATE
, D3DRS_SPECULARENABLE
, "D3DRS_SPECULARENABLE"},
229 {SC_RENDERSTATE
, D3DRS_FOGCOLOR
, "D3DRS_FOGCOLOR"}, /* 0x10 */
230 {SC_RENDERSTATE
, D3DRS_FOGTABLEMODE
, "D3DRS_FOGTABLEMODE"},
231 {SC_RENDERSTATE
, D3DRS_FOGSTART
, "D3DRS_FOGSTART"},
232 {SC_RENDERSTATE
, D3DRS_FOGEND
, "D3DRS_FOGEND"},
233 {SC_RENDERSTATE
, D3DRS_FOGDENSITY
, "D3DRS_FOGDENSITY"},
234 {SC_RENDERSTATE
, D3DRS_RANGEFOGENABLE
, "D3DRS_RANGEFOGENABLE"},
235 {SC_RENDERSTATE
, D3DRS_STENCILENABLE
, "D3DRS_STENCILENABLE"},
236 {SC_RENDERSTATE
, D3DRS_STENCILFAIL
, "D3DRS_STENCILFAIL"},
237 {SC_RENDERSTATE
, D3DRS_STENCILZFAIL
, "D3DRS_STENCILZFAIL"},
238 {SC_RENDERSTATE
, D3DRS_STENCILPASS
, "D3DRS_STENCILPASS"},
239 {SC_RENDERSTATE
, D3DRS_STENCILFUNC
, "D3DRS_STENCILFUNC"},
240 {SC_RENDERSTATE
, D3DRS_STENCILREF
, "D3DRS_STENCILREF"},
241 {SC_RENDERSTATE
, D3DRS_STENCILMASK
, "D3DRS_STENCILMASK"},
242 {SC_RENDERSTATE
, D3DRS_STENCILWRITEMASK
, "D3DRS_STENCILWRITEMASK"},
243 {SC_RENDERSTATE
, D3DRS_TEXTUREFACTOR
, "D3DRS_TEXTUREFACTOR"},
244 {SC_RENDERSTATE
, D3DRS_WRAP0
, "D3DRS_WRAP0"},
245 {SC_RENDERSTATE
, D3DRS_WRAP1
, "D3DRS_WRAP1"}, /* 0x20 */
246 {SC_RENDERSTATE
, D3DRS_WRAP2
, "D3DRS_WRAP2"},
247 {SC_RENDERSTATE
, D3DRS_WRAP3
, "D3DRS_WRAP3"},
248 {SC_RENDERSTATE
, D3DRS_WRAP4
, "D3DRS_WRAP4"},
249 {SC_RENDERSTATE
, D3DRS_WRAP5
, "D3DRS_WRAP5"},
250 {SC_RENDERSTATE
, D3DRS_WRAP6
, "D3DRS_WRAP6"},
251 {SC_RENDERSTATE
, D3DRS_WRAP7
, "D3DRS_WRAP7"},
252 {SC_RENDERSTATE
, D3DRS_WRAP8
, "D3DRS_WRAP8"},
253 {SC_RENDERSTATE
, D3DRS_WRAP9
, "D3DRS_WRAP9"},
254 {SC_RENDERSTATE
, D3DRS_WRAP10
, "D3DRS_WRAP10"},
255 {SC_RENDERSTATE
, D3DRS_WRAP11
, "D3DRS_WRAP11"},
256 {SC_RENDERSTATE
, D3DRS_WRAP12
, "D3DRS_WRAP12"},
257 {SC_RENDERSTATE
, D3DRS_WRAP13
, "D3DRS_WRAP13"},
258 {SC_RENDERSTATE
, D3DRS_WRAP14
, "D3DRS_WRAP14"},
259 {SC_RENDERSTATE
, D3DRS_WRAP15
, "D3DRS_WRAP15"},
260 {SC_RENDERSTATE
, D3DRS_CLIPPING
, "D3DRS_CLIPPING"},
261 {SC_RENDERSTATE
, D3DRS_LIGHTING
, "D3DRS_LIGHTING"}, /* 0x30 */
262 {SC_RENDERSTATE
, D3DRS_AMBIENT
, "D3DRS_AMBIENT"},
263 {SC_RENDERSTATE
, D3DRS_FOGVERTEXMODE
, "D3DRS_FOGVERTEXMODE"},
264 {SC_RENDERSTATE
, D3DRS_COLORVERTEX
, "D3DRS_COLORVERTEX"},
265 {SC_RENDERSTATE
, D3DRS_LOCALVIEWER
, "D3DRS_LOCALVIEWER"},
266 {SC_RENDERSTATE
, D3DRS_NORMALIZENORMALS
, "D3DRS_NORMALIZENORMALS"},
267 {SC_RENDERSTATE
, D3DRS_DIFFUSEMATERIALSOURCE
, "D3DRS_DIFFUSEMATERIALSOURCE"},
268 {SC_RENDERSTATE
, D3DRS_SPECULARMATERIALSOURCE
, "D3DRS_SPECULARMATERIALSOURCE"},
269 {SC_RENDERSTATE
, D3DRS_AMBIENTMATERIALSOURCE
, "D3DRS_AMBIENTMATERIALSOURCE"},
270 {SC_RENDERSTATE
, D3DRS_EMISSIVEMATERIALSOURCE
, "D3DRS_EMISSIVEMATERIALSOURCE"},
271 {SC_RENDERSTATE
, D3DRS_VERTEXBLEND
, "D3DRS_VERTEXBLEND"},
272 {SC_RENDERSTATE
, D3DRS_CLIPPLANEENABLE
, "D3DRS_CLIPPLANEENABLE"},
273 {SC_RENDERSTATE
, D3DRS_POINTSIZE
, "D3DRS_POINTSIZE"},
274 {SC_RENDERSTATE
, D3DRS_POINTSIZE_MIN
, "D3DRS_POINTSIZE_MIN"},
275 {SC_RENDERSTATE
, D3DRS_POINTSIZE_MAX
, "D3DRS_POINTSIZE_MAX"},
276 {SC_RENDERSTATE
, D3DRS_POINTSPRITEENABLE
, "D3DRS_POINTSPRITEENABLE"},
277 {SC_RENDERSTATE
, D3DRS_POINTSCALEENABLE
, "D3DRS_POINTSCALEENABLE"}, /* 0x40 */
278 {SC_RENDERSTATE
, D3DRS_POINTSCALE_A
, "D3DRS_POINTSCALE_A"},
279 {SC_RENDERSTATE
, D3DRS_POINTSCALE_B
, "D3DRS_POINTSCALE_B"},
280 {SC_RENDERSTATE
, D3DRS_POINTSCALE_C
, "D3DRS_POINTSCALE_C"},
281 {SC_RENDERSTATE
, D3DRS_MULTISAMPLEANTIALIAS
, "D3DRS_MULTISAMPLEANTIALIAS"},
282 {SC_RENDERSTATE
, D3DRS_MULTISAMPLEMASK
, "D3DRS_MULTISAMPLEMASK"},
283 {SC_RENDERSTATE
, D3DRS_PATCHEDGESTYLE
, "D3DRS_PATCHEDGESTYLE"},
284 {SC_RENDERSTATE
, D3DRS_DEBUGMONITORTOKEN
, "D3DRS_DEBUGMONITORTOKEN"},
285 {SC_RENDERSTATE
, D3DRS_INDEXEDVERTEXBLENDENABLE
, "D3DRS_INDEXEDVERTEXBLENDENABLE"},
286 {SC_RENDERSTATE
, D3DRS_COLORWRITEENABLE
, "D3DRS_COLORWRITEENABLE"},
287 {SC_RENDERSTATE
, D3DRS_TWEENFACTOR
, "D3DRS_TWEENFACTOR"},
288 {SC_RENDERSTATE
, D3DRS_BLENDOP
, "D3DRS_BLENDOP"},
289 {SC_RENDERSTATE
, D3DRS_POSITIONDEGREE
, "D3DRS_POSITIONDEGREE"},
290 {SC_RENDERSTATE
, D3DRS_NORMALDEGREE
, "D3DRS_NORMALDEGREE"},
291 {SC_RENDERSTATE
, D3DRS_SCISSORTESTENABLE
, "D3DRS_SCISSORTESTENABLE"},
292 {SC_RENDERSTATE
, D3DRS_SLOPESCALEDEPTHBIAS
, "D3DRS_SLOPESCALEDEPTHBIAS"},
293 {SC_RENDERSTATE
, D3DRS_ANTIALIASEDLINEENABLE
, "D3DRS_ANTIALIASEDLINEENABLE"}, /* 0x50 */
294 {SC_RENDERSTATE
, D3DRS_MINTESSELLATIONLEVEL
, "D3DRS_MINTESSELLATIONLEVEL"},
295 {SC_RENDERSTATE
, D3DRS_MAXTESSELLATIONLEVEL
, "D3DRS_MAXTESSELLATIONLEVEL"},
296 {SC_RENDERSTATE
, D3DRS_ADAPTIVETESS_X
, "D3DRS_ADAPTIVETESS_X"},
297 {SC_RENDERSTATE
, D3DRS_ADAPTIVETESS_Y
, "D3DRS_ADAPTIVETESS_Y"},
298 {SC_RENDERSTATE
, D3DRS_ADAPTIVETESS_Z
, "D3DRS_ADAPTIVETESS_Z"},
299 {SC_RENDERSTATE
, D3DRS_ADAPTIVETESS_W
, "D3DRS_ADAPTIVETESS_W"},
300 {SC_RENDERSTATE
, D3DRS_ENABLEADAPTIVETESSELLATION
, "D3DRS_ENABLEADAPTIVETESSELLATION"},
301 {SC_RENDERSTATE
, D3DRS_TWOSIDEDSTENCILMODE
, "D3DRS_TWOSIDEDSTENCILMODE"},
302 {SC_RENDERSTATE
, D3DRS_CCW_STENCILFAIL
, "D3DRS_CCW_STENCILFAIL"},
303 {SC_RENDERSTATE
, D3DRS_CCW_STENCILZFAIL
, "D3DRS_CCW_STENCILZFAIL"},
304 {SC_RENDERSTATE
, D3DRS_CCW_STENCILPASS
, "D3DRS_CCW_STENCILPASS"},
305 {SC_RENDERSTATE
, D3DRS_CCW_STENCILFUNC
, "D3DRS_CCW_STENCILFUNC"},
306 {SC_RENDERSTATE
, D3DRS_COLORWRITEENABLE1
, "D3DRS_COLORWRITEENABLE1"},
307 {SC_RENDERSTATE
, D3DRS_COLORWRITEENABLE2
, "D3DRS_COLORWRITEENABLE2"},
308 {SC_RENDERSTATE
, D3DRS_COLORWRITEENABLE3
, "D3DRS_COLORWRITEENABLE3"},
309 {SC_RENDERSTATE
, D3DRS_BLENDFACTOR
, "D3DRS_BLENDFACTOR"}, /* 0x60 */
310 {SC_RENDERSTATE
, D3DRS_SRGBWRITEENABLE
, "D3DRS_SRGBWRITEENABLE"},
311 {SC_RENDERSTATE
, D3DRS_DEPTHBIAS
, "D3DRS_DEPTHBIAS"},
312 {SC_RENDERSTATE
, D3DRS_SEPARATEALPHABLENDENABLE
, "D3DRS_SEPARATEALPHABLENDENABLE"},
313 {SC_RENDERSTATE
, D3DRS_SRCBLENDALPHA
, "D3DRS_SRCBLENDALPHA"},
314 {SC_RENDERSTATE
, D3DRS_DESTBLENDALPHA
, "D3DRS_DESTBLENDALPHA"},
315 {SC_RENDERSTATE
, D3DRS_BLENDOPALPHA
, "D3DRS_BLENDOPALPHA"},
317 {SC_TEXTURESTAGE
, D3DTSS_COLOROP
, "D3DTSS_COLOROP"},
318 {SC_TEXTURESTAGE
, D3DTSS_COLORARG0
, "D3DTSS_COLORARG0"},
319 {SC_TEXTURESTAGE
, D3DTSS_COLORARG1
, "D3DTSS_COLORARG1"},
320 {SC_TEXTURESTAGE
, D3DTSS_COLORARG2
, "D3DTSS_COLORARG2"},
321 {SC_TEXTURESTAGE
, D3DTSS_ALPHAOP
, "D3DTSS_ALPHAOP"},
322 {SC_TEXTURESTAGE
, D3DTSS_ALPHAARG0
, "D3DTSS_ALPHAARG0"},
323 {SC_TEXTURESTAGE
, D3DTSS_ALPHAARG1
, "D3DTSS_ALPHAARG1"},
324 {SC_TEXTURESTAGE
, D3DTSS_ALPHAARG2
, "D3DTSS_ALPHAARG2"},
325 {SC_TEXTURESTAGE
, D3DTSS_RESULTARG
, "D3DTSS_RESULTARG"},
326 {SC_TEXTURESTAGE
, D3DTSS_BUMPENVMAT00
, "D3DTSS_BUMPENVMAT00"}, /* 0x70 */
327 {SC_TEXTURESTAGE
, D3DTSS_BUMPENVMAT01
, "D3DTSS_BUMPENVMAT01"},
328 {SC_TEXTURESTAGE
, D3DTSS_BUMPENVMAT10
, "D3DTSS_BUMPENVMAT10"},
329 {SC_TEXTURESTAGE
, D3DTSS_BUMPENVMAT11
, "D3DTSS_BUMPENVMAT11"},
330 {SC_TEXTURESTAGE
, D3DTSS_TEXCOORDINDEX
, "D3DTSS_TEXCOORDINDEX"},
331 {SC_TEXTURESTAGE
, D3DTSS_BUMPENVLSCALE
, "D3DTSS_BUMPENVLSCALE"},
332 {SC_TEXTURESTAGE
, D3DTSS_BUMPENVLOFFSET
, "D3DTSS_BUMPENVLOFFSET"},
333 {SC_TEXTURESTAGE
, D3DTSS_TEXTURETRANSFORMFLAGS
, "D3DTSS_TEXTURETRANSFORMFLAGS"},
334 {SC_TEXTURESTAGE
, D3DTSS_CONSTANT
, "D3DTSS_CONSTANT"},
336 {SC_NPATCHMODE
, 0, "NPatchMode"},
340 {SC_TRANSFORM
, D3DTS_PROJECTION
, "D3DTS_PROJECTION"},
341 {SC_TRANSFORM
, D3DTS_VIEW
, "D3DTS_VIEW"},
342 {SC_TRANSFORM
, D3DTS_WORLD
, "D3DTS_WORLD"},
343 {SC_TRANSFORM
, D3DTS_TEXTURE0
, "D3DTS_TEXTURE0"},
345 {SC_MATERIAL
, MT_DIFFUSE
, "MaterialDiffuse"},
346 {SC_MATERIAL
, MT_AMBIENT
, "MaterialAmbient"}, /* 0x80 */
347 {SC_MATERIAL
, MT_SPECULAR
, "MaterialSpecular"},
348 {SC_MATERIAL
, MT_EMISSIVE
, "MaterialEmissive"},
349 {SC_MATERIAL
, MT_POWER
, "MaterialPower"},
351 {SC_LIGHT
, LT_TYPE
, "LightType"},
352 {SC_LIGHT
, LT_DIFFUSE
, "LightDiffuse"},
353 {SC_LIGHT
, LT_SPECULAR
, "LightSpecular"},
354 {SC_LIGHT
, LT_AMBIENT
, "LightAmbient"},
355 {SC_LIGHT
, LT_POSITION
, "LightPosition"},
356 {SC_LIGHT
, LT_DIRECTION
, "LightDirection"},
357 {SC_LIGHT
, LT_RANGE
, "LightRange"},
358 {SC_LIGHT
, LT_FALLOFF
, "LightFallOff"},
359 {SC_LIGHT
, LT_ATTENUATION0
, "LightAttenuation0"},
360 {SC_LIGHT
, LT_ATTENUATION1
, "LightAttenuation1"},
361 {SC_LIGHT
, LT_ATTENUATION2
, "LightAttenuation2"},
362 {SC_LIGHT
, LT_THETA
, "LightTheta"},
363 {SC_LIGHT
, LT_PHI
, "LightPhi"}, /* 0x90 */
365 {SC_LIGHTENABLE
, 0, "LightEnable"},
367 {SC_VERTEXSHADER
, 0, "Vertexshader"},
369 {SC_PIXELSHADER
, 0, "Pixelshader"},
370 /* Shader constants */
371 {SC_SHADERCONST
, SCT_VSFLOAT
, "VertexShaderConstantF"},
372 {SC_SHADERCONST
, SCT_VSBOOL
, "VertexShaderConstantB"},
373 {SC_SHADERCONST
, SCT_VSINT
, "VertexShaderConstantI"},
374 {SC_SHADERCONST
, SCT_VSFLOAT
, "VertexShaderConstant"},
375 {SC_SHADERCONST
, SCT_VSFLOAT
, "VertexShaderConstant1"},
376 {SC_SHADERCONST
, SCT_VSFLOAT
, "VertexShaderConstant2"},
377 {SC_SHADERCONST
, SCT_VSFLOAT
, "VertexShaderConstant3"},
378 {SC_SHADERCONST
, SCT_VSFLOAT
, "VertexShaderConstant4"},
379 {SC_SHADERCONST
, SCT_PSFLOAT
, "PixelShaderConstantF"},
380 {SC_SHADERCONST
, SCT_PSBOOL
, "PixelShaderConstantB"},
381 {SC_SHADERCONST
, SCT_PSINT
, "PixelShaderConstantI"},
382 {SC_SHADERCONST
, SCT_PSFLOAT
, "PixelShaderConstant"},
383 {SC_SHADERCONST
, SCT_PSFLOAT
, "PixelShaderConstant1"}, /* 0xa0 */
384 {SC_SHADERCONST
, SCT_PSFLOAT
, "PixelShaderConstant2"},
385 {SC_SHADERCONST
, SCT_PSFLOAT
, "PixelShaderConstant3"},
386 {SC_SHADERCONST
, SCT_PSFLOAT
, "PixelShaderConstant4"},
388 {SC_TEXTURE
, 0, "Texture"},
390 {SC_SAMPLERSTATE
, D3DSAMP_ADDRESSU
, "AddressU"},
391 {SC_SAMPLERSTATE
, D3DSAMP_ADDRESSV
, "AddressV"},
392 {SC_SAMPLERSTATE
, D3DSAMP_ADDRESSW
, "AddressW"},
393 {SC_SAMPLERSTATE
, D3DSAMP_BORDERCOLOR
, "BorderColor"},
394 {SC_SAMPLERSTATE
, D3DSAMP_MAGFILTER
, "MagFilter"},
395 {SC_SAMPLERSTATE
, D3DSAMP_MINFILTER
, "MinFilter"},
396 {SC_SAMPLERSTATE
, D3DSAMP_MIPFILTER
, "MipFilter"},
397 {SC_SAMPLERSTATE
, D3DSAMP_MIPMAPLODBIAS
, "MipMapLodBias"},
398 {SC_SAMPLERSTATE
, D3DSAMP_MAXMIPLEVEL
, "MaxMipLevel"},
399 {SC_SAMPLERSTATE
, D3DSAMP_MAXANISOTROPY
, "MaxAnisotropy"},
400 {SC_SAMPLERSTATE
, D3DSAMP_SRGBTEXTURE
, "SRGBTexture"},
401 {SC_SAMPLERSTATE
, D3DSAMP_ELEMENTINDEX
, "ElementIndex"}, /* 0xb0 */
402 {SC_SAMPLERSTATE
, D3DSAMP_DMAPOFFSET
, "DMAPOffset"},
404 {SC_SETSAMPLER
, 0, "Sampler"},
407 static inline void read_dword(const char **ptr
, DWORD
*d
)
409 memcpy(d
, *ptr
, sizeof(*d
));
413 static void skip_dword_unknown(const char **ptr
, unsigned int count
)
418 FIXME("Skipping %u unknown DWORDs:\n", count
);
419 for (i
= 0; i
< count
; ++i
)
422 FIXME("\t0x%08x\n", d
);
426 static inline D3DXHANDLE
get_parameter_handle(struct d3dx_parameter
*parameter
)
428 return (D3DXHANDLE
) parameter
;
431 static inline D3DXHANDLE
get_technique_handle(struct d3dx_technique
*technique
)
433 return (D3DXHANDLE
) technique
;
436 static inline D3DXHANDLE
get_pass_handle(struct d3dx_pass
*pass
)
438 return (D3DXHANDLE
) pass
;
441 static struct d3dx_technique
*get_technique_by_name(struct d3dx9_base_effect
*base
, const char *name
)
445 if (!name
) return NULL
;
447 for (i
= 0; i
< base
->technique_count
; ++i
)
449 if (!strcmp(base
->techniques
[i
].name
, name
))
450 return &base
->techniques
[i
];
456 static struct d3dx_technique
*get_valid_technique(struct d3dx9_base_effect
*base
, D3DXHANDLE technique
)
460 for (i
= 0; i
< base
->technique_count
; ++i
)
462 if (get_technique_handle(&base
->techniques
[i
]) == technique
)
463 return &base
->techniques
[i
];
466 return get_technique_by_name(base
, technique
);
469 static struct d3dx_pass
*get_valid_pass(struct d3dx9_base_effect
*base
, D3DXHANDLE pass
)
473 for (i
= 0; i
< base
->technique_count
; ++i
)
475 struct d3dx_technique
*technique
= &base
->techniques
[i
];
477 for (k
= 0; k
< technique
->pass_count
; ++k
)
479 if (get_pass_handle(&technique
->passes
[k
]) == pass
)
480 return &technique
->passes
[k
];
487 static struct d3dx_parameter
*get_valid_sub_parameter(struct d3dx_parameter
*param
, D3DXHANDLE parameter
)
489 unsigned int i
, count
;
490 struct d3dx_parameter
*p
;
492 for (i
= 0; i
< param
->annotation_count
; ++i
)
494 if (get_parameter_handle(¶m
->annotations
[i
]) == parameter
)
495 return ¶m
->annotations
[i
];
497 p
= get_valid_sub_parameter(¶m
->annotations
[i
], parameter
);
501 count
= param
->element_count
? param
->element_count
: param
->member_count
;
502 for (i
= 0; i
< count
; ++i
)
504 if (get_parameter_handle(¶m
->members
[i
]) == parameter
)
505 return ¶m
->members
[i
];
507 p
= get_valid_sub_parameter(¶m
->members
[i
], parameter
);
514 static struct d3dx_parameter
*get_valid_parameter(struct d3dx9_base_effect
*base
, D3DXHANDLE parameter
)
516 unsigned int i
, k
, m
;
517 struct d3dx_parameter
*p
;
519 for (i
= 0; i
< base
->parameter_count
; ++i
)
521 if (get_parameter_handle(&base
->parameters
[i
]) == parameter
)
522 return &base
->parameters
[i
];
524 p
= get_valid_sub_parameter(&base
->parameters
[i
], parameter
);
528 for (i
= 0; i
< base
->technique_count
; ++i
)
530 struct d3dx_technique
*technique
= &base
->techniques
[i
];
532 for (k
= 0; k
< technique
->pass_count
; ++k
)
534 struct d3dx_pass
*pass
= &technique
->passes
[k
];
536 for (m
= 0; m
< pass
->annotation_count
; ++m
)
538 if (get_parameter_handle(&pass
->annotations
[m
]) == parameter
)
539 return &pass
->annotations
[m
];
541 p
= get_valid_sub_parameter(&pass
->annotations
[m
], parameter
);
546 for (k
= 0; k
< technique
->annotation_count
; ++k
)
548 if (get_parameter_handle(&technique
->annotations
[k
]) == parameter
)
549 return &technique
->annotations
[k
];
551 p
= get_valid_sub_parameter(&technique
->annotations
[k
], parameter
);
556 return get_parameter_by_name(base
, NULL
, parameter
);
559 static void free_state(struct d3dx_state
*state
)
561 free_parameter(state
->parameter
, FALSE
, FALSE
);
562 HeapFree(GetProcessHeap(), 0, state
->parameter
);
565 static void free_object(struct d3dx_object
*object
)
567 HeapFree(GetProcessHeap(), 0, object
->data
);
570 static void free_sampler(struct d3dx_sampler
*sampler
)
574 for (i
= 0; i
< sampler
->state_count
; ++i
)
576 free_state(&sampler
->states
[i
]);
578 HeapFree(GetProcessHeap(), 0, sampler
->states
);
581 static void free_parameter(struct d3dx_parameter
*param
, BOOL element
, BOOL child
)
585 TRACE("Free parameter %p, name %s, type %s, child %s\n", param
, param
->name
,
586 debug_d3dxparameter_type(param
->type
), child
? "yes" : "no");
591 if (param
->annotations
)
593 for (i
= 0; i
< param
->annotation_count
; ++i
)
594 free_parameter(¶m
->annotations
[i
], FALSE
, FALSE
);
595 HeapFree(GetProcessHeap(), 0, param
->annotations
);
596 param
->annotations
= NULL
;
601 unsigned int count
= param
->element_count
? param
->element_count
: param
->member_count
;
603 for (i
= 0; i
< count
; ++i
)
604 free_parameter(¶m
->members
[i
], param
->element_count
!= 0, TRUE
);
605 HeapFree(GetProcessHeap(), 0, param
->members
);
606 param
->members
= NULL
;
609 if (param
->class == D3DXPC_OBJECT
&& !param
->element_count
)
617 case D3DXPT_TEXTURE1D
:
618 case D3DXPT_TEXTURE2D
:
619 case D3DXPT_TEXTURE3D
:
620 case D3DXPT_TEXTURECUBE
:
621 case D3DXPT_PIXELSHADER
:
622 case D3DXPT_VERTEXSHADER
:
623 if (*(IUnknown
**)param
->data
) IUnknown_Release(*(IUnknown
**)param
->data
);
627 case D3DXPT_SAMPLER1D
:
628 case D3DXPT_SAMPLER2D
:
629 case D3DXPT_SAMPLER3D
:
630 case D3DXPT_SAMPLERCUBE
:
631 free_sampler((struct d3dx_sampler
*)param
->data
);
635 FIXME("Unhandled type %s\n", debug_d3dxparameter_type(param
->type
));
642 HeapFree(GetProcessHeap(), 0, param
->data
);
645 /* only the parent has to release name and semantic */
648 HeapFree(GetProcessHeap(), 0, param
->name
);
649 HeapFree(GetProcessHeap(), 0, param
->semantic
);
653 static void free_pass(struct d3dx_pass
*pass
)
657 TRACE("Free pass %p\n", pass
);
662 if (pass
->annotations
)
664 for (i
= 0; i
< pass
->annotation_count
; ++i
)
665 free_parameter(&pass
->annotations
[i
], FALSE
, FALSE
);
666 HeapFree(GetProcessHeap(), 0, pass
->annotations
);
667 pass
->annotations
= NULL
;
672 for (i
= 0; i
< pass
->state_count
; ++i
)
673 free_state(&pass
->states
[i
]);
674 HeapFree(GetProcessHeap(), 0, pass
->states
);
678 HeapFree(GetProcessHeap(), 0, pass
->name
);
682 static void free_technique(struct d3dx_technique
*technique
)
686 TRACE("Free technique %p\n", technique
);
691 if (technique
->annotations
)
693 for (i
= 0; i
< technique
->annotation_count
; ++i
)
694 free_parameter(&technique
->annotations
[i
], FALSE
, FALSE
);
695 HeapFree(GetProcessHeap(), 0, technique
->annotations
);
696 technique
->annotations
= NULL
;
699 if (technique
->passes
)
701 for (i
= 0; i
< technique
->pass_count
; ++i
)
702 free_pass(&technique
->passes
[i
]);
703 HeapFree(GetProcessHeap(), 0, technique
->passes
);
704 technique
->passes
= NULL
;
707 HeapFree(GetProcessHeap(), 0, technique
->name
);
708 technique
->name
= NULL
;
711 static void d3dx9_base_effect_cleanup(struct d3dx9_base_effect
*base
)
715 TRACE("base %p.\n", base
);
717 if (base
->parameters
)
719 for (i
= 0; i
< base
->parameter_count
; ++i
)
720 free_parameter(&base
->parameters
[i
], FALSE
, FALSE
);
721 HeapFree(GetProcessHeap(), 0, base
->parameters
);
722 base
->parameters
= NULL
;
725 if (base
->techniques
)
727 for (i
= 0; i
< base
->technique_count
; ++i
)
728 free_technique(&base
->techniques
[i
]);
729 HeapFree(GetProcessHeap(), 0, base
->techniques
);
730 base
->techniques
= NULL
;
735 for (i
= 0; i
< base
->object_count
; ++i
)
737 free_object(&base
->objects
[i
]);
739 HeapFree(GetProcessHeap(), 0, base
->objects
);
740 base
->objects
= NULL
;
744 static void free_effect(struct ID3DXEffectImpl
*effect
)
746 TRACE("Free effect %p\n", effect
);
748 d3dx9_base_effect_cleanup(&effect
->base_effect
);
752 effect
->pool
->lpVtbl
->Release(effect
->pool
);
757 IUnknown_Release(effect
->manager
);
760 IDirect3DDevice9_Release(effect
->device
);
763 static void free_effect_compiler(struct ID3DXEffectCompilerImpl
*compiler
)
765 TRACE("Free effect compiler %p\n", compiler
);
767 d3dx9_base_effect_cleanup(&compiler
->base_effect
);
770 static void get_vector(struct d3dx_parameter
*param
, D3DXVECTOR4
*vector
)
774 for (i
= 0; i
< 4; ++i
)
776 if (i
< param
->columns
)
777 set_number((FLOAT
*)vector
+ i
, D3DXPT_FLOAT
, (DWORD
*)param
->data
+ i
, param
->type
);
779 ((FLOAT
*)vector
)[i
] = 0.0f
;
783 static void set_vector(struct d3dx_parameter
*param
, const D3DXVECTOR4
*vector
)
787 for (i
= 0; i
< param
->columns
; ++i
)
789 set_number((FLOAT
*)param
->data
+ i
, param
->type
, (FLOAT
*)vector
+ i
, D3DXPT_FLOAT
);
793 static void get_matrix(struct d3dx_parameter
*param
, D3DXMATRIX
*matrix
, BOOL transpose
)
797 for (i
= 0; i
< 4; ++i
)
799 for (k
= 0; k
< 4; ++k
)
801 FLOAT
*tmp
= transpose
? (FLOAT
*)&matrix
->u
.m
[k
][i
] : (FLOAT
*)&matrix
->u
.m
[i
][k
];
803 if ((i
< param
->rows
) && (k
< param
->columns
))
804 set_number(tmp
, D3DXPT_FLOAT
, (DWORD
*)param
->data
+ i
* param
->columns
+ k
, param
->type
);
811 static void set_matrix(struct d3dx_parameter
*param
, const D3DXMATRIX
*matrix
, BOOL transpose
)
815 for (i
= 0; i
< param
->rows
; ++i
)
817 for (k
= 0; k
< param
->columns
; ++k
)
819 set_number((FLOAT
*)param
->data
+ i
* param
->columns
+ k
, param
->type
,
820 transpose
? &matrix
->u
.m
[k
][i
] : &matrix
->u
.m
[i
][k
], D3DXPT_FLOAT
);
825 static struct d3dx_parameter
*get_parameter_element_by_name(struct d3dx_parameter
*parameter
, const char *name
)
828 struct d3dx_parameter
*temp_parameter
;
831 TRACE("parameter %p, name %s\n", parameter
, debugstr_a(name
));
833 if (!name
|| !*name
) return NULL
;
835 element
= atoi(name
);
836 part
= strchr(name
, ']') + 1;
838 /* check for empty [] && element range */
839 if ((part
- name
) > 1 && parameter
->element_count
> element
)
841 temp_parameter
= ¶meter
->members
[element
];
846 return get_parameter_by_name(NULL
, temp_parameter
, part
);
849 return get_annotation_by_name(temp_parameter
->annotation_count
, temp_parameter
->annotations
, part
);
852 TRACE("Returning parameter %p\n", temp_parameter
);
853 return temp_parameter
;
856 FIXME("Unhandled case \"%c\"\n", *--part
);
861 TRACE("Parameter not found\n");
865 static struct d3dx_parameter
*get_annotation_by_name(UINT count
, struct d3dx_parameter
*annotations
,
869 struct d3dx_parameter
*temp_parameter
;
872 TRACE("count %u, annotations %p, name %s\n", count
, annotations
, debugstr_a(name
));
874 if (!name
|| !*name
) return NULL
;
876 length
= strcspn( name
, "[.@" );
877 part
= name
+ length
;
879 for (i
= 0; i
< count
; ++i
)
881 temp_parameter
= &annotations
[i
];
883 if (!strcmp(temp_parameter
->name
, name
))
885 TRACE("Returning annotation %p\n", temp_parameter
);
886 return temp_parameter
;
888 else if (strlen(temp_parameter
->name
) == length
&& !strncmp(temp_parameter
->name
, name
, length
))
893 return get_parameter_by_name(NULL
, temp_parameter
, part
);
896 return get_parameter_element_by_name(temp_parameter
, part
);
899 FIXME("Unhandled case \"%c\"\n", *--part
);
905 TRACE("Annotation not found\n");
909 static struct d3dx_parameter
*get_parameter_by_name(struct d3dx9_base_effect
*base
,
910 struct d3dx_parameter
*parameter
, const char *name
)
912 UINT i
, count
, length
;
913 struct d3dx_parameter
*temp_parameter
;
914 struct d3dx_parameter
*parameters
;
917 TRACE("base %p, parameter %p, name %s\n", base
, parameter
, debugstr_a(name
));
919 if (!name
|| !*name
) return NULL
;
923 count
= base
->parameter_count
;
924 parameters
= base
->parameters
;
928 count
= parameter
->member_count
;
929 parameters
= parameter
->members
;
932 length
= strcspn( name
, "[.@" );
933 part
= name
+ length
;
935 for (i
= 0; i
< count
; i
++)
937 temp_parameter
= ¶meters
[i
];
939 if (!strcmp(temp_parameter
->name
, name
))
941 TRACE("Returning parameter %p\n", temp_parameter
);
942 return temp_parameter
;
944 else if (strlen(temp_parameter
->name
) == length
&& !strncmp(temp_parameter
->name
, name
, length
))
949 return get_parameter_by_name(NULL
, temp_parameter
, part
);
952 return get_annotation_by_name(temp_parameter
->annotation_count
, temp_parameter
->annotations
, part
);
955 return get_parameter_element_by_name(temp_parameter
, part
);
958 FIXME("Unhandled case \"%c\"\n", *--part
);
964 TRACE("Parameter not found\n");
968 static inline DWORD
d3dx9_effect_version(DWORD major
, DWORD minor
)
970 return (0xfeff0000 | ((major
) << 8) | (minor
));
973 static HRESULT
d3dx9_base_effect_get_desc(struct d3dx9_base_effect
*base
, D3DXEFFECT_DESC
*desc
)
977 WARN("Invalid argument specified.\n");
978 return D3DERR_INVALIDCALL
;
981 FIXME("partial stub!\n");
983 /* TODO: add creator and function count. */
984 desc
->Creator
= NULL
;
986 desc
->Parameters
= base
->parameter_count
;
987 desc
->Techniques
= base
->technique_count
;
992 static HRESULT
d3dx9_base_effect_get_parameter_desc(struct d3dx9_base_effect
*base
,
993 D3DXHANDLE parameter
, D3DXPARAMETER_DESC
*desc
)
995 struct d3dx_parameter
*param
= get_valid_parameter(base
, parameter
);
999 WARN("Invalid argument specified.\n");
1000 return D3DERR_INVALIDCALL
;
1003 desc
->Name
= param
->name
;
1004 desc
->Semantic
= param
->semantic
;
1005 desc
->Class
= param
->class;
1006 desc
->Type
= param
->type
;
1007 desc
->Rows
= param
->rows
;
1008 desc
->Columns
= param
->columns
;
1009 desc
->Elements
= param
->element_count
;
1010 desc
->Annotations
= param
->annotation_count
;
1011 desc
->StructMembers
= param
->member_count
;
1012 desc
->Flags
= param
->flags
;
1013 desc
->Bytes
= param
->bytes
;
1018 static HRESULT
d3dx9_base_effect_get_technique_desc(struct d3dx9_base_effect
*base
,
1019 D3DXHANDLE technique
, D3DXTECHNIQUE_DESC
*desc
)
1021 struct d3dx_technique
*tech
= technique
? get_valid_technique(base
, technique
) : &base
->techniques
[0];
1025 WARN("Invalid argument specified.\n");
1026 return D3DERR_INVALIDCALL
;
1029 desc
->Name
= tech
->name
;
1030 desc
->Passes
= tech
->pass_count
;
1031 desc
->Annotations
= tech
->annotation_count
;
1036 static HRESULT
d3dx9_base_effect_get_pass_desc(struct d3dx9_base_effect
*base
,
1037 D3DXHANDLE pass
, D3DXPASS_DESC
*desc
)
1039 struct d3dx_pass
*p
= get_valid_pass(base
, pass
);
1043 WARN("Invalid argument specified.\n");
1044 return D3DERR_INVALIDCALL
;
1047 desc
->Name
= p
->name
;
1048 desc
->Annotations
= p
->annotation_count
;
1050 FIXME("Pixel shader and vertex shader are not supported, yet.\n");
1051 desc
->pVertexShaderFunction
= NULL
;
1052 desc
->pPixelShaderFunction
= NULL
;
1057 static HRESULT
d3dx9_base_effect_get_function_desc(struct d3dx9_base_effect
*base
,
1058 D3DXHANDLE shader
, D3DXFUNCTION_DESC
*desc
)
1065 static D3DXHANDLE
d3dx9_base_effect_get_parameter(struct d3dx9_base_effect
*base
,
1066 D3DXHANDLE parameter
, UINT index
)
1068 struct d3dx_parameter
*param
= get_valid_parameter(base
, parameter
);
1072 if (index
< base
->parameter_count
)
1074 TRACE("Returning parameter %p.\n", &base
->parameters
[index
]);
1075 return get_parameter_handle(&base
->parameters
[index
]);
1080 if (param
&& !param
->element_count
&& index
< param
->member_count
)
1082 TRACE("Returning parameter %p.\n", ¶m
->members
[index
]);
1083 return get_parameter_handle(¶m
->members
[index
]);
1087 WARN("Invalid argument specified.\n");
1092 static D3DXHANDLE
d3dx9_base_effect_get_parameter_by_name(struct d3dx9_base_effect
*base
,
1093 D3DXHANDLE parameter
, const char *name
)
1095 struct d3dx_parameter
*param
= get_valid_parameter(base
, parameter
);
1100 handle
= get_parameter_handle(param
);
1101 TRACE("Returning parameter %p.\n", handle
);
1105 handle
= get_parameter_handle(get_parameter_by_name(base
, param
, name
));
1106 TRACE("Returning parameter %p.\n", handle
);
1111 static D3DXHANDLE
d3dx9_base_effect_get_parameter_by_semantic(struct d3dx9_base_effect
*base
,
1112 D3DXHANDLE parameter
, const char *semantic
)
1114 struct d3dx_parameter
*param
= get_valid_parameter(base
, parameter
);
1115 struct d3dx_parameter
*temp_param
;
1120 for (i
= 0; i
< base
->parameter_count
; ++i
)
1122 temp_param
= &base
->parameters
[i
];
1124 if (!temp_param
->semantic
)
1128 TRACE("Returning parameter %p\n", temp_param
);
1129 return get_parameter_handle(temp_param
);
1134 if (!strcasecmp(temp_param
->semantic
, semantic
))
1136 TRACE("Returning parameter %p\n", temp_param
);
1137 return get_parameter_handle(temp_param
);
1143 for (i
= 0; i
< param
->member_count
; ++i
)
1145 temp_param
= ¶m
->members
[i
];
1147 if (!temp_param
->semantic
)
1151 TRACE("Returning parameter %p\n", temp_param
);
1152 return get_parameter_handle(temp_param
);
1157 if (!strcasecmp(temp_param
->semantic
, semantic
))
1159 TRACE("Returning parameter %p\n", temp_param
);
1160 return get_parameter_handle(temp_param
);
1165 WARN("Invalid argument specified\n");
1170 static D3DXHANDLE
d3dx9_base_effect_get_parameter_element(struct d3dx9_base_effect
*base
,
1171 D3DXHANDLE parameter
, UINT index
)
1173 struct d3dx_parameter
*param
= get_valid_parameter(base
, parameter
);
1177 if (index
< base
->parameter_count
)
1179 TRACE("Returning parameter %p.\n", &base
->parameters
[index
]);
1180 return get_parameter_handle(&base
->parameters
[index
]);
1185 if (index
< param
->element_count
)
1187 TRACE("Returning parameter %p.\n", ¶m
->members
[index
]);
1188 return get_parameter_handle(¶m
->members
[index
]);
1192 WARN("Invalid argument specified\n");
1197 static D3DXHANDLE
d3dx9_base_effect_get_technique(struct d3dx9_base_effect
*base
, UINT index
)
1199 if (index
>= base
->technique_count
)
1201 WARN("Invalid argument specified.\n");
1205 TRACE("Returning technique %p.\n", &base
->techniques
[index
]);
1207 return get_technique_handle(&base
->techniques
[index
]);
1210 static D3DXHANDLE
d3dx9_base_effect_get_technique_by_name(struct d3dx9_base_effect
*base
, const char *name
)
1212 struct d3dx_technique
*tech
= get_technique_by_name(base
, name
);
1216 D3DXHANDLE t
= get_technique_handle(tech
);
1217 TRACE("Returning technique %p\n", t
);
1221 WARN("Invalid argument specified.\n");
1226 static D3DXHANDLE
d3dx9_base_effect_get_pass(struct d3dx9_base_effect
*base
,
1227 D3DXHANDLE technique
, UINT index
)
1229 struct d3dx_technique
*tech
= get_valid_technique(base
, technique
);
1231 if (tech
&& index
< tech
->pass_count
)
1233 TRACE("Returning pass %p\n", &tech
->passes
[index
]);
1234 return get_pass_handle(&tech
->passes
[index
]);
1237 WARN("Invalid argument specified.\n");
1242 static D3DXHANDLE
d3dx9_base_effect_get_pass_by_name(struct d3dx9_base_effect
*base
,
1243 D3DXHANDLE technique
, const char *name
)
1245 struct d3dx_technique
*tech
= get_valid_technique(base
, technique
);
1251 for (i
= 0; i
< tech
->pass_count
; ++i
)
1253 struct d3dx_pass
*pass
= &tech
->passes
[i
];
1255 if (!strcmp(pass
->name
, name
))
1257 TRACE("Returning pass %p\n", pass
);
1258 return get_pass_handle(pass
);
1263 WARN("Invalid argument specified.\n");
1268 static D3DXHANDLE
d3dx9_base_effect_get_function(struct d3dx9_base_effect
*base
, UINT index
)
1275 static D3DXHANDLE
d3dx9_base_effect_get_function_by_name(struct d3dx9_base_effect
*base
, const char *name
)
1282 static UINT
get_annotation_from_object(struct d3dx9_base_effect
*base
,
1283 D3DXHANDLE object
, struct d3dx_parameter
**annotations
)
1285 struct d3dx_parameter
*param
= get_valid_parameter(base
, object
);
1286 struct d3dx_pass
*pass
= get_valid_pass(base
, object
);
1287 struct d3dx_technique
*technique
= get_valid_technique(base
, object
);
1291 *annotations
= pass
->annotations
;
1292 return pass
->annotation_count
;
1296 *annotations
= technique
->annotations
;
1297 return technique
->annotation_count
;
1301 *annotations
= param
->annotations
;
1302 return param
->annotation_count
;
1306 FIXME("Functions are not handled, yet!\n");
1311 static D3DXHANDLE
d3dx9_base_effect_get_annotation(struct d3dx9_base_effect
*base
,
1312 D3DXHANDLE object
, UINT index
)
1314 struct d3dx_parameter
*annotations
= NULL
;
1315 UINT annotation_count
= 0;
1317 annotation_count
= get_annotation_from_object(base
, object
, &annotations
);
1319 if (index
< annotation_count
)
1321 TRACE("Returning parameter %p\n", &annotations
[index
]);
1322 return get_parameter_handle(&annotations
[index
]);
1325 WARN("Invalid argument specified\n");
1330 static D3DXHANDLE
d3dx9_base_effect_get_annotation_by_name(struct d3dx9_base_effect
*base
,
1331 D3DXHANDLE object
, const char *name
)
1333 struct d3dx_parameter
*annotation
= NULL
;
1334 struct d3dx_parameter
*annotations
= NULL
;
1335 UINT annotation_count
= 0;
1339 WARN("Invalid argument specified\n");
1343 annotation_count
= get_annotation_from_object(base
, object
, &annotations
);
1345 annotation
= get_annotation_by_name(annotation_count
, annotations
, name
);
1348 TRACE("Returning parameter %p\n", annotation
);
1349 return get_parameter_handle(annotation
);
1352 WARN("Invalid argument specified\n");
1357 static HRESULT
d3dx9_base_effect_set_value(struct d3dx9_base_effect
*base
,
1358 D3DXHANDLE parameter
, const void *data
, UINT bytes
)
1360 struct d3dx_parameter
*param
= get_valid_parameter(base
, parameter
);
1364 WARN("Invalid parameter %p specified\n", parameter
);
1365 return D3DERR_INVALIDCALL
;
1368 /* samplers don't touch data */
1369 if (param
->class == D3DXPC_OBJECT
&& (param
->type
== D3DXPT_SAMPLER
1370 || param
->type
== D3DXPT_SAMPLER1D
|| param
->type
== D3DXPT_SAMPLER2D
1371 || param
->type
== D3DXPT_SAMPLER3D
|| param
->type
== D3DXPT_SAMPLERCUBE
))
1373 TRACE("Sampler: returning E_FAIL\n");
1377 if (data
&& param
->bytes
<= bytes
)
1379 switch (param
->type
)
1385 TRACE("Copy %u bytes\n", param
->bytes
);
1386 memcpy(param
->data
, data
, param
->bytes
);
1390 FIXME("Unhandled type %s\n", debug_d3dxparameter_type(param
->type
));
1397 WARN("Invalid argument specified\n");
1399 return D3DERR_INVALIDCALL
;
1402 static HRESULT
d3dx9_base_effect_get_value(struct d3dx9_base_effect
*base
,
1403 D3DXHANDLE parameter
, void *data
, UINT bytes
)
1405 struct d3dx_parameter
*param
= get_valid_parameter(base
, parameter
);
1409 WARN("Invalid parameter %p specified\n", parameter
);
1410 return D3DERR_INVALIDCALL
;
1413 /* samplers don't touch data */
1414 if (param
->class == D3DXPC_OBJECT
&& (param
->type
== D3DXPT_SAMPLER
1415 || param
->type
== D3DXPT_SAMPLER1D
|| param
->type
== D3DXPT_SAMPLER2D
1416 || param
->type
== D3DXPT_SAMPLER3D
|| param
->type
== D3DXPT_SAMPLERCUBE
))
1418 TRACE("Sampler: returning E_FAIL\n");
1422 if (data
&& param
->bytes
<= bytes
)
1424 TRACE("Type %s\n", debug_d3dxparameter_type(param
->type
));
1426 switch (param
->type
)
1435 case D3DXPT_VERTEXSHADER
:
1436 case D3DXPT_PIXELSHADER
:
1437 case D3DXPT_TEXTURE
:
1438 case D3DXPT_TEXTURE1D
:
1439 case D3DXPT_TEXTURE2D
:
1440 case D3DXPT_TEXTURE3D
:
1441 case D3DXPT_TEXTURECUBE
:
1445 for (i
= 0; i
< (param
->element_count
? param
->element_count
: 1); ++i
)
1447 IUnknown
*unk
= ((IUnknown
**)param
->data
)[i
];
1448 if (unk
) IUnknown_AddRef(unk
);
1454 FIXME("Unhandled type %s\n", debug_d3dxparameter_type(param
->type
));
1458 TRACE("Copy %u bytes\n", param
->bytes
);
1459 memcpy(data
, param
->data
, param
->bytes
);
1463 WARN("Invalid argument specified\n");
1465 return D3DERR_INVALIDCALL
;
1468 static HRESULT
d3dx9_base_effect_set_bool(struct d3dx9_base_effect
*base
, D3DXHANDLE parameter
, BOOL b
)
1470 struct d3dx_parameter
*param
= get_valid_parameter(base
, parameter
);
1472 if (param
&& !param
->element_count
&& param
->rows
== 1 && param
->columns
== 1)
1474 set_number(param
->data
, param
->type
, &b
, D3DXPT_BOOL
);
1478 WARN("Invalid argument specified\n");
1480 return D3DERR_INVALIDCALL
;
1483 static HRESULT
d3dx9_base_effect_get_bool(struct d3dx9_base_effect
*base
, D3DXHANDLE parameter
, BOOL
*b
)
1485 struct d3dx_parameter
*param
= get_valid_parameter(base
, parameter
);
1487 if (b
&& param
&& !param
->element_count
&& param
->rows
== 1 && param
->columns
== 1)
1489 set_number(b
, D3DXPT_BOOL
, param
->data
, param
->type
);
1490 TRACE("Returning %s\n", *b
? "TRUE" : "FALSE");
1494 WARN("Invalid argument specified\n");
1496 return D3DERR_INVALIDCALL
;
1499 static HRESULT
d3dx9_base_effect_set_bool_array(struct d3dx9_base_effect
*base
,
1500 D3DXHANDLE parameter
, const BOOL
*b
, UINT count
)
1502 struct d3dx_parameter
*param
= get_valid_parameter(base
, parameter
);
1506 UINT i
, size
= min(count
, param
->bytes
/ sizeof(DWORD
));
1508 TRACE("Class %s\n", debug_d3dxparameter_class(param
->class));
1510 switch (param
->class)
1514 case D3DXPC_MATRIX_ROWS
:
1515 for (i
= 0; i
< size
; ++i
)
1517 /* don't crop the input, use D3DXPT_INT instead of D3DXPT_BOOL */
1518 set_number((DWORD
*)param
->data
+ i
, param
->type
, &b
[i
], D3DXPT_INT
);
1527 FIXME("Unhandled class %s\n", debug_d3dxparameter_class(param
->class));
1532 WARN("Invalid argument specified\n");
1534 return D3DERR_INVALIDCALL
;
1537 static HRESULT
d3dx9_base_effect_get_bool_array(struct d3dx9_base_effect
*base
,
1538 D3DXHANDLE parameter
, BOOL
*b
, UINT count
)
1540 struct d3dx_parameter
*param
= get_valid_parameter(base
, parameter
);
1542 if (b
&& param
&& (param
->class == D3DXPC_SCALAR
1543 || param
->class == D3DXPC_VECTOR
1544 || param
->class == D3DXPC_MATRIX_ROWS
1545 || param
->class == D3DXPC_MATRIX_COLUMNS
))
1547 UINT i
, size
= min(count
, param
->bytes
/ sizeof(DWORD
));
1549 for (i
= 0; i
< size
; ++i
)
1551 set_number(&b
[i
], D3DXPT_BOOL
, (DWORD
*)param
->data
+ i
, param
->type
);
1556 WARN("Invalid argument specified\n");
1558 return D3DERR_INVALIDCALL
;
1561 static HRESULT
d3dx9_base_effect_set_int(struct d3dx9_base_effect
*base
, D3DXHANDLE parameter
, INT n
)
1563 struct d3dx_parameter
*param
= get_valid_parameter(base
, parameter
);
1565 if (param
&& !param
->element_count
)
1567 if (param
->rows
== 1 && param
->columns
== 1)
1569 set_number(param
->data
, param
->type
, &n
, D3DXPT_INT
);
1574 * Split the value, if parameter is a vector with dimension 3 or 4.
1576 if (param
->type
== D3DXPT_FLOAT
&&
1577 ((param
->class == D3DXPC_VECTOR
&& param
->columns
!= 2) ||
1578 (param
->class == D3DXPC_MATRIX_ROWS
&& param
->rows
!= 2 && param
->columns
== 1)))
1580 TRACE("Vector fixup\n");
1582 *(FLOAT
*)param
->data
= ((n
& 0xff0000) >> 16) * INT_FLOAT_MULTI_INVERSE
;
1583 ((FLOAT
*)param
->data
)[1] = ((n
& 0xff00) >> 8) * INT_FLOAT_MULTI_INVERSE
;
1584 ((FLOAT
*)param
->data
)[2] = (n
& 0xff) * INT_FLOAT_MULTI_INVERSE
;
1585 if (param
->rows
* param
->columns
> 3)
1587 ((FLOAT
*)param
->data
)[3] = ((n
& 0xff000000) >> 24) * INT_FLOAT_MULTI_INVERSE
;
1593 WARN("Invalid argument specified\n");
1595 return D3DERR_INVALIDCALL
;
1598 static HRESULT
d3dx9_base_effect_get_int(struct d3dx9_base_effect
*base
, D3DXHANDLE parameter
, INT
*n
)
1600 struct d3dx_parameter
*param
= get_valid_parameter(base
, parameter
);
1602 if (n
&& param
&& !param
->element_count
)
1604 if (param
->columns
== 1 && param
->rows
== 1)
1606 set_number(n
, D3DXPT_INT
, param
->data
, param
->type
);
1607 TRACE("Returning %i\n", *n
);
1611 if (param
->type
== D3DXPT_FLOAT
&&
1612 ((param
->class == D3DXPC_VECTOR
&& param
->columns
!= 2)
1613 || (param
->class == D3DXPC_MATRIX_ROWS
&& param
->rows
!= 2 && param
->columns
== 1)))
1615 TRACE("Vector fixup\n");
1617 /* all components (3,4) are clamped (0,255) and put in the INT */
1618 *n
= (INT
)(min(max(0.0f
, *((FLOAT
*)param
->data
+ 2)), 1.0f
) * INT_FLOAT_MULTI
);
1619 *n
+= ((INT
)(min(max(0.0f
, *((FLOAT
*)param
->data
+ 1)), 1.0f
) * INT_FLOAT_MULTI
)) << 8;
1620 *n
+= ((INT
)(min(max(0.0f
, *((FLOAT
*)param
->data
+ 0)), 1.0f
) * INT_FLOAT_MULTI
)) << 16;
1621 if (param
->columns
* param
->rows
> 3)
1623 *n
+= ((INT
)(min(max(0.0f
, *((FLOAT
*)param
->data
+ 3)), 1.0f
) * INT_FLOAT_MULTI
)) << 24;
1626 TRACE("Returning %i\n", *n
);
1631 WARN("Invalid argument specified\n");
1633 return D3DERR_INVALIDCALL
;
1636 static HRESULT
d3dx9_base_effect_set_int_array(struct d3dx9_base_effect
*base
,
1637 D3DXHANDLE parameter
, const INT
*n
, UINT count
)
1639 struct d3dx_parameter
*param
= get_valid_parameter(base
, parameter
);
1643 UINT i
, size
= min(count
, param
->bytes
/ sizeof(DWORD
));
1645 TRACE("Class %s\n", debug_d3dxparameter_class(param
->class));
1647 switch (param
->class)
1651 case D3DXPC_MATRIX_ROWS
:
1652 for (i
= 0; i
< size
; ++i
)
1654 set_number((DWORD
*)param
->data
+ i
, param
->type
, &n
[i
], D3DXPT_INT
);
1663 FIXME("Unhandled class %s\n", debug_d3dxparameter_class(param
->class));
1668 WARN("Invalid argument specified\n");
1670 return D3DERR_INVALIDCALL
;
1673 static HRESULT
d3dx9_base_effect_get_int_array(struct d3dx9_base_effect
*base
,
1674 D3DXHANDLE parameter
, INT
*n
, UINT count
)
1676 struct d3dx_parameter
*param
= get_valid_parameter(base
, parameter
);
1678 if (n
&& param
&& (param
->class == D3DXPC_SCALAR
1679 || param
->class == D3DXPC_VECTOR
1680 || param
->class == D3DXPC_MATRIX_ROWS
1681 || param
->class == D3DXPC_MATRIX_COLUMNS
))
1683 UINT i
, size
= min(count
, param
->bytes
/ sizeof(DWORD
));
1685 for (i
= 0; i
< size
; ++i
)
1687 set_number(&n
[i
], D3DXPT_INT
, (DWORD
*)param
->data
+ i
, param
->type
);
1692 WARN("Invalid argument specified\n");
1694 return D3DERR_INVALIDCALL
;
1697 static HRESULT
d3dx9_base_effect_set_float(struct d3dx9_base_effect
*base
, D3DXHANDLE parameter
, float f
)
1699 struct d3dx_parameter
*param
= get_valid_parameter(base
, parameter
);
1701 if (param
&& !param
->element_count
&& param
->rows
== 1 && param
->columns
== 1)
1703 set_number((DWORD
*)param
->data
, param
->type
, &f
, D3DXPT_FLOAT
);
1707 WARN("Invalid argument specified\n");
1709 return D3DERR_INVALIDCALL
;
1712 static HRESULT
d3dx9_base_effect_get_float(struct d3dx9_base_effect
*base
, D3DXHANDLE parameter
, float *f
)
1714 struct d3dx_parameter
*param
= get_valid_parameter(base
, parameter
);
1716 if (f
&& param
&& !param
->element_count
&& param
->columns
== 1 && param
->rows
== 1)
1718 set_number(f
, D3DXPT_FLOAT
, (DWORD
*)param
->data
, param
->type
);
1719 TRACE("Returning %f\n", *f
);
1723 WARN("Invalid argument specified\n");
1725 return D3DERR_INVALIDCALL
;
1728 static HRESULT
d3dx9_base_effect_set_float_array(struct d3dx9_base_effect
*base
,
1729 D3DXHANDLE parameter
, const float *f
, UINT count
)
1731 struct d3dx_parameter
*param
= get_valid_parameter(base
, parameter
);
1735 UINT i
, size
= min(count
, param
->bytes
/ sizeof(DWORD
));
1737 TRACE("Class %s\n", debug_d3dxparameter_class(param
->class));
1739 switch (param
->class)
1743 case D3DXPC_MATRIX_ROWS
:
1744 for (i
= 0; i
< size
; ++i
)
1746 set_number((DWORD
*)param
->data
+ i
, param
->type
, &f
[i
], D3DXPT_FLOAT
);
1755 FIXME("Unhandled class %s\n", debug_d3dxparameter_class(param
->class));
1760 WARN("Invalid argument specified\n");
1762 return D3DERR_INVALIDCALL
;
1765 static HRESULT
d3dx9_base_effect_get_float_array(struct d3dx9_base_effect
*base
,
1766 D3DXHANDLE parameter
, float *f
, UINT count
)
1768 struct d3dx_parameter
*param
= get_valid_parameter(base
, parameter
);
1770 if (f
&& param
&& (param
->class == D3DXPC_SCALAR
1771 || param
->class == D3DXPC_VECTOR
1772 || param
->class == D3DXPC_MATRIX_ROWS
1773 || param
->class == D3DXPC_MATRIX_COLUMNS
))
1775 UINT i
, size
= min(count
, param
->bytes
/ sizeof(DWORD
));
1777 for (i
= 0; i
< size
; ++i
)
1779 set_number(&f
[i
], D3DXPT_FLOAT
, (DWORD
*)param
->data
+ i
, param
->type
);
1784 WARN("Invalid argument specified\n");
1786 return D3DERR_INVALIDCALL
;
1789 static HRESULT
d3dx9_base_effect_set_vector(struct d3dx9_base_effect
*base
,
1790 D3DXHANDLE parameter
, const D3DXVECTOR4
*vector
)
1792 struct d3dx_parameter
*param
= get_valid_parameter(base
, parameter
);
1794 if (param
&& !param
->element_count
)
1796 TRACE("Class %s\n", debug_d3dxparameter_class(param
->class));
1798 switch (param
->class)
1802 if (param
->type
== D3DXPT_INT
&& param
->bytes
== 4)
1806 TRACE("INT fixup\n");
1807 tmp
= (DWORD
)(max(min(vector
->z
, 1.0f
), 0.0f
) * INT_FLOAT_MULTI
);
1808 tmp
+= ((DWORD
)(max(min(vector
->y
, 1.0f
), 0.0f
) * INT_FLOAT_MULTI
)) << 8;
1809 tmp
+= ((DWORD
)(max(min(vector
->x
, 1.0f
), 0.0f
) * INT_FLOAT_MULTI
)) << 16;
1810 tmp
+= ((DWORD
)(max(min(vector
->w
, 1.0f
), 0.0f
) * INT_FLOAT_MULTI
)) << 24;
1812 *(INT
*)param
->data
= tmp
;
1815 set_vector(param
, vector
);
1818 case D3DXPC_MATRIX_ROWS
:
1824 FIXME("Unhandled class %s\n", debug_d3dxparameter_class(param
->class));
1829 WARN("Invalid argument specified\n");
1831 return D3DERR_INVALIDCALL
;
1834 static HRESULT
d3dx9_base_effect_get_vector(struct d3dx9_base_effect
*base
,
1835 D3DXHANDLE parameter
, D3DXVECTOR4
*vector
)
1837 struct d3dx_parameter
*param
= get_valid_parameter(base
, parameter
);
1839 if (vector
&& param
&& !param
->element_count
)
1841 TRACE("Class %s\n", debug_d3dxparameter_class(param
->class));
1843 switch (param
->class)
1847 if (param
->type
== D3DXPT_INT
&& param
->bytes
== 4)
1849 TRACE("INT fixup\n");
1850 vector
->x
= (((*(INT
*)param
->data
) & 0xff0000) >> 16) * INT_FLOAT_MULTI_INVERSE
;
1851 vector
->y
= (((*(INT
*)param
->data
) & 0xff00) >> 8) * INT_FLOAT_MULTI_INVERSE
;
1852 vector
->z
= ((*(INT
*)param
->data
) & 0xff) * INT_FLOAT_MULTI_INVERSE
;
1853 vector
->w
= (((*(INT
*)param
->data
) & 0xff000000) >> 24) * INT_FLOAT_MULTI_INVERSE
;
1856 get_vector(param
, vector
);
1859 case D3DXPC_MATRIX_ROWS
:
1865 FIXME("Unhandled class %s\n", debug_d3dxparameter_class(param
->class));
1870 WARN("Invalid argument specified\n");
1872 return D3DERR_INVALIDCALL
;
1875 static HRESULT
d3dx9_base_effect_set_vector_array(struct d3dx9_base_effect
*base
,
1876 D3DXHANDLE parameter
, const D3DXVECTOR4
*vector
, UINT count
)
1878 struct d3dx_parameter
*param
= get_valid_parameter(base
, parameter
);
1880 if (param
&& param
->element_count
&& param
->element_count
>= count
)
1884 TRACE("Class %s\n", debug_d3dxparameter_class(param
->class));
1886 switch (param
->class)
1889 for (i
= 0; i
< count
; ++i
)
1891 set_vector(¶m
->members
[i
], &vector
[i
]);
1896 case D3DXPC_MATRIX_ROWS
:
1902 FIXME("Unhandled class %s\n", debug_d3dxparameter_class(param
->class));
1907 WARN("Invalid argument specified\n");
1909 return D3DERR_INVALIDCALL
;
1912 static HRESULT
d3dx9_base_effect_get_vector_array(struct d3dx9_base_effect
*base
,
1913 D3DXHANDLE parameter
, D3DXVECTOR4
*vector
, UINT count
)
1915 struct d3dx_parameter
*param
= get_valid_parameter(base
, parameter
);
1917 if (!count
) return D3D_OK
;
1919 if (vector
&& param
&& count
<= param
->element_count
)
1923 TRACE("Class %s\n", debug_d3dxparameter_class(param
->class));
1925 switch (param
->class)
1928 for (i
= 0; i
< count
; ++i
)
1930 get_vector(¶m
->members
[i
], &vector
[i
]);
1935 case D3DXPC_MATRIX_ROWS
:
1941 FIXME("Unhandled class %s\n", debug_d3dxparameter_class(param
->class));
1946 WARN("Invalid argument specified\n");
1948 return D3DERR_INVALIDCALL
;
1951 static HRESULT
d3dx9_base_effect_set_matrix(struct d3dx9_base_effect
*base
,
1952 D3DXHANDLE parameter
, const D3DXMATRIX
*matrix
)
1954 struct d3dx_parameter
*param
= get_valid_parameter(base
, parameter
);
1956 if (param
&& !param
->element_count
)
1958 TRACE("Class %s\n", debug_d3dxparameter_class(param
->class));
1960 switch (param
->class)
1962 case D3DXPC_MATRIX_ROWS
:
1963 set_matrix(param
, matrix
, FALSE
);
1973 FIXME("Unhandled class %s\n", debug_d3dxparameter_class(param
->class));
1978 WARN("Invalid argument specified\n");
1980 return D3DERR_INVALIDCALL
;
1983 static HRESULT
d3dx9_base_effect_get_matrix(struct d3dx9_base_effect
*base
,
1984 D3DXHANDLE parameter
, D3DXMATRIX
*matrix
)
1986 struct d3dx_parameter
*param
= get_valid_parameter(base
, parameter
);
1988 if (matrix
&& param
&& !param
->element_count
)
1990 TRACE("Class %s\n", debug_d3dxparameter_class(param
->class));
1992 switch (param
->class)
1994 case D3DXPC_MATRIX_ROWS
:
1995 get_matrix(param
, matrix
, FALSE
);
2005 FIXME("Unhandled class %s\n", debug_d3dxparameter_class(param
->class));
2010 WARN("Invalid argument specified\n");
2012 return D3DERR_INVALIDCALL
;
2015 static HRESULT
d3dx9_base_effect_set_matrix_array(struct d3dx9_base_effect
*base
,
2016 D3DXHANDLE parameter
, const D3DXMATRIX
*matrix
, UINT count
)
2018 struct d3dx_parameter
*param
= get_valid_parameter(base
, parameter
);
2020 if (param
&& param
->element_count
>= count
)
2024 TRACE("Class %s\n", debug_d3dxparameter_class(param
->class));
2026 switch (param
->class)
2028 case D3DXPC_MATRIX_ROWS
:
2029 for (i
= 0; i
< count
; ++i
)
2031 set_matrix(¶m
->members
[i
], &matrix
[i
], FALSE
);
2042 FIXME("Unhandled class %s\n", debug_d3dxparameter_class(param
->class));
2047 WARN("Invalid argument specified\n");
2049 return D3DERR_INVALIDCALL
;
2052 static HRESULT
d3dx9_base_effect_get_matrix_array(struct d3dx9_base_effect
*base
,
2053 D3DXHANDLE parameter
, D3DXMATRIX
*matrix
, UINT count
)
2055 struct d3dx_parameter
*param
= get_valid_parameter(base
, parameter
);
2057 if (!count
) return D3D_OK
;
2059 if (matrix
&& param
&& count
<= param
->element_count
)
2063 TRACE("Class %s\n", debug_d3dxparameter_class(param
->class));
2065 switch (param
->class)
2067 case D3DXPC_MATRIX_ROWS
:
2068 for (i
= 0; i
< count
; ++i
)
2070 get_matrix(¶m
->members
[i
], &matrix
[i
], FALSE
);
2081 FIXME("Unhandled class %s\n", debug_d3dxparameter_class(param
->class));
2086 WARN("Invalid argument specified\n");
2088 return D3DERR_INVALIDCALL
;
2091 static HRESULT
d3dx9_base_effect_set_matrix_pointer_array(struct d3dx9_base_effect
*base
,
2092 D3DXHANDLE parameter
, const D3DXMATRIX
**matrix
, UINT count
)
2094 struct d3dx_parameter
*param
= get_valid_parameter(base
, parameter
);
2096 if (param
&& count
<= param
->element_count
)
2100 switch (param
->class)
2102 case D3DXPC_MATRIX_ROWS
:
2103 for (i
= 0; i
< count
; ++i
)
2105 set_matrix(¶m
->members
[i
], matrix
[i
], FALSE
);
2115 FIXME("Unhandled class %s\n", debug_d3dxparameter_class(param
->class));
2120 WARN("Invalid argument specified\n");
2122 return D3DERR_INVALIDCALL
;
2125 static HRESULT
d3dx9_base_effect_get_matrix_pointer_array(struct d3dx9_base_effect
*base
,
2126 D3DXHANDLE parameter
, D3DXMATRIX
**matrix
, UINT count
)
2128 struct d3dx_parameter
*param
= get_valid_parameter(base
, parameter
);
2130 if (!count
) return D3D_OK
;
2132 if (param
&& matrix
&& count
<= param
->element_count
)
2136 TRACE("Class %s\n", debug_d3dxparameter_class(param
->class));
2138 switch (param
->class)
2140 case D3DXPC_MATRIX_ROWS
:
2141 for (i
= 0; i
< count
; ++i
)
2143 get_matrix(¶m
->members
[i
], matrix
[i
], FALSE
);
2153 FIXME("Unhandled class %s\n", debug_d3dxparameter_class(param
->class));
2158 WARN("Invalid argument specified\n");
2160 return D3DERR_INVALIDCALL
;
2163 static HRESULT
d3dx9_base_effect_set_matrix_transpose(struct d3dx9_base_effect
*base
,
2164 D3DXHANDLE parameter
, const D3DXMATRIX
*matrix
)
2166 struct d3dx_parameter
*param
= get_valid_parameter(base
, parameter
);
2168 if (param
&& !param
->element_count
)
2170 TRACE("Class %s\n", debug_d3dxparameter_class(param
->class));
2172 switch (param
->class)
2174 case D3DXPC_MATRIX_ROWS
:
2175 set_matrix(param
, matrix
, TRUE
);
2185 FIXME("Unhandled class %s\n", debug_d3dxparameter_class(param
->class));
2190 WARN("Invalid argument specified\n");
2192 return D3DERR_INVALIDCALL
;
2195 static HRESULT
d3dx9_base_effect_get_matrix_transpose(struct d3dx9_base_effect
*base
,
2196 D3DXHANDLE parameter
, D3DXMATRIX
*matrix
)
2198 struct d3dx_parameter
*param
= get_valid_parameter(base
, parameter
);
2200 if (matrix
&& param
&& !param
->element_count
)
2202 TRACE("Class %s\n", debug_d3dxparameter_class(param
->class));
2204 switch (param
->class)
2208 get_matrix(param
, matrix
, FALSE
);
2211 case D3DXPC_MATRIX_ROWS
:
2212 get_matrix(param
, matrix
, TRUE
);
2220 FIXME("Unhandled class %s\n", debug_d3dxparameter_class(param
->class));
2225 WARN("Invalid argument specified\n");
2227 return D3DERR_INVALIDCALL
;
2230 static HRESULT
d3dx9_base_effect_set_matrix_transpose_array(struct d3dx9_base_effect
*base
,
2231 D3DXHANDLE parameter
, const D3DXMATRIX
*matrix
, UINT count
)
2233 struct d3dx_parameter
*param
= get_valid_parameter(base
, parameter
);
2235 if (param
&& param
->element_count
>= count
)
2239 TRACE("Class %s\n", debug_d3dxparameter_class(param
->class));
2241 switch (param
->class)
2243 case D3DXPC_MATRIX_ROWS
:
2244 for (i
= 0; i
< count
; ++i
)
2246 set_matrix(¶m
->members
[i
], &matrix
[i
], TRUE
);
2257 FIXME("Unhandled class %s\n", debug_d3dxparameter_class(param
->class));
2262 WARN("Invalid argument specified\n");
2264 return D3DERR_INVALIDCALL
;
2267 static HRESULT
d3dx9_base_effect_get_matrix_transpose_array(struct d3dx9_base_effect
*base
,
2268 D3DXHANDLE parameter
, D3DXMATRIX
*matrix
, UINT count
)
2270 struct d3dx_parameter
*param
= get_valid_parameter(base
, parameter
);
2272 if (!count
) return D3D_OK
;
2274 if (matrix
&& param
&& count
<= param
->element_count
)
2278 TRACE("Class %s\n", debug_d3dxparameter_class(param
->class));
2280 switch (param
->class)
2282 case D3DXPC_MATRIX_ROWS
:
2283 for (i
= 0; i
< count
; ++i
)
2285 get_matrix(¶m
->members
[i
], &matrix
[i
], TRUE
);
2296 FIXME("Unhandled class %s\n", debug_d3dxparameter_class(param
->class));
2301 WARN("Invalid argument specified\n");
2303 return D3DERR_INVALIDCALL
;
2306 static HRESULT
d3dx9_base_effect_set_matrix_transpose_pointer_array(struct d3dx9_base_effect
*base
,
2307 D3DXHANDLE parameter
, const D3DXMATRIX
**matrix
, UINT count
)
2309 struct d3dx_parameter
*param
= get_valid_parameter(base
, parameter
);
2311 if (param
&& count
<= param
->element_count
)
2315 switch (param
->class)
2317 case D3DXPC_MATRIX_ROWS
:
2318 for (i
= 0; i
< count
; ++i
)
2320 set_matrix(¶m
->members
[i
], matrix
[i
], TRUE
);
2330 FIXME("Unhandled class %s\n", debug_d3dxparameter_class(param
->class));
2335 WARN("Invalid argument specified\n");
2337 return D3DERR_INVALIDCALL
;
2340 static HRESULT
d3dx9_base_effect_get_matrix_transpose_pointer_array(struct d3dx9_base_effect
*base
,
2341 D3DXHANDLE parameter
, D3DXMATRIX
**matrix
, UINT count
)
2343 struct d3dx_parameter
*param
= get_valid_parameter(base
, parameter
);
2345 if (!count
) return D3D_OK
;
2347 if (matrix
&& param
&& count
<= param
->element_count
)
2351 TRACE("Class %s\n", debug_d3dxparameter_class(param
->class));
2353 switch (param
->class)
2355 case D3DXPC_MATRIX_ROWS
:
2356 for (i
= 0; i
< count
; ++i
)
2358 get_matrix(¶m
->members
[i
], matrix
[i
], TRUE
);
2368 FIXME("Unhandled class %s\n", debug_d3dxparameter_class(param
->class));
2373 WARN("Invalid argument specified\n");
2375 return D3DERR_INVALIDCALL
;
2378 static HRESULT
d3dx9_base_effect_set_string(struct d3dx9_base_effect
*base
,
2379 D3DXHANDLE parameter
, const char *string
)
2386 static HRESULT
d3dx9_base_effect_get_string(struct d3dx9_base_effect
*base
,
2387 D3DXHANDLE parameter
, const char **string
)
2389 struct d3dx_parameter
*param
= get_valid_parameter(base
, parameter
);
2391 if (string
&& param
&& !param
->element_count
&& param
->type
== D3DXPT_STRING
)
2393 *string
= *(const char **)param
->data
;
2394 TRACE("Returning %s.\n", debugstr_a(*string
));
2398 WARN("Invalid argument specified\n");
2400 return D3DERR_INVALIDCALL
;
2403 static HRESULT
d3dx9_base_effect_set_texture(struct d3dx9_base_effect
*base
,
2404 D3DXHANDLE parameter
, struct IDirect3DBaseTexture9
*texture
)
2406 struct d3dx_parameter
*param
= get_valid_parameter(base
, parameter
);
2408 if (param
&& !param
->element_count
&&
2409 (param
->type
== D3DXPT_TEXTURE
|| param
->type
== D3DXPT_TEXTURE1D
2410 || param
->type
== D3DXPT_TEXTURE2D
|| param
->type
== D3DXPT_TEXTURE3D
2411 || param
->type
== D3DXPT_TEXTURECUBE
))
2413 struct IDirect3DBaseTexture9
*oltexture
= *(struct IDirect3DBaseTexture9
**)param
->data
;
2415 if (texture
) IDirect3DBaseTexture9_AddRef(texture
);
2416 if (oltexture
) IDirect3DBaseTexture9_Release(oltexture
);
2418 *(struct IDirect3DBaseTexture9
**)param
->data
= texture
;
2423 WARN("Invalid argument specified\n");
2425 return D3DERR_INVALIDCALL
;
2428 static HRESULT
d3dx9_base_effect_get_texture(struct d3dx9_base_effect
*base
,
2429 D3DXHANDLE parameter
, struct IDirect3DBaseTexture9
**texture
)
2431 struct d3dx_parameter
*param
= get_valid_parameter(base
, parameter
);
2433 if (texture
&& param
&& !param
->element_count
&&
2434 (param
->type
== D3DXPT_TEXTURE
|| param
->type
== D3DXPT_TEXTURE1D
2435 || param
->type
== D3DXPT_TEXTURE2D
|| param
->type
== D3DXPT_TEXTURE3D
2436 || param
->type
== D3DXPT_TEXTURECUBE
))
2438 *texture
= *(struct IDirect3DBaseTexture9
**)param
->data
;
2439 if (*texture
) IDirect3DBaseTexture9_AddRef(*texture
);
2440 TRACE("Returning %p\n", *texture
);
2444 WARN("Invalid argument specified\n");
2446 return D3DERR_INVALIDCALL
;
2449 static HRESULT
d3dx9_base_effect_get_pixel_shader(struct d3dx9_base_effect
*base
,
2450 D3DXHANDLE parameter
, struct IDirect3DPixelShader9
**shader
)
2452 struct d3dx_parameter
*param
= get_valid_parameter(base
, parameter
);
2454 if (shader
&& param
&& !param
->element_count
&& param
->type
== D3DXPT_PIXELSHADER
)
2456 if ((*shader
= *(struct IDirect3DPixelShader9
**)param
->data
))
2457 IDirect3DPixelShader9_AddRef(*shader
);
2458 TRACE("Returning %p.\n", *shader
);
2462 WARN("Invalid argument specified\n");
2464 return D3DERR_INVALIDCALL
;
2467 static HRESULT
d3dx9_base_effect_get_vertex_shader(struct d3dx9_base_effect
*base
,
2468 D3DXHANDLE parameter
, struct IDirect3DVertexShader9
**shader
)
2470 struct d3dx_parameter
*param
= get_valid_parameter(base
, parameter
);
2472 if (shader
&& param
&& !param
->element_count
&& param
->type
== D3DXPT_VERTEXSHADER
)
2474 if ((*shader
= *(struct IDirect3DVertexShader9
**)param
->data
))
2475 IDirect3DVertexShader9_AddRef(*shader
);
2476 TRACE("Returning %p.\n", *shader
);
2480 WARN("Invalid argument specified\n");
2482 return D3DERR_INVALIDCALL
;
2485 static HRESULT
d3dx9_base_effect_set_array_range(struct d3dx9_base_effect
*base
,
2486 D3DXHANDLE parameter
, UINT start
, UINT end
)
2493 static inline struct ID3DXEffectImpl
*impl_from_ID3DXEffect(ID3DXEffect
*iface
)
2495 return CONTAINING_RECORD(iface
, struct ID3DXEffectImpl
, ID3DXEffect_iface
);
2498 /*** IUnknown methods ***/
2499 static HRESULT WINAPI
ID3DXEffectImpl_QueryInterface(ID3DXEffect
*iface
, REFIID riid
, void **object
)
2501 TRACE("(%p)->(%s, %p)\n", iface
, debugstr_guid(riid
), object
);
2503 if (IsEqualGUID(riid
, &IID_IUnknown
) ||
2504 IsEqualGUID(riid
, &IID_ID3DXEffect
))
2506 iface
->lpVtbl
->AddRef(iface
);
2511 ERR("Interface %s not found\n", debugstr_guid(riid
));
2513 return E_NOINTERFACE
;
2516 static ULONG WINAPI
ID3DXEffectImpl_AddRef(ID3DXEffect
*iface
)
2518 struct ID3DXEffectImpl
*This
= impl_from_ID3DXEffect(iface
);
2520 TRACE("(%p)->(): AddRef from %u\n", This
, This
->ref
);
2522 return InterlockedIncrement(&This
->ref
);
2525 static ULONG WINAPI
ID3DXEffectImpl_Release(ID3DXEffect
*iface
)
2527 struct ID3DXEffectImpl
*This
= impl_from_ID3DXEffect(iface
);
2528 ULONG ref
= InterlockedDecrement(&This
->ref
);
2530 TRACE("(%p)->(): Release from %u\n", This
, ref
+ 1);
2535 HeapFree(GetProcessHeap(), 0, This
);
2541 /*** ID3DXBaseEffect methods ***/
2542 static HRESULT WINAPI
ID3DXEffectImpl_GetDesc(ID3DXEffect
*iface
, D3DXEFFECT_DESC
*desc
)
2544 struct ID3DXEffectImpl
*effect
= impl_from_ID3DXEffect(iface
);
2546 TRACE("iface %p, desc %p.\n", iface
, desc
);
2548 return d3dx9_base_effect_get_desc(&effect
->base_effect
, desc
);
2551 static HRESULT WINAPI
ID3DXEffectImpl_GetParameterDesc(ID3DXEffect
*iface
,
2552 D3DXHANDLE parameter
, D3DXPARAMETER_DESC
*desc
)
2554 struct ID3DXEffectImpl
*effect
= impl_from_ID3DXEffect(iface
);
2556 TRACE("iface %p, parameter %p, desc %p.\n", iface
, parameter
, desc
);
2558 return d3dx9_base_effect_get_parameter_desc(&effect
->base_effect
, parameter
, desc
);
2561 static HRESULT WINAPI
ID3DXEffectImpl_GetTechniqueDesc(ID3DXEffect
*iface
,
2562 D3DXHANDLE technique
, D3DXTECHNIQUE_DESC
*desc
)
2564 struct ID3DXEffectImpl
*effect
= impl_from_ID3DXEffect(iface
);
2566 TRACE("iface %p, technique %p, desc %p.\n", iface
, technique
, desc
);
2568 return d3dx9_base_effect_get_technique_desc(&effect
->base_effect
, technique
, desc
);
2571 static HRESULT WINAPI
ID3DXEffectImpl_GetPassDesc(ID3DXEffect
*iface
, D3DXHANDLE pass
, D3DXPASS_DESC
*desc
)
2573 struct ID3DXEffectImpl
*effect
= impl_from_ID3DXEffect(iface
);
2575 TRACE("iface %p, pass %p, desc %p.\n", iface
, pass
, desc
);
2577 return d3dx9_base_effect_get_pass_desc(&effect
->base_effect
, pass
, desc
);
2580 static HRESULT WINAPI
ID3DXEffectImpl_GetFunctionDesc(ID3DXEffect
*iface
, D3DXHANDLE shader
, D3DXFUNCTION_DESC
*desc
)
2582 struct ID3DXEffectImpl
*effect
= impl_from_ID3DXEffect(iface
);
2584 TRACE("iface %p, shader %p, desc %p.\n", iface
, shader
, desc
);
2586 return d3dx9_base_effect_get_function_desc(&effect
->base_effect
, shader
, desc
);
2589 static D3DXHANDLE WINAPI
ID3DXEffectImpl_GetParameter(ID3DXEffect
*iface
, D3DXHANDLE parameter
, UINT index
)
2591 struct ID3DXEffectImpl
*effect
= impl_from_ID3DXEffect(iface
);
2593 TRACE("iface %p, parameter %p, index %u.\n", iface
, parameter
, index
);
2595 return d3dx9_base_effect_get_parameter(&effect
->base_effect
, parameter
, index
);
2598 static D3DXHANDLE WINAPI
ID3DXEffectImpl_GetParameterByName(ID3DXEffect
*iface
,
2599 D3DXHANDLE parameter
, const char *name
)
2601 struct ID3DXEffectImpl
*effect
= impl_from_ID3DXEffect(iface
);
2603 TRACE("iface %p, parameter %p, name %s.\n", iface
, parameter
, debugstr_a(name
));
2605 return d3dx9_base_effect_get_parameter_by_name(&effect
->base_effect
, parameter
, name
);
2608 static D3DXHANDLE WINAPI
ID3DXEffectImpl_GetParameterBySemantic(ID3DXEffect
*iface
,
2609 D3DXHANDLE parameter
, const char *semantic
)
2611 struct ID3DXEffectImpl
*effect
= impl_from_ID3DXEffect(iface
);
2613 TRACE("iface %p, parameter %p, semantic %s.\n", iface
, parameter
, debugstr_a(semantic
));
2615 return d3dx9_base_effect_get_parameter_by_semantic(&effect
->base_effect
, parameter
, semantic
);
2618 static D3DXHANDLE WINAPI
ID3DXEffectImpl_GetParameterElement(ID3DXEffect
*iface
, D3DXHANDLE parameter
, UINT index
)
2620 struct ID3DXEffectImpl
*effect
= impl_from_ID3DXEffect(iface
);
2622 TRACE("iface %p, parameter %p, index %u.\n", iface
, parameter
, index
);
2624 return d3dx9_base_effect_get_parameter_element(&effect
->base_effect
, parameter
, index
);
2627 static D3DXHANDLE WINAPI
ID3DXEffectImpl_GetTechnique(ID3DXEffect
*iface
, UINT index
)
2629 struct ID3DXEffectImpl
*effect
= impl_from_ID3DXEffect(iface
);
2631 TRACE("iface %p, index %u.\n", iface
, index
);
2633 return d3dx9_base_effect_get_technique(&effect
->base_effect
, index
);
2636 static D3DXHANDLE WINAPI
ID3DXEffectImpl_GetTechniqueByName(ID3DXEffect
*iface
, const char *name
)
2638 struct ID3DXEffectImpl
*effect
= impl_from_ID3DXEffect(iface
);
2640 TRACE("iface %p, name %s.\n", iface
, debugstr_a(name
));
2642 return d3dx9_base_effect_get_technique_by_name(&effect
->base_effect
, name
);
2645 static D3DXHANDLE WINAPI
ID3DXEffectImpl_GetPass(ID3DXEffect
*iface
, D3DXHANDLE technique
, UINT index
)
2647 struct ID3DXEffectImpl
*effect
= impl_from_ID3DXEffect(iface
);
2649 TRACE("iface %p, technique %p, index %u.\n", iface
, technique
, index
);
2651 return d3dx9_base_effect_get_pass(&effect
->base_effect
, technique
, index
);
2654 static D3DXHANDLE WINAPI
ID3DXEffectImpl_GetPassByName(ID3DXEffect
*iface
,
2655 D3DXHANDLE technique
, const char *name
)
2657 struct ID3DXEffectImpl
*effect
= impl_from_ID3DXEffect(iface
);
2659 TRACE("iface %p, technique %p, name %s.\n", iface
, technique
, debugstr_a(name
));
2661 return d3dx9_base_effect_get_pass_by_name(&effect
->base_effect
, technique
, name
);
2664 static D3DXHANDLE WINAPI
ID3DXEffectImpl_GetFunction(ID3DXEffect
*iface
, UINT index
)
2666 struct ID3DXEffectImpl
*effect
= impl_from_ID3DXEffect(iface
);
2668 TRACE("iface %p, index %u.\n", iface
, index
);
2670 return d3dx9_base_effect_get_function(&effect
->base_effect
, index
);
2673 static D3DXHANDLE WINAPI
ID3DXEffectImpl_GetFunctionByName(ID3DXEffect
*iface
, const char *name
)
2675 struct ID3DXEffectImpl
*effect
= impl_from_ID3DXEffect(iface
);
2677 TRACE("iface %p, name %s.\n", iface
, debugstr_a(name
));
2679 return d3dx9_base_effect_get_function_by_name(&effect
->base_effect
, name
);
2682 static D3DXHANDLE WINAPI
ID3DXEffectImpl_GetAnnotation(ID3DXEffect
*iface
, D3DXHANDLE object
, UINT index
)
2684 struct ID3DXEffectImpl
*effect
= impl_from_ID3DXEffect(iface
);
2686 TRACE("iface %p, object %p, index %u.\n", iface
, object
, index
);
2688 return d3dx9_base_effect_get_annotation(&effect
->base_effect
, object
, index
);
2691 static D3DXHANDLE WINAPI
ID3DXEffectImpl_GetAnnotationByName(ID3DXEffect
*iface
,
2692 D3DXHANDLE object
, const char *name
)
2694 struct ID3DXEffectImpl
*effect
= impl_from_ID3DXEffect(iface
);
2696 TRACE("iface %p, object %p, name %s.\n", iface
, object
, debugstr_a(name
));
2698 return d3dx9_base_effect_get_annotation_by_name(&effect
->base_effect
, object
, name
);
2701 static HRESULT WINAPI
ID3DXEffectImpl_SetValue(ID3DXEffect
*iface
,
2702 D3DXHANDLE parameter
, const void *data
, UINT bytes
)
2704 struct ID3DXEffectImpl
*effect
= impl_from_ID3DXEffect(iface
);
2706 TRACE("iface %p, parameter %p, data %p, bytes %u.\n", iface
, parameter
, data
, bytes
);
2708 return d3dx9_base_effect_set_value(&effect
->base_effect
, parameter
, data
, bytes
);
2711 static HRESULT WINAPI
ID3DXEffectImpl_GetValue(ID3DXEffect
*iface
,
2712 D3DXHANDLE parameter
, void *data
, UINT bytes
)
2714 struct ID3DXEffectImpl
*effect
= impl_from_ID3DXEffect(iface
);
2716 TRACE("iface %p, parameter %p, data %p, bytes %u.\n", iface
, parameter
, data
, bytes
);
2718 return d3dx9_base_effect_get_value(&effect
->base_effect
, parameter
, data
, bytes
);
2721 static HRESULT WINAPI
ID3DXEffectImpl_SetBool(ID3DXEffect
*iface
, D3DXHANDLE parameter
, BOOL b
)
2723 struct ID3DXEffectImpl
*effect
= impl_from_ID3DXEffect(iface
);
2725 TRACE("iface %p, parameter %p, b %#x.\n", iface
, parameter
, b
);
2727 return d3dx9_base_effect_set_bool(&effect
->base_effect
, parameter
, b
);
2730 static HRESULT WINAPI
ID3DXEffectImpl_GetBool(ID3DXEffect
*iface
, D3DXHANDLE parameter
, BOOL
*b
)
2732 struct ID3DXEffectImpl
*effect
= impl_from_ID3DXEffect(iface
);
2734 TRACE("iface %p, parameter %p, b %p.\n", iface
, parameter
, b
);
2736 return d3dx9_base_effect_get_bool(&effect
->base_effect
, parameter
, b
);
2739 static HRESULT WINAPI
ID3DXEffectImpl_SetBoolArray(ID3DXEffect
*iface
,
2740 D3DXHANDLE parameter
, const BOOL
*b
, UINT count
)
2742 struct ID3DXEffectImpl
*effect
= impl_from_ID3DXEffect(iface
);
2744 TRACE("iface %p, parameter %p, b %p, count %u.\n", iface
, parameter
, b
, count
);
2746 return d3dx9_base_effect_set_bool_array(&effect
->base_effect
, parameter
, b
, count
);
2749 static HRESULT WINAPI
ID3DXEffectImpl_GetBoolArray(ID3DXEffect
*iface
,
2750 D3DXHANDLE parameter
, BOOL
*b
, UINT count
)
2752 struct ID3DXEffectImpl
*effect
= impl_from_ID3DXEffect(iface
);
2754 TRACE("iface %p, parameter %p, b %p, count %u.\n", iface
, parameter
, b
, count
);
2756 return d3dx9_base_effect_get_bool_array(&effect
->base_effect
, parameter
, b
, count
);
2759 static HRESULT WINAPI
ID3DXEffectImpl_SetInt(ID3DXEffect
*iface
, D3DXHANDLE parameter
, INT n
)
2761 struct ID3DXEffectImpl
*effect
= impl_from_ID3DXEffect(iface
);
2763 TRACE("iface %p, parameter %p, n %d.\n", iface
, parameter
, n
);
2765 return d3dx9_base_effect_set_int(&effect
->base_effect
, parameter
, n
);
2768 static HRESULT WINAPI
ID3DXEffectImpl_GetInt(ID3DXEffect
*iface
, D3DXHANDLE parameter
, INT
*n
)
2770 struct ID3DXEffectImpl
*effect
= impl_from_ID3DXEffect(iface
);
2772 TRACE("iface %p, parameter %p, n %p.\n", iface
, parameter
, n
);
2774 return d3dx9_base_effect_get_int(&effect
->base_effect
, parameter
, n
);
2777 static HRESULT WINAPI
ID3DXEffectImpl_SetIntArray(ID3DXEffect
*iface
,
2778 D3DXHANDLE parameter
, const INT
*n
, UINT count
)
2780 struct ID3DXEffectImpl
*effect
= impl_from_ID3DXEffect(iface
);
2782 TRACE("iface %p, parameter %p, n %p, count %u.\n", iface
, parameter
, n
, count
);
2784 return d3dx9_base_effect_set_int_array(&effect
->base_effect
, parameter
, n
, count
);
2787 static HRESULT WINAPI
ID3DXEffectImpl_GetIntArray(ID3DXEffect
*iface
,
2788 D3DXHANDLE parameter
, INT
*n
, UINT count
)
2790 struct ID3DXEffectImpl
*effect
= impl_from_ID3DXEffect(iface
);
2792 TRACE("iface %p, parameter %p, n %p, count %u.\n", iface
, parameter
, n
, count
);
2794 return d3dx9_base_effect_get_int_array(&effect
->base_effect
, parameter
, n
, count
);
2797 static HRESULT WINAPI
ID3DXEffectImpl_SetFloat(ID3DXEffect
*iface
, D3DXHANDLE parameter
, float f
)
2799 struct ID3DXEffectImpl
*effect
= impl_from_ID3DXEffect(iface
);
2801 TRACE("iface %p, parameter %p, f %.8e.\n", iface
, parameter
, f
);
2803 return d3dx9_base_effect_set_float(&effect
->base_effect
, parameter
, f
);
2806 static HRESULT WINAPI
ID3DXEffectImpl_GetFloat(ID3DXEffect
*iface
, D3DXHANDLE parameter
, float *f
)
2808 struct ID3DXEffectImpl
*effect
= impl_from_ID3DXEffect(iface
);
2810 TRACE("iface %p, parameter %p, f %p.\n", iface
, parameter
, f
);
2812 return d3dx9_base_effect_get_float(&effect
->base_effect
, parameter
, f
);
2815 static HRESULT WINAPI
ID3DXEffectImpl_SetFloatArray(ID3DXEffect
*iface
,
2816 D3DXHANDLE parameter
, const float *f
, UINT count
)
2818 struct ID3DXEffectImpl
*effect
= impl_from_ID3DXEffect(iface
);
2820 TRACE("iface %p, parameter %p, f %p, count %u.\n", iface
, parameter
, f
, count
);
2822 return d3dx9_base_effect_set_float_array(&effect
->base_effect
, parameter
, f
, count
);
2825 static HRESULT WINAPI
ID3DXEffectImpl_GetFloatArray(ID3DXEffect
*iface
,
2826 D3DXHANDLE parameter
, float *f
, UINT count
)
2828 struct ID3DXEffectImpl
*effect
= impl_from_ID3DXEffect(iface
);
2830 TRACE("iface %p, parameter %p, f %p, count %u.\n", iface
, parameter
, f
, count
);
2832 return d3dx9_base_effect_get_float_array(&effect
->base_effect
, parameter
, f
, count
);
2835 static HRESULT WINAPI
ID3DXEffectImpl_SetVector(ID3DXEffect
*iface
,
2836 D3DXHANDLE parameter
, const D3DXVECTOR4
*vector
)
2838 struct ID3DXEffectImpl
*effect
= impl_from_ID3DXEffect(iface
);
2840 TRACE("iface %p, parameter %p, vector %p.\n", iface
, parameter
, vector
);
2842 return d3dx9_base_effect_set_vector(&effect
->base_effect
, parameter
, vector
);
2845 static HRESULT WINAPI
ID3DXEffectImpl_GetVector(ID3DXEffect
*iface
,
2846 D3DXHANDLE parameter
, D3DXVECTOR4
*vector
)
2848 struct ID3DXEffectImpl
*effect
= impl_from_ID3DXEffect(iface
);
2850 TRACE("iface %p, parameter %p, vector %p.\n", iface
, parameter
, vector
);
2852 return d3dx9_base_effect_get_vector(&effect
->base_effect
, parameter
, vector
);
2855 static HRESULT WINAPI
ID3DXEffectImpl_SetVectorArray(ID3DXEffect
*iface
,
2856 D3DXHANDLE parameter
, const D3DXVECTOR4
*vector
, UINT count
)
2858 struct ID3DXEffectImpl
*effect
= impl_from_ID3DXEffect(iface
);
2860 TRACE("iface %p, parameter %p, vector %p, count %u.\n", iface
, parameter
, vector
, count
);
2862 return d3dx9_base_effect_set_vector_array(&effect
->base_effect
, parameter
, vector
, count
);
2865 static HRESULT WINAPI
ID3DXEffectImpl_GetVectorArray(ID3DXEffect
*iface
,
2866 D3DXHANDLE parameter
, D3DXVECTOR4
*vector
, UINT count
)
2868 struct ID3DXEffectImpl
*effect
= impl_from_ID3DXEffect(iface
);
2870 TRACE("iface %p, parameter %p, vector %p, count %u.\n", iface
, parameter
, vector
, count
);
2872 return d3dx9_base_effect_get_vector_array(&effect
->base_effect
, parameter
, vector
, count
);
2875 static HRESULT WINAPI
ID3DXEffectImpl_SetMatrix(ID3DXEffect
*iface
,
2876 D3DXHANDLE parameter
, const D3DXMATRIX
*matrix
)
2878 struct ID3DXEffectImpl
*effect
= impl_from_ID3DXEffect(iface
);
2880 TRACE("iface %p, parameter %p, matrix %p.\n", iface
, parameter
, matrix
);
2882 return d3dx9_base_effect_set_matrix(&effect
->base_effect
, parameter
, matrix
);
2885 static HRESULT WINAPI
ID3DXEffectImpl_GetMatrix(ID3DXEffect
*iface
,
2886 D3DXHANDLE parameter
, D3DXMATRIX
*matrix
)
2888 struct ID3DXEffectImpl
*effect
= impl_from_ID3DXEffect(iface
);
2890 TRACE("iface %p, parameter %p, matrix %p.\n", iface
, parameter
, matrix
);
2892 return d3dx9_base_effect_get_matrix(&effect
->base_effect
, parameter
, matrix
);
2895 static HRESULT WINAPI
ID3DXEffectImpl_SetMatrixArray(ID3DXEffect
*iface
,
2896 D3DXHANDLE parameter
, const D3DXMATRIX
*matrix
, UINT count
)
2898 struct ID3DXEffectImpl
*effect
= impl_from_ID3DXEffect(iface
);
2900 TRACE("iface %p, parameter %p, matrix %p, count %u.\n", iface
, parameter
, matrix
, count
);
2902 return d3dx9_base_effect_set_matrix_array(&effect
->base_effect
, parameter
, matrix
, count
);
2905 static HRESULT WINAPI
ID3DXEffectImpl_GetMatrixArray(ID3DXEffect
*iface
,
2906 D3DXHANDLE parameter
, D3DXMATRIX
*matrix
, UINT count
)
2908 struct ID3DXEffectImpl
*effect
= impl_from_ID3DXEffect(iface
);
2910 TRACE("iface %p, parameter %p, matrix %p, count %u.\n", iface
, parameter
, matrix
, count
);
2912 return d3dx9_base_effect_get_matrix_array(&effect
->base_effect
, parameter
, matrix
, count
);
2915 static HRESULT WINAPI
ID3DXEffectImpl_SetMatrixPointerArray(ID3DXEffect
*iface
,
2916 D3DXHANDLE parameter
, const D3DXMATRIX
**matrix
, UINT count
)
2918 struct ID3DXEffectImpl
*effect
= impl_from_ID3DXEffect(iface
);
2920 TRACE("iface %p, parameter %p, matrix %p, count %u.\n", iface
, parameter
, matrix
, count
);
2922 return d3dx9_base_effect_set_matrix_pointer_array(&effect
->base_effect
, parameter
, matrix
, count
);
2925 static HRESULT WINAPI
ID3DXEffectImpl_GetMatrixPointerArray(ID3DXEffect
*iface
,
2926 D3DXHANDLE parameter
, D3DXMATRIX
**matrix
, UINT count
)
2928 struct ID3DXEffectImpl
*effect
= impl_from_ID3DXEffect(iface
);
2930 TRACE("iface %p, parameter %p, matrix %p, count %u.\n", iface
, parameter
, matrix
, count
);
2932 return d3dx9_base_effect_get_matrix_pointer_array(&effect
->base_effect
, parameter
, matrix
, count
);
2935 static HRESULT WINAPI
ID3DXEffectImpl_SetMatrixTranspose(ID3DXEffect
*iface
,
2936 D3DXHANDLE parameter
, const D3DXMATRIX
*matrix
)
2938 struct ID3DXEffectImpl
*effect
= impl_from_ID3DXEffect(iface
);
2940 TRACE("iface %p, parameter %p, matrix %p.\n", iface
, parameter
, matrix
);
2942 return d3dx9_base_effect_set_matrix_transpose(&effect
->base_effect
, parameter
, matrix
);
2945 static HRESULT WINAPI
ID3DXEffectImpl_GetMatrixTranspose(ID3DXEffect
*iface
,
2946 D3DXHANDLE parameter
, D3DXMATRIX
*matrix
)
2948 struct ID3DXEffectImpl
*effect
= impl_from_ID3DXEffect(iface
);
2950 TRACE("iface %p, parameter %p, matrix %p.\n", iface
, parameter
, matrix
);
2952 return d3dx9_base_effect_get_matrix_transpose(&effect
->base_effect
, parameter
, matrix
);
2955 static HRESULT WINAPI
ID3DXEffectImpl_SetMatrixTransposeArray(ID3DXEffect
*iface
,
2956 D3DXHANDLE parameter
, const D3DXMATRIX
*matrix
, UINT count
)
2958 struct ID3DXEffectImpl
*effect
= impl_from_ID3DXEffect(iface
);
2960 TRACE("iface %p, parameter %p, matrix %p, count %u.\n", iface
, parameter
, matrix
, count
);
2962 return d3dx9_base_effect_set_matrix_transpose_array(&effect
->base_effect
, parameter
, matrix
, count
);
2965 static HRESULT WINAPI
ID3DXEffectImpl_GetMatrixTransposeArray(ID3DXEffect
*iface
,
2966 D3DXHANDLE parameter
, D3DXMATRIX
*matrix
, UINT count
)
2968 struct ID3DXEffectImpl
*effect
= impl_from_ID3DXEffect(iface
);
2970 TRACE("iface %p, parameter %p, matrix %p, count %u.\n", iface
, parameter
, matrix
, count
);
2972 return d3dx9_base_effect_get_matrix_transpose_array(&effect
->base_effect
, parameter
, matrix
, count
);
2975 static HRESULT WINAPI
ID3DXEffectImpl_SetMatrixTransposePointerArray(ID3DXEffect
*iface
,
2976 D3DXHANDLE parameter
, const D3DXMATRIX
**matrix
, UINT count
)
2978 struct ID3DXEffectImpl
*effect
= impl_from_ID3DXEffect(iface
);
2980 TRACE("iface %p, parameter %p, matrix %p, count %u.\n", iface
, parameter
, matrix
, count
);
2982 return d3dx9_base_effect_set_matrix_transpose_pointer_array(&effect
->base_effect
, parameter
, matrix
, count
);
2985 static HRESULT WINAPI
ID3DXEffectImpl_GetMatrixTransposePointerArray(ID3DXEffect
*iface
,
2986 D3DXHANDLE parameter
, D3DXMATRIX
**matrix
, UINT count
)
2988 struct ID3DXEffectImpl
*effect
= impl_from_ID3DXEffect(iface
);
2990 TRACE("iface %p, parameter %p, matrix %p, count %u.\n", iface
, parameter
, matrix
, count
);
2992 return d3dx9_base_effect_get_matrix_transpose_pointer_array(&effect
->base_effect
, parameter
, matrix
, count
);
2995 static HRESULT WINAPI
ID3DXEffectImpl_SetString(ID3DXEffect
*iface
, D3DXHANDLE parameter
, const char *string
)
2997 struct ID3DXEffectImpl
*effect
= impl_from_ID3DXEffect(iface
);
2999 TRACE("iface %p, parameter %p, string %s.\n", iface
, parameter
, debugstr_a(string
));
3001 return d3dx9_base_effect_set_string(&effect
->base_effect
, parameter
, string
);
3004 static HRESULT WINAPI
ID3DXEffectImpl_GetString(ID3DXEffect
*iface
, D3DXHANDLE parameter
, const char **string
)
3006 struct ID3DXEffectImpl
*effect
= impl_from_ID3DXEffect(iface
);
3008 TRACE("iface %p, parameter %p, string %p.\n", iface
, parameter
, string
);
3010 return d3dx9_base_effect_get_string(&effect
->base_effect
, parameter
, string
);
3013 static HRESULT WINAPI
ID3DXEffectImpl_SetTexture(struct ID3DXEffect
*iface
,
3014 D3DXHANDLE parameter
, struct IDirect3DBaseTexture9
*texture
)
3016 struct ID3DXEffectImpl
*effect
= impl_from_ID3DXEffect(iface
);
3018 TRACE("iface %p, parameter %p, texture %p.\n", iface
, parameter
, texture
);
3020 return d3dx9_base_effect_set_texture(&effect
->base_effect
, parameter
, texture
);
3023 static HRESULT WINAPI
ID3DXEffectImpl_GetTexture(struct ID3DXEffect
*iface
,
3024 D3DXHANDLE parameter
, struct IDirect3DBaseTexture9
**texture
)
3026 struct ID3DXEffectImpl
*effect
= impl_from_ID3DXEffect(iface
);
3028 TRACE("iface %p, parameter %p, texture %p.\n", iface
, parameter
, texture
);
3030 return d3dx9_base_effect_get_texture(&effect
->base_effect
, parameter
, texture
);
3033 static HRESULT WINAPI
ID3DXEffectImpl_GetPixelShader(ID3DXEffect
*iface
,
3034 D3DXHANDLE parameter
, struct IDirect3DPixelShader9
**shader
)
3036 struct ID3DXEffectImpl
*effect
= impl_from_ID3DXEffect(iface
);
3038 TRACE("iface %p, parameter %p, shader %p.\n", iface
, parameter
, shader
);
3040 return d3dx9_base_effect_get_pixel_shader(&effect
->base_effect
, parameter
, shader
);
3043 static HRESULT WINAPI
ID3DXEffectImpl_GetVertexShader(struct ID3DXEffect
*iface
,
3044 D3DXHANDLE parameter
, struct IDirect3DVertexShader9
**shader
)
3046 struct ID3DXEffectImpl
*effect
= impl_from_ID3DXEffect(iface
);
3048 TRACE("iface %p, parameter %p, shader %p.\n", iface
, parameter
, shader
);
3050 return d3dx9_base_effect_get_vertex_shader(&effect
->base_effect
, parameter
, shader
);
3053 static HRESULT WINAPI
ID3DXEffectImpl_SetArrayRange(ID3DXEffect
*iface
, D3DXHANDLE parameter
, UINT start
, UINT end
)
3055 struct ID3DXEffectImpl
*effect
= impl_from_ID3DXEffect(iface
);
3057 TRACE("iface %p, parameter %p, start %u, end %u.\n", iface
, parameter
, start
, end
);
3059 return d3dx9_base_effect_set_array_range(&effect
->base_effect
, parameter
, start
, end
);
3062 /*** ID3DXEffect methods ***/
3063 static HRESULT WINAPI
ID3DXEffectImpl_GetPool(ID3DXEffect
*iface
, ID3DXEffectPool
**pool
)
3065 struct ID3DXEffectImpl
*This
= impl_from_ID3DXEffect(iface
);
3067 TRACE("iface %p, pool %p\n", This
, pool
);
3071 WARN("Invalid argument supplied.\n");
3072 return D3DERR_INVALIDCALL
;
3077 This
->pool
->lpVtbl
->AddRef(This
->pool
);
3082 TRACE("Returning pool %p\n", *pool
);
3087 static HRESULT WINAPI
ID3DXEffectImpl_SetTechnique(ID3DXEffect
*iface
, D3DXHANDLE technique
)
3089 struct ID3DXEffectImpl
*This
= impl_from_ID3DXEffect(iface
);
3090 struct d3dx9_base_effect
*base
= &This
->base_effect
;
3091 struct d3dx_technique
*tech
= get_valid_technique(base
, technique
);
3093 TRACE("iface %p, technique %p\n", This
, technique
);
3097 This
->active_technique
= tech
;
3098 TRACE("Technique %p\n", tech
);
3102 WARN("Invalid argument supplied.\n");
3104 return D3DERR_INVALIDCALL
;
3107 static D3DXHANDLE WINAPI
ID3DXEffectImpl_GetCurrentTechnique(ID3DXEffect
*iface
)
3109 struct ID3DXEffectImpl
*This
= impl_from_ID3DXEffect(iface
);
3111 TRACE("iface %p\n", This
);
3113 return get_technique_handle(This
->active_technique
);
3116 static HRESULT WINAPI
ID3DXEffectImpl_ValidateTechnique(ID3DXEffect
* iface
, D3DXHANDLE technique
)
3118 struct ID3DXEffectImpl
*This
= impl_from_ID3DXEffect(iface
);
3120 FIXME("(%p)->(%p): stub\n", This
, technique
);
3125 static HRESULT WINAPI
ID3DXEffectImpl_FindNextValidTechnique(ID3DXEffect
* iface
, D3DXHANDLE technique
, D3DXHANDLE
* next_technique
)
3127 struct ID3DXEffectImpl
*This
= impl_from_ID3DXEffect(iface
);
3129 FIXME("(%p)->(%p, %p): stub\n", This
, technique
, next_technique
);
3134 static BOOL WINAPI
ID3DXEffectImpl_IsParameterUsed(ID3DXEffect
* iface
, D3DXHANDLE parameter
, D3DXHANDLE technique
)
3136 struct ID3DXEffectImpl
*This
= impl_from_ID3DXEffect(iface
);
3138 FIXME("(%p)->(%p, %p): stub\n", This
, parameter
, technique
);
3143 static HRESULT WINAPI
ID3DXEffectImpl_Begin(ID3DXEffect
*iface
, UINT
*passes
, DWORD flags
)
3145 struct ID3DXEffectImpl
*This
= impl_from_ID3DXEffect(iface
);
3146 struct d3dx_technique
*technique
= This
->active_technique
;
3148 FIXME("iface %p, passes %p, flags %#x partial stub\n", iface
, passes
, flags
);
3150 if (passes
&& technique
)
3152 if (flags
& ~(D3DXFX_DONOTSAVESTATE
| D3DXFX_DONOTSAVESAMPLERSTATE
| D3DXFX_DONOTSAVESHADERSTATE
))
3153 WARN("Invalid flags (%#x) specified.\n", flags
);
3155 if (This
->manager
|| flags
& D3DXFX_DONOTSAVESTATE
)
3157 TRACE("State capturing disabled.\n");
3161 FIXME("State capturing not supported, yet!\n");
3164 *passes
= technique
->pass_count
;
3165 This
->started
= TRUE
;
3166 This
->flags
= flags
;
3171 WARN("Invalid argument supplied.\n");
3173 return D3DERR_INVALIDCALL
;
3176 static HRESULT WINAPI
ID3DXEffectImpl_BeginPass(ID3DXEffect
*iface
, UINT pass
)
3178 struct ID3DXEffectImpl
*This
= impl_from_ID3DXEffect(iface
);
3179 struct d3dx_technique
*technique
= This
->active_technique
;
3181 TRACE("iface %p, pass %u\n", This
, pass
);
3183 if (technique
&& pass
< technique
->pass_count
&& !This
->active_pass
)
3185 This
->active_pass
= &technique
->passes
[pass
];
3187 FIXME("No states applied, yet!\n");
3192 WARN("Invalid argument supplied.\n");
3194 return D3DERR_INVALIDCALL
;
3197 static HRESULT WINAPI
ID3DXEffectImpl_CommitChanges(ID3DXEffect
* iface
)
3199 struct ID3DXEffectImpl
*This
= impl_from_ID3DXEffect(iface
);
3201 FIXME("(%p)->(): stub\n", This
);
3206 static HRESULT WINAPI
ID3DXEffectImpl_EndPass(ID3DXEffect
*iface
)
3208 struct ID3DXEffectImpl
*This
= impl_from_ID3DXEffect(iface
);
3210 TRACE("iface %p\n", This
);
3212 if (This
->active_pass
)
3214 This
->active_pass
= NULL
;
3218 WARN("Invalid call.\n");
3220 return D3DERR_INVALIDCALL
;
3223 static HRESULT WINAPI
ID3DXEffectImpl_End(ID3DXEffect
*iface
)
3225 struct ID3DXEffectImpl
*This
= impl_from_ID3DXEffect(iface
);
3227 FIXME("iface %p partial stub\n", iface
);
3232 if (This
->manager
|| This
->flags
& D3DXFX_DONOTSAVESTATE
)
3234 TRACE("State restoring disabled.\n");
3238 FIXME("State restoring not supported, yet!\n");
3241 This
->started
= FALSE
;
3246 static HRESULT WINAPI
ID3DXEffectImpl_GetDevice(ID3DXEffect
*iface
, struct IDirect3DDevice9
**device
)
3248 struct ID3DXEffectImpl
*This
= impl_from_ID3DXEffect(iface
);
3250 TRACE("iface %p, device %p\n", This
, device
);
3254 WARN("Invalid argument supplied.\n");
3255 return D3DERR_INVALIDCALL
;
3258 IDirect3DDevice9_AddRef(This
->device
);
3260 *device
= This
->device
;
3262 TRACE("Returning device %p\n", *device
);
3267 static HRESULT WINAPI
ID3DXEffectImpl_OnLostDevice(ID3DXEffect
* iface
)
3269 struct ID3DXEffectImpl
*This
= impl_from_ID3DXEffect(iface
);
3271 FIXME("(%p)->(): stub\n", This
);
3276 static HRESULT WINAPI
ID3DXEffectImpl_OnResetDevice(ID3DXEffect
* iface
)
3278 struct ID3DXEffectImpl
*This
= impl_from_ID3DXEffect(iface
);
3280 FIXME("(%p)->(): stub\n", This
);
3285 static HRESULT WINAPI
ID3DXEffectImpl_SetStateManager(ID3DXEffect
*iface
, ID3DXEffectStateManager
*manager
)
3287 struct ID3DXEffectImpl
*This
= impl_from_ID3DXEffect(iface
);
3289 TRACE("iface %p, manager %p\n", This
, manager
);
3291 if (manager
) IUnknown_AddRef(manager
);
3292 if (This
->manager
) IUnknown_Release(This
->manager
);
3294 This
->manager
= manager
;
3299 static HRESULT WINAPI
ID3DXEffectImpl_GetStateManager(ID3DXEffect
*iface
, ID3DXEffectStateManager
**manager
)
3301 struct ID3DXEffectImpl
*This
= impl_from_ID3DXEffect(iface
);
3303 TRACE("iface %p, manager %p\n", This
, manager
);
3307 WARN("Invalid argument supplied.\n");
3308 return D3DERR_INVALIDCALL
;
3311 if (This
->manager
) IUnknown_AddRef(This
->manager
);
3312 *manager
= This
->manager
;
3317 static HRESULT WINAPI
ID3DXEffectImpl_BeginParameterBlock(ID3DXEffect
* iface
)
3319 struct ID3DXEffectImpl
*This
= impl_from_ID3DXEffect(iface
);
3321 FIXME("(%p)->(): stub\n", This
);
3326 static D3DXHANDLE WINAPI
ID3DXEffectImpl_EndParameterBlock(ID3DXEffect
* iface
)
3328 struct ID3DXEffectImpl
*This
= impl_from_ID3DXEffect(iface
);
3330 FIXME("(%p)->(): stub\n", This
);
3335 static HRESULT WINAPI
ID3DXEffectImpl_ApplyParameterBlock(ID3DXEffect
* iface
, D3DXHANDLE parameter_block
)
3337 struct ID3DXEffectImpl
*This
= impl_from_ID3DXEffect(iface
);
3339 FIXME("(%p)->(%p): stub\n", This
, parameter_block
);
3344 static HRESULT WINAPI
ID3DXEffectImpl_DeleteParameterBlock(ID3DXEffect
* iface
, D3DXHANDLE parameter_block
)
3346 struct ID3DXEffectImpl
*This
= impl_from_ID3DXEffect(iface
);
3348 FIXME("(%p)->(%p): stub\n", This
, parameter_block
);
3353 static HRESULT WINAPI
ID3DXEffectImpl_CloneEffect(ID3DXEffect
*iface
,
3354 struct IDirect3DDevice9
*device
, struct ID3DXEffect
**effect
)
3356 struct ID3DXEffectImpl
*This
= impl_from_ID3DXEffect(iface
);
3358 FIXME("(%p)->(%p, %p): stub\n", This
, device
, effect
);
3363 static HRESULT WINAPI
ID3DXEffectImpl_SetRawValue(ID3DXEffect
*iface
,
3364 D3DXHANDLE parameter
, const void *data
, UINT byte_offset
, UINT bytes
)
3366 FIXME("iface %p, parameter %p, data %p, byte_offset %u, bytes %u stub!\n",
3367 iface
, parameter
, data
, byte_offset
, bytes
);
3372 static const struct ID3DXEffectVtbl ID3DXEffect_Vtbl
=
3374 /*** IUnknown methods ***/
3375 ID3DXEffectImpl_QueryInterface
,
3376 ID3DXEffectImpl_AddRef
,
3377 ID3DXEffectImpl_Release
,
3378 /*** ID3DXBaseEffect methods ***/
3379 ID3DXEffectImpl_GetDesc
,
3380 ID3DXEffectImpl_GetParameterDesc
,
3381 ID3DXEffectImpl_GetTechniqueDesc
,
3382 ID3DXEffectImpl_GetPassDesc
,
3383 ID3DXEffectImpl_GetFunctionDesc
,
3384 ID3DXEffectImpl_GetParameter
,
3385 ID3DXEffectImpl_GetParameterByName
,
3386 ID3DXEffectImpl_GetParameterBySemantic
,
3387 ID3DXEffectImpl_GetParameterElement
,
3388 ID3DXEffectImpl_GetTechnique
,
3389 ID3DXEffectImpl_GetTechniqueByName
,
3390 ID3DXEffectImpl_GetPass
,
3391 ID3DXEffectImpl_GetPassByName
,
3392 ID3DXEffectImpl_GetFunction
,
3393 ID3DXEffectImpl_GetFunctionByName
,
3394 ID3DXEffectImpl_GetAnnotation
,
3395 ID3DXEffectImpl_GetAnnotationByName
,
3396 ID3DXEffectImpl_SetValue
,
3397 ID3DXEffectImpl_GetValue
,
3398 ID3DXEffectImpl_SetBool
,
3399 ID3DXEffectImpl_GetBool
,
3400 ID3DXEffectImpl_SetBoolArray
,
3401 ID3DXEffectImpl_GetBoolArray
,
3402 ID3DXEffectImpl_SetInt
,
3403 ID3DXEffectImpl_GetInt
,
3404 ID3DXEffectImpl_SetIntArray
,
3405 ID3DXEffectImpl_GetIntArray
,
3406 ID3DXEffectImpl_SetFloat
,
3407 ID3DXEffectImpl_GetFloat
,
3408 ID3DXEffectImpl_SetFloatArray
,
3409 ID3DXEffectImpl_GetFloatArray
,
3410 ID3DXEffectImpl_SetVector
,
3411 ID3DXEffectImpl_GetVector
,
3412 ID3DXEffectImpl_SetVectorArray
,
3413 ID3DXEffectImpl_GetVectorArray
,
3414 ID3DXEffectImpl_SetMatrix
,
3415 ID3DXEffectImpl_GetMatrix
,
3416 ID3DXEffectImpl_SetMatrixArray
,
3417 ID3DXEffectImpl_GetMatrixArray
,
3418 ID3DXEffectImpl_SetMatrixPointerArray
,
3419 ID3DXEffectImpl_GetMatrixPointerArray
,
3420 ID3DXEffectImpl_SetMatrixTranspose
,
3421 ID3DXEffectImpl_GetMatrixTranspose
,
3422 ID3DXEffectImpl_SetMatrixTransposeArray
,
3423 ID3DXEffectImpl_GetMatrixTransposeArray
,
3424 ID3DXEffectImpl_SetMatrixTransposePointerArray
,
3425 ID3DXEffectImpl_GetMatrixTransposePointerArray
,
3426 ID3DXEffectImpl_SetString
,
3427 ID3DXEffectImpl_GetString
,
3428 ID3DXEffectImpl_SetTexture
,
3429 ID3DXEffectImpl_GetTexture
,
3430 ID3DXEffectImpl_GetPixelShader
,
3431 ID3DXEffectImpl_GetVertexShader
,
3432 ID3DXEffectImpl_SetArrayRange
,
3433 /*** ID3DXEffect methods ***/
3434 ID3DXEffectImpl_GetPool
,
3435 ID3DXEffectImpl_SetTechnique
,
3436 ID3DXEffectImpl_GetCurrentTechnique
,
3437 ID3DXEffectImpl_ValidateTechnique
,
3438 ID3DXEffectImpl_FindNextValidTechnique
,
3439 ID3DXEffectImpl_IsParameterUsed
,
3440 ID3DXEffectImpl_Begin
,
3441 ID3DXEffectImpl_BeginPass
,
3442 ID3DXEffectImpl_CommitChanges
,
3443 ID3DXEffectImpl_EndPass
,
3444 ID3DXEffectImpl_End
,
3445 ID3DXEffectImpl_GetDevice
,
3446 ID3DXEffectImpl_OnLostDevice
,
3447 ID3DXEffectImpl_OnResetDevice
,
3448 ID3DXEffectImpl_SetStateManager
,
3449 ID3DXEffectImpl_GetStateManager
,
3450 ID3DXEffectImpl_BeginParameterBlock
,
3451 ID3DXEffectImpl_EndParameterBlock
,
3452 ID3DXEffectImpl_ApplyParameterBlock
,
3453 ID3DXEffectImpl_DeleteParameterBlock
,
3454 ID3DXEffectImpl_CloneEffect
,
3455 ID3DXEffectImpl_SetRawValue
3458 static inline struct ID3DXEffectCompilerImpl
*impl_from_ID3DXEffectCompiler(ID3DXEffectCompiler
*iface
)
3460 return CONTAINING_RECORD(iface
, struct ID3DXEffectCompilerImpl
, ID3DXEffectCompiler_iface
);
3463 /*** IUnknown methods ***/
3464 static HRESULT WINAPI
ID3DXEffectCompilerImpl_QueryInterface(ID3DXEffectCompiler
*iface
, REFIID riid
, void **object
)
3466 TRACE("iface %p, riid %s, object %p.\n", iface
, debugstr_guid(riid
), object
);
3468 if (IsEqualGUID(riid
, &IID_IUnknown
) ||
3469 IsEqualGUID(riid
, &IID_ID3DXEffectCompiler
))
3471 iface
->lpVtbl
->AddRef(iface
);
3476 ERR("Interface %s not found\n", debugstr_guid(riid
));
3478 return E_NOINTERFACE
;
3481 static ULONG WINAPI
ID3DXEffectCompilerImpl_AddRef(ID3DXEffectCompiler
*iface
)
3483 struct ID3DXEffectCompilerImpl
*This
= impl_from_ID3DXEffectCompiler(iface
);
3485 TRACE("iface %p: AddRef from %u\n", iface
, This
->ref
);
3487 return InterlockedIncrement(&This
->ref
);
3490 static ULONG WINAPI
ID3DXEffectCompilerImpl_Release(ID3DXEffectCompiler
*iface
)
3492 struct ID3DXEffectCompilerImpl
*This
= impl_from_ID3DXEffectCompiler(iface
);
3493 ULONG ref
= InterlockedDecrement(&This
->ref
);
3495 TRACE("iface %p: Release from %u\n", iface
, ref
+ 1);
3499 free_effect_compiler(This
);
3500 HeapFree(GetProcessHeap(), 0, This
);
3506 /*** ID3DXBaseEffect methods ***/
3507 static HRESULT WINAPI
ID3DXEffectCompilerImpl_GetDesc(ID3DXEffectCompiler
*iface
, D3DXEFFECT_DESC
*desc
)
3509 struct ID3DXEffectCompilerImpl
*compiler
= impl_from_ID3DXEffectCompiler(iface
);
3511 TRACE("iface %p, desc %p.\n", iface
, desc
);
3513 return d3dx9_base_effect_get_desc(&compiler
->base_effect
, desc
);
3516 static HRESULT WINAPI
ID3DXEffectCompilerImpl_GetParameterDesc(ID3DXEffectCompiler
*iface
,
3517 D3DXHANDLE parameter
, D3DXPARAMETER_DESC
*desc
)
3519 struct ID3DXEffectCompilerImpl
*compiler
= impl_from_ID3DXEffectCompiler(iface
);
3521 TRACE("iface %p, parameter %p, desc %p.\n", iface
, parameter
, desc
);
3523 return d3dx9_base_effect_get_parameter_desc(&compiler
->base_effect
, parameter
, desc
);
3526 static HRESULT WINAPI
ID3DXEffectCompilerImpl_GetTechniqueDesc(ID3DXEffectCompiler
*iface
,
3527 D3DXHANDLE technique
, D3DXTECHNIQUE_DESC
*desc
)
3529 struct ID3DXEffectCompilerImpl
*compiler
= impl_from_ID3DXEffectCompiler(iface
);
3531 TRACE("iface %p, technique %p, desc %p.\n", iface
, technique
, desc
);
3533 return d3dx9_base_effect_get_technique_desc(&compiler
->base_effect
, technique
, desc
);
3536 static HRESULT WINAPI
ID3DXEffectCompilerImpl_GetPassDesc(ID3DXEffectCompiler
*iface
,
3537 D3DXHANDLE pass
, D3DXPASS_DESC
*desc
)
3539 struct ID3DXEffectCompilerImpl
*compiler
= impl_from_ID3DXEffectCompiler(iface
);
3541 TRACE("iface %p, pass %p, desc %p.\n", iface
, pass
, desc
);
3543 return d3dx9_base_effect_get_pass_desc(&compiler
->base_effect
, pass
, desc
);
3546 static HRESULT WINAPI
ID3DXEffectCompilerImpl_GetFunctionDesc(ID3DXEffectCompiler
*iface
,
3547 D3DXHANDLE shader
, D3DXFUNCTION_DESC
*desc
)
3549 struct ID3DXEffectCompilerImpl
*compiler
= impl_from_ID3DXEffectCompiler(iface
);
3551 TRACE("iface %p, shader %p, desc %p.\n", iface
, shader
, desc
);
3553 return d3dx9_base_effect_get_function_desc(&compiler
->base_effect
, shader
, desc
);
3556 static D3DXHANDLE WINAPI
ID3DXEffectCompilerImpl_GetParameter(ID3DXEffectCompiler
*iface
,
3557 D3DXHANDLE parameter
, UINT index
)
3559 struct ID3DXEffectCompilerImpl
*compiler
= impl_from_ID3DXEffectCompiler(iface
);
3561 TRACE("iface %p, parameter %p, index %u.\n", iface
, parameter
, index
);
3563 return d3dx9_base_effect_get_parameter(&compiler
->base_effect
, parameter
, index
);
3566 static D3DXHANDLE WINAPI
ID3DXEffectCompilerImpl_GetParameterByName(ID3DXEffectCompiler
*iface
,
3567 D3DXHANDLE parameter
, const char *name
)
3569 struct ID3DXEffectCompilerImpl
*compiler
= impl_from_ID3DXEffectCompiler(iface
);
3571 TRACE("iface %p, parameter %p, name %s.\n", iface
, parameter
, debugstr_a(name
));
3573 return d3dx9_base_effect_get_parameter_by_name(&compiler
->base_effect
, parameter
, name
);
3576 static D3DXHANDLE WINAPI
ID3DXEffectCompilerImpl_GetParameterBySemantic(ID3DXEffectCompiler
*iface
,
3577 D3DXHANDLE parameter
, const char *semantic
)
3579 struct ID3DXEffectCompilerImpl
*compiler
= impl_from_ID3DXEffectCompiler(iface
);
3581 TRACE("iface %p, parameter %p, semantic %s.\n", iface
, parameter
, debugstr_a(semantic
));
3583 return d3dx9_base_effect_get_parameter_by_semantic(&compiler
->base_effect
, parameter
, semantic
);
3586 static D3DXHANDLE WINAPI
ID3DXEffectCompilerImpl_GetParameterElement(ID3DXEffectCompiler
*iface
,
3587 D3DXHANDLE parameter
, UINT index
)
3589 struct ID3DXEffectCompilerImpl
*compiler
= impl_from_ID3DXEffectCompiler(iface
);
3591 TRACE("iface %p, parameter %p, index %u.\n", iface
, parameter
, index
);
3593 return d3dx9_base_effect_get_parameter_element(&compiler
->base_effect
, parameter
, index
);
3596 static D3DXHANDLE WINAPI
ID3DXEffectCompilerImpl_GetTechnique(ID3DXEffectCompiler
*iface
, UINT index
)
3598 struct ID3DXEffectCompilerImpl
*compiler
= impl_from_ID3DXEffectCompiler(iface
);
3600 TRACE("iface %p, index %u.\n", iface
, index
);
3602 return d3dx9_base_effect_get_technique(&compiler
->base_effect
, index
);
3605 static D3DXHANDLE WINAPI
ID3DXEffectCompilerImpl_GetTechniqueByName(ID3DXEffectCompiler
*iface
, const char *name
)
3607 struct ID3DXEffectCompilerImpl
*compiler
= impl_from_ID3DXEffectCompiler(iface
);
3609 TRACE("iface %p, name %s.\n", iface
, debugstr_a(name
));
3611 return d3dx9_base_effect_get_technique_by_name(&compiler
->base_effect
, name
);
3614 static D3DXHANDLE WINAPI
ID3DXEffectCompilerImpl_GetPass(ID3DXEffectCompiler
*iface
, D3DXHANDLE technique
, UINT index
)
3616 struct ID3DXEffectCompilerImpl
*compiler
= impl_from_ID3DXEffectCompiler(iface
);
3618 TRACE("iface %p, technique %p, index %u.\n", iface
, technique
, index
);
3620 return d3dx9_base_effect_get_pass(&compiler
->base_effect
, technique
, index
);
3623 static D3DXHANDLE WINAPI
ID3DXEffectCompilerImpl_GetPassByName(ID3DXEffectCompiler
*iface
,
3624 D3DXHANDLE technique
, const char *name
)
3626 struct ID3DXEffectCompilerImpl
*compiler
= impl_from_ID3DXEffectCompiler(iface
);
3628 TRACE("iface %p, technique %p, name %s.\n", iface
, technique
, debugstr_a(name
));
3630 return d3dx9_base_effect_get_pass_by_name(&compiler
->base_effect
, technique
, name
);
3633 static D3DXHANDLE WINAPI
ID3DXEffectCompilerImpl_GetFunction(ID3DXEffectCompiler
*iface
, UINT index
)
3635 struct ID3DXEffectCompilerImpl
*compiler
= impl_from_ID3DXEffectCompiler(iface
);
3637 TRACE("iface %p, index %u.\n", iface
, index
);
3639 return d3dx9_base_effect_get_function(&compiler
->base_effect
, index
);
3642 static D3DXHANDLE WINAPI
ID3DXEffectCompilerImpl_GetFunctionByName(ID3DXEffectCompiler
*iface
, const char *name
)
3644 struct ID3DXEffectCompilerImpl
*compiler
= impl_from_ID3DXEffectCompiler(iface
);
3646 TRACE("iface %p, name %s.\n", iface
, debugstr_a(name
));
3648 return d3dx9_base_effect_get_function_by_name(&compiler
->base_effect
, name
);
3651 static D3DXHANDLE WINAPI
ID3DXEffectCompilerImpl_GetAnnotation(ID3DXEffectCompiler
*iface
,
3652 D3DXHANDLE object
, UINT index
)
3654 struct ID3DXEffectCompilerImpl
*compiler
= impl_from_ID3DXEffectCompiler(iface
);
3656 TRACE("iface %p, object %p, index %u.\n", iface
, object
, index
);
3658 return d3dx9_base_effect_get_annotation(&compiler
->base_effect
, object
, index
);
3661 static D3DXHANDLE WINAPI
ID3DXEffectCompilerImpl_GetAnnotationByName(ID3DXEffectCompiler
*iface
,
3662 D3DXHANDLE object
, const char *name
)
3664 struct ID3DXEffectCompilerImpl
*compiler
= impl_from_ID3DXEffectCompiler(iface
);
3666 TRACE("iface %p, object %p, name %s.\n", iface
, object
, debugstr_a(name
));
3668 return d3dx9_base_effect_get_annotation_by_name(&compiler
->base_effect
, object
, name
);
3671 static HRESULT WINAPI
ID3DXEffectCompilerImpl_SetValue(ID3DXEffectCompiler
*iface
,
3672 D3DXHANDLE parameter
, const void *data
, UINT bytes
)
3674 struct ID3DXEffectCompilerImpl
*compiler
= impl_from_ID3DXEffectCompiler(iface
);
3676 TRACE("iface %p, parameter %p, data %p, bytes %u.\n", iface
, parameter
, data
, bytes
);
3678 return d3dx9_base_effect_set_value(&compiler
->base_effect
, parameter
, data
, bytes
);
3681 static HRESULT WINAPI
ID3DXEffectCompilerImpl_GetValue(ID3DXEffectCompiler
*iface
,
3682 D3DXHANDLE parameter
, void *data
, UINT bytes
)
3684 struct ID3DXEffectCompilerImpl
*compiler
= impl_from_ID3DXEffectCompiler(iface
);
3686 TRACE("iface %p, parameter %p, data %p, bytes %u.\n", iface
, parameter
, data
, bytes
);
3688 return d3dx9_base_effect_get_value(&compiler
->base_effect
, parameter
, data
, bytes
);
3691 static HRESULT WINAPI
ID3DXEffectCompilerImpl_SetBool(ID3DXEffectCompiler
*iface
, D3DXHANDLE parameter
, BOOL b
)
3693 struct ID3DXEffectCompilerImpl
*compiler
= impl_from_ID3DXEffectCompiler(iface
);
3695 TRACE("iface %p, parameter %p, b %#x.\n", iface
, parameter
, b
);
3697 return d3dx9_base_effect_set_bool(&compiler
->base_effect
, parameter
, b
);
3700 static HRESULT WINAPI
ID3DXEffectCompilerImpl_GetBool(ID3DXEffectCompiler
*iface
, D3DXHANDLE parameter
, BOOL
*b
)
3702 struct ID3DXEffectCompilerImpl
*compiler
= impl_from_ID3DXEffectCompiler(iface
);
3704 TRACE("iface %p, parameter %p, b %p.\n", iface
, parameter
, b
);
3706 return d3dx9_base_effect_get_bool(&compiler
->base_effect
, parameter
, b
);
3709 static HRESULT WINAPI
ID3DXEffectCompilerImpl_SetBoolArray(ID3DXEffectCompiler
*iface
,
3710 D3DXHANDLE parameter
, const BOOL
*b
, UINT count
)
3712 struct ID3DXEffectCompilerImpl
*compiler
= impl_from_ID3DXEffectCompiler(iface
);
3714 TRACE("iface %p, parameter %p, b %p, count %u.\n", iface
, parameter
, b
, count
);
3716 return d3dx9_base_effect_set_bool_array(&compiler
->base_effect
, parameter
, b
, count
);
3719 static HRESULT WINAPI
ID3DXEffectCompilerImpl_GetBoolArray(ID3DXEffectCompiler
*iface
,
3720 D3DXHANDLE parameter
, BOOL
*b
, UINT count
)
3722 struct ID3DXEffectCompilerImpl
*compiler
= impl_from_ID3DXEffectCompiler(iface
);
3724 TRACE("iface %p, parameter %p, b %p, count %u.\n", iface
, parameter
, b
, count
);
3726 return d3dx9_base_effect_get_bool_array(&compiler
->base_effect
, parameter
, b
, count
);
3729 static HRESULT WINAPI
ID3DXEffectCompilerImpl_SetInt(ID3DXEffectCompiler
*iface
, D3DXHANDLE parameter
, INT n
)
3731 struct ID3DXEffectCompilerImpl
*compiler
= impl_from_ID3DXEffectCompiler(iface
);
3733 TRACE("iface %p, parameter %p, n %d.\n", iface
, parameter
, n
);
3735 return d3dx9_base_effect_set_int(&compiler
->base_effect
, parameter
, n
);
3738 static HRESULT WINAPI
ID3DXEffectCompilerImpl_GetInt(ID3DXEffectCompiler
*iface
, D3DXHANDLE parameter
, INT
*n
)
3740 struct ID3DXEffectCompilerImpl
*compiler
= impl_from_ID3DXEffectCompiler(iface
);
3742 TRACE("iface %p, parameter %p, n %p.\n", iface
, parameter
, n
);
3744 return d3dx9_base_effect_get_int(&compiler
->base_effect
, parameter
, n
);
3747 static HRESULT WINAPI
ID3DXEffectCompilerImpl_SetIntArray(ID3DXEffectCompiler
*iface
,
3748 D3DXHANDLE parameter
, const INT
*n
, UINT count
)
3750 struct ID3DXEffectCompilerImpl
*compiler
= impl_from_ID3DXEffectCompiler(iface
);
3752 TRACE("iface %p, parameter %p, n %p, count %u.\n", iface
, parameter
, n
, count
);
3754 return d3dx9_base_effect_set_int_array(&compiler
->base_effect
, parameter
, n
, count
);
3757 static HRESULT WINAPI
ID3DXEffectCompilerImpl_GetIntArray(ID3DXEffectCompiler
*iface
,
3758 D3DXHANDLE parameter
, INT
*n
, UINT count
)
3760 struct ID3DXEffectCompilerImpl
*compiler
= impl_from_ID3DXEffectCompiler(iface
);
3762 TRACE("iface %p, parameter %p, n %p, count %u.\n", iface
, parameter
, n
, count
);
3764 return d3dx9_base_effect_get_int_array(&compiler
->base_effect
, parameter
, n
, count
);
3767 static HRESULT WINAPI
ID3DXEffectCompilerImpl_SetFloat(ID3DXEffectCompiler
*iface
, D3DXHANDLE parameter
, float f
)
3769 struct ID3DXEffectCompilerImpl
*compiler
= impl_from_ID3DXEffectCompiler(iface
);
3771 TRACE("iface %p, parameter %p, f %.8e.\n", iface
, parameter
, f
);
3773 return d3dx9_base_effect_set_float(&compiler
->base_effect
, parameter
, f
);
3776 static HRESULT WINAPI
ID3DXEffectCompilerImpl_GetFloat(ID3DXEffectCompiler
*iface
, D3DXHANDLE parameter
, float *f
)
3778 struct ID3DXEffectCompilerImpl
*compiler
= impl_from_ID3DXEffectCompiler(iface
);
3780 TRACE("iface %p, parameter %p, f %p.\n", iface
, parameter
, f
);
3782 return d3dx9_base_effect_get_float(&compiler
->base_effect
, parameter
, f
);
3785 static HRESULT WINAPI
ID3DXEffectCompilerImpl_SetFloatArray(ID3DXEffectCompiler
*iface
,
3786 D3DXHANDLE parameter
, const float *f
, UINT count
)
3788 struct ID3DXEffectCompilerImpl
*compiler
= impl_from_ID3DXEffectCompiler(iface
);
3790 TRACE("iface %p, parameter %p, f %p, count %u.\n", iface
, parameter
, f
, count
);
3792 return d3dx9_base_effect_set_float_array(&compiler
->base_effect
, parameter
, f
, count
);
3795 static HRESULT WINAPI
ID3DXEffectCompilerImpl_GetFloatArray(ID3DXEffectCompiler
*iface
,
3796 D3DXHANDLE parameter
, float *f
, UINT count
)
3798 struct ID3DXEffectCompilerImpl
*compiler
= impl_from_ID3DXEffectCompiler(iface
);
3800 TRACE("iface %p, parameter %p, f %p, count %u.\n", iface
, parameter
, f
, count
);
3802 return d3dx9_base_effect_get_float_array(&compiler
->base_effect
, parameter
, f
, count
);
3805 static HRESULT WINAPI
ID3DXEffectCompilerImpl_SetVector(ID3DXEffectCompiler
*iface
,
3806 D3DXHANDLE parameter
, const D3DXVECTOR4
*vector
)
3808 struct ID3DXEffectCompilerImpl
*compiler
= impl_from_ID3DXEffectCompiler(iface
);
3810 TRACE("iface %p, parameter %p, vector %p.\n", iface
, parameter
, vector
);
3812 return d3dx9_base_effect_set_vector(&compiler
->base_effect
, parameter
, vector
);
3815 static HRESULT WINAPI
ID3DXEffectCompilerImpl_GetVector(ID3DXEffectCompiler
*iface
,
3816 D3DXHANDLE parameter
, D3DXVECTOR4
*vector
)
3818 struct ID3DXEffectCompilerImpl
*compiler
= impl_from_ID3DXEffectCompiler(iface
);
3820 TRACE("iface %p, parameter %p, vector %p.\n", iface
, parameter
, vector
);
3822 return d3dx9_base_effect_get_vector(&compiler
->base_effect
, parameter
, vector
);
3825 static HRESULT WINAPI
ID3DXEffectCompilerImpl_SetVectorArray(ID3DXEffectCompiler
*iface
,
3826 D3DXHANDLE parameter
, const D3DXVECTOR4
*vector
, UINT count
)
3828 struct ID3DXEffectCompilerImpl
*compiler
= impl_from_ID3DXEffectCompiler(iface
);
3830 TRACE("iface %p, parameter %p, vector %p, count %u.\n", iface
, parameter
, vector
, count
);
3832 return d3dx9_base_effect_set_vector_array(&compiler
->base_effect
, parameter
, vector
, count
);
3835 static HRESULT WINAPI
ID3DXEffectCompilerImpl_GetVectorArray(ID3DXEffectCompiler
*iface
,
3836 D3DXHANDLE parameter
, D3DXVECTOR4
*vector
, UINT count
)
3838 struct ID3DXEffectCompilerImpl
*compiler
= impl_from_ID3DXEffectCompiler(iface
);
3840 TRACE("iface %p, parameter %p, vector %p, count %u.\n", iface
, parameter
, vector
, count
);
3842 return d3dx9_base_effect_get_vector_array(&compiler
->base_effect
, parameter
, vector
, count
);
3845 static HRESULT WINAPI
ID3DXEffectCompilerImpl_SetMatrix(ID3DXEffectCompiler
*iface
,
3846 D3DXHANDLE parameter
, const D3DXMATRIX
*matrix
)
3848 struct ID3DXEffectCompilerImpl
*compiler
= impl_from_ID3DXEffectCompiler(iface
);
3850 TRACE("iface %p, parameter %p, matrix %p.\n", iface
, parameter
, matrix
);
3852 return d3dx9_base_effect_set_matrix(&compiler
->base_effect
, parameter
, matrix
);
3855 static HRESULT WINAPI
ID3DXEffectCompilerImpl_GetMatrix(ID3DXEffectCompiler
*iface
,
3856 D3DXHANDLE parameter
, D3DXMATRIX
*matrix
)
3858 struct ID3DXEffectCompilerImpl
*compiler
= impl_from_ID3DXEffectCompiler(iface
);
3860 TRACE("iface %p, parameter %p, matrix %p.\n", iface
, parameter
, matrix
);
3862 return d3dx9_base_effect_get_matrix(&compiler
->base_effect
, parameter
, matrix
);
3865 static HRESULT WINAPI
ID3DXEffectCompilerImpl_SetMatrixArray(ID3DXEffectCompiler
*iface
,
3866 D3DXHANDLE parameter
, const D3DXMATRIX
*matrix
, UINT count
)
3868 struct ID3DXEffectCompilerImpl
*compiler
= impl_from_ID3DXEffectCompiler(iface
);
3870 TRACE("iface %p, parameter %p, matrix %p, count %u.\n", iface
, parameter
, matrix
, count
);
3872 return d3dx9_base_effect_set_matrix_array(&compiler
->base_effect
, parameter
, matrix
, count
);
3875 static HRESULT WINAPI
ID3DXEffectCompilerImpl_GetMatrixArray(ID3DXEffectCompiler
*iface
,
3876 D3DXHANDLE parameter
, D3DXMATRIX
*matrix
, UINT count
)
3878 struct ID3DXEffectCompilerImpl
*compiler
= impl_from_ID3DXEffectCompiler(iface
);
3880 TRACE("iface %p, parameter %p, matrix %p, count %u.\n", iface
, parameter
, matrix
, count
);
3882 return d3dx9_base_effect_get_matrix_array(&compiler
->base_effect
, parameter
, matrix
, count
);
3885 static HRESULT WINAPI
ID3DXEffectCompilerImpl_SetMatrixPointerArray(ID3DXEffectCompiler
*iface
,
3886 D3DXHANDLE parameter
, const D3DXMATRIX
**matrix
, UINT count
)
3888 struct ID3DXEffectCompilerImpl
*compiler
= impl_from_ID3DXEffectCompiler(iface
);
3890 TRACE("iface %p, parameter %p, matrix %p, count %u.\n", iface
, parameter
, matrix
, count
);
3892 return d3dx9_base_effect_set_matrix_pointer_array(&compiler
->base_effect
, parameter
, matrix
, count
);
3895 static HRESULT WINAPI
ID3DXEffectCompilerImpl_GetMatrixPointerArray(ID3DXEffectCompiler
*iface
,
3896 D3DXHANDLE parameter
, D3DXMATRIX
**matrix
, UINT count
)
3898 struct ID3DXEffectCompilerImpl
*compiler
= impl_from_ID3DXEffectCompiler(iface
);
3900 TRACE("iface %p, parameter %p, matrix %p, count %u.\n", iface
, parameter
, matrix
, count
);
3902 return d3dx9_base_effect_get_matrix_pointer_array(&compiler
->base_effect
, parameter
, matrix
, count
);
3905 static HRESULT WINAPI
ID3DXEffectCompilerImpl_SetMatrixTranspose(ID3DXEffectCompiler
*iface
,
3906 D3DXHANDLE parameter
, const D3DXMATRIX
*matrix
)
3908 struct ID3DXEffectCompilerImpl
*compiler
= impl_from_ID3DXEffectCompiler(iface
);
3910 TRACE("iface %p, parameter %p, matrix %p.\n", iface
, parameter
, matrix
);
3912 return d3dx9_base_effect_set_matrix_transpose(&compiler
->base_effect
, parameter
, matrix
);
3915 static HRESULT WINAPI
ID3DXEffectCompilerImpl_GetMatrixTranspose(ID3DXEffectCompiler
*iface
,
3916 D3DXHANDLE parameter
, D3DXMATRIX
*matrix
)
3918 struct ID3DXEffectCompilerImpl
*compiler
= impl_from_ID3DXEffectCompiler(iface
);
3920 TRACE("iface %p, parameter %p, matrix %p.\n", iface
, parameter
, matrix
);
3922 return d3dx9_base_effect_get_matrix_transpose(&compiler
->base_effect
, parameter
, matrix
);
3925 static HRESULT WINAPI
ID3DXEffectCompilerImpl_SetMatrixTransposeArray(ID3DXEffectCompiler
*iface
,
3926 D3DXHANDLE parameter
, const D3DXMATRIX
*matrix
, UINT count
)
3928 struct ID3DXEffectCompilerImpl
*compiler
= impl_from_ID3DXEffectCompiler(iface
);
3930 TRACE("iface %p, parameter %p, matrix %p, count %u.\n", iface
, parameter
, matrix
, count
);
3932 return d3dx9_base_effect_set_matrix_transpose_array(&compiler
->base_effect
, parameter
, matrix
, count
);
3935 static HRESULT WINAPI
ID3DXEffectCompilerImpl_GetMatrixTransposeArray(ID3DXEffectCompiler
*iface
,
3936 D3DXHANDLE parameter
, D3DXMATRIX
*matrix
, UINT count
)
3938 struct ID3DXEffectCompilerImpl
*compiler
= impl_from_ID3DXEffectCompiler(iface
);
3940 TRACE("iface %p, parameter %p, matrix %p, count %u.\n", iface
, parameter
, matrix
, count
);
3942 return d3dx9_base_effect_get_matrix_transpose_array(&compiler
->base_effect
, parameter
, matrix
, count
);
3945 static HRESULT WINAPI
ID3DXEffectCompilerImpl_SetMatrixTransposePointerArray(ID3DXEffectCompiler
*iface
,
3946 D3DXHANDLE parameter
, const D3DXMATRIX
**matrix
, UINT count
)
3948 struct ID3DXEffectCompilerImpl
*compiler
= impl_from_ID3DXEffectCompiler(iface
);
3950 TRACE("iface %p, parameter %p, matrix %p, count %u.\n", iface
, parameter
, matrix
, count
);
3952 return d3dx9_base_effect_set_matrix_transpose_pointer_array(&compiler
->base_effect
, parameter
, matrix
, count
);
3955 static HRESULT WINAPI
ID3DXEffectCompilerImpl_GetMatrixTransposePointerArray(ID3DXEffectCompiler
*iface
,
3956 D3DXHANDLE parameter
, D3DXMATRIX
**matrix
, UINT count
)
3958 struct ID3DXEffectCompilerImpl
*compiler
= impl_from_ID3DXEffectCompiler(iface
);
3960 TRACE("iface %p, parameter %p, matrix %p, count %u.\n", iface
, parameter
, matrix
, count
);
3962 return d3dx9_base_effect_get_matrix_transpose_pointer_array(&compiler
->base_effect
, parameter
, matrix
, count
);
3965 static HRESULT WINAPI
ID3DXEffectCompilerImpl_SetString(ID3DXEffectCompiler
*iface
,
3966 D3DXHANDLE parameter
, const char *string
)
3968 struct ID3DXEffectCompilerImpl
*compiler
= impl_from_ID3DXEffectCompiler(iface
);
3970 TRACE("iface %p, parameter %p, string %s.\n", iface
, parameter
, debugstr_a(string
));
3972 return d3dx9_base_effect_set_string(&compiler
->base_effect
, parameter
, string
);
3975 static HRESULT WINAPI
ID3DXEffectCompilerImpl_GetString(ID3DXEffectCompiler
*iface
,
3976 D3DXHANDLE parameter
, const char **string
)
3978 struct ID3DXEffectCompilerImpl
*compiler
= impl_from_ID3DXEffectCompiler(iface
);
3980 TRACE("iface %p, parameter %p, string %p.\n", iface
, parameter
, string
);
3982 return d3dx9_base_effect_get_string(&compiler
->base_effect
, parameter
, string
);
3985 static HRESULT WINAPI
ID3DXEffectCompilerImpl_SetTexture(struct ID3DXEffectCompiler
*iface
,
3986 D3DXHANDLE parameter
, struct IDirect3DBaseTexture9
*texture
)
3988 struct ID3DXEffectCompilerImpl
*compiler
= impl_from_ID3DXEffectCompiler(iface
);
3990 TRACE("iface %p, parameter %p, texture %p.\n", iface
, parameter
, texture
);
3992 return d3dx9_base_effect_set_texture(&compiler
->base_effect
, parameter
, texture
);
3995 static HRESULT WINAPI
ID3DXEffectCompilerImpl_GetTexture(struct ID3DXEffectCompiler
*iface
,
3996 D3DXHANDLE parameter
, struct IDirect3DBaseTexture9
**texture
)
3998 struct ID3DXEffectCompilerImpl
*compiler
= impl_from_ID3DXEffectCompiler(iface
);
4000 TRACE("iface %p, parameter %p, texture %p.\n", iface
, parameter
, texture
);
4002 return d3dx9_base_effect_get_texture(&compiler
->base_effect
, parameter
, texture
);
4005 static HRESULT WINAPI
ID3DXEffectCompilerImpl_GetPixelShader(ID3DXEffectCompiler
*iface
,
4006 D3DXHANDLE parameter
, struct IDirect3DPixelShader9
**shader
)
4008 struct ID3DXEffectCompilerImpl
*compiler
= impl_from_ID3DXEffectCompiler(iface
);
4010 TRACE("iface %p, parameter %p, shader %p.\n", iface
, parameter
, shader
);
4012 return d3dx9_base_effect_get_pixel_shader(&compiler
->base_effect
, parameter
, shader
);
4015 static HRESULT WINAPI
ID3DXEffectCompilerImpl_GetVertexShader(struct ID3DXEffectCompiler
*iface
,
4016 D3DXHANDLE parameter
, struct IDirect3DVertexShader9
**shader
)
4018 struct ID3DXEffectCompilerImpl
*compiler
= impl_from_ID3DXEffectCompiler(iface
);
4020 TRACE("iface %p, parameter %p, shader %p.\n", iface
, parameter
, shader
);
4022 return d3dx9_base_effect_get_vertex_shader(&compiler
->base_effect
, parameter
, shader
);
4025 static HRESULT WINAPI
ID3DXEffectCompilerImpl_SetArrayRange(ID3DXEffectCompiler
*iface
,
4026 D3DXHANDLE parameter
, UINT start
, UINT end
)
4028 struct ID3DXEffectCompilerImpl
*compiler
= impl_from_ID3DXEffectCompiler(iface
);
4030 TRACE("iface %p, parameter %p, start %u, end %u.\n", iface
, parameter
, start
, end
);
4032 return d3dx9_base_effect_set_array_range(&compiler
->base_effect
, parameter
, start
, end
);
4035 /*** ID3DXEffectCompiler methods ***/
4036 static HRESULT WINAPI
ID3DXEffectCompilerImpl_SetLiteral(ID3DXEffectCompiler
*iface
, D3DXHANDLE parameter
, BOOL literal
)
4038 struct ID3DXEffectCompilerImpl
*This
= impl_from_ID3DXEffectCompiler(iface
);
4040 FIXME("iface %p, parameter %p, literal %u\n", This
, parameter
, literal
);
4045 static HRESULT WINAPI
ID3DXEffectCompilerImpl_GetLiteral(ID3DXEffectCompiler
*iface
, D3DXHANDLE parameter
, BOOL
*literal
)
4047 struct ID3DXEffectCompilerImpl
*This
= impl_from_ID3DXEffectCompiler(iface
);
4049 FIXME("iface %p, parameter %p, literal %p\n", This
, parameter
, literal
);
4054 static HRESULT WINAPI
ID3DXEffectCompilerImpl_CompileEffect(ID3DXEffectCompiler
*iface
, DWORD flags
,
4055 ID3DXBuffer
**effect
, ID3DXBuffer
**error_msgs
)
4057 struct ID3DXEffectCompilerImpl
*This
= impl_from_ID3DXEffectCompiler(iface
);
4059 FIXME("iface %p, flags %#x, effect %p, error_msgs %p stub\n", This
, flags
, effect
, error_msgs
);
4064 static HRESULT WINAPI
ID3DXEffectCompilerImpl_CompileShader(ID3DXEffectCompiler
*iface
, D3DXHANDLE function
,
4065 const char *target
, DWORD flags
, ID3DXBuffer
**shader
, ID3DXBuffer
**error_msgs
,
4066 ID3DXConstantTable
**constant_table
)
4068 struct ID3DXEffectCompilerImpl
*This
= impl_from_ID3DXEffectCompiler(iface
);
4070 FIXME("iface %p, function %p, target %p, flags %#x, shader %p, error_msgs %p, constant_table %p stub\n",
4071 This
, function
, target
, flags
, shader
, error_msgs
, constant_table
);
4076 static const struct ID3DXEffectCompilerVtbl ID3DXEffectCompiler_Vtbl
=
4078 /*** IUnknown methods ***/
4079 ID3DXEffectCompilerImpl_QueryInterface
,
4080 ID3DXEffectCompilerImpl_AddRef
,
4081 ID3DXEffectCompilerImpl_Release
,
4082 /*** ID3DXBaseEffect methods ***/
4083 ID3DXEffectCompilerImpl_GetDesc
,
4084 ID3DXEffectCompilerImpl_GetParameterDesc
,
4085 ID3DXEffectCompilerImpl_GetTechniqueDesc
,
4086 ID3DXEffectCompilerImpl_GetPassDesc
,
4087 ID3DXEffectCompilerImpl_GetFunctionDesc
,
4088 ID3DXEffectCompilerImpl_GetParameter
,
4089 ID3DXEffectCompilerImpl_GetParameterByName
,
4090 ID3DXEffectCompilerImpl_GetParameterBySemantic
,
4091 ID3DXEffectCompilerImpl_GetParameterElement
,
4092 ID3DXEffectCompilerImpl_GetTechnique
,
4093 ID3DXEffectCompilerImpl_GetTechniqueByName
,
4094 ID3DXEffectCompilerImpl_GetPass
,
4095 ID3DXEffectCompilerImpl_GetPassByName
,
4096 ID3DXEffectCompilerImpl_GetFunction
,
4097 ID3DXEffectCompilerImpl_GetFunctionByName
,
4098 ID3DXEffectCompilerImpl_GetAnnotation
,
4099 ID3DXEffectCompilerImpl_GetAnnotationByName
,
4100 ID3DXEffectCompilerImpl_SetValue
,
4101 ID3DXEffectCompilerImpl_GetValue
,
4102 ID3DXEffectCompilerImpl_SetBool
,
4103 ID3DXEffectCompilerImpl_GetBool
,
4104 ID3DXEffectCompilerImpl_SetBoolArray
,
4105 ID3DXEffectCompilerImpl_GetBoolArray
,
4106 ID3DXEffectCompilerImpl_SetInt
,
4107 ID3DXEffectCompilerImpl_GetInt
,
4108 ID3DXEffectCompilerImpl_SetIntArray
,
4109 ID3DXEffectCompilerImpl_GetIntArray
,
4110 ID3DXEffectCompilerImpl_SetFloat
,
4111 ID3DXEffectCompilerImpl_GetFloat
,
4112 ID3DXEffectCompilerImpl_SetFloatArray
,
4113 ID3DXEffectCompilerImpl_GetFloatArray
,
4114 ID3DXEffectCompilerImpl_SetVector
,
4115 ID3DXEffectCompilerImpl_GetVector
,
4116 ID3DXEffectCompilerImpl_SetVectorArray
,
4117 ID3DXEffectCompilerImpl_GetVectorArray
,
4118 ID3DXEffectCompilerImpl_SetMatrix
,
4119 ID3DXEffectCompilerImpl_GetMatrix
,
4120 ID3DXEffectCompilerImpl_SetMatrixArray
,
4121 ID3DXEffectCompilerImpl_GetMatrixArray
,
4122 ID3DXEffectCompilerImpl_SetMatrixPointerArray
,
4123 ID3DXEffectCompilerImpl_GetMatrixPointerArray
,
4124 ID3DXEffectCompilerImpl_SetMatrixTranspose
,
4125 ID3DXEffectCompilerImpl_GetMatrixTranspose
,
4126 ID3DXEffectCompilerImpl_SetMatrixTransposeArray
,
4127 ID3DXEffectCompilerImpl_GetMatrixTransposeArray
,
4128 ID3DXEffectCompilerImpl_SetMatrixTransposePointerArray
,
4129 ID3DXEffectCompilerImpl_GetMatrixTransposePointerArray
,
4130 ID3DXEffectCompilerImpl_SetString
,
4131 ID3DXEffectCompilerImpl_GetString
,
4132 ID3DXEffectCompilerImpl_SetTexture
,
4133 ID3DXEffectCompilerImpl_GetTexture
,
4134 ID3DXEffectCompilerImpl_GetPixelShader
,
4135 ID3DXEffectCompilerImpl_GetVertexShader
,
4136 ID3DXEffectCompilerImpl_SetArrayRange
,
4137 /*** ID3DXEffectCompiler methods ***/
4138 ID3DXEffectCompilerImpl_SetLiteral
,
4139 ID3DXEffectCompilerImpl_GetLiteral
,
4140 ID3DXEffectCompilerImpl_CompileEffect
,
4141 ID3DXEffectCompilerImpl_CompileShader
,
4144 static HRESULT
d3dx9_parse_sampler(struct d3dx_sampler
*sampler
, const char *data
, const char **ptr
,
4145 struct d3dx_object
*objects
)
4150 read_dword(ptr
, &sampler
->state_count
);
4151 TRACE("Count: %u\n", sampler
->state_count
);
4153 sampler
->states
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
, sizeof(*sampler
->states
) * sampler
->state_count
);
4154 if (!sampler
->states
)
4156 ERR("Out of memory\n");
4157 return E_OUTOFMEMORY
;
4160 for (i
= 0; i
< sampler
->state_count
; ++i
)
4162 hr
= d3dx9_parse_state(&sampler
->states
[i
], data
, ptr
, objects
);
4165 WARN("Failed to parse state %u\n", i
);
4174 for (i
= 0; i
< sampler
->state_count
; ++i
)
4176 free_state(&sampler
->states
[i
]);
4178 HeapFree(GetProcessHeap(), 0, sampler
->states
);
4179 sampler
->states
= NULL
;
4184 static HRESULT
d3dx9_parse_value(struct d3dx_parameter
*param
, void *value
, const char *data
,
4185 const char **ptr
, struct d3dx_object
*objects
)
4191 if (param
->element_count
)
4193 param
->data
= value
;
4195 for (i
= 0; i
< param
->element_count
; ++i
)
4197 struct d3dx_parameter
*member
= ¶m
->members
[i
];
4199 hr
= d3dx9_parse_value(member
, value
? (char *)value
+ old_size
: NULL
, data
, ptr
, objects
);
4202 WARN("Failed to parse value %u\n", i
);
4206 old_size
+= member
->bytes
;
4212 switch(param
->class)
4216 case D3DXPC_MATRIX_ROWS
:
4217 case D3DXPC_MATRIX_COLUMNS
:
4218 param
->data
= value
;
4222 param
->data
= value
;
4224 for (i
= 0; i
< param
->member_count
; ++i
)
4226 struct d3dx_parameter
*member
= ¶m
->members
[i
];
4228 hr
= d3dx9_parse_value(member
, (char *)value
+ old_size
, data
, ptr
, objects
);
4231 WARN("Failed to parse value %u\n", i
);
4235 old_size
+= member
->bytes
;
4240 switch (param
->type
)
4243 case D3DXPT_TEXTURE
:
4244 case D3DXPT_TEXTURE1D
:
4245 case D3DXPT_TEXTURE2D
:
4246 case D3DXPT_TEXTURE3D
:
4247 case D3DXPT_TEXTURECUBE
:
4248 case D3DXPT_PIXELSHADER
:
4249 case D3DXPT_VERTEXSHADER
:
4250 read_dword(ptr
, ¶m
->object_id
);
4251 TRACE("Id: %u\n", param
->object_id
);
4252 objects
[param
->object_id
].param
= param
;
4253 param
->data
= value
;
4256 case D3DXPT_SAMPLER
:
4257 case D3DXPT_SAMPLER1D
:
4258 case D3DXPT_SAMPLER2D
:
4259 case D3DXPT_SAMPLER3D
:
4260 case D3DXPT_SAMPLERCUBE
:
4262 struct d3dx_sampler
*sampler
;
4264 sampler
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
, sizeof(*sampler
));
4266 return E_OUTOFMEMORY
;
4268 hr
= d3dx9_parse_sampler(sampler
, data
, ptr
, objects
);
4271 HeapFree(GetProcessHeap(), 0, sampler
);
4272 WARN("Failed to parse sampler\n");
4276 param
->data
= sampler
;
4281 FIXME("Unhandled type %s\n", debug_d3dxparameter_type(param
->type
));
4287 FIXME("Unhandled class %s\n", debug_d3dxparameter_class(param
->class));
4294 static HRESULT
d3dx9_parse_init_value(struct d3dx_parameter
*param
, const char *data
, const char *ptr
,
4295 struct d3dx_object
*objects
)
4297 UINT size
= param
->bytes
;
4301 TRACE("param size: %u\n", size
);
4305 value
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
, size
);
4308 ERR("Failed to allocate data memory.\n");
4309 return E_OUTOFMEMORY
;
4312 switch(param
->class)
4319 case D3DXPC_MATRIX_ROWS
:
4320 case D3DXPC_MATRIX_COLUMNS
:
4322 TRACE("Data: %s.\n", debugstr_an(ptr
, size
));
4323 memcpy(value
, ptr
, size
);
4327 FIXME("Unhandled class %s\n", debug_d3dxparameter_class(param
->class));
4332 hr
= d3dx9_parse_value(param
, value
, data
, &ptr
, objects
);
4335 WARN("Failed to parse value\n");
4336 HeapFree(GetProcessHeap(), 0, value
);
4343 static HRESULT
d3dx9_parse_name(char **name
, const char *ptr
)
4347 read_dword(&ptr
, &size
);
4348 TRACE("Name size: %#x\n", size
);
4355 *name
= HeapAlloc(GetProcessHeap(), 0, size
);
4358 ERR("Failed to allocate name memory.\n");
4359 return E_OUTOFMEMORY
;
4362 TRACE("Name: %s.\n", debugstr_an(ptr
, size
));
4363 memcpy(*name
, ptr
, size
);
4368 static HRESULT
d3dx9_copy_data(struct d3dx_object
*object
, const char **ptr
)
4370 if (object
->size
|| object
->data
)
4371 FIXME("Object already initialized!\n");
4373 read_dword(ptr
, &object
->size
);
4374 TRACE("Data size: %#x\n", object
->size
);
4376 object
->data
= HeapAlloc(GetProcessHeap(), 0, object
->size
);
4379 ERR("Failed to allocate name memory.\n");
4380 return E_OUTOFMEMORY
;
4383 TRACE("Data: %s.\n", debugstr_an(*ptr
, object
->size
));
4384 memcpy(object
->data
, *ptr
, object
->size
);
4386 *ptr
+= ((object
->size
+ 3) & ~3);
4391 static HRESULT
d3dx9_parse_effect_typedef(struct d3dx_parameter
*param
, const char *data
, const char **ptr
,
4392 struct d3dx_parameter
*parent
, UINT flags
)
4398 param
->flags
= flags
;
4402 read_dword(ptr
, ¶m
->type
);
4403 TRACE("Type: %s\n", debug_d3dxparameter_type(param
->type
));
4405 read_dword(ptr
, ¶m
->class);
4406 TRACE("Class: %s\n", debug_d3dxparameter_class(param
->class));
4408 read_dword(ptr
, &offset
);
4409 TRACE("Type name offset: %#x\n", offset
);
4410 hr
= d3dx9_parse_name(¶m
->name
, data
+ offset
);
4413 WARN("Failed to parse name\n");
4417 read_dword(ptr
, &offset
);
4418 TRACE("Type semantic offset: %#x\n", offset
);
4419 hr
= d3dx9_parse_name(¶m
->semantic
, data
+ offset
);
4422 WARN("Failed to parse semantic\n");
4426 read_dword(ptr
, ¶m
->element_count
);
4427 TRACE("Elements: %u\n", param
->element_count
);
4429 switch (param
->class)
4432 read_dword(ptr
, ¶m
->columns
);
4433 TRACE("Columns: %u\n", param
->columns
);
4435 read_dword(ptr
, ¶m
->rows
);
4436 TRACE("Rows: %u\n", param
->rows
);
4438 /* sizeof(DWORD) * rows * columns */
4439 param
->bytes
= 4 * param
->rows
* param
->columns
;
4443 case D3DXPC_MATRIX_ROWS
:
4444 case D3DXPC_MATRIX_COLUMNS
:
4445 read_dword(ptr
, ¶m
->rows
);
4446 TRACE("Rows: %u\n", param
->rows
);
4448 read_dword(ptr
, ¶m
->columns
);
4449 TRACE("Columns: %u\n", param
->columns
);
4451 /* sizeof(DWORD) * rows * columns */
4452 param
->bytes
= 4 * param
->rows
* param
->columns
;
4456 read_dword(ptr
, ¶m
->member_count
);
4457 TRACE("Members: %u\n", param
->member_count
);
4461 switch (param
->type
)
4464 case D3DXPT_PIXELSHADER
:
4465 case D3DXPT_VERTEXSHADER
:
4466 case D3DXPT_TEXTURE
:
4467 case D3DXPT_TEXTURE1D
:
4468 case D3DXPT_TEXTURE2D
:
4469 case D3DXPT_TEXTURE3D
:
4470 case D3DXPT_TEXTURECUBE
:
4471 param
->bytes
= sizeof(void *);
4474 case D3DXPT_SAMPLER
:
4475 case D3DXPT_SAMPLER1D
:
4476 case D3DXPT_SAMPLER2D
:
4477 case D3DXPT_SAMPLER3D
:
4478 case D3DXPT_SAMPLERCUBE
:
4483 FIXME("Unhandled type %s\n", debug_d3dxparameter_type(param
->type
));
4489 FIXME("Unhandled class %s\n", debug_d3dxparameter_class(param
->class));
4496 param
->type
= parent
->type
;
4497 param
->class = parent
->class;
4498 param
->name
= parent
->name
;
4499 param
->semantic
= parent
->semantic
;
4500 param
->element_count
= 0;
4501 param
->annotation_count
= 0;
4502 param
->member_count
= parent
->member_count
;
4503 param
->bytes
= parent
->bytes
;
4504 param
->rows
= parent
->rows
;
4505 param
->columns
= parent
->columns
;
4508 if (param
->element_count
)
4510 unsigned int param_bytes
= 0;
4511 const char *save_ptr
= *ptr
;
4513 param
->members
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
, sizeof(*param
->members
) * param
->element_count
);
4514 if (!param
->members
)
4516 ERR("Out of memory\n");
4521 for (i
= 0; i
< param
->element_count
; ++i
)
4525 hr
= d3dx9_parse_effect_typedef(¶m
->members
[i
], data
, ptr
, param
, flags
);
4528 WARN("Failed to parse member %u\n", i
);
4532 param_bytes
+= param
->members
[i
].bytes
;
4535 param
->bytes
= param_bytes
;
4537 else if (param
->member_count
)
4539 param
->members
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
, sizeof(*param
->members
) * param
->member_count
);
4540 if (!param
->members
)
4542 ERR("Out of memory\n");
4547 for (i
= 0; i
< param
->member_count
; ++i
)
4549 hr
= d3dx9_parse_effect_typedef(¶m
->members
[i
], data
, ptr
, NULL
, flags
);
4552 WARN("Failed to parse member %u\n", i
);
4556 param
->bytes
+= param
->members
[i
].bytes
;
4565 unsigned int count
= param
->element_count
? param
->element_count
: param
->member_count
;
4567 for (i
= 0; i
< count
; ++i
)
4568 free_parameter(¶m
->members
[i
], param
->element_count
!= 0, TRUE
);
4569 HeapFree(GetProcessHeap(), 0, param
->members
);
4570 param
->members
= NULL
;
4575 HeapFree(GetProcessHeap(), 0, param
->name
);
4576 HeapFree(GetProcessHeap(), 0, param
->semantic
);
4579 param
->semantic
= NULL
;
4584 static HRESULT
d3dx9_parse_effect_annotation(struct d3dx_parameter
*anno
, const char *data
,
4585 const char **ptr
, struct d3dx_object
*objects
)
4591 anno
->flags
= D3DX_PARAMETER_ANNOTATION
;
4593 read_dword(ptr
, &offset
);
4594 TRACE("Typedef offset: %#x\n", offset
);
4595 ptr2
= data
+ offset
;
4596 hr
= d3dx9_parse_effect_typedef(anno
, data
, &ptr2
, NULL
, D3DX_PARAMETER_ANNOTATION
);
4599 WARN("Failed to parse type definition\n");
4603 read_dword(ptr
, &offset
);
4604 TRACE("Value offset: %#x\n", offset
);
4605 hr
= d3dx9_parse_init_value(anno
, data
, data
+ offset
, objects
);
4608 WARN("Failed to parse value\n");
4615 static HRESULT
d3dx9_parse_state(struct d3dx_state
*state
, const char *data
, const char **ptr
,
4616 struct d3dx_object
*objects
)
4621 struct d3dx_parameter
*parameter
;
4623 parameter
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
, sizeof(*parameter
));
4625 return E_OUTOFMEMORY
;
4627 state
->type
= ST_CONSTANT
;
4629 read_dword(ptr
, &state
->operation
);
4630 TRACE("Operation: %#x (%s)\n", state
->operation
, state_table
[state
->operation
].name
);
4632 read_dword(ptr
, &state
->index
);
4633 TRACE("Index: %#x\n", state
->index
);
4635 read_dword(ptr
, &offset
);
4636 TRACE("Typedef offset: %#x\n", offset
);
4637 ptr2
= data
+ offset
;
4638 hr
= d3dx9_parse_effect_typedef(parameter
, data
, &ptr2
, NULL
, 0);
4641 WARN("Failed to parse type definition\n");
4645 read_dword(ptr
, &offset
);
4646 TRACE("Value offset: %#x\n", offset
);
4647 hr
= d3dx9_parse_init_value(parameter
, data
, data
+ offset
, objects
);
4650 WARN("Failed to parse value\n");
4654 state
->parameter
= parameter
;
4660 free_parameter(parameter
, FALSE
, FALSE
);
4665 static HRESULT
d3dx9_parse_effect_parameter(struct d3dx_parameter
*param
, const char *data
,
4666 const char **ptr
, struct d3dx_object
*objects
)
4673 read_dword(ptr
, &offset
);
4674 TRACE("Typedef offset: %#x\n", offset
);
4675 ptr2
= data
+ offset
;
4677 read_dword(ptr
, &offset
);
4678 TRACE("Value offset: %#x\n", offset
);
4680 read_dword(ptr
, ¶m
->flags
);
4681 TRACE("Flags: %#x\n", param
->flags
);
4683 read_dword(ptr
, ¶m
->annotation_count
);
4684 TRACE("Annotation count: %u\n", param
->annotation_count
);
4686 hr
= d3dx9_parse_effect_typedef(param
, data
, &ptr2
, NULL
, param
->flags
);
4689 WARN("Failed to parse type definition\n");
4693 hr
= d3dx9_parse_init_value(param
, data
, data
+ offset
, objects
);
4696 WARN("Failed to parse value\n");
4700 if (param
->annotation_count
)
4702 param
->annotations
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
,
4703 sizeof(*param
->annotations
) * param
->annotation_count
);
4704 if (!param
->annotations
)
4706 ERR("Out of memory\n");
4711 for (i
= 0; i
< param
->annotation_count
; ++i
)
4713 hr
= d3dx9_parse_effect_annotation(¶m
->annotations
[i
], data
, ptr
, objects
);
4716 WARN("Failed to parse annotation\n");
4726 if (param
->annotations
)
4728 for (i
= 0; i
< param
->annotation_count
; ++i
)
4729 free_parameter(¶m
->annotations
[i
], FALSE
, FALSE
);
4730 HeapFree(GetProcessHeap(), 0, param
->annotations
);
4731 param
->annotations
= NULL
;
4737 static HRESULT
d3dx9_parse_effect_pass(struct d3dx_pass
*pass
, const char *data
, const char **ptr
,
4738 struct d3dx_object
*objects
)
4743 struct d3dx_state
*states
= NULL
;
4746 read_dword(ptr
, &offset
);
4747 TRACE("Pass name offset: %#x\n", offset
);
4748 hr
= d3dx9_parse_name(&name
, data
+ offset
);
4751 WARN("Failed to parse name\n");
4755 read_dword(ptr
, &pass
->annotation_count
);
4756 TRACE("Annotation count: %u\n", pass
->annotation_count
);
4758 read_dword(ptr
, &pass
->state_count
);
4759 TRACE("State count: %u\n", pass
->state_count
);
4761 if (pass
->annotation_count
)
4763 pass
->annotations
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
,
4764 sizeof(*pass
->annotations
) * pass
->annotation_count
);
4765 if (!pass
->annotations
)
4767 ERR("Out of memory\n");
4772 for (i
= 0; i
< pass
->annotation_count
; ++i
)
4774 hr
= d3dx9_parse_effect_annotation(&pass
->annotations
[i
], data
, ptr
, objects
);
4777 WARN("Failed to parse annotation %u\n", i
);
4783 if (pass
->state_count
)
4785 states
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
, sizeof(*states
) * pass
->state_count
);
4788 ERR("Out of memory\n");
4793 for (i
= 0; i
< pass
->state_count
; ++i
)
4795 hr
= d3dx9_parse_state(&states
[i
], data
, ptr
, objects
);
4798 WARN("Failed to parse annotation %u\n", i
);
4805 pass
->states
= states
;
4811 if (pass
->annotations
)
4813 for (i
= 0; i
< pass
->annotation_count
; ++i
)
4814 free_parameter(&pass
->annotations
[i
], FALSE
, FALSE
);
4815 HeapFree(GetProcessHeap(), 0, pass
->annotations
);
4816 pass
->annotations
= NULL
;
4821 for (i
= 0; i
< pass
->state_count
; ++i
)
4823 free_state(&states
[i
]);
4825 HeapFree(GetProcessHeap(), 0, states
);
4828 HeapFree(GetProcessHeap(), 0, name
);
4833 static HRESULT
d3dx9_parse_effect_technique(struct d3dx_technique
*technique
, const char *data
,
4834 const char **ptr
, struct d3dx_object
*objects
)
4841 read_dword(ptr
, &offset
);
4842 TRACE("Technique name offset: %#x\n", offset
);
4843 hr
= d3dx9_parse_name(&name
, data
+ offset
);
4846 WARN("Failed to parse name\n");
4850 read_dword(ptr
, &technique
->annotation_count
);
4851 TRACE("Annotation count: %u\n", technique
->annotation_count
);
4853 read_dword(ptr
, &technique
->pass_count
);
4854 TRACE("Pass count: %u\n", technique
->pass_count
);
4856 if (technique
->annotation_count
)
4858 technique
->annotations
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
,
4859 sizeof(*technique
->annotations
) * technique
->annotation_count
);
4860 if (!technique
->annotations
)
4862 ERR("Out of memory\n");
4867 for (i
= 0; i
< technique
->annotation_count
; ++i
)
4869 hr
= d3dx9_parse_effect_annotation(&technique
->annotations
[i
], data
, ptr
, objects
);
4872 WARN("Failed to parse annotation %u\n", i
);
4878 if (technique
->pass_count
)
4880 technique
->passes
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
,
4881 sizeof(*technique
->passes
) * technique
->pass_count
);
4882 if (!technique
->passes
)
4884 ERR("Out of memory\n");
4889 for (i
= 0; i
< technique
->pass_count
; ++i
)
4891 hr
= d3dx9_parse_effect_pass(&technique
->passes
[i
], data
, ptr
, objects
);
4894 WARN("Failed to parse pass %u\n", i
);
4900 technique
->name
= name
;
4906 if (technique
->passes
)
4908 for (i
= 0; i
< technique
->pass_count
; ++i
)
4909 free_pass(&technique
->passes
[i
]);
4910 HeapFree(GetProcessHeap(), 0, technique
->passes
);
4911 technique
->passes
= NULL
;
4914 if (technique
->annotations
)
4916 for (i
= 0; i
< technique
->annotation_count
; ++i
)
4917 free_parameter(&technique
->annotations
[i
], FALSE
, FALSE
);
4918 HeapFree(GetProcessHeap(), 0, technique
->annotations
);
4919 technique
->annotations
= NULL
;
4922 HeapFree(GetProcessHeap(), 0, name
);
4927 static HRESULT
d3dx9_parse_resource(struct d3dx9_base_effect
*base
, const char *data
, const char **ptr
)
4929 DWORD technique_index
;
4930 DWORD index
, state_index
, usage
, element_index
;
4931 struct d3dx_state
*state
;
4932 struct d3dx_parameter
*param
;
4933 HRESULT hr
= E_FAIL
;
4935 read_dword(ptr
, &technique_index
);
4936 TRACE("techn: %u\n", technique_index
);
4938 read_dword(ptr
, &index
);
4939 TRACE("index: %u\n", index
);
4941 read_dword(ptr
, &element_index
);
4942 TRACE("element_index: %u\n", element_index
);
4944 read_dword(ptr
, &state_index
);
4945 TRACE("state_index: %u\n", state_index
);
4947 read_dword(ptr
, &usage
);
4948 TRACE("usage: %u\n", usage
);
4950 if (technique_index
== 0xffffffff)
4952 struct d3dx_parameter
*parameter
;
4953 struct d3dx_sampler
*sampler
;
4955 if (index
>= base
->parameter_count
)
4957 FIXME("Index out of bounds: index %u >= parameter_count %u\n", index
, base
->parameter_count
);
4961 parameter
= &base
->parameters
[index
];
4962 if (element_index
!= 0xffffffff)
4964 if (element_index
>= parameter
->element_count
&& parameter
->element_count
!= 0)
4966 FIXME("Index out of bounds: element_index %u >= element_count %u\n", element_index
, parameter
->element_count
);
4970 if (parameter
->element_count
!= 0) parameter
= ¶meter
->members
[element_index
];
4973 sampler
= parameter
->data
;
4974 if (state_index
>= sampler
->state_count
)
4976 FIXME("Index out of bounds: state_index %u >= state_count %u\n", state_index
, sampler
->state_count
);
4980 state
= &sampler
->states
[state_index
];
4984 struct d3dx_technique
*technique
;
4985 struct d3dx_pass
*pass
;
4987 if (technique_index
>= base
->technique_count
)
4989 FIXME("Index out of bounds: technique_index %u >= technique_count %u\n", technique_index
, base
->technique_count
);
4993 technique
= &base
->techniques
[technique_index
];
4994 if (index
>= technique
->pass_count
)
4996 FIXME("Index out of bounds: index %u >= pass_count %u\n", index
, technique
->pass_count
);
5000 pass
= &technique
->passes
[index
];
5001 if (state_index
>= pass
->state_count
)
5003 FIXME("Index out of bounds: state_index %u >= state_count %u\n", state_index
, pass
->state_count
);
5007 state
= &pass
->states
[state_index
];
5010 param
= state
->parameter
;
5013 * TODO: Do we need to create the shader/string here or later when we access them?
5018 TRACE("usage 0: type %s\n", debug_d3dxparameter_type(param
->type
));
5019 switch (param
->type
)
5021 case D3DXPT_VERTEXSHADER
:
5022 case D3DXPT_PIXELSHADER
:
5023 state
->type
= ST_CONSTANT
;
5024 hr
= d3dx9_copy_data(&base
->objects
[param
->object_id
], ptr
);
5031 state
->type
= ST_FXLC
;
5032 hr
= d3dx9_copy_data(&base
->objects
[param
->object_id
], ptr
);
5036 FIXME("Unhandled type %s\n", debug_d3dxparameter_type(param
->type
));
5042 state
->type
= ST_PARAMETER
;
5043 hr
= d3dx9_copy_data(&base
->objects
[param
->object_id
], ptr
);
5047 FIXME("Unknown usage %x\n", usage
);
5054 static HRESULT
d3dx9_parse_effect(struct d3dx9_base_effect
*base
, const char *data
, UINT data_size
, DWORD start
)
5056 const char *ptr
= data
+ start
;
5057 UINT stringcount
, resourcecount
;
5061 read_dword(&ptr
, &base
->parameter_count
);
5062 TRACE("Parameter count: %u\n", base
->parameter_count
);
5064 read_dword(&ptr
, &base
->technique_count
);
5065 TRACE("Technique count: %u\n", base
->technique_count
);
5067 skip_dword_unknown(&ptr
, 1);
5069 read_dword(&ptr
, &base
->object_count
);
5070 TRACE("Object count: %u\n", base
->object_count
);
5072 base
->objects
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
, sizeof(*base
->objects
) * base
->object_count
);
5075 ERR("Out of memory\n");
5080 if (base
->parameter_count
)
5082 base
->parameters
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
,
5083 sizeof(*base
->parameters
) * base
->parameter_count
);
5084 if (!base
->parameters
)
5086 ERR("Out of memory\n");
5091 for (i
= 0; i
< base
->parameter_count
; ++i
)
5093 hr
= d3dx9_parse_effect_parameter(&base
->parameters
[i
], data
, &ptr
, base
->objects
);
5096 WARN("Failed to parse parameter %u\n", i
);
5102 if (base
->technique_count
)
5104 base
->techniques
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
,
5105 sizeof(*base
->techniques
) * base
->technique_count
);
5106 if (!base
->techniques
)
5108 ERR("Out of memory\n");
5113 for (i
= 0; i
< base
->technique_count
; ++i
)
5115 hr
= d3dx9_parse_effect_technique(&base
->techniques
[i
], data
, &ptr
, base
->objects
);
5118 WARN("Failed to parse technique %u\n", i
);
5124 read_dword(&ptr
, &stringcount
);
5125 TRACE("String count: %u\n", stringcount
);
5127 read_dword(&ptr
, &resourcecount
);
5128 TRACE("Resource count: %u\n", resourcecount
);
5130 for (i
= 0; i
< stringcount
; ++i
)
5134 read_dword(&ptr
, &id
);
5135 TRACE("Id: %u\n", id
);
5137 hr
= d3dx9_copy_data(&base
->objects
[id
], &ptr
);
5140 WARN("Failed to parse data %u\n", i
);
5145 for (i
= 0; i
< resourcecount
; ++i
)
5147 TRACE("parse resource %u\n", i
);
5149 hr
= d3dx9_parse_resource(base
, data
, &ptr
);
5152 WARN("Failed to parse resource %u\n", i
);
5161 if (base
->techniques
)
5163 for (i
= 0; i
< base
->technique_count
; ++i
)
5164 free_technique(&base
->techniques
[i
]);
5165 HeapFree(GetProcessHeap(), 0, base
->techniques
);
5166 base
->techniques
= NULL
;
5169 if (base
->parameters
)
5171 for (i
= 0; i
< base
->parameter_count
; ++i
)
5173 free_parameter(&base
->parameters
[i
], FALSE
, FALSE
);
5175 HeapFree(GetProcessHeap(), 0, base
->parameters
);
5176 base
->parameters
= NULL
;
5181 for (i
= 0; i
< base
->object_count
; ++i
)
5183 free_object(&base
->objects
[i
]);
5185 HeapFree(GetProcessHeap(), 0, base
->objects
);
5186 base
->objects
= NULL
;
5192 static HRESULT
d3dx9_base_effect_init(struct d3dx9_base_effect
*base
,
5193 const char *data
, SIZE_T data_size
, struct ID3DXEffectImpl
*effect
)
5196 const char *ptr
= data
;
5199 TRACE("base %p, data %p, data_size %lu, effect %p\n", base
, data
, data_size
, effect
);
5201 base
->effect
= effect
;
5203 read_dword(&ptr
, &tag
);
5204 TRACE("Tag: %x\n", tag
);
5206 if (tag
!= d3dx9_effect_version(9, 1))
5208 /* todo: compile hlsl ascii code */
5209 FIXME("HLSL ascii effects not supported, yet\n");
5211 /* Show the start of the shader for debugging info. */
5212 TRACE("effect:\n%s\n", debugstr_an(data
, data_size
> 40 ? 40 : data_size
));
5216 read_dword(&ptr
, &offset
);
5217 TRACE("Offset: %x\n", offset
);
5219 hr
= d3dx9_parse_effect(base
, ptr
, data_size
, offset
);
5222 FIXME("Failed to parse effect.\n");
5230 static HRESULT
d3dx9_effect_init(struct ID3DXEffectImpl
*effect
, struct IDirect3DDevice9
*device
,
5231 const char *data
, SIZE_T data_size
, struct ID3DXEffectPool
*pool
)
5235 TRACE("effect %p, device %p, data %p, data_size %lu, pool %p\n", effect
, device
, data
, data_size
, pool
);
5237 effect
->ID3DXEffect_iface
.lpVtbl
= &ID3DXEffect_Vtbl
;
5240 if (pool
) pool
->lpVtbl
->AddRef(pool
);
5241 effect
->pool
= pool
;
5243 IDirect3DDevice9_AddRef(device
);
5244 effect
->device
= device
;
5246 if (FAILED(hr
= d3dx9_base_effect_init(&effect
->base_effect
, data
, data_size
, effect
)))
5248 FIXME("Failed to parse effect, hr %#x.\n", hr
);
5249 free_effect(effect
);
5253 /* initialize defaults - check because of unsupported ascii effects */
5254 if (effect
->base_effect
.techniques
)
5256 effect
->active_technique
= &effect
->base_effect
.techniques
[0];
5257 effect
->active_pass
= NULL
;
5263 HRESULT WINAPI
D3DXCreateEffectEx(struct IDirect3DDevice9
*device
, const void *srcdata
, UINT srcdatalen
,
5264 const D3DXMACRO
*defines
, struct ID3DXInclude
*include
, const char *skip_constants
, DWORD flags
,
5265 struct ID3DXEffectPool
*pool
, struct ID3DXEffect
**effect
, struct ID3DXBuffer
**compilation_errors
)
5267 struct ID3DXEffectImpl
*object
;
5270 FIXME("(%p, %p, %u, %p, %p, %p, %#x, %p, %p, %p): semi-stub\n", device
, srcdata
, srcdatalen
, defines
, include
,
5271 skip_constants
, flags
, pool
, effect
, compilation_errors
);
5273 if (compilation_errors
)
5274 *compilation_errors
= NULL
;
5276 if (!device
|| !srcdata
)
5277 return D3DERR_INVALIDCALL
;
5282 /* Native dll allows effect to be null so just return D3D_OK after doing basic checks */
5286 object
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
, sizeof(*object
));
5288 return E_OUTOFMEMORY
;
5290 hr
= d3dx9_effect_init(object
, device
, srcdata
, srcdatalen
, pool
);
5293 WARN("Failed to initialize shader reflection\n");
5294 HeapFree(GetProcessHeap(), 0, object
);
5298 *effect
= &object
->ID3DXEffect_iface
;
5300 TRACE("Created ID3DXEffect %p\n", object
);
5305 HRESULT WINAPI
D3DXCreateEffect(struct IDirect3DDevice9
*device
, const void *srcdata
, UINT srcdatalen
,
5306 const D3DXMACRO
*defines
, struct ID3DXInclude
*include
, DWORD flags
,
5307 struct ID3DXEffectPool
*pool
, struct ID3DXEffect
**effect
, struct ID3DXBuffer
**compilation_errors
)
5309 TRACE("(%p, %p, %u, %p, %p, %#x, %p, %p, %p): Forwarded to D3DXCreateEffectEx\n", device
, srcdata
, srcdatalen
, defines
,
5310 include
, flags
, pool
, effect
, compilation_errors
);
5312 return D3DXCreateEffectEx(device
, srcdata
, srcdatalen
, defines
, include
, NULL
, flags
, pool
, effect
, compilation_errors
);
5315 static HRESULT
d3dx9_effect_compiler_init(struct ID3DXEffectCompilerImpl
*compiler
, const char *data
, SIZE_T data_size
)
5319 TRACE("effect %p, data %p, data_size %lu\n", compiler
, data
, data_size
);
5321 compiler
->ID3DXEffectCompiler_iface
.lpVtbl
= &ID3DXEffectCompiler_Vtbl
;
5324 if (FAILED(hr
= d3dx9_base_effect_init(&compiler
->base_effect
, data
, data_size
, NULL
)))
5326 FIXME("Failed to parse effect, hr %#x.\n", hr
);
5327 free_effect_compiler(compiler
);
5334 HRESULT WINAPI
D3DXCreateEffectCompiler(const char *srcdata
, UINT srcdatalen
, const D3DXMACRO
*defines
,
5335 ID3DXInclude
*include
, DWORD flags
, ID3DXEffectCompiler
**compiler
, ID3DXBuffer
**parse_errors
)
5337 struct ID3DXEffectCompilerImpl
*object
;
5340 TRACE("srcdata %p, srcdatalen %u, defines %p, include %p, flags %#x, compiler %p, parse_errors %p\n",
5341 srcdata
, srcdatalen
, defines
, include
, flags
, compiler
, parse_errors
);
5343 if (!srcdata
|| !compiler
)
5345 WARN("Invalid arguments supplied\n");
5346 return D3DERR_INVALIDCALL
;
5349 object
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
, sizeof(*object
));
5351 return E_OUTOFMEMORY
;
5353 hr
= d3dx9_effect_compiler_init(object
, srcdata
, srcdatalen
);
5356 WARN("Failed to initialize effect compiler\n");
5357 HeapFree(GetProcessHeap(), 0, object
);
5361 *compiler
= &object
->ID3DXEffectCompiler_iface
;
5363 TRACE("Created ID3DXEffectCompiler %p\n", object
);
5368 struct ID3DXEffectPoolImpl
5370 ID3DXEffectPool ID3DXEffectPool_iface
;
5374 static inline struct ID3DXEffectPoolImpl
*impl_from_ID3DXEffectPool(ID3DXEffectPool
*iface
)
5376 return CONTAINING_RECORD(iface
, struct ID3DXEffectPoolImpl
, ID3DXEffectPool_iface
);
5379 /*** IUnknown methods ***/
5380 static HRESULT WINAPI
ID3DXEffectPoolImpl_QueryInterface(ID3DXEffectPool
*iface
, REFIID riid
, void **object
)
5382 TRACE("(%p)->(%s, %p)\n", iface
, debugstr_guid(riid
), object
);
5384 if (IsEqualGUID(riid
, &IID_IUnknown
) ||
5385 IsEqualGUID(riid
, &IID_ID3DXEffectPool
))
5387 iface
->lpVtbl
->AddRef(iface
);
5392 WARN("Interface %s not found\n", debugstr_guid(riid
));
5394 return E_NOINTERFACE
;
5397 static ULONG WINAPI
ID3DXEffectPoolImpl_AddRef(ID3DXEffectPool
*iface
)
5399 struct ID3DXEffectPoolImpl
*This
= impl_from_ID3DXEffectPool(iface
);
5401 TRACE("(%p)->(): AddRef from %u\n", This
, This
->ref
);
5403 return InterlockedIncrement(&This
->ref
);
5406 static ULONG WINAPI
ID3DXEffectPoolImpl_Release(ID3DXEffectPool
*iface
)
5408 struct ID3DXEffectPoolImpl
*This
= impl_from_ID3DXEffectPool(iface
);
5409 ULONG ref
= InterlockedDecrement(&This
->ref
);
5411 TRACE("(%p)->(): Release from %u\n", This
, ref
+ 1);
5414 HeapFree(GetProcessHeap(), 0, This
);
5419 static const struct ID3DXEffectPoolVtbl ID3DXEffectPool_Vtbl
=
5421 /*** IUnknown methods ***/
5422 ID3DXEffectPoolImpl_QueryInterface
,
5423 ID3DXEffectPoolImpl_AddRef
,
5424 ID3DXEffectPoolImpl_Release
5427 HRESULT WINAPI
D3DXCreateEffectPool(ID3DXEffectPool
**pool
)
5429 struct ID3DXEffectPoolImpl
*object
;
5431 TRACE("(%p)\n", pool
);
5434 return D3DERR_INVALIDCALL
;
5436 object
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
, sizeof(*object
));
5438 return E_OUTOFMEMORY
;
5440 object
->ID3DXEffectPool_iface
.lpVtbl
= &ID3DXEffectPool_Vtbl
;
5443 *pool
= &object
->ID3DXEffectPool_iface
;
5448 HRESULT WINAPI
D3DXCreateEffectFromFileExW(struct IDirect3DDevice9
*device
, const WCHAR
*srcfile
,
5449 const D3DXMACRO
*defines
, struct ID3DXInclude
*include
, const char *skipconstants
, DWORD flags
,
5450 struct ID3DXEffectPool
*pool
, struct ID3DXEffect
**effect
, struct ID3DXBuffer
**compilationerrors
)
5456 TRACE("device %p, srcfile %s, defines %p, include %p, skipconstants %s, "
5457 "flags %#x, pool %p, effect %p, compilationerrors %p.\n",
5458 device
, debugstr_w(srcfile
), defines
, include
, debugstr_a(skipconstants
),
5459 flags
, pool
, effect
, compilationerrors
);
5461 if (!device
|| !srcfile
)
5462 return D3DERR_INVALIDCALL
;
5464 ret
= map_view_of_file(srcfile
, &buffer
, &size
);
5467 return D3DXERR_INVALIDDATA
;
5469 ret
= D3DXCreateEffectEx(device
, buffer
, size
, defines
, include
, skipconstants
, flags
, pool
, effect
, compilationerrors
);
5470 UnmapViewOfFile(buffer
);
5475 HRESULT WINAPI
D3DXCreateEffectFromFileExA(struct IDirect3DDevice9
*device
, const char *srcfile
,
5476 const D3DXMACRO
*defines
, struct ID3DXInclude
*include
, const char *skipconstants
, DWORD flags
,
5477 struct ID3DXEffectPool
*pool
, struct ID3DXEffect
**effect
, struct ID3DXBuffer
**compilationerrors
)
5483 TRACE("device %p, srcfile %s, defines %p, include %p, skipconstants %s, "
5484 "flags %#x, pool %p, effect %p, compilationerrors %p.\n",
5485 device
, debugstr_a(srcfile
), defines
, include
, debugstr_a(skipconstants
),
5486 flags
, pool
, effect
, compilationerrors
);
5489 return D3DERR_INVALIDCALL
;
5491 len
= MultiByteToWideChar(CP_ACP
, 0, srcfile
, -1, NULL
, 0);
5492 srcfileW
= HeapAlloc(GetProcessHeap(), 0, len
* sizeof(*srcfileW
));
5493 MultiByteToWideChar(CP_ACP
, 0, srcfile
, -1, srcfileW
, len
);
5495 ret
= D3DXCreateEffectFromFileExW(device
, srcfileW
, defines
, include
, skipconstants
, flags
, pool
, effect
, compilationerrors
);
5496 HeapFree(GetProcessHeap(), 0, srcfileW
);
5501 HRESULT WINAPI
D3DXCreateEffectFromFileW(struct IDirect3DDevice9
*device
, const WCHAR
*srcfile
,
5502 const D3DXMACRO
*defines
, struct ID3DXInclude
*include
, DWORD flags
, struct ID3DXEffectPool
*pool
,
5503 struct ID3DXEffect
**effect
, struct ID3DXBuffer
**compilationerrors
)
5505 TRACE("(void): relay\n");
5506 return D3DXCreateEffectFromFileExW(device
, srcfile
, defines
, include
, NULL
, flags
, pool
, effect
, compilationerrors
);
5509 HRESULT WINAPI
D3DXCreateEffectFromFileA(struct IDirect3DDevice9
*device
, const char *srcfile
,
5510 const D3DXMACRO
*defines
, struct ID3DXInclude
*include
, DWORD flags
, struct ID3DXEffectPool
*pool
,
5511 struct ID3DXEffect
**effect
, struct ID3DXBuffer
**compilationerrors
)
5513 TRACE("(void): relay\n");
5514 return D3DXCreateEffectFromFileExA(device
, srcfile
, defines
, include
, NULL
, flags
, pool
, effect
, compilationerrors
);
5517 HRESULT WINAPI
D3DXCreateEffectFromResourceExW(struct IDirect3DDevice9
*device
, HMODULE srcmodule
,
5518 const WCHAR
*srcresource
, const D3DXMACRO
*defines
, struct ID3DXInclude
*include
, const char *skipconstants
,
5519 DWORD flags
, struct ID3DXEffectPool
*pool
, struct ID3DXEffect
**effect
, struct ID3DXBuffer
**compilationerrors
)
5525 TRACE("device %p, srcmodule %p, srcresource %s, defines %p, include %p, skipconstants %s, "
5526 "flags %#x, pool %p, effect %p, compilationerrors %p.\n",
5527 device
, srcmodule
, debugstr_w(srcresource
), defines
, include
, debugstr_a(skipconstants
),
5528 flags
, pool
, effect
, compilationerrors
);
5531 return D3DERR_INVALIDCALL
;
5533 if (!(resinfo
= FindResourceW(srcmodule
, srcresource
, (const WCHAR
*)RT_RCDATA
)))
5534 return D3DXERR_INVALIDDATA
;
5536 if (FAILED(load_resource_into_memory(srcmodule
, resinfo
, &buffer
, &size
)))
5537 return D3DXERR_INVALIDDATA
;
5539 return D3DXCreateEffectEx(device
, buffer
, size
, defines
, include
,
5540 skipconstants
, flags
, pool
, effect
, compilationerrors
);
5543 HRESULT WINAPI
D3DXCreateEffectFromResourceExA(struct IDirect3DDevice9
*device
, HMODULE srcmodule
,
5544 const char *srcresource
, const D3DXMACRO
*defines
, struct ID3DXInclude
*include
, const char *skipconstants
,
5545 DWORD flags
, struct ID3DXEffectPool
*pool
, struct ID3DXEffect
**effect
, struct ID3DXBuffer
**compilationerrors
)
5551 TRACE("device %p, srcmodule %p, srcresource %s, defines %p, include %p, skipconstants %s, "
5552 "flags %#x, pool %p, effect %p, compilationerrors %p.\n",
5553 device
, srcmodule
, debugstr_a(srcresource
), defines
, include
, debugstr_a(skipconstants
),
5554 flags
, pool
, effect
, compilationerrors
);
5557 return D3DERR_INVALIDCALL
;
5559 if (!(resinfo
= FindResourceA(srcmodule
, srcresource
, (const char *)RT_RCDATA
)))
5560 return D3DXERR_INVALIDDATA
;
5562 if (FAILED(load_resource_into_memory(srcmodule
, resinfo
, &buffer
, &size
)))
5563 return D3DXERR_INVALIDDATA
;
5565 return D3DXCreateEffectEx(device
, buffer
, size
, defines
, include
,
5566 skipconstants
, flags
, pool
, effect
, compilationerrors
);
5569 HRESULT WINAPI
D3DXCreateEffectFromResourceW(struct IDirect3DDevice9
*device
, HMODULE srcmodule
,
5570 const WCHAR
*srcresource
, const D3DXMACRO
*defines
, struct ID3DXInclude
*include
, DWORD flags
,
5571 struct ID3DXEffectPool
*pool
, struct ID3DXEffect
**effect
, struct ID3DXBuffer
**compilationerrors
)
5573 TRACE("(void): relay\n");
5574 return D3DXCreateEffectFromResourceExW(device
, srcmodule
, srcresource
, defines
, include
, NULL
, flags
, pool
, effect
, compilationerrors
);
5577 HRESULT WINAPI
D3DXCreateEffectFromResourceA(struct IDirect3DDevice9
*device
, HMODULE srcmodule
,
5578 const char *srcresource
, const D3DXMACRO
*defines
, struct ID3DXInclude
*include
, DWORD flags
,
5579 struct ID3DXEffectPool
*pool
, struct ID3DXEffect
**effect
, struct ID3DXBuffer
**compilationerrors
)
5581 TRACE("(void): relay\n");
5582 return D3DXCreateEffectFromResourceExA(device
, srcmodule
, srcresource
, defines
, include
, NULL
, flags
, pool
, effect
, compilationerrors
);
5585 HRESULT WINAPI
D3DXCreateEffectCompilerFromFileW(const WCHAR
*srcfile
, const D3DXMACRO
*defines
,
5586 ID3DXInclude
*include
, DWORD flags
, ID3DXEffectCompiler
**effectcompiler
, ID3DXBuffer
**parseerrors
)
5592 TRACE("srcfile %s, defines %p, include %p, flags %#x, effectcompiler %p, parseerrors %p.\n",
5593 debugstr_w(srcfile
), defines
, include
, flags
, effectcompiler
, parseerrors
);
5596 return D3DERR_INVALIDCALL
;
5598 ret
= map_view_of_file(srcfile
, &buffer
, &size
);
5601 return D3DXERR_INVALIDDATA
;
5603 ret
= D3DXCreateEffectCompiler(buffer
, size
, defines
, include
, flags
, effectcompiler
, parseerrors
);
5604 UnmapViewOfFile(buffer
);
5609 HRESULT WINAPI
D3DXCreateEffectCompilerFromFileA(const char *srcfile
, const D3DXMACRO
*defines
,
5610 ID3DXInclude
*include
, DWORD flags
, ID3DXEffectCompiler
**effectcompiler
, ID3DXBuffer
**parseerrors
)
5616 TRACE("srcfile %s, defines %p, include %p, flags %#x, effectcompiler %p, parseerrors %p.\n",
5617 debugstr_a(srcfile
), defines
, include
, flags
, effectcompiler
, parseerrors
);
5620 return D3DERR_INVALIDCALL
;
5622 len
= MultiByteToWideChar(CP_ACP
, 0, srcfile
, -1, NULL
, 0);
5623 srcfileW
= HeapAlloc(GetProcessHeap(), 0, len
* sizeof(*srcfileW
));
5624 MultiByteToWideChar(CP_ACP
, 0, srcfile
, -1, srcfileW
, len
);
5626 ret
= D3DXCreateEffectCompilerFromFileW(srcfileW
, defines
, include
, flags
, effectcompiler
, parseerrors
);
5627 HeapFree(GetProcessHeap(), 0, srcfileW
);
5632 HRESULT WINAPI
D3DXCreateEffectCompilerFromResourceA(HMODULE srcmodule
, const char *srcresource
,
5633 const D3DXMACRO
*defines
, ID3DXInclude
*include
, DWORD flags
,
5634 ID3DXEffectCompiler
**effectcompiler
, ID3DXBuffer
**parseerrors
)
5640 TRACE("srcmodule %p, srcresource %s, defines %p, include %p, flags %#x, effectcompiler %p, parseerrors %p.\n",
5641 srcmodule
, debugstr_a(srcresource
), defines
, include
, flags
, effectcompiler
, parseerrors
);
5643 if (!(resinfo
= FindResourceA(srcmodule
, srcresource
, (const char *)RT_RCDATA
)))
5644 return D3DXERR_INVALIDDATA
;
5646 if (FAILED(load_resource_into_memory(srcmodule
, resinfo
, &buffer
, &size
)))
5647 return D3DXERR_INVALIDDATA
;
5649 return D3DXCreateEffectCompiler(buffer
, size
, defines
, include
, flags
, effectcompiler
, parseerrors
);
5652 HRESULT WINAPI
D3DXCreateEffectCompilerFromResourceW(HMODULE srcmodule
, const WCHAR
*srcresource
,
5653 const D3DXMACRO
*defines
, ID3DXInclude
*include
, DWORD flags
,
5654 ID3DXEffectCompiler
**effectcompiler
, ID3DXBuffer
**parseerrors
)
5660 TRACE("srcmodule %p, srcresource %s, defines %p, include %p, flags %#x, effectcompiler %p, parseerrors %p.\n",
5661 srcmodule
, debugstr_w(srcresource
), defines
, include
, flags
, effectcompiler
, parseerrors
);
5663 if (!(resinfo
= FindResourceW(srcmodule
, srcresource
, (const WCHAR
*)RT_RCDATA
)))
5664 return D3DXERR_INVALIDDATA
;
5666 if (FAILED(load_resource_into_memory(srcmodule
, resinfo
, &buffer
, &size
)))
5667 return D3DXERR_INVALIDDATA
;
5669 return D3DXCreateEffectCompiler(buffer
, size
, defines
, include
, flags
, effectcompiler
, parseerrors
);
5672 HRESULT WINAPI
D3DXDisassembleEffect(ID3DXEffect
*effect
, BOOL enable_color_code
, ID3DXBuffer
**disassembly
)
5674 FIXME("(%p, %u, %p): stub\n", effect
, enable_color_code
, disassembly
);
5676 return D3DXERR_INVALIDDATA
;