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

#pragma once

#include <XCEngine/Core/Asset/AssetRef.h>
#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 {

enum class ManagedPipelineRendererAssetPolicy {
    Unspecified = 0,
    // Runtime resolved a concrete shared native backend asset.
    ExplicitAsset = 1,
    // Runtime explicitly uses the engine default native scene backend.
    DefaultNativeBackend = 2,
};

struct ManagedRenderPipelineAssetDescriptor {
    std::string assemblyName;
    std::string namespaceName;
    std::string className;
    uint32_t managedAssetHandle = 0u;
    Resources::AssetRef assetRef = {};

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

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

    bool HasAssetRef() const {
        return assetRef.IsValid();
    }

    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>
    ResolveSharedPipelineBackendAsset() 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;
    }
    // Optional shared native backend asset for the managed pipeline runtime.
    // Current Mono-backed SRP assets typically return nullptr here and rely on
    // DefaultNativeBackend instead.
    virtual std::shared_ptr<const RenderPipelineAsset>
    GetSharedPipelineBackendAsset() const {
        return GetPipelineRendererAsset();
    }
    virtual ManagedPipelineRendererAssetPolicy
    GetPipelineRendererAssetPolicy() const {
        return GetPipelineRendererAsset() != nullptr
            ? ManagedPipelineRendererAssetPolicy::ExplicitAsset
            : ManagedPipelineRendererAssetPolicy::Unspecified;
    }
    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 SetConfiguredManagedRenderPipelineAssetRef(
    const Resources::AssetRef& assetRef);
void SetConfiguredManagedRenderPipelineAssetSelection(
    const Resources::AssetRef& assetRef,
    const ManagedRenderPipelineAssetDescriptor& descriptor);
void UpdateConfiguredManagedRenderPipelineAssetRuntimeDescriptor(
    const ManagedRenderPipelineAssetDescriptor& descriptor);
void ClearConfiguredManagedRenderPipelineAssetDescriptor();
Resources::AssetRef GetConfiguredManagedRenderPipelineAssetRef();
ManagedRenderPipelineAssetDescriptor
GetConfiguredManagedRenderPipelineAssetDescriptor();
std::shared_ptr<const RenderPipelineAsset>
CreateConfiguredManagedRenderPipelineAsset();

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