XCEngine/engine/src/Rendering/Execution/CameraRenderer.cpp

#include "Rendering/Execution/CameraRenderer.h"

#include "Components/CameraComponent.h"
#include "Rendering/Caches/DirectionalShadowSurfaceCache.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"
#include "RHI/RHIResourceView.h"
#include "Scene/Scene.h"

namespace XCEngine {
namespace Rendering {

namespace {

std::shared_ptr<const RenderPipelineAsset> CreateDefaultPipelineAsset() {
    static const std::shared_ptr<const RenderPipelineAsset> s_defaultPipelineAsset =
        std::make_shared<Pipelines::BuiltinForwardPipelineAsset>();
    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) {
        std::unique_ptr<RenderPipeline> pipeline = pipelineAsset->CreatePipeline();
        if (pipeline != nullptr) {
            return pipeline;
        }
    }

    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);
}

bool ExecuteStandalonePass(
    RenderPass* pass,
    const RenderContext& context,
    const RenderSurface& surface,
    const RenderSceneData& sceneData) {
    if (pass == nullptr) {
        return false;
    }

    if (!InitializeStandalonePass(pass, context)) {
        return false;
    }

    const RenderPassContext passContext = {
        context,
        surface,
        sceneData
    };
    return pass->Execute(passContext);
}

class ScopedInitializedPassSequence {
public:
    ScopedInitializedPassSequence(
        RenderPassSequence* sequence,
        const RenderContext& context)
        : m_sequence(sequence) {
        if (m_sequence == nullptr) {
            return;
        }

        m_initialized = m_sequence->Initialize(context);
        if (!m_initialized) {
            m_failed = true;
            m_sequence->Shutdown();
            m_sequence = nullptr;
        }
    }

    ScopedInitializedPassSequence(const ScopedInitializedPassSequence&) = delete;
    ScopedInitializedPassSequence& operator=(const ScopedInitializedPassSequence&) = delete;

    ~ScopedInitializedPassSequence() {
        if (m_sequence != nullptr && m_initialized) {
            m_sequence->Shutdown();
        }
    }

    bool IsReady() const {
        return !m_failed;
    }

    bool Execute(const RenderPassContext& context) const {
        return m_sequence == nullptr || m_sequence->Execute(context);
    }

private:
    RenderPassSequence* m_sequence = nullptr;
    bool m_initialized = false;
    bool m_failed = false;
};

struct CameraFrameExecutionState {
    RenderPipeline* pipeline = nullptr;
    RenderPass* objectIdPass = nullptr;
    RenderPass* depthOnlyPass = nullptr;
    RenderPass* shadowCasterPass = nullptr;
    std::unique_ptr<ScopedInitializedPassSequence> preScenePasses;
    std::unique_ptr<ScopedInitializedPassSequence> postScenePasses;
    std::unique_ptr<ScopedInitializedPassSequence> overlayPasses;
};

bool ExecutePassSequenceStage(
    std::unique_ptr<ScopedInitializedPassSequence>& activeSequence,
    RenderPassSequence* sequence,
    const RenderContext& context,
    const RenderPassContext& passContext) {
    activeSequence = std::make_unique<ScopedInitializedPassSequence>(sequence, context);
    return activeSequence->IsReady() && activeSequence->Execute(passContext);
}

bool ExecuteFrameStage(
    CameraFrameStage stage,
    const CameraRenderRequest& request,
    const ShadowCasterRenderRequest& resolvedShadowCaster,
    const RenderPassContext& passContext,
    CameraFrameExecutionState& executionState) {
    switch (stage) {
    case CameraFrameStage::PreScenePasses:
        return ExecutePassSequenceStage(
            executionState.preScenePasses,
            request.GetPassSequence(stage),
            request.context,
            passContext);
    case CameraFrameStage::ShadowCaster:
        return ExecuteScenePassRequest(
            executionState.shadowCasterPass,
            resolvedShadowCaster,
            request.context,
            passContext.sceneData);
    case CameraFrameStage::DepthOnly:
        return ExecuteScenePassRequest(
            executionState.depthOnlyPass,
            request.depthOnly,
            request.context,
            passContext.sceneData);
    case CameraFrameStage::MainScene:
        return executionState.pipeline != nullptr &&
               executionState.pipeline->Render(request.context, request.surface, passContext.sceneData);
    case CameraFrameStage::ObjectId:
        return !request.objectId.IsRequested() ||
               ExecuteStandalonePass(
                   executionState.objectIdPass,
                   request.context,
                   request.objectId.surface,
                   passContext.sceneData);
    case CameraFrameStage::PostScenePasses:
        return ExecutePassSequenceStage(
            executionState.postScenePasses,
            request.GetPassSequence(stage),
            request.context,
            passContext);
    case CameraFrameStage::OverlayPasses:
        return ExecutePassSequenceStage(
            executionState.overlayPasses,
            request.GetPassSequence(stage),
            request.context,
            passContext);
    default:
        return false;
    }
}

RenderDirectionalShadowData BuildDirectionalShadowData(
    const DirectionalShadowRenderPlan& plan,
    RHI::RHIResourceView* shadowMapView) {
    RenderDirectionalShadowData shadowData = {};
    if (!plan.IsValid() || shadowMapView == nullptr) {
        return shadowData;
    }

    shadowData.enabled = true;
    shadowData.viewProjection = plan.cameraData.viewProjection;
    shadowData.shadowMap = shadowMapView;
    shadowData.shadowParams = Math::Vector4(
        0.0015f,
        1.0f / static_cast<float>(plan.mapWidth),
        1.0f / static_cast<float>(plan.mapHeight),
        0.85f);
    return shadowData;
}

RenderEnvironmentData BuildEnvironmentData(const CameraRenderRequest& request) {
    RenderEnvironmentData environment = {};
    if (request.camera == nullptr ||
        request.surface.GetDepthAttachment() == nullptr ||
        !HasRenderClearFlag(request.clearFlags, RenderClearFlags::Color) ||
        !request.camera->IsSkyboxEnabled() ||
        request.camera->GetProjectionType() != Components::CameraProjectionType::Perspective) {
        return environment;
    }

    if (const Resources::Material* skyboxMaterial = request.camera->GetSkyboxMaterial()) {
        environment.mode = RenderEnvironmentMode::MaterialSkybox;
        environment.materialSkybox.material = skyboxMaterial;
        return environment;
    }

    environment.mode = RenderEnvironmentMode::ProceduralSkybox;
    environment.skybox.topColor = request.camera->GetSkyboxTopColor();
    environment.skybox.horizonColor = request.camera->GetSkyboxHorizonColor();
    environment.skybox.bottomColor = request.camera->GetSkyboxBottomColor();
    return environment;
}

} // namespace

CameraRenderer::CameraRenderer()
    : CameraRenderer(CreateDefaultPipelineAsset()) {
}

CameraRenderer::CameraRenderer(std::unique_ptr<RenderPipeline> pipeline)
    : CameraRenderer(
        std::move(pipeline),
        std::make_unique<Passes::BuiltinObjectIdPass>(),
        CreateDefaultDepthOnlyPass(),
        CreateDefaultShadowCasterPass()) {
}

CameraRenderer::CameraRenderer(
    std::unique_ptr<RenderPipeline> pipeline,
    std::unique_ptr<RenderPass> objectIdPass,
    std::unique_ptr<RenderPass> depthOnlyPass,
    std::unique_ptr<RenderPass> shadowCasterPass)
    : m_pipelineAsset(nullptr)
    , 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_depthOnlyPass(CreateDefaultDepthOnlyPass())
    , m_shadowCasterPass(CreateDefaultShadowCasterPass()) {
    SetPipelineAsset(m_pipelineAsset);
}

CameraRenderer::~CameraRenderer() {
    if (m_pipeline) {
        m_pipeline->Shutdown();
    }
    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) {
    m_pipelineAsset.reset();
    ResetPipeline(std::move(pipeline));
}

void CameraRenderer::SetPipelineAsset(std::shared_ptr<const RenderPipelineAsset> pipelineAsset) {
    m_pipelineAsset = pipelineAsset != nullptr ? std::move(pipelineAsset) : CreateDefaultPipelineAsset();
    ResetPipeline(CreatePipelineFromAsset(m_pipelineAsset));
}

void CameraRenderer::SetObjectIdPass(std::unique_ptr<RenderPass> objectIdPass) {
    if (m_objectIdPass != nullptr) {
        m_objectIdPass->Shutdown();
    }

    m_objectIdPass = std::move(objectIdPass);
    if (m_objectIdPass == nullptr) {
        m_objectIdPass = std::make_unique<Passes::BuiltinObjectIdPass>();
    }
}

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();
    }

    m_pipeline = std::move(pipeline);
    if (m_pipeline == nullptr) {
        m_pipelineAsset = CreateDefaultPipelineAsset();
        m_pipeline = CreatePipelineFromAsset(m_pipelineAsset);
    }
}

bool CameraRenderer::ResolveShadowCasterRequest(
    const CameraRenderRequest& request,
    ShadowCasterRenderRequest& outResolvedShadowCaster,
    RHI::RHIResourceView*& outShadowMapView) {
    outResolvedShadowCaster = request.shadowCaster;
    outShadowMapView = nullptr;

    if (outResolvedShadowCaster.IsRequested()) {
        return outResolvedShadowCaster.IsValid();
    }

    if (!request.directionalShadow.IsValid()) {
        return true;
    }

    if (m_directionalShadowSurface == nullptr) {
        m_directionalShadowSurface = std::make_unique<DirectionalShadowSurfaceCache>();
    }

    if (!m_directionalShadowSurface->EnsureSurface(request.context, request.directionalShadow)) {
        return false;
    }

    outResolvedShadowCaster.surface = m_directionalShadowSurface->GetSurface();
    outResolvedShadowCaster.clearFlags = RenderClearFlags::Depth;
    if (!outResolvedShadowCaster.hasCameraDataOverride) {
        outResolvedShadowCaster.hasCameraDataOverride = true;
        outResolvedShadowCaster.cameraDataOverride = request.directionalShadow.cameraData;
    }

    outShadowMapView = m_directionalShadowSurface->GetDepthShaderView();
    return true;
}

bool CameraRenderer::BuildSceneDataForRequest(
    const CameraRenderRequest& request,
    RHI::RHIResourceView* shadowMapView,
    RenderSceneData& outSceneData) {
    outSceneData = m_sceneExtractor.ExtractForCamera(
        *request.scene,
        *request.camera,
        request.surface.GetRenderAreaWidth(),
        request.surface.GetRenderAreaHeight());
    if (!outSceneData.HasCamera()) {
        return false;
    }

    if (request.directionalShadow.IsValid()) {
        outSceneData.lighting.mainDirectionalShadow =
            BuildDirectionalShadowData(request.directionalShadow, shadowMapView);
    }

    outSceneData.cameraData.clearFlags = request.clearFlags;
    outSceneData.environment = BuildEnvironmentData(request);
    if (request.hasClearColorOverride) {
        outSceneData.cameraData.clearColor = request.clearColorOverride;
    }

    return true;
}

bool CameraRenderer::ExecuteRenderPlan(
    const CameraRenderRequest& request,
    const ShadowCasterRenderRequest& resolvedShadowCaster,
    const RenderSceneData& sceneData) {
    const RenderPassContext passContext = {
        request.context,
        request.surface,
        sceneData
    };
    CameraFrameExecutionState executionState = {};
    executionState.pipeline = m_pipeline.get();
    executionState.objectIdPass = m_objectIdPass.get();
    executionState.depthOnlyPass = m_depthOnlyPass.get();
    executionState.shadowCasterPass = m_shadowCasterPass.get();

    for (const CameraFrameStageInfo& stageInfo : kOrderedCameraFrameStages) {
        if (!request.HasFrameStage(stageInfo.stage) &&
            stageInfo.stage != CameraFrameStage::MainScene) {
            continue;
        }

        if (!ExecuteFrameStage(
                stageInfo.stage,
                request,
                resolvedShadowCaster,
                passContext,
                executionState)) {
            return false;
        }
    }

    return true;
}

bool CameraRenderer::Render(
    const CameraRenderRequest& request) {
    if (!request.IsValid() || m_pipeline == nullptr) {
        return false;
    }

    if (request.surface.GetRenderAreaWidth() == 0 ||
        request.surface.GetRenderAreaHeight() == 0) {
        return false;
    }
    if (request.depthOnly.IsRequested() &&
        !request.depthOnly.IsValid()) {
        return false;
    }
    if (request.objectId.IsRequested() &&
        !request.objectId.IsValid()) {
        return false;
    }

    ShadowCasterRenderRequest resolvedShadowCaster = {};
    RHI::RHIResourceView* shadowMapView = nullptr;
    if (!ResolveShadowCasterRequest(request, resolvedShadowCaster, shadowMapView)) {
        return false;
    }

    RenderSceneData sceneData = {};
    if (!BuildSceneDataForRequest(request, shadowMapView, sceneData)) {
        return false;
    }

    return ExecuteRenderPlan(request, resolvedShadowCaster, sceneData);
}

} // namespace Rendering
} // namespace XCEngine