Enable depth-only shadow pass execution

engine/src/Rendering/CameraRenderer.cpp

@@ -6,6 +6,9 @@
 #include "Rendering/Pipelines/BuiltinForwardPipeline.h"
 #include "Rendering/RenderPipelineAsset.h"
 #include "Rendering/RenderSurface.h"
+#include "RHI/RHIDevice.h"
+#include "RHI/RHIResourceView.h"
+#include "RHI/RHITexture.h"
 #include "Scene/Scene.h"
 
 namespace XCEngine {
@@ -13,6 +16,36 @@ namespace Rendering {
 
 namespace {
 
+struct OwnedShadowSurfaceResources {
+    RHI::RHITexture* depthTexture = nullptr;
+    RHI::RHIResourceView* depthView = nullptr;
+    RenderSurface surface = {};
+
+    OwnedShadowSurfaceResources() = default;
+    OwnedShadowSurfaceResources(const OwnedShadowSurfaceResources&) = delete;
+    OwnedShadowSurfaceResources& operator=(const OwnedShadowSurfaceResources&) = delete;
+
+    ~OwnedShadowSurfaceResources() {
+        Reset();
+    }
+
+    void Reset() {
+        if (depthView != nullptr) {
+            depthView->Shutdown();
+            delete depthView;
+            depthView = nullptr;
+        }
+
+        if (depthTexture != nullptr) {
+            depthTexture->Shutdown();
+            delete depthTexture;
+            depthTexture = nullptr;
+        }
+
+        surface = RenderSurface();
+    }
+};
+
 bool InitializePassSequence(
     RenderPassSequence* sequence,
     const RenderContext& context,
@@ -110,6 +143,52 @@ bool ExecuteScenePassRequest(
     return pass->Execute(passContext);
 }
 
+bool CreateDirectionalShadowSurface(
+    const RenderContext& context,
+    const DirectionalShadowRenderPlan& plan,
+    OwnedShadowSurfaceResources& outResources) {
+    if (!context.IsValid() || !plan.IsValid()) {
+        return false;
+    }
+
+    RHI::TextureDesc depthDesc = {};
+    depthDesc.width = plan.mapWidth;
+    depthDesc.height = plan.mapHeight;
+    depthDesc.depth = 1;
+    depthDesc.mipLevels = 1;
+    depthDesc.arraySize = 1;
+    depthDesc.format = static_cast<uint32_t>(RHI::Format::D24_UNorm_S8_UInt);
+    depthDesc.textureType = static_cast<uint32_t>(RHI::TextureType::Texture2D);
+    depthDesc.sampleCount = 1;
+    depthDesc.sampleQuality = 0;
+    depthDesc.flags = 0;
+
+    RHI::RHITexture* depthTexture = context.device->CreateTexture(depthDesc);
+    if (depthTexture == nullptr) {
+        return false;
+    }
+
+    RHI::ResourceViewDesc depthViewDesc = {};
+    depthViewDesc.format = static_cast<uint32_t>(RHI::Format::D24_UNorm_S8_UInt);
+    depthViewDesc.dimension = RHI::ResourceViewDimension::Texture2D;
+    depthViewDesc.mipLevel = 0;
+
+    RHI::RHIResourceView* depthView =
+        context.device->CreateDepthStencilView(depthTexture, depthViewDesc);
+    if (depthView == nullptr) {
+        depthTexture->Shutdown();
+        delete depthTexture;
+        return false;
+    }
+
+    outResources.Reset();
+    outResources.depthTexture = depthTexture;
+    outResources.depthView = depthView;
+    outResources.surface = RenderSurface(plan.mapWidth, plan.mapHeight);
+    outResources.surface.SetDepthAttachment(depthView);
+    return true;
+}
+
 } // namespace
 
 CameraRenderer::CameraRenderer()
@@ -237,14 +316,32 @@ bool CameraRenderer::Render(
         !request.depthOnly.IsValid()) {
         return false;
     }
-    if (request.shadowCaster.IsRequested() &&
-        !request.shadowCaster.IsValid()) {
-        return false;
-    }
     if (request.objectId.IsRequested() &&
         !request.objectId.IsValid()) {
         return false;
     }
+
+    ShadowCasterRenderRequest resolvedShadowCaster = request.shadowCaster;
+    OwnedShadowSurfaceResources ownedShadowSurface;
+    if (resolvedShadowCaster.IsRequested()) {
+        if (!resolvedShadowCaster.IsValid()) {
+            return false;
+        }
+    } else if (request.directionalShadow.IsValid()) {
+        if (!CreateDirectionalShadowSurface(
+                request.context,
+                request.directionalShadow,
+                ownedShadowSurface)) {
+            return false;
+        }
+
+        resolvedShadowCaster.surface = ownedShadowSurface.surface;
+        if (!resolvedShadowCaster.hasCameraDataOverride) {
+            resolvedShadowCaster.hasCameraDataOverride = true;
+            resolvedShadowCaster.cameraDataOverride = request.directionalShadow.cameraData;
+        }
+    }
+
     RenderSceneData sceneData = m_sceneExtractor.ExtractForCamera(
         *request.scene,
         *request.camera,
@@ -279,7 +376,7 @@ bool CameraRenderer::Render(
 
     if (!ExecuteScenePassRequest(
             m_shadowCasterPass.get(),
-            request.shadowCaster,
+            resolvedShadowCaster,
             request.context,
             sceneData)) {
         ShutdownPassSequence(request.preScenePasses, preScenePassesInitialized);