Subversion Repositories Games.Chess Giants

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

//

//  Copyright (c) Microsoft Corporation.  All rights reserved.

//

//  File:       D3D10Shader.h

//  Content:    D3D10 Shader Types and APIs

//

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

#ifndef __D3D10SHADER_H__

#define __D3D10SHADER_H__

#include "d3d10.h"

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

// D3D10_TX_VERSION:

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

// Version token used to create a procedural texture filler in effects

// Used by D3D10Fill[]TX functions

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

#define D3D10_TX_VERSION(_Major,_Minor) (('T' << 24) | ('X' << 16) | ((_Major) << 8) | (_Minor))

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

// D3D10SHADER flags:

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

// D3D10_SHADER_DEBUG

//   Insert debug file/line/type/symbol information.

//

// D3D10_SHADER_SKIP_VALIDATION

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

//

// D3D10_SHADER_SKIP_OPTIMIZATION 

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

//

// D3D10_SHADER_PACK_MATRIX_ROW_MAJOR

//   Unless explicitly specified, matrices will be packed in row-major order

//   on input and output from the shader.

//

// D3D10_SHADER_PACK_MATRIX_COLUMN_MAJOR

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

//

// D3D10_SHADER_PARTIAL_PRECISION

//   Force all computations in resulting shader to occur at partial precision.

//   This may result in faster evaluation of shaders on some hardware.

//

// D3D10_SHADER_FORCE_VS_SOFTWARE_NO_OPT

//   Force compiler to compile against the next highest available software

//   target for vertex shaders.  This flag also turns optimizations off, 

//   and debugging on.  

//

// D3D10_SHADER_FORCE_PS_SOFTWARE_NO_OPT

//   Force compiler to compile against the next highest available software

//   target for pixel shaders.  This flag also turns optimizations off, 

//   and debugging on.

//

// D3D10_SHADER_NO_PRESHADER

//   Disables Preshaders. Using this flag will cause the compiler to not 

//   pull out static expression for evaluation on the host cpu

//

// D3D10_SHADER_AVOID_FLOW_CONTROL

//   Hint compiler to avoid flow-control constructs where possible.

//

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

//

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

#define D3D10_SHADER_DEBUG                          (1 << 0)

#define D3D10_SHADER_SKIP_VALIDATION                (1 << 1)

#define D3D10_SHADER_SKIP_OPTIMIZATION              (1 << 2)

#define D3D10_SHADER_PACK_MATRIX_ROW_MAJOR          (1 << 3)

#define D3D10_SHADER_PACK_MATRIX_COLUMN_MAJOR       (1 << 4)

#define D3D10_SHADER_PARTIAL_PRECISION              (1 << 5)

#define D3D10_SHADER_FORCE_VS_SOFTWARE_NO_OPT       (1 << 6)

#define D3D10_SHADER_FORCE_PS_SOFTWARE_NO_OPT       (1 << 7)

#define D3D10_SHADER_NO_PRESHADER                   (1 << 8)

#define D3D10_SHADER_AVOID_FLOW_CONTROL             (1 << 9)

#define D3D10_SHADER_PREFER_FLOW_CONTROL            (1 << 10)

#define D3D10_SHADER_ENABLE_STRICTNESS              (1 << 11)

#define D3D10_SHADER_ENABLE_BACKWARDS_COMPATIBILITY (1 << 12)

#define D3D10_SHADER_IEEE_STRICTNESS                (1 << 13)

#define D3D10_SHADER_WARNINGS_ARE_ERRORS            (1 << 18)

// optimization level flags

#define D3D10_SHADER_OPTIMIZATION_LEVEL0            (1 << 14)

#define D3D10_SHADER_OPTIMIZATION_LEVEL1            0

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

#define D3D10_SHADER_OPTIMIZATION_LEVEL3            (1 << 15)

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

// D3D10_SHADER_MACRO:

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

// Preprocessor macro definition.  The application pass in a NULL-terminated

// array of this structure to various D3D10 APIs.  This enables the application

// to #define tokens at runtime, before the file is parsed.

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

typedef struct _D3D10_SHADER_MACRO

{

    LPCSTR Name;

    LPCSTR Definition;

} D3D10_SHADER_MACRO, *LPD3D10_SHADER_MACRO;

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

// D3D10_SHADER_VARIABLE_CLASS:

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

typedef enum _D3D10_SHADER_VARIABLE_CLASS

{

    D3D10_SVC_SCALAR,

    D3D10_SVC_VECTOR,

    D3D10_SVC_MATRIX_ROWS,

    D3D10_SVC_MATRIX_COLUMNS,

    D3D10_SVC_OBJECT,

    D3D10_SVC_STRUCT,

    D3D11_SVC_INTERFACE_CLASS,

    D3D11_SVC_INTERFACE_POINTER,

    // force 32-bit size enum

    D3D10_SVC_FORCE_DWORD = 0x7fffffff

} D3D10_SHADER_VARIABLE_CLASS, *LPD3D10_SHADER_VARIABLE_CLASS;

typedef enum _D3D10_SHADER_VARIABLE_FLAGS

{

    D3D10_SVF_USERPACKED = 1,

    D3D10_SVF_USED       = 2,

    D3D11_SVF_INTERFACE_POINTER = 4,

    D3D11_SVF_INTERFACE_PARAMETER = 8,

    // force 32-bit size enum

    D3D10_SVF_FORCE_DWORD = 0x7fffffff

} D3D10_SHADER_VARIABLE_FLAGS, *LPD3D10_SHADER_VARIABLE_FLAGS;

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

// D3D10_SHADER_VARIABLE_TYPE:

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

typedef enum _D3D10_SHADER_VARIABLE_TYPE

{

    D3D10_SVT_VOID = 0,

    D3D10_SVT_BOOL = 1,

    D3D10_SVT_INT = 2,

    D3D10_SVT_FLOAT = 3,

    D3D10_SVT_STRING = 4,

    D3D10_SVT_TEXTURE = 5,

    D3D10_SVT_TEXTURE1D = 6,

    D3D10_SVT_TEXTURE2D = 7,

    D3D10_SVT_TEXTURE3D = 8,

    D3D10_SVT_TEXTURECUBE = 9,

    D3D10_SVT_SAMPLER = 10,

    D3D10_SVT_PIXELSHADER = 15,

    D3D10_SVT_VERTEXSHADER = 16,

    D3D10_SVT_UINT = 19,

    D3D10_SVT_UINT8 = 20,

    D3D10_SVT_GEOMETRYSHADER = 21,

    D3D10_SVT_RASTERIZER = 22,

    D3D10_SVT_DEPTHSTENCIL = 23,

    D3D10_SVT_BLEND = 24,

    D3D10_SVT_BUFFER = 25,

    D3D10_SVT_CBUFFER = 26,

    D3D10_SVT_TBUFFER = 27,

    D3D10_SVT_TEXTURE1DARRAY = 28,

    D3D10_SVT_TEXTURE2DARRAY = 29,

    D3D10_SVT_RENDERTARGETVIEW = 30,

    D3D10_SVT_DEPTHSTENCILVIEW = 31,

    D3D10_SVT_TEXTURE2DMS = 32,

    D3D10_SVT_TEXTURE2DMSARRAY = 33,

    D3D10_SVT_TEXTURECUBEARRAY = 34,

    D3D11_SVT_HULLSHADER = 35,

    D3D11_SVT_DOMAINSHADER = 36,

    D3D11_SVT_INTERFACE_POINTER = 37,

    D3D11_SVT_COMPUTESHADER = 38,

    D3D11_SVT_DOUBLE = 39,

    D3D11_SVT_RWTEXTURE1D,

    D3D11_SVT_RWTEXTURE1DARRAY,

    D3D11_SVT_RWTEXTURE2D,

    D3D11_SVT_RWTEXTURE2DARRAY,

    D3D11_SVT_RWTEXTURE3D,

    D3D11_SVT_RWBUFFER,

    D3D11_SVT_BYTEADDRESS_BUFFER,

    D3D11_SVT_RWBYTEADDRESS_BUFFER,

    D3D11_SVT_STRUCTURED_BUFFER,

    D3D11_SVT_RWSTRUCTURED_BUFFER,

    D3D11_SVT_APPEND_STRUCTURED_BUFFER,

    D3D11_SVT_CONSUME_STRUCTURED_BUFFER,

    // force 32-bit size enum

    D3D10_SVT_FORCE_DWORD = 0x7fffffff

} D3D10_SHADER_VARIABLE_TYPE, *LPD3D10_SHADER_VARIABLE_TYPE;

typedef enum _D3D10_SHADER_INPUT_FLAGS

{

    D3D10_SIF_USERPACKED = 1,

    D3D10_SIF_COMPARISON_SAMPLER = 2,  // is this a comparison sampler?

    D3D10_SIF_TEXTURE_COMPONENT_0 = 4, // this 2-bit value encodes c - 1, where c

    D3D10_SIF_TEXTURE_COMPONENT_1 = 8, // is the number of components in the texture

    D3D10_SIF_TEXTURE_COMPONENTS = 12,

    // force 32-bit size enum

    D3D10_SIF_FORCE_DWORD = 0x7fffffff

} D3D10_SHADER_INPUT_FLAGS, *LPD3D10_SHADER_INPUT_FLAGS;

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

// D3D10_SHADER_INPUT_TYPE

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

typedef enum _D3D10_SHADER_INPUT_TYPE

{

    D3D10_SIT_CBUFFER,

    D3D10_SIT_TBUFFER,

    D3D10_SIT_TEXTURE,

    D3D10_SIT_SAMPLER,

    D3D11_SIT_UAV_RWTYPED,

    D3D11_SIT_STRUCTURED,

    D3D11_SIT_UAV_RWSTRUCTURED,

    D3D11_SIT_BYTEADDRESS,

    D3D11_SIT_UAV_RWBYTEADDRESS,

    D3D11_SIT_UAV_APPEND_STRUCTURED,

    D3D11_SIT_UAV_CONSUME_STRUCTURED,

    D3D11_SIT_UAV_RWSTRUCTURED_WITH_COUNTER,

} D3D10_SHADER_INPUT_TYPE, *LPD3D10_SHADER_INPUT_TYPE;

typedef enum _D3D10_SHADER_CBUFFER_FLAGS

{

    D3D10_CBF_USERPACKED = 1,

    // force 32-bit size enum

    D3D10_CBF_FORCE_DWORD = 0x7fffffff

} D3D10_SHADER_CBUFFER_FLAGS, *LPD3D10_SHADER_CBUFFER_FLAGS;

typedef enum _D3D10_CBUFFER_TYPE

{

    D3D10_CT_CBUFFER,

    D3D10_CT_TBUFFER,

}  D3D10_CBUFFER_TYPE, *LPD3D10_CBUFFER_TYPE;

typedef enum D3D10_NAME

{

    D3D10_NAME_UNDEFINED = 0,

    // Names meaningful to both HLSL and hardware

    D3D10_NAME_POSITION = 1,

    D3D10_NAME_CLIP_DISTANCE = 2,

    D3D10_NAME_CULL_DISTANCE = 3,

    D3D10_NAME_RENDER_TARGET_ARRAY_INDEX = 4,

    D3D10_NAME_VIEWPORT_ARRAY_INDEX = 5,

    D3D10_NAME_VERTEX_ID = 6,

    D3D10_NAME_PRIMITIVE_ID = 7,

    D3D10_NAME_INSTANCE_ID = 8,

    D3D10_NAME_IS_FRONT_FACE = 9,

    D3D10_NAME_SAMPLE_INDEX = 10,

    D3D11_NAME_FINAL_QUAD_EDGE_TESSFACTOR = 11,

    D3D11_NAME_FINAL_QUAD_INSIDE_TESSFACTOR = 12,

    D3D11_NAME_FINAL_TRI_EDGE_TESSFACTOR = 13,

    D3D11_NAME_FINAL_TRI_INSIDE_TESSFACTOR = 14,

    D3D11_NAME_FINAL_LINE_DETAIL_TESSFACTOR = 15,

    D3D11_NAME_FINAL_LINE_DENSITY_TESSFACTOR = 16,

    // Names meaningful to HLSL only

    D3D10_NAME_TARGET = 64,

    D3D10_NAME_DEPTH = 65,

    D3D10_NAME_COVERAGE = 66,

    D3D11_NAME_DEPTH_GREATER_EQUAL = 67,

    D3D11_NAME_DEPTH_LESS_EQUAL = 68,

} D3D10_NAME;

typedef enum D3D10_RESOURCE_RETURN_TYPE

{

    D3D10_RETURN_TYPE_UNORM = 1,

    D3D10_RETURN_TYPE_SNORM = 2,

    D3D10_RETURN_TYPE_SINT = 3,

    D3D10_RETURN_TYPE_UINT = 4,

    D3D10_RETURN_TYPE_FLOAT = 5,

    D3D10_RETURN_TYPE_MIXED = 6,

} D3D10_RESOURCE_RETURN_TYPE;

typedef enum D3D10_REGISTER_COMPONENT_TYPE

{

    D3D10_REGISTER_COMPONENT_UNKNOWN = 0,

    D3D10_REGISTER_COMPONENT_UINT32 = 1,

    D3D10_REGISTER_COMPONENT_SINT32 = 2,

    D3D10_REGISTER_COMPONENT_FLOAT32 = 3

} D3D10_REGISTER_COMPONENT_TYPE;

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

// D3D10_INCLUDE_TYPE:

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

typedef enum _D3D10_INCLUDE_TYPE

{

    D3D10_INCLUDE_LOCAL,

    D3D10_INCLUDE_SYSTEM,

    // force 32-bit size enum

    D3D10_INCLUDE_FORCE_DWORD = 0x7fffffff

} D3D10_INCLUDE_TYPE, *LPD3D10_INCLUDE_TYPE;

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

// ID3D10Include:

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

// This interface is intended to be implemented by the application, and can

// be used by various D3D10 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 ID3D10Include ID3D10Include;

typedef interface ID3D10Include *LPD3D10INCLUDE;

#undef INTERFACE

#define INTERFACE ID3D10Include

DECLARE_INTERFACE(ID3D10Include)

{

    STDMETHOD(Open)(THIS_ D3D10_INCLUDE_TYPE IncludeType, LPCSTR pFileName, LPCVOID pParentData, LPCVOID *ppData, UINT *pBytes) PURE;

    STDMETHOD(Close)(THIS_ LPCVOID pData) PURE;

};

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

// ID3D10ShaderReflection:

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

//

// Structure definitions

//

typedef struct _D3D10_SHADER_DESC

{

    UINT                    Version;                     // Shader version

    LPCSTR                  Creator;                     // Creator string

    UINT                    Flags;                       // Shader compilation/parse flags

    UINT                    ConstantBuffers;             // Number of constant buffers

    UINT                    BoundResources;              // Number of bound resources

    UINT                    InputParameters;             // Number of parameters in the input signature

    UINT                    OutputParameters;            // Number of parameters in the output signature

    UINT                    InstructionCount;            // Number of emitted instructions

    UINT                    TempRegisterCount;           // Number of temporary registers used 

    UINT                    TempArrayCount;              // Number of temporary arrays used

    UINT                    DefCount;                    // Number of constant defines 

    UINT                    DclCount;                    // Number of declarations (input + output)

    UINT                    TextureNormalInstructions;   // Number of non-categorized texture instructions

    UINT                    TextureLoadInstructions;     // Number of texture load instructions

    UINT                    TextureCompInstructions;     // Number of texture comparison instructions

    UINT                    TextureBiasInstructions;     // Number of texture bias instructions

    UINT                    TextureGradientInstructions; // Number of texture gradient instructions

    UINT                    FloatInstructionCount;       // Number of floating point arithmetic instructions used

    UINT                    IntInstructionCount;         // Number of signed integer arithmetic instructions used

    UINT                    UintInstructionCount;        // Number of unsigned integer arithmetic instructions used

    UINT                    StaticFlowControlCount;      // Number of static flow control instructions used

    UINT                    DynamicFlowControlCount;     // Number of dynamic flow control instructions used

    UINT                    MacroInstructionCount;       // Number of macro instructions used

    UINT                    ArrayInstructionCount;       // Number of array instructions used

    UINT                    CutInstructionCount;         // Number of cut instructions used

    UINT                    EmitInstructionCount;        // Number of emit instructions used

    D3D10_PRIMITIVE_TOPOLOGY GSOutputTopology;           // Geometry shader output topology

    UINT                    GSMaxOutputVertexCount;      // Geometry shader maximum output vertex count

} D3D10_SHADER_DESC;

typedef struct _D3D10_SHADER_BUFFER_DESC

{

    LPCSTR                  Name;           // Name of the constant buffer

    D3D10_CBUFFER_TYPE      Type;           // Indicates that this is a CBuffer or TBuffer

    UINT                    Variables;      // Number of member variables

    UINT                    Size;           // Size of CB (in bytes)

    UINT                    uFlags;         // Buffer description flags

} D3D10_SHADER_BUFFER_DESC;

typedef struct _D3D10_SHADER_VARIABLE_DESC

{

    LPCSTR                  Name;           // Name of the variable

    UINT                    StartOffset;    // Offset in constant buffer's backing store

    UINT                    Size;           // Size of variable (in bytes)

    UINT                    uFlags;         // Variable flags

    LPVOID                  DefaultValue;   // Raw pointer to default value

} D3D10_SHADER_VARIABLE_DESC;

typedef struct _D3D10_SHADER_TYPE_DESC

{

    D3D10_SHADER_VARIABLE_CLASS Class;          // Variable class (e.g. object, matrix, etc.)

    D3D10_SHADER_VARIABLE_TYPE  Type;           // Variable type (e.g. float, sampler, etc.)

    UINT                        Rows;           // Number of rows (for matrices, 1 for other numeric, 0 if not applicable)

    UINT                        Columns;        // Number of columns (for vectors & matrices, 1 for other numeric, 0 if not applicable)

    UINT                        Elements;       // Number of elements (0 if not an array)

    UINT                        Members;        // Number of members (0 if not a structure)

    UINT                        Offset;         // Offset from the start of structure (0 if not a structure member) 

} D3D10_SHADER_TYPE_DESC;

typedef struct _D3D10_SHADER_INPUT_BIND_DESC

{

    LPCSTR                      Name;           // Name of the resource

    D3D10_SHADER_INPUT_TYPE     Type;           // Type of resource (e.g. texture, cbuffer, etc.)

    UINT                        BindPoint;      // Starting bind point

    UINT                        BindCount;      // Number of contiguous bind points (for arrays)

    UINT                        uFlags;         // Input binding flags

    D3D10_RESOURCE_RETURN_TYPE  ReturnType;     // Return type (if texture)

    D3D10_SRV_DIMENSION         Dimension;      // Dimension (if texture)

    UINT                        NumSamples;     // Number of samples (0 if not MS texture)

} D3D10_SHADER_INPUT_BIND_DESC;

typedef struct _D3D10_SIGNATURE_PARAMETER_DESC

{

    LPCSTR                      SemanticName;   // Name of the semantic

    UINT                        SemanticIndex;  // Index of the semantic

    UINT                        Register;       // Number of member variables

    D3D10_NAME                  SystemValueType;// A predefined system value, or D3D10_NAME_UNDEFINED if not applicable

    D3D10_REGISTER_COMPONENT_TYPE ComponentType;// Scalar type (e.g. uint, float, etc.)

    BYTE                        Mask;           // Mask to indicate which components of the register

                                                // are used (combination of D3D10_COMPONENT_MASK values)

    BYTE                        ReadWriteMask;  // Mask to indicate whether a given component is 

                                                // never written (if this is an output signature) or

                                                // always read (if this is an input signature).

                                                // (combination of D3D10_COMPONENT_MASK values)

} D3D10_SIGNATURE_PARAMETER_DESC;

//

// Interface definitions

//

typedef interface ID3D10ShaderReflectionType ID3D10ShaderReflectionType;

typedef interface ID3D10ShaderReflectionType *LPD3D10SHADERREFLECTIONTYPE;

// {C530AD7D-9B16-4395-A979-BA2ECFF83ADD}

DEFINE_GUID(IID_ID3D10ShaderReflectionType,

0xc530ad7d, 0x9b16, 0x4395, 0xa9, 0x79, 0xba, 0x2e, 0xcf, 0xf8, 0x3a, 0xdd);

#undef INTERFACE

#define INTERFACE ID3D10ShaderReflectionType

DECLARE_INTERFACE(ID3D10ShaderReflectionType)

{

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

    STDMETHOD_(ID3D10ShaderReflectionType*, GetMemberTypeByIndex)(THIS_ UINT Index) PURE;

    STDMETHOD_(ID3D10ShaderReflectionType*, GetMemberTypeByName)(THIS_ LPCSTR Name) PURE;

    STDMETHOD_(LPCSTR, GetMemberTypeName)(THIS_ UINT Index) PURE;

};

typedef interface ID3D10ShaderReflectionVariable ID3D10ShaderReflectionVariable;

typedef interface ID3D10ShaderReflectionVariable *LPD3D10SHADERREFLECTIONVARIABLE;

// {1BF63C95-2650-405d-99C1-3636BD1DA0A1}

DEFINE_GUID(IID_ID3D10ShaderReflectionVariable,

0x1bf63c95, 0x2650, 0x405d, 0x99, 0xc1, 0x36, 0x36, 0xbd, 0x1d, 0xa0, 0xa1);

#undef INTERFACE

#define INTERFACE ID3D10ShaderReflectionVariable

DECLARE_INTERFACE(ID3D10ShaderReflectionVariable)

{

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

    STDMETHOD_(ID3D10ShaderReflectionType*, GetType)(THIS) PURE;

};

typedef interface ID3D10ShaderReflectionConstantBuffer ID3D10ShaderReflectionConstantBuffer;

typedef interface ID3D10ShaderReflectionConstantBuffer *LPD3D10SHADERREFLECTIONCONSTANTBUFFER;

// {66C66A94-DDDD-4b62-A66A-F0DA33C2B4D0}

DEFINE_GUID(IID_ID3D10ShaderReflectionConstantBuffer,

0x66c66a94, 0xdddd, 0x4b62, 0xa6, 0x6a, 0xf0, 0xda, 0x33, 0xc2, 0xb4, 0xd0);

#undef INTERFACE

#define INTERFACE ID3D10ShaderReflectionConstantBuffer

DECLARE_INTERFACE(ID3D10ShaderReflectionConstantBuffer)

{

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

    STDMETHOD_(ID3D10ShaderReflectionVariable*, GetVariableByIndex)(THIS_ UINT Index) PURE;

    STDMETHOD_(ID3D10ShaderReflectionVariable*, GetVariableByName)(THIS_ LPCSTR Name) PURE;

};

typedef interface ID3D10ShaderReflection ID3D10ShaderReflection;

typedef interface ID3D10ShaderReflection *LPD3D10SHADERREFLECTION;

// {D40E20B6-F8F7-42ad-AB20-4BAF8F15DFAA}

DEFINE_GUID(IID_ID3D10ShaderReflection,

0xd40e20b6, 0xf8f7, 0x42ad, 0xab, 0x20, 0x4b, 0xaf, 0x8f, 0x15, 0xdf, 0xaa);

#undef INTERFACE

#define INTERFACE ID3D10ShaderReflection

DECLARE_INTERFACE_(ID3D10ShaderReflection, IUnknown)

{

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

    STDMETHOD_(ULONG, AddRef)(THIS) PURE;

    STDMETHOD_(ULONG, Release)(THIS) PURE;

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

    STDMETHOD_(ID3D10ShaderReflectionConstantBuffer*, GetConstantBufferByIndex)(THIS_ UINT Index) PURE;

    STDMETHOD_(ID3D10ShaderReflectionConstantBuffer*, GetConstantBufferByName)(THIS_ LPCSTR Name) PURE;

    STDMETHOD(GetResourceBindingDesc)(THIS_ UINT ResourceIndex, D3D10_SHADER_INPUT_BIND_DESC *pDesc) PURE;

    STDMETHOD(GetInputParameterDesc)(THIS_ UINT ParameterIndex, D3D10_SIGNATURE_PARAMETER_DESC *pDesc) PURE;

    STDMETHOD(GetOutputParameterDesc)(THIS_ UINT ParameterIndex, D3D10_SIGNATURE_PARAMETER_DESC *pDesc) PURE;

};

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

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

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

#ifdef __cplusplus

extern "C" {

#endif //__cplusplus

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

// D3D10CompileShader:

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

// 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.  The D3D10 entry

//      point currently supports only "vs_4_0", "ps_4_0", and "gs_4_0".

//  Flags

//      See D3D10_SHADER_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 D3D10GetShaderConstantTable)

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

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

HRESULT WINAPI D3D10CompileShader(LPCSTR pSrcData, SIZE_T SrcDataLen, LPCSTR pFileName, CONST D3D10_SHADER_MACRO* pDefines, LPD3D10INCLUDE pInclude,

    LPCSTR pFunctionName, LPCSTR pProfile, UINT Flags, ID3D10Blob** ppShader, ID3D10Blob** ppErrorMsgs);

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

// D3D10DisassembleShader:

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

// Takes a binary shader, and returns a buffer containing text assembly.

//

// Parameters:

//  pShader

//      Pointer to the shader byte code.

//  BytecodeLength

//      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 D3D10DisassembleShader(CONST void *pShader, SIZE_T BytecodeLength, BOOL EnableColorCode, LPCSTR pComments, ID3D10Blob** ppDisassembly);

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

// D3D10GetPixelShaderProfile/D3D10GetVertexShaderProfile/D3D10GetGeometryShaderProfile:

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

// Returns the name of the HLSL profile best suited to a given device.

//

// Parameters:

//  pDevice

//      Pointer to the device in question

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

LPCSTR WINAPI D3D10GetPixelShaderProfile(ID3D10Device *pDevice);

LPCSTR WINAPI D3D10GetVertexShaderProfile(ID3D10Device *pDevice);

LPCSTR WINAPI D3D10GetGeometryShaderProfile(ID3D10Device *pDevice);

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

// D3D10ReflectShader:

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

// Creates a shader reflection object that can be used to retrieve information

// about a compiled shader

//

// Parameters:

//  pShaderBytecode

//      Pointer to a compiled shader (same pointer that is passed into

//      ID3D10Device::CreateShader)

//  BytecodeLength

//      Length of the shader bytecode buffer

//  ppReflector

//      [out] Returns a ID3D10ShaderReflection object that can be used to 

//      retrieve shader resource and constant buffer information

//

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

HRESULT WINAPI D3D10ReflectShader(CONST void *pShaderBytecode, SIZE_T BytecodeLength, ID3D10ShaderReflection **ppReflector);

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

// D3D10PreprocessShader

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

// Creates a shader reflection object that can be used to retrieve information

// about a compiled shader

//

// Parameters:

//  pSrcData

//      Pointer to source code

//  SrcDataLen

//      Size of source code, in bytes

//  pFileName

//      Source file name (used for error output)

//  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 D3D10PreprocessShader(LPCSTR pSrcData, SIZE_T SrcDataSize, LPCSTR pFileName, CONST D3D10_SHADER_MACRO* pDefines,

    LPD3D10INCLUDE pInclude, ID3D10Blob** ppShaderText, ID3D10Blob** ppErrorMsgs);

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

//

// Shader blob manipulation routines

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

//

// void *pShaderBytecode - a buffer containing the result of an HLSL

//  compilation.  Typically this opaque buffer contains several 

//  discrete sections including the shader executable code, the input

//  signature, and the output signature.  This can typically be retrieved 

//  by calling ID3D10Blob::GetBufferPointer() on the returned blob

//  from HLSL's compile APIs.

//

// UINT BytecodeLength - the length of pShaderBytecode.  This can 

//  typically be retrieved by calling ID3D10Blob::GetBufferSize() 

//  on the returned blob from HLSL's compile APIs.

//

// ID3D10Blob **ppSignatureBlob(s) - a newly created buffer that

//  contains only the signature portions of the original bytecode.

//  This is a copy; the original bytecode is not modified.  You may

//  specify NULL for this parameter to have the bytecode validated

//  for the presence of the corresponding signatures without actually

//  copying them and creating a new blob.

//

// Returns E_INVALIDARG if any required parameters are NULL

// Returns E_FAIL is the bytecode is corrupt or missing signatures

// Returns S_OK on success

//

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

HRESULT WINAPI D3D10GetInputSignatureBlob(CONST void *pShaderBytecode, SIZE_T BytecodeLength, ID3D10Blob **ppSignatureBlob);

HRESULT WINAPI D3D10GetOutputSignatureBlob(CONST void *pShaderBytecode, SIZE_T BytecodeLength, ID3D10Blob **ppSignatureBlob);

HRESULT WINAPI D3D10GetInputAndOutputSignatureBlob(CONST void *pShaderBytecode, SIZE_T BytecodeLength, ID3D10Blob **ppSignatureBlob);

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

// D3D10GetShaderDebugInfo:

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

// Gets shader debug info.  Debug info is generated by D3D10CompileShader and is

// embedded in the body of the shader.

//

// Parameters:

//  pShaderBytecode

//      Pointer to the function bytecode

//  BytecodeLength

//      Length of the shader bytecode buffer

//  ppDebugInfo

//      Buffer used to return debug info.  For information about the layout

//      of this buffer, see definition of D3D10_SHADER_DEBUG_INFO above.

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

HRESULT WINAPI D3D10GetShaderDebugInfo(CONST void *pShaderBytecode, SIZE_T BytecodeLength, ID3D10Blob** ppDebugInfo);

#ifdef __cplusplus

}

#endif //__cplusplus

#endif //__D3D10SHADER_H__