Merging, Simplify and Split groups of meshlets

[GiuseppeCassisi96]

Hi,

I would like to: merge a group of N meshlets, simplify that group, and then split the group to generate N/2 meshlets. I am having troubles with the merging operation.

For the merging operation, I was considering creating a local index buffer for each group. I would fill this local index buffer using the meshlet_vertices and the appropriate offset and vertex count (meshlet.vertex_offset and meshlet.vertex_count). I would then use this local index buffer to create a new sub-vertex buffer (also known as a local vertex buffer). In the Simplify and Split operation, I will use these two buffers (localIndexBuffer and localVertexBuffer). Unfortunately, the creation of the local index buffer in this way seems incorrect because an assert is thrown (index_count % 3 == 0). So I have two questions:

• Is there a proper way to create a local index buffer from a group of merged meshlets? Do you have any suggestions or advice about that?
• Why the index buffer count must be divisible for 3?

Many thanks.

[zeux]

My recommendation would be to start from a simpler baseline, where you always refer to vertices in the original vertex buffer and feed a small index buffer that refers to original vertices to meshopt_simplify et al. This is not optimal in terms of the time that the simplifier will take to process the meshlets, but it's much easier to get going this way and ensure that you have a correct result.

For this you basically need to keep meshlets as sets of triangles/indices that refer to the original vertices. After calling meshopt_buildMeshlets initially, you can convert each meshlet triangle into a regular 3-index triangle (see https://github.com/zeux/meshoptimizer/blob/master/src/clusterizer.cpp#L873-L881). After this every meshlet is just a collection of unsigned int indices into the original vertex buffer. You can merge any set of meshlets by simply concatenating the index buffers. You can simplify the result by simply passing it to meshopt_simplify, while using original full vertex count of the entire mesh as the vertex_count parameter.

This post https://jglrxavpok.github.io/2024/03/12/recreating-nanite-faster-lod-generation.html covers improvements to time it takes to do this processing but this is more involved and I'd recommend starting with the simpler scheme outlined above. I would only recommend going here once you have everything else fully working. (I'm also planning to look into providing an option to meshopt_simplify that improves its performance for sparse inputs like this so that maybe none of the complexity is needed in the end).

To answer your specific question about the index buffer count, you're working with triangles, and every triangle has 3 indices, so index buffer count must be divisible by 3.

[GiuseppeCassisi96]

@zeux Ok I will follow your advice. Many thanks for your suggestions

[GiuseppeCassisi96]

Hi @zeux,

I tried to merge the local index buffer following your advice but the method seems dosen't work. I'm sharing to you my code for the merging operation:

void PhoenixMesh::Merge(MeshletGroup& group, const std::vector<Minerva::Mesh::Vertex>& vertices)
    {
        for(auto& meshlet : group.meshlets)
       {
            group.localMeshletsIndex.insert(group.localMeshletsIndex.end(),
                meshletVertices.begin() + meshlet.vertex_offset, meshletVertices.begin() 
                + meshlet.vertex_offset
                + meshlet.vertex_count);
       }
       for(auto& meshlet : group.meshlets)
       {
            for (size_t i = 0; i < meshlet.triangle_count * 3; ++i)
            {
                uint32_t index = group.localMeshletsIndex[meshletTriangles[i]];
		        assert(index < vertices.size());
                group.localIndexBuffer.emplace_back(index);
            }
       }

    }

First of all I create a local meshlets (is the ''' meshlet_vertices''' obtained by the splitting but for each group) and then I create the local index buffer following https://github.com/zeux/meshoptimizer/blob/master/src/clusterizer.cpp#L873-L881. Tring to render using the global index buffer (obtained by concatenating the local index buffers of each group) I obtain this result:

Where am I going wrong?
Many thanks.

[zeux]

The approach I outlined doesn't need localMeshletsIndex/localIndexBuffer I guess, you'd expect that after the transformation I suggested each meshlet is just a subset of the original index buffer, and so merging them can just use concatenation. You have extra levels of indirection and offsetting in your code that I think are leading the code astray; I would suggest using the code I linked to to convert each individual meshlet's data into a set of indices that refer to original vertices. That just requires a single vector with indices per meshlet group.

[GiuseppeCassisi96]

hi, @zeux

Ok many thanks for suggestions. I implemented the index buffer merging in this way and seems work:

 for(const auto& meshletIndex : group.meshlets) 
       {
            const auto& meshlet = currentLod.lodVerticesMeshlets[meshletIndex].meshletData;
            std::vector<uint32_t> perMeshletInndexBuffer;
            for(size_t j = 0; j < meshlet.triangle_count * 3; j+=3) 
            {
                for(int i = 0; i < 3; i++)
                {
                    uint32_t index = currentLod.lodMeshletsClusterIndex[currentLod.lodMeshletsClusterTriangle
                    [meshlet.triangle_offset + j + i] + meshlet.vertex_offset];
                    localGroupIndexBuffer.emplace_back(index);
                    perMeshletInndexBuffer.emplace_back(index);
                    currentLod.vertexNumber.insert(index);
                }
            }    
            currentLod.lodVerticesMeshlets[meshletIndex].bound = 
            meshopt_computeClusterBounds(perMeshletInndexBuffer.data(), perMeshletInndexBuffer.size(),
            &currentLod.lodVertexBuffer[0].pos.x, currentLod.lodVertexBuffer.size(), sizeof(MINERVA_VERTEX)); 
        }

The final result is the following:

The image above represents my mesh at LOD 2. Another issue arises during the simplification process. The simplifier appears to become stuck when I attempt to further simplify my mesh. It isn't able to simplify my mesh properly. How I could force the simplifier to simplify more ?

Many thanks