meshshader ues meshlet

[WdsPjm]

I'm incorporating meshlets into a mesh shader, and there are some parts that I don't quite understand. For example, I have a mesh with 150 vertex coordinates and 576 indices. After generating meshlets, I have three of them. I want to extract the vertices, normals, and UVs from a meshlet based on the vertexList and indexList of the original mesh. I attempted to calculate it like this:

for (int i = 0; i < meshlets[j].vertex_count; ++i) {
index = meshlets[j].triangle_offset + i;
position[i] = mesh.vertexList[index];
...
}

In the end, I found that this approach is not correct. This is because the vertex data in the VertexList has been deduplicated. Have I missed something?

[zeux]

If you just want to access vertices then you need to use the vertex indices in the meshlet data, for example:

for (int i = 0; i < meshlets[j].vertex_count; ++i) {
    unsigned int index = meshlet_vertices[meshlets[j].vertex_offset + i];
    position[i] = mesh.vertexList[index];
}

meshlet_vertices stores, for each meshlet, indices (from the original vertex buffer) of vertices that the meshlet is using, and meshlet_indices stores the connectivity information using this local vertex list to index into. So if you are processing vertices directly without connectivity then something like the above will work, but if you need to take connectivity into account you need an extra indirection through meshlet_indices.

[WdsPjm]

下面是cpp中 meshlet 的构建代码

The following is the C++ code for constructing meshlets.

struct Vertex
{
float px, py, pz;
float nx, ny, nz;
float tx, ty;
};

struct Mesh
{
std::vector vertices;
std::vector indices;
};

Mesh tmpMesh;

"...construct tmpMesh using MyMesh in my project..."

meshopt_optimizeVertexCache(&tmpMesh.indices[0], &tmpMesh.indices[0], tmpMesh.indices.size(), tmpMesh.vertices.size());
meshopt_optimizeVertexFetch(&tmpMesh.vertices[0], &tmpMesh.indices[0], tmpMesh.indices.size(), &tmpMesh.vertices[0], tmpMesh.vertices.size(), sizeof(Vertex));
std::vector<meshopt_Meshlet> myMeshlets;
Makemeshlets(tmpMesh, myMeshlets, true, tmpmeshLet_Vertex);

The following is part of the code in 'my.mesh.'"

IndexList contains the original indices of tmpMesh, and Positions represent the original vertex coordinates of tmpMesh.

for (int i = 0; i < meshlets[meshletIndex].triangle_count; ++i) {

    index0 = IndexList[mbuf.meshlets[meshletIndex].vertex_offset + i * 3 + 0];
    index1 = IndexList[mbuf.meshlets[meshletIndex].vertex_offset + i * 3 + 1];
    index2 = IndexList[mbuf.meshlets[meshletIndex].vertex_offset + i * 3 + 2];
  
    gl_MeshVerticesEXT[index0].gl_Position = mvp * Positions[index0];
    gl_MeshVerticesEXT[index1].gl_Position = mvp * Positions[index1];
    gl_MeshVerticesEXT[index2].gl_Position = mvp * Positions[index2];

    vertexOutput[ i * 3 +0].color = vec4(0.2,0.2,0.2,1);
    vertexOutput[ i * 3 +1].color = vec4(0.2,0.2,0.2,1);
    vertexOutput[ i * 3 +2].color = vec4(0.2,0.2,0.2,1);
	
    gl_PrimitiveTriangleIndicesEXT[i] = uvec3(index0, index1, index2);
   
}

The above code renders correctly only for meshlet[0]. meshlet[1], meshlet[2], and so on, do not render correctly. I suspect that the indices of the vertices in each meshlet are not corresponding properly, but I am not sure how to address this.

[zeux]

IndexList contains the original indices of tmpMesh

This is not necessary or correct I think; the original index buffer doesn't need to be used for rendering with meshlets - you need the original vertex buffer as well as the three constructed arrays that buildMeshlets outputs. You can see https://github.com/zeux/niagara for complete example usage.

[WdsPjm]

I haven't found such a comprehensive tutorial. Luckily, I am also using Vulkan. Thank you so much.

[WdsPjm]

meshopt_generateVertexRemap(remap.data(), 0, index_count, triangle_vertices.data(), index_count, sizeof(Vertex));

Can the triangle_vertices.data() parameter be the deduplicated vertices? My project has already loaded the model data, and the vertices of these models have been deduplicated. Can I directly use the deduplicated vertices and corresponding indices from my project to construct meshlets

[zeux]

Yes, you can use the source IB/VB directly, all other steps are optional.

[WdsPjm]

I followed the steps mentioned above to read both OBJ and GLB models, then constructed meshlets, and finally rendered them. However, only the OBJ model renders correctly, while the GLB model does not render properly. My question is, do different models need to undergo a unified preprocessing step before meshlet construction?

[zeux]

Not really - if the code that generates and uses meshlets is correct, it should not really matter what kind of input it is given. If you are using .obj and you are doing reindexing via vertex remap, it might be easier to get this wrong for GLB file that already has an index buffer - it can still work if written correctly, but it's easier to make a mistake. If you can post your processing and shader code then it'll be easier to find an error.

[WdsPjm]

Before constructing meshlets, I performed the following operations: lodIndices is the index array of the model, and vertices is the vertex array of the model

std::vector verticesReMap(lodIndices.size());
std::vector<uint32_t> indicesRemMap;
indicesRemMap.insert(indicesRemMap.end(), lodIndices.begin(), lodIndices.end());

      //
    size_t index_count = verticesReMap.size();

    std::vector<uint32_t> remap(index_count);
    size_t vertex_count = meshopt_generateVertexRemap(remap.data(), 0, index_count, verticesReMap.data(), index_count, sizeof(Vertex));

    for (int i = 0; i < lodIndices.size(); ++i) {

        verticesReMap[i] = vertices[lodIndices[i]];
    }


    std::vector<Vertex> verticestmpRemap(vertex_count);
    std::vector<uint32_t> indicestmpRemap(index_count);

    meshopt_remapVertexBuffer(verticestmpRemap.data(), verticesReMap.data(), index_count, sizeof(Vertex), remap.data());
    meshopt_remapIndexBuffer(indicestmpRemap.data(), 0, index_count, remap.data());

    meshopt_optimizeVertexCache(indicestmpRemap.data(), indicestmpRemap.data(), index_count, vertex_count);
    meshopt_optimizeVertexFetch(verticestmpRemap.data(), indicestmpRemap.data(), index_count, vertices.data(), vertex_count, sizeof(Vertex));。

When I removed these lines and directly performed meshlet construction, everything worked fine. Now, I'm using a GLB model with 5,000,000 vertices in my project, and it's working properly. Regarding this code snippet causing issues with building meshlets for my GLB model, I will investigate further. Thank you very much

[zeux]

Great! Yeah the remap/optimizations aren't very necessary if you are starting from a model with a deduplicated vertex buffer; the optimizations (optimizeVertex*) mostly affect traditional rasterization pipeline. Otherwise it looks like the code above is assuming that the source model is not indexed, which is correct for .obj as it's typically deindexed during load, but not for GLB that has a source index buffer. That needs to be passed to generateVertexRemap and remapIndexBuffer instead of 0.