AppendMeshlets()

void Spices::MeshProcessor::AppendMeshlets ( MeshPack * meshPack, uint32_t lod, const SpicesShader::Sphere & clusterBoundSphere, const std::vector< glm::uvec3 > & primVertices )

staticprivate

Create and Append Meshlets to MeshPack use given indices.

Parameters

[in]	meshPack	MeshPack.
[in]	lod	current lod level.
[in]	clusterBoundSphere	Cluster's Bound Sphere.
[in]	primVertices	PrimVertices Buffer.

normal cone weight set 0.5f; Get Const variable.

Init meshopt variable.

Pack Sparse Inputs.

Build Meshlets.

Adjust meshopt variable.

Optimize meshlets and compute meshlet bound and cone.

Layout map for primpoints.

Fill in data back to meshpack variable.

Fill in Lod data.

normal cone weight set 0.5f; Get Const variable.

Init meshopt variable.

Pack Sparse Inputs.

Build Meshlets.

Adjust meshopt variable.

Optimize meshlets and compute meshlet bound and cone.

Layout map for primpoints.

Fill in data back to meshpack variable.

Fill in Lod data.

Definition at line 154 of file MeshProcessor.cpp.

    {
        SPICES_PROFILE_ZONE;
 
        const float coneWeight              = 0.5f;
        const uint32_t primLocationsOffset  = meshPack->m_MeshResource.primitiveLocations.attributes->size();
        const uint32_t primVerticesOffset   = meshPack->m_MeshResource.primitiveVertices.attributes->size();
        const uint32_t meshletsOffset       = meshPack->m_MeshResource.meshlets.attributes->size();
        
        size_t max_meshlets = meshopt_buildMeshletsBound(primVertices.size() * 3, SpicesShader::MESHLET_NVERTICES, SpicesShader::MESHLET_NPRIMITIVES);
        std::vector<meshopt_Meshlet> meshoptlets(max_meshlets);
        std::vector<unsigned int> meshlet_vertices(max_meshlets * SpicesShader::MESHLET_NVERTICES);
        std::vector<unsigned char> meshlet_triangles(max_meshlets * SpicesShader::MESHLET_NPRIMITIVES * 3);
        
        std::vector<glm::vec3>  packPoints;
        std::vector<glm::uvec3> packPrimPoints;
        std::unordered_map<uint32_t, uint32_t> primVerticesMapReverse;
        PackPrimVerticesFromSparseInputs(meshPack, primVertices, packPoints, packPrimPoints, primVerticesMapReverse);
 
        size_t nMeshlet = meshopt_buildMeshlets(
            meshoptlets.data()         , 
            meshlet_vertices.data()    , 
            meshlet_triangles.data()   , 
            &packPrimPoints[0].x       ,
            packPrimPoints.size() * 3  ,
            &packPoints[0].x           ,
            packPoints.size()          ,
            sizeof(glm::vec3)          , 
            SpicesShader::MESHLET_NVERTICES          , 
            SpicesShader::MESHLET_NPRIMITIVES        , 
            coneWeight
        );
        
        const meshopt_Meshlet& last = meshoptlets[nMeshlet - 1];
        meshoptlets      .resize(nMeshlet);
        meshlet_vertices .resize(last.vertex_offset + last.vertex_count);
        meshlet_triangles.resize(last.triangle_offset + (last.triangle_count * 3 + 3) & ~3);
        
        uint32_t nPrimitives = 0;
        for (size_t i = 0; i < nMeshlet; ++i)
        {
            meshopt_optimizeMeshlet(
                &meshlet_vertices[meshoptlets[i].vertex_offset]            ,
                &meshlet_triangles[meshoptlets[i].triangle_offset]         ,
                meshoptlets[i].triangle_count, meshoptlets[i].vertex_count
            );
        
            const meshopt_Meshlet& m = meshoptlets[i];
            meshopt_Bounds bounds = meshopt_computeMeshletBounds(
                &meshlet_vertices[m.vertex_offset]    ,
                &meshlet_triangles[m.triangle_offset] ,
                m.triangle_count                      ,
                &packPoints[0].x,
                packPoints.size(),
                sizeof(glm::vec3)
            );
        
            Meshlet meshlet;
            meshlet.FromMeshopt(meshoptlets[i], bounds);
            meshlet.primitiveOffset      = nPrimitives;
                                        
            meshlet.vertexOffset        += primLocationsOffset;
            meshlet.primitiveOffset     += primVerticesOffset;
            meshlet.lod                  = lod;
                                        
            meshlet.clusterBoundSphere   = clusterBoundSphere;
 
            meshPack->m_MeshResource.meshlets.attributes->push_back(std::move(meshlet));
        
            nPrimitives += m.triangle_count;
        }
 
        std::unordered_map<glm::uvec3, uint32_t> inPrimPointsLayoutMap;
        auto& vertices = *meshPack->m_MeshResource.vertices.attributes;
        for (auto& primVertex : primVertices)
        {
            inPrimPointsLayoutMap[{ vertices[primVertex.x].x, vertices[primVertex.y].x, vertices[primVertex.z].x }] = inPrimPointsLayoutMap.size();
        }
 
        const Meshlet& lastm = (*meshPack->m_MeshResource.meshlets.attributes)[meshletsOffset + nMeshlet - 1];
        meshPack->m_MeshResource.primitivePoints    .attributes->resize(lastm.primitiveOffset + lastm.nPrimitives);
        meshPack->m_MeshResource.primitiveVertices  .attributes->resize(lastm.primitiveOffset + lastm.nPrimitives);
        meshPack->m_MeshResource.primitiveLocations .attributes->resize(lastm.primitiveOffset + lastm.nPrimitives);
 
        for (uint32_t i = 0; i < nMeshlet; i++)
        {
            const meshopt_Meshlet& m = meshoptlets[i];
            const Meshlet& ml = (*meshPack->m_MeshResource.meshlets.attributes)[meshletsOffset + i];
        
            for (uint32_t j = 0; j < m.triangle_count; j++)
            {
                uint32_t a = (uint32_t)meshlet_triangles[m.triangle_offset + 3 * j + 0] + m.vertex_offset;
                uint32_t b = (uint32_t)meshlet_triangles[m.triangle_offset + 3 * j + 1] + m.vertex_offset;
                uint32_t c = (uint32_t)meshlet_triangles[m.triangle_offset + 3 * j + 2] + m.vertex_offset;
        
                uint32_t& x = vertices[primVerticesMapReverse[meshlet_vertices[a]]].x;
                uint32_t& y = vertices[primVerticesMapReverse[meshlet_vertices[b]]].x;
                uint32_t& z = vertices[primVerticesMapReverse[meshlet_vertices[c]]].x;
 
                (*meshPack->m_MeshResource.primitivePoints.attributes)[ml.primitiveOffset + j] = { x, y, z };
        
                (*meshPack->m_MeshResource.primitiveLocations.attributes)[ml.primitiveOffset + j].x = a + primLocationsOffset;
                (*meshPack->m_MeshResource.primitiveLocations.attributes)[ml.primitiveOffset + j].y = b + primLocationsOffset;
                (*meshPack->m_MeshResource.primitiveLocations.attributes)[ml.primitiveOffset + j].z = c + primLocationsOffset;
 
                (*meshPack->m_MeshResource.primitiveVertices.attributes)[ml.primitiveOffset + j] = primVertices[inPrimPointsLayoutMap[{ x, y, z }]];
            }
        }
 
        uint32_t nLods = meshPack->m_MeshResource.lods.attributes->size();
 
        if (nLods == lod + 1)
        {
            Lod& lodRef = (*meshPack->m_MeshResource.lods.attributes)[lod];
 
            lodRef.nPrimitives       += lastm.primitiveOffset + lastm.nPrimitives - primVerticesOffset;
            lodRef.nMeshlets         += nMeshlet;
        }
        else
        {
            Lod lodData;
            lodData.primVertexOffset  = primVerticesOffset;
            lodData.nPrimitives       = lastm.primitiveOffset + lastm.nPrimitives - primVerticesOffset;
            lodData.nMeshlets         = nMeshlet;
            lodData.meshletOffset     = meshletsOffset;
 
            meshPack->m_MeshResource.lods.attributes->push_back(std::move(lodData));
        }
    }

References Spices::Lod::meshletOffset, Spices::Lod::nPrimitives, and Spices::Lod::primVertexOffset.