DeviceState.h

#pragma once
 
#include "spark/render/Buffer.h"
#include "spark/render/DescriptorSet.h"
#include "spark/render/Export.h"
#include "spark/render/Image.h"
#include "spark/render/IndexBuffer.h"
#include "spark/render/Pipeline.h"
#include "spark/render/RenderPass.h"
#include "spark/render/Sampler.h"
#include "spark/render/VertexBuffer.h"
 
#include <memory>
#include <string>
 
namespace spark::render
{
    class SPARK_RENDER_EXPORT DeviceState final
    {
    public:
        explicit DeviceState();
        ~DeviceState();
 
        DeviceState(const DeviceState& other) = delete;
        DeviceState(DeviceState&& other) noexcept = delete;
        DeviceState& operator=(const DeviceState& other) = delete;
        DeviceState& operator=(DeviceState&& other) noexcept = delete;
 
        [[nodiscard]] IRenderPass& renderPass(const std::string& id) const;
 
        [[nodiscard]] IPipeline& pipeline(const std::string& id) const;
 
        [[nodiscard]] IBuffer& buffer(const std::string& id) const;
 
        [[nodiscard]] IVertexBuffer& vertexBuffer(const std::string& id) const;
 
        [[nodiscard]] IIndexBuffer& indexBuffer(const std::string& id) const;
 
        [[nodiscard]] IImage& image(const std::string& id) const;
 
        [[nodiscard]] ISampler& sampler(const std::string& id) const;
 
        [[nodiscard]] IDescriptorSet& descriptorSet(const std::string& id) const;
 
        void add(std::unique_ptr<IRenderPass>&& render_pass);
 
        void add(const std::string& id, std::unique_ptr<IRenderPass>&& render_pass);
 
        void add(std::unique_ptr<IPipeline>&& pipeline);
 
        void add(const std::string& id, std::unique_ptr<IPipeline>&& pipeline);
 
        void add(std::unique_ptr<IBuffer>&& buffer);
 
        void add(const std::string& id, std::unique_ptr<IBuffer>&& buffer);
 
        void add(std::unique_ptr<IVertexBuffer>&& vertex_buffer);
 
        void add(const std::string& id, std::unique_ptr<IVertexBuffer>&& vertex_buffer);
 
        void add(std::unique_ptr<IIndexBuffer>&& index_buffer);
 
        void add(const std::string& id, std::unique_ptr<IIndexBuffer>&& index_buffer);
 
        void add(std::unique_ptr<IImage>&& image);
 
        void add(const std::string& id, std::unique_ptr<IImage>&& image);
 
        void add(std::unique_ptr<ISampler>&& sampler);
 
        void add(const std::string& id, std::unique_ptr<ISampler>&& sampler);
 
        void add(const std::string& id, std::unique_ptr<IDescriptorSet>&& descriptor_set);
 
        bool release(const IRenderPass& render_pass);
 
        bool release(const IPipeline& pipeline);
 
        bool release(const IBuffer& buffer);
 
        bool release(const IVertexBuffer& vertex_buffer);
 
        bool release(const IIndexBuffer& index_buffer);
 
        bool release(const IImage& image);
 
        bool release(const ISampler& sampler);
 
        bool release(const IDescriptorSet& descriptor_set);
 
        void clear();
 
    private:
        struct Impl;
        std::unique_ptr<Impl> m_impl;
    };
}