GraphicsDevice.h

#pragma once
 
#include "spark/render/CommandQueue.h"
#include "spark/render/DeviceState.h"
#include "spark/render/Export.h"
#include "spark/render/GraphicsAdapter.h"
#include "spark/render/GraphicsFactory.h"
#include "spark/render/Surface.h"
#include "spark/render/SwapChain.h"
#include "spark/render/Format.h"
 
namespace spark::render
{
    class SPARK_RENDER_EXPORT IGraphicsDevice
    {
    public:
        virtual ~IGraphicsDevice() noexcept = default;
 
        [[nodiscard]] virtual DeviceState& state() noexcept = 0;
 
        [[nodiscard]] virtual const ISurface& surface() const noexcept = 0;
 
        [[nodiscard]] virtual const IGraphicsFactory& factory() const noexcept = 0;
 
        [[nodiscard]] virtual const IGraphicsAdapter& graphicsAdapter() const noexcept = 0;
 
        [[nodiscard]] virtual const ISwapChain& swapChain() const noexcept = 0;
 
        [[nodiscard]] virtual ISwapChain& swapChain() noexcept = 0;
 
        [[nodiscard]] virtual const ICommandQueue& graphicsQueue() const noexcept = 0;
 
        [[nodiscard]] virtual const ICommandQueue& transferQueue() const noexcept = 0;
 
        [[nodiscard]] virtual const ICommandQueue& bufferQueue() const noexcept = 0;
 
        [[nodiscard]] virtual const ICommandQueue& computeQueue() const noexcept = 0;
 
        [[nodiscard]] virtual MultiSamplingLevel maximumMultiSamplingLevel(Format format) const noexcept = 0;
 
        [[nodiscard]] virtual double ticksPerMillisecond() const noexcept = 0;
 
        virtual void wait() const = 0;
    };
 
    template <typename FactoryType, typename SurfaceType, typename GraphicsAdapterType, typename SwapChainType, typename CommandQueueType, typename RenderPassType>
    class GraphicsDevice : public IGraphicsDevice
    {
    public:
        using surface_type = SurfaceType;
        using adapter_type = GraphicsAdapterType;
        using swap_chain_type = SwapChainType;
        using command_queue_type = CommandQueueType;
        using command_buffer_type = typename command_queue_type::command_buffer_type;
        using factory_type = FactoryType;
        using descriptor_layout_type = typename factory_type::descriptor_layout_type;
        using vertex_buffer_type = typename factory_type::vertex_buffer_type;
        using index_buffer_type = typename factory_type::index_buffer_type;
        using buffer_type = typename factory_type::buffer_type;
        using image_type = typename factory_type::image_type;
        using sampler_type = typename factory_type::sampler_type;
        using render_pass_type = RenderPassType;
        using frame_buffer_type = typename render_pass_type::frame_buffer_type;
        using render_pipeline_type = typename render_pass_type::render_pipeline_type;
        using pipeline_layout_type = typename render_pipeline_type::pipeline_layout_type;
        using shader_program_type = typename render_pipeline_type::shader_program_type;
        using input_assembler_type = typename render_pipeline_type::input_assembler_type;
        using rasterizer_type = typename render_pipeline_type::rasterizer_type;
 
    public:
        [[nodiscard]] DeviceState& state() noexcept override = 0;
 
        [[nodiscard]] const surface_type& surface() const noexcept override = 0;
 
        [[nodiscard]] const adapter_type& graphicsAdapter() const noexcept override = 0;
 
        [[nodiscard]] const swap_chain_type& swapChain() const noexcept override = 0;
 
        [[nodiscard]] swap_chain_type& swapChain() noexcept override = 0;
 
        [[nodiscard]] const factory_type& factory() const noexcept override = 0;
 
        [[nodiscard]] const command_queue_type& graphicsQueue() const noexcept override = 0;
 
        [[nodiscard]] const command_queue_type& transferQueue() const noexcept override = 0;
 
        [[nodiscard]] const command_queue_type& bufferQueue() const noexcept override = 0;
 
        [[nodiscard]] const command_queue_type& computeQueue() const noexcept override = 0;
    };
}