ItemEntry.hpp

#pragma once
 
#include <Core/CoreMacros.hpp>
#include <Core/Utils/Index.hpp>
#include <Engine/RaEngine.hpp>
#include <string>
#include <vector>
 
namespace Ra {
namespace Engine {
class RadiumEngine;
 
namespace Scene {
 
class Entity;
class Component;
 
struct RA_ENGINE_API ItemEntry {
    ItemEntry() = default;
 
    explicit ItemEntry( Entity* ent,
                        Component* comp           = nullptr,
                        Ra::Core::Utils::Index ro = Ra::Core::Utils::Index::Invalid() ) :
        m_entity { ent }, m_component { comp }, m_roIndex { ro } {}
    explicit ItemEntry( Entity* ent, {…}
 
    inline bool operator==( const ItemEntry& rhs ) const;
 
    bool isValid() const;
 
    bool isSelectable() const;
 
    inline bool isEntityNode() const;
 
    inline bool isComponentNode() const;
 
    inline bool isRoNode() const;
 
    inline void checkConsistency() const;
 
    Entity* m_entity { nullptr };
 
    Component* m_component { nullptr };
 
    Ra::Core::Utils::Index m_roIndex {};
};
struct RA_ENGINE_API ItemEntry {…};
 
RA_ENGINE_API std::string getEntryName( const Engine::RadiumEngine* engine, const ItemEntry& ent );
 
RA_ENGINE_API std::vector<Ra::Core::Utils::Index> getItemROs( const Engine::RadiumEngine* engine,
                                                              const ItemEntry& ent );
 
bool ItemEntry::isEntityNode() const {
    ON_DEBUG( checkConsistency() );
    return ( m_entity && !m_component );
}
bool ItemEntry::isEntityNode() const  {…}
 
bool ItemEntry::isComponentNode() const {
    ON_DEBUG( checkConsistency() );
    return ( m_entity && m_component && m_roIndex.isInvalid() );
}
bool ItemEntry::isComponentNode() const  {…}
 
bool ItemEntry::isRoNode() const {
    ON_DEBUG( checkConsistency() );
    return ( m_entity && m_component && m_roIndex.isValid() );
}
bool ItemEntry::isRoNode() const  {…}
 
void ItemEntry::checkConsistency() const {
    CORE_ASSERT( m_entity || ( !m_component && m_roIndex.isInvalid() ),
                 "Component or RO  is set while entity is not" );
    CORE_ASSERT( m_component || m_roIndex.isInvalid(), "RO  is set while component is not" );
}
void ItemEntry::checkConsistency() const  {…}
 
inline bool ItemEntry::operator==( const ItemEntry& rhs ) const {
    return m_entity == rhs.m_entity && m_component == rhs.m_component && m_roIndex == rhs.m_roIndex;
}
inline bool ItemEntry::operator==( const ItemEntry& rhs ) const  {…}
 
} // namespace Scene
} // namespace Engine
} // namespace Ra