//--------------------------------------------------------------------------------------
// File: EffectVariable.inl
//
// Direct3D 11 Effects Variable reflection template
// These templates define the many Effect variable types.
//
// THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF
// ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO
// THE IMPLIED WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A
// PARTICULAR PURPOSE.
//
// Copyright (c) Microsoft Corporation. All rights reserved.
//
// 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_ const 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_ const 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_ const 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;
        TTopLevelVariable<ID3DX11EffectVariable> *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;
        TTopLevelVariable<ID3DX11EffectVariable> *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;
        TTopLevelVariable<ID3DX11EffectVariable> *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";
        TTopLevelVariable<ID3DX11EffectVariable> *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() : 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()
    {
        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() :
        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_ const 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_ const 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_ const 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(const 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(const 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_ const 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_ const 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_ const 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(const 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(const 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_ const 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_ const 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_ const 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(const 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(const 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>((Offset + Count) * sizeof(CEffectVector4), pType->TotalSize));

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>((Offset + Count) * sizeof(CEffectVector4), pType->TotalSize));

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)
