Hydrogent: added task controller

Hydrogent/CMakeLists.txt

@@ -18,6 +18,7 @@ set(SOURCE
     src/Tasks/HnTask.cpp
     src/Tasks/HnRenderTask.cpp
     src/Tasks/HnPostProcessTask.cpp
+    src/Tasks/HnTaskController.cpp
 )
 
 set(INCLUDE
@@ -37,6 +38,7 @@ set(INCLUDE
     include/Tasks/HnTask.hpp
     include/Tasks/HnRenderTask.hpp
     include/Tasks/HnPostProcessTask.hpp
+    include/Tasks/HnTaskController.hpp
 )
 
 set(INTERFACE
@@ -116,6 +118,7 @@ INTERFACE
     usd_hio
     usd_sdr
     usd_ndr
+    usd_trace
 )
 
 target_include_directories(Diligent-Hydrogent

Hydrogent/include/HnRendererImpl.hpp

@@ -39,6 +39,7 @@
 #include "ObjectBase.hpp"
 #include "GPUCompletionAwaitQueue.hpp"
 #include "USD_Renderer.hpp"
+#include "Tasks/HnTaskController.hpp"
 
 #include "pxr/usd/usd/stage.h"
 #include "pxr/imaging/hd/tokens.h"
@@ -58,6 +59,7 @@ namespace USD
 class HnRenderDelegate;
 class HnMesh;
 class HnMaterial;
+class HnTaskController;
 
 class HnRendererImpl final : public ObjectBase<IHnRenderer>
 {
@@ -112,6 +114,7 @@ class HnRendererImpl final : public ObjectBase<IHnRenderer>
     USD_Renderer::WireframePsoCacheAccessor m_WireframePSOCache;
 
     std::unique_ptr<HnRenderDelegate> m_RenderDelegate;
+    std::unique_ptr<HnTaskController> m_TaskController;
 
     pxr::UsdStageRefPtr        m_Stage;
     pxr::HdEngine              m_Engine;

Hydrogent/include/Tasks/HnPostProcessTask.hpp

@@ -34,15 +34,27 @@ namespace Diligent
 namespace USD
 {
 
+struct HnPostProcessTaskParams
+{
+    constexpr bool operator==(const HnPostProcessTaskParams& rhs) const
+    {
+        return true;
+    }
+    constexpr bool operator!=(const HnPostProcessTaskParams& rhs) const
+    {
+        return !(*this == rhs);
+    }
+};
+
 /// Post processing task implementation in Hydrogent.
 class HnPostProcessTask final : public HnTask
 {
 public:
     using TaskSharedPtr = std::shared_ptr<HnPostProcessTask>;
 
-    static TaskSharedPtr Create(const pxr::SdfPath& id);
+    static TaskSharedPtr Create(pxr::HdSceneDelegate& ParamsDelegate, const pxr::SdfPath& id);
 
-    HnPostProcessTask(const pxr::SdfPath& Id);
+    HnPostProcessTask(pxr::HdSceneDelegate* ParamsDelegate, const pxr::SdfPath& Id);
     ~HnPostProcessTask();
 
     virtual void Sync(pxr::HdSceneDelegate* Delegate,

Hydrogent/include/Tasks/HnRenderTask.hpp

@@ -34,15 +34,27 @@ namespace Diligent
 namespace USD
 {
 
+struct HnRenderTaskParams
+{
+    constexpr bool operator==(const HnRenderTaskParams& rhs) const
+    {
+        return true;
+    }
+    constexpr bool operator!=(const HnRenderTaskParams& rhs) const
+    {
+        return !(*this == rhs);
+    }
+};
+
 /// Render task implementation in Hydrogent.
 class HnRenderTask final : public HnTask
 {
 public:
     using TaskSharedPtr = std::shared_ptr<HnRenderTask>;
 
-    static TaskSharedPtr Create(const pxr::SdfPath& id);
+    static TaskSharedPtr Create(pxr::HdSceneDelegate& ParamsDelegate, const pxr::SdfPath& Id);
 
-    HnRenderTask(const pxr::SdfPath& Id);
+    HnRenderTask(pxr::HdSceneDelegate* ParamsDelegate, const pxr::SdfPath& Id);
     ~HnRenderTask();
 
     virtual void Sync(pxr::HdSceneDelegate* Delegate,

Hydrogent/include/Tasks/HnTaskController.hpp

@@ -0,0 +1,96 @@
+/*
+ *  Copyright 2023 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.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ *
+ *  In no event and under no legal theory, whether in tort (including negligence),
+ *  contract, or otherwise, unless required by applicable law (such as deliberate
+ *  and grossly negligent acts) or agreed to in writing, shall any Contributor be
+ *  liable for any damages, including any direct, indirect, special, incidental,
+ *  or consequential damages of any character arising as a result of this License or
+ *  out of the use or inability to use the software (including but not limited to damages
+ *  for loss of goodwill, work stoppage, computer failure or malfunction, or any and
+ *  all other commercial damages or losses), even if such Contributor has been advised
+ *  of the possibility of such damages.
+ */
+
+#pragma once
+
+#include <memory>
+#include <array>
+
+#include "Tasks/HnTask.hpp"
+
+namespace Diligent
+{
+
+namespace USD
+{
+
+struct HnRenderTaskParams;
+struct HnPostProcessTaskParams;
+
+/// Task controller implementation in Hydrogent.
+class HnTaskController
+{
+public:
+    HnTaskController(pxr::HdRenderIndex& RenderIndex,
+                     const pxr::SdfPath& ControllerId);
+
+    ~HnTaskController();
+
+    const pxr::HdRenderIndex& GetRenderIndex() const { return m_RenderIndex; }
+    pxr::HdRenderIndex&       GetRenderIndex() { return m_RenderIndex; }
+
+    const pxr::SdfPath& GetControllerId() const { return m_ControllerId; }
+
+    const pxr::HdTaskSharedPtrVector GetRenderingTasks() const;
+
+    /// Sets new collection for the render tasks.
+    void SetCollection(const pxr::HdRprimCollection& Collection);
+
+    /// Sets new params for the render tasks.
+    void SetRenderParams(const HnRenderTaskParams& Params);
+
+    /// Sets new params for the post-process task.
+    void SetPostProcessParams(const HnPostProcessTaskParams& Params);
+
+    /// Sets new render tags for the render tasks.
+    void SetRenderTags(const pxr::TfTokenVector& RenderTags);
+
+private:
+    pxr::SdfPath GetRenderTaskId(const pxr::TfToken& MaterialTag) const;
+    pxr::SdfPath CreateRenderTask(const pxr::TfToken& MaterialTag);
+    pxr::SdfPath CreatePostProcessTask();
+
+private:
+    pxr::HdRenderIndex& m_RenderIndex;
+    const pxr::SdfPath  m_ControllerId;
+
+    // Custom delegate to pass parameters to the render tasks.
+    class TaskParamsDelegate;
+    std::unique_ptr<TaskParamsDelegate> m_ParamsDelegate;
+
+    pxr::SdfPathVector m_RenderTaskIds;
+
+    enum TASK_ID
+    {
+        TASK_ID_POST_PROCESS,
+        TASK_ID_COUNT
+    };
+    std::array<pxr::SdfPath, TASK_ID_COUNT> m_TaskIds;
+};
+
+} // namespace USD
+
+} // namespace Diligent

Hydrogent/src/HnRendererImpl.cpp

@@ -29,6 +29,7 @@
 #include "HnMesh.hpp"
 #include "HnMaterial.hpp"
 #include "HnTokens.hpp"
+#include "Tasks/HnTaskController.hpp"
 
 #include "EngineMemory.h"
 #include "USD_Renderer.hpp"
@@ -148,11 +149,16 @@ void HnRendererImpl::LoadUSDStage(pxr::UsdStageRefPtr& Stage)
     m_Stage = Stage;
 
     m_RenderDelegate = HnRenderDelegate::Create({m_Device, m_Context, m_CameraAttribsCB, m_LightAttribsCB, m_USDRenderer});
+    m_RenderIndex    = pxr::HdRenderIndex::New(m_RenderDelegate.get(), pxr::HdDriverVector{});
 
-    m_RenderIndex     = pxr::HdRenderIndex::New(m_RenderDelegate.get(), pxr::HdDriverVector{});
-    m_ImagingDelegate = new pxr::UsdImagingDelegate(m_RenderIndex, pxr::SdfPath::AbsoluteRootPath());
+    const pxr::SdfPath SceneDelegateId = pxr::SdfPath::AbsoluteRootPath();
+
+    m_ImagingDelegate = new pxr::UsdImagingDelegate(m_RenderIndex, SceneDelegateId);
     m_ImagingDelegate->Populate(m_Stage->GetPseudoRoot());
 
+    const pxr::SdfPath TaskControllerId = SceneDelegateId.AppendChild(pxr::TfToken{"_HnTaskController_"});
+    m_TaskController                    = std::make_unique<HnTaskController>(*m_RenderIndex, TaskControllerId);
+
     m_RenderTags = {pxr::HdRenderTagTokens->geometry};
 
     auto Collection = pxr::HdRprimCollection{pxr::HdTokens->geometry, pxr::HdReprSelector(pxr::HdReprTokens->hull)};
@@ -204,8 +210,8 @@ void HnRendererImpl::Update()
     if (m_ImagingDelegate)
     {
         m_ImagingDelegate->ApplyPendingUpdates();
-        pxr::HdTaskSharedPtrVector tasks = {
-            std::make_shared<SyncTask>(m_GeometryPass, m_RenderTags)};
+        pxr::HdTaskSharedPtrVector tasks = m_TaskController->GetRenderingTasks();
+        tasks.push_back(std::make_shared<SyncTask>(m_GeometryPass, m_RenderTags));
         m_Engine.Execute(&m_ImagingDelegate->GetRenderIndex(), &tasks);
     }
 }

Hydrogent/src/Tasks/HnPostProcessTask.cpp

@@ -32,12 +32,12 @@ namespace Diligent
 namespace USD
 {
 
-HnPostProcessTask::TaskSharedPtr HnPostProcessTask::Create(const pxr::SdfPath& Id)
+HnPostProcessTask::TaskSharedPtr HnPostProcessTask::Create(pxr::HdSceneDelegate& ParamsDelegate, const pxr::SdfPath& Id)
 {
-    return TaskSharedPtr(new HnPostProcessTask{Id});
+    return TaskSharedPtr(new HnPostProcessTask{&ParamsDelegate, Id});
 }
 
-HnPostProcessTask::HnPostProcessTask(const pxr::SdfPath& Id) :
+HnPostProcessTask::HnPostProcessTask(pxr::HdSceneDelegate* ParamsDelegate, const pxr::SdfPath& Id) :
     HnTask{Id}
 {
 }

Hydrogent/src/Tasks/HnRenderTask.cpp

@@ -32,12 +32,12 @@ namespace Diligent
 namespace USD
 {
 
-HnRenderTask::TaskSharedPtr HnRenderTask::Create(const pxr::SdfPath& Id)
+HnRenderTask::TaskSharedPtr HnRenderTask::Create(pxr::HdSceneDelegate& ParamsDelegate, const pxr::SdfPath& Id)
 {
-    return TaskSharedPtr(new HnRenderTask{Id});
+    return TaskSharedPtr(new HnRenderTask{&ParamsDelegate, Id});
 }
 
-HnRenderTask::HnRenderTask(const pxr::SdfPath& Id) :
+HnRenderTask::HnRenderTask(pxr::HdSceneDelegate* ParamsDelegate, const pxr::SdfPath& Id) :
     HnTask{Id}
 {
 }