d3dx9shader.h File Reference

#include "d3dx9.h"

Include dependency graph for d3dx9shader.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
struct	_D3DXCONSTANTTABLE_DESC
struct	_D3DXCONSTANT_DESC
struct	_D3DXMACRO
struct	_D3DXSEMANTIC
struct	_D3DXFRAGMENT_DESC
struct	_D3DXSHADER_CONSTANTTABLE
struct	_D3DXSHADER_CONSTANTINFO
struct	_D3DXSHADER_TYPEINFO
struct	_D3DXSHADER_STRUCTMEMBERINFO

Macros
#define	D3DXSHADER_DEBUG   0x1
#define	D3DXSHADER_SKIPVALIDATION   0x2
#define	D3DXSHADER_SKIPOPTIMIZATION   0x4
#define	D3DXSHADER_PACKMATRIX_ROWMAJOR   0x8
#define	D3DXSHADER_PACKMATRIX_COLUMNMAJOR   0x10
#define	D3DXSHADER_PARTIALPRECISION   0x20
#define	D3DXSHADER_FORCE_VS_SOFTWARE_NOOPT   0x40
#define	D3DXSHADER_FORCE_PS_SOFTWARE_NOOPT   0x80
#define	D3DXSHADER_NO_PRESHADER   0x100
#define	D3DXSHADER_AVOID_FLOW_CONTROL   0x200
#define	D3DXSHADER_PREFER_FLOW_CONTROL   0x400
#define	D3DXSHADER_ENABLE_BACKWARDS_COMPATIBILITY   0x1000
#define	D3DXSHADER_IEEE_STRICTNESS   0x2000
#define	D3DXSHADER_OPTIMIZATION_LEVEL0   0x4000
#define	D3DXSHADER_OPTIMIZATION_LEVEL1   0x0
#define	D3DXSHADER_OPTIMIZATION_LEVEL2   0xC000
#define	D3DXSHADER_OPTIMIZATION_LEVEL3   0x8000
#define	D3DXSHADER_USE_LEGACY_D3DX9_31_DLL   0x10000
#define	D3DXCONSTTABLE_LARGEADDRESSAWARE   0x20000
#define	INTERFACE   ID3DXConstantTable
#define	ID3DXConstantTable_QueryInterface(p, a, b)   (p)->lpVtbl->QueryInterface(p,a,b)
#define	ID3DXConstantTable_AddRef(p)   (p)->lpVtbl->AddRef(p)
#define	ID3DXConstantTable_Release(p)   (p)->lpVtbl->Release(p)
#define	ID3DXConstantTable_GetBufferPointer(p)   (p)->lpVtbl->GetBufferPointer(p)
#define	ID3DXConstantTable_GetBufferSize(p)   (p)->lpVtbl->GetBufferSize(p)
#define	ID3DXConstantTable_GetDesc(p, a)   (p)->lpVtbl->GetDesc(p,a)
#define	ID3DXConstantTable_GetConstantDesc(p, a, b, c)   (p)->lpVtbl->GetConstantDesc(p,a,b,c)
#define	ID3DXConstantTable_GetSamplerIndex(p, a)   (p)->lpVtbl->GetSamplerIndex(p,a)
#define	ID3DXConstantTable_GetConstant(p, a, b)   (p)->lpVtbl->GetConstant(p,a,b)
#define	ID3DXConstantTable_GetConstantByName(p, a, b)   (p)->lpVtbl->GetConstantByName(p,a,b)
#define	ID3DXConstantTable_GetConstantElement(p, a, b)   (p)->lpVtbl->GetConstantElement(p,a,b)
#define	ID3DXConstantTable_SetDefaults(p, a)   (p)->lpVtbl->SetDefaults(p,a)
#define	ID3DXConstantTable_SetValue(p, a, b, c, d)   (p)->lpVtbl->SetValue(p,a,b,c,d)
#define	ID3DXConstantTable_SetBool(p, a, b, c)   (p)->lpVtbl->SetBool(p,a,b,c)
#define	ID3DXConstantTable_SetBoolArray(p, a, b, c, d)   (p)->lpVtbl->SetBoolArray(p,a,b,c,d)
#define	ID3DXConstantTable_SetInt(p, a, b, c)   (p)->lpVtbl->SetInt(p,a,b,c)
#define	ID3DXConstantTable_SetIntArray(p, a, b, c, d)   (p)->lpVtbl->SetIntArray(p,a,b,c,d)
#define	ID3DXConstantTable_SetFloat(p, a, b, c)   (p)->lpVtbl->SetFloat(p,a,b,c)
#define	ID3DXConstantTable_SetFloatArray(p, a, b, c, d)   (p)->lpVtbl->SetFloatArray(p,a,b,c,d)
#define	ID3DXConstantTable_SetVector(p, a, b, c)   (p)->lpVtbl->SetVector(p,a,b,c)
#define	ID3DXConstantTable_SetVectorArray(p, a, b, c, d)   (p)->lpVtbl->SetVectorArray(p,a,b,c,d)
#define	ID3DXConstantTable_SetMatrix(p, a, b, c)   (p)->lpVtbl->SetMatrix(p,a,b,c)
#define	ID3DXConstantTable_SetMatrixArray(p, a, b, c, d)   (p)->lpVtbl->SetMatrixArray(p,a,b,c,d)
#define	ID3DXConstantTable_SetMatrixPointerArray(p, a, b, c, d)   (p)->lpVtbl->SetMatrixPointerArray(p,a,b,c,d)
#define	ID3DXConstantTable_SetMatrixTranspose(p, a, b, c)   (p)->lpVtbl->SetMatrixTranspose(p,a,b,c)
#define	ID3DXConstantTable_SetMatrixTransposeArray(p, a, b, c, d)   (p)->lpVtbl->SetMatrixTransposeArray(p,a,b,c,d)
#define	ID3DXConstantTable_SetMatrixTransposePointerArray(p, a, b, c, d)   (p)->lpVtbl->SetMatrixTransposePointerArray(p,a,b,c,d)
#define	INTERFACE   ID3DXTextureShader
#define	INTERFACE   ID3DXInclude
#define	ID3DXInclude_Open(p, a, b, c, d, e)   (p)->lpVtbl->Open(p,a,b,c,d,e)
#define	ID3DXInclude_Close(p, a)   (p)->lpVtbl->Close(p,a)
#define	INTERFACE   ID3DXFragmentLinker
#define	D3DXAssembleShaderFromFile   WINELIB_NAME_AW(D3DXAssembleShaderFromFile)
#define	D3DXAssembleShaderFromResource   WINELIB_NAME_AW(D3DXAssembleShaderFromResource)
#define	D3DXCompileShaderFromFile   WINELIB_NAME_AW(D3DXCompileShaderFromFile)
#define	D3DXCompileShaderFromResource   WINELIB_NAME_AW(D3DXCompileShaderFromResource)
#define	D3DXPreprocessShaderFromFile   WINELIB_NAME_AW(D3DXPreprocessShaderFromFile)
#define	D3DXPreprocessShaderFromResource   WINELIB_NAME_AW(D3DXPreprocessShaderFromResource)

Typedefs
typedef const char *	D3DXHANDLE
typedef D3DXHANDLE *	LPD3DXHANDLE
typedef enum _D3DXREGISTER_SET	D3DXREGISTER_SET
typedef enum _D3DXREGISTER_SET *	LPD3DXREGISTER_SET
typedef enum D3DXPARAMETER_CLASS	D3DXPARAMETER_CLASS
typedef enum D3DXPARAMETER_CLASS *	LPD3DXPARAMETER_CLASS
typedef enum D3DXPARAMETER_TYPE	D3DXPARAMETER_TYPE
typedef enum D3DXPARAMETER_TYPE *	LPD3DXPARAMETER_TYPE
typedef struct _D3DXCONSTANTTABLE_DESC	D3DXCONSTANTTABLE_DESC
typedef struct _D3DXCONSTANTTABLE_DESC *	LPD3DXCONSTANTTABLE_DESC
typedef struct _D3DXCONSTANT_DESC	D3DXCONSTANT_DESC
typedef struct _D3DXCONSTANT_DESC *	LPD3DXCONSTANT_DESC
typedef struct ID3DXConstantTable *	LPD3DXCONSTANTTABLE
typedef interface ID3DXTextureShader *	LPD3DXTEXTURESHADER
typedef struct _D3DXMACRO	D3DXMACRO
typedef struct _D3DXMACRO *	LPD3DXMACRO
typedef struct _D3DXSEMANTIC	D3DXSEMANTIC
typedef struct _D3DXSEMANTIC *	LPD3DXSEMANTIC
typedef enum _D3DXINCLUDE_TYPE	D3DXINCLUDE_TYPE
typedef enum _D3DXINCLUDE_TYPE *	LPD3DXINCLUDE_TYPE
typedef struct ID3DXInclude *	LPD3DXINCLUDE
typedef struct _D3DXFRAGMENT_DESC	D3DXFRAGMENT_DESC
typedef struct _D3DXFRAGMENT_DESC *	LPD3DXFRAGMENT_DESC
typedef struct _D3DXSHADER_CONSTANTTABLE	D3DXSHADER_CONSTANTTABLE
typedef struct _D3DXSHADER_CONSTANTTABLE *	LPD3DXSHADER_CONSTANTTABLE
typedef struct _D3DXSHADER_CONSTANTINFO	D3DXSHADER_CONSTANTINFO
typedef struct _D3DXSHADER_CONSTANTINFO *	LPD3DXSHADER_CONSTANTINFO
typedef struct _D3DXSHADER_TYPEINFO	D3DXSHADER_TYPEINFO
typedef struct _D3DXSHADER_TYPEINFO *	LPD3DXSHADER_TYPEINFO
typedef struct _D3DXSHADER_STRUCTMEMBERINFO	D3DXSHADER_STRUCTMEMBERINFO
typedef struct _D3DXSHADER_STRUCTMEMBERINFO *	LPD3DXSHADER_STRUCTMEMBERINFO

Enumerations
enum	_D3DXREGISTER_SET {   D3DXRS_BOOL , D3DXRS_INT4 , D3DXRS_FLOAT4 , D3DXRS_SAMPLER ,   D3DXRS_FORCE_DWORD = 0x7fffffff }
enum	D3DXPARAMETER_CLASS {   D3DXPC_SCALAR , D3DXPC_VECTOR , D3DXPC_MATRIX_ROWS , D3DXPC_MATRIX_COLUMNS ,   D3DXPC_OBJECT , D3DXPC_STRUCT , D3DXPC_FORCE_DWORD = 0x7fffffff }
enum	D3DXPARAMETER_TYPE {   D3DXPT_VOID , D3DXPT_BOOL , D3DXPT_INT , D3DXPT_FLOAT ,   D3DXPT_STRING , D3DXPT_TEXTURE , D3DXPT_TEXTURE1D , D3DXPT_TEXTURE2D ,   D3DXPT_TEXTURE3D , D3DXPT_TEXTURECUBE , D3DXPT_SAMPLER , D3DXPT_SAMPLER1D ,   D3DXPT_SAMPLER2D , D3DXPT_SAMPLER3D , D3DXPT_SAMPLERCUBE , D3DXPT_PIXELSHADER ,   D3DXPT_VERTEXSHADER , D3DXPT_PIXELFRAGMENT , D3DXPT_VERTEXFRAGMENT , D3DXPT_UNSUPPORTED ,   D3DXPT_FORCE_DWORD = 0x7fffffff }
enum	_D3DXINCLUDE_TYPE { D3DXINC_LOCAL , D3DXINC_SYSTEM , D3DXINC_FORCE_DWORD = 0x7fffffff }

Functions
	DEFINE_GUID (IID_ID3DXConstantTable, 0x9dca3190, 0x38b9, 0x4fc3, 0x92, 0xe3, 0x39, 0xc6, 0xdd, 0xfb, 0x35, 0x8b)
	DECLARE_INTERFACE_ (ID3DXConstantTable, ID3DXBuffer)
	DEFINE_GUID (IID_ID3DXTextureShader, 0x3e3d67f8, 0xaa7a, 0x405d, 0xa8, 0x57, 0xba, 0x1, 0xd4, 0x75, 0x84, 0x26)
	DECLARE_INTERFACE_ (ID3DXTextureShader, IUnknown)
	DECLARE_INTERFACE (ID3DXInclude)
	DEFINE_GUID (IID_ID3DXFragmentLinker, 0x1a2c0cc2, 0xe5b6, 0x4ebc, 0x9e, 0x8d, 0x39, 0xe, 0x5, 0x78, 0x11, 0xb6)
	DECLARE_INTERFACE_ (ID3DXFragmentLinker, IUnknown)
const char *WINAPI	D3DXGetPixelShaderProfile (struct IDirect3DDevice9 *device)
UINT WINAPI	D3DXGetShaderSize (const DWORD *byte_code)
DWORD WINAPI	D3DXGetShaderVersion (const DWORD *byte_code)
const char *WINAPI	D3DXGetVertexShaderProfile (struct IDirect3DDevice9 *device)
HRESULT WINAPI	D3DXFindShaderComment (const DWORD *byte_code, DWORD fourcc, const void **data, UINT *size)
HRESULT WINAPI	D3DXGetShaderSamplers (const DWORD *byte_code, const char **samplers, UINT *count)
HRESULT WINAPI	D3DXGetShaderInputSemantics (const DWORD *byte_code, D3DXSEMANTIC *semantics, UINT *count)
HRESULT WINAPI	D3DXGetShaderOuputSemantics (const DWORD *byte_code, D3DXSEMANTIC *semantics, UINT *count)
HRESULT WINAPI	D3DXAssembleShaderFromFileA (const char *filename, const D3DXMACRO *defines, ID3DXInclude *include, DWORD flags, ID3DXBuffer **shader, ID3DXBuffer **error_messages)
HRESULT WINAPI	D3DXAssembleShaderFromFileW (const WCHAR *filename, const D3DXMACRO *defines, ID3DXInclude *include, DWORD flags, ID3DXBuffer **shader, ID3DXBuffer **error_messages)
HRESULT WINAPI	D3DXAssembleShaderFromResourceA (HMODULE module, const char *resource, const D3DXMACRO *defines, ID3DXInclude *include, DWORD flags, ID3DXBuffer **shader, ID3DXBuffer **error_messages)
HRESULT WINAPI	D3DXAssembleShaderFromResourceW (HMODULE module, const WCHAR *resource, const D3DXMACRO *defines, ID3DXInclude *include, DWORD flags, ID3DXBuffer **shader, ID3DXBuffer **error_messages)
HRESULT WINAPI	D3DXAssembleShader (const char *data, UINT data_len, const D3DXMACRO *defines, ID3DXInclude *include, DWORD flags, ID3DXBuffer **shader, ID3DXBuffer **error_messages)
HRESULT WINAPI	D3DXCompileShader (const char *src_data, UINT data_len, const D3DXMACRO *defines, ID3DXInclude *include, const char *function_name, const char *profile, DWORD flags, ID3DXBuffer **shader, ID3DXBuffer **error_messages, ID3DXConstantTable **constant_table)
HRESULT WINAPI	D3DXDisassembleShader (const DWORD *pShader, BOOL EnableColorCode, const char *pComments, struct ID3DXBuffer **ppDisassembly)
HRESULT WINAPI	D3DXCompileShaderFromFileA (const char *filename, const D3DXMACRO *defines, ID3DXInclude *include, const char *entrypoint, const char *profile, DWORD flags, ID3DXBuffer **shader, ID3DXBuffer **error_messages, ID3DXConstantTable **constant_table)
HRESULT WINAPI	D3DXCompileShaderFromFileW (const WCHAR *filename, const D3DXMACRO *defines, ID3DXInclude *include, const char *entrypoint, const char *profile, DWORD flags, ID3DXBuffer **shader, ID3DXBuffer **error_messages, ID3DXConstantTable **constant_table)
HRESULT WINAPI	D3DXCompileShaderFromResourceA (HMODULE module, const char *resource, const D3DXMACRO *defines, ID3DXInclude *include, const char *entrypoint, const char *profile, DWORD flags, ID3DXBuffer **shader, ID3DXBuffer **error_messages, ID3DXConstantTable **constant_table)
HRESULT WINAPI	D3DXCompileShaderFromResourceW (HMODULE module, const WCHAR *resource, const D3DXMACRO *defines, ID3DXInclude *include, const char *entrypoint, const char *profile, DWORD flags, ID3DXBuffer **shader, ID3DXBuffer **error_messages, ID3DXConstantTable **constant_table)
HRESULT WINAPI	D3DXPreprocessShader (const char *data, UINT data_len, const D3DXMACRO *defines, ID3DXInclude *include, ID3DXBuffer **shader, ID3DXBuffer **error_messages)
HRESULT WINAPI	D3DXPreprocessShaderFromFileA (const char *filename, const D3DXMACRO *defines, ID3DXInclude *include, ID3DXBuffer **shader, ID3DXBuffer **error_messages)
HRESULT WINAPI	D3DXPreprocessShaderFromFileW (const WCHAR *filename, const D3DXMACRO *defines, ID3DXInclude *include, ID3DXBuffer **shader, ID3DXBuffer **error_messages)
HRESULT WINAPI	D3DXPreprocessShaderFromResourceA (HMODULE module, const char *resource, const D3DXMACRO *defines, ID3DXInclude *include, ID3DXBuffer **shader, ID3DXBuffer **error_messages)
HRESULT WINAPI	D3DXPreprocessShaderFromResourceW (HMODULE module, const WCHAR *resource, const D3DXMACRO *defines, ID3DXInclude *include, ID3DXBuffer **shader, ID3DXBuffer **error_messages)
HRESULT WINAPI	D3DXGetShaderConstantTableEx (const DWORD *byte_code, DWORD flags, ID3DXConstantTable **constant_table)
HRESULT WINAPI	D3DXGetShaderConstantTable (const DWORD *byte_code, ID3DXConstantTable **constant_table)
HRESULT WINAPI	D3DXGetShaderOutputSemantics (const DWORD *pFunction, D3DXSEMANTIC *pSemantics, UINT *pCount)
HRESULT WINAPI	D3DXCreateTextureShader (const DWORD *pFunction, ID3DXTextureShader **ppTextureShader)
HRESULT WINAPI	D3DXCreateFragmentLinker (IDirect3DDevice9 *device, UINT size, ID3DXFragmentLinker **linker)
HRESULT WINAPI	D3DXCreateFragmentLinkerEx (IDirect3DDevice9 *device, UINT size, DWORD flags, ID3DXFragmentLinker **linker)

Macro Definition Documentation

D3DXAssembleShaderFromFile

#define D3DXAssembleShaderFromFile   WINELIB_NAME_AW(D3DXAssembleShaderFromFile)

Definition at line 362 of file d3dx9shader.h.

D3DXAssembleShaderFromResource

#define D3DXAssembleShaderFromResource   WINELIB_NAME_AW(D3DXAssembleShaderFromResource)

Definition at line 368 of file d3dx9shader.h.

D3DXCompileShaderFromFile

#define D3DXCompileShaderFromFile   WINELIB_NAME_AW(D3DXCompileShaderFromFile)

Definition at line 385 of file d3dx9shader.h.

D3DXCompileShaderFromResource

#define D3DXCompileShaderFromResource   WINELIB_NAME_AW(D3DXCompileShaderFromResource)

Definition at line 393 of file d3dx9shader.h.

D3DXCONSTTABLE_LARGEADDRESSAWARE

#define D3DXCONSTTABLE_LARGEADDRESSAWARE   0x20000

Definition at line 46 of file d3dx9shader.h.

D3DXPreprocessShaderFromFile

#define D3DXPreprocessShaderFromFile   WINELIB_NAME_AW(D3DXPreprocessShaderFromFile)

Definition at line 402 of file d3dx9shader.h.

D3DXPreprocessShaderFromResource

#define D3DXPreprocessShaderFromResource   WINELIB_NAME_AW(D3DXPreprocessShaderFromResource)

Definition at line 408 of file d3dx9shader.h.

D3DXSHADER_AVOID_FLOW_CONTROL

#define D3DXSHADER_AVOID_FLOW_CONTROL   0x200

Definition at line 34 of file d3dx9shader.h.

D3DXSHADER_DEBUG

#define D3DXSHADER_DEBUG   0x1

Definition at line 25 of file d3dx9shader.h.

D3DXSHADER_ENABLE_BACKWARDS_COMPATIBILITY

#define D3DXSHADER_ENABLE_BACKWARDS_COMPATIBILITY   0x1000

Definition at line 36 of file d3dx9shader.h.

D3DXSHADER_FORCE_PS_SOFTWARE_NOOPT

#define D3DXSHADER_FORCE_PS_SOFTWARE_NOOPT   0x80

Definition at line 32 of file d3dx9shader.h.

D3DXSHADER_FORCE_VS_SOFTWARE_NOOPT

#define D3DXSHADER_FORCE_VS_SOFTWARE_NOOPT   0x40

Definition at line 31 of file d3dx9shader.h.

D3DXSHADER_IEEE_STRICTNESS

#define D3DXSHADER_IEEE_STRICTNESS   0x2000

Definition at line 37 of file d3dx9shader.h.

D3DXSHADER_NO_PRESHADER

#define D3DXSHADER_NO_PRESHADER   0x100

Definition at line 33 of file d3dx9shader.h.

D3DXSHADER_OPTIMIZATION_LEVEL0

#define D3DXSHADER_OPTIMIZATION_LEVEL0   0x4000

Definition at line 39 of file d3dx9shader.h.

D3DXSHADER_OPTIMIZATION_LEVEL1

#define D3DXSHADER_OPTIMIZATION_LEVEL1   0x0

Definition at line 40 of file d3dx9shader.h.

D3DXSHADER_OPTIMIZATION_LEVEL2

#define D3DXSHADER_OPTIMIZATION_LEVEL2   0xC000

Definition at line 41 of file d3dx9shader.h.

D3DXSHADER_OPTIMIZATION_LEVEL3

#define D3DXSHADER_OPTIMIZATION_LEVEL3   0x8000

Definition at line 42 of file d3dx9shader.h.

D3DXSHADER_PACKMATRIX_COLUMNMAJOR

#define D3DXSHADER_PACKMATRIX_COLUMNMAJOR   0x10

Definition at line 29 of file d3dx9shader.h.

D3DXSHADER_PACKMATRIX_ROWMAJOR

#define D3DXSHADER_PACKMATRIX_ROWMAJOR   0x8

Definition at line 28 of file d3dx9shader.h.

D3DXSHADER_PARTIALPRECISION

#define D3DXSHADER_PARTIALPRECISION   0x20

Definition at line 30 of file d3dx9shader.h.

D3DXSHADER_PREFER_FLOW_CONTROL

#define D3DXSHADER_PREFER_FLOW_CONTROL   0x400

Definition at line 35 of file d3dx9shader.h.

D3DXSHADER_SKIPOPTIMIZATION

#define D3DXSHADER_SKIPOPTIMIZATION   0x4

Definition at line 27 of file d3dx9shader.h.

D3DXSHADER_SKIPVALIDATION

#define D3DXSHADER_SKIPVALIDATION   0x2

Definition at line 26 of file d3dx9shader.h.

D3DXSHADER_USE_LEGACY_D3DX9_31_DLL

#define D3DXSHADER_USE_LEGACY_D3DX9_31_DLL   0x10000

Definition at line 44 of file d3dx9shader.h.

ID3DXConstantTable_AddRef

#define ID3DXConstantTable_AddRef

(

p

)

(p)->lpVtbl->AddRef(p)

Definition at line 176 of file d3dx9shader.h.

ID3DXConstantTable_GetBufferPointer

#define ID3DXConstantTable_GetBufferPointer

(

p

)

(p)->lpVtbl->GetBufferPointer(p)

Definition at line 179 of file d3dx9shader.h.

ID3DXConstantTable_GetBufferSize

#define ID3DXConstantTable_GetBufferSize

(

p

)

(p)->lpVtbl->GetBufferSize(p)

Definition at line 180 of file d3dx9shader.h.

ID3DXConstantTable_GetConstant

#define ID3DXConstantTable_GetConstant	(		p,
			a,
			b
	)		(p)->lpVtbl->GetConstant(p,a,b)

Definition at line 185 of file d3dx9shader.h.

ID3DXConstantTable_GetConstantByName

#define ID3DXConstantTable_GetConstantByName	(		p,
			a,
			b
	)		(p)->lpVtbl->GetConstantByName(p,a,b)

Definition at line 186 of file d3dx9shader.h.

ID3DXConstantTable_GetConstantDesc

#define ID3DXConstantTable_GetConstantDesc	(		p,
			a,
			b,
			c
	)		(p)->lpVtbl->GetConstantDesc(p,a,b,c)

Definition at line 183 of file d3dx9shader.h.

ID3DXConstantTable_GetConstantElement

#define ID3DXConstantTable_GetConstantElement	(		p,
			a,
			b
	)		(p)->lpVtbl->GetConstantElement(p,a,b)

Definition at line 187 of file d3dx9shader.h.

ID3DXConstantTable_GetDesc

#define ID3DXConstantTable_GetDesc	(		p,
			a
	)		(p)->lpVtbl->GetDesc(p,a)

Definition at line 182 of file d3dx9shader.h.

ID3DXConstantTable_GetSamplerIndex

#define ID3DXConstantTable_GetSamplerIndex	(		p,
			a
	)		(p)->lpVtbl->GetSamplerIndex(p,a)

Definition at line 184 of file d3dx9shader.h.

ID3DXConstantTable_QueryInterface

#define ID3DXConstantTable_QueryInterface	(		p,
			a,
			b
	)		(p)->lpVtbl->QueryInterface(p,a,b)

Definition at line 175 of file d3dx9shader.h.

ID3DXConstantTable_Release

#define ID3DXConstantTable_Release

(

p

)

(p)->lpVtbl->Release(p)

Definition at line 177 of file d3dx9shader.h.

ID3DXConstantTable_SetBool

#define ID3DXConstantTable_SetBool	(		p,
			a,
			b,
			c
	)		(p)->lpVtbl->SetBool(p,a,b,c)

Definition at line 190 of file d3dx9shader.h.

ID3DXConstantTable_SetBoolArray

#define ID3DXConstantTable_SetBoolArray	(		p,
			a,
			b,
			c,
			d
	)		(p)->lpVtbl->SetBoolArray(p,a,b,c,d)

Definition at line 191 of file d3dx9shader.h.

ID3DXConstantTable_SetDefaults

#define ID3DXConstantTable_SetDefaults	(		p,
			a
	)		(p)->lpVtbl->SetDefaults(p,a)

Definition at line 188 of file d3dx9shader.h.

ID3DXConstantTable_SetFloat

#define ID3DXConstantTable_SetFloat	(		p,
			a,
			b,
			c
	)		(p)->lpVtbl->SetFloat(p,a,b,c)

Definition at line 194 of file d3dx9shader.h.

ID3DXConstantTable_SetFloatArray

#define ID3DXConstantTable_SetFloatArray	(		p,
			a,
			b,
			c,
			d
	)		(p)->lpVtbl->SetFloatArray(p,a,b,c,d)

Definition at line 195 of file d3dx9shader.h.

ID3DXConstantTable_SetInt

#define ID3DXConstantTable_SetInt	(		p,
			a,
			b,
			c
	)		(p)->lpVtbl->SetInt(p,a,b,c)

Definition at line 192 of file d3dx9shader.h.

ID3DXConstantTable_SetIntArray

#define ID3DXConstantTable_SetIntArray	(		p,
			a,
			b,
			c,
			d
	)		(p)->lpVtbl->SetIntArray(p,a,b,c,d)

Definition at line 193 of file d3dx9shader.h.

ID3DXConstantTable_SetMatrix

#define ID3DXConstantTable_SetMatrix	(		p,
			a,
			b,
			c
	)		(p)->lpVtbl->SetMatrix(p,a,b,c)

Definition at line 198 of file d3dx9shader.h.

ID3DXConstantTable_SetMatrixArray

#define ID3DXConstantTable_SetMatrixArray	(		p,
			a,
			b,
			c,
			d
	)		(p)->lpVtbl->SetMatrixArray(p,a,b,c,d)

Definition at line 199 of file d3dx9shader.h.

ID3DXConstantTable_SetMatrixPointerArray

#define ID3DXConstantTable_SetMatrixPointerArray	(		p,
			a,
			b,
			c,
			d
	)		(p)->lpVtbl->SetMatrixPointerArray(p,a,b,c,d)

Definition at line 200 of file d3dx9shader.h.

ID3DXConstantTable_SetMatrixTranspose

#define ID3DXConstantTable_SetMatrixTranspose	(		p,
			a,
			b,
			c
	)		(p)->lpVtbl->SetMatrixTranspose(p,a,b,c)

Definition at line 201 of file d3dx9shader.h.

ID3DXConstantTable_SetMatrixTransposeArray

#define ID3DXConstantTable_SetMatrixTransposeArray	(		p,
			a,
			b,
			c,
			d
	)		(p)->lpVtbl->SetMatrixTransposeArray(p,a,b,c,d)

Definition at line 202 of file d3dx9shader.h.

ID3DXConstantTable_SetMatrixTransposePointerArray

#define ID3DXConstantTable_SetMatrixTransposePointerArray	(		p,
			a,
			b,
			c,
			d
	)		(p)->lpVtbl->SetMatrixTransposePointerArray(p,a,b,c,d)

Definition at line 203 of file d3dx9shader.h.

ID3DXConstantTable_SetValue

#define ID3DXConstantTable_SetValue	(		p,
			a,
			b,
			c,
			d
	)		(p)->lpVtbl->SetValue(p,a,b,c,d)

Definition at line 189 of file d3dx9shader.h.

ID3DXConstantTable_SetVector

#define ID3DXConstantTable_SetVector	(		p,
			a,
			b,
			c
	)		(p)->lpVtbl->SetVector(p,a,b,c)

Definition at line 196 of file d3dx9shader.h.

ID3DXConstantTable_SetVectorArray

#define ID3DXConstantTable_SetVectorArray	(		p,
			a,
			b,
			c,
			d
	)		(p)->lpVtbl->SetVectorArray(p,a,b,c,d)

Definition at line 197 of file d3dx9shader.h.

ID3DXInclude_Close

#define ID3DXInclude_Close	(		p,
			a
	)		(p)->lpVtbl->Close(p,a)

Definition at line 304 of file d3dx9shader.h.

ID3DXInclude_Open

#define ID3DXInclude_Open	(		p,
			a,
			b,
			c,
			d,
			e
	)		(p)->lpVtbl->Open(p,a,b,c,d,e)

Definition at line 303 of file d3dx9shader.h.

INTERFACE [1/4]

#define INTERFACE   ID3DXConstantTable

Definition at line 318 of file d3dx9shader.h.

INTERFACE [2/4]

#define INTERFACE   ID3DXTextureShader

Definition at line 318 of file d3dx9shader.h.

INTERFACE [3/4]

#define INTERFACE   ID3DXInclude

Definition at line 318 of file d3dx9shader.h.

INTERFACE [4/4]

#define INTERFACE   ID3DXFragmentLinker

Definition at line 318 of file d3dx9shader.h.

Typedef Documentation

D3DXCONSTANT_DESC

typedef struct _D3DXCONSTANT_DESC D3DXCONSTANT_DESC

D3DXCONSTANTTABLE_DESC

typedef struct _D3DXCONSTANTTABLE_DESC D3DXCONSTANTTABLE_DESC

D3DXFRAGMENT_DESC

typedef struct _D3DXFRAGMENT_DESC D3DXFRAGMENT_DESC

D3DXHANDLE

typedef const char* D3DXHANDLE

Definition at line 48 of file d3dx9shader.h.

D3DXINCLUDE_TYPE

typedef enum _D3DXINCLUDE_TYPE D3DXINCLUDE_TYPE

D3DXMACRO

typedef struct _D3DXMACRO D3DXMACRO

D3DXPARAMETER_CLASS

typedef enum D3DXPARAMETER_CLASS D3DXPARAMETER_CLASS

D3DXPARAMETER_TYPE

typedef enum D3DXPARAMETER_TYPE D3DXPARAMETER_TYPE

D3DXREGISTER_SET

typedef enum _D3DXREGISTER_SET D3DXREGISTER_SET

D3DXSEMANTIC

typedef struct _D3DXSEMANTIC D3DXSEMANTIC

D3DXSHADER_CONSTANTINFO

typedef struct _D3DXSHADER_CONSTANTINFO D3DXSHADER_CONSTANTINFO

D3DXSHADER_CONSTANTTABLE

typedef struct _D3DXSHADER_CONSTANTTABLE D3DXSHADER_CONSTANTTABLE

D3DXSHADER_STRUCTMEMBERINFO

typedef struct _D3DXSHADER_STRUCTMEMBERINFO D3DXSHADER_STRUCTMEMBERINFO

D3DXSHADER_TYPEINFO

typedef struct _D3DXSHADER_TYPEINFO D3DXSHADER_TYPEINFO

LPD3DXCONSTANT_DESC

typedef struct _D3DXCONSTANT_DESC * LPD3DXCONSTANT_DESC

LPD3DXCONSTANTTABLE

typedef struct ID3DXConstantTable* LPD3DXCONSTANTTABLE

Definition at line 237 of file d3dx9shader.h.

LPD3DXCONSTANTTABLE_DESC

typedef struct _D3DXCONSTANTTABLE_DESC * LPD3DXCONSTANTTABLE_DESC

LPD3DXFRAGMENT_DESC

typedef struct _D3DXFRAGMENT_DESC * LPD3DXFRAGMENT_DESC

LPD3DXHANDLE

typedef D3DXHANDLE* LPD3DXHANDLE

Definition at line 49 of file d3dx9shader.h.

LPD3DXINCLUDE

typedef struct ID3DXInclude* LPD3DXINCLUDE

Definition at line 306 of file d3dx9shader.h.

LPD3DXINCLUDE_TYPE

typedef enum _D3DXINCLUDE_TYPE * LPD3DXINCLUDE_TYPE

LPD3DXMACRO

typedef struct _D3DXMACRO * LPD3DXMACRO

LPD3DXPARAMETER_CLASS

typedef enum D3DXPARAMETER_CLASS * LPD3DXPARAMETER_CLASS

LPD3DXPARAMETER_TYPE

typedef enum D3DXPARAMETER_TYPE * LPD3DXPARAMETER_TYPE

LPD3DXREGISTER_SET

typedef enum _D3DXREGISTER_SET * LPD3DXREGISTER_SET

LPD3DXSEMANTIC

typedef struct _D3DXSEMANTIC * LPD3DXSEMANTIC

LPD3DXSHADER_CONSTANTINFO

typedef struct _D3DXSHADER_CONSTANTINFO * LPD3DXSHADER_CONSTANTINFO

LPD3DXSHADER_CONSTANTTABLE

typedef struct _D3DXSHADER_CONSTANTTABLE * LPD3DXSHADER_CONSTANTTABLE

LPD3DXSHADER_STRUCTMEMBERINFO

typedef struct _D3DXSHADER_STRUCTMEMBERINFO * LPD3DXSHADER_STRUCTMEMBERINFO

LPD3DXSHADER_TYPEINFO

typedef struct _D3DXSHADER_TYPEINFO * LPD3DXSHADER_TYPEINFO

LPD3DXTEXTURESHADER

typedef interface ID3DXTextureShader* LPD3DXTEXTURESHADER

Definition at line 239 of file d3dx9shader.h.

Enumeration Type Documentation

_D3DXINCLUDE_TYPE

enum _D3DXINCLUDE_TYPE

Enumerator
D3DXINC_LOCAL
D3DXINC_SYSTEM
D3DXINC_FORCE_DWORD

Definition at line 286 of file d3dx9shader.h.

{
    D3DXINC_LOCAL,
    D3DXINC_SYSTEM,
    D3DXINC_FORCE_DWORD = 0x7fffffff,
} D3DXINCLUDE_TYPE, *LPD3DXINCLUDE_TYPE;

_D3DXREGISTER_SET

enum _D3DXREGISTER_SET

Enumerator
D3DXRS_BOOL
D3DXRS_INT4
D3DXRS_FLOAT4
D3DXRS_SAMPLER
D3DXRS_FORCE_DWORD

Definition at line 51 of file d3dx9shader.h.

{
    D3DXRS_BOOL,
    D3DXRS_INT4,
    D3DXRS_FLOAT4,
    D3DXRS_SAMPLER,
    D3DXRS_FORCE_DWORD = 0x7fffffff
} D3DXREGISTER_SET, *LPD3DXREGISTER_SET;

D3DXPARAMETER_CLASS

enum D3DXPARAMETER_CLASS

Enumerator
D3DXPC_SCALAR
D3DXPC_VECTOR
D3DXPC_MATRIX_ROWS
D3DXPC_MATRIX_COLUMNS
D3DXPC_OBJECT
D3DXPC_STRUCT
D3DXPC_FORCE_DWORD

Definition at line 60 of file d3dx9shader.h.

{
    D3DXPC_SCALAR,
    D3DXPC_VECTOR,
    D3DXPC_MATRIX_ROWS,
    D3DXPC_MATRIX_COLUMNS,
    D3DXPC_OBJECT,
    D3DXPC_STRUCT,
    D3DXPC_FORCE_DWORD = 0x7fffffff,
} D3DXPARAMETER_CLASS, *LPD3DXPARAMETER_CLASS;

D3DXPARAMETER_TYPE

enum D3DXPARAMETER_TYPE

Enumerator
D3DXPT_VOID
D3DXPT_BOOL
D3DXPT_INT
D3DXPT_FLOAT
D3DXPT_STRING
D3DXPT_TEXTURE
D3DXPT_TEXTURE1D
D3DXPT_TEXTURE2D
D3DXPT_TEXTURE3D
D3DXPT_TEXTURECUBE
D3DXPT_SAMPLER
D3DXPT_SAMPLER1D
D3DXPT_SAMPLER2D
D3DXPT_SAMPLER3D
D3DXPT_SAMPLERCUBE
D3DXPT_PIXELSHADER
D3DXPT_VERTEXSHADER
D3DXPT_PIXELFRAGMENT
D3DXPT_VERTEXFRAGMENT
D3DXPT_UNSUPPORTED
D3DXPT_FORCE_DWORD

Definition at line 71 of file d3dx9shader.h.

{
    D3DXPT_VOID,
    D3DXPT_BOOL,
    D3DXPT_INT,
    D3DXPT_FLOAT,
    D3DXPT_STRING,
    D3DXPT_TEXTURE,
    D3DXPT_TEXTURE1D,
    D3DXPT_TEXTURE2D,
    D3DXPT_TEXTURE3D,
    D3DXPT_TEXTURECUBE,
    D3DXPT_SAMPLER,
    D3DXPT_SAMPLER1D,
    D3DXPT_SAMPLER2D,
    D3DXPT_SAMPLER3D,
    D3DXPT_SAMPLERCUBE,
    D3DXPT_PIXELSHADER,
    D3DXPT_VERTEXSHADER,
    D3DXPT_PIXELFRAGMENT,
    D3DXPT_VERTEXFRAGMENT,
    D3DXPT_UNSUPPORTED,
    D3DXPT_FORCE_DWORD = 0x7fffffff,
} D3DXPARAMETER_TYPE, *LPD3DXPARAMETER_TYPE;

Function Documentation

D3DXAssembleShader()

HRESULT WINAPI D3DXAssembleShader	(	const char *	data,
		UINT	data_len,
		const D3DXMACRO *	defines,
		ID3DXInclude *	include,
		DWORD	flags,
		ID3DXBuffer **	shader,
		ID3DXBuffer **	error_messages
	)

Definition at line 200 of file shader.c.

{
    HRESULT hr;
 
    TRACE("data %p, data_len %u, defines %p, include %p, flags %#x, shader %p, error_messages %p\n",
          data, data_len, defines, include, flags, shader, error_messages);
 
    /* Forward to d3dcompiler: the parameter types aren't really different,
       the actual data types are equivalent */
    hr = D3DAssemble(data, data_len, NULL, (D3D_SHADER_MACRO *)defines,
                     (ID3DInclude *)include, flags, (ID3DBlob **)shader,
                     (ID3DBlob **)error_messages);
 
    if(hr == E_FAIL) hr = D3DXERR_INVALIDDATA;
    return hr;
}

Referenced by assembleshader_test(), D3DXAssembleShaderFromFileW(), D3DXAssembleShaderFromResourceA(), and D3DXAssembleShaderFromResourceW().

D3DXAssembleShaderFromFileA()

HRESULT WINAPI D3DXAssembleShaderFromFileA	(	const char *	filename,
		const D3DXMACRO *	defines,
		ID3DXInclude *	include,
		DWORD	flags,
		ID3DXBuffer **	shader,
		ID3DXBuffer **	error_messages
	)

Definition at line 321 of file shader.c.

{
    WCHAR *filename_w;
    DWORD len;
    HRESULT ret;
 
    TRACE("filename %s, defines %p, include %p, flags %#x, shader %p, error_messages %p.\n",
            debugstr_a(filename), defines, include, flags, shader, error_messages);
 
    if (!filename) return D3DXERR_INVALIDDATA;
 
    len = MultiByteToWideChar(CP_ACP, 0, filename, -1, NULL, 0);
    filename_w = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
    if (!filename_w) return E_OUTOFMEMORY;
    MultiByteToWideChar(CP_ACP, 0, filename, -1, filename_w, len);
 
    ret = D3DXAssembleShaderFromFileW(filename_w, defines, include, flags, shader, error_messages);
 
    HeapFree(GetProcessHeap(), 0, filename_w);
    return ret;
}

Referenced by assembleshader_test().

D3DXAssembleShaderFromFileW()

HRESULT WINAPI D3DXAssembleShaderFromFileW	(	const WCHAR *	filename,
		const D3DXMACRO *	defines,
		ID3DXInclude *	include,
		DWORD	flags,
		ID3DXBuffer **	shader,
		ID3DXBuffer **	error_messages
	)

Definition at line 344 of file shader.c.

{
    const void *buffer;
    DWORD len;
    HRESULT hr;
    struct d3dx_include_from_file include_from_file;
    char *filename_a;
 
    TRACE("filename %s, defines %p, include %p, flags %#x, shader %p, error_messages %p.\n",
            debugstr_w(filename), defines, include, flags, shader, error_messages);
 
    if(!include)
    {
        include_from_file.ID3DXInclude_iface.lpVtbl = &d3dx_include_from_file_vtbl;
        include = &include_from_file.ID3DXInclude_iface;
    }
 
    len = WideCharToMultiByte(CP_ACP, 0, filename, -1, NULL, 0, NULL, NULL);
    filename_a = HeapAlloc(GetProcessHeap(), 0, len * sizeof(char));
    if (!filename_a)
        return E_OUTOFMEMORY;
    WideCharToMultiByte(CP_ACP, 0, filename, -1, filename_a, len, NULL, NULL);
 
    EnterCriticalSection(&from_file_mutex);
    hr = ID3DXInclude_Open(include, D3DXINC_LOCAL, filename_a, NULL, &buffer, &len);
    if (FAILED(hr))
    {
        LeaveCriticalSection(&from_file_mutex);
        HeapFree(GetProcessHeap(), 0, filename_a);
        return D3DXERR_INVALIDDATA;
    }
 
    hr = D3DXAssembleShader(buffer, len, defines, include, flags, shader, error_messages);
 
    ID3DXInclude_Close(include, buffer);
    LeaveCriticalSection(&from_file_mutex);
    HeapFree(GetProcessHeap(), 0, filename_a);
    return hr;
}

Referenced by assembleshader_test(), and D3DXAssembleShaderFromFileA().

D3DXAssembleShaderFromResourceA()

HRESULT WINAPI D3DXAssembleShaderFromResourceA	(	HMODULE	module,
		const char *	resource,
		const D3DXMACRO *	defines,
		ID3DXInclude *	include,
		DWORD	flags,
		ID3DXBuffer **	shader,
		ID3DXBuffer **	error_messages
	)

Definition at line 385 of file shader.c.

{
    void *buffer;
    HRSRC res;
    DWORD len;
 
    TRACE("module %p, resource %s, defines %p, include %p, flags %#x, shader %p, error_messages %p.\n",
            module, debugstr_a(resource), defines, include, flags, shader, error_messages);
 
    if (!(res = FindResourceA(module, resource, (const char *)RT_RCDATA)))
        return D3DXERR_INVALIDDATA;
    if (FAILED(load_resource_into_memory(module, res, &buffer, &len)))
        return D3DXERR_INVALIDDATA;
    return D3DXAssembleShader(buffer, len, defines, include, flags,
                              shader, error_messages);
}

Referenced by assembleshader_test().

D3DXAssembleShaderFromResourceW()

HRESULT WINAPI D3DXAssembleShaderFromResourceW	(	HMODULE	module,
		const WCHAR *	resource,
		const D3DXMACRO *	defines,
		ID3DXInclude *	include,
		DWORD	flags,
		ID3DXBuffer **	shader,
		ID3DXBuffer **	error_messages
	)

Definition at line 403 of file shader.c.

{
    void *buffer;
    HRSRC res;
    DWORD len;
 
    TRACE("module %p, resource %s, defines %p, include %p, flags %#x, shader %p, error_messages %p.\n",
            module, debugstr_w(resource), defines, include, flags, shader, error_messages);
 
    if (!(res = FindResourceW(module, resource, (const WCHAR *)RT_RCDATA)))
        return D3DXERR_INVALIDDATA;
    if (FAILED(load_resource_into_memory(module, res, &buffer, &len)))
        return D3DXERR_INVALIDDATA;
    return D3DXAssembleShader(buffer, len, defines, include, flags,
                              shader, error_messages);
}

D3DXCompileShader()

HRESULT WINAPI D3DXCompileShader	(	const char *	src_data,
		UINT	data_len,
		const D3DXMACRO *	defines,
		ID3DXInclude *	include,
		const char *	function_name,
		const char *	profile,
		DWORD	flags,
		ID3DXBuffer **	shader,
		ID3DXBuffer **	error_messages,
		ID3DXConstantTable **	constant_table
	)

Definition at line 421 of file shader.c.

{
    HRESULT hr;
 
    TRACE("data %s, length %u, defines %p, include %p, function %s, profile %s, "
            "flags %#x, shader %p, error_msgs %p, constant_table %p.\n",
            debugstr_a(data), length, defines, include, debugstr_a(function), debugstr_a(profile),
            flags, shader, error_msgs, constant_table);
 
    if (D3DX_SDK_VERSION <= 36)
        flags |= D3DCOMPILE_ENABLE_BACKWARDS_COMPATIBILITY;
 
    hr = D3DCompile(data, length, NULL, (D3D_SHADER_MACRO *)defines, (ID3DInclude *)include,
                    function, profile, flags, 0, (ID3DBlob **)shader, (ID3DBlob **)error_msgs);
 
    if (SUCCEEDED(hr) && constant_table)
    {
        hr = D3DXGetShaderConstantTable(ID3DXBuffer_GetBufferPointer(*shader), constant_table);
        if (FAILED(hr))
        {
            ID3DXBuffer_Release(*shader);
            *shader = NULL;
        }
    }
 
    /* Filter out D3DCompile warning messages that are not present with D3DCompileShader */
    if (SUCCEEDED(hr) && error_msgs && *error_msgs)
    {
        char *messages = ID3DXBuffer_GetBufferPointer(*error_msgs);
        DWORD size     = ID3DXBuffer_GetBufferSize(*error_msgs);
 
        /* Ensure messages are null terminated for safe processing */
        if (size) messages[size - 1] = 0;
 
        while (size > 1)
        {
            char *prev, *next;
 
            /* Warning has the form "warning X3206: ... implicit truncation of vector type"
               but we only search for "X3206:" in case d3dcompiler_43 has localization */
            prev = next = strstr(messages, "X3206:");
            if (!prev) break;
 
            /* get pointer to beginning and end of current line */
            while (prev > messages && *(prev - 1) != '\n') prev--;
            while (next < messages + size - 1 && *next != '\n') next++;
            if (next < messages + size - 1 && *next == '\n') next++;
 
            memmove(prev, next, messages + size - next);
            size -= (next - prev);
        }
 
        /* Only return a buffer if the resulting string is not empty as some apps depend on that */
        if (size <= 1)
        {
            ID3DXBuffer_Release(*error_msgs);
            *error_msgs = NULL;
        }
    }
 
    return hr;
}

Referenced by D3DXCompileShaderFromResourceA(), and D3DXCompileShaderFromResourceW().

D3DXCompileShaderFromFileA()

HRESULT WINAPI D3DXCompileShaderFromFileA	(	const char *	filename,
		const D3DXMACRO *	defines,
		ID3DXInclude *	include,
		const char *	entrypoint,
		const char *	profile,
		DWORD	flags,
		ID3DXBuffer **	shader,
		ID3DXBuffer **	error_messages,
		ID3DXConstantTable **	constant_table
	)

Definition at line 486 of file shader.c.

{
    WCHAR *filename_w;
    DWORD len;
    HRESULT ret;
 
    TRACE("filename %s, defines %p, include %p, entrypoint %s, profile %s, "
            "flags %#x, shader %p, error_messages %p, constant_table %p.\n",
            debugstr_a(filename), defines, include, debugstr_a(entrypoint),
            debugstr_a(profile), flags, shader, error_messages, constant_table);
 
    if (!filename) return D3DXERR_INVALIDDATA;
 
    len = MultiByteToWideChar(CP_ACP, 0, filename, -1, NULL, 0);
    filename_w = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
    if (!filename_w) return E_OUTOFMEMORY;
    MultiByteToWideChar(CP_ACP, 0, filename, -1, filename_w, len);
 
    ret = D3DXCompileShaderFromFileW(filename_w, defines, include,
                                     entrypoint, profile, flags,
                                     shader, error_messages, constant_table);
 
    HeapFree(GetProcessHeap(), 0, filename_w);
    return ret;
}

D3DXCompileShaderFromFileW()

HRESULT WINAPI D3DXCompileShaderFromFileW	(	const WCHAR *	filename,
		const D3DXMACRO *	defines,
		ID3DXInclude *	include,
		const char *	entrypoint,
		const char *	profile,
		DWORD	flags,
		ID3DXBuffer **	shader,
		ID3DXBuffer **	error_messages,
		ID3DXConstantTable **	constant_table
	)

Definition at line 514 of file shader.c.

{
    const void *buffer;
    DWORD len, filename_len;
    HRESULT hr;
    struct d3dx_include_from_file include_from_file;
    char *filename_a;
 
    TRACE("filename %s, defines %p, include %p, entrypoint %s, profile %s, "
            "flags %#x, shader %p, error_messages %p, constant_table %p.\n",
            debugstr_w(filename), defines, include, debugstr_a(entrypoint), debugstr_a(profile),
            flags, shader, error_messages, constant_table);
 
    if (!include)
    {
        include_from_file.ID3DXInclude_iface.lpVtbl = &d3dx_include_from_file_vtbl;
        include = &include_from_file.ID3DXInclude_iface;
    }
 
    filename_len = WideCharToMultiByte(CP_ACP, 0, filename, -1, NULL, 0, NULL, NULL);
    filename_a = HeapAlloc(GetProcessHeap(), 0, filename_len * sizeof(char));
    if (!filename_a)
        return E_OUTOFMEMORY;
    WideCharToMultiByte(CP_ACP, 0, filename, -1, filename_a, filename_len, NULL, NULL);
 
    EnterCriticalSection(&from_file_mutex);
    hr = ID3DXInclude_Open(include, D3DXINC_LOCAL, filename_a, NULL, &buffer, &len);
    if (FAILED(hr))
    {
        LeaveCriticalSection(&from_file_mutex);
        HeapFree(GetProcessHeap(), 0, filename_a);
        return D3DXERR_INVALIDDATA;
    }
 
    if (D3DX_SDK_VERSION <= 36)
        flags |= D3DCOMPILE_ENABLE_BACKWARDS_COMPATIBILITY;
 
    hr = D3DCompile(buffer, len, filename_a, (const D3D_SHADER_MACRO *)defines,
                    (ID3DInclude *)include, entrypoint, profile, flags, 0,
                    (ID3DBlob **)shader, (ID3DBlob **)error_messages);
 
    if (SUCCEEDED(hr) && constant_table)
        hr = D3DXGetShaderConstantTable(ID3DXBuffer_GetBufferPointer(*shader),
                                        constant_table);
 
    ID3DXInclude_Close(include, buffer);
    LeaveCriticalSection(&from_file_mutex);
    HeapFree(GetProcessHeap(), 0, filename_a);
    return hr;
}

Referenced by D3DXCompileShaderFromFileA().

D3DXCompileShaderFromResourceA()

HRESULT WINAPI D3DXCompileShaderFromResourceA	(	HMODULE	module,
		const char *	resource,
		const D3DXMACRO *	defines,
		ID3DXInclude *	include,
		const char *	entrypoint,
		const char *	profile,
		DWORD	flags,
		ID3DXBuffer **	shader,
		ID3DXBuffer **	error_messages,
		ID3DXConstantTable **	constant_table
	)

Definition at line 567 of file shader.c.

{
    void *buffer;
    HRSRC res;
    DWORD len;
 
    TRACE("module %p, resource %s, defines %p, include %p, entrypoint %s, profile %s, "
            "flags %#x, shader %p, error_messages %p, constant_table %p.\n",
            module, debugstr_a(resource), defines, include, debugstr_a(entrypoint), debugstr_a(profile),
            flags, shader, error_messages, constant_table);
 
    if (!(res = FindResourceA(module, resource, (const char *)RT_RCDATA)))
        return D3DXERR_INVALIDDATA;
    if (FAILED(load_resource_into_memory(module, res, &buffer, &len)))
        return D3DXERR_INVALIDDATA;
    return D3DXCompileShader(buffer, len, defines, include, entrypoint, profile,
                             flags, shader, error_messages, constant_table);
}

D3DXCompileShaderFromResourceW()

HRESULT WINAPI D3DXCompileShaderFromResourceW	(	HMODULE	module,
		const WCHAR *	resource,
		const D3DXMACRO *	defines,
		ID3DXInclude *	include,
		const char *	entrypoint,
		const char *	profile,
		DWORD	flags,
		ID3DXBuffer **	shader,
		ID3DXBuffer **	error_messages,
		ID3DXConstantTable **	constant_table
	)

Definition at line 588 of file shader.c.

{
    void *buffer;
    HRSRC res;
    DWORD len;
 
    TRACE("module %p, resource %s, defines %p, include %p, entrypoint %s, profile %s, "
            "flags %#x, shader %p, error_messages %p, constant_table %p.\n",
            module, debugstr_w(resource), defines, include, debugstr_a(entrypoint), debugstr_a(profile),
            flags, shader, error_messages, constant_table);
 
    if (!(res = FindResourceW(module, resource, (const WCHAR *)RT_RCDATA)))
        return D3DXERR_INVALIDDATA;
    if (FAILED(load_resource_into_memory(module, res, &buffer, &len)))
        return D3DXERR_INVALIDDATA;
    return D3DXCompileShader(buffer, len, defines, include, entrypoint, profile,
                             flags, shader, error_messages, constant_table);
}

D3DXCreateFragmentLinker()

HRESULT WINAPI D3DXCreateFragmentLinker	(	IDirect3DDevice9 *	device,
		UINT	size,
		ID3DXFragmentLinker **	linker
	)

Definition at line 2325 of file shader.c.

{
    TRACE("device %p, size %u, linker %p.\n", device, size, linker);
 
    return D3DXCreateFragmentLinkerEx(device, size, 0, linker);
}

Referenced by test_fragment_linker().

D3DXCreateFragmentLinkerEx()

HRESULT WINAPI D3DXCreateFragmentLinkerEx	(	IDirect3DDevice9 *	device,
		UINT	size,
		DWORD	flags,
		ID3DXFragmentLinker **	linker
	)

Definition at line 2302 of file shader.c.

{
    struct d3dx9_fragment_linker *object;
 
    TRACE("device %p, size %u, flags %#x, linker %p.\n", device, size, flags, linker);
 
    object = heap_alloc(sizeof(*object));
    if (!object)
        return E_OUTOFMEMORY;
 
    object->ID3DXFragmentLinker_iface.lpVtbl = &d3dx9_fragment_linker_vtbl;
    object->ref = 1;
 
    IDirect3DDevice9_AddRef(device);
    object->device = device;
    object->flags = flags;
 
    *linker = &object->ID3DXFragmentLinker_iface;
 
    return S_OK;
}

Referenced by D3DXCreateFragmentLinker(), and test_fragment_linker().

D3DXCreateTextureShader()

HRESULT WINAPI D3DXCreateTextureShader	(	const DWORD *	pFunction,
		ID3DXTextureShader **	ppTextureShader
	)

Definition at line 2956 of file shader.c.

{
    struct d3dx9_texture_shader *object;
 
    TRACE("function %p, texture_shader %p.\n", function, texture_shader);
 
    if (!function || !texture_shader)
        return D3DERR_INVALIDCALL;
 
    object = HeapAlloc(GetProcessHeap(), 0, sizeof(*object));
    if (!object)
        return E_OUTOFMEMORY;
 
    object->ID3DXTextureShader_iface.lpVtbl = &d3dx9_texture_shader_vtbl;
    object->ref = 1;
 
    *texture_shader = &object->ID3DXTextureShader_iface;
 
    return D3D_OK;
}

Referenced by test_texture_shader().

D3DXDisassembleShader()

HRESULT WINAPI D3DXDisassembleShader	(	const DWORD *	pShader,
		BOOL	EnableColorCode,
		const char *	pComments,
		struct ID3DXBuffer **	ppDisassembly
	)

Definition at line 2645 of file shader.c.

{
    DWORD *ptr = (DWORD *)shader;
    char *buffer, *buf;
    UINT capacity = 4096;
    BOOL ps;
    WORD version;
    HRESULT hr;
 
    TRACE("%p %d %s %p\n", shader, colorcode, debugstr_a(comments), disassembly);
 
    if (!shader || !disassembly)
        return D3DERR_INVALIDCALL;
 
    buf = buffer = HeapAlloc(GetProcessHeap(), 0, capacity);
    if (!buffer)
        return E_OUTOFMEMORY;
 
    ps = (*ptr >> 16) & 1;
    version = *ptr & 0xFFFF;
    buf += sprintf(buf, "    %s_%d_%d\n", ps ? "ps" : "vs", D3DSHADER_VERSION_MAJOR(*ptr), D3DSHADER_VERSION_MINOR(*ptr));
    ptr++;
 
    while (*ptr != D3DSIO_END)
    {
        DWORD index;
 
        if ((buf - buffer + 128) > capacity)
        {
            UINT count = buf - buffer;
            char *new_buffer = HeapReAlloc(GetProcessHeap(), 0, buffer, capacity * 2);
            if (!new_buffer)
            {
                HeapFree(GetProcessHeap(), 0, buffer);
                return E_OUTOFMEMORY;
            }
            capacity *= 2;
            buffer = new_buffer;
            buf = buffer + count;
        }
 
        for (index = 0; index < sizeof(instructions)/sizeof(instructions[0]); index++)
            if (((*ptr & D3DSI_OPCODE_MASK) == instructions[index].opcode) &&
                (version >= instructions[index].min_version) && (version <= instructions[index].max_version))
                break;
 
        if (index != sizeof(instructions)/sizeof(instructions[0]))
        {
            buf += instructions[index].function(&(instructions[index]), &ptr, buf, ps);
        }
        else
        {
            buf += sprintf(buf, "    ??? (Unknown opcode %x)\n", *ptr);
            while (*++ptr & (1u << 31));
        }
    }
 
    hr = D3DXCreateBuffer(buf - buffer + 1 , disassembly);
    if (SUCCEEDED(hr))
        strcpy(ID3DXBuffer_GetBufferPointer(*disassembly), buffer);
    HeapFree(GetProcessHeap(), 0, buffer);
 
    return hr;
}

Referenced by test_disassemble_shader().

D3DXFindShaderComment()

HRESULT WINAPI D3DXFindShaderComment	(	const DWORD *	byte_code,
		DWORD	fourcc,
		const void **	data,
		UINT *	size
	)

Definition at line 150 of file shader.c.

{
    const DWORD *ptr = byte_code;
    DWORD version;
 
    TRACE("byte_code %p, fourcc %x, data %p, size %p\n", byte_code, fourcc, data, size);
 
    if (data) *data = NULL;
    if (size) *size = 0;
 
    if (!byte_code) return D3DERR_INVALIDCALL;
 
    version = *ptr >> 16;
    if (version != 0x4658         /* FX */
            && version != 0x5458  /* TX */
            && version != 0x7ffe
            && version != 0x7fff
            && version != 0xfffe  /* VS */
            && version != 0xffff) /* PS */
    {
        WARN("Invalid data supplied\n");
        return D3DXERR_INVALIDDATA;
    }
 
    while (*++ptr != D3DSIO_END)
    {
        /* Check if it is a comment */
        if ((*ptr & D3DSI_OPCODE_MASK) == D3DSIO_COMMENT)
        {
            DWORD comment_size = (*ptr & D3DSI_COMMENTSIZE_MASK) >> D3DSI_COMMENTSIZE_SHIFT;
 
            /* Check if this is the comment we are looking for */
            if (*(ptr + 1) == fourcc)
            {
                UINT ctab_size = (comment_size - 1) * sizeof(DWORD);
                const void *ctab_data = ptr + 2;
                if (size)
                    *size = ctab_size;
                if (data)
                    *data = ctab_data;
                TRACE("Returning comment data at %p with size %d\n", ctab_data, ctab_size);
                return D3D_OK;
            }
            ptr += comment_size;
        }
    }
 
    return S_FALSE;
}

Referenced by D3DXGetShaderConstantTableEx(), D3DXGetShaderSamplers(), and test_find_shader_comment().

D3DXGetPixelShaderProfile()

const char *WINAPI D3DXGetPixelShaderProfile

(

struct IDirect3DDevice9 *

device

)

Definition at line 43 of file shader.c.

{
    D3DCAPS9 caps;
 
    TRACE("device %p\n", device);
 
    if (!device) return NULL;
 
    IDirect3DDevice9_GetDeviceCaps(device,&caps);
 
    switch (caps.PixelShaderVersion)
    {
    case D3DPS_VERSION(1, 1):
        return "ps_1_1";
 
    case D3DPS_VERSION(1, 2):
        return "ps_1_2";
 
    case D3DPS_VERSION(1, 3):
        return "ps_1_3";
 
    case D3DPS_VERSION(1, 4):
        return "ps_1_4";
 
    case D3DPS_VERSION(2, 0):
        if ((caps.PS20Caps.NumTemps>=22)                          &&
            (caps.PS20Caps.Caps&D3DPS20CAPS_ARBITRARYSWIZZLE)     &&
            (caps.PS20Caps.Caps&D3DPS20CAPS_GRADIENTINSTRUCTIONS) &&
            (caps.PS20Caps.Caps&D3DPS20CAPS_PREDICATION)          &&
            (caps.PS20Caps.Caps&D3DPS20CAPS_NODEPENDENTREADLIMIT) &&
            (caps.PS20Caps.Caps&D3DPS20CAPS_NOTEXINSTRUCTIONLIMIT))
        {
            return "ps_2_a";
        }
        if ((caps.PS20Caps.NumTemps>=32)                          &&
            (caps.PS20Caps.Caps&D3DPS20CAPS_NOTEXINSTRUCTIONLIMIT))
        {
            return "ps_2_b";
        }
        return "ps_2_0";
 
    case D3DPS_VERSION(3, 0):
        return "ps_3_0";
    }
 
    return NULL;
}

D3DXGetShaderConstantTable()

HRESULT WINAPI D3DXGetShaderConstantTable	(	const DWORD *	byte_code,
		ID3DXConstantTable **	constant_table
	)

Definition at line 2111 of file shader.c.

{
    TRACE("(%p, %p): Forwarded to D3DXGetShaderConstantTableEx\n", byte_code, constant_table);
 
    return D3DXGetShaderConstantTableEx(byte_code, 0, constant_table);
}

Referenced by compile_pixel_shader9(), D3DXCompileShader(), D3DXCompileShaderFromFileW(), get_constants_desc(), test_constant_table(), test_get_sampler_index(), test_get_shader_constant_variables(), test_registerset(), test_registerset_defaults(), test_SetDefaults(), test_setting_arrays_table(), test_setting_basic_table(), test_setting_matrices_table(), and test_SetValue().

D3DXGetShaderConstantTableEx()

HRESULT WINAPI D3DXGetShaderConstantTableEx	(	const DWORD *	byte_code,
		DWORD	flags,
		ID3DXConstantTable **	constant_table
	)

Definition at line 1993 of file shader.c.

{
    struct ID3DXConstantTableImpl *object = NULL;
    const void *data;
    HRESULT hr;
    UINT size;
    const D3DXSHADER_CONSTANTTABLE *ctab_header;
    const D3DXSHADER_CONSTANTINFO *constant_info;
    DWORD i;
 
    TRACE("byte_code %p, flags %x, constant_table %p\n", byte_code, flags, constant_table);
 
    if (constant_table) *constant_table = NULL;
 
    if (!byte_code || !constant_table)
    {
        WARN("Invalid argument specified.\n");
        return D3DERR_INVALIDCALL;
    }
 
    if (!is_valid_bytecode(*byte_code))
    {
        WARN("Invalid byte_code specified.\n");
        return D3D_OK;
    }
 
    if (flags) FIXME("Flags (%#x) are not handled, yet!\n", flags);
 
    hr = D3DXFindShaderComment(byte_code, MAKEFOURCC('C','T','A','B'), &data, &size);
    if (hr != D3D_OK)
    {
        WARN("CTAB not found.\n");
        return D3DXERR_INVALIDDATA;
    }
 
    if (size < sizeof(*ctab_header))
    {
        WARN("Invalid CTAB size.\n");
        return D3DXERR_INVALIDDATA;
    }
 
    ctab_header = (const D3DXSHADER_CONSTANTTABLE *)data;
    if (ctab_header->Size != sizeof(*ctab_header))
    {
        WARN("Invalid D3DXSHADER_CONSTANTTABLE size.\n");
        return D3DXERR_INVALIDDATA;
    }
 
    object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object));
    if (!object)
        return E_OUTOFMEMORY;
 
    object->ID3DXConstantTable_iface.lpVtbl = &ID3DXConstantTable_Vtbl;
    object->ref = 1;
 
    object->ctab = HeapAlloc(GetProcessHeap(), 0, size);
    if (!object->ctab)
    {
        ERR("Out of memory\n");
        HeapFree(GetProcessHeap(), 0, object);
        return E_OUTOFMEMORY;
    }
    object->size = size;
    memcpy(object->ctab, data, object->size);
 
    object->desc.Creator = ctab_header->Creator ? object->ctab + ctab_header->Creator : NULL;
    object->desc.Version = ctab_header->Version;
    object->desc.Constants = ctab_header->Constants;
    TRACE("Creator %s, Version %x, Constants %u, Target %s\n",
            debugstr_a(object->desc.Creator), object->desc.Version, object->desc.Constants,
            debugstr_a(ctab_header->Target ? object->ctab + ctab_header->Target : NULL));
 
    object->constants = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
                                  sizeof(*object->constants) * object->desc.Constants);
    if (!object->constants)
    {
         ERR("Out of memory\n");
         hr = E_OUTOFMEMORY;
         goto error;
    }
 
    constant_info = (const D3DXSHADER_CONSTANTINFO *)(object->ctab + ctab_header->ConstantInfo);
    for (i = 0; i < ctab_header->Constants; i++)
    {
        DWORD offset = constant_info[i].DefaultValue;
 
        hr = parse_ctab_constant_type(object->ctab, constant_info[i].TypeInfo,
                &object->constants[i], FALSE, constant_info[i].RegisterIndex,
                constant_info[i].RegisterIndex + constant_info[i].RegisterCount,
                offset ? &offset : NULL, constant_info[i].Name, constant_info[i].RegisterSet);
        if (hr != D3D_OK)
            goto error;
 
        /*
         * Set the register count, it may differ for D3DXRS_INT4, because somehow
         * it makes the assumption that the register size is 1 instead of 4, so the
         * count is 4 times bigger. This holds true only for toplevel shader
         * constants. The count of elements and members is always based on a
         * register size of 4.
         */
        if (object->constants[i].desc.RegisterSet == D3DXRS_INT4)
        {
            object->constants[i].desc.RegisterCount = constant_info[i].RegisterCount;
        }
        object->constants[i].constantinfo_reserved = constant_info[i].Reserved;
    }
 
    *constant_table = &object->ID3DXConstantTable_iface;
 
    return D3D_OK;
 
error:
    free_constant_table(object);
    HeapFree(GetProcessHeap(), 0, object);
 
    return hr;
}

Referenced by D3DXGetShaderConstantTable(), and test_get_shader_constant_table_ex().

D3DXGetShaderInputSemantics()

HRESULT WINAPI D3DXGetShaderInputSemantics	(	const DWORD *	byte_code,
		D3DXSEMANTIC *	semantics,
		UINT *	count
	)

Definition at line 3211 of file shader.c.

{
    TRACE("byte_code %p, semantics %p, count %p.\n", byte_code, semantics, count);
 
    return get_shader_semantics(byte_code, semantics, count, FALSE);
}

Referenced by test_shader_semantics().

D3DXGetShaderOuputSemantics()

HRESULT WINAPI D3DXGetShaderOuputSemantics	(	const DWORD *	byte_code,
		D3DXSEMANTIC *	semantics,
		UINT *	count
	)

D3DXGetShaderOutputSemantics()

HRESULT WINAPI D3DXGetShaderOutputSemantics	(	const DWORD *	pFunction,
		D3DXSEMANTIC *	pSemantics,
		UINT *	pCount
	)

Definition at line 3218 of file shader.c.

{
    TRACE("byte_code %p, semantics %p, count %p.\n", byte_code, semantics, count);
 
    return get_shader_semantics(byte_code, semantics, count, TRUE);
}

Referenced by test_shader_semantics().

D3DXGetShaderSamplers()

HRESULT WINAPI D3DXGetShaderSamplers	(	const DWORD *	byte_code,
		const char **	samplers,
		UINT *	count
	)

Definition at line 2332 of file shader.c.

{
    UINT i, sampler_count = 0;
    UINT size;
    const char *data;
    const D3DXSHADER_CONSTANTTABLE *ctab_header;
    const D3DXSHADER_CONSTANTINFO *constant_info;
 
    TRACE("byte_code %p, samplers %p, count %p\n", byte_code, samplers, count);
 
    if (count) *count = 0;
 
    if (D3DXFindShaderComment(byte_code, MAKEFOURCC('C','T','A','B'), (const void **)&data, &size) != D3D_OK)
        return D3D_OK;
 
    if (size < sizeof(*ctab_header)) return D3D_OK;
 
    ctab_header = (const D3DXSHADER_CONSTANTTABLE *)data;
    if (ctab_header->Size != sizeof(*ctab_header)) return D3D_OK;
 
    constant_info = (const D3DXSHADER_CONSTANTINFO *)(data + ctab_header->ConstantInfo);
    for (i = 0; i < ctab_header->Constants; i++)
    {
        const D3DXSHADER_TYPEINFO *type;
 
        TRACE("name = %s\n", data + constant_info[i].Name);
 
        type = (const D3DXSHADER_TYPEINFO *)(data + constant_info[i].TypeInfo);
 
        if (type->Type == D3DXPT_SAMPLER
                || type->Type == D3DXPT_SAMPLER1D
                || type->Type == D3DXPT_SAMPLER2D
                || type->Type == D3DXPT_SAMPLER3D
                || type->Type == D3DXPT_SAMPLERCUBE)
        {
            if (samplers) samplers[sampler_count] = data + constant_info[i].Name;
 
            ++sampler_count;
        }
    }
 
    TRACE("Found %u samplers\n", sampler_count);
 
    if (count) *count = sampler_count;
 
    return D3D_OK;
}

Referenced by test_get_shader_samplers().

D3DXGetShaderSize()

UINT WINAPI D3DXGetShaderSize

(

const DWORD *

byte_code

)

Definition at line 91 of file shader.c.

{
    const DWORD *ptr = byte_code;
 
    TRACE("byte_code %p\n", byte_code);
 
    if (!ptr) return 0;
 
    /* Look for the END token, skipping the VERSION token */
    while (*++ptr != D3DSIO_END)
    {
        /* Skip comments */
        if ((*ptr & D3DSI_OPCODE_MASK) == D3DSIO_COMMENT)
        {
            ptr += ((*ptr & D3DSI_COMMENTSIZE_MASK) >> D3DSI_COMMENTSIZE_SHIFT);
        }
    }
    ++ptr;
 
    /* Return the shader size in bytes */
    return (ptr - byte_code) * sizeof(*ptr);
}

Referenced by test_get_shader_size().

D3DXGetShaderVersion()

DWORD WINAPI D3DXGetShaderVersion

(

const DWORD *

byte_code

)

Definition at line 114 of file shader.c.

{
    TRACE("byte_code %p\n", byte_code);
 
    return byte_code ? *byte_code : 0;
}

Referenced by test_get_shader_version().

D3DXGetVertexShaderProfile()

const char *WINAPI D3DXGetVertexShaderProfile

(

struct IDirect3DDevice9 *

device

)

Definition at line 121 of file shader.c.

{
    D3DCAPS9 caps;
 
    TRACE("device %p\n", device);
 
    if (!device) return NULL;
 
    IDirect3DDevice9_GetDeviceCaps(device,&caps);
 
    switch (caps.VertexShaderVersion)
    {
    case D3DVS_VERSION(1, 1):
        return "vs_1_1";
    case D3DVS_VERSION(2, 0):
        if ((caps.VS20Caps.NumTemps>=13) &&
            (caps.VS20Caps.DynamicFlowControlDepth==24) &&
            (caps.VS20Caps.Caps&D3DPS20CAPS_PREDICATION))
        {
            return "vs_2_a";
        }
        return "vs_2_0";
    case D3DVS_VERSION(3, 0):
        return "vs_3_0";
    }
 
    return NULL;
}

D3DXPreprocessShader()

HRESULT WINAPI D3DXPreprocessShader	(	const char *	data,
		UINT	data_len,
		const D3DXMACRO *	defines,
		ID3DXInclude *	include,
		ID3DXBuffer **	shader,
		ID3DXBuffer **	error_messages
	)

Definition at line 609 of file shader.c.

{
    TRACE("data %s, data_len %u, defines %p, include %p, shader %p, error_messages %p.\n",
            debugstr_a(data), data_len, defines, include, shader, error_messages);
 
    return D3DPreprocess(data, data_len, NULL,
                         (const D3D_SHADER_MACRO *)defines, (ID3DInclude *)include,
                         (ID3DBlob **)shader, (ID3DBlob **)error_messages);
}

Referenced by D3DXPreprocessShaderFromResourceA(), and D3DXPreprocessShaderFromResourceW().

D3DXPreprocessShaderFromFileA()

HRESULT WINAPI D3DXPreprocessShaderFromFileA	(	const char *	filename,
		const D3DXMACRO *	defines,
		ID3DXInclude *	include,
		ID3DXBuffer **	shader,
		ID3DXBuffer **	error_messages
	)

Definition at line 620 of file shader.c.

{
    WCHAR *filename_w = NULL;
    DWORD len;
    HRESULT ret;
 
    TRACE("filename %s, defines %p, include %p, shader %p, error_messages %p.\n",
            debugstr_a(filename), defines, include, shader, error_messages);
 
    if (!filename) return D3DXERR_INVALIDDATA;
 
    len = MultiByteToWideChar(CP_ACP, 0, filename, -1, NULL, 0);
    filename_w = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
    if (!filename_w) return E_OUTOFMEMORY;
    MultiByteToWideChar(CP_ACP, 0, filename, -1, filename_w, len);
 
    ret = D3DXPreprocessShaderFromFileW(filename_w, defines, include, shader, error_messages);
 
    HeapFree(GetProcessHeap(), 0, filename_w);
    return ret;
}

Referenced by d3dxpreprocess_test().

D3DXPreprocessShaderFromFileW()

HRESULT WINAPI D3DXPreprocessShaderFromFileW	(	const WCHAR *	filename,
		const D3DXMACRO *	defines,
		ID3DXInclude *	include,
		ID3DXBuffer **	shader,
		ID3DXBuffer **	error_messages
	)

Definition at line 643 of file shader.c.

{
    const void *buffer;
    DWORD len;
    HRESULT hr;
    struct d3dx_include_from_file include_from_file;
    char *filename_a;
 
    TRACE("filename %s, defines %p, include %p, shader %p, error_messages %p.\n",
            debugstr_w(filename), defines, include, shader, error_messages);
 
    if (!include)
    {
        include_from_file.ID3DXInclude_iface.lpVtbl = &d3dx_include_from_file_vtbl;
        include = &include_from_file.ID3DXInclude_iface;
    }
 
    len = WideCharToMultiByte(CP_ACP, 0, filename, -1, NULL, 0, NULL, NULL);
    filename_a = HeapAlloc(GetProcessHeap(), 0, len * sizeof(char));
    if (!filename_a)
        return E_OUTOFMEMORY;
    WideCharToMultiByte(CP_ACP, 0, filename, -1, filename_a, len, NULL, NULL);
 
    EnterCriticalSection(&from_file_mutex);
    hr = ID3DXInclude_Open(include, D3DXINC_LOCAL, filename_a, NULL, &buffer, &len);
    if (FAILED(hr))
    {
        LeaveCriticalSection(&from_file_mutex);
        HeapFree(GetProcessHeap(), 0, filename_a);
        return D3DXERR_INVALIDDATA;
    }
 
    hr = D3DPreprocess(buffer, len, NULL,
                       (const D3D_SHADER_MACRO *)defines,
                       (ID3DInclude *) include,
                       (ID3DBlob **)shader, (ID3DBlob **)error_messages);
 
    ID3DXInclude_Close(include, buffer);
    LeaveCriticalSection(&from_file_mutex);
    HeapFree(GetProcessHeap(), 0, filename_a);
    return hr;
}

Referenced by d3dxpreprocess_test(), and D3DXPreprocessShaderFromFileA().

D3DXPreprocessShaderFromResourceA()

HRESULT WINAPI D3DXPreprocessShaderFromResourceA	(	HMODULE	module,
		const char *	resource,
		const D3DXMACRO *	defines,
		ID3DXInclude *	include,
		ID3DXBuffer **	shader,
		ID3DXBuffer **	error_messages
	)

Definition at line 687 of file shader.c.

{
    void *buffer;
    HRSRC res;
    DWORD len;
 
    TRACE("module %p, resource %s, defines %p, include %p, shader %p, error_messages %p.\n",
            module, debugstr_a(resource), defines, include, shader, error_messages);
 
    if (!(res = FindResourceA(module, resource, (const char *)RT_RCDATA)))
        return D3DXERR_INVALIDDATA;
    if (FAILED(load_resource_into_memory(module, res, &buffer, &len)))
        return D3DXERR_INVALIDDATA;
    return D3DXPreprocessShader(buffer, len, defines, include,
                                shader, error_messages);
}

Referenced by d3dxpreprocess_test().

D3DXPreprocessShaderFromResourceW()

HRESULT WINAPI D3DXPreprocessShaderFromResourceW	(	HMODULE	module,
		const WCHAR *	resource,
		const D3DXMACRO *	defines,
		ID3DXInclude *	include,
		ID3DXBuffer **	shader,
		ID3DXBuffer **	error_messages
	)

Definition at line 705 of file shader.c.

{
    void *buffer;
    HRSRC res;
    DWORD len;
 
    TRACE("module %p, resource %s, defines %p, include %p, shader %p, error_messages %p.\n",
            module, debugstr_w(resource), defines, include, shader, error_messages);
 
    if (!(res = FindResourceW(module, resource, (const WCHAR *)RT_RCDATA)))
        return D3DXERR_INVALIDDATA;
    if (FAILED(load_resource_into_memory(module, res, &buffer, &len)))
        return D3DXERR_INVALIDDATA;
    return D3DXPreprocessShader(buffer, len, defines, include,
                                shader, error_messages);
 
}

DECLARE_INTERFACE()

DECLARE_INTERFACE

(

ID3DXInclude

)

Definition at line 295 of file d3dx9shader.h.

{
    STDMETHOD(Open)(THIS_ D3DXINCLUDE_TYPE include_type, const char *filename,
            const void *parent_data, const void **data, UINT *bytes) PURE;
    STDMETHOD(Close)(THIS_ const void *data) PURE;
};

DECLARE_INTERFACE_() [1/3]

DECLARE_INTERFACE_	(	ID3DXConstantTable	,
		ID3DXBuffer
	)

Definition at line 128 of file d3dx9shader.h.

{
    /*** IUnknown methods ***/
    STDMETHOD(QueryInterface)(THIS_ REFIID iid, void **out) PURE;
    STDMETHOD_(ULONG, AddRef)(THIS) PURE;
    STDMETHOD_(ULONG, Release)(THIS) PURE;
    /*** ID3DXBuffer methods ***/
    STDMETHOD_(void *, GetBufferPointer)(THIS) PURE;
    STDMETHOD_(DWORD, GetBufferSize)(THIS) PURE;
    /*** ID3DXConstantTable methods ***/
    STDMETHOD(GetDesc)(THIS_ D3DXCONSTANTTABLE_DESC *pDesc) PURE;
    STDMETHOD(GetConstantDesc)(THIS_ D3DXHANDLE hConstant, D3DXCONSTANT_DESC *pConstantDesc, UINT *pCount) PURE;
    STDMETHOD_(UINT, GetSamplerIndex)(THIS_ D3DXHANDLE hConstant) PURE;
    STDMETHOD_(D3DXHANDLE, GetConstant)(THIS_ D3DXHANDLE hConstant, UINT Index) PURE;
    STDMETHOD_(D3DXHANDLE, GetConstantByName)(THIS_ D3DXHANDLE constant, const char *name) PURE;
    STDMETHOD_(D3DXHANDLE, GetConstantElement)(THIS_ D3DXHANDLE hConstant, UINT Index) PURE;
    STDMETHOD(SetDefaults)(THIS_ struct IDirect3DDevice9 *device) PURE;
    STDMETHOD(SetValue)(THIS_ struct IDirect3DDevice9 *device, D3DXHANDLE constant,
            const void *data, UINT data_size) PURE;
    STDMETHOD(SetBool)(THIS_ struct IDirect3DDevice9 *device, D3DXHANDLE constant, BOOL value) PURE;
    STDMETHOD(SetBoolArray)(THIS_ struct IDirect3DDevice9 *device, D3DXHANDLE constant,
            const BOOL *values, UINT value_count) PURE;
    STDMETHOD(SetInt)(THIS_ struct IDirect3DDevice9 *device, D3DXHANDLE constant, INT value) PURE;
    STDMETHOD(SetIntArray)(THIS_ struct IDirect3DDevice9 *device, D3DXHANDLE constant,
            const INT *values, UINT value_count) PURE;
    STDMETHOD(SetFloat)(THIS_ struct IDirect3DDevice9 *device, D3DXHANDLE constant, float value) PURE;
    STDMETHOD(SetFloatArray)(THIS_ struct IDirect3DDevice9 *device, D3DXHANDLE constant,
            const float *values, UINT value_count) PURE;
    STDMETHOD(SetVector)(THIS_ struct IDirect3DDevice9 *device, D3DXHANDLE constant, const D3DXVECTOR4 *value) PURE;
    STDMETHOD(SetVectorArray)(THIS_ struct IDirect3DDevice9 *device, D3DXHANDLE constant,
            const D3DXVECTOR4 *values, UINT value_count) PURE;
    STDMETHOD(SetMatrix)(THIS_ struct IDirect3DDevice9 *device, D3DXHANDLE constant, const D3DXMATRIX *value) PURE;
    STDMETHOD(SetMatrixArray)(THIS_ struct IDirect3DDevice9 *device, D3DXHANDLE constant,
            const D3DXMATRIX *values, UINT value_count) PURE;
    STDMETHOD(SetMatrixPointerArray)(THIS_ struct IDirect3DDevice9 *device, D3DXHANDLE constant,
            const D3DXMATRIX **values, UINT value_count) PURE;
    STDMETHOD(SetMatrixTranspose)(THIS_ struct IDirect3DDevice9 *device, D3DXHANDLE constant,
            const D3DXMATRIX *value) PURE;
    STDMETHOD(SetMatrixTransposeArray)(THIS_ struct IDirect3DDevice9 *device, D3DXHANDLE constant,
            const D3DXMATRIX *values, UINT value_count) PURE;
    STDMETHOD(SetMatrixTransposePointerArray)(THIS_ struct IDirect3DDevice9 *device, D3DXHANDLE constant,
            const D3DXMATRIX **values, UINT value_count) PURE;
};

DECLARE_INTERFACE_() [2/3]

DECLARE_INTERFACE_	(	ID3DXFragmentLinker	,
		IUnknown
	)

Definition at line 319 of file d3dx9shader.h.

{
    STDMETHOD(QueryInterface)(THIS_ REFIID iid, void **ppv) PURE;
    STDMETHOD_(ULONG, AddRef)(THIS) PURE;
    STDMETHOD_(ULONG, Release)(THIS) PURE;
 
    STDMETHOD(GetDevice)(THIS_ struct IDirect3DDevice9 **device) PURE;
    STDMETHOD_(UINT, GetNumberOfFragments)(THIS) PURE;
 
    STDMETHOD_(D3DXHANDLE, GetFragmentHandleByIndex)(THIS_ UINT index) PURE;
    STDMETHOD_(D3DXHANDLE, GetFragmentHandleByName)(THIS_ const char *name) PURE;
    STDMETHOD(GetFragmentDesc)(THIS_ D3DXHANDLE name, D3DXFRAGMENT_DESC *frag_desc) PURE;
 
    STDMETHOD(AddFragments)(THIS_ const DWORD *fragments) PURE;
 
    STDMETHOD(GetAllFragments)(THIS_ ID3DXBuffer **buffer) PURE;
    STDMETHOD(GetFragment)(THIS_ D3DXHANDLE name, ID3DXBuffer **buffer) PURE;
 
    STDMETHOD(LinkShader)(THIS_ const char *profile, DWORD flags, const D3DXHANDLE *fragmenthandles, UINT fragments, ID3DXBuffer **buffer, ID3DXBuffer **errors) PURE;
    STDMETHOD(LinkVertexShader)(THIS_ const char *profile, DWORD flags, const D3DXHANDLE *fragment_handles, UINT fragments, IDirect3DVertexShader9 **shader, ID3DXBuffer **errors) PURE;
    STDMETHOD(LinkPixelShader)(THIS_ const char *profile, DWORD flags, const D3DXHANDLE *fragment_handles, UINT fragments, IDirect3DPixelShader9 **shader, ID3DXBuffer **errors) PURE;
 
    STDMETHOD(ClearCache)(THIS) PURE;
};

DECLARE_INTERFACE_() [3/3]

DECLARE_INTERFACE_	(	ID3DXTextureShader	,
		IUnknown
	)

Definition at line 244 of file d3dx9shader.h.

{
    STDMETHOD(QueryInterface)(THIS_ REFIID riid, void **ppv) PURE;
    STDMETHOD_(ULONG, AddRef)(THIS) PURE;
    STDMETHOD_(ULONG, Release)(THIS) PURE;
    STDMETHOD(GetFunction)(THIS_ struct ID3DXBuffer **ppFunction) PURE;
    STDMETHOD(GetConstantBuffer)(THIS_ struct ID3DXBuffer **ppConstantBuffer) PURE;
    STDMETHOD(GetDesc)(THIS_ D3DXCONSTANTTABLE_DESC *pDesc) PURE;
    STDMETHOD(GetConstantDesc)(THIS_ D3DXHANDLE hConstant, D3DXCONSTANT_DESC *pConstantDesc, UINT *pCount) PURE;
    STDMETHOD_(D3DXHANDLE, GetConstant)(THIS_ D3DXHANDLE hConstant, UINT Index) PURE;
    STDMETHOD_(D3DXHANDLE, GetConstantByName)(THIS_ D3DXHANDLE hConstant, const char *pName) PURE;
    STDMETHOD_(D3DXHANDLE, GetConstantElement)(THIS_ D3DXHANDLE hConstant, UINT Index) PURE;
    STDMETHOD(SetDefaults)(THIS) PURE;
    STDMETHOD(SetValue)(THIS_ D3DXHANDLE hConstant, const void *pData, UINT Bytes) PURE;
    STDMETHOD(SetBool)(THIS_ D3DXHANDLE hConstant, BOOL b) PURE;
    STDMETHOD(SetBoolArray)(THIS_ D3DXHANDLE hConstant, const BOOL *pb, UINT Count) PURE;
    STDMETHOD(SetInt)(THIS_ D3DXHANDLE hConstant, INT n) PURE;
    STDMETHOD(SetIntArray)(THIS_ D3DXHANDLE hConstant, const INT *pn, UINT Count) PURE;
    STDMETHOD(SetFloat)(THIS_ D3DXHANDLE hConstant, FLOAT f) PURE;
    STDMETHOD(SetFloatArray)(THIS_ D3DXHANDLE hConstant, const FLOAT *pf, UINT Count) PURE;
    STDMETHOD(SetVector)(THIS_ D3DXHANDLE hConstant, const D3DXVECTOR4 *pVector) PURE;
    STDMETHOD(SetVectorArray)(THIS_ D3DXHANDLE hConstant, const D3DXVECTOR4 *pVector, UINT Count) PURE;
    STDMETHOD(SetMatrix)(THIS_ D3DXHANDLE hConstant, const D3DXMATRIX *pMatrix) PURE;
    STDMETHOD(SetMatrixArray)(THIS_ D3DXHANDLE hConstant, const D3DXMATRIX *pMatrix, UINT Count) PURE;
    STDMETHOD(SetMatrixPointerArray)(THIS_ D3DXHANDLE hConstant, const D3DXMATRIX **ppMatrix, UINT Count) PURE;
    STDMETHOD(SetMatrixTranspose)(THIS_ D3DXHANDLE hConstant, const D3DXMATRIX *pMatrix) PURE;
    STDMETHOD(SetMatrixTransposeArray)(THIS_ D3DXHANDLE hConstant, const D3DXMATRIX *pMatrix, UINT Count) PURE;
    STDMETHOD(SetMatrixTransposePointerArray)(THIS_ D3DXHANDLE hConstant, const D3DXMATRIX **ppMatrix, UINT Count) PURE;
};

DEFINE_GUID() [1/3]

DEFINE_GUID	(	IID_ID3DXConstantTable	,
		0x9dca3190	,
		0x38b9	,
		0x4fc3	,
		0x92	,
		0xe3	,
		0x39	,
		0xc6	,
		0xdd	,
		0xfb	,
		0x35	,
		0x8b
	)

DEFINE_GUID() [2/3]

DEFINE_GUID	(	IID_ID3DXFragmentLinker	,
		0x1a2c0cc2	,
		0xe5b6	,
		0x4ebc	,
		0x9e	,
		0x8d	,
		0x39	,
		0xe	,
		0x5	,
		0x78	,
		0x11	,
		0xb6
	)

DEFINE_GUID() [3/3]

DEFINE_GUID	(	IID_ID3DXTextureShader	,
		0x3e3d67f8	,
		0xaa7a	,
		0x405d	,
		0xa8	,
		0x57	,
		0xba	,
		0x1	,
		0xd4	,
		0x75	,
		0x84	,
		0x26
	)