Subversion Repositories Games.Chess Giants

//////////////////////////////////////////////////////////////////////////////

//

//  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))

//----------------------------------------------------------------------------

// D3DXSHADER 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 

//   Instructs the compiler to skip optimization steps during code generation.

//   Unless you are trying to isolate a problem in your code 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_PARTIALPRECISION

//   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.

//

//----------------------------------------------------------------------------

#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 D3DXSHADER_ENABLE_BACKWARDS_COMPATIBILITY (1 << 12)

#define D3DXSHADER_IEEE_STRICTNESS                (1 << 13)

#define D3DXSHADER_USE_LEGACY_D3DX9_31_DLL        (1 << 16)

// optimization level flags

#define D3DXSHADER_OPTIMIZATION_LEVEL0            (1 << 14)

#define D3DXSHADER_OPTIMIZATION_LEVEL1            0

#define D3DXSHADER_OPTIMIZATION_LEVEL2            ((1 << 14) | (1 << 15))

#define D3DXSHADER_OPTIMIZATION_LEVEL3            (1 << 15)

//----------------------------------------------------------------------------

// D3DXCONSTTABLE flags:

// -------------------

#define D3DXCONSTTABLE_LARGEADDRESSAWARE          (1 << 17)

//----------------------------------------------------------------------------

// D3DXHANDLE:

// -----------

// Handle values used to efficiently reference shader and effect parameters.

// Strings can be used as handles.  However, handles are not always strings.

//----------------------------------------------------------------------------

#ifndef D3DXFX_LARGEADDRESS_HANDLE

typedef LPCSTR D3DXHANDLE;

#else

typedef UINT_PTR D3DXHANDLE;

#endif

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;

//----------------------------------------------------------------------------

// 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,

    D3DXPT_UNSUPPORTED,

    // 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:

//----------------------------------------------------------------------------

typedef interface ID3DXConstantTable ID3DXConstantTable;

typedef interface ID3DXConstantTable *LPD3DXCONSTANTTABLE;

// {AB3C758F-093E-4356-B762-4DB18F1B3A01}

DEFINE_GUID(IID_ID3DXConstantTable,

0xab3c758f, 0x93e, 0x4356, 0xb7, 0x62, 0x4d, 0xb1, 0x8f, 0x1b, 0x3a, 0x1);

#undef INTERFACE

#define INTERFACE ID3DXConstantTable

DECLARE_INTERFACE_(ID3DXConstantTable, IUnknown)

{

    // IUnknown

    STDMETHOD(QueryInterface)(THIS_ REFIID iid, LPVOID *ppv) PURE;

    STDMETHOD_(ULONG, AddRef)(THIS) PURE;

    STDMETHOD_(ULONG, Release)(THIS) PURE;

    // Buffer

    STDMETHOD_(LPVOID, GetBufferPointer)(THIS) PURE;

    STDMETHOD_(DWORD, GetBufferSize)(THIS) PURE;

    // Descs

    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;

    // Handle operations

    STDMETHOD_(D3DXHANDLE, GetConstant)(THIS_ D3DXHANDLE hConstant, UINT Index) PURE;

    STDMETHOD_(D3DXHANDLE, GetConstantByName)(THIS_ D3DXHANDLE hConstant, LPCSTR pName) PURE;

    STDMETHOD_(D3DXHANDLE, GetConstantElement)(THIS_ D3DXHANDLE hConstant, UINT Index) PURE;

    // Set Constants

    STDMETHOD(SetDefaults)(THIS_ LPDIRECT3DDEVICE9 pDevice) PURE;

    STDMETHOD(SetValue)(THIS_ LPDIRECT3DDEVICE9 pDevice, D3DXHANDLE hConstant, LPCVOID pData, UINT Bytes) PURE;

    STDMETHOD(SetBool)(THIS_ LPDIRECT3DDEVICE9 pDevice, D3DXHANDLE hConstant, BOOL b) PURE;

    STDMETHOD(SetBoolArray)(THIS_ LPDIRECT3DDEVICE9 pDevice, D3DXHANDLE hConstant, CONST BOOL* pb, UINT Count) PURE;

    STDMETHOD(SetInt)(THIS_ LPDIRECT3DDEVICE9 pDevice, D3DXHANDLE hConstant, INT n) PURE;

    STDMETHOD(SetIntArray)(THIS_ LPDIRECT3DDEVICE9 pDevice, D3DXHANDLE hConstant, CONST INT* pn, UINT Count) PURE;

    STDMETHOD(SetFloat)(THIS_ LPDIRECT3DDEVICE9 pDevice, D3DXHANDLE hConstant, FLOAT f) PURE;

    STDMETHOD(SetFloatArray)(THIS_ LPDIRECT3DDEVICE9 pDevice, D3DXHANDLE hConstant, CONST FLOAT* pf, UINT Count) PURE;

    STDMETHOD(SetVector)(THIS_ LPDIRECT3DDEVICE9 pDevice, D3DXHANDLE hConstant, CONST D3DXVECTOR4* pVector) PURE;

    STDMETHOD(SetVectorArray)(THIS_ LPDIRECT3DDEVICE9 pDevice, D3DXHANDLE hConstant, CONST D3DXVECTOR4* pVector, UINT Count) PURE;

    STDMETHOD(SetMatrix)(THIS_ LPDIRECT3DDEVICE9 pDevice, D3DXHANDLE hConstant, CONST D3DXMATRIX* pMatrix) PURE;

    STDMETHOD(SetMatrixArray)(THIS_ LPDIRECT3DDEVICE9 pDevice, D3DXHANDLE hConstant, CONST D3DXMATRIX* pMatrix, UINT Count) PURE;

    STDMETHOD(SetMatrixPointerArray)(THIS_ LPDIRECT3DDEVICE9 pDevice, D3DXHANDLE hConstant, CONST D3DXMATRIX** ppMatrix, UINT Count) PURE;

    STDMETHOD(SetMatrixTranspose)(THIS_ LPDIRECT3DDEVICE9 pDevice, D3DXHANDLE hConstant, CONST D3DXMATRIX* pMatrix) PURE;

    STDMETHOD(SetMatrixTransposeArray)(THIS_ LPDIRECT3DDEVICE9 pDevice, D3DXHANDLE hConstant, CONST D3DXMATRIX* pMatrix, UINT Count) PURE;

    STDMETHOD(SetMatrixTransposePointerArray)(THIS_ LPDIRECT3DDEVICE9 pDevice, D3DXHANDLE hConstant, CONST D3DXMATRIX** ppMatrix, UINT Count) PURE;

};

//----------------------------------------------------------------------------

// ID3DXTextureShader:

//----------------------------------------------------------------------------

typedef interface ID3DXTextureShader ID3DXTextureShader;

typedef interface ID3DXTextureShader *LPD3DXTEXTURESHADER;

// {3E3D67F8-AA7A-405d-A857-BA01D4758426}

DEFINE_GUID(IID_ID3DXTextureShader,

0x3e3d67f8, 0xaa7a, 0x405d, 0xa8, 0x57, 0xba, 0x1, 0xd4, 0x75, 0x84, 0x26);

#undef INTERFACE

#define INTERFACE ID3DXTextureShader

DECLARE_INTERFACE_(ID3DXTextureShader, IUnknown)

{

    // IUnknown

    STDMETHOD(QueryInterface)(THIS_ REFIID iid, LPVOID *ppv) PURE;

    STDMETHOD_(ULONG, AddRef)(THIS) PURE;

    STDMETHOD_(ULONG, Release)(THIS) PURE;

    // Gets

    STDMETHOD(GetFunction)(THIS_ LPD3DXBUFFER *ppFunction) PURE;

    STDMETHOD(GetConstantBuffer)(THIS_ LPD3DXBUFFER *ppConstantBuffer) PURE;

    // Descs

    STDMETHOD(GetDesc)(THIS_ D3DXCONSTANTTABLE_DESC *pDesc) PURE;

    STDMETHOD(GetConstantDesc)(THIS_ D3DXHANDLE hConstant, D3DXCONSTANT_DESC *pConstantDesc, UINT *pCount) PURE;

    // Handle operations

    STDMETHOD_(D3DXHANDLE, GetConstant)(THIS_ D3DXHANDLE hConstant, UINT Index) PURE;

    STDMETHOD_(D3DXHANDLE, GetConstantByName)(THIS_ D3DXHANDLE hConstant, LPCSTR pName) PURE;

    STDMETHOD_(D3DXHANDLE, GetConstantElement)(THIS_ D3DXHANDLE hConstant, UINT Index) PURE;

    // Set Constants

    STDMETHOD(SetDefaults)(THIS) PURE;

    STDMETHOD(SetValue)(THIS_ D3DXHANDLE hConstant, LPCVOID 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;

};

//----------------------------------------------------------------------------

// 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.  The name of the file is encoded in UTF-8 format.

// 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, LPCSTR pFileName, LPCVOID pParentData, LPCVOID *ppData, UINT *pBytes) PURE;

    STDMETHOD(Close)(THIS_ LPCVOID pData) PURE;

};

//////////////////////////////////////////////////////////////////////////////

// APIs //////////////////////////////////////////////////////////////////////

//////////////////////////////////////////////////////////////////////////////

#ifdef __cplusplus

extern "C" {

#endif //__cplusplus

//----------------------------------------------------------------------------

// D3DXAssembleShader:

// -------------------

// 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(

        LPCSTR                          pSrcFile,

        CONST D3DXMACRO*                pDefines,

        LPD3DXINCLUDE                   pInclude,

        DWORD                           Flags,

        LPD3DXBUFFER*                   ppShader,

        LPD3DXBUFFER*                   ppErrorMsgs);

HRESULT WINAPI

    D3DXAssembleShaderFromFileW(

        LPCWSTR                         pSrcFile,

        CONST D3DXMACRO*                pDefines,

        LPD3DXINCLUDE                   pInclude,

        DWORD                           Flags,

        LPD3DXBUFFER*                   ppShader,

        LPD3DXBUFFER*                   ppErrorMsgs);

#ifdef UNICODE

#define D3DXAssembleShaderFromFile D3DXAssembleShaderFromFileW

#else

#define D3DXAssembleShaderFromFile D3DXAssembleShaderFromFileA

#endif

HRESULT WINAPI

    D3DXAssembleShaderFromResourceA(

        HMODULE                         hSrcModule,

        LPCSTR                          pSrcResource,

        CONST D3DXMACRO*                pDefines,

        LPD3DXINCLUDE                   pInclude,

        DWORD                           Flags,

        LPD3DXBUFFER*                   ppShader,

        LPD3DXBUFFER*                   ppErrorMsgs);

HRESULT WINAPI

    D3DXAssembleShaderFromResourceW(

        HMODULE                         hSrcModule,

        LPCWSTR                         pSrcResource,

        CONST D3DXMACRO*                pDefines,

        LPD3DXINCLUDE                   pInclude,

        DWORD                           Flags,

        LPD3DXBUFFER*                   ppShader,

        LPD3DXBUFFER*                   ppErrorMsgs);

#ifdef UNICODE

#define D3DXAssembleShaderFromResource D3DXAssembleShaderFromResourceW

#else

#define D3DXAssembleShaderFromResource D3DXAssembleShaderFromResourceA

#endif

HRESULT WINAPI

    D3DXAssembleShader(

        LPCSTR                          pSrcData,

        UINT                            SrcDataLen,

        CONST D3DXMACRO*                pDefines,

        LPD3DXINCLUDE                   pInclude,

        DWORD                           Flags,

        LPD3DXBUFFER*                   ppShader,

        LPD3DXBUFFER*                   ppErrorMsgs);

//----------------------------------------------------------------------------

// D3DXCompileShader:

// ------------------

// 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_1_1", "vs_2_0", "vs_2_a", "vs_2_sw", "ps_1_1", 

//      "ps_1_2", "ps_1_3", "ps_1_4", "ps_2_0", "ps_2_a", "ps_2_sw", "tx_1_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(

        LPCSTR                          pSrcFile,

        CONST D3DXMACRO*                pDefines,

        LPD3DXINCLUDE                   pInclude,

        LPCSTR                          pFunctionName,

        LPCSTR                          pProfile,

        DWORD                           Flags,

        LPD3DXBUFFER*                   ppShader,

        LPD3DXBUFFER*                   ppErrorMsgs,

        LPD3DXCONSTANTTABLE*            ppConstantTable);

HRESULT WINAPI

    D3DXCompileShaderFromFileW(

        LPCWSTR                         pSrcFile,

        CONST D3DXMACRO*                pDefines,

        LPD3DXINCLUDE                   pInclude,

        LPCSTR                          pFunctionName,

        LPCSTR                          pProfile,

        DWORD                           Flags,

        LPD3DXBUFFER*                   ppShader,

        LPD3DXBUFFER*                   ppErrorMsgs,

        LPD3DXCONSTANTTABLE*            ppConstantTable);

#ifdef UNICODE

#define D3DXCompileShaderFromFile D3DXCompileShaderFromFileW

#else

#define D3DXCompileShaderFromFile D3DXCompileShaderFromFileA

#endif

HRESULT WINAPI

    D3DXCompileShaderFromResourceA(

        HMODULE                         hSrcModule,

        LPCSTR                          pSrcResource,

        CONST D3DXMACRO*                pDefines,

        LPD3DXINCLUDE                   pInclude,

        LPCSTR                          pFunctionName,

        LPCSTR                          pProfile,

        DWORD                           Flags,

        LPD3DXBUFFER*                   ppShader,

        LPD3DXBUFFER*                   ppErrorMsgs,

        LPD3DXCONSTANTTABLE*            ppConstantTable);

HRESULT WINAPI

    D3DXCompileShaderFromResourceW(

        HMODULE                         hSrcModule,

        LPCWSTR                         pSrcResource,

        CONST D3DXMACRO*                pDefines,

        LPD3DXINCLUDE                   pInclude,

        LPCSTR                          pFunctionName,

        LPCSTR                          pProfile,

        DWORD                           Flags,

        LPD3DXBUFFER*                   ppShader,

        LPD3DXBUFFER*                   ppErrorMsgs,

        LPD3DXCONSTANTTABLE*            ppConstantTable);

#ifdef UNICODE

#define D3DXCompileShaderFromResource D3DXCompileShaderFromResourceW

#else

#define D3DXCompileShaderFromResource D3DXCompileShaderFromResourceA

#endif

HRESULT WINAPI

    D3DXCompileShader(

        LPCSTR                          pSrcData,

        UINT                            SrcDataLen,

        CONST D3DXMACRO*                pDefines,

        LPD3DXINCLUDE                   pInclude,

        LPCSTR                          pFunctionName,

        LPCSTR                          pProfile,

        DWORD                           Flags,

        LPD3DXBUFFER*                   ppShader,

        LPD3DXBUFFER*                   ppErrorMsgs,

        LPD3DXCONSTANTTABLE*            ppConstantTable);

//----------------------------------------------------------------------------

// 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(

        CONST DWORD*                    pShader,

        BOOL                            EnableColorCode,

        LPCSTR                          pComments,

        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(

        LPDIRECT3DDEVICE9               pDevice);

LPCSTR WINAPI

    D3DXGetVertexShaderProfile(

        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(

        CONST DWORD*                    pFunction,

        DWORD                           FourCC,

        LPCVOID*                        ppData,

        UINT*                           pSizeInBytes);

//----------------------------------------------------------------------------

// D3DXGetShaderSize:

// ------------------

// Returns the size of the shader byte-code, in bytes.

//

// Parameters:

//  pFunction

//      Pointer to the function DWORD stream

//----------------------------------------------------------------------------

UINT WINAPI

    D3DXGetShaderSize(

        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(

        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(

        CONST DWORD*                    pFunction,

        D3DXSEMANTIC*                   pSemantics,

        UINT*                           pCount);

HRESULT WINAPI

    D3DXGetShaderOutputSemantics(

        CONST DWORD*                    pFunction,

        D3DXSEMANTIC*                   pSemantics,

        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 16 elements.

// pCount

//      Returns the number of samplers referenced by the shader

//----------------------------------------------------------------------------

HRESULT WINAPI

    D3DXGetShaderSamplers(

        CONST DWORD*                    pFunction,

        LPCSTR*                         pSamplers,

        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

//  Flags

//      See D3DXCONSTTABLE_xxx

//  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(

        CONST DWORD*                    pFunction,

        LPD3DXCONSTANTTABLE*            ppConstantTable);

HRESULT WINAPI

    D3DXGetShaderConstantTableEx(

        CONST DWORD*                    pFunction,

        DWORD                           Flags,

        LPD3DXCONSTANTTABLE*            ppConstantTable);

//----------------------------------------------------------------------------

// D3DXCreateTextureShader:

// ------------------------

// Creates a texture shader object, given the compiled shader.

//

// Parameters

//  pFunction

//      Pointer to the function DWORD stream

//  ppTextureShader

//      Returns a ID3DXTextureShader object which can be used to procedurally 

//      fill the contents of a texture using the D3DXFillTextureTX functions.

//----------------------------------------------------------------------------

HRESULT WINAPI

    D3DXCreateTextureShader(

        CONST DWORD*                    pFunction,

        LPD3DXTEXTURESHADER*            ppTextureShader);

//----------------------------------------------------------------------------

// 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(

        LPCSTR                       pSrcFile,

        CONST D3DXMACRO*             pDefines,

        LPD3DXINCLUDE                pInclude,

        LPD3DXBUFFER*                ppShaderText,

        LPD3DXBUFFER*                ppErrorMsgs);

HRESULT WINAPI

    D3DXPreprocessShaderFromFileW(

        LPCWSTR                      pSrcFile,

        CONST D3DXMACRO*             pDefines,

        LPD3DXINCLUDE                pInclude,

        LPD3DXBUFFER*                ppShaderText,

        LPD3DXBUFFER*                ppErrorMsgs);

#ifdef UNICODE

#define D3DXPreprocessShaderFromFile D3DXPreprocessShaderFromFileW

#else

#define D3DXPreprocessShaderFromFile D3DXPreprocessShaderFromFileA

#endif

HRESULT WINAPI

    D3DXPreprocessShaderFromResourceA(

        HMODULE                      hSrcModule,

        LPCSTR                       pSrcResource,

        CONST D3DXMACRO*             pDefines,

        LPD3DXINCLUDE                pInclude,

        LPD3DXBUFFER*                ppShaderText,

        LPD3DXBUFFER*                ppErrorMsgs);

HRESULT WINAPI

    D3DXPreprocessShaderFromResourceW(

        HMODULE                      hSrcModule,

        LPCWSTR                      pSrcResource,

        CONST D3DXMACRO*             pDefines,

        LPD3DXINCLUDE                pInclude,

        LPD3DXBUFFER*                ppShaderText,

        LPD3DXBUFFER*                ppErrorMsgs);

#ifdef UNICODE

#define D3DXPreprocessShaderFromResource D3DXPreprocessShaderFromResourceW

#else

#define D3DXPreprocessShaderFromResource D3DXPreprocessShaderFromResourceA

#endif

HRESULT WINAPI

    D3DXPreprocessShader(

        LPCSTR                       pSrcData,

        UINT                         SrcDataSize,

        CONST D3DXMACRO*             pDefines,

        LPD3DXINCLUDE                pInclude,

        LPD3DXBUFFER*                ppShaderText,

        LPD3DXBUFFER*                ppErrorMsgs);

#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;

typedef struct _D3DXSHADER_CONSTANTINFO

{