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

#include "Rendering/Pipelines/ManagedScriptableRenderPipelineAsset.h"

#include "Rendering/GraphicsSettingsState.h"

#include <utility>

namespace XCEngine {
namespace Rendering {
namespace Pipelines {

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

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

    m_managedAssetRuntime.reset();
    m_managedAssetRuntimeBridgeGeneration = bridgeGeneration;

    const std::shared_ptr<const ManagedRenderPipelineBridge> bridge =
        graphicsSettings.GetManagedRenderPipelineBridge();
    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_executionHostAsset.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_executionHostAsset.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) {
    GetGraphicsSettingsState().SetManagedRenderPipelineBridge(
        std::move(bridge));
}

void ClearManagedRenderPipelineBridge() {
    GetGraphicsSettingsState().ClearManagedRenderPipelineBridge();
}

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

size_t GetManagedRenderPipelineEnvironmentGeneration() {
    return GetGraphicsSettingsState().GetEnvironmentGeneration();
}

void SetConfiguredManagedRenderPipelineAssetDescriptor(
    const ManagedRenderPipelineAssetDescriptor& descriptor) {
    GetGraphicsSettingsState().SetConfiguredRenderPipelineAssetDescriptor(
        descriptor);
}

void ClearConfiguredManagedRenderPipelineAssetDescriptor() {
    GetGraphicsSettingsState().ClearConfiguredRenderPipelineAssetDescriptor();
}

ManagedRenderPipelineAssetDescriptor
GetConfiguredManagedRenderPipelineAssetDescriptor() {
    return GetGraphicsSettingsState()
        .GetConfiguredRenderPipelineAssetDescriptor();
}

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

    return nullptr;
}

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