Hydrogent: fixed edge/point render modes

TheMostDiligent · TheMostDiligent · commit 6ff99f81675c · 2025-03-11T13:25:34.000-07:00
diff --git a/Hydrogent/interface/HnTypes.hpp b/Hydrogent/interface/HnTypes.hpp
@@ -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.
@@ -37,7 +37,7 @@ namespace USD
 {
 
 /// Renering mode
-enum HN_RENDER_MODE
+enum HN_RENDER_MODE : Uint8
 {
     /// Render solid geometry
     HN_RENDER_MODE_SOLID,
diff --git a/Hydrogent/interface/Tasks/HnBeginOITPassTask.hpp b/Hydrogent/interface/Tasks/HnBeginOITPassTask.hpp
@@ -71,6 +71,8 @@ class HnBeginOITPassTask final : public HnTask
 
     virtual void Execute(pxr::HdTaskContext* TaskCtx) override final;
 
+    virtual bool IsActive(pxr::HdRenderIndex& RenderIndex) const override final;
+
 private:
     void BindOITResources(HnRenderDelegate* RenderDelegate);
 
diff --git a/Hydrogent/interface/Tasks/HnEndOITPassTask.hpp b/Hydrogent/interface/Tasks/HnEndOITPassTask.hpp
@@ -66,6 +66,8 @@ class HnEndOITPassTask final : public HnTask
 
     virtual void Execute(pxr::HdTaskContext* TaskCtx) override final;
 
+    virtual bool IsActive(pxr::HdRenderIndex& RenderIndex) const override final;
+
 private:
     pxr::HdRenderIndex* m_RenderIndex = nullptr;
 
diff --git a/Hydrogent/interface/Tasks/HnRenderRprimsTask.hpp b/Hydrogent/interface/Tasks/HnRenderRprimsTask.hpp
@@ -29,7 +29,8 @@
 #include "HnTask.hpp"
 #include "HnTypes.hpp"
 
-#include "../../../Common/interface/BasicMath.hpp"
+#include "../../../../DiligentCore/Common/interface/BasicMath.hpp"
+#include "../../../../DiligentCore/Primitives/interface/FlagEnum.h"
 
 #include "pxr/imaging/hd/renderPass.h"
 
@@ -43,16 +44,32 @@ class HnRenderPass;
 
 struct HnRenderRprimsTaskParams
 {
+    static_assert(HN_RENDER_MODE_COUNT == 3, "Did you add a new render mode? Please update the flags!");
+    enum RENDER_MODE_FLAGS : Uint32
+    {
+        RENDER_MODE_FLAG_NONE = 0u,
+
+        RENDER_MODE_FLAG_SOLID = 1u << HN_RENDER_MODE_SOLID,
+
+        RENDER_MODE_FLAG_MESH_EDGES = 1u << HN_RENDER_MODE_MESH_EDGES,
+
+        RENDER_MODE_FLAG_POINTS = 1u << HN_RENDER_MODE_POINTS,
+
+        RENDER_MODE_FLAG_ALL = RENDER_MODE_FLAG_SOLID | RENDER_MODE_FLAG_MESH_EDGES | RENDER_MODE_FLAG_POINTS
+    };
+    RENDER_MODE_FLAGS RenderModes = RENDER_MODE_FLAG_ALL;
+
     constexpr bool operator==(const HnRenderRprimsTaskParams& rhs) const
     {
-        return true;
+        return RenderModes == rhs.RenderModes;
     }
 
     constexpr bool operator!=(const HnRenderRprimsTaskParams& rhs) const
     {
         return !(*this == rhs);
     }
 };
+DEFINE_FLAG_ENUM_OPERATORS(HnRenderRprimsTaskParams::RENDER_MODE_FLAGS);
 
 /// Renders the Rprims by executing the render pass.
 /// The task should be executed after the HnSetupRenderingTask that prepares
@@ -79,7 +96,10 @@ class HnRenderRprimsTask final : public HnTask
         return m_RenderTags;
     }
 
+    virtual bool IsActive(pxr::HdRenderIndex& RenderIndex) const override final;
+
 private:
+    HnRenderRprimsTaskParams      m_Params;
     pxr::TfTokenVector            m_RenderTags;
     std::shared_ptr<HnRenderPass> m_RenderPass;
 };
diff --git a/Hydrogent/interface/Tasks/HnTask.hpp b/Hydrogent/interface/Tasks/HnTask.hpp
@@ -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.
@@ -50,6 +50,11 @@ class HnTask : public pxr::HdTask
 public:
     HnTask(const pxr::SdfPath& Id);
 
+    virtual bool IsActive(pxr::HdRenderIndex& RenderIndex) const
+    {
+        return true;
+    }
+
 protected:
     HnFrameRenderTargets* GetFrameRenderTargets(pxr::HdTaskContext* TaskCtx) const;
     HnRenderPassState*    GetRenderPassState(pxr::HdTaskContext* TaskCtx, const pxr::TfToken& Name) const;
diff --git a/Hydrogent/interface/Tasks/HnTaskManager.hpp b/Hydrogent/interface/Tasks/HnTaskManager.hpp
@@ -30,6 +30,7 @@
 #include <vector>
 
 #include "Tasks/HnTask.hpp"
+#include "Tasks/HnRenderRprimsTask.hpp"
 
 #include "../../../../DiligentCore/Platforms/Basic/interface/DebugUtilities.hpp"
 
@@ -201,7 +202,6 @@ class HnTaskManager
                        TaskParamsType&&    Params);
 
     void SetFrameParams(const HnBeginFrameTaskParams& Params);
-    void SetRenderRprimParams(const HnRenderRprimsTaskParams& Params);
     void SetPostProcessParams(const HnPostProcessTaskParams& Params);
     void SetReadRprimIdParams(const HnReadRprimIdTaskParams& Params);
     void SetRenderBoundBoxParams(const HnRenderBoundBoxTaskParams& Params);
@@ -253,7 +253,10 @@ class HnTaskManager
     void CreateBeginFrameTask();
     void CreateBeginMainPassTask();
     void CreateRenderShadowsTask(const HnShadowMapManager& ShadowMapMgr);
-    void CreateRenderRprimsTask(const pxr::TfToken& MaterialTag, TaskUID UID, const HnRenderPassParams& RenderPassParams);
+    void CreateRenderRprimsTask(const pxr::TfToken&             MaterialTag,
+                                TaskUID                         UID,
+                                const HnRenderPassParams&       RenderPassParams,
+                                const HnRenderRprimsTaskParams& TaskParams = {});
     void CreateRenderEnvMapTask(const pxr::TfToken& RenderPassName);
     void CreateRenderBoundBoxTask(const pxr::TfToken& RenderPassName);
     void CreateBeginOITPassTask();
diff --git a/Hydrogent/src/Tasks/HnBeginFrameTask.cpp b/Hydrogent/src/Tasks/HnBeginFrameTask.cpp
@@ -690,7 +690,6 @@ void HnBeginFrameTask::Execute(pxr::HdTaskContext* TaskCtx)
 
     HnRenderDelegate* RenderDelegate = static_cast<HnRenderDelegate*>(m_RenderIndex->GetRenderDelegate());
     HnRenderParam*    RenderParam    = static_cast<HnRenderParam*>(RenderDelegate->GetRenderParam());
-    USD_Renderer&     Renderer       = *RenderDelegate->GetUSDRenderer();
     IDeviceContext*   pCtx           = RenderDelegate->GetDeviceContext();
 
     ScopedDebugGroup DebugGroup{pCtx, "Begin Frame"};
diff --git a/Hydrogent/src/Tasks/HnBeginOITPassTask.cpp b/Hydrogent/src/Tasks/HnBeginOITPassTask.cpp
@@ -55,6 +55,15 @@ void HnBeginOITPassTask::Sync(pxr::HdSceneDelegate* Delegate,
     *DirtyBits = pxr::HdChangeTracker::Clean;
 }
 
+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();
+
+    return RenderMode == HN_RENDER_MODE_SOLID;
+}
+
 void HnBeginOITPassTask::Prepare(pxr::HdTaskContext* TaskCtx,
                                  pxr::HdRenderIndex* RenderIndex)
 {
@@ -188,8 +197,9 @@ void HnBeginOITPassTask::Execute(pxr::HdTaskContext* TaskCtx)
     const bool        IsWebGPUDevice = pDevice->GetDeviceInfo().IsWebGPUDevice();
     IDeviceContext*   pCtx           = RenderDelegate->GetDeviceContext();
 
-    const HnRenderParam* RenderParam         = static_cast<HnRenderParam*>(RenderDelegate->GetRenderParam());
-    const Uint32         OITResourcesVersion = RenderParam->GetAttribVersion(HnRenderParam::GlobalAttrib::OITResources);
+    const HnRenderParam* RenderParam = static_cast<HnRenderParam*>(RenderDelegate->GetRenderParam());
+    VERIFY_EXPR(RenderParam->GetRenderMode() == HN_RENDER_MODE_SOLID);
+    const Uint32 OITResourcesVersion = RenderParam->GetAttribVersion(HnRenderParam::GlobalAttrib::OITResources);
     if (m_BoundOITResourcesVersion != OITResourcesVersion)
     {
         BindOITResources(RenderDelegate);
diff --git a/Hydrogent/src/Tasks/HnEndOITPassTask.cpp b/Hydrogent/src/Tasks/HnEndOITPassTask.cpp
@@ -53,6 +53,15 @@ void HnEndOITPassTask::Sync(pxr::HdSceneDelegate* Delegate,
     *DirtyBits = pxr::HdChangeTracker::Clean;
 }
 
+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();
+
+    return RenderMode == HN_RENDER_MODE_SOLID;
+}
+
 void HnEndOITPassTask::Prepare(pxr::HdTaskContext* TaskCtx,
                                pxr::HdRenderIndex* RenderIndex)
 {
@@ -89,6 +98,7 @@ void HnEndOITPassTask::Prepare(pxr::HdTaskContext* TaskCtx,
     }
 
     HnRenderParam* RenderParam = static_cast<HnRenderParam*>(RenderDelegate->GetRenderParam());
+    VERIFY_EXPR(RenderParam->GetRenderMode() == HN_RENDER_MODE_SOLID);
     if (m_OITResourcesVersion != RenderParam->GetAttribVersion(HnRenderParam::GlobalAttrib::OITResources))
     {
         m_ApplyOITAttenuationSRB.Release();
diff --git a/Hydrogent/src/Tasks/HnRenderRprimsTask.cpp b/Hydrogent/src/Tasks/HnRenderRprimsTask.cpp
@@ -29,6 +29,7 @@
 #include "HnRenderPassState.hpp"
 #include "HnRenderPass.hpp"
 #include "HnTokens.hpp"
+#include "HnRenderParam.hpp"
 
 #include "pxr/imaging/hd/renderDelegate.h"
 
@@ -100,6 +101,7 @@ void HnRenderRprimsTask::Sync(pxr::HdSceneDelegate* Delegate,
         HnRenderRprimsTaskParams Params;
         if (GetTaskParams(Delegate, Params))
         {
+            m_Params = Params;
         }
     }
 
@@ -121,6 +123,15 @@ void HnRenderRprimsTask::Prepare(pxr::HdTaskContext* TaskCtx,
 {
 }
 
+bool HnRenderRprimsTask::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();
+
+    return (m_Params.RenderModes & (1u << RenderMode)) != 0;
+}
+
 void HnRenderRprimsTask::Execute(pxr::HdTaskContext* TaskCtx)
 {
     if (m_RenderPass)
diff --git a/Hydrogent/src/Tasks/HnTaskManager.cpp b/Hydrogent/src/Tasks/HnTaskManager.cpp
@@ -223,6 +223,9 @@ HnTaskManager::HnTaskManager(pxr::HdRenderIndex& RenderIndex,
                                    HnRenderPassParams::SelectionType::All,
                                    USD_Renderer::RenderPassType::OITLayers,
                                    USD_Renderer::USD_PSO_FLAG_ENABLE_ALL_OUTPUTS,
+                               },
+                               {
+                                   HnRenderRprimsTaskParams::RENDER_MODE_FLAG_SOLID,
                                });
         CreateEndOITPassTask();
         // We will write mesh ID, motion vectors and depth in a separate pass
@@ -406,10 +409,12 @@ pxr::SdfPath HnTaskManager::GetRenderRprimsTaskId(const pxr::TfToken& MaterialTa
     return GetTaskId(TfToken{Id});
 }
 
-void HnTaskManager::CreateRenderRprimsTask(const pxr::TfToken& MaterialTag, TaskUID UID, const HnRenderPassParams& RenderPassParams)
+void HnTaskManager::CreateRenderRprimsTask(const pxr::TfToken&             MaterialTag,
+                                           TaskUID                         UID,
+                                           const HnRenderPassParams&       RenderPassParams,
+                                           const HnRenderRprimsTaskParams& TaskParams)
 {
-    HnRenderRprimsTaskParams TaskParams;
-    pxr::SdfPath             RenderRprimsTaskId = GetRenderRprimsTaskId(MaterialTag, RenderPassParams);
+    pxr::SdfPath RenderRprimsTaskId = GetRenderRprimsTaskId(MaterialTag, RenderPassParams);
     // Note that we pass the delegate to the scene index. This delegate will be passed
     // to the task's Sync() method.
     CreateTask<HnRenderRprimsTask>(RenderRprimsTaskId, UID, TaskParams);
@@ -439,14 +444,6 @@ void HnTaskManager::SetFrameParams(const HnBeginFrameTaskParams& Params)
     SetTaskParams(TaskUID_BeginFrame, Params);
 }
 
-void HnTaskManager::SetRenderRprimParams(const HnRenderRprimsTaskParams& Params)
-{
-    for (const auto& TaskId : m_RenderTaskIds)
-    {
-        SetTaskParams(TaskId, Params);
-    }
-}
-
 void HnTaskManager::CreatePostProcessTask()
 {
     HnPostProcessTaskParams TaskParams;
@@ -507,7 +504,7 @@ const pxr::HdTaskSharedPtrVector HnTaskManager::GetTasks(const std::vector<TaskU
 
     pxr::HdTaskSharedPtrVector Tasks;
     Tasks.reserve(TaskOrder->size());
-    for (auto UID : *TaskOrder)
+    for (TaskUID UID : *TaskOrder)
     {
         auto it = m_TaskInfo.find(UID);
         if (it == m_TaskInfo.end())
@@ -516,7 +513,17 @@ const pxr::HdTaskSharedPtrVector HnTaskManager::GetTasks(const std::vector<TaskU
         if (!it->second.Enabled)
             continue;
 
-        Tasks.push_back(m_RenderIndex.GetTask(it->second.Id));
+        if (pxr::HdTaskSharedPtr pTask = m_RenderIndex.GetTask(it->second.Id))
+        {
+            if (static_cast<const HnTask*>(pTask.get())->IsActive(m_RenderIndex))
+            {
+                Tasks.push_back(std::move(pTask));
+            }
+        }
+        else
+        {
+            UNEXPECTED("Task ", it->second.Id, " is not found in the render index");
+        }
     }
 
     return Tasks;
@@ -542,7 +549,7 @@ void HnTaskManager::SetCollection(const pxr::HdRprimCollection& Collection)
 
 void HnTaskManager::SetRenderTags(const pxr::TfTokenVector& RenderTags)
 {
-    for (const auto& TaskId : m_RenderTaskIds)
+    for (const pxr::SdfPath& TaskId : m_RenderTaskIds)
     {
         pxr::TfTokenVector OldRenderTags = m_ParamsDelegate.GetParameter<pxr::TfTokenVector>(TaskId, pxr::HdTokens->renderTags);
         if (OldRenderTags == RenderTags)
diff --git a/PBR/src/USD_Renderer.cpp b/PBR/src/USD_Renderer.cpp
@@ -118,11 +118,11 @@ USD_Renderer::CreateInfo::PSMainSourceInfo USD_Renderer::GetUsdPbrPSMainSource(U
 #   if LOADING_ANIMATION
         MaterialData = lerp(MaterialData, float2(1.0, 0.0), g_Frame.Renderer.LoadingAnimation.Factor);
 #   endif
-#endif
 
     MaterialData  *= Transmittance;
     IBL           *= Transmittance;
     BaseColor.rgb *= Transmittance;
+#endif
 )";
 
     if (PSOFlags & USD_PSO_FLAG_ENABLE_ALL_OUTPUTS)

Original file line number	Diff line number	Diff line change
`@@ -1,5 +1,5 @@`
`1`	`1`	`/*`
`2`		`- * Copyright 2023-2024 Diligent Graphics LLC`
	`2`	`+ * Copyright 2023-2025 Diligent Graphics LLC`
`3`	`3`	`*`
`4`	`4`	`* Licensed under the Apache License, Version 2.0 (the "License");`
`5`	`5`	`* you may not use this file except in compliance with the License.`
`@@ -37,7 +37,7 @@ namespace USD`
`37`	`37`	`{`
`38`	`38`
`39`	`39`	`/// Renering mode`
`40`		`-enum HN_RENDER_MODE`
	`40`	`+enum HN_RENDER_MODE : Uint8`
`41`	`41`	`{`
`42`	`42`	`/// Render solid geometry`
`43`	`43`	`HN_RENDER_MODE_SOLID,`
Original file line number	Diff line number	Diff line change
`@@ -53,6 +53,15 @@ void HnEndOITPassTask::Sync(pxr::HdSceneDelegate* Delegate,`
`53`	`53`	`*DirtyBits = pxr::HdChangeTracker::Clean;`
`54`	`54`	`}`
`55`	`55`
	`56`	`+bool HnEndOITPassTask::IsActive(pxr::HdRenderIndex& RenderIndex) const`
	`57`	`+{`
	`58`	`+ pxr::HdRenderDelegate* RenderDelegate = RenderIndex.GetRenderDelegate();`
	`59`	`+ const HnRenderParam* RenderParam = static_cast<const HnRenderParam*>(RenderDelegate->GetRenderParam());`
	`60`	`+ const HN_RENDER_MODE RenderMode = RenderParam->GetRenderMode();`
	`61`	`+`
	`62`	`+ return RenderMode == HN_RENDER_MODE_SOLID;`
	`63`	`+}`
	`64`	`+`
`56`	`65`	`void HnEndOITPassTask::Prepare(pxr::HdTaskContext* TaskCtx,`
`57`	`66`	`pxr::HdRenderIndex* RenderIndex)`
`58`	`67`	`{`
`@@ -89,6 +98,7 @@ void HnEndOITPassTask::Prepare(pxr::HdTaskContext* TaskCtx,`
`89`	`98`	`}`
`90`	`99`
`91`	`100`	`HnRenderParam* RenderParam = static_cast<HnRenderParam*>(RenderDelegate->GetRenderParam());`
	`101`	`+ VERIFY_EXPR(RenderParam->GetRenderMode() == HN_RENDER_MODE_SOLID);`
`92`	`102`	`if (m_OITResourcesVersion != RenderParam->GetAttribVersion(HnRenderParam::GlobalAttrib::OITResources))`
`93`	`103`	`{`
`94`	`104`	`m_ApplyOITAttenuationSRB.Release();`
Original file line number	Diff line number	Diff line change
`@@ -29,6 +29,7 @@`
`29`	`29`	`#include "HnRenderPassState.hpp"`
`30`	`30`	`#include "HnRenderPass.hpp"`
`31`	`31`	`#include "HnTokens.hpp"`
	`32`	`+#include "HnRenderParam.hpp"`
`32`	`33`
`33`	`34`	`#include "pxr/imaging/hd/renderDelegate.h"`
`34`	`35`
`@@ -100,6 +101,7 @@ void HnRenderRprimsTask::Sync(pxr::HdSceneDelegate* Delegate,`
`100`	`101`	`HnRenderRprimsTaskParams Params;`
`101`	`102`	`if (GetTaskParams(Delegate, Params))`
`102`	`103`	`{`
	`104`	`+ m_Params = Params;`
`103`	`105`	`}`
`104`	`106`	`}`
`105`	`107`
`@@ -121,6 +123,15 @@ void HnRenderRprimsTask::Prepare(pxr::HdTaskContext* TaskCtx,`
`121`	`123`	`{`
`122`	`124`	`}`
`123`	`125`
	`126`	`+bool HnRenderRprimsTask::IsActive(pxr::HdRenderIndex& RenderIndex) const`
	`127`	`+{`
	`128`	`+ pxr::HdRenderDelegate* RenderDelegate = RenderIndex.GetRenderDelegate();`
	`129`	`+ const HnRenderParam* RenderParam = static_cast<const HnRenderParam*>(RenderDelegate->GetRenderParam());`
	`130`	`+ const HN_RENDER_MODE RenderMode = RenderParam->GetRenderMode();`
	`131`	`+`
	`132`	`+ return (m_Params.RenderModes & (1u << RenderMode)) != 0;`
	`133`	`+}`
	`134`	`+`
`124`	`135`	`void HnRenderRprimsTask::Execute(pxr::HdTaskContext* TaskCtx)`
`125`	`136`	`{`
`126`	`137`	`if (m_RenderPass)`