+++ /dev/null
-//////////////////////////////////////////////////////////////////////////////\r
-//\r
-// Copyright (C) Microsoft Corporation. All Rights Reserved.\r
-//\r
-// File: Effect.h\r
-// Content: D3DX11 Effects Header for ID3DX11Effect Implementation\r
-//\r
-//////////////////////////////////////////////////////////////////////////////\r
-\r
-#pragma once\r
-\r
-#include "EffectBinaryFormat.h"\r
-\r
-using namespace D3DX11Core;\r
-\r
-namespace D3DX11Effects\r
-{\r
-\r
-//////////////////////////////////////////////////////////////////////////\r
-// Forward defines\r
-//////////////////////////////////////////////////////////////////////////\r
-\r
-struct SBaseBlock;\r
-struct SShaderBlock;\r
-struct SPassBlock;\r
-struct SClassInstance;\r
-struct SInterface;\r
-struct SShaderResource;\r
-struct SUnorderedAccessView;\r
-struct SRenderTargetView;\r
-struct SDepthStencilView;\r
-struct SSamplerBlock;\r
-struct SDepthStencilBlock;\r
-struct SBlendBlock;\r
-struct SRasterizerBlock;\r
-struct SString;\r
-struct SD3DShaderVTable;\r
-struct SClassInstanceGlobalVariable;\r
-\r
-struct SAssignment;\r
-struct SVariable;\r
-struct SGlobalVariable;\r
-struct SAnnotation;\r
-struct SConstantBuffer;\r
-\r
-class CEffect;\r
-class CEffectLoader;\r
-\r
-enum ELhsType;\r
-\r
-// Allows the use of 32-bit and 64-bit timers depending on platform type\r
-typedef SIZE_T Timer;\r
-\r
-//////////////////////////////////////////////////////////////////////////\r
-// Reflection & Type structures\r
-//////////////////////////////////////////////////////////////////////////\r
-\r
-// CEffectMatrix is used internally instead of float arrays\r
-struct CEffectMatrix \r
-{\r
- union \r
- {\r
- struct \r
- {\r
- float _11, _12, _13, _14;\r
- float _21, _22, _23, _24;\r
- float _31, _32, _33, _34;\r
- float _41, _42, _43, _44;\r
-\r
- };\r
- float m[4][4];\r
- };\r
-};\r
-\r
-struct CEffectVector4 \r
-{\r
- float x;\r
- float y;\r
- float z;\r
- float w;\r
-};\r
-\r
-union UDataPointer\r
-{\r
- void *pGeneric;\r
- BYTE *pNumeric; \r
- float *pNumericFloat;\r
- UINT *pNumericDword;\r
- int *pNumericInt;\r
- BOOL *pNumericBool;\r
- SString *pString;\r
- SShaderBlock *pShader;\r
- SBaseBlock *pBlock;\r
- SBlendBlock *pBlend;\r
- SDepthStencilBlock *pDepthStencil;\r
- SRasterizerBlock *pRasterizer;\r
- SInterface *pInterface;\r
- SShaderResource *pShaderResource;\r
- SUnorderedAccessView *pUnorderedAccessView;\r
- SRenderTargetView *pRenderTargetView;\r
- SDepthStencilView *pDepthStencilView;\r
- SSamplerBlock *pSampler;\r
- CEffectVector4 *pVector;\r
- CEffectMatrix *pMatrix;\r
- UINT_PTR Offset;\r
-};\r
-\r
-enum EMemberDataType\r
-{\r
- MDT_ClassInstance,\r
- MDT_BlendState,\r
- MDT_DepthStencilState,\r
- MDT_RasterizerState,\r
- MDT_SamplerState,\r
- MDT_Buffer,\r
- MDT_ShaderResourceView,\r
-};\r
-\r
-struct SMemberDataPointer\r
-{\r
- EMemberDataType Type;\r
- union\r
- {\r
- IUnknown *pGeneric;\r
- ID3D11ClassInstance *pD3DClassInstance;\r
- ID3D11BlendState *pD3DEffectsManagedBlendState;\r
- ID3D11DepthStencilState *pD3DEffectsManagedDepthStencilState;\r
- ID3D11RasterizerState *pD3DEffectsManagedRasterizerState;\r
- ID3D11SamplerState *pD3DEffectsManagedSamplerState;\r
- ID3D11Buffer *pD3DEffectsManagedConstantBuffer;\r
- ID3D11ShaderResourceView*pD3DEffectsManagedTextureBuffer;\r
- } Data;\r
-};\r
-\r
-struct SType : public ID3DX11EffectType\r
-{ \r
- static const UINT_PTR c_InvalidIndex = (UINT) -1;\r
- static const UINT c_ScalarSize = sizeof(UINT);\r
-\r
- // packing rule constants\r
- static const UINT c_ScalarsPerRegister = 4;\r
- static const UINT c_RegisterSize = c_ScalarsPerRegister * c_ScalarSize; // must be a power of 2!! \r
- \r
- EVarType VarType; // numeric, object, struct\r
- UINT Elements; // # of array elements (0 for non-arrays)\r
- char *pTypeName; // friendly name of the type: "VS_OUTPUT", "float4", etc.\r
-\r
- // *Size and stride values are always 0 for object types\r
- // *Annotations adhere to packing rules (even though they do not reside in constant buffers)\r
- // for consistency's sake\r
- //\r
- // Packing rules:\r
- // *Structures and array elements are always register aligned\r
- // *Single-row values (or, for column major matrices, single-column) are greedily\r
- // packed unless doing so would span a register boundary, in which case they are\r
- // register aligned\r
-\r
- UINT TotalSize; // Total size of this data type in a constant buffer from\r
- // start to finish (padding in between elements is included,\r
- // but padding at the end is not since that would require\r
- // knowledge of the following data type).\r
-\r
- UINT Stride; // Number of bytes to advance between elements.\r
- // Typically a multiple of 16 for arrays, vectors, matrices.\r
- // For scalars and small vectors/matrices, this can be 4 or 8. \r
-\r
- UINT PackedSize; // Size, in bytes, of this data typed when fully packed\r
-\r
- union\r
- { \r
- SBinaryNumericType NumericType;\r
- EObjectType ObjectType; // not all values of EObjectType are valid here (e.g. constant buffer)\r
- struct\r
- {\r
- SVariable *pMembers; // array of type instances describing structure members\r
- UINT Members;\r
- bool ImplementsInterface; // true if this type implements an interface\r
- bool HasSuperClass; // true if this type has a parent class\r
- } StructType;\r
- void* InterfaceType; // nothing for interfaces\r
- };\r
-\r
-\r
- SType() :\r
- VarType(EVT_Invalid),\r
- Elements(0),\r
- pTypeName(NULL),\r
- TotalSize(0),\r
- Stride(0),\r
- PackedSize(0)\r
- {\r
- C_ASSERT( sizeof(NumericType) <= sizeof(StructType) );\r
- C_ASSERT( sizeof(ObjectType) <= sizeof(StructType) );\r
- C_ASSERT( sizeof(InterfaceType) <= sizeof(StructType) );\r
- ZeroMemory( &StructType, sizeof(StructType) );\r
- }\r
-\r
- BOOL IsEqual(SType *pOtherType) const;\r
- \r
- BOOL IsObjectType(EObjectType ObjType) const\r
- {\r
- return IsObjectTypeHelper(VarType, ObjectType, ObjType);\r
- }\r
- BOOL IsShader() const\r
- {\r
- return IsShaderHelper(VarType, ObjectType);\r
- }\r
- BOOL BelongsInConstantBuffer() const\r
- {\r
- return (VarType == EVT_Numeric) || (VarType == EVT_Struct);\r
- }\r
- BOOL IsStateBlockObject() const\r
- {\r
- return IsStateBlockObjectHelper(VarType, ObjectType);\r
- }\r
- BOOL IsClassInstance() const\r
- {\r
- return (VarType == EVT_Struct) && StructType.ImplementsInterface;\r
- }\r
- BOOL IsInterface() const\r
- {\r
- return IsInterfaceHelper(VarType, ObjectType);\r
- }\r
- BOOL IsShaderResource() const\r
- {\r
- return IsShaderResourceHelper(VarType, ObjectType);\r
- }\r
- BOOL IsUnorderedAccessView() const\r
- {\r
- return IsUnorderedAccessViewHelper(VarType, ObjectType);\r
- }\r
- BOOL IsSampler() const\r
- {\r
- return IsSamplerHelper(VarType, ObjectType);\r
- }\r
- BOOL IsRenderTargetView() const\r
- {\r
- return IsRenderTargetViewHelper(VarType, ObjectType);\r
- }\r
- BOOL IsDepthStencilView() const\r
- {\r
- return IsDepthStencilViewHelper(VarType, ObjectType);\r
- }\r
-\r
- UINT GetTotalUnpackedSize(BOOL IsSingleElement) const; \r
- UINT GetTotalPackedSize(BOOL IsSingleElement) const; \r
- HRESULT GetDescHelper(D3DX11_EFFECT_TYPE_DESC *pDesc, BOOL IsSingleElement) const;\r
-\r
- STDMETHOD_(BOOL, IsValid)() { return TRUE; }\r
- STDMETHOD(GetDesc)(D3DX11_EFFECT_TYPE_DESC *pDesc) { return GetDescHelper(pDesc, FALSE); }\r
- STDMETHOD_(ID3DX11EffectType*, GetMemberTypeByIndex)(UINT Index);\r
- STDMETHOD_(ID3DX11EffectType*, GetMemberTypeByName)(LPCSTR Name);\r
- STDMETHOD_(ID3DX11EffectType*, GetMemberTypeBySemantic)(LPCSTR Semantic);\r
- STDMETHOD_(LPCSTR, GetMemberName)(UINT Index);\r
- STDMETHOD_(LPCSTR, GetMemberSemantic)(UINT Index);\r
-};\r
-\r
-// Represents a type structure for a single element.\r
-// It seems pretty trivial, but it has a different virtual table which enables\r
-// us to accurately represent a type that consists of a single element\r
-struct SSingleElementType : public ID3DX11EffectType\r
-{\r
- SType *pType;\r
-\r
- STDMETHOD_(BOOL, IsValid)() { return TRUE; }\r
- STDMETHOD(GetDesc)(D3DX11_EFFECT_TYPE_DESC *pDesc) { return ((SType*)pType)->GetDescHelper(pDesc, TRUE); }\r
- STDMETHOD_(ID3DX11EffectType*, GetMemberTypeByIndex)(UINT Index) { return ((SType*)pType)->GetMemberTypeByIndex(Index); }\r
- STDMETHOD_(ID3DX11EffectType*, GetMemberTypeByName)(LPCSTR Name) { return ((SType*)pType)->GetMemberTypeByName(Name); }\r
- STDMETHOD_(ID3DX11EffectType*, GetMemberTypeBySemantic)(LPCSTR Semantic) { return ((SType*)pType)->GetMemberTypeBySemantic(Semantic); }\r
- STDMETHOD_(LPCSTR, GetMemberName)(UINT Index) { return ((SType*)pType)->GetMemberName(Index); }\r
- STDMETHOD_(LPCSTR, GetMemberSemantic)(UINT Index) { return ((SType*)pType)->GetMemberSemantic(Index); }\r
-};\r
-\r
-//////////////////////////////////////////////////////////////////////////\r
-// Block definitions\r
-//////////////////////////////////////////////////////////////////////////\r
-\r
-void * GetBlockByIndex(EVarType VarType, EObjectType ObjectType, void *pBaseBlock, UINT Index);\r
-\r
-struct SBaseBlock\r
-{\r
- EBlockType BlockType;\r
-\r
- BOOL IsUserManaged:1;\r
-\r
- UINT AssignmentCount;\r
- SAssignment *pAssignments;\r
-\r
- SBaseBlock();\r
-\r
- BOOL ApplyAssignments(CEffect *pEffect);\r
-\r
- D3DX11INLINE SSamplerBlock *AsSampler() const\r
- {\r
- D3DXASSERT( BlockType == EBT_Sampler );\r
- return (SSamplerBlock*) this;\r
- }\r
-\r
- D3DX11INLINE SDepthStencilBlock *AsDepthStencil() const\r
- {\r
- D3DXASSERT( BlockType == EBT_DepthStencil );\r
- return (SDepthStencilBlock*) this;\r
- }\r
-\r
- D3DX11INLINE SBlendBlock *AsBlend() const\r
- {\r
- D3DXASSERT( BlockType == EBT_Blend );\r
- return (SBlendBlock*) this;\r
- }\r
-\r
- D3DX11INLINE SRasterizerBlock *AsRasterizer() const\r
- {\r
- D3DXASSERT( BlockType == EBT_Rasterizer );\r
- return (SRasterizerBlock*) this;\r
- }\r
-\r
- D3DX11INLINE SPassBlock *AsPass() const\r
- {\r
- D3DXASSERT( BlockType == EBT_Pass );\r
- return (SPassBlock*) this;\r
- }\r
-};\r
-\r
-struct STechnique : public ID3DX11EffectTechnique\r
-{\r
- char *pName;\r
-\r
- UINT PassCount;\r
- SPassBlock *pPasses;\r
-\r
- UINT AnnotationCount;\r
- SAnnotation *pAnnotations;\r
-\r
- BOOL InitiallyValid;\r
- BOOL HasDependencies;\r
-\r
- STechnique();\r
-\r
- STDMETHOD_(BOOL, IsValid)();\r
- STDMETHOD(GetDesc)(D3DX11_TECHNIQUE_DESC *pDesc);\r
-\r
- STDMETHOD_(ID3DX11EffectVariable*, GetAnnotationByIndex)(UINT Index);\r
- STDMETHOD_(ID3DX11EffectVariable*, GetAnnotationByName)(LPCSTR Name);\r
-\r
- STDMETHOD_(ID3DX11EffectPass*, GetPassByIndex)(UINT Index);\r
- STDMETHOD_(ID3DX11EffectPass*, GetPassByName)(LPCSTR Name);\r
-\r
- STDMETHOD(ComputeStateBlockMask)(D3DX11_STATE_BLOCK_MASK *pStateBlockMask);\r
-};\r
-\r
-struct SGroup : public ID3DX11EffectGroup\r
-{\r
- char *pName;\r
-\r
- UINT TechniqueCount;\r
- STechnique *pTechniques;\r
-\r
- UINT AnnotationCount;\r
- SAnnotation *pAnnotations;\r
-\r
- BOOL InitiallyValid;\r
- BOOL HasDependencies;\r
-\r
- SGroup();\r
-\r
- STDMETHOD_(BOOL, IsValid)();\r
- STDMETHOD(GetDesc)(D3DX11_GROUP_DESC *pDesc);\r
-\r
- STDMETHOD_(ID3DX11EffectVariable*, GetAnnotationByIndex)(UINT Index);\r
- STDMETHOD_(ID3DX11EffectVariable*, GetAnnotationByName)(LPCSTR Name);\r
-\r
- STDMETHOD_(ID3DX11EffectTechnique*, GetTechniqueByIndex)(UINT Index);\r
- STDMETHOD_(ID3DX11EffectTechnique*, GetTechniqueByName)(LPCSTR Name);\r
-};\r
-\r
-struct SPassBlock : SBaseBlock, public ID3DX11EffectPass\r
-{\r
- struct\r
- {\r
- ID3D11BlendState* pBlendState;\r
- FLOAT BlendFactor[4];\r
- UINT SampleMask;\r
- ID3D11DepthStencilState *pDepthStencilState;\r
- UINT StencilRef;\r
- union\r
- {\r
- D3D11_SO_DECLARATION_ENTRY *pEntry;\r
- char *pEntryDesc;\r
- } GSSODesc;\r
-\r
- // Pass assignments can write directly into these\r
- SBlendBlock *pBlendBlock;\r
- SDepthStencilBlock *pDepthStencilBlock;\r
- SRasterizerBlock *pRasterizerBlock;\r
- UINT RenderTargetViewCount;\r
- SRenderTargetView *pRenderTargetViews[D3D11_SIMULTANEOUS_RENDER_TARGET_COUNT];\r
- SDepthStencilView *pDepthStencilView;\r
- SShaderBlock *pVertexShaderBlock;\r
- SShaderBlock *pPixelShaderBlock;\r
- SShaderBlock *pGeometryShaderBlock;\r
- SShaderBlock *pComputeShaderBlock;\r
- SShaderBlock *pDomainShaderBlock;\r
- SShaderBlock *pHullShaderBlock;\r
- } BackingStore;\r
-\r
- char *pName;\r
-\r
- UINT AnnotationCount;\r
- SAnnotation *pAnnotations;\r
-\r
- CEffect *pEffect;\r
-\r
- BOOL InitiallyValid; // validity of all state objects and shaders in pass upon BindToDevice\r
- BOOL HasDependencies; // if pass expressions or pass state blocks have dependencies on variables (if true, IsValid != InitiallyValid possibly)\r
-\r
- SPassBlock();\r
-\r
- void ApplyPassAssignments();\r
- BOOL CheckShaderDependencies( SShaderBlock* pBlock );\r
- BOOL CheckDependencies();\r
-\r
- template<EObjectType EShaderType>\r
- HRESULT GetShaderDescHelper(D3DX11_PASS_SHADER_DESC *pDesc);\r
-\r
- STDMETHOD_(BOOL, IsValid)();\r
- STDMETHOD(GetDesc)(D3DX11_PASS_DESC *pDesc);\r
-\r
- STDMETHOD(GetVertexShaderDesc)(D3DX11_PASS_SHADER_DESC *pDesc);\r
- STDMETHOD(GetGeometryShaderDesc)(D3DX11_PASS_SHADER_DESC *pDesc);\r
- STDMETHOD(GetPixelShaderDesc)(D3DX11_PASS_SHADER_DESC *pDesc);\r
- STDMETHOD(GetHullShaderDesc)(D3DX11_PASS_SHADER_DESC *pDesc);\r
- STDMETHOD(GetDomainShaderDesc)(D3DX11_PASS_SHADER_DESC *pDesc);\r
- STDMETHOD(GetComputeShaderDesc)(D3DX11_PASS_SHADER_DESC *pDesc);\r
-\r
- STDMETHOD_(ID3DX11EffectVariable*, GetAnnotationByIndex)(UINT Index);\r
- STDMETHOD_(ID3DX11EffectVariable*, GetAnnotationByName)(LPCSTR Name);\r
-\r
- STDMETHOD(Apply)(UINT Flags, ID3D11DeviceContext* pContext);\r
- \r
- STDMETHOD(ComputeStateBlockMask)(D3DX11_STATE_BLOCK_MASK *pStateBlockMask);\r
-};\r
-\r
-struct SDepthStencilBlock : SBaseBlock\r
-{\r
- ID3D11DepthStencilState *pDSObject;\r
- D3D11_DEPTH_STENCIL_DESC BackingStore;\r
- BOOL IsValid;\r
-\r
- SDepthStencilBlock();\r
-};\r
-\r
-struct SBlendBlock : SBaseBlock\r
-{\r
- ID3D11BlendState *pBlendObject;\r
- D3D11_BLEND_DESC BackingStore;\r
- BOOL IsValid;\r
-\r
- SBlendBlock();\r
-};\r
-\r
-struct SRasterizerBlock : SBaseBlock\r
-{\r
- ID3D11RasterizerState *pRasterizerObject;\r
- D3D11_RASTERIZER_DESC BackingStore;\r
- BOOL IsValid;\r
-\r
- SRasterizerBlock();\r
-};\r
-\r
-struct SSamplerBlock : SBaseBlock\r
-{\r
- ID3D11SamplerState *pD3DObject;\r
- struct\r
- {\r
- D3D11_SAMPLER_DESC SamplerDesc;\r
- // Sampler "TEXTURE" assignments can write directly into this\r
- SShaderResource *pTexture;\r
- } BackingStore;\r
-\r
- SSamplerBlock();\r
-};\r
-\r
-struct SInterface\r
-{\r
- SClassInstanceGlobalVariable* pClassInstance;\r
-\r
- SInterface()\r
- {\r
- pClassInstance = NULL;\r
- }\r
-};\r
-\r
-struct SShaderResource\r
-{\r
- ID3D11ShaderResourceView *pShaderResource;\r
-\r
- SShaderResource() \r
- {\r
- pShaderResource = NULL;\r
- }\r
-\r
-};\r
-\r
-struct SUnorderedAccessView\r
-{\r
- ID3D11UnorderedAccessView *pUnorderedAccessView;\r
-\r
- SUnorderedAccessView() \r
- {\r
- pUnorderedAccessView = NULL;\r
- }\r
-\r
-};\r
-\r
-struct SRenderTargetView\r
-{\r
- ID3D11RenderTargetView *pRenderTargetView;\r
-\r
- SRenderTargetView();\r
-};\r
-\r
-struct SDepthStencilView\r
-{\r
- ID3D11DepthStencilView *pDepthStencilView;\r
-\r
- SDepthStencilView();\r
-};\r
-\r
-\r
-template<class T, class D3DTYPE> struct SShaderDependency\r
-{\r
- UINT StartIndex;\r
- UINT Count;\r
-\r
- T *ppFXPointers; // Array of ptrs to FX objects (CBs, SShaderResources, etc)\r
- D3DTYPE *ppD3DObjects; // Array of ptrs to matching D3D objects\r
-\r
- SShaderDependency()\r
- {\r
- StartIndex = Count = 0;\r
-\r
- ppD3DObjects = NULL;\r
- ppFXPointers = NULL;\r
- }\r
-};\r
-\r
-typedef SShaderDependency<SConstantBuffer*, ID3D11Buffer*> SShaderCBDependency;\r
-typedef SShaderDependency<SSamplerBlock*, ID3D11SamplerState*> SShaderSamplerDependency;\r
-typedef SShaderDependency<SShaderResource*, ID3D11ShaderResourceView*> SShaderResourceDependency;\r
-typedef SShaderDependency<SUnorderedAccessView*, ID3D11UnorderedAccessView*> SUnorderedAccessViewDependency;\r
-typedef SShaderDependency<SInterface*, ID3D11ClassInstance*> SInterfaceDependency;\r
-\r
-// Shader VTables are used to eliminate branching in ApplyShaderBlock.\r
-// The effect owns three D3DShaderVTables, one for PS, one for VS, and one for GS.\r
-struct SD3DShaderVTable\r
-{\r
- void ( __stdcall ID3D11DeviceContext::*pSetShader)(ID3D11DeviceChild* pShader, ID3D11ClassInstance*const* ppClassInstances, UINT NumClassInstances);\r
- void ( __stdcall ID3D11DeviceContext::*pSetConstantBuffers)(UINT StartConstantSlot, UINT NumBuffers, ID3D11Buffer *const *pBuffers);\r
- void ( __stdcall ID3D11DeviceContext::*pSetSamplers)(UINT Offset, UINT NumSamplers, ID3D11SamplerState*const* pSamplers);\r
- void ( __stdcall ID3D11DeviceContext::*pSetShaderResources)(UINT Offset, UINT NumResources, ID3D11ShaderResourceView *const *pResources);\r
- HRESULT ( __stdcall ID3D11Device::*pCreateShader)(const void *pShaderBlob, SIZE_T ShaderBlobSize, ID3D11ClassLinkage* pClassLinkage, ID3D11DeviceChild **ppShader);\r
-};\r
-\r
-\r
-struct SShaderBlock\r
-{\r
- enum ESigType\r
- {\r
- ST_Input,\r
- ST_Output,\r
- ST_PatchConstant,\r
- };\r
-\r
- struct SInterfaceParameter\r
- {\r
- char *pName;\r
- UINT Index;\r
- };\r
-\r
- // this data is classified as reflection-only and will all be discarded at runtime\r
- struct SReflectionData\r
- {\r
- BYTE *pBytecode;\r
- UINT BytecodeLength;\r
- char *pStreamOutDecls[4]; // set with ConstructGSWithSO\r
- UINT RasterizedStream; // set with ConstructGSWithSO\r
- BOOL IsNullGS;\r
- ID3D11ShaderReflection *pReflection;\r
- UINT InterfaceParameterCount; // set with BindInterfaces (used for function interface parameters)\r
- SInterfaceParameter *pInterfaceParameters; // set with BindInterfaces (used for function interface parameters)\r
- };\r
-\r
- BOOL IsValid;\r
- SD3DShaderVTable *pVT; \r
-\r
- // This value is NULL if the shader is NULL or was never initialized\r
- SReflectionData *pReflectionData;\r
-\r
- ID3D11DeviceChild *pD3DObject;\r
-\r
- UINT CBDepCount;\r
- SShaderCBDependency *pCBDeps;\r
-\r
- UINT SampDepCount;\r
- SShaderSamplerDependency *pSampDeps;\r
-\r
- UINT InterfaceDepCount;\r
- SInterfaceDependency *pInterfaceDeps;\r
-\r
- UINT ResourceDepCount;\r
- SShaderResourceDependency *pResourceDeps;\r
-\r
- UINT UAVDepCount;\r
- SUnorderedAccessViewDependency *pUAVDeps;\r
-\r
- UINT TBufferDepCount;\r
- SConstantBuffer **ppTbufDeps;\r
-\r
- ID3DBlob *pInputSignatureBlob; // The input signature is separated from the bytecode because it \r
- // is always available, even after Optimize() has been called.\r
-\r
- SShaderBlock(SD3DShaderVTable *pVirtualTable = NULL);\r
-\r
- EObjectType GetShaderType();\r
-\r
- HRESULT OnDeviceBind();\r
-\r
- // Public API helpers\r
- HRESULT ComputeStateBlockMask(D3DX11_STATE_BLOCK_MASK *pStateBlockMask);\r
-\r
- HRESULT GetShaderDesc(D3DX11_EFFECT_SHADER_DESC *pDesc, BOOL IsInline);\r
-\r
- HRESULT GetVertexShader(ID3D11VertexShader **ppVS);\r
- HRESULT GetGeometryShader(ID3D11GeometryShader **ppGS);\r
- HRESULT GetPixelShader(ID3D11PixelShader **ppPS);\r
- HRESULT GetHullShader(ID3D11HullShader **ppPS);\r
- HRESULT GetDomainShader(ID3D11DomainShader **ppPS);\r
- HRESULT GetComputeShader(ID3D11ComputeShader **ppPS);\r
-\r
- HRESULT GetSignatureElementDesc(ESigType SigType, UINT Element, D3D11_SIGNATURE_PARAMETER_DESC *pDesc);\r
-};\r
-\r
-\r
-\r
-struct SString\r
-{\r
- char *pString;\r
-\r
- SString();\r
-};\r
-\r
-\r
-\r
-//////////////////////////////////////////////////////////////////////////\r
-// Global Variable & Annotation structure/interface definitions\r
-//////////////////////////////////////////////////////////////////////////\r
-\r
-//\r
-// This is a general structure that can describe\r
-// annotations, variables, and structure members\r
-//\r
-struct SVariable\r
-{\r
- // For annotations/variables/variable members:\r
- // 1) If numeric, pointer to data (for variables: points into backing store,\r
- // for annotations, points into reflection heap)\r
- // OR\r
- // 2) If object, pointer to the block. If object array, subsequent array elements are found in\r
- // contiguous blocks; the Nth block is found by ((<SpecificBlockType> *) pBlock) + N\r
- // (this is because variables that are arrays of objects have their blocks allocated contiguously)\r
- //\r
- // For structure members:\r
- // Offset of this member (in bytes) from parent structure (structure members must be numeric/struct)\r
- UDataPointer Data;\r
- union\r
- {\r
- UINT MemberDataOffsetPlus4; // 4 added so that 0 == NULL can represent "unused"\r
- SMemberDataPointer *pMemberData;\r
- };\r
-\r
- SType *pType;\r
- char *pName;\r
- char *pSemantic;\r
- UINT ExplicitBindPoint;\r
-\r
- SVariable()\r
- {\r
- ZeroMemory(this, sizeof(*this));\r
- ExplicitBindPoint = -1;\r
- }\r
-};\r
-\r
-// Template definitions for all of the various ID3DX11EffectVariable specializations\r
-#include "EffectVariable.inl"\r
-\r
-\r
-////////////////////////////////////////////////////////////////////////////////\r
-// ID3DX11EffectShaderVariable (SAnonymousShader implementation)\r
-////////////////////////////////////////////////////////////////////////////////\r
-\r
-struct SAnonymousShader : public TUncastableVariable<ID3DX11EffectShaderVariable>, public ID3DX11EffectType\r
-{\r
- SShaderBlock *pShaderBlock;\r
-\r
- SAnonymousShader(SShaderBlock *pBlock = NULL);\r
-\r
- // ID3DX11EffectShaderVariable interface\r
- STDMETHOD_(BOOL, IsValid)();\r
- STDMETHOD_(ID3DX11EffectType*, GetType)();\r
- STDMETHOD(GetDesc)(D3DX11_EFFECT_VARIABLE_DESC *pDesc);\r
-\r
- STDMETHOD_(ID3DX11EffectVariable*, GetAnnotationByIndex)(UINT Index);\r
- STDMETHOD_(ID3DX11EffectVariable*, GetAnnotationByName)(LPCSTR Name);\r
-\r
- STDMETHOD_(ID3DX11EffectVariable*, GetMemberByIndex)(UINT Index);\r
- STDMETHOD_(ID3DX11EffectVariable*, GetMemberByName)(LPCSTR Name);\r
- STDMETHOD_(ID3DX11EffectVariable*, GetMemberBySemantic)(LPCSTR Semantic);\r
-\r
- STDMETHOD_(ID3DX11EffectVariable*, GetElement)(UINT Index);\r
-\r
- STDMETHOD_(ID3DX11EffectConstantBuffer*, GetParentConstantBuffer)();\r
-\r
- // other casts are handled by TUncastableVariable\r
- STDMETHOD_(ID3DX11EffectShaderVariable*, AsShader)();\r
-\r
- STDMETHOD(SetRawValue)(CONST void *pData, UINT Offset, UINT Count);\r
- STDMETHOD(GetRawValue)(__out_bcount(Count) void *pData, UINT Offset, UINT Count);\r
-\r
- STDMETHOD(GetShaderDesc)(UINT ShaderIndex, D3DX11_EFFECT_SHADER_DESC *pDesc);\r
-\r
- STDMETHOD(GetVertexShader)(UINT ShaderIndex, ID3D11VertexShader **ppVS);\r
- STDMETHOD(GetGeometryShader)(UINT ShaderIndex, ID3D11GeometryShader **ppGS);\r
- STDMETHOD(GetPixelShader)(UINT ShaderIndex, ID3D11PixelShader **ppPS);\r
- STDMETHOD(GetHullShader)(UINT ShaderIndex, ID3D11HullShader **ppPS);\r
- STDMETHOD(GetDomainShader)(UINT ShaderIndex, ID3D11DomainShader **ppPS);\r
- STDMETHOD(GetComputeShader)(UINT ShaderIndex, ID3D11ComputeShader **ppPS);\r
-\r
- STDMETHOD(GetInputSignatureElementDesc)(UINT ShaderIndex, UINT Element, D3D11_SIGNATURE_PARAMETER_DESC *pDesc);\r
- STDMETHOD(GetOutputSignatureElementDesc)(UINT ShaderIndex, UINT Element, D3D11_SIGNATURE_PARAMETER_DESC *pDesc);\r
- STDMETHOD(GetPatchConstantSignatureElementDesc)(UINT ShaderIndex, UINT Element, D3D11_SIGNATURE_PARAMETER_DESC *pDesc);\r
-\r
- // ID3DX11EffectType interface\r
- STDMETHOD(GetDesc)(D3DX11_EFFECT_TYPE_DESC *pDesc);\r
- STDMETHOD_(ID3DX11EffectType*, GetMemberTypeByIndex)(UINT Index);\r
- STDMETHOD_(ID3DX11EffectType*, GetMemberTypeByName)(LPCSTR Name);\r
- STDMETHOD_(ID3DX11EffectType*, GetMemberTypeBySemantic)(LPCSTR Semantic);\r
-\r
- STDMETHOD_(LPCSTR, GetMemberName)(UINT Index);\r
- STDMETHOD_(LPCSTR, GetMemberSemantic)(UINT Index);\r
-};\r
-\r
-////////////////////////////////////////////////////////////////////////////////\r
-// ID3DX11EffectConstantBuffer (SConstantBuffer implementation)\r
-////////////////////////////////////////////////////////////////////////////////\r
-\r
-struct SConstantBuffer : public TUncastableVariable<ID3DX11EffectConstantBuffer>, public ID3DX11EffectType\r
-{\r
- ID3D11Buffer *pD3DObject;\r
- SShaderResource TBuffer; // NULL iff IsTbuffer == FALSE\r
-\r
- BYTE *pBackingStore;\r
- UINT Size; // in bytes\r
-\r
- char *pName;\r
-\r
- UINT AnnotationCount;\r
- SAnnotation *pAnnotations;\r
-\r
- UINT VariableCount; // # of variables contained in this cbuffer\r
- SGlobalVariable *pVariables; // array of size [VariableCount], points into effect's contiguous variable list\r
- UINT ExplicitBindPoint; // Used when a CB has been explicitly bound (register(bXX)). -1 if not\r
-\r
- BOOL IsDirty:1; // Set when any member is updated; cleared on CB apply \r
- BOOL IsTBuffer:1; // TRUE iff TBuffer.pShaderResource != NULL\r
- BOOL IsUserManaged:1; // Set if you don't want effects to update this buffer\r
- BOOL IsEffectOptimized:1;// Set if the effect has been optimized\r
- BOOL IsUsedByExpression:1;// Set if used by any expressions\r
- BOOL IsUserPacked:1; // Set if the elements have user-specified offsets\r
- BOOL IsSingle:1; // Set to true if you want to share this CB with cloned Effects\r
- BOOL IsNonUpdatable:1; // Set to true if you want to share this CB with cloned Effects\r
-\r
- union\r
- {\r
- // These are used to store the original ID3D11Buffer* for use in UndoSetConstantBuffer\r
- UINT MemberDataOffsetPlus4; // 4 added so that 0 == NULL can represent "unused"\r
- SMemberDataPointer *pMemberData;\r
- };\r
-\r
- CEffect *pEffect;\r
-\r
- SConstantBuffer()\r
- {\r
- pD3DObject = NULL;\r
- ZeroMemory(&TBuffer, sizeof(TBuffer));\r
- ExplicitBindPoint = -1;\r
- pBackingStore = NULL;\r
- Size = 0;\r
- pName = NULL;\r
- VariableCount = 0;\r
- pVariables = NULL;\r
- AnnotationCount = 0;\r
- pAnnotations = NULL;\r
- IsDirty = FALSE;\r
- IsTBuffer = FALSE;\r
- IsUserManaged = FALSE;\r
- IsEffectOptimized = FALSE;\r
- IsUsedByExpression = FALSE;\r
- IsUserPacked = FALSE;\r
- IsSingle = FALSE;\r
- IsNonUpdatable = FALSE;\r
- pEffect = NULL;\r
- }\r
-\r
- bool ClonedSingle() const;\r
-\r
- // ID3DX11EffectConstantBuffer interface\r
- STDMETHOD_(BOOL, IsValid)();\r
- STDMETHOD_(ID3DX11EffectType*, GetType)();\r
- STDMETHOD(GetDesc)(D3DX11_EFFECT_VARIABLE_DESC *pDesc);\r
-\r
- STDMETHOD_(ID3DX11EffectVariable*, GetAnnotationByIndex)(UINT Index);\r
- STDMETHOD_(ID3DX11EffectVariable*, GetAnnotationByName)(LPCSTR Name);\r
-\r
- STDMETHOD_(ID3DX11EffectVariable*, GetMemberByIndex)(UINT Index);\r
- STDMETHOD_(ID3DX11EffectVariable*, GetMemberByName)(LPCSTR Name);\r
- STDMETHOD_(ID3DX11EffectVariable*, GetMemberBySemantic)(LPCSTR Semantic);\r
-\r
- STDMETHOD_(ID3DX11EffectVariable*, GetElement)(UINT Index);\r
-\r
- STDMETHOD_(ID3DX11EffectConstantBuffer*, GetParentConstantBuffer)();\r
-\r
- // other casts are handled by TUncastableVariable\r
- STDMETHOD_(ID3DX11EffectConstantBuffer*, AsConstantBuffer)();\r
-\r
- STDMETHOD(SetRawValue)(CONST void *pData, UINT Offset, UINT Count);\r
- STDMETHOD(GetRawValue)(__out_bcount(Count) void *pData, UINT Offset, UINT Count);\r
-\r
- STDMETHOD(SetConstantBuffer)(ID3D11Buffer *pConstantBuffer);\r
- STDMETHOD(GetConstantBuffer)(ID3D11Buffer **ppConstantBuffer);\r
- STDMETHOD(UndoSetConstantBuffer)();\r
-\r
- STDMETHOD(SetTextureBuffer)(ID3D11ShaderResourceView *pTextureBuffer);\r
- STDMETHOD(GetTextureBuffer)(ID3D11ShaderResourceView **ppTextureBuffer);\r
- STDMETHOD(UndoSetTextureBuffer)();\r
-\r
- // ID3DX11EffectType interface\r
- STDMETHOD(GetDesc)(D3DX11_EFFECT_TYPE_DESC *pDesc);\r
- STDMETHOD_(ID3DX11EffectType*, GetMemberTypeByIndex)(UINT Index);\r
- STDMETHOD_(ID3DX11EffectType*, GetMemberTypeByName)(LPCSTR Name);\r
- STDMETHOD_(ID3DX11EffectType*, GetMemberTypeBySemantic)(LPCSTR Semantic);\r
-\r
- STDMETHOD_(LPCSTR, GetMemberName)(UINT Index);\r
- STDMETHOD_(LPCSTR, GetMemberSemantic)(UINT Index);\r
-};\r
-\r
-\r
-//////////////////////////////////////////////////////////////////////////\r
-// Assignments\r
-//////////////////////////////////////////////////////////////////////////\r
-\r
-enum ERuntimeAssignmentType\r
-{\r
- ERAT_Invalid,\r
- // [Destination] refers to the destination location, which is always the backing store of the pass/state block. \r
- // [Source] refers to the current source of data, always coming from either a constant buffer's \r
- // backing store (for numeric assignments), an object variable's block array, or an anonymous (unowned) block\r
-\r
- // Numeric variables:\r
- ERAT_Constant, // Source is unused.\r
- // No dependencies; this assignment can be safely removed after load.\r
- ERAT_NumericVariable, // Source points to the CB's backing store where the value lives.\r
- // 1 dependency: the variable itself.\r
- ERAT_NumericConstIndex, // Source points to the CB's backing store where the value lives, offset by N.\r
- // 1 dependency: the variable array being indexed.\r
- ERAT_NumericVariableIndex, // Source points to the last used element of the variable in the CB's backing store.\r
- // 2 dependencies: the index variable followed by the array variable.\r
-\r
- // Object variables:\r
- ERAT_ObjectInlineShader, // An anonymous, immutable shader block pointer is copied to the destination immediately.\r
- // No dependencies; this assignment can be safely removed after load.\r
- ERAT_ObjectVariable, // A pointer to the block owned by the object variable is copied to the destination immediately.\r
- // No dependencies; this assignment can be safely removed after load.\r
- ERAT_ObjectConstIndex, // A pointer to the Nth block owned by an object variable is copied to the destination immediately.\r
- // No dependencies; this assignment can be safely removed after load.\r
- ERAT_ObjectVariableIndex, // Source points to the first block owned by an object variable array\r
- // (the offset from this, N, is taken from another variable).\r
- // 1 dependency: the variable being used to index the array.\r
-};\r
-\r
-struct SAssignment\r
-{\r
- struct SDependency\r
- {\r
- SGlobalVariable *pVariable;\r
-\r
- SDependency()\r
- {\r
- pVariable = NULL;\r
- }\r
- };\r
-\r
- ELhsType LhsType; // PS, VS, DepthStencil etc.\r
-\r
- // The value of SAssignment.AssignmentType determines how the other fields behave\r
- // (DependencyCount, pDependencies, Destination, and Source)\r
- ERuntimeAssignmentType AssignmentType; \r
-\r
- Timer LastRecomputedTime;\r
-\r
- // see comments in ERuntimeAssignmentType for how dependencies and data pointers are handled\r
- UINT DependencyCount;\r
- SDependency *pDependencies;\r
-\r
- UDataPointer Destination; // This value never changes after load, and always refers to the backing store\r
- UDataPointer Source; // This value, on the other hand, can change if variable- or expression- driven\r
-\r
- UINT DataSize : 16; // Size of the data element to be copied in bytes (if numeric) or\r
- // stride of the block type (if object)\r
- UINT MaxElements : 16; // Max allowable index (needed because we don't store object arrays as dependencies,\r
- // and therefore have no way of getting their Element count)\r
-\r
- BOOL IsObjectAssignment() // True for Shader and RObject assignments (the type that appear in pass blocks)\r
- {\r
- return IsObjectAssignmentHelper(LhsType);\r
- }\r
-\r
- SAssignment()\r
- {\r
- LhsType = ELHS_Invalid;\r
- AssignmentType = ERAT_Invalid;\r
-\r
- Destination.pGeneric = NULL;\r
- Source.pGeneric = NULL;\r
-\r
- LastRecomputedTime = 0;\r
- DependencyCount = 0;\r
- pDependencies = NULL;\r
-\r
- DataSize = 0;\r
- }\r
-};\r
-\r
-//////////////////////////////////////////////////////////////////////////\r
-// Private effect heaps\r
-//////////////////////////////////////////////////////////////////////////\r
-\r
-// Used to efficiently reallocate data\r
-// 1) For every piece of data that needs reallocation, move it to its new location\r
-// and add an entry into the table\r
-// 2) For everyone that references one of these data blocks, do a quick table lookup\r
-// to find the old pointer and then replace it with the new one\r
-struct SPointerMapping\r
-{\r
- void *pOld;\r
- void *pNew;\r
-\r
- static BOOL AreMappingsEqual(const SPointerMapping &pMap1, const SPointerMapping &pMap2)\r
- {\r
- return (pMap1.pOld == pMap2.pOld);\r
- }\r
-\r
- UINT Hash()\r
- {\r
- // hash the pointer itself \r
- // (using the pointer as a hash would be very bad)\r
- return ComputeHash((BYTE*)&pOld, sizeof(pOld));\r
- }\r
-};\r
-\r
-typedef CEffectHashTableWithPrivateHeap<SPointerMapping, SPointerMapping::AreMappingsEqual> CPointerMappingTable;\r
-\r
-// Assist adding data to a block of memory\r
-class CEffectHeap\r
-{\r
-protected:\r
- BYTE *m_pData;\r
- UINT m_dwBufferSize;\r
- UINT m_dwSize;\r
-\r
- template <bool bCopyData>\r
- HRESULT AddDataInternal(const void *pData, UINT dwSize, void **ppPointer);\r
-\r
-public:\r
- HRESULT ReserveMemory(UINT dwSize);\r
- UINT GetSize();\r
- BYTE* GetDataStart() { return m_pData; }\r
-\r
- // AddData and AddString append existing data to the buffer - they change m_dwSize. Users are \r
- // not expected to modify the data pointed to by the return pointer\r
- HRESULT AddString(const char *pString, __deref_out_z char **ppPointer);\r
- HRESULT AddData(const void *pData, UINT dwSize, void **ppPointer);\r
-\r
- // Allocate behaves like a standard new - it will allocate memory, move m_dwSize. The caller is \r
- // expected to use the returned pointer\r
- void* Allocate(UINT dwSize);\r
-\r
- // Move data from the general heap and optional free memory\r
- HRESULT MoveData(void **ppData, UINT size);\r
- HRESULT MoveString(__deref_inout_z char **ppStringData);\r
- HRESULT MoveInterfaceParameters(UINT InterfaceCount, __in_ecount(1) SShaderBlock::SInterfaceParameter **ppInterfaces);\r
- HRESULT MoveEmptyDataBlock(void **ppData, UINT size);\r
-\r
- BOOL IsInHeap(void *pData) const\r
- {\r
- return (pData >= m_pData && pData < (m_pData + m_dwBufferSize));\r
- }\r
-\r
- CEffectHeap();\r
- ~CEffectHeap();\r
-};\r
-\r
-class CEffectReflection\r
-{\r
-public:\r
- // Single memory block support\r
- CEffectHeap m_Heap;\r
-};\r
-\r
-\r
-class CEffect : public ID3DX11Effect\r
-{\r
- friend struct SBaseBlock;\r
- friend struct SPassBlock;\r
- friend class CEffectLoader;\r
- friend struct SConstantBuffer;\r
- friend struct TSamplerVariable<TGlobalVariable<ID3DX11EffectSamplerVariable>>;\r
- friend struct TSamplerVariable<TVariable<TMember<ID3DX11EffectSamplerVariable>>>;\r
- \r
-protected:\r
-\r
- UINT m_RefCount;\r
- UINT m_Flags;\r
-\r
- // Private heap - all pointers should point into here\r
- CEffectHeap m_Heap;\r
-\r
- // Reflection object\r
- CEffectReflection *m_pReflection;\r
-\r
- // global variables in the effect (aka parameters)\r
- UINT m_VariableCount;\r
- SGlobalVariable *m_pVariables;\r
-\r
- // anonymous shader variables (one for every inline shader assignment)\r
- UINT m_AnonymousShaderCount;\r
- SAnonymousShader *m_pAnonymousShaders;\r
-\r
- // techniques within this effect (the actual data is located in each group)\r
- UINT m_TechniqueCount;\r
-\r
- // groups within this effect\r
- UINT m_GroupCount;\r
- SGroup *m_pGroups;\r
- SGroup *m_pNullGroup;\r
-\r
- UINT m_ShaderBlockCount;\r
- SShaderBlock *m_pShaderBlocks;\r
-\r
- UINT m_DepthStencilBlockCount;\r
- SDepthStencilBlock *m_pDepthStencilBlocks;\r
-\r
- UINT m_BlendBlockCount;\r
- SBlendBlock *m_pBlendBlocks;\r
-\r
- UINT m_RasterizerBlockCount;\r
- SRasterizerBlock *m_pRasterizerBlocks;\r
-\r
- UINT m_SamplerBlockCount;\r
- SSamplerBlock *m_pSamplerBlocks;\r
-\r
- UINT m_MemberDataCount;\r
- SMemberDataPointer *m_pMemberDataBlocks;\r
-\r
- UINT m_InterfaceCount;\r
- SInterface *m_pInterfaces;\r
-\r
- UINT m_CBCount;\r
- SConstantBuffer *m_pCBs;\r
-\r
- UINT m_StringCount;\r
- SString *m_pStrings;\r
-\r
- UINT m_ShaderResourceCount;\r
- SShaderResource *m_pShaderResources;\r
-\r
- UINT m_UnorderedAccessViewCount;\r
- SUnorderedAccessView *m_pUnorderedAccessViews;\r
-\r
- UINT m_RenderTargetViewCount;\r
- SRenderTargetView *m_pRenderTargetViews;\r
-\r
- UINT m_DepthStencilViewCount;\r
- SDepthStencilView *m_pDepthStencilViews; \r
-\r
- Timer m_LocalTimer;\r
- \r
- // temporary index variable for assignment evaluation\r
- UINT m_FXLIndex;\r
-\r
- ID3D11Device *m_pDevice;\r
- ID3D11DeviceContext *m_pContext;\r
- ID3D11ClassLinkage *m_pClassLinkage;\r
-\r
- // Master lists of reflection interfaces\r
- CEffectVectorOwner<SSingleElementType> m_pTypeInterfaces;\r
- CEffectVectorOwner<SMember> m_pMemberInterfaces;\r
-\r
- ////////////////////////////////////////////////////////////////////////// \r
- // String & Type pooling\r
-\r
- typedef SType *LPSRUNTIMETYPE;\r
- static BOOL AreTypesEqual(const LPSRUNTIMETYPE &pType1, const LPSRUNTIMETYPE &pType2) { return (pType1->IsEqual(pType2)); }\r
- static BOOL AreStringsEqual(__in const LPCSTR &pStr1, __in const LPCSTR &pStr2) { return strcmp(pStr1, pStr2) == 0; }\r
-\r
- typedef CEffectHashTableWithPrivateHeap<SType *, AreTypesEqual> CTypeHashTable;\r
- typedef CEffectHashTableWithPrivateHeap<LPCSTR, AreStringsEqual> CStringHashTable;\r
-\r
- // These are used to pool types & type-related strings\r
- // until Optimize() is called\r
- CTypeHashTable *m_pTypePool;\r
- CStringHashTable *m_pStringPool;\r
- CDataBlockStore *m_pPooledHeap;\r
- // After Optimize() is called, the type/string pools should be deleted and all\r
- // remaining data should be migrated into the optimized type heap\r
- CEffectHeap *m_pOptimizedTypeHeap;\r
-\r
- // Pools a string or type and modifies the pointer\r
- void AddStringToPool(const char **ppString);\r
- void AddTypeToPool(SType **ppType);\r
-\r
- HRESULT OptimizeTypes(CPointerMappingTable *pMappingTable, bool Cloning = false);\r
-\r
-\r
- ////////////////////////////////////////////////////////////////////////// \r
- // Runtime (performance critical)\r
- \r
- void ApplyShaderBlock(SShaderBlock *pBlock);\r
- BOOL ApplyRenderStateBlock(SBaseBlock *pBlock);\r
- BOOL ApplySamplerBlock(SSamplerBlock *pBlock);\r
- void ApplyPassBlock(SPassBlock *pBlock);\r
- BOOL EvaluateAssignment(SAssignment *pAssignment);\r
- BOOL ValidateShaderBlock( SShaderBlock* pBlock );\r
- BOOL ValidatePassBlock( SPassBlock* pBlock );\r
- \r
- ////////////////////////////////////////////////////////////////////////// \r
- // Non-runtime functions (not performance critical) \r
-\r
- SGlobalVariable *FindLocalVariableByName(LPCSTR pVarName); // Looks in the current effect only\r
- SGlobalVariable *FindVariableByName(LPCSTR pVarName);\r
- SVariable *FindVariableByNameWithParsing(LPCSTR pVarName);\r
- SConstantBuffer *FindCB(LPCSTR pName);\r
- void ReplaceCBReference(SConstantBuffer *pOldBufferBlock, ID3D11Buffer *pNewBuffer); // Used by user-managed CBs\r
- void ReplaceSamplerReference(SSamplerBlock *pOldSamplerBlock, ID3D11SamplerState *pNewSampler);\r
- void AddRefAllForCloning( CEffect* pEffectSource );\r
- HRESULT CopyMemberInterfaces( CEffect* pEffectSource );\r
- HRESULT CopyStringPool( CEffect* pEffectSource, CPointerMappingTable& mappingTable );\r
- HRESULT CopyTypePool( CEffect* pEffectSource, CPointerMappingTable& mappingTableTypes, CPointerMappingTable& mappingTableStrings );\r
- HRESULT CopyOptimizedTypePool( CEffect* pEffectSource, CPointerMappingTable& mappingTableTypes );\r
- HRESULT RecreateCBs();\r
- HRESULT FixupMemberInterface( SMember* pMember, CEffect* pEffectSource, CPointerMappingTable& mappingTableStrings );\r
-\r
- void ValidateIndex(UINT Elements);\r
-\r
- void IncrementTimer(); \r
- void HandleLocalTimerRollover();\r
-\r
- friend struct SConstantBuffer;\r
-\r
-public:\r
- CEffect( UINT Flags = 0 );\r
- virtual ~CEffect();\r
- void ReleaseShaderRefection();\r
-\r
- // Initialize must be called after the effect is created\r
- HRESULT LoadEffect(CONST void *pEffectBuffer, UINT cbEffectBuffer);\r
-\r
- // Once the effect is fully loaded, call BindToDevice to attach it to a device\r
- HRESULT BindToDevice(ID3D11Device *pDevice);\r
-\r
- Timer GetCurrentTime() const { return m_LocalTimer; }\r
- \r
- BOOL IsReflectionData(void *pData) const { return m_pReflection->m_Heap.IsInHeap(pData); }\r
- BOOL IsRuntimeData(void *pData) const { return m_Heap.IsInHeap(pData); }\r
-\r
- ////////////////////////////////////////////////////////////////////////// \r
- // Public interface\r
-\r
- // IUnknown\r
- STDMETHOD(QueryInterface)(REFIID iid, LPVOID *ppv);\r
- STDMETHOD_(ULONG, AddRef)();\r
- STDMETHOD_(ULONG, Release)();\r
-\r
- STDMETHOD_(BOOL, IsValid)() { return TRUE; }\r
-\r
- STDMETHOD(GetDevice)(ID3D11Device** ppDevice); \r
-\r
- STDMETHOD(GetDesc)(D3DX11_EFFECT_DESC *pDesc);\r
-\r
- STDMETHOD_(ID3DX11EffectConstantBuffer*, GetConstantBufferByIndex)(UINT Index);\r
- STDMETHOD_(ID3DX11EffectConstantBuffer*, GetConstantBufferByName)(LPCSTR Name);\r
-\r
- STDMETHOD_(ID3DX11EffectVariable*, GetVariableByIndex)(UINT Index);\r
- STDMETHOD_(ID3DX11EffectVariable*, GetVariableByName)(LPCSTR Name);\r
- STDMETHOD_(ID3DX11EffectVariable*, GetVariableBySemantic)(LPCSTR Semantic);\r
-\r
- STDMETHOD_(ID3DX11EffectTechnique*, GetTechniqueByIndex)(UINT Index);\r
- STDMETHOD_(ID3DX11EffectTechnique*, GetTechniqueByName)(LPCSTR Name);\r
-\r
- STDMETHOD_(ID3DX11EffectGroup*, GetGroupByIndex)(UINT Index);\r
- STDMETHOD_(ID3DX11EffectGroup*, GetGroupByName)(LPCSTR Name);\r
-\r
- STDMETHOD_(ID3D11ClassLinkage*, GetClassLinkage)();\r
-\r
- STDMETHOD(CloneEffect)(UINT Flags, ID3DX11Effect** ppClonedEffect);\r
- STDMETHOD(Optimize)();\r
- STDMETHOD_(BOOL, IsOptimized)();\r
-\r
- ////////////////////////////////////////////////////////////////////////// \r
- // New reflection helpers\r
-\r
- ID3DX11EffectType * CreatePooledSingleElementTypeInterface(SType *pType);\r
- ID3DX11EffectVariable * CreatePooledVariableMemberInterface(TTopLevelVariable<ID3DX11EffectVariable> *pTopLevelEntity, SVariable *pMember, UDataPointer Data, BOOL IsSingleElement, UINT Index);\r
-\r
-};\r
-\r
-}\r
OSDN Git Service
