VariableInspector.cpp

#include "Inspectors.h"
 
#include "Context.h"
#include "Renderer/IRenderer.h"
#include "InspectorGuiHelper.h"
#include "Services/Variables.h"
#include "Utilities/Parsing.h"
 
#include "Foundation/Reflection/TypeDatabase.h"
 
#include "imgui.h"
 
#include <algorithm>
 
using namespace Cogs::Reflection;
 
namespace Cogs
{
  namespace Core
  {
    struct InputUserData
    {
      Context * context;
      Variable * variable;
    };
 
    int inputCallback(ImGuiInputTextCallbackData* /*data*/)
    {
      return 0;
    }
  }
}
 
void Cogs::Core::variableInspector(Context * context, bool * show)
{
  if (*show) {
    ImGui::SetNextWindowSize(ImVec2(600, 1000), ImGuiCond_Once);
 
    guiBegin("Variables", show);
 
    auto & variables = context->variables->getVariables();
 
    std::unordered_map<std::string, std::vector<Variable *>> groupedVars;
    std::vector<std::string> groups;
 
    for (auto & p : variables) {
      auto splits = split(p.second.getName(), ".");
 
      if (splits.size() > 1) {
        std::string name(splits[0]);
        auto & group = groupedVars[name];
 
        if (group.empty()) {
          groups.emplace_back(name);
        }
 
        group.push_back(&p.second);
      } else if (splits.size() > 0) {
        auto & group = groupedVars["global"];
 
        group.push_back(&p.second);
      }
    }
 
    std::sort(groups.begin(), groups.end());
 
    for (auto & g : groups) {
      auto gs = groupedVars[g];
      if (gs.size()) {
        if (ImGui::CollapsingHeader(g.c_str())) {
          ScopedIndent si;
 
          // Sort by name.
          std::sort(gs.begin(), gs.end(), [](const Variable* a, const Variable* b) { return a->getName() < b->getName(); });
          for (auto & pp : gs) {
            auto & variable = *pp;
 
            auto pName = variable.getName().data();
            std::string buffer(variable.getValue());
            buffer.resize(128);
 
            InputUserData userData = {
              context,
              &variable,
            };
 
            auto type = variable.getType();
 
            switch (type) {
            case ParsedDataType::Bool:
            {
              bool value = variable.getBool();
              if (ImGui::Checkbox(pName, &value)) {
                variable.setBool(value);
              }
              break;
            }
            case ParsedDataType::Float:
            {
              float value = variable.getFloat();
              if (ImGui::DragFloat(pName, &value)) {
                variable.setFloat(value);
              }
              break;
            }
            case ParsedDataType::Double:
            {
              float value = (float)variable.getDouble();
              if (ImGui::DragFloat(pName, &value)) {
                variable.setDouble(value);
              }
              break;
            }
            case ParsedDataType::Int:
            {
              int value = variable.getInt();
              if (ImGui::DragInt(pName, &value)) {
                variable.setInt(value);
              }
              break;
            }
            default:
              if (ImGui::InputText(pName, buffer.data(), buffer.size(), ImGuiInputTextFlags_EnterReturnsTrue, inputCallback, &userData)) {
 
                ImguiRenderer* guiRenderer = context->renderer->getGuiRenderer();
                if (guiRenderer) {
                  guiRenderer->addTextToGlyphBuilder(buffer.data());
                }
 
                variable.setValue(buffer.c_str());
              }
              break;
            }
          }
        }
      }
 
 
    }
 
    guiEnd();
  }
}