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"
#include "Rendering/Passes/BuiltinDepthOnlyPass.h"
#include "Rendering/Passes/BuiltinObjectIdPass.h"
#include "Rendering/Passes/BuiltinShadowCasterPass.h"

namespace XCEngine {
namespace Rendering {
namespace Internal {

namespace {

std::shared_ptr<const RenderPipelineAsset>
CreateBuiltinForwardPipelineRendererAsset() {
    static const std::shared_ptr<const RenderPipelineAsset>
        s_builtinForwardPipelineAsset =
            std::make_shared<Pipelines::BuiltinForwardPipelineAsset>();
    return s_builtinForwardPipelineAsset;
}

std::unique_ptr<RenderPass> CreateBuiltinDepthOnlyStandalonePass() {
    return std::make_unique<Passes::BuiltinDepthOnlyPass>();
}

std::unique_ptr<RenderPass> CreateBuiltinObjectIdStandalonePass() {
    return std::make_unique<Passes::BuiltinObjectIdPass>();
}

std::unique_ptr<RenderPass> CreateBuiltinShadowCasterStandalonePass() {
    return std::make_unique<Passes::BuiltinShadowCasterPass>();
}

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

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

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

    (void)pipeline.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 =
        CreateBuiltinForwardPipelineRendererAsset();
    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<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() {
    if (std::unique_ptr<SceneDrawBackend> sceneDrawBackend =
            TryCreateSceneDrawBackendFromAsset(
                CreateDefaultPipelineBackendAsset());
        sceneDrawBackend != nullptr) {
        return sceneDrawBackend;
    }

    return Pipelines::Internal::CreateConfiguredBuiltinForwardPipeline();
}

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