Wire depth and shadow requests through camera renderer

engine/src/Rendering/CameraRenderer.cpp

@@ -1,6 +1,8 @@
 #include "Rendering/CameraRenderer.h"
 
+#include "Rendering/Passes/BuiltinDepthOnlyPass.h"
 #include "Rendering/Passes/BuiltinObjectIdPass.h"
+#include "Rendering/Passes/BuiltinShadowCasterPass.h"
 #include "Rendering/Pipelines/BuiltinForwardPipeline.h"
 #include "Rendering/RenderPipelineAsset.h"
 #include "Rendering/RenderSurface.h"
@@ -40,6 +42,14 @@ std::shared_ptr<const RenderPipelineAsset> CreateDefaultPipelineAsset() {
     return s_defaultPipelineAsset;
 }
 
+std::unique_ptr<RenderPass> CreateDefaultDepthOnlyPass() {
+    return std::make_unique<Passes::BuiltinDepthOnlyPass>();
+}
+
+std::unique_ptr<RenderPass> CreateDefaultShadowCasterPass() {
+    return std::make_unique<Passes::BuiltinShadowCasterPass>();
+}
+
 std::unique_ptr<RenderPipeline> CreatePipelineFromAsset(
     const std::shared_ptr<const RenderPipelineAsset>& pipelineAsset) {
     if (pipelineAsset != nullptr) {
@@ -52,6 +62,54 @@ std::unique_ptr<RenderPipeline> CreatePipelineFromAsset(
     return std::make_unique<Pipelines::BuiltinForwardPipeline>();
 }
 
+bool InitializeStandalonePass(
+    RenderPass* pass,
+    const RenderContext& context) {
+    if (pass == nullptr) {
+        return false;
+    }
+
+    if (pass->Initialize(context)) {
+        return true;
+    }
+
+    pass->Shutdown();
+    return false;
+}
+
+bool ExecuteScenePassRequest(
+    RenderPass* pass,
+    const ScenePassRenderRequest& request,
+    const RenderContext& context,
+    const RenderSceneData& baseSceneData) {
+    if (!request.IsRequested()) {
+        return true;
+    }
+
+    if (!InitializeStandalonePass(pass, context)) {
+        return false;
+    }
+
+    RenderSceneData sceneData = baseSceneData;
+    if (request.hasCameraDataOverride) {
+        sceneData.cameraData = request.cameraDataOverride;
+    }
+
+    sceneData.cameraData.viewportWidth = request.surface.GetRenderAreaWidth();
+    sceneData.cameraData.viewportHeight = request.surface.GetRenderAreaHeight();
+    sceneData.cameraData.clearFlags = request.clearFlags;
+    if (request.hasClearColorOverride) {
+        sceneData.cameraData.clearColor = request.clearColorOverride;
+    }
+
+    const RenderPassContext passContext = {
+        context,
+        request.surface,
+        sceneData
+    };
+    return pass->Execute(passContext);
+}
+
 } // namespace
 
 CameraRenderer::CameraRenderer()
@@ -59,23 +117,39 @@ CameraRenderer::CameraRenderer()
 }
 
 CameraRenderer::CameraRenderer(std::unique_ptr<RenderPipeline> pipeline)
-    : CameraRenderer(std::move(pipeline), std::make_unique<Passes::BuiltinObjectIdPass>()) {
+    : CameraRenderer(
+        std::move(pipeline),
+        std::make_unique<Passes::BuiltinObjectIdPass>(),
+        CreateDefaultDepthOnlyPass(),
+        CreateDefaultShadowCasterPass()) {
 }
 
 CameraRenderer::CameraRenderer(
     std::unique_ptr<RenderPipeline> pipeline,
-    std::unique_ptr<ObjectIdPass> objectIdPass)
+    std::unique_ptr<ObjectIdPass> objectIdPass,
+    std::unique_ptr<RenderPass> depthOnlyPass,
+    std::unique_ptr<RenderPass> shadowCasterPass)
     : m_pipelineAsset(nullptr)
-    , m_objectIdPass(std::move(objectIdPass)) {
+    , m_objectIdPass(std::move(objectIdPass))
+    , m_depthOnlyPass(std::move(depthOnlyPass))
+    , m_shadowCasterPass(std::move(shadowCasterPass)) {
     if (m_objectIdPass == nullptr) {
         m_objectIdPass = std::make_unique<Passes::BuiltinObjectIdPass>();
     }
+    if (m_depthOnlyPass == nullptr) {
+        m_depthOnlyPass = CreateDefaultDepthOnlyPass();
+    }
+    if (m_shadowCasterPass == nullptr) {
+        m_shadowCasterPass = CreateDefaultShadowCasterPass();
+    }
     ResetPipeline(std::move(pipeline));
 }
 
 CameraRenderer::CameraRenderer(std::shared_ptr<const RenderPipelineAsset> pipelineAsset)
     : m_pipelineAsset(std::move(pipelineAsset))
-    , m_objectIdPass(std::make_unique<Passes::BuiltinObjectIdPass>()) {
+    , m_objectIdPass(std::make_unique<Passes::BuiltinObjectIdPass>())
+    , m_depthOnlyPass(CreateDefaultDepthOnlyPass())
+    , m_shadowCasterPass(CreateDefaultShadowCasterPass()) {
     SetPipelineAsset(m_pipelineAsset);
 }
 
@@ -86,6 +160,12 @@ CameraRenderer::~CameraRenderer() {
     if (m_objectIdPass != nullptr) {
         m_objectIdPass->Shutdown();
     }
+    if (m_depthOnlyPass != nullptr) {
+        m_depthOnlyPass->Shutdown();
+    }
+    if (m_shadowCasterPass != nullptr) {
+        m_shadowCasterPass->Shutdown();
+    }
 }
 
 void CameraRenderer::SetPipeline(std::unique_ptr<RenderPipeline> pipeline) {
@@ -109,6 +189,28 @@ void CameraRenderer::SetObjectIdPass(std::unique_ptr<ObjectIdPass> objectIdPass)
     }
 }
 
+void CameraRenderer::SetDepthOnlyPass(std::unique_ptr<RenderPass> depthOnlyPass) {
+    if (m_depthOnlyPass != nullptr) {
+        m_depthOnlyPass->Shutdown();
+    }
+
+    m_depthOnlyPass = std::move(depthOnlyPass);
+    if (m_depthOnlyPass == nullptr) {
+        m_depthOnlyPass = CreateDefaultDepthOnlyPass();
+    }
+}
+
+void CameraRenderer::SetShadowCasterPass(std::unique_ptr<RenderPass> shadowCasterPass) {
+    if (m_shadowCasterPass != nullptr) {
+        m_shadowCasterPass->Shutdown();
+    }
+
+    m_shadowCasterPass = std::move(shadowCasterPass);
+    if (m_shadowCasterPass == nullptr) {
+        m_shadowCasterPass = CreateDefaultShadowCasterPass();
+    }
+}
+
 void CameraRenderer::ResetPipeline(std::unique_ptr<RenderPipeline> pipeline) {
     if (m_pipeline != nullptr) {
         m_pipeline->Shutdown();
@@ -131,6 +233,14 @@ bool CameraRenderer::Render(
         request.surface.GetRenderAreaHeight() == 0) {
         return false;
     }
+    if (request.depthOnly.IsRequested() &&
+        !request.depthOnly.IsValid()) {
+        return false;
+    }
+    if (request.shadowCaster.IsRequested() &&
+        !request.shadowCaster.IsValid()) {
+        return false;
+    }
     if (request.objectId.IsRequested() &&
         !request.objectId.IsValid()) {
         return false;
@@ -167,6 +277,24 @@ bool CameraRenderer::Render(
         return false;
     }
 
+    if (!ExecuteScenePassRequest(
+            m_shadowCasterPass.get(),
+            request.shadowCaster,
+            request.context,
+            sceneData)) {
+        ShutdownPassSequence(request.preScenePasses, preScenePassesInitialized);
+        return false;
+    }
+
+    if (!ExecuteScenePassRequest(
+            m_depthOnlyPass.get(),
+            request.depthOnly,
+            request.context,
+            sceneData)) {
+        ShutdownPassSequence(request.preScenePasses, preScenePassesInitialized);
+        return false;
+    }
+
     if (!m_pipeline->Render(request.context, request.surface, sceneData)) {
         ShutdownPassSequence(request.preScenePasses, preScenePassesInitialized);
         return false;