RRTasks.cpp

#include <rrapi/rrapi.h>
 
#include "Platform/Instrumentation.h"
 
#include "../Extensions/GeometryProcessing/GeometryProcessing.h"
#include "RRTasks.h"
 
#include "Foundation/Logging/Logger.h"
 
#include <glm/gtc/type_ptr.hpp>
 
namespace {
  Cogs::Logging::Log logger = Cogs::Logging::getLogger("RationalReducer");
 
  struct TriangleData
  {
    size_t meshIndex;
    Cogs::Core::MaterialInstance * material;
  };
 
  rr_bool_t extractPrimitives(void * handle, void * userdata)
  {
    CpuInstrumentationScope(SCOPE_RATIONALREDUCER, "RRextractPrimitives");
 
    auto * task = static_cast<Cogs::Core::RRTaskBase *>(userdata);
    auto * state = task->state;
    auto & inputSet = state->meshSets.front();
 
    for (size_t m = 0; m < inputSet.meshes.size(); m++) {
      auto & mesh = inputSet.meshes[m];
 
      auto transverts = rr_add_vertices(handle, (int)mesh.positions.size(), reinterpret_cast<const float *>(mesh.positions.data()));
 
      auto triangleData = static_cast<TriangleData*>(rr_malloc(handle, static_cast<unsigned int>(sizeof(TriangleData))));
      triangleData->meshIndex = m;
      triangleData->material = state->items.meshes[m].matlInst;
 
      glm::vec2 * tex = nullptr;
      if (task->textured) {
        tex = static_cast<glm::vec2*>(rr_malloc(handle, static_cast<unsigned int>(sizeof(glm::vec2) * 3 * mesh.indices.size())));
        if (mesh.texcoords.size() != 0) {
          for (size_t i = 0; i < mesh.indices.size(); i++) {
            tex[i] = mesh.texcoords[mesh.indices[i]];
          }
        }
        else {
          for (size_t i = 0; i < mesh.indices.size(); i++) {
            tex[i] = glm::vec2(0.f);
          }
        }
      }
 
      for (size_t i = 0; i < mesh.indices.size(); i += 3) {
        rr_add_indexed_polygon(handle, 3, reinterpret_cast<int*>(mesh.indices.data() + i), transverts, triangleData, reinterpret_cast<float*>(tex ? tex + i : nullptr), RR_REDUCABLE);
      }
    }
    return TRUE;
  }
 
 
  rr_bool_t stuffPrimitives(void *handle, void *userdata)
  {
    CpuInstrumentationScope(SCOPE_RATIONALREDUCER, "RRstuffPrimitives");
 
    auto * task = static_cast<Cogs::Core::RRTaskBase *>(userdata);
    auto * state = task->state;
 
    auto Nt = static_cast<unsigned>(rr_get_num_triangles(handle));
 
    // If identical, just skip.
    if (state->meshSets.back().triangles == Nt || Nt == 0) return TRUE;
 
 
    // Group triangles by mesh
    state->meshSets.emplace_back();
    auto & currentSet = state->meshSets.back();
 
    currentSet.triangles = Nt;
    currentSet.error = rr_get_approximation_error(handle);
    currentSet.bboxMin = state->meshSets.front().bboxMin;
    currentSet.bboxMax = state->meshSets.front().bboxMax;
    currentSet.meshes.resize(state->meshSets.front().meshes.size());
 
    if (Nt == 0) {
      currentSet.error = glm::distance(currentSet.bboxMin, currentSet.bboxMax);
    }
 
    LOG_TRACE(logger, "Stuff primitives invoked error=%f, triangles=%d", currentSet.error, currentSet.triangles);
 
    std::vector<std::vector<rr_triangle_t*>> groupedTriangles(currentSet.meshes.size());
    for (unsigned i = 0; i < currentSet.triangles; 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);
    }
 
    for (size_t l = 0; l < currentSet.meshes.size(); l++) {
      auto & mesh = currentSet.meshes[l];
      auto & triangles = groupedTriangles[l];
 
      mesh.indices.clear();
      if (triangles.empty()) {
        mesh.positions.clear();
        mesh.normals.clear();
        mesh.texcoords.clear();
        mesh.tangents.clear();
        continue;
      }
 
      mesh.positions.resize(3 * triangles.size(), false);
      mesh.normals.clear();
 
      for (size_t j = 0; j < triangles.size(); j++) {
        for (unsigned i = 0; i < 3; i++) {
          auto * vertex = rr_triangle_get_vertex(triangles[j], i);
          mesh.positions[3 * j + i] = glm::make_vec3(rr_vertex_get_coord(vertex));
        }
      }
 
      if (mesh.texcoords.size() != 0 || task->textured) {
        mesh.texcoords.resize(3 * triangles.size(), false);
        for (size_t j = 0; j < triangles.size(); j++) {
          auto * tex = rr_triangle_get_texcoords(triangles[j]);
          for (size_t i = 0; i < 3; i++) {
            mesh.texcoords[3 * j + i] = tex ? glm::make_vec2(tex + 2 * i) : glm::vec2(0.f);
          }
        }
      }
    }
 
    // Mesh is non-indexed with crappy faceted normals. But we have other EditorCommands to fix that.
 
    return TRUE;
  }
 
 
  void progressModal(float fraction, void *userdata)
  {
    auto * task = static_cast<Cogs::Core::RRTaskBase *>(userdata);
    auto * state = task->state;
 
    state->progress = fraction;
    if (state->cancel) {
      rr_abort(task->rrHandle);
    }
  }
 
  void progressBatch(float fraction, void *userdata)
  {
    auto * task = static_cast<Cogs::Core::RRTaskBase *>(userdata);
    auto * state = task->state;
 
    if (floor(10.f*(state->progress)) != floor(10.f*fraction)) {
      float appError = rr_get_approximation_error(task->rrHandle);
      LOG_TRACE(logger, "Progress=%.1f%%, approximation error=%f", 100.f*fraction, appError);
    }
 
    state->progress = fraction;
 
    if (state->cancel) {
      rr_abort(task->rrHandle);
    }
  }
 
  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;
  }
}
 
void Cogs::Core::RRTaskBase::initRR()
{
  assert(state->meshSets.size() == 1);
 
  auto & inputSet = state->meshSets.front();
  inputSet.triangles = 0;
  inputSet.error = 0.f;
  textured = false;
 
  inputSet.bboxMin = glm::vec3(std::numeric_limits<float>::max());
  inputSet.bboxMax = glm::vec3(-std::numeric_limits<float>::max());
 
  for (auto & mesh : inputSet.meshes) {
    for (size_t i = 0; i < mesh.positions.size(); i++) {
      inputSet.bboxMin = glm::min(inputSet.bboxMin, mesh.positions[i]);
      inputSet.bboxMax = glm::max(inputSet.bboxMax, mesh.positions[i]);
    }
 
    textured = textured || mesh.texcoords.size() != 0;
    inputSet.triangles += static_cast<int>(mesh.indices.size() / 3);
  }
 
  //LOG_DEBUG(logger, "bbox: [%f, %f, %f]x[%f, %f, %f]",
  //          inputSet.bboxMin.x, inputSet.bboxMin.y, inputSet.bboxMin.z,
  //          inputSet.bboxMax.x, inputSet.bboxMax.y, inputSet.bboxMax.z);
 
  rrHandle = rr_init(textured);
 
  state->progress = 0.f;
  rr_set_extract_primitives(rrHandle, ::extractPrimitives, &state);
  rr_set_stuff_primitives(rrHandle, ::stuffPrimitives, &state);
  rr_set_simple_progress(rrHandle, modal ? ::progressModal : ::progressBatch, &state);
  rr_set_same_texture(rrHandle, ::sameMaterial, &state);
  rr_set_same_material(rrHandle, ::sameMaterial, &state);
  rr_set_same_surfaceappearance(rrHandle, ::sameMaterial, &state);
  rr_set_num_native_triangles(rrHandle, inputSet.triangles);
  rr_set_epsilon(rrHandle, epsilon);
 
  if (edgeLengthWeight != 1.0f) {
    rr_set_edgelength_weight(rrHandle, edgeLengthWeight);
  }
}
 
void Cogs::Core::RRTaskBase::runRR()
{
  auto & inputSet = state->meshSets.front();
  if (inputSet.bboxMin.x == inputSet.bboxMax.x && inputSet.bboxMin.y == inputSet.bboxMax.y) return;
 
  auto ret = rr_reduce(rrHandle);
  rr_end(rrHandle);
 
  switch (ret)
  {
  case RR_OK: {
    std::vector<glm::vec3> N;
    std::vector<uint32_t> map;
    std::vector<uint32_t> unique;
 
    std::vector<uint32_t> newIndices;
 
 
    for (auto & meshSet : state->meshSets) {
      for (auto & mesh : meshSet.meshes) {
 
        // Create indexed mesh
        if (!textured) mesh.texcoords.clear();
        mesh.normals.clear();
 
        map.clear();
        unique.clear();
        GeometryProcessing::uniqueVertexSubset(state->context, unique, map,
                                               (float*)mesh.positions.data(),
                                               3 * sizeof(float),
                                               mesh.normals.size() ? (float*)mesh.normals.data() : nullptr,
                                               3 * sizeof(float),
                                               mesh.texcoords.size() ? (float*)mesh.texcoords.data() : nullptr,
                                               2 * sizeof(float),
                                               static_cast<uint32_t>(mesh.positions.size()), std::numeric_limits<float>::epsilon());
 
        if (mesh.indices.size() == 0) {
          mesh.indices.resize(mesh.positions.size(), false);
          for (size_t i = 0; i < mesh.positions.size(); i++) {
            mesh.indices[i] = uint32_t(i);
          }
        }
      
        remapVertices(state->context, mesh, unique);
        remapIndices(state->context, mesh, map);
 
        // Add normals
        N.clear();
        unique.clear();
        newIndices.clear();
        GeometryProcessing::normalsFromIndexedTriangles(state->context,
                                                        N, unique, newIndices,
                                                        reinterpret_cast<const float*>(mesh.positions.data()), 3 * sizeof(float), static_cast<uint32_t>(mesh.positions.size()),
                                                        mesh.indices.data(), static_cast<uint32_t>(mesh.indices.size()),
                                                        normalGenArgs.featureAngle,
                                                        normalGenArgs.protrusionAngle,
                                                        normalGenArgs.flip);
        assert(N.size() == unique.size());
 
        remapVertices(state->context, mesh, unique);
 
        mesh.indices.resize(newIndices.size());
        std::memcpy(mesh.indices.data(), newIndices.data(), sizeof(uint32_t)*newIndices.size());
 
        mesh.normals.resize(unique.size(), false);
        std::memcpy(mesh.normals.data(), N.data(), mesh.normals.byteSize());
      }
    }
 
    state->running = false;
    return;
    break;
  }
  case RR_ABORT: LOG_WARNING(logger, "rr_reduce returned RR_ABORT"); break;
  case RR_CALLBACK_ERROR: LOG_ERROR(logger, "rr_reduce returned RR_CALLBACK_ERROR"); break;
  case RR_ERROR:
    // RR Fails. Will have invalid data. No normals. Remove failing meshes.
    for (auto& meshSet : state->meshSets) {
      meshSet.triangles = 0;
      meshSet.meshes.clear();
    }
    LOG_ERROR(logger, "rr_reduce returned RR_ERROR. Meshes deleted");
    break;
  case RR_NODATA: LOG_ERROR(logger, "rr_reduce returned RR_NODATA"); break;
  case RR_NONUMTRIS: LOG_ERROR(logger, "rr_reduce returned RR_NONUMTRIS"); break;
  default:
    assert(0);
    break;
  }
  state->cancel = true;
  state->running = false;
}
 
 
void Cogs::Core::RRTriangleGuidedTask::operator()()
{
  CpuInstrumentationScope(SCOPE_RATIONALREDUCER, "RRtask");
  initRR();
  rr_set_percentage(rrHandle, percentage);
  runRR();
}
 
void Cogs::Core::RRMinMaxErrorGuidedTask::operator()()
{
  CpuInstrumentationScope(SCOPE_RATIONALREDUCER, "RRtask");
  initRR();
  rr_set_minmax_error(rrHandle, error_threshold);
  runRR();
}
 
void Cogs::Core::RRMultiTriangleGuidedTask::operator()()
{
  CpuInstrumentationScope(SCOPE_RATIONALREDUCER, "RRtask");
  initRR();
 
  assert(!thresholds.empty());
  auto steps = thresholds.size();
 
  auto Nt = state->meshSets.front().triangles;
  std::vector<unsigned> lodLevels(steps);
  for (size_t i = 0; i < steps; i++) {
    lodLevels[i] = unsigned(std::max(0.f, 0.01f*Nt*thresholds[i]));
  }
 
  if (1 < steps) {
    rr_set_lod_levels(rrHandle, unsigned(steps - 1), lodLevels.data());
  }
  rr_set_target_tris(rrHandle, lodLevels.back());
  runRR();
}
 
void Cogs::Core::RRMultiMinMaxErrorGuidedTask::operator()()
{
  CpuInstrumentationScope(SCOPE_RATIONALREDUCER, "RRtask");
  initRR();
 
  assert(!thresholds.empty());
  auto steps = thresholds.size();
 
  if (1 < steps) {
    rr_set_error_lod_levels(rrHandle, unsigned(steps - 1), thresholds.data());
  }
  rr_set_minmax_error(rrHandle, thresholds.back());
  runRR();
}