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

size_t& GetManagedRenderPipelineBridgeGenerationStorage() {
    static size_t s_generation = 1u;
    return s_generation;
}

size_t& GetManagedRenderPipelineEnvironmentGenerationStorage() {
    static size_t s_generation = 1u;
    return s_generation;
}

} // namespace

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

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

    m_managedAssetRuntime.reset();
    m_managedAssetRuntimeBridgeGeneration = bridgeGeneration;

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

void ManagedScriptableRenderPipelineAsset::ConfigureCameraRenderRequest(
    CameraRenderRequest& request,
    size_t renderedBaseCameraCount,
    size_t renderedRequestCount,
    const DirectionalShadowPlanningSettings& directionalShadowSettings) const {
    RenderPipelineAsset::ConfigureCameraRenderRequest(
        request,
        renderedBaseCameraCount,
        renderedRequestCount,
        directionalShadowSettings);

    if (const std::shared_ptr<const ManagedRenderPipelineAssetRuntime> runtime =
            ResolveManagedAssetRuntime();
        runtime != nullptr) {
        runtime->ConfigureCameraRenderRequest(
            request,
            renderedBaseCameraCount,
            renderedRequestCount,
            directionalShadowSettings);
    }
}

FinalColorSettings ManagedScriptableRenderPipelineAsset::GetDefaultFinalColorSettings() const {
    if (const std::shared_ptr<const ManagedRenderPipelineAssetRuntime> runtime =
            ResolveManagedAssetRuntime();
        runtime != nullptr) {
        FinalColorSettings settings = {};
        if (runtime->TryGetDefaultFinalColorSettings(settings)) {
            return settings;
        }
    }

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

void ClearManagedRenderPipelineBridge() {
    GetManagedRenderPipelineBridgeStorage().reset();
    ++GetManagedRenderPipelineBridgeGenerationStorage();
    ++GetManagedRenderPipelineEnvironmentGenerationStorage();
}

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

size_t GetManagedRenderPipelineEnvironmentGeneration() {
    return GetManagedRenderPipelineEnvironmentGenerationStorage();
}

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

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

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