LoadRvmCommand.cpp

#include "imgui.h"
 
#include "LoadRvmCommand.h"
#include "Editor.h"
#include "Context.h"
#include "EditorState.h"
#include "Resources/ModelManager.h"
#include "Components/Core/ModelComponent.h"
#include "Commands/EditorCommand.h"
#include "Foundation/Platform/IO.h"
#include "Foundation/Logging/Logger.h"
 
namespace
{
  const Cogs::Logging::Log logger = Cogs::Logging::getLogger("LoadRvmCommand");
}
 
Cogs::Core::LoadRvmCommand::LoadRvmCommand(EditorState* state, const StringView& path, bool openInRoot, bool synchronous) :
  ModalEditorCommand(state), pathStr(path), openInRoot(openInRoot), synchronous(synchronous)
{
  fileName = Cogs::IO::fileName(pathStr);
 
  // Initialize rvmparser options, existing variables take precedence over stated defaulted values
  createOption<bool>(rvmMdb2, "rvm.mdb2", true);
  createOption<bool>(rvmMdb2GuessHierarchy, "rvm.mdb2.guessHierarchy", true);
  createOption<bool>(rvmInheritAttributes, "rvm.inheritAttributes", false);
  createOption<float>(rvmTessellateTolerance, "rvm.tessellate.tolerance", 0.01f);
  createOption<float>(rvmTessellateFeatureAngle, "rvm.tessellate.featureAngle", 0.7f);
  createOption<float>(rvmTessellateCullDiameter, "rvm.tessellate.cullDiameter", -1.f);
  createOption<bool>(rvmParseColorize, "rvm.parse.colorize", true);
  createOption<bool>(rvmParseIgnoreAttributeIndentation, "rvm.parse.ignoreAttributeIndentation", true);
  createOption<bool>(rvmParseIgnoreAttributeHierarchy, "rvm.parse.ignoreAttributeHierarchy", false);
  createOption<bool>(rvmParseAllowReparent, "rvm.parse.allowReparent", true);
  createOption<bool>(rvmVueExperimental, "rvm.vue.experimental", false);
}
 
void Cogs::Core::LoadRvmCommand::beginModal()
{
  modal = true;
}
 
void Cogs::Core::LoadRvmCommand::showGui()
{
  assert(modal);
 
  ImGui::OpenPopup("Rvmparser file options");
  if (ImGui::BeginPopupModal("Rvmparser file options", nullptr, ImGuiWindowFlags_AlwaysAutoResize)) {
 
    ImGui::Text("File: %s", fileName.c_str());
    ImGui::Separator();
    ImGui::PushItemWidth(ImGui::GetWindowWidth() * 0.4f);
 
    ImGui::Checkbox(rvmMdb2.key.data(), &rvmMdb2.value);
    ImGui::Checkbox(rvmMdb2GuessHierarchy.key.data(), &rvmMdb2GuessHierarchy.value);
    ImGui::Checkbox(rvmInheritAttributes.key.data(), &rvmInheritAttributes.value);
 
    ImGui::InputFloat(rvmTessellateTolerance.key.data(), &rvmTessellateTolerance.value);
    ImGui::InputFloat(rvmTessellateFeatureAngle.key.data(), &rvmTessellateFeatureAngle.value);
    ImGui::InputFloat(rvmTessellateCullDiameter.key.data(), &rvmTessellateCullDiameter.value);
 
    ImGui::Checkbox(rvmParseColorize.key.data(), &rvmParseColorize.value);
    ImGui::Checkbox(rvmParseIgnoreAttributeIndentation.key.data(), &rvmParseIgnoreAttributeIndentation.value);
    ImGui::Checkbox(rvmParseIgnoreAttributeHierarchy.key.data(), &rvmParseIgnoreAttributeHierarchy.value);
    ImGui::Checkbox(rvmParseAllowReparent.key.data(), &rvmParseAllowReparent.value);
 
    ImGui::Checkbox(rvmVueExperimental.key.data(), &rvmVueExperimental.value);
 
    ImGui::Separator();
    ImGui::PopItemWidth();
 
    ImGui::SetItemDefaultFocus();
    if (ImGui::Button("OK", ImVec2(120, 0))) {
      loadFile();
      modal = false;
      ImGui::CloseCurrentPopup();
    }
    ImGui::SameLine();
    if (ImGui::Button("Cancel", ImVec2(120, 0))) {
      modal = false;
      ImGui::CloseCurrentPopup();
    }
    ImGui::EndPopup();
  }
}
 
bool Cogs::Core::LoadRvmCommand::continueModal()
{
  return modal;
}
 
void Cogs::Core::LoadRvmCommand::loadFile()
{
  std::string name = Cogs::IO::stem(pathStr);
  std::unique_ptr<CreateEntityCommand> newCommand = std::make_unique<CreateEntityCommand>(state, "ModelEntity", name, openInRoot);
  EditorCommand* createCommand = state->editor->doApply(std::move(newCommand));
 
  createCommand->permanentUndo = true;
  Cogs::ComponentModel::Entity* selected = state->getSelected();
  if (!selected) {
    LOG_ERROR(logger, "Could not create Entity ModelEntity");
    return;
  }
 
  ModelComponent* modelComponent = selected->getComponent<ModelComponent>();
 
  ModelLoadInfo*  loadInfo = context->modelManager->createLoadInfo();
 
  loadInfo->resourceId = NoResourceId;
  loadInfo->resourcePath = pathStr;
  ModelLoadFlags flags = ModelLoadFlags::DisableOptimization | (synchronous ? ModelLoadFlags::ForceSynchronous : ModelLoadFlags::None);
  loadInfo->loadFlags = static_cast<ResourceLoadFlags>(flags);
  loadInfo->modelFlags = flags;
  if (context->variables->get("resources.models.autoReload", false)) {
    loadInfo->loadFlags |= ResourceLoadFlags::AutoReload;
  }
 
  loadInfo->properties = std::make_unique<PropertyStore>();
  for (RvmparserOptionBase* option : allOptions) {
    option->addPropertyTo(loadInfo->properties.get());
  }
 
  // Ownership of loadInfo will be passed to modelManager
  modelComponent->model = context->modelManager->loadResource(loadInfo);
  modelComponent->waitForSubresources = false;
  modelComponent->setChanged();
}