XCEngine/engine/include/XCEngine/Rendering/Pipelines/ManagedScriptableRenderPipelineAsset.h

#pragma once

#include <XCEngine/Rendering/Pipelines/ScriptableRenderPipelineHost.h>

#include <cstdint>
#include <cstddef>
#include <memory>
#include <string>

namespace XCEngine {
namespace Rendering {

struct CameraFramePlan;
struct CameraRenderRequest;
struct DirectionalShadowExecutionState;
struct DirectionalShadowPlanningSettings;
struct DirectionalShadowSurfaceAllocation;

namespace Pipelines {

struct ManagedRenderPipelineAssetDescriptor {
    std::string assemblyName;
    std::string namespaceName;
    std::string className;
    uint32_t managedAssetHandle = 0u;

    bool IsValid() const {
        return !assemblyName.empty() && !className.empty();
    }

    bool HasManagedAssetHandle() const {
        return managedAssetHandle != 0u;
    }

    std::string GetFullName() const {
        return namespaceName.empty()
            ? className
            : namespaceName + "." + className;
    }
};

class ManagedScriptableRenderPipelineAsset final : public RenderPipelineAsset {
public:
    explicit ManagedScriptableRenderPipelineAsset(
        ManagedRenderPipelineAssetDescriptor descriptor);

    const ManagedRenderPipelineAssetDescriptor& GetDescriptor() const {
        return m_descriptor;
    }

    std::unique_ptr<RenderPipeline> CreatePipeline() const override;
    void ConfigureCameraRenderRequest(
        CameraRenderRequest& request,
        size_t renderedBaseCameraCount,
        size_t renderedRequestCount,
        const DirectionalShadowPlanningSettings& directionalShadowSettings)
        const override;
    void ConfigureCameraFramePlan(CameraFramePlan& plan) const override;
    FinalColorSettings GetDefaultFinalColorSettings() const override;

private:
    std::shared_ptr<const class ManagedRenderPipelineAssetRuntime>
    ResolveManagedAssetRuntime() const;
    std::shared_ptr<const RenderPipelineAsset>
    ResolvePipelineRendererAsset() const;
    ScriptableRenderPipelineHostAsset
    CreateExecutionHostAsset() const;

    ManagedRenderPipelineAssetDescriptor m_descriptor;
    mutable std::shared_ptr<const class ManagedRenderPipelineAssetRuntime>
        m_managedAssetRuntime = nullptr;
    mutable size_t m_managedAssetRuntimeBridgeGeneration = 0u;
};

class ManagedRenderPipelineAssetRuntime {
public:
    virtual ~ManagedRenderPipelineAssetRuntime() = default;

    virtual std::unique_ptr<RenderPipelineStageRecorder> CreateStageRecorder() const {
        return nullptr;
    }

    virtual void ConfigureCameraRenderRequest(
        CameraRenderRequest&,
        size_t,
        size_t,
        const DirectionalShadowPlanningSettings&) const {
    }
    virtual void ConfigureCameraFramePlan(CameraFramePlan&) const {
    }
    virtual bool ConfigureRenderSceneSetup(
        const CameraFramePlan&,
        RenderSceneData&) const {
        return false;
    }
    virtual bool ConfigureDirectionalShadowExecutionState(
        const CameraFramePlan&,
        const DirectionalShadowSurfaceAllocation&,
        DirectionalShadowExecutionState&) const {
        return false;
    }

    virtual std::shared_ptr<const RenderPipelineAsset>
    GetPipelineRendererAsset() const {
        return nullptr;
    }
    virtual std::shared_ptr<const RenderPipelineAsset>
    GetPipelineRendererAsset(int32_t rendererIndex) const {
        (void)rendererIndex;
        return GetPipelineRendererAsset();
    }
    virtual bool UsesNativeCameraFramePlanBaseline() const {
        return false;
    }
    virtual bool UsesNativeCameraFramePlanBaseline(
        int32_t rendererIndex) const {
        (void)rendererIndex;
        return UsesNativeCameraFramePlanBaseline();
    }
    virtual std::string GetCameraFrameStandalonePassAssetKey(
        CameraFrameStage stage) const {
        (void)stage;
        return {};
    }
    virtual std::string GetCameraFrameStandalonePassAssetKey(
        CameraFrameStage stage,
        int32_t rendererIndex) const {
        (void)rendererIndex;
        return GetCameraFrameStandalonePassAssetKey(stage);
    }

    virtual bool TryGetDefaultFinalColorSettings(FinalColorSettings&) const {
        return false;
    }
};

class ManagedRenderPipelineBridge {
public:
    virtual ~ManagedRenderPipelineBridge() = default;

    virtual std::shared_ptr<const ManagedRenderPipelineAssetRuntime>
    CreateAssetRuntime(
        const ManagedRenderPipelineAssetDescriptor&) const {
        return nullptr;
    }
};

void SetManagedRenderPipelineBridge(
    std::shared_ptr<const ManagedRenderPipelineBridge> bridge);
void ClearManagedRenderPipelineBridge();
std::shared_ptr<const ManagedRenderPipelineBridge>
GetManagedRenderPipelineBridge();
size_t GetManagedRenderPipelineEnvironmentGeneration();

void SetConfiguredManagedRenderPipelineAssetDescriptor(
    const ManagedRenderPipelineAssetDescriptor& descriptor);
void ClearConfiguredManagedRenderPipelineAssetDescriptor();
ManagedRenderPipelineAssetDescriptor
GetConfiguredManagedRenderPipelineAssetDescriptor();
std::shared_ptr<const RenderPipelineAsset>
CreateConfiguredManagedRenderPipelineAsset();

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