EditorState.h

#pragma once
 
#include "Base.h"
#include "Context.h"
#include "EntityStore.h"
 
#include "Resources/Resources.h"
#include "Serialization/EntityWriter.h"
 
#include "Foundation/ComponentModel/Entity.h"
 
#include <string>
#include <vector>
#include <array>
#include <regex>
#include <span>
#include <unordered_map>
 
namespace Cogs::Core
{
  using EntityIds = std::vector<EntityId>;
 
  enum class EditingMode
  {
    None = 0,
    Select,
    Translate,
    Rotate,
    Scale
  };
 
  enum class EditingPivot
  {
    ObjectPivot = 0,
    ObjectCenter,
    GroupCenter,
    Default = ObjectCenter,
  };
 
  class ICommandState {
  public:
    virtual ~ICommandState() = default;
  };
 
  struct LastPickState {
    EntityId rootId = NoEntity;
 
    std::string details;
 
    std::string pickId;
 
    std::string assetRootGroupName;
 
    // Formatted bounding Box
    std::string boundingBox;
 
    void clear() {
      rootId = NoEntity;
      details.clear();
      pickId.clear();
      assetRootGroupName.clear();
      boundingBox.clear();
    }
  };
 
  struct EditorState
  {
    EditingMode mode = EditingMode::Select;
    EditingPivot pivot = EditingPivot::Default;
 
    class Editor * editor = nullptr;
    class Context * context = nullptr;
 
    WeakEntityPtr editorCamera;
 
    std::string fileName;
    std::string directory;
 
    LastPickState lastPickState;
    EntityIds selected;
    int pickId = -1;
    bool scrolled = false;
 
    bool findEntities = false;
    size_t findOffset = 0;
 
    bool showSettings = false;
 
    void setSelection(const EntityIds& ids) {
      selected = ids;
      if (ids.size() != 1) this->pickId = -1;
      updateSelectedInfo();
    }
 
    void setSelection(EntityId id) {
      selected = { id };
      updateSelectedInfo();
    }
 
    void clearSelection() {
      selected.clear();
      updateSelectedInfo();
      // lastPickState.clear();
    }
 
    void updateSelectedInfo();
 
    size_t numSelected() const { return selected.size(); }
 
    bool hasSelected() const { return !selected.empty(); }
 
    bool isSelected(EntityId entityId) const {
      for (auto & id : selected) { if (id == entityId) return true; }
      return false;
    }
 
    EntityId getSelectedId() const { return numSelected() == 1U ? selected.back() : NoEntity; }
 
    ComponentModel::Entity * getSelected() const { return getSelectedId() != NoEntity ? context->store->getEntityPtr(getSelectedId()) : nullptr; }
 
    std::span<const EntityId> getAllSelectedIds() const { return this->selected; }
 
    void setFindPattern(const std::string& pattern)
    {
      findPattern = pattern;
      try {
        findRegex = pattern;
        validRegex = true;
      }
      catch (std::regex_error) {
        findRegex = std::string();
        validRegex = false;
      }
    }
 
    const std::string& getFindPattern() const { return findPattern; }
    const std::regex& getFindRegex() const { return findRegex; }
    bool isFindRegexValid() const { return validRegex; }
 
 
    std::string eraseInvalidSelected() {
      std::string erasedSelections;
      for (size_t i = selected.size(); i > 0; --i) {
        const size_t index = i - 1u;
        if (!context->store->getEntityPtr(selected[index])) {
          erasedSelections += ' ' + std::to_string(selected[index]);
          selected.erase(selected.begin() + index);
        }
      }
 
      if (!erasedSelections.empty()) {
        updateSelectedInfo();
      }
 
      return erasedSelections;
    }
 
    std::vector<ComponentModel::Entity *> selectedPath;
 
    std::unordered_map<int, TextureHandle> icons;
 
    glm::vec3 startTranslation = glm::vec3(0);
    glm::vec3 endTranslation = glm::vec3(0);
 
    glm::quat startRotation;
    glm::quat endRotation;
 
    glm::vec3 startScale;
    glm::vec3 endScale;
 
    std::vector<glm::vec3> startTranslations;
    std::vector<glm::quat> startRotations;
    std::vector<glm::vec3> startScales;
 
    glm::vec3 startMin;
    glm::vec3 startMax;
 
    bool wasUsingGizmo = false;
 
    bool lButtonDown = false;
 
    int downX = 0;
    int downY = 0;
 
    rapidjson::Document copied;
 
    float translateSnap = 0.1f;
    float rotateSnap = 1.0f;
    float scaleSnap = 0.1f;
 
    std::vector<std::shared_ptr<ICommandState>> commandStates;
    private:
      std::string findPattern;
      std::regex findRegex;
      bool validRegex = true;
  };
}