Method createMeshGroups

Source/Falcor/Scene/SceneBuilder.cpp:1833–1980

    }

    void SceneBuilder::createMeshGroups()
    {
        FALCOR_ASSERT(mMeshGroups.empty());

        // This function sorts meshes into groups based on their properties.
        // The scene will build one BLAS per mesh group for raytracing.
        // Note that a BLAS may be referenced by multiple TLAS instances.
        //
        // The sorting criteria are:
        //  - Non-instanced static meshes are all placed in the same group (BLAS).
        //    The vertices are pre-transformed in the BLAS and the TLAS instance has an identity transform.
        //    This ensures fast traversal for the static parts of a scene independent of the scene hierarchy.
        //  - Non-instanced dynamic meshes (skinned and/or animated) are sorted into groups (BLASes) with the same transform.
        //    The idea is that all parts of a dynamic object that move together go in the same BLAS and the TLAS instance applies the transform.
        //  - Instanced meshes are sorted into groups (BLASes) with identical instances.
        //    The idea is that all parts of an instanced object go in the same BLAS and the TLAS instances apply the transforms.
        //    Note that dynamic (skinned) meshes currently cannot be instanced due to limitations in the scene structures. See #1118.
        // TODO: Add build flag to turn off pre-transformation to world space.

        // Classify non-instanced meshes.
        // The non-instanced dynamic meshes are grouped based on what global matrix ID their transform is.
        // The non-instanced static meshes are placed in the same group.

        using meshList = std::vector<MeshID>;
        std::unordered_map<NodeID, meshList> nodeToMeshList;
        meshList staticMeshes;
        meshList staticDisplacedMeshes;
        meshList dynamicDisplacedMeshes;
        size_t nonInstancedMeshCount = 0;

        for (MeshID meshID{ 0 }; meshID.get() < (uint32_t)mMeshes.size(); ++meshID)
        {
            auto& mesh = mMeshes[meshID.get()];
            if (mesh.instances.size() > 1) continue; // Only processing non-instanced meshes here

            FALCOR_ASSERT(mesh.instances.size() == 1);
            NodeID nodeID = *mesh.instances.begin();

            // Mark displaced meshes.
            const auto& pMaterial = mSceneData.pMaterials->getMaterial(mesh.materialId);
            if (pMaterial->isDisplaced()) mesh.isDisplaced = true;

            if (mesh.isStatic && mesh.isDisplaced) staticDisplacedMeshes.push_back(meshID);
            else if (mesh.isStatic) staticMeshes.push_back(meshID);
            else if (!mesh.isStatic && mesh.isDisplaced) dynamicDisplacedMeshes.push_back(meshID);
            else nodeToMeshList[nodeID].push_back(meshID);
            nonInstancedMeshCount++;
        }

        // Validate that mesh counts add up.
        size_t nonInstancedDynamicMeshCount = 0;
        for (const auto& it : nodeToMeshList) nonInstancedDynamicMeshCount += it.second.size();
        FALCOR_ASSERT(staticMeshes.size() + staticDisplacedMeshes.size() + dynamicDisplacedMeshes.size() + nonInstancedDynamicMeshCount == nonInstancedMeshCount);

        // Classify instanced meshes.
        // The instanced meshes are grouped based on their lists of instances.
        // Meshes with an identical set of instances can be placed together in a BLAS.
        std::map<std::set<NodeID>, meshList> instancesToMeshList;