Editor.h

#pragma once
 
#include "Editor/IEditor.h"
#include "EventBasedInput.h"
 
#include "EditorExtension.h"
 
#include "Commands/EditorCommand.h"
#include "Foundation/Geometry/BoundingBox.hpp"
 
#include <memory>
#include <functional>
#include <vector>
 
namespace Cogs::ComponentModel
{
  class Entity;
}
 
namespace Cogs::Core
{
  class Context;
  struct FieldInfo;
 
  using CommandCreator = std::function<EditorCommand* (EditorState*)>;
 
  struct ExtensionCommand
  {
    std::string key;
    CommandCreator creator;
  };
 
  struct ExtensionItem
  {
    std::string name;
    std::string key;
  };
 
 
  enum class Icon
  {
    None = 0,
    New,
    Open,
    Save,
 
    Undo,
    Redo,
 
    Select,
    Move,
    Rotate,
    Scale,
 
    Plus,
    Minus,
    Info,
    Gears,
 
    Eye,
 
    Solid,
    Wireframe,
    BoundingBox,
 
    PivotLocal,
    PivotCenter,
 
    Hide,
    HideUnselected,
    ShowAll,
    SelectFurthestAway,
    IconInvertVisibility
  };
 
  class Editor : public IEditor
  {
  public:
    explicit Editor(Context * context);
    ~Editor() override;
 
    static void COGSCORE_EDITOR_API registerExtensionCommand(const StringView & key, CommandCreator creator);
    static COGSCORE_EDITOR_API std::vector<ExtensionCommand> & getExtensionCommands();
 
    static void COGSCORE_EDITOR_API registerExtensionItem(const StringView & key, const StringView & name);
    static COGSCORE_EDITOR_API std::vector<ExtensionItem> & getExtensionItems();
 
    void initialize() override;
    void cleanup() override;
 
    void show() override;
    void processShortcuts();
 
    void beginFrame() override;
 
    bool isActive() const override { return active; }
 
    EditorState * getState() override;
 
    void showText(const char* format, ...) const;
    bool showModel(ModelHandle & modelHandle);
    bool showTexture(const StringView & header, TextureHandle & textureHandle) override;
    bool showMaterialInstance(FieldInfo & fieldInfo, MaterialInstanceHandle & materialInstanceHandle);
 
    bool imageButton(Icon icon, int size, int padding);
 
    void clear(bool interactive=true) override;
 
    void open(const StringView & path, bool openInRoot, bool synchronous) override;
    void save() override;
    void saveAs() override;
    void saveIncremental() override;
 
    void importStatic();
    void exportEntities(bool exportScene = false);
 
    void cut() override;
    void copy() override;
    void paste() override;
 
    void invokeCommand(const StringView & key) override;
 
    void destroy() override;
    void destroyPermanently();
 
    void changeMode(EditingMode mode);
    void focusSelected();
    void focusAll();
    bool focusBoundingBox(const Cogs::Geometry::DBoundingBox& boundingBox);
 
    void setStatusbarText(const std::string& text, bool guiStatus);
 
    void showHide(bool visible);
 
    void hideUnselected();
 
    void showAll();
 
    void selectFurthestAway();
 
    void invertVisibility();
 
    void selectAll();
    void selectOne(EntityId id);
 
    void clearCommands();
 
    void onlineHelp(bool generalHelp);
 
    void showLicenses();
    void showAbout();
 
    EditorCommand * doApply(std::unique_ptr<EditorCommand>&& newCommand)
    {
      modalCommand = dynamic_cast<ModalEditorCommand*>(newCommand.get());
      if (modalCommand) {
        modalCommand->beginModal();
      }
      else {
        newCommand->apply();
        if (commands.size() && commands.back()->merge(newCommand.get())) {
          return commands.back().get();
        }
      }
 
      commands.resize(commandIndex + 1);
      commands.emplace_back(std::move(newCommand));
      ++commandIndex;
 
      return commands.back().get();
    }
 
 
    template<typename Command, typename... Args>
    Command * apply(Args... args)
    {
      assert(modalCommand == nullptr);
      auto newCommand = std::make_unique<Command>(state.get(), std::move(args)...);
      return (Command*)doApply(std::move(newCommand));
    }
 
    template<typename Command, typename... Args>
    Command * applySelected(Args... args)
    {
      return apply<Command, EntityIds, Args...>(state->selected, std::move(args)...);
    }
 
    void undo();
    void redo();
 
  private:
    void handleMouseEvent(const struct Cogs::Core::InputEvent& event);
    void showEntities();
    void showEntityDetails(ComponentModel::Entity * entity);
    void showGizmo();
    void selectLayer(ComponentModel::Entity* entity, StringView layer);
    void setLayerVisibility(ComponentModel::Entity* entity, StringView layer, bool visible);
 
    bool getLayerVisibility(const ComponentModel::Entity* entity, StringView layer);
 
    bool isStandardEntity(const Cogs::ComponentModel::Entity* entity) const;
 
    bool isUserRootEntity(const Cogs::ComponentModel::Entity* entity) const;
 
    // If not interactive, don't present user with open dialogs or options
    void openInternal(const StringView& path, bool openInRoot, bool synchronous, bool interactive);
 
  private:
    Context * context;
 
    std::unique_ptr<struct EditorState> state;
 
    ModalEditorCommand* modalCommand = nullptr;
 
    std::vector<std::unique_ptr<EditorCommand>> commands;
    static constexpr size_t NoCommand = static_cast<size_t>(-1);
    size_t commandIndex = NoCommand;
 
    std::unique_ptr<class MaterialEditor> materialEditor;
 
    std::vector<Cogs::Core::WeakEntityPtr> standardEntities;
 
    mutable int textElementId = 0;
 
    bool initialized = false;
    bool active = false;
 
    float minWidth = 50;
    float sidebarWidth = 200;
    float inspectorWidth = 250;
    float menuHeight = 20;
    float toolbarHeight = 40;
    glm::vec2 buttonSize = glm::vec2{ 24 };
 
    float statusbarHeight = 20;
    bool showStatusbar = true;
    std::string statusbarText;
    bool guiStatusInStatusbar = true;
  
    bool showToolbar = true;
    bool showSidebar = true;
    bool showInspector = true;
    bool showMenu = true;
 
  private:
    const std::string& getStatusbarText() const { return statusbarText; }
    bool showingGuiStatusbarText() const { return guiStatusInStatusbar; }
    float getStatusbarHeight() const { return showStatusbar ? statusbarHeight : 0.0f; }
    float getToolbarHeight() const { return showToolbar ? toolbarHeight : 0.0f; }
    float getSidebarWidth() const { return showSidebar ? sidebarWidth : 0.0f; }
    float getInspectorWidth() const { return showInspector ? inspectorWidth : 0.0f; }
    float getMenuHeight() const { return showMenu ? menuHeight : 0.0f; }
 
    virtual void exportScene(const StringView & path) override;
    virtual EntityIds getSelected() const override;
    virtual void select(const EntityIds & ids, SelectMode mode = SelectMode::Exclusive) override;
    virtual EditorCommand * createCommand(const StringView & key) override;
    virtual void createEntity(const StringView & type, const StringView & name) override;
};
}