VulkanBuffer.h

#pragma once
 
#include "spark/render/Buffer.h"
#include "spark/render/Resource.h"
#include "spark/render/vk/Export.h"
#include "spark/render/vk/Helpers.h"
 
#include "spark/base/Macros.h"
 
SPARK_FWD_DECLARE_VK_HANDLE(VkBuffer)
SPARK_FWD_DECLARE_VK_HANDLE(VmaAllocator)
SPARK_FWD_DECLARE_VK_HANDLE(VmaAllocation)
struct VkBufferCreateInfo;
struct VmaAllocationCreateInfo;
struct VmaAllocationInfo;
 
namespace spark::render::vk
{
    class SPARK_RENDER_VK_EXPORT IVulkanBuffer : public virtual IBuffer, public virtual IResource<VkBuffer> {};
 
    SPARK_WARNING_PUSH
    SPARK_DISABLE_MSVC_WARNING(4250) // 'VulkanBuffer': inherits 'Resource<VkBuffer>::handle' via dominance
 
    
    class SPARK_RENDER_VK_EXPORT VulkanBuffer : public virtual IVulkanBuffer, public Resource<VkBuffer>, public StateResource
    {
    public:
        explicit VulkanBuffer(VkBuffer buffer,
                              BufferType type,
                              unsigned elements,
                              std::size_t element_size,
                              std::size_t alignment,
                              bool writable,
                              const VmaAllocator& allocator,
                              const VmaAllocation& allocation,
                              const std::string& name);
        ~VulkanBuffer() override;
 
        VulkanBuffer(const VulkanBuffer& other) = delete;
        VulkanBuffer(VulkanBuffer&& other) noexcept = delete;
        VulkanBuffer& operator=(const VulkanBuffer& other) = delete;
        VulkanBuffer& operator=(VulkanBuffer&& other) noexcept = delete;
 
        static std::unique_ptr<IVulkanBuffer> Allocate(BufferType type,
                                                       unsigned elements,
                                                       std::size_t element_size,
                                                       std::size_t alignment,
                                                       bool writable,
                                                       const VmaAllocator& allocator,
                                                       const VkBufferCreateInfo& create_info,
                                                       const VmaAllocationCreateInfo& allocation_info,
                                                       VmaAllocationInfo* allocation_result = nullptr);
 
        static std::unique_ptr<IVulkanBuffer> Allocate(const std::string& name,
                                                       BufferType type,
                                                       unsigned elements,
                                                       std::size_t element_size,
                                                       std::size_t alignment,
                                                       bool writable,
                                                       const VmaAllocator& allocator,
                                                       const VkBufferCreateInfo& create_info,
                                                       const VmaAllocationCreateInfo& allocation_info,
                                                       VmaAllocationInfo* allocation_result = nullptr);
 
        [[nodiscard]] BufferType type() const override;
 
        [[nodiscard]] unsigned elements() const noexcept override;
 
        [[nodiscard]] std::size_t size() const noexcept override;
 
        [[nodiscard]] std::size_t elementSize() const noexcept override;
 
        [[nodiscard]] std::size_t elementAlignment() const override;
 
        [[nodiscard]] std::size_t alignedElementSize() const noexcept override;
 
        [[nodiscard]] bool writable() const noexcept override;
 
        void map(const void* data, std::size_t size, unsigned element) override;
 
        void map(std::span<const void*> data, std::size_t element_size, unsigned first_element) override;
 
        void map(void* data, size_t size, unsigned element, bool write) override;
 
        void map(std::span<void*> data, size_t element_size, unsigned first_element, bool write) override;
 
    private:
        struct Impl;
        std::unique_ptr<Impl> m_impl;
    };
 
    SPARK_WARNING_POP
}