ResourceSignatureD3D12: implement CommitRootConstants method (#672)

Author: TheMostDiligent

Graphics/GraphicsEngine/include/DeviceContextBase.hpp

@@ -381,6 +381,9 @@ class DeviceContextBase : public ObjectBase<typename EngineImplTraits::DeviceCon
         // buffers with dynamic offsets in all backends).
         SRBMaskType DynamicSRBMask = 0;
 
+        // Indicates which SRBs contain inline constants
+        SRBMaskType InlineConstantsSRBMask = 0;
+
         void Set(Uint32 Index, ShaderResourceBindingImplType* pSRB)
         {
             VERIFY_EXPR(Index < MAX_RESOURCE_SIGNATURES);
@@ -398,6 +401,11 @@ class DeviceContextBase : public ObjectBase<typename EngineImplTraits::DeviceCon
             else
                 DynamicSRBMask &= ~SRBBit;
 
+            if (pResourceCache != nullptr && pResourceCache->HasInlineConstants())
+                InlineConstantsSRBMask |= SRBBit;
+            else
+                InlineConstantsSRBMask &= ~SRBBit;
+
 #ifdef DILIGENT_DEVELOPMENT
             SRBs[Index] = pSRB;
             if (pSRB != nullptr)
@@ -412,18 +420,26 @@ class DeviceContextBase : public ObjectBase<typename EngineImplTraits::DeviceCon
         }
 
         // Returns the mask of SRBs whose resources need to be committed
-        SRBMaskType GetCommitMask(bool DynamicResourcesIntact = false) const
+        SRBMaskType GetCommitMask(bool DynamicResourcesIntact = false,
+                                  bool InlineConstantsIntact  = false) const
         {
 #ifdef DILIGENT_DEVELOPMENT
             DvpVerifyCacheRevisions();
 #endif
 
             // Stale SRBs always have to be committed
             SRBMaskType CommitMask = StaleSRBMask;
+
             // If dynamic resources are not intact, SRBs with dynamic resources
             // have to be handled
             if (!DynamicResourcesIntact)
                 CommitMask |= DynamicSRBMask;
+
+            // If inline constants are not intact, SRBs with inline constants
+            // have to be handled
+            if (!InlineConstantsIntact)
+                CommitMask |= InlineConstantsSRBMask;
+
             // Only process SRBs that are used by current PSO
             CommitMask &= ActiveSRBMask;
             return CommitMask;

Graphics/GraphicsEngineD3D11/include/ShaderResourceCacheD3D11.hpp

@@ -392,6 +392,11 @@ class ShaderResourceCacheD3D11 : public ShaderResourceCacheBase
         return false;
     }
 
+    bool HasInlineConstants() const
+    {
+        return false;
+    }
+
 #ifdef DILIGENT_DEBUG
     void DbgVerifyDynamicBufferMasks() const;
 #endif

Graphics/GraphicsEngineD3D12/include/PipelineResourceSignatureD3D12Impl.hpp

@@ -163,6 +163,9 @@ class PipelineResourceSignatureD3D12Impl final : public PipelineResourceSignatur
     void CommitRootViews(const CommitCacheResourcesAttribs& CommitAttribs,
                          Uint64                             BuffersMask) const;
 
+    void CommitRootConstants(const CommitCacheResourcesAttribs& CommitAttribs,
+                             Uint64                             ConstantsMask) const;
+
     const RootParamsManager& GetRootParams() const { return m_RootParams; }
 
     // Adds resources and immutable samplers from this signature to the

Graphics/GraphicsEngineD3D12/include/ShaderResourceCacheD3D12.hpp

@@ -339,10 +339,16 @@ class ShaderResourceCacheD3D12 : public ShaderResourceCacheBase
     // Returns the bitmask indicating root views with bound non-dynamic buffers
     Uint64 GetNonDynamicRootBuffersMask() const { return m_NonDynamicRootBuffersMask; }
 
+    // Returns the bitmask indicating constants parameters
+    Uint64 GetRootConstantsMask() const { return m_RootConstantsMask; }
+
     // Returns true if the cache contains at least one dynamic resource, i.e.
     // dynamic buffer or a buffer range.
     bool HasDynamicResources() const { return GetDynamicRootBuffersMask() != 0; }
 
+    // Returns true if the cache contains at least one inline constants parameter.
+    bool HasInlineConstants() const { return GetRootConstantsMask() != 0; }
+
 #ifdef DILIGENT_DEBUG
     void DbgValidateDynamicBuffersMask() const;
 #endif
@@ -392,6 +398,9 @@ class ShaderResourceCacheD3D12 : public ShaderResourceCacheBase
 
     // The bitmask indicating root views with bound non-dynamic buffers
     Uint64 m_NonDynamicRootBuffersMask = Uint64{0};
+
+    // The bitmask indicating root constants parameters
+    Uint64 m_RootConstantsMask = Uint64{0};
 };
 
 } // namespace Diligent

Graphics/GraphicsEngineD3D12/src/PipelineResourceSignatureD3D12Impl.cpp

@@ -522,6 +522,45 @@ void PipelineResourceSignatureD3D12Impl::CommitRootViews(const CommitCacheResour
     }
 }
 
+void PipelineResourceSignatureD3D12Impl::CommitRootConstants(const CommitCacheResourcesAttribs& CommitAttribs,
+                                                             Uint64                             ConstantsMask) const
+{
+    VERIFY_EXPR(CommitAttribs.pResourceCache != nullptr);
+
+    while (ConstantsMask != 0)
+    {
+        // Root constants are stored as raw data in the CPU descriptor handle pointer of
+        // the single-resource root table.
+
+        const Uint64                               RootIndBit    = ExtractLSB(ConstantsMask);
+        const Uint32                               RootInd       = PlatformMisc::GetLSB(RootIndBit);
+        const ShaderResourceCacheD3D12::RootTable& CacheTbl      = CommitAttribs.pResourceCache->GetRootTable(RootInd);
+        const Uint32&                              BaseRootIndex = CommitAttribs.BaseRootIndex;
+
+        VERIFY_EXPR(CacheTbl.GetSize() == 1);
+        const ShaderResourceCacheD3D12::Resource& Res = CacheTbl.GetResource(0);
+        VERIFY_EXPR(Res.Type == SHADER_RESOURCE_TYPE_INLINE_CONSTANTS);
+        VERIFY(Res.IsNull(), "There should be no resource bound for root constants as they contain raw data.");
+
+        const Uint32* pConstants = reinterpret_cast<const Uint32*>(Res.CPUDescriptorHandle.ptr);
+        VERIFY(pConstants != nullptr, "Resources used to store root constants must have valid pointer to the data.");
+        // The number of root constants is stored in BufferRangeSize
+        const Uint32 NumConstants = static_cast<Uint32>(Res.BufferRangeSize);
+
+        ID3D12GraphicsCommandList* const pd3d12CmdList = CommitAttribs.CmdCtx.GetCommandList();
+        if (CommitAttribs.IsCompute)
+        {
+            for (Uint32 i = 0; i < NumConstants; ++i)
+                pd3d12CmdList->SetComputeRoot32BitConstant(BaseRootIndex + RootInd, pConstants[i], i);
+        }
+        else
+        {
+            for (Uint32 i = 0; i < NumConstants; ++i)
+                pd3d12CmdList->SetGraphicsRoot32BitConstant(BaseRootIndex + RootInd, pConstants[i], i);
+        }
+    }
+}
+
 void PipelineResourceSignatureD3D12Impl::CommitRootTables(const CommitCacheResourcesAttribs& CommitAttribs) const
 {
     VERIFY_EXPR(CommitAttribs.pResourceCache != nullptr);

Graphics/GraphicsEngineOpenGL/include/ShaderResourceCacheGL.hpp

@@ -345,6 +345,11 @@ class ShaderResourceCacheGL : public ShaderResourceCacheBase
         return m_DynamicUBOMask != 0 || m_DynamicSSBOMask != 0;
     }
 
+    bool HasInlineConstants() const
+    {
+        return false;
+    }
+
 #ifdef DILIGENT_DEBUG
     void DbgVerifyDynamicBufferMasks() const;
 #endif

Graphics/GraphicsEngineVulkan/include/ShaderResourceCacheVk.hpp

@@ -249,6 +249,11 @@ class ShaderResourceCacheVk : public ShaderResourceCacheBase
     Uint32 GetNumDescriptorSets() const { return m_NumSets; }
     bool   HasDynamicResources() const { return m_NumDynamicBuffers > 0; }
 
+    bool HasInlineConstants() const
+    {
+        return false;
+    }
+
     ResourceCacheContentType GetContentType() const { return static_cast<ResourceCacheContentType>(m_ContentType); }
 
 #ifdef DILIGENT_DEBUG

Graphics/GraphicsEngineWebGPU/include/ShaderResourceCacheWebGPU.hpp

@@ -176,6 +176,11 @@ class ShaderResourceCacheWebGPU : public ShaderResourceCacheBase
     Uint32 GetNumBindGroups() const { return m_NumBindGroups; }
     bool   HasDynamicResources() const { return m_NumDynamicBuffers > 0; }
 
+    bool HasInlineConstants() const
+    {
+        return false;
+    }
+
     ResourceCacheContentType GetContentType() const { return static_cast<ResourceCacheContentType>(m_ContentType); }
 
     WGPUBindGroup UpdateBindGroup(WGPUDevice wgpuDevice, Uint32 GroupIndex, WGPUBindGroupLayout wgpuGroupLayout);