GenerateMeshLodClusterHierarchy()

void Spices::MeshProcessor::GenerateMeshLodClusterHierarchy ( MeshPack * meshPack )

static

Generate Mesh Lod Resources.

Parameters

[in]

meshPack

MeshPack.

Lod0

Pack to Points.

Calculate Bound Sphere.

Create Lod0 meshlets.

meshlets of last lod.

Build KDTree.

Pack to Points.

Calculate Bound Sphere.

Pack Sparse Inputs.

Simplify meshlets group primPoints.

Simplify succeed: merge result to meshlets.

Lod0

Pack to Points.

Calculate Bound Sphere.

Create Lod0 meshlets.

meshlets of last lod.

Build KDTree.

Pack to Points.

Calculate Bound Sphere.

Pack Sparse Inputs.

Simplify meshlets group primPoints.

Simplify succeed: merge result to meshlets.

Definition at line 17 of file MeshProcessor.cpp.

    {
        SPICES_PROFILE_ZONE;
 
        {
            auto primVertices = meshPack->m_MeshResource.primitiveVertices.attributes;
            meshPack->m_MeshResource.primitiveVertices.attributes = std::make_shared<std::vector<glm::uvec3>>();
 
            std::vector<glm::vec3> initPoints;
            PackVertexToPoints(meshPack, *primVertices, initPoints);
 
            SpicesShader::Sphere initBoundSphere = CalculateBoundSphere(initPoints);
 
            AppendMeshlets(meshPack, 0, initBoundSphere, *primVertices);
        }
 
        uint32_t meshletStart = 0;
        const uint32_t maxLod = 0;
        for (uint32_t lod = 0; lod < maxLod; ++lod)
        {
            auto in = std::chrono::high_resolution_clock::now();
        
            float tLod = lod / (float)maxLod;
        
            std::vector<Meshlet> meshlets = std::vector<Meshlet>(
                meshPack->m_MeshResource.meshlets.attributes->begin() + meshletStart, 
                meshPack->m_MeshResource.meshlets.attributes->end()
            );
        
            if (meshlets.size() <= 1)
            {
                return;
            }
        
            const uint32_t nextStart   = meshPack->m_MeshResource.meshlets.attributes->size();
            meshletStart               = nextStart;
            auto groups                = GroupMeshlets(meshPack, meshlets);
            
            for (const auto& group : groups)
            {
                std::vector<glm::uvec3> groupPrimVertices;
                auto ptr = meshPack->m_MeshResource.primitiveVertices.attributes;
                for (const auto& meshletIndex : group.meshlets)
                {
                    const auto& meshlet = meshlets[meshletIndex];
 
                    groupPrimVertices.insert(
                        groupPrimVertices.end(), 
                        ptr->begin() + meshlet.primitiveOffset, 
                        ptr->begin() + meshlet.primitiveOffset + meshlet.nPrimitives
                    );
                }
 
                scl::kd_tree<6> kdTree;
                BuildKDTree(meshPack, groupPrimVertices, kdTree);
 
                std::vector<glm::vec3> points;
                PackVertexToPoints(meshPack, groupPrimVertices, points);
 
                SpicesShader::Sphere clusterBoundSphere = CalculateBoundSphere(points);
 
                float simplifyScale       = meshopt_simplifyScale(&points[0].x, points.size(), sizeof(glm::vec3));
                const float maxDistance   = (tLod * 0.01f + (1 - tLod) * 0.001f) * simplifyScale;
                const float maxUVDistance =  tLod * 0.1f  + (1 - tLod) * 0.001f;
                MergeByDistance(meshPack, groupPrimVertices, kdTree, maxDistance, maxUVDistance);
 
                std::vector<glm::vec3>                 packPoints;
                std::vector<glm::uvec3>                packPrimPoints;
                std::unordered_map<uint32_t, uint32_t> primVerticesMapReverse;
                PackPrimVerticesFromSparseInputs(meshPack, groupPrimVertices, packPoints, packPrimPoints, primVerticesMapReverse);
 
                const float threshold   = 0.5f;
                size_t targetCount      = packPrimPoints.size() * threshold * 3;
                float targetError       = 0.1f * tLod + 0.01f * (1 - tLod);
                uint32_t options        = meshopt_SimplifyLockBorder;
                
                std::vector<glm::uvec3> simplifiedPrimPoints(packPrimPoints.size());
                float simplificationError = 0.0f;
                
                size_t simplifiedCount = meshopt_simplify(
                    &simplifiedPrimPoints[0].x ,
                    &packPrimPoints[0].x       ,
                    packPrimPoints.size() * 3  ,
                    &packPoints[0].x           ,
                    packPoints.size()          ,
                    sizeof(glm::vec3)          ,
                    targetCount                ,
                    targetError                ,
                    options                    ,
                    &simplificationError
                );
                simplifiedPrimPoints.resize(simplifiedCount / 3);
                
                std::vector<glm::uvec3> primVerticesBuffer;
                UnPackPrimVerticesToSparseInputs(primVerticesBuffer, primVerticesMapReverse, simplifiedPrimPoints);
                
                AppendMeshlets(meshPack, lod + 1, clusterBoundSphere, primVerticesBuffer);
            }
        
            auto out = std::chrono::high_resolution_clock::now();
            std::cout << "    Lod Cost: " << std::chrono::duration_cast<std::chrono::milliseconds>(out - in).count() << "    " << meshlets.size() << std::endl;
        }
    }

Referenced by Spices::MeshLoader::LoadFromOBJ(), Spices::GltfPack::OnCreatePack(), Spices::PlanePack::OnCreatePack(), Spices::CubePack::OnCreatePack(), and Spices::SpherePack::OnCreatePack().