RRSaveAllLodCommand.cpp

#include "imgui.h"
#include "Commands/CommandHelpers.h"
#include "Commands/CommandParseHelpers.h"
#include "Commands/ExportCommand.h"
#include "EditorState.h"
#include "Editor/Editor.h"
 
#include "Context.h"
#include "Renderer/IRenderer.h"
#include "Renderer/InspectorGui/InspectorGuiRenderer.h"
 
#include "Components/Core/LodComponent.h"
#include "Components/Core/SceneComponent.h"
 
#include "RRSaveAllLodCommand.h"
#include "RRSaveAllLodCommand.h"
#include "Rendering/Common.h"
 
#include "Platform/Instrumentation.h"
 
#include "Scene/GetBounds.h"
 
#include "Foundation/Logging/Logger.h"
#include "Foundation/Platform/IO.h"
 
#define _SILENCE_CXX17_ITERATOR_BASE_CLASS_DEPRECATION_WARNING
#include "rapidjson/document.h"
#include "rapidjson/stringbuffer.h"
#include "rapidjson/prettywriter.h"
#undef _SILENCE_CXX17_ITERATOR_BASE_CLASS_DEPRECATION_WARNING
 
#include <cassert>
#include <fstream>
 
using namespace rapidjson;
 
namespace {
  Cogs::Logging::Log logger = Cogs::Logging::getLogger("RRSaveAllLodCommand");
 
  const char * label1 = "RR LOD Save All";
 
  uint64_t getModelSizeEstimate(const std::string & filename)
  {
    auto fh = Cogs::IO::openFile(filename, Cogs::FileHandle::OpenMode::Open, Cogs::FileHandle::AccessMode::Read);
    uint64_t size = Cogs::IO::fileSize(fh);
    return size;
  }
 
  void storeLodSidecarfile(std::string path,
                           const std::string & sourcePath,
                           const float threshold,
                           const std::vector<Cogs::Core::ParsedValue> & options,
                           Cogs::Geometry::BoundingBox bbox)
  {
    path = Cogs::Core::replaceFileMacros(path, options);
    auto jsonpath = path + ".json";
    const auto filename = Cogs::IO::fileName(jsonpath);
    Document doc;
    doc.SetObject();
    auto & alloc = doc.GetAllocator();
    doc.AddMember("error", Value().SetFloat(threshold), alloc);
    doc.AddMember("byteSize", Value().SetUint64(getModelSizeEstimate(path)), alloc);
    doc.AddMember("path", Value().SetString(filename.c_str(), alloc), alloc);
    doc.AddMember("offset", Value().SetUint(0), alloc);
    doc.AddMember("source", Value().SetString(sourcePath.c_str(), alloc), alloc);
 
    Value box(kArrayType);
    box.PushBack(Value().SetFloat(bbox.min.x), alloc);
    box.PushBack(Value().SetFloat(bbox.min.y), alloc);
    box.PushBack(Value().SetFloat(bbox.min.z), alloc);
    box.PushBack(Value().SetFloat(bbox.max.x), alloc);
    box.PushBack(Value().SetFloat(bbox.max.y), alloc);
    box.PushBack(Value().SetFloat(bbox.max.z), alloc);
    doc.AddMember("bbox", box, alloc);
 
    StringBuffer buffer;
    PrettyWriter<StringBuffer> writer(buffer);
    doc.Accept(writer);
 
    LOG_DEBUG(logger, "Writing JSon sidecar: '%s'.", jsonpath.c_str());
    std::ofstream file(jsonpath.c_str());
    file.write(buffer.GetString(), buffer.GetSize());
    file.close();
  }
}
 
namespace Cogs::Core
{
  RRSaveAllLodCommand::RRSaveAllLodCommand(EditorState * state)
    : ModalEditorCommand(state)
  {
    path.resize(128, '\0');
  }
 
  void RRSaveAllLodCommand::apply()
  {
    bool hasStem = false;
    bool hasExtension = false;
    std::string batchSource;
    for (auto & option : options) {
 
      if (option.key == "path")
      {
        path.resize(0);
        path.insert(path.begin(), std::begin(option.value), std::end(option.value));
      }
      else if (option.key == "source") {
        batchSource = option.value;
      }
      else if (option.key == "stem") {
        hasStem = true;
      }
      else if (option.key == "extension") {
        hasExtension = true;
      }
    }
 
    if (!hasStem) {
      auto fileName = IO::fileName(batchSource);
      auto stem = IO::stem(fileName);
 
      auto & stemValue = options.emplace_back();
      stemValue.key = "stem";
      stemValue.value = stem;
    }
    if (!hasExtension) {
      auto fileName = IO::fileName(batchSource);
      auto extension = IO::extension(batchSource);
 
      auto & extensionValue = options.emplace_back();
      extensionValue.key = "extension";
      extensionValue.value = extension;
    }
 
    // Run the task and wait for completion
    issueTask();
  }
 
 
  void RRSaveAllLodCommand::beginModal()
  {
    modal = true;
  }
 
  void RRSaveAllLodCommand::showGui()
  {
    if (modal) {
      // Config gui
      ImGui::OpenPopup(label1);
      if (ImGui::BeginPopupModal(label1, nullptr)) {
 
        if (ImGui::InputText("Path", path.data(), path.size())) {
 
          ImguiRenderer* guiRenderer = context->renderer->getGuiRenderer();
          if (guiRenderer) {
            guiRenderer->addTextToGlyphBuilder(path.data());
          }
 
        }
 
        ImGui::Separator();
 
        if (ImGui::Button("Save", ImVec2(120, 0))) {
          modal = issueTask();
          ImGui::CloseCurrentPopup();
        }
 
        ImGui::EndPopup();
      }
    }
  }
 
  bool RRSaveAllLodCommand::continueModal()
  {
    return modal;
  }
 
  void RRSaveAllLodCommand::runTask()
  {
    while (!path.empty() && path.back() == ' ')
      path.resize(path.size() - 1);
 
    auto entity = state->getSelected();
    if (entity == nullptr) {
      LOG_ERROR(logger, "No Selected entity.");
      return;
    }
 
    auto lodComp = entity->getComponent<LodComponent>();
    if (lodComp == nullptr) {
      LOG_ERROR(logger, "No LodComponent in entity to save.");
      return;
    }
 
    auto sourcePath = getOption(options, "source", "");
    auto sceneComponent = entity->getComponent<SceneComponent>();
 
    Cogs::Geometry::BoundingBox bb;
    bb = state->context->bounds->getBounds(context, state->getSelected(), true);
 
    size_t index = 0;
    for (auto threshold : lodComp->thresholds)
    {
      EntityPtr child = sceneComponent->children[index];
 
      SelectCommand select(state, child->getId());
      select.apply();
 
      ExportCommand cmd(state, child->getId());
      cmd.options = options;
      auto & opt = cmd.options.emplace_back();
      opt.key = "fileName";
      opt.value = std::string(path.empty() ? "" : path.data()) + "_" + std::to_string(threshold) + ".cogsbin";
      opt.type = ParsedDataType::String;
      cmd.apply();
 
      auto outputPath = opt.value;
      if (IO::isRelative(outputPath)) {
        auto destination = getOption(options, "destination").to_string();
        outputPath = IO::combine(destination, outputPath);
      }
 
      storeLodSidecarfile(outputPath, sourcePath.to_string(), threshold, options, bb);
 
      index++;
    }
 
    // Select old entity.
    SelectCommand select(state, entity->getId());
    select.apply();
  }
 
  bool RRSaveAllLodCommand::issueTask()
  {
    runTask();
    running = false;
 
    // Value of modal is returned.
    return false;
  }
}