PotreeCell.cpp

#include "PotreeSystem.h"
 
#include "Context.h"
#include "Engine.h"
 
#include "Rendering/IGraphicsDevice.h"
#include "Rendering/IBuffers.h"
 
#include "Foundation/Logging/Logger.h"
#include "Foundation/Platform/IO.h"
 
namespace {
  using namespace Cogs::Core;
  Cogs::Logging::Log logger = Cogs::Logging::getLogger("Potree");
 
}
 
void Cogs::Core::PotreeCell::appendDescendSteps(std::string& path) const
{
  auto steps = prefix;
  for (unsigned i = 0; i < l; i++) {
    path.push_back('0' + (steps & 0x7));
    steps = steps >> 3;
  }
}
 
void Cogs::Core::PotreeCell::fetchData(Context* context, PotreeSystem* poSystem, const PotreeComponent* poComp, PotreeData* poData)
{
  // Change state
  assert(state == PotreeCell::State::None);
  state = PotreeCell::State::Issued;
 
  std::string url;
  uint64_t fileOffset = 0u;
  uint64_t fileByteSize = 0u;
  if (poData->versionMajor == 1) {
    url = poData->octreeDir;
    url.append(owningSubtree->path);
    url.push_back('r');
    url.append(owningSubtree->prefix);
    appendDescendSteps(url);
    url.append(poData->suffix);
  }
  else {
    url = poData->rootPath + "octree.bin";
    fileOffset = byteOffset;
    fileByteSize = byteCount;
  }
 
  // Either decompress during transfer or handle this when receiving result.
  Cogs::FileContentsHints hints = Cogs::FileContentsHints::None;
  switch (poData->encoding)
  {
  case PotreeEnconding::ZStd:
    hints = Cogs::FileContentsHints::ZStdDecompress;
    break;
  case PotreeEnconding::Brotli:
    hints = Cogs::FileContentsHints::BrotliDecompress;
    break;
  default:
    break;
  }
 
  // Issue fetch
  PotreeSystem::startFetch(context, poComp, poData);
 
  PotreeDecodeInData decodeArgs{
    .layoutInfo = PotreeSystem::vertexLayoutInfo[static_cast<size_t>(poData->layout)],
    .attributes = poData->attributes,
    .cellPos = glm::uvec4((owningSubtree->i << this->l) + this->i,
                          (owningSubtree->j << this->l) + this->j,
                          (owningSubtree->k << this->l) + this->k,
                          owningSubtree->l + this->l),
    .posScale = poData->positionDecode.scale,
    .posShift = poData->positionDecode.shift,
    .encoding = poData->encoding,
    .occGridDim = poData->occupancyGridDim,
    .fullBBoxMin = poData->octtreeFrame.fullBBoxMin,
    .fullBBoxSize = poData->octtreeFrame.fullBBoxSize
  };
  if (poData->versionMajor == 1) {
    // Points in data file has the minimum corner of the oct-tree cell as origin
    //auto shift = poData->active.bbmin - poData->active.tbCenter;
    const glm::vec3& bbsize = poData->octtreeFrame.fullBBoxSize;
    float cellSizeAtLevel = std::exp2f(-float(decodeArgs.cellPos.w));
    glm::vec3 octCellMinCorner = /*shift +*/ bbsize * cellSizeAtLevel * glm::vec3(decodeArgs.cellPos);
    decodeArgs.posShift += octCellMinCorner;
  }
 
 
  poSystem->requestsInFlight++;
  fetch_id = DataFetcherManager::fetchAsync(context, url, [context, url, decodeArgs, cell = this, instanceId = poData->instanceId, treeId = owningSubtree->subtreeId](std::unique_ptr<Cogs::FileContents>&& data)
  {
    // This might run in a resource worker thread.
    std::unique_ptr<PotreeDecodeOutData> decoded = std::make_unique<PotreeDecodeOutData>();
 
    if (!data) {
      decoded->state = PotreeDecodeOutData::State::NoData;
    }
    else {
      decodePotreeBin(*decoded, decodeArgs, *data.get());
    }
 
    auto task = [context, decodedPtr = decoded.release(), url, cell, instanceId, treeId]()
    {
      // This should run in the main thread.
      std::unique_ptr<PotreeDecodeOutData> decoded(decodedPtr);
      PotreeSystem* poSystem = nullptr;
      PotreeComponent* poComp = nullptr;
      PotreeData* poData = nullptr;
      PotreeSubtree* subtree = nullptr;
      bool ret = PotreeSystem::lookupAndCheckForStaleness(context, poSystem, poData, poComp, subtree, instanceId, treeId);
      poSystem->requestsInFlight--;
      if(subtree) cell->fetch_id = DataFetcherManager::NoFetchId;
      PotreeSystem::endFetch(context, poComp, poData);
 
      if (!ret) {
        return;
      }
      else if (cell->state != PotreeCell::State::Issued) {
        LOG_TRACE(logger, "[instance=%u,tree=%u] Got data for cell, but cell has been deactivated (state=%u), discarding data: %s", instanceId, treeId, static_cast<uint32_t>(cell->state), url.c_str());
      }
      else if (decoded->state == PotreeDecodeOutData::State::NoData) {
        LOG_ERROR(logger, "[instance=%u,tree=%u] Failed to get .bin-file: %s", instanceId, treeId, url.c_str());
        cell->state = PotreeCell::State::Failed;
      }
      else if (decoded->state != PotreeDecodeOutData::State::Success) {
        LOG_ERROR(logger, "[instance=%u,tree=%u] Failed to parse .bin-file: %s", instanceId, treeId, url.c_str());
        cell->state = PotreeCell::State::Failed;
      }
      else {
 
        // Check if number of points is as expected
        switch (poData->encoding) {
          case PotreeEnconding::Default:
          case PotreeEnconding::ZStd:
            if (decoded->pointCount != cell->hierarchyNumPoints) {
              // This happens a lot for potree 1.x data
              // LOG_WARNING(logger, "Mismatch between number of points in hierarchy (%u) and number of points in data (%zu)", cell->hierarchyNumPoints, pointCount);
            }
            break;
 
          case PotreeEnconding::Brotli:
            if (decoded->pointCount != cell->hierarchyNumPoints) {
              LOG_WARNING(logger, "Mismatch between number of points in hierarchy (%u) and number of points in data (%zu)", cell->hierarchyNumPoints, decoded->pointCount);
            }
            break;
          default:
            assert(false && "Invalid encoding enum value");
        }
 
        if (decoded->lo.x <= decoded->hi.x) {
          cell->tbmin = decoded->lo;
          cell->tbmax = decoded->hi;
        }
 
        if (poData->supportPicking) {
          cell->points.swap(decoded->points);
        }
 
        cell->pointCount = static_cast<uint32_t>(decoded->pointCount);
        if (cell->pointCount) {
          Cogs::IBuffers* buffers = context->device->getBuffers();
          cell->pointData = buffers->loadVertexBuffer(decoded->vertexData.data(), cell->pointCount, poData->streamsLayout.vertexFormats[0]);
        }
 
        // Value of scale-factor will probably be something more clever in the future.
#if 0
        // Density-based scale is calculated in parseBin
        float scale = 255.f * std::pow(0.65f, static_cast<float>(cell->owningSubtree->l + cell->l));
        scale = scale <= 255.f ? scale : 255.f;
        scale = 1.f <= scale ? scale : 1.f;
        cell->scaleFactor = static_cast<uint8_t>(scale);
#endif
 
        // Update cell scale factor
        float density = static_cast<float>(decoded->pointCount) / static_cast<float>(decoded->nonEmptyCells);
        float offset = 10.f * (std::log2(density) / 2.f + 8.5f);
        cell->scaleFactor = static_cast<uint8_t>(glm::clamp(offset, 0.f, 255.f));
 
        for (auto* child : cell->children) {
          if (child && child->state != PotreeCell::State::Ready) {
            // Forward parent's scale factor to child until child has calculated its own factor.
            child->scaleFactor = cell->scaleFactor;
          }
        }
 
        cell->state = PotreeCell::State::Ready;
      }
 
      context->engine->setDirty();
    };
 
    context->engine->runTaskInMainThread(std::move(task));
 
  }, fileOffset, fileByteSize, true, hints);
}
 
 
void Cogs::Core::PotreeCell::releaseData(Context* context, PotreeData* /*poData*/)
{
  PotreeCell::State old_state = state;
  state = PotreeCell::State::None;
  if (old_state == PotreeCell::State::Issued) {
    LOG_TRACE(logger, "Deactivating cell with data still in transit.");
    DataFetcherManager::cancelAsyncFetch(context, fetch_id);
    fetch_id = DataFetcherManager::NoFetchId;
  }
  if (HandleIsValid(boxParametersBuffer)) {
    auto* buffers = context->device->getBuffers();
    buffers->releaseBuffer(boxParametersBuffer);
    boxParametersBuffer = Cogs::BufferHandle::NoHandle;
  }
  if (HandleIsValid(pointData)) {
    auto* buffers = context->device->getBuffers();
    buffers->releaseVertexBuffer(pointData);
    pointData = Cogs::VertexBufferHandle::NoHandle;
  }
}