RationalReducerExtension.cpp

#include "ExtensionRegistry.h"
 
#include "Components/Core/DynamicComponent.h"
#include "Components/Core/TransformComponent.h"
#include "Components/Core/MeshRenderComponent.h"
#include "Components/Core/SceneComponent.h"
 
#include "Context.h"
#include "EntityStore.h"
 
#include "Renderer/Renderer.h"
#include "Renderer/RenderPipelineManager.h"
#include "Renderer/Tasks/RenderTaskFactory.h"
 
#include "Resources/ResourceStore.h"
#include "Resources/MaterialInstance.h"
 
#include "Editor.h"
 
#include "Services/Services.h"
 
#include "AnnotationComponent.h"
#include "RationalReducerComponent.h"
#include "MeshReductionManager.h"
#include "RRSimplifyCommand.h"
#include "RRMultiSimplifyCommand.h"
#include "RRSaveAllLodCommand.h"
 
#include "Foundation/ComponentModel/Entity.h"
#include "Foundation/Logging/Logger.h"
 
using namespace Cogs::Core;
using namespace Cogs::Reflection;
 
namespace {
  Cogs::Logging::Log logger = Cogs::Logging::getLogger("RationalReducer");
 
 
  struct MeshItem
  {
    MeshComponent* meshComp;
    MaterialInstanceHandle& mat;
  };
 
  void populateMeshItems(std::vector<MeshItem>& items, Cogs::ComponentModel::Entity* root)
  {
    if (auto * sceneComp = root->getComponent<SceneComponent>(); sceneComp) {
      for (auto & child : sceneComp->children) {
        populateMeshItems(items, child.get());
      }
    }
    if (auto * meshComp = root->getComponent<MeshComponent>(); meshComp && meshComp->meshHandle) {
      if (auto * meshRenderComp = root->getComponent<MeshRenderComponent>(); meshRenderComp && meshRenderComp->material) {
        items.emplace_back(MeshItem{meshComp, meshRenderComp->material });
      }
    }
  }
 
 
  struct RationalReducerCommand : public EditorCommand
  {
    RationalReducerCommand(EditorState * state) : EditorCommand(state, state->context) {}
 
        TaskId id = NoTask;
 
        virtual bool done() {
                LOG_DEBUG(logger, "done\n");
                return true;
        }
 
    void apply() override
    {
      auto entity = state->getSelected();
      if (!entity) return;
 
      std::vector<MeshItem> items;
      populateMeshItems(items, entity);
 
      if (items.empty()) return;
      
      std::vector<Mesh *> meshes;
      std::vector<MaterialInstance *> mats;
      for (auto & item : items) {
        meshes.push_back(item.meshComp->meshHandle.resolve());
        mats.push_back(item.mat.resolve());
      }
      
      float reductionPercent = 90.f;
      float reductionEpsilon = 0.05f;
 
      auto manager = context->services->getService<Cogs::RationalReducerExtension::MeshReductionManager>();
      //manager->setAddNormals(true);
      auto reducedMeshes = manager->reduce(meshes, mats, std::clamp(reductionPercent, 0.0f, 100.0f), reductionEpsilon);
 
      if (reducedMeshes.size() != items.size()) {
        LOG_ERROR(logger, "Expected %zu meshes from reduce, got %zu.", items.size(), reducedMeshes.size());
      }
      else {
        for (size_t i = 0; i < items.size(); i++) {
          items[i].meshComp->meshHandle = reducedMeshes[i];
          items[i].meshComp->setChanged();
        }
        LOG_DEBUG(logger, "Simplified %zu meshes", items.size());
      }
    }
 
    void undo() override
    {
 
    }
 
  };
 
}
 
 
namespace Cogs
{
  namespace RationalReducerExtension
  {
 
    struct RationalReducerExtension : public Extension
    {
      
      RationalReducerExtension() 
      { 
        ExtensionRegistry::add(this, COGS_CORE_VERSION_STRING);
      }
 
      virtual bool initializeStatic() override
      {
        RationalReducerComponent::registerType();
        AnnotationComponent::registerType();
        TypeDatabase::createType<MeshReductionManager>();
        Editor::registerExtensionCommand("RRSimplify", [](EditorState * state) { return new RRSimplifiyCommand(state); });
        Editor::registerExtensionItem("RRSimplify", "RR Simplify Mesh");
        Editor::registerExtensionCommand("RRMultiSimplify", [](EditorState * state) { return new RRMultiSimplifyCommand(state); });
        Editor::registerExtensionItem("RRMultiSimplify", "RR create LOD levels");
        Editor::registerExtensionCommand("RRSaveAllLod", [](EditorState * state) { return new RRSaveAllLodCommand(state); });
        Editor::registerExtensionItem("RRSaveAllLod", "RR save LODs in separate files");
 
        //Editor::registerExtensionCommand("RationalReducer", [](EditorState * state) { return new RationalReducerCommand(state); });
        //Editor::registerExtensionItem("RationalReducer", "Reduce Mesh");
 
        return true;
      }
 
      virtual bool initialize(Context * context) override
      {
        context->registerDynamicComponentType("RationalReducerComponent");
        context->registerDynamicComponentType("AnnotationComponent");
        context->resourceStore->addSearchPath("../Extensions/RationalReducer/Data/");
        context->services->registerService<MeshReductionManager>(context);
 
        return true;
      }
 
      virtual void cleanup(Context * context) override
      {
        auto manager = context->services->getService<MeshReductionManager>();
 
        if (manager) {
          manager->cleanup();
        }
      }
 
      virtual const char * getExtensionKey() const override { return "RationalReducer"; }
    } rationalReducerExtensionInstance;
  }
}