IsoSurfaces_internal.h

#pragma once
#include "IsoSurfaces.h"
 
#include "Foundation/Memory/MemoryBuffer.h"
 
#include <mutex>
#include <atomic>
#include <list>
#include <glm/glm.hpp>
 
namespace Cogs::Core::IsoSurfaces
{
  // Global state that the various analyze-pass tasks use.
  struct AnalyzeGlobalState {
    Context* context;
    const void* field;
    const void* thresholds;
 
    std::atomic<int32_t>* cellOffsets;  // We might have contention on these.
 
    int32_t* cellMap;
    uint8_t* activeCellCases;
    int32_t* activeCellIndices;
    std::atomic<uint64_t>* elapsed_us;
    std::mutex scratchLock;
    std::list<Cogs::Memory::MemoryBuffer*> scratchBuffers;
 
    glm::ivec3 tileSize;
    glm::ivec3 tiles;
    glm::ivec3 gridA;
    glm::ivec3 fieldDim;
    glm::ivec3 M;
    unsigned Nt;                        // Number of thresholds
    bool exteriorIsLess;
    bool tryToUseAVX2;
 
    Cogs::Memory::MemoryBuffer* scratchAcquire(uint32_t byteCount); // byte count is assumed to be consistent between invocations.
 
    void scratchRelease(Cogs::Memory::MemoryBuffer* scratch);
 
  };
 
  void analyzeTile_f32(AnalyzeGlobalState* g, const glm::ivec3 id);
  void analyzeTile_u16(AnalyzeGlobalState* g, const glm::ivec3 id);
 
#ifndef EMSCRIPTEN
  void analyzeTile_f32_SSE(AnalyzeGlobalState* stash, const glm::ivec3 id);
  void analyzeTile_u16_SSE(AnalyzeGlobalState* g, const glm::ivec3 id);
  void analyzeTile_f32_AVX2(AnalyzeGlobalState* g, const glm::ivec3 id);
  void analyzeTile_u16_AVX2(AnalyzeGlobalState* g, const glm::ivec3 id);
#endif
 
 
  inline int32_t linearize(const glm::ivec3& i,
                           const glm::ivec3& M,
                           const glm::ivec3& gridA)
  {
    return ((i.z - gridA.z)*M.y + (i.y - gridA.y))*M.x + (i.x - gridA.x);
  }
 
  inline glm::ivec3 delinarize(const glm::int32_t ix,
                               const glm::ivec3& M,
                               const glm::ivec3& gridA)
  {
    glm::ivec3 i;
    i.x = (ix % M.x) + gridA.x;
    i.y = ((ix / M.x) % M.y) + gridA.y;
    i.z = (ix / (M.x*M.y)) + gridA.z;
    return i;
  }
 
 
  struct AnalyzePrefixSum
  {
    TaskId antecedent;
    Context* context = nullptr;
    int32_t* actCellVtxOff = nullptr;
    int32_t* actCellIdxOff = nullptr;
    size_t Nc;
    std::atomic<uint64_t>* elapsed_us = nullptr;
 
    void operator()();
  };
 
  struct AnalyzePopulateCounts
  {
    struct Global
    {
      Context* context = nullptr;
      const uint8_t* axesTable = nullptr;
      const uint8_t* indexCountTable = nullptr;
      const uint8_t* actCellCasesIn = nullptr;
      const int32_t* actCellIndicesIn = nullptr;
      glm::ivec3 M;
      glm::ivec3 gridA;
      glm::ivec3 gridB;
      uint8_t* actCellCasesOut = nullptr;
      int32_t* actCellIndicesOut = nullptr;
      Scratch::ijk_t* actCellIJKOut = nullptr;
      int32_t* actCellVtxCntOut = nullptr;
      int32_t* actCellIdxCntOut = nullptr;
      std::atomic<uint64_t>* elapsed_us = nullptr;
    };
    Global* g = nullptr;
    size_t ca = 0;
    size_t cb = 0;
 
    void operator()();
  };
 
}