Hydrogent: moved OIT resource management from HnBeginFrameTask to HnBeginOITPassTask

Author: TheMostDiligent

Hydrogent/interface/HnRenderPassState.hpp

@@ -119,6 +119,10 @@ class HnRenderPassState final : public pxr::HdRenderPassState
     {
         return m_ClearDepth;
     }
+    bool GetUseReverseDepth() const
+    {
+        return GetDepthFunc() == pxr::HdCmpFuncGreater;
+    }
 
     static constexpr Uint32 ClearDepthBit = 1u << 31u;
 

Hydrogent/interface/HnTokens.hpp

@@ -105,6 +105,7 @@ namespace USD
     (nearestMipmapNearest)
 
 #define HN_RENDER_RESOURCE_TOKENS        \
+    (camera)                             \
     (cameraAttribsBuffer)                \
     (lightAttribsBuffer)                 \
     (offscreenColorTarget)               \

Hydrogent/interface/Tasks/HnBeginFrameTask.hpp

@@ -162,7 +162,6 @@ class HnBeginFrameTask final : public HnTask
                               const float2&   Jitter,
                               bool&           CameraTransformDirty,
                               bool&           LoadingAnimationActive);
-    void BindOITResources(HnRenderDelegate* RenderDelegate);
 
 private:
     std::unordered_map<pxr::TfToken, HnRenderPassState, pxr::TfToken::HashFunctor> m_RenderPassStates;
@@ -196,8 +195,6 @@ class HnBeginFrameTask final : public HnTask
     double m_CurrFrameTime           = 0;
     double m_FallBackPsoUseStartTime = -1;
     double m_FallBackPsoUseEndTime   = -1;
-
-    Uint32 m_BoundOITResourcesVersion = ~0u;
 };
 
 } // namespace USD

Hydrogent/interface/Tasks/HnBeginOITPassTask.hpp

@@ -27,13 +27,17 @@
 #pragma once
 
 #include "HnTask.hpp"
+#include "../interface/HnRenderPassState.hpp"
 
 namespace Diligent
 {
 
 namespace USD
 {
 
+struct HnFrameRenderTargets;
+class HnRenderDelegate;
+
 struct HnBeginOITPassTaskParams
 {
     constexpr bool operator==(const HnBeginOITPassTaskParams& rhs) const
@@ -62,8 +66,17 @@ class HnBeginOITPassTask final : public HnTask
 
     virtual void Execute(pxr::HdTaskContext* TaskCtx) override final;
 
+private:
+    void BindOITResources(HnRenderDelegate* RenderDelegate);
+
 private:
     pxr::HdRenderIndex* m_RenderIndex = nullptr;
+
+    const HnFrameRenderTargets* m_FrameTargets = nullptr; // Set in Prepare()
+
+    HnRenderPassState m_RenderPassState;
+
+    Uint32 m_BoundOITResourcesVersion = ~0u;
 };
 
 } // namespace USD

Hydrogent/src/HnRenderDelegate.cpp

@@ -769,8 +769,8 @@ void HnRenderDelegate::CommitResources(pxr::HdChangeTracker* tracker)
     const bool EnableOIT = m_USDRenderer->GetSettings().OITLayerCount > 0;
     if (EnableOIT)
     {
-        // OIT resource version is made dirty by HnBeginFrameTask when the frame size changes.
-        // OIT resources will be set in the SRB by HnBeginFrameTask::Execute().
+        // OIT resource version is made dirty by HnBeginOITPassTask when the frame size changes.
+        // OIT resources will be set in the SRB by HnBeginOITPassTask::Execute().
         if (m_OITResourcesVersion != m_RenderParam->GetAttribVersion(HnRenderParam::GlobalAttrib::OITResources))
         {
             m_OITResourcesVersion = m_RenderParam->MakeAttribDirty(HnRenderParam::GlobalAttrib::OITResources);

Hydrogent/src/Tasks/HnBeginFrameTask.cpp

@@ -145,13 +145,6 @@ void HnBeginFrameTask::Sync(pxr::HdSceneDelegate* Delegate,
                 m_Params.Formats.Depth,
                 m_Params.UseReverseDepth);
 
-            const TEXTURE_FORMAT OITRTVFormats[] = {USD_Renderer::OITTailFmt};
-            m_RenderPassStates[HnRenderResourceTokens->renderPass_OITLayers].Init(
-                OITRTVFormats,
-                _countof(OITRTVFormats),
-                m_Params.Formats.Depth,
-                m_Params.UseReverseDepth);
-
             (*TaskCtx)[HnRenderResourceTokens->suspendSuperSampling] = pxr::VtValue{true};
         }
     }
@@ -172,9 +165,6 @@ void HnBeginFrameTask::PrepareRenderTargets(pxr::HdRenderIndex* RenderIndex,
 
     HnRenderDelegate* RenderDelegate = static_cast<HnRenderDelegate*>(RenderIndex->GetRenderDelegate());
 
-    const bool FrameBufferResized = (m_FrameBufferWidth != FinalTargetDesc.Width ||
-                                     m_FrameBufferHeight != FinalTargetDesc.Height);
-
     m_FrameBufferWidth  = FinalTargetDesc.Width;
     m_FrameBufferHeight = FinalTargetDesc.Height;
 
@@ -255,22 +245,6 @@ void HnBeginFrameTask::PrepareRenderTargets(pxr::HdRenderIndex* RenderIndex,
     m_FrameRenderTargets.ClosestSelectedLocationRTV[1] = UpdateBrim(m_ClosestSelLocnTargetId[1], m_Params.Formats.ClosestSelectedLocation, "Closest selected location 1");
     m_FrameRenderTargets.JitteredFinalColorRTV         = UpdateBrim(m_JitteredFinalColorTargetId, m_Params.Formats.JitteredColor, "Jittered final color");
 
-    const USD_Renderer& Renderer = *RenderDelegate->GetUSDRenderer();
-    if (Renderer.GetSettings().OITLayerCount > 0)
-    {
-        if (FrameBufferResized)
-        {
-            m_FrameRenderTargets.OIT = {};
-        }
-
-        if (!m_FrameRenderTargets.OIT)
-        {
-            m_FrameRenderTargets.OIT = Renderer.CreateOITResources(FinalTargetDesc.Width, FinalTargetDesc.Height);
-            // Mark OIT resources dirty to make render delegate recreate main pass frame attribs SRB.
-            static_cast<HnRenderParam*>(RenderDelegate->GetRenderParam())->MakeAttribDirty(HnRenderParam::GlobalAttrib::OITResources);
-        }
-    }
-
     (*TaskCtx)[HnRenderResourceTokens->frameRenderTargets] = pxr::VtValue{&m_FrameRenderTargets};
 
     // Set render pass render targets
@@ -306,21 +280,6 @@ void HnBeginFrameTask::PrepareRenderTargets(pxr::HdRenderIndex* RenderIndex,
         RPState->SetCamera(m_pCamera);
     }
 
-    if (Renderer.GetSettings().OITLayerCount > 0)
-    {
-        HnRenderPassState& RP_OITLayers = m_RenderPassStates[HnRenderResourceTokens->renderPass_OITLayers];
-
-        ITextureView* OITRTVs[] = {m_FrameRenderTargets.OIT.Tail->GetDefaultView(TEXTURE_VIEW_RENDER_TARGET)};
-        const float4  TailClearValue{
-            0, // Layer counter
-            0, // Unused
-            0, // Unused
-            1, // Total tail transmittance
-        };
-        RP_OITLayers.Begin(_countof(OITRTVs), OITRTVs, m_FrameRenderTargets.DepthDSV, &TailClearValue, 0, 0x01u);
-        RP_OITLayers.SetCamera(m_pCamera);
-    }
-
     // Register render pass states in the task context
     for (auto& it : m_RenderPassStates)
     {
@@ -388,6 +347,7 @@ void HnBeginFrameTask::Prepare(pxr::HdTaskContext* TaskCtx,
         {
             LOG_ERROR_MESSAGE("Camera is not set at Id ", m_Params.CameraId);
         }
+        (*TaskCtx)[HnRenderResourceTokens->camera] = pxr::VtValue{static_cast<const HnCamera*>(m_pCamera)};
     }
     else
     {
@@ -720,39 +680,6 @@ void HnBeginFrameTask::UpdateFrameConstants(IDeviceContext* pCtx,
     pCtx->TransitionResourceStates(static_cast<Uint32>(Barriers.size()), Barriers.data());
 }
 
-void HnBeginFrameTask::BindOITResources(HnRenderDelegate* RenderDelegate)
-{
-    HnRenderParam* RenderParam = static_cast<HnRenderParam*>(RenderDelegate->GetRenderParam());
-    if (m_BoundOITResourcesVersion == RenderParam->GetAttribVersion(HnRenderParam::GlobalAttrib::OITResources))
-        return;
-
-    if (!m_FrameRenderTargets.OIT)
-    {
-        UNEXPECTED("OIT resources are not initialized. This likely indicates that Prepare() has not been called.");
-        return;
-    }
-
-    USD_Renderer& Renderer = *RenderDelegate->GetUSDRenderer();
-    if (IShaderResourceBinding* pFrameAttribsSRB = RenderDelegate->GetFrameAttribsSRB(HnRenderDelegate::FrameAttribsSRBType::Transparent))
-    {
-        Renderer.SetOITResources(pFrameAttribsSRB, m_FrameRenderTargets.OIT);
-        m_BoundOITResourcesVersion = RenderParam->GetAttribVersion(HnRenderParam::GlobalAttrib::OITResources);
-    }
-    else
-    {
-        UNEXPECTED("Main pass frame attribs SRB is null");
-    }
-
-    IDeviceContext* pCtx = RenderDelegate->GetDeviceContext();
-
-    StateTransitionDesc Barriers[] =
-        {
-            {m_FrameRenderTargets.OIT.Layers, RESOURCE_STATE_UNKNOWN, RESOURCE_STATE_SHADER_RESOURCE, STATE_TRANSITION_FLAG_UPDATE_STATE},
-            {m_FrameRenderTargets.OIT.Tail, RESOURCE_STATE_UNKNOWN, RESOURCE_STATE_SHADER_RESOURCE, STATE_TRANSITION_FLAG_UPDATE_STATE},
-        };
-    pCtx->TransitionResourceStates(_countof(Barriers), Barriers);
-}
-
 void HnBeginFrameTask::Execute(pxr::HdTaskContext* TaskCtx)
 {
     if (m_RenderIndex == nullptr)
@@ -768,11 +695,6 @@ void HnBeginFrameTask::Execute(pxr::HdTaskContext* TaskCtx)
 
     ScopedDebugGroup DebugGroup{pCtx, "Begin Frame"};
 
-    if (Renderer.GetSettings().OITLayerCount > 0)
-    {
-        BindOITResources(RenderDelegate);
-    }
-
     // NB: we can't move the buffer update to Prepare() because we need TAA parameters
     //     that are set by HnPostProcessTask::Prepare().
     if (IBuffer* pFrameAttribsCB = RenderDelegate->GetFrameAttribsCB())

Hydrogent/src/Tasks/HnBeginOITPassTask.cpp

@@ -29,6 +29,9 @@
 #include "ScopedDebugGroup.hpp"
 #include "HnTokens.hpp"
 #include "HnRenderPassState.hpp"
+#include "HnFrameRenderTargets.hpp"
+#include "HnCamera.hpp"
+#include "HnRenderParam.hpp"
 
 namespace Diligent
 {
@@ -56,6 +59,111 @@ void HnBeginOITPassTask::Prepare(pxr::HdTaskContext* TaskCtx,
                                  pxr::HdRenderIndex* RenderIndex)
 {
     m_RenderIndex = RenderIndex;
+
+    HnFrameRenderTargets* FrameTargets = GetFrameRenderTargets(TaskCtx);
+    if (FrameTargets == nullptr)
+    {
+        UNEXPECTED("Framebuffer targets are null");
+        return;
+    }
+    m_FrameTargets = FrameTargets;
+
+    ITextureView* pColorRTV = FrameTargets->GBufferRTVs[HnFrameRenderTargets::GBUFFER_TARGET_SCENE_COLOR];
+    if (pColorRTV == nullptr)
+    {
+        UNEXPECTED("Scene color target is null");
+        return;
+    }
+
+    const TextureDesc& ColorTargetDesc = pColorRTV->GetTexture()->GetDesc();
+    if (FrameTargets->OIT)
+    {
+        const TextureDesc& OITDesc = FrameTargets->OIT.Tail->GetDesc();
+        if (OITDesc.Width != ColorTargetDesc.Width || OITDesc.Height != ColorTargetDesc.Height)
+        {
+            FrameTargets->OIT = {};
+        }
+    }
+
+    HnRenderDelegate* RenderDelegate = static_cast<HnRenderDelegate*>(RenderIndex->GetRenderDelegate());
+
+    const USD_Renderer& Renderer = *RenderDelegate->GetUSDRenderer();
+    VERIFY_EXPR(Renderer.GetSettings().OITLayerCount > 0);
+
+    if (!FrameTargets->OIT)
+    {
+        FrameTargets->OIT = Renderer.CreateOITResources(ColorTargetDesc.Width, ColorTargetDesc.Height);
+        // Mark OIT resources dirty to make render delegate recreate transparent pass frame attribs SRB.
+        // We will set the OIT resources in the SBR in Execute().
+        static_cast<HnRenderParam*>(RenderDelegate->GetRenderParam())->MakeAttribDirty(HnRenderParam::GlobalAttrib::OITResources);
+    }
+
+    bool UseReverseDepth = false;
+    GetTaskContextData(TaskCtx, HnRenderResourceTokens->useReverseDepth, UseReverseDepth);
+
+    const TEXTURE_FORMAT DepthFormat = FrameTargets->DepthDSV->GetTexture()->GetDesc().Format;
+    if (m_RenderPassState.GetDepthStencilFormat() != DepthFormat ||
+        m_RenderPassState.GetUseReverseDepth() != UseReverseDepth)
+    {
+        const TEXTURE_FORMAT OITRTVFormats[] = {USD_Renderer::OITTailFmt};
+        m_RenderPassState.Init(
+            OITRTVFormats,
+            _countof(OITRTVFormats),
+            DepthFormat,
+            UseReverseDepth);
+    }
+
+    ITextureView* OITRTVs[] = {FrameTargets->OIT.Tail->GetDefaultView(TEXTURE_VIEW_RENDER_TARGET)};
+    const float4  TailClearValue{
+        0, // Layer counter
+        0, // Unused
+        0, // Unused
+        1, // Total tail transmittance
+    };
+    m_RenderPassState.Begin(_countof(OITRTVs), OITRTVs, FrameTargets->DepthDSV, &TailClearValue, 0, 0x01u);
+
+    const HnCamera* pCamera = nullptr;
+    if (GetTaskContextData(TaskCtx, HnRenderResourceTokens->camera, pCamera))
+    {
+        m_RenderPassState.SetCamera(pCamera);
+    }
+
+    (*TaskCtx)[HnRenderResourceTokens->renderPass_OITLayers] = pxr::VtValue{&m_RenderPassState};
+}
+
+
+void HnBeginOITPassTask::BindOITResources(HnRenderDelegate* RenderDelegate)
+{
+    if (m_FrameTargets == nullptr)
+    {
+        UNEXPECTED("Frame targets are null. This likely indicates that Prepare() has not been called.");
+        return;
+    }
+
+    if (!m_FrameTargets->OIT)
+    {
+        UNEXPECTED("OIT resources are not initialized. This likely indicates that Prepare() has not been called.");
+        return;
+    }
+
+    USD_Renderer& Renderer = *RenderDelegate->GetUSDRenderer();
+    if (IShaderResourceBinding* pFrameAttribsSRB = RenderDelegate->GetFrameAttribsSRB(HnRenderDelegate::FrameAttribsSRBType::Transparent))
+    {
+        Renderer.SetOITResources(pFrameAttribsSRB, m_FrameTargets->OIT);
+    }
+    else
+    {
+        UNEXPECTED("Main pass frame attribs SRB is null");
+    }
+
+    IDeviceContext* pCtx = RenderDelegate->GetDeviceContext();
+
+    StateTransitionDesc Barriers[] =
+        {
+            {m_FrameTargets->OIT.Layers, RESOURCE_STATE_UNKNOWN, RESOURCE_STATE_SHADER_RESOURCE, STATE_TRANSITION_FLAG_UPDATE_STATE},
+            {m_FrameTargets->OIT.Tail, RESOURCE_STATE_UNKNOWN, RESOURCE_STATE_SHADER_RESOURCE, STATE_TRANSITION_FLAG_UPDATE_STATE},
+        };
+    pCtx->TransitionResourceStates(_countof(Barriers), Barriers);
 }
 
 void HnBeginOITPassTask::Execute(pxr::HdTaskContext* TaskCtx)
@@ -69,17 +177,17 @@ void HnBeginOITPassTask::Execute(pxr::HdTaskContext* TaskCtx)
     HnRenderDelegate* RenderDelegate = static_cast<HnRenderDelegate*>(m_RenderIndex->GetRenderDelegate());
     IDeviceContext*   pCtx           = RenderDelegate->GetDeviceContext();
 
-    ScopedDebugGroup DebugGroup{pCtx, "Begin OIT pass"};
-
-    if (HnRenderPassState* RP_OITLayers = GetRenderPassState(TaskCtx, HnRenderResourceTokens->renderPass_OITLayers))
+    HnRenderParam* RenderParam = static_cast<HnRenderParam*>(RenderDelegate->GetRenderParam());
+    if (m_BoundOITResourcesVersion != RenderParam->GetAttribVersion(HnRenderParam::GlobalAttrib::OITResources))
     {
-        RP_OITLayers->SetFrameAttribsSRB(RenderDelegate->GetFrameAttribsSRB(HnRenderDelegate::FrameAttribsSRBType::OITLayers));
-        RP_OITLayers->Commit(pCtx);
-    }
-    else
-    {
-        UNEXPECTED("OIT layers render pass state is not set in the task context");
+        BindOITResources(RenderDelegate);
+        m_BoundOITResourcesVersion = RenderParam->GetAttribVersion(HnRenderParam::GlobalAttrib::OITResources);
     }
+
+    ScopedDebugGroup DebugGroup{pCtx, "Begin OIT pass"};
+
+    m_RenderPassState.SetFrameAttribsSRB(RenderDelegate->GetFrameAttribsSRB(HnRenderDelegate::FrameAttribsSRBType::OITLayers));
+    m_RenderPassState.Commit(pCtx);
 }
 
 } // namespace USD

Hydrogent/src/Tasks/HnRenderRprimsTask.cpp

@@ -1,5 +1,5 @@
 /*
- *  Copyright 2023-2024 Diligent Graphics LLC
+ *  Copyright 2023-2025 Diligent Graphics LLC
  *
  *  Licensed under the Apache License, Version 2.0 (the "License");
  *  you may not use this file except in compliance with the License.
@@ -136,7 +136,7 @@ void HnRenderRprimsTask::Execute(pxr::HdTaskContext* TaskCtx)
         }
         else
         {
-            UNEXPECTED("Render pass state is null. This likely indicates that HnBeginFrameTask was not been created or executed.");
+            UNEXPECTED("Render pass state is null. This likely indicates that HnBeginFrameTask has not been created or executed.");
         }
     }
 }