Entity.h

Go to the documentation of this file.

 
#pragma once
 
#include "ncmath/Vector.h"
#include "ncmath/Quaternion.h"
 
#include <cstdint>
#include <limits>
#include <string>
 
namespace nc
{
class Entity
{
    public:
        using index_type = uint32_t;
        using layer_type = uint8_t;
        using flags_type = uint8_t;
        using user_data_type = uint8_t;
 
        static constexpr index_type NullIndex = std::numeric_limits<index_type>::max();
 
        struct Flags
        {
            static constexpr Entity::flags_type None                     = 0b00000000; 
            static constexpr Entity::flags_type Static                   = 0b00000001; 
            static constexpr Entity::flags_type Persistent               = 0b00000010; 
            static constexpr Entity::flags_type NoCollisionNotifications = 0b00000100; 
            static constexpr Entity::flags_type NoSerialize              = 0b00001000; 
            static constexpr Entity::flags_type Internal                 = 0b00010000; 
        };
 
        constexpr Entity() noexcept
            : m_index{NullIndex},
              m_layer{0},
              m_flags{Flags::None},
              m_userData{0}
        {
        }
 
        explicit constexpr Entity(index_type index,
                                  layer_type layer = 0,
                                  flags_type flags = Flags::None,
                                  user_data_type userData = 0) noexcept
            : m_index{index},
              m_layer{layer},
              m_flags{flags},
              m_userData{userData}
        {
        }
 
        static constexpr auto Null() noexcept { return Entity{}; }
 
        static constexpr auto FromHash(uint64_t hash) noexcept -> Entity
        {
            const auto index = static_cast<Entity::index_type>((hash >> 24) & 0xFFFFFFFF);
            const auto layer = static_cast<Entity::layer_type>((hash >> 16) & 0xFF);
            const auto flags = static_cast<Entity::flags_type>((hash >> 8) & 0xFF);
            const auto userData = static_cast<Entity::user_data_type>(hash & 0xFF);
            return Entity{index, layer, flags, userData};
        }
 
        constexpr auto Valid()                   const noexcept -> bool           { return m_index != NullIndex; }
        constexpr auto Index()                   const noexcept -> index_type     { return m_index; }
        constexpr auto Layer()                   const noexcept -> layer_type     { return m_layer; }
        constexpr auto Flags()                   const noexcept -> flags_type     { return m_flags; }
        constexpr auto UserData()                const noexcept -> user_data_type { return m_userData; }
        constexpr auto IsStatic()                const noexcept -> bool           { return m_flags & Flags::Static; }
        constexpr auto IsPersistent()            const noexcept -> bool           { return m_flags & Flags::Persistent; }
        constexpr auto ReceivesCollisionEvents() const noexcept -> bool           { return !(m_flags & Flags::NoCollisionNotifications); }
        constexpr auto IsSerializable()          const noexcept -> bool           { return !(m_flags & Flags::NoSerialize); }
        constexpr auto IsInternal()              const noexcept -> bool           { return m_flags & Flags::Internal; }
 
        explicit constexpr operator index_type() const noexcept { return m_index; }
        friend bool constexpr operator==(const Entity& a, const Entity& b) { return a.Index() == b.Index(); }
        friend bool constexpr operator!=(const Entity& a, const Entity& b) { return !(a == b); }
 
        struct Hash
        {
            constexpr auto operator()(const Entity& entity) const noexcept
            {
                return static_cast<uint64_t>(entity.Index()) << 24
                     | static_cast<uint64_t>(entity.Layer()) << 16
                     | static_cast<uint64_t>(entity.Flags()) << 8
                     | static_cast<uint64_t>(entity.UserData());
            }
        };
 
    private:
        index_type m_index;
        layer_type m_layer;
        flags_type m_flags;
        user_data_type m_userData;
};
 
struct EntityInfo
{
    Vector3 position = Vector3::Zero();              
    Quaternion rotation = Quaternion::Identity();    
    Vector3 scale = Vector3::One();                  
    Entity parent = Entity::Null();                  
    std::string tag = "Entity";                      
    Entity::layer_type layer = 1u;                   
    Entity::flags_type flags = Entity::Flags::None;  
    Entity::user_data_type userData = 0u;            
};
} // namespace nc