id.h

#pragma once
#include "gaia/config/config.h"
 
#include <cstdint>
#include <type_traits>
 
#include "gaia/cnt/sparse_storage.h"
#include "gaia/core/hashing_policy.h"
#include "gaia/core/utility.h"
#include "gaia/ecs/id_fwd.h"
 
namespace gaia {
  namespace ecs {
#define GAIA_ID(type) GAIA_ID_##type
 
    using Identifier = uint64_t;
    inline constexpr Identifier IdentifierBad = (Identifier)-1;
    inline constexpr Identifier EntityCompMask = IdentifierBad << 1;
    inline constexpr IdentifierId IdentifierIdBad = (IdentifierId)-1;
 
    enum class DataStorageType : uint32_t {
      Table,
      Sparse,
 
      Count = 2
    };
 
    // ------------------------------------------------------------------------------------
    // Component
    // ------------------------------------------------------------------------------------
 
    struct GAIA_API Component final {
      static constexpr uint32_t IdMask = IdentifierIdBad;
      static constexpr uint32_t MaxComponentSize_Bits = 13;
      static constexpr uint32_t MaxComponentSizeInBytes = (1 << MaxComponentSize_Bits) - 1;
      static constexpr uint32_t MaxAlignment_Bits = MaxComponentSize_Bits;
      static constexpr uint32_t MaxAlignment = MaxComponentSizeInBytes;
 
      struct InternalData {
        // detail::ComponentDescId id;
        uint32_t id;
        IdentifierData size : MaxComponentSize_Bits;
        IdentifierData alig : MaxAlignment_Bits;
        IdentifierData storage : 1;
        IdentifierData soa : meta::StructToTupleMaxTypes_Bits;
        IdentifierData unused : 1;
      };
      static_assert(sizeof(InternalData) == sizeof(Identifier));
 
      union {
        InternalData data;
        Identifier val;
      };
 
      Component() noexcept = default;
 
      Component(uint32_t id, uint32_t soa, uint32_t size, uint32_t alig, DataStorageType storage) noexcept {
        data.id = id;
        data.soa = soa;
        data.size = size;
        data.alig = alig;
        data.storage = (IdentifierData)storage;
        data.unused = 0;
      }
 
      GAIA_NODISCARD constexpr auto id() const noexcept {
        return (uint32_t)data.id;
      }
 
      GAIA_NODISCARD constexpr auto soa() const noexcept {
        return (uint32_t)data.soa;
      }
 
      GAIA_NODISCARD constexpr auto size() const noexcept {
        return (uint32_t)data.size;
      }
 
      GAIA_NODISCARD constexpr auto alig() const noexcept {
        return (uint32_t)data.alig;
      }
 
      GAIA_NODISCARD constexpr DataStorageType storage_type() const noexcept {
        return (DataStorageType)data.storage;
      }
 
      GAIA_NODISCARD constexpr auto value() const noexcept {
        return val;
      }
 
      GAIA_NODISCARD constexpr bool operator==(Component other) const noexcept {
        return value() == other.value();
      }
 
      GAIA_NODISCARD constexpr bool operator!=(Component other) const noexcept {
        return value() != other.value();
      }
 
      GAIA_NODISCARD constexpr bool operator<(Component other) const noexcept {
        return id() < other.id();
      }
    };
 
    //----------------------------------------------------------------------
    // Entity kind
    //----------------------------------------------------------------------
 
    enum EntityKind : uint8_t {
      // Generic entity, one per entity
      EK_Gen = 0,
      // Unique entity, one per chunk
      EK_Uni
    };
 
    inline constexpr const char* EntityKindString[] = {"Gen", "Uni"};
 
    //----------------------------------------------------------------------
    // Id type deduction
    //----------------------------------------------------------------------
 
    template <typename T>
    struct uni {
      static_assert(core::is_raw_v<T>);
      static_assert(
          std::is_trivial_v<T> ||
              // For non-trivial T the comparison operator must be implemented because
              // defragmentation needs it to figure out if entities can be moved around.
              (core::has_ffunc_equals<T>::value || core::has_func_equals<T>::value),
          "Non-trivial Uni component must implement operator==");
 
      static constexpr EntityKind Kind = EntityKind::EK_Uni;
 
      using TType = T;
      using TTypeFull = uni<TType>;
      using TTypeOriginal = T;
    };
 
    namespace detail {
      template <typename, typename = void>
      struct has_entity_kind: std::false_type {};
      template <typename T>
      struct has_entity_kind<T, std::void_t<decltype(T::Kind)>>: std::true_type {};
 
      template <typename T>
      struct ExtractComponentType_NoEntityKind {
        static constexpr EntityKind Kind = EntityKind::EK_Gen;
 
        using Type = core::raw_t<T>;
        using TypeFull = Type;
        using TypeOriginal = T;
      };
 
      template <typename T>
      struct ExtractComponentType_WithEntityKind {
        static constexpr EntityKind Kind = T::Kind;
 
        using Type = typename T::TType;
        using TypeFull = std::conditional_t<Kind == EntityKind::EK_Gen, Type, uni<Type>>;
        using TypeOriginal = typename T::TTypeOriginal;
      };
 
      template <typename, typename = void>
      struct is_gen_component: std::true_type {};
      template <typename T>
      struct is_gen_component<T, std::void_t<decltype(T::Kind)>>: std::bool_constant<T::Kind == EntityKind::EK_Gen> {};
 
      template <typename T, typename = void>
      struct component_type {
        using type = typename detail::ExtractComponentType_NoEntityKind<T>;
      };
      template <typename T>
      struct component_type<T, std::void_t<decltype(T::Kind)>> {
        using type = typename detail::ExtractComponentType_WithEntityKind<T>;
      };
    } // namespace detail
 
    template <typename T>
    using component_type_t = typename detail::component_type<T>::type;
 
    template <typename T>
    inline constexpr EntityKind entity_kind_v = component_type_t<T>::Kind;
 
    //----------------------------------------------------------------------
    // Pair helpers
    //----------------------------------------------------------------------
 
    namespace detail {
      struct pair_base {};
    } // namespace detail
 
    template <typename Rel, typename Tgt>
    class pair: public detail::pair_base {
      using rel_comp_type = component_type_t<Rel>;
      using tgt_comp_type = component_type_t<Tgt>;
 
    public:
      using rel = typename rel_comp_type::TypeFull;
      using tgt = typename tgt_comp_type::TypeFull;
      using rel_type = typename rel_comp_type::Type;
      using tgt_type = typename tgt_comp_type::Type;
      using rel_original = typename rel_comp_type::TypeOriginal;
      using tgt_original = typename tgt_comp_type::TypeOriginal;
      using type = std::conditional_t<!std::is_empty_v<rel_type> || std::is_empty_v<tgt_type>, rel, tgt>;
    };
 
    template <typename T>
    struct is_pair {
      static constexpr bool value = std::is_base_of<detail::pair_base, core::raw_t<T>>::value;
    };
 
    // ------------------------------------------------------------------------------------
    // Entity
    // ------------------------------------------------------------------------------------
 
    struct GAIA_API Entity final {
      static constexpr uint32_t IdMask = IdentifierIdBad;
 
      struct InternalData {
        EntityId id;
 
        // Bits in this section need to be 1:1 with EntityContainer data.
        // Note, the order of these bits is important because entities
        // are sorted by their "val" member and many behaviors rely on this.
 
        IdentifierData gen : 28;
        IdentifierData ent : 1;
        IdentifierData pair : 1;
        IdentifierData kind : 1;
        IdentifierData tmp : 1;
 
      };
      static_assert(sizeof(InternalData) == sizeof(Identifier));
 
      union {
        InternalData data;
        Identifier val;
      };
 
      constexpr Entity() noexcept: val(IdentifierBad) {};
 
      template <typename T, typename = std::enable_if_t<std::is_same_v<T, Identifier>>>
      constexpr Entity(T value) noexcept: val(value) {}
 
      Entity(EntityId id, IdentifierData gen) noexcept {
        val = 0;
        data.id = id;
        data.gen = gen;
      }
 
      Entity(EntityId id, IdentifierData gen, bool isEntity, bool isPair, EntityKind kind) noexcept {
        data.id = id;
        data.gen = gen;
        data.ent = isEntity;
        data.pair = isPair;
        data.kind = kind;
        data.tmp = 0;
      }
 
      GAIA_NODISCARD constexpr auto id() const noexcept {
        return (uint32_t)data.id;
      }
 
      GAIA_NODISCARD constexpr auto gen() const noexcept {
        return (uint32_t)data.gen;
      }
 
      GAIA_NODISCARD constexpr bool entity() const noexcept {
        return data.ent != 0;
      }
 
      GAIA_NODISCARD constexpr bool pair() const noexcept {
        return data.pair != 0;
      }
 
      GAIA_NODISCARD constexpr bool comp() const noexcept {
        return (data.pair | data.ent) == 0;
      }
 
      GAIA_NODISCARD constexpr auto kind() const noexcept {
        return (EntityKind)data.kind;
      }
 
      GAIA_NODISCARD constexpr auto value() const noexcept {
        return val;
      }
 
      GAIA_NODISCARD constexpr bool operator==(Entity other) const noexcept {
        return value() == other.value();
      }
 
      GAIA_NODISCARD constexpr bool operator!=(Entity other) const noexcept {
        return value() != other.value();
      }
 
      GAIA_NODISCARD constexpr bool operator<(Entity other) const noexcept {
        return value() < other.value();
      }
      GAIA_NODISCARD constexpr bool operator<=(Entity other) const noexcept {
        return value() <= other.value();
      }
 
      GAIA_NODISCARD constexpr bool operator>(Entity other) const noexcept {
        return value() > other.value();
      }
      GAIA_NODISCARD constexpr bool operator>=(Entity other) const noexcept {
        return value() >= other.value();
      }
 
      template <typename Serializer>
      void save(Serializer& s) const;
 
      template <typename Serializer>
      void load(Serializer& s);
    };
 
    inline static const Entity EntityBad = Entity(IdentifierBad);
 
    namespace detail {
      struct EntityLoadRemapState {
        uint32_t savedLastCoreComponentId = 0;
        uint32_t currLastCoreComponentId = 0;
        bool active = false;
      };
 
      // NOTE: Entity::load() only receives a serializer, not World state.
      //       Therefore the load-time core-id remap currently uses scoped ambient context.
      //       thread_local keeps concurrent world loads on different threads independent.
      //       Tradeoff: this is less explicit than carrying the remap state on the serializer.
      inline thread_local EntityLoadRemapState g_entityLoadRemapState{};
 
      struct EntityLoadRemapGuard {
        EntityLoadRemapState prev;
 
        EntityLoadRemapGuard(uint32_t savedLastCoreComponentId, uint32_t currLastCoreComponentId) noexcept:
            prev(g_entityLoadRemapState) {
          g_entityLoadRemapState.savedLastCoreComponentId = savedLastCoreComponentId;
          g_entityLoadRemapState.currLastCoreComponentId = currLastCoreComponentId;
          g_entityLoadRemapState.active = true;
        }
 
        ~EntityLoadRemapGuard() {
          g_entityLoadRemapState = prev;
        }
 
        EntityLoadRemapGuard(const EntityLoadRemapGuard&) = delete;
        EntityLoadRemapGuard& operator=(const EntityLoadRemapGuard&) = delete;
        EntityLoadRemapGuard(EntityLoadRemapGuard&&) = delete;
        EntityLoadRemapGuard& operator=(EntityLoadRemapGuard&&) = delete;
      };
 
      GAIA_NODISCARD inline uint32_t remap_loaded_entity_id(
          uint32_t id, uint32_t savedLastCoreComponentId, uint32_t currLastCoreComponentId) noexcept {
        if (id == Entity::IdMask || //
            id <= savedLastCoreComponentId || //
            currLastCoreComponentId <= savedLastCoreComponentId //
        )
          return id;
 
        return id + (currLastCoreComponentId - savedLastCoreComponentId);
      }
 
      GAIA_NODISCARD inline Entity
      remap_loaded_entity(Entity entity, uint32_t savedLastCoreComponentId, uint32_t currLastCoreComponentId) noexcept {
        if (entity == EntityBad)
          return entity;
 
        if (!entity.pair()) {
          return Entity(
              (EntityId)remap_loaded_entity_id(entity.id(), savedLastCoreComponentId, currLastCoreComponentId),
              entity.gen(), entity.entity(), false, entity.kind());
        }
 
        return Entity(
            (EntityId)remap_loaded_entity_id(entity.id(), savedLastCoreComponentId, currLastCoreComponentId),
            (IdentifierData)remap_loaded_entity_id(entity.gen(), savedLastCoreComponentId, currLastCoreComponentId),
            entity.entity(), true, entity.kind());
      }
 
      GAIA_NODISCARD inline Entity remap_loaded_entity(Entity entity) noexcept {
        const auto& state = g_entityLoadRemapState;
        if (!state.active)
          return entity;
 
        return remap_loaded_entity(entity, state.savedLastCoreComponentId, state.currLastCoreComponentId);
      }
    } // namespace detail
 
    template <typename Serializer>
    inline void Entity::save(Serializer& s) const {
      s.save(val);
    }
 
    template <typename Serializer>
    inline void Entity::load(Serializer& s) {
      s.load(val);
      *this = detail::remap_loaded_entity(*this);
    }
 
    struct GAIA_API EntityLookupKey {
      using LookupHash = core::direct_hash_key<uint64_t>;
 
    private:
      Entity m_entity;
      LookupHash m_hash;
 
      static LookupHash calc(Entity entity) {
        return {core::calculate_hash64(entity.value())};
      }
 
    public:
      static constexpr bool IsDirectHashKey = true;
 
      EntityLookupKey() = default;
      explicit EntityLookupKey(Entity entity): m_entity(entity), m_hash(calc(entity)) {}
      ~EntityLookupKey() = default;
 
      EntityLookupKey(const EntityLookupKey&) = default;
      EntityLookupKey(EntityLookupKey&&) noexcept = default;
      EntityLookupKey& operator=(const EntityLookupKey&) = default;
      EntityLookupKey& operator=(EntityLookupKey&&) noexcept = default;
 
      Entity entity() const {
        return m_entity;
      }
 
      size_t hash() const {
        return (size_t)m_hash.hash;
      }
 
      bool operator==(const EntityLookupKey& other) const {
        if GAIA_LIKELY (m_hash != other.m_hash)
          return false;
 
        return m_entity == other.m_entity;
      }
 
      bool operator!=(const EntityLookupKey& other) const {
        return !operator==(other);
      }
    };
 
    inline static const EntityLookupKey EntityBadLookupKey = EntityLookupKey(EntityBad);
 
    struct GAIA_API EntityDesc {
      const char* name{};
      uint32_t name_len{};
      const char* alias{};
      uint32_t alias_len{};
    };
 
    //----------------------------------------------------------------------
    // Pair
    //----------------------------------------------------------------------
 
    template <>
    class pair<Entity, Entity>: public detail::pair_base {
      Entity m_first;
      Entity m_second;
 
    public:
      pair(Entity a, Entity b) noexcept: m_first(a), m_second(b) {}
 
      operator Entity() const noexcept {
        return Entity(
            m_first.id(), m_second.id(),
            // Pairs have no way of telling gen and uni entities apart.
            // Therefore, for first, we use the entity bit as Gen/Uni...
            (bool)m_first.kind(),
            // Always true for pairs
            true,
            // ... and for second, we use the kind bit.
            m_second.kind());
      }
 
      Entity first() const noexcept {
        return m_first;
      }
 
      Entity second() const noexcept {
        return m_second;
      }
 
      bool operator==(const pair& other) const {
        return m_first == other.m_first && m_second == other.m_second;
      }
      bool operator!=(const pair& other) const {
        return !operator==(other);
      }
    };
 
    using Pair = pair<Entity, Entity>;
 
    //----------------------------------------------------------------------
    // Core components
    //----------------------------------------------------------------------
 
    namespace detail {
      template <typename T, typename U = void>
      struct actual_type {
        using type = typename component_type<T>::type;
      };
 
      template <typename T>
      struct actual_type<T, std::enable_if_t<is_pair<T>::value>> {
        using storage_type = typename T::type;
        using type = typename component_type<storage_type>::type;
      };
    } // namespace detail
 
    template <typename T>
    using actual_type_t = typename detail::actual_type<T>::type;
 
    //----------------------------------------------------------------------
    // Core components
    //----------------------------------------------------------------------
 
    // Core component. The entity it is attached to is ignored by queries
    struct GAIA_API Core_ {};
    // struct EntityDesc;
    // struct Component;
    struct GAIA_API OnDelete_ {};
    struct GAIA_API OnDeleteTarget_ {};
    struct GAIA_API Remove_ {};
    struct GAIA_API Delete_ {};
    struct GAIA_API Error_ {};
    struct GAIA_API Requires_ {};
    struct GAIA_API CantCombine_ {};
    struct GAIA_API Exclusive_ {};
    struct GAIA_API DontFragment_ {};
    struct GAIA_API Sparse_ {};
    struct GAIA_API Acyclic_ {};
    struct GAIA_API All_ {};
    struct GAIA_API ChildOf_ {};
    struct GAIA_API Parent_ {};
    struct GAIA_API Is_ {};
    struct GAIA_API Prefab_ {};
    struct GAIA_API OnInstantiate_ {};
    struct GAIA_API Override_ {};
    struct GAIA_API Inherit_ {};
    struct GAIA_API DontInherit_ {};
    struct GAIA_API Traversable_ {};
    struct GAIA_API System_;
    struct GAIA_API DependsOn_ {};
    struct GAIA_API Observer_;
 
    // Query variables
    struct GAIA_API _Var0 {};
    struct GAIA_API _Var1 {};
    struct GAIA_API _Var2 {};
    struct GAIA_API _Var3 {};
    struct GAIA_API _Var4 {};
    struct GAIA_API _Var5 {};
    struct GAIA_API _Var6 {};
    struct GAIA_API _Var7 {};
 
    //----------------------------------------------------------------------
    // Core component entities
    //----------------------------------------------------------------------
 
    // Core component. The entity it is attached to is ignored by queries
    inline Entity Core = Entity(0, 0, false, false, EntityKind::EK_Gen);
    inline Entity GAIA_ID(EntityDesc) = Entity(1, 0, false, false, EntityKind::EK_Gen);
    inline Entity GAIA_ID(Component) = Entity(2, 0, false, false, EntityKind::EK_Gen);
    // Cleanup rules
    inline Entity OnDelete = Entity(3, 0, false, false, EntityKind::EK_Gen);
    inline Entity OnDeleteTarget = Entity(4, 0, false, false, EntityKind::EK_Gen);
    inline Entity Remove = Entity(5, 0, false, false, EntityKind::EK_Gen);
    inline Entity Delete = Entity(6, 0, false, false, EntityKind::EK_Gen);
    inline Entity Error = Entity(7, 0, false, false, EntityKind::EK_Gen);
    // Entity dependencies
    inline Entity Requires = Entity(8, 0, false, false, EntityKind::EK_Gen);
    inline Entity CantCombine = Entity(9, 0, false, false, EntityKind::EK_Gen);
    inline Entity Exclusive = Entity(10, 0, false, false, EntityKind::EK_Gen);
    // Entity storage
    inline Entity DontFragment = Entity(11, 0, false, false, EntityKind::EK_Gen);
    inline Entity Sparse = Entity(12, 0, false, false, EntityKind::EK_Gen);
    // Graph properties
    inline Entity Acyclic = Entity(13, 0, false, false, EntityKind::EK_Gen);
    inline Entity Traversable = Entity(14, 0, false, false, EntityKind::EK_Gen);
    // Wildcard query entity
    inline Entity All = Entity(15, 0, false, false, EntityKind::EK_Gen);
    // Entity representing a physical hierarchy.
    // When the relationship target is deleted all children are deleted as well.
    inline Entity ChildOf = Entity(16, 0, false, false, EntityKind::EK_Gen);
    // Entity representing a logical/non-fragmenting hierarchy.
    inline Entity Parent = Entity(17, 0, false, false, EntityKind::EK_Gen);
    // Alias for a base entity/inheritance
    inline Entity Is = Entity(18, 0, false, false, EntityKind::EK_Gen);
    // Template entity excluded from queries by default unless explicitly requested.
    inline Entity Prefab = Entity(19, 0, false, false, EntityKind::EK_Gen);
    // Prefab instantiation policy relation and values.
    inline Entity OnInstantiate = Entity(20, 0, false, false, EntityKind::EK_Gen);
    inline Entity Override = Entity(21, 0, false, false, EntityKind::EK_Gen);
    inline Entity Inherit = Entity(22, 0, false, false, EntityKind::EK_Gen);
    inline Entity DontInherit = Entity(23, 0, false, false, EntityKind::EK_Gen);
    // Systems
    inline Entity System = Entity(24, 0, false, false, EntityKind::EK_Gen);
    inline Entity DependsOn = Entity(25, 0, false, false, EntityKind::EK_Gen);
    // Observers
    inline Entity Observer = Entity(26, 0, false, false, EntityKind::EK_Gen);
    // Query variables
    inline Entity Var0 = Entity(27, 0, false, false, EntityKind::EK_Gen);
    inline Entity Var1 = Entity(28, 0, false, false, EntityKind::EK_Gen);
    inline Entity Var2 = Entity(29, 0, false, false, EntityKind::EK_Gen);
    inline Entity Var3 = Entity(30, 0, false, false, EntityKind::EK_Gen);
    inline Entity Var4 = Entity(31, 0, false, false, EntityKind::EK_Gen);
    inline Entity Var5 = Entity(32, 0, false, false, EntityKind::EK_Gen);
    inline Entity Var6 = Entity(33, 0, false, false, EntityKind::EK_Gen);
    inline Entity Var7 = Entity(34, 0, false, false, EntityKind::EK_Gen);
    inline static constexpr uint32_t MaxVarCnt = 8;
 
    // Core component ids are append-only.
    // Existing core ids must remain stable; new core components may only be added
    // after LastCoreComponent.
    //
    // Because of that, old snapshots stay loadable without bumping the serializer
    // version: any serialized entity id greater than the saved last core id is
    // remapped by the current core-id delta during load.
    //
    // Reordering or removing core components is not supported by this compatibility path.
    // Always has to match the last internal entity.
    inline Entity GAIA_ID(LastCoreComponent) = Var7;
 
    //----------------------------------------------------------------------
    // Helper functions
    //----------------------------------------------------------------------
 
    GAIA_NODISCARD inline bool is_wildcard(EntityId entityId) {
      return entityId == All.id();
    }
 
    GAIA_NODISCARD inline bool is_wildcard(Entity entity) {
      return entity.pair() && (is_wildcard(entity.id()) || is_wildcard(entity.gen()));
    }
 
    GAIA_NODISCARD inline bool is_wildcard(Pair pair) {
      return pair.first() == All || pair.second() == All;
    }
 
    GAIA_NODISCARD inline bool is_variable(EntityId entityId) {
      return entityId <= Var7.id() && entityId >= Var0.id();
    }
 
    GAIA_NODISCARD inline bool is_variable(Entity entity) {
      return entity.id() <= Var7.id() && entity.id() >= Var0.id();
    }
 
    GAIA_NODISCARD inline bool is_variable(Pair pair) {
      return is_variable(pair.first()) || is_variable(pair.second());
    }
 
  } // namespace ecs
 
  namespace cnt {
    template <>
    struct to_sparse_id<ecs::Entity> {
      static sparse_id get(const ecs::Entity& item) noexcept {
        // Cut off the flags
        return item.id();
      }
    };
  } // namespace cnt
} // namespace gaia