Fix issue from DiligentGraphics#747

Author: hzqst

Graphics/Archiver/src/Archiver_Vk.cpp

@@ -128,9 +128,10 @@ void SerializedPipelineStateImpl::PatchShadersVk(const CreateInfoType& CreateInf
     {
         ShaderStageInfoVk&                    Src{ShaderStages[i]};
         PipelineStateVkImpl::ShaderStageInfo& Dst{ShaderStagesVk[i]};
-        Dst.Type    = Src.Type;
-        Dst.Shaders = std::move(Src.Shaders);
-        Dst.SPIRVs  = std::move(Src.SPIRVs);
+        Dst.Type            = Src.Type;
+        Dst.Shaders         = std::move(Src.Shaders);
+        Dst.SPIRVs          = std::move(Src.SPIRVs);
+        Dst.ShaderResources = std::move(Src.ShaderResources);
     }
 
     IPipelineResourceSignature** ppSignatures    = CreateInfo.ppResourceSignatures;

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

Graphics/GraphicsEngineVulkan/include/PipelineResourceSignatureVkImpl.hpp

@@ -50,6 +50,7 @@ namespace Diligent
 
 struct SPIRVShaderResourceAttribs;
 class DeviceContextVkImpl;
+class BufferVkImpl;
 
 struct ImmutableSamplerAttribsVk
 {
@@ -58,6 +59,27 @@ struct ImmutableSamplerAttribsVk
 };
 ASSERT_SIZEOF(ImmutableSamplerAttribsVk, 8, "The struct is used in serialization and must be tightly packed");
 
+/// Inline constant buffer attributes for Vulkan backend.
+/// All inline constants are treated uniformly at PRS level - they all get:
+/// - DescriptorSet binding and cache allocation
+/// - Shared emulated buffer (created in the Signature, shared by all SRBs)
+///
+/// Push constant selection is deferred to PSO creation time. At PSO creation,
+/// one inline constant may be selected to use vkCmdPushConstants based on:
+/// 1. SPIR-V reflection (ResourceType::PushConstant in shader)
+/// 2. First inline constant as fallback (converted via PatchShader)
+struct InlineConstantBufferAttribsVk
+{
+    Uint32 ResIndex     = 0; // Resource index in the signature (used for matching)
+    Uint32 DescrSet     = 0; // Descriptor set index
+    Uint32 BindingIndex = 0; // Binding index within the descriptor set
+    Uint32 NumConstants = 0; // Number of 32-bit constants
+
+    // Shared buffer created in the Signature (similar to D3D11)
+    // All SRBs reference this same buffer to reduce memory usage.
+    RefCntAutoPtr<BufferVkImpl> pBuffer;
+};
+
 struct PipelineResourceSignatureInternalDataVk : PipelineResourceSignatureInternalData<PipelineResourceAttribsVk, ImmutableSamplerAttribsVk>
 {
     Uint16 DynamicUniformBufferCount = 0;
@@ -134,6 +156,23 @@ class PipelineResourceSignatureVkImpl final : public PipelineResourceSignatureBa
     void CommitDynamicResources(const ShaderResourceCacheVk& ResourceCache,
                                 VkDescriptorSet              vkDynamicDescriptorSet) const;
 
+    // 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 the number of inline constant buffers
+    Uint32 GetNumInlineConstantBufferAttribs() const { return m_NumInlineConstantBufferAttribs; }
+
+    // Returns the inline constant buffer attributes
+    const InlineConstantBufferAttribsVk* GetInlineConstantBufferAttribs() const { return m_InlineConstantBufferAttribs.get(); }
+
+    // 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,
@@ -152,8 +191,7 @@ class PipelineResourceSignatureVkImpl final : public PipelineResourceSignatureBa
 
     bool HasInlineConstants() const
     {
-        // TODO
-        return false;
+        return m_NumInlineConstantBufferAttribs != 0;
     }
 
 private:
@@ -199,6 +237,11 @@ class PipelineResourceSignatureVkImpl final : public PipelineResourceSignatureBa
     // The total number storage buffers with dynamic offsets in both descriptor sets,
     // accounting for array size.
     Uint16 m_DynamicStorageBufferCount = 0;
+
+    // Number of inline constant buffers
+    Uint32 m_NumInlineConstantBufferAttribs = 0;
+    // Inline constant buffer attributes
+    std::unique_ptr<InlineConstantBufferAttribsVk[]> m_InlineConstantBufferAttribs;
 };
 
 template <> Uint32 PipelineResourceSignatureVkImpl::GetDescriptorSetIndex<PipelineResourceSignatureVkImpl::DESCRIPTOR_SET_ID_STATIC_MUTABLE>() const;

Graphics/GraphicsEngineVulkan/include/PipelineStateVkImpl.hpp

@@ -84,8 +84,9 @@ class PipelineStateVkImpl final : public PipelineStateBase<EngineVkImplTraits>
         // Shader stage type. All shaders in the stage must have the same type.
         SHADER_TYPE Type = SHADER_TYPE_UNKNOWN;
 
-        std::vector<const ShaderVkImpl*>   Shaders;
-        std::vector<std::vector<uint32_t>> SPIRVs;
+        std::vector<const ShaderVkImpl*>                         Shaders;
+        std::vector<std::vector<uint32_t>>                       SPIRVs;
+        std::vector<std::shared_ptr<const SPIRVShaderResources>> ShaderResources; //This can be also updated due to push constant
 
         friend SHADER_TYPE GetShaderStageType(const ShaderStageInfo& Stage) { return Stage.Type; }
     };
@@ -133,6 +134,10 @@ class PipelineStateVkImpl final : public PipelineStateBase<EngineVkImplTraits>
     void InitializePipeline(const ComputePipelineStateCreateInfo& CreateInfo);
     void InitializePipeline(const RayTracingPipelineStateCreateInfo& CreateInfo);
 
+    void ValidateShaderPushConstants(const TShaderStages& ShaderStages) const noexcept(false);
+
+    void PatchShaderConvertUniformBufferToPushConstant(TShaderStages& ShaderStages) const noexcept(false);
+
     // TPipelineStateBase::Construct needs access to InitializePipeline
     friend TPipelineStateBase;
 

Graphics/GraphicsEngineVulkan/include/ShaderResourceCacheVk.hpp

@@ -37,7 +37,7 @@
 //  m_pMemory                                |   |              m_pResources, m_NumResources == m            |
 //  |               m_DescriptorSetAllocation|   |                                                           |
 //  V                                        |   |                                                           V
-//  |  DescriptorSet[0]  |   ....    |  DescriptorSet[Ns-1]  |  Res[0]  |  ... |  Res[n-1]  |    ....     | Res[0]  |  ... |  Res[m-1]  |
+//  |  DescriptorSet[0]  |   ....    |  DescriptorSet[Ns-1]  |  Res[0]  |  ... |  Res[n-1]  |    ....     | Res[0]  |  ... |  Res[m-1]  | Inline constant values |
 //         |    |                                                A \
 //         |    |                                                |  \
 //         |    |________________________________________________|   \RefCntAutoPtr
@@ -74,7 +74,8 @@ class ShaderResourceCacheVk : public ShaderResourceCacheBase
 public:
     explicit ShaderResourceCacheVk(ResourceCacheContentType ContentType) noexcept :
         m_TotalResources{0},
-        m_ContentType{static_cast<Uint32>(ContentType)}
+        m_ContentType{static_cast<Uint32>(ContentType)},
+        m_HasInlineConstants{0}
     {
         VERIFY_EXPR(GetContentType() == ContentType);
     }
@@ -88,12 +89,12 @@ class ShaderResourceCacheVk : public ShaderResourceCacheBase
 
     ~ShaderResourceCacheVk();
 
-    static size_t GetRequiredMemorySize(Uint32 NumSets, const Uint32* SetSizes);
+    static size_t GetRequiredMemorySize(Uint32 NumSets, const Uint32* SetSizes, Uint32 TotalInlineConstantBytes = 0);
 
-    void InitializeSets(IMemoryAllocator& MemAllocator, Uint32 NumSets, const Uint32* SetSizes);
+    void InitializeSets(IMemoryAllocator& MemAllocator, Uint32 NumSets, const Uint32* SetSizes, Uint32 TotalInlineConstantBytes = 0);
     void InitializeResources(Uint32 Set, Uint32 Offset, Uint32 ArraySize, DescriptorType Type, bool HasImmutableSampler);
 
-    // sizeof(Resource) == 32 (x64, msvc, Release)
+    // sizeof(Resource) == 40 (x64, msvc, Release)
     struct Resource
     {
         explicit Resource(DescriptorType _Type, bool _HasImmutableSampler) noexcept :
@@ -120,6 +121,10 @@ class ShaderResourceCacheVk : public ShaderResourceCacheBase
 /*16 */ Uint64                       BufferBaseOffset = 0;
 /*24 */ Uint64                       BufferRangeSize  = 0;
 
+        // For inline constants only - pointer to CPU-side staging buffer
+/*32 */ void*                        pInlineConstantData = nullptr;
+/*40 */ // End of structure
+
         VkDescriptorBufferInfo GetUniformBufferDescriptorWriteInfo()                     const;
         VkDescriptorBufferInfo GetStorageBufferDescriptorWriteInfo()                     const;
         VkDescriptorImageInfo  GetImageDescriptorWriteInfo  ()                           const;
@@ -245,13 +250,46 @@ class ShaderResourceCacheVk : public ShaderResourceCacheBase
                                 Uint32 CacheOffset,
                                 Uint32 DynamicBufferOffset);
 
+    // Sets inline constant data in the resource cache
+    void SetInlineConstants(Uint32      DescrSetIndex,
+                            Uint32      CacheOffset,
+                            const void* pConstants,
+                            Uint32      FirstConstant,
+                            Uint32      NumConstants);
+
+    // Gets the inline constant data pointer from the resource cache
+    const void* GetInlineConstantData(Uint32 DescrSetIndex, Uint32 CacheOffset) const;
+
+    // Initialize inline constant buffer in the resource cache
+    void InitializeInlineConstantBuffer(Uint32 DescrSetIndex,
+                                        Uint32 CacheOffset,
+                                        Uint32 NumConstants,
+                                        Uint32 InlineConstantOffset);
+
+    // Returns pointer to inline constant storage at the given byte offset
+    void* GetInlineConstantStorage(Uint32 ByteOffset = 0)
+    {
+        return reinterpret_cast<Uint8*>(GetFirstResourcePtr() + m_TotalResources) + ByteOffset;
+    }
+    const void* GetInlineConstantStorage(Uint32 ByteOffset = 0) const
+    {
+        return reinterpret_cast<const Uint8*>(GetFirstResourcePtr() + m_TotalResources) + ByteOffset;
+    }
+
+    // Explicitly marks that this cache contains inline constants.
+    // This is useful when inline constant memory is initialized externally
+    // (e.g., during SRB cache setup) before any data is written.
+    void MarkHasInlineConstants()
+    {
+        m_HasInlineConstants = 1;
+    }
 
     Uint32 GetNumDescriptorSets() const { return m_NumSets; }
     bool   HasDynamicResources() const { return m_NumDynamicBuffers > 0; }
 
     bool HasInlineConstants() const
     {
-        return false;
+        return m_HasInlineConstants;
     }
 
     ResourceCacheContentType GetContentType() const { return static_cast<ResourceCacheContentType>(m_ContentType); }
@@ -292,11 +330,14 @@ class ShaderResourceCacheVk : public ShaderResourceCacheBase
     // Total actual number of dynamic buffers (that were created with USAGE_DYNAMIC) bound in the resource cache
     // regardless of the variable type. Note this variable is not equal to dynamic offsets count, which is constant.
     Uint16 m_NumDynamicBuffers = 0;
-    Uint32 m_TotalResources : 31;
+    Uint32 m_TotalResources : 30;
 
     // Indicates what types of resources are stored in the cache
     const Uint32 m_ContentType : 1;
 
+    // Indicates whether the cache contains inline constants
+    Uint32 m_HasInlineConstants : 1;
+
 #ifdef DILIGENT_DEBUG
     // Debug array that stores flags indicating if resources in the cache have been initialized
     std::vector<std::vector<bool>> m_DbgInitializedResources;