EditorCommand.h

#pragma once
 
#include "../EditorExtension.h"
#include "../EditorState.h"
 
#include "Editor/EditorCommand.h"
 
#include "Utilities/Parsing.h"
 
#include "CommandParseHelpers.h"
 
#include "Serialization/JsonParser.h"
 
#include "Services/PropertiesManager.h"
 
#include <vector>
 
namespace Cogs::Core
{
  class Context;
  class MeshComponent;
 
  // Remove children from entityIds if any ancestor is in the list as well
  void RemoveEntitiesWithAncestors(Context* context, const EntityIds& entityIds, EntityIds& output);
 
  struct COGSCORE_EDITOR_API PostCommand : public EditorCommand
  {
    explicit PostCommand(EditorState * state) : EditorCommand(state, state->context) {}
    // Must have destructor as having DLL interface.
    ~PostCommand() override;
 
    virtual void applyPost() = 0;
 
    PropertyStore properties;
  };
 
  struct ModalEditorCommand : public EditorCommand
  {
    ModalEditorCommand(EditorState * state) : EditorCommand(state, state->context) {}
 
    virtual void beginModal() = 0;
 
    virtual void showGui() = 0;
 
    virtual bool continueModal() = 0;
  };
 
  struct ChangeEditingModeCommand : public EditorCommand
  {
    ChangeEditingModeCommand(EditorState * state, EditingMode newMode) : EditorCommand(state, state->context), newMode(newMode) {}
 
    void apply() override;
    void undo() override;
 
  private:
    EditingMode newMode = EditingMode::None;
    EditingMode previousMode = EditingMode::None;
  };
 
  struct COGSCORE_EDITOR_API CreateEntityCommand : public EditorCommand
  {
    CreateEntityCommand(EditorState* state, const StringView& type, const StringView& name, bool openInRoot);
 
    void apply() override;
    void undo() override;
 
  private:
    std::string type;
    std::string name;
    bool openInRoot;
 
    EntityId entityId = NoEntity;
    EntityId parentId = NoEntity;
 
    EntityIds previousSelection;
  };
 
  struct PasteEntityCommand : public EditorCommand
  {
    PasteEntityCommand(EditorState * state) : EditorCommand(state, state->context) {}
 
    void apply() override;
    void undo() override;
 
  private:
    EntityIds entityIds;
    
    EntityIds previousSelection;
  };
 
  struct DestroyCommand : public EditorCommand
  {
    DestroyCommand(EditorState * state, const EntityIds& entityIds, bool allowUndo) : EditorCommand(state, state->context), allowUndo(allowUndo) 
    {
      RemoveEntitiesWithAncestors(context, entityIds, this->entityIds);
    }
 
    void apply() override;
    void undo() override;
 
  private:
    bool allowUndo;
    EntityIds entityIds;
    EntityIds parentIds;
    rapidjson::Document copied;
  };
 
  class COGSCORE_EDITOR_API SelectCommand : public EditorCommand
  {
  public:
    SelectCommand(EditorState * state, const EntityIds& selectedIds, SelectMode mode = SelectMode::Exclusive, int pickId = -1)
      : EditorCommand(state, state->context), pickId(pickId), selectedIds(selectedIds), mode(mode)
    {
    }
 
    SelectCommand(EditorState * state, const EntityId& selectedId, SelectMode mode = SelectMode::Exclusive, int pickId = -1)
      : SelectCommand(state, EntityIds{ selectedId }, mode, pickId)
    {
    }
 
    void apply() override;
    void undo() override;
 
    int pickId = -1;
  private:
    EntityIds selectedIds;
    SelectMode mode = SelectMode::Exclusive;
 
    EntityIds previousSelection;
  };
 
  struct AddComponentCommand : public EditorCommand
  {
    AddComponentCommand(EditorState * state, EntityId entityId, const StringView & type) : EditorCommand(state, state->context), entityId(entityId), type(type.to_string()) {}
 
    void apply() override;
    void undo() override;
 
  private:
    EntityId entityId = NoEntity;
    std::string type;
  };
 
  struct TranslateCommand : public EditorCommand
  {
    TranslateCommand(EditorState * state, const EntityIds& entityIds, glm::vec3 translation) : EditorCommand(state, state->context), entityIds(entityIds), translation(translation) {}
 
    void apply() override;
    void undo() override;
 
    bool mergeWith(const EditorCommand * command) override;
 
  private:
    EntityIds entityIds;
    glm::vec3 translation;
 
    std::vector<glm::vec3> previousTranslations;
  };
 
  struct RotateCommand : public EditorCommand
  {
    RotateCommand(EditorState * state, const EntityIds& entityIds, glm::quat rotation) : EditorCommand(state, state->context), entityIds(entityIds), rotation(rotation) {}
 
    void apply() override;
    void undo() override;
 
    bool mergeWith(const EditorCommand * command) override;
 
  private:
    EntityIds entityIds;
    glm::quat rotation;
 
    std::vector<glm::quat> previousRotations;
  };
 
  struct ScaleCommand : public EditorCommand
  {
    ScaleCommand(EditorState * state, const EntityIds& entityIds, glm::vec3 scale) : EditorCommand(state, state->context), entityIds(entityIds), scale(scale) {}
 
    void apply() override;
    void undo() override;
 
    bool mergeWith(const EditorCommand * command) override;
 
  private:
    EntityIds entityIds;
    glm::vec3 scale;
 
    std::vector<glm::vec3> previousScales;
  };
 
  struct ScaleToUnitCubeCommand : public EditorCommand
  {
    ScaleToUnitCubeCommand(EditorState* state, EntityId entityId) : EditorCommand(state, state->context), entityId(entityId) {}
 
    void apply() override;
    void undo() override;
 
  private:
    EntityId entityId;
 
    glm::vec3 previousScale;
    glm::vec3 previousPosition;
  };
 
  struct GroupCommand : public EditorCommand
  {
    GroupCommand(EditorState * state, const EntityIds& entityIds) : EditorCommand(state, state->context)
    {
      RemoveEntitiesWithAncestors(context, entityIds, this->entityIds);
    }
 
    void apply() override;
    void undo() override;
 
  private:
    EntityIds entityIds;
    EntityId groupId = NoEntity;
  };
}