DensityFieldTask.cpp

#include "Platform/Instrumentation.h"
 
#include "../Extensions/IsoSurfaces/IsoSurfaces.h"
 
#include "Resources/Buffer.h"
 
#include "Blur.h"
 
#include "../Tasks/DensityFieldTask.h"
#include "../Systems/DensityFieldSystem.h"
 
#include "Foundation/Platform/Timer.h"
 
void Cogs::Core::Volumetric::DensityFieldTaskData::update(Context * ctx,
                                                          DensityFieldComponent &fieldComp,
                                                          DensityFieldData& fieldData,
                                                          BufferView<glm::vec3> positions,
                                                          BufferView<float> data)
{
  CpuInstrumentationScope(SCOPE_VOLUMETRIC, "DensityTask::update");
 
  context = ctx;
 
  thresholds = fieldComp.thresholds;
  if (16 < thresholds.size()) thresholds.resize(16);
 
  resolution = fieldData.resolution;
 
  dataAttached = fieldComp.attachData
    && data
    && data.size() == positions.size();
 
  const auto extent = fieldComp.extentMax - fieldComp.extentMin;
  const auto cellSize = glm::vec3(1.f / fieldComp.resolution.x,
                                  1.f / fieldComp.resolution.y,
                                  1.f / fieldComp.resolution.z)*extent;
 
 
  densityWeight = fieldComp.pointWeight;
  boxFilterWidth = Blur::boxFilterWidthFromStdDev(fieldComp.basisStdDev / glm::max(glm::max(cellSize.x, cellSize.y), cellSize.z),
                                                  fieldComp.basisQuality);
  boxFilterIterations = fieldComp.basisQuality;
  extentMin = fieldComp.extentMin;
  extentMax = fieldComp.extentMax;
 
  rPositions.resize(positions.size());
  rData.resize(positions.size());
 
  std::memcpy(rPositions.data(), positions.data(), rPositions.size() * sizeof(glm::vec3));
  if (dataAttached) {
    std::memcpy(rData.data(), data.data(), rData.size() * sizeof(float));
  }
 
  attachedDataScale = fieldComp.attachedDataScale;
  attachedDataOffset = fieldComp.attachedDataOffset;
}
 
void Cogs::Core::Volumetric::DensityFieldTask::operator()()
{
  CpuInstrumentationScope(SCOPE_VOLUMETRIC, "DensityTask::compute");
 
  auto & data = *persistentData.get();
 
  const glm::vec3 s = glm::vec3(data.resolution) / (data.extentMax - data.extentMin);
  const glm::vec3 o = -data.extentMin;
  const auto dts = data.attachedDataScale;
  const auto dto = data.attachedDataOffset;
 
  data.points.clear();
  data.points.reserve(data.rPositions.size());
 
  for (size_t i = 0; i < data.rPositions.size(); i++) {
    glm::uvec3 k(s*(data.rPositions.data()[i] + o));
    if ((k.x < data.resolution.x)
        && (k.y < data.resolution.y)
        && (k.z < data.resolution.z)) {
      data.points.push_back({ k, data.dataAttached ? dts * (data.rData.data()[i] + dto) : 0.f });
    }
  }
 
  const auto X = data.resolution.x;
  const auto Y = data.resolution.y;
  const auto Z = data.resolution.y;
  const auto numCells = X * Y * Z;
  const auto w = data.densityWeight;
 
  data.densityField.resize(numCells, false);
  std::memset(data.densityField.data(), 0, data.densityField.byteSize());
 
  auto phi = data.densityField.data();
  for (auto & p : data.points) {
    phi[(p.ix.z*Y + p.ix.y)*X + p.ix.x] += w;
  }
 
  data.densityFieldOut.resize(numCells, false);
  Blur::boxFilterIterations3D(data.context,
                              data.densityFieldOut.data(),
                              data.densityField.data(),
                              data.resolution,
                              data.boxFilterWidth,
                              data.boxFilterIterations);
 
  if (data.dataAttached) {
    data.dataField.resize(numCells);
    std::memset(data.dataField.data(), 0, data.dataField.byteSize());
 
    auto F = data.dataField.data();
 
    for (auto & p : data.points) {
      F[(p.ix.z*Y + p.ix.y)*X + p.ix.x] += w * p.data;
    }
 
    data.dataFieldOut.resize(numCells);
    Blur::boxFilterIterations3D(data.context,
                                data.dataFieldOut.data(),
                                data.dataField.data(),
                                data.resolution,
                                data.boxFilterWidth,
                                data.boxFilterIterations);
  }
 
  IsoSurfaces::Scratch scratch;
  data.mesh = IsoSurfaces::createIsoSurfacesMesh(data.context,
                                                 scratch,
                                                 data.thresholds,
                                                 data.densityFieldOut.data(),
                                                 data.dataAttached ? data.dataFieldOut.data() : nullptr,
                                                 data.resolution,
                                                 data.extentMin, data.extentMax, false, false, true, true, true, true, true, true,
                                                 data.mesh);
}