XCEngine/engine/src/Rendering/Pipelines/ManagedScriptableRenderPipelineAsset.cpp

#include "Rendering/Pipelines/ManagedScriptableRenderPipelineAsset.h"

#include <utility>

namespace XCEngine {
namespace Rendering {
namespace Pipelines {

namespace {

ManagedRenderPipelineAssetDescriptor& GetManagedRenderPipelineAssetDescriptorStorage() {
    static ManagedRenderPipelineAssetDescriptor s_descriptor = {};
    return s_descriptor;
}

std::shared_ptr<const ManagedRenderPipelineBridge>& GetManagedRenderPipelineBridgeStorage() {
    static std::shared_ptr<const ManagedRenderPipelineBridge> s_bridge = nullptr;
    return s_bridge;
}

} // namespace

ManagedScriptableRenderPipelineAsset::ManagedScriptableRenderPipelineAsset(
    ManagedRenderPipelineAssetDescriptor descriptor)
    : m_descriptor(std::move(descriptor)) {
}

std::shared_ptr<const ManagedRenderPipelineAssetRuntime>
ManagedScriptableRenderPipelineAsset::ResolveManagedAssetRuntime() const {
    if (m_managedAssetRuntime != nullptr) {
        return m_managedAssetRuntime;
    }

    const std::shared_ptr<const ManagedRenderPipelineBridge> bridge =
        GetManagedRenderPipelineBridgeStorage();
    if (bridge == nullptr) {
        return nullptr;
    }

    m_managedAssetRuntime = bridge->CreateAssetRuntime(m_descriptor);
    return m_managedAssetRuntime;
}

std::unique_ptr<RenderPipeline> ManagedScriptableRenderPipelineAsset::CreatePipeline() const {
    std::unique_ptr<RenderPipeline> pipeline = m_fallbackAsset.CreatePipeline();
    auto* host = dynamic_cast<ScriptableRenderPipelineHost*>(pipeline.get());
    if (host == nullptr) {
        return pipeline;
    }

    if (const std::shared_ptr<const ManagedRenderPipelineAssetRuntime> runtime =
            ResolveManagedAssetRuntime();
        runtime != nullptr) {
        host->SetStageRecorder(runtime->CreateStageRecorder());
    }

    return pipeline;
}

FinalColorSettings ManagedScriptableRenderPipelineAsset::GetDefaultFinalColorSettings() const {
    return m_fallbackAsset.GetDefaultFinalColorSettings();
}

void ManagedScriptableRenderPipelineAsset::ConfigureCameraFramePlan(
    CameraFramePlan& plan) const {
    RenderPipelineAsset::ConfigureCameraFramePlan(plan);

    if (const std::shared_ptr<const ManagedRenderPipelineAssetRuntime> runtime =
            ResolveManagedAssetRuntime();
        runtime != nullptr) {
        runtime->ConfigureCameraFramePlan(plan);
    }
}

void SetManagedRenderPipelineBridge(
    std::shared_ptr<const ManagedRenderPipelineBridge> bridge) {
    GetManagedRenderPipelineBridgeStorage() = std::move(bridge);
}

void ClearManagedRenderPipelineBridge() {
    GetManagedRenderPipelineBridgeStorage().reset();
}

std::shared_ptr<const ManagedRenderPipelineBridge>
GetManagedRenderPipelineBridge() {
    return GetManagedRenderPipelineBridgeStorage();
}

void SetManagedRenderPipelineAssetDescriptor(
    const ManagedRenderPipelineAssetDescriptor& descriptor) {
    GetManagedRenderPipelineAssetDescriptorStorage() = descriptor;
}

void ClearManagedRenderPipelineAssetDescriptor() {
    GetManagedRenderPipelineAssetDescriptorStorage() = {};
}

ManagedRenderPipelineAssetDescriptor GetManagedRenderPipelineAssetDescriptor() {
    return GetManagedRenderPipelineAssetDescriptorStorage();
}

std::shared_ptr<const RenderPipelineAsset>
CreateManagedOrDefaultScriptableRenderPipelineAsset() {
    const ManagedRenderPipelineAssetDescriptor descriptor =
        GetManagedRenderPipelineAssetDescriptor();
    if (descriptor.IsValid()) {
        return std::make_shared<ManagedScriptableRenderPipelineAsset>(descriptor);
    }

    return std::make_shared<ScriptableRenderPipelineHostAsset>();
}

} // namespace Pipelines
} // namespace Rendering
} // namespace XCEngine