MeshReductionManager.cpp

#include "MeshReductionManager.h"
 
#include "Context.h"
#include "Resources/MeshManager.h"
 
#include "../Extensions/GeometryProcessing/GeometryProcessing.h"
 
#include "Foundation/Geometry/NormalGenerator.hpp"
#include "Foundation/Logging/Logger.h"
 
#include <rrapi/rrapi.h>
 
using namespace Cogs::RationalReducerExtension;
 
namespace
{
  Cogs::Logging::Log logger = Cogs::Logging::getLogger("RR::MeshReductionManager");
 
 
  struct ReductionState
  {
    Context* context = nullptr;
    size_t triangleCount = 0;
    size_t reducedCount = 0;
    std::vector<Mesh *> original;
    std::vector<MeshHandle> reduced;
    std::vector<MaterialInstance *> materials;
    void * rrHandle = nullptr;
    bool textured = false;
    bool hasNormals = false;
    bool addNormals = true;
    class MeshReductionManager * manager = nullptr;
  };
 
  void dummyprogress(float /*fraction*/, void* /*userdata*/)
  {
  }
 
  /*
  * Write progress info Logging system.
  */
  void progress(float fraction, void* /*userdata*/)
  {
    //auto state = static_cast<ReductionState *>(userdata);
    LOG_INFO(logger, "Reduction Progress %d", (int)(fraction * 100));
  }
 
  //Add a single mesh to RR
  void addMesh(ReductionState * state, Mesh * mesh, MaterialInstance * material, int index)
  {
    auto handle = state->rrHandle;
 
    auto vertices = mesh->copyData<glm::vec3>(Cogs::ElementSemantic::Position, Cogs::DataFormat::X32Y32Z32_FLOAT);
    auto texcoords = mesh->copyData<glm::vec2>(Cogs::ElementSemantic::TextureCoordinate, Cogs::DataFormat::X32Y32_FLOAT);
    auto normals = mesh->copyData<glm::vec3>(Cogs::ElementSemantic::Normal, Cogs::DataFormat::X32Y32Z32_FLOAT);
    state->hasNormals = state->hasNormals || normals.size();
 
    //Add all vertices to RR
    auto transverts = rr_add_vertices(handle, (int)vertices.size(), reinterpret_cast<const float *>(vertices.data()));
 
    auto triangleData = static_cast<TriangleData*>(rr_malloc(handle, static_cast<unsigned int>(sizeof(TriangleData))));
    triangleData->meshIndex = index;
    triangleData->material = material;
 
    glm::vec2 * tex = nullptr;
    bool textured = state->textured && texcoords.size();
    if (textured) {
      tex = static_cast<glm::vec2*>(rr_malloc(handle, static_cast<unsigned int>(sizeof(glm::vec2) * 3 * state->triangleCount)));
    }
 
    //FIXME: Assumes indexed triangle set
    int indices[3];
    auto indexes = mesh->getIndexes();
    for (size_t t = 0; t < indexes.size() / 3; t++) {
      auto iA = indices[0] = indexes[t * 3];
      auto iB = indices[1] = indexes[t * 3 + 1];
      auto iC = indices[2] = indexes[t * 3 + 2];
 
 
      if (textured) {
        tex[t * 3] = texcoords[iA];
        tex[t * 3 + 1] = texcoords[iB];
        tex[t * 3 + 2] = texcoords[iC];
      }
 
      rr_add_indexed_polygon(handle, 3, indices, transverts, triangleData, textured ? reinterpret_cast<float *>(&tex[t * 3]) : NULL, RR_REDUCABLE);
    }
  }
 
  /*
  * Extraction callback.
  */
  rr_bool_t extractPrimitives(void * /*handle*/, void * userdata)
  {
    auto state = static_cast<ReductionState *>(userdata);
 
    for (int i = 0, s = static_cast<int>(state->original.size()); i < s; i++) {
      addMesh(state, state->original[i], state->materials[i], i);
    }
 
    /* Everything is OK */
    return TRUE;
  }
 
  /*
  * Stuffing callback.
  */
  rr_bool_t stuffPrimitives(void *handle, void *userdata)
  {
          auto state = static_cast<ReductionState *>(userdata);
          const auto numTriangles = rr_get_num_triangles(handle);
          //const auto numVertices = rr_get_num_vertices(handle);
 
          // Group triangles by mesh
          std::vector<std::vector<rr_triangle_t*>> groupedTriangles(state->original.size());
          for (int i = 0; i < numTriangles; i++) {
                  auto rr_triangle = rr_get_triangle(handle, i);
                  auto * triangleData = static_cast<TriangleData*>(rr_triangle_get_data(rr_triangle));
                  groupedTriangles[triangleData->meshIndex].push_back(rr_triangle);
          }
 
          // Process triangles mesh by mesh.
          state->reduced.resize(state->original.size());
          for (size_t l = 0; l < groupedTriangles.size(); l++) {
                  auto & triangles = groupedTriangles[l];
                  if (triangles.empty()) continue;
 
                  auto bbox = Cogs::Geometry::makeEmptyBoundingBox<Cogs::Geometry::BoundingBox>();
                  std::vector<glm::vec3> P; P.reserve(triangles.size());
                  std::vector<glm::vec2> T; T.reserve(triangles.size());
                  for (auto & triangle : triangles) {
                          for (unsigned i = 0; i < 3; i++) {
                                  auto * vertex = rr_triangle_get_vertex(triangle, i);
                                  P.emplace_back(glm::make_vec3(rr_vertex_get_coord(vertex)));
                                  bbox += P.back();
                          }
                          auto * tex = rr_triangle_get_texcoords(triangle);
                          if (tex) {
                                  for (unsigned i = 0; i < 3; i++) {
                                          T.emplace_back(glm::make_vec2(tex + 2 * i));
                                  }
                          }
                  }
                  if (P.size() != T.size() && !T.empty()) {
                          LOG_WARNING(logger, "Mesh with texture coordinates on only some of the triangles.");
                          T.clear();
                  }
 
                  std::vector<uint32_t> unique;
                  std::vector<uint32_t> map;
 
 
                  if constexpr (true || T.empty()) {
            GeometryProcessing::uniqueVertexSubset(state->context, unique, map,
                                                   (const float*)P.data(), 3 * sizeof(float),
                                                   nullptr, 0,
                                                   nullptr, 0,
                                                   (uint32_t)P.size());
                          std::vector<glm::vec3> P_(unique.size());
                          for (size_t i = 0; i < unique.size(); i++) {
                                  P_[i] = P[unique[i]];
                          }
                          P.swap(P_);
                  }
                  else {
                          assert(P.size() == T.size());
              GeometryProcessing::uniqueVertexSubset(state->context, unique, map,
                                                     (const float*)P.data(), 3 * sizeof(float),
                                                     nullptr, 0,
                                                     (const float*)T.data(), 2 * sizeof(float),
                                                     (uint32_t)P.size());
                          std::vector<glm::vec3> P_(unique.size());
                          std::vector<glm::vec2> T_(unique.size());
                          for (size_t i = 0; i < unique.size(); i++) {
                                  P_[i] = P[unique[i]];
                                  T_[i] = T[unique[i]];
                          }
                          P.swap(P_);
                          T.swap(T_);
                  }
 
                  auto proxy = state->context->meshManager->createLocked();
 
                  std::vector<glm::vec3> N;
                  if (state->addNormals) {
#if 1
                          T.clear();
                          std::vector<uint32_t> remap;
                          std::vector<uint32_t> newIndices;
                          GeometryProcessing::normalsFromIndexedTriangles(state->context,
                                                              N, remap, newIndices,
                                                              reinterpret_cast<const float*>(P.data()), 3 * sizeof(float), static_cast<uint32_t>(P.size()),
                                                              map.data(), static_cast<uint32_t>(map.size()));
 
                          std::vector<glm::vec3> P_(remap.size());
                          for (size_t i = 0; i <P_.size(); i++) {
                                  P_[i] = P[remap[i]];
                          }
                          P.swap(P_);
 
                          map.swap(newIndices);
 
#else
                          N.resize(P.size());
                          Cogs::Core::normalsFromIndexedTriangles(state->context,
                                                                                                          reinterpret_cast<float*>(N.data()), 3,
                                                                                                          reinterpret_cast<const float*>(P.data()), 3, P.size(),
                                                                                                          map.data(), map.size());
 
                          for (auto & n : N) {
                                  n = -n;
                          }
#endif
                  }
                  if (state->original[l]->isMeshFlagSet(MeshFlags::ClockwiseWinding)) {
                          proxy->setMeshFlag(MeshFlags::ClockwiseWinding);
                  }
                  else {
                          proxy->unsetMeshFlag(MeshFlags::ClockwiseWinding);
                  }
 
                  proxy->setPositions(P);
                  if (!T.empty()) {
                          proxy->setTexCoords(T);
                  }
                  if (!N.empty()) {
                          proxy->setNormals(N);
                  }
 
                  proxy->setBounds(bbox);
                  proxy->setIndexData(std::move(map));
                  proxy->primitiveType = Cogs::PrimitiveType::TriangleList;
                  state->reduced[l] = proxy.getHandle();
          }
 
          return TRUE;
  }
 
  float sameTexture(void * triangle1data, void * triangle2data, void * /*userdata*/)
  {
    auto tri1 = static_cast<TriangleData *>(triangle1data);
    auto tri2 = static_cast<TriangleData *>(triangle2data);
    return tri1->material == tri2->material ? 0.0f : 1.0f; //FIXME: for now, assume different material pointer means different texture
  }
 
  float sameMaterial(void* triangle1data, void* triangle2data, void* /*userdata*/)
  {
    auto tri1 = static_cast<TriangleData*>(triangle1data);
    auto tri2 = static_cast<TriangleData*>(triangle2data);
    return tri1->material == tri2->material ? 0.0f : 1.0f; //FIXME: for now, assume different material pointer means different material
  }
 
  bool anyTextured(std::vector<Mesh *> meshes)
  {
    for (auto & mesh : meshes) {
      auto[_, num, __] = mesh->getSemanticStream(Cogs::ElementSemantic::TextureCoordinate, Cogs::DataFormat::X32Y32_FLOAT);
      bool textured = num != 0;
      if (textured) return true;
    }
    return false;
  }
 
}
 
 
 
 
 
void MeshReductionManager::cleanup()
{
 
}
 
 
std::vector<MeshHandle> MeshReductionManager::reduce(std::vector<Mesh *> meshes, std::vector<MaterialInstance *> materials, float percent, float epsilon)
{
  /* Let RR know how many triangles we've got. */
  size_t numTriangles = 0;
  for(auto & mesh : meshes) numTriangles += mesh->getIndexes().size() / 3; //FIXME: Assumes indexed triangle set
 
  std::vector<MeshHandle> reduced(meshes.size());
  for (auto & red : reduced) red = context->meshManager->create();
 
  ReductionState state;
  state.context = context;
  state.textured = anyTextured(meshes);
  state.addNormals = addNormals;
  state.rrHandle = rr_init(state.textured);
  state.original = meshes;
  state.materials = materials;
  state.manager = this;
  //state.reduced.resize(meshes.size());
  //for (auto & r : state.reduced) r = context->meshManager->create();
  for (auto & m : state.original) state.triangleCount += m->getIndexes().size() / 3;
 
  //ReductionState state(meshes, reduced, materials, this, numTriangles, anyTextured(meshes));
 
  auto & rrHandle = state.rrHandle;
 
  //Register our functions
  rr_set_extract_primitives(rrHandle, extractPrimitives, &state);
  rr_set_stuff_primitives(rrHandle, stuffPrimitives, &state);
  if (loglevel > 1) {
    rr_set_simple_progress(rrHandle, progress, &state);
  }
  else {
    rr_set_simple_progress(rrHandle, dummyprogress, &state);
  }
 
  rr_set_same_texture(rrHandle, sameTexture, &state);
  rr_set_same_material(rrHandle, sameTexture, &state);
  rr_set_same_surfaceappearance(rrHandle, sameTexture, &state);
 
  //Set options
  rr_set_num_native_triangles(rrHandle, (int)numTriangles);
  rr_set_epsilon(rrHandle, epsilon);
  rr_set_percentage(rrHandle, percent);
 
  /* Reduce! */
  auto ret = rr_reduce(rrHandle);
  rr_end(state.rrHandle);
 
  if (ret != RR_OK) {
    LOG_ERROR(logger, "Reduction error.  #Triangles: %d", (int)numTriangles);
    return std::vector<MeshHandle>();
  }
  else if (loglevel > 0) {
    LOG_INFO(logger, "Reduction Complete");
  }
 
  return state.reduced;
}
 
MeshHandle Cogs::RationalReducerExtension::MeshReductionManager::reduce(Mesh * mesh, float percent, float epsilon)
{
  auto meshes = std::vector<Mesh *>();
  meshes.push_back(mesh);
 
  auto materials = std::vector<MaterialInstance *>();
  materials.push_back(NULL);
 
  auto reduced = reduce(meshes, materials, percent, epsilon);
  return reduced[0];
}