Method splitIndexedMesh

Source/Falcor/Scene/SceneBuilder.cpp:2057–2116

    }

    void SceneBuilder::splitIndexedMesh(const MeshSpec& mesh, MeshSpec& leftMesh, MeshSpec& rightMesh, const int axis, const float pos)
    {
        FALCOR_ASSERT(mesh.indexCount > 0 && !mesh.indexData.empty());

        const uint32_t invalidIdx = uint32_t(-1);
        std::vector<uint32_t> leftIndexMap(mesh.indexCount, invalidIdx);
        std::vector<uint32_t> rightIndexMap(mesh.indexCount, invalidIdx);

        // Iterate over the triangles.
        const size_t triangleCount = mesh.getTriangleCount();
        for (size_t i = 0; i < triangleCount * 3; i += 3)
        {
            const uint32_t indices[3] = { mesh.getIndex(i + 0), mesh.getIndex(i + 1), mesh.getIndex(i + 2) };

            auto addVertex = [&](const uint32_t vtxIndex, MeshSpec& dstMesh, std::vector<uint32_t>& indexMap)
            {
                if (indexMap[vtxIndex] != invalidIdx) return indexMap[vtxIndex];

                uint32_t dstIndex = (uint32_t)dstMesh.staticData.size();
                dstMesh.staticData.push_back(mesh.staticData[vtxIndex]);
                indexMap[vtxIndex] = dstIndex;
                return dstIndex;
            };
            auto addTriangleToMesh = [&](MeshSpec& dstMesh, std::vector<uint32_t>& indexMap)
            {
                for (size_t j = 0; j < 3; j++)
                {
                    uint32_t dstIdx = addVertex(indices[j], dstMesh, indexMap);
                    dstMesh.indexData.push_back(dstIdx);
                }
            };

            // Compute the centroid and add the triangle to the left or right side.
            float centroid = 0.f;
            for (size_t j = 0; j < 3; j++)
            {
                centroid += mesh.staticData[indices[j]].position[axis];
            };
            centroid /= 3.f;

            if (centroid < pos) addTriangleToMesh(leftMesh, leftIndexMap);
            else addTriangleToMesh(rightMesh, rightIndexMap);
        }

        auto finalizeMesh = [this](MeshSpec& m)
        {
            m.indexCount = (uint32_t)m.indexData.size();
            m.vertexCount = (uint32_t)m.staticData.size();
            m.staticVertexCount = m.vertexCount;

            m.use16BitIndices = (m.vertexCount <= (1u << 16)) && !(is_set(mFlags, Flags::Force32BitIndices));
            if (m.use16BitIndices) m.indexData = compact16BitIndices(m.indexData);

            m.boundingBox = AABB();
            for (auto& v : m.staticData) m.boundingBox.include(v.position);
        };

        finalizeMesh(leftMesh);