ClusterLodGenerator.cpp

Go to the documentation of this file.

 
#include "Engine/Mesh/ClusterLodGenerator.h"
#include "Engine/Logging/LogCategories.h"
#include "meshoptimizer.h"
#include <algorithm>
#include <limits>
 
namespace EngineCore
{
 
glm::vec4 ClusterLodGenerator::computeBoundingSphere(
    const std::vector<Vertex>& vertices,
    const std::vector<uint32_t>& indices)
{
    if (indices.empty()) {
        return glm::vec4(0.0f);
    }
 
    // Compute centroid
    glm::vec3 center(0.0f);
    for (uint32_t idx : indices) {
        center += glm::vec3(vertices[idx].position);
    }
    center /= static_cast<float>(indices.size());
 
    // Compute radius
    float radiusSq = 0.0f;
    for (uint32_t idx : indices) {
        glm::vec3 pos = glm::vec3(vertices[idx].position);
        float distSq = glm::dot(pos - center, pos - center);
        radiusSq = std::max(radiusSq, distSq);
    }
 
    return glm::vec4(center, std::sqrt(radiusSq));
}
 
glm::vec4 ClusterLodGenerator::computeMeshletBoundingSphere(
    const std::vector<Vertex>& vertices,
    const meshopt_Meshlet& meshlet,
    const std::vector<uint32_t>& meshletVertices)
{
    if (meshlet.vertex_count == 0) {
        return glm::vec4(0.0f);
    }
 
    // Collect vertex positions for this meshlet
    glm::vec3 center(0.0f);
    for (uint32_t i = 0; i < meshlet.vertex_count; ++i) {
        uint32_t vertexIndex = meshletVertices[meshlet.vertex_offset + i];
        center += glm::vec3(vertices[vertexIndex].position);
    }
    center /= static_cast<float>(meshlet.vertex_count);
 
    // Compute radius
    float radiusSq = 0.0f;
    for (uint32_t i = 0; i < meshlet.vertex_count; ++i) {
        uint32_t vertexIndex = meshletVertices[meshlet.vertex_offset + i];
        glm::vec3 pos = glm::vec3(vertices[vertexIndex].position);
        float distSq = glm::dot(pos - center, pos - center);
        radiusSq = std::max(radiusSq, distSq);
    }
 
    return glm::vec4(center, std::sqrt(radiusSq));
}
 
ClusterLodGenerator::LodLevelData ClusterLodGenerator::generateLodLevel(
    const std::vector<Vertex>& srcVertices,
    const std::vector<uint32_t>& srcIndices,
    size_t targetIndexCount,
    float targetError,
    size_t maxVerticesPerMeshlet,
    size_t maxTrianglesPerMeshlet)
{
    LodLevelData result;
 
    // Simplify the mesh
    result.indices.resize(srcIndices.size());
    float resultError = 0.0f;
 
    size_t newIndexCount = meshopt_simplify(
        result.indices.data(),
        srcIndices.data(),
        srcIndices.size(),
        &srcVertices[0].position.x,
        srcVertices.size(),
        sizeof(Vertex),
        targetIndexCount,
        targetError,
        0,  // options
        &resultError
    );
 
    result.indices.resize(newIndexCount);
    result.error = resultError;
 
    if (newIndexCount == 0) {
        return result;
    }
 
    // Remap vertices to remove unused ones
    std::vector<uint32_t> remap(srcVertices.size());
    size_t uniqueVertexCount = meshopt_generateVertexRemap(
        remap.data(),
        result.indices.data(),
        result.indices.size(),
        srcVertices.data(),
        srcVertices.size(),
        sizeof(Vertex)
    );
 
    result.vertices.resize(uniqueVertexCount);
    meshopt_remapVertexBuffer(
        result.vertices.data(),
        srcVertices.data(),
        srcVertices.size(),
        sizeof(Vertex),
        remap.data()
    );
 
    std::vector<uint32_t> remappedIndices(result.indices.size());
    meshopt_remapIndexBuffer(
        remappedIndices.data(),
        result.indices.data(),
        result.indices.size(),
        remap.data()
    );
    result.indices = std::move(remappedIndices);
 
    // Optimize for vertex cache
    meshopt_optimizeVertexCache(
        result.indices.data(),
        result.indices.data(),
        result.indices.size(),
        result.vertices.size()
    );
 
    // Generate meshlets for simplified geometry
    size_t maxMeshlets = meshopt_buildMeshletsBound(
        result.indices.size(),
        maxVerticesPerMeshlet,
        maxTrianglesPerMeshlet
    );
 
    result.meshlets.resize(maxMeshlets);
    result.meshletVertices.resize(maxMeshlets * maxVerticesPerMeshlet);
    result.meshletTriangles.resize(maxMeshlets * maxTrianglesPerMeshlet * 3);
 
    size_t meshletCount = meshopt_buildMeshlets(
        result.meshlets.data(),
        result.meshletVertices.data(),
        result.meshletTriangles.data(),
        result.indices.data(),
        result.indices.size(),
        &result.vertices[0].position.x,
        result.vertices.size(),
        sizeof(Vertex),
        maxVerticesPerMeshlet,
        maxTrianglesPerMeshlet,
        0.5f  // cone weight
    );
 
    // Trim to actual size
    if (meshletCount > 0) {
        const auto& lastMeshlet = result.meshlets[meshletCount - 1];
        result.meshlets.resize(meshletCount);
        result.meshletVertices.resize(lastMeshlet.vertex_offset + lastMeshlet.vertex_count);
        result.meshletTriangles.resize(lastMeshlet.triangle_offset + lastMeshlet.triangle_count * 3);
    } else {
        result.meshlets.clear();
        result.meshletVertices.clear();
        result.meshletTriangles.clear();
    }
 
    return result;
}
 
Ecs::LodHierarchyResult ClusterLodGenerator::generate(
    const std::vector<Vertex>& vertices,
    const std::vector<uint32_t>& indices,
    const std::vector<meshopt_Meshlet>& baseMeshlets,
    const std::vector<uint32_t>& baseMeshletVertices,
    const std::vector<uint8_t>& baseMeshletTriangles,
    const LodGenerationConfig& config)
{
    Ecs::LodHierarchyResult result;
 
    // Check if mesh is large enough for LOD
    if (indices.size() < config.minTrianglesForLod * 3) {
        VS_LOG(LogLOD, Debug, "Mesh too small for LOD generation (indices: {}, min triangles: {})",
               indices.size(), config.minTrianglesForLod);
        return result;
    }
 
    VS_LOG(LogLOD, Info, "Generating LOD hierarchy: {} triangles, {} base meshlets",
           indices.size() / 3, baseMeshlets.size());
 
    // Store LOD level data for hierarchy building
    std::vector<LodLevelData> lodLevels;
 
    // LOD 0 = base level (finest)
    LodLevelData baseLod;
    baseLod.vertices = vertices;
    baseLod.indices = indices;
    baseLod.meshlets = baseMeshlets;
    baseLod.meshletVertices = baseMeshletVertices;
    baseLod.meshletTriangles = baseMeshletTriangles;
    baseLod.error = 0.0f;
    lodLevels.push_back(std::move(baseLod));
 
    result.baseLevelClusterCount = baseMeshlets.size();
 
    // Generate coarser LOD levels
    size_t currentIndexCount = indices.size();
    float accumulatedError = 0.0f;
 
    for (size_t level = 1; level < config.maxLodLevels; ++level) {
        size_t targetIndexCount = static_cast<size_t>(currentIndexCount * config.simplificationRatio);
        targetIndexCount = (targetIndexCount / 3) * 3;  // Round to triangles
 
        if (targetIndexCount < 12) {  // Minimum 4 triangles
            break;
        }
 
        const auto& prevLevel = lodLevels.back();
        LodLevelData newLevel = generateLodLevel(
            prevLevel.vertices,
            prevLevel.indices,
            targetIndexCount,
            config.targetError * static_cast<float>(level),
            252,  // Max vertices per meshlet
            static_cast<size_t>(config.maxTrianglesPerCluster)
        );
 
        if (newLevel.indices.empty() || newLevel.meshlets.empty()) {
            VS_LOG(LogLOD, Debug, "LOD level {} generation failed or produced empty result", level);
            break;
        }
 
        accumulatedError += newLevel.error;
        newLevel.error = accumulatedError;
 
        VS_LOG(LogLOD, Debug, "LOD level {}: {} triangles, {} meshlets, error={:.4f}",
               level, newLevel.indices.size() / 3, newLevel.meshlets.size(), newLevel.error);
 
        currentIndexCount = newLevel.indices.size();
        lodLevels.push_back(std::move(newLevel));
 
        // Stop if we've reduced enough
        if (newLevel.meshlets.size() <= 2) {
            break;
        }
    }
 
    result.lodLevelCount = lodLevels.size();
 
    // Build cluster and group data structures
    // Clusters: one per meshlet across all LOD levels
    // Groups: link finer level clusters to coarser level representation
 
    // First pass: count total meshlets and create cluster entries
    size_t totalMeshlets = 0;
    for (const auto& level : lodLevels) {
        totalMeshlets += level.meshlets.size();
    }
 
    result.clusters.reserve(totalMeshlets);
    result.groups.reserve(lodLevels.size() - 1);  // One group per transition
 
    // Track meshlet indices as we build the combined buffer
    uint32_t globalMeshletIndex = 0;
    std::vector<uint32_t> levelMeshletStartIndices;
 
    for (size_t levelIdx = 0; levelIdx < lodLevels.size(); ++levelIdx) {
        const auto& level = lodLevels[levelIdx];
        levelMeshletStartIndices.push_back(globalMeshletIndex);
 
        for (size_t meshletIdx = 0; meshletIdx < level.meshlets.size(); ++meshletIdx) {
            const auto& meshlet = level.meshlets[meshletIdx];
 
            ClusterLodData cluster;
            cluster.boundsPositionAndRadius = computeMeshletBoundingSphere(
                level.vertices, meshlet, level.meshletVertices);
            cluster.error = level.error;
            cluster.meshletIndex = globalMeshletIndex;
 
            // Link to parent group (coarser level alternative)
            // Each cluster checks: "Is there a coarser representation that's good enough?"
            // - If yes (parent error acceptable): don't render this cluster, use coarser
            // - If no (parent error too high): render this cluster for finer detail
            //
            // Group k stores the error of LOD level k+1 (the coarser alternative)
            // So LOD level k should check Group k to decide if LOD k+1 is sufficient
            if (levelIdx < lodLevels.size() - 1) {
                // Not the coarsest level - check if coarser level is sufficient
                cluster.refinedGroupId = static_cast<int32_t>(levelIdx);
            } else {
                // Coarsest level - always render (no coarser alternative available)
                cluster.refinedGroupId = -1;
            }
 
            result.clusters.push_back(cluster);
            globalMeshletIndex++;
        }
    }
 
    // Create groups linking each level to its coarser representation
    for (size_t levelIdx = 0; levelIdx < lodLevels.size() - 1; ++levelIdx) {
        const auto& coarserLevel = lodLevels[levelIdx + 1];
 
        ClusterGroupData group;
        // Group bounds encompass all meshlets in the coarser level
        group.simplifiedBoundsPositionAndRadius = computeBoundingSphere(
            coarserLevel.vertices, coarserLevel.indices);
        group.simplifiedError = coarserLevel.error;
        group.depth = static_cast<int32_t>(lodLevels.size() - 1 - levelIdx);  // Higher = finer
 
        result.groups.push_back(group);
    }
 
    // Build combined meshlet data buffer
    // Vertices and triangles need to be offset correctly
    size_t totalVertices = 0;
    size_t totalTriangles = 0;
    for (const auto& level : lodLevels) {
        for (const auto& meshlet : level.meshlets) {
            totalVertices += meshlet.vertex_count;
            totalTriangles += meshlet.triangle_count;
        }
    }
 
    result.meshletData.meshlets.reserve(totalMeshlets);
    result.unpackedData.vertices.reserve(totalVertices);
    result.unpackedData.triangles.reserve(totalTriangles);
 
    uint32_t vertexOffset = 0;
    uint32_t triangleOffset = 0;
 
    for (const auto& level : lodLevels) {
        for (const auto& meshlet : level.meshlets) {
            // Create unified meshlet with correct offsets
            meshopt_Meshlet unifiedMeshlet;
            unifiedMeshlet.vertex_offset = vertexOffset;
            unifiedMeshlet.vertex_count = meshlet.vertex_count;
            unifiedMeshlet.triangle_offset = triangleOffset;
            unifiedMeshlet.triangle_count = meshlet.triangle_count;
            result.meshletData.meshlets.push_back(unifiedMeshlet);
 
            // Unpack vertices
            for (uint32_t i = 0; i < meshlet.vertex_count; ++i) {
                uint32_t srcVertexIndex = level.meshletVertices[meshlet.vertex_offset + i];
                result.unpackedData.vertices.push_back(level.vertices[srcVertexIndex]);
            }
 
            // Pack triangles
            for (uint32_t i = 0; i < meshlet.triangle_count; ++i) {
                const uint8_t* triPtr = &level.meshletTriangles[meshlet.triangle_offset + i * 3];
                result.unpackedData.triangles.push_back(
                    Ecs::PackedTriangle::pack(triPtr[0], triPtr[1], triPtr[2])
                );
            }
 
            vertexOffset += meshlet.vertex_count;
            triangleOffset += meshlet.triangle_count;
        }
    }
 
    VS_LOG(LogLOD, Info, "LOD hierarchy generated: {} levels, {} clusters, {} groups",
           result.lodLevelCount, result.clusters.size(), result.groups.size());
 
    return result;
}
 
}  // namespace EngineCore