Hydrogent: moved environment map rendering to the task

Hydrogent/include/HnRenderDelegate.hpp

@@ -201,6 +201,7 @@ class HnRenderDelegate final : public pxr::HdRenderDelegate
 
     IRenderDevice*  GetDevice() { return m_pDevice; }
     IDeviceContext* GetDeviceContext() { return m_pContext; }
+    IBuffer*        GetCameraAttribsCB() { return m_CameraAttribsCB; }
 
 private:
     static const pxr::TfTokenVector SupportedRPrimTypes;

Hydrogent/include/HnRenderPassState.hpp

@@ -55,9 +55,9 @@ class HnRenderPassState final : public pxr::HdRenderPassState
 
     void Begin(IDeviceContext* pContext);
 
-    void SetRenderTargetFormat(Uint32 RT, TEXTURE_FORMAT Fmt)
+    void SetRenderTargetFormat(Uint32 rt, TEXTURE_FORMAT Fmt)
     {
-        m_RTVFormats[RT] = Fmt;
+        m_RTVFormats[rt] = Fmt;
     }
     void SetDepthStencilFormat(TEXTURE_FORMAT DepthFormat)
     {
@@ -131,6 +131,19 @@ class HnRenderPassState final : public pxr::HdRenderPassState
         return m_Transform;
     }
 
+    Uint32 GetNumRenderTargets() const
+    {
+        return m_NumRenderTargets;
+    }
+    TEXTURE_FORMAT GetRenderTargetFormat(Uint32 rt) const
+    {
+        return m_RTVFormats[rt];
+    }
+    TEXTURE_FORMAT GetDepthStencilFormat() const
+    {
+        return m_DepthFormat;
+    }
+
     RasterizerStateDesc   GetRasterizerState() const;
     DepthStencilStateDesc GetDepthStencilState() const;
     BlendStateDesc        GetBlendState() const;

Hydrogent/include/HnRendererImpl.hpp

@@ -51,8 +51,6 @@
 namespace Diligent
 {
 
-class EnvMapRenderer;
-
 namespace USD
 {
 
@@ -102,8 +100,6 @@ class HnRendererImpl final : public ObjectBase<IHnRenderer>
 
     const bool m_ConvertOutputToSRGB;
 
-    std::unique_ptr<EnvMapRenderer> m_EnvMapRenderer;
-
     pxr::UsdStageRefPtr m_Stage;
 
     std::unique_ptr<HnRenderDelegate>        m_RenderDelegate;

Hydrogent/include/Tasks/HnRenderEnvMapTask.hpp

@@ -26,11 +26,15 @@
 
 #pragma once
 
+#include <memory>
+
 #include "HnTask.hpp"
 
 namespace Diligent
 {
 
+class EnvMapRenderer;
+
 namespace USD
 {
 
@@ -62,6 +66,11 @@ class HnRenderEnvMapTask final : public HnTask
 
 
     virtual void Execute(pxr::HdTaskContext* TaskCtx) override final;
+
+private:
+    std::unique_ptr<EnvMapRenderer> m_EnvMapRenderer;
+
+    pxr::HdRenderIndex* m_RenderIndex = nullptr;
 };
 
 } // namespace USD

Hydrogent/include/Tasks/HnTask.hpp

@@ -26,6 +26,8 @@
 
 #pragma once
 
+#include <memory>
+
 #include "pxr/imaging/hd/task.h"
 
 namespace Diligent
@@ -34,11 +36,16 @@ namespace Diligent
 namespace USD
 {
 
+class HnRenderPassState;
+
 /// Hydra task implementation in Hydrogent.
 class HnTask : public pxr::HdTask
 {
 public:
     HnTask(const pxr::SdfPath& Id);
+
+protected:
+    std::shared_ptr<HnRenderPassState> GetRenderPassState(pxr::HdTaskContext* TaskCtx) const;
 };
 
 } // namespace USD

Hydrogent/src/HnRendererImpl.cpp

@@ -76,19 +76,6 @@ HnRendererImpl::HnRendererImpl(IReferenceCounters*         pRefCounters,
     m_LightAttribsCB{CI.pLightAttribsCB},
     m_PostProcessAttribsCB{m_Device.CreateBuffer("Post process attribs CB", sizeof(HLSL::PostProcessAttribs))},
     m_ConvertOutputToSRGB{CI.ConvertOutputToSRGB},
-    m_EnvMapRenderer{
-        std::make_unique<EnvMapRenderer>(
-            [](const HnRendererCreateInfo& CI, IRenderDevice* pDevice) {
-                EnvMapRenderer::CreateInfo EnvMapRndrCI;
-                EnvMapRndrCI.pDevice          = pDevice;
-                EnvMapRndrCI.pCameraAttribsCB = CI.pCameraAttribsCB;
-                EnvMapRndrCI.NumRenderTargets = 2;
-                EnvMapRndrCI.RTVFormats[0]    = ColorBufferFormat;
-                EnvMapRndrCI.RTVFormats[1]    = MeshIdFormat;
-                EnvMapRndrCI.DSVFormat        = DepthFormat;
-
-                return EnvMapRndrCI;
-            }(CI, pDevice))},
     m_MeshIdReadBackQueue{pDevice}
 {
 }
@@ -276,25 +263,6 @@ void HnRendererImpl::Draw(IDeviceContext* pCtx, const HnDrawAttribs& Attribs)
         pCtx->ClearDepthStencil(m_DepthBufferDSV, CLEAR_DEPTH_FLAG, 1.f, 0, RESOURCE_STATE_TRANSITION_MODE_TRANSITION);
     }
 
-    if (auto* pEnvMapSRV = m_RenderDelegate->GetUSDRenderer()->GetPrefilteredEnvMapSRV())
-    {
-        Diligent::HLSL::ToneMappingAttribs TMAttribs;
-        TMAttribs.iToneMappingMode     = TONE_MAPPING_MODE_UNCHARTED2;
-        TMAttribs.bAutoExposure        = 0;
-        TMAttribs.fMiddleGray          = Attribs.MiddleGray;
-        TMAttribs.bLightAdaptation     = 0;
-        TMAttribs.fWhitePoint          = Attribs.WhitePoint;
-        TMAttribs.fLuminanceSaturation = 1.0;
-
-        EnvMapRenderer::RenderAttribs EnvMapAttribs;
-        EnvMapAttribs.pContext      = pCtx;
-        EnvMapAttribs.pEnvMap       = pEnvMapSRV;
-        EnvMapAttribs.AverageLogLum = Attribs.AverageLogLum;
-        EnvMapAttribs.MipLevel      = 1;
-
-        m_EnvMapRenderer->Render(EnvMapAttribs, TMAttribs);
-    }
-
     pxr::HdTaskSharedPtrVector tasks = m_TaskController->GetTasks();
     m_Engine.Execute(&m_ImagingDelegate->GetRenderIndex(), &tasks);
 

Hydrogent/src/Tasks/HnRenderEnvMapTask.cpp

@@ -25,6 +25,12 @@
  */
 
 #include "Tasks/HnRenderEnvMapTask.hpp"
+#include "HnRenderDelegate.hpp"
+#include "HnRenderPassState.hpp"
+#include "HnTokens.hpp"
+
+#include "EnvMapRenderer.hpp"
+#include "USD_Renderer.hpp"
 
 #include "DebugUtilities.hpp"
 
@@ -67,10 +73,65 @@ void HnRenderEnvMapTask::Sync(pxr::HdSceneDelegate* Delegate,
 void HnRenderEnvMapTask::Prepare(pxr::HdTaskContext* TaskCtx,
                                  pxr::HdRenderIndex* RenderIndex)
 {
+    m_RenderIndex = RenderIndex;
+
+    if (!m_EnvMapRenderer)
+    {
+        std::shared_ptr<HnRenderPassState> RenderPassState = GetRenderPassState(TaskCtx);
+        if (RenderPassState)
+        {
+            HnRenderDelegate* pRenderDelegate = static_cast<HnRenderDelegate*>(m_RenderIndex->GetRenderDelegate());
+
+            EnvMapRenderer::CreateInfo EnvMapRndrCI;
+            EnvMapRndrCI.pDevice          = pRenderDelegate->GetDevice();
+            EnvMapRndrCI.pCameraAttribsCB = pRenderDelegate->GetCameraAttribsCB();
+            EnvMapRndrCI.NumRenderTargets = RenderPassState->GetNumRenderTargets();
+            for (Uint32 rt = 0; rt < EnvMapRndrCI.NumRenderTargets; ++rt)
+                EnvMapRndrCI.RTVFormats[rt] = RenderPassState->GetRenderTargetFormat(rt);
+            EnvMapRndrCI.DSVFormat = RenderPassState->GetDepthStencilFormat();
+
+            m_EnvMapRenderer = std::make_unique<EnvMapRenderer>(EnvMapRndrCI);
+        }
+        else
+        {
+            UNEXPECTED("Render pass state is not set");
+        }
+    }
 }
 
 void HnRenderEnvMapTask::Execute(pxr::HdTaskContext* TaskCtx)
 {
+    if (!m_EnvMapRenderer)
+        return;
+
+    HnRenderDelegate* pRenderDelegate = static_cast<HnRenderDelegate*>(m_RenderIndex->GetRenderDelegate());
+
+    auto& USDRenderer = pRenderDelegate->GetUSDRenderer();
+    if (!USDRenderer)
+    {
+        UNEXPECTED("USD renderer is not initialized");
+        return;
+    }
+
+    auto* pEnvMapSRV = USDRenderer->GetPrefilteredEnvMapSRV();
+    if (pEnvMapSRV == nullptr)
+        return;
+
+    Diligent::HLSL::ToneMappingAttribs TMAttribs;
+    TMAttribs.iToneMappingMode     = TONE_MAPPING_MODE_UNCHARTED2;
+    TMAttribs.bAutoExposure        = 0;
+    TMAttribs.fMiddleGray          = 0.18f;
+    TMAttribs.bLightAdaptation     = 0;
+    TMAttribs.fWhitePoint          = 3.0f;
+    TMAttribs.fLuminanceSaturation = 1.0;
+
+    EnvMapRenderer::RenderAttribs EnvMapAttribs;
+    EnvMapAttribs.pContext      = pRenderDelegate->GetDeviceContext();
+    EnvMapAttribs.pEnvMap       = pEnvMapSRV;
+    EnvMapAttribs.AverageLogLum = 0.3f;
+    EnvMapAttribs.MipLevel      = 1;
+
+    m_EnvMapRenderer->Render(EnvMapAttribs, TMAttribs);
 }
 
 } // namespace USD

Hydrogent/src/Tasks/HnRenderRprimsTask.cpp

@@ -117,8 +117,7 @@ void HnRenderRprimsTask::Execute(pxr::HdTaskContext* TaskCtx)
     {
         // Render pass state is initialized by the setup rendering task.
         // It is shared between all instances of the render rprims task.
-        std::shared_ptr<HnRenderPassState> RenderPassState;
-        _GetTaskContextData(TaskCtx, HnTokens->renderPassState, &RenderPassState);
+        std::shared_ptr<HnRenderPassState> RenderPassState = GetRenderPassState(TaskCtx);
         VERIFY(RenderPassState, "Render pass state is null. This likely indicates that setup rendering task has not been created or executed.");
         m_RenderPass->Execute(RenderPassState, GetRenderTags());
     }

Hydrogent/src/Tasks/HnTask.cpp

@@ -25,6 +25,7 @@
  */
 
 #include "Tasks/HnTask.hpp"
+#include "HnTokens.hpp"
 
 namespace Diligent
 {
@@ -37,6 +38,13 @@ HnTask::HnTask(const pxr::SdfPath& Id) :
 {
 }
 
+std::shared_ptr<HnRenderPassState> HnTask::GetRenderPassState(pxr::HdTaskContext* TaskCtx) const
+{
+    std::shared_ptr<HnRenderPassState> RenderPassState;
+    _GetTaskContextData(TaskCtx, HnTokens->renderPassState, &RenderPassState);
+    return RenderPassState;
+}
+
 } // namespace USD
 
 } // namespace Diligent