EntityManager.h

Go to the documentation of this file.

/*
    Author : Tobias Stein
    Date   : 11th July, 2016
    File   : EntityManager.h
    
    Enity manager class.
 
    All Rights Reserved. (c) Copyright 2016.
*/
 
#pragma once
#ifndef ECS__ENTITY_MANAGER_H__
#define ECS__ENTITY_MANAGER_H__
 
#include "API.h"
#include "Engine.h"
 
#include "IEntity.h"
#include "ComponentManager.h"
 
#include "Memory/MemoryChunkAllocator.h"
 
#include "util/Handle.h"
 
#ifdef _MSC_VER
#pragma warning(push)
 
// warning C4291: 'void *operator new(::size_t,void *) throw()': no matching operator delete found; memory will not be freed if initialization throws an exception
// note we are using custom memory allocator no need for delete
#pragma warning(disable: 4291)
#endif //_MSC_VER
 
namespace ECS
{   
    using EntityHandleTable = util::HandleTable<IEntity, EntityId>;
 
 
    class ECS_API EntityManager
    {
        DECLARE_LOGGER
 
 
        class IEntityContainer
        {
        public:
 
            virtual ~IEntityContainer()
            {}
 
            virtual const char* GetEntityContainerTypeName() const = 0;
 
            virtual void DestroyEntity(IEntity* object) = 0;
 
        }; // class IEntityContainer
 
 
        template<class T>
        class EntityContainer : public Memory::MemoryChunkAllocator<T, ENITY_T_CHUNK_SIZE>, public IEntityContainer
        {
 
            EntityContainer(const EntityContainer&) = delete;
            EntityContainer& operator=(EntityContainer&) = delete;
 
        public:
 
            EntityContainer() : Memory::MemoryChunkAllocator<T, ENITY_T_CHUNK_SIZE>("EntityManager")
            {}
 
            virtual ~EntityContainer() override = default;
 
            virtual const char* GetEntityContainerTypeName() const override
            { 
                static const char* ENTITY_TYPE_NAME{ typeid(T).name() };
                return ENTITY_TYPE_NAME;
            }
 
            virtual void DestroyEntity(IEntity* object) override
            {
                // call d'tor
                object->~IEntity();
 
                this->DestroyObject(object);
            }
 
        }; // EntityContainer
 
        using EntityRegistry = eastl::unordered_map<EntityTypeId, IEntityContainer*>;
        EntityRegistry m_EntityRegistry;
 
        using PendingDestroyedEntities = eastl::vector<EntityId>;
        PendingDestroyedEntities m_PendingDestroyedEntities;
        size_t m_NumPendingDestroyedEntities;
 
        ComponentManager*   m_ComponentManagerInstance = nullptr;
 
    private:    
 
        EntityManager(const EntityManager&) = delete;
        EntityManager& operator=(EntityManager&) = delete;
 
        EntityHandleTable m_EntityHandleTable;
 
 
 
 
        template<class T>
        inline EntityContainer<T>* GetEntityContainer()
        {
            EntityTypeId EID = T::STATIC_ENTITY_TYPE_ID;
 
            auto it = this->m_EntityRegistry.find(EID);
            EntityContainer<T>* ec = nullptr;
                        
            if (it == this->m_EntityRegistry.end())
            {
                ec = new EntityContainer<T>();
                this->m_EntityRegistry[EID] = ec;
            }
            else
                ec = (EntityContainer<T>*)it->second;
 
            assert(ec != nullptr && "Failed to create EntityContainer<T>!");
            return ec;
        }
 
 
        EntityId AqcuireEntityId(IEntity* entity);
 
 
        void ReleaseEntityId(EntityId id);  
 
    public:
 
        EntityManager(ComponentManager* componentManagerInstance);
        ~EntityManager();
 
 
        template<class T, class... ARGS>
        EntityId CreateEntity(ARGS&&... args)
        {       
            // aqcuire memory for new entity object of type T
            void* pObjectMemory = GetEntityContainer<T>()->CreateObject();
 
            ECS::EntityId entityId = this->AqcuireEntityId((T*)pObjectMemory);
 
            ((T*)pObjectMemory)->m_EntityID = entityId;
            ((T*)pObjectMemory)->m_ComponentManagerInstance = this->m_ComponentManagerInstance;
 
            // create entity inplace
            IEntity* entity = new (pObjectMemory)T(std::forward<ARGS>(args)...);
            (void)entity;
 
            return entityId;
        }
 
        void DestroyAndRemoveEntity(EntityId entityId)
        {
            RemoveDestroyedEntity(entityId);
        }
 
        void DestroyEntity(EntityId entityId)
        {
 
            if (this->m_NumPendingDestroyedEntities < this->m_PendingDestroyedEntities.size())
            {
                this->m_PendingDestroyedEntities[this->m_NumPendingDestroyedEntities++] = entityId;
            }
            else
            {
                this->m_PendingDestroyedEntities.push_back(entityId);
                this->m_NumPendingDestroyedEntities++;
            }
        }
 
 
        inline IEntity* GetEntity(EntityId entityId)
        {
            return this->m_EntityHandleTable[entityId];
        }
 
 
        inline EntityId GetEntityId(EntityId::value_type index) const
        {
            return this->m_EntityHandleTable[index];
        }
 
        void RemoveDestroyedEntity(EntityId id);
 
 
 
        void RemoveDestroyedEntities();
    };
 
     
} // namespace ECS
 
#ifdef _MSC_VER
#pragma warning(pop)
#endif //_MSC_VER
 
#endif // ECS__ENTITY_MANAGER_H__