Backend.h

#pragma once
 
#include "spark/render/Export.h"
#include "spark/render/GraphicsAdapter.h"
#include "spark/render/GraphicsDevice.h"
 
#include <optional>
 
namespace spark::core
{
    class Application;
}
 
namespace spark::render
{
    enum class BackendType
    {
        Rendering = 0x01,
        Other     = 0xFF
    };
 
    class SPARK_RENDER_EXPORT IBackend
    {
        friend class spark::core::Application;
 
    public:
        virtual ~IBackend() noexcept = default;
 
        [[nodiscard]] virtual BackendType type() const noexcept = 0;
    };
 
    class SPARK_RENDER_EXPORT IRenderBackend : public IBackend
    {
    public:
        ~IRenderBackend() noexcept override = default;
 
        [[nodiscard]] BackendType type() const noexcept override { return BackendType::Rendering; }
 
        [[nodiscard]] std::vector<const IGraphicsAdapter*> adapters() const noexcept { return genericAdapters(); }
 
        SPARK_SUPPRESS_MSVC_WARNING(4324) // 'std::optional': structure was padded due to alignment specifier
        [[nodiscard]] virtual const IGraphicsAdapter* findAdapter(const std::optional<lib::Uuid>& id = std::nullopt) const = 0;
 
        [[nodiscard]] virtual IGraphicsDevice* device(const std::string& name) noexcept = 0;
 
        [[nodiscard]] virtual const IGraphicsDevice* device(const std::string& name) const noexcept = 0;
 
    private:
        [[nodiscard]] virtual std::vector<const IGraphicsAdapter*> genericAdapters() const noexcept = 0;
    };
 
    template <typename GraphicsDeviceType>
    class RenderBackend : public IRenderBackend
    {
    public:
        using device_type = GraphicsDeviceType;
        using surface_type = typename device_type::surface_type;
        using adapter_type = typename device_type::adapter_type;
        using swap_chain_type = typename device_type::swap_chain_type;
        using command_queue_type = typename device_type::command_queue_type;
        using command_buffer_type = typename device_type::command_buffer_type;
        using frame_buffer_type = typename device_type::frame_buffer_type;
        using render_pass_type = typename device_type::render_pass_type;
        using pipeline_layout_type = typename device_type::pipeline_layout_type;
        using render_pipeline_type = typename device_type::render_pipeline_type;
        using shader_program_type = typename device_type::shader_program_type;
        using input_assembler_type = typename device_type::input_assembler_type;
        using rasterizer_type = typename device_type::rasterizer_type;
 
    public:
        ~RenderBackend() noexcept override = default;
 
        [[nodiscard]] virtual std::vector<const adapter_type*> adapters() const noexcept = 0;
 
        [[nodiscard]] const adapter_type* findAdapter(const std::optional<lib::Uuid>& id = std::nullopt) const override = 0;
 
        [[nodiscard]] device_type* device(const std::string& name) noexcept override = 0;
 
        [[nodiscard]] const device_type* device(const std::string& name) const noexcept override = 0;
 
        virtual void registerDevice(std::string name, std::unique_ptr<device_type>&& device) = 0;
 
        virtual void releaseDevice(const std::string& name) = 0;
 
        template <typename Self, typename... Args>
        device_type* createDevice(std::string name, const adapter_type& adapter, std::unique_ptr<surface_type>&& surface, Args&&... args)
        {
            auto device = std::make_unique<device_type>(adapter, std::move(surface), std::forward<Args>(args)...);
            auto* ptr = device.get();
            static_cast<Self*>(this)->registerDevice(name, std::move(device));
            return ptr;
        }
 
    private:
        [[nodiscard]] std::vector<const IGraphicsAdapter*> genericAdapters() const noexcept final
        {
            auto tmp = adapters();
            std::vector<const IGraphicsAdapter*> result;
            result.reserve(tmp.size());
            std::ranges::transform(tmp, std::back_inserter(result), [](const auto& adapter) { return static_cast<const IGraphicsAdapter*>(adapter); });
            return result;
        }
    };
}