njohnson/XPlor
0
0
Fork 0
Code Issues Pull Requests Actions Packages Projects 1 Releases 1 Wiki Activity
XPlor/third_party/xbox_sdk/include/d3dx9shader.h

1476 lines
62 KiB
C
Raw Normal View History

Oh yeah
2025-04-23 00:09:35 -04:00
//////////////////////////////////////////////////////////////////////////////
//
// Copyright (c) Microsoft Corporation. All rights reserved.
//
// File: d3dx9shader.h
// Content: D3DX Shader APIs
//
//////////////////////////////////////////////////////////////////////////////
#include "d3dx9.h"
#ifndef __D3DX9SHADER_H__
#define __D3DX9SHADER_H__
//---------------------------------------------------------------------------
// D3DXTX_VERSION:
// --------------
// Version token used to create a procedural texture filler in effects
// Used by D3DXFill[]TX functions
//---------------------------------------------------------------------------
#define D3DXTX_VERSION(_Major,_Minor) (('T' << 24) | ('X' << 16) | ((_Major) << 8) | (_Minor))
// begin_internal
//----------------------------------------------------------------------------
// D3DXFXL_VERSION:
// ----------------
// Version token used by host expression evaluator.
//----------------------------------------------------------------------------
#define D3DXFXL_VERSION(_Major,_Minor) (('F' << 24) | ('X' << 16) | ((_Major) << 8) | (_Minor)) // internal
// end_internal
//----------------------------------------------------------------------------
// D3DXSHADER/EX flags:
// -----------------
// D3DXSHADER_DEBUG
// Insert debug file/line/type/symbol information.
//
// D3DXSHADER_SKIPVALIDATION
// Do not validate the generated code against known capabilities and
// constraints. This option is only recommended when compiling shaders
// you KNOW will work. (ie. have compiled before without this option.)
// Shaders are always validated by D3D before they are set to the device.
//
// D3DXSHADER_SKIPOPTIMIZATION (valid for D3DXCompileShader calls only)
// Instructs the compiler to skip optimization steps during code generation.
// Unless you are trying to isolate a problem in your code, and suspect the
// compiler, using this option is not recommended.
//
// D3DXSHADER_PACKMATRIX_ROWMAJOR
// Unless explicitly specified, matrices will be packed in row-major order
// on input and output from the shader.
//
// D3DXSHADER_PACKMATRIX_COLUMNMAJOR
// Unless explicitly specified, matrices will be packed in column-major
// order on input and output from the shader. This is generally more
// efficient, since it allows vector-matrix multiplication to be performed
// using a series of dot-products.
//
// D3DXSHADER_PARTIAL_PRECISION
// Force all computations in resulting shader to occur at partial precision.
// This may result in faster evaluation of shaders on some hardware.
//
// D3DXSHADER_FORCE_VS_SOFTWARE_NOOPT
// Force compiler to compile against the next highest available software
// target for vertex shaders. This flag also turns optimizations off,
// and debugging on.
//
// D3DXSHADER_FORCE_PS_SOFTWARE_NOOPT
// Force compiler to compile against the next highest available software
// target for pixel shaders. This flag also turns optimizations off,
// and debugging on.
//
// D3DXSHADER_NO_PRESHADER
// Disables Preshaders. Using this flag will cause the compiler to not
// pull out static expression for evaluation on the host cpu
//
// D3DXSHADER_AVOID_FLOW_CONTROL
// Hint compiler to avoid flow-control constructs where possible.
//
// D3DXSHADER_PREFER_FLOW_CONTROL
// Hint compiler to prefer flow-control constructs where possible.
//
// D3D10_SHADER_ENABLE_STRICTNESS
// By default, the HLSL/Effect compilers are not strict on deprecated syntax.
// Specifying this flag enables the strict mode. Deprecated syntax may be
// removed in a future release, and enabling syntax is a good way to make sure
// your shaders comply to the latest spec.
//
// D3D10_SHADER_ENABLE_BACKWARDS_COMPATIBILITY
// This enables older shaders to compile to 4_0 targets.
// begin internal
//
// D3DXSHADER_FRAGMENT
// Indicates that you are compiling code as a fragment, to be linked
// together at a later time. This flag implies D3DXSHADER_SKIPVALIDATION.
//
// D3DXSHADER_SKIPASMBLOCKS
// Indicates that the parser should skip over ASM blocks without invoking
// the assembler. This flag is implied by D3DXCompileShader APIs.
// end internal
//----------------------------------------------------------------------------
#define D3DXSHADER_DEBUG (1 << 0)
#define D3DXSHADER_SKIPVALIDATION (1 << 1)
#define D3DXSHADER_SKIPOPTIMIZATION (1 << 2)
#define D3DXSHADER_PACKMATRIX_ROWMAJOR (1 << 3)
#define D3DXSHADER_PACKMATRIX_COLUMNMAJOR (1 << 4)
#define D3DXSHADER_PARTIALPRECISION (1 << 5)
#define D3DXSHADER_FORCE_VS_SOFTWARE_NOOPT (1 << 6)
#define D3DXSHADER_FORCE_PS_SOFTWARE_NOOPT (1 << 7)
#define D3DXSHADER_NO_PRESHADER (1 << 8)
#define D3DXSHADER_AVOID_FLOW_CONTROL (1 << 9)
#define D3DXSHADER_PREFER_FLOW_CONTROL (1 << 10)
#define D3D10_SHADER_ENABLE_STRICTNESS (1 << 11)
#define D3D10_SHADER_ENABLE_BACKWARDS_COMPATIBILITY (1 << 12)
#define D3DXSHADER_SKIPMICROCODEOPTIMIZATION_DEPRECATED (1 << 17) // Xbox extension
#define D3DXSHADER_ZERO_INIT_LOCAL_VARS (1 << 18) // Xbox extension
#define D3DXSHADER_DISABLE_ZPASS_COMPARISON_VALIDATION (1 << 19) //Xbox extension
#define D3DXSHADER_SKIPMICROCODE_DEPRECATED (1 << 20) // Xbox extension
#define D3DXSHADER_ENABLEVERIFIER (1 << 22) // Xbox extension
#define D3DXSHADER_MICROCODE_BACKEND_NEW (1 << 24) // Xbox extension
#define D3DXSHADER_MICROCODE_BACKEND_OLD_DEPRECATED (1 << 25) // Xbox extension
// from fxl.h
//#define D3DXSHADER_FXLANNOTATE_VARIABLE_NAMES (1 << 26)
//#define D3DXSHADER_FXLANNOTATE_SEMANTIC_NAMES (1 << 27)
//#define D3DXSHADER_FXLPARAMETERS_AS_VARIABLE_NAMES (1 << 28)
//#define D3DXSHADER_FXLEFFECT_NATIVE_ENDIAN (1 << 29)
#define D3DXSHADER_FRAGMENT (1 << 30) // internal
#define D3DXSHADER_SKIPASMBLOCKS (1 << 31) // internal
// begin internal
#define D3DXSHADER_VALID_ASSEMBLER_FLAGS \
( D3DXSHADER_DEBUG | \
D3DXSHADER_SKIPVALIDATION | \
D3DXSHADER_SKIPMICROCODE_DEPRECATED | \
D3DXSHADER_SKIPMICROCODEOPTIMIZATION_DEPRECATED | \
D3DXSHADER_DISABLE_ZPASS_COMPARISON_VALIDATION)
#define D3DXSHADER_VALID_COMPILER_FLAGS \
( D3DXSHADER_DEBUG | \
D3DXSHADER_SKIPVALIDATION | \
D3DXSHADER_SKIPOPTIMIZATION | \
D3DXSHADER_PACKMATRIX_ROWMAJOR | \
D3DXSHADER_PACKMATRIX_COLUMNMAJOR | \
D3DXSHADER_PARTIALPRECISION | \
D3DXSHADER_AVOID_FLOW_CONTROL | \
D3DXSHADER_PREFER_FLOW_CONTROL | \
D3D10_SHADER_ENABLE_STRICTNESS | \
D3D10_SHADER_ENABLE_BACKWARDS_COMPATIBILITY | \
D3DXSHADER_SKIPMICROCODE_DEPRECATED | \
D3DXSHADER_SKIPMICROCODEOPTIMIZATION_DEPRECATED | \
D3DXSHADER_ZERO_INIT_LOCAL_VARS | \
D3DXSHADER_MICROCODE_BACKEND_OLD_DEPRECATED | \
D3DXSHADER_MICROCODE_BACKEND_NEW | \
D3DXSHADER_ENABLEVERIFIER | \
D3DXSHADER_DISABLE_ZPASS_COMPARISON_VALIDATION)
#define D3DXSHADER_VALID \
( D3DXSHADER_VALID_ASSEMBLER_FLAGS | \
D3DXSHADER_VALID_COMPILER_FLAGS | \
D3DXSHADER_FORCE_VS_SOFTWARE_NOOPT | \
D3DXSHADER_FORCE_PS_SOFTWARE_NOOPT )
#define D3DXSHADEREX_CPUCODE_NO_INTRINSICS (1 << 0) // Xbox extension
#define D3DXSHADEREX_GENERATE_UPDB (1 << 1) // Xbox extension
#define D3DXSHADEREX_OPTIMIZE_UCODE (1 << 2) // Xbox extension
#define D3DXSHADEREX_NO_MASKED_EXPORTS (1 << 3) // Xbox extension
#define D3DXSHADEREX_DEBUGGABLE_UCODE (1 << 4) // Xbox extension
#define D3DXSHADEREX_AUTOZ (1 << 5) // Xbox extension
#define D3DXSHADEREX_REMOVE_UNUSED_PS_INPUTS (1 << 6) // Xbox extension
#define D3DXSHADEREX_AUTO_VFETCHE (1 << 7) // Xbox extension
#define D3DXSHADEREX_ENABLE_ASSERTIONS (1 << 8) // Xbox extension
#define D3DXSHADEREX_ISOLATE_ASSERTIONS (1 << 9) // Xbox extension
#define D3DXSHADEREX_ENABLE_ASSERTIONS_FOR_PIX (1 << 10) // Xbox extension
#define D3DXSHADEREX_ENABLE_DBGPRINT_FOR_PIX (1 << 11)// Xbox extension
#define D3DXSHADEREX_ENABLE_DBGPRINT_FOR_PIX_DEBUGGER (1 << 12)// Xbox extension
#define D3DXSHADEREX_VALID_COMPILER_FLAGS \
( D3DXSHADEREX_CPUCODE_NO_INTRINSICS | \
D3DXSHADEREX_GENERATE_UPDB | \
D3DXSHADEREX_OPTIMIZE_UCODE | \
D3DXSHADEREX_NO_MASKED_EXPORTS | \
D3DXSHADEREX_DEBUGGABLE_UCODE | \
D3DXSHADEREX_AUTOZ | \
D3DXSHADEREX_REMOVE_UNUSED_PS_INPUTS | \
D3DXSHADEREX_AUTO_VFETCHE | \
D3DXSHADEREX_ENABLE_ASSERTIONS | \
D3DXSHADEREX_ISOLATE_ASSERTIONS | \
D3DXSHADEREX_ENABLE_ASSERTIONS_FOR_PIX | \
D3DXSHADEREX_ENABLE_ASSERTIONS_FOR_PIX_DEBUGGER)
// end internal
#define D3DXDISASSEMBLER_ENABLE_COLOR (1 << 0)
#define D3DXDISASSEMBLER_SHOW_CONSTANT_TABLE_DEFAULTS (1 << 1)
#define D3DXDISASSEMBLER_SHOW_DETAILS (1 << 2)
#define D3DXDISASSEMBLER_HIDE_PATCHED (1 << 3)
#define D3DXDISASSEMBLER_OUTPUT_FORMAT_RTF (1 << 4)
#define D3DXDISASSEMBLER_SHOW_ADDRESSES (1 << 6)
#define D3DXDISASSEMBLER_SHOW_MICROCODE_DEFAULTS (1 << 7)
#define D3DXDISASSEMBLER_SHOW_RUNTIME_DATA (1 << 8)
#define D3DXDISASSEMBLER_SHOW_TIMING_ESTIMATE (1 << 11)
// begin internal
//----------------------------------------------------------------------------
// D3DXAPI:
// --------
// Identifies different API entrypoint sets. Used by D3DXGetTargetDesc.
//----------------------------------------------------------------------------
#define D3DXAPI_ASSEMBLE_SHADER (1 << 0)
#define D3DXAPI_COMPILE_SHADER (1 << 1)
#define D3DXAPI_FILL_TEXTURE (1 << 2)
// end internal
//----------------------------------------------------------------------------
// D3DXHANDLE:
// -----------
// Handle values used to efficiently reference shader and effect parameters.
// On Xbox 360, strings cannot be used as handles (handles are never strings).
//----------------------------------------------------------------------------
typedef UINT_PTR D3DXHANDLE;
typedef D3DXHANDLE *LPD3DXHANDLE;
//----------------------------------------------------------------------------
// D3DXMACRO:
// ----------
// Preprocessor macro definition. The application pass in a NULL-terminated
// array of this structure to various D3DX APIs. This enables the application
// to #define tokens at runtime, before the file is parsed.
//----------------------------------------------------------------------------
typedef struct _D3DXMACRO
{
LPCSTR Name;
LPCSTR Definition;
} D3DXMACRO, *LPD3DXMACRO;
//----------------------------------------------------------------------------
// D3DXSEMANTIC:
//----------------------------------------------------------------------------
typedef struct _D3DXSEMANTIC
{
UINT Usage;
UINT UsageIndex;
} D3DXSEMANTIC, *LPD3DXSEMANTIC;
// begin internal
//----------------------------------------------------------------------------
// D3DXTARGET_DESC:
//----------------------------------------------------------------------------
typedef struct _D3DXTARGET_DESC
{
LPCSTR Name;
DWORD Version;
DWORD API;
} D3DXTARGET_DESC, *LPD3DXTARGET_DESC;
// end internal
//----------------------------------------------------------------------------
// D3DXFRAGMENT_DESC:
//----------------------------------------------------------------------------
typedef struct _D3DXFRAGMENT_DESC
{
LPCSTR Name;
DWORD Target;
} D3DXFRAGMENT_DESC, *LPD3DXFRAGMENT_DESC;
//----------------------------------------------------------------------------
// D3DXREGISTER_SET:
//----------------------------------------------------------------------------
typedef enum _D3DXREGISTER_SET
{
D3DXRS_BOOL,
D3DXRS_INT4,
D3DXRS_FLOAT4,
D3DXRS_SAMPLER,
// force 32-bit size enum
D3DXRS_FORCE_DWORD = 0x7fffffff
} D3DXREGISTER_SET, *LPD3DXREGISTER_SET;
//----------------------------------------------------------------------------
// D3DXPARAMETER_CLASS:
//----------------------------------------------------------------------------
typedef enum _D3DXPARAMETER_CLASS
{
D3DXPC_SCALAR,
D3DXPC_VECTOR,
D3DXPC_MATRIX_ROWS,
D3DXPC_MATRIX_COLUMNS,
D3DXPC_OBJECT,
D3DXPC_STRUCT,
// force 32-bit size enum
D3DXPC_FORCE_DWORD = 0x7fffffff
} D3DXPARAMETER_CLASS, *LPD3DXPARAMETER_CLASS;
//----------------------------------------------------------------------------
// D3DXPARAMETER_TYPE:
//----------------------------------------------------------------------------
typedef 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,
// force 32-bit size enum
D3DXPT_FORCE_DWORD = 0x7fffffff
} D3DXPARAMETER_TYPE, *LPD3DXPARAMETER_TYPE;
//----------------------------------------------------------------------------
// D3DXCONSTANTTABLE_DESC:
//----------------------------------------------------------------------------
typedef struct _D3DXCONSTANTTABLE_DESC
{
LPCSTR Creator; // Creator string
DWORD Version; // Shader version
UINT Constants; // Number of constants
} D3DXCONSTANTTABLE_DESC, *LPD3DXCONSTANTTABLE_DESC;
//----------------------------------------------------------------------------
// D3DXCONSTANT_DESC:
//----------------------------------------------------------------------------
typedef struct _D3DXCONSTANT_DESC
{
LPCSTR Name; // Constant name
D3DXREGISTER_SET RegisterSet; // Register set
UINT RegisterIndex; // Register index
UINT RegisterCount; // Number of registers occupied
D3DXPARAMETER_CLASS Class; // Class
D3DXPARAMETER_TYPE Type; // Component type
UINT Rows; // Number of rows
UINT Columns; // Number of columns
UINT Elements; // Number of array elements
UINT StructMembers; // Number of structure member sub-parameters
UINT Bytes; // Data size, in bytes
LPCVOID DefaultValue; // Pointer to default value
} D3DXCONSTANT_DESC, *LPD3DXCONSTANT_DESC;
//----------------------------------------------------------------------------
// ID3DXConstantTable:
//----------------------------------------------------------------------------
// {9DCA3190-38B9-4fc3-92E3-39C6DDFB358B}
DEFINE_GUID( IID_ID3DXConstantTable,
0x9dca3190, 0x38b9, 0x4fc3, 0x92, 0xe3, 0x39, 0xc6, 0xdd, 0xfb, 0x35, 0x8b);
#undef INTERFACE
#define INTERFACE ID3DXConstantTable
DECLARE_INTERFACE_(ID3DXConstantTable, ID3DXBuffer)
{
// IUnknown
STDMETHOD(QueryInterface)(THIS_ REFIID iid, __deref_out LPVOID *ppv) PURE;
STDMETHOD_(ULONG, AddRef)(THIS) PURE;
STDMETHOD_(ULONG, Release)(THIS) PURE;
// ID3DXBuffer
STDMETHOD_(LPVOID, GetBufferPointer)(THIS) PURE;
STDMETHOD_(DWORD, GetBufferSize)(THIS) PURE;
// Descs
STDMETHOD(GetDesc)(THIS_ __out D3DXCONSTANTTABLE_DESC *pDesc) PURE;
STDMETHOD(GetConstantDesc)(THIS_ __in D3DXHANDLE hConstant, __out_ecount_part(*pCount, *pCount) D3DXCONSTANT_DESC *pConstantDesc, __out UINT *pCount) PURE;
STDMETHOD_(UINT, GetSamplerIndex)(THIS_ __in D3DXHANDLE hConstant) PURE;
// Handle operations
STDMETHOD_(__out D3DXHANDLE, GetConstant)(THIS_ __in D3DXHANDLE hConstant, UINT Index) PURE;
STDMETHOD_(__out D3DXHANDLE, GetConstantByName)(THIS_ __in D3DXHANDLE hConstant, __in_z LPCSTR pName) PURE;
STDMETHOD_(__out D3DXHANDLE, GetConstantElement)(THIS_ __in D3DXHANDLE hConstant, UINT Index) PURE;
// Set Constants
STDMETHOD(SetDefaults)(THIS_ __in LPDIRECT3DDEVICE9 pDevice) PURE;
STDMETHOD(SetValue)(THIS_ __in LPDIRECT3DDEVICE9 pDevice, __in D3DXHANDLE hConstant, __in_bcount(Bytes) LPCVOID pData, UINT Bytes) PURE;
STDMETHOD(SetBool)(THIS_ __in LPDIRECT3DDEVICE9 pDevice, __in D3DXHANDLE hConstant, BOOL b) PURE;
STDMETHOD(SetBoolArray)(THIS_ __in LPDIRECT3DDEVICE9 pDevice, __in D3DXHANDLE hConstant, __in_ecount(Count) CONST BOOL* pb, UINT Count) PURE;
STDMETHOD(SetInt)(THIS_ __in LPDIRECT3DDEVICE9 pDevice, __in D3DXHANDLE hConstant, INT n) PURE;
STDMETHOD(SetIntArray)(THIS_ __in LPDIRECT3DDEVICE9 pDevice, __in D3DXHANDLE hConstant, __in_ecount(Count) CONST INT* pn, UINT Count) PURE;
STDMETHOD(SetFloat)(THIS_ __in LPDIRECT3DDEVICE9 pDevice, __in D3DXHANDLE hConstant, FLOAT f) PURE;
STDMETHOD(SetFloatArray)(THIS_ __in LPDIRECT3DDEVICE9 pDevice, __in D3DXHANDLE hConstant, __in_ecount(Count) CONST FLOAT* pf, UINT Count) PURE;
STDMETHOD(SetVector)(THIS_ __in LPDIRECT3DDEVICE9 pDevice, __in D3DXHANDLE hConstant, __in CONST D3DXVECTOR4* pVector) PURE;
STDMETHOD(SetVectorArray)(THIS_ __in LPDIRECT3DDEVICE9 pDevice, __in D3DXHANDLE hConstant, __in_ecount(Count) CONST D3DXVECTOR4* pVector, UINT Count) PURE;
STDMETHOD(SetMatrix)(THIS_ __in LPDIRECT3DDEVICE9 pDevice, __in D3DXHANDLE hConstant, __in CONST D3DXMATRIX* pMatrix) PURE;
STDMETHOD(SetMatrixArray)(THIS_ __in LPDIRECT3DDEVICE9 pDevice, __in D3DXHANDLE hConstant, __in_ecount(Count) CONST D3DXMATRIX* pMatrix, UINT Count) PURE;
STDMETHOD(SetMatrixPointerArray)(THIS_ __in LPDIRECT3DDEVICE9 pDevice, __in D3DXHANDLE hConstant, __in_ecount(Count) CONST D3DXMATRIX** ppMatrix, UINT Count) PURE;
STDMETHOD(SetMatrixTranspose)(THIS_ __in LPDIRECT3DDEVICE9 pDevice, __in D3DXHANDLE hConstant, __in CONST D3DXMATRIX* pMatrix) PURE;
STDMETHOD(SetMatrixTransposeArray)(THIS_ __in LPDIRECT3DDEVICE9 pDevice, __in D3DXHANDLE hConstant, __in_ecount(Count) CONST D3DXMATRIX* pMatrix, UINT Count) PURE;
STDMETHOD(SetMatrixTransposePointerArray)(THIS_ __in LPDIRECT3DDEVICE9 pDevice, __in D3DXHANDLE hConstant, __in_ecount(Count) CONST D3DXMATRIX** ppMatrix, UINT Count) PURE;
};
typedef interface ID3DXConstantTable ID3DXConstantTable;
typedef interface ID3DXConstantTable *LPD3DXCONSTANTTABLE;
//----------------------------------------------------------------------------
// ID3DXFragmentLinker
//----------------------------------------------------------------------------
#undef INTERFACE
#define INTERFACE ID3DXFragmentLinker
// {D59D3777-C973-4a3c-B4B0-2A62CD3D8B40}
DEFINE_GUID(IID_ID3DXFragmentLinker,
0xd59d3777, 0xc973, 0x4a3c, 0xb4, 0xb0, 0x2a, 0x62, 0xcd, 0x3d, 0x8b, 0x40);
DECLARE_INTERFACE_(ID3DXFragmentLinker, IUnknown)
{
// IUnknown
STDMETHOD(QueryInterface)(THIS_ REFIID iid, __deref_out LPVOID *ppv) PURE;
STDMETHOD_(ULONG, AddRef)(THIS) PURE;
STDMETHOD_(ULONG, Release)(THIS) PURE;
// ID3DXFragmentLinker
// fragment access and information retrieval functions
STDMETHOD(GetDevice)(THIS_ __deref_out LPDIRECT3DDEVICE9* ppDevice) PURE;
STDMETHOD_(UINT, GetNumberOfFragments)(THIS) PURE;
STDMETHOD_(__out D3DXHANDLE, GetFragmentHandleByIndex)(THIS_ UINT Index) PURE;
STDMETHOD_(__out D3DXHANDLE, GetFragmentHandleByName)(THIS_ __in_z LPCSTR Name) PURE;
STDMETHOD(GetFragmentDesc)(THIS_ __in D3DXHANDLE Name, __out LPD3DXFRAGMENT_DESC FragDesc) PURE;
// add the fragments in the buffer to the linker
STDMETHOD(AddFragments)(THIS_ __in CONST DWORD *Fragments) PURE;
// Create a buffer containing the fragments. Suitable for saving to disk
STDMETHOD(GetAllFragments)(THIS_ __deref_out LPD3DXBUFFER *ppBuffer) PURE;
STDMETHOD(GetFragment)(THIS_ __in D3DXHANDLE Name, __deref_out LPD3DXBUFFER *ppBuffer) PURE;
STDMETHOD(LinkShader)(THIS_ __in_z LPCSTR pProfile, DWORD Flags, __in_ecount(cFragments) CONST D3DXHANDLE *rgFragmentHandles, UINT cFragments, __deref_out LPD3DXBUFFER *ppBuffer, __deref_opt_out LPD3DXBUFFER *ppErrorMsgs) PURE;
STDMETHOD(LinkVertexShader)(THIS_ __in_z LPCSTR pProfile, DWORD Flags, __in_ecount(cFragments) CONST D3DXHANDLE *rgFragmentHandles, UINT cFragments, __deref_out LPDIRECT3DVERTEXSHADER9 *ppVShader, __deref_opt_out LPD3DXBUFFER *ppErrorMsgs) PURE;
STDMETHOD(LinkPixelShader)(THIS_ __in_z LPCSTR pProfile, DWORD Flags, __in_ecount(cFragments) CONST D3DXHANDLE *rgFragmentHandles, UINT cFragments, __deref_out LPDIRECT3DPIXELSHADER9 *ppPShader, __deref_opt_out LPD3DXBUFFER *ppErrorMsgs) PURE;
STDMETHOD(ClearCache)(THIS) PURE;
};
//----------------------------------------------------------------------------
// D3DXINCLUDE_TYPE:
//----------------------------------------------------------------------------
typedef enum _D3DXINCLUDE_TYPE
{
D3DXINC_LOCAL,
D3DXINC_SYSTEM,
// force 32-bit size enum
D3DXINC_FORCE_DWORD = 0x7fffffff
} D3DXINCLUDE_TYPE, *LPD3DXINCLUDE_TYPE;
//----------------------------------------------------------------------------
// ID3DXInclude:
// -------------
// This interface is intended to be implemented by the application, and can
// be used by various D3DX APIs. This enables application-specific handling
// of #include directives in source files.
//
// Open()
// Opens an include file. If successful, it should fill in ppData and
// pBytes. The data pointer returned must remain valid until Close is
// subsequently called.
//
// Xbox 360 Extension: To aid source level debugging, Open() may optionally
// return the full path to the found include file, by storing it in the
// buffer pointed to by pFullPath. The full path may be up to cbFullPath
// characters long, including the terminating '\0' character.
//
// Close()
// Closes an include file. If Open was successful, Close is guaranteed
// to be called before the API using this interface returns.
//----------------------------------------------------------------------------
typedef interface ID3DXInclude ID3DXInclude;
typedef interface ID3DXInclude *LPD3DXINCLUDE;
#undef INTERFACE
#define INTERFACE ID3DXInclude
DECLARE_INTERFACE(ID3DXInclude)
{
STDMETHOD(Open)(THIS_ D3DXINCLUDE_TYPE IncludeType, __in_z LPCSTR pFileName, __in LPCVOID pParentData,
__deref_out_bcount(*pBytes) LPCVOID *ppData, __out UINT *pBytes,
/* OUT */ __out_bcount_z(cbFullPath) LPSTR pFullPath, DWORD cbFullPath) PURE;
STDMETHOD(Close)(THIS_ __in LPCVOID pData) PURE;
};
//----------------------------------------------------------------------------
// D3DXSHADER_COMPILE_PARAMETERS:
//----------------------------------------------------------------------------
typedef struct _D3DXSHADER_COMPILE_PARAMETERSA
{
// Fields use by both assembler and compiler:
DWORD Flags; // D3DXSHADEREX_* flags
DWORD UPDBTimestamp; // UPDB Timestamp for this compile.
LPCSTR UPDBPath; // UPDB path for this compile.
LPD3DXBUFFER pUPDBBuffer; // OUT parameter, the resulting UPDB data, caller is responsible for releasing.
DWORD TempRegisterLimit; // Maximum number of general registers available to the generated microcode.
LPVOID pUPDBB; // Must be NULL.
// Compiler-specific fields:
LPCSTR CpuFunctionName; // Name to use for generated CPU shader function (NULL to use HLSL entry-point)
BOOL bXbox360ExtensionUsed; // Filled in by CParse and/or the new back end. Used to avoid calling the old back end
DWORD PixelShaderSamplerRegisterBase; // Starting sampler register available to pixel shaders.
DWORD PixelShaderSamplerRegisterCount; // Number of sampler registers available to pixel shaders.
DWORD VertexShaderSamplerRegisterBase; // Starting sampler register available to vertex shaders.
DWORD VertexShaderSamplerRegisterCount; // Number of sampler registers available to vertex shaders.
DWORD PixelShaderInstructionCount_DEPRECATED; // Number of instruction slots available to pixel shaders.
DWORD VertexShaderInstructionCount_DEPRECATED; // Number of instruction slots available to vertex shaders.
WORD PixAssertAddressReg;
WORD PixDebugPrintAddressReg;
WORD PixDebugPrintSamplerReg;
WORD PixDebugPrintEnableReg;
WORD PixDiagnosticIndexReg;
} D3DXSHADER_COMPILE_PARAMETERSA, *LPD3DXSHADER_COMPILE_PARAMETERSA;
typedef struct _D3DXSHADER_COMPILE_PARAMETERSW
{
// Fields use by both assembler and compiler:
DWORD Flags; // D3DXSHADEREX_* flags
DWORD UPDBTimestamp; // UPDB Timestamp for this compile.
LPWSTR UPDBPath; // UPDB path for this compile.
LPD3DXBUFFER pUPDBBuffer; // OUT parameter, the resulting UPDB data, caller is responsible for releasing.
DWORD TempRegisterLimit; // Maximum number of general registers available to the generated microcode.
LPVOID pUPDBB; // Used internally. Must be NULL.
// Compiler-specific fields:
LPCSTR CpuFunctionName; // Name to use for generated CPU shader function (NULL to use HLSL entry-point)
BOOL bXbox360ExtensionUsed; // Filled in by CParse and/or the new back end. Used to avoid calling the old back end
DWORD PixelShaderSamplerRegisterBase; // Starting sampler register available to pixel shaders.
DWORD PixelShaderSamplerRegisterCount; // Number of sampler registers available to pixel shaders.
DWORD VertexShaderSamplerRegisterBase; // Starting sampler register available to vertex shaders.
DWORD VertexShaderSamplerRegisterCount; // Number of sampler registers available to vertex shaders.
DWORD PixelShaderInstructionCount_DEPRECATED; // Number of instruction slots available to pixel shaders.
DWORD VertexShaderInstructionCount_DEPRECATED; // Number of instruction slots available to vertex shaders.
WORD PixAssertAddressReg;
WORD PixDebugPrintAddressReg;
WORD PixDebugPrintSamplerReg;
WORD PixDebugPrintEnableReg;
WORD PixDiagnosticIndexReg;
} D3DXSHADER_COMPILE_PARAMETERSW, *LPD3DXSHADER_COMPILE_PARAMETERSW;
#ifdef UNICODE
#define D3DXSHADER_COMPILE_PARAMETERS D3DXSHADER_COMPILE_PARAMETERSW
#define LPD3DXSHADER_COMPILE_PARAMETERS LPD3DXSHADER_COMPILE_PARAMETERSW
#else
#define D3DXSHADER_COMPILE_PARAMETERS D3DXSHADER_COMPILE_PARAMETERSA
#define LPD3DXSHADER_COMPILE_PARAMETERS LPD3DXSHADER_COMPILE_PARAMETERSA
#endif
//////////////////////////////////////////////////////////////////////////////
// APIs //////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////
#ifdef __cplusplus
extern "C" {
#endif //__cplusplus
//----------------------------------------------------------------------------
// D3DXAssembleShader/Ex:
// -------------------
// Assembles a shader.
//
// Parameters:
// pSrcFile
// Source file name
// hSrcModule
// Module handle. if NULL, current module will be used
// pSrcResource
// Resource name in module
// pSrcData
// Pointer to source code
// SrcDataLen
// Size of source code, in bytes
// pDefines
// Optional NULL-terminated array of preprocessor macro definitions.
// pInclude
// Optional interface pointer to use for handling #include directives.
// If this parameter is NULL, #includes will be honored when assembling
// from file, and will error when assembling from resource or memory.
// Flags
// See D3DXSHADER_xxx flags
// ppShader
// Returns a buffer containing the created shader. This buffer contains
// the assembled shader code, as well as any embedded debug info.
// ppErrorMsgs
// Returns a buffer containing a listing of errors and warnings that were
// encountered during assembly. If you are running in a debugger,
// these are the same messages you will see in your debug output.
//----------------------------------------------------------------------------
HRESULT WINAPI
D3DXAssembleShaderFromFileA(
__in_z LPCSTR pSrcFile,
__in_opt CONST D3DXMACRO* pDefines,
__in_opt LPD3DXINCLUDE pInclude,
DWORD Flags,
__deref_out LPD3DXBUFFER* ppShader,
__deref_opt_out LPD3DXBUFFER* ppErrorMsgs);
HRESULT WINAPI
D3DXAssembleShaderFromFileW(
__in_z LPCWSTR pSrcFile,
__in_opt CONST D3DXMACRO* pDefines,
__in_opt LPD3DXINCLUDE pInclude,
DWORD Flags,
__deref_out LPD3DXBUFFER* ppShader,
__deref_opt_out LPD3DXBUFFER* ppErrorMsgs);
#ifdef UNICODE
#define D3DXAssembleShaderFromFile D3DXAssembleShaderFromFileW
#else
#define D3DXAssembleShaderFromFile D3DXAssembleShaderFromFileA
#endif
HRESULT WINAPI
D3DXAssembleShader(
__in_ecount_z(SrcDataLen) LPCSTR pSrcData,
UINT SrcDataLen,
__in_opt CONST D3DXMACRO* pDefines,
__in_opt LPD3DXINCLUDE pInclude,
DWORD Flags,
__deref_out LPD3DXBUFFER* ppShader,
__deref_opt_out LPD3DXBUFFER* ppErrorMsgs);
// Ex version:
HRESULT WINAPI
D3DXAssembleShaderFromFileExA(
__in_z LPCSTR pSrcFile,
__in_opt CONST D3DXMACRO* pDefines,
__in_opt LPD3DXINCLUDE pInclude,
DWORD Flags,
__deref_out LPD3DXBUFFER* ppShader,
__deref_opt_out LPD3DXBUFFER* ppErrorMsgs,
__in LPD3DXSHADER_COMPILE_PARAMETERSA pParameters);
HRESULT WINAPI
D3DXAssembleShaderFromFileExW(
__in_z LPCWSTR pSrcFile,
__in_opt CONST D3DXMACRO* pDefines,
__in_opt LPD3DXINCLUDE pInclude,
DWORD Flags,
__deref_out LPD3DXBUFFER* ppShader,
__deref_opt_out LPD3DXBUFFER* ppErrorMsgs,
__in LPD3DXSHADER_COMPILE_PARAMETERSW pParameters);
#ifdef UNICODE
#define D3DXAssembleShaderFromFileEx D3DXAssembleShaderFromFileExW
#else
#define D3DXAssembleShaderFromFileEx D3DXAssembleShaderFromFileExA
#endif
HRESULT WINAPI
D3DXAssembleShaderExA(
__in_ecount_z(SrcDataLen) LPCSTR pSrcData,
UINT SrcDataLen,
__in_opt CONST D3DXMACRO* pDefines,
__in_opt LPD3DXINCLUDE pInclude,
DWORD Flags,
__deref_out LPD3DXBUFFER* ppShader,
__deref_opt_out LPD3DXBUFFER* ppErrorMsgs,
__in LPD3DXSHADER_COMPILE_PARAMETERSA pParameters);
HRESULT WINAPI
D3DXAssembleShaderExW(
__in_ecount_z(SrcDataLen) LPCSTR pSrcData,
UINT SrcDataLen,
__in_opt CONST D3DXMACRO* pDefines,
__in_opt LPD3DXINCLUDE pInclude,
DWORD Flags,
__deref_out LPD3DXBUFFER* ppShader,
__deref_opt_out LPD3DXBUFFER* ppErrorMsgs,
__in LPD3DXSHADER_COMPILE_PARAMETERSW pParameters);
#ifdef UNICODE
#define D3DXAssembleShaderEx D3DXAssembleShaderExW
#else
#define D3DXAssembleShaderEx D3DXAssembleShaderExA
#endif
//----------------------------------------------------------------------------
// D3DXCompileShader/Ex:
// ------------------
// Compiles a shader.
//
// Parameters:
// pSrcFile
// Source file name.
// hSrcModule
// Module handle. if NULL, current module will be used.
// pSrcResource
// Resource name in module.
// pSrcData
// Pointer to source code.
// SrcDataLen
// Size of source code, in bytes.
// pDefines
// Optional NULL-terminated array of preprocessor macro definitions.
// pInclude
// Optional interface pointer to use for handling #include directives.
// If this parameter is NULL, #includes will be honored when compiling
// from file, and will error when compiling from resource or memory.
// pFunctionName
// Name of the entrypoint function where execution should begin.
// pProfile
// Instruction set to be used when generating code. Currently supported
// profiles are "vs_3_0", "ps_3_0", and "tx_1_0". For backwards compatibility
// any profile starting with "vs" will automatically be promoted to "vs_3_0", and
// any profile starting with "ps" will automatically be promoted to "ps_3_0".
//
//
// Flags
// See D3DXSHADER_xxx flags.
// ppShader
// Returns a buffer containing the created shader. This buffer contains
// the compiled shader code, as well as any embedded debug and symbol
// table info. (See D3DXGetShaderConstantTable)
// ppErrorMsgs
// Returns a buffer containing a listing of errors and warnings that were
// encountered during the compile. If you are running in a debugger,
// these are the same messages you will see in your debug output.
// ppConstantTable
// Returns a ID3DXConstantTable object which can be used to set
// shader constants to the device. Alternatively, an application can
// parse the D3DXSHADER_CONSTANTTABLE block embedded as a comment within
// the shader.
//----------------------------------------------------------------------------
HRESULT WINAPI
D3DXCompileShaderFromFileA(
__in_z LPCSTR pSrcFile,
__in_opt CONST D3DXMACRO* pDefines,
__in_opt LPD3DXINCLUDE pInclude,
__in_z LPCSTR pFunctionName,
__in_z LPCSTR pProfile,
DWORD Flags,
__deref_out LPD3DXBUFFER* ppShader,
__deref_opt_out LPD3DXBUFFER* ppErrorMsgs,
__deref_opt_out LPD3DXCONSTANTTABLE* ppConstantTable);
HRESULT WINAPI
D3DXCompileShaderFromFileW(
__in_z LPCWSTR pSrcFile,
__in_opt CONST D3DXMACRO* pDefines,
__in_opt LPD3DXINCLUDE pInclude,
__in_z LPCSTR pFunctionName,
__in_z LPCSTR pProfile,
DWORD Flags,
__deref_out LPD3DXBUFFER* ppShader,
__deref_opt_out LPD3DXBUFFER* ppErrorMsgs,
__deref_opt_out LPD3DXCONSTANTTABLE* ppConstantTable);
#ifdef UNICODE
#define D3DXCompileShaderFromFile D3DXCompileShaderFromFileW
#else
#define D3DXCompileShaderFromFile D3DXCompileShaderFromFileA
#endif
HRESULT WINAPI
D3DXCompileShader(
__in_ecount_z(SrcDataLen) LPCSTR pSrcData,
UINT SrcDataLen,
__in_opt CONST D3DXMACRO* pDefines,
__in_opt LPD3DXINCLUDE pInclude,
__in_z LPCSTR pFunctionName,
__in_z LPCSTR pProfile,
DWORD Flags,
__deref_out LPD3DXBUFFER* ppShader,
__deref_opt_out LPD3DXBUFFER* ppErrorMsgs,
__deref_opt_out LPD3DXCONSTANTTABLE* ppConstantTable);
HRESULT WINAPI
D3DXCompileShaderFromFileExA(
__in_z LPCSTR pSrcFile,
__in_opt CONST D3DXMACRO* pDefines,
__in_opt LPD3DXINCLUDE pInclude,
__in_z LPCSTR pFunctionName,
__in_z LPCSTR pProfile,
DWORD Flags,
__deref_out LPD3DXBUFFER* ppShader,
__deref_opt_out LPD3DXBUFFER* ppErrorMsgs,
__deref_opt_out LPD3DXCONSTANTTABLE* ppConstantTable,
__in LPD3DXSHADER_COMPILE_PARAMETERSA pParameters);
HRESULT WINAPI
D3DXCompileShaderFromFileExW(
__in_z LPCWSTR pSrcFile,
__in_opt CONST D3DXMACRO* pDefines,
__in_opt LPD3DXINCLUDE pInclude,
__in_z LPCSTR pFunctionName,
__in_z LPCSTR pProfile,
DWORD Flags,
__deref_out LPD3DXBUFFER* ppShader,
__deref_opt_out LPD3DXBUFFER* ppErrorMsgs,
__deref_opt_out LPD3DXCONSTANTTABLE* ppConstantTable,
__in LPD3DXSHADER_COMPILE_PARAMETERSW pParameters);
#ifdef UNICODE
#define D3DXCompileShaderFromFileEx D3DXCompileShaderFromFileExW
#else
#define D3DXCompileShaderFromFileEx D3DXCompileShaderFromFileExA
#endif
HRESULT WINAPI
D3DXCompileShaderExA(
__in_ecount_z(SrcDataLen) LPCSTR pSrcData,
UINT SrcDataLen,
__in_opt CONST D3DXMACRO* pDefines,
__in_opt LPD3DXINCLUDE pInclude,
__in_z LPCSTR pFunctionName,
__in_z LPCSTR pProfile,
DWORD Flags,
__deref_out LPD3DXBUFFER* ppShader,
__deref_opt_out LPD3DXBUFFER* ppErrorMsgs,
__deref_opt_out LPD3DXCONSTANTTABLE* ppConstantTable,
__in LPD3DXSHADER_COMPILE_PARAMETERSA pParameters);
HRESULT WINAPI
D3DXCompileShaderExW(
__in_ecount_z(SrcDataLen) LPCSTR pSrcData,
UINT SrcDataLen,
__in_opt CONST D3DXMACRO* pDefines,
__in_opt LPD3DXINCLUDE pInclude,
__in_z LPCSTR pFunctionName,
__in_z LPCSTR pProfile,
DWORD Flags,
__deref_out LPD3DXBUFFER* ppShader,
__deref_opt_out LPD3DXBUFFER* ppErrorMsgs,
__deref_opt_out LPD3DXCONSTANTTABLE* ppConstantTable,
__in LPD3DXSHADER_COMPILE_PARAMETERSW pParameters);
#ifdef UNICODE
#define D3DXCompileShaderEx D3DXCompileShaderExW
#else
#define D3DXCompileShaderEx D3DXCompileShaderExA
#endif
//----------------------------------------------------------------------------
// D3DXDisassembleShader:
// ----------------------
// Takes a binary shader, and returns a buffer containing text assembly.
//
// Parameters:
// pShader
// Pointer to the shader byte code.
// ShaderSizeInBytes
// Size of the shader byte code in bytes.
// EnableColorCode
// Emit HTML tags for color coding the output?
// pComments
// Pointer to a comment string to include at the top of the shader.
// ppDisassembly
// Returns a buffer containing the disassembled shader.
//----------------------------------------------------------------------------
HRESULT WINAPI
D3DXDisassembleShader(
__in CONST DWORD* pShader,
BOOL EnableColorCode,
__in_z_opt LPCSTR pComments,
__deref_out LPD3DXBUFFER* ppDisassembly);
//----------------------------------------------------------------------------
// D3DXDisassembleShaderEx:
// ----------------------
// Takes a binary shader, and returns a buffer containing text assembly.
//
// Parameters:
// pShader
// Pointer to the shader byte code.
// ShaderSizeInBytes
// Size of the shader byte code in bytes.
// Flags
// combination of D3DXDISASSEMBLER flags controlling output format.
// pComments
// Pointer to a comment string to include at the top of the shader.
// ppDisassembly
// Returns a buffer containing the disassembled shader.
//----------------------------------------------------------------------------
HRESULT WINAPI
D3DXDisassembleShaderEx(
__in CONST DWORD* pShader,
DWORD Flags,
__in_z_opt LPCSTR pComments,
__deref_out LPD3DXBUFFER* ppDisassembly);
//----------------------------------------------------------------------------
// D3DXGetPixelShaderProfile/D3DXGetVertexShaderProfile:
// -----------------------------------------------------
// Returns the name of the HLSL profile best suited to a given device.
//
// Parameters:
// pDevice
// Pointer to the device in question
//----------------------------------------------------------------------------
LPCSTR WINAPI
D3DXGetPixelShaderProfile(
__in LPDIRECT3DDEVICE9 pDevice);
LPCSTR WINAPI
D3DXGetVertexShaderProfile(
__in LPDIRECT3DDEVICE9 pDevice);
//----------------------------------------------------------------------------
// D3DXFindShaderComment:
// ----------------------
// Searches through a shader for a particular comment, denoted by a FourCC in
// the first DWORD of the comment. If the comment is not found, and no other
// error has occurred, S_FALSE is returned.
//
// Parameters:
// pFunction
// Pointer to the function DWORD stream
// FourCC
// FourCC used to identify the desired comment block.
// ppData
// Returns a pointer to the comment data (not including comment token
// and FourCC). Can be NULL.
// pSizeInBytes
// Returns the size of the comment data in bytes. Can be NULL.
//----------------------------------------------------------------------------
HRESULT WINAPI
D3DXFindShaderComment(
__in CONST DWORD* pFunction,
DWORD FourCC,
__deref_opt_out LPCVOID* ppData,
__out_opt UINT* pSizeInBytes);
//----------------------------------------------------------------------------
// D3DXGetShaderSize:
// ------------------
// Returns the size of the shader byte-code, in bytes.
//
// Parameters:
// pFunction
// Pointer to the function DWORD stream
//----------------------------------------------------------------------------
UINT WINAPI
D3DXGetShaderSize(
__in CONST DWORD* pFunction);
//----------------------------------------------------------------------------
// D3DXGetShaderVersion:
// -----------------------
// Returns the shader version of a given shader. Returns zero if the shader
// function is NULL.
//
// Parameters:
// pFunction
// Pointer to the function DWORD stream
//----------------------------------------------------------------------------
DWORD WINAPI
D3DXGetShaderVersion(
__in CONST DWORD* pFunction);
//----------------------------------------------------------------------------
// D3DXGetShaderSemantics:
// -----------------------
// Gets semantics for all input elements referenced inside a given shader.
//
// Parameters:
// pFunction
// Pointer to the function DWORD stream
// pSemantics
// Pointer to an array of D3DXSEMANTIC structures. The function will
// fill this array with the semantics for each input element referenced
// inside the shader. This array is assumed to contain at least
// MAXD3DDECLLENGTH elements.
// pCount
// Returns the number of elements referenced by the shader
//----------------------------------------------------------------------------
HRESULT WINAPI
D3DXGetShaderInputSemantics(
__in CONST DWORD* pFunction,
__out_opt D3DXSEMANTIC* pSemantics,
__out_opt UINT* pCount);
HRESULT WINAPI
D3DXGetShaderOutputSemantics(
__in CONST DWORD* pFunction,
__out_opt D3DXSEMANTIC* pSemantics,
__out_opt UINT* pCount);
//----------------------------------------------------------------------------
// D3DXGetShaderSamplers:
// ----------------------
// Gets semantics for all input elements referenced inside a given shader.
//
// pFunction
// Pointer to the function DWORD stream
// pSamplers
// Pointer to an array of LPCSTRs. The function will fill this array
// with pointers to the sampler names contained within pFunction, for
// each sampler referenced inside the shader. This array is assumed to
// contain at least 32 elements.
// pCount
// Returns the number of samplers referenced by the shader
//----------------------------------------------------------------------------
HRESULT WINAPI
D3DXGetShaderSamplers(
__in CONST DWORD* pFunction,
__out_ecount_part(32, *pCount) LPCSTR* pSamplers,
__out_opt UINT* pCount);
//----------------------------------------------------------------------------
// D3DXGetShaderConstantTable:
// ---------------------------
// Gets shader constant table embedded inside shader. A constant table is
// generated by D3DXAssembleShader and D3DXCompileShader, and is embedded in
// the body of the shader.
//
// Parameters:
// pFunction
// Pointer to the function DWORD stream
// ppConstantTable
// Returns a ID3DXConstantTable object which can be used to set
// shader constants to the device. Alternatively, an application can
// parse the D3DXSHADER_CONSTANTTABLE block embedded as a comment within
// the shader.
//----------------------------------------------------------------------------
HRESULT WINAPI
D3DXGetShaderConstantTable(
__in CONST DWORD* pFunction,
__deref_out LPD3DXCONSTANTTABLE* ppConstantTable);
//----------------------------------------------------------------------------
// D3DXGatherFragments:
// -------------------
// Assembles shader fragments into a buffer to be passed to a fragment linker.
// will generate shader fragments for all fragments in the file
//
// Parameters:
// pSrcFile
// Source file name
// hSrcModule
// Module handle. if NULL, current module will be used
// pSrcResource
// Resource name in module
// pSrcData
// Pointer to source code
// SrcDataLen
// Size of source code, in bytes
// pDefines
// Optional NULL-terminated array of preprocessor macro definitions.
// pInclude
// Optional interface pointer to use for handling #include directives.
// If this parameter is NULL, #includes will be honored when assembling
// from file, and will error when assembling from resource or memory.
// Flags
// See D3DXSHADER_xxx flags
// ppShader
// Returns a buffer containing the created shader fragments. This buffer contains
// the assembled shader code, as well as any embedded debug info.
// ppErrorMsgs
// Returns a buffer containing a listing of errors and warnings that were
// encountered during assembly. If you are running in a debugger,
// these are the same messages you will see in your debug output.
//----------------------------------------------------------------------------
HRESULT WINAPI
D3DXGatherFragmentsFromFileA(
__in_z LPCSTR pSrcFile,
__in_opt CONST D3DXMACRO* pDefines,
__in_opt LPD3DXINCLUDE pInclude,
DWORD Flags,
__deref_out LPD3DXBUFFER* ppShader,
__deref_opt_out LPD3DXBUFFER* ppErrorMsgs);
HRESULT WINAPI
D3DXGatherFragmentsFromFileW(
__in_z LPCWSTR pSrcFile,
__in_opt CONST D3DXMACRO* pDefines,
__in_opt LPD3DXINCLUDE pInclude,
DWORD Flags,
__deref_out LPD3DXBUFFER* ppShader,
__deref_opt_out LPD3DXBUFFER* ppErrorMsgs);
#ifdef UNICODE
#define D3DXGatherFragmentsFromFile D3DXGatherFragmentsFromFileW
#else
#define D3DXGatherFragmentsFromFile D3DXGatherFragmentsFromFileA
#endif
HRESULT WINAPI
D3DXGatherFragments(
__in_ecount_z(SrcDataLen) LPCSTR pSrcData,
UINT SrcDataLen,
__in_opt CONST D3DXMACRO* pDefines,
__in_opt LPD3DXINCLUDE pInclude,
DWORD Flags,
__deref_out LPD3DXBUFFER* ppShader,
__deref_opt_out LPD3DXBUFFER* ppErrorMsgs);
typedef ID3DXFragmentLinker *LPD3DXFRAGMENTLINKER;
//----------------------------------------------------------------------------
// D3DXCreateFragmentLinker:
// -------------------------
// Creates a fragment linker with a given cache size. The interface returned
// can be used to link together shader fragments. (both HLSL & ASM fragements)
//
// Parameters:
// pDevice
// Pointer to the device on which to create the shaders
// ShaderCacheSize
// Size of the shader cache
// ppFragmentLinker
// pointer to a memory location to put the created interface pointer
//
//----------------------------------------------------------------------------
HRESULT WINAPI
D3DXCreateFragmentLinker(
__in LPDIRECT3DDEVICE9 pDevice,
UINT ShaderCacheSize,
__deref_out LPD3DXFRAGMENTLINKER* ppFragmentLinker);
//----------------------------------------------------------------------------
// D3DXPreprocessShader:
// ---------------------
// Runs the preprocessor on the specified shader or effect, but does
// not actually compile it. This is useful for evaluating the #includes
// and #defines in a shader and then emitting a reformatted token stream
// for debugging purposes or for generating a self-contained shader.
//
// Parameters:
// pSrcFile
// Source file name
// hSrcModule
// Module handle. if NULL, current module will be used
// pSrcResource
// Resource name in module
// pSrcData
// Pointer to source code
// SrcDataLen
// Size of source code, in bytes
// pDefines
// Optional NULL-terminated array of preprocessor macro definitions.
// pInclude
// Optional interface pointer to use for handling #include directives.
// If this parameter is NULL, #includes will be honored when assembling
// from file, and will error when assembling from resource or memory.
// ppShaderText
// Returns a buffer containing a single large string that represents
// the resulting formatted token stream
// ppErrorMsgs
// Returns a buffer containing a listing of errors and warnings that were
// encountered during assembly. If you are running in a debugger,
// these are the same messages you will see in your debug output.
//----------------------------------------------------------------------------
HRESULT WINAPI
D3DXPreprocessShaderFromFileA(
__in_z LPCSTR pSrcFile,
__in_opt CONST D3DXMACRO* pDefines,
__in_opt LPD3DXINCLUDE pInclude,
__deref_out LPD3DXBUFFER* ppShaderText,
__deref_opt_out LPD3DXBUFFER* ppErrorMsgs);
HRESULT WINAPI
D3DXPreprocessShaderFromFileW(
__in_z LPCWSTR pSrcFile,
__in_opt CONST D3DXMACRO* pDefines,
__in_opt LPD3DXINCLUDE pInclude,
__deref_out LPD3DXBUFFER* ppShaderText,
__deref_opt_out LPD3DXBUFFER* ppErrorMsgs);
#ifdef UNICODE
#define D3DXPreprocessShaderFromFile D3DXPreprocessShaderFromFileW
#else
#define D3DXPreprocessShaderFromFile D3DXPreprocessShaderFromFileA
#endif
#ifndef _XBOX
HRESULT WINAPI
D3DXPreprocessShaderFromResourceA(
__in HMODULE hSrcModule,
__in_z LPCSTR pSrcResource,
__in_opt CONST D3DXMACRO* pDefines,
__in_opt LPD3DXINCLUDE pInclude,
__deref_out LPD3DXBUFFER* ppShaderText,
__deref_opt_out LPD3DXBUFFER* ppErrorMsgs);
HRESULT WINAPI
D3DXPreprocessShaderFromResourceW(
__in HMODULE hSrcModule,
__in_z LPCWSTR pSrcResource,
__in_opt CONST D3DXMACRO* pDefines,
__in_opt LPD3DXINCLUDE pInclude,
__deref_out LPD3DXBUFFER* ppShaderText,
__deref_opt_out LPD3DXBUFFER* ppErrorMsgs);
#ifdef UNICODE
#define D3DXPreprocessShaderFromResource D3DXPreprocessShaderFromResourceW
#else
#define D3DXPreprocessShaderFromResource D3DXPreprocessShaderFromResourceA
#endif
#endif
HRESULT WINAPI
D3DXPreprocessShader(
__in_ecount_z(SrcDataSize) LPCSTR pSrcData,
UINT SrcDataSize,
__in_opt CONST D3DXMACRO* pDefines,
__in_opt LPD3DXINCLUDE pInclude,
__deref_out LPD3DXBUFFER* ppShaderText,
__deref_opt_out LPD3DXBUFFER* ppErrorMsgs);
// begin internal
//----------------------------------------------------------------------------
// D3DXGetTargetDesc:
// ------------------
// Functions to lookup and describe various shader target versions.
//----------------------------------------------------------------------------
HRESULT WINAPI
D3DXGetTargetDescByName(
__in_z LPCSTR pName,
DWORD API,
__out D3DXTARGET_DESC* pTargetDesc);
HRESULT WINAPI
D3DXGetTargetDescByVersion(
DWORD Version,
DWORD API,
__out D3DXTARGET_DESC* pDesc);
// end internal
#ifdef __cplusplus
}
#endif //__cplusplus
//////////////////////////////////////////////////////////////////////////////
// Shader comment block layouts //////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////
//----------------------------------------------------------------------------
// D3DXSHADER_CONSTANTTABLE:
// -------------------------
// Shader constant information; included as an CTAB comment block inside
// shaders. All offsets are BYTE offsets from start of CONSTANTTABLE struct.
// Entries in the table are sorted by Name in ascending order.
//----------------------------------------------------------------------------
typedef struct _D3DXSHADER_CONSTANTTABLE
{
DWORD Size; // sizeof(D3DXSHADER_CONSTANTTABLE)
DWORD Creator; // LPCSTR offset
DWORD Version; // shader version
DWORD Constants; // number of constants
DWORD ConstantInfo; // D3DXSHADER_CONSTANTINFO[Constants] offset
DWORD Flags; // flags shader was compiled with
DWORD Target; // LPCSTR offset
} D3DXSHADER_CONSTANTTABLE, *LPD3DXSHADER_CONSTANTTABLE;
// begin internal
#define CONSTANTINFOFLAG_STATIC 0x1
#define CONSTANTINFOFLAG_USEROFFSET 0x2
#define CONSTANTINFOFLAG_USEROFFSETSHIFT 2
// end internal
typedef struct _D3DXSHADER_CONSTANTINFO
{
DWORD Name; // LPCSTR offset
WORD RegisterSet; // D3DXREGISTER_SET
WORD RegisterIndex; // register number
WORD RegisterCount; // number of registers
WORD Flags; // Fragment linker flags (internal field. this field is also known as Reserved).
DWORD TypeInfo; // D3DXSHADER_TYPEINFO offset
DWORD DefaultValue; // offset of default value
} D3DXSHADER_CONSTANTINFO, *LPD3DXSHADER_CONSTANTINFO;
typedef struct _D3DXSHADER_TYPEINFO
{
WORD Class; // D3DXPARAMETER_CLASS
WORD Type; // D3DXPARAMETER_TYPE
WORD Rows; // number of rows (matrices)
WORD Columns; // number of columns (vectors and matrices)
WORD Elements; // array dimension
WORD StructMembers; // number of struct members
DWORD StructMemberInfo; // D3DXSHADER_STRUCTMEMBERINFO[Members] offset
} D3DXSHADER_TYPEINFO, *LPD3DXSHADER_TYPEINFO;
typedef struct _D3DXSHADER_STRUCTMEMBERINFO
{
DWORD Name; // LPCSTR offset
DWORD TypeInfo; // D3DXSHADER_TYPEINFO offset
} D3DXSHADER_STRUCTMEMBERINFO, *LPD3DXSHADER_STRUCTMEMBERINFO;
// begin internal
//----------------------------------------------------------------------------
// D3DXGetShaderDebugInfo:
// -----------------------
// Gets shader debug info. Debug info is generated D3DXAssembleShader and
// D3DXCompileShader and is embedded the body of the shader.
//
// Parameters:
// pFunction
// Pointer to the function DWORD stream
// ppDebugInfo
// Buffer used to return debug info. For information about the layout
// of this buffer, see definition of D3DXSHADER_DEBUGINFO above.
//----------------------------------------------------------------------------
HRESULT WINAPI
D3DXGetShaderDebugInfo(
__in CONST DWORD* pFunction,
__deref_out LPD3DXBUFFER* ppDebugInfo);
//----------------------------------------------------------------------------
// D3DXSHADER_DEBUGINFO:
// ---------------------
// Shader debug information; included as an DBUG comment block inside shaders.
// All offsets are BYTE offsets from start of DEBUGINFO struct.
//----------------------------------------------------------------------------
typedef struct _D3DXSHADER_DEBUGINFO
{
DWORD Size; // sizeof(D3DXSHADER_DEBUGINFO)
DWORD Creator; // LPCSTR offset
DWORD SourceCode; // LPCSTR offset
DWORD Files; // number of source files
DWORD FileInfo; // D3DXSHADER_FILEINFO[Files] offset
DWORD Instructions; // number of instructions
DWORD InstructionInfo; // D3DXSHADER_INSTRUCTIONINFO[Instructions] offset
DWORD Variables; // number of variables
DWORD VariableInfo; // D3DXSHADER_VARIABLEINFO[Variables] offset
DWORD EntrypointName; // LPCSTR offset
} D3DXSHADER_DEBUGINFO, *LPD3DXSHADER_DEBUGINFO;
typedef struct _D3DXSHADER_FILEINFO
{
DWORD Name; // LPCSTR offset
} D3DXSHADER_FILEINFO, *LPD3DXSHADER_FILEINFO;
typedef struct _D3DXSHADER_INSTRUCTIONINFO
{
WORD Line; // line number
WORD File; // file index
DWORD Offset; // BYTE offset of instruction from start of shader
} D3DXSHADER_INSTRUCTIONINFO, *LPD3DXSHADER_INSTRUCTIONINFO;
typedef struct _D3DXSHADER_VARIABLEINFO
{
DWORD Scope; // LPCSTR scope
DWORD Name; // LPCSTR offset
DWORD TypeInfo; // D3DXSHADER_TYPEINFO offset
DWORD Writes; // number of writes
DWORD WriteInfo; // D3DXSHADER_WRITEINFO[Writes] offset
} D3DXSHADER_VARIABLEINFO, *LPD3DXSHADER_VARIABLEINFO;
typedef struct _D3DXSHADER_WRITEINFO
{
DWORD Instruction; // instruction index
WORD Component[4]; // variable component per output value
} D3DXSHADER_WRITEINFO, *LPD3DXSHADER_WRITEINFO;
// end internal
#endif //__D3DX9SHADER_H__
Reference in New Issue Copy Permalink