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
20 #include "d3dx9_36_private.h"
22 #include <d3dcompiler.h>
24 /* Constants for special INT/FLOAT conversation */
25 #define INT_FLOAT_MULTI 255.0f
26 #define INT_FLOAT_MULTI_INVERSE (1/INT_FLOAT_MULTI)
28 #define INITIAL_PARAM_TABLE_SIZE 16
75 enum SHADER_CONSTANT_TYPE
98 D3DXPARAMETER_CLASS
class;
99 D3DXPARAMETER_TYPE type
;
103 UINT annotation_count
;
111 struct d3dx_parameter
*annotations
;
112 struct d3dx_parameter
*members
;
114 struct d3dx_parameter
*referenced_param
;
121 struct d3dx_parameter
*param
;
128 enum STATE_TYPE type
;
129 struct d3dx_parameter parameter
;
135 struct d3dx_state
*states
;
142 UINT annotation_count
;
144 struct d3dx_state
*states
;
145 struct d3dx_parameter
*annotations
;
148 struct d3dx_technique
152 UINT annotation_count
;
154 struct d3dx_parameter
*annotations
;
155 struct d3dx_pass
*passes
;
160 struct d3dx_parameter
**table
;
161 unsigned int count
, size
;
164 struct d3dx9_base_effect
166 struct ID3DXEffectImpl
*effect
;
168 UINT parameter_count
;
169 UINT technique_count
;
172 struct d3dx_parameter
*parameters
;
173 struct d3dx_technique
*techniques
;
174 struct d3dx_object
*objects
;
176 struct param_table param_table
;
179 struct ID3DXEffectImpl
181 ID3DXEffect ID3DXEffect_iface
;
184 struct d3dx9_base_effect base_effect
;
186 struct ID3DXEffectStateManager
*manager
;
187 struct IDirect3DDevice9
*device
;
188 struct ID3DXEffectPool
*pool
;
189 struct d3dx_technique
*active_technique
;
190 struct d3dx_pass
*active_pass
;
195 struct ID3DXEffectCompilerImpl
197 ID3DXEffectCompiler ID3DXEffectCompiler_iface
;
200 struct d3dx9_base_effect base_effect
;
203 static struct d3dx_parameter
*get_parameter_by_name(struct d3dx9_base_effect
*base
,
204 struct d3dx_parameter
*parameter
, const char *name
);
205 static struct d3dx_parameter
*get_annotation_by_name(UINT count
, struct d3dx_parameter
*parameters
,
207 static HRESULT
d3dx9_parse_state(struct d3dx9_base_effect
*base
, struct d3dx_state
*state
,
208 const char *data
, const char **ptr
, struct d3dx_object
*objects
);
209 static void free_parameter(struct d3dx_parameter
*param
, BOOL element
, BOOL child
);
213 enum STATE_CLASS
class;
220 {SC_RENDERSTATE
, D3DRS_ZENABLE
, "D3DRS_ZENABLE"}, /* 0x0 */
221 {SC_RENDERSTATE
, D3DRS_FILLMODE
, "D3DRS_FILLMODE"},
222 {SC_RENDERSTATE
, D3DRS_SHADEMODE
, "D3DRS_SHADEMODE"},
223 {SC_RENDERSTATE
, D3DRS_ZWRITEENABLE
, "D3DRS_ZWRITEENABLE"},
224 {SC_RENDERSTATE
, D3DRS_ALPHATESTENABLE
, "D3DRS_ALPHATESTENABLE"},
225 {SC_RENDERSTATE
, D3DRS_LASTPIXEL
, "D3DRS_LASTPIXEL"},
226 {SC_RENDERSTATE
, D3DRS_SRCBLEND
, "D3DRS_SRCBLEND"},
227 {SC_RENDERSTATE
, D3DRS_DESTBLEND
, "D3DRS_DESTBLEND"},
228 {SC_RENDERSTATE
, D3DRS_CULLMODE
, "D3DRS_CULLMODE"},
229 {SC_RENDERSTATE
, D3DRS_ZFUNC
, "D3DRS_ZFUNC"},
230 {SC_RENDERSTATE
, D3DRS_ALPHAREF
, "D3DRS_ALPHAREF"},
231 {SC_RENDERSTATE
, D3DRS_ALPHAFUNC
, "D3DRS_ALPHAFUNC"},
232 {SC_RENDERSTATE
, D3DRS_DITHERENABLE
, "D3DRS_DITHERENABLE"},
233 {SC_RENDERSTATE
, D3DRS_ALPHABLENDENABLE
, "D3DRS_ALPHABLENDENABLE"},
234 {SC_RENDERSTATE
, D3DRS_FOGENABLE
, "D3DRS_FOGENABLE"},
235 {SC_RENDERSTATE
, D3DRS_SPECULARENABLE
, "D3DRS_SPECULARENABLE"},
236 {SC_RENDERSTATE
, D3DRS_FOGCOLOR
, "D3DRS_FOGCOLOR"}, /* 0x10 */
237 {SC_RENDERSTATE
, D3DRS_FOGTABLEMODE
, "D3DRS_FOGTABLEMODE"},
238 {SC_RENDERSTATE
, D3DRS_FOGSTART
, "D3DRS_FOGSTART"},
239 {SC_RENDERSTATE
, D3DRS_FOGEND
, "D3DRS_FOGEND"},
240 {SC_RENDERSTATE
, D3DRS_FOGDENSITY
, "D3DRS_FOGDENSITY"},
241 {SC_RENDERSTATE
, D3DRS_RANGEFOGENABLE
, "D3DRS_RANGEFOGENABLE"},
242 {SC_RENDERSTATE
, D3DRS_STENCILENABLE
, "D3DRS_STENCILENABLE"},
243 {SC_RENDERSTATE
, D3DRS_STENCILFAIL
, "D3DRS_STENCILFAIL"},
244 {SC_RENDERSTATE
, D3DRS_STENCILZFAIL
, "D3DRS_STENCILZFAIL"},
245 {SC_RENDERSTATE
, D3DRS_STENCILPASS
, "D3DRS_STENCILPASS"},
246 {SC_RENDERSTATE
, D3DRS_STENCILFUNC
, "D3DRS_STENCILFUNC"},
247 {SC_RENDERSTATE
, D3DRS_STENCILREF
, "D3DRS_STENCILREF"},
248 {SC_RENDERSTATE
, D3DRS_STENCILMASK
, "D3DRS_STENCILMASK"},
249 {SC_RENDERSTATE
, D3DRS_STENCILWRITEMASK
, "D3DRS_STENCILWRITEMASK"},
250 {SC_RENDERSTATE
, D3DRS_TEXTUREFACTOR
, "D3DRS_TEXTUREFACTOR"},
251 {SC_RENDERSTATE
, D3DRS_WRAP0
, "D3DRS_WRAP0"},
252 {SC_RENDERSTATE
, D3DRS_WRAP1
, "D3DRS_WRAP1"}, /* 0x20 */
253 {SC_RENDERSTATE
, D3DRS_WRAP2
, "D3DRS_WRAP2"},
254 {SC_RENDERSTATE
, D3DRS_WRAP3
, "D3DRS_WRAP3"},
255 {SC_RENDERSTATE
, D3DRS_WRAP4
, "D3DRS_WRAP4"},
256 {SC_RENDERSTATE
, D3DRS_WRAP5
, "D3DRS_WRAP5"},
257 {SC_RENDERSTATE
, D3DRS_WRAP6
, "D3DRS_WRAP6"},
258 {SC_RENDERSTATE
, D3DRS_WRAP7
, "D3DRS_WRAP7"},
259 {SC_RENDERSTATE
, D3DRS_WRAP8
, "D3DRS_WRAP8"},
260 {SC_RENDERSTATE
, D3DRS_WRAP9
, "D3DRS_WRAP9"},
261 {SC_RENDERSTATE
, D3DRS_WRAP10
, "D3DRS_WRAP10"},
262 {SC_RENDERSTATE
, D3DRS_WRAP11
, "D3DRS_WRAP11"},
263 {SC_RENDERSTATE
, D3DRS_WRAP12
, "D3DRS_WRAP12"},
264 {SC_RENDERSTATE
, D3DRS_WRAP13
, "D3DRS_WRAP13"},
265 {SC_RENDERSTATE
, D3DRS_WRAP14
, "D3DRS_WRAP14"},
266 {SC_RENDERSTATE
, D3DRS_WRAP15
, "D3DRS_WRAP15"},
267 {SC_RENDERSTATE
, D3DRS_CLIPPING
, "D3DRS_CLIPPING"},
268 {SC_RENDERSTATE
, D3DRS_LIGHTING
, "D3DRS_LIGHTING"}, /* 0x30 */
269 {SC_RENDERSTATE
, D3DRS_AMBIENT
, "D3DRS_AMBIENT"},
270 {SC_RENDERSTATE
, D3DRS_FOGVERTEXMODE
, "D3DRS_FOGVERTEXMODE"},
271 {SC_RENDERSTATE
, D3DRS_COLORVERTEX
, "D3DRS_COLORVERTEX"},
272 {SC_RENDERSTATE
, D3DRS_LOCALVIEWER
, "D3DRS_LOCALVIEWER"},
273 {SC_RENDERSTATE
, D3DRS_NORMALIZENORMALS
, "D3DRS_NORMALIZENORMALS"},
274 {SC_RENDERSTATE
, D3DRS_DIFFUSEMATERIALSOURCE
, "D3DRS_DIFFUSEMATERIALSOURCE"},
275 {SC_RENDERSTATE
, D3DRS_SPECULARMATERIALSOURCE
, "D3DRS_SPECULARMATERIALSOURCE"},
276 {SC_RENDERSTATE
, D3DRS_AMBIENTMATERIALSOURCE
, "D3DRS_AMBIENTMATERIALSOURCE"},
277 {SC_RENDERSTATE
, D3DRS_EMISSIVEMATERIALSOURCE
, "D3DRS_EMISSIVEMATERIALSOURCE"},
278 {SC_RENDERSTATE
, D3DRS_VERTEXBLEND
, "D3DRS_VERTEXBLEND"},
279 {SC_RENDERSTATE
, D3DRS_CLIPPLANEENABLE
, "D3DRS_CLIPPLANEENABLE"},
280 {SC_RENDERSTATE
, D3DRS_POINTSIZE
, "D3DRS_POINTSIZE"},
281 {SC_RENDERSTATE
, D3DRS_POINTSIZE_MIN
, "D3DRS_POINTSIZE_MIN"},
282 {SC_RENDERSTATE
, D3DRS_POINTSIZE_MAX
, "D3DRS_POINTSIZE_MAX"},
283 {SC_RENDERSTATE
, D3DRS_POINTSPRITEENABLE
, "D3DRS_POINTSPRITEENABLE"},
284 {SC_RENDERSTATE
, D3DRS_POINTSCALEENABLE
, "D3DRS_POINTSCALEENABLE"}, /* 0x40 */
285 {SC_RENDERSTATE
, D3DRS_POINTSCALE_A
, "D3DRS_POINTSCALE_A"},
286 {SC_RENDERSTATE
, D3DRS_POINTSCALE_B
, "D3DRS_POINTSCALE_B"},
287 {SC_RENDERSTATE
, D3DRS_POINTSCALE_C
, "D3DRS_POINTSCALE_C"},
288 {SC_RENDERSTATE
, D3DRS_MULTISAMPLEANTIALIAS
, "D3DRS_MULTISAMPLEANTIALIAS"},
289 {SC_RENDERSTATE
, D3DRS_MULTISAMPLEMASK
, "D3DRS_MULTISAMPLEMASK"},
290 {SC_RENDERSTATE
, D3DRS_PATCHEDGESTYLE
, "D3DRS_PATCHEDGESTYLE"},
291 {SC_RENDERSTATE
, D3DRS_DEBUGMONITORTOKEN
, "D3DRS_DEBUGMONITORTOKEN"},
292 {SC_RENDERSTATE
, D3DRS_INDEXEDVERTEXBLENDENABLE
, "D3DRS_INDEXEDVERTEXBLENDENABLE"},
293 {SC_RENDERSTATE
, D3DRS_COLORWRITEENABLE
, "D3DRS_COLORWRITEENABLE"},
294 {SC_RENDERSTATE
, D3DRS_TWEENFACTOR
, "D3DRS_TWEENFACTOR"},
295 {SC_RENDERSTATE
, D3DRS_BLENDOP
, "D3DRS_BLENDOP"},
296 {SC_RENDERSTATE
, D3DRS_POSITIONDEGREE
, "D3DRS_POSITIONDEGREE"},
297 {SC_RENDERSTATE
, D3DRS_NORMALDEGREE
, "D3DRS_NORMALDEGREE"},
298 {SC_RENDERSTATE
, D3DRS_SCISSORTESTENABLE
, "D3DRS_SCISSORTESTENABLE"},
299 {SC_RENDERSTATE
, D3DRS_SLOPESCALEDEPTHBIAS
, "D3DRS_SLOPESCALEDEPTHBIAS"},
300 {SC_RENDERSTATE
, D3DRS_ANTIALIASEDLINEENABLE
, "D3DRS_ANTIALIASEDLINEENABLE"}, /* 0x50 */
301 {SC_RENDERSTATE
, D3DRS_MINTESSELLATIONLEVEL
, "D3DRS_MINTESSELLATIONLEVEL"},
302 {SC_RENDERSTATE
, D3DRS_MAXTESSELLATIONLEVEL
, "D3DRS_MAXTESSELLATIONLEVEL"},
303 {SC_RENDERSTATE
, D3DRS_ADAPTIVETESS_X
, "D3DRS_ADAPTIVETESS_X"},
304 {SC_RENDERSTATE
, D3DRS_ADAPTIVETESS_Y
, "D3DRS_ADAPTIVETESS_Y"},
305 {SC_RENDERSTATE
, D3DRS_ADAPTIVETESS_Z
, "D3DRS_ADAPTIVETESS_Z"},
306 {SC_RENDERSTATE
, D3DRS_ADAPTIVETESS_W
, "D3DRS_ADAPTIVETESS_W"},
307 {SC_RENDERSTATE
, D3DRS_ENABLEADAPTIVETESSELLATION
, "D3DRS_ENABLEADAPTIVETESSELLATION"},
308 {SC_RENDERSTATE
, D3DRS_TWOSIDEDSTENCILMODE
, "D3DRS_TWOSIDEDSTENCILMODE"},
309 {SC_RENDERSTATE
, D3DRS_CCW_STENCILFAIL
, "D3DRS_CCW_STENCILFAIL"},
310 {SC_RENDERSTATE
, D3DRS_CCW_STENCILZFAIL
, "D3DRS_CCW_STENCILZFAIL"},
311 {SC_RENDERSTATE
, D3DRS_CCW_STENCILPASS
, "D3DRS_CCW_STENCILPASS"},
312 {SC_RENDERSTATE
, D3DRS_CCW_STENCILFUNC
, "D3DRS_CCW_STENCILFUNC"},
313 {SC_RENDERSTATE
, D3DRS_COLORWRITEENABLE1
, "D3DRS_COLORWRITEENABLE1"},
314 {SC_RENDERSTATE
, D3DRS_COLORWRITEENABLE2
, "D3DRS_COLORWRITEENABLE2"},
315 {SC_RENDERSTATE
, D3DRS_COLORWRITEENABLE3
, "D3DRS_COLORWRITEENABLE3"},
316 {SC_RENDERSTATE
, D3DRS_BLENDFACTOR
, "D3DRS_BLENDFACTOR"}, /* 0x60 */
317 {SC_RENDERSTATE
, D3DRS_SRGBWRITEENABLE
, "D3DRS_SRGBWRITEENABLE"},
318 {SC_RENDERSTATE
, D3DRS_DEPTHBIAS
, "D3DRS_DEPTHBIAS"},
319 {SC_RENDERSTATE
, D3DRS_SEPARATEALPHABLENDENABLE
, "D3DRS_SEPARATEALPHABLENDENABLE"},
320 {SC_RENDERSTATE
, D3DRS_SRCBLENDALPHA
, "D3DRS_SRCBLENDALPHA"},
321 {SC_RENDERSTATE
, D3DRS_DESTBLENDALPHA
, "D3DRS_DESTBLENDALPHA"},
322 {SC_RENDERSTATE
, D3DRS_BLENDOPALPHA
, "D3DRS_BLENDOPALPHA"},
324 {SC_TEXTURESTAGE
, D3DTSS_COLOROP
, "D3DTSS_COLOROP"},
325 {SC_TEXTURESTAGE
, D3DTSS_COLORARG0
, "D3DTSS_COLORARG0"},
326 {SC_TEXTURESTAGE
, D3DTSS_COLORARG1
, "D3DTSS_COLORARG1"},
327 {SC_TEXTURESTAGE
, D3DTSS_COLORARG2
, "D3DTSS_COLORARG2"},
328 {SC_TEXTURESTAGE
, D3DTSS_ALPHAOP
, "D3DTSS_ALPHAOP"},
329 {SC_TEXTURESTAGE
, D3DTSS_ALPHAARG0
, "D3DTSS_ALPHAARG0"},
330 {SC_TEXTURESTAGE
, D3DTSS_ALPHAARG1
, "D3DTSS_ALPHAARG1"},
331 {SC_TEXTURESTAGE
, D3DTSS_ALPHAARG2
, "D3DTSS_ALPHAARG2"},
332 {SC_TEXTURESTAGE
, D3DTSS_RESULTARG
, "D3DTSS_RESULTARG"},
333 {SC_TEXTURESTAGE
, D3DTSS_BUMPENVMAT00
, "D3DTSS_BUMPENVMAT00"}, /* 0x70 */
334 {SC_TEXTURESTAGE
, D3DTSS_BUMPENVMAT01
, "D3DTSS_BUMPENVMAT01"},
335 {SC_TEXTURESTAGE
, D3DTSS_BUMPENVMAT10
, "D3DTSS_BUMPENVMAT10"},
336 {SC_TEXTURESTAGE
, D3DTSS_BUMPENVMAT11
, "D3DTSS_BUMPENVMAT11"},
337 {SC_TEXTURESTAGE
, D3DTSS_TEXCOORDINDEX
, "D3DTSS_TEXCOORDINDEX"},
338 {SC_TEXTURESTAGE
, D3DTSS_BUMPENVLSCALE
, "D3DTSS_BUMPENVLSCALE"},
339 {SC_TEXTURESTAGE
, D3DTSS_BUMPENVLOFFSET
, "D3DTSS_BUMPENVLOFFSET"},
340 {SC_TEXTURESTAGE
, D3DTSS_TEXTURETRANSFORMFLAGS
, "D3DTSS_TEXTURETRANSFORMFLAGS"},
341 {SC_TEXTURESTAGE
, D3DTSS_CONSTANT
, "D3DTSS_CONSTANT"},
343 {SC_NPATCHMODE
, 0, "NPatchMode"},
347 {SC_TRANSFORM
, D3DTS_PROJECTION
, "D3DTS_PROJECTION"},
348 {SC_TRANSFORM
, D3DTS_VIEW
, "D3DTS_VIEW"},
349 {SC_TRANSFORM
, D3DTS_WORLD
, "D3DTS_WORLD"},
350 {SC_TRANSFORM
, D3DTS_TEXTURE0
, "D3DTS_TEXTURE0"},
352 {SC_MATERIAL
, MT_DIFFUSE
, "MaterialDiffuse"},
353 {SC_MATERIAL
, MT_AMBIENT
, "MaterialAmbient"}, /* 0x80 */
354 {SC_MATERIAL
, MT_SPECULAR
, "MaterialSpecular"},
355 {SC_MATERIAL
, MT_EMISSIVE
, "MaterialEmissive"},
356 {SC_MATERIAL
, MT_POWER
, "MaterialPower"},
358 {SC_LIGHT
, LT_TYPE
, "LightType"},
359 {SC_LIGHT
, LT_DIFFUSE
, "LightDiffuse"},
360 {SC_LIGHT
, LT_SPECULAR
, "LightSpecular"},
361 {SC_LIGHT
, LT_AMBIENT
, "LightAmbient"},
362 {SC_LIGHT
, LT_POSITION
, "LightPosition"},
363 {SC_LIGHT
, LT_DIRECTION
, "LightDirection"},
364 {SC_LIGHT
, LT_RANGE
, "LightRange"},
365 {SC_LIGHT
, LT_FALLOFF
, "LightFallOff"},
366 {SC_LIGHT
, LT_ATTENUATION0
, "LightAttenuation0"},
367 {SC_LIGHT
, LT_ATTENUATION1
, "LightAttenuation1"},
368 {SC_LIGHT
, LT_ATTENUATION2
, "LightAttenuation2"},
369 {SC_LIGHT
, LT_THETA
, "LightTheta"},
370 {SC_LIGHT
, LT_PHI
, "LightPhi"}, /* 0x90 */
372 {SC_LIGHTENABLE
, 0, "LightEnable"},
374 {SC_VERTEXSHADER
, 0, "Vertexshader"},
376 {SC_PIXELSHADER
, 0, "Pixelshader"},
377 /* Shader constants */
378 {SC_SHADERCONST
, SCT_VSFLOAT
, "VertexShaderConstantF"},
379 {SC_SHADERCONST
, SCT_VSBOOL
, "VertexShaderConstantB"},
380 {SC_SHADERCONST
, SCT_VSINT
, "VertexShaderConstantI"},
381 {SC_SHADERCONST
, SCT_VSFLOAT
, "VertexShaderConstant"},
382 {SC_SHADERCONST
, SCT_VSFLOAT
, "VertexShaderConstant1"},
383 {SC_SHADERCONST
, SCT_VSFLOAT
, "VertexShaderConstant2"},
384 {SC_SHADERCONST
, SCT_VSFLOAT
, "VertexShaderConstant3"},
385 {SC_SHADERCONST
, SCT_VSFLOAT
, "VertexShaderConstant4"},
386 {SC_SHADERCONST
, SCT_PSFLOAT
, "PixelShaderConstantF"},
387 {SC_SHADERCONST
, SCT_PSBOOL
, "PixelShaderConstantB"},
388 {SC_SHADERCONST
, SCT_PSINT
, "PixelShaderConstantI"},
389 {SC_SHADERCONST
, SCT_PSFLOAT
, "PixelShaderConstant"},
390 {SC_SHADERCONST
, SCT_PSFLOAT
, "PixelShaderConstant1"}, /* 0xa0 */
391 {SC_SHADERCONST
, SCT_PSFLOAT
, "PixelShaderConstant2"},
392 {SC_SHADERCONST
, SCT_PSFLOAT
, "PixelShaderConstant3"},
393 {SC_SHADERCONST
, SCT_PSFLOAT
, "PixelShaderConstant4"},
395 {SC_TEXTURE
, 0, "Texture"},
397 {SC_SAMPLERSTATE
, D3DSAMP_ADDRESSU
, "AddressU"},
398 {SC_SAMPLERSTATE
, D3DSAMP_ADDRESSV
, "AddressV"},
399 {SC_SAMPLERSTATE
, D3DSAMP_ADDRESSW
, "AddressW"},
400 {SC_SAMPLERSTATE
, D3DSAMP_BORDERCOLOR
, "BorderColor"},
401 {SC_SAMPLERSTATE
, D3DSAMP_MAGFILTER
, "MagFilter"},
402 {SC_SAMPLERSTATE
, D3DSAMP_MINFILTER
, "MinFilter"},
403 {SC_SAMPLERSTATE
, D3DSAMP_MIPFILTER
, "MipFilter"},
404 {SC_SAMPLERSTATE
, D3DSAMP_MIPMAPLODBIAS
, "MipMapLodBias"},
405 {SC_SAMPLERSTATE
, D3DSAMP_MAXMIPLEVEL
, "MaxMipLevel"},
406 {SC_SAMPLERSTATE
, D3DSAMP_MAXANISOTROPY
, "MaxAnisotropy"},
407 {SC_SAMPLERSTATE
, D3DSAMP_SRGBTEXTURE
, "SRGBTexture"},
408 {SC_SAMPLERSTATE
, D3DSAMP_ELEMENTINDEX
, "ElementIndex"}, /* 0xb0 */
409 {SC_SAMPLERSTATE
, D3DSAMP_DMAPOFFSET
, "DMAPOffset"},
411 {SC_SETSAMPLER
, 0, "Sampler"},
414 static inline void read_dword(const char **ptr
, DWORD
*d
)
416 memcpy(d
, *ptr
, sizeof(*d
));
420 static void skip_dword_unknown(const char **ptr
, unsigned int count
)
425 FIXME("Skipping %u unknown DWORDs:\n", count
);
426 for (i
= 0; i
< count
; ++i
)
429 FIXME("\t0x%08x\n", d
);
433 static inline D3DXHANDLE
get_parameter_handle(struct d3dx_parameter
*parameter
)
435 return parameter
? parameter
->handle
: NULL
;
438 static inline D3DXHANDLE
get_technique_handle(struct d3dx_technique
*technique
)
440 return (D3DXHANDLE
) technique
;
443 static inline D3DXHANDLE
get_pass_handle(struct d3dx_pass
*pass
)
445 return (D3DXHANDLE
) pass
;
448 static struct d3dx_technique
*get_technique_by_name(struct d3dx9_base_effect
*base
, const char *name
)
452 if (!name
) return NULL
;
454 for (i
= 0; i
< base
->technique_count
; ++i
)
456 if (!strcmp(base
->techniques
[i
].name
, name
))
457 return &base
->techniques
[i
];
463 static struct d3dx_technique
*get_valid_technique(struct d3dx9_base_effect
*base
, D3DXHANDLE technique
)
467 for (i
= 0; i
< base
->technique_count
; ++i
)
469 if (get_technique_handle(&base
->techniques
[i
]) == technique
)
470 return &base
->techniques
[i
];
473 return get_technique_by_name(base
, technique
);
476 static struct d3dx_pass
*get_valid_pass(struct d3dx9_base_effect
*base
, D3DXHANDLE pass
)
480 for (i
= 0; i
< base
->technique_count
; ++i
)
482 struct d3dx_technique
*technique
= &base
->techniques
[i
];
484 for (k
= 0; k
< technique
->pass_count
; ++k
)
486 if (get_pass_handle(&technique
->passes
[k
]) == pass
)
487 return &technique
->passes
[k
];
494 static struct d3dx_parameter
*get_valid_parameter(struct d3dx9_base_effect
*base
, D3DXHANDLE parameter
)
496 struct d3dx_parameter
**handle_param
= (struct d3dx_parameter
**)parameter
;
498 if (handle_param
>= base
->param_table
.table
&& handle_param
< base
->param_table
.table
+ base
->param_table
.count
)
499 return *handle_param
;
501 return get_parameter_by_name(base
, NULL
, parameter
);
504 static void free_state(struct d3dx_state
*state
)
506 free_parameter(&state
->parameter
, FALSE
, FALSE
);
509 static void free_object(struct d3dx_object
*object
)
511 HeapFree(GetProcessHeap(), 0, object
->data
);
514 static void free_sampler(struct d3dx_sampler
*sampler
)
518 for (i
= 0; i
< sampler
->state_count
; ++i
)
520 free_state(&sampler
->states
[i
]);
522 HeapFree(GetProcessHeap(), 0, sampler
->states
);
525 static void free_parameter(struct d3dx_parameter
*param
, BOOL element
, BOOL child
)
529 TRACE("Free parameter %p, name %s, type %s, child %s\n", param
, param
->name
,
530 debug_d3dxparameter_type(param
->type
), child
? "yes" : "no");
535 if (param
->annotations
)
537 for (i
= 0; i
< param
->annotation_count
; ++i
)
538 free_parameter(¶m
->annotations
[i
], FALSE
, FALSE
);
539 HeapFree(GetProcessHeap(), 0, param
->annotations
);
540 param
->annotations
= NULL
;
545 unsigned int count
= param
->element_count
? param
->element_count
: param
->member_count
;
547 for (i
= 0; i
< count
; ++i
)
548 free_parameter(¶m
->members
[i
], param
->element_count
!= 0, TRUE
);
549 HeapFree(GetProcessHeap(), 0, param
->members
);
550 param
->members
= NULL
;
553 if (param
->class == D3DXPC_OBJECT
&& !param
->element_count
)
558 HeapFree(GetProcessHeap(), 0, *(char **)param
->data
);
562 case D3DXPT_TEXTURE1D
:
563 case D3DXPT_TEXTURE2D
:
564 case D3DXPT_TEXTURE3D
:
565 case D3DXPT_TEXTURECUBE
:
566 case D3DXPT_PIXELSHADER
:
567 case D3DXPT_VERTEXSHADER
:
568 if (*(IUnknown
**)param
->data
) IUnknown_Release(*(IUnknown
**)param
->data
);
572 case D3DXPT_SAMPLER1D
:
573 case D3DXPT_SAMPLER2D
:
574 case D3DXPT_SAMPLER3D
:
575 case D3DXPT_SAMPLERCUBE
:
576 free_sampler((struct d3dx_sampler
*)param
->data
);
580 FIXME("Unhandled type %s\n", debug_d3dxparameter_type(param
->type
));
587 HeapFree(GetProcessHeap(), 0, param
->data
);
590 /* only the parent has to release name and semantic */
593 HeapFree(GetProcessHeap(), 0, param
->name
);
594 HeapFree(GetProcessHeap(), 0, param
->semantic
);
598 static void free_pass(struct d3dx_pass
*pass
)
602 TRACE("Free pass %p\n", pass
);
607 if (pass
->annotations
)
609 for (i
= 0; i
< pass
->annotation_count
; ++i
)
610 free_parameter(&pass
->annotations
[i
], FALSE
, FALSE
);
611 HeapFree(GetProcessHeap(), 0, pass
->annotations
);
612 pass
->annotations
= NULL
;
617 for (i
= 0; i
< pass
->state_count
; ++i
)
618 free_state(&pass
->states
[i
]);
619 HeapFree(GetProcessHeap(), 0, pass
->states
);
623 HeapFree(GetProcessHeap(), 0, pass
->name
);
627 static void free_technique(struct d3dx_technique
*technique
)
631 TRACE("Free technique %p\n", technique
);
636 if (technique
->annotations
)
638 for (i
= 0; i
< technique
->annotation_count
; ++i
)
639 free_parameter(&technique
->annotations
[i
], FALSE
, FALSE
);
640 HeapFree(GetProcessHeap(), 0, technique
->annotations
);
641 technique
->annotations
= NULL
;
644 if (technique
->passes
)
646 for (i
= 0; i
< technique
->pass_count
; ++i
)
647 free_pass(&technique
->passes
[i
]);
648 HeapFree(GetProcessHeap(), 0, technique
->passes
);
649 technique
->passes
= NULL
;
652 HeapFree(GetProcessHeap(), 0, technique
->name
);
653 technique
->name
= NULL
;
656 static void d3dx9_base_effect_cleanup(struct d3dx9_base_effect
*base
)
660 TRACE("base %p.\n", base
);
662 HeapFree(GetProcessHeap(), 0, base
->param_table
.table
);
664 if (base
->parameters
)
666 for (i
= 0; i
< base
->parameter_count
; ++i
)
667 free_parameter(&base
->parameters
[i
], FALSE
, FALSE
);
668 HeapFree(GetProcessHeap(), 0, base
->parameters
);
669 base
->parameters
= NULL
;
672 if (base
->techniques
)
674 for (i
= 0; i
< base
->technique_count
; ++i
)
675 free_technique(&base
->techniques
[i
]);
676 HeapFree(GetProcessHeap(), 0, base
->techniques
);
677 base
->techniques
= NULL
;
682 for (i
= 0; i
< base
->object_count
; ++i
)
684 free_object(&base
->objects
[i
]);
686 HeapFree(GetProcessHeap(), 0, base
->objects
);
687 base
->objects
= NULL
;
691 static void free_effect(struct ID3DXEffectImpl
*effect
)
693 TRACE("Free effect %p\n", effect
);
695 d3dx9_base_effect_cleanup(&effect
->base_effect
);
699 effect
->pool
->lpVtbl
->Release(effect
->pool
);
704 IUnknown_Release(effect
->manager
);
707 IDirect3DDevice9_Release(effect
->device
);
710 static void free_effect_compiler(struct ID3DXEffectCompilerImpl
*compiler
)
712 TRACE("Free effect compiler %p\n", compiler
);
714 d3dx9_base_effect_cleanup(&compiler
->base_effect
);
717 static void get_vector(struct d3dx_parameter
*param
, D3DXVECTOR4
*vector
)
721 for (i
= 0; i
< 4; ++i
)
723 if (i
< param
->columns
)
724 set_number((FLOAT
*)vector
+ i
, D3DXPT_FLOAT
, (DWORD
*)param
->data
+ i
, param
->type
);
726 ((FLOAT
*)vector
)[i
] = 0.0f
;
730 static void set_vector(struct d3dx_parameter
*param
, const D3DXVECTOR4
*vector
)
734 for (i
= 0; i
< param
->columns
; ++i
)
736 set_number((FLOAT
*)param
->data
+ i
, param
->type
, (FLOAT
*)vector
+ i
, D3DXPT_FLOAT
);
740 static void get_matrix(struct d3dx_parameter
*param
, D3DXMATRIX
*matrix
, BOOL transpose
)
744 for (i
= 0; i
< 4; ++i
)
746 for (k
= 0; k
< 4; ++k
)
748 FLOAT
*tmp
= transpose
? (FLOAT
*)&matrix
->u
.m
[k
][i
] : (FLOAT
*)&matrix
->u
.m
[i
][k
];
750 if ((i
< param
->rows
) && (k
< param
->columns
))
751 set_number(tmp
, D3DXPT_FLOAT
, (DWORD
*)param
->data
+ i
* param
->columns
+ k
, param
->type
);
758 static void set_matrix(struct d3dx_parameter
*param
, const D3DXMATRIX
*matrix
)
762 if (param
->type
== D3DXPT_FLOAT
)
764 if (param
->columns
== 4)
765 memcpy(param
->data
, matrix
->u
.m
, param
->rows
* 4 * sizeof(float));
767 for (i
= 0; i
< param
->rows
; ++i
)
768 memcpy((float *)param
->data
+ i
* param
->columns
, matrix
->u
.m
+ i
, param
->columns
* sizeof(float));
772 for (i
= 0; i
< param
->rows
; ++i
)
774 for (k
= 0; k
< param
->columns
; ++k
)
776 set_number((FLOAT
*)param
->data
+ i
* param
->columns
+ k
, param
->type
,
777 &matrix
->u
.m
[i
][k
], D3DXPT_FLOAT
);
782 static void set_matrix_transpose(struct d3dx_parameter
*param
, const D3DXMATRIX
*matrix
)
786 for (i
= 0; i
< param
->rows
; ++i
)
788 for (k
= 0; k
< param
->columns
; ++k
)
790 set_number((FLOAT
*)param
->data
+ i
* param
->columns
+ k
, param
->type
,
791 &matrix
->u
.m
[k
][i
], D3DXPT_FLOAT
);
796 static struct d3dx_parameter
*get_parameter_element_by_name(struct d3dx_parameter
*parameter
, const char *name
)
799 struct d3dx_parameter
*temp_parameter
;
802 TRACE("parameter %p, name %s\n", parameter
, debugstr_a(name
));
804 if (!name
|| !*name
) return NULL
;
806 element
= atoi(name
);
807 part
= strchr(name
, ']') + 1;
809 /* check for empty [] && element range */
810 if ((part
- name
) > 1 && parameter
->element_count
> element
)
812 temp_parameter
= ¶meter
->members
[element
];
817 return get_parameter_by_name(NULL
, temp_parameter
, part
);
820 return get_annotation_by_name(temp_parameter
->annotation_count
, temp_parameter
->annotations
, part
);
823 TRACE("Returning parameter %p\n", temp_parameter
);
824 return temp_parameter
;
827 FIXME("Unhandled case \"%c\"\n", *--part
);
832 TRACE("Parameter not found\n");
836 static struct d3dx_parameter
*get_annotation_by_name(UINT count
, struct d3dx_parameter
*annotations
,
840 struct d3dx_parameter
*temp_parameter
;
843 TRACE("count %u, annotations %p, name %s\n", count
, annotations
, debugstr_a(name
));
845 if (!name
|| !*name
) return NULL
;
847 length
= strcspn( name
, "[.@" );
848 part
= name
+ length
;
850 for (i
= 0; i
< count
; ++i
)
852 temp_parameter
= &annotations
[i
];
854 if (!strcmp(temp_parameter
->name
, name
))
856 TRACE("Returning annotation %p\n", temp_parameter
);
857 return temp_parameter
;
859 else if (strlen(temp_parameter
->name
) == length
&& !strncmp(temp_parameter
->name
, name
, length
))
864 return get_parameter_by_name(NULL
, temp_parameter
, part
);
867 return get_parameter_element_by_name(temp_parameter
, part
);
870 FIXME("Unhandled case \"%c\"\n", *--part
);
876 TRACE("Annotation not found\n");
880 static struct d3dx_parameter
*get_parameter_by_name(struct d3dx9_base_effect
*base
,
881 struct d3dx_parameter
*parameter
, const char *name
)
883 UINT i
, count
, length
;
884 struct d3dx_parameter
*temp_parameter
;
885 struct d3dx_parameter
*parameters
;
888 TRACE("base %p, parameter %p, name %s\n", base
, parameter
, debugstr_a(name
));
890 if (!name
|| !*name
) return NULL
;
894 count
= base
->parameter_count
;
895 parameters
= base
->parameters
;
899 count
= parameter
->member_count
;
900 parameters
= parameter
->members
;
903 length
= strcspn( name
, "[.@" );
904 part
= name
+ length
;
906 for (i
= 0; i
< count
; i
++)
908 temp_parameter
= ¶meters
[i
];
910 if (!strcmp(temp_parameter
->name
, name
))
912 TRACE("Returning parameter %p\n", temp_parameter
);
913 return temp_parameter
;
915 else if (strlen(temp_parameter
->name
) == length
&& !strncmp(temp_parameter
->name
, name
, length
))
920 return get_parameter_by_name(NULL
, temp_parameter
, part
);
923 return get_annotation_by_name(temp_parameter
->annotation_count
, temp_parameter
->annotations
, part
);
926 return get_parameter_element_by_name(temp_parameter
, part
);
929 FIXME("Unhandled case \"%c\"\n", *--part
);
935 TRACE("Parameter not found\n");
939 static inline DWORD
d3dx9_effect_version(DWORD major
, DWORD minor
)
941 return (0xfeff0000 | ((major
) << 8) | (minor
));
944 static HRESULT
d3dx9_base_effect_get_desc(struct d3dx9_base_effect
*base
, D3DXEFFECT_DESC
*desc
)
948 WARN("Invalid argument specified.\n");
949 return D3DERR_INVALIDCALL
;
952 FIXME("partial stub!\n");
954 /* TODO: add creator and function count. */
955 desc
->Creator
= NULL
;
957 desc
->Parameters
= base
->parameter_count
;
958 desc
->Techniques
= base
->technique_count
;
963 static HRESULT
d3dx9_base_effect_get_parameter_desc(struct d3dx9_base_effect
*base
,
964 D3DXHANDLE parameter
, D3DXPARAMETER_DESC
*desc
)
966 struct d3dx_parameter
*param
= get_valid_parameter(base
, parameter
);
970 WARN("Invalid argument specified.\n");
971 return D3DERR_INVALIDCALL
;
974 desc
->Name
= param
->name
;
975 desc
->Semantic
= param
->semantic
;
976 desc
->Class
= param
->class;
977 desc
->Type
= param
->type
;
978 desc
->Rows
= param
->rows
;
979 desc
->Columns
= param
->columns
;
980 desc
->Elements
= param
->element_count
;
981 desc
->Annotations
= param
->annotation_count
;
982 desc
->StructMembers
= param
->member_count
;
983 desc
->Flags
= param
->flags
;
984 desc
->Bytes
= param
->bytes
;
989 static HRESULT
d3dx9_base_effect_get_technique_desc(struct d3dx9_base_effect
*base
,
990 D3DXHANDLE technique
, D3DXTECHNIQUE_DESC
*desc
)
992 struct d3dx_technique
*tech
= technique
? get_valid_technique(base
, technique
) : &base
->techniques
[0];
996 WARN("Invalid argument specified.\n");
997 return D3DERR_INVALIDCALL
;
1000 desc
->Name
= tech
->name
;
1001 desc
->Passes
= tech
->pass_count
;
1002 desc
->Annotations
= tech
->annotation_count
;
1007 static HRESULT
d3dx9_base_effect_get_pass_desc(struct d3dx9_base_effect
*base
,
1008 D3DXHANDLE pass
, D3DXPASS_DESC
*desc
)
1010 struct d3dx_pass
*p
= get_valid_pass(base
, pass
);
1014 WARN("Invalid argument specified.\n");
1015 return D3DERR_INVALIDCALL
;
1018 desc
->Name
= p
->name
;
1019 desc
->Annotations
= p
->annotation_count
;
1021 FIXME("Pixel shader and vertex shader are not supported, yet.\n");
1022 desc
->pVertexShaderFunction
= NULL
;
1023 desc
->pPixelShaderFunction
= NULL
;
1028 static HRESULT
d3dx9_base_effect_get_function_desc(struct d3dx9_base_effect
*base
,
1029 D3DXHANDLE shader
, D3DXFUNCTION_DESC
*desc
)
1036 static D3DXHANDLE
d3dx9_base_effect_get_parameter(struct d3dx9_base_effect
*base
,
1037 D3DXHANDLE parameter
, UINT index
)
1039 struct d3dx_parameter
*param
= get_valid_parameter(base
, parameter
);
1043 if (index
< base
->parameter_count
)
1045 TRACE("Returning parameter %p.\n", &base
->parameters
[index
]);
1046 return get_parameter_handle(&base
->parameters
[index
]);
1051 if (param
&& !param
->element_count
&& index
< param
->member_count
)
1053 TRACE("Returning parameter %p.\n", ¶m
->members
[index
]);
1054 return get_parameter_handle(¶m
->members
[index
]);
1058 WARN("Parameter not found.\n");
1063 static D3DXHANDLE
d3dx9_base_effect_get_parameter_by_name(struct d3dx9_base_effect
*base
,
1064 D3DXHANDLE parameter
, const char *name
)
1066 struct d3dx_parameter
*param
= get_valid_parameter(base
, parameter
);
1071 handle
= get_parameter_handle(param
);
1072 TRACE("Returning parameter %p.\n", handle
);
1076 handle
= get_parameter_handle(get_parameter_by_name(base
, param
, name
));
1077 TRACE("Returning parameter %p.\n", handle
);
1082 static D3DXHANDLE
d3dx9_base_effect_get_parameter_by_semantic(struct d3dx9_base_effect
*base
,
1083 D3DXHANDLE parameter
, const char *semantic
)
1085 struct d3dx_parameter
*param
= get_valid_parameter(base
, parameter
);
1086 struct d3dx_parameter
*temp_param
;
1091 for (i
= 0; i
< base
->parameter_count
; ++i
)
1093 temp_param
= &base
->parameters
[i
];
1095 if (!temp_param
->semantic
)
1099 TRACE("Returning parameter %p\n", temp_param
);
1100 return get_parameter_handle(temp_param
);
1105 if (!strcasecmp(temp_param
->semantic
, semantic
))
1107 TRACE("Returning parameter %p\n", temp_param
);
1108 return get_parameter_handle(temp_param
);
1114 for (i
= 0; i
< param
->member_count
; ++i
)
1116 temp_param
= ¶m
->members
[i
];
1118 if (!temp_param
->semantic
)
1122 TRACE("Returning parameter %p\n", temp_param
);
1123 return get_parameter_handle(temp_param
);
1128 if (!strcasecmp(temp_param
->semantic
, semantic
))
1130 TRACE("Returning parameter %p\n", temp_param
);
1131 return get_parameter_handle(temp_param
);
1136 WARN("Parameter not found.\n");
1141 static D3DXHANDLE
d3dx9_base_effect_get_parameter_element(struct d3dx9_base_effect
*base
,
1142 D3DXHANDLE parameter
, UINT index
)
1144 struct d3dx_parameter
*param
= get_valid_parameter(base
, parameter
);
1148 if (index
< base
->parameter_count
)
1150 TRACE("Returning parameter %p.\n", &base
->parameters
[index
]);
1151 return get_parameter_handle(&base
->parameters
[index
]);
1156 if (index
< param
->element_count
)
1158 TRACE("Returning parameter %p.\n", ¶m
->members
[index
]);
1159 return get_parameter_handle(¶m
->members
[index
]);
1163 WARN("Parameter not found.\n");
1168 static D3DXHANDLE
d3dx9_base_effect_get_technique(struct d3dx9_base_effect
*base
, UINT index
)
1170 if (index
>= base
->technique_count
)
1172 WARN("Invalid argument specified.\n");
1176 TRACE("Returning technique %p.\n", &base
->techniques
[index
]);
1178 return get_technique_handle(&base
->techniques
[index
]);
1181 static D3DXHANDLE
d3dx9_base_effect_get_technique_by_name(struct d3dx9_base_effect
*base
, const char *name
)
1183 struct d3dx_technique
*tech
= get_technique_by_name(base
, name
);
1187 D3DXHANDLE t
= get_technique_handle(tech
);
1188 TRACE("Returning technique %p\n", t
);
1192 WARN("Technique not found.\n");
1197 static D3DXHANDLE
d3dx9_base_effect_get_pass(struct d3dx9_base_effect
*base
,
1198 D3DXHANDLE technique
, UINT index
)
1200 struct d3dx_technique
*tech
= get_valid_technique(base
, technique
);
1202 if (tech
&& index
< tech
->pass_count
)
1204 TRACE("Returning pass %p\n", &tech
->passes
[index
]);
1205 return get_pass_handle(&tech
->passes
[index
]);
1208 WARN("Pass not found.\n");
1213 static D3DXHANDLE
d3dx9_base_effect_get_pass_by_name(struct d3dx9_base_effect
*base
,
1214 D3DXHANDLE technique
, const char *name
)
1216 struct d3dx_technique
*tech
= get_valid_technique(base
, technique
);
1222 for (i
= 0; i
< tech
->pass_count
; ++i
)
1224 struct d3dx_pass
*pass
= &tech
->passes
[i
];
1226 if (!strcmp(pass
->name
, name
))
1228 TRACE("Returning pass %p\n", pass
);
1229 return get_pass_handle(pass
);
1234 WARN("Pass not found.\n");
1239 static D3DXHANDLE
d3dx9_base_effect_get_function(struct d3dx9_base_effect
*base
, UINT index
)
1246 static D3DXHANDLE
d3dx9_base_effect_get_function_by_name(struct d3dx9_base_effect
*base
, const char *name
)
1253 static UINT
get_annotation_from_object(struct d3dx9_base_effect
*base
,
1254 D3DXHANDLE object
, struct d3dx_parameter
**annotations
)
1256 struct d3dx_parameter
*param
= get_valid_parameter(base
, object
);
1257 struct d3dx_pass
*pass
= get_valid_pass(base
, object
);
1258 struct d3dx_technique
*technique
= get_valid_technique(base
, object
);
1262 *annotations
= pass
->annotations
;
1263 return pass
->annotation_count
;
1267 *annotations
= technique
->annotations
;
1268 return technique
->annotation_count
;
1272 *annotations
= param
->annotations
;
1273 return param
->annotation_count
;
1277 FIXME("Functions are not handled, yet!\n");
1282 static D3DXHANDLE
d3dx9_base_effect_get_annotation(struct d3dx9_base_effect
*base
,
1283 D3DXHANDLE object
, UINT index
)
1285 struct d3dx_parameter
*annotations
= NULL
;
1286 UINT annotation_count
= 0;
1288 annotation_count
= get_annotation_from_object(base
, object
, &annotations
);
1290 if (index
< annotation_count
)
1292 TRACE("Returning parameter %p\n", &annotations
[index
]);
1293 return get_parameter_handle(&annotations
[index
]);
1296 WARN("Annotation not found.\n");
1301 static D3DXHANDLE
d3dx9_base_effect_get_annotation_by_name(struct d3dx9_base_effect
*base
,
1302 D3DXHANDLE object
, const char *name
)
1304 struct d3dx_parameter
*annotation
= NULL
;
1305 struct d3dx_parameter
*annotations
= NULL
;
1306 UINT annotation_count
= 0;
1310 WARN("Invalid argument specified\n");
1314 annotation_count
= get_annotation_from_object(base
, object
, &annotations
);
1316 annotation
= get_annotation_by_name(annotation_count
, annotations
, name
);
1319 TRACE("Returning parameter %p\n", annotation
);
1320 return get_parameter_handle(annotation
);
1323 WARN("Annotation not found.\n");
1328 static HRESULT
d3dx9_base_effect_set_value(struct d3dx9_base_effect
*base
,
1329 D3DXHANDLE parameter
, const void *data
, UINT bytes
)
1331 struct d3dx_parameter
*param
= get_valid_parameter(base
, parameter
);
1335 WARN("Invalid parameter %p specified\n", parameter
);
1336 return D3DERR_INVALIDCALL
;
1339 /* samplers don't touch data */
1340 if (param
->class == D3DXPC_OBJECT
&& (param
->type
== D3DXPT_SAMPLER
1341 || param
->type
== D3DXPT_SAMPLER1D
|| param
->type
== D3DXPT_SAMPLER2D
1342 || param
->type
== D3DXPT_SAMPLER3D
|| param
->type
== D3DXPT_SAMPLERCUBE
))
1344 TRACE("Sampler: returning E_FAIL\n");
1348 if (data
&& param
->bytes
<= bytes
)
1350 switch (param
->type
)
1356 TRACE("Copy %u bytes\n", param
->bytes
);
1357 memcpy(param
->data
, data
, param
->bytes
);
1361 FIXME("Unhandled type %s\n", debug_d3dxparameter_type(param
->type
));
1368 WARN("Invalid argument specified\n");
1370 return D3DERR_INVALIDCALL
;
1373 static HRESULT
d3dx9_base_effect_get_value(struct d3dx9_base_effect
*base
,
1374 D3DXHANDLE parameter
, void *data
, UINT bytes
)
1376 struct d3dx_parameter
*param
= get_valid_parameter(base
, parameter
);
1380 WARN("Invalid parameter %p specified\n", parameter
);
1381 return D3DERR_INVALIDCALL
;
1384 /* samplers don't touch data */
1385 if (param
->class == D3DXPC_OBJECT
&& (param
->type
== D3DXPT_SAMPLER
1386 || param
->type
== D3DXPT_SAMPLER1D
|| param
->type
== D3DXPT_SAMPLER2D
1387 || param
->type
== D3DXPT_SAMPLER3D
|| param
->type
== D3DXPT_SAMPLERCUBE
))
1389 TRACE("Sampler: returning E_FAIL\n");
1393 if (data
&& param
->bytes
<= bytes
)
1395 TRACE("Type %s\n", debug_d3dxparameter_type(param
->type
));
1397 switch (param
->type
)
1406 case D3DXPT_VERTEXSHADER
:
1407 case D3DXPT_PIXELSHADER
:
1408 case D3DXPT_TEXTURE
:
1409 case D3DXPT_TEXTURE1D
:
1410 case D3DXPT_TEXTURE2D
:
1411 case D3DXPT_TEXTURE3D
:
1412 case D3DXPT_TEXTURECUBE
:
1416 for (i
= 0; i
< (param
->element_count
? param
->element_count
: 1); ++i
)
1418 IUnknown
*unk
= ((IUnknown
**)param
->data
)[i
];
1419 if (unk
) IUnknown_AddRef(unk
);
1425 FIXME("Unhandled type %s\n", debug_d3dxparameter_type(param
->type
));
1429 TRACE("Copy %u bytes\n", param
->bytes
);
1430 memcpy(data
, param
->data
, param
->bytes
);
1434 WARN("Parameter not found.\n");
1436 return D3DERR_INVALIDCALL
;
1439 static HRESULT
d3dx9_base_effect_set_bool(struct d3dx9_base_effect
*base
, D3DXHANDLE parameter
, BOOL b
)
1441 struct d3dx_parameter
*param
= get_valid_parameter(base
, parameter
);
1443 if (param
&& !param
->element_count
&& param
->rows
== 1 && param
->columns
== 1)
1445 set_number(param
->data
, param
->type
, &b
, D3DXPT_BOOL
);
1449 WARN("Parameter not found.\n");
1451 return D3DERR_INVALIDCALL
;
1454 static HRESULT
d3dx9_base_effect_get_bool(struct d3dx9_base_effect
*base
, D3DXHANDLE parameter
, BOOL
*b
)
1456 struct d3dx_parameter
*param
= get_valid_parameter(base
, parameter
);
1458 if (b
&& param
&& !param
->element_count
&& param
->rows
== 1 && param
->columns
== 1)
1460 set_number(b
, D3DXPT_BOOL
, param
->data
, param
->type
);
1461 TRACE("Returning %s\n", *b
? "TRUE" : "FALSE");
1465 WARN("Parameter not found.\n");
1467 return D3DERR_INVALIDCALL
;
1470 static HRESULT
d3dx9_base_effect_set_bool_array(struct d3dx9_base_effect
*base
,
1471 D3DXHANDLE parameter
, const BOOL
*b
, UINT count
)
1473 struct d3dx_parameter
*param
= get_valid_parameter(base
, parameter
);
1477 UINT i
, size
= min(count
, param
->bytes
/ sizeof(DWORD
));
1479 TRACE("Class %s\n", debug_d3dxparameter_class(param
->class));
1481 switch (param
->class)
1485 case D3DXPC_MATRIX_ROWS
:
1486 for (i
= 0; i
< size
; ++i
)
1488 /* don't crop the input, use D3DXPT_INT instead of D3DXPT_BOOL */
1489 set_number((DWORD
*)param
->data
+ i
, param
->type
, &b
[i
], D3DXPT_INT
);
1498 FIXME("Unhandled class %s\n", debug_d3dxparameter_class(param
->class));
1503 WARN("Parameter not found.\n");
1505 return D3DERR_INVALIDCALL
;
1508 static HRESULT
d3dx9_base_effect_get_bool_array(struct d3dx9_base_effect
*base
,
1509 D3DXHANDLE parameter
, BOOL
*b
, UINT count
)
1511 struct d3dx_parameter
*param
= get_valid_parameter(base
, parameter
);
1513 if (b
&& param
&& (param
->class == D3DXPC_SCALAR
1514 || param
->class == D3DXPC_VECTOR
1515 || param
->class == D3DXPC_MATRIX_ROWS
1516 || param
->class == D3DXPC_MATRIX_COLUMNS
))
1518 UINT i
, size
= min(count
, param
->bytes
/ sizeof(DWORD
));
1520 for (i
= 0; i
< size
; ++i
)
1522 set_number(&b
[i
], D3DXPT_BOOL
, (DWORD
*)param
->data
+ i
, param
->type
);
1527 WARN("Parameter not found.\n");
1529 return D3DERR_INVALIDCALL
;
1532 static HRESULT
d3dx9_base_effect_set_int(struct d3dx9_base_effect
*base
, D3DXHANDLE parameter
, INT n
)
1534 struct d3dx_parameter
*param
= get_valid_parameter(base
, parameter
);
1536 if (param
&& !param
->element_count
)
1538 if (param
->rows
== 1 && param
->columns
== 1)
1540 set_number(param
->data
, param
->type
, &n
, D3DXPT_INT
);
1545 * Split the value, if parameter is a vector with dimension 3 or 4.
1547 if (param
->type
== D3DXPT_FLOAT
&&
1548 ((param
->class == D3DXPC_VECTOR
&& param
->columns
!= 2) ||
1549 (param
->class == D3DXPC_MATRIX_ROWS
&& param
->rows
!= 2 && param
->columns
== 1)))
1551 TRACE("Vector fixup\n");
1553 *(FLOAT
*)param
->data
= ((n
& 0xff0000) >> 16) * INT_FLOAT_MULTI_INVERSE
;
1554 ((FLOAT
*)param
->data
)[1] = ((n
& 0xff00) >> 8) * INT_FLOAT_MULTI_INVERSE
;
1555 ((FLOAT
*)param
->data
)[2] = (n
& 0xff) * INT_FLOAT_MULTI_INVERSE
;
1556 if (param
->rows
* param
->columns
> 3)
1558 ((FLOAT
*)param
->data
)[3] = ((n
& 0xff000000) >> 24) * INT_FLOAT_MULTI_INVERSE
;
1564 WARN("Parameter not found.\n");
1566 return D3DERR_INVALIDCALL
;
1569 static HRESULT
d3dx9_base_effect_get_int(struct d3dx9_base_effect
*base
, D3DXHANDLE parameter
, INT
*n
)
1571 struct d3dx_parameter
*param
= get_valid_parameter(base
, parameter
);
1573 if (n
&& param
&& !param
->element_count
)
1575 if (param
->columns
== 1 && param
->rows
== 1)
1577 set_number(n
, D3DXPT_INT
, param
->data
, param
->type
);
1578 TRACE("Returning %i\n", *n
);
1582 if (param
->type
== D3DXPT_FLOAT
&&
1583 ((param
->class == D3DXPC_VECTOR
&& param
->columns
!= 2)
1584 || (param
->class == D3DXPC_MATRIX_ROWS
&& param
->rows
!= 2 && param
->columns
== 1)))
1586 TRACE("Vector fixup\n");
1588 /* all components (3,4) are clamped (0,255) and put in the INT */
1589 *n
= (INT
)(min(max(0.0f
, *((FLOAT
*)param
->data
+ 2)), 1.0f
) * INT_FLOAT_MULTI
);
1590 *n
+= ((INT
)(min(max(0.0f
, *((FLOAT
*)param
->data
+ 1)), 1.0f
) * INT_FLOAT_MULTI
)) << 8;
1591 *n
+= ((INT
)(min(max(0.0f
, *((FLOAT
*)param
->data
+ 0)), 1.0f
) * INT_FLOAT_MULTI
)) << 16;
1592 if (param
->columns
* param
->rows
> 3)
1594 *n
+= ((INT
)(min(max(0.0f
, *((FLOAT
*)param
->data
+ 3)), 1.0f
) * INT_FLOAT_MULTI
)) << 24;
1597 TRACE("Returning %i\n", *n
);
1602 WARN("Parameter not found.\n");
1604 return D3DERR_INVALIDCALL
;
1607 static HRESULT
d3dx9_base_effect_set_int_array(struct d3dx9_base_effect
*base
,
1608 D3DXHANDLE parameter
, const INT
*n
, UINT count
)
1610 struct d3dx_parameter
*param
= get_valid_parameter(base
, parameter
);
1614 UINT i
, size
= min(count
, param
->bytes
/ sizeof(DWORD
));
1616 TRACE("Class %s\n", debug_d3dxparameter_class(param
->class));
1618 switch (param
->class)
1622 case D3DXPC_MATRIX_ROWS
:
1623 for (i
= 0; i
< size
; ++i
)
1625 set_number((DWORD
*)param
->data
+ i
, param
->type
, &n
[i
], D3DXPT_INT
);
1634 FIXME("Unhandled class %s\n", debug_d3dxparameter_class(param
->class));
1639 WARN("Parameter not found.\n");
1641 return D3DERR_INVALIDCALL
;
1644 static HRESULT
d3dx9_base_effect_get_int_array(struct d3dx9_base_effect
*base
,
1645 D3DXHANDLE parameter
, INT
*n
, UINT count
)
1647 struct d3dx_parameter
*param
= get_valid_parameter(base
, parameter
);
1649 if (n
&& param
&& (param
->class == D3DXPC_SCALAR
1650 || param
->class == D3DXPC_VECTOR
1651 || param
->class == D3DXPC_MATRIX_ROWS
1652 || param
->class == D3DXPC_MATRIX_COLUMNS
))
1654 UINT i
, size
= min(count
, param
->bytes
/ sizeof(DWORD
));
1656 for (i
= 0; i
< size
; ++i
)
1658 set_number(&n
[i
], D3DXPT_INT
, (DWORD
*)param
->data
+ i
, param
->type
);
1663 WARN("Parameter not found.\n");
1665 return D3DERR_INVALIDCALL
;
1668 static HRESULT
d3dx9_base_effect_set_float(struct d3dx9_base_effect
*base
, D3DXHANDLE parameter
, float f
)
1670 struct d3dx_parameter
*param
= get_valid_parameter(base
, parameter
);
1672 if (param
&& !param
->element_count
&& param
->rows
== 1 && param
->columns
== 1)
1674 set_number((DWORD
*)param
->data
, param
->type
, &f
, D3DXPT_FLOAT
);
1678 WARN("Parameter not found.\n");
1680 return D3DERR_INVALIDCALL
;
1683 static HRESULT
d3dx9_base_effect_get_float(struct d3dx9_base_effect
*base
, D3DXHANDLE parameter
, float *f
)
1685 struct d3dx_parameter
*param
= get_valid_parameter(base
, parameter
);
1687 if (f
&& param
&& !param
->element_count
&& param
->columns
== 1 && param
->rows
== 1)
1689 set_number(f
, D3DXPT_FLOAT
, (DWORD
*)param
->data
, param
->type
);
1690 TRACE("Returning %f\n", *f
);
1694 WARN("Parameter not found.\n");
1696 return D3DERR_INVALIDCALL
;
1699 static HRESULT
d3dx9_base_effect_set_float_array(struct d3dx9_base_effect
*base
,
1700 D3DXHANDLE parameter
, const float *f
, UINT count
)
1702 struct d3dx_parameter
*param
= get_valid_parameter(base
, parameter
);
1706 UINT i
, size
= min(count
, param
->bytes
/ sizeof(DWORD
));
1708 TRACE("Class %s\n", debug_d3dxparameter_class(param
->class));
1710 switch (param
->class)
1714 case D3DXPC_MATRIX_ROWS
:
1715 for (i
= 0; i
< size
; ++i
)
1717 set_number((DWORD
*)param
->data
+ i
, param
->type
, &f
[i
], D3DXPT_FLOAT
);
1726 FIXME("Unhandled class %s\n", debug_d3dxparameter_class(param
->class));
1731 WARN("Parameter not found.\n");
1733 return D3DERR_INVALIDCALL
;
1736 static HRESULT
d3dx9_base_effect_get_float_array(struct d3dx9_base_effect
*base
,
1737 D3DXHANDLE parameter
, float *f
, UINT count
)
1739 struct d3dx_parameter
*param
= get_valid_parameter(base
, parameter
);
1741 if (f
&& param
&& (param
->class == D3DXPC_SCALAR
1742 || param
->class == D3DXPC_VECTOR
1743 || param
->class == D3DXPC_MATRIX_ROWS
1744 || param
->class == D3DXPC_MATRIX_COLUMNS
))
1746 UINT i
, size
= min(count
, param
->bytes
/ sizeof(DWORD
));
1748 for (i
= 0; i
< size
; ++i
)
1750 set_number(&f
[i
], D3DXPT_FLOAT
, (DWORD
*)param
->data
+ i
, param
->type
);
1755 WARN("Parameter not found.\n");
1757 return D3DERR_INVALIDCALL
;
1760 static HRESULT
d3dx9_base_effect_set_vector(struct d3dx9_base_effect
*base
,
1761 D3DXHANDLE parameter
, const D3DXVECTOR4
*vector
)
1763 struct d3dx_parameter
*param
= get_valid_parameter(base
, parameter
);
1765 if (param
&& !param
->element_count
)
1767 TRACE("Class %s\n", debug_d3dxparameter_class(param
->class));
1769 switch (param
->class)
1773 if (param
->type
== D3DXPT_INT
&& param
->bytes
== 4)
1777 TRACE("INT fixup\n");
1778 tmp
= (DWORD
)(max(min(vector
->z
, 1.0f
), 0.0f
) * INT_FLOAT_MULTI
);
1779 tmp
+= ((DWORD
)(max(min(vector
->y
, 1.0f
), 0.0f
) * INT_FLOAT_MULTI
)) << 8;
1780 tmp
+= ((DWORD
)(max(min(vector
->x
, 1.0f
), 0.0f
) * INT_FLOAT_MULTI
)) << 16;
1781 tmp
+= ((DWORD
)(max(min(vector
->w
, 1.0f
), 0.0f
) * INT_FLOAT_MULTI
)) << 24;
1783 *(INT
*)param
->data
= tmp
;
1786 if (param
->type
== D3DXPT_FLOAT
)
1788 memcpy(param
->data
, vector
, param
->columns
* sizeof(float));
1792 set_vector(param
, vector
);
1795 case D3DXPC_MATRIX_ROWS
:
1801 FIXME("Unhandled class %s\n", debug_d3dxparameter_class(param
->class));
1806 WARN("Parameter not found.\n");
1808 return D3DERR_INVALIDCALL
;
1811 static HRESULT
d3dx9_base_effect_get_vector(struct d3dx9_base_effect
*base
,
1812 D3DXHANDLE parameter
, D3DXVECTOR4
*vector
)
1814 struct d3dx_parameter
*param
= get_valid_parameter(base
, parameter
);
1816 if (vector
&& param
&& !param
->element_count
)
1818 TRACE("Class %s\n", debug_d3dxparameter_class(param
->class));
1820 switch (param
->class)
1824 if (param
->type
== D3DXPT_INT
&& param
->bytes
== 4)
1826 TRACE("INT fixup\n");
1827 vector
->x
= (((*(INT
*)param
->data
) & 0xff0000) >> 16) * INT_FLOAT_MULTI_INVERSE
;
1828 vector
->y
= (((*(INT
*)param
->data
) & 0xff00) >> 8) * INT_FLOAT_MULTI_INVERSE
;
1829 vector
->z
= ((*(INT
*)param
->data
) & 0xff) * INT_FLOAT_MULTI_INVERSE
;
1830 vector
->w
= (((*(INT
*)param
->data
) & 0xff000000) >> 24) * INT_FLOAT_MULTI_INVERSE
;
1833 get_vector(param
, vector
);
1836 case D3DXPC_MATRIX_ROWS
:
1842 FIXME("Unhandled class %s\n", debug_d3dxparameter_class(param
->class));
1847 WARN("Parameter not found.\n");
1849 return D3DERR_INVALIDCALL
;
1852 static HRESULT
d3dx9_base_effect_set_vector_array(struct d3dx9_base_effect
*base
,
1853 D3DXHANDLE parameter
, const D3DXVECTOR4
*vector
, UINT count
)
1855 struct d3dx_parameter
*param
= get_valid_parameter(base
, parameter
);
1857 if (param
&& param
->element_count
&& param
->element_count
>= count
)
1861 TRACE("Class %s\n", debug_d3dxparameter_class(param
->class));
1863 switch (param
->class)
1866 if (param
->type
== D3DXPT_FLOAT
)
1868 if (param
->columns
== 4)
1869 memcpy(param
->data
, vector
, count
* 4 * sizeof(float));
1871 for (i
= 0; i
< count
; ++i
)
1872 memcpy((float *)param
->data
+ param
->columns
* i
, vector
+ i
,
1873 param
->columns
* sizeof(float));
1877 for (i
= 0; i
< count
; ++i
)
1879 set_vector(¶m
->members
[i
], &vector
[i
]);
1884 case D3DXPC_MATRIX_ROWS
:
1890 FIXME("Unhandled class %s\n", debug_d3dxparameter_class(param
->class));
1895 WARN("Parameter not found.\n");
1897 return D3DERR_INVALIDCALL
;
1900 static HRESULT
d3dx9_base_effect_get_vector_array(struct d3dx9_base_effect
*base
,
1901 D3DXHANDLE parameter
, D3DXVECTOR4
*vector
, UINT count
)
1903 struct d3dx_parameter
*param
= get_valid_parameter(base
, parameter
);
1905 if (!count
) return D3D_OK
;
1907 if (vector
&& param
&& count
<= param
->element_count
)
1911 TRACE("Class %s\n", debug_d3dxparameter_class(param
->class));
1913 switch (param
->class)
1916 for (i
= 0; i
< count
; ++i
)
1918 get_vector(¶m
->members
[i
], &vector
[i
]);
1923 case D3DXPC_MATRIX_ROWS
:
1929 FIXME("Unhandled class %s\n", debug_d3dxparameter_class(param
->class));
1934 WARN("Parameter not found.\n");
1936 return D3DERR_INVALIDCALL
;
1939 static HRESULT
d3dx9_base_effect_set_matrix(struct d3dx9_base_effect
*base
,
1940 D3DXHANDLE parameter
, const D3DXMATRIX
*matrix
)
1942 struct d3dx_parameter
*param
= get_valid_parameter(base
, parameter
);
1944 if (param
&& !param
->element_count
)
1946 TRACE("Class %s\n", debug_d3dxparameter_class(param
->class));
1948 switch (param
->class)
1950 case D3DXPC_MATRIX_ROWS
:
1951 set_matrix(param
, matrix
);
1961 FIXME("Unhandled class %s\n", debug_d3dxparameter_class(param
->class));
1966 WARN("Parameter not found.\n");
1968 return D3DERR_INVALIDCALL
;
1971 static HRESULT
d3dx9_base_effect_get_matrix(struct d3dx9_base_effect
*base
,
1972 D3DXHANDLE parameter
, D3DXMATRIX
*matrix
)
1974 struct d3dx_parameter
*param
= get_valid_parameter(base
, parameter
);
1976 if (matrix
&& param
&& !param
->element_count
)
1978 TRACE("Class %s\n", debug_d3dxparameter_class(param
->class));
1980 switch (param
->class)
1982 case D3DXPC_MATRIX_ROWS
:
1983 get_matrix(param
, matrix
, FALSE
);
1993 FIXME("Unhandled class %s\n", debug_d3dxparameter_class(param
->class));
1998 WARN("Parameter not found.\n");
2000 return D3DERR_INVALIDCALL
;
2003 static HRESULT
d3dx9_base_effect_set_matrix_array(struct d3dx9_base_effect
*base
,
2004 D3DXHANDLE parameter
, const D3DXMATRIX
*matrix
, UINT count
)
2006 struct d3dx_parameter
*param
= get_valid_parameter(base
, parameter
);
2008 if (param
&& param
->element_count
>= count
)
2012 TRACE("Class %s\n", debug_d3dxparameter_class(param
->class));
2014 switch (param
->class)
2016 case D3DXPC_MATRIX_ROWS
:
2017 for (i
= 0; i
< count
; ++i
)
2019 set_matrix(¶m
->members
[i
], &matrix
[i
]);
2030 FIXME("Unhandled class %s\n", debug_d3dxparameter_class(param
->class));
2035 WARN("Parameter not found.\n");
2037 return D3DERR_INVALIDCALL
;
2040 static HRESULT
d3dx9_base_effect_get_matrix_array(struct d3dx9_base_effect
*base
,
2041 D3DXHANDLE parameter
, D3DXMATRIX
*matrix
, UINT count
)
2043 struct d3dx_parameter
*param
= get_valid_parameter(base
, parameter
);
2045 if (!count
) return D3D_OK
;
2047 if (matrix
&& param
&& count
<= param
->element_count
)
2051 TRACE("Class %s\n", debug_d3dxparameter_class(param
->class));
2053 switch (param
->class)
2055 case D3DXPC_MATRIX_ROWS
:
2056 for (i
= 0; i
< count
; ++i
)
2058 get_matrix(¶m
->members
[i
], &matrix
[i
], FALSE
);
2069 FIXME("Unhandled class %s\n", debug_d3dxparameter_class(param
->class));
2074 WARN("Parameter not found.\n");
2076 return D3DERR_INVALIDCALL
;
2079 static HRESULT
d3dx9_base_effect_set_matrix_pointer_array(struct d3dx9_base_effect
*base
,
2080 D3DXHANDLE parameter
, const D3DXMATRIX
**matrix
, UINT count
)
2082 struct d3dx_parameter
*param
= get_valid_parameter(base
, parameter
);
2084 if (param
&& count
<= param
->element_count
)
2088 switch (param
->class)
2090 case D3DXPC_MATRIX_ROWS
:
2091 for (i
= 0; i
< count
; ++i
)
2093 set_matrix(¶m
->members
[i
], matrix
[i
]);
2103 FIXME("Unhandled class %s\n", debug_d3dxparameter_class(param
->class));
2108 WARN("Parameter not found.\n");
2110 return D3DERR_INVALIDCALL
;
2113 static HRESULT
d3dx9_base_effect_get_matrix_pointer_array(struct d3dx9_base_effect
*base
,
2114 D3DXHANDLE parameter
, D3DXMATRIX
**matrix
, UINT count
)
2116 struct d3dx_parameter
*param
= get_valid_parameter(base
, parameter
);
2118 if (!count
) return D3D_OK
;
2120 if (param
&& matrix
&& count
<= param
->element_count
)
2124 TRACE("Class %s\n", debug_d3dxparameter_class(param
->class));
2126 switch (param
->class)
2128 case D3DXPC_MATRIX_ROWS
:
2129 for (i
= 0; i
< count
; ++i
)
2131 get_matrix(¶m
->members
[i
], matrix
[i
], FALSE
);
2141 FIXME("Unhandled class %s\n", debug_d3dxparameter_class(param
->class));
2146 WARN("Parameter not found.\n");
2148 return D3DERR_INVALIDCALL
;
2151 static HRESULT
d3dx9_base_effect_set_matrix_transpose(struct d3dx9_base_effect
*base
,
2152 D3DXHANDLE parameter
, const D3DXMATRIX
*matrix
)
2154 struct d3dx_parameter
*param
= get_valid_parameter(base
, parameter
);
2156 if (param
&& !param
->element_count
)
2158 TRACE("Class %s\n", debug_d3dxparameter_class(param
->class));
2160 switch (param
->class)
2162 case D3DXPC_MATRIX_ROWS
:
2163 set_matrix_transpose(param
, matrix
);
2173 FIXME("Unhandled class %s\n", debug_d3dxparameter_class(param
->class));
2178 WARN("Parameter not found.\n");
2180 return D3DERR_INVALIDCALL
;
2183 static HRESULT
d3dx9_base_effect_get_matrix_transpose(struct d3dx9_base_effect
*base
,
2184 D3DXHANDLE parameter
, D3DXMATRIX
*matrix
)
2186 struct d3dx_parameter
*param
= get_valid_parameter(base
, parameter
);
2188 if (matrix
&& param
&& !param
->element_count
)
2190 TRACE("Class %s\n", debug_d3dxparameter_class(param
->class));
2192 switch (param
->class)
2196 get_matrix(param
, matrix
, FALSE
);
2199 case D3DXPC_MATRIX_ROWS
:
2200 get_matrix(param
, matrix
, TRUE
);
2208 FIXME("Unhandled class %s\n", debug_d3dxparameter_class(param
->class));
2213 WARN("Parameter not found.\n");
2215 return D3DERR_INVALIDCALL
;
2218 static HRESULT
d3dx9_base_effect_set_matrix_transpose_array(struct d3dx9_base_effect
*base
,
2219 D3DXHANDLE parameter
, const D3DXMATRIX
*matrix
, UINT count
)
2221 struct d3dx_parameter
*param
= get_valid_parameter(base
, parameter
);
2223 if (param
&& param
->element_count
>= count
)
2227 TRACE("Class %s\n", debug_d3dxparameter_class(param
->class));
2229 switch (param
->class)
2231 case D3DXPC_MATRIX_ROWS
:
2232 for (i
= 0; i
< count
; ++i
)
2234 set_matrix_transpose(¶m
->members
[i
], &matrix
[i
]);
2245 FIXME("Unhandled class %s\n", debug_d3dxparameter_class(param
->class));
2250 WARN("Parameter not found.\n");
2252 return D3DERR_INVALIDCALL
;
2255 static HRESULT
d3dx9_base_effect_get_matrix_transpose_array(struct d3dx9_base_effect
*base
,
2256 D3DXHANDLE parameter
, D3DXMATRIX
*matrix
, UINT count
)
2258 struct d3dx_parameter
*param
= get_valid_parameter(base
, parameter
);
2260 if (!count
) return D3D_OK
;
2262 if (matrix
&& param
&& count
<= param
->element_count
)
2266 TRACE("Class %s\n", debug_d3dxparameter_class(param
->class));
2268 switch (param
->class)
2270 case D3DXPC_MATRIX_ROWS
:
2271 for (i
= 0; i
< count
; ++i
)
2273 get_matrix(¶m
->members
[i
], &matrix
[i
], TRUE
);
2284 FIXME("Unhandled class %s\n", debug_d3dxparameter_class(param
->class));
2289 WARN("Parameter not found.\n");
2291 return D3DERR_INVALIDCALL
;
2294 static HRESULT
d3dx9_base_effect_set_matrix_transpose_pointer_array(struct d3dx9_base_effect
*base
,
2295 D3DXHANDLE parameter
, const D3DXMATRIX
**matrix
, UINT count
)
2297 struct d3dx_parameter
*param
= get_valid_parameter(base
, parameter
);
2299 if (param
&& count
<= param
->element_count
)
2303 switch (param
->class)
2305 case D3DXPC_MATRIX_ROWS
:
2306 for (i
= 0; i
< count
; ++i
)
2308 set_matrix_transpose(¶m
->members
[i
], matrix
[i
]);
2318 FIXME("Unhandled class %s\n", debug_d3dxparameter_class(param
->class));
2323 WARN("Parameter not found.\n");
2325 return D3DERR_INVALIDCALL
;
2328 static HRESULT
d3dx9_base_effect_get_matrix_transpose_pointer_array(struct d3dx9_base_effect
*base
,
2329 D3DXHANDLE parameter
, D3DXMATRIX
**matrix
, UINT count
)
2331 struct d3dx_parameter
*param
= get_valid_parameter(base
, parameter
);
2333 if (!count
) return D3D_OK
;
2335 if (matrix
&& param
&& count
<= param
->element_count
)
2339 TRACE("Class %s\n", debug_d3dxparameter_class(param
->class));
2341 switch (param
->class)
2343 case D3DXPC_MATRIX_ROWS
:
2344 for (i
= 0; i
< count
; ++i
)
2346 get_matrix(¶m
->members
[i
], matrix
[i
], TRUE
);
2356 FIXME("Unhandled class %s\n", debug_d3dxparameter_class(param
->class));
2361 WARN("Parameter not found.\n");
2363 return D3DERR_INVALIDCALL
;
2366 static HRESULT
d3dx9_base_effect_set_string(struct d3dx9_base_effect
*base
,
2367 D3DXHANDLE parameter
, const char *string
)
2374 static HRESULT
d3dx9_base_effect_get_string(struct d3dx9_base_effect
*base
,
2375 D3DXHANDLE parameter
, const char **string
)
2377 struct d3dx_parameter
*param
= get_valid_parameter(base
, parameter
);
2379 if (string
&& param
&& !param
->element_count
&& param
->type
== D3DXPT_STRING
)
2381 *string
= *(const char **)param
->data
;
2382 TRACE("Returning %s.\n", debugstr_a(*string
));
2386 WARN("Parameter not found.\n");
2388 return D3DERR_INVALIDCALL
;
2391 static HRESULT
d3dx9_base_effect_set_texture(struct d3dx9_base_effect
*base
,
2392 D3DXHANDLE parameter
, struct IDirect3DBaseTexture9
*texture
)
2394 struct d3dx_parameter
*param
= get_valid_parameter(base
, parameter
);
2396 if (param
&& !param
->element_count
&&
2397 (param
->type
== D3DXPT_TEXTURE
|| param
->type
== D3DXPT_TEXTURE1D
2398 || param
->type
== D3DXPT_TEXTURE2D
|| param
->type
== D3DXPT_TEXTURE3D
2399 || param
->type
== D3DXPT_TEXTURECUBE
))
2401 struct IDirect3DBaseTexture9
*oltexture
= *(struct IDirect3DBaseTexture9
**)param
->data
;
2403 if (texture
== oltexture
)
2406 if (texture
) IDirect3DBaseTexture9_AddRef(texture
);
2407 if (oltexture
) IDirect3DBaseTexture9_Release(oltexture
);
2409 *(struct IDirect3DBaseTexture9
**)param
->data
= texture
;
2414 WARN("Parameter not found.\n");
2416 return D3DERR_INVALIDCALL
;
2419 static HRESULT
d3dx9_base_effect_get_texture(struct d3dx9_base_effect
*base
,
2420 D3DXHANDLE parameter
, struct IDirect3DBaseTexture9
**texture
)
2422 struct d3dx_parameter
*param
= get_valid_parameter(base
, parameter
);
2424 if (texture
&& param
&& !param
->element_count
&&
2425 (param
->type
== D3DXPT_TEXTURE
|| param
->type
== D3DXPT_TEXTURE1D
2426 || param
->type
== D3DXPT_TEXTURE2D
|| param
->type
== D3DXPT_TEXTURE3D
2427 || param
->type
== D3DXPT_TEXTURECUBE
))
2429 *texture
= *(struct IDirect3DBaseTexture9
**)param
->data
;
2430 if (*texture
) IDirect3DBaseTexture9_AddRef(*texture
);
2431 TRACE("Returning %p\n", *texture
);
2435 WARN("Parameter not found.\n");
2437 return D3DERR_INVALIDCALL
;
2440 static HRESULT
d3dx9_base_effect_get_pixel_shader(struct d3dx9_base_effect
*base
,
2441 D3DXHANDLE parameter
, struct IDirect3DPixelShader9
**shader
)
2443 struct d3dx_parameter
*param
= get_valid_parameter(base
, parameter
);
2445 if (shader
&& param
&& !param
->element_count
&& param
->type
== D3DXPT_PIXELSHADER
)
2447 if ((*shader
= *(struct IDirect3DPixelShader9
**)param
->data
))
2448 IDirect3DPixelShader9_AddRef(*shader
);
2449 TRACE("Returning %p.\n", *shader
);
2453 WARN("Parameter not found.\n");
2455 return D3DERR_INVALIDCALL
;
2458 static HRESULT
d3dx9_base_effect_get_vertex_shader(struct d3dx9_base_effect
*base
,
2459 D3DXHANDLE parameter
, struct IDirect3DVertexShader9
**shader
)
2461 struct d3dx_parameter
*param
= get_valid_parameter(base
, parameter
);
2463 if (shader
&& param
&& !param
->element_count
&& param
->type
== D3DXPT_VERTEXSHADER
)
2465 if ((*shader
= *(struct IDirect3DVertexShader9
**)param
->data
))
2466 IDirect3DVertexShader9_AddRef(*shader
);
2467 TRACE("Returning %p.\n", *shader
);
2471 WARN("Parameter not found.\n");
2473 return D3DERR_INVALIDCALL
;
2476 static HRESULT
d3dx9_base_effect_set_array_range(struct d3dx9_base_effect
*base
,
2477 D3DXHANDLE parameter
, UINT start
, UINT end
)
2484 static inline struct ID3DXEffectImpl
*impl_from_ID3DXEffect(ID3DXEffect
*iface
)
2486 return CONTAINING_RECORD(iface
, struct ID3DXEffectImpl
, ID3DXEffect_iface
);
2489 /*** IUnknown methods ***/
2490 static HRESULT WINAPI
ID3DXEffectImpl_QueryInterface(ID3DXEffect
*iface
, REFIID riid
, void **object
)
2492 TRACE("(%p)->(%s, %p)\n", iface
, debugstr_guid(riid
), object
);
2494 if (IsEqualGUID(riid
, &IID_IUnknown
) ||
2495 IsEqualGUID(riid
, &IID_ID3DXEffect
))
2497 iface
->lpVtbl
->AddRef(iface
);
2502 ERR("Interface %s not found\n", debugstr_guid(riid
));
2504 return E_NOINTERFACE
;
2507 static ULONG WINAPI
ID3DXEffectImpl_AddRef(ID3DXEffect
*iface
)
2509 struct ID3DXEffectImpl
*This
= impl_from_ID3DXEffect(iface
);
2511 TRACE("(%p)->(): AddRef from %u\n", This
, This
->ref
);
2513 return InterlockedIncrement(&This
->ref
);
2516 static ULONG WINAPI
ID3DXEffectImpl_Release(ID3DXEffect
*iface
)
2518 struct ID3DXEffectImpl
*This
= impl_from_ID3DXEffect(iface
);
2519 ULONG ref
= InterlockedDecrement(&This
->ref
);
2521 TRACE("(%p)->(): Release from %u\n", This
, ref
+ 1);
2526 HeapFree(GetProcessHeap(), 0, This
);
2532 /*** ID3DXBaseEffect methods ***/
2533 static HRESULT WINAPI
ID3DXEffectImpl_GetDesc(ID3DXEffect
*iface
, D3DXEFFECT_DESC
*desc
)
2535 struct ID3DXEffectImpl
*effect
= impl_from_ID3DXEffect(iface
);
2537 TRACE("iface %p, desc %p.\n", iface
, desc
);
2539 return d3dx9_base_effect_get_desc(&effect
->base_effect
, desc
);
2542 static HRESULT WINAPI
ID3DXEffectImpl_GetParameterDesc(ID3DXEffect
*iface
,
2543 D3DXHANDLE parameter
, D3DXPARAMETER_DESC
*desc
)
2545 struct ID3DXEffectImpl
*effect
= impl_from_ID3DXEffect(iface
);
2547 TRACE("iface %p, parameter %p, desc %p.\n", iface
, parameter
, desc
);
2549 return d3dx9_base_effect_get_parameter_desc(&effect
->base_effect
, parameter
, desc
);
2552 static HRESULT WINAPI
ID3DXEffectImpl_GetTechniqueDesc(ID3DXEffect
*iface
,
2553 D3DXHANDLE technique
, D3DXTECHNIQUE_DESC
*desc
)
2555 struct ID3DXEffectImpl
*effect
= impl_from_ID3DXEffect(iface
);
2557 TRACE("iface %p, technique %p, desc %p.\n", iface
, technique
, desc
);
2559 return d3dx9_base_effect_get_technique_desc(&effect
->base_effect
, technique
, desc
);
2562 static HRESULT WINAPI
ID3DXEffectImpl_GetPassDesc(ID3DXEffect
*iface
, D3DXHANDLE pass
, D3DXPASS_DESC
*desc
)
2564 struct ID3DXEffectImpl
*effect
= impl_from_ID3DXEffect(iface
);
2566 TRACE("iface %p, pass %p, desc %p.\n", iface
, pass
, desc
);
2568 return d3dx9_base_effect_get_pass_desc(&effect
->base_effect
, pass
, desc
);
2571 static HRESULT WINAPI
ID3DXEffectImpl_GetFunctionDesc(ID3DXEffect
*iface
, D3DXHANDLE shader
, D3DXFUNCTION_DESC
*desc
)
2573 struct ID3DXEffectImpl
*effect
= impl_from_ID3DXEffect(iface
);
2575 TRACE("iface %p, shader %p, desc %p.\n", iface
, shader
, desc
);
2577 return d3dx9_base_effect_get_function_desc(&effect
->base_effect
, shader
, desc
);
2580 static D3DXHANDLE WINAPI
ID3DXEffectImpl_GetParameter(ID3DXEffect
*iface
, D3DXHANDLE parameter
, UINT index
)
2582 struct ID3DXEffectImpl
*effect
= impl_from_ID3DXEffect(iface
);
2584 TRACE("iface %p, parameter %p, index %u.\n", iface
, parameter
, index
);
2586 return d3dx9_base_effect_get_parameter(&effect
->base_effect
, parameter
, index
);
2589 static D3DXHANDLE WINAPI
ID3DXEffectImpl_GetParameterByName(ID3DXEffect
*iface
,
2590 D3DXHANDLE parameter
, const char *name
)
2592 struct ID3DXEffectImpl
*effect
= impl_from_ID3DXEffect(iface
);
2594 TRACE("iface %p, parameter %p, name %s.\n", iface
, parameter
, debugstr_a(name
));
2596 return d3dx9_base_effect_get_parameter_by_name(&effect
->base_effect
, parameter
, name
);
2599 static D3DXHANDLE WINAPI
ID3DXEffectImpl_GetParameterBySemantic(ID3DXEffect
*iface
,
2600 D3DXHANDLE parameter
, const char *semantic
)
2602 struct ID3DXEffectImpl
*effect
= impl_from_ID3DXEffect(iface
);
2604 TRACE("iface %p, parameter %p, semantic %s.\n", iface
, parameter
, debugstr_a(semantic
));
2606 return d3dx9_base_effect_get_parameter_by_semantic(&effect
->base_effect
, parameter
, semantic
);
2609 static D3DXHANDLE WINAPI
ID3DXEffectImpl_GetParameterElement(ID3DXEffect
*iface
, D3DXHANDLE parameter
, UINT index
)
2611 struct ID3DXEffectImpl
*effect
= impl_from_ID3DXEffect(iface
);
2613 TRACE("iface %p, parameter %p, index %u.\n", iface
, parameter
, index
);
2615 return d3dx9_base_effect_get_parameter_element(&effect
->base_effect
, parameter
, index
);
2618 static D3DXHANDLE WINAPI
ID3DXEffectImpl_GetTechnique(ID3DXEffect
*iface
, UINT index
)
2620 struct ID3DXEffectImpl
*effect
= impl_from_ID3DXEffect(iface
);
2622 TRACE("iface %p, index %u.\n", iface
, index
);
2624 return d3dx9_base_effect_get_technique(&effect
->base_effect
, index
);
2627 static D3DXHANDLE WINAPI
ID3DXEffectImpl_GetTechniqueByName(ID3DXEffect
*iface
, const char *name
)
2629 struct ID3DXEffectImpl
*effect
= impl_from_ID3DXEffect(iface
);
2631 TRACE("iface %p, name %s.\n", iface
, debugstr_a(name
));
2633 return d3dx9_base_effect_get_technique_by_name(&effect
->base_effect
, name
);
2636 static D3DXHANDLE WINAPI
ID3DXEffectImpl_GetPass(ID3DXEffect
*iface
, D3DXHANDLE technique
, UINT index
)
2638 struct ID3DXEffectImpl
*effect
= impl_from_ID3DXEffect(iface
);
2640 TRACE("iface %p, technique %p, index %u.\n", iface
, technique
, index
);
2642 return d3dx9_base_effect_get_pass(&effect
->base_effect
, technique
, index
);
2645 static D3DXHANDLE WINAPI
ID3DXEffectImpl_GetPassByName(ID3DXEffect
*iface
,
2646 D3DXHANDLE technique
, const char *name
)
2648 struct ID3DXEffectImpl
*effect
= impl_from_ID3DXEffect(iface
);
2650 TRACE("iface %p, technique %p, name %s.\n", iface
, technique
, debugstr_a(name
));
2652 return d3dx9_base_effect_get_pass_by_name(&effect
->base_effect
, technique
, name
);
2655 static D3DXHANDLE WINAPI
ID3DXEffectImpl_GetFunction(ID3DXEffect
*iface
, UINT index
)
2657 struct ID3DXEffectImpl
*effect
= impl_from_ID3DXEffect(iface
);
2659 TRACE("iface %p, index %u.\n", iface
, index
);
2661 return d3dx9_base_effect_get_function(&effect
->base_effect
, index
);
2664 static D3DXHANDLE WINAPI
ID3DXEffectImpl_GetFunctionByName(ID3DXEffect
*iface
, const char *name
)
2666 struct ID3DXEffectImpl
*effect
= impl_from_ID3DXEffect(iface
);
2668 TRACE("iface %p, name %s.\n", iface
, debugstr_a(name
));
2670 return d3dx9_base_effect_get_function_by_name(&effect
->base_effect
, name
);
2673 static D3DXHANDLE WINAPI
ID3DXEffectImpl_GetAnnotation(ID3DXEffect
*iface
, D3DXHANDLE object
, UINT index
)
2675 struct ID3DXEffectImpl
*effect
= impl_from_ID3DXEffect(iface
);
2677 TRACE("iface %p, object %p, index %u.\n", iface
, object
, index
);
2679 return d3dx9_base_effect_get_annotation(&effect
->base_effect
, object
, index
);
2682 static D3DXHANDLE WINAPI
ID3DXEffectImpl_GetAnnotationByName(ID3DXEffect
*iface
,
2683 D3DXHANDLE object
, const char *name
)
2685 struct ID3DXEffectImpl
*effect
= impl_from_ID3DXEffect(iface
);
2687 TRACE("iface %p, object %p, name %s.\n", iface
, object
, debugstr_a(name
));
2689 return d3dx9_base_effect_get_annotation_by_name(&effect
->base_effect
, object
, name
);
2692 static HRESULT WINAPI
ID3DXEffectImpl_SetValue(ID3DXEffect
*iface
,
2693 D3DXHANDLE parameter
, const void *data
, UINT bytes
)
2695 struct ID3DXEffectImpl
*effect
= impl_from_ID3DXEffect(iface
);
2697 TRACE("iface %p, parameter %p, data %p, bytes %u.\n", iface
, parameter
, data
, bytes
);
2699 return d3dx9_base_effect_set_value(&effect
->base_effect
, parameter
, data
, bytes
);
2702 static HRESULT WINAPI
ID3DXEffectImpl_GetValue(ID3DXEffect
*iface
,
2703 D3DXHANDLE parameter
, void *data
, UINT bytes
)
2705 struct ID3DXEffectImpl
*effect
= impl_from_ID3DXEffect(iface
);
2707 TRACE("iface %p, parameter %p, data %p, bytes %u.\n", iface
, parameter
, data
, bytes
);
2709 return d3dx9_base_effect_get_value(&effect
->base_effect
, parameter
, data
, bytes
);
2712 static HRESULT WINAPI
ID3DXEffectImpl_SetBool(ID3DXEffect
*iface
, D3DXHANDLE parameter
, BOOL b
)
2714 struct ID3DXEffectImpl
*effect
= impl_from_ID3DXEffect(iface
);
2716 TRACE("iface %p, parameter %p, b %#x.\n", iface
, parameter
, b
);
2718 return d3dx9_base_effect_set_bool(&effect
->base_effect
, parameter
, b
);
2721 static HRESULT WINAPI
ID3DXEffectImpl_GetBool(ID3DXEffect
*iface
, D3DXHANDLE parameter
, BOOL
*b
)
2723 struct ID3DXEffectImpl
*effect
= impl_from_ID3DXEffect(iface
);
2725 TRACE("iface %p, parameter %p, b %p.\n", iface
, parameter
, b
);
2727 return d3dx9_base_effect_get_bool(&effect
->base_effect
, parameter
, b
);
2730 static HRESULT WINAPI
ID3DXEffectImpl_SetBoolArray(ID3DXEffect
*iface
,
2731 D3DXHANDLE parameter
, const BOOL
*b
, UINT count
)
2733 struct ID3DXEffectImpl
*effect
= impl_from_ID3DXEffect(iface
);
2735 TRACE("iface %p, parameter %p, b %p, count %u.\n", iface
, parameter
, b
, count
);
2737 return d3dx9_base_effect_set_bool_array(&effect
->base_effect
, parameter
, b
, count
);
2740 static HRESULT WINAPI
ID3DXEffectImpl_GetBoolArray(ID3DXEffect
*iface
,
2741 D3DXHANDLE parameter
, BOOL
*b
, UINT count
)
2743 struct ID3DXEffectImpl
*effect
= impl_from_ID3DXEffect(iface
);
2745 TRACE("iface %p, parameter %p, b %p, count %u.\n", iface
, parameter
, b
, count
);
2747 return d3dx9_base_effect_get_bool_array(&effect
->base_effect
, parameter
, b
, count
);
2750 static HRESULT WINAPI
ID3DXEffectImpl_SetInt(ID3DXEffect
*iface
, D3DXHANDLE parameter
, INT n
)
2752 struct ID3DXEffectImpl
*effect
= impl_from_ID3DXEffect(iface
);
2754 TRACE("iface %p, parameter %p, n %d.\n", iface
, parameter
, n
);
2756 return d3dx9_base_effect_set_int(&effect
->base_effect
, parameter
, n
);
2759 static HRESULT WINAPI
ID3DXEffectImpl_GetInt(ID3DXEffect
*iface
, D3DXHANDLE parameter
, INT
*n
)
2761 struct ID3DXEffectImpl
*effect
= impl_from_ID3DXEffect(iface
);
2763 TRACE("iface %p, parameter %p, n %p.\n", iface
, parameter
, n
);
2765 return d3dx9_base_effect_get_int(&effect
->base_effect
, parameter
, n
);
2768 static HRESULT WINAPI
ID3DXEffectImpl_SetIntArray(ID3DXEffect
*iface
,
2769 D3DXHANDLE parameter
, const INT
*n
, UINT count
)
2771 struct ID3DXEffectImpl
*effect
= impl_from_ID3DXEffect(iface
);
2773 TRACE("iface %p, parameter %p, n %p, count %u.\n", iface
, parameter
, n
, count
);
2775 return d3dx9_base_effect_set_int_array(&effect
->base_effect
, parameter
, n
, count
);
2778 static HRESULT WINAPI
ID3DXEffectImpl_GetIntArray(ID3DXEffect
*iface
,
2779 D3DXHANDLE parameter
, INT
*n
, UINT count
)
2781 struct ID3DXEffectImpl
*effect
= impl_from_ID3DXEffect(iface
);
2783 TRACE("iface %p, parameter %p, n %p, count %u.\n", iface
, parameter
, n
, count
);
2785 return d3dx9_base_effect_get_int_array(&effect
->base_effect
, parameter
, n
, count
);
2788 static HRESULT WINAPI
ID3DXEffectImpl_SetFloat(ID3DXEffect
*iface
, D3DXHANDLE parameter
, float f
)
2790 struct ID3DXEffectImpl
*effect
= impl_from_ID3DXEffect(iface
);
2792 TRACE("iface %p, parameter %p, f %.8e.\n", iface
, parameter
, f
);
2794 return d3dx9_base_effect_set_float(&effect
->base_effect
, parameter
, f
);
2797 static HRESULT WINAPI
ID3DXEffectImpl_GetFloat(ID3DXEffect
*iface
, D3DXHANDLE parameter
, float *f
)
2799 struct ID3DXEffectImpl
*effect
= impl_from_ID3DXEffect(iface
);
2801 TRACE("iface %p, parameter %p, f %p.\n", iface
, parameter
, f
);
2803 return d3dx9_base_effect_get_float(&effect
->base_effect
, parameter
, f
);
2806 static HRESULT WINAPI
ID3DXEffectImpl_SetFloatArray(ID3DXEffect
*iface
,
2807 D3DXHANDLE parameter
, const float *f
, UINT count
)
2809 struct ID3DXEffectImpl
*effect
= impl_from_ID3DXEffect(iface
);
2811 TRACE("iface %p, parameter %p, f %p, count %u.\n", iface
, parameter
, f
, count
);
2813 return d3dx9_base_effect_set_float_array(&effect
->base_effect
, parameter
, f
, count
);
2816 static HRESULT WINAPI
ID3DXEffectImpl_GetFloatArray(ID3DXEffect
*iface
,
2817 D3DXHANDLE parameter
, float *f
, UINT count
)
2819 struct ID3DXEffectImpl
*effect
= impl_from_ID3DXEffect(iface
);
2821 TRACE("iface %p, parameter %p, f %p, count %u.\n", iface
, parameter
, f
, count
);
2823 return d3dx9_base_effect_get_float_array(&effect
->base_effect
, parameter
, f
, count
);
2826 static HRESULT WINAPI
ID3DXEffectImpl_SetVector(ID3DXEffect
*iface
,
2827 D3DXHANDLE parameter
, const D3DXVECTOR4
*vector
)
2829 struct ID3DXEffectImpl
*effect
= impl_from_ID3DXEffect(iface
);
2831 TRACE("iface %p, parameter %p, vector %p.\n", iface
, parameter
, vector
);
2833 return d3dx9_base_effect_set_vector(&effect
->base_effect
, parameter
, vector
);
2836 static HRESULT WINAPI
ID3DXEffectImpl_GetVector(ID3DXEffect
*iface
,
2837 D3DXHANDLE parameter
, D3DXVECTOR4
*vector
)
2839 struct ID3DXEffectImpl
*effect
= impl_from_ID3DXEffect(iface
);
2841 TRACE("iface %p, parameter %p, vector %p.\n", iface
, parameter
, vector
);
2843 return d3dx9_base_effect_get_vector(&effect
->base_effect
, parameter
, vector
);
2846 static HRESULT WINAPI
ID3DXEffectImpl_SetVectorArray(ID3DXEffect
*iface
,
2847 D3DXHANDLE parameter
, const D3DXVECTOR4
*vector
, UINT count
)
2849 struct ID3DXEffectImpl
*effect
= impl_from_ID3DXEffect(iface
);
2851 TRACE("iface %p, parameter %p, vector %p, count %u.\n", iface
, parameter
, vector
, count
);
2853 return d3dx9_base_effect_set_vector_array(&effect
->base_effect
, parameter
, vector
, count
);
2856 static HRESULT WINAPI
ID3DXEffectImpl_GetVectorArray(ID3DXEffect
*iface
,
2857 D3DXHANDLE parameter
, D3DXVECTOR4
*vector
, UINT count
)
2859 struct ID3DXEffectImpl
*effect
= impl_from_ID3DXEffect(iface
);
2861 TRACE("iface %p, parameter %p, vector %p, count %u.\n", iface
, parameter
, vector
, count
);
2863 return d3dx9_base_effect_get_vector_array(&effect
->base_effect
, parameter
, vector
, count
);
2866 static HRESULT WINAPI
ID3DXEffectImpl_SetMatrix(ID3DXEffect
*iface
,
2867 D3DXHANDLE parameter
, const D3DXMATRIX
*matrix
)
2869 struct ID3DXEffectImpl
*effect
= impl_from_ID3DXEffect(iface
);
2871 TRACE("iface %p, parameter %p, matrix %p.\n", iface
, parameter
, matrix
);
2873 return d3dx9_base_effect_set_matrix(&effect
->base_effect
, parameter
, matrix
);
2876 static HRESULT WINAPI
ID3DXEffectImpl_GetMatrix(ID3DXEffect
*iface
,
2877 D3DXHANDLE parameter
, D3DXMATRIX
*matrix
)
2879 struct ID3DXEffectImpl
*effect
= impl_from_ID3DXEffect(iface
);
2881 TRACE("iface %p, parameter %p, matrix %p.\n", iface
, parameter
, matrix
);
2883 return d3dx9_base_effect_get_matrix(&effect
->base_effect
, parameter
, matrix
);
2886 static HRESULT WINAPI
ID3DXEffectImpl_SetMatrixArray(ID3DXEffect
*iface
,
2887 D3DXHANDLE parameter
, const D3DXMATRIX
*matrix
, UINT count
)
2889 struct ID3DXEffectImpl
*effect
= impl_from_ID3DXEffect(iface
);
2891 TRACE("iface %p, parameter %p, matrix %p, count %u.\n", iface
, parameter
, matrix
, count
);
2893 return d3dx9_base_effect_set_matrix_array(&effect
->base_effect
, parameter
, matrix
, count
);
2896 static HRESULT WINAPI
ID3DXEffectImpl_GetMatrixArray(ID3DXEffect
*iface
,
2897 D3DXHANDLE parameter
, D3DXMATRIX
*matrix
, UINT count
)
2899 struct ID3DXEffectImpl
*effect
= impl_from_ID3DXEffect(iface
);
2901 TRACE("iface %p, parameter %p, matrix %p, count %u.\n", iface
, parameter
, matrix
, count
);
2903 return d3dx9_base_effect_get_matrix_array(&effect
->base_effect
, parameter
, matrix
, count
);
2906 static HRESULT WINAPI
ID3DXEffectImpl_SetMatrixPointerArray(ID3DXEffect
*iface
,
2907 D3DXHANDLE parameter
, const D3DXMATRIX
**matrix
, UINT count
)
2909 struct ID3DXEffectImpl
*effect
= impl_from_ID3DXEffect(iface
);
2911 TRACE("iface %p, parameter %p, matrix %p, count %u.\n", iface
, parameter
, matrix
, count
);
2913 return d3dx9_base_effect_set_matrix_pointer_array(&effect
->base_effect
, parameter
, matrix
, count
);
2916 static HRESULT WINAPI
ID3DXEffectImpl_GetMatrixPointerArray(ID3DXEffect
*iface
,
2917 D3DXHANDLE parameter
, D3DXMATRIX
**matrix
, UINT count
)
2919 struct ID3DXEffectImpl
*effect
= impl_from_ID3DXEffect(iface
);
2921 TRACE("iface %p, parameter %p, matrix %p, count %u.\n", iface
, parameter
, matrix
, count
);
2923 return d3dx9_base_effect_get_matrix_pointer_array(&effect
->base_effect
, parameter
, matrix
, count
);
2926 static HRESULT WINAPI
ID3DXEffectImpl_SetMatrixTranspose(ID3DXEffect
*iface
,
2927 D3DXHANDLE parameter
, const D3DXMATRIX
*matrix
)
2929 struct ID3DXEffectImpl
*effect
= impl_from_ID3DXEffect(iface
);
2931 TRACE("iface %p, parameter %p, matrix %p.\n", iface
, parameter
, matrix
);
2933 return d3dx9_base_effect_set_matrix_transpose(&effect
->base_effect
, parameter
, matrix
);
2936 static HRESULT WINAPI
ID3DXEffectImpl_GetMatrixTranspose(ID3DXEffect
*iface
,
2937 D3DXHANDLE parameter
, D3DXMATRIX
*matrix
)
2939 struct ID3DXEffectImpl
*effect
= impl_from_ID3DXEffect(iface
);
2941 TRACE("iface %p, parameter %p, matrix %p.\n", iface
, parameter
, matrix
);
2943 return d3dx9_base_effect_get_matrix_transpose(&effect
->base_effect
, parameter
, matrix
);
2946 static HRESULT WINAPI
ID3DXEffectImpl_SetMatrixTransposeArray(ID3DXEffect
*iface
,
2947 D3DXHANDLE parameter
, const D3DXMATRIX
*matrix
, UINT count
)
2949 struct ID3DXEffectImpl
*effect
= impl_from_ID3DXEffect(iface
);
2951 TRACE("iface %p, parameter %p, matrix %p, count %u.\n", iface
, parameter
, matrix
, count
);
2953 return d3dx9_base_effect_set_matrix_transpose_array(&effect
->base_effect
, parameter
, matrix
, count
);
2956 static HRESULT WINAPI
ID3DXEffectImpl_GetMatrixTransposeArray(ID3DXEffect
*iface
,
2957 D3DXHANDLE parameter
, D3DXMATRIX
*matrix
, UINT count
)
2959 struct ID3DXEffectImpl
*effect
= impl_from_ID3DXEffect(iface
);
2961 TRACE("iface %p, parameter %p, matrix %p, count %u.\n", iface
, parameter
, matrix
, count
);
2963 return d3dx9_base_effect_get_matrix_transpose_array(&effect
->base_effect
, parameter
, matrix
, count
);
2966 static HRESULT WINAPI
ID3DXEffectImpl_SetMatrixTransposePointerArray(ID3DXEffect
*iface
,
2967 D3DXHANDLE parameter
, const D3DXMATRIX
**matrix
, UINT count
)
2969 struct ID3DXEffectImpl
*effect
= impl_from_ID3DXEffect(iface
);
2971 TRACE("iface %p, parameter %p, matrix %p, count %u.\n", iface
, parameter
, matrix
, count
);
2973 return d3dx9_base_effect_set_matrix_transpose_pointer_array(&effect
->base_effect
, parameter
, matrix
, count
);
2976 static HRESULT WINAPI
ID3DXEffectImpl_GetMatrixTransposePointerArray(ID3DXEffect
*iface
,
2977 D3DXHANDLE parameter
, D3DXMATRIX
**matrix
, UINT count
)
2979 struct ID3DXEffectImpl
*effect
= impl_from_ID3DXEffect(iface
);
2981 TRACE("iface %p, parameter %p, matrix %p, count %u.\n", iface
, parameter
, matrix
, count
);
2983 return d3dx9_base_effect_get_matrix_transpose_pointer_array(&effect
->base_effect
, parameter
, matrix
, count
);
2986 static HRESULT WINAPI
ID3DXEffectImpl_SetString(ID3DXEffect
*iface
, D3DXHANDLE parameter
, const char *string
)
2988 struct ID3DXEffectImpl
*effect
= impl_from_ID3DXEffect(iface
);
2990 TRACE("iface %p, parameter %p, string %s.\n", iface
, parameter
, debugstr_a(string
));
2992 return d3dx9_base_effect_set_string(&effect
->base_effect
, parameter
, string
);
2995 static HRESULT WINAPI
ID3DXEffectImpl_GetString(ID3DXEffect
*iface
, D3DXHANDLE parameter
, const char **string
)
2997 struct ID3DXEffectImpl
*effect
= impl_from_ID3DXEffect(iface
);
2999 TRACE("iface %p, parameter %p, string %p.\n", iface
, parameter
, string
);
3001 return d3dx9_base_effect_get_string(&effect
->base_effect
, parameter
, string
);
3004 static HRESULT WINAPI
ID3DXEffectImpl_SetTexture(struct ID3DXEffect
*iface
,
3005 D3DXHANDLE parameter
, struct IDirect3DBaseTexture9
*texture
)
3007 struct ID3DXEffectImpl
*effect
= impl_from_ID3DXEffect(iface
);
3009 TRACE("iface %p, parameter %p, texture %p.\n", iface
, parameter
, texture
);
3011 return d3dx9_base_effect_set_texture(&effect
->base_effect
, parameter
, texture
);
3014 static HRESULT WINAPI
ID3DXEffectImpl_GetTexture(struct ID3DXEffect
*iface
,
3015 D3DXHANDLE parameter
, struct IDirect3DBaseTexture9
**texture
)
3017 struct ID3DXEffectImpl
*effect
= impl_from_ID3DXEffect(iface
);
3019 TRACE("iface %p, parameter %p, texture %p.\n", iface
, parameter
, texture
);
3021 return d3dx9_base_effect_get_texture(&effect
->base_effect
, parameter
, texture
);
3024 static HRESULT WINAPI
ID3DXEffectImpl_GetPixelShader(ID3DXEffect
*iface
,
3025 D3DXHANDLE parameter
, struct IDirect3DPixelShader9
**shader
)
3027 struct ID3DXEffectImpl
*effect
= impl_from_ID3DXEffect(iface
);
3029 TRACE("iface %p, parameter %p, shader %p.\n", iface
, parameter
, shader
);
3031 return d3dx9_base_effect_get_pixel_shader(&effect
->base_effect
, parameter
, shader
);
3034 static HRESULT WINAPI
ID3DXEffectImpl_GetVertexShader(struct ID3DXEffect
*iface
,
3035 D3DXHANDLE parameter
, struct IDirect3DVertexShader9
**shader
)
3037 struct ID3DXEffectImpl
*effect
= impl_from_ID3DXEffect(iface
);
3039 TRACE("iface %p, parameter %p, shader %p.\n", iface
, parameter
, shader
);
3041 return d3dx9_base_effect_get_vertex_shader(&effect
->base_effect
, parameter
, shader
);
3044 static HRESULT WINAPI
ID3DXEffectImpl_SetArrayRange(ID3DXEffect
*iface
, D3DXHANDLE parameter
, UINT start
, UINT end
)
3046 struct ID3DXEffectImpl
*effect
= impl_from_ID3DXEffect(iface
);
3048 TRACE("iface %p, parameter %p, start %u, end %u.\n", iface
, parameter
, start
, end
);
3050 return d3dx9_base_effect_set_array_range(&effect
->base_effect
, parameter
, start
, end
);
3053 /*** ID3DXEffect methods ***/
3054 static HRESULT WINAPI
ID3DXEffectImpl_GetPool(ID3DXEffect
*iface
, ID3DXEffectPool
**pool
)
3056 struct ID3DXEffectImpl
*This
= impl_from_ID3DXEffect(iface
);
3058 TRACE("iface %p, pool %p\n", This
, pool
);
3062 WARN("Invalid argument supplied.\n");
3063 return D3DERR_INVALIDCALL
;
3068 This
->pool
->lpVtbl
->AddRef(This
->pool
);
3073 TRACE("Returning pool %p\n", *pool
);
3078 static HRESULT WINAPI
ID3DXEffectImpl_SetTechnique(ID3DXEffect
*iface
, D3DXHANDLE technique
)
3080 struct ID3DXEffectImpl
*This
= impl_from_ID3DXEffect(iface
);
3081 struct d3dx9_base_effect
*base
= &This
->base_effect
;
3082 struct d3dx_technique
*tech
= get_valid_technique(base
, technique
);
3084 TRACE("iface %p, technique %p\n", This
, technique
);
3088 This
->active_technique
= tech
;
3089 TRACE("Technique %p\n", tech
);
3093 WARN("Technique not found.\n");
3095 return D3DERR_INVALIDCALL
;
3098 static D3DXHANDLE WINAPI
ID3DXEffectImpl_GetCurrentTechnique(ID3DXEffect
*iface
)
3100 struct ID3DXEffectImpl
*This
= impl_from_ID3DXEffect(iface
);
3102 TRACE("iface %p\n", This
);
3104 return get_technique_handle(This
->active_technique
);
3107 static HRESULT WINAPI
ID3DXEffectImpl_ValidateTechnique(ID3DXEffect
* iface
, D3DXHANDLE technique
)
3109 struct ID3DXEffectImpl
*This
= impl_from_ID3DXEffect(iface
);
3111 FIXME("(%p)->(%p): stub\n", This
, technique
);
3116 static HRESULT WINAPI
ID3DXEffectImpl_FindNextValidTechnique(ID3DXEffect
* iface
, D3DXHANDLE technique
, D3DXHANDLE
* next_technique
)
3118 struct ID3DXEffectImpl
*This
= impl_from_ID3DXEffect(iface
);
3120 FIXME("(%p)->(%p, %p): stub\n", This
, technique
, next_technique
);
3125 static BOOL WINAPI
ID3DXEffectImpl_IsParameterUsed(ID3DXEffect
* iface
, D3DXHANDLE parameter
, D3DXHANDLE technique
)
3127 struct ID3DXEffectImpl
*This
= impl_from_ID3DXEffect(iface
);
3129 FIXME("(%p)->(%p, %p): stub\n", This
, parameter
, technique
);
3134 static HRESULT WINAPI
ID3DXEffectImpl_Begin(ID3DXEffect
*iface
, UINT
*passes
, DWORD flags
)
3136 struct ID3DXEffectImpl
*This
= impl_from_ID3DXEffect(iface
);
3137 struct d3dx_technique
*technique
= This
->active_technique
;
3139 TRACE("iface %p, passes %p, flags %#x.\n", iface
, passes
, flags
);
3141 if (passes
&& technique
)
3143 if (flags
& ~(D3DXFX_DONOTSAVESTATE
| D3DXFX_DONOTSAVESAMPLERSTATE
| D3DXFX_DONOTSAVESHADERSTATE
))
3144 WARN("Invalid flags (%#x) specified.\n", flags
);
3146 if (This
->manager
|| flags
& D3DXFX_DONOTSAVESTATE
)
3148 TRACE("State capturing disabled.\n");
3152 FIXME("State capturing not supported, yet!\n");
3155 *passes
= technique
->pass_count
;
3156 This
->started
= TRUE
;
3157 This
->flags
= flags
;
3162 WARN("Invalid argument supplied.\n");
3164 return D3DERR_INVALIDCALL
;
3167 static HRESULT WINAPI
ID3DXEffectImpl_BeginPass(ID3DXEffect
*iface
, UINT pass
)
3169 struct ID3DXEffectImpl
*This
= impl_from_ID3DXEffect(iface
);
3170 struct d3dx_technique
*technique
= This
->active_technique
;
3172 TRACE("iface %p, pass %u\n", This
, pass
);
3174 if (technique
&& pass
< technique
->pass_count
&& !This
->active_pass
)
3176 This
->active_pass
= &technique
->passes
[pass
];
3178 FIXME("No states applied, yet!\n");
3183 WARN("Invalid argument supplied.\n");
3185 return D3DERR_INVALIDCALL
;
3188 static HRESULT WINAPI
ID3DXEffectImpl_CommitChanges(ID3DXEffect
* iface
)
3190 struct ID3DXEffectImpl
*This
= impl_from_ID3DXEffect(iface
);
3192 FIXME("(%p)->(): stub\n", This
);
3194 if (!This
->active_pass
)
3196 WARN("Called without an active pass.\n");
3203 static HRESULT WINAPI
ID3DXEffectImpl_EndPass(ID3DXEffect
*iface
)
3205 struct ID3DXEffectImpl
*This
= impl_from_ID3DXEffect(iface
);
3207 TRACE("iface %p\n", This
);
3209 if (This
->active_pass
)
3211 This
->active_pass
= NULL
;
3215 WARN("Invalid call.\n");
3217 return D3DERR_INVALIDCALL
;
3220 static HRESULT WINAPI
ID3DXEffectImpl_End(ID3DXEffect
*iface
)
3222 struct ID3DXEffectImpl
*This
= impl_from_ID3DXEffect(iface
);
3224 TRACE("iface %p.\n", iface
);
3229 if (This
->manager
|| This
->flags
& D3DXFX_DONOTSAVESTATE
)
3231 TRACE("State restoring disabled.\n");
3235 FIXME("State restoring not supported, yet!\n");
3238 This
->started
= FALSE
;
3243 static HRESULT WINAPI
ID3DXEffectImpl_GetDevice(ID3DXEffect
*iface
, struct IDirect3DDevice9
**device
)
3245 struct ID3DXEffectImpl
*This
= impl_from_ID3DXEffect(iface
);
3247 TRACE("iface %p, device %p\n", This
, device
);
3251 WARN("Invalid argument supplied.\n");
3252 return D3DERR_INVALIDCALL
;
3255 IDirect3DDevice9_AddRef(This
->device
);
3257 *device
= This
->device
;
3259 TRACE("Returning device %p\n", *device
);
3264 static HRESULT WINAPI
ID3DXEffectImpl_OnLostDevice(ID3DXEffect
* iface
)
3266 struct ID3DXEffectImpl
*This
= impl_from_ID3DXEffect(iface
);
3268 FIXME("(%p)->(): stub\n", This
);
3273 static HRESULT WINAPI
ID3DXEffectImpl_OnResetDevice(ID3DXEffect
* iface
)
3275 struct ID3DXEffectImpl
*This
= impl_from_ID3DXEffect(iface
);
3277 FIXME("(%p)->(): stub\n", This
);
3282 static HRESULT WINAPI
ID3DXEffectImpl_SetStateManager(ID3DXEffect
*iface
, ID3DXEffectStateManager
*manager
)
3284 struct ID3DXEffectImpl
*This
= impl_from_ID3DXEffect(iface
);
3286 TRACE("iface %p, manager %p\n", This
, manager
);
3288 if (manager
) IUnknown_AddRef(manager
);
3289 if (This
->manager
) IUnknown_Release(This
->manager
);
3291 This
->manager
= manager
;
3296 static HRESULT WINAPI
ID3DXEffectImpl_GetStateManager(ID3DXEffect
*iface
, ID3DXEffectStateManager
**manager
)
3298 struct ID3DXEffectImpl
*This
= impl_from_ID3DXEffect(iface
);
3300 TRACE("iface %p, manager %p\n", This
, manager
);
3304 WARN("Invalid argument supplied.\n");
3305 return D3DERR_INVALIDCALL
;
3308 if (This
->manager
) IUnknown_AddRef(This
->manager
);
3309 *manager
= This
->manager
;
3314 static HRESULT WINAPI
ID3DXEffectImpl_BeginParameterBlock(ID3DXEffect
* iface
)
3316 struct ID3DXEffectImpl
*This
= impl_from_ID3DXEffect(iface
);
3318 FIXME("(%p)->(): stub\n", This
);
3323 static D3DXHANDLE WINAPI
ID3DXEffectImpl_EndParameterBlock(ID3DXEffect
* iface
)
3325 struct ID3DXEffectImpl
*This
= impl_from_ID3DXEffect(iface
);
3327 FIXME("(%p)->(): stub\n", This
);
3332 static HRESULT WINAPI
ID3DXEffectImpl_ApplyParameterBlock(ID3DXEffect
* iface
, D3DXHANDLE parameter_block
)
3334 struct ID3DXEffectImpl
*This
= impl_from_ID3DXEffect(iface
);
3336 FIXME("(%p)->(%p): stub\n", This
, parameter_block
);
3341 static HRESULT WINAPI
ID3DXEffectImpl_DeleteParameterBlock(ID3DXEffect
* iface
, D3DXHANDLE parameter_block
)
3343 struct ID3DXEffectImpl
*This
= impl_from_ID3DXEffect(iface
);
3345 FIXME("(%p)->(%p): stub\n", This
, parameter_block
);
3350 static HRESULT WINAPI
ID3DXEffectImpl_CloneEffect(ID3DXEffect
*iface
,
3351 struct IDirect3DDevice9
*device
, struct ID3DXEffect
**effect
)
3353 struct ID3DXEffectImpl
*This
= impl_from_ID3DXEffect(iface
);
3355 FIXME("(%p)->(%p, %p): stub\n", This
, device
, effect
);
3360 static HRESULT WINAPI
ID3DXEffectImpl_SetRawValue(ID3DXEffect
*iface
,
3361 D3DXHANDLE parameter
, const void *data
, UINT byte_offset
, UINT bytes
)
3363 FIXME("iface %p, parameter %p, data %p, byte_offset %u, bytes %u stub!\n",
3364 iface
, parameter
, data
, byte_offset
, bytes
);
3369 static const struct ID3DXEffectVtbl ID3DXEffect_Vtbl
=
3371 /*** IUnknown methods ***/
3372 ID3DXEffectImpl_QueryInterface
,
3373 ID3DXEffectImpl_AddRef
,
3374 ID3DXEffectImpl_Release
,
3375 /*** ID3DXBaseEffect methods ***/
3376 ID3DXEffectImpl_GetDesc
,
3377 ID3DXEffectImpl_GetParameterDesc
,
3378 ID3DXEffectImpl_GetTechniqueDesc
,
3379 ID3DXEffectImpl_GetPassDesc
,
3380 ID3DXEffectImpl_GetFunctionDesc
,
3381 ID3DXEffectImpl_GetParameter
,
3382 ID3DXEffectImpl_GetParameterByName
,
3383 ID3DXEffectImpl_GetParameterBySemantic
,
3384 ID3DXEffectImpl_GetParameterElement
,
3385 ID3DXEffectImpl_GetTechnique
,
3386 ID3DXEffectImpl_GetTechniqueByName
,
3387 ID3DXEffectImpl_GetPass
,
3388 ID3DXEffectImpl_GetPassByName
,
3389 ID3DXEffectImpl_GetFunction
,
3390 ID3DXEffectImpl_GetFunctionByName
,
3391 ID3DXEffectImpl_GetAnnotation
,
3392 ID3DXEffectImpl_GetAnnotationByName
,
3393 ID3DXEffectImpl_SetValue
,
3394 ID3DXEffectImpl_GetValue
,
3395 ID3DXEffectImpl_SetBool
,
3396 ID3DXEffectImpl_GetBool
,
3397 ID3DXEffectImpl_SetBoolArray
,
3398 ID3DXEffectImpl_GetBoolArray
,
3399 ID3DXEffectImpl_SetInt
,
3400 ID3DXEffectImpl_GetInt
,
3401 ID3DXEffectImpl_SetIntArray
,
3402 ID3DXEffectImpl_GetIntArray
,
3403 ID3DXEffectImpl_SetFloat
,
3404 ID3DXEffectImpl_GetFloat
,
3405 ID3DXEffectImpl_SetFloatArray
,
3406 ID3DXEffectImpl_GetFloatArray
,
3407 ID3DXEffectImpl_SetVector
,
3408 ID3DXEffectImpl_GetVector
,
3409 ID3DXEffectImpl_SetVectorArray
,
3410 ID3DXEffectImpl_GetVectorArray
,
3411 ID3DXEffectImpl_SetMatrix
,
3412 ID3DXEffectImpl_GetMatrix
,
3413 ID3DXEffectImpl_SetMatrixArray
,
3414 ID3DXEffectImpl_GetMatrixArray
,
3415 ID3DXEffectImpl_SetMatrixPointerArray
,
3416 ID3DXEffectImpl_GetMatrixPointerArray
,
3417 ID3DXEffectImpl_SetMatrixTranspose
,
3418 ID3DXEffectImpl_GetMatrixTranspose
,
3419 ID3DXEffectImpl_SetMatrixTransposeArray
,
3420 ID3DXEffectImpl_GetMatrixTransposeArray
,
3421 ID3DXEffectImpl_SetMatrixTransposePointerArray
,
3422 ID3DXEffectImpl_GetMatrixTransposePointerArray
,
3423 ID3DXEffectImpl_SetString
,
3424 ID3DXEffectImpl_GetString
,
3425 ID3DXEffectImpl_SetTexture
,
3426 ID3DXEffectImpl_GetTexture
,
3427 ID3DXEffectImpl_GetPixelShader
,
3428 ID3DXEffectImpl_GetVertexShader
,
3429 ID3DXEffectImpl_SetArrayRange
,
3430 /*** ID3DXEffect methods ***/
3431 ID3DXEffectImpl_GetPool
,
3432 ID3DXEffectImpl_SetTechnique
,
3433 ID3DXEffectImpl_GetCurrentTechnique
,
3434 ID3DXEffectImpl_ValidateTechnique
,
3435 ID3DXEffectImpl_FindNextValidTechnique
,
3436 ID3DXEffectImpl_IsParameterUsed
,
3437 ID3DXEffectImpl_Begin
,
3438 ID3DXEffectImpl_BeginPass
,
3439 ID3DXEffectImpl_CommitChanges
,
3440 ID3DXEffectImpl_EndPass
,
3441 ID3DXEffectImpl_End
,
3442 ID3DXEffectImpl_GetDevice
,
3443 ID3DXEffectImpl_OnLostDevice
,
3444 ID3DXEffectImpl_OnResetDevice
,
3445 ID3DXEffectImpl_SetStateManager
,
3446 ID3DXEffectImpl_GetStateManager
,
3447 ID3DXEffectImpl_BeginParameterBlock
,
3448 ID3DXEffectImpl_EndParameterBlock
,
3449 ID3DXEffectImpl_ApplyParameterBlock
,
3450 ID3DXEffectImpl_DeleteParameterBlock
,
3451 ID3DXEffectImpl_CloneEffect
,
3452 ID3DXEffectImpl_SetRawValue
3455 static inline struct ID3DXEffectCompilerImpl
*impl_from_ID3DXEffectCompiler(ID3DXEffectCompiler
*iface
)
3457 return CONTAINING_RECORD(iface
, struct ID3DXEffectCompilerImpl
, ID3DXEffectCompiler_iface
);
3460 /*** IUnknown methods ***/
3461 static HRESULT WINAPI
ID3DXEffectCompilerImpl_QueryInterface(ID3DXEffectCompiler
*iface
, REFIID riid
, void **object
)
3463 TRACE("iface %p, riid %s, object %p.\n", iface
, debugstr_guid(riid
), object
);
3465 if (IsEqualGUID(riid
, &IID_IUnknown
) ||
3466 IsEqualGUID(riid
, &IID_ID3DXEffectCompiler
))
3468 iface
->lpVtbl
->AddRef(iface
);
3473 ERR("Interface %s not found\n", debugstr_guid(riid
));
3475 return E_NOINTERFACE
;
3478 static ULONG WINAPI
ID3DXEffectCompilerImpl_AddRef(ID3DXEffectCompiler
*iface
)
3480 struct ID3DXEffectCompilerImpl
*This
= impl_from_ID3DXEffectCompiler(iface
);
3482 TRACE("iface %p: AddRef from %u\n", iface
, This
->ref
);
3484 return InterlockedIncrement(&This
->ref
);
3487 static ULONG WINAPI
ID3DXEffectCompilerImpl_Release(ID3DXEffectCompiler
*iface
)
3489 struct ID3DXEffectCompilerImpl
*This
= impl_from_ID3DXEffectCompiler(iface
);
3490 ULONG ref
= InterlockedDecrement(&This
->ref
);
3492 TRACE("iface %p: Release from %u\n", iface
, ref
+ 1);
3496 free_effect_compiler(This
);
3497 HeapFree(GetProcessHeap(), 0, This
);
3503 /*** ID3DXBaseEffect methods ***/
3504 static HRESULT WINAPI
ID3DXEffectCompilerImpl_GetDesc(ID3DXEffectCompiler
*iface
, D3DXEFFECT_DESC
*desc
)
3506 struct ID3DXEffectCompilerImpl
*compiler
= impl_from_ID3DXEffectCompiler(iface
);
3508 TRACE("iface %p, desc %p.\n", iface
, desc
);
3510 return d3dx9_base_effect_get_desc(&compiler
->base_effect
, desc
);
3513 static HRESULT WINAPI
ID3DXEffectCompilerImpl_GetParameterDesc(ID3DXEffectCompiler
*iface
,
3514 D3DXHANDLE parameter
, D3DXPARAMETER_DESC
*desc
)
3516 struct ID3DXEffectCompilerImpl
*compiler
= impl_from_ID3DXEffectCompiler(iface
);
3518 TRACE("iface %p, parameter %p, desc %p.\n", iface
, parameter
, desc
);
3520 return d3dx9_base_effect_get_parameter_desc(&compiler
->base_effect
, parameter
, desc
);
3523 static HRESULT WINAPI
ID3DXEffectCompilerImpl_GetTechniqueDesc(ID3DXEffectCompiler
*iface
,
3524 D3DXHANDLE technique
, D3DXTECHNIQUE_DESC
*desc
)
3526 struct ID3DXEffectCompilerImpl
*compiler
= impl_from_ID3DXEffectCompiler(iface
);
3528 TRACE("iface %p, technique %p, desc %p.\n", iface
, technique
, desc
);
3530 return d3dx9_base_effect_get_technique_desc(&compiler
->base_effect
, technique
, desc
);
3533 static HRESULT WINAPI
ID3DXEffectCompilerImpl_GetPassDesc(ID3DXEffectCompiler
*iface
,
3534 D3DXHANDLE pass
, D3DXPASS_DESC
*desc
)
3536 struct ID3DXEffectCompilerImpl
*compiler
= impl_from_ID3DXEffectCompiler(iface
);
3538 TRACE("iface %p, pass %p, desc %p.\n", iface
, pass
, desc
);
3540 return d3dx9_base_effect_get_pass_desc(&compiler
->base_effect
, pass
, desc
);
3543 static HRESULT WINAPI
ID3DXEffectCompilerImpl_GetFunctionDesc(ID3DXEffectCompiler
*iface
,
3544 D3DXHANDLE shader
, D3DXFUNCTION_DESC
*desc
)
3546 struct ID3DXEffectCompilerImpl
*compiler
= impl_from_ID3DXEffectCompiler(iface
);
3548 TRACE("iface %p, shader %p, desc %p.\n", iface
, shader
, desc
);
3550 return d3dx9_base_effect_get_function_desc(&compiler
->base_effect
, shader
, desc
);
3553 static D3DXHANDLE WINAPI
ID3DXEffectCompilerImpl_GetParameter(ID3DXEffectCompiler
*iface
,
3554 D3DXHANDLE parameter
, UINT index
)
3556 struct ID3DXEffectCompilerImpl
*compiler
= impl_from_ID3DXEffectCompiler(iface
);
3558 TRACE("iface %p, parameter %p, index %u.\n", iface
, parameter
, index
);
3560 return d3dx9_base_effect_get_parameter(&compiler
->base_effect
, parameter
, index
);
3563 static D3DXHANDLE WINAPI
ID3DXEffectCompilerImpl_GetParameterByName(ID3DXEffectCompiler
*iface
,
3564 D3DXHANDLE parameter
, const char *name
)
3566 struct ID3DXEffectCompilerImpl
*compiler
= impl_from_ID3DXEffectCompiler(iface
);
3568 TRACE("iface %p, parameter %p, name %s.\n", iface
, parameter
, debugstr_a(name
));
3570 return d3dx9_base_effect_get_parameter_by_name(&compiler
->base_effect
, parameter
, name
);
3573 static D3DXHANDLE WINAPI
ID3DXEffectCompilerImpl_GetParameterBySemantic(ID3DXEffectCompiler
*iface
,
3574 D3DXHANDLE parameter
, const char *semantic
)
3576 struct ID3DXEffectCompilerImpl
*compiler
= impl_from_ID3DXEffectCompiler(iface
);
3578 TRACE("iface %p, parameter %p, semantic %s.\n", iface
, parameter
, debugstr_a(semantic
));
3580 return d3dx9_base_effect_get_parameter_by_semantic(&compiler
->base_effect
, parameter
, semantic
);
3583 static D3DXHANDLE WINAPI
ID3DXEffectCompilerImpl_GetParameterElement(ID3DXEffectCompiler
*iface
,
3584 D3DXHANDLE parameter
, UINT index
)
3586 struct ID3DXEffectCompilerImpl
*compiler
= impl_from_ID3DXEffectCompiler(iface
);
3588 TRACE("iface %p, parameter %p, index %u.\n", iface
, parameter
, index
);
3590 return d3dx9_base_effect_get_parameter_element(&compiler
->base_effect
, parameter
, index
);
3593 static D3DXHANDLE WINAPI
ID3DXEffectCompilerImpl_GetTechnique(ID3DXEffectCompiler
*iface
, UINT index
)
3595 struct ID3DXEffectCompilerImpl
*compiler
= impl_from_ID3DXEffectCompiler(iface
);
3597 TRACE("iface %p, index %u.\n", iface
, index
);
3599 return d3dx9_base_effect_get_technique(&compiler
->base_effect
, index
);
3602 static D3DXHANDLE WINAPI
ID3DXEffectCompilerImpl_GetTechniqueByName(ID3DXEffectCompiler
*iface
, const char *name
)
3604 struct ID3DXEffectCompilerImpl
*compiler
= impl_from_ID3DXEffectCompiler(iface
);
3606 TRACE("iface %p, name %s.\n", iface
, debugstr_a(name
));
3608 return d3dx9_base_effect_get_technique_by_name(&compiler
->base_effect
, name
);
3611 static D3DXHANDLE WINAPI
ID3DXEffectCompilerImpl_GetPass(ID3DXEffectCompiler
*iface
, D3DXHANDLE technique
, UINT index
)
3613 struct ID3DXEffectCompilerImpl
*compiler
= impl_from_ID3DXEffectCompiler(iface
);
3615 TRACE("iface %p, technique %p, index %u.\n", iface
, technique
, index
);
3617 return d3dx9_base_effect_get_pass(&compiler
->base_effect
, technique
, index
);
3620 static D3DXHANDLE WINAPI
ID3DXEffectCompilerImpl_GetPassByName(ID3DXEffectCompiler
*iface
,
3621 D3DXHANDLE technique
, const char *name
)
3623 struct ID3DXEffectCompilerImpl
*compiler
= impl_from_ID3DXEffectCompiler(iface
);
3625 TRACE("iface %p, technique %p, name %s.\n", iface
, technique
, debugstr_a(name
));
3627 return d3dx9_base_effect_get_pass_by_name(&compiler
->base_effect
, technique
, name
);
3630 static D3DXHANDLE WINAPI
ID3DXEffectCompilerImpl_GetFunction(ID3DXEffectCompiler
*iface
, UINT index
)
3632 struct ID3DXEffectCompilerImpl
*compiler
= impl_from_ID3DXEffectCompiler(iface
);
3634 TRACE("iface %p, index %u.\n", iface
, index
);
3636 return d3dx9_base_effect_get_function(&compiler
->base_effect
, index
);
3639 static D3DXHANDLE WINAPI
ID3DXEffectCompilerImpl_GetFunctionByName(ID3DXEffectCompiler
*iface
, const char *name
)
3641 struct ID3DXEffectCompilerImpl
*compiler
= impl_from_ID3DXEffectCompiler(iface
);
3643 TRACE("iface %p, name %s.\n", iface
, debugstr_a(name
));
3645 return d3dx9_base_effect_get_function_by_name(&compiler
->base_effect
, name
);
3648 static D3DXHANDLE WINAPI
ID3DXEffectCompilerImpl_GetAnnotation(ID3DXEffectCompiler
*iface
,
3649 D3DXHANDLE object
, UINT index
)
3651 struct ID3DXEffectCompilerImpl
*compiler
= impl_from_ID3DXEffectCompiler(iface
);
3653 TRACE("iface %p, object %p, index %u.\n", iface
, object
, index
);
3655 return d3dx9_base_effect_get_annotation(&compiler
->base_effect
, object
, index
);
3658 static D3DXHANDLE WINAPI
ID3DXEffectCompilerImpl_GetAnnotationByName(ID3DXEffectCompiler
*iface
,
3659 D3DXHANDLE object
, const char *name
)
3661 struct ID3DXEffectCompilerImpl
*compiler
= impl_from_ID3DXEffectCompiler(iface
);
3663 TRACE("iface %p, object %p, name %s.\n", iface
, object
, debugstr_a(name
));
3665 return d3dx9_base_effect_get_annotation_by_name(&compiler
->base_effect
, object
, name
);
3668 static HRESULT WINAPI
ID3DXEffectCompilerImpl_SetValue(ID3DXEffectCompiler
*iface
,
3669 D3DXHANDLE parameter
, const void *data
, UINT bytes
)
3671 struct ID3DXEffectCompilerImpl
*compiler
= impl_from_ID3DXEffectCompiler(iface
);
3673 TRACE("iface %p, parameter %p, data %p, bytes %u.\n", iface
, parameter
, data
, bytes
);
3675 return d3dx9_base_effect_set_value(&compiler
->base_effect
, parameter
, data
, bytes
);
3678 static HRESULT WINAPI
ID3DXEffectCompilerImpl_GetValue(ID3DXEffectCompiler
*iface
,
3679 D3DXHANDLE parameter
, void *data
, UINT bytes
)
3681 struct ID3DXEffectCompilerImpl
*compiler
= impl_from_ID3DXEffectCompiler(iface
);
3683 TRACE("iface %p, parameter %p, data %p, bytes %u.\n", iface
, parameter
, data
, bytes
);
3685 return d3dx9_base_effect_get_value(&compiler
->base_effect
, parameter
, data
, bytes
);
3688 static HRESULT WINAPI
ID3DXEffectCompilerImpl_SetBool(ID3DXEffectCompiler
*iface
, D3DXHANDLE parameter
, BOOL b
)
3690 struct ID3DXEffectCompilerImpl
*compiler
= impl_from_ID3DXEffectCompiler(iface
);
3692 TRACE("iface %p, parameter %p, b %#x.\n", iface
, parameter
, b
);
3694 return d3dx9_base_effect_set_bool(&compiler
->base_effect
, parameter
, b
);
3697 static HRESULT WINAPI
ID3DXEffectCompilerImpl_GetBool(ID3DXEffectCompiler
*iface
, D3DXHANDLE parameter
, BOOL
*b
)
3699 struct ID3DXEffectCompilerImpl
*compiler
= impl_from_ID3DXEffectCompiler(iface
);
3701 TRACE("iface %p, parameter %p, b %p.\n", iface
, parameter
, b
);
3703 return d3dx9_base_effect_get_bool(&compiler
->base_effect
, parameter
, b
);
3706 static HRESULT WINAPI
ID3DXEffectCompilerImpl_SetBoolArray(ID3DXEffectCompiler
*iface
,
3707 D3DXHANDLE parameter
, const BOOL
*b
, UINT count
)
3709 struct ID3DXEffectCompilerImpl
*compiler
= impl_from_ID3DXEffectCompiler(iface
);
3711 TRACE("iface %p, parameter %p, b %p, count %u.\n", iface
, parameter
, b
, count
);
3713 return d3dx9_base_effect_set_bool_array(&compiler
->base_effect
, parameter
, b
, count
);
3716 static HRESULT WINAPI
ID3DXEffectCompilerImpl_GetBoolArray(ID3DXEffectCompiler
*iface
,
3717 D3DXHANDLE parameter
, BOOL
*b
, UINT count
)
3719 struct ID3DXEffectCompilerImpl
*compiler
= impl_from_ID3DXEffectCompiler(iface
);
3721 TRACE("iface %p, parameter %p, b %p, count %u.\n", iface
, parameter
, b
, count
);
3723 return d3dx9_base_effect_get_bool_array(&compiler
->base_effect
, parameter
, b
, count
);
3726 static HRESULT WINAPI
ID3DXEffectCompilerImpl_SetInt(ID3DXEffectCompiler
*iface
, D3DXHANDLE parameter
, INT n
)
3728 struct ID3DXEffectCompilerImpl
*compiler
= impl_from_ID3DXEffectCompiler(iface
);
3730 TRACE("iface %p, parameter %p, n %d.\n", iface
, parameter
, n
);
3732 return d3dx9_base_effect_set_int(&compiler
->base_effect
, parameter
, n
);
3735 static HRESULT WINAPI
ID3DXEffectCompilerImpl_GetInt(ID3DXEffectCompiler
*iface
, D3DXHANDLE parameter
, INT
*n
)
3737 struct ID3DXEffectCompilerImpl
*compiler
= impl_from_ID3DXEffectCompiler(iface
);
3739 TRACE("iface %p, parameter %p, n %p.\n", iface
, parameter
, n
);
3741 return d3dx9_base_effect_get_int(&compiler
->base_effect
, parameter
, n
);
3744 static HRESULT WINAPI
ID3DXEffectCompilerImpl_SetIntArray(ID3DXEffectCompiler
*iface
,
3745 D3DXHANDLE parameter
, const INT
*n
, UINT count
)
3747 struct ID3DXEffectCompilerImpl
*compiler
= impl_from_ID3DXEffectCompiler(iface
);
3749 TRACE("iface %p, parameter %p, n %p, count %u.\n", iface
, parameter
, n
, count
);
3751 return d3dx9_base_effect_set_int_array(&compiler
->base_effect
, parameter
, n
, count
);
3754 static HRESULT WINAPI
ID3DXEffectCompilerImpl_GetIntArray(ID3DXEffectCompiler
*iface
,
3755 D3DXHANDLE parameter
, INT
*n
, UINT count
)
3757 struct ID3DXEffectCompilerImpl
*compiler
= impl_from_ID3DXEffectCompiler(iface
);
3759 TRACE("iface %p, parameter %p, n %p, count %u.\n", iface
, parameter
, n
, count
);
3761 return d3dx9_base_effect_get_int_array(&compiler
->base_effect
, parameter
, n
, count
);
3764 static HRESULT WINAPI
ID3DXEffectCompilerImpl_SetFloat(ID3DXEffectCompiler
*iface
, D3DXHANDLE parameter
, float f
)
3766 struct ID3DXEffectCompilerImpl
*compiler
= impl_from_ID3DXEffectCompiler(iface
);
3768 TRACE("iface %p, parameter %p, f %.8e.\n", iface
, parameter
, f
);
3770 return d3dx9_base_effect_set_float(&compiler
->base_effect
, parameter
, f
);
3773 static HRESULT WINAPI
ID3DXEffectCompilerImpl_GetFloat(ID3DXEffectCompiler
*iface
, D3DXHANDLE parameter
, float *f
)
3775 struct ID3DXEffectCompilerImpl
*compiler
= impl_from_ID3DXEffectCompiler(iface
);
3777 TRACE("iface %p, parameter %p, f %p.\n", iface
, parameter
, f
);
3779 return d3dx9_base_effect_get_float(&compiler
->base_effect
, parameter
, f
);
3782 static HRESULT WINAPI
ID3DXEffectCompilerImpl_SetFloatArray(ID3DXEffectCompiler
*iface
,
3783 D3DXHANDLE parameter
, const float *f
, UINT count
)
3785 struct ID3DXEffectCompilerImpl
*compiler
= impl_from_ID3DXEffectCompiler(iface
);
3787 TRACE("iface %p, parameter %p, f %p, count %u.\n", iface
, parameter
, f
, count
);
3789 return d3dx9_base_effect_set_float_array(&compiler
->base_effect
, parameter
, f
, count
);
3792 static HRESULT WINAPI
ID3DXEffectCompilerImpl_GetFloatArray(ID3DXEffectCompiler
*iface
,
3793 D3DXHANDLE parameter
, float *f
, UINT count
)
3795 struct ID3DXEffectCompilerImpl
*compiler
= impl_from_ID3DXEffectCompiler(iface
);
3797 TRACE("iface %p, parameter %p, f %p, count %u.\n", iface
, parameter
, f
, count
);
3799 return d3dx9_base_effect_get_float_array(&compiler
->base_effect
, parameter
, f
, count
);
3802 static HRESULT WINAPI
ID3DXEffectCompilerImpl_SetVector(ID3DXEffectCompiler
*iface
,
3803 D3DXHANDLE parameter
, const D3DXVECTOR4
*vector
)
3805 struct ID3DXEffectCompilerImpl
*compiler
= impl_from_ID3DXEffectCompiler(iface
);
3807 TRACE("iface %p, parameter %p, vector %p.\n", iface
, parameter
, vector
);
3809 return d3dx9_base_effect_set_vector(&compiler
->base_effect
, parameter
, vector
);
3812 static HRESULT WINAPI
ID3DXEffectCompilerImpl_GetVector(ID3DXEffectCompiler
*iface
,
3813 D3DXHANDLE parameter
, D3DXVECTOR4
*vector
)
3815 struct ID3DXEffectCompilerImpl
*compiler
= impl_from_ID3DXEffectCompiler(iface
);
3817 TRACE("iface %p, parameter %p, vector %p.\n", iface
, parameter
, vector
);
3819 return d3dx9_base_effect_get_vector(&compiler
->base_effect
, parameter
, vector
);
3822 static HRESULT WINAPI
ID3DXEffectCompilerImpl_SetVectorArray(ID3DXEffectCompiler
*iface
,
3823 D3DXHANDLE parameter
, const D3DXVECTOR4
*vector
, UINT count
)
3825 struct ID3DXEffectCompilerImpl
*compiler
= impl_from_ID3DXEffectCompiler(iface
);
3827 TRACE("iface %p, parameter %p, vector %p, count %u.\n", iface
, parameter
, vector
, count
);
3829 return d3dx9_base_effect_set_vector_array(&compiler
->base_effect
, parameter
, vector
, count
);
3832 static HRESULT WINAPI
ID3DXEffectCompilerImpl_GetVectorArray(ID3DXEffectCompiler
*iface
,
3833 D3DXHANDLE parameter
, D3DXVECTOR4
*vector
, UINT count
)
3835 struct ID3DXEffectCompilerImpl
*compiler
= impl_from_ID3DXEffectCompiler(iface
);
3837 TRACE("iface %p, parameter %p, vector %p, count %u.\n", iface
, parameter
, vector
, count
);
3839 return d3dx9_base_effect_get_vector_array(&compiler
->base_effect
, parameter
, vector
, count
);
3842 static HRESULT WINAPI
ID3DXEffectCompilerImpl_SetMatrix(ID3DXEffectCompiler
*iface
,
3843 D3DXHANDLE parameter
, const D3DXMATRIX
*matrix
)
3845 struct ID3DXEffectCompilerImpl
*compiler
= impl_from_ID3DXEffectCompiler(iface
);
3847 TRACE("iface %p, parameter %p, matrix %p.\n", iface
, parameter
, matrix
);
3849 return d3dx9_base_effect_set_matrix(&compiler
->base_effect
, parameter
, matrix
);
3852 static HRESULT WINAPI
ID3DXEffectCompilerImpl_GetMatrix(ID3DXEffectCompiler
*iface
,
3853 D3DXHANDLE parameter
, D3DXMATRIX
*matrix
)
3855 struct ID3DXEffectCompilerImpl
*compiler
= impl_from_ID3DXEffectCompiler(iface
);
3857 TRACE("iface %p, parameter %p, matrix %p.\n", iface
, parameter
, matrix
);
3859 return d3dx9_base_effect_get_matrix(&compiler
->base_effect
, parameter
, matrix
);
3862 static HRESULT WINAPI
ID3DXEffectCompilerImpl_SetMatrixArray(ID3DXEffectCompiler
*iface
,
3863 D3DXHANDLE parameter
, const D3DXMATRIX
*matrix
, UINT count
)
3865 struct ID3DXEffectCompilerImpl
*compiler
= impl_from_ID3DXEffectCompiler(iface
);
3867 TRACE("iface %p, parameter %p, matrix %p, count %u.\n", iface
, parameter
, matrix
, count
);
3869 return d3dx9_base_effect_set_matrix_array(&compiler
->base_effect
, parameter
, matrix
, count
);
3872 static HRESULT WINAPI
ID3DXEffectCompilerImpl_GetMatrixArray(ID3DXEffectCompiler
*iface
,
3873 D3DXHANDLE parameter
, D3DXMATRIX
*matrix
, UINT count
)
3875 struct ID3DXEffectCompilerImpl
*compiler
= impl_from_ID3DXEffectCompiler(iface
);
3877 TRACE("iface %p, parameter %p, matrix %p, count %u.\n", iface
, parameter
, matrix
, count
);
3879 return d3dx9_base_effect_get_matrix_array(&compiler
->base_effect
, parameter
, matrix
, count
);
3882 static HRESULT WINAPI
ID3DXEffectCompilerImpl_SetMatrixPointerArray(ID3DXEffectCompiler
*iface
,
3883 D3DXHANDLE parameter
, const D3DXMATRIX
**matrix
, UINT count
)
3885 struct ID3DXEffectCompilerImpl
*compiler
= impl_from_ID3DXEffectCompiler(iface
);
3887 TRACE("iface %p, parameter %p, matrix %p, count %u.\n", iface
, parameter
, matrix
, count
);
3889 return d3dx9_base_effect_set_matrix_pointer_array(&compiler
->base_effect
, parameter
, matrix
, count
);
3892 static HRESULT WINAPI
ID3DXEffectCompilerImpl_GetMatrixPointerArray(ID3DXEffectCompiler
*iface
,
3893 D3DXHANDLE parameter
, D3DXMATRIX
**matrix
, UINT count
)
3895 struct ID3DXEffectCompilerImpl
*compiler
= impl_from_ID3DXEffectCompiler(iface
);
3897 TRACE("iface %p, parameter %p, matrix %p, count %u.\n", iface
, parameter
, matrix
, count
);
3899 return d3dx9_base_effect_get_matrix_pointer_array(&compiler
->base_effect
, parameter
, matrix
, count
);
3902 static HRESULT WINAPI
ID3DXEffectCompilerImpl_SetMatrixTranspose(ID3DXEffectCompiler
*iface
,
3903 D3DXHANDLE parameter
, const D3DXMATRIX
*matrix
)
3905 struct ID3DXEffectCompilerImpl
*compiler
= impl_from_ID3DXEffectCompiler(iface
);
3907 TRACE("iface %p, parameter %p, matrix %p.\n", iface
, parameter
, matrix
);
3909 return d3dx9_base_effect_set_matrix_transpose(&compiler
->base_effect
, parameter
, matrix
);
3912 static HRESULT WINAPI
ID3DXEffectCompilerImpl_GetMatrixTranspose(ID3DXEffectCompiler
*iface
,
3913 D3DXHANDLE parameter
, D3DXMATRIX
*matrix
)
3915 struct ID3DXEffectCompilerImpl
*compiler
= impl_from_ID3DXEffectCompiler(iface
);
3917 TRACE("iface %p, parameter %p, matrix %p.\n", iface
, parameter
, matrix
);
3919 return d3dx9_base_effect_get_matrix_transpose(&compiler
->base_effect
, parameter
, matrix
);
3922 static HRESULT WINAPI
ID3DXEffectCompilerImpl_SetMatrixTransposeArray(ID3DXEffectCompiler
*iface
,
3923 D3DXHANDLE parameter
, const D3DXMATRIX
*matrix
, UINT count
)
3925 struct ID3DXEffectCompilerImpl
*compiler
= impl_from_ID3DXEffectCompiler(iface
);
3927 TRACE("iface %p, parameter %p, matrix %p, count %u.\n", iface
, parameter
, matrix
, count
);
3929 return d3dx9_base_effect_set_matrix_transpose_array(&compiler
->base_effect
, parameter
, matrix
, count
);
3932 static HRESULT WINAPI
ID3DXEffectCompilerImpl_GetMatrixTransposeArray(ID3DXEffectCompiler
*iface
,
3933 D3DXHANDLE parameter
, D3DXMATRIX
*matrix
, UINT count
)
3935 struct ID3DXEffectCompilerImpl
*compiler
= impl_from_ID3DXEffectCompiler(iface
);
3937 TRACE("iface %p, parameter %p, matrix %p, count %u.\n", iface
, parameter
, matrix
, count
);
3939 return d3dx9_base_effect_get_matrix_transpose_array(&compiler
->base_effect
, parameter
, matrix
, count
);
3942 static HRESULT WINAPI
ID3DXEffectCompilerImpl_SetMatrixTransposePointerArray(ID3DXEffectCompiler
*iface
,
3943 D3DXHANDLE parameter
, const D3DXMATRIX
**matrix
, UINT count
)
3945 struct ID3DXEffectCompilerImpl
*compiler
= impl_from_ID3DXEffectCompiler(iface
);
3947 TRACE("iface %p, parameter %p, matrix %p, count %u.\n", iface
, parameter
, matrix
, count
);
3949 return d3dx9_base_effect_set_matrix_transpose_pointer_array(&compiler
->base_effect
, parameter
, matrix
, count
);
3952 static HRESULT WINAPI
ID3DXEffectCompilerImpl_GetMatrixTransposePointerArray(ID3DXEffectCompiler
*iface
,
3953 D3DXHANDLE parameter
, D3DXMATRIX
**matrix
, UINT count
)
3955 struct ID3DXEffectCompilerImpl
*compiler
= impl_from_ID3DXEffectCompiler(iface
);
3957 TRACE("iface %p, parameter %p, matrix %p, count %u.\n", iface
, parameter
, matrix
, count
);
3959 return d3dx9_base_effect_get_matrix_transpose_pointer_array(&compiler
->base_effect
, parameter
, matrix
, count
);
3962 static HRESULT WINAPI
ID3DXEffectCompilerImpl_SetString(ID3DXEffectCompiler
*iface
,
3963 D3DXHANDLE parameter
, const char *string
)
3965 struct ID3DXEffectCompilerImpl
*compiler
= impl_from_ID3DXEffectCompiler(iface
);
3967 TRACE("iface %p, parameter %p, string %s.\n", iface
, parameter
, debugstr_a(string
));
3969 return d3dx9_base_effect_set_string(&compiler
->base_effect
, parameter
, string
);
3972 static HRESULT WINAPI
ID3DXEffectCompilerImpl_GetString(ID3DXEffectCompiler
*iface
,
3973 D3DXHANDLE parameter
, const char **string
)
3975 struct ID3DXEffectCompilerImpl
*compiler
= impl_from_ID3DXEffectCompiler(iface
);
3977 TRACE("iface %p, parameter %p, string %p.\n", iface
, parameter
, string
);
3979 return d3dx9_base_effect_get_string(&compiler
->base_effect
, parameter
, string
);
3982 static HRESULT WINAPI
ID3DXEffectCompilerImpl_SetTexture(struct ID3DXEffectCompiler
*iface
,
3983 D3DXHANDLE parameter
, struct IDirect3DBaseTexture9
*texture
)
3985 struct ID3DXEffectCompilerImpl
*compiler
= impl_from_ID3DXEffectCompiler(iface
);
3987 TRACE("iface %p, parameter %p, texture %p.\n", iface
, parameter
, texture
);
3989 return d3dx9_base_effect_set_texture(&compiler
->base_effect
, parameter
, texture
);
3992 static HRESULT WINAPI
ID3DXEffectCompilerImpl_GetTexture(struct ID3DXEffectCompiler
*iface
,
3993 D3DXHANDLE parameter
, struct IDirect3DBaseTexture9
**texture
)
3995 struct ID3DXEffectCompilerImpl
*compiler
= impl_from_ID3DXEffectCompiler(iface
);
3997 TRACE("iface %p, parameter %p, texture %p.\n", iface
, parameter
, texture
);
3999 return d3dx9_base_effect_get_texture(&compiler
->base_effect
, parameter
, texture
);
4002 static HRESULT WINAPI
ID3DXEffectCompilerImpl_GetPixelShader(ID3DXEffectCompiler
*iface
,
4003 D3DXHANDLE parameter
, struct IDirect3DPixelShader9
**shader
)
4005 struct ID3DXEffectCompilerImpl
*compiler
= impl_from_ID3DXEffectCompiler(iface
);
4007 TRACE("iface %p, parameter %p, shader %p.\n", iface
, parameter
, shader
);
4009 return d3dx9_base_effect_get_pixel_shader(&compiler
->base_effect
, parameter
, shader
);
4012 static HRESULT WINAPI
ID3DXEffectCompilerImpl_GetVertexShader(struct ID3DXEffectCompiler
*iface
,
4013 D3DXHANDLE parameter
, struct IDirect3DVertexShader9
**shader
)
4015 struct ID3DXEffectCompilerImpl
*compiler
= impl_from_ID3DXEffectCompiler(iface
);
4017 TRACE("iface %p, parameter %p, shader %p.\n", iface
, parameter
, shader
);
4019 return d3dx9_base_effect_get_vertex_shader(&compiler
->base_effect
, parameter
, shader
);
4022 static HRESULT WINAPI
ID3DXEffectCompilerImpl_SetArrayRange(ID3DXEffectCompiler
*iface
,
4023 D3DXHANDLE parameter
, UINT start
, UINT end
)
4025 struct ID3DXEffectCompilerImpl
*compiler
= impl_from_ID3DXEffectCompiler(iface
);
4027 TRACE("iface %p, parameter %p, start %u, end %u.\n", iface
, parameter
, start
, end
);
4029 return d3dx9_base_effect_set_array_range(&compiler
->base_effect
, parameter
, start
, end
);
4032 /*** ID3DXEffectCompiler methods ***/
4033 static HRESULT WINAPI
ID3DXEffectCompilerImpl_SetLiteral(ID3DXEffectCompiler
*iface
, D3DXHANDLE parameter
, BOOL literal
)
4035 struct ID3DXEffectCompilerImpl
*This
= impl_from_ID3DXEffectCompiler(iface
);
4037 FIXME("iface %p, parameter %p, literal %u\n", This
, parameter
, literal
);
4042 static HRESULT WINAPI
ID3DXEffectCompilerImpl_GetLiteral(ID3DXEffectCompiler
*iface
, D3DXHANDLE parameter
, BOOL
*literal
)
4044 struct ID3DXEffectCompilerImpl
*This
= impl_from_ID3DXEffectCompiler(iface
);
4046 FIXME("iface %p, parameter %p, literal %p\n", This
, parameter
, literal
);
4051 static HRESULT WINAPI
ID3DXEffectCompilerImpl_CompileEffect(ID3DXEffectCompiler
*iface
, DWORD flags
,
4052 ID3DXBuffer
**effect
, ID3DXBuffer
**error_msgs
)
4054 struct ID3DXEffectCompilerImpl
*This
= impl_from_ID3DXEffectCompiler(iface
);
4056 FIXME("iface %p, flags %#x, effect %p, error_msgs %p stub\n", This
, flags
, effect
, error_msgs
);
4061 static HRESULT WINAPI
ID3DXEffectCompilerImpl_CompileShader(ID3DXEffectCompiler
*iface
, D3DXHANDLE function
,
4062 const char *target
, DWORD flags
, ID3DXBuffer
**shader
, ID3DXBuffer
**error_msgs
,
4063 ID3DXConstantTable
**constant_table
)
4065 struct ID3DXEffectCompilerImpl
*This
= impl_from_ID3DXEffectCompiler(iface
);
4067 FIXME("iface %p, function %p, target %p, flags %#x, shader %p, error_msgs %p, constant_table %p stub\n",
4068 This
, function
, target
, flags
, shader
, error_msgs
, constant_table
);
4073 static const struct ID3DXEffectCompilerVtbl ID3DXEffectCompiler_Vtbl
=
4075 /*** IUnknown methods ***/
4076 ID3DXEffectCompilerImpl_QueryInterface
,
4077 ID3DXEffectCompilerImpl_AddRef
,
4078 ID3DXEffectCompilerImpl_Release
,
4079 /*** ID3DXBaseEffect methods ***/
4080 ID3DXEffectCompilerImpl_GetDesc
,
4081 ID3DXEffectCompilerImpl_GetParameterDesc
,
4082 ID3DXEffectCompilerImpl_GetTechniqueDesc
,
4083 ID3DXEffectCompilerImpl_GetPassDesc
,
4084 ID3DXEffectCompilerImpl_GetFunctionDesc
,
4085 ID3DXEffectCompilerImpl_GetParameter
,
4086 ID3DXEffectCompilerImpl_GetParameterByName
,
4087 ID3DXEffectCompilerImpl_GetParameterBySemantic
,
4088 ID3DXEffectCompilerImpl_GetParameterElement
,
4089 ID3DXEffectCompilerImpl_GetTechnique
,
4090 ID3DXEffectCompilerImpl_GetTechniqueByName
,
4091 ID3DXEffectCompilerImpl_GetPass
,
4092 ID3DXEffectCompilerImpl_GetPassByName
,
4093 ID3DXEffectCompilerImpl_GetFunction
,
4094 ID3DXEffectCompilerImpl_GetFunctionByName
,
4095 ID3DXEffectCompilerImpl_GetAnnotation
,
4096 ID3DXEffectCompilerImpl_GetAnnotationByName
,
4097 ID3DXEffectCompilerImpl_SetValue
,
4098 ID3DXEffectCompilerImpl_GetValue
,
4099 ID3DXEffectCompilerImpl_SetBool
,
4100 ID3DXEffectCompilerImpl_GetBool
,
4101 ID3DXEffectCompilerImpl_SetBoolArray
,
4102 ID3DXEffectCompilerImpl_GetBoolArray
,
4103 ID3DXEffectCompilerImpl_SetInt
,
4104 ID3DXEffectCompilerImpl_GetInt
,
4105 ID3DXEffectCompilerImpl_SetIntArray
,
4106 ID3DXEffectCompilerImpl_GetIntArray
,
4107 ID3DXEffectCompilerImpl_SetFloat
,
4108 ID3DXEffectCompilerImpl_GetFloat
,
4109 ID3DXEffectCompilerImpl_SetFloatArray
,
4110 ID3DXEffectCompilerImpl_GetFloatArray
,
4111 ID3DXEffectCompilerImpl_SetVector
,
4112 ID3DXEffectCompilerImpl_GetVector
,
4113 ID3DXEffectCompilerImpl_SetVectorArray
,
4114 ID3DXEffectCompilerImpl_GetVectorArray
,
4115 ID3DXEffectCompilerImpl_SetMatrix
,
4116 ID3DXEffectCompilerImpl_GetMatrix
,
4117 ID3DXEffectCompilerImpl_SetMatrixArray
,
4118 ID3DXEffectCompilerImpl_GetMatrixArray
,
4119 ID3DXEffectCompilerImpl_SetMatrixPointerArray
,
4120 ID3DXEffectCompilerImpl_GetMatrixPointerArray
,
4121 ID3DXEffectCompilerImpl_SetMatrixTranspose
,
4122 ID3DXEffectCompilerImpl_GetMatrixTranspose
,
4123 ID3DXEffectCompilerImpl_SetMatrixTransposeArray
,
4124 ID3DXEffectCompilerImpl_GetMatrixTransposeArray
,
4125 ID3DXEffectCompilerImpl_SetMatrixTransposePointerArray
,
4126 ID3DXEffectCompilerImpl_GetMatrixTransposePointerArray
,
4127 ID3DXEffectCompilerImpl_SetString
,
4128 ID3DXEffectCompilerImpl_GetString
,
4129 ID3DXEffectCompilerImpl_SetTexture
,
4130 ID3DXEffectCompilerImpl_GetTexture
,
4131 ID3DXEffectCompilerImpl_GetPixelShader
,
4132 ID3DXEffectCompilerImpl_GetVertexShader
,
4133 ID3DXEffectCompilerImpl_SetArrayRange
,
4134 /*** ID3DXEffectCompiler methods ***/
4135 ID3DXEffectCompilerImpl_SetLiteral
,
4136 ID3DXEffectCompilerImpl_GetLiteral
,
4137 ID3DXEffectCompilerImpl_CompileEffect
,
4138 ID3DXEffectCompilerImpl_CompileShader
,
4141 static HRESULT
d3dx9_parse_sampler(struct d3dx9_base_effect
*base
, struct d3dx_sampler
*sampler
,
4142 const char *data
, const char **ptr
, struct d3dx_object
*objects
)
4147 read_dword(ptr
, &sampler
->state_count
);
4148 TRACE("Count: %u\n", sampler
->state_count
);
4150 sampler
->states
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
, sizeof(*sampler
->states
) * sampler
->state_count
);
4151 if (!sampler
->states
)
4153 ERR("Out of memory\n");
4154 return E_OUTOFMEMORY
;
4157 for (i
= 0; i
< sampler
->state_count
; ++i
)
4159 hr
= d3dx9_parse_state(base
, &sampler
->states
[i
], data
, ptr
, objects
);
4162 WARN("Failed to parse state %u\n", i
);
4171 for (i
= 0; i
< sampler
->state_count
; ++i
)
4173 free_state(&sampler
->states
[i
]);
4175 HeapFree(GetProcessHeap(), 0, sampler
->states
);
4176 sampler
->states
= NULL
;
4181 static HRESULT
d3dx9_parse_value(struct d3dx9_base_effect
*base
, struct d3dx_parameter
*param
,
4182 void *value
, const char *data
, const char **ptr
, struct d3dx_object
*objects
)
4188 if (param
->element_count
)
4190 param
->data
= value
;
4192 for (i
= 0; i
< param
->element_count
; ++i
)
4194 struct d3dx_parameter
*member
= ¶m
->members
[i
];
4196 hr
= d3dx9_parse_value(base
, member
, value
? (char *)value
+ old_size
: NULL
, data
, ptr
, objects
);
4199 WARN("Failed to parse value %u\n", i
);
4203 old_size
+= member
->bytes
;
4209 switch(param
->class)
4213 case D3DXPC_MATRIX_ROWS
:
4214 case D3DXPC_MATRIX_COLUMNS
:
4215 param
->data
= value
;
4219 param
->data
= value
;
4221 for (i
= 0; i
< param
->member_count
; ++i
)
4223 struct d3dx_parameter
*member
= ¶m
->members
[i
];
4225 hr
= d3dx9_parse_value(base
, member
, (char *)value
+ old_size
, data
, ptr
, objects
);
4228 WARN("Failed to parse value %u\n", i
);
4232 old_size
+= member
->bytes
;
4237 switch (param
->type
)
4240 case D3DXPT_TEXTURE
:
4241 case D3DXPT_TEXTURE1D
:
4242 case D3DXPT_TEXTURE2D
:
4243 case D3DXPT_TEXTURE3D
:
4244 case D3DXPT_TEXTURECUBE
:
4245 case D3DXPT_PIXELSHADER
:
4246 case D3DXPT_VERTEXSHADER
:
4247 read_dword(ptr
, ¶m
->object_id
);
4248 TRACE("Id: %u\n", param
->object_id
);
4249 objects
[param
->object_id
].param
= param
;
4250 param
->data
= value
;
4253 case D3DXPT_SAMPLER
:
4254 case D3DXPT_SAMPLER1D
:
4255 case D3DXPT_SAMPLER2D
:
4256 case D3DXPT_SAMPLER3D
:
4257 case D3DXPT_SAMPLERCUBE
:
4259 struct d3dx_sampler
*sampler
;
4261 sampler
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
, sizeof(*sampler
));
4263 return E_OUTOFMEMORY
;
4265 hr
= d3dx9_parse_sampler(base
, sampler
, data
, ptr
, objects
);
4268 HeapFree(GetProcessHeap(), 0, sampler
);
4269 WARN("Failed to parse sampler\n");
4273 param
->data
= sampler
;
4278 FIXME("Unhandled type %s\n", debug_d3dxparameter_type(param
->type
));
4284 FIXME("Unhandled class %s\n", debug_d3dxparameter_class(param
->class));
4291 static HRESULT
d3dx9_parse_init_value(struct d3dx9_base_effect
*base
, struct d3dx_parameter
*param
,
4292 const char *data
, const char *ptr
, struct d3dx_object
*objects
)
4294 UINT size
= param
->bytes
;
4298 TRACE("param size: %u\n", size
);
4302 value
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
, size
);
4305 ERR("Failed to allocate data memory.\n");
4306 return E_OUTOFMEMORY
;
4309 switch(param
->class)
4316 case D3DXPC_MATRIX_ROWS
:
4317 case D3DXPC_MATRIX_COLUMNS
:
4319 TRACE("Data: %s.\n", debugstr_an(ptr
, size
));
4320 memcpy(value
, ptr
, size
);
4324 FIXME("Unhandled class %s\n", debug_d3dxparameter_class(param
->class));
4329 hr
= d3dx9_parse_value(base
, param
, value
, data
, &ptr
, objects
);
4332 WARN("Failed to parse value\n");
4333 HeapFree(GetProcessHeap(), 0, value
);
4340 static HRESULT
d3dx9_parse_name(char **name
, const char *ptr
)
4344 read_dword(&ptr
, &size
);
4345 TRACE("Name size: %#x\n", size
);
4352 *name
= HeapAlloc(GetProcessHeap(), 0, size
);
4355 ERR("Failed to allocate name memory.\n");
4356 return E_OUTOFMEMORY
;
4359 TRACE("Name: %s.\n", debugstr_an(ptr
, size
));
4360 memcpy(*name
, ptr
, size
);
4365 static HRESULT
d3dx9_copy_data(struct d3dx_object
*object
, const char **ptr
)
4367 if (object
->size
|| object
->data
)
4368 FIXME("Object already initialized!\n");
4370 read_dword(ptr
, &object
->size
);
4371 TRACE("Data size: %#x\n", object
->size
);
4376 object
->data
= HeapAlloc(GetProcessHeap(), 0, object
->size
);
4379 ERR("Failed to allocate object memory.\n");
4380 return E_OUTOFMEMORY
;
4383 TRACE("Data: %s.\n", debugstr_an(*ptr
, object
->size
));
4384 memcpy(object
->data
, *ptr
, object
->size
);
4386 *ptr
+= ((object
->size
+ 3) & ~3);
4391 static void add_param_to_table(struct d3dx9_base_effect
*base
, struct d3dx_parameter
*param
)
4393 struct param_table
*table
= &base
->param_table
;
4395 if (table
->count
>= table
->size
)
4397 unsigned int new_size
;
4398 struct d3dx_parameter
**new_alloc
;
4402 new_size
= INITIAL_PARAM_TABLE_SIZE
;
4403 new_alloc
= HeapAlloc(GetProcessHeap(), 0, sizeof(*table
->table
) * new_size
);
4406 ERR("Out of memory.\n");
4412 new_size
= table
->size
* 2;
4413 new_alloc
= HeapReAlloc(GetProcessHeap(), 0, table
->table
, sizeof(*table
->table
) * new_size
);
4416 ERR("Out of memory.\n");
4420 table
->table
= new_alloc
;
4421 table
->size
= new_size
;
4424 table
->table
[table
->count
++] = param
;
4427 static void sync_param_handles(struct d3dx9_base_effect
*base
)
4429 struct param_table
*table
= &base
->param_table
;
4430 struct d3dx_parameter
**new_alloc
;
4435 new_alloc
= HeapReAlloc(GetProcessHeap(), 0, table
->table
, sizeof(*table
->table
) * table
->count
);
4437 table
->table
= new_alloc
;
4439 ERR("Out of memory.\n");
4442 for (i
= 0; i
< table
->count
; ++i
)
4443 table
->table
[i
]->handle
= (D3DXHANDLE
)&table
->table
[i
];
4446 static HRESULT
d3dx9_parse_effect_typedef(struct d3dx9_base_effect
*base
, struct d3dx_parameter
*param
,
4447 const char *data
, const char **ptr
, struct d3dx_parameter
*parent
, UINT flags
)
4453 param
->flags
= flags
;
4457 read_dword(ptr
, (DWORD
*)¶m
->type
);
4458 TRACE("Type: %s\n", debug_d3dxparameter_type(param
->type
));
4460 read_dword(ptr
, (DWORD
*)¶m
->class);
4461 TRACE("Class: %s\n", debug_d3dxparameter_class(param
->class));
4463 read_dword(ptr
, &offset
);
4464 TRACE("Type name offset: %#x\n", offset
);
4465 hr
= d3dx9_parse_name(¶m
->name
, data
+ offset
);
4468 WARN("Failed to parse name\n");
4472 read_dword(ptr
, &offset
);
4473 TRACE("Type semantic offset: %#x\n", offset
);
4474 hr
= d3dx9_parse_name(¶m
->semantic
, data
+ offset
);
4477 WARN("Failed to parse semantic\n");
4481 read_dword(ptr
, ¶m
->element_count
);
4482 TRACE("Elements: %u\n", param
->element_count
);
4484 switch (param
->class)
4487 read_dword(ptr
, ¶m
->columns
);
4488 TRACE("Columns: %u\n", param
->columns
);
4490 read_dword(ptr
, ¶m
->rows
);
4491 TRACE("Rows: %u\n", param
->rows
);
4493 /* sizeof(DWORD) * rows * columns */
4494 param
->bytes
= 4 * param
->rows
* param
->columns
;
4498 case D3DXPC_MATRIX_ROWS
:
4499 case D3DXPC_MATRIX_COLUMNS
:
4500 read_dword(ptr
, ¶m
->rows
);
4501 TRACE("Rows: %u\n", param
->rows
);
4503 read_dword(ptr
, ¶m
->columns
);
4504 TRACE("Columns: %u\n", param
->columns
);
4506 /* sizeof(DWORD) * rows * columns */
4507 param
->bytes
= 4 * param
->rows
* param
->columns
;
4511 read_dword(ptr
, ¶m
->member_count
);
4512 TRACE("Members: %u\n", param
->member_count
);
4516 switch (param
->type
)
4519 case D3DXPT_PIXELSHADER
:
4520 case D3DXPT_VERTEXSHADER
:
4521 case D3DXPT_TEXTURE
:
4522 case D3DXPT_TEXTURE1D
:
4523 case D3DXPT_TEXTURE2D
:
4524 case D3DXPT_TEXTURE3D
:
4525 case D3DXPT_TEXTURECUBE
:
4526 param
->bytes
= sizeof(void *);
4529 case D3DXPT_SAMPLER
:
4530 case D3DXPT_SAMPLER1D
:
4531 case D3DXPT_SAMPLER2D
:
4532 case D3DXPT_SAMPLER3D
:
4533 case D3DXPT_SAMPLERCUBE
:
4538 FIXME("Unhandled type %s\n", debug_d3dxparameter_type(param
->type
));
4544 FIXME("Unhandled class %s\n", debug_d3dxparameter_class(param
->class));
4551 param
->type
= parent
->type
;
4552 param
->class = parent
->class;
4553 param
->name
= parent
->name
;
4554 param
->semantic
= parent
->semantic
;
4555 param
->element_count
= 0;
4556 param
->annotation_count
= 0;
4557 param
->member_count
= parent
->member_count
;
4558 param
->bytes
= parent
->bytes
;
4559 param
->rows
= parent
->rows
;
4560 param
->columns
= parent
->columns
;
4563 if (param
->element_count
)
4565 unsigned int param_bytes
= 0;
4566 const char *save_ptr
= *ptr
;
4568 param
->members
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
, sizeof(*param
->members
) * param
->element_count
);
4569 if (!param
->members
)
4571 ERR("Out of memory\n");
4576 for (i
= 0; i
< param
->element_count
; ++i
)
4580 add_param_to_table(base
, ¶m
->members
[i
]);
4581 hr
= d3dx9_parse_effect_typedef(base
, ¶m
->members
[i
], data
, ptr
, param
, flags
);
4584 WARN("Failed to parse member %u\n", i
);
4588 param_bytes
+= param
->members
[i
].bytes
;
4591 param
->bytes
= param_bytes
;
4593 else if (param
->member_count
)
4595 param
->members
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
, sizeof(*param
->members
) * param
->member_count
);
4596 if (!param
->members
)
4598 ERR("Out of memory\n");
4603 for (i
= 0; i
< param
->member_count
; ++i
)
4605 add_param_to_table(base
, ¶m
->members
[i
]);
4606 hr
= d3dx9_parse_effect_typedef(base
, ¶m
->members
[i
], data
, ptr
, NULL
, flags
);
4609 WARN("Failed to parse member %u\n", i
);
4613 param
->bytes
+= param
->members
[i
].bytes
;
4622 unsigned int count
= param
->element_count
? param
->element_count
: param
->member_count
;
4624 for (i
= 0; i
< count
; ++i
)
4625 free_parameter(¶m
->members
[i
], param
->element_count
!= 0, TRUE
);
4626 HeapFree(GetProcessHeap(), 0, param
->members
);
4627 param
->members
= NULL
;
4632 HeapFree(GetProcessHeap(), 0, param
->name
);
4633 HeapFree(GetProcessHeap(), 0, param
->semantic
);
4636 param
->semantic
= NULL
;
4641 static HRESULT
d3dx9_parse_effect_annotation(struct d3dx9_base_effect
*base
, struct d3dx_parameter
*anno
,
4642 const char *data
, const char **ptr
, struct d3dx_object
*objects
)
4648 anno
->flags
= D3DX_PARAMETER_ANNOTATION
;
4650 read_dword(ptr
, &offset
);
4651 TRACE("Typedef offset: %#x\n", offset
);
4652 ptr2
= data
+ offset
;
4653 hr
= d3dx9_parse_effect_typedef(base
, anno
, data
, &ptr2
, NULL
, D3DX_PARAMETER_ANNOTATION
);
4656 WARN("Failed to parse type definition\n");
4660 read_dword(ptr
, &offset
);
4661 TRACE("Value offset: %#x\n", offset
);
4662 hr
= d3dx9_parse_init_value(base
, anno
, data
, data
+ offset
, objects
);
4665 WARN("Failed to parse value\n");
4672 static HRESULT
d3dx9_parse_state(struct d3dx9_base_effect
*base
, struct d3dx_state
*state
,
4673 const char *data
, const char **ptr
, struct d3dx_object
*objects
)
4679 state
->type
= ST_CONSTANT
;
4681 read_dword(ptr
, &state
->operation
);
4682 TRACE("Operation: %#x (%s)\n", state
->operation
, state_table
[state
->operation
].name
);
4684 read_dword(ptr
, &state
->index
);
4685 TRACE("Index: %#x\n", state
->index
);
4687 read_dword(ptr
, &offset
);
4688 TRACE("Typedef offset: %#x\n", offset
);
4689 ptr2
= data
+ offset
;
4690 hr
= d3dx9_parse_effect_typedef(base
, &state
->parameter
, data
, &ptr2
, NULL
, 0);
4693 WARN("Failed to parse type definition\n");
4697 read_dword(ptr
, &offset
);
4698 TRACE("Value offset: %#x\n", offset
);
4699 hr
= d3dx9_parse_init_value(base
, &state
->parameter
, data
, data
+ offset
, objects
);
4702 WARN("Failed to parse value\n");
4710 free_parameter(&state
->parameter
, FALSE
, FALSE
);
4715 static HRESULT
d3dx9_parse_effect_parameter(struct d3dx9_base_effect
*base
, struct d3dx_parameter
*param
,
4716 const char *data
, const char **ptr
, struct d3dx_object
*objects
)
4723 read_dword(ptr
, &offset
);
4724 TRACE("Typedef offset: %#x\n", offset
);
4725 ptr2
= data
+ offset
;
4727 read_dword(ptr
, &offset
);
4728 TRACE("Value offset: %#x\n", offset
);
4730 read_dword(ptr
, ¶m
->flags
);
4731 TRACE("Flags: %#x\n", param
->flags
);
4733 read_dword(ptr
, ¶m
->annotation_count
);
4734 TRACE("Annotation count: %u\n", param
->annotation_count
);
4736 hr
= d3dx9_parse_effect_typedef(base
, param
, data
, &ptr2
, NULL
, param
->flags
);
4739 WARN("Failed to parse type definition\n");
4743 hr
= d3dx9_parse_init_value(base
, param
, data
, data
+ offset
, objects
);
4746 WARN("Failed to parse value\n");
4750 if (param
->annotation_count
)
4752 param
->annotations
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
,
4753 sizeof(*param
->annotations
) * param
->annotation_count
);
4754 if (!param
->annotations
)
4756 ERR("Out of memory\n");
4761 for (i
= 0; i
< param
->annotation_count
; ++i
)
4763 add_param_to_table(base
, ¶m
->annotations
[i
]);
4764 hr
= d3dx9_parse_effect_annotation(base
, ¶m
->annotations
[i
], data
, ptr
, objects
);
4767 WARN("Failed to parse annotation\n");
4777 if (param
->annotations
)
4779 for (i
= 0; i
< param
->annotation_count
; ++i
)
4780 free_parameter(¶m
->annotations
[i
], FALSE
, FALSE
);
4781 HeapFree(GetProcessHeap(), 0, param
->annotations
);
4782 param
->annotations
= NULL
;
4788 static HRESULT
d3dx9_parse_effect_pass(struct d3dx9_base_effect
*base
, struct d3dx_pass
*pass
,
4789 const char *data
, const char **ptr
, struct d3dx_object
*objects
)
4794 struct d3dx_state
*states
= NULL
;
4797 read_dword(ptr
, &offset
);
4798 TRACE("Pass name offset: %#x\n", offset
);
4799 hr
= d3dx9_parse_name(&name
, data
+ offset
);
4802 WARN("Failed to parse name\n");
4806 read_dword(ptr
, &pass
->annotation_count
);
4807 TRACE("Annotation count: %u\n", pass
->annotation_count
);
4809 read_dword(ptr
, &pass
->state_count
);
4810 TRACE("State count: %u\n", pass
->state_count
);
4812 if (pass
->annotation_count
)
4814 pass
->annotations
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
,
4815 sizeof(*pass
->annotations
) * pass
->annotation_count
);
4816 if (!pass
->annotations
)
4818 ERR("Out of memory\n");
4823 for (i
= 0; i
< pass
->annotation_count
; ++i
)
4825 add_param_to_table(base
, &pass
->annotations
[i
]);
4826 hr
= d3dx9_parse_effect_annotation(base
, &pass
->annotations
[i
], data
, ptr
, objects
);
4829 WARN("Failed to parse annotation %u\n", i
);
4835 if (pass
->state_count
)
4837 states
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
, sizeof(*states
) * pass
->state_count
);
4840 ERR("Out of memory\n");
4845 for (i
= 0; i
< pass
->state_count
; ++i
)
4847 hr
= d3dx9_parse_state(base
, &states
[i
], data
, ptr
, objects
);
4850 WARN("Failed to parse annotation %u\n", i
);
4857 pass
->states
= states
;
4863 if (pass
->annotations
)
4865 for (i
= 0; i
< pass
->annotation_count
; ++i
)
4866 free_parameter(&pass
->annotations
[i
], FALSE
, FALSE
);
4867 HeapFree(GetProcessHeap(), 0, pass
->annotations
);
4868 pass
->annotations
= NULL
;
4873 for (i
= 0; i
< pass
->state_count
; ++i
)
4875 free_state(&states
[i
]);
4877 HeapFree(GetProcessHeap(), 0, states
);
4880 HeapFree(GetProcessHeap(), 0, name
);
4885 static HRESULT
d3dx9_parse_effect_technique(struct d3dx9_base_effect
*base
, struct d3dx_technique
*technique
,
4886 const char *data
, const char **ptr
, struct d3dx_object
*objects
)
4893 read_dword(ptr
, &offset
);
4894 TRACE("Technique name offset: %#x\n", offset
);
4895 hr
= d3dx9_parse_name(&name
, data
+ offset
);
4898 WARN("Failed to parse name\n");
4902 read_dword(ptr
, &technique
->annotation_count
);
4903 TRACE("Annotation count: %u\n", technique
->annotation_count
);
4905 read_dword(ptr
, &technique
->pass_count
);
4906 TRACE("Pass count: %u\n", technique
->pass_count
);
4908 if (technique
->annotation_count
)
4910 technique
->annotations
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
,
4911 sizeof(*technique
->annotations
) * technique
->annotation_count
);
4912 if (!technique
->annotations
)
4914 ERR("Out of memory\n");
4919 for (i
= 0; i
< technique
->annotation_count
; ++i
)
4921 add_param_to_table(base
, &technique
->annotations
[i
]);
4922 hr
= d3dx9_parse_effect_annotation(base
, &technique
->annotations
[i
], data
, ptr
, objects
);
4925 WARN("Failed to parse annotation %u\n", i
);
4931 if (technique
->pass_count
)
4933 technique
->passes
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
,
4934 sizeof(*technique
->passes
) * technique
->pass_count
);
4935 if (!technique
->passes
)
4937 ERR("Out of memory\n");
4942 for (i
= 0; i
< technique
->pass_count
; ++i
)
4944 hr
= d3dx9_parse_effect_pass(base
, &technique
->passes
[i
], data
, ptr
, objects
);
4947 WARN("Failed to parse pass %u\n", i
);
4953 technique
->name
= name
;
4959 if (technique
->passes
)
4961 for (i
= 0; i
< technique
->pass_count
; ++i
)
4962 free_pass(&technique
->passes
[i
]);
4963 HeapFree(GetProcessHeap(), 0, technique
->passes
);
4964 technique
->passes
= NULL
;
4967 if (technique
->annotations
)
4969 for (i
= 0; i
< technique
->annotation_count
; ++i
)
4970 free_parameter(&technique
->annotations
[i
], FALSE
, FALSE
);
4971 HeapFree(GetProcessHeap(), 0, technique
->annotations
);
4972 technique
->annotations
= NULL
;
4975 HeapFree(GetProcessHeap(), 0, name
);
4980 static HRESULT
d3dx9_create_object(struct d3dx9_base_effect
*base
, struct d3dx_object
*object
)
4982 struct d3dx_parameter
*param
= object
->param
;
4983 struct IDirect3DDevice9
*device
= base
->effect
->device
;
4986 if (*(char **)param
->data
)
4987 ERR("Parameter data already allocated.\n");
4989 switch (param
->type
)
4992 *(char **)param
->data
= HeapAlloc(GetProcessHeap(), 0, object
->size
);
4993 if (!*(char **)param
->data
)
4995 ERR("Out of memory.\n");
4996 return E_OUTOFMEMORY
;
4998 memcpy(*(char **)param
->data
, object
->data
, object
->size
);
5000 case D3DXPT_VERTEXSHADER
:
5001 if (FAILED(hr
= IDirect3DDevice9_CreateVertexShader(device
, object
->data
,
5002 (IDirect3DVertexShader9
**)param
->data
)))
5004 WARN("Failed to create vertex shader.\n");
5008 case D3DXPT_PIXELSHADER
:
5009 if (FAILED(hr
= IDirect3DDevice9_CreatePixelShader(device
, object
->data
,
5010 (IDirect3DPixelShader9
**)param
->data
)))
5012 WARN("Failed to create pixel shader.\n");
5022 static HRESULT
d3dx9_parse_array_selector(struct d3dx9_base_effect
*base
, struct d3dx_parameter
*param
)
5025 struct d3dx_object
*object
= &base
->objects
[param
->object_id
];
5026 char *ptr
= object
->data
;
5028 TRACE("Parsing array entry selection state for parameter %p.\n", param
);
5030 string_size
= *(DWORD
*)ptr
;
5031 param
->referenced_param
= get_parameter_by_name(base
, NULL
, ptr
+ 4);
5032 if (param
->referenced_param
)
5034 TRACE("Mapping to parameter %s.\n", debugstr_a(param
->referenced_param
->name
));
5038 FIXME("Referenced parameter %s not found.\n", ptr
+ 4);
5039 return D3DXERR_INVALIDDATA
;
5041 TRACE("Unknown DWORD: 0x%.8x.\n", *(DWORD
*)(ptr
+ string_size
));
5043 FIXME("Parse preshader.\n");
5048 static HRESULT
d3dx9_parse_resource(struct d3dx9_base_effect
*base
, const char *data
, const char **ptr
)
5050 DWORD technique_index
;
5051 DWORD index
, state_index
, usage
, element_index
;
5052 struct d3dx_state
*state
;
5053 struct d3dx_parameter
*param
;
5054 struct d3dx_object
*object
;
5055 HRESULT hr
= E_FAIL
;
5057 read_dword(ptr
, &technique_index
);
5058 TRACE("techn: %u\n", technique_index
);
5060 read_dword(ptr
, &index
);
5061 TRACE("index: %u\n", index
);
5063 read_dword(ptr
, &element_index
);
5064 TRACE("element_index: %u\n", element_index
);
5066 read_dword(ptr
, &state_index
);
5067 TRACE("state_index: %u\n", state_index
);
5069 read_dword(ptr
, &usage
);
5070 TRACE("usage: %u\n", usage
);
5072 if (technique_index
== 0xffffffff)
5074 struct d3dx_parameter
*parameter
;
5075 struct d3dx_sampler
*sampler
;
5077 if (index
>= base
->parameter_count
)
5079 FIXME("Index out of bounds: index %u >= parameter_count %u\n", index
, base
->parameter_count
);
5083 parameter
= &base
->parameters
[index
];
5084 if (element_index
!= 0xffffffff)
5086 if (element_index
>= parameter
->element_count
&& parameter
->element_count
!= 0)
5088 FIXME("Index out of bounds: element_index %u >= element_count %u\n", element_index
, parameter
->element_count
);
5092 if (parameter
->element_count
!= 0) parameter
= ¶meter
->members
[element_index
];
5095 sampler
= parameter
->data
;
5096 if (state_index
>= sampler
->state_count
)
5098 FIXME("Index out of bounds: state_index %u >= state_count %u\n", state_index
, sampler
->state_count
);
5102 state
= &sampler
->states
[state_index
];
5106 struct d3dx_technique
*technique
;
5107 struct d3dx_pass
*pass
;
5109 if (technique_index
>= base
->technique_count
)
5111 FIXME("Index out of bounds: technique_index %u >= technique_count %u\n", technique_index
, base
->technique_count
);
5115 technique
= &base
->techniques
[technique_index
];
5116 if (index
>= technique
->pass_count
)
5118 FIXME("Index out of bounds: index %u >= pass_count %u\n", index
, technique
->pass_count
);
5122 pass
= &technique
->passes
[index
];
5123 if (state_index
>= pass
->state_count
)
5125 FIXME("Index out of bounds: state_index %u >= state_count %u\n", state_index
, pass
->state_count
);
5129 state
= &pass
->states
[state_index
];
5132 TRACE("State operation %#x (%s).\n", state
->operation
, state_table
[state
->operation
].name
);
5133 param
= &state
->parameter
;
5134 TRACE("Using object id %u.\n", param
->object_id
);
5135 object
= &base
->objects
[param
->object_id
];
5137 TRACE("Usage %u: class %s, type %s.\n", usage
, debug_d3dxparameter_class(param
->class),
5138 debug_d3dxparameter_type(param
->type
));
5142 switch (param
->type
)
5144 case D3DXPT_VERTEXSHADER
:
5145 case D3DXPT_PIXELSHADER
:
5146 state
->type
= ST_CONSTANT
;
5147 if (FAILED(hr
= d3dx9_copy_data(&base
->objects
[param
->object_id
], ptr
)))
5151 hr
= d3dx9_create_object(base
, object
);
5158 state
->type
= ST_FXLC
;
5159 hr
= d3dx9_copy_data(&base
->objects
[param
->object_id
], ptr
);
5163 FIXME("Unhandled type %s\n", debug_d3dxparameter_type(param
->type
));
5169 state
->type
= ST_PARAMETER
;
5170 if (FAILED(hr
= d3dx9_copy_data(&base
->objects
[param
->object_id
], ptr
)))
5173 TRACE("Looking for parameter %s.\n", debugstr_a(object
->data
));
5174 param
->referenced_param
= get_parameter_by_name(base
, NULL
, object
->data
);
5175 if (param
->referenced_param
)
5177 TRACE("Mapping to parameter %p.\n", param
->referenced_param
);
5181 FIXME("Referenced parameter %s not found.\n", (char *)object
->data
);
5182 return D3DXERR_INVALIDDATA
;
5187 state
->type
= ST_ARRAY_SELECTOR
;
5188 if (FAILED(hr
= d3dx9_copy_data(object
, ptr
)))
5190 hr
= d3dx9_parse_array_selector(base
, param
);
5194 FIXME("Unknown usage %x\n", usage
);
5201 static HRESULT
d3dx9_parse_effect(struct d3dx9_base_effect
*base
, const char *data
, UINT data_size
, DWORD start
)
5203 const char *ptr
= data
+ start
;
5204 UINT stringcount
, resourcecount
;
5208 read_dword(&ptr
, &base
->parameter_count
);
5209 TRACE("Parameter count: %u\n", base
->parameter_count
);
5211 read_dword(&ptr
, &base
->technique_count
);
5212 TRACE("Technique count: %u\n", base
->technique_count
);
5214 skip_dword_unknown(&ptr
, 1);
5216 read_dword(&ptr
, &base
->object_count
);
5217 TRACE("Object count: %u\n", base
->object_count
);
5219 base
->objects
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
, sizeof(*base
->objects
) * base
->object_count
);
5222 ERR("Out of memory\n");
5227 if (base
->parameter_count
)
5229 base
->parameters
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
,
5230 sizeof(*base
->parameters
) * base
->parameter_count
);
5231 if (!base
->parameters
)
5233 ERR("Out of memory\n");
5238 for (i
= 0; i
< base
->parameter_count
; ++i
)
5240 add_param_to_table(base
, &base
->parameters
[i
]);
5241 hr
= d3dx9_parse_effect_parameter(base
, &base
->parameters
[i
], data
, &ptr
, base
->objects
);
5244 WARN("Failed to parse parameter %u\n", i
);
5250 if (base
->technique_count
)
5252 base
->techniques
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
,
5253 sizeof(*base
->techniques
) * base
->technique_count
);
5254 if (!base
->techniques
)
5256 ERR("Out of memory\n");
5261 for (i
= 0; i
< base
->technique_count
; ++i
)
5263 TRACE("Parsing technique %u.\n", i
);
5264 hr
= d3dx9_parse_effect_technique(base
, &base
->techniques
[i
], data
, &ptr
, base
->objects
);
5267 WARN("Failed to parse technique %u\n", i
);
5273 sync_param_handles(base
);
5275 read_dword(&ptr
, &stringcount
);
5276 TRACE("String count: %u\n", stringcount
);
5278 read_dword(&ptr
, &resourcecount
);
5279 TRACE("Resource count: %u\n", resourcecount
);
5281 for (i
= 0; i
< stringcount
; ++i
)
5285 read_dword(&ptr
, &id
);
5286 TRACE("Id: %u\n", id
);
5288 if (FAILED(hr
= d3dx9_copy_data(&base
->objects
[id
], &ptr
)))
5291 if (base
->objects
[id
].data
)
5293 if (FAILED(hr
= d3dx9_create_object(base
, &base
->objects
[id
])))
5298 for (i
= 0; i
< resourcecount
; ++i
)
5300 TRACE("parse resource %u\n", i
);
5302 hr
= d3dx9_parse_resource(base
, data
, &ptr
);
5305 WARN("Failed to parse resource %u\n", i
);
5314 if (base
->techniques
)
5316 for (i
= 0; i
< base
->technique_count
; ++i
)
5317 free_technique(&base
->techniques
[i
]);
5318 HeapFree(GetProcessHeap(), 0, base
->techniques
);
5319 base
->techniques
= NULL
;
5322 if (base
->parameters
)
5324 for (i
= 0; i
< base
->parameter_count
; ++i
)
5326 free_parameter(&base
->parameters
[i
], FALSE
, FALSE
);
5328 HeapFree(GetProcessHeap(), 0, base
->parameters
);
5329 base
->parameters
= NULL
;
5334 for (i
= 0; i
< base
->object_count
; ++i
)
5336 free_object(&base
->objects
[i
]);
5338 HeapFree(GetProcessHeap(), 0, base
->objects
);
5339 base
->objects
= NULL
;
5345 static HRESULT
d3dx9_base_effect_init(struct d3dx9_base_effect
*base
,
5346 const char *data
, SIZE_T data_size
, const D3D_SHADER_MACRO
*defines
, ID3DInclude
*include
,
5347 UINT eflags
, ID3DBlob
**errors
, struct ID3DXEffectImpl
*effect
)
5350 const char *ptr
= data
;
5352 ID3DBlob
*bytecode
= NULL
, *temp_errors
= NULL
;
5354 TRACE("base %p, data %p, data_size %lu, effect %p\n", base
, data
, data_size
, effect
);
5356 base
->effect
= effect
;
5358 read_dword(&ptr
, &tag
);
5359 TRACE("Tag: %x\n", tag
);
5361 if (tag
!= d3dx9_effect_version(9, 1))
5363 TRACE("HLSL ASCII effect, trying to compile it.\n");
5364 hr
= D3DCompile(data
, data_size
, NULL
, defines
, include
,
5365 "main", "fx_2_0", 0, eflags
, &bytecode
, &temp_errors
);
5368 WARN("Failed to compile ASCII effect.\n");
5370 ID3D10Blob_Release(bytecode
);
5372 TRACE("%s\n", (char *)ID3D10Blob_GetBufferPointer(temp_errors
));
5374 *errors
= temp_errors
;
5375 else if (temp_errors
)
5376 ID3D10Blob_Release(temp_errors
);
5381 FIXME("No output from effect compilation.\n");
5382 return D3DERR_INVALIDCALL
;
5385 *errors
= temp_errors
;
5386 else if (temp_errors
)
5387 ID3D10Blob_Release(temp_errors
);
5389 ptr
= ID3D10Blob_GetBufferPointer(bytecode
);
5390 read_dword(&ptr
, &tag
);
5391 TRACE("Tag: %x\n", tag
);
5394 read_dword(&ptr
, &offset
);
5395 TRACE("Offset: %x\n", offset
);
5397 hr
= d3dx9_parse_effect(base
, ptr
, data_size
, offset
);
5399 ID3D10Blob_Release(bytecode
);
5402 FIXME("Failed to parse effect.\n");
5409 static HRESULT
d3dx9_effect_init(struct ID3DXEffectImpl
*effect
, struct IDirect3DDevice9
*device
,
5410 const char *data
, SIZE_T data_size
, const D3D_SHADER_MACRO
*defines
, ID3DInclude
*include
,
5411 UINT eflags
, ID3DBlob
**error_messages
, struct ID3DXEffectPool
*pool
)
5415 TRACE("effect %p, device %p, data %p, data_size %lu, pool %p\n", effect
, device
, data
, data_size
, pool
);
5417 effect
->ID3DXEffect_iface
.lpVtbl
= &ID3DXEffect_Vtbl
;
5420 if (pool
) pool
->lpVtbl
->AddRef(pool
);
5421 effect
->pool
= pool
;
5423 IDirect3DDevice9_AddRef(device
);
5424 effect
->device
= device
;
5426 if (FAILED(hr
= d3dx9_base_effect_init(&effect
->base_effect
, data
, data_size
, defines
, include
,
5427 eflags
, error_messages
, effect
)))
5429 FIXME("Failed to parse effect, hr %#x.\n", hr
);
5430 free_effect(effect
);
5434 /* initialize defaults - check because of unsupported ascii effects */
5435 if (effect
->base_effect
.techniques
)
5437 effect
->active_technique
= &effect
->base_effect
.techniques
[0];
5438 effect
->active_pass
= NULL
;
5444 HRESULT WINAPI
D3DXCreateEffectEx(struct IDirect3DDevice9
*device
, const void *srcdata
, UINT srcdatalen
,
5445 const D3DXMACRO
*defines
, struct ID3DXInclude
*include
, const char *skip_constants
, DWORD flags
,
5446 struct ID3DXEffectPool
*pool
, struct ID3DXEffect
**effect
, struct ID3DXBuffer
**compilation_errors
)
5448 struct ID3DXEffectImpl
*object
;
5451 TRACE("device %p, srcdata %p, srcdatalen %u, defines %p, include %p,"
5452 " skip_constants %p, flags %#x, pool %p, effect %p, compilation_errors %p.\n",
5453 device
, srcdata
, srcdatalen
, defines
, include
,
5454 skip_constants
, flags
, pool
, effect
, compilation_errors
);
5456 if (compilation_errors
)
5457 *compilation_errors
= NULL
;
5459 if (!device
|| !srcdata
)
5460 return D3DERR_INVALIDCALL
;
5465 /* Native dll allows effect to be null so just return D3D_OK after doing basic checks */
5470 FIXME("skip_constants is not NULL, not supported yet.\n");
5472 object
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
, sizeof(*object
));
5474 return E_OUTOFMEMORY
;
5476 hr
= d3dx9_effect_init(object
, device
, srcdata
, srcdatalen
, (const D3D_SHADER_MACRO
*)defines
,
5477 (ID3DInclude
*)include
, flags
, (ID3DBlob
**)compilation_errors
, pool
);
5480 WARN("Failed to create effect object.\n");
5481 HeapFree(GetProcessHeap(), 0, object
);
5485 *effect
= &object
->ID3DXEffect_iface
;
5487 TRACE("Created ID3DXEffect %p\n", object
);
5492 HRESULT WINAPI
D3DXCreateEffect(struct IDirect3DDevice9
*device
, const void *srcdata
, UINT srcdatalen
,
5493 const D3DXMACRO
*defines
, struct ID3DXInclude
*include
, DWORD flags
,
5494 struct ID3DXEffectPool
*pool
, struct ID3DXEffect
**effect
, struct ID3DXBuffer
**compilation_errors
)
5496 TRACE("(%p, %p, %u, %p, %p, %#x, %p, %p, %p): Forwarded to D3DXCreateEffectEx\n", device
, srcdata
, srcdatalen
, defines
,
5497 include
, flags
, pool
, effect
, compilation_errors
);
5499 return D3DXCreateEffectEx(device
, srcdata
, srcdatalen
, defines
, include
, NULL
, flags
, pool
, effect
, compilation_errors
);
5502 static HRESULT
d3dx9_effect_compiler_init(struct ID3DXEffectCompilerImpl
*compiler
,
5503 const char *data
, SIZE_T data_size
, const D3D_SHADER_MACRO
*defines
, ID3DInclude
*include
,
5504 UINT eflags
, ID3DBlob
**error_messages
)
5508 TRACE("effect %p, data %p, data_size %lu\n", compiler
, data
, data_size
);
5510 compiler
->ID3DXEffectCompiler_iface
.lpVtbl
= &ID3DXEffectCompiler_Vtbl
;
5513 if (FAILED(hr
= d3dx9_base_effect_init(&compiler
->base_effect
, data
, data_size
, defines
,
5514 include
, eflags
, error_messages
, NULL
)))
5516 FIXME("Failed to parse effect, hr %#x.\n", hr
);
5517 free_effect_compiler(compiler
);
5524 HRESULT WINAPI
D3DXCreateEffectCompiler(const char *srcdata
, UINT srcdatalen
, const D3DXMACRO
*defines
,
5525 ID3DXInclude
*include
, DWORD flags
, ID3DXEffectCompiler
**compiler
, ID3DXBuffer
**parse_errors
)
5527 struct ID3DXEffectCompilerImpl
*object
;
5530 TRACE("srcdata %p, srcdatalen %u, defines %p, include %p, flags %#x, compiler %p, parse_errors %p\n",
5531 srcdata
, srcdatalen
, defines
, include
, flags
, compiler
, parse_errors
);
5533 if (!srcdata
|| !compiler
)
5535 WARN("Invalid arguments supplied\n");
5536 return D3DERR_INVALIDCALL
;
5539 object
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
, sizeof(*object
));
5541 return E_OUTOFMEMORY
;
5543 hr
= d3dx9_effect_compiler_init(object
, srcdata
, srcdatalen
, (const D3D_SHADER_MACRO
*)defines
,
5544 (ID3DInclude
*)include
, flags
, (ID3DBlob
**)parse_errors
);
5547 WARN("Failed to initialize effect compiler\n");
5548 HeapFree(GetProcessHeap(), 0, object
);
5552 *compiler
= &object
->ID3DXEffectCompiler_iface
;
5554 TRACE("Created ID3DXEffectCompiler %p\n", object
);
5559 struct ID3DXEffectPoolImpl
5561 ID3DXEffectPool ID3DXEffectPool_iface
;
5565 static inline struct ID3DXEffectPoolImpl
*impl_from_ID3DXEffectPool(ID3DXEffectPool
*iface
)
5567 return CONTAINING_RECORD(iface
, struct ID3DXEffectPoolImpl
, ID3DXEffectPool_iface
);
5570 /*** IUnknown methods ***/
5571 static HRESULT WINAPI
ID3DXEffectPoolImpl_QueryInterface(ID3DXEffectPool
*iface
, REFIID riid
, void **object
)
5573 TRACE("(%p)->(%s, %p)\n", iface
, debugstr_guid(riid
), object
);
5575 if (IsEqualGUID(riid
, &IID_IUnknown
) ||
5576 IsEqualGUID(riid
, &IID_ID3DXEffectPool
))
5578 iface
->lpVtbl
->AddRef(iface
);
5583 WARN("Interface %s not found\n", debugstr_guid(riid
));
5585 return E_NOINTERFACE
;
5588 static ULONG WINAPI
ID3DXEffectPoolImpl_AddRef(ID3DXEffectPool
*iface
)
5590 struct ID3DXEffectPoolImpl
*This
= impl_from_ID3DXEffectPool(iface
);
5592 TRACE("(%p)->(): AddRef from %u\n", This
, This
->ref
);
5594 return InterlockedIncrement(&This
->ref
);
5597 static ULONG WINAPI
ID3DXEffectPoolImpl_Release(ID3DXEffectPool
*iface
)
5599 struct ID3DXEffectPoolImpl
*This
= impl_from_ID3DXEffectPool(iface
);
5600 ULONG ref
= InterlockedDecrement(&This
->ref
);
5602 TRACE("(%p)->(): Release from %u\n", This
, ref
+ 1);
5605 HeapFree(GetProcessHeap(), 0, This
);
5610 static const struct ID3DXEffectPoolVtbl ID3DXEffectPool_Vtbl
=
5612 /*** IUnknown methods ***/
5613 ID3DXEffectPoolImpl_QueryInterface
,
5614 ID3DXEffectPoolImpl_AddRef
,
5615 ID3DXEffectPoolImpl_Release
5618 HRESULT WINAPI
D3DXCreateEffectPool(ID3DXEffectPool
**pool
)
5620 struct ID3DXEffectPoolImpl
*object
;
5622 TRACE("(%p)\n", pool
);
5625 return D3DERR_INVALIDCALL
;
5627 object
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
, sizeof(*object
));
5629 return E_OUTOFMEMORY
;
5631 object
->ID3DXEffectPool_iface
.lpVtbl
= &ID3DXEffectPool_Vtbl
;
5634 *pool
= &object
->ID3DXEffectPool_iface
;
5639 HRESULT WINAPI
D3DXCreateEffectFromFileExW(struct IDirect3DDevice9
*device
, const WCHAR
*srcfile
,
5640 const D3DXMACRO
*defines
, struct ID3DXInclude
*include
, const char *skipconstants
, DWORD flags
,
5641 struct ID3DXEffectPool
*pool
, struct ID3DXEffect
**effect
, struct ID3DXBuffer
**compilationerrors
)
5647 TRACE("device %p, srcfile %s, defines %p, include %p, skipconstants %s, "
5648 "flags %#x, pool %p, effect %p, compilationerrors %p.\n",
5649 device
, debugstr_w(srcfile
), defines
, include
, debugstr_a(skipconstants
),
5650 flags
, pool
, effect
, compilationerrors
);
5652 if (!device
|| !srcfile
)
5653 return D3DERR_INVALIDCALL
;
5655 ret
= map_view_of_file(srcfile
, &buffer
, &size
);
5658 return D3DXERR_INVALIDDATA
;
5660 ret
= D3DXCreateEffectEx(device
, buffer
, size
, defines
, include
, skipconstants
, flags
, pool
, effect
, compilationerrors
);
5661 UnmapViewOfFile(buffer
);
5666 HRESULT WINAPI
D3DXCreateEffectFromFileExA(struct IDirect3DDevice9
*device
, const char *srcfile
,
5667 const D3DXMACRO
*defines
, struct ID3DXInclude
*include
, const char *skipconstants
, DWORD flags
,
5668 struct ID3DXEffectPool
*pool
, struct ID3DXEffect
**effect
, struct ID3DXBuffer
**compilationerrors
)
5674 TRACE("device %p, srcfile %s, defines %p, include %p, skipconstants %s, "
5675 "flags %#x, pool %p, effect %p, compilationerrors %p.\n",
5676 device
, debugstr_a(srcfile
), defines
, include
, debugstr_a(skipconstants
),
5677 flags
, pool
, effect
, compilationerrors
);
5680 return D3DERR_INVALIDCALL
;
5682 len
= MultiByteToWideChar(CP_ACP
, 0, srcfile
, -1, NULL
, 0);
5683 srcfileW
= HeapAlloc(GetProcessHeap(), 0, len
* sizeof(*srcfileW
));
5684 MultiByteToWideChar(CP_ACP
, 0, srcfile
, -1, srcfileW
, len
);
5686 ret
= D3DXCreateEffectFromFileExW(device
, srcfileW
, defines
, include
, skipconstants
, flags
, pool
, effect
, compilationerrors
);
5687 HeapFree(GetProcessHeap(), 0, srcfileW
);
5692 HRESULT WINAPI
D3DXCreateEffectFromFileW(struct IDirect3DDevice9
*device
, const WCHAR
*srcfile
,
5693 const D3DXMACRO
*defines
, struct ID3DXInclude
*include
, DWORD flags
, struct ID3DXEffectPool
*pool
,
5694 struct ID3DXEffect
**effect
, struct ID3DXBuffer
**compilationerrors
)
5696 TRACE("(void): relay\n");
5697 return D3DXCreateEffectFromFileExW(device
, srcfile
, defines
, include
, NULL
, flags
, pool
, effect
, compilationerrors
);
5700 HRESULT WINAPI
D3DXCreateEffectFromFileA(struct IDirect3DDevice9
*device
, const char *srcfile
,
5701 const D3DXMACRO
*defines
, struct ID3DXInclude
*include
, DWORD flags
, struct ID3DXEffectPool
*pool
,
5702 struct ID3DXEffect
**effect
, struct ID3DXBuffer
**compilationerrors
)
5704 TRACE("(void): relay\n");
5705 return D3DXCreateEffectFromFileExA(device
, srcfile
, defines
, include
, NULL
, flags
, pool
, effect
, compilationerrors
);
5708 HRESULT WINAPI
D3DXCreateEffectFromResourceExW(struct IDirect3DDevice9
*device
, HMODULE srcmodule
,
5709 const WCHAR
*srcresource
, const D3DXMACRO
*defines
, struct ID3DXInclude
*include
, const char *skipconstants
,
5710 DWORD flags
, struct ID3DXEffectPool
*pool
, struct ID3DXEffect
**effect
, struct ID3DXBuffer
**compilationerrors
)
5716 TRACE("device %p, srcmodule %p, srcresource %s, defines %p, include %p, skipconstants %s, "
5717 "flags %#x, pool %p, effect %p, compilationerrors %p.\n",
5718 device
, srcmodule
, debugstr_w(srcresource
), defines
, include
, debugstr_a(skipconstants
),
5719 flags
, pool
, effect
, compilationerrors
);
5722 return D3DERR_INVALIDCALL
;
5724 if (!(resinfo
= FindResourceW(srcmodule
, srcresource
, (const WCHAR
*)RT_RCDATA
)))
5725 return D3DXERR_INVALIDDATA
;
5727 if (FAILED(load_resource_into_memory(srcmodule
, resinfo
, &buffer
, &size
)))
5728 return D3DXERR_INVALIDDATA
;
5730 return D3DXCreateEffectEx(device
, buffer
, size
, defines
, include
,
5731 skipconstants
, flags
, pool
, effect
, compilationerrors
);
5734 HRESULT WINAPI
D3DXCreateEffectFromResourceExA(struct IDirect3DDevice9
*device
, HMODULE srcmodule
,
5735 const char *srcresource
, const D3DXMACRO
*defines
, struct ID3DXInclude
*include
, const char *skipconstants
,
5736 DWORD flags
, struct ID3DXEffectPool
*pool
, struct ID3DXEffect
**effect
, struct ID3DXBuffer
**compilationerrors
)
5742 TRACE("device %p, srcmodule %p, srcresource %s, defines %p, include %p, skipconstants %s, "
5743 "flags %#x, pool %p, effect %p, compilationerrors %p.\n",
5744 device
, srcmodule
, debugstr_a(srcresource
), defines
, include
, debugstr_a(skipconstants
),
5745 flags
, pool
, effect
, compilationerrors
);
5748 return D3DERR_INVALIDCALL
;
5750 if (!(resinfo
= FindResourceA(srcmodule
, srcresource
, (const char *)RT_RCDATA
)))
5751 return D3DXERR_INVALIDDATA
;
5753 if (FAILED(load_resource_into_memory(srcmodule
, resinfo
, &buffer
, &size
)))
5754 return D3DXERR_INVALIDDATA
;
5756 return D3DXCreateEffectEx(device
, buffer
, size
, defines
, include
,
5757 skipconstants
, flags
, pool
, effect
, compilationerrors
);
5760 HRESULT WINAPI
D3DXCreateEffectFromResourceW(struct IDirect3DDevice9
*device
, HMODULE srcmodule
,
5761 const WCHAR
*srcresource
, const D3DXMACRO
*defines
, struct ID3DXInclude
*include
, DWORD flags
,
5762 struct ID3DXEffectPool
*pool
, struct ID3DXEffect
**effect
, struct ID3DXBuffer
**compilationerrors
)
5764 TRACE("(void): relay\n");
5765 return D3DXCreateEffectFromResourceExW(device
, srcmodule
, srcresource
, defines
, include
, NULL
, flags
, pool
, effect
, compilationerrors
);
5768 HRESULT WINAPI
D3DXCreateEffectFromResourceA(struct IDirect3DDevice9
*device
, HMODULE srcmodule
,
5769 const char *srcresource
, const D3DXMACRO
*defines
, struct ID3DXInclude
*include
, DWORD flags
,
5770 struct ID3DXEffectPool
*pool
, struct ID3DXEffect
**effect
, struct ID3DXBuffer
**compilationerrors
)
5772 TRACE("(void): relay\n");
5773 return D3DXCreateEffectFromResourceExA(device
, srcmodule
, srcresource
, defines
, include
, NULL
, flags
, pool
, effect
, compilationerrors
);
5776 HRESULT WINAPI
D3DXCreateEffectCompilerFromFileW(const WCHAR
*srcfile
, const D3DXMACRO
*defines
,
5777 ID3DXInclude
*include
, DWORD flags
, ID3DXEffectCompiler
**effectcompiler
, ID3DXBuffer
**parseerrors
)
5783 TRACE("srcfile %s, defines %p, include %p, flags %#x, effectcompiler %p, parseerrors %p.\n",
5784 debugstr_w(srcfile
), defines
, include
, flags
, effectcompiler
, parseerrors
);
5787 return D3DERR_INVALIDCALL
;
5789 ret
= map_view_of_file(srcfile
, &buffer
, &size
);
5792 return D3DXERR_INVALIDDATA
;
5794 ret
= D3DXCreateEffectCompiler(buffer
, size
, defines
, include
, flags
, effectcompiler
, parseerrors
);
5795 UnmapViewOfFile(buffer
);
5800 HRESULT WINAPI
D3DXCreateEffectCompilerFromFileA(const char *srcfile
, const D3DXMACRO
*defines
,
5801 ID3DXInclude
*include
, DWORD flags
, ID3DXEffectCompiler
**effectcompiler
, ID3DXBuffer
**parseerrors
)
5807 TRACE("srcfile %s, defines %p, include %p, flags %#x, effectcompiler %p, parseerrors %p.\n",
5808 debugstr_a(srcfile
), defines
, include
, flags
, effectcompiler
, parseerrors
);
5811 return D3DERR_INVALIDCALL
;
5813 len
= MultiByteToWideChar(CP_ACP
, 0, srcfile
, -1, NULL
, 0);
5814 srcfileW
= HeapAlloc(GetProcessHeap(), 0, len
* sizeof(*srcfileW
));
5815 MultiByteToWideChar(CP_ACP
, 0, srcfile
, -1, srcfileW
, len
);
5817 ret
= D3DXCreateEffectCompilerFromFileW(srcfileW
, defines
, include
, flags
, effectcompiler
, parseerrors
);
5818 HeapFree(GetProcessHeap(), 0, srcfileW
);
5823 HRESULT WINAPI
D3DXCreateEffectCompilerFromResourceA(HMODULE srcmodule
, const char *srcresource
,
5824 const D3DXMACRO
*defines
, ID3DXInclude
*include
, DWORD flags
,
5825 ID3DXEffectCompiler
**effectcompiler
, ID3DXBuffer
**parseerrors
)
5831 TRACE("srcmodule %p, srcresource %s, defines %p, include %p, flags %#x, effectcompiler %p, parseerrors %p.\n",
5832 srcmodule
, debugstr_a(srcresource
), defines
, include
, flags
, effectcompiler
, parseerrors
);
5834 if (!(resinfo
= FindResourceA(srcmodule
, srcresource
, (const char *)RT_RCDATA
)))
5835 return D3DXERR_INVALIDDATA
;
5837 if (FAILED(load_resource_into_memory(srcmodule
, resinfo
, &buffer
, &size
)))
5838 return D3DXERR_INVALIDDATA
;
5840 return D3DXCreateEffectCompiler(buffer
, size
, defines
, include
, flags
, effectcompiler
, parseerrors
);
5843 HRESULT WINAPI
D3DXCreateEffectCompilerFromResourceW(HMODULE srcmodule
, const WCHAR
*srcresource
,
5844 const D3DXMACRO
*defines
, ID3DXInclude
*include
, DWORD flags
,
5845 ID3DXEffectCompiler
**effectcompiler
, ID3DXBuffer
**parseerrors
)
5851 TRACE("srcmodule %p, srcresource %s, defines %p, include %p, flags %#x, effectcompiler %p, parseerrors %p.\n",
5852 srcmodule
, debugstr_w(srcresource
), defines
, include
, flags
, effectcompiler
, parseerrors
);
5854 if (!(resinfo
= FindResourceW(srcmodule
, srcresource
, (const WCHAR
*)RT_RCDATA
)))
5855 return D3DXERR_INVALIDDATA
;
5857 if (FAILED(load_resource_into_memory(srcmodule
, resinfo
, &buffer
, &size
)))
5858 return D3DXERR_INVALIDDATA
;
5860 return D3DXCreateEffectCompiler(buffer
, size
, defines
, include
, flags
, effectcompiler
, parseerrors
);
5863 HRESULT WINAPI
D3DXDisassembleEffect(ID3DXEffect
*effect
, BOOL enable_color_code
, ID3DXBuffer
**disassembly
)
5865 FIXME("(%p, %u, %p): stub\n", effect
, enable_color_code
, disassembly
);
5867 return D3DXERR_INVALIDDATA
;