Buffer.h

Go to the documentation of this file.

#pragma once
#include <vk_mem_alloc.h>
#include <string>
 
namespace Engine::Assets
{
    class Texture;
}  // namespace Engine::Assets
 
namespace Engine::Core
{
    class ApplicationContext;
    class AssetManager;
}  // namespace Engine::Core
 
namespace Vulkan {

class Buffer{
    friend class Engine::Core::AssetManager;
    friend class Engine::Assets::Texture;
public:
 
    // Move constructor
    Buffer(Buffer&& 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
    Buffer& operator=(Buffer&& 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;
    }

    Buffer();

    Buffer(VkDevice device, VkPhysicalDevice physicalDevice);

    explicit Buffer( Engine::Core::ApplicationContext * context);
 
    ~Buffer();

    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);

    void uploadDataAtOffset(const void* data, VkDeviceSize dataSize, VkDeviceSize offset);

    bool ensureSize(size_t requiredSize, VkBufferUsageFlags usage, VkMemoryPropertyFlags properties);
 
    [[nodiscard]] VkBuffer getBuffer() const { return buffer; }
    [[nodiscard]] VkDeviceAddress getDeviceAddress() const;
    [[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;
};
}