EntityStore.cpp

#include "EntityStore.h"
 
#include "Systems/Core/TransformSystem.h"
 
#include "Components/Core/RenderComponent.h"
 
#include "Systems/Core/SceneSystem.h"
 
#include "Services/DeferredNameResolution.h"
 
#include "EntityDefinitions.h"
#include "Context.h"
#include "MemoryContext.h"
 
#include "Serialization/AssetReader.h"
 
#include "Foundation/Logging/Logger.h"
#include "Foundation/HashFunctions.h"
#include "Foundation/Reflection/TypeDatabase.h"
 
#include <algorithm>
 
using namespace Cogs::Reflection;
 
namespace
{
  const Cogs::Logging::Log logger = Cogs::Logging::getLogger("EntityStore");
}
 
Cogs::Core::EntityStore::EntityStore(Context * context) :
  entityPool(8192, 8192, context->memory->baseAllocator, MemBlockType::Entity),
  entityDataPool(MemBlockType::Entity)
{
  LOG_TRACE(logger, "Initializing entity store...");
 
  this->context = context;
 
  LOG_TRACE(logger, "Initializing entity definitions...");
 
  Cogs::Core::createDefaultEntityDefinitions(this);
 
  LOG_TRACE(logger, "Entity definitions initialized.");
}
 
void Cogs::Core::EntityStore::clear()
{
  LOG_DEBUG(logger, "Cleaning up entities...");
 
  entitiesByName.clear();
  entities.clear();
 
  if (entityPool.size()) {
    LOG_WARNING(logger, "%zd entities allocated after clear. First N(6) from default scene", entityPool.size());
  }
 
  LOG_DEBUG(logger, "Entity store cleaned up.");
}
 
void Cogs::Core::EntityStore::addEntityDefinition(const EntityDefinition & definition)
{
  const size_t hashCode = Cogs::hash(definition.name);
 
  if (entityDefinitions.contains(hashCode)) {
    LOG_WARNING(logger, "Overwriting existing entity definition for %s.", definition.name.c_str());
  }
  LOG_TRACE(logger, "Adding entity definition for %s.", definition.name.c_str());
 
  entityDefinitions[hashCode] = definition;
}
 
void Cogs::Core::EntityStore::getEntityDefinitions(std::vector<StringView>& names) const
{
  names.clear();
  names.reserve(entityDefinitions.size());
  for (const auto & [_, def] : entityDefinitions) {
    names.emplace_back(def.name);
  }
}
 
void Cogs::Core::EntityStore::getEntityDefinitionComponents(std::vector<StringView>& components, const StringView & name) const
{
  components.clear();
  if (auto * def = getEntityDefinition(name); def) {
    components.reserve(def->components.size());
    for (auto & c : def->components) {
      components.emplace_back(c);
    }
  }
}
 
 
const Cogs::Core::EntityDefinition * Cogs::Core::EntityStore::getEntityDefinition(const StringView & name) const
{
  return getEntityDefinition(Cogs::hash(name));
}
 
const Cogs::Core::EntityDefinition * Cogs::Core::EntityStore::getEntityDefinition(size_t id) const
{
  auto fIt = entityDefinitions.find(id);
 
  return fIt != entityDefinitions.end() ? &fIt->second : nullptr;
}
 
Cogs::Core::EntityPtr Cogs::Core::EntityStore::createEntity(const StringView & name, const StringView & type, bool storeOwnership)
{
  auto entityPtr = entityPool.create();
  auto entityData = entityDataPool.create();
  auto entity = EntityPtr(entityPtr, [&](Entity * e)
  {
    this->destroyEntityComponents(e);
 
    entityDataPool.destroy(static_cast<EntityData*>(e->getUserData()));
    e->setId(NoEntity);
    entityPool.destroy(e);
    revision++;
  });
 
  auto entityId = entityPool.getHandle(entityPtr);
 
  entity->setId(entityId);
 
  if (storeOwnership) {
    entities[entityId] = entity;
  }
 
  if (name.size()) {
    context->deferredResolution->scheduleRescan();
    entity->setName(name);
 
    if (storeOwnership) {
      storeNamedEntity(entity, name);
    }
  }
 
  const size_t typeCode = Cogs::hash(type);
 
  entityData->templateId = typeCode;
  entity->setUserData(entityData);
 
  auto definitionIt = entityDefinitions.find(typeCode);
 
  if (definitionIt != entityDefinitions.end()) {
    auto & entityDefinition = definitionIt->second;
 
    createEntityComponents(entityDefinition, entity);
 
    applyFieldValues(context, {entityDefinition.defaultValues}, entity.get());
  } else {
    LOG_WARNING(logger, "Could not find entity definition for type: %.*s, name:%.*s. No components will be added.", StringViewFormat(type), StringViewFormat(name));
  }
 
  revision++;
  return entity;
}
 
void Cogs::Core::EntityStore::createEntities(size_t count, std::vector<EntityPtr> & entities)
{
  createEntities(count, entities, [&](Entity * e)
  {
    this->destroyEntityComponents(e);
 
    entityDataPool.destroy(static_cast<EntityData*>(e->getUserData()));
    e->setId(NoEntity);
    entityPool.destroy(e);
  });
}
 
void Cogs::Core::EntityStore::createEntities(size_t count, std::vector<EntityPtr> & entities, std::function<void(Entity *)> destructor)
{
  entities.resize(count);
 
  for (EntityPtr & entity : entities) {
    Entity* entityPtr = entityPool.create();
    EntityData* entityData = entityDataPool.create();
    entityPtr->setUserData(entityData);
 
    entity = EntityPtr(entityPtr, destructor);
    auto entityId = entityPool.getHandle(entityPtr);
 
    entity->setId(entityId);
  }
}
 
void Cogs::Core::EntityStore::createEntityComponents(EntityDefinition & entityDefinition, const EntityPtr & entity)
{
  if (!entityDefinition.compiled) {
    compileEntityDefinition(entityDefinition);
  }
 
  for (auto creator : entityDefinition.creators) {
    auto component = (*creator)();
 
    if (component.resolve()) {
      entity->addComponent(component);
    } else {
      LOG_ERROR(logger, "Null component returned by system creator.");
    }
  }
}
 
void Cogs::Core::EntityStore::compileEntityDefinition(EntityDefinition & entityDefinition)
{
  for (const std::string& componentName : entityDefinition.components) {
    const Reflection::Type & type = TypeDatabase::getType(componentName);
 
    if (!type.isValid()) {
      LOG_ERROR(logger, "Type \"%s\" not valid as component.", componentName.c_str());
      continue;
    }
 
    auto creatorIt = creators.find(type.getTypeId());
 
    if (creatorIt != creators.end()) {
      entityDefinition.creators.push_back(&creators[type.getTypeId()]);
    } else {
      LOG_ERROR(logger, "No creator function available for components of type %s.", componentName.c_str());
    }
  }
 
  entityDefinition.compiled = true;
}
 
void Cogs::Core::EntityStore::addChild(Entity * parent, const EntityPtr & entity)
{
  debug_assert(parent && "Invalid parent entity pointer.");
  debug_assert(entity && "Invalid entity cannot be parented.");
  if (!parent || !entity) return;
 
  TransformComponent* transform = entity->getComponent<TransformComponent>();
  const TransformComponent* parentTransform = parent->getComponent<TransformComponent>();
 
  bool noTransform = false;
  bool noScene = false;
 
  if (transform && parentTransform) {
    transform->parent = context->transformSystem->getHandle(parentTransform);
    transform->setChanged();
 
    context->transformSystem->updateTransformData(*transform);
  } else {
    noTransform = true;
  }
 
  SceneComponent* sceneComponent = entity->getComponent<SceneComponent>();
  SceneComponent* parentSceneComponent = parent->getComponent<SceneComponent>();
 
  if (sceneComponent && parentSceneComponent) {
    parentSceneComponent->children.push_back(entity);
    parentSceneComponent->setFieldChanged(&SceneComponent::children);
 
    sceneComponent->parent = context->sceneSystem->getHandle(parentSceneComponent);
    SceneSystem::updateState(*sceneComponent);
  } else {
    noScene = true;
  }
 
  if (noTransform && noScene) {
    std::string pid = parent->getName().empty() ? std::to_string(parent->getId()) : parent->getName();
    std::string cid = entity->getName().empty() ? std::to_string(entity->getId()) : entity->getName();
    LOG_WARNING(logger, "addChild failed: Both parent and child must have Scene and Transform components: Parent:%s Child:%s.", pid.c_str(), cid.c_str());
  }
}
 
void Cogs::Core::EntityStore::addChild(EntityId parent, EntityId child)
{
  addChild(getEntityPtr(parent), getEntity(child));
}
 
Cogs::ComponentModel::Component * Cogs::Core::EntityStore::addComponent(ComponentModel::Entity * entity, Reflection::TypeId typeId)
{
  auto & creator = creators[typeId];
 
  auto component = creator ? creator() : ComponentHandle::Empty();
 
  auto * compPtr = component.resolve();
  if (compPtr) {
    entity->addComponent(component);
  } else {
    LOG_ERROR(logger, "Could not create component with type id %d.", typeId);
    return nullptr;
  }
 
  return compPtr;
}
 
Cogs::ComponentModel::Component * Cogs::Core::EntityStore::addComponent(ComponentModel::Entity * entity, const StringView & type)
{
  return addComponent(entity, TypeDatabase::getType(type).getTypeId());
}
 
void Cogs::Core::EntityStore::removeComponent(ComponentModel::Entity * entity, ComponentModel::ComponentHandle handle)
{
  auto component = handle.resolve();
 
  if (!component) {
    LOG_ERROR(logger, "Cannot remove empty component handle.");
    return;
  }
 
  entity->removeComponent(handle);
 
  auto & destroyer = destroyers[component->getTypeId()];
 
  if (destroyer) destroyer(handle);
}
 
void Cogs::Core::EntityStore::removeChild(Entity * parent, const Entity * entity)
{
  if (!parent) {
    LOG_ERROR(logger, "Cannot remove child from null entity.");
    return;
  }
 
  if (!entity) {
    LOG_ERROR(logger, "Cannot remove null child from parent.");
    return;
  }
 
  auto transform = entity->getComponent<TransformComponent>();
 
  if (transform) {
    transform->parent = ComponentModel::ComponentHandle::Empty();
    transform->setChanged();
  }
 
  auto sceneComponent = parent->getComponent<SceneComponent>();
 
  if (!sceneComponent) {
    LOG_ERROR(logger, "Cannot remove child from parent without SceneComponent.");
    return;
  }
 
  auto it = std::find_if(sceneComponent->children.begin(),
                      sceneComponent->children.end(),
    [=](const EntityPtr & e) { return e.get() == entity; });
 
  if (it != sceneComponent->children.end()) {
    sceneComponent->children.erase(it);
  }
 
  sceneComponent->setChanged();
}
 
void Cogs::Core::EntityStore::removeChildren(ComponentModel::Entity * entity)
{
  if (!entity) {
    LOG_ERROR(logger, "Cannot remove children from null entity.");
    return;
  }
 
  auto sceneComponent = entity->getComponent<SceneComponent>();
 
  if (!sceneComponent) {
    return;
  }
 
  // Break all transform relationships. Be defensive about references to parent entity.
  for (auto & child : sceneComponent->children) {
    auto childTransform = child->getComponent<TransformComponent>();
 
    if (childTransform) {
      childTransform->parent = ComponentModel::ComponentHandle::Empty();
      childTransform->setChanged();
    }
 
    auto childSceneComponent = child->getComponent<SceneComponent>();
 
    if (childSceneComponent) {
      childSceneComponent->parent = {};
    }
  }
 
  sceneComponent->children.clear();
  sceneComponent->setChanged();
}
 
void Cogs::Core::EntityStore::setEntityParent(ComponentModel::Entity* parent, ComponentModel::Entity* child)
{
  Entity* oldParent = context->store->getEntityParent(child);
  if (oldParent != nullptr && parent == nullptr) {
    EntityPtr childPtr = findEntity(child->getId(), oldParent);
    assert(childPtr);
    // Move to Root
    removeChild(oldParent, child);
    if (!entities.contains(child->getId())) {
      entities[child->getId()] = childPtr;
      storeNamedEntity(childPtr, child->getName());
    }
  }
  else if (oldParent != nullptr && parent != nullptr) {
    // Change parent
    EntityPtr childPtr = findEntity(child->getId(), oldParent);
    assert(childPtr);
    removeChild(oldParent, child);
    addChild(parent, childPtr);
  }
  else if (oldParent == nullptr && parent != nullptr) {
    EntityPtr childPtr = getEntity(child->getId());
    assert(childPtr);
    destroyEntity(childPtr->getId());
    addChild(parent, childPtr);
  }
 
  // old and new parent null - no change
}
 
void Cogs::Core::EntityStore::destroyEntity(const EntityId id)
{
  auto entityIt = entities.find(id);
 
  if (entityIt != entities.end()) {
    auto entity = entityIt->second;
 
    assert(entity->getId() == static_cast<size_t>(id) && "Registered id does not match internal entity id. Entity store corrupted.");
 
    StringView name(entity->getName());
 
    if (name.size()) {
      entitiesByName.erase(Cogs::hash(name));
    }
 
    // NOTE: It is important that this owning reference is destroyed last.
    entities.erase(id);
  } else {
    LOG_WARNING(logger, "Could not erase entity with id %zu. No such entity found in store.", size_t(id));
  }
}
 
void Cogs::Core::EntityStore::destroyEntityComponents(Entity * entity)
{
  for (const ComponentHandle& c : entity->getComponents()) {
    const Component* component = c.resolve();
 
    assert(destroyers.contains(component->getTypeId()) && "No system registered to handle given type.");
 
    destroyers[component->getTypeId()](c);
  }
}
 
EntityId Cogs::Core::EntityStore::getNextEntityId()
{
  static EntityId entityId = 0;
 
  entityId++;
 
  return entityId;
}
 
Cogs::Core::EntityPtr Cogs::Core::EntityStore::getEntity(const EntityId entityId, bool logIfNotFound, bool onlyRegistered) const
{
  auto it = entities.find(entityId);
  if (it != entities.end()) {
    return it->second;
  }
 
  if (!onlyRegistered) {
    for (const auto& [_, child] : entities) {
      EntityPtr output = findEntity(entityId, child.get());
      if (output) {
        return output;
      }
    }
  }
 
  if (logIfNotFound) {
    LOG_ERROR(logger, "getEntity - unknown Id: %zu", static_cast<size_t>(entityId));
  }
 
  return {};
}
 
Cogs::Core::EntityPtr Cogs::Core::EntityStore::getEntity(const StringView & name, bool logIfNotFound) const
{
  auto it = entitiesByName.find(Cogs::hash(name));
 
  if (it == std::end(entitiesByName)) {
    if (logIfNotFound) {
      LOG_WARNING(logger, "No entity named '%.*s' found.", StringViewFormat(name));
    }
    return EntityPtr{};
  }
 
  EntityPtr ptr = it->second.lock();
  if (!ptr) {
    LOG_ERROR(logger, "Internal Error: Entity erased without removing entry in 'entitiesByName'.");
  }
 
  // Ensure that name matches.
  else if (StringView(ptr->getName()) != name) {
    LOG_ERROR(logger, "getEntity: Entity with name: '%s' vs '%.*s' duplicate hash in store.", ptr->getName().c_str(), StringViewFormat(name));
    return EntityPtr{};
  }
 
  return ptr;
}
 
Cogs::Core::EntityPtr Cogs::Core::EntityStore::findEntity(const StringView & name, const ComponentModel::Entity * root, EntityFind find) const
{
  if (root) {
    const SceneComponent* sceneComponent = root->getComponent<SceneComponent>();
 
    if (!sceneComponent) {
      return EntityPtr{};
    }
 
    for (const EntityPtr& child : sceneComponent->children) {
      if ((find & EntityFind::PartialNameMatch) != EntityFind::PartialNameMatch) {
        if (name == child->getName()) {
          return child;
        }
      }
      else {
        if (child->getName().find(std::string_view(name)) != std::string::npos) {
          return child;
        }
      }
 
      if ((find & EntityFind::NonRecursive) != EntityFind::NonRecursive) {
        EntityPtr found = findEntity(name, child.get(), find);
        if (found) {
          return found;
        }
      }
    }
  }
  else {
    // Look for global entities. Do quick lookup.
    EntityPtr entity = getEntity(name, false);
    if (entity) {
      // If non-recursive search entity must be a root entity.
      if ((find & EntityFind::NonRecursive) == EntityFind::NonRecursive) {
        if (getEntityParent(entity.get()) == nullptr) {
          return entity;
        }
      }
      else {
        return entity;
      }
    }
 
    for (const auto& [_, child] : entities) {
 
      // Using only root entities if Non-recursive search.
      if ((find & EntityFind::NonRecursive) != EntityFind::NonRecursive || !getEntityParent(child.get())) {
        if ((find & EntityFind::PartialNameMatch) != EntityFind::PartialNameMatch) {
          if (name == child->getName()) {
            return child;
          }
        }
        else {
          if (child->getName().find(std::string_view(name)) != std::string::npos) {
            return child;
          }
        }
 
        if ((find & EntityFind::NonRecursive) != EntityFind::NonRecursive) {
          EntityPtr found = findEntity(name, child.get(), find);
 
          if (found) {
            return found;
          }
        }
      }
    }
  }
 
  return EntityPtr{};
}
 
Cogs::Core::EntityPtr Cogs::Core::EntityStore::findEntity(EntityId entityId, const ComponentModel::Entity* parent) const
{
  EntityPtr output;
  const SceneComponent* sceneComponent = parent->getComponent<SceneComponent>();
  if (sceneComponent) {
    for (const EntityPtr& child : sceneComponent->children) {
      if (entityId == static_cast<EntityId>(child->getId())) {
        output = child;
        break;
      }
 
      output = findEntity(entityId, child.get());
      if (output) {
        break;
      }
    }
  }
 
  return output;
}
 
Cogs::ComponentModel::Entity* Cogs::Core::EntityStore::getEntityParent(const ComponentModel::Entity* entity) const
{
  auto transformComponent = entity->getComponent<TransformComponent>();
 
  if (transformComponent) {
    auto* parentTransform = transformComponent->parent.resolve();
    if (parentTransform) {
      auto parent = parentTransform->getContainer();
      return parent;
    }
  }
 
  return nullptr;
}
 
void Cogs::Core::EntityStore::renameEntity(ComponentModel::Entity* entityPtr, const StringView name)
{
  auto it = entities.find(entityPtr->getId());
  if (it == entities.end()) {
    // Not in global store, just rename the entity's name.
    entityPtr->setName(name);
  }
  else {
    if (!entityPtr->getName().empty()) {
      const size_t oldHashCode = Cogs::hash(entityPtr->getName());
 
      auto oldIt = entitiesByName.find(oldHashCode);
      if (oldIt == entitiesByName.end()) {
        LOG_WARNING(logger, "renameEntity: Failed old name lookup: '%s' in store.", entityPtr->getName().c_str());
      }
      else {
        entitiesByName.erase(oldIt);
      }
    }
 
    if (!name.empty()) {
      storeNamedEntity(it->second, name);
    }
 
    entityPtr->setName(name);
  }
 
  context->deferredResolution->scheduleRescan();
}
 
 
std::string Cogs::Core::EntityStore::dumpHierarchy() const
{
  std::string result;
 
  for (auto& e : entities) {
    result += dumpHierarchy(e.second.get());
  }
  return result;
}
 
std::string Cogs::Core::EntityStore::dumpHierarchy(const ComponentModel::Entity* parent, const std::string& prefix) const {
  std::string                     newprefix = prefix + "  ";
  std::string                     result;
  const ComponentCollectionBase&  components = parent->getComponents();
 
  result.reserve(4000);
  result += prefix;
  result += parent->getName().empty() ? "<unnamed entity>" : parent->getName().c_str();
 
  if (components.size()) {
    const char* sep = " [";
 
    for (ComponentHandle c : components) {
      const Reflection::Type& type = TypeDatabase::getType(c.typeId);
 
      result += sep;
      result += type.getName().getName();
      sep = ", ";
    }
    result += "]";
  }
  result += "\n";
 
  SceneComponent* sceneComponent = parent->getComponent<SceneComponent>();
 
  if (sceneComponent) {
    for (const EntityPtr& child : sceneComponent->children) {
      result += dumpHierarchy(child.get(), newprefix);
    }
  }
  return result;
}
 
 
Cogs::ComponentModel::Entity* Cogs::Core::EntityStore::getEntityPtr(const EntityId entityId)
{
  if (entityId == NoEntity) {
    return nullptr;
  }
 
  if (!entityPool.isValid(static_cast<Collections::ElementHandle>(entityId))) {
    LOG_ERROR(logger, "getEntityPtr: EntityHandle out of range: %zd.", static_cast<size_t>(entityId));
    return nullptr;
  }
 
  ComponentModel::Entity* entity = entityPool[static_cast<Collections::ElementHandle>(entityId)];
 
  // Checks that entity pointed to not deleted or space reused by new entity.
  return (entity && static_cast<EntityId>(entity->getId()) == entityId) ? entity : nullptr;
}
 
void Cogs::Core::EntityStore::addSystem(const TypeId typeId, ComponentCreator creator, ComponentDestroyer destroyer)
{
  creators[typeId] = creator;
  destroyers[typeId] = destroyer;
}
 
void Cogs::Core::EntityStore::addSystem(ComponentSystemBase * system)
{
  const TypeId typeId = system->getComponentType();
 
  if (typeId == Reflection::NoType) {
    LOG_ERROR(logger, "Cannot add system using uninitialized type id (Reflection::NoType).");
 
    return;
  }
 
  auto creator = [system]() -> ComponentHandle
  {
    return system->createComponent();
  };
 
  auto destroyer = [system](ComponentHandle c)
  {
    system->destroyComponent(c);
  };
 
  systems[typeId] = system;
  addSystem(typeId, creator, destroyer);
}
 
Cogs::Core::EntityPtr Cogs::Core::EntityStore::createChildEntity(const StringView & type, Entity * parent, const StringView & name)
{
  auto entity = createEntity(name, type, false);
 
  addChild(parent, entity);
 
  return entity;
}
 
void Cogs::Core::EntityStore::getEntitiesWithComponent(std::vector<EntityId>& entities, Reflection::TypeId componentTypeId)
{
  entities.clear();
  if (auto it = systems.find(componentTypeId); it != systems.end()) {
    it->second->addEntitiesWithComponent(entities, componentTypeId);
  }
}
 
void Cogs::Core::EntityStore::storeNamedEntity(const EntityPtr& entity, StringView name)
{
  const size_t hashCode = Cogs::hash(name);
 
  const auto it = entitiesByName.find(hashCode);
  if (it != entitiesByName.end()) {
    const EntityPtr oldEntityPtr = it->second.lock();
    if (!oldEntityPtr) {
      LOG_ERROR(logger, "Expired Entity with name: '%.*s' in store. Replaced.", StringViewFormat(name));
      entitiesByName[hashCode] = entity;
    }
    else if (name == oldEntityPtr->getName())
      LOG_WARNING_ONCE(logger, "Entity with name: '%.*s' already exists in store.", StringViewFormat(name));
    else
      LOG_ERROR(logger, "Entity with name: '%s' vs '%.*s' duplicate hash in store.", oldEntityPtr->getName().c_str(), StringViewFormat(name));
  }
  else {
    entitiesByName[hashCode] = entity;
  }
}