XCEngine/engine/src/Rendering/Internal/RenderPipelineFactory.cpp

#include "Rendering/Internal/RenderPipelineFactory.h"

#include "Rendering/Pipelines/BuiltinForwardPipeline.h"
#include "Rendering/Pipelines/ManagedScriptableRenderPipelineAsset.h"
#include "Rendering/Pipelines/ScriptableRenderPipelineHost.h"

namespace XCEngine {
namespace Rendering {
namespace Internal {

namespace {

std::unique_ptr<NativeSceneRenderer> TryCreateNativeSceneRendererFromAsset(
    const std::shared_ptr<const RenderPipelineAsset>& asset) {
    if (asset == nullptr) {
        return nullptr;
    }

    std::unique_ptr<RenderPipeline> pipeline = asset->CreatePipeline();
    if (pipeline == nullptr) {
        return nullptr;
    }

    NativeSceneRenderer* const sceneRenderer =
        dynamic_cast<NativeSceneRenderer*>(pipeline.get());
    if (sceneRenderer == nullptr) {
        return nullptr;
    }

    (void)pipeline.release();
    return std::unique_ptr<NativeSceneRenderer>(sceneRenderer);
}

} // namespace

std::shared_ptr<const RenderPipelineAsset> CreateConfiguredRenderPipelineAsset() {
    return Pipelines::CreateConfiguredManagedRenderPipelineAsset();
}

std::shared_ptr<const RenderPipelineAsset> CreateFallbackRenderPipelineAsset() {
    return std::make_shared<Pipelines::ScriptableRenderPipelineHostAsset>();
}

std::shared_ptr<const RenderPipelineAsset> CreatePipelineRendererAssetByKey(
    const std::string& key) {
    if (key == "BuiltinForward") {
        static const std::shared_ptr<const RenderPipelineAsset>
            s_builtinForwardPipelineAsset =
                std::make_shared<Pipelines::BuiltinForwardPipelineAsset>();
        return s_builtinForwardPipelineAsset;
    }

    return nullptr;
}

std::shared_ptr<const RenderPipelineAsset> ResolveRenderPipelineAssetOrDefault(
    std::shared_ptr<const RenderPipelineAsset> preferredAsset) {
    if (preferredAsset != nullptr) {
        return std::move(preferredAsset);
    }

    if (std::shared_ptr<const RenderPipelineAsset> configuredAsset =
            CreateConfiguredRenderPipelineAsset();
        configuredAsset != nullptr) {
        return configuredAsset;
    }

    return CreateFallbackRenderPipelineAsset();
}

std::unique_ptr<RenderPipeline> CreateRenderPipelineOrDefault(
    const std::shared_ptr<const RenderPipelineAsset>& preferredAsset,
    std::shared_ptr<const RenderPipelineAsset>* outResolvedAsset) {
    const std::shared_ptr<const RenderPipelineAsset> resolvedAsset =
        ResolveRenderPipelineAssetOrDefault(preferredAsset);
    if (resolvedAsset != nullptr) {
        if (std::unique_ptr<RenderPipeline> pipeline =
                resolvedAsset->CreatePipeline()) {
            if (outResolvedAsset != nullptr) {
                *outResolvedAsset = resolvedAsset;
            }
            return pipeline;
        }
    }

    const std::shared_ptr<const RenderPipelineAsset> defaultAsset =
        ResolveRenderPipelineAssetOrDefault(nullptr);
    if (defaultAsset != nullptr &&
        defaultAsset != resolvedAsset) {
        if (std::unique_ptr<RenderPipeline> pipeline =
                defaultAsset->CreatePipeline()) {
            if (outResolvedAsset != nullptr) {
                *outResolvedAsset = defaultAsset;
            }
            return pipeline;
        }
    }

    const std::shared_ptr<const RenderPipelineAsset> fallbackAsset =
        CreateFallbackRenderPipelineAsset();
    if (fallbackAsset != nullptr &&
        fallbackAsset != resolvedAsset &&
        fallbackAsset != defaultAsset) {
        if (std::unique_ptr<RenderPipeline> pipeline =
                fallbackAsset->CreatePipeline()) {
            if (outResolvedAsset != nullptr) {
                *outResolvedAsset = fallbackAsset;
            }
            return pipeline;
        }
    }

    if (outResolvedAsset != nullptr) {
        *outResolvedAsset =
            fallbackAsset != nullptr
                ? fallbackAsset
                : (defaultAsset != nullptr
                    ? defaultAsset
                    : resolvedAsset);
    }
    return std::make_unique<Pipelines::ScriptableRenderPipelineHost>();
}

std::unique_ptr<NativeSceneRenderer> CreateNativeSceneRendererFromAsset(
    const std::shared_ptr<const RenderPipelineAsset>& preferredAsset,
    std::shared_ptr<const RenderPipelineAsset>* outResolvedAsset) {
    if (std::unique_ptr<NativeSceneRenderer> sceneRenderer =
            TryCreateNativeSceneRendererFromAsset(preferredAsset)) {
        if (outResolvedAsset != nullptr) {
            *outResolvedAsset = preferredAsset;
        }
        return sceneRenderer;
    }

    if (outResolvedAsset != nullptr) {
        outResolvedAsset->reset();
    }
    return CreateDefaultNativeSceneRenderer();
}

std::unique_ptr<NativeSceneRenderer> CreateDefaultNativeSceneRenderer() {
    return std::make_unique<Pipelines::BuiltinForwardPipeline>();
}

} // namespace Internal
} // namespace Rendering
} // namespace XCEngine