DataBuffer.cpp

Go to the documentation of this file.

#include "Engine/Core/DataBuffer.h"
#include "plog/Log.h"
#include "Engine/Core/VulkanHelper.h"
 
#include <sstream>
 
namespace EngineCore {
    DataBuffer::DataBuffer(VkDevice device,
        VkPhysicalDevice physicalDevice,
        VmaAllocator allocator,
        const VkBufferUsageFlags bufferUsageFlags,
        const VkMemoryPropertyFlags memoryProperties,
        const VkDeviceSize size)
        : device(device), physicalDevice(physicalDevice), allocator_(allocator), size(size)
    {
        VkBufferCreateInfo bufferCI{ VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO };
        bufferCI.size = size;
        bufferCI.usage = bufferUsageFlags;
        bufferCI.sharingMode = VK_SHARING_MODE_EXCLUSIVE;
 
        VmaAllocationCreateInfo allocCI{};
        allocCI.usage = VMA_MEMORY_USAGE_AUTO;
 
        // Configure VMA based on requested memory properties
        if (memoryProperties & VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT)
        {
            allocCI.flags |= VMA_ALLOCATION_CREATE_HOST_ACCESS_SEQUENTIAL_WRITE_BIT;
        }
        if (memoryProperties & VK_MEMORY_PROPERTY_HOST_COHERENT_BIT)
        {
            allocCI.flags |= VMA_ALLOCATION_CREATE_MAPPED_BIT;
        }
        if ((memoryProperties & VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT) &&
            !(memoryProperties & VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT))
        {
            allocCI.usage = VMA_MEMORY_USAGE_AUTO_PREFER_DEVICE;
        }
 
        if (vmaCreateBuffer(allocator_, &bufferCI, &allocCI, &buffer, &allocation_, nullptr) != VK_SUCCESS)
        {
            THROW_ERROR("Failed to create DataBuffer with VMA");
        }
    }
 
    DataBuffer::~DataBuffer()
    {
        if (allocator_ && buffer)
        {
            vmaDestroyBuffer(allocator_, buffer, allocation_);
            buffer = VK_NULL_HANDLE;
            allocation_ = VK_NULL_HANDLE;
        }
    }
 
    bool DataBuffer::copyTo(const DataBuffer& target, VkCommandBuffer commandBuffer, VkQueue queue) const
    {
        VkCommandBufferBeginInfo beginInfo{ VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO };
        beginInfo.flags = VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT;
        PLOG_THROW_FN_VK(vkBeginCommandBuffer(commandBuffer, &beginInfo));
 
        VkBufferCopy copyRegion{};
        copyRegion.size = size;
        vkCmdCopyBuffer(commandBuffer, buffer, target.getBuffer(), 1u, &copyRegion);
 
        PLOG_THROW_FN_VK(vkEndCommandBuffer(commandBuffer));
    
 
        VkSubmitInfo submitInfo{ VK_STRUCTURE_TYPE_SUBMIT_INFO };
        submitInfo.commandBufferCount = 1u;
        submitInfo.pCommandBuffers = &commandBuffer;
        PLOG_THROW_FN_VK(vkQueueSubmit(queue, 1u, &submitInfo, VK_NULL_HANDLE));
    
 
        PLOG_THROW_FN_VK(vkQueueWaitIdle(queue));
 
        return true;
    }
 
    void* DataBuffer::map() const
    {
        void* data = nullptr;
        if (allocator_ && allocation_)
        {
            if (vmaMapMemory(allocator_, allocation_, &data) != VK_SUCCESS)
            {
                PLOGE << "Failed to map DataBuffer memory";
                return nullptr;
            }
        }
        return data;
    }
 
    void DataBuffer::unmap() const
    {
        if (allocator_ && allocation_)
        {
            vmaUnmapMemory(allocator_, allocation_);
        }
    }
 
    VkBuffer DataBuffer::getBuffer() const
    {
        return buffer;
    }
}