Editor.cpp

#include "Editor.h"
 
#include "EditorState.h"
 
#include "imgui.h"
#include "ImGuizmo.h"
 
#include "../../../Cogs.Desktop/Source/ModalDialogs.h"
 
#include "Context.h"
#include "ViewContext.h"
#include "Engine.h"
#include "EntityStore.h"
#include "Scene.h"
#include "ExtensionRegistry.h"
 
#include "Renderer/Renderer.h"
 
#include "Renderer/InspectorGui/InspectorGuiRenderer.h"
#include "Renderer/InspectorGui/InspectorGuiHelper.h"
 
#include "Components/Core/AssetComponent.h"
#include "Components/Core/SceneComponent.h"
#include "Components/Core/TransformComponent.h"
#include "Components/Core/ModelComponent.h"
#include "Components/Core/StaticModelComponent.h"
#include "Components/Core/PropertiesComponent.h"
 
#include "Components/Behavior/OrbitingCameraController.h"
#include "../Extensions/Potree/Source/PotreeComponent.h"
#include "../Extensions/Image360/Source/Image360Component.h"
 
#include "Utilities/CameraHelper.h"
#include "Utilities/CameraUtils.h"
 
#include "Resources/AssetManager.h"
#include "Resources/ModelManager.h"
#include "Resources/TextureManager.h"
#include "Resources/MaterialManager.h"
#include "Resources/Model.h"
#include "Resources/ResourceStore.h"
 
#include "Systems/Core/CameraSystem.h"
#include "Systems/Core/ModelSystem.h"
#include "Systems/Core/TransformSystem.h"
 
#include "Services/DPIService.h"
 
#include "Scene/RayPick.h"
#include "Scene/GetBounds.h"
 
#include "Input/InputManager.h"
#include "Input/KeyboardMapping.h"
 
#include "Renderer/RenderTexture.h"
#include "Renderer/InspectorGui/Inspectors.h"
 
#include "EntityEditor.h"
#include "MaterialEditor.h"
 
#include "Serialization/ModelWriter.h"
#include "Serialization/ModelLoader.h"
 
#include "Bridge/Bridge.h"
#include "Bridge/RenderFunctions.h"
#include "Bridge/ResourceFunctions.h"
#include "Bridge/SceneFunctions.h"
 
 
#include "Commands/ResourceCommands.h"
#include "Commands/MergeCommand.h"
#include "Commands/DumpStatsCommand.h"
#include "Commands/ExportCommand.h"
#include "Commands/ExportGltfCommand.h"
#include "Commands/MeshOpCommands.h"
#include "Commands/PackMeshCommand.h"
#include "Commands/LoadRvmCommand.h"
#include "Commands/ShowLicensesCommand.h"
#include "Commands/AboutCommand.h"
 
#include "Batch.h"
 
#include "Foundation/Logging/Logger.h"
#include "Foundation/Platform/Mouse.h"
#include "Foundation/Platform/Keyboard.h"
#include "Foundation/Platform/IO.h"
 
#include <algorithm>
#include <array>
#include <cctype>
#include <set>
#include <unordered_set>
 
// To stop warnings like
// ../Extensions/Editor/Source/Editor.cpp:2686:3: warning: unused function 'operator~' [-Wunused-function]
#if defined(__clang__)
#pragma clang diagnostic ignored "-Wunused-function"
#endif
 
using namespace Cogs::Geometry;
 
namespace
{
  const Cogs::Logging::Log logger = Cogs::Logging::getLogger("Editor");
  Cogs::Core::EventBasedInput eventBasedInput;
}
 
namespace
{
  struct CameraSetupData {
    glm::dvec3 position;
    glm::quat rotation;
  };
 
  [[nodiscard]] Cogs::Core::EntityPtr getEditorCamera(const Cogs::Core::Context* context)
  {
    Cogs::Core::EntityPtr cameraEntity = context->store->findEntity("EditorCamera");
    if (!cameraEntity) {
      // Check for 'Camera'. Reading Scenes with clear can leave only saved Camera (normal name for Camera).
      cameraEntity = context->store->findEntity("Camera");
    }
 
    // Auto-update ViewContext camera if changed.
    // Check that really a Camera.
    if (cameraEntity && cameraEntity != context->getDefaultView()->getCamera()) {
      if (cameraEntity->getComponent<Cogs::Core::SceneComponent>()) {
        context->getDefaultView()->setCamera(cameraEntity);
      }
      else {
        cameraEntity = nullptr;
        LOG_ERROR(logger, "Detected Camera without CameraComponent: %s", cameraEntity->getName().c_str());
      }
    }
 
    if (!cameraEntity) {
      LOG_FATAL(logger, "Crashing: Missing editor camera (Name: 'EditorCamera' or 'Camera') in scene");
      abort();
    }
 
    return cameraEntity;
  }
 
  void utilSetRenderMode(Cogs::Core::Context* context, Cogs::Core::RenderMode mode)
  {
    ::setRenderMode(context, static_cast<int>(mode));
  }
 
  std::string toLower(const std::string & input)
  {
    std::string lowerCase;
    lowerCase.resize(input.size());
    std::transform(input.begin(), input.end(), lowerCase.begin(), [](const auto x) { return static_cast<char>(std::tolower(x)); });
 
    return lowerCase;
  }
 
  bool is3dModelFileFormat(const std::string & extension)
  {
    const std::string ext = toLower(extension);
    return ext == ".obj" || ext == ".3ds" || ext == ".fbx" || ext == ".dae" ||
      ext == ".cogsbin" ||
      ext == ".dxf" ||
      ext == ".rvm" ||
      ext == ".rvmdump" ||
      ext == ".vue" ||
      ext == ".gltf" ||
      ext == ".glb" ||
      ext == ".stp" ||
      ext == ".ogex" || ext == ".iv" || ext == ".wrl";
  }
 
  template<typename T>
  void setIfNotSet(Cogs::Core::Context* context, const Cogs::StringView& key, const T& value)
  {
    if (!context->variables->exist(key)) {
      context->variables->set(key, value);
    }
  }
 
  template<class Matcher>
  void recurseEntity(const Cogs::ComponentModel::Entity& entity, Matcher matcherFunc)
  {
    bool recurse = matcherFunc(entity);
    if (recurse) {
      const auto* sceneComponent = entity.getComponent<Cogs::Core::SceneComponent>();
      if (sceneComponent) {
        for (const auto& child : sceneComponent->children) {
          recurseEntity(*child, matcherFunc);
        }
      }
    }
  }
 
  void addAssetTags(Cogs::Core::Context* context, Entity* asset, const std::string& fileName)
  {
    const size_t extLength = (::toLower(fileName).find(".asset.zst") != std::string::npos) ? 10u : 6u;
    const std::string stem = fileName.substr(0, fileName.size() - extLength);
    const std::string tagsPath = stem + ".tags.txt";
 
    if (Cogs::IO::exists(tagsPath)) {
      auto content = Cogs::IO::readFileSync(tagsPath);
      if (content) {
        Cogs::StringView data(static_cast<const char*>(content->data()), content->size);
        const auto lines = data.split("\n");
 
        // Store each tag.
        Cogs::Core::PropertiesComponent* propsComponent = context->store->addComponent<Cogs::Core::PropertiesComponent>(asset);
        if (propsComponent) {
          size_t index = 0;
          for (Cogs::StringView line : lines) {
            // Ignore parent and children if tags with hierarchy.
            const size_t comma = line.find(",");
            if (comma != Cogs::StringView::NoPosition) {
              line = line.substr(0, comma);
            }
            propsComponent->properties.addProperty(std::to_string(index), line);
            index++;
          }
        }
        LOG_DEBUG(logger, "Read Asset tags. Count: %zd", lines.size());
      }
      else {
        LOG_ERROR(logger, "Reading Asset tags file failed: %s", tagsPath.c_str());
      }
    }
  }
 
  Cogs::ComponentModel::Entity* getRootEntity(Cogs::ComponentModel::Entity* entity,
                                              const Cogs::Core::Context* context,
                                              size_t level = 0)
  {
    assert(level <= 2);
    std::array<Cogs::ComponentModel::Entity*, 3> lastStack = { nullptr, nullptr, nullptr };
    while (entity) {
      lastStack[2] = lastStack[1];
      lastStack[1] = lastStack[0];
      lastStack[0] = entity;
      entity = context->store->getEntityParent(entity);
    }
 
    return lastStack[level];
  }
 
  void setVisibility(Cogs::Core::SceneComponent* sceneComponent, bool visible, bool recurse = false)
  {
    if (sceneComponent && sceneComponent->visible != visible) {
      sceneComponent->visible = visible;
      sceneComponent->setChanged();
    }
 
    if (sceneComponent && recurse) {
      for (const auto& child : sceneComponent->children) {
        auto childSceneComponent = child->getComponent<Cogs::Core::SceneComponent>();
        setVisibility(childSceneComponent, visible, recurse);
      }
    }
  }
 
  void setConsistentChildInvisibility(Cogs::ComponentModel::Entity* entity)
  {
    Cogs::Core::SceneComponent* sceneComponent = entity->getComponent<Cogs::Core::SceneComponent>();
    if (sceneComponent) {
      if (sceneComponent->visible == false) {
        setVisibility(sceneComponent, false, true);
      }
      else {
        for (const auto& child : sceneComponent->children) {
          setConsistentChildInvisibility(child.get());
        }
      }
    }
 
  }
 
  void recurseAddFindPatternMatches(const Cogs::ComponentModel::Entity& entity, const std::regex& findRegex, Cogs::Core::EntityIds& ids)
  {
    recurseEntity(entity, [&](const Cogs::ComponentModel::Entity& entity) {
      if (std::regex_search(entity.getName(), findRegex)) {
        ids.push_back(entity.getId());
        return false;
      }
      return true;
      });
  }
 
  void addChildrenIds(const Cogs::ComponentModel::Entity* entity,
                      std::unordered_set<size_t>& entityIds)
  {
    entityIds.insert(entity->getId());
    const auto* sceneComponent = entity->getComponent<Cogs::Core::SceneComponent>();
    if (sceneComponent) {
      for (const auto& child : sceneComponent->children) {
        addChildrenIds(child.get(), entityIds);
      }
    }
  }
 
  template<class T>
  bool recursiveSetVisibility(Cogs::ComponentModel::Entity* entity, T show)
  {
    bool anyChildVisible = false;
    auto sceneComponent = entity->getComponent<Cogs::Core::SceneComponent>();
    if (sceneComponent) {
      for (const auto& child : sceneComponent->children) {
        anyChildVisible = recursiveSetVisibility(child.get(), show) || anyChildVisible;
      }
    }
 
    // calculate visibility of node.
    bool visible = show(entity, anyChildVisible);
 
    if (sceneComponent && sceneComponent->visible != visible) {
      sceneComponent->visible = visible;
      sceneComponent->setChanged();
    }
 
    return visible;
  }
 
 
  template<class T>
  bool recursiveGetVisibility(const Cogs::ComponentModel::Entity* entity, T isVisible)
  {
    bool anyChildVisible = false;
    auto sceneComponent = entity->getComponent<Cogs::Core::SceneComponent>();
    if (sceneComponent) {
      for (const auto& child : sceneComponent->children) {
        anyChildVisible = recursiveGetVisibility(child.get(), isVisible);
        if (anyChildVisible) {
          break;
        }
      }
    }
 
    if (!anyChildVisible) {
      anyChildVisible = isVisible(entity);
    }
 
    return anyChildVisible;
  }
 
  void ensureEntityVisible(Cogs::Core::Context* context, Cogs::ComponentModel::Entity* entity)
  {
    auto sceneComponent = entity->getComponent<Cogs::Core::SceneComponent>();
    if (sceneComponent && !sceneComponent->visible) {
      sceneComponent->visible = true;
      sceneComponent->setChanged();
    }
 
    auto parent = context->store->getEntityParent(entity);
    if (parent) {
      ensureEntityVisible(context, parent);
    }
  }
 
  // Get all layers specified in the _rvmAllLayers property for the selected entity, after the following rules:
  // if the current entity has a PropertiesComponent:
  //   if it has the _rvmAllLayers property, parse and return the layers
  //   else if not, search an ancestor that has PropertiesComponent and _rvmAllLayers and return those layers
  //   otherwise return no layers
  // otherwise go through all children and find all that have a PropertiesComponent with the _rvmAllLayers property
  //   if any found, gather all layers and return
  //   otherwise return no layers
  std::set<Cogs::StringView> getAllLayers(Cogs::ComponentModel::Entity* entity) {
    if (entity == nullptr) return {};
 
    Cogs::Core::PropertiesComponent* propertiesComponent = entity->getComponent<Cogs::Core::PropertiesComponent>();
    if (propertiesComponent) {
      if (propertiesComponent->properties.hasProperty("_rvmAllLayers")) {
        Cogs::StringView::Vector allLayers = propertiesComponent->properties.getProperty("_rvmAllLayers", "").split("@");
        std::set<Cogs::StringView> allLayersStrs = {};
        for (Cogs::StringView layer : allLayers) {
          allLayersStrs.insert(layer);
        }
        return allLayersStrs;
      }
      // Current entity has a PropertiesComponent but doesn't have a _rvmAllLayers property.
      // Find the first parent that has and get the layers from it, or return no layers.
      else {
        Cogs::Core::SceneComponent* sceneComponent = entity->getComponent<Cogs::Core::SceneComponent>();
        if (sceneComponent) {
          if (Component* parent = sceneComponent->parent.resolve(); parent && parent->getComponent<Cogs::Core::PropertiesComponent>()) {
            return getAllLayers(parent->getContainer());
          }
        }
        return {};
      }
    }
    // Current entity doesn't have PropertiesComponent. Check the children and gather all layers from them, if any.
    else {
      Cogs::Core::SceneComponent* sceneComponent = entity->getComponent<Cogs::Core::SceneComponent>();
      if (!sceneComponent) return {};
 
      std::set<Cogs::StringView> allLayers = {};
      for (const Cogs::Core::EntityPtr& child : sceneComponent->children) {
        std::set<Cogs::StringView> layers = getAllLayers(child.get());
        allLayers.merge(layers);
      }
      return allLayers;
    }
  }
 
  size_t searchEntity(size_t numFound, Cogs::Core::Editor& editor, const Entity* entity)
  {
    const std::string& name = entity->getName();
    if (std::regex_search(name, editor.getState()->getFindRegex())) {
      if (numFound == editor.getState()->findOffset) {
        editor.selectOne(entity->getId());
        editor.setStatusbarText("Found: " + entity->getName() + " Index:" + std::to_string(editor.getState()->findOffset + 1), false);
        // editor.focusEntity();
        return numFound + 1u;
      }
 
      numFound++;
    }
 
    auto sceneComponent = entity->getComponent<Cogs::Core::SceneComponent>();
    if (sceneComponent) {
      for (auto& child : sceneComponent->children) {
        numFound = searchEntity(numFound, editor, child.get());
        if (numFound > editor.getState()->findOffset) {
          break;
        }
      }
    }
 
    return numFound;
 
  }
 
  CameraSetupData parseCameraPosition(Cogs::Core::Context* context, const std::string& path, bool fixCameraAlways, const Cogs::Core::EditorState* state)
  {
    bool fixCamera = fixCameraAlways;
    glm::dvec3 pos = { 0.0, 0.0, 0.0 };
    glm::quat orientation;
 
    FILE* scannerPos = std::fopen(path.c_str(), "r");
    if (scannerPos) {
      std::array<char, 256> line = {};
      std::fgets(line.data(), static_cast<int>(line.size()), scannerPos);
      if (std::sscanf(line.data(), "%lf, %lf, %lf", &pos.x, &pos.y, &pos.z) == 3) {
        fixCamera = true;
      }
      else if (std::sscanf(line.data(), "%lf %lf %lf", &pos.x, &pos.y, &pos.z) == 3) {
        fixCamera = true;
      }
      else {
        pos = { 0.0, 0.0, 0.0 };
      }
 
      // Read optional second line. Either Euler angles (3-values) or x,y,z,w.
      if (fixCamera) {
        line = {};
        std::fgets(line.data(), static_cast<int>(line.size()), scannerPos);
        glm::quat q;
        int nScan = std::sscanf(line.data(), "%f %f %f %f", &q.x, &q.y, &q.z, &q.w);
        if (nScan == 4) {
          orientation = q;
        }
        else if (nScan == 3) {
          orientation = glm::quat(glm::vec3(q.x, q.y, q.z));
        }
        else if (nScan != 0) {
          LOG_ERROR(logger, "Parsing error second line. Expected x y z, OR x y z w File: %s", path.c_str());
        }
      }
 
      std::fclose(scannerPos);
    }
 
    if (fixCamera) {
      Cogs::Core::OrbitingCameraController* orbitingCameraController = state->editorCamera.lock()->getComponent<Cogs::Core::OrbitingCameraController>();
      if (orbitingCameraController) {
        Cogs::Core::TransformComponent* transformComponent = state->editorCamera.lock()->getComponent<Cogs::Core::TransformComponent>();
        transformComponent->coordinates = pos;
        transformComponent->position = {};
        transformComponent->setChanged();
        ::setOrigin(context, glm::value_ptr(pos));
 
        orbitingCameraController->moveCamera = false;
        orbitingCameraController->setChanged();
        LOG_WARNING(logger, "OrbitingCameraComponent.moveCamera turned off (fixed camera rotation mode)");
        LOG_WARNING(logger, "Camera position set to: [%.2f %.2f %.2f]", pos.x, pos.y, pos.z);
      }
    }
 
    return { pos, orientation };
  }
}
 
 
namespace Cogs::Core
{
  struct IconInfo
  {
    Icon icon;
    const char * fileName;
  };
 
  const IconInfo icons[] = {
    { Icon::None, nullptr },
    { Icon::New, "IconNew.png" },
    { Icon::Open, "IconOpen.png" },
    { Icon::Save, "IconSave.png" },
 
    { Icon::Undo, "IconUndo.png" },
    { Icon::Redo, "IconRedo.png" },
 
    { Icon::Select, "IconSelect.png" },
    { Icon::Move, "IconMove.png" },
    { Icon::Rotate, "IconRotate.png" },
    { Icon::Scale, "IconScale.png" },
 
    { Icon::Plus, "IconPlus.png" },
    { Icon::Minus, "IconMinus.png" },
    { Icon::Info, "IconInfo.png" },
    { Icon::Gears, "IconGears.png" },
 
    { Icon::Eye, "IconEye.png" },
 
    { Icon::Solid, "IconSolid.png" },
    { Icon::Wireframe, "IconWireframe.png" },
    { Icon::BoundingBox, "IconBoundingBox.png" },
 
    { Icon::PivotLocal, "IconPivotLocal.png" },
    { Icon::PivotCenter, "IconPivotCenter.png" },
 
    { Icon::ShowAll, "IconShowAll.png" },
    { Icon::Hide, "IconHide.png" },
    { Icon::HideUnselected, "IconHideUnselected.png" },
    { Icon::Eye, "IconEye.png" },
    { Icon::SelectFurthestAway, "IconFurthest.png" },
    { Icon::IconInvertVisibility, "IconInvertVisibility.png" },
  };
}
 
Cogs::Core::Editor::Editor(Context * context) :
  context(context),
  state(std::make_unique<EditorState>()),
  materialEditor(std::make_unique<MaterialEditor>(context, this))
{
  state->editor = this;
  state->context = context;
}
 
Cogs::Core::Editor::~Editor() = default;
 
void Cogs::Core::Editor::registerExtensionCommand(const StringView & key, CommandCreator creator)
{
  auto & command = getExtensionCommands().emplace_back();
 
  command.key = key.to_string();
  command.creator = creator;
}
 
std::vector<Cogs::Core::ExtensionCommand> & Cogs::Core::Editor::getExtensionCommands()
{
  static std::vector<ExtensionCommand> commands;
 
  return commands;
}
 
void Cogs::Core::Editor::registerExtensionItem(const StringView & key, const StringView & name)
{
  auto & item = getExtensionItems().emplace_back();
 
  item.key = key.to_string();
  item.name = name.to_string();
}
 
std::vector<Cogs::Core::ExtensionItem> & Cogs::Core::Editor::getExtensionItems()
{
  static std::vector<ExtensionItem> items;
 
  return items;
}
 
 
void Cogs::Core::Editor::initialize()
{
  ::setIntVariable(context, "cogsbin.writeVersion", 4);
 
  if (initialized) return;
  for (auto & icon : icons) {
    if (!icon.fileName) continue;
 
    std::string path = "Textures/Gui/" + std::string(icon.fileName);
 
    if (icon.icon == Icon::Select) {
      state->icons[(int)icon.icon] = context->textureManager->loadTexture(path, NoResourceId, TextureLoadFlags::Flip);
    }
    else {
      state->icons[(int)icon.icon] = context->textureManager->loadTexture(path, NoResourceId, TextureLoadFlags::ForceUnique);
    }
  }
 
  ::setDoubleVariable(context, "resources.meshes.uploadBatchMaxTime", 0.2);
  context->modelManager->registerLoader(new CogsModelLoader());
 
  float scaleFactor = context->getDefaultView()->dpiService->getScaleFactor();
 
  ImguiRenderer* guiRenderer = context->renderer->getGuiRenderer();
  guiRenderer->fontRegistry.defaultFont->load(context, "Fonts/GoNotoCurrent.ttf", 16 * scaleFactor, ImGui::GetIO().Fonts->GetGlyphRangesDefault());
 
  minWidth *= scaleFactor;
  sidebarWidth *= scaleFactor;
  inspectorWidth *= scaleFactor;
  menuHeight *= scaleFactor;
  toolbarHeight *= scaleFactor;
  statusbarHeight *= scaleFactor;
  buttonSize *= scaleFactor;
 
  initialized = true;
}
 
void Cogs::Core::Editor::cleanup()
{
  state->icons.clear();
  commands.clear();
}
 
namespace Cogs::Core
{
  struct MenuItem
  {
    static MenuItem Separator() {
      return MenuItem{ nullptr, nullptr, nullptr, []() {} };
    }
 
    const char* getStatusbarText() const { return description ? description : name; }
 
    const char * name;
    const char * description;
    const char * shortCut;
    std::function<void(void)> action;
    bool enabled = true;
    bool * selected = nullptr;
  };
 
  struct Menu
  {
    const char * name;
    std::vector<MenuItem> items;
    bool enabled = true;
  };
}
 
void Cogs::Core::Editor::show()
{
  if (!initialized) {
    initialize();
  }
 
  eventBasedInput.updateState(context->getDefaultView()->refKeyboard(), context->getDefaultView()->refMouse());
 
  ImGuizmo::BeginFrame();
 
  ImGui::PushStyleVar(ImGuiStyleVar_WindowRounding, 0);
 
  const glm::vec2 size = context->renderer->getSize();
  ImGui::SetNextWindowSize(ImVec2(size.x, size.y));
  ImGui::SetNextWindowPos(ImVec2(0, 0));
 
  processShortcuts();
 
  bool selectedVisible = false;
  if (state->getSelected()) {
    auto* selectedSceneComponent = state->getSelected()->getComponent<Cogs::Core::SceneComponent>();
    selectedVisible = selectedSceneComponent ? selectedSceneComponent->visible : false;
  }
 
  // Alt key temporarily shows the hidden menu
  const Keyboard& keyboard = context->getDefaultView()->refKeyboard();
  if ((showMenu || keyboard.isKeyDown(Key::Alt)) && ImGui::BeginMainMenuBar()) {
 
    bool assetSystemFreeze = ::getBoolVariable(context, "resources.assets.lodFreeze");
 
    Menu menus[] = {
      { "File",
        {
          { "Clear All", "Clear any loaded files and reset the GUI", nullptr, [this]() { clear(); } },
          { "Open", "Open a file for viewing in the GUI, add data to the root Entity level. Supported files are scenes, 3D models, assets, point clouds, 360 images", "Ctrl+O", [this]() { open("", true, false); }},
          { "Open as Child of Selected", "Open a file for viewing, add data as a child to the selected Entity", nullptr, [this]() { open("", false, false); }, state->getSelected() != nullptr},
          MenuItem::Separator(),
          { nullptr, nullptr, nullptr, []() {} },
          { "Save", "Save the contents in Cogs scene format", "Ctrl+S", [this]() { save(); }},
          { "Save As...", "Save the contents in Cogs scene format to a new file", "Ctrl+Shift+S", [this]() { saveAs(); } },
          { "Save Incremental", nullptr, "Ctrl+Alt+S", [this]() { saveIncremental(); } },
          MenuItem::Separator(),
          { "Import Static Models...", nullptr, nullptr, [this]() { importStatic(); } },
          { "Export Selected As...", "Allows exporting selected entities in cogsbin/GLTF/GLB formats", "Ctrl+E", [this]() { exportEntities(); }},
          { "Export Scene As...", "Allows exporting whole scene in cogsbin/GLTF/GLB formats", nullptr, [this]() { exportEntities(true); }},
          MenuItem::Separator(),
          { "Exit", "Exit the application", "Ctrl+Q", []() { exit(0); } },
        }
      },
      { "Edit",
        {
          { "Undo", "Normal editor undo command", "Ctrl+Z", [this]() { undo(); }, modalCommand == nullptr && commandIndex != NoCommand},
          { "Redo", "Normal editor redo command", "Ctrl+Y", [this]() { redo(); }, modalCommand == nullptr && commandIndex < (commands.size() - 1)},
          { "Cut", "Cut (Copy and Delete) selected Entity", "Ctrl+X", [this]() { cut(); }, state->hasSelected()},
          { "Copy", "Copy selected Entity", "Ctrl+C", [this]() { copy(); }, state->hasSelected() },
          { "Paste", "Paste copied Entity below selected", "Ctrl+V", [this]() { paste(); }, state->copied.IsArray()},
          { "Delete", "Delete selected Entity", "Ctrl+Del", [this]() { destroy(); }, state->hasSelected()},
          { "Delete Permamently", "Delete selected Entity permanently, without ability to recover using Undo", "Shift+Del", [this]() { destroyPermanently(); }, state->hasSelected()},
          MenuItem::Separator(),
          { "Select All", "Select all entities", "Ctrl+A", [this]() { selectAll(); }},
          { "Toggle Entity Search", "Turn Entity Search of or off", "Ctrl+F", [this]() { state->findEntities = !state->findEntities; }},
        }
      },
      { "Debug",
        {
          { "No visualizer", nullptr,        nullptr, [this]() { ::setVariable(context, "renderer.pipeline.override", ""); } },
          { "Show normals", nullptr,         nullptr, [this]() { ::setVariable(context, "renderer.pipeline.override", "Pipelines/DebugView/ShowNormals.pipeline"); } },
          { "Show draw calls", nullptr,      nullptr, [this]() { ::setVariable(context, "renderer.pipeline.override", "Pipelines/DebugView/ShowDrawCalls.pipeline"); } },
          { "Show object IDs", nullptr,      nullptr, [this]() { ::setVariable(context, "renderer.pipeline.override", "Pipelines/DebugView/ShowObjectIDs.pipeline"); } },
          { "Show triangle size", nullptr,   nullptr, [this]() { ::setVariable(context, "renderer.pipeline.override", "Pipelines/DebugView/ShowTriangleSizes.pipeline"); } },
          { "Show shadow cascades", nullptr, nullptr, [this]() { ::setVariable(context, "renderer.pipeline.override", "Pipelines/DebugView/ShowShadowCascades.pipeline"); } },
          MenuItem::Separator(),
          { assetSystemFreeze ? "Disable asset lod freeze" : "Enable asset lod freeze", nullptr, nullptr, [&]() { ::setBoolVariable(context, "resources.assets.lodFreeze", !assetSystemFreeze); } }
        }
      },
      { "Modes",
      {
          { "Select Mode", "Select objects by clicking on them", nullptr, [this]() { changeMode(EditingMode::Select); }},
          { "Translate Mode", "Translate the object using the Gizmo tool", nullptr, [this]() { changeMode(EditingMode::Translate); }},
          { "Rotate Mode", "Rotate the object using the Gizmo tool", nullptr, [this]() { changeMode(EditingMode::Rotate); }},
          { "Scale Mode", "Scale the object using the Gizmo tool", nullptr, [this]() { changeMode(EditingMode::Scale); }},
          MenuItem::Separator(),
          { "Solid shading", nullptr, "0", [this]() { utilSetRenderMode(context, RenderMode::Normal); }},
          { "Wireframe shading", nullptr, "1", [this]() { utilSetRenderMode(context, RenderMode::Wireframe); }},
          { "Solid shading Bounding Boxes", nullptr, "3", [this]() { utilSetRenderMode(context, RenderMode::Box); }},
      }
      },
      { "Commands",
      {
 
      }
      },
      { "Create",
        {
 
        }
      },
      { "Entity",
        {
          { "Destroy", "Destroy Entity", nullptr, [this]() { destroy(); }},
          { "Destroy Permanently", "Destroy Entity permanently, without Undo possibility", nullptr, [this]() { destroyPermanently(); }},
          MenuItem::Separator(),
        }
      },
      { "View",
        {
          { "Focus on Selection", "Zooms to the selected item(s)", "f",        [this]() { focusSelected(); }, state->hasSelected()},
          { "Focus all", "Best fit all objects in the scene to the screen", "v",                     [this]() { focusAll(); }, true},
          { nullptr, nullptr, nullptr,                     []() {} },
          { "Show All", "Make all objects visible", nullptr,                  [this]() { showAll(); }, true},
          { "Select All", "Select all objects", "Ctrl+A",               [this]() { selectAll(); }, true},
          { selectedVisible ? "Hide Selected" : "Show Selected", nullptr, nullptr, [this,selectedVisible]() { showHide(!selectedVisible); }, state->hasSelected() },
          { "Hide Unselected", "Show only selected objects, hide all others", nullptr,           [this]() { hideUnselected(); }, state->hasSelected()},
          { "Invert Visibility", "Toggles visibility of all objects", nullptr,         [this]() { invertVisibility(); }, state->hasSelected()},
          { "Select Furthest Away", "Select object in tree furthest away from center of selected bounding box. Modifiers: Shift(X-axis), Control(Y-axis), Alt(Z-axis)", nullptr,      [this]() { selectFurthestAway(); }, state->hasSelected()},
        }
      },
      { "Help",
        {
          { "Cogs.Runtime Help", nullptr, nullptr, [this]() { onlineHelp(false); } },
          { "Cogs Help", nullptr, nullptr, [this]() { onlineHelp(true); } },
          { nullptr, nullptr, nullptr, []() {} },
          { "About", nullptr, nullptr, [this]() { showAbout(); } },
          { "Show Licenses", nullptr, nullptr, [this]() { showLicenses(); } }
        },
      },
    };
 
    auto findMenuEntry = [&menus](const Cogs::StringView & name) -> Menu& {
      for (Menu& menu : menus) {
        if (name == menu.name)
          return menu;
      }
 
      return menus[0];
    };
 
    Menu& viewMenu = findMenuEntry("View");
    viewMenu.items.push_back(MenuItem::Separator());
    viewMenu.items.emplace_back(MenuItem{ "Show Menu", showMenu ? "Hide Menu (Alt key shows menu temporarily)" : "Show Menu", "F10", []() {}, true, &showMenu });
    viewMenu.items.emplace_back(MenuItem{ "Show Toolbar", showToolbar ? "Hide Toolbar" : "Show Toolbar", "", []() {}, true, &showToolbar});
    viewMenu.items.emplace_back(MenuItem{ "Show Entity sidebar", showSidebar ? "Hide Entity left sidebar" : "Show Entity left sidebar", "", []() {}, true, &showSidebar });
    viewMenu.items.emplace_back(MenuItem{ "Show Inspector sidebar", showInspector ? "Hide Inspector right sidebar" : "Show Inspector right sidebar", "", []() {}, true, &showInspector });
    viewMenu.items.emplace_back(MenuItem{ "Show Statusbar", showStatusbar ? "Hide Statusbar" : "Show Statusbar", "", []() {}, true, &showStatusbar });
 
    auto & commandsMenu = findMenuEntry("Commands");
    commandsMenu.enabled = state->hasSelected();
 
    if (state->getSelected() != nullptr) {
      commandsMenu.items.emplace_back(MenuItem{ "Scale to unit cube", nullptr, "", [this]() { apply<ScaleToUnitCubeCommand>(state->getSelectedId()); } });
      commandsMenu.items.emplace_back(MenuItem{ "Merge Material", nullptr, "", [this]() { apply<MergeMaterialCommand>(state->getSelectedId()); } });
      commandsMenu.items.emplace_back(MenuItem{ "Remap Material", nullptr, "", [this]() { apply<RemapMaterialCommand>(state->getSelectedId()); } });
      commandsMenu.items.emplace_back(MenuItem{ "Merge Children", nullptr, "", [this]() { apply<MergeCommand>(state->selected); } });
      commandsMenu.items.emplace_back(MenuItem{ "Merge Meshes", nullptr, "", [this]() { apply<MergeMeshCommand>(state->selected); } });
      commandsMenu.items.emplace_back(MenuItem{ "Generate Normals", nullptr, "", [this]() { apply<GenerateNormalsCommand>(); } });
      commandsMenu.items.emplace_back(MenuItem{ "Generate Tangents", nullptr, "", [this]() { apply<GenerateTangentsCommand>(state->getSelectedId()); } });
      commandsMenu.items.emplace_back(MenuItem{ "Dump Entity Stats", nullptr, "", [this]() { apply<DumpStatsCommand>(state->getSelectedId()); } });
      commandsMenu.items.emplace_back(MenuItem{ "Remove duplicate vertices", nullptr, "", [this]() { apply<UniqueVerticesCommand>(); } });
      commandsMenu.items.emplace_back(MenuItem{ "Scale Mesh", nullptr, "", [this]() { apply<ScaleMeshCommand>(state->selected); } });
 
      for (auto & item : getExtensionItems()) {
        for (auto & ext : getExtensionCommands()) {
          if (ext.key == item.key) {
            commandsMenu.items.emplace_back(MenuItem{ item.name.c_str(), nullptr, nullptr,[&, creator = ext.creator]()
            {
              doApply(std::unique_ptr<EditorCommand>(creator(getState())));
            }});
          }
        }
      }
 
    }
 
    struct NameDescription
    {
      const char* name;
      const char* description;
    } defs[] = {
      {"Empty", "Create Empty"},
      {"Group", "Create Group"},
      {"Lod", "Create Lod"},
      {"Light", "Create Light"},
      {nullptr, nullptr},
      {"Plane", "Create Plane"},
      {"Cube", "Create Cube"},
      {"Sphere", "Create Sphere"},
      {"Cylinder", "Create Cylinder"},
      {"Cone", "Create Cone"},
      {"SkyDome", "Create SkyDome"},
      {"BasicOcean", "Create BasicOcean"},
      {"ModelEntity", "Create ModelEntity"},
      {"StaticModel", "Create StaticModel"},
      {nullptr, nullptr},
      {"PlaneMesh", "Create PlaneMesh"}
    };
 
    auto & createMenu = findMenuEntry("Create");
 
    for (auto & def : defs) {
      if (!def.name) {
        createMenu.items.emplace_back(MenuItem::Separator());
      } else {
        createMenu.items.emplace_back(MenuItem{
          def.name, def.description, nullptr, [&, def]() {
            apply<CreateEntityCommand>(def.name, def.name, false);
          }
        });
      }
    }
 
    const NameDescription comps[] = {
      {"TransformComponent", "Create TransformComponent"},
      {"SceneComponent", "Create SceneComponent"},
      {"MeshComponent", "Create MeshComponent"},
      {"MeshRenderComponent", "Create MeshRenderComponent"},
      {"MeshGeneratorComponent", "Create MeshGeneratorComponent"},
      {"ModelComponent", "Create ModelComponent"}
    };
 
    auto & entityMenu = findMenuEntry("Entity");
 
    entityMenu.enabled = state->numSelected() == 1U;
 
    if (entityMenu.enabled) {
      for (const NameDescription& comp : comps) {
        entityMenu.items.emplace_back(MenuItem{
          comp.name, comp.description, nullptr, [this, comp]() {
            apply<AddComponentCommand>(state->getSelectedId(), comp.name);
          }
        });
      }
    }
 
    bool setStatus = false;
    for (auto & menu : menus) {
      if (!menu.enabled) continue;
 
      if (ImGui::BeginMenu(menu.name, menu.enabled)) {
        for (auto & item : menu.items) {
          if (item.name) {
            if (ImGui::MenuItem(item.name, item.shortCut, item.selected, item.enabled)) {
              item.action();
            }
            if (ImGui::IsItemHovered(ImGuiHoveredFlags_None)) {
              setStatusbarText(item.getStatusbarText(), true);
              setStatus = true;
            }
          } else {
            ImGui::Separator();
          }
        }
 
        ImGui::EndMenu();
      }
    }
 
    // No longer hovering over a GUI item remove.
    // Don't remove if application status as always entering this code.
    if (showingGuiStatusbarText() && !setStatus) {
      setStatusbarText(std::string(), true);
    }
 
    ImGui::EndMainMenuBar();
  }
 
  auto staticWindowFlags = ImGuiWindowFlags_NoTitleBar |
    ImGuiWindowFlags_NoResize |
    ImGuiWindowFlags_NoMove |
    ImGuiWindowFlags_NoCollapse |
    ImGuiWindowFlags_NoSavedSettings |
    ImGuiWindowFlags_NoFocusOnAppearing;
 
  if (showToolbar) {
 
    ImGui::SetNextWindowPos(ImVec2(0, getMenuHeight()));
    ImGui::SetNextWindowSize(ImVec2(ImGui::GetIO().DisplaySize.x, getToolbarHeight()));
 
    ImGui::Begin("Toolbar", nullptr, staticWindowFlags);
 
    auto actionDummy = []() { };
    auto highlightDummy = []() {return false;};
 
    auto hightlightIfVisible = [selectedVisible]() {
      return selectedVisible;
    };
 
    struct ToolbarButton
    {
      const char * name;
      const char * description;
      const Icon icon = Icon::None;
      std::function<void(void)> action;
      std::function<bool(void)> highlight;
    };
 
    const ToolbarButton buttons[] = {
      { "Clear All", nullptr, Icon::New, [this]() { clear(); }, highlightDummy },
      { "Open", nullptr, Icon::Open, [this]() { open("", true, false); }, highlightDummy },
      { "Save", nullptr, Icon::Save, [this]() { save(); }, highlightDummy },
 
      { "Undo", nullptr, Icon::Undo, [this]() { undo(); }, highlightDummy },
      { "Redo", nullptr, Icon::Redo, [this]() { redo(); } , highlightDummy },
 
      { nullptr, nullptr, Icon::None, actionDummy, highlightDummy },
 
      { "Select Mode", nullptr, Icon::Select, [this]() { changeMode(EditingMode::Select); }, [this]() { return state->mode == EditingMode::Select; } },
      { "Translate Mode", nullptr, Icon::Move, [this]() { changeMode(EditingMode::Translate); }, [this]() { return state->mode == EditingMode::Translate; } },
      { "Rotate Mode", nullptr, Icon::Rotate, [this]() { changeMode(EditingMode::Rotate); }, [this]() { return state->mode == EditingMode::Rotate; } },
      { "Scale Mode", nullptr, Icon::Scale, [this]() { changeMode(EditingMode::Scale); }, [this]() { return state->mode == EditingMode::Scale; } },
 
      { nullptr, nullptr, Icon::None, actionDummy, highlightDummy },
 
      { "Variables", nullptr, Icon::Gears, [this]() { state->showSettings = !state->showSettings; }, highlightDummy },
 
      { nullptr, nullptr, Icon::None, actionDummy, highlightDummy },
 
      { "Focus", "Focus on Selection", Icon::Eye, [this]() { focusSelected(); }, highlightDummy },
 
      { nullptr, nullptr, Icon::None, actionDummy, highlightDummy },
 
      { "Solid", "Solid shading", Icon::Solid, [this]() { utilSetRenderMode(context, RenderMode::Normal); }, highlightDummy },
      { "Wireframe", "Wireframe shading", Icon::Wireframe, [this]() { utilSetRenderMode(context, RenderMode::Wireframe); }, highlightDummy },
      { "BoundingBox", "Solid shading Bounding Boxes", Icon::BoundingBox, [this]() { utilSetRenderMode(context, RenderMode::Box); }, highlightDummy },
 
      { nullptr, nullptr, Icon::None, actionDummy, highlightDummy },
 
      { "PivotLocal", "Use object local origin as pivot", Icon::PivotLocal, [this]() { state->pivot = EditingPivot::ObjectPivot; }, [this]() { return state->pivot == EditingPivot::ObjectPivot; } },
      { "PivotCenter", "Use object center as pivot", Icon::PivotCenter, [this]() { state->pivot = EditingPivot::ObjectCenter; }, [this]() { return state->pivot == EditingPivot::ObjectCenter; } },
 
      { nullptr, nullptr, Icon::None, actionDummy, highlightDummy },
 
      { "ShowAll", "Show All", Icon::ShowAll, [this]() { showAll(); }, highlightDummy },
      { "Hide", hightlightIfVisible() ? "Hide Selected" : "Show Selected", Icon::Hide, [this, selectedVisible]() { showHide(!selectedVisible); }, hightlightIfVisible },
      { "HideUnselected", "Hide Unselected", Icon::HideUnselected, [this]() { hideUnselected(); }, highlightDummy },
      { "InvertVisibility", "Invert Visibility", Icon::IconInvertVisibility, [this]() { invertVisibility(); }, highlightDummy },
      { "SelectFurthestAway", "Select Furthest Away", Icon::SelectFurthestAway, [this]() { selectFurthestAway(); }, highlightDummy },
    };
 
    ImGui::PushStyleColor(ImGuiCol_Button, ImGui::GetStyleColorVec4(ImGuiCol_WindowBg));
 
    for (const ToolbarButton& button : buttons) {
      if (!button.name) {
        ImVec2 cursor = ImGui::GetCursorScreenPos();
        const float xOffset = 6;
        ImGui::GetWindowDrawList()->AddLine(ImVec2(cursor.x + xOffset, cursor.y + 4), ImVec2(cursor.x + xOffset, cursor.y + 32), 0x33FFFFFF, 1.0f);
        ImGui::SameLine(cursor.x + 20);
        continue;
      }
 
      if (button.icon != Icon::None) {
        auto texture = state->icons[(int)button.icon];
 
        Renderer* renderer = dynamic_cast<Renderer*>(context->renderer);
        RenderTexture * renderTexture = renderer->getRenderResources().getRenderTexture(context->textureManager->generateHandle((Texture *)texture.resolve()));
 
        if (renderTexture && HandleIsValid(renderTexture->textureHandle)) {
          auto textureId = renderTexture->textureHandle.handle;
 
          float padding = 6;
          float textureSize = buttonSize.x - padding * 2;
 
          if (ImGui::ImageButton(button.name, textureId, ImVec2(textureSize, textureSize), ImVec2(0, 1), ImVec2(1, 0))) {
            button.action();
          } else if (ImGui::IsItemHovered()) {
            ImGui::SetTooltip("%s", button.description ? button.description : button.name);
            setStatusbarText(std::string(), true);
          }
 
          if (button.highlight) {
            const bool isHighlighted = button.highlight();
 
            if (isHighlighted) {
              ImGui::GetWindowDrawList()->AddRectFilled(ImGui::GetItemRectMin(), ImGui::GetItemRectMax(), 0x33FFFFFF, 0, 0);
            }
          }
        }
      } else {
        if (ImGui::Button(button.name, ImVec2(buttonSize.x, buttonSize.y))) {
          button.action();
        }
      }
 
      ImGui::SameLine();
    }
 
    ImGui::PopStyleColor();
 
    ImGui::End();
  }
 
  float w = ImGui::GetIO().DisplaySize.x;
  float thickness = 6.f;
 
  if (showSidebar) {
 
    if (getSidebarWidth() + getInspectorWidth() + 2 * thickness >= w) {
      // This can happen if user hid sidebars, shrunk the window and then enabled them again
      // Set left sidebar to 1/3 of the window, the right one will be checked/fixed afterwards
      sidebarWidth = w / 3;
    }
 
    auto oldColor = ImGui::GetStyleColorVec4(ImGuiCol_WindowBg);
    const float d = 0.85f;
    ImGui::PushStyleColor(ImGuiCol_WindowBg, ImVec4(oldColor.x * d, oldColor.y * d, oldColor.z * d, 1));
 
    ImGui::SetNextWindowPos(ImVec2(0, getMenuHeight() + getToolbarHeight()));
    ImGui::SetNextWindowSize(ImVec2(getSidebarWidth(), ImGui::GetIO().DisplaySize.y - getMenuHeight() - getToolbarHeight() - getStatusbarHeight()));
 
    ImGui::Begin("EditorEntities", nullptr, staticWindowFlags | ImGuiWindowFlags_HorizontalScrollbar);
 
    showEntities();
 
    ImGui::End();
 
    ImGui::PopStyleColor();
 
    // Left Splitter window to resize sidebar
 
    ImGui::PushStyleVar(ImGuiStyleVar_WindowPadding, ImVec2(0, 0));      // Disable padding
    ImGui::PushStyleVar(ImGuiStyleVar_WindowMinSize, ImVec2(0, 0));
    ImGui::PushStyleColor(ImGuiCol_WindowBg, ImVec4(0, 0, 0, 0));
 
    ImGui::PushStyleColor(ImGuiCol_Button, ImVec4(1.0f, 1.0f, 1.0f, 0.2f));
    ImGui::PushStyleColor(ImGuiCol_ButtonActive, ImVec4(1.f, 1.f, 1.f, 1.0f));
    ImGui::PushStyleColor(ImGuiCol_ButtonHovered, ImVec4(1.0f, 1.0f, 1.0f, 0.8f));
 
    ImGui::SetNextWindowPos(ImVec2(getSidebarWidth(), getMenuHeight() + getToolbarHeight()));
    ImGui::SetNextWindowSize(ImVec2(thickness, ImGui::GetIO().DisplaySize.y - getMenuHeight() - getToolbarHeight() - getStatusbarHeight()));
    ImGui::Begin("TransparentLWindow", nullptr, staticWindowFlags | ImGuiWindowFlags_NoScrollbar | ImGuiWindowFlags_NoBackground);
 
    // left splitter
    ImGui::SetCursorPosX(0);
    ImGui::Button("##LSplitter", ImVec2(thickness, -1));
    if (ImGui::IsItemActive()) {
      sidebarWidth += static_cast<int>(ImGui::GetIO().MouseDelta.x);
      if (sidebarWidth < minWidth) sidebarWidth = minWidth;
      if (w - 2 * thickness - getInspectorWidth() < sidebarWidth) sidebarWidth = w - 2 * thickness - getInspectorWidth();
    }
 
    ImGui::End();
    ImGui::PopStyleColor(4);
    ImGui::PopStyleVar(2);
  }
 
  if (showInspector) {
 
    if (getSidebarWidth() + getInspectorWidth() + 2 * thickness >= w) {
      inspectorWidth = w / 3;
    }
 
    ImGui::SetNextWindowPos(ImVec2(w - getInspectorWidth(), getMenuHeight() + getToolbarHeight()));
    ImGui::SetNextWindowSize(ImVec2(getInspectorWidth(), ImGui::GetIO().DisplaySize.y - getMenuHeight() - getToolbarHeight() - getStatusbarHeight()));
 
    ImGui::Begin("Inspector", nullptr, staticWindowFlags | ImGuiWindowFlags_HorizontalScrollbar);
 
    if (state->findEntities) {
      bool search = false;
      static std::array<char, 65> buffer;
 
      float spacing = ImGui::GetStyle().ItemInnerSpacing.x;
      showText("Entity Search");
      ImGui::SameLine(0.0f, spacing);
      if (ImGui::Button("Prev")) {
        if (state->findOffset > 0) state->findOffset--;
        search = true;
      }
      ImGui::SameLine(0.0f, spacing);
      if (ImGui::Button("Next")) {
        state->findOffset++;
        search = true;
      }
 
      if (ImGui::InputText("Pattern", buffer.data(), buffer.size(), ImGuiInputTextFlags_None)) {
        state->findOffset = 0u;
 
        ImguiRenderer* guiRenderer = context->renderer->getGuiRenderer();
        if (guiRenderer) {
          guiRenderer->addTextToGlyphBuilder(buffer.data());
        }
 
        state->setFindPattern(buffer.data());
        if (!state->getFindPattern().empty()) {
          if (state->isFindRegexValid()) {
            search = true;
          }
          else {
            setStatusbarText("Invalid regular expression", false);
          }
        }
      }
 
      if (search) {
        setStatusbarText(std::string(), false);
        size_t numFound = 0;
        auto store = context->store;
        auto& entities = store->getEntities();
 
        for (auto& e : entities) {
          const EntityPtr& entity = e.second;
          if (!entity) continue;
          const TransformComponent* transformComponent = entity->getComponent<TransformComponent>();
          if (transformComponent && !transformComponent->parent) {
            numFound = searchEntity(numFound, *this, entity.get());
            if (numFound > state->findOffset) {
              break;
            }
          }
        }
 
        if (getStatusbarText().empty()) {
          setStatusbarText("Find - None Index: " + std::to_string(getState()->findOffset + 1), false);
        }
        else if (keyboard.isKeyDown(Key::Control)) {
          // Auto focus
          focusSelected();
        }
      }
    }
 
    if (state->getSelected()) {
      const std::set<StringView> allLayers = getAllLayers(state->getSelected());
      if (!allLayers.empty()) {
        // Add Pull-down for individual layer visibility
        if (ImGui::CollapsingHeader("Layer Visibility"))
        {
          // Go to the first ancestor that doesn't have a PropertiesComponent and set the layer visibility down from there
          // to make sure all the nodes get toggled on/off based on the layer visibility.
          Entity* startingEntity = state->getSelected();
          for (SceneComponent* sceneComp = startingEntity->getComponent<SceneComponent>(); sceneComp; sceneComp = sceneComp->parent.resolveComponent<SceneComponent>()) {
            startingEntity = sceneComp->getContainer();
          }
 
          ScopedIndent si;
          for (StringView layer : allLayers) {
            bool layerVisible = getLayerVisibility(startingEntity, layer);
            if (ImGui::Checkbox(layer.to_string().data(), &layerVisible)) {
 
              setLayerVisibility(startingEntity, layer, layerVisible);
            }
          }
        }
      }
 
      if (state->lastPickState.rootId != NoEntity &&
        (state->lastPickState.rootId != state->getSelected()->getId())) {
        showText("Pick Root Id: %zd", state->lastPickState.rootId);
        const Entity* entity = state->getSelected();
        Cogs::Core::PropertiesComponent* propertiesComponent = entity->getComponent<Cogs::Core::PropertiesComponent>();
        if (propertiesComponent) {
          Cogs::StringView layerProperty = propertiesComponent->properties.getProperty("_rvmLayer", "");
          if (!layerProperty.empty()) {
            showText("Layer : %s", layerProperty.to_string().c_str());
          }
 
        }
 
      }
      if (!state->lastPickState.details.empty()) {
        showText("%s", state->lastPickState.details.c_str());
      }
      if (!state->lastPickState.assetRootGroupName.empty()) {
        showText("Asset Root : %s", state->lastPickState.assetRootGroupName.c_str());
      }
      if (!state->lastPickState.pickId.empty() && state->lastPickState.pickId != std::to_string(state->getSelected()->getId())) {
        showText("Asset PickId : %s", state->lastPickState.pickId.c_str());
      }
      if (!state->lastPickState.boundingBox.empty()) {
        showText("BBox : %s", state->lastPickState.boundingBox.c_str());
      }
 
      showEntityDetails(state->getSelected());
    }
 
    ImGui::End();
 
    // Right Splitter window to resize inspector sidebar
 
    ImGui::PushStyleVar(ImGuiStyleVar_WindowPadding, ImVec2(0, 0));      // Disable padding
    ImGui::PushStyleVar(ImGuiStyleVar_WindowMinSize, ImVec2(0, 0));
    ImGui::PushStyleColor(ImGuiCol_WindowBg, ImVec4(0, 0, 0, 0));
 
    ImGui::PushStyleColor(ImGuiCol_Button, ImVec4(1.0f, 1.0f, 1.0f, 0.2f));
    ImGui::PushStyleColor(ImGuiCol_ButtonActive, ImVec4(1.f, 1.f, 1.f, 1.0f));
    ImGui::PushStyleColor(ImGuiCol_ButtonHovered, ImVec4(1.0f, 1.0f, 1.0f, 0.8f));
 
    ImGui::SetNextWindowPos(ImVec2(w - getInspectorWidth() - thickness, getMenuHeight() + getToolbarHeight()));
    ImGui::SetNextWindowSize(ImVec2(thickness, ImGui::GetIO().DisplaySize.y - getMenuHeight() - getToolbarHeight() - getStatusbarHeight()));
    ImGui::Begin("TransparentRWindow", nullptr, staticWindowFlags | ImGuiWindowFlags_NoScrollbar | ImGuiWindowFlags_NoBackground);
 
    // right splitter
    ImGui::SetCursorPosX(0);
    ImGui::Button("##RSplitter", ImVec2(thickness, -1));
    if (ImGui::IsItemActive()) {
      inspectorWidth -= static_cast<int>(ImGui::GetIO().MouseDelta.x);
      if (inspectorWidth < minWidth) inspectorWidth = minWidth;
      if (w - 2 * thickness - getSidebarWidth() < inspectorWidth) inspectorWidth = w - 2 * thickness - getSidebarWidth();
    }
 
    ImGui::End();
    ImGui::PopStyleColor(4);
    ImGui::PopStyleVar(2);
  }
 
  if (showStatusbar) {
    ImGui::SetNextWindowPos(ImVec2(0, ImGui::GetIO().DisplaySize.y - getStatusbarHeight()));
    ImGui::SetNextWindowSize(ImVec2(ImGui::GetIO().DisplaySize.x, getStatusbarHeight()));
 
    ImGui::Begin("Statusbar", nullptr, staticWindowFlags);
 
    ImGui::SetCursorPos(ImVec2(5, 0));
    ImGui::TextUnformatted(getStatusbarText().c_str());
 
    ImGui::End();
  }
 
  showGizmo();
 
  if (modalCommand) {
    modalCommand->showGui();
  }
 
  ImGui::PopStyleVar(); // Window rounding
 
  if (state->showSettings) {
    variableInspector(context, &state->showSettings);
 
  }
}
 
 
void Cogs::Core::Editor::processShortcuts()
{
  if (modalCommand) return;
 
  // TODO: Use input manager mappings after adding proper action modifier support.
  struct EditorShortcut
  {
    Key                       key = Key::None;
    KeyboardModifiers         modifier = KeyboardModifiers::None;
    std::function<void(void)> action;
  };
 
  const EditorShortcut shortCuts[] = {
    { Key::Q, KeyboardModifiers::None, [this]() { apply<ChangeEditingModeCommand>(EditingMode::Select); } },
    { Key::W, KeyboardModifiers::None, [this]() { apply<ChangeEditingModeCommand>(EditingMode::Translate); } },
    { Key::E, KeyboardModifiers::None, [this]() { apply<ChangeEditingModeCommand>(EditingMode::Rotate); } },
    { Key::R, KeyboardModifiers::None, [this]() { apply<ChangeEditingModeCommand>(EditingMode::Scale); } },
 
    { Key::Zero, KeyboardModifiers::None, [this]() { utilSetRenderMode(context, RenderMode::Normal); } },
    { Key::One, KeyboardModifiers::None, [this]() { utilSetRenderMode(context, RenderMode::Wireframe); } },
    { Key::Three, KeyboardModifiers::None, [this]() { utilSetRenderMode(context, RenderMode::Box); } },
 
    { Key::F, KeyboardModifiers::None, [this]() { focusSelected(); } },
    { Key::F, KeyboardModifiers::Control, [this]() { state->findEntities = !state->findEntities; } },
 
    { Key::V, KeyboardModifiers::None, [this]() { focusAll(); } },
 
    { Key::A, KeyboardModifiers::Control, [this]() { selectAll(); } },
 
    { Key::Z, KeyboardModifiers::Control, [this]() { undo(); } },
    { Key::Y, KeyboardModifiers::Control, [this]() { redo(); } },
    { Key::Z, KeyboardModifiers::Control | KeyboardModifiers::Shift, [this]() { redo(); } },
 
    { Key::C, KeyboardModifiers::Control, [this]() { copy(); } },
    { Key::V, KeyboardModifiers::Control, [this]() { paste(); } },
    { Key::X, KeyboardModifiers::Control, [this]() { cut(); } },
 
    { Key::O, KeyboardModifiers::Control, [this]() { open("", true, false); } },
 
    { Key::E, KeyboardModifiers::Control, [this]() { exportEntities(); } },
 
    { Key::S, KeyboardModifiers::Control, [this]() { save(); } },
    { Key::S, KeyboardModifiers::Control | KeyboardModifiers::Shift, [this]() { saveAs(); } },
    { Key::S, KeyboardModifiers::Control | KeyboardModifiers::Alt, [this]() { saveIncremental(); } },
 
    { Key::G, KeyboardModifiers::Control, [this]()
      {
        apply<GroupCommand>(state->selected);
      }
    },
 
    // Avoid deleting entity to be edited pressing Delete editing component field in ImGui.
    // No keyboard focus in this GUI.
    { Key::Delete, KeyboardModifiers::Control, [this]() { destroy(); } },
    { Key::Delete, KeyboardModifiers::Shift, [this]() { destroyPermanently(); } },
    { Key::F10, KeyboardModifiers::None, [this]() { showMenu = !showMenu; } },
  };
 
  const Keyboard& keyboard = context->getDefaultView()->refKeyboard();
 
  KeyboardModifiers currentModifiers = KeyboardModifiers::None;
 
  if (keyboard.isKeyDown(Key::Control))   currentModifiers |= KeyboardModifiers::Control;
  if (keyboard.isKeyDown(Key::Shift))     currentModifiers |= KeyboardModifiers::Shift;
  if (keyboard.isKeyDown(Key::Alt))       currentModifiers |= KeyboardModifiers::Alt;
 
 
  // Toggle debug GUI on 'g' if there are no GUI item is active (e.g. typing in a text box)
  if (!Cogs::Core::ImguiRenderer::isUsingKeyboard() && (currentModifiers == KeyboardModifiers::None) && keyboard.wasKeyPressed(Key::G)) {
    bool enabled = ::getBoolVariable(context, "gui.enabled");
    ::setBoolVariable(context, "gui.enabled", !enabled);
  }
 
  for (const auto& event : eventBasedInput.events()) {
    switch (event.inputEventType) {
    case InputEventType::Keyboard:
      if (!ImGui::GetIO().WantCaptureKeyboard) {
        for (const auto& s : shortCuts) {
          if (event.modifiers == s.modifier && event.keyEvent.key == s.key) {
            s.action();
          }
        }
      }
      break;
 
    case InputEventType::Mouse:
      handleMouseEvent(event);
      break;
 
    case InputEventType::Reset:
      break;
    }
  }
 
  if (!Cogs::Core::ImguiRenderer::isUsingKeyboard() &&
    (keyboard.wasKeyPressed(Key::Left) || keyboard.wasKeyPressed(Key::Right) || keyboard.wasKeyPressed(Key::Up) || keyboard.wasKeyPressed(Key::Down)))
  {
    if (!state->hasSelected()) {
 
      if (!context->store->getEntities().empty()) {
        select({ context->store->getEntities().begin()->first }, SelectMode::Exclusive);
      }
    }
 
    else if (state->numSelected() == 1)
    {
      const Entity* entity = state->getSelected();
      assert(entity);
 
      if (keyboard.wasKeyPressed(Key::Right)) {
        if (SceneComponent* trc = entity->getComponent<SceneComponent>(); trc && !trc->children.empty()) {
          select({ trc->children[0]->getId() }, SelectMode::Exclusive);
        }
      }
 
      else {
 
        if (const TransformComponent* trc = entity->getComponent<TransformComponent>(); trc) {
 
 
          if (const Component* parent = trc->parent.resolve(); parent) {
 
            if (keyboard.wasKeyPressed(Key::Left)) {
              select({ parent->getContainer()->getId() }, SelectMode::Exclusive);
            }
            else {
 
              if (SceneComponent* scc = parent->getComponent<SceneComponent>(); scc) {
                size_t ix = 0;
                size_t childCount = scc->children.size();
                for (ix = 0; ix < childCount; ix++) {
                  if (scc->children[ix].get() == entity) break;
                }
                if (keyboard.wasKeyPressed(Key::Up) && (0 < ix) && (ix < childCount)) {
                  select({ scc->children[ix - 1]->getId() }, SelectMode::Exclusive);
                }
                else if (keyboard.wasKeyPressed(Key::Down) && (ix + 1 < childCount)) {
                  select({ scc->children[ix + 1]->getId() }, SelectMode::Exclusive);
                }
              }
            }
          }
 
          else {
 
            std::vector<EntityId> roots;
            roots.reserve(context->store->getEntities().size());
            for (const auto& it : context->store->getEntities()) {
              roots.push_back(it.first);
            }
 
            EntityId id = entity->getId();
            size_t ix = 0;
            size_t childCount = roots.size();
            for (ix = 0; ix < childCount; ix++) {
              if (roots[ix] == id) break;
            }
            if (keyboard.wasKeyPressed(Key::Up) && (0 < ix) && (ix < childCount)) {
              select({ roots[ix - 1] }, SelectMode::Exclusive);
            }
            else if (keyboard.wasKeyPressed(Key::Down) && (ix + 1 < childCount)) {
              select({ roots[ix + 1] }, SelectMode::Exclusive);
            }
 
          }
        }
      }
 
    }
  }
}
 
void Cogs::Core::Editor::handleMouseEvent(const struct Cogs::Core::InputEvent& event)
{
  using Event = Cogs::Mouse::Event;
 
  const glm::ivec2 mousePos = event.mouseEvent.currPosition;
 
  switch (event.mouseEvent.type) {
  case Cogs::Mouse::Event::Type::Press:
  {
    Cogs::Mouse::Event::ButtonData data = std::get<Event::ButtonData>(event.mouseEvent.data);
    if (data.button == MouseButton::Left) {
      if (!state->lButtonDown) {
        state->lButtonDown = true;
 
        state->downX = mousePos.x;
        state->downY = mousePos.y;
      }
    }
  }
  break;
 
  case Cogs::Mouse::Event::Type::Release:
  {
    Cogs::Mouse::Event::ButtonData data = std::get<Event::ButtonData>(event.mouseEvent.data);
    if (data.button == MouseButton::Left) {
      const EntityPtr cameraEntity = getEditorCamera(context);
      ComponentHandle cameraHandle = cameraEntity->getComponentHandle<CameraComponent>();
      const CameraComponent* camera = cameraHandle.resolveComponent<CameraComponent>();
 
      if (!ImGui::GetIO().WantCaptureMouse && !modalCommand && (mousePos.x == state->downX || mousePos.y == state->downY)) {
 
        glm::vec2 pickPoint = glm::vec2(mousePos) - camera->viewportOrigin;
        pickPoint.y = camera->viewportSize.y - pickPoint.y;
 
        if (pickPoint.x >= 0.f && pickPoint.y >= 0.f && pickPoint.x < camera->viewportSize.x && pickPoint.y < camera->viewportSize.y) {
 
          glm::dvec3 coordsWorld;
          glm::vec2 textureCoords;
          EntityId rootId = NoEntity;
          EntityId entityId = NoEntity;
          const float pickingRadius = std::max(1.0f, context->variables->get("editor.pickingRadius", 4.0f));
          ::pickWithCameraRay(context, cameraEntity->getId(), pickPoint.x, pickPoint.y, std::numeric_limits<float>::max(), pickingRadius,
            int(PickingFlags::PickSprites | PickingFlags::ReturnChildEntity | PickingFlags::FlatTexcoordInterpolation | PickingFlags::AddInstanceTexcoords), int(PicksReturned::Closest), int(RenderLayers::All), nullptr,
            1, &entityId, &rootId, glm::value_ptr(coordsWorld), glm::value_ptr(textureCoords));
          state->lastPickState.clear();
          int pickId = std::isnan(textureCoords.x) ? -1 : static_cast<int>(std::round(textureCoords.x));
          if (entityId != NoEntity) {
            LOG_DEBUG(logger, "Pick Global Coords: %f, %f, %f. ID: %d", coordsWorld.x, coordsWorld.y, coordsWorld.z, pickId);
          }
 
 
          if ((event.modifiers & KeyboardModifiers::Shift) == KeyboardModifiers::Shift) {
            apply<SelectCommand>(entityId, SelectMode::Add, pickId);
          }
          else if ((event.modifiers & KeyboardModifiers::Control) == KeyboardModifiers::Control) {
            apply<SelectCommand>(entityId, SelectMode::Toggle, pickId);
          }
          else {
            apply<SelectCommand>(entityId, SelectMode::Exclusive, pickId);
          }
        }
      }
 
      state->lButtonDown = false;
 
    }
 
    // Release mode - complete current command
    if (commands.size()) {
      commands.back()->close();
    }
 
  }
  break;
  default:
    break;
  }
}
 
 
void Cogs::Core::Editor::beginFrame()
{
  textElementId = 0;
  bool wasActive = active;
 
  active = ::getBoolVariable(context, "editor.enabled");
 
  const Cogs::StringView batch = ::getVariable(context, "editor.batch");
 
  if (!batch.empty()) {
 
    runBatch(context, this, batch);
 
    ::setVariable(context, "editor.batch", "");
  }
 
  std::string sceneFile;
  if (active && !wasActive) {
    sceneFile = Cogs::StringView(::getVariable(context, "editor.scene")).to_string();
  }
 
  if (active) {
    if (!sceneFile.empty()) {
      std::string path = context->resourceStore->getResourcePath(sceneFile);
 
      if (path.empty()) {
        LOG_ERROR(logger, "Could not resolve scene resource: %s.", sceneFile.data());
      }
 
      ::loadScene(context, path.data(), int(AssetLoadFlags::ClearScene));
 
      state->clearSelection();
      state->fileName = path;
      state->directory = IO::parentPath(path);
 
      ::addSearchPath(context, IO::absolute(state->directory).data());
 
      // TODO: Set title based on loaded scene.
      // Currently the extension doesn't have access to the window class.
      // auto title = "Editor - " + sceneFile;
      // Cogs::Desktop::setTitle(title);
 
      ::setVariable(context, "editor.scene", "");
    }
 
    // Set default scene before starting batch:
    if (!state->editorCamera.lock()) {
      LOG_INFO(logger, "No EditorCamera entity found. Resetting editor.");
 
      bool ok = ::loadScene(context, "Scenes/Editor.scene", int(AssetLoadFlags::NoDefault | AssetLoadFlags::ClearScene));
      if (!ok) {
        LOG_FATAL(logger, "Failed loading Editor Scene file: Scenes/Editor.scene");
        abort();
      }
 
      standardEntities.clear();
      for (const auto& entry : context->store->getEntities()) {
        standardEntities.push_back(entry.second);
      }
    }
 
    const EntityPtr cameraEntity = getEditorCamera(context);
    if (cameraEntity != state->editorCamera.lock()) {
      state->editorCamera = cameraEntity;
      context->getDefaultView()->setCamera(cameraEntity);
    }
 
    ComponentHandle cameraHandle = cameraEntity->getComponentHandle<CameraComponent>();
    CameraComponent* camera = cameraHandle.resolveComponent<CameraComponent>();
 
    if (context->cameraSystem->getMainCamera() != camera) {
      context->cameraSystem->setMainCamera(cameraHandle);
    }
 
    {
      const glm::vec2 rendererSize = context->renderer->getSize();
      float topUiHeight = getMenuHeight() + getToolbarHeight();
      const glm::vec2 newViewportSize(std::max(rendererSize.x - getSidebarWidth() - getInspectorWidth(), 1.0f), std::max(rendererSize.y - topUiHeight - getStatusbarHeight(), 1.0f));
      const glm::vec2 newViewportOrigin(getSidebarWidth(), topUiHeight);
 
      if (camera->viewportSize != newViewportSize || camera->viewportOrigin != newViewportOrigin) {
        camera->viewportSize = newViewportSize;
        camera->viewportOrigin = newViewportOrigin;
        camera->setChanged();
      }
    }
 
    if (modalCommand) {
      if (modalCommand->continueModal() == false) {
        modalCommand->close();
        modalCommand = nullptr;
      }
    }
  }
}
 
namespace Cogs::Core
{
  Entity * showEntity(EditorState & editor, Entity * entity)
  {
    Entity * picked = nullptr;
 
    bool descend = false;
    const SceneComponent* sceneComponent = entity->getComponent<SceneComponent>();
    ImguiRenderer* guiRenderer = editor.context->renderer->getGuiRenderer();
 
    // Scope where static buf/header exists, do not recurse inside this scope.
    {
      static char buf[64] = {}; // Needs space to encode "Id: " + 64-bit decimal number + terminator.
      const char* header = nullptr;
 
      // If Entity has a name, use that name
      if (const std::string& name = entity->getName(); !name.empty()) {
        header = name.c_str();
 
        // Check for non-ASCII characters
        bool nonAscii = false;
        for (const char* p = header; *p != '\0'; p++) { nonAscii = nonAscii || (*p < 0); }
        if (nonAscii) {
          guiRenderer->addTextToGlyphBuilder(header);
        }
      }
 
      // Otherwise use the entity id as name. This is always pure ascii.
      else {
        int rv = snprintf(buf, sizeof(buf), "Id: %zu", entity->getId());
        if (rv < 0) {
          return nullptr; // encoding error
        }
        assert(size_t(rv) < sizeof(buf));
        header = buf;
      }
 
      ImGui::PushID(entity);
      const bool hasChildren = sceneComponent ? sceneComponent->children.size() != 0 : false;
      auto flags = ImGuiTreeNodeFlags_OpenOnArrow | ImGuiTreeNodeFlags_NoAutoOpenOnLog | (hasChildren ? 0 : ImGuiTreeNodeFlags_Leaf);
 
      if (editor.isSelected(entity->getId())) {
        flags |= ImGuiTreeNodeFlags_Selected;
 
        if (!editor.scrolled) {
          ImGui::SetScrollHereY();
          editor.scrolled = true;
        }
      }
 
      auto found = std::find(editor.selectedPath.begin(), editor.selectedPath.end(), entity);
 
      if (found != editor.selectedPath.end()) {
        ImGui::SetNextItemOpen(true);
      }
 
      bool descendChecked = false;
      if (ModelComponent* modelComponent = entity->getComponent<ModelComponent>()) {
        ModelData& modelData = editor.context->modelSystem->getData<ModelData>(modelComponent);
        if (!modelData.isResourcesLoaded()) {
          if (HandleIsValid(modelComponent->model)) {
            // ModelSystem does not inform that loading is completed. Assume loaded when fraction = 1.
            const float progressFrac = editor.context->modelSystem->getLoadProgress(modelComponent);
            if (progressFrac < 1.0f) {
              if (modelComponent->model->isLoaded()) {
                descend = ImGui::TreeNodeEx(header, flags, "%s (uploading %d%%)",
                                            header, static_cast<int>(100.f * progressFrac));
              }
              else {
                descend = ImGui::TreeNodeEx(header, flags, "%s (loading %d%%)",
                  header, static_cast<int>(100.f * progressFrac));
              }
 
              descendChecked = true;
            }
          }
        }
      }
 
      if (!descendChecked) {
        descend = ImGui::TreeNodeEx(header, flags, "%s", header);
 
        // Tree node context menu
        if (ImGui::BeginPopupContextItem(nullptr)) {
          // If current item was not selected, make it a selection
          if (!editor.isSelected(entity->getId())) {
            editor.setSelection(entity->getId());
          }
          if (ImGui::MenuItem("Focus", nullptr, nullptr, editor.hasSelected())) {
            editor.editor->focusSelected();
          }
          ImGui::Separator();
          if (ImGui::MenuItem("Copy", nullptr, nullptr, editor.hasSelected())) {
            editor.editor->copy();
          }
          if (ImGui::MenuItem("Paste as Child", nullptr, nullptr, editor.numSelected() == 1U && editor.copied.IsArray())) {
            editor.editor->paste();
          }
          ImGui::Separator();
          if (ImGui::MenuItem("Copy name", nullptr, nullptr, editor.numSelected() == 1U)) {
            ImGui::SetClipboardText(header);
            LOG_DEBUG(logger, "Copied \"%s\" to clipboard", header);
          }
          static std::array<char, 512> buffer;
          if (editor.numSelected() == 1U) {
            snprintf(buffer.data(), buffer.size(), "%s", entity->getName().c_str());
            ImGui::SetNextItemWidth(200);
            if (ImGui::InputText("Rename", buffer.data(), buffer.size(), ImGuiInputTextFlags_EnterReturnsTrue)) {
              entity->setName(buffer.data());
            }
          }
          else {
            ImGui::MenuItem("Rename", nullptr, nullptr, false);
          }
          ImGui::EndPopup();
        }
      }
    }
 
 
    if (descend) {
      if (ImGui::IsItemClicked()) {
        picked = entity;
      }
 
      if (sceneComponent) {
        for (auto & child : sceneComponent->children) {
          auto p = showEntity(editor, child.get());
 
          picked = p ? p : picked;
        }
      }
 
      ImGui::TreePop();
    } else {
      if (ImGui::IsItemClicked()) {
        picked = entity;
      }
    }
 
    ImGui::PopID();
 
    return picked;
  }
}
 
Cogs::Core::EditorState * Cogs::Core::Editor::getState()
{
  return state.get();
}
 
void Cogs::Core::Editor::showText(const char* format, ...) const {
  // Using a read-only InputEdit instead of a Text element, so we can highlight and copy text from it.
  // Try to style it to get it looking like a normal label.
  char buff[256];
  va_list args;
  va_start(args, format);
  int ret = std::vsnprintf(buff, sizeof(buff), format, args);
  va_end(args);
  if (ret < 0) {
    LOG_ERROR_ONCE(logger, "Internal error: Format: %s", format);
    buff[0] = '\0';
  }
 
  ImGui::PushStyleVar(ImGuiStyleVar_FramePadding, ImVec2(0.f, 0.f));
  ImGui::PushStyleVar(ImGuiStyleVar_FrameBorderSize, 0.f);
  ImGui::PushStyleColor(ImGuiCol_FrameBg, ImGui::GetStyleColorVec4(ImGuiCol_WindowBg));
 
  bool prevCursorBlink = ImGui::GetIO().ConfigInputTextCursorBlink;
  ImGui::GetIO().ConfigInputTextCursorBlink = false;
 
  ImGui::PushID(textElementId++);
  ImGui::InputText("##", buff, 256, ImGuiInputTextFlags_ReadOnly);
  ImGui::PopID();
 
  ImGui::GetIO().ConfigInputTextCursorBlink = prevCursorBlink;
 
  ImGui::PopStyleColor();
  ImGui::PopStyleVar();
  ImGui::PopStyleVar();
}
 
bool Cogs::Core::Editor::showModel(ModelHandle & modelHandle)
{
  std::vector<const char *> combos;
 
  if (modelHandle) {
    ImguiRenderer* guiRenderer = context->renderer->getGuiRenderer();
    guiRenderer->addTextToGlyphBuilder(modelHandle->getName().to_string().c_str());
 
    showText("%s", modelHandle->getName().to_string().c_str());
  } else {
    showText("Empty");
    ImGui::SameLine();
 
    if (imageButton(Icon::Open, 26, 2)) {
      auto fileName = Cogs::Desktop::getOpenFileName(context->getDefaultView()->refWindowData(), "Model files (*.fbx;*.gltf;*.glb;*.obj;*.cogsbin;*.stp;*.dxf)\0*.fbx;*.gltf;*.glb;*.obj;*.cogsbin;*.stp;*.dxf\0All Files\0*.*\0");
 
      if (fileName.size()) {
        ModelLoadInfo & loadInfo = *context->modelManager->createLoadInfo();
        loadInfo.resourceId = NoResourceId;
        loadInfo.resourcePath = std::move(fileName);
        loadInfo.resourceName = IO::fileName(loadInfo.resourcePath);
        loadInfo.loadFlags = (ResourceLoadFlags)ModelLoadFlags::None;
        loadInfo.modelFlags = ModelLoadFlags::None;
 
        modelHandle = context->modelManager->loadResource(&loadInfo);
 
        return true;
      }
    }
  }
 
  return false;
}
 
bool Cogs::Core::Editor::showTexture(const StringView & header, TextureHandle & textureHandle)
{
  TextureHandle oldValue = textureHandle;
 
  showText("%s", header.to_string().c_str());
 
  ImGui::SameLine();
 
  if (textureHandle) {
    ImguiRenderer* guiRenderer = context->renderer->getGuiRenderer();
    guiRenderer->addTextToGlyphBuilder(textureHandle->getName().to_string().c_str());
 
    showText("%s", textureHandle->getName().to_string().c_str());
  } else {
    showText("Empty");
  }
 
  ImGui::SameLine();
 
  ImGui::PushID(&textureHandle);
 
  if (imageButton(Icon::Open, 26, 2)) {
    auto fileName = Desktop::getOpenFileName(context->getDefaultView()->refWindowData(), "Texture Files (*.png;*.jpeg;*.jpg;*.tga;*.dds)\0*.png;*.jpeg;*.jpg;*.tga;*.dds;*.bmp\0All Files\0*.*\0");
 
    if (fileName.size()) {
      bool linear = fileName.find("norm") != StringView::NoPosition;
      linear |= fileName.find("Norm") != StringView::NoPosition;
      linear |= fileName.find("Spec") != StringView::NoPosition;
      linear |= fileName.find("spec") != StringView::NoPosition;
      linear |= fileName.find("tang") != StringView::NoPosition;
      linear |= fileName.find("Tang") != StringView::NoPosition;
      linear |= fileName.find("gloss") != StringView::NoPosition;
      linear |= fileName.find("Gloss") != StringView::NoPosition;
 
      TextureLoadInfo & loadInfo = *context->textureManager->createLoadInfo();
      loadInfo.resourceId = NoResourceId;
      loadInfo.resourcePath = std::move(fileName);
      loadInfo.resourceName = IO::fileName(loadInfo.resourcePath);
      loadInfo.loadFlags = (ResourceLoadFlags)(linear ? TextureLoadFlags::LinearColorSpace : TextureLoadFlags::None);
 
      textureHandle = context->textureManager->loadResource(&loadInfo);
 
      context->scene->addResource(textureHandle);
    }
  }
 
  ImGui::PopID();
 
  return textureHandle != oldValue;
}
 
bool Cogs::Core::Editor::showMaterialInstance(FieldInfo & fieldInfo, MaterialInstanceHandle & materialInstanceHandle)
{
  return materialEditor->showMaterialInstance(fieldInfo, materialInstanceHandle);
}
 
void Cogs::Core::Editor::showEntities()
{
  auto store = context->store;
  auto & entities = store->getEntities();
 
  Entity * picked = nullptr;
 
  if (state->getSelected()) {
    state->selectedPath.clear();
 
    auto parent = store->getEntityParent(state->getSelected());
 
    while (parent) {
      state->selectedPath.push_back(parent);
 
      parent = store->getEntityParent(parent);
    }
  }
 
  for (auto & e : entities) {
    const EntityPtr & entity = e.second;
 
    if (!entity) continue;
 
    const TransformComponent* transformComponent = entity->getComponent<TransformComponent>();
 
    if (!transformComponent || (transformComponent && !transformComponent->parent)) {
      Entity* p = showEntity(*state, entity.get());
 
      picked = p ? p : picked;
    }
  }
 
  const Keyboard& keyboard = context->getDefaultView()->refKeyboard();
  SelectMode mode = SelectMode::Exclusive;
 
  if (keyboard.isKeyDown(Key::Shift)) {
    mode = SelectMode::Add;
  } else if (keyboard.isKeyDown(Key::Control)) {
    mode = SelectMode::Toggle;
  }
 
  if (picked && (picked != state->getSelected() || mode == SelectMode::Toggle)) {
    apply<SelectCommand>(picked->getId(), mode);
  }
 
  // Context menu for Entity tree viewer, when right clicked on the empty widget space
  if (ImGui::BeginPopupContextWindow(nullptr, ImGuiPopupFlags_MouseButtonRight + ImGuiPopupFlags_NoOpenOverItems)) {
    if (ImGui::MenuItem("Paste at Root level", nullptr, nullptr, state->copied.IsArray())) {
      state->clearSelection();
      paste();
    }
    if (ImGui::MenuItem("Clear selection", nullptr, nullptr, state->hasSelected())) {
      state->clearSelection();
    }
    ImGui::EndPopup();
  }
 
  // Clear selection if left clicked on the empty Entity Editor widget space
  if (ImGui::IsWindowHovered() && ImGui::IsMouseClicked(ImGuiMouseButton_Left) &&
    !picked && !ImGui::IsPopupOpen(nullptr, ImGuiPopupFlags_AnyPopupId + ImGuiPopupFlags_AnyPopupLevel))
  {
    state->clearSelection();
  }
}
 
void Cogs::Core::Editor::showEntityDetails(Entity * entity)
{
  Cogs::Core::EntityEditor::showEntityEditor(context, this, entity);
}
 
void Cogs::Core::Editor::showGizmo()
{
  Cogs::Core::EntityEditor::showEntityGizmo(context, this);
}
 
void Cogs::Core::Editor::selectLayer(ComponentModel::Entity* entity, StringView layer)
{
  LOG_DEBUG(logger, "Selecting Layer: %s", layer.to_string().data());
  bool anyVisible = recursiveSetVisibility(entity,
    [&layer](Cogs::ComponentModel::Entity* entityPtr, bool anyChildVisible) {
      Cogs::Core::PropertiesComponent* propertiesComponent = entityPtr->getComponent< Cogs::Core::PropertiesComponent>();
      if (propertiesComponent) {
        Cogs::StringView layerProperty = propertiesComponent->properties.getProperty("_rvmLayer", "");
        if (layer == layerProperty) {
          return true;
        }
      }
 
      return anyChildVisible;
    });
 
  if (anyVisible) {
    ensureEntityVisible(context, entity);
  }
}
 
void Cogs::Core::Editor::setLayerVisibility(ComponentModel::Entity* entity, StringView layer, bool visible)
{
  LOG_DEBUG(logger, "Set Layer: %s. Visible: %s", layer.to_string().data(), visible ? "true" : "false");
  bool anyVisible = recursiveSetVisibility(entity,
    [&layer, visible](Cogs::ComponentModel::Entity* entityPtr, bool /*anyChildVisible*/) {
      auto propertiesComponent = entityPtr->getComponent< Cogs::Core::PropertiesComponent>();
      if (propertiesComponent) {
        Cogs::StringView layerProperty = propertiesComponent->properties.getProperty("_rvmLayer", "");
        if (layer == layerProperty) {
          return visible;
        }
      }
 
      auto sceneComponent = entityPtr->getComponent<Cogs::Core::SceneComponent>();
      return sceneComponent ? sceneComponent->visible : true;
    });
 
  if (anyVisible) {
    ensureEntityVisible(context, entity);
  }
 
}
 
bool Cogs::Core::Editor::getLayerVisibility(const ComponentModel::Entity* entity, StringView layer)
{
  bool anyVisible = recursiveGetVisibility(entity,
    [&layer](const Cogs::ComponentModel::Entity* entity) {
      auto sceneComponent = entity->getComponent<Cogs::Core::SceneComponent>();
      if (sceneComponent) {
        auto propertiesComponent = entity->getComponent< Cogs::Core::PropertiesComponent>();
        if (propertiesComponent) {
          Cogs::StringView layerProperty = propertiesComponent->properties.getProperty("_rvmLayer", "");
          if (layer == layerProperty) {
            return sceneComponent->visible;
          }
        }
      }
 
      return false;
    });
 
  return anyVisible;
}
 
bool Cogs::Core::Editor::isStandardEntity(const Cogs::ComponentModel::Entity* entity) const
{
  for (const Cogs::Core::WeakEntityPtr& stdEntity : standardEntities) {
    if (stdEntity.lock().get() == entity) {
      return true;
    }
  }
 
  auto cameraComponent = entity->getComponent< Cogs::Core::CameraComponent>();
  if (cameraComponent) {
    return true;
  }
 
  return false;
}
 
bool Cogs::Core::Editor::isUserRootEntity(const Cogs::ComponentModel::Entity* entity) const
{
  if (isStandardEntity(entity)) {
    return false;
  }
 
  if (context->store->getEntityParent(entity)) {
    return false;
  }
 
  return true;
}
 
void Cogs::Core::Editor::exportScene(const StringView & path)
{
  ExportCommand exportCommand(state.get(), NoEntity);
  auto & o = exportCommand.options.emplace_back();
  o.key = "fileName";
  o.value = path.to_string();
  o.type = ParsedDataType::String;
  exportCommand.apply();
}
 
Cogs::Core::EntityIds Cogs::Core::Editor::getSelected() const
{
  return state->selected;
}
 
void Cogs::Core::Editor::select(const EntityIds & ids, SelectMode mode)
{
  apply<SelectCommand>(ids, mode);
}
 
Cogs::Core::EditorCommand * Cogs::Core::Editor::createCommand(const StringView & /*key*/)
{
  return nullptr;
}
 
void Cogs::Core::Editor::createEntity(const StringView & type, const StringView & name)
{
  apply<CreateEntityCommand>(type, name, false);
}
 
bool Cogs::Core::Editor::imageButton(Icon icon, int size, int padding)
{
  auto texture = state->icons[(int)icon];
 
  Renderer* renderer = dynamic_cast<Renderer*>(context->renderer);
  RenderTexture* renderTexture = renderer->getRenderResources().getRenderTexture(context->textureManager->generateHandle((Texture *)texture.resolve()));
 
  if (renderTexture && HandleIsValid(renderTexture->textureHandle)) {
    auto textureId = ImTextureID(renderTexture->textureHandle.handle);
 
    int textureSize = size - padding * 2;
    if (ImGui::ImageButton("", textureId, ImVec2((float)textureSize, (float)textureSize), ImVec2(0, 1), ImVec2(1, 0))) {
      return true;
    }
  }
 
  return false;
}
 
void Cogs::Core::Editor::clear(bool interactive)
{
  const bool askSave = ::getBoolVariable(context, "editor.askSave");
  if (interactive && askSave &&  commands.size()) {
    auto result = Desktop::showMessageBox(context->getDefaultView()->refWindowData(), "Save changes before clearing?", "Save Changes", Desktop::MessageBoxType::YesNoCancel, Desktop::MessageBoxIcon::Question);
 
    if (result == Desktop::MessageBoxResult::Cancel) return;
    else if (result == Desktop::MessageBoxResult::Yes) saveAs();
  }
 
  state->clearSelection();
 
  clearCommands();
 
  context->scene->clear();
  context->scene->setup(true);
}
 
void Cogs::Core::Editor::openInternal(const StringView& path, bool openInRoot, bool synchronous, bool interactive)
{
  if (path.empty()) {
    LOG_ERROR(logger, "Trying to open a file without a file path");
    return;
  }
 
  std::string pathStr = path.to_string();
  std::string extension = ::toLower(IO::extension(pathStr));
  std::string name = IO::stem(pathStr);
  state->directory = IO::parentPath(pathStr);
 
  if (extension == ".scene") {
    Cogs::Desktop::MessageBoxResult result = Desktop::MessageBoxResult::Yes;
    if (interactive) {
      result = Desktop::showMessageBox(context->getDefaultView()->refWindowData(), "Clear Scene before loading?", "Clear Scene", Desktop::MessageBoxType::YesNoCancel, Desktop::MessageBoxIcon::Question);
    }
 
    // Parent Entity is selected if only one selected.
    EntityId parentId = openInRoot ? NoEntity : state->getSelectedId();
 
    if (result == Desktop::MessageBoxResult::Yes) {
      clear(false);
      ::loadScene(context, pathStr.data(), int(AssetLoadFlags::ClearScene));
      state->editorCamera = getEditorCamera(context);
    }
    else if (result == Desktop::MessageBoxResult::No) {
      if (parentId == NoEntity) {
        ::loadScene(context, pathStr.data(), int(AssetLoadFlags::None));
      }
      else {
        ::loadAsset(context, pathStr.data(), parentId, int(AssetLoadFlags::None));
      }
    }
  }
  else if (extension == ".json" && name == "metadata") {
    std::string entityName = IO::stem(state->directory);
 
    // Remove Twin full name, e.g. "XXX\Level 1\full\metadata.json" => "Level 1".
    if (entityName == "full") {
      entityName = IO::stem(IO::parentPath(state->directory));
    }
 
    if (ExtensionRegistry::loadExtensionModule("Cogs.Core.Extensions.PoTree")) {
      auto createCommand = apply<CreateEntityCommand>("PotreeModel", entityName, openInRoot);
      createCommand->permanentUndo = true;
      Entity* potreeModel = state->getSelected();
      if (potreeModel) {
        auto potreeComponent = potreeModel->getComponent<PotreeComponent>();
        if (potreeComponent) {
          potreeComponent->source = pathStr;
          potreeComponent->coloring = PotreeColoring::Color;
          potreeComponent->outlineSize = 0.0f;
          potreeComponent->shading = PotreeShading::Flat;
          potreeComponent->pointShape = PotreePointShape::Disc;
          potreeComponent->setChanged();
 
          if (context->store->getEntityParent(potreeModel) != nullptr) {
            // Auto origin sets TransformComponent coordinates which is ignored for child entities.
            LOG_INFO(logger, "Disabling PoTree auto origin when PoTree is not root entity");
            potreeComponent->originPolicy = PotreeOriginPolicy::None;
            potreeComponent->setChanged();
          }
        }
 
        // Move and fix camera to PoTree camera position for single scans IF scanner position known.
        parseCameraPosition(context, IO::combine(state->directory, "ScannerPosition.pos"), false, state.get());
      }
      else {
        LOG_ERROR(logger, "Could not create Entity PotreeModel");
      }
    }
    else {
      LOG_ERROR(logger, "Could not load extension: Cogs.Core.Extensions.PoTree");
    }
  }
  else if (extension == ".json" && name == "360") {
    std::string entityName = IO::stem(state->directory);
 
    if (ExtensionRegistry::loadExtensionModule("Cogs.Core.Extensions.Image360")) {
      auto createCommand = apply<CreateEntityCommand>("Image360", entityName, openInRoot);
      createCommand->permanentUndo = true;
      Entity* image360 = state->getSelected();
      if (image360) {
        auto image360Component = image360->getComponent<Image360Component>();
        if (image360Component) {
          image360Component->source = pathStr;
          image360Component->setChanged();
 
          // Move and fix Camera Position from optional file. Move 360 image to fit position
          CameraSetupData pos = parseCameraPosition(context, IO::combine(state->directory, "ScannerPosition.pos"), true, state.get());
          TransformComponent* transformComponent = image360->getComponent<TransformComponent>();
 
          if (context->store->getEntityParent(image360)) {
            transformComponent->position = pos.position;
          }
          else {
            transformComponent->coordinates = pos.position;
          }
 
          transformComponent->rotation = pos.rotation;
          transformComponent->setChanged();
        }
      }
      else{
        LOG_ERROR(logger, "Could not create Entity Image360");
      }
    }
    else {
      LOG_ERROR(logger, "Could not load extension: Cogs.Core.Extensions.Image360");
    }
  }
  else if (extension == ".asset" || ::toLower(pathStr).find(".asset.zst") != std::string::npos) {
 
    // Open an Asset with LOD support.
    auto createCommand = apply<CreateEntityCommand>("Asset", name, openInRoot);
    createCommand->permanentUndo = true;
 
    Entity* selected = state->getSelected();
    if (selected) {
      auto assetComponent = selected->getComponent<AssetComponent>();
      assetComponent->flags = AssetFlags::InstantiateOnDemand | AssetFlags::RelativePaths | AssetFlags::OverrideMaterial;
      assetComponent->asset = context->assetManager->loadAsset(pathStr, Core::NoResourceId, Core::AssetLoadFlags::None);
      assetComponent->setChanged();
 
      addAssetTags(context, selected, pathStr);
    }
    else {
      LOG_ERROR(logger, "Could not create Entity Asset");
    }
  }
  else if (extension == ".rvm" || extension == ".rvmdump" || extension == ".vue") {
    if (interactive) {
      apply<LoadRvmCommand>(path, openInRoot, synchronous);
    }
    else {
      // Open the file without showing the dialog, non-modal
      LoadRvmCommand loadRvmCommand(state.get(), path, openInRoot, synchronous);
      loadRvmCommand.loadFile();
    }
  }
  else {
    auto createCommand = apply<CreateEntityCommand>("ModelEntity", name, openInRoot);
    createCommand->permanentUndo = true;
 
    auto selected = state->getSelected();
 
    if (selected) {
      auto modelComponent = selected->getComponent<ModelComponent>();
      modelComponent->model = context->modelManager->loadModel(pathStr, NoResourceId, ModelLoadFlags::DisableOptimization | (synchronous ? ModelLoadFlags::ForceSynchronous : ModelLoadFlags::None));
      modelComponent->waitForSubresources = false;
      modelComponent->setChanged();
    }
    else {
      LOG_ERROR(logger, "Could not create Entity ModelEntity");
    }
  }
}
 
void Cogs::Core::Editor::open(const StringView& path, bool openInRoot, bool synchronous)
{
  if (path.empty()) {
    // Caled without a file path, ask user to select a file or files to open
    std::vector<std::string> files(Desktop::getOpenFileNames(context->getDefaultView()->refWindowData(), "Editor File (*.scene, *.asset, *.assbin, *.asset.zst, 360.json, metadata.json, *.obj, *.fbx, *.gltf, *.glb, *.rvm, *.rvmdump, *.cogsbin, *.vue, *.dxf)\0*.scene;*.asset;*.assbin;*.asset.zst;360.json;metadata.json;*.obj;*.fbx;*.gltf;*.glb;*.rvm;*.rvmdump;*.cogsbin;*.vue;*.dxf\0All Files\0*.*\0", nullptr));
 
    // Alow further user interaction only if a single file has been selected
    bool interactive = (files.size() == 1);
 
    // Reset selection for multi file import to import all on same level.
    EntityIds oldSelected = state->selected;
    EntityIds ids;
    ids.reserve(oldSelected.size());
    for (const std::string& file : files) {
      if (!file.empty()) {
        openInternal(file, openInRoot, synchronous, interactive);
        ids.insert(ids.end(), state->getAllSelectedIds().begin(), state->getAllSelectedIds().end());
      }
      if (!openInRoot && file != files.back()) {
        state->setSelection(oldSelected);
      }
    }
 
    if (!ids.empty()) {
      state->setSelection(ids);
    }
  }
  else {
    // Called with a file path, e.g. from a command line. Do not show dialogs (interactive = false)
    EntityIds oldSelected = state->selected;
    openInternal(path, openInRoot, synchronous, false);
    oldSelected.push_back(state->getSelectedId());
    state->setSelection(oldSelected);
  }
}
 
void Cogs::Core::Editor::save()
{
  if (state->fileName.size()) {
    const std::string out = state->fileName;
 
    ::writeAsset(context, out.data(), NoEntity, int(AssetWriteFlags::None));
  } else {
    saveAs();
  }
}
 
void Cogs::Core::Editor::saveAs()
{
  auto saveFile = Desktop::getSaveFileName(context->getDefaultView()->refWindowData(), state->fileName, "Scene Files (*.scene)\0*.scene\0All Files\0*.*\0");
 
  if (saveFile.empty()) {
    return;
  }
 
  state->fileName = saveFile;
 
  if (IO::extension(state->fileName).empty()) {
    state->fileName += ".scene";
  }
 
  ::writeAsset(context, state->fileName.data(), NoEntity, int(AssetWriteFlags::None | AssetWriteFlags::Hierarchy));
}
 
void Cogs::Core::Editor::saveIncremental()
{
  if (state->fileName.empty()) {
    saveAs();
    return;
  }
 
  auto fileName = IO::fileName(state->fileName);
  auto extension = IO::extension(fileName);
  auto extIt = fileName.rfind(extension);
 
  auto name = fileName.substr(0, extIt);
 
  auto firstDigit = std::find_if(name.begin(), name.end(), [](const char & c) { return ::isdigit(c); });
 
  int number = 0;
 
  if (firstDigit != name.end()) {
    auto digits = std::string(firstDigit, name.end());
    number = atoi(digits.c_str());
  } else {
    number = 0;
  }
 
  ++number;
  char buffer[2048];
  snprintf(buffer, sizeof(buffer), "%03d", number);
 
  name += std::string(buffer);
  name += extension;
 
  auto path = IO::parentPath(state->fileName);
  path = IO::combine(path, name);
 
  if (path.empty()) return;
 
  state->fileName = path;
 
  save();
}
 
void Cogs::Core::Editor::importStatic()
{
  bool openInRoot = true;
  auto files = Desktop::getOpenFileNames(context->getDefaultView()->refWindowData(), "Editor File (*.obj, *.gltf, *.glb, *.fbx, *.cogsbin, *.dxf)\0*.obj;*.gltf;*.glb;*.fbx;*.cogsbin;*.dxf\0All Files\0*.*\0", nullptr);
 
  if (files.empty()) return;
 
  state->clearSelection();
  state->directory = IO::parentPath(files.front());
 
  EntityIds ids;
 
  for (const std::string & fileName : files) {
    std::string ext = IO::extension(fileName);
 
    if (is3dModelFileFormat(ext)) {
      std::string name = IO::stem(fileName);
 
      apply<CreateEntityCommand>("StaticModel", name, openInRoot);
 
      const Entity* selected = state->getSelected();
      if (selected) {
        StaticModelComponent* modelComponent = selected->getComponent<StaticModelComponent>();
        modelComponent->model = context->modelManager->loadModel(fileName, NoResourceId, ModelLoadFlags::DisableOptimization);
        modelComponent->setChanged();
 
        ids.push_back(selected->getId());
      }
      else {
        LOG_ERROR(logger, "Could not create Entity StaticModel");
      }
    }
  }
 
  if (!ids.empty()) {
    state->setSelection(ids);
  }
}
 
void Cogs::Core::Editor::exportEntities(bool exportScene)
{
  if (!exportScene && !state->hasSelected()) {
    LOG_WARNING(logger, "exportSelected: No entity selected.");
    return;
  }
 
  auto [saveFile, filterIndex] = Desktop::getSaveFileNameExt(context->getDefaultView()->refWindowData(), state->fileName, "Cogsbin Files (*.cogsbin)\0*.cogsbin;\0GL Transmission Format (*.gltf)\0*.gltf;\0GL Binary (*.glb)\0*.glb\0");
 
  if (saveFile.empty()) {
    LOG_WARNING(logger, "exportEntities: No filename");
    return;
  }
 
  if (filterIndex == 1) {
    ExportCommand exportCommand(state.get(), state->getSelectedId(), exportScene);
    auto& option = exportCommand.options.emplace_back();
    option.key = "fileName";
    option.value = fs::path(saveFile).replace_extension(".cogsbin").string();
    exportCommand.apply();
  }
  else {
    auto path = IO::parentPath(saveFile);
    auto name = IO::stem(saveFile);
    if (filterIndex == 2) {
      apply<ExportGltfCommand>(path, name, false, exportScene);
    }
    else if (filterIndex == 3) {
      apply<ExportGltfCommand>(path, name, true, exportScene);
    }
  }
}
 
void Cogs::Core::Editor::cut()
{
  if (!state->hasSelected()) return;
 
  copy();
 
  apply<DestroyCommand>(state->selected, true);
}
 
void Cogs::Core::Editor::copy()
{
  if (!state->hasSelected()) return;
 
  EntityIds ids;
  RemoveEntitiesWithAncestors(context, state->selected, ids);
 
  Document d;
  d.SetArray();
  const AssetWriteFlags writeFlags = AssetWriteFlags::Geometry | AssetWriteFlags::Hierarchy;
 
  for (const EntityId s : ids) {
    Value entityValue;
    entityValue.SetObject();
 
    writeEntity(context, context->store->getEntityPtr(s), entityValue, d, nullptr, writeFlags);
 
    d.PushBack(entityValue, d.GetAllocator());
  }
 
  state->copied = std::move(d);
}
 
void Cogs::Core::Editor::paste()
{
  if (!state->copied.IsArray()) return;
 
  apply<PasteEntityCommand>();
}
 
void Cogs::Core::Editor::invokeCommand(const StringView & /*key*/)
{
 
}
 
void Cogs::Core::Editor::destroy()
{
  if (!state->hasSelected()) return;
 
  apply<DestroyCommand>(state->selected, true);
}
 
void Cogs::Core::Editor::destroyPermanently()
{
  if (!state->hasSelected()) return;
 
  apply<DestroyCommand>(state->selected, false);
}
 
void Cogs::Core::Editor::changeMode(EditingMode mode)
{
  if (mode != state->mode) {
    apply<ChangeEditingModeCommand>(mode);
  }
}
 
void Cogs::Core::Editor::focusSelected()
{
  if (!state->hasSelected()) return;
 
  Cogs::Geometry::DBoundingBox bb;
 
  for (EntityId id : state->getAllSelectedIds()) {
    Cogs::Geometry::DBoundingBox bbb;
    ::calculateBoundingBoxWorld(context, id, bbb.data());
 
    bb += bbb;
  }
 
  focusBoundingBox(bb);
}
 
void Cogs::Core::Editor::focusAll()
{
  Geometry::DBoundingBox bb;
 
  for (const auto& e : context->store->getEntities()) {
    const EntityPtr & entity = e.second;
 
    if (!entity) continue;
 
    const TransformComponent* transformComponent = entity->getComponent<TransformComponent>();
 
    if (transformComponent && !transformComponent->parent) {
      Geometry::DBoundingBox bbb;
      ::calculateBoundingBoxWorld(context, entity->getId(), bbb.data());
 
      bb += bbb;
    }
  }
 
  if (isEmpty(bb)) {
    LOG_WARNING(logger, "Scene bounding box is empty.");
  }
  else {
    focusBoundingBox(bb);
  }
}
 
bool Cogs::Core::Editor::focusBoundingBox(const Cogs::Geometry::DBoundingBox& boundingBox)
{
  if (isEmpty(boundingBox)) {
    LOG_DEBUG(logger, "focusBoundingBox bounds: Empty");
  }
  else {
    LOG_DEBUG(logger, "focusBoundingBox bounds: [%.2f %.2f %.2f] x [%.2f %.2f %.2f]",
      boundingBox.min.x, boundingBox.min.y, boundingBox.min.z,
      boundingBox.max.x, boundingBox.max.y, boundingBox.max.z);
  }
 
  EntityPtr camera = state->editorCamera.lock();
  if (!camera) {
    return false;
  }
 
  // Need extent (hasExtent(bbox) too strict requiring min<max for all XYZ).
  if (isEmpty(boundingBox) || Cogs::Utility::CameraHelper::getRadius(boundingBox) == 0.0f) {
    return false;
  }
 
  // Calculate viewAll + update Components.
  // Not perfectly centered due to camera viewport offset used for imgui panels.
 
  CameraComponent* cameraComponent = state->editorCamera.lock()->getComponent<CameraComponent>();
  TransformComponent* transformComponent = state->editorCamera.lock()->getComponent<TransformComponent>();
  OrbitingCameraController* orbitingCameraController = state->editorCamera.lock()->getComponent<OrbitingCameraController>();
  ProjectionMode projectionMode = cameraComponent->projectionMode;
  glm::vec2 viewport = cameraComponent->viewportSize;
 
  // Update camera:
  const glm::dvec3 cameraPos = Cogs::Utility::CameraUtils::viewAll(cameraComponent, transformComponent, orbitingCameraController, projectionMode,
    boundingBox, viewport);
 
  // Use camera Focal Point as new Origin:
  const glm::quat orientation = Cogs::Utility::CameraUtils::getCameraOrientation(transformComponent, camera->getComponent<OrbitingCameraController>());
  const glm::dvec3 focalPos = Cogs::Utility::CameraHelper::getFocalPosition(cameraPos, orientation, cameraComponent->focalDistance);
  ::setOrigin(context, glm::value_ptr(focalPos));
  LOG_DEBUG(logger, "Scene Origin set to: [%.2f %.2f %.2f]", focalPos.x, focalPos.y, focalPos.z);
  return true;
}
 
void Cogs::Core::Editor::setStatusbarText(const std::string& text, bool guiStatus)
{
  statusbarText = text;
  guiStatusInStatusbar = guiStatus;
}
 
 
namespace {
  enum class FurthestFlags {
    None = 0,
    X = 1,
    Y = 2,
    Z = 4,
    All = 7
  };
  ENABLE_ENUM_FLAGS(FurthestFlags)
 
 
  void recurseSelectFurthest(Cogs::ComponentModel::Entity** furthest,
    double& distance,
    const Cogs::Geometry::DBoundingBox & selectedBbox,
    Cogs::ComponentModel::Entity* entity,
    Cogs::Core::Context* context,
    FurthestFlags options)
  {
    // Only check leaf nodes
    auto sceneComponent = entity->getComponent<Cogs::Core::SceneComponent>();
    if (sceneComponent && sceneComponent->visible) {
      if (sceneComponent->children.empty()) {
        Cogs::Geometry::DBoundingBox bb;
        ::calculateBoundingBoxWorld(context, entity->getId(), bb.data());
 
        double xDist = 0;
        double yDist = 0;
        double zDist = 0;
        if (!isEmpty(bb)) {
          if ((options & FurthestFlags::X) != FurthestFlags::None) {
            xDist = std::max(xDist, selectedBbox.min.x - bb.max.x);
            xDist = std::max(xDist, bb.min.x - selectedBbox.max.x);
          }
          if ((options & FurthestFlags::Y) != FurthestFlags::None) {
            yDist = std::max(yDist, selectedBbox.min.y - bb.max.y);
            yDist = std::max(yDist, bb.min.y - selectedBbox.max.y);
          }
          if ((options & FurthestFlags::Z) != FurthestFlags::None) {
            zDist = std::max(zDist, selectedBbox.min.z - bb.max.z);
            zDist = std::max(zDist, bb.min.z - selectedBbox.max.z);
          }
        }
 
        double sqrDist = double(xDist) * double(xDist) + double(yDist) * double(yDist) + double(zDist) * double(zDist);
        if (sqrDist > distance) {
          distance = sqrDist;
          *furthest = entity;
        }
      }
      else {
        for (const auto& child : sceneComponent->children) {
          recurseSelectFurthest(furthest, distance, selectedBbox, child.get(), context, options);
        }
      }
    }
  }
}
 
void Cogs::Core::Editor::showHide(bool visible)
{
  // Hide or show all selected entities.
  for (const EntityId id : state->selected) {
    auto entity = context->store->getEntityPtr(id);
    if (entity) {
      auto* sceneComponent = entity->getComponent<Cogs::Core::SceneComponent>();
      if (sceneComponent) {
        recursiveSetVisibility(entity,
          [visible](Cogs::ComponentModel::Entity* /*entity*/, bool /*anyChildVisible*/) {
            return visible;
          });
 
        if (visible) {
          ensureEntityVisible(context, entity);
        }
      }
    }
  }
}
 
void Cogs::Core::Editor::hideUnselected()
{
  if (state->hasSelected()) {
    std::unordered_set<size_t> entityIds;
    std::vector<ComponentModel::Entity*> selectedEntities;
    std::unordered_set<size_t> selectedIds;
 
    for (const EntityId id : state->selected) {
      auto ptr = context->store->getEntityPtr(id);
      if (ptr) {
        selectedIds.insert(ptr->getId());
        addChildrenIds(ptr, entityIds);
      }
    }
 
    auto store = context->store;
    const auto& entities = store->getEntities();
 
    for (auto& e : entities) {
      if (isUserRootEntity(e.second.get())) {
        recursiveSetVisibility(e.second.get(),
          [&entityIds](Cogs::ComponentModel::Entity* entity, bool anyChildVisible) {
            bool visible = entityIds.find(entity->getId()) != std::end(entityIds);
            return visible || anyChildVisible;
          });
      }
    }
  }
}
 
void Cogs::Core::Editor::showAll()
{
  auto store = context->store;
  auto& entities = store->getEntities();
 
  for (auto& e : entities) {
    auto& entity = e.second;
 
    if (!entity) continue;
 
    auto rootSceneComponent = entity->getComponent<SceneComponent>();
    if (rootSceneComponent) {
      setVisibility(rootSceneComponent, true, true);
    }
  }
}
 
// Find entity furthest away from bounding box around selected entities.
// Control keys to limit search.
// Shift    = Ignore X-distance
// Control  = Ignore Y-distance
// Alt      = Ignore Z-distance
void Cogs::Core::Editor::selectFurthestAway()
{
  FurthestFlags flags = FurthestFlags::None;
  const Keyboard& keyboard = context->getDefaultView()->refKeyboard();
 
  if (!keyboard.isKeyDown(Key::Shift)) {
    flags |= FurthestFlags::X;
  }
  if (!keyboard.isKeyDown(Key::Control)) {
    flags |= FurthestFlags::Y;
  }
  if (!keyboard.isKeyDown(Key::Alt)) {
    flags |= FurthestFlags::Z;
  }
 
 
  if (state->hasSelected()) {
    std::unordered_set<size_t> entityIds;
 
    Geometry::DBoundingBox selectedBbox;
 
    for (const EntityId id : state->selected) {
      auto entity = context->store->getEntityPtr(id);
      if (entity) {
        auto sceneComponent = entity->getComponent<SceneComponent>();
        if (sceneComponent && sceneComponent->visible) {
          Geometry::DBoundingBox bb;
          ::calculateBoundingBoxWorld(context, id, bb.data());
          selectedBbox += bb;
        }
      }
    }
 
    if (isEmpty(selectedBbox)) {
      LOG_WARNING(logger, "selectFurthestAway: Selection bounding box is empty.");
      return;
    }
 
    double distance = 0;
    Cogs::ComponentModel::Entity* furthest = nullptr;
    if (!isEmpty(selectedBbox)) {
      for (const EntityId id : state->selected) {
        auto entity = context->store->getEntityPtr(id);
        if (entity) {
          auto root = getRootEntity(entity, context);
          recurseSelectFurthest(&furthest, distance, selectedBbox, root, context, flags);
        }
      }
    }
 
    if (distance > 0 && furthest) {
      LOG_DEBUG(logger, "Found Faraway land");
      EntityIds ids { furthest->getId() };
      apply<SelectCommand>(ids);
    }
  }
}
 
void Cogs::Core::Editor::invertVisibility()
{
  auto store = context->store;
  auto& entities = store->getEntities();
 
  for (auto& e : entities) {
    if (isUserRootEntity(e.second.get())) {
      setConsistentChildInvisibility(e.second.get());
      recursiveSetVisibility(e.second.get(),
        [](Cogs::ComponentModel::Entity* entity, bool anyChildVisible) {
          auto sceneComponent = entity->getComponent< Cogs::Core::SceneComponent>();
          if (sceneComponent) {
            return anyChildVisible || !sceneComponent->visible;
          }
 
          return anyChildVisible;
        });
    }
  }
}
 
void Cogs::Core::Editor::selectAll()
{
  EntityIds ids;
 
  for (auto& e : context->store->getEntities()) {
    const EntityPtr& entity = e.second;
    if (entity && !isStandardEntity(entity.get())) {
      if (state->getFindPattern().empty()) {
        ids.emplace_back(entity->getId());
      }
      else {
        recurseAddFindPatternMatches(*entity, state->getFindRegex(), ids);
      }
    }
  }
 
  apply<SelectCommand>(ids);
  setStatusbarText("Selected entity count: " + std::to_string(ids.size()), false);
}
 
void Cogs::Core::Editor::selectOne(EntityId id)
{
  EntityIds ids { id };
  apply<SelectCommand>(ids);
  setStatusbarText("Selected entity count: " + std::to_string(ids.size()), false);
}
 
void Cogs::Core::Editor::clearCommands()
{
  commands.clear();
  commandIndex = NoCommand;
}
 
void Cogs::Core::Editor::onlineHelp(bool generalHelp)
{
  if (generalHelp) {
    Cogs::Desktop::systemOpen("https://3dvstorage.blob.core.windows.net/$web/cogsdoc/core/index.html");
  }
  else {
    Cogs::Desktop::systemOpen("https://3dvstorage.blob.core.windows.net/$web/cogsdoc/core/md_Documentation_CogsCoreRuntime.html");
  }
}
 
void Cogs::Core::Editor::showLicenses()
{
  apply<ShowLicensesCommand>();
}
 
void Cogs::Core::Editor::showAbout()
{
  apply<AboutCommand>();
}
 
void Cogs::Core::Editor::undo()
{
  if (commandIndex != NoCommand) {
    auto & command = commands[commandIndex--];
    command->undo();
    if (command->permanentUndo) {
      commands.resize(commandIndex + 1);
    }
  }
}
 
void Cogs::Core::Editor::redo()
{
  ++commandIndex;
 
  if (commandIndex >= commands.size()) {
    commandIndex = commands.size() - 1;
    return;
  }
 
  modalCommand = dynamic_cast<ModalEditorCommand*>(commands[commandIndex].get());
 
  commands[commandIndex]->redo();
}
 
void Cogs::Core::EditorState::updateSelectedInfo()
{
  lastPickState.clear();
  if (selected.size() == 1) {
    const EntityId pickEntityId = selected[0];
    Entity* selectedEntity = context->store->getEntityPtr(pickEntityId);
    if (!selectedEntity) {
      lastPickState.clear();
      return;
    }
 
    const Entity* rootEntity = getRootEntity(selectedEntity, context);
    if (rootEntity) {
      lastPickState.rootId = rootEntity->getId();
      auto propsComponent = rootEntity->getComponent<Cogs::Core::PropertiesComponent>();
      if (propsComponent) {
        std::string tag;
        tag = propsComponent->properties.getProperty(std::to_string(this->pickId), std::string()).to_string();
        if (!tag.empty()) {
          lastPickState.details = "Tag: " + tag;
        }
      }
    }
 
    if (pickId >= 0) {
      lastPickState.pickId = std::to_string(pickId);
    }
 
    const Entity* assetGroupRoot = getRootEntity(selectedEntity, context, 2);
    const Entity* assetRoot = getRootEntity(selectedEntity, context, 1);
 
    if (assetGroupRoot) {
      lastPickState.assetRootGroupName = assetGroupRoot->getName();
    }
 
    Geometry::DBoundingBox globalBB;
    ::calculateBoundingBoxWorld(context, selectedEntity->getId(), globalBB.data());
 
    if (assetRoot && !isEmpty(globalBB)) {
      auto propsComponent = assetRoot->getComponent<Cogs::Core::PropertiesComponent>();
      if (propsComponent) {
        const auto rvmOrigin = propsComponent->properties.getProperty("_rvmOrigin", std::span<const float>());
        if (rvmOrigin.size() == 3) {
          // Shift BBox by rvmOrigin
          globalBB.min += glm::dvec3(rvmOrigin[0], rvmOrigin[1], rvmOrigin[2]);
          globalBB.max += glm::dvec3(rvmOrigin[0], rvmOrigin[1], rvmOrigin[2]);
        }
      }
    }
 
    if (!isEmpty(globalBB)) {
      char buffer[128] = {};
      snprintf(buffer, sizeof(buffer), "[%.2f %.2f %.2f] x [%.2f %.2f %.2f]",
        globalBB.min.x, globalBB.min.y, globalBB.min.z,
        globalBB.max.x, globalBB.max.y, globalBB.max.z);
      lastPickState.boundingBox = buffer;
    }
  }
}