EntityStore.h

#pragma once
 
#include "EntityDefinition.h"
#include "ComponentFunctions.h"
 
#include "Foundation/Collections/Pool.h"
#include "Foundation/ComponentModel/Component.h"
#include "Foundation/ComponentModel/Entity.h"
#include "Foundation/Reflection/Type.h"
 
#include <unordered_map>
 
namespace Cogs
{
  namespace Core
  {
    class ContextBase;
    class Context;
 
    struct EntityData
    {
      size_t templateId = 0;
      ContextBase * entityContext = 0;
      uint32_t flags = 0;
    };
 
    enum class EntityFind {
      Default           = 1,        
      PartialNameMatch  = 1 << 1,   
      NonRecursive      = 1 << 2,   
      // Insert new flags here
      MaxFlag           = 1 << 7,   
    };
    ENABLE_ENUM_FLAGS(EntityFind);
 
    class COGSCORE_DLL_API EntityStore
    {
    public:
      EntityStore(Context * context);
 
      void clear();
 
      void addEntityDefinition(const EntityDefinition & definition);
 
      const EntityDefinition * getEntityDefinition(const StringView & name) const;
      const EntityDefinition * getEntityDefinition(size_t id) const;
 
      void getEntityDefinitions(std::vector<StringView>& names) const;
 
      void getEntityDefinitionComponents(std::vector<StringView>& components, const StringView & name) const;
 
      EntityPtr createEntity(const StringView & name, const StringView & type, bool storeOwnership = true);
 
      void createEntities(size_t count, std::vector<EntityPtr> & entities);
      void createEntities(size_t count, std::vector<EntityPtr> & entities, std::function<void(ComponentModel::Entity *)> destructor);
 
      EntityPtr createChildEntity(const StringView & type, ComponentModel::Entity * parent, const StringView & name = StringView());
 
      void removeChild(ComponentModel::Entity * parent, const ComponentModel::Entity * entity);
 
      void removeChildren(ComponentModel::Entity * entity);
 
      void setEntityParent(ComponentModel::Entity* parent, ComponentModel::Entity* child);
 
      void destroyEntity(const EntityId id);
 
      EntityPtr getEntity(const StringView & name, bool logIfNotFound = true) const;
 
      EntityPtr findEntity(const StringView & name, const ComponentModel::Entity * root = nullptr, EntityFind findOptions = EntityFind::Default) const;
 
      Cogs::ComponentModel::Entity* getEntityParent(const ComponentModel::Entity* entity) const;
 
      EntityPtr getEntity(const EntityId entityId, bool logIfNotFound = true, bool onlyRegistered = false) const;
 
      void renameEntity(ComponentModel::Entity* entityPtr, StringView name);
 
      bool hasEntityOwnership(const EntityId entityId) const
      {
        return entities.find(entityId) != entities.end();
      }
 
      const std::unordered_map<EntityId, EntityPtr> & getEntities() const
      {
        return entities;
      }
 
      ComponentModel::Entity* getEntityPtr(const EntityId entityId);
 
      std::string dumpHierarchy() const;
 
      std::string dumpHierarchy(const ComponentModel::Entity* parent, const std::string& prefix = "") const;
 
      void addSystem(const Reflection::TypeId typeId, ComponentCreator creator, ComponentDestroyer destroyer);
 
      void addSystem(class ComponentSystemBase * system);
 
      void addChild(ComponentModel::Entity * parent, const EntityPtr & entity);
      void addChild(EntityId parent, EntityId child);
 
      ComponentModel::Component * addComponent(ComponentModel::Entity * entity, Reflection::TypeId typeId);
      ComponentModel::Component * addComponent(ComponentModel::Entity * entity, const StringView & type);
 
      template<typename ComponentType>
      ComponentType * addComponent(ComponentModel::Entity * entity)
      {
        return static_cast<ComponentType *>(addComponent(entity, Cogs::Reflection::TypeDatabase::getType<ComponentType>().getTypeId()));
      }
 
      void removeComponent(ComponentModel::Entity * entity, ComponentModel::ComponentHandle handle);
 
      const std::unordered_map<size_t, EntityDefinition> & getDefinitions() const
      {
        return entityDefinitions;
      }
 
      size_t getAllocatedEntityCount() const { return entityDataPool.size(); }
 
      uint32_t getRevision() const { return revision; }
 
 
      void getEntitiesWithComponent(std::vector<EntityId>& entities, Reflection::TypeId typeId);
 
      Context * getContext() const { return context; }
 
    private:
      EntityId getNextEntityId();
 
      EntityPtr findEntity(EntityId entityId, const ComponentModel::Entity* parent) const;
 
      void createEntityComponents(EntityDefinition & entityDefinition, const EntityPtr & entity);
      void destroyEntityComponents(ComponentModel::Entity * entity);
      
      void compileEntityDefinition(EntityDefinition & entityDefinition);
 
      void storeNamedEntity(const EntityPtr& entity, StringView name);
    private:
 
      std::unordered_map<size_t, EntityDefinition> entityDefinitions;
 
      std::unordered_map<Reflection::TypeId, ComponentCreator> creators;
      std::unordered_map<Reflection::TypeId, ComponentDestroyer> destroyers;
      std::unordered_map<Reflection::TypeId, ComponentSystemBase*> systems;
 
      Collections::Pool<ComponentModel::Entity> entityPool;
      Collections::Pool<EntityData> entityDataPool;
      std::unordered_map<EntityId, EntityPtr> entities;
      std::unordered_map<size_t, WeakEntityPtr> entitiesByName;
 
      Context * context;
      uint32_t revision = 1;
    };
  }
}