RationalReducerComponent.cpp

#include "RationalReducerComponent.h"
#include "MeshReductionManager.h"
 
#include "Components/Core/MeshComponent.h"
#include "Components/Core/MeshRenderComponent.h"
#include "Components/Core/SceneComponent.h"
#include "Components/Core/ModelComponent.h"
 
#include "Context.h"
#include "Engine.h"
 
#include "Resources/Mesh.h"
#include "Resources/MaterialInstance.h"
#include "Services/Services.h"
 
#include "Foundation/ComponentModel/Component.h"
#include "Foundation/Reflection/TypeDatabase.h"
 
#include <stack>
 
using namespace Cogs::Core;
using namespace Cogs::ComponentModel;
using namespace Cogs::Reflection;
using namespace Cogs::RationalReducerExtension;
 
void RationalReducerComponent::registerType()
{
  Field fields[] = {
    Field(Name("reductionPercent"), &RationalReducerComponent::reductionPercent),
    Field(Name("reductionEpsilon"), &RationalReducerComponent::reductionEpsilon),
    Field(Name("enabled"), &RationalReducerComponent::enabled),
    Field(Name("loglevel"), &RationalReducerComponent::loglevel),
    Field(Name("addNormals"), &RationalReducerComponent::addNormals),
  };
 
  Method methods[] = {
    Method(Name("initialize"), &RationalReducerComponent::initialize),
    Method(Name("update"), &RationalReducerComponent::update),
  };
  DynamicComponent::registerDerivedType<RationalReducerComponent>().setFields(fields).setMethods(methods);
}
 
void RationalReducerComponent::initialize(Context * context)
{
  this->context = context;
}
 
namespace {
  void updateMeshComp(Context* context, MeshComponent* meshComp, MeshHandle handle)
  {
    if (handle) {
      if (meshComp->meshHandle != handle) {
        meshComp->meshHandle = handle;
        meshComp->setChanged();
        context->engine->setDirty();
      }
    }
  }
 
  void updateMeshComps(Context* context, std::vector<ComponentHandle> meshComps, std::vector<MeshHandle> handles)
  {
    for (size_t i = 0; i < meshComps.size(); i++)
    {
      if (i >= handles.size()) return;
      updateMeshComp(context, meshComps[i].resolveComponent<MeshComponent>(), handles[i]);
    }
  }
 
  std::vector<ComponentHandle> findMeshComps(Cogs::ComponentModel::Entity* entity)
  {
    std::stack<Cogs::ComponentModel::Entity*> candidates;
    candidates.push(entity);
 
    std::vector<ComponentHandle> comps;
 
    while (!candidates.empty()) {
      auto candidate = candidates.top();
      candidates.pop();
 
      auto meshComp = candidate->getComponent<MeshComponent>();
      if (meshComp != nullptr) comps.push_back(meshComp->getComponentHandle<MeshComponent>());
 
      auto sceneComp = candidate->getComponent<SceneComponent>();
      if (sceneComp != nullptr) {
        for (auto& child : sceneComp->children) {
          candidates.push(child.get());
        }
      }
    }
 
    return comps;
  }
}
 
void RationalReducerComponent::update()
{
  auto meshComps = findMeshComps(getContainer());
  if (meshComps.empty()) return; //No mesh components
 
  if (this->meshComponents.size() > 0 && !std::equal(meshComps.begin(), meshComps.end(), this->meshComponents.begin())) {
    //New mesh components detected, reset and start over
    originalMeshes.clear();
    reducedMeshes.clear();
    materials.clear();
    this->meshComponents = meshComps;
  }
  if (!enabled)
  {
    updateMeshComps(context, meshComps, originalMeshes);
    return;
  }
 
  //if (!meshComp->meshHandle) return; //No valid mesh
 
  if (reducedMeshes.size() > 0 && reductionPercent == lastPercent) {
    //already processed, if we have a reduced version, set it now as it might not have been ready earlier or we might have toggled enabled state
    updateMeshComps(context, meshComps, reducedMeshes);
    return;
  }
 
  lastPercent = reductionPercent;
 
  if (originalMeshes.size() == 0) {
    for (auto & handle : meshComps) {
      auto comp = handle.resolveComponent<MeshComponent>();
      originalMeshes.push_back(comp->meshHandle); //Keep the handle so it can be restored later
      auto mat = comp->getComponent<MeshRenderComponent>()->material;
      materials.push_back(mat);
      mat->setVariant("TangentSpaceNormalMap", false); //FIXME
    }
  }
  auto manager = context->services->getService<MeshReductionManager>();
 
  //FIXME: Should be moved to a task or background thread. Consider using resource system.
  std::vector<Mesh *> meshes;
  for (auto & handle : originalMeshes) meshes.push_back(handle.resolve());
  std::vector<MaterialInstance *> mats;
  for (auto & mat : materials) mats.push_back(mat.resolve());
 
  manager->setLogging(loglevel);
  manager->setAddNormals(addNormals);
  reducedMeshes = manager->reduce(meshes, mats, std::clamp(reductionPercent, 0.0f, 100.0f), reductionEpsilon);
 
  updateMeshComps(context, meshComps, reducedMeshes);
 
  //auto meshRender = meshComp->getComponent<MeshRenderComponent>();
  //auto & mat = meshRender->materialHandles[0];
  //mat->setVariant("TangentSpaceNormalMap", false);
  //mat->setVariant("SpecularMap", false);
  //mat->setVariant("EnableLighting", false);
  //mat->setVariant("LightModel", "BaseColor");
  //mat->setOption("CullMode", "None");
}