Render state cache: reworked reload callback to handle graphics pipeline desc

TheMostDiligent · TheMostDiligent · commit cf8eb68dd957 · 2022-10-30T22:51:10.000-07:00
diff --git a/Graphics/GraphicsTools/interface/RenderStateCache.h b/Graphics/GraphicsTools/interface/RenderStateCache.h
@@ -78,7 +78,7 @@ typedef struct RenderStateCacheCreateInfo RenderStateCacheCreateInfo;
 #endif
 
 /// Type of the callback function called by the IRenderStateCache::Reload method.
-typedef void(DILIGENT_CALL_TYPE* ModifyPipelineReloadInfoCallbackType)(PipelineStateCreateInfo REF CreateInfo, void* pUserData);
+typedef void(DILIGENT_CALL_TYPE* ReloadGraphicsPipelineCallbackType)(const char* PipelineName, GraphicsPipelineDesc REF GraphicsDesc, void* pUserData);
 
 #undef REF
 
@@ -188,22 +188,18 @@ DILIGENT_BEGIN_INTERFACE(IRenderStateCache, IObject)
 
     /// Reloads render states in the cache.
 
-    /// \param [in]  ModifyReloadInfo - An optional callback function that will be called by the render state cache
-    ///                                 to let the application modify pipeline state create info before creating new
-    ///                                 pipeline.
-    /// \param [in]  pUserData        - A pointer to user-specific data to pass to ModifyReloadInfo callback.
+    /// \param [in]  ReloadGraphicsPipeline - An optional callback function that will be called by the render state cache
+    ///                                       to let the application modify graphics pipeline state info before creating new
+    ///                                       pipeline.
+    /// \param [in]  pUserData              - A pointer to the user-specific data to pass to ReloadGraphicsPipeline callback.
     ///
     /// \return     The total number of render states (shaders and pipelines) that were reloaded.
     ///
     /// \remars     Reloading is only enabled if the cache was created with the EnableHotReload member of
     ///             RenderStateCacheCreateInfo member set to true.
-    ///
-    ///             ModifyReloadInfo callback is not allowed to modify shaders, resource layout or pipeline resource
-    ///             signatures. Its main use is to modify the graphics states of a graphics pipeline (blend state,
-    ///             rasterizer state, depth state, etc.).
     VIRTUAL Uint32 METHOD(Reload)(THIS_
-                                  ModifyPipelineReloadInfoCallbackType ModifyReloadInfo DEFAULT_VALUE(nullptr), 
-                                  void*                                pUserData        DEFAULT_VALUE(nullptr)) PURE;
+                                  ReloadGraphicsPipelineCallbackType ReloadGraphicsPipeline DEFAULT_VALUE(nullptr), 
+                                  void*                              pUserData              DEFAULT_VALUE(nullptr)) PURE;
 };
 DILIGENT_END_INTERFACE
 
diff --git a/Graphics/GraphicsTools/src/RenderStateCache.cpp b/Graphics/GraphicsTools/src/RenderStateCache.cpp
@@ -222,11 +222,11 @@ class ReloadablePipelineState final : public ObjectBase<IPipelineState>
         }
     }
 
-    bool Reload(ModifyPipelineReloadInfoCallbackType ModifyReloadInfo, void* pUserData);
+    bool Reload(ReloadGraphicsPipelineCallbackType ReloadGraphicsPipeline, void* pUserData);
 
 private:
     template <typename CreateInfoType>
-    bool Reload(ModifyPipelineReloadInfoCallbackType ModifyReloadInfo, void* pUserData);
+    bool Reload(ReloadGraphicsPipelineCallbackType ReloadGraphicsPipeline, void* pUserData);
 
     struct DynamicHeapObjectBase
     {
@@ -341,7 +341,7 @@ class RenderStateCacheImpl final : public ObjectBase<IRenderStateCache>
         m_Pipelines.clear();
     }
 
-    virtual Uint32 DILIGENT_CALL_TYPE Reload(ModifyPipelineReloadInfoCallbackType ModifyReloadInfo, void* pUserData) override final;
+    virtual Uint32 DILIGENT_CALL_TYPE Reload(ReloadGraphicsPipelineCallbackType ReloadGraphicsPipeline, void* pUserData) override final;
 
     bool CreateShaderInternal(const ShaderCreateInfo& ShaderCI,
                               IShader**               ppShader);
@@ -1097,7 +1097,7 @@ bool RenderStateCacheImpl::CreatePipelineStateInternal(const CreateInfoType& PSO
     return false;
 }
 
-Uint32 RenderStateCacheImpl::Reload(ModifyPipelineReloadInfoCallbackType ModifyReloadInfo, void* pUserData)
+Uint32 RenderStateCacheImpl::Reload(ReloadGraphicsPipelineCallbackType ReloadGraphicsPipeline, void* pUserData)
 {
     if (!m_CI.EnableHotReload)
     {
@@ -1136,7 +1136,7 @@ Uint32 RenderStateCacheImpl::Reload(ModifyPipelineReloadInfoCallbackType ModifyR
                 RefCntAutoPtr<ReloadablePipelineState> pReloadablePSO{pPSO, ReloadablePipelineState::IID_InternalImpl};
                 if (pPSO)
                 {
-                    if (pReloadablePSO->Reload(ModifyReloadInfo, pUserData))
+                    if (pReloadablePSO->Reload(ReloadGraphicsPipeline, pUserData))
                         ++NumStatesReloaded;
                 }
                 else
@@ -1193,7 +1193,12 @@ struct ReloadablePipelineState::CreateInfoWrapperBase : DynamicHeapObjectBase
         return m_CI;
     }
 
-    operator const CreateInfoType&()
+    operator const CreateInfoType&() const
+    {
+        return m_CI;
+    }
+
+    operator CreateInfoType&()
     {
         return m_CI;
     }
@@ -1354,22 +1359,28 @@ ReloadablePipelineState::ReloadablePipelineState(IReferenceCounters*
 }
 
 template <typename CreateInfoType>
-bool ReloadablePipelineState::Reload(ModifyPipelineReloadInfoCallbackType ModifyReloadInfo, void* pUserData)
+void ModifyPsoCreateInfo(CreateInfoType& PsoCreateInfo, ReloadGraphicsPipelineCallbackType ReloadGraphicsPipeline, void* pUserData)
 {
-    const auto& CreateInfo = static_cast<const CreateInfoWrapper<CreateInfoType>&>(*m_pCreateInfo).Get();
+}
 
-    RefCntAutoPtr<IPipelineState> pNewPSO;
-    bool                          FoundInCache = false;
-    if (ModifyReloadInfo != nullptr)
-    {
-        auto _CreateInfo = CreateInfo;
-        ModifyReloadInfo(_CreateInfo, pUserData);
-        FoundInCache = m_pStateCache->CreatePipelineStateInternal(_CreateInfo, &pNewPSO);
-    }
-    else
+template <>
+void ModifyPsoCreateInfo(GraphicsPipelineStateCreateInfo& PsoCreateInfo, ReloadGraphicsPipelineCallbackType ReloadGraphicsPipeline, void* pUserData)
+{
+    if (ReloadGraphicsPipeline != nullptr)
     {
-        FoundInCache = m_pStateCache->CreatePipelineStateInternal(CreateInfo, &pNewPSO);
+        ReloadGraphicsPipeline(PsoCreateInfo.PSODesc.Name, PsoCreateInfo.GraphicsPipeline, pUserData);
     }
+}
+
+template <typename CreateInfoType>
+bool ReloadablePipelineState::Reload(ReloadGraphicsPipelineCallbackType ReloadGraphicsPipeline, void* pUserData)
+{
+    auto& CreateInfo = static_cast<CreateInfoWrapper<CreateInfoType>&>(*m_pCreateInfo);
+    ModifyPsoCreateInfo<CreateInfoType>(static_cast<CreateInfoType&>(CreateInfo), ReloadGraphicsPipeline, pUserData);
+
+    RefCntAutoPtr<IPipelineState> pNewPSO;
+
+    const auto FoundInCache = m_pStateCache->CreatePipelineStateInternal(static_cast<const CreateInfoType&>(CreateInfo), &pNewPSO);
 
     if (pNewPSO)
     {
@@ -1381,14 +1392,14 @@ bool ReloadablePipelineState::Reload(ModifyPipelineReloadInfoCallbackType Modify
     }
     else
     {
-        const auto* Name = CreateInfo.PSODesc.Name;
+        const auto* Name = CreateInfo.Get().PSODesc.Name;
         LOG_ERROR_MESSAGE("Failed to reload pipeline state '", (Name ? Name : "<unnamed>"), "'.");
     }
     return !FoundInCache;
 }
 
 
-bool ReloadablePipelineState::Reload(ModifyPipelineReloadInfoCallbackType ModifyReloadInfo, void* pUserData)
+bool ReloadablePipelineState::Reload(ReloadGraphicsPipelineCallbackType ReloadGraphicsPipeline, void* pUserData)
 {
     static_assert(PIPELINE_TYPE_COUNT == 5, "Did you add a new pipeline type? You may need to handle it here.");
     // Note that all shaders in Create Info are reloadable shaders, so they will automatically redirect all calls
@@ -1397,16 +1408,16 @@ bool ReloadablePipelineState::Reload(ModifyPipelineReloadInfoCallbackType Modify
     {
         case PIPELINE_TYPE_GRAPHICS:
         case PIPELINE_TYPE_MESH:
-            return Reload<GraphicsPipelineStateCreateInfo>(ModifyReloadInfo, pUserData);
+            return Reload<GraphicsPipelineStateCreateInfo>(ReloadGraphicsPipeline, pUserData);
 
         case PIPELINE_TYPE_COMPUTE:
-            return Reload<ComputePipelineStateCreateInfo>(ModifyReloadInfo, pUserData);
+            return Reload<ComputePipelineStateCreateInfo>(ReloadGraphicsPipeline, pUserData);
 
         case PIPELINE_TYPE_RAY_TRACING:
-            return Reload<RayTracingPipelineStateCreateInfo>(ModifyReloadInfo, pUserData);
+            return Reload<RayTracingPipelineStateCreateInfo>(ReloadGraphicsPipeline, pUserData);
 
         case PIPELINE_TYPE_TILE:
-            return Reload<TilePipelineStateCreateInfo>(ModifyReloadInfo, pUserData);
+            return Reload<TilePipelineStateCreateInfo>(ReloadGraphicsPipeline, pUserData);
 
         default:
             UNEXPECTED("Unexpected pipeline type");
diff --git a/Tests/DiligentCoreAPITest/src/RenderStateCacheTest.cpp b/Tests/DiligentCoreAPITest/src/RenderStateCacheTest.cpp
@@ -1062,11 +1062,9 @@ void TestPipelineReload(bool UseRenderPass, bool CreateSrbBeforeReload = false)
         }
 
         auto ModifyPSO = MakeCallback(
-            [&](PipelineStateCreateInfo& CreateInfo) {
-                ASSERT_STREQ(CreateInfo.PSODesc.Name, PSOName);
-                auto& GraphicsPsoCI = static_cast<GraphicsPipelineStateCreateInfo&>(CreateInfo);
-
-                GraphicsPsoCI.GraphicsPipeline.PrimitiveTopology = PRIMITIVE_TOPOLOGY_TRIANGLE_LIST;
+            [&](const char* PipelineName, GraphicsPipelineDesc& GraphicsPipeline) {
+                ASSERT_STREQ(PipelineName, PSOName);
+                GraphicsPipeline.PrimitiveTopology = PRIMITIVE_TOPOLOGY_TRIANGLE_LIST;
             });
 
         EXPECT_EQ(pCache->Reload(ModifyPSO, ModifyPSO), pass == 0 ? 3u : 0u);

Original file line number	Diff line number	Diff line change
`@@ -222,11 +222,11 @@ class ReloadablePipelineState final : public ObjectBase<IPipelineState>`
`222`	`222`	`}`
`223`	`223`	`}`
`224`	`224`
`225`		`- bool Reload(ModifyPipelineReloadInfoCallbackType ModifyReloadInfo, void* pUserData);`
	`225`	`+ bool Reload(ReloadGraphicsPipelineCallbackType ReloadGraphicsPipeline, void* pUserData);`
`226`	`226`
`227`	`227`	`private:`
`228`	`228`	`template <typename CreateInfoType>`
`229`		`- bool Reload(ModifyPipelineReloadInfoCallbackType ModifyReloadInfo, void* pUserData);`
	`229`	`+ bool Reload(ReloadGraphicsPipelineCallbackType ReloadGraphicsPipeline, void* pUserData);`
`230`	`230`
`231`	`231`	`struct DynamicHeapObjectBase`
`232`	`232`	`{`
`@@ -341,7 +341,7 @@ class RenderStateCacheImpl final : public ObjectBase<IRenderStateCache>`
`341`	`341`	`m_Pipelines.clear();`
`342`	`342`	`}`
`343`	`343`
`344`		`- virtual Uint32 DILIGENT_CALL_TYPE Reload(ModifyPipelineReloadInfoCallbackType ModifyReloadInfo, void* pUserData) override final;`
	`344`	`+ virtual Uint32 DILIGENT_CALL_TYPE Reload(ReloadGraphicsPipelineCallbackType ReloadGraphicsPipeline, void* pUserData) override final;`
`345`	`345`
`346`	`346`	`bool CreateShaderInternal(const ShaderCreateInfo& ShaderCI,`
`347`	`347`	`IShader** ppShader);`
`@@ -1097,7 +1097,7 @@ bool RenderStateCacheImpl::CreatePipelineStateInternal(const CreateInfoType& PSO`
`1097`	`1097`	`return false;`
`1098`	`1098`	`}`
`1099`	`1099`
`1100`		`-Uint32 RenderStateCacheImpl::Reload(ModifyPipelineReloadInfoCallbackType ModifyReloadInfo, void* pUserData)`
	`1100`	`+Uint32 RenderStateCacheImpl::Reload(ReloadGraphicsPipelineCallbackType ReloadGraphicsPipeline, void* pUserData)`
`1101`	`1101`	`{`
`1102`	`1102`	`if (!m_CI.EnableHotReload)`
`1103`	`1103`	`{`
`@@ -1136,7 +1136,7 @@ Uint32 RenderStateCacheImpl::Reload(ModifyPipelineReloadInfoCallbackType ModifyR`
`1136`	`1136`	`RefCntAutoPtr<ReloadablePipelineState> pReloadablePSO{pPSO, ReloadablePipelineState::IID_InternalImpl};`
`1137`	`1137`	`if (pPSO)`
`1138`	`1138`	`{`
`1139`		`- if (pReloadablePSO->Reload(ModifyReloadInfo, pUserData))`
	`1139`	`+ if (pReloadablePSO->Reload(ReloadGraphicsPipeline, pUserData))`
`1140`	`1140`	`++NumStatesReloaded;`
`1141`	`1141`	`}`
`1142`	`1142`	`else`
`@@ -1193,7 +1193,12 @@ struct ReloadablePipelineState::CreateInfoWrapperBase : DynamicHeapObjectBase`
`1193`	`1193`	`return m_CI;`
`1194`	`1194`	`}`
`1195`	`1195`
`1196`		`- operator const CreateInfoType&()`
	`1196`	`+ operator const CreateInfoType&() const`
	`1197`	`+ {`
	`1198`	`+ return m_CI;`
	`1199`	`+ }`
	`1200`	`+`
	`1201`	`+ operator CreateInfoType&()`
`1197`	`1202`	`{`
`1198`	`1203`	`return m_CI;`
`1199`	`1204`	`}`
`@@ -1354,22 +1359,28 @@ ReloadablePipelineState::ReloadablePipelineState(IReferenceCounters*`
`1354`	`1359`	`}`
`1355`	`1360`
`1356`	`1361`	`template <typename CreateInfoType>`
`1357`		`-bool ReloadablePipelineState::Reload(ModifyPipelineReloadInfoCallbackType ModifyReloadInfo, void* pUserData)`
	`1362`	`+void ModifyPsoCreateInfo(CreateInfoType& PsoCreateInfo, ReloadGraphicsPipelineCallbackType ReloadGraphicsPipeline, void* pUserData)`
`1358`	`1363`	`{`
`1359`		`- const auto& CreateInfo = static_cast<const CreateInfoWrapper<CreateInfoType>&>(*m_pCreateInfo).Get();`
	`1364`	`+}`
`1360`	`1365`
`1361`		`- RefCntAutoPtr<IPipelineState> pNewPSO;`
`1362`		`- bool FoundInCache = false;`
`1363`		`- if (ModifyReloadInfo != nullptr)`
`1364`		`- {`
`1365`		`- auto _CreateInfo = CreateInfo;`
`1366`		`- ModifyReloadInfo(_CreateInfo, pUserData);`
`1367`		`- FoundInCache = m_pStateCache->CreatePipelineStateInternal(_CreateInfo, &pNewPSO);`
`1368`		`- }`
`1369`		`- else`
	`1366`	`+template <>`
	`1367`	`+void ModifyPsoCreateInfo(GraphicsPipelineStateCreateInfo& PsoCreateInfo, ReloadGraphicsPipelineCallbackType ReloadGraphicsPipeline, void* pUserData)`
	`1368`	`+{`
	`1369`	`+ if (ReloadGraphicsPipeline != nullptr)`
`1370`	`1370`	`{`
`1371`		`- FoundInCache = m_pStateCache->CreatePipelineStateInternal(CreateInfo, &pNewPSO);`
	`1371`	`+ ReloadGraphicsPipeline(PsoCreateInfo.PSODesc.Name, PsoCreateInfo.GraphicsPipeline, pUserData);`
`1372`	`1372`	`}`
	`1373`	`+}`
	`1374`	`+`
	`1375`	`+template <typename CreateInfoType>`
	`1376`	`+bool ReloadablePipelineState::Reload(ReloadGraphicsPipelineCallbackType ReloadGraphicsPipeline, void* pUserData)`
	`1377`	`+{`
	`1378`	`+ auto& CreateInfo = static_cast<CreateInfoWrapper<CreateInfoType>&>(*m_pCreateInfo);`
	`1379`	`+ ModifyPsoCreateInfo<CreateInfoType>(static_cast<CreateInfoType&>(CreateInfo), ReloadGraphicsPipeline, pUserData);`
	`1380`	`+`
	`1381`	`+ RefCntAutoPtr<IPipelineState> pNewPSO;`
	`1382`	`+`
	`1383`	`+ const auto FoundInCache = m_pStateCache->CreatePipelineStateInternal(static_cast<const CreateInfoType&>(CreateInfo), &pNewPSO);`
`1373`	`1384`
`1374`	`1385`	`if (pNewPSO)`
`1375`	`1386`	`{`
`@@ -1381,14 +1392,14 @@ bool ReloadablePipelineState::Reload(ModifyPipelineReloadInfoCallbackType Modify`
`1381`	`1392`	`}`
`1382`	`1393`	`else`
`1383`	`1394`	`{`
`1384`		`- const auto* Name = CreateInfo.PSODesc.Name;`
	`1395`	`+ const auto* Name = CreateInfo.Get().PSODesc.Name;`
`1385`	`1396`	`LOG_ERROR_MESSAGE("Failed to reload pipeline state '", (Name ? Name : "<unnamed>"), "'.");`
`1386`	`1397`	`}`
`1387`	`1398`	`return !FoundInCache;`
`1388`	`1399`	`}`
`1389`	`1400`
`1390`	`1401`
`1391`		`-bool ReloadablePipelineState::Reload(ModifyPipelineReloadInfoCallbackType ModifyReloadInfo, void* pUserData)`
	`1402`	`+bool ReloadablePipelineState::Reload(ReloadGraphicsPipelineCallbackType ReloadGraphicsPipeline, void* pUserData)`
`1392`	`1403`	`{`
`1393`	`1404`	`static_assert(PIPELINE_TYPE_COUNT == 5, "Did you add a new pipeline type? You may need to handle it here.");`
`1394`	`1405`	`// Note that all shaders in Create Info are reloadable shaders, so they will automatically redirect all calls`
`@@ -1397,16 +1408,16 @@ bool ReloadablePipelineState::Reload(ModifyPipelineReloadInfoCallbackType Modify`
`1397`	`1408`	`{`
`1398`	`1409`	`case PIPELINE_TYPE_GRAPHICS:`
`1399`	`1410`	`case PIPELINE_TYPE_MESH:`
`1400`		`- return Reload<GraphicsPipelineStateCreateInfo>(ModifyReloadInfo, pUserData);`
	`1411`	`+ return Reload<GraphicsPipelineStateCreateInfo>(ReloadGraphicsPipeline, pUserData);`
`1401`	`1412`
`1402`	`1413`	`case PIPELINE_TYPE_COMPUTE:`
`1403`		`- return Reload<ComputePipelineStateCreateInfo>(ModifyReloadInfo, pUserData);`
	`1414`	`+ return Reload<ComputePipelineStateCreateInfo>(ReloadGraphicsPipeline, pUserData);`
`1404`	`1415`
`1405`	`1416`	`case PIPELINE_TYPE_RAY_TRACING:`
`1406`		`- return Reload<RayTracingPipelineStateCreateInfo>(ModifyReloadInfo, pUserData);`
	`1417`	`+ return Reload<RayTracingPipelineStateCreateInfo>(ReloadGraphicsPipeline, pUserData);`
`1407`	`1418`
`1408`	`1419`	`case PIPELINE_TYPE_TILE:`
`1409`		`- return Reload<TilePipelineStateCreateInfo>(ModifyReloadInfo, pUserData);`
	`1420`	`+ return Reload<TilePipelineStateCreateInfo>(ReloadGraphicsPipeline, pUserData);`
`1410`	`1421`
`1411`	`1422`	`default:`
`1412`	`1423`	`UNEXPECTED("Unexpected pipeline type");`