ExtractVertices.cpp

#include "Platform/Instrumentation.h"
#include "Services/TaskManager.h"
#include "Context.h"
 
#include "MarchingCubesTables.h"
#include "IsoSurfaces_internal.h"
 
#include "Foundation/Platform/Timer.h"
#include "Foundation/Platform/Threads.h"
 
namespace {
 
  struct ExtractVtxTask
  {
    Cogs::Core::Context* context = nullptr;
    const uint8_t* axesTable = nullptr;
    const uint8_t* activeCellCases = nullptr;
    const int32_t* activeCellVertexOffsets = nullptr;
    const int32_t* activeCellIndices = nullptr;
    const Cogs::Core::IsoSurfaces::Scratch::ijk_t* activeCellIJK = nullptr;
    glm::ivec3 M;
    glm::ivec3 gridA;
    int ca = 0;
    int cb = 0;
    std::atomic<uint64_t>* elapsed_us = nullptr;
    Cogs::Core::IsoSurfaces::VertexEmitFunc emit;
 
    void operator()()
    {
      CpuInstrumentationScope(SCOPE_ISOSURFACES, "ExtVtx");
      auto timer = Cogs::Timer::startNew();
 
      glm::ivec4 samples[4];
      for (int c = ca; c < cb; c++) {
        auto oc = activeCellVertexOffsets[c];
        const auto on = activeCellVertexOffsets[c + 1];
        if (oc == on) continue;
 
        auto ijk = activeCellIJK[c];
 
        //auto q = activeCellIndices[c];
        //auto i = delinarize(q, M, gridA);
        auto i = glm::ivec3(ijk.i, ijk.j, ijk.k) + gridA;
 
        auto axes = ijk.axes;// axesTable[code];
 
 
        samples[0][0] = i.x;
        samples[1][0] = i.y;
        samples[2][0] = i.z;
 
        samples[0][1] = i.x;
        samples[1][1] = i.y;
        samples[2][1] = i.z + 1;
        uint32_t ixN = ((axes & 4) != 0) ? 1 : 0;
 
        samples[0][1 + ixN] = i.x;
        samples[1][1 + ixN] = i.y + 1;
        samples[2][1 + ixN] = i.z;
        ixN += ((axes & 2) != 0) ? 1 : 0;
 
        samples[0][1 + ixN] = i.x + 1;
        samples[1][1 + ixN] = i.y;
        samples[2][1 + ixN] = i.z;
        ixN += ((axes & 1) != 0) ? 1 : 0;
 
        emit(oc, samples, ixN);
 
        /*    if (axes & 4) {
              emit(oc++, i, i + ivec3(0, 0, 1));
            }
            if (axes & 2) {
              emit(oc++, i, i + ivec3(0, 1, 0));
            }
            if (axes & 1) {
              emit(oc++, i, i + ivec3(1, 0, 0));
            }*/
      }
 
      if (elapsed_us != nullptr) {
        elapsed_us->fetch_add(timer.elapsedMicroseconds());
      }
    }
  };
 
}
 
 
void Cogs::Core::IsoSurfaces::extractVertices(Context* context,
                                              TaskId group,
                                              VertexEmitFunc emitFunc,
                                              const uint8_t* activeCellCases,
                                              const int32_t* activeCellVertexOffsets,
                                              const int32_t* activeCellIndices,
                                              const Scratch::ijk_t* activeCellIJK,
                                              const int32_t activeCellCount,
                                              const glm::ivec3 gridA,
                                              const glm::ivec3 gridB,
                                              std::atomic<uint64_t>* elapsed_us)
{
  const auto & axesTable = MarchingCubes::axesTable();
  const glm::ivec3 M = gridB - gridA;
 
  const auto Q = static_cast<int>(Threads::hardwareConcurrency());
  const auto taskSize = std::max(1024, (activeCellCount + Q - 1) / Q);
  for (int c = 0; c < activeCellCount; c += taskSize) {
 
    ExtractVtxTask task;
    task.context = context;
    task.axesTable = axesTable.data();
    task.activeCellCases = activeCellCases;
    task.activeCellVertexOffsets = activeCellVertexOffsets;
    task.activeCellIndices = activeCellIndices;
    task.activeCellIJK = activeCellIJK;
    task.M = M;
    task.gridA = gridA;
    task.ca = c;
    task.cb = std::min(c + taskSize, activeCellCount);
    task.elapsed_us = elapsed_us;
    task.emit = emitFunc;
 
    context->taskManager->enqueueChild(group, task);
  }
}