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

#include "Rendering/Internal/RenderPipelineFactory.h"

#include <XCEngine/Rendering/RenderPipelineAsset.h>
#include <XCEngine/Rendering/RenderPipeline.h>

#include "Rendering/Execution/DirectionalShadowExecutionState.h"
#include "Rendering/Pipelines/BuiltinForwardPipeline.h"
#include "Rendering/Pipelines/Internal/BuiltinForwardSceneSetup.h"
#include "Rendering/Pipelines/ManagedScriptableRenderPipelineAsset.h"
#include "Rendering/Pipelines/ScriptableRenderPipelineHost.h"

namespace XCEngine {
namespace Rendering {
namespace Internal {

namespace {

class DefaultNativePipelineBackendAsset final : public RenderPipelineAsset {
public:
    std::unique_ptr<RenderPipeline> CreatePipeline() const override {
        return Pipelines::Internal::CreateConfiguredBuiltinForwardPipeline();
    }

    FinalColorSettings GetDefaultFinalColorSettings() const override {
        return {};
    }
};

std::shared_ptr<const RenderPipelineAsset>
CreateDefaultNativePipelineBackendAsset() {
    static const std::shared_ptr<const RenderPipelineAsset>
        s_defaultNativePipelineBackendAsset =
            std::make_shared<DefaultNativePipelineBackendAsset>();
    return s_defaultNativePipelineBackendAsset;
}

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

    return asset->CreatePipeline();
}

std::unique_ptr<SceneDrawBackend> TryCreateSceneDrawBackendFromAsset(
    const std::shared_ptr<const RenderPipelineAsset>& asset) {
    std::unique_ptr<RenderPipelineBackend> pipelineBackend =
        TryCreatePipelineBackendFromAsset(asset);
    if (pipelineBackend == nullptr) {
        return nullptr;
    }

    SceneDrawBackend* const sceneDrawBackend =
        dynamic_cast<SceneDrawBackend*>(pipelineBackend.get());
    if (sceneDrawBackend == nullptr) {
        return nullptr;
    }

    (void)pipelineBackend.release();
    return std::unique_ptr<SceneDrawBackend>(sceneDrawBackend);
}

} // 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> CreateDefaultPipelineBackendAsset() {
    static const std::shared_ptr<const RenderPipelineAsset> s_defaultAsset =
        CreateDefaultNativePipelineBackendAsset();
    return s_defaultAsset;
}

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<RenderPipelineBackend> CreatePipelineBackendFromAsset(
    const std::shared_ptr<const RenderPipelineAsset>& preferredAsset,
    std::shared_ptr<const RenderPipelineAsset>* outResolvedAsset) {
    if (std::unique_ptr<RenderPipelineBackend> pipelineBackend =
            TryCreatePipelineBackendFromAsset(preferredAsset)) {
        if (outResolvedAsset != nullptr) {
            *outResolvedAsset = preferredAsset;
        }
        return pipelineBackend;
    }

    const std::shared_ptr<const RenderPipelineAsset> defaultAsset =
        CreateDefaultPipelineBackendAsset();
    if (defaultAsset != nullptr &&
        defaultAsset != preferredAsset) {
        if (std::unique_ptr<RenderPipelineBackend> pipelineBackend =
                TryCreatePipelineBackendFromAsset(defaultAsset)) {
            if (outResolvedAsset != nullptr) {
                *outResolvedAsset = defaultAsset;
            }
            return pipelineBackend;
        }
    }

    if (outResolvedAsset != nullptr) {
        *outResolvedAsset =
            defaultAsset != nullptr
                ? defaultAsset
                : preferredAsset;
    }
    return Pipelines::Internal::CreateConfiguredBuiltinForwardPipeline();
}

std::unique_ptr<SceneDrawBackend> CreateSceneDrawBackendFromAsset(
    const std::shared_ptr<const RenderPipelineAsset>& preferredAsset,
    std::shared_ptr<const RenderPipelineAsset>* outResolvedAsset) {
    if (std::unique_ptr<SceneDrawBackend> sceneDrawBackend =
            TryCreateSceneDrawBackendFromAsset(preferredAsset)) {
        if (outResolvedAsset != nullptr) {
            *outResolvedAsset = preferredAsset;
        }
        return sceneDrawBackend;
    }

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

std::unique_ptr<SceneDrawBackend> CreateDefaultSceneDrawBackend() {
    return Pipelines::Internal::CreateConfiguredBuiltinForwardSceneDrawBackend();
}

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