Wire depth and shadow requests through camera renderer

engine/include/XCEngine/Rendering/CameraRenderRequest.h

@@ -13,6 +13,31 @@ class Scene;
 
 namespace Rendering {
 
+struct ScenePassRenderRequest {
+    RenderSurface surface;
+    RenderClearFlags clearFlags = RenderClearFlags::Depth;
+    bool hasClearColorOverride = false;
+    Math::Color clearColorOverride = Math::Color::Black();
+    bool hasCameraDataOverride = false;
+    RenderCameraData cameraDataOverride = {};
+
+    bool IsRequested() const {
+        return !surface.GetColorAttachments().empty();
+    }
+
+    bool IsValid() const {
+        const std::vector<RHI::RHIResourceView*>& colorAttachments = surface.GetColorAttachments();
+        return !colorAttachments.empty() &&
+               colorAttachments[0] != nullptr &&
+               surface.GetDepthAttachment() != nullptr &&
+               surface.GetRenderAreaWidth() > 0 &&
+               surface.GetRenderAreaHeight() > 0;
+    }
+};
+
+using DepthOnlyRenderRequest = ScenePassRenderRequest;
+using ShadowCasterRenderRequest = ScenePassRenderRequest;
+
 struct ObjectIdRenderRequest {
     RenderSurface surface;
 
@@ -35,6 +60,8 @@ struct CameraRenderRequest {
     Components::CameraComponent* camera = nullptr;
     RenderContext context;
     RenderSurface surface;
+    DepthOnlyRenderRequest depthOnly;
+    ShadowCasterRenderRequest shadowCaster;
     ObjectIdRenderRequest objectId;
     float cameraDepth = 0.0f;
     uint8_t cameraStackOrder = 0;

engine/include/XCEngine/Rendering/CameraRenderer.h

@@ -24,15 +24,21 @@ public:
     explicit CameraRenderer(std::shared_ptr<const RenderPipelineAsset> pipelineAsset);
     CameraRenderer(
         std::unique_ptr<RenderPipeline> pipeline,
-        std::unique_ptr<ObjectIdPass> objectIdPass);
+        std::unique_ptr<ObjectIdPass> objectIdPass,
+        std::unique_ptr<RenderPass> depthOnlyPass = nullptr,
+        std::unique_ptr<RenderPass> shadowCasterPass = nullptr);
     ~CameraRenderer();
 
     void SetPipeline(std::unique_ptr<RenderPipeline> pipeline);
     void SetPipelineAsset(std::shared_ptr<const RenderPipelineAsset> pipelineAsset);
     void SetObjectIdPass(std::unique_ptr<ObjectIdPass> objectIdPass);
+    void SetDepthOnlyPass(std::unique_ptr<RenderPass> depthOnlyPass);
+    void SetShadowCasterPass(std::unique_ptr<RenderPass> shadowCasterPass);
     RenderPipeline* GetPipeline() const { return m_pipeline.get(); }
     const RenderPipelineAsset* GetPipelineAsset() const { return m_pipelineAsset.get(); }
     ObjectIdPass* GetObjectIdPass() const { return m_objectIdPass.get(); }
+    RenderPass* GetDepthOnlyPass() const { return m_depthOnlyPass.get(); }
+    RenderPass* GetShadowCasterPass() const { return m_shadowCasterPass.get(); }
 
     bool Render(const CameraRenderRequest& request);
 
@@ -43,6 +49,8 @@ private:
     std::shared_ptr<const RenderPipelineAsset> m_pipelineAsset;
     std::unique_ptr<RenderPipeline> m_pipeline;
     std::unique_ptr<ObjectIdPass> m_objectIdPass;
+    std::unique_ptr<RenderPass> m_depthOnlyPass;
+    std::unique_ptr<RenderPass> m_shadowCasterPass;
 };
 
 } // namespace Rendering

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;

engine/src/Rendering/Passes/BuiltinDepthStylePassBase.cpp

@@ -179,8 +179,19 @@ bool BuiltinDepthStylePassBase::Execute(const RenderPassContext& context) {
         renderArea.x + renderArea.width,
         renderArea.y + renderArea.height
     };
+    const RHI::Rect clearRects[] = { scissorRect };
     commandList->SetViewport(viewport);
     commandList->SetScissorRect(scissorRect);
+
+    const Math::Color clearColor = context.sceneData.cameraData.clearColor;
+    const float clearValues[4] = { clearColor.r, clearColor.g, clearColor.b, clearColor.a };
+    if (HasRenderClearFlag(context.sceneData.cameraData.clearFlags, RenderClearFlags::Color)) {
+        commandList->ClearRenderTarget(renderTarget, clearValues, 1, clearRects);
+    }
+    if (HasRenderClearFlag(context.sceneData.cameraData.clearFlags, RenderClearFlags::Depth)) {
+        commandList->ClearDepthStencil(context.surface.GetDepthAttachment(), 1.0f, 0, 1, clearRects);
+    }
+
     commandList->SetPrimitiveTopology(RHI::PrimitiveTopology::TriangleList);
 
     for (const VisibleRenderItem& visibleItem : context.sceneData.visibleItems) {