VulkanHelper.cpp

Go to the documentation of this file.

#include "Engine/Core/VulkanHelper.h"
 
#include "Engine/Core/Engine.h"
#include "Engine/Logging/TracyMacros.hpp"
#include "Engine/String/ConstExprStrings.h"
 
#include <stdexcept>
#include <vulkan/vulkan_core.h>
 
VulkanFunctions VulkanHelper::s_functions;
DynamicFunctionInitState VulkanHelper::s_functionInitializationState = NOT_INITIALIZED;
std::mutex      VulkanHelper::s_mutex;
#ifdef IS_IN_DEBUG
std::unordered_map<uint64_t, std::string> VulkanHelper::objectNames;
#endif
 
void VulkanHelper::initializeDebugFunctions( VkInstance instance )
{
    if (s_functionInitializationState < DEBUG_FUNCTIONS_INITIALIZED)
#ifdef IS_IN_DEBUG
    loadVkFunction( instance, "vkCreateDebugUtilsMessengerEXT", s_functions.vkCreateDebugUtilsMessengerEXT );
    loadVkFunction( instance, "vkDestroyDebugUtilsMessengerEXT", s_functions.vkDestroyDebugUtilsMessengerEXT );
 
    loadVkFunction( instance, "vkCmdBeginDebugUtilsLabelEXT", s_functions.vkCmdBeginDebugUtilsLabelEXT );
    loadVkFunction( instance, "vkCmdEndDebugUtilsLabelEXT", s_functions.vkCmdEndDebugUtilsLabelEXT );
 
    loadVkFunction( instance, "vkSetDebugUtilsObjectNameEXT", s_functions.vkSetDebugUtilsObjectNameEXT );
#endif
    s_functionInitializationState = DEBUG_FUNCTIONS_INITIALIZED;
}
 
void VulkanHelper::initializeFunctions( VkInstance instance, VkDevice device )
{
    std::lock_guard<std::mutex> lock( s_mutex );
    if ( s_functionInitializationState >= FINISHED )
    {
        PLOGW << "Vulkan functions already initialized. Ignoring redundant call.";
        return;
    }
 
    initializeDebugFunctions( instance );
 
    loadVkFunction( instance, "vkCmdDrawMeshTasksIndirectEXT", s_functions.vkCmdDrawMeshTasksIndirectEXT );
    loadVkFunction( instance, "vkCmdDrawMeshTasksIndirectCountEXT", s_functions.vkCmdDrawMeshTasksIndirectCountEXT );
    loadVkFunction( instance, "vkCmdPushConstants2", s_functions.vkCmdPushConstants2 );
    loadVkFunction (instance, "vkCmdBindDescriptorSets2", s_functions.vkCmdBindDescriptorSets2);
    loadVkDeviceFunction( device, "vkCmdBeginConditionalRenderingEXT",  s_functions.vkCmdBeginConditionalRenderingEXT);
    loadVkDeviceFunction( device, "vkCmdEndConditionalRenderingEXT",  s_functions.vkCmdEndConditionalRenderingEXT);
 
#ifdef ENABLE_TRACY
    // Load Tracy calibrated timestamps extension functions (only if extensions are supported)
    loadVkFunction(
        instance,
        "vkGetPhysicalDeviceCalibrateableTimeDomainsEXT",
        s_functions.vkGetPhysicalDeviceCalibrateableTimeDomainsEXT
    );
    loadVkFunction( instance, "vkGetCalibratedTimestampsEXT", s_functions.vkGetCalibratedTimestampsEXT );
    loadVkDeviceFunction( device, "vkResetQueryPool", s_functions.vkResetQueryPool );
#endif
 
    s_functionInitializationState = FINISHED;
    PLOGI << "Vulkan extension functions initialized successfully.";
}
 
const VulkanFunctions & VulkanHelper::getFunctions()
{
    if ( !s_functionInitializationState )
    {
        throw std::runtime_error(
            "Vulkan functions have not been initialized! Call VulkanHelper::initializeFunctions() first."
        );
    }
    return s_functions;
}
 
void VulkanHelper::createBuffer(
    VkDevice              device,
    VkPhysicalDevice      physicalDevice,
    VkDeviceSize          size,
    VkBufferUsageFlags    usage,
    VkMemoryPropertyFlags properties,
    VkBuffer &            buffer,
    VkDeviceMemory &      bufferMemory
)
{
#ifdef ENABLE_TRACY
    TRACY_ZONE_SCOPED_NAMED( "Create buffer" );
#endif
    VkBufferCreateInfo bufferInfo{};
    bufferInfo.sType       = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO;
    bufferInfo.size        = size;
    bufferInfo.usage       = usage;
    bufferInfo.sharingMode = VK_SHARING_MODE_EXCLUSIVE;  // it will only be accessed by the graphics pipeline
    bufferInfo.flags       = 0;
 
    {
        TRACY_ZONE_SCOPED_NAMED( "Buffer creation" );
        if ( vkCreateBuffer( device, &bufferInfo, nullptr, &buffer ) != VK_SUCCESS )
        {
            throw std::runtime_error( "failed to create buffer!" );
        }
    }
 
 
    VkMemoryRequirements memoryRequirements;
    {
        TRACY_ZONE_SCOPED_NAMED( "Finding Memory Requirements" );
        vkGetBufferMemoryRequirements( device, buffer, &memoryRequirements );
 
    }
 
    VkMemoryAllocateInfo allocInfo{};
    allocInfo.sType          = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO;
    allocInfo.allocationSize = memoryRequirements.size;
    allocInfo.memoryTypeIndex =
        findMemoryType( physicalDevice, memoryRequirements.memoryTypeBits, properties );
 
    {
        TRACY_ZONE_SCOPED_NAMED( "Allocating buffer memory" );
        if ( vkAllocateMemory( device, &allocInfo, nullptr, &bufferMemory ) != VK_SUCCESS )
        {
#if IS_IN_DEBUG
            std::stringstream ss;
            ss << "failed to allocate buffer memory for buffer ";
            ss << VulkanHelper::getDebugName( buffer );
            throw std::runtime_error(ss.str().c_str());
#else
            throw std::runtime_error( "failed to allocate vertex buffer memory!" );
#endif
        }
    }
 
    vkBindBufferMemory( device, buffer, bufferMemory, 0 );
}
 
void VulkanHelper::uploadDataToExistingBuffer(
    VkDevice         device,
    VkPhysicalDevice physicalDevice,
    VkCommandPool    commandPool,
    VkQueue          queue,
    VkDeviceSize     size,
    const void *     dataPtr,
    VkBuffer         targetBuffer
)
{
    // Create staging buffer
    VkBuffer       stagingBuffer;
    VkDeviceMemory stagingBufferMemory;
    VulkanHelper::createBuffer(
        device,
        physicalDevice,
        size,
        VK_BUFFER_USAGE_TRANSFER_SRC_BIT,
        VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT,
        stagingBuffer,
        stagingBufferMemory
    );
 
    // Map staging buffer and copy data
    void * mappedData;
    vkMapMemory( device, stagingBufferMemory, 0, size, 0, &mappedData );
    memcpy( mappedData, dataPtr, static_cast<size_t>( size ) );
    vkUnmapMemory( device, stagingBufferMemory );
 
    // Copy from staging buffer to existing target buffer
    VulkanHelper::copyBuffer( device, commandPool, queue, stagingBuffer, targetBuffer, size );
 
    // Clean up staging buffer
    vkDestroyBuffer( device, stagingBuffer, nullptr );
    vkFreeMemory( device, stagingBufferMemory, nullptr );
}
 
bool VulkanHelper::isValid( void * object )
{
    return object != VK_NULL_HANDLE;
}
 
std::string VulkanHelper::strIsValid( void * object )
{
    return isValid( object ) ? CHECK_STR : CROSS_STR;
}
 
void VulkanHelper::createBufferWithStaging(
    VkDevice           device,
    VkPhysicalDevice   physicalDevice,
    VkCommandPool      commandPool,
    VkQueue            queue,
    VkDeviceSize       size,
    VkBufferUsageFlags usage,
    const void *       dataPtr,
    VkBuffer &         buffer,
    VkDeviceMemory &   bufferMemory
)
{
    VkBuffer       stagingBuffer;
    VkDeviceMemory stagingBufferMemory;
    VulkanHelper::createBuffer(
        device,
        physicalDevice,
        size,
        VK_BUFFER_USAGE_TRANSFER_SRC_BIT,
        VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT,
        stagingBuffer,
        stagingBufferMemory
    );
 
    void * mappedData;
    vkMapMemory( device, stagingBufferMemory, 0, size, 0, &mappedData );
    memcpy( mappedData, dataPtr, static_cast<size_t>( size ) );
    vkUnmapMemory( device, stagingBufferMemory );
 
    VulkanHelper::createBuffer(
        device,
        physicalDevice,
        size,
        VK_BUFFER_USAGE_TRANSFER_DST_BIT | usage,
        VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT,
        buffer,
        bufferMemory
    );
 
    VulkanHelper::copyBuffer( device, commandPool, queue, stagingBuffer, buffer, size );
 
    vkDestroyBuffer( device, stagingBuffer, nullptr );
    vkFreeMemory( device, stagingBufferMemory, nullptr );
}
 
void VulkanHelper::copyDataToBufferViaStaging(
    VkDevice         device,
    VkPhysicalDevice physicalDevice,
    VkCommandPool    commandPool,
    VkQueue          queue,
    VkDeviceSize     size,
    const void *     dataPtr,
    VkBuffer         buffer,
    VkDeviceMemory   bufferMemory
)
{
    VkBuffer       stagingBuffer;
    VkDeviceMemory stagingBufferMemory;
 
    VulkanHelper::createBuffer(
        device,
        physicalDevice,
        size,
        VK_BUFFER_USAGE_TRANSFER_SRC_BIT,
        VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT,
        stagingBuffer,
        stagingBufferMemory
    );
 
    void * mappedData;
    vkMapMemory( device, stagingBufferMemory, 0, size, 0, &mappedData );
    memcpy( mappedData, dataPtr, static_cast<size_t>( size ) );
    vkUnmapMemory( device, stagingBufferMemory );
 
    VulkanHelper::copyBuffer( device, commandPool, queue, stagingBuffer, buffer, size );
 
    vkDestroyBuffer( device, stagingBuffer, nullptr );
    vkFreeMemory( device, stagingBufferMemory, nullptr );
}
 
uint32_t VulkanHelper::findMemoryType(
    VkPhysicalDevice      physicalDevice,
    uint32_t              typeFilter,
    VkMemoryPropertyFlags properties
)
{
    VkPhysicalDeviceMemoryProperties memoryProperties;
    vkGetPhysicalDeviceMemoryProperties( physicalDevice, &memoryProperties );
 
    for ( uint32_t i = 0; i < memoryProperties.memoryTypeCount; i++ )
    {
        if ( typeFilter & ( 1 << i ) &&
             ( memoryProperties.memoryTypes[i].propertyFlags & properties ) == properties )
        {
            return i;
        }
    }
 
    throw std::runtime_error( "failed to find suitable memory type!" );
}
 
bool VulkanHelper::findSuitableMemoryType(
    VkPhysicalDevice      physicalDevice,
    VkMemoryRequirements2 requirements,
    VkMemoryPropertyFlags properties,
    uint32_t &            out_typeIndex
)
{
    VkPhysicalDeviceMemoryProperties supportedMemoryProperties;
    vkGetPhysicalDeviceMemoryProperties( physicalDevice, &supportedMemoryProperties );
 
    const VkMemoryPropertyFlags typeFilter = requirements.memoryRequirements.memoryTypeBits;
    for ( uint32_t memoryTypeIndex = 0u; memoryTypeIndex < supportedMemoryProperties.memoryTypeCount;
          ++memoryTypeIndex )
    {
        const VkMemoryPropertyFlags propertyFlags =
            supportedMemoryProperties.memoryTypes[memoryTypeIndex].propertyFlags;
        if ( typeFilter & ( 1u << memoryTypeIndex ) && ( propertyFlags & properties ) == properties )
        {
            out_typeIndex = memoryTypeIndex;
            return true;
        }
    }
 
    return false;
}
 
VkDeviceSize VulkanHelper::align( VkDeviceSize value, VkDeviceSize alignment )
{
    if ( value == 0u )
    {
        return value;
    }
    return ( value + alignment - 1u ) & ~( alignment - 1u );
}
 
void VulkanHelper::copyBuffer(
    VkDevice      device,
    VkCommandPool commandPool,
    VkQueue       graphicsQueue,
    VkBuffer      sourceBuffer,
    VkBuffer      destinationBuffer,
    VkDeviceSize  size
)
{
#ifdef ENABLE_TRACY
    TRACY_ZONE_SCOPED_NAMED( "Copy buffer" );
#endif
    VkCommandBuffer commandBuffer = beginSingleTimeCommands( device, commandPool );
 
    VkBufferCopy copyRegion{};
    copyRegion.size = size;
    vkCmdCopyBuffer( commandBuffer, sourceBuffer, destinationBuffer, 1, &copyRegion );
 
    endSingleTimeCommands( device, graphicsQueue, commandPool, commandBuffer );
}
 
void VulkanHelper::copyBufferMultiple(
    VkDevice                              device,
    VkCommandPool                         commandPool,
    VkQueue                               graphicsQueue,
    const std::vector<BufferCopyObject> & bufferCopyObjects
)
{
#ifdef ENABLE_TRACY
    TRACY_ZONE_SCOPED_NAMED( "Copy buffer" );
#endif
    VkCommandBuffer commandBuffer = beginSingleTimeCommands( device, commandPool );
 
    for ( const BufferCopyObject & copyObject : bufferCopyObjects )
    {
        VkBufferCopy copyRegion{};
        copyRegion.size = copyObject.size;
        vkCmdCopyBuffer(
            commandBuffer, copyObject.sourceBuffer, copyObject.destinationBuffer, 1, &copyRegion
        );
    }
 
    endSingleTimeCommands( device, graphicsQueue, commandPool, commandBuffer );
}
 
void VulkanHelper::recordBufferCopyMultiple(
    EngineCore::ApplicationContext *      context,  // Pass context to get queue indices
    VkCommandBuffer                       commandBuffer,
    const std::vector<BufferCopyObject> & bufferCopyObjects
)
{
#ifdef ENABLE_TRACY
    TRACY_ZONE_SCOPED_FUNCTION;
#endif
 
    // Get queue family indices once before the loop
    uint32_t graphicsFamilyIndex = context->getVkGraphicsQueueFamilyIndex();
    uint32_t transferFamilyIndex = context->getVkTransferQueueFamilyIndex();
    bool     familiesDiffer      = ( transferFamilyIndex != graphicsFamilyIndex );
 
    for ( const BufferCopyObject & copyObject : bufferCopyObjects )
    {
        VkBufferCopy copyRegion{};
        copyRegion.size      = copyObject.size;
        copyRegion.srcOffset = 0;
        copyRegion.dstOffset = 0;
        vkCmdCopyBuffer(
            commandBuffer, copyObject.sourceBuffer, copyObject.destinationBuffer, 1, &copyRegion
        );
 
        // --- Synchronization ---
        // This barrier's job depends on whether the queue families differ.
 
        VkBufferMemoryBarrier bufferMemoryBarrier{};
        bufferMemoryBarrier.sType         = VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER;
        bufferMemoryBarrier.srcAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT;  // Memory written by the transfer
        bufferMemoryBarrier.buffer        = copyObject.destinationBuffer;
        bufferMemoryBarrier.offset        = 0;
        bufferMemoryBarrier.size          = VK_WHOLE_SIZE;
 
        if ( familiesDiffer )
        {
            // **Queue Family Release Operation**
            // If families differ, we need to release ownership from the transfer queue family.
            // The corresponding 'acquire' operation will happen in the GRAPHICS command buffer.
            bufferMemoryBarrier.dstAccessMask       = 0;  // No access needed on transfer queue after release
            bufferMemoryBarrier.srcQueueFamilyIndex = transferFamilyIndex;
            bufferMemoryBarrier.dstQueueFamilyIndex = graphicsFamilyIndex;
 
            vkCmdPipelineBarrier(
                commandBuffer,
                VK_PIPELINE_STAGE_TRANSFER_BIT,        // Stage where the write happened
                VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT,  // Doesn't matter on release, just needs to happen
                                                       // after srcStage
                0,                                     // No dependency flags needed for release
                0,
                nullptr,  // No memory barriers
                1,
                &bufferMemoryBarrier,  // The buffer release barrier
                0,
                nullptr
            );  // No image barriers
        }
        else
        {
            // **Same Queue Family**
            // No ownership transfer needed. The memory visibility for the graphics queue
            // will be handled ENTIRELY by the semaphore wait + pWaitDstStageMask
            // in the graphics vkQueueSubmit call.
            // We DON'T put graphics stages (DRAW_INDIRECT, MESH_SHADER etc.) here.
            // A barrier might *only* be needed if subsequent commands *within this transfer CB*
            // depended on this copy, which isn't the case here.
            // So, often, no barrier is needed here when families are the same.
 
            // Optional: If you wanted to ensure this write is finished before ANY
            // *subsequent* transfer command in *this same command buffer*, you could use:
            /*
            bufferMemoryBarrier.dstAccessMask = VK_ACCESS_TRANSFER_READ_BIT | VK_ACCESS_TRANSFER_WRITE_BIT; //
            Or whatever next transfer needs bufferMemoryBarrier.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
            bufferMemoryBarrier.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
 
            vkCmdPipelineBarrier(
                commandBuffer,
                VK_PIPELINE_STAGE_TRANSFER_BIT, // Stage where the write happened
                VK_PIPELINE_STAGE_TRANSFER_BIT, // Stage for subsequent transfers
                0,
                0, nullptr,
                1, &bufferMemoryBarrier,
                0, nullptr);
            */
            // However, for syncing with the graphics queue, this is NOT needed.
        }
    }  // End for loop
}
 
VkCommandBuffer VulkanHelper::beginSingleTimeCommands( VkDevice device, VkCommandPool commandPool )
{
    VkCommandBufferAllocateInfo allocInfo{};
    allocInfo.sType              = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO;
    allocInfo.level              = VK_COMMAND_BUFFER_LEVEL_PRIMARY;
    allocInfo.commandPool        = commandPool;
    allocInfo.commandBufferCount = 1;
 
    VkCommandBuffer commandBuffer;
    vkAllocateCommandBuffers( device, &allocInfo, &commandBuffer );
    VulkanHelper::setObjectName( device, commandBuffer, "Single time command buffer" );
 
    VkCommandBufferBeginInfo beginInfo{};
    beginInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO;
    beginInfo.flags = VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT;
 
    vkBeginCommandBuffer( commandBuffer, &beginInfo );
 
    return commandBuffer;
}
 
void VulkanHelper::endSingleTimeCommands(
    VkDevice        device,
    VkQueue         graphicsQueue,
    VkCommandPool   commandPool,
    VkCommandBuffer commandBuffer
)
{
    vkEndCommandBuffer( commandBuffer );
 
    VkSubmitInfo submitInfo{};
    submitInfo.sType              = VK_STRUCTURE_TYPE_SUBMIT_INFO;
    submitInfo.commandBufferCount = 1;
    submitInfo.pCommandBuffers    = &commandBuffer;
 
    vkQueueSubmit( graphicsQueue, 1, &submitInfo, VK_NULL_HANDLE );
    vkQueueWaitIdle( graphicsQueue );
 
    vkFreeCommandBuffers( device, commandPool, 1, &commandBuffer );
}
 
void VulkanHelper::cleanupBuffer( VkDevice device, VkBuffer buffer, VkDeviceMemory bufferMemory )
{
    if ( buffer != VK_NULL_HANDLE )
        vkDestroyBuffer( device, buffer, nullptr );
    if ( bufferMemory != VK_NULL_HANDLE )
        vkFreeMemory( device, bufferMemory, nullptr );
}
 
void VulkanHelper::createImage(
    VkDevice              device,
    VkPhysicalDevice      physicalDevice,
    uint32_t              width,
    uint32_t              height,
    VkFormat              format,
    VkImageTiling         tiling,
    VkImageUsageFlags     usage,
    VkMemoryPropertyFlags properties,
    VkImage &             image,
    VkDeviceMemory &      imageMemory
)
{
    VkImageCreateInfo imageInfo{};
    imageInfo.sType         = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO;
    imageInfo.imageType     = VK_IMAGE_TYPE_2D;
    imageInfo.extent.width  = width;
    imageInfo.extent.height = height;
    imageInfo.extent.depth  = 1;
    imageInfo.mipLevels     = 1;
    imageInfo.arrayLayers   = 1;
    imageInfo.format        = format;
    imageInfo.tiling        = tiling;
    imageInfo.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED;
    imageInfo.usage         = usage;
    imageInfo.sharingMode   = VK_SHARING_MODE_EXCLUSIVE;
    imageInfo.samples       = VK_SAMPLE_COUNT_1_BIT;
    imageInfo.flags         = 0;
 
    if ( vkCreateImage( device, &imageInfo, nullptr, &image ) != VK_SUCCESS )
    {
        throw std::runtime_error( "failed to create image!" );
    }
 
    VkMemoryRequirements memoryRequirements;
    vkGetImageMemoryRequirements( device, image, &memoryRequirements );
 
    VkMemoryAllocateInfo allocInfo{};
    allocInfo.sType          = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO;
    allocInfo.allocationSize = memoryRequirements.size;
    allocInfo.memoryTypeIndex =
        VulkanHelper::findMemoryType( physicalDevice, memoryRequirements.memoryTypeBits, properties );
    assert(memoryRequirements.size > 0);
    if ( vkAllocateMemory( device, &allocInfo, nullptr, &imageMemory ) != VK_SUCCESS )
    {
        throw std::runtime_error( "failed to allocate image memory!" );
    }
 
    vkBindImageMemory( device, image, imageMemory, 0 );
}
 
void VulkanHelper::transitionImageLayout(
    VkCommandBuffer commandBuffer,
    VkDevice        device,
    VkQueue         graphicsQueue,
    VkCommandPool   commandPool,
    VkImage         image,
    VkFormat        format,
    VkImageLayout   oldLayout,
    VkImageLayout   newLayout,
    uint32_t        layerCount
)
{
    VkImageMemoryBarrier barrier{};
    barrier.sType               = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER;
    barrier.oldLayout           = oldLayout;
    barrier.newLayout           = newLayout;
    barrier.image               = image;
    barrier.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;  // Add this
    barrier.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;  // Add this
 
    if ( newLayout == VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL )
    {
        barrier.subresourceRange.aspectMask = VK_IMAGE_ASPECT_DEPTH_BIT;
 
        if ( VulkanHelper::hasStencilComponent( format ) )
        {
            barrier.subresourceRange.aspectMask |= VK_IMAGE_ASPECT_STENCIL_BIT;
        }
    }
    else
    {
        barrier.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
    }
    barrier.subresourceRange.baseMipLevel   = 0;
    barrier.subresourceRange.levelCount     = 1;
    barrier.subresourceRange.baseArrayLayer = 0;
    barrier.subresourceRange.layerCount     = layerCount;  // <--- USE THE PARAMETER
 
    // This part of your function is very specific and can be improved.
    // Let's make it more robust for our use case.
    barrier.srcAccessMask = 0;
    barrier.dstAccessMask = 0;
 
    VkPipelineStageFlags sourceStage;
    VkPipelineStageFlags destinationStage;
 
    if ( oldLayout == VK_IMAGE_LAYOUT_UNDEFINED && newLayout == VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL )
    {
        barrier.srcAccessMask = 0;
        barrier.dstAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT;
        sourceStage           = VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT;
        destinationStage      = VK_PIPELINE_STAGE_TRANSFER_BIT;
    }
    else if ( oldLayout == VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL && newLayout == VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL )
    {
        barrier.srcAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT;
        barrier.dstAccessMask = VK_ACCESS_SHADER_READ_BIT;
        sourceStage           = VK_PIPELINE_STAGE_TRANSFER_BIT;
        destinationStage      = VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT;
    }
    else if ( oldLayout == VK_IMAGE_LAYOUT_UNDEFINED && newLayout == VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL )
    {
        barrier.srcAccessMask = 0;
        barrier.dstAccessMask =
            VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT | VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT;
        sourceStage      = VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT;
        destinationStage = VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT;
    }
    // ---- ADD THIS NEW CASE ----
    else if ( oldLayout == VK_IMAGE_LAYOUT_UNDEFINED && newLayout == VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL )
    {
        barrier.srcAccessMask = 0;
        barrier.dstAccessMask = VK_ACCESS_COLOR_ATTACHMENT_READ_BIT | VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT;
        sourceStage           = VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT;
        destinationStage      = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT;
    }
    else
    {
        throw std::invalid_argument( "unsupported layout transition!" );
    }
 
    vkCmdPipelineBarrier(
        commandBuffer, sourceStage, destinationStage, 0, 0, nullptr, 0, nullptr, 1, &barrier
    );
}
 
bool VulkanHelper::hasStencilComponent( VkFormat format )
{
    return format == VK_FORMAT_D32_SFLOAT_S8_UINT || format == VK_FORMAT_D24_UNORM_S8_UINT;
}
 
void VulkanHelper::copyBufferToImage(
    VkDevice      device,
    VkCommandPool commandPool,
    VkQueue       graphicsQueue,
    VkBuffer      buffer,
    VkImage       image,
    uint32_t      width,
    uint32_t      height
)
{
    VkCommandBuffer commandBuffer = beginSingleTimeCommands( device, commandPool );
 
    VkBufferImageCopy region{};
    region.bufferOffset      = 0;
    region.bufferRowLength   = 0;
    region.bufferImageHeight = 0;
 
    region.imageSubresource.aspectMask     = VK_IMAGE_ASPECT_COLOR_BIT;
    region.imageSubresource.mipLevel       = 0;
    region.imageSubresource.baseArrayLayer = 0;
    region.imageSubresource.layerCount     = 1;
 
    region.imageOffset = { 0, 0, 0 };
    region.imageExtent = { width, height, 1 };
 
    vkCmdCopyBufferToImage( commandBuffer, buffer, image, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 1, &region );
 
    VulkanHelper::endSingleTimeCommands( device, graphicsQueue, commandPool, commandBuffer );
}
 
VkImageView VulkanHelper::createImageView(
    VkDevice           device,
    VkImage            image,
    VkFormat           format,
    VkImageAspectFlags aspectFlags
)
{
    assert( image != VK_NULL_HANDLE );
 
    VkImageViewCreateInfo viewInfo{};
    viewInfo.sType    = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO;
    viewInfo.image    = image;
    viewInfo.viewType = VK_IMAGE_VIEW_TYPE_2D;
    viewInfo.format   = format;
 
    viewInfo.subresourceRange.aspectMask     = aspectFlags;
    viewInfo.subresourceRange.baseMipLevel   = 0;
    viewInfo.subresourceRange.levelCount     = 1;
    viewInfo.subresourceRange.baseArrayLayer = 0;
    viewInfo.subresourceRange.layerCount     = 1;
 
    viewInfo.components.r = VK_COMPONENT_SWIZZLE_IDENTITY;
    viewInfo.components.g = VK_COMPONENT_SWIZZLE_IDENTITY;
    viewInfo.components.b = VK_COMPONENT_SWIZZLE_IDENTITY;
    viewInfo.components.a = VK_COMPONENT_SWIZZLE_IDENTITY;
 
    VkImageView imageView = nullptr;
    if ( vkCreateImageView( device, &viewInfo, nullptr, &imageView ) != VK_SUCCESS )
    {
        throw std::runtime_error( "failed to create texture image view!" );
    }
 
    return imageView;
}
 
VkDescriptorBufferInfo VulkanHelper::fullBufferInfo( VkBuffer buffer )
{
#ifdef IS_IN_DEBUG
    PLOGD << "Buffer \"" << VulkanHelper::getDebugName( buffer ) << "\" is valid: " << VulkanHelper::strIsValid( buffer );
#endif
    VkDescriptorBufferInfo bufferInfo{
        .buffer = buffer,
        .offset = 0,
        .range = VK_WHOLE_SIZE
    };
    return bufferInfo;
}
 
VkResult VulkanHelper::allocateDescriptorSets(
    VkDevice                            device,
    const VkDescriptorSetAllocateInfo * pAllocateInfo,
    VkDescriptorSet *                   pDescriptorSets,
    const std::string &                 name
)
{
    PLOG_FN_VK_RETURN( vkAllocateDescriptorSets( device, pAllocateInfo, pDescriptorSets ) );
    setObjectName( device, *pDescriptorSets, getName( name, " Descriptor Set allocations" ) );
    return result;
}
 
VkResult VulkanHelper::createSemaphore(
    VkDevice                      device,
    const VkSemaphoreCreateInfo * pCreateInfo,
    const VkAllocationCallbacks * pAllocator,
    VkSemaphore *                 pSemaphore,
    const std::string &           name
)
{
    assert( pCreateInfo );
    PLOG_THROW_FN_VK_RETURN( vkCreateSemaphore( device, pCreateInfo, pAllocator, pSemaphore ) );
    setObjectName( device, *pSemaphore, getName( name, " Semaphore" ) );
    return result;
}
 
VkResult VulkanHelper::allocateCommandBuffers(
    VkDevice                            device,
    const VkCommandBufferAllocateInfo * pAllocateInfo,
    VkCommandBuffer *                   pCommandBuffers,
    const std::string &                 name
)
{
    PLOG_THROW_FN_VK_RETURN( vkAllocateCommandBuffers( device, pAllocateInfo, pCommandBuffers ) );
    setObjectName( device, *pCommandBuffers, getName( name, " Command Buffer allocation" ) );
    return result;
}
 
VkResult VulkanHelper::createDescriptorSetLayout(
    VkDevice                                device,
    const VkDescriptorSetLayoutCreateInfo * pCreateInfo,
    const VkAllocationCallbacks *           pAllocator,
    VkDescriptorSetLayout *                 pSetLayout,
    const std::string &                     name
)
{
    PLOG_THROW_FN_VK_RETURN( vkCreateDescriptorSetLayout( device, pCreateInfo, pAllocator, pSetLayout ) );
    setObjectName( device, *pSetLayout, getName( name, " Descriptor Set Layout" ) );
    return result;
}
 
VkResult VulkanHelper::createPipelineLayout(
    VkDevice                           device,
    const VkPipelineLayoutCreateInfo * pCreateInfo,
    const VkAllocationCallbacks *      pAllocator,
    VkPipelineLayout *                 pPipelineLayout,
    const std::string &                name
)
{
    assert(pCreateInfo != nullptr);
    PLOG_THROW_FN_VK_RETURN( vkCreatePipelineLayout( device, pCreateInfo, pAllocator, pPipelineLayout ) );
    setObjectName( device, *pPipelineLayout, getName( name, " Pipeline Layout" ) );
    return result;
}
 
void VulkanHelper::createFence(
    VkDevice                      device,
    const VkFenceCreateInfo *     pCreateInfo,
    const VkAllocationCallbacks * pAllocator,
    VkFence *                     pFence,
    const std::string &           name
)
{
    PLOG_THROW_FN_VK_RETURN( vkCreateFence( device, pCreateInfo, pAllocator, pFence ) );
    setObjectName( device, *pFence, getName( name, " Fence" ) );
}
 
VkResult VulkanHelper::createDescriptorPool(
    VkDevice                           device,
    const VkDescriptorPoolCreateInfo * pCreateInfo,
    const VkAllocationCallbacks *      pAllocator,
    VkDescriptorPool *                 pDescriptorPool,
    const std::string &                name
)
{
    PLOG_FN_VK_RETURN( vkCreateDescriptorPool( device, pCreateInfo, pAllocator, pDescriptorPool ) )
    setObjectName( device, *pDescriptorPool, getName( name, " descriptor Pool" ) );
    return result;
}
 
std::string VulkanHelper::getName( const std::string & name, const std::string & suffix )
{
    std::stringstream ss;
    ss << name;
    ss << suffix;
    return ss.str();
}
 
#ifdef IS_IN_DEBUG
void VulkanHelper::beginLabel( VkCommandBuffer commandBuffer, const char * pLabelName, const float color[4] )
{
    // Only proceed if the function pointer was successfully loaded
    if ( !s_functions.vkCmdBeginDebugUtilsLabelEXT )
    {
        return;
    }
 
    VkDebugUtilsLabelEXT labelInfo{};
    labelInfo.sType      = VK_STRUCTURE_TYPE_DEBUG_UTILS_LABEL_EXT;
    labelInfo.pLabelName = pLabelName;
 
    // The color is optional. If provided, copy it.
    if ( color )
    {
        labelInfo.color[0] = color[0];
        labelInfo.color[1] = color[1];
        labelInfo.color[2] = color[2];
        labelInfo.color[3] = color[3];
    }
 
    s_functions.vkCmdBeginDebugUtilsLabelEXT( commandBuffer, &labelInfo );
}
 
void VulkanHelper::endLabel( VkCommandBuffer commandBuffer )
{
    // Only proceed if the function pointer was successfully loaded
    if ( !s_functions.vkCmdEndDebugUtilsLabelEXT )
    {
        return;
    }
 
    s_functions.vkCmdEndDebugUtilsLabelEXT( commandBuffer );
}
#endif  // IS_IN_DEBUG
 
/*
VkSampler VulkanHelper::createTextureSampler(const EngineCore::VulkanContext context) {
 
    VkSampler textureSampler;
 
    VkSamplerCreateInfo samplerInfo{};
    samplerInfo.sType = VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO;
    samplerInfo.magFilter = VK_FILTER_LINEAR;
    samplerInfo.minFilter = VK_FILTER_LINEAR;
    samplerInfo.addressModeU = VK_SAMPLER_ADDRESS_MODE_REPEAT;
    samplerInfo.addressModeV = VK_SAMPLER_ADDRESS_MODE_REPEAT;
    samplerInfo.addressModeW = VK_SAMPLER_ADDRESS_MODE_REPEAT;
    samplerInfo.anisotropyEnable = VK_TRUE;
 
    VkPhysicalDeviceProperties properties{};
    vkGetPhysicalDeviceProperties(context.getPhysicalDevice(), &properties);
    samplerInfo.maxAnisotropy = properties.limits.maxSamplerAnisotropy;
 
    samplerInfo.borderColor = VK_BORDER_COLOR_INT_OPAQUE_BLACK;
    samplerInfo.unnormalizedCoordinates = VK_FALSE;
 
    samplerInfo.mipmapMode = VK_SAMPLER_MIPMAP_MODE_LINEAR;
    samplerInfo.mipLodBias = 0.0f;
    samplerInfo.minLod = 0.0f;
    samplerInfo.maxLod = 0.0f;
 
    if (vkCreateSampler(context.getDevice(), &samplerInfo, nullptr, &textureSampler)) {
        throw std::runtime_error("failed to create texture sampler!");
    }
 
    return textureSampler;
}
*/