VulkanBuffer.cpp

Go to the documentation of this file.

#include "Engine/Core/ApplicationContext.h"
#include "Engine/Core/Engine.h"
#include "Engine/Core/Exceptions.h"
#include "Engine/Core/VulkanHelper.h"
#include "Engine/Logging/TracyMacros.hpp"
 
#include <Engine/Renderer/VulkanBuffer.h>
 
namespace EngineCore
{
 
VulkanBuffer::VulkanBuffer()
{
    const Engine* engine = EngineManager::getInstance().getEngineModule();
    if (engine == nullptr) throw std::runtime_error("engine is null");
    ApplicationContext* context = engine->getContext();
    device_ = context->getVkDevice();
    physicalDevice_ = context->getVkPhysicalDevice();
    allocator_ = context->getVmaAllocator();
}
 
VulkanBuffer::VulkanBuffer( VkDevice device, VkPhysicalDevice physicalDevice )
    : device_( device )
    , physicalDevice_( physicalDevice )
    , allocator_( VK_NULL_HANDLE )  // Direct Vulkan mode - no VMA
{
}
 
VulkanBuffer::VulkanBuffer( ApplicationContext * context )
    : device_( context->getVkDevice() )
    , physicalDevice_( context->getVkPhysicalDevice() )
    , allocator_( context->getVmaAllocator() )
{
}
 
VulkanBuffer::~VulkanBuffer()
{
}
 
void VulkanBuffer::setDebugName( const std::string & name )
{
    debugName = name;
    if ( device_ != VK_NULL_HANDLE && buffer != VK_NULL_HANDLE )
    {
        VulkanHelper::setObjectName( device_, buffer, name.c_str() );
    }
    // Set VMA allocation name for debugging
    if ( allocator_ != VK_NULL_HANDLE && allocation_ != VK_NULL_HANDLE )
    {
        vmaSetAllocationName( allocator_, allocation_, name.c_str() );
    }
}
 
std::string VulkanBuffer::getDebugName() const
{
    return debugName;
}
 
void VulkanBuffer::create(size_t size, VkBufferUsageFlags usage, VkMemoryPropertyFlags properties)
{
    // Use VMA if allocator is available, otherwise fall back to VulkanHelper
    if (allocator_ != VK_NULL_HANDLE)
    {
        VkBufferCreateInfo bufferCI{VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO};
        bufferCI.size = size;
        bufferCI.usage = usage;
        bufferCI.sharingMode = VK_SHARING_MODE_EXCLUSIVE;
 
        VmaAllocationCreateInfo allocCI{};
        allocCI.usage = VMA_MEMORY_USAGE_AUTO;
 
        // Configure VMA based on requested memory properties
        if (properties & VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT)
        {
            allocCI.flags |= VMA_ALLOCATION_CREATE_HOST_ACCESS_SEQUENTIAL_WRITE_BIT;
        }
        if (properties & VK_MEMORY_PROPERTY_HOST_COHERENT_BIT)
        {
            allocCI.flags |= VMA_ALLOCATION_CREATE_MAPPED_BIT;
        }
        // For device-local memory, prefer device memory
        if ((properties & VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT) &&
            !(properties & VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT))
        {
            allocCI.usage = VMA_MEMORY_USAGE_AUTO_PREFER_DEVICE;
        }
 
        VmaAllocationInfo allocInfo{};
        if (vmaCreateBuffer(allocator_, &bufferCI, &allocCI, &buffer, &allocation_, &allocInfo) != VK_SUCCESS)
        {
            throw std::runtime_error("Failed to create VMA buffer: " + debugName);
        }
 
        this->size = size;
 
        // If mapped bit was set, VMA returns persistent mapping
        if (allocCI.flags & VMA_ALLOCATION_CREATE_MAPPED_BIT)
        {
            mappedMemory = allocInfo.pMappedData;
            isPersistentlyMapped_ = true;
        }
 
        isHostCoherent_ = (properties & VK_MEMORY_PROPERTY_HOST_COHERENT_BIT) != 0;
    }
    else
    {
        // Fallback for direct Vulkan handle usage (tests without VMA)
        VkDeviceMemory tempMemory;
        VulkanHelper::createBuffer(device_, physicalDevice_, size, usage, properties, buffer, tempMemory);
        this->size = size;
        isHostCoherent_ = (properties & VK_MEMORY_PROPERTY_HOST_COHERENT_BIT) != 0;
        // Note: tempMemory is leaked in this case - this path should only be used in tests
        // that manage memory directly
    }
}
 
void VulkanBuffer::destroy()
{
    if (allocator_ != VK_NULL_HANDLE && buffer != VK_NULL_HANDLE)
    {
        // VMA handles both buffer and memory destruction together
        // Note: VMA automatically unmaps if memory was mapped
        vmaDestroyBuffer(allocator_, buffer, allocation_);
        invalidate();
    }
    else if (device_ != VK_NULL_HANDLE && buffer != VK_NULL_HANDLE)
    {
        // Fallback for non-VMA path (should not be used in production)
        if (isMapped()) unmap();
        vkDestroyBuffer(device_, buffer, nullptr);
        invalidate();
        PLOGW << "VulkanBuffer::destroy() called without VMA - memory may be leaked";
    }
    else if (buffer != VK_NULL_HANDLE || allocation_ != VK_NULL_HANDLE)
    {
        PLOGW << "Called VulkanBuffer::destroy() with valid resources but no allocator handle. Resources could not be destroyed.";
    }
}
 
void* VulkanBuffer::map()
{
    if (isMapped()) return mappedMemory;
 
    if (allocator_ != VK_NULL_HANDLE && allocation_ != VK_NULL_HANDLE)
    {
        if (vmaMapMemory(allocator_, allocation_, &mappedMemory) != VK_SUCCESS)
        {
            PLOGE << "Failed to map VMA buffer: " << debugName;
            return nullptr;
        }
    }
    else
    {
        PLOGW << "VulkanBuffer::map() called without VMA allocation";
        return nullptr;
    }
    return mappedMemory;
}
 
void VulkanBuffer::unmap()
{
    if (isMapped())
    {
        // Only call vmaUnmapMemory for explicit mappings, not persistent ones
        // Persistent mappings (VMA_ALLOCATION_CREATE_MAPPED_BIT) should never be unmapped
        if (!isPersistentlyMapped_ && allocator_ != VK_NULL_HANDLE && allocation_ != VK_NULL_HANDLE)
        {
            vmaUnmapMemory(allocator_, allocation_);
            mappedMemory = VK_NULL_HANDLE;
        }
        // For persistent mappings, keep mappedMemory valid - the memory stays mapped
    }
}
 
void VulkanBuffer::flush(VkDeviceSize mappedOffset, VkDeviceSize mappedSize)
{
    if (!isHostCoherent_ && allocator_ != VK_NULL_HANDLE && allocation_ != VK_NULL_HANDLE)
    {
        vmaFlushAllocation(allocator_, allocation_, mappedOffset, mappedSize);
    }
}
 
void VulkanBuffer::uploadData(const void* data, VkDeviceSize dataSize)
{
    TRACY_ZONE_SCOPED_NAMED("Uploading buffer to the GPU");
    if(dataSize > size)
    {
        throw BufferWriteException("Data size is too large for buffer");
    }
 
    void* memory = map();
    memcpy(memory, data, dataSize);
    // Only flush if not host-coherent (coherent memory is automatically visible)
    if (!isHostCoherent_)
    {
        flush();
    }
    unmap();
}
 
VkDeviceMemory VulkanBuffer::getBufferMemory() const
{
    if (allocator_ != VK_NULL_HANDLE && allocation_ != VK_NULL_HANDLE)
    {
        VmaAllocationInfo info{};
        vmaGetAllocationInfo(allocator_, allocation_, &info);
        return info.deviceMemory;
    }
    return VK_NULL_HANDLE;
}
 
bool VulkanBuffer::ensureSize(size_t requiredSize, VkBufferUsageFlags usage, VkMemoryPropertyFlags properties)
{
    // Minimum size to avoid zero-sized buffers
    constexpr size_t MIN_BUFFER_SIZE = 64;
    if (requiredSize < MIN_BUFFER_SIZE) {
        requiredSize = MIN_BUFFER_SIZE;
    }
 
    // Check if current buffer is sufficient
    if (size >= requiredSize) {
        return false;
    }
 
    // Need to recreate - save debug name before destroying
    std::string savedDebugName = debugName;
 
    // Destroy existing buffer
    destroy();
 
    // Create new buffer with required size
    create(requiredSize, usage, properties);
 
    // Restore debug name
    if (!savedDebugName.empty()) {
        setDebugName(savedDebugName);
    }
 
    return true;
}
 
} // namespace EngineCore