Mesh.cpp

Go to the documentation of this file.

#include "Engine/Mesh/Mesh.h"
#include "Engine/Core/Engine.h"
#include "Engine/Core/Settings.h"
#include "Engine/Files/FileHandler.h"
#include "Engine/Logging/TracyMacros.hpp"
#include "Engine/Texture/Texture.h"
#include "tiny_gltf.h"
#include <cstring>
#include <iostream>
#include <plog/Log.h>
 
namespace EngineCore
{
    Mesh::Mesh()
      : meshData(
            GltfLoader::GltfMeshData( tinygltf::Model(), tinygltf::Mesh(), tinygltf::Node(), glm::mat4( 1 ) )
        ) {
 
      };
 
    Mesh::Mesh( GltfLoader::GltfMeshData meshData, ApplicationContext * context, Renderer * renderer )
      : name( meshData.getName() ), meshData( meshData ), renderer( renderer ), context( context )
    {
        PLOGI << "=== Mesh CONSTRUCTOR STARTED ===";
        PLOGI << "Mesh name: " << name;
        PLOGI << "Mesh primitives count: " << meshData.getPrimitives().size();
 
        for ( const auto & meshPrimitiveData : meshData.getPrimitives() )
        {
            PLOGI << "MeshPrimitive color texture ptr: "
                  << ( meshPrimitiveData.getColorTexturePtr() ? " is Valid" : " is Invalid" );
        }
 
        PLOGI << "=== Mesh CONSTRUCTOR FINISHED ===";
    }
 
    void Mesh::createResources()
    {
        TRACY_ZONE_SCOPED_NAMED( "Create mesh resources" );
        PLOGI << "=== Create Mesh resources ===";
        PLOGI << "Mesh name: " << name;
        meshPrimitives.resize( meshData.getPrimitives().size() );
        const uint32_t meshPrimitiveCount = meshData.getPrimitives().size();
        PLOGI << "Creating " << meshPrimitiveCount << " mesh primitives";
 
        for ( uint32_t i = 0; i < meshPrimitiveCount; i++ )
        {
            PLOGI << "=== Creating mesh primitive " << i + 1 << " of " << meshPrimitiveCount << " ===";
            try
            {
                meshPrimitives[i] = MeshPrimitive( meshData.getPrimitives()[i], context, renderer );
                PLOGI << "=== Mesh primitive " << i + 1 << " created successfully ===";
            }
            catch ( const std::exception & e )
            {
                PLOGE << "=== ERROR creating mesh primitive " << i + 1 << ": " << e.what() << " ===";
                throw;
            }
        }
        PLOGI << "=== Mesh primitive data loaded ===";
        glm::mat4 matrix = meshData.getTransform();
        sceneTransform   = Transform( matrix );
 
        // Calculate bounding sphere for the entire mesh
        if ( !meshPrimitives.empty() )
        {
            glm::vec3 minCoordinates( std::numeric_limits<float>::max() );
            glm::vec3 maxCoordinates( std::numeric_limits<float>::lowest() );
 
            for ( const auto & primitive : meshPrimitives )
            {
                for ( const auto & vertex : primitive.getVertices() )
                {
                    minCoordinates = glm::min( minCoordinates, glm::vec3(vertex.position) );
                    maxCoordinates = glm::max( maxCoordinates, glm::vec3(vertex.position) );
                }
            }
            glm::vec3 extent     = maxCoordinates - minCoordinates;
            boundingSphereRadius = glm::length( extent ) / 2.0f;
        }
 
        isReady = true;
    }
 
    void Mesh::cleanup() {}
 
    void Mesh::reset()
    {
        meshPrimitives.clear();
    }
 
    uint32_t Mesh::getIndexCount() const
    {
        uint32_t indicesCount = 0u;
        for ( const MeshPrimitive & primitive : meshPrimitives )
        {
            indicesCount += primitive.getIndices().size();
        }
        return indicesCount;
    }
 
    uint32_t Mesh::getMeshletTriangleCount() const
    {
        TRACY_ZONE_SCOPED_FUNCTION;
        uint32_t primitiveCount = 0u;
        for ( const MeshPrimitive & primitive : meshPrimitives )
        {
            primitiveCount += primitive.getMeshletTriangleCount();
        }
        return primitiveCount;
    }
 
    uint32_t Mesh::getMeshletCount() const
    {
        TRACY_ZONE_SCOPED_NAMED( "Get meshlet count" );
        uint32_t count = 0u;
        for ( const MeshPrimitive & primitive : meshPrimitives )
        {
            count += primitive.getMeshletsCount();
        }
        return count;
    }
 
    std::vector<MeshPrimitive> Mesh::getPrimitives() const
    {
        return meshPrimitives;
    }
 
    const std::vector<MeshPrimitive> & Mesh::getPrimitivesByReference() const
    {
        return meshPrimitives;
    }
 
    std::vector<MeshPrimitive> & Mesh::getPrimitivesByReference()
    {
        return meshPrimitives;
    }
 
    std::string Mesh::getName() const
    {
        return name;
    }
 
    std::string Mesh::createMeshName( const std::filesystem::path & path, const std::string & meshName )
    {
        std::stringstream name;
        name << path.generic_string() << ";" << meshName;
        return name.str();
    }
 
    Transform Mesh::getSceneTransform() const
    {
        return sceneTransform;
    }
 
    float Mesh::getBoundingSphereRadius() const
    {
        return boundingSphereRadius;
    }
 
    PipelineNames Mesh::getShaderName() const
    {
        if ( materialName.has_value() )
        {
            return materialName.value();
        }
        return PipelineNames::NORMALS_SHADER;
    }
 
    uint32_t Mesh::getTextureCount()
    {
        return textureCount;
    }
 
}  // namespace EngineCore