EntityEditor.cpp

#include "EntityEditor.h"
 
#include "Renderer/IRenderer.h"
#include "Renderer/InspectorGui/InspectorGuiHelper.h"
#include "Renderer/InspectorGui/EntityInspector.h"
 
#include "MaterialEditor.h"
 
#include "Components/Core/PropertiesComponent.h"
 
#include "Systems/Core/TransformSystem.h"
#include "Systems/Core/CameraSystem.h"
 
#include "Resources/MaterialInstance.h"
#include "Resources/Mesh.h"
 
#include "Bridge/Bridge.h"
#include "Bridge/SceneFunctions.h"
 
#include "Commands/FieldCommands.h"
 
#include "Types.h"
 
#include "Foundation/Geometry/BoundingBox.hpp"
#include "Foundation/Reflection/TypeDatabase.h"
 
#include "imgui.h"
#include "ImGuizmo.h"
 
#include <bit>
#include <span>
 
using namespace Cogs::Reflection;
 
namespace
{
  void showPropertyStore(const Cogs::Core::Editor& editor, const Cogs::Core::PropertyStore& props) {
    std::span<const Cogs::Core::PropertyInfo> headers = props.getHeaders();
 
    for (const Cogs::Core::PropertyInfo& header : headers) {
      const std::string propName = props.getKey(header).to_string();
 
      switch(header.type) {
        case Cogs::Core::PropertyType::Bool: {
          editor.showText("%s: %s", propName.c_str(), header.boolValue ? "true" : "false");
          break;
        }
        case Cogs::Core::PropertyType::Integer: {
          editor.showText("%s: %d", propName.c_str(), header.intValue);
          break;
        }
        case Cogs::Core::PropertyType::Int2: {
          editor.showText("%s: (%d, %d)", propName.c_str(), header.int2Value[0], header.int2Value[1]);
          break;
        }
        case Cogs::Core::PropertyType::UnsignedInteger: {
          editor.showText("%s: %u", propName.c_str(), header.uintValue);
          break;
        }
        case Cogs::Core::PropertyType::UInt2: {
          editor.showText("%s: (%u, %u)", propName.c_str(), header.uint2Value[0], header.uint2Value[1]);
          break;
        }
        case Cogs::Core::PropertyType::Float: {
          editor.showText("%s: %f", propName.c_str(), header.floatValue);
          break;
        }
        case Cogs::Core::PropertyType::Float2: {
          editor.showText("%s: (%f, %f)", propName.c_str(), header.float2Value[0], header.float2Value[1]);
          break;
        }
        case Cogs::Core::PropertyType::Double: {
          editor.showText("%s: %f", propName.c_str(), header.doubleValue);
          break;
        }
        case Cogs::Core::PropertyType::StringRef: {
          editor.showText("%s: %s", propName.c_str(), Cogs::Core::Strings::getC(header.stringRefValue));
          break;
        }
        case Cogs::Core::PropertyType::String: {
          editor.showText("%s: %s", propName.c_str(), props.getString(header).to_string().c_str());
          break;
        }
        case Cogs::Core::PropertyType::FloatArray: {
          std::span<const float> floats = props.getFloatArray(header);
          if (floats.empty()) {
            editor.showText("%s: Empty", propName.c_str());
          }
          else {
            if (ImGui::TreeNode((propName + " [size=" + std::to_string(floats.size()) + "]").c_str())) {
              for (size_t i = 0; i < floats.size(); i++) {
                editor.showText("%zu: %f", i, floats[i]);
              }
              ImGui::TreePop();
            }
          }
          break;
        }
        case Cogs::Core::PropertyType::IntArray: {
          std::span<const int32_t> ints = props.getIntArray(header);
          if (ints.empty()) {
            editor.showText("%s: Empty", propName.c_str());
          }
          else {
            if (ImGui::TreeNode((propName + " [size=" + std::to_string(ints.size()) + "]").c_str())) {
              for (size_t i = 0; i < ints.size(); i++) {
                editor.showText("%zu: %d", i, ints[i]);
              }
              ImGui::TreePop();
            }
          }
          break;
        }
        case Cogs::Core::PropertyType::UIntArray: {
          std::span<const uint32_t> uints = props.getUIntArray(header);
          if (uints.empty()) {
            editor.showText("%s: Empty", propName.c_str());
          }
          else {
            if (ImGui::TreeNode((propName + " [size=" + std::to_string(uints.size()) + "]").c_str())) {
              for (size_t i = 0; i < uints.size(); i++) {
                editor.showText("%zu: %u", i, uints[i]);
              }
              ImGui::TreePop();
            }
          }
          break;
        }
        case Cogs::Core::PropertyType::DoubleArray: {
          std::span<const double> doubles = props.getDoubleArray(header);
          if (doubles.empty()) {
            editor.showText("%s: Empty", propName.c_str());
          }
          else {
            if (ImGui::TreeNode((propName + " [size=" + std::to_string(doubles.size()) + "]").c_str())) {
              for (size_t i = 0; i < doubles.size(); i++) {
                editor.showText("%zu: %f", i, doubles[i]);
              }
              ImGui::TreePop();
            }
          }
          break;
        }
        default: {
          assert(false && "Unsupported PropertyType");
        }
      }
    }
  }
}
 
void Cogs::Core::EntityEditor::showEntityEditor(Context* context, Editor* editor, ComponentModel::Entity* entity)
{
  editor->showText("%s", entity->getName().c_str());
  const char* entityTemplate = ::getEntityTemplate(context, entity->getId());
  if (entityTemplate) {
    editor->showText("Type: %s", entityTemplate);
  }
 
  editor->showText("Id: %zd", entity->getId());
 
  auto& components = entity->getComponents();
 
  std::string componentHeader;
  componentHeader.reserve(128);
 
  for (auto& c : components) {
    Cogs::ComponentModel::Component* component = c.resolve();
    showComponentEditor(context, editor, entity, component);
  }
}
 
void Cogs::Core::EntityEditor::showComponentEditor(Context* context, Editor* editor, ComponentModel::Entity* entity, Cogs::ComponentModel::Component* component)
{
  const Cogs::Reflection::Type& componentType = component->getType();
  const Name& typeName = componentType.getName();
 
  if (ImGui::TreeNodeEx(typeName.c_str(), ImGuiTreeNodeFlags_NoTreePushOnOpen | ImGuiTreeNodeFlags_NoAutoOpenOnLog)) {
    ScopedIndent componentIndent;
 
    ImGui::PushID(component);
 
    const size_t numFields = componentType.getNumHierarchyFields();
 
    if (typeName == "TransformComponent") {
      const TransformComponent* transform = static_cast<const TransformComponent*>(component);
      for (FieldId fieldId = 0; fieldId < numFields; ++fieldId) {
        const Cogs::Reflection::Field* field = componentType.getField(fieldId);
        const Cogs::Reflection::Name& fieldName = field->getName();
        if (fieldName == "transformFlags") {
          // Do not display - user shouldn't change.
          continue;
        } else if (fieldName == "transform") {
          // Inactive unless transformFlags = 0.
          if (!transform->transformFlags) {
            continue;
          }
        }
        else {
          // If transformFlags set position/rotation etc not in use
          if (transform->transformFlags) {
            continue;
          }
        }
 
        // coordinates field only used for root entities. Hide if child and zero coord.
        if (fieldName == "coordinates" && context->store->getEntityParent(entity) && transform->coordinates == glm::dvec3(0, 0, 0)) {
          continue;
        }
 
        showFieldEditor(context, editor, component, fieldId);
      }
    }
    else {
      for (FieldId fieldId = 0; fieldId < numFields; ++fieldId) {
        showFieldEditor(context, editor, component, fieldId);
      }
    }
 
    ImGui::PopID();
  }
}
 
void Cogs::Core::EntityEditor::showFieldEditor(Context* context, Editor* editor, Cogs::ComponentModel::Component* component, FieldId fieldId)
{
  const Cogs::Reflection::Type* componentType = &component->getType();
 
  const Cogs::Reflection::Field* field = componentType->getField(fieldId);
  const Cogs::Reflection::Name & fieldName = field->getName();
  FieldInfo fieldInfo{ componentType->getTypeId(), fieldId };
 
  const std::string& fieldHeader = fieldName.getName();
 
  const Cogs::Reflection::Type& fieldType = TypeDatabase::getType(field->getTypeId());
 
  if (fieldType == TypeDatabase::getType<int32_t>()) {
    auto value = *field->getPtr<int32_t>(component);
    const auto* range = field->get<ComponentModel::RangeAttribute<int>>();
    if (range) {
      const int32_t min = std::min(range->getMin(), value);
      const int32_t max = std::max(range->getMax(), value);
      if (ImGui::SliderInt(fieldHeader.c_str(), &value, min, max)) {
        editor->applySelected<SetFieldCommand<int32_t>>(fieldInfo, value);
      }
    }
    else {
      if (ImGui::DragInt(fieldHeader.c_str(), &value)) {
        editor->applySelected<SetFieldCommand<int32_t>>(fieldInfo, value);
      }
    }
  }
  else if (fieldType == TypeDatabase::getType<float>()) {
    auto value = *field->getPtr<float>(component);
 
    const auto* range = field->get<ComponentModel::RangeAttribute<float>>();
    if (range) {
      const float min = std::min(range ? range->getMin() : 0.0f, value);
      const float max = std::max(range ? range->getMax() : 100.0f, value);
      const float stepValue = (max - min) / 100.f;
 
      if (ImGui::DragFloat(fieldHeader.c_str(), &value, stepValue, min, max)) {
        editor->applySelected<SetFieldCommand<float>>(fieldInfo, value);
      }
    }
    else {
      if (ImGui::DragFloat(fieldHeader.c_str(), &value)) {
        editor->applySelected<SetFieldCommand<float>>(fieldInfo, value);
      }
    }
  }
  else if (fieldType == TypeDatabase::getType<glm::vec2>()) {
    auto value = *field->getPtr<glm::vec2>(component);
 
    if (ImGui::DragFloat2(fieldHeader.c_str(), glm::value_ptr(value))) {
      editor->applySelected<SetFieldCommand<glm::vec2>>(fieldInfo, value);
    }
  }
  else if (fieldType == TypeDatabase::getType<glm::vec3>()) {
    auto value = *field->getPtr<glm::vec3>(component);
 
    if (ImGui::DragFloat3(fieldHeader.c_str(), glm::value_ptr(value))) {
      editor->applySelected<SetFieldCommand<glm::vec3>>(fieldInfo, value);
    }
  }
  else if (fieldType == TypeDatabase::getType<glm::vec4>()) {
    auto value = *field->getPtr<glm::vec4>(component);
 
    auto ca = field->get<ComponentModel::ColorAttribute>();
 
    if (ca || (fieldName.getName().find("olor") != std::string::npos)) {
      if (ImGui::ColorEdit4(fieldHeader.c_str(), glm::value_ptr(value))) {
        editor->applySelected<SetFieldCommand<glm::vec4>>(fieldInfo, value);
      }
    } else {
      if (ImGui::DragFloat4(fieldHeader.c_str(), glm::value_ptr(value))) {
        editor->applySelected<SetFieldCommand<glm::vec4>>(fieldInfo, value);
      }
    }
  }
  else if (fieldType == TypeDatabase::getType<glm::ivec2>()) {
    auto value = *field->getPtr<glm::ivec2>(component);
    if (ImGui::DragInt2(fieldHeader.c_str(), glm::value_ptr(value))) {
      editor->applySelected<SetFieldCommand<glm::ivec2>>(fieldInfo, value);
    }
  }
  else if (fieldType == TypeDatabase::getType<glm::ivec3>()) {
    auto value = *field->getPtr<glm::ivec3>(component);
    if (ImGui::DragInt3(fieldHeader.c_str(), glm::value_ptr(value))) {
      editor->applySelected<SetFieldCommand<glm::ivec3>>(fieldInfo, value);
    }
  }
  else if (fieldType == TypeDatabase::getType<glm::ivec4>()) {
    auto value = *field->getPtr<glm::ivec4>(component);
    if (ImGui::DragInt4(fieldHeader.c_str(), glm::value_ptr(value))) {
      editor->applySelected<SetFieldCommand<glm::ivec4>>(fieldInfo, value);
    }
  }
  else if (fieldType == TypeDatabase::getType<glm::uvec2>()) {
    auto fieldValue = field->getPtr<glm::uvec2>(component);
    glm::ivec2 tmp = *fieldValue;
    if (ImGui::DragInt2(fieldHeader.c_str(), glm::value_ptr(tmp))) {
      editor->applySelected<SetFieldCommand<glm::uvec2>>(fieldInfo, tmp);
    }
  }
  else if (fieldType == TypeDatabase::getType<glm::uvec3>()) {
    auto fieldValue = field->getPtr<glm::uvec3>(component);
    glm::ivec3 tmp = *fieldValue;
    if (ImGui::DragInt3(fieldHeader.c_str(), glm::value_ptr(tmp))) {
      editor->applySelected<SetFieldCommand<glm::uvec3>>(fieldInfo, tmp);
    }
  }
  else if (fieldType == TypeDatabase::getType<glm::uvec4>()) {
    auto fieldValue = field->getPtr<glm::uvec4>(component);
    glm::ivec4 tmp = *fieldValue;
    if (ImGui::DragInt4(fieldHeader.c_str(), glm::value_ptr(tmp))) {
      editor->applySelected<SetFieldCommand<glm::uvec4>>(fieldInfo, tmp);
    }
  }
  else if (fieldType == TypeDatabase::getType<glm::dvec2>()) {
    auto fieldValue = field->getPtr<glm::dvec2>(component);
 
    glm::vec2 fValues(*fieldValue);
 
    if (ImGui::DragFloat2(fieldHeader.c_str(), glm::value_ptr(fValues))) {
      editor->applySelected<SetFieldCommand<glm::dvec2>>(fieldInfo, fValues);
    }
  }
  else if (fieldType == TypeDatabase::getType<glm::dvec3>()) {
    auto fieldValue = field->getPtr<glm::dvec3>(component);
 
    glm::vec3 fValues(*fieldValue);
 
    if (ImGui::DragFloat3(fieldHeader.c_str(), glm::value_ptr(fValues))) {
      editor->applySelected<SetFieldCommand<glm::dvec3>>(fieldInfo, fValues);
    }
  }
  else if (fieldType == TypeDatabase::getType<glm::quat>()) {
    auto value = *field->getPtr<glm::quat>(component);
    // Euler Angles
    glm::vec3 euler = glm::eulerAngles(value);
    if (ImGui::DragFloat3("Euler", glm::value_ptr(euler), 0.01f, -glm::pi<float>(), glm::pi<float>())) {
      float eps = 0.00001f;
      if (euler.y >= glm::pi<float>() / 2.0f - eps)
        euler.y = glm::pi<float>() / 2.0f - eps;
      else if (euler.y <= -glm::pi<float>() / 2.0f + eps)
        euler.y = -glm::pi<float>() / 2.0f + eps;
 
      value = glm::quat(euler);
      editor->applySelected<SetFieldCommand<glm::quat>>(fieldInfo, value);
    }
 
    if (ImGui::DragFloat4(fieldHeader.c_str(), glm::value_ptr(value), 0.01f, 0, 1)) {
      editor->applySelected<SetFieldCommand<glm::quat>>(fieldInfo, value);
    }
  }
  else if (fieldType == TypeDatabase::getType<glm::mat4>()) {
    auto fieldValue = field->getPtr<glm::mat4>(component);
    auto value = *fieldValue;
 
    ImGui::PushID(field);
 
    if (showMatrix(fieldHeader, *fieldValue)) {
      editor->applySelected<SetFieldCommand<glm::mat4>>(fieldInfo, value);
    }
    ImGui::PopID();
  }
  else if (fieldType == TypeDatabase::getType<bool>()) {
    auto value = *field->getPtr<bool>(component);
 
    if (ImGui::Checkbox(fieldHeader.c_str(), &value)) {
      editor->applySelected<SetFieldCommand<bool>>(fieldInfo, value);
    }
  }
  else if (fieldType == TypeDatabase::getType<uint32_t>()) {
    auto fieldValue = field->getPtr<uint32_t>(component);
    editor->showText("%s: 0x%08x", fieldHeader.c_str(), *fieldValue);
 
    int tmp = static_cast<int>(*fieldValue);
    const auto* range = field->get<ComponentModel::RangeAttribute<uint32_t>>();
    if (range) {
      const int min = std::min(tmp, static_cast<int>(range->getMin()));
      const int max = std::max(tmp, static_cast<int>(range->getMax()));
      if (ImGui::SliderInt(fieldHeader.c_str(), &tmp, min, max)) {
        editor->applySelected<SetFieldCommand<uint32_t>>(fieldInfo, static_cast<uint32_t>(tmp));
      }
    }
    else {
      if (ImGui::DragInt(fieldHeader.c_str(), &tmp)) {
        editor->applySelected<SetFieldCommand<uint32_t>>(fieldInfo, static_cast<uint32_t>(tmp));
      }
    }
  }
  else if (fieldType.isEnum()) {
    auto fieldValue = field->getPtr<uint32_t>(component);
    auto value = *fieldValue;
 
    if (fieldType.isEnumFlags()) {
      editor->showText("%s:", fieldHeader.c_str());
      ScopedIndent si;
 
      ImGui::PushID(field);
 
      auto numEnums = fieldType.getNumEnumerators();
 
      for (size_t i = 0; i < numEnums; ++i) {
        auto enumerator = fieldType.getEnumerator(i);
        auto enumeratorValue = enumerator->getValue();
 
        if (std::popcount(static_cast<uint32_t>(enumeratorValue)) != 1) continue;
 
        if (ImGui::CheckboxFlags(enumerator->getName().c_str(), &value, enumeratorValue)) {
          editor->applySelected<SetFieldCommand<uint32_t>>(fieldInfo, value);
        }
      }
 
      ImGui::PopID();
    }
    else {
      size_t enums = fieldType.getNumEnumerators();
 
      std::vector<const char *> enumNames(enums);
      std::vector<int> enumValues(enums);
      int index = 0;
      for (size_t i = 0; i < enums; ++i) {
        enumNames[i] = fieldType.getEnumerator(i)->getName().c_str();
        enumValues[i] = fieldType.getEnumerator(i)->getValue();
        if (enumValues[i] == static_cast<int>(*fieldValue)) index = static_cast<int>(i);
      }
 
      if (ImGui::Combo(fieldHeader.c_str(), &index, enumNames.data(), static_cast<int>(enumNames.size()))) {
        editor->applySelected<SetFieldCommand<uint32_t>>(fieldInfo, enumValues[index]);
      }
    }
  }
  else if (fieldType == TypeDatabase::getType<MeshHandle>()) {
    auto & fieldValue = *field->getPtr<MeshHandle>(component);
 
    if (fieldValue) {
      showMesh(context, fieldValue.resolve(), fieldHeader);
    } else {
      editor->showText("None");
    }
  }
  else if (fieldType == TypeDatabase::getType<TextureHandle>()) {
    auto fieldValue = field->getPtr<TextureHandle>(component);
 
    if (editor->showTexture(field->getName().c_str(), *fieldValue)) {
      component->setFieldChanged(fieldId);
    }
  }
  else if (fieldType == TypeDatabase::getType<WeakEntityPtr>()) {
    auto fieldValue = field->getPtr<WeakEntityPtr>(component);
    if (auto spt = fieldValue->lock())
    {
      showEntityEditor(context, editor, &(*spt));
    } else {
      editor->showText("%s: NULL", field->getName().c_str());
    }
  }
  else if (fieldType == TypeDatabase::getType<std::string>()) {
    auto fieldValue = field->getPtr<std::string>(component);
    std::string buffer = *fieldValue;
    buffer.resize(256);
    if (ImGui::InputText(field->getName().c_str(), &buffer[0], buffer.size())) {
      for (size_t i = 0; i < buffer.size(); i++) {
        if (buffer[i] == '\0') {
          buffer.resize(i);
          break;
        }
      }
 
      ImguiRenderer* guiRenderer = context->renderer->getGuiRenderer();
      if (guiRenderer) {
        guiRenderer->addTextToGlyphBuilder(buffer.c_str());
      }
 
      *fieldValue = std::move(buffer);
    }
  }
  else if (fieldType == TypeDatabase::getType<std::vector<std::string>>()) {
    auto fieldValue = field->getPtr<std::vector<std::string>>(component);
    if (fieldValue->empty())
    {
      editor->showText("%s: Empty", field->getName().c_str());
    }
    else {
      ScopedIndent si;
      if (ImGui::CollapsingHeader(std::string(fieldHeader + " [size=" + std::to_string(fieldValue->size()) + "]").c_str()))
      {
        int i = 0;
        for (auto& s : *fieldValue) {
          auto label = std::to_string(i++);
          std::string buffer = s;
          buffer.resize(256);
          if (ImGui::InputText(label.c_str(), &buffer[0], buffer.size())) {
 
            ImguiRenderer* guiRenderer = context->renderer->getGuiRenderer();
            if (guiRenderer) {
              guiRenderer->addTextToGlyphBuilder(buffer.c_str());
            }
 
            s = buffer;
          }
        }
      }
    }
  }
  else if (fieldType == TypeDatabase::getType<std::vector<float>>()) {
    auto fieldValue = field->getPtr<std::vector<float>>(component);
    if (showArray1D(field->getName().getName(), std::span<float>(*fieldValue))) {
      component->setFieldChanged(fieldId);
    }
  }
  else if (fieldType == TypeDatabase::getType<std::vector<glm::vec3>>()) {
    auto fieldValue = field->getPtr<std::vector<glm::vec3>>(component);
    if (showArray3D(fieldHeader, *fieldValue)) {
      component->setFieldChanged(fieldId);
    }
  }
  else if (fieldType == TypeDatabase::getType<std::vector<glm::vec2>>()) {
    auto fieldValue = field->getPtr<std::vector<glm::vec2>>(component);
    if (fieldValue->empty())
    {
      editor->showText("%s: Empty", field->getName().c_str());
    }
    else if (ImGui::CollapsingHeader(fieldHeader.c_str())) {
      ScopedIndent si;
      int i = 0;
      for (auto& v : *fieldValue) {
        std::string label = std::to_string(i++);
        if (ImGui::DragFloat2(label.c_str(), glm::value_ptr(v))) {
          component->setFieldChanged(fieldId);
        }
      }
    }
  }
  else if (fieldType == TypeDatabase::getType<std::vector<glm::vec4>>()) {
    auto fieldValue = field->getPtr<std::vector<glm::vec4>>(component);
    if (fieldValue->empty()) {
      editor->showText("%s: Empty", field->getName().c_str());
    }
    else if (ImGui::CollapsingHeader(fieldHeader.c_str())) {
      ScopedIndent si;
      int i = 0;
      for (auto& v : *fieldValue) {
        std::string label = std::to_string(i++);
        if (ImGui::DragFloat4(label.c_str(), glm::value_ptr(v))) {
          component->setFieldChanged(fieldId);
        }
      }
    }
  }
  else if (fieldType == TypeDatabase::getType<MaterialInstanceHandle>()) {
    auto fieldValue = field->getPtr<MaterialInstanceHandle>(component);
 
    editor->showText("%s:", fieldHeader.c_str());
 
    ScopedIndent indent;
    editor->showMaterialInstance(fieldInfo, *fieldValue);
  }
  else if (fieldType == TypeDatabase::getType<EntityPtr>()) {
    auto fieldValue = field->getPtr<EntityPtr>(component);
    if (fieldValue->get()) {
      if (ImGui::CollapsingHeader(fieldHeader.c_str())) {
        ScopedIndent si;
        showEntityEditor(context, editor, fieldValue->get());
      }
    }
    else {
      editor->showText("%s: NULL", field->getName().c_str());
    }
  }
  else if (fieldType == TypeDatabase::getType<Cogs::Core::FontHandle>()) {
    auto fieldValue = field->getPtr<Cogs::Core::FontHandle>(component);
    if (fieldValue->get()) {
      editor->showText("%s:", field->getName().c_str());
      ImGui::SameLine();
      editor->showText("%d", fieldValue->getId());
    }
    else {
      editor->showText("%s: NULL", field->getName().c_str());
    }
  }
  else if (fieldType == TypeDatabase::getType<ModelHandle>()) {
    auto fieldValue = field->getPtr<ModelHandle>(component);
    editor->showModel(*fieldValue);
  }
  else if (fieldType == TypeDatabase::getType<PropertyStore>()) {
    PropertyStore* propStore = field->getPtr<PropertyStore>(component);
    assert(propStore != nullptr);
    showPropertyStore(*editor, *propStore);
  }
  else {
    // Fallback to default inspector for unhandled type.
    // TypeDatabase::getType<std::vector<EntityPtr>>()
    // TypeDatabase::getType<glm::ivecN>()
    // TypeDatabase::getType<glm::uvecN>()
    // .. ?
    Cogs::Core::showFieldInspector(context, component, fieldId, std::string_view(), std::string_view());
  }
}
 
 
void Cogs::Core::EntityEditor::showEntityGizmo(Context * context, Editor * editor)
{
  auto state = editor->getState();
 
  if (state->mode == EditingMode::Select) {
    // No editing
    state->wasUsingGizmo = false;
  } else if (state->hasSelected()) {
    ImGuizmo::OPERATION currentOperation = ImGuizmo::TRANSLATE;
    ImGuizmo::MODE currentGizmoMode = ImGuizmo::WORLD;
 
    float snap = state->translateSnap;
 
    if (state->mode == EditingMode::Rotate) {
      currentOperation = ImGuizmo::ROTATE;
      currentGizmoMode = ImGuizmo::LOCAL;
      snap = state->rotateSnap;
    } else if (state->mode == EditingMode::Scale) {
      currentOperation = ImGuizmo::SCALE;
      currentGizmoMode = ImGuizmo::LOCAL;
      snap = state->scaleSnap;
    }
 
    const Entity* entity = state->getSelected();
    if (!entity) return;
 
    const TransformComponent* transformComponent = entity->getComponent<TransformComponent>();
    if (!transformComponent) return;
 
    if (!state->wasUsingGizmo) {
      Geometry::DBoundingBox bounds;
      ::calculateBoundingBoxWorld(context, entity->getId(), bounds.data());
      if (Cogs::Geometry::isEmpty(bounds)) return;
 
      glm::dvec3 center = 0.5 * (bounds.min + bounds.max);
 
      // Capture transforms
      if (state->pivot == EditingPivot::ObjectPivot) {
        state->startTranslation = transformComponent->position;
      } else {
        state->startTranslation = center;
      }
      state->endTranslation = state->startTranslation;
 
      state->startRotation = transformComponent->rotation;
      state->endRotation = state->startRotation;
 
      state->startScale = transformComponent->scale;
      state->endScale = state->startScale;
 
      state->startTranslations.resize(state->selected.size());
      state->startRotations.resize(state->selected.size());
      state->startScales.resize(state->selected.size());
 
      for (size_t i = 0; i < state->selected.size(); ++i) {
        const Entity* e = context->store->getEntityPtr(state->selected[i]);
        auto t = e->getComponent<TransformComponent>();
 
        state->startTranslations[i] = t->position;
        state->startRotations[i] = t->rotation;
        state->startScales[i] = t->scale;
      }
 
      const EntityData* entityData = static_cast<EntityData*>(state->getSelected()->getUserData());
 
      glm::mat4 localTransform;
      if (entityData->entityContext) {
        localTransform = entityData->entityContext->transformSystem->getLocalTransform(transformComponent);
      } else {
        localTransform = context->transformSystem->getLocalTransform(transformComponent);
      }
 
      glm::mat4 invLocal = glm::inverse(localTransform);
 
      state->startMin = glm::vec3(invLocal * glm::vec4(bounds.min, 1));
      state->startMax = glm::vec3(invLocal * glm::vec4(bounds.max, 1));
    }
 
    const glm::vec3 rads = glm::eulerAngles(state->endRotation);
    const glm::vec3 euler = glm::degrees(rads);
 
    float transform[16];
    ImGuizmo::RecomposeMatrixFromComponents(glm::value_ptr(state->endTranslation), glm::value_ptr(euler), glm::value_ptr(state->endScale), transform);
 
    const auto cameraHandle = state->editorCamera.lock()->getComponentHandle<CameraComponent>();
    const auto camera = cameraHandle.resolveComponent<CameraComponent>();
    const auto & cameraData = context->cameraSystem->getData(camera);
 
    ImGuizmo::SetRect(camera->viewportOrigin.x, camera->viewportOrigin.y, camera->viewportSize.x, camera->viewportSize.y);
 
    glm::vec3 snapValue(snap);
    ImGuizmo::Manipulate(glm::value_ptr(cameraData.viewMatrix), glm::value_ptr(cameraData.rawProjectionMatrix), currentOperation, currentGizmoMode, transform, nullptr, glm::value_ptr(snapValue));
 
    glm::vec3 rotate;
    ImGuizmo::DecomposeMatrixToComponents(transform, glm::value_ptr(state->endTranslation), glm::value_ptr(rotate), glm::value_ptr(state->endScale));
 
    if (!ImGuizmo::IsUsing()) {
      state->wasUsingGizmo = false;
      return;
    }
 
    if (!state->wasUsingGizmo) {
      // First
      state->wasUsingGizmo = true;
    }
 
    if (state->mode == EditingMode::Translate) {
      glm::vec3 diff = state->endTranslation - state->startTranslation;
      editor->apply<TranslateCommand>(state->selected, diff);
    } else if (state->mode == EditingMode::Rotate) {
      glm::vec3 angles = glm::radians(rotate);
      state->endRotation = glm::quat(angles);
      glm::quat diff = state->endRotation * glm::inverse(state->startRotation);
      editor->apply<RotateCommand>(state->selected, diff);
    } else if (state->mode == EditingMode::Scale) {
      glm::vec3 diff = state->endScale - state->startScale;
      editor->apply<ScaleCommand>(state->selected, diff);
    }
  }
}