EntityInspector.cpp

#include "EntityInspector.h"
 
#include "Context.h"
#include "Engine.h"
#include "EntityStore.h"
#include "Types.h"
 
#include "Editor/IEditor.h"
 
#include "InspectorGuiHelper.h"
#include "Inspectors.h"
 
#include "Components/Core/PropertiesComponent.h"
#include "Components/Core/SceneComponent.h"
 
#include "Resources/Resources.h"
#include "Resources/TextureManager.h"
#include "Renderer/Renderer.h"
#include "Renderer/RenderTexture.h"
#include "Resources/MaterialInstance.h"
#include "Resources/Model.h"
#include "Resources/Mesh.h"
 
#include "Foundation/ComponentModel/Entity.h"
#include "Foundation/Reflection/TypeDatabase.h"
 
// Add a button to the Entity Inspector that allows you to export the entity tree as XML.
// (Handy for debugging.)
#define ENABLE_XML_EXPORT
#if defined(ENABLE_XML_EXPORT)
  #include "Foundation/Platform/IO.h"
#endif
 
#include "imgui.h"
 
#include <glm/vec2.hpp>
#include <glm/vec3.hpp>
#include <glm/vec4.hpp>
#include <glm/mat4x4.hpp>
#include <glm/ext/quaternion_float.hpp>
 
#include <algorithm>
#include <sstream>
#include <iomanip>
#include <array>
#include <bit>
#include <cstdio>
 
using namespace Cogs::Reflection;
using namespace Cogs::ComponentModel;
 
#if defined(ENABLE_XML_EXPORT)
namespace Cogs::Core
{
  void exportEntity(Context* context, Entity* entity, std::string& dest) {
    char  buffer[1024];
 
    sprintf(buffer, "<entity name='%s' id='%zu'>", entity->getName().c_str(), entity->getId());
    dest += buffer;
 
    for (const ComponentHandle& componentHandle : entity->getComponents()) {
      const Component*        component = componentHandle.resolve();
      const Reflection::Type* type = &TypeDatabase::getType(componentHandle.typeId);
      std::string             children;
 
      dest += "<component name='";
      dest += type->getName().getName();
      dest += "'";
 
      if (type == &TypeDatabase::getType<PropertiesComponent>()) {
        const PropertiesComponent*  propertiesComp = static_cast<const PropertiesComponent*>(component);
 
        for (const PropertyInfo& header : propertiesComp->properties.getHeaders()) {
          StringView  name = propertiesComp->properties.getKey(header);
 
          if (!name.empty()) {
            dest += " ";
            dest += name.to_string();
            dest += "='";
 
            switch (header.type) {
              case PropertyType::Bool:
                dest += header.boolValue ? "true" : "false";
                break;
              case PropertyType::Integer:
                sprintf(buffer, "%d", header.intValue);
                dest += buffer;
                break;
              case PropertyType::UnsignedInteger:
                sprintf(buffer, "%u", header.uintValue);
                dest += buffer;
                break;
              case PropertyType::Float:
                sprintf(buffer, "%f", header.floatValue);
                dest += buffer;
                break;
              case PropertyType::Float2:
                sprintf(buffer, "%f,%f", header.float2Value[0], header.float2Value[1]);
                dest += buffer;
                break;
              case PropertyType::StringRef:
              case PropertyType::String:
                dest += propertiesComp->properties.getString(header).to_string();
                break;
              case PropertyType::FloatArray:
                for (float value : propertiesComp->properties.getFloatArray(header.index)) {
                  sprintf(buffer, "%f,", value);
                  dest += buffer;
                }
                dest.resize(dest.size() - 1);
                break;
            }
            dest += "'";
          }
        }
      }
 
 
 
      for (; type; type = type->getBase()) {
        for (size_t fieldIdx = 0, fieldCount = type->getNumFields(); fieldIdx < fieldCount; ++fieldIdx) {
          const Reflection::Field*  field = type->getField(static_cast<FieldId>(fieldIdx));
          const Reflection::Type&   fieldType = TypeDatabase::getType(field->getTypeId());
          const std::string&        name = field->getName().getName();
 
          if (!name.empty()) {
            dest += " ";
            dest += name;
            dest += "='";
 
            if (fieldType == TypeDatabase::getType<bool>()) {
              dest += field->getPtr<bool>(component) ? "true" : "false";
            }
            else if (fieldType == TypeDatabase::getType<int32_t>()) {
              sprintf(buffer, "%d", *field->getPtr<int32_t>(component));
              dest += buffer;
            }
            else if (fieldType == TypeDatabase::getType<uint32_t>()) {
              sprintf(buffer, "%u", *field->getPtr<uint32_t>(component));
              dest += buffer;
            }
            else if (fieldType == TypeDatabase::getType<float>()) {
              sprintf(buffer, "%f", *field->getPtr<float>(component));
              dest += buffer;
            }
            else if (fieldType == TypeDatabase::getType<glm::vec2>()) {
              const glm::vec2* value = field->getPtr<glm::vec2>(component);
              sprintf(buffer, "%f,%f", value->x, value->y);
              dest += buffer;
            }
            else if (fieldType == TypeDatabase::getType<glm::vec3>()) {
              const glm::vec3* value = field->getPtr<glm::vec3>(component);
              sprintf(buffer, "%f,%f,%f", value->x, value->y, value->z);
              dest += buffer;
            }
            else if (fieldType == TypeDatabase::getType<glm::vec4>()) {
              const glm::vec4* value = field->getPtr<glm::vec4>(component);
              sprintf(buffer, "%f,%f,%f,%f", value->x, value->y, value->z, value->w);
              dest += buffer;
            }
            else if (fieldType == TypeDatabase::getType<glm::dvec2>()) {
              const glm::dvec2* value = field->getPtr<glm::dvec2>(component);
              sprintf(buffer, "%f,%f", value->x, value->y);
              dest += buffer;
            }
            else if (fieldType == TypeDatabase::getType<glm::dvec3>()) {
              const glm::dvec3* value = field->getPtr<glm::dvec3>(component);
              sprintf(buffer, "%f,%f,%f", value->x, value->y, value->z);
              dest += buffer;
            }
            else if (fieldType == TypeDatabase::getType<glm::dvec4>()) {
              const glm::dvec4* value = field->getPtr<glm::dvec4>(component);
              sprintf(buffer, "%f,%f,%f,%f", value->x, value->y, value->z, value->w);
              dest += buffer;
            }
            else if (fieldType == TypeDatabase::getType<glm::ivec2>()) {
              const glm::ivec2*  value = field->getPtr<glm::ivec2>(component);
              sprintf(buffer, "%d,%d", value->x, value->y);
              dest += buffer;
            }
            else if (fieldType == TypeDatabase::getType<glm::ivec3>()) {
              const glm::ivec3*  value = field->getPtr<glm::ivec3>(component);
              sprintf(buffer, "%d,%d,%d", value->x, value->y, value->z);
              dest += buffer;
            }
            else if (fieldType == TypeDatabase::getType<glm::ivec4>()) {
              const glm::ivec4*  value = field->getPtr<glm::ivec4>(component);
              sprintf(buffer, "%d,%d,%d,%d", value->x, value->y, value->z, value->w);
              dest += buffer;
            }
            else if (fieldType == TypeDatabase::getType<glm::uvec2>()) {
              const glm::uvec2*  value = field->getPtr<glm::uvec2>(component);
              sprintf(buffer, "%u,%u", value->x, value->y);
              dest += buffer;
            }
            else if (fieldType == TypeDatabase::getType<glm::uvec3>()) {
              const glm::uvec3*  value = field->getPtr<glm::uvec3>(component);
              sprintf(buffer, "%u,%u,%u", value->x, value->y, value->z);
              dest += buffer;
            }
            else if (fieldType == TypeDatabase::getType<glm::uvec4>()) {
              const glm::uvec4* value = field->getPtr<glm::uvec4>(component);
              sprintf(buffer, "%d,%d,%d,%d", value->x, value->y, value->z, value->w);
              dest += buffer;
            }
            else if (fieldType == TypeDatabase::getType<glm::mat4>()) {
              const float* values = glm::value_ptr(*field->getPtr<glm::mat4>(component));
              sprintf(buffer, "%f,%f,%f,%f,%f,%f,%f,%f,%f,%f,%f,%f,%f,%f,%f,%f", values[0], values[1], values[2], values[3], values[4], values[5], values[6], values[7], values[8], values[9], values[10], values[11], values[12], values[13], values[14], values[15]);
              dest += buffer;
            }
            else if (fieldType == TypeDatabase::getType<glm::quat>()) {
              const glm::quat* value = field->getPtr<glm::quat>(component);
              sprintf(buffer, "%f,%f,%f,%f", value->x, value->y, value->z, value->w);
              dest += buffer;
            }
            else if (fieldType.isEnumFlags()) {
              sprintf(buffer, "0x%08X", *field->getPtr<uint32_t>(component));
              dest += buffer;
            }
            else if (fieldType.isEnum()) {
              uint32_t value = *field->getPtr<uint32_t>(component);
 
              for (size_t idx = 0, enumCount = fieldType.getNumEnumerators(); idx < enumCount; ++idx) {
                if (value == static_cast<uint32_t>(fieldType.getEnumerator(idx)->getValue())) {
                  dest += fieldType.getEnumerator(idx)->getName().getName();
                  break;
                }
              }
            }
            else if (fieldType == TypeDatabase::getType<std::vector<EntityPtr>>()) {
              dest.resize(dest.size() - name.size() - 3);
 
              const std::vector<EntityPtr>* childEntities = field->getPtr<std::vector<EntityPtr>>(component);
 
              if (!childEntities->empty()) {
                children.reserve(1048576);
                children += "<";
                children += name;
                children += ">";
                for (const EntityPtr& child : *childEntities) {
                  exportEntity(context, child.get(), children);
                }
                children += "</";
                children += name;
                children += ">";
              }
              continue;
            }
            else if (fieldType == TypeDatabase::getType<std::string>()) {
              dest += *field->getPtr<std::string>(component);
            }
            else if (fieldType == TypeDatabase::getType<std::vector<std::string>>()) {
              const std::vector<std::string>* values = field->getPtr<std::vector<std::string>>(component);
 
              if (!values->empty()) {
                for (const std::string& str : *values) {
                  dest += str;
                  dest += ",";
                }
                dest.resize(dest.size() - 1);
              }
            }
            else {
              dest += "UNSUPPORTED";
            }
            dest += "'";
          }
        }
      }
      if (children.empty()) {
        dest += "/>";
      }
      else {
        dest += ">";
        dest += children;
        dest += "</component>";
      }
    }
    dest += "</entity>";
  }
}
#endif //ENABLE_XML_EXPORT
 
void Cogs::Core::showCollapsableEntityInspector(Cogs::Core::Context* context, const ComponentModel::Entity* entity, std::string_view entityNamePattern, std::string_view componentNamePattern, bool showBorder)
{
  if (Cogs::Core::findHierarchyWithMatch(*entity, entityNamePattern, componentNamePattern)) {
    std::array<char, 128> header = {};
    std::snprintf(header.data(), header.size(), "%s Id: %zu", entity->getName().c_str(), entity->getId());
 
    ImGui::PushID(entity);
 
    if (ImGui::TreeNodeEx(header.data(), ImGuiTreeNodeFlags_NoAutoOpenOnLog | (showBorder ? ImGuiTreeNodeFlags_Framed : 0))) {
      ScopedIndent si;
      showEntityInspector(context, entity, entityNamePattern, componentNamePattern, showBorder);
 
      ImGui::TreePop();
    }
 
    ImGui::PopID();
  }
}
 
void Cogs::Core::showEntities(Context * context, std::span<const EntityPtr> entities, std::string_view entityNamePattern, std::string_view componentNamePattern)
{
  for (const EntityPtr & e : entities) {
    showCollapsableEntityInspector(context, e.get(), entityNamePattern, componentNamePattern);
  }
}
 
void Cogs::Core::showEntityInspector(Context* context, const ComponentModel::Entity* entity, std::string_view entityNamePattern, std::string_view componentNamePattern, bool showBorder)
{
  ImGui::Text("Id: %zd", entity->getId());
  ImGui::SameLine();
  const float spacing = ImGui::GetStyle().ItemInnerSpacing.x;
  static std::array<char, 65> buffer;
  ImGui::SameLine(0.0f, spacing);
  constexpr int widthInputText = 120;
  ImGui::PushItemWidth(widthInputText);
  ImGui::Text("Filter: ");
  ImGui::SameLine(0.0f, spacing);
  if (ImGui::InputText(" ", buffer.data(), buffer.size(), ImGuiInputTextFlags_None)) {
    ImguiRenderer* guiRenderer = context->renderer->getGuiRenderer();
    if (guiRenderer) {
      guiRenderer->addTextToGlyphBuilder(buffer.data());
    }
  }
  ImGui::PopItemWidth();
 
  std::string_view findPattern = buffer.data();
 
  for (const Cogs::ComponentModel::ComponentHandle& c : entity->getComponents()) {
    Cogs::ComponentModel::Component* component = c.resolve();
 
    bool showComponent = (bool)component;
    if(showComponent && !findPattern.empty()) {
      showComponent = containsInvariantCase(component->getType().getName().c_str(), findPattern);
    }
 
    if(showComponent) {
      showComponentInspector(context, component, entityNamePattern, componentNamePattern, showBorder);
    }
  }
}
 
void Cogs::Core::showComponentInspector(Context* context, ComponentModel::Component* component, std::string_view entityNamePattern, std::string_view componentNamePattern, bool showBorder)
{
  const Cogs::Reflection::Type* componentType = &component->getType();
 
  if (ImGui::TreeNodeEx(componentType->getName().getName().c_str(), ImGuiTreeNodeFlags_NoTreePushOnOpen | ImGuiTreeNodeFlags_NoAutoOpenOnLog | (showBorder ? ImGuiTreeNodeFlags_Framed : 0))) {
    ImGui::PushID(component);
    ImGui::Text(" ");
    const float spacing = ImGui::GetStyle().ItemInnerSpacing.x;
    static std::array<char, 65> buffer;
    ImGui::SameLine(0.0f, spacing);
    constexpr int widthInputText = 120;
    ImGui::PushItemWidth(widthInputText);
    ImGui::Text("Filter: ");
    ImGui::SameLine(0.0f, spacing);
    if (ImGui::InputText(" ", buffer.data(), buffer.size(), ImGuiInputTextFlags_None)) {
      ImguiRenderer* guiRenderer = context->renderer->getGuiRenderer();
      if (guiRenderer) {
        guiRenderer->addTextToGlyphBuilder(buffer.data());
      }
    }
    ImGui::PopItemWidth();
    auto updateGui = componentType->getMethod("updateGui");
    if (updateGui) {
      updateGui->call(component);
      ImGui::PopID();
      return;
    }
 
    std::string_view findPattern = buffer.data();
 
    // Show fields
    ScopedIndent si_type;
    size_t numFields = componentType->getNumHierarchyFields();
 
    for (FieldId fieldId = 0; fieldId < numFields; ++fieldId) {
      bool showField = true;
      if(!findPattern.empty()) {
        showField = containsInvariantCase(componentType->getField(fieldId)->getName().c_str(), findPattern);
      }
 
      if(showField) {
        showFieldInspector(context, component, fieldId, entityNamePattern, componentNamePattern, showBorder);
      }
    }
 
    ImGui::PopID();
  }
}
 
void Cogs::Core::showFieldInspector(Context* context, ComponentModel::Component* component, FieldId fieldId, std::string_view entityNamePattern, std::string_view componentNamePattern, bool showBorder)
{
  const Cogs::Reflection::Type* componentType = &component->getType();
 
  const Cogs::Reflection::Field* field = componentType->getField(fieldId);
  const Cogs::Reflection::Name& fieldName = field->getName();
 
  const std::string & fieldHeader = fieldName.getName();
 
  const Cogs::Reflection::Type & fieldType = TypeDatabase::getType(field->getTypeId());
 
  if (fieldType == TypeDatabase::getType<int32_t>()) {
    auto fieldValue = field->getPtr<int32_t>(component);
    const auto* range = field->get<ComponentModel::RangeAttribute<int>>();
    if (range) {
      const int32_t min = std::min(range->getMin(), *fieldValue);
      const int32_t max = std::max(range->getMax(), *fieldValue);
      if (ImGui::SliderInt(fieldHeader.c_str(), fieldValue, min, max)) {
        component->setFieldChanged(fieldId);
      }
    }
    else {
      if (ImGui::DragInt(fieldHeader.c_str(), fieldValue)) {
        component->setFieldChanged(fieldId);
      }
    }
  }
  else if (fieldType == TypeDatabase::getType<float>()) {
    auto fieldValue = field->getPtr<float>(component);
 
    const auto* range = field->get<ComponentModel::RangeAttribute<float>>();
    if (range) {
      const float min = std::min(range ? range->getMin() : 0.0f, *fieldValue);
      const float max = std::max(range ? range->getMax() : 100.0f, *fieldValue);
      const float stepValue = (max - min) / 100.f;
 
      if (ImGui::DragFloat(fieldHeader.c_str(), fieldValue, stepValue, min, max)) {
        component->setFieldChanged(fieldId);
      }
    }
    else {
      if (ImGui::DragFloat(fieldHeader.c_str(), fieldValue)) {
        component->setFieldChanged(fieldId);
      }
    }
  }
  else if (fieldType == TypeDatabase::getType<glm::vec2>()) {
    auto fieldValue = field->getPtr<glm::vec2>(component);
 
    if (ImGui::DragFloat2(fieldHeader.c_str(), glm::value_ptr(*fieldValue))) {
      component->setFieldChanged(fieldId);
    }
  }
  else if (fieldType == TypeDatabase::getType<glm::vec3>()) {
    auto fieldValue = field->getPtr<glm::vec3>(component);
 
    if (ImGui::DragFloat3(fieldHeader.c_str(), glm::value_ptr(*fieldValue))) {
      component->setFieldChanged(fieldId);
    }
  }
  else if (fieldType == TypeDatabase::getType<glm::vec4>()) {
    auto fieldValue = 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(*fieldValue))) {
        component->setFieldChanged(fieldId);
      }
    } else {
      if (ImGui::DragFloat4(fieldHeader.c_str(), glm::value_ptr(*fieldValue))) {
        component->setFieldChanged(fieldId);
      }
    }
  }
  else if (fieldType == TypeDatabase::getType<glm::ivec2>()) {
    auto fieldValue = field->getPtr<glm::ivec2>(component);
    if (ImGui::DragInt2(fieldHeader.c_str(), glm::value_ptr(*fieldValue))) {
      component->setFieldChanged(fieldId);
    }
  }
  else if (fieldType == TypeDatabase::getType<glm::ivec3>()) {
    auto fieldValue = field->getPtr<glm::ivec3>(component);
    if (ImGui::DragInt3(fieldHeader.c_str(), glm::value_ptr(*fieldValue))) {
      component->setFieldChanged(fieldId);
    }
  }
  else if (fieldType == TypeDatabase::getType<glm::ivec4>()) {
    auto fieldValue = field->getPtr<glm::ivec4>(component);
    if (ImGui::DragInt4(fieldHeader.c_str(), glm::value_ptr(*fieldValue))) {
      component->setFieldChanged(fieldId);
    }
  }
  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))) {
      *fieldValue = tmp;
      component->setFieldChanged(fieldId);
    }
  }
  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))) {
      *fieldValue = tmp;
      component->setFieldChanged(fieldId);
    }
  }
  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))) {
      *fieldValue = tmp;
      component->setFieldChanged(fieldId);
    }
  }
  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))) {
      *fieldValue = glm::dvec2(fValues);
      component->setFieldChanged(fieldId);
    }
  }
  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))) {
      *fieldValue = glm::dvec3(fValues);
      component->setFieldChanged(fieldId);
    }
  }
  else if (fieldType == TypeDatabase::getType<glm::quat>()) {
    auto fieldValue = field->getPtr<glm::quat>(component);
    // Euler Angles
    glm::vec3 euler = glm::eulerAngles(*fieldValue);
    if (ImGui::DragFloat3("Euler", glm::value_ptr(euler), 0.01f, -3.14f, 3.14f)) {
      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;
      *fieldValue = glm::quat(euler);
 
      component->setFieldChanged(fieldId);
    }
 
    if (ImGui::DragFloat4(fieldHeader.c_str(), glm::value_ptr(*fieldValue), 0.01f, 0, 1)) {
      component->setFieldChanged(fieldId);
    }
  }
  else if (fieldType == TypeDatabase::getType<glm::mat4>()) {
    auto fieldValue = field->getPtr<glm::mat4>(component);
 
    ImGui::PushID(field);
 
    if (showMatrix(fieldHeader, *fieldValue)) {
      component->setFieldChanged(fieldId);
    }
    ImGui::PopID();
  }
  else if (fieldType == TypeDatabase::getType<bool>()) {
    auto fieldValue = field->getPtr<bool>(component);
 
    if (ImGui::Checkbox(fieldHeader.c_str(), fieldValue)) {
      component->setFieldChanged(fieldId);
    }
  }
  else if (fieldType == TypeDatabase::getType<uint32_t>()) {
    auto fieldValue = field->getPtr<uint32_t>(component);
    ImGui::Text("%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)) {
        *fieldValue = static_cast<uint32_t>(tmp);
        component->setFieldChanged(fieldId);
      }
    }
    else {
      if (ImGui::DragInt(fieldHeader.c_str(), &tmp)) {
        *fieldValue = static_cast<uint32_t>(tmp);
        component->setFieldChanged(fieldId);
      }
    }
  }
  else if (fieldType.isEnum()) {
    auto fieldValue = field->getPtr<uint32_t>(component);
    auto value = *fieldValue;
 
    if (fieldType.isEnumFlags()) {
      ImGui::Text("%s (%d = 0x%08X):", fieldHeader.c_str(), value, value);
      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)) {
          *fieldValue = 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()))) {
        *fieldValue = enumValues[index];
        component->setFieldChanged(fieldId);
      }
    }
  }
  else if (fieldType == TypeDatabase::getType<std::vector<EntityPtr>>()) {
    auto fieldValue = field->getPtr<std::vector<EntityPtr>>(component);
    showEntities(context, *fieldValue, entityNamePattern, componentNamePattern);
  }
  else if (fieldType == TypeDatabase::getType<MeshHandle>()) {
    auto & fieldValue = *field->getPtr<MeshHandle>(component);
 
    if (fieldValue) {
      showMesh(context, fieldValue.resolve(), fieldHeader);
    } else {
      ImGui::Text("None");
    }
  }
  else if (fieldType == TypeDatabase::getType<TextureHandle>()) {
    auto fieldValue = field->getPtr<TextureHandle>(component);
 
    auto editor = context->engine->getEditor();
    if (editor && editor->isActive()) {
      if (editor->showTexture(field->getName().c_str(), *fieldValue)) {
        component->setFieldChanged(fieldId);
      }
    }
    else {
      if (*fieldValue) {
        if (ImGui::CollapsingHeader(field->getName().c_str())) {
          Texture* texture = fieldValue->resolve();
          auto renderer = dynamic_cast<Cogs::Core::Renderer*>(context->renderer);
          showTexture(context, renderer, texture);
        }
      }
      else {
        ImGui::Text("%s: NULL", field->getName().c_str());
      }
    }
  }
  else if (fieldType == TypeDatabase::getType<WeakEntityPtr>()) {
    auto fieldValue = field->getPtr<WeakEntityPtr>(component);
    if (auto spt = fieldValue->lock())
    {
      showEntityInspector(context, &(*spt), entityNamePattern, componentNamePattern, showBorder);
    } else {
      ImGui::Text("%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())
    {
      ImGui::Text("%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<int32_t>>()) {
    auto fieldValue = field->getPtr<std::vector<int32_t>>(component);
    if (showArray1D(field->getName().getName(), std::span<int32_t>(*fieldValue))) {
      component->setFieldChanged(fieldId);
    }
  }
  else if (fieldType == TypeDatabase::getType<std::vector<uint32_t>>()) {
    auto fieldValue = field->getPtr<std::vector<uint32_t>>(component);
    if (showArray1D(field->getName().getName(), std::span<uint32_t>(*fieldValue))) {
      component->setFieldChanged(fieldId);
    }
  }
  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())
    {
      ImGui::Text("%s: Empty", field->getName().c_str());
    }
    else if (ImGui::CollapsingHeader(fieldHeader.c_str())) {
      ScopedIndent si;
      int i = 0;
      for (auto& v : *fieldValue) {
        auto 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()) {
      ImGui::Text("%s: Empty", field->getName().c_str());
    }
    else if (ImGui::CollapsingHeader(fieldHeader.c_str())) {
      ScopedIndent si;
      int i = 0;
      for (auto& v : *fieldValue) {
        auto 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);
    auto header = (!field->getName().getName().empty() ? field->getName().getName() : "Material");
    auto * material = fieldValue->resolve();
    if (material) {
      showMaterialInstance(context, material, header);
    }
    else {
      ImGui::Text("%s: NULL", header.c_str());
    }
  }
  else if (fieldType == TypeDatabase::getType<std::vector<MaterialInstanceHandle>>()) {
    auto fieldValue = field->getPtr<std::vector<MaterialInstanceHandle>>(component);
    if (fieldValue->empty()) {
      ImGui::Text("%s: Empty", field->getName().c_str());
    }
    else if (ImGui::CollapsingHeader(fieldHeader.c_str())) {
      ScopedIndent si;
      int i = 0;
      for (auto& v : *fieldValue) {
      auto* material = v.resolve();
 
        auto label = "Mat: " + std::to_string(i++);
        if (material) {
          showMaterialInstance(context, material, label);
        }
        else {
          ImGui::Text("%s: NULL", label.c_str());
        }
      }
    }
  }
  else if (fieldType == TypeDatabase::getType<EntityPtr>()) {
    auto fieldValue = field->getPtr<EntityPtr>(component);
    if (fieldValue->get()) {
      showEntityInspector(context, fieldValue->get(), entityNamePattern, componentNamePattern, showBorder);
    }
    else {
      ImGui::Text("%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()) {
      ImGui::Text("%s:", field->getName().c_str());
      ImGui::SameLine();
      ImGui::Text("%d", fieldValue->getId());
    }
    else {
      ImGui::Text("%s: NULL", field->getName().c_str());
    }
  }
  else if (fieldType == TypeDatabase::getType<ModelHandle>()) {
    auto fieldValue = field->getPtr<ModelHandle>(component);
 
    Model * model = fieldValue->resolve();
    if (model) {
      auto header = (!model->getName().empty() ? model->getName() : "Model");
      showModel(context, model, std::string(header));
    } else {
      ImGui::Text("%s: NULL", field->getName().c_str());
    }
  }
  else if (fieldType == TypeDatabase::getType<PropertyStore>()) {
    PropertyStore* propStore = field->getPtr<PropertyStore>(component);
    assert(propStore != nullptr);
 
    for (const Cogs::Core::PropertyInfo& header : propStore->getHeaders()) {
      const std::string propName(propStore->getKey(header));
 
      switch(header.type) {
        case Cogs::Core::PropertyType::Bool: {
          ImGui::Text("%s: %s", propName.c_str(), header.boolValue ? "true" : "false");
          break;
        }
        case Cogs::Core::PropertyType::Integer: {
          ImGui::Text("%s: %d", propName.c_str(), header.intValue);
          break;
        }
        case Cogs::Core::PropertyType::Int2: {
          ImGui::Text("%s: (%d, %d)", propName.c_str(), header.int2Value[0], header.int2Value[1]);
          break;
        }
        case Cogs::Core::PropertyType::UnsignedInteger: {
          ImGui::Text("%s: %u", propName.c_str(), header.uintValue);
          break;
        }
        case Cogs::Core::PropertyType::UInt2: {
          ImGui::Text("%s: (%u, %u)", propName.c_str(), header.uint2Value[0], header.uint2Value[1]);
          break;
        }
        case Cogs::Core::PropertyType::Float: {
          ImGui::Text("%s: %f", propName.c_str(), header.floatValue);
          break;
        }
        case Cogs::Core::PropertyType::Float2: {
          ImGui::Text("%s: (%f, %f)", propName.c_str(), header.float2Value[0], header.float2Value[1]);
          break;
        }
        case Cogs::Core::PropertyType::Double: {
          ImGui::Text("%s: %f", propName.c_str(), header.doubleValue);
          break;
        }
        case Cogs::Core::PropertyType::StringRef: {
          ImGui::Text("%s: %s", propName.c_str(), Cogs::Core::Strings::getC(header.stringRefValue));
          break;
        }
        case Cogs::Core::PropertyType::String: {
          ImGui::Text("%s: %.*s", propName.c_str(), StringViewFormat(propStore->getString(header)));
          break;
        }
        case Cogs::Core::PropertyType::FloatArray: {
          showArray1D(propName, propStore->getFloatArray(header));
          break;
        }
        case Cogs::Core::PropertyType::IntArray: {
          showArray1D(propName, propStore->getIntArray(header));
          break;
        }
        case Cogs::Core::PropertyType::UIntArray: {
          showArray1D(propName, propStore->getUIntArray(header));
          break;
        }
        case Cogs::Core::PropertyType::DoubleArray: {
          showArray1D(propName, propStore->getDoubleArray(header));
          break;
        }
        default: {
          assert(false && "Unsupported PropertyType");
        }
      }
    }
  }
  else {
    ImGui::Text("%s: %s (Type: %d)", field->getName().c_str(), fieldType.getName().c_str(), static_cast<int>(fieldType.getTypeId()));
  }
}
 
void Cogs::Core::entityInspector(Context * context, bool * show)
{
  if (*show) {
    ImGui::SetNextWindowSize(ImVec2(400, 1000), ImGuiCond_Once);
 
    guiBegin("Entities", show);
 
    const std::unordered_map<EntityId, EntityPtr>&  entities = context->store->getEntities();
 
#if defined(ENABLE_XML_EXPORT)
    static char filename[1024];
 
    ImGui::SameLine();
    if (ImGui::Button("Export XML to >")) {
      if (filename[0]) {
        std::string dest;
        
        dest.reserve(1048576);
        dest = "<?xml version='1.0'?><entities>";
        for (const auto& [id, entity] : entities) {
          if (entity) {
            exportEntity(context, entity.get(), dest);
          }
        }
        dest += "</entities>";
        IO::writeBinaryFile(filename, dest.data(), dest.size());
      }
    }
    ImGui::SameLine();
    ImGui::InputText("Filename", filename, sizeof(filename));
#endif
 
    // Filter out entities in store, but child of other.
    static bool onlyRootEntities = true;
    size_t numEntities = 0;
    if (onlyRootEntities) {
      for (const auto& [id, entity] : entities) {
        if (context->store->getEntityParent(entity.get()) == nullptr) {
          numEntities++;
        }
      }
    }
    else {
      numEntities = entities.size();
    }
 
    ImGui::Text("Entities: %zu", numEntities);
 
    const float spacing = ImGui::GetStyle().ItemInnerSpacing.x;
    ImGui::SameLine(0.0f, spacing);
    ImGui::Text("  ");
    ImGui::SameLine(0.0f, spacing);
    if (ImGui::RadioButton("Root Entities", onlyRootEntities == true)) { onlyRootEntities = true; }
    ImGui::SameLine(0.0f, spacing);
    if (ImGui::RadioButton("All User", onlyRootEntities == false)) { onlyRootEntities = false; }
 
    // Add text-box allowing filtering by entity name. Simple String containsInvariantCase.
    std::string_view entityNamePattern;
    {
      static std::array<char, 33> nameFilterBuffer;
      constexpr int widthInputText = 120;
      ImGui::PushItemWidth(widthInputText);
      ImGui::Text("Name:");
      ImGui::SameLine(0.0f, spacing);
      if (ImGui::InputText(" ", nameFilterBuffer.data(), nameFilterBuffer.size(), ImGuiInputTextFlags_None)) {
        ImguiRenderer* guiRenderer = context->renderer->getGuiRenderer();
        if (guiRenderer) {
          guiRenderer->addTextToGlyphBuilder(nameFilterBuffer.data());
        }
      }
      entityNamePattern = nameFilterBuffer.data();
    }
 
    std::string_view componentNamePattern;
    {
      static std::array<char, 33> componentFilterBuffer;
      ImGui::SameLine(0.0f, spacing);
      ImGui::Text("Componen:");
      ImGui::SameLine(0.0f, spacing);
      if (ImGui::InputText("  ", componentFilterBuffer.data(), componentFilterBuffer.size(), ImGuiInputTextFlags_None)) {
        ImguiRenderer* guiRenderer = context->renderer->getGuiRenderer();
        if (guiRenderer) {
          guiRenderer->addTextToGlyphBuilder(componentFilterBuffer.data());
        }
      }
      componentNamePattern = componentFilterBuffer.data();
    }
 
    ImGui::PopItemWidth();
 
    // Get entity search. Special: startes with '+' only show entities with several refs.
    // Possible leaked refs. E.g. both a child and stored in store->entities.
    bool showOnlyMultiRefs = false;
    if (!entityNamePattern.empty() && entityNamePattern[0] == '+') {
      showOnlyMultiRefs = true;
      entityNamePattern = entityNamePattern.substr(1);
    }
 
 
    ImGui::BeginChild("Child");
    for (const auto& [id, entity] : entities) {
      bool showEntity = entity.operator bool();
      if (showOnlyMultiRefs) {
        showEntity = entity.use_count() > 1;
      }
 
      if (showEntity && (!entityNamePattern.empty() || !componentNamePattern.empty())) {
        showEntity = findHierarchyWithMatch(*entity, entityNamePattern, componentNamePattern);
      }
 
      if (showEntity && onlyRootEntities) {
        showEntity = context->store->getEntityParent(entity.get()) == nullptr;
      }
 
      if (showEntity) {
        showCollapsableEntityInspector(context, entity.get(), entityNamePattern, componentNamePattern);
      }
    }
    ImGui::EndChild();
 
    guiEnd();
  }
}