EditorCommand.cpp

#include "EditorCommand.h"
 
#include "Context.h"
#include "EntityStore.h"
 
#include "Serialization/EntityReader.h"
#include "Serialization/EntityWriter.h"
#include "Serialization/SceneReader.h"
#include "Serialization/EntityCreator.h"
 
#include "Bridge/SceneFunctions.h"
 
#include "Components/Core/TransformComponent.h"
 
#include "Foundation/Geometry/BoundingBox.hpp"
#include "Foundation/Logging/Logger.h"
#include "Foundation/Reflection/TypeDatabase.h"
 
#include <algorithm>
 
using namespace Cogs::Geometry;
 
 
Cogs::Core::PostCommand::~PostCommand() = default;
 
// --------
 
Cogs::Core::CreateEntityCommand::CreateEntityCommand(EditorState* state, const StringView& type, const StringView& name, bool openInRoot)
  : EditorCommand(state, state->context), type(type.to_string()), name(name.to_string()),
    openInRoot(openInRoot)
{
}
 
void Cogs::Core::CreateEntityCommand::apply()
{
  EntityPtr entity;
  if (!openInRoot && state->getSelected()) {
    ComponentModel::Entity * parent = state->getSelected();
    entity = context->store->createChildEntity(type, parent, name);
    parentId = parent->getId();
  }
  else {
    entity = context->store->createEntity(name, type);
  }
 
  entityId = entity->getId();
  
  previousSelection = state->selected;
 
  state->setSelection(entity->getId());
}
 
void Cogs::Core::CreateEntityCommand::undo()
{
  if (entityId == NoEntity) return;
 
  if (parentId == NoEntity) {
    context->store->destroyEntity(entityId);
  }
  else {
    ComponentModel::Entity* parent = context->store->getEntityPtr(parentId);
    ComponentModel::Entity* entity = context->store->getEntityPtr(entityId);
    if (entity && parent) {
      context->store->removeChild(parent, entity);
    }
  }
 
  state->setSelection(previousSelection);
}
 
// --------
 
void Cogs::Core::PasteEntityCommand::apply()
{
  ComponentModel::Entity * parent = state->getSelected();
 
  previousSelection = state->selected;
 
  Value object;
  object.CopyFrom(state->copied, state->copied.GetAllocator());
 
  // The following is based on Cogs::Core::readScene() from SceneReader.cpp
 
  AssetDefinition asset;
  SceneDefinition& scene = asset.scene;
  readSceneDefinition(context, object, AssetLoadFlags::None, asset);
  std::vector<ComponentModel::Entity*> entities(scene.entities.size());
  EntityIds ids;
  ids.reserve(scene.entities.size());
 
  for (SceneEntityDefinition& definition : scene.entities) {
    ComponentModel::Entity* parentEntity = definition.isParentedByName() ? nullptr :
      (definition.parentIndex == SceneEntityDefinition::NoIndex ? parent : entities[definition.parentIndex]);
 
    entities[definition.index] = createEntity(context, scene, definition, parentEntity);
 
    ids.push_back(entities[definition.index]->getId());
  }
 
  RemoveEntitiesWithAncestors(context, ids, entityIds);
  state->setSelection(entityIds);
}
 
void Cogs::Core::PasteEntityCommand::undo()
{
  for (const EntityId entityId : entityIds) {
    const ComponentModel::Entity* entity = context->store->getEntityPtr(entityId);
    ComponentModel::Entity* parent = entity ? context->store->getEntityParent(entity) : nullptr;
    if (parent && entity) {
      context->store->removeChild(parent, entity);
    }
    else {
      context->store->destroyEntity(entityId);
    }
  }
 
  state->setSelection(previousSelection);
}
 
// --------
 
void Cogs::Core::SelectCommand::apply()
{
  previousSelection = state->selected;
  state->scrolled = false;
 
  if (selectedIds.size() && selectedIds[0] == NoEntity) {
    selectedIds.clear();
  }
 
  if (mode == SelectMode::Exclusive) {
    state->pickId = pickId;
    state->setSelection(selectedIds);
  }
  else if (mode == SelectMode::Add) {
    EntityIds newSelection = state->selected;
    for (const EntityId id : selectedIds) {
      const bool found = std::find(previousSelection.begin(), previousSelection.end(), id) != previousSelection.end();
      if (!found) {
        newSelection.push_back(id);
      }
    }
    state->pickId = pickId;
    state->setSelection(newSelection);
  }
  else if (mode == SelectMode::Toggle) {
    EntityIds newSelection = state->selected;
    for (const EntityId id : selectedIds) {
      const bool found = std::find(previousSelection.begin(), previousSelection.end(), id) != previousSelection.end();
      if (!found) {
        newSelection.push_back(id);
        if (selectedIds.size() == 1) {
          state->pickId = pickId;
        }
      }
      else {
        auto end = std::remove(newSelection.begin(), newSelection.end(), id);
        if (end != newSelection.end()) {
          newSelection.erase(end, newSelection.end());
        }
      }
    }
 
    state->setSelection(newSelection);
  }
}
 
void Cogs::Core::SelectCommand::undo()
{
  state->setSelection(previousSelection);
}
 
// --------
 
void Cogs::Core::AddComponentCommand::apply()
{
  ComponentModel::Entity* entity = context->store->getEntityPtr(entityId);
 
  context->store->addComponent(entity, type);
}
 
void Cogs::Core::AddComponentCommand::undo()
{
  ComponentModel::Entity* entity = context->store->getEntityPtr(entityId);
 
  const Reflection::Type & componentType = Reflection::TypeDatabase::getType(type);
 
  ComponentModel::ComponentHandle handle = entity->getComponentHandle(componentType);
 
  context->store->removeComponent(entity, handle);
}
 
// --------
 
void Cogs::Core::ChangeEditingModeCommand::apply()
{
  previousMode = state->mode;
  state->mode = newMode;
}
 
void Cogs::Core::ChangeEditingModeCommand::undo()
{
  state->mode = previousMode;
}
 
// --------
 
void Cogs::Core::TranslateCommand::apply()
{
  for (size_t i = 0; i < state->selected.size(); ++i) {
    auto entity = context->store->getEntityPtr(entityIds[i]);
    auto transformComponent = entity->getComponent<TransformComponent>();
 
    transformComponent->position = state->startTranslations[i] + translation;
    transformComponent->setChanged();
  }
 
  previousTranslations = state->startTranslations;
}
 
void Cogs::Core::TranslateCommand::undo()
{
  for (size_t i = 0; i < state->selected.size(); ++i) {
    auto entity = context->store->getEntityPtr(entityIds[i]);
    auto transformComponent = entity->getComponent<TransformComponent>();
 
    transformComponent->position = previousTranslations[i];
    transformComponent->setChanged();
  }
}
 
// --------
 
bool Cogs::Core::TranslateCommand::mergeWith(const EditorCommand * command)
{
  const TranslateCommand* translateCommand = dynamic_cast<const TranslateCommand *>(command);
  
  if (!translateCommand) return false;
  if (entityIds != translateCommand->entityIds) return false;
 
  translation = translateCommand->translation;
 
  return true;
}
 
// --------
 
void Cogs::Core::RotateCommand::apply()
{
  for (size_t i = 0; i < state->selected.size(); ++i) {
    auto entity = context->store->getEntityPtr(entityIds[i]);
    auto transformComponent = entity->getComponent<TransformComponent>();
 
    transformComponent->rotation = rotation * state->startRotations[i];
    transformComponent->setChanged();
  }
 
  previousRotations = state->startRotations;
}
 
void Cogs::Core::RotateCommand::undo()
{
  for (size_t i = 0; i < state->selected.size(); ++i) {
    auto entity = context->store->getEntityPtr(entityIds[i]);
    auto transformComponent = entity->getComponent<TransformComponent>();
 
    transformComponent->rotation = previousRotations[i];
    transformComponent->setChanged();
  }
}
 
bool Cogs::Core::RotateCommand::mergeWith(const EditorCommand * command)
{
  const RotateCommand* rotateCommand = dynamic_cast<const RotateCommand *>(command);
 
  if (!rotateCommand) return false;
  if (entityIds != rotateCommand->entityIds) return false;
 
  rotation = rotateCommand->rotation;
  return true;
}
 
// --------
 
void Cogs::Core::ScaleCommand::apply()
{
  for (size_t i = 0; i < state->selected.size(); ++i) {
    auto entity = context->store->getEntityPtr(entityIds[i]);
    auto transformComponent = entity->getComponent<TransformComponent>();
 
    transformComponent->scale = state->startScales[i] + scale;
    transformComponent->setChanged();
  }
 
  previousScales = state->startScales;
}
 
void Cogs::Core::ScaleCommand::undo()
{
  for (size_t i = 0; i < state->selected.size(); ++i) {
    auto entity = context->store->getEntityPtr(entityIds[i]);
    auto transformComponent = entity->getComponent<TransformComponent>();
 
    transformComponent->scale = previousScales[i];
    transformComponent->setChanged();
  }
}
 
bool Cogs::Core::ScaleCommand::mergeWith(const EditorCommand* command)
{
  const ScaleCommand* scaleCommand = dynamic_cast<const ScaleCommand*>(command);
 
  if (!scaleCommand) return false;
  if (entityIds != scaleCommand->entityIds) return false;
 
  scale = scaleCommand->scale;
  return true;
}
 
// --------
 
void Cogs::Core::ScaleToUnitCubeCommand::apply()
{
  const Cogs::Logging::Log logger = Cogs::Logging::getLogger("ScaleToUnitCubeCommand");
 
  Geometry::DBoundingBox bb;
  ::calculateBoundingBoxWorld(context, entityId, bb.data());
  LOG_DEBUG(logger, "Original bounds: [%.2f %.2f %.2f] x [%.2f %.2f %.2f]",
            bb.min.x, bb.min.y, bb.min.z,
            bb.max.x, bb.max.y, bb.max.z);
 
  double scale = 1.0;
  if (!isEmpty(bb) && bb.min.x < bb.max.x) {
    const glm::dvec3 extent = bb.max - bb.min;
    scale = 2.0 / std::max(std::max(extent.x, extent.y), extent.z);
  }
  LOG_DEBUG(logger, "Scale: %e", scale);
 
  if (ComponentModel::Entity* entity = context->store->getEntityPtr(entityId)) {
    if (TransformComponent* trComp = entity->getComponent<TransformComponent>()) {
      previousScale = trComp->scale;
      trComp->scale = glm::vec3(float(scale)) * trComp->scale;
 
      previousPosition = trComp->position;
      trComp->position = trComp->position - glm::vec3(scale * bb.min) - glm::vec3(1.f);
 
      trComp->setChanged();
    }
  }
}
 
void Cogs::Core::ScaleToUnitCubeCommand::undo()
{
  if (ComponentModel::Entity* entity = context->store->getEntityPtr(entityId)) {
    if (TransformComponent* trComp = entity->getComponent<TransformComponent>()) {
      trComp->scale = previousScale;
      trComp->position = previousPosition;
      trComp->setChanged();
    }
  }
}
 
// --------
 
void Cogs::Core::DestroyCommand::apply()
{
  if (allowUndo) {
    Document d;
    d.SetArray();
    const AssetWriteFlags writeFlags = AssetWriteFlags::Geometry | AssetWriteFlags::Hierarchy;
 
    for (const EntityId s : entityIds) {
      Value entityValue;
      entityValue.SetObject();
 
      writeEntity(context, context->store->getEntityPtr(s), entityValue, d, nullptr, writeFlags);
 
      d.PushBack(entityValue, d.GetAllocator());
    }
 
    copied = std::move(d);
  }
 
  if (allowUndo) {
    parentIds.reserve(entityIds.size());
  }
  for (const EntityId entityId : entityIds) {
    EntityId parentId = NoEntity;
    const ComponentModel::Entity* entity = context->store->getEntityPtr(entityId);
    ComponentModel::Entity* parent = entity ? context->store->getEntityParent(entity) : nullptr;
    if (parent && entity) {
      context->store->removeChild(parent, entity);
      parentId = parent->getId();
    }
    else {
      context->store->destroyEntity(entityId);
    }
 
    if (allowUndo) {
      parentIds.emplace_back(parentId);
    }
  }
 
  state->clearSelection();
  state->mode = EditingMode::Select;
}
 
void Cogs::Core::DestroyCommand::undo()
{
  if (!allowUndo) {
    return;
  }
 
  // This is similar to PasteEntityCommand::apply()
  // But here we have to pay attention to parent Entities from the deleted list
 
  Value object;
  object.CopyFrom(copied, copied.GetAllocator());
 
  AssetDefinition asset;
  SceneDefinition& scene = asset.scene;
  readSceneDefinition(context, object, AssetLoadFlags::None, asset);
  std::vector<ComponentModel::Entity*> entities(scene.entities.size());
  EntityIds ids;
  ids.reserve(scene.entities.size());
 
  size_t entityNo = 0;  // count Entities from the original deletion list
  for (SceneEntityDefinition& definition : scene.entities) {
    ComponentModel::Entity* parentEntity = nullptr;
    if (!definition.isParentedByName()) {
      if (definition.parentIndex == SceneEntityDefinition::NoIndex) {
        // Entities without parentIndex are from the original delete list
        assert(entityNo < parentIds.size());
        parentEntity = (entityNo < parentIds.size() && parentIds[entityNo] != NoEntity) ?
          context->store->getEntityPtr(parentIds[entityNo]) : nullptr;
        entityNo++;
      }
      else {
        parentEntity = entities[definition.parentIndex];
      }
    }
 
    entities[definition.index] = createEntity(context, scene, definition, parentEntity);
 
    ids.push_back(entities[definition.index]->getId());
  }
 
  RemoveEntitiesWithAncestors(context, ids, ids);
  state->setSelection(ids);
}
 
void Cogs::Core::GroupCommand::apply()
{
  EntityPtr group = context->store->createEntity("Group", "Group");
 
  groupId = group->getId();
  ComponentModel::Entity* groupEntity = context->store->getEntityPtr(groupId);
 
  for (const EntityId childId : entityIds) {
    EntityPtr childEntity = context->store->getEntity(childId);
    if(childEntity)
      context->store->addChild(groupEntity, childEntity);
  }
 
  state->setSelection(groupId);
}
 
void Cogs::Core::GroupCommand::undo()
{
  for (const EntityId id : entityIds) {
    context->store->removeChild(context->store->getEntityPtr(groupId), context->store->getEntityPtr(id));
  }
 
  context->store->destroyEntity(groupId);
 
  state->setSelection(entityIds);
}
 
 
void Cogs::Core::RemoveEntitiesWithAncestors(Context* context, const EntityIds& entityIds, EntityIds& output)
{
  EntityIds ids;
  ids.reserve(entityIds.size());
  for (const EntityId id : entityIds) {
    if (const ComponentModel::Entity* entity = context->store->getEntityPtr(id);  entity) {
      while ((entity = context->store->getEntityParent(entity)) != nullptr) {
        EntityId parentId = entity->getId();
        if (std::find(entityIds.begin(), entityIds.end(), parentId) != entityIds.end()) {
          break;
        }
      }
      if (!entity) {
        ids.push_back(id);
      }
    }
  }
 
  output = std::move(ids);
}