XCEngine/engine/include/XCEngine/Rendering/RenderPipeline.h

#pragma once

#include <XCEngine/Core/Containers/String.h>
#include <XCEngine/Rendering/Execution/CameraFrameColorSource.h>
#include <XCEngine/Rendering/Execution/CameraFrameStage.h>
#include <XCEngine/Rendering/Execution/CameraFrameRenderGraphFrameData.h>
#include <XCEngine/Rendering/Execution/FrameExecutionContext.h>
#include <XCEngine/Rendering/FrameData/RenderSceneData.h>
#include <XCEngine/Rendering/Graph/RenderGraphTypes.h>
#include <XCEngine/Rendering/Planning/FinalColorSettings.h>
#include <XCEngine/Rendering/RenderContext.h>
#include <XCEngine/Rendering/RenderPass.h>
#include <XCEngine/Rendering/RenderSurface.h>
#include <XCEngine/Rendering/Shadow/DirectionalShadowData.h>

#include <memory>
#include <array>
#include <vector>

namespace XCEngine {
namespace Rendering {

class RenderGraphBuilder;
struct CameraFramePlan;
struct DirectionalShadowExecutionState;
struct DirectionalShadowSurfaceAllocation;

void ApplyDefaultRenderPipelineDirectionalShadowExecutionPolicy(
    const CameraFramePlan& plan,
    const DirectionalShadowSurfaceAllocation& shadowAllocation,
    DirectionalShadowExecutionState& shadowState);

struct RenderPipelineStageRenderGraphContext {
    RenderGraphBuilder& graphBuilder;
    Containers::String passName = {};
    CameraFrameStage stage = CameraFrameStage::MainScene;
    const RenderContext& renderContext;
    const RenderSceneData& sceneData;
    RenderSurface surfaceTemplate = {};
    const RenderSurface* sourceSurface = nullptr;
    RHI::RHIResourceView* sourceColorView = nullptr;
    RHI::ResourceStates sourceColorState = RHI::ResourceStates::Common;
    RenderGraphTextureHandle sourceColorTexture = {};
    std::vector<RenderGraphTextureHandle> colorTargets = {};
    RenderGraphTextureHandle depthTarget = {};
    ResolvedFinalColorPolicy finalColorPolicy = {};
    bool* executionSucceeded = nullptr;
    RenderGraphBlackboard* blackboard = nullptr;
    CameraFrameColorSource stageColorSource =
        CameraFrameColorSource::ExplicitSurface;
    bool usesGraphManagedOutputColor = false;
    DirectionalShadowRenderPlan directionalShadowPlan = {};
    int32_t rendererIndex = -1;
};

class RenderPipelineRenderer;

class RenderPipelineStageRecorder {
public:
    virtual ~RenderPipelineStageRecorder() = default;

    virtual bool Initialize(const RenderContext&) {
        return true;
    }
    virtual void Shutdown() {}
    virtual void SetPipelineRenderer(RenderPipelineRenderer*) {}
    virtual bool SupportsStageRenderGraph(CameraFrameStage) const {
        return false;
    }
    virtual bool RecordStageRenderGraph(
        const RenderPipelineStageRenderGraphContext&) {
        return false;
    }
};

class RenderPipelineRenderer {
public:
    virtual ~RenderPipelineRenderer() = default;

    virtual bool Initialize(const RenderContext& context) = 0;
    virtual void Shutdown() = 0;
    virtual bool SupportsStageRenderGraph(CameraFrameStage) const {
        return false;
    }
    virtual bool RecordStageRenderGraph(
        const RenderPipelineStageRenderGraphContext&) {
        return false;
    }
    virtual bool Render(const FrameExecutionContext& executionContext) {
        return Render(
            executionContext.renderContext,
            executionContext.surface,
            executionContext.sceneData);
    }
    virtual bool Render(
        const RenderContext& context,
        const RenderSurface& surface,
        const RenderSceneData& sceneData) = 0;
};

class RenderPipeline : public RenderPipelineRenderer {
public:
    using RenderPipelineRenderer::Render;

    ~RenderPipeline() override = default;

    virtual void ConfigureRenderSceneData(
        const CameraFramePlan& plan,
        RenderSceneData& sceneData) const;
    virtual bool ConfigureDirectionalShadowExecutionState(
        const CameraFramePlan& plan,
        const DirectionalShadowSurfaceAllocation& shadowAllocation,
        DirectionalShadowExecutionState& shadowState) const;

    void SetCameraFrameStandalonePass(
        CameraFrameStage stage,
        std::unique_ptr<RenderPass> pass) {
        std::unique_ptr<RenderPass>* const passSlot =
            ResolveCameraFrameStandalonePassSlot(stage);
        if (passSlot == nullptr) {
            return;
        }

        if (*passSlot != nullptr) {
            (*passSlot)->Shutdown();
        }

        *passSlot = std::move(pass);
    }

    RenderPass* GetCameraFrameStandalonePass(CameraFrameStage stage) const {
        const std::unique_ptr<RenderPass>* const passSlot =
            ResolveCameraFrameStandalonePassSlot(stage);
        return passSlot != nullptr
            ? passSlot->get()
            : nullptr;
    }

protected:
    void ShutdownCameraFrameStandalonePasses() {
        for (std::unique_ptr<RenderPass>& pass : m_cameraFrameStandalonePasses) {
            if (pass != nullptr) {
                pass->Shutdown();
            }
        }
    }

private:
    using CameraFrameStandalonePassStorage =
        std::array<std::unique_ptr<RenderPass>, kCameraFrameStageCount>;

    std::unique_ptr<RenderPass>* ResolveCameraFrameStandalonePassSlot(
        CameraFrameStage stage) {
        if (!SupportsCameraFrameStandalonePass(stage)) {
            return nullptr;
        }

        return &m_cameraFrameStandalonePasses[GetCameraFrameStageIndex(stage)];
    }

    const std::unique_ptr<RenderPass>* ResolveCameraFrameStandalonePassSlot(
        CameraFrameStage stage) const {
        if (!SupportsCameraFrameStandalonePass(stage)) {
            return nullptr;
        }

        return &m_cameraFrameStandalonePasses[GetCameraFrameStageIndex(stage)];
    }

    CameraFrameStandalonePassStorage m_cameraFrameStandalonePasses = {};
};

} // namespace Rendering
} // namespace XCEngine