VulkanHelper.h

Go to the documentation of this file.

#pragma once
#include "plog/Log.h"
#include <mutex>
#include <vulkan/vulkan_core.h>
#include <unordered_map>
 
 
namespace EngineCore
{
    class ApplicationContext;
}  // namespace EngineCore
 
struct VulkanFunctions
{
    PFN_vkCreateDebugUtilsMessengerEXT     vkCreateDebugUtilsMessengerEXT     = nullptr;
    PFN_vkDestroyDebugUtilsMessengerEXT    vkDestroyDebugUtilsMessengerEXT    = nullptr;
    PFN_vkCmdBeginDebugUtilsLabelEXT       vkCmdBeginDebugUtilsLabelEXT       = nullptr;
    PFN_vkCmdEndDebugUtilsLabelEXT         vkCmdEndDebugUtilsLabelEXT         = nullptr;
    PFN_vkCmdDrawMeshTasksIndirectCountEXT vkCmdDrawMeshTasksIndirectCountEXT = nullptr;
    PFN_vkCmdPushConstants2                vkCmdPushConstants2                = nullptr;
    PFN_vkCmdBindDescriptorSets2           vkCmdBindDescriptorSets2           = nullptr;
    PFN_vkSetDebugUtilsObjectNameEXT       vkSetDebugUtilsObjectNameEXT       = nullptr;
    PFN_vkCmdDrawMeshTasksIndirectEXT      vkCmdDrawMeshTasksIndirectEXT      = nullptr;
    PFN_vkCmdBeginConditionalRenderingEXT  vkCmdBeginConditionalRenderingEXT  = nullptr;
    PFN_vkCmdEndConditionalRenderingEXT    vkCmdEndConditionalRenderingEXT    = nullptr;
#ifdef ENABLE_TRACY
    // Tracy calibrated timestamps extension functions
    PFN_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT vkGetPhysicalDeviceCalibrateableTimeDomainsEXT =
        nullptr;
    PFN_vkGetCalibratedTimestampsEXT vkGetCalibratedTimestampsEXT = nullptr;
    PFN_vkResetQueryPool             vkResetQueryPool             = nullptr;
#endif
};
 
struct BufferCopyObject
{
    VkBuffer     sourceBuffer;
    VkBuffer     destinationBuffer;
    VkDeviceSize size;
    VkDeviceSize srcOffset = 0;  
    VkDeviceSize dstOffset = 0;  
};
 
enum DynamicFunctionInitState : uint32_t
{
    NOT_INITIALIZED = 0,
    DEBUG_FUNCTIONS_INITIALIZED = 1,
    FINISHED = 2
};

class VulkanHelper
{
public:
    static void initializeDebugFunctions(VkInstance instance);
    static void                    initializeFunctions( VkInstance instance, VkDevice device );
    static const VulkanFunctions & getFunctions();
 
    template <typename T>
    static void loadVkFunction( VkInstance instance, const std::string & name, T & functionPointer )
    {
        functionPointer = reinterpret_cast<T>( vkGetInstanceProcAddr( instance, name.c_str() ) );
 
        if ( !functionPointer )
        {
            std::stringstream error;
            error << "Vulkan INSTANCE extension function " << name << " is not supported!";
            PLOGE << error.str();
            throw std::runtime_error( error.str() );
        }
    }
 
    template <typename T>
    static void loadVkDeviceFunction( VkDevice device, const std::string & name, T & functionPointer )
    {
        functionPointer = reinterpret_cast<T>( vkGetDeviceProcAddr( device, name.c_str() ) );
        if ( !functionPointer )
        {
            std::stringstream error;
            error << "Vulkan DEVICE extension function " << name << " is not supported!";
            PLOGE << error.str();
            throw std::runtime_error( error.str() );
        }
    }

    [[deprecated("Use VulkanBuffer with VMA instead")]]
    static void createBuffer(
        VkDevice              device,
        VkPhysicalDevice      physicalDevice,
        VkDeviceSize          size,
        VkBufferUsageFlags    usage,
        VkMemoryPropertyFlags properties,
        VkBuffer &            buffer,
        VkDeviceMemory &      bufferMemory
    );
 
    static void uploadDataToExistingBuffer(
        VkDevice         device,
        VkPhysicalDevice physicalDevice,
        VkCommandPool    commandPool,
        VkQueue          queue,
        VkDeviceSize     size,
        const void *     dataPtr,
        VkBuffer         targetBuffer
    );
 
    static bool isValid( void * object );
 
    static std::string strIsValid( void * object );
 
    static void createBufferWithStaging(
        VkDevice           device,
        VkPhysicalDevice   physicalDevice,
        VkCommandPool      commandPool,
        VkQueue            queue,
        VkDeviceSize       size,
        VkBufferUsageFlags usage,
        const void *       dataPtr,
        VkBuffer &         buffer,
        VkDeviceMemory &   bufferMemory
    );
 
    static void copyDataToBufferViaStaging(
        VkDevice         device,
        VkPhysicalDevice physicalDevice,
        VkCommandPool    commandPool,
        VkQueue          queue,
        VkDeviceSize     size,
        const void *     dataPtr,
        VkBuffer         buffer,
        VkDeviceMemory   bufferMemory
    );
 
    static uint32_t findMemoryType(
        VkPhysicalDevice      physicalDevice,
        uint32_t              typeFilter,
        VkMemoryPropertyFlags properties
    );
 
    static bool findSuitableMemoryType(
        VkPhysicalDevice      physicalDevice,
        VkMemoryRequirements2 requirements,
        VkMemoryPropertyFlags properties,
        uint32_t &            out_typeIndex
    );
 
    static VkDeviceSize align( VkDeviceSize value, VkDeviceSize alignment );
 
    static void copyBuffer(
        VkDevice      device,
        VkCommandPool commandPool,
        VkQueue       graphicsQueue,
        VkBuffer      sourceBuffer,
        VkBuffer      destinationBuffer,
        VkDeviceSize  size
    );
 
    static void copyBufferMultiple(
        VkDevice                              device,
        VkCommandPool                         commandPool,
        VkQueue                               graphicsQueue,
        const std::vector<BufferCopyObject> & bufferCopyObjects
    );
 
    static void recordBufferCopyMultiple(
        EngineCore::ApplicationContext *      context,
        VkCommandBuffer                       commandBuffer,
        const std::vector<BufferCopyObject> & bufferCopyObjects
    );
 
    static VkCommandBuffer beginSingleTimeCommands( VkDevice device, VkCommandPool commandPool );
    static void            endSingleTimeCommands(
                   VkDevice        device,
                   VkQueue         graphicsQueue,
                   VkCommandPool   commandPool,
                   VkCommandBuffer commandBuffer
               );
    static void cleanupBuffer( VkDevice device, VkBuffer buffer, VkDeviceMemory bufferMemory );
    [[deprecated("Use Texture class with VMA instead")]]
    static void createImage(
        VkDevice              device,
        VkPhysicalDevice      physicalDevice,
        uint32_t              width,
        uint32_t              height,
        VkFormat              format,
        VkImageTiling         tiling,
        VkImageUsageFlags     usage,
        VkMemoryPropertyFlags properties,
        VkImage &             image,
        VkDeviceMemory &      imageMemory
    );
 
    static void transitionImageLayout(
        VkCommandBuffer commandBuffer,
        VkDevice        device,
        VkQueue         graphicsQueue,
        VkCommandPool   commandPool,
        VkImage         image,
        VkFormat        format,
        VkImageLayout   oldLayout,
        VkImageLayout   newLayout,
        uint32_t        layerCount = 1
    );
 
    static bool hasStencilComponent( VkFormat format );
 
    static void copyBufferToImage(
        VkDevice      device,
        VkCommandPool commandPool,
        VkQueue       graphicsQueue,
        VkBuffer      buffer,
        VkImage       image,
        uint32_t      width,
        uint32_t      height
    );
 
    static VkImageView
        createImageView( VkDevice device, VkImage image, VkFormat format, VkImageAspectFlags aspectFlags );
 
    static VkDescriptorBufferInfo fullBufferInfo( VkBuffer buffer );
 
    static VkResult allocateDescriptorSets(
        VkDevice                            device,
        const VkDescriptorSetAllocateInfo * pAllocateInfo,
        VkDescriptorSet *                   pDescriptorSets,
        const std::string &                 name
    );
 
    static VkResult createSemaphore(
        VkDevice                      device,
        const VkSemaphoreCreateInfo * pCreateInfo,
        const VkAllocationCallbacks * pAllocator,
        VkSemaphore *                 pSemaphore,
        const std::string &           name
    );
 
    static VkResult allocateCommandBuffers(
        VkDevice                            device,
        const VkCommandBufferAllocateInfo * pAllocateInfo,
        VkCommandBuffer *                   pCommandBuffers,
        const std::string &                 name
    );
 
    static VkResult createDescriptorSetLayout(
        VkDevice                                device,
        const VkDescriptorSetLayoutCreateInfo * pCreateInfo,
        const VkAllocationCallbacks *           pAllocator,
        VkDescriptorSetLayout *                 pSetLayout,
        const std::string &                     name
    );
 
    static VkResult createPipelineLayout(
        VkDevice                           device,
        const VkPipelineLayoutCreateInfo * pCreateInfo,
        const VkAllocationCallbacks *      pAllocator,
        VkPipelineLayout *                 pPipelineLayout,
        const std::string &                name
    );
 
    static void createFence(
        VkDevice                      device,
        const VkFenceCreateInfo *     pCreateInfo,
        const VkAllocationCallbacks * pAllocator,
        VkFence *                     pFence,
        const std::string &           name
    );
 
    static VkResult createDescriptorPool(
        VkDevice                           device,
        const VkDescriptorPoolCreateInfo * pCreateInfo,
        const VkAllocationCallbacks *      pAllocator,
        VkDescriptorPool *                 pDescriptorPool,
        const std::string &                name
    );
 
private:
    static std::string getName( const std::string & name, const std::string & suffix );
 
public:
    /*static VkSampler createTextureSampler(const EngineCore::VulkanContext context);*/
#ifdef IS_IN_DEBUG
    static void
        beginLabel( VkCommandBuffer commandBuffer, const char * pLabelName, const float color[4] = nullptr );

    static void endLabel( VkCommandBuffer commandBuffer );
 
private:
    static std::unordered_map<uint64_t, std::string> objectNames;
public:
#else
    // In release builds, these functions are empty and will be optimized away.
    static void beginLabel( VkCommandBuffer, const char *, const float * ) {}
 
    static void endLabel( VkCommandBuffer ) {}
#endif
 
public:
#ifdef IS_IN_DEBUG
 
#    define VK_OBJECT_TYPE_CASE( VkType, VkEnum )                                                            \
        if constexpr ( std::is_same_v<VulkanObjectType, VkType> )                                            \
            return VkEnum;
 
    template <typename VulkanObjectType>
    static constexpr VkObjectType getVulkanObjectType()
    {
        VK_OBJECT_TYPE_CASE( VkBuffer, VK_OBJECT_TYPE_BUFFER );
        VK_OBJECT_TYPE_CASE( VkQueue, VK_OBJECT_TYPE_QUEUE );
        VK_OBJECT_TYPE_CASE( VkDescriptorPool, VK_OBJECT_TYPE_DESCRIPTOR_POOL );
        VK_OBJECT_TYPE_CASE( VkDescriptorSetLayout, VK_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT );
        VK_OBJECT_TYPE_CASE( VkDescriptorSet, VK_OBJECT_TYPE_DESCRIPTOR_SET );
        VK_OBJECT_TYPE_CASE( VkPipelineLayout, VK_OBJECT_TYPE_PIPELINE_LAYOUT );
        VK_OBJECT_TYPE_CASE( VkPipeline, VK_OBJECT_TYPE_PIPELINE );
        VK_OBJECT_TYPE_CASE( VkCommandBuffer, VK_OBJECT_TYPE_COMMAND_BUFFER );
        VK_OBJECT_TYPE_CASE( VkSemaphore, VK_OBJECT_TYPE_SEMAPHORE );
        VK_OBJECT_TYPE_CASE( VkFence, VK_OBJECT_TYPE_FENCE );
        VK_OBJECT_TYPE_CASE( VkImage, VK_OBJECT_TYPE_IMAGE );
        VK_OBJECT_TYPE_CASE( VkDeviceMemory, VK_OBJECT_TYPE_DEVICE_MEMORY );
        VK_OBJECT_TYPE_CASE( VkImageView, VK_OBJECT_TYPE_IMAGE_VIEW );
        VK_OBJECT_TYPE_CASE( VkSampler, VK_OBJECT_TYPE_SAMPLER );
        VK_OBJECT_TYPE_CASE( VkRenderPass, VK_OBJECT_TYPE_RENDER_PASS );
        VK_OBJECT_TYPE_CASE( VkShaderModule, VK_OBJECT_TYPE_SHADER_MODULE );
        VK_OBJECT_TYPE_CASE( VkCommandPool, VK_OBJECT_TYPE_COMMAND_POOL );
 
        PLOGF << "Failed to find the type of " << typeid( VulkanObjectType ).name();
        return VK_OBJECT_TYPE_UNKNOWN;
    }

    template <typename VulkanObjectType>
    static void setObjectName( VkDevice device, VulkanObjectType objectHandle, const std::string & name );
 
    template <typename VulkanObjectType>
    static std::string getDebugName ( VulkanObjectType objectHandle );
#else
    template <typename VulkanObjectType>
    static void setObjectName( VkDevice device, VulkanObjectType objectHandle, const std::string & name )
    {
    }
 
    template <typename VulkanObjectType>
    static std::string getDebugName ( VulkanObjectType objectHandle )
    {
        return "";
    }
#endif
 
private:
    static VulkanFunctions s_functions;
    static DynamicFunctionInitState s_functionInitializationState;
    static std::mutex      s_mutex;
};
 
#ifdef IS_IN_DEBUG
template <typename VulkanObjectType>
void VulkanHelper::setObjectName( VkDevice device, VulkanObjectType objectHandle, const std::string & name )
{
    // Only proceed if the function pointer was successfully loaded
    if ( s_functionInitializationState < DEBUG_FUNCTIONS_INITIALIZED ||
         !s_functions.vkSetDebugUtilsObjectNameEXT )
    {
        return;
    }
 
    VkDebugUtilsObjectNameInfoEXT nameInfo = {};
    nameInfo.sType                         = VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_NAME_INFO_EXT;
    nameInfo.objectHandle                  = reinterpret_cast<uint64_t>( objectHandle );
    nameInfo.objectType                    = VulkanHelper::getVulkanObjectType<VulkanObjectType>();
    nameInfo.pObjectName                   = name.c_str();
 
    // Call the function
    s_functions.vkSetDebugUtilsObjectNameEXT( device, &nameInfo );
 
    objectNames.insert( {reinterpret_cast<uint64_t>(objectHandle), name} );
}
 
template <typename VulkanObjectType>
std::string VulkanHelper::getDebugName( VulkanObjectType objectHandle )
{
    const auto objectHandle64 = reinterpret_cast<uint64_t>( objectHandle );
    if (!objectNames.contains( objectHandle64 ) )
    {
        return "Unnamed Object";
    }
    return objectNames.find( objectHandle64 )->second;
}
#endif

class DebugLabel
{
public:
#ifdef IS_IN_DEBUG
    DebugLabel( VkCommandBuffer commandBuffer, const char * pLabelName, const float color[4] = nullptr )
      : m_commandBuffer( commandBuffer )
    {
        VulkanHelper::beginLabel( m_commandBuffer, pLabelName, color );
    }
 
    ~DebugLabel()
    {
        VulkanHelper::endLabel( m_commandBuffer );
    }
#else
    // In release builds, the constructor and destructor do nothing.
    DebugLabel( VkCommandBuffer, const char *, const float * = nullptr ) {}
 
    ~DebugLabel() {}
#endif
 
    // Make the class non-copyable and non-movable to prevent misuse.
                 DebugLabel( const DebugLabel & ) = delete;
    DebugLabel & operator=( const DebugLabel & )  = delete;
                 DebugLabel( DebugLabel && )      = delete;
    DebugLabel & operator=( DebugLabel && )       = delete;
 
private:
#ifdef IS_IN_DEBUG
    VkCommandBuffer m_commandBuffer;
#endif
};