PBR Renderer and Hydrogent: added scene depth debug view mode

Author: TheMostDiligent

Hydrogent/interface/HnRenderPass.hpp

@@ -92,9 +92,9 @@ class HnRenderPass final : public pxr::HdRenderPass
 
     void SetParams(const HnRenderPassParams& Params);
 
-    const pxr::TfToken& GetName() const
+    const HnRenderPassParams& GetParams() const
     {
-        return m_Params.Name;
+        return m_Params;
     }
 
     // A mapping from the primvar name to its role (e.g. "points" -> "point", "normals" -> "normal", "st0" -> "textureCoordinate", etc.)

Hydrogent/interface/Tasks/HnRenderEnvMapTask.hpp

@@ -1,5 +1,5 @@
 /*
- *  Copyright 2023 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.
@@ -67,6 +67,8 @@ class HnRenderEnvMapTask final : public HnTask
 
     virtual void Execute(pxr::HdTaskContext* TaskCtx) override final;
 
+    virtual bool IsActive(pxr::HdRenderIndex& RenderIndex) const override final;
+
 private:
     pxr::TfToken m_RenderPassName;
 

Hydrogent/src/Tasks/HnBeginFrameTask.cpp

@@ -163,7 +163,8 @@ void HnBeginFrameTask::PrepareRenderTargets(pxr::HdRenderIndex* RenderIndex,
     }
     const TextureDesc& FinalTargetDesc = pFinalColorRTV->GetTexture()->GetDesc();
 
-    HnRenderDelegate* RenderDelegate = static_cast<HnRenderDelegate*>(RenderIndex->GetRenderDelegate());
+    const HnRenderDelegate* RenderDelegate = static_cast<const HnRenderDelegate*>(RenderIndex->GetRenderDelegate());
+    const HnRenderParam*    RenderParam    = static_cast<const HnRenderParam*>(RenderDelegate->GetRenderParam());
 
     m_FrameBufferWidth  = FinalTargetDesc.Width;
     m_FrameBufferHeight = FinalTargetDesc.Height;
@@ -252,10 +253,23 @@ void HnBeginFrameTask::PrepareRenderTargets(pxr::HdRenderIndex* RenderIndex,
     std::array<float4, HnFrameRenderTargets::GBUFFER_TARGET_COUNT> ClearValues; // No need to zero-initialize
     for (Uint32 i = 0; i < HnFrameRenderTargets::GBUFFER_TARGET_COUNT; ++i)
     {
-        // NB: we should clear alpha to one as it accumulates the total transmittance
-        ClearValues[i] = (i == HnFrameRenderTargets::GBUFFER_TARGET_SCENE_COLOR) ?
-            float4{m_Params.ClearColor.r, m_Params.ClearColor.g, m_Params.ClearColor.b, 1.0} :
-            float4{0};
+        if (i == HnFrameRenderTargets::GBUFFER_TARGET_SCENE_COLOR)
+        {
+            if (RenderParam->GetDebugView() != PBR_Renderer::DebugViewType::SceneDepth)
+            {
+                // NB: we should clear alpha to one as it accumulates the total transmittance
+                ClearValues[i] = float4{m_Params.ClearColor.r, m_Params.ClearColor.g, m_Params.ClearColor.b, 1.0};
+            }
+            else
+            {
+                // Clear background to white in scene depth debug view mode
+                ClearValues[i] = float4{1};
+            }
+        }
+        else
+        {
+            ClearValues[i] = float4{0};
+        }
     }
 
     HnRenderPassState& RP_OpaqueSelected      = m_RenderPassStates[HnRenderResourceTokens->renderPass_OpaqueSelected];

Hydrogent/src/Tasks/HnBeginOITPassTask.cpp

@@ -57,11 +57,13 @@ void HnBeginOITPassTask::Sync(pxr::HdSceneDelegate* Delegate,
 
 bool HnBeginOITPassTask::IsActive(pxr::HdRenderIndex& RenderIndex) const
 {
-    pxr::HdRenderDelegate* RenderDelegate = RenderIndex.GetRenderDelegate();
-    const HnRenderParam*   RenderParam    = static_cast<const HnRenderParam*>(RenderDelegate->GetRenderParam());
-    const HN_RENDER_MODE   RenderMode     = RenderParam->GetRenderMode();
+    pxr::HdRenderDelegate*            RenderDelegate = RenderIndex.GetRenderDelegate();
+    const HnRenderParam*              RenderParam    = static_cast<const HnRenderParam*>(RenderDelegate->GetRenderParam());
+    const HN_RENDER_MODE              RenderMode     = RenderParam->GetRenderMode();
+    const PBR_Renderer::DebugViewType DebugView      = RenderParam->GetDebugView();
 
-    return RenderMode == HN_RENDER_MODE_SOLID;
+    // Scene depth debug view for transparent objects is rendered in opaque mode and does not need OIT layers.
+    return RenderMode == HN_RENDER_MODE_SOLID && DebugView != PBR_Renderer::DebugViewType::SceneDepth;
 }
 
 void HnBeginOITPassTask::Prepare(pxr::HdTaskContext* TaskCtx,

Hydrogent/src/Tasks/HnEndOITPassTask.cpp

@@ -56,11 +56,13 @@ void HnEndOITPassTask::Sync(pxr::HdSceneDelegate* Delegate,
 
 bool HnEndOITPassTask::IsActive(pxr::HdRenderIndex& RenderIndex) const
 {
-    pxr::HdRenderDelegate* RenderDelegate = RenderIndex.GetRenderDelegate();
-    const HnRenderParam*   RenderParam    = static_cast<const HnRenderParam*>(RenderDelegate->GetRenderParam());
-    const HN_RENDER_MODE   RenderMode     = RenderParam->GetRenderMode();
+    pxr::HdRenderDelegate*            RenderDelegate = RenderIndex.GetRenderDelegate();
+    const HnRenderParam*              RenderParam    = static_cast<const HnRenderParam*>(RenderDelegate->GetRenderParam());
+    const HN_RENDER_MODE              RenderMode     = RenderParam->GetRenderMode();
+    const PBR_Renderer::DebugViewType DebugView      = RenderParam->GetDebugView();
 
-    return RenderMode == HN_RENDER_MODE_SOLID;
+    // Scene depth debug view for transparent objects is rendered in opaque mode and does not need OIT layers.
+    return RenderMode == HN_RENDER_MODE_SOLID && DebugView != PBR_Renderer::DebugViewType::SceneDepth;
 }
 
 static_assert(USD_Renderer::USD_PSO_FLAG_OIT_BLEND_OUTPUTS ==

Hydrogent/src/Tasks/HnRenderEnvMapTask.cpp

@@ -81,6 +81,17 @@ void HnRenderEnvMapTask::Sync(pxr::HdSceneDelegate* Delegate,
     *DirtyBits = pxr::HdChangeTracker::Clean;
 }
 
+bool HnRenderEnvMapTask::IsActive(pxr::HdRenderIndex& RenderIndex) const
+{
+    pxr::HdRenderDelegate*            RenderDelegate = RenderIndex.GetRenderDelegate();
+    const HnRenderParam*              RenderParam    = static_cast<const HnRenderParam*>(RenderDelegate->GetRenderParam());
+    const HN_RENDER_MODE              RenderMode     = RenderParam->GetRenderMode();
+    const PBR_Renderer::DebugViewType DebugView      = RenderParam->GetDebugView();
+
+    // Background is cleared to white in scene depth debug view mode
+    return !(RenderMode == HN_RENDER_MODE_SOLID && DebugView == PBR_Renderer::DebugViewType::SceneDepth);
+}
+
 static std::string GetEnvMapPSMain()
 {
     static_assert(HnFrameRenderTargets::GBUFFER_TARGET_COUNT == 7, "Did you change the number of G-buffer targets? You may need to update the code below.");

Hydrogent/src/Tasks/HnRenderRprimsTask.cpp

@@ -129,14 +129,23 @@ bool HnRenderRprimsTask::IsActive(pxr::HdRenderIndex& RenderIndex) const
     const HnRenderParam*   RenderParam    = static_cast<const HnRenderParam*>(RenderDelegate->GetRenderParam());
     const HN_RENDER_MODE   RenderMode     = RenderParam->GetRenderMode();
 
-    return (m_Params.RenderModes & (1u << RenderMode)) != 0;
+    if ((m_Params.RenderModes & (1u << RenderMode)) == 0)
+        return false;
+
+    if (m_RenderPass && m_RenderPass->GetParams().Type == USD_Renderer::RenderPassType::OITLayers)
+    {
+        // Scene depth debug view for transparent objects is rendered in opaque mode and does not need OIT layers.
+        return RenderParam->GetDebugView() != PBR_Renderer::DebugViewType::SceneDepth;
+    }
+
+    return true;
 }
 
 void HnRenderRprimsTask::Execute(pxr::HdTaskContext* TaskCtx)
 {
     if (m_RenderPass)
     {
-        const pxr::TfToken& RenderPassName = m_RenderPass->GetName();
+        const pxr::TfToken& RenderPassName = m_RenderPass->GetParams().Name;
 
         // Render pass state is initialized by HnBeginFrameTask.
         if (HnRenderPassState* RenderPassState = GetRenderPassState(TaskCtx, RenderPassName))

PBR/interface/PBR_Renderer.hpp

@@ -444,6 +444,7 @@ class PBR_Renderer
         IridescenceThickness,
         Transmission,
         Thickness,
+        SceneDepth,
         NumDebugViews
     };
 

PBR/src/PBR_Renderer.cpp

@@ -112,6 +112,13 @@ PBR_Renderer::PSOKey::PSOKey(RenderPassType       _Type,
         DebugView        = DebugViewType::None;
     }
 
+    if (DebugView == DebugViewType::SceneDepth)
+    {
+        // Rendering scene depth with blending does not make sense,
+        // so force alpha mode to opaque.
+        AlphaMode = ALPHA_MODE_OPAQUE;
+    }
+
     if (Flags & PSO_FLAG_UNSHADED)
     {
         AlphaMode = ALPHA_MODE_OPAQUE;
@@ -1382,7 +1389,7 @@ ShaderMacroHelper PBR_Renderer::DefineMacros(const PSOKey& Key) const
         Macros.Add("PCF_FILTER_SIZE", KernelSize);
     }
 
-    static_assert(static_cast<int>(DebugViewType::NumDebugViews) == 34, "Did you add debug view? You may need to handle it here.");
+    static_assert(static_cast<int>(DebugViewType::NumDebugViews) == 35, "Did you add debug view? You may need to handle it here.");
     // clang-format off
     Macros.Add("DEBUG_VIEW",                       static_cast<int>(Key.GetDebugView()));
     Macros.Add("DEBUG_VIEW_NONE",                  static_cast<int>(DebugViewType::None));
@@ -1419,6 +1426,7 @@ ShaderMacroHelper PBR_Renderer::DefineMacros(const PSOKey& Key) const
     Macros.Add("DEBUG_VIEW_IRIDESCENCE_THICKNESS", static_cast<int>(DebugViewType::IridescenceThickness));
     Macros.Add("DEBUG_VIEW_TRANSMISSION",          static_cast<int>(DebugViewType::Transmission));
     Macros.Add("DEBUG_VIEW_THICKNESS",             static_cast<int>(DebugViewType::Thickness));
+    Macros.Add("DEBUG_VIEW_SCENE_DEPTH",           static_cast<int>(DebugViewType::SceneDepth));
     // clang-format on
 
     static_assert(static_cast<int>(LoadingAnimationMode::Count) == 3, "Did you add new loading animation mode? You may need to handle it here.");
@@ -2596,7 +2604,7 @@ void* PBR_Renderer::WriteSkinningData(void* pDst, const WriteSkinningDataAttribs
 
 const char* PBR_Renderer::GetDebugViewTypeString(DebugViewType DebugView)
 {
-    static_assert(static_cast<int>(DebugViewType::NumDebugViews) == 34, "Please update the switch below to handle the new debug view type");
+    static_assert(static_cast<int>(DebugViewType::NumDebugViews) == 35, "Please update the switch below to handle the new debug view type");
     switch (DebugView)
     {
 #define DEBUG_VIEW_TYPE_CASE(Type) \
@@ -2636,6 +2644,7 @@ const char* PBR_Renderer::GetDebugViewTypeString(DebugViewType DebugView)
         DEBUG_VIEW_TYPE_CASE(IridescenceThickness);
         DEBUG_VIEW_TYPE_CASE(Transmission);
         DEBUG_VIEW_TYPE_CASE(Thickness);
+        DEBUG_VIEW_TYPE_CASE(SceneDepth);
 #undef DEBUG_VIEW_TYPE_CASE
 
         default:

Shaders/PBR/private/RenderPBR.psh

@@ -594,6 +594,12 @@ PSOutput main(in VSOutput VSOut,
     {
         // Already handled
     }
+#   elif (DEBUG_VIEW == DEBUG_VIEW_SCENE_DEPTH)
+    {
+        float CameraZ = DepthToCameraZ(VSOut.ClipPos.z, g_Frame.Camera.mProj);
+        CameraZ = (CameraZ - g_Frame.Camera.fNearPlaneZ) / (g_Frame.Camera.fFarPlaneZ - g_Frame.Camera.fNearPlaneZ);
+        OutColor.rgb = float3(CameraZ, CameraZ, CameraZ);
+    }
 #   elif (DEBUG_VIEW != DEBUG_VIEW_NONE)
     {
         OutColor.rgb = GetDebugColor(Shading, SrfLighting);