IndexConversion.cpp

#include "IndexConversion.h"
 
// Cogs.js (EMSCRIPTEN) cannot use binary libraries from ZipMan, so it needs to compile all from sources, Libtess2 in this case
// When built from source, tesselator.h is inside the "Include" folder in Libtess2 source tree (added as a project search path)
// Using ZipMan binaries, it is located at "xxx/include/libtess2/tesselator.h" with "xxx/include" in the search path
#ifdef EMSCRIPTEN
  #include "tesselator.h"
#else
  #include "libtess2/tesselator.h"
#endif
 
#include "Resources/Mesh.h"
 
namespace Cogs {
  // Wraps a position-index pair to be able to sort/reindex by tesselator and
  // get original index back.
  struct IndexedPosition
  {
    glm::vec3 position;
    int32_t index = 0;
  };
}
 
void Cogs::Core::tesselate(const glm::vec3*       contours,
                           const size_t           count,
                           const size_t           stride,
                           std::vector<uint32_t>& triangleIndexes,
                           uint32_t               base) {
  const int       polySize = 3;
  TESStesselator* tess = tessNewTess(nullptr);
 
  tessAddContour(tess, polySize, contours, static_cast<int>(stride), static_cast<int>(count));
 
  if (!tessTesselate(tess, TESS_WINDING_POSITIVE, TESS_POLYGONS, 3, 3, nullptr)) {
    return;
  }
 
  const int elementCount = tessGetElementCount(tess);
  const auto elements = tessGetElements(tess);
  const auto indexes = tessGetVertexIndices(tess);
 
  triangleIndexes.reserve(base + elementCount * polySize);
 
  for (int i = 0; i < elementCount; ++i) {
    const auto poly = &elements[i * polySize];
 
    bool valid = true;
    uint32_t polyIndexes[polySize];
 
    for (int j = 0; j < polySize; ++j) {
      const TESSindex index = indexes[poly[j]];
 
      valid &= (index >= 0) && ((size_t)index < count);
 
      polyIndexes[j] = base + static_cast<uint32_t>(index);
    }
 
    if (valid) {
      triangleIndexes.insert(triangleIndexes.end(), std::begin(polyIndexes), std::end(polyIndexes));
    }
  }
 
  tessDeleteTess(tess);
}
 
std::vector<int32_t> Cogs::Core::tesselatePolygons(std::vector<int32_t> & inputIndexes, Mesh * mesh)
{
  if (inputIndexes.size()) {
    std::vector<uint32_t> indexes;
    size_t currentIndex = 0;
 
    auto addPolygon = [&](size_t base, size_t numVertexes)
    {
      auto [data, count, stride] = mesh->getPositionStream();
 
      std::vector<IndexedPosition> positions(numVertexes);
 
      for (size_t i = 0; i < numVertexes; ++i) {
        const uint32_t index = inputIndexes[base + i];
        assert(index < count && "Vertex index out of bounds.");
        positions[i].index = index;
        positions[i].position = *reinterpret_cast<glm::vec3 *>(data + index * stride);
      }
 
      std::vector<uint32_t> positionIndexes;
      tesselate(reinterpret_cast<const glm::vec3 *>(positions.data()), numVertexes, sizeof(IndexedPosition), positionIndexes);
 
      for (size_t i = 0; i < positionIndexes.size(); ++i) {
        indexes.push_back(positions[positionIndexes[i]].index);
      }
 
      currentIndex = indexes.size();
    };
 
    size_t idx = 0;
    while (idx < inputIndexes.size()) {
      const size_t base = idx;
 
      while (inputIndexes[idx++] != -1 && idx < inputIndexes.size()) {}
 
      size_t numVertexes = idx - base - 1;
 
      addPolygon(base, numVertexes);
    }
 
    std::vector<int32_t> output((indexes.size() / 3) * 4);
 
    for (size_t i = 0; i < indexes.size() / 3; ++i) {
      output[i * 4 + 0] = indexes[i * 3 + 0];
      output[i * 4 + 1] = indexes[i * 3 + 1];
      output[i * 4 + 2] = indexes[i * 3 + 2];
      output[i * 4 + 3] = -1;
    }
 
    return output;
  }
 
  return std::vector<int32_t>();
}
 
void Cogs::Core::reindex(const std::vector<int32_t> & inputIndexes, Mesh * mesh, bool isLine)
{
  if (inputIndexes.size()) {
    std::vector<uint32_t> indexes;
    size_t currentIndex = 0;
 
    if (!isLine) {
 
      auto addTriangle = [&](size_t base)
      {
        indexes.resize(indexes.size() + 3);
        indexes[currentIndex++] = inputIndexes[base];
        indexes[currentIndex++] = inputIndexes[base + 1];
        indexes[currentIndex++] = inputIndexes[base + 2];
      };
 
      auto addQuad = [&](size_t base)
      {
        indexes.resize(indexes.size() + 6);
        indexes[currentIndex++] = inputIndexes[base];
        indexes[currentIndex++] = inputIndexes[base + 1];
        indexes[currentIndex++] = inputIndexes[base + 2];
 
        indexes[currentIndex++] = inputIndexes[base];
        indexes[currentIndex++] = inputIndexes[base + 2];
        indexes[currentIndex++] = inputIndexes[base + 3];
      };
 
      auto addPolygon = [&](size_t base, size_t numVertexes)
      {
        auto [data, count, stride] = mesh->getPositionStream();
 
        std::vector<IndexedPosition> positions(numVertexes);
 
        for (size_t i = 0; i < numVertexes; ++i) {
          const uint32_t index = inputIndexes[base + i];
          assert(index < count && "Vertex index out of bounds.");
          positions[i].index = index;
          positions[i].position = *reinterpret_cast<glm::vec3 *>(data + index * stride);
        }
 
        std::vector<uint32_t> positionIndexes;
        tesselate(reinterpret_cast<const glm::vec3 *>(positions.data()), numVertexes, sizeof(IndexedPosition), positionIndexes);
 
        for (size_t i = 0; i < positionIndexes.size(); ++i) {
          indexes.push_back(positions[positionIndexes[i]].index);
        }
 
        currentIndex = indexes.size();
      };
 
      size_t idx = 0;
      while (idx < inputIndexes.size()) {
        const size_t base = idx;
 
        while (inputIndexes[idx++] != -1 && idx < inputIndexes.size()) {}
 
        size_t numVertexes = idx - base - 1;
 
        if (numVertexes == 3) {
          addTriangle(base);
        } else if (numVertexes == 4) {
          addQuad(base);
        } else {
          addPolygon(base, numVertexes);
        }
      }
    } else {
      for (size_t i = 0; i < inputIndexes.size() - 1; ++i) {
        if (inputIndexes[i] != -1 && inputIndexes[i + 1] != -1) {
          indexes.push_back(inputIndexes[i]);
          indexes.push_back(inputIndexes[i + 1]);
        }
      }
 
      mesh->primitiveType = PrimitiveType::LineList;
    }
 
    mesh->setIndexData(indexes.data(), indexes.size());
  }
}