Updated Shader Binding Table documentation

TheMostDiligent · TheMostDiligent · commit 1445dde3910d · 2025-04-12T13:14:35.000-07:00
diff --git a/Graphics/GraphicsEngine/include/ShaderResourceBindingBase.hpp b/Graphics/GraphicsEngine/include/ShaderResourceBindingBase.hpp
@@ -1,5 +1,5 @@
 /*
- *  Copyright 2019-2023 Diligent Graphics LLC
+ *  Copyright 2019-2025 Diligent Graphics LLC
  *  Copyright 2015-2019 Egor Yusov
  *
  *  Licensed under the Apache License, Version 2.0 (the "License");
@@ -42,6 +42,7 @@
 #include "GraphicsAccessories.hpp"
 #include "ShaderResourceCacheCommon.hpp"
 #include "FixedLinearAllocator.hpp"
+#include "SRBMemoryAllocator.hpp"
 #include "EngineMemory.h"
 
 namespace Diligent
@@ -79,12 +80,12 @@ class ShaderResourceBindingBase : public ObjectBase<typename EngineImplTraits::S
         {
             m_ActiveShaderStageIndex.fill(-1);
 
-            const auto NumShaders   = GetNumShaders();
-            const auto PipelineType = GetPipelineType();
+            const Uint32        NumShaders   = GetNumShaders();
+            const PIPELINE_TYPE PipelineType = GetPipelineType();
             for (Uint32 s = 0; s < NumShaders; ++s)
             {
-                const auto ShaderType = pPRS->GetActiveShaderStageType(s);
-                const auto ShaderInd  = GetShaderTypePipelineIndex(ShaderType, PipelineType);
+                const SHADER_TYPE ShaderType = pPRS->GetActiveShaderStageType(s);
+                const Int32       ShaderInd  = GetShaderTypePipelineIndex(ShaderType, PipelineType);
 
                 m_ActiveShaderStageIndex[ShaderInd] = static_cast<Int8>(s);
             }
@@ -98,7 +99,7 @@ class ShaderResourceBindingBase : public ObjectBase<typename EngineImplTraits::S
             m_pShaderVarMgrs = MemPool.ConstructArray<ShaderVariableManagerImplType>(NumShaders, std::ref(*this), std::ref(m_ShaderResourceCache));
 
             // The memory is now owned by ShaderResourceBindingBase and will be freed by Destruct().
-            auto* Ptr = MemPool.ReleaseOwnership();
+            void* Ptr = MemPool.ReleaseOwnership();
             VERIFY_EXPR(Ptr == m_pShaderVarMgrs);
             (void)Ptr;
 
@@ -107,15 +108,15 @@ class ShaderResourceBindingBase : public ObjectBase<typename EngineImplTraits::S
 
             pPRS->InitSRBResourceCache(m_ShaderResourceCache);
 
-            auto& SRBMemAllocator = pPRS->GetSRBMemoryAllocator();
+            SRBMemoryAllocator& SRBMemAllocator = pPRS->GetSRBMemoryAllocator();
             for (Uint32 s = 0; s < NumShaders; ++s)
             {
-                const auto ShaderType = pPRS->GetActiveShaderStageType(s);
-                const auto ShaderInd  = GetShaderTypePipelineIndex(ShaderType, pPRS->GetPipelineType());
-                const auto MgrInd     = m_ActiveShaderStageIndex[ShaderInd];
+                const SHADER_TYPE ShaderType = pPRS->GetActiveShaderStageType(s);
+                const Int32       ShaderInd  = GetShaderTypePipelineIndex(ShaderType, pPRS->GetPipelineType());
+                const int         MgrInd     = m_ActiveShaderStageIndex[ShaderInd];
                 VERIFY_EXPR(MgrInd >= 0 && MgrInd < static_cast<int>(NumShaders));
 
-                auto& VarDataAllocator = SRBMemAllocator.GetShaderVariableDataAllocator(s);
+                IMemoryAllocator& VarDataAllocator = SRBMemAllocator.GetShaderVariableDataAllocator(s);
 
                 // Initialize vars manager to reference mutable and dynamic variables
                 // Note that the cache has space for all variable types
@@ -178,16 +179,16 @@ class ShaderResourceBindingBase : public ObjectBase<typename EngineImplTraits::S
     /// Implementation of IShaderResourceBinding::GetVariableByName().
     virtual IShaderResourceVariable* DILIGENT_CALL_TYPE GetVariableByName(SHADER_TYPE ShaderType, const char* Name) override final
     {
-        const auto PipelineType = GetPipelineType();
+        const PIPELINE_TYPE PipelineType = GetPipelineType();
         if (!IsConsistentShaderType(ShaderType, PipelineType))
         {
             LOG_WARNING_MESSAGE("Unable to find mutable/dynamic variable '", Name, "' in shader stage ", GetShaderTypeLiteralName(ShaderType),
                                 " as the stage is invalid for ", GetPipelineTypeString(PipelineType), " pipeline resource signature '", m_pPRS->GetDesc().Name, "'.");
             return nullptr;
         }
 
-        const auto ShaderInd = GetShaderTypePipelineIndex(ShaderType, PipelineType);
-        const auto MgrInd    = m_ActiveShaderStageIndex[ShaderInd];
+        const Int32 ShaderInd = GetShaderTypePipelineIndex(ShaderType, PipelineType);
+        const int   MgrInd    = m_ActiveShaderStageIndex[ShaderInd];
         if (MgrInd < 0)
             return nullptr;
 
@@ -198,16 +199,16 @@ class ShaderResourceBindingBase : public ObjectBase<typename EngineImplTraits::S
     /// Implementation of IShaderResourceBinding::GetVariableCount().
     virtual Uint32 DILIGENT_CALL_TYPE GetVariableCount(SHADER_TYPE ShaderType) const override final
     {
-        const auto PipelineType = GetPipelineType();
+        const PIPELINE_TYPE PipelineType = GetPipelineType();
         if (!IsConsistentShaderType(ShaderType, PipelineType))
         {
             LOG_WARNING_MESSAGE("Unable to get the number of mutable/dynamic variables in shader stage ", GetShaderTypeLiteralName(ShaderType),
                                 " as the stage is invalid for ", GetPipelineTypeString(PipelineType), " pipeline resource signature '", m_pPRS->GetDesc().Name, "'.");
             return 0;
         }
 
-        const auto ShaderInd = GetShaderTypePipelineIndex(ShaderType, PipelineType);
-        const auto MgrInd    = m_ActiveShaderStageIndex[ShaderInd];
+        const Int32 ShaderInd = GetShaderTypePipelineIndex(ShaderType, PipelineType);
+        const int   MgrInd    = m_ActiveShaderStageIndex[ShaderInd];
         if (MgrInd < 0)
             return 0;
 
@@ -218,16 +219,16 @@ class ShaderResourceBindingBase : public ObjectBase<typename EngineImplTraits::S
     /// Implementation of IShaderResourceBinding::GetVariableByIndex().
     virtual IShaderResourceVariable* DILIGENT_CALL_TYPE GetVariableByIndex(SHADER_TYPE ShaderType, Uint32 Index) override final
     {
-        const auto PipelineType = GetPipelineType();
+        const PIPELINE_TYPE PipelineType = GetPipelineType();
         if (!IsConsistentShaderType(ShaderType, PipelineType))
         {
             LOG_WARNING_MESSAGE("Unable to get mutable/dynamic variable at index ", Index, " in shader stage ", GetShaderTypeLiteralName(ShaderType),
                                 " as the stage is invalid for ", GetPipelineTypeString(PipelineType), " pipeline resource signature '", m_pPRS->GetDesc().Name, "'.");
             return nullptr;
         }
 
-        const auto ShaderInd = GetShaderTypePipelineIndex(ShaderType, PipelineType);
-        const auto MgrInd    = m_ActiveShaderStageIndex[ShaderInd];
+        const Int32 ShaderInd = GetShaderTypePipelineIndex(ShaderType, PipelineType);
+        const int   MgrInd    = m_ActiveShaderStageIndex[ShaderInd];
         if (MgrInd < 0)
             return nullptr;
 
@@ -273,10 +274,10 @@ class ShaderResourceBindingBase : public ObjectBase<typename EngineImplTraits::S
     {
         if (m_pShaderVarMgrs != nullptr)
         {
-            auto& SRBMemAllocator = GetSignature()->GetSRBMemoryAllocator();
+            SRBMemoryAllocator& SRBMemAllocator = GetSignature()->GetSRBMemoryAllocator();
             for (Uint32 s = 0; s < GetNumShaders(); ++s)
             {
-                auto& VarDataAllocator = SRBMemAllocator.GetShaderVariableDataAllocator(s);
+                IMemoryAllocator& VarDataAllocator = SRBMemAllocator.GetShaderVariableDataAllocator(s);
                 m_pShaderVarMgrs[s].Destroy(VarDataAllocator);
                 m_pShaderVarMgrs[s].~ShaderVariableManagerImplType();
             }
@@ -288,15 +289,15 @@ class ShaderResourceBindingBase : public ObjectBase<typename EngineImplTraits::S
     void ProcessVariables(SHADER_TYPE   ShaderStages,
                           HandlerType&& Handler) const
     {
-        const auto PipelineType = GetPipelineType();
+        const PIPELINE_TYPE PipelineType = GetPipelineType();
         for (size_t ShaderInd = 0; ShaderInd < m_ActiveShaderStageIndex.size(); ++ShaderInd)
         {
-            const auto VarMngrInd = m_ActiveShaderStageIndex[ShaderInd];
+            const int VarMngrInd = m_ActiveShaderStageIndex[ShaderInd];
             if (VarMngrInd < 0)
                 continue;
 
             // ShaderInd is the shader type pipeline index here
-            const auto ShaderType = GetShaderTypeFromPipelineIndex(static_cast<Int32>(ShaderInd), PipelineType);
+            const SHADER_TYPE ShaderType = GetShaderTypeFromPipelineIndex(static_cast<Int32>(ShaderInd), PipelineType);
             if ((ShaderStages & ShaderType) == 0)
                 continue;
 
diff --git a/Graphics/GraphicsEngine/interface/ShaderResourceBinding.h b/Graphics/GraphicsEngine/interface/ShaderResourceBinding.h
@@ -1,5 +1,5 @@
 /*
- *  Copyright 2019-2023 Diligent Graphics LLC
+ *  Copyright 2019-2025 Diligent Graphics LLC
  *  Copyright 2015-2019 Egor Yusov
  *
  *  Licensed under the Apache License, Version 2.0 (the "License");
@@ -87,23 +87,23 @@ DILIGENT_BEGIN_INTERFACE(IShaderResourceBinding, IObject)
     ///
     /// \return     Variable type flags that did not pass the checks and thus may need to be updated.
     ///
-    /// \remarks    This method may be used to perform various checks of the currently bound resources:
+    /// This method may be used to perform various checks of the currently bound resources:
     ///
-    ///             - BIND_SHADER_RESOURCES_UPDATE_MUTABLE and BIND_SHADER_RESOURCES_UPDATE_DYNAMIC flags
-    ///               define which variable types to examine. Note that BIND_SHADER_RESOURCES_UPDATE_STATIC
-    ///               has no effect as static resources are accessed through the PSO.
+    /// - Diligent::BIND_SHADER_RESOURCES_UPDATE_MUTABLE and Diligent::BIND_SHADER_RESOURCES_UPDATE_DYNAMIC flags
+    ///   define which variable types to examine. Note that Diligent::BIND_SHADER_RESOURCES_UPDATE_STATIC
+    ///   has no effect as static resources are accessed through the PSO.
     ///
-    ///             - If BIND_SHADER_RESOURCES_KEEP_EXISTING flag is not set and pResMapping is not null,
-    ///               the method will compare currently bound resources with the ones in the resource mapping.
-    ///               If any mismatch is found, the method will return the types of the variables that
-    ///               contain mismatching resources.
-    ///               Note that the situation when non-null object is bound to the variable, but the resource
-    ///               mapping does not contain an object corresponding to the variable name, does not count as
-    ///               mismatch.
+    /// - If Diligent::BIND_SHADER_RESOURCES_KEEP_EXISTING flag is not set and pResMapping is not null,
+    ///   the method will compare currently bound resources with the ones in the resource mapping.
+    ///   If any mismatch is found, the method will return the types of the variables that
+    ///   contain mismatching resources.
+    ///   Note that the situation when non-null object is bound to the variable, but the resource
+    ///   mapping does not contain an object corresponding to the variable name, does not count as
+    ///   mismatch.
     ///
-    ///             - If BIND_SHADER_RESOURCES_VERIFY_ALL_RESOLVED flag is set, the method will check that
-    ///               all resources of the specified variable types are bound and return the types of the variables
-    ///               that are not bound.
+    /// - If Diligent::BIND_SHADER_RESOURCES_VERIFY_ALL_RESOLVED flag is set, the method will check that
+    ///   all resources of the specified variable types are bound and return the types of the variables
+    ///   that are not bound.
     VIRTUAL SHADER_RESOURCE_VARIABLE_TYPE_FLAGS METHOD(CheckResources)(
                                         THIS_
                                         SHADER_TYPE                 ShaderStages,
@@ -127,9 +127,11 @@ DILIGENT_BEGIN_INTERFACE(IShaderResourceBinding, IObject)
     /// Returns the total variable count for the specific shader stage.
 
     /// \param [in] ShaderType - Type of the shader.
-    /// \remark The method only counts mutable and dynamic variables that can be accessed through
-    ///         the Shader Resource Binding object. Static variables are accessed through the Shader
-    ///         object.
+    /// \return Total number of variables in the shader stage.
+    ///
+    /// The method only counts mutable and dynamic variables that can be accessed through
+    /// the Shader Resource Binding object. Static variables are accessed through the Shader
+    /// object.
     VIRTUAL Uint32 METHOD(GetVariableCount)(THIS_
                                             SHADER_TYPE ShaderType) CONST PURE;
 
@@ -140,8 +142,9 @@ DILIGENT_BEGIN_INTERFACE(IShaderResourceBinding, IObject)
     /// \param [in] Index      - Variable index. The index must be between 0 and the total number
     ///                          of variables in this shader stage as returned by
     ///                          IShaderResourceBinding::GetVariableCount().
-    /// \remark Only mutable and dynamic variables can be accessed through this method.
-    ///         Static variables are accessed through the Shader object.
+    ///
+    /// Only mutable and dynamic variables can be accessed through this method.
+    /// Static variables are accessed through the Shader object.
     ///
     /// \note   This operation may potentially be expensive. If the variable will be used often, it is
     ///         recommended to store and reuse the pointer as it never changes.
