ReactOS 0.4.17-dev-970-gcf0f1a6
Classes | Macros | Typedefs | Enumerations | Functions | Variables
effect.c File Reference
#include <stdbool.h>
#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 d3dx9_effect_init_from_binary (struct d3dx_effect *effect, struct IDirect3DDevice9 *device, const char *data, SIZE_T data_size, unsigned int flags, struct ID3DXEffectPool *pool, const char *skip_constants_string)
 
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 uint32_t read_u32 (const char **ptr)
 
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 int param_rb_compare (const void *key, const struct wine_rb_entry *entry)
 
HRESULT d3dx_init_parameters_store (struct d3dx_parameters_store *store, unsigned int count)
 
void d3dx_parameters_store_cleanup (struct d3dx_parameters_store *store)
 
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_parameters_store *store, 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_parameters_store *store, 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 bool copy_parameter (struct d3dx_effect *dst_effect, const struct d3dx_effect *src_effect, struct d3dx_parameter *dst, const struct d3dx_parameter *src)
 
static HRESULT WINAPI d3dx_effect_CloneEffect (ID3DXEffect *iface, IDirect3DDevice9 *device, ID3DXEffect **out)
 
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 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, uint32_t 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 flags, 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 *data, UINT data_size, const D3DXMACRO *defines, struct ID3DXInclude *include, DWORD flags, struct ID3DXEffectPool *pool, struct ID3DXEffect **effect, struct ID3DXBuffer **messages)
 
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 **messages)
 
HRESULT WINAPI D3DXCreateEffectCompiler (const char *data, UINT data_size, const D3DXMACRO *defines, ID3DXInclude *include, DWORD flags, ID3DXEffectCompiler **compiler, ID3DXBuffer **messages)
 
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 **messages)
 
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 **messages)
 
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 **messages)
 
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 **messages)
 
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 **messages)
 
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 **messages)
 
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 **messages)
 
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 **messages)
 
HRESULT WINAPI D3DXCreateEffectCompilerFromFileW (const WCHAR *srcfile, const D3DXMACRO *defines, ID3DXInclude *include, DWORD flags, ID3DXEffectCompiler **compiler, ID3DXBuffer **messages)
 
HRESULT WINAPI D3DXCreateEffectCompilerFromFileA (const char *srcfile, const D3DXMACRO *defines, ID3DXInclude *include, DWORD flags, ID3DXEffectCompiler **compiler, ID3DXBuffer **messages)
 
HRESULT WINAPI D3DXCreateEffectCompilerFromResourceA (HMODULE srcmodule, const char *srcresource, const D3DXMACRO *defines, ID3DXInclude *include, DWORD flags, ID3DXEffectCompiler **compiler, ID3DXBuffer **messages)
 
HRESULT WINAPI D3DXCreateEffectCompilerFromResourceW (HMODULE srcmodule, const WCHAR *srcresource, const D3DXMACRO *defines, ID3DXInclude *include, DWORD flags, ID3DXEffectCompiler **compiler, ID3DXBuffer **messages)
 
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 6418 of file effect.c.

◆ INITIAL_PARAM_BLOCK_SIZE

#define INITIAL_PARAM_BLOCK_SIZE   1024

Definition at line 39 of file effect.c.

◆ INITIAL_POOL_SIZE

#define INITIAL_POOL_SIZE   16

Definition at line 38 of file effect.c.

◆ INITIAL_SHARED_DATA_SIZE

#define INITIAL_SHARED_DATA_SIZE   4

Definition at line 204 of file effect.c.

◆ INT_FLOAT_MULTI

#define INT_FLOAT_MULTI   255.0f

Definition at line 30 of file effect.c.

◆ INT_FLOAT_MULTI_INVERSE

#define INT_FLOAT_MULTI_INVERSE   (1/INT_FLOAT_MULTI)

Definition at line 31 of file effect.c.

◆ PARAMETER_FLAG_SHARED

#define PARAMETER_FLAG_SHARED   1

Definition at line 36 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 230 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 71 of file effect.c.

72{
73 LT_TYPE,
74 LT_DIFFUSE,
75 LT_SPECULAR,
76 LT_AMBIENT,
77 LT_POSITION,
78 LT_DIRECTION,
79 LT_RANGE,
80 LT_FALLOFF,
81 LT_ATTENUATION0,
82 LT_ATTENUATION1,
83 LT_ATTENUATION2,
84 LT_THETA,
85 LT_PHI,
86};
LT_ATTENUATION0
@ LT_ATTENUATION0
Definition: effect.c:81
LT_THETA
@ LT_THETA
Definition: effect.c:84
LT_SPECULAR
@ LT_SPECULAR
Definition: effect.c:75
LT_DIFFUSE
@ LT_DIFFUSE
Definition: effect.c:74
LT_RANGE
@ LT_RANGE
Definition: effect.c:79
LT_ATTENUATION2
@ LT_ATTENUATION2
Definition: effect.c:83
LT_AMBIENT
@ LT_AMBIENT
Definition: effect.c:76
LT_TYPE
@ LT_TYPE
Definition: effect.c:73
LT_POSITION
@ LT_POSITION
Definition: effect.c:77
LT_DIRECTION
@ LT_DIRECTION
Definition: effect.c:78
LT_ATTENUATION1
@ LT_ATTENUATION1
Definition: effect.c:82
LT_PHI
@ LT_PHI
Definition: effect.c:85
LT_FALLOFF
@ LT_FALLOFF
Definition: effect.c:80

◆ MATERIAL_TYPE

enum MATERIAL_TYPE
Enumerator
MT_DIFFUSE 
MT_AMBIENT 
MT_SPECULAR 
MT_EMISSIVE 
MT_POWER 

Definition at line 62 of file effect.c.

63{
64 MT_DIFFUSE,
65 MT_AMBIENT,
66 MT_SPECULAR,
67 MT_EMISSIVE,
68 MT_POWER,
69};
MT_EMISSIVE
@ MT_EMISSIVE
Definition: effect.c:67
MT_POWER
@ MT_POWER
Definition: effect.c:68
MT_DIFFUSE
@ MT_DIFFUSE
Definition: effect.c:64
MT_AMBIENT
@ MT_AMBIENT
Definition: effect.c:65
MT_SPECULAR
@ MT_SPECULAR
Definition: effect.c:66

◆ SHADER_CONSTANT_TYPE

enum SHADER_CONSTANT_TYPE
Enumerator
SCT_VSFLOAT 
SCT_VSBOOL 
SCT_VSINT 
SCT_PSFLOAT 
SCT_PSBOOL 
SCT_PSINT 

Definition at line 88 of file effect.c.

89{
90 SCT_VSFLOAT,
91 SCT_VSBOOL,
92 SCT_VSINT,
93 SCT_PSFLOAT,
94 SCT_PSBOOL,
95 SCT_PSINT,
96};
SCT_PSINT
@ SCT_PSINT
Definition: effect.c:95
SCT_VSBOOL
@ SCT_VSBOOL
Definition: effect.c:91
SCT_VSINT
@ SCT_VSINT
Definition: effect.c:92
SCT_VSFLOAT
@ SCT_VSFLOAT
Definition: effect.c:90
SCT_PSBOOL
@ SCT_PSBOOL
Definition: effect.c:94
SCT_PSFLOAT
@ SCT_PSFLOAT
Definition: effect.c:93

◆ 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 43 of file effect.c.

44{
45 SC_LIGHTENABLE,
46 SC_FVF,
47 SC_LIGHT,
48 SC_MATERIAL,
49 SC_NPATCHMODE,
50 SC_PIXELSHADER,
51 SC_RENDERSTATE,
52 SC_SETSAMPLER,
53 SC_SAMPLERSTATE,
54 SC_TEXTURE,
55 SC_TEXTURESTAGE,
56 SC_TRANSFORM,
57 SC_VERTEXSHADER,
58 SC_SHADERCONST,
59 SC_UNKNOWN,
60};
SC_NPATCHMODE
@ SC_NPATCHMODE
Definition: effect.c:49
SC_TEXTURE
@ SC_TEXTURE
Definition: effect.c:54
SC_TEXTURESTAGE
@ SC_TEXTURESTAGE
Definition: effect.c:55
SC_UNKNOWN
@ SC_UNKNOWN
Definition: effect.c:59
SC_TRANSFORM
@ SC_TRANSFORM
Definition: effect.c:56
SC_LIGHTENABLE
@ SC_LIGHTENABLE
Definition: effect.c:45
SC_SHADERCONST
@ SC_SHADERCONST
Definition: effect.c:58
SC_MATERIAL
@ SC_MATERIAL
Definition: effect.c:48
SC_SAMPLERSTATE
@ SC_SAMPLERSTATE
Definition: effect.c:53
SC_RENDERSTATE
@ SC_RENDERSTATE
Definition: effect.c:51
SC_VERTEXSHADER
@ SC_VERTEXSHADER
Definition: effect.c:57
SC_SETSAMPLER
@ SC_SETSAMPLER
Definition: effect.c:52
SC_PIXELSHADER
@ SC_PIXELSHADER
Definition: effect.c:50
SC_LIGHT
@ SC_LIGHT
Definition: effect.c:47
SC_FVF
@ SC_FVF
Definition: effect.c:46

◆ STATE_TYPE

enum STATE_TYPE
Enumerator
ST_CONSTANT 
ST_PARAMETER 
ST_FXLC 
ST_ARRAY_SELECTOR 

Definition at line 98 of file effect.c.

99{
100 ST_CONSTANT,
101 ST_PARAMETER,
102 ST_FXLC,
103 ST_ARRAY_SELECTOR,
104};
ST_FXLC
@ ST_FXLC
Definition: effect.c:102
ST_PARAMETER
@ ST_PARAMETER
Definition: effect.c:101
ST_CONSTANT
@ ST_CONSTANT
Definition: effect.c:100
ST_ARRAY_SELECTOR
@ ST_ARRAY_SELECTOR
Definition: effect.c:103

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 5367 of file effect.c.

5369{
5370 const char *parent_name = parent ? parent->full_name : NULL;
5371 unsigned int i;
5372
5373 TRACE("Adding parameter %p (%s - parent %p, element %u) to the rbtree.\n",
5374 param, debugstr_a(param->name), parent, element);
5375
5376 if (parent_name)
5377 {
5378 unsigned int parent_name_len = strlen(parent_name);
5379 unsigned int name_len = strlen(param->name);
5380 unsigned int part_str_len;
5381 unsigned int len;
5382 char part_str[16];
5383
5384 if (separator == '[')
5385 {
5386 sprintf(part_str, "[%u]", element);
5387 part_str_len = strlen(part_str);
5388 name_len = 0;
5389 }
5390 else
5391 {
5392 part_str[0] = separator;
5393 part_str[1] = 0;
5394 part_str_len = 1;
5395 }
5396 len = parent_name_len + part_str_len + name_len + 1;
5397
5398 if (!(param->full_name = malloc(len)))
5399 {
5400 ERR("Out of memory.\n");
5401 return;
5402 }
5403
5404 memcpy(param->full_name, parent_name, parent_name_len);
5405 memcpy(param->full_name + parent_name_len, part_str, part_str_len);
5406 memcpy(param->full_name + parent_name_len + part_str_len, param->name, name_len);
5407 param->full_name[len - 1] = 0;
5408 }
5409 else
5410 {
5411 if (!(param->full_name = strdup(param->name)))
5412 {
5413 ERR("Out of memory.\n");
5414 return;
5415 }
5416 }
5417 TRACE("Full name is %s.\n", param->full_name);
5418 wine_rb_put(&effect->params.tree, param->full_name, &param->rb_entry);
5419
5420 if (is_top_level_parameter(param))
5421 for (i = 0; i < param->top_level_param->annotation_count; ++i)
5422 add_param_to_tree(effect, &param->top_level_param->annotations[i], param, '@', 0);
5423
5424 if (param->element_count)
5425 for (i = 0; i < param->element_count; ++i)
5426 add_param_to_tree(effect, &param->members[i], param, '[', i);
5427 else
5428 for (i = 0; i < param->member_count; ++i)
5429 add_param_to_tree(effect, &param->members[i], param, '.', 0);
5430}
ERR
#define ERR(fmt,...)
Definition: precomp.h:57
is_top_level_parameter
static BOOL is_top_level_parameter(struct d3dx_parameter *param)
Definition: d3dx9_private.h:555
malloc
#define malloc
Definition: debug_ros.c:4
NULL
#define NULL
Definition: types.h:112
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)
Definition: effect.c:5367
separator
static const WCHAR separator[]
Definition: asmname.c:65
strlen
_ACRTIMP size_t __cdecl strlen(const char *)
Definition: string.c:1597
strdup
static char * strdup(const char *buf)
Definition: string.h:83
parent
r parent
Definition: btrfs.c:3010
param
GLfloat param
Definition: glext.h:5796
len
GLenum GLsizei len
Definition: glext.h:6722
i
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
debugstr_a
#define debugstr_a
Definition: kernel32.h:31
memcpy
#define memcpy(s1, s2, n)
Definition: mkisofs.h:878
sprintf
#define sprintf
Definition: sprintf.c:45
wine_rb_put
#define wine_rb_put
Definition: rbtree.h:410
TRACE
#define TRACE(s)
Definition: solgame.cpp:4
d3dx_effect::params
struct d3dx_parameters_store params
Definition: effect.c:180

Referenced by add_param_to_tree(), and d3dx_parse_effect().

◆ copy_parameter()

static bool copy_parameter ( struct d3dx_effect *  dst_effect,
const struct d3dx_effect *  src_effect,
struct d3dx_parameter *  dst,
const struct d3dx_parameter *  src 
)
static

Definition at line 4313 of file effect.c.

4315{
4316 IUnknown *iface;
4317
4318 if ((src->flags & PARAMETER_FLAG_SHARED) && dst_effect->pool)
4319 return true;
4320
4321 switch (src->type)
4322 {
4323 case D3DXPT_VOID:
4324 case D3DXPT_BOOL:
4325 case D3DXPT_INT:
4326 case D3DXPT_FLOAT:
4327 memcpy(dst->data, src->data, src->bytes);
4328 break;
4329
4330 case D3DXPT_STRING:
4331 free(*(char **)dst->data);
4332 if (!(*(char **)dst->data = strdup(*(char **)src->data)))
4333 return false;
4334 break;
4335
4336 case D3DXPT_TEXTURE:
4337 case D3DXPT_TEXTURE1D:
4338 case D3DXPT_TEXTURE2D:
4339 case D3DXPT_TEXTURE3D:
4340 case D3DXPT_TEXTURECUBE:
4341 case D3DXPT_PIXELSHADER:
4342 case D3DXPT_VERTEXSHADER:
4343 iface = *(IUnknown **)src->data;
4344 if (src_effect->device == dst_effect->device && iface)
4345 {
4346 if (*(IUnknown **)dst->data)
4347 IUnknown_Release(*(IUnknown **)dst->data);
4348 IUnknown_AddRef(iface);
4349 *(IUnknown **)dst->data = iface;
4350 }
4351 break;
4352
4353 case D3DXPT_SAMPLER:
4354 case D3DXPT_SAMPLER1D:
4355 case D3DXPT_SAMPLER2D:
4356 case D3DXPT_SAMPLER3D:
4357 case D3DXPT_SAMPLERCUBE:
4358 /* Nothing to do; these parameters are not mutable and cannot be
4359 * retrieved using API calls. */
4360 break;
4361
4362 default:
4363 FIXME("Unhandled parameter type %#x.\n", src->type);
4364 }
4365
4366 return true;
4367}
FIXME
#define FIXME(fmt,...)
Definition: precomp.h:53
free
#define free
Definition: debug_ros.c:5
PARAMETER_FLAG_SHARED
#define PARAMETER_FLAG_SHARED
Definition: effect.c:36
D3DXPT_STRING
@ D3DXPT_STRING
Definition: d3dx9shader.h:77
D3DXPT_TEXTURE
@ D3DXPT_TEXTURE
Definition: d3dx9shader.h:78
D3DXPT_SAMPLER3D
@ D3DXPT_SAMPLER3D
Definition: d3dx9shader.h:86
D3DXPT_VERTEXSHADER
@ D3DXPT_VERTEXSHADER
Definition: d3dx9shader.h:89
D3DXPT_TEXTURE1D
@ D3DXPT_TEXTURE1D
Definition: d3dx9shader.h:79
D3DXPT_SAMPLERCUBE
@ D3DXPT_SAMPLERCUBE
Definition: d3dx9shader.h:87
D3DXPT_FLOAT
@ D3DXPT_FLOAT
Definition: d3dx9shader.h:76
D3DXPT_TEXTURECUBE
@ D3DXPT_TEXTURECUBE
Definition: d3dx9shader.h:82
D3DXPT_PIXELSHADER
@ D3DXPT_PIXELSHADER
Definition: d3dx9shader.h:88
D3DXPT_BOOL
@ D3DXPT_BOOL
Definition: d3dx9shader.h:74
D3DXPT_INT
@ D3DXPT_INT
Definition: d3dx9shader.h:75
D3DXPT_VOID
@ D3DXPT_VOID
Definition: d3dx9shader.h:73
D3DXPT_SAMPLER
@ D3DXPT_SAMPLER
Definition: d3dx9shader.h:83
D3DXPT_SAMPLER1D
@ D3DXPT_SAMPLER1D
Definition: d3dx9shader.h:84
D3DXPT_SAMPLER2D
@ D3DXPT_SAMPLER2D
Definition: d3dx9shader.h:85
D3DXPT_TEXTURE3D
@ D3DXPT_TEXTURE3D
Definition: d3dx9shader.h:81
D3DXPT_TEXTURE2D
@ D3DXPT_TEXTURE2D
Definition: d3dx9shader.h:80
src
GLenum src
Definition: glext.h:6340
dst
GLenum GLenum dst
Definition: glext.h:6340
if
if(dx< 0)
Definition: linetemp.h:194
d3dx_effect::device
struct IDirect3DDevice9 * device
Definition: effect.c:183
d3dx_effect::pool
struct d3dx_effect_pool * pool
Definition: effect.c:184

Referenced by d3dx_effect_CloneEffect().

◆ 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 1745 of file effect.c.

1746{
1747 unsigned int i;
1748 HRESULT ret;
1749 HRESULT hr;
1750 ULONG64 new_update_version = next_effect_update_version(effect);
1751
1752 TRACE("effect %p, pass %p, state_count %u.\n", effect, pass, pass->state_count);
1753
1754 ret = D3D_OK;
1755 for (i = 0; i < pass->state_count; ++i)
1756 {
1757 if (FAILED(hr = d3dx9_apply_state(effect, pass, &pass->states[i], ~0u, update_all)))
1758 {
1759 WARN("Error applying state, hr %#lx.\n", hr);
1760 ret = hr;
1761 }
1762 }
1763
1764 if (effect->light_updated)
1765 {
1766 for (i = 0; i < ARRAY_SIZE(effect->current_light); ++i)
1767 {
1768 if ((effect->light_updated & (1u << i))
1769 && FAILED(hr = SET_D3D_STATE(effect, SetLight, i, &effect->current_light[i])))
1770 {
1771 WARN("Error setting light, hr %#lx.\n", hr);
1772 ret = hr;
1773 }
1774 }
1775 effect->light_updated = 0;
1776 }
1777
1778 if (effect->material_updated
1779 && FAILED(hr = SET_D3D_STATE(effect, SetMaterial, &effect->current_material)))
1780 {
1781 WARN("Error setting material, hr %#lx.\n", hr);
1782 ret = hr;
1783 }
1784 effect->material_updated = FALSE;
1785
1786 pass->update_version = new_update_version;
1787 return ret;
1788}
ARRAY_SIZE
#define ARRAY_SIZE(A)
Definition: main.h:20
WARN
#define WARN(fmt,...)
Definition: precomp.h:61
D3D_OK
#define D3D_OK
Definition: d3d.h:106
SET_D3D_STATE
#define SET_D3D_STATE(base_effect,...)
Definition: d3dx9_private.h:609
hr
HRESULT hr
Definition: delayimp.cpp:582
FALSE
#define FALSE
Definition: types.h:117
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)
Definition: effect.c:1609
next_effect_update_version
static ULONG64 next_effect_update_version(struct d3dx_effect *effect)
Definition: effect.c:1291
ret
return ret
Definition: mutex.c:147
u
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble * u
Definition: glfuncs.h:240
FAILED
#define FAILED(hr)
Definition: intsafe.h:51
ULONG64
unsigned __int64 ULONG64
Definition: imports.h:198
d3dx_effect::current_material
D3DMATERIAL9 current_material
Definition: effect.c:193
d3dx_effect::material_updated
BOOL material_updated
Definition: effect.c:194
d3dx_effect::current_light
D3DLIGHT9 current_light[8]
Definition: effect.c:191
d3dx_effect::light_updated
unsigned int light_updated
Definition: effect.c:192
pass
pass
Definition: typegen.h:25

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 1609 of file effect.c.

1611{
1612 struct d3dx_parameter *param;
1613 void *param_value;
1614 BOOL param_dirty;
1615 HRESULT hr;
1616
1617 TRACE("operation %u, index %u, type %u.\n", state->operation, state->index, state->type);
1618
1619 if (FAILED(hr = d3dx9_get_param_value_ptr(pass, state, &param_value, &param,
1620 update_all, &param_dirty)))
1621 {
1622 if (!update_all && hr == E_FAIL)
1623 {
1624 /* Native d3dx9 returns D3D_OK from CommitChanges() involving
1625 * out of bounds array access and does not touch the affected
1626 * states. */
1627 WARN("Returning D3D_OK on out of bounds array access.\n");
1628 return D3D_OK;
1629 }
1630 return hr;
1631 }
1632
1633 if (!(update_all || param_dirty
1634 || state_table[state->operation].class == SC_VERTEXSHADER
1635 || state_table[state->operation].class == SC_PIXELSHADER
1636 || state_table[state->operation].class == SC_SETSAMPLER))
1637 return D3D_OK;
1638
1639 switch (state_table[state->operation].class)
1640 {
1641 case SC_RENDERSTATE:
1642 TRACE("%s, operation %u, value %lu.\n", state_table[state->operation].name,
1643 state_table[state->operation].op, *(DWORD *)param_value);
1644 return SET_D3D_STATE(effect, SetRenderState, state_table[state->operation].op, *(DWORD *)param_value);
1645 case SC_FVF:
1646 TRACE("%s, value %#lx.\n", state_table[state->operation].name, *(DWORD *)param_value);
1647 return SET_D3D_STATE(effect, SetFVF, *(DWORD *)param_value);
1648 case SC_TEXTURE:
1649 {
1650 UINT unit;
1651
1652 unit = parent_index == ~0u ? state->index : parent_index;
1653 TRACE("%s, unit %u, value %p.\n", state_table[state->operation].name, unit,
1654 *(IDirect3DBaseTexture9 **)param_value);
1655 return SET_D3D_STATE(effect, SetTexture, unit, *(IDirect3DBaseTexture9 **)param_value);
1656 }
1657 case SC_TEXTURESTAGE:
1658 TRACE("%s, stage %u, value %lu.\n", state_table[state->operation].name, state->index, *(DWORD *)param_value);
1659 return SET_D3D_STATE(effect, SetTextureStageState, state->index,
1660 state_table[state->operation].op, *(DWORD *)param_value);
1661 case SC_SETSAMPLER:
1662 {
1663 struct d3dx_sampler *sampler;
1664 HRESULT ret, hr;
1665 unsigned int i;
1666
1667 sampler = (struct d3dx_sampler *)param_value;
1668 TRACE("%s, sampler %u, applying %u states.\n", state_table[state->operation].name, state->index,
1669 sampler->state_count);
1670 ret = D3D_OK;
1671 for (i = 0; i < sampler->state_count; i++)
1672 {
1673 if (FAILED(hr = d3dx9_apply_state(effect, pass, &sampler->states[i], state->index, update_all)))
1674 ret = hr;
1675 }
1676 return ret;
1677 }
1678 case SC_SAMPLERSTATE:
1679 {
1680 UINT sampler;
1681
1682 sampler = parent_index == ~0u ? state->index : parent_index;
1683 TRACE("%s, sampler %u, value %lu.\n", state_table[state->operation].name, sampler, *(DWORD *)param_value);
1684 return SET_D3D_STATE(effect, SetSamplerState, sampler, state_table[state->operation].op,
1685 *(DWORD *)param_value);
1686 }
1687 case SC_VERTEXSHADER:
1688 TRACE("%s, shader %p.\n", state_table[state->operation].name, *(IDirect3DVertexShader9 **)param_value);
1689 if ((update_all || param_dirty)
1690 && FAILED(hr = SET_D3D_STATE(effect, SetVertexShader,
1691 *(IDirect3DVertexShader9 **)param_value)))
1692 ERR("Could not set vertex shader, hr %#lx.\n", hr);
1693 else if (*(IDirect3DVertexShader9 **)param_value)
1694 hr = d3dx_set_shader_constants(effect, pass, param, TRUE, update_all || param_dirty);
1695 return hr;
1696 case SC_PIXELSHADER:
1697 TRACE("%s, shader %p.\n", state_table[state->operation].name, *(IDirect3DPixelShader9 **)param_value);
1698 if ((update_all || param_dirty)
1699 && FAILED(hr = SET_D3D_STATE(effect, SetPixelShader,
1700 *(IDirect3DPixelShader9 **)param_value)))
1701 ERR("Could not set pixel shader, hr %#lx.\n", hr);
1702 else if (*(IDirect3DPixelShader9 **)param_value)
1703 hr = d3dx_set_shader_constants(effect, pass, param, FALSE, update_all || param_dirty);
1704 return hr;
1705 case SC_TRANSFORM:
1706 TRACE("%s, state %u.\n", state_table[state->operation].name, state->index);
1707 return SET_D3D_STATE(effect, SetTransform, state_table[state->operation].op + state->index,
1708 (D3DMATRIX *)param_value);
1709 case SC_LIGHTENABLE:
1710 TRACE("%s, index %u, value %u.\n", state_table[state->operation].name, state->index, *(BOOL *)param_value);
1711 return SET_D3D_STATE(effect, LightEnable, state->index, *(BOOL *)param_value);
1712 case SC_LIGHT:
1713 {
1714 TRACE("%s, index %u, op %u.\n", state_table[state->operation].name, state->index,
1715 state_table[state->operation].op);
1716 d3dx9_set_light_parameter(state_table[state->operation].op,
1717 &effect->current_light[state->index], param_value);
1718 effect->light_updated |= 1u << state->index;
1719 return D3D_OK;
1720 }
1721 case SC_MATERIAL:
1722 {
1723 TRACE("%s, index %u, op %u.\n", state_table[state->operation].name, state->index,
1724 state_table[state->operation].op);
1725 d3dx9_set_material_parameter(state_table[state->operation].op,
1726 &effect->current_material, param_value);
1727 effect->material_updated = TRUE;
1728 return D3D_OK;
1729 }
1730 case SC_NPATCHMODE:
1731 TRACE("%s, nsegments %f.\n", state_table[state->operation].name, *(float *)param_value);
1732 return SET_D3D_STATE(effect, SetNPatchMode, *(float *)param_value);
1733 case SC_SHADERCONST:
1734 TRACE("%s, index %u, op %u.\n", state_table[state->operation].name, state->index,
1735 state_table[state->operation].op);
1736 return d3dx_set_shader_const_state(effect, state_table[state->operation].op, state->index,
1737 param, param_value);
1738 default:
1739 FIXME("%s not handled.\n", state_table[state->operation].name);
1740 break;
1741 }
1742 return D3D_OK;
1743}
state
static int state
Definition: maze.c:121
E_FAIL
#define E_FAIL
Definition: ddrawi.h:102
TRUE
#define TRUE
Definition: types.h:120
d3dx9_set_light_parameter
static void d3dx9_set_light_parameter(enum LIGHT_TYPE op, D3DLIGHT9 *light, void *value)
Definition: effect.c:1357
d3dx9_set_material_parameter
static void d3dx9_set_material_parameter(enum MATERIAL_TYPE op, D3DMATERIAL9 *material, void *value)
Definition: effect.c:1424
d3dx_set_shader_constants
static HRESULT d3dx_set_shader_constants(struct d3dx_effect *effect, struct d3dx_pass *pass, struct d3dx_parameter *param, BOOL vs, BOOL update_all)
Definition: effect.c:1563
d3dx_set_shader_const_state
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)
Definition: effect.c:1467
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)
Definition: effect.c:1134
state_table
static const struct @283 state_table[]
BOOL
unsigned int BOOL
Definition: ntddk_ex.h:94
DWORD
unsigned long DWORD
Definition: ntddk_ex.h:95
sampler
GLuint sampler
Definition: glext.h:7283
UINT
unsigned int UINT
Definition: sysinfo.c:13
unit
png_const_structrp png_const_inforp int * unit
Definition: png.h:2392
_D3DMATRIX
Definition: d3d8types.h:1108
d3dx_parameter
Definition: d3dx9_private.h:512
d3dx_sampler
Definition: effect.c:124

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 5326 of file effect.c.

5327{
5328 struct d3dx_object *object = &effect->objects[object_id];
5329
5330 if (object->size || object->data)
5331 {
5332 if (object_id)
5333 FIXME("Overwriting object id %u!\n", object_id);
5334 else
5335 TRACE("Overwriting object id 0.\n");
5336
5337 free(object->data);
5338 object->data = NULL;
5339 }
5340
5341 object->size = read_u32(ptr);
5342 TRACE("Data size: %#x.\n", object->size);
5343
5344 if (!object->size)
5345 return D3D_OK;
5346
5347 object->data = malloc(object->size);
5348 if (!object->data)
5349 {
5350 ERR("Failed to allocate object memory.\n");
5351 return E_OUTOFMEMORY;
5352 }
5353
5354 TRACE("Data: %s.\n", debugstr_an(*ptr, object->size));
5355 memcpy(object->data, *ptr, object->size);
5356
5357 *ptr += ((object->size + 3) & ~3);
5358
5359 return D3D_OK;
5360}
E_OUTOFMEMORY
#define E_OUTOFMEMORY
Definition: ddrawi.h:100
read_u32
static uint32_t read_u32(const char **ptr)
Definition: utils.h:24
debugstr_an
static __inline const char * debugstr_an(const char *s, int n)
Definition: compat.h:55
ptr
static PVOID ptr
Definition: dispmode.c:27
d3dx_effect::objects
struct d3dx_object * objects
Definition: effect.c:177
d3dx_object
Definition: effect.c:107

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 5993 of file effect.c.

5994{
5995 struct d3dx_parameter *param = object->param;
5996 IDirect3DDevice9 *device = effect->device;
5997 HRESULT hr;
5998
5999 if (*(char **)param->data)
6000 ERR("Parameter data already allocated.\n");
6001
6002 switch (param->type)
6003 {
6004 case D3DXPT_STRING:
6005 *(char **)param->data = malloc(object->size);
6006 if (!*(char **)param->data)
6007 {
6008 ERR("Out of memory.\n");
6009 return E_OUTOFMEMORY;
6010 }
6011 memcpy(*(char **)param->data, object->data, object->size);
6012 break;
6013 case D3DXPT_VERTEXSHADER:
6014 if (FAILED(hr = IDirect3DDevice9_CreateVertexShader(device, object->data,
6015 (IDirect3DVertexShader9 **)param->data)))
6016 {
6017 WARN("Failed to create vertex shader.\n");
6018 object->creation_failed = TRUE;
6019 }
6020 break;
6021 case D3DXPT_PIXELSHADER:
6022 if (FAILED(hr = IDirect3DDevice9_CreatePixelShader(device, object->data,
6023 (IDirect3DPixelShader9 **)param->data)))
6024 {
6025 WARN("Failed to create pixel shader.\n");
6026 object->creation_failed = TRUE;
6027 }
6028 break;
6029 default:
6030 break;
6031 }
6032 return D3D_OK;
6033}
IDirect3DDevice9_CreatePixelShader
#define IDirect3DDevice9_CreatePixelShader(p, a, b)
Definition: d3d9.h:1441
IDirect3DDevice9_CreateVertexShader
#define IDirect3DDevice9_CreateVertexShader(p, a, b)
Definition: d3d9.h:1426
IDirect3DDevice9
DWORD IDirect3DDevice9
Definition: dxva2api.idl:22
device
Definition: devices.h:37

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 **  messages 
)
static

Definition at line 6740 of file effect.c.

6743{
6744 TRACE("compiler %p, data %p, data_size %Iu, defines %p, include %p, eflags %#x, messages %p.\n",
6745 compiler, data, data_size, defines, include, eflags, messages);
6746
6747 compiler->ID3DXEffectCompiler_iface.lpVtbl = &ID3DXEffectCompiler_Vtbl;
6748 compiler->ref = 1;
6749
6750 FIXME("ID3DXEffectCompiler implementation is only a stub.\n");
6751
6752 return D3D_OK;
6753}
include
static SIZE_T const char const D3D_SHADER_MACRO ID3DInclude * include
Definition: asm.c:31
defines
static SIZE_T const char const D3D_SHADER_MACRO * defines
Definition: asm.c:31
ID3DXEffectCompiler_Vtbl
static const struct ID3DXEffectCompilerVtbl ID3DXEffectCompiler_Vtbl
Definition: effect.c:5034
data
GLint GLenum GLsizei GLsizei GLsizei GLint GLsizei const GLvoid * data
Definition: gl.h:1950
ID3DXEffectCompilerImpl::ID3DXEffectCompiler_iface
ID3DXEffectCompiler ID3DXEffectCompiler_iface
Definition: effect.c:219

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  flags,
ID3DBlob **  errors,
struct ID3DXEffectPool *  pool,
const char *  skip_constants_string 
)
static

Definition at line 6613 of file effect.c.

6616{
6617#if D3DX_SDK_VERSION <= 36
6618 UINT compile_flags = D3DCOMPILE_ENABLE_BACKWARDS_COMPATIBILITY;
6619#else
6620 UINT compile_flags = 0;
6621#endif
6622 ID3DBlob *bytecode = NULL, *temp_errors = NULL;
6623 const char *ptr = data;
6624 unsigned int tag;
6625 HRESULT hr;
6626
6627 TRACE("effect %p, device %p, data %p, data_size %Iu, defines %p, include %p, flags %#x, errors %p, "
6628 "pool %p, skip_constants %s.\n",
6629 effect, device, data, data_size, defines, include, flags, errors, pool,
6630 debugstr_a(skip_constants_string));
6631
6632 tag = read_u32(&ptr);
6633
6634 if (tag == d3dx9_effect_version(9, 1))
6635 return d3dx9_effect_init_from_binary(effect, device, data, data_size, flags, pool, skip_constants_string);
6636
6637 TRACE("HLSL ASCII effect, trying to compile it.\n");
6638 compile_flags |= flags & ~(D3DXFX_NOT_CLONEABLE | D3DXFX_LARGEADDRESSAWARE);
6639 hr = D3DCompile(data, data_size, NULL, defines, include,
6640 NULL, "fx_2_0", compile_flags, 0, &bytecode, &temp_errors);
6641 if (FAILED(hr))
6642 {
6643 WARN("Failed to compile ASCII effect.\n");
6644 if (bytecode)
6645 ID3D10Blob_Release(bytecode);
6646 if (temp_errors)
6647 {
6648 const char *error_string = ID3D10Blob_GetBufferPointer(temp_errors);
6649 const char *string_ptr;
6650
6651 while (*error_string)
6652 {
6653 string_ptr = error_string;
6654 while (*string_ptr && *string_ptr != '\n' && *string_ptr != '\r'
6655 && string_ptr - error_string < 80)
6656 ++string_ptr;
6657 TRACE("%s\n", debugstr_an(error_string, string_ptr - error_string));
6658 error_string = string_ptr;
6659 while (*error_string == '\n' || *error_string == '\r')
6660 ++error_string;
6661 }
6662 }
6663 if (errors)
6664 *errors = temp_errors;
6665 else if (temp_errors)
6666 ID3D10Blob_Release(temp_errors);
6667 return hr;
6668 }
6669 if (!bytecode)
6670 {
6671 FIXME("No output from effect compilation.\n");
6672 return D3DERR_INVALIDCALL;
6673 }
6674 if (errors)
6675 *errors = temp_errors;
6676 else if (temp_errors)
6677 ID3D10Blob_Release(temp_errors);
6678
6679 hr = d3dx9_effect_init_from_binary(effect, device, ID3D10Blob_GetBufferPointer(bytecode),
6680 ID3D10Blob_GetBufferSize(bytecode), flags, pool, skip_constants_string);
6681 ID3D10Blob_Release(bytecode);
6682 return hr;
6683}
D3DERR_INVALIDCALL
#define D3DERR_INVALIDCALL
Definition: d3d10_private.h:42
D3DCOMPILE_ENABLE_BACKWARDS_COMPATIBILITY
#define D3DCOMPILE_ENABLE_BACKWARDS_COMPATIBILITY
Definition: d3dcompiler.h:54
D3DCompile
HRESULT WINAPI D3DCompile(const void *data, SIZE_T data_size, const char *filename, const D3D_SHADER_MACRO *defines, ID3DInclude *include, const char *entrypoint, const char *target, UINT sflags, UINT eflags, ID3DBlob **shader, ID3DBlob **error_messages)
Definition: compiler.c:639
d3dx9_effect_init_from_binary
static HRESULT d3dx9_effect_init_from_binary(struct d3dx_effect *effect, struct IDirect3DDevice9 *device, const char *data, SIZE_T data_size, unsigned int flags, struct ID3DXEffectPool *pool, const char *skip_constants_string)
Definition: effect.c:6473
d3dx9_effect_version
static DWORD d3dx9_effect_version(DWORD major, DWORD minor)
Definition: effect.c:1129
D3DXFX_NOT_CLONEABLE
#define D3DXFX_NOT_CLONEABLE
Definition: d3dx9effect.h:27
D3DXFX_LARGEADDRESSAWARE
#define D3DXFX_LARGEADDRESSAWARE
Definition: d3dx9effect.h:28
flags
GLbitfield flags
Definition: glext.h:7161
tag
Definition: ecma_167.h:138

Referenced by D3DXCreateEffectEx().

◆ d3dx9_effect_init_from_binary()

static HRESULT d3dx9_effect_init_from_binary ( struct d3dx_effect *  effect,
struct IDirect3DDevice9 *  device,
const char *  data,
SIZE_T  data_size,
unsigned int  flags,
struct ID3DXEffectPool *  pool,
const char *  skip_constants_string 
)
static

Definition at line 6473 of file effect.c.

6476{
6477 unsigned int skip_constants_count = 0;
6478 char *skip_constants_buffer = NULL;
6479 const char **skip_constants = NULL;
6480 const char *ptr = data;
6481 uint32_t tag, offset;
6482 unsigned int i, j;
6483 HRESULT hr;
6484
6485 effect->ID3DXEffect_iface.lpVtbl = &ID3DXEffect_Vtbl;
6486 effect->ref = 1;
6487
6488 effect->flags = flags;
6489
6490 list_init(&effect->parameter_block_list);
6491
6492 tag = read_u32(&ptr);
6493 TRACE("Tag: %#x.\n", tag);
6494
6495 if (!(flags & D3DXFX_NOT_CLONEABLE))
6496 {
6497 if (!(effect->source = malloc(data_size)))
6498 return E_OUTOFMEMORY;
6499 memcpy(effect->source, data, data_size);
6500 effect->source_size = data_size;
6501 }
6502
6503 if (pool)
6504 {
6505 effect->pool = unsafe_impl_from_ID3DXEffectPool(pool);
6506 pool->lpVtbl->AddRef(pool);
6507 }
6508
6509 IDirect3DDevice9_AddRef(device);
6510 effect->device = device;
6511
6512 if (skip_constants_string)
6513 {
6514 if (!(flags & D3DXFX_NOT_CLONEABLE) && !(effect->skip_constants_string = strdup(skip_constants_string)))
6515 {
6516 hr = E_OUTOFMEMORY;
6517 goto fail;
6518 }
6519
6520 if (!(skip_constants_buffer = strdup(skip_constants_string)))
6521 {
6522 hr = E_OUTOFMEMORY;
6523 goto fail;
6524 }
6525
6526 if (!(skip_constants = parse_skip_constants_string(skip_constants_buffer, &skip_constants_count)))
6527 {
6528 free(skip_constants_buffer);
6529 hr = E_OUTOFMEMORY;
6530 goto fail;
6531 }
6532 }
6533 offset = read_u32(&ptr);
6534 TRACE("Offset: %#x.\n", offset);
6535
6536 hr = d3dx_parse_effect(effect, ptr, data_size, offset, skip_constants, skip_constants_count);
6537 if (hr != D3D_OK)
6538 {
6539 FIXME("Failed to parse effect.\n");
6540 free(skip_constants_buffer);
6541 free(skip_constants);
6542 goto fail;
6543 }
6544
6545 for (i = 0; i < skip_constants_count; ++i)
6546 {
6547 struct d3dx_parameter *param;
6548 param = get_parameter_by_name(&effect->params, NULL, skip_constants[i]);
6549 if (param)
6550 {
6551 for (j = 0; j < effect->technique_count; ++j)
6552 {
6553 if (is_parameter_used(param, &effect->techniques[j]))
6554 {
6555 WARN("skip_constants parameter %s is used in technique %u.\n",
6556 debugstr_a(skip_constants[i]), j);
6557 free(skip_constants_buffer);
6558 free(skip_constants);
6559 hr = D3DERR_INVALIDCALL;
6560 goto fail;
6561 }
6562 }
6563 }
6564 else
6565 {
6566 TRACE("skip_constants parameter %s not found.\n",
6567 debugstr_a(skip_constants[i]));
6568 }
6569 }
6570
6571 free(skip_constants_buffer);
6572 free(skip_constants);
6573
6574 /* initialize defaults - check because of unsupported ascii effects */
6575 if (effect->techniques)
6576 {
6577 effect->active_technique = &effect->techniques[0];
6578 effect->active_pass = NULL;
6579 }
6580
6581 return D3D_OK;
6582
6583fail:
6584 if (effect->techniques)
6585 {
6586 for (i = 0; i < effect->technique_count; ++i)
6587 free_technique(&effect->techniques[i]);
6588 free(effect->techniques);
6589 }
6590
6591 if (effect->params.parameters)
6592 {
6593 for (i = 0; i < effect->params.count; ++i)
6594 free_top_level_parameter(&effect->params.parameters[i]);
6595 free(effect->params.parameters);
6596 }
6597
6598 if (effect->objects)
6599 {
6600 for (i = 0; i < effect->object_count; ++i)
6601 free_object(&effect->objects[i]);
6602 free(effect->objects);
6603 }
6604
6605 IDirect3DDevice9_Release(effect->device);
6606 if (pool)
6607 pool->lpVtbl->Release(pool);
6608 free(effect->source);
6609 free(effect->skip_constants_string);
6610 return hr;
6611}
list_init
static void list_init(struct list_entry *head)
Definition: list.h:51
IDirect3DDevice9_Release
#define IDirect3DDevice9_Release(p)
Definition: d3d9.h:1336
IDirect3DDevice9_AddRef
#define IDirect3DDevice9_AddRef(p)
Definition: d3d9.h:1335
uint32_t
UINT32 uint32_t
Definition: types.h:75
free_top_level_parameter
static void free_top_level_parameter(struct d3dx_top_level_parameter *param)
Definition: effect.c:633
free_technique
static void free_technique(struct d3dx_technique *technique)
Definition: effect.c:676
is_parameter_used
static BOOL is_parameter_used(struct d3dx_parameter *param, struct d3dx_technique *tech)
Definition: effect.c:3918
d3dx_parse_effect
static HRESULT d3dx_parse_effect(struct d3dx_effect *effect, const char *data, UINT data_size, uint32_t start, const char **skip_constants, unsigned int skip_constants_count)
Definition: effect.c:6278
get_parameter_by_name
struct d3dx_parameter * get_parameter_by_name(struct d3dx_parameters_store *store, struct d3dx_parameter *parameter, const char *name)
Definition: effect.c:1041
parse_skip_constants_string
static const char ** parse_skip_constants_string(char *skip_constants_string, unsigned int *names_count)
Definition: effect.c:6439
unsafe_impl_from_ID3DXEffectPool
static struct d3dx_effect_pool * unsafe_impl_from_ID3DXEffectPool(ID3DXEffectPool *iface)
Definition: effect.c:6866
free_object
static void free_object(struct d3dx_object *object)
Definition: effect.c:529
ID3DXEffect_Vtbl
static const struct ID3DXEffectVtbl ID3DXEffect_Vtbl
Definition: effect.c:4441
offset
GLintptr offset
Definition: glext.h:5920
j
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint GLint GLint j
Definition: glfuncs.h:250
d3dx_effect::active_technique
struct d3dx_technique * active_technique
Definition: effect.c:185
d3dx_effect::source_size
SIZE_T source_size
Definition: effect.c:200
d3dx_effect::technique_count
unsigned int technique_count
Definition: effect.c:174
d3dx_effect::object_count
unsigned int object_count
Definition: effect.c:175
d3dx_effect::techniques
struct d3dx_technique * techniques
Definition: effect.c:176
d3dx_effect::active_pass
struct d3dx_pass * active_pass
Definition: effect.c:186
d3dx_effect::ID3DXEffect_iface
ID3DXEffect ID3DXEffect_iface
Definition: effect.c:171
d3dx_effect::ref
LONG ref
Definition: effect.c:172
d3dx_effect::parameter_block_list
struct list parameter_block_list
Definition: effect.c:196
d3dx_effect::source
char * source
Definition: effect.c:199
d3dx_effect::skip_constants_string
char * skip_constants_string
Definition: effect.c:201
d3dx_effect::flags
DWORD flags
Definition: effect.c:178

Referenced by d3dx9_effect_init(), and d3dx_effect_CloneEffect().

◆ d3dx9_effect_version()

static DWORD d3dx9_effect_version ( DWORD  major,
DWORD  minor 
)
inlinestatic

Definition at line 1129 of file effect.c.

1130{
1131 return (0xfeff0000 | ((major) << 8) | (minor));
1132}
minor
#define minor(rdev)
Definition: propsheet.cpp:929
major
#define major(rdev)
Definition: propsheet.cpp:928

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 1134 of file effect.c.

1137{
1138 struct d3dx_parameter *param = &state->parameter;
1139
1140 *param_value = NULL;
1141 *out_param = NULL;
1142 *param_dirty = FALSE;
1143
1144 switch (state->type)
1145 {
1146 case ST_PARAMETER:
1147 param = state->referenced_param;
1148 *param_dirty = is_param_dirty(param, pass->update_version);
1149 /* fallthrough */
1150 case ST_CONSTANT:
1151 *out_param = param;
1152 *param_value = param->data;
1153 return D3D_OK;
1154 case ST_ARRAY_SELECTOR:
1155 {
1156 unsigned int array_idx;
1157 static const struct d3dx_parameter array_idx_param =
1158 {"", NULL, NULL, NULL, NULL, D3DXPC_SCALAR, D3DXPT_INT, 1, 1, 0, 0, 0, sizeof(array_idx)};
1159 HRESULT hr;
1160 struct d3dx_parameter *ref_param, *selected_param;
1161
1162 if (!param->param_eval)
1163 {
1164 FIXME("Preshader structure is null.\n");
1165 return D3DERR_INVALIDCALL;
1166 }
1167 /* We override with the update_version of the pass because we want
1168 * to force index recomputation and check for out of bounds. */
1169 if (is_param_eval_input_dirty(param->param_eval, pass->update_version))
1170 {
1171 if (FAILED(hr = d3dx_evaluate_parameter(param->param_eval, &array_idx_param, &array_idx)))
1172 return hr;
1173 }
1174 else
1175 {
1176 array_idx = state->index;
1177 }
1178 ref_param = state->referenced_param;
1179 TRACE("Array index %u, stored array index %u, element_count %u.\n", array_idx, state->index,
1180 ref_param->element_count);
1181 /* According to the tests, native d3dx handles the case of array index evaluated to -1
1182 * in a specific way, always selecting first array element and not returning error. */
1183 if (array_idx == ~0u)
1184 {
1185 WARN("Array index is -1, setting to 0.\n");
1186 array_idx = 0;
1187 }
1188
1189 if (array_idx >= ref_param->element_count)
1190 {
1191 WARN("Computed array index %u is larger than array size %u.\n",
1192 array_idx, ref_param->element_count);
1193 return E_FAIL;
1194 }
1195 selected_param = &ref_param->members[array_idx];
1196 *param_dirty = state->index != array_idx || is_param_dirty(selected_param, pass->update_version);
1197 state->index = array_idx;
1198
1199 *param_value = selected_param->data;
1200 *out_param = selected_param;
1201 return D3D_OK;
1202 }
1203 case ST_FXLC:
1204 if (param->param_eval)
1205 {
1206 *out_param = param;
1207 *param_value = param->data;
1208 /* We check with the update_version of the pass because the
1209 * same preshader might be used by both the vertex and the
1210 * pixel shader (that can happen e.g. for sampler states). */
1211 if (update_all || is_param_eval_input_dirty(param->param_eval, pass->update_version))
1212 {
1213 *param_dirty = TRUE;
1214 return d3dx_evaluate_parameter(param->param_eval, param, *param_value);
1215 }
1216 else
1217 return D3D_OK;
1218 }
1219 else
1220 {
1221 FIXME("No preshader for FXLC parameter.\n");
1222 return D3DERR_INVALIDCALL;
1223 }
1224 }
1225 return E_NOTIMPL;
1226}
is_param_dirty
static BOOL is_param_dirty(struct d3dx_parameter *param, ULONG64 update_version)
Definition: d3dx9_private.h:581
is_param_eval_input_dirty
BOOL is_param_eval_input_dirty(struct d3dx_param_eval *peval, ULONG64 update_version)
Definition: preshader.c:1716
d3dx_evaluate_parameter
HRESULT d3dx_evaluate_parameter(struct d3dx_param_eval *peval, const struct d3dx_parameter *param, void *param_value)
Definition: preshader.c:1722
E_NOTIMPL
#define E_NOTIMPL
Definition: ddrawi.h:99
D3DXPC_SCALAR
@ D3DXPC_SCALAR
Definition: d3dx9shader.h:62
d3dx_parameter::members
struct d3dx_parameter * members
Definition: d3dx9_private.h:528
d3dx_parameter::data
void * data
Definition: d3dx9_private.h:517
d3dx_parameter::element_count
unsigned int element_count
Definition: d3dx9_private.h:522

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 5301 of file effect.c.

5302{
5303 unsigned int size;
5304
5305 size = read_u32(&ptr);
5306 TRACE("Name size: %#x.\n", size);
5307
5308 if (!size)
5309 {
5310 return D3D_OK;
5311 }
5312
5313 *name = malloc(size);
5314 if (!*name)
5315 {
5316 ERR("Failed to allocate name memory.\n");
5317 return E_OUTOFMEMORY;
5318 }
5319
5320 TRACE("Name: %s.\n", debugstr_an(ptr, size));
5321 memcpy(*name, ptr, size);
5322
5323 return D3D_OK;
5324}
size
GLsizeiptr size
Definition: glext.h:5919
name
Definition: name.c:39

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 1357 of file effect.c.

1358{
1359 static const struct
1360 {
1361 unsigned int offset;
1362 const char *name;
1363 }
1364 light_tbl[] =
1365 {
1366 {FIELD_OFFSET(D3DLIGHT9, Type), "LC_TYPE"},
1367 {FIELD_OFFSET(D3DLIGHT9, Diffuse), "LT_DIFFUSE"},
1368 {FIELD_OFFSET(D3DLIGHT9, Specular), "LT_SPECULAR"},
1369 {FIELD_OFFSET(D3DLIGHT9, Ambient), "LT_AMBIENT"},
1370 {FIELD_OFFSET(D3DLIGHT9, Position), "LT_POSITION"},
1371 {FIELD_OFFSET(D3DLIGHT9, Direction), "LT_DIRECTION"},
1372 {FIELD_OFFSET(D3DLIGHT9, Range), "LT_RANGE"},
1373 {FIELD_OFFSET(D3DLIGHT9, Falloff), "LT_FALLOFF"},
1374 {FIELD_OFFSET(D3DLIGHT9, Attenuation0), "LT_ATTENUATION0"},
1375 {FIELD_OFFSET(D3DLIGHT9, Attenuation1), "LT_ATTENUATION1"},
1376 {FIELD_OFFSET(D3DLIGHT9, Attenuation2), "LT_ATTENUATION2"},
1377 {FIELD_OFFSET(D3DLIGHT9, Theta), "LT_THETA"},
1378 {FIELD_OFFSET(D3DLIGHT9, Phi), "LT_PHI"}
1379 };
1380 switch (op)
1381 {
1382 case LT_TYPE:
1383 TRACE("LT_TYPE %u.\n", *(D3DLIGHTTYPE *)value);
1384 light->Type = *(D3DLIGHTTYPE *)value;
1385 break;
1386 case LT_DIFFUSE:
1387 case LT_SPECULAR:
1388 case LT_AMBIENT:
1389 {
1390 D3DCOLORVALUE c = *(D3DCOLORVALUE *)value;
1391
1392 TRACE("%s (%.8e %.8e %.8e %.8e).\n", light_tbl[op].name, c.r, c.g, c.b, c.a);
1393 *(D3DCOLORVALUE *)((BYTE *)light + light_tbl[op].offset) = c;
1394 break;
1395 }
1396 case LT_POSITION:
1397 case LT_DIRECTION:
1398 {
1399 D3DVECTOR v = *(D3DVECTOR *)value;
1400
1401 TRACE("%s (%.8e %.8e %.8e).\n", light_tbl[op].name, v.x, v.y, v.z);
1402 *(D3DVECTOR *)((BYTE *)light + light_tbl[op].offset) = v;
1403 break;
1404 }
1405 case LT_RANGE:
1406 case LT_FALLOFF:
1407 case LT_ATTENUATION0:
1408 case LT_ATTENUATION1:
1409 case LT_ATTENUATION2:
1410 case LT_THETA:
1411 case LT_PHI:
1412 {
1413 float v = *(float *)value;
1414 TRACE("%s %.8e.\n", light_tbl[op].name, v);
1415 *(float *)((BYTE *)light + light_tbl[op].offset) = v;
1416 break;
1417 }
1418 default:
1419 WARN("Unknown light parameter %u.\n", op);
1420 break;
1421 }
1422}
Type
Type
Definition: Type.h:7
D3DLIGHTTYPE
D3DLIGHTTYPE
Definition: d3dtypes.h:554
op
UINT op
Definition: effect.c:235
v
const GLdouble * v
Definition: gl.h:2040
c
const GLubyte * c
Definition: glext.h:8905
light
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum light
Definition: glfuncs.h:170
_D3DLIGHT9
Definition: d3d9types.h:1408
_D3DVECTOR
Definition: d3d8types.h:1060
Position
static COORD Position
Definition: mouse.c:34
FIELD_OFFSET
#define FIELD_OFFSET(t, f)
Definition: typedefs.h:255
value
Definition: pdh_main.c:64
Direction
WDF_EXTERN_C_START typedef _In_ WDFDEVICE _In_ WDFCONTEXT _In_ WDF_DMA_DIRECTION Direction
Definition: wdfdmatransaction.h:68
BYTE
unsigned char BYTE
Definition: xxhash.c:193

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 1424 of file effect.c.

1425{
1426 static const struct
1427 {
1428 unsigned int offset;
1429 const char *name;
1430 }
1431 material_tbl[] =
1432 {
1433 {FIELD_OFFSET(D3DMATERIAL9, Diffuse), "MT_DIFFUSE"},
1434 {FIELD_OFFSET(D3DMATERIAL9, Ambient), "MT_AMBIENT"},
1435 {FIELD_OFFSET(D3DMATERIAL9, Specular), "MT_SPECULAR"},
1436 {FIELD_OFFSET(D3DMATERIAL9, Emissive), "MT_EMISSIVE"},
1437 {FIELD_OFFSET(D3DMATERIAL9, Power), "MT_POWER"}
1438 };
1439
1440 switch (op)
1441 {
1442 case MT_POWER:
1443 {
1444 float v = *(float *)value;
1445
1446 TRACE("%s %.8e.\n", material_tbl[op].name, v);
1447 material->Power = v;
1448 break;
1449 }
1450 case MT_DIFFUSE:
1451 case MT_AMBIENT:
1452 case MT_SPECULAR:
1453 case MT_EMISSIVE:
1454 {
1455 D3DCOLORVALUE c = *(D3DCOLORVALUE *)value;
1456
1457 TRACE("%s, value (%.8e %.8e %.8e %.8e).\n", material_tbl[op].name, c.r, c.g, c.b, c.a);
1458 *(D3DCOLORVALUE *)((BYTE *)material + material_tbl[op].offset) = c;
1459 break;
1460 }
1461 default:
1462 WARN("Unknown material parameter %u.\n", op);
1463 break;
1464 }
1465}
_D3DMATERIAL9
Definition: d3d9types.h:1440
_D3DMATERIAL9::Power
float Power
Definition: d3d9types.h:1445

Referenced by d3dx9_apply_state().

◆ d3dx_effect_AddRef()

static ULONG WINAPI d3dx_effect_AddRef ( ID3DXEffect *  iface)
static

Definition at line 1982 of file effect.c.

1983{
1984 struct d3dx_effect *effect = impl_from_ID3DXEffect(iface);
1985 ULONG refcount = InterlockedIncrement(&effect->ref);
1986
1987 TRACE("%p increasing refcount to %lu.\n", effect, refcount);
1988
1989 return refcount;
1990}
InterlockedIncrement
#define InterlockedIncrement
Definition: armddk.h:53
impl_from_ID3DXEffect
static struct d3dx_effect * impl_from_ID3DXEffect(ID3DXEffect *iface)
Definition: effect.c:1959
d3dx_effect
Definition: effect.c:170
ULONG
uint32_t ULONG
Definition: typedefs.h:59

◆ d3dx_effect_ApplyParameterBlock()

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

Definition at line 4265 of file effect.c.

4266{
4267 struct d3dx_parameter_block *block = get_valid_parameter_block(parameter_block);
4268 struct d3dx_recorded_parameter *record;
4269
4270 TRACE("iface %p, parameter_block %p.\n", iface, parameter_block);
4271
4272 if (!block || !block->offset)
4273 return D3DERR_INVALIDCALL;
4274
4275 record = (struct d3dx_recorded_parameter *)block->buffer;
4276 while ((BYTE *)record < block->buffer + block->offset)
4277 {
4278 set_value(record->param, record + 1, record->bytes,
4279 param_get_data_and_dirtify(block->effect, record->param, record->bytes, TRUE));
4280 record = (struct d3dx_recorded_parameter *)((BYTE *)record + get_recorded_parameter_size(record));
4281 }
4282 assert((BYTE *)record == block->buffer + block->offset);
4283 return D3D_OK;
4284}
while
while(CdLookupNextInitialFileDirent(IrpContext, Fcb, FileContext))
get_valid_parameter_block
static struct d3dx_parameter_block * get_valid_parameter_block(D3DXHANDLE handle)
Definition: effect.c:516
set_value
static HRESULT set_value(struct d3dx_parameter *param, const void *data, unsigned int bytes, void *dst_data)
Definition: effect.c:904
get_recorded_parameter_size
static unsigned int get_recorded_parameter_size(const struct d3dx_recorded_parameter *record)
Definition: effect.c:711
param_get_data_and_dirtify
static void * param_get_data_and_dirtify(struct d3dx_effect *effect, struct d3dx_parameter *param, unsigned int bytes, BOOL value_changed)
Definition: effect.c:1346
assert
#define assert(_expr)
Definition: assert.h:32
d3dx_parameter_block
Definition: effect.c:154
d3dx_recorded_parameter
Definition: effect.c:164
block
static unsigned int block
Definition: xmlmemory.c:101

◆ d3dx_effect_Begin()

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

Definition at line 3953 of file effect.c.

3954{
3955 struct d3dx_effect *effect = impl_from_ID3DXEffect(iface);
3956 struct d3dx_technique *technique = effect->active_technique;
3957
3958 TRACE("iface %p, passes %p, flags %#lx.\n", iface, passes, flags);
3959
3960 if (technique)
3961 {
3962 if (flags & ~(D3DXFX_DONOTSAVESTATE | D3DXFX_DONOTSAVESAMPLERSTATE | D3DXFX_DONOTSAVESHADERSTATE))
3963 WARN("Invalid flags %#lx specified.\n", flags);
3964
3965 if (flags & D3DXFX_DONOTSAVESTATE)
3966 {
3967 TRACE("State capturing disabled.\n");
3968 }
3969 else
3970 {
3971 HRESULT hr;
3972 unsigned int i;
3973
3974 if (!technique->saved_state)
3975 {
3976 ID3DXEffectStateManager *manager;
3977
3978 manager = effect->manager;
3979 effect->manager = NULL;
3980 if (FAILED(hr = IDirect3DDevice9_BeginStateBlock(effect->device)))
3981 ERR("BeginStateBlock failed, hr %#lx.\n", hr);
3982 for (i = 0; i < technique->pass_count; i++)
3983 d3dx9_apply_pass_states(effect, &technique->passes[i], TRUE);
3984 if (FAILED(hr = IDirect3DDevice9_EndStateBlock(effect->device, &technique->saved_state)))
3985 ERR("EndStateBlock failed, hr %#lx.\n", hr);
3986 effect->manager = manager;
3987 }
3988 if (FAILED(hr = IDirect3DStateBlock9_Capture(technique->saved_state)))
3989 ERR("StateBlock Capture failed, hr %#lx.\n", hr);
3990 }
3991
3992 if (passes)
3993 *passes = technique->pass_count;
3994 effect->started = TRUE;
3995 effect->begin_flags = flags;
3996
3997 return D3D_OK;
3998 }
3999
4000 WARN("Invalid argument supplied.\n");
4001
4002 return D3DERR_INVALIDCALL;
4003}
IDirect3DDevice9_EndStateBlock
#define IDirect3DDevice9_EndStateBlock(p, a)
Definition: d3d9.h:1396
IDirect3DDevice9_BeginStateBlock
#define IDirect3DDevice9_BeginStateBlock(p)
Definition: d3d9.h:1395
IDirect3DStateBlock9_Capture
#define IDirect3DStateBlock9_Capture(p)
Definition: d3d9.h:1131
d3dx9_apply_pass_states
static HRESULT d3dx9_apply_pass_states(struct d3dx_effect *effect, struct d3dx_pass *pass, BOOL update_all)
Definition: effect.c:1745
D3DXFX_DONOTSAVESTATE
#define D3DXFX_DONOTSAVESTATE
Definition: d3dx9effect.h:24
D3DXFX_DONOTSAVESAMPLERSTATE
#define D3DXFX_DONOTSAVESAMPLERSTATE
Definition: d3dx9effect.h:26
D3DXFX_DONOTSAVESHADERSTATE
#define D3DXFX_DONOTSAVESHADERSTATE
Definition: d3dx9effect.h:25
d3dx_effect::manager
struct ID3DXEffectStateManager * manager
Definition: effect.c:182
d3dx_effect::begin_flags
DWORD begin_flags
Definition: effect.c:188
d3dx_effect::started
BOOL started
Definition: effect.c:187
d3dx_technique
Definition: effect.c:142
d3dx_technique::passes
struct d3dx_pass * passes
Definition: effect.c:148
d3dx_technique::pass_count
unsigned int pass_count
Definition: effect.c:144
d3dx_technique::saved_state
struct IDirect3DStateBlock9 * saved_state
Definition: effect.c:150

◆ d3dx_effect_BeginParameterBlock()

static HRESULT WINAPI d3dx_effect_BeginParameterBlock ( ID3DXEffect *  iface)
static

Definition at line 4220 of file effect.c.

4221{
4222 struct d3dx_effect *effect = impl_from_ID3DXEffect(iface);
4223
4224 TRACE("iface %p.\n", iface);
4225
4226 if (effect->current_parameter_block)
4227 {
4228 WARN("Parameter block is already started.\n");
4229 return D3DERR_INVALIDCALL;
4230 }
4231
4232 effect->current_parameter_block = calloc(1, sizeof(*effect->current_parameter_block));
4233 memcpy(effect->current_parameter_block->magic_string, parameter_block_magic_string,
4234 sizeof(parameter_block_magic_string));
4235 effect->current_parameter_block->effect = effect;
4236
4237 return D3D_OK;
4238}
parameter_block_magic_string
static const char parameter_block_magic_string[4]
Definition: effect.c:34
calloc
#define calloc
Definition: rosglue.h:14
d3dx_effect::current_parameter_block
struct d3dx_parameter_block * current_parameter_block
Definition: effect.c:197

◆ d3dx_effect_BeginPass()

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

Definition at line 4005 of file effect.c.

4006{
4007 struct d3dx_effect *effect = impl_from_ID3DXEffect(iface);
4008 struct d3dx_technique *technique = effect->active_technique;
4009
4010 TRACE("iface %p, pass %u\n", effect, pass);
4011
4012 if (!effect->started)
4013 {
4014 WARN("Effect is not started, returning D3DERR_INVALIDCALL.\n");
4015 return D3DERR_INVALIDCALL;
4016 }
4017
4018 if (technique && pass < technique->pass_count && !effect->active_pass)
4019 {
4020 HRESULT hr;
4021
4022 memset(effect->current_light, 0, sizeof(effect->current_light));
4023 memset(&effect->current_material, 0, sizeof(effect->current_material));
4024
4025 if (SUCCEEDED(hr = d3dx9_apply_pass_states(effect, &technique->passes[pass], TRUE)))
4026 effect->active_pass = &technique->passes[pass];
4027 return hr;
4028 }
4029
4030 WARN("Invalid argument supplied.\n");
4031
4032 return D3DERR_INVALIDCALL;
4033}
SUCCEEDED
#define SUCCEEDED(hr)
Definition: intsafe.h:50
memset
#define memset(x, y, z)
Definition: compat.h:39

◆ d3dx_effect_cleanup()

static void d3dx_effect_cleanup ( struct d3dx_effect *  effect)
static

Definition at line 769 of file effect.c.

770{
771 struct d3dx_parameter_block *block, *cursor;
772 ID3DXEffectPool *pool;
773 unsigned int i;
774
775 TRACE("effect %p.\n", effect);
776
777 free_parameter_block(effect->current_parameter_block);
778 LIST_FOR_EACH_ENTRY_SAFE(block, cursor, &effect->parameter_block_list, struct d3dx_parameter_block, entry)
779 {
780 list_remove(&block->entry);
781 free_parameter_block(block);
782 }
783
784 d3dx_parameters_store_cleanup(&effect->params);
785
786 if (effect->techniques)
787 {
788 for (i = 0; i < effect->technique_count; ++i)
789 free_technique(&effect->techniques[i]);
790 free(effect->techniques);
791 }
792
793 if (effect->objects)
794 {
795 for (i = 0; i < effect->object_count; ++i)
796 free_object(&effect->objects[i]);
797 free(effect->objects);
798 }
799
800 if (effect->pool)
801 {
802 pool = &effect->pool->ID3DXEffectPool_iface;
803 pool->lpVtbl->Release(pool);
804 }
805
806 if (effect->manager)
807 IUnknown_Release(effect->manager);
808
809 IDirect3DDevice9_Release(effect->device);
810 free(effect);
811}
list_remove
static void list_remove(struct list_entry *entry)
Definition: list.h:90
free_parameter_block
static void free_parameter_block(struct d3dx_parameter_block *block)
Definition: effect.c:716
d3dx_parameters_store_cleanup
void d3dx_parameters_store_cleanup(struct d3dx_parameters_store *store)
Definition: effect.c:754
cursor
const char cursor[]
Definition: icontest.c:13
entry
uint32_t entry
Definition: isohybrid.c:63
LIST_FOR_EACH_ENTRY_SAFE
#define LIST_FOR_EACH_ENTRY_SAFE(cursor, cursor2, list, type, field)
Definition: list.h:242
d3dx_parameter_block::effect
struct d3dx_effect * effect
Definition: effect.c:156

Referenced by d3dx_effect_Release().

◆ d3dx_effect_CloneEffect()

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

Definition at line 4369 of file effect.c.

4370{
4371 struct d3dx_effect *src = impl_from_ID3DXEffect(iface);
4372 struct d3dx_effect *dst;
4373 unsigned int i, j, k;
4374 HRESULT hr;
4375
4376 TRACE("iface %p, device %p, out %p.\n", iface, device, out);
4377
4378 if (!out)
4379 return D3DERR_INVALIDCALL;
4380
4381 if (src->flags & D3DXFX_NOT_CLONEABLE)
4382 return E_FAIL;
4383
4384 if (!device)
4385 return D3DERR_INVALIDCALL;
4386
4387 if (!(dst = calloc(1, sizeof(*dst))))
4388 return E_OUTOFMEMORY;
4389
4390 if (FAILED(hr = d3dx9_effect_init_from_binary(dst, device, src->source, src->source_size,
4391 src->flags, &src->pool->ID3DXEffectPool_iface, src->skip_constants_string)))
4392 {
4393 free(dst);
4394 return hr;
4395 }
4396
4397 for (i = 0; i < src->params.count; ++i)
4398 {
4399 const struct d3dx_top_level_parameter *src_param = &src->params.parameters[i];
4400 struct d3dx_top_level_parameter *dst_param = &dst->params.parameters[i];
4401
4402 copy_parameter(dst, src, &dst_param->param, &src_param->param);
4403 for (j = 0; j < src_param->annotation_count; ++j)
4404 copy_parameter(dst, src, &dst_param->annotations[j], &src_param->annotations[j]);
4405 }
4406
4407 for (i = 0; i < src->technique_count; ++i)
4408 {
4409 const struct d3dx_technique *src_technique = &src->techniques[i];
4410 struct d3dx_technique *dst_technique = &dst->techniques[i];
4411
4412 for (j = 0; j < src_technique->annotation_count; ++j)
4413 copy_parameter(dst, src, &dst_technique->annotations[j], &src_technique->annotations[j]);
4414
4415 for (j = 0; j < src_technique->pass_count; ++j)
4416 {
4417 const struct d3dx_pass *src_pass = &src_technique->passes[j];
4418 struct d3dx_pass *dst_pass = &dst_technique->passes[j];
4419
4420 for (k = 0; k < src_pass->annotation_count; ++k)
4421 copy_parameter(dst, src, &dst_pass->annotations[k], &src_pass->annotations[k]);
4422 }
4423 }
4424
4425 *out = &dst->ID3DXEffect_iface;
4426 TRACE("Created effect %p.\n", dst);
4427 return D3D_OK;
4428}
copy_parameter
static bool copy_parameter(struct d3dx_effect *dst_effect, const struct d3dx_effect *src_effect, struct d3dx_parameter *dst, const struct d3dx_parameter *src)
Definition: effect.c:4313
k
int k
Definition: mpi.c:3369
d3dx_pass
Definition: effect.c:130
d3dx_pass::annotations
struct d3dx_parameter * annotations
Definition: effect.c:136
d3dx_pass::annotation_count
unsigned int annotation_count
Definition: effect.c:133
d3dx_technique::annotations
struct d3dx_parameter * annotations
Definition: effect.c:147
d3dx_technique::annotation_count
unsigned int annotation_count
Definition: effect.c:145
d3dx_top_level_parameter
Definition: d3dx9_private.h:536
d3dx_top_level_parameter::annotation_count
unsigned int annotation_count
Definition: d3dx9_private.h:538
d3dx_top_level_parameter::annotations
struct d3dx_parameter * annotations
Definition: d3dx9_private.h:539
d3dx_top_level_parameter::param
struct d3dx_parameter param
Definition: d3dx9_private.h:537
out
wchar_t tm const _CrtWcstime_Writes_and_advances_ptr_ count wchar_t ** out
Definition: wcsftime.cpp:383

◆ d3dx_effect_CommitChanges()

static HRESULT WINAPI d3dx_effect_CommitChanges ( ID3DXEffect *  iface)
static

Definition at line 4035 of file effect.c.

4036{
4037 struct d3dx_effect *effect = impl_from_ID3DXEffect(iface);
4038
4039 TRACE("iface %p.\n", iface);
4040
4041 if (!effect->active_pass)
4042 {
4043 WARN("Called without an active pass.\n");
4044 return D3D_OK;
4045 }
4046 return d3dx9_apply_pass_states(effect, effect->active_pass, FALSE);
4047}

◆ d3dx_effect_End()

static HRESULT WINAPI d3dx_effect_End ( ID3DXEffect *  iface)
static

Definition at line 4066 of file effect.c.

4067{
4068 struct d3dx_effect *effect = impl_from_ID3DXEffect(iface);
4069 struct d3dx_technique *technique = effect->active_technique;
4070
4071 TRACE("iface %p.\n", iface);
4072
4073 if (!effect->started)
4074 return D3D_OK;
4075
4076 if (effect->begin_flags & D3DXFX_DONOTSAVESTATE)
4077 {
4078 TRACE("State restoring disabled.\n");
4079 }
4080 else
4081 {
4082 HRESULT hr;
4083
4084 if (technique && technique->saved_state)
4085 {
4086 if (FAILED(hr = IDirect3DStateBlock9_Apply(technique->saved_state)))
4087 ERR("State block apply failed, hr %#lx.\n", hr);
4088 }
4089 else
4090 ERR("No saved state.\n");
4091 }
4092
4093 effect->started = FALSE;
4094
4095 return D3D_OK;
4096}
IDirect3DStateBlock9_Apply
#define IDirect3DStateBlock9_Apply(p)
Definition: d3d9.h:1132

◆ d3dx_effect_EndParameterBlock()

static D3DXHANDLE WINAPI d3dx_effect_EndParameterBlock ( ID3DXEffect *  iface)
static

Definition at line 4240 of file effect.c.

4241{
4242 struct d3dx_effect *effect = impl_from_ID3DXEffect(iface);
4243 struct d3dx_parameter_block *ret;
4244 BYTE *new_buffer;
4245
4246 TRACE("iface %p.\n", iface);
4247
4248 if (!effect->current_parameter_block)
4249 {
4250 WARN("No active parameter block.\n");
4251 return NULL;
4252 }
4253 ret = effect->current_parameter_block;
4254
4255 new_buffer = realloc(ret->buffer, ret->offset);
4256 if (new_buffer)
4257 ret->buffer = new_buffer;
4258 ret->size = ret->offset;
4259
4260 effect->current_parameter_block = NULL;
4261 list_add_tail(&effect->parameter_block_list, &ret->entry);
4262 return (D3DXHANDLE)ret;
4263}
list_add_tail
static void list_add_tail(struct list_entry *head, struct list_entry *entry)
Definition: list.h:83
realloc
#define realloc
Definition: debug_ros.c:6
D3DXHANDLE
const char * D3DXHANDLE
Definition: d3dx9shader.h:48

◆ d3dx_effect_EndPass()

static HRESULT WINAPI d3dx_effect_EndPass ( ID3DXEffect *  iface)
static

Definition at line 4049 of file effect.c.

4050{
4051 struct d3dx_effect *This = impl_from_ID3DXEffect(iface);
4052
4053 TRACE("iface %p\n", This);
4054
4055 if (This->active_pass)
4056 {
4057 This->active_pass = NULL;
4058 return D3D_OK;
4059 }
4060
4061 WARN("Invalid call.\n");
4062
4063 return D3DERR_INVALIDCALL;
4064}

◆ d3dx_effect_FindNextValidTechnique()

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

Definition at line 3788 of file effect.c.

3790{
3791 struct d3dx_effect *effect = impl_from_ID3DXEffect(iface);
3792 struct d3dx_technique *prev_tech, *tech;
3793 unsigned int i;
3794
3795 TRACE("iface %p, technique %p, next_technique %p.\n", iface, technique, next_technique);
3796
3797 if (technique)
3798 {
3799 if (!(prev_tech = get_valid_technique(effect, technique)))
3800 return D3DERR_INVALIDCALL;
3801
3802 for (i = 0; i < effect->technique_count; ++i)
3803 {
3804 tech = &effect->techniques[i];
3805 if (tech == prev_tech)
3806 {
3807 ++i;
3808 break;
3809 }
3810 }
3811 }
3812 else
3813 {
3814 i = 0;
3815 }
3816
3817 for (; i < effect->technique_count; ++i)
3818 {
3819 tech = &effect->techniques[i];
3820 if (SUCCEEDED(d3dx_effect_ValidateTechnique(iface, get_technique_handle(tech))))
3821 {
3822 *next_technique = get_technique_handle(tech);
3823 return D3D_OK;
3824 }
3825 }
3826
3827 *next_technique = NULL;
3828 return S_FALSE;
3829}
get_technique_handle
static D3DXHANDLE get_technique_handle(struct d3dx_technique *technique)
Definition: effect.c:449
get_valid_technique
static struct d3dx_technique * get_valid_technique(struct d3dx_effect *effect, D3DXHANDLE technique)
Definition: effect.c:474
d3dx_effect_ValidateTechnique
static HRESULT WINAPI d3dx_effect_ValidateTechnique(ID3DXEffect *iface, D3DXHANDLE technique)
Definition: effect.c:3741
S_FALSE
#define S_FALSE
Definition: winerror.h:3451

◆ d3dx_effect_GetAnnotation()

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

Definition at line 2374 of file effect.c.

2375{
2376 struct d3dx_effect *effect = impl_from_ID3DXEffect(iface);
2377 struct d3dx_parameter *annotations = NULL;
2378 unsigned int annotation_count;
2379
2380 TRACE("iface %p, object %p, index %u.\n", iface, object, index);
2381
2382 annotation_count = get_annotation_from_object(effect, object, &annotations);
2383
2384 if (index < annotation_count)
2385 {
2386 TRACE("Returning parameter %p\n", &annotations[index]);
2387 return get_parameter_handle(&annotations[index]);
2388 }
2389
2390 WARN("Annotation not found.\n");
2391
2392 return NULL;
2393}
get_annotation_from_object
static unsigned int get_annotation_from_object(struct d3dx_effect *effect, D3DXHANDLE object, struct d3dx_parameter **annotations)
Definition: effect.c:1228
get_parameter_handle
static D3DXHANDLE get_parameter_handle(struct d3dx_parameter *parameter)
Definition: effect.c:444
index
GLuint index
Definition: glext.h:6031

◆ d3dx_effect_GetAnnotationByName()

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

Definition at line 2395 of file effect.c.

2397{
2398 struct d3dx_effect *effect = impl_from_ID3DXEffect(iface);
2399 struct d3dx_parameter *annotation = NULL;
2400 struct d3dx_parameter *annotations = NULL;
2401 unsigned int annotation_count;
2402
2403 TRACE("iface %p, object %p, name %s.\n", iface, object, debugstr_a(name));
2404
2405 if (!name)
2406 {
2407 WARN("Invalid argument specified\n");
2408 return NULL;
2409 }
2410
2411 annotation_count = get_annotation_from_object(effect, object, &annotations);
2412
2413 annotation = get_annotation_by_name(effect, annotation_count, annotations, name);
2414 if (annotation)
2415 {
2416 TRACE("Returning parameter %p\n", annotation);
2417 return get_parameter_handle(annotation);
2418 }
2419
2420 WARN("Annotation not found.\n");
2421
2422 return NULL;
2423}
annotation
#define annotation(x)
Definition: dispex.idl:19
get_annotation_by_name
static struct d3dx_parameter * get_annotation_by_name(struct d3dx_effect *effect, unsigned int count, struct d3dx_parameter *annotations, const char *name)
Definition: effect.c:997

◆ d3dx_effect_GetBool()

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

Definition at line 2536 of file effect.c.

2537{
2538 struct d3dx_effect *effect = impl_from_ID3DXEffect(iface);
2539 struct d3dx_parameter *param = get_valid_parameter(effect, parameter);
2540
2541 TRACE("iface %p, parameter %p, b %p.\n", iface, parameter, b);
2542
2543 if (b && param && !param->element_count && param->rows == 1 && param->columns == 1)
2544 {
2545 set_number(b, D3DXPT_BOOL, param->data, param->type);
2546 TRACE("Returning %s\n", *b ? "TRUE" : "FALSE");
2547 return D3D_OK;
2548 }
2549
2550 WARN("Parameter not found.\n");
2551
2552 return D3DERR_INVALIDCALL;
2553}
set_number
static void set_number(void *outdata, D3DXPARAMETER_TYPE outtype, const void *indata, D3DXPARAMETER_TYPE intype)
Definition: d3dx9_private.h:392
get_valid_parameter
static struct d3dx_parameter * get_valid_parameter(struct d3dx_effect *effect, D3DXHANDLE parameter)
Definition: effect.c:505
b
GLboolean GLboolean GLboolean b
Definition: glext.h:6204

◆ d3dx_effect_GetBoolArray()

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

Definition at line 2597 of file effect.c.

2598{
2599 struct d3dx_effect *effect = impl_from_ID3DXEffect(iface);
2600 struct d3dx_parameter *param = get_valid_parameter(effect, parameter);
2601
2602 TRACE("iface %p, parameter %p, b %p, count %u.\n", iface, parameter, b, count);
2603
2604 if (b && param && (param->class == D3DXPC_SCALAR
2605 || param->class == D3DXPC_VECTOR
2606 || param->class == D3DXPC_MATRIX_ROWS
2607 || param->class == D3DXPC_MATRIX_COLUMNS))
2608 {
2609 unsigned int i, size = min(count, param->bytes / sizeof(DWORD));
2610
2611 for (i = 0; i < size; ++i)
2612 {
2613 set_number(&b[i], D3DXPT_BOOL, (DWORD *)param->data + i, param->type);
2614 }
2615 return D3D_OK;
2616 }
2617
2618 WARN("Parameter not found.\n");
2619
2620 return D3DERR_INVALIDCALL;
2621}
D3DXPC_MATRIX_COLUMNS
@ D3DXPC_MATRIX_COLUMNS
Definition: d3dx9shader.h:65
D3DXPC_MATRIX_ROWS
@ D3DXPC_MATRIX_ROWS
Definition: d3dx9shader.h:64
D3DXPC_VECTOR
@ D3DXPC_VECTOR
Definition: d3dx9shader.h:63
count
GLuint GLuint GLsizei count
Definition: gl.h:1545
min
#define min(a, b)
Definition: monoChain.cc:55

◆ d3dx_effect_GetCurrentTechnique()

static D3DXHANDLE WINAPI d3dx_effect_GetCurrentTechnique ( ID3DXEffect *  iface)
static

Definition at line 3732 of file effect.c.

3733{
3734 struct d3dx_effect *This = impl_from_ID3DXEffect(iface);
3735
3736 TRACE("iface %p\n", This);
3737
3738 return get_technique_handle(This->active_technique);
3739}

◆ d3dx_effect_GetDesc()

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

Definition at line 2006 of file effect.c.

2007{
2008 struct d3dx_effect *effect = impl_from_ID3DXEffect(iface);
2009
2010 TRACE("iface %p, desc %p.\n", iface, desc);
2011
2012 if (!desc)
2013 {
2014 WARN("Invalid argument specified.\n");
2015 return D3DERR_INVALIDCALL;
2016 }
2017
2018 desc->Creator = "D3DX Effect Compiler";
2019 desc->Functions = 0;
2020 desc->Parameters = effect->params.count;
2021 desc->Techniques = effect->technique_count;
2022
2023 return D3D_OK;
2024}
desc
D3D11_SHADER_VARIABLE_DESC desc
Definition: reflection.c:1683

◆ d3dx_effect_GetDevice()

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

Definition at line 4098 of file effect.c.

4099{
4100 struct d3dx_effect *This = impl_from_ID3DXEffect(iface);
4101
4102 TRACE("iface %p, device %p\n", This, device);
4103
4104 if (!device)
4105 {
4106 WARN("Invalid argument supplied.\n");
4107 return D3DERR_INVALIDCALL;
4108 }
4109
4110 IDirect3DDevice9_AddRef(This->device);
4111
4112 *device = This->device;
4113
4114 TRACE("Returning device %p\n", *device);
4115
4116 return S_OK;
4117}
S_OK
#define S_OK
Definition: intsafe.h:52

◆ d3dx_effect_GetFloat()

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

Definition at line 2792 of file effect.c.

2793{
2794 struct d3dx_effect *effect = impl_from_ID3DXEffect(iface);
2795 struct d3dx_parameter *param = get_valid_parameter(effect, parameter);
2796
2797 TRACE("iface %p, parameter %p, f %p.\n", iface, parameter, f);
2798
2799 if (f && param && !param->element_count && param->columns == 1 && param->rows == 1)
2800 {
2801 set_number(f, D3DXPT_FLOAT, (DWORD *)param->data, param->type);
2802 TRACE("Returning %f.\n", *f);
2803 return D3D_OK;
2804 }
2805
2806 WARN("Parameter not found.\n");
2807
2808 return D3DERR_INVALIDCALL;
2809}
f
GLfloat f
Definition: glext.h:7540

◆ d3dx_effect_GetFloatArray()

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

Definition at line 2851 of file effect.c.

2852{
2853 struct d3dx_effect *effect = impl_from_ID3DXEffect(iface);
2854 struct d3dx_parameter *param = get_valid_parameter(effect, parameter);
2855
2856 TRACE("iface %p, parameter %p, f %p, count %u.\n", iface, parameter, f, count);
2857
2858 if (f && param && (param->class == D3DXPC_SCALAR
2859 || param->class == D3DXPC_VECTOR
2860 || param->class == D3DXPC_MATRIX_ROWS
2861 || param->class == D3DXPC_MATRIX_COLUMNS))
2862 {
2863 unsigned int i, size = min(count, param->bytes / sizeof(DWORD));
2864
2865 for (i = 0; i < size; ++i)
2866 set_number(&f[i], D3DXPT_FLOAT, (DWORD *)param->data + i, param->type);
2867 return D3D_OK;
2868 }
2869
2870 WARN("Parameter not found.\n");
2871
2872 return D3DERR_INVALIDCALL;
2873}

◆ d3dx_effect_GetFunction()

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

Definition at line 2360 of file effect.c.

2361{
2362 FIXME("iface %p, index %u stub.\n", iface, index);
2363
2364 return NULL;
2365}

◆ d3dx_effect_GetFunctionByName()

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

Definition at line 2367 of file effect.c.

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

◆ d3dx_effect_GetFunctionDesc()

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

Definition at line 2128 of file effect.c.

2130{
2131 FIXME("iface %p, shader %p, desc %p stub.\n", iface, shader, desc);
2132
2133 return E_NOTIMPL;
2134}
shader
GLuint shader
Definition: glext.h:6030

◆ d3dx_effect_GetInt()

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

Definition at line 2669 of file effect.c.

2670{
2671 struct d3dx_effect *effect = impl_from_ID3DXEffect(iface);
2672 struct d3dx_parameter *param = get_valid_parameter(effect, parameter);
2673
2674 TRACE("iface %p, parameter %p, n %p.\n", iface, parameter, n);
2675
2676 if (n && param && !param->element_count)
2677 {
2678 if (param->columns == 1 && param->rows == 1)
2679 {
2680 set_number(n, D3DXPT_INT, param->data, param->type);
2681 TRACE("Returning %d.\n", *n);
2682 return D3D_OK;
2683 }
2684
2685 if (param->type == D3DXPT_FLOAT &&
2686 ((param->class == D3DXPC_VECTOR && param->columns != 2)
2687 || (param->class == D3DXPC_MATRIX_ROWS && param->rows != 2 && param->columns == 1)))
2688 {
2689 TRACE("Vector fixup.\n");
2690
2691 *n = min(max(0.0f, *((float *)param->data + 2)), 1.0f) * INT_FLOAT_MULTI;
2692 *n += ((int)(min(max(0.0f, *((float *)param->data + 1)), 1.0f) * INT_FLOAT_MULTI)) << 8;
2693 *n += ((int)(min(max(0.0f, *((float *)param->data + 0)), 1.0f) * INT_FLOAT_MULTI)) << 16;
2694 if (param->columns * param->rows > 3)
2695 *n += ((int)(min(max(0.0f, *((float *)param->data + 3)), 1.0f) * INT_FLOAT_MULTI)) << 24;
2696
2697 TRACE("Returning %d.\n", *n);
2698 return D3D_OK;
2699 }
2700 }
2701
2702 WARN("Parameter not found.\n");
2703
2704 return D3DERR_INVALIDCALL;
2705}
INT_FLOAT_MULTI
#define INT_FLOAT_MULTI
Definition: effect.c:30
int
unsigned int(__cdecl typeof(jpeg_read_scanlines))(struct jpeg_decompress_struct *
Definition: typeof.h:31
n
GLdouble n
Definition: glext.h:7729
max
#define max(a, b)
Definition: svc.c:63

◆ d3dx_effect_GetIntArray()

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

Definition at line 2746 of file effect.c.

2747{
2748 struct d3dx_effect *effect = impl_from_ID3DXEffect(iface);
2749 struct d3dx_parameter *param = get_valid_parameter(effect, parameter);
2750
2751 TRACE("iface %p, parameter %p, n %p, count %u.\n", iface, parameter, n, count);
2752
2753 if (n && param && (param->class == D3DXPC_SCALAR
2754 || param->class == D3DXPC_VECTOR
2755 || param->class == D3DXPC_MATRIX_ROWS
2756 || param->class == D3DXPC_MATRIX_COLUMNS))
2757 {
2758 unsigned int i, size = min(count, param->bytes / sizeof(DWORD));
2759
2760 for (i = 0; i < size; ++i)
2761 set_number(&n[i], D3DXPT_INT, (DWORD *)param->data + i, param->type);
2762 return D3D_OK;
2763 }
2764
2765 WARN("Parameter not found.\n");
2766
2767 return D3DERR_INVALIDCALL;
2768}

◆ d3dx_effect_GetMatrix()

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

Definition at line 3105 of file effect.c.

3106{
3107 struct d3dx_effect *effect = impl_from_ID3DXEffect(iface);
3108 struct d3dx_parameter *param = get_valid_parameter(effect, parameter);
3109
3110 TRACE("iface %p, parameter %p, matrix %p.\n", iface, parameter, matrix);
3111
3112 if (matrix && param && !param->element_count)
3113 {
3114 TRACE("Class %s.\n", debug_d3dxparameter_class(param->class));
3115
3116 switch (param->class)
3117 {
3118 case D3DXPC_MATRIX_ROWS:
3119 get_matrix(param, matrix, FALSE);
3120 return D3D_OK;
3121
3122 case D3DXPC_SCALAR:
3123 case D3DXPC_VECTOR:
3124 case D3DXPC_OBJECT:
3125 case D3DXPC_STRUCT:
3126 break;
3127
3128 default:
3129 FIXME("Unhandled class %s.\n", debug_d3dxparameter_class(param->class));
3130 break;
3131 }
3132 }
3133
3134 WARN("Parameter not found.\n");
3135
3136 return D3DERR_INVALIDCALL;
3137}
debug_d3dxparameter_class
const char * debug_d3dxparameter_class(D3DXPARAMETER_CLASS c)
Definition: util.c:328
get_matrix
static void get_matrix(struct d3dx_parameter *param, D3DXMATRIX *matrix, BOOL transpose)
Definition: effect.c:834
D3DXPC_STRUCT
@ D3DXPC_STRUCT
Definition: d3dx9shader.h:67
D3DXPC_OBJECT
@ D3DXPC_OBJECT
Definition: d3dx9shader.h:66
matrix
GLuint GLenum matrix
Definition: glext.h:9407

◆ d3dx_effect_GetMatrixArray()

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

Definition at line 3183 of file effect.c.

3185{
3186 struct d3dx_effect *effect = impl_from_ID3DXEffect(iface);
3187 struct d3dx_parameter *param = get_valid_parameter(effect, parameter);
3188
3189 TRACE("iface %p, parameter %p, matrix %p, count %u.\n", iface, parameter, matrix, count);
3190
3191 if (!count)
3192 return D3D_OK;
3193
3194 if (matrix && param && count <= param->element_count)
3195 {
3196 unsigned int i;
3197
3198 TRACE("Class %s.\n", debug_d3dxparameter_class(param->class));
3199
3200 switch (param->class)
3201 {
3202 case D3DXPC_MATRIX_ROWS:
3203 for (i = 0; i < count; ++i)
3204 get_matrix(&param->members[i], &matrix[i], FALSE);
3205 return D3D_OK;
3206
3207 case D3DXPC_SCALAR:
3208 case D3DXPC_VECTOR:
3209 case D3DXPC_OBJECT:
3210 case D3DXPC_STRUCT:
3211 break;
3212
3213 default:
3214 FIXME("Unhandled class %s.\n", debug_d3dxparameter_class(param->class));
3215 break;
3216 }
3217 }
3218
3219 WARN("Parameter not found.\n");
3220
3221 return D3DERR_INVALIDCALL;
3222}
element_count
static ULONG ** element_count
Definition: exception.c:124

◆ d3dx_effect_GetMatrixPointerArray()

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

Definition at line 3265 of file effect.c.

3267{
3268 struct d3dx_effect *effect = impl_from_ID3DXEffect(iface);
3269 struct d3dx_parameter *param = get_valid_parameter(effect, parameter);
3270
3271 TRACE("iface %p, parameter %p, matrix %p, count %u.\n", iface, parameter, matrix, count);
3272
3273 if (!count)
3274 return D3D_OK;
3275
3276 if (param && matrix && count <= param->element_count)
3277 {
3278 unsigned int i;
3279
3280 TRACE("Class %s.\n", debug_d3dxparameter_class(param->class));
3281
3282 switch (param->class)
3283 {
3284 case D3DXPC_MATRIX_ROWS:
3285 for (i = 0; i < count; ++i)
3286 get_matrix(&param->members[i], matrix[i], FALSE);
3287 return D3D_OK;
3288
3289 case D3DXPC_SCALAR:
3290 case D3DXPC_VECTOR:
3291 case D3DXPC_OBJECT:
3292 break;
3293
3294 default:
3295 FIXME("Unhandled class %s.\n", debug_d3dxparameter_class(param->class));
3296 break;
3297 }
3298 }
3299
3300 WARN("Parameter not found.\n");
3301
3302 return D3DERR_INVALIDCALL;
3303}

◆ d3dx_effect_GetMatrixTranspose()

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

Definition at line 3341 of file effect.c.

3343{
3344 struct d3dx_effect *effect = impl_from_ID3DXEffect(iface);
3345 struct d3dx_parameter *param = get_valid_parameter(effect, parameter);
3346
3347 TRACE("iface %p, parameter %p, matrix %p.\n", iface, parameter, matrix);
3348
3349 if (matrix && param && !param->element_count)
3350 {
3351 TRACE("Class %s.\n", debug_d3dxparameter_class(param->class));
3352
3353 switch (param->class)
3354 {
3355 case D3DXPC_SCALAR:
3356 case D3DXPC_VECTOR:
3357 get_matrix(param, matrix, FALSE);
3358 return D3D_OK;
3359
3360 case D3DXPC_MATRIX_ROWS:
3361 get_matrix(param, matrix, TRUE);
3362 return D3D_OK;
3363
3364 case D3DXPC_OBJECT:
3365 case D3DXPC_STRUCT:
3366 break;
3367
3368 default:
3369 FIXME("Unhandled class %s.\n", debug_d3dxparameter_class(param->class));
3370 break;
3371 }
3372 }
3373
3374 WARN("Parameter not found.\n");
3375
3376 return D3DERR_INVALIDCALL;
3377}

◆ d3dx_effect_GetMatrixTransposeArray()

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

Definition at line 3423 of file effect.c.

3425{
3426 struct d3dx_effect *effect = impl_from_ID3DXEffect(iface);
3427 struct d3dx_parameter *param = get_valid_parameter(effect, parameter);
3428
3429 TRACE("iface %p, parameter %p, matrix %p, count %u.\n", iface, parameter, matrix, count);
3430
3431 if (!count)
3432 return D3D_OK;
3433
3434 if (matrix && param && count <= param->element_count)
3435 {
3436 unsigned int i;
3437
3438 TRACE("Class %s.\n", debug_d3dxparameter_class(param->class));
3439
3440 switch (param->class)
3441 {
3442 case D3DXPC_MATRIX_ROWS:
3443 for (i = 0; i < count; ++i)
3444 get_matrix(&param->members[i], &matrix[i], TRUE);
3445 return D3D_OK;
3446
3447 case D3DXPC_SCALAR:
3448 case D3DXPC_VECTOR:
3449 case D3DXPC_OBJECT:
3450 case D3DXPC_STRUCT:
3451 break;
3452
3453 default:
3454 FIXME("Unhandled class %s.\n", debug_d3dxparameter_class(param->class));
3455 break;
3456 }
3457 }
3458
3459 WARN("Parameter not found.\n");
3460
3461 return D3DERR_INVALIDCALL;
3462}

◆ d3dx_effect_GetMatrixTransposePointerArray()

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

Definition at line 3505 of file effect.c.

3507{
3508 struct d3dx_effect *effect = impl_from_ID3DXEffect(iface);
3509 struct d3dx_parameter *param = get_valid_parameter(effect, parameter);
3510
3511 TRACE("iface %p, parameter %p, matrix %p, count %u.\n", iface, parameter, matrix, count);
3512
3513 if (!count)
3514 return D3D_OK;
3515
3516 if (matrix && param && count <= param->element_count)
3517 {
3518 unsigned int i;
3519
3520 TRACE("Class %s.\n", debug_d3dxparameter_class(param->class));
3521
3522 switch (param->class)
3523 {
3524 case D3DXPC_MATRIX_ROWS:
3525 for (i = 0; i < count; ++i)
3526 get_matrix(&param->members[i], matrix[i], TRUE);
3527 return D3D_OK;
3528
3529 case D3DXPC_SCALAR:
3530 case D3DXPC_VECTOR:
3531 case D3DXPC_OBJECT:
3532 break;
3533
3534 default:
3535 FIXME("Unhandled class %s.\n", debug_d3dxparameter_class(param->class));
3536 break;
3537 }
3538 }
3539
3540 WARN("Parameter not found.\n");
3541
3542 return D3DERR_INVALIDCALL;
3543}

◆ d3dx_effect_GetParameter()

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

Definition at line 2136 of file effect.c.

2137{
2138 struct d3dx_effect *effect = impl_from_ID3DXEffect(iface);
2139 struct d3dx_parameter *param = get_valid_parameter(effect, parameter);
2140
2141 TRACE("iface %p, parameter %p, index %u.\n", iface, parameter, index);
2142
2143 if (!parameter)
2144 {
2145 if (index < effect->params.count)
2146 {
2147 TRACE("Returning parameter %p.\n", &effect->params.parameters[index]);
2148 return get_parameter_handle(&effect->params.parameters[index].param);
2149 }
2150 }
2151 else
2152 {
2153 if (param && !param->element_count && index < param->member_count)
2154 {
2155 TRACE("Returning parameter %p.\n", &param->members[index]);
2156 return get_parameter_handle(&param->members[index]);
2157 }
2158 }
2159
2160 WARN("Parameter not found.\n");
2161
2162 return NULL;
2163}
params
GLenum const GLfloat * params
Definition: glext.h:5645
d3dx_parameter::member_count
unsigned int member_count
Definition: d3dx9_private.h:523

◆ d3dx_effect_GetParameterByName()

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

Definition at line 2165 of file effect.c.

2167{
2168 struct d3dx_effect *effect = impl_from_ID3DXEffect(iface);
2169 struct d3dx_parameter *param = get_valid_parameter(effect, parameter);
2170 D3DXHANDLE handle;
2171
2172 TRACE("iface %p, parameter %p, name %s.\n", iface, parameter, debugstr_a(name));
2173
2174 if (!name)
2175 {
2176 handle = get_parameter_handle(param);
2177 TRACE("Returning parameter %p.\n", handle);
2178 return handle;
2179 }
2180
2181 handle = get_parameter_handle(get_parameter_by_name(&effect->params, param, name));
2182 TRACE("Returning parameter %p.\n", handle);
2183
2184 return handle;
2185}

◆ d3dx_effect_GetParameterBySemantic()

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

Definition at line 2187 of file effect.c.

2189{
2190 struct d3dx_effect *effect = impl_from_ID3DXEffect(iface);
2191 struct d3dx_parameter *param = get_valid_parameter(effect, parameter);
2192 struct d3dx_parameter *temp_param;
2193 unsigned int i;
2194
2195 TRACE("iface %p, parameter %p, semantic %s.\n", iface, parameter, debugstr_a(semantic));
2196
2197 if (!parameter)
2198 {
2199 for (i = 0; i < effect->params.count; ++i)
2200 {
2201 temp_param = &effect->params.parameters[i].param;
2202
2203 if (!temp_param->semantic)
2204 {
2205 if (!semantic)
2206 {
2207 TRACE("Returning parameter %p\n", temp_param);
2208 return get_parameter_handle(temp_param);
2209 }
2210 continue;
2211 }
2212
2213 if (!stricmp(temp_param->semantic, semantic))
2214 {
2215 TRACE("Returning parameter %p\n", temp_param);
2216 return get_parameter_handle(temp_param);
2217 }
2218 }
2219 }
2220 else if (param)
2221 {
2222 for (i = 0; i < param->member_count; ++i)
2223 {
2224 temp_param = &param->members[i];
2225
2226 if (!temp_param->semantic)
2227 {
2228 if (!semantic)
2229 {
2230 TRACE("Returning parameter %p\n", temp_param);
2231 return get_parameter_handle(temp_param);
2232 }
2233 continue;
2234 }
2235
2236 if (!stricmp(temp_param->semantic, semantic))
2237 {
2238 TRACE("Returning parameter %p\n", temp_param);
2239 return get_parameter_handle(temp_param);
2240 }
2241 }
2242 }
2243
2244 WARN("Parameter not found.\n");
2245
2246 return NULL;
2247}
stricmp
#define stricmp(_String1, _String2)
Definition: compat.h:24
d3dx_parameter::semantic
char * semantic
Definition: d3dx9_private.h:529

◆ d3dx_effect_GetParameterDesc()

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

Definition at line 2026 of file effect.c.

2028{
2029 struct d3dx_effect *effect = impl_from_ID3DXEffect(iface);
2030 struct d3dx_parameter *param = get_valid_parameter(effect, parameter);
2031
2032 TRACE("iface %p, parameter %p, desc %p.\n", iface, parameter, desc);
2033
2034 if (!desc || !param)
2035 {
2036 WARN("Invalid argument specified.\n");
2037 return D3DERR_INVALIDCALL;
2038 }
2039
2040 desc->Name = param->name;
2041 desc->Semantic = param->semantic;
2042 desc->Class = param->class;
2043 desc->Type = param->type;
2044 desc->Rows = param->rows;
2045 desc->Columns = param->columns;
2046 desc->Elements = param->element_count;
2047 desc->Annotations = is_top_level_parameter(param)
2048 ? top_level_parameter_from_parameter(param)->annotation_count : 0;
2049 desc->StructMembers = param->member_count;
2050 desc->Flags = param->flags;
2051 desc->Bytes = param->bytes;
2052
2053 return D3D_OK;
2054}
top_level_parameter_from_parameter
static struct d3dx_top_level_parameter * top_level_parameter_from_parameter(struct d3dx_parameter *param)
Definition: d3dx9_private.h:561
_D3D11_SHADER_VARIABLE_DESC::Name
const char * Name
Definition: d3d11shader.h:94

◆ d3dx_effect_GetParameterElement()

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

Definition at line 2249 of file effect.c.

2250{
2251 struct d3dx_effect *effect = impl_from_ID3DXEffect(iface);
2252 struct d3dx_parameter *param = get_valid_parameter(effect, parameter);
2253
2254 TRACE("iface %p, parameter %p, index %u.\n", iface, parameter, index);
2255
2256 if (!param)
2257 {
2258 if (index < effect->params.count)
2259 {
2260 TRACE("Returning parameter %p.\n", &effect->params.parameters[index]);
2261 return get_parameter_handle(&effect->params.parameters[index].param);
2262 }
2263 }
2264 else
2265 {
2266 if (index < param->element_count)
2267 {
2268 TRACE("Returning parameter %p.\n", &param->members[index]);
2269 return get_parameter_handle(&param->members[index]);
2270 }
2271 }
2272
2273 WARN("Parameter not found.\n");
2274
2275 return NULL;
2276}

◆ d3dx_effect_GetPass()

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

Definition at line 2314 of file effect.c.

2315{
2316 struct d3dx_effect *effect = impl_from_ID3DXEffect(iface);
2317 struct d3dx_technique *tech = get_valid_technique(effect, technique);
2318
2319 TRACE("iface %p, technique %p, index %u.\n", iface, technique, index);
2320
2321 if (tech && index < tech->pass_count)
2322 {
2323 TRACE("Returning pass %p\n", &tech->passes[index]);
2324 return get_pass_handle(&tech->passes[index]);
2325 }
2326
2327 WARN("Pass not found.\n");
2328
2329 return NULL;
2330}
get_pass_handle
static D3DXHANDLE get_pass_handle(struct d3dx_pass *pass)
Definition: effect.c:454

◆ d3dx_effect_GetPassByName()

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

Definition at line 2332 of file effect.c.

2333{
2334 struct d3dx_effect *effect = impl_from_ID3DXEffect(iface);
2335 struct d3dx_technique *tech = get_valid_technique(effect, technique);
2336
2337 TRACE("iface %p, technique %p, name %s.\n", iface, technique, debugstr_a(name));
2338
2339 if (tech && name)
2340 {
2341 unsigned int i;
2342
2343 for (i = 0; i < tech->pass_count; ++i)
2344 {
2345 struct d3dx_pass *pass = &tech->passes[i];
2346
2347 if (!strcmp(pass->name, name))
2348 {
2349 TRACE("Returning pass %p\n", pass);
2350 return get_pass_handle(pass);
2351 }
2352 }
2353 }
2354
2355 WARN("Pass not found.\n");
2356
2357 return NULL;
2358}
strcmp
_ACRTIMP int __cdecl strcmp(const char *, const char *)
Definition: string.c:3324

◆ d3dx_effect_GetPassDesc()

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

Definition at line 2077 of file effect.c.

2078{
2079 struct d3dx_effect *effect = impl_from_ID3DXEffect(iface);
2080 struct d3dx_pass *pass = get_valid_pass(effect, pass_handle);
2081 unsigned int i;
2082
2083 TRACE("iface %p, pass %p, desc %p.\n", iface, pass, desc);
2084
2085 if (!desc || !pass)
2086 {
2087 WARN("Invalid argument specified.\n");
2088 return D3DERR_INVALIDCALL;
2089 }
2090
2091 desc->Name = pass->name;
2092 desc->Annotations = pass->annotation_count;
2093
2094 desc->pVertexShaderFunction = NULL;
2095 desc->pPixelShaderFunction = NULL;
2096
2097 if (effect->flags & D3DXFX_NOT_CLONEABLE)
2098 return D3D_OK;
2099
2100 for (i = 0; i < pass->state_count; ++i)
2101 {
2102 struct d3dx_state *state = &pass->states[i];
2103
2104 if (state_table[state->operation].class == SC_VERTEXSHADER
2105 || state_table[state->operation].class == SC_PIXELSHADER)
2106 {
2107 struct d3dx_parameter *param;
2108 void *param_value;
2109 BOOL param_dirty;
2110 HRESULT hr;
2111 void *data;
2112
2113 if (FAILED(hr = d3dx9_get_param_value_ptr(pass, &pass->states[i], &param_value, &param,
2114 FALSE, &param_dirty)))
2115 return hr;
2116
2117 data = param->object_id ? effect->objects[param->object_id].data : NULL;
2118 if (state_table[state->operation].class == SC_VERTEXSHADER)
2119 desc->pVertexShaderFunction = data;
2120 else
2121 desc->pPixelShaderFunction = data;
2122 }
2123 }
2124
2125 return D3D_OK;
2126}
get_valid_pass
static struct d3dx_pass * get_valid_pass(struct d3dx_effect *effect, D3DXHANDLE pass)
Definition: effect.c:487
d3dx_state
Definition: effect.c:115

◆ d3dx_effect_GetPixelShader()

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

Definition at line 3639 of file effect.c.

3641{
3642 struct d3dx_effect *effect = impl_from_ID3DXEffect(iface);
3643 struct d3dx_parameter *param = get_valid_parameter(effect, parameter);
3644
3645 TRACE("iface %p, parameter %p, shader %p.\n", iface, parameter, shader);
3646
3647 if (shader && param && !param->element_count && param->type == D3DXPT_PIXELSHADER)
3648 {
3649 if ((*shader = *(IDirect3DPixelShader9 **)param->data))
3650 IDirect3DPixelShader9_AddRef(*shader);
3651 TRACE("Returning %p.\n", *shader);
3652 return D3D_OK;
3653 }
3654
3655 WARN("Parameter not found.\n");
3656
3657 return D3DERR_INVALIDCALL;
3658}
IDirect3DPixelShader9_AddRef
#define IDirect3DPixelShader9_AddRef(p)
Definition: d3d9.h:1088

◆ d3dx_effect_GetPool()

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

Definition at line 3689 of file effect.c.

3690{
3691 struct d3dx_effect *effect = impl_from_ID3DXEffect(iface);
3692
3693 TRACE("iface %p, pool %p.\n", effect, pool);
3694
3695 if (!pool)
3696 {
3697 WARN("Invalid argument supplied.\n");
3698 return D3DERR_INVALIDCALL;
3699 }
3700
3701 *pool = NULL;
3702 if (effect->pool)
3703 {
3704 *pool = &effect->pool->ID3DXEffectPool_iface;
3705 (*pool)->lpVtbl->AddRef(*pool);
3706 }
3707
3708 TRACE("Returning pool %p.\n", *pool);
3709
3710 return S_OK;
3711}
IUnknown::AddRef
ULONG AddRef()

◆ d3dx_effect_GetStateManager()

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

Definition at line 4202 of file effect.c.

4203{
4204 struct d3dx_effect *This = impl_from_ID3DXEffect(iface);
4205
4206 TRACE("iface %p, manager %p\n", This, manager);
4207
4208 if (!manager)
4209 {
4210 WARN("Invalid argument supplied.\n");
4211 return D3DERR_INVALIDCALL;
4212 }
4213
4214 if (This->manager) IUnknown_AddRef(This->manager);
4215 *manager = This->manager;
4216
4217 return D3D_OK;
4218}

◆ d3dx_effect_GetString()

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

Definition at line 3560 of file effect.c.

3561{
3562 struct d3dx_effect *effect = impl_from_ID3DXEffect(iface);
3563 struct d3dx_parameter *param = get_valid_parameter(effect, parameter);
3564
3565 TRACE("iface %p, parameter %p, string %p.\n", iface, parameter, string);
3566
3567 if (string && param && !param->element_count && param->type == D3DXPT_STRING)
3568 {
3569 *string = *(const char **)param->data;
3570 TRACE("Returning %s.\n", debugstr_a(*string));
3571 return D3D_OK;
3572 }
3573
3574 WARN("Parameter not found.\n");
3575
3576 return D3DERR_INVALIDCALL;
3577}

◆ d3dx_effect_GetTechnique()

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

Definition at line 2278 of file effect.c.

2279{
2280 struct d3dx_effect *effect = impl_from_ID3DXEffect(iface);
2281
2282 TRACE("iface %p, index %u.\n", iface, index);
2283
2284 if (index >= effect->technique_count)
2285 {
2286 WARN("Invalid argument specified.\n");
2287 return NULL;
2288 }
2289
2290 TRACE("Returning technique %p.\n", &effect->techniques[index]);
2291
2292 return get_technique_handle(&effect->techniques[index]);
2293}

◆ d3dx_effect_GetTechniqueByName()

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

Definition at line 2295 of file effect.c.

2296{
2297 struct d3dx_effect *effect = impl_from_ID3DXEffect(iface);
2298 struct d3dx_technique *tech = get_technique_by_name(effect, name);
2299
2300 TRACE("iface %p, name %s.\n", iface, debugstr_a(name));
2301
2302 if (tech)
2303 {
2304 D3DXHANDLE t = get_technique_handle(tech);
2305 TRACE("Returning technique %p\n", t);
2306 return t;
2307 }
2308
2309 WARN("Technique not found.\n");
2310
2311 return NULL;
2312}
get_technique_by_name
static struct d3dx_technique * get_technique_by_name(struct d3dx_effect *effect, const char *name)
Definition: effect.c:459
t
GLdouble GLdouble t
Definition: gl.h:2047

◆ d3dx_effect_GetTechniqueDesc()

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

Definition at line 2056 of file effect.c.

2058{
2059 struct d3dx_effect *effect = impl_from_ID3DXEffect(iface);
2060 struct d3dx_technique *tech = technique ? get_valid_technique(effect, technique) : &effect->techniques[0];
2061
2062 TRACE("iface %p, technique %p, desc %p.\n", iface, technique, desc);
2063
2064 if (!desc || !tech)
2065 {
2066 WARN("Invalid argument specified.\n");
2067 return D3DERR_INVALIDCALL;
2068 }
2069
2070 desc->Name = tech->name;
2071 desc->Passes = tech->pass_count;
2072 desc->Annotations = tech->annotation_count;
2073
2074 return D3D_OK;
2075}
d3dx_technique::name
char * name
Definition: effect.c:143

◆ d3dx_effect_GetTexture()

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

Definition at line 3614 of file effect.c.

3616{
3617 struct d3dx_effect *effect = impl_from_ID3DXEffect(iface);
3618 struct d3dx_parameter *param = get_valid_parameter(effect, parameter);
3619
3620 TRACE("iface %p, parameter %p, texture %p.\n", iface, parameter, texture);
3621
3622 if (texture && param && !param->element_count
3623 && (param->type == D3DXPT_TEXTURE || param->type == D3DXPT_TEXTURE1D
3624 || param->type == D3DXPT_TEXTURE2D || param->type == D3DXPT_TEXTURE3D
3625 || param->type == D3DXPT_TEXTURECUBE))
3626 {
3627 *texture = *(IDirect3DBaseTexture9 **)param->data;
3628 if (*texture)
3629 IDirect3DBaseTexture9_AddRef(*texture);
3630 TRACE("Returning %p.\n", *texture);
3631 return D3D_OK;
3632 }
3633
3634 WARN("Parameter not found.\n");
3635
3636 return D3DERR_INVALIDCALL;
3637}
IDirect3DBaseTexture9_AddRef
#define IDirect3DBaseTexture9_AddRef(p)
Definition: d3d9.h:662
texture
GLenum GLuint texture
Definition: glext.h:6295

◆ d3dx_effect_GetValue()

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

Definition at line 2452 of file effect.c.

2453{
2454 struct d3dx_effect *effect = impl_from_ID3DXEffect(iface);
2455 struct d3dx_parameter *param = get_valid_parameter(effect, parameter);
2456
2457 TRACE("iface %p, parameter %p, data %p, bytes %u.\n", iface, parameter, data, bytes);
2458
2459 if (!param)
2460 {
2461 WARN("Invalid parameter %p specified.\n", parameter);
2462 return D3DERR_INVALIDCALL;
2463 }
2464 if (param->class == D3DXPC_OBJECT && is_param_type_sampler(param->type))
2465 {
2466 WARN("Parameter is a sampler, returning E_FAIL.\n");
2467 return E_FAIL;
2468 }
2469
2470 if (data && param->bytes <= bytes)
2471 {
2472 TRACE("Type %s.\n", debug_d3dxparameter_type(param->type));
2473
2474 switch (param->type)
2475 {
2476 case D3DXPT_VOID:
2477 case D3DXPT_BOOL:
2478 case D3DXPT_INT:
2479 case D3DXPT_FLOAT:
2480 case D3DXPT_STRING:
2481 break;
2482
2483 case D3DXPT_VERTEXSHADER:
2484 case D3DXPT_PIXELSHADER:
2485 case D3DXPT_TEXTURE:
2486 case D3DXPT_TEXTURE1D:
2487 case D3DXPT_TEXTURE2D:
2488 case D3DXPT_TEXTURE3D:
2489 case D3DXPT_TEXTURECUBE:
2490 {
2491 unsigned int i;
2492
2493 for (i = 0; i < (param->element_count ? param->element_count : 1); ++i)
2494 {
2495 IUnknown *unk = ((IUnknown **)param->data)[i];
2496 if (unk)
2497 IUnknown_AddRef(unk);
2498 }
2499 break;
2500 }
2501
2502 default:
2503 FIXME("Unhandled type %s.\n", debug_d3dxparameter_type(param->type));
2504 break;
2505 }
2506
2507 TRACE("Copy %u bytes.\n", param->bytes);
2508 memcpy(data, param->data, param->bytes);
2509 return D3D_OK;
2510 }
2511
2512 WARN("Parameter not found.\n");
2513
2514 return D3DERR_INVALIDCALL;
2515}
bytes
static unsigned char bytes[4]
Definition: adnsresfilter.c:74
is_param_type_sampler
static BOOL is_param_type_sampler(D3DXPARAMETER_TYPE type)
Definition: d3dx9_private.h:420
debug_d3dxparameter_type
const char * debug_d3dxparameter_type(D3DXPARAMETER_TYPE t)
Definition: util.c:344

◆ d3dx_effect_GetVector()

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

Definition at line 2929 of file effect.c.

2930{
2931 struct d3dx_effect *effect = impl_from_ID3DXEffect(iface);
2932 struct d3dx_parameter *param = get_valid_parameter(effect, parameter);
2933
2934 TRACE("iface %p, parameter %p, vector %p.\n", iface, parameter, vector);
2935
2936 if (vector && param && !param->element_count)
2937 {
2938 TRACE("Class %s.\n", debug_d3dxparameter_class(param->class));
2939
2940 switch (param->class)
2941 {
2942 case D3DXPC_SCALAR:
2943 case D3DXPC_VECTOR:
2944 if (param->type == D3DXPT_INT && param->bytes == 4)
2945 {
2946 TRACE("INT fixup.\n");
2947 vector->x = (((*(int *)param->data) & 0xff0000) >> 16) * INT_FLOAT_MULTI_INVERSE;
2948 vector->y = (((*(int *)param->data) & 0xff00) >> 8) * INT_FLOAT_MULTI_INVERSE;
2949 vector->z = ((*(int *)param->data) & 0xff) * INT_FLOAT_MULTI_INVERSE;
2950 vector->w = (((*(int *)param->data) & 0xff000000) >> 24) * INT_FLOAT_MULTI_INVERSE;
2951 return D3D_OK;
2952 }
2953 get_vector(param, vector);
2954 return D3D_OK;
2955
2956 case D3DXPC_MATRIX_ROWS:
2957 case D3DXPC_OBJECT:
2958 case D3DXPC_STRUCT:
2959 break;
2960
2961 default:
2962 FIXME("Unhandled class %s.\n", debug_d3dxparameter_class(param->class));
2963 break;
2964 }
2965 }
2966
2967 WARN("Parameter not found.\n");
2968
2969 return D3DERR_INVALIDCALL;
2970}
INT_FLOAT_MULTI_INVERSE
#define INT_FLOAT_MULTI_INVERSE
Definition: effect.c:31
get_vector
static void get_vector(struct d3dx_parameter *param, D3DXVECTOR4 *vector)
Definition: effect.c:813

◆ d3dx_effect_GetVectorArray()

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

Definition at line 3029 of file effect.c.

3031{
3032 struct d3dx_effect *effect = impl_from_ID3DXEffect(iface);
3033 struct d3dx_parameter *param = get_valid_parameter(effect, parameter);
3034
3035 TRACE("iface %p, parameter %p, vector %p, count %u.\n", iface, parameter, vector, count);
3036
3037 if (!count)
3038 return D3D_OK;
3039
3040 if (vector && param && count <= param->element_count)
3041 {
3042 unsigned int i;
3043
3044 TRACE("Class %s.\n", debug_d3dxparameter_class(param->class));
3045
3046 switch (param->class)
3047 {
3048 case D3DXPC_VECTOR:
3049 for (i = 0; i < count; ++i)
3050 get_vector(&param->members[i], &vector[i]);
3051 return D3D_OK;
3052
3053 case D3DXPC_SCALAR:
3054 case D3DXPC_MATRIX_ROWS:
3055 case D3DXPC_OBJECT:
3056 case D3DXPC_STRUCT:
3057 break;
3058
3059 default:
3060 FIXME("Unhandled class %s.\n", debug_d3dxparameter_class(param->class));
3061 break;
3062 }
3063 }
3064
3065 WARN("Parameter not found.\n");
3066
3067 return D3DERR_INVALIDCALL;
3068}

◆ d3dx_effect_GetVertexShader()

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

Definition at line 3660 of file effect.c.

3662{
3663 struct d3dx_effect *effect = impl_from_ID3DXEffect(iface);
3664 struct d3dx_parameter *param = get_valid_parameter(effect, parameter);
3665
3666 TRACE("iface %p, parameter %p, shader %p.\n", iface, parameter, shader);
3667
3668 if (shader && param && !param->element_count && param->type == D3DXPT_VERTEXSHADER)
3669 {
3670 if ((*shader = *(IDirect3DVertexShader9 **)param->data))
3671 IDirect3DVertexShader9_AddRef(*shader);
3672 TRACE("Returning %p.\n", *shader);
3673 return D3D_OK;
3674 }
3675
3676 WARN("Parameter not found.\n");
3677
3678 return D3DERR_INVALIDCALL;
3679}
IDirect3DVertexShader9_AddRef
#define IDirect3DVertexShader9_AddRef(p)
Definition: d3d9.h:1050

◆ d3dx_effect_IsParameterUsed()

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

Definition at line 3938 of file effect.c.

3939{
3940 struct d3dx_effect *effect = impl_from_ID3DXEffect(iface);
3941 struct d3dx_parameter *param = get_valid_parameter(effect, parameter);
3942 struct d3dx_technique *tech = get_valid_technique(effect, technique);
3943 BOOL ret;
3944
3945 TRACE("iface %p, parameter %p, technique %p.\n", iface, parameter, technique);
3946 TRACE("param %p, name %s, tech %p.\n", param, param ? debugstr_a(param->name) : "", tech);
3947
3948 ret = is_parameter_used(param, tech);
3949 TRACE("Returning %#x.\n", ret);
3950 return ret;
3951}

◆ d3dx_effect_OnLostDevice()

static HRESULT WINAPI d3dx_effect_OnLostDevice ( ID3DXEffect *  iface)
static

Definition at line 4166 of file effect.c.

4167{
4168 struct d3dx_effect *effect = impl_from_ID3DXEffect(iface);
4169 unsigned int i;
4170
4171 TRACE("iface %p.\n", iface);
4172
4173 for (i = 0; i < effect->params.count; ++i)
4174 walk_parameter_tree(&effect->params.parameters[i].param, param_on_lost_device, NULL);
4175
4176 return D3D_OK;
4177}
param_on_lost_device
static BOOL param_on_lost_device(void *data, struct d3dx_parameter *param)
Definition: effect.c:4119
walk_parameter_tree
static BOOL walk_parameter_tree(struct d3dx_parameter *param, walk_parameter_dep_func param_func, void *data)
Definition: effect.c:1268

◆ d3dx_effect_OnResetDevice()

static HRESULT WINAPI d3dx_effect_OnResetDevice ( ID3DXEffect *  iface)
static

Definition at line 4179 of file effect.c.

4180{
4181 struct d3dx_effect *This = impl_from_ID3DXEffect(iface);
4182
4183 FIXME("(%p)->(): stub\n", This);
4184
4185 return E_NOTIMPL;
4186}

◆ d3dx_effect_pool_AddRef()

static ULONG WINAPI d3dx_effect_pool_AddRef ( ID3DXEffectPool *  iface)
static

Definition at line 6808 of file effect.c.

6809{
6810 struct d3dx_effect_pool *pool = impl_from_ID3DXEffectPool(iface);
6811 ULONG refcount = InterlockedIncrement(&pool->refcount);
6812
6813 TRACE("%p increasing refcount to %lu.\n", pool, refcount);
6814
6815 return refcount;
6816}
impl_from_ID3DXEffectPool
static struct d3dx_effect_pool * impl_from_ID3DXEffectPool(ID3DXEffectPool *iface)
Definition: effect.c:1952
d3dx_effect_pool
Definition: effect.c:207
d3dx_effect_pool::refcount
LONG refcount
Definition: effect.c:209

◆ d3dx_effect_pool_QueryInterface()

static HRESULT WINAPI d3dx_effect_pool_QueryInterface ( ID3DXEffectPool *  iface,
REFIID  riid,
void **  object 
)
static

Definition at line 6791 of file effect.c.

6792{
6793 TRACE("iface %p, riid %s, object %p.\n", iface, debugstr_guid(riid), object);
6794
6795 if (IsEqualGUID(riid, &IID_IUnknown) ||
6796 IsEqualGUID(riid, &IID_ID3DXEffectPool))
6797 {
6798 iface->lpVtbl->AddRef(iface);
6799 *object = iface;
6800 return S_OK;
6801 }
6802
6803 WARN("Interface %s not found\n", debugstr_guid(riid));
6804
6805 return E_NOINTERFACE;
6806}
IID_IUnknown
const GUID IID_IUnknown
Definition: classfactory.cpp:11
riid
REFIID riid
Definition: atlbase.h:39
debugstr_guid
#define debugstr_guid
Definition: kernel32.h:35
IsEqualGUID
#define IsEqualGUID(rguid1, rguid2)
Definition: guiddef.h:147
E_NOINTERFACE
#define E_NOINTERFACE
Definition: winerror.h:3479

◆ d3dx_effect_pool_Release()

static ULONG WINAPI d3dx_effect_pool_Release ( ID3DXEffectPool *  iface)
static

Definition at line 6845 of file effect.c.

6846{
6847 struct d3dx_effect_pool *pool = impl_from_ID3DXEffectPool(iface);
6848 ULONG refcount = InterlockedDecrement(&pool->refcount);
6849
6850 TRACE("%p decreasing refcount to %lu.\n", pool, refcount);
6851
6852 if (!refcount)
6853 free_effect_pool(pool);
6854
6855 return refcount;
6856}
InterlockedDecrement
#define InterlockedDecrement
Definition: armddk.h:52
free_effect_pool
static void free_effect_pool(struct d3dx_effect_pool *pool)
Definition: effect.c:6818

◆ d3dx_effect_QueryInterface()

static HRESULT WINAPI d3dx_effect_QueryInterface ( ID3DXEffect *  iface,
REFIID  riid,
void **  object 
)
static

Definition at line 1965 of file effect.c.

1966{
1967 TRACE("(%p)->(%s, %p)\n", iface, debugstr_guid(riid), object);
1968
1969 if (IsEqualGUID(riid, &IID_IUnknown) ||
1970 IsEqualGUID(riid, &IID_ID3DXEffect))
1971 {
1972 iface->lpVtbl->AddRef(iface);
1973 *object = iface;
1974 return S_OK;
1975 }
1976
1977 ERR("Interface %s not found\n", debugstr_guid(riid));
1978
1979 return E_NOINTERFACE;
1980}

◆ d3dx_effect_Release()

static ULONG WINAPI d3dx_effect_Release ( ID3DXEffect *  iface)
static

Definition at line 1992 of file effect.c.

1993{
1994 struct d3dx_effect *effect = impl_from_ID3DXEffect(iface);
1995 ULONG refcount = InterlockedDecrement(&effect->ref);
1996
1997 TRACE("%p decreasing refcount to %lu.\n", effect, refcount);
1998
1999 if (!refcount)
2000 d3dx_effect_cleanup(effect);
2001
2002 return refcount;
2003}
d3dx_effect_cleanup
static void d3dx_effect_cleanup(struct d3dx_effect *effect)
Definition: effect.c:769

◆ d3dx_effect_SetArrayRange()

static HRESULT WINAPI d3dx_effect_SetArrayRange ( ID3DXEffect *  iface,
D3DXHANDLE  parameter,
UINT  start,
UINT  end 
)
static

Definition at line 3681 of file effect.c.

3682{
3683 FIXME("iface %p, parameter %p, start %u, end %u stub.\n", iface, parameter, start, end);
3684
3685 return E_NOTIMPL;
3686}
start
GLuint start
Definition: gl.h:1545
end
GLuint GLuint end
Definition: gl.h:1545

◆ d3dx_effect_SetBool()

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

Definition at line 2517 of file effect.c.

2518{
2519 struct d3dx_effect *effect = impl_from_ID3DXEffect(iface);
2520 struct d3dx_parameter *param = get_valid_parameter(effect, parameter);
2521
2522 TRACE("iface %p, parameter %p, b %#x.\n", iface, parameter, b);
2523
2524 if (param && !param->element_count && param->rows == 1 && param->columns == 1)
2525 {
2526 set_number(param_get_data_and_dirtify(effect, param, sizeof(int), TRUE),
2527 param->type, &b, D3DXPT_BOOL);
2528 return D3D_OK;
2529 }
2530
2531 WARN("Parameter not found.\n");
2532
2533 return D3DERR_INVALIDCALL;
2534}

◆ d3dx_effect_SetBoolArray()

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

Definition at line 2555 of file effect.c.

2556{
2557 struct d3dx_effect *effect = impl_from_ID3DXEffect(iface);
2558 struct d3dx_parameter *param = get_valid_parameter(effect, parameter);
2559 DWORD *data;
2560
2561 TRACE("iface %p, parameter %p, b %p, count %u.\n", iface, parameter, b, count);
2562
2563 if (param)
2564 {
2565 unsigned int i, size = min(count, param->bytes / sizeof(DWORD));
2566
2567 TRACE("Class %s.\n", debug_d3dxparameter_class(param->class));
2568
2569 switch (param->class)
2570 {
2571 case D3DXPC_SCALAR:
2572 case D3DXPC_VECTOR:
2573 case D3DXPC_MATRIX_ROWS:
2574 data = param_get_data_and_dirtify(effect, param, size * sizeof(int), TRUE);
2575 for (i = 0; i < size; ++i)
2576 {
2577 /* don't crop the input, use D3DXPT_INT instead of D3DXPT_BOOL */
2578 set_number(data + i, param->type, &b[i], D3DXPT_INT);
2579 }
2580 return D3D_OK;
2581
2582 case D3DXPC_OBJECT:
2583 case D3DXPC_STRUCT:
2584 break;
2585
2586 default:
2587 FIXME("Unhandled class %s.\n", debug_d3dxparameter_class(param->class));
2588 break;
2589 }
2590 }
2591
2592 WARN("Parameter not found.\n");
2593
2594 return D3DERR_INVALIDCALL;
2595}

◆ d3dx_effect_SetFloat()

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

Definition at line 2770 of file effect.c.

2771{
2772 struct d3dx_effect *effect = impl_from_ID3DXEffect(iface);
2773 struct d3dx_parameter *param = get_valid_parameter(effect, parameter);
2774
2775 TRACE("iface %p, parameter %p, f %.8e.\n", iface, parameter, f);
2776
2777 if (param && !param->element_count && param->rows == 1 && param->columns == 1)
2778 {
2779 DWORD value;
2780
2781 set_number(&value, param->type, &f, D3DXPT_FLOAT);
2782 *(DWORD *)param_get_data_and_dirtify(effect, param, sizeof(float),
2783 value != *(DWORD *)param->data) = value;
2784 return D3D_OK;
2785 }
2786
2787 WARN("Parameter not found.\n");
2788
2789 return D3DERR_INVALIDCALL;
2790}

◆ d3dx_effect_SetFloatArray()

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

Definition at line 2811 of file effect.c.

2813{
2814 struct d3dx_effect *effect = impl_from_ID3DXEffect(iface);
2815 struct d3dx_parameter *param = get_valid_parameter(effect, parameter);
2816 DWORD *data;
2817
2818 TRACE("iface %p, parameter %p, f %p, count %u.\n", iface, parameter, f, count);
2819
2820 if (param)
2821 {
2822 unsigned int i, size = min(count, param->bytes / sizeof(DWORD));
2823
2824 TRACE("Class %s.\n", debug_d3dxparameter_class(param->class));
2825
2826 switch (param->class)
2827 {
2828 case D3DXPC_SCALAR:
2829 case D3DXPC_VECTOR:
2830 case D3DXPC_MATRIX_ROWS:
2831 data = param_get_data_and_dirtify(effect, param, size * sizeof(float), TRUE);
2832 for (i = 0; i < size; ++i)
2833 set_number(data + i, param->type, &f[i], D3DXPT_FLOAT);
2834 return D3D_OK;
2835
2836 case D3DXPC_OBJECT:
2837 case D3DXPC_STRUCT:
2838 break;
2839
2840 default:
2841 FIXME("Unhandled class %s.\n", debug_d3dxparameter_class(param->class));
2842 break;
2843 }
2844 }
2845
2846 WARN("Parameter not found.\n");
2847
2848 return D3DERR_INVALIDCALL;
2849}

◆ d3dx_effect_SetInt()

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

Definition at line 2623 of file effect.c.

2624{
2625 struct d3dx_effect *effect = impl_from_ID3DXEffect(iface);
2626 struct d3dx_parameter *param = get_valid_parameter(effect, parameter);
2627
2628 TRACE("iface %p, parameter %p, n %d.\n", iface, parameter, n);
2629
2630 if (param && !param->element_count)
2631 {
2632 if (param->rows == 1 && param->columns == 1)
2633 {
2634 DWORD value;
2635
2636 set_number(&value, param->type, &n, D3DXPT_INT);
2637 *(DWORD *)param_get_data_and_dirtify(effect, param, sizeof(int),
2638 value != *(DWORD *)param->data) = value;
2639 return D3D_OK;
2640 }
2641
2642 /* Split the value if parameter is a vector with dimension 3 or 4. */
2643 if (param->type == D3DXPT_FLOAT
2644 && ((param->class == D3DXPC_VECTOR && param->columns != 2)
2645 || (param->class == D3DXPC_MATRIX_ROWS && param->rows != 2 && param->columns == 1)))
2646 {
2647 float *data;
2648
2649 TRACE("Vector fixup.\n");
2650
2651 data = param_get_data_and_dirtify(effect, param,
2652 min(4, param->rows * param->columns) * sizeof(float), TRUE);
2653
2654 data[0] = ((n & 0xff0000) >> 16) * INT_FLOAT_MULTI_INVERSE;
2655 data[1] = ((n & 0xff00) >> 8) * INT_FLOAT_MULTI_INVERSE;
2656 data[2] = (n & 0xff) * INT_FLOAT_MULTI_INVERSE;
2657 if (param->rows * param->columns > 3)
2658 data[3] = ((n & 0xff000000) >> 24) * INT_FLOAT_MULTI_INVERSE;
2659
2660 return D3D_OK;
2661 }
2662 }
2663
2664 WARN("Parameter not found.\n");
2665
2666 return D3DERR_INVALIDCALL;
2667}

◆ d3dx_effect_SetIntArray()

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

Definition at line 2707 of file effect.c.

2708{
2709 struct d3dx_effect *effect = impl_from_ID3DXEffect(iface);
2710 struct d3dx_parameter *param = get_valid_parameter(effect, parameter);
2711 DWORD *data;
2712
2713 TRACE("iface %p, parameter %p, n %p, count %u.\n", iface, parameter, n, count);
2714
2715 if (param)
2716 {
2717 unsigned int i, size = min(count, param->bytes / sizeof(DWORD));
2718
2719 TRACE("Class %s.\n", debug_d3dxparameter_class(param->class));
2720
2721 switch (param->class)
2722 {
2723 case D3DXPC_SCALAR:
2724 case D3DXPC_VECTOR:
2725 case D3DXPC_MATRIX_ROWS:
2726 data = param_get_data_and_dirtify(effect, param, size * sizeof(int), TRUE);
2727 for (i = 0; i < size; ++i)
2728 set_number(data + i, param->type, &n[i], D3DXPT_INT);
2729 return D3D_OK;
2730
2731 case D3DXPC_OBJECT:
2732 case D3DXPC_STRUCT:
2733 break;
2734
2735 default:
2736 FIXME("Unhandled class %s.\n", debug_d3dxparameter_class(param->class));
2737 break;
2738 }
2739 }
2740
2741 WARN("Parameter not found.\n");
2742
2743 return D3DERR_INVALIDCALL;
2744}

◆ d3dx_effect_SetMatrix()

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

Definition at line 3070 of file effect.c.

3071{
3072 struct d3dx_effect *effect = impl_from_ID3DXEffect(iface);
3073 struct d3dx_parameter *param = get_valid_parameter(effect, parameter);
3074
3075 TRACE("iface %p, parameter %p, matrix %p.\n", iface, parameter, matrix);
3076
3077 if (param && !param->element_count)
3078 {
3079 TRACE("Class %s.\n", debug_d3dxparameter_class(param->class));
3080
3081 switch (param->class)
3082 {
3083 case D3DXPC_MATRIX_ROWS:
3084 set_matrix(param, matrix, param_get_data_and_dirtify(effect, param,
3085 param->rows * param->columns * sizeof(float), TRUE));
3086 return D3D_OK;
3087
3088 case D3DXPC_SCALAR:
3089 case D3DXPC_VECTOR:
3090 case D3DXPC_OBJECT:
3091 case D3DXPC_STRUCT:
3092 break;
3093
3094 default:
3095 FIXME("Unhandled class %s.\n", debug_d3dxparameter_class(param->class));
3096 break;
3097 }
3098 }
3099
3100 WARN("Parameter not found.\n");
3101
3102 return D3DERR_INVALIDCALL;
3103}
set_matrix
static void set_matrix(struct d3dx_parameter *param, const D3DXMATRIX *matrix, void *dst_data)
Definition: effect.c:852

◆ d3dx_effect_SetMatrixArray()

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

Definition at line 3139 of file effect.c.

3141{
3142 struct d3dx_effect *effect = impl_from_ID3DXEffect(iface);
3143 struct d3dx_parameter *param = get_valid_parameter(effect, parameter);
3144
3145 TRACE("iface %p, parameter %p, matrix %p, count %u.\n", iface, parameter, matrix, count);
3146
3147 if (param && param->element_count >= count)
3148 {
3149 unsigned int i;
3150 BYTE *data;
3151
3152 TRACE("Class %s.\n", debug_d3dxparameter_class(param->class));
3153
3154 switch (param->class)
3155 {
3156 case D3DXPC_MATRIX_ROWS:
3157 data = param_get_data_and_dirtify(effect, param, count * param->rows
3158 * param->columns * sizeof(float), TRUE);
3159
3160 for (i = 0; i < count; ++i)
3161 set_matrix(&param->members[i], &matrix[i],
3162 data + i * param->rows * param->columns * sizeof(float));
3163
3164 return D3D_OK;
3165
3166 case D3DXPC_SCALAR:
3167 case D3DXPC_VECTOR:
3168 case D3DXPC_OBJECT:
3169 case D3DXPC_STRUCT:
3170 break;
3171
3172 default:
3173 FIXME("Unhandled class %s.\n", debug_d3dxparameter_class(param->class));
3174 break;
3175 }
3176 }
3177
3178 WARN("Parameter not found.\n");
3179
3180 return D3DERR_INVALIDCALL;
3181}

◆ d3dx_effect_SetMatrixPointerArray()

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

Definition at line 3224 of file effect.c.

3226{
3227 struct d3dx_effect *effect = impl_from_ID3DXEffect(iface);
3228 struct d3dx_parameter *param = get_valid_parameter(effect, parameter);
3229
3230 TRACE("iface %p, parameter %p, matrix %p, count %u.\n", iface, parameter, matrix, count);
3231
3232 if (param && count <= param->element_count)
3233 {
3234 unsigned int i;
3235 BYTE *data;
3236
3237 switch (param->class)
3238 {
3239 case D3DXPC_MATRIX_ROWS:
3240 data = param_get_data_and_dirtify(effect, param, count * param->rows
3241 * param->columns * sizeof(float), TRUE);
3242
3243 for (i = 0; i < count; ++i)
3244 set_matrix(&param->members[i], matrix[i], data + i * param->rows
3245 * param->columns * sizeof(float));
3246
3247 return D3D_OK;
3248
3249 case D3DXPC_SCALAR:
3250 case D3DXPC_VECTOR:
3251 case D3DXPC_OBJECT:
3252 break;
3253
3254 default:
3255 FIXME("Unhandled class %s.\n", debug_d3dxparameter_class(param->class));
3256 break;
3257 }
3258 }
3259
3260 WARN("Parameter not found.\n");
3261
3262 return D3DERR_INVALIDCALL;
3263}

◆ d3dx_effect_SetMatrixTranspose()

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

Definition at line 3305 of file effect.c.

3307{
3308 struct d3dx_effect *effect = impl_from_ID3DXEffect(iface);
3309 struct d3dx_parameter *param = get_valid_parameter(effect, parameter);
3310
3311 TRACE("iface %p, parameter %p, matrix %p.\n", iface, parameter, matrix);
3312
3313 if (param && !param->element_count)
3314 {
3315 TRACE("Class %s.\n", debug_d3dxparameter_class(param->class));
3316
3317 switch (param->class)
3318 {
3319 case D3DXPC_MATRIX_ROWS:
3320 set_matrix_transpose(param, matrix, param_get_data_and_dirtify(effect, param,
3321 param->rows * param->columns * sizeof(float), TRUE));
3322 return D3D_OK;
3323
3324 case D3DXPC_SCALAR:
3325 case D3DXPC_VECTOR:
3326 case D3DXPC_OBJECT:
3327 case D3DXPC_STRUCT:
3328 break;
3329
3330 default:
3331 FIXME("Unhandled class %s.\n", debug_d3dxparameter_class(param->class));
3332 break;
3333 }
3334 }
3335
3336 WARN("Parameter not found.\n");
3337
3338 return D3DERR_INVALIDCALL;
3339}
set_matrix_transpose
static void set_matrix_transpose(struct d3dx_parameter *param, const D3DXMATRIX *matrix, void *dst_data)
Definition: effect.c:878

◆ d3dx_effect_SetMatrixTransposeArray()

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

Definition at line 3379 of file effect.c.

3381{
3382 struct d3dx_effect *effect = impl_from_ID3DXEffect(iface);
3383 struct d3dx_parameter *param = get_valid_parameter(effect, parameter);
3384
3385 TRACE("iface %p, parameter %p, matrix %p, count %u.\n", iface, parameter, matrix, count);
3386
3387 if (param && param->element_count >= count)
3388 {
3389 unsigned int i;
3390 BYTE *data;
3391
3392 TRACE("Class %s.\n", debug_d3dxparameter_class(param->class));
3393
3394 switch (param->class)
3395 {
3396 case D3DXPC_MATRIX_ROWS:
3397 data = param_get_data_and_dirtify(effect, param, count * param->rows
3398 * param->columns * sizeof(float), TRUE);
3399
3400 for (i = 0; i < count; ++i)
3401 set_matrix_transpose(&param->members[i], &matrix[i], data
3402 + i * param->rows * param->columns * sizeof(float));
3403
3404 return D3D_OK;
3405
3406 case D3DXPC_SCALAR:
3407 case D3DXPC_VECTOR:
3408 case D3DXPC_OBJECT:
3409 case D3DXPC_STRUCT:
3410 break;
3411
3412 default:
3413 FIXME("Unhandled class %s.\n", debug_d3dxparameter_class(param->class));
3414 break;
3415 }
3416 }
3417
3418 WARN("Parameter not found.\n");
3419
3420 return D3DERR_INVALIDCALL;
3421}

◆ d3dx_effect_SetMatrixTransposePointerArray()

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

Definition at line 3464 of file effect.c.

3466{
3467 struct d3dx_effect *effect = impl_from_ID3DXEffect(iface);
3468 struct d3dx_parameter *param = get_valid_parameter(effect, parameter);
3469
3470 TRACE("iface %p, parameter %p, matrix %p, count %u.\n", iface, parameter, matrix, count);
3471
3472 if (param && count <= param->element_count)
3473 {
3474 unsigned int i;
3475 BYTE *data;
3476
3477 switch (param->class)
3478 {
3479 case D3DXPC_MATRIX_ROWS:
3480 data = param_get_data_and_dirtify(effect, param, count * param->rows
3481 * param->columns * sizeof(float), TRUE);
3482
3483 for (i = 0; i < count; ++i)
3484 set_matrix_transpose(&param->members[i], matrix[i], data
3485 + i * param->rows * param->columns * sizeof(float));
3486
3487 return D3D_OK;
3488
3489 case D3DXPC_SCALAR:
3490 case D3DXPC_VECTOR:
3491 case D3DXPC_OBJECT:
3492 break;
3493
3494 default:
3495 FIXME("Unhandled class %s.\n", debug_d3dxparameter_class(param->class));
3496 break;
3497 }
3498 }
3499
3500 WARN("Parameter not found.\n");
3501
3502 return D3DERR_INVALIDCALL;
3503}

◆ d3dx_effect_SetStateManager()

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

Definition at line 4188 of file effect.c.

4189{
4190 struct d3dx_effect *This = impl_from_ID3DXEffect(iface);
4191
4192 TRACE("iface %p, manager %p\n", This, manager);
4193
4194 if (manager) IUnknown_AddRef(manager);
4195 if (This->manager) IUnknown_Release(This->manager);
4196
4197 This->manager = manager;
4198
4199 return D3D_OK;
4200}

◆ d3dx_effect_SetString()

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

Definition at line 3545 of file effect.c.

3546{
3547 struct d3dx_effect *effect = impl_from_ID3DXEffect(iface);
3548 struct d3dx_parameter *param = get_valid_parameter(effect, parameter);
3549
3550 TRACE("iface %p, parameter %p, string %s.\n", iface, parameter, debugstr_a(string));
3551
3552 if (param && param->type == D3DXPT_STRING)
3553 return set_string(param_get_data_and_dirtify(effect, param, sizeof(void *), TRUE), string);
3554
3555 WARN("Parameter not found.\n");
3556
3557 return D3DERR_INVALIDCALL;
3558}
set_string
static HRESULT set_string(char **param_data, const char *string)
Definition: effect.c:892

◆ d3dx_effect_SetTechnique()

static HRESULT WINAPI d3dx_effect_SetTechnique ( ID3DXEffect *  iface,
D3DXHANDLE  technique 
)
static

Definition at line 3713 of file effect.c.

3714{
3715 struct d3dx_effect *effect = impl_from_ID3DXEffect(iface);
3716 struct d3dx_technique *tech = get_valid_technique(effect, technique);
3717
3718 TRACE("iface %p, technique %p\n", iface, technique);
3719
3720 if (tech)
3721 {
3722 effect->active_technique = tech;
3723 TRACE("Technique %p\n", tech);
3724 return D3D_OK;
3725 }
3726
3727 WARN("Technique not found.\n");
3728
3729 return D3DERR_INVALIDCALL;
3730}

◆ d3dx_effect_SetTexture()

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

Definition at line 3579 of file effect.c.

3581{
3582 struct d3dx_effect *effect = impl_from_ID3DXEffect(iface);
3583 struct d3dx_parameter *param = get_valid_parameter(effect, parameter);
3584
3585 TRACE("iface %p, parameter %p, texture %p.\n", iface, parameter, texture);
3586
3587 if (param && !param->element_count
3588 && (param->type == D3DXPT_TEXTURE || param->type == D3DXPT_TEXTURE1D
3589 || param->type == D3DXPT_TEXTURE2D || param->type == D3DXPT_TEXTURE3D
3590 || param->type == D3DXPT_TEXTURECUBE))
3591 {
3592 IDirect3DBaseTexture9 **data = param_get_data_and_dirtify(effect, param,
3593 sizeof(void *), texture != *(IDirect3DBaseTexture9 **)param->data);
3594 IDirect3DBaseTexture9 *old_texture = *data;
3595
3596 *data = texture;
3597
3598 if (texture == old_texture)
3599 return D3D_OK;
3600
3601 if (texture)
3602 IDirect3DBaseTexture9_AddRef(texture);
3603 if (old_texture)
3604 IDirect3DBaseTexture9_Release(old_texture);
3605
3606 return D3D_OK;
3607 }
3608
3609 WARN("Parameter not found.\n");
3610
3611 return D3DERR_INVALIDCALL;
3612}
IDirect3DBaseTexture9_Release
#define IDirect3DBaseTexture9_Release(p)
Definition: d3d9.h:663

◆ d3dx_effect_SetValue()

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

Definition at line 2425 of file effect.c.

2427{
2428 struct d3dx_effect *effect = impl_from_ID3DXEffect(iface);
2429 struct d3dx_parameter *param = get_valid_parameter(effect, parameter);
2430
2431 TRACE("iface %p, parameter %p, data %p, bytes %u.\n", iface, parameter, data, bytes);
2432
2433 if (!param)
2434 {
2435 WARN("Invalid parameter %p specified.\n", parameter);
2436 return D3DERR_INVALIDCALL;
2437 }
2438 if (param->class == D3DXPC_OBJECT && is_param_type_sampler(param->type))
2439 {
2440 WARN("Parameter is a sampler, returning E_FAIL.\n");
2441 return E_FAIL;
2442 }
2443
2444 if (data && param->bytes <= bytes)
2445 return set_value(param, data, bytes, param_get_data_and_dirtify(effect, param, param->bytes, TRUE));
2446
2447 WARN("Invalid argument specified.\n");
2448
2449 return D3DERR_INVALIDCALL;
2450}

◆ d3dx_effect_SetVector()

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

Definition at line 2875 of file effect.c.

2876{
2877 struct d3dx_effect *effect = impl_from_ID3DXEffect(iface);
2878 struct d3dx_parameter *param = get_valid_parameter(effect, parameter);
2879
2880 TRACE("iface %p, parameter %p, vector %p.\n", iface, parameter, vector);
2881
2882 if (param && !param->element_count)
2883 {
2884 TRACE("Class %s.\n", debug_d3dxparameter_class(param->class));
2885
2886 switch (param->class)
2887 {
2888 case D3DXPC_SCALAR:
2889 case D3DXPC_VECTOR:
2890 if (param->type == D3DXPT_INT && param->bytes == 4)
2891 {
2892 DWORD tmp;
2893
2894 TRACE("INT fixup.\n");
2895 tmp = max(min(vector->z, 1.0f), 0.0f) * INT_FLOAT_MULTI;
2896 tmp += ((DWORD)(max(min(vector->y, 1.0f), 0.0f) * INT_FLOAT_MULTI)) << 8;
2897 tmp += ((DWORD)(max(min(vector->x, 1.0f), 0.0f) * INT_FLOAT_MULTI)) << 16;
2898 tmp += ((DWORD)(max(min(vector->w, 1.0f), 0.0f) * INT_FLOAT_MULTI)) << 24;
2899
2900 *(int *)param_get_data_and_dirtify(effect, param, sizeof(int), TRUE) = tmp;
2901 return D3D_OK;
2902 }
2903 if (param->type == D3DXPT_FLOAT)
2904 {
2905 memcpy(param_get_data_and_dirtify(effect, param, param->columns * sizeof(float), TRUE),
2906 vector, param->columns * sizeof(float));
2907 return D3D_OK;
2908 }
2909
2910 set_vector(param, vector, param_get_data_and_dirtify(effect, param, param->columns * sizeof(float), TRUE));
2911 return D3D_OK;
2912
2913 case D3DXPC_MATRIX_ROWS:
2914 case D3DXPC_OBJECT:
2915 case D3DXPC_STRUCT:
2916 break;
2917
2918 default:
2919 FIXME("Unhandled class %s.\n", debug_d3dxparameter_class(param->class));
2920 break;
2921 }
2922 }
2923
2924 WARN("Parameter not found.\n");
2925
2926 return D3DERR_INVALIDCALL;
2927}
set_vector
static void set_vector(struct d3dx_parameter *param, const D3DXVECTOR4 *vector, void *dst_data)
Definition: effect.c:826
DWORD
#define DWORD
Definition: nt_native.h:44

◆ d3dx_effect_SetVectorArray()

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

Definition at line 2972 of file effect.c.

2974{
2975 struct d3dx_effect *effect = impl_from_ID3DXEffect(iface);
2976 struct d3dx_parameter *param = get_valid_parameter(effect, parameter);
2977
2978 TRACE("iface %p, parameter %p, vector %p, count %u.\n", iface, parameter, vector, count);
2979
2980 if (param && param->element_count && param->element_count >= count)
2981 {
2982 unsigned int i;
2983 BYTE *data;
2984
2985 TRACE("Class %s.\n", debug_d3dxparameter_class(param->class));
2986
2987 switch (param->class)
2988 {
2989 case D3DXPC_VECTOR:
2990 data = param_get_data_and_dirtify(effect, param, count * param->columns * sizeof(float), TRUE);
2991
2992 if (param->type == D3DXPT_FLOAT)
2993 {
2994 if (param->columns == 4)
2995 {
2996 memcpy(data, vector, count * 4 * sizeof(float));
2997 }
2998 else
2999 {
3000 for (i = 0; i < count; ++i)
3001 memcpy((float *)data + param->columns * i, vector + i,
3002 param->columns * sizeof(float));
3003 }
3004 return D3D_OK;
3005 }
3006
3007 for (i = 0; i < count; ++i)
3008 set_vector(&param->members[i], &vector[i], data + i * param->columns * sizeof(float));
3009
3010 return D3D_OK;
3011
3012 case D3DXPC_SCALAR:
3013 case D3DXPC_MATRIX_ROWS:
3014 case D3DXPC_OBJECT:
3015 case D3DXPC_STRUCT:
3016 break;
3017
3018 default:
3019 FIXME("Unhandled class %s.\n", debug_d3dxparameter_class(param->class));
3020 break;
3021 }
3022 }
3023
3024 WARN("Parameter not found.\n");
3025
3026 return D3DERR_INVALIDCALL;
3027}

◆ d3dx_effect_ValidateTechnique()

static HRESULT WINAPI d3dx_effect_ValidateTechnique ( ID3DXEffect *  iface,
D3DXHANDLE  technique 
)
static

Definition at line 3741 of file effect.c.

3742{
3743 struct d3dx_effect *effect = impl_from_ID3DXEffect(iface);
3744 struct d3dx_technique *tech = get_valid_technique(effect, technique);
3745 HRESULT ret = D3D_OK;
3746 unsigned int i, j;
3747
3748 FIXME("iface %p, technique %p semi-stub.\n", iface, technique);
3749
3750 if (!tech)
3751 {
3752 ret = D3DERR_INVALIDCALL;
3753 goto done;
3754 }
3755 for (i = 0; i < tech->pass_count; ++i)
3756 {
3757 struct d3dx_pass *pass = &tech->passes[i];
3758
3759 for (j = 0; j < pass->state_count; ++j)
3760 {
3761 struct d3dx_state *state = &pass->states[j];
3762
3763 if (state_table[state->operation].class == SC_VERTEXSHADER
3764 || state_table[state->operation].class == SC_PIXELSHADER)
3765 {
3766 struct d3dx_parameter *param;
3767 void *param_value;
3768 BOOL param_dirty;
3769 HRESULT hr;
3770
3771 if (FAILED(hr = d3dx9_get_param_value_ptr(pass, &pass->states[j], &param_value, &param,
3772 FALSE, &param_dirty)))
3773 return hr;
3774
3775 if (param->object_id && effect->objects[param->object_id].creation_failed)
3776 {
3777 ret = E_FAIL;
3778 goto done;
3779 }
3780 }
3781 }
3782 }
3783done:
3784 TRACE("Returning %#lx.\n", ret);
3785 return ret;
3786}

Referenced by d3dx_effect_FindNextValidTechnique().

◆ d3dx_init_parameters_store()

HRESULT d3dx_init_parameters_store ( struct d3dx_parameters_store *  store,
unsigned int  count 
)

Definition at line 743 of file effect.c.

744{
745 store->count = count;
746 wine_rb_init(&store->tree, param_rb_compare);
747
748 if (store->count && !(store->parameters = calloc(store->count, sizeof(*store->parameters))))
749 return E_OUTOFMEMORY;
750
751 return S_OK;
752}
param_rb_compare
static int param_rb_compare(const void *key, const struct wine_rb_entry *entry)
Definition: effect.c:735
wine_rb_init
#define wine_rb_init
Definition: rbtree.h:406
d3dx_parameters_store::parameters
struct d3dx_top_level_parameter * parameters
Definition: d3dx9_private.h:589
d3dx_parameters_store::tree
struct wine_rb_tree tree
Definition: d3dx9_private.h:588
d3dx_parameters_store::count
unsigned int count
Definition: d3dx9_private.h:590

Referenced by d3dx_parse_effect(), and D3DXCreateTextureShader().

◆ d3dx_parameters_store_cleanup()

void d3dx_parameters_store_cleanup ( struct d3dx_parameters_store *  store)

Definition at line 754 of file effect.c.

755{
756 unsigned int i;
757
758 free(store->full_name_tmp);
759
760 if (store->parameters)
761 {
762 for (i = 0; i < store->count; ++i)
763 free_top_level_parameter(&store->parameters[i]);
764 free(store->parameters);
765 store->parameters = NULL;
766 }
767}
d3dx_parameters_store::full_name_tmp
char * full_name_tmp
Definition: d3dx9_private.h:592

Referenced by d3dx9_texture_shader_Release(), d3dx_effect_cleanup(), and d3dx_parse_effect().

◆ d3dx_parse_array_selector()

static HRESULT d3dx_parse_array_selector ( struct d3dx_effect *  effect,
struct d3dx_state *  state,
const char **  skip_constants,
unsigned int  skip_constants_count 
)
static

Definition at line 6035 of file effect.c.

6037{
6038 struct d3dx_parameter *param = &state->parameter;
6039 struct d3dx_object *object = &effect->objects[param->object_id];
6040 char *ptr = object->data;
6041 uint32_t string_size;
6042 HRESULT ret;
6043
6044 TRACE("Parsing array entry selection state for parameter %p.\n", param);
6045
6046 string_size = *(uint32_t *)ptr;
6047 state->referenced_param = get_parameter_by_name(&effect->params, NULL, ptr + 4);
6048 if (state->referenced_param)
6049 {
6050 TRACE("Mapping to parameter %s.\n", debugstr_a(state->referenced_param->name));
6051 }
6052 else
6053 {
6054 FIXME("Referenced parameter %s not found.\n", ptr + 4);
6055 return D3DXERR_INVALIDDATA;
6056 }
6057 TRACE("Unknown u32: 0x%.8x.\n", *(uint32_t *)(ptr + string_size));
6058
6059 if (string_size % sizeof(uint32_t))
6060 FIXME("Unaligned string_size %u.\n", string_size);
6061 if (FAILED(ret = d3dx_create_param_eval(&effect->params, (uint32_t *)(ptr + string_size) + 1,
6062 object->size - (string_size + sizeof(uint32_t)), D3DXPT_INT, &param->param_eval,
6063 get_version_counter_ptr(effect), NULL, 0)))
6064 return ret;
6065 ret = D3D_OK;
6066 param = state->referenced_param;
6067 if (param->type == D3DXPT_VERTEXSHADER || param->type == D3DXPT_PIXELSHADER)
6068 {
6069 unsigned int i;
6070
6071 for (i = 0; i < param->element_count; i++)
6072 {
6073 if (param->members[i].type != param->type)
6074 {
6075 FIXME("Unexpected member parameter type %u, expected %u.\n", param->members[i].type, param->type);
6076 return D3DXERR_INVALIDDATA;
6077 }
6078 if (!param->members[i].param_eval)
6079 {
6080 TRACE("Creating preshader for object %u.\n", param->members[i].object_id);
6081 object = &effect->objects[param->members[i].object_id];
6082 if (FAILED(ret = d3dx_create_param_eval(&effect->params, object->data, object->size, param->type,
6083 &param->members[i].param_eval, get_version_counter_ptr(effect),
6084 skip_constants, skip_constants_count)))
6085 break;
6086 }
6087 }
6088 }
6089 return ret;
6090}
D3DXERR_INVALIDDATA
#define D3DXERR_INVALIDDATA
Definition: compiler.c:53
d3dx_create_param_eval
HRESULT d3dx_create_param_eval(struct d3dx_parameters_store *parameters, void *byte_code, unsigned int byte_code_size, D3DXPARAMETER_TYPE type, struct d3dx_param_eval **peval, ULONG64 *version_counter, const char **skip_constants, unsigned int skip_constants_count)
Definition: preshader.c:1232
get_version_counter_ptr
static ULONG64 * get_version_counter_ptr(struct d3dx_effect *effect)
Definition: effect.c:1286
object::members
struct member * members
Definition: locator.c:515

Referenced by d3dx_parse_resource().

◆ d3dx_parse_effect()

static HRESULT d3dx_parse_effect ( struct d3dx_effect *  effect,
const char *  data,
UINT  data_size,
uint32_t  start,
const char **  skip_constants,
unsigned int  skip_constants_count 
)
static

Definition at line 6278 of file effect.c.

6280{
6281 unsigned int string_count, resource_count, params_count, shader_count;
6282 const char *ptr = data + start;
6283 unsigned int i;
6284 HRESULT hr;
6285
6286 params_count = read_u32(&ptr);
6287 TRACE("Parameter count: %u.\n", params_count);
6288
6289 effect->technique_count = read_u32(&ptr);
6290 TRACE("Technique count: %u.\n", effect->technique_count);
6291
6292 /* This value appears to be equal to a number of shader variables, with each pass contributing
6293 one additional slot. */
6294 shader_count = read_u32(&ptr);
6295 TRACE("Shader count: %u.\n", shader_count);
6296
6297 effect->object_count = read_u32(&ptr);
6298 TRACE("Object count: %u.\n", effect->object_count);
6299
6300 effect->objects = calloc(effect->object_count, sizeof(*effect->objects));
6301 if (!effect->objects)
6302 {
6303 ERR("Out of memory.\n");
6304 hr = E_OUTOFMEMORY;
6305 goto err_out;
6306 }
6307
6308 if (FAILED(hr = d3dx_init_parameters_store(&effect->params, params_count)))
6309 {
6310 hr = E_OUTOFMEMORY;
6311 goto err_out;
6312 }
6313
6314 for (i = 0; i < effect->params.count; ++i)
6315 {
6316 param_set_magic_number(&effect->params.parameters[i].param);
6317 hr = d3dx_parse_effect_parameter(effect, &effect->params.parameters[i], data, &ptr, effect->objects);
6318 if (hr != D3D_OK)
6319 {
6320 WARN("Failed to parse parameter %u.\n", i);
6321 goto err_out;
6322 }
6323 walk_parameter_tree(&effect->params.parameters[i].param, param_set_top_level_param, &effect->params.parameters[i]);
6324 add_param_to_tree(effect, &effect->params.parameters[i].param, NULL, 0, 0);
6325 }
6326
6327 if (effect->technique_count)
6328 {
6329 effect->techniques = calloc(effect->technique_count, sizeof(*effect->techniques));
6330 if (!effect->techniques)
6331 {
6332 ERR("Out of memory.\n");
6333 hr = E_OUTOFMEMORY;
6334 goto err_out;
6335 }
6336
6337 for (i = 0; i < effect->technique_count; ++i)
6338 {
6339 TRACE("Parsing technique %u.\n", i);
6340 hr = d3dx_parse_effect_technique(effect, &effect->techniques[i], data, &ptr, effect->objects);
6341 if (hr != D3D_OK)
6342 {
6343 WARN("Failed to parse technique %u.\n", i);
6344 goto err_out;
6345 }
6346 }
6347 }
6348
6349 string_count = read_u32(&ptr);
6350 TRACE("String count: %u.\n", string_count);
6351
6352 resource_count = read_u32(&ptr);
6353 TRACE("Resource count: %u.\n", resource_count);
6354
6355 for (i = 0; i < string_count; ++i)
6356 {
6357 unsigned int id;
6358
6359 id = read_u32(&ptr);
6360 TRACE("id: %u.\n", id);
6361
6362 if (FAILED(hr = d3dx9_copy_data(effect, id, &ptr)))
6363 goto err_out;
6364
6365 if (effect->objects[id].data)
6366 {
6367 if (FAILED(hr = d3dx9_create_object(effect, &effect->objects[id])))
6368 goto err_out;
6369 }
6370 }
6371
6372 for (i = 0; i < resource_count; ++i)
6373 {
6374 TRACE("parse resource %u.\n", i);
6375
6376 hr = d3dx_parse_resource(effect, data, &ptr, skip_constants, skip_constants_count);
6377 if (hr != D3D_OK)
6378 {
6379 WARN("Failed to parse resource %u.\n", i);
6380 goto err_out;
6381 }
6382 }
6383
6384 for (i = 0; i < effect->params.count; ++i)
6385 {
6386 if (FAILED(hr = d3dx_pool_sync_shared_parameter(effect->pool, &effect->params.parameters[i])))
6387 goto err_out;
6388 effect->params.parameters[i].version_counter = get_version_counter_ptr(effect);
6389 set_dirty(&effect->params.parameters[i].param);
6390 }
6391 return D3D_OK;
6392
6393err_out:
6394
6395 if (effect->techniques)
6396 {
6397 for (i = 0; i < effect->technique_count; ++i)
6398 free_technique(&effect->techniques[i]);
6399 free(effect->techniques);
6400 effect->techniques = NULL;
6401 }
6402
6403 d3dx_parameters_store_cleanup(&effect->params);
6404
6405 if (effect->objects)
6406 {
6407 for (i = 0; i < effect->object_count; ++i)
6408 {
6409 free_object(&effect->objects[i]);
6410 }
6411 free(effect->objects);
6412 effect->objects = NULL;
6413 }
6414
6415 return hr;
6416}
d3dx_parse_effect_technique
static HRESULT d3dx_parse_effect_technique(struct d3dx_effect *effect, struct d3dx_technique *technique, const char *data, const char **ptr, struct d3dx_object *objects)
Definition: effect.c:5900
param_set_magic_number
static void param_set_magic_number(struct d3dx_parameter *param)
Definition: effect.c:5362
d3dx_parse_resource
static HRESULT d3dx_parse_resource(struct d3dx_effect *effect, const char *data, const char **ptr, const char **skip_constants, unsigned int skip_constants_count)
Definition: effect.c:6092
d3dx9_create_object
static HRESULT d3dx9_create_object(struct d3dx_effect *effect, struct d3dx_object *object)
Definition: effect.c:5993
d3dx_parse_effect_parameter
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)
Definition: effect.c:5732
d3dx_init_parameters_store
HRESULT d3dx_init_parameters_store(struct d3dx_parameters_store *store, unsigned int count)
Definition: effect.c:743
param_set_top_level_param
static BOOL param_set_top_level_param(void *top_level_param, struct d3dx_parameter *param)
Definition: effect.c:6272
set_dirty
static void set_dirty(struct d3dx_parameter *param)
Definition: effect.c:1329
d3dx_pool_sync_shared_parameter
static HRESULT d3dx_pool_sync_shared_parameter(struct d3dx_effect_pool *pool, struct d3dx_top_level_parameter *param)
Definition: effect.c:1831
d3dx9_copy_data
static HRESULT d3dx9_copy_data(struct d3dx_effect *effect, unsigned int object_id, const char **ptr)
Definition: effect.c:5326
id
GLuint id
Definition: glext.h:5910

Referenced by d3dx9_effect_init_from_binary().

◆ d3dx_parse_effect_annotation()

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

Definition at line 5626 of file effect.c.

5628{
5629 const char *ptr2;
5630 uint32_t offset;
5631 HRESULT hr;
5632
5633 anno->flags = D3DX_PARAMETER_ANNOTATION;
5634
5635 offset = read_u32(ptr);
5636 TRACE("Typedef offset: %#x.\n", offset);
5637 ptr2 = data + offset;
5638 hr = d3dx_parse_effect_typedef(effect, anno, data, &ptr2, NULL, D3DX_PARAMETER_ANNOTATION);
5639 if (hr != D3D_OK)
5640 {
5641 WARN("Failed to parse type definition.\n");
5642 return hr;
5643 }
5644
5645 offset = read_u32(ptr);
5646 TRACE("Value offset: %#x.\n", offset);
5647 hr = d3dx_parse_init_value(effect, anno, data, data + offset, objects);
5648 if (hr != D3D_OK)
5649 {
5650 WARN("Failed to parse value.\n");
5651 return hr;
5652 }
5653
5654 return D3D_OK;
5655}
d3dx_parse_effect_typedef
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)
Definition: effect.c:5432
d3dx_parse_init_value
static HRESULT d3dx_parse_init_value(struct d3dx_effect *effect, struct d3dx_parameter *param, const char *data, const char *ptr, struct d3dx_object *objects)
Definition: effect.c:5252
D3DX_PARAMETER_ANNOTATION
#define D3DX_PARAMETER_ANNOTATION
Definition: d3dx9effect.h:32
objects
static const CLSID * objects[]
Definition: apphelp.c:112
d3dx_parameter::flags
uint32_t flags
Definition: d3dx9_private.h:524

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

◆ d3dx_parse_effect_parameter()

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

Definition at line 5732 of file effect.c.

5734{
5735 const char *ptr2;
5736 uint32_t offset;
5737 unsigned int i;
5738 HRESULT hr;
5739
5740 offset = read_u32(ptr);
5741 TRACE("Typedef offset: %#x.\n", offset);
5742 ptr2 = data + offset;
5743
5744 offset = read_u32(ptr);
5745 TRACE("Value offset: %#x.\n", offset);
5746
5747 param->param.flags = read_u32(ptr);
5748 TRACE("Flags: %#x.\n", param->param.flags);
5749
5750 param->annotation_count = read_u32(ptr);
5751 TRACE("Annotation count: %u.\n", param->annotation_count);
5752
5753 hr = d3dx_parse_effect_typedef(effect, &param->param, data, &ptr2, NULL, param->param.flags);
5754 if (hr != D3D_OK)
5755 {
5756 WARN("Failed to parse type definition.\n");
5757 return hr;
5758 }
5759
5760 hr = d3dx_parse_init_value(effect, &param->param, data, data + offset, objects);
5761 if (hr != D3D_OK)
5762 {
5763 WARN("Failed to parse value.\n");
5764 return hr;
5765 }
5766
5767 if (param->annotation_count)
5768 {
5769 param->annotations = calloc(param->annotation_count, sizeof(*param->annotations));
5770 if (!param->annotations)
5771 {
5772 ERR("Out of memory.\n");
5773 hr = E_OUTOFMEMORY;
5774 goto err_out;
5775 }
5776
5777 for (i = 0; i < param->annotation_count; ++i)
5778 {
5779 param_set_magic_number(&param->annotations[i]);
5780 hr = d3dx_parse_effect_annotation(effect, &param->annotations[i], data, ptr, objects);
5781 if (hr != D3D_OK)
5782 {
5783 WARN("Failed to parse annotation.\n");
5784 goto err_out;
5785 }
5786 }
5787 }
5788
5789 return D3D_OK;
5790
5791err_out:
5792
5793 if (param->annotations)
5794 {
5795 for (i = 0; i < param->annotation_count; ++i)
5796 free_parameter(&param->annotations[i], FALSE, FALSE);
5797 free(param->annotations);
5798 param->annotations = NULL;
5799 }
5800
5801 return hr;
5802}
d3dx_parse_effect_annotation
static HRESULT d3dx_parse_effect_annotation(struct d3dx_effect *effect, struct d3dx_parameter *anno, const char *data, const char **ptr, struct d3dx_object *objects)
Definition: effect.c:5626
free_parameter
static void free_parameter(struct d3dx_parameter *param, BOOL element, BOOL child)
Definition: effect.c:603

Referenced by d3dx_parse_effect().

◆ d3dx_parse_effect_pass()

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

Definition at line 5804 of file effect.c.

5806{
5807 struct d3dx_state *states = NULL;
5808 char *name = NULL;
5809 uint32_t offset;
5810 unsigned int i;
5811 HRESULT hr;
5812
5813 offset = read_u32(ptr);
5814 TRACE("Pass name offset: %#x.\n", offset);
5815 hr = d3dx9_parse_name(&name, data + offset);
5816 if (hr != D3D_OK)
5817 {
5818 WARN("Failed to parse name.\n");
5819 goto err_out;
5820 }
5821
5822 pass->annotation_count = read_u32(ptr);
5823 TRACE("Annotation count: %u.\n", pass->annotation_count);
5824
5825 pass->state_count = read_u32(ptr);
5826 TRACE("State count: %u.\n", pass->state_count);
5827
5828 if (pass->annotation_count)
5829 {
5830 pass->annotations = calloc(pass->annotation_count, sizeof(*pass->annotations));
5831 if (!pass->annotations)
5832 {
5833 ERR("Out of memory\n");
5834 hr = E_OUTOFMEMORY;
5835 goto err_out;
5836 }
5837
5838 for (i = 0; i < pass->annotation_count; ++i)
5839 {
5840 param_set_magic_number(&pass->annotations[i]);
5841 hr = d3dx_parse_effect_annotation(effect, &pass->annotations[i], data, ptr, objects);
5842 if (hr != D3D_OK)
5843 {
5844 WARN("Failed to parse annotation %u\n", i);
5845 goto err_out;
5846 }
5847 }
5848 }
5849
5850 if (pass->state_count)
5851 {
5852 states = calloc(pass->state_count, sizeof(*states));
5853 if (!states)
5854 {
5855 ERR("Out of memory\n");
5856 hr = E_OUTOFMEMORY;
5857 goto err_out;
5858 }
5859
5860 for (i = 0; i < pass->state_count; ++i)
5861 {
5862 hr = d3dx_parse_state(effect, &states[i], data, ptr, objects);
5863 if (hr != D3D_OK)
5864 {
5865 WARN("Failed to parse annotation %u\n", i);
5866 goto err_out;
5867 }
5868 }
5869 }
5870
5871 pass->name = name;
5872 pass->states = states;
5873
5874 return D3D_OK;
5875
5876err_out:
5877
5878 if (pass->annotations)
5879 {
5880 for (i = 0; i < pass->annotation_count; ++i)
5881 free_parameter(&pass->annotations[i], FALSE, FALSE);
5882 free(pass->annotations);
5883 pass->annotations = NULL;
5884 }
5885
5886 if (states)
5887 {
5888 for (i = 0; i < pass->state_count; ++i)
5889 {
5890 free_state(&states[i]);
5891 }
5892 free(states);
5893 }
5894
5895 free(name);
5896
5897 return hr;
5898}
d3dx_parse_state
static HRESULT d3dx_parse_state(struct d3dx_effect *effect, struct d3dx_state *state, const char *data, const char **ptr, struct d3dx_object *objects)
Definition: effect.c:5657
free_state
static void free_state(struct d3dx_state *state)
Definition: effect.c:524
name
const char * name
Definition: effect.c:236
d3dx9_parse_name
static HRESULT d3dx9_parse_name(char **name, const char *ptr)
Definition: effect.c:5301

Referenced by d3dx_parse_effect_technique().

◆ d3dx_parse_effect_technique()

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

Definition at line 5900 of file effect.c.

5902{
5903 char *name = NULL;
5904 uint32_t offset;
5905 unsigned int i;
5906 HRESULT hr;
5907
5908 offset = read_u32(ptr);
5909 TRACE("Technique name offset: %#x.\n", offset);
5910 hr = d3dx9_parse_name(&name, data + offset);
5911 if (hr != D3D_OK)
5912 {
5913 WARN("Failed to parse name\n");
5914 goto err_out;
5915 }
5916
5917 technique->annotation_count = read_u32(ptr);
5918 TRACE("Annotation count: %u.\n", technique->annotation_count);
5919
5920 technique->pass_count = read_u32(ptr);
5921 TRACE("Pass count: %u.\n", technique->pass_count);
5922
5923 if (technique->annotation_count)
5924 {
5925 technique->annotations = calloc(technique->annotation_count, sizeof(*technique->annotations));
5926 if (!technique->annotations)
5927 {
5928 ERR("Out of memory\n");
5929 hr = E_OUTOFMEMORY;
5930 goto err_out;
5931 }
5932
5933 for (i = 0; i < technique->annotation_count; ++i)
5934 {
5935 param_set_magic_number(&technique->annotations[i]);
5936 hr = d3dx_parse_effect_annotation(effect, &technique->annotations[i], data, ptr, objects);
5937 if (hr != D3D_OK)
5938 {
5939 WARN("Failed to parse annotation %u\n", i);
5940 goto err_out;
5941 }
5942 }
5943 }
5944
5945 if (technique->pass_count)
5946 {
5947 technique->passes = calloc(technique->pass_count, sizeof(*technique->passes));
5948 if (!technique->passes)
5949 {
5950 ERR("Out of memory\n");
5951 hr = E_OUTOFMEMORY;
5952 goto err_out;
5953 }
5954
5955 for (i = 0; i < technique->pass_count; ++i)
5956 {
5957 hr = d3dx_parse_effect_pass(effect, &technique->passes[i], data, ptr, objects);
5958 if (hr != D3D_OK)
5959 {
5960 WARN("Failed to parse pass %u\n", i);
5961 goto err_out;
5962 }
5963 }
5964 }
5965
5966 technique->name = name;
5967
5968 return D3D_OK;
5969
5970err_out:
5971
5972 if (technique->passes)
5973 {
5974 for (i = 0; i < technique->pass_count; ++i)
5975 free_pass(&technique->passes[i]);
5976 free(technique->passes);
5977 technique->passes = NULL;
5978 }
5979
5980 if (technique->annotations)
5981 {
5982 for (i = 0; i < technique->annotation_count; ++i)
5983 free_parameter(&technique->annotations[i], FALSE, FALSE);
5984 free(technique->annotations);
5985 technique->annotations = NULL;
5986 }
5987
5988 free(name);
5989
5990 return hr;
5991}
d3dx_parse_effect_pass
static HRESULT d3dx_parse_effect_pass(struct d3dx_effect *effect, struct d3dx_pass *pass, const char *data, const char **ptr, struct d3dx_object *objects)
Definition: effect.c:5804
free_pass
static void free_pass(struct d3dx_pass *pass)
Definition: effect.c:647

Referenced by d3dx_parse_effect().

◆ d3dx_parse_effect_typedef()

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

Definition at line 5432 of file effect.c.

5434{
5435 uint32_t offset;
5436 HRESULT hr;
5437 UINT i;
5438
5439 param->flags = flags;
5440
5441 if (!parent)
5442 {
5443 param->type = read_u32(ptr);
5444 TRACE("Type: %s.\n", debug_d3dxparameter_type(param->type));
5445
5446 param->class = read_u32(ptr);
5447 TRACE("Class: %s.\n", debug_d3dxparameter_class(param->class));
5448
5449 offset = read_u32(ptr);
5450 TRACE("Type name offset: %#x.\n", offset);
5451 hr = d3dx9_parse_name(&param->name, data + offset);
5452 if (hr != D3D_OK)
5453 {
5454 WARN("Failed to parse name\n");
5455 goto err_out;
5456 }
5457
5458 offset = read_u32(ptr);
5459 TRACE("Type semantic offset: %#x.\n", offset);
5460 hr = d3dx9_parse_name(&param->semantic, data + offset);
5461 if (hr != D3D_OK)
5462 {
5463 WARN("Failed to parse semantic\n");
5464 goto err_out;
5465 }
5466
5467 param->element_count = read_u32(ptr);
5468 TRACE("Elements: %u.\n", param->element_count);
5469
5470 switch (param->class)
5471 {
5472 case D3DXPC_VECTOR:
5473 param->columns = read_u32(ptr);
5474 TRACE("Columns: %u.\n", param->columns);
5475
5476 param->rows = read_u32(ptr);
5477 TRACE("Rows: %u.\n", param->rows);
5478
5479 /* sizeof(DWORD) * rows * columns */
5480 param->bytes = 4 * param->rows * param->columns;
5481 break;
5482
5483 case D3DXPC_SCALAR:
5484 case D3DXPC_MATRIX_ROWS:
5485 case D3DXPC_MATRIX_COLUMNS:
5486 param->rows = read_u32(ptr);
5487 TRACE("Rows: %u.\n", param->rows);
5488
5489 param->columns = read_u32(ptr);
5490 TRACE("Columns: %u.\n", param->columns);
5491
5492 /* sizeof(DWORD) * rows * columns */
5493 param->bytes = 4 * param->rows * param->columns;
5494 break;
5495
5496 case D3DXPC_STRUCT:
5497 param->member_count = read_u32(ptr);
5498 TRACE("Members: %u.\n", param->member_count);
5499 break;
5500
5501 case D3DXPC_OBJECT:
5502 switch (param->type)
5503 {
5504 case D3DXPT_STRING:
5505 case D3DXPT_PIXELSHADER:
5506 case D3DXPT_VERTEXSHADER:
5507 case D3DXPT_TEXTURE:
5508 case D3DXPT_TEXTURE1D:
5509 case D3DXPT_TEXTURE2D:
5510 case D3DXPT_TEXTURE3D:
5511 case D3DXPT_TEXTURECUBE:
5512 param->bytes = sizeof(void *);
5513 break;
5514
5515 case D3DXPT_SAMPLER:
5516 case D3DXPT_SAMPLER1D:
5517 case D3DXPT_SAMPLER2D:
5518 case D3DXPT_SAMPLER3D:
5519 case D3DXPT_SAMPLERCUBE:
5520 param->bytes = 0;
5521 break;
5522
5523 default:
5524 FIXME("Unhandled type %s.\n", debug_d3dxparameter_type(param->type));
5525 break;
5526 }
5527 break;
5528
5529 default:
5530 FIXME("Unhandled class %s.\n", debug_d3dxparameter_class(param->class));
5531 break;
5532 }
5533 }
5534 else
5535 {
5536 /* elements */
5537 param->type = parent->type;
5538 param->class = parent->class;
5539 param->name = parent->name;
5540 param->semantic = parent->semantic;
5541 param->element_count = 0;
5542 param->member_count = parent->member_count;
5543 param->bytes = parent->bytes;
5544 param->rows = parent->rows;
5545 param->columns = parent->columns;
5546 }
5547
5548 if (param->element_count)
5549 {
5550 unsigned int param_bytes = 0;
5551 const char *save_ptr = *ptr;
5552
5553 param->members = calloc(param->element_count, sizeof(*param->members));
5554 if (!param->members)
5555 {
5556 ERR("Out of memory\n");
5557 hr = E_OUTOFMEMORY;
5558 goto err_out;
5559 }
5560
5561 for (i = 0; i < param->element_count; ++i)
5562 {
5563 *ptr = save_ptr;
5564
5565 param_set_magic_number(&param->members[i]);
5566 hr = d3dx_parse_effect_typedef(effect, &param->members[i], data, ptr, param, flags);
5567 if (hr != D3D_OK)
5568 {
5569 WARN("Failed to parse member %u\n", i);
5570 goto err_out;
5571 }
5572
5573 param_bytes += param->members[i].bytes;
5574 }
5575
5576 param->bytes = param_bytes;
5577 }
5578 else if (param->member_count)
5579 {
5580 param->members = calloc(param->member_count, sizeof(*param->members));
5581 if (!param->members)
5582 {
5583 ERR("Out of memory\n");
5584 hr = E_OUTOFMEMORY;
5585 goto err_out;
5586 }
5587
5588 for (i = 0; i < param->member_count; ++i)
5589 {
5590 param_set_magic_number(&param->members[i]);
5591 hr = d3dx_parse_effect_typedef(effect, &param->members[i], data, ptr, NULL, flags);
5592 if (hr != D3D_OK)
5593 {
5594 WARN("Failed to parse member %u\n", i);
5595 goto err_out;
5596 }
5597
5598 param->bytes += param->members[i].bytes;
5599 }
5600 }
5601 return D3D_OK;
5602
5603err_out:
5604
5605 if (param->members)
5606 {
5607 unsigned int count = param->element_count ? param->element_count : param->member_count;
5608
5609 for (i = 0; i < count; ++i)
5610 free_parameter(&param->members[i], param->element_count != 0, TRUE);
5611 free(param->members);
5612 param->members = NULL;
5613 }
5614
5615 if (!parent)
5616 {
5617 free(param->name);
5618 free(param->semantic);
5619 }
5620 param->name = NULL;
5621 param->semantic = NULL;
5622
5623 return hr;
5624}

Referenced by d3dx_parse_effect_annotation(), d3dx_parse_effect_parameter(), d3dx_parse_effect_typedef(), and d3dx_parse_state().

◆ d3dx_parse_init_value()

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

Definition at line 5252 of file effect.c.

5254{
5255 UINT size = param->bytes;
5256 HRESULT hr;
5257 void *value = NULL;
5258
5259 TRACE("param size: %u\n", size);
5260
5261 if (size)
5262 {
5263 value = calloc(1, size);
5264 if (!value)
5265 {
5266 ERR("Failed to allocate data memory.\n");
5267 return E_OUTOFMEMORY;
5268 }
5269
5270 switch(param->class)
5271 {
5272 case D3DXPC_OBJECT:
5273 break;
5274
5275 case D3DXPC_SCALAR:
5276 case D3DXPC_VECTOR:
5277 case D3DXPC_MATRIX_ROWS:
5278 case D3DXPC_MATRIX_COLUMNS:
5279 case D3DXPC_STRUCT:
5280 TRACE("Data: %s.\n", debugstr_an(ptr, size));
5281 memcpy(value, ptr, size);
5282 break;
5283
5284 default:
5285 FIXME("Unhandled class %s\n", debug_d3dxparameter_class(param->class));
5286 break;
5287 }
5288 }
5289
5290 hr = d3dx_parse_value(effect, param, value, data, &ptr, objects);
5291 if (hr != D3D_OK)
5292 {
5293 WARN("Failed to parse value\n");
5294 free(value);
5295 return hr;
5296 }
5297
5298 return D3D_OK;
5299}
d3dx_parse_value
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)
Definition: effect.c:5142

Referenced by d3dx_parse_effect_annotation(), d3dx_parse_effect_parameter(), and d3dx_parse_state().

◆ d3dx_parse_resource()

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

Definition at line 6092 of file effect.c.

6094{
6095 unsigned int index, state_index, usage, element_index, technique_index;
6096 struct d3dx_parameter *param;
6097 struct d3dx_object *object;
6098 struct d3dx_state *state;
6099 HRESULT hr = E_FAIL;
6100
6101 technique_index = read_u32(ptr);
6102 TRACE("technique_index: %u.\n", technique_index);
6103
6104 index = read_u32(ptr);
6105 TRACE("index: %u.\n", index);
6106
6107 element_index = read_u32(ptr);
6108 TRACE("element_index: %u.\n", element_index);
6109
6110 state_index = read_u32(ptr);
6111 TRACE("state_index: %u.\n", state_index);
6112
6113 usage = read_u32(ptr);
6114 TRACE("usage: %u.\n", usage);
6115
6116 if (technique_index == 0xffffffff)
6117 {
6118 struct d3dx_parameter *parameter;
6119 struct d3dx_sampler *sampler;
6120
6121 if (index >= effect->params.count)
6122 {
6123 FIXME("Index out of bounds: index %u >= parameter count %u.\n", index, effect->params.count);
6124 return E_FAIL;
6125 }
6126
6127 parameter = &effect->params.parameters[index].param;
6128 if (element_index != 0xffffffff)
6129 {
6130 if (element_index >= parameter->element_count && parameter->element_count != 0)
6131 {
6132 FIXME("Index out of bounds: element_index %u >= element_count %u.\n", element_index, parameter->element_count);
6133 return E_FAIL;
6134 }
6135
6136 if (parameter->element_count)
6137 parameter = &parameter->members[element_index];
6138 }
6139
6140 sampler = parameter->data;
6141 if (state_index >= sampler->state_count)
6142 {
6143 FIXME("Index out of bounds: state_index %u >= state_count %u.\n", state_index, sampler->state_count);
6144 return E_FAIL;
6145 }
6146
6147 state = &sampler->states[state_index];
6148 }
6149 else
6150 {
6151 struct d3dx_technique *technique;
6152 struct d3dx_pass *pass;
6153
6154 if (technique_index >= effect->technique_count)
6155 {
6156 FIXME("Index out of bounds: technique_index %u >= technique_count %u.\n", technique_index,
6157 effect->technique_count);
6158 return E_FAIL;
6159 }
6160
6161 technique = &effect->techniques[technique_index];
6162 if (index >= technique->pass_count)
6163 {
6164 FIXME("Index out of bounds: index %u >= pass_count %u.\n", index, technique->pass_count);
6165 return E_FAIL;
6166 }
6167
6168 pass = &technique->passes[index];
6169 if (state_index >= pass->state_count)
6170 {
6171 FIXME("Index out of bounds: state_index %u >= state_count %u.\n", state_index, pass->state_count);
6172 return E_FAIL;
6173 }
6174
6175 state = &pass->states[state_index];
6176 }
6177
6178 TRACE("State operation %#x (%s).\n", state->operation, state_table[state->operation].name);
6179 param = &state->parameter;
6180 TRACE("Using object id %u.\n", param->object_id);
6181 object = &effect->objects[param->object_id];
6182
6183 TRACE("Usage %u: class %s, type %s.\n", usage, debug_d3dxparameter_class(param->class),
6184 debug_d3dxparameter_type(param->type));
6185 switch (usage)
6186 {
6187 case 0:
6188 switch (param->type)
6189 {
6190 case D3DXPT_VERTEXSHADER:
6191 case D3DXPT_PIXELSHADER:
6192 state->type = ST_CONSTANT;
6193 if (FAILED(hr = d3dx9_copy_data(effect, param->object_id, ptr)))
6194 return hr;
6195
6196 if (object->data)
6197 {
6198 if (FAILED(hr = d3dx9_create_object(effect, object)))
6199 return hr;
6200 if (FAILED(hr = d3dx_create_param_eval(&effect->params, object->data, object->size, param->type,
6201 &param->param_eval, get_version_counter_ptr(effect),
6202 skip_constants, skip_constants_count)))
6203 return hr;
6204 }
6205 break;
6206
6207 case D3DXPT_BOOL:
6208 case D3DXPT_INT:
6209 case D3DXPT_FLOAT:
6210 case D3DXPT_STRING:
6211 state->type = ST_FXLC;
6212 if (FAILED(hr = d3dx9_copy_data(effect, param->object_id, ptr)))
6213 return hr;
6214 if (FAILED(hr = d3dx_create_param_eval(&effect->params, object->data, object->size, param->type,
6215 &param->param_eval, get_version_counter_ptr(effect), NULL, 0)))
6216 return hr;
6217 break;
6218
6219 default:
6220 FIXME("Unhandled type %s\n", debug_d3dxparameter_type(param->type));
6221 break;
6222 }
6223 break;
6224
6225 case 1:
6226 state->type = ST_PARAMETER;
6227 if (FAILED(hr = d3dx9_copy_data(effect, param->object_id, ptr)))
6228 return hr;
6229
6230 TRACE("Looking for parameter %s.\n", debugstr_a(object->data));
6231 state->referenced_param = get_parameter_by_name(&effect->params, NULL, object->data);
6232 if (state->referenced_param)
6233 {
6234 struct d3dx_parameter *refpar = state->referenced_param;
6235
6236 TRACE("Mapping to parameter %p, having object id %u.\n", refpar, refpar->object_id);
6237 if (refpar->type == D3DXPT_VERTEXSHADER || refpar->type == D3DXPT_PIXELSHADER)
6238 {
6239 struct d3dx_object *refobj = &effect->objects[refpar->object_id];
6240
6241 if (!refpar->param_eval)
6242 {
6243 if (FAILED(hr = d3dx_create_param_eval(&effect->params, refobj->data, refobj->size,
6244 refpar->type, &refpar->param_eval, get_version_counter_ptr(effect),
6245 skip_constants, skip_constants_count)))
6246 return hr;
6247 }
6248 }
6249 }
6250 else
6251 {
6252 FIXME("Referenced parameter %s not found.\n", (char *)object->data);
6253 return D3DXERR_INVALIDDATA;
6254 }
6255 break;
6256
6257 case 2:
6258 state->type = ST_ARRAY_SELECTOR;
6259 if (FAILED(hr = d3dx9_copy_data(effect, param->object_id, ptr)))
6260 return hr;
6261 hr = d3dx_parse_array_selector(effect, state, skip_constants, skip_constants_count);
6262 break;
6263
6264 default:
6265 FIXME("Unknown usage %u.\n", usage);
6266 break;
6267 }
6268
6269 return hr;
6270}
index
#define index(s, c)
Definition: various.h:29
d3dx_parse_array_selector
static HRESULT d3dx_parse_array_selector(struct d3dx_effect *effect, struct d3dx_state *state, const char **skip_constants, unsigned int skip_constants_count)
Definition: effect.c:6035
usage
GLsizeiptr const GLvoid GLenum usage
Definition: glext.h:5919
d3dx_object::size
unsigned int size
Definition: effect.c:108
d3dx_object::data
void * data
Definition: effect.c:109
d3dx_parameter::param_eval
struct d3dx_param_eval * param_eval
Definition: d3dx9_private.h:515
d3dx_parameter::object_id
unsigned int object_id
Definition: d3dx9_private.h:526
d3dx_parameter::type
D3DXPARAMETER_TYPE type
Definition: d3dx9_private.h:519

Referenced by d3dx_parse_effect().

◆ d3dx_parse_sampler()

static HRESULT d3dx_parse_sampler ( struct d3dx_effect *  effect,
struct d3dx_sampler *  sampler,
const char *  data,
const char **  ptr,
struct d3dx_object *  objects 
)
static

Definition at line 5102 of file effect.c.

5104{
5105 HRESULT hr;
5106 UINT i;
5107
5108 sampler->state_count = read_u32(ptr);
5109 TRACE("Count: %u\n", sampler->state_count);
5110
5111 sampler->states = calloc(sampler->state_count, sizeof(*sampler->states));
5112 if (!sampler->states)
5113 {
5114 ERR("Out of memory\n");
5115 return E_OUTOFMEMORY;
5116 }
5117
5118 for (i = 0; i < sampler->state_count; ++i)
5119 {
5120 hr = d3dx_parse_state(effect, &sampler->states[i], data, ptr, objects);
5121 if (hr != D3D_OK)
5122 {
5123 WARN("Failed to parse state %u\n", i);
5124 goto err_out;
5125 }
5126 }
5127
5128 return D3D_OK;
5129
5130err_out:
5131
5132 for (i = 0; i < sampler->state_count; ++i)
5133 {
5134 free_state(&sampler->states[i]);
5135 }
5136 free(sampler->states);
5137 sampler->states = NULL;
5138
5139 return hr;
5140}

Referenced by d3dx_parse_value().

◆ d3dx_parse_state()

static HRESULT d3dx_parse_state ( struct d3dx_effect *  effect,
struct d3dx_state *  state,
const char *  data,
const char **  ptr,
struct d3dx_object *  objects 
)
static

Definition at line 5657 of file effect.c.

5659{
5660 struct d3dx_parameter *param = &state->parameter;
5661 enum STATE_CLASS state_class;
5662 const char *ptr2;
5663 uint32_t offset;
5664 void *new_data;
5665 HRESULT hr;
5666
5667 state->type = ST_CONSTANT;
5668
5669 state->operation = read_u32(ptr);
5670 if (state->operation >= ARRAY_SIZE(state_table))
5671 {
5672 WARN("Unknown state operation %u.\n", state->operation);
5673 return D3DERR_INVALIDCALL;
5674 }
5675 TRACE("Operation: %#x (%s).\n", state->operation, state_table[state->operation].name);
5676
5677 state->index = read_u32(ptr);
5678 TRACE("Index: %#x.\n", state->index);
5679
5680 offset = read_u32(ptr);
5681 TRACE("Typedef offset: %#x.\n", offset);
5682 ptr2 = data + offset;
5683 hr = d3dx_parse_effect_typedef(effect, param, data, &ptr2, NULL, 0);
5684 if (hr != D3D_OK)
5685 {
5686 WARN("Failed to parse type definition\n");
5687 goto err_out;
5688 }
5689
5690 offset = read_u32(ptr);
5691 TRACE("Value offset: %#x.\n", offset);
5692 hr = d3dx_parse_init_value(effect, param, data, data + offset, objects);
5693 if (hr != D3D_OK)
5694 {
5695 WARN("Failed to parse value\n");
5696 goto err_out;
5697 }
5698
5699 if (((state_class = state_table[state->operation].class) == SC_VERTEXSHADER
5700 || state_class == SC_PIXELSHADER || state_class == SC_TEXTURE)
5701 && param->bytes < sizeof(void *))
5702 {
5703 if (param->type != D3DXPT_INT || *(unsigned int *)param->data)
5704 {
5705 FIXME("Unexpected parameter for object, param->type %#x, param->class %#x, *param->data %#x.\n",
5706 param->type, param->class, *(unsigned int *)param->data);
5707 hr = D3DXERR_INVALIDDATA;
5708 goto err_out;
5709 }
5710
5711 new_data = realloc(param->data, sizeof(void *));
5712 if (!new_data)
5713 {
5714 ERR("Out of memory.\n");
5715 hr = E_OUTOFMEMORY;
5716 goto err_out;
5717 }
5718 memset(new_data, 0, sizeof(void *));
5719 param->data = new_data;
5720 param->bytes = sizeof(void *);
5721 }
5722
5723 return D3D_OK;
5724
5725err_out:
5726
5727 free_parameter(param, FALSE, FALSE);
5728
5729 return hr;
5730}
STATE_CLASS
STATE_CLASS
Definition: effect.c:44

Referenced by d3dx_parse_effect_pass(), and d3dx_parse_sampler().

◆ d3dx_parse_value()

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

Definition at line 5142 of file effect.c.

5144{
5145 unsigned int i;
5146 HRESULT hr;
5147 UINT old_size = 0;
5148
5149 if (param->element_count)
5150 {
5151 param->data = value;
5152
5153 for (i = 0; i < param->element_count; ++i)
5154 {
5155 struct d3dx_parameter *member = &param->members[i];
5156
5157 hr = d3dx_parse_value(effect, member, value ? (char *)value + old_size : NULL, data, ptr, objects);
5158 if (hr != D3D_OK)
5159 {
5160 WARN("Failed to parse value %u\n", i);
5161 return hr;
5162 }
5163
5164 old_size += member->bytes;
5165 }
5166
5167 return D3D_OK;
5168 }
5169
5170 switch(param->class)
5171 {
5172 case D3DXPC_SCALAR:
5173 case D3DXPC_VECTOR:
5174 case D3DXPC_MATRIX_ROWS:
5175 case D3DXPC_MATRIX_COLUMNS:
5176 param->data = value;
5177 break;
5178
5179 case D3DXPC_STRUCT:
5180 param->data = value;
5181
5182 for (i = 0; i < param->member_count; ++i)
5183 {
5184 struct d3dx_parameter *member = &param->members[i];
5185
5186 hr = d3dx_parse_value(effect, member, (char *)value + old_size, data, ptr, objects);
5187 if (hr != D3D_OK)
5188 {
5189 WARN("Failed to parse value %u\n", i);
5190 return hr;
5191 }
5192
5193 old_size += member->bytes;
5194 }
5195 break;
5196
5197 case D3DXPC_OBJECT:
5198 switch (param->type)
5199 {
5200 case D3DXPT_STRING:
5201 case D3DXPT_TEXTURE:
5202 case D3DXPT_TEXTURE1D:
5203 case D3DXPT_TEXTURE2D:
5204 case D3DXPT_TEXTURE3D:
5205 case D3DXPT_TEXTURECUBE:
5206 case D3DXPT_PIXELSHADER:
5207 case D3DXPT_VERTEXSHADER:
5208 param->object_id = read_u32(ptr);
5209 TRACE("Id: %u\n", param->object_id);
5210 objects[param->object_id].param = param;
5211 param->data = value;
5212 break;
5213
5214 case D3DXPT_SAMPLER:
5215 case D3DXPT_SAMPLER1D:
5216 case D3DXPT_SAMPLER2D:
5217 case D3DXPT_SAMPLER3D:
5218 case D3DXPT_SAMPLERCUBE:
5219 {
5220 struct d3dx_sampler *sampler;
5221
5222 sampler = calloc(1, sizeof(*sampler));
5223 if (!sampler)
5224 return E_OUTOFMEMORY;
5225
5226 hr = d3dx_parse_sampler(effect, sampler, data, ptr, objects);
5227 if (hr != D3D_OK)
5228 {
5229 free(sampler);
5230 WARN("Failed to parse sampler\n");
5231 return hr;
5232 }
5233
5234 param->data = sampler;
5235 break;
5236 }
5237
5238 default:
5239 FIXME("Unhandled type %s\n", debug_d3dxparameter_type(param->type));
5240 break;
5241 }
5242 break;
5243
5244 default:
5245 FIXME("Unhandled class %s\n", debug_d3dxparameter_class(param->class));
5246 break;
5247 }
5248
5249 return D3D_OK;
5250}
d3dx_parse_sampler
static HRESULT d3dx_parse_sampler(struct d3dx_effect *effect, struct d3dx_sampler *sampler, const char *data, const char **ptr, struct d3dx_object *objects)
Definition: effect.c:5102
old_size
size_t const old_size
Definition: expand.cpp:65

Referenced by d3dx_parse_init_value(), and d3dx_parse_value().

◆ d3dx_pool_release_shared_parameter()

static void d3dx_pool_release_shared_parameter ( struct d3dx_top_level_parameter *  param)
static

Definition at line 1917 of file effect.c.

1918{
1919 unsigned int new_count;
1920
1921 if (!(param->param.flags & PARAMETER_FLAG_SHARED) || !param->shared_data)
1922 return;
1923 new_count = --param->shared_data->count;
1924
1925 TRACE("param %p, param->shared_data %p, new_count %d.\n", param, param->shared_data, new_count);
1926
1927 if (new_count)
1928 {
1929 unsigned int i;
1930
1931 for (i = 0; i < new_count; ++i)
1932 {
1933 if (param->shared_data->parameters[i] == param)
1934 {
1935 memmove(&param->shared_data->parameters[i],
1936 &param->shared_data->parameters[i + 1],
1937 sizeof(param->shared_data->parameters[i]) * (new_count - i));
1938 break;
1939 }
1940 }
1941 walk_parameter_tree(&param->param, param_zero_data_func, NULL);
1942 }
1943 else
1944 {
1945 free(param->shared_data->parameters);
1946 /* Zeroing table size is required as the entry in pool parameters table can be reused. */
1947 param->shared_data->size = 0;
1948 param->shared_data = NULL;
1949 }
1950}
param_zero_data_func
static BOOL param_zero_data_func(void *dummy, struct d3dx_parameter *param)
Definition: effect.c:1911
memmove
#define memmove(s1, s2, n)
Definition: mkisofs.h:881

Referenced by free_top_level_parameter().

◆ d3dx_pool_sync_shared_parameter()

static HRESULT d3dx_pool_sync_shared_parameter ( struct d3dx_effect_pool *  pool,
struct d3dx_top_level_parameter *  param 
)
static

Definition at line 1831 of file effect.c.

1832{
1833 unsigned int i, free_entry_index;
1834 unsigned int new_size, new_count;
1835
1836 if (!(param->param.flags & PARAMETER_FLAG_SHARED) || !pool || is_param_type_sampler(param->param.type))
1837 return D3D_OK;
1838
1839 free_entry_index = pool->size;
1840 for (i = 0; i < pool->size; ++i)
1841 {
1842 if (!pool->shared_data[i].count)
1843 free_entry_index = i;
1844 else if (is_same_parameter(&param->param, &pool->shared_data[i].parameters[0]->param))
1845 break;
1846 }
1847 if (i == pool->size)
1848 {
1849 i = free_entry_index;
1850 if (i == pool->size)
1851 {
1852 struct d3dx_shared_data *new_alloc;
1853
1854 if (!pool->size)
1855 {
1856 new_size = INITIAL_POOL_SIZE;
1857 new_alloc = calloc(new_size, sizeof(*pool->shared_data));
1858 if (!new_alloc)
1859 goto oom;
1860 }
1861 else
1862 {
1863 new_size = pool->size * 2;
1864 new_alloc = _recalloc(pool->shared_data, new_size, sizeof(*pool->shared_data));
1865 if (!new_alloc)
1866 goto oom;
1867 if (new_alloc != pool->shared_data)
1868 {
1869 unsigned int j, k;
1870
1871 for (j = 0; j < pool->size; ++j)
1872 for (k = 0; k < new_alloc[j].count; ++k)
1873 new_alloc[j].parameters[k]->shared_data = &new_alloc[j];
1874 }
1875 }
1876 pool->shared_data = new_alloc;
1877 pool->size = new_size;
1878 }
1879 pool->shared_data[i].data = param->param.data;
1880 }
1881 else
1882 {
1883 param_set_data_pointer(&param->param, pool->shared_data[i].data, FALSE, TRUE);
1884 }
1885 new_count = ++pool->shared_data[i].count;
1886 if (new_count >= pool->shared_data[i].size)
1887 {
1888 struct d3dx_top_level_parameter **new_alloc;
1889
1890 new_size = pool->shared_data[i].size ? pool->shared_data[i].size * 2 : INITIAL_SHARED_DATA_SIZE;
1891 new_alloc = _recalloc(pool->shared_data[i].parameters, new_size, sizeof(*pool->shared_data[i].parameters));
1892 if (!new_alloc)
1893 goto oom;
1894 pool->shared_data[i].parameters = new_alloc;
1895 pool->shared_data[i].size = new_size;
1896 }
1897
1898 param->shared_data = &pool->shared_data[i];
1899 pool->shared_data[i].parameters[new_count - 1] = param;
1900
1901 TRACE("name %s, parameter idx %u, new refcount %u.\n", debugstr_a(param->param.name), i,
1902 new_count);
1903
1904 return D3D_OK;
1905
1906oom:
1907 ERR("Out of memory.\n");
1908 return E_OUTOFMEMORY;
1909}
INITIAL_SHARED_DATA_SIZE
#define INITIAL_SHARED_DATA_SIZE
Definition: effect.c:204
is_same_parameter
static BOOL is_same_parameter(void *param1_, struct d3dx_parameter *param2)
Definition: effect.c:1807
param_set_data_pointer
static void param_set_data_pointer(struct d3dx_parameter *param, unsigned char *data, BOOL child, BOOL free_data)
Definition: effect.c:1790
INITIAL_POOL_SIZE
#define INITIAL_POOL_SIZE
Definition: effect.c:38
_recalloc
_ACRTIMP void *__cdecl _recalloc(void *, size_t, size_t) __WINE_ALLOC_SIZE(2
new_size
size_t const new_size
Definition: expand.cpp:66
parameters
static BYTE parameters[]
Definition: asn.c:558
d3dx_shared_data
Definition: d3dx9_private.h:546
d3dx_shared_data::count
unsigned int count
Definition: d3dx9_private.h:549

Referenced by d3dx_parse_effect().

◆ d3dx_set_shader_const_state()

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

Definition at line 1467 of file effect.c.

1469{
1470 static const struct
1471 {
1472 D3DXPARAMETER_TYPE type;
1473 UINT elem_size;
1474 const char *name;
1475 }
1476 const_tbl[] =
1477 {
1478 {D3DXPT_FLOAT, sizeof(float) * 4, "SCT_VSFLOAT"},
1479 {D3DXPT_BOOL, sizeof(BOOL), "SCT_VSBOOL"},
1480 {D3DXPT_INT, sizeof(int) * 4, "SCT_VSINT"},
1481 {D3DXPT_FLOAT, sizeof(float) * 4, "SCT_PSFLOAT"},
1482 {D3DXPT_BOOL, sizeof(BOOL), "SCT_PSBOOL"},
1483 {D3DXPT_INT, sizeof(int) * 4, "SCT_PSINT"},
1484 };
1485
1486 BOOL is_heap_buffer = FALSE;
1487 unsigned int element_count;
1488 void *buffer = value_ptr;
1489 D3DXVECTOR4 value;
1490 HRESULT ret;
1491
1492 assert(op < ARRAY_SIZE(const_tbl));
1493 element_count = param->bytes / const_tbl[op].elem_size;
1494 TRACE("%s, index %u, element_count %u.\n", const_tbl[op].name, index, element_count);
1495 if (param->type != const_tbl[op].type)
1496 {
1497 FIXME("Unexpected param type %u.\n", param->type);
1498 return D3DERR_INVALIDCALL;
1499 }
1500
1501 if (param->bytes % const_tbl[op].elem_size || element_count > 1)
1502 {
1503 unsigned int param_data_size;
1504
1505 TRACE("Parameter size %u, rows %u, cols %u.\n", param->bytes, param->rows, param->columns);
1506
1507 if (param->bytes % const_tbl[op].elem_size)
1508 ++element_count;
1509 if (element_count > 1)
1510 {
1511 WARN("Setting %u elements.\n", element_count);
1512 buffer = calloc(element_count, const_tbl[op].elem_size);
1513 if (!buffer)
1514 {
1515 ERR("Out of memory.\n");
1516 return E_OUTOFMEMORY;
1517 }
1518 is_heap_buffer = TRUE;
1519 }
1520 else
1521 {
1522 assert(const_tbl[op].elem_size <= sizeof(value));
1523 buffer = &value;
1524 }
1525 param_data_size = min(param->bytes, const_tbl[op].elem_size);
1526 memcpy(buffer, value_ptr, param_data_size);
1527 }
1528
1529 switch (op)
1530 {
1531 case SCT_VSFLOAT:
1532 ret = SET_D3D_STATE(effect, SetVertexShaderConstantF, index, (const float *)buffer, element_count);
1533 break;
1534 case SCT_VSBOOL:
1535 ret = SET_D3D_STATE(effect, SetVertexShaderConstantB, index, (const BOOL *)buffer, element_count);
1536 break;
1537 case SCT_VSINT:
1538 ret = SET_D3D_STATE(effect, SetVertexShaderConstantI, index, (const int *)buffer, element_count);
1539 break;
1540 case SCT_PSFLOAT:
1541 ret = SET_D3D_STATE(effect, SetPixelShaderConstantF, index, (const float *)buffer, element_count);
1542 break;
1543 case SCT_PSBOOL:
1544 ret = SET_D3D_STATE(effect, SetPixelShaderConstantB, index, (const BOOL *)buffer, element_count);
1545 break;
1546 case SCT_PSINT:
1547 ret = SET_D3D_STATE(effect, SetPixelShaderConstantI, index, (const int *)buffer, element_count);
1548 break;
1549 default:
1550 ret = D3DERR_INVALIDCALL;
1551 break;
1552 }
1553
1554 if (is_heap_buffer)
1555 free(buffer);
1556
1557 return ret;
1558}
float
static float(WINAPI *pD2D1Tan)(float angle)
D3DXPARAMETER_TYPE
D3DXPARAMETER_TYPE
Definition: d3dx9shader.h:72
type
GLuint GLuint GLsizei GLenum type
Definition: gl.h:1545
buffer
GLuint buffer
Definition: glext.h:5915
BOOL
#define BOOL
Definition: nt_native.h:43

Referenced by d3dx9_apply_state().

◆ d3dx_set_shader_constants()

static HRESULT d3dx_set_shader_constants ( struct d3dx_effect *  effect,
struct d3dx_pass *  pass,
struct d3dx_parameter *  param,
BOOL  vs,
BOOL  update_all 
)
static

Definition at line 1563 of file effect.c.

1565{
1566 HRESULT hr, ret;
1567 struct d3dx_parameter **params;
1568 D3DXCONSTANT_DESC *cdesc;
1569 unsigned int parameters_count;
1570 unsigned int i, j;
1571
1572 if (!param->param_eval)
1573 {
1574 FIXME("param_eval structure is null.\n");
1575 return D3DERR_INVALIDCALL;
1576 }
1577 if (FAILED(hr = d3dx_param_eval_set_shader_constants(effect->manager, effect->device,
1578 param->param_eval, update_all)))
1579 return hr;
1580 params = param->param_eval->shader_inputs.inputs_param;
1581 cdesc = param->param_eval->shader_inputs.inputs;
1582 parameters_count = param->param_eval->shader_inputs.input_count;
1583 ret = D3D_OK;
1584 for (i = 0; i < parameters_count; ++i)
1585 {
1586 if (params[i] && params[i]->class == D3DXPC_OBJECT && is_param_type_sampler(params[i]->type))
1587 {
1588 struct d3dx_sampler *sampler;
1589 unsigned int sampler_idx;
1590
1591 for (sampler_idx = 0; sampler_idx < cdesc[i].RegisterCount; ++sampler_idx)
1592 {
1593 sampler = params[i]->element_count ? params[i]->members[sampler_idx].data : params[i]->data;
1594 TRACE("sampler %s, register index %u, state count %u.\n", debugstr_a(params[i]->name),
1595 cdesc[i].RegisterIndex, sampler->state_count);
1596 for (j = 0; j < sampler->state_count; ++j)
1597 {
1598 if (FAILED(hr = d3dx9_apply_state(effect, pass, &sampler->states[j],
1599 cdesc[i].RegisterIndex + sampler_idx + (vs ? D3DVERTEXTEXTURESAMPLER0 : 0),
1600 update_all)))
1601 ret = hr;
1602 }
1603 }
1604 }
1605 }
1606 return ret;
1607}
D3DVERTEXTEXTURESAMPLER0
#define D3DVERTEXTEXTURESAMPLER0
Definition: d3d9types.h:202
d3dx_param_eval_set_shader_constants
HRESULT d3dx_param_eval_set_shader_constants(ID3DXEffectStateManager *manager, struct IDirect3DDevice9 *device, struct d3dx_param_eval *peval, BOOL update_all)
Definition: preshader.c:1755
vs
static vector_t * vs
Definition: server.c:146
_D3DXCONSTANT_DESC
Definition: d3dx9shader.h:104
_D3DXCONSTANT_DESC::RegisterCount
UINT RegisterCount
Definition: d3dx9shader.h:108

Referenced by d3dx9_apply_state().

◆ D3DXCreateEffect()

HRESULT WINAPI D3DXCreateEffect ( struct IDirect3DDevice9 *  device,
const void *  data,
UINT  data_size,
const D3DXMACRO *  defines,
struct ID3DXInclude *  include,
DWORD  flags,
struct ID3DXEffectPool *  pool,
struct ID3DXEffect **  effect,
struct ID3DXBuffer **  messages 
)

Definition at line 6729 of file effect.c.

6732{
6733 TRACE("device %p, data %p, data_size %u, defines %p, include %p, flags %#lx, pool %p, "
6734 "effect %p, messages %p.\n", device, data, data_size, defines,
6735 include, flags, pool, effect, messages);
6736
6737 return D3DXCreateEffectEx(device, data, data_size, defines, include, NULL, flags, pool, effect, messages);
6738}
D3DXCreateEffectEx
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)
Definition: effect.c:6685

Referenced by test_create_effect_and_pool(), test_cross_effect_handle(), test_effect_clone(), test_effect_commitchanges(), test_effect_compilation_errors(), test_effect_get_pass_desc(), test_effect_isparameterused(), test_effect_large_address_aware_flag(), test_effect_out_of_bounds_selector(), test_effect_parameter_block(), test_effect_parameter_value(), test_effect_preshader(), test_effect_preshader_ops(), test_effect_preshader_relative_addressing(), test_effect_setvalue_object(), test_effect_shared_parameters(), test_effect_state_manager(), test_effect_states(), test_effect_variable_names(), and test_refcount().

◆ D3DXCreateEffectCompiler()

HRESULT WINAPI D3DXCreateEffectCompiler ( const char *  data,
UINT  data_size,
const D3DXMACRO *  defines,
ID3DXInclude *  include,
DWORD  flags,
ID3DXEffectCompiler **  compiler,
ID3DXBuffer **  messages 
)

Definition at line 6755 of file effect.c.

6757{
6758 struct ID3DXEffectCompilerImpl *object;
6759 HRESULT hr;
6760
6761 TRACE("data %p, data_size %u, defines %p, include %p, flags %#lx, compiler %p, messages %p.\n",
6762 data, data_size, defines, include, flags, compiler, messages);
6763
6764 if (!data || !compiler)
6765 {
6766 WARN("Invalid arguments supplied\n");
6767 return D3DERR_INVALIDCALL;
6768 }
6769
6770 object = calloc(1, sizeof(*object));
6771 if (!object)
6772 return E_OUTOFMEMORY;
6773
6774 hr = d3dx9_effect_compiler_init(object, data, data_size, (const D3D_SHADER_MACRO *)defines,
6775 (ID3DInclude *)include, flags, (ID3DBlob **)messages);
6776 if (FAILED(hr))
6777 {
6778 WARN("Failed to initialize effect compiler\n");
6779 free(object);
6780 return hr;
6781 }
6782
6783 *compiler = &object->ID3DXEffectCompiler_iface;
6784
6785 TRACE("Created ID3DXEffectCompiler %p\n", object);
6786
6787 return D3D_OK;
6788}
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 **messages)
Definition: effect.c:6740
_D3D_SHADER_MACRO
Definition: d3dcommon.idl:23

Referenced by D3DXCreateEffectCompilerFromFileW(), D3DXCreateEffectCompilerFromResourceA(), D3DXCreateEffectCompilerFromResourceW(), and test_create_effect_compiler().

◆ D3DXCreateEffectCompilerFromFileA()

HRESULT WINAPI D3DXCreateEffectCompilerFromFileA ( const char *  srcfile,
const D3DXMACRO *  defines,
ID3DXInclude *  include,
DWORD  flags,
ID3DXEffectCompiler **  compiler,
ID3DXBuffer **  messages 
)

Definition at line 7083 of file effect.c.

7085{
7086 WCHAR *srcfileW;
7087 HRESULT ret;
7088 DWORD len;
7089
7090 TRACE("srcfile %s, defines %p, include %p, flags %#lx, compiler %p, messages %p.\n",
7091 debugstr_a(srcfile), defines, include, flags, compiler, messages);
7092
7093 if (!srcfile)
7094 return D3DERR_INVALIDCALL;
7095
7096 len = MultiByteToWideChar(CP_ACP, 0, srcfile, -1, NULL, 0);
7097 srcfileW = malloc(len * sizeof(*srcfileW));
7098 MultiByteToWideChar(CP_ACP, 0, srcfile, -1, srcfileW, len);
7099
7100 ret = D3DXCreateEffectCompilerFromFileW(srcfileW, defines, include, flags, compiler, messages);
7101 free(srcfileW);
7102
7103 return ret;
7104}
D3DXCreateEffectCompilerFromFileW
HRESULT WINAPI D3DXCreateEffectCompilerFromFileW(const WCHAR *srcfile, const D3DXMACRO *defines, ID3DXInclude *include, DWORD flags, ID3DXEffectCompiler **compiler, ID3DXBuffer **messages)
Definition: effect.c:7059
CP_ACP
#define CP_ACP
Definition: compat.h:109
MultiByteToWideChar
#define MultiByteToWideChar
Definition: compat.h:110
WCHAR
short WCHAR
Definition: pedump.c:58

◆ D3DXCreateEffectCompilerFromFileW()

HRESULT WINAPI D3DXCreateEffectCompilerFromFileW ( const WCHAR *  srcfile,
const D3DXMACRO *  defines,
ID3DXInclude *  include,
DWORD  flags,
ID3DXEffectCompiler **  compiler,
ID3DXBuffer **  messages 
)

Definition at line 7059 of file effect.c.

7061{
7062 void *buffer;
7063 HRESULT ret;
7064 DWORD size;
7065
7066 TRACE("srcfile %s, defines %p, include %p, flags %#lx, compiler %p, messages %p.\n",
7067 debugstr_w(srcfile), defines, include, flags, compiler, messages);
7068
7069 if (!srcfile)
7070 return D3DERR_INVALIDCALL;
7071
7072 ret = map_view_of_file(srcfile, &buffer, &size);
7073
7074 if (FAILED(ret))
7075 return D3DXERR_INVALIDDATA;
7076
7077 ret = D3DXCreateEffectCompiler(buffer, size, defines, include, flags, compiler, messages);
7078 UnmapViewOfFile(buffer);
7079
7080 return ret;
7081}
map_view_of_file
HRESULT map_view_of_file(const WCHAR *filename, void **buffer, DWORD *length)
Definition: util.c:211
D3DXCreateEffectCompiler
HRESULT WINAPI D3DXCreateEffectCompiler(const char *data, UINT data_size, const D3DXMACRO *defines, ID3DXInclude *include, DWORD flags, ID3DXEffectCompiler **compiler, ID3DXBuffer **messages)
Definition: effect.c:6755
UnmapViewOfFile
#define UnmapViewOfFile
Definition: compat.h:746
debugstr_w
#define debugstr_w
Definition: kernel32.h:32

Referenced by D3DXCreateEffectCompilerFromFileA().

◆ D3DXCreateEffectCompilerFromResourceA()

HRESULT WINAPI D3DXCreateEffectCompilerFromResourceA ( HMODULE  srcmodule,
const char *  srcresource,
const D3DXMACRO *  defines,
ID3DXInclude *  include,
DWORD  flags,
ID3DXEffectCompiler **  compiler,
ID3DXBuffer **  messages 
)

Definition at line 7106 of file effect.c.

7109{
7110 HRSRC resinfo;
7111 void *buffer;
7112 DWORD size;
7113
7114 TRACE("srcmodule %p, srcresource %s, defines %p, include %p, flags %#lx, compiler %p, messages %p.\n",
7115 srcmodule, debugstr_a(srcresource), defines, include, flags, compiler, messages);
7116
7117 if (!(resinfo = FindResourceA(srcmodule, srcresource, (const char *)RT_RCDATA)))
7118 return D3DXERR_INVALIDDATA;
7119
7120 if (FAILED(load_resource_into_memory(srcmodule, resinfo, &buffer, &size)))
7121 return D3DXERR_INVALIDDATA;
7122
7123 return D3DXCreateEffectCompiler(buffer, size, defines, include, flags, compiler, messages);
7124}
load_resource_into_memory
HRESULT load_resource_into_memory(HMODULE module, HRSRC resinfo, void **buffer, DWORD *length)
Definition: util.c:261
FindResourceA
HRSRC WINAPI FindResourceA(HMODULE hModule, LPCSTR name, LPCSTR type)
Definition: res.c:155
RT_RCDATA
#define RT_RCDATA
Definition: pedump.c:372

◆ D3DXCreateEffectCompilerFromResourceW()

HRESULT WINAPI D3DXCreateEffectCompilerFromResourceW ( HMODULE  srcmodule,
const WCHAR *  srcresource,
const D3DXMACRO *  defines,
ID3DXInclude *  include,
DWORD  flags,
ID3DXEffectCompiler **  compiler,
ID3DXBuffer **  messages 
)

Definition at line 7126 of file effect.c.

7129{
7130 HRSRC resinfo;
7131 void *buffer;
7132 DWORD size;
7133
7134 TRACE("srcmodule %p, srcresource %s, defines %p, include %p, flags %#lx, compiler %p, messages %p.\n",
7135 srcmodule, debugstr_w(srcresource), defines, include, flags, compiler, messages);
7136
7137 if (!(resinfo = FindResourceW(srcmodule, srcresource, (const WCHAR *)RT_RCDATA)))
7138 return D3DXERR_INVALIDDATA;
7139
7140 if (FAILED(load_resource_into_memory(srcmodule, resinfo, &buffer, &size)))
7141 return D3DXERR_INVALIDDATA;
7142
7143 return D3DXCreateEffectCompiler(buffer, size, defines, include, flags, compiler, messages);
7144}
FindResourceW
HRSRC WINAPI FindResourceW(HINSTANCE hModule, LPCWSTR name, LPCWSTR type)
Definition: res.c:176

◆ D3DXCreateEffectEx()

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 
)

Definition at line 6685 of file effect.c.

6688{
6689 struct d3dx_effect *object;
6690 HRESULT hr;
6691
6692 TRACE("device %p, srcdata %p, srcdatalen %u, defines %p, include %p, "
6693 "skip_constants %p, flags %#lx, pool %p, effect %p, compilation_errors %p.\n",
6694 device, srcdata, srcdatalen, defines, include,
6695 skip_constants, flags, pool, effect, compilation_errors);
6696
6697 if (compilation_errors)
6698 *compilation_errors = NULL;
6699
6700 if (!device || !srcdata)
6701 return D3DERR_INVALIDCALL;
6702
6703 if (!srcdatalen)
6704 return E_FAIL;
6705
6706 /* Native dll allows effect to be null so just return D3D_OK after doing basic checks */
6707 if (!effect)
6708 return D3D_OK;
6709
6710 object = calloc(1, sizeof(*object));
6711 if (!object)
6712 return E_OUTOFMEMORY;
6713
6714 hr = d3dx9_effect_init(object, device, srcdata, srcdatalen, (const D3D_SHADER_MACRO *)defines,
6715 (ID3DInclude *)include, flags, (ID3DBlob **)compilation_errors, pool, skip_constants);
6716 if (FAILED(hr))
6717 {
6718 WARN("Failed to create effect object, hr %#lx.\n", hr);
6719 return hr;
6720 }
6721
6722 *effect = &object->ID3DXEffect_iface;
6723
6724 TRACE("Created ID3DXEffect %p\n", object);
6725
6726 return D3D_OK;
6727}
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 flags, ID3DBlob **errors, struct ID3DXEffectPool *pool, const char *skip_constants_string)
Definition: effect.c:6613

Referenced by D3DXCreateEffect(), D3DXCreateEffectFromFileExW(), D3DXCreateEffectFromResourceExA(), D3DXCreateEffectFromResourceExW(), test_effect_clone(), test_effect_find_next_valid_technique(), test_effect_null_shader(), test_effect_skip_constants(), and test_effect_unsupported_shader().

◆ D3DXCreateEffectFromFileA()

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 **  messages 
)

Definition at line 6979 of file effect.c.

6982{
6983 TRACE("(void): relay\n");
6984 return D3DXCreateEffectFromFileExA(device, srcfile, defines, include, NULL, flags, pool,
6985 effect, messages);
6986}
D3DXCreateEffectFromFileExA
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 **messages)
Definition: effect.c:6944

◆ D3DXCreateEffectFromFileExA()

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 **  messages 
)

Definition at line 6944 of file effect.c.

6947{
6948 WCHAR *srcfileW;
6949 HRESULT ret;
6950 DWORD len;
6951
6952 TRACE("device %p, srcfile %s, defines %p, include %p, skipconstants %s, "
6953 "flags %#lx, pool %p, effect %p, messages %p.\n",
6954 device, debugstr_a(srcfile), defines, include, debugstr_a(skipconstants),
6955 flags, pool, effect, messages);
6956
6957 if (!srcfile)
6958 return D3DERR_INVALIDCALL;
6959
6960 len = MultiByteToWideChar(CP_ACP, 0, srcfile, -1, NULL, 0);
6961 srcfileW = malloc(len * sizeof(*srcfileW));
6962 MultiByteToWideChar(CP_ACP, 0, srcfile, -1, srcfileW, len);
6963
6964 ret = D3DXCreateEffectFromFileExW(device, srcfileW, defines, include, skipconstants, flags, pool, effect, messages);
6965 free(srcfileW);
6966
6967 return ret;
6968}
D3DXCreateEffectFromFileExW
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 **messages)
Definition: effect.c:6896

Referenced by D3DXCreateEffectFromFileA().

◆ D3DXCreateEffectFromFileExW()

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 **  messages 
)

Definition at line 6896 of file effect.c.

6899{
6900 struct d3dx_include_from_file include_from_file;
6901 const void *buffer;
6902 unsigned int size;
6903 char *filename_a;
6904 HRESULT ret;
6905
6906 TRACE("device %p, srcfile %s, defines %p, include %p, skipconstants %s, "
6907 "flags %#lx, pool %p, effect %p, messages %p.\n",
6908 device, debugstr_w(srcfile), defines, include, debugstr_a(skipconstants),
6909 flags, pool, effect, messages);
6910
6911 if (!device || !srcfile)
6912 return D3DERR_INVALIDCALL;
6913
6914 if (!include)
6915 {
6916 include_from_file.ID3DXInclude_iface.lpVtbl = &d3dx_include_from_file_vtbl;
6917 include = &include_from_file.ID3DXInclude_iface;
6918 }
6919
6920 size = WideCharToMultiByte(CP_ACP, 0, srcfile, -1, NULL, 0, NULL, NULL);
6921 filename_a = malloc(size);
6922 if (!filename_a)
6923 return E_OUTOFMEMORY;
6924 WideCharToMultiByte(CP_ACP, 0, srcfile, -1, filename_a, size, NULL, NULL);
6925
6926 EnterCriticalSection(&from_file_mutex);
6927 ret = ID3DXInclude_Open(include, D3DXINC_LOCAL, filename_a, NULL, &buffer, &size);
6928 if (FAILED(ret))
6929 {
6930 LeaveCriticalSection(&from_file_mutex);
6931 free(filename_a);
6932 return D3DXERR_INVALIDDATA;
6933 }
6934
6935 ret = D3DXCreateEffectEx(device, buffer, size, defines, include, skipconstants, flags, pool,
6936 effect, messages);
6937
6938 ID3DXInclude_Close(include, buffer);
6939 LeaveCriticalSection(&from_file_mutex);
6940 free(filename_a);
6941 return ret;
6942}
from_file_mutex
CRITICAL_SECTION from_file_mutex
Definition: shader.c:242
d3dx_include_from_file_vtbl
const struct ID3DXIncludeVtbl d3dx_include_from_file_vtbl
Definition: shader.c:328
WideCharToMultiByte
#define WideCharToMultiByte
Definition: compat.h:111
D3DXINC_LOCAL
@ D3DXINC_LOCAL
Definition: d3dx9shader.h:288
ID3DXInclude_Close
#define ID3DXInclude_Close(p, a)
Definition: d3dx9shader.h:304
ID3DXInclude_Open
#define ID3DXInclude_Open(p, a, b, c, d, e)
Definition: d3dx9shader.h:303
d3dx_include_from_file
Definition: d3dx9_private.h:232
LeaveCriticalSection
void WINAPI LeaveCriticalSection(LPCRITICAL_SECTION)
EnterCriticalSection
void WINAPI EnterCriticalSection(LPCRITICAL_SECTION)

Referenced by D3DXCreateEffectFromFileExA(), D3DXCreateEffectFromFileW(), and test_create_effect_from_file().

◆ D3DXCreateEffectFromFileW()

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 **  messages 
)

Definition at line 6970 of file effect.c.

6973{
6974 TRACE("(void): relay\n");
6975 return D3DXCreateEffectFromFileExW(device, srcfile, defines, include, NULL, flags, pool,
6976 effect, messages);
6977}

◆ D3DXCreateEffectFromResourceA()

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 **  messages 
)

Definition at line 7050 of file effect.c.

7053{
7054 TRACE("(void): relay\n");
7055 return D3DXCreateEffectFromResourceExA(device, srcmodule, srcresource, defines, include, NULL,
7056 flags, pool, effect, messages);
7057}
D3DXCreateEffectFromResourceExA
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 **messages)
Definition: effect.c:7014

◆ D3DXCreateEffectFromResourceExA()

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 **  messages 
)

Definition at line 7014 of file effect.c.

7018{
7019 HRSRC resinfo;
7020 void *buffer;
7021 DWORD size;
7022
7023 TRACE("device %p, srcmodule %p, srcresource %s, defines %p, include %p, skipconstants %s, "
7024 "flags %#lx, pool %p, effect %p, messages %p.\n",
7025 device, srcmodule, debugstr_a(srcresource), defines, include, debugstr_a(skipconstants),
7026 flags, pool, effect, messages);
7027
7028 if (!device)
7029 return D3DERR_INVALIDCALL;
7030
7031 if (!(resinfo = FindResourceA(srcmodule, srcresource, (const char *)RT_RCDATA)))
7032 return D3DXERR_INVALIDDATA;
7033
7034 if (FAILED(load_resource_into_memory(srcmodule, resinfo, &buffer, &size)))
7035 return D3DXERR_INVALIDDATA;
7036
7037 return D3DXCreateEffectEx(device, buffer, size, defines, include,
7038 skipconstants, flags, pool, effect, messages);
7039}

Referenced by D3DXCreateEffectFromResourceA().

◆ D3DXCreateEffectFromResourceExW()

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 **  messages 
)

Definition at line 6988 of file effect.c.

6991{
6992 HRSRC resinfo;
6993 void *buffer;
6994 DWORD size;
6995
6996 TRACE("device %p, srcmodule %p, srcresource %s, defines %p, include %p, skipconstants %s, "
6997 "flags %#lx, pool %p, effect %p, messages %p.\n",
6998 device, srcmodule, debugstr_w(srcresource), defines, include, debugstr_a(skipconstants),
6999 flags, pool, effect, messages);
7000
7001 if (!device)
7002 return D3DERR_INVALIDCALL;
7003
7004 if (!(resinfo = FindResourceW(srcmodule, srcresource, (const WCHAR *)RT_RCDATA)))
7005 return D3DXERR_INVALIDDATA;
7006
7007 if (FAILED(load_resource_into_memory(srcmodule, resinfo, &buffer, &size)))
7008 return D3DXERR_INVALIDDATA;
7009
7010 return D3DXCreateEffectEx(device, buffer, size, defines, include,
7011 skipconstants, flags, pool, effect, messages);
7012}

Referenced by D3DXCreateEffectFromResourceW().

◆ D3DXCreateEffectFromResourceW()

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 **  messages 
)

Definition at line 7041 of file effect.c.

7044{
7045 TRACE("(void): relay\n");
7046 return D3DXCreateEffectFromResourceExW(device, srcmodule, srcresource, defines, include, NULL,
7047 flags, pool, effect, messages);
7048}
D3DXCreateEffectFromResourceExW
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 **messages)
Definition: effect.c:6988

◆ D3DXCreateEffectPool()

HRESULT WINAPI D3DXCreateEffectPool ( ID3DXEffectPool **  pool)

Definition at line 6875 of file effect.c.

6876{
6877 struct d3dx_effect_pool *object;
6878
6879 TRACE("pool %p.\n", pool);
6880
6881 if (!pool)
6882 return D3DERR_INVALIDCALL;
6883
6884 object = calloc(1, sizeof(*object));
6885 if (!object)
6886 return E_OUTOFMEMORY;
6887
6888 object->ID3DXEffectPool_iface.lpVtbl = &ID3DXEffectPool_Vtbl;
6889 object->refcount = 1;
6890
6891 *pool = &object->ID3DXEffectPool_iface;
6892
6893 return S_OK;
6894}
ID3DXEffectPool_Vtbl
static const struct ID3DXEffectPoolVtbl ID3DXEffectPool_Vtbl
Definition: effect.c:6858

Referenced by test_create_effect_and_pool(), test_effect_parameter_block(), and test_effect_shared_parameters().

◆ D3DXDisassembleEffect()

HRESULT WINAPI D3DXDisassembleEffect ( ID3DXEffect *  effect,
BOOL  enable_color_code,
ID3DXBuffer **  disassembly 
)

Definition at line 7146 of file effect.c.

7147{
7148 FIXME("(%p, %u, %p): stub\n", effect, enable_color_code, disassembly);
7149
7150 return D3DXERR_INVALIDDATA;
7151}

◆ free_effect_pool()

static void free_effect_pool ( struct d3dx_effect_pool *  pool)
static

Definition at line 6818 of file effect.c.

6819{
6820 unsigned int i;
6821
6822 for (i = 0; i < pool->size; ++i)
6823 {
6824 if (pool->shared_data[i].count)
6825 {
6826 unsigned int j;
6827
6828 WARN("Releasing pool with referenced parameters.\n");
6829
6830 param_set_data_pointer(&pool->shared_data[i].parameters[0]->param, NULL, FALSE, TRUE);
6831 pool->shared_data[i].parameters[0]->shared_data = NULL;
6832
6833 for (j = 1; j < pool->shared_data[i].count; ++j)
6834 {
6835 walk_parameter_tree(&pool->shared_data[i].parameters[j]->param, param_zero_data_func, NULL);
6836 pool->shared_data[i].parameters[j]->shared_data = NULL;
6837 }
6838 free(pool->shared_data[i].parameters);
6839 }
6840 }
6841 free(pool->shared_data);
6842 free(pool);
6843}

Referenced by d3dx_effect_pool_Release().

◆ free_object()

static void free_object ( struct d3dx_object *  object)
static

Definition at line 529 of file effect.c.

530{
531 free(object->data);
532}

Referenced by d3dx9_effect_init_from_binary(), d3dx_effect_cleanup(), and d3dx_parse_effect().

◆ free_parameter()

static void free_parameter ( struct d3dx_parameter *  param,
BOOL  element,
BOOL  child 
)
static

Definition at line 603 of file effect.c.

604{
605 unsigned int i;
606
607 TRACE("Free parameter %p, name %s, type %s, element %#x, child %#x.\n", param, param->name,
608 debug_d3dxparameter_type(param->type), element, child);
609
610 if (param->param_eval)
611 d3dx_free_param_eval(param->param_eval);
612
613 if (param->members)
614 {
615 unsigned int count = param->element_count ? param->element_count : param->member_count;
616
617 for (i = 0; i < count; ++i)
618 free_parameter(&param->members[i], param->element_count != 0, TRUE);
619 free(param->members);
620 }
621
622 free(param->full_name);
623 free_parameter_data(param, child);
624
625 /* only the parent has to release name and semantic */
626 if (!element)
627 {
628 free(param->name);
629 free(param->semantic);
630 }
631}
d3dx_free_param_eval
void d3dx_free_param_eval(struct d3dx_param_eval *peval)
Definition: preshader.c:1357
free_parameter_data
static void free_parameter_data(struct d3dx_parameter *param, BOOL child)
Definition: effect.c:591
child
static HWND child
Definition: cursoricon.c:298

Referenced by d3dx_parse_effect_parameter(), d3dx_parse_effect_pass(), d3dx_parse_effect_technique(), d3dx_parse_effect_typedef(), d3dx_parse_state(), free_parameter(), free_pass(), free_state(), free_technique(), and free_top_level_parameter().

◆ free_parameter_block()

static void free_parameter_block ( struct d3dx_parameter_block *  block)
static

Definition at line 716 of file effect.c.

717{
718 struct d3dx_recorded_parameter *record;
719
720 if (!block)
721 return;
722
723 record = (struct d3dx_recorded_parameter *)block->buffer;
724 while ((BYTE *)record < block->buffer + block->offset)
725 {
726 free_parameter_object_data(record->param, record + 1, record->bytes);
727 record = (struct d3dx_recorded_parameter *)((BYTE *)record + get_recorded_parameter_size(record));
728 }
729 assert((BYTE *)record == block->buffer + block->offset);
730
731 free(block->buffer);
732 free(block);
733}
free_parameter_object_data
static void free_parameter_object_data(struct d3dx_parameter *param, const void *data, unsigned int bytes)
Definition: effect.c:547

Referenced by d3dx_effect_cleanup().

◆ free_parameter_data()

static void free_parameter_data ( struct d3dx_parameter *  param,
BOOL  child 
)
static

Definition at line 591 of file effect.c.

592{
593 if (!param->data)
594 return;
595
596 if (!param->element_count)
597 free_parameter_object_data(param, param->data, param->bytes);
598
599 if (!child || is_param_type_sampler(param->type))
600 free(param->data);
601}

Referenced by free_parameter(), and param_set_data_pointer().

◆ free_parameter_object_data()

static void free_parameter_object_data ( struct d3dx_parameter *  param,
const void *  data,
unsigned int  bytes 
)
static

Definition at line 547 of file effect.c.

548{
549 unsigned int i, count;
550
551 if (param->class != D3DXPC_OBJECT)
552 return;
553
554 count = min(param->element_count ? param->element_count : 1, bytes / sizeof(void *));
555
556 for (i = 0; i < count; ++i)
557 {
558 switch (param->type)
559 {
560 case D3DXPT_STRING:
561 free(((char **)data)[i]);
562 break;
563
564 case D3DXPT_TEXTURE:
565 case D3DXPT_TEXTURE1D:
566 case D3DXPT_TEXTURE2D:
567 case D3DXPT_TEXTURE3D:
568 case D3DXPT_TEXTURECUBE:
569 case D3DXPT_PIXELSHADER:
570 case D3DXPT_VERTEXSHADER:
571 if (*(IUnknown **)data)
572 IUnknown_Release(((IUnknown **)data)[i]);
573 break;
574
575 case D3DXPT_SAMPLER:
576 case D3DXPT_SAMPLER1D:
577 case D3DXPT_SAMPLER2D:
578 case D3DXPT_SAMPLER3D:
579 case D3DXPT_SAMPLERCUBE:
580 assert(count == 1);
581 free_sampler((struct d3dx_sampler *)data);
582 return;
583
584 default:
585 FIXME("Unhandled type %s\n", debug_d3dxparameter_type(param->type));
586 break;
587 }
588 }
589}
free_sampler
static void free_sampler(struct d3dx_sampler *sampler)
Definition: effect.c:534

Referenced by free_parameter_block(), and free_parameter_data().

◆ free_pass()

static void free_pass ( struct d3dx_pass *  pass)
static

Definition at line 647 of file effect.c.

648{
649 unsigned int i;
650
651 TRACE("Free pass %p\n", pass);
652
653 if (!pass)
654 return;
655
656 if (pass->annotations)
657 {
658 for (i = 0; i < pass->annotation_count; ++i)
659 free_parameter(&pass->annotations[i], FALSE, FALSE);
660 free(pass->annotations);
661 pass->annotations = NULL;
662 }
663
664 if (pass->states)
665 {
666 for (i = 0; i < pass->state_count; ++i)
667 free_state(&pass->states[i]);
668 free(pass->states);
669 pass->states = NULL;
670 }
671
672 free(pass->name);
673 pass->name = NULL;
674}

Referenced by d3dx_parse_effect_technique(), and free_technique().

◆ free_sampler()

static void free_sampler ( struct d3dx_sampler *  sampler)
static

Definition at line 534 of file effect.c.

535{
536 UINT i;
537
538 for (i = 0; i < sampler->state_count; ++i)
539 {
540 free_state(&sampler->states[i]);
541 }
542 free(sampler->states);
543}

Referenced by free_parameter_object_data().

◆ free_state()

static void free_state ( struct d3dx_state *  state)
static

Definition at line 524 of file effect.c.

525{
526 free_parameter(&state->parameter, FALSE, FALSE);
527}

Referenced by d3dx_parse_effect_pass(), d3dx_parse_sampler(), free_pass(), and free_sampler().

◆ free_technique()

static void free_technique ( struct d3dx_technique *  technique)
static

Definition at line 676 of file effect.c.

677{
678 unsigned int i;
679
680 TRACE("Free technique %p\n", technique);
681
682 if (!technique)
683 return;
684
685 if (technique->saved_state)
686 {
687 IDirect3DStateBlock9_Release(technique->saved_state);
688 technique->saved_state = NULL;
689 }
690
691 if (technique->annotations)
692 {
693 for (i = 0; i < technique->annotation_count; ++i)
694 free_parameter(&technique->annotations[i], FALSE, FALSE);
695 free(technique->annotations);
696 technique->annotations = NULL;
697 }
698
699 if (technique->passes)
700 {
701 for (i = 0; i < technique->pass_count; ++i)
702 free_pass(&technique->passes[i]);
703 free(technique->passes);
704 technique->passes = NULL;
705 }
706
707 free(technique->name);
708 technique->name = NULL;
709}
IDirect3DStateBlock9_Release
#define IDirect3DStateBlock9_Release(p)
Definition: d3d9.h:1128

Referenced by d3dx9_effect_init_from_binary(), d3dx_effect_cleanup(), and d3dx_parse_effect().

◆ free_top_level_parameter()

static void free_top_level_parameter ( struct d3dx_top_level_parameter *  param)
static

Definition at line 633 of file effect.c.

634{
635 if (param->annotations)
636 {
637 unsigned int i;
638
639 for (i = 0; i < param->annotation_count; ++i)
640 free_parameter(&param->annotations[i], FALSE, FALSE);
641 free(param->annotations);
642 }
643 d3dx_pool_release_shared_parameter(param);
644 free_parameter(&param->param, FALSE, FALSE);
645}
d3dx_pool_release_shared_parameter
static void d3dx_pool_release_shared_parameter(struct d3dx_top_level_parameter *param)
Definition: effect.c:1917

Referenced by d3dx9_effect_init_from_binary(), and d3dx_parameters_store_cleanup().

◆ get_annotation_by_name()

static struct d3dx_parameter * get_annotation_by_name ( struct d3dx_effect *  effect,
unsigned int  count,
struct d3dx_parameter *  annotations,
const char *  name 
)
static

Definition at line 997 of file effect.c.

999{
1000 UINT i, length;
1001 struct d3dx_parameter *temp_parameter;
1002 const char *part;
1003
1004 TRACE("count %u, annotations %p, name %s\n", count, annotations, debugstr_a(name));
1005
1006 if (!name || !*name) return NULL;
1007
1008 length = strcspn( name, "[.@" );
1009 part = name + length;
1010
1011 for (i = 0; i < count; ++i)
1012 {
1013 temp_parameter = &annotations[i];
1014
1015 if (!strcmp(temp_parameter->name, name))
1016 {
1017 TRACE("Returning annotation %p\n", temp_parameter);
1018 return temp_parameter;
1019 }
1020 else if (strlen(temp_parameter->name) == length && !strncmp(temp_parameter->name, name, length))
1021 {
1022 switch (*part++)
1023 {
1024 case '.':
1025 return get_parameter_by_name(&effect->params, temp_parameter, part);
1026
1027 case '[':
1028 return get_parameter_element_by_name(&effect->params, temp_parameter, part);
1029
1030 default:
1031 FIXME("Unhandled case \"%c\"\n", *--part);
1032 break;
1033 }
1034 }
1035 }
1036
1037 TRACE("Annotation not found\n");
1038 return NULL;
1039}
get_parameter_element_by_name
static struct d3dx_parameter * get_parameter_element_by_name(struct d3dx_parameters_store *store, struct d3dx_parameter *parameter, const char *name)
Definition: effect.c:959
strcspn
_ACRTIMP size_t __cdecl strcspn(const char *, const char *)
Definition: string.c:3498
strncmp
_ACRTIMP int __cdecl strncmp(const char *, const char *, size_t)
Definition: string.c:3335
length
GLuint GLsizei GLsizei * length
Definition: glext.h:6040
d3dx_parameter::name
char * name
Definition: d3dx9_private.h:516

Referenced by d3dx_effect_GetAnnotationByName().

◆ get_annotation_from_object()

static unsigned int get_annotation_from_object ( struct d3dx_effect *  effect,
D3DXHANDLE  object,
struct d3dx_parameter **  annotations 
)
static

Definition at line 1228 of file effect.c.

1230{
1231 struct d3dx_parameter *param = get_valid_parameter(effect, object);
1232 struct d3dx_pass *pass = get_valid_pass(effect, object);
1233 struct d3dx_technique *technique = get_valid_technique(effect, object);
1234
1235 if (pass)
1236 {
1237 *annotations = pass->annotations;
1238 return pass->annotation_count;
1239 }
1240 else if (technique)
1241 {
1242 *annotations = technique->annotations;
1243 return technique->annotation_count;
1244 }
1245 else if (param)
1246 {
1247 if (is_top_level_parameter(param))
1248 {
1249 struct d3dx_top_level_parameter *top_param
1250 = top_level_parameter_from_parameter(param);
1251
1252 *annotations = top_param->annotations;
1253 return top_param->annotation_count;
1254 }
1255 else
1256 {
1257 *annotations = NULL;
1258 return 0;
1259 }
1260 }
1261 else
1262 {
1263 FIXME("Functions are not handled, yet!\n");
1264 return 0;
1265 }
1266}

Referenced by d3dx_effect_GetAnnotation(), and d3dx_effect_GetAnnotationByName().

◆ get_matrix()

static void get_matrix ( struct d3dx_parameter *  param,
D3DXMATRIX *  matrix,
BOOL  transpose 
)
static

Definition at line 834 of file effect.c.

835{
836 UINT i, k;
837
838 for (i = 0; i < 4; ++i)
839 {
840 for (k = 0; k < 4; ++k)
841 {
842 FLOAT *tmp = transpose ? (FLOAT *)&matrix->m[k][i] : (FLOAT *)&matrix->m[i][k];
843
844 if ((i < param->rows) && (k < param->columns))
845 set_number(tmp, D3DXPT_FLOAT, (DWORD *)param->data + i * param->columns + k, param->type);
846 else
847 *tmp = 0.0f;
848 }
849 }
850}
transpose
GLsizei GLboolean transpose
Definition: glext.h:6077
FLOAT
float FLOAT
Definition: typedefs.h:69

Referenced by d3dx_effect_GetMatrix(), d3dx_effect_GetMatrixArray(), d3dx_effect_GetMatrixPointerArray(), d3dx_effect_GetMatrixTranspose(), d3dx_effect_GetMatrixTransposeArray(), and d3dx_effect_GetMatrixTransposePointerArray().

◆ get_parameter_by_name()

struct d3dx_parameter * get_parameter_by_name ( struct d3dx_parameters_store *  store,
struct d3dx_parameter *  parameter,
const char *  name 
)

Definition at line 1041 of file effect.c.

1043{
1044 struct d3dx_parameter *temp_parameter;
1045 unsigned int name_len, param_name_len;
1046 unsigned int i, count, length;
1047 struct wine_rb_entry *entry;
1048 unsigned int full_name_size;
1049 const char *part;
1050 char *full_name;
1051
1052 TRACE("store %p, parameter %p, name %s.\n", store, parameter, debugstr_a(name));
1053
1054 if (!name || !*name) return NULL;
1055
1056 if (!parameter)
1057 {
1058 if ((entry = wine_rb_get(&store->tree, name)))
1059 return WINE_RB_ENTRY_VALUE(entry, struct d3dx_parameter, rb_entry);
1060 return NULL;
1061 }
1062
1063 if (parameter->full_name)
1064 {
1065 name_len = strlen(name);
1066 param_name_len = strlen(parameter->full_name);
1067 full_name_size = name_len + param_name_len + 2;
1068 if (store->full_name_tmp_size < full_name_size)
1069 {
1070 if (!(full_name = realloc(store->full_name_tmp, full_name_size)))
1071 {
1072 ERR("Out of memory.\n");
1073 return NULL;
1074 }
1075 store->full_name_tmp = full_name;
1076 store->full_name_tmp_size = full_name_size;
1077 }
1078 else
1079 {
1080 full_name = store->full_name_tmp;
1081 }
1082 memcpy(full_name, parameter->full_name, param_name_len);
1083 full_name[param_name_len] = '.';
1084 memcpy(full_name + param_name_len + 1, name, name_len);
1085 full_name[param_name_len + 1 + name_len] = 0;
1086
1087 if ((entry = wine_rb_get(&store->tree, full_name)))
1088 return WINE_RB_ENTRY_VALUE(entry, struct d3dx_parameter, rb_entry);
1089 return NULL;
1090 }
1091
1092 /* Pass / technique annotations are not stored in the parameters tree,
1093 * do a linear search. */
1094 count = parameter->member_count;
1095
1096 length = strcspn( name, "[." );
1097 part = name + length;
1098
1099 for (i = 0; i < count; i++)
1100 {
1101 temp_parameter = &parameter->members[i];
1102
1103 if (!strcmp(temp_parameter->name, name))
1104 {
1105 TRACE("Returning parameter %p\n", temp_parameter);
1106 return temp_parameter;
1107 }
1108 else if (strlen(temp_parameter->name) == length && !strncmp(temp_parameter->name, name, length))
1109 {
1110 switch (*part++)
1111 {
1112 case '.':
1113 return get_parameter_by_name(store, temp_parameter, part);
1114
1115 case '[':
1116 return get_parameter_element_by_name(store, temp_parameter, part);
1117
1118 default:
1119 FIXME("Unhandled case \"%c\"\n", *--part);
1120 break;
1121 }
1122 }
1123 }
1124
1125 TRACE("Parameter not found\n");
1126 return NULL;
1127}
wine_rb_entry
#define wine_rb_entry
Definition: rbtree.h:404
WINE_RB_ENTRY_VALUE
#define WINE_RB_ENTRY_VALUE
Definition: rbtree.h:414
wine_rb_get
#define wine_rb_get
Definition: rbtree.h:409
d3dx_parameter::full_name
char * full_name
Definition: d3dx9_private.h:531
d3dx_parameters_store::full_name_tmp_size
unsigned int full_name_tmp_size
Definition: d3dx9_private.h:593
rb_entry
Definition: rbtree.h:30

Referenced by d3dx9_effect_init_from_binary(), d3dx_effect_GetParameterByName(), d3dx_parse_array_selector(), d3dx_parse_resource(), get_annotation_by_name(), get_constants_desc(), get_parameter_by_name(), get_parameter_element_by_name(), and get_valid_parameter().

◆ get_parameter_element_by_name()

static struct d3dx_parameter * get_parameter_element_by_name ( struct d3dx_parameters_store *  store,
struct d3dx_parameter *  parameter,
const char *  name 
)
static

Definition at line 959 of file effect.c.

961{
962 UINT element;
963 struct d3dx_parameter *temp_parameter;
964 const char *part;
965
966 TRACE("parameter %p, name %s\n", parameter, debugstr_a(name));
967
968 if (!name || !*name) return NULL;
969
970 element = atoi(name);
971 part = strchr(name, ']') + 1;
972
973 /* check for empty [] && element range */
974 if ((part - name) > 1 && parameter->element_count > element)
975 {
976 temp_parameter = &parameter->members[element];
977
978 switch (*part++)
979 {
980 case '.':
981 return get_parameter_by_name(store, temp_parameter, part);
982
983 case '\0':
984 TRACE("Returning parameter %p\n", temp_parameter);
985 return temp_parameter;
986
987 default:
988 FIXME("Unhandled case \"%c\"\n", *--part);
989 break;
990 }
991 }
992
993 TRACE("Parameter not found\n");
994 return NULL;
995}
atoi
_ACRTIMP int __cdecl atoi(const char *)
Definition: string.c:1720
strchr
_ACRTIMP char *__cdecl strchr(const char *, int)
Definition: string.c:3291

Referenced by get_annotation_by_name(), and get_parameter_by_name().

◆ get_parameter_handle()

static D3DXHANDLE get_parameter_handle ( struct d3dx_parameter *  parameter)
inlinestatic

Definition at line 444 of file effect.c.

445{
446 return (D3DXHANDLE)parameter;
447}

Referenced by d3dx_effect_GetAnnotation(), d3dx_effect_GetAnnotationByName(), d3dx_effect_GetParameter(), d3dx_effect_GetParameterByName(), d3dx_effect_GetParameterBySemantic(), and d3dx_effect_GetParameterElement().

◆ get_pass_handle()

static D3DXHANDLE get_pass_handle ( struct d3dx_pass *  pass)
inlinestatic

Definition at line 454 of file effect.c.

455{
456 return (D3DXHANDLE)pass;
457}

Referenced by d3dx_effect_GetPass(), d3dx_effect_GetPassByName(), and get_valid_pass().

◆ get_recorded_parameter_size()

static unsigned int get_recorded_parameter_size ( const struct d3dx_recorded_parameter *  record)
static

Definition at line 711 of file effect.c.

712{
713 return sizeof(*record) + record->bytes;
714}

Referenced by d3dx_effect_ApplyParameterBlock(), free_parameter_block(), and record_parameter().

◆ get_technique_by_name()

static struct d3dx_technique * get_technique_by_name ( struct d3dx_effect *  effect,
const char *  name 
)
static

Definition at line 459 of file effect.c.

460{
461 unsigned int i;
462
463 if (!name) return NULL;
464
465 for (i = 0; i < effect->technique_count; ++i)
466 {
467 if (!strcmp(effect->techniques[i].name, name))
468 return &effect->techniques[i];
469 }
470
471 return NULL;
472}

Referenced by d3dx_effect_GetTechniqueByName(), and get_valid_technique().

◆ get_technique_handle()

static D3DXHANDLE get_technique_handle ( struct d3dx_technique *  technique)
inlinestatic

Definition at line 449 of file effect.c.

450{
451 return (D3DXHANDLE)technique;
452}

Referenced by d3dx_effect_FindNextValidTechnique(), d3dx_effect_GetCurrentTechnique(), d3dx_effect_GetTechnique(), d3dx_effect_GetTechniqueByName(), and get_valid_technique().

◆ get_valid_parameter()

static struct d3dx_parameter * get_valid_parameter ( struct d3dx_effect *  effect,
D3DXHANDLE  parameter 
)
static

Definition at line 505 of file effect.c.

506{
507 struct d3dx_parameter *handle_param = (struct d3dx_parameter *)parameter;
508
509 if (handle_param && !strncmp(handle_param->magic_string, parameter_magic_string,
510 sizeof(parameter_magic_string)))
511 return handle_param;
512
513 return effect->flags & D3DXFX_LARGEADDRESSAWARE ? NULL : get_parameter_by_name(&effect->params, NULL, parameter);
514}
parameter_magic_string
static const char parameter_magic_string[4]
Definition: effect.c:33
d3dx_parameter::magic_string
char magic_string[4]
Definition: d3dx9_private.h:513

Referenced by d3dx_effect_GetBool(), d3dx_effect_GetBoolArray(), d3dx_effect_GetFloat(), d3dx_effect_GetFloatArray(), d3dx_effect_GetInt(), d3dx_effect_GetIntArray(), d3dx_effect_GetMatrix(), d3dx_effect_GetMatrixArray(), d3dx_effect_GetMatrixPointerArray(), d3dx_effect_GetMatrixTranspose(), d3dx_effect_GetMatrixTransposeArray(), d3dx_effect_GetMatrixTransposePointerArray(), d3dx_effect_GetParameter(), d3dx_effect_GetParameterByName(), d3dx_effect_GetParameterBySemantic(), d3dx_effect_GetParameterDesc(), d3dx_effect_GetParameterElement(), d3dx_effect_GetPixelShader(), d3dx_effect_GetString(), d3dx_effect_GetTexture(), d3dx_effect_GetValue(), d3dx_effect_GetVector(), d3dx_effect_GetVectorArray(), d3dx_effect_GetVertexShader(), d3dx_effect_IsParameterUsed(), d3dx_effect_SetBool(), d3dx_effect_SetBoolArray(), d3dx_effect_SetFloat(), d3dx_effect_SetFloatArray(), d3dx_effect_SetInt(), d3dx_effect_SetIntArray(), d3dx_effect_SetMatrix(), d3dx_effect_SetMatrixArray(), d3dx_effect_SetMatrixPointerArray(), d3dx_effect_SetMatrixTranspose(), d3dx_effect_SetMatrixTransposeArray(), d3dx_effect_SetMatrixTransposePointerArray(), d3dx_effect_SetString(), d3dx_effect_SetTexture(), d3dx_effect_SetValue(), d3dx_effect_SetVector(), d3dx_effect_SetVectorArray(), and get_annotation_from_object().

◆ get_valid_parameter_block()

static struct d3dx_parameter_block * get_valid_parameter_block ( D3DXHANDLE  handle)
static

Definition at line 516 of file effect.c.

517{
518 struct d3dx_parameter_block *block = (struct d3dx_parameter_block *)handle;
519
520 return block && !strncmp(block->magic_string, parameter_block_magic_string,
521 sizeof(parameter_block_magic_string)) ? block : NULL;
522}

Referenced by d3dx_effect_ApplyParameterBlock().

◆ get_valid_pass()

static struct d3dx_pass * get_valid_pass ( struct d3dx_effect *  effect,
D3DXHANDLE  pass 
)
static

Definition at line 487 of file effect.c.

488{
489 unsigned int i, k;
490
491 for (i = 0; i < effect->technique_count; ++i)
492 {
493 struct d3dx_technique *technique = &effect->techniques[i];
494
495 for (k = 0; k < technique->pass_count; ++k)
496 {
497 if (get_pass_handle(&technique->passes[k]) == pass)
498 return &technique->passes[k];
499 }
500 }
501
502 return NULL;
503}

Referenced by d3dx_effect_GetPassDesc(), and get_annotation_from_object().

◆ get_valid_technique()

static struct d3dx_technique * get_valid_technique ( struct d3dx_effect *  effect,
D3DXHANDLE  technique 
)
static

Definition at line 474 of file effect.c.

475{
476 unsigned int i;
477
478 for (i = 0; i < effect->technique_count; ++i)
479 {
480 if (get_technique_handle(&effect->techniques[i]) == technique)
481 return &effect->techniques[i];
482 }
483
484 return get_technique_by_name(effect, technique);
485}

Referenced by d3dx_effect_FindNextValidTechnique(), d3dx_effect_GetPass(), d3dx_effect_GetPassByName(), d3dx_effect_GetTechniqueDesc(), d3dx_effect_IsParameterUsed(), d3dx_effect_SetTechnique(), d3dx_effect_ValidateTechnique(), and get_annotation_from_object().

◆ get_vector()

static void get_vector ( struct d3dx_parameter *  param,
D3DXVECTOR4 *  vector 
)
static

Definition at line 813 of file effect.c.

814{
815 UINT i;
816
817 for (i = 0; i < 4; ++i)
818 {
819 if (i < param->columns)
820 set_number((FLOAT *)vector + i, D3DXPT_FLOAT, (DWORD *)param->data + i, param->type);
821 else
822 ((FLOAT *)vector)[i] = 0.0f;
823 }
824}

Referenced by d3dx_effect_GetVector(), and d3dx_effect_GetVectorArray().

◆ get_version_counter_ptr()

static ULONG64 * get_version_counter_ptr ( struct d3dx_effect *  effect)
static

Definition at line 1286 of file effect.c.

1287{
1288 return effect->pool ? &effect->pool->version_counter : &effect->version_counter;
1289}
d3dx_effect::version_counter
ULONG64 version_counter
Definition: effect.c:189

Referenced by d3dx_parse_array_selector(), d3dx_parse_effect(), d3dx_parse_resource(), and next_effect_update_version().

◆ ID3DXEffectCompilerImpl_AddRef()

static ULONG WINAPI ID3DXEffectCompilerImpl_AddRef ( ID3DXEffectCompiler *  iface)
static

Definition at line 4555 of file effect.c.

4556{
4557 struct ID3DXEffectCompilerImpl *compiler = impl_from_ID3DXEffectCompiler(iface);
4558 ULONG refcount = InterlockedIncrement(&compiler->ref);
4559
4560 TRACE("%p increasing refcount to %lu.\n", iface, refcount);
4561
4562 return refcount;
4563}
impl_from_ID3DXEffectCompiler
static struct ID3DXEffectCompilerImpl * impl_from_ID3DXEffectCompiler(ID3DXEffectCompiler *iface)
Definition: effect.c:4531

◆ ID3DXEffectCompilerImpl_CompileEffect()

static HRESULT WINAPI ID3DXEffectCompilerImpl_CompileEffect ( ID3DXEffectCompiler *  iface,
DWORD  flags,
ID3DXBuffer **  effect,
ID3DXBuffer **  error_msgs 
)
static

Definition at line 5016 of file effect.c.

5018{
5019 FIXME("iface %p, flags %#lx, effect %p, error_msgs %p stub!\n", iface, flags, effect, error_msgs);
5020
5021 return E_NOTIMPL;
5022}

◆ ID3DXEffectCompilerImpl_CompileShader()

static HRESULT WINAPI ID3DXEffectCompilerImpl_CompileShader ( ID3DXEffectCompiler *  iface,
D3DXHANDLE  function,
const char *  target,
DWORD  flags,
ID3DXBuffer **  shader,
ID3DXBuffer **  error_msgs,
ID3DXConstantTable **  constant_table 
)
static

Definition at line 5024 of file effect.c.

5027{
5028 FIXME("iface %p, function %p, target %s, flags %#lx, shader %p, error_msgs %p, constant_table %p stub!\n",
5029 iface, function, debugstr_a(target), flags, shader, error_msgs, constant_table);
5030
5031 return E_NOTIMPL;
5032}
constant_table
static ID3DXConstantTable ** constant_table
Definition: hlsl_d3d9.c:32
target
Definition: tools.h:99

◆ ID3DXEffectCompilerImpl_GetAnnotation()

static D3DXHANDLE WINAPI ID3DXEffectCompilerImpl_GetAnnotation ( ID3DXEffectCompiler *  iface,
D3DXHANDLE  object,
UINT  index 
)
static

Definition at line 4695 of file effect.c.

4697{
4698 FIXME("iface %p, object %p, index %u stub!\n", iface, object, index);
4699
4700 return NULL;
4701}

◆ ID3DXEffectCompilerImpl_GetAnnotationByName()

static D3DXHANDLE WINAPI ID3DXEffectCompilerImpl_GetAnnotationByName ( ID3DXEffectCompiler *  iface,
D3DXHANDLE  object,
const char *  name 
)
static

Definition at line 4703 of file effect.c.

4705{
4706 FIXME("iface %p, object %p, name %s stub!\n", iface, object, debugstr_a(name));
4707
4708 return NULL;
4709}

◆ ID3DXEffectCompilerImpl_GetBool()

static HRESULT WINAPI ID3DXEffectCompilerImpl_GetBool ( ID3DXEffectCompiler *  iface,
D3DXHANDLE  parameter,
BOOL *  b 
)
static

Definition at line 4734 of file effect.c.

4735{
4736 FIXME("iface %p, parameter %p, b %p stub!\n", iface, parameter, b);
4737
4738 return E_NOTIMPL;
4739}

◆ ID3DXEffectCompilerImpl_GetBoolArray()

static HRESULT WINAPI ID3DXEffectCompilerImpl_GetBoolArray ( ID3DXEffectCompiler *  iface,
D3DXHANDLE  parameter,
BOOL *  b,
UINT  count 
)
static

Definition at line 4749 of file effect.c.

4751{
4752 FIXME("iface %p, parameter %p, b %p, count %u stub!\n", iface, parameter, b, count);
4753
4754 return E_NOTIMPL;
4755}

◆ ID3DXEffectCompilerImpl_GetDesc()

static HRESULT WINAPI ID3DXEffectCompilerImpl_GetDesc ( ID3DXEffectCompiler *  iface,
D3DXEFFECT_DESC *  desc 
)
static

Definition at line 4581 of file effect.c.

4582{
4583 FIXME("iface %p, desc %p stub!\n", iface, desc);
4584
4585 return E_NOTIMPL;
4586}

◆ ID3DXEffectCompilerImpl_GetFloat()

static HRESULT WINAPI ID3DXEffectCompilerImpl_GetFloat ( ID3DXEffectCompiler *  iface,
D3DXHANDLE  parameter,
float *  f 
)
static

Definition at line 4794 of file effect.c.

4795{
4796 FIXME("iface %p, parameter %p, f %p stub!\n", iface, parameter, f);
4797
4798 return E_NOTIMPL;
4799}

◆ ID3DXEffectCompilerImpl_GetFloatArray()

static HRESULT WINAPI ID3DXEffectCompilerImpl_GetFloatArray ( ID3DXEffectCompiler *  iface,
D3DXHANDLE  parameter,
float *  f,
UINT  count 
)
static

Definition at line 4809 of file effect.c.

4811{
4812 FIXME("iface %p, parameter %p, f %p, count %u stub!\n", iface, parameter, f, count);
4813
4814 return E_NOTIMPL;
4815}

◆ ID3DXEffectCompilerImpl_GetFunction()

static D3DXHANDLE WINAPI ID3DXEffectCompilerImpl_GetFunction ( ID3DXEffectCompiler *  iface,
UINT  index 
)
static

Definition at line 4681 of file effect.c.

4682{
4683 FIXME("iface %p, index %u stub!\n", iface, index);
4684
4685 return NULL;
4686}

◆ ID3DXEffectCompilerImpl_GetFunctionByName()

static D3DXHANDLE WINAPI ID3DXEffectCompilerImpl_GetFunctionByName ( ID3DXEffectCompiler *  iface,
const char *  name 
)
static

Definition at line 4688 of file effect.c.

4689{
4690 FIXME("iface %p, name %s stub!\n", iface, debugstr_a(name));
4691
4692 return NULL;
4693}

◆ ID3DXEffectCompilerImpl_GetFunctionDesc()

static HRESULT WINAPI ID3DXEffectCompilerImpl_GetFunctionDesc ( ID3DXEffectCompiler *  iface,
D3DXHANDLE  shader,
D3DXFUNCTION_DESC *  desc 
)
static

Definition at line 4612 of file effect.c.

4614{
4615 FIXME("iface %p, shader %p, desc %p stub!\n", iface, shader, desc);
4616
4617 return E_NOTIMPL;
4618}

◆ ID3DXEffectCompilerImpl_GetInt()

static HRESULT WINAPI ID3DXEffectCompilerImpl_GetInt ( ID3DXEffectCompiler *  iface,
D3DXHANDLE  parameter,
INT *  n 
)
static

Definition at line 4764 of file effect.c.

4765{
4766 FIXME("iface %p, parameter %p, n %p stub!\n", iface, parameter, n);
4767
4768 return E_NOTIMPL;
4769}

◆ ID3DXEffectCompilerImpl_GetIntArray()

static HRESULT WINAPI ID3DXEffectCompilerImpl_GetIntArray ( ID3DXEffectCompiler *  iface,
D3DXHANDLE  parameter,
INT *  n,
UINT  count 
)
static

Definition at line 4779 of file effect.c.

4781{
4782 FIXME("iface %p, parameter %p, n %p, count %u stub!\n", iface, parameter, n, count);
4783
4784 return E_NOTIMPL;
4785}

◆ ID3DXEffectCompilerImpl_GetLiteral()

static HRESULT WINAPI ID3DXEffectCompilerImpl_GetLiteral ( ID3DXEffectCompiler *  iface,
D3DXHANDLE  parameter,
BOOL *  literal 
)
static

Definition at line 5009 of file effect.c.

5010{
5011 FIXME("iface %p, parameter %p, literal %p stub!\n", iface, parameter, literal);
5012
5013 return E_NOTIMPL;
5014}

◆ ID3DXEffectCompilerImpl_GetMatrix()

static HRESULT WINAPI ID3DXEffectCompilerImpl_GetMatrix ( ID3DXEffectCompiler *  iface,
D3DXHANDLE  parameter,
D3DXMATRIX *  matrix 
)
static

Definition at line 4857 of file effect.c.

4859{
4860 FIXME("iface %p, parameter %p, matrix %p stub!\n", iface, parameter, matrix);
4861
4862 return E_NOTIMPL;
4863}

◆ ID3DXEffectCompilerImpl_GetMatrixArray()

static HRESULT WINAPI ID3DXEffectCompilerImpl_GetMatrixArray ( ID3DXEffectCompiler *  iface,
D3DXHANDLE  parameter,
D3DXMATRIX *  matrix,
UINT  count 
)
static

Definition at line 4873 of file effect.c.

4875{
4876 FIXME("iface %p, parameter %p, matrix %p, count %u stub!\n", iface, parameter, matrix, count);
4877
4878 return E_NOTIMPL;
4879}

◆ ID3DXEffectCompilerImpl_GetMatrixPointerArray()

static HRESULT WINAPI ID3DXEffectCompilerImpl_GetMatrixPointerArray ( ID3DXEffectCompiler *  iface,
D3DXHANDLE  parameter,
D3DXMATRIX **  matrix,
UINT  count 
)
static

Definition at line 4889 of file effect.c.

4891{
4892 FIXME("iface %p, parameter %p, matrix %p, count %u stub!\n", iface, parameter, matrix, count);
4893
4894 return E_NOTIMPL;
4895}

◆ ID3DXEffectCompilerImpl_GetMatrixTranspose()

static HRESULT WINAPI ID3DXEffectCompilerImpl_GetMatrixTranspose ( ID3DXEffectCompiler *  iface,
D3DXHANDLE  parameter,
D3DXMATRIX *  matrix 
)
static

Definition at line 4905 of file effect.c.

4907{
4908 FIXME("iface %p, parameter %p, matrix %p stub!\n", iface, parameter, matrix);
4909
4910 return E_NOTIMPL;
4911}

◆ ID3DXEffectCompilerImpl_GetMatrixTransposeArray()

static HRESULT WINAPI ID3DXEffectCompilerImpl_GetMatrixTransposeArray ( ID3DXEffectCompiler *  iface,
D3DXHANDLE  parameter,
D3DXMATRIX *  matrix,
UINT  count 
)
static

Definition at line 4921 of file effect.c.

4923{
4924 FIXME("iface %p, parameter %p, matrix %p, count %u stub!\n", iface, parameter, matrix, count);
4925
4926 return E_NOTIMPL;
4927}

◆ ID3DXEffectCompilerImpl_GetMatrixTransposePointerArray()

static HRESULT WINAPI ID3DXEffectCompilerImpl_GetMatrixTransposePointerArray ( ID3DXEffectCompiler *  iface,
D3DXHANDLE  parameter,
D3DXMATRIX **  matrix,
UINT  count 
)
static

Definition at line 4937 of file effect.c.

4939{
4940 FIXME("iface %p, parameter %p, matrix %p, count %u stub!\n", iface, parameter, matrix, count);
4941
4942 return E_NOTIMPL;
4943}

◆ ID3DXEffectCompilerImpl_GetParameter()

static D3DXHANDLE WINAPI ID3DXEffectCompilerImpl_GetParameter ( ID3DXEffectCompiler *  iface,
D3DXHANDLE  parameter,
UINT  index 
)
static

Definition at line 4620 of file effect.c.

4622{
4623 FIXME("iface %p, parameter %p, index %u stub!\n", iface, parameter, index);
4624
4625 return NULL;
4626}

◆ ID3DXEffectCompilerImpl_GetParameterByName()

static D3DXHANDLE WINAPI ID3DXEffectCompilerImpl_GetParameterByName ( ID3DXEffectCompiler *  iface,
D3DXHANDLE  parameter,
const char *  name 
)
static

Definition at line 4628 of file effect.c.

4630{
4631 FIXME("iface %p, parameter %p, name %s stub!\n", iface, parameter, debugstr_a(name));
4632
4633 return NULL;
4634}

◆ ID3DXEffectCompilerImpl_GetParameterBySemantic()

static D3DXHANDLE WINAPI ID3DXEffectCompilerImpl_GetParameterBySemantic ( ID3DXEffectCompiler *  iface,
D3DXHANDLE  parameter,
const char *  semantic 
)
static

Definition at line 4636 of file effect.c.

4638{
4639 FIXME("iface %p, parameter %p, semantic %s stub!\n", iface, parameter, debugstr_a(semantic));
4640
4641 return NULL;
4642}

◆ ID3DXEffectCompilerImpl_GetParameterDesc()

static HRESULT WINAPI ID3DXEffectCompilerImpl_GetParameterDesc ( ID3DXEffectCompiler *  iface,
D3DXHANDLE  parameter,
D3DXPARAMETER_DESC *  desc 
)
static

Definition at line 4588 of file effect.c.

4590{
4591 FIXME("iface %p, parameter %p, desc %p stub!\n", iface, parameter, desc);
4592
4593 return E_NOTIMPL;
4594}

◆ ID3DXEffectCompilerImpl_GetParameterElement()

static D3DXHANDLE WINAPI ID3DXEffectCompilerImpl_GetParameterElement ( ID3DXEffectCompiler *  iface,
D3DXHANDLE  parameter,
UINT  index 
)
static

Definition at line 4644 of file effect.c.

4646{
4647 FIXME("iface %p, parameter %p, index %u stub!\n", iface, parameter, index);
4648
4649 return NULL;
4650}

◆ ID3DXEffectCompilerImpl_GetPass()

static D3DXHANDLE WINAPI ID3DXEffectCompilerImpl_GetPass ( ID3DXEffectCompiler *  iface,
D3DXHANDLE  technique,
UINT  index 
)
static

Definition at line 4666 of file effect.c.

4667{
4668 FIXME("iface %p, technique %p, index %u stub!\n", iface, technique, index);
4669
4670 return NULL;
4671}

◆ ID3DXEffectCompilerImpl_GetPassByName()

static D3DXHANDLE WINAPI ID3DXEffectCompilerImpl_GetPassByName ( ID3DXEffectCompiler *  iface,
D3DXHANDLE  technique,
const char *  name 
)
static

Definition at line 4673 of file effect.c.

4675{
4676 FIXME("iface %p, technique %p, name %s stub!\n", iface, technique, debugstr_a(name));
4677
4678 return NULL;
4679}

◆ ID3DXEffectCompilerImpl_GetPassDesc()

static HRESULT WINAPI ID3DXEffectCompilerImpl_GetPassDesc ( ID3DXEffectCompiler *  iface,
D3DXHANDLE  pass,
D3DXPASS_DESC *  desc 
)
static

Definition at line 4604 of file effect.c.

4606{
4607 FIXME("iface %p, pass %p, desc %p stub!\n", iface, pass, desc);
4608
4609 return E_NOTIMPL;
4610}

◆ ID3DXEffectCompilerImpl_GetPixelShader()

static HRESULT WINAPI ID3DXEffectCompilerImpl_GetPixelShader ( ID3DXEffectCompiler *  iface,
D3DXHANDLE  parameter,
struct IDirect3DPixelShader9 **  shader 
)
static

Definition at line 4977 of file effect.c.

4979{
4980 FIXME("iface %p, parameter %p, shader %p stub!\n", iface, parameter, shader);
4981
4982 return E_NOTIMPL;
4983}

◆ ID3DXEffectCompilerImpl_GetString()

static HRESULT WINAPI ID3DXEffectCompilerImpl_GetString ( ID3DXEffectCompiler *  iface,
D3DXHANDLE  parameter,
const char **  string 
)
static

Definition at line 4953 of file effect.c.

4955{
4956 FIXME("iface %p, parameter %p, string %p stub!\n", iface, parameter, string);
4957
4958 return E_NOTIMPL;
4959}

◆ ID3DXEffectCompilerImpl_GetTechnique()

static D3DXHANDLE WINAPI ID3DXEffectCompilerImpl_GetTechnique ( ID3DXEffectCompiler *  iface,
UINT  index 
)
static

Definition at line 4652 of file effect.c.

4653{
4654 FIXME("iface %p, index %u stub!\n", iface, index);
4655
4656 return NULL;
4657}

◆ ID3DXEffectCompilerImpl_GetTechniqueByName()

static D3DXHANDLE WINAPI ID3DXEffectCompilerImpl_GetTechniqueByName ( ID3DXEffectCompiler *  iface,
const char *  name 
)
static

Definition at line 4659 of file effect.c.

4660{
4661 FIXME("iface %p, name %s stub!\n", iface, debugstr_a(name));
4662
4663 return NULL;
4664}

◆ ID3DXEffectCompilerImpl_GetTechniqueDesc()

static HRESULT WINAPI ID3DXEffectCompilerImpl_GetTechniqueDesc ( ID3DXEffectCompiler *  iface,
D3DXHANDLE  technique,
D3DXTECHNIQUE_DESC *  desc 
)
static

Definition at line 4596 of file effect.c.

4598{
4599 FIXME("iface %p, technique %p, desc %p stub!\n", iface, technique, desc);
4600
4601 return E_NOTIMPL;
4602}

◆ ID3DXEffectCompilerImpl_GetTexture()

static HRESULT WINAPI ID3DXEffectCompilerImpl_GetTexture ( struct ID3DXEffectCompiler *  iface,
D3DXHANDLE  parameter,
struct IDirect3DBaseTexture9 **  texture 
)
static

Definition at line 4969 of file effect.c.

4971{
4972 FIXME("iface %p, parameter %p, texture %p stub!\n", iface, parameter, texture);
4973
4974 return E_NOTIMPL;
4975}

◆ ID3DXEffectCompilerImpl_GetValue()

static HRESULT WINAPI ID3DXEffectCompilerImpl_GetValue ( ID3DXEffectCompiler *  iface,
D3DXHANDLE  parameter,
void *  data,
UINT  bytes 
)
static

Definition at line 4719 of file effect.c.

4721{
4722 FIXME("iface %p, parameter %p, data %p, bytes %u stub!\n", iface, parameter, data, bytes);
4723
4724 return E_NOTIMPL;
4725}

◆ ID3DXEffectCompilerImpl_GetVector()

static HRESULT WINAPI ID3DXEffectCompilerImpl_GetVector ( ID3DXEffectCompiler *  iface,
D3DXHANDLE  parameter,
D3DXVECTOR4 *  vector 
)
static

Definition at line 4825 of file effect.c.

4827{
4828 FIXME("iface %p, parameter %p, vector %p stub!\n", iface, parameter, vector);
4829
4830 return E_NOTIMPL;
4831}

◆ ID3DXEffectCompilerImpl_GetVectorArray()

static HRESULT WINAPI ID3DXEffectCompilerImpl_GetVectorArray ( ID3DXEffectCompiler *  iface,
D3DXHANDLE  parameter,
D3DXVECTOR4 *  vector,
UINT  count 
)
static

Definition at line 4841 of file effect.c.

4843{
4844 FIXME("iface %p, parameter %p, vector %p, count %u stub!\n", iface, parameter, vector, count);
4845
4846 return E_NOTIMPL;
4847}

◆ ID3DXEffectCompilerImpl_GetVertexShader()

static HRESULT WINAPI ID3DXEffectCompilerImpl_GetVertexShader ( struct ID3DXEffectCompiler *  iface,
D3DXHANDLE  parameter,
struct IDirect3DVertexShader9 **  shader 
)
static

Definition at line 4985 of file effect.c.

4987{
4988 FIXME("iface %p, parameter %p, shader %p stub!\n", iface, parameter, shader);
4989
4990 return E_NOTIMPL;
4991}

◆ ID3DXEffectCompilerImpl_QueryInterface()

static HRESULT WINAPI ID3DXEffectCompilerImpl_QueryInterface ( ID3DXEffectCompiler *  iface,
REFIID  riid,
void **  object 
)
static

Definition at line 4537 of file effect.c.

4538{
4539 TRACE("iface %p, riid %s, object %p.\n", iface, debugstr_guid(riid), object);
4540
4541 if (IsEqualGUID(riid, &IID_IUnknown)
4542 || IsEqualGUID(riid, &IID_ID3DXEffectCompiler))
4543 {
4544 iface->lpVtbl->AddRef(iface);
4545 *object = iface;
4546 return S_OK;
4547 }
4548
4549 WARN("%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid(riid));
4550
4551 *object = NULL;
4552 return E_NOINTERFACE;
4553}

◆ ID3DXEffectCompilerImpl_Release()

static ULONG WINAPI ID3DXEffectCompilerImpl_Release ( ID3DXEffectCompiler *  iface)
static

Definition at line 4565 of file effect.c.

4566{
4567 struct ID3DXEffectCompilerImpl *compiler = impl_from_ID3DXEffectCompiler(iface);
4568 ULONG refcount = InterlockedDecrement(&compiler->ref);
4569
4570 TRACE("%p decreasing refcount to %lu.\n", iface, refcount);
4571
4572 if (!refcount)
4573 {
4574 free(compiler);
4575 }
4576
4577 return refcount;
4578}

◆ ID3DXEffectCompilerImpl_SetArrayRange()

static HRESULT WINAPI ID3DXEffectCompilerImpl_SetArrayRange ( ID3DXEffectCompiler *  iface,
D3DXHANDLE  parameter,
UINT  start,
UINT  end 
)
static

Definition at line 4993 of file effect.c.

4995{
4996 FIXME("iface %p, parameter %p, start %u, end %u stub!\n", iface, parameter, start, end);
4997
4998 return E_NOTIMPL;
4999}

◆ ID3DXEffectCompilerImpl_SetBool()

static HRESULT WINAPI ID3DXEffectCompilerImpl_SetBool ( ID3DXEffectCompiler *  iface,
D3DXHANDLE  parameter,
BOOL  b 
)
static

Definition at line 4727 of file effect.c.

4728{
4729 FIXME("iface %p, parameter %p, b %#x stub!\n", iface, parameter, b);
4730
4731 return E_NOTIMPL;
4732}

◆ ID3DXEffectCompilerImpl_SetBoolArray()

static HRESULT WINAPI ID3DXEffectCompilerImpl_SetBoolArray ( ID3DXEffectCompiler *  iface,
D3DXHANDLE  parameter,
const BOOL *  b,
UINT  count 
)
static

Definition at line 4741 of file effect.c.

4743{
4744 FIXME("iface %p, parameter %p, b %p, count %u stub!\n", iface, parameter, b, count);
4745
4746 return E_NOTIMPL;
4747}

◆ ID3DXEffectCompilerImpl_SetFloat()

static HRESULT WINAPI ID3DXEffectCompilerImpl_SetFloat ( ID3DXEffectCompiler *  iface,
D3DXHANDLE  parameter,
float  f 
)
static

Definition at line 4787 of file effect.c.

4788{
4789 FIXME("iface %p, parameter %p, f %.8e stub!\n", iface, parameter, f);
4790
4791 return E_NOTIMPL;
4792}

◆ ID3DXEffectCompilerImpl_SetFloatArray()

static HRESULT WINAPI ID3DXEffectCompilerImpl_SetFloatArray ( ID3DXEffectCompiler *  iface,
D3DXHANDLE  parameter,
const float *  f,
UINT  count 
)
static

Definition at line 4801 of file effect.c.

4803{
4804 FIXME("iface %p, parameter %p, f %p, count %u stub!\n", iface, parameter, f, count);
4805
4806 return E_NOTIMPL;
4807}

◆ ID3DXEffectCompilerImpl_SetInt()

static HRESULT WINAPI ID3DXEffectCompilerImpl_SetInt ( ID3DXEffectCompiler *  iface,
D3DXHANDLE  parameter,
INT  n 
)
static

Definition at line 4757 of file effect.c.

4758{
4759 FIXME("iface %p, parameter %p, n %d stub!\n", iface, parameter, n);
4760
4761 return E_NOTIMPL;
4762}

◆ ID3DXEffectCompilerImpl_SetIntArray()

static HRESULT WINAPI ID3DXEffectCompilerImpl_SetIntArray ( ID3DXEffectCompiler *  iface,
D3DXHANDLE  parameter,
const INT *  n,
UINT  count 
)
static

Definition at line 4771 of file effect.c.

4773{
4774 FIXME("iface %p, parameter %p, n %p, count %u stub!\n", iface, parameter, n, count);
4775
4776 return E_NOTIMPL;
4777}

◆ ID3DXEffectCompilerImpl_SetLiteral()

static HRESULT WINAPI ID3DXEffectCompilerImpl_SetLiteral ( ID3DXEffectCompiler *  iface,
D3DXHANDLE  parameter,
BOOL  literal 
)
static

Definition at line 5002 of file effect.c.

5003{
5004 FIXME("iface %p, parameter %p, literal %#x stub!\n", iface, parameter, literal);
5005
5006 return E_NOTIMPL;
5007}

◆ ID3DXEffectCompilerImpl_SetMatrix()

static HRESULT WINAPI ID3DXEffectCompilerImpl_SetMatrix ( ID3DXEffectCompiler *  iface,
D3DXHANDLE  parameter,
const D3DXMATRIX *  matrix 
)
static

Definition at line 4849 of file effect.c.

4851{
4852 FIXME("iface %p, parameter %p, matrix %p stub!\n", iface, parameter, matrix);
4853
4854 return E_NOTIMPL;
4855}

◆ ID3DXEffectCompilerImpl_SetMatrixArray()

static HRESULT WINAPI ID3DXEffectCompilerImpl_SetMatrixArray ( ID3DXEffectCompiler *  iface,
D3DXHANDLE  parameter,
const D3DXMATRIX *  matrix,
UINT  count 
)
static

Definition at line 4865 of file effect.c.

4867{
4868 FIXME("iface %p, parameter %p, matrix %p, count %u stub!\n", iface, parameter, matrix, count);
4869
4870 return E_NOTIMPL;
4871}

◆ ID3DXEffectCompilerImpl_SetMatrixPointerArray()

static HRESULT WINAPI ID3DXEffectCompilerImpl_SetMatrixPointerArray ( ID3DXEffectCompiler *  iface,
D3DXHANDLE  parameter,
const D3DXMATRIX **  matrix,
UINT  count 
)
static

Definition at line 4881 of file effect.c.

4883{
4884 FIXME("iface %p, parameter %p, matrix %p, count %u stub!\n", iface, parameter, matrix, count);
4885
4886 return E_NOTIMPL;
4887}

◆ ID3DXEffectCompilerImpl_SetMatrixTranspose()

static HRESULT WINAPI ID3DXEffectCompilerImpl_SetMatrixTranspose ( ID3DXEffectCompiler *  iface,
D3DXHANDLE  parameter,
const D3DXMATRIX *  matrix 
)
static

Definition at line 4897 of file effect.c.

4899{
4900 FIXME("iface %p, parameter %p, matrix %p stub!\n", iface, parameter, matrix);
4901
4902 return E_NOTIMPL;
4903}

◆ ID3DXEffectCompilerImpl_SetMatrixTransposeArray()

static HRESULT WINAPI ID3DXEffectCompilerImpl_SetMatrixTransposeArray ( ID3DXEffectCompiler *  iface,
D3DXHANDLE  parameter,
const D3DXMATRIX *  matrix,
UINT  count 
)
static

Definition at line 4913 of file effect.c.

4915{
4916 FIXME("iface %p, parameter %p, matrix %p, count %u stub!\n", iface, parameter, matrix, count);
4917
4918 return E_NOTIMPL;
4919}

◆ ID3DXEffectCompilerImpl_SetMatrixTransposePointerArray()

static HRESULT WINAPI ID3DXEffectCompilerImpl_SetMatrixTransposePointerArray ( ID3DXEffectCompiler *  iface,
D3DXHANDLE  parameter,
const D3DXMATRIX **  matrix,
UINT  count 
)
static

Definition at line 4929 of file effect.c.

4931{
4932 FIXME("iface %p, parameter %p, matrix %p, count %u stub!\n", iface, parameter, matrix, count);
4933
4934 return E_NOTIMPL;
4935}

◆ ID3DXEffectCompilerImpl_SetString()

static HRESULT WINAPI ID3DXEffectCompilerImpl_SetString ( ID3DXEffectCompiler *  iface,
D3DXHANDLE  parameter,
const char *  string 
)
static

Definition at line 4945 of file effect.c.

4947{
4948 FIXME("iface %p, parameter %p, string %s stub!\n", iface, parameter, debugstr_a(string));
4949
4950 return E_NOTIMPL;
4951}

◆ ID3DXEffectCompilerImpl_SetTexture()

static HRESULT WINAPI ID3DXEffectCompilerImpl_SetTexture ( struct ID3DXEffectCompiler *  iface,
D3DXHANDLE  parameter,
struct IDirect3DBaseTexture9 *  texture 
)
static

Definition at line 4961 of file effect.c.

4963{
4964 FIXME("iface %p, parameter %p, texture %p stub!\n", iface, parameter, texture);
4965
4966 return E_NOTIMPL;
4967}

◆ ID3DXEffectCompilerImpl_SetValue()

static HRESULT WINAPI ID3DXEffectCompilerImpl_SetValue ( ID3DXEffectCompiler *  iface,
D3DXHANDLE  parameter,
const void *  data,
UINT  bytes 
)
static

Definition at line 4711 of file effect.c.

4713{
4714 FIXME("iface %p, parameter %p, data %p, bytes %u stub!\n", iface, parameter, data, bytes);
4715
4716 return E_NOTIMPL;
4717}

◆ ID3DXEffectCompilerImpl_SetVector()

static HRESULT WINAPI ID3DXEffectCompilerImpl_SetVector ( ID3DXEffectCompiler *  iface,
D3DXHANDLE  parameter,
const D3DXVECTOR4 *  vector 
)
static

Definition at line 4817 of file effect.c.

4819{
4820 FIXME("iface %p, parameter %p, vector %p stub!\n", iface, parameter, vector);
4821
4822 return E_NOTIMPL;
4823}

◆ ID3DXEffectCompilerImpl_SetVectorArray()

static HRESULT WINAPI ID3DXEffectCompilerImpl_SetVectorArray ( ID3DXEffectCompiler *  iface,
D3DXHANDLE  parameter,
const D3DXVECTOR4 *  vector,
UINT  count 
)
static

Definition at line 4833 of file effect.c.

4835{
4836 FIXME("iface %p, parameter %p, vector %p, count %u stub!\n", iface, parameter, vector, count);
4837
4838 return E_NOTIMPL;
4839}

◆ impl_from_ID3DXEffect()

static struct d3dx_effect * impl_from_ID3DXEffect ( ID3DXEffect *  iface)
inlinestatic

Definition at line 1959 of file effect.c.

1960{
1961 return CONTAINING_RECORD(iface, struct d3dx_effect, ID3DXEffect_iface);
1962}
CONTAINING_RECORD
#define CONTAINING_RECORD(address, type, field)
Definition: typedefs.h:260

Referenced by d3dx_effect_AddRef(), d3dx_effect_Begin(), d3dx_effect_BeginParameterBlock(), d3dx_effect_BeginPass(), d3dx_effect_CloneEffect(), d3dx_effect_CommitChanges(), d3dx_effect_End(), d3dx_effect_EndParameterBlock(), d3dx_effect_EndPass(), d3dx_effect_FindNextValidTechnique(), d3dx_effect_GetAnnotation(), d3dx_effect_GetAnnotationByName(), d3dx_effect_GetBool(), d3dx_effect_GetBoolArray(), d3dx_effect_GetCurrentTechnique(), d3dx_effect_GetDesc(), d3dx_effect_GetDevice(), d3dx_effect_GetFloat(), d3dx_effect_GetFloatArray(), d3dx_effect_GetInt(), d3dx_effect_GetIntArray(), d3dx_effect_GetMatrix(), d3dx_effect_GetMatrixArray(), d3dx_effect_GetMatrixPointerArray(), d3dx_effect_GetMatrixTranspose(), d3dx_effect_GetMatrixTransposeArray(), d3dx_effect_GetMatrixTransposePointerArray(), d3dx_effect_GetParameter(), d3dx_effect_GetParameterByName(), d3dx_effect_GetParameterBySemantic(), d3dx_effect_GetParameterDesc(), d3dx_effect_GetParameterElement(), d3dx_effect_GetPass(), d3dx_effect_GetPassByName(), d3dx_effect_GetPassDesc(), d3dx_effect_GetPixelShader(), d3dx_effect_GetPool(), d3dx_effect_GetStateManager(), d3dx_effect_GetString(), d3dx_effect_GetTechnique(), d3dx_effect_GetTechniqueByName(), d3dx_effect_GetTechniqueDesc(), d3dx_effect_GetTexture(), d3dx_effect_GetValue(), d3dx_effect_GetVector(), d3dx_effect_GetVectorArray(), d3dx_effect_GetVertexShader(), d3dx_effect_IsParameterUsed(), d3dx_effect_OnLostDevice(), d3dx_effect_OnResetDevice(), d3dx_effect_Release(), d3dx_effect_SetBool(), d3dx_effect_SetBoolArray(), d3dx_effect_SetFloat(), d3dx_effect_SetFloatArray(), d3dx_effect_SetInt(), d3dx_effect_SetIntArray(), d3dx_effect_SetMatrix(), d3dx_effect_SetMatrixArray(), d3dx_effect_SetMatrixPointerArray(), d3dx_effect_SetMatrixTranspose(), d3dx_effect_SetMatrixTransposeArray(), d3dx_effect_SetMatrixTransposePointerArray(), d3dx_effect_SetStateManager(), d3dx_effect_SetString(), d3dx_effect_SetTechnique(), d3dx_effect_SetTexture(), d3dx_effect_SetValue(), d3dx_effect_SetVector(), d3dx_effect_SetVectorArray(), and d3dx_effect_ValidateTechnique().

◆ impl_from_ID3DXEffectCompiler()

static struct ID3DXEffectCompilerImpl * impl_from_ID3DXEffectCompiler ( ID3DXEffectCompiler *  iface)
inlinestatic

Definition at line 4531 of file effect.c.

4532{
4533 return CONTAINING_RECORD(iface, struct ID3DXEffectCompilerImpl, ID3DXEffectCompiler_iface);
4534}

Referenced by ID3DXEffectCompilerImpl_AddRef(), and ID3DXEffectCompilerImpl_Release().

◆ impl_from_ID3DXEffectPool()

static struct d3dx_effect_pool * impl_from_ID3DXEffectPool ( ID3DXEffectPool *  iface)
inlinestatic

Definition at line 1952 of file effect.c.

1953{
1954 return CONTAINING_RECORD(iface, struct d3dx_effect_pool, ID3DXEffectPool_iface);
1955}

Referenced by d3dx_effect_pool_AddRef(), d3dx_effect_pool_Release(), and unsafe_impl_from_ID3DXEffectPool().

◆ is_parameter_used()

static BOOL is_parameter_used ( struct d3dx_parameter *  param,
struct d3dx_technique *  tech 
)
static

Definition at line 3918 of file effect.c.

3919{
3920 unsigned int i, j;
3921 struct d3dx_pass *pass;
3922
3923 if (!tech || !param)
3924 return FALSE;
3925
3926 for (i = 0; i < tech->pass_count; ++i)
3927 {
3928 pass = &tech->passes[i];
3929 for (j = 0; j < pass->state_count; ++j)
3930 {
3931 if (walk_state_dep(&pass->states[j], is_same_parameter, param))
3932 return TRUE;
3933 }
3934 }
3935 return FALSE;
3936}
walk_state_dep
static BOOL walk_state_dep(struct d3dx_state *state, walk_parameter_dep_func param_func, void *data)
Definition: effect.c:3861

Referenced by d3dx9_effect_init_from_binary(), and d3dx_effect_IsParameterUsed().

◆ is_same_parameter()

static BOOL is_same_parameter ( void *  param1_,
struct d3dx_parameter *  param2 
)
static

Definition at line 1807 of file effect.c.

1808{
1809 struct d3dx_parameter *param1 = (struct d3dx_parameter *)param1_;
1810 BOOL matches;
1811 unsigned int i, member_count;
1812
1813 matches = !strcmp(param1->name, param2->name) && param1->class == param2->class
1814 && param1->type == param2->type && param1->rows == param2->rows
1815 && param1->columns == param2->columns && param1->element_count == param2->element_count
1816 && param1->member_count == param2->member_count;
1817
1818 member_count = param1->element_count ? param1->element_count : param1->member_count;
1819
1820 if (!matches || !member_count)
1821 return matches;
1822
1823 for (i = 0; i < member_count; ++i)
1824 {
1825 if (!is_same_parameter(&param1->members[i], &param2->members[i]))
1826 return FALSE;
1827 }
1828 return TRUE;
1829}
matches
#define matches(FN)
Definition: match.h:70
d3dx_parameter::rows
unsigned int rows
Definition: d3dx9_private.h:520
d3dx_parameter::class
D3DXPARAMETER_CLASS class
Definition: d3dx9_private.h:518
d3dx_parameter::columns
unsigned int columns
Definition: d3dx9_private.h:521

Referenced by d3dx_pool_sync_shared_parameter(), is_parameter_used(), and is_same_parameter().

◆ next_effect_update_version()

static ULONG64 next_effect_update_version ( struct d3dx_effect *  effect)
static

Definition at line 1291 of file effect.c.

1292{
1293 return next_update_version(get_version_counter_ptr(effect));
1294}
next_update_version
static ULONG64 next_update_version(ULONG64 *version_counter)
Definition: d3dx9_private.h:566

Referenced by d3dx9_apply_pass_states().

◆ next_valid_constant_name()

static char * next_valid_constant_name ( char **  string)
static

Definition at line 6420 of file effect.c.

6421{
6422 char *ret = *string;
6423 char *next;
6424
6425 while (*ret && !isalpha(*ret) && *ret != '_')
6426 ++ret;
6427 if (!*ret)
6428 return NULL;
6429
6430 next = ret + 1;
6431 while (isalpha(*next) || isdigit(*next) || *next == '_')
6432 ++next;
6433 if (*next)
6434 *next++ = 0;
6435 *string = next;
6436 return ret;
6437}
isalpha
#define isalpha(c)
Definition: acclib.h:74
isdigit
#define isdigit(c)
Definition: acclib.h:68
string
char string[160]
Definition: util.h:11
next
static unsigned __int64 next
Definition: rand_nt.c:6

Referenced by parse_skip_constants_string().

◆ param_get_data_and_dirtify()

static void * param_get_data_and_dirtify ( struct d3dx_effect *  effect,
struct d3dx_parameter *  param,
unsigned int  bytes,
BOOL  value_changed 
)
static

Definition at line 1346 of file effect.c.

1348{
1349 assert(bytes <= param->bytes);
1350
1351 if (value_changed && !effect->current_parameter_block)
1352 set_dirty(param);
1353
1354 return effect->current_parameter_block ? record_parameter(effect, param, bytes) : param->data;
1355}
record_parameter
static void * record_parameter(struct d3dx_effect *effect, struct d3dx_parameter *param, unsigned int bytes)
Definition: effect.c:1296

Referenced by d3dx_effect_ApplyParameterBlock(), d3dx_effect_SetBool(), d3dx_effect_SetBoolArray(), d3dx_effect_SetFloat(), d3dx_effect_SetFloatArray(), d3dx_effect_SetInt(), d3dx_effect_SetIntArray(), d3dx_effect_SetMatrix(), d3dx_effect_SetMatrixArray(), d3dx_effect_SetMatrixPointerArray(), d3dx_effect_SetMatrixTranspose(), d3dx_effect_SetMatrixTransposeArray(), d3dx_effect_SetMatrixTransposePointerArray(), d3dx_effect_SetString(), d3dx_effect_SetTexture(), d3dx_effect_SetValue(), d3dx_effect_SetVector(), and d3dx_effect_SetVectorArray().

◆ param_on_lost_device()

static BOOL param_on_lost_device ( void *  data,
struct d3dx_parameter *  param 
)
static

Definition at line 4119 of file effect.c.

4120{
4121 struct IDirect3DVolumeTexture9 *volume_texture;
4122 struct IDirect3DCubeTexture9 *cube_texture;
4123 struct IDirect3DTexture9 *texture;
4124 D3DSURFACE_DESC surface_desc;
4125 D3DVOLUME_DESC volume_desc;
4126
4127 if (param->class == D3DXPC_OBJECT && !param->element_count)
4128 {
4129 switch (param->type)
4130 {
4131 case D3DXPT_TEXTURE:
4132 case D3DXPT_TEXTURE1D:
4133 case D3DXPT_TEXTURE2D:
4134 texture = *(IDirect3DTexture9 **)param->data;
4135 if (!texture)
4136 return FALSE;
4137 IDirect3DTexture9_GetLevelDesc(texture, 0, &surface_desc);
4138 if (surface_desc.Pool != D3DPOOL_DEFAULT)
4139 return FALSE;
4140 break;
4141 case D3DXPT_TEXTURE3D:
4142 volume_texture = *(IDirect3DVolumeTexture9 **)param->data;
4143 if (!volume_texture)
4144 return FALSE;
4145 IDirect3DVolumeTexture9_GetLevelDesc(volume_texture, 0, &volume_desc);
4146 if (volume_desc.Pool != D3DPOOL_DEFAULT)
4147 return FALSE;
4148 break;
4149 case D3DXPT_TEXTURECUBE:
4150 cube_texture = *(IDirect3DCubeTexture9 **)param->data;
4151 if (!cube_texture)
4152 return FALSE;
4153 IDirect3DCubeTexture9_GetLevelDesc(cube_texture, 0, &surface_desc);
4154 if (surface_desc.Pool != D3DPOOL_DEFAULT)
4155 return FALSE;
4156 break;
4157 default:
4158 return FALSE;
4159 }
4160 IUnknown_Release(*(IUnknown **)param->data);
4161 *(IUnknown **)param->data = NULL;
4162 }
4163 return FALSE;
4164}
D3DPOOL_DEFAULT
@ D3DPOOL_DEFAULT
Definition: d3d8types.h:709
IDirect3DTexture9_GetLevelDesc
#define IDirect3DTexture9_GetLevelDesc(p, a, b)
Definition: d3d9.h:860
IDirect3DVolumeTexture9_GetLevelDesc
#define IDirect3DVolumeTexture9_GetLevelDesc(p, a, b)
Definition: d3d9.h:955
IDirect3DCubeTexture9_GetLevelDesc
#define IDirect3DCubeTexture9_GetLevelDesc(p, a, b)
Definition: d3d9.h:765
_D3DSURFACE_DESC
Definition: d3d8types.h:1169
_D3DSURFACE_DESC::Pool
D3DPOOL Pool
Definition: d3d8types.h:1173
_D3DVOLUME_DESC
Definition: d3d8types.h:1205
_D3DVOLUME_DESC::Pool
D3DPOOL Pool
Definition: d3d8types.h:1209

Referenced by d3dx_effect_OnLostDevice().

◆ param_rb_compare()

static int param_rb_compare ( const void *  key,
const struct wine_rb_entry *  entry 
)
static

Definition at line 735 of file effect.c.

736{
737 const char *name = key;
738 struct d3dx_parameter *param = WINE_RB_ENTRY_VALUE(entry, struct d3dx_parameter, rb_entry);
739
740 return strcmp(name, param->full_name);
741}
key
Definition: copy.c:22

Referenced by d3dx_init_parameters_store().

◆ param_set_data_pointer()

static void param_set_data_pointer ( struct d3dx_parameter *  param,
unsigned char *  data,
BOOL  child,
BOOL  free_data 
)
static

Definition at line 1790 of file effect.c.

1791{
1792 unsigned char *member_data = data;
1793 unsigned int i, count;
1794
1795 count = param->element_count ? param->element_count : param->member_count;
1796 for (i = 0; i < count; ++i)
1797 {
1798 param_set_data_pointer(&param->members[i], member_data, TRUE, free_data);
1799 if (data)
1800 member_data += param->members[i].bytes;
1801 }
1802 if (free_data)
1803 free_parameter_data(param, child);
1804 param->data = data;
1805}

Referenced by d3dx_pool_sync_shared_parameter(), free_effect_pool(), and param_set_data_pointer().

◆ param_set_magic_number()

static void param_set_magic_number ( struct d3dx_parameter *  param)
static

Definition at line 5362 of file effect.c.

5363{
5364 memcpy(param->magic_string, parameter_magic_string, sizeof(parameter_magic_string));
5365}

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

◆ param_set_top_level_param()

static BOOL param_set_top_level_param ( void *  top_level_param,
struct d3dx_parameter *  param 
)
static

Definition at line 6272 of file effect.c.

6273{
6274 param->top_level_param = top_level_param;
6275 return FALSE;
6276}

Referenced by d3dx_parse_effect().

◆ param_zero_data_func()

static BOOL param_zero_data_func ( void *  dummy,
struct d3dx_parameter *  param 
)
static

Definition at line 1911 of file effect.c.

1912{
1913 param->data = NULL;
1914 return FALSE;
1915}

Referenced by d3dx_pool_release_shared_parameter(), and free_effect_pool().

◆ parse_skip_constants_string()

static const char ** parse_skip_constants_string ( char *  skip_constants_string,
unsigned int *  names_count 
)
static

Definition at line 6439 of file effect.c.

6440{
6441 const char **names, **new_alloc;
6442 const char *name;
6443 char *s;
6444 unsigned int size = INITIAL_CONST_NAMES_SIZE;
6445
6446 names = malloc(sizeof(*names) * size);
6447 if (!names)
6448 return NULL;
6449
6450 *names_count = 0;
6451 s = skip_constants_string;
6452 while ((name = next_valid_constant_name(&s)))
6453 {
6454 if (*names_count == size)
6455 {
6456 size *= 2;
6457 new_alloc = realloc(names, sizeof(*names) * size);
6458 if (!new_alloc)
6459 {
6460 free(names);
6461 return NULL;
6462 }
6463 names = new_alloc;
6464 }
6465 names[(*names_count)++] = name;
6466 }
6467 new_alloc = realloc(names, *names_count * sizeof(*names));
6468 if (!new_alloc)
6469 return names;
6470 return new_alloc;
6471}
next_valid_constant_name
static char * next_valid_constant_name(char **string)
Definition: effect.c:6420
INITIAL_CONST_NAMES_SIZE
#define INITIAL_CONST_NAMES_SIZE
Definition: effect.c:6418
s
GLdouble s
Definition: gl.h:2039
names
GLuint GLuint * names
Definition: glext.h:11545

Referenced by d3dx9_effect_init_from_binary().

◆ read_u32()

static uint32_t read_u32 ( const char **  ptr)
inlinestatic

Definition at line 435 of file effect.c.

436{
437 uint32_t u;
438
439 memcpy(&u, *ptr, sizeof(u));
440 *ptr += sizeof(u);
441 return u;
442}

◆ record_parameter()

static void * record_parameter ( struct d3dx_effect *  effect,
struct d3dx_parameter *  param,
unsigned int  bytes 
)
static

Definition at line 1296 of file effect.c.

1297{
1298 struct d3dx_parameter_block *block = effect->current_parameter_block;
1299 struct d3dx_recorded_parameter new_record, *record;
1300 unsigned int new_size, alloc_size;
1301
1302 new_record.param = param;
1303 new_record.bytes = bytes;
1304 new_size = block->offset + get_recorded_parameter_size(&new_record);
1305
1306 if (new_size > block->size)
1307 {
1308 BYTE *new_alloc;
1309
1310 alloc_size = max(block->size * 2, max(new_size, INITIAL_PARAM_BLOCK_SIZE));
1311 new_alloc = realloc(block->buffer, alloc_size);
1312 if (!new_alloc)
1313 {
1314 ERR("Out of memory.\n");
1315 return param->data;
1316 }
1317 /* Data update functions may want to free some references upon setting value. */
1318 memset(new_alloc + block->size, 0, alloc_size - block->size);
1319
1320 block->size = alloc_size;
1321 block->buffer = new_alloc;
1322 }
1323 record = (struct d3dx_recorded_parameter *)(block->buffer + block->offset);
1324 *record = new_record;
1325 block->offset = new_size;
1326 return record + 1;
1327}
INITIAL_PARAM_BLOCK_SIZE
#define INITIAL_PARAM_BLOCK_SIZE
Definition: effect.c:39

Referenced by param_get_data_and_dirtify().

◆ set_dirty()

static void set_dirty ( struct d3dx_parameter *  param)
static

Definition at line 1329 of file effect.c.

1330{
1331 struct d3dx_top_level_parameter *top_param = param->top_level_param;
1332 struct d3dx_shared_data *shared_data;
1333 ULONG64 new_update_version;
1334
1335 /* This is true for annotations. */
1336 if (!top_param)
1337 return;
1338
1339 new_update_version = next_update_version(top_param->version_counter);
1340 if ((shared_data = top_param->shared_data))
1341 shared_data->update_version = new_update_version;
1342 else
1343 top_param->update_version = new_update_version;
1344}
d3dx_shared_data::update_version
ULONG64 update_version
Definition: d3dx9_private.h:550
d3dx_top_level_parameter::shared_data
struct d3dx_shared_data * shared_data
Definition: d3dx9_private.h:542
d3dx_top_level_parameter::version_counter
ULONG64 * version_counter
Definition: d3dx9_private.h:541
d3dx_top_level_parameter::update_version
ULONG64 update_version
Definition: d3dx9_private.h:540

Referenced by d3dx_parse_effect(), param_get_data_and_dirtify(), and PersistStreamInit_Save().

◆ set_matrix()

static void set_matrix ( struct d3dx_parameter *  param,
const D3DXMATRIX *  matrix,
void *  dst_data 
)
static

Definition at line 852 of file effect.c.

853{
854 UINT i, k;
855
856 if (param->type == D3DXPT_FLOAT)
857 {
858 if (param->columns == 4)
859 {
860 memcpy(dst_data, matrix->m, param->rows * 4 * sizeof(float));
861 }
862 else
863 {
864 for (i = 0; i < param->rows; ++i)
865 memcpy((float *)dst_data + i * param->columns, matrix->m + i, param->columns * sizeof(float));
866 }
867 return;
868 }
869
870 for (i = 0; i < param->rows; ++i)
871 {
872 for (k = 0; k < param->columns; ++k)
873 set_number((FLOAT *)dst_data + i * param->columns + k, param->type,
874 &matrix->m[i][k], D3DXPT_FLOAT);
875 }
876}

Referenced by d3dx_effect_SetMatrix(), d3dx_effect_SetMatrixArray(), and d3dx_effect_SetMatrixPointerArray().

◆ set_matrix_transpose()

static void set_matrix_transpose ( struct d3dx_parameter *  param,
const D3DXMATRIX *  matrix,
void *  dst_data 
)
static

Definition at line 878 of file effect.c.

879{
880 UINT i, k;
881
882 for (i = 0; i < param->rows; ++i)
883 {
884 for (k = 0; k < param->columns; ++k)
885 {
886 set_number((FLOAT *)dst_data + i * param->columns + k, param->type,
887 &matrix->m[k][i], D3DXPT_FLOAT);
888 }
889 }
890}

Referenced by d3dx_effect_SetMatrixTranspose(), d3dx_effect_SetMatrixTransposeArray(), and d3dx_effect_SetMatrixTransposePointerArray().

◆ set_string()

static HRESULT set_string ( char **  param_data,
const char *  string 
)
static

Definition at line 892 of file effect.c.

893{
894 free(*param_data);
895 *param_data = strdup(string);
896 if (!*param_data)
897 {
898 ERR("Out of memory.\n");
899 return E_OUTOFMEMORY;
900 }
901 return D3D_OK;
902}

Referenced by d3dx_effect_SetString(), and set_value().

◆ set_value()

static HRESULT set_value ( struct d3dx_parameter *  param,
const void *  data,
unsigned int  bytes,
void *  dst_data 
)
static

Definition at line 904 of file effect.c.

906{
907 unsigned int i, count;
908
909 bytes = min(bytes, param->bytes);
910 count = min(param->element_count ? param->element_count : 1, bytes / sizeof(void *));
911
912 switch (param->type)
913 {
914 case D3DXPT_TEXTURE:
915 case D3DXPT_TEXTURE1D:
916 case D3DXPT_TEXTURE2D:
917 case D3DXPT_TEXTURE3D:
918 case D3DXPT_TEXTURECUBE:
919 for (i = 0; i < count; ++i)
920 {
921 IUnknown *old_texture = ((IUnknown **)dst_data)[i];
922 IUnknown *new_texture = ((IUnknown **)data)[i];
923
924 if (new_texture == old_texture)
925 continue;
926
927 if (new_texture)
928 IUnknown_AddRef(new_texture);
929 if (old_texture)
930 IUnknown_Release(old_texture);
931 }
932 /* fallthrough */
933 case D3DXPT_VOID:
934 case D3DXPT_BOOL:
935 case D3DXPT_INT:
936 case D3DXPT_FLOAT:
937 TRACE("Copy %u bytes.\n", bytes);
938 memcpy(dst_data, data, bytes);
939 break;
940
941 case D3DXPT_STRING:
942 {
943 HRESULT hr;
944
945 for (i = 0; i < count; ++i)
946 if (FAILED(hr = set_string(&((char **)dst_data)[i], ((const char **)data)[i])))
947 return hr;
948 break;
949 }
950
951 default:
952 FIXME("Unhandled type %s.\n", debug_d3dxparameter_type(param->type));
953 break;
954 }
955
956 return D3D_OK;
957}

Referenced by d3dx_effect_ApplyParameterBlock(), d3dx_effect_SetValue(), hex_data_state(), and put_propval().

◆ set_vector()

static void set_vector ( struct d3dx_parameter *  param,
const D3DXVECTOR4 *  vector,
void *  dst_data 
)
static

Definition at line 826 of file effect.c.

827{
828 UINT i;
829
830 for (i = 0; i < param->columns; ++i)
831 set_number((FLOAT *)dst_data + i, param->type, (FLOAT *)vector + i, D3DXPT_FLOAT);
832}

Referenced by d3dx_effect_SetVector(), and d3dx_effect_SetVectorArray().

◆ unsafe_impl_from_ID3DXEffectPool()

static struct d3dx_effect_pool * unsafe_impl_from_ID3DXEffectPool ( ID3DXEffectPool *  iface)
inlinestatic

Definition at line 6866 of file effect.c.

6867{
6868 if (!iface)
6869 return NULL;
6870
6871 assert(iface->lpVtbl == &ID3DXEffectPool_Vtbl);
6872 return impl_from_ID3DXEffectPool(iface);
6873}

Referenced by d3dx9_effect_init_from_binary().

◆ walk_param_eval_dep()

static BOOL walk_param_eval_dep ( struct d3dx_param_eval *  param_eval,
walk_parameter_dep_func  param_func,
void *  data 
)
static

Definition at line 3834 of file effect.c.

3836{
3837 struct d3dx_parameter **params;
3838 unsigned int i, param_count;
3839
3840 if (!param_eval)
3841 return FALSE;
3842
3843 params = param_eval->shader_inputs.inputs_param;
3844 param_count = param_eval->shader_inputs.input_count;
3845 for (i = 0; i < param_count; ++i)
3846 {
3847 if (walk_parameter_dep(params[i], param_func, data))
3848 return TRUE;
3849 }
3850
3851 params = param_eval->pres.inputs.inputs_param;
3852 param_count = param_eval->pres.inputs.input_count;
3853 for (i = 0; i < param_count; ++i)
3854 {
3855 if (walk_parameter_dep(params[i], param_func, data))
3856 return TRUE;
3857 }
3858 return FALSE;
3859}
walk_parameter_dep
static BOOL walk_parameter_dep(struct d3dx_parameter *param, walk_parameter_dep_func param_func, void *data)
Definition: effect.c:3877

Referenced by walk_parameter_dep(), and walk_state_dep().

◆ walk_parameter_dep()

static BOOL walk_parameter_dep ( struct d3dx_parameter *  param,
walk_parameter_dep_func  param_func,
void *  data 
)
static

Definition at line 3877 of file effect.c.

3879{
3880 unsigned int i;
3881 unsigned int member_count;
3882
3883 param = &param->top_level_param->param;
3884 if (param_func(data, param))
3885 return TRUE;
3886
3887 if (walk_param_eval_dep(param->param_eval, param_func, data))
3888 return TRUE;
3889
3890 if (param->class == D3DXPC_OBJECT && is_param_type_sampler(param->type))
3891 {
3892 struct d3dx_sampler *sampler;
3893 unsigned int sampler_idx;
3894 unsigned int samplers_count = max(param->element_count, 1);
3895
3896 for (sampler_idx = 0; sampler_idx < samplers_count; ++sampler_idx)
3897 {
3898 sampler = param->element_count ? param->members[sampler_idx].data : param->data;
3899 for (i = 0; i < sampler->state_count; ++i)
3900 {
3901 if (walk_state_dep(&sampler->states[i], param_func, data))
3902 return TRUE;
3903 }
3904 }
3905 return FALSE;
3906 }
3907
3908 member_count = param->element_count ? param->element_count : param->member_count;
3909 for (i = 0; i < member_count; ++i)
3910 {
3911 if (walk_param_eval_dep(param->members[i].param_eval, param_func, data))
3912 return TRUE;
3913 }
3914
3915 return FALSE;
3916}
walk_param_eval_dep
static BOOL walk_param_eval_dep(struct d3dx_param_eval *param_eval, walk_parameter_dep_func param_func, void *data)
Definition: effect.c:3834

Referenced by walk_param_eval_dep(), and walk_state_dep().

◆ walk_parameter_tree()

static BOOL walk_parameter_tree ( struct d3dx_parameter *  param,
walk_parameter_dep_func  param_func,
void *  data 
)
static

Definition at line 1268 of file effect.c.

1270{
1271 unsigned int i;
1272 unsigned int member_count;
1273
1274 if (param_func(data, param))
1275 return TRUE;
1276
1277 member_count = param->element_count ? param->element_count : param->member_count;
1278 for (i = 0; i < member_count; ++i)
1279 {
1280 if (walk_parameter_tree(&param->members[i], param_func, data))
1281 return TRUE;
1282 }
1283 return FALSE;
1284}

Referenced by d3dx_effect_OnLostDevice(), d3dx_parse_effect(), d3dx_pool_release_shared_parameter(), free_effect_pool(), and walk_parameter_tree().

◆ walk_state_dep()

static BOOL walk_state_dep ( struct d3dx_state *  state,
walk_parameter_dep_func  param_func,
void *  data 
)
static

Definition at line 3861 of file effect.c.

3863{
3864 if (state->type == ST_CONSTANT && is_param_type_sampler(state->parameter.type))
3865 {
3866 if (walk_parameter_dep(&state->parameter, param_func, data))
3867 return TRUE;
3868 }
3869 else if (state->type == ST_ARRAY_SELECTOR || state->type == ST_PARAMETER)
3870 {
3871 if (walk_parameter_dep(state->referenced_param, param_func, data))
3872 return TRUE;
3873 }
3874 return walk_param_eval_dep(state->parameter.param_eval, param_func, data);
3875}

Referenced by is_parameter_used(), and walk_parameter_dep().

◆ WINE_DEFAULT_DEBUG_CHANNEL()

WINE_DEFAULT_DEBUG_CHANNEL ( d3dx  )

Variable Documentation

◆ class

enum STATE_CLASS class

Definition at line 234 of file effect.c.

◆ ID3DXEffect_Vtbl

const struct ID3DXEffectVtbl ID3DXEffect_Vtbl
static

Definition at line 4441 of file effect.c.

Referenced by d3dx9_effect_init_from_binary().

◆ ID3DXEffectCompiler_Vtbl

const struct ID3DXEffectCompilerVtbl ID3DXEffectCompiler_Vtbl
static

Definition at line 5034 of file effect.c.

Referenced by d3dx9_effect_compiler_init().

◆ ID3DXEffectPool_Vtbl

const struct ID3DXEffectPoolVtbl ID3DXEffectPool_Vtbl
static
Initial value:
=
{
d3dx_effect_pool_QueryInterface,
d3dx_effect_pool_AddRef,
d3dx_effect_pool_Release
}
d3dx_effect_pool_AddRef
static ULONG WINAPI d3dx_effect_pool_AddRef(ID3DXEffectPool *iface)
Definition: effect.c:6808
d3dx_effect_pool_Release
static ULONG WINAPI d3dx_effect_pool_Release(ID3DXEffectPool *iface)
Definition: effect.c:6845
d3dx_effect_pool_QueryInterface
static HRESULT WINAPI d3dx_effect_pool_QueryInterface(ID3DXEffectPool *iface, REFIID riid, void **object)
Definition: effect.c:6791

Definition at line 6858 of file effect.c.

Referenced by D3DXCreateEffectPool(), and unsafe_impl_from_ID3DXEffectPool().

◆ name

const char* name

Definition at line 236 of file effect.c.

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

◆ op

GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat op

Definition at line 235 of file effect.c.

Referenced by CFSDropTarget::_DoDrop(), _FileOpCount(), _FileOpCountManager(), _log_special_common(), _logf_special_common(), _mesa_Accum(), _SetOperationTexts(), _SetOperationTitle(), access_field_unit(), add_thread_job(), KeyTranslator::AddKeyDef(), allocate_instr_temp_register(), allocate_sincos_const_registers(), Arguments_gc_traverse(), BindFunction_gc_traverse(), build_filepathsW(), build_multi_string_value(), calc(), CB_MergeDeleteOddSrc(), CB_MergeInsertSrc(), CheckForError(), compile_assign_expression(), compile_assignment(), compile_binary_expression(), compile_call_expression(), compile_increment_expression(), compile_logical_expression(), compile_typeof_expression(), compile_unary_expression(), compound_encode_send_decode(), compute_location(), ConstCheck(), copy_dir_to_dir(), copy_file_to_file(), copy_files(), copy_to_dir(), cpu_blitter_blit(), crc32_combine_op(), d3d10_blend_op_from_d3d11(), d3d12_command_queue_CopyTileMappings(), d3d12_command_queue_destroy_op(), d3d12_command_queue_ExecuteCommandLists(), d3d12_command_queue_flush_ops_locked(), d3d12_command_queue_Signal(), d3d12_command_queue_UpdateTileMappings(), d3d12_command_queue_Wait(), d3d12_swapchain_destroy(), d3d12_swapchain_op_destroy(), d3d12_swapchain_op_present_execute(), d3d12_swapchain_op_resize_buffers_execute(), d3d12_swapchain_present(), d3d12_swapchain_resize_buffers(), d3d12_swapchain_worker_proc(), d3dx9_set_light_parameter(), d3dx9_set_material_parameter(), d3dx_set_shader_const_state(), DataView_gc_traverse(), debug_cs_op(), debug_hlsl_expr_op(), delete_files(), do_binary_math(), do_op(), CCopyMoveToMenu::DoRealFileOp(), dwarfpctoline(), dx_map_quad_op(), EmitREBytecode(), enter_bytecode(), Enumerator_gc_traverse(), epoll_ctl(), eval_boolcmp(), eval_refcmp(), eval_strcmp(), evalStack(), exec_change_infix(), exec_closeparent(), exec_op(), exec_script(), execute_cfa_instructions(), ExecuteREBytecode(), Ext2CreateMdl(), fbo_blitter_blit(), ffp_blitter_blit(), FileOpCallback(), free_file_op_queue(), FSE_compress_wksp(), FSE_decompress_usingDTable_generic(), Function_gc_traverse(), gc_process_linked_obj(), gc_process_linked_val(), generate_fragment_op(), get_expression_operator(), get_op(), get_operation(), get_src_file_info(), gl_Accum(), gl_blend_op(), gl_save_Accum(), gl_stencil_op(), glsl_blitter_blit(), handle_binary_logic(), handle_binary_math(), handle_io_region(), handle_logical_less_or_greater(), handle_memory_region(), handle_pci_region(), handle_seh_pragma(), handle_special_field(), handle_table_data_region(), handle_unary_math(), hlsl_new_binary_expr(), hlsl_new_expr(), hlsl_new_ternary_expr(), hlsl_new_unary_expr(), HUF_compress1X_usingCTable_internal_body(), HUF_compress4X_usingCTable_internal(), HUF_compress_internal(), HUF_compressCTable_internal(), HUF_compressWeights(), HUF_decodeLastSymbolX2(), HUF_decodeSymbolX2(), HUF_decompress1X1_usingDTable_internal_body(), HUF_writeCTable(), inflate_fast(), InterpretedFunction_gc_traverse(), io_region_do_rw(), is_invalid_op(), join_multi_string_values(), lower_nonconstant_vector_derefs(), lower_trig(), lzo1x_1_compress(), lzo_do_compress(), map_binary_op(), map_dx_binary_op(), map_dx_unary_op(), Map_gc_traverse(), match_one(), memory_region_do_rw(), move_dir_to_dir(), move_file_to_file(), move_files(), move_to_dir(), NewRENode(), nfs41_DevFcbXXXControlFile(), op_allows_unresolved(), op_allows_unresolved_if_load(), op_decode_aml_op(), OP_I(), OP_I64(), op_is_internal(), op_is_invalid(), OP_sI(), op_table_find(), op_wants_supername(), op_wants_term_arg_or_operand(), TKeyDef::operator=(), option_as_string(), ParseRegExp(), pci_region_do_rw(), peek_next_op(), pev_binop(), pretty_print_option(), prim(), print_fs_ioctl(), print_ioctl(), ProcessOp(), pswitch(), push(), push_instr(), push_instr_addr(), push_instr_bstr(), push_instr_bstr_uint(), push_instr_date(), push_instr_double(), push_instr_int(), push_instr_str(), push_instr_str_uint(), push_instr_uint(), push_instr_uint_bstr(), push_instr_uint_str(), PushBackTrackState(), queue_file_op(), raw_blitter_blit(), RegExp_gc_traverse(), rename_files(), ResetOpCode(), RichEditWndProc_common(), run_copy(), scope_gc_traverse(), set_firewall(), set_op(), set_options(), set_pixel(), seta_assignment(), seta_bitAndTerm(), seta_ltorTerm(), seta_mulTerm(), SetOpCode(), SetupCommitFileQueueW(), SetupGetFileQueueCount(), SetupQueueCopyIndirectA(), SetupQueueCopyIndirectW(), SetupQueueDeleteA(), SetupQueueDeleteW(), SetupQueueRenameA(), SetupQueueRenameW(), SetupScanFileQueueW(), shader_glsl_atomic(), shader_glsl_binop(), shader_glsl_conditional_op(), shader_glsl_ffp_fragment_op(), shader_glsl_get_rel_op(), shader_glsl_intrinsic(), shader_glsl_relop(), shader_glsl_uav_counter(), shader_glsl_unary_op(), SHCopyProgressRoutine(), SHELL32_FileOperation(), SHELL_ConfirmDialogW(), SHELL_DeleteDirectoryW(), CShellDispatch::ShellExecute(), SHNotifyCopyFileW(), SHNotifyDeleteFileW(), SHNotifyMoveFileW(), SimpleMatch(), sm6_dx_map_ma_op(), sm6_dx_map_tertiary_op(), sm6_dx_map_void_op(), sm6_dx_map_wave_bit_op(), sm6_dx_map_wave_op(), sm6_map_cast_op(), sm6_parser_decode_dx_op(), sm6_parser_emit_atomicrmw(), sm6_parser_emit_dx_atomic_binop(), sm6_parser_emit_dx_binary(), sm6_parser_emit_dx_buffer_load(), sm6_parser_emit_dx_buffer_store(), sm6_parser_emit_dx_calculate_lod(), sm6_parser_emit_dx_compute_builtin(), sm6_parser_emit_dx_dot(), sm6_parser_emit_dx_get_sample_pos(), sm6_parser_emit_dx_load_input(), sm6_parser_emit_dx_ma(), sm6_parser_emit_dx_raw_buffer_load(), sm6_parser_emit_dx_raw_buffer_store(), sm6_parser_emit_dx_sample(), sm6_parser_emit_dx_sincos(), sm6_parser_emit_dx_store_output(), sm6_parser_emit_dx_stream(), sm6_parser_emit_dx_tertiary(), sm6_parser_emit_dx_texture_gather(), sm6_parser_emit_dx_texture_load(), sm6_parser_emit_dx_texture_store(), sm6_parser_emit_dx_unary(), sm6_parser_emit_dx_void(), sm6_parser_emit_dx_wave_builtin(), sm6_parser_emit_dx_wave_op(), sm6_parser_read_char6_operand(), sm6_parser_read_fixed_operand(), sm6_parser_read_literal_operand(), sm6_parser_read_vbr_operand(), sm6_parser_validate_dx_op(), sm6_value_validate_is_sampler_handle(), sm6_value_validate_is_texture_2dms_handle(), sm6_value_validate_is_texture_handle(), snarf_tokens(), spirv_compiler_emit_alu_instruction(), spirv_compiler_emit_atomic_instruction(), spirv_compiler_emit_bitfield_instruction(), spirv_compiler_emit_comparison_instruction(), spirv_compiler_emit_deriv_instruction(), spirv_compiler_emit_eval_attrib(), spirv_compiler_emit_float_comparison_instruction(), spirv_compiler_emit_int_to_bool(), spirv_compiler_emit_ld_raw_structured_srv_uav(), spirv_compiler_emit_sample(), spirv_compiler_emit_sample_c(), spirv_compiler_emit_uav_counter_instruction(), spirv_compiler_emit_wave_alu_op(), spirv_compiler_emit_wave_bool_op(), SpoolX(), SquareDouble(), stack_unwind(), StrongCheck(), t1_decoder_parse_metrics(), table_data_region_do_rw(), test_BCryptEnumAlgorithms(), test_CompareStringEx(), test_ddeml_client(), test_ShellExecute(), textranges_update_ranges(), TKeyDef::TKeyDef(), trace_method_abort(), trace_named_object_lookup_or_creation_failure(), trace_op(), trace_region_io(), translate_expression(), tree_concat(), tree_const(), tree_evaluate_recurse(), tree_host_lookup(), tree_limit(), uacpi_dispatch_opregion_io(), uacpi_get_op_spec(), ui_destblt(), ui_line(), ui_patblt(), unexpected_op(), UninstallThread(), upcall_cancel(), upcall_cleanup(), upcall_handle(), upcall_marshall(), upcall_parse(), utf8_mbstowcs(), utf8_wcstombs(), validate_operation(), vk_blend_op_from_d3d12(), vk_blend_op_from_wined3d(), vk_blitter_blit(), vk_blitter_blit_supported(), vk_compare_op_from_d3d12(), vk_compare_op_from_wined3d(), vk_logic_op_from_d3d12(), vk_stencil_op_from_d3d12(), vk_stencil_op_from_wined3d(), vkd3d_spirv_build_image_instruction(), vkd3d_spirv_build_once1(), vkd3d_spirv_build_once1v(), vkd3d_spirv_build_once2(), vkd3d_spirv_build_once7(), vkd3d_spirv_build_op(), vkd3d_spirv_build_op1(), vkd3d_spirv_build_op1v(), vkd3d_spirv_build_op2(), vkd3d_spirv_build_op2v(), vkd3d_spirv_build_op3(), vkd3d_spirv_build_op3v(), vkd3d_spirv_build_op_glsl_std450_tr1(), vkd3d_spirv_build_op_image_sample(), vkd3d_spirv_build_op_image_sample_dref(), vkd3d_spirv_build_op_r(), vkd3d_spirv_build_op_r1(), vkd3d_spirv_build_op_r1v(), vkd3d_spirv_build_op_r2(), vkd3d_spirv_build_op_rv(), vkd3d_spirv_build_op_tr(), vkd3d_spirv_build_op_tr1(), vkd3d_spirv_build_op_tr1v(), vkd3d_spirv_build_op_tr2(), vkd3d_spirv_build_op_tr2v(), vkd3d_spirv_build_op_tr3(), vkd3d_spirv_build_op_trv(), vkd3d_spirv_opcode_word(), WeakCheck(), WeakMap_gc_traverse(), wined3d_blend_op_from_d3d11(), wined3d_cs_emit_add_dirty_texture_region(), wined3d_cs_emit_callback(), wined3d_cs_emit_clear(), wined3d_cs_emit_preload_resource(), wined3d_cs_emit_present(), wined3d_cs_emit_set_color_key(), wined3d_cs_emit_stop(), wined3d_cs_emit_unload_resource(), wined3d_cs_exec_add_dirty_texture_region(), wined3d_cs_exec_blt_sub_resource(), wined3d_cs_exec_callback(), wined3d_cs_exec_clear(), wined3d_cs_exec_clear_sysmem_texture(), wined3d_cs_exec_clear_unordered_access_view(), wined3d_cs_exec_copy_uav_counter(), wined3d_cs_exec_dispatch(), wined3d_cs_exec_draw(), wined3d_cs_exec_execute_command_list(), wined3d_cs_exec_generate_mipmaps(), wined3d_cs_exec_map(), wined3d_cs_exec_map_bo_address(), wined3d_cs_exec_preload_resource(), wined3d_cs_exec_present(), wined3d_cs_exec_push_constants(), wined3d_cs_exec_query_issue(), wined3d_cs_exec_reset_state(), wined3d_cs_exec_set_blend_state(), wined3d_cs_exec_set_clip_plane(), wined3d_cs_exec_set_color_key(), wined3d_cs_exec_set_constant_buffers(), wined3d_cs_exec_set_depth_bounds(), wined3d_cs_exec_set_depth_stencil_state(), wined3d_cs_exec_set_depth_stencil_view(), wined3d_cs_exec_set_feature_level(), wined3d_cs_exec_set_index_buffer(), wined3d_cs_exec_set_light(), wined3d_cs_exec_set_light_enable(), wined3d_cs_exec_set_predication(), wined3d_cs_exec_set_rasterizer_state(), wined3d_cs_exec_set_render_state(), wined3d_cs_exec_set_rendertarget_views(), wined3d_cs_exec_set_samplers(), wined3d_cs_exec_set_scissor_rects(), wined3d_cs_exec_set_shader(), wined3d_cs_exec_set_shader_resource_views(), wined3d_cs_exec_set_stream_outputs(), wined3d_cs_exec_set_stream_sources(), wined3d_cs_exec_set_texture(), wined3d_cs_exec_set_texture_state(), wined3d_cs_exec_set_transform(), wined3d_cs_exec_set_unordered_access_views(), wined3d_cs_exec_set_vertex_declaration(), wined3d_cs_exec_set_viewports(), wined3d_cs_exec_unload_resource(), wined3d_cs_exec_unmap(), wined3d_cs_exec_update_sub_resource(), wined3d_cs_flush(), wined3d_cs_issue_query(), wined3d_cs_map_bo_address(), wined3d_cs_packet_decref_objects(), wined3d_cs_packet_incref_objects(), wined3d_deferred_context_issue_query(), wined3d_device_context_clear_sysmem_texture(), wined3d_device_context_dispatch(), wined3d_device_context_dispatch_indirect(), wined3d_device_context_draw_indirect(), wined3d_device_context_emit_blt_sub_resource(), wined3d_device_context_emit_clear_rendertarget_view(), wined3d_device_context_emit_clear_uav(), wined3d_device_context_emit_copy_uav_counter(), wined3d_device_context_emit_draw(), wined3d_device_context_emit_execute_command_list(), wined3d_device_context_emit_generate_mipmaps(), wined3d_device_context_emit_map(), wined3d_device_context_emit_push_constants(), wined3d_device_context_emit_reset_state(), wined3d_device_context_emit_set_blend_state(), wined3d_device_context_emit_set_clip_plane(), wined3d_device_context_emit_set_constant_buffers(), wined3d_device_context_emit_set_depth_stencil_state(), wined3d_device_context_emit_set_depth_stencil_view(), wined3d_device_context_emit_set_feature_level(), wined3d_device_context_emit_set_index_buffer(), wined3d_device_context_emit_set_light(), wined3d_device_context_emit_set_light_enable(), wined3d_device_context_emit_set_predication(), wined3d_device_context_emit_set_rasterizer_state(), wined3d_device_context_emit_set_render_state(), wined3d_device_context_emit_set_rendertarget_views(), wined3d_device_context_emit_set_samplers(), wined3d_device_context_emit_set_scissor_rects(), wined3d_device_context_emit_set_shader(), wined3d_device_context_emit_set_shader_resource_views(), wined3d_device_context_emit_set_stream_outputs(), wined3d_device_context_emit_set_stream_sources(), wined3d_device_context_emit_set_texture(), wined3d_device_context_emit_set_texture_state(), wined3d_device_context_emit_set_transform(), wined3d_device_context_emit_set_unordered_access_views(), wined3d_device_context_emit_set_vertex_declaration(), wined3d_device_context_emit_set_viewports(), wined3d_device_context_emit_unmap(), wined3d_device_context_emit_update_sub_resource(), wined3d_device_context_set_depth_bounds(), wined3d_device_context_upload_bo(), wmain(), xdrmem_create(), xdrstdio_create(), xmlParseElementChildrenContentDeclPriv(), xrealloc(), xsltCompMatchAdd(), xsltFreeCompMatch(), xsltReverseCompMatch(), xsltSwapTopCompMatch(), ZSTD_buildCTable(), ZSTD_buildSuperBlockEntropy_sequences(), ZSTD_compress_frameChunk(), ZSTD_compressBlock_internal(), ZSTD_compressSequences_internal(), ZSTD_compressStream_generic(), ZSTD_compressSubBlock(), ZSTD_compressSubBlock_literal(), ZSTD_compressSubBlock_multi(), ZSTD_compressSubBlock_sequences(), ZSTD_decompressContinueStream(), ZSTD_decompressFrame(), ZSTD_decompressStream(), ZSTD_safecopyLiterals(), ZSTD_wildcopy(), ZSTD_writeEpilogue(), and ZSTD_writeFrameHeader().

◆ parameter_block_magic_string

const char parameter_block_magic_string[4] = {'@', '!', '#', '\xFE'}
static

Definition at line 34 of file effect.c.

Referenced by d3dx_effect_BeginParameterBlock(), and get_valid_parameter_block().

◆ parameter_magic_string

const char parameter_magic_string[4] = {'@', '!', '#', '\xFF'}
static

Definition at line 33 of file effect.c.

Referenced by get_valid_parameter(), and param_set_magic_number().

◆ 

const struct { ... } state_table[]

Referenced by compile_state_table(), context_apply_draw_state(), context_apply_state(), d3dx9_apply_state(), d3dx_effect_GetPassDesc(), d3dx_effect_ValidateTechnique(), d3dx_parse_resource(), d3dx_parse_state(), prune_invalid_states(), resolve_fx_4_state_block_values(), TREEVIEW_ToggleItemState(), validate_state_table(), wined3d_context_gl_apply_compute_state(), and wined3d_cs_exec_reset_state().