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
);
36 static const struct ID3DXEffectVtbl ID3DXEffect_Vtbl
;
37 static const struct ID3DXBaseEffectVtbl ID3DXBaseEffect_Vtbl
;
38 static const struct ID3DXEffectCompilerVtbl ID3DXEffectCompiler_Vtbl
;
85 enum SHADER_CONSTANT_TYPE
102 struct d3dx_parameter
107 D3DXPARAMETER_CLASS
class;
108 D3DXPARAMETER_TYPE type
;
112 UINT annotation_count
;
117 D3DXHANDLE
*annotation_handles
;
118 D3DXHANDLE
*member_handles
;
125 enum STATE_TYPE type
;
126 D3DXHANDLE parameter
;
132 struct d3dx_state
*states
;
139 UINT annotation_count
;
141 struct d3dx_state
*states
;
142 D3DXHANDLE
*annotation_handles
;
145 struct d3dx_technique
149 UINT annotation_count
;
151 D3DXHANDLE
*annotation_handles
;
152 D3DXHANDLE
*pass_handles
;
155 struct ID3DXBaseEffectImpl
157 ID3DXBaseEffect ID3DXBaseEffect_iface
;
160 struct ID3DXEffectImpl
*effect
;
162 UINT parameter_count
;
163 UINT technique_count
;
165 D3DXHANDLE
*parameter_handles
;
166 D3DXHANDLE
*technique_handles
;
169 struct ID3DXEffectImpl
171 ID3DXEffect ID3DXEffect_iface
;
174 LPD3DXEFFECTSTATEMANAGER manager
;
175 LPDIRECT3DDEVICE9 device
;
176 LPD3DXEFFECTPOOL pool
;
177 D3DXHANDLE active_technique
;
178 D3DXHANDLE active_pass
;
180 ID3DXBaseEffect
*base_effect
;
183 struct ID3DXEffectCompilerImpl
185 ID3DXEffectCompiler ID3DXEffectCompiler_iface
;
188 ID3DXBaseEffect
*base_effect
;
191 static struct d3dx_parameter
*get_parameter_by_name(struct ID3DXBaseEffectImpl
*base
,
192 struct d3dx_parameter
*parameter
, LPCSTR name
);
193 static struct d3dx_parameter
*get_parameter_annotation_by_name(struct d3dx_parameter
*parameter
, LPCSTR name
);
194 static HRESULT
d3dx9_parse_state(struct d3dx_state
*state
, const char *data
, const char **ptr
, D3DXHANDLE
*objects
);
195 static void free_parameter_state(D3DXHANDLE handle
, BOOL element
, BOOL child
, enum STATE_TYPE st
);
199 enum STATE_CLASS
class;
206 {SC_RENDERSTATE
, D3DRS_ZENABLE
, "D3DRS_ZENABLE"}, /* 0x0 */
207 {SC_RENDERSTATE
, D3DRS_FILLMODE
, "D3DRS_FILLMODE"},
208 {SC_RENDERSTATE
, D3DRS_SHADEMODE
, "D3DRS_SHADEMODE"},
209 {SC_RENDERSTATE
, D3DRS_ZWRITEENABLE
, "D3DRS_ZWRITEENABLE"},
210 {SC_RENDERSTATE
, D3DRS_ALPHATESTENABLE
, "D3DRS_ALPHATESTENABLE"},
211 {SC_RENDERSTATE
, D3DRS_LASTPIXEL
, "D3DRS_LASTPIXEL"},
212 {SC_RENDERSTATE
, D3DRS_SRCBLEND
, "D3DRS_SRCBLEND"},
213 {SC_RENDERSTATE
, D3DRS_DESTBLEND
, "D3DRS_DESTBLEND"},
214 {SC_RENDERSTATE
, D3DRS_CULLMODE
, "D3DRS_CULLMODE"},
215 {SC_RENDERSTATE
, D3DRS_ZFUNC
, "D3DRS_ZFUNC"},
216 {SC_RENDERSTATE
, D3DRS_ALPHAREF
, "D3DRS_ALPHAREF"},
217 {SC_RENDERSTATE
, D3DRS_ALPHAFUNC
, "D3DRS_ALPHAFUNC"},
218 {SC_RENDERSTATE
, D3DRS_DITHERENABLE
, "D3DRS_DITHERENABLE"},
219 {SC_RENDERSTATE
, D3DRS_ALPHABLENDENABLE
, "D3DRS_ALPHABLENDENABLE"},
220 {SC_RENDERSTATE
, D3DRS_FOGENABLE
, "D3DRS_FOGENABLE"},
221 {SC_RENDERSTATE
, D3DRS_SPECULARENABLE
, "D3DRS_SPECULARENABLE"},
222 {SC_RENDERSTATE
, D3DRS_FOGCOLOR
, "D3DRS_FOGCOLOR"}, /* 0x10 */
223 {SC_RENDERSTATE
, D3DRS_FOGTABLEMODE
, "D3DRS_FOGTABLEMODE"},
224 {SC_RENDERSTATE
, D3DRS_FOGSTART
, "D3DRS_FOGSTART"},
225 {SC_RENDERSTATE
, D3DRS_FOGEND
, "D3DRS_FOGEND"},
226 {SC_RENDERSTATE
, D3DRS_FOGDENSITY
, "D3DRS_FOGDENSITY"},
227 {SC_RENDERSTATE
, D3DRS_RANGEFOGENABLE
, "D3DRS_RANGEFOGENABLE"},
228 {SC_RENDERSTATE
, D3DRS_STENCILENABLE
, "D3DRS_STENCILENABLE"},
229 {SC_RENDERSTATE
, D3DRS_STENCILFAIL
, "D3DRS_STENCILFAIL"},
230 {SC_RENDERSTATE
, D3DRS_STENCILZFAIL
, "D3DRS_STENCILZFAIL"},
231 {SC_RENDERSTATE
, D3DRS_STENCILPASS
, "D3DRS_STENCILPASS"},
232 {SC_RENDERSTATE
, D3DRS_STENCILFUNC
, "D3DRS_STENCILFUNC"},
233 {SC_RENDERSTATE
, D3DRS_STENCILREF
, "D3DRS_STENCILREF"},
234 {SC_RENDERSTATE
, D3DRS_STENCILMASK
, "D3DRS_STENCILMASK"},
235 {SC_RENDERSTATE
, D3DRS_STENCILWRITEMASK
, "D3DRS_STENCILWRITEMASK"},
236 {SC_RENDERSTATE
, D3DRS_TEXTUREFACTOR
, "D3DRS_TEXTUREFACTOR"},
237 {SC_RENDERSTATE
, D3DRS_WRAP0
, "D3DRS_WRAP0"},
238 {SC_RENDERSTATE
, D3DRS_WRAP1
, "D3DRS_WRAP1"}, /* 0x20 */
239 {SC_RENDERSTATE
, D3DRS_WRAP2
, "D3DRS_WRAP2"},
240 {SC_RENDERSTATE
, D3DRS_WRAP3
, "D3DRS_WRAP3"},
241 {SC_RENDERSTATE
, D3DRS_WRAP4
, "D3DRS_WRAP4"},
242 {SC_RENDERSTATE
, D3DRS_WRAP5
, "D3DRS_WRAP5"},
243 {SC_RENDERSTATE
, D3DRS_WRAP6
, "D3DRS_WRAP6"},
244 {SC_RENDERSTATE
, D3DRS_WRAP7
, "D3DRS_WRAP7"},
245 {SC_RENDERSTATE
, D3DRS_WRAP8
, "D3DRS_WRAP8"},
246 {SC_RENDERSTATE
, D3DRS_WRAP9
, "D3DRS_WRAP9"},
247 {SC_RENDERSTATE
, D3DRS_WRAP10
, "D3DRS_WRAP10"},
248 {SC_RENDERSTATE
, D3DRS_WRAP11
, "D3DRS_WRAP11"},
249 {SC_RENDERSTATE
, D3DRS_WRAP12
, "D3DRS_WRAP12"},
250 {SC_RENDERSTATE
, D3DRS_WRAP13
, "D3DRS_WRAP13"},
251 {SC_RENDERSTATE
, D3DRS_WRAP14
, "D3DRS_WRAP14"},
252 {SC_RENDERSTATE
, D3DRS_WRAP15
, "D3DRS_WRAP15"},
253 {SC_RENDERSTATE
, D3DRS_CLIPPING
, "D3DRS_CLIPPING"},
254 {SC_RENDERSTATE
, D3DRS_LIGHTING
, "D3DRS_LIGHTING"}, /* 0x30 */
255 {SC_RENDERSTATE
, D3DRS_AMBIENT
, "D3DRS_AMBIENT"},
256 {SC_RENDERSTATE
, D3DRS_FOGVERTEXMODE
, "D3DRS_FOGVERTEXMODE"},
257 {SC_RENDERSTATE
, D3DRS_COLORVERTEX
, "D3DRS_COLORVERTEX"},
258 {SC_RENDERSTATE
, D3DRS_LOCALVIEWER
, "D3DRS_LOCALVIEWER"},
259 {SC_RENDERSTATE
, D3DRS_NORMALIZENORMALS
, "D3DRS_NORMALIZENORMALS"},
260 {SC_RENDERSTATE
, D3DRS_DIFFUSEMATERIALSOURCE
, "D3DRS_DIFFUSEMATERIALSOURCE"},
261 {SC_RENDERSTATE
, D3DRS_SPECULARMATERIALSOURCE
, "D3DRS_SPECULARMATERIALSOURCE"},
262 {SC_RENDERSTATE
, D3DRS_AMBIENTMATERIALSOURCE
, "D3DRS_AMBIENTMATERIALSOURCE"},
263 {SC_RENDERSTATE
, D3DRS_EMISSIVEMATERIALSOURCE
, "D3DRS_EMISSIVEMATERIALSOURCE"},
264 {SC_RENDERSTATE
, D3DRS_VERTEXBLEND
, "D3DRS_VERTEXBLEND"},
265 {SC_RENDERSTATE
, D3DRS_CLIPPLANEENABLE
, "D3DRS_CLIPPLANEENABLE"},
266 {SC_RENDERSTATE
, D3DRS_POINTSIZE
, "D3DRS_POINTSIZE"},
267 {SC_RENDERSTATE
, D3DRS_POINTSIZE_MIN
, "D3DRS_POINTSIZE_MIN"},
268 {SC_RENDERSTATE
, D3DRS_POINTSIZE_MAX
, "D3DRS_POINTSIZE_MAX"},
269 {SC_RENDERSTATE
, D3DRS_POINTSPRITEENABLE
, "D3DRS_POINTSPRITEENABLE"},
270 {SC_RENDERSTATE
, D3DRS_POINTSCALEENABLE
, "D3DRS_POINTSCALEENABLE"}, /* 0x40 */
271 {SC_RENDERSTATE
, D3DRS_POINTSCALE_A
, "D3DRS_POINTSCALE_A"},
272 {SC_RENDERSTATE
, D3DRS_POINTSCALE_B
, "D3DRS_POINTSCALE_B"},
273 {SC_RENDERSTATE
, D3DRS_POINTSCALE_C
, "D3DRS_POINTSCALE_C"},
274 {SC_RENDERSTATE
, D3DRS_MULTISAMPLEANTIALIAS
, "D3DRS_MULTISAMPLEANTIALIAS"},
275 {SC_RENDERSTATE
, D3DRS_MULTISAMPLEMASK
, "D3DRS_MULTISAMPLEMASK"},
276 {SC_RENDERSTATE
, D3DRS_PATCHEDGESTYLE
, "D3DRS_PATCHEDGESTYLE"},
277 {SC_RENDERSTATE
, D3DRS_DEBUGMONITORTOKEN
, "D3DRS_DEBUGMONITORTOKEN"},
278 {SC_RENDERSTATE
, D3DRS_INDEXEDVERTEXBLENDENABLE
, "D3DRS_INDEXEDVERTEXBLENDENABLE"},
279 {SC_RENDERSTATE
, D3DRS_COLORWRITEENABLE
, "D3DRS_COLORWRITEENABLE"},
280 {SC_RENDERSTATE
, D3DRS_TWEENFACTOR
, "D3DRS_TWEENFACTOR"},
281 {SC_RENDERSTATE
, D3DRS_BLENDOP
, "D3DRS_BLENDOP"},
282 {SC_RENDERSTATE
, D3DRS_POSITIONDEGREE
, "D3DRS_POSITIONDEGREE"},
283 {SC_RENDERSTATE
, D3DRS_NORMALDEGREE
, "D3DRS_NORMALDEGREE"},
284 {SC_RENDERSTATE
, D3DRS_SCISSORTESTENABLE
, "D3DRS_SCISSORTESTENABLE"},
285 {SC_RENDERSTATE
, D3DRS_SLOPESCALEDEPTHBIAS
, "D3DRS_SLOPESCALEDEPTHBIAS"},
286 {SC_RENDERSTATE
, D3DRS_ANTIALIASEDLINEENABLE
, "D3DRS_ANTIALIASEDLINEENABLE"}, /* 0x50 */
287 {SC_RENDERSTATE
, D3DRS_MINTESSELLATIONLEVEL
, "D3DRS_MINTESSELLATIONLEVEL"},
288 {SC_RENDERSTATE
, D3DRS_MAXTESSELLATIONLEVEL
, "D3DRS_MAXTESSELLATIONLEVEL"},
289 {SC_RENDERSTATE
, D3DRS_ADAPTIVETESS_X
, "D3DRS_ADAPTIVETESS_X"},
290 {SC_RENDERSTATE
, D3DRS_ADAPTIVETESS_Y
, "D3DRS_ADAPTIVETESS_Y"},
291 {SC_RENDERSTATE
, D3DRS_ADAPTIVETESS_Z
, "D3DRS_ADAPTIVETESS_Z"},
292 {SC_RENDERSTATE
, D3DRS_ADAPTIVETESS_W
, "D3DRS_ADAPTIVETESS_W"},
293 {SC_RENDERSTATE
, D3DRS_ENABLEADAPTIVETESSELLATION
, "D3DRS_ENABLEADAPTIVETESSELLATION"},
294 {SC_RENDERSTATE
, D3DRS_TWOSIDEDSTENCILMODE
, "D3DRS_TWOSIDEDSTENCILMODE"},
295 {SC_RENDERSTATE
, D3DRS_CCW_STENCILFAIL
, "D3DRS_CCW_STENCILFAIL"},
296 {SC_RENDERSTATE
, D3DRS_CCW_STENCILZFAIL
, "D3DRS_CCW_STENCILZFAIL"},
297 {SC_RENDERSTATE
, D3DRS_CCW_STENCILPASS
, "D3DRS_CCW_STENCILPASS"},
298 {SC_RENDERSTATE
, D3DRS_CCW_STENCILFUNC
, "D3DRS_CCW_STENCILFUNC"},
299 {SC_RENDERSTATE
, D3DRS_COLORWRITEENABLE1
, "D3DRS_COLORWRITEENABLE1"},
300 {SC_RENDERSTATE
, D3DRS_COLORWRITEENABLE2
, "D3DRS_COLORWRITEENABLE2"},
301 {SC_RENDERSTATE
, D3DRS_COLORWRITEENABLE3
, "D3DRS_COLORWRITEENABLE3"},
302 {SC_RENDERSTATE
, D3DRS_BLENDFACTOR
, "D3DRS_BLENDFACTOR"}, /* 0x60 */
303 {SC_RENDERSTATE
, D3DRS_SRGBWRITEENABLE
, "D3DRS_SRGBWRITEENABLE"},
304 {SC_RENDERSTATE
, D3DRS_DEPTHBIAS
, "D3DRS_DEPTHBIAS"},
305 {SC_RENDERSTATE
, D3DRS_SEPARATEALPHABLENDENABLE
, "D3DRS_SEPARATEALPHABLENDENABLE"},
306 {SC_RENDERSTATE
, D3DRS_SRCBLENDALPHA
, "D3DRS_SRCBLENDALPHA"},
307 {SC_RENDERSTATE
, D3DRS_DESTBLENDALPHA
, "D3DRS_DESTBLENDALPHA"},
308 {SC_RENDERSTATE
, D3DRS_BLENDOPALPHA
, "D3DRS_BLENDOPALPHA"},
310 {SC_TEXTURESTAGE
, D3DTSS_COLOROP
, "D3DTSS_COLOROP"},
311 {SC_TEXTURESTAGE
, D3DTSS_COLORARG0
, "D3DTSS_COLORARG0"},
312 {SC_TEXTURESTAGE
, D3DTSS_COLORARG1
, "D3DTSS_COLORARG1"},
313 {SC_TEXTURESTAGE
, D3DTSS_COLORARG2
, "D3DTSS_COLORARG2"},
314 {SC_TEXTURESTAGE
, D3DTSS_ALPHAOP
, "D3DTSS_ALPHAOP"},
315 {SC_TEXTURESTAGE
, D3DTSS_ALPHAARG0
, "D3DTSS_ALPHAARG0"},
316 {SC_TEXTURESTAGE
, D3DTSS_ALPHAARG1
, "D3DTSS_ALPHAARG1"},
317 {SC_TEXTURESTAGE
, D3DTSS_ALPHAARG2
, "D3DTSS_ALPHAARG2"},
318 {SC_TEXTURESTAGE
, D3DTSS_RESULTARG
, "D3DTSS_RESULTARG"},
319 {SC_TEXTURESTAGE
, D3DTSS_BUMPENVMAT00
, "D3DTSS_BUMPENVMAT00"}, /* 0x70 */
320 {SC_TEXTURESTAGE
, D3DTSS_BUMPENVMAT01
, "D3DTSS_BUMPENVMAT01"},
321 {SC_TEXTURESTAGE
, D3DTSS_BUMPENVMAT10
, "D3DTSS_BUMPENVMAT10"},
322 {SC_TEXTURESTAGE
, D3DTSS_BUMPENVMAT11
, "D3DTSS_BUMPENVMAT11"},
323 {SC_TEXTURESTAGE
, D3DTSS_TEXCOORDINDEX
, "D3DTSS_TEXCOORDINDEX"},
324 {SC_TEXTURESTAGE
, D3DTSS_BUMPENVLSCALE
, "D3DTSS_BUMPENVLSCALE"},
325 {SC_TEXTURESTAGE
, D3DTSS_BUMPENVLOFFSET
, "D3DTSS_BUMPENVLOFFSET"},
326 {SC_TEXTURESTAGE
, D3DTSS_TEXTURETRANSFORMFLAGS
, "D3DTSS_TEXTURETRANSFORMFLAGS"},
328 {SC_UNKNOWN
, 0, "UNKNOWN"},
330 {SC_NPATCHMODE
, 0, "NPatchMode"},
332 {SC_UNKNOWN
, 0, "UNKNOWN"},
334 {SC_TRANSFORM
, D3DTS_PROJECTION
, "D3DTS_PROJECTION"},
335 {SC_TRANSFORM
, D3DTS_VIEW
, "D3DTS_VIEW"},
336 {SC_TRANSFORM
, D3DTS_WORLD
, "D3DTS_WORLD"},
337 {SC_TRANSFORM
, D3DTS_TEXTURE0
, "D3DTS_TEXTURE0"},
339 {SC_MATERIAL
, MT_DIFFUSE
, "MaterialDiffuse"},
340 {SC_MATERIAL
, MT_AMBIENT
, "MaterialAmbient"}, /* 0x80 */
341 {SC_MATERIAL
, MT_SPECULAR
, "MaterialSpecular"},
342 {SC_MATERIAL
, MT_EMISSIVE
, "MaterialEmissive"},
343 {SC_MATERIAL
, MT_POWER
, "MaterialPower"},
345 {SC_LIGHT
, LT_TYPE
, "LightType"},
346 {SC_LIGHT
, LT_DIFFUSE
, "LightDiffuse"},
347 {SC_LIGHT
, LT_SPECULAR
, "LightSpecular"},
348 {SC_LIGHT
, LT_AMBIENT
, "LightAmbient"},
349 {SC_LIGHT
, LT_POSITION
, "LightPosition"},
350 {SC_LIGHT
, LT_DIRECTION
, "LightDirection"},
351 {SC_LIGHT
, LT_RANGE
, "LightRange"},
352 {SC_LIGHT
, LT_FALLOFF
, "LightFallOff"},
353 {SC_LIGHT
, LT_ATTENUATION0
, "LightAttenuation0"},
354 {SC_LIGHT
, LT_ATTENUATION1
, "LightAttenuation1"},
355 {SC_LIGHT
, LT_ATTENUATION2
, "LightAttenuation2"},
356 {SC_LIGHT
, LT_THETA
, "LightTheta"},
357 {SC_LIGHT
, LT_PHI
, "LightPhi"}, /* 0x90 */
359 {SC_LIGHTENABLE
, 0, "LightEnable"},
361 {SC_VERTEXSHADER
, 0, "Vertexshader"},
363 {SC_PIXELSHADER
, 0, "Pixelshader"},
364 /* Shader constants */
365 {SC_SHADERCONST
, SCT_VSFLOAT
, "VertexShaderConstantF"},
366 {SC_SHADERCONST
, SCT_VSBOOL
, "VertexShaderConstantB"},
367 {SC_SHADERCONST
, SCT_VSINT
, "VertexShaderConstantI"},
368 {SC_SHADERCONST
, SCT_VSFLOAT
, "VertexShaderConstant"},
369 {SC_SHADERCONST
, SCT_VSFLOAT
, "VertexShaderConstant1"},
370 {SC_SHADERCONST
, SCT_VSFLOAT
, "VertexShaderConstant2"},
371 {SC_SHADERCONST
, SCT_VSFLOAT
, "VertexShaderConstant3"},
372 {SC_SHADERCONST
, SCT_VSFLOAT
, "VertexShaderConstant4"},
373 {SC_SHADERCONST
, SCT_PSFLOAT
, "PixelShaderConstantF"},
374 {SC_SHADERCONST
, SCT_PSBOOL
, "PixelShaderConstantB"},
375 {SC_SHADERCONST
, SCT_PSINT
, "PixelShaderConstantI"},
376 {SC_SHADERCONST
, SCT_PSFLOAT
, "PixelShaderConstant"},
377 {SC_SHADERCONST
, SCT_PSFLOAT
, "PixelShaderConstant1"}, /* 0xa0 */
378 {SC_SHADERCONST
, SCT_PSFLOAT
, "PixelShaderConstant2"},
379 {SC_SHADERCONST
, SCT_PSFLOAT
, "PixelShaderConstant3"},
380 {SC_SHADERCONST
, SCT_PSFLOAT
, "PixelShaderConstant4"},
382 {SC_TEXTURE
, 0, "Texture"},
384 {SC_SAMPLERSTATE
, D3DSAMP_ADDRESSU
, "AddressU"},
385 {SC_SAMPLERSTATE
, D3DSAMP_ADDRESSV
, "AddressV"},
386 {SC_SAMPLERSTATE
, D3DSAMP_ADDRESSW
, "AddressW"},
387 {SC_SAMPLERSTATE
, D3DSAMP_BORDERCOLOR
, "BorderColor"},
388 {SC_SAMPLERSTATE
, D3DSAMP_MAGFILTER
, "MagFilter"},
389 {SC_SAMPLERSTATE
, D3DSAMP_MINFILTER
, "MinFilter"},
390 {SC_SAMPLERSTATE
, D3DSAMP_MIPFILTER
, "MipFilter"},
391 {SC_SAMPLERSTATE
, D3DSAMP_MIPMAPLODBIAS
, "MipMapLodBias"},
392 {SC_SAMPLERSTATE
, D3DSAMP_MAXMIPLEVEL
, "MaxMipLevel"},
393 {SC_SAMPLERSTATE
, D3DSAMP_MAXANISOTROPY
, "MaxAnisotropy"},
394 {SC_SAMPLERSTATE
, D3DSAMP_SRGBTEXTURE
, "SRGBTexture"},
395 {SC_SAMPLERSTATE
, D3DSAMP_ELEMENTINDEX
, "ElementIndex"}, /* 0xb0 */
396 {SC_SAMPLERSTATE
, D3DSAMP_DMAPOFFSET
, "DMAPOffset"},
398 {SC_SETSAMPLER
, 0, "Sampler"},
401 static inline void read_dword(const char **ptr
, DWORD
*d
)
403 memcpy(d
, *ptr
, sizeof(*d
));
407 static void skip_dword_unknown(const char **ptr
, unsigned int count
)
412 FIXME("Skipping %u unknown DWORDs:\n", count
);
413 for (i
= 0; i
< count
; ++i
)
416 FIXME("\t0x%08x\n", d
);
420 static inline struct d3dx_parameter
*get_parameter_struct(D3DXHANDLE handle
)
422 return (struct d3dx_parameter
*) handle
;
425 static inline struct d3dx_pass
*get_pass_struct(D3DXHANDLE handle
)
427 return (struct d3dx_pass
*) handle
;
430 static inline struct d3dx_technique
*get_technique_struct(D3DXHANDLE handle
)
432 return (struct d3dx_technique
*) handle
;
435 static inline D3DXHANDLE
get_parameter_handle(struct d3dx_parameter
*parameter
)
437 return (D3DXHANDLE
) parameter
;
440 static inline D3DXHANDLE
get_technique_handle(struct d3dx_technique
*technique
)
442 return (D3DXHANDLE
) technique
;
445 static inline D3DXHANDLE
get_pass_handle(struct d3dx_pass
*pass
)
447 return (D3DXHANDLE
) pass
;
450 static struct d3dx_technique
*is_valid_technique(struct ID3DXBaseEffectImpl
*base
, D3DXHANDLE technique
)
454 for (i
= 0; i
< base
->technique_count
; ++i
)
456 if (base
->technique_handles
[i
] == technique
)
458 return get_technique_struct(technique
);
465 static struct d3dx_pass
*is_valid_pass(struct ID3DXBaseEffectImpl
*base
, D3DXHANDLE pass
)
469 for (i
= 0; i
< base
->technique_count
; ++i
)
471 struct d3dx_technique
*technique
= get_technique_struct(base
->technique_handles
[i
]);
473 for (k
= 0; k
< technique
->pass_count
; ++k
)
475 if (technique
->pass_handles
[k
] == pass
)
477 return get_pass_struct(pass
);
485 static struct d3dx_parameter
*is_valid_sub_parameter(struct d3dx_parameter
*param
, D3DXHANDLE parameter
)
487 unsigned int i
, count
;
488 struct d3dx_parameter
*p
;
490 for (i
= 0; i
< param
->annotation_count
; ++i
)
492 if (param
->annotation_handles
[i
] == parameter
)
494 return get_parameter_struct(parameter
);
497 p
= is_valid_sub_parameter(get_parameter_struct(param
->annotation_handles
[i
]), parameter
);
501 if (param
->element_count
) count
= param
->element_count
;
502 else count
= param
->member_count
;
504 for (i
= 0; i
< count
; ++i
)
506 if (param
->member_handles
[i
] == parameter
)
508 return get_parameter_struct(parameter
);
511 p
= is_valid_sub_parameter(get_parameter_struct(param
->member_handles
[i
]), parameter
);
518 static struct d3dx_parameter
*is_valid_parameter(struct ID3DXBaseEffectImpl
*base
, D3DXHANDLE parameter
)
520 unsigned int i
, k
, m
;
521 struct d3dx_parameter
*p
;
523 for (i
= 0; i
< base
->parameter_count
; ++i
)
525 if (base
->parameter_handles
[i
] == parameter
)
527 return get_parameter_struct(parameter
);
530 p
= is_valid_sub_parameter(get_parameter_struct(base
->parameter_handles
[i
]), parameter
);
534 for (i
= 0; i
< base
->technique_count
; ++i
)
536 struct d3dx_technique
*technique
= get_technique_struct(base
->technique_handles
[i
]);
538 for (k
= 0; k
< technique
->pass_count
; ++k
)
540 struct d3dx_pass
*pass
= get_pass_struct(technique
->pass_handles
[k
]);
542 for (m
= 0; m
< pass
->annotation_count
; ++m
)
544 if (pass
->annotation_handles
[i
] == parameter
)
546 return get_parameter_struct(parameter
);
549 p
= is_valid_sub_parameter(get_parameter_struct(pass
->annotation_handles
[m
]), parameter
);
554 for (k
= 0; k
< technique
->annotation_count
; ++k
)
556 if (technique
->annotation_handles
[k
] == parameter
)
558 return get_parameter_struct(parameter
);
561 p
= is_valid_sub_parameter(get_parameter_struct(technique
->annotation_handles
[k
]), parameter
);
569 static inline struct d3dx_parameter
*get_valid_parameter(struct ID3DXBaseEffectImpl
*base
, D3DXHANDLE parameter
)
571 struct d3dx_parameter
*param
= is_valid_parameter(base
, parameter
);
573 if (!param
) param
= get_parameter_by_name(base
, NULL
, parameter
);
578 static void free_state(struct d3dx_state
*state
)
580 free_parameter_state(state
->parameter
, FALSE
, FALSE
, state
->type
);
583 static void free_sampler(struct d3dx_sampler
*sampler
)
587 for (i
= 0; i
< sampler
->state_count
; ++i
)
589 free_state(&sampler
->states
[i
]);
591 HeapFree(GetProcessHeap(), 0, sampler
->states
);
594 static void free_parameter(D3DXHANDLE handle
, BOOL element
, BOOL child
)
596 free_parameter_state(handle
, element
, child
, ST_CONSTANT
);
599 static void free_parameter_state(D3DXHANDLE handle
, BOOL element
, BOOL child
, enum STATE_TYPE st
)
602 struct d3dx_parameter
*param
= get_parameter_struct(handle
);
604 TRACE("Free parameter %p, name %s, type %s, child %s, state_type %x\n", param
, param
->name
,
605 debug_d3dxparameter_type(param
->type
), child
? "yes" : "no", st
);
612 if (param
->annotation_handles
)
614 for (i
= 0; i
< param
->annotation_count
; ++i
)
616 free_parameter(param
->annotation_handles
[i
], FALSE
, FALSE
);
618 HeapFree(GetProcessHeap(), 0, param
->annotation_handles
);
621 if (param
->member_handles
)
625 if (param
->element_count
) count
= param
->element_count
;
626 else count
= param
->member_count
;
628 for (i
= 0; i
< count
; ++i
)
630 free_parameter(param
->member_handles
[i
], param
->element_count
!= 0, TRUE
);
632 HeapFree(GetProcessHeap(), 0, param
->member_handles
);
635 if (param
->class == D3DXPC_OBJECT
&& !param
->element_count
)
640 HeapFree(GetProcessHeap(), 0, *(LPSTR
*)param
->data
);
641 if (!child
) HeapFree(GetProcessHeap(), 0, param
->data
);
645 case D3DXPT_TEXTURE1D
:
646 case D3DXPT_TEXTURE2D
:
647 case D3DXPT_TEXTURE3D
:
648 case D3DXPT_TEXTURECUBE
:
649 case D3DXPT_PIXELSHADER
:
650 case D3DXPT_VERTEXSHADER
:
651 if (st
== ST_CONSTANT
)
653 if (*(IUnknown
**)param
->data
) IUnknown_Release(*(IUnknown
**)param
->data
);
657 HeapFree(GetProcessHeap(), 0, *(LPSTR
*)param
->data
);
659 if (!child
) HeapFree(GetProcessHeap(), 0, param
->data
);
663 case D3DXPT_SAMPLER1D
:
664 case D3DXPT_SAMPLER2D
:
665 case D3DXPT_SAMPLER3D
:
666 case D3DXPT_SAMPLERCUBE
:
667 if (st
== ST_CONSTANT
)
669 free_sampler((struct d3dx_sampler
*)param
->data
);
673 HeapFree(GetProcessHeap(), 0, *(LPSTR
*)param
->data
);
675 /* samplers have always own data, so free that */
676 HeapFree(GetProcessHeap(), 0, param
->data
);
680 FIXME("Unhandled type %s\n", debug_d3dxparameter_type(param
->type
));
688 if (st
!= ST_CONSTANT
)
690 HeapFree(GetProcessHeap(), 0, *(LPSTR
*)param
->data
);
692 HeapFree(GetProcessHeap(), 0, param
->data
);
696 /* only the parent has to release name and semantic */
699 HeapFree(GetProcessHeap(), 0, param
->name
);
700 HeapFree(GetProcessHeap(), 0, param
->semantic
);
703 HeapFree(GetProcessHeap(), 0, param
);
706 static void free_pass(D3DXHANDLE handle
)
709 struct d3dx_pass
*pass
= get_pass_struct(handle
);
711 TRACE("Free pass %p\n", pass
);
718 if (pass
->annotation_handles
)
720 for (i
= 0; i
< pass
->annotation_count
; ++i
)
722 free_parameter(pass
->annotation_handles
[i
], FALSE
, FALSE
);
724 HeapFree(GetProcessHeap(), 0, pass
->annotation_handles
);
729 for (i
= 0; i
< pass
->state_count
; ++i
)
731 free_state(&pass
->states
[i
]);
733 HeapFree(GetProcessHeap(), 0, pass
->states
);
736 HeapFree(GetProcessHeap(), 0, pass
->name
);
737 HeapFree(GetProcessHeap(), 0, pass
);
740 static void free_technique(D3DXHANDLE handle
)
743 struct d3dx_technique
*technique
= get_technique_struct(handle
);
745 TRACE("Free technique %p\n", technique
);
752 if (technique
->annotation_handles
)
754 for (i
= 0; i
< technique
->annotation_count
; ++i
)
756 free_parameter(technique
->annotation_handles
[i
], FALSE
, FALSE
);
758 HeapFree(GetProcessHeap(), 0, technique
->annotation_handles
);
761 if (technique
->pass_handles
)
763 for (i
= 0; i
< technique
->pass_count
; ++i
)
765 free_pass(technique
->pass_handles
[i
]);
767 HeapFree(GetProcessHeap(), 0, technique
->pass_handles
);
770 HeapFree(GetProcessHeap(), 0, technique
->name
);
771 HeapFree(GetProcessHeap(), 0, technique
);
774 static void free_base_effect(struct ID3DXBaseEffectImpl
*base
)
778 TRACE("Free base effect %p\n", base
);
780 if (base
->parameter_handles
)
782 for (i
= 0; i
< base
->parameter_count
; ++i
)
784 free_parameter(base
->parameter_handles
[i
], FALSE
, FALSE
);
786 HeapFree(GetProcessHeap(), 0, base
->parameter_handles
);
789 if (base
->technique_handles
)
791 for (i
= 0; i
< base
->technique_count
; ++i
)
793 free_technique(base
->technique_handles
[i
]);
795 HeapFree(GetProcessHeap(), 0, base
->technique_handles
);
799 static void free_effect(struct ID3DXEffectImpl
*effect
)
801 TRACE("Free effect %p\n", effect
);
803 if (effect
->base_effect
)
805 effect
->base_effect
->lpVtbl
->Release(effect
->base_effect
);
810 effect
->pool
->lpVtbl
->Release(effect
->pool
);
815 IUnknown_Release(effect
->manager
);
818 IDirect3DDevice9_Release(effect
->device
);
821 static void free_effect_compiler(struct ID3DXEffectCompilerImpl
*compiler
)
823 TRACE("Free effect compiler %p\n", compiler
);
825 if (compiler
->base_effect
)
827 compiler
->base_effect
->lpVtbl
->Release(compiler
->base_effect
);
831 static INT
get_int(D3DXPARAMETER_TYPE type
, LPCVOID data
)
851 FIXME("Unhandled type %s. This should not happen!\n", debug_d3dxparameter_type(type
));
858 inline static FLOAT
get_float(D3DXPARAMETER_TYPE type
, LPCVOID data
)
878 FIXME("Unhandled type %s. This should not happen!\n", debug_d3dxparameter_type(type
));
885 static inline BOOL
get_bool(LPCVOID data
)
887 return (*(DWORD
*)data
) ? TRUE
: FALSE
;
890 static void set_number(LPVOID outdata
, D3DXPARAMETER_TYPE outtype
, LPCVOID indata
, D3DXPARAMETER_TYPE intype
)
892 TRACE("Changing from type %i to type %i\n", intype
, outtype
);
897 *(FLOAT
*)outdata
= get_float(intype
, indata
);
901 *(BOOL
*)outdata
= get_bool(indata
);
905 *(INT
*)outdata
= get_int(intype
, indata
);
909 FIXME("Error converting to type %i\n", outtype
);
915 static void get_vector(struct d3dx_parameter
*param
, D3DXVECTOR4
*vector
)
919 for (i
= 0; i
< 4; ++i
)
921 ((FLOAT
*)vector
)[i
] = i
< param
->columns
? get_float(param
->type
, (DWORD
*)param
->data
+ i
) : 0.0f
;
925 static void set_vector(struct d3dx_parameter
*param
, CONST D3DXVECTOR4
*vector
)
929 for (i
= 0; i
< param
->columns
; ++i
)
931 set_number((FLOAT
*)param
->data
+ i
, param
->type
, (FLOAT
*)vector
+ i
, D3DXPT_FLOAT
);
935 static void get_matrix(struct d3dx_parameter
*param
, D3DXMATRIX
*matrix
)
939 for (i
= 0; i
< 4; ++i
)
941 for (k
= 0; k
< 4; ++k
)
943 if ((i
< param
->rows
) && (k
< param
->columns
))
944 matrix
->u
.m
[i
][k
] = get_float(param
->type
, (FLOAT
*)param
->data
+ i
* param
->columns
+ k
);
946 matrix
->u
.m
[i
][k
] = 0.0f
;
951 static void set_matrix(struct d3dx_parameter
*param
, CONST D3DXMATRIX
*matrix
)
955 for (i
= 0; i
< 4; ++i
)
957 for (k
= 0; k
< 4; ++k
)
959 if ((i
< param
->rows
) && (k
< param
->columns
))
960 set_number((FLOAT
*)param
->data
+ i
* param
->columns
+ k
, param
->type
, &matrix
->u
.m
[i
][k
], D3DXPT_FLOAT
);
965 static struct d3dx_parameter
*get_parameter_element_by_name(struct d3dx_parameter
*parameter
, LPCSTR name
)
968 struct d3dx_parameter
*temp_parameter
;
971 TRACE("parameter %p, name %s\n", parameter
, debugstr_a(name
));
973 if (!name
|| !*name
) return parameter
;
975 element
= atoi(name
);
976 part
= strchr(name
, ']') + 1;
978 if (parameter
->element_count
> element
)
980 temp_parameter
= get_parameter_struct(parameter
->member_handles
[element
]);
985 return get_parameter_by_name(NULL
, temp_parameter
, part
);
988 return get_parameter_annotation_by_name(temp_parameter
, part
);
991 TRACE("Returning parameter %p\n", temp_parameter
);
992 return temp_parameter
;
995 FIXME("Unhandled case \"%c\"\n", *--part
);
1000 TRACE("Parameter not found\n");
1004 static struct d3dx_parameter
*get_parameter_annotation_by_name(struct d3dx_parameter
*parameter
, LPCSTR name
)
1007 struct d3dx_parameter
*temp_parameter
;
1010 TRACE("parameter %p, name %s\n", parameter
, debugstr_a(name
));
1012 if (!name
|| !*name
) return parameter
;
1014 length
= strcspn( name
, "[.@" );
1015 part
= name
+ length
;
1017 for (i
= 0; i
< parameter
->annotation_count
; ++i
)
1019 temp_parameter
= get_parameter_struct(parameter
->annotation_handles
[i
]);
1021 if (!strcmp(temp_parameter
->name
, name
))
1023 TRACE("Returning parameter %p\n", temp_parameter
);
1024 return temp_parameter
;
1026 else if (strlen(temp_parameter
->name
) == length
&& !strncmp(temp_parameter
->name
, name
, length
))
1031 return get_parameter_by_name(NULL
, temp_parameter
, part
);
1034 return get_parameter_element_by_name(temp_parameter
, part
);
1037 FIXME("Unhandled case \"%c\"\n", *--part
);
1043 TRACE("Parameter not found\n");
1047 static struct d3dx_parameter
*get_parameter_by_name(struct ID3DXBaseEffectImpl
*base
,
1048 struct d3dx_parameter
*parameter
, LPCSTR name
)
1050 UINT i
, count
, length
;
1051 struct d3dx_parameter
*temp_parameter
;
1052 D3DXHANDLE
*handles
;
1055 TRACE("base %p, parameter %p, name %s\n", base
, parameter
, debugstr_a(name
));
1057 if (!name
|| !*name
) return parameter
;
1061 count
= base
->parameter_count
;
1062 handles
= base
->parameter_handles
;
1066 count
= parameter
->member_count
;
1067 handles
= parameter
->member_handles
;
1070 length
= strcspn( name
, "[.@" );
1071 part
= name
+ length
;
1073 for (i
= 0; i
< count
; i
++)
1075 temp_parameter
= get_parameter_struct(handles
[i
]);
1077 if (!strcmp(temp_parameter
->name
, name
))
1079 TRACE("Returning parameter %p\n", temp_parameter
);
1080 return temp_parameter
;
1082 else if (strlen(temp_parameter
->name
) == length
&& !strncmp(temp_parameter
->name
, name
, length
))
1087 return get_parameter_by_name(NULL
, temp_parameter
, part
);
1090 return get_parameter_annotation_by_name(temp_parameter
, part
);
1093 return get_parameter_element_by_name(temp_parameter
, part
);
1096 FIXME("Unhandled case \"%c\"\n", *--part
);
1102 TRACE("Parameter not found\n");
1106 static inline DWORD
d3dx9_effect_version(DWORD major
, DWORD minor
)
1108 return (0xfeff0000 | ((major
) << 8) | (minor
));
1111 static inline struct ID3DXBaseEffectImpl
*impl_from_ID3DXBaseEffect(ID3DXBaseEffect
*iface
)
1113 return CONTAINING_RECORD(iface
, struct ID3DXBaseEffectImpl
, ID3DXBaseEffect_iface
);
1116 /*** IUnknown methods ***/
1117 static HRESULT WINAPI
ID3DXBaseEffectImpl_QueryInterface(ID3DXBaseEffect
*iface
, REFIID riid
, void **object
)
1119 TRACE("iface %p, riid %s, object %p.\n", iface
, debugstr_guid(riid
), object
);
1121 if (IsEqualGUID(riid
, &IID_IUnknown
) ||
1122 IsEqualGUID(riid
, &IID_ID3DXBaseEffect
))
1124 iface
->lpVtbl
->AddRef(iface
);
1129 ERR("Interface %s not found\n", debugstr_guid(riid
));
1131 return E_NOINTERFACE
;
1134 static ULONG WINAPI
ID3DXBaseEffectImpl_AddRef(ID3DXBaseEffect
*iface
)
1136 struct ID3DXBaseEffectImpl
*This
= impl_from_ID3DXBaseEffect(iface
);
1138 TRACE("iface %p: AddRef from %u\n", iface
, This
->ref
);
1140 return InterlockedIncrement(&This
->ref
);
1143 static ULONG WINAPI
ID3DXBaseEffectImpl_Release(ID3DXBaseEffect
*iface
)
1145 struct ID3DXBaseEffectImpl
*This
= impl_from_ID3DXBaseEffect(iface
);
1146 ULONG ref
= InterlockedDecrement(&This
->ref
);
1148 TRACE("iface %p: Release from %u\n", iface
, ref
+ 1);
1152 free_base_effect(This
);
1153 HeapFree(GetProcessHeap(), 0, This
);
1159 /*** ID3DXBaseEffect methods ***/
1160 static HRESULT WINAPI
ID3DXBaseEffectImpl_GetDesc(ID3DXBaseEffect
*iface
, D3DXEFFECT_DESC
*desc
)
1162 struct ID3DXBaseEffectImpl
*This
= impl_from_ID3DXBaseEffect(iface
);
1164 FIXME("iface %p, desc %p partial stub\n", This
, desc
);
1168 WARN("Invalid argument specified.\n");
1169 return D3DERR_INVALIDCALL
;
1172 /* Todo: add creator and function count */
1173 desc
->Creator
= NULL
;
1174 desc
->Functions
= 0;
1175 desc
->Parameters
= This
->parameter_count
;
1176 desc
->Techniques
= This
->technique_count
;
1181 static HRESULT WINAPI
ID3DXBaseEffectImpl_GetParameterDesc(ID3DXBaseEffect
*iface
, D3DXHANDLE parameter
, D3DXPARAMETER_DESC
*desc
)
1183 struct ID3DXBaseEffectImpl
*This
= impl_from_ID3DXBaseEffect(iface
);
1184 struct d3dx_parameter
*param
= get_valid_parameter(This
, parameter
);
1186 TRACE("iface %p, parameter %p, desc %p\n", This
, parameter
, desc
);
1188 if (!desc
|| !param
)
1190 WARN("Invalid argument specified.\n");
1191 return D3DERR_INVALIDCALL
;
1194 desc
->Name
= param
->name
;
1195 desc
->Semantic
= param
->semantic
;
1196 desc
->Class
= param
->class;
1197 desc
->Type
= param
->type
;
1198 desc
->Rows
= param
->rows
;
1199 desc
->Columns
= param
->columns
;
1200 desc
->Elements
= param
->element_count
;
1201 desc
->Annotations
= param
->annotation_count
;
1202 desc
->StructMembers
= param
->member_count
;
1203 desc
->Flags
= param
->flags
;
1204 desc
->Bytes
= param
->bytes
;
1209 static HRESULT WINAPI
ID3DXBaseEffectImpl_GetTechniqueDesc(ID3DXBaseEffect
*iface
, D3DXHANDLE technique
, D3DXTECHNIQUE_DESC
*desc
)
1211 struct ID3DXBaseEffectImpl
*This
= impl_from_ID3DXBaseEffect(iface
);
1212 struct d3dx_technique
*tech
= technique
? is_valid_technique(This
, technique
) : get_technique_struct(This
->technique_handles
[0]);
1214 TRACE("iface %p, technique %p, desc %p\n", This
, technique
, desc
);
1218 WARN("Invalid argument specified.\n");
1219 return D3DERR_INVALIDCALL
;
1222 desc
->Name
= tech
->name
;
1223 desc
->Passes
= tech
->pass_count
;
1224 desc
->Annotations
= tech
->annotation_count
;
1229 static HRESULT WINAPI
ID3DXBaseEffectImpl_GetPassDesc(ID3DXBaseEffect
*iface
, D3DXHANDLE pass
, D3DXPASS_DESC
*desc
)
1231 struct ID3DXBaseEffectImpl
*This
= impl_from_ID3DXBaseEffect(iface
);
1232 struct d3dx_pass
*p
= is_valid_pass(This
, pass
);
1234 TRACE("iface %p, pass %p, desc %p\n", This
, pass
, desc
);
1238 WARN("Invalid argument specified.\n");
1239 return D3DERR_INVALIDCALL
;
1242 desc
->Name
= p
->name
;
1243 desc
->Annotations
= p
->annotation_count
;
1245 FIXME("Pixel shader and vertex shader are not supported, yet.\n");
1246 desc
->pVertexShaderFunction
= NULL
;
1247 desc
->pPixelShaderFunction
= NULL
;
1252 static HRESULT WINAPI
ID3DXBaseEffectImpl_GetFunctionDesc(ID3DXBaseEffect
*iface
, D3DXHANDLE shader
, D3DXFUNCTION_DESC
*desc
)
1254 struct ID3DXBaseEffectImpl
*This
= impl_from_ID3DXBaseEffect(iface
);
1256 FIXME("iface %p, shader %p, desc %p stub\n", This
, shader
, desc
);
1261 static D3DXHANDLE WINAPI
ID3DXBaseEffectImpl_GetParameter(ID3DXBaseEffect
*iface
, D3DXHANDLE parameter
, UINT index
)
1263 struct ID3DXBaseEffectImpl
*This
= impl_from_ID3DXBaseEffect(iface
);
1264 struct d3dx_parameter
*param
= get_valid_parameter(This
, parameter
);
1266 TRACE("iface %p, parameter %p, index %u\n", This
, parameter
, index
);
1270 if (index
< This
->parameter_count
)
1272 TRACE("Returning parameter %p\n", This
->parameter_handles
[index
]);
1273 return This
->parameter_handles
[index
];
1278 if (param
&& !param
->element_count
&& index
< param
->member_count
)
1280 TRACE("Returning parameter %p\n", param
->member_handles
[index
]);
1281 return param
->member_handles
[index
];
1285 WARN("Invalid argument specified.\n");
1290 static D3DXHANDLE WINAPI
ID3DXBaseEffectImpl_GetParameterByName(ID3DXBaseEffect
*iface
, D3DXHANDLE parameter
, LPCSTR name
)
1292 struct ID3DXBaseEffectImpl
*This
= impl_from_ID3DXBaseEffect(iface
);
1293 struct d3dx_parameter
*param
= get_valid_parameter(This
, parameter
);
1296 TRACE("iface %p, parameter %p, name %s\n", This
, parameter
, debugstr_a(name
));
1300 handle
= get_parameter_handle(param
);
1301 TRACE("Returning parameter %p\n", handle
);
1305 handle
= get_parameter_handle(get_parameter_by_name(This
, param
, name
));
1306 TRACE("Returning parameter %p\n", handle
);
1311 static D3DXHANDLE WINAPI
ID3DXBaseEffectImpl_GetParameterBySemantic(ID3DXBaseEffect
*iface
, D3DXHANDLE parameter
, LPCSTR semantic
)
1313 struct ID3DXBaseEffectImpl
*This
= impl_from_ID3DXBaseEffect(iface
);
1314 struct d3dx_parameter
*param
= get_valid_parameter(This
, parameter
);
1315 struct d3dx_parameter
*temp_param
;
1318 TRACE("iface %p, parameter %p, semantic %s\n", This
, parameter
, debugstr_a(semantic
));
1322 for (i
= 0; i
< This
->parameter_count
; ++i
)
1324 temp_param
= get_parameter_struct(This
->parameter_handles
[i
]);
1326 if (!temp_param
->semantic
)
1330 TRACE("Returning parameter %p\n", This
->parameter_handles
[i
]);
1331 return This
->parameter_handles
[i
];
1336 if (!strcasecmp(temp_param
->semantic
, semantic
))
1338 TRACE("Returning parameter %p\n", This
->parameter_handles
[i
]);
1339 return This
->parameter_handles
[i
];
1345 for (i
= 0; i
< param
->member_count
; ++i
)
1347 temp_param
= get_parameter_struct(param
->member_handles
[i
]);
1349 if (!temp_param
->semantic
)
1353 TRACE("Returning parameter %p\n", param
->member_handles
[i
]);
1354 return param
->member_handles
[i
];
1359 if (!strcasecmp(temp_param
->semantic
, semantic
))
1361 TRACE("Returning parameter %p\n", param
->member_handles
[i
]);
1362 return param
->member_handles
[i
];
1367 WARN("Invalid argument specified\n");
1372 static D3DXHANDLE WINAPI
ID3DXBaseEffectImpl_GetParameterElement(ID3DXBaseEffect
*iface
, D3DXHANDLE parameter
, UINT index
)
1374 struct ID3DXBaseEffectImpl
*This
= impl_from_ID3DXBaseEffect(iface
);
1375 struct d3dx_parameter
*param
= get_valid_parameter(This
, parameter
);
1377 TRACE("iface %p, parameter %p, index %u\n", This
, parameter
, index
);
1381 if (index
< This
->parameter_count
)
1383 TRACE("Returning parameter %p\n", This
->parameter_handles
[index
]);
1384 return This
->parameter_handles
[index
];
1389 if (index
< param
->element_count
)
1391 TRACE("Returning parameter %p\n", param
->member_handles
[index
]);
1392 return param
->member_handles
[index
];
1396 WARN("Invalid argument specified\n");
1401 static D3DXHANDLE WINAPI
ID3DXBaseEffectImpl_GetTechnique(ID3DXBaseEffect
*iface
, UINT index
)
1403 struct ID3DXBaseEffectImpl
*This
= impl_from_ID3DXBaseEffect(iface
);
1405 TRACE("iface %p, index %u\n", This
, index
);
1407 if (index
>= This
->technique_count
)
1409 WARN("Invalid argument specified.\n");
1413 TRACE("Returning technique %p\n", This
->technique_handles
[index
]);
1415 return This
->technique_handles
[index
];
1418 static D3DXHANDLE WINAPI
ID3DXBaseEffectImpl_GetTechniqueByName(ID3DXBaseEffect
*iface
, LPCSTR name
)
1420 struct ID3DXBaseEffectImpl
*This
= impl_from_ID3DXBaseEffect(iface
);
1423 TRACE("iface %p, name %s stub\n", This
, debugstr_a(name
));
1427 WARN("Invalid argument specified.\n");
1431 for (i
= 0; i
< This
->technique_count
; ++i
)
1433 struct d3dx_technique
*tech
= get_technique_struct(This
->technique_handles
[i
]);
1435 if (!strcmp(tech
->name
, name
))
1437 TRACE("Returning technique %p\n", This
->technique_handles
[i
]);
1438 return This
->technique_handles
[i
];
1442 WARN("Invalid argument specified.\n");
1447 static D3DXHANDLE WINAPI
ID3DXBaseEffectImpl_GetPass(ID3DXBaseEffect
*iface
, D3DXHANDLE technique
, UINT index
)
1449 struct ID3DXBaseEffectImpl
*This
= impl_from_ID3DXBaseEffect(iface
);
1450 struct d3dx_technique
*tech
= is_valid_technique(This
, technique
);
1452 TRACE("iface %p, technique %p, index %u\n", This
, technique
, index
);
1454 if (!tech
) tech
= get_technique_struct(iface
->lpVtbl
->GetTechniqueByName(iface
, technique
));
1456 if (tech
&& index
< tech
->pass_count
)
1458 TRACE("Returning pass %p\n", tech
->pass_handles
[index
]);
1459 return tech
->pass_handles
[index
];
1462 WARN("Invalid argument specified.\n");
1467 static D3DXHANDLE WINAPI
ID3DXBaseEffectImpl_GetPassByName(ID3DXBaseEffect
*iface
, D3DXHANDLE technique
, LPCSTR name
)
1469 struct ID3DXBaseEffectImpl
*This
= impl_from_ID3DXBaseEffect(iface
);
1470 struct d3dx_technique
*tech
= is_valid_technique(This
, technique
);
1472 TRACE("iface %p, technique %p, name %s\n", This
, technique
, debugstr_a(name
));
1474 if (!tech
) tech
= get_technique_struct(iface
->lpVtbl
->GetTechniqueByName(iface
, technique
));
1480 for (i
= 0; i
< tech
->pass_count
; ++i
)
1482 struct d3dx_pass
*pass
= get_pass_struct(tech
->pass_handles
[i
]);
1484 if (!strcmp(pass
->name
, name
))
1486 TRACE("Returning pass %p\n", tech
->pass_handles
[i
]);
1487 return tech
->pass_handles
[i
];
1492 WARN("Invalid argument specified.\n");
1497 static D3DXHANDLE WINAPI
ID3DXBaseEffectImpl_GetFunction(ID3DXBaseEffect
*iface
, UINT index
)
1499 struct ID3DXBaseEffectImpl
*This
= impl_from_ID3DXBaseEffect(iface
);
1501 FIXME("iface %p, index %u stub\n", This
, index
);
1506 static D3DXHANDLE WINAPI
ID3DXBaseEffectImpl_GetFunctionByName(ID3DXBaseEffect
*iface
, LPCSTR name
)
1508 struct ID3DXBaseEffectImpl
*This
= impl_from_ID3DXBaseEffect(iface
);
1510 FIXME("iface %p, name %s stub\n", This
, debugstr_a(name
));
1515 static D3DXHANDLE WINAPI
ID3DXBaseEffectImpl_GetAnnotation(ID3DXBaseEffect
*iface
, D3DXHANDLE object
, UINT index
)
1517 struct ID3DXBaseEffectImpl
*This
= impl_from_ID3DXBaseEffect(iface
);
1518 struct d3dx_parameter
*param
= get_valid_parameter(This
, object
);
1519 struct d3dx_pass
*pass
= is_valid_pass(This
, object
);
1520 struct d3dx_technique
*technique
= is_valid_technique(This
, object
);
1521 UINT annotation_count
= 0;
1522 D3DXHANDLE
*annotation_handles
= NULL
;
1524 FIXME("iface %p, object %p, index %u partial stub\n", This
, object
, index
);
1528 annotation_count
= pass
->annotation_count
;
1529 annotation_handles
= pass
->annotation_handles
;
1533 annotation_count
= technique
->annotation_count
;
1534 annotation_handles
= technique
->annotation_handles
;
1538 annotation_count
= param
->annotation_count
;
1539 annotation_handles
= param
->annotation_handles
;
1541 /* Todo: add funcs */
1543 if (index
< annotation_count
)
1545 TRACE("Returning parameter %p\n", annotation_handles
[index
]);
1546 return annotation_handles
[index
];
1549 WARN("Invalid argument specified\n");
1554 static D3DXHANDLE WINAPI
ID3DXBaseEffectImpl_GetAnnotationByName(ID3DXBaseEffect
*iface
, D3DXHANDLE object
, LPCSTR name
)
1556 struct ID3DXBaseEffectImpl
*This
= impl_from_ID3DXBaseEffect(iface
);
1557 struct d3dx_parameter
*param
= get_valid_parameter(This
, object
);
1558 struct d3dx_pass
*pass
= is_valid_pass(This
, object
);
1559 struct d3dx_technique
*technique
= is_valid_technique(This
, object
);
1560 UINT annotation_count
= 0, i
;
1561 D3DXHANDLE
*annotation_handles
= NULL
;
1563 FIXME("iface %p, object %p, name %s partial stub\n", This
, object
, debugstr_a(name
));
1567 WARN("Invalid argument specified\n");
1573 annotation_count
= pass
->annotation_count
;
1574 annotation_handles
= pass
->annotation_handles
;
1578 annotation_count
= technique
->annotation_count
;
1579 annotation_handles
= technique
->annotation_handles
;
1583 annotation_count
= param
->annotation_count
;
1584 annotation_handles
= param
->annotation_handles
;
1586 /* Todo: add funcs */
1588 for (i
= 0; i
< annotation_count
; i
++)
1590 struct d3dx_parameter
*anno
= get_parameter_struct(annotation_handles
[i
]);
1592 if (!strcmp(anno
->name
, name
))
1594 TRACE("Returning parameter %p\n", anno
);
1595 return get_parameter_handle(anno
);
1599 WARN("Invalid argument specified\n");
1604 static HRESULT WINAPI
ID3DXBaseEffectImpl_SetValue(ID3DXBaseEffect
*iface
, D3DXHANDLE parameter
, LPCVOID data
, UINT bytes
)
1606 struct ID3DXBaseEffectImpl
*This
= impl_from_ID3DXBaseEffect(iface
);
1607 struct d3dx_parameter
*param
= get_valid_parameter(This
, parameter
);
1609 TRACE("iface %p, parameter %p, data %p, bytes %u\n", This
, parameter
, data
, bytes
);
1613 WARN("Invalid parameter %p specified\n", parameter
);
1614 return D3DERR_INVALIDCALL
;
1617 /* samplers don't touch data */
1618 if (param
->class == D3DXPC_OBJECT
&& (param
->type
== D3DXPT_SAMPLER
1619 || param
->type
== D3DXPT_SAMPLER1D
|| param
->type
== D3DXPT_SAMPLER2D
1620 || param
->type
== D3DXPT_SAMPLER3D
|| param
->type
== D3DXPT_SAMPLERCUBE
))
1622 TRACE("Sampler: returning E_FAIL\n");
1626 if (data
&& param
->bytes
<= bytes
)
1628 switch (param
->type
)
1634 TRACE("Copy %u bytes\n", param
->bytes
);
1635 memcpy(param
->data
, data
, param
->bytes
);
1639 FIXME("Unhandled type %s\n", debug_d3dxparameter_type(param
->type
));
1646 WARN("Invalid argument specified\n");
1648 return D3DERR_INVALIDCALL
;
1651 static HRESULT WINAPI
ID3DXBaseEffectImpl_GetValue(ID3DXBaseEffect
*iface
, D3DXHANDLE parameter
, LPVOID data
, UINT bytes
)
1653 struct ID3DXBaseEffectImpl
*This
= impl_from_ID3DXBaseEffect(iface
);
1654 struct d3dx_parameter
*param
= get_valid_parameter(This
, parameter
);
1656 TRACE("iface %p, parameter %p, data %p, bytes %u\n", This
, parameter
, data
, bytes
);
1660 WARN("Invalid parameter %p specified\n", parameter
);
1661 return D3DERR_INVALIDCALL
;
1664 /* samplers don't touch data */
1665 if (param
->class == D3DXPC_OBJECT
&& (param
->type
== D3DXPT_SAMPLER
1666 || param
->type
== D3DXPT_SAMPLER1D
|| param
->type
== D3DXPT_SAMPLER2D
1667 || param
->type
== D3DXPT_SAMPLER3D
|| param
->type
== D3DXPT_SAMPLERCUBE
))
1669 TRACE("Sampler: returning E_FAIL\n");
1673 if (data
&& param
->bytes
<= bytes
)
1675 TRACE("Type %s\n", debug_d3dxparameter_type(param
->type
));
1677 switch (param
->type
)
1686 case D3DXPT_VERTEXSHADER
:
1687 case D3DXPT_PIXELSHADER
:
1688 case D3DXPT_TEXTURE
:
1689 case D3DXPT_TEXTURE1D
:
1690 case D3DXPT_TEXTURE2D
:
1691 case D3DXPT_TEXTURE3D
:
1692 case D3DXPT_TEXTURECUBE
:
1696 for (i
= 0; i
< (param
->element_count
? param
->element_count
: 1); ++i
)
1698 IUnknown
*unk
= ((IUnknown
**)param
->data
)[i
];
1699 if (unk
) IUnknown_AddRef(unk
);
1705 FIXME("Unhandled type %s\n", debug_d3dxparameter_type(param
->type
));
1709 TRACE("Copy %u bytes\n", param
->bytes
);
1710 memcpy(data
, param
->data
, param
->bytes
);
1714 WARN("Invalid argument specified\n");
1716 return D3DERR_INVALIDCALL
;
1719 static HRESULT WINAPI
ID3DXBaseEffectImpl_SetBool(ID3DXBaseEffect
*iface
, D3DXHANDLE parameter
, BOOL b
)
1721 struct ID3DXBaseEffectImpl
*This
= impl_from_ID3DXBaseEffect(iface
);
1722 struct d3dx_parameter
*param
= get_valid_parameter(This
, parameter
);
1724 TRACE("iface %p, parameter %p, b %s\n", This
, parameter
, b
? "TRUE" : "FALSE");
1726 if (param
&& !param
->element_count
&& param
->rows
== 1 && param
->columns
== 1)
1729 b
= b
? TRUE
: FALSE
;
1730 set_number(param
->data
, param
->type
, &b
, D3DXPT_BOOL
);
1734 WARN("Invalid argument specified\n");
1736 return D3DERR_INVALIDCALL
;
1739 static HRESULT WINAPI
ID3DXBaseEffectImpl_GetBool(ID3DXBaseEffect
*iface
, D3DXHANDLE parameter
, BOOL
*b
)
1741 struct ID3DXBaseEffectImpl
*This
= impl_from_ID3DXBaseEffect(iface
);
1742 struct d3dx_parameter
*param
= get_valid_parameter(This
, parameter
);
1744 TRACE("iface %p, parameter %p, b %p\n", This
, parameter
, b
);
1746 if (b
&& param
&& !param
->element_count
&& param
->rows
== 1 && param
->columns
== 1)
1748 *b
= get_bool(param
->data
);
1749 TRACE("Returning %s\n", *b
? "TRUE" : "FALSE");
1753 WARN("Invalid argument specified\n");
1755 return D3DERR_INVALIDCALL
;
1758 static HRESULT WINAPI
ID3DXBaseEffectImpl_SetBoolArray(ID3DXBaseEffect
*iface
, D3DXHANDLE parameter
, CONST BOOL
*b
, UINT count
)
1760 struct ID3DXBaseEffectImpl
*This
= impl_from_ID3DXBaseEffect(iface
);
1761 struct d3dx_parameter
*param
= get_valid_parameter(This
, parameter
);
1763 TRACE("iface %p, parameter %p, b %p, count %u\n", This
, parameter
, b
, count
);
1767 UINT i
, size
= min(count
, param
->bytes
/ sizeof(DWORD
));
1769 TRACE("Class %s\n", debug_d3dxparameter_class(param
->class));
1771 switch (param
->class)
1775 case D3DXPC_MATRIX_ROWS
:
1776 for (i
= 0; i
< size
; ++i
)
1778 set_number((DWORD
*)param
->data
+ i
, param
->type
, &b
[i
], D3DXPT_BOOL
);
1787 FIXME("Unhandled class %s\n", debug_d3dxparameter_class(param
->class));
1792 WARN("Invalid argument specified\n");
1794 return D3DERR_INVALIDCALL
;
1797 static HRESULT WINAPI
ID3DXBaseEffectImpl_GetBoolArray(ID3DXBaseEffect
*iface
, D3DXHANDLE parameter
, BOOL
*b
, UINT count
)
1799 struct ID3DXBaseEffectImpl
*This
= impl_from_ID3DXBaseEffect(iface
);
1800 struct d3dx_parameter
*param
= get_valid_parameter(This
, parameter
);
1802 TRACE("iface %p, parameter %p, b %p, count %u\n", This
, parameter
, b
, count
);
1804 if (b
&& param
&& (param
->class == D3DXPC_SCALAR
1805 || param
->class == D3DXPC_VECTOR
1806 || param
->class == D3DXPC_MATRIX_ROWS
1807 || param
->class == D3DXPC_MATRIX_COLUMNS
))
1809 UINT i
, size
= min(count
, param
->bytes
/ sizeof(DWORD
));
1811 for (i
= 0; i
< size
; ++i
)
1813 b
[i
] = get_bool((DWORD
*)param
->data
+ i
);
1818 WARN("Invalid argument specified\n");
1820 return D3DERR_INVALIDCALL
;
1823 static HRESULT WINAPI
ID3DXBaseEffectImpl_SetInt(ID3DXBaseEffect
*iface
, D3DXHANDLE parameter
, INT n
)
1825 struct ID3DXBaseEffectImpl
*This
= impl_from_ID3DXBaseEffect(iface
);
1826 struct d3dx_parameter
*param
= get_valid_parameter(This
, parameter
);
1828 TRACE("iface %p, parameter %p, n %i\n", This
, parameter
, n
);
1830 if (param
&& !param
->element_count
)
1832 if (param
->rows
== 1 && param
->columns
== 1)
1834 set_number(param
->data
, param
->type
, &n
, D3DXPT_INT
);
1839 * Split the value, if parameter is a vector with dimension 3 or 4.
1841 if (param
->type
== D3DXPT_FLOAT
&&
1842 ((param
->class == D3DXPC_VECTOR
&& param
->columns
!= 2) ||
1843 (param
->class == D3DXPC_MATRIX_ROWS
&& param
->rows
!= 2 && param
->columns
== 1)))
1845 TRACE("Vector fixup\n");
1847 *(FLOAT
*)param
->data
= ((n
& 0xff0000) >> 16) * INT_FLOAT_MULTI_INVERSE
;
1848 ((FLOAT
*)param
->data
)[1] = ((n
& 0xff00) >> 8) * INT_FLOAT_MULTI_INVERSE
;
1849 ((FLOAT
*)param
->data
)[2] = (n
& 0xff) * INT_FLOAT_MULTI_INVERSE
;
1850 if (param
->rows
* param
->columns
> 3)
1852 ((FLOAT
*)param
->data
)[3] = ((n
& 0xff000000) >> 24) * INT_FLOAT_MULTI_INVERSE
;
1858 WARN("Invalid argument specified\n");
1860 return D3DERR_INVALIDCALL
;
1863 static HRESULT WINAPI
ID3DXBaseEffectImpl_GetInt(ID3DXBaseEffect
*iface
, D3DXHANDLE parameter
, INT
*n
)
1865 struct ID3DXBaseEffectImpl
*This
= impl_from_ID3DXBaseEffect(iface
);
1866 struct d3dx_parameter
*param
= get_valid_parameter(This
, parameter
);
1868 TRACE("iface %p, parameter %p, n %p\n", This
, parameter
, n
);
1870 if (n
&& param
&& !param
->element_count
)
1872 if (param
->columns
== 1 && param
->rows
== 1)
1874 *n
= get_int(param
->type
, param
->data
);
1875 TRACE("Returning %i\n", *n
);
1879 if (param
->type
== D3DXPT_FLOAT
&&
1880 ((param
->class == D3DXPC_VECTOR
&& param
->columns
!= 2)
1881 || (param
->class == D3DXPC_MATRIX_ROWS
&& param
->rows
!= 2 && param
->columns
== 1)))
1883 TRACE("Vector fixup\n");
1885 /* all components (3,4) are clamped (0,255) and put in the INT */
1886 *n
= (INT
)(min(max(0.0f
, *((FLOAT
*)param
->data
+ 2)), 1.0f
) * INT_FLOAT_MULTI
);
1887 *n
+= ((INT
)(min(max(0.0f
, *((FLOAT
*)param
->data
+ 1)), 1.0f
) * INT_FLOAT_MULTI
)) << 8;
1888 *n
+= ((INT
)(min(max(0.0f
, *((FLOAT
*)param
->data
+ 0)), 1.0f
) * INT_FLOAT_MULTI
)) << 16;
1889 if (param
->columns
* param
->rows
> 3)
1891 *n
+= ((INT
)(min(max(0.0f
, *((FLOAT
*)param
->data
+ 3)), 1.0f
) * INT_FLOAT_MULTI
)) << 24;
1894 TRACE("Returning %i\n", *n
);
1899 WARN("Invalid argument specified\n");
1901 return D3DERR_INVALIDCALL
;
1904 static HRESULT WINAPI
ID3DXBaseEffectImpl_SetIntArray(ID3DXBaseEffect
*iface
, D3DXHANDLE parameter
, CONST INT
*n
, UINT count
)
1906 struct ID3DXBaseEffectImpl
*This
= impl_from_ID3DXBaseEffect(iface
);
1907 struct d3dx_parameter
*param
= get_valid_parameter(This
, parameter
);
1909 TRACE("iface %p, parameter %p, n %p, count %u\n", This
, parameter
, n
, count
);
1913 UINT i
, size
= min(count
, param
->bytes
/ sizeof(DWORD
));
1915 TRACE("Class %s\n", debug_d3dxparameter_class(param
->class));
1917 switch (param
->class)
1921 case D3DXPC_MATRIX_ROWS
:
1922 for (i
= 0; i
< size
; ++i
)
1924 set_number((DWORD
*)param
->data
+ i
, param
->type
, &n
[i
], D3DXPT_INT
);
1933 FIXME("Unhandled class %s\n", debug_d3dxparameter_class(param
->class));
1938 WARN("Invalid argument specified\n");
1940 return D3DERR_INVALIDCALL
;
1943 static HRESULT WINAPI
ID3DXBaseEffectImpl_GetIntArray(ID3DXBaseEffect
*iface
, D3DXHANDLE parameter
, INT
*n
, UINT count
)
1945 struct ID3DXBaseEffectImpl
*This
= impl_from_ID3DXBaseEffect(iface
);
1946 struct d3dx_parameter
*param
= get_valid_parameter(This
, parameter
);
1948 TRACE("iface %p, parameter %p, n %p, count %u\n", This
, parameter
, n
, count
);
1950 if (n
&& param
&& (param
->class == D3DXPC_SCALAR
1951 || param
->class == D3DXPC_VECTOR
1952 || param
->class == D3DXPC_MATRIX_ROWS
1953 || param
->class == D3DXPC_MATRIX_COLUMNS
))
1955 UINT i
, size
= min(count
, param
->bytes
/ sizeof(DWORD
));
1957 for (i
= 0; i
< size
; ++i
)
1959 n
[i
] = get_int(param
->type
, (DWORD
*)param
->data
+ i
);
1964 WARN("Invalid argument specified\n");
1966 return D3DERR_INVALIDCALL
;
1969 static HRESULT WINAPI
ID3DXBaseEffectImpl_SetFloat(ID3DXBaseEffect
*iface
, D3DXHANDLE parameter
, FLOAT f
)
1971 struct ID3DXBaseEffectImpl
*This
= impl_from_ID3DXBaseEffect(iface
);
1972 struct d3dx_parameter
*param
= get_valid_parameter(This
, parameter
);
1974 TRACE("iface %p, parameter %p, f %f\n", This
, parameter
, f
);
1976 if (param
&& !param
->element_count
&& param
->rows
== 1 && param
->columns
== 1)
1978 set_number((DWORD
*)param
->data
, param
->type
, &f
, D3DXPT_FLOAT
);
1982 WARN("Invalid argument specified\n");
1984 return D3DERR_INVALIDCALL
;
1987 static HRESULT WINAPI
ID3DXBaseEffectImpl_GetFloat(ID3DXBaseEffect
*iface
, D3DXHANDLE parameter
, FLOAT
*f
)
1989 struct ID3DXBaseEffectImpl
*This
= impl_from_ID3DXBaseEffect(iface
);
1990 struct d3dx_parameter
*param
= get_valid_parameter(This
, parameter
);
1992 TRACE("iface %p, parameter %p, f %p\n", This
, parameter
, f
);
1994 if (f
&& param
&& !param
->element_count
&& param
->columns
== 1 && param
->rows
== 1)
1996 *f
= get_float(param
->type
, (DWORD
*)param
->data
);
1997 TRACE("Returning %f\n", *f
);
2001 WARN("Invalid argument specified\n");
2003 return D3DERR_INVALIDCALL
;
2006 static HRESULT WINAPI
ID3DXBaseEffectImpl_SetFloatArray(ID3DXBaseEffect
*iface
, D3DXHANDLE parameter
, CONST FLOAT
*f
, UINT count
)
2008 struct ID3DXBaseEffectImpl
*This
= impl_from_ID3DXBaseEffect(iface
);
2009 struct d3dx_parameter
*param
= get_valid_parameter(This
, parameter
);
2011 TRACE("iface %p, parameter %p, f %p, count %u\n", This
, parameter
, f
, count
);
2015 UINT i
, size
= min(count
, param
->bytes
/ sizeof(DWORD
));
2017 TRACE("Class %s\n", debug_d3dxparameter_class(param
->class));
2019 switch (param
->class)
2023 case D3DXPC_MATRIX_ROWS
:
2024 for (i
= 0; i
< size
; ++i
)
2026 set_number((DWORD
*)param
->data
+ i
, param
->type
, &f
[i
], D3DXPT_FLOAT
);
2035 FIXME("Unhandled class %s\n", debug_d3dxparameter_class(param
->class));
2040 WARN("Invalid argument specified\n");
2042 return D3DERR_INVALIDCALL
;
2045 static HRESULT WINAPI
ID3DXBaseEffectImpl_GetFloatArray(ID3DXBaseEffect
*iface
, D3DXHANDLE parameter
, FLOAT
*f
, UINT count
)
2047 struct ID3DXBaseEffectImpl
*This
= impl_from_ID3DXBaseEffect(iface
);
2048 struct d3dx_parameter
*param
= get_valid_parameter(This
, parameter
);
2050 TRACE("iface %p, parameter %p, f %p, count %u\n", This
, parameter
, f
, count
);
2052 if (f
&& param
&& (param
->class == D3DXPC_SCALAR
2053 || param
->class == D3DXPC_VECTOR
2054 || param
->class == D3DXPC_MATRIX_ROWS
2055 || param
->class == D3DXPC_MATRIX_COLUMNS
))
2057 UINT i
, size
= min(count
, param
->bytes
/ sizeof(DWORD
));
2059 for (i
= 0; i
< size
; ++i
)
2061 f
[i
] = get_float(param
->type
, (DWORD
*)param
->data
+ i
);
2066 WARN("Invalid argument specified\n");
2068 return D3DERR_INVALIDCALL
;
2071 static HRESULT WINAPI
ID3DXBaseEffectImpl_SetVector(ID3DXBaseEffect
*iface
, D3DXHANDLE parameter
, CONST D3DXVECTOR4
*vector
)
2073 struct ID3DXBaseEffectImpl
*This
= impl_from_ID3DXBaseEffect(iface
);
2074 struct d3dx_parameter
*param
= get_valid_parameter(This
, parameter
);
2076 TRACE("iface %p, parameter %p, vector %p\n", This
, parameter
, vector
);
2078 if (param
&& !param
->element_count
)
2080 TRACE("Class %s\n", debug_d3dxparameter_class(param
->class));
2082 switch (param
->class)
2086 if (param
->type
== D3DXPT_INT
&& param
->bytes
== 4)
2090 TRACE("INT fixup\n");
2091 tmp
= (DWORD
)(max(min(vector
->z
, 1.0f
), 0.0f
) * INT_FLOAT_MULTI
);
2092 tmp
+= ((DWORD
)(max(min(vector
->y
, 1.0f
), 0.0f
) * INT_FLOAT_MULTI
)) << 8;
2093 tmp
+= ((DWORD
)(max(min(vector
->x
, 1.0f
), 0.0f
) * INT_FLOAT_MULTI
)) << 16;
2094 tmp
+= ((DWORD
)(max(min(vector
->w
, 1.0f
), 0.0f
) * INT_FLOAT_MULTI
)) << 24;
2096 *(INT
*)param
->data
= tmp
;
2099 set_vector(param
, vector
);
2102 case D3DXPC_MATRIX_ROWS
:
2108 FIXME("Unhandled class %s\n", debug_d3dxparameter_class(param
->class));
2113 WARN("Invalid argument specified\n");
2115 return D3DERR_INVALIDCALL
;
2118 static HRESULT WINAPI
ID3DXBaseEffectImpl_GetVector(ID3DXBaseEffect
*iface
, D3DXHANDLE parameter
, D3DXVECTOR4
*vector
)
2120 struct ID3DXBaseEffectImpl
*This
= impl_from_ID3DXBaseEffect(iface
);
2121 struct d3dx_parameter
*param
= get_valid_parameter(This
, parameter
);
2123 TRACE("iface %p, parameter %p, vector %p\n", This
, parameter
, vector
);
2125 if (vector
&& param
&& !param
->element_count
)
2127 TRACE("Class %s\n", debug_d3dxparameter_class(param
->class));
2129 switch (param
->class)
2133 if (param
->type
== D3DXPT_INT
&& param
->bytes
== 4)
2135 TRACE("INT fixup\n");
2136 vector
->x
= (((*(INT
*)param
->data
) & 0xff0000) >> 16) * INT_FLOAT_MULTI_INVERSE
;
2137 vector
->y
= (((*(INT
*)param
->data
) & 0xff00) >> 8) * INT_FLOAT_MULTI_INVERSE
;
2138 vector
->z
= ((*(INT
*)param
->data
) & 0xff) * INT_FLOAT_MULTI_INVERSE
;
2139 vector
->w
= (((*(INT
*)param
->data
) & 0xff000000) >> 24) * INT_FLOAT_MULTI_INVERSE
;
2142 get_vector(param
, vector
);
2145 case D3DXPC_MATRIX_ROWS
:
2151 FIXME("Unhandled class %s\n", debug_d3dxparameter_class(param
->class));
2156 WARN("Invalid argument specified\n");
2158 return D3DERR_INVALIDCALL
;
2161 static HRESULT WINAPI
ID3DXBaseEffectImpl_SetVectorArray(ID3DXBaseEffect
*iface
, D3DXHANDLE parameter
, CONST D3DXVECTOR4
*vector
, UINT count
)
2163 struct ID3DXBaseEffectImpl
*This
= impl_from_ID3DXBaseEffect(iface
);
2164 struct d3dx_parameter
*param
= get_valid_parameter(This
, parameter
);
2166 TRACE("iface %p, parameter %p, vector %p, count %u stub\n", This
, parameter
, vector
, count
);
2168 if (param
&& param
->element_count
&& param
->element_count
>= count
)
2172 TRACE("Class %s\n", debug_d3dxparameter_class(param
->class));
2174 switch (param
->class)
2177 for (i
= 0; i
< count
; ++i
)
2179 set_vector(get_parameter_struct(param
->member_handles
[i
]), &vector
[i
]);
2184 case D3DXPC_MATRIX_ROWS
:
2190 FIXME("Unhandled class %s\n", debug_d3dxparameter_class(param
->class));
2195 WARN("Invalid argument specified\n");
2197 return D3DERR_INVALIDCALL
;
2200 static HRESULT WINAPI
ID3DXBaseEffectImpl_GetVectorArray(ID3DXBaseEffect
*iface
, D3DXHANDLE parameter
, D3DXVECTOR4
*vector
, UINT count
)
2202 struct ID3DXBaseEffectImpl
*This
= impl_from_ID3DXBaseEffect(iface
);
2203 struct d3dx_parameter
*param
= get_valid_parameter(This
, parameter
);
2205 TRACE("iface %p, parameter %p, vector %p, count %u\n", This
, parameter
, vector
, count
);
2207 if (!count
) return D3D_OK
;
2209 if (vector
&& param
&& count
<= param
->element_count
)
2213 TRACE("Class %s\n", debug_d3dxparameter_class(param
->class));
2215 switch (param
->class)
2218 for (i
= 0; i
< count
; ++i
)
2220 get_vector(get_parameter_struct(param
->member_handles
[i
]), &vector
[i
]);
2225 case D3DXPC_MATRIX_ROWS
:
2231 FIXME("Unhandled class %s\n", debug_d3dxparameter_class(param
->class));
2236 WARN("Invalid argument specified\n");
2238 return D3DERR_INVALIDCALL
;
2241 static HRESULT WINAPI
ID3DXBaseEffectImpl_SetMatrix(ID3DXBaseEffect
*iface
, D3DXHANDLE parameter
, CONST D3DXMATRIX
*matrix
)
2243 struct ID3DXBaseEffectImpl
*This
= impl_from_ID3DXBaseEffect(iface
);
2244 struct d3dx_parameter
*param
= get_valid_parameter(This
, parameter
);
2246 TRACE("iface %p, parameter %p, matrix %p\n", This
, parameter
, matrix
);
2248 if (param
&& !param
->element_count
)
2250 TRACE("Class %s\n", debug_d3dxparameter_class(param
->class));
2252 switch (param
->class)
2254 case D3DXPC_MATRIX_ROWS
:
2255 set_matrix(param
, matrix
);
2265 FIXME("Unhandled class %s\n", debug_d3dxparameter_class(param
->class));
2270 WARN("Invalid argument specified\n");
2272 return D3DERR_INVALIDCALL
;
2275 static HRESULT WINAPI
ID3DXBaseEffectImpl_GetMatrix(ID3DXBaseEffect
*iface
, D3DXHANDLE parameter
, D3DXMATRIX
*matrix
)
2277 struct ID3DXBaseEffectImpl
*This
= impl_from_ID3DXBaseEffect(iface
);
2278 struct d3dx_parameter
*param
= get_valid_parameter(This
, parameter
);
2280 TRACE("iface %p, parameter %p, matrix %p\n", This
, parameter
, matrix
);
2282 if (matrix
&& param
&& !param
->element_count
)
2284 TRACE("Class %s\n", debug_d3dxparameter_class(param
->class));
2286 switch (param
->class)
2288 case D3DXPC_MATRIX_ROWS
:
2289 get_matrix(param
, matrix
);
2299 FIXME("Unhandled class %s\n", debug_d3dxparameter_class(param
->class));
2304 WARN("Invalid argument specified\n");
2306 return D3DERR_INVALIDCALL
;
2309 static HRESULT WINAPI
ID3DXBaseEffectImpl_SetMatrixArray(ID3DXBaseEffect
*iface
, D3DXHANDLE parameter
, CONST D3DXMATRIX
*matrix
, UINT count
)
2311 struct ID3DXBaseEffectImpl
*This
= impl_from_ID3DXBaseEffect(iface
);
2312 struct d3dx_parameter
*param
= get_valid_parameter(This
, parameter
);
2314 TRACE("iface %p, parameter %p, matrix %p, count %u\n", This
, parameter
, matrix
, count
);
2316 if (param
&& param
->element_count
>= count
)
2320 TRACE("Class %s\n", debug_d3dxparameter_class(param
->class));
2322 switch (param
->class)
2324 case D3DXPC_MATRIX_ROWS
:
2325 for (i
= 0; i
< count
; ++i
)
2327 set_matrix(get_parameter_struct(param
->member_handles
[i
]), &matrix
[i
]);
2338 FIXME("Unhandled class %s\n", debug_d3dxparameter_class(param
->class));
2343 WARN("Invalid argument specified\n");
2345 return D3DERR_INVALIDCALL
;
2348 static HRESULT WINAPI
ID3DXBaseEffectImpl_GetMatrixArray(ID3DXBaseEffect
*iface
, D3DXHANDLE parameter
, D3DXMATRIX
*matrix
, UINT count
)
2350 struct ID3DXBaseEffectImpl
*This
= impl_from_ID3DXBaseEffect(iface
);
2351 struct d3dx_parameter
*param
= get_valid_parameter(This
, parameter
);
2353 TRACE("iface %p, parameter %p, matrix %p, count %u\n", This
, parameter
, matrix
, count
);
2355 if (!count
) return D3D_OK
;
2357 if (matrix
&& param
&& count
<= param
->element_count
)
2361 TRACE("Class %s\n", debug_d3dxparameter_class(param
->class));
2363 switch (param
->class)
2365 case D3DXPC_MATRIX_ROWS
:
2366 for (i
= 0; i
< count
; ++i
)
2368 get_matrix(get_parameter_struct(param
->member_handles
[i
]), &matrix
[i
]);
2379 FIXME("Unhandled class %s\n", debug_d3dxparameter_class(param
->class));
2384 WARN("Invalid argument specified\n");
2386 return D3DERR_INVALIDCALL
;
2389 static HRESULT WINAPI
ID3DXBaseEffectImpl_SetMatrixPointerArray(ID3DXBaseEffect
*iface
, D3DXHANDLE parameter
, CONST D3DXMATRIX
**matrix
, UINT count
)
2391 struct ID3DXBaseEffectImpl
*This
= impl_from_ID3DXBaseEffect(iface
);
2392 struct d3dx_parameter
*param
= get_valid_parameter(This
, parameter
);
2394 TRACE("iface %p, parameter %p, matrix %p, count %u\n", This
, parameter
, matrix
, count
);
2396 if (param
&& count
<= param
->element_count
)
2400 switch (param
->class)
2402 case D3DXPC_MATRIX_ROWS
:
2403 for (i
= 0; i
< count
; ++i
)
2405 set_matrix(get_parameter_struct(param
->member_handles
[i
]), matrix
[i
]);
2415 FIXME("Unhandled class %s\n", debug_d3dxparameter_class(param
->class));
2420 WARN("Invalid argument specified\n");
2422 return D3DERR_INVALIDCALL
;
2425 static HRESULT WINAPI
ID3DXBaseEffectImpl_GetMatrixPointerArray(ID3DXBaseEffect
*iface
, D3DXHANDLE parameter
, D3DXMATRIX
**matrix
, UINT count
)
2427 struct ID3DXBaseEffectImpl
*This
= impl_from_ID3DXBaseEffect(iface
);
2428 struct d3dx_parameter
*param
= get_valid_parameter(This
, parameter
);
2430 TRACE("iface %p, parameter %p, matrix %p, count %u\n", This
, parameter
, matrix
, count
);
2432 if (!count
) return D3D_OK
;
2434 if (param
&& matrix
&& count
<= param
->element_count
)
2438 TRACE("Class %s\n", debug_d3dxparameter_class(param
->class));
2440 switch (param
->class)
2442 case D3DXPC_MATRIX_ROWS
:
2443 for (i
= 0; i
< count
; ++i
)
2445 get_matrix(get_parameter_struct(param
->member_handles
[i
]), matrix
[i
]);
2455 FIXME("Unhandled class %s\n", debug_d3dxparameter_class(param
->class));
2460 WARN("Invalid argument specified\n");
2462 return D3DERR_INVALIDCALL
;
2465 static HRESULT WINAPI
ID3DXBaseEffectImpl_SetMatrixTranspose(ID3DXBaseEffect
*iface
, D3DXHANDLE parameter
, CONST D3DXMATRIX
*matrix
)
2467 struct ID3DXBaseEffectImpl
*This
= impl_from_ID3DXBaseEffect(iface
);
2468 struct d3dx_parameter
*param
= get_valid_parameter(This
, parameter
);
2471 TRACE("iface %p, parameter %p, matrix %p\n", This
, parameter
, matrix
);
2473 if (param
&& !param
->element_count
)
2475 TRACE("Class %s\n", debug_d3dxparameter_class(param
->class));
2477 switch (param
->class)
2479 case D3DXPC_MATRIX_ROWS
:
2480 set_matrix(param
, D3DXMatrixTranspose(&m
, matrix
));
2490 FIXME("Unhandled class %s\n", debug_d3dxparameter_class(param
->class));
2495 WARN("Invalid argument specified\n");
2497 return D3DERR_INVALIDCALL
;
2500 static HRESULT WINAPI
ID3DXBaseEffectImpl_GetMatrixTranspose(ID3DXBaseEffect
*iface
, D3DXHANDLE parameter
, D3DXMATRIX
*matrix
)
2502 struct ID3DXBaseEffectImpl
*This
= impl_from_ID3DXBaseEffect(iface
);
2503 struct d3dx_parameter
*param
= get_valid_parameter(This
, parameter
);
2506 TRACE("iface %p, parameter %p, matrix %p\n", This
, parameter
, matrix
);
2508 if (matrix
&& param
&& !param
->element_count
)
2510 TRACE("Class %s\n", debug_d3dxparameter_class(param
->class));
2512 switch (param
->class)
2516 get_matrix(param
, matrix
);
2519 case D3DXPC_MATRIX_ROWS
:
2520 get_matrix(param
, &m
);
2521 D3DXMatrixTranspose(matrix
, &m
);
2529 FIXME("Unhandled class %s\n", debug_d3dxparameter_class(param
->class));
2534 WARN("Invalid argument specified\n");
2536 return D3DERR_INVALIDCALL
;
2539 static HRESULT WINAPI
ID3DXBaseEffectImpl_SetMatrixTransposeArray(ID3DXBaseEffect
*iface
, D3DXHANDLE parameter
, CONST D3DXMATRIX
*matrix
, UINT count
)
2541 struct ID3DXBaseEffectImpl
*This
= impl_from_ID3DXBaseEffect(iface
);
2542 struct d3dx_parameter
*param
= get_valid_parameter(This
, parameter
);
2545 TRACE("iface %p, parameter %p, matrix %p, count %u\n", This
, parameter
, matrix
, count
);
2547 if (param
&& param
->element_count
>= count
)
2551 TRACE("Class %s\n", debug_d3dxparameter_class(param
->class));
2553 switch (param
->class)
2555 case D3DXPC_MATRIX_ROWS
:
2556 for (i
= 0; i
< count
; ++i
)
2558 set_matrix(get_parameter_struct(param
->member_handles
[i
]), D3DXMatrixTranspose(&m
, &matrix
[i
]));
2569 FIXME("Unhandled class %s\n", debug_d3dxparameter_class(param
->class));
2574 WARN("Invalid argument specified\n");
2576 return D3DERR_INVALIDCALL
;
2579 static HRESULT WINAPI
ID3DXBaseEffectImpl_GetMatrixTransposeArray(ID3DXBaseEffect
*iface
, D3DXHANDLE parameter
, D3DXMATRIX
*matrix
, UINT count
)
2581 struct ID3DXBaseEffectImpl
*This
= impl_from_ID3DXBaseEffect(iface
);
2582 struct d3dx_parameter
*param
= get_valid_parameter(This
, parameter
);
2584 TRACE("iface %p, parameter %p, matrix %p, count %u\n", This
, parameter
, matrix
, count
);
2586 if (!count
) return D3D_OK
;
2588 if (matrix
&& param
&& count
<= param
->element_count
)
2592 TRACE("Class %s\n", debug_d3dxparameter_class(param
->class));
2594 switch (param
->class)
2596 case D3DXPC_MATRIX_ROWS
:
2597 for (i
= 0; i
< count
; ++i
)
2601 get_matrix(get_parameter_struct(param
->member_handles
[i
]), &m
);
2602 D3DXMatrixTranspose(&matrix
[i
], &m
);
2613 FIXME("Unhandled class %s\n", debug_d3dxparameter_class(param
->class));
2618 WARN("Invalid argument specified\n");
2620 return D3DERR_INVALIDCALL
;
2623 static HRESULT WINAPI
ID3DXBaseEffectImpl_SetMatrixTransposePointerArray(ID3DXBaseEffect
*iface
, D3DXHANDLE parameter
, CONST D3DXMATRIX
**matrix
, UINT count
)
2625 struct ID3DXBaseEffectImpl
*This
= impl_from_ID3DXBaseEffect(iface
);
2626 struct d3dx_parameter
*param
= get_valid_parameter(This
, parameter
);
2629 TRACE("iface %p, parameter %p, matrix %p, count %u\n", This
, parameter
, matrix
, count
);
2631 if (param
&& count
<= param
->element_count
)
2635 switch (param
->class)
2637 case D3DXPC_MATRIX_ROWS
:
2638 for (i
= 0; i
< count
; ++i
)
2640 set_matrix(get_parameter_struct(param
->member_handles
[i
]), D3DXMatrixTranspose(&m
, matrix
[i
]));
2650 FIXME("Unhandled class %s\n", debug_d3dxparameter_class(param
->class));
2655 WARN("Invalid argument specified\n");
2657 return D3DERR_INVALIDCALL
;
2660 static HRESULT WINAPI
ID3DXBaseEffectImpl_GetMatrixTransposePointerArray(ID3DXBaseEffect
*iface
, D3DXHANDLE parameter
, D3DXMATRIX
**matrix
, UINT count
)
2662 struct ID3DXBaseEffectImpl
*This
= impl_from_ID3DXBaseEffect(iface
);
2664 FIXME("iface %p, parameter %p, matrix %p, count %u stub\n", This
, parameter
, matrix
, count
);
2669 static HRESULT WINAPI
ID3DXBaseEffectImpl_SetString(ID3DXBaseEffect
*iface
, D3DXHANDLE parameter
, LPCSTR string
)
2671 struct ID3DXBaseEffectImpl
*This
= impl_from_ID3DXBaseEffect(iface
);
2673 FIXME("iface %p, parameter %p, string %p stub\n", This
, parameter
, string
);
2678 static HRESULT WINAPI
ID3DXBaseEffectImpl_GetString(ID3DXBaseEffect
*iface
, D3DXHANDLE parameter
, LPCSTR
*string
)
2680 struct ID3DXBaseEffectImpl
*This
= impl_from_ID3DXBaseEffect(iface
);
2681 struct d3dx_parameter
*param
= get_valid_parameter(This
, parameter
);
2683 TRACE("iface %p, parameter %p, string %p\n", This
, parameter
, string
);
2685 if (string
&& param
&& !param
->element_count
&& param
->type
== D3DXPT_STRING
)
2687 *string
= *(LPCSTR
*)param
->data
;
2688 TRACE("Returning %s\n", debugstr_a(*string
));
2692 WARN("Invalid argument specified\n");
2694 return D3DERR_INVALIDCALL
;
2697 static HRESULT WINAPI
ID3DXBaseEffectImpl_SetTexture(ID3DXBaseEffect
*iface
, D3DXHANDLE parameter
, LPDIRECT3DBASETEXTURE9 texture
)
2699 struct ID3DXBaseEffectImpl
*This
= impl_from_ID3DXBaseEffect(iface
);
2700 struct d3dx_parameter
*param
= get_valid_parameter(This
, parameter
);
2702 TRACE("iface %p, parameter %p, texture %p\n", This
, parameter
, texture
);
2704 if (param
&& !param
->element_count
&&
2705 (param
->type
== D3DXPT_TEXTURE
|| param
->type
== D3DXPT_TEXTURE1D
2706 || param
->type
== D3DXPT_TEXTURE2D
|| param
->type
== D3DXPT_TEXTURE3D
2707 || param
->type
== D3DXPT_TEXTURECUBE
))
2709 LPDIRECT3DBASETEXTURE9 oltexture
= *(LPDIRECT3DBASETEXTURE9
*)param
->data
;
2711 if (texture
) IDirect3DBaseTexture9_AddRef(texture
);
2712 if (oltexture
) IDirect3DBaseTexture9_Release(oltexture
);
2714 *(LPDIRECT3DBASETEXTURE9
*)param
->data
= texture
;
2719 WARN("Invalid argument specified\n");
2721 return D3DERR_INVALIDCALL
;
2724 static HRESULT WINAPI
ID3DXBaseEffectImpl_GetTexture(ID3DXBaseEffect
*iface
, D3DXHANDLE parameter
, LPDIRECT3DBASETEXTURE9
*texture
)
2726 struct ID3DXBaseEffectImpl
*This
= impl_from_ID3DXBaseEffect(iface
);
2727 struct d3dx_parameter
*param
= get_valid_parameter(This
, parameter
);
2729 TRACE("iface %p, parameter %p, texture %p\n", This
, parameter
, texture
);
2731 if (texture
&& param
&& !param
->element_count
&&
2732 (param
->type
== D3DXPT_TEXTURE
|| param
->type
== D3DXPT_TEXTURE1D
2733 || param
->type
== D3DXPT_TEXTURE2D
|| param
->type
== D3DXPT_TEXTURE3D
2734 || param
->type
== D3DXPT_TEXTURECUBE
))
2736 *texture
= *(LPDIRECT3DBASETEXTURE9
*)param
->data
;
2737 if (*texture
) IDirect3DBaseTexture9_AddRef(*texture
);
2738 TRACE("Returning %p\n", *texture
);
2742 WARN("Invalid argument specified\n");
2744 return D3DERR_INVALIDCALL
;
2747 static HRESULT WINAPI
ID3DXBaseEffectImpl_GetPixelShader(ID3DXBaseEffect
*iface
, D3DXHANDLE parameter
, LPDIRECT3DPIXELSHADER9
*pshader
)
2749 struct ID3DXBaseEffectImpl
*This
= impl_from_ID3DXBaseEffect(iface
);
2750 struct d3dx_parameter
*param
= get_valid_parameter(This
, parameter
);
2752 TRACE("iface %p, parameter %p, pshader %p\n", This
, parameter
, pshader
);
2754 if (pshader
&& param
&& !param
->element_count
&& param
->type
== D3DXPT_PIXELSHADER
)
2756 *pshader
= *(LPDIRECT3DPIXELSHADER9
*)param
->data
;
2757 if (*pshader
) IDirect3DPixelShader9_AddRef(*pshader
);
2758 TRACE("Returning %p\n", *pshader
);
2762 WARN("Invalid argument specified\n");
2764 return D3DERR_INVALIDCALL
;
2767 static HRESULT WINAPI
ID3DXBaseEffectImpl_GetVertexShader(ID3DXBaseEffect
*iface
, D3DXHANDLE parameter
, LPDIRECT3DVERTEXSHADER9
*vshader
)
2769 struct ID3DXBaseEffectImpl
*This
= impl_from_ID3DXBaseEffect(iface
);
2770 struct d3dx_parameter
*param
= get_valid_parameter(This
, parameter
);
2772 TRACE("iface %p, parameter %p, vshader %p\n", This
, parameter
, vshader
);
2774 if (vshader
&& param
&& !param
->element_count
&& param
->type
== D3DXPT_VERTEXSHADER
)
2776 *vshader
= *(LPDIRECT3DVERTEXSHADER9
*)param
->data
;
2777 if (*vshader
) IDirect3DVertexShader9_AddRef(*vshader
);
2778 TRACE("Returning %p\n", *vshader
);
2782 WARN("Invalid argument specified\n");
2784 return D3DERR_INVALIDCALL
;
2787 static HRESULT WINAPI
ID3DXBaseEffectImpl_SetArrayRange(ID3DXBaseEffect
*iface
, D3DXHANDLE parameter
, UINT start
, UINT end
)
2789 struct ID3DXBaseEffectImpl
*This
= impl_from_ID3DXBaseEffect(iface
);
2791 FIXME("iface %p, parameter %p, start %u, end %u stub\n", This
, parameter
, start
, end
);
2796 static const struct ID3DXBaseEffectVtbl ID3DXBaseEffect_Vtbl
=
2798 /*** IUnknown methods ***/
2799 ID3DXBaseEffectImpl_QueryInterface
,
2800 ID3DXBaseEffectImpl_AddRef
,
2801 ID3DXBaseEffectImpl_Release
,
2802 /*** ID3DXBaseEffect methods ***/
2803 ID3DXBaseEffectImpl_GetDesc
,
2804 ID3DXBaseEffectImpl_GetParameterDesc
,
2805 ID3DXBaseEffectImpl_GetTechniqueDesc
,
2806 ID3DXBaseEffectImpl_GetPassDesc
,
2807 ID3DXBaseEffectImpl_GetFunctionDesc
,
2808 ID3DXBaseEffectImpl_GetParameter
,
2809 ID3DXBaseEffectImpl_GetParameterByName
,
2810 ID3DXBaseEffectImpl_GetParameterBySemantic
,
2811 ID3DXBaseEffectImpl_GetParameterElement
,
2812 ID3DXBaseEffectImpl_GetTechnique
,
2813 ID3DXBaseEffectImpl_GetTechniqueByName
,
2814 ID3DXBaseEffectImpl_GetPass
,
2815 ID3DXBaseEffectImpl_GetPassByName
,
2816 ID3DXBaseEffectImpl_GetFunction
,
2817 ID3DXBaseEffectImpl_GetFunctionByName
,
2818 ID3DXBaseEffectImpl_GetAnnotation
,
2819 ID3DXBaseEffectImpl_GetAnnotationByName
,
2820 ID3DXBaseEffectImpl_SetValue
,
2821 ID3DXBaseEffectImpl_GetValue
,
2822 ID3DXBaseEffectImpl_SetBool
,
2823 ID3DXBaseEffectImpl_GetBool
,
2824 ID3DXBaseEffectImpl_SetBoolArray
,
2825 ID3DXBaseEffectImpl_GetBoolArray
,
2826 ID3DXBaseEffectImpl_SetInt
,
2827 ID3DXBaseEffectImpl_GetInt
,
2828 ID3DXBaseEffectImpl_SetIntArray
,
2829 ID3DXBaseEffectImpl_GetIntArray
,
2830 ID3DXBaseEffectImpl_SetFloat
,
2831 ID3DXBaseEffectImpl_GetFloat
,
2832 ID3DXBaseEffectImpl_SetFloatArray
,
2833 ID3DXBaseEffectImpl_GetFloatArray
,
2834 ID3DXBaseEffectImpl_SetVector
,
2835 ID3DXBaseEffectImpl_GetVector
,
2836 ID3DXBaseEffectImpl_SetVectorArray
,
2837 ID3DXBaseEffectImpl_GetVectorArray
,
2838 ID3DXBaseEffectImpl_SetMatrix
,
2839 ID3DXBaseEffectImpl_GetMatrix
,
2840 ID3DXBaseEffectImpl_SetMatrixArray
,
2841 ID3DXBaseEffectImpl_GetMatrixArray
,
2842 ID3DXBaseEffectImpl_SetMatrixPointerArray
,
2843 ID3DXBaseEffectImpl_GetMatrixPointerArray
,
2844 ID3DXBaseEffectImpl_SetMatrixTranspose
,
2845 ID3DXBaseEffectImpl_GetMatrixTranspose
,
2846 ID3DXBaseEffectImpl_SetMatrixTransposeArray
,
2847 ID3DXBaseEffectImpl_GetMatrixTransposeArray
,
2848 ID3DXBaseEffectImpl_SetMatrixTransposePointerArray
,
2849 ID3DXBaseEffectImpl_GetMatrixTransposePointerArray
,
2850 ID3DXBaseEffectImpl_SetString
,
2851 ID3DXBaseEffectImpl_GetString
,
2852 ID3DXBaseEffectImpl_SetTexture
,
2853 ID3DXBaseEffectImpl_GetTexture
,
2854 ID3DXBaseEffectImpl_GetPixelShader
,
2855 ID3DXBaseEffectImpl_GetVertexShader
,
2856 ID3DXBaseEffectImpl_SetArrayRange
,
2859 static inline struct ID3DXEffectImpl
*impl_from_ID3DXEffect(ID3DXEffect
*iface
)
2861 return CONTAINING_RECORD(iface
, struct ID3DXEffectImpl
, ID3DXEffect_iface
);
2864 /*** IUnknown methods ***/
2865 static HRESULT WINAPI
ID3DXEffectImpl_QueryInterface(ID3DXEffect
*iface
, REFIID riid
, void **object
)
2867 TRACE("(%p)->(%s, %p)\n", iface
, debugstr_guid(riid
), object
);
2869 if (IsEqualGUID(riid
, &IID_IUnknown
) ||
2870 IsEqualGUID(riid
, &IID_ID3DXEffect
))
2872 iface
->lpVtbl
->AddRef(iface
);
2877 ERR("Interface %s not found\n", debugstr_guid(riid
));
2879 return E_NOINTERFACE
;
2882 static ULONG WINAPI
ID3DXEffectImpl_AddRef(ID3DXEffect
*iface
)
2884 struct ID3DXEffectImpl
*This
= impl_from_ID3DXEffect(iface
);
2886 TRACE("(%p)->(): AddRef from %u\n", This
, This
->ref
);
2888 return InterlockedIncrement(&This
->ref
);
2891 static ULONG WINAPI
ID3DXEffectImpl_Release(ID3DXEffect
*iface
)
2893 struct ID3DXEffectImpl
*This
= impl_from_ID3DXEffect(iface
);
2894 ULONG ref
= InterlockedDecrement(&This
->ref
);
2896 TRACE("(%p)->(): Release from %u\n", This
, ref
+ 1);
2901 HeapFree(GetProcessHeap(), 0, This
);
2907 /*** ID3DXBaseEffect methods ***/
2908 static HRESULT WINAPI
ID3DXEffectImpl_GetDesc(ID3DXEffect
*iface
, D3DXEFFECT_DESC
*desc
)
2910 struct ID3DXEffectImpl
*This
= impl_from_ID3DXEffect(iface
);
2911 ID3DXBaseEffect
*base
= This
->base_effect
;
2913 TRACE("Forward iface %p, base %p\n", This
, base
);
2915 return ID3DXBaseEffectImpl_GetDesc(base
, desc
);
2918 static HRESULT WINAPI
ID3DXEffectImpl_GetParameterDesc(ID3DXEffect
*iface
, D3DXHANDLE parameter
, D3DXPARAMETER_DESC
*desc
)
2920 struct ID3DXEffectImpl
*This
= impl_from_ID3DXEffect(iface
);
2921 ID3DXBaseEffect
*base
= This
->base_effect
;
2923 TRACE("Forward iface %p, base %p\n", This
, base
);
2925 return ID3DXBaseEffectImpl_GetParameterDesc(base
, parameter
, desc
);
2928 static HRESULT WINAPI
ID3DXEffectImpl_GetTechniqueDesc(ID3DXEffect
*iface
, D3DXHANDLE technique
, D3DXTECHNIQUE_DESC
*desc
)
2930 struct ID3DXEffectImpl
*This
= impl_from_ID3DXEffect(iface
);
2931 ID3DXBaseEffect
*base
= This
->base_effect
;
2933 TRACE("Forward iface %p, base %p\n", This
, base
);
2935 return ID3DXBaseEffectImpl_GetTechniqueDesc(base
, technique
, desc
);
2938 static HRESULT WINAPI
ID3DXEffectImpl_GetPassDesc(ID3DXEffect
*iface
, D3DXHANDLE pass
, D3DXPASS_DESC
*desc
)
2940 struct ID3DXEffectImpl
*This
= impl_from_ID3DXEffect(iface
);
2941 ID3DXBaseEffect
*base
= This
->base_effect
;
2943 TRACE("Forward iface %p, base %p\n", This
, base
);
2945 return ID3DXBaseEffectImpl_GetPassDesc(base
, pass
, desc
);
2948 static HRESULT WINAPI
ID3DXEffectImpl_GetFunctionDesc(ID3DXEffect
*iface
, D3DXHANDLE shader
, D3DXFUNCTION_DESC
*desc
)
2950 struct ID3DXEffectImpl
*This
= impl_from_ID3DXEffect(iface
);
2951 ID3DXBaseEffect
*base
= This
->base_effect
;
2953 TRACE("Forward iface %p, base %p\n", This
, base
);
2955 return ID3DXBaseEffectImpl_GetFunctionDesc(base
, shader
, desc
);
2958 static D3DXHANDLE WINAPI
ID3DXEffectImpl_GetParameter(ID3DXEffect
*iface
, D3DXHANDLE parameter
, UINT index
)
2960 struct ID3DXEffectImpl
*This
= impl_from_ID3DXEffect(iface
);
2961 ID3DXBaseEffect
*base
= This
->base_effect
;
2963 TRACE("Forward iface %p, base %p\n", This
, base
);
2965 return ID3DXBaseEffectImpl_GetParameter(base
, parameter
, index
);
2968 static D3DXHANDLE WINAPI
ID3DXEffectImpl_GetParameterByName(ID3DXEffect
*iface
, D3DXHANDLE parameter
, LPCSTR name
)
2970 struct ID3DXEffectImpl
*This
= impl_from_ID3DXEffect(iface
);
2971 ID3DXBaseEffect
*base
= This
->base_effect
;
2973 TRACE("Forward iface %p, base %p\n", This
, base
);
2975 return ID3DXBaseEffectImpl_GetParameterByName(base
, parameter
, name
);
2978 static D3DXHANDLE WINAPI
ID3DXEffectImpl_GetParameterBySemantic(ID3DXEffect
*iface
, D3DXHANDLE parameter
, LPCSTR semantic
)
2980 struct ID3DXEffectImpl
*This
= impl_from_ID3DXEffect(iface
);
2981 ID3DXBaseEffect
*base
= This
->base_effect
;
2983 TRACE("Forward iface %p, base %p\n", This
, base
);
2985 return ID3DXBaseEffectImpl_GetParameterBySemantic(base
, parameter
, semantic
);
2988 static D3DXHANDLE WINAPI
ID3DXEffectImpl_GetParameterElement(ID3DXEffect
*iface
, D3DXHANDLE parameter
, UINT index
)
2990 struct ID3DXEffectImpl
*This
= impl_from_ID3DXEffect(iface
);
2991 ID3DXBaseEffect
*base
= This
->base_effect
;
2993 TRACE("Forward iface %p, base %p\n", This
, base
);
2995 return ID3DXBaseEffectImpl_GetParameterElement(base
, parameter
, index
);
2998 static D3DXHANDLE WINAPI
ID3DXEffectImpl_GetTechnique(ID3DXEffect
*iface
, UINT index
)
3000 struct ID3DXEffectImpl
*This
= impl_from_ID3DXEffect(iface
);
3001 ID3DXBaseEffect
*base
= This
->base_effect
;
3003 TRACE("Forward iface %p, base %p\n", This
, base
);
3005 return ID3DXBaseEffectImpl_GetTechnique(base
, index
);
3008 static D3DXHANDLE WINAPI
ID3DXEffectImpl_GetTechniqueByName(ID3DXEffect
*iface
, LPCSTR name
)
3010 struct ID3DXEffectImpl
*This
= impl_from_ID3DXEffect(iface
);
3011 ID3DXBaseEffect
*base
= This
->base_effect
;
3013 TRACE("Forward iface %p, base %p\n", This
, base
);
3015 return ID3DXBaseEffectImpl_GetTechniqueByName(base
, name
);
3018 static D3DXHANDLE WINAPI
ID3DXEffectImpl_GetPass(ID3DXEffect
*iface
, D3DXHANDLE technique
, UINT index
)
3020 struct ID3DXEffectImpl
*This
= impl_from_ID3DXEffect(iface
);
3021 ID3DXBaseEffect
*base
= This
->base_effect
;
3023 TRACE("Forward iface %p, base %p\n", This
, base
);
3025 return ID3DXBaseEffectImpl_GetPass(base
, technique
, index
);
3028 static D3DXHANDLE WINAPI
ID3DXEffectImpl_GetPassByName(ID3DXEffect
*iface
, D3DXHANDLE technique
, LPCSTR name
)
3030 struct ID3DXEffectImpl
*This
= impl_from_ID3DXEffect(iface
);
3031 ID3DXBaseEffect
*base
= This
->base_effect
;
3033 TRACE("Forward iface %p, base %p\n", This
, base
);
3035 return ID3DXBaseEffectImpl_GetPassByName(base
, technique
, name
);
3038 static D3DXHANDLE WINAPI
ID3DXEffectImpl_GetFunction(ID3DXEffect
*iface
, UINT index
)
3040 struct ID3DXEffectImpl
*This
= impl_from_ID3DXEffect(iface
);
3041 ID3DXBaseEffect
*base
= This
->base_effect
;
3043 TRACE("Forward iface %p, base %p\n", This
, base
);
3045 return ID3DXBaseEffectImpl_GetFunction(base
, index
);
3048 static D3DXHANDLE WINAPI
ID3DXEffectImpl_GetFunctionByName(ID3DXEffect
*iface
, LPCSTR name
)
3050 struct ID3DXEffectImpl
*This
= impl_from_ID3DXEffect(iface
);
3051 ID3DXBaseEffect
*base
= This
->base_effect
;
3053 TRACE("Forward iface %p, base %p\n", This
, base
);
3055 return ID3DXBaseEffectImpl_GetFunctionByName(base
, name
);
3058 static D3DXHANDLE WINAPI
ID3DXEffectImpl_GetAnnotation(ID3DXEffect
*iface
, D3DXHANDLE object
, UINT index
)
3060 struct ID3DXEffectImpl
*This
= impl_from_ID3DXEffect(iface
);
3061 ID3DXBaseEffect
*base
= This
->base_effect
;
3063 TRACE("Forward iface %p, base %p\n", This
, base
);
3065 return ID3DXBaseEffectImpl_GetAnnotation(base
, object
, index
);
3068 static D3DXHANDLE WINAPI
ID3DXEffectImpl_GetAnnotationByName(ID3DXEffect
*iface
, D3DXHANDLE object
, LPCSTR name
)
3070 struct ID3DXEffectImpl
*This
= impl_from_ID3DXEffect(iface
);
3071 ID3DXBaseEffect
*base
= This
->base_effect
;
3073 TRACE("Forward iface %p, base %p\n", This
, base
);
3075 return ID3DXBaseEffectImpl_GetAnnotationByName(base
, object
, name
);
3078 static HRESULT WINAPI
ID3DXEffectImpl_SetValue(ID3DXEffect
*iface
, D3DXHANDLE parameter
, LPCVOID data
, UINT bytes
)
3080 struct ID3DXEffectImpl
*This
= impl_from_ID3DXEffect(iface
);
3081 ID3DXBaseEffect
*base
= This
->base_effect
;
3083 TRACE("Forward iface %p, base %p\n", This
, base
);
3085 return ID3DXBaseEffectImpl_SetValue(base
, parameter
, data
, bytes
);
3088 static HRESULT WINAPI
ID3DXEffectImpl_GetValue(ID3DXEffect
*iface
, D3DXHANDLE parameter
, LPVOID data
, UINT bytes
)
3090 struct ID3DXEffectImpl
*This
= impl_from_ID3DXEffect(iface
);
3091 ID3DXBaseEffect
*base
= This
->base_effect
;
3093 TRACE("Forward iface %p, base %p\n", This
, base
);
3095 return ID3DXBaseEffectImpl_GetValue(base
, parameter
, data
, bytes
);
3098 static HRESULT WINAPI
ID3DXEffectImpl_SetBool(ID3DXEffect
*iface
, D3DXHANDLE parameter
, BOOL b
)
3100 struct ID3DXEffectImpl
*This
= impl_from_ID3DXEffect(iface
);
3101 ID3DXBaseEffect
*base
= This
->base_effect
;
3103 TRACE("Forward iface %p, base %p\n", This
, base
);
3105 return ID3DXBaseEffectImpl_SetBool(base
, parameter
, b
);
3108 static HRESULT WINAPI
ID3DXEffectImpl_GetBool(ID3DXEffect
*iface
, D3DXHANDLE parameter
, BOOL
*b
)
3110 struct ID3DXEffectImpl
*This
= impl_from_ID3DXEffect(iface
);
3111 ID3DXBaseEffect
*base
= This
->base_effect
;
3113 TRACE("Forward iface %p, base %p\n", This
, base
);
3115 return ID3DXBaseEffectImpl_GetBool(base
, parameter
, b
);
3118 static HRESULT WINAPI
ID3DXEffectImpl_SetBoolArray(ID3DXEffect
*iface
, D3DXHANDLE parameter
, CONST BOOL
*b
, UINT count
)
3120 struct ID3DXEffectImpl
*This
= impl_from_ID3DXEffect(iface
);
3121 ID3DXBaseEffect
*base
= This
->base_effect
;
3123 TRACE("Forward iface %p, base %p\n", This
, base
);
3125 return ID3DXBaseEffectImpl_SetBoolArray(base
, parameter
, b
, count
);
3128 static HRESULT WINAPI
ID3DXEffectImpl_GetBoolArray(ID3DXEffect
*iface
, D3DXHANDLE parameter
, BOOL
*b
, UINT count
)
3130 struct ID3DXEffectImpl
*This
= impl_from_ID3DXEffect(iface
);
3131 ID3DXBaseEffect
*base
= This
->base_effect
;
3133 TRACE("Forward iface %p, base %p\n", This
, base
);
3135 return ID3DXBaseEffectImpl_GetBoolArray(base
, parameter
, b
, count
);
3138 static HRESULT WINAPI
ID3DXEffectImpl_SetInt(ID3DXEffect
*iface
, D3DXHANDLE parameter
, INT n
)
3140 struct ID3DXEffectImpl
*This
= impl_from_ID3DXEffect(iface
);
3141 ID3DXBaseEffect
*base
= This
->base_effect
;
3143 TRACE("Forward iface %p, base %p\n", This
, base
);
3145 return ID3DXBaseEffectImpl_SetInt(base
, parameter
, n
);
3148 static HRESULT WINAPI
ID3DXEffectImpl_GetInt(ID3DXEffect
*iface
, D3DXHANDLE parameter
, INT
*n
)
3150 struct ID3DXEffectImpl
*This
= impl_from_ID3DXEffect(iface
);
3151 ID3DXBaseEffect
*base
= This
->base_effect
;
3153 TRACE("Forward iface %p, base %p\n", This
, base
);
3155 return ID3DXBaseEffectImpl_GetInt(base
, parameter
, n
);
3158 static HRESULT WINAPI
ID3DXEffectImpl_SetIntArray(ID3DXEffect
*iface
, D3DXHANDLE parameter
, CONST INT
*n
, UINT count
)
3160 struct ID3DXEffectImpl
*This
= impl_from_ID3DXEffect(iface
);
3161 ID3DXBaseEffect
*base
= This
->base_effect
;
3163 TRACE("Forward iface %p, base %p\n", This
, base
);
3165 return ID3DXBaseEffectImpl_SetIntArray(base
, parameter
, n
, count
);
3168 static HRESULT WINAPI
ID3DXEffectImpl_GetIntArray(ID3DXEffect
*iface
, D3DXHANDLE parameter
, INT
*n
, UINT count
)
3170 struct ID3DXEffectImpl
*This
= impl_from_ID3DXEffect(iface
);
3171 ID3DXBaseEffect
*base
= This
->base_effect
;
3173 TRACE("Forward iface %p, base %p\n", This
, base
);
3175 return ID3DXBaseEffectImpl_GetIntArray(base
, parameter
, n
, count
);
3178 static HRESULT WINAPI
ID3DXEffectImpl_SetFloat(ID3DXEffect
*iface
, D3DXHANDLE parameter
, FLOAT f
)
3180 struct ID3DXEffectImpl
*This
= impl_from_ID3DXEffect(iface
);
3181 ID3DXBaseEffect
*base
= This
->base_effect
;
3183 TRACE("Forward iface %p, base %p\n", This
, base
);
3185 return ID3DXBaseEffectImpl_SetFloat(base
, parameter
, f
);
3188 static HRESULT WINAPI
ID3DXEffectImpl_GetFloat(ID3DXEffect
*iface
, D3DXHANDLE parameter
, FLOAT
*f
)
3190 struct ID3DXEffectImpl
*This
= impl_from_ID3DXEffect(iface
);
3191 ID3DXBaseEffect
*base
= This
->base_effect
;
3193 TRACE("Forward iface %p, base %p\n", This
, base
);
3195 return ID3DXBaseEffectImpl_GetFloat(base
, parameter
, f
);
3198 static HRESULT WINAPI
ID3DXEffectImpl_SetFloatArray(ID3DXEffect
*iface
, D3DXHANDLE parameter
, CONST FLOAT
*f
, UINT count
)
3200 struct ID3DXEffectImpl
*This
= impl_from_ID3DXEffect(iface
);
3201 ID3DXBaseEffect
*base
= This
->base_effect
;
3203 TRACE("Forward iface %p, base %p\n", This
, base
);
3205 return ID3DXBaseEffectImpl_SetFloatArray(base
, parameter
, f
, count
);
3208 static HRESULT WINAPI
ID3DXEffectImpl_GetFloatArray(ID3DXEffect
*iface
, D3DXHANDLE parameter
, FLOAT
*f
, UINT count
)
3210 struct ID3DXEffectImpl
*This
= impl_from_ID3DXEffect(iface
);
3211 ID3DXBaseEffect
*base
= This
->base_effect
;
3213 TRACE("Forward iface %p, base %p\n", This
, base
);
3215 return ID3DXBaseEffectImpl_GetFloatArray(base
, parameter
, f
, count
);
3218 static HRESULT WINAPI
ID3DXEffectImpl_SetVector(ID3DXEffect
*iface
, D3DXHANDLE parameter
, CONST D3DXVECTOR4
*vector
)
3220 struct ID3DXEffectImpl
*This
= impl_from_ID3DXEffect(iface
);
3221 ID3DXBaseEffect
*base
= This
->base_effect
;
3223 TRACE("Forward iface %p, base %p\n", This
, base
);
3225 return ID3DXBaseEffectImpl_SetVector(base
, parameter
, vector
);
3228 static HRESULT WINAPI
ID3DXEffectImpl_GetVector(ID3DXEffect
*iface
, D3DXHANDLE parameter
, D3DXVECTOR4
*vector
)
3230 struct ID3DXEffectImpl
*This
= impl_from_ID3DXEffect(iface
);
3231 ID3DXBaseEffect
*base
= This
->base_effect
;
3233 TRACE("Forward iface %p, base %p\n", This
, base
);
3235 return ID3DXBaseEffectImpl_GetVector(base
, parameter
, vector
);
3238 static HRESULT WINAPI
ID3DXEffectImpl_SetVectorArray(ID3DXEffect
*iface
, D3DXHANDLE parameter
, CONST D3DXVECTOR4
*vector
, UINT count
)
3240 struct ID3DXEffectImpl
*This
= impl_from_ID3DXEffect(iface
);
3241 ID3DXBaseEffect
*base
= This
->base_effect
;
3243 TRACE("Forward iface %p, base %p\n", This
, base
);
3245 return ID3DXBaseEffectImpl_SetVectorArray(base
, parameter
, vector
, count
);
3248 static HRESULT WINAPI
ID3DXEffectImpl_GetVectorArray(ID3DXEffect
*iface
, D3DXHANDLE parameter
, D3DXVECTOR4
*vector
, UINT count
)
3250 struct ID3DXEffectImpl
*This
= impl_from_ID3DXEffect(iface
);
3251 ID3DXBaseEffect
*base
= This
->base_effect
;
3253 TRACE("Forward iface %p, base %p\n", This
, base
);
3255 return ID3DXBaseEffectImpl_GetVectorArray(base
, parameter
, vector
, count
);
3258 static HRESULT WINAPI
ID3DXEffectImpl_SetMatrix(ID3DXEffect
*iface
, D3DXHANDLE parameter
, CONST D3DXMATRIX
*matrix
)
3260 struct ID3DXEffectImpl
*This
= impl_from_ID3DXEffect(iface
);
3261 ID3DXBaseEffect
*base
= This
->base_effect
;
3263 TRACE("Forward iface %p, base %p\n", This
, base
);
3265 return ID3DXBaseEffectImpl_SetMatrix(base
, parameter
, matrix
);
3268 static HRESULT WINAPI
ID3DXEffectImpl_GetMatrix(ID3DXEffect
*iface
, D3DXHANDLE parameter
, D3DXMATRIX
*matrix
)
3270 struct ID3DXEffectImpl
*This
= impl_from_ID3DXEffect(iface
);
3271 ID3DXBaseEffect
*base
= This
->base_effect
;
3273 TRACE("Forward iface %p, base %p\n", This
, base
);
3275 return ID3DXBaseEffectImpl_GetMatrix(base
, parameter
, matrix
);
3278 static HRESULT WINAPI
ID3DXEffectImpl_SetMatrixArray(ID3DXEffect
*iface
, D3DXHANDLE parameter
, CONST D3DXMATRIX
*matrix
, UINT count
)
3280 struct ID3DXEffectImpl
*This
= impl_from_ID3DXEffect(iface
);
3281 ID3DXBaseEffect
*base
= This
->base_effect
;
3283 TRACE("Forward iface %p, base %p\n", This
, base
);
3285 return ID3DXBaseEffectImpl_SetMatrixArray(base
, parameter
, matrix
, count
);
3288 static HRESULT WINAPI
ID3DXEffectImpl_GetMatrixArray(ID3DXEffect
*iface
, D3DXHANDLE parameter
, D3DXMATRIX
*matrix
, UINT count
)
3290 struct ID3DXEffectImpl
*This
= impl_from_ID3DXEffect(iface
);
3291 ID3DXBaseEffect
*base
= This
->base_effect
;
3293 TRACE("Forward iface %p, base %p\n", This
, base
);
3295 return ID3DXBaseEffectImpl_GetMatrixArray(base
, parameter
, matrix
, count
);
3298 static HRESULT WINAPI
ID3DXEffectImpl_SetMatrixPointerArray(ID3DXEffect
*iface
, D3DXHANDLE parameter
, CONST D3DXMATRIX
**matrix
, UINT count
)
3300 struct ID3DXEffectImpl
*This
= impl_from_ID3DXEffect(iface
);
3301 ID3DXBaseEffect
*base
= This
->base_effect
;
3303 TRACE("Forward iface %p, base %p\n", This
, base
);
3305 return ID3DXBaseEffectImpl_SetMatrixPointerArray(base
, parameter
, matrix
, count
);
3308 static HRESULT WINAPI
ID3DXEffectImpl_GetMatrixPointerArray(ID3DXEffect
*iface
, D3DXHANDLE parameter
, D3DXMATRIX
**matrix
, UINT count
)
3310 struct ID3DXEffectImpl
*This
= impl_from_ID3DXEffect(iface
);
3311 ID3DXBaseEffect
*base
= This
->base_effect
;
3313 TRACE("Forward iface %p, base %p\n", This
, base
);
3315 return ID3DXBaseEffectImpl_GetMatrixPointerArray(base
, parameter
, matrix
, count
);
3318 static HRESULT WINAPI
ID3DXEffectImpl_SetMatrixTranspose(ID3DXEffect
*iface
, D3DXHANDLE parameter
, CONST D3DXMATRIX
*matrix
)
3320 struct ID3DXEffectImpl
*This
= impl_from_ID3DXEffect(iface
);
3321 ID3DXBaseEffect
*base
= This
->base_effect
;
3323 TRACE("Forward iface %p, base %p\n", This
, base
);
3325 return ID3DXBaseEffectImpl_SetMatrixTranspose(base
, parameter
, matrix
);
3328 static HRESULT WINAPI
ID3DXEffectImpl_GetMatrixTranspose(ID3DXEffect
*iface
, D3DXHANDLE parameter
, D3DXMATRIX
*matrix
)
3330 struct ID3DXEffectImpl
*This
= impl_from_ID3DXEffect(iface
);
3331 ID3DXBaseEffect
*base
= This
->base_effect
;
3333 TRACE("Forward iface %p, base %p\n", This
, base
);
3335 return ID3DXBaseEffectImpl_GetMatrixTranspose(base
, parameter
, matrix
);
3338 static HRESULT WINAPI
ID3DXEffectImpl_SetMatrixTransposeArray(ID3DXEffect
*iface
, D3DXHANDLE parameter
, CONST D3DXMATRIX
*matrix
, UINT count
)
3340 struct ID3DXEffectImpl
*This
= impl_from_ID3DXEffect(iface
);
3341 ID3DXBaseEffect
*base
= This
->base_effect
;
3343 TRACE("Forward iface %p, base %p\n", This
, base
);
3345 return ID3DXBaseEffectImpl_SetMatrixTransposeArray(base
, parameter
, matrix
, count
);
3348 static HRESULT WINAPI
ID3DXEffectImpl_GetMatrixTransposeArray(ID3DXEffect
*iface
, D3DXHANDLE parameter
, D3DXMATRIX
*matrix
, UINT count
)
3350 struct ID3DXEffectImpl
*This
= impl_from_ID3DXEffect(iface
);
3351 ID3DXBaseEffect
*base
= This
->base_effect
;
3353 TRACE("Forward iface %p, base %p\n", This
, base
);
3355 return ID3DXBaseEffectImpl_GetMatrixTransposeArray(base
, parameter
, matrix
, count
);
3358 static HRESULT WINAPI
ID3DXEffectImpl_SetMatrixTransposePointerArray(ID3DXEffect
*iface
, D3DXHANDLE parameter
, CONST D3DXMATRIX
**matrix
, UINT count
)
3360 struct ID3DXEffectImpl
*This
= impl_from_ID3DXEffect(iface
);
3361 ID3DXBaseEffect
*base
= This
->base_effect
;
3363 TRACE("Forward iface %p, base %p\n", This
, base
);
3365 return ID3DXBaseEffectImpl_SetMatrixTransposePointerArray(base
, parameter
, matrix
, count
);
3368 static HRESULT WINAPI
ID3DXEffectImpl_GetMatrixTransposePointerArray(ID3DXEffect
*iface
, D3DXHANDLE parameter
, D3DXMATRIX
**matrix
, UINT count
)
3370 struct ID3DXEffectImpl
*This
= impl_from_ID3DXEffect(iface
);
3371 ID3DXBaseEffect
*base
= This
->base_effect
;
3373 TRACE("Forward iface %p, base %p\n", This
, base
);
3375 return ID3DXBaseEffectImpl_GetMatrixTransposePointerArray(base
, parameter
, matrix
, count
);
3378 static HRESULT WINAPI
ID3DXEffectImpl_SetString(ID3DXEffect
*iface
, D3DXHANDLE parameter
, LPCSTR string
)
3380 struct ID3DXEffectImpl
*This
= impl_from_ID3DXEffect(iface
);
3381 ID3DXBaseEffect
*base
= This
->base_effect
;
3383 TRACE("Forward iface %p, base %p\n", This
, base
);
3385 return ID3DXBaseEffectImpl_SetString(base
, parameter
, string
);
3388 static HRESULT WINAPI
ID3DXEffectImpl_GetString(ID3DXEffect
*iface
, D3DXHANDLE parameter
, LPCSTR
*string
)
3390 struct ID3DXEffectImpl
*This
= impl_from_ID3DXEffect(iface
);
3391 ID3DXBaseEffect
*base
= This
->base_effect
;
3393 TRACE("Forward iface %p, base %p\n", This
, base
);
3395 return ID3DXBaseEffectImpl_GetString(base
, parameter
, string
);
3398 static HRESULT WINAPI
ID3DXEffectImpl_SetTexture(ID3DXEffect
*iface
, D3DXHANDLE parameter
, LPDIRECT3DBASETEXTURE9 texture
)
3400 struct ID3DXEffectImpl
*This
= impl_from_ID3DXEffect(iface
);
3401 ID3DXBaseEffect
*base
= This
->base_effect
;
3403 TRACE("Forward iface %p, base %p\n", This
, base
);
3405 return ID3DXBaseEffectImpl_SetTexture(base
, parameter
, texture
);
3408 static HRESULT WINAPI
ID3DXEffectImpl_GetTexture(ID3DXEffect
*iface
, D3DXHANDLE parameter
, LPDIRECT3DBASETEXTURE9
*texture
)
3410 struct ID3DXEffectImpl
*This
= impl_from_ID3DXEffect(iface
);
3411 ID3DXBaseEffect
*base
= This
->base_effect
;
3413 TRACE("Forward iface %p, base %p\n", This
, base
);
3415 return ID3DXBaseEffectImpl_GetTexture(base
, parameter
, texture
);
3418 static HRESULT WINAPI
ID3DXEffectImpl_GetPixelShader(ID3DXEffect
*iface
, D3DXHANDLE parameter
, LPDIRECT3DPIXELSHADER9
*pshader
)
3420 struct ID3DXEffectImpl
*This
= impl_from_ID3DXEffect(iface
);
3421 ID3DXBaseEffect
*base
= This
->base_effect
;
3423 TRACE("Forward iface %p, base %p\n", This
, base
);
3425 return ID3DXBaseEffectImpl_GetPixelShader(base
, parameter
, pshader
);
3428 static HRESULT WINAPI
ID3DXEffectImpl_GetVertexShader(ID3DXEffect
*iface
, D3DXHANDLE parameter
, LPDIRECT3DVERTEXSHADER9
*vshader
)
3430 struct ID3DXEffectImpl
*This
= impl_from_ID3DXEffect(iface
);
3431 ID3DXBaseEffect
*base
= This
->base_effect
;
3433 TRACE("Forward iface %p, base %p\n", This
, base
);
3435 return ID3DXBaseEffectImpl_GetVertexShader(base
, parameter
, vshader
);
3438 static HRESULT WINAPI
ID3DXEffectImpl_SetArrayRange(ID3DXEffect
*iface
, D3DXHANDLE parameter
, UINT start
, UINT end
)
3440 struct ID3DXEffectImpl
*This
= impl_from_ID3DXEffect(iface
);
3441 ID3DXBaseEffect
*base
= This
->base_effect
;
3443 TRACE("Forward iface %p, base %p\n", This
, base
);
3445 return ID3DXBaseEffectImpl_SetArrayRange(base
, parameter
, start
, end
);
3448 /*** ID3DXEffect methods ***/
3449 static HRESULT WINAPI
ID3DXEffectImpl_GetPool(ID3DXEffect
*iface
, LPD3DXEFFECTPOOL
*pool
)
3451 struct ID3DXEffectImpl
*This
= impl_from_ID3DXEffect(iface
);
3453 TRACE("iface %p, pool %p\n", This
, pool
);
3457 WARN("Invalid argument supplied.\n");
3458 return D3DERR_INVALIDCALL
;
3463 This
->pool
->lpVtbl
->AddRef(This
->pool
);
3468 TRACE("Returning pool %p\n", *pool
);
3473 static HRESULT WINAPI
ID3DXEffectImpl_SetTechnique(ID3DXEffect
*iface
, D3DXHANDLE technique
)
3475 struct ID3DXEffectImpl
*This
= impl_from_ID3DXEffect(iface
);
3476 struct ID3DXBaseEffectImpl
*base
= impl_from_ID3DXBaseEffect(This
->base_effect
);
3477 struct d3dx_technique
*tech
= is_valid_technique(base
, technique
);
3479 TRACE("iface %p, technique %p\n", This
, technique
);
3481 if (!tech
) tech
= get_technique_struct(iface
->lpVtbl
->GetTechniqueByName(iface
, technique
));
3487 for (i
= 0; i
< base
->technique_count
; ++i
)
3489 struct d3dx_technique
*t
= get_technique_struct(base
->technique_handles
[i
]);
3493 This
->active_technique
= get_technique_handle(t
);
3494 TRACE("Technique %u (%p)\n", i
, tech
);
3500 WARN("Invalid argument supplied.\n");
3502 return D3DERR_INVALIDCALL
;
3505 static D3DXHANDLE WINAPI
ID3DXEffectImpl_GetCurrentTechnique(ID3DXEffect
*iface
)
3507 struct ID3DXEffectImpl
*This
= impl_from_ID3DXEffect(iface
);
3509 TRACE("iface %p\n", This
);
3511 return This
->active_technique
;
3514 static HRESULT WINAPI
ID3DXEffectImpl_ValidateTechnique(ID3DXEffect
* iface
, D3DXHANDLE technique
)
3516 struct ID3DXEffectImpl
*This
= impl_from_ID3DXEffect(iface
);
3518 FIXME("(%p)->(%p): stub\n", This
, technique
);
3523 static HRESULT WINAPI
ID3DXEffectImpl_FindNextValidTechnique(ID3DXEffect
* iface
, D3DXHANDLE technique
, D3DXHANDLE
* next_technique
)
3525 struct ID3DXEffectImpl
*This
= impl_from_ID3DXEffect(iface
);
3527 FIXME("(%p)->(%p, %p): stub\n", This
, technique
, next_technique
);
3532 static BOOL WINAPI
ID3DXEffectImpl_IsParameterUsed(ID3DXEffect
* iface
, D3DXHANDLE parameter
, D3DXHANDLE technique
)
3534 struct ID3DXEffectImpl
*This
= impl_from_ID3DXEffect(iface
);
3536 FIXME("(%p)->(%p, %p): stub\n", This
, parameter
, technique
);
3541 static HRESULT WINAPI
ID3DXEffectImpl_Begin(ID3DXEffect
*iface
, UINT
*passes
, DWORD flags
)
3543 struct ID3DXEffectImpl
*This
= impl_from_ID3DXEffect(iface
);
3544 struct d3dx_technique
*technique
= get_technique_struct(This
->active_technique
);
3546 FIXME("iface %p, passes %p, flags %#x partial stub\n", This
, passes
, flags
);
3548 if (passes
&& technique
)
3550 if (This
->manager
|| flags
& D3DXFX_DONOTSAVESTATE
)
3552 TRACE("State capturing disabled.\n");
3556 FIXME("State capturing not supported, yet!\n");
3559 *passes
= technique
->pass_count
;
3564 WARN("Invalid argument supplied.\n");
3566 return D3DERR_INVALIDCALL
;
3569 static HRESULT WINAPI
ID3DXEffectImpl_BeginPass(ID3DXEffect
*iface
, UINT pass
)
3571 struct ID3DXEffectImpl
*This
= impl_from_ID3DXEffect(iface
);
3572 struct d3dx_technique
*technique
= get_technique_struct(This
->active_technique
);
3574 TRACE("iface %p, pass %u\n", This
, pass
);
3576 if (technique
&& pass
< technique
->pass_count
&& !This
->active_pass
)
3578 This
->active_pass
= technique
->pass_handles
[pass
];
3580 FIXME("No states applied, yet!\n");
3585 WARN("Invalid argument supplied.\n");
3587 return D3DERR_INVALIDCALL
;
3590 static HRESULT WINAPI
ID3DXEffectImpl_CommitChanges(ID3DXEffect
* iface
)
3592 struct ID3DXEffectImpl
*This
= impl_from_ID3DXEffect(iface
);
3594 FIXME("(%p)->(): stub\n", This
);
3599 static HRESULT WINAPI
ID3DXEffectImpl_EndPass(ID3DXEffect
*iface
)
3601 struct ID3DXEffectImpl
*This
= impl_from_ID3DXEffect(iface
);
3603 TRACE("iface %p\n", This
);
3605 if (This
->active_pass
)
3607 This
->active_pass
= NULL
;
3611 WARN("Invalid call.\n");
3613 return D3DERR_INVALIDCALL
;
3616 static HRESULT WINAPI
ID3DXEffectImpl_End(ID3DXEffect
* iface
)
3618 struct ID3DXEffectImpl
*This
= impl_from_ID3DXEffect(iface
);
3620 FIXME("(%p)->(): stub\n", This
);
3625 static HRESULT WINAPI
ID3DXEffectImpl_GetDevice(ID3DXEffect
*iface
, LPDIRECT3DDEVICE9
*device
)
3627 struct ID3DXEffectImpl
*This
= impl_from_ID3DXEffect(iface
);
3629 TRACE("iface %p, device %p\n", This
, device
);
3633 WARN("Invalid argument supplied.\n");
3634 return D3DERR_INVALIDCALL
;
3637 IDirect3DDevice9_AddRef(This
->device
);
3639 *device
= This
->device
;
3641 TRACE("Returning device %p\n", *device
);
3646 static HRESULT WINAPI
ID3DXEffectImpl_OnLostDevice(ID3DXEffect
* iface
)
3648 struct ID3DXEffectImpl
*This
= impl_from_ID3DXEffect(iface
);
3650 FIXME("(%p)->(): stub\n", This
);
3655 static HRESULT WINAPI
ID3DXEffectImpl_OnResetDevice(ID3DXEffect
* iface
)
3657 struct ID3DXEffectImpl
*This
= impl_from_ID3DXEffect(iface
);
3659 FIXME("(%p)->(): stub\n", This
);
3664 static HRESULT WINAPI
ID3DXEffectImpl_SetStateManager(ID3DXEffect
*iface
, LPD3DXEFFECTSTATEMANAGER manager
)
3666 struct ID3DXEffectImpl
*This
= impl_from_ID3DXEffect(iface
);
3668 TRACE("iface %p, manager %p\n", This
, manager
);
3670 if (manager
) IUnknown_AddRef(manager
);
3671 if (This
->manager
) IUnknown_Release(This
->manager
);
3673 This
->manager
= manager
;
3678 static HRESULT WINAPI
ID3DXEffectImpl_GetStateManager(ID3DXEffect
*iface
, LPD3DXEFFECTSTATEMANAGER
*manager
)
3680 struct ID3DXEffectImpl
*This
= impl_from_ID3DXEffect(iface
);
3682 TRACE("iface %p, manager %p\n", This
, manager
);
3686 WARN("Invalid argument supplied.\n");
3687 return D3DERR_INVALIDCALL
;
3690 if (This
->manager
) IUnknown_AddRef(This
->manager
);
3691 *manager
= This
->manager
;
3696 static HRESULT WINAPI
ID3DXEffectImpl_BeginParameterBlock(ID3DXEffect
* iface
)
3698 struct ID3DXEffectImpl
*This
= impl_from_ID3DXEffect(iface
);
3700 FIXME("(%p)->(): stub\n", This
);
3705 static D3DXHANDLE WINAPI
ID3DXEffectImpl_EndParameterBlock(ID3DXEffect
* iface
)
3707 struct ID3DXEffectImpl
*This
= impl_from_ID3DXEffect(iface
);
3709 FIXME("(%p)->(): stub\n", This
);
3714 static HRESULT WINAPI
ID3DXEffectImpl_ApplyParameterBlock(ID3DXEffect
* iface
, D3DXHANDLE parameter_block
)
3716 struct ID3DXEffectImpl
*This
= impl_from_ID3DXEffect(iface
);
3718 FIXME("(%p)->(%p): stub\n", This
, parameter_block
);
3723 static HRESULT WINAPI
ID3DXEffectImpl_DeleteParameterBlock(ID3DXEffect
* iface
, D3DXHANDLE parameter_block
)
3725 struct ID3DXEffectImpl
*This
= impl_from_ID3DXEffect(iface
);
3727 FIXME("(%p)->(%p): stub\n", This
, parameter_block
);
3732 static HRESULT WINAPI
ID3DXEffectImpl_CloneEffect(ID3DXEffect
* iface
, LPDIRECT3DDEVICE9 device
, LPD3DXEFFECT
* effect
)
3734 struct ID3DXEffectImpl
*This
= impl_from_ID3DXEffect(iface
);
3736 FIXME("(%p)->(%p, %p): stub\n", This
, device
, effect
);
3741 static HRESULT WINAPI
ID3DXEffectImpl_SetRawValue(ID3DXEffect
* iface
, D3DXHANDLE parameter
, LPCVOID data
, UINT byte_offset
, UINT bytes
)
3743 struct ID3DXEffectImpl
*This
= impl_from_ID3DXEffect(iface
);
3745 FIXME("(%p)->(%p, %p, %u, %u): stub\n", This
, parameter
, data
, byte_offset
, bytes
);
3750 static const struct ID3DXEffectVtbl ID3DXEffect_Vtbl
=
3752 /*** IUnknown methods ***/
3753 ID3DXEffectImpl_QueryInterface
,
3754 ID3DXEffectImpl_AddRef
,
3755 ID3DXEffectImpl_Release
,
3756 /*** ID3DXBaseEffect methods ***/
3757 ID3DXEffectImpl_GetDesc
,
3758 ID3DXEffectImpl_GetParameterDesc
,
3759 ID3DXEffectImpl_GetTechniqueDesc
,
3760 ID3DXEffectImpl_GetPassDesc
,
3761 ID3DXEffectImpl_GetFunctionDesc
,
3762 ID3DXEffectImpl_GetParameter
,
3763 ID3DXEffectImpl_GetParameterByName
,
3764 ID3DXEffectImpl_GetParameterBySemantic
,
3765 ID3DXEffectImpl_GetParameterElement
,
3766 ID3DXEffectImpl_GetTechnique
,
3767 ID3DXEffectImpl_GetTechniqueByName
,
3768 ID3DXEffectImpl_GetPass
,
3769 ID3DXEffectImpl_GetPassByName
,
3770 ID3DXEffectImpl_GetFunction
,
3771 ID3DXEffectImpl_GetFunctionByName
,
3772 ID3DXEffectImpl_GetAnnotation
,
3773 ID3DXEffectImpl_GetAnnotationByName
,
3774 ID3DXEffectImpl_SetValue
,
3775 ID3DXEffectImpl_GetValue
,
3776 ID3DXEffectImpl_SetBool
,
3777 ID3DXEffectImpl_GetBool
,
3778 ID3DXEffectImpl_SetBoolArray
,
3779 ID3DXEffectImpl_GetBoolArray
,
3780 ID3DXEffectImpl_SetInt
,
3781 ID3DXEffectImpl_GetInt
,
3782 ID3DXEffectImpl_SetIntArray
,
3783 ID3DXEffectImpl_GetIntArray
,
3784 ID3DXEffectImpl_SetFloat
,
3785 ID3DXEffectImpl_GetFloat
,
3786 ID3DXEffectImpl_SetFloatArray
,
3787 ID3DXEffectImpl_GetFloatArray
,
3788 ID3DXEffectImpl_SetVector
,
3789 ID3DXEffectImpl_GetVector
,
3790 ID3DXEffectImpl_SetVectorArray
,
3791 ID3DXEffectImpl_GetVectorArray
,
3792 ID3DXEffectImpl_SetMatrix
,
3793 ID3DXEffectImpl_GetMatrix
,
3794 ID3DXEffectImpl_SetMatrixArray
,
3795 ID3DXEffectImpl_GetMatrixArray
,
3796 ID3DXEffectImpl_SetMatrixPointerArray
,
3797 ID3DXEffectImpl_GetMatrixPointerArray
,
3798 ID3DXEffectImpl_SetMatrixTranspose
,
3799 ID3DXEffectImpl_GetMatrixTranspose
,
3800 ID3DXEffectImpl_SetMatrixTransposeArray
,
3801 ID3DXEffectImpl_GetMatrixTransposeArray
,
3802 ID3DXEffectImpl_SetMatrixTransposePointerArray
,
3803 ID3DXEffectImpl_GetMatrixTransposePointerArray
,
3804 ID3DXEffectImpl_SetString
,
3805 ID3DXEffectImpl_GetString
,
3806 ID3DXEffectImpl_SetTexture
,
3807 ID3DXEffectImpl_GetTexture
,
3808 ID3DXEffectImpl_GetPixelShader
,
3809 ID3DXEffectImpl_GetVertexShader
,
3810 ID3DXEffectImpl_SetArrayRange
,
3811 /*** ID3DXEffect methods ***/
3812 ID3DXEffectImpl_GetPool
,
3813 ID3DXEffectImpl_SetTechnique
,
3814 ID3DXEffectImpl_GetCurrentTechnique
,
3815 ID3DXEffectImpl_ValidateTechnique
,
3816 ID3DXEffectImpl_FindNextValidTechnique
,
3817 ID3DXEffectImpl_IsParameterUsed
,
3818 ID3DXEffectImpl_Begin
,
3819 ID3DXEffectImpl_BeginPass
,
3820 ID3DXEffectImpl_CommitChanges
,
3821 ID3DXEffectImpl_EndPass
,
3822 ID3DXEffectImpl_End
,
3823 ID3DXEffectImpl_GetDevice
,
3824 ID3DXEffectImpl_OnLostDevice
,
3825 ID3DXEffectImpl_OnResetDevice
,
3826 ID3DXEffectImpl_SetStateManager
,
3827 ID3DXEffectImpl_GetStateManager
,
3828 ID3DXEffectImpl_BeginParameterBlock
,
3829 ID3DXEffectImpl_EndParameterBlock
,
3830 ID3DXEffectImpl_ApplyParameterBlock
,
3831 ID3DXEffectImpl_DeleteParameterBlock
,
3832 ID3DXEffectImpl_CloneEffect
,
3833 ID3DXEffectImpl_SetRawValue
3836 static inline struct ID3DXEffectCompilerImpl
*impl_from_ID3DXEffectCompiler(ID3DXEffectCompiler
*iface
)
3838 return CONTAINING_RECORD(iface
, struct ID3DXEffectCompilerImpl
, ID3DXEffectCompiler_iface
);
3841 /*** IUnknown methods ***/
3842 static HRESULT WINAPI
ID3DXEffectCompilerImpl_QueryInterface(ID3DXEffectCompiler
*iface
, REFIID riid
, void **object
)
3844 TRACE("iface %p, riid %s, object %p.\n", iface
, debugstr_guid(riid
), object
);
3846 if (IsEqualGUID(riid
, &IID_IUnknown
) ||
3847 IsEqualGUID(riid
, &IID_ID3DXEffectCompiler
))
3849 iface
->lpVtbl
->AddRef(iface
);
3854 ERR("Interface %s not found\n", debugstr_guid(riid
));
3856 return E_NOINTERFACE
;
3859 static ULONG WINAPI
ID3DXEffectCompilerImpl_AddRef(ID3DXEffectCompiler
*iface
)
3861 struct ID3DXEffectCompilerImpl
*This
= impl_from_ID3DXEffectCompiler(iface
);
3863 TRACE("iface %p: AddRef from %u\n", iface
, This
->ref
);
3865 return InterlockedIncrement(&This
->ref
);
3868 static ULONG WINAPI
ID3DXEffectCompilerImpl_Release(ID3DXEffectCompiler
*iface
)
3870 struct ID3DXEffectCompilerImpl
*This
= impl_from_ID3DXEffectCompiler(iface
);
3871 ULONG ref
= InterlockedDecrement(&This
->ref
);
3873 TRACE("iface %p: Release from %u\n", iface
, ref
+ 1);
3877 free_effect_compiler(This
);
3878 HeapFree(GetProcessHeap(), 0, This
);
3884 /*** ID3DXBaseEffect methods ***/
3885 static HRESULT WINAPI
ID3DXEffectCompilerImpl_GetDesc(ID3DXEffectCompiler
*iface
, D3DXEFFECT_DESC
*desc
)
3887 struct ID3DXEffectCompilerImpl
*This
= impl_from_ID3DXEffectCompiler(iface
);
3888 ID3DXBaseEffect
*base
= This
->base_effect
;
3890 TRACE("Forward iface %p, base %p\n", This
, base
);
3892 return ID3DXBaseEffectImpl_GetDesc(base
, desc
);
3895 static HRESULT WINAPI
ID3DXEffectCompilerImpl_GetParameterDesc(ID3DXEffectCompiler
*iface
, D3DXHANDLE parameter
, D3DXPARAMETER_DESC
*desc
)
3897 struct ID3DXEffectCompilerImpl
*This
= impl_from_ID3DXEffectCompiler(iface
);
3898 ID3DXBaseEffect
*base
= This
->base_effect
;
3900 TRACE("Forward iface %p, base %p\n", This
, base
);
3902 return ID3DXBaseEffectImpl_GetParameterDesc(base
, parameter
, desc
);
3905 static HRESULT WINAPI
ID3DXEffectCompilerImpl_GetTechniqueDesc(ID3DXEffectCompiler
*iface
, D3DXHANDLE technique
, D3DXTECHNIQUE_DESC
*desc
)
3907 struct ID3DXEffectCompilerImpl
*This
= impl_from_ID3DXEffectCompiler(iface
);
3908 ID3DXBaseEffect
*base
= This
->base_effect
;
3910 TRACE("Forward iface %p, base %p\n", This
, base
);
3912 return ID3DXBaseEffectImpl_GetTechniqueDesc(base
, technique
, desc
);
3915 static HRESULT WINAPI
ID3DXEffectCompilerImpl_GetPassDesc(ID3DXEffectCompiler
*iface
, D3DXHANDLE pass
, D3DXPASS_DESC
*desc
)
3917 struct ID3DXEffectCompilerImpl
*This
= impl_from_ID3DXEffectCompiler(iface
);
3918 ID3DXBaseEffect
*base
= This
->base_effect
;
3920 TRACE("Forward iface %p, base %p\n", This
, base
);
3922 return ID3DXBaseEffectImpl_GetPassDesc(base
, pass
, desc
);
3925 static HRESULT WINAPI
ID3DXEffectCompilerImpl_GetFunctionDesc(ID3DXEffectCompiler
*iface
, D3DXHANDLE shader
, D3DXFUNCTION_DESC
*desc
)
3927 struct ID3DXEffectCompilerImpl
*This
= impl_from_ID3DXEffectCompiler(iface
);
3928 ID3DXBaseEffect
*base
= This
->base_effect
;
3930 TRACE("Forward iface %p, base %p\n", This
, base
);
3932 return ID3DXBaseEffectImpl_GetFunctionDesc(base
, shader
, desc
);
3935 static D3DXHANDLE WINAPI
ID3DXEffectCompilerImpl_GetParameter(ID3DXEffectCompiler
*iface
, D3DXHANDLE parameter
, UINT index
)
3937 struct ID3DXEffectCompilerImpl
*This
= impl_from_ID3DXEffectCompiler(iface
);
3938 ID3DXBaseEffect
*base
= This
->base_effect
;
3940 TRACE("Forward iface %p, base %p\n", This
, base
);
3942 return ID3DXBaseEffectImpl_GetParameter(base
, parameter
, index
);
3945 static D3DXHANDLE WINAPI
ID3DXEffectCompilerImpl_GetParameterByName(ID3DXEffectCompiler
*iface
, D3DXHANDLE parameter
, LPCSTR name
)
3947 struct ID3DXEffectCompilerImpl
*This
= impl_from_ID3DXEffectCompiler(iface
);
3948 ID3DXBaseEffect
*base
= This
->base_effect
;
3950 TRACE("Forward iface %p, base %p\n", This
, base
);
3952 return ID3DXBaseEffectImpl_GetParameterByName(base
, parameter
, name
);
3955 static D3DXHANDLE WINAPI
ID3DXEffectCompilerImpl_GetParameterBySemantic(ID3DXEffectCompiler
*iface
, D3DXHANDLE parameter
, LPCSTR semantic
)
3957 struct ID3DXEffectCompilerImpl
*This
= impl_from_ID3DXEffectCompiler(iface
);
3958 ID3DXBaseEffect
*base
= This
->base_effect
;
3960 TRACE("Forward iface %p, base %p\n", This
, base
);
3962 return ID3DXBaseEffectImpl_GetParameterBySemantic(base
, parameter
, semantic
);
3965 static D3DXHANDLE WINAPI
ID3DXEffectCompilerImpl_GetParameterElement(ID3DXEffectCompiler
*iface
, D3DXHANDLE parameter
, UINT index
)
3967 struct ID3DXEffectCompilerImpl
*This
= impl_from_ID3DXEffectCompiler(iface
);
3968 ID3DXBaseEffect
*base
= This
->base_effect
;
3970 TRACE("Forward iface %p, base %p\n", This
, base
);
3972 return ID3DXBaseEffectImpl_GetParameterElement(base
, parameter
, index
);
3975 static D3DXHANDLE WINAPI
ID3DXEffectCompilerImpl_GetTechnique(ID3DXEffectCompiler
*iface
, UINT index
)
3977 struct ID3DXEffectCompilerImpl
*This
= impl_from_ID3DXEffectCompiler(iface
);
3978 ID3DXBaseEffect
*base
= This
->base_effect
;
3980 TRACE("Forward iface %p, base %p\n", This
, base
);
3982 return ID3DXBaseEffectImpl_GetTechnique(base
, index
);
3985 static D3DXHANDLE WINAPI
ID3DXEffectCompilerImpl_GetTechniqueByName(ID3DXEffectCompiler
*iface
, LPCSTR name
)
3987 struct ID3DXEffectCompilerImpl
*This
= impl_from_ID3DXEffectCompiler(iface
);
3988 ID3DXBaseEffect
*base
= This
->base_effect
;
3990 TRACE("Forward iface %p, base %p\n", This
, base
);
3992 return ID3DXBaseEffectImpl_GetTechniqueByName(base
, name
);
3995 static D3DXHANDLE WINAPI
ID3DXEffectCompilerImpl_GetPass(ID3DXEffectCompiler
*iface
, D3DXHANDLE technique
, UINT index
)
3997 struct ID3DXEffectCompilerImpl
*This
= impl_from_ID3DXEffectCompiler(iface
);
3998 ID3DXBaseEffect
*base
= This
->base_effect
;
4000 TRACE("Forward iface %p, base %p\n", This
, base
);
4002 return ID3DXBaseEffectImpl_GetPass(base
, technique
, index
);
4005 static D3DXHANDLE WINAPI
ID3DXEffectCompilerImpl_GetPassByName(ID3DXEffectCompiler
*iface
, D3DXHANDLE technique
, LPCSTR name
)
4007 struct ID3DXEffectCompilerImpl
*This
= impl_from_ID3DXEffectCompiler(iface
);
4008 ID3DXBaseEffect
*base
= This
->base_effect
;
4010 TRACE("Forward iface %p, base %p\n", This
, base
);
4012 return ID3DXBaseEffectImpl_GetPassByName(base
, technique
, name
);
4015 static D3DXHANDLE WINAPI
ID3DXEffectCompilerImpl_GetFunction(ID3DXEffectCompiler
*iface
, UINT index
)
4017 struct ID3DXEffectCompilerImpl
*This
= impl_from_ID3DXEffectCompiler(iface
);
4018 ID3DXBaseEffect
*base
= This
->base_effect
;
4020 TRACE("Forward iface %p, base %p\n", This
, base
);
4022 return ID3DXBaseEffectImpl_GetFunction(base
, index
);
4025 static D3DXHANDLE WINAPI
ID3DXEffectCompilerImpl_GetFunctionByName(ID3DXEffectCompiler
*iface
, LPCSTR name
)
4027 struct ID3DXEffectCompilerImpl
*This
= impl_from_ID3DXEffectCompiler(iface
);
4028 ID3DXBaseEffect
*base
= This
->base_effect
;
4030 TRACE("Forward iface %p, base %p\n", This
, base
);
4032 return ID3DXBaseEffectImpl_GetFunctionByName(base
, name
);
4035 static D3DXHANDLE WINAPI
ID3DXEffectCompilerImpl_GetAnnotation(ID3DXEffectCompiler
*iface
, D3DXHANDLE object
, UINT index
)
4037 struct ID3DXEffectCompilerImpl
*This
= impl_from_ID3DXEffectCompiler(iface
);
4038 ID3DXBaseEffect
*base
= This
->base_effect
;
4040 TRACE("Forward iface %p, base %p\n", This
, base
);
4042 return ID3DXBaseEffectImpl_GetAnnotation(base
, object
, index
);
4045 static D3DXHANDLE WINAPI
ID3DXEffectCompilerImpl_GetAnnotationByName(ID3DXEffectCompiler
*iface
, D3DXHANDLE object
, LPCSTR name
)
4047 struct ID3DXEffectCompilerImpl
*This
= impl_from_ID3DXEffectCompiler(iface
);
4048 ID3DXBaseEffect
*base
= This
->base_effect
;
4050 TRACE("Forward iface %p, base %p\n", This
, base
);
4052 return ID3DXBaseEffectImpl_GetAnnotationByName(base
, object
, name
);
4055 static HRESULT WINAPI
ID3DXEffectCompilerImpl_SetValue(ID3DXEffectCompiler
*iface
, D3DXHANDLE parameter
, LPCVOID data
, UINT bytes
)
4057 struct ID3DXEffectCompilerImpl
*This
= impl_from_ID3DXEffectCompiler(iface
);
4058 ID3DXBaseEffect
*base
= This
->base_effect
;
4060 TRACE("Forward iface %p, base %p\n", This
, base
);
4062 return ID3DXBaseEffectImpl_SetValue(base
, parameter
, data
, bytes
);
4065 static HRESULT WINAPI
ID3DXEffectCompilerImpl_GetValue(ID3DXEffectCompiler
*iface
, D3DXHANDLE parameter
, LPVOID data
, UINT bytes
)
4067 struct ID3DXEffectCompilerImpl
*This
= impl_from_ID3DXEffectCompiler(iface
);
4068 ID3DXBaseEffect
*base
= This
->base_effect
;
4070 TRACE("Forward iface %p, base %p\n", This
, base
);
4072 return ID3DXBaseEffectImpl_GetValue(base
, parameter
, data
, bytes
);
4075 static HRESULT WINAPI
ID3DXEffectCompilerImpl_SetBool(ID3DXEffectCompiler
*iface
, D3DXHANDLE parameter
, BOOL b
)
4077 struct ID3DXEffectCompilerImpl
*This
= impl_from_ID3DXEffectCompiler(iface
);
4078 ID3DXBaseEffect
*base
= This
->base_effect
;
4080 TRACE("Forward iface %p, base %p\n", This
, base
);
4082 return ID3DXBaseEffectImpl_SetBool(base
, parameter
, b
);
4085 static HRESULT WINAPI
ID3DXEffectCompilerImpl_GetBool(ID3DXEffectCompiler
*iface
, D3DXHANDLE parameter
, BOOL
*b
)
4087 struct ID3DXEffectCompilerImpl
*This
= impl_from_ID3DXEffectCompiler(iface
);
4088 ID3DXBaseEffect
*base
= This
->base_effect
;
4090 TRACE("Forward iface %p, base %p\n", This
, base
);
4092 return ID3DXBaseEffectImpl_GetBool(base
, parameter
, b
);
4095 static HRESULT WINAPI
ID3DXEffectCompilerImpl_SetBoolArray(ID3DXEffectCompiler
*iface
, D3DXHANDLE parameter
, CONST BOOL
*b
, UINT count
)
4097 struct ID3DXEffectCompilerImpl
*This
= impl_from_ID3DXEffectCompiler(iface
);
4098 ID3DXBaseEffect
*base
= This
->base_effect
;
4100 TRACE("Forward iface %p, base %p\n", This
, base
);
4102 return ID3DXBaseEffectImpl_SetBoolArray(base
, parameter
, b
, count
);
4105 static HRESULT WINAPI
ID3DXEffectCompilerImpl_GetBoolArray(ID3DXEffectCompiler
*iface
, D3DXHANDLE parameter
, BOOL
*b
, UINT count
)
4107 struct ID3DXEffectCompilerImpl
*This
= impl_from_ID3DXEffectCompiler(iface
);
4108 ID3DXBaseEffect
*base
= This
->base_effect
;
4110 TRACE("Forward iface %p, base %p\n", This
, base
);
4112 return ID3DXBaseEffectImpl_GetBoolArray(base
, parameter
, b
, count
);
4115 static HRESULT WINAPI
ID3DXEffectCompilerImpl_SetInt(ID3DXEffectCompiler
*iface
, D3DXHANDLE parameter
, INT n
)
4117 struct ID3DXEffectCompilerImpl
*This
= impl_from_ID3DXEffectCompiler(iface
);
4118 ID3DXBaseEffect
*base
= This
->base_effect
;
4120 TRACE("Forward iface %p, base %p\n", This
, base
);
4122 return ID3DXBaseEffectImpl_SetInt(base
, parameter
, n
);
4125 static HRESULT WINAPI
ID3DXEffectCompilerImpl_GetInt(ID3DXEffectCompiler
*iface
, D3DXHANDLE parameter
, INT
*n
)
4127 struct ID3DXEffectCompilerImpl
*This
= impl_from_ID3DXEffectCompiler(iface
);
4128 ID3DXBaseEffect
*base
= This
->base_effect
;
4130 TRACE("Forward iface %p, base %p\n", This
, base
);
4132 return ID3DXBaseEffectImpl_GetInt(base
, parameter
, n
);
4135 static HRESULT WINAPI
ID3DXEffectCompilerImpl_SetIntArray(ID3DXEffectCompiler
*iface
, D3DXHANDLE parameter
, CONST INT
*n
, UINT count
)
4137 struct ID3DXEffectCompilerImpl
*This
= impl_from_ID3DXEffectCompiler(iface
);
4138 ID3DXBaseEffect
*base
= This
->base_effect
;
4140 TRACE("Forward iface %p, base %p\n", This
, base
);
4142 return ID3DXBaseEffectImpl_SetIntArray(base
, parameter
, n
, count
);
4145 static HRESULT WINAPI
ID3DXEffectCompilerImpl_GetIntArray(ID3DXEffectCompiler
*iface
, D3DXHANDLE parameter
, INT
*n
, UINT count
)
4147 struct ID3DXEffectCompilerImpl
*This
= impl_from_ID3DXEffectCompiler(iface
);
4148 ID3DXBaseEffect
*base
= This
->base_effect
;
4150 TRACE("Forward iface %p, base %p\n", This
, base
);
4152 return ID3DXBaseEffectImpl_GetIntArray(base
, parameter
, n
, count
);
4155 static HRESULT WINAPI
ID3DXEffectCompilerImpl_SetFloat(ID3DXEffectCompiler
*iface
, D3DXHANDLE parameter
, FLOAT f
)
4157 struct ID3DXEffectCompilerImpl
*This
= impl_from_ID3DXEffectCompiler(iface
);
4158 ID3DXBaseEffect
*base
= This
->base_effect
;
4160 TRACE("Forward iface %p, base %p\n", This
, base
);
4162 return ID3DXBaseEffectImpl_SetFloat(base
, parameter
, f
);
4165 static HRESULT WINAPI
ID3DXEffectCompilerImpl_GetFloat(ID3DXEffectCompiler
*iface
, D3DXHANDLE parameter
, FLOAT
*f
)
4167 struct ID3DXEffectCompilerImpl
*This
= impl_from_ID3DXEffectCompiler(iface
);
4168 ID3DXBaseEffect
*base
= This
->base_effect
;
4170 TRACE("Forward iface %p, base %p\n", This
, base
);
4172 return ID3DXBaseEffectImpl_GetFloat(base
, parameter
, f
);
4175 static HRESULT WINAPI
ID3DXEffectCompilerImpl_SetFloatArray(ID3DXEffectCompiler
*iface
, D3DXHANDLE parameter
, CONST FLOAT
*f
, UINT count
)
4177 struct ID3DXEffectCompilerImpl
*This
= impl_from_ID3DXEffectCompiler(iface
);
4178 ID3DXBaseEffect
*base
= This
->base_effect
;
4180 TRACE("Forward iface %p, base %p\n", This
, base
);
4182 return ID3DXBaseEffectImpl_SetFloatArray(base
, parameter
, f
, count
);
4185 static HRESULT WINAPI
ID3DXEffectCompilerImpl_GetFloatArray(ID3DXEffectCompiler
*iface
, D3DXHANDLE parameter
, FLOAT
*f
, UINT count
)
4187 struct ID3DXEffectCompilerImpl
*This
= impl_from_ID3DXEffectCompiler(iface
);
4188 ID3DXBaseEffect
*base
= This
->base_effect
;
4190 TRACE("Forward iface %p, base %p\n", This
, base
);
4192 return ID3DXBaseEffectImpl_GetFloatArray(base
, parameter
, f
, count
);
4195 static HRESULT WINAPI
ID3DXEffectCompilerImpl_SetVector(ID3DXEffectCompiler
*iface
, D3DXHANDLE parameter
, CONST D3DXVECTOR4
*vector
)
4197 struct ID3DXEffectCompilerImpl
*This
= impl_from_ID3DXEffectCompiler(iface
);
4198 ID3DXBaseEffect
*base
= This
->base_effect
;
4200 TRACE("Forward iface %p, base %p\n", This
, base
);
4202 return ID3DXBaseEffectImpl_SetVector(base
, parameter
, vector
);
4205 static HRESULT WINAPI
ID3DXEffectCompilerImpl_GetVector(ID3DXEffectCompiler
*iface
, D3DXHANDLE parameter
, D3DXVECTOR4
*vector
)
4207 struct ID3DXEffectCompilerImpl
*This
= impl_from_ID3DXEffectCompiler(iface
);
4208 ID3DXBaseEffect
*base
= This
->base_effect
;
4210 TRACE("Forward iface %p, base %p\n", This
, base
);
4212 return ID3DXBaseEffectImpl_GetVector(base
, parameter
, vector
);
4215 static HRESULT WINAPI
ID3DXEffectCompilerImpl_SetVectorArray(ID3DXEffectCompiler
*iface
, D3DXHANDLE parameter
, CONST D3DXVECTOR4
*vector
, UINT count
)
4217 struct ID3DXEffectCompilerImpl
*This
= impl_from_ID3DXEffectCompiler(iface
);
4218 ID3DXBaseEffect
*base
= This
->base_effect
;
4220 TRACE("Forward iface %p, base %p\n", This
, base
);
4222 return ID3DXBaseEffectImpl_SetVectorArray(base
, parameter
, vector
, count
);
4225 static HRESULT WINAPI
ID3DXEffectCompilerImpl_GetVectorArray(ID3DXEffectCompiler
*iface
, D3DXHANDLE parameter
, D3DXVECTOR4
*vector
, UINT count
)
4227 struct ID3DXEffectCompilerImpl
*This
= impl_from_ID3DXEffectCompiler(iface
);
4228 ID3DXBaseEffect
*base
= This
->base_effect
;
4230 TRACE("Forward iface %p, base %p\n", This
, base
);
4232 return ID3DXBaseEffectImpl_GetVectorArray(base
, parameter
, vector
, count
);
4235 static HRESULT WINAPI
ID3DXEffectCompilerImpl_SetMatrix(ID3DXEffectCompiler
*iface
, D3DXHANDLE parameter
, CONST D3DXMATRIX
*matrix
)
4237 struct ID3DXEffectCompilerImpl
*This
= impl_from_ID3DXEffectCompiler(iface
);
4238 ID3DXBaseEffect
*base
= This
->base_effect
;
4240 TRACE("Forward iface %p, base %p\n", This
, base
);
4242 return ID3DXBaseEffectImpl_SetMatrix(base
, parameter
, matrix
);
4245 static HRESULT WINAPI
ID3DXEffectCompilerImpl_GetMatrix(ID3DXEffectCompiler
*iface
, D3DXHANDLE parameter
, D3DXMATRIX
*matrix
)
4247 struct ID3DXEffectCompilerImpl
*This
= impl_from_ID3DXEffectCompiler(iface
);
4248 ID3DXBaseEffect
*base
= This
->base_effect
;
4250 TRACE("Forward iface %p, base %p\n", This
, base
);
4252 return ID3DXBaseEffectImpl_GetMatrix(base
, parameter
, matrix
);
4255 static HRESULT WINAPI
ID3DXEffectCompilerImpl_SetMatrixArray(ID3DXEffectCompiler
*iface
, D3DXHANDLE parameter
, CONST D3DXMATRIX
*matrix
, UINT count
)
4257 struct ID3DXEffectCompilerImpl
*This
= impl_from_ID3DXEffectCompiler(iface
);
4258 ID3DXBaseEffect
*base
= This
->base_effect
;
4260 TRACE("Forward iface %p, base %p\n", This
, base
);
4262 return ID3DXBaseEffectImpl_SetMatrixArray(base
, parameter
, matrix
, count
);
4265 static HRESULT WINAPI
ID3DXEffectCompilerImpl_GetMatrixArray(ID3DXEffectCompiler
*iface
, D3DXHANDLE parameter
, D3DXMATRIX
*matrix
, UINT count
)
4267 struct ID3DXEffectCompilerImpl
*This
= impl_from_ID3DXEffectCompiler(iface
);
4268 ID3DXBaseEffect
*base
= This
->base_effect
;
4270 TRACE("Forward iface %p, base %p\n", This
, base
);
4272 return ID3DXBaseEffectImpl_GetMatrixArray(base
, parameter
, matrix
, count
);
4275 static HRESULT WINAPI
ID3DXEffectCompilerImpl_SetMatrixPointerArray(ID3DXEffectCompiler
*iface
, D3DXHANDLE parameter
, CONST D3DXMATRIX
**matrix
, UINT count
)
4277 struct ID3DXEffectCompilerImpl
*This
= impl_from_ID3DXEffectCompiler(iface
);
4278 ID3DXBaseEffect
*base
= This
->base_effect
;
4280 TRACE("Forward iface %p, base %p\n", This
, base
);
4282 return ID3DXBaseEffectImpl_SetMatrixPointerArray(base
, parameter
, matrix
, count
);
4285 static HRESULT WINAPI
ID3DXEffectCompilerImpl_GetMatrixPointerArray(ID3DXEffectCompiler
*iface
, D3DXHANDLE parameter
, D3DXMATRIX
**matrix
, UINT count
)
4287 struct ID3DXEffectCompilerImpl
*This
= impl_from_ID3DXEffectCompiler(iface
);
4288 ID3DXBaseEffect
*base
= This
->base_effect
;
4290 TRACE("Forward iface %p, base %p\n", This
, base
);
4292 return ID3DXBaseEffectImpl_GetMatrixPointerArray(base
, parameter
, matrix
, count
);
4295 static HRESULT WINAPI
ID3DXEffectCompilerImpl_SetMatrixTranspose(ID3DXEffectCompiler
*iface
, D3DXHANDLE parameter
, CONST D3DXMATRIX
*matrix
)
4297 struct ID3DXEffectCompilerImpl
*This
= impl_from_ID3DXEffectCompiler(iface
);
4298 ID3DXBaseEffect
*base
= This
->base_effect
;
4300 TRACE("Forward iface %p, base %p\n", This
, base
);
4302 return ID3DXBaseEffectImpl_SetMatrixTranspose(base
, parameter
, matrix
);
4305 static HRESULT WINAPI
ID3DXEffectCompilerImpl_GetMatrixTranspose(ID3DXEffectCompiler
*iface
, D3DXHANDLE parameter
, D3DXMATRIX
*matrix
)
4307 struct ID3DXEffectCompilerImpl
*This
= impl_from_ID3DXEffectCompiler(iface
);
4308 ID3DXBaseEffect
*base
= This
->base_effect
;
4310 TRACE("Forward iface %p, base %p\n", This
, base
);
4312 return ID3DXBaseEffectImpl_GetMatrixTranspose(base
, parameter
, matrix
);
4315 static HRESULT WINAPI
ID3DXEffectCompilerImpl_SetMatrixTransposeArray(ID3DXEffectCompiler
*iface
, D3DXHANDLE parameter
, CONST D3DXMATRIX
*matrix
, UINT count
)
4317 struct ID3DXEffectCompilerImpl
*This
= impl_from_ID3DXEffectCompiler(iface
);
4318 ID3DXBaseEffect
*base
= This
->base_effect
;
4320 TRACE("Forward iface %p, base %p\n", This
, base
);
4322 return ID3DXBaseEffectImpl_SetMatrixTransposeArray(base
, parameter
, matrix
, count
);
4325 static HRESULT WINAPI
ID3DXEffectCompilerImpl_GetMatrixTransposeArray(ID3DXEffectCompiler
*iface
, D3DXHANDLE parameter
, D3DXMATRIX
*matrix
, UINT count
)
4327 struct ID3DXEffectCompilerImpl
*This
= impl_from_ID3DXEffectCompiler(iface
);
4328 ID3DXBaseEffect
*base
= This
->base_effect
;
4330 TRACE("Forward iface %p, base %p\n", This
, base
);
4332 return ID3DXBaseEffectImpl_GetMatrixTransposeArray(base
, parameter
, matrix
, count
);
4335 static HRESULT WINAPI
ID3DXEffectCompilerImpl_SetMatrixTransposePointerArray(ID3DXEffectCompiler
*iface
, D3DXHANDLE parameter
, CONST D3DXMATRIX
**matrix
, UINT count
)
4337 struct ID3DXEffectCompilerImpl
*This
= impl_from_ID3DXEffectCompiler(iface
);
4338 ID3DXBaseEffect
*base
= This
->base_effect
;
4340 TRACE("Forward iface %p, base %p\n", This
, base
);
4342 return ID3DXBaseEffectImpl_SetMatrixTransposePointerArray(base
, parameter
, matrix
, count
);
4345 static HRESULT WINAPI
ID3DXEffectCompilerImpl_GetMatrixTransposePointerArray(ID3DXEffectCompiler
*iface
, D3DXHANDLE parameter
, D3DXMATRIX
**matrix
, UINT count
)
4347 struct ID3DXEffectCompilerImpl
*This
= impl_from_ID3DXEffectCompiler(iface
);
4348 ID3DXBaseEffect
*base
= This
->base_effect
;
4350 TRACE("Forward iface %p, base %p\n", This
, base
);
4352 return ID3DXBaseEffectImpl_GetMatrixTransposePointerArray(base
, parameter
, matrix
, count
);
4355 static HRESULT WINAPI
ID3DXEffectCompilerImpl_SetString(ID3DXEffectCompiler
*iface
, D3DXHANDLE parameter
, LPCSTR string
)
4357 struct ID3DXEffectCompilerImpl
*This
= impl_from_ID3DXEffectCompiler(iface
);
4358 ID3DXBaseEffect
*base
= This
->base_effect
;
4360 TRACE("Forward iface %p, base %p\n", This
, base
);
4362 return ID3DXBaseEffectImpl_SetString(base
, parameter
, string
);
4365 static HRESULT WINAPI
ID3DXEffectCompilerImpl_GetString(ID3DXEffectCompiler
*iface
, D3DXHANDLE parameter
, LPCSTR
*string
)
4367 struct ID3DXEffectCompilerImpl
*This
= impl_from_ID3DXEffectCompiler(iface
);
4368 ID3DXBaseEffect
*base
= This
->base_effect
;
4370 TRACE("Forward iface %p, base %p\n", This
, base
);
4372 return ID3DXBaseEffectImpl_GetString(base
, parameter
, string
);
4375 static HRESULT WINAPI
ID3DXEffectCompilerImpl_SetTexture(ID3DXEffectCompiler
*iface
, D3DXHANDLE parameter
, LPDIRECT3DBASETEXTURE9 texture
)
4377 struct ID3DXEffectCompilerImpl
*This
= impl_from_ID3DXEffectCompiler(iface
);
4378 ID3DXBaseEffect
*base
= This
->base_effect
;
4380 TRACE("Forward iface %p, base %p\n", This
, base
);
4382 return ID3DXBaseEffectImpl_SetTexture(base
, parameter
, texture
);
4385 static HRESULT WINAPI
ID3DXEffectCompilerImpl_GetTexture(ID3DXEffectCompiler
*iface
, D3DXHANDLE parameter
, LPDIRECT3DBASETEXTURE9
*texture
)
4387 struct ID3DXEffectCompilerImpl
*This
= impl_from_ID3DXEffectCompiler(iface
);
4388 ID3DXBaseEffect
*base
= This
->base_effect
;
4390 TRACE("Forward iface %p, base %p\n", This
, base
);
4392 return ID3DXBaseEffectImpl_GetTexture(base
, parameter
, texture
);
4395 static HRESULT WINAPI
ID3DXEffectCompilerImpl_GetPixelShader(ID3DXEffectCompiler
*iface
, D3DXHANDLE parameter
, LPDIRECT3DPIXELSHADER9
*pshader
)
4397 struct ID3DXEffectCompilerImpl
*This
= impl_from_ID3DXEffectCompiler(iface
);
4398 ID3DXBaseEffect
*base
= This
->base_effect
;
4400 TRACE("Forward iface %p, base %p\n", This
, base
);
4402 return ID3DXBaseEffectImpl_GetPixelShader(base
, parameter
, pshader
);
4405 static HRESULT WINAPI
ID3DXEffectCompilerImpl_GetVertexShader(ID3DXEffectCompiler
*iface
, D3DXHANDLE parameter
, LPDIRECT3DVERTEXSHADER9
*vshader
)
4407 struct ID3DXEffectCompilerImpl
*This
= impl_from_ID3DXEffectCompiler(iface
);
4408 ID3DXBaseEffect
*base
= This
->base_effect
;
4410 TRACE("Forward iface %p, base %p\n", This
, base
);
4412 return ID3DXBaseEffectImpl_GetVertexShader(base
, parameter
, vshader
);
4415 static HRESULT WINAPI
ID3DXEffectCompilerImpl_SetArrayRange(ID3DXEffectCompiler
*iface
, D3DXHANDLE parameter
, UINT start
, UINT end
)
4417 struct ID3DXEffectCompilerImpl
*This
= impl_from_ID3DXEffectCompiler(iface
);
4418 ID3DXBaseEffect
*base
= This
->base_effect
;
4420 TRACE("Forward iface %p, base %p\n", This
, base
);
4422 return ID3DXBaseEffectImpl_SetArrayRange(base
, parameter
, start
, end
);
4425 /*** ID3DXEffectCompiler methods ***/
4426 static HRESULT WINAPI
ID3DXEffectCompilerImpl_SetLiteral(ID3DXEffectCompiler
*iface
, D3DXHANDLE parameter
, BOOL literal
)
4428 struct ID3DXEffectCompilerImpl
*This
= impl_from_ID3DXEffectCompiler(iface
);
4430 FIXME("iface %p, parameter %p, literal %u\n", This
, parameter
, literal
);
4435 static HRESULT WINAPI
ID3DXEffectCompilerImpl_GetLiteral(ID3DXEffectCompiler
*iface
, D3DXHANDLE parameter
, BOOL
*literal
)
4437 struct ID3DXEffectCompilerImpl
*This
= impl_from_ID3DXEffectCompiler(iface
);
4439 FIXME("iface %p, parameter %p, literal %p\n", This
, parameter
, literal
);
4444 static HRESULT WINAPI
ID3DXEffectCompilerImpl_CompileEffect(ID3DXEffectCompiler
*iface
, DWORD flags
,
4445 LPD3DXBUFFER
*effect
, LPD3DXBUFFER
*error_msgs
)
4447 struct ID3DXEffectCompilerImpl
*This
= impl_from_ID3DXEffectCompiler(iface
);
4449 FIXME("iface %p, flags %#x, effect %p, error_msgs %p stub\n", This
, flags
, effect
, error_msgs
);
4454 static HRESULT WINAPI
ID3DXEffectCompilerImpl_CompileShader(ID3DXEffectCompiler
*iface
, D3DXHANDLE function
,
4455 LPCSTR target
, DWORD flags
, LPD3DXBUFFER
*shader
, LPD3DXBUFFER
*error_msgs
, LPD3DXCONSTANTTABLE
*constant_table
)
4457 struct ID3DXEffectCompilerImpl
*This
= impl_from_ID3DXEffectCompiler(iface
);
4459 FIXME("iface %p, function %p, target %p, flags %#x, shader %p, error_msgs %p, constant_table %p stub\n",
4460 This
, function
, target
, flags
, shader
, error_msgs
, constant_table
);
4465 static const struct ID3DXEffectCompilerVtbl ID3DXEffectCompiler_Vtbl
=
4467 /*** IUnknown methods ***/
4468 ID3DXEffectCompilerImpl_QueryInterface
,
4469 ID3DXEffectCompilerImpl_AddRef
,
4470 ID3DXEffectCompilerImpl_Release
,
4471 /*** ID3DXBaseEffect methods ***/
4472 ID3DXEffectCompilerImpl_GetDesc
,
4473 ID3DXEffectCompilerImpl_GetParameterDesc
,
4474 ID3DXEffectCompilerImpl_GetTechniqueDesc
,
4475 ID3DXEffectCompilerImpl_GetPassDesc
,
4476 ID3DXEffectCompilerImpl_GetFunctionDesc
,
4477 ID3DXEffectCompilerImpl_GetParameter
,
4478 ID3DXEffectCompilerImpl_GetParameterByName
,
4479 ID3DXEffectCompilerImpl_GetParameterBySemantic
,
4480 ID3DXEffectCompilerImpl_GetParameterElement
,
4481 ID3DXEffectCompilerImpl_GetTechnique
,
4482 ID3DXEffectCompilerImpl_GetTechniqueByName
,
4483 ID3DXEffectCompilerImpl_GetPass
,
4484 ID3DXEffectCompilerImpl_GetPassByName
,
4485 ID3DXEffectCompilerImpl_GetFunction
,
4486 ID3DXEffectCompilerImpl_GetFunctionByName
,
4487 ID3DXEffectCompilerImpl_GetAnnotation
,
4488 ID3DXEffectCompilerImpl_GetAnnotationByName
,
4489 ID3DXEffectCompilerImpl_SetValue
,
4490 ID3DXEffectCompilerImpl_GetValue
,
4491 ID3DXEffectCompilerImpl_SetBool
,
4492 ID3DXEffectCompilerImpl_GetBool
,
4493 ID3DXEffectCompilerImpl_SetBoolArray
,
4494 ID3DXEffectCompilerImpl_GetBoolArray
,
4495 ID3DXEffectCompilerImpl_SetInt
,
4496 ID3DXEffectCompilerImpl_GetInt
,
4497 ID3DXEffectCompilerImpl_SetIntArray
,
4498 ID3DXEffectCompilerImpl_GetIntArray
,
4499 ID3DXEffectCompilerImpl_SetFloat
,
4500 ID3DXEffectCompilerImpl_GetFloat
,
4501 ID3DXEffectCompilerImpl_SetFloatArray
,
4502 ID3DXEffectCompilerImpl_GetFloatArray
,
4503 ID3DXEffectCompilerImpl_SetVector
,
4504 ID3DXEffectCompilerImpl_GetVector
,
4505 ID3DXEffectCompilerImpl_SetVectorArray
,
4506 ID3DXEffectCompilerImpl_GetVectorArray
,
4507 ID3DXEffectCompilerImpl_SetMatrix
,
4508 ID3DXEffectCompilerImpl_GetMatrix
,
4509 ID3DXEffectCompilerImpl_SetMatrixArray
,
4510 ID3DXEffectCompilerImpl_GetMatrixArray
,
4511 ID3DXEffectCompilerImpl_SetMatrixPointerArray
,
4512 ID3DXEffectCompilerImpl_GetMatrixPointerArray
,
4513 ID3DXEffectCompilerImpl_SetMatrixTranspose
,
4514 ID3DXEffectCompilerImpl_GetMatrixTranspose
,
4515 ID3DXEffectCompilerImpl_SetMatrixTransposeArray
,
4516 ID3DXEffectCompilerImpl_GetMatrixTransposeArray
,
4517 ID3DXEffectCompilerImpl_SetMatrixTransposePointerArray
,
4518 ID3DXEffectCompilerImpl_GetMatrixTransposePointerArray
,
4519 ID3DXEffectCompilerImpl_SetString
,
4520 ID3DXEffectCompilerImpl_GetString
,
4521 ID3DXEffectCompilerImpl_SetTexture
,
4522 ID3DXEffectCompilerImpl_GetTexture
,
4523 ID3DXEffectCompilerImpl_GetPixelShader
,
4524 ID3DXEffectCompilerImpl_GetVertexShader
,
4525 ID3DXEffectCompilerImpl_SetArrayRange
,
4526 /*** ID3DXEffectCompiler methods ***/
4527 ID3DXEffectCompilerImpl_SetLiteral
,
4528 ID3DXEffectCompilerImpl_GetLiteral
,
4529 ID3DXEffectCompilerImpl_CompileEffect
,
4530 ID3DXEffectCompilerImpl_CompileShader
,
4533 static HRESULT
d3dx9_parse_sampler(struct d3dx_sampler
*sampler
, const char *data
, const char **ptr
, D3DXHANDLE
*objects
)
4537 struct d3dx_state
*states
;
4539 read_dword(ptr
, &sampler
->state_count
);
4540 TRACE("Count: %u\n", sampler
->state_count
);
4542 states
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
, sizeof(*states
) * sampler
->state_count
);
4545 ERR("Out of memory\n");
4546 return E_OUTOFMEMORY
;
4549 for (i
= 0; i
< sampler
->state_count
; ++i
)
4551 hr
= d3dx9_parse_state(&states
[i
], data
, ptr
, objects
);
4554 WARN("Failed to parse state\n");
4559 sampler
->states
= states
;
4565 for (i
= 0; i
< sampler
->state_count
; ++i
)
4567 free_state(&states
[i
]);
4570 HeapFree(GetProcessHeap(), 0, states
);
4575 static HRESULT
d3dx9_parse_value(struct d3dx_parameter
*param
, void *value
, const char *data
, const char **ptr
, D3DXHANDLE
*objects
)
4582 if (param
->element_count
)
4584 param
->data
= value
;
4586 for (i
= 0; i
< param
->element_count
; ++i
)
4588 struct d3dx_parameter
*member
= get_parameter_struct(param
->member_handles
[i
]);
4590 hr
= d3dx9_parse_value(member
, value
? (char *)value
+ old_size
: NULL
, data
, ptr
, objects
);
4593 WARN("Failed to parse value\n");
4597 old_size
+= member
->bytes
;
4603 switch(param
->class)
4607 case D3DXPC_MATRIX_ROWS
:
4608 case D3DXPC_MATRIX_COLUMNS
:
4609 param
->data
= value
;
4613 param
->data
= value
;
4615 for (i
= 0; i
< param
->member_count
; ++i
)
4617 struct d3dx_parameter
*member
= get_parameter_struct(param
->member_handles
[i
]);
4619 hr
= d3dx9_parse_value(member
, (char *)value
+ old_size
, data
, ptr
, objects
);
4622 WARN("Failed to parse value\n");
4626 old_size
+= member
->bytes
;
4631 switch (param
->type
)
4634 case D3DXPT_TEXTURE
:
4635 case D3DXPT_TEXTURE1D
:
4636 case D3DXPT_TEXTURE2D
:
4637 case D3DXPT_TEXTURE3D
:
4638 case D3DXPT_TEXTURECUBE
:
4639 case D3DXPT_PIXELSHADER
:
4640 case D3DXPT_VERTEXSHADER
:
4641 read_dword(ptr
, &id
);
4642 TRACE("Id: %u\n", id
);
4643 objects
[id
] = get_parameter_handle(param
);
4644 param
->data
= value
;
4647 case D3DXPT_SAMPLER
:
4648 case D3DXPT_SAMPLER1D
:
4649 case D3DXPT_SAMPLER2D
:
4650 case D3DXPT_SAMPLER3D
:
4651 case D3DXPT_SAMPLERCUBE
:
4653 struct d3dx_sampler
*sampler
;
4655 sampler
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
, sizeof(*sampler
));
4658 ERR("Out of memory\n");
4659 return E_OUTOFMEMORY
;
4662 hr
= d3dx9_parse_sampler(sampler
, data
, ptr
, objects
);
4665 HeapFree(GetProcessHeap(), 0, sampler
);
4666 WARN("Failed to parse sampler\n");
4670 param
->data
= sampler
;
4675 FIXME("Unhandled type %s\n", debug_d3dxparameter_type(param
->type
));
4681 FIXME("Unhandled class %s\n", debug_d3dxparameter_class(param
->class));
4688 static HRESULT
d3dx9_parse_init_value(struct d3dx_parameter
*param
, const char *data
, const char *ptr
, D3DXHANDLE
*objects
)
4690 UINT size
= param
->bytes
;
4694 TRACE("param size: %u\n", size
);
4698 value
= HeapAlloc(GetProcessHeap(), 0, size
);
4701 ERR("Failed to allocate data memory.\n");
4702 return E_OUTOFMEMORY
;
4705 TRACE("Data: %s.\n", debugstr_an(ptr
, size
));
4706 memcpy(value
, ptr
, size
);
4709 hr
= d3dx9_parse_value(param
, value
, data
, &ptr
, objects
);
4712 WARN("Failed to parse value\n");
4713 HeapFree(GetProcessHeap(), 0, value
);
4720 static HRESULT
d3dx9_parse_name(char **name
, const char *ptr
)
4724 read_dword(&ptr
, &size
);
4725 TRACE("Name size: %#x\n", size
);
4732 *name
= HeapAlloc(GetProcessHeap(), 0, size
);
4735 ERR("Failed to allocate name memory.\n");
4736 return E_OUTOFMEMORY
;
4739 TRACE("Name: %s.\n", debugstr_an(ptr
, size
));
4740 memcpy(*name
, ptr
, size
);
4745 static HRESULT
d3dx9_copy_data(char **str
, const char **ptr
)
4749 read_dword(ptr
, &size
);
4750 TRACE("Data size: %#x\n", size
);
4752 *str
= HeapAlloc(GetProcessHeap(), 0, size
);
4755 ERR("Failed to allocate name memory.\n");
4756 return E_OUTOFMEMORY
;
4759 TRACE("Data: %s.\n", debugstr_an(*ptr
, size
));
4760 memcpy(*str
, *ptr
, size
);
4762 *ptr
+= ((size
+ 3) & ~3);
4767 static HRESULT
d3dx9_parse_data(struct d3dx_parameter
*param
, const char **ptr
, LPDIRECT3DDEVICE9 device
)
4772 TRACE("Parse data for parameter %s, type %s\n", debugstr_a(param
->name
), debug_d3dxparameter_type(param
->type
));
4774 read_dword(ptr
, &size
);
4775 TRACE("Data size: %#x\n", size
);
4779 TRACE("Size is 0\n");
4780 *(void **)param
->data
= NULL
;
4784 switch (param
->type
)
4787 /* re-read with size (sizeof(DWORD) = 4) */
4788 hr
= d3dx9_parse_name((LPSTR
*)param
->data
, *ptr
- 4);
4791 WARN("Failed to parse string data\n");
4796 case D3DXPT_VERTEXSHADER
:
4797 hr
= IDirect3DDevice9_CreateVertexShader(device
, (DWORD
*)*ptr
, (LPDIRECT3DVERTEXSHADER9
*)param
->data
);
4800 WARN("Failed to create vertex shader\n");
4805 case D3DXPT_PIXELSHADER
:
4806 hr
= IDirect3DDevice9_CreatePixelShader(device
, (DWORD
*)*ptr
, (LPDIRECT3DPIXELSHADER9
*)param
->data
);
4809 WARN("Failed to create pixel shader\n");
4815 FIXME("Unhandled type %s\n", debug_d3dxparameter_type(param
->type
));
4820 *ptr
+= ((size
+ 3) & ~3);
4825 static HRESULT
d3dx9_parse_effect_typedef(struct d3dx_parameter
*param
, const char *data
, const char **ptr
,
4826 struct d3dx_parameter
*parent
, UINT flags
)
4830 D3DXHANDLE
*member_handles
= NULL
;
4833 param
->flags
= flags
;
4837 read_dword(ptr
, ¶m
->type
);
4838 TRACE("Type: %s\n", debug_d3dxparameter_type(param
->type
));
4840 read_dword(ptr
, ¶m
->class);
4841 TRACE("Class: %s\n", debug_d3dxparameter_class(param
->class));
4843 read_dword(ptr
, &offset
);
4844 TRACE("Type name offset: %#x\n", offset
);
4845 hr
= d3dx9_parse_name(¶m
->name
, data
+ offset
);
4848 WARN("Failed to parse name\n");
4852 read_dword(ptr
, &offset
);
4853 TRACE("Type semantic offset: %#x\n", offset
);
4854 hr
= d3dx9_parse_name(¶m
->semantic
, data
+ offset
);
4857 WARN("Failed to parse semantic\n");
4861 read_dword(ptr
, ¶m
->element_count
);
4862 TRACE("Elements: %u\n", param
->element_count
);
4864 switch (param
->class)
4867 read_dword(ptr
, ¶m
->columns
);
4868 TRACE("Columns: %u\n", param
->columns
);
4870 read_dword(ptr
, ¶m
->rows
);
4871 TRACE("Rows: %u\n", param
->rows
);
4873 /* sizeof(DWORD) * rows * columns */
4874 param
->bytes
= 4 * param
->rows
* param
->columns
;
4878 case D3DXPC_MATRIX_ROWS
:
4879 case D3DXPC_MATRIX_COLUMNS
:
4880 read_dword(ptr
, ¶m
->rows
);
4881 TRACE("Rows: %u\n", param
->rows
);
4883 read_dword(ptr
, ¶m
->columns
);
4884 TRACE("Columns: %u\n", param
->columns
);
4886 /* sizeof(DWORD) * rows * columns */
4887 param
->bytes
= 4 * param
->rows
* param
->columns
;
4891 read_dword(ptr
, ¶m
->member_count
);
4892 TRACE("Members: %u\n", param
->member_count
);
4896 switch (param
->type
)
4899 param
->bytes
= sizeof(LPCSTR
);
4902 case D3DXPT_PIXELSHADER
:
4903 param
->bytes
= sizeof(LPDIRECT3DPIXELSHADER9
);
4906 case D3DXPT_VERTEXSHADER
:
4907 param
->bytes
= sizeof(LPDIRECT3DVERTEXSHADER9
);
4910 case D3DXPT_TEXTURE
:
4911 case D3DXPT_TEXTURE1D
:
4912 case D3DXPT_TEXTURE2D
:
4913 case D3DXPT_TEXTURE3D
:
4914 case D3DXPT_TEXTURECUBE
:
4915 param
->bytes
= sizeof(LPDIRECT3DBASETEXTURE9
);
4918 case D3DXPT_SAMPLER
:
4919 case D3DXPT_SAMPLER1D
:
4920 case D3DXPT_SAMPLER2D
:
4921 case D3DXPT_SAMPLER3D
:
4922 case D3DXPT_SAMPLERCUBE
:
4927 FIXME("Unhandled type %s\n", debug_d3dxparameter_type(param
->type
));
4933 FIXME("Unhandled class %s\n", debug_d3dxparameter_class(param
->class));
4940 param
->type
= parent
->type
;
4941 param
->class = parent
->class;
4942 param
->name
= parent
->name
;
4943 param
->semantic
= parent
->semantic
;
4944 param
->element_count
= 0;
4945 param
->annotation_count
= 0;
4946 param
->member_count
= parent
->member_count
;
4947 param
->bytes
= parent
->bytes
;
4948 param
->rows
= parent
->rows
;
4949 param
->columns
= parent
->columns
;
4952 if (param
->element_count
)
4954 unsigned int param_bytes
= 0;
4955 const char *save_ptr
= *ptr
;
4957 member_handles
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
, sizeof(*member_handles
) * param
->element_count
);
4958 if (!member_handles
)
4960 ERR("Out of memory\n");
4965 for (i
= 0; i
< param
->element_count
; ++i
)
4967 struct d3dx_parameter
*member
;
4970 member
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
, sizeof(*member
));
4973 ERR("Out of memory\n");
4978 member_handles
[i
] = get_parameter_handle(member
);
4980 hr
= d3dx9_parse_effect_typedef(member
, data
, ptr
, param
, flags
);
4983 WARN("Failed to parse member\n");
4987 param_bytes
+= member
->bytes
;
4990 param
->bytes
= param_bytes
;
4992 else if (param
->member_count
)
4994 member_handles
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
, sizeof(*member_handles
) * param
->member_count
);
4995 if (!member_handles
)
4997 ERR("Out of memory\n");
5002 for (i
= 0; i
< param
->member_count
; ++i
)
5004 struct d3dx_parameter
*member
;
5006 member
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
, sizeof(*member
));
5009 ERR("Out of memory\n");
5014 member_handles
[i
] = get_parameter_handle(member
);
5016 hr
= d3dx9_parse_effect_typedef(member
, data
, ptr
, NULL
, flags
);
5019 WARN("Failed to parse member\n");
5023 param
->bytes
+= member
->bytes
;
5027 param
->member_handles
= member_handles
;
5037 if (param
->element_count
) count
= param
->element_count
;
5038 else count
= param
->member_count
;
5040 for (i
= 0; i
< count
; ++i
)
5042 free_parameter(member_handles
[i
], param
->element_count
!= 0, TRUE
);
5044 HeapFree(GetProcessHeap(), 0, member_handles
);
5049 HeapFree(GetProcessHeap(), 0, param
->name
);
5050 HeapFree(GetProcessHeap(), 0, param
->semantic
);
5053 param
->semantic
= NULL
;
5058 static HRESULT
d3dx9_parse_effect_annotation(struct d3dx_parameter
*anno
, const char *data
, const char **ptr
, D3DXHANDLE
*objects
)
5064 anno
->flags
= D3DX_PARAMETER_ANNOTATION
;
5066 read_dword(ptr
, &offset
);
5067 TRACE("Typedef offset: %#x\n", offset
);
5068 ptr2
= data
+ offset
;
5069 hr
= d3dx9_parse_effect_typedef(anno
, data
, &ptr2
, NULL
, D3DX_PARAMETER_ANNOTATION
);
5072 WARN("Failed to parse type definition\n");
5076 read_dword(ptr
, &offset
);
5077 TRACE("Value offset: %#x\n", offset
);
5078 hr
= d3dx9_parse_init_value(anno
, data
, data
+ offset
, objects
);
5081 WARN("Failed to parse value\n");
5088 static HRESULT
d3dx9_parse_state(struct d3dx_state
*state
, const char *data
, const char **ptr
, D3DXHANDLE
*objects
)
5093 struct d3dx_parameter
*parameter
;
5095 parameter
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
, sizeof(*parameter
));
5098 ERR("Out of memory\n");
5099 return E_OUTOFMEMORY
;
5102 state
->type
= ST_CONSTANT
;
5104 read_dword(ptr
, &state
->operation
);
5105 TRACE("Operation: %#x (%s)\n", state
->operation
, state_table
[state
->operation
].name
);
5107 read_dword(ptr
, &state
->index
);
5108 TRACE("Index: %#x\n", state
->index
);
5110 read_dword(ptr
, &offset
);
5111 TRACE("Typedef offset: %#x\n", offset
);
5112 ptr2
= data
+ offset
;
5113 hr
= d3dx9_parse_effect_typedef(parameter
, data
, &ptr2
, NULL
, 0);
5116 WARN("Failed to parse type definition\n");
5120 read_dword(ptr
, &offset
);
5121 TRACE("Value offset: %#x\n", offset
);
5122 hr
= d3dx9_parse_init_value(parameter
, data
, data
+ offset
, objects
);
5125 WARN("Failed to parse value\n");
5129 state
->parameter
= get_parameter_handle(parameter
);
5135 free_parameter(get_parameter_handle(parameter
), FALSE
, FALSE
);
5140 static HRESULT
d3dx9_parse_effect_parameter(struct d3dx_parameter
*param
, const char *data
, const char **ptr
, D3DXHANDLE
*objects
)
5145 D3DXHANDLE
*annotation_handles
= NULL
;
5148 read_dword(ptr
, &offset
);
5149 TRACE("Typedef offset: %#x\n", offset
);
5150 ptr2
= data
+ offset
;
5152 read_dword(ptr
, &offset
);
5153 TRACE("Value offset: %#x\n", offset
);
5155 read_dword(ptr
, ¶m
->flags
);
5156 TRACE("Flags: %#x\n", param
->flags
);
5158 read_dword(ptr
, ¶m
->annotation_count
);
5159 TRACE("Annotation count: %u\n", param
->annotation_count
);
5161 hr
= d3dx9_parse_effect_typedef(param
, data
, &ptr2
, NULL
, param
->flags
);
5164 WARN("Failed to parse type definition\n");
5168 hr
= d3dx9_parse_init_value(param
, data
, data
+ offset
, objects
);
5171 WARN("Failed to parse value\n");
5175 if (param
->annotation_count
)
5177 annotation_handles
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
, sizeof(*annotation_handles
) * param
->annotation_count
);
5178 if (!annotation_handles
)
5180 ERR("Out of memory\n");
5185 for (i
= 0; i
< param
->annotation_count
; ++i
)
5187 struct d3dx_parameter
*annotation
;
5189 annotation
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
, sizeof(*annotation
));
5192 ERR("Out of memory\n");
5197 annotation_handles
[i
] = get_parameter_handle(annotation
);
5199 hr
= d3dx9_parse_effect_annotation(annotation
, data
, ptr
, objects
);
5202 WARN("Failed to parse annotation\n");
5208 param
->annotation_handles
= annotation_handles
;
5214 if (annotation_handles
)
5216 for (i
= 0; i
< param
->annotation_count
; ++i
)
5218 free_parameter(annotation_handles
[i
], FALSE
, FALSE
);
5220 HeapFree(GetProcessHeap(), 0, annotation_handles
);
5226 static HRESULT
d3dx9_parse_effect_pass(struct d3dx_pass
*pass
, const char *data
, const char **ptr
, D3DXHANDLE
*objects
)
5231 D3DXHANDLE
*annotation_handles
= NULL
;
5232 struct d3dx_state
*states
= NULL
;
5235 read_dword(ptr
, &offset
);
5236 TRACE("Pass name offset: %#x\n", offset
);
5237 hr
= d3dx9_parse_name(&name
, data
+ offset
);
5240 WARN("Failed to parse name\n");
5244 read_dword(ptr
, &pass
->annotation_count
);
5245 TRACE("Annotation count: %u\n", pass
->annotation_count
);
5247 read_dword(ptr
, &pass
->state_count
);
5248 TRACE("State count: %u\n", pass
->state_count
);
5250 if (pass
->annotation_count
)
5252 annotation_handles
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
, sizeof(*annotation_handles
) * pass
->annotation_count
);
5253 if (!annotation_handles
)
5255 ERR("Out of memory\n");
5260 for (i
= 0; i
< pass
->annotation_count
; ++i
)
5262 struct d3dx_parameter
*annotation
;
5264 annotation
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
, sizeof(*annotation
));
5267 ERR("Out of memory\n");
5272 annotation_handles
[i
] = get_parameter_handle(annotation
);
5274 hr
= d3dx9_parse_effect_annotation(annotation
, data
, ptr
, objects
);
5277 WARN("Failed to parse annotations\n");
5283 if (pass
->state_count
)
5285 states
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
, sizeof(*states
) * pass
->state_count
);
5288 ERR("Out of memory\n");
5293 for (i
= 0; i
< pass
->state_count
; ++i
)
5295 hr
= d3dx9_parse_state(&states
[i
], data
, ptr
, objects
);
5298 WARN("Failed to parse annotations\n");
5305 pass
->annotation_handles
= annotation_handles
;
5306 pass
->states
= states
;
5312 if (annotation_handles
)
5314 for (i
= 0; i
< pass
->annotation_count
; ++i
)
5316 free_parameter(annotation_handles
[i
], FALSE
, FALSE
);
5318 HeapFree(GetProcessHeap(), 0, annotation_handles
);
5323 for (i
= 0; i
< pass
->state_count
; ++i
)
5325 free_state(&states
[i
]);
5327 HeapFree(GetProcessHeap(), 0, states
);
5330 HeapFree(GetProcessHeap(), 0, name
);
5335 static HRESULT
d3dx9_parse_effect_technique(struct d3dx_technique
*technique
, const char *data
, const char **ptr
, D3DXHANDLE
*objects
)
5340 D3DXHANDLE
*annotation_handles
= NULL
;
5341 D3DXHANDLE
*pass_handles
= NULL
;
5344 read_dword(ptr
, &offset
);
5345 TRACE("Technique name offset: %#x\n", offset
);
5346 hr
= d3dx9_parse_name(&name
, data
+ offset
);
5349 WARN("Failed to parse name\n");
5353 read_dword(ptr
, &technique
->annotation_count
);
5354 TRACE("Annotation count: %u\n", technique
->annotation_count
);
5356 read_dword(ptr
, &technique
->pass_count
);
5357 TRACE("Pass count: %u\n", technique
->pass_count
);
5359 if (technique
->annotation_count
)
5361 annotation_handles
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
, sizeof(*annotation_handles
) * technique
->annotation_count
);
5362 if (!annotation_handles
)
5364 ERR("Out of memory\n");
5369 for (i
= 0; i
< technique
->annotation_count
; ++i
)
5371 struct d3dx_parameter
*annotation
;
5373 annotation
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
, sizeof(*annotation
));
5376 ERR("Out of memory\n");
5381 annotation_handles
[i
] = get_parameter_handle(annotation
);
5383 hr
= d3dx9_parse_effect_annotation(annotation
, data
, ptr
, objects
);
5386 WARN("Failed to parse annotations\n");
5392 if (technique
->pass_count
)
5394 pass_handles
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
, sizeof(*pass_handles
) * technique
->pass_count
);
5397 ERR("Out of memory\n");
5402 for (i
= 0; i
< technique
->pass_count
; ++i
)
5404 struct d3dx_pass
*pass
;
5406 pass
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
, sizeof(*pass
));
5409 ERR("Out of memory\n");
5414 pass_handles
[i
] = get_pass_handle(pass
);
5416 hr
= d3dx9_parse_effect_pass(pass
, data
, ptr
, objects
);
5419 WARN("Failed to parse passes\n");
5425 technique
->name
= name
;
5426 technique
->pass_handles
= pass_handles
;
5427 technique
->annotation_handles
= annotation_handles
;
5435 for (i
= 0; i
< technique
->pass_count
; ++i
)
5437 free_pass(pass_handles
[i
]);
5439 HeapFree(GetProcessHeap(), 0, pass_handles
);
5442 if (annotation_handles
)
5444 for (i
= 0; i
< technique
->annotation_count
; ++i
)
5446 free_parameter(annotation_handles
[i
], FALSE
, FALSE
);
5448 HeapFree(GetProcessHeap(), 0, annotation_handles
);
5451 HeapFree(GetProcessHeap(), 0, name
);
5456 static HRESULT
d3dx9_parse_resource(struct ID3DXBaseEffectImpl
*base
, const char *data
, const char **ptr
)
5458 DWORD technique_index
;
5459 DWORD index
, state_index
, usage
, element_index
;
5460 struct d3dx_state
*state
;
5461 struct d3dx_parameter
*param
;
5462 HRESULT hr
= E_FAIL
;
5464 read_dword(ptr
, &technique_index
);
5465 TRACE("techn: %u\n", technique_index
);
5467 read_dword(ptr
, &index
);
5468 TRACE("index: %u\n", index
);
5470 read_dword(ptr
, &element_index
);
5471 TRACE("element_index: %u\n", element_index
);
5473 read_dword(ptr
, &state_index
);
5474 TRACE("state_index: %u\n", state_index
);
5476 read_dword(ptr
, &usage
);
5477 TRACE("usage: %u\n", usage
);
5479 if (technique_index
== 0xffffffff)
5481 struct d3dx_parameter
*parameter
;
5482 struct d3dx_sampler
*sampler
;
5484 if (index
>= base
->parameter_count
)
5486 FIXME("Index out of bounds: index %u >= parameter_count %u\n", index
, base
->parameter_count
);
5490 parameter
= get_parameter_struct(base
->parameter_handles
[index
]);
5491 if (element_index
!= 0xffffffff)
5493 if (element_index
>= parameter
->element_count
&& parameter
->element_count
!= 0)
5495 FIXME("Index out of bounds: element_index %u >= element_count %u\n", element_index
, parameter
->element_count
);
5499 if (parameter
->element_count
!= 0) parameter
= get_parameter_struct(parameter
->member_handles
[element_index
]);
5502 sampler
= parameter
->data
;
5503 if (state_index
>= sampler
->state_count
)
5505 FIXME("Index out of bounds: state_index %u >= state_count %u\n", state_index
, sampler
->state_count
);
5509 state
= &sampler
->states
[state_index
];
5513 struct d3dx_technique
*technique
;
5514 struct d3dx_pass
*pass
;
5516 if (technique_index
>= base
->technique_count
)
5518 FIXME("Index out of bounds: technique_index %u >= technique_count %u\n", technique_index
, base
->technique_count
);
5522 technique
= get_technique_struct(base
->technique_handles
[technique_index
]);
5523 if (index
>= technique
->pass_count
)
5525 FIXME("Index out of bounds: index %u >= pass_count %u\n", index
, technique
->pass_count
);
5529 pass
= get_pass_struct(technique
->pass_handles
[index
]);
5530 if (state_index
>= pass
->state_count
)
5532 FIXME("Index out of bounds: state_index %u >= state_count %u\n", state_index
, pass
->state_count
);
5536 state
= &pass
->states
[state_index
];
5539 param
= get_parameter_struct(state
->parameter
);
5544 TRACE("usage 0: type %s\n", debug_d3dxparameter_type(param
->type
));
5545 switch (param
->type
)
5547 case D3DXPT_VERTEXSHADER
:
5548 case D3DXPT_PIXELSHADER
:
5549 state
->type
= ST_CONSTANT
;
5550 hr
= d3dx9_parse_data(param
, ptr
, base
->effect
->device
);
5557 state
->type
= ST_FXLC
;
5558 hr
= d3dx9_copy_data(param
->data
, ptr
);
5562 FIXME("Unhandled type %s\n", debug_d3dxparameter_type(param
->type
));
5568 state
->type
= ST_PARAMETER
;
5569 hr
= d3dx9_copy_data(param
->data
, ptr
);
5572 TRACE("Mapping to parameter %s\n", *(char **)param
->data
);
5577 FIXME("Unknown usage %x\n", usage
);
5584 static HRESULT
d3dx9_parse_effect(struct ID3DXBaseEffectImpl
*base
, const char *data
, UINT data_size
, DWORD start
)
5586 const char *ptr
= data
+ start
;
5587 D3DXHANDLE
*parameter_handles
= NULL
;
5588 D3DXHANDLE
*technique_handles
= NULL
;
5589 D3DXHANDLE
*objects
= NULL
;
5590 UINT stringcount
, objectcount
, resourcecount
;
5594 read_dword(&ptr
, &base
->parameter_count
);
5595 TRACE("Parameter count: %u\n", base
->parameter_count
);
5597 read_dword(&ptr
, &base
->technique_count
);
5598 TRACE("Technique count: %u\n", base
->technique_count
);
5600 skip_dword_unknown(&ptr
, 1);
5602 read_dword(&ptr
, &objectcount
);
5603 TRACE("Object count: %u\n", objectcount
);
5605 objects
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
, sizeof(*objects
) * objectcount
);
5608 ERR("Out of memory\n");
5613 if (base
->parameter_count
)
5615 parameter_handles
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
, sizeof(*parameter_handles
) * base
->parameter_count
);
5616 if (!parameter_handles
)
5618 ERR("Out of memory\n");
5623 for (i
= 0; i
< base
->parameter_count
; ++i
)
5625 struct d3dx_parameter
*parameter
;
5627 parameter
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
, sizeof(*parameter
));
5630 ERR("Out of memory\n");
5635 parameter_handles
[i
] = get_parameter_handle(parameter
);
5637 hr
= d3dx9_parse_effect_parameter(parameter
, data
, &ptr
, objects
);
5640 WARN("Failed to parse parameter\n");
5646 if (base
->technique_count
)
5648 technique_handles
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
, sizeof(*technique_handles
) * base
->technique_count
);
5649 if (!technique_handles
)
5651 ERR("Out of memory\n");
5656 for (i
= 0; i
< base
->technique_count
; ++i
)
5658 struct d3dx_technique
*technique
;
5660 technique
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
, sizeof(*technique
));
5663 ERR("Out of memory\n");
5668 technique_handles
[i
] = get_technique_handle(technique
);
5670 hr
= d3dx9_parse_effect_technique(technique
, data
, &ptr
, objects
);
5673 WARN("Failed to parse technique\n");
5679 /* needed for further parsing */
5680 base
->technique_handles
= technique_handles
;
5681 base
->parameter_handles
= parameter_handles
;
5683 read_dword(&ptr
, &stringcount
);
5684 TRACE("String count: %u\n", stringcount
);
5686 read_dword(&ptr
, &resourcecount
);
5687 TRACE("Resource count: %u\n", resourcecount
);
5689 for (i
= 0; i
< stringcount
; ++i
)
5692 struct d3dx_parameter
*param
;
5694 read_dword(&ptr
, &id
);
5695 TRACE("Id: %u\n", id
);
5697 param
= get_parameter_struct(objects
[id
]);
5699 hr
= d3dx9_parse_data(param
, &ptr
, base
->effect
->device
);
5702 WARN("Failed to parse data\n");
5707 for (i
= 0; i
< resourcecount
; ++i
)
5709 TRACE("parse resource %u\n", i
);
5711 hr
= d3dx9_parse_resource(base
, data
, &ptr
);
5714 WARN("Failed to parse data\n");
5719 HeapFree(GetProcessHeap(), 0, objects
);
5725 if (technique_handles
)
5727 for (i
= 0; i
< base
->technique_count
; ++i
)
5729 free_technique(technique_handles
[i
]);
5731 HeapFree(GetProcessHeap(), 0, technique_handles
);
5734 if (parameter_handles
)
5736 for (i
= 0; i
< base
->parameter_count
; ++i
)
5738 free_parameter(parameter_handles
[i
], FALSE
, FALSE
);
5740 HeapFree(GetProcessHeap(), 0, parameter_handles
);
5743 base
->technique_handles
= NULL
;
5744 base
->parameter_handles
= NULL
;
5746 HeapFree(GetProcessHeap(), 0, objects
);
5751 static HRESULT
d3dx9_base_effect_init(struct ID3DXBaseEffectImpl
*base
,
5752 const char *data
, SIZE_T data_size
, struct ID3DXEffectImpl
*effect
)
5755 const char *ptr
= data
;
5758 TRACE("base %p, data %p, data_size %lu, effect %p\n", base
, data
, data_size
, effect
);
5760 base
->ID3DXBaseEffect_iface
.lpVtbl
= &ID3DXBaseEffect_Vtbl
;
5762 base
->effect
= effect
;
5764 read_dword(&ptr
, &tag
);
5765 TRACE("Tag: %x\n", tag
);
5767 if (tag
!= d3dx9_effect_version(9, 1))
5769 /* todo: compile hlsl ascii code */
5770 FIXME("HLSL ascii effects not supported, yet\n");
5772 /* Show the start of the shader for debugging info. */
5773 TRACE("effect:\n%s\n", debugstr_an(data
, data_size
> 40 ? 40 : data_size
));
5777 read_dword(&ptr
, &offset
);
5778 TRACE("Offset: %x\n", offset
);
5780 hr
= d3dx9_parse_effect(base
, ptr
, data_size
, offset
);
5783 FIXME("Failed to parse effect.\n");
5791 static HRESULT
d3dx9_effect_init(struct ID3DXEffectImpl
*effect
, LPDIRECT3DDEVICE9 device
,
5792 const char *data
, SIZE_T data_size
, LPD3DXEFFECTPOOL pool
)
5795 struct ID3DXBaseEffectImpl
*object
= NULL
;
5797 TRACE("effect %p, device %p, data %p, data_size %lu, pool %p\n", effect
, device
, data
, data_size
, pool
);
5799 effect
->ID3DXEffect_iface
.lpVtbl
= &ID3DXEffect_Vtbl
;
5802 if (pool
) pool
->lpVtbl
->AddRef(pool
);
5803 effect
->pool
= pool
;
5805 IDirect3DDevice9_AddRef(device
);
5806 effect
->device
= device
;
5808 object
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
, sizeof(*object
));
5811 ERR("Out of memory\n");
5816 hr
= d3dx9_base_effect_init(object
, data
, data_size
, effect
);
5819 FIXME("Failed to parse effect.\n");
5823 effect
->base_effect
= &object
->ID3DXBaseEffect_iface
;
5825 /* initialize defaults - check because of unsupported ascii effects */
5826 if (object
->technique_handles
)
5828 effect
->active_technique
= object
->technique_handles
[0];
5829 effect
->active_pass
= NULL
;
5836 HeapFree(GetProcessHeap(), 0, object
);
5837 free_effect(effect
);
5842 HRESULT WINAPI
D3DXCreateEffectEx(LPDIRECT3DDEVICE9 device
,
5845 CONST D3DXMACRO
* defines
,
5846 LPD3DXINCLUDE include
,
5847 LPCSTR skip_constants
,
5849 LPD3DXEFFECTPOOL pool
,
5850 LPD3DXEFFECT
* effect
,
5851 LPD3DXBUFFER
* compilation_errors
)
5853 struct ID3DXEffectImpl
*object
;
5856 FIXME("(%p, %p, %u, %p, %p, %p, %#x, %p, %p, %p): semi-stub\n", device
, srcdata
, srcdatalen
, defines
, include
,
5857 skip_constants
, flags
, pool
, effect
, compilation_errors
);
5859 if (!device
|| !srcdata
)
5860 return D3DERR_INVALIDCALL
;
5865 /* Native dll allows effect to be null so just return D3D_OK after doing basic checks */
5869 object
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
, sizeof(*object
));
5872 ERR("Out of memory\n");
5873 return E_OUTOFMEMORY
;
5876 hr
= d3dx9_effect_init(object
, device
, srcdata
, srcdatalen
, pool
);
5879 WARN("Failed to initialize shader reflection\n");
5880 HeapFree(GetProcessHeap(), 0, object
);
5884 *effect
= &object
->ID3DXEffect_iface
;
5886 TRACE("Created ID3DXEffect %p\n", object
);
5891 HRESULT WINAPI
D3DXCreateEffect(LPDIRECT3DDEVICE9 device
,
5894 CONST D3DXMACRO
* defines
,
5895 LPD3DXINCLUDE include
,
5897 LPD3DXEFFECTPOOL pool
,
5898 LPD3DXEFFECT
* effect
,
5899 LPD3DXBUFFER
* compilation_errors
)
5901 TRACE("(%p, %p, %u, %p, %p, %#x, %p, %p, %p): Forwarded to D3DXCreateEffectEx\n", device
, srcdata
, srcdatalen
, defines
,
5902 include
, flags
, pool
, effect
, compilation_errors
);
5904 return D3DXCreateEffectEx(device
, srcdata
, srcdatalen
, defines
, include
, NULL
, flags
, pool
, effect
, compilation_errors
);
5907 static HRESULT
d3dx9_effect_compiler_init(struct ID3DXEffectCompilerImpl
*compiler
, const char *data
, SIZE_T data_size
)
5910 struct ID3DXBaseEffectImpl
*object
= NULL
;
5912 TRACE("effect %p, data %p, data_size %lu\n", compiler
, data
, data_size
);
5914 compiler
->ID3DXEffectCompiler_iface
.lpVtbl
= &ID3DXEffectCompiler_Vtbl
;
5917 object
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
, sizeof(*object
));
5920 ERR("Out of memory\n");
5925 hr
= d3dx9_base_effect_init(object
, data
, data_size
, NULL
);
5928 FIXME("Failed to parse effect.\n");
5932 compiler
->base_effect
= &object
->ID3DXBaseEffect_iface
;
5938 HeapFree(GetProcessHeap(), 0, object
);
5939 free_effect_compiler(compiler
);
5944 HRESULT WINAPI
D3DXCreateEffectCompiler(LPCSTR srcdata
,
5946 CONST D3DXMACRO
*defines
,
5947 LPD3DXINCLUDE include
,
5949 LPD3DXEFFECTCOMPILER
*compiler
,
5950 LPD3DXBUFFER
*parse_errors
)
5952 struct ID3DXEffectCompilerImpl
*object
;
5955 TRACE("srcdata %p, srcdatalen %u, defines %p, include %p, flags %#x, compiler %p, parse_errors %p\n",
5956 srcdata
, srcdatalen
, defines
, include
, flags
, compiler
, parse_errors
);
5958 if (!srcdata
|| !compiler
)
5960 WARN("Invalid arguments supplied\n");
5961 return D3DERR_INVALIDCALL
;
5964 object
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
, sizeof(*object
));
5967 ERR("Out of memory\n");
5968 return E_OUTOFMEMORY
;
5971 hr
= d3dx9_effect_compiler_init(object
, srcdata
, srcdatalen
);
5974 WARN("Failed to initialize effect compiler\n");
5975 HeapFree(GetProcessHeap(), 0, object
);
5979 *compiler
= &object
->ID3DXEffectCompiler_iface
;
5981 TRACE("Created ID3DXEffectCompiler %p\n", object
);
5986 static const struct ID3DXEffectPoolVtbl ID3DXEffectPool_Vtbl
;
5988 struct ID3DXEffectPoolImpl
5990 ID3DXEffectPool ID3DXEffectPool_iface
;
5994 static inline struct ID3DXEffectPoolImpl
*impl_from_ID3DXEffectPool(ID3DXEffectPool
*iface
)
5996 return CONTAINING_RECORD(iface
, struct ID3DXEffectPoolImpl
, ID3DXEffectPool_iface
);
5999 /*** IUnknown methods ***/
6000 static HRESULT WINAPI
ID3DXEffectPoolImpl_QueryInterface(ID3DXEffectPool
*iface
, REFIID riid
, void **object
)
6002 TRACE("(%p)->(%s, %p)\n", iface
, debugstr_guid(riid
), object
);
6004 if (IsEqualGUID(riid
, &IID_IUnknown
) ||
6005 IsEqualGUID(riid
, &IID_ID3DXEffectPool
))
6007 iface
->lpVtbl
->AddRef(iface
);
6012 WARN("Interface %s not found\n", debugstr_guid(riid
));
6014 return E_NOINTERFACE
;
6017 static ULONG WINAPI
ID3DXEffectPoolImpl_AddRef(ID3DXEffectPool
*iface
)
6019 struct ID3DXEffectPoolImpl
*This
= impl_from_ID3DXEffectPool(iface
);
6021 TRACE("(%p)->(): AddRef from %u\n", This
, This
->ref
);
6023 return InterlockedIncrement(&This
->ref
);
6026 static ULONG WINAPI
ID3DXEffectPoolImpl_Release(ID3DXEffectPool
*iface
)
6028 struct ID3DXEffectPoolImpl
*This
= impl_from_ID3DXEffectPool(iface
);
6029 ULONG ref
= InterlockedDecrement(&This
->ref
);
6031 TRACE("(%p)->(): Release from %u\n", This
, ref
+ 1);
6034 HeapFree(GetProcessHeap(), 0, This
);
6039 static const struct ID3DXEffectPoolVtbl ID3DXEffectPool_Vtbl
=
6041 /*** IUnknown methods ***/
6042 ID3DXEffectPoolImpl_QueryInterface
,
6043 ID3DXEffectPoolImpl_AddRef
,
6044 ID3DXEffectPoolImpl_Release
6047 HRESULT WINAPI
D3DXCreateEffectPool(LPD3DXEFFECTPOOL
*pool
)
6049 struct ID3DXEffectPoolImpl
*object
;
6051 TRACE("(%p)\n", pool
);
6054 return D3DERR_INVALIDCALL
;
6056 object
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
, sizeof(*object
));
6059 ERR("Out of memory\n");
6060 return E_OUTOFMEMORY
;
6063 object
->ID3DXEffectPool_iface
.lpVtbl
= &ID3DXEffectPool_Vtbl
;
6066 *pool
= &object
->ID3DXEffectPool_iface
;
6071 HRESULT WINAPI
D3DXCreateEffectFromFileExW(LPDIRECT3DDEVICE9 device
, LPCWSTR srcfile
,
6072 const D3DXMACRO
*defines
, LPD3DXINCLUDE include
, LPCSTR skipconstants
, DWORD flags
,
6073 LPD3DXEFFECTPOOL pool
, LPD3DXEFFECT
*effect
, LPD3DXBUFFER
*compilationerrors
)
6079 TRACE("(%s): relay\n", debugstr_w(srcfile
));
6081 if (!device
|| !srcfile
)
6082 return D3DERR_INVALIDCALL
;
6084 ret
= map_view_of_file(srcfile
, &buffer
, &size
);
6087 return D3DXERR_INVALIDDATA
;
6089 ret
= D3DXCreateEffectEx(device
, buffer
, size
, defines
, include
, skipconstants
, flags
, pool
, effect
, compilationerrors
);
6090 UnmapViewOfFile(buffer
);
6095 HRESULT WINAPI
D3DXCreateEffectFromFileExA(LPDIRECT3DDEVICE9 device
, LPCSTR srcfile
,
6096 const D3DXMACRO
*defines
, LPD3DXINCLUDE include
, LPCSTR skipconstants
, DWORD flags
,
6097 LPD3DXEFFECTPOOL pool
, LPD3DXEFFECT
*effect
, LPD3DXBUFFER
*compilationerrors
)
6103 TRACE("(void): relay\n");
6106 return D3DERR_INVALIDCALL
;
6108 len
= MultiByteToWideChar(CP_ACP
, 0, srcfile
, -1, NULL
, 0);
6109 srcfileW
= HeapAlloc(GetProcessHeap(), 0, len
* sizeof(*srcfileW
));
6110 MultiByteToWideChar(CP_ACP
, 0, srcfile
, -1, srcfileW
, len
);
6112 ret
= D3DXCreateEffectFromFileExW(device
, srcfileW
, defines
, include
, skipconstants
, flags
, pool
, effect
, compilationerrors
);
6113 HeapFree(GetProcessHeap(), 0, srcfileW
);
6118 HRESULT WINAPI
D3DXCreateEffectFromFileW(LPDIRECT3DDEVICE9 device
, LPCWSTR srcfile
,
6119 const D3DXMACRO
*defines
, LPD3DXINCLUDE include
, DWORD flags
, LPD3DXEFFECTPOOL pool
,
6120 LPD3DXEFFECT
*effect
, LPD3DXBUFFER
*compilationerrors
)
6122 TRACE("(void): relay\n");
6123 return D3DXCreateEffectFromFileExW(device
, srcfile
, defines
, include
, NULL
, flags
, pool
, effect
, compilationerrors
);
6126 HRESULT WINAPI
D3DXCreateEffectFromFileA(LPDIRECT3DDEVICE9 device
, LPCSTR srcfile
,
6127 const D3DXMACRO
*defines
, LPD3DXINCLUDE include
, DWORD flags
, LPD3DXEFFECTPOOL pool
,
6128 LPD3DXEFFECT
*effect
, LPD3DXBUFFER
*compilationerrors
)
6130 TRACE("(void): relay\n");
6131 return D3DXCreateEffectFromFileExA(device
, srcfile
, defines
, include
, NULL
, flags
, pool
, effect
, compilationerrors
);
6134 HRESULT WINAPI
D3DXCreateEffectFromResourceExW(LPDIRECT3DDEVICE9 device
, HMODULE srcmodule
, LPCWSTR srcresource
,
6135 const D3DXMACRO
*defines
, LPD3DXINCLUDE include
, LPCSTR skipconstants
, DWORD flags
,
6136 LPD3DXEFFECTPOOL pool
, LPD3DXEFFECT
*effect
, LPD3DXBUFFER
*compilationerrors
)
6140 TRACE("(%p, %s): relay\n", srcmodule
, debugstr_w(srcresource
));
6143 return D3DERR_INVALIDCALL
;
6145 resinfo
= FindResourceW(srcmodule
, srcresource
, (LPCWSTR
) RT_RCDATA
);
6153 ret
= load_resource_into_memory(srcmodule
, resinfo
, &buffer
, &size
);
6156 return D3DXERR_INVALIDDATA
;
6158 return D3DXCreateEffectEx(device
, buffer
, size
, defines
, include
, skipconstants
, flags
, pool
, effect
, compilationerrors
);
6161 return D3DXERR_INVALIDDATA
;
6164 HRESULT WINAPI
D3DXCreateEffectFromResourceExA(LPDIRECT3DDEVICE9 device
, HMODULE srcmodule
, LPCSTR srcresource
,
6165 const D3DXMACRO
*defines
, LPD3DXINCLUDE include
, LPCSTR skipconstants
, DWORD flags
,
6166 LPD3DXEFFECTPOOL pool
, LPD3DXEFFECT
*effect
, LPD3DXBUFFER
*compilationerrors
)
6170 TRACE("(%p, %s): relay\n", srcmodule
, debugstr_a(srcresource
));
6173 return D3DERR_INVALIDCALL
;
6175 resinfo
= FindResourceA(srcmodule
, srcresource
, (LPCSTR
) RT_RCDATA
);
6183 ret
= load_resource_into_memory(srcmodule
, resinfo
, &buffer
, &size
);
6186 return D3DXERR_INVALIDDATA
;
6188 return D3DXCreateEffectEx(device
, buffer
, size
, defines
, include
, skipconstants
, flags
, pool
, effect
, compilationerrors
);
6191 return D3DXERR_INVALIDDATA
;
6194 HRESULT WINAPI
D3DXCreateEffectFromResourceW(LPDIRECT3DDEVICE9 device
, HMODULE srcmodule
, LPCWSTR srcresource
,
6195 const D3DXMACRO
*defines
, LPD3DXINCLUDE include
, DWORD flags
, LPD3DXEFFECTPOOL pool
,
6196 LPD3DXEFFECT
*effect
, LPD3DXBUFFER
*compilationerrors
)
6198 TRACE("(void): relay\n");
6199 return D3DXCreateEffectFromResourceExW(device
, srcmodule
, srcresource
, defines
, include
, NULL
, flags
, pool
, effect
, compilationerrors
);
6202 HRESULT WINAPI
D3DXCreateEffectFromResourceA(LPDIRECT3DDEVICE9 device
, HMODULE srcmodule
, LPCSTR srcresource
,
6203 const D3DXMACRO
*defines
, LPD3DXINCLUDE include
, DWORD flags
, LPD3DXEFFECTPOOL pool
,
6204 LPD3DXEFFECT
*effect
, LPD3DXBUFFER
*compilationerrors
)
6206 TRACE("(void): relay\n");
6207 return D3DXCreateEffectFromResourceExA(device
, srcmodule
, srcresource
, defines
, include
, NULL
, flags
, pool
, effect
, compilationerrors
);
6210 HRESULT WINAPI
D3DXCreateEffectCompilerFromFileW(LPCWSTR srcfile
, const D3DXMACRO
*defines
, LPD3DXINCLUDE include
,
6211 DWORD flags
, LPD3DXEFFECTCOMPILER
*effectcompiler
, LPD3DXBUFFER
*parseerrors
)
6217 TRACE("(%s): relay\n", debugstr_w(srcfile
));
6220 return D3DERR_INVALIDCALL
;
6222 ret
= map_view_of_file(srcfile
, &buffer
, &size
);
6225 return D3DXERR_INVALIDDATA
;
6227 ret
= D3DXCreateEffectCompiler(buffer
, size
, defines
, include
, flags
, effectcompiler
, parseerrors
);
6228 UnmapViewOfFile(buffer
);
6233 HRESULT WINAPI
D3DXCreateEffectCompilerFromFileA(LPCSTR srcfile
, const D3DXMACRO
*defines
, LPD3DXINCLUDE include
,
6234 DWORD flags
, LPD3DXEFFECTCOMPILER
*effectcompiler
, LPD3DXBUFFER
*parseerrors
)
6240 TRACE("(void): relay\n");
6243 return D3DERR_INVALIDCALL
;
6245 len
= MultiByteToWideChar(CP_ACP
, 0, srcfile
, -1, NULL
, 0);
6246 srcfileW
= HeapAlloc(GetProcessHeap(), 0, len
* sizeof(*srcfileW
));
6247 MultiByteToWideChar(CP_ACP
, 0, srcfile
, -1, srcfileW
, len
);
6249 ret
= D3DXCreateEffectCompilerFromFileW(srcfileW
, defines
, include
, flags
, effectcompiler
, parseerrors
);
6250 HeapFree(GetProcessHeap(), 0, srcfileW
);
6255 HRESULT WINAPI
D3DXCreateEffectCompilerFromResourceA(HMODULE srcmodule
, LPCSTR srcresource
, const D3DXMACRO
*defines
,
6256 LPD3DXINCLUDE include
, DWORD flags
, LPD3DXEFFECTCOMPILER
*effectcompiler
, LPD3DXBUFFER
*parseerrors
)
6260 TRACE("(%p, %s): relay\n", srcmodule
, debugstr_a(srcresource
));
6262 resinfo
= FindResourceA(srcmodule
, srcresource
, (LPCSTR
) RT_RCDATA
);
6270 ret
= load_resource_into_memory(srcmodule
, resinfo
, &buffer
, &size
);
6273 return D3DXERR_INVALIDDATA
;
6275 return D3DXCreateEffectCompiler(buffer
, size
, defines
, include
, flags
, effectcompiler
, parseerrors
);
6278 return D3DXERR_INVALIDDATA
;
6281 HRESULT WINAPI
D3DXCreateEffectCompilerFromResourceW(HMODULE srcmodule
, LPCWSTR srcresource
, const D3DXMACRO
*defines
,
6282 LPD3DXINCLUDE include
, DWORD flags
, LPD3DXEFFECTCOMPILER
*effectcompiler
, LPD3DXBUFFER
*parseerrors
)
6286 TRACE("(%p, %s): relay\n", srcmodule
, debugstr_w(srcresource
));
6288 resinfo
= FindResourceW(srcmodule
, srcresource
, (LPCWSTR
) RT_RCDATA
);
6296 ret
= load_resource_into_memory(srcmodule
, resinfo
, &buffer
, &size
);
6299 return D3DXERR_INVALIDDATA
;
6301 return D3DXCreateEffectCompiler(buffer
, size
, defines
, include
, flags
, effectcompiler
, parseerrors
);
6304 return D3DXERR_INVALIDDATA
;