RRMultiSimplifyCommand.cpp

#include "imgui.h"
#include <charconv>
#include "Components/Core/SceneComponent.h"
#include "Components/Core/LodComponent.h"
#include "Components/Core/TransformComponent.h"
#include "Components/Core/MeshRenderComponent.h"
#include "Resources/MaterialInstance.h"
#include "Resources/MaterialManager.h"
#include "EntityStore.h"
 
#include "Editor/Editor.h"
#include "Commands/EditorCommand.h"
#include "Rendering/Common.h"
 
#include "RRMultiSimplifyCommand.h"
 
namespace {
  using namespace Cogs::Core;
}
 
Cogs::Core::RRMultiSimplifyCommand::RRMultiSimplifyCommand(EditorState * state)
  : ModalEditorCommand(state)
{
  taskState.context = state->context;
}
 
bool Cogs::Core::RRMultiSimplifyCommand::initTaskData()
{
  // Extract all entities with an appropriate mesh
  taskState.items.transforms.clear();
  taskState.items.meshes.clear();
  getMeshItems(context, taskState.items, state->selected, 1 << Cogs::PrimitiveType::TriangleList);
  if (taskState.items.meshes.empty()) return false;
 
  UnpackOptions opts;
  opts.discardNormals = true;
  opts.discardTexCoords = false;
  opts.discardTangents = true;
  opts.forceIndexed = false;
 
  taskState.meshSets.clear();
  taskState.meshSets.emplace_back();
  unpackMeshItems(context, originalMeshes, taskState.meshSets.front().meshes, taskState.items, opts);
 
  return true;
}
 
namespace {
 
  void descendAndColorize(Cogs::ComponentModel::Entity* entity, MaterialInstanceHandle material)
  {
    if (auto * sceneComp = entity->getComponent<SceneComponent>()) {
      for (auto child : sceneComp->children) {
        descendAndColorize(child.get(), material);
      }
    }
    if (auto * mRndComp = entity->getComponent<MeshRenderComponent>()) {
      mRndComp->material = material;
    }
 
  }
 
}
 
void Cogs::Core::RRMultiSimplifyCommand::finishTaskData()
{
  if (taskState.cancel) return;
 
  ComponentModel::Entity * parent = nullptr;
  if (auto * sceneComp = state->getSelected()->getComponent<SceneComponent>()) {
    if (sceneComp->parent) {
      parent = sceneComp->parent.resolve()->getContainer();
    }
  }
 
  // Delete output from previous batch run existing (expect warning first time).
  // Don't have any "LODs" named entities...
  auto lodGroup = context->store->getEntity("LODs");
  if (lodGroup) {
    const auto id = lodGroup->getId();
    lodGroup.reset();
    context->store->destroyEntity(id);
  }
 
  lodGroup = context->store->createEntity("LODs", "Lod", parent == nullptr);
  if (parent) {
    context->store->addChild(parent, lodGroup);
  }
 
  auto * lodComp = lodGroup->getComponent<LodComponent>();
  lodComp->policy = LodPolicy::GeometricTolerance;
  lodComp->separateHierarchies = true;
  lodComp->thresholds.resize(taskState.meshSets.size());
  for (size_t i = 0; i < taskState.meshSets.size(); i++) {
    auto & meshSet = taskState.meshSets[i];
 
    lodComp->thresholds[i] = meshSet.error;
 
    EntityPtr hierarchy;
    if (singleMesh) {
      hierarchy = createAsSingleMeshItem(context, lodGroup.get(), originalMeshes, meshSet.meshes, taskState.items);
    }
    else {
      hierarchy = createNewMeshItems(context, lodGroup.get(), originalMeshes, meshSet.meshes, taskState.items);
    }
    hierarchy->setName("Level " + std::to_string(i));
 
    if (debugColors) {
      glm::vec4 c((i >> 2) & 1, (i >> 1) & 1, i & 1, 1);
      auto material = context->materialInstanceManager->createMaterialInstance(context->materialManager->getDefaultMaterial());
      material->setProperty("diffuseColor", glm::value_ptr(c), sizeof(c));
      descendAndColorize(hierarchy.get(), material);
    }
  }
  lodComp->setChanged();
 
  state->selected = EntityIds{ lodGroup->getId() };
}
 
void Cogs::Core::RRMultiSimplifyCommand::apply()
{
  std::vector<float> thresholds;
 
  for (auto & option : options) {
    if (option.key == "epsilon") option.asFloat(epsilon);
    else if (option.key == "thresholds") {
      auto & val = option.value;
 
      size_t a = 0;
      while (a < val.length()) {
        auto b = val.find(',', a);
        thresholds.push_back(std::stof(val.substr(a, b == std::string::npos ? b : b - a)));
        if (b == std::string::npos) break;
        a = b + 1;
      }
    }
    else if (option.key == "errorGuided") option.asBool(error_guided);
 
    else if (option.key == "featureAngle") option.asFloat(normalGenArgs.featureAngle);
    else if (option.key == "protrusionAngle") option.asFloat(normalGenArgs.protrusionAngle);
    else if (option.key == "flip") option.asBool(normalGenArgs.flip);
    else if (option.key == "singleMesh") option.asBool(singleMesh);
 
  }
 
 
  steps = std::max(1, steps);
 
  if (initTaskData())
  {
    if (error_guided) {
      RRMultiMinMaxErrorGuidedTask task(&taskState, false, epsilon, thresholds, normalGenArgs);
      task();
    }
    else {
      RRMultiTriangleGuidedTask task(&taskState, false, epsilon, thresholds, normalGenArgs);
      task();
    }
 
    finishTaskData();
  }
}
 
bool Cogs::Core::RRMultiSimplifyCommand::issueTask()
{
  if (initTaskData()) {
    std::vector<float> thresholds(steps);
    for (int i = 0; i < steps; i++) {
      auto t = (i + 1.f) / steps;
      assert(0 <= t);
      thresholds[i] = error * t;
    }
    taskState.cancel = false;
    taskState.running = true;
    if (error_guided) {
      task = context->taskManager->enqueue(context->taskManager->GlobalQueue, RRMultiMinMaxErrorGuidedTask(&taskState, false, epsilon, thresholds, normalGenArgs));
    }
    else {
      std::vector<float> thresholds_(steps);
      for (int i = 0; i < steps; i++) {
        auto t = (steps - i - 1.f) / steps;
        assert(0 <= t);
        thresholds_[i] = 100.f * t * t * t * t;
      }
      task = context->taskManager->enqueue(context->taskManager->GlobalQueue, RRMultiTriangleGuidedTask(&taskState, false, epsilon, thresholds_, normalGenArgs));
    }
    return true;
  }
  return false;
}
 
void  Cogs::Core::RRMultiSimplifyCommand::waitForTask()
{
  context->taskManager->wait(task);
  task = NoTask;
  finishTaskData();
}
 
void Cogs::Core::RRMultiSimplifyCommand::showParameterGui()
{
  const char * label = "RR multi-level mesh simplification";
 
  ImGui::OpenPopup(label);
  if (ImGui::BeginPopupModal(label, NULL)) {
 
    ImGui::InputFloat("Vertex merge epsilon", &epsilon);
 
    const char* modes[] = { "Error-driven", "Triangle count-driven" };
    int mode_current = error_guided ? 0 : 1;
    ImGui::Combo("Simplification guide", &mode_current, modes, 2);
    error_guided = mode_current == 0;
 
    if (error_guided) {
      ImGui::InputFloat("Min-max error threhold", &error);
    }
    ImGui::SliderInt("Steps", &steps, 1, 25);
 
    ImGui::Separator();
 
    ImGui::Checkbox("Merge lod level into single mesh", &singleMesh);
    ImGui::SliderAngle("Feature angle", &normalGenArgs.featureAngle, 0.f, 180.f);
    ImGui::SliderAngle("Protrusion angle", &normalGenArgs.protrusionAngle, 0.f, 180.f);
    ImGui::Checkbox("Flip normals", &normalGenArgs.flip);
 
    ImGui::Separator();
 
    ImGui::Checkbox("Debug-colorize levels", &debugColors);
    ImGui::Separator();
    if (ImGui::Button("Simplify", ImVec2(120, 0))) {
      modal = issueTask();
    }
    //ImGui::SetItemDefaultFocus();
 
    ImGui::SameLine();
    if (ImGui::Button("Cancel", ImVec2(120, 0))) {
      taskState.cancel = true;
      modal = false;
      ImGui::CloseCurrentPopup();
    }
    ImGui::EndPopup();
  }
}
 
void Cogs::Core::RRMultiSimplifyCommand::showProgressGui()
{
  const char * label = "Simplification in progress";
 
  ImGui::OpenPopup(label);
  if (ImGui::BeginPopupModal(label, NULL)) {
    ImGui::ProgressBar(taskState.progress);
 
    ImGui::Separator();
    if (ImGui::Button("Cancel", ImVec2(120, 0))) {
      taskState.cancel = true;
    }
    ImGui::EndPopup();
  }
}
 
void Cogs::Core::RRMultiSimplifyCommand::beginModal()
{
  modal = true;
}
 
void Cogs::Core::RRMultiSimplifyCommand::showGui()
{
  if (taskState.running == false) {
    showParameterGui();
  }
  else {
    showProgressGui();
  }
}
 
bool Cogs::Core::RRMultiSimplifyCommand::continueModal()
{
  if (!taskState.running && task.isValid()) {
    waitForTask();
    modal = false;
  }
  return modal;
}