EntityCreator.cpp

#include "EntityCreator.h"
 
#include "Foundation/Logging/Logger.h"
 
#include "EntityStore.h"
 
#include "Systems/Core/TransformSystem.h"
#include "Systems/Core/PropertiesSystem.h"
#include "Systems/Core/AssetSystem.h"
 
#include "Components/Core/RenderComponent.h"
 
#include "Resources/AssetManager.h"
 
namespace
{
  Cogs::Logging::Log logger = Cogs::Logging::getLogger("EntityCreator");
 
  void logFail(bool lookupExisting, Cogs::StringView type, Cogs::StringView name)
  {
    if (lookupExisting) {
      LOG_ERROR(logger, "Could not find entity name:'%.*s'.", StringViewFormat(name));
    }
    else {
      LOG_ERROR(logger, "Could not create entity type:'%.*s'.", StringViewFormat(type));
    }
  }
}
 
Cogs::Core::EntityPtr Cogs::Core::createEntity(EntityCreationContext & entityContext, const SceneEntityDefinition & definition)
{
  auto context = entityContext.context;
  auto & scene = *entityContext.scene;
 
  if (definition.isSequence()) return nullptr;
 
  const auto name = scene.properties.getString(definition.nameIndex);
 
  StringView type{};
  if (definition.isModel()) {
    type = entityContext.skipModel ? "Group" : "Model";
  }
  else if (definition.isAsset()) {
    type = "Asset";
  }
  else if (definition.isModel() || definition.isLodGroup()) {
  }
  else {
    type = Strings::get(definition.type);
  }
 
  const bool lookupExisting = !name.empty() && name[0] == '$';
 
  EntityPtr entity{};
 
  if (lookupExisting) {
    entity = context->store->findEntity(name.substr(1));
  } else {
    switch (entityContext.parentMode) {
    case EntityParentMode::None:
      entity = context->store->createEntity(name, type);
      break;
    case EntityParentMode::Default:
      entity = context->store->createChildEntity(type, entityContext.parent, name);
      break;
    case EntityParentMode::TransformOnly:
      entity = context->store->createEntity(name, type, false);
 
      {
        auto parentTransform = entityContext.parent->getComponentHandle<TransformComponent>();
 
        auto transform = entity->getComponent<TransformComponent>();
 
        if (transform) {
          transform->parent = parentTransform;
        }
      }
 
      break;
    default:
      break;
    }
  }
 
  if (!entity) {
    logFail(lookupExisting, type, name);
    return {};
  }
 
  if (definition.objectId < ~0u) {
    auto renderComponent = entity->getComponent<RenderComponent>();
 
    if (renderComponent) {
      renderComponent->objectId = definition.objectId;
    } else {
      LOG_ERROR(logger, "objectId property set but no target RenderComponent defined.");
    }
  }
 
  if (definition.numFields) {
    std::span<FieldValue> fields = std::span(scene.fieldValues).subspan(definition.firstField, definition.numFields);
    applyFieldValues(context, fields, entity.get());
  }
 
  if (definition.numProperties > 0) {
    auto propertiesComponent = entity->getComponent<PropertiesComponent>();
 
    if (!propertiesComponent) {
      propertiesComponent = context->store->addComponent<PropertiesComponent>(entity.get());
    }
 
    propertiesComponent->properties.copyProperties(scene.properties, definition.firstProperty, definition.numProperties);
  }
 
  if (definition.isParentedByName()) {
    auto parentName = scene.properties.getString(definition.parentIndex);
 
    auto p = context->store->findEntity(parentName.substr(1));
    context->store->addChild(p.get(), entity);
  }
 
  if (definition.isAsset()) {
    auto path = scene.properties.getString(definition.asset.index);
 
    auto assetComponent = entity->getComponent<AssetComponent>();
 
    if (!assetComponent) {
      assetComponent = context->store->addComponent<AssetComponent>(entity.get());
    }
 
    assetComponent->asset = context->assetManager->loadAsset(path, NoResourceId, AssetLoadFlags::None);
    assetComponent->flags = (AssetFlags)definition.asset.flags;
  }
 
  return entity;
}
 
Cogs::ComponentModel::Entity * Cogs::Core::createEntity(Context * context, SceneDefinition & scene, const SceneEntityDefinition & definition, Cogs::ComponentModel::Entity * parent)
{
  if (definition.isSequence()) {
    return nullptr;
  }
 
  const StringView name = scene.properties.getString(definition.nameIndex);
  StringView type;
  if (definition.isAsset()) {
    type = "Asset";
  }
  else if (definition.isModel() || definition.isLodGroup()) {
  }
  else {
    type = Strings::get(definition.type);
  }
 
  const bool lookupExisting = !name.empty() && name[0] == '$';
  EntityPtr entity;
  if (lookupExisting) {
    entity = context->store->findEntity(name.substr(1));
  }
  else if (parent) {
    entity = context->store->createChildEntity(type, parent, name);
  } else {
    entity = context->store->createEntity(name, type);
  }
 
  if (!entity) {
    logFail(lookupExisting, type, name);
    return nullptr;
  }
 
  if (definition.objectId < ~0u) {
    auto renderComponent = entity->getComponent<RenderComponent>();
 
    if (renderComponent) {
      renderComponent->objectId = definition.objectId;
    } else {
      LOG_ERROR(logger, "objectId property set but no target RenderComponent defined.");
    }
  }
 
  if (definition.numFields) {
    auto fields = std::span(scene.fieldValues).subspan(definition.firstField, definition.numFields);
    applyFieldValues(context, fields, entity.get());
  }
 
  if (definition.numProperties > 0) {
    auto propertiesComponent = entity->getComponent<PropertiesComponent>();
 
    if (!propertiesComponent) {
      propertiesComponent = context->store->addComponent<PropertiesComponent>(entity.get());
    }
 
    propertiesComponent->properties.copyProperties(scene.properties, definition.firstProperty, definition.numProperties);
  }
 
  if (definition.isParentedByName()) {
    auto parentName = scene.properties.getString(definition.parentIndex);
 
    auto p = context->store->findEntity(parentName.substr(1));
    context->store->addChild(p.get(), entity);
  }
 
  if (definition.isAsset()) {
    auto path = scene.properties.getString(definition.asset.index);
 
    auto assetComponent = entity->getComponent<AssetComponent>();
 
    if (!assetComponent) {
      assetComponent = context->store->addComponent<AssetComponent>(entity.get());
    }
 
    assetComponent->asset = context->assetManager->loadAsset(path, NoResourceId, AssetLoadFlags::None);
    assetComponent->flags = (AssetFlags)definition.asset.flags;
  }
 
  return entity.get();
}