VulkanBuffer.h

Go to the documentation of this file.

#pragma once
 
#include <vulkan/vulkan.h>
#include <vk_mem_alloc.h>
#include <string>
 
namespace EngineCore
{
class Texture;
}
namespace EngineCore
{
class AssetManager;
class ApplicationContext;
}
namespace EngineCore {

class VulkanBuffer{
    friend AssetManager;
    friend EngineCore::Texture;
public:
 
    // Move constructor
    VulkanBuffer(VulkanBuffer&& other) noexcept
        : device_(other.device_)
        , physicalDevice_(other.physicalDevice_)
        , allocator_(other.allocator_)
        , buffer(other.buffer)
        , allocation_(other.allocation_)
        , size(other.size)
        , mappedMemory(other.mappedMemory)
        , isHostCoherent_(other.isHostCoherent_)
        , isPersistentlyMapped_(other.isPersistentlyMapped_)
    {
        // Reset the moved-from object
        other.device_ = VK_NULL_HANDLE;
        other.physicalDevice_ = VK_NULL_HANDLE;
        other.allocator_ = VK_NULL_HANDLE;
        other.buffer = VK_NULL_HANDLE;
        other.allocation_ = VK_NULL_HANDLE;
        other.size = 0;
        other.mappedMemory = nullptr;
        other.isHostCoherent_ = false;
        other.isPersistentlyMapped_ = false;
    }
 
    // Move assignment
    VulkanBuffer& operator=(VulkanBuffer&& other) noexcept
    {
        if (this != &other)
        {
            // Only destroy if we actually have resources
            if (buffer != VK_NULL_HANDLE || allocation_ != VK_NULL_HANDLE) {
                destroy();
            }
 
            // Move from other
            device_ = other.device_;
            physicalDevice_ = other.physicalDevice_;
            allocator_ = other.allocator_;
            buffer = other.buffer;
            allocation_ = other.allocation_;
            size = other.size;
            mappedMemory = other.mappedMemory;
            isHostCoherent_ = other.isHostCoherent_;
            isPersistentlyMapped_ = other.isPersistentlyMapped_;
 
            // Reset other
            other.device_ = VK_NULL_HANDLE;
            other.physicalDevice_ = VK_NULL_HANDLE;
            other.allocator_ = VK_NULL_HANDLE;
            other.buffer = VK_NULL_HANDLE;
            other.allocation_ = VK_NULL_HANDLE;
            other.size = 0;
            other.mappedMemory = VK_NULL_HANDLE;
            other.isHostCoherent_ = false;
            other.isPersistentlyMapped_ = false;
        }
        return *this;
    }

    VulkanBuffer();

    VulkanBuffer(VkDevice device, VkPhysicalDevice physicalDevice);

    explicit VulkanBuffer(ApplicationContext* context);
 
    ~VulkanBuffer();

    void setDebugName(const std::string& name);
 
    [[nodiscard]] std::string getDebugName() const;

    void create(size_t size, VkBufferUsageFlags usage, VkMemoryPropertyFlags properties);

    void destroy();

    void* map();

    void unmap();

    [[nodiscard]] bool isMapped() const { return mappedMemory != VK_NULL_HANDLE; }

    void flush(VkDeviceSize mappedOffset = 0, VkDeviceSize mappedSize = VK_WHOLE_SIZE);
    void uploadData(const void* data, VkDeviceSize dataSize);

    bool ensureSize(size_t requiredSize, VkBufferUsageFlags usage, VkMemoryPropertyFlags properties);
 
    [[nodiscard]] VkBuffer getBuffer() const { return buffer; }
    [[nodiscard]] VkDeviceMemory getBufferMemory() const;
    [[nodiscard]] VkDeviceSize getBufferSize() const { return size; }
 
    [[nodiscard]] void* getMappedMemory() const { return mappedMemory; }
    [[nodiscard]] bool isValid() const { return buffer != VK_NULL_HANDLE; }
    void invalidate()
    {
        buffer         = VK_NULL_HANDLE;
        allocation_    = VK_NULL_HANDLE;
        size           = 0;
        mappedMemory   = VK_NULL_HANDLE;
        isHostCoherent_ = false;
        isPersistentlyMapped_ = false;
    }

    void overrideSize(VkDeviceSize newSize) { size = newSize; }
 
private:
    std::string debugName = "Buffer";
 
    VkDevice device_ = VK_NULL_HANDLE;
    VkPhysicalDevice physicalDevice_ = VK_NULL_HANDLE;
    VmaAllocator allocator_ = VK_NULL_HANDLE;  
 
    VkBuffer buffer = VK_NULL_HANDLE;
    VmaAllocation allocation_ = VK_NULL_HANDLE;  
    VkDeviceSize size = 0;
 
    void* mappedMemory = VK_NULL_HANDLE;

    bool isHostCoherent_ = false;

    bool isPersistentlyMapped_ = false;
};
}