зеркало из https://github.com/microsoft/FX11.git
4965 строки
189 KiB
C++
4965 строки
189 KiB
C++
//--------------------------------------------------------------------------------------
|
|
// File: EffectVariable.inl
|
|
//
|
|
// Direct3D 11 Effects Variable reflection template
|
|
// These templates define the many Effect variable types.
|
|
//
|
|
// Copyright (c) Microsoft Corporation.
|
|
// Licensed under the MIT License.
|
|
//
|
|
// http://go.microsoft.com/fwlink/p/?LinkId=271568
|
|
//--------------------------------------------------------------------------------------
|
|
|
|
#pragma warning(push)
|
|
#pragma warning(disable : 4127)
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
// Invalid variable forward defines
|
|
//////////////////////////////////////////////////////////////////////////
|
|
|
|
struct SEffectInvalidScalarVariable;
|
|
struct SEffectInvalidVectorVariable;
|
|
struct SEffectInvalidMatrixVariable;
|
|
struct SEffectInvalidStringVariable;
|
|
struct SEffectInvalidClassInstanceVariable;
|
|
struct SEffectInvalidInterfaceVariable;
|
|
struct SEffectInvalidShaderResourceVariable;
|
|
struct SEffectInvalidUnorderedAccessViewVariable;
|
|
struct SEffectInvalidRenderTargetViewVariable;
|
|
struct SEffectInvalidDepthStencilViewVariable;
|
|
struct SEffectInvalidConstantBuffer;
|
|
struct SEffectInvalidShaderVariable;
|
|
struct SEffectInvalidBlendVariable;
|
|
struct SEffectInvalidDepthStencilVariable;
|
|
struct SEffectInvalidRasterizerVariable;
|
|
struct SEffectInvalidSamplerVariable;
|
|
struct SEffectInvalidTechnique;
|
|
struct SEffectInvalidPass;
|
|
struct SEffectInvalidType;
|
|
|
|
extern SEffectInvalidScalarVariable g_InvalidScalarVariable;
|
|
extern SEffectInvalidVectorVariable g_InvalidVectorVariable;
|
|
extern SEffectInvalidMatrixVariable g_InvalidMatrixVariable;
|
|
extern SEffectInvalidStringVariable g_InvalidStringVariable;
|
|
extern SEffectInvalidClassInstanceVariable g_InvalidClassInstanceVariable;
|
|
extern SEffectInvalidInterfaceVariable g_InvalidInterfaceVariable;
|
|
extern SEffectInvalidShaderResourceVariable g_InvalidShaderResourceVariable;
|
|
extern SEffectInvalidUnorderedAccessViewVariable g_InvalidUnorderedAccessViewVariable;
|
|
extern SEffectInvalidRenderTargetViewVariable g_InvalidRenderTargetViewVariable;
|
|
extern SEffectInvalidDepthStencilViewVariable g_InvalidDepthStencilViewVariable;
|
|
extern SEffectInvalidConstantBuffer g_InvalidConstantBuffer;
|
|
extern SEffectInvalidShaderVariable g_InvalidShaderVariable;
|
|
extern SEffectInvalidBlendVariable g_InvalidBlendVariable;
|
|
extern SEffectInvalidDepthStencilVariable g_InvalidDepthStencilVariable;
|
|
extern SEffectInvalidRasterizerVariable g_InvalidRasterizerVariable;
|
|
extern SEffectInvalidSamplerVariable g_InvalidSamplerVariable;
|
|
extern SEffectInvalidTechnique g_InvalidTechnique;
|
|
extern SEffectInvalidPass g_InvalidPass;
|
|
extern SEffectInvalidType g_InvalidType;
|
|
|
|
enum ETemplateVarType
|
|
{
|
|
ETVT_Bool,
|
|
ETVT_Int,
|
|
ETVT_Float,
|
|
ETVT_bool
|
|
};
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
// Invalid effect variable struct definitions
|
|
//////////////////////////////////////////////////////////////////////////
|
|
|
|
struct SEffectInvalidType : public ID3DX11EffectType
|
|
{
|
|
STDMETHOD_(bool, IsValid)() override { return false; }
|
|
STDMETHOD(GetDesc)(_Out_ D3DX11_EFFECT_TYPE_DESC *pDesc) override { UNREFERENCED_PARAMETER(pDesc); return E_FAIL; }
|
|
STDMETHOD_(ID3DX11EffectType*, GetMemberTypeByIndex)(_In_ uint32_t Index) override { UNREFERENCED_PARAMETER(Index); return &g_InvalidType; }
|
|
STDMETHOD_(ID3DX11EffectType*, GetMemberTypeByName)(_In_z_ LPCSTR Name) override { UNREFERENCED_PARAMETER(Name); return &g_InvalidType; }
|
|
STDMETHOD_(ID3DX11EffectType*, GetMemberTypeBySemantic)(_In_z_ LPCSTR Semantic) override { UNREFERENCED_PARAMETER(Semantic); return &g_InvalidType; }
|
|
STDMETHOD_(LPCSTR, GetMemberName)(_In_ uint32_t Index) override { UNREFERENCED_PARAMETER(Index); return nullptr; }
|
|
STDMETHOD_(LPCSTR, GetMemberSemantic)(_In_ uint32_t Index) override { UNREFERENCED_PARAMETER(Index); return nullptr; }
|
|
IUNKNOWN_IMP(SEffectInvalidType, ID3DX11EffectType, IUnknown);
|
|
};
|
|
|
|
template<typename IBaseInterface>
|
|
struct TEffectInvalidVariable : public IBaseInterface
|
|
{
|
|
public:
|
|
STDMETHOD_(bool, IsValid)() override { return false; }
|
|
STDMETHOD_(ID3DX11EffectType*, GetType)() override { return &g_InvalidType; }
|
|
STDMETHOD(GetDesc)(_Out_ D3DX11_EFFECT_VARIABLE_DESC *pDesc) override { UNREFERENCED_PARAMETER(pDesc); return E_FAIL; }
|
|
|
|
STDMETHOD_(ID3DX11EffectVariable*, GetAnnotationByIndex)(_In_ uint32_t Index) override { UNREFERENCED_PARAMETER(Index); return &g_InvalidScalarVariable; }
|
|
STDMETHOD_(ID3DX11EffectVariable*, GetAnnotationByName)(_In_z_ LPCSTR Name) override { UNREFERENCED_PARAMETER(Name); return &g_InvalidScalarVariable; }
|
|
|
|
STDMETHOD_(ID3DX11EffectVariable*, GetMemberByIndex)(_In_ uint32_t Index) override { UNREFERENCED_PARAMETER(Index); return &g_InvalidScalarVariable; }
|
|
STDMETHOD_(ID3DX11EffectVariable*, GetMemberByName)(_In_z_ LPCSTR Name) override { UNREFERENCED_PARAMETER(Name); return &g_InvalidScalarVariable; }
|
|
STDMETHOD_(ID3DX11EffectVariable*, GetMemberBySemantic)(_In_z_ LPCSTR Semantic) override { UNREFERENCED_PARAMETER(Semantic); return &g_InvalidScalarVariable; }
|
|
|
|
STDMETHOD_(ID3DX11EffectVariable*, GetElement)(_In_ uint32_t Index) override { UNREFERENCED_PARAMETER(Index); return &g_InvalidScalarVariable; }
|
|
|
|
STDMETHOD_(ID3DX11EffectConstantBuffer*, GetParentConstantBuffer)() override { return &g_InvalidConstantBuffer; }
|
|
|
|
STDMETHOD_(ID3DX11EffectScalarVariable*, AsScalar)() override { return &g_InvalidScalarVariable; }
|
|
STDMETHOD_(ID3DX11EffectVectorVariable*, AsVector)() override { return &g_InvalidVectorVariable; }
|
|
STDMETHOD_(ID3DX11EffectMatrixVariable*, AsMatrix)() override { return &g_InvalidMatrixVariable; }
|
|
STDMETHOD_(ID3DX11EffectStringVariable*, AsString)() override { return &g_InvalidStringVariable; }
|
|
STDMETHOD_(ID3DX11EffectClassInstanceVariable*, AsClassInstance)() override { return &g_InvalidClassInstanceVariable; }
|
|
STDMETHOD_(ID3DX11EffectInterfaceVariable*, AsInterface)() override { return &g_InvalidInterfaceVariable; }
|
|
STDMETHOD_(ID3DX11EffectShaderResourceVariable*, AsShaderResource)() override { return &g_InvalidShaderResourceVariable; }
|
|
STDMETHOD_(ID3DX11EffectUnorderedAccessViewVariable*, AsUnorderedAccessView)() override { return &g_InvalidUnorderedAccessViewVariable; }
|
|
STDMETHOD_(ID3DX11EffectRenderTargetViewVariable*, AsRenderTargetView)() override { return &g_InvalidRenderTargetViewVariable; }
|
|
STDMETHOD_(ID3DX11EffectDepthStencilViewVariable*, AsDepthStencilView)() override { return &g_InvalidDepthStencilViewVariable; }
|
|
STDMETHOD_(ID3DX11EffectConstantBuffer*, AsConstantBuffer)() override { return &g_InvalidConstantBuffer; }
|
|
STDMETHOD_(ID3DX11EffectShaderVariable*, AsShader)() override { return &g_InvalidShaderVariable; }
|
|
STDMETHOD_(ID3DX11EffectBlendVariable*, AsBlend)() override { return &g_InvalidBlendVariable; }
|
|
STDMETHOD_(ID3DX11EffectDepthStencilVariable*, AsDepthStencil)() override { return &g_InvalidDepthStencilVariable; }
|
|
STDMETHOD_(ID3DX11EffectRasterizerVariable*, AsRasterizer)() override { return &g_InvalidRasterizerVariable; }
|
|
STDMETHOD_(ID3DX11EffectSamplerVariable*, AsSampler)() override { return &g_InvalidSamplerVariable; }
|
|
|
|
STDMETHOD(SetRawValue)(_In_reads_bytes_(Count) const void *pData, _In_ uint32_t Offset, _In_ uint32_t Count) override
|
|
{ UNREFERENCED_PARAMETER(pData); UNREFERENCED_PARAMETER(Offset); UNREFERENCED_PARAMETER(Count); return E_FAIL; }
|
|
STDMETHOD(GetRawValue)(_Out_writes_bytes_(Count) void *pData, _In_ uint32_t Offset, _In_ uint32_t Count) override
|
|
{ UNREFERENCED_PARAMETER(pData); UNREFERENCED_PARAMETER(Offset); UNREFERENCED_PARAMETER(Count); return E_FAIL; }
|
|
};
|
|
|
|
struct SEffectInvalidScalarVariable : public TEffectInvalidVariable<ID3DX11EffectScalarVariable>
|
|
{
|
|
public:
|
|
|
|
STDMETHOD(SetFloat)(_In_ float Value) override { UNREFERENCED_PARAMETER(Value); return E_FAIL; }
|
|
STDMETHOD(GetFloat)(_Out_ float *pValue) override { UNREFERENCED_PARAMETER(pValue); return E_FAIL; }
|
|
|
|
STDMETHOD(SetFloatArray)(_In_reads_(Count) const float *pData, _In_ uint32_t Offset, _In_ uint32_t Count) override
|
|
{ UNREFERENCED_PARAMETER(pData); UNREFERENCED_PARAMETER(Offset); UNREFERENCED_PARAMETER(Count); return E_FAIL; }
|
|
STDMETHOD(GetFloatArray)(_Out_writes_(Count) float *pData, _In_ uint32_t Offset, _In_ uint32_t Count) override
|
|
{ UNREFERENCED_PARAMETER(pData); UNREFERENCED_PARAMETER(Offset); UNREFERENCED_PARAMETER(Count); return E_FAIL; }
|
|
|
|
STDMETHOD(SetInt)(_In_ int Value) override { UNREFERENCED_PARAMETER(Value); return E_FAIL; }
|
|
STDMETHOD(GetInt)(_Out_ int *pValue) override { UNREFERENCED_PARAMETER(pValue); return E_FAIL; }
|
|
|
|
STDMETHOD(SetIntArray)(_In_reads_(Count) const int *pData, _In_ uint32_t Offset, _In_ uint32_t Count) override
|
|
{ UNREFERENCED_PARAMETER(pData); UNREFERENCED_PARAMETER(Offset); UNREFERENCED_PARAMETER(Count); return E_FAIL; }
|
|
STDMETHOD(GetIntArray)(_Out_writes_(Count) int *pData, _In_ uint32_t Offset, _In_ uint32_t Count) override
|
|
{ UNREFERENCED_PARAMETER(pData); UNREFERENCED_PARAMETER(Offset); UNREFERENCED_PARAMETER(Count); return E_FAIL; }
|
|
|
|
STDMETHOD(SetBool)(_In_ bool Value) override { UNREFERENCED_PARAMETER(Value); return E_FAIL; }
|
|
STDMETHOD(GetBool)(_Out_ bool *pValue) override { UNREFERENCED_PARAMETER(pValue); return E_FAIL; }
|
|
|
|
STDMETHOD(SetBoolArray)(_In_reads_(Count) const bool *pData, _In_ uint32_t Offset, _In_ uint32_t Count) override
|
|
{ UNREFERENCED_PARAMETER(pData); UNREFERENCED_PARAMETER(Offset); UNREFERENCED_PARAMETER(Count); return E_FAIL; }
|
|
STDMETHOD(GetBoolArray)(_Out_writes_(Count) bool *pData, _In_ uint32_t Offset, _In_ uint32_t Count) override
|
|
{ UNREFERENCED_PARAMETER(pData); UNREFERENCED_PARAMETER(Offset); UNREFERENCED_PARAMETER(Count); return E_FAIL; }
|
|
|
|
IUNKNOWN_IMP(SEffectInvalidScalarVariable, ID3DX11EffectScalarVariable, ID3DX11EffectVariable);
|
|
};
|
|
|
|
|
|
struct SEffectInvalidVectorVariable : public TEffectInvalidVariable<ID3DX11EffectVectorVariable>
|
|
{
|
|
public:
|
|
STDMETHOD(SetFloatVector)(_In_reads_(4) const float *pData) override { UNREFERENCED_PARAMETER(pData); return E_FAIL; };
|
|
STDMETHOD(SetIntVector)(_In_reads_(4) const int *pData) override { UNREFERENCED_PARAMETER(pData); return E_FAIL; };
|
|
STDMETHOD(SetBoolVector)(_In_reads_(4) const bool *pData) override { UNREFERENCED_PARAMETER(pData); return E_FAIL; };
|
|
|
|
STDMETHOD(GetFloatVector)(_Out_writes_(4) float *pData) override { UNREFERENCED_PARAMETER(pData); return E_FAIL; };
|
|
STDMETHOD(GetIntVector)(_Out_writes_(4) int *pData) override { UNREFERENCED_PARAMETER(pData); return E_FAIL; };
|
|
STDMETHOD(GetBoolVector)(_Out_writes_(4) bool *pData) override { UNREFERENCED_PARAMETER(pData); return E_FAIL; };
|
|
|
|
STDMETHOD(SetBoolVectorArray) (_In_reads_(4*Count) const bool *pData, _In_ uint32_t Offset, _In_ uint32_t Count) override
|
|
{ UNREFERENCED_PARAMETER(pData); UNREFERENCED_PARAMETER(Offset); UNREFERENCED_PARAMETER(Count); return E_FAIL; };
|
|
STDMETHOD(SetIntVectorArray) (_In_reads_(4*Count) const int *pData, _In_ uint32_t Offset, _In_ uint32_t Count) override
|
|
{ UNREFERENCED_PARAMETER(pData); UNREFERENCED_PARAMETER(Offset); UNREFERENCED_PARAMETER(Count); return E_FAIL; };
|
|
STDMETHOD(SetFloatVectorArray)(_In_reads_(4*Count) const float *pData, _In_ uint32_t Offset, _In_ uint32_t Count) override
|
|
{ UNREFERENCED_PARAMETER(pData); UNREFERENCED_PARAMETER(Offset); UNREFERENCED_PARAMETER(Count); return E_FAIL; };
|
|
|
|
STDMETHOD(GetBoolVectorArray) (_Out_writes_(4*Count) bool *pData, _In_ uint32_t Offset, _In_ uint32_t Count) override
|
|
{ UNREFERENCED_PARAMETER(pData); UNREFERENCED_PARAMETER(Offset); UNREFERENCED_PARAMETER(Count); return E_FAIL; };
|
|
STDMETHOD(GetIntVectorArray) (_Out_writes_(4*Count) int *pData, _In_ uint32_t Offset, _In_ uint32_t Count) override
|
|
{ UNREFERENCED_PARAMETER(pData); UNREFERENCED_PARAMETER(Offset); UNREFERENCED_PARAMETER(Count); return E_FAIL; };
|
|
STDMETHOD(GetFloatVectorArray)(_Out_writes_(4*Count) float *pData, _In_ uint32_t Offset, _In_ uint32_t Count) override
|
|
{ UNREFERENCED_PARAMETER(pData); UNREFERENCED_PARAMETER(Offset); UNREFERENCED_PARAMETER(Count); return E_FAIL; };
|
|
|
|
IUNKNOWN_IMP(SEffectInvalidVectorVariable, ID3DX11EffectVectorVariable, ID3DX11EffectVariable);
|
|
};
|
|
|
|
struct SEffectInvalidMatrixVariable : public TEffectInvalidVariable<ID3DX11EffectMatrixVariable>
|
|
{
|
|
public:
|
|
|
|
STDMETHOD(SetMatrix)(_In_reads_(16) const float *pData) override { UNREFERENCED_PARAMETER(pData); return E_FAIL; }
|
|
STDMETHOD(GetMatrix)(_Out_writes_(16) float *pData) override { UNREFERENCED_PARAMETER(pData); return E_FAIL; }
|
|
|
|
STDMETHOD(SetMatrixArray)(_In_reads_(16*Count) const float *pData, _In_ uint32_t Offset, _In_ uint32_t Count) override
|
|
{ UNREFERENCED_PARAMETER(pData); UNREFERENCED_PARAMETER(Offset); UNREFERENCED_PARAMETER(Count); return E_FAIL; }
|
|
STDMETHOD(GetMatrixArray)(_Out_writes_(16*Count) float *pData, _In_ uint32_t Offset, _In_ uint32_t Count) override
|
|
{ UNREFERENCED_PARAMETER(pData); UNREFERENCED_PARAMETER(Offset); UNREFERENCED_PARAMETER(Count); return E_FAIL; }
|
|
|
|
STDMETHOD(SetMatrixPointerArray)(_In_reads_(16*Count) const float **ppData, _In_ uint32_t Offset, _In_ uint32_t Count) override
|
|
{ UNREFERENCED_PARAMETER(ppData); UNREFERENCED_PARAMETER(Offset); UNREFERENCED_PARAMETER(Count); return E_FAIL; }
|
|
STDMETHOD(GetMatrixPointerArray)(_Out_writes_(16*Count) float **ppData, _In_ uint32_t Offset, _In_ uint32_t Count) override
|
|
{ UNREFERENCED_PARAMETER(ppData); UNREFERENCED_PARAMETER(Offset); UNREFERENCED_PARAMETER(Count); return E_FAIL; }
|
|
|
|
STDMETHOD(SetMatrixTranspose)(_In_reads_(16) const float *pData) override { UNREFERENCED_PARAMETER(pData); return E_FAIL; }
|
|
STDMETHOD(GetMatrixTranspose)(_Out_writes_(16) float *pData) override { UNREFERENCED_PARAMETER(pData); return E_FAIL; }
|
|
|
|
STDMETHOD(SetMatrixTransposeArray)(_In_reads_(16*Count) const float *pData, _In_ uint32_t Offset, _In_ uint32_t Count) override
|
|
{ UNREFERENCED_PARAMETER(pData); UNREFERENCED_PARAMETER(Offset); UNREFERENCED_PARAMETER(Count); return E_FAIL; }
|
|
STDMETHOD(GetMatrixTransposeArray)(_Out_writes_(16*Count) float *pData, _In_ uint32_t Offset, _In_ uint32_t Count) override
|
|
{ UNREFERENCED_PARAMETER(pData); UNREFERENCED_PARAMETER(Offset); UNREFERENCED_PARAMETER(Count); return E_FAIL; }
|
|
|
|
STDMETHOD(SetMatrixTransposePointerArray)(_In_reads_(16*Count) const float **ppData, _In_ uint32_t Offset, _In_ uint32_t Count) override
|
|
{ UNREFERENCED_PARAMETER(ppData); UNREFERENCED_PARAMETER(Offset); UNREFERENCED_PARAMETER(Count); return E_FAIL; }
|
|
STDMETHOD(GetMatrixTransposePointerArray)(_Out_writes_(16*Count) float **ppData, _In_ uint32_t Offset, _In_ uint32_t Count) override
|
|
{ UNREFERENCED_PARAMETER(ppData); UNREFERENCED_PARAMETER(Offset); UNREFERENCED_PARAMETER(Count); return E_FAIL; }
|
|
|
|
IUNKNOWN_IMP(SEffectInvalidMatrixVariable, ID3DX11EffectMatrixVariable, ID3DX11EffectVariable);
|
|
};
|
|
|
|
struct SEffectInvalidStringVariable : public TEffectInvalidVariable<ID3DX11EffectStringVariable>
|
|
{
|
|
public:
|
|
|
|
STDMETHOD(GetString)(_Outptr_result_z_ LPCSTR *ppString) override { UNREFERENCED_PARAMETER(ppString); return E_FAIL; }
|
|
STDMETHOD(GetStringArray)(_Out_writes_(Count) LPCSTR *ppStrings, _In_ uint32_t Offset, _In_ uint32_t Count) override
|
|
{ UNREFERENCED_PARAMETER(ppStrings); UNREFERENCED_PARAMETER(Offset); UNREFERENCED_PARAMETER(Count); return E_FAIL; }
|
|
|
|
IUNKNOWN_IMP(SEffectInvalidStringVariable, ID3DX11EffectStringVariable, ID3DX11EffectVariable);
|
|
};
|
|
|
|
struct SEffectInvalidClassInstanceVariable : public TEffectInvalidVariable<ID3DX11EffectClassInstanceVariable>
|
|
{
|
|
public:
|
|
|
|
STDMETHOD(GetClassInstance)(_Outptr_ ID3D11ClassInstance **ppClassInstance) override { UNREFERENCED_PARAMETER(ppClassInstance); return E_FAIL; }
|
|
|
|
IUNKNOWN_IMP(SEffectInvalidClassInstanceVariable, ID3DX11EffectClassInstanceVariable, ID3DX11EffectVariable);
|
|
};
|
|
|
|
|
|
struct SEffectInvalidInterfaceVariable : public TEffectInvalidVariable<ID3DX11EffectInterfaceVariable>
|
|
{
|
|
public:
|
|
|
|
STDMETHOD(SetClassInstance)(_In_ ID3DX11EffectClassInstanceVariable *pEffectClassInstance) override
|
|
{ UNREFERENCED_PARAMETER(pEffectClassInstance); return E_FAIL; }
|
|
STDMETHOD(GetClassInstance)(_Outptr_ ID3DX11EffectClassInstanceVariable **ppEffectClassInstance) override
|
|
{ UNREFERENCED_PARAMETER(ppEffectClassInstance); return E_FAIL; }
|
|
|
|
IUNKNOWN_IMP(SEffectInvalidInterfaceVariable, ID3DX11EffectInterfaceVariable, ID3DX11EffectVariable);
|
|
};
|
|
|
|
|
|
struct SEffectInvalidShaderResourceVariable : public TEffectInvalidVariable<ID3DX11EffectShaderResourceVariable>
|
|
{
|
|
public:
|
|
|
|
STDMETHOD(SetResource)(_In_ ID3D11ShaderResourceView *pResource) override { UNREFERENCED_PARAMETER(pResource); return E_FAIL; }
|
|
STDMETHOD(GetResource)(_Outptr_ ID3D11ShaderResourceView **ppResource) override { UNREFERENCED_PARAMETER(ppResource); return E_FAIL; }
|
|
|
|
STDMETHOD(SetResourceArray)(_In_reads_(Count) ID3D11ShaderResourceView **ppResources, _In_ uint32_t Offset, _In_ uint32_t Count) override
|
|
{ UNREFERENCED_PARAMETER(ppResources); UNREFERENCED_PARAMETER(Offset); UNREFERENCED_PARAMETER(Count); return E_FAIL; }
|
|
STDMETHOD(GetResourceArray)(_Out_writes_(Count) ID3D11ShaderResourceView **ppResources, _In_ uint32_t Offset, _In_ uint32_t Count) override
|
|
{ UNREFERENCED_PARAMETER(ppResources); UNREFERENCED_PARAMETER(Offset); UNREFERENCED_PARAMETER(Count); return E_FAIL; }
|
|
|
|
IUNKNOWN_IMP(SEffectInvalidShaderResourceVariable, ID3DX11EffectShaderResourceVariable, ID3DX11EffectVariable);
|
|
};
|
|
|
|
|
|
struct SEffectInvalidUnorderedAccessViewVariable : public TEffectInvalidVariable<ID3DX11EffectUnorderedAccessViewVariable>
|
|
{
|
|
public:
|
|
|
|
STDMETHOD(SetUnorderedAccessView)(_In_ ID3D11UnorderedAccessView *pResource) override { UNREFERENCED_PARAMETER(pResource); return E_FAIL; }
|
|
STDMETHOD(GetUnorderedAccessView)(_Outptr_ ID3D11UnorderedAccessView **ppResource) override { UNREFERENCED_PARAMETER(ppResource); return E_FAIL; }
|
|
|
|
STDMETHOD(SetUnorderedAccessViewArray)(_In_reads_(Count) ID3D11UnorderedAccessView **ppResources, _In_ uint32_t Offset, _In_ uint32_t Count) override
|
|
{ UNREFERENCED_PARAMETER(ppResources); UNREFERENCED_PARAMETER(Offset); UNREFERENCED_PARAMETER(Count); return E_FAIL; }
|
|
STDMETHOD(GetUnorderedAccessViewArray)(_Out_writes_(Count) ID3D11UnorderedAccessView **ppResources, _In_ uint32_t Offset, _In_ uint32_t Count) override
|
|
{ UNREFERENCED_PARAMETER(ppResources); UNREFERENCED_PARAMETER(Offset); UNREFERENCED_PARAMETER(Count); return E_FAIL; }
|
|
|
|
IUNKNOWN_IMP(SEffectInvalidUnorderedAccessViewVariable, ID3DX11EffectUnorderedAccessViewVariable, ID3DX11EffectVariable);
|
|
};
|
|
|
|
|
|
struct SEffectInvalidRenderTargetViewVariable : public TEffectInvalidVariable<ID3DX11EffectRenderTargetViewVariable>
|
|
{
|
|
public:
|
|
|
|
STDMETHOD(SetRenderTarget)(_In_ ID3D11RenderTargetView *pResource) override { UNREFERENCED_PARAMETER(pResource); return E_FAIL; }
|
|
STDMETHOD(GetRenderTarget)(_Outptr_ ID3D11RenderTargetView **ppResource) override { UNREFERENCED_PARAMETER(ppResource); return E_FAIL; }
|
|
|
|
STDMETHOD(SetRenderTargetArray)(_In_reads_(Count) ID3D11RenderTargetView **ppResources, _In_ uint32_t Offset, _In_ uint32_t Count) override
|
|
{ UNREFERENCED_PARAMETER(ppResources); UNREFERENCED_PARAMETER(Offset); UNREFERENCED_PARAMETER(Count); return E_FAIL; }
|
|
STDMETHOD(GetRenderTargetArray)(_Out_writes_(Count) ID3D11RenderTargetView **ppResources, _In_ uint32_t Offset, _In_ uint32_t Count) override
|
|
{ UNREFERENCED_PARAMETER(ppResources); UNREFERENCED_PARAMETER(Offset); UNREFERENCED_PARAMETER(Count); return E_FAIL; }
|
|
|
|
IUNKNOWN_IMP(SEffectInvalidRenderTargetViewVariable, ID3DX11EffectRenderTargetViewVariable, ID3DX11EffectVariable);
|
|
};
|
|
|
|
|
|
struct SEffectInvalidDepthStencilViewVariable : public TEffectInvalidVariable<ID3DX11EffectDepthStencilViewVariable>
|
|
{
|
|
public:
|
|
|
|
STDMETHOD(SetDepthStencil)(_In_ ID3D11DepthStencilView *pResource) override { UNREFERENCED_PARAMETER(pResource); return E_FAIL; }
|
|
STDMETHOD(GetDepthStencil)(_Outptr_ ID3D11DepthStencilView **ppResource) override { UNREFERENCED_PARAMETER(ppResource); return E_FAIL; }
|
|
|
|
STDMETHOD(SetDepthStencilArray)(_In_reads_(Count) ID3D11DepthStencilView **ppResources, _In_ uint32_t Offset, _In_ uint32_t Count) override
|
|
{ UNREFERENCED_PARAMETER(ppResources); UNREFERENCED_PARAMETER(Offset); UNREFERENCED_PARAMETER(Count); return E_FAIL; }
|
|
STDMETHOD(GetDepthStencilArray)(_Out_writes_(Count) ID3D11DepthStencilView **ppResources, _In_ uint32_t Offset, _In_ uint32_t Count) override
|
|
{ UNREFERENCED_PARAMETER(ppResources); UNREFERENCED_PARAMETER(Offset); UNREFERENCED_PARAMETER(Count); return E_FAIL; }
|
|
|
|
IUNKNOWN_IMP(SEffectInvalidDepthStencilViewVariable, ID3DX11EffectDepthStencilViewVariable, ID3DX11EffectVariable);
|
|
};
|
|
|
|
|
|
struct SEffectInvalidConstantBuffer : public TEffectInvalidVariable<ID3DX11EffectConstantBuffer>
|
|
{
|
|
public:
|
|
|
|
STDMETHOD(SetConstantBuffer)(_In_ ID3D11Buffer *pConstantBuffer) override { UNREFERENCED_PARAMETER(pConstantBuffer); return E_FAIL; }
|
|
STDMETHOD(GetConstantBuffer)(_Outptr_ ID3D11Buffer **ppConstantBuffer) override { UNREFERENCED_PARAMETER(ppConstantBuffer); return E_FAIL; }
|
|
STDMETHOD(UndoSetConstantBuffer)() override { return E_FAIL; }
|
|
|
|
STDMETHOD(SetTextureBuffer)(_In_ ID3D11ShaderResourceView *pTextureBuffer) override { UNREFERENCED_PARAMETER(pTextureBuffer); return E_FAIL; }
|
|
STDMETHOD(GetTextureBuffer)(_Outptr_ ID3D11ShaderResourceView **ppTextureBuffer) override { UNREFERENCED_PARAMETER(ppTextureBuffer); return E_FAIL; }
|
|
STDMETHOD(UndoSetTextureBuffer)() override { return E_FAIL; }
|
|
|
|
IUNKNOWN_IMP(SEffectInvalidConstantBuffer, ID3DX11EffectConstantBuffer, ID3DX11EffectVariable);
|
|
};
|
|
|
|
struct SEffectInvalidShaderVariable : public TEffectInvalidVariable<ID3DX11EffectShaderVariable>
|
|
{
|
|
public:
|
|
|
|
STDMETHOD(GetShaderDesc)(_In_ uint32_t ShaderIndex, _Out_ D3DX11_EFFECT_SHADER_DESC *pDesc) override
|
|
{ UNREFERENCED_PARAMETER(ShaderIndex); UNREFERENCED_PARAMETER(pDesc); return E_FAIL; }
|
|
|
|
STDMETHOD(GetVertexShader)(_In_ uint32_t ShaderIndex, _Outptr_ ID3D11VertexShader **ppVS) override
|
|
{ UNREFERENCED_PARAMETER(ShaderIndex); UNREFERENCED_PARAMETER(ppVS); return E_FAIL; }
|
|
STDMETHOD(GetGeometryShader)(_In_ uint32_t ShaderIndex, _Outptr_ ID3D11GeometryShader **ppGS) override
|
|
{ UNREFERENCED_PARAMETER(ShaderIndex); UNREFERENCED_PARAMETER(ppGS); return E_FAIL; }
|
|
STDMETHOD(GetPixelShader)(_In_ uint32_t ShaderIndex, _Outptr_ ID3D11PixelShader **ppPS) override
|
|
{ UNREFERENCED_PARAMETER(ShaderIndex); UNREFERENCED_PARAMETER(ppPS); return E_FAIL; }
|
|
STDMETHOD(GetHullShader)(_In_ uint32_t ShaderIndex, _Outptr_ ID3D11HullShader **ppHS) override
|
|
{ UNREFERENCED_PARAMETER(ShaderIndex); UNREFERENCED_PARAMETER(ppHS); return E_FAIL; }
|
|
STDMETHOD(GetDomainShader)(_In_ uint32_t ShaderIndex, _Outptr_ ID3D11DomainShader **ppDS) override
|
|
{ UNREFERENCED_PARAMETER(ShaderIndex); UNREFERENCED_PARAMETER(ppDS); return E_FAIL; }
|
|
STDMETHOD(GetComputeShader)(_In_ uint32_t ShaderIndex, _Outptr_ ID3D11ComputeShader **ppCS) override
|
|
{ UNREFERENCED_PARAMETER(ShaderIndex); UNREFERENCED_PARAMETER(ppCS); return E_FAIL; }
|
|
|
|
STDMETHOD(GetInputSignatureElementDesc)(_In_ uint32_t ShaderIndex, _In_ uint32_t Element, _Out_ D3D11_SIGNATURE_PARAMETER_DESC *pDesc) override
|
|
{ UNREFERENCED_PARAMETER(ShaderIndex); UNREFERENCED_PARAMETER(Element); UNREFERENCED_PARAMETER(pDesc); return E_FAIL; }
|
|
STDMETHOD(GetOutputSignatureElementDesc)(_In_ uint32_t ShaderIndex, _In_ uint32_t Element, _Out_ D3D11_SIGNATURE_PARAMETER_DESC *pDesc) override
|
|
{ UNREFERENCED_PARAMETER(ShaderIndex); UNREFERENCED_PARAMETER(Element); UNREFERENCED_PARAMETER(pDesc); return E_FAIL; }
|
|
STDMETHOD(GetPatchConstantSignatureElementDesc)(_In_ uint32_t ShaderIndex, _In_ uint32_t Element, _Out_ D3D11_SIGNATURE_PARAMETER_DESC *pDesc) override
|
|
{ UNREFERENCED_PARAMETER(ShaderIndex); UNREFERENCED_PARAMETER(Element); UNREFERENCED_PARAMETER(pDesc); return E_FAIL; }
|
|
|
|
IUNKNOWN_IMP(SEffectInvalidShaderVariable, ID3DX11EffectShaderVariable, ID3DX11EffectVariable);
|
|
};
|
|
|
|
struct SEffectInvalidBlendVariable : public TEffectInvalidVariable<ID3DX11EffectBlendVariable>
|
|
{
|
|
public:
|
|
|
|
STDMETHOD(GetBlendState)(_In_ uint32_t Index, _Outptr_ ID3D11BlendState **ppState) override
|
|
{ UNREFERENCED_PARAMETER(Index); UNREFERENCED_PARAMETER(ppState); return E_FAIL; }
|
|
STDMETHOD(SetBlendState)(_In_ uint32_t Index, _In_ ID3D11BlendState *pState) override
|
|
{ UNREFERENCED_PARAMETER(Index); UNREFERENCED_PARAMETER(pState); return E_FAIL; }
|
|
STDMETHOD(UndoSetBlendState)(_In_ uint32_t Index) override { UNREFERENCED_PARAMETER(Index); return E_FAIL; }
|
|
STDMETHOD(GetBackingStore)(_In_ uint32_t Index, _Out_ D3D11_BLEND_DESC *pDesc) override
|
|
{ UNREFERENCED_PARAMETER(Index); UNREFERENCED_PARAMETER(pDesc); return E_FAIL; }
|
|
|
|
IUNKNOWN_IMP(SEffectInvalidBlendVariable, ID3DX11EffectBlendVariable, ID3DX11EffectVariable);
|
|
};
|
|
|
|
struct SEffectInvalidDepthStencilVariable : public TEffectInvalidVariable<ID3DX11EffectDepthStencilVariable>
|
|
{
|
|
public:
|
|
|
|
STDMETHOD(GetDepthStencilState)(_In_ uint32_t Index, _Outptr_ ID3D11DepthStencilState **ppState) override
|
|
{ UNREFERENCED_PARAMETER(Index); UNREFERENCED_PARAMETER(ppState); return E_FAIL; }
|
|
STDMETHOD(SetDepthStencilState)(_In_ uint32_t Index, _In_ ID3D11DepthStencilState *pState) override
|
|
{ UNREFERENCED_PARAMETER(Index); UNREFERENCED_PARAMETER(pState); return E_FAIL; }
|
|
STDMETHOD(UndoSetDepthStencilState)(_In_ uint32_t Index) override { UNREFERENCED_PARAMETER(Index); return E_FAIL; }
|
|
STDMETHOD(GetBackingStore)(_In_ uint32_t Index, _Out_ D3D11_DEPTH_STENCIL_DESC *pDesc) override
|
|
{ UNREFERENCED_PARAMETER(Index); UNREFERENCED_PARAMETER(pDesc); return E_FAIL; }
|
|
|
|
IUNKNOWN_IMP(SEffectInvalidDepthStencilVariable, ID3DX11EffectDepthStencilVariable, ID3DX11EffectVariable);
|
|
};
|
|
|
|
struct SEffectInvalidRasterizerVariable : public TEffectInvalidVariable<ID3DX11EffectRasterizerVariable>
|
|
{
|
|
public:
|
|
|
|
STDMETHOD(GetRasterizerState)(_In_ uint32_t Index, _Outptr_ ID3D11RasterizerState **ppState) override
|
|
{ UNREFERENCED_PARAMETER(Index); UNREFERENCED_PARAMETER(ppState); return E_FAIL; }
|
|
STDMETHOD(SetRasterizerState)(_In_ uint32_t Index, _In_ ID3D11RasterizerState *pState) override
|
|
{ UNREFERENCED_PARAMETER(Index); UNREFERENCED_PARAMETER(pState); return E_FAIL; }
|
|
STDMETHOD(UndoSetRasterizerState)(_In_ uint32_t Index) override { UNREFERENCED_PARAMETER(Index); return E_FAIL; }
|
|
STDMETHOD(GetBackingStore)(_In_ uint32_t Index, _Out_ D3D11_RASTERIZER_DESC *pDesc) override
|
|
{ UNREFERENCED_PARAMETER(Index); UNREFERENCED_PARAMETER(pDesc); return E_FAIL; }
|
|
|
|
IUNKNOWN_IMP(SEffectInvalidRasterizerVariable, ID3DX11EffectRasterizerVariable, ID3DX11EffectVariable);
|
|
};
|
|
|
|
struct SEffectInvalidSamplerVariable : public TEffectInvalidVariable<ID3DX11EffectSamplerVariable>
|
|
{
|
|
public:
|
|
|
|
STDMETHOD(GetSampler)(_In_ uint32_t Index, _Outptr_ ID3D11SamplerState **ppSampler) override
|
|
{ UNREFERENCED_PARAMETER(Index); UNREFERENCED_PARAMETER(ppSampler); return E_FAIL; }
|
|
STDMETHOD(SetSampler)(_In_ uint32_t Index, _In_ ID3D11SamplerState *pSampler) override
|
|
{ UNREFERENCED_PARAMETER(Index); UNREFERENCED_PARAMETER(pSampler); return E_FAIL; }
|
|
STDMETHOD(UndoSetSampler)(_In_ uint32_t Index) override { UNREFERENCED_PARAMETER(Index); return E_FAIL; }
|
|
STDMETHOD(GetBackingStore)(_In_ uint32_t Index, _Out_ D3D11_SAMPLER_DESC *pDesc) override
|
|
{ UNREFERENCED_PARAMETER(Index); UNREFERENCED_PARAMETER(pDesc); return E_FAIL; }
|
|
|
|
IUNKNOWN_IMP(SEffectInvalidSamplerVariable, ID3DX11EffectSamplerVariable, ID3DX11EffectVariable);
|
|
};
|
|
|
|
struct SEffectInvalidPass : public ID3DX11EffectPass
|
|
{
|
|
public:
|
|
STDMETHOD_(bool, IsValid)() override { return false; }
|
|
STDMETHOD(GetDesc)(_Out_ D3DX11_PASS_DESC *pDesc) override { UNREFERENCED_PARAMETER(pDesc); return E_FAIL; }
|
|
|
|
STDMETHOD(GetVertexShaderDesc)(_Out_ D3DX11_PASS_SHADER_DESC *pDesc) override { UNREFERENCED_PARAMETER(pDesc); return E_FAIL; }
|
|
STDMETHOD(GetGeometryShaderDesc)(_Out_ D3DX11_PASS_SHADER_DESC *pDesc) override { UNREFERENCED_PARAMETER(pDesc); return E_FAIL; }
|
|
STDMETHOD(GetPixelShaderDesc)(_Out_ D3DX11_PASS_SHADER_DESC *pDesc) override { UNREFERENCED_PARAMETER(pDesc); return E_FAIL; }
|
|
STDMETHOD(GetHullShaderDesc)(_Out_ D3DX11_PASS_SHADER_DESC *pDesc) override { UNREFERENCED_PARAMETER(pDesc); return E_FAIL; }
|
|
STDMETHOD(GetDomainShaderDesc)(_Out_ D3DX11_PASS_SHADER_DESC *pDesc) override { UNREFERENCED_PARAMETER(pDesc); return E_FAIL; }
|
|
STDMETHOD(GetComputeShaderDesc)(_Out_ D3DX11_PASS_SHADER_DESC *pDesc) override { UNREFERENCED_PARAMETER(pDesc); return E_FAIL; }
|
|
|
|
STDMETHOD_(ID3DX11EffectVariable*, GetAnnotationByIndex)(_In_ uint32_t Index) override { UNREFERENCED_PARAMETER(Index); return &g_InvalidScalarVariable; }
|
|
STDMETHOD_(ID3DX11EffectVariable*, GetAnnotationByName)(_In_z_ LPCSTR Name) override { UNREFERENCED_PARAMETER(Name); return &g_InvalidScalarVariable; }
|
|
|
|
STDMETHOD(Apply)(_In_ uint32_t Flags, _In_ ID3D11DeviceContext* pContext) override
|
|
{ UNREFERENCED_PARAMETER(Flags); UNREFERENCED_PARAMETER(pContext); return E_FAIL; }
|
|
STDMETHOD(ComputeStateBlockMask)(_Inout_ D3DX11_STATE_BLOCK_MASK *pStateBlockMask) override { UNREFERENCED_PARAMETER(pStateBlockMask); return E_FAIL; }
|
|
|
|
IUNKNOWN_IMP(SEffectInvalidPass, ID3DX11EffectPass, IUnknown);
|
|
};
|
|
|
|
struct SEffectInvalidTechnique : public ID3DX11EffectTechnique
|
|
{
|
|
public:
|
|
STDMETHOD_(bool, IsValid)() override { return false; }
|
|
STDMETHOD(GetDesc)(_Out_ D3DX11_TECHNIQUE_DESC *pDesc) override { UNREFERENCED_PARAMETER(pDesc); return E_FAIL; }
|
|
|
|
STDMETHOD_(ID3DX11EffectVariable*, GetAnnotationByIndex)(_In_ uint32_t Index) override { UNREFERENCED_PARAMETER(Index); return &g_InvalidScalarVariable; }
|
|
STDMETHOD_(ID3DX11EffectVariable*, GetAnnotationByName)(_In_z_ LPCSTR Name) override { UNREFERENCED_PARAMETER(Name); return &g_InvalidScalarVariable; }
|
|
|
|
STDMETHOD_(ID3DX11EffectPass*, GetPassByIndex)(_In_ uint32_t Index) override { UNREFERENCED_PARAMETER(Index); return &g_InvalidPass; }
|
|
STDMETHOD_(ID3DX11EffectPass*, GetPassByName)(_In_z_ LPCSTR Name) override { UNREFERENCED_PARAMETER(Name); return &g_InvalidPass; }
|
|
|
|
STDMETHOD(ComputeStateBlockMask)(_Inout_ D3DX11_STATE_BLOCK_MASK *pStateBlockMask) override { UNREFERENCED_PARAMETER(pStateBlockMask); return E_FAIL; }
|
|
|
|
IUNKNOWN_IMP(SEffectInvalidTechnique, ID3DX11EffectTechnique, IUnknown);
|
|
};
|
|
|
|
struct SEffectInvalidGroup : public ID3DX11EffectGroup
|
|
{
|
|
public:
|
|
STDMETHOD_(bool, IsValid)() override { return false; }
|
|
STDMETHOD(GetDesc)(_Out_ D3DX11_GROUP_DESC *pDesc) override { UNREFERENCED_PARAMETER(pDesc); return E_FAIL; }
|
|
|
|
STDMETHOD_(ID3DX11EffectVariable*, GetAnnotationByIndex)(_In_ uint32_t Index) override { UNREFERENCED_PARAMETER(Index); return &g_InvalidScalarVariable; }
|
|
STDMETHOD_(ID3DX11EffectVariable*, GetAnnotationByName)(_In_z_ LPCSTR Name) override { UNREFERENCED_PARAMETER(Name); return &g_InvalidScalarVariable; }
|
|
|
|
STDMETHOD_(ID3DX11EffectTechnique*, GetTechniqueByIndex)(_In_ uint32_t Index) override { UNREFERENCED_PARAMETER(Index); return &g_InvalidTechnique; }
|
|
STDMETHOD_(ID3DX11EffectTechnique*, GetTechniqueByName)(_In_z_ LPCSTR Name) override { UNREFERENCED_PARAMETER(Name); return &g_InvalidTechnique; }
|
|
|
|
IUNKNOWN_IMP(SEffectInvalidGroup, ID3DX11EffectGroup, IUnknown);
|
|
};
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
// Helper routines
|
|
//////////////////////////////////////////////////////////////////////////
|
|
|
|
// This is an annoying warning that pops up in retail builds because
|
|
// the code that jumps to "lExit" is conditionally not compiled.
|
|
// The only alternative is more #ifdefs in every function
|
|
#pragma warning( disable : 4102 ) // 'label' : unreferenced label
|
|
|
|
#define VERIFYPARAMETER(x) \
|
|
{ if (!(x)) { DPF(0, "%s: Parameter " #x " was nullptr.", pFuncName); \
|
|
__BREAK_ON_FAIL; hr = E_INVALIDARG; goto lExit; } }
|
|
|
|
static HRESULT AnnotationInvalidSetCall(LPCSTR pFuncName)
|
|
{
|
|
DPF(0, "%s: Annotations are readonly", pFuncName);
|
|
return D3DERR_INVALIDCALL;
|
|
}
|
|
|
|
static HRESULT ObjectSetRawValue()
|
|
{
|
|
DPF(0, "ID3DX11EffectVariable::SetRawValue: Objects do not support ths call; please use the specific object accessors instead.");
|
|
return D3DERR_INVALIDCALL;
|
|
}
|
|
|
|
static HRESULT ObjectGetRawValue()
|
|
{
|
|
DPF(0, "ID3DX11EffectVariable::GetRawValue: Objects do not support ths call; please use the specific object accessors instead.");
|
|
return D3DERR_INVALIDCALL;
|
|
}
|
|
|
|
ID3DX11EffectConstantBuffer * NoParentCB();
|
|
|
|
ID3DX11EffectVariable * GetAnnotationByIndexHelper(_In_z_ const char *pClassName, _In_ uint32_t Index,
|
|
_In_ uint32_t AnnotationCount, _In_reads_(AnnotationCount) SAnnotation *pAnnotations);
|
|
|
|
ID3DX11EffectVariable * GetAnnotationByNameHelper(_In_z_ const char *pClassName, _In_z_ LPCSTR Name,
|
|
_In_ uint32_t AnnotationCount, _In_reads_(AnnotationCount) SAnnotation *pAnnotations);
|
|
|
|
template<typename SVarType>
|
|
_Success_(return)
|
|
bool GetVariableByIndexHelper(_In_ uint32_t Index, _In_ uint32_t VariableCount, _In_reads_(VariableCount) SVarType *pVariables,
|
|
_In_opt_ uint8_t *pBaseAddress, _Outptr_ SVarType **ppMember, _Outptr_ void **ppDataPtr)
|
|
{
|
|
static LPCSTR pFuncName = "ID3DX11EffectVariable::GetMemberByIndex";
|
|
|
|
if (Index >= VariableCount)
|
|
{
|
|
DPF(0, "%s: Invalid index (%u, total: %u)", pFuncName, Index, VariableCount);
|
|
return false;
|
|
}
|
|
|
|
*ppMember = pVariables + Index;
|
|
*ppDataPtr = pBaseAddress + (*ppMember)->Data.Offset;
|
|
return true;
|
|
}
|
|
|
|
template<typename SVarType>
|
|
_Success_(return)
|
|
bool GetVariableByNameHelper(_In_z_ LPCSTR Name, _In_ uint32_t VariableCount, _In_reads_(VariableCount) SVarType *pVariables,
|
|
_In_opt_ uint8_t *pBaseAddress, _Outptr_ SVarType **ppMember, _Outptr_ void **ppDataPtr, _Out_ uint32_t* pIndex)
|
|
{
|
|
static LPCSTR pFuncName = "ID3DX11EffectVariable::GetMemberByName";
|
|
|
|
if (nullptr == Name)
|
|
{
|
|
DPF(0, "%s: Parameter Name was nullptr.", pFuncName);
|
|
return false;
|
|
}
|
|
|
|
bool bHasSuper = false;
|
|
|
|
for (uint32_t i = 0; i < VariableCount; ++ i)
|
|
{
|
|
*ppMember = pVariables + i;
|
|
assert((*ppMember)->pName != 0);
|
|
_Analysis_assume_((*ppMember)->pName != 0);
|
|
if (strcmp((*ppMember)->pName, Name) == 0)
|
|
{
|
|
*ppDataPtr = pBaseAddress + (*ppMember)->Data.Offset;
|
|
*pIndex = i;
|
|
return true;
|
|
}
|
|
else if (i == 0 &&
|
|
(*ppMember)->pName[0] == '$' &&
|
|
strcmp((*ppMember)->pName, "$super") == 0)
|
|
{
|
|
bHasSuper = true;
|
|
}
|
|
}
|
|
|
|
if (bHasSuper)
|
|
{
|
|
SVarType* pSuper = pVariables;
|
|
|
|
return GetVariableByNameHelper<SVarType>(Name,
|
|
pSuper->pType->StructType.Members,
|
|
(SVarType*)pSuper->pType->StructType.pMembers,
|
|
pBaseAddress + pSuper->Data.Offset,
|
|
ppMember,
|
|
ppDataPtr,
|
|
pIndex);
|
|
}
|
|
|
|
DPF(0, "%s: Variable [%s] not found", pFuncName, Name);
|
|
return false;
|
|
}
|
|
|
|
template<typename SVarType>
|
|
_Success_(return)
|
|
bool GetVariableBySemanticHelper(_In_z_ LPCSTR Semantic, _In_ uint32_t VariableCount, _In_reads_(VariableCount) SVarType *pVariables,
|
|
_In_opt_ uint8_t *pBaseAddress, _Outptr_ SVarType **ppMember, _Outptr_ void **ppDataPtr, _Out_ uint32_t* pIndex)
|
|
{
|
|
static LPCSTR pFuncName = "ID3DX11EffectVariable::GetMemberBySemantic";
|
|
|
|
if (nullptr == Semantic)
|
|
{
|
|
DPF(0, "%s: Parameter Semantic was nullptr.", pFuncName);
|
|
return false;
|
|
}
|
|
|
|
for (uint32_t i = 0; i < VariableCount; ++ i)
|
|
{
|
|
*ppMember = pVariables + i;
|
|
if (nullptr != (*ppMember)->pSemantic &&
|
|
_stricmp((*ppMember)->pSemantic, Semantic) == 0)
|
|
{
|
|
*ppDataPtr = pBaseAddress + (*ppMember)->Data.Offset;
|
|
*pIndex = i;
|
|
return true;
|
|
}
|
|
}
|
|
|
|
DPF(0, "%s: Variable with semantic [%s] not found", pFuncName, Semantic);
|
|
return false;
|
|
}
|
|
|
|
inline bool AreBoundsValid(_In_ uint32_t Offset, _In_ uint32_t Count, _In_ const void *pData, _In_ const SType *pType, _In_ uint32_t TotalUnpackedSize)
|
|
{
|
|
if (Count == 0) return true;
|
|
uint32_t singleElementSize = pType->GetTotalUnpackedSize(true);
|
|
assert(singleElementSize <= pType->Stride);
|
|
|
|
return ((Offset + Count >= Offset) &&
|
|
((Offset + Count) < ((uint32_t)-1) / pType->Stride) &&
|
|
(Count * pType->Stride + (uint8_t*)pData >= (uint8_t*)pData) &&
|
|
((Offset + Count - 1) * pType->Stride + singleElementSize <= TotalUnpackedSize));
|
|
}
|
|
|
|
// Note that the branches in this code is based on template parameters and will be compiled out
|
|
template<ETemplateVarType SourceType, ETemplateVarType DestType, typename SRC_TYPE, bool ValidatePtr>
|
|
__forceinline HRESULT CopyScalarValue(_In_ SRC_TYPE SrcValue, _Out_ void *pDest, _In_z_ const char *pFuncName)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
#ifdef _DEBUG
|
|
if (ValidatePtr)
|
|
VERIFYPARAMETER(pDest);
|
|
#else
|
|
UNREFERENCED_PARAMETER(pFuncName);
|
|
#endif
|
|
|
|
switch (SourceType)
|
|
{
|
|
case ETVT_Bool:
|
|
switch (DestType)
|
|
{
|
|
case ETVT_Bool:
|
|
*(int*)pDest = (SrcValue != 0) ? -1 : 0;
|
|
break;
|
|
|
|
case ETVT_Int:
|
|
*(int*)pDest = SrcValue ? 1 : 0;
|
|
break;
|
|
|
|
case ETVT_Float:
|
|
*(float*)pDest = SrcValue ? 1.0f : 0.0f;
|
|
break;
|
|
|
|
case ETVT_bool:
|
|
*(bool*)pDest = (SrcValue != 0) ? true : false;
|
|
break;
|
|
|
|
default:
|
|
assert(0);
|
|
}
|
|
break;
|
|
|
|
case ETVT_Int:
|
|
switch (DestType)
|
|
{
|
|
case ETVT_Bool:
|
|
*(int*)pDest = (SrcValue != 0) ? -1 : 0;
|
|
break;
|
|
|
|
case ETVT_Int:
|
|
*(int*)pDest = (int) SrcValue;
|
|
break;
|
|
|
|
case ETVT_Float:
|
|
*(float*)pDest = (float)(SrcValue);
|
|
break;
|
|
|
|
case ETVT_bool:
|
|
*(bool*)pDest = (SrcValue != 0) ? true : false;
|
|
break;
|
|
|
|
default:
|
|
assert(0);
|
|
}
|
|
break;
|
|
|
|
case ETVT_Float:
|
|
switch (DestType)
|
|
{
|
|
case ETVT_Bool:
|
|
*(int*)pDest = (SrcValue != 0.0f) ? -1 : 0;
|
|
break;
|
|
|
|
case ETVT_Int:
|
|
*(int*)pDest = (int) (SrcValue);
|
|
break;
|
|
|
|
case ETVT_Float:
|
|
*(float*)pDest = (float) SrcValue;
|
|
break;
|
|
|
|
case ETVT_bool:
|
|
*(bool*)pDest = (SrcValue != 0.0f) ? true : false;
|
|
break;
|
|
|
|
default:
|
|
assert(0);
|
|
}
|
|
break;
|
|
|
|
case ETVT_bool:
|
|
switch (DestType)
|
|
{
|
|
case ETVT_Bool:
|
|
*(int*)pDest = SrcValue ? -1 : 0;
|
|
break;
|
|
|
|
case ETVT_Int:
|
|
*(int*)pDest = SrcValue ? 1 : 0;
|
|
break;
|
|
|
|
case ETVT_Float:
|
|
*(float*)pDest = SrcValue ? 1.0f : 0.0f;
|
|
break;
|
|
|
|
case ETVT_bool:
|
|
*(bool*)pDest = (SrcValue != 0) ? true : false;
|
|
break;
|
|
|
|
default:
|
|
assert(0);
|
|
}
|
|
break;
|
|
|
|
default:
|
|
assert(0);
|
|
}
|
|
|
|
lExit:
|
|
return hr;
|
|
}
|
|
|
|
#pragma warning(push)
|
|
#pragma warning( disable : 6103 )
|
|
template<ETemplateVarType SourceType, ETemplateVarType DestType, typename SRC_TYPE, typename DEST_TYPE>
|
|
inline HRESULT SetScalarArray(_In_reads_(Count) const SRC_TYPE *pSrcValues, _Out_writes_(Count) DEST_TYPE *pDestValues,
|
|
_In_ uint32_t Offset, _In_ uint32_t Count,
|
|
_In_ const SType *pType, _In_ uint32_t TotalUnpackedSize, _In_z_ const char *pFuncName)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
|
|
#ifdef _DEBUG
|
|
VERIFYPARAMETER(pSrcValues);
|
|
|
|
#pragma warning( suppress : 6001 )
|
|
if (!AreBoundsValid(Offset, Count, pSrcValues, pType, TotalUnpackedSize))
|
|
{
|
|
DPF(0, "%s: Invalid range specified", pFuncName);
|
|
VH(E_INVALIDARG);
|
|
}
|
|
#else
|
|
UNREFERENCED_PARAMETER(TotalUnpackedSize);
|
|
UNREFERENCED_PARAMETER(pFuncName);
|
|
#endif
|
|
|
|
uint32_t i, j, delta = pType->NumericType.IsPackedArray ? 1 : SType::c_ScalarsPerRegister;
|
|
pDestValues += Offset * delta;
|
|
for (i = 0, j = 0; j < Count; i += delta, ++ j)
|
|
{
|
|
// pDestValues[i] = (DEST_TYPE)pSrcValues[j];
|
|
CopyScalarValue<SourceType, DestType, SRC_TYPE, false>(pSrcValues[j], &pDestValues[i], "SetScalarArray");
|
|
}
|
|
|
|
lExit:
|
|
return hr;
|
|
}
|
|
#pragma warning(pop)
|
|
|
|
#pragma warning( disable : 6103 )
|
|
template<ETemplateVarType SourceType, ETemplateVarType DestType, typename SRC_TYPE, typename DEST_TYPE>
|
|
inline HRESULT GetScalarArray(_In_reads_(Count) SRC_TYPE *pSrcValues, _Out_writes_(Count) DEST_TYPE *pDestValues,
|
|
_In_ uint32_t Offset, _In_ uint32_t Count,
|
|
_In_ const SType *pType, _In_ uint32_t TotalUnpackedSize, _In_z_ const char *pFuncName)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
|
|
#ifdef _DEBUG
|
|
VERIFYPARAMETER(pDestValues);
|
|
|
|
#pragma warning( suppress : 6001 )
|
|
if (!AreBoundsValid(Offset, Count, pDestValues, pType, TotalUnpackedSize))
|
|
{
|
|
DPF(0, "%s: Invalid range specified", pFuncName);
|
|
VH(E_INVALIDARG);
|
|
}
|
|
#else
|
|
UNREFERENCED_PARAMETER(TotalUnpackedSize);
|
|
UNREFERENCED_PARAMETER(pFuncName);
|
|
#endif
|
|
|
|
uint32_t i, j, delta = pType->NumericType.IsPackedArray ? 1 : SType::c_ScalarsPerRegister;
|
|
pSrcValues += Offset * delta;
|
|
for (i = 0, j = 0; j < Count; i += delta, ++ j)
|
|
{
|
|
// pDestValues[j] = (DEST_TYPE)pSrcValues[i];
|
|
CopyScalarValue<SourceType, DestType, SRC_TYPE, false>(pSrcValues[i], &pDestValues[j], "GetScalarArray");
|
|
}
|
|
|
|
lExit:
|
|
return hr;
|
|
}
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
// TVariable - implements type casting and member/element retrieval
|
|
//////////////////////////////////////////////////////////////////////////
|
|
|
|
// requires that IBaseInterface contain SVariable's fields and support ID3DX11EffectVariable
|
|
template<typename IBaseInterface>
|
|
struct TVariable : public IBaseInterface
|
|
{
|
|
STDMETHOD_(bool, IsValid)() override { return true; }
|
|
|
|
STDMETHOD_(ID3DX11EffectVariable*, GetMemberByIndex)(_In_ uint32_t Index)
|
|
{
|
|
SVariable *pMember;
|
|
UDataPointer dataPtr;
|
|
auto pTopLevelEntity2 = GetTopLevelEntity();
|
|
|
|
if (((ID3DX11Effect*)pTopLevelEntity2->pEffect)->IsOptimized())
|
|
{
|
|
DPF(0, "ID3DX11EffectVariable::GetMemberByIndex: Cannot get members; effect has been Optimize()'ed");
|
|
return &g_InvalidScalarVariable;
|
|
}
|
|
|
|
if (pType->VarType != EVT_Struct)
|
|
{
|
|
DPF(0, "ID3DX11EffectVariable::GetMemberByIndex: Variable is not a structure");
|
|
return &g_InvalidScalarVariable;
|
|
}
|
|
|
|
if (!GetVariableByIndexHelper<SVariable>(Index, pType->StructType.Members, pType->StructType.pMembers,
|
|
Data.pNumeric, &pMember, &dataPtr.pGeneric))
|
|
{
|
|
return &g_InvalidScalarVariable;
|
|
}
|
|
|
|
return pTopLevelEntity2->pEffect->CreatePooledVariableMemberInterface(pTopLevelEntity2, pMember, dataPtr, false, Index);
|
|
}
|
|
|
|
STDMETHOD_(ID3DX11EffectVariable*, GetMemberByName)(_In_z_ LPCSTR Name)
|
|
{
|
|
SVariable *pMember;
|
|
UDataPointer dataPtr;
|
|
uint32_t index;
|
|
auto pTopLevelEntity2 = GetTopLevelEntity();
|
|
|
|
if (pTopLevelEntity2->pEffect->IsOptimized())
|
|
{
|
|
DPF(0, "ID3DX11EffectVariable::GetMemberByName: Cannot get members; effect has been Optimize()'ed");
|
|
return &g_InvalidScalarVariable;
|
|
}
|
|
|
|
if (pType->VarType != EVT_Struct)
|
|
{
|
|
DPF(0, "ID3DX11EffectVariable::GetMemberByName: Variable is not a structure");
|
|
return &g_InvalidScalarVariable;
|
|
}
|
|
|
|
if (!GetVariableByNameHelper<SVariable>(Name, pType->StructType.Members, pType->StructType.pMembers,
|
|
Data.pNumeric, &pMember, &dataPtr.pGeneric, &index))
|
|
{
|
|
return &g_InvalidScalarVariable;
|
|
|
|
}
|
|
|
|
return pTopLevelEntity2->pEffect->CreatePooledVariableMemberInterface(pTopLevelEntity2, pMember, dataPtr, false, index);
|
|
}
|
|
|
|
STDMETHOD_(ID3DX11EffectVariable*, GetMemberBySemantic)(_In_z_ LPCSTR Semantic)
|
|
{
|
|
SVariable *pMember;
|
|
UDataPointer dataPtr;
|
|
uint32_t index;
|
|
auto pTopLevelEntity2 = GetTopLevelEntity();
|
|
|
|
if (pTopLevelEntity2->pEffect->IsOptimized())
|
|
{
|
|
DPF(0, "ID3DX11EffectVariable::GetMemberBySemantic: Cannot get members; effect has been Optimize()'ed");
|
|
return &g_InvalidScalarVariable;
|
|
}
|
|
|
|
if (pType->VarType != EVT_Struct)
|
|
{
|
|
DPF(0, "ID3DX11EffectVariable::GetMemberBySemantic: Variable is not a structure");
|
|
return &g_InvalidScalarVariable;
|
|
}
|
|
|
|
if (!GetVariableBySemanticHelper<SVariable>(Semantic, pType->StructType.Members, pType->StructType.pMembers,
|
|
Data.pNumeric, &pMember, &dataPtr.pGeneric, &index))
|
|
{
|
|
return &g_InvalidScalarVariable;
|
|
|
|
}
|
|
|
|
return pTopLevelEntity2->pEffect->CreatePooledVariableMemberInterface(pTopLevelEntity2, pMember, dataPtr, false, index);
|
|
}
|
|
|
|
STDMETHOD_(ID3DX11EffectVariable*, GetElement)(_In_ uint32_t Index)
|
|
{
|
|
static LPCSTR pFuncName = "ID3DX11EffectVariable::GetElement";
|
|
auto pTopLevelEntity2 = GetTopLevelEntity();
|
|
UDataPointer dataPtr;
|
|
|
|
if (pTopLevelEntity2->pEffect->IsOptimized())
|
|
{
|
|
DPF(0, "ID3DX11EffectVariable::GetElement: Cannot get element; effect has been Optimize()'ed");
|
|
return &g_InvalidScalarVariable;
|
|
}
|
|
|
|
if (!IsArray())
|
|
{
|
|
DPF(0, "%s: This interface does not refer to an array", pFuncName);
|
|
return &g_InvalidScalarVariable;
|
|
}
|
|
|
|
if (Index >= pType->Elements)
|
|
{
|
|
DPF(0, "%s: Invalid element index (%u, total: %u)", pFuncName, Index, pType->Elements);
|
|
return &g_InvalidScalarVariable;
|
|
}
|
|
|
|
if (pType->BelongsInConstantBuffer())
|
|
{
|
|
dataPtr.pGeneric = Data.pNumeric + pType->Stride * Index;
|
|
}
|
|
else
|
|
{
|
|
dataPtr.pGeneric = GetBlockByIndex(pType->VarType, pType->ObjectType, Data.pGeneric, Index);
|
|
if (nullptr == dataPtr.pGeneric)
|
|
{
|
|
DPF(0, "%s: Internal error", pFuncName);
|
|
return &g_InvalidScalarVariable;
|
|
}
|
|
}
|
|
|
|
return pTopLevelEntity2->pEffect->CreatePooledVariableMemberInterface(pTopLevelEntity2, (SVariable *) this, dataPtr, true, Index);
|
|
}
|
|
|
|
STDMETHOD_(ID3DX11EffectScalarVariable*, AsScalar)()
|
|
{
|
|
static LPCSTR pFuncName = "ID3DX11EffectVariable::AsScalar";
|
|
|
|
if (pType->VarType != EVT_Numeric ||
|
|
pType->NumericType.NumericLayout != ENL_Scalar)
|
|
{
|
|
DPF(0, "%s: Invalid typecast", pFuncName);
|
|
return &g_InvalidScalarVariable;
|
|
}
|
|
|
|
return (ID3DX11EffectScalarVariable *) this;
|
|
}
|
|
|
|
STDMETHOD_(ID3DX11EffectVectorVariable*, AsVector)()
|
|
{
|
|
static LPCSTR pFuncName = "ID3DX11EffectVariable::AsVector";
|
|
|
|
if (pType->VarType != EVT_Numeric ||
|
|
pType->NumericType.NumericLayout != ENL_Vector)
|
|
{
|
|
DPF(0, "%s: Invalid typecast", pFuncName);
|
|
return &g_InvalidVectorVariable;
|
|
}
|
|
|
|
return (ID3DX11EffectVectorVariable *) this;
|
|
}
|
|
|
|
STDMETHOD_(ID3DX11EffectMatrixVariable*, AsMatrix)()
|
|
{
|
|
static LPCSTR pFuncName = "ID3DX11EffectVariable::AsMatrix";
|
|
|
|
if (pType->VarType != EVT_Numeric ||
|
|
pType->NumericType.NumericLayout != ENL_Matrix)
|
|
{
|
|
DPF(0, "%s: Invalid typecast", pFuncName);
|
|
return &g_InvalidMatrixVariable;
|
|
}
|
|
|
|
return (ID3DX11EffectMatrixVariable *) this;
|
|
}
|
|
|
|
STDMETHOD_(ID3DX11EffectStringVariable*, AsString)()
|
|
{
|
|
static LPCSTR pFuncName = "ID3DX11EffectVariable::AsString";
|
|
|
|
if (!pType->IsObjectType(EOT_String))
|
|
{
|
|
DPF(0, "%s: Invalid typecast", pFuncName);
|
|
return &g_InvalidStringVariable;
|
|
}
|
|
|
|
return (ID3DX11EffectStringVariable *) this;
|
|
}
|
|
|
|
STDMETHOD_(ID3DX11EffectClassInstanceVariable*, AsClassInstance)()
|
|
{
|
|
static LPCSTR pFuncName = "ID3DX11EffectVariable::AsClassInstance";
|
|
|
|
if (!pType->IsClassInstance() )
|
|
{
|
|
DPF(0, "%s: Invalid typecast", pFuncName);
|
|
return &g_InvalidClassInstanceVariable;
|
|
}
|
|
else if( pMemberData == nullptr )
|
|
{
|
|
DPF(0, "%s: Non-global class instance variables (members of structs or classes) and class instances "
|
|
"inside tbuffers are not supported.", pFuncName );
|
|
return &g_InvalidClassInstanceVariable;
|
|
}
|
|
|
|
return (ID3DX11EffectClassInstanceVariable *) this;
|
|
}
|
|
|
|
STDMETHOD_(ID3DX11EffectInterfaceVariable*, AsInterface)()
|
|
{
|
|
static LPCSTR pFuncName = "ID3DX11EffectVariable::AsInterface";
|
|
|
|
if (!pType->IsInterface())
|
|
{
|
|
DPF(0, "%s: Invalid typecast", pFuncName);
|
|
return &g_InvalidInterfaceVariable;
|
|
}
|
|
|
|
return (ID3DX11EffectInterfaceVariable *) this;
|
|
}
|
|
|
|
STDMETHOD_(ID3DX11EffectShaderResourceVariable*, AsShaderResource)()
|
|
{
|
|
static LPCSTR pFuncName = "ID3DX11EffectVariable::AsShaderResource";
|
|
|
|
if (!pType->IsShaderResource())
|
|
{
|
|
DPF(0, "%s: Invalid typecast", pFuncName);
|
|
return &g_InvalidShaderResourceVariable;
|
|
}
|
|
|
|
return (ID3DX11EffectShaderResourceVariable *) this;
|
|
}
|
|
|
|
STDMETHOD_(ID3DX11EffectUnorderedAccessViewVariable*, AsUnorderedAccessView)()
|
|
{
|
|
static LPCSTR pFuncName = "ID3DX11EffectVariable::AsUnorderedAccessView";
|
|
|
|
if (!pType->IsUnorderedAccessView())
|
|
{
|
|
DPF(0, "%s: Invalid typecast", pFuncName);
|
|
return &g_InvalidUnorderedAccessViewVariable;
|
|
}
|
|
|
|
return (ID3DX11EffectUnorderedAccessViewVariable *) this;
|
|
}
|
|
|
|
STDMETHOD_(ID3DX11EffectRenderTargetViewVariable*, AsRenderTargetView)()
|
|
{
|
|
static LPCSTR pFuncName = "ID3DX11EffectVariable::AsRenderTargetView";
|
|
|
|
if (!pType->IsRenderTargetView())
|
|
{
|
|
DPF(0, "%s: Invalid typecast", pFuncName);
|
|
return &g_InvalidRenderTargetViewVariable;
|
|
}
|
|
|
|
return (ID3DX11EffectRenderTargetViewVariable *) this;
|
|
}
|
|
|
|
STDMETHOD_(ID3DX11EffectDepthStencilViewVariable*, AsDepthStencilView)()
|
|
{
|
|
static LPCSTR pFuncName = "ID3DX11EffectVariable::AsDepthStencilView";
|
|
|
|
if (!pType->IsDepthStencilView())
|
|
{
|
|
DPF(0, "%s: Invalid typecast", pFuncName);
|
|
return &g_InvalidDepthStencilViewVariable;
|
|
}
|
|
|
|
return (ID3DX11EffectDepthStencilViewVariable *) this;
|
|
}
|
|
|
|
STDMETHOD_(ID3DX11EffectConstantBuffer*, AsConstantBuffer)()
|
|
{
|
|
static LPCSTR pFuncName = "ID3DX11EffectVariable::AsConstantBuffer";
|
|
DPF(0, "%s: Invalid typecast", pFuncName);
|
|
return &g_InvalidConstantBuffer;
|
|
}
|
|
|
|
STDMETHOD_(ID3DX11EffectShaderVariable*, AsShader)()
|
|
{
|
|
static LPCSTR pFuncName = "ID3DX11EffectVariable::AsShader";
|
|
|
|
if (!pType->IsShader())
|
|
{
|
|
DPF(0, "%s: Invalid typecast", pFuncName);
|
|
return &g_InvalidShaderVariable;
|
|
}
|
|
|
|
return (ID3DX11EffectShaderVariable *) this;
|
|
}
|
|
|
|
STDMETHOD_(ID3DX11EffectBlendVariable*, AsBlend)()
|
|
{
|
|
static LPCSTR pFuncName = "ID3DX11EffectVariable::AsBlend";
|
|
|
|
if (!pType->IsObjectType(EOT_Blend))
|
|
{
|
|
DPF(0, "%s: Invalid typecast", pFuncName);
|
|
return &g_InvalidBlendVariable;
|
|
}
|
|
|
|
return (ID3DX11EffectBlendVariable *) this;
|
|
}
|
|
|
|
STDMETHOD_(ID3DX11EffectDepthStencilVariable*, AsDepthStencil)()
|
|
{
|
|
static LPCSTR pFuncName = "ID3DX11EffectVariable::AsDepthStencil";
|
|
|
|
if (!pType->IsObjectType(EOT_DepthStencil))
|
|
{
|
|
DPF(0, "%s: Invalid typecast", pFuncName);
|
|
return &g_InvalidDepthStencilVariable;
|
|
}
|
|
|
|
return (ID3DX11EffectDepthStencilVariable *) this;
|
|
}
|
|
|
|
STDMETHOD_(ID3DX11EffectRasterizerVariable*, AsRasterizer)()
|
|
{
|
|
static LPCSTR pFuncName = "ID3DX11EffectVariable::AsRasterizer";
|
|
|
|
if (!pType->IsObjectType(EOT_Rasterizer))
|
|
{
|
|
DPF(0, "%s: Invalid typecast", pFuncName);
|
|
return &g_InvalidRasterizerVariable;
|
|
}
|
|
|
|
return (ID3DX11EffectRasterizerVariable *) this;
|
|
}
|
|
|
|
STDMETHOD_(ID3DX11EffectSamplerVariable*, AsSampler)()
|
|
{
|
|
static LPCSTR pFuncName = "ID3DX11EffectVariable::AsSampler";
|
|
|
|
if (!pType->IsSampler())
|
|
{
|
|
DPF(0, "%s: Invalid typecast", pFuncName);
|
|
return &g_InvalidSamplerVariable;
|
|
}
|
|
|
|
return (ID3DX11EffectSamplerVariable *) this;
|
|
}
|
|
|
|
// Numeric variables should override this
|
|
STDMETHOD(SetRawValue)(_In_reads_bytes_(Count) const void *pData, _In_ uint32_t Offset, _In_ uint32_t Count)
|
|
{ UNREFERENCED_PARAMETER(pData); UNREFERENCED_PARAMETER(Offset); UNREFERENCED_PARAMETER(Count); return ObjectSetRawValue(); }
|
|
STDMETHOD(GetRawValue)(_Out_writes_(Count) void *pData, _In_ uint32_t Offset, _In_ uint32_t Count)
|
|
{ UNREFERENCED_PARAMETER(pData); UNREFERENCED_PARAMETER(Offset); UNREFERENCED_PARAMETER(Count); return ObjectGetRawValue(); }
|
|
};
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
// TTopLevelVariable - functionality for annotations and global variables
|
|
//////////////////////////////////////////////////////////////////////////
|
|
|
|
template<typename IBaseInterface>
|
|
struct TTopLevelVariable : public SVariable, public IBaseInterface
|
|
{
|
|
// Required to create member/element variable interfaces
|
|
CEffect *pEffect;
|
|
|
|
CEffect* GetEffect()
|
|
{
|
|
return pEffect;
|
|
}
|
|
|
|
TTopLevelVariable() noexcept :
|
|
pEffect(nullptr)
|
|
{
|
|
}
|
|
|
|
uint32_t GetTotalUnpackedSize()
|
|
{
|
|
return ((SType*)pType)->GetTotalUnpackedSize(false);
|
|
}
|
|
|
|
STDMETHOD_(ID3DX11EffectType*, GetType)()
|
|
{
|
|
return (ID3DX11EffectType*)(SType*)pType;
|
|
}
|
|
|
|
TTopLevelVariable<ID3DX11EffectVariable> * GetTopLevelEntity()
|
|
{
|
|
return (TTopLevelVariable<ID3DX11EffectVariable> *)this;
|
|
}
|
|
|
|
bool IsArray()
|
|
{
|
|
return (pType->Elements > 0);
|
|
}
|
|
|
|
};
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
// TMember - functionality for structure/array members of other variables
|
|
//////////////////////////////////////////////////////////////////////////
|
|
|
|
template<typename IBaseInterface>
|
|
struct TMember : public SVariable, public IBaseInterface
|
|
{
|
|
// Indicates that this is a single element of a containing array
|
|
uint32_t IsSingleElement : 1;
|
|
|
|
// Required to create member/element variable interfaces
|
|
TTopLevelVariable<ID3DX11EffectVariable> *pTopLevelEntity;
|
|
|
|
TMember() noexcept :
|
|
IsSingleElement(false),
|
|
pTopLevelEntity(nullptr)
|
|
{
|
|
}
|
|
|
|
CEffect* GetEffect()
|
|
{
|
|
return pTopLevelEntity->pEffect;
|
|
}
|
|
|
|
uint32_t GetTotalUnpackedSize()
|
|
{
|
|
return pType->GetTotalUnpackedSize(IsSingleElement);
|
|
}
|
|
|
|
STDMETHOD_(ID3DX11EffectType*, GetType)() override
|
|
{
|
|
if (IsSingleElement)
|
|
{
|
|
return pTopLevelEntity->pEffect->CreatePooledSingleElementTypeInterface( pType );
|
|
}
|
|
else
|
|
{
|
|
return (ID3DX11EffectType*) pType;
|
|
}
|
|
}
|
|
|
|
STDMETHOD(GetDesc)(_Out_ D3DX11_EFFECT_VARIABLE_DESC *pDesc) override
|
|
{
|
|
HRESULT hr = S_OK;
|
|
static LPCSTR pFuncName = "ID3DX11EffectVariable::GetDesc";
|
|
|
|
VERIFYPARAMETER(pDesc != nullptr);
|
|
|
|
pDesc->Name = pName;
|
|
pDesc->Semantic = pSemantic;
|
|
pDesc->Flags = 0;
|
|
|
|
if (pTopLevelEntity->pEffect->IsReflectionData(pTopLevelEntity))
|
|
{
|
|
// Is part of an annotation
|
|
assert(pTopLevelEntity->pEffect->IsReflectionData(Data.pGeneric));
|
|
pDesc->Annotations = 0;
|
|
pDesc->BufferOffset = 0;
|
|
pDesc->Flags |= D3DX11_EFFECT_VARIABLE_ANNOTATION;
|
|
}
|
|
else
|
|
{
|
|
// Is part of a global variable
|
|
assert(pTopLevelEntity->pEffect->IsRuntimeData(pTopLevelEntity));
|
|
if (!pTopLevelEntity->pType->IsObjectType(EOT_String))
|
|
{
|
|
// strings are funny; their data is reflection data, so ignore those
|
|
assert(pTopLevelEntity->pEffect->IsRuntimeData(Data.pGeneric));
|
|
}
|
|
|
|
pDesc->Annotations = ((TGlobalVariable<ID3DX11Effect>*)pTopLevelEntity)->AnnotationCount;
|
|
|
|
SConstantBuffer *pCB = ((TGlobalVariable<ID3DX11Effect>*)pTopLevelEntity)->pCB;
|
|
|
|
if (pType->BelongsInConstantBuffer())
|
|
{
|
|
assert(pCB != 0);
|
|
_Analysis_assume_(pCB != 0);
|
|
UINT_PTR offset = Data.pNumeric - pCB->pBackingStore;
|
|
assert(offset == (uint32_t)offset);
|
|
pDesc->BufferOffset = (uint32_t)offset;
|
|
assert(pDesc->BufferOffset >= 0 && pDesc->BufferOffset + GetTotalUnpackedSize() <= pCB->Size);
|
|
}
|
|
else
|
|
{
|
|
assert(pCB == nullptr);
|
|
pDesc->BufferOffset = 0;
|
|
}
|
|
}
|
|
|
|
lExit:
|
|
return hr;
|
|
}
|
|
|
|
TTopLevelVariable<ID3DX11EffectVariable> * GetTopLevelEntity()
|
|
{
|
|
return pTopLevelEntity;
|
|
}
|
|
|
|
bool IsArray()
|
|
{
|
|
return (pType->Elements > 0 && !IsSingleElement);
|
|
}
|
|
|
|
STDMETHOD_(ID3DX11EffectVariable*, GetAnnotationByIndex)(_In_ uint32_t Index) override
|
|
{ return pTopLevelEntity->GetAnnotationByIndex(Index); }
|
|
STDMETHOD_(ID3DX11EffectVariable*, GetAnnotationByName)(_In_z_ LPCSTR Name) override
|
|
{ return pTopLevelEntity->GetAnnotationByName(Name); }
|
|
|
|
STDMETHOD_(ID3DX11EffectConstantBuffer*, GetParentConstantBuffer)() override
|
|
{ return pTopLevelEntity->GetParentConstantBuffer(); }
|
|
|
|
// Annotations should never be able to go down this codepath
|
|
void DirtyVariable()
|
|
{
|
|
// make sure to call the global variable's version of dirty variable
|
|
((TGlobalVariable<ID3DX11EffectVariable>*)pTopLevelEntity)->DirtyVariable();
|
|
}
|
|
};
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
// TAnnotation - functionality for top level annotations
|
|
//////////////////////////////////////////////////////////////////////////
|
|
|
|
template<typename IBaseInterface>
|
|
struct TAnnotation : public TVariable<TTopLevelVariable<IBaseInterface> >
|
|
{
|
|
STDMETHOD(GetDesc)(_Out_ D3DX11_EFFECT_VARIABLE_DESC *pDesc) override
|
|
{
|
|
HRESULT hr = S_OK;
|
|
static LPCSTR pFuncName = "ID3DX11EffectVariable::GetDesc";
|
|
|
|
VERIFYPARAMETER(pDesc != nullptr);
|
|
|
|
pDesc->Name = pName;
|
|
pDesc->Semantic = pSemantic;
|
|
pDesc->Flags = D3DX11_EFFECT_VARIABLE_ANNOTATION;
|
|
pDesc->Annotations = 0;
|
|
pDesc->BufferOffset = 0;
|
|
pDesc->ExplicitBindPoint = 0;
|
|
|
|
lExit:
|
|
return hr;
|
|
|
|
}
|
|
|
|
STDMETHOD_(ID3DX11EffectVariable*, GetAnnotationByIndex)(_In_ uint32_t Index) override
|
|
{
|
|
UNREFERENCED_PARAMETER(Index);
|
|
static LPCSTR pFuncName = "ID3DX11EffectVariable::GetAnnotationByIndex";
|
|
DPF(0, "%s: Only variables may have annotations", pFuncName);
|
|
return &g_InvalidScalarVariable;
|
|
}
|
|
|
|
STDMETHOD_(ID3DX11EffectVariable*, GetAnnotationByName)(_In_z_ LPCSTR Name) override
|
|
{
|
|
UNREFERENCED_PARAMETER(Name);
|
|
static LPCSTR pFuncName = "ID3DX11EffectVariable::GetAnnotationByName";
|
|
DPF(0, "%s: Only variables may have annotations", pFuncName);
|
|
return &g_InvalidScalarVariable;
|
|
}
|
|
|
|
STDMETHOD_(ID3DX11EffectConstantBuffer*, GetParentConstantBuffer)() override
|
|
{ return NoParentCB(); }
|
|
|
|
void DirtyVariable()
|
|
{
|
|
assert(0);
|
|
}
|
|
};
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
// TGlobalVariable - functionality for top level global variables
|
|
//////////////////////////////////////////////////////////////////////////
|
|
|
|
template<typename IBaseInterface>
|
|
struct TGlobalVariable : public TVariable<TTopLevelVariable<IBaseInterface> >
|
|
{
|
|
Timer LastModifiedTime;
|
|
|
|
// if numeric, pointer to the constant buffer where this variable lives
|
|
SConstantBuffer *pCB;
|
|
|
|
uint32_t AnnotationCount;
|
|
SAnnotation *pAnnotations;
|
|
|
|
TGlobalVariable() noexcept :
|
|
LastModifiedTime(0),
|
|
pCB(nullptr),
|
|
AnnotationCount(0),
|
|
pAnnotations(nullptr)
|
|
{
|
|
}
|
|
|
|
STDMETHOD(GetDesc)(_Out_ D3DX11_EFFECT_VARIABLE_DESC *pDesc)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
static LPCSTR pFuncName = "ID3DX11EffectVariable::GetDesc";
|
|
|
|
VERIFYPARAMETER(pDesc != nullptr);
|
|
|
|
pDesc->Name = pName;
|
|
pDesc->Semantic = pSemantic;
|
|
pDesc->Flags = 0;
|
|
pDesc->Annotations = AnnotationCount;
|
|
|
|
if (pType->BelongsInConstantBuffer())
|
|
{
|
|
assert(pCB != 0);
|
|
_Analysis_assume_(pCB != 0);
|
|
UINT_PTR offset = Data.pNumeric - pCB->pBackingStore;
|
|
assert(offset == (uint32_t)offset);
|
|
pDesc->BufferOffset = (uint32_t)offset;
|
|
assert(pDesc->BufferOffset >= 0 && pDesc->BufferOffset + GetTotalUnpackedSize() <= pCB->Size );
|
|
}
|
|
else
|
|
{
|
|
assert(pCB == nullptr);
|
|
pDesc->BufferOffset = 0;
|
|
}
|
|
|
|
if (ExplicitBindPoint != -1)
|
|
{
|
|
pDesc->ExplicitBindPoint = ExplicitBindPoint;
|
|
pDesc->Flags |= D3DX11_EFFECT_VARIABLE_EXPLICIT_BIND_POINT;
|
|
}
|
|
else
|
|
{
|
|
pDesc->ExplicitBindPoint = 0;
|
|
}
|
|
|
|
lExit:
|
|
return hr;
|
|
}
|
|
|
|
// these are all well defined for global vars
|
|
STDMETHOD_(ID3DX11EffectVariable*, GetAnnotationByIndex)(_In_ uint32_t Index)
|
|
{
|
|
return GetAnnotationByIndexHelper("ID3DX11EffectVariable", Index, AnnotationCount, pAnnotations);
|
|
}
|
|
|
|
STDMETHOD_(ID3DX11EffectVariable*, GetAnnotationByName)(_In_z_ LPCSTR Name)
|
|
{
|
|
return GetAnnotationByNameHelper("ID3DX11EffectVariable", Name, AnnotationCount, pAnnotations);
|
|
}
|
|
|
|
STDMETHOD_(ID3DX11EffectConstantBuffer*, GetParentConstantBuffer)()
|
|
{
|
|
if (nullptr != pCB)
|
|
{
|
|
assert(pType->BelongsInConstantBuffer());
|
|
return (ID3DX11EffectConstantBuffer*)pCB;
|
|
}
|
|
else
|
|
{
|
|
assert(!pType->BelongsInConstantBuffer());
|
|
return &g_InvalidConstantBuffer;
|
|
}
|
|
}
|
|
|
|
inline void DirtyVariable()
|
|
{
|
|
assert(pCB != 0);
|
|
_Analysis_assume_(pCB != 0);
|
|
pCB->IsDirty = true;
|
|
LastModifiedTime = pEffect->GetCurrentTime();
|
|
}
|
|
|
|
};
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
// TNumericVariable - implements raw set/get functionality
|
|
//////////////////////////////////////////////////////////////////////////
|
|
|
|
// IMPORTANT NOTE: All of these numeric & object aspect classes MUST NOT
|
|
// add data members to the base variable classes. Otherwise type sizes
|
|
// will disagree between object & numeric variables and we cannot eaily
|
|
// create arrays of global variables using SGlobalVariable
|
|
|
|
// Requires that IBaseInterface have SVariable's members, GetTotalUnpackedSize() and DirtyVariable()
|
|
template<typename IBaseInterface, bool IsAnnotation>
|
|
struct TNumericVariable : public IBaseInterface
|
|
{
|
|
STDMETHOD(SetRawValue)(_In_reads_bytes_(ByteCount) const void *pData, _In_ uint32_t ByteOffset, _In_ uint32_t ByteCount) override
|
|
{
|
|
if (IsAnnotation)
|
|
{
|
|
return AnnotationInvalidSetCall("ID3DX11EffectVariable::SetRawValue");
|
|
}
|
|
else
|
|
{
|
|
HRESULT hr = S_OK;
|
|
|
|
#ifdef _DEBUG
|
|
static LPCSTR pFuncName = "ID3DX11EffectVariable::SetRawValue";
|
|
|
|
VERIFYPARAMETER(pData);
|
|
|
|
if ((ByteOffset + ByteCount < ByteOffset) ||
|
|
(ByteCount + (uint8_t*)pData < (uint8_t*)pData) ||
|
|
((ByteOffset + ByteCount) > GetTotalUnpackedSize()))
|
|
{
|
|
// overflow of some kind
|
|
DPF(0, "%s: Invalid range specified", pFuncName);
|
|
VH(E_INVALIDARG);
|
|
}
|
|
#endif
|
|
|
|
DirtyVariable();
|
|
memcpy(Data.pNumeric + ByteOffset, pData, ByteCount);
|
|
|
|
lExit:
|
|
return hr;
|
|
}
|
|
}
|
|
|
|
STDMETHOD(GetRawValue)(_Out_writes_bytes_(ByteCount) void *pData, _In_ uint32_t ByteOffset, _In_ uint32_t ByteCount) override
|
|
{
|
|
HRESULT hr = S_OK;
|
|
|
|
#ifdef _DEBUG
|
|
static LPCSTR pFuncName = "ID3DX11EffectVariable::GetRawValue";
|
|
|
|
VERIFYPARAMETER(pData);
|
|
|
|
if ((ByteOffset + ByteCount < ByteOffset) ||
|
|
(ByteCount + (uint8_t*)pData < (uint8_t*)pData) ||
|
|
((ByteOffset + ByteCount) > GetTotalUnpackedSize()))
|
|
{
|
|
// overflow of some kind
|
|
DPF(0, "%s: Invalid range specified", pFuncName);
|
|
VH(E_INVALIDARG);
|
|
}
|
|
#endif
|
|
|
|
memcpy(pData, Data.pNumeric + ByteOffset, ByteCount);
|
|
|
|
lExit:
|
|
return hr;
|
|
}
|
|
};
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
// ID3DX11EffectScalarVariable (TFloatScalarVariable implementation)
|
|
//////////////////////////////////////////////////////////////////////////
|
|
|
|
template<typename IBaseInterface, bool IsAnnotation>
|
|
struct TFloatScalarVariable : public TNumericVariable<IBaseInterface, IsAnnotation>
|
|
{
|
|
STDMETHOD(SetFloat)(_In_ float Value) override;
|
|
STDMETHOD(GetFloat)(_Out_ float *pValue) override;
|
|
|
|
STDMETHOD(SetFloatArray)(_In_reads_(Count) const float *pData, _In_ uint32_t Offset, _In_ uint32_t Count) override;
|
|
STDMETHOD(GetFloatArray)(_Out_writes_(Count) float *pData, _In_ uint32_t Offset, _In_ uint32_t Count) override;
|
|
|
|
STDMETHOD(SetInt)(_In_ int Value) override;
|
|
STDMETHOD(GetInt)(_Out_ int *pValue) override;
|
|
|
|
STDMETHOD(SetIntArray)(_In_reads_(Count) const int *pData, _In_ uint32_t Offset, _In_ uint32_t Count) override;
|
|
STDMETHOD(GetIntArray)(_Out_writes_(Count) int *pData, _In_ uint32_t Offset, _In_ uint32_t Count) override;
|
|
|
|
STDMETHOD(SetBool)(_In_ bool Value) override;
|
|
STDMETHOD(GetBool)(_Out_ bool *pValue) override;
|
|
|
|
STDMETHOD(SetBoolArray)(_In_reads_(Count) const bool *pData, _In_ uint32_t Offset, _In_ uint32_t Count) override;
|
|
STDMETHOD(GetBoolArray)(_Out_writes_(Count) bool *pData, _In_ uint32_t Offset, _In_ uint32_t Count) override;
|
|
};
|
|
|
|
template<typename IBaseInterface, bool IsAnnotation>
|
|
_Use_decl_annotations_
|
|
HRESULT TFloatScalarVariable<IBaseInterface, IsAnnotation>::SetFloat(float Value)
|
|
{
|
|
static LPCSTR pFuncName = "ID3DX11EffectScalarVariable::SetFloat";
|
|
if (IsAnnotation) return AnnotationInvalidSetCall(pFuncName);
|
|
DirtyVariable();
|
|
return CopyScalarValue<ETVT_Float, ETVT_Float, float, false>(Value, Data.pNumericFloat, pFuncName);
|
|
}
|
|
|
|
template<typename IBaseInterface, bool IsAnnotation>
|
|
_Use_decl_annotations_
|
|
HRESULT TFloatScalarVariable<IBaseInterface, IsAnnotation>::GetFloat(float *pValue)
|
|
{
|
|
return CopyScalarValue<ETVT_Float, ETVT_Float, float, true>(*Data.pNumericFloat, pValue, "ID3DX11EffectScalarVariable::GetFloat");
|
|
}
|
|
|
|
template<typename IBaseInterface, bool IsAnnotation>
|
|
_Use_decl_annotations_
|
|
HRESULT TFloatScalarVariable<IBaseInterface, IsAnnotation>::SetFloatArray(const float *pData, uint32_t Offset, uint32_t Count)
|
|
{
|
|
static LPCSTR pFuncName = "ID3DX11EffectScalarVariable::SetFloatArray";
|
|
if (IsAnnotation) return AnnotationInvalidSetCall(pFuncName);
|
|
DirtyVariable();
|
|
return SetScalarArray<ETVT_Float, ETVT_Float, float, float>(pData, Data.pNumericFloat, Offset, Count,
|
|
pType, GetTotalUnpackedSize(), pFuncName);
|
|
}
|
|
|
|
template<typename IBaseInterface, bool IsAnnotation>
|
|
_Use_decl_annotations_
|
|
HRESULT TFloatScalarVariable<IBaseInterface, IsAnnotation>::GetFloatArray(float *pData, uint32_t Offset, uint32_t Count)
|
|
{
|
|
return GetScalarArray<ETVT_Float, ETVT_Float, float, float>(Data.pNumericFloat, pData, Offset, Count,
|
|
pType, GetTotalUnpackedSize(), "ID3DX11EffectScalarVariable::GetFloatArray");
|
|
}
|
|
|
|
template<typename IBaseInterface, bool IsAnnotation>
|
|
_Use_decl_annotations_
|
|
HRESULT TFloatScalarVariable<IBaseInterface, IsAnnotation>::SetInt(int Value)
|
|
{
|
|
static LPCSTR pFuncName = "ID3DX11EffectScalarVariable::SetInt";
|
|
if (IsAnnotation) return AnnotationInvalidSetCall(pFuncName);
|
|
DirtyVariable();
|
|
return CopyScalarValue<ETVT_Int, ETVT_Float, int, false>(Value, Data.pNumericFloat, pFuncName);
|
|
}
|
|
|
|
template<typename IBaseInterface, bool IsAnnotation>
|
|
_Use_decl_annotations_
|
|
HRESULT TFloatScalarVariable<IBaseInterface, IsAnnotation>::GetInt(int *pValue)
|
|
{
|
|
return CopyScalarValue<ETVT_Float, ETVT_Int, float, true>(*Data.pNumericFloat, pValue, "ID3DX11EffectScalarVariable::GetInt");
|
|
}
|
|
|
|
template<typename IBaseInterface, bool IsAnnotation>
|
|
_Use_decl_annotations_
|
|
HRESULT TFloatScalarVariable<IBaseInterface, IsAnnotation>::SetIntArray(const int *pData, uint32_t Offset, uint32_t Count)
|
|
{
|
|
static LPCSTR pFuncName = "ID3DX11EffectScalarVariable::SetIntArray";
|
|
if (IsAnnotation) return AnnotationInvalidSetCall(pFuncName);
|
|
DirtyVariable();
|
|
return SetScalarArray<ETVT_Int, ETVT_Float, int, float>(pData, Data.pNumericFloat, Offset, Count,
|
|
pType, GetTotalUnpackedSize(), pFuncName);
|
|
}
|
|
|
|
template<typename IBaseInterface, bool IsAnnotation>
|
|
_Use_decl_annotations_
|
|
HRESULT TFloatScalarVariable<IBaseInterface, IsAnnotation>::GetIntArray(int *pData, uint32_t Offset, uint32_t Count)
|
|
{
|
|
return GetScalarArray<ETVT_Float, ETVT_Int, float, int>(Data.pNumericFloat, pData, Offset, Count,
|
|
pType, GetTotalUnpackedSize(), "ID3DX11EffectScalarVariable::GetIntArray");
|
|
}
|
|
|
|
template<typename IBaseInterface, bool IsAnnotation>
|
|
_Use_decl_annotations_
|
|
HRESULT TFloatScalarVariable<IBaseInterface, IsAnnotation>::SetBool(bool Value)
|
|
{
|
|
static LPCSTR pFuncName = "ID3DX11EffectScalarVariable::SetBool";
|
|
if (IsAnnotation) return AnnotationInvalidSetCall(pFuncName);
|
|
DirtyVariable();
|
|
return CopyScalarValue<ETVT_bool, ETVT_Float, bool, false>(Value, Data.pNumericFloat, pFuncName);
|
|
}
|
|
|
|
template<typename IBaseInterface, bool IsAnnotation>
|
|
_Use_decl_annotations_
|
|
HRESULT TFloatScalarVariable<IBaseInterface, IsAnnotation>::GetBool(bool *pValue)
|
|
{
|
|
return CopyScalarValue<ETVT_Float, ETVT_bool, float, true>(*Data.pNumericFloat, pValue, "ID3DX11EffectScalarVariable::GetBool");
|
|
}
|
|
|
|
template<typename IBaseInterface, bool IsAnnotation>
|
|
_Use_decl_annotations_
|
|
HRESULT TFloatScalarVariable<IBaseInterface, IsAnnotation>::SetBoolArray(const bool *pData, uint32_t Offset, uint32_t Count)
|
|
{
|
|
static LPCSTR pFuncName = "ID3DX11EffectScalarVariable::SetBoolArray";
|
|
if (IsAnnotation) return AnnotationInvalidSetCall(pFuncName);
|
|
DirtyVariable();
|
|
return SetScalarArray<ETVT_bool, ETVT_Float, bool, float>(pData, Data.pNumericFloat, Offset, Count,
|
|
pType, GetTotalUnpackedSize(), pFuncName);
|
|
}
|
|
|
|
template<typename IBaseInterface, bool IsAnnotation>
|
|
_Use_decl_annotations_
|
|
HRESULT TFloatScalarVariable<IBaseInterface, IsAnnotation>::GetBoolArray(bool *pData, uint32_t Offset, uint32_t Count)
|
|
{
|
|
return GetScalarArray<ETVT_Float, ETVT_bool, float, bool>(Data.pNumericFloat, pData, Offset, Count,
|
|
pType, GetTotalUnpackedSize(), "ID3DX11EffectScalarVariable::GetBoolArray");
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
// ID3DX11EffectScalarVariable (TIntScalarVariable implementation)
|
|
//////////////////////////////////////////////////////////////////////////
|
|
|
|
template<typename IBaseInterface, bool IsAnnotation>
|
|
struct TIntScalarVariable : public TNumericVariable<IBaseInterface, IsAnnotation>
|
|
{
|
|
STDMETHOD(SetFloat)(_In_ float Value) override;
|
|
STDMETHOD(GetFloat)(_Out_ float *pValue) override;
|
|
|
|
STDMETHOD(SetFloatArray)(_In_reads_(Count) const float *pData, _In_ uint32_t Offset, _In_ uint32_t Count) override;
|
|
STDMETHOD(GetFloatArray)(_Out_writes_(Count) float *pData, _In_ uint32_t Offset, _In_ uint32_t Count) override;
|
|
|
|
STDMETHOD(SetInt)(_In_ int Value) override;
|
|
STDMETHOD(GetInt)(_Out_ int *pValue) override;
|
|
|
|
STDMETHOD(SetIntArray)(_In_reads_(Count) const int *pData, _In_ uint32_t Offset, _In_ uint32_t Count) override;
|
|
STDMETHOD(GetIntArray)(_Out_writes_(Count) int *pData, _In_ uint32_t Offset, _In_ uint32_t Count) override;
|
|
|
|
STDMETHOD(SetBool)(_In_ bool Value) override;
|
|
STDMETHOD(GetBool)(_Out_ bool *pValue) override;
|
|
|
|
STDMETHOD(SetBoolArray)(_In_reads_(Count) const bool *pData, _In_ uint32_t Offset, _In_ uint32_t Count) override;
|
|
STDMETHOD(GetBoolArray)(_Out_writes_(Count) bool *pData, _In_ uint32_t Offset, _In_ uint32_t Count) override;
|
|
};
|
|
|
|
template<typename IBaseInterface, bool IsAnnotation>
|
|
_Use_decl_annotations_
|
|
HRESULT TIntScalarVariable<IBaseInterface, IsAnnotation>::SetFloat(float Value)
|
|
{
|
|
static LPCSTR pFuncName = "ID3DX11EffectScalarVariable::SetFloat";
|
|
if (IsAnnotation) return AnnotationInvalidSetCall(pFuncName);
|
|
DirtyVariable();
|
|
return CopyScalarValue<ETVT_Float, ETVT_Int, float, false>(Value, Data.pNumericInt, pFuncName);
|
|
}
|
|
|
|
template<typename IBaseInterface, bool IsAnnotation>
|
|
_Use_decl_annotations_
|
|
HRESULT TIntScalarVariable<IBaseInterface, IsAnnotation>::GetFloat(float *pValue)
|
|
{
|
|
return CopyScalarValue<ETVT_Int, ETVT_Float, int, true>(*Data.pNumericInt, pValue, "ID3DX11EffectScalarVariable::GetFloat");
|
|
}
|
|
|
|
template<typename IBaseInterface, bool IsAnnotation>
|
|
_Use_decl_annotations_
|
|
HRESULT TIntScalarVariable<IBaseInterface, IsAnnotation>::SetFloatArray(const float *pData, uint32_t Offset, uint32_t Count)
|
|
{
|
|
static LPCSTR pFuncName = "ID3DX11EffectScalarVariable::SetFloatArray";
|
|
if (IsAnnotation) return AnnotationInvalidSetCall(pFuncName);
|
|
DirtyVariable();
|
|
return SetScalarArray<ETVT_Float, ETVT_Int, float, int>(pData, Data.pNumericInt, Offset, Count,
|
|
pType, GetTotalUnpackedSize(), pFuncName);
|
|
}
|
|
|
|
template<typename IBaseInterface, bool IsAnnotation>
|
|
_Use_decl_annotations_
|
|
HRESULT TIntScalarVariable<IBaseInterface, IsAnnotation>::GetFloatArray(float *pData, uint32_t Offset, uint32_t Count)
|
|
{
|
|
return GetScalarArray<ETVT_Int, ETVT_Float, int, float>(Data.pNumericInt, pData, Offset, Count,
|
|
pType, GetTotalUnpackedSize(), "ID3DX11EffectScalarVariable::GetFloatArray");
|
|
}
|
|
|
|
template<typename IBaseInterface, bool IsAnnotation>
|
|
_Use_decl_annotations_
|
|
HRESULT TIntScalarVariable<IBaseInterface, IsAnnotation>::SetInt(int Value)
|
|
{
|
|
static LPCSTR pFuncName = "ID3DX11EffectScalarVariable::SetInt";
|
|
if (IsAnnotation) return AnnotationInvalidSetCall(pFuncName);
|
|
DirtyVariable();
|
|
return CopyScalarValue<ETVT_Int, ETVT_Int, int, false>(Value, Data.pNumericInt, pFuncName);
|
|
}
|
|
|
|
template<typename IBaseInterface, bool IsAnnotation>
|
|
_Use_decl_annotations_
|
|
HRESULT TIntScalarVariable<IBaseInterface, IsAnnotation>::GetInt(int *pValue)
|
|
{
|
|
return CopyScalarValue<ETVT_Int, ETVT_Int, int, true>(*Data.pNumericInt, pValue, "ID3DX11EffectScalarVariable::GetInt");
|
|
}
|
|
|
|
template<typename IBaseInterface, bool IsAnnotation>
|
|
_Use_decl_annotations_
|
|
HRESULT TIntScalarVariable<IBaseInterface, IsAnnotation>::SetIntArray(const int *pData, uint32_t Offset, uint32_t Count)
|
|
{
|
|
static LPCSTR pFuncName = "ID3DX11EffectScalarVariable::SetIntArray";
|
|
if (IsAnnotation) return AnnotationInvalidSetCall(pFuncName);
|
|
DirtyVariable();
|
|
return SetScalarArray<ETVT_Int, ETVT_Int, int, int>(pData, Data.pNumericInt, Offset, Count,
|
|
pType, GetTotalUnpackedSize(), pFuncName);
|
|
}
|
|
|
|
template<typename IBaseInterface, bool IsAnnotation>
|
|
_Use_decl_annotations_
|
|
HRESULT TIntScalarVariable<IBaseInterface, IsAnnotation>::GetIntArray(int *pData, uint32_t Offset, uint32_t Count)
|
|
{
|
|
return GetScalarArray<ETVT_Int, ETVT_Int, int, int>(Data.pNumericInt, pData, Offset, Count,
|
|
pType, GetTotalUnpackedSize(), "ID3DX11EffectScalarVariable::GetIntArray");
|
|
}
|
|
|
|
template<typename IBaseInterface, bool IsAnnotation>
|
|
_Use_decl_annotations_
|
|
HRESULT TIntScalarVariable<IBaseInterface, IsAnnotation>::SetBool(bool Value)
|
|
{
|
|
static LPCSTR pFuncName = "ID3DX11EffectScalarVariable::SetBool";
|
|
if (IsAnnotation) return AnnotationInvalidSetCall(pFuncName);
|
|
DirtyVariable();
|
|
return CopyScalarValue<ETVT_bool, ETVT_Int, bool, false>(Value, Data.pNumericInt, pFuncName);
|
|
}
|
|
|
|
template<typename IBaseInterface, bool IsAnnotation>
|
|
_Use_decl_annotations_
|
|
HRESULT TIntScalarVariable<IBaseInterface, IsAnnotation>::GetBool(bool *pValue)
|
|
{
|
|
return CopyScalarValue<ETVT_Int, ETVT_bool, int, true>(*Data.pNumericInt, pValue, "ID3DX11EffectScalarVariable::GetBool");
|
|
}
|
|
|
|
template<typename IBaseInterface, bool IsAnnotation>
|
|
_Use_decl_annotations_
|
|
HRESULT TIntScalarVariable<IBaseInterface, IsAnnotation>::SetBoolArray(const bool *pData, uint32_t Offset, uint32_t Count)
|
|
{
|
|
static LPCSTR pFuncName = "ID3DX11EffectScalarVariable::SetBoolArray";
|
|
if (IsAnnotation) return AnnotationInvalidSetCall(pFuncName);
|
|
DirtyVariable();
|
|
return SetScalarArray<ETVT_bool, ETVT_Int, bool, int>(pData, Data.pNumericInt, Offset, Count,
|
|
pType, GetTotalUnpackedSize(), pFuncName);
|
|
}
|
|
|
|
template<typename IBaseInterface, bool IsAnnotation>
|
|
_Use_decl_annotations_
|
|
HRESULT TIntScalarVariable<IBaseInterface, IsAnnotation>::GetBoolArray(bool *pData, uint32_t Offset, uint32_t Count)
|
|
{
|
|
return GetScalarArray<ETVT_Int, ETVT_bool, int, bool>(Data.pNumericInt, pData, Offset, Count,
|
|
pType, GetTotalUnpackedSize(), "ID3DX11EffectScalarVariable::GetBoolArray");
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
// ID3DX11EffectScalarVariable (TBoolScalarVariable implementation)
|
|
//////////////////////////////////////////////////////////////////////////
|
|
|
|
template<typename IBaseInterface, bool IsAnnotation>
|
|
struct TBoolScalarVariable : public TNumericVariable<IBaseInterface, IsAnnotation>
|
|
{
|
|
STDMETHOD(SetFloat)(_In_ float Value) override;
|
|
STDMETHOD(GetFloat)(_Out_ float *pValue) override;
|
|
|
|
STDMETHOD(SetFloatArray)(_In_reads_(Count) const float *pData, _In_ uint32_t Offset, _In_ uint32_t Count) override;
|
|
STDMETHOD(GetFloatArray)(_Out_writes_(Count) float *pData, _In_ uint32_t Offset, _In_ uint32_t Count) override;
|
|
|
|
STDMETHOD(SetInt)(_In_ int Value) override;
|
|
STDMETHOD(GetInt)(_Out_ int *pValue) override;
|
|
|
|
STDMETHOD(SetIntArray)(_In_reads_(Count) const int *pData, _In_ uint32_t Offset, _In_ uint32_t Count) override;
|
|
STDMETHOD(GetIntArray)(_Out_writes_(Count) int *pData, _In_ uint32_t Offset, _In_ uint32_t Count) override;
|
|
|
|
STDMETHOD(SetBool)(_In_ bool Value) override;
|
|
STDMETHOD(GetBool)(_Out_ bool *pValue) override;
|
|
|
|
STDMETHOD(SetBoolArray)(_In_reads_(Count) const bool *pData, uint32_t Offset, _In_ uint32_t Count) override;
|
|
STDMETHOD(GetBoolArray)(_Out_writes_(Count) bool *pData, _In_ uint32_t Offset, _In_ uint32_t Count) override;
|
|
};
|
|
|
|
template<typename IBaseInterface, bool IsAnnotation>
|
|
_Use_decl_annotations_
|
|
HRESULT TBoolScalarVariable<IBaseInterface, IsAnnotation>::SetFloat(float Value)
|
|
{
|
|
static LPCSTR pFuncName = "ID3DX11EffectScalarVariable::SetFloat";
|
|
if (IsAnnotation) return AnnotationInvalidSetCall(pFuncName);
|
|
DirtyVariable();
|
|
return CopyScalarValue<ETVT_Float, ETVT_Bool, float, false>(Value, Data.pNumericBool, pFuncName);
|
|
}
|
|
|
|
template<typename IBaseInterface, bool IsAnnotation>
|
|
_Use_decl_annotations_
|
|
HRESULT TBoolScalarVariable<IBaseInterface, IsAnnotation>::GetFloat(float *pValue)
|
|
{
|
|
return CopyScalarValue<ETVT_Bool, ETVT_Float, BOOL, true>(*Data.pNumericBool, pValue, "ID3DX11EffectScalarVariable::GetFloat");
|
|
}
|
|
|
|
template<typename IBaseInterface, bool IsAnnotation>
|
|
_Use_decl_annotations_
|
|
HRESULT TBoolScalarVariable<IBaseInterface, IsAnnotation>::SetFloatArray(const float *pData, uint32_t Offset, uint32_t Count)
|
|
{
|
|
static LPCSTR pFuncName = "ID3DX11EffectScalarVariable::SetFloatArray";
|
|
if (IsAnnotation) return AnnotationInvalidSetCall(pFuncName);
|
|
DirtyVariable();
|
|
return SetScalarArray<ETVT_Float, ETVT_Bool, float, BOOL>(pData, Data.pNumericBool, Offset, Count,
|
|
pType, GetTotalUnpackedSize(), pFuncName);
|
|
}
|
|
|
|
template<typename IBaseInterface, bool IsAnnotation>
|
|
_Use_decl_annotations_
|
|
HRESULT TBoolScalarVariable<IBaseInterface, IsAnnotation>::GetFloatArray(float *pData, uint32_t Offset, uint32_t Count)
|
|
{
|
|
return GetScalarArray<ETVT_Bool, ETVT_Float, BOOL, float>(Data.pNumericBool, pData, Offset, Count,
|
|
pType, GetTotalUnpackedSize(), "ID3DX11EffectScalarVariable::GetFloatArray");
|
|
}
|
|
|
|
template<typename IBaseInterface, bool IsAnnotation>
|
|
_Use_decl_annotations_
|
|
HRESULT TBoolScalarVariable<IBaseInterface, IsAnnotation>::SetInt(int Value)
|
|
{
|
|
static LPCSTR pFuncName = "ID3DX11EffectScalarVariable::SetInt";
|
|
if (IsAnnotation) return AnnotationInvalidSetCall(pFuncName);
|
|
DirtyVariable();
|
|
return CopyScalarValue<ETVT_Int, ETVT_Bool, int, false>(Value, Data.pNumericBool, pFuncName);
|
|
}
|
|
|
|
template<typename IBaseInterface, bool IsAnnotation>
|
|
_Use_decl_annotations_
|
|
HRESULT TBoolScalarVariable<IBaseInterface, IsAnnotation>::GetInt(int *pValue)
|
|
{
|
|
return CopyScalarValue<ETVT_Bool, ETVT_Int, BOOL, true>(*Data.pNumericBool, pValue, "ID3DX11EffectScalarVariable::GetInt");
|
|
}
|
|
|
|
template<typename IBaseInterface, bool IsAnnotation>
|
|
_Use_decl_annotations_
|
|
HRESULT TBoolScalarVariable<IBaseInterface, IsAnnotation>::SetIntArray(const int *pData, uint32_t Offset, uint32_t Count)
|
|
{
|
|
static LPCSTR pFuncName = "ID3DX11EffectScalarVariable::SetIntArray";
|
|
if (IsAnnotation) return AnnotationInvalidSetCall(pFuncName);
|
|
DirtyVariable();
|
|
return SetScalarArray<ETVT_Int, ETVT_Bool, int, BOOL>(pData, Data.pNumericBool, Offset, Count,
|
|
pType, GetTotalUnpackedSize(), pFuncName);
|
|
}
|
|
|
|
template<typename IBaseInterface, bool IsAnnotation>
|
|
_Use_decl_annotations_
|
|
HRESULT TBoolScalarVariable<IBaseInterface, IsAnnotation>::GetIntArray(int *pData, uint32_t Offset, uint32_t Count)
|
|
{
|
|
return GetScalarArray<ETVT_Bool, ETVT_Int, BOOL, int>(Data.pNumericBool, pData, Offset, Count,
|
|
pType, GetTotalUnpackedSize(), "ID3DX11EffectScalarVariable::GetIntArray");
|
|
}
|
|
|
|
template<typename IBaseInterface, bool IsAnnotation>
|
|
_Use_decl_annotations_
|
|
HRESULT TBoolScalarVariable<IBaseInterface, IsAnnotation>::SetBool(bool Value)
|
|
{
|
|
static LPCSTR pFuncName = "ID3DX11EffectScalarVariable::SetBool";
|
|
if (IsAnnotation) return AnnotationInvalidSetCall(pFuncName);
|
|
DirtyVariable();
|
|
return CopyScalarValue<ETVT_bool, ETVT_Bool, bool, false>(Value, Data.pNumericBool, pFuncName);
|
|
}
|
|
|
|
template<typename IBaseInterface, bool IsAnnotation>
|
|
_Use_decl_annotations_
|
|
HRESULT TBoolScalarVariable<IBaseInterface, IsAnnotation>::GetBool(bool *pValue)
|
|
{
|
|
return CopyScalarValue<ETVT_Bool, ETVT_bool, BOOL, true>(*Data.pNumericBool, pValue, "ID3DX11EffectScalarVariable::GetBool");
|
|
}
|
|
|
|
template<typename IBaseInterface, bool IsAnnotation>
|
|
_Use_decl_annotations_
|
|
HRESULT TBoolScalarVariable<IBaseInterface, IsAnnotation>::SetBoolArray(const bool *pData, uint32_t Offset, uint32_t Count)
|
|
{
|
|
static LPCSTR pFuncName = "ID3DX11EffectScalarVariable::SetBoolArray";
|
|
if (IsAnnotation) return AnnotationInvalidSetCall(pFuncName);
|
|
DirtyVariable();
|
|
return SetScalarArray<ETVT_bool, ETVT_Bool, bool, BOOL>(pData, Data.pNumericBool, Offset, Count,
|
|
pType, GetTotalUnpackedSize(), pFuncName);
|
|
}
|
|
|
|
template<typename IBaseInterface, bool IsAnnotation>
|
|
_Use_decl_annotations_
|
|
HRESULT TBoolScalarVariable<IBaseInterface, IsAnnotation>::GetBoolArray(bool *pData, uint32_t Offset, uint32_t Count)
|
|
{
|
|
return GetScalarArray<ETVT_Bool, ETVT_bool, BOOL, bool>(Data.pNumericBool, pData, Offset, Count,
|
|
pType, GetTotalUnpackedSize(), "ID3DX11EffectScalarVariable::GetBoolArray");
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
// ID3DX11EffectVectorVariable (TVectorVariable implementation)
|
|
//////////////////////////////////////////////////////////////////////////
|
|
|
|
template<typename IBaseInterface, bool IsAnnotation, ETemplateVarType BaseType >
|
|
struct TVectorVariable : public TNumericVariable<IBaseInterface, IsAnnotation>
|
|
{
|
|
STDMETHOD(SetBoolVector) (_In_reads_(4) const bool *pData) override;
|
|
STDMETHOD(SetIntVector) (_In_reads_(4) const int *pData) override;
|
|
STDMETHOD(SetFloatVector)(_In_reads_(4) const float *pData) override;
|
|
|
|
STDMETHOD(GetBoolVector) (_Out_writes_(4) bool *pData) override;
|
|
STDMETHOD(GetIntVector) (_Out_writes_(4) int *pData) override;
|
|
STDMETHOD(GetFloatVector)(_Out_writes_(4) float *pData) override;
|
|
|
|
|
|
STDMETHOD(SetBoolVectorArray) (_In_reads_(Count*4) const bool *pData, _In_ uint32_t Offset, _In_ uint32_t Count) override;
|
|
STDMETHOD(SetIntVectorArray) (_In_reads_(Count*4) const int *pData, _In_ uint32_t Offset, _In_ uint32_t Count) override;
|
|
STDMETHOD(SetFloatVectorArray)(_In_reads_(Count*4) const float *pData, _In_ uint32_t Offset, _In_ uint32_t Count) override;
|
|
|
|
STDMETHOD(GetBoolVectorArray) (_Out_writes_(Count*4) bool *pData, _In_ uint32_t Offset, _In_ uint32_t Count) override;
|
|
STDMETHOD(GetIntVectorArray) (_Out_writes_(Count*4) int *pData, _In_ uint32_t Offset, _In_ uint32_t Count) override;
|
|
STDMETHOD(GetFloatVectorArray)(_Out_writes_(Count*4) float *pData, _In_ uint32_t Offset, _In_ uint32_t Count) override;
|
|
};
|
|
|
|
// Note that branches in this code is based on template parameters and will be compiled out
|
|
#pragma warning (push)
|
|
#pragma warning (disable : 6101)
|
|
template <ETemplateVarType DestType, ETemplateVarType SourceType>
|
|
void __forceinline CopyDataWithTypeConversion(_Out_ void *pDest,
|
|
_In_ const void *pSource,
|
|
_In_ size_t dstVecSize, _In_ size_t srcVecSize,
|
|
_In_ size_t elementCount, _In_ size_t vecCount)
|
|
{
|
|
switch (SourceType)
|
|
{
|
|
case ETVT_Bool:
|
|
switch (DestType)
|
|
{
|
|
case ETVT_Bool:
|
|
for (size_t j=0; j<vecCount; j++)
|
|
{
|
|
memcpy(pDest, pSource, elementCount * SType::c_ScalarSize);
|
|
|
|
pDest = ((float*) pDest) + dstVecSize;
|
|
pSource = ((float*) pSource) + srcVecSize;
|
|
}
|
|
break;
|
|
|
|
case ETVT_Int:
|
|
for (size_t j=0; j<vecCount; j++)
|
|
{
|
|
for (size_t i=0; i<elementCount; i++)
|
|
((int*)pDest)[i] = ((bool*)pSource)[i] ? -1 : 0;
|
|
|
|
pDest = ((float*) pDest) + dstVecSize;
|
|
pSource = ((float*) pSource) + srcVecSize;
|
|
}
|
|
break;
|
|
|
|
case ETVT_Float:
|
|
for (size_t j=0; j<vecCount; j++)
|
|
{
|
|
for (size_t i=0; i<elementCount; i++)
|
|
((float*)pDest)[i] = ((bool*)pSource)[i] ? -1.0f : 0.0f;
|
|
|
|
pDest = ((float*) pDest) + dstVecSize;
|
|
pSource = ((float*) pSource) + srcVecSize;
|
|
}
|
|
break;
|
|
|
|
case ETVT_bool:
|
|
for (size_t j=0; j<vecCount; j++)
|
|
{
|
|
for (size_t i=0; i<elementCount; i++)
|
|
((bool*)pDest)[i] = (((int*)pSource)[i] != 0) ? true : false;
|
|
|
|
pDest = ((bool*) pDest) + dstVecSize;
|
|
pSource = ((float*) pSource) + srcVecSize;
|
|
}
|
|
break;
|
|
|
|
default:
|
|
assert(0);
|
|
}
|
|
break;
|
|
|
|
case ETVT_Int:
|
|
switch (DestType)
|
|
{
|
|
case ETVT_Bool:
|
|
for (size_t j=0; j<vecCount; j++)
|
|
{
|
|
for (size_t i=0; i<elementCount; i++)
|
|
((int*)pDest)[i] = (((int*)pSource)[i] != 0) ? -1 : 0;
|
|
|
|
pDest = ((float*) pDest) + dstVecSize;
|
|
pSource = ((float*) pSource) + srcVecSize;
|
|
}
|
|
break;
|
|
|
|
case ETVT_Int:
|
|
for (size_t j=0; j<vecCount; j++)
|
|
{
|
|
memcpy(pDest, pSource, elementCount * SType::c_ScalarSize);
|
|
|
|
pDest = ((float*) pDest) + dstVecSize;
|
|
pSource = ((float*) pSource) + srcVecSize;
|
|
}
|
|
break;
|
|
|
|
case ETVT_Float:
|
|
for (size_t j=0; j<vecCount; j++)
|
|
{
|
|
for (size_t i=0; i<elementCount; i++)
|
|
((float*)pDest)[i] = (float)(((int*)pSource)[i]);
|
|
|
|
pDest = ((float*) pDest) + dstVecSize;
|
|
pSource = ((float*) pSource) + srcVecSize;
|
|
}
|
|
break;
|
|
|
|
case ETVT_bool:
|
|
for (size_t j=0; j<vecCount; j++)
|
|
{
|
|
for (size_t i=0; i<elementCount; i++)
|
|
((bool*)pDest)[i] = (((int*)pSource)[i] != 0) ? true : false;
|
|
|
|
pDest = ((bool*) pDest) + dstVecSize;
|
|
pSource = ((float*) pSource) + srcVecSize;
|
|
}
|
|
break;
|
|
|
|
default:
|
|
assert(0);
|
|
}
|
|
break;
|
|
|
|
case ETVT_Float:
|
|
switch (DestType)
|
|
{
|
|
case ETVT_Bool:
|
|
for (size_t j=0; j<vecCount; j++)
|
|
{
|
|
for (size_t i=0; i<elementCount; i++)
|
|
((int*)pDest)[i] = (((float*)pSource)[i] != 0.0f) ? -1 : 0;
|
|
|
|
pDest = ((float*) pDest) + dstVecSize;
|
|
pSource = ((float*) pSource) + srcVecSize;
|
|
}
|
|
break;
|
|
|
|
case ETVT_Int:
|
|
for (size_t j=0; j<vecCount; j++)
|
|
{
|
|
for (size_t i=0; i<elementCount; i++)
|
|
((int*)pDest)[i] = (int)((float*)pSource)[i];
|
|
|
|
pDest = ((float*) pDest) + dstVecSize;
|
|
pSource = ((float*) pSource) + srcVecSize;
|
|
}
|
|
break;
|
|
|
|
case ETVT_Float:
|
|
for (size_t i=0; i<vecCount; i++)
|
|
{
|
|
memcpy( pDest, pSource, elementCount * SType::c_ScalarSize);
|
|
|
|
pDest = ((float*) pDest) + dstVecSize;
|
|
pSource = ((float*) pSource) + srcVecSize;
|
|
}
|
|
break;
|
|
|
|
case ETVT_bool:
|
|
for (size_t j=0; j<vecCount; j++)
|
|
{
|
|
for (size_t i=0; i<elementCount; i++)
|
|
((bool*)pDest)[i] = (((float*)pSource)[i] != 0.0f) ? true : false;
|
|
|
|
pDest = ((bool*) pDest) + dstVecSize;
|
|
pSource = ((float*) pSource) + srcVecSize;
|
|
}
|
|
break;
|
|
|
|
default:
|
|
assert(0);
|
|
}
|
|
break;
|
|
|
|
case ETVT_bool:
|
|
switch (DestType)
|
|
{
|
|
case ETVT_Bool:
|
|
for (size_t j=0; j<vecCount; j++)
|
|
{
|
|
for (size_t i=0; i<elementCount; i++)
|
|
reinterpret_cast<int*>(pDest)[i] = reinterpret_cast<const bool*>(pSource)[i] ? -1 : 0;
|
|
|
|
pDest = ((float*) pDest) + dstVecSize;
|
|
pSource = ((bool*) pSource) + srcVecSize;
|
|
}
|
|
break;
|
|
|
|
case ETVT_Int:
|
|
for (size_t j=0; j<vecCount; j++)
|
|
{
|
|
for (size_t i=0; i<elementCount; i++)
|
|
reinterpret_cast<int*>(pDest)[i] = reinterpret_cast<const bool*>(pSource)[i] ? -1 : 0;
|
|
|
|
pDest = ((float*) pDest) + dstVecSize;
|
|
pSource = ((bool*) pSource) + srcVecSize;
|
|
}
|
|
break;
|
|
|
|
case ETVT_Float:
|
|
for (size_t j=0; j<vecCount; j++)
|
|
{
|
|
for (size_t i=0; i<elementCount; i++)
|
|
reinterpret_cast<float*>(pDest)[i] = reinterpret_cast<const bool*>(pSource)[i] ? -1.0f : 0.0f;
|
|
|
|
pDest = ((float*) pDest) + dstVecSize;
|
|
pSource = ((bool*) pSource) + srcVecSize;
|
|
}
|
|
break;
|
|
|
|
case ETVT_bool:
|
|
for (size_t j=0; j<vecCount; j++)
|
|
{
|
|
memcpy(pDest, pSource, elementCount);
|
|
|
|
pDest = ((bool*) pDest) + dstVecSize;
|
|
pSource = ((bool*) pSource) + srcVecSize;
|
|
}
|
|
break;
|
|
|
|
default:
|
|
assert(0);
|
|
}
|
|
break;
|
|
|
|
default:
|
|
assert(0);
|
|
}
|
|
}
|
|
#pragma warning (pop)
|
|
|
|
// Float Vector
|
|
|
|
template<typename IBaseInterface, bool IsAnnotation, ETemplateVarType BaseType>
|
|
_Use_decl_annotations_
|
|
HRESULT TVectorVariable<IBaseInterface, IsAnnotation, BaseType >::SetFloatVector(const float *pData)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
static LPCSTR pFuncName = "ID3DX11EffectVectorVariable::SetFloatVector";
|
|
|
|
#ifdef _DEBUG
|
|
VERIFYPARAMETER(pData);
|
|
#endif
|
|
|
|
if (IsAnnotation) return AnnotationInvalidSetCall(pFuncName);
|
|
DirtyVariable();
|
|
CopyDataWithTypeConversion<BaseType, ETVT_Float>(Data.pVector, pData, 4, pType->NumericType.Columns, pType->NumericType.Columns, 1);
|
|
|
|
lExit:
|
|
return hr;
|
|
}
|
|
|
|
template<typename IBaseInterface, bool IsAnnotation, ETemplateVarType BaseType>
|
|
_Use_decl_annotations_
|
|
HRESULT TVectorVariable<IBaseInterface, IsAnnotation, BaseType>::GetFloatVector(float *pData)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
static LPCSTR pFuncName = "ID3DX11EffectVectorVariable::GetFloatVector";
|
|
|
|
#ifdef _DEBUG
|
|
VERIFYPARAMETER(pData);
|
|
#endif
|
|
|
|
CopyDataWithTypeConversion<ETVT_Float, BaseType>(pData, Data.pVector, pType->NumericType.Columns, 4, pType->NumericType.Columns, 1);
|
|
|
|
lExit:
|
|
return hr;
|
|
}
|
|
|
|
// Int Vector
|
|
|
|
template<typename IBaseInterface, bool IsAnnotation, ETemplateVarType BaseType>
|
|
_Use_decl_annotations_
|
|
HRESULT TVectorVariable<IBaseInterface, IsAnnotation, BaseType >::SetIntVector(const int *pData)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
static LPCSTR pFuncName = "ID3DX11EffectVectorVariable::SetIntVector";
|
|
|
|
#ifdef _DEBUG
|
|
VERIFYPARAMETER(pData);
|
|
#endif
|
|
|
|
if (IsAnnotation) return AnnotationInvalidSetCall(pFuncName);
|
|
DirtyVariable();
|
|
CopyDataWithTypeConversion<BaseType, ETVT_Int>(Data.pVector, pData, 4, pType->NumericType.Columns, pType->NumericType.Columns, 1);
|
|
|
|
lExit:
|
|
return hr;
|
|
}
|
|
|
|
template<typename IBaseInterface, bool IsAnnotation, ETemplateVarType BaseType>
|
|
_Use_decl_annotations_
|
|
HRESULT TVectorVariable<IBaseInterface, IsAnnotation, BaseType>::GetIntVector(int *pData)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
|
|
#ifdef _DEBUG
|
|
static LPCSTR pFuncName = "ID3DX11EffectVectorVariable::GetIntVector";
|
|
VERIFYPARAMETER(pData);
|
|
#endif
|
|
|
|
CopyDataWithTypeConversion<ETVT_Int, BaseType>(pData, Data.pVector, pType->NumericType.Columns, 4, pType->NumericType.Columns, 1);
|
|
|
|
lExit:
|
|
return hr;
|
|
}
|
|
|
|
// Bool Vector
|
|
|
|
template<typename IBaseInterface, bool IsAnnotation, ETemplateVarType BaseType>
|
|
_Use_decl_annotations_
|
|
HRESULT TVectorVariable<IBaseInterface, IsAnnotation, BaseType >::SetBoolVector(const bool *pData)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
|
|
static LPCSTR pFuncName = "ID3DX11EffectVectorVariable::SetBoolVector";
|
|
|
|
#ifdef _DEBUG
|
|
VERIFYPARAMETER(pData);
|
|
#endif
|
|
|
|
if (IsAnnotation) return AnnotationInvalidSetCall(pFuncName);
|
|
DirtyVariable();
|
|
CopyDataWithTypeConversion<BaseType, ETVT_bool>(Data.pVector, pData, 4, pType->NumericType.Columns, pType->NumericType.Columns, 1);
|
|
|
|
lExit:
|
|
return hr;
|
|
}
|
|
|
|
template<typename IBaseInterface, bool IsAnnotation, ETemplateVarType BaseType>
|
|
_Use_decl_annotations_
|
|
HRESULT TVectorVariable<IBaseInterface, IsAnnotation, BaseType>::GetBoolVector(bool *pData)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
|
|
#ifdef _DEBUG
|
|
static LPCSTR pFuncName = "ID3DX11EffectVectorVariable::GetBoolVector";
|
|
VERIFYPARAMETER(pData);
|
|
#endif
|
|
|
|
CopyDataWithTypeConversion<ETVT_bool, BaseType>(pData, Data.pVector, pType->NumericType.Columns, 4, pType->NumericType.Columns, 1);
|
|
|
|
lExit:
|
|
return hr;
|
|
}
|
|
|
|
// Vector Arrays /////////////////////////////////////////////////////////
|
|
|
|
template<typename IBaseInterface, bool IsAnnotation, ETemplateVarType BaseType>
|
|
_Use_decl_annotations_
|
|
HRESULT TVectorVariable<IBaseInterface, IsAnnotation, BaseType>::SetFloatVectorArray(const float *pData, uint32_t Offset, uint32_t Count)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
static LPCSTR pFuncName = "ID3DX11EffectVectorVariable::SetFloatVectorArray";
|
|
|
|
#ifdef _DEBUG
|
|
#pragma warning( suppress : 6001 )
|
|
if (!AreBoundsValid(Offset, Count, pData, pType, GetTotalUnpackedSize()))
|
|
{
|
|
DPF(0, "%s: Invalid range specified", pFuncName);
|
|
VH(E_INVALIDARG);
|
|
}
|
|
#endif
|
|
|
|
if (IsAnnotation) return AnnotationInvalidSetCall(pFuncName);
|
|
DirtyVariable();
|
|
// ensure we don't write over the padding at the end of the vector array
|
|
CopyDataWithTypeConversion<BaseType, ETVT_Float>(Data.pVector + Offset, pData, 4, pType->NumericType.Columns, pType->NumericType.Columns, std::max(std::min((int)Count, (int)pType->Elements - (int)Offset), 0));
|
|
|
|
lExit:
|
|
return hr;
|
|
}
|
|
|
|
template<typename IBaseInterface, bool IsAnnotation, ETemplateVarType BaseType>
|
|
_Use_decl_annotations_
|
|
HRESULT TVectorVariable<IBaseInterface, IsAnnotation, BaseType>::GetFloatVectorArray(float *pData, uint32_t Offset, uint32_t Count)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
|
|
#ifdef _DEBUG
|
|
static LPCSTR pFuncName = "ID3DX11EffectVectorVariable::GetFloatVectorArray";
|
|
#pragma warning( suppress : 6001 )
|
|
if (!AreBoundsValid(Offset, Count, pData, pType, GetTotalUnpackedSize()))
|
|
{
|
|
DPF(0, "%s: Invalid range specified", pFuncName);
|
|
VH(E_INVALIDARG);
|
|
}
|
|
#endif
|
|
|
|
// ensure we don't read past the end of the vector array
|
|
CopyDataWithTypeConversion<ETVT_Float, BaseType>(pData, Data.pVector + Offset, pType->NumericType.Columns, 4, pType->NumericType.Columns, std::max(std::min((int)Count, (int)pType->Elements - (int)Offset), 0));
|
|
|
|
lExit:
|
|
return hr;
|
|
}
|
|
|
|
// int
|
|
|
|
template<typename IBaseInterface, bool IsAnnotation, ETemplateVarType BaseType>
|
|
_Use_decl_annotations_
|
|
HRESULT TVectorVariable<IBaseInterface, IsAnnotation, BaseType>::SetIntVectorArray(const int *pData, uint32_t Offset, uint32_t Count)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
static LPCSTR pFuncName = "ID3DX11EffectVectorVariable::SetIntVectorArray";
|
|
|
|
#ifdef _DEBUG
|
|
#pragma warning( suppress : 6001 )
|
|
if (!AreBoundsValid(Offset, Count, pData, pType, GetTotalUnpackedSize()))
|
|
{
|
|
DPF(0, "%s: Invalid range specified", pFuncName);
|
|
VH(E_INVALIDARG);
|
|
}
|
|
#endif
|
|
|
|
if (IsAnnotation) return AnnotationInvalidSetCall(pFuncName);
|
|
DirtyVariable();
|
|
// ensure we don't write over the padding at the end of the vector array
|
|
CopyDataWithTypeConversion<BaseType, ETVT_Int>(Data.pVector + Offset, pData, 4, pType->NumericType.Columns, pType->NumericType.Columns, std::max(std::min((int)Count, (int)pType->Elements - (int)Offset), 0));
|
|
|
|
lExit:
|
|
return hr;
|
|
}
|
|
|
|
template<typename IBaseInterface, bool IsAnnotation, ETemplateVarType BaseType>
|
|
_Use_decl_annotations_
|
|
HRESULT TVectorVariable<IBaseInterface, IsAnnotation, BaseType>::GetIntVectorArray(int *pData, uint32_t Offset, uint32_t Count)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
static LPCSTR pFuncName = "ID3DX11EffectVectorVariable::GetIntVectorArray";
|
|
|
|
#ifdef _DEBUG
|
|
#pragma warning( suppress : 6001 )
|
|
if (!AreBoundsValid(Offset, Count, pData, pType, GetTotalUnpackedSize()))
|
|
{
|
|
DPF(0, "%s: Invalid range specified", pFuncName);
|
|
VH(E_INVALIDARG);
|
|
}
|
|
#endif
|
|
|
|
// ensure we don't read past the end of the vector array
|
|
CopyDataWithTypeConversion<ETVT_Int, BaseType>(pData, Data.pVector + Offset, pType->NumericType.Columns, 4, pType->NumericType.Columns, std::max(std::min((int)Count, (int)pType->Elements - (int)Offset), 0));
|
|
|
|
lExit:
|
|
return hr;
|
|
}
|
|
|
|
// bool
|
|
|
|
template<typename IBaseInterface, bool IsAnnotation, ETemplateVarType BaseType>
|
|
_Use_decl_annotations_
|
|
HRESULT TVectorVariable<IBaseInterface, IsAnnotation, BaseType>::SetBoolVectorArray(const bool *pData, uint32_t Offset, uint32_t Count)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
static LPCSTR pFuncName = "ID3DX11EffectVectorVariable::SetBoolVectorArray";
|
|
|
|
#ifdef _DEBUG
|
|
#pragma warning( suppress : 6001 )
|
|
if (!AreBoundsValid(Offset, Count, pData, pType, GetTotalUnpackedSize()))
|
|
{
|
|
DPF(0, "%s: Invalid range specified", pFuncName);
|
|
VH(E_INVALIDARG);
|
|
}
|
|
#endif
|
|
|
|
if (IsAnnotation) return AnnotationInvalidSetCall(pFuncName);
|
|
DirtyVariable();
|
|
// ensure we don't write over the padding at the end of the vector array
|
|
CopyDataWithTypeConversion<BaseType, ETVT_bool>(Data.pVector + Offset, pData, 4, pType->NumericType.Columns, pType->NumericType.Columns, std::max(std::min((int)Count, (int)pType->Elements - (int)Offset), 0));
|
|
|
|
lExit:
|
|
return hr;
|
|
}
|
|
|
|
template<typename IBaseInterface, bool IsAnnotation, ETemplateVarType BaseType>
|
|
_Use_decl_annotations_
|
|
HRESULT TVectorVariable<IBaseInterface, IsAnnotation, BaseType>::GetBoolVectorArray(bool *pData, uint32_t Offset, uint32_t Count)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
static LPCSTR pFuncName = "ID3DX11EffectVectorVariable::GetBoolVectorArray";
|
|
|
|
#ifdef _DEBUG
|
|
#pragma warning( suppress : 6001 )
|
|
if (!AreBoundsValid(Offset, Count, pData, pType, GetTotalUnpackedSize()))
|
|
{
|
|
DPF(0, "%s: Invalid range specified", pFuncName);
|
|
VH(E_INVALIDARG);
|
|
}
|
|
#endif
|
|
|
|
// ensure we don't read past the end of the vector array
|
|
CopyDataWithTypeConversion<ETVT_bool, BaseType>(pData, Data.pVector + Offset, pType->NumericType.Columns, 4, pType->NumericType.Columns, std::max(std::min((int)Count, (int)pType->Elements - (int)Offset), 0));
|
|
|
|
lExit:
|
|
return hr;
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
// ID3DX11EffectVector4Variable (TVectorVariable implementation) [OPTIMIZED]
|
|
//////////////////////////////////////////////////////////////////////////
|
|
|
|
template<typename IBaseInterface>
|
|
struct TVector4Variable : public TVectorVariable<IBaseInterface, false, ETVT_Float>
|
|
{
|
|
STDMETHOD(SetFloatVector)(_In_reads_(4) const float *pData) override;
|
|
STDMETHOD(GetFloatVector)(_Out_writes_(4) float *pData) override;
|
|
|
|
STDMETHOD(SetFloatVectorArray)(_In_reads_(Count*4) const float *pData, _In_ uint32_t Offset, _In_ uint32_t Count) override;
|
|
STDMETHOD(GetFloatVectorArray)(_Out_writes_(Count*4) float *pData, _In_ uint32_t Offset, _In_ uint32_t Count) override;
|
|
};
|
|
|
|
template<typename IBaseInterface>
|
|
_Use_decl_annotations_
|
|
HRESULT TVector4Variable<IBaseInterface>::SetFloatVector(const float *pData)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
static LPCSTR pFuncName = "ID3DX11EffectVectorVariable::SetFloatVector";
|
|
|
|
#ifdef _DEBUG
|
|
VERIFYPARAMETER(pData);
|
|
#endif
|
|
|
|
DirtyVariable();
|
|
Data.pVector[0] = ((CEffectVector4*) pData)[0];
|
|
|
|
lExit:
|
|
return hr;
|
|
}
|
|
|
|
template<typename IBaseInterface>
|
|
_Use_decl_annotations_
|
|
HRESULT TVector4Variable<IBaseInterface>::GetFloatVector(float *pData)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
static LPCSTR pFuncName = "ID3DX11EffectVectorVariable::GetFloatVector";
|
|
|
|
#ifdef _DEBUG
|
|
VERIFYPARAMETER(pData);
|
|
#endif
|
|
|
|
memcpy(pData, Data.pVector, pType->NumericType.Columns * SType::c_ScalarSize);
|
|
|
|
lExit:
|
|
return hr;
|
|
}
|
|
|
|
template<typename IBaseInterface>
|
|
_Use_decl_annotations_
|
|
HRESULT TVector4Variable<IBaseInterface>::SetFloatVectorArray(const float *pData, uint32_t Offset, uint32_t Count)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
static LPCSTR pFuncName = "ID3DX11EffectVectorVariable::SetFloatVectorArray";
|
|
|
|
#ifdef _DEBUG
|
|
#pragma warning( suppress : 6001 )
|
|
if (!AreBoundsValid(Offset, Count, pData, pType, GetTotalUnpackedSize()))
|
|
{
|
|
DPF(0, "%s: Invalid range specified", pFuncName);
|
|
VH(E_INVALIDARG);
|
|
}
|
|
#endif
|
|
|
|
DirtyVariable();
|
|
// ensure we don't write over the padding at the end of the vector array
|
|
memcpy(Data.pVector + Offset, pData,
|
|
std::min<size_t>(Count * sizeof(CEffectVector4), pType->TotalSize - (Offset * sizeof(CEffectVector4))));
|
|
|
|
lExit:
|
|
return hr;
|
|
}
|
|
|
|
template<typename IBaseInterface>
|
|
_Use_decl_annotations_
|
|
HRESULT TVector4Variable<IBaseInterface>::GetFloatVectorArray(float *pData, uint32_t Offset, uint32_t Count)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
static LPCSTR pFuncName = "ID3DX11EffectVectorVariable::GetFloatVectorArray";
|
|
|
|
#ifdef _DEBUG
|
|
#pragma warning( suppress : 6001 )
|
|
if (!AreBoundsValid(Offset, Count, pData, pType, GetTotalUnpackedSize()))
|
|
{
|
|
DPF(0, "%s: Invalid range specified", pFuncName);
|
|
VH(E_INVALIDARG);
|
|
}
|
|
#endif
|
|
|
|
// ensure we don't read past the end of the vector array
|
|
memcpy(pData, Data.pVector + Offset,
|
|
std::min<size_t>(Count * sizeof(CEffectVector4), pType->TotalSize - (Offset * sizeof(CEffectVector4))));
|
|
|
|
lExit:
|
|
return hr;
|
|
}
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
// ID3DX11EffectMatrixVariable (TMatrixVariable implementation)
|
|
//////////////////////////////////////////////////////////////////////////
|
|
|
|
template<typename IBaseInterface, bool IsAnnotation>
|
|
struct TMatrixVariable : public TNumericVariable<IBaseInterface, IsAnnotation>
|
|
{
|
|
STDMETHOD(SetMatrix)(_In_reads_(16) const float *pData) override;
|
|
STDMETHOD(GetMatrix)(_Out_writes_(16) float *pData) override;
|
|
|
|
STDMETHOD(SetMatrixArray)(_In_reads_(Count*16) const float *pData, uint32_t Offset, uint32_t Count) override;
|
|
STDMETHOD(GetMatrixArray)(_Out_writes_(Count*16) float *pData, uint32_t Offset, uint32_t Count) override;
|
|
|
|
STDMETHOD(SetMatrixPointerArray)(_In_reads_(Count*16) const float **ppData, uint32_t Offset, uint32_t Count) override;
|
|
STDMETHOD(GetMatrixPointerArray)(_Out_writes_(Count*16) float **ppData, uint32_t Offset, uint32_t Count) override;
|
|
|
|
STDMETHOD(SetMatrixTranspose)(_In_reads_(16) const float *pData) override;
|
|
STDMETHOD(GetMatrixTranspose)(_Out_writes_(16) float *pData) override;
|
|
|
|
STDMETHOD(SetMatrixTransposeArray)(_In_reads_(Count*16) const float *pData, uint32_t Offset, uint32_t Count) override;
|
|
STDMETHOD(GetMatrixTransposeArray)(_Out_writes_(Count*16) float *pData, uint32_t Offset, uint32_t Count) override;
|
|
|
|
STDMETHOD(SetMatrixTransposePointerArray)(_In_reads_(Count*16) const float **ppData, uint32_t Offset, uint32_t Count) override;
|
|
STDMETHOD(GetMatrixTransposePointerArray)(_Out_writes_(Count*16) float **ppData, uint32_t Offset, uint32_t Count) override;
|
|
};
|
|
|
|
#pragma warning (push)
|
|
#pragma warning (disable : 6101)
|
|
template<bool Transpose>
|
|
static void SetMatrixTransposeHelper(_In_ const SType *pType, _Out_writes_bytes_(64) uint8_t *pDestData, _In_reads_(16) const float* pMatrix)
|
|
{
|
|
uint32_t registers, entries;
|
|
|
|
if (Transpose)
|
|
{
|
|
// row major
|
|
registers = pType->NumericType.Rows;
|
|
entries = pType->NumericType.Columns;
|
|
}
|
|
else
|
|
{
|
|
// column major
|
|
registers = pType->NumericType.Columns;
|
|
entries = pType->NumericType.Rows;
|
|
}
|
|
_Analysis_assume_( registers <= 4 );
|
|
_Analysis_assume_( entries <= 4 );
|
|
|
|
for (size_t i = 0; i < registers; ++ i)
|
|
{
|
|
for (size_t j = 0; j < entries; ++ j)
|
|
{
|
|
#pragma prefast(suppress:__WARNING_UNRELATED_LOOP_TERMINATION, "regs / entries <= 4")
|
|
((float*)pDestData)[j] = ((float*)pMatrix)[j * 4 + i];
|
|
}
|
|
pDestData += SType::c_RegisterSize;
|
|
}
|
|
}
|
|
|
|
template<bool Transpose>
|
|
static void GetMatrixTransposeHelper(_In_ const SType *pType, _In_reads_bytes_(64) uint8_t *pSrcData, _Out_writes_(16) float* pMatrix)
|
|
{
|
|
uint32_t registers, entries;
|
|
|
|
if (Transpose)
|
|
{
|
|
// row major
|
|
registers = pType->NumericType.Rows;
|
|
entries = pType->NumericType.Columns;
|
|
}
|
|
else
|
|
{
|
|
// column major
|
|
registers = pType->NumericType.Columns;
|
|
entries = pType->NumericType.Rows;
|
|
}
|
|
_Analysis_assume_( registers <= 4 );
|
|
_Analysis_assume_( entries <= 4 );
|
|
|
|
for (size_t i = 0; i < registers; ++ i)
|
|
{
|
|
for (size_t j = 0; j < entries; ++ j)
|
|
{
|
|
((float*)pMatrix)[j * 4 + i] = ((float*)pSrcData)[j];
|
|
}
|
|
pSrcData += SType::c_RegisterSize;
|
|
}
|
|
}
|
|
|
|
template<bool Transpose, bool IsSetting, bool ExtraIndirection>
|
|
HRESULT DoMatrixArrayInternal(_In_ const SType *pType, _In_ uint32_t TotalUnpackedSize,
|
|
_Out_ uint8_t *pEffectData,
|
|
void *pMatrixData,
|
|
_In_ uint32_t Offset, _In_ uint32_t Count, _In_z_ LPCSTR pFuncName)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
|
|
#ifdef _DEBUG
|
|
#pragma warning( suppress : 6001 )
|
|
if (!AreBoundsValid(Offset, Count, pMatrixData, pType, TotalUnpackedSize))
|
|
{
|
|
DPF(0, "%s: Invalid range specified", pFuncName);
|
|
VH(E_INVALIDARG);
|
|
}
|
|
#else
|
|
UNREFERENCED_PARAMETER(TotalUnpackedSize);
|
|
UNREFERENCED_PARAMETER(pFuncName);
|
|
#endif
|
|
|
|
if ((pType->NumericType.IsColumnMajor && Transpose) || (!pType->NumericType.IsColumnMajor && !Transpose))
|
|
{
|
|
// fast path
|
|
uint32_t dataSize;
|
|
if (Transpose)
|
|
{
|
|
dataSize = ((pType->NumericType.Columns - 1) * 4 + pType->NumericType.Rows) * SType::c_ScalarSize;
|
|
}
|
|
else
|
|
{
|
|
dataSize = ((pType->NumericType.Rows - 1) * 4 + pType->NumericType.Columns) * SType::c_ScalarSize;
|
|
}
|
|
|
|
for (size_t i = 0; i < Count; ++ i)
|
|
{
|
|
CEffectMatrix *pMatrix;
|
|
if (ExtraIndirection)
|
|
{
|
|
pMatrix = ((CEffectMatrix **)pMatrixData)[i];
|
|
if (!pMatrix)
|
|
{
|
|
continue;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
pMatrix = ((CEffectMatrix *)pMatrixData) + i;
|
|
}
|
|
|
|
if (IsSetting)
|
|
{
|
|
memcpy(pEffectData + pType->Stride * (i + Offset), pMatrix, dataSize);
|
|
}
|
|
else
|
|
{
|
|
memcpy(pMatrix, pEffectData + pType->Stride * (i + Offset), dataSize);
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// slow path
|
|
for (size_t i = 0; i < Count; ++ i)
|
|
{
|
|
CEffectMatrix *pMatrix;
|
|
if (ExtraIndirection)
|
|
{
|
|
pMatrix = ((CEffectMatrix **)pMatrixData)[i];
|
|
if (!pMatrix)
|
|
{
|
|
continue;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
pMatrix = ((CEffectMatrix *)pMatrixData) + i;
|
|
}
|
|
|
|
if (IsSetting)
|
|
{
|
|
SetMatrixTransposeHelper<Transpose>(pType, pEffectData + pType->Stride * (i + Offset), (float*) pMatrix);
|
|
}
|
|
else
|
|
{
|
|
GetMatrixTransposeHelper<Transpose>(pType, pEffectData + pType->Stride * (i + Offset), (float*) pMatrix);
|
|
}
|
|
}
|
|
}
|
|
|
|
lExit:
|
|
return hr;
|
|
}
|
|
#pragma warning (pop)
|
|
|
|
template<typename IBaseInterface, bool IsAnnotation>
|
|
_Use_decl_annotations_
|
|
HRESULT TMatrixVariable<IBaseInterface, IsAnnotation>::SetMatrix(const float *pData)
|
|
{
|
|
static LPCSTR pFuncName = "ID3DX11EffectMatrixVariable::SetMatrix";
|
|
if (IsAnnotation) return AnnotationInvalidSetCall(pFuncName);
|
|
DirtyVariable();
|
|
return DoMatrixArrayInternal<false, true, false>(pType, GetTotalUnpackedSize(),
|
|
Data.pNumeric, const_cast<float*>(pData), 0, 1, pFuncName);
|
|
}
|
|
|
|
template<typename IBaseInterface, bool IsAnnotation>
|
|
_Use_decl_annotations_
|
|
HRESULT TMatrixVariable<IBaseInterface, IsAnnotation>::GetMatrix(float *pData)
|
|
{
|
|
return DoMatrixArrayInternal<false, false, false>(pType, GetTotalUnpackedSize(),
|
|
Data.pNumeric, pData, 0, 1, "ID3DX11EffectMatrixVariable::GetMatrix");
|
|
}
|
|
|
|
template<typename IBaseInterface, bool IsAnnotation>
|
|
_Use_decl_annotations_
|
|
HRESULT TMatrixVariable<IBaseInterface, IsAnnotation>::SetMatrixArray(const float *pData, uint32_t Offset, uint32_t Count)
|
|
{
|
|
static LPCSTR pFuncName = "ID3DX11EffectMatrixVariable::SetMatrixArray";
|
|
if (IsAnnotation) return AnnotationInvalidSetCall(pFuncName);
|
|
DirtyVariable();
|
|
return DoMatrixArrayInternal<false, true, false>(pType, GetTotalUnpackedSize(),
|
|
Data.pNumeric, const_cast<float*>(pData), Offset, Count, "ID3DX11EffectMatrixVariable::SetMatrixArray");
|
|
}
|
|
|
|
template<typename IBaseInterface, bool IsAnnotation>
|
|
_Use_decl_annotations_
|
|
HRESULT TMatrixVariable<IBaseInterface, IsAnnotation>::GetMatrixArray(float *pData, uint32_t Offset, uint32_t Count)
|
|
{
|
|
return DoMatrixArrayInternal<false, false, false>(pType, GetTotalUnpackedSize(),
|
|
Data.pNumeric, pData, Offset, Count, "ID3DX11EffectMatrixVariable::GetMatrixArray");
|
|
}
|
|
|
|
template<typename IBaseInterface, bool IsAnnotation>
|
|
_Use_decl_annotations_
|
|
HRESULT TMatrixVariable<IBaseInterface, IsAnnotation>::SetMatrixPointerArray(const float **ppData, uint32_t Offset, uint32_t Count)
|
|
{
|
|
static LPCSTR pFuncName = "ID3DX11EffectMatrixVariable::SetMatrixPointerArray";
|
|
if (IsAnnotation) return AnnotationInvalidSetCall(pFuncName);
|
|
DirtyVariable();
|
|
return DoMatrixArrayInternal<false, true, true>(pType, GetTotalUnpackedSize(),
|
|
Data.pNumeric, const_cast<float**>(ppData), Offset, Count, "ID3DX11EffectMatrixVariable::SetMatrixPointerArray");
|
|
}
|
|
|
|
template<typename IBaseInterface, bool IsAnnotation>
|
|
_Use_decl_annotations_
|
|
HRESULT TMatrixVariable<IBaseInterface, IsAnnotation>::GetMatrixPointerArray(float **ppData, uint32_t Offset, uint32_t Count)
|
|
{
|
|
return DoMatrixArrayInternal<false, false, true>(pType, GetTotalUnpackedSize(),
|
|
Data.pNumeric, ppData, Offset, Count, "ID3DX11EffectMatrixVariable::GetMatrixPointerArray");
|
|
}
|
|
|
|
template<typename IBaseInterface, bool IsAnnotation>
|
|
_Use_decl_annotations_
|
|
HRESULT TMatrixVariable<IBaseInterface, IsAnnotation>::SetMatrixTranspose(const float *pData)
|
|
{
|
|
static LPCSTR pFuncName = "ID3DX11EffectMatrixVariable::SetMatrixTranspose";
|
|
if (IsAnnotation) return AnnotationInvalidSetCall(pFuncName);
|
|
DirtyVariable();
|
|
return DoMatrixArrayInternal<true, true, false>(pType, GetTotalUnpackedSize(),
|
|
Data.pNumeric, const_cast<float*>(pData), 0, 1, "ID3DX11EffectMatrixVariable::SetMatrixTranspose");
|
|
}
|
|
|
|
template<typename IBaseInterface, bool IsAnnotation>
|
|
_Use_decl_annotations_
|
|
HRESULT TMatrixVariable<IBaseInterface, IsAnnotation>::GetMatrixTranspose(float *pData)
|
|
{
|
|
return DoMatrixArrayInternal<true, false, false>(pType, GetTotalUnpackedSize(),
|
|
Data.pNumeric, pData, 0, 1, "ID3DX11EffectMatrixVariable::GetMatrixTranspose");
|
|
}
|
|
|
|
template<typename IBaseInterface, bool IsAnnotation>
|
|
_Use_decl_annotations_
|
|
HRESULT TMatrixVariable<IBaseInterface, IsAnnotation>::SetMatrixTransposeArray(const float *pData, uint32_t Offset, uint32_t Count)
|
|
{
|
|
static LPCSTR pFuncName = "ID3DX11EffectMatrixVariable::SetMatrixTransposeArray";
|
|
if (IsAnnotation) return AnnotationInvalidSetCall(pFuncName);
|
|
DirtyVariable();
|
|
return DoMatrixArrayInternal<true, true, false>(pType, GetTotalUnpackedSize(),
|
|
Data.pNumeric, const_cast<float*>(pData), Offset, Count, "ID3DX11EffectMatrixVariable::SetMatrixTransposeArray");
|
|
}
|
|
|
|
template<typename IBaseInterface, bool IsAnnotation>
|
|
_Use_decl_annotations_
|
|
HRESULT TMatrixVariable<IBaseInterface, IsAnnotation>::GetMatrixTransposeArray(float *pData, uint32_t Offset, uint32_t Count)
|
|
{
|
|
return DoMatrixArrayInternal<true, false, false>(pType, GetTotalUnpackedSize(),
|
|
Data.pNumeric, pData, Offset, Count, "ID3DX11EffectMatrixVariable::GetMatrixTransposeArray");
|
|
}
|
|
|
|
template<typename IBaseInterface, bool IsAnnotation>
|
|
_Use_decl_annotations_
|
|
HRESULT TMatrixVariable<IBaseInterface, IsAnnotation>::SetMatrixTransposePointerArray(const float **ppData, uint32_t Offset, uint32_t Count)
|
|
{
|
|
static LPCSTR pFuncName = "ID3DX11EffectMatrixVariable::SetMatrixTransposePointerArray";
|
|
if (IsAnnotation) return AnnotationInvalidSetCall(pFuncName);
|
|
DirtyVariable();
|
|
return DoMatrixArrayInternal<true, true, true>(pType, GetTotalUnpackedSize(),
|
|
Data.pNumeric, const_cast<float**>(ppData), Offset, Count, "ID3DX11EffectMatrixVariable::SetMatrixTransposePointerArray");
|
|
}
|
|
|
|
template<typename IBaseInterface, bool IsAnnotation>
|
|
_Use_decl_annotations_
|
|
HRESULT TMatrixVariable<IBaseInterface, IsAnnotation>::GetMatrixTransposePointerArray(float **ppData, uint32_t Offset, uint32_t Count)
|
|
{
|
|
return DoMatrixArrayInternal<true, false, true>(pType, GetTotalUnpackedSize(),
|
|
Data.pNumeric, ppData, Offset, Count, "ID3DX11EffectMatrixVariable::GetMatrixTransposePointerArray");
|
|
}
|
|
|
|
// Optimize commonly used fast paths
|
|
// (non-annotations only!)
|
|
template<typename IBaseInterface, bool IsColumnMajor>
|
|
struct TMatrix4x4Variable : public TMatrixVariable<IBaseInterface, false>
|
|
{
|
|
STDMETHOD(SetMatrix)(_In_reads_(16) const float *pData) override;
|
|
STDMETHOD(GetMatrix)(_Out_writes_(16) float *pData) override;
|
|
|
|
STDMETHOD(SetMatrixArray)(_In_reads_(16*Count) const float *pData, _In_ uint32_t Offset, _In_ uint32_t Count) override;
|
|
STDMETHOD(GetMatrixArray)(_Out_writes_(16*Count) float *pData, _In_ uint32_t Offset, _In_ uint32_t Count) override;
|
|
|
|
STDMETHOD(SetMatrixTranspose)(_In_reads_(16) const float *pData) override;
|
|
STDMETHOD(GetMatrixTranspose)(_Out_writes_(16) float *pData) override;
|
|
|
|
STDMETHOD(SetMatrixTransposeArray)(_In_reads_(16*Count) const float *pData, _In_ uint32_t Offset, _In_ uint32_t Count) override;
|
|
STDMETHOD(GetMatrixTransposeArray)(_Out_writes_(16*Count) float *pData, _In_ uint32_t Offset, _In_ uint32_t Count) override;
|
|
};
|
|
|
|
inline static void Matrix4x4TransposeHelper(_In_reads_bytes_(64) const void *pSrc, _Out_writes_bytes_(64) void *pDst)
|
|
{
|
|
uint8_t *pDestData = (uint8_t*)pDst;
|
|
uint32_t *pMatrix = (uint32_t*)pSrc;
|
|
|
|
((uint32_t*)pDestData)[0 * 4 + 0] = pMatrix[0 * 4 + 0];
|
|
((uint32_t*)pDestData)[0 * 4 + 1] = pMatrix[1 * 4 + 0];
|
|
((uint32_t*)pDestData)[0 * 4 + 2] = pMatrix[2 * 4 + 0];
|
|
((uint32_t*)pDestData)[0 * 4 + 3] = pMatrix[3 * 4 + 0];
|
|
|
|
((uint32_t*)pDestData)[1 * 4 + 0] = pMatrix[0 * 4 + 1];
|
|
((uint32_t*)pDestData)[1 * 4 + 1] = pMatrix[1 * 4 + 1];
|
|
((uint32_t*)pDestData)[1 * 4 + 2] = pMatrix[2 * 4 + 1];
|
|
((uint32_t*)pDestData)[1 * 4 + 3] = pMatrix[3 * 4 + 1];
|
|
|
|
((uint32_t*)pDestData)[2 * 4 + 0] = pMatrix[0 * 4 + 2];
|
|
((uint32_t*)pDestData)[2 * 4 + 1] = pMatrix[1 * 4 + 2];
|
|
((uint32_t*)pDestData)[2 * 4 + 2] = pMatrix[2 * 4 + 2];
|
|
((uint32_t*)pDestData)[2 * 4 + 3] = pMatrix[3 * 4 + 2];
|
|
|
|
((uint32_t*)pDestData)[3 * 4 + 0] = pMatrix[0 * 4 + 3];
|
|
((uint32_t*)pDestData)[3 * 4 + 1] = pMatrix[1 * 4 + 3];
|
|
((uint32_t*)pDestData)[3 * 4 + 2] = pMatrix[2 * 4 + 3];
|
|
((uint32_t*)pDestData)[3 * 4 + 3] = pMatrix[3 * 4 + 3];
|
|
}
|
|
|
|
inline static void Matrix4x4Copy(_In_reads_bytes_(64) const void *pSrc, _Out_writes_bytes_(64) void *pDst)
|
|
{
|
|
#if 1
|
|
// In tests, this path ended up generating faster code both on x86 and x64
|
|
// T1 - Matrix4x4Copy - this path
|
|
// T2 - Matrix4x4Transpose
|
|
// T1: 1.88 T2: 1.92 - with 32 bit copies
|
|
// T1: 1.85 T2: 1.80 - with 64 bit copies
|
|
|
|
uint64_t *pDestData = (uint64_t*)pDst;
|
|
uint64_t *pMatrix = (uint64_t*)pSrc;
|
|
|
|
pDestData[0 * 4 + 0] = pMatrix[0 * 4 + 0];
|
|
pDestData[0 * 4 + 1] = pMatrix[0 * 4 + 1];
|
|
pDestData[0 * 4 + 2] = pMatrix[0 * 4 + 2];
|
|
pDestData[0 * 4 + 3] = pMatrix[0 * 4 + 3];
|
|
|
|
pDestData[1 * 4 + 0] = pMatrix[1 * 4 + 0];
|
|
pDestData[1 * 4 + 1] = pMatrix[1 * 4 + 1];
|
|
pDestData[1 * 4 + 2] = pMatrix[1 * 4 + 2];
|
|
pDestData[1 * 4 + 3] = pMatrix[1 * 4 + 3];
|
|
#else
|
|
uint32_t *pDestData = (uint32_t*)pDst;
|
|
uint32_t *pMatrix = (uint32_t*)pSrc;
|
|
|
|
pDestData[0 * 4 + 0] = pMatrix[0 * 4 + 0];
|
|
pDestData[0 * 4 + 1] = pMatrix[0 * 4 + 1];
|
|
pDestData[0 * 4 + 2] = pMatrix[0 * 4 + 2];
|
|
pDestData[0 * 4 + 3] = pMatrix[0 * 4 + 3];
|
|
|
|
pDestData[1 * 4 + 0] = pMatrix[1 * 4 + 0];
|
|
pDestData[1 * 4 + 1] = pMatrix[1 * 4 + 1];
|
|
pDestData[1 * 4 + 2] = pMatrix[1 * 4 + 2];
|
|
pDestData[1 * 4 + 3] = pMatrix[1 * 4 + 3];
|
|
|
|
pDestData[2 * 4 + 0] = pMatrix[2 * 4 + 0];
|
|
pDestData[2 * 4 + 1] = pMatrix[2 * 4 + 1];
|
|
pDestData[2 * 4 + 2] = pMatrix[2 * 4 + 2];
|
|
pDestData[2 * 4 + 3] = pMatrix[2 * 4 + 3];
|
|
|
|
pDestData[3 * 4 + 0] = pMatrix[3 * 4 + 0];
|
|
pDestData[3 * 4 + 1] = pMatrix[3 * 4 + 1];
|
|
pDestData[3 * 4 + 2] = pMatrix[3 * 4 + 2];
|
|
pDestData[3 * 4 + 3] = pMatrix[3 * 4 + 3];
|
|
#endif
|
|
}
|
|
|
|
|
|
// Note that branches in this code is based on template parameters and will be compiled out
|
|
#pragma warning (push)
|
|
#pragma warning (disable : 6101)
|
|
template<bool IsColumnMajor, bool Transpose, bool IsSetting>
|
|
inline HRESULT DoMatrix4x4ArrayInternal(_In_ uint8_t *pEffectData,
|
|
_When_(IsSetting, _In_reads_bytes_(64 * Count))
|
|
_When_(!IsSetting, _Out_writes_bytes_(64 * Count))
|
|
void *pMatrixData,
|
|
_In_ uint32_t Offset, _In_ uint32_t Count
|
|
#ifdef _DEBUG
|
|
, _In_ const SType *pType, _In_ uint32_t TotalUnpackedSize, _In_z_ LPCSTR pFuncName
|
|
#endif
|
|
|
|
)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
|
|
#ifdef _DEBUG
|
|
#pragma warning( suppress : 6001 )
|
|
if (!AreBoundsValid(Offset, Count, pMatrixData, pType, TotalUnpackedSize))
|
|
{
|
|
DPF(0, "%s: Invalid range specified", pFuncName);
|
|
VH(E_INVALIDARG);
|
|
}
|
|
|
|
assert(pType->NumericType.IsColumnMajor == IsColumnMajor && pType->Stride == (4 * SType::c_RegisterSize));
|
|
#endif
|
|
|
|
if ((IsColumnMajor && Transpose) || (!IsColumnMajor && !Transpose))
|
|
{
|
|
// fast path
|
|
for (size_t i = 0; i < Count; ++ i)
|
|
{
|
|
CEffectMatrix *pMatrix = ((CEffectMatrix *)pMatrixData) + i;
|
|
|
|
if (IsSetting)
|
|
{
|
|
Matrix4x4Copy(pMatrix, pEffectData + 4 * SType::c_RegisterSize * (i + Offset));
|
|
}
|
|
else
|
|
{
|
|
Matrix4x4Copy(pEffectData + 4 * SType::c_RegisterSize * (i + Offset), pMatrix);
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// slow path
|
|
for (size_t i = 0; i < Count; ++ i)
|
|
{
|
|
CEffectMatrix *pMatrix = ((CEffectMatrix *)pMatrixData) + i;
|
|
|
|
if (IsSetting)
|
|
{
|
|
Matrix4x4TransposeHelper((float*) pMatrix, pEffectData + 4 * SType::c_RegisterSize * (i + Offset));
|
|
}
|
|
else
|
|
{
|
|
Matrix4x4TransposeHelper(pEffectData + 4 * SType::c_RegisterSize * (i + Offset), (float*) pMatrix);
|
|
}
|
|
}
|
|
}
|
|
|
|
lExit:
|
|
return hr;
|
|
}
|
|
#pragma warning (pop)
|
|
|
|
template<typename IBaseInterface, bool IsColumnMajor>
|
|
_Use_decl_annotations_
|
|
HRESULT TMatrix4x4Variable<IBaseInterface, IsColumnMajor>::SetMatrix(const float *pData)
|
|
{
|
|
DirtyVariable();
|
|
return DoMatrix4x4ArrayInternal<IsColumnMajor, false, true>(Data.pNumeric, const_cast<float*>(pData), 0, 1
|
|
#ifdef _DEBUG
|
|
, pType, GetTotalUnpackedSize(), "ID3DX11EffectMatrixVariable::SetMatrix");
|
|
#else
|
|
);
|
|
#endif
|
|
}
|
|
|
|
template<typename IBaseInterface, bool IsColumnMajor>
|
|
_Use_decl_annotations_
|
|
HRESULT TMatrix4x4Variable<IBaseInterface, IsColumnMajor>::GetMatrix(float *pData)
|
|
{
|
|
return DoMatrix4x4ArrayInternal<IsColumnMajor, false, false>(Data.pNumeric, pData, 0, 1
|
|
#ifdef _DEBUG
|
|
, pType, GetTotalUnpackedSize(), "ID3DX11EffectMatrixVariable::GetMatrix");
|
|
#else
|
|
);
|
|
#endif
|
|
}
|
|
|
|
template<typename IBaseInterface, bool IsColumnMajor>
|
|
_Use_decl_annotations_
|
|
HRESULT TMatrix4x4Variable<IBaseInterface, IsColumnMajor>::SetMatrixArray(const float *pData, uint32_t Offset, uint32_t Count)
|
|
{
|
|
DirtyVariable();
|
|
return DoMatrix4x4ArrayInternal<IsColumnMajor, false, true>(Data.pNumeric, const_cast<float*>(pData), Offset, Count
|
|
#ifdef _DEBUG
|
|
, pType, GetTotalUnpackedSize(), "ID3DX11EffectMatrixVariable::SetMatrixArray");
|
|
#else
|
|
);
|
|
#endif
|
|
}
|
|
|
|
template<typename IBaseInterface, bool IsColumnMajor>
|
|
_Use_decl_annotations_
|
|
HRESULT TMatrix4x4Variable<IBaseInterface, IsColumnMajor>::GetMatrixArray(float *pData, uint32_t Offset, uint32_t Count)
|
|
{
|
|
return DoMatrix4x4ArrayInternal<IsColumnMajor, false, false>(Data.pNumeric, pData, Offset, Count
|
|
#ifdef _DEBUG
|
|
, pType, GetTotalUnpackedSize(), "ID3DX11EffectMatrixVariable::GetMatrixArray");
|
|
#else
|
|
);
|
|
#endif
|
|
}
|
|
|
|
template<typename IBaseInterface, bool IsColumnMajor>
|
|
_Use_decl_annotations_
|
|
HRESULT TMatrix4x4Variable<IBaseInterface, IsColumnMajor>::SetMatrixTranspose(const float *pData)
|
|
{
|
|
DirtyVariable();
|
|
return DoMatrix4x4ArrayInternal<IsColumnMajor, true, true>(Data.pNumeric, const_cast<float*>(pData), 0, 1
|
|
#ifdef _DEBUG
|
|
, pType, GetTotalUnpackedSize(), "ID3DX11EffectMatrixVariable::SetMatrixTranspose");
|
|
#else
|
|
);
|
|
#endif
|
|
}
|
|
|
|
template<typename IBaseInterface, bool IsColumnMajor>
|
|
_Use_decl_annotations_
|
|
HRESULT TMatrix4x4Variable<IBaseInterface, IsColumnMajor>::GetMatrixTranspose(float *pData)
|
|
{
|
|
return DoMatrix4x4ArrayInternal<IsColumnMajor, true, false>(Data.pNumeric, pData, 0, 1
|
|
#ifdef _DEBUG
|
|
, pType, GetTotalUnpackedSize(), "ID3DX11EffectMatrixVariable::GetMatrixTranspose");
|
|
#else
|
|
);
|
|
#endif
|
|
}
|
|
|
|
template<typename IBaseInterface, bool IsColumnMajor>
|
|
_Use_decl_annotations_
|
|
HRESULT TMatrix4x4Variable<IBaseInterface, IsColumnMajor>::SetMatrixTransposeArray(const float *pData, uint32_t Offset, uint32_t Count)
|
|
{
|
|
DirtyVariable();
|
|
return DoMatrix4x4ArrayInternal<IsColumnMajor, true, true>(Data.pNumeric, const_cast<float*>(pData), Offset, Count
|
|
#ifdef _DEBUG
|
|
, pType, GetTotalUnpackedSize(), "ID3DX11EffectMatrixVariable::SetMatrixTransposeArray");
|
|
#else
|
|
);
|
|
#endif
|
|
}
|
|
|
|
template<typename IBaseInterface, bool IsColumnMajor>
|
|
_Use_decl_annotations_
|
|
HRESULT TMatrix4x4Variable<IBaseInterface, IsColumnMajor>::GetMatrixTransposeArray(float *pData, uint32_t Offset, uint32_t Count)
|
|
{
|
|
return DoMatrix4x4ArrayInternal<IsColumnMajor, true, false>(Data.pNumeric, pData, Offset, Count
|
|
#ifdef _DEBUG
|
|
, pType, GetTotalUnpackedSize(), "ID3DX11EffectMatrixVariable::GetMatrixTransposeArray");
|
|
#else
|
|
);
|
|
#endif
|
|
}
|
|
|
|
#ifdef _DEBUG
|
|
|
|
// Useful object macro to check bounds and parameters
|
|
#define CHECK_OBJECT_ARRAY_BOUNDS(Offset, Count, Pointer) \
|
|
HRESULT hr = S_OK; \
|
|
VERIFYPARAMETER(Pointer) \
|
|
uint32_t elements = IsArray() ? pType->Elements : 1; \
|
|
\
|
|
if ((Offset + Count < Offset) || (elements < Offset + Count)) \
|
|
{ \
|
|
DPF(0, "%s: Invalid range specified", pFuncName); \
|
|
VH(E_INVALIDARG); \
|
|
} \
|
|
|
|
#define CHECK_OBJECT_SCALAR_BOUNDS(Index, Pointer) \
|
|
HRESULT hr = S_OK; \
|
|
VERIFYPARAMETER(Pointer) \
|
|
uint32_t elements = IsArray() ? pType->Elements : 1; \
|
|
\
|
|
if (Index >= elements) \
|
|
{ \
|
|
DPF(0, "%s: Invalid index specified", pFuncName); \
|
|
VH(E_INVALIDARG); \
|
|
} \
|
|
|
|
#define CHECK_SCALAR_BOUNDS(Index) \
|
|
HRESULT hr = S_OK; \
|
|
uint32_t elements = IsArray() ? pType->Elements : 1; \
|
|
\
|
|
if (Index >= elements) \
|
|
{ \
|
|
DPF(0, "%s: Invalid index specified", pFuncName); \
|
|
VH(E_INVALIDARG); \
|
|
} \
|
|
|
|
#else // _DEBUG
|
|
|
|
#define CHECK_OBJECT_ARRAY_BOUNDS(Offset, Count, Pointer) \
|
|
HRESULT hr = S_OK; \
|
|
|
|
#define CHECK_OBJECT_SCALAR_BOUNDS(Index, Pointer) \
|
|
HRESULT hr = S_OK; \
|
|
|
|
#define CHECK_SCALAR_BOUNDS(Index) \
|
|
HRESULT hr = S_OK; \
|
|
|
|
#endif // _DEBUG
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
// ID3DX11EffectStringVariable (TStringVariable implementation)
|
|
//////////////////////////////////////////////////////////////////////////
|
|
|
|
template<typename IBaseInterface, bool IsAnnotation>
|
|
struct TStringVariable : public IBaseInterface
|
|
{
|
|
STDMETHOD(GetString)(_Outptr_result_z_ LPCSTR *ppString) override;
|
|
STDMETHOD(GetStringArray)( _Out_writes_(Count) LPCSTR *ppStrings, _In_ uint32_t Offset, _In_ uint32_t Count ) override;
|
|
};
|
|
|
|
template<typename IBaseInterface, bool IsAnnotation>
|
|
_Use_decl_annotations_
|
|
HRESULT TStringVariable<IBaseInterface, IsAnnotation>::GetString(LPCSTR *ppString)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
static LPCSTR pFuncName = "ID3DX11EffectStringVariable::GetString";
|
|
|
|
VERIFYPARAMETER(ppString);
|
|
|
|
if (GetTopLevelEntity()->pEffect->IsOptimized())
|
|
{
|
|
DPF(0, "%s: Effect has been Optimize()'ed; all string/reflection data has been deleted", pFuncName);
|
|
return D3DERR_INVALIDCALL;
|
|
}
|
|
|
|
assert(Data.pString != 0);
|
|
_Analysis_assume_(Data.pString != 0);
|
|
|
|
*ppString = Data.pString->pString;
|
|
|
|
lExit:
|
|
return hr;
|
|
}
|
|
|
|
template<typename IBaseInterface, bool IsAnnotation>
|
|
_Use_decl_annotations_
|
|
#pragma warning(suppress : 6054)
|
|
HRESULT TStringVariable<IBaseInterface, IsAnnotation>::GetStringArray( LPCSTR *ppStrings, uint32_t Offset, uint32_t Count)
|
|
{
|
|
static LPCSTR pFuncName = "ID3DX11EffectStringVariable::GetStringArray";
|
|
|
|
CHECK_OBJECT_ARRAY_BOUNDS(Offset, Count, ppStrings);
|
|
|
|
if (GetTopLevelEntity()->pEffect->IsOptimized())
|
|
{
|
|
DPF(0, "%s: Effect has been Optimize()'ed; all string/reflection data has been deleted", pFuncName);
|
|
return D3DERR_INVALIDCALL;
|
|
}
|
|
|
|
assert(Data.pString != 0);
|
|
_Analysis_assume_(Data.pString != 0);
|
|
|
|
for (size_t i = 0; i < Count; ++ i)
|
|
{
|
|
ppStrings[i] = (Data.pString + Offset + i)->pString;
|
|
}
|
|
|
|
lExit:
|
|
return hr;
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
// ID3DX11EffectClassInstanceVariable (TClassInstanceVariable implementation)
|
|
//////////////////////////////////////////////////////////////////////////
|
|
|
|
template<typename IBaseInterface>
|
|
struct TClassInstanceVariable : public IBaseInterface
|
|
{
|
|
STDMETHOD(GetClassInstance)(_Outptr_ ID3D11ClassInstance **ppClassInstance) override;
|
|
};
|
|
|
|
template<typename IBaseClassInstance>
|
|
HRESULT TClassInstanceVariable<IBaseClassInstance>::GetClassInstance(_Outptr_ ID3D11ClassInstance** ppClassInstance)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
static LPCSTR pFuncName = "ID3DX11EffectClassInstanceVariable::GetClassInstance";
|
|
|
|
assert( pMemberData != 0 && pMemberData->Data.pD3DClassInstance != 0);
|
|
_Analysis_assume_( pMemberData != 0 && pMemberData->Data.pD3DClassInstance != 0);
|
|
*ppClassInstance = pMemberData->Data.pD3DClassInstance;
|
|
SAFE_ADDREF(*ppClassInstance);
|
|
|
|
lExit:
|
|
return hr;
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
// ID3DX11EffectInterfaceeVariable (TInterfaceVariable implementation)
|
|
//////////////////////////////////////////////////////////////////////////
|
|
|
|
template<typename IBaseInterface>
|
|
struct TInterfaceVariable : public IBaseInterface
|
|
{
|
|
STDMETHOD(SetClassInstance)(_In_ ID3DX11EffectClassInstanceVariable *pEffectClassInstance) override;
|
|
STDMETHOD(GetClassInstance)(_Outptr_ ID3DX11EffectClassInstanceVariable **ppEffectClassInstance) override;
|
|
};
|
|
|
|
template<typename IBaseInterface>
|
|
HRESULT TInterfaceVariable<IBaseInterface>::SetClassInstance(_In_ ID3DX11EffectClassInstanceVariable *pEffectClassInstance)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
static LPCSTR pFuncName = "ID3DX11EffectInterfaceVariable::SetClassInstance";
|
|
|
|
// Note that we don't check if the types are compatible. The debug layer will complain if it is.
|
|
// IsValid() will not catch type mismatches.
|
|
SClassInstanceGlobalVariable* pCI = (SClassInstanceGlobalVariable*)pEffectClassInstance;
|
|
Data.pInterface->pClassInstance = pCI;
|
|
|
|
lExit:
|
|
return hr;
|
|
}
|
|
|
|
template<typename IBaseInterface>
|
|
HRESULT TInterfaceVariable<IBaseInterface>::GetClassInstance(_Outptr_ ID3DX11EffectClassInstanceVariable **ppEffectClassInstance)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
static LPCSTR pFuncName = "ID3DX11EffectInterfaceVariable::GetClassInstance";
|
|
|
|
#ifdef _DEBUG
|
|
VERIFYPARAMETER(ppEffectClassInstance);
|
|
#endif
|
|
|
|
*ppEffectClassInstance = Data.pInterface->pClassInstance;
|
|
|
|
lExit:
|
|
return hr;
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
// ID3DX11EffectShaderResourceVariable (TShaderResourceVariable implementation)
|
|
//////////////////////////////////////////////////////////////////////////
|
|
|
|
template<typename IBaseInterface>
|
|
struct TShaderResourceVariable : public IBaseInterface
|
|
{
|
|
STDMETHOD(SetResource)(_In_ ID3D11ShaderResourceView *pResource) override;
|
|
STDMETHOD(GetResource)(_Outptr_ ID3D11ShaderResourceView **ppResource) override;
|
|
|
|
STDMETHOD(SetResourceArray)(_In_reads_(Count) ID3D11ShaderResourceView **ppResources, _In_ uint32_t Offset, _In_ uint32_t Count) override;
|
|
STDMETHOD(GetResourceArray)(_Out_writes_(Count) ID3D11ShaderResourceView **ppResources, _In_ uint32_t Offset, _In_ uint32_t Count) override;
|
|
};
|
|
|
|
static LPCSTR GetTextureTypeNameFromEnum(_In_ EObjectType ObjectType)
|
|
{
|
|
switch (ObjectType)
|
|
{
|
|
case EOT_Buffer:
|
|
return "Buffer";
|
|
case EOT_Texture:
|
|
return "texture";
|
|
case EOT_Texture1D:
|
|
case EOT_Texture1DArray:
|
|
return "Texture1D";
|
|
case EOT_Texture2DMS:
|
|
case EOT_Texture2DMSArray:
|
|
return "Texture2DMS";
|
|
case EOT_Texture2D:
|
|
case EOT_Texture2DArray:
|
|
return "Texture2D";
|
|
case EOT_Texture3D:
|
|
return "Texture3D";
|
|
case EOT_TextureCube:
|
|
return "TextureCube";
|
|
case EOT_TextureCubeArray:
|
|
return "TextureCubeArray";
|
|
case EOT_RWTexture1D:
|
|
case EOT_RWTexture1DArray:
|
|
return "RWTexture1D";
|
|
case EOT_RWTexture2D:
|
|
case EOT_RWTexture2DArray:
|
|
return "RWTexture2D";
|
|
case EOT_RWTexture3D:
|
|
return "RWTexture3D";
|
|
case EOT_RWBuffer:
|
|
return "RWBuffer";
|
|
case EOT_ByteAddressBuffer:
|
|
return "ByteAddressBuffer";
|
|
case EOT_RWByteAddressBuffer:
|
|
return "RWByteAddressBuffer";
|
|
case EOT_StructuredBuffer:
|
|
return "StructuredBuffe";
|
|
case EOT_RWStructuredBuffer:
|
|
return "RWStructuredBuffer";
|
|
case EOT_RWStructuredBufferAlloc:
|
|
return "RWStructuredBufferAlloc";
|
|
case EOT_RWStructuredBufferConsume:
|
|
return "RWStructuredBufferConsume";
|
|
case EOT_AppendStructuredBuffer:
|
|
return "AppendStructuredBuffer";
|
|
case EOT_ConsumeStructuredBuffer:
|
|
return "ConsumeStructuredBuffer";
|
|
}
|
|
return "<unknown texture format>";
|
|
}
|
|
|
|
static LPCSTR GetResourceDimensionNameFromEnum(_In_ D3D11_RESOURCE_DIMENSION ResourceDimension)
|
|
{
|
|
switch (ResourceDimension)
|
|
{
|
|
case D3D11_RESOURCE_DIMENSION_BUFFER:
|
|
return "Buffer";
|
|
case D3D11_RESOURCE_DIMENSION_TEXTURE1D:
|
|
return "Texture1D";
|
|
case D3D11_RESOURCE_DIMENSION_TEXTURE2D:
|
|
return "Texture2D";
|
|
case D3D11_RESOURCE_DIMENSION_TEXTURE3D:
|
|
return "Texture3D";
|
|
}
|
|
return "<unknown texture format>";
|
|
}
|
|
|
|
static LPCSTR GetSRVDimensionNameFromEnum(_In_ D3D11_SRV_DIMENSION ViewDimension)
|
|
{
|
|
switch (ViewDimension)
|
|
{
|
|
case D3D11_SRV_DIMENSION_BUFFER:
|
|
case D3D11_SRV_DIMENSION_BUFFEREX:
|
|
return "Buffer";
|
|
case D3D11_SRV_DIMENSION_TEXTURE1D:
|
|
return "Texture1D";
|
|
case D3D11_SRV_DIMENSION_TEXTURE1DARRAY:
|
|
return "Texture1DArray";
|
|
case D3D11_SRV_DIMENSION_TEXTURE2D:
|
|
return "Texture2D";
|
|
case D3D11_SRV_DIMENSION_TEXTURE2DARRAY:
|
|
return "Texture2DArray";
|
|
case D3D11_SRV_DIMENSION_TEXTURE2DMS:
|
|
return "Texture2DMS";
|
|
case D3D11_SRV_DIMENSION_TEXTURE2DMSARRAY:
|
|
return "Texture2DMSArray";
|
|
case D3D11_SRV_DIMENSION_TEXTURE3D:
|
|
return "Texture3D";
|
|
case D3D11_SRV_DIMENSION_TEXTURECUBE:
|
|
return "TextureCube";
|
|
}
|
|
return "<unknown texture format>";
|
|
}
|
|
|
|
static LPCSTR GetUAVDimensionNameFromEnum(_In_ D3D11_UAV_DIMENSION ViewDimension)
|
|
{
|
|
switch (ViewDimension)
|
|
{
|
|
case D3D11_UAV_DIMENSION_BUFFER:
|
|
return "Buffer";
|
|
case D3D11_UAV_DIMENSION_TEXTURE1D:
|
|
return "RWTexture1D";
|
|
case D3D11_UAV_DIMENSION_TEXTURE1DARRAY:
|
|
return "RWTexture1DArray";
|
|
case D3D11_UAV_DIMENSION_TEXTURE2D:
|
|
return "RWTexture2D";
|
|
case D3D11_UAV_DIMENSION_TEXTURE2DARRAY:
|
|
return "RWTexture2DArray";
|
|
case D3D11_UAV_DIMENSION_TEXTURE3D:
|
|
return "RWTexture3D";
|
|
}
|
|
return "<unknown texture format>";
|
|
}
|
|
|
|
static LPCSTR GetRTVDimensionNameFromEnum(_In_ D3D11_RTV_DIMENSION ViewDimension)
|
|
{
|
|
switch (ViewDimension)
|
|
{
|
|
case D3D11_RTV_DIMENSION_BUFFER:
|
|
return "Buffer";
|
|
case D3D11_RTV_DIMENSION_TEXTURE1D:
|
|
return "Texture1D";
|
|
case D3D11_RTV_DIMENSION_TEXTURE1DARRAY:
|
|
return "Texture1DArray";
|
|
case D3D11_RTV_DIMENSION_TEXTURE2D:
|
|
return "Texture2D";
|
|
case D3D11_RTV_DIMENSION_TEXTURE2DARRAY:
|
|
return "Texture2DArray";
|
|
case D3D11_RTV_DIMENSION_TEXTURE2DMS:
|
|
return "Texture2DMS";
|
|
case D3D11_RTV_DIMENSION_TEXTURE2DMSARRAY:
|
|
return "Texture2DMSArray";
|
|
case D3D11_RTV_DIMENSION_TEXTURE3D:
|
|
return "Texture3D";
|
|
}
|
|
return "<unknown texture format>";
|
|
}
|
|
|
|
static LPCSTR GetDSVDimensionNameFromEnum(_In_ D3D11_DSV_DIMENSION ViewDimension)
|
|
{
|
|
switch (ViewDimension)
|
|
{
|
|
case D3D11_DSV_DIMENSION_TEXTURE1D:
|
|
return "Texture1D";
|
|
case D3D11_DSV_DIMENSION_TEXTURE1DARRAY:
|
|
return "Texture1DArray";
|
|
case D3D11_DSV_DIMENSION_TEXTURE2D:
|
|
return "Texture2D";
|
|
case D3D11_DSV_DIMENSION_TEXTURE2DARRAY:
|
|
return "Texture2DArray";
|
|
case D3D11_DSV_DIMENSION_TEXTURE2DMS:
|
|
return "Texture2DMS";
|
|
case D3D11_DSV_DIMENSION_TEXTURE2DMSARRAY:
|
|
return "Texture2DMSArray";
|
|
}
|
|
return "<unknown texture format>";
|
|
}
|
|
|
|
static HRESULT ValidateTextureType(_In_ ID3D11ShaderResourceView *pView, _In_ EObjectType ObjectType, _In_z_ LPCSTR pFuncName)
|
|
{
|
|
if (nullptr != pView)
|
|
{
|
|
D3D11_SHADER_RESOURCE_VIEW_DESC desc;
|
|
pView->GetDesc(&desc);
|
|
switch (ObjectType)
|
|
{
|
|
case EOT_Texture:
|
|
if (desc.ViewDimension != D3D11_SRV_DIMENSION_BUFFER && desc.ViewDimension != D3D11_SRV_DIMENSION_BUFFEREX)
|
|
return S_OK;
|
|
break;
|
|
case EOT_Buffer:
|
|
if (desc.ViewDimension != D3D11_SRV_DIMENSION_BUFFER && desc.ViewDimension != D3D11_SRV_DIMENSION_BUFFEREX)
|
|
break;
|
|
if (desc.ViewDimension == D3D11_SRV_DIMENSION_BUFFEREX && (desc.BufferEx.Flags & D3D11_BUFFEREX_SRV_FLAG_RAW))
|
|
{
|
|
DPF(0, "%s: Resource type mismatch; %s expected, ByteAddressBuffer provided.", pFuncName, GetTextureTypeNameFromEnum(ObjectType));
|
|
return E_INVALIDARG;
|
|
}
|
|
else
|
|
{
|
|
ID3D11Buffer* pBuffer = nullptr;
|
|
pView->GetResource( (ID3D11Resource**)&pBuffer );
|
|
assert( pBuffer != nullptr );
|
|
D3D11_BUFFER_DESC BufDesc;
|
|
pBuffer->GetDesc( &BufDesc );
|
|
SAFE_RELEASE( pBuffer );
|
|
if( BufDesc.MiscFlags & D3D11_RESOURCE_MISC_BUFFER_STRUCTURED )
|
|
{
|
|
DPF(0, "%s: Resource type mismatch; %s expected, StructuredBuffer provided.", pFuncName, GetTextureTypeNameFromEnum(ObjectType));
|
|
return E_INVALIDARG;
|
|
}
|
|
else
|
|
{
|
|
return S_OK;
|
|
}
|
|
}
|
|
break;
|
|
case EOT_Texture1D:
|
|
case EOT_Texture1DArray:
|
|
if (desc.ViewDimension == D3D11_SRV_DIMENSION_TEXTURE1D ||
|
|
desc.ViewDimension == D3D11_SRV_DIMENSION_TEXTURE1DARRAY)
|
|
return S_OK;
|
|
break;
|
|
case EOT_Texture2D:
|
|
case EOT_Texture2DArray:
|
|
if (desc.ViewDimension == D3D11_SRV_DIMENSION_TEXTURE2D ||
|
|
desc.ViewDimension == D3D11_SRV_DIMENSION_TEXTURE2DARRAY)
|
|
return S_OK;
|
|
break;
|
|
case EOT_Texture2DMS:
|
|
case EOT_Texture2DMSArray:
|
|
if (desc.ViewDimension == D3D11_SRV_DIMENSION_TEXTURE2DMS ||
|
|
desc.ViewDimension == D3D11_SRV_DIMENSION_TEXTURE2DMSARRAY)
|
|
return S_OK;
|
|
break;
|
|
case EOT_Texture3D:
|
|
if (desc.ViewDimension == D3D11_SRV_DIMENSION_TEXTURE3D)
|
|
return S_OK;
|
|
break;
|
|
case EOT_TextureCube:
|
|
case EOT_TextureCubeArray:
|
|
if (desc.ViewDimension == D3D11_SRV_DIMENSION_TEXTURECUBE ||
|
|
desc.ViewDimension == D3D11_SRV_DIMENSION_TEXTURECUBEARRAY)
|
|
return S_OK;
|
|
break;
|
|
case EOT_ByteAddressBuffer:
|
|
if (desc.ViewDimension == D3D11_SRV_DIMENSION_BUFFEREX && (desc.BufferEx.Flags & D3D11_BUFFEREX_SRV_FLAG_RAW))
|
|
return S_OK;
|
|
break;
|
|
case EOT_StructuredBuffer:
|
|
if (desc.ViewDimension == D3D11_SRV_DIMENSION_BUFFEREX || desc.ViewDimension == D3D11_SRV_DIMENSION_BUFFER)
|
|
{
|
|
ID3D11Buffer* pBuffer = nullptr;
|
|
pView->GetResource( (ID3D11Resource**)&pBuffer );
|
|
assert( pBuffer != nullptr );
|
|
D3D11_BUFFER_DESC BufDesc;
|
|
pBuffer->GetDesc( &BufDesc );
|
|
SAFE_RELEASE( pBuffer );
|
|
if( BufDesc.MiscFlags & D3D11_RESOURCE_MISC_BUFFER_STRUCTURED )
|
|
{
|
|
return S_OK;
|
|
}
|
|
else
|
|
{
|
|
DPF(0, "%s: Resource type mismatch; %s expected, non-structured Buffer provided.", pFuncName, GetTextureTypeNameFromEnum(ObjectType));
|
|
return E_INVALIDARG;
|
|
}
|
|
}
|
|
break;
|
|
default:
|
|
assert(0); // internal error, should never get here
|
|
return E_FAIL;
|
|
}
|
|
|
|
|
|
DPF(0, "%s: Resource type mismatch; %s expected, %s provided.", pFuncName, GetTextureTypeNameFromEnum(ObjectType), GetSRVDimensionNameFromEnum(desc.ViewDimension));
|
|
return E_INVALIDARG;
|
|
}
|
|
return S_OK;
|
|
}
|
|
|
|
template<typename IBaseInterface>
|
|
_Use_decl_annotations_
|
|
HRESULT TShaderResourceVariable<IBaseInterface>::SetResource(ID3D11ShaderResourceView *pResource)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
|
|
#ifdef _DEBUG
|
|
static LPCSTR pFuncName = "ID3DX11EffectShaderResourceVariable::SetResource";
|
|
|
|
VH(ValidateTextureType(pResource, pType->ObjectType, pFuncName));
|
|
#endif
|
|
|
|
// Texture variables don't need to be dirtied.
|
|
SAFE_ADDREF(pResource);
|
|
SAFE_RELEASE(Data.pShaderResource->pShaderResource);
|
|
Data.pShaderResource->pShaderResource = pResource;
|
|
|
|
lExit:
|
|
return hr;
|
|
}
|
|
|
|
template<typename IBaseInterface>
|
|
_Use_decl_annotations_
|
|
HRESULT TShaderResourceVariable<IBaseInterface>::GetResource(ID3D11ShaderResourceView **ppResource)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
|
|
#ifdef _DEBUG
|
|
static LPCSTR pFuncName = "ID3DX11EffectShaderResourceVariable::GetResource";
|
|
|
|
VERIFYPARAMETER(ppResource);
|
|
#endif
|
|
|
|
assert(Data.pShaderResource != 0 && Data.pShaderResource->pShaderResource != 0);
|
|
_Analysis_assume_(Data.pShaderResource != 0 && Data.pShaderResource->pShaderResource != 0);
|
|
*ppResource = Data.pShaderResource->pShaderResource;
|
|
SAFE_ADDREF(*ppResource);
|
|
|
|
lExit:
|
|
return hr;
|
|
}
|
|
|
|
template<typename IBaseInterface>
|
|
_Use_decl_annotations_
|
|
HRESULT TShaderResourceVariable<IBaseInterface>::SetResourceArray(ID3D11ShaderResourceView **ppResources, uint32_t Offset, uint32_t Count)
|
|
{
|
|
static LPCSTR pFuncName = "ID3DX11EffectShaderResourceVariable::SetResourceArray";
|
|
|
|
CHECK_OBJECT_ARRAY_BOUNDS(Offset, Count, ppResources);
|
|
|
|
#ifdef _DEBUG
|
|
for (size_t i = 0; i < Count; ++ i)
|
|
{
|
|
VH(ValidateTextureType(ppResources[i], pType->ObjectType, pFuncName));
|
|
}
|
|
#endif
|
|
|
|
// Texture variables don't need to be dirtied.
|
|
for (size_t i = 0; i < Count; ++ i)
|
|
{
|
|
SShaderResource *pResourceBlock = Data.pShaderResource + Offset + i;
|
|
SAFE_ADDREF(ppResources[i]);
|
|
SAFE_RELEASE(pResourceBlock->pShaderResource);
|
|
pResourceBlock->pShaderResource = ppResources[i];
|
|
}
|
|
|
|
lExit:
|
|
return hr;
|
|
}
|
|
|
|
template<typename IBaseInterface>
|
|
_Use_decl_annotations_
|
|
HRESULT TShaderResourceVariable<IBaseInterface>::GetResourceArray(ID3D11ShaderResourceView **ppResources, uint32_t Offset, uint32_t Count)
|
|
{
|
|
static LPCSTR pFuncName = "ID3DX11EffectShaderResourceVariable::GetResourceArray";
|
|
|
|
CHECK_OBJECT_ARRAY_BOUNDS(Offset, Count, ppResources);
|
|
|
|
for (size_t i = 0; i < Count; ++ i)
|
|
{
|
|
ppResources[i] = (Data.pShaderResource + Offset + i)->pShaderResource;
|
|
SAFE_ADDREF(ppResources[i]);
|
|
}
|
|
|
|
lExit:
|
|
return hr;
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
// ID3DX11EffectUnorderedAccessViewVariable (TUnorderedAccessViewVariable implementation)
|
|
//////////////////////////////////////////////////////////////////////////
|
|
|
|
template<typename IBaseInterface>
|
|
struct TUnorderedAccessViewVariable : public IBaseInterface
|
|
{
|
|
STDMETHOD(SetUnorderedAccessView)(_In_ ID3D11UnorderedAccessView *pResource) override;
|
|
STDMETHOD(GetUnorderedAccessView)(_Outptr_ ID3D11UnorderedAccessView **ppResource) override;
|
|
|
|
STDMETHOD(SetUnorderedAccessViewArray)(_In_reads_(Count) ID3D11UnorderedAccessView **ppResources, _In_ uint32_t Offset, _In_ uint32_t Count) override;
|
|
STDMETHOD(GetUnorderedAccessViewArray)(_Out_writes_(Count) ID3D11UnorderedAccessView **ppResources, _In_ uint32_t Offset, _In_ uint32_t Count) override;
|
|
};
|
|
|
|
static HRESULT ValidateTextureType(_In_ ID3D11UnorderedAccessView *pView, _In_ EObjectType ObjectType, _In_z_ LPCSTR pFuncName)
|
|
{
|
|
if (nullptr != pView)
|
|
{
|
|
D3D11_UNORDERED_ACCESS_VIEW_DESC desc;
|
|
pView->GetDesc(&desc);
|
|
switch (ObjectType)
|
|
{
|
|
case EOT_RWBuffer:
|
|
if (desc.ViewDimension != D3D11_UAV_DIMENSION_BUFFER)
|
|
break;
|
|
if (desc.Buffer.Flags & D3D11_BUFFER_UAV_FLAG_RAW)
|
|
{
|
|
DPF(0, "%s: Resource type mismatch; %s expected, RWByteAddressBuffer provided.", pFuncName, GetTextureTypeNameFromEnum(ObjectType));
|
|
return E_INVALIDARG;
|
|
}
|
|
else
|
|
{
|
|
ID3D11Buffer* pBuffer = nullptr;
|
|
pView->GetResource( (ID3D11Resource**)&pBuffer );
|
|
assert( pBuffer != nullptr );
|
|
D3D11_BUFFER_DESC BufDesc;
|
|
pBuffer->GetDesc( &BufDesc );
|
|
SAFE_RELEASE( pBuffer );
|
|
if( BufDesc.MiscFlags & D3D11_RESOURCE_MISC_BUFFER_STRUCTURED )
|
|
{
|
|
DPF(0, "%s: Resource type mismatch; %s expected, an RWStructuredBuffer provided.", pFuncName, GetTextureTypeNameFromEnum(ObjectType));
|
|
return E_INVALIDARG;
|
|
}
|
|
else
|
|
{
|
|
return S_OK;
|
|
}
|
|
}
|
|
break;
|
|
case EOT_RWTexture1D:
|
|
case EOT_RWTexture1DArray:
|
|
if (desc.ViewDimension == D3D11_UAV_DIMENSION_TEXTURE1D ||
|
|
desc.ViewDimension == D3D11_UAV_DIMENSION_TEXTURE1DARRAY)
|
|
return S_OK;
|
|
break;
|
|
case EOT_RWTexture2D:
|
|
case EOT_RWTexture2DArray:
|
|
if (desc.ViewDimension == D3D11_UAV_DIMENSION_TEXTURE2D ||
|
|
desc.ViewDimension == D3D11_UAV_DIMENSION_TEXTURE2DARRAY)
|
|
return S_OK;
|
|
break;
|
|
case EOT_RWTexture3D:
|
|
if (desc.ViewDimension == D3D11_UAV_DIMENSION_TEXTURE3D)
|
|
return S_OK;
|
|
break;
|
|
case EOT_RWByteAddressBuffer:
|
|
if (desc.ViewDimension == D3D11_UAV_DIMENSION_BUFFER && (desc.Buffer.Flags & D3D11_BUFFER_UAV_FLAG_RAW))
|
|
return S_OK;
|
|
break;
|
|
case EOT_RWStructuredBuffer:
|
|
if (desc.ViewDimension == D3D11_UAV_DIMENSION_BUFFER)
|
|
{
|
|
ID3D11Buffer* pBuffer = nullptr;
|
|
pView->GetResource( (ID3D11Resource**)&pBuffer );
|
|
assert( pBuffer != nullptr );
|
|
D3D11_BUFFER_DESC BufDesc;
|
|
pBuffer->GetDesc( &BufDesc );
|
|
SAFE_RELEASE( pBuffer );
|
|
if( BufDesc.MiscFlags & D3D11_RESOURCE_MISC_BUFFER_STRUCTURED )
|
|
{
|
|
return S_OK;
|
|
}
|
|
else
|
|
{
|
|
DPF(0, "%s: Resource type mismatch; %s expected, non-structured Buffer provided.", pFuncName, GetTextureTypeNameFromEnum(ObjectType));
|
|
return E_INVALIDARG;
|
|
}
|
|
}
|
|
break;
|
|
case EOT_RWStructuredBufferAlloc:
|
|
case EOT_RWStructuredBufferConsume:
|
|
if (desc.ViewDimension != D3D11_UAV_DIMENSION_BUFFER)
|
|
break;
|
|
if (desc.Buffer.Flags & D3D11_BUFFER_UAV_FLAG_COUNTER)
|
|
{
|
|
return S_OK;
|
|
}
|
|
else
|
|
{
|
|
DPF(0, "%s: Resource type mismatch; %s expected, non-Counter buffer provided.", pFuncName, GetTextureTypeNameFromEnum(ObjectType));
|
|
return E_INVALIDARG;
|
|
}
|
|
break;
|
|
case EOT_AppendStructuredBuffer:
|
|
case EOT_ConsumeStructuredBuffer:
|
|
if (desc.ViewDimension != D3D11_UAV_DIMENSION_BUFFER)
|
|
break;
|
|
if (desc.Buffer.Flags & D3D11_BUFFER_UAV_FLAG_APPEND)
|
|
{
|
|
return S_OK;
|
|
}
|
|
else
|
|
{
|
|
DPF(0, "%s: Resource type mismatch; %s expected, non-Append buffer provided.", pFuncName, GetTextureTypeNameFromEnum(ObjectType));
|
|
return E_INVALIDARG;
|
|
}
|
|
break;
|
|
default:
|
|
assert(0); // internal error, should never get here
|
|
return E_FAIL;
|
|
}
|
|
|
|
|
|
DPF(0, "%s: Resource type mismatch; %s expected, %s provided.", pFuncName, GetTextureTypeNameFromEnum(ObjectType), GetUAVDimensionNameFromEnum(desc.ViewDimension));
|
|
return E_INVALIDARG;
|
|
}
|
|
return S_OK;
|
|
}
|
|
|
|
template<typename IBaseInterface>
|
|
_Use_decl_annotations_
|
|
HRESULT TUnorderedAccessViewVariable<IBaseInterface>::SetUnorderedAccessView(ID3D11UnorderedAccessView *pResource)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
|
|
#ifdef _DEBUG
|
|
static LPCSTR pFuncName = "ID3DX11EffectUnorderedAccessViewVariable::SetUnorderedAccessView";
|
|
|
|
VH(ValidateTextureType(pResource, pType->ObjectType, pFuncName));
|
|
#endif
|
|
|
|
// UAV variables don't need to be dirtied.
|
|
SAFE_ADDREF(pResource);
|
|
SAFE_RELEASE(Data.pUnorderedAccessView->pUnorderedAccessView);
|
|
Data.pUnorderedAccessView->pUnorderedAccessView = pResource;
|
|
|
|
lExit:
|
|
return hr;
|
|
}
|
|
|
|
template<typename IBaseInterface>
|
|
_Use_decl_annotations_
|
|
HRESULT TUnorderedAccessViewVariable<IBaseInterface>::GetUnorderedAccessView(ID3D11UnorderedAccessView **ppResource)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
|
|
#ifdef _DEBUG
|
|
static LPCSTR pFuncName = "ID3DX11EffectUnorderedAccessViewVariable::GetUnorderedAccessView";
|
|
|
|
VERIFYPARAMETER(ppResource);
|
|
#endif
|
|
|
|
assert(Data.pUnorderedAccessView != 0 && Data.pUnorderedAccessView->pUnorderedAccessView != 0);
|
|
_Analysis_assume_(Data.pUnorderedAccessView != 0 && Data.pUnorderedAccessView->pUnorderedAccessView != 0);
|
|
*ppResource = Data.pUnorderedAccessView->pUnorderedAccessView;
|
|
SAFE_ADDREF(*ppResource);
|
|
|
|
lExit:
|
|
return hr;
|
|
}
|
|
|
|
template<typename IBaseInterface>
|
|
_Use_decl_annotations_
|
|
HRESULT TUnorderedAccessViewVariable<IBaseInterface>::SetUnorderedAccessViewArray(ID3D11UnorderedAccessView **ppResources, uint32_t Offset, uint32_t Count)
|
|
{
|
|
static LPCSTR pFuncName = "ID3DX11EffectUnorderedAccessViewVariable::SetUnorderedAccessViewArray";
|
|
|
|
CHECK_OBJECT_ARRAY_BOUNDS(Offset, Count, ppResources);
|
|
|
|
#ifdef _DEBUG
|
|
for (size_t i = 0; i < Count; ++ i)
|
|
{
|
|
VH(ValidateTextureType(ppResources[i], pType->ObjectType, pFuncName));
|
|
}
|
|
#endif
|
|
|
|
// Texture variables don't need to be dirtied.
|
|
for (size_t i = 0; i < Count; ++ i)
|
|
{
|
|
SUnorderedAccessView *pResourceBlock = Data.pUnorderedAccessView + Offset + i;
|
|
SAFE_ADDREF(ppResources[i]);
|
|
SAFE_RELEASE(pResourceBlock->pUnorderedAccessView);
|
|
pResourceBlock->pUnorderedAccessView = ppResources[i];
|
|
}
|
|
|
|
lExit:
|
|
return hr;
|
|
}
|
|
|
|
template<typename IBaseInterface>
|
|
_Use_decl_annotations_
|
|
HRESULT TUnorderedAccessViewVariable<IBaseInterface>::GetUnorderedAccessViewArray(ID3D11UnorderedAccessView **ppResources, uint32_t Offset, uint32_t Count)
|
|
{
|
|
static LPCSTR pFuncName = "ID3DX11EffectUnorderedAccessViewVariable::GetUnorderedAccessViewArray";
|
|
|
|
CHECK_OBJECT_ARRAY_BOUNDS(Offset, Count, ppResources);
|
|
|
|
for (size_t i = 0; i < Count; ++ i)
|
|
{
|
|
ppResources[i] = (Data.pUnorderedAccessView + Offset + i)->pUnorderedAccessView;
|
|
SAFE_ADDREF(ppResources[i]);
|
|
}
|
|
|
|
lExit:
|
|
return hr;
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
// ID3DX11EffectRenderTargetViewVariable (TRenderTargetViewVariable implementation)
|
|
//////////////////////////////////////////////////////////////////////////
|
|
|
|
template<typename IBaseInterface>
|
|
struct TRenderTargetViewVariable : public IBaseInterface
|
|
{
|
|
STDMETHOD(SetRenderTarget)(_In_ ID3D11RenderTargetView *pResource) override;
|
|
STDMETHOD(GetRenderTarget)(_Outptr_ ID3D11RenderTargetView **ppResource) override;
|
|
|
|
STDMETHOD(SetRenderTargetArray)(_In_reads_(Count) ID3D11RenderTargetView **ppResources, _In_ uint32_t Offset, _In_ uint32_t Count) override;
|
|
STDMETHOD(GetRenderTargetArray)(_Out_writes_(Count) ID3D11RenderTargetView **ppResources, _In_ uint32_t Offset, _In_ uint32_t Count) override;
|
|
};
|
|
|
|
|
|
template<typename IBaseInterface>
|
|
_Use_decl_annotations_
|
|
HRESULT TRenderTargetViewVariable<IBaseInterface>::SetRenderTarget(ID3D11RenderTargetView *pResource)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
|
|
#ifdef _DEBUG
|
|
static LPCSTR pFuncName = "ID3DX11EffectRenderTargetVariable::SetRenderTarget";
|
|
#endif
|
|
|
|
// Texture variables don't need to be dirtied.
|
|
SAFE_ADDREF(pResource);
|
|
SAFE_RELEASE(Data.pRenderTargetView->pRenderTargetView);
|
|
Data.pRenderTargetView->pRenderTargetView = pResource;
|
|
|
|
lExit:
|
|
return hr;
|
|
}
|
|
|
|
template<typename IBaseInterface>
|
|
_Use_decl_annotations_
|
|
HRESULT TRenderTargetViewVariable<IBaseInterface>::GetRenderTarget(ID3D11RenderTargetView **ppResource)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
|
|
assert(Data.pRenderTargetView->pRenderTargetView != 0);
|
|
_Analysis_assume_(Data.pRenderTargetView->pRenderTargetView != 0);
|
|
*ppResource = Data.pRenderTargetView->pRenderTargetView;
|
|
SAFE_ADDREF(*ppResource);
|
|
|
|
lExit:
|
|
return hr;
|
|
}
|
|
|
|
template<typename IBaseInterface>
|
|
_Use_decl_annotations_
|
|
HRESULT TRenderTargetViewVariable<IBaseInterface>::SetRenderTargetArray(ID3D11RenderTargetView **ppResources, uint32_t Offset, uint32_t Count)
|
|
{
|
|
static LPCSTR pFuncName = "ID3DX11EffectRenderTargetVariable::SetRenderTargetArray";
|
|
|
|
CHECK_OBJECT_ARRAY_BOUNDS(Offset, Count, ppResources);
|
|
|
|
// Texture variables don't need to be dirtied.
|
|
for (size_t i = 0; i < Count; ++ i)
|
|
{
|
|
SRenderTargetView *pResourceBlock = Data.pRenderTargetView + Offset + i;
|
|
SAFE_ADDREF(ppResources[i]);
|
|
SAFE_RELEASE(pResourceBlock->pRenderTargetView);
|
|
pResourceBlock->pRenderTargetView = ppResources[i];
|
|
}
|
|
|
|
lExit:
|
|
return hr;
|
|
}
|
|
|
|
template<typename IBaseInterface>
|
|
_Use_decl_annotations_
|
|
HRESULT TRenderTargetViewVariable<IBaseInterface>::GetRenderTargetArray(ID3D11RenderTargetView **ppResources, uint32_t Offset, uint32_t Count)
|
|
{
|
|
static LPCSTR pFuncName = "ID3DX11EffectRenderTargetVariable::GetRenderTargetArray";
|
|
|
|
CHECK_OBJECT_ARRAY_BOUNDS(Offset, Count, ppResources);
|
|
|
|
for (size_t i = 0; i < Count; ++ i)
|
|
{
|
|
ppResources[i] = (Data.pRenderTargetView + Offset + i)->pRenderTargetView;
|
|
SAFE_ADDREF(ppResources[i]);
|
|
}
|
|
|
|
lExit:
|
|
return hr;
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
// ID3DX11EffectDepthStencilViewVariable (TDepthStencilViewVariable implementation)
|
|
//////////////////////////////////////////////////////////////////////////
|
|
|
|
template<typename IBaseInterface>
|
|
struct TDepthStencilViewVariable : public IBaseInterface
|
|
{
|
|
STDMETHOD(SetDepthStencil)(_In_ ID3D11DepthStencilView *pResource) override;
|
|
STDMETHOD(GetDepthStencil)(_Outptr_ ID3D11DepthStencilView **ppResource) override;
|
|
|
|
STDMETHOD(SetDepthStencilArray)(_In_reads_(Count) ID3D11DepthStencilView **ppResources, _In_ uint32_t Offset, _In_ uint32_t Count) override;
|
|
STDMETHOD(GetDepthStencilArray)(_Out_writes_(Count) ID3D11DepthStencilView **ppResources, _In_ uint32_t Offset, _In_ uint32_t Count) override;
|
|
};
|
|
|
|
|
|
template<typename IBaseInterface>
|
|
_Use_decl_annotations_
|
|
HRESULT TDepthStencilViewVariable<IBaseInterface>::SetDepthStencil(ID3D11DepthStencilView *pResource)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
|
|
#ifdef _DEBUG
|
|
static LPCSTR pFuncName = "ID3D11DepthStencilViewVariable::SetDepthStencil";
|
|
|
|
#endif
|
|
|
|
// Texture variables don't need to be dirtied.
|
|
SAFE_ADDREF(pResource);
|
|
SAFE_RELEASE(Data.pDepthStencilView->pDepthStencilView);
|
|
Data.pDepthStencilView->pDepthStencilView = pResource;
|
|
|
|
lExit:
|
|
return hr;
|
|
}
|
|
|
|
template<typename IBaseInterface>
|
|
_Use_decl_annotations_
|
|
HRESULT TDepthStencilViewVariable<IBaseInterface>::GetDepthStencil(ID3D11DepthStencilView **ppResource)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
|
|
#ifdef _DEBUG
|
|
static LPCSTR pFuncName = "ID3D11DepthStencilViewVariable::GetDepthStencil";
|
|
|
|
VERIFYPARAMETER(ppResource);
|
|
#endif
|
|
|
|
assert(Data.pDepthStencilView->pDepthStencilView != 0);
|
|
_Analysis_assume_(Data.pDepthStencilView->pDepthStencilView != 0);
|
|
*ppResource = Data.pDepthStencilView->pDepthStencilView;
|
|
SAFE_ADDREF(*ppResource);
|
|
|
|
lExit:
|
|
return hr;
|
|
}
|
|
|
|
template<typename IBaseInterface>
|
|
_Use_decl_annotations_
|
|
HRESULT TDepthStencilViewVariable<IBaseInterface>::SetDepthStencilArray(ID3D11DepthStencilView **ppResources, uint32_t Offset, uint32_t Count)
|
|
{
|
|
static LPCSTR pFuncName = "ID3D11DepthStencilViewVariable::SetDepthStencilArray";
|
|
|
|
CHECK_OBJECT_ARRAY_BOUNDS(Offset, Count, ppResources);
|
|
|
|
// Texture variables don't need to be dirtied.
|
|
for (size_t i = 0; i < Count; ++ i)
|
|
{
|
|
SDepthStencilView *pResourceBlock = Data.pDepthStencilView + Offset + i;
|
|
SAFE_ADDREF(ppResources[i]);
|
|
SAFE_RELEASE(pResourceBlock->pDepthStencilView);
|
|
pResourceBlock->pDepthStencilView = ppResources[i];
|
|
}
|
|
|
|
lExit:
|
|
return hr;
|
|
}
|
|
|
|
template<typename IBaseInterface>
|
|
_Use_decl_annotations_
|
|
HRESULT TDepthStencilViewVariable<IBaseInterface>::GetDepthStencilArray(ID3D11DepthStencilView **ppResources, uint32_t Offset, uint32_t Count)
|
|
{
|
|
static LPCSTR pFuncName = "ID3D11DepthStencilViewVariable::GetDepthStencilArray";
|
|
|
|
CHECK_OBJECT_ARRAY_BOUNDS(Offset, Count, ppResources);
|
|
|
|
for (size_t i = 0; i < Count; ++ i)
|
|
{
|
|
ppResources[i] = (Data.pDepthStencilView + Offset + i)->pDepthStencilView;
|
|
SAFE_ADDREF(ppResources[i]);
|
|
}
|
|
|
|
lExit:
|
|
return hr;
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
// ID3DX11EffectShaderVariable (TShaderVariable implementation)
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
template<typename IBaseInterface>
|
|
struct TShaderVariable : public IBaseInterface
|
|
{
|
|
STDMETHOD(GetShaderDesc)(_In_ uint32_t ShaderIndex, _Out_ D3DX11_EFFECT_SHADER_DESC *pDesc) override;
|
|
|
|
STDMETHOD(GetVertexShader)(_In_ uint32_t ShaderIndex, _Outptr_ ID3D11VertexShader **ppVS) override;
|
|
STDMETHOD(GetGeometryShader)(_In_ uint32_t ShaderIndex, _Outptr_ ID3D11GeometryShader **ppGS) override;
|
|
STDMETHOD(GetPixelShader)(_In_ uint32_t ShaderIndex, _Outptr_ ID3D11PixelShader **ppPS) override;
|
|
STDMETHOD(GetHullShader)(_In_ uint32_t ShaderIndex, _Outptr_ ID3D11HullShader **ppHS) override;
|
|
STDMETHOD(GetDomainShader)(_In_ uint32_t ShaderIndex, _Outptr_ ID3D11DomainShader **ppDS) override;
|
|
STDMETHOD(GetComputeShader)(_In_ uint32_t ShaderIndex, _Outptr_ ID3D11ComputeShader **ppCS) override;
|
|
|
|
STDMETHOD(GetInputSignatureElementDesc)(_In_ uint32_t ShaderIndex, _In_ uint32_t Element, _Out_ D3D11_SIGNATURE_PARAMETER_DESC *pDesc) override;
|
|
STDMETHOD(GetOutputSignatureElementDesc)(_In_ uint32_t ShaderIndex, _In_ uint32_t Element, _Out_ D3D11_SIGNATURE_PARAMETER_DESC *pDesc) override;
|
|
STDMETHOD(GetPatchConstantSignatureElementDesc)(_In_ uint32_t ShaderIndex, _In_ uint32_t Element, _Out_ D3D11_SIGNATURE_PARAMETER_DESC *pDesc) override;
|
|
|
|
STDMETHOD_(bool, IsValid)();
|
|
};
|
|
|
|
template<typename IBaseInterface>
|
|
_Use_decl_annotations_
|
|
HRESULT TShaderVariable<IBaseInterface>::GetShaderDesc(uint32_t ShaderIndex, D3DX11_EFFECT_SHADER_DESC *pDesc)
|
|
{
|
|
static LPCSTR pFuncName = "ID3DX11EffectShaderVariable::GetShaderDesc";
|
|
|
|
CHECK_OBJECT_SCALAR_BOUNDS(ShaderIndex, pDesc);
|
|
|
|
hr = Data.pShader[ShaderIndex].GetShaderDesc(pDesc, false);
|
|
|
|
lExit:
|
|
return hr;
|
|
}
|
|
|
|
template<typename IBaseInterface>
|
|
_Use_decl_annotations_
|
|
HRESULT TShaderVariable<IBaseInterface>::GetVertexShader(uint32_t ShaderIndex, ID3D11VertexShader **ppVS)
|
|
{
|
|
static LPCSTR pFuncName = "ID3DX11EffectShaderVariable::GetVertexShader";
|
|
|
|
CHECK_OBJECT_SCALAR_BOUNDS(ShaderIndex, ppVS);
|
|
|
|
VH( Data.pShader[ShaderIndex].GetVertexShader(ppVS) );
|
|
|
|
lExit:
|
|
return hr;
|
|
}
|
|
|
|
template<typename IBaseInterface>
|
|
_Use_decl_annotations_
|
|
HRESULT TShaderVariable<IBaseInterface>::GetGeometryShader(uint32_t ShaderIndex, ID3D11GeometryShader **ppGS)
|
|
{
|
|
static LPCSTR pFuncName = "ID3DX11EffectShaderVariable::GetGeometryShader";
|
|
|
|
CHECK_OBJECT_SCALAR_BOUNDS(ShaderIndex, ppGS);
|
|
|
|
VH( Data.pShader[ShaderIndex].GetGeometryShader(ppGS) );
|
|
|
|
lExit:
|
|
return hr;
|
|
}
|
|
|
|
template<typename IBaseInterface>
|
|
_Use_decl_annotations_
|
|
HRESULT TShaderVariable<IBaseInterface>::GetPixelShader(uint32_t ShaderIndex, ID3D11PixelShader **ppPS)
|
|
{
|
|
static LPCSTR pFuncName = "ID3DX11EffectShaderVariable::GetPixelShader";
|
|
|
|
CHECK_OBJECT_SCALAR_BOUNDS(ShaderIndex, ppPS);
|
|
|
|
VH( Data.pShader[ShaderIndex].GetPixelShader(ppPS) );
|
|
|
|
lExit:
|
|
return hr;
|
|
}
|
|
|
|
template<typename IBaseInterface>
|
|
_Use_decl_annotations_
|
|
HRESULT TShaderVariable<IBaseInterface>::GetHullShader(uint32_t ShaderIndex, ID3D11HullShader **ppHS)
|
|
{
|
|
static LPCSTR pFuncName = "ID3DX11EffectShaderVariable::GetHullShader";
|
|
|
|
CHECK_OBJECT_SCALAR_BOUNDS(ShaderIndex, ppHS);
|
|
|
|
VH( Data.pShader[ShaderIndex].GetHullShader(ppHS) );
|
|
|
|
lExit:
|
|
return hr;
|
|
}
|
|
|
|
template<typename IBaseInterface>
|
|
_Use_decl_annotations_
|
|
HRESULT TShaderVariable<IBaseInterface>::GetDomainShader(uint32_t ShaderIndex, ID3D11DomainShader **ppDS)
|
|
{
|
|
static LPCSTR pFuncName = "ID3DX11EffectShaderVariable::GetDomainShader";
|
|
|
|
CHECK_OBJECT_SCALAR_BOUNDS(ShaderIndex, ppDS);
|
|
|
|
VH( Data.pShader[ShaderIndex].GetDomainShader(ppDS) );
|
|
|
|
lExit:
|
|
return hr;
|
|
}
|
|
|
|
template<typename IBaseInterface>
|
|
_Use_decl_annotations_
|
|
HRESULT TShaderVariable<IBaseInterface>::GetComputeShader(uint32_t ShaderIndex, ID3D11ComputeShader **ppCS)
|
|
{
|
|
static LPCSTR pFuncName = "ID3DX11EffectShaderVariable::GetComputeShader";
|
|
|
|
CHECK_OBJECT_SCALAR_BOUNDS(ShaderIndex, ppCS);
|
|
|
|
VH( Data.pShader[ShaderIndex].GetComputeShader(ppCS) );
|
|
|
|
lExit:
|
|
return hr;
|
|
}
|
|
|
|
template<typename IBaseInterface>
|
|
_Use_decl_annotations_
|
|
HRESULT TShaderVariable<IBaseInterface>::GetInputSignatureElementDesc(uint32_t ShaderIndex, uint32_t Element, D3D11_SIGNATURE_PARAMETER_DESC *pDesc)
|
|
{
|
|
static LPCSTR pFuncName = "ID3DX11EffectShaderVariable::GetInputSignatureElementDesc";
|
|
|
|
CHECK_OBJECT_SCALAR_BOUNDS(ShaderIndex, pDesc);
|
|
|
|
VH( Data.pShader[ShaderIndex].GetSignatureElementDesc(SShaderBlock::ST_Input, Element, pDesc) );
|
|
|
|
lExit:
|
|
return hr;
|
|
}
|
|
|
|
template<typename IBaseInterface>
|
|
_Use_decl_annotations_
|
|
HRESULT TShaderVariable<IBaseInterface>::GetOutputSignatureElementDesc(uint32_t ShaderIndex, uint32_t Element, D3D11_SIGNATURE_PARAMETER_DESC *pDesc)
|
|
{
|
|
static LPCSTR pFuncName = "ID3DX11EffectShaderVariable::GetOutputSignatureElementDesc";
|
|
|
|
CHECK_OBJECT_SCALAR_BOUNDS(ShaderIndex, pDesc);
|
|
|
|
VH( Data.pShader[ShaderIndex].GetSignatureElementDesc(SShaderBlock::ST_Output, Element, pDesc) );
|
|
|
|
lExit:
|
|
return hr;
|
|
}
|
|
|
|
template<typename IBaseInterface>
|
|
_Use_decl_annotations_
|
|
HRESULT TShaderVariable<IBaseInterface>::GetPatchConstantSignatureElementDesc(uint32_t ShaderIndex, uint32_t Element, D3D11_SIGNATURE_PARAMETER_DESC *pDesc)
|
|
{
|
|
static LPCSTR pFuncName = "ID3DX11EffectShaderVariable::GetPatchConstantSignatureElementDesc";
|
|
|
|
CHECK_OBJECT_SCALAR_BOUNDS(ShaderIndex, pDesc);
|
|
|
|
VH( Data.pShader[ShaderIndex].GetSignatureElementDesc(SShaderBlock::ST_PatchConstant, Element, pDesc) );
|
|
|
|
lExit:
|
|
return hr;
|
|
}
|
|
|
|
template<typename IBaseInterface>
|
|
bool TShaderVariable<IBaseInterface>::IsValid()
|
|
{
|
|
uint32_t numElements = IsArray()? pType->Elements : 1;
|
|
bool valid = true;
|
|
while( numElements > 0 && ( valid = Data.pShader[ numElements-1 ].IsValid ) )
|
|
numElements--;
|
|
return valid;
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
// ID3DX11EffectBlendVariable (TBlendVariable implementation)
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
template<typename IBaseInterface>
|
|
struct TBlendVariable : public IBaseInterface
|
|
{
|
|
public:
|
|
STDMETHOD(GetBlendState)(_In_ uint32_t Index, _Outptr_ ID3D11BlendState **ppState) override;
|
|
STDMETHOD(SetBlendState)(_In_ uint32_t Index, _In_ ID3D11BlendState *pState) override;
|
|
STDMETHOD(UndoSetBlendState)(_In_ uint32_t Index) override;
|
|
STDMETHOD(GetBackingStore)(_In_ uint32_t Index, _Out_ D3D11_BLEND_DESC *pDesc) override;
|
|
STDMETHOD_(bool, IsValid)() override;
|
|
};
|
|
|
|
template<typename IBaseInterface>
|
|
_Use_decl_annotations_
|
|
HRESULT TBlendVariable<IBaseInterface>::GetBlendState(uint32_t Index, ID3D11BlendState **ppState)
|
|
{
|
|
static LPCSTR pFuncName = "ID3DX11EffectBlendVariable::GetBlendState";
|
|
|
|
CHECK_OBJECT_SCALAR_BOUNDS(Index, ppState);
|
|
|
|
assert(Data.pBlend[Index].pBlendObject != 0);
|
|
_Analysis_assume_(Data.pBlend[Index].pBlendObject != 0);
|
|
*ppState = Data.pBlend[Index].pBlendObject;
|
|
SAFE_ADDREF(*ppState);
|
|
|
|
lExit:
|
|
return hr;
|
|
}
|
|
|
|
template<typename IBaseInterface>
|
|
_Use_decl_annotations_
|
|
HRESULT TBlendVariable<IBaseInterface>::SetBlendState(uint32_t Index, ID3D11BlendState *pState)
|
|
{
|
|
static LPCSTR pFuncName = "ID3DX11EffectBlendState::SetBlendState";
|
|
|
|
CHECK_SCALAR_BOUNDS(Index);
|
|
|
|
if( !Data.pBlend[Index].IsUserManaged )
|
|
{
|
|
// Save original state object in case we UndoSet
|
|
assert( pMemberData[Index].Type == MDT_BlendState );
|
|
VB( pMemberData[Index].Data.pD3DEffectsManagedBlendState == nullptr );
|
|
pMemberData[Index].Data.pD3DEffectsManagedBlendState = Data.pBlend[Index].pBlendObject;
|
|
Data.pBlend[Index].pBlendObject = nullptr;
|
|
Data.pBlend[Index].IsUserManaged = true;
|
|
}
|
|
|
|
SAFE_ADDREF( pState );
|
|
SAFE_RELEASE( Data.pBlend[Index].pBlendObject );
|
|
Data.pBlend[Index].pBlendObject = pState;
|
|
Data.pBlend[Index].IsValid = true;
|
|
lExit:
|
|
return hr;
|
|
}
|
|
|
|
template<typename IBaseInterface>
|
|
_Use_decl_annotations_
|
|
HRESULT TBlendVariable<IBaseInterface>::UndoSetBlendState(uint32_t Index)
|
|
{
|
|
static LPCSTR pFuncName = "ID3DX11EffectBlendState::UndoSetBlendState";
|
|
|
|
CHECK_SCALAR_BOUNDS(Index);
|
|
|
|
if( !Data.pBlend[Index].IsUserManaged )
|
|
{
|
|
return S_FALSE;
|
|
}
|
|
|
|
// Revert to original state object
|
|
SAFE_RELEASE( Data.pBlend[Index].pBlendObject );
|
|
Data.pBlend[Index].pBlendObject = pMemberData[Index].Data.pD3DEffectsManagedBlendState;
|
|
pMemberData[Index].Data.pD3DEffectsManagedBlendState = nullptr;
|
|
Data.pBlend[Index].IsUserManaged = false;
|
|
|
|
lExit:
|
|
return hr;
|
|
}
|
|
|
|
template<typename IBaseInterface>
|
|
_Use_decl_annotations_
|
|
HRESULT TBlendVariable<IBaseInterface>::GetBackingStore(uint32_t Index, D3D11_BLEND_DESC *pBlendDesc)
|
|
{
|
|
static LPCSTR pFuncName = "ID3DX11EffectBlendVariable::GetBackingStore";
|
|
|
|
CHECK_OBJECT_SCALAR_BOUNDS(Index, pBlendDesc);
|
|
|
|
if( Data.pBlend[Index].IsUserManaged )
|
|
{
|
|
if( Data.pBlend[Index].pBlendObject )
|
|
{
|
|
Data.pBlend[Index].pBlendObject->GetDesc( pBlendDesc );
|
|
}
|
|
else
|
|
{
|
|
*pBlendDesc = CD3D11_BLEND_DESC( D3D11_DEFAULT );
|
|
}
|
|
}
|
|
else
|
|
{
|
|
SBlendBlock *pBlock = Data.pBlend + Index;
|
|
if (pBlock->ApplyAssignments(GetTopLevelEntity()->pEffect))
|
|
{
|
|
pBlock->pAssignments[0].LastRecomputedTime = 0; // Force a recreate of this block the next time ApplyRenderStateBlock is called
|
|
}
|
|
|
|
memcpy( pBlendDesc, &pBlock->BackingStore, sizeof(D3D11_BLEND_DESC) );
|
|
}
|
|
|
|
lExit:
|
|
return hr;
|
|
}
|
|
|
|
template<typename IBaseInterface>
|
|
bool TBlendVariable<IBaseInterface>::IsValid()
|
|
{
|
|
uint32_t numElements = IsArray()? pType->Elements : 1;
|
|
bool valid = true;
|
|
while( numElements > 0 && ( valid = Data.pBlend[ numElements-1 ].IsValid ) )
|
|
numElements--;
|
|
return valid;
|
|
}
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
// ID3DX11EffectDepthStencilVariable (TDepthStencilVariable implementation)
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
template<typename IBaseInterface>
|
|
struct TDepthStencilVariable : public IBaseInterface
|
|
{
|
|
public:
|
|
STDMETHOD(GetDepthStencilState)(_In_ uint32_t Index, _Outptr_ ID3D11DepthStencilState **ppState) override;
|
|
STDMETHOD(SetDepthStencilState)(_In_ uint32_t Index, _In_ ID3D11DepthStencilState *pState) override;
|
|
STDMETHOD(UndoSetDepthStencilState)(_In_ uint32_t Index) override;
|
|
STDMETHOD(GetBackingStore)(_In_ uint32_t Index, _Out_ D3D11_DEPTH_STENCIL_DESC *pDesc) override;
|
|
STDMETHOD_(bool, IsValid)() override;
|
|
};
|
|
|
|
template<typename IBaseInterface>
|
|
_Use_decl_annotations_
|
|
HRESULT TDepthStencilVariable<IBaseInterface>::GetDepthStencilState(uint32_t Index, ID3D11DepthStencilState **ppState)
|
|
{
|
|
static LPCSTR pFuncName = "ID3DX11EffectDepthStencilVariable::GetDepthStencilState";
|
|
|
|
CHECK_OBJECT_SCALAR_BOUNDS(Index, ppState);
|
|
|
|
assert(Data.pDepthStencil[Index].pDSObject != 0);
|
|
_Analysis_assume_(Data.pDepthStencil[Index].pDSObject != 0);
|
|
*ppState = Data.pDepthStencil[Index].pDSObject;
|
|
SAFE_ADDREF(*ppState);
|
|
|
|
lExit:
|
|
return hr;
|
|
}
|
|
|
|
template<typename IBaseInterface>
|
|
_Use_decl_annotations_
|
|
HRESULT TDepthStencilVariable<IBaseInterface>::SetDepthStencilState(uint32_t Index, ID3D11DepthStencilState *pState)
|
|
{
|
|
static LPCSTR pFuncName = "ID3DX11EffectDepthStencilState::SetDepthStencilState";
|
|
|
|
CHECK_SCALAR_BOUNDS(Index);
|
|
|
|
if( !Data.pDepthStencil[Index].IsUserManaged )
|
|
{
|
|
// Save original state object in case we UndoSet
|
|
assert( pMemberData[Index].Type == MDT_DepthStencilState );
|
|
VB( pMemberData[Index].Data.pD3DEffectsManagedDepthStencilState == nullptr );
|
|
pMemberData[Index].Data.pD3DEffectsManagedDepthStencilState = Data.pDepthStencil[Index].pDSObject;
|
|
Data.pDepthStencil[Index].pDSObject = nullptr;
|
|
Data.pDepthStencil[Index].IsUserManaged = true;
|
|
}
|
|
|
|
SAFE_ADDREF( pState );
|
|
SAFE_RELEASE( Data.pDepthStencil[Index].pDSObject );
|
|
Data.pDepthStencil[Index].pDSObject = pState;
|
|
Data.pDepthStencil[Index].IsValid = true;
|
|
lExit:
|
|
return hr;
|
|
}
|
|
|
|
template<typename IBaseInterface>
|
|
HRESULT TDepthStencilVariable<IBaseInterface>::UndoSetDepthStencilState(_In_ uint32_t Index)
|
|
{
|
|
static LPCSTR pFuncName = "ID3DX11EffectDepthStencilState::UndoSetDepthStencilState";
|
|
|
|
CHECK_SCALAR_BOUNDS(Index);
|
|
|
|
if( !Data.pDepthStencil[Index].IsUserManaged )
|
|
{
|
|
return S_FALSE;
|
|
}
|
|
|
|
// Revert to original state object
|
|
SAFE_RELEASE( Data.pDepthStencil[Index].pDSObject );
|
|
Data.pDepthStencil[Index].pDSObject = pMemberData[Index].Data.pD3DEffectsManagedDepthStencilState;
|
|
pMemberData[Index].Data.pD3DEffectsManagedDepthStencilState = nullptr;
|
|
Data.pDepthStencil[Index].IsUserManaged = false;
|
|
|
|
lExit:
|
|
return hr;
|
|
}
|
|
|
|
template<typename IBaseInterface>
|
|
_Use_decl_annotations_
|
|
HRESULT TDepthStencilVariable<IBaseInterface>::GetBackingStore(uint32_t Index, D3D11_DEPTH_STENCIL_DESC *pDepthStencilDesc)
|
|
{
|
|
static LPCSTR pFuncName = "ID3DX11EffectDepthStencilVariable::GetBackingStore";
|
|
|
|
CHECK_OBJECT_SCALAR_BOUNDS(Index, pDepthStencilDesc);
|
|
|
|
if( Data.pDepthStencil[Index].IsUserManaged )
|
|
{
|
|
if( Data.pDepthStencil[Index].pDSObject )
|
|
{
|
|
Data.pDepthStencil[Index].pDSObject->GetDesc( pDepthStencilDesc );
|
|
}
|
|
else
|
|
{
|
|
*pDepthStencilDesc = CD3D11_DEPTH_STENCIL_DESC( D3D11_DEFAULT );
|
|
}
|
|
}
|
|
else
|
|
{
|
|
SDepthStencilBlock *pBlock = Data.pDepthStencil + Index;
|
|
if (pBlock->ApplyAssignments(GetTopLevelEntity()->pEffect))
|
|
{
|
|
pBlock->pAssignments[0].LastRecomputedTime = 0; // Force a recreate of this block the next time ApplyRenderStateBlock is called
|
|
}
|
|
|
|
memcpy(pDepthStencilDesc, &pBlock->BackingStore, sizeof(D3D11_DEPTH_STENCIL_DESC));
|
|
}
|
|
|
|
lExit:
|
|
return hr;
|
|
}
|
|
|
|
template<typename IBaseInterface>
|
|
bool TDepthStencilVariable<IBaseInterface>::IsValid()
|
|
{
|
|
uint32_t numElements = IsArray()? pType->Elements : 1;
|
|
bool valid = true;
|
|
while( numElements > 0 && ( valid = Data.pDepthStencil[ numElements-1 ].IsValid ) )
|
|
numElements--;
|
|
return valid;
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
// ID3DX11EffectRasterizerVariable (TRasterizerVariable implementation)
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
template<typename IBaseInterface>
|
|
struct TRasterizerVariable : public IBaseInterface
|
|
{
|
|
public:
|
|
|
|
STDMETHOD(GetRasterizerState)(_In_ uint32_t Index, _Outptr_ ID3D11RasterizerState **ppState) override;
|
|
STDMETHOD(SetRasterizerState)(_In_ uint32_t Index, _In_ ID3D11RasterizerState *pState) override;
|
|
STDMETHOD(UndoSetRasterizerState)(_In_ uint32_t Index) override;
|
|
STDMETHOD(GetBackingStore)(_In_ uint32_t Index, _Out_ D3D11_RASTERIZER_DESC *pDesc) override;
|
|
STDMETHOD_(bool, IsValid)() override;
|
|
};
|
|
|
|
template<typename IBaseInterface>
|
|
_Use_decl_annotations_
|
|
HRESULT TRasterizerVariable<IBaseInterface>::GetRasterizerState(uint32_t Index, ID3D11RasterizerState **ppState)
|
|
{
|
|
static LPCSTR pFuncName = "ID3DX11EffectRasterizerVariable::GetRasterizerState";
|
|
|
|
CHECK_OBJECT_SCALAR_BOUNDS(Index, ppState);
|
|
|
|
assert(Data.pRasterizer[Index].pRasterizerObject != 0);
|
|
_Analysis_assume_(Data.pRasterizer[Index].pRasterizerObject != 0);
|
|
*ppState = Data.pRasterizer[Index].pRasterizerObject;
|
|
SAFE_ADDREF(*ppState);
|
|
|
|
lExit:
|
|
return hr;
|
|
}
|
|
|
|
template<typename IBaseInterface>
|
|
_Use_decl_annotations_
|
|
HRESULT TRasterizerVariable<IBaseInterface>::SetRasterizerState(uint32_t Index, ID3D11RasterizerState *pState)
|
|
{
|
|
static LPCSTR pFuncName = "ID3DX11EffectRasterizerState::SetRasterizerState";
|
|
|
|
CHECK_SCALAR_BOUNDS(Index);
|
|
|
|
if( !Data.pRasterizer[Index].IsUserManaged )
|
|
{
|
|
// Save original state object in case we UndoSet
|
|
assert( pMemberData[Index].Type == MDT_RasterizerState );
|
|
VB( pMemberData[Index].Data.pD3DEffectsManagedRasterizerState == nullptr );
|
|
pMemberData[Index].Data.pD3DEffectsManagedRasterizerState = Data.pRasterizer[Index].pRasterizerObject;
|
|
Data.pRasterizer[Index].pRasterizerObject = nullptr;
|
|
Data.pRasterizer[Index].IsUserManaged = true;
|
|
}
|
|
|
|
SAFE_ADDREF( pState );
|
|
SAFE_RELEASE( Data.pRasterizer[Index].pRasterizerObject );
|
|
Data.pRasterizer[Index].pRasterizerObject = pState;
|
|
Data.pRasterizer[Index].IsValid = true;
|
|
lExit:
|
|
return hr;
|
|
}
|
|
|
|
template<typename IBaseInterface>
|
|
_Use_decl_annotations_
|
|
HRESULT TRasterizerVariable<IBaseInterface>::UndoSetRasterizerState(uint32_t Index)
|
|
{
|
|
static LPCSTR pFuncName = "ID3DX11EffectRasterizerState::UndoSetRasterizerState";
|
|
|
|
CHECK_SCALAR_BOUNDS(Index);
|
|
|
|
if( !Data.pRasterizer[Index].IsUserManaged )
|
|
{
|
|
return S_FALSE;
|
|
}
|
|
|
|
// Revert to original state object
|
|
SAFE_RELEASE( Data.pRasterizer[Index].pRasterizerObject );
|
|
Data.pRasterizer[Index].pRasterizerObject = pMemberData[Index].Data.pD3DEffectsManagedRasterizerState;
|
|
pMemberData[Index].Data.pD3DEffectsManagedRasterizerState = nullptr;
|
|
Data.pRasterizer[Index].IsUserManaged = false;
|
|
|
|
lExit:
|
|
return hr;
|
|
}
|
|
|
|
template<typename IBaseInterface>
|
|
_Use_decl_annotations_
|
|
HRESULT TRasterizerVariable<IBaseInterface>::GetBackingStore(uint32_t Index, D3D11_RASTERIZER_DESC *pRasterizerDesc)
|
|
{
|
|
static LPCSTR pFuncName = "ID3DX11EffectRasterizerVariable::GetBackingStore";
|
|
|
|
CHECK_OBJECT_SCALAR_BOUNDS(Index, pRasterizerDesc);
|
|
|
|
if( Data.pRasterizer[Index].IsUserManaged )
|
|
{
|
|
if( Data.pRasterizer[Index].pRasterizerObject )
|
|
{
|
|
Data.pRasterizer[Index].pRasterizerObject->GetDesc( pRasterizerDesc );
|
|
}
|
|
else
|
|
{
|
|
*pRasterizerDesc = CD3D11_RASTERIZER_DESC( D3D11_DEFAULT );
|
|
}
|
|
}
|
|
else
|
|
{
|
|
SRasterizerBlock *pBlock = Data.pRasterizer + Index;
|
|
if (pBlock->ApplyAssignments(GetTopLevelEntity()->pEffect))
|
|
{
|
|
pBlock->pAssignments[0].LastRecomputedTime = 0; // Force a recreate of this block the next time ApplyRenderStateBlock is called
|
|
}
|
|
|
|
memcpy(pRasterizerDesc, &pBlock->BackingStore, sizeof(D3D11_RASTERIZER_DESC));
|
|
}
|
|
|
|
lExit:
|
|
return hr;
|
|
}
|
|
|
|
template<typename IBaseInterface>
|
|
bool TRasterizerVariable<IBaseInterface>::IsValid()
|
|
{
|
|
uint32_t numElements = IsArray()? pType->Elements : 1;
|
|
bool valid = true;
|
|
while( numElements > 0 && ( valid = Data.pRasterizer[ numElements-1 ].IsValid ) )
|
|
numElements--;
|
|
return valid;
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
// ID3DX11EffectSamplerVariable (TSamplerVariable implementation)
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
template<typename IBaseInterface>
|
|
struct TSamplerVariable : public IBaseInterface
|
|
{
|
|
public:
|
|
|
|
STDMETHOD(GetSampler)(_In_ uint32_t Index, _Outptr_ ID3D11SamplerState **ppSampler) override;
|
|
STDMETHOD(SetSampler)(_In_ uint32_t Index, _In_ ID3D11SamplerState *pSampler) override;
|
|
STDMETHOD(UndoSetSampler)(_In_ uint32_t Index) override;
|
|
STDMETHOD(GetBackingStore)(_In_ uint32_t Index, _Out_ D3D11_SAMPLER_DESC *pDesc) override;
|
|
};
|
|
|
|
template<typename IBaseInterface>
|
|
_Use_decl_annotations_
|
|
HRESULT TSamplerVariable<IBaseInterface>::GetSampler(uint32_t Index, ID3D11SamplerState **ppSampler)
|
|
{
|
|
static LPCSTR pFuncName = "ID3DX11EffectSamplerVariable::GetSampler";
|
|
|
|
CHECK_OBJECT_SCALAR_BOUNDS(Index, ppSampler);
|
|
|
|
_Analysis_assume_( Data.pSampler[Index].pD3DObject != 0 );
|
|
*ppSampler = Data.pSampler[Index].pD3DObject;
|
|
SAFE_ADDREF(*ppSampler);
|
|
|
|
lExit:
|
|
return hr;
|
|
}
|
|
|
|
template<typename IBaseInterface>
|
|
_Use_decl_annotations_
|
|
HRESULT TSamplerVariable<IBaseInterface>::SetSampler(uint32_t Index, ID3D11SamplerState *pSampler)
|
|
{
|
|
static LPCSTR pFuncName = "ID3DX11EffectSamplerState::SetSampler";
|
|
|
|
CHECK_SCALAR_BOUNDS(Index);
|
|
|
|
// Replace all references to the old shader block with this one
|
|
GetEffect()->ReplaceSamplerReference(&Data.pSampler[Index], pSampler);
|
|
|
|
if( !Data.pSampler[Index].IsUserManaged )
|
|
{
|
|
// Save original state object in case we UndoSet
|
|
assert( pMemberData[Index].Type == MDT_SamplerState );
|
|
VB( pMemberData[Index].Data.pD3DEffectsManagedSamplerState == nullptr );
|
|
pMemberData[Index].Data.pD3DEffectsManagedSamplerState = Data.pSampler[Index].pD3DObject;
|
|
Data.pSampler[Index].pD3DObject = nullptr;
|
|
Data.pSampler[Index].IsUserManaged = true;
|
|
}
|
|
|
|
SAFE_ADDREF( pSampler );
|
|
SAFE_RELEASE( Data.pSampler[Index].pD3DObject );
|
|
Data.pSampler[Index].pD3DObject = pSampler;
|
|
lExit:
|
|
return hr;
|
|
}
|
|
|
|
template<typename IBaseInterface>
|
|
HRESULT TSamplerVariable<IBaseInterface>::UndoSetSampler(_In_ uint32_t Index)
|
|
{
|
|
static LPCSTR pFuncName = "ID3DX11EffectSamplerState::UndoSetSampler";
|
|
|
|
CHECK_SCALAR_BOUNDS(Index);
|
|
|
|
if( !Data.pSampler[Index].IsUserManaged )
|
|
{
|
|
return S_FALSE;
|
|
}
|
|
|
|
// Replace all references to the old shader block with this one
|
|
GetEffect()->ReplaceSamplerReference(&Data.pSampler[Index], pMemberData[Index].Data.pD3DEffectsManagedSamplerState);
|
|
|
|
// Revert to original state object
|
|
SAFE_RELEASE( Data.pSampler[Index].pD3DObject );
|
|
Data.pSampler[Index].pD3DObject = pMemberData[Index].Data.pD3DEffectsManagedSamplerState;
|
|
pMemberData[Index].Data.pD3DEffectsManagedSamplerState = nullptr;
|
|
Data.pSampler[Index].IsUserManaged = false;
|
|
|
|
lExit:
|
|
return hr;
|
|
}
|
|
|
|
template<typename IBaseInterface>
|
|
_Use_decl_annotations_
|
|
HRESULT TSamplerVariable<IBaseInterface>::GetBackingStore(uint32_t Index, D3D11_SAMPLER_DESC *pDesc)
|
|
{
|
|
static LPCSTR pFuncName = "ID3DX11EffectSamplerVariable::GetBackingStore";
|
|
|
|
CHECK_OBJECT_SCALAR_BOUNDS(Index, pDesc);
|
|
|
|
if( Data.pSampler[Index].IsUserManaged )
|
|
{
|
|
if( Data.pSampler[Index].pD3DObject )
|
|
{
|
|
Data.pSampler[Index].pD3DObject->GetDesc( pDesc );
|
|
}
|
|
else
|
|
{
|
|
*pDesc = CD3D11_SAMPLER_DESC( D3D11_DEFAULT );
|
|
}
|
|
}
|
|
else
|
|
{
|
|
SSamplerBlock *pBlock = Data.pSampler + Index;
|
|
if (pBlock->ApplyAssignments(GetTopLevelEntity()->pEffect))
|
|
{
|
|
pBlock->pAssignments[0].LastRecomputedTime = 0; // Force a recreate of this block the next time ApplyRenderStateBlock is called
|
|
}
|
|
|
|
memcpy(pDesc, &pBlock->BackingStore.SamplerDesc, sizeof(D3D11_SAMPLER_DESC));
|
|
}
|
|
|
|
lExit:
|
|
return hr;
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
// TUncastableVariable
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
template<typename IBaseInterface>
|
|
struct TUncastableVariable : public IBaseInterface
|
|
{
|
|
STDMETHOD_(ID3DX11EffectScalarVariable*, AsScalar)() override;
|
|
STDMETHOD_(ID3DX11EffectVectorVariable*, AsVector)() override;
|
|
STDMETHOD_(ID3DX11EffectMatrixVariable*, AsMatrix)() override;
|
|
STDMETHOD_(ID3DX11EffectStringVariable*, AsString)() override;
|
|
STDMETHOD_(ID3DX11EffectClassInstanceVariable*, AsClassInstance)() override;
|
|
STDMETHOD_(ID3DX11EffectInterfaceVariable*, AsInterface)() override;
|
|
STDMETHOD_(ID3DX11EffectShaderResourceVariable*, AsShaderResource)() override;
|
|
STDMETHOD_(ID3DX11EffectUnorderedAccessViewVariable*, AsUnorderedAccessView)() override;
|
|
STDMETHOD_(ID3DX11EffectRenderTargetViewVariable*, AsRenderTargetView)() override;
|
|
STDMETHOD_(ID3DX11EffectDepthStencilViewVariable*, AsDepthStencilView)() override;
|
|
STDMETHOD_(ID3DX11EffectConstantBuffer*, AsConstantBuffer)() override;
|
|
STDMETHOD_(ID3DX11EffectShaderVariable*, AsShader)() override;
|
|
STDMETHOD_(ID3DX11EffectBlendVariable*, AsBlend)() override;
|
|
STDMETHOD_(ID3DX11EffectDepthStencilVariable*, AsDepthStencil)() override;
|
|
STDMETHOD_(ID3DX11EffectRasterizerVariable*, AsRasterizer)() override;
|
|
STDMETHOD_(ID3DX11EffectSamplerVariable*, AsSampler)() override;
|
|
};
|
|
|
|
template<typename IBaseInterface>
|
|
ID3DX11EffectScalarVariable * TUncastableVariable<IBaseInterface>::AsScalar()
|
|
{
|
|
static LPCSTR pFuncName = "ID3DX11EffectVariable::AsScalar";
|
|
DPF(0, "%s: Invalid typecast", pFuncName);
|
|
return &g_InvalidScalarVariable;
|
|
}
|
|
|
|
template<typename IBaseInterface>
|
|
ID3DX11EffectVectorVariable * TUncastableVariable<IBaseInterface>::AsVector()
|
|
{
|
|
static LPCSTR pFuncName = "ID3DX11EffectVariable::AsVector";
|
|
DPF(0, "%s: Invalid typecast", pFuncName);
|
|
return &g_InvalidVectorVariable;
|
|
}
|
|
|
|
template<typename IBaseInterface>
|
|
ID3DX11EffectMatrixVariable * TUncastableVariable<IBaseInterface>::AsMatrix()
|
|
{
|
|
static LPCSTR pFuncName = "ID3DX11EffectVariable::AsMatrix";
|
|
DPF(0, "%s: Invalid typecast", pFuncName);
|
|
return &g_InvalidMatrixVariable;
|
|
}
|
|
|
|
template<typename IBaseInterface>
|
|
ID3DX11EffectStringVariable * TUncastableVariable<IBaseInterface>::AsString()
|
|
{
|
|
static LPCSTR pFuncName = "ID3DX11EffectVariable::AsString";
|
|
DPF(0, "%s: Invalid typecast", pFuncName);
|
|
return &g_InvalidStringVariable;
|
|
}
|
|
|
|
template<typename IBaseClassInstance>
|
|
ID3DX11EffectClassInstanceVariable * TUncastableVariable<IBaseClassInstance>::AsClassInstance()
|
|
{
|
|
static LPCSTR pFuncName = "ID3DX11EffectVariable::AsClassInstance";
|
|
DPF(0, "%s: Invalid typecast", pFuncName);
|
|
return &g_InvalidClassInstanceVariable;
|
|
}
|
|
|
|
template<typename IBaseInterface>
|
|
ID3DX11EffectInterfaceVariable * TUncastableVariable<IBaseInterface>::AsInterface()
|
|
{
|
|
static LPCSTR pFuncName = "ID3DX11EffectVariable::AsInterface";
|
|
DPF(0, "%s: Invalid typecast", pFuncName);
|
|
return &g_InvalidInterfaceVariable;
|
|
}
|
|
|
|
template<typename IBaseInterface>
|
|
ID3DX11EffectShaderResourceVariable * TUncastableVariable<IBaseInterface>::AsShaderResource()
|
|
{
|
|
static LPCSTR pFuncName = "ID3DX11EffectVariable::AsShaderResource";
|
|
DPF(0, "%s: Invalid typecast", pFuncName);
|
|
return &g_InvalidShaderResourceVariable;
|
|
}
|
|
|
|
template<typename IBaseInterface>
|
|
ID3DX11EffectUnorderedAccessViewVariable * TUncastableVariable<IBaseInterface>::AsUnorderedAccessView()
|
|
{
|
|
static LPCSTR pFuncName = "ID3DX11EffectVariable::AsUnorderedAccessView";
|
|
DPF(0, "%s: Invalid typecast", pFuncName);
|
|
return &g_InvalidUnorderedAccessViewVariable;
|
|
}
|
|
|
|
template<typename IBaseInterface>
|
|
ID3DX11EffectRenderTargetViewVariable * TUncastableVariable<IBaseInterface>::AsRenderTargetView()
|
|
{
|
|
static LPCSTR pFuncName = "ID3DX11EffectVariable::AsRenderTargetView";
|
|
DPF(0, "%s: Invalid typecast", pFuncName);
|
|
return &g_InvalidRenderTargetViewVariable;
|
|
}
|
|
|
|
template<typename IBaseInterface>
|
|
ID3DX11EffectDepthStencilViewVariable * TUncastableVariable<IBaseInterface>::AsDepthStencilView()
|
|
{
|
|
static LPCSTR pFuncName = "ID3DX11EffectVariable::AsDepthStencilView";
|
|
DPF(0, "%s: Invalid typecast", pFuncName);
|
|
return &g_InvalidDepthStencilViewVariable;
|
|
}
|
|
|
|
template<typename IBaseInterface>
|
|
ID3DX11EffectConstantBuffer * TUncastableVariable<IBaseInterface>::AsConstantBuffer()
|
|
{
|
|
static LPCSTR pFuncName = "ID3DX11EffectVariable::AsConstantBuffer";
|
|
DPF(0, "%s: Invalid typecast", pFuncName);
|
|
return &g_InvalidConstantBuffer;
|
|
}
|
|
|
|
template<typename IBaseInterface>
|
|
ID3DX11EffectShaderVariable * TUncastableVariable<IBaseInterface>::AsShader()
|
|
{
|
|
static LPCSTR pFuncName = "ID3DX11EffectVariable::AsShader";
|
|
DPF(0, "%s: Invalid typecast", pFuncName);
|
|
return &g_InvalidShaderVariable;
|
|
}
|
|
|
|
template<typename IBaseInterface>
|
|
ID3DX11EffectBlendVariable * TUncastableVariable<IBaseInterface>::AsBlend()
|
|
{
|
|
static LPCSTR pFuncName = "ID3DX11EffectVariable::AsBlend";
|
|
DPF(0, "%s: Invalid typecast", pFuncName);
|
|
return &g_InvalidBlendVariable;
|
|
}
|
|
|
|
template<typename IBaseInterface>
|
|
ID3DX11EffectDepthStencilVariable * TUncastableVariable<IBaseInterface>::AsDepthStencil()
|
|
{
|
|
static LPCSTR pFuncName = "ID3DX11EffectVariable::AsDepthStencil";
|
|
DPF(0, "%s: Invalid typecast", pFuncName);
|
|
return &g_InvalidDepthStencilVariable;
|
|
}
|
|
|
|
template<typename IBaseInterface>
|
|
ID3DX11EffectRasterizerVariable * TUncastableVariable<IBaseInterface>::AsRasterizer()
|
|
{
|
|
static LPCSTR pFuncName = "ID3DX11EffectVariable::AsRasterizer";
|
|
DPF(0, "%s: Invalid typecast", pFuncName);
|
|
return &g_InvalidRasterizerVariable;
|
|
}
|
|
|
|
template<typename IBaseInterface>
|
|
ID3DX11EffectSamplerVariable * TUncastableVariable<IBaseInterface>::AsSampler()
|
|
{
|
|
static LPCSTR pFuncName = "ID3DX11EffectVariable::AsSampler";
|
|
DPF(0, "%s: Invalid typecast", pFuncName);
|
|
return &g_InvalidSamplerVariable;
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
// Macros to instantiate the myriad templates
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
// generates a global variable, annotation, global variable member, and annotation member of each struct type
|
|
#define GenerateReflectionClasses(Type, BaseInterface) \
|
|
struct S##Type##GlobalVariable : public T##Type##Variable<TGlobalVariable<BaseInterface>, false> { IUNKNOWN_IMP(S##Type##GlobalVariable, BaseInterface, ID3DX11EffectVariable); }; \
|
|
struct S##Type##Annotation : public T##Type##Variable<TAnnotation<BaseInterface>, true> { IUNKNOWN_IMP(S##Type##Annotation, BaseInterface, ID3DX11EffectVariable);}; \
|
|
struct S##Type##GlobalVariableMember : public T##Type##Variable<TVariable<TMember<BaseInterface> >, false> { IUNKNOWN_IMP(S##Type##GlobalVariableMember, BaseInterface, ID3DX11EffectVariable); }; \
|
|
struct S##Type##AnnotationMember : public T##Type##Variable<TVariable<TMember<BaseInterface> >, true> { IUNKNOWN_IMP(S##Type##AnnotationMember, BaseInterface, ID3DX11EffectVariable); };
|
|
|
|
#define GenerateVectorReflectionClasses(Type, BaseType, BaseInterface) \
|
|
struct S##Type##GlobalVariable : public TVectorVariable<TGlobalVariable<BaseInterface>, false, BaseType> { IUNKNOWN_IMP(S##Type##GlobalVariable, BaseInterface, ID3DX11EffectVariable); }; \
|
|
struct S##Type##Annotation : public TVectorVariable<TAnnotation<BaseInterface>, true, BaseType> { IUNKNOWN_IMP(S##Type##Annotation, BaseInterface, ID3DX11EffectVariable);}; \
|
|
struct S##Type##GlobalVariableMember : public TVectorVariable<TVariable<TMember<BaseInterface> >, false, BaseType> { IUNKNOWN_IMP(S##Type##GlobalVariableMember, BaseInterface, ID3DX11EffectVariable);}; \
|
|
struct S##Type##AnnotationMember : public TVectorVariable<TVariable<TMember<BaseInterface> >, true, BaseType> { IUNKNOWN_IMP(S##Type##AnnotationMember, BaseInterface, ID3DX11EffectVariable);};
|
|
|
|
#define GenerateReflectionGlobalOnlyClasses(Type) \
|
|
struct S##Type##GlobalVariable : public T##Type##Variable<TGlobalVariable<ID3DX11Effect##Type##Variable> > { IUNKNOWN_IMP(S##Type##GlobalVariable, ID3DX11Effect##Type##Variable, ID3DX11EffectVariable); }; \
|
|
struct S##Type##GlobalVariableMember : public T##Type##Variable<TVariable<TMember<ID3DX11Effect##Type##Variable> > > { IUNKNOWN_IMP(S##Type##GlobalVariableMember, ID3DX11Effect##Type##Variable, ID3DX11EffectVariable); }; \
|
|
|
|
GenerateReflectionClasses(Numeric, ID3DX11EffectVariable);
|
|
GenerateReflectionClasses(FloatScalar, ID3DX11EffectScalarVariable);
|
|
GenerateReflectionClasses(IntScalar, ID3DX11EffectScalarVariable);
|
|
GenerateReflectionClasses(BoolScalar, ID3DX11EffectScalarVariable);
|
|
GenerateVectorReflectionClasses(FloatVector, ETVT_Float, ID3DX11EffectVectorVariable);
|
|
GenerateVectorReflectionClasses(BoolVector, ETVT_Bool, ID3DX11EffectVectorVariable);
|
|
GenerateVectorReflectionClasses(IntVector, ETVT_Int, ID3DX11EffectVectorVariable);
|
|
GenerateReflectionClasses(Matrix, ID3DX11EffectMatrixVariable);
|
|
GenerateReflectionClasses(String, ID3DX11EffectStringVariable);
|
|
GenerateReflectionGlobalOnlyClasses(ClassInstance);
|
|
GenerateReflectionGlobalOnlyClasses(Interface);
|
|
GenerateReflectionGlobalOnlyClasses(ShaderResource);
|
|
GenerateReflectionGlobalOnlyClasses(UnorderedAccessView);
|
|
GenerateReflectionGlobalOnlyClasses(RenderTargetView);
|
|
GenerateReflectionGlobalOnlyClasses(DepthStencilView);
|
|
GenerateReflectionGlobalOnlyClasses(Shader);
|
|
GenerateReflectionGlobalOnlyClasses(Blend);
|
|
GenerateReflectionGlobalOnlyClasses(DepthStencil);
|
|
GenerateReflectionGlobalOnlyClasses(Rasterizer);
|
|
GenerateReflectionGlobalOnlyClasses(Sampler);
|
|
|
|
// Optimized matrix classes
|
|
struct SMatrix4x4ColumnMajorGlobalVariable : public TMatrix4x4Variable<TGlobalVariable<ID3DX11EffectMatrixVariable>, true> { IUNKNOWN_IMP(SMatrix4x4ColumnMajorGlobalVariable, ID3DX11EffectMatrixVariable, ID3DX11EffectVariable); };
|
|
struct SMatrix4x4RowMajorGlobalVariable : public TMatrix4x4Variable<TGlobalVariable<ID3DX11EffectMatrixVariable>, false> { IUNKNOWN_IMP(SMatrix4x4RowMajorGlobalVariable, ID3DX11EffectMatrixVariable, ID3DX11EffectVariable); };
|
|
|
|
struct SMatrix4x4ColumnMajorGlobalVariableMember : public TMatrix4x4Variable<TVariable<TMember<ID3DX11EffectMatrixVariable> >, true> { IUNKNOWN_IMP(SMatrix4x4ColumnMajorGlobalVariableMember, ID3DX11EffectMatrixVariable, ID3DX11EffectVariable); };
|
|
struct SMatrix4x4RowMajorGlobalVariableMember : public TMatrix4x4Variable<TVariable<TMember<ID3DX11EffectMatrixVariable> >, false> { IUNKNOWN_IMP(SMatrix4x4RowMajorGlobalVariableMember, ID3DX11EffectMatrixVariable, ID3DX11EffectVariable); };
|
|
|
|
// Optimized vector classes
|
|
struct SFloatVector4GlobalVariable : public TVector4Variable<TGlobalVariable<ID3DX11EffectVectorVariable> > { IUNKNOWN_IMP(SFloatVector4GlobalVariable, ID3DX11EffectVectorVariable, ID3DX11EffectVariable); };
|
|
struct SFloatVector4GlobalVariableMember : public TVector4Variable<TVariable<TMember<ID3DX11EffectVectorVariable> > > { IUNKNOWN_IMP(SFloatVector4GlobalVariableMember, ID3DX11EffectVectorVariable, ID3DX11EffectVariable); };
|
|
|
|
// These 3 classes should never be used directly
|
|
|
|
// The "base" global variable struct (all global variables should be the same size in bytes,
|
|
// but we pick this as the default).
|
|
struct SGlobalVariable : public TGlobalVariable<ID3DX11EffectVariable>
|
|
{
|
|
|
|
};
|
|
|
|
// The "base" annotation struct (all annotations should be the same size in bytes,
|
|
// but we pick this as the default).
|
|
struct SAnnotation : public TAnnotation<ID3DX11EffectVariable>
|
|
{
|
|
|
|
};
|
|
|
|
// The "base" variable member struct (all annotation/global variable members should be the
|
|
// same size in bytes, but we pick this as the default).
|
|
struct SMember : public TVariable<TMember<ID3DX11EffectVariable> >
|
|
{
|
|
|
|
};
|
|
|
|
// creates a new variable of the appropriate polymorphic type where pVar was
|
|
HRESULT PlacementNewVariable(_In_ void *pVar, _In_ SType *pType, _In_ bool IsAnnotation);
|
|
SMember * CreateNewMember(_In_ SType *pType, _In_ bool IsAnnotation);
|
|
|
|
#pragma warning(pop)
|