MeshComponent.cpp

Go to the documentation of this file.

#include "Engine/Component/MeshComponent.h"
#include "Engine/Core/Engine.h"
#include "Engine/Entity/Scene.h"
#include "Engine/Mesh/AssetManager.h"
#include "Engine/Renderer/RenderingDataManager.h"
 
namespace EngineCore
{
    MeshComponent::MeshComponent(
        Scene* owningScene,
        entt::entity &             actor,
        Asset::Path                asset,
        std::shared_ptr<SceneNode> sceneNode,
        bool                       isVisible_,
        const std::string &        name_
    )
      : MeshComponent( owningScene, actor, asset, sceneNode, nullptr, isVisible_, name_ )
    {
    }
 
    MeshComponent::MeshComponent(
        Scene* owningScene,
        entt::entity &             actor,
        Asset::Path                asset,
        std::shared_ptr<SceneNode> sceneNode,
        RenderingDataManager*      renderingDataManager,
        bool                       isVisible_,
        const std::string &        name_
    )
      : LogicComponent( owningScene ), name( name_ ), visible( isVisible_ ), sceneNode( sceneNode ),
        renderingDataManager_( renderingDataManager )
    {
        auto & registry = Ecs::RegistryManager::get();
        componentEntity = registry.create();
 
        AssetManager* assetManager = owningScene->getAssetManager();
        if (assetManager == nullptr) throw std::runtime_error("AssetManager not available on Scene");
        MeshAsset *    meshAsset    = assetManager->getMeshAsset( asset );
 
        staticMeshData = &registry.emplace<Ecs::StaticMeshData>( componentEntity );
        staticMeshData->asset  = asset;
 
        if ( meshAsset == nullptr )
        {
            staticMeshData->assetData = nullptr;
            registry.emplace<Ecs::AssetRequested>( componentEntity );
        }
        else
        {
            staticMeshData->assetData = meshAsset;
        }
 
        auto & parent = registry.emplace<Ecs::Parent>( componentEntity );
        parent.parent = actor;
    }
 
    void MeshComponent::beginPlay()
    {
        LogicComponent::beginPlay();
 
        // Register MeshComponentRef on the SceneNode's entity for ECS-based iteration
        // This enables efficient querying without iterating all actors
        if ( sceneNode.has_value() )
        {
            auto & registry = Ecs::RegistryManager::get();
            entt::entity nodeEntity = sceneNode.value()->getEntity();
            registry.emplace_or_replace<Ecs::MeshComponentRef>( nodeEntity, Ecs::MeshComponentRef{ this } );
        }
 
        // Resolve RenderingDataManager if not injected (production path)
        if ( renderingDataManager_ == nullptr )
        {
            Engine* engine = EngineManager::getInstance().getEngineModule();
            if ( engine != nullptr && engine->getRenderer() != nullptr )
            {
                renderingDataManager_ = engine->getRenderer()->getRenderingDataManager().get();
            }
        }
 
        if ( renderingDataManager_ != nullptr )
        {
            renderingDataManager_->onRenderableSpawned( this );
        }
    }
 
    void MeshComponent::endPlay()
    {
        // Unregister MeshComponentRef from the SceneNode's entity
        if ( sceneNode.has_value() )
        {
            auto & registry = Ecs::RegistryManager::get();
            entt::entity nodeEntity = sceneNode.value()->getEntity();
            if ( registry.valid( nodeEntity ) && registry.any_of<Ecs::MeshComponentRef>( nodeEntity ) )
            {
                registry.remove<Ecs::MeshComponentRef>( nodeEntity );
            }
        }
 
        if ( renderingDataManager_ != nullptr )
        {
            renderingDataManager_->onRenderableDestroyed( this );
        }
 
        LogicComponent::endPlay();
    }
 
    bool MeshComponent::isVisible() const
    {
        return visible;
    }
 
    MeshAsset * MeshComponent::getMeshAsset() const
    {
        if (staticMeshData == nullptr) throw std::runtime_error("MeshAsset does not exist");
        return staticMeshData->assetData;
    }
 
    glm::mat4 MeshComponent::getWorldTransform() const
    {
        return sceneNode->get()->getWorldMatrix();
    }
 
    glm::mat4 MeshComponent::getLocalTransform() const
    {
        return sceneNode->get()->getLocalTransform().matrix;
    }
 
    PipelineNames MeshComponent::getMaterialNames() const
    {
        return PipelineNames::NORMALS_SHADER;
    }
} // namespace EngineCore