Now using pShaderResources from ShaderStageInfo instead of from ShaderVkImpl, allow updating SPIRVShaderResource with ShaderStageInfo on patching SPIRV simultaneously.

hzqst · hzqst · commit c67819de0db2 · 2025-12-10T10:50:24.000+08:00
diff --git a/Graphics/Archiver/src/Archiver_Vk.cpp b/Graphics/Archiver/src/Archiver_Vk.cpp
@@ -131,6 +131,7 @@ void SerializedPipelineStateImpl::PatchShadersVk(const CreateInfoType& CreateInf
         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;
diff --git a/Graphics/GraphicsEngineVulkan/include/PipelineStateVkImpl.hpp b/Graphics/GraphicsEngineVulkan/include/PipelineStateVkImpl.hpp
@@ -86,6 +86,7 @@ class PipelineStateVkImpl final : public PipelineStateBase<EngineVkImplTraits>
 
         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; }
     };
@@ -136,8 +137,8 @@ class PipelineStateVkImpl final : public PipelineStateBase<EngineVkImplTraits>
     bool InitPushConstantInfoFromSignatures(PushConstantInfoVk& PushConstant,
                                             TShaderStages&      ShaderStages) const noexcept(false);
 
-    void PatchShaderConvertUniformBufferToPushConstant(TShaderStages&            ShaderStages,
-                                                       const PushConstantInfoVk& PushConstant) const noexcept(false);
+    void PatchShaderConvertUniformBufferToPushConstant(const PushConstantInfoVk&                    PushConstant,
+                                                       TShaderStages&                               ShaderStages) const noexcept(false);
 
     // TPipelineStateBase::Construct needs access to InitializePipeline
     friend TPipelineStateBase;
diff --git a/Graphics/GraphicsEngineVulkan/include/ShaderVkImpl.hpp b/Graphics/GraphicsEngineVulkan/include/ShaderVkImpl.hpp
@@ -110,9 +110,7 @@ class ShaderVkImpl final : public ShaderBase<EngineVkImplTraits>
         Size        = m_SPIRV.size() * sizeof(m_SPIRV[0]);
     }
 
-    void SetSPIRV(const std::vector<uint32_t>& SPIRV) noexcept(false);
-
-    void CreateSPIRVShaderResources() noexcept(false);
+    std::shared_ptr<const SPIRVShaderResources> CreateSPIRVShaderResources(const std::vector<uint32_t>& SPIRV) noexcept(false);
 
 private:
     void Initialize(const ShaderCreateInfo& ShaderCI,
diff --git a/Graphics/GraphicsEngineVulkan/src/PipelineStateVkImpl.cpp b/Graphics/GraphicsEngineVulkan/src/PipelineStateVkImpl.cpp
@@ -555,7 +555,8 @@ void VerifyResourceMerge(const char*                       PSOName,
 PipelineStateVkImpl::ShaderStageInfo::ShaderStageInfo(const ShaderVkImpl* pShader) :
     Type{pShader->GetDesc().ShaderType},
     Shaders{pShader},
-    SPIRVs{pShader->GetSPIRV()}
+    SPIRVs{pShader->GetSPIRV()},
+    ShaderResources{pShader->GetShaderResources()}
 {}
 
 void PipelineStateVkImpl::ShaderStageInfo::Append(const ShaderVkImpl* pShader)
@@ -578,6 +579,7 @@ void PipelineStateVkImpl::ShaderStageInfo::Append(const ShaderVkImpl* pShader)
     }
     Shaders.push_back(pShader);
     SPIRVs.push_back(pShader->GetSPIRV());
+    ShaderResources.push_back(pShader->GetShaderResources());
 }
 
 size_t PipelineStateVkImpl::ShaderStageInfo::Count() const
@@ -691,16 +693,19 @@ void PipelineStateVkImpl::RemapOrVerifyShaderResources(
     {
         const std::vector<const ShaderVkImpl*>& Shaders    = ShaderStages[s].Shaders;
         std::vector<std::vector<uint32_t>>&     SPIRVs     = ShaderStages[s].SPIRVs;
-        const SHADER_TYPE                       ShaderType = ShaderStages[s].Type;
+        const SHADER_TYPE                                         ShaderType      = ShaderStages[s].Type;
+        std::vector<std::shared_ptr<const SPIRVShaderResources>>& ShaderResources = ShaderStages[s].ShaderResources;
 
         VERIFY_EXPR(Shaders.size() == SPIRVs.size());
+        VERIFY_EXPR(Shaders.size() == ShaderResources.size());
 
         for (size_t i = 0; i < Shaders.size(); ++i)
         {
             const ShaderVkImpl*    pShader = Shaders[i];
             std::vector<uint32_t>& SPIRV   = SPIRVs[i];
+            const std::shared_ptr<const SPIRVShaderResources>& pShaderResources = ShaderResources[i];
 
-            const auto& pShaderResources = pShader->GetShaderResources();
+            //const auto& pShaderResources = pShader->GetShaderResources();
             VERIFY_EXPR(pShaderResources);
 
             if (pDvpShaderResources)
@@ -867,7 +872,7 @@ bool PipelineStateVkImpl::InitPushConstantInfoFromSignatures(PushConstantInfoVk&
                                 PushConstant.StageFlags |= ShaderTypeToVkShaderStageFlagBit(ShaderType);
                             }
 
-                            // Found push constant from SPIR-V, we're done
+                            // Found push constant from SPIR-V
                             return true;
                         }
                     }
@@ -904,7 +909,7 @@ bool PipelineStateVkImpl::InitPushConstantInfoFromSignatures(PushConstantInfoVk&
                     PushConstant.StageFlags |= ShaderTypeToVkShaderStageFlagBit(ShaderType);
                 }
 
-                // Found first inline constant, we're done
+                // Found first inline constant
                 return true;
             }
         }
@@ -937,7 +942,7 @@ void PipelineStateVkImpl::InitPipelineLayout(const PipelineStateCreateInfo& Crea
 
     // If we promoted an inline constant as push constant (not an existing SPIR-V push constant),
     // convert the uniform buffer to push constant in SPIRV bytecode.
-    PatchShaderConvertUniformBufferToPushConstant(ShaderStages, PushConstant);
+    PatchShaderConvertUniformBufferToPushConstant(PushConstant, ShaderStages);
 
     const bool RemapResources = (CreateInfo.Flags & PSO_CREATE_FLAG_DONT_REMAP_SHADER_RESOURCES) == 0;
     const bool VerifyBindings = !RemapResources && ((InternalFlags & PSO_CREATE_INTERNAL_FLAG_NO_SHADER_REFLECTION) == 0);
@@ -965,8 +970,8 @@ void PipelineStateVkImpl::InitPipelineLayout(const PipelineStateCreateInfo& Crea
     }
 }
 
-void PipelineStateVkImpl::PatchShaderConvertUniformBufferToPushConstant(TShaderStages&            ShaderStages,
-                                                                        const PushConstantInfoVk& PushConstantInfo) const noexcept(false)
+void PipelineStateVkImpl::PatchShaderConvertUniformBufferToPushConstant(const PushConstantInfoVk& PushConstantInfo, 
+                                                                        TShaderStages& ShaderStages) const noexcept(false)
 {
     // If no push constant was selected, no patching needed
     if (PushConstantInfo.SignatureIndex == INVALID_PUSH_CONSTANT_INDEX ||
@@ -987,43 +992,50 @@ void PipelineStateVkImpl::PatchShaderConvertUniformBufferToPushConstant(TShaderS
         for (size_t i = 0; i < Stage.Shaders.size(); ++i)
         {
             ShaderVkImpl*               pShader = const_cast<ShaderVkImpl*>(Stage.Shaders[i]);
-            const SPIRVShaderResources* pRes    = pShader->GetShaderResources().get();
-
-            if (pRes == nullptr)
-                continue;
 
             // First check if the shader already has this as push constant
             bool AlreadyPushConstant = false;
-            for (Uint32 pc = 0; pc < pRes->GetNumPushConstants(); ++pc)
+
+            // Check if this shader has a uniform buffer with the push constant name
+            bool ShouldPatchUniformBuffer = false;
             {
-                const SPIRVShaderResourceAttribs& PCAttribs = pRes->GetPushConstant(pc);
-                if (PCAttribs.Name == PushConstantName)
+                const SPIRVShaderResources* pShaderRes = pShader->GetShaderResources().get();
+
+                if (pShaderRes == nullptr)
+                    continue;
+
+                for (Uint32 pc = 0; pc < pShaderRes->GetNumPushConstants(); ++pc)
+                {
+                    const SPIRVShaderResourceAttribs& PCAttribs = pShaderRes->GetPushConstant(pc);
+                    if (PCAttribs.Name == PushConstantName)
+                    {
+                        AlreadyPushConstant = true;
+                        break;
+                    }
+                }
+
+                if (!AlreadyPushConstant)
                 {
-                    AlreadyPushConstant = true;
-                    break;
+                    for (Uint32 ub = 0; ub < pShaderRes->GetNumUBs(); ++ub)
+                    {
+                        const SPIRVShaderResourceAttribs& UBAttribs = pShaderRes->GetUB(ub);
+                        if (UBAttribs.Name == PushConstantName)
+                        {
+                            ShouldPatchUniformBuffer = true;
+                            break;
+                        }
+                    }
                 }
             }
 
             // If already push constant, no conversion needed
             if (AlreadyPushConstant)
                 continue;
 
-            // Check if this shader has a uniform buffer with the push constant name
-            bool ShouldPatchUniformBuffer = false;
-
-            for (Uint32 ub = 0; ub < pRes->GetNumUBs(); ++ub)
-            {
-                const SPIRVShaderResourceAttribs& UBAttribs = pRes->GetUB(ub);
-                if (UBAttribs.Name == PushConstantName)
-                {
-                    ShouldPatchUniformBuffer = true;
-                    break;
-                }
-            }
-
             if (ShouldPatchUniformBuffer)
             {
                 const std::vector<uint32_t>& SPIRV        = Stage.SPIRVs[i];
+
                 std::vector<uint32_t>        PatchedSPIRV = PatchSPIRVConvertUniformBufferToPushConstant(
                     SPIRV,
                     SPV_ENV_MAX, // Auto-detect target environment
@@ -1032,11 +1044,7 @@ void PipelineStateVkImpl::PatchShaderConvertUniformBufferToPushConstant(TShaderS
                 if (!PatchedSPIRV.empty())
                 {
                     Stage.SPIRVs[i] = PatchedSPIRV;
-
-                    pShader->SetSPIRV(PatchedSPIRV);
-
-                    // Reconstruct shader resources from SPIRV
-                    pShader->CreateSPIRVShaderResources();
+                    Stage.ShaderResources[i] = pShader->CreateSPIRVShaderResources(PatchedSPIRV);
                 }
                 else
                 {
diff --git a/Graphics/GraphicsEngineVulkan/src/ShaderVkImpl.cpp b/Graphics/GraphicsEngineVulkan/src/ShaderVkImpl.cpp
@@ -235,7 +235,12 @@ void ShaderVkImpl::Initialize(const ShaderCreateInfo& ShaderCI,
     {
         if ((ShaderCI.CompileFlags & SHADER_COMPILE_FLAG_SKIP_REFLECTION) == 0)
         {
-            CreateSPIRVShaderResources();
+            m_pShaderResources = CreateSPIRVShaderResources(m_SPIRV);
+
+            if (m_Desc.ShaderType == SHADER_TYPE_VERTEX && m_pShaderResources->IsHLSLSource())
+            {
+                m_pShaderResources->MapHLSLVertexShaderInputs(m_SPIRV);
+            }
 
             VERIFY_EXPR(ShaderCI.ByteCode != nullptr || m_EntryPoint == ShaderCI.EntryPoint ||
                         (m_EntryPoint == "main" && (ShaderCI.CompileFlags & SHADER_COMPILE_FLAG_HLSL_TO_SPIRV_VIA_GLSL) != 0));
@@ -249,37 +254,30 @@ void ShaderVkImpl::Initialize(const ShaderCreateInfo& ShaderCI,
     }
 }
 
-void ShaderVkImpl::SetSPIRV(const std::vector<uint32_t>& SPIRV) noexcept(false)
-{
-    m_SPIRV = SPIRV;
-}
-
-void ShaderVkImpl::CreateSPIRVShaderResources() noexcept(false)
+std::shared_ptr<const SPIRVShaderResources> ShaderVkImpl::CreateSPIRVShaderResources(const std::vector<uint32_t>& SPIRV) noexcept(false)
 {
     IMemoryAllocator& Allocator = GetRawAllocator();
 
     std::unique_ptr<void, STDDeleterRawMem<void>> pRawMem{
         ALLOCATE(Allocator, "Memory for SPIRVShaderResources", SPIRVShaderResources, 1),
         STDDeleterRawMem<void>(Allocator),
     };
-    const bool LoadShaderInputs = m_Desc.ShaderType == SHADER_TYPE_VERTEX;
     new (pRawMem.get()) SPIRVShaderResources // May throw
         {
             Allocator,
-            m_SPIRV,
+            SPIRV,
             m_Desc,
             m_Desc.UseCombinedTextureSamplers ? m_Desc.CombinedSamplerSuffix : nullptr,
-            LoadShaderInputs,
+            m_Desc.ShaderType == SHADER_TYPE_VERTEX ? true : false,
             m_LoadConstantBufferReflection,
             m_EntryPoint //
         };
 
-    m_pShaderResources.reset(static_cast<SPIRVShaderResources*>(pRawMem.release()), STDDeleterRawMem<SPIRVShaderResources>(Allocator));
+    std::shared_ptr<const SPIRVShaderResources> pShaderResources;
 
-    if (LoadShaderInputs && m_pShaderResources->IsHLSLSource())
-    {
-        m_pShaderResources->MapHLSLVertexShaderInputs(m_SPIRV);
-    }
+    pShaderResources.reset(static_cast<SPIRVShaderResources*>(pRawMem.release()), STDDeleterRawMem<SPIRVShaderResources>(Allocator));
+
+    return pShaderResources;
 }
 
 ShaderVkImpl::ShaderVkImpl(IReferenceCounters*     pRefCounters,
diff --git a/Graphics/ShaderTools/src/SPIRVTools.cpp b/Graphics/ShaderTools/src/SPIRVTools.cpp
@@ -170,10 +170,16 @@ std::vector<uint32_t> PatchSPIRVConvertUniformBufferToPushConstant(
 
     // Register the pass to convert UBO to push constant
     optimizer.RegisterPass(spvtools::CreateConvertUBOToPushConstantPass(BlockName));
+    //optimizer.RegisterPass(spvtools::CreateDeadVariableEliminationPass());
+    //optimizer.RegisterPerformancePasses();
 
     spvtools::OptimizerOptions options;
 #ifndef DILIGENT_DEVELOPMENT
+    // Do not run validator in release build
     options.set_run_validator(false);
+#else
+    // Run validator in debug build
+    options.set_run_validator(true);
 #endif
 
     std::vector<uint32_t> result;

Original file line number	Diff line number	Diff line change
`@@ -131,6 +131,7 @@ void SerializedPipelineStateImpl::PatchShadersVk(const CreateInfoType& CreateInf`
`131`	`131`	`Dst.Type = Src.Type;`
`132`	`132`	`Dst.Shaders = std::move(Src.Shaders);`
`133`	`133`	`Dst.SPIRVs = std::move(Src.SPIRVs);`
	`134`	`+ Dst.ShaderResources = std::move(Src.ShaderResources);`
`134`	`135`	`}`
`135`	`136`
`136`	`137`	`IPipelineResourceSignature** ppSignatures = CreateInfo.ppResourceSignatures;`
Original file line number	Diff line number	Diff line change
`@@ -110,9 +110,7 @@ class ShaderVkImpl final : public ShaderBase<EngineVkImplTraits>`
`110`	`110`	`Size = m_SPIRV.size() * sizeof(m_SPIRV[0]);`
`111`	`111`	`}`
`112`	`112`
`113`		`- void SetSPIRV(const std::vector<uint32_t>& SPIRV) noexcept(false);`
`114`		`-`
`115`		`- void CreateSPIRVShaderResources() noexcept(false);`
	`113`	`+ std::shared_ptr<const SPIRVShaderResources> CreateSPIRVShaderResources(const std::vector<uint32_t>& SPIRV) noexcept(false);`
`116`	`114`
`117`	`115`	`private:`
`118`	`116`	`void Initialize(const ShaderCreateInfo& ShaderCI,`