BuildBLAS()

void Spices::VulkanRayTracing::BuildBLAS	(	const std::vector< BlasInput > &	input,
		VkBuildAccelerationStructureFlagsKHR	flags = VK_BUILD_ACCELERATION_STRUCTURE_PREFER_FAST_TRACE_BIT_KHR )

Create all the BLAS from the vector of BlasInput. There will be one BLAS per input-vector entry. There will be as many BLAS as input.size(). The resulting BLAS (along with the inputs used to build) are stored in m_blas, and can be referenced by index. if flag has the 'Compact' flag, the BLAS will be compacted.

Parameters

[in]	input	BlasInput.
[in]	flags	VkBuildAccelerationStructureFlagsKHR.

Preparing the information for the acceleration build commands..

Get ASBuildSize.

Extra info.

Allocate the scratch buffers holding the temporary data of the acceleration structure builder.

Allocate a query pool for storing the needed size for every BLAS compaction.

Create Query Pool.

Batching creation / compaction of BLAS to allow staying in restricted amount of memory.

Over the limit or last BLAS element.

Reset.

Preparing the information for the acceleration build commands..

Get ASBuildSize.

Extra info.

Allocate the scratch buffers holding the temporary data of the acceleration structure builder.

Allocate a query pool for storing the needed size for every BLAS compaction.

Create Query Pool.

Batching creation / compaction of BLAS to allow staying in restricted amount of memory.

Over the limit or last BLAS element.

Reset.

Definition at line 32 of file VulkanRayTracing.cpp.

    {
        SPICES_PROFILE_ZONE;
 
        const auto       nbBlas         = static_cast<uint32_t>(input.size());
        VkDeviceSize     asTotalSize    = 0;     
        uint32_t         nbCompactions  = 0;   
        VkDeviceSize     maxScratchSize = 0;  
 
        std::vector<BuildAccelerationStructure> buildAs(nbBlas);
        for (uint32_t idx = 0; idx < nbBlas; idx++)
        {
            /* 
            * @brief Filling partially the VkAccelerationStructureBuildGeometryInfoKHR for querying the build sizes.
            * Other information will be filled in the createBlas (see #2)
            */ 
            buildAs[idx].buildInfo.type              = VK_ACCELERATION_STRUCTURE_TYPE_BOTTOM_LEVEL_KHR;
            buildAs[idx].buildInfo.mode              = VK_BUILD_ACCELERATION_STRUCTURE_MODE_BUILD_KHR;
            buildAs[idx].buildInfo.flags             = input[idx].flags | flags;
            buildAs[idx].buildInfo.geometryCount     = static_cast<uint32_t>(input[idx].asGeometry.size());
            buildAs[idx].buildInfo.pGeometries       = input[idx].asGeometry.data();
            buildAs[idx].rangeInfo                   = input[idx].asBuildOffsetInfo.data();  /*@brief Build range information.*/
            buildAs[idx].as                          = input[idx].accel;
 
            /*
            * @brief Finding sizes to create acceleration structures and scratch.
            */ 
            std::vector<uint32_t> maxPrimCount(input[idx].asBuildOffsetInfo.size());
            for (auto tt = 0; tt < input[idx].asBuildOffsetInfo.size(); tt++)
            {
                maxPrimCount[tt] = input[idx].asBuildOffsetInfo[tt].primitiveCount;  /*@brief Number of primitives / triangles*/
            }
 
            m_VulkanState.m_VkFunc.vkGetAccelerationStructureBuildSizesKHR(
                m_VulkanState.m_Device, 
                VK_ACCELERATION_STRUCTURE_BUILD_TYPE_DEVICE_KHR,
                &buildAs[idx].buildInfo, 
                maxPrimCount.data(), 
                &buildAs[idx].sizeInfo
            );
 
            asTotalSize      += buildAs[idx].sizeInfo.accelerationStructureSize;
            maxScratchSize    = std::max(maxScratchSize, buildAs[idx].sizeInfo.buildScratchSize);
            nbCompactions    += hasFlag(buildAs[idx].buildInfo.flags, VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_COMPACTION_BIT_KHR);
        }
 
        VulkanBuffer scratchBuffer(
            m_VulkanState, 
            "ScratchBuffer",
            maxScratchSize, 
            VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT | 
            VK_BUFFER_USAGE_STORAGE_BUFFER_BIT        , 
            VMA_MEMORY_PROPERTY_DEDICATED_MEMORY_BIT
        );
 
        const VkDeviceAddress scratchAddress = scratchBuffer.GetAddress();
 
        std::shared_ptr<VulkanQueryPool> queryPool = nullptr;
        if (nbCompactions > 0)                // Is compaction requested?
        {
            assert(nbCompactions == nbBlas);  // Don't allow mix of on/off compaction
 
            queryPool = std::make_shared<VulkanQueryPool>(m_VulkanState, VK_QUERY_TYPE_ACCELERATION_STRUCTURE_COMPACTED_SIZE_KHR, nbBlas);
        }
 
        std::vector<uint32_t>     indices;                    // Indices of the BLAS to create
        VkDeviceSize              batchSize = 0;
        constexpr VkDeviceSize    batchLimit = 256'000'000;  // 256 MB
 
        for (uint32_t idx = 0; idx < nbBlas; idx++)
        {
            indices.push_back(idx);
            batchSize += buildAs[idx].sizeInfo.accelerationStructureSize;
 
            if (batchSize >= batchLimit || idx == nbBlas - 1)
            {
                VulkanCommandBuffer::CustomGraphicCmd(m_VulkanState, [&](const VkCommandBuffer& commandBuffer) {
                    CmdCreateBLAS(commandBuffer, indices, buildAs, scratchAddress, queryPool);              
                });
 
                if (queryPool)
                {
                    VulkanCommandBuffer::CustomGraphicCmd(m_VulkanState, [&](const VkCommandBuffer& commandBuffer) {
                        CmdCompactBLAS(commandBuffer, indices, buildAs, queryPool);
                    });
                }
                
                batchSize = 0;
                indices.clear();
            }
        }
    }