MeshPrimitive.cpp

Go to the documentation of this file.

#include "Engine/Mesh/MeshPrimitive.h"
#include "Engine/Core/Engine.h"
#include "Engine/Core/VulkanHelper.h"
#include "Engine/Logging/TracyMacros.hpp"
#include "Engine/Material/MaterialShader.h"
#include "Engine/Renderer/RenderData.h"
#include "Engine/Math/BoundingSphere.h"
#include "Engine/Texture/Texture.h"
#include "glm/gtx/norm.hpp"
 
#include <meshoptimizer.h>
 
namespace EngineCore
{
 
    MeshPrimitive::MeshPrimitive(
        GltfLoader::GltfMeshPrimitiveData meshPrimitiveData,
        ApplicationContext *              context,
        Renderer *                        renderer
    )
      : context( context )
      , renderer( renderer )
      , vertices( meshPrimitiveData.getVertices() )
      , indices( meshPrimitiveData.getIndices() )
    {
        PLOGI << "=== MeshPrimitive CONSTRUCTOR STARTED ===";
        PLOGI << "MeshPrimitive constructor - vertices: " << vertices.size() << ", indices: " << indices.size();
 
        // Extract material name from primitive data
        if ( meshPrimitiveData.getMaterialData().hasVulkanSchneeExtension() )
        {
            materialName = meshPrimitiveData.getMaterialData().getVulkanSchneeExtension().materialName;
            materialData = meshPrimitiveData.getMaterialData().getMaterialDataRaw();
            PLOGI << "MeshPrimitive loaded with materialID: " << static_cast<int>( materialName );
        }
        else
        {
            materialName = PipelineNames::NORMALS_SHADER;  // Default material
            PLOGI << "MeshPrimitive using default material (normalsShader)";
        }
 
        if ( meshPrimitiveData.getMaterialData().hasTexture() )
        {
            textureIndex = meshPrimitiveData.getColorTextureIndex();
            colorTexture = meshPrimitiveData.getColorTexturePtr();
        }
        PLOGI << "=== About to generate meshlets... ===";
        generateMeshlets();
        PLOGI << "=== Meshlet generation completed - meshlets: " << meshlets.size() << " ===";
        PLOGI << "=== MeshPrimitive CONSTRUCTOR FINISHED ===";
    }
 
    MeshPrimitive::~MeshPrimitive() {}
 
    std::vector<Vertex> MeshPrimitive::getVertices() const
    {
        return vertices;
    }
 
    const std::vector<Vertex> & MeshPrimitive::getVerticesByRef() const
    {
        return vertices;
    }
 
    std::vector<uint32_t> MeshPrimitive::getIndices() const
    {
        return indices;
    }
 
    const std::vector<uint32_t> & MeshPrimitive::getIndicesByRef() const
    {
        return indices;
    }
 
    uint32_t MeshPrimitive::getTextureIndex() const
    {
        return textureIndex;
    }
 
    std::vector<meshopt_Meshlet> MeshPrimitive::getMeshlets() const
    {
        return meshlets;
    }
 
    const std::vector<meshopt_Meshlet> & MeshPrimitive::getMeshletByRef() const
    {
        return meshlets;
    }
 
    std::vector<uint8_t> MeshPrimitive::getMeshletTriangles() const
    {
        return meshletTriangles;
    }
 
    const std::vector<uint8_t> & MeshPrimitive::getMeshletTrianglesByRef() const
    {
        return meshletTriangles;
    }
 
    std::vector<uint32_t> MeshPrimitive::getMeshletVertices() const
    {
        return meshletVertices;
    }
 
    const std::vector<uint32_t> & MeshPrimitive::getMeshletVerticesByRef() const
    {
        return meshletVertices;
    }
 
    uint32_t MeshPrimitive::getMeshletTriangleCount() const
    {
        return meshletTriangles.size();
    }
 
    uint32_t MeshPrimitive::getMeshletVertexCount() const
    {
        return meshletVertices.size();
    }
 
    uint32_t MeshPrimitive::getMeshletsCount() const
    {
        return meshlets.size();
    }
 
    float MeshPrimitive::getBoundingSphereRadius() const
    {
        return objectCullingData.worldPositionAndRadius.w;
    }
 
    glm::vec3 MeshPrimitive::getBoundingSphereCenter() const
    {
        return glm::vec3(objectCullingData.worldPositionAndRadius);
    }
 
    ObjectCullingData MeshPrimitive::getCullingData() const
    {
        return objectCullingData;
    }
 
    bool MeshPrimitive::hasCustomTexture() const
    {
        return colorTexture->getDescriptorIndex() != 0;
    }
 
    PipelineNames MeshPrimitive::getMaterialName() const
    {
        return materialName;
    }
 
    MaterialShader * MeshPrimitive::getMaterialShader() const
    {
        return materialShader;
    }
 
    void MeshPrimitive::setMaterialShader( MaterialShader * shader )
    {
        materialShader = shader;
    }
 
    void MeshPrimitive::setMaterialId( uint32_t materialId )
    {
        this->materialId = materialId;
    }
 
    const ObjectCullingData & MeshPrimitive::getPrimitiveBoundsByRef() const
    {
        return objectCullingData;
    }
 
    const std::vector<MeshletBounds> & MeshPrimitive::getMeshletBoundsByRef() const
    {
        return meshletBounds;
    }
 
    // In MeshPrimitive.cpp
    void MeshPrimitive::generateMeshlets()
    {
        TRACY_ZONE_SCOPED_NAMED( "Generate Meshlets" );
        PLOGI << "=== GENERATE MESHLETS STARTED ===";
        PLOGI << "Starting meshlet generation - vertices: " << vertices.size() << ", indices: " << indices.size();
 
        // --- 0. Vertex Optimization ---
        // Your existing vertex welding and optimization is good. Keep it.
        std::vector<uint32_t> remap( vertices.size() );
        size_t                uniqueVertexCount;
        {
            TRACY_ZONE_SCOPED_NAMED( "Generate Vertex Remap" );
            uniqueVertexCount = meshopt_generateVertexRemap(
                remap.data(),
                indices.data(),
                indices.size(),
                vertices.data(),
                vertices.size(),
                sizeof( Vertex )
            );
        }
 
        {
            std::vector<Vertex>   uniqueVertices( uniqueVertexCount );
            std::vector<uint32_t> uniqueIndices( indices.size() );
 
            {
                TRACY_ZONE_SCOPED_NAMED( "Remap vertex buffer" );
                meshopt_remapVertexBuffer(
                    uniqueVertices.data(), vertices.data(), vertices.size(), sizeof( Vertex ), remap.data()
                );
            }
            {
                TRACY_ZONE_SCOPED_NAMED( "Remap index buffer" );
                meshopt_remapIndexBuffer(
                    uniqueIndices.data(), indices.data(), indices.size(), remap.data()
                );
            }
 
            // From now on, use the optimized, unique data.
            this->vertices = uniqueVertices;
            this->indices  = uniqueIndices;
        }
 
        {
            TRACY_ZONE_SCOPED_NAMED( "Optimize vertex cache" );
            meshopt_optimizeVertexCache(
                this->indices.data(), this->indices.data(), this->indices.size(), this->vertices.size()
            );
        }
        {
            TRACY_ZONE_SCOPED_NAMED( "Optimize vertex fetch" );
            meshopt_optimizeVertexFetch(
                this->vertices.data(),
                this->indices.data(),
                this->indices.size(),
                this->vertices.data(),
                this->vertices.size(),
                sizeof( Vertex )
            );
        }
 
        // --- 1. Meshlet Generation ---
        constexpr size_t maxVerticesPerMeshlet  = 252;
        constexpr size_t maxTrianglesPerMeshlet = 252;
        constexpr float  coneWeight             = 0.5f;
        size_t           maxMeshlets;
 
        {
            TRACY_ZONE_SCOPED_NAMED( "Generate meshlet bounds" );
            maxMeshlets =
                meshopt_buildMeshletsBound( indices.size(), maxVerticesPerMeshlet, maxTrianglesPerMeshlet );
        }
 
        meshlets.resize( maxMeshlets );
        meshletVertices.resize( maxMeshlets * maxVerticesPerMeshlet );
        // Directly generate into the uint8_t member variable.
        meshletTriangles.resize( maxMeshlets * maxTrianglesPerMeshlet * 3 );
        size_t meshletCount;
        {
            TRACY_ZONE_SCOPED_NAMED( "Build meshlets" );
            meshletCount = meshopt_buildMeshlets(
                meshlets.data(),
                meshletVertices.data(),
                meshletTriangles.data(),  // Generate into temporary uint8_t buffer
                indices.data(),           // Use optimized indices
                indices.size(),
                &vertices[0].position.x,  // Use optimized vertices
                vertices.size(),
                sizeof( Vertex ),
                maxVerticesPerMeshlet,
                maxTrianglesPerMeshlet,
                coneWeight  // Use cone weight for better culling
            );
        }
 
        // --- 2. Finalize and Optimize within Meshlets ---
        {
            TRACY_ZONE_SCOPED_NAMED( "Optimize meshlets" );
            if ( meshletCount > 0 )
            {
                const auto & [vertex_offset, triangle_offset, vertex_count, triangle_count] =
                    meshlets[meshletCount - 1];
 
                meshlets.resize( meshletCount );
                meshletVertices.resize( vertex_offset + vertex_count );
                meshletTriangles.resize( triangle_offset + ( triangle_count * 3 ) );
 
                // This is a key step for performance inside the shader.
                for ( size_t i = 0; i < meshletCount; ++i )
                {
                    const meshopt_Meshlet & m = meshlets[i];
                    meshopt_optimizeMeshlet(
                        &meshletVertices[m.vertex_offset],
                        &meshletTriangles[m.triangle_offset],
                        m.triangle_count,
                        m.vertex_count
                    );
                }
            }
            else
            {
                meshlets.clear();
                meshletVertices.clear();
                meshletTriangles.clear();
            }
        }
 
        {
            TRACY_ZONE_SCOPED_NAMED( "Generate meshlet bounds" );
            generateBoundingSpheres();
        }
 
        PLOGI << "Generated " << meshlets.size() << " meshlets for primitive.";
    }
 
    void MeshPrimitive::generateBoundingSpheres()
    {
        TRACY_ZONE_SCOPED_NAMED( "Generate bounding spheres" );
        if ( vertices.empty() )
            return;
 
        // Find most separated points along each axis
        auto primitiveBoundsHelper = MeshletBoundsHelper( vertices[0].position );
 
        uint32_t meshletCount = meshlets.size();
        meshletBounds.resize( meshletCount );
 
        for ( size_t i = 0; i < meshletCount; ++i )
        {
            TRACY_ZONE_SCOPED_NAMED( "Generate bounding spheres" );
            const meshopt_Meshlet & m = meshlets[i];
            auto                    meshletBoundsHelper =
                MeshletBoundsHelper( vertices[meshletVertices[m.vertex_offset]].position );
            {
                TRACY_ZONE_SCOPED_NAMED( "Enlarge bounds" );
                for ( uint32_t vertexId = 0; vertexId < m.vertex_count; ++vertexId )
                {
                    const glm::vec3 & pos = vertices[meshletVertices[m.vertex_offset + vertexId]].position;
                    primitiveBoundsHelper.enlarge( pos );
                    meshletBoundsHelper.enlarge( pos );
                }
            }
 
            {
                TRACY_ZONE_SCOPED_NAMED( "Calculate bounds sphere" );
                meshletBounds[i] = meshletBoundsHelper.getBounds( { m }, vertices, meshletVertices );
                meshletBounds[i].meshletIndex = i;
            }
        }
 
        {
            TRACY_ZONE_SCOPED_NAMED( "Get primitive bounds" );
            MeshletBounds primitiveBounds =
                primitiveBoundsHelper.getBounds( meshlets, vertices, meshletVertices );
            objectCullingData.worldPositionAndRadius = primitiveBounds.worldPositionAndRadius;
        }
    }
 
    void MeshPrimitive::MeshletBoundsHelper::enlarge( glm::vec3 point )
    {
        if ( point.x < minX.x )
            minX = point;
        if ( point.x > maxX.x )
            maxX = point;
        if ( point.y < minY.y )
            minY = point;
        if ( point.y > maxY.y )
            maxY = point;
        if ( point.z < minZ.z )
            minZ = point;
        if ( point.z > maxZ.z )
            maxZ = point;
    }
 
    MeshletBounds MeshPrimitive::MeshletBoundsHelper::getBounds(
        const std::vector<meshopt_Meshlet> & meshlets,
        const std::vector<Vertex> &          vertices,
        const std::vector<uint32_t> &        meshletVertices
    ) const
    {
        // Find the most separated pair
        TRACY_ZONE_SCOPED_NAMED( "Calculate Bounds" );
 
        float distX = glm::distance2( minX, maxX );
        float distY = glm::distance2( minY, maxY );
        float distZ = glm::distance2( minZ, maxZ );
 
        glm::vec3 p1, p2;
        if ( distX > distY && distX > distZ )
        {
            p1 = minX;
            p2 = maxX;
        }
        else if ( distY > distZ )
        {
            p1 = minY;
            p2 = maxY;
        }
        else
        {
            p1 = minZ;
            p2 = maxZ;
        }
 
        // Initial sphere
        glm::vec3 center = ( p1 + p2 ) * 0.5f;
        float     radius = glm::distance( center, p2 );
 
        // Expand to include all points using Ritter's algorithm
        {
            TRACY_ZONE_SCOPED_NAMED( "Expand bounds to include all points" );
 
            // First pass: find the point farthest from current center
            float     maxDistSq     = 0.0f;
            glm::vec3 farthestPoint = center;
 
            for ( const auto & meshlet : meshlets )
            {
                for ( uint32_t vertexId = 0; vertexId < meshlet.vertex_count; ++vertexId )
                {
                    const glm::vec3 & pos =
                        vertices[meshletVertices[meshlet.vertex_offset + vertexId]].position;
                    glm::vec3 diff   = pos - center;
                    float     distSq = glm::dot( diff, diff );  // Use squared distance to avoid sqrt
 
                    if ( distSq > maxDistSq )
                    {
                        maxDistSq     = distSq;
                        farthestPoint = pos;
                    }
                }
            }
 
            // If we found a point outside the sphere, expand the sphere
            if ( maxDistSq > radius * radius )
            {
                float dist      = glm::sqrt( maxDistSq );
                float newRadius = ( radius + dist ) * 0.5f;
                center += ( farthestPoint - center ) * ( ( dist - radius ) / dist );
                radius = newRadius;
 
                // Second pass: expand again to ensure all points are included
                // This is typically sufficient for most cases
                maxDistSq = 0.0f;
                for ( const auto & meshlet : meshlets )
                {
                    for ( uint32_t vertexId = 0; vertexId < meshlet.vertex_count; ++vertexId )
                    {
                        const glm::vec3 & pos =
                            vertices[meshletVertices[meshlet.vertex_offset + vertexId]].position;
                        glm::vec3 diff   = pos - center;
                        float     distSq = glm::dot( diff, diff );
 
                        if ( distSq > maxDistSq )
                        {
                            maxDistSq     = distSq;
                            farthestPoint = pos;
                        }
                    }
                }
 
                if ( maxDistSq > radius * radius )
                {
                    float dist      = glm::sqrt( maxDistSq );
                    float newRadius = ( radius + dist ) * 0.5f;
                    center += ( farthestPoint - center ) * ( ( dist - radius ) / dist );
                    radius = newRadius;
                }
            }
        }
 
        return {
            {center.x, center.y, center.z, radius},
        };
    }
}  // namespace EngineCore