DAG construction Nanite style

[GiuseppeCassisi96]

Hey,

I would like to implement my LOD algorithm cluster-based . I'm following the Nanite's approcch, so the first step is to construct the DAG in order to select the appropriate LOD at runtime. I use the library to subdivide and simplify my mesh. I encountered troubles in DAG implementation, especially in the "merge" phase implementyation. I tried to following this previus discussion: https://github.com/zeux/meshoptimizer/discussions/569 , but the assertion "indices[i] < vertex_count" is launched.

Here you can see the implementation code:

` void PhoenixMesh::BuildDag(std::vector<Minerva::Mesh::Vertex>& vertices, std::vector<unsigned int> &indices)
    {
        Lod firstLod;
        std::vector<MeshletGroup> meshletsGroup;
        std::vector<meshopt_Meshlet> meshlets;
        std::vector<uint32_t> meshletVertices;
        std::vector<unsigned char> meshletTriangles;

        Split(indices,vertices, meshletVertices, meshlets, meshletTriangles);
        meshletsGroup = Group(meshlets);

        //Zero-LOD creation
        firstLod.groups = meshletsGroup;
        firstLod.lodGlobalMeshlets = meshlets;
        firstLod.lodGlobalIndex = meshletVertices;
        firstLod.lodGlobalTriangles = meshletTriangles;
        lods[0] = firstLod;
        int lodIndex = 1;
        Lod currentLod = firstLod;
        //Loop to create other lods
        while (lodIndex <= MAX_LOD_NUMBER)
        {  
        std::vector<uint32_t> newLodMeshletVertices;
        std::vector<unsigned char> newLodMeshletTriangles;
        std::vector<meshopt_Meshlet> newLodMeshlets;
            for(auto group : currentLod.groups)
            {
                std::vector<Minerva::Mesh::Vertex> groupVerticesData;
                groupVerticesData = Merge(group,currentLod.lodGlobalIndex,vertices,currentLod.lodGlobalTriangles);
                Simplify(group.meshletVerticesGroup, groupVerticesData);

                std::vector<unsigned int> globalIndices;
                globalIndices.reserve(group.meshletVerticesGroup.size());

                for (size_t i = 0; i < group.meshletVerticesGroup.size(); ++i)
                    globalIndices.push_back(groupVerticesData[group.meshletVerticesGroup[i]].index);

                Split(globalIndices,groupVerticesData,group.meshletVerticesGroup, 
                group.meshletsGroup, group.meshletTrianglesGroup);

                newLodMeshletVertices.insert(newLodMeshletVertices.end(),
                group.meshletVerticesGroup.begin(), group.meshletVerticesGroup.end());

                newLodMeshletTriangles.insert(newLodMeshletTriangles.end(),
                group.meshletTrianglesGroup.begin(), group.meshletTrianglesGroup.end());

                newLodMeshlets.insert(newLodMeshlets.end(),
                group.meshletVerticesGroup.begin(), group.meshletVerticesGroup.end());
            }
            currentLod.lodGlobalIndex = newLodMeshletVertices;
            currentLod.lodGlobalTriangles = newLodMeshletTriangles;
            currentLod.lodGlobalMeshlets = newLodMeshlets; 
            currentLod.groups = Group(currentLod.lodGlobalMeshlets);
            
            lods[lodIndex] = currentLod;
            lodIndex++;
        }   
    }`

The merge and group metods:

std::vector<MeshletGroup> PhoenixMesh::Group(std::vector<meshopt_Meshlet>& meshlets)
     {  
         std::vector<MeshletGroup> groups;
         MeshletGroup group;
         int meshletGrouped = 0;
         for(int i = 0; i < meshlets.size(); i++)
         {
             group.meshletsGroup.emplace_back(meshlets[i]);
             meshletGrouped++;
             if(meshletGrouped >= groupNumber)
             {
                 groups.emplace_back(group);
                 group.meshletsGroup.clear();
                 meshletGrouped = 0;
             }
 
         }
         if(meshletGrouped < groupNumber)
         {
             groups.emplace_back(group);
         }
         std::cout<< "END group phase\n";
         return groups; 
     }
 
     std::vector<Minerva::Mesh::Vertex> PhoenixMesh::Merge(MeshletGroup& group, std::vector<uint32_t> meshletVertices,
     std::vector<Minerva::Mesh::Vertex>& vertices, std::vector<unsigned char> groupMeshletTriangles)
     {
         std::vector<Minerva::Mesh::Vertex> localVertices;
         for(auto meshlet : group.meshletsGroup)
         {
             size_t localOffset = localVertices.size();
             for (unsigned int v = 0; v < meshlet.vertex_count; ++v)
             {
                 unsigned int globalIndex = meshletVertices[meshlet.vertex_offset + v];
                 vertices[globalIndex].index = globalIndex;
                 localVertices.push_back(vertices[globalIndex]);
             }
 
             for (unsigned int t = 0; t < meshlet.triangle_count; ++t)
             {
                 group.meshletVerticesGroup.push_back(localOffset + 
                 groupMeshletTriangles[meshlet.triangle_offset + t * 0]);
                 group.meshletVerticesGroup.push_back(localOffset + 
                 groupMeshletTriangles[meshlet.triangle_offset + t * 1]);
                 group.meshletVerticesGroup.push_back(localOffset + 
                 groupMeshletTriangles[meshlet.triangle_offset + t * 2]);
             }
 
         }
         return localVertices;
 
     }

Sorry for the huge code. Any suggestions will be greatly appreciated.
Many thanks.