EntityManager.hpp

Go to the documentation of this file.

//
//  CeresEngine - A game development framework
//
//  Created by Rogiel Sulzbach.
//  Copyright (c) 2018-2022 Rogiel Sulzbach. All rights reserved.
//
 
#pragma once
 
#include "Forward.hpp"
 
#include "Component.hpp"
#include "ComponentStore.hpp"
#include "EntityID.hpp"
 
#include "CeresEngine/Macros.hpp"
 
#include "CeresEngine/Foundation/Flags.hpp"
#include "CeresEngine/Foundation/Generator.hpp"
#include "CeresEngine/Foundation/SmartPtr.hpp"
#include "CeresEngine/Foundation/String.hpp"
#include "CeresEngine/Foundation/Container/Map.hpp"
#include "CeresEngine/Foundation/Container/Set.hpp"
#include "CeresEngine/Foundation/Container/Vector.hpp"
 
#include <bitset>
 
namespace CeresEngine {
 
    enum class EntityDirtyBit {
        Name = 1u << 0u,
        Parent = 1u << 1u,
        Children = 1u << 2u,
        Component = 1 << 3u,
    };
 
    using EntityDirtyFlags = Flags<EntityDirtyBit>;
    CE_FLAGS_OPERATORS(EntityDirtyBit)
 
    enum class ComponentDirtyBit {
        Added,
        Updated,
        Removed
    };
 
    using ComponentDirtyFlags = Flags<ComponentDirtyBit>;
    CE_FLAGS_OPERATORS(ComponentDirtyBit)
 
    class CE_SCRIPT_EXPORT() EntityManager final {
        template<typename C> friend class TComponentType;
 
    private:
        Vector<UPtr<AbstractComponentStore>> mComponentStores;
 
        ComponentMaskSet mComponentMasks;
 
        EntityIDAllocator mAllocator;
 
        struct EntityMetadata;
 
        Vector<EntityMetadata> mEntityMetadata;
 
        HashMap<ComponentMask, Vector<AbstractComponentListener*>> mComponentListeners;
 
        Map<EntityIndex, EntityChangeSet> mDirtyEntities;
 
    private:
        World* mWorld = nullptr;
 
        EntityEventManager& mEventManager;
 
        EntityActionManager* mActionManager;
 
        static const Entity nullEntity;
 
    public:
        CE_SCRIPT_EXPORT()
        explicit EntityManager(EntityEventManager& eventManager);
 
        CE_SCRIPT_EXPORT()
        explicit EntityManager(EntityEventManager& eventManager, EntityActionManager& actionManager);
 
        CE_SCRIPT_EXPORT()
        explicit EntityManager(World& world, EntityEventManager& eventManager, EntityActionManager& actionManager);
 
        EntityManager(const EntityManager&) = delete;
        EntityManager& operator=(const EntityManager&) = delete;
 
        EntityManager(EntityManager&&) = delete;
        EntityManager& operator=(EntityManager&&) = delete;
 
        ~EntityManager();
 
    public:
        void update();
 
    public: // Entity management
        [[nodiscard]] EntityID allocate(const Entity& parent = nullEntity, String name = {});
 
        //        /// Allocates a new entity ID.
        //        /// \return The allocated entity ID
        //        [[nodiscard]] CE_SCRIPT_EXPORT()
        //        EntityID allocate(String name) { return allocate(nullEntity, std::move(name)); }
 
        [[nodiscard]] Vector<EntityID> allocate(EntityIndex n, const Entity& parent = nullEntity);
 
        [[nodiscard]] Entity create(const Entity& parent = nullEntity, String name = {});
 
        //        /// Creates a new entity
        //        /// \return The created entity
        //        [[nodiscard]] CE_SCRIPT_EXPORT()
        //        Entity create(String name) { return create(nullEntity, std::move(name)); }
 
        [[nodiscard]] Vector<Entity> create(EntityIndex n, const Entity& parent = nullEntity);
 
        [[nodiscard]] CE_SCRIPT_EXPORT()
        Entity get(EntityID entityID);
 
        [[nodiscard]] CE_SCRIPT_EXPORT()
        Entity get(EntityIndex entityIndex);
 
        CE_SCRIPT_EXPORT()
        void destroy(EntityID entityID);
 
        CE_SCRIPT_EXPORT()
        Entity copy(EntityID entityID);
 
        [[nodiscard]] CE_SCRIPT_EXPORT()
        bool valid(EntityID entityID) noexcept;
 
        CE_SCRIPT_EXPORT()
        void clear();
 
    private: // Entity-Component interface
        friend class Entity;
        template<CComponent... Components> friend class EntityObject;
        template<typename T, typename Component> friend struct ComponentFieldMutator;
 
        template<CComponent C, typename... Args>
        inline C& createComponent(EntityID entityID, Args&&... args) noexcept(std::is_nothrow_constructible_v<C, Args...>);
 
        AbstractComponent& createComponent(EntityID entityID, const ComponentType& type, const Box& initialValue = nullptr);
 
        template<CComponent C, typename... Args>
        inline C& setComponent(EntityID entityID, Args&&... args) noexcept(std::is_nothrow_constructible_v<C, Args...>);
 
        template<CComponent C> inline void removeComponent(EntityID entityID) noexcept(std::is_nothrow_destructible_v<C>);
 
        void removeComponent(EntityID entityID, const ComponentType& type);
 
        template<CComponent C> [[nodiscard]] inline C& getComponent(EntityID entityID) noexcept;
 
        [[nodiscard]] AbstractComponent& getComponent(EntityID entityID, const ComponentType& type);
 
        // TODO Write docs.
        [[nodiscard]] Vector<AbstractComponent*> getComponents(EntityID entityID);
 
        template<CComponent... Cs> [[nodiscard]] bool hasComponents(EntityID entityID) const noexcept;
 
        [[nodiscard]] bool hasComponents(EntityID entityID, ComponentMask mask) const noexcept;
 
        void clear(EntityID entityID);
 
        [[nodiscard]] bool empty(EntityID entityID) noexcept;
 
    public: // Entity Objects
        template<typename E, typename... Args> [[nodiscard]] inline E create(Args&&... args);
 
        template<typename E, typename Block, typename... Args> inline E createWith(Block&& block, Args&&... args);
 
    private: // Entity Objects interface
        template<typename E> [[nodiscard]] inline bool is(EntityID entityID) const noexcept;
 
        template<typename E> [[nodiscard]] inline E as(EntityID entityID) const;
 
        template<typename E> [[nodiscard]] inline E being(EntityID entityID) const noexcept;
 
    private: // Parent & Children entities
        [[nodiscard]] Entity getParent(EntityID entityID) const noexcept;
 
        void setParent(EntityID entityID, Entity parent);
 
        [[nodiscard]] const Vector<Entity>& getChildren(EntityID entityID) const noexcept;
 
    private: // Naming
        [[nodiscard]] StringView getName(EntityID entityID) const noexcept;
 
        void setName(EntityID entityID, String name);
 
    public: // Listeners
        void addListener(AbstractComponentListener& componentListener);
 
        void removeListener(AbstractComponentListener& componentListener);
 
    private:
        void triggerComponentListeners(EntityID entityID, ComponentMask oldMask, ComponentMask newMask) noexcept;
 
    public: // Querying
        template<typename P> class QueryExecutor {
        public:
            using Predicate = P;
 
        private:
            Predicate mPredicate;
 
        public:
            explicit inline QueryExecutor(Predicate&& predicate);
 
        public:
            Generator<const Entity> operator()(const EntityManager& entityManager) const noexcept;
        };
 
        [[nodiscard]] Generator<const Entity> each() const noexcept;
 
        template<typename Predicate> [[nodiscard]] inline EntityQuery<Predicate> query(Predicate&& predicate) const noexcept;
 
        template<typename... Cs, typename Callable> inline void with(Callable&& call) const noexcept;
 
        template<typename EO> inline Generator<EO> with() const noexcept;
 
    public: // Component changes
    private:
        template<CComponent C, typename T> void markComponentFieldAsDirty(EntityID entityID, T C::*fieldPointer);
 
        void markComponentFieldAsDirty(EntityID entityID, const ComponentType& componentType, const ClassProperty* property);
 
        void markEntityAsDirty(EntityID entityID, EntityDirtyFlags flags);
 
    public:
        [[nodiscard]] World& getWorld() noexcept { return *mWorld; }
 
        [[nodiscard]] const World& getWorld() const noexcept { return *mWorld; }
 
        [[nodiscard]] CE_SCRIPT_EXPORT(property = "getter", name = "eventManager")
        EntityEventManager& events() noexcept;
 
        [[nodiscard]] const EntityEventManager& events() const noexcept;
 
        [[nodiscard]] CE_SCRIPT_EXPORT(property = "getter", name = "actionManager")
        EntityActionManager& actions() noexcept;
 
        [[nodiscard]] const EntityActionManager& actions() const noexcept;
 
    private: // Entity Metadata
        [[nodiscard]] EntityMetadata& metadata(EntityID entityID);
 
        [[nodiscard]] EntityMetadata* metadataIf(EntityID entityID) noexcept;
 
        [[nodiscard]] const EntityMetadata* metadataIf(EntityID entityID) const noexcept;
 
    private:
        template<typename C> [[nodiscard]] inline ComponentStore<C>& getComponentStore() noexcept;
 
        template<typename C> [[nodiscard]] inline const ComponentStore<C>& getComponentStore() const noexcept;
 
        [[nodiscard]] AbstractComponentStore& getComponentStore(ComponentID componentID) noexcept;
    };
 
} // namespace CeresEngine
 
#include "EntityManager.inl"