effect.c File Reference

#include <stdio.h>
#include <assert.h>
#include "d3dx9_private.h"
#include "d3dcompiler.h"
#include "winternl.h"
#include "wine/list.h"

Include dependency graph for effect.c:

Go to the source code of this file.

Classes
struct	d3dx_object
struct	d3dx_state
struct	d3dx_sampler
struct	d3dx_pass
struct	d3dx_technique
struct	d3dx_parameter_block
struct	d3dx_recorded_parameter
struct	d3dx_effect
struct	d3dx_effect_pool
struct	ID3DXEffectCompilerImpl

Macros
#define	INT_FLOAT_MULTI   255.0f
#define	INT_FLOAT_MULTI_INVERSE   (1/INT_FLOAT_MULTI)
#define	PARAMETER_FLAG_SHARED   1
#define	INITIAL_POOL_SIZE   16
#define	INITIAL_PARAM_BLOCK_SIZE   1024
#define	INITIAL_SHARED_DATA_SIZE   4
#define	INITIAL_CONST_NAMES_SIZE   4

Typedefs
typedef BOOL(*	walk_parameter_dep_func) (void *data, struct d3dx_parameter *param)

Enumerations
enum	STATE_CLASS {   SC_LIGHTENABLE , SC_FVF , SC_LIGHT , SC_MATERIAL ,   SC_NPATCHMODE , SC_PIXELSHADER , SC_RENDERSTATE , SC_SETSAMPLER ,   SC_SAMPLERSTATE , SC_TEXTURE , SC_TEXTURESTAGE , SC_TRANSFORM ,   SC_VERTEXSHADER , SC_SHADERCONST , SC_UNKNOWN }
enum	MATERIAL_TYPE {   MT_DIFFUSE , MT_AMBIENT , MT_SPECULAR , MT_EMISSIVE ,   MT_POWER }
enum	LIGHT_TYPE {   LT_TYPE , LT_DIFFUSE , LT_SPECULAR , LT_AMBIENT ,   LT_POSITION , LT_DIRECTION , LT_RANGE , LT_FALLOFF ,   LT_ATTENUATION0 , LT_ATTENUATION1 , LT_ATTENUATION2 , LT_THETA ,   LT_PHI }
enum	SHADER_CONSTANT_TYPE {   SCT_VSFLOAT , SCT_VSBOOL , SCT_VSINT , SCT_PSFLOAT ,   SCT_PSBOOL , SCT_PSINT }
enum	STATE_TYPE { ST_CONSTANT , ST_PARAMETER , ST_FXLC , ST_ARRAY_SELECTOR }

Functions
	WINE_DEFAULT_DEBUG_CHANNEL (d3dx)
static HRESULT	d3dx_parse_state (struct d3dx_effect *effect, struct d3dx_state *state, const char *data, const char **ptr, struct d3dx_object *objects)
static void	free_parameter (struct d3dx_parameter *param, BOOL element, BOOL child)
static void	read_dword (const char **ptr, DWORD *d)
static void	skip_dword_unknown (const char **ptr, unsigned int count)
static D3DXHANDLE	get_parameter_handle (struct d3dx_parameter *parameter)
static D3DXHANDLE	get_technique_handle (struct d3dx_technique *technique)
static D3DXHANDLE	get_pass_handle (struct d3dx_pass *pass)
static struct d3dx_technique *	get_technique_by_name (struct d3dx_effect *effect, const char *name)
static struct d3dx_technique *	get_valid_technique (struct d3dx_effect *effect, D3DXHANDLE technique)
static struct d3dx_pass *	get_valid_pass (struct d3dx_effect *effect, D3DXHANDLE pass)
static struct d3dx_parameter *	get_valid_parameter (struct d3dx_effect *effect, D3DXHANDLE parameter)
static struct d3dx_parameter_block *	get_valid_parameter_block (D3DXHANDLE handle)
static void	free_state (struct d3dx_state *state)
static void	free_object (struct d3dx_object *object)
static void	free_sampler (struct d3dx_sampler *sampler)
static void	d3dx_pool_release_shared_parameter (struct d3dx_top_level_parameter *param)
static void	free_parameter_object_data (struct d3dx_parameter *param, const void *data, unsigned int bytes)
static void	free_parameter_data (struct d3dx_parameter *param, BOOL child)
static void	free_top_level_parameter (struct d3dx_top_level_parameter *param)
static void	free_pass (struct d3dx_pass *pass)
static void	free_technique (struct d3dx_technique *technique)
static unsigned int	get_recorded_parameter_size (const struct d3dx_recorded_parameter *record)
static void	free_parameter_block (struct d3dx_parameter_block *block)
static void	d3dx_effect_cleanup (struct d3dx_effect *effect)
static void	get_vector (struct d3dx_parameter *param, D3DXVECTOR4 *vector)
static void	set_vector (struct d3dx_parameter *param, const D3DXVECTOR4 *vector, void *dst_data)
static void	get_matrix (struct d3dx_parameter *param, D3DXMATRIX *matrix, BOOL transpose)
static void	set_matrix (struct d3dx_parameter *param, const D3DXMATRIX *matrix, void *dst_data)
static void	set_matrix_transpose (struct d3dx_parameter *param, const D3DXMATRIX *matrix, void *dst_data)
static HRESULT	set_string (char **param_data, const char *string)
static HRESULT	set_value (struct d3dx_parameter *param, const void *data, unsigned int bytes, void *dst_data)
static struct d3dx_parameter *	get_parameter_element_by_name (struct d3dx_effect *effect, struct d3dx_parameter *parameter, const char *name)
static struct d3dx_parameter *	get_annotation_by_name (struct d3dx_effect *effect, unsigned int count, struct d3dx_parameter *annotations, const char *name)
struct d3dx_parameter *	get_parameter_by_name (struct d3dx_effect *effect, struct d3dx_parameter *parameter, const char *name)
static DWORD	d3dx9_effect_version (DWORD major, DWORD minor)
static HRESULT	d3dx9_get_param_value_ptr (struct d3dx_pass *pass, struct d3dx_state *state, void **param_value, struct d3dx_parameter **out_param, BOOL update_all, BOOL *param_dirty)
static unsigned int	get_annotation_from_object (struct d3dx_effect *effect, D3DXHANDLE object, struct d3dx_parameter **annotations)
static BOOL	walk_parameter_tree (struct d3dx_parameter *param, walk_parameter_dep_func param_func, void *data)
static ULONG64 *	get_version_counter_ptr (struct d3dx_effect *effect)
static ULONG64	next_effect_update_version (struct d3dx_effect *effect)
static void *	record_parameter (struct d3dx_effect *effect, struct d3dx_parameter *param, unsigned int bytes)
static void	set_dirty (struct d3dx_parameter *param)
static void *	param_get_data_and_dirtify (struct d3dx_effect *effect, struct d3dx_parameter *param, unsigned int bytes, BOOL value_changed)
static void	d3dx9_set_light_parameter (enum LIGHT_TYPE op, D3DLIGHT9 *light, void *value)
static void	d3dx9_set_material_parameter (enum MATERIAL_TYPE op, D3DMATERIAL9 *material, void *value)
static HRESULT	d3dx_set_shader_const_state (struct d3dx_effect *effect, enum SHADER_CONSTANT_TYPE op, UINT index, struct d3dx_parameter *param, void *value_ptr)
static HRESULT	d3dx9_apply_state (struct d3dx_effect *effect, struct d3dx_pass *pass, struct d3dx_state *state, unsigned int parent_index, BOOL update_all)
static HRESULT	d3dx_set_shader_constants (struct d3dx_effect *effect, struct d3dx_pass *pass, struct d3dx_parameter *param, BOOL vs, BOOL update_all)
static HRESULT	d3dx9_apply_pass_states (struct d3dx_effect *effect, struct d3dx_pass *pass, BOOL update_all)
static void	param_set_data_pointer (struct d3dx_parameter *param, unsigned char *data, BOOL child, BOOL free_data)
static BOOL	is_same_parameter (void *param1_, struct d3dx_parameter *param2)
static HRESULT	d3dx_pool_sync_shared_parameter (struct d3dx_effect_pool *pool, struct d3dx_top_level_parameter *param)
static BOOL	param_zero_data_func (void *dummy, struct d3dx_parameter *param)
static struct d3dx_effect_pool *	impl_from_ID3DXEffectPool (ID3DXEffectPool *iface)
static struct d3dx_effect_pool *	unsafe_impl_from_ID3DXEffectPool (ID3DXEffectPool *iface)
static struct d3dx_effect *	impl_from_ID3DXEffect (ID3DXEffect *iface)
static HRESULT WINAPI	d3dx_effect_QueryInterface (ID3DXEffect *iface, REFIID riid, void **object)
static ULONG WINAPI	d3dx_effect_AddRef (ID3DXEffect *iface)
static ULONG WINAPI	d3dx_effect_Release (ID3DXEffect *iface)
static HRESULT WINAPI	d3dx_effect_GetDesc (ID3DXEffect *iface, D3DXEFFECT_DESC *desc)
static HRESULT WINAPI	d3dx_effect_GetParameterDesc (ID3DXEffect *iface, D3DXHANDLE parameter, D3DXPARAMETER_DESC *desc)
static HRESULT WINAPI	d3dx_effect_GetTechniqueDesc (ID3DXEffect *iface, D3DXHANDLE technique, D3DXTECHNIQUE_DESC *desc)
static HRESULT WINAPI	d3dx_effect_GetPassDesc (ID3DXEffect *iface, D3DXHANDLE pass_handle, D3DXPASS_DESC *desc)
static HRESULT WINAPI	d3dx_effect_GetFunctionDesc (ID3DXEffect *iface, D3DXHANDLE shader, D3DXFUNCTION_DESC *desc)
static D3DXHANDLE WINAPI	d3dx_effect_GetParameter (ID3DXEffect *iface, D3DXHANDLE parameter, UINT index)
static D3DXHANDLE WINAPI	d3dx_effect_GetParameterByName (ID3DXEffect *iface, D3DXHANDLE parameter, const char *name)
static D3DXHANDLE WINAPI	d3dx_effect_GetParameterBySemantic (ID3DXEffect *iface, D3DXHANDLE parameter, const char *semantic)
static D3DXHANDLE WINAPI	d3dx_effect_GetParameterElement (ID3DXEffect *iface, D3DXHANDLE parameter, UINT index)
static D3DXHANDLE WINAPI	d3dx_effect_GetTechnique (ID3DXEffect *iface, UINT index)
static D3DXHANDLE WINAPI	d3dx_effect_GetTechniqueByName (ID3DXEffect *iface, const char *name)
static D3DXHANDLE WINAPI	d3dx_effect_GetPass (ID3DXEffect *iface, D3DXHANDLE technique, UINT index)
static D3DXHANDLE WINAPI	d3dx_effect_GetPassByName (ID3DXEffect *iface, D3DXHANDLE technique, const char *name)
static D3DXHANDLE WINAPI	d3dx_effect_GetFunction (ID3DXEffect *iface, UINT index)
static D3DXHANDLE WINAPI	d3dx_effect_GetFunctionByName (ID3DXEffect *iface, const char *name)
static D3DXHANDLE WINAPI	d3dx_effect_GetAnnotation (ID3DXEffect *iface, D3DXHANDLE object, UINT index)
static D3DXHANDLE WINAPI	d3dx_effect_GetAnnotationByName (ID3DXEffect *iface, D3DXHANDLE object, const char *name)
static HRESULT WINAPI	d3dx_effect_SetValue (ID3DXEffect *iface, D3DXHANDLE parameter, const void *data, UINT bytes)
static HRESULT WINAPI	d3dx_effect_GetValue (ID3DXEffect *iface, D3DXHANDLE parameter, void *data, UINT bytes)
static HRESULT WINAPI	d3dx_effect_SetBool (ID3DXEffect *iface, D3DXHANDLE parameter, BOOL b)
static HRESULT WINAPI	d3dx_effect_GetBool (ID3DXEffect *iface, D3DXHANDLE parameter, BOOL *b)
static HRESULT WINAPI	d3dx_effect_SetBoolArray (ID3DXEffect *iface, D3DXHANDLE parameter, const BOOL *b, UINT count)
static HRESULT WINAPI	d3dx_effect_GetBoolArray (ID3DXEffect *iface, D3DXHANDLE parameter, BOOL *b, UINT count)
static HRESULT WINAPI	d3dx_effect_SetInt (ID3DXEffect *iface, D3DXHANDLE parameter, INT n)
static HRESULT WINAPI	d3dx_effect_GetInt (ID3DXEffect *iface, D3DXHANDLE parameter, INT *n)
static HRESULT WINAPI	d3dx_effect_SetIntArray (ID3DXEffect *iface, D3DXHANDLE parameter, const INT *n, UINT count)
static HRESULT WINAPI	d3dx_effect_GetIntArray (ID3DXEffect *iface, D3DXHANDLE parameter, INT *n, UINT count)
static HRESULT WINAPI	d3dx_effect_SetFloat (ID3DXEffect *iface, D3DXHANDLE parameter, float f)
static HRESULT WINAPI	d3dx_effect_GetFloat (ID3DXEffect *iface, D3DXHANDLE parameter, float *f)
static HRESULT WINAPI	d3dx_effect_SetFloatArray (ID3DXEffect *iface, D3DXHANDLE parameter, const float *f, UINT count)
static HRESULT WINAPI	d3dx_effect_GetFloatArray (ID3DXEffect *iface, D3DXHANDLE parameter, float *f, UINT count)
static HRESULT WINAPI	d3dx_effect_SetVector (ID3DXEffect *iface, D3DXHANDLE parameter, const D3DXVECTOR4 *vector)
static HRESULT WINAPI	d3dx_effect_GetVector (ID3DXEffect *iface, D3DXHANDLE parameter, D3DXVECTOR4 *vector)
static HRESULT WINAPI	d3dx_effect_SetVectorArray (ID3DXEffect *iface, D3DXHANDLE parameter, const D3DXVECTOR4 *vector, UINT count)
static HRESULT WINAPI	d3dx_effect_GetVectorArray (ID3DXEffect *iface, D3DXHANDLE parameter, D3DXVECTOR4 *vector, UINT count)
static HRESULT WINAPI	d3dx_effect_SetMatrix (ID3DXEffect *iface, D3DXHANDLE parameter, const D3DXMATRIX *matrix)
static HRESULT WINAPI	d3dx_effect_GetMatrix (ID3DXEffect *iface, D3DXHANDLE parameter, D3DXMATRIX *matrix)
static HRESULT WINAPI	d3dx_effect_SetMatrixArray (ID3DXEffect *iface, D3DXHANDLE parameter, const D3DXMATRIX *matrix, UINT count)
static HRESULT WINAPI	d3dx_effect_GetMatrixArray (ID3DXEffect *iface, D3DXHANDLE parameter, D3DXMATRIX *matrix, UINT count)
static HRESULT WINAPI	d3dx_effect_SetMatrixPointerArray (ID3DXEffect *iface, D3DXHANDLE parameter, const D3DXMATRIX **matrix, UINT count)
static HRESULT WINAPI	d3dx_effect_GetMatrixPointerArray (ID3DXEffect *iface, D3DXHANDLE parameter, D3DXMATRIX **matrix, UINT count)
static HRESULT WINAPI	d3dx_effect_SetMatrixTranspose (ID3DXEffect *iface, D3DXHANDLE parameter, const D3DXMATRIX *matrix)
static HRESULT WINAPI	d3dx_effect_GetMatrixTranspose (ID3DXEffect *iface, D3DXHANDLE parameter, D3DXMATRIX *matrix)
static HRESULT WINAPI	d3dx_effect_SetMatrixTransposeArray (ID3DXEffect *iface, D3DXHANDLE parameter, const D3DXMATRIX *matrix, UINT count)
static HRESULT WINAPI	d3dx_effect_GetMatrixTransposeArray (ID3DXEffect *iface, D3DXHANDLE parameter, D3DXMATRIX *matrix, UINT count)
static HRESULT WINAPI	d3dx_effect_SetMatrixTransposePointerArray (ID3DXEffect *iface, D3DXHANDLE parameter, const D3DXMATRIX **matrix, UINT count)
static HRESULT WINAPI	d3dx_effect_GetMatrixTransposePointerArray (ID3DXEffect *iface, D3DXHANDLE parameter, D3DXMATRIX **matrix, UINT count)
static HRESULT WINAPI	d3dx_effect_SetString (ID3DXEffect *iface, D3DXHANDLE parameter, const char *string)
static HRESULT WINAPI	d3dx_effect_GetString (ID3DXEffect *iface, D3DXHANDLE parameter, const char **string)
static HRESULT WINAPI	d3dx_effect_SetTexture (ID3DXEffect *iface, D3DXHANDLE parameter, IDirect3DBaseTexture9 *texture)
static HRESULT WINAPI	d3dx_effect_GetTexture (ID3DXEffect *iface, D3DXHANDLE parameter, IDirect3DBaseTexture9 **texture)
static HRESULT WINAPI	d3dx_effect_GetPixelShader (ID3DXEffect *iface, D3DXHANDLE parameter, IDirect3DPixelShader9 **shader)
static HRESULT WINAPI	d3dx_effect_GetVertexShader (ID3DXEffect *iface, D3DXHANDLE parameter, IDirect3DVertexShader9 **shader)
static HRESULT WINAPI	d3dx_effect_SetArrayRange (ID3DXEffect *iface, D3DXHANDLE parameter, UINT start, UINT end)
static HRESULT WINAPI	d3dx_effect_GetPool (ID3DXEffect *iface, ID3DXEffectPool **pool)
static HRESULT WINAPI	d3dx_effect_SetTechnique (ID3DXEffect *iface, D3DXHANDLE technique)
static D3DXHANDLE WINAPI	d3dx_effect_GetCurrentTechnique (ID3DXEffect *iface)
static HRESULT WINAPI	d3dx_effect_ValidateTechnique (ID3DXEffect *iface, D3DXHANDLE technique)
static HRESULT WINAPI	d3dx_effect_FindNextValidTechnique (ID3DXEffect *iface, D3DXHANDLE technique, D3DXHANDLE *next_technique)
static BOOL	walk_parameter_dep (struct d3dx_parameter *param, walk_parameter_dep_func param_func, void *data)
static BOOL	walk_param_eval_dep (struct d3dx_param_eval *param_eval, walk_parameter_dep_func param_func, void *data)
static BOOL	walk_state_dep (struct d3dx_state *state, walk_parameter_dep_func param_func, void *data)
static BOOL	is_parameter_used (struct d3dx_parameter *param, struct d3dx_technique *tech)
static BOOL WINAPI	d3dx_effect_IsParameterUsed (ID3DXEffect *iface, D3DXHANDLE parameter, D3DXHANDLE technique)
static HRESULT WINAPI	d3dx_effect_Begin (ID3DXEffect *iface, UINT *passes, DWORD flags)
static HRESULT WINAPI	d3dx_effect_BeginPass (ID3DXEffect *iface, UINT pass)
static HRESULT WINAPI	d3dx_effect_CommitChanges (ID3DXEffect *iface)
static HRESULT WINAPI	d3dx_effect_EndPass (ID3DXEffect *iface)
static HRESULT WINAPI	d3dx_effect_End (ID3DXEffect *iface)
static HRESULT WINAPI	d3dx_effect_GetDevice (ID3DXEffect *iface, struct IDirect3DDevice9 **device)
static BOOL	param_on_lost_device (void *data, struct d3dx_parameter *param)
static HRESULT WINAPI	d3dx_effect_OnLostDevice (ID3DXEffect *iface)
static HRESULT WINAPI	d3dx_effect_OnResetDevice (ID3DXEffect *iface)
static HRESULT WINAPI	d3dx_effect_SetStateManager (ID3DXEffect *iface, ID3DXEffectStateManager *manager)
static HRESULT WINAPI	d3dx_effect_GetStateManager (ID3DXEffect *iface, ID3DXEffectStateManager **manager)
static HRESULT WINAPI	d3dx_effect_BeginParameterBlock (ID3DXEffect *iface)
static D3DXHANDLE WINAPI	d3dx_effect_EndParameterBlock (ID3DXEffect *iface)
static HRESULT WINAPI	d3dx_effect_ApplyParameterBlock (ID3DXEffect *iface, D3DXHANDLE parameter_block)
static HRESULT WINAPI	d3dx_effect_CloneEffect (ID3DXEffect *iface, IDirect3DDevice9 *device, ID3DXEffect **new_effect)
static struct ID3DXEffectCompilerImpl *	impl_from_ID3DXEffectCompiler (ID3DXEffectCompiler *iface)
static HRESULT WINAPI	ID3DXEffectCompilerImpl_QueryInterface (ID3DXEffectCompiler *iface, REFIID riid, void **object)
static ULONG WINAPI	ID3DXEffectCompilerImpl_AddRef (ID3DXEffectCompiler *iface)
static ULONG WINAPI	ID3DXEffectCompilerImpl_Release (ID3DXEffectCompiler *iface)
static HRESULT WINAPI	ID3DXEffectCompilerImpl_GetDesc (ID3DXEffectCompiler *iface, D3DXEFFECT_DESC *desc)
static HRESULT WINAPI	ID3DXEffectCompilerImpl_GetParameterDesc (ID3DXEffectCompiler *iface, D3DXHANDLE parameter, D3DXPARAMETER_DESC *desc)
static HRESULT WINAPI	ID3DXEffectCompilerImpl_GetTechniqueDesc (ID3DXEffectCompiler *iface, D3DXHANDLE technique, D3DXTECHNIQUE_DESC *desc)
static HRESULT WINAPI	ID3DXEffectCompilerImpl_GetPassDesc (ID3DXEffectCompiler *iface, D3DXHANDLE pass, D3DXPASS_DESC *desc)
static HRESULT WINAPI	ID3DXEffectCompilerImpl_GetFunctionDesc (ID3DXEffectCompiler *iface, D3DXHANDLE shader, D3DXFUNCTION_DESC *desc)
static D3DXHANDLE WINAPI	ID3DXEffectCompilerImpl_GetParameter (ID3DXEffectCompiler *iface, D3DXHANDLE parameter, UINT index)
static D3DXHANDLE WINAPI	ID3DXEffectCompilerImpl_GetParameterByName (ID3DXEffectCompiler *iface, D3DXHANDLE parameter, const char *name)
static D3DXHANDLE WINAPI	ID3DXEffectCompilerImpl_GetParameterBySemantic (ID3DXEffectCompiler *iface, D3DXHANDLE parameter, const char *semantic)
static D3DXHANDLE WINAPI	ID3DXEffectCompilerImpl_GetParameterElement (ID3DXEffectCompiler *iface, D3DXHANDLE parameter, UINT index)
static D3DXHANDLE WINAPI	ID3DXEffectCompilerImpl_GetTechnique (ID3DXEffectCompiler *iface, UINT index)
static D3DXHANDLE WINAPI	ID3DXEffectCompilerImpl_GetTechniqueByName (ID3DXEffectCompiler *iface, const char *name)
static D3DXHANDLE WINAPI	ID3DXEffectCompilerImpl_GetPass (ID3DXEffectCompiler *iface, D3DXHANDLE technique, UINT index)
static D3DXHANDLE WINAPI	ID3DXEffectCompilerImpl_GetPassByName (ID3DXEffectCompiler *iface, D3DXHANDLE technique, const char *name)
static D3DXHANDLE WINAPI	ID3DXEffectCompilerImpl_GetFunction (ID3DXEffectCompiler *iface, UINT index)
static D3DXHANDLE WINAPI	ID3DXEffectCompilerImpl_GetFunctionByName (ID3DXEffectCompiler *iface, const char *name)
static D3DXHANDLE WINAPI	ID3DXEffectCompilerImpl_GetAnnotation (ID3DXEffectCompiler *iface, D3DXHANDLE object, UINT index)
static D3DXHANDLE WINAPI	ID3DXEffectCompilerImpl_GetAnnotationByName (ID3DXEffectCompiler *iface, D3DXHANDLE object, const char *name)
static HRESULT WINAPI	ID3DXEffectCompilerImpl_SetValue (ID3DXEffectCompiler *iface, D3DXHANDLE parameter, const void *data, UINT bytes)
static HRESULT WINAPI	ID3DXEffectCompilerImpl_GetValue (ID3DXEffectCompiler *iface, D3DXHANDLE parameter, void *data, UINT bytes)
static HRESULT WINAPI	ID3DXEffectCompilerImpl_SetBool (ID3DXEffectCompiler *iface, D3DXHANDLE parameter, BOOL b)
static HRESULT WINAPI	ID3DXEffectCompilerImpl_GetBool (ID3DXEffectCompiler *iface, D3DXHANDLE parameter, BOOL *b)
static HRESULT WINAPI	ID3DXEffectCompilerImpl_SetBoolArray (ID3DXEffectCompiler *iface, D3DXHANDLE parameter, const BOOL *b, UINT count)
static HRESULT WINAPI	ID3DXEffectCompilerImpl_GetBoolArray (ID3DXEffectCompiler *iface, D3DXHANDLE parameter, BOOL *b, UINT count)
static HRESULT WINAPI	ID3DXEffectCompilerImpl_SetInt (ID3DXEffectCompiler *iface, D3DXHANDLE parameter, INT n)
static HRESULT WINAPI	ID3DXEffectCompilerImpl_GetInt (ID3DXEffectCompiler *iface, D3DXHANDLE parameter, INT *n)
static HRESULT WINAPI	ID3DXEffectCompilerImpl_SetIntArray (ID3DXEffectCompiler *iface, D3DXHANDLE parameter, const INT *n, UINT count)
static HRESULT WINAPI	ID3DXEffectCompilerImpl_GetIntArray (ID3DXEffectCompiler *iface, D3DXHANDLE parameter, INT *n, UINT count)
static HRESULT WINAPI	ID3DXEffectCompilerImpl_SetFloat (ID3DXEffectCompiler *iface, D3DXHANDLE parameter, float f)
static HRESULT WINAPI	ID3DXEffectCompilerImpl_GetFloat (ID3DXEffectCompiler *iface, D3DXHANDLE parameter, float *f)
static HRESULT WINAPI	ID3DXEffectCompilerImpl_SetFloatArray (ID3DXEffectCompiler *iface, D3DXHANDLE parameter, const float *f, UINT count)
static HRESULT WINAPI	ID3DXEffectCompilerImpl_GetFloatArray (ID3DXEffectCompiler *iface, D3DXHANDLE parameter, float *f, UINT count)
static HRESULT WINAPI	ID3DXEffectCompilerImpl_SetVector (ID3DXEffectCompiler *iface, D3DXHANDLE parameter, const D3DXVECTOR4 *vector)
static HRESULT WINAPI	ID3DXEffectCompilerImpl_GetVector (ID3DXEffectCompiler *iface, D3DXHANDLE parameter, D3DXVECTOR4 *vector)
static HRESULT WINAPI	ID3DXEffectCompilerImpl_SetVectorArray (ID3DXEffectCompiler *iface, D3DXHANDLE parameter, const D3DXVECTOR4 *vector, UINT count)
static HRESULT WINAPI	ID3DXEffectCompilerImpl_GetVectorArray (ID3DXEffectCompiler *iface, D3DXHANDLE parameter, D3DXVECTOR4 *vector, UINT count)
static HRESULT WINAPI	ID3DXEffectCompilerImpl_SetMatrix (ID3DXEffectCompiler *iface, D3DXHANDLE parameter, const D3DXMATRIX *matrix)
static HRESULT WINAPI	ID3DXEffectCompilerImpl_GetMatrix (ID3DXEffectCompiler *iface, D3DXHANDLE parameter, D3DXMATRIX *matrix)
static HRESULT WINAPI	ID3DXEffectCompilerImpl_SetMatrixArray (ID3DXEffectCompiler *iface, D3DXHANDLE parameter, const D3DXMATRIX *matrix, UINT count)
static HRESULT WINAPI	ID3DXEffectCompilerImpl_GetMatrixArray (ID3DXEffectCompiler *iface, D3DXHANDLE parameter, D3DXMATRIX *matrix, UINT count)
static HRESULT WINAPI	ID3DXEffectCompilerImpl_SetMatrixPointerArray (ID3DXEffectCompiler *iface, D3DXHANDLE parameter, const D3DXMATRIX **matrix, UINT count)
static HRESULT WINAPI	ID3DXEffectCompilerImpl_GetMatrixPointerArray (ID3DXEffectCompiler *iface, D3DXHANDLE parameter, D3DXMATRIX **matrix, UINT count)
static HRESULT WINAPI	ID3DXEffectCompilerImpl_SetMatrixTranspose (ID3DXEffectCompiler *iface, D3DXHANDLE parameter, const D3DXMATRIX *matrix)
static HRESULT WINAPI	ID3DXEffectCompilerImpl_GetMatrixTranspose (ID3DXEffectCompiler *iface, D3DXHANDLE parameter, D3DXMATRIX *matrix)
static HRESULT WINAPI	ID3DXEffectCompilerImpl_SetMatrixTransposeArray (ID3DXEffectCompiler *iface, D3DXHANDLE parameter, const D3DXMATRIX *matrix, UINT count)
static HRESULT WINAPI	ID3DXEffectCompilerImpl_GetMatrixTransposeArray (ID3DXEffectCompiler *iface, D3DXHANDLE parameter, D3DXMATRIX *matrix, UINT count)
static HRESULT WINAPI	ID3DXEffectCompilerImpl_SetMatrixTransposePointerArray (ID3DXEffectCompiler *iface, D3DXHANDLE parameter, const D3DXMATRIX **matrix, UINT count)
static HRESULT WINAPI	ID3DXEffectCompilerImpl_GetMatrixTransposePointerArray (ID3DXEffectCompiler *iface, D3DXHANDLE parameter, D3DXMATRIX **matrix, UINT count)
static HRESULT WINAPI	ID3DXEffectCompilerImpl_SetString (ID3DXEffectCompiler *iface, D3DXHANDLE parameter, const char *string)
static HRESULT WINAPI	ID3DXEffectCompilerImpl_GetString (ID3DXEffectCompiler *iface, D3DXHANDLE parameter, const char **string)
static HRESULT WINAPI	ID3DXEffectCompilerImpl_SetTexture (struct ID3DXEffectCompiler *iface, D3DXHANDLE parameter, struct IDirect3DBaseTexture9 *texture)
static HRESULT WINAPI	ID3DXEffectCompilerImpl_GetTexture (struct ID3DXEffectCompiler *iface, D3DXHANDLE parameter, struct IDirect3DBaseTexture9 **texture)
static HRESULT WINAPI	ID3DXEffectCompilerImpl_GetPixelShader (ID3DXEffectCompiler *iface, D3DXHANDLE parameter, struct IDirect3DPixelShader9 **shader)
static HRESULT WINAPI	ID3DXEffectCompilerImpl_GetVertexShader (struct ID3DXEffectCompiler *iface, D3DXHANDLE parameter, struct IDirect3DVertexShader9 **shader)
static HRESULT WINAPI	ID3DXEffectCompilerImpl_SetArrayRange (ID3DXEffectCompiler *iface, D3DXHANDLE parameter, UINT start, UINT end)
static HRESULT WINAPI	ID3DXEffectCompilerImpl_SetLiteral (ID3DXEffectCompiler *iface, D3DXHANDLE parameter, BOOL literal)
static HRESULT WINAPI	ID3DXEffectCompilerImpl_GetLiteral (ID3DXEffectCompiler *iface, D3DXHANDLE parameter, BOOL *literal)
static HRESULT WINAPI	ID3DXEffectCompilerImpl_CompileEffect (ID3DXEffectCompiler *iface, DWORD flags, ID3DXBuffer **effect, ID3DXBuffer **error_msgs)
static HRESULT WINAPI	ID3DXEffectCompilerImpl_CompileShader (ID3DXEffectCompiler *iface, D3DXHANDLE function, const char *target, DWORD flags, ID3DXBuffer **shader, ID3DXBuffer **error_msgs, ID3DXConstantTable **constant_table)
static HRESULT	d3dx_parse_sampler (struct d3dx_effect *effect, struct d3dx_sampler *sampler, const char *data, const char **ptr, struct d3dx_object *objects)
static HRESULT	d3dx_parse_value (struct d3dx_effect *effect, struct d3dx_parameter *param, void *value, const char *data, const char **ptr, struct d3dx_object *objects)
static HRESULT	d3dx_parse_init_value (struct d3dx_effect *effect, struct d3dx_parameter *param, const char *data, const char *ptr, struct d3dx_object *objects)
static HRESULT	d3dx9_parse_name (char **name, const char *ptr)
static HRESULT	d3dx9_copy_data (struct d3dx_effect *effect, unsigned int object_id, const char **ptr)
static void	param_set_magic_number (struct d3dx_parameter *param)
static int	param_rb_compare (const void *key, const struct wine_rb_entry *entry)
static void	add_param_to_tree (struct d3dx_effect *effect, struct d3dx_parameter *param, struct d3dx_parameter *parent, char separator, unsigned int element)
static HRESULT	d3dx_parse_effect_typedef (struct d3dx_effect *effect, struct d3dx_parameter *param, const char *data, const char **ptr, struct d3dx_parameter *parent, UINT flags)
static HRESULT	d3dx_parse_effect_annotation (struct d3dx_effect *effect, struct d3dx_parameter *anno, const char *data, const char **ptr, struct d3dx_object *objects)
static HRESULT	d3dx_parse_effect_parameter (struct d3dx_effect *effect, struct d3dx_top_level_parameter *param, const char *data, const char **ptr, struct d3dx_object *objects)
static HRESULT	d3dx_parse_effect_pass (struct d3dx_effect *effect, struct d3dx_pass *pass, const char *data, const char **ptr, struct d3dx_object *objects)
static HRESULT	d3dx_parse_effect_technique (struct d3dx_effect *effect, struct d3dx_technique *technique, const char *data, const char **ptr, struct d3dx_object *objects)
static HRESULT	d3dx9_create_object (struct d3dx_effect *effect, struct d3dx_object *object)
static HRESULT	d3dx_parse_array_selector (struct d3dx_effect *effect, struct d3dx_state *state, const char **skip_constants, unsigned int skip_constants_count)
static HRESULT	d3dx_parse_resource (struct d3dx_effect *effect, const char *data, const char **ptr, const char **skip_constants, unsigned int skip_constants_count)
static BOOL	param_set_top_level_param (void *top_level_param, struct d3dx_parameter *param)
static HRESULT	d3dx_parse_effect (struct d3dx_effect *effect, const char *data, UINT data_size, DWORD start, const char **skip_constants, unsigned int skip_constants_count)
static char *	next_valid_constant_name (char **string)
static const char **	parse_skip_constants_string (char *skip_constants_string, unsigned int *names_count)
static HRESULT	d3dx9_effect_init (struct d3dx_effect *effect, struct IDirect3DDevice9 *device, const char *data, SIZE_T data_size, const D3D_SHADER_MACRO *defines, ID3DInclude *include, UINT eflags, ID3DBlob **errors, struct ID3DXEffectPool *pool, const char *skip_constants_string)
HRESULT WINAPI	D3DXCreateEffectEx (struct IDirect3DDevice9 *device, const void *srcdata, UINT srcdatalen, const D3DXMACRO *defines, struct ID3DXInclude *include, const char *skip_constants, DWORD flags, struct ID3DXEffectPool *pool, struct ID3DXEffect **effect, struct ID3DXBuffer **compilation_errors)
HRESULT WINAPI	D3DXCreateEffect (struct IDirect3DDevice9 *device, const void *srcdata, UINT srcdatalen, const D3DXMACRO *defines, struct ID3DXInclude *include, DWORD flags, struct ID3DXEffectPool *pool, struct ID3DXEffect **effect, struct ID3DXBuffer **compilation_errors)
static HRESULT	d3dx9_effect_compiler_init (struct ID3DXEffectCompilerImpl *compiler, const char *data, SIZE_T data_size, const D3D_SHADER_MACRO *defines, ID3DInclude *include, UINT eflags, ID3DBlob **error_messages)
HRESULT WINAPI	D3DXCreateEffectCompiler (const char *srcdata, UINT srcdatalen, const D3DXMACRO *defines, ID3DXInclude *include, DWORD flags, ID3DXEffectCompiler **compiler, ID3DXBuffer **parse_errors)
static HRESULT WINAPI	d3dx_effect_pool_QueryInterface (ID3DXEffectPool *iface, REFIID riid, void **object)
static ULONG WINAPI	d3dx_effect_pool_AddRef (ID3DXEffectPool *iface)
static void	free_effect_pool (struct d3dx_effect_pool *pool)
static ULONG WINAPI	d3dx_effect_pool_Release (ID3DXEffectPool *iface)
HRESULT WINAPI	D3DXCreateEffectPool (ID3DXEffectPool **pool)
HRESULT WINAPI	D3DXCreateEffectFromFileExW (struct IDirect3DDevice9 *device, const WCHAR *srcfile, const D3DXMACRO *defines, struct ID3DXInclude *include, const char *skipconstants, DWORD flags, struct ID3DXEffectPool *pool, struct ID3DXEffect **effect, struct ID3DXBuffer **compilationerrors)
HRESULT WINAPI	D3DXCreateEffectFromFileExA (struct IDirect3DDevice9 *device, const char *srcfile, const D3DXMACRO *defines, struct ID3DXInclude *include, const char *skipconstants, DWORD flags, struct ID3DXEffectPool *pool, struct ID3DXEffect **effect, struct ID3DXBuffer **compilationerrors)
HRESULT WINAPI	D3DXCreateEffectFromFileW (struct IDirect3DDevice9 *device, const WCHAR *srcfile, const D3DXMACRO *defines, struct ID3DXInclude *include, DWORD flags, struct ID3DXEffectPool *pool, struct ID3DXEffect **effect, struct ID3DXBuffer **compilationerrors)
HRESULT WINAPI	D3DXCreateEffectFromFileA (struct IDirect3DDevice9 *device, const char *srcfile, const D3DXMACRO *defines, struct ID3DXInclude *include, DWORD flags, struct ID3DXEffectPool *pool, struct ID3DXEffect **effect, struct ID3DXBuffer **compilationerrors)
HRESULT WINAPI	D3DXCreateEffectFromResourceExW (struct IDirect3DDevice9 *device, HMODULE srcmodule, const WCHAR *srcresource, const D3DXMACRO *defines, struct ID3DXInclude *include, const char *skipconstants, DWORD flags, struct ID3DXEffectPool *pool, struct ID3DXEffect **effect, struct ID3DXBuffer **compilationerrors)
HRESULT WINAPI	D3DXCreateEffectFromResourceExA (struct IDirect3DDevice9 *device, HMODULE srcmodule, const char *srcresource, const D3DXMACRO *defines, struct ID3DXInclude *include, const char *skipconstants, DWORD flags, struct ID3DXEffectPool *pool, struct ID3DXEffect **effect, struct ID3DXBuffer **compilationerrors)
HRESULT WINAPI	D3DXCreateEffectFromResourceW (struct IDirect3DDevice9 *device, HMODULE srcmodule, const WCHAR *srcresource, const D3DXMACRO *defines, struct ID3DXInclude *include, DWORD flags, struct ID3DXEffectPool *pool, struct ID3DXEffect **effect, struct ID3DXBuffer **compilationerrors)
HRESULT WINAPI	D3DXCreateEffectFromResourceA (struct IDirect3DDevice9 *device, HMODULE srcmodule, const char *srcresource, const D3DXMACRO *defines, struct ID3DXInclude *include, DWORD flags, struct ID3DXEffectPool *pool, struct ID3DXEffect **effect, struct ID3DXBuffer **compilationerrors)
HRESULT WINAPI	D3DXCreateEffectCompilerFromFileW (const WCHAR *srcfile, const D3DXMACRO *defines, ID3DXInclude *include, DWORD flags, ID3DXEffectCompiler **effectcompiler, ID3DXBuffer **parseerrors)
HRESULT WINAPI	D3DXCreateEffectCompilerFromFileA (const char *srcfile, const D3DXMACRO *defines, ID3DXInclude *include, DWORD flags, ID3DXEffectCompiler **effectcompiler, ID3DXBuffer **parseerrors)
HRESULT WINAPI	D3DXCreateEffectCompilerFromResourceA (HMODULE srcmodule, const char *srcresource, const D3DXMACRO *defines, ID3DXInclude *include, DWORD flags, ID3DXEffectCompiler **effectcompiler, ID3DXBuffer **parseerrors)
HRESULT WINAPI	D3DXCreateEffectCompilerFromResourceW (HMODULE srcmodule, const WCHAR *srcresource, const D3DXMACRO *defines, ID3DXInclude *include, DWORD flags, ID3DXEffectCompiler **effectcompiler, ID3DXBuffer **parseerrors)
HRESULT WINAPI	D3DXDisassembleEffect (ID3DXEffect *effect, BOOL enable_color_code, ID3DXBuffer **disassembly)

Variables
static const char	parameter_magic_string [4] = {'@', '!', '#', '\xFF'}
static const char	parameter_block_magic_string [4] = {'@', '!', '#', '\xFE'}
struct {
enum STATE_CLASS   class
UINT   op
const char *   name
}	state_table []
static const struct ID3DXEffectVtbl	ID3DXEffect_Vtbl
static const struct ID3DXEffectCompilerVtbl	ID3DXEffectCompiler_Vtbl
static const struct ID3DXEffectPoolVtbl	ID3DXEffectPool_Vtbl

Macro Definition Documentation

INITIAL_CONST_NAMES_SIZE

#define INITIAL_CONST_NAMES_SIZE   4

Definition at line 6339 of file effect.c.

INITIAL_PARAM_BLOCK_SIZE

#define INITIAL_PARAM_BLOCK_SIZE   1024

Definition at line 43 of file effect.c.

INITIAL_POOL_SIZE

#define INITIAL_POOL_SIZE   16

Definition at line 42 of file effect.c.

INITIAL_SHARED_DATA_SIZE

#define INITIAL_SHARED_DATA_SIZE   4

Definition at line 208 of file effect.c.

INT_FLOAT_MULTI

#define INT_FLOAT_MULTI   255.0f

Definition at line 34 of file effect.c.

INT_FLOAT_MULTI_INVERSE

#define INT_FLOAT_MULTI_INVERSE   (1/INT_FLOAT_MULTI)

Definition at line 35 of file effect.c.

PARAMETER_FLAG_SHARED

#define PARAMETER_FLAG_SHARED   1

Definition at line 40 of file effect.c.

Typedef Documentation

walk_parameter_dep_func

typedef BOOL(* walk_parameter_dep_func) (void *data, struct d3dx_parameter *param)

Definition at line 231 of file effect.c.

Enumeration Type Documentation

LIGHT_TYPE

enum LIGHT_TYPE

Enumerator
LT_TYPE
LT_DIFFUSE
LT_SPECULAR
LT_AMBIENT
LT_POSITION
LT_DIRECTION
LT_RANGE
LT_FALLOFF
LT_ATTENUATION0
LT_ATTENUATION1
LT_ATTENUATION2
LT_THETA
LT_PHI

Definition at line 75 of file effect.c.

{
    LT_TYPE,
    LT_DIFFUSE,
    LT_SPECULAR,
    LT_AMBIENT,
    LT_POSITION,
    LT_DIRECTION,
    LT_RANGE,
    LT_FALLOFF,
    LT_ATTENUATION0,
    LT_ATTENUATION1,
    LT_ATTENUATION2,
    LT_THETA,
    LT_PHI,
};

MATERIAL_TYPE

enum MATERIAL_TYPE

Enumerator
MT_DIFFUSE
MT_AMBIENT
MT_SPECULAR
MT_EMISSIVE
MT_POWER

Definition at line 66 of file effect.c.

{
    MT_DIFFUSE,
    MT_AMBIENT,
    MT_SPECULAR,
    MT_EMISSIVE,
    MT_POWER,
};

SHADER_CONSTANT_TYPE

enum SHADER_CONSTANT_TYPE

Enumerator
SCT_VSFLOAT
SCT_VSBOOL
SCT_VSINT
SCT_PSFLOAT
SCT_PSBOOL
SCT_PSINT

Definition at line 92 of file effect.c.

{
    SCT_VSFLOAT,
    SCT_VSBOOL,
    SCT_VSINT,
    SCT_PSFLOAT,
    SCT_PSBOOL,
    SCT_PSINT,
};

STATE_CLASS

enum STATE_CLASS

Enumerator
SC_LIGHTENABLE
SC_FVF
SC_LIGHT
SC_MATERIAL
SC_NPATCHMODE
SC_PIXELSHADER
SC_RENDERSTATE
SC_SETSAMPLER
SC_SAMPLERSTATE
SC_TEXTURE
SC_TEXTURESTAGE
SC_TRANSFORM
SC_VERTEXSHADER
SC_SHADERCONST
SC_UNKNOWN

Definition at line 47 of file effect.c.

{
    SC_LIGHTENABLE,
    SC_FVF,
    SC_LIGHT,
    SC_MATERIAL,
    SC_NPATCHMODE,
    SC_PIXELSHADER,
    SC_RENDERSTATE,
    SC_SETSAMPLER,
    SC_SAMPLERSTATE,
    SC_TEXTURE,
    SC_TEXTURESTAGE,
    SC_TRANSFORM,
    SC_VERTEXSHADER,
    SC_SHADERCONST,
    SC_UNKNOWN,
};

STATE_TYPE

enum STATE_TYPE

Enumerator
ST_CONSTANT
ST_PARAMETER
ST_FXLC
ST_ARRAY_SELECTOR

Definition at line 102 of file effect.c.

{
    ST_CONSTANT,
    ST_PARAMETER,
    ST_FXLC,
    ST_ARRAY_SELECTOR,
};

Function Documentation

add_param_to_tree()

static void add_param_to_tree ( struct d3dx_effect *  effect, struct d3dx_parameter *  param, struct d3dx_parameter *  parent, char  separator, unsigned int  element  )

static

Definition at line 5266 of file effect.c.

{
    const char *parent_name = parent ? parent->full_name : NULL;
    unsigned int i;
 
    TRACE("Adding parameter %p (%s - parent %p, element %u) to the rbtree.\n",
            param, debugstr_a(param->name), parent, element);
 
    if (parent_name)
    {
        unsigned int parent_name_len = strlen(parent_name);
        unsigned int name_len = strlen(param->name);
        unsigned int part_str_len;
        unsigned int len;
        char part_str[16];
 
        if (separator == '[')
        {
            sprintf(part_str, "[%u]", element);
            part_str_len = strlen(part_str);
            name_len = 0;
        }
        else
        {
            part_str[0] = separator;
            part_str[1] = 0;
            part_str_len = 1;
        }
        len = parent_name_len + part_str_len + name_len + 1;
 
        if (!(param->full_name = heap_alloc(len)))
        {
            ERR("Out of memory.\n");
            return;
        }
 
        memcpy(param->full_name, parent_name, parent_name_len);
        memcpy(param->full_name + parent_name_len, part_str, part_str_len);
        memcpy(param->full_name + parent_name_len + part_str_len, param->name, name_len);
        param->full_name[len - 1] = 0;
    }
    else
    {
        unsigned int len = strlen(param->name) + 1;
 
        if (!(param->full_name = heap_alloc(len)))
        {
            ERR("Out of memory.\n");
            return;
        }
 
        memcpy(param->full_name, param->name, len);
    }
    TRACE("Full name is %s.\n", param->full_name);
    wine_rb_put(&effect->param_tree, param->full_name, &param->rb_entry);
 
    if (is_top_level_parameter(param))
        for (i = 0; i < param->top_level_param->annotation_count; ++i)
            add_param_to_tree(effect, &param->top_level_param->annotations[i], param, '@', 0);
 
    if (param->element_count)
        for (i = 0; i < param->element_count; ++i)
            add_param_to_tree(effect, &param->members[i], param, '[', i);
    else
        for (i = 0; i < param->member_count; ++i)
            add_param_to_tree(effect, &param->members[i], param, '.', 0);
}

Referenced by add_param_to_tree(), and d3dx_parse_effect().

d3dx9_apply_pass_states()

static HRESULT d3dx9_apply_pass_states ( struct d3dx_effect *  effect, struct d3dx_pass *  pass, BOOL  update_all  )

static

Definition at line 1731 of file effect.c.

{
    unsigned int i;
    HRESULT ret;
    HRESULT hr;
    ULONG64 new_update_version = next_effect_update_version(effect);
 
    TRACE("effect %p, pass %p, state_count %u.\n", effect, pass, pass->state_count);
 
    ret = D3D_OK;
    for (i = 0; i < pass->state_count; ++i)
    {
        if (FAILED(hr = d3dx9_apply_state(effect, pass, &pass->states[i], ~0u, update_all)))
        {
            WARN("Error applying state, hr %#x.\n", hr);
            ret = hr;
        }
    }
 
    if (effect->light_updated)
    {
        for (i = 0; i < ARRAY_SIZE(effect->current_light); ++i)
        {
            if ((effect->light_updated & (1u << i))
                    && FAILED(hr = SET_D3D_STATE(effect, SetLight, i, &effect->current_light[i])))
            {
                WARN("Error setting light, hr %#x.\n", hr);
                ret = hr;
            }
        }
        effect->light_updated = 0;
    }
 
    if (effect->material_updated
            && FAILED(hr = SET_D3D_STATE(effect, SetMaterial, &effect->current_material)))
    {
        WARN("Error setting material, hr %#x.\n", hr);
        ret = hr;
    }
    effect->material_updated = FALSE;
 
    pass->update_version = new_update_version;
    return ret;
}

Referenced by d3dx_effect_Begin(), d3dx_effect_BeginPass(), and d3dx_effect_CommitChanges().

d3dx9_apply_state()

static HRESULT d3dx9_apply_state ( struct d3dx_effect *  effect, struct d3dx_pass *  pass, struct d3dx_state *  state, unsigned int  parent_index, BOOL  update_all  )

static

Definition at line 1595 of file effect.c.

{
    struct d3dx_parameter *param;
    void *param_value;
    BOOL param_dirty;
    HRESULT hr;
 
    TRACE("operation %u, index %u, type %u.\n", state->operation, state->index, state->type);
 
    if (FAILED(hr = d3dx9_get_param_value_ptr(pass, state, &param_value, &param,
            update_all, &param_dirty)))
    {
        if (!update_all && hr == E_FAIL)
        {
            /* Native d3dx9 returns D3D_OK from CommitChanges() involving
             * out of bounds array access and does not touch the affected
             * states. */
            WARN("Returning D3D_OK on out of bounds array access.\n");
            return D3D_OK;
        }
        return hr;
    }
 
    if (!(update_all || param_dirty
            || state_table[state->operation].class == SC_VERTEXSHADER
            || state_table[state->operation].class == SC_PIXELSHADER
            || state_table[state->operation].class == SC_SETSAMPLER))
        return D3D_OK;
 
    switch (state_table[state->operation].class)
    {
        case SC_RENDERSTATE:
            TRACE("%s, operation %u, value %u.\n", state_table[state->operation].name,
                    state_table[state->operation].op, *(DWORD *)param_value);
            return SET_D3D_STATE(effect, SetRenderState, state_table[state->operation].op, *(DWORD *)param_value);
        case SC_FVF:
            TRACE("%s, value %#x.\n", state_table[state->operation].name, *(DWORD *)param_value);
            return SET_D3D_STATE(effect, SetFVF, *(DWORD *)param_value);
        case SC_TEXTURE:
        {
            UINT unit;
 
            unit = parent_index == ~0u ? state->index : parent_index;
            TRACE("%s, unit %u, value %p.\n", state_table[state->operation].name, unit,
                    *(IDirect3DBaseTexture9 **)param_value);
            return SET_D3D_STATE(effect, SetTexture, unit, *(IDirect3DBaseTexture9 **)param_value);
        }
        case SC_TEXTURESTAGE:
            TRACE("%s, stage %u, value %u.\n", state_table[state->operation].name, state->index, *(DWORD *)param_value);
            return SET_D3D_STATE(effect, SetTextureStageState, state->index,
                        state_table[state->operation].op, *(DWORD *)param_value);
        case SC_SETSAMPLER:
        {
            struct d3dx_sampler *sampler;
            HRESULT ret, hr;
            unsigned int i;
 
            sampler = (struct d3dx_sampler *)param_value;
            TRACE("%s, sampler %u, applying %u states.\n", state_table[state->operation].name, state->index,
                    sampler->state_count);
            ret = D3D_OK;
            for (i = 0; i < sampler->state_count; i++)
            {
                if (FAILED(hr = d3dx9_apply_state(effect, pass, &sampler->states[i], state->index, update_all)))
                    ret = hr;
            }
            return ret;
        }
        case SC_SAMPLERSTATE:
        {
            UINT sampler;
 
            sampler = parent_index == ~0u ? state->index : parent_index;
            TRACE("%s, sampler %u, value %u.\n", state_table[state->operation].name, sampler, *(DWORD *)param_value);
            return SET_D3D_STATE(effect, SetSamplerState, sampler, state_table[state->operation].op,
                    *(DWORD *)param_value);
        }
        case SC_VERTEXSHADER:
            TRACE("%s, shader %p.\n", state_table[state->operation].name, *(IDirect3DVertexShader9 **)param_value);
            if ((update_all || param_dirty)
                    && FAILED(hr = SET_D3D_STATE(effect, SetVertexShader,
                    *(IDirect3DVertexShader9 **)param_value)))
                ERR("Could not set vertex shader, hr %#x.\n", hr);
            else if (*(IDirect3DVertexShader9 **)param_value)
                hr = d3dx_set_shader_constants(effect, pass, param, TRUE, update_all || param_dirty);
            return hr;
        case SC_PIXELSHADER:
            TRACE("%s, shader %p.\n", state_table[state->operation].name, *(IDirect3DPixelShader9 **)param_value);
            if ((update_all || param_dirty)
                    && FAILED(hr = SET_D3D_STATE(effect, SetPixelShader,
                    *(IDirect3DPixelShader9 **)param_value)))
                ERR("Could not set pixel shader, hr %#x.\n", hr);
            else if (*(IDirect3DPixelShader9 **)param_value)
                hr = d3dx_set_shader_constants(effect, pass, param, FALSE, update_all || param_dirty);
            return hr;
        case SC_TRANSFORM:
            TRACE("%s, state %u.\n", state_table[state->operation].name, state->index);
            return SET_D3D_STATE(effect, SetTransform, state_table[state->operation].op + state->index,
                    (D3DMATRIX *)param_value);
        case SC_LIGHTENABLE:
            TRACE("%s, index %u, value %u.\n", state_table[state->operation].name, state->index, *(BOOL *)param_value);
            return SET_D3D_STATE(effect, LightEnable, state->index, *(BOOL *)param_value);
        case SC_LIGHT:
        {
            TRACE("%s, index %u, op %u.\n", state_table[state->operation].name, state->index,
                    state_table[state->operation].op);
            d3dx9_set_light_parameter(state_table[state->operation].op,
                    &effect->current_light[state->index], param_value);
            effect->light_updated |= 1u << state->index;
            return D3D_OK;
        }
        case SC_MATERIAL:
        {
            TRACE("%s, index %u, op %u.\n", state_table[state->operation].name, state->index,
                    state_table[state->operation].op);
            d3dx9_set_material_parameter(state_table[state->operation].op,
                    &effect->current_material, param_value);
            effect->material_updated = TRUE;
            return D3D_OK;
        }
        case SC_NPATCHMODE:
            TRACE("%s, nsegments %f.\n", state_table[state->operation].name, *(float *)param_value);
            return SET_D3D_STATE(effect, SetNPatchMode, *(float *)param_value);
        case SC_SHADERCONST:
            TRACE("%s, index %u, op %u.\n", state_table[state->operation].name, state->index,
                state_table[state->operation].op);
            return d3dx_set_shader_const_state(effect, state_table[state->operation].op, state->index,
                param, param_value);
        default:
            FIXME("%s not handled.\n", state_table[state->operation].name);
            break;
    }
    return D3D_OK;
}

Referenced by d3dx9_apply_pass_states(), d3dx9_apply_state(), and d3dx_set_shader_constants().

d3dx9_copy_data()

static HRESULT d3dx9_copy_data ( struct d3dx_effect *  effect, unsigned int  object_id, const char **  ptr  )

static

Definition at line 5217 of file effect.c.

{
    struct d3dx_object *object = &effect->objects[object_id];
 
    if (object->size || object->data)
    {
        if (object_id)
            FIXME("Overwriting object id %u!\n", object_id);
        else
            TRACE("Overwriting object id 0.\n");
 
        HeapFree(GetProcessHeap(), 0, object->data);
        object->data = NULL;
    }
 
    read_dword(ptr, &object->size);
    TRACE("Data size: %#x.\n", object->size);
 
    if (!object->size)
        return D3D_OK;
 
    object->data = HeapAlloc(GetProcessHeap(), 0, object->size);
    if (!object->data)
    {
        ERR("Failed to allocate object memory.\n");
        return E_OUTOFMEMORY;
    }
 
    TRACE("Data: %s.\n", debugstr_an(*ptr, object->size));
    memcpy(object->data, *ptr, object->size);
 
    *ptr += ((object->size + 3) & ~3);
 
    return D3D_OK;
}

Referenced by d3dx_parse_effect(), and d3dx_parse_resource().

d3dx9_create_object()

static HRESULT d3dx9_create_object ( struct d3dx_effect *  effect, struct d3dx_object *  object  )

static

Definition at line 5901 of file effect.c.

{
    struct d3dx_parameter *param = object->param;
    IDirect3DDevice9 *device = effect->device;
    HRESULT hr;
 
    if (*(char **)param->data)
        ERR("Parameter data already allocated.\n");
 
    switch (param->type)
    {
        case D3DXPT_STRING:
            *(char **)param->data = HeapAlloc(GetProcessHeap(), 0, object->size);
            if (!*(char **)param->data)
            {
                ERR("Out of memory.\n");
                return E_OUTOFMEMORY;
            }
            memcpy(*(char **)param->data, object->data, object->size);
            break;
        case D3DXPT_VERTEXSHADER:
            if (FAILED(hr = IDirect3DDevice9_CreateVertexShader(device, object->data,
                    (IDirect3DVertexShader9 **)param->data)))
            {
                WARN("Failed to create vertex shader.\n");
                object->creation_failed = TRUE;
            }
            break;
        case D3DXPT_PIXELSHADER:
            if (FAILED(hr = IDirect3DDevice9_CreatePixelShader(device, object->data,
                    (IDirect3DPixelShader9 **)param->data)))
            {
                WARN("Failed to create pixel shader.\n");
                object->creation_failed = TRUE;
            }
            break;
        default:
            break;
    }
    return D3D_OK;
}

Referenced by d3dx_parse_effect(), and d3dx_parse_resource().

d3dx9_effect_compiler_init()

static HRESULT d3dx9_effect_compiler_init ( struct ID3DXEffectCompilerImpl *  compiler, const char *  data, SIZE_T  data_size, const D3D_SHADER_MACRO *  defines, ID3DInclude *  include, UINT  eflags, ID3DBlob **  error_messages  )

static

Definition at line 6611 of file effect.c.

{
    TRACE("compiler %p, data %p, data_size %lu, defines %p, include %p, eflags %#x, error_messages %p.\n",
            compiler, data, data_size, defines, include, eflags, error_messages);
 
    compiler->ID3DXEffectCompiler_iface.lpVtbl = &ID3DXEffectCompiler_Vtbl;
    compiler->ref = 1;
 
    FIXME("ID3DXEffectCompiler implementation is only a stub.\n");
 
    return D3D_OK;
}

Referenced by D3DXCreateEffectCompiler().

d3dx9_effect_init()

static HRESULT d3dx9_effect_init ( struct d3dx_effect *  effect, struct IDirect3DDevice9 *  device, const char *  data, SIZE_T  data_size, const D3D_SHADER_MACRO *  defines, ID3DInclude *  include, UINT  eflags, ID3DBlob **  errors, struct ID3DXEffectPool *  pool, const char *  skip_constants_string  )

static

Definition at line 6394 of file effect.c.

{
#if D3DX_SDK_VERSION <= 36
    UINT compile_flags = D3DCOMPILE_ENABLE_BACKWARDS_COMPATIBILITY;
#else
    UINT compile_flags = 0;
#endif
    ID3DBlob *bytecode = NULL, *temp_errors = NULL;
    unsigned int skip_constants_count = 0;
    char *skip_constants_buffer = NULL;
    const char **skip_constants = NULL;
    const char *ptr = data;
    DWORD tag, offset;
    unsigned int i, j;
    HRESULT hr;
 
    TRACE("effect %p, device %p, data %p, data_size %lu, defines %p, include %p, eflags %#x, errors %p, "
            "pool %p, skip_constants %s.\n",
            effect, device, data, data_size, defines, include, eflags, errors, pool,
            debugstr_a(skip_constants_string));
 
    effect->ID3DXEffect_iface.lpVtbl = &ID3DXEffect_Vtbl;
    effect->ref = 1;
 
    if (pool)
    {
        effect->pool = unsafe_impl_from_ID3DXEffectPool(pool);
        pool->lpVtbl->AddRef(pool);
    }
 
    IDirect3DDevice9_AddRef(device);
    effect->device = device;
 
    effect->flags = eflags;
 
    list_init(&effect->parameter_block_list);
 
    read_dword(&ptr, &tag);
    TRACE("Tag: %x\n", tag);
 
    if (tag != d3dx9_effect_version(9, 1))
    {
        TRACE("HLSL ASCII effect, trying to compile it.\n");
        hr = D3DCompile(data, data_size, NULL, defines, include,
                NULL, "fx_2_0", compile_flags, eflags, &bytecode, &temp_errors);
        if (FAILED(hr))
        {
            WARN("Failed to compile ASCII effect.\n");
            if (bytecode)
                ID3D10Blob_Release(bytecode);
            if (temp_errors)
            {
                const char *error_string = ID3D10Blob_GetBufferPointer(temp_errors);
                const char *string_ptr;
 
                while (*error_string)
                {
                    string_ptr = error_string;
                    while (*string_ptr && *string_ptr != '\n' && *string_ptr != '\r'
                           && string_ptr - error_string < 80)
                        ++string_ptr;
                    TRACE("%s\n", debugstr_an(error_string, string_ptr - error_string));
                    error_string = string_ptr;
                    while (*error_string == '\n' || *error_string == '\r')
                        ++error_string;
                }
            }
            if (errors)
                *errors = temp_errors;
            else if (temp_errors)
                ID3D10Blob_Release(temp_errors);
            return hr;
        }
        if (!bytecode)
        {
            FIXME("No output from effect compilation.\n");
            return D3DERR_INVALIDCALL;
        }
        if (errors)
            *errors = temp_errors;
        else if (temp_errors)
            ID3D10Blob_Release(temp_errors);
 
        ptr = ID3D10Blob_GetBufferPointer(bytecode);
        read_dword(&ptr, &tag);
        TRACE("Tag: %x\n", tag);
    }
 
    if (skip_constants_string)
    {
        skip_constants_buffer = HeapAlloc(GetProcessHeap(), 0,
                sizeof(*skip_constants_buffer) * (strlen(skip_constants_string) + 1));
        if (!skip_constants_buffer)
        {
            if (bytecode)
                ID3D10Blob_Release(bytecode);
            return E_OUTOFMEMORY;
        }
        strcpy(skip_constants_buffer, skip_constants_string);
 
        if (!(skip_constants = parse_skip_constants_string(skip_constants_buffer, &skip_constants_count)))
        {
            HeapFree(GetProcessHeap(), 0, skip_constants_buffer);
            if (bytecode)
                ID3D10Blob_Release(bytecode);
            return E_OUTOFMEMORY;
        }
    }
    read_dword(&ptr, &offset);
    TRACE("Offset: %x\n", offset);
 
    hr = d3dx_parse_effect(effect, ptr, data_size, offset, skip_constants, skip_constants_count);
    if (bytecode)
        ID3D10Blob_Release(bytecode);
    if (hr != D3D_OK)
    {
        FIXME("Failed to parse effect.\n");
        HeapFree(GetProcessHeap(), 0, skip_constants_buffer);
        HeapFree(GetProcessHeap(), 0, skip_constants);
        return hr;
    }
 
    for (i = 0; i < skip_constants_count; ++i)
    {
        struct d3dx_parameter *param;
        param = get_parameter_by_name(effect, NULL, skip_constants[i]);
        if (param)
        {
            for (j = 0; j < effect->technique_count; ++j)
            {
                if (is_parameter_used(param, &effect->techniques[j]))
                {
                    WARN("skip_constants parameter %s is used in technique %u.\n",
                            debugstr_a(skip_constants[i]), j);
                    HeapFree(GetProcessHeap(), 0, skip_constants_buffer);
                    HeapFree(GetProcessHeap(), 0, skip_constants);
                    return D3DERR_INVALIDCALL;
                }
            }
        }
        else
        {
            TRACE("skip_constants parameter %s not found.\n",
                    debugstr_a(skip_constants[i]));
        }
    }
 
    HeapFree(GetProcessHeap(), 0, skip_constants_buffer);
    HeapFree(GetProcessHeap(), 0, skip_constants);
 
    /* initialize defaults - check because of unsupported ascii effects */
    if (effect->techniques)
    {
        effect->active_technique = &effect->techniques[0];
        effect->active_pass = NULL;
    }
 
    return D3D_OK;
}

Referenced by D3DXCreateEffectEx().

d3dx9_effect_version()

static DWORD d3dx9_effect_version ( DWORD  major, DWORD  minor  )

inlinestatic

Definition at line 1114 of file effect.c.

{
    return (0xfeff0000 | ((major) << 8) | (minor));
}

Referenced by d3dx9_effect_init().

d3dx9_get_param_value_ptr()

static HRESULT d3dx9_get_param_value_ptr ( struct d3dx_pass *  pass, struct d3dx_state *  state, void **  param_value, struct d3dx_parameter **  out_param, BOOL  update_all, BOOL *  param_dirty  )

static

Definition at line 1119 of file effect.c.

{
    struct d3dx_parameter *param = &state->parameter;
 
    *param_value = NULL;
    *out_param = NULL;
    *param_dirty = FALSE;
 
    switch (state->type)
    {
        case ST_PARAMETER:
            param = state->referenced_param;
            *param_dirty = is_param_dirty(param, pass->update_version);
            /* fallthrough */
        case ST_CONSTANT:
            *out_param = param;
            *param_value = param->data;
            return D3D_OK;
        case ST_ARRAY_SELECTOR:
        {
            unsigned int array_idx;
            static const struct d3dx_parameter array_idx_param =
                {"", NULL, NULL, NULL, NULL, D3DXPC_SCALAR, D3DXPT_INT, 1, 1, 0, 0, 0, sizeof(array_idx)};
            HRESULT hr;
            struct d3dx_parameter *ref_param, *selected_param;
 
            if (!param->param_eval)
            {
                FIXME("Preshader structure is null.\n");
                return D3DERR_INVALIDCALL;
            }
            /* We override with the update_version of the pass because we want
             * to force index recomputation and check for out of bounds. */
            if (is_param_eval_input_dirty(param->param_eval, pass->update_version))
            {
                if (FAILED(hr = d3dx_evaluate_parameter(param->param_eval, &array_idx_param, &array_idx)))
                    return hr;
            }
            else
            {
                array_idx = state->index;
            }
            ref_param = state->referenced_param;
            TRACE("Array index %u, stored array index %u, element_count %u.\n", array_idx, state->index,
                    ref_param->element_count);
            /* According to the tests, native d3dx handles the case of array index evaluated to -1
             * in a specific way, always selecting first array element and not returning error. */
            if (array_idx == ~0u)
            {
                WARN("Array index is -1, setting to 0.\n");
                array_idx = 0;
            }
 
            if (array_idx >= ref_param->element_count)
            {
                WARN("Computed array index %u is larger than array size %u.\n",
                        array_idx, ref_param->element_count);
                return E_FAIL;
            }
            selected_param = &ref_param->members[array_idx];
            *param_dirty = state->index != array_idx || is_param_dirty(selected_param, pass->update_version);
            state->index = array_idx;
 
            *param_value = selected_param->data;
            *out_param = selected_param;
            return D3D_OK;
        }
        case ST_FXLC:
            if (param->param_eval)
            {
                *out_param = param;
                *param_value = param->data;
                /* We check with the update_version of the pass because the
                 * same preshader might be used by both the vertex and the
                 * pixel shader (that can happen e.g. for sampler states). */
                if (update_all || is_param_eval_input_dirty(param->param_eval, pass->update_version))
                {
                    *param_dirty = TRUE;
                    return d3dx_evaluate_parameter(param->param_eval, param, *param_value);
                }
                else
                    return D3D_OK;
            }
            else
            {
                FIXME("No preshader for FXLC parameter.\n");
                return D3DERR_INVALIDCALL;
            }
    }
    return E_NOTIMPL;
}

Referenced by d3dx9_apply_state(), d3dx_effect_GetPassDesc(), and d3dx_effect_ValidateTechnique().

d3dx9_parse_name()

static HRESULT d3dx9_parse_name ( char **  name, const char *  ptr  )

static

Definition at line 5192 of file effect.c.

{
    DWORD size;
 
    read_dword(&ptr, &size);
    TRACE("Name size: %#x\n", size);
 
    if (!size)
    {
        return D3D_OK;
    }
 
    *name = HeapAlloc(GetProcessHeap(), 0, size);
    if (!*name)
    {
        ERR("Failed to allocate name memory.\n");
        return E_OUTOFMEMORY;
    }
 
    TRACE("Name: %s.\n", debugstr_an(ptr, size));
    memcpy(*name, ptr, size);
 
    return D3D_OK;
}

Referenced by d3dx_parse_effect_pass(), d3dx_parse_effect_technique(), and d3dx_parse_effect_typedef().

d3dx9_set_light_parameter()

static void d3dx9_set_light_parameter ( enum LIGHT_TYPE  op, D3DLIGHT9 *  light, void *  value  )

static

Definition at line 1341 of file effect.c.

{
    static const struct
    {
        unsigned int offset;
        const char *name;
    }
    light_tbl[] =
    {
        {FIELD_OFFSET(D3DLIGHT9, Type),         "LC_TYPE"},
        {FIELD_OFFSET(D3DLIGHT9, Diffuse),      "LT_DIFFUSE"},
        {FIELD_OFFSET(D3DLIGHT9, Specular),     "LT_SPECULAR"},
        {FIELD_OFFSET(D3DLIGHT9, Ambient),      "LT_AMBIENT"},
        {FIELD_OFFSET(D3DLIGHT9, Position),     "LT_POSITION"},
        {FIELD_OFFSET(D3DLIGHT9, Direction),    "LT_DIRECTION"},
        {FIELD_OFFSET(D3DLIGHT9, Range),        "LT_RANGE"},
        {FIELD_OFFSET(D3DLIGHT9, Falloff),      "LT_FALLOFF"},
        {FIELD_OFFSET(D3DLIGHT9, Attenuation0), "LT_ATTENUATION0"},
        {FIELD_OFFSET(D3DLIGHT9, Attenuation1), "LT_ATTENUATION1"},
        {FIELD_OFFSET(D3DLIGHT9, Attenuation2), "LT_ATTENUATION2"},
        {FIELD_OFFSET(D3DLIGHT9, Theta),        "LT_THETA"},
        {FIELD_OFFSET(D3DLIGHT9, Phi),          "LT_PHI"}
    };
    switch (op)
    {
        case LT_TYPE:
            TRACE("LT_TYPE %u.\n", *(D3DLIGHTTYPE *)value);
            light->Type = *(D3DLIGHTTYPE *)value;
            break;
        case LT_DIFFUSE:
        case LT_SPECULAR:
        case LT_AMBIENT:
        {
            D3DCOLORVALUE c = *(D3DCOLORVALUE *)value;
 
            TRACE("%s (%.8e %.8e %.8e %.8e).\n", light_tbl[op].name, c.r, c.g, c.b, c.a);
            *(D3DCOLORVALUE *)((BYTE *)light + light_tbl[op].offset) = c;
            break;
        }
        case LT_POSITION:
        case LT_DIRECTION:
        {
            D3DVECTOR v = *(D3DVECTOR *)value;
 
            TRACE("%s (%.8e %.8e %.8e).\n", light_tbl[op].name, v.x, v.y, v.z);
            *(D3DVECTOR *)((BYTE *)light + light_tbl[op].offset) = v;
            break;
        }
        case LT_RANGE:
        case LT_FALLOFF:
        case LT_ATTENUATION0:
        case LT_ATTENUATION1:
        case LT_ATTENUATION2:
        case LT_THETA:
        case LT_PHI:
        {
            float v = *(float *)value;
            TRACE("%s %.8e.\n", light_tbl[op].name, v);
            *(float *)((BYTE *)light + light_tbl[op].offset) = v;
            break;
        }
        default:
            WARN("Unknown light parameter %u.\n", op);
            break;
    }
}

Referenced by d3dx9_apply_state().

d3dx9_set_material_parameter()

static void d3dx9_set_material_parameter ( enum MATERIAL_TYPE  op, D3DMATERIAL9 *  material, void *  value  )

static

Definition at line 1408 of file effect.c.

{
    static const struct
    {
        unsigned int offset;
        const char *name;
    }
    material_tbl[] =
    {
        {FIELD_OFFSET(D3DMATERIAL9, Diffuse),  "MT_DIFFUSE"},
        {FIELD_OFFSET(D3DMATERIAL9, Ambient),  "MT_AMBIENT"},
        {FIELD_OFFSET(D3DMATERIAL9, Specular), "MT_SPECULAR"},
        {FIELD_OFFSET(D3DMATERIAL9, Emissive), "MT_EMISSIVE"},
        {FIELD_OFFSET(D3DMATERIAL9, Power),    "MT_POWER"}
    };
 
    switch (op)
    {
        case MT_POWER:
        {
            float v = *(float *)value;
 
            TRACE("%s %.8e.\n", material_tbl[op].name, v);
            material->Power = v;
            break;
        }
        case MT_DIFFUSE:
        case MT_AMBIENT:
        case MT_SPECULAR:
        case MT_EMISSIVE:
        {
            D3DCOLORVALUE c = *(D3DCOLORVALUE *)value;
 
            TRACE("%s, value (%.8e %.8e %.8e %.8e).\n", material_tbl[op].name, c.r, c.g, c.b, c.a);
            *(D3DCOLORVALUE *)((BYTE *)material + material_tbl[op].offset) = c;
            break;
        }
        default:
            WARN("Unknown material parameter %u.\n", op);
            break;
    }
}

Referenced by d3dx9_apply_state().

d3dx_effect_AddRef()

static ULONG WINAPI d3dx_effect_AddRef ( ID3DXEffect *  iface )

static

Definition at line 1978 of file effect.c.

{
    struct d3dx_effect *This = impl_from_ID3DXEffect(iface);
 
    TRACE("(%p)->(): AddRef from %u\n", This, This->ref);
 
    return InterlockedIncrement(&This->ref);
}

d3dx_effect_ApplyParameterBlock()

static HRESULT WINAPI d3dx_effect_ApplyParameterBlock ( ID3DXEffect *  iface, D3DXHANDLE  parameter_block  )

static

Definition at line 4252 of file effect.c.

{
    struct d3dx_parameter_block *block = get_valid_parameter_block(parameter_block);
    struct d3dx_recorded_parameter *record;
 
    TRACE("iface %p, parameter_block %p.\n", iface, parameter_block);
 
    if (!block || !block->offset)
        return D3DERR_INVALIDCALL;
 
    record = (struct d3dx_recorded_parameter *)block->buffer;
    while ((BYTE *)record < block->buffer + block->offset)
    {
        set_value(record->param, record + 1, record->bytes,
                param_get_data_and_dirtify(block->effect, record->param, record->bytes, TRUE));
        record = (struct d3dx_recorded_parameter *)((BYTE *)record + get_recorded_parameter_size(record));
    }
    assert((BYTE *)record == block->buffer + block->offset);
    return D3D_OK;
}

d3dx_effect_Begin()

static HRESULT WINAPI d3dx_effect_Begin ( ID3DXEffect *  iface, UINT *  passes, DWORD  flags  )

static

Definition at line 3949 of file effect.c.

{
    struct d3dx_effect *effect = impl_from_ID3DXEffect(iface);
    struct d3dx_technique *technique = effect->active_technique;
 
    TRACE("iface %p, passes %p, flags %#x.\n", iface, passes, flags);
 
    if (technique)
    {
        if (flags & ~(D3DXFX_DONOTSAVESTATE | D3DXFX_DONOTSAVESAMPLERSTATE | D3DXFX_DONOTSAVESHADERSTATE))
            WARN("Invalid flags (%#x) specified.\n", flags);
 
        if (flags & D3DXFX_DONOTSAVESTATE)
        {
            TRACE("State capturing disabled.\n");
        }
        else
        {
            HRESULT hr;
            unsigned int i;
 
            if (!technique->saved_state)
            {
                ID3DXEffectStateManager *manager;
 
                manager = effect->manager;
                effect->manager = NULL;
                if (FAILED(hr = IDirect3DDevice9_BeginStateBlock(effect->device)))
                    ERR("BeginStateBlock failed, hr %#x.\n", hr);
                for (i = 0; i < technique->pass_count; i++)
                    d3dx9_apply_pass_states(effect, &technique->passes[i], TRUE);
                if (FAILED(hr = IDirect3DDevice9_EndStateBlock(effect->device, &technique->saved_state)))
                    ERR("EndStateBlock failed, hr %#x.\n", hr);
                effect->manager = manager;
            }
            if (FAILED(hr = IDirect3DStateBlock9_Capture(technique->saved_state)))
                ERR("StateBlock Capture failed, hr %#x.\n", hr);
        }
 
        if (passes)
            *passes = technique->pass_count;
        effect->started = TRUE;
        effect->begin_flags = flags;
 
        return D3D_OK;
    }
 
    WARN("Invalid argument supplied.\n");
 
    return D3DERR_INVALIDCALL;
}

d3dx_effect_BeginParameterBlock()

static HRESULT WINAPI d3dx_effect_BeginParameterBlock ( ID3DXEffect *  iface )

static

Definition at line 4210 of file effect.c.

{
    struct d3dx_effect *effect = impl_from_ID3DXEffect(iface);
 
    TRACE("iface %p.\n", iface);
 
    if (effect->current_parameter_block)
    {
        WARN("Parameter block is already started.\n");
        return D3DERR_INVALIDCALL;
    }
 
    effect->current_parameter_block = heap_alloc_zero(sizeof(*effect->current_parameter_block));
    memcpy(effect->current_parameter_block->magic_string, parameter_block_magic_string,
            sizeof(parameter_block_magic_string));
    effect->current_parameter_block->effect = effect;
 
    return D3D_OK;
}

d3dx_effect_BeginPass()

static HRESULT WINAPI d3dx_effect_BeginPass ( ID3DXEffect *  iface, UINT  pass  )

static

Definition at line 4001 of file effect.c.

{
    struct d3dx_effect *effect = impl_from_ID3DXEffect(iface);
    struct d3dx_technique *technique = effect->active_technique;
 
    TRACE("iface %p, pass %u\n", effect, pass);
 
    if (technique && pass < technique->pass_count && !effect->active_pass)
    {
        HRESULT hr;
 
        memset(effect->current_light, 0, sizeof(effect->current_light));
        memset(&effect->current_material, 0, sizeof(effect->current_material));
 
        if (SUCCEEDED(hr = d3dx9_apply_pass_states(effect, &technique->passes[pass], TRUE)))
            effect->active_pass = &technique->passes[pass];
        return hr;
    }
 
    WARN("Invalid argument supplied.\n");
 
    return D3DERR_INVALIDCALL;
}

d3dx_effect_cleanup()

static void d3dx_effect_cleanup ( struct d3dx_effect *  effect )

static

Definition at line 746 of file effect.c.

{
    struct d3dx_parameter_block *block, *cursor;
    ID3DXEffectPool *pool;
    unsigned int i;
 
    TRACE("effect %p.\n", effect);
 
    free_parameter_block(effect->current_parameter_block);
    LIST_FOR_EACH_ENTRY_SAFE(block, cursor, &effect->parameter_block_list, struct d3dx_parameter_block, entry)
    {
        list_remove(&block->entry);
        free_parameter_block(block);
    }
 
    heap_free(effect->full_name_tmp);
 
    if (effect->parameters)
    {
        for (i = 0; i < effect->parameter_count; ++i)
            free_top_level_parameter(&effect->parameters[i]);
        heap_free(effect->parameters);
    }
 
    if (effect->techniques)
    {
        for (i = 0; i < effect->technique_count; ++i)
            free_technique(&effect->techniques[i]);
        heap_free(effect->techniques);
    }
 
    if (effect->objects)
    {
        for (i = 0; i < effect->object_count; ++i)
            free_object(&effect->objects[i]);
        heap_free(effect->objects);
    }
 
    if (effect->pool)
    {
        pool = &effect->pool->ID3DXEffectPool_iface;
        pool->lpVtbl->Release(pool);
    }
 
    if (effect->manager)
        IUnknown_Release(effect->manager);
 
    IDirect3DDevice9_Release(effect->device);
    heap_free(effect);
}

Referenced by d3dx_effect_Release(), and D3DXCreateEffectEx().

d3dx_effect_CloneEffect()

static HRESULT WINAPI d3dx_effect_CloneEffect ( ID3DXEffect *  iface, IDirect3DDevice9 *  device, ID3DXEffect **  new_effect  )

static

Definition at line 4300 of file effect.c.

{
    struct d3dx_effect *effect = impl_from_ID3DXEffect(iface);
 
    FIXME("iface %p, device %p, new_effect %p stub.\n", effect, device, new_effect);
 
    if (!new_effect)
        return D3DERR_INVALIDCALL;
 
    if (effect->flags & D3DXFX_NOT_CLONEABLE)
        return E_FAIL;
 
    if (!device)
        return D3DERR_INVALIDCALL;
 
    iface->lpVtbl->AddRef(iface);
    *new_effect = iface;
    return S_OK;
}

d3dx_effect_CommitChanges()

static HRESULT WINAPI d3dx_effect_CommitChanges ( ID3DXEffect *  iface )

static

Definition at line 4025 of file effect.c.

{
    struct d3dx_effect *effect = impl_from_ID3DXEffect(iface);
 
    TRACE("iface %p.\n", iface);
 
    if (!effect->active_pass)
    {
        WARN("Called without an active pass.\n");
        return D3D_OK;
    }
    return d3dx9_apply_pass_states(effect, effect->active_pass, FALSE);
}

d3dx_effect_End()

static HRESULT WINAPI d3dx_effect_End ( ID3DXEffect *  iface )

static

Definition at line 4056 of file effect.c.

{
    struct d3dx_effect *effect = impl_from_ID3DXEffect(iface);
    struct d3dx_technique *technique = effect->active_technique;
 
    TRACE("iface %p.\n", iface);
 
    if (!effect->started)
        return D3D_OK;
 
    if (effect->begin_flags & D3DXFX_DONOTSAVESTATE)
    {
        TRACE("State restoring disabled.\n");
    }
    else
    {
        HRESULT hr;
 
        if (technique && technique->saved_state)
        {
            if (FAILED(hr = IDirect3DStateBlock9_Apply(technique->saved_state)))
                ERR("State block apply failed, hr %#x.\n", hr);
        }
        else
            ERR("No saved state.\n");
    }
 
    effect->started = FALSE;
 
    return D3D_OK;
}

d3dx_effect_EndParameterBlock()

static D3DXHANDLE WINAPI d3dx_effect_EndParameterBlock ( ID3DXEffect *  iface )

static

Definition at line 4230 of file effect.c.

{
    struct d3dx_effect *effect = impl_from_ID3DXEffect(iface);
    struct d3dx_parameter_block *ret;
 
    TRACE("iface %p.\n", iface);
 
    if (!effect->current_parameter_block)
    {
        WARN("No active parameter block.\n");
        return NULL;
    }
    ret = effect->current_parameter_block;
 
    ret->buffer = heap_realloc(ret->buffer, ret->offset);
    ret->size = ret->offset;
 
    effect->current_parameter_block = NULL;
    list_add_tail(&effect->parameter_block_list, &ret->entry);
    return (D3DXHANDLE)ret;
}

d3dx_effect_EndPass()

static HRESULT WINAPI d3dx_effect_EndPass ( ID3DXEffect *  iface )

static

Definition at line 4039 of file effect.c.

{
    struct d3dx_effect *This = impl_from_ID3DXEffect(iface);
 
    TRACE("iface %p\n", This);
 
    if (This->active_pass)
    {
         This->active_pass = NULL;
         return D3D_OK;
    }
 
    WARN("Invalid call.\n");
 
    return D3DERR_INVALIDCALL;
}

d3dx_effect_FindNextValidTechnique()

static HRESULT WINAPI d3dx_effect_FindNextValidTechnique ( ID3DXEffect *  iface, D3DXHANDLE  technique, D3DXHANDLE *  next_technique  )

static

Definition at line 3784 of file effect.c.

{
    struct d3dx_effect *effect = impl_from_ID3DXEffect(iface);
    struct d3dx_technique *prev_tech, *tech;
    unsigned int i;
 
    TRACE("iface %p, technique %p, next_technique %p.\n", iface, technique, next_technique);
 
    if (technique)
    {
        if (!(prev_tech = get_valid_technique(effect, technique)))
            return D3DERR_INVALIDCALL;
 
        for (i = 0; i < effect->technique_count; ++i)
        {
            tech = &effect->techniques[i];
            if (tech == prev_tech)
            {
                ++i;
                break;
            }
        }
    }
    else
    {
        i = 0;
    }
 
    for (; i < effect->technique_count; ++i)
    {
        tech = &effect->techniques[i];
        if (SUCCEEDED(d3dx_effect_ValidateTechnique(iface, get_technique_handle(tech))))
        {
            *next_technique = get_technique_handle(tech);
            return D3D_OK;
        }
    }
 
    *next_technique = get_technique_handle(&effect->techniques[0]);
    return S_FALSE;
}

d3dx_effect_GetAnnotation()

static D3DXHANDLE WINAPI d3dx_effect_GetAnnotation ( ID3DXEffect *  iface, D3DXHANDLE  object, UINT  index  )

static

Definition at line 2370 of file effect.c.

{
    struct d3dx_effect *effect = impl_from_ID3DXEffect(iface);
    struct d3dx_parameter *annotations = NULL;
    unsigned int annotation_count;
 
    TRACE("iface %p, object %p, index %u.\n", iface, object, index);
 
    annotation_count = get_annotation_from_object(effect, object, &annotations);
 
    if (index < annotation_count)
    {
        TRACE("Returning parameter %p\n", &annotations[index]);
        return get_parameter_handle(&annotations[index]);
    }
 
    WARN("Annotation not found.\n");
 
    return NULL;
}

d3dx_effect_GetAnnotationByName()

static D3DXHANDLE WINAPI d3dx_effect_GetAnnotationByName ( ID3DXEffect *  iface, D3DXHANDLE  object, const char *  name  )

static

Definition at line 2391 of file effect.c.

{
    struct d3dx_effect *effect = impl_from_ID3DXEffect(iface);
    struct d3dx_parameter *annotation = NULL;
    struct d3dx_parameter *annotations = NULL;
    unsigned int annotation_count;
 
    TRACE("iface %p, object %p, name %s.\n", iface, object, debugstr_a(name));
 
    if (!name)
    {
        WARN("Invalid argument specified\n");
        return NULL;
    }
 
    annotation_count = get_annotation_from_object(effect, object, &annotations);
 
    annotation = get_annotation_by_name(effect, annotation_count, annotations, name);
    if (annotation)
    {
        TRACE("Returning parameter %p\n", annotation);
        return get_parameter_handle(annotation);
    }
 
    WARN("Annotation not found.\n");
 
    return NULL;
}

d3dx_effect_GetBool()

static HRESULT WINAPI d3dx_effect_GetBool ( ID3DXEffect *  iface, D3DXHANDLE  parameter, BOOL *  b  )

static

Definition at line 2532 of file effect.c.

{
    struct d3dx_effect *effect = impl_from_ID3DXEffect(iface);
    struct d3dx_parameter *param = get_valid_parameter(effect, parameter);
 
    TRACE("iface %p, parameter %p, b %p.\n", iface, parameter, b);
 
    if (b && param && !param->element_count && param->rows == 1 && param->columns == 1)
    {
        set_number(b, D3DXPT_BOOL, param->data, param->type);
        TRACE("Returning %s\n", *b ? "TRUE" : "FALSE");
        return D3D_OK;
    }
 
    WARN("Parameter not found.\n");
 
    return D3DERR_INVALIDCALL;
}

d3dx_effect_GetBoolArray()

static HRESULT WINAPI d3dx_effect_GetBoolArray ( ID3DXEffect *  iface, D3DXHANDLE  parameter, BOOL *  b, UINT  count  )

static

Definition at line 2593 of file effect.c.

{
    struct d3dx_effect *effect = impl_from_ID3DXEffect(iface);
    struct d3dx_parameter *param = get_valid_parameter(effect, parameter);
 
    TRACE("iface %p, parameter %p, b %p, count %u.\n", iface, parameter, b, count);
 
    if (b && param && (param->class == D3DXPC_SCALAR
            || param->class == D3DXPC_VECTOR
            || param->class == D3DXPC_MATRIX_ROWS
            || param->class == D3DXPC_MATRIX_COLUMNS))
    {
        unsigned int i, size = min(count, param->bytes / sizeof(DWORD));
 
        for (i = 0; i < size; ++i)
        {
            set_number(&b[i], D3DXPT_BOOL, (DWORD *)param->data + i, param->type);
        }
        return D3D_OK;
    }
 
    WARN("Parameter not found.\n");
 
    return D3DERR_INVALIDCALL;
}

d3dx_effect_GetCurrentTechnique()

static D3DXHANDLE WINAPI d3dx_effect_GetCurrentTechnique ( ID3DXEffect *  iface )

static

Definition at line 3728 of file effect.c.

{
    struct d3dx_effect *This = impl_from_ID3DXEffect(iface);
 
    TRACE("iface %p\n", This);
 
    return get_technique_handle(This->active_technique);
}

d3dx_effect_GetDesc()

static HRESULT WINAPI d3dx_effect_GetDesc ( ID3DXEffect *  iface, D3DXEFFECT_DESC *  desc  )

static

Definition at line 2001 of file effect.c.

{
    struct d3dx_effect *effect = impl_from_ID3DXEffect(iface);
 
    FIXME("iface %p, desc %p partial stub.\n", iface, desc);
 
    if (!desc)
    {
        WARN("Invalid argument specified.\n");
        return D3DERR_INVALIDCALL;
    }
 
    /* TODO: add creator and function count. */
    desc->Creator = NULL;
    desc->Functions = 0;
    desc->Parameters = effect->parameter_count;
    desc->Techniques = effect->technique_count;
 
    return D3D_OK;
}

d3dx_effect_GetDevice()

static HRESULT WINAPI d3dx_effect_GetDevice ( ID3DXEffect *  iface, struct IDirect3DDevice9 **  device  )

static

Definition at line 4088 of file effect.c.

{
    struct d3dx_effect *This = impl_from_ID3DXEffect(iface);
 
    TRACE("iface %p, device %p\n", This, device);
 
    if (!device)
    {
        WARN("Invalid argument supplied.\n");
        return D3DERR_INVALIDCALL;
    }
 
    IDirect3DDevice9_AddRef(This->device);
 
    *device = This->device;
 
    TRACE("Returning device %p\n", *device);
 
    return S_OK;
}

d3dx_effect_GetFloat()

static HRESULT WINAPI d3dx_effect_GetFloat ( ID3DXEffect *  iface, D3DXHANDLE  parameter, float *  f  )

static

Definition at line 2788 of file effect.c.

{
    struct d3dx_effect *effect = impl_from_ID3DXEffect(iface);
    struct d3dx_parameter *param = get_valid_parameter(effect, parameter);
 
    TRACE("iface %p, parameter %p, f %p.\n", iface, parameter, f);
 
    if (f && param && !param->element_count && param->columns == 1 && param->rows == 1)
    {
        set_number(f, D3DXPT_FLOAT, (DWORD *)param->data, param->type);
        TRACE("Returning %f.\n", *f);
        return D3D_OK;
    }
 
    WARN("Parameter not found.\n");
 
    return D3DERR_INVALIDCALL;
}

d3dx_effect_GetFloatArray()

static HRESULT WINAPI d3dx_effect_GetFloatArray ( ID3DXEffect *  iface, D3DXHANDLE  parameter, float *  f, UINT  count  )

static

Definition at line 2847 of file effect.c.

{
    struct d3dx_effect *effect = impl_from_ID3DXEffect(iface);
    struct d3dx_parameter *param = get_valid_parameter(effect, parameter);
 
    TRACE("iface %p, parameter %p, f %p, count %u.\n", iface, parameter, f, count);
 
    if (f && param && (param->class == D3DXPC_SCALAR
            || param->class == D3DXPC_VECTOR
            || param->class == D3DXPC_MATRIX_ROWS
            || param->class == D3DXPC_MATRIX_COLUMNS))
    {
        unsigned int i, size = min(count, param->bytes / sizeof(DWORD));
 
        for (i = 0; i < size; ++i)
            set_number(&f[i], D3DXPT_FLOAT, (DWORD *)param->data + i, param->type);
        return D3D_OK;
    }
 
    WARN("Parameter not found.\n");
 
    return D3DERR_INVALIDCALL;
}

d3dx_effect_GetFunction()

static D3DXHANDLE WINAPI d3dx_effect_GetFunction ( ID3DXEffect *  iface, UINT  index  )

static

Definition at line 2356 of file effect.c.

{
    FIXME("iface %p, index %u stub.\n", iface, index);
 
    return NULL;
}

d3dx_effect_GetFunctionByName()

static D3DXHANDLE WINAPI d3dx_effect_GetFunctionByName ( ID3DXEffect *  iface, const char *  name  )

static

Definition at line 2363 of file effect.c.

{
    FIXME("iface %p, name %s stub.\n", iface, debugstr_a(name));
 
    return NULL;
}

d3dx_effect_GetFunctionDesc()

static HRESULT WINAPI d3dx_effect_GetFunctionDesc ( ID3DXEffect *  iface, D3DXHANDLE  shader, D3DXFUNCTION_DESC *  desc  )

static

Definition at line 2124 of file effect.c.

{
    FIXME("iface %p, shader %p, desc %p stub.\n", iface, shader, desc);
 
    return E_NOTIMPL;
}

d3dx_effect_GetInt()

static HRESULT WINAPI d3dx_effect_GetInt ( ID3DXEffect *  iface, D3DXHANDLE  parameter, INT *  n  )

static

Definition at line 2665 of file effect.c.

{
    struct d3dx_effect *effect = impl_from_ID3DXEffect(iface);
    struct d3dx_parameter *param = get_valid_parameter(effect, parameter);
 
    TRACE("iface %p, parameter %p, n %p.\n", iface, parameter, n);
 
    if (n && param && !param->element_count)
    {
        if (param->columns == 1 && param->rows == 1)
        {
            set_number(n, D3DXPT_INT, param->data, param->type);
            TRACE("Returning %d.\n", *n);
            return D3D_OK;
        }
 
        if (param->type == D3DXPT_FLOAT &&
                ((param->class == D3DXPC_VECTOR && param->columns != 2)
                || (param->class == D3DXPC_MATRIX_ROWS && param->rows != 2 && param->columns == 1)))
        {
            TRACE("Vector fixup.\n");
 
            *n = min(max(0.0f, *((float *)param->data + 2)), 1.0f) * INT_FLOAT_MULTI;
            *n += ((int)(min(max(0.0f, *((float *)param->data + 1)), 1.0f) * INT_FLOAT_MULTI)) << 8;
            *n += ((int)(min(max(0.0f, *((float *)param->data + 0)), 1.0f) * INT_FLOAT_MULTI)) << 16;
            if (param->columns * param->rows > 3)
                *n += ((int)(min(max(0.0f, *((float *)param->data + 3)), 1.0f) * INT_FLOAT_MULTI)) << 24;
 
            TRACE("Returning %d.\n", *n);
            return D3D_OK;
        }
    }
 
    WARN("Parameter not found.\n");
 
    return D3DERR_INVALIDCALL;
}

d3dx_effect_GetIntArray()

static HRESULT WINAPI d3dx_effect_GetIntArray ( ID3DXEffect *  iface, D3DXHANDLE  parameter, INT *  n, UINT  count  )

static

Definition at line 2742 of file effect.c.

{
    struct d3dx_effect *effect = impl_from_ID3DXEffect(iface);
    struct d3dx_parameter *param = get_valid_parameter(effect, parameter);
 
    TRACE("iface %p, parameter %p, n %p, count %u.\n", iface, parameter, n, count);
 
    if (n && param && (param->class == D3DXPC_SCALAR
            || param->class == D3DXPC_VECTOR
            || param->class == D3DXPC_MATRIX_ROWS
            || param->class == D3DXPC_MATRIX_COLUMNS))
    {
        unsigned int i, size = min(count, param->bytes / sizeof(DWORD));
 
        for (i = 0; i < size; ++i)
            set_number(&n[i], D3DXPT_INT, (DWORD *)param->data + i, param->type);
        return D3D_OK;
    }
 
    WARN("Parameter not found.\n");
 
    return D3DERR_INVALIDCALL;
}

d3dx_effect_GetMatrix()

static HRESULT WINAPI d3dx_effect_GetMatrix ( ID3DXEffect *  iface, D3DXHANDLE  parameter, D3DXMATRIX *  matrix  )

static

Definition at line 3101 of file effect.c.

{
    struct d3dx_effect *effect = impl_from_ID3DXEffect(iface);
    struct d3dx_parameter *param = get_valid_parameter(effect, parameter);
 
    TRACE("iface %p, parameter %p, matrix %p.\n", iface, parameter, matrix);
 
    if (matrix && param && !param->element_count)
    {
        TRACE("Class %s.\n", debug_d3dxparameter_class(param->class));
 
        switch (param->class)
        {
            case D3DXPC_MATRIX_ROWS:
                get_matrix(param, matrix, FALSE);
                return D3D_OK;
 
            case D3DXPC_SCALAR:
            case D3DXPC_VECTOR:
            case D3DXPC_OBJECT:
            case D3DXPC_STRUCT:
                break;
 
            default:
                FIXME("Unhandled class %s.\n", debug_d3dxparameter_class(param->class));
                break;
        }
    }
 
    WARN("Parameter not found.\n");
 
    return D3DERR_INVALIDCALL;
}

d3dx_effect_GetMatrixArray()

static HRESULT WINAPI d3dx_effect_GetMatrixArray ( ID3DXEffect *  iface, D3DXHANDLE  parameter, D3DXMATRIX *  matrix, UINT  count  )

static

Definition at line 3179 of file effect.c.

{
    struct d3dx_effect *effect = impl_from_ID3DXEffect(iface);
    struct d3dx_parameter *param = get_valid_parameter(effect, parameter);
 
    TRACE("iface %p, parameter %p, matrix %p, count %u.\n", iface, parameter, matrix, count);
 
    if (!count)
        return D3D_OK;
 
    if (matrix && param && count <= param->element_count)
    {
        unsigned int i;
 
        TRACE("Class %s.\n", debug_d3dxparameter_class(param->class));
 
        switch (param->class)
        {
            case D3DXPC_MATRIX_ROWS:
                for (i = 0; i < count; ++i)
                    get_matrix(&param->members[i], &matrix[i], FALSE);
                return D3D_OK;
 
            case D3DXPC_SCALAR:
            case D3DXPC_VECTOR:
            case D3DXPC_OBJECT:
            case D3DXPC_STRUCT:
                break;
 
            default:
                FIXME("Unhandled class %s.\n", debug_d3dxparameter_class(param->class));
                break;
        }
    }
 
    WARN("Parameter not found.\n");
 
    return D3DERR_INVALIDCALL;
}

d3dx_effect_GetMatrixPointerArray()

static HRESULT WINAPI d3dx_effect_GetMatrixPointerArray ( ID3DXEffect *  iface, D3DXHANDLE  parameter, D3DXMATRIX **  matrix, UINT  count  )

static

Definition at line 3261 of file effect.c.

{
    struct d3dx_effect *effect = impl_from_ID3DXEffect(iface);
    struct d3dx_parameter *param = get_valid_parameter(effect, parameter);
 
    TRACE("iface %p, parameter %p, matrix %p, count %u.\n", iface, parameter, matrix, count);
 
    if (!count)
        return D3D_OK;
 
    if (param && matrix && count <= param->element_count)
    {
        unsigned int i;
 
        TRACE("Class %s.\n", debug_d3dxparameter_class(param->class));
 
        switch (param->class)
        {
            case D3DXPC_MATRIX_ROWS:
                for (i = 0; i < count; ++i)
                    get_matrix(&param->members[i], matrix[i], FALSE);
                return D3D_OK;
 
            case D3DXPC_SCALAR:
            case D3DXPC_VECTOR:
            case D3DXPC_OBJECT:
                break;
 
            default:
                FIXME("Unhandled class %s.\n", debug_d3dxparameter_class(param->class));
                break;
        }
    }
 
    WARN("Parameter not found.\n");
 
    return D3DERR_INVALIDCALL;
}

d3dx_effect_GetMatrixTranspose()

static HRESULT WINAPI d3dx_effect_GetMatrixTranspose ( ID3DXEffect *  iface, D3DXHANDLE  parameter, D3DXMATRIX *  matrix  )

static

Definition at line 3337 of file effect.c.

{
    struct d3dx_effect *effect = impl_from_ID3DXEffect(iface);
    struct d3dx_parameter *param = get_valid_parameter(effect, parameter);
 
    TRACE("iface %p, parameter %p, matrix %p.\n", iface, parameter, matrix);
 
    if (matrix && param && !param->element_count)
    {
        TRACE("Class %s.\n", debug_d3dxparameter_class(param->class));
 
        switch (param->class)
        {
            case D3DXPC_SCALAR:
            case D3DXPC_VECTOR:
                get_matrix(param, matrix, FALSE);
                return D3D_OK;
 
            case D3DXPC_MATRIX_ROWS:
                get_matrix(param, matrix, TRUE);
                return D3D_OK;
 
            case D3DXPC_OBJECT:
            case D3DXPC_STRUCT:
                break;
 
            default:
                FIXME("Unhandled class %s.\n", debug_d3dxparameter_class(param->class));
                break;
        }
    }
 
    WARN("Parameter not found.\n");
 
    return D3DERR_INVALIDCALL;
}

d3dx_effect_GetMatrixTransposeArray()

static HRESULT WINAPI d3dx_effect_GetMatrixTransposeArray ( ID3DXEffect *  iface, D3DXHANDLE  parameter, D3DXMATRIX *  matrix, UINT  count  )

static

Definition at line 3419 of file effect.c.

{
    struct d3dx_effect *effect = impl_from_ID3DXEffect(iface);
    struct d3dx_parameter *param = get_valid_parameter(effect, parameter);
 
    TRACE("iface %p, parameter %p, matrix %p, count %u.\n", iface, parameter, matrix, count);
 
    if (!count)
        return D3D_OK;
 
    if (matrix && param && count <= param->element_count)
    {
        unsigned int i;
 
        TRACE("Class %s.\n", debug_d3dxparameter_class(param->class));
 
        switch (param->class)
        {
            case D3DXPC_MATRIX_ROWS:
                for (i = 0; i < count; ++i)
                    get_matrix(&param->members[i], &matrix[i], TRUE);
                return D3D_OK;
 
            case D3DXPC_SCALAR:
            case D3DXPC_VECTOR:
            case D3DXPC_OBJECT:
            case D3DXPC_STRUCT:
                break;
 
            default:
                FIXME("Unhandled class %s.\n", debug_d3dxparameter_class(param->class));
                break;
        }
    }
 
    WARN("Parameter not found.\n");
 
    return D3DERR_INVALIDCALL;
}

d3dx_effect_GetMatrixTransposePointerArray()

static HRESULT WINAPI d3dx_effect_GetMatrixTransposePointerArray ( ID3DXEffect *  iface, D3DXHANDLE  parameter, D3DXMATRIX **  matrix, UINT  count  )

static

Definition at line 3501 of file effect.c.

{
    struct d3dx_effect *effect = impl_from_ID3DXEffect(iface);
    struct d3dx_parameter *param = get_valid_parameter(effect, parameter);
 
    TRACE("iface %p, parameter %p, matrix %p, count %u.\n", iface, parameter, matrix, count);
 
    if (!count)
        return D3D_OK;
 
    if (matrix && param && count <= param->element_count)
    {
        unsigned int i;
 
        TRACE("Class %s.\n", debug_d3dxparameter_class(param->class));
 
        switch (param->class)
        {
            case D3DXPC_MATRIX_ROWS:
                for (i = 0; i < count; ++i)
                    get_matrix(&param->members[i], matrix[i], TRUE);
                return D3D_OK;
 
            case D3DXPC_SCALAR:
            case D3DXPC_VECTOR:
            case D3DXPC_OBJECT:
                break;
 
            default:
                FIXME("Unhandled class %s.\n", debug_d3dxparameter_class(param->class));
                break;
        }
    }
 
    WARN("Parameter not found.\n");
 
    return D3DERR_INVALIDCALL;
}

d3dx_effect_GetParameter()

static D3DXHANDLE WINAPI d3dx_effect_GetParameter ( ID3DXEffect *  iface, D3DXHANDLE  parameter, UINT  index  )

static

Definition at line 2132 of file effect.c.

{
    struct d3dx_effect *effect = impl_from_ID3DXEffect(iface);
    struct d3dx_parameter *param = get_valid_parameter(effect, parameter);
 
    TRACE("iface %p, parameter %p, index %u.\n", iface, parameter, index);
 
    if (!parameter)
    {
        if (index < effect->parameter_count)
        {
            TRACE("Returning parameter %p.\n", &effect->parameters[index]);
            return get_parameter_handle(&effect->parameters[index].param);
        }
    }
    else
    {
        if (param && !param->element_count && index < param->member_count)
        {
            TRACE("Returning parameter %p.\n", &param->members[index]);
            return get_parameter_handle(&param->members[index]);
        }
    }
 
    WARN("Parameter not found.\n");
 
    return NULL;
}

d3dx_effect_GetParameterByName()

static D3DXHANDLE WINAPI d3dx_effect_GetParameterByName ( ID3DXEffect *  iface, D3DXHANDLE  parameter, const char *  name  )

static

Definition at line 2161 of file effect.c.

{
    struct d3dx_effect *effect = impl_from_ID3DXEffect(iface);
    struct d3dx_parameter *param = get_valid_parameter(effect, parameter);
    D3DXHANDLE handle;
 
    TRACE("iface %p, parameter %p, name %s.\n", iface, parameter, debugstr_a(name));
 
    if (!name)
    {
        handle = get_parameter_handle(param);
        TRACE("Returning parameter %p.\n", handle);
        return handle;
    }
 
    handle = get_parameter_handle(get_parameter_by_name(effect, param, name));
    TRACE("Returning parameter %p.\n", handle);
 
    return handle;
}

d3dx_effect_GetParameterBySemantic()

static D3DXHANDLE WINAPI d3dx_effect_GetParameterBySemantic ( ID3DXEffect *  iface, D3DXHANDLE  parameter, const char *  semantic  )

static

Definition at line 2183 of file effect.c.

{
    struct d3dx_effect *effect = impl_from_ID3DXEffect(iface);
    struct d3dx_parameter *param = get_valid_parameter(effect, parameter);
    struct d3dx_parameter *temp_param;
    unsigned int i;
 
    TRACE("iface %p, parameter %p, semantic %s.\n", iface, parameter, debugstr_a(semantic));
 
    if (!parameter)
    {
        for (i = 0; i < effect->parameter_count; ++i)
        {
            temp_param = &effect->parameters[i].param;
 
            if (!temp_param->semantic)
            {
                if (!semantic)
                {
                    TRACE("Returning parameter %p\n", temp_param);
                    return get_parameter_handle(temp_param);
                }
                continue;
            }
 
            if (!stricmp(temp_param->semantic, semantic))
            {
                TRACE("Returning parameter %p\n", temp_param);
                return get_parameter_handle(temp_param);
            }
        }
    }
    else if (param)
    {
        for (i = 0; i < param->member_count; ++i)
        {
            temp_param = &param->members[i];
 
            if (!temp_param->semantic)
            {
                if (!semantic)
                {
                    TRACE("Returning parameter %p\n", temp_param);
                    return get_parameter_handle(temp_param);
                }
                continue;
            }
 
            if (!stricmp(temp_param->semantic, semantic))
            {
                TRACE("Returning parameter %p\n", temp_param);
                return get_parameter_handle(temp_param);
            }
        }
    }
 
    WARN("Parameter not found.\n");
 
    return NULL;
}

d3dx_effect_GetParameterDesc()

static HRESULT WINAPI d3dx_effect_GetParameterDesc ( ID3DXEffect *  iface, D3DXHANDLE  parameter, D3DXPARAMETER_DESC *  desc  )

static

Definition at line 2022 of file effect.c.

{
    struct d3dx_effect *effect = impl_from_ID3DXEffect(iface);
    struct d3dx_parameter *param = get_valid_parameter(effect, parameter);
 
    TRACE("iface %p, parameter %p, desc %p.\n", iface, parameter, desc);
 
    if (!desc || !param)
    {
        WARN("Invalid argument specified.\n");
        return D3DERR_INVALIDCALL;
    }
 
    desc->Name = param->name;
    desc->Semantic = param->semantic;
    desc->Class = param->class;
    desc->Type = param->type;
    desc->Rows = param->rows;
    desc->Columns = param->columns;
    desc->Elements = param->element_count;
    desc->Annotations = is_top_level_parameter(param)
            ? top_level_parameter_from_parameter(param)->annotation_count : 0;
    desc->StructMembers = param->member_count;
    desc->Flags = param->flags;
    desc->Bytes = param->bytes;
 
    return D3D_OK;
}

d3dx_effect_GetParameterElement()

static D3DXHANDLE WINAPI d3dx_effect_GetParameterElement ( ID3DXEffect *  iface, D3DXHANDLE  parameter, UINT  index  )

static

Definition at line 2245 of file effect.c.

{
    struct d3dx_effect *effect = impl_from_ID3DXEffect(iface);
    struct d3dx_parameter *param = get_valid_parameter(effect, parameter);
 
    TRACE("iface %p, parameter %p, index %u.\n", iface, parameter, index);
 
    if (!param)
    {
        if (index < effect->parameter_count)
        {
            TRACE("Returning parameter %p.\n", &effect->parameters[index]);
            return get_parameter_handle(&effect->parameters[index].param);
        }
    }
    else
    {
        if (index < param->element_count)
        {
            TRACE("Returning parameter %p.\n", &param->members[index]);
            return get_parameter_handle(&param->members[index]);
        }
    }
 
    WARN("Parameter not found.\n");
 
    return NULL;
}

d3dx_effect_GetPass()

static D3DXHANDLE WINAPI d3dx_effect_GetPass ( ID3DXEffect *  iface, D3DXHANDLE  technique, UINT  index  )

static

Definition at line 2310 of file effect.c.

{
    struct d3dx_effect *effect = impl_from_ID3DXEffect(iface);
    struct d3dx_technique *tech = get_valid_technique(effect, technique);
 
    TRACE("iface %p, technique %p, index %u.\n", iface, technique, index);
 
    if (tech && index < tech->pass_count)
    {
        TRACE("Returning pass %p\n", &tech->passes[index]);
        return get_pass_handle(&tech->passes[index]);
    }
 
    WARN("Pass not found.\n");
 
    return NULL;
}

d3dx_effect_GetPassByName()

static D3DXHANDLE WINAPI d3dx_effect_GetPassByName ( ID3DXEffect *  iface, D3DXHANDLE  technique, const char *  name  )

static

Definition at line 2328 of file effect.c.

{
    struct d3dx_effect *effect = impl_from_ID3DXEffect(iface);
    struct d3dx_technique *tech = get_valid_technique(effect, technique);
 
    TRACE("iface %p, technique %p, name %s.\n", iface, technique, debugstr_a(name));
 
    if (tech && name)
    {
        unsigned int i;
 
        for (i = 0; i < tech->pass_count; ++i)
        {
            struct d3dx_pass *pass = &tech->passes[i];
 
            if (!strcmp(pass->name, name))
            {
                TRACE("Returning pass %p\n", pass);
                return get_pass_handle(pass);
            }
        }
    }
 
    WARN("Pass not found.\n");
 
    return NULL;
}

d3dx_effect_GetPassDesc()

static HRESULT WINAPI d3dx_effect_GetPassDesc ( ID3DXEffect *  iface, D3DXHANDLE  pass_handle, D3DXPASS_DESC *  desc  )

static

Definition at line 2073 of file effect.c.

{
    struct d3dx_effect *effect = impl_from_ID3DXEffect(iface);
    struct d3dx_pass *pass = get_valid_pass(effect, pass_handle);
    unsigned int i;
 
    TRACE("iface %p, pass %p, desc %p.\n", iface, pass, desc);
 
    if (!desc || !pass)
    {
        WARN("Invalid argument specified.\n");
        return D3DERR_INVALIDCALL;
    }
 
    desc->Name = pass->name;
    desc->Annotations = pass->annotation_count;
 
    desc->pVertexShaderFunction = NULL;
    desc->pPixelShaderFunction = NULL;
 
    if (effect->flags & D3DXFX_NOT_CLONEABLE)
        return D3D_OK;
 
    for (i = 0; i < pass->state_count; ++i)
    {
        struct d3dx_state *state = &pass->states[i];
 
        if (state_table[state->operation].class == SC_VERTEXSHADER
                || state_table[state->operation].class == SC_PIXELSHADER)
        {
            struct d3dx_parameter *param;
            void *param_value;
            BOOL param_dirty;
            HRESULT hr;
            void *data;
 
            if (FAILED(hr = d3dx9_get_param_value_ptr(pass, &pass->states[i], &param_value, &param,
                    FALSE, &param_dirty)))
                return hr;
 
            data = param->object_id ? effect->objects[param->object_id].data : NULL;
            if (state_table[state->operation].class == SC_VERTEXSHADER)
                desc->pVertexShaderFunction = data;
            else
                desc->pPixelShaderFunction = data;
        }
    }
 
    return D3D_OK;
}

d3dx_effect_GetPixelShader()

static HRESULT WINAPI d3dx_effect_GetPixelShader ( ID3DXEffect *  iface, D3DXHANDLE  parameter, IDirect3DPixelShader9 **  shader  )

static

Definition at line 3635 of file effect.c.

{
    struct d3dx_effect *effect = impl_from_ID3DXEffect(iface);
    struct d3dx_parameter *param = get_valid_parameter(effect, parameter);
 
    TRACE("iface %p, parameter %p, shader %p.\n", iface, parameter, shader);
 
    if (shader && param && !param->element_count && param->type == D3DXPT_PIXELSHADER)
    {
        if ((*shader = *(IDirect3DPixelShader9 **)param->data))
            IDirect3DPixelShader9_AddRef(*shader);
        TRACE("Returning %p.\n", *shader);
        return D3D_OK;
    }
 
    WARN("Parameter not found.\n");
 
    return D3DERR_INVALIDCALL;
}

d3dx_effect_GetPool()

static HRESULT WINAPI d3dx_effect_GetPool ( ID3DXEffect *  iface, ID3DXEffectPool **  pool  )

static

Definition at line 3685 of file effect.c.

{
    struct d3dx_effect *effect = impl_from_ID3DXEffect(iface);
 
    TRACE("iface %p, pool %p.\n", effect, pool);
 
    if (!pool)
    {
        WARN("Invalid argument supplied.\n");
        return D3DERR_INVALIDCALL;
    }
 
    *pool = NULL;
    if (effect->pool)
    {
        *pool = &effect->pool->ID3DXEffectPool_iface;
        (*pool)->lpVtbl->AddRef(*pool);
    }
 
    TRACE("Returning pool %p.\n", *pool);
 
    return S_OK;
}

d3dx_effect_GetStateManager()

static HRESULT WINAPI d3dx_effect_GetStateManager ( ID3DXEffect *  iface, ID3DXEffectStateManager **  manager  )

static

Definition at line 4192 of file effect.c.

{
    struct d3dx_effect *This = impl_from_ID3DXEffect(iface);
 
    TRACE("iface %p, manager %p\n", This, manager);
 
    if (!manager)
    {
        WARN("Invalid argument supplied.\n");
        return D3DERR_INVALIDCALL;
    }
 
    if (This->manager) IUnknown_AddRef(This->manager);
    *manager = This->manager;
 
    return D3D_OK;
}

d3dx_effect_GetString()

static HRESULT WINAPI d3dx_effect_GetString ( ID3DXEffect *  iface, D3DXHANDLE  parameter, const char **  string  )

static

Definition at line 3556 of file effect.c.

{
    struct d3dx_effect *effect = impl_from_ID3DXEffect(iface);
    struct d3dx_parameter *param = get_valid_parameter(effect, parameter);
 
    TRACE("iface %p, parameter %p, string %p.\n", iface, parameter, string);
 
    if (string && param && !param->element_count && param->type == D3DXPT_STRING)
    {
        *string = *(const char **)param->data;
        TRACE("Returning %s.\n", debugstr_a(*string));
        return D3D_OK;
    }
 
    WARN("Parameter not found.\n");
 
    return D3DERR_INVALIDCALL;
}

d3dx_effect_GetTechnique()

static D3DXHANDLE WINAPI d3dx_effect_GetTechnique ( ID3DXEffect *  iface, UINT  index  )

static

Definition at line 2274 of file effect.c.

{
    struct d3dx_effect *effect = impl_from_ID3DXEffect(iface);
 
    TRACE("iface %p, index %u.\n", iface, index);
 
    if (index >= effect->technique_count)
    {
        WARN("Invalid argument specified.\n");
        return NULL;
    }
 
    TRACE("Returning technique %p.\n", &effect->techniques[index]);
 
    return get_technique_handle(&effect->techniques[index]);
}

d3dx_effect_GetTechniqueByName()

static D3DXHANDLE WINAPI d3dx_effect_GetTechniqueByName ( ID3DXEffect *  iface, const char *  name  )

static

Definition at line 2291 of file effect.c.

{
    struct d3dx_effect *effect = impl_from_ID3DXEffect(iface);
    struct d3dx_technique *tech = get_technique_by_name(effect, name);
 
    TRACE("iface %p, name %s.\n", iface, debugstr_a(name));
 
    if (tech)
    {
        D3DXHANDLE t = get_technique_handle(tech);
        TRACE("Returning technique %p\n", t);
        return t;
    }
 
    WARN("Technique not found.\n");
 
    return NULL;
}

d3dx_effect_GetTechniqueDesc()

static HRESULT WINAPI d3dx_effect_GetTechniqueDesc ( ID3DXEffect *  iface, D3DXHANDLE  technique, D3DXTECHNIQUE_DESC *  desc  )

static

Definition at line 2052 of file effect.c.

{
    struct d3dx_effect *effect = impl_from_ID3DXEffect(iface);
    struct d3dx_technique *tech = technique ? get_valid_technique(effect, technique) : &effect->techniques[0];
 
    TRACE("iface %p, technique %p, desc %p.\n", iface, technique, desc);
 
    if (!desc || !tech)
    {
        WARN("Invalid argument specified.\n");
        return D3DERR_INVALIDCALL;
    }
 
    desc->Name = tech->name;
    desc->Passes = tech->pass_count;
    desc->Annotations = tech->annotation_count;
 
    return D3D_OK;
}

d3dx_effect_GetTexture()

static HRESULT WINAPI d3dx_effect_GetTexture ( ID3DXEffect *  iface, D3DXHANDLE  parameter, IDirect3DBaseTexture9 **  texture  )

static

Definition at line 3610 of file effect.c.

{
    struct d3dx_effect *effect = impl_from_ID3DXEffect(iface);
    struct d3dx_parameter *param = get_valid_parameter(effect, parameter);
 
    TRACE("iface %p, parameter %p, texture %p.\n", iface, parameter, texture);
 
    if (texture && param && !param->element_count
            && (param->type == D3DXPT_TEXTURE || param->type == D3DXPT_TEXTURE1D
            || param->type == D3DXPT_TEXTURE2D || param->type ==  D3DXPT_TEXTURE3D
            || param->type == D3DXPT_TEXTURECUBE))
    {
        *texture = *(IDirect3DBaseTexture9 **)param->data;
        if (*texture)
            IDirect3DBaseTexture9_AddRef(*texture);
        TRACE("Returning %p.\n", *texture);
        return D3D_OK;
    }
 
    WARN("Parameter not found.\n");
 
    return D3DERR_INVALIDCALL;
}

d3dx_effect_GetValue()

static HRESULT WINAPI d3dx_effect_GetValue ( ID3DXEffect *  iface, D3DXHANDLE  parameter, void *  data, UINT  bytes  )

static

Definition at line 2448 of file effect.c.

{
    struct d3dx_effect *effect = impl_from_ID3DXEffect(iface);
    struct d3dx_parameter *param = get_valid_parameter(effect, parameter);
 
    TRACE("iface %p, parameter %p, data %p, bytes %u.\n", iface, parameter, data, bytes);
 
    if (!param)
    {
        WARN("Invalid parameter %p specified.\n", parameter);
        return D3DERR_INVALIDCALL;
    }
    if (param->class == D3DXPC_OBJECT && is_param_type_sampler(param->type))
    {
        WARN("Parameter is a sampler, returning E_FAIL.\n");
        return E_FAIL;
    }
 
    if (data && param->bytes <= bytes)
    {
        TRACE("Type %s.\n", debug_d3dxparameter_type(param->type));
 
        switch (param->type)
        {
            case D3DXPT_VOID:
            case D3DXPT_BOOL:
            case D3DXPT_INT:
            case D3DXPT_FLOAT:
            case D3DXPT_STRING:
                break;
 
            case D3DXPT_VERTEXSHADER:
            case D3DXPT_PIXELSHADER:
            case D3DXPT_TEXTURE:
            case D3DXPT_TEXTURE1D:
            case D3DXPT_TEXTURE2D:
            case D3DXPT_TEXTURE3D:
            case D3DXPT_TEXTURECUBE:
            {
                unsigned int i;
 
                for (i = 0; i < (param->element_count ? param->element_count : 1); ++i)
                {
                    IUnknown *unk = ((IUnknown **)param->data)[i];
                    if (unk)
                        IUnknown_AddRef(unk);
                }
                break;
            }
 
            default:
                FIXME("Unhandled type %s.\n", debug_d3dxparameter_type(param->type));
                break;
        }
 
        TRACE("Copy %u bytes.\n", param->bytes);
        memcpy(data, param->data, param->bytes);
        return D3D_OK;
    }
 
    WARN("Parameter not found.\n");
 
    return D3DERR_INVALIDCALL;
}

d3dx_effect_GetVector()

static HRESULT WINAPI d3dx_effect_GetVector ( ID3DXEffect *  iface, D3DXHANDLE  parameter, D3DXVECTOR4 *  vector  )

static

Definition at line 2925 of file effect.c.

{
    struct d3dx_effect *effect = impl_from_ID3DXEffect(iface);
    struct d3dx_parameter *param = get_valid_parameter(effect, parameter);
 
    TRACE("iface %p, parameter %p, vector %p.\n", iface, parameter, vector);
 
    if (vector && param && !param->element_count)
    {
        TRACE("Class %s.\n", debug_d3dxparameter_class(param->class));
 
        switch (param->class)
        {
            case D3DXPC_SCALAR:
            case D3DXPC_VECTOR:
                if (param->type == D3DXPT_INT && param->bytes == 4)
                {
                    TRACE("INT fixup.\n");
                    vector->x = (((*(int *)param->data) & 0xff0000) >> 16) * INT_FLOAT_MULTI_INVERSE;
                    vector->y = (((*(int *)param->data) & 0xff00) >> 8) * INT_FLOAT_MULTI_INVERSE;
                    vector->z = ((*(int *)param->data) & 0xff) * INT_FLOAT_MULTI_INVERSE;
                    vector->w = (((*(int *)param->data) & 0xff000000) >> 24) * INT_FLOAT_MULTI_INVERSE;
                    return D3D_OK;
                }
                get_vector(param, vector);
                return D3D_OK;
 
            case D3DXPC_MATRIX_ROWS:
            case D3DXPC_OBJECT:
            case D3DXPC_STRUCT:
                break;
 
            default:
                FIXME("Unhandled class %s.\n", debug_d3dxparameter_class(param->class));
                break;
        }
    }
 
    WARN("Parameter not found.\n");
 
    return D3DERR_INVALIDCALL;
}

d3dx_effect_GetVectorArray()

static HRESULT WINAPI d3dx_effect_GetVectorArray ( ID3DXEffect *  iface, D3DXHANDLE  parameter, D3DXVECTOR4 *  vector, UINT  count  )

static

Definition at line 3025 of file effect.c.

{
    struct d3dx_effect *effect = impl_from_ID3DXEffect(iface);
    struct d3dx_parameter *param = get_valid_parameter(effect, parameter);
 
    TRACE("iface %p, parameter %p, vector %p, count %u.\n", iface, parameter, vector, count);
 
    if (!count)
        return D3D_OK;
 
    if (vector && param && count <= param->element_count)
    {
        unsigned int i;
 
        TRACE("Class %s.\n", debug_d3dxparameter_class(param->class));
 
        switch (param->class)
        {
            case D3DXPC_VECTOR:
                for (i = 0; i < count; ++i)
                    get_vector(&param->members[i], &vector[i]);
                return D3D_OK;
 
            case D3DXPC_SCALAR:
            case D3DXPC_MATRIX_ROWS:
            case D3DXPC_OBJECT:
            case D3DXPC_STRUCT:
                break;
 
            default:
                FIXME("Unhandled class %s.\n", debug_d3dxparameter_class(param->class));
                break;
        }
    }
 
    WARN("Parameter not found.\n");
 
    return D3DERR_INVALIDCALL;
}

d3dx_effect_GetVertexShader()

static HRESULT WINAPI d3dx_effect_GetVertexShader ( ID3DXEffect *  iface, D3DXHANDLE  parameter, IDirect3DVertexShader9 **  shader  )

static

Definition at line 3656 of file effect.c.

{
    struct d3dx_effect *effect = impl_from_ID3DXEffect(iface);
    struct d3dx_parameter *param = get_valid_parameter(effect, parameter);
 
    TRACE("iface %p, parameter %p, shader %p.\n", iface, parameter, shader);
 
    if (shader && param && !param->element_count && param->type == D3DXPT_VERTEXSHADER)
    {
        if ((*shader = *(IDirect3DVertexShader9 **)param->data))
            IDirect3DVertexShader9_AddRef(*shader);
        TRACE("Returning %p.\n", *shader);
        return D3D_OK;
    }
 
    WARN("Parameter not found.\n");
 
    return D3DERR_INVALIDCALL;
}

d3dx_effect_IsParameterUsed()

static BOOL WINAPI d3dx_effect_IsParameterUsed ( ID3DXEffect *  iface, D3DXHANDLE  parameter, D3DXHANDLE  technique