D3D12/RootParamsManager: add support for root constants (#672)

TheMostDiligent · TheMostDiligent · commit aea9cac00be6 · 2025-10-19T12:50:34.000-07:00
diff --git a/Graphics/GraphicsEngineD3D12/include/PipelineResourceSignatureD3D12Impl.hpp b/Graphics/GraphicsEngineD3D12/include/PipelineResourceSignatureD3D12Impl.hpp
@@ -125,7 +125,7 @@ class PipelineResourceSignatureD3D12Impl final : public PipelineResourceSignatur
 
     Uint32 GetTotalRootParamsCount() const
     {
-        return m_RootParams.GetNumRootTables() + m_RootParams.GetNumRootViews();
+        return m_RootParams.GetNumRootTables() + m_RootParams.GetNumRootViews() + m_RootParams.GetNumRootConstants();
     }
 
     Uint32 GetNumRootTables() const
@@ -138,6 +138,11 @@ class PipelineResourceSignatureD3D12Impl final : public PipelineResourceSignatur
         return m_RootParams.GetNumRootViews();
     }
 
+    Uint32 GetNumRootConstants() const
+    {
+        return m_RootParams.GetNumRootConstants();
+    }
+
     void InitSRBResourceCache(ShaderResourceCacheD3D12& ResourceCache);
 
     void CopyStaticResources(ShaderResourceCacheD3D12& ResourceCache) const;
diff --git a/Graphics/GraphicsEngineD3D12/include/RootParamsManager.hpp b/Graphics/GraphicsEngineD3D12/include/RootParamsManager.hpp
@@ -139,6 +139,7 @@ class RootParamsManager
 
     Uint32 GetNumRootTables() const { return m_NumRootTables; }
     Uint32 GetNumRootViews() const { return m_NumRootViews; }
+    Uint32 GetNumRootConstants() const { return m_NumRootConstants; }
 
     const RootParameter& GetRootTable(Uint32 TableInd) const
     {
@@ -152,6 +153,12 @@ class RootParamsManager
         return m_pRootViews[ViewInd];
     }
 
+    const RootParameter& GetRootConstants(Uint32 ConstInd) const
+    {
+        VERIFY_EXPR(ConstInd < m_NumRootConstants);
+        return m_pRootConstants[ConstInd];
+    }
+
     // Returns the total number of resources in a given parameter group and descriptor heap type
     Uint32 GetParameterGroupSize(D3D12_DESCRIPTOR_HEAP_TYPE d3d12HeapType, ROOT_PARAMETER_GROUP Group) const
     {
@@ -169,11 +176,18 @@ class RootParamsManager
 
     std::unique_ptr<void, STDDeleter<void, IMemoryAllocator>> m_pMemory;
 
+    // The number of root tables
     Uint32 m_NumRootTables = 0;
-    Uint32 m_NumRootViews  = 0;
 
-    const RootParameter* m_pRootTables = nullptr;
-    const RootParameter* m_pRootViews  = nullptr;
+    // The number of root views
+    Uint32 m_NumRootViews = 0;
+
+    // The number of root constant parameters (not the number of 32-bit constants)
+    Uint32 m_NumRootConstants = 0;
+
+    const RootParameter* m_pRootTables    = nullptr;
+    const RootParameter* m_pRootViews     = nullptr;
+    const RootParameter* m_pRootConstants = nullptr;
 
     // The total number of resources placed in descriptor tables for each heap type and parameter group type
     std::array<std::array<Uint32, ROOT_PARAMETER_GROUP_COUNT>, D3D12_DESCRIPTOR_HEAP_TYPE_SAMPLER + 1> m_ParameterGroupSizes{};
@@ -206,6 +220,14 @@ class RootParamsBuilder
                                D3D12_SHADER_VISIBILITY   Visibility,
                                ROOT_PARAMETER_GROUP      RootType);
 
+    // Adds a new root constants parameter and returns the reference to it.
+    RootParameter& AddRootConstants(Uint32                  RootIndex,
+                                    UINT                    Register,
+                                    UINT                    RegisterSpace,
+                                    UINT                    Num32BitValues,
+                                    D3D12_SHADER_VISIBILITY Visibility,
+                                    ROOT_PARAMETER_GROUP    RootType);
+
     struct RootTableData;
     // Adds a new root table parameter and returns the reference to it.
     RootTableData& AddRootTable(Uint32                  RootIndex,
@@ -214,6 +236,10 @@ class RootParamsBuilder
                                 Uint32                  NumRangesInNewTable = 1);
 
 
+#ifdef DILIGENT_DEBUG
+    void DbgCheckRootIndexUniqueness(Uint32 RootIndex) const;
+#endif
+
 private:
     struct RootTableData
     {
@@ -231,6 +257,7 @@ class RootParamsBuilder
     };
     std::vector<RootTableData> m_RootTables;
     std::vector<RootParameter> m_RootViews;
+    std::vector<RootParameter> m_RootConstants;
 
     static constexpr int InvalidRootTableIndex = -1;
 
diff --git a/Graphics/GraphicsEngineD3D12/src/RootParamsManager.cpp b/Graphics/GraphicsEngineD3D12/src/RootParamsManager.cpp
@@ -144,13 +144,14 @@ size_t RootParameter::GetHash() const
 
 RootParamsManager::~RootParamsManager()
 {
-    static_assert(std::is_trivially_destructible<RootParameter>::value, "Destructors for m_pRootTables and m_pRootViews are required");
+    static_assert(std::is_trivially_destructible<RootParameter>::value, "m_pRootTables, m_pRootViews and m_pRootConstants must be manually destroyed");
 }
 
 bool RootParamsManager::operator==(const RootParamsManager& RootParams) const noexcept
 {
     if (m_NumRootTables != RootParams.m_NumRootTables ||
-        m_NumRootViews != RootParams.m_NumRootViews)
+        m_NumRootViews != RootParams.m_NumRootViews ||
+        m_NumRootConstants != RootParams.m_NumRootConstants)
         return false;
 
     for (Uint32 rv = 0; rv < m_NumRootViews; ++rv)
@@ -169,6 +170,14 @@ bool RootParamsManager::operator==(const RootParamsManager& RootParams) const no
             return false;
     }
 
+    for (Uint32 rc = 0; rc < m_NumRootConstants; ++rc)
+    {
+        const RootParameter& RC0 = GetRootConstants(rc);
+        const RootParameter& RC1 = RootParams.GetRootConstants(rc);
+        if (RC0 != RC1)
+            return false;
+    }
+
     return true;
 }
 
@@ -230,6 +239,13 @@ void RootParamsManager::Validate() const
         VERIFY(RootView.TableOffsetInGroupAllocation == RootParameter::InvalidTableOffsetInGroupAllocation,
                "Root views must not be assigned to descriptor table allocations.");
     }
+
+    for (Uint32 i = 0; i < GetNumRootConstants(); ++i)
+    {
+        const RootParameter& RootConst = GetRootConstants(i);
+        VERIFY(RootConst.TableOffsetInGroupAllocation == RootParameter::InvalidTableOffsetInGroupAllocation,
+               "Root constants must not be assigned to descriptor table allocations.");
+    }
 }
 #endif
 
@@ -243,6 +259,18 @@ RootParamsBuilder::RootParamsBuilder()
         Map.fill(InvalidRootTableIndex);
 }
 
+#ifdef DILIGENT_DEBUG
+void RootParamsBuilder::DbgCheckRootIndexUniqueness(Uint32 RootIndex) const
+{
+    for (const RootTableData& RootTbl : m_RootTables)
+        VERIFY(RootTbl.RootIndex != RootIndex, "Index ", RootIndex, " is already used by another root table");
+    for (const RootParameter& RootView : m_RootViews)
+        VERIFY(RootView.RootIndex != RootIndex, "Index ", RootIndex, " is already used by another root view");
+    for (const RootParameter& RootConst : m_RootConstants)
+        VERIFY(RootConst.RootIndex != RootIndex, "Index ", RootIndex, " is already used by another root constant");
+}
+#endif
+
 RootParameter& RootParamsBuilder::AddRootView(D3D12_ROOT_PARAMETER_TYPE ParameterType,
                                               Uint32                    RootIndex,
                                               UINT                      Register,
@@ -255,11 +283,7 @@ RootParameter& RootParamsBuilder::AddRootView(D3D12_ROOT_PARAMETER_TYPE Paramete
             ParameterType == D3D12_ROOT_PARAMETER_TYPE_SRV ||
             ParameterType == D3D12_ROOT_PARAMETER_TYPE_UAV),
            "Unexpected parameter type SBV, SRV or UAV is expected");
-
-    for (const RootTableData& RootTbl : m_RootTables)
-        VERIFY(RootTbl.RootIndex != RootIndex, "Index ", RootIndex, " is already used by another root table");
-    for (const RootParameter& RootView : m_RootViews)
-        VERIFY(RootView.RootIndex != RootIndex, "Index ", RootIndex, " is already used by another root view");
+    DbgCheckRootIndexUniqueness(RootIndex);
 #endif
 
     D3D12_ROOT_PARAMETER d3d12RootParam{ParameterType, {}, Visibility};
@@ -270,6 +294,26 @@ RootParameter& RootParamsBuilder::AddRootView(D3D12_ROOT_PARAMETER_TYPE Paramete
     return m_RootViews.back();
 }
 
+RootParameter& RootParamsBuilder::AddRootConstants(Uint32                  RootIndex,
+                                                   UINT                    Register,
+                                                   UINT                    RegisterSpace,
+                                                   UINT                    Num32BitValues,
+                                                   D3D12_SHADER_VISIBILITY Visibility,
+                                                   ROOT_PARAMETER_GROUP    RootType)
+{
+#ifdef DILIGENT_DEBUG
+    DbgCheckRootIndexUniqueness(RootIndex);
+#endif
+
+    D3D12_ROOT_PARAMETER d3d12RootParam{D3D12_ROOT_PARAMETER_TYPE_32BIT_CONSTANTS, {}, Visibility};
+    d3d12RootParam.Constants.ShaderRegister = Register;
+    d3d12RootParam.Constants.RegisterSpace  = RegisterSpace;
+    d3d12RootParam.Constants.Num32BitValues = Num32BitValues;
+    m_RootConstants.emplace_back(RootIndex, RootType, d3d12RootParam);
+
+    return m_RootConstants.back();
+}
+
 RootParamsBuilder::RootTableData::RootTableData(Uint32                  _RootIndex,
                                                 D3D12_SHADER_VISIBILITY _Visibility,
                                                 ROOT_PARAMETER_GROUP    _Group,
@@ -305,10 +349,7 @@ RootParamsBuilder::RootTableData& RootParamsBuilder::AddRootTable(Uint32
                                                                   Uint32                  NumRangesInNewTable)
 {
 #ifdef DILIGENT_DEBUG
-    for (const RootTableData& RootTbl : m_RootTables)
-        VERIFY(RootTbl.RootIndex != RootIndex, "Index ", RootIndex, " is already used by another root table");
-    for (const RootParameter& RootView : m_RootViews)
-        VERIFY(RootView.RootIndex != RootIndex, "Index ", RootIndex, " is already used by another root view");
+    DbgCheckRootIndexUniqueness(RootIndex);
 #endif
 
     m_RootTables.emplace_back(RootIndex, Visibility, Group, NumRangesInNewTable);
@@ -330,8 +371,8 @@ void RootParamsBuilder::AllocateResourceSlot(SHADER_TYPE                   Shade
     const D3D12_SHADER_VISIBILITY ShaderVisibility = ShaderStagesToD3D12ShaderVisibility(ShaderStages);
     const ROOT_PARAMETER_GROUP    ParameterGroup   = VariableTypeToRootParameterGroup(VariableType);
 
-    // Get the next available root index past all allocated tables and root views
-    RootIndex = static_cast<Uint32>(m_RootTables.size() + m_RootViews.size());
+    // Get the next available root index past all allocated tables, root views and root constants
+    RootIndex = static_cast<Uint32>(m_RootTables.size() + m_RootViews.size() + m_RootConstants.size());
 
     if (RootParameterType == D3D12_ROOT_PARAMETER_TYPE_CBV ||
         RootParameterType == D3D12_ROOT_PARAMETER_TYPE_SRV ||
@@ -345,6 +386,13 @@ void RootParamsBuilder::AllocateResourceSlot(SHADER_TYPE                   Shade
         // Add new root view to existing root parameters
         AddRootView(RootParameterType, RootIndex, Register, Space, ShaderVisibility, ParameterGroup);
     }
+    else if (RootParameterType == D3D12_ROOT_PARAMETER_TYPE_32BIT_CONSTANTS)
+    {
+        OffsetFromTableStart = 0;
+
+        // Add new 32-bit constants parameter to existing root parameters
+        AddRootConstants(RootIndex, Register, Space, ArraySize, ShaderVisibility, ParameterGroup);
+    }
     else if (RootParameterType == D3D12_ROOT_PARAMETER_TYPE_DESCRIPTOR_TABLE)
     {
         const bool IsSampler = (RangeType == D3D12_DESCRIPTOR_RANGE_TYPE_SAMPLER);
@@ -406,15 +454,17 @@ void RootParamsBuilder::InitializeMgr(IMemoryAllocator& MemAllocator, RootParams
 {
     VERIFY(!ParamsMgr.m_pMemory, "Params manager has already been initialized!");
 
-    Uint32& NumRootTables = ParamsMgr.m_NumRootTables;
-    Uint32& NumRootViews  = ParamsMgr.m_NumRootViews;
+    Uint32& NumRootTables    = ParamsMgr.m_NumRootTables;
+    Uint32& NumRootViews     = ParamsMgr.m_NumRootViews;
+    Uint32& NumRootConstants = ParamsMgr.m_NumRootConstants;
 
-    NumRootTables = static_cast<Uint32>(m_RootTables.size());
-    NumRootViews  = static_cast<Uint32>(m_RootViews.size());
-    if (NumRootTables == 0 && NumRootViews == 0)
+    NumRootTables    = static_cast<Uint32>(m_RootTables.size());
+    NumRootViews     = static_cast<Uint32>(m_RootViews.size());
+    NumRootConstants = static_cast<Uint32>(m_RootConstants.size());
+    if (NumRootTables == 0 && NumRootViews == 0 && NumRootConstants == 0)
         return;
 
-    const size_t TotalRootParamsCount = m_RootTables.size() + m_RootViews.size();
+    const size_t TotalRootParamsCount = m_RootTables.size() + m_RootViews.size() + m_RootConstants.size();
 
     size_t TotalRangesCount = 0;
     for (RootTableData& Tbl : m_RootTables)
@@ -437,7 +487,8 @@ void RootParamsBuilder::InitializeMgr(IMemoryAllocator& MemAllocator, RootParams
     // Note: this order is more efficient than views->tables->ranges
     RootParameter* const          pRootTables       = reinterpret_cast<RootParameter*>(ParamsMgr.m_pMemory.get());
     RootParameter* const          pRootViews        = pRootTables + NumRootTables;
-    D3D12_DESCRIPTOR_RANGE* const pDescriptorRanges = reinterpret_cast<D3D12_DESCRIPTOR_RANGE*>(pRootViews + NumRootViews);
+    RootParameter* const          pRootConstants    = pRootViews + NumRootViews;
+    D3D12_DESCRIPTOR_RANGE* const pDescriptorRanges = reinterpret_cast<D3D12_DESCRIPTOR_RANGE*>(pRootConstants + NumRootConstants);
 
     // Copy descriptor tables
     D3D12_DESCRIPTOR_RANGE* pCurrDescrRangePtr = pDescriptorRanges;
@@ -484,8 +535,20 @@ void RootParamsBuilder::InitializeMgr(IMemoryAllocator& MemAllocator, RootParams
                "Unexpected parameter type: SBV, SRV or UAV is expected");
         new (pRootViews + rv) RootParameter{SrcView.RootIndex, SrcView.Group, d3d12RootParam};
     }
-    ParamsMgr.m_pRootTables = NumRootTables != 0 ? pRootTables : nullptr;
-    ParamsMgr.m_pRootViews  = NumRootViews != 0 ? pRootViews : nullptr;
+
+    // Copy root constants
+    for (Uint32 rc = 0; rc < NumRootConstants; ++rc)
+    {
+        const RootParameter&        SrcConst       = m_RootConstants[rc];
+        const D3D12_ROOT_PARAMETER& d3d12RootParam = SrcConst.d3d12RootParam;
+        VERIFY(d3d12RootParam.ParameterType == D3D12_ROOT_PARAMETER_TYPE_32BIT_CONSTANTS,
+               "Unexpected parameter type: 32-bit constants is expected");
+        new (pRootConstants + rc) RootParameter{SrcConst.RootIndex, SrcConst.Group, d3d12RootParam};
+    }
+
+    ParamsMgr.m_pRootTables    = NumRootTables != 0 ? pRootTables : nullptr;
+    ParamsMgr.m_pRootViews     = NumRootViews != 0 ? pRootViews : nullptr;
+    ParamsMgr.m_pRootConstants = NumRootConstants != 0 ? pRootConstants : nullptr;
 
 #ifdef DILIGENT_DEBUG
     ParamsMgr.Validate();
diff --git a/Graphics/GraphicsEngineD3D12/src/RootSignature.cpp b/Graphics/GraphicsEngineD3D12/src/RootSignature.cpp
@@ -78,7 +78,7 @@ RootSignatureD3D12::RootSignatureD3D12(IReferenceCounters*
         const RootParamsManager& RootParams = pSignature->GetRootParams();
 
         SignInfo.BaseRootIndex = TotalParams;
-        TotalParams += RootParams.GetNumRootTables() + RootParams.GetNumRootViews();
+        TotalParams += RootParams.GetNumRootTables() + RootParams.GetNumRootViews() + RootParams.GetNumRootConstants();
 
         for (Uint32 rt = 0; rt < RootParams.GetNumRootTables(); ++rt)
         {
@@ -166,6 +166,20 @@ RootSignatureD3D12::RootSignatureD3D12(IReferenceCounters*
             d3d12Parameters[RootIndex].Descriptor.RegisterSpace += BaseRegisterSpace;
         }
 
+        for (Uint32 rc = 0; rc < RootParams.GetNumRootConstants(); ++rc)
+        {
+            const RootParameter&        RootConsts    = RootParams.GetRootConstants(rc);
+            const D3D12_ROOT_PARAMETER& d3d12SrcParam = RootConsts.d3d12RootParam;
+            const Uint32                RootIndex     = SignInfo.BaseRootIndex + RootConsts.RootIndex;
+            VERIFY(d3d12SrcParam.ParameterType == D3D12_ROOT_PARAMETER_TYPE_32BIT_CONSTANTS, "Root 32-bit constants is expected");
+
+            MaxSpaceUsed = std::max(MaxSpaceUsed, d3d12SrcParam.Constants.RegisterSpace);
+
+            d3d12Parameters[RootIndex] = d3d12SrcParam;
+            // Offset register space value by the base register space of the current resource signature.
+            d3d12Parameters[RootIndex].Constants.RegisterSpace += BaseRegisterSpace;
+        }
+
         for (Uint32 samp = 0, SampCount = pSignature->GetImmutableSamplerCount(); samp < SampCount; ++samp)
         {
             const ImmutableSamplerAttribsD3D12& SampAttr = pSignature->GetImmutableSamplerAttribs(samp);
@@ -191,8 +205,8 @@ RootSignatureD3D12::RootSignatureD3D12(IReferenceCounters*
                         SamDesc.MaxLOD,
                         SampAttr.ShaderRegister + ArrInd,
                         SampAttr.RegisterSpace + BaseRegisterSpace,
-                        ShaderVisibility //
-                    }                    //
+                        ShaderVisibility,
+                    } //
                 );
             }
         }

Original file line number	Diff line number	Diff line change
`@@ -125,7 +125,7 @@ class PipelineResourceSignatureD3D12Impl final : public PipelineResourceSignatur`
`125`	`125`
`126`	`126`	`Uint32 GetTotalRootParamsCount() const`
`127`	`127`	`{`
`128`		`- return m_RootParams.GetNumRootTables() + m_RootParams.GetNumRootViews();`
	`128`	`+ return m_RootParams.GetNumRootTables() + m_RootParams.GetNumRootViews() + m_RootParams.GetNumRootConstants();`
`129`	`129`	`}`
`130`	`130`
`131`	`131`	`Uint32 GetNumRootTables() const`
`@@ -138,6 +138,11 @@ class PipelineResourceSignatureD3D12Impl final : public PipelineResourceSignatur`
`138`	`138`	`return m_RootParams.GetNumRootViews();`
`139`	`139`	`}`
`140`	`140`
	`141`	`+ Uint32 GetNumRootConstants() const`
	`142`	`+ {`
	`143`	`+ return m_RootParams.GetNumRootConstants();`
	`144`	`+ }`
	`145`	`+`
`141`	`146`	`void InitSRBResourceCache(ShaderResourceCacheD3D12& ResourceCache);`
`142`	`147`
`143`	`148`	`void CopyStaticResources(ShaderResourceCacheD3D12& ResourceCache) const;`