BuildTLAS() [1/2]

template<class T >

void Spices::VulkanRayTracing::BuildTLAS ( const std::vector< T > & instances, VkBuildAccelerationStructureFlagsKHR flags = VK_BUILD_ACCELERATION_STRUCTURE_PREFER_FAST_TRACE_BIT_KHR, bool update = false, bool motion = false )

inline

Build TLAS from an array of VkAccelerationStructureInstanceKHR. The resulting TLAS will be stored in m_tlas. update is to rebuild the Tlas with updated matrices, flag must have the 'allow_update'.

Parameters

[in]	instances	Scene MeshPack Instances data.
[in]	flags	VkBuildAccelerationStructureFlagsKHR.
[in]	update	True if want update rather than create new one.
[in]	motion	True if with VkAccelerationStructureMotionInstanceNV.

Cannot call buildTlas twice except to update.

Create a buffer holding the actual instance data (matrices++) for use by the AS builder.

Command buffer to create the TLAS.

Make sure the copy of the instance buffer are copied before triggering the acceleration structure build.

Definition at line 326 of file VulkanRayTracing.h.

    {
        SPICES_PROFILE_ZONE;
 
        assert(m_tlas.accel == VK_NULL_HANDLE || update);
        const uint32_t countInstance = static_cast<uint32_t>(instances.size());
 
        VulkanBuffer instancesBuffer(
            m_VulkanState                              ,
            "TLASInstancesBuffer"                      ,
            sizeof(T) * instances.size()               ,
            VK_BUFFER_USAGE_TRANSFER_DST_BIT           |
            VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT  | 
            VK_BUFFER_USAGE_ACCELERATION_STRUCTURE_BUILD_INPUT_READ_ONLY_BIT_KHR ,
            0
        );
 
        VulkanBuffer stagingBuffer(
            m_VulkanState                        ,
            "StagingBuffer"                      ,
            sizeof(T) * instances.size()         ,
            VK_BUFFER_USAGE_TRANSFER_SRC_BIT     ,
            VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT  |
            VK_MEMORY_PROPERTY_HOST_COHERENT_BIT
        );
 
        stagingBuffer.WriteToBuffer(instances.data());
 
        instancesBuffer.CopyBuffer(stagingBuffer.Get(), instancesBuffer.Get(), sizeof(T) * instances.size());
 
        const VkDeviceAddress instBufferAddr = instancesBuffer.GetAddress();
 
        std::unique_ptr<VulkanBuffer> scratchBuffer = nullptr;
        VulkanCommandBuffer::CustomGraphicCmd(m_VulkanState, [&](const VkCommandBuffer& commandBuffer) {
 
            VkMemoryBarrier                        barrier{};
            barrier.sType                        = VK_STRUCTURE_TYPE_MEMORY_BARRIER;
            barrier.srcAccessMask                = VK_ACCESS_TRANSFER_WRITE_BIT;
            barrier.dstAccessMask                = VK_ACCESS_ACCELERATION_STRUCTURE_WRITE_BIT_KHR;
 
            vkCmdPipelineBarrier(
                commandBuffer                                          ,
                VK_PIPELINE_STAGE_TRANSFER_BIT                         ,
                VK_PIPELINE_STAGE_ACCELERATION_STRUCTURE_BUILD_BIT_KHR ,
                0                                                      ,
                1                                                      ,
                &barrier                                               ,
                0                                                      ,
                nullptr                                                ,
                0                                                      ,
                nullptr
            );
 
            CmdCreateTLAS(
                commandBuffer  ,
                countInstance  , 
                instBufferAddr , 
                scratchBuffer  , 
                flags          , 
                update         ,
                motion
            );
        });
    }

References Spices::VulkanObject::m_VulkanState.