CreateBuffer()

void Spices::VulkanBuffer::CreateBuffer ( VulkanState & vulkanState, const std::string & name, VkDeviceSize size, VkBufferUsageFlags usage, VkMemoryPropertyFlags properties )

private

Create a buffer.

Parameters

[in]	vulkanState	The global VulkanState.
[in]	name	Buffer name
[in]	size	The buffer size.
[in]	usage	The buffer usage.
[in]	properties	The buffer memory requirement flags.

Instance a VkBufferCreateInfo.

Instance a VmaAllocationCreateInfo.

Create a Buffer.

Instance a VkBufferDeviceAddressInfo.

Get Address and return it.

Instance a VkBufferCreateInfo.

Instance a VmaAllocationCreateInfo.

Create a Buffer.

Instance a VkBufferDeviceAddressInfo.

Get Address and return it.

Definition at line 244 of file VulkanBuffer.cpp.

    {
        SPICES_PROFILE_ZONE;
 
        m_Name       = name;
        m_DeviceSize = size;
        m_Usage      = usage;
        m_Flags      = properties;
 
        VkBufferCreateInfo                                  bufferInfo{};
        bufferInfo.sType                                  = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO;
        bufferInfo.size                                   = size;
        bufferInfo.usage                                  = usage;
        bufferInfo.sharingMode                            = VK_SHARING_MODE_EXCLUSIVE;
 
#if VMA_ALLOCATOR
 
        VmaAllocationCreateInfo                             allocInfo{};
        allocInfo.usage                                   = VMA_MEMORY_USAGE_AUTO;
 
        if (properties & VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT)
        {
            allocInfo.flags                             |= VMA_ALLOCATION_CREATE_HOST_ACCESS_SEQUENTIAL_WRITE_BIT;
        }
 
        if (properties & VMA_MEMORY_PROPERTY_DEDICATED_MEMORY_BIT)
        {
            allocInfo.flags                             |= VMA_ALLOCATION_CREATE_DEDICATED_MEMORY_BIT;
        }
 
        VK_CHECK(vmaCreateBuffer(vulkanState.m_VmaAllocator, &bufferInfo, &allocInfo, &m_Buffer, &m_Alloc, nullptr))
        DEBUGUTILS_SETOBJECTNAME(VK_OBJECT_TYPE_BUFFER, (uint64_t)m_Buffer, vulkanState.m_Device, name)
 
        if (usage & VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT)
        {
            VkBufferDeviceAddressInfo           info {};
            info.sType                        = VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO;
            info.buffer                       = m_Buffer;
 
            m_BufferAddress = vkGetBufferDeviceAddress(m_VulkanState.m_Device, &info);
        }
 
#else
 
        VK_CHECK(vkCreateBuffer(vulkanState.m_Device, &bufferInfo, nullptr, &m_Buffer));
        DEBUGUTILS_SETOBJECTNAME(VK_OBJECT_TYPE_BUFFER, (uint64_t)m_Buffer, vulkanState.m_Device, "Buffer")
 
        
        VkMemoryDedicatedRequirements                       dedicatedRegs{};
        dedicatedRegs.sType                               = VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS;
 
        VkMemoryRequirements2                               memReqs{};
        memReqs.sType                                     = VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2;
        memReqs.pNext                                     = &dedicatedRegs;
 
        VkBufferMemoryRequirementsInfo2                     bufferReqs{};
        bufferReqs.sType                                  = VK_STRUCTURE_TYPE_BUFFER_MEMORY_REQUIREMENTS_INFO_2;
        bufferReqs.buffer                                 = m_Buffer;
 
        vkGetBufferMemoryRequirements2(m_VulkanState.m_Device, &bufferReqs, &memReqs);
 
        VkMemoryAllocateInfo                                allocInfo{};
        allocInfo.sType                                   = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO;
        allocInfo.allocationSize                          = memReqs.memoryRequirements.size;
        
        VkMemoryAllocateFlagsInfoKHR                        flagsInfo{};
        flagsInfo.sType                                   = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO_KHR;
        flagsInfo.flags                                   = VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_BIT;
 
        if (usage & VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT)
        {
            allocInfo.pNext = &flagsInfo;
        }
 
        VkPhysicalDeviceMemoryProperties memProperties{};
        vkGetPhysicalDeviceMemoryProperties(vulkanState.m_PhysicalDevice, &memProperties);
 
        for (uint32_t i = 0; i < memProperties.memoryTypeCount; i++) 
        {
            if (memReqs.memoryRequirements.memoryTypeBits & (1 << i) && (memProperties.memoryTypes[i].propertyFlags & properties) == properties) 
            {
                allocInfo.memoryTypeIndex = i;
                break;
            }
        }
 
        VK_CHECK(vkAllocateMemory(vulkanState.m_Device, &allocInfo, nullptr, &m_BufferMemory));
        VK_CHECK(vkBindBufferMemory(vulkanState.m_Device, m_Buffer, m_BufferMemory, 0));
 
        if (usage & VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT)
        {
            VkBufferDeviceAddressInfo           info {};
            info.sType                        = VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO;
            info.buffer                       = m_Buffer;
 
            m_BufferAddress = vkGetBufferDeviceAddress(m_VulkanState.m_Device, &info);
        }
 
#endif
 
    }

References m_Name.