Some improvements D3D shader resource management

3 files changed, 69 insertions, 86 deletions

diff --git a/Graphics/GraphicsEngineD3DBase/include/D3DShaderResourceLoader.h b/Graphics/GraphicsEngineD3DBase/include/D3DShaderResourceLoader.h
index c053d39e..346917ea 100644
--- a/Graphics/GraphicsEngineD3DBase/include/D3DShaderResourceLoader.h
+++ b/Graphics/GraphicsEngineD3DBase/include/D3DShaderResourceLoader.h
@@ -35,6 +35,16 @@
 
 namespace Diligent
 {
+    struct D3DShaderResourceCounters
+    {
+        Uint32 NumCBs      = 0;
+        Uint32 NumTexSRVs  = 0;
+        Uint32 NumTexUAVs  = 0; 
+        Uint32 NumBufSRVs  = 0;
+        Uint32 NumBufUAVs  = 0;
+        Uint32 NumSamplers = 0;
+    };
+
     template<typename D3D_SHADER_DESC, 
              typename D3D_SHADER_INPUT_BIND_DESC,
              typename TShaderReflection, 
@@ -72,7 +82,7 @@ namespace Diligent
         
         const bool UseCombinedTextureSamplers = SamplerSuffix != nullptr;
 
-        Uint32 NumCBs = 0, NumTexSRVs = 0, NumTexUAVs = 0, NumBufSRVs = 0, NumBufUAVs = 0, NumSamplers = 0;
+        D3DShaderResourceCounters RC;
         size_t ResourceNamesPoolSize = 0;
         // Number of resources to skip (used for array resources)
         UINT SkipCount = 1;
@@ -174,18 +184,18 @@ namespace Diligent
 
             switch( BindingDesc.Type )
             {
-                case D3D_SIT_CBUFFER:                       ++NumCBs;                                                                        break;
-                case D3D_SIT_TBUFFER:                       UNSUPPORTED( "TBuffers are not supported" );                                     break;
-                case D3D_SIT_TEXTURE:                       ++(BindingDesc.Dimension == D3D_SRV_DIMENSION_BUFFER ? NumBufSRVs : NumTexSRVs); break;
-                case D3D_SIT_SAMPLER:                       ++NumSamplers;                                                                   break;
-                case D3D_SIT_UAV_RWTYPED:                   ++(BindingDesc.Dimension == D3D_SRV_DIMENSION_BUFFER ? NumBufUAVs : NumTexUAVs); break;
-                case D3D_SIT_STRUCTURED:                    ++NumBufSRVs;                                                                    break;
-                case D3D_SIT_UAV_RWSTRUCTURED:              ++NumBufUAVs;                                                                    break;
-                case D3D_SIT_BYTEADDRESS:                   ++NumBufSRVs;                                                                    break;
-                case D3D_SIT_UAV_RWBYTEADDRESS:             ++NumBufUAVs;                                                                    break;
-                case D3D_SIT_UAV_APPEND_STRUCTURED:         UNSUPPORTED( "Append structured buffers are not supported" );                    break;
-                case D3D_SIT_UAV_CONSUME_STRUCTURED:        UNSUPPORTED( "Consume structured buffers are not supported" );                   break;
-                case D3D_SIT_UAV_RWSTRUCTURED_WITH_COUNTER: UNSUPPORTED( "RW structured buffers with counter are not supported" );           break;
+                case D3D_SIT_CBUFFER:                       ++RC.NumCBs;                                                                           break;
+                case D3D_SIT_TBUFFER:                       UNSUPPORTED( "TBuffers are not supported" );                                           break;
+                case D3D_SIT_TEXTURE:                       ++(BindingDesc.Dimension == D3D_SRV_DIMENSION_BUFFER ? RC.NumBufSRVs : RC.NumTexSRVs); break;
+                case D3D_SIT_SAMPLER:                       ++RC.NumSamplers;                                                                      break;
+                case D3D_SIT_UAV_RWTYPED:                   ++(BindingDesc.Dimension == D3D_SRV_DIMENSION_BUFFER ? RC.NumBufUAVs : RC.NumTexUAVs); break;
+                case D3D_SIT_STRUCTURED:                    ++RC.NumBufSRVs;                                                                       break;
+                case D3D_SIT_UAV_RWSTRUCTURED:              ++RC.NumBufUAVs;                                                                       break;
+                case D3D_SIT_BYTEADDRESS:                   ++RC.NumBufSRVs;                                                                       break;
+                case D3D_SIT_UAV_RWBYTEADDRESS:             ++RC.NumBufUAVs;                                                                       break;
+                case D3D_SIT_UAV_APPEND_STRUCTURED:         UNSUPPORTED( "Append structured buffers are not supported" );                          break;
+                case D3D_SIT_UAV_CONSUME_STRUCTURED:        UNSUPPORTED( "Consume structured buffers are not supported" );                         break;
+                case D3D_SIT_UAV_RWSTRUCTURED_WITH_COUNTER: UNSUPPORTED( "RW structured buffers with counter are not supported" );                 break;
                 default: UNEXPECTED("Unexpected resource type");
             }
             ResourceNamesPoolSize += Name.length() + 1;
@@ -251,10 +261,10 @@ namespace Diligent
         }
 #endif
 
-        OnResourcesCounted(NumCBs, NumTexSRVs, NumTexUAVs, NumBufSRVs, NumBufUAVs, NumSamplers, ResourceNamesPoolSize);
+        OnResourcesCounted(RC, ResourceNamesPoolSize);
 
         std::vector<size_t, STDAllocatorRawMem<size_t> > TexSRVInds( STD_ALLOCATOR_RAW_MEM(size_t, GetRawAllocator(), "Allocator for vector<size_t>") );
-        TexSRVInds.reserve(NumTexSRVs);
+        TexSRVInds.reserve(RC.NumTexSRVs);
 
         for(size_t ResInd = 0; ResInd < Resources.size(); ++ResInd)
         {
diff --git a/Graphics/GraphicsEngineD3DBase/include/ShaderResources.h b/Graphics/GraphicsEngineD3DBase/include/ShaderResources.h
index ec016324..b13e5e18 100644
--- a/Graphics/GraphicsEngineD3DBase/include/ShaderResources.h
+++ b/Graphics/GraphicsEngineD3DBase/include/ShaderResources.h
@@ -316,15 +316,8 @@ public:
     const D3DShaderResourceAttribs& GetBufUAV (Uint32 n)const noexcept{ return GetResAttribs(n, GetNumBufUAV(),   m_BufUAVOffset); }
     const D3DShaderResourceAttribs& GetSampler(Uint32 n)const noexcept{ return GetResAttribs(n, GetNumSamplers(), m_SamplersOffset); }
 
-    
-    void CountResources(const SHADER_VARIABLE_TYPE* AllowedVarTypes,
-                        Uint32                      NumAllowedTypes, 
-                        Uint32&                     NumCBs,
-                        Uint32&                     NumTexSRVs,
-                        Uint32&                     NumTexUAVs, 
-                        Uint32&                     NumBufSRVs,
-                        Uint32&                     NumBufUAVs,
-                        Uint32&                     NumSamplers)const noexcept;
+    D3DShaderResourceCounters CountResources(const SHADER_VARIABLE_TYPE* AllowedVarTypes,
+                                             Uint32                      NumAllowedTypes)const noexcept;
 
     SHADER_TYPE GetShaderType()const noexcept{return m_ShaderType;}
 
@@ -428,14 +421,9 @@ protected:
     D3DShaderResourceAttribs& GetSampler(Uint32 n)noexcept{ return GetResAttribs(n, GetNumSamplers(), m_SamplersOffset); }
 
 private:
-    void AllocateMemory(IMemoryAllocator& Allocator, 
-                        Uint32            NumCBs, 
-                        Uint32            NumTexSRVs, 
-                        Uint32            NumTexUAVs, 
-                        Uint32            NumBufSRVs, 
-                        Uint32            NumBufUAVs, 
-                        Uint32            NumSamplers,
-                        size_t            ResourceNamesPoolSize);
+    void AllocateMemory(IMemoryAllocator&                Allocator, 
+                        const D3DShaderResourceCounters& ResCounters,
+                        size_t                           ResourceNamesPoolSize);
 
     Uint32 FindAssignedSamplerId(const D3DShaderResourceAttribs& TexSRV, const char* SamplerSuffix)const;
 
@@ -472,12 +460,12 @@ void ShaderResources::Initialize(ID3DBlob*           pShaderByteCode,
     LoadD3DShaderResources<D3D_SHADER_DESC, D3D_SHADER_INPUT_BIND_DESC, TShaderReflection>(
         pShaderByteCode,
 
-        [&](Uint32 NumCBs, Uint32 NumTexSRVs, Uint32 NumTexUAVs, Uint32 NumBufSRVs, Uint32 NumBufUAVs, Uint32 NumSamplers, size_t ResourceNamesPoolSize)
+        [&](const D3DShaderResourceCounters& ResCounters, size_t ResourceNamesPoolSize)
         {
             if (CombinedSamplerSuffix != nullptr)
                 ResourceNamesPoolSize += strlen(CombinedSamplerSuffix)+1;
 
-            AllocateMemory(GetRawAllocator(), NumCBs, NumTexSRVs, NumTexUAVs, NumBufSRVs, NumBufUAVs, NumSamplers, ResourceNamesPoolSize);
+            AllocateMemory(GetRawAllocator(), ResCounters, ResourceNamesPoolSize);
         },
 
         [&](const D3DShaderResourceAttribs& CBAttribs)
diff --git a/Graphics/GraphicsEngineD3DBase/src/ShaderResources.cpp b/Graphics/GraphicsEngineD3DBase/src/ShaderResources.cpp
index 52527697..5b2b2d4e 100644
--- a/Graphics/GraphicsEngineD3DBase/src/ShaderResources.cpp
+++ b/Graphics/GraphicsEngineD3DBase/src/ShaderResources.cpp
@@ -51,42 +51,36 @@ ShaderResources::~ShaderResources()
         GetSampler(n).~D3DShaderResourceAttribs();
 }
 
-void ShaderResources::AllocateMemory(IMemoryAllocator& Allocator, 
-                                     Uint32            NumCBs, 
-                                     Uint32            NumTexSRVs, 
-                                     Uint32            NumTexUAVs, 
-                                     Uint32            NumBufSRVs, 
-                                     Uint32            NumBufUAVs, 
-                                     Uint32            NumSamplers,
-                                     size_t            ResourceNamesPoolSize)
+void ShaderResources::AllocateMemory(IMemoryAllocator&                Allocator, 
+                                     const D3DShaderResourceCounters& ResCounters,
+                                     size_t                           ResourceNamesPoolSize)
 {
-    const auto MaxOffset = static_cast<Uint32>(std::numeric_limits<OffsetType>::max());
-    VERIFY(NumCBs <= MaxOffset, "Max offset exceeded");
-    m_TexSRVOffset    = 0                + static_cast<OffsetType>(NumCBs);
-
-    VERIFY(m_TexSRVOffset   + NumTexSRVs <= MaxOffset, "Max offset exceeded");
-    m_TexUAVOffset    = m_TexSRVOffset   + static_cast<OffsetType>(NumTexSRVs);
-
-    VERIFY(m_TexUAVOffset   + NumTexUAVs <= MaxOffset, "Max offset exceeded");
-    m_BufSRVOffset    = m_TexUAVOffset   + static_cast<OffsetType>(NumTexUAVs);
-
-    VERIFY(m_BufSRVOffset   + NumBufSRVs <= MaxOffset, "Max offset exceeded");
-    m_BufUAVOffset    = m_BufSRVOffset   + static_cast<OffsetType>(NumBufSRVs);
-
-    VERIFY(m_BufUAVOffset   + NumBufUAVs <= MaxOffset, "Max offset exceeded");
-    m_SamplersOffset  = m_BufUAVOffset   + static_cast<OffsetType>(NumBufUAVs);
-
-    VERIFY(m_SamplersOffset + NumSamplers<= MaxOffset, "Max offset exceeded");
-    m_TotalResources = m_SamplersOffset + static_cast<OffsetType>(NumSamplers);
+    Uint32 CurrentOffset = 0;
+    auto AdvanceOffset = [&CurrentOffset](Uint32 NumResources)
+    {
+        constexpr Uint32 MaxOffset = std::numeric_limits<OffsetType>::max();
+        VERIFY(CurrentOffset <= MaxOffset, "Current offser (", CurrentOffset, ") exceeds max allowed value (", MaxOffset, ")");
+        auto Offset = static_cast<OffsetType>(CurrentOffset);
+        CurrentOffset += NumResources;
+        return Offset;
+    };
+
+    auto CBOffset    = AdvanceOffset(ResCounters.NumCBs);       CBOffset; // To suppress warning
+    m_TexSRVOffset   = AdvanceOffset(ResCounters.NumTexSRVs);
+    m_TexUAVOffset   = AdvanceOffset(ResCounters.NumTexUAVs);
+    m_BufSRVOffset   = AdvanceOffset(ResCounters.NumBufSRVs);
+    m_BufUAVOffset   = AdvanceOffset(ResCounters.NumBufUAVs);
+    m_SamplersOffset = AdvanceOffset(ResCounters.NumSamplers);
+    m_TotalResources = AdvanceOffset(0);
 
     auto MemorySize = m_TotalResources * sizeof(D3DShaderResourceAttribs) + ResourceNamesPoolSize * sizeof(char);
 
-    VERIFY_EXPR(GetNumCBs()     == NumCBs);
-    VERIFY_EXPR(GetNumTexSRV()  == NumTexSRVs);
-    VERIFY_EXPR(GetNumTexUAV()  == NumTexUAVs);
-    VERIFY_EXPR(GetNumBufSRV()  == NumBufSRVs);
-    VERIFY_EXPR(GetNumBufUAV()  == NumBufUAVs);
-    VERIFY_EXPR(GetNumSamplers()== NumSamplers);
+    VERIFY_EXPR(GetNumCBs()     == ResCounters.NumCBs);
+    VERIFY_EXPR(GetNumTexSRV()  == ResCounters.NumTexSRVs);
+    VERIFY_EXPR(GetNumTexUAV()  == ResCounters.NumTexUAVs);
+    VERIFY_EXPR(GetNumBufSRV()  == ResCounters.NumBufSRVs);
+    VERIFY_EXPR(GetNumBufUAV()  == ResCounters.NumBufUAVs);
+    VERIFY_EXPR(GetNumSamplers()== ResCounters.NumSamplers);
 
     if( MemorySize )
     {
@@ -102,59 +96,50 @@ ShaderResources::ShaderResources(SHADER_TYPE ShaderType):
 {
 }
 
-void ShaderResources::CountResources(const SHADER_VARIABLE_TYPE* AllowedVarTypes,
-                                     Uint32                      NumAllowedTypes, 
-                                     Uint32&                     NumCBs, 
-                                     Uint32&                     NumTexSRVs,
-                                     Uint32&                     NumTexUAVs, 
-                                     Uint32&                     NumBufSRVs,
-                                     Uint32&                     NumBufUAVs,
-                                     Uint32&                     NumSamplers)const noexcept
+D3DShaderResourceCounters ShaderResources::CountResources(const SHADER_VARIABLE_TYPE* AllowedVarTypes,
+                                                          Uint32                      NumAllowedTypes)const noexcept
 {
     auto AllowedTypeBits = GetAllowedTypeBits(AllowedVarTypes, NumAllowedTypes);
 
-    NumCBs = 0;
-    NumTexSRVs = 0;
-    NumTexUAVs = 0;
-    NumBufSRVs = 0;
-    NumBufUAVs = 0;
-    NumSamplers = 0;
+    D3DShaderResourceCounters Counters;
     ProcessResources(
         AllowedVarTypes, NumAllowedTypes,
 
         [&](const D3DShaderResourceAttribs& CB, Uint32)
         {
             VERIFY_EXPR(CB.IsAllowedType(AllowedTypeBits));
-            ++NumCBs;
+            ++Counters.NumCBs;
         },
         [&](const D3DShaderResourceAttribs& Sam, Uint32)
         {
             VERIFY_EXPR(Sam.IsAllowedType(AllowedTypeBits));
             // Skip static samplers
             if (!Sam.IsStaticSampler())
-                ++NumSamplers;
+                ++Counters.NumSamplers;
         },
         [&](const D3DShaderResourceAttribs& TexSRV, Uint32)
         {
             VERIFY_EXPR(TexSRV.IsAllowedType(AllowedTypeBits));
-            ++NumTexSRVs;
+            ++Counters.NumTexSRVs;
         },
         [&](const D3DShaderResourceAttribs& TexUAV, Uint32)
         {
             VERIFY_EXPR(TexUAV.IsAllowedType(AllowedTypeBits));
-            ++NumTexUAVs;
+            ++Counters.NumTexUAVs;
         },
         [&](const D3DShaderResourceAttribs& BufSRV, Uint32)
         {
             VERIFY_EXPR(BufSRV.IsAllowedType(AllowedTypeBits));
-            ++NumBufSRVs;
+            ++Counters.NumBufSRVs;
         },
         [&](const D3DShaderResourceAttribs& BufUAV, Uint32)
         {
             VERIFY_EXPR(BufUAV.IsAllowedType(AllowedTypeBits));
-            ++NumBufUAVs;
+            ++Counters.NumBufUAVs;
         }
     );
+
+    return Counters;
 }