Component.hpp

#pragma once
 
#include <Core/Utils/Index.hpp>
#include <Eigen/Core>
#include <Eigen/Geometry>
#include <Engine/RaEngine.hpp>
 
#include <vector>
 
#include <Core/Types.hpp>
 
namespace Ra {
 
namespace Engine {
 
namespace Rendering {
class RenderObject;
class RenderObjectManager;
} // namespace Rendering
 
namespace Scene {
class System;
class Entity;
 
class RA_ENGINE_API Component
{
  public:
    Component( const std::string& name, Entity* entity );
 
    virtual ~Component();
 
    virtual void initialize() = 0;
    virtual void setEntity( Entity* entity ) { m_entity = entity; }
 
    virtual Entity* getEntity() const { return m_entity; }
 
    virtual const std::string& getName() const { return m_name; }
 
    virtual void setSystem( System* system ) { m_system = system; }
 
    virtual System* getSystem() const { return m_system; }
 
    Core::Utils::Index addRenderObject( Rendering::RenderObject* renderObject );
 
    void removeRenderObject( const Core::Utils::Index& roIdx );
 
    // Editable transform interface.
    // This allow to edit the data in the component with a render object
    // as a key. An invalid RO index can be passed, meaning no specific RO is
    // queried.
 
    virtual bool canEdit( const Core::Utils::Index& /*roIdx*/ ) const { return false; }
 
    virtual Core::Transform getTransform( const Core::Utils::Index& /*roIdx*/ ) const {
        return Core::Transform::Identity();
    }
 
    virtual void setTransform( const Core::Utils::Index& /*roIdx*/,
                               const Core::Transform& /*transform*/ ) {}
 
    void notifyRenderObjectExpired( const Core::Utils::Index& idx );
 
    // return the aabb of the union of visible RenderObjects aabb
    virtual Core::Aabb computeAabb();
 
    void invalidateAabb();
 
    const std::vector<Core::Utils::Index>& getRenderObjects() { return m_renderObjects; }
 
  protected:
    static Rendering::RenderObjectManager* getRoMgr();
 
  public:
    std::vector<Core::Utils::Index> m_renderObjects;
 
  protected:
    std::string m_name {};
    Entity* m_entity { nullptr };
    System* m_system { nullptr };
 
  private:
    bool m_isAabbValid { false };
    Core::Aabb m_aabb;
};
 
} // namespace Scene
} // namespace Engine
} // namespace Ra