Pipeline state and resource signature: added CopyStaticResources method (API252008)

Author: TheMostDiligent

Graphics/Archiver/include/SerializedPipelineStateImpl.hpp

@@ -82,6 +82,7 @@ class SerializedPipelineStateImpl final : public ObjectBase<ISerializedPipelineS
 
     UNSUPPORTED_METHOD      (void, CreateShaderResourceBinding,  IShaderResourceBinding** ppShaderResourceBinding, bool InitStaticResources)
     UNSUPPORTED_CONST_METHOD(void, InitializeStaticSRBResources, IShaderResourceBinding* pShaderResourceBinding)
+    UNSUPPORTED_CONST_METHOD(void, CopyStaticResources,          IPipelineState* pPSO)
     UNSUPPORTED_CONST_METHOD(bool, IsCompatibleWith,             const IPipelineState* pPSO)
 
     UNSUPPORTED_CONST_METHOD(Uint32,                      GetResourceSignatureCount)

Graphics/Archiver/include/SerializedResourceSignatureImpl.hpp

@@ -74,6 +74,7 @@ class SerializedResourceSignatureImpl final : public ObjectBase<IPipelineResourc
     UNSUPPORTED_METHOD      (IShaderResourceVariable*, GetStaticVariableByIndex, SHADER_TYPE ShaderType, Uint32 Index)
     UNSUPPORTED_CONST_METHOD(Uint32,   GetStaticVariableCount,       SHADER_TYPE ShaderType)
     UNSUPPORTED_CONST_METHOD(void,     InitializeStaticSRBResources, IShaderResourceBinding* pShaderResourceBinding)
+    UNSUPPORTED_CONST_METHOD(void,     CopyStaticResources,          IPipelineResourceSignature* pPRS)
     UNSUPPORTED_CONST_METHOD(bool,     IsCompatibleWith,             const IPipelineResourceSignature* pPRS)
     UNSUPPORTED_CONST_METHOD(Int32,    GetUniqueID)
     UNSUPPORTED_METHOD      (void,     SetUserData, IObject* pUserData)

Graphics/GraphicsEngine/include/PipelineResourceSignatureBase.hpp

@@ -523,6 +523,33 @@ class PipelineResourceSignatureBase : public DeviceObjectBase<typename EngineImp
         pSRBImpl->SetStaticResourcesInitialized();
     }
 
+    /// Implementation of IPipelineResourceSignature::CopyStaticResources.
+    virtual void DILIGENT_CALL_TYPE CopyStaticResources(IPipelineResourceSignature* pDstSignature) const override final
+    {
+        if (pDstSignature == nullptr)
+        {
+            DEV_ERROR("Destination signature must not be null");
+            return;
+        }
+
+        if (pDstSignature == this)
+        {
+            DEV_ERROR("Source and destination signatures must be different");
+            return;
+        }
+
+        const auto* const pThisImpl    = static_cast<const PipelineResourceSignatureImplType*>(this);
+        auto* const       pDstSignImpl = static_cast<const PipelineResourceSignatureImplType*>(pDstSignature);
+        if (!pDstSignImpl->IsCompatibleWith(pThisImpl))
+        {
+            LOG_ERROR_MESSAGE("Can't copy static resources: destination pipeline resource signature '", pDstSignImpl->m_Desc.Name,
+                              "' is not compatible with the source signature '", pThisImpl->m_Desc.Name, "'.");
+            return;
+        }
+
+        pThisImpl->CopyStaticResources(*pDstSignImpl->m_pStaticResCache);
+    }
+
     /// Implementation of IPipelineResourceSignature::IsCompatibleWith.
     virtual bool DILIGENT_CALL_TYPE IsCompatibleWith(const IPipelineResourceSignature* pPRS) const override final
     {

Graphics/GraphicsEngine/include/PipelineStateBase.hpp

@@ -460,6 +460,31 @@ class PipelineStateBase : public DeviceObjectBase<typename EngineImplTraits::Pip
         return this->GetResourceSignature(0)->InitializeStaticSRBResources(pSRB);
     }
 
+    virtual void DILIGENT_CALL_TYPE CopyStaticResources(IPipelineState* pDstPipeline) const override final
+    {
+        if (pDstPipeline == nullptr)
+        {
+            DEV_ERROR("Destination pipeline must not be null");
+            return;
+        }
+
+        if (pDstPipeline == this)
+        {
+            DEV_ERROR("Source and destination pipelines must be different");
+            return;
+        }
+
+        if (!m_UsingImplicitSignature)
+        {
+            LOG_ERROR_MESSAGE("IPipelineState::CopyStaticResources is not allowed for pipelines that use explicit "
+                              "resource signatures. Use IPipelineResourceSignature::CopyStaticResources instead.");
+            return;
+        }
+
+        auto* pDstSign = static_cast<PipelineStateImplType*>(pDstPipeline)->GetResourceSignature(0);
+        return this->GetResourceSignature(0)->CopyStaticResources(pDstSign);
+    }
+
     /// Implementation of IPipelineState::GetResourceSignatureCount().
     virtual Uint32 DILIGENT_CALL_TYPE GetResourceSignatureCount() const override final
     {

Graphics/GraphicsEngine/interface/APIInfo.h

@@ -30,7 +30,7 @@
 /// \file
 /// Diligent API information
 
-#define DILIGENT_API_VERSION 252007
+#define DILIGENT_API_VERSION 252008
 
 #include "../../../Primitives/interface/BasicTypes.h"
 

Graphics/GraphicsEngine/interface/PipelineResourceSignature.h

@@ -408,6 +408,14 @@ DILIGENT_BEGIN_INTERFACE(IPipelineResourceSignature, IDeviceObject)
     VIRTUAL void METHOD(InitializeStaticSRBResources)(THIS_
                                                       struct IShaderResourceBinding* pShaderResourceBinding) CONST PURE;
 
+    /// Copies static resource bindings to the destination signature.
+
+    /// \param [in] pDstSignature - Destination pipeline resource signature.
+    ///
+    /// \note   Destination signature must be compatible with this signature.
+    VIRTUAL void METHOD(CopyStaticResources)(THIS_
+                                             IPipelineResourceSignature* pDstSignature) CONST PURE;
+
     /// Returns true if the signature is compatible with another one.
 
     /// \remarks    Two signatures are compatible if they contain identical resources and immutabke samplers,
@@ -431,6 +439,7 @@ DILIGENT_END_INTERFACE
 #    define IPipelineResourceSignature_GetStaticVariableByIndex(This, ...)     CALL_IFACE_METHOD(PipelineResourceSignature, GetStaticVariableByIndex,    This, __VA_ARGS__)
 #    define IPipelineResourceSignature_GetStaticVariableCount(This, ...)       CALL_IFACE_METHOD(PipelineResourceSignature, GetStaticVariableCount,      This, __VA_ARGS__)
 #    define IPipelineResourceSignature_InitializeStaticSRBResources(This, ...) CALL_IFACE_METHOD(PipelineResourceSignature, InitializeStaticSRBResources,This, __VA_ARGS__)
+#    define IPipelineResourceSignature_CopyStaticResources(This, ...)          CALL_IFACE_METHOD(PipelineResourceSignature, CopyStaticResources,         This, __VA_ARGS__)
 #    define IPipelineResourceSignature_IsCompatibleWith(This, ...)             CALL_IFACE_METHOD(PipelineResourceSignature, IsCompatibleWith,            This, __VA_ARGS__)
 
 // clang-format on

Graphics/GraphicsEngine/interface/PipelineState.h

@@ -1094,6 +1094,20 @@ DILIGENT_BEGIN_INTERFACE(IPipelineState, IDeviceObject)
                                                       struct IShaderResourceBinding* pShaderResourceBinding) CONST PURE;
 
 
+    /// Copies static resource bindings to the destination pipeline.
+
+    /// \param [in] pDstPipeline - Destination pipeline state.
+    ///
+    /// \note   Destination pipeline state must be compatible with this pipeline.
+    ///
+    /// \remarks    This method is only allowed for pipelines that use implicit resource signature
+    ///             (e.g. shader resources are defined through ResourceLayout member of the pipeline desc).
+    ///             For pipelines that use explicit resource signatures, use
+    ///             IPipelineResourceSignature::CopyStaticResources() method.
+    VIRTUAL void METHOD(CopyStaticResources)(THIS_
+                                             IPipelineState* pDstPipeline) CONST PURE;
+
+
     /// Checks if this pipeline state object is compatible with another PSO
 
     /// If two pipeline state objects are compatible, they can use shader resource binding
@@ -1155,6 +1169,7 @@ DILIGENT_END_INTERFACE
 #    define IPipelineState_GetStaticVariableByIndex(This, ...)     CALL_IFACE_METHOD(PipelineState, GetStaticVariableByIndex,     This, __VA_ARGS__)
 #    define IPipelineState_CreateShaderResourceBinding(This, ...)  CALL_IFACE_METHOD(PipelineState, CreateShaderResourceBinding,  This, __VA_ARGS__)
 #    define IPipelineState_InitializeStaticSRBResources(This, ...) CALL_IFACE_METHOD(PipelineState, InitializeStaticSRBResources, This, __VA_ARGS__)
+#    define IPipelineState_CopyStaticResources(This, ...)          CALL_IFACE_METHOD(PipelineState, CopyStaticResources,          This, __VA_ARGS__)
 #    define IPipelineState_IsCompatibleWith(This, ...)             CALL_IFACE_METHOD(PipelineState, IsCompatibleWith,             This, __VA_ARGS__)
 #    define IPipelineState_GetResourceSignatureCount(This)         CALL_IFACE_METHOD(PipelineState, GetResourceSignatureCount,    This)
 #    define IPipelineState_GetResourceSignature(This, ...)         CALL_IFACE_METHOD(PipelineState, GetResourceSignature,         This, __VA_ARGS__)

Graphics/GraphicsEngineD3D11/include/PipelineResourceSignatureD3D11Impl.hpp

@@ -126,6 +126,8 @@ class PipelineResourceSignatureD3D11Impl final : public PipelineResourceSignatur
 
     // Copies static resources from the static resource cache to the destination cache
     void CopyStaticResources(ShaderResourceCacheD3D11& ResourceCache) const;
+    // Make the base class method visible
+    using TPipelineResourceSignatureBase::CopyStaticResources;
 
     PipelineResourceSignatureInternalDataD3D11 GetInternalData() const;
 

Graphics/GraphicsEngineD3D11/include/ShaderResourceCacheD3D11.hpp

@@ -767,13 +767,17 @@ bool ShaderResourceCacheD3D11::CopyResource(const ShaderResourceCacheD3D11& SrcC
         const Uint32 Binding = BindPoints[ShaderInd];
         VERIFY(Binding < GetResourceCount<ResRange>(ShaderInd), "Index is out of range");
         VERIFY(Binding < SrcCache.GetResourceCount<ResRange>(ShaderInd), "Index is out of range");
-        if (!SrcResArrays.first[Binding])
-            IsBound = false;
-
-        DstResArrays.first[Binding]  = SrcResArrays.first[Binding];
-        DstResArrays.second[Binding] = SrcResArrays.second[Binding];
+        if (SrcResArrays.first[Binding])
+        {
+            DstResArrays.first[Binding]  = SrcResArrays.first[Binding];
+            DstResArrays.second[Binding] = SrcResArrays.second[Binding];
 
-        UpdateDynamicCBOffsetFlag<ResRange>(DstResArrays.first[Binding], ShaderInd, Binding);
+            UpdateDynamicCBOffsetFlag<ResRange>(DstResArrays.first[Binding], ShaderInd, Binding);
+        }
+        else if (!DstResArrays.first[Binding])
+        {
+            IsBound = false;
+        }
     }
 
     this->UpdateRevision();

Graphics/GraphicsEngineD3D11/src/PipelineResourceSignatureD3D11Impl.cpp

@@ -292,10 +292,11 @@ void PipelineResourceSignatureD3D11Impl::CopyStaticResources(ShaderResourceCache
         return;
 
     // SrcResourceCache contains only static resources.
-    // DstResourceCache contains static, mutable and dynamic resources.
+    // In case of SRB, DstResourceCache contains static, mutable and dynamic resources.
+    // In case of Signature, DstResourceCache contains only static resources.
     const auto& SrcResourceCache = *m_pStaticResCache;
     VERIFY_EXPR(SrcResourceCache.GetContentType() == ResourceCacheContentType::Signature);
-    VERIFY_EXPR(DstResourceCache.GetContentType() == ResourceCacheContentType::SRB);
+    const auto DstCacheType = DstResourceCache.GetContentType();
 
     const auto ResIdxRange = GetResourceIndexRange(SHADER_RESOURCE_VARIABLE_TYPE_STATIC);
     for (Uint32 r = ResIdxRange.first; r < ResIdxRange.second; ++r)
@@ -311,14 +312,20 @@ void PipelineResourceSignatureD3D11Impl::CopyStaticResources(ShaderResourceCache
                 for (Uint32 ArrInd = 0; ArrInd < ResDesc.ArraySize; ++ArrInd)
                 {
                     if (!DstResourceCache.CopyResource<D3D11_RESOURCE_RANGE_CBV>(SrcResourceCache, ResAttr.BindPoints + ArrInd))
-                        LOG_ERROR_MESSAGE("No resource is assigned to static shader variable '", GetShaderResourcePrintName(ResDesc, ArrInd), "' in pipeline resource signature '", m_Desc.Name, "'.");
+                    {
+                        if (DstCacheType == ResourceCacheContentType::SRB)
+                            LOG_ERROR_MESSAGE("No resource is assigned to static shader variable '", GetShaderResourcePrintName(ResDesc, ArrInd), "' in pipeline resource signature '", m_Desc.Name, "'.");
+                    }
                 }
                 break;
             case D3D11_RESOURCE_RANGE_SRV:
                 for (Uint32 ArrInd = 0; ArrInd < ResDesc.ArraySize; ++ArrInd)
                 {
                     if (!DstResourceCache.CopyResource<D3D11_RESOURCE_RANGE_SRV>(SrcResourceCache, ResAttr.BindPoints + ArrInd))
-                        LOG_ERROR_MESSAGE("No resource is assigned to static shader variable '", GetShaderResourcePrintName(ResDesc, ArrInd), "' in pipeline resource signature '", m_Desc.Name, "'.");
+                    {
+                        if (DstCacheType == ResourceCacheContentType::SRB)
+                            LOG_ERROR_MESSAGE("No resource is assigned to static shader variable '", GetShaderResourcePrintName(ResDesc, ArrInd), "' in pipeline resource signature '", m_Desc.Name, "'.");
+                    }
                 }
                 break;
             case D3D11_RESOURCE_RANGE_SAMPLER:
@@ -327,11 +334,14 @@ void PipelineResourceSignatureD3D11Impl::CopyStaticResources(ShaderResourceCache
                     for (Uint32 ArrInd = 0; ArrInd < ResDesc.ArraySize; ++ArrInd)
                     {
                         if (!DstResourceCache.CopyResource<D3D11_RESOURCE_RANGE_SAMPLER>(SrcResourceCache, ResAttr.BindPoints + ArrInd))
-                            LOG_ERROR_MESSAGE("No resource is assigned to static shader variable '", GetShaderResourcePrintName(ResDesc, ArrInd), "' in pipeline resource signature '", m_Desc.Name, "'.");
+                        {
+                            if (DstCacheType == ResourceCacheContentType::SRB)
+                                LOG_ERROR_MESSAGE("No resource is assigned to static shader variable '", GetShaderResourcePrintName(ResDesc, ArrInd), "' in pipeline resource signature '", m_Desc.Name, "'.");
+                        }
                     }
                 }
 #ifdef DILIGENT_DEBUG
-                else
+                else if (DstCacheType == ResourceCacheContentType::SRB)
                 {
                     for (Uint32 ArrInd = 0; ArrInd < ResDesc.ArraySize; ++ArrInd)
                     {
@@ -345,7 +355,10 @@ void PipelineResourceSignatureD3D11Impl::CopyStaticResources(ShaderResourceCache
                 for (Uint32 ArrInd = 0; ArrInd < ResDesc.ArraySize; ++ArrInd)
                 {
                     if (!DstResourceCache.CopyResource<D3D11_RESOURCE_RANGE_UAV>(SrcResourceCache, ResAttr.BindPoints + ArrInd))
-                        LOG_ERROR_MESSAGE("No resource is assigned to static shader variable '", GetShaderResourcePrintName(ResDesc, ArrInd), "' in pipeline resource signature '", m_Desc.Name, "'.");
+                    {
+                        if (DstCacheType == ResourceCacheContentType::SRB)
+                            LOG_ERROR_MESSAGE("No resource is assigned to static shader variable '", GetShaderResourcePrintName(ResDesc, ArrInd), "' in pipeline resource signature '", m_Desc.Name, "'.");
+                    }
                 }
                 break;
             default: