DeviceContextVk: enable inline constants

hzqst · TheMostDiligent · commit d444f827550f · 2026-01-07T08:28:15.000-08:00
diff --git a/Graphics/GraphicsEngineVulkan/include/DeviceContextVkImpl.hpp b/Graphics/GraphicsEngineVulkan/include/DeviceContextVkImpl.hpp
@@ -555,6 +555,12 @@ class DeviceContextVkImpl final : public DeviceContextNextGenBase<EngineVkImplTr
     __forceinline ResourceBindInfo& GetBindInfo(PIPELINE_TYPE Type);
 
     __forceinline void CommitDescriptorSets(ResourceBindInfo& BindInfo, Uint32 CommitSRBMask);
+
+    void UpdateInlineConstantBuffers(ResourceBindInfo& BindInfo);
+
+    // Commits push constants to the command buffer directly from SRB cache
+    void CommitPushConstants(ResourceBindInfo& BindInfo);
+
 #ifdef DILIGENT_DEVELOPMENT
     void DvpValidateCommittedShaderResources(ResourceBindInfo& BindInfo);
 #endif
diff --git a/Graphics/GraphicsEngineVulkan/include/PipelineResourceSignatureVkImpl.hpp b/Graphics/GraphicsEngineVulkan/include/PipelineResourceSignatureVkImpl.hpp
@@ -160,6 +160,17 @@ class PipelineResourceSignatureVkImpl final : public PipelineResourceSignatureBa
     // Returns the inline constant buffer attributes
     const InlineConstantBufferAttribsVk* GetInlineConstantBuffers() const { return m_InlineConstantBuffers.get(); }
 
+    // Updates inline constant buffers by mapping the internal buffers and copying data from the resource cache
+    // ResourceCache must be valid - each SRB has its own copy of inline constant data stored in the cache
+    // PushConstantResIndex: Resource index of the inline constant selected as push constant by PSO
+    //                       Pass ~0u if no push constant is selected from this signature
+    void UpdateInlineConstantBuffers(const ShaderResourceCacheVk& ResourceCache,
+                                     DeviceContextVkImpl&         Ctx,
+                                     Uint32                       PushConstantResIndex) const;
+
+    // Returns push constant data from the resource cache for the specified resource index
+    const void* GetPushConstantData(const ShaderResourceCacheVk& ResourceCache, Uint32 ResIndex) const;
+
 #ifdef DILIGENT_DEVELOPMENT
     /// Verifies committed resource using the SPIRV resource attributes from the PSO.
     bool DvpValidateCommittedResource(const DeviceContextVkImpl*        pDeviceCtx,
diff --git a/Graphics/GraphicsEngineVulkan/src/DeviceContextVkImpl.cpp b/Graphics/GraphicsEngineVulkan/src/DeviceContextVkImpl.cpp
@@ -415,6 +415,71 @@ DeviceContextVkImpl::ResourceBindInfo& DeviceContextVkImpl::GetBindInfo(PIPELINE
     return m_BindInfo[Indices[Uint32{Type}]];
 }
 
+void DeviceContextVkImpl::UpdateInlineConstantBuffers(ResourceBindInfo& BindInfo)
+{
+    const PipelineLayoutVk& Layout           = m_pPipelineState->GetPipelineLayout();
+    const auto&             PushConstantInfo = Layout.GetPushConstantInfo();
+    const Uint32            SignCount        = m_pPipelineState->GetResourceSignatureCount();
+
+    for (Uint32 i = 0; i < SignCount; ++i)
+    {
+        const PipelineResourceSignatureVkImpl* pSign = m_pPipelineState->GetResourceSignature(i);
+        if (pSign == nullptr || pSign->GetNumInlineConstantBuffers() == 0)
+            continue;
+
+        const ShaderResourceCacheVk* pResourceCache = BindInfo.ResourceCaches[i];
+        if (pResourceCache == nullptr)
+        {
+            // Each signature with inline constants must have a bound SRB with a valid resource cache
+            DEV_CHECK_ERR(false, "Signature '", pSign->GetDesc().Name, "' has inline constants but no SRB is bound. "
+                                                                       "Did you call CommitShaderResources()?");
+            continue;
+        }
+
+        if (!pResourceCache->HasInlineConstants())
+            continue;
+
+        // Determine which resource (if any) in this signature should use push constant path
+        // If this signature contains the selected push constant, pass its resource index
+        // Otherwise pass ~0u to use emulated buffer path for all
+        const Uint32 PushConstantResIndex = (i == PushConstantInfo.SignatureIndex) ? PushConstantInfo.ResourceIndex : ~0u;
+
+        // Update inline constant buffers
+        pSign->UpdateInlineConstantBuffers(*pResourceCache, *this, PushConstantResIndex);
+    }
+}
+
+void DeviceContextVkImpl::CommitPushConstants(ResourceBindInfo& BindInfo)
+{
+    VERIFY_EXPR(m_pPipelineState != nullptr);
+    const PipelineLayoutVk& Layout           = m_pPipelineState->GetPipelineLayout();
+    const auto&             PushConstantInfo = Layout.GetPushConstantInfo();
+
+    if (!PushConstantInfo)
+        return;
+
+    const PipelineResourceSignatureVkImpl* pSign = m_pPipelineState->GetResourceSignature(PushConstantInfo.SignatureIndex);
+    VERIFY_EXPR(pSign != nullptr);
+
+    const ShaderResourceCacheVk* pResourceCache = BindInfo.ResourceCaches[PushConstantInfo.SignatureIndex];
+    if (pResourceCache == nullptr)
+    {
+        DEV_CHECK_ERR(false, "Signature '", pSign->GetDesc().Name, "' has push constants but no SRB is bound. "
+                                                                   "Did you call CommitShaderResources()?");
+        return;
+    }
+
+    // Get inline constant data directly from the resource cache
+    const void* pPushConstantData = pSign->GetPushConstantData(*pResourceCache, PushConstantInfo.ResourceIndex);
+    if (pPushConstantData == nullptr)
+    {
+        DEV_CHECK_ERR(false, "Push constant data is null in signature '", pSign->GetDesc().Name, "'");
+        return;
+    }
+
+    m_CommandBuffer.PushConstants(Layout.GetVkPipelineLayout(), PushConstantInfo.vkRange, pPushConstantData);
+}
+
 void DeviceContextVkImpl::CommitDescriptorSets(ResourceBindInfo& BindInfo, Uint32 CommitSRBMask)
 {
     VERIFY(CommitSRBMask != 0, "This method should not be called when there is nothing to commit");
@@ -758,13 +823,28 @@ void DeviceContextVkImpl::PrepareForDraw(DRAW_FLAGS Flags)
 #endif
 
     ResourceBindInfo& BindInfo = GetBindInfo(PIPELINE_TYPE_GRAPHICS);
+
+    // Update inline constant buffers (emulated path) before binding descriptor sets
+    const bool DynamicBuffersIntact  = (Flags & DRAW_FLAG_DYNAMIC_RESOURCE_BUFFERS_INTACT) != 0;
+    const bool InlineConstantsIntact = (Flags & DRAW_FLAG_INLINE_CONSTANTS_INTACT) != 0;
+    if (!InlineConstantsIntact)
+    {
+        UpdateInlineConstantBuffers(BindInfo);
+    }
+
     // First time we must always bind descriptor sets with dynamic offsets as SRBs are stale.
     // If there are no dynamic buffers bound in the resource cache, for all subsequent
     // calls we do not need to bind the sets again.
-    if (Uint32 CommitMask = BindInfo.GetCommitMask(Flags & DRAW_FLAG_DYNAMIC_RESOURCE_BUFFERS_INTACT, Flags & DRAW_FLAG_INLINE_CONSTANTS_INTACT))
+    if (Uint32 CommitMask = BindInfo.GetCommitMask(DynamicBuffersIntact, InlineConstantsIntact))
     {
         CommitDescriptorSets(BindInfo, CommitMask);
     }
+
+    // Commit push constants directly from SRB cache.
+    // Push constants are always submitted before draw (similar to D3D11/D3D12) because
+    // inline constants are designed to change every draw call.
+    CommitPushConstants(BindInfo);
+
 #ifdef DILIGENT_DEVELOPMENT
     // Must be called after CommitDescriptorSets as it needs SetInfo.BaseInd
     DvpValidateCommittedShaderResources(BindInfo);
@@ -1059,11 +1139,18 @@ void DeviceContextVkImpl::PrepareForDispatchCompute()
     EndRenderScope();
 
     ResourceBindInfo& BindInfo = GetBindInfo(PIPELINE_TYPE_COMPUTE);
+
+    // Update inline constant buffers before binding descriptor sets
+    UpdateInlineConstantBuffers(BindInfo);
+
     if (Uint32 CommitMask = BindInfo.GetCommitMask())
     {
         CommitDescriptorSets(BindInfo, CommitMask);
     }
 
+    // Commit push constants directly from SRB cache
+    CommitPushConstants(BindInfo);
+
 #ifdef DILIGENT_DEVELOPMENT
     // Must be called after CommitDescriptorSets as it needs SetInfo.BaseInd
     DvpValidateCommittedShaderResources(BindInfo);
@@ -1075,11 +1162,18 @@ void DeviceContextVkImpl::PrepareForRayTracing()
     EnsureVkCmdBuffer();
 
     ResourceBindInfo& BindInfo = GetBindInfo(PIPELINE_TYPE_RAY_TRACING);
+
+    // Update inline constant buffers before binding descriptor sets
+    UpdateInlineConstantBuffers(BindInfo);
+
     if (Uint32 CommitMask = BindInfo.GetCommitMask())
     {
         CommitDescriptorSets(BindInfo, CommitMask);
     }
 
+    // Commit push constants directly from SRB cache
+    CommitPushConstants(BindInfo);
+
 #ifdef DILIGENT_DEVELOPMENT
     // Must be called after CommitDescriptorSets as it needs SetInfo.BaseInd
     DvpValidateCommittedShaderResources(BindInfo);
diff --git a/Graphics/GraphicsEngineVulkan/src/PipelineResourceSignatureVkImpl.cpp b/Graphics/GraphicsEngineVulkan/src/PipelineResourceSignatureVkImpl.cpp
@@ -956,6 +956,8 @@ bool PipelineResourceSignatureVkImpl::DvpValidateCommittedResource(const DeviceC
 
     VERIFY_EXPR(SPIRVAttribs.ArraySize <= ResAttribs.ArraySize);
 
+    // TODO: verify how this works for push constants
+
     bool BindingsOK = true;
     for (Uint32 ArrIndex = 0; ArrIndex < SPIRVAttribs.ArraySize; ++ArrIndex)
     {
@@ -1000,7 +1002,16 @@ bool PipelineResourceSignatureVkImpl::DvpValidateCommittedResource(const DeviceC
                 // is bound. It will be null if the type is incorrect.
                 if (const BufferVkImpl* pBufferVk = Res.pObject.RawPtr<BufferVkImpl>())
                 {
-                    pDeviceCtx->DvpVerifyDynamicAllocation(pBufferVk);
+                    // Skip dynamic allocation verification for inline constant buffers.
+                    // These are internal buffers managed by the signature and are updated
+                    // via UpdateInlineConstantBuffers() before each draw/dispatch.
+                    // The Dynamic Buffer ID may be reused after PSO recreation (e.g., from cache),
+                    // which would cause false validation failures.
+                    const bool IsInlineConstantBuffer = (ResDesc.Flags & PIPELINE_RESOURCE_FLAG_INLINE_CONSTANTS) != 0;
+                    if (!IsInlineConstantBuffer)
+                    {
+                        pDeviceCtx->DvpVerifyDynamicAllocation(pBufferVk);
+                    }
 
                     if ((pBufferVk->GetDesc().Size < SPIRVAttribs.BufferStaticSize) &&
                         (GetDevice()->GetValidationFlags() & VALIDATION_FLAG_CHECK_SHADER_BUFFER_SIZE) != 0)
@@ -1115,4 +1126,57 @@ PipelineResourceSignatureInternalDataVk PipelineResourceSignatureVkImpl::GetInte
     return InternalData;
 }
 
+void PipelineResourceSignatureVkImpl::UpdateInlineConstantBuffers(const ShaderResourceCacheVk& ResourceCache,
+                                                                  DeviceContextVkImpl&         Ctx,
+                                                                  Uint32                       PushConstantResIndex) const
+{
+    // Determine the cache type based on the resource cache content
+    // SRB caches use SRBCacheOffset, static caches use StaticCacheOffset
+    const ResourceCacheContentType CacheType = ResourceCache.GetContentType();
+
+    for (Uint32 i = 0; i < m_NumInlineConstantBuffers; ++i)
+    {
+        const InlineConstantBufferAttribsVk& InlineCBAttr        = m_InlineConstantBuffers[i];
+        const Uint32                         DataSize            = InlineCBAttr.NumConstants * sizeof(Uint32);
+        const ResourceAttribs&               Attr                = GetResourceAttribs(InlineCBAttr.ResIndex);
+        const Uint32                         CacheOffset         = Attr.CacheOffset(CacheType);
+        const void*                          pInlineConstantData = ResourceCache.GetInlineConstantData(Attr.DescrSet, CacheOffset);
+        VERIFY_EXPR(pInlineConstantData != nullptr);
+
+        // Skip push constants - they are handled directly by CommitPushConstants
+        if (InlineCBAttr.ResIndex == PushConstantResIndex)
+            continue;
+
+        // For emulated inline constants, get the shared buffer from the Signature
+        // All SRBs share this buffer (similar to D3D11 backend)
+        BufferVkImpl* pBuffer = InlineCBAttr.pBuffer.RawPtr();
+
+        if (pBuffer)
+        {
+            // Map the shared buffer and copy the data
+            void* pMappedData = nullptr;
+            Ctx.MapBuffer(pBuffer, MAP_WRITE, MAP_FLAG_DISCARD, pMappedData);
+            memcpy(pMappedData, pInlineConstantData, DataSize);
+            Ctx.UnmapBuffer(pBuffer, MAP_WRITE);
+        }
+    }
+}
+
+const void* PipelineResourceSignatureVkImpl::GetPushConstantData(const ShaderResourceCacheVk& ResourceCache, Uint32 ResIndex) const
+{
+    // Find the inline constant buffer with the specified resource index
+    for (Uint32 i = 0; i < m_NumInlineConstantBuffers; ++i)
+    {
+        const InlineConstantBufferAttribsVk& InlineCBAttr = m_InlineConstantBuffers[i];
+        if (InlineCBAttr.ResIndex == ResIndex)
+        {
+            const ResourceCacheContentType CacheType   = ResourceCache.GetContentType();
+            const ResourceAttribs&         Attr        = GetResourceAttribs(InlineCBAttr.ResIndex);
+            const Uint32                   CacheOffset = Attr.CacheOffset(CacheType);
+            return ResourceCache.GetInlineConstantData(Attr.DescrSet, CacheOffset);
+        }
+    }
+    return nullptr;
+}
+
 } // namespace Diligent
diff --git a/Tests/DiligentCoreAPITest/src/InlineConstantsTest.cpp b/Tests/DiligentCoreAPITest/src/InlineConstantsTest.cpp
@@ -129,7 +129,7 @@ class InlineConstants : public ::testing::Test
         GPUTestingEnvironment* pEnv    = GPUTestingEnvironment::GetInstance();
         IRenderDevice*         pDevice = pEnv->GetDevice();
 
-        if (!pDevice->GetDeviceInfo().IsD3DDevice())
+        if (!pDevice->GetDeviceInfo().IsD3DDevice() && !pDevice->GetDeviceInfo().IsVulkanDevice())
         {
             GTEST_SKIP();
         }
@@ -342,7 +342,7 @@ void InlineConstants::TestSignatures(Uint32 NumSignatures)
 
             PipelineResourceSignatureDescX SignDesc{"Inline constants test"};
             SignDesc
-                .AddResource(SHADER_TYPE_VERTEX, "cb0_stat", 1u, SHADER_RESOURCE_TYPE_CONSTANT_BUFFER, SHADER_RESOURCE_VARIABLE_TYPE_STATIC)
+                .AddResource(SHADER_TYPE_VERTEX, "cb0_stat", 1u, SHADER_RESOURCE_TYPE_CONSTANT_BUFFER, SHADER_RESOURCE_VARIABLE_TYPE_STATIC, PIPELINE_RESOURCE_FLAG_NO_DYNAMIC_BUFFERS)
                 .AddResource(SHADER_TYPE_VERTEX, "cb0_mut", 1u, SHADER_RESOURCE_TYPE_CONSTANT_BUFFER, SHADER_RESOURCE_VARIABLE_TYPE_MUTABLE)
                 .AddResource(SHADER_TYPE_VERTEX, "cb0_dyn", 1u, SHADER_RESOURCE_TYPE_CONSTANT_BUFFER, SHADER_RESOURCE_VARIABLE_TYPE_DYNAMIC)
                 .AddResource(SHADER_TYPE_VERTEX, "tex0_stat", SHADER_RESOURCE_TYPE_TEXTURE_SRV, SHADER_RESOURCE_VARIABLE_TYPE_STATIC)
@@ -363,7 +363,7 @@ void InlineConstants::TestSignatures(Uint32 NumSignatures)
                 SignDesc.BindingIndex = 1;
             }
 
-            SignDesc.AddResource(SHADER_TYPE_VERTEX, "cb1_stat", 1u, SHADER_RESOURCE_TYPE_CONSTANT_BUFFER, SHADER_RESOURCE_VARIABLE_TYPE_STATIC)
+            SignDesc.AddResource(SHADER_TYPE_VERTEX, "cb1_stat", 1u, SHADER_RESOURCE_TYPE_CONSTANT_BUFFER, SHADER_RESOURCE_VARIABLE_TYPE_STATIC, PIPELINE_RESOURCE_FLAG_NO_DYNAMIC_BUFFERS)
                 .AddResource(SHADER_TYPE_VERTEX, "cb1_mut", 1u, SHADER_RESOURCE_TYPE_CONSTANT_BUFFER, SHADER_RESOURCE_VARIABLE_TYPE_MUTABLE)
                 .AddResource(SHADER_TYPE_VERTEX, "cb1_dyn", 1u, SHADER_RESOURCE_TYPE_CONSTANT_BUFFER, SHADER_RESOURCE_VARIABLE_TYPE_DYNAMIC)
                 .AddResource(SHADER_TYPE_VERTEX, "tex1_stat", SHADER_RESOURCE_TYPE_TEXTURE_SRV, SHADER_RESOURCE_VARIABLE_TYPE_STATIC)
@@ -372,7 +372,7 @@ void InlineConstants::TestSignatures(Uint32 NumSignatures)
 
                 .AddResource(SHADER_TYPE_VS_PS, "cbInlineColors", kNumColConstants, SHADER_RESOURCE_TYPE_CONSTANT_BUFFER, ColType, PIPELINE_RESOURCE_FLAG_INLINE_CONSTANTS)
 
-                .AddResource(SHADER_TYPE_VERTEX, "cb2_stat", 1u, SHADER_RESOURCE_TYPE_CONSTANT_BUFFER, SHADER_RESOURCE_VARIABLE_TYPE_STATIC)
+                .AddResource(SHADER_TYPE_VERTEX, "cb2_stat", 1u, SHADER_RESOURCE_TYPE_CONSTANT_BUFFER, SHADER_RESOURCE_VARIABLE_TYPE_STATIC, PIPELINE_RESOURCE_FLAG_NO_DYNAMIC_BUFFERS)
                 .AddResource(SHADER_TYPE_VERTEX, "cb2_mut", 1u, SHADER_RESOURCE_TYPE_CONSTANT_BUFFER, SHADER_RESOURCE_VARIABLE_TYPE_MUTABLE)
                 .AddResource(SHADER_TYPE_VERTEX, "cb2_dyn", 1u, SHADER_RESOURCE_TYPE_CONSTANT_BUFFER, SHADER_RESOURCE_VARIABLE_TYPE_DYNAMIC)
                 .AddResource(SHADER_TYPE_VERTEX, "tex2_stat", SHADER_RESOURCE_TYPE_TEXTURE_SRV, SHADER_RESOURCE_VARIABLE_TYPE_STATIC)
@@ -753,6 +753,11 @@ TEST_F(InlineConstants, RenderStateCache)
                 PresentInCache = true;
             }
 #endif
+            if (pDevice->GetDeviceInfo().IsVulkanDevice())
+            {
+                // For some reason, pUncachedVS and pVS1 got same hash computation result on Vulkan.
+                PresentInCache = true;
+            }
             CreatePSOFromCache(pCache, PresentInCache, pUncachedVS, pUncachedPS, &pPSO2);
             ASSERT_NE(pPSO2, nullptr);
             ASSERT_EQ(pPSO2->GetStatus(), PIPELINE_STATE_STATUS_READY);
