IsoSurfaces.h

#pragma once
#include "Resources/Resources.h"
#include "Services/TaskManager.h"
#include "Base.h"
 
#include "Foundation/Memory/MemoryBuffer.h"
 
#include <glm/glm.hpp>
 
#include <atomic>
#include <vector>
 
namespace Cogs::Core {
  class Context;
}
 
namespace Cogs::Core::IsoSurfaces
{
 
  struct Scratch
  {
    struct ijk_t {
      uint16_t i, j, k;
      uint8_t code;
      uint8_t axes;
    };
    Cogs::Memory::TypedBuffer<int32_t> cellMap;
    Cogs::Memory::TypedBuffer<uint8_t> activeCellCases;
    Cogs::Memory::TypedBuffer<int32_t> activeCellVertexOffsets;
    Cogs::Memory::TypedBuffer<int32_t> activeCellIndexOffsets;
    Cogs::Memory::TypedBuffer<int32_t> activeCellIndices;
    Cogs::Memory::TypedBuffer<ijk_t> activeCellIJK;
    Cogs::Memory::TypedBuffer<uint32_t> indices;
  };
 
  MeshHandle COGSCORE_DLL_API createIsoSurfacesMesh(Context* context,
                                                    Scratch& scratch,                     //< Scratch memory, can be recycled between invocations.
                                                    const std::vector<float>& thresholds, //< List of up to 16 threshold values.
                                                    const float* densityField,            //< Pointer to a 3D array of scalar float values.
                                                    const float* dataField,               //< Optional data field, may be null, mapped to texcoord Y.
                                                    const glm::uvec3 fieldSize,           //< The dimensions of field.
                                                    const glm::vec3 minCorner,            //< The spatial position of the minimum corner of the scalar field grid.
                                                    const glm::vec3 maxCorner,            //< The spatial position of the maximum corner of the scalar field grid.
                                                    const bool exteriorIsInside = true,
                                                    const bool flipOrientation = true,
                                                    const bool closeZNeg = true,          //< Close surface at the Z negative face or leave it open?
                                                    const bool closeZPos = true,
                                                    const bool closeYNeg = true,
                                                    const bool closeYPos = true,
                                                    const bool closeXNeg = true,
                                                    const bool closeXPos = true,
                                                    MeshHandle mesh = MeshHandle::NoHandle);
 
  void COGSCORE_DLL_API analyze(Context* context,
                                std::vector<int32_t>& vertexOffsets,  // [L]
                                std::vector<int32_t>& indexOffsets,   // [L]
                                std::vector<int32_t>& cellOffsets,    // [L]
                                Memory::TypedBuffer<int32_t>& cellMap,
                                Memory::TypedBuffer<uint8_t>& activeCellCases,
                                Memory::TypedBuffer<int32_t>& activeCellVertexOffsets, // One element per active cell.
                                Memory::TypedBuffer<int32_t>& activeCellIndexOffsets, // One element per active cell.
                                Memory::TypedBuffer<int32_t>& activeCellIndices,            // One element per active cell.
                                Memory::TypedBuffer<Scratch::ijk_t>& activeCellIJK,            // One element per active cell.
                                const std::vector<float>& thresholds,
                                const bool exteriorIsInside,
                                const float* field,
                                const glm::ivec3 fieldDim,
                                const glm::ivec3 gridA,
                                const glm::ivec3 gridB,
                                std::atomic<uint64_t>* elapsed_us = nullptr);
 
  typedef std::function<void(int32_t ixIndex, glm::ivec4* samples, const uint32_t ixN)> VertexEmitFunc;
 
  void COGSCORE_DLL_API extractVertices(Context* context,
                                        TaskId group,
                                        VertexEmitFunc vertexEmit,
                                        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 = nullptr);
 
 
  typedef std::function<void(uint32_t ixIndex, glm::ivec3 cell, const uint32_t* indices, const uint32_t ixN)> IndexEmitFunc;
 
  void COGSCORE_DLL_API extractIndices(Context*         context,
                                       TaskId group,
                                       IndexEmitFunc&   emitFunc,
                                       const int32_t* cellMap,
                                       const uint8_t* activeCellCases,
                                       const int32_t* activeCellVertexOffsets,
                                       const int32_t* activeCellIndexOffsets,
                                       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 = nullptr);
 
 
}