PotreeSystem.cpp

#include "Context.h"
#include "ViewContext.h"
#include "Resources/DataFetcherManager.h"
#include "Resources/MaterialManager.h"
#include "ExtensionRegistry.h"
#include "Services/DPIService.h"
 
#include "Services/Services.h"
#include "Generators/TextureGenerator.h"
 
#include "Systems/Core/TransformSystem.h"
#include "Systems/Core/ClipShapeSystem.h"
 
#include "PotreeSystem.h"
#include "PotreeRenderer.h"
 
#include "Rendering/IGraphicsDevice.h"
#include "Rendering/ICapabilities.h"
#include "Foundation/Logging/Logger.h"
#include "Foundation/Platform/IO.h"
 
namespace Cogs::Core {
 
  const Cogs::StringView spacingGlobalScaleName = "potree.spacing.globalScale";
  const Cogs::StringView pointSizeGlobalMinScaleName = "potree.pointSize.globalMinScale";
  const Cogs::StringView pointSizeGlobalMaxScaleName = "potree.pointSize.globalMaxScale";
  const Cogs::StringView pointSizeGlobalScaleName = "potree.pointSize.globalScale";
 
  bool parseCloudJs(Context* context, PotreeSystem* poSystem, PotreeData* poData, const Cogs::FileContents* data);
 
}
 
namespace {
  using namespace Cogs::Core;
  Cogs::Logging::Log logger = Cogs::Logging::getLogger("Potree");
 
  // Ids used to make sure that we're referencing the correct stuff in async callbacks.
 
  uint32_t createId()
  {
    static uint32_t idCounter = 1;
    if (idCounter == 0) idCounter++;
    return idCounter++;
  }
 
 
 
  // --- Utils ---------------------------------------------------------------
#if 0
  unsigned popcount(uint8_t x)
  {
    x = (x & 0x55u) + ((x >> 1) & 0x55u);
    x = (x & 0x33u) + ((x >> 2) & 0x33u);
    x = (x & 0x0Fu) + ((x >> 4) & 0x0Fu);
    return x;
  }
#endif
 
  // --- Fetch and parse cloud.js ------------------------------------------
 
 
 
  void issueCloudJSFetch(Context* context, PotreeSystem* poSystem, const PotreeComponent* poComp, PotreeData* poData)
  {
    PotreeSystem::startFetch(context, poComp, poData);
    poSystem->requestsInFlight++;
    poData->fetch_id = DataFetcherManager::fetchAsync(context, poData->jsonPath, [context, instanceId=poData->instanceId](std::unique_ptr<Cogs::FileContents> data)
    {
      auto task = [context, instanceId, dataPtr = data.release()]()
      {
        std::unique_ptr<Cogs::FileContents> data(dataPtr);
        PotreeSystem* poSystem = nullptr;
        PotreeComponent* poComp = nullptr;
        PotreeData* poData = nullptr;
        bool ret = PotreeSystem::lookupAndCheckForStaleness(context, poSystem, poData, poComp, instanceId);
        poSystem->requestsInFlight--;
        PotreeSystem::endFetch(context, poComp, poData);
 
        if (!ret) {
          if (data) {
            LOG_TRACE(logger, "[instance=%u] Received stale metadata file, ignoring: %.*s", instanceId, StringViewFormat(data->origin()));
          }
          return;
        }
        else if (poData->state != PotreeState::RequestedCloudJS) {
          if (data) {
            LOG_ERROR(logger, "[instance=%u] Unexpected metadata file, ignoring: %.*s", instanceId, StringViewFormat(data->origin()));
          }
          else {
            LOG_ERROR(logger, "[instance=%u] Unexpected metadata file", instanceId);
          }
        }
        else if (!data) {
          LOG_ERROR(logger, "[instance=%u] Failed to get metadata file: %s", instanceId, poData ? poData->jsonPath.c_str() : "");
          poData->state = PotreeState::Error;
        }
        else if (!parseCloudJs(context, poSystem, poData, data.get())) {
          LOG_ERROR(logger, "[instance=%u] Error while parsing metadata file", instanceId);
          poData->state = PotreeState::Error;
        }
        else {
          LOG_TRACE(logger, "[instance=%u] metadata parsed successfully", instanceId);
          poData->state = PotreeState::ParsedCloudJs;
        }
 
        poData->fetch_id = DataFetcherManager::NoFetchId;
        context->engine->setDirty();
      };
 
      context->engine->runTaskInMainThread(std::move(task));
    }, 0, 0, true, Cogs::FileContentsHints::None);
 
  }
 
  void setUpMaterial(Context* /*context*/, PotreeSystem* poSystem,  PotreeComponent* /*poComp*/, PotreeData* poData)
  {
    Material* PM = poData->pointMaterial.instance->material;
 
    poData->pointMaterial.instance->setVariant("UseInstancing", poSystem->useInstancing);
 
    poData->pointMaterial.pointSize = PM->getFloatKey("pointSize");
    poData->pointMaterial.shadingIntensity = PM->getFloatKey("shadingIntensity");
    poData->pointMaterial.octTexScale = PM->getFloatKey("octTexScale");
    poData->pointMaterial.minPointSize = PM->getFloatKey("minPointSize");
    poData->pointMaterial.maxPointSize = PM->getFloatKey("maxPointSize");
    poData->pointMaterial.outlineSize = PM->getFloatKey("outlineSize");
    poData->pointMaterial.outlineColor = PM->getVec3Key("outlineColor");
    poData->pointMaterial.baseColor = PM->getVec4Key("baseColor");
    poData->pointMaterial.invShift = PM->getVec3Key("invShift");
    poData->pointMaterial.invScale = PM->getVec3Key("invScale");
    poData->pointMaterial.gradient = PM->getTextureKey("Gradient");
 
    auto* BM = poData->boxMaterial.instance->material;
    poData->boxMaterial.scale = BM->getVec3Key("scale");
    poData->boxMaterial.offset = BM->getVec3Key("offset");
  }
 
  void refreshMaterialInstances(Context* context, PotreeSystem* system, PotreeComponent* poComp, PotreeData* poData)
  {
    float minPointSize = poData->pointSize.min;
    float maxPointSize = poData->pointSize.max;
    float pointSize = poData->pointSize.val;
 
    // The pointSize has already been adjusted with the dpi scale.
    // We require the unadjusted value to calculate modelSpaceRadius and avoid double adjustment.
    float rawPointSize = pointSize / context->getDefaultView()->dpiService->getScaleFactor();
    float pointSizeScale = glm::clamp(rawPointSize / 10.f, 1e-2f, 1e2f);
    poData->modelSpaceRadius = 0.5f * pointSizeScale * poData->spacing;
 
    auto& PM = poData->pointMaterial;
    bool hasFragDepth = context->device->getCapabilities()->getDeviceCapabilities().FragDepth;
    switch (poComp->pointShape) {
    case PotreePointShape::Square:
      PM.instance->setVariant("Shape", "Square");
      hasFragDepth = false;
      break;
    case PotreePointShape::Disc:
      PM.instance->setVariant("Shape", "Disc");
      hasFragDepth = false;
      break;
    case PotreePointShape::Paraboloid:
      PM.instance->setVariant("Shape", hasFragDepth ? "Paraboloid" : "Square");
      break;
    case PotreePointShape::Sphere:
      PM.instance->setVariant("Shape", hasFragDepth ? "Sphere" : "Disc");
      break;
    default:
      LOG_FATAL(logger, "Component member pointShape has illegal enum value: %u", unsigned(poComp->pointShape));
      poComp->pointShape = PotreePointShape::Square;
      PM.instance->setVariant("Shape", "Square");
      hasFragDepth = false;
      break;
    }
    // OpenGLES sets depth slightly differently to the HLSL shaders...
    if ((context->device->getType() != Cogs::GraphicsDeviceType::OpenGLES30)) {
      PM.instance->setVariant("CustomDepth", hasFragDepth);
    }
 
    switch (poComp->pointSizing) {
    case PotreePointSizing::FixedSize:
      PM.instance->setVariant("PointSizing", "FixedSize");
      break;
    case PotreePointSizing::DistanceScaled:
      PM.instance->setVariant("PointSizing", "DistanceScaled");
      break;
    case PotreePointSizing::DistanceAndDensityScaled:
      PM.instance->setVariant("PointSizing", "DistanceAndDensityScaled");
      break;
    default:
      LOG_FATAL(logger, "Component member pointSizing has illegal enum value: %u", unsigned(poComp->pointSizing));
      poComp->pointSizing = PotreePointSizing::FixedSize;
      PM.instance->setVariant("PointSizing", "FixedSize");
      break;
    }
 
    switch (poComp->shading)
    {
    case PotreeShading::Flat:
      PM.instance->setVariant("BasicShading", false);
      break;
    case PotreeShading::Basic:
      PM.instance->setVariant("BasicShading", true);
      break;
    default:
      LOG_FATAL(logger, "Component member shading has illegal enum value: %u", unsigned(poComp->shading));
      poComp->shading = PotreeShading::Flat;
      PM.instance->setVariant("BasicShading", false);
      break;
    }
 
    switch (poComp->coloring) {
    case PotreeColoring::Base:
      PM.instance->setVariant("HasColor", false);
      PM.instance->setVariant("HasIntensity", false);
      PM.instance->setVariant("Coloring", "Base");
      break;
    case PotreeColoring::Color:
      PM.instance->setVariant("HasColor", poData->hasColor);
      PM.instance->setVariant("HasIntensity", false);
      PM.instance->setVariant("Coloring", poData->hasColor ? "Color" : "Base");
      break;
    case PotreeColoring::Intensity:
      PM.instance->setVariant("HasColor", false);
      PM.instance->setVariant("HasIntensity", poData->hasIntensity);
      PM.instance->setVariant("Coloring", poData->hasIntensity ? "Intensity" : "Base");
      break;
    case PotreeColoring::Level:
      PM.instance->setVariant("HasColor", false);
      PM.instance->setVariant("HasIntensity", false);
      PM.instance->setVariant("Coloring", "Level");
      break;
    default:
      LOG_FATAL(logger, "Component member coloring has illegal enum value: %u", unsigned(poComp->coloring));
      poComp->coloring = PotreeColoring::Base;
      PM.instance->setVariant("Coloring", "Base");
      break;
    }
    PM.instance->setVariant("Outline", poComp->outlineSize != 0.f);
    PM.instance->setVariant("ClipPlanes", static_cast<int>(poData->clipPlaneCount));
 
    if (PM.pointSize != NoProperty) PM.instance->setFloatProperty(PM.pointSize, pointSize);
    if (PM.shadingIntensity != NoProperty) PM.instance->setFloatProperty(PM.shadingIntensity, poComp->shadingIntensity);
    if (PM.octTexScale != NoProperty) PM.instance->setFloatProperty(PM.octTexScale, 1.f / poData->octtreeTextureData.size());
    if (PM.minPointSize != NoProperty) PM.instance->setFloatProperty(PM.minPointSize, minPointSize);
    if (PM.maxPointSize != NoProperty) PM.instance->setFloatProperty(PM.maxPointSize, maxPointSize);
    if (PM.baseColor != NoProperty) PM.instance->setVec4Property(PM.baseColor, poComp->baseColor);
    if (PM.outlineColor != NoProperty) PM.instance->setVec3Property(PM.outlineColor, poComp->outlineColor);
    if (PM.outlineSize != NoProperty) PM.instance->setFloatProperty(PM.outlineSize, poComp->outlineSize);
    if (PM.gradient != NoProperty) PM.instance->setTextureProperty(PM.gradient, HandleIsValid(poComp->gradient) ? poComp->gradient : system->defaultGradient);
    if (PM.gradient != NoProperty) PM.instance->setTextureAddressMode(PM.gradient, Cogs::SamplerState::Clamp);
    if (PM.invShift != NoProperty) PM.instance->setVec3Property(PM.invShift, 0.5f * (poData->octtreeFrame.tightBBoxMax - poData->octtreeFrame.tightBBoxMin));
    if (PM.invScale != NoProperty) PM.instance->setVec3Property(PM.invScale, glm::vec3(1.f) / (poData->octtreeFrame.fullBBoxMax - poData->octtreeFrame.fullBBoxMin));
 
    auto& BM = poData->boxMaterial;
    if (BM.scale != NoProperty) BM.instance->setVec3Property(BM.scale, poData->octtreeFrame.fullBBoxSize);
    if (BM.offset != NoProperty) BM.instance->setVec3Property(BM.offset,-poData->octtreeFrame.currentPositionInEntityFrame);
  }
 
  void initComponentData(Context* context, PotreeSystem* system, PotreeComponent* poComp, PotreeData* poData)
  {
    poData->instanceId = createId();
    poData->pointMaterial.instance = context->materialInstanceManager->createMaterialInstance(system->defaultPointMaterial);
    poData->boxMaterial.instance = context->materialInstanceManager->createMaterialInstance(system->defaultBoxMaterial);
    setUpMaterial(context, system, poComp, poData);
  }
 
  void resetComponentData(Context* context, PotreeSystem* system, PotreeComponent* poComp, PotreeData* poData)
  {
    LOG_DEBUG(logger, "[instance=%u] Releasing resources (%s)", poData->instanceId, poData->jsonPath.c_str());
    while (!poData->subtrees.empty()) {
      auto* subtree = poData->subtrees.shift();
      subtree->release(context, poData);
      poData->subtreeStore.destroy(subtree);
    }
    DataFetcherManager::cancelAsyncFetch(context, poData->fetch_id);
    poData->fetch_id = DataFetcherManager::NoFetchId;
    assert(poData->subtrees.empty());
    assert(poData->cellStore.size() == 0);
    assert(poData->subtreeStore.size() == 0);
    poData->~PotreeData();
    poData = new (poData) PotreeData();
    initComponentData(context, system, poComp, poData);
  }
 
}
 
PotreeVertexLayoutInfo Cogs::Core::PotreeSystem::vertexLayoutInfo[static_cast<size_t>(PotreeVertexLayout::COUNT)] =
{
  //POSITION:
  { ~0u, ~0u, ~0u, ~0u, ~0u, ~0u, {}},
  //POSITION_COLOR:
  { 0, 3 * 4, ~0u, ~0u, ~0u, 4 * 4, {
    {0,     Cogs::Format::R32G32B32_FLOAT, Cogs::ElementSemantic::Position,          0, Cogs::InputType::VertexData, 0 },
    {3 * 4, Cogs::Format::R8G8B8A8_UNORM,  Cogs::ElementSemantic::Color,             0, Cogs::InputType::VertexData, 0 }
  }},
  //POSITION_NORMAL:
  { ~0u, ~0u, ~0u, ~0u, ~0u, ~0u, {}},
  //POSITION_COLOR_NORMAL:
  { ~0u, ~0u, ~0u, ~0u, ~0u, ~0u, {}},
  //POSITION_INTENSITY:
  { 0, ~0u, ~0u, 3 * 4, ~0u, 4 * 4, {
    {0,     Cogs::Format::R32G32B32_FLOAT, Cogs::ElementSemantic::Position,          0, Cogs::InputType::VertexData, 0 },
    {3 * 4, Cogs::Format::R32_FLOAT,       Cogs::ElementSemantic::TextureCoordinate, 0, Cogs::InputType::VertexData, 0 }
  }},
  //POSITION_COLOR_INTENSITY:
  { 0, 4 * 4, ~0u, 3 * 4, ~0u, 5 * 4, {
    {0,     Cogs::Format::R32G32B32_FLOAT, Cogs::ElementSemantic::Position,          0, Cogs::InputType::VertexData, 0 },
    {3 * 4, Cogs::Format::R32_FLOAT,       Cogs::ElementSemantic::TextureCoordinate, 0, Cogs::InputType::VertexData, 0 },
    {4 * 4, Cogs::Format::R8G8B8A8_UNORM,  Cogs::ElementSemantic::Color,             0, Cogs::InputType::VertexData, 0 }
  }},
  //POSITION_NORMAL_INTENSITY:
  { ~0u, ~0u, ~0u, ~0u, ~0u, ~0u, {}},
  //POSITION_COLOR_NORMAL_INTENSITY:
  { ~0u, ~0u, ~0u, ~0u, ~0u, ~0u, {}},
  //POSITION_CLASSIFICATION:
  { ~0u, ~0u, ~0u, ~0u, ~0u, ~0u, {}},
  //POSITION_COLOR_CLASSIFICATION:
  { ~0u, ~0u, ~0u, ~0u, ~0u, ~0u, {}},
  //POSITION_NORMAL_CLASSIFICATION:
  { ~0u, ~0u, ~0u, ~0u, ~0u, ~0u, {}},
  //POSITION_COLOR_NORMAL_CLASSIFICATION:
  { ~0u, ~0u, ~0u, ~0u, ~0u, ~0u, {}},
  //POSITION_INTENSITY_CLASSIFICATION:
  { ~0u, ~0u, ~0u, ~0u, ~0u, ~0u, {}},
  //POSITION_COLOR_INTENSITY_CLASSIFICATION:
  { ~0u, ~0u, ~0u, ~0u, ~0u, ~0u, {}},
  //POSITION_NORMAL_INTENSITY_CLASSIFICATION:
  { ~0u, ~0u, ~0u, ~0u, ~0u, ~0u, {}},
  //POSITION_COLOR_NORMAL_INTENSITY_CLASSIFICATION:
  { ~0u, ~0u, ~0u, ~0u, ~0u, ~0u, {}},
};
 
// --- Fetch and parse *.hrc -----------------------------------------------
 
void Cogs::Core::PotreeSystem::issueSubtreeFetch(Context* context, const PotreeComponent* poComp, PotreeData* poData, PotreeCell* parent)
{
  PotreeSubtree* subtree = nullptr;
  if (parent == nullptr && !poData->subtrees.empty()) {
    LOG_FATAL(logger, "[instanceId=%u] Fetching root node but subtree array is not empty.", poData->instanceId);
    assert(parent != nullptr || poData->subtrees.empty());
    return;
  }
  subtree = poData->subtrees.push(poData->subtreeStore.create());
  subtree->subtreeId = createId();
  subtree->fetchLayoutAndInitialize(context, this, poComp, poData, parent);
}
 
bool Cogs::Core::PotreeSystem::lookupAndCheckForStaleness(Context* context, PotreeSystem*& potreeSystem, PotreeData*& poData, PotreeComponent*& poComp, const uint32_t instanceId)
{
  potreeSystem = ExtensionRegistry::getExtensionSystem<PotreeSystem>(context);
  for (auto& poComp_ : potreeSystem->pool) {
 
    PotreeDataHolder& poDataHolder = potreeSystem->getData(&poComp_);
    PotreeData* poData_ = poDataHolder.poData.get();
    assert(poData_);
 
    if (poData_->instanceId == instanceId) {
      poComp = &poComp_;
      poData = poData_;
      return true;
    }
  }
  LOG_TRACE(logger, "[instance=%u] Failed to lookup instance, doesn't exist anymore.", instanceId);
  return false;
}
 
bool Cogs::Core::PotreeSystem::lookupAndCheckForStaleness(Context* context, PotreeSystem*& potreeSystem, PotreeData*& poData, PotreeComponent*& poComp, PotreeSubtree*& subtree, const uint32_t instanceId, const uint32_t subtreeId)
{
  if (lookupAndCheckForStaleness(context, potreeSystem, poData, poComp, instanceId)) {
    for (auto* item : poData->subtrees) {
      if (item->subtreeId == subtreeId) {
        subtree = item;
        return true;
      }
    }
  }
  LOG_TRACE(logger, "[instance=%u,tree=%u] Failed to lookup subtree, doesn't exist anymore.", instanceId, subtreeId);
  return false;
}
 
void Cogs::Core::PotreeSystem::initialize(Context * context)
{
  ComponentSystemWithDataPool::initialize(context);
 
  useInstancing = true;
  if (context->device->getType() == Cogs::GraphicsDeviceType::OpenGLES30) {
    if (Variable* var = context->variables->getIfExists("potree.renderAsPoints"); var) {
      useInstancing = !var->getBool(useInstancing);
    }
  }
  LOG_DEBUG(logger, "Render points as %s", useInstancing ? "instanced quads" : "points");
 
  for (PotreeVertexLayoutInfo& info : vertexLayoutInfo) {
    for (Cogs::VertexElement& element : info.elements) {
      element.inputType = useInstancing ? Cogs::InputType::InstanceData : Cogs::InputType::VertexData;
      element.instanceStep = useInstancing ? 1 : 0;
    }
  }
 
  renderer = new PotreeRenderer();
  context->renderer->registerExtension(renderer);
 
  auto* texGen = context->services->getService<TextureGenerator>();
  defaultGradient = texGen->getTexture(Cogs::Core::ImageType::GradientHeat);
 
  if (!context->variables->exist(spacingGlobalScaleName)) {
    context->variables->set(spacingGlobalScaleName, 1.f);
  }
 
  if (!context->variables->exist(pointSizeGlobalScaleName)) {
    context->variables->set(pointSizeGlobalScaleName, 1.f);
  }
 
  if (!context->variables->exist(pointSizeGlobalMinScaleName)) {
    context->variables->set(pointSizeGlobalMinScaleName, 1.f);
  }
 
  if (!context->variables->exist(pointSizeGlobalMaxScaleName)) {
    context->variables->set(pointSizeGlobalMaxScaleName, 1.f);
  }
}
 
void Cogs::Core::PotreeSystem::cleanup(Context* context)
{
  context->renderer->unregisterExtension(renderer);
  delete renderer;
}
 
ComponentHandle Cogs::Core::PotreeSystem::createComponent()
{
  // Load it here where base materials etc. should have been loaded.
  if (!materialLoaded) {
    context->materialManager->loadMaterial("Materials/PotreeBoxCore.material");
    context->materialManager->loadMaterial("Materials/PotreePointCore.material");
    defaultBoxMaterial = context->materialManager->loadMaterial("Materials/PotreeBoxDefault.material");
    defaultPointMaterial = context->materialManager->loadMaterial("Materials/PotreePointDefault.material");
    context->materialManager->processLoading();
 
    materialLoaded = true;
  }
 
  ComponentHandle handle = ComponentSystemWithDataPool::createComponent();
  auto* poComp  = static_cast<PotreeComponent*>(handle.resolve());
  auto& poDataHolder = getData(poComp);
  poDataHolder.poData = std::make_unique<PotreeData>();
  initComponentData(context, this, poComp, poDataHolder.poData.get());
 
  if(pool.size() == 1) {
    assert(bounds == nullptr);
    bounds = new PotreeBounds(this);
    context->bounds->addBoundsExtension(bounds);
 
    assert(picker == nullptr);
    picker = new PotreePicker(this);
    context->rayPicking->addPickable(picker);
 
    LOG_DEBUG(logger, "Registered potree bounds and picker extensions");
  }
 
  return handle;
}
 
 
 
void Cogs::Core::PotreeSystem::destroyComponent(ComponentHandle handle)
{
  ComponentSystemWithDataPool::destroyComponent(handle);
  if (pool.size() == 0) {
    assert(bounds);
    context->bounds->removeBoundsExtension(bounds);
    delete bounds;
    bounds = nullptr;
 
    assert(picker);
    context->rayPicking->removePickable(picker);
    delete picker;
    picker = nullptr;
 
    LOG_DEBUG(logger, "Last component destroyed, unregistered potree bounds and picker extensions");
  }
}
 
void Cogs::Core::PotreeSystem::preUpdate(Context* context)
{
  ComponentSystemWithDataPool::preUpdate(context);
  CpuInstrumentationScope(SCOPE_POTREE, "PotreeSystem::preUpdate");
 
  for (auto& poComp : pool) {
    TransformComponent* trComp = poComp.getComponent<TransformComponent>();
    assert(trComp);
 
    PotreeDataHolder& poDataHolder = getData(&poComp);
    PotreeData* poData = poDataHolder.poData.get();
 
    switch (poComp.originPolicy) {
    case PotreeOriginPolicy::None:
      poData->octtreeFrame.currentPositionInEntityFrame = poData->octtreeFrame.positionInEntityFrame;
      break;
    case PotreeOriginPolicy::CenterOnOrigin:
      poData->octtreeFrame.currentPositionInEntityFrame = glm::vec3(0.f);
      break;
    case PotreeOriginPolicy::CenterOnOriginAdjustCoordinate:
      poData->octtreeFrame.currentPositionInEntityFrame = glm::vec3(0.f);
      if (trComp->coordinates != poData->octtreeFrame.positionInEntityFrame) {
        trComp->coordinates = poData->octtreeFrame.positionInEntityFrame;
        trComp->setChanged();
      }
      break;
    default:
      poComp.originPolicy = PotreeOriginPolicy::None;
    }
    poData->originPolicy = poComp.originPolicy;
  }
}
 
void Cogs::Core::PotreeSystem::updateOcttreeFrame(Context* context, PotreeData& poData, const PotreeComponent& poComp)
{
  const glm::vec3& o = poData.octtreeFrame.currentPositionInEntityFrame;
  const TransformComponent* transformComp = poComp.getComponent<TransformComponent>();
  poData.worldFromOcttreeFrame = context->transformSystem->getLocalToWorld(transformComp) * glm::mat4(1.f, 0.f, 0.f, 0.f,
                                                                                                      0.f, 1.f, 0.f, 0.f,
                                                                                                      0.f, 0.f, 1.f, 0.f,
                                                                                                      o.x, o.y, o.z, 1.f);
 
}
 
 
void Cogs::Core::PotreeSystem::update(Context* context)
{
  CpuInstrumentationScope(SCOPE_POTREE, "PotreeSystem::update");
 
  const float spacingGlobalScale = context->variables->get(spacingGlobalScaleName, 1.f);
  const float pointSizeGlobalMinScale = context->variables->get(pointSizeGlobalMinScaleName, 1.f);
  const float pointSizeGlobalMaxScale = context->variables->get(pointSizeGlobalMaxScaleName, 1.f);
  const float pointSizeGlobalScale = context->variables->get(pointSizeGlobalScaleName, 1.f);
 
  for (auto& poComp : pool) {
 
    bool notifyRunning = false;
    PotreeDataHolder& poDataHolder = getData(&poComp);
    PotreeData* poData = poDataHolder.poData.get();
    assert(poData);
    if (!poComp.isVisible()) {
      if (poData->state != PotreeState::Uninitialized) {
        resetComponentData(context, this, &poComp, poData);
        assert(poData->state == PotreeState::Uninitialized);
      }
      continue;  // Don't fetch anything while it is not visible.
    }
 
 
    if (poData->state != PotreeState::Uninitialized &&
        ((poData->jsonPath != poComp.source) ||
         (poData->supportPicking != poComp.supportPicking)))
    {
      resetComponentData(context, this, &poComp, poData);
      assert(poData->state == PotreeState::Uninitialized);
    }
 
    if (poData->state == PotreeState::Uninitialized) {
 
      if (!poComp.source.empty() && (poData->jsonPath != poComp.source)) {
        poData->jsonPath = poComp.source;
        if (size_t o = poData->jsonPath.find_last_of("\\/"); o != std::string::npos) {
          poData->rootPath = poData->jsonPath.substr(0, o + 1);
        }
        else {
          poData->rootPath.clear();
        }
        poData->supportPicking = poComp.supportPicking;
        poData->instanceId = createId();
        poData->state = PotreeState::RequestedCloudJS;
        issueCloudJSFetch(context, this, &poComp, poData);
        continue;
      }
    }
 
    if (poData->state == PotreeState::ParsedCloudJs) {
      poData->state = PotreeState::Running;
      notifyRunning = true;
      issueSubtreeFetch(context, &poComp, poData, nullptr);  // fetch root subtree
    }
 
    // Sanity checks
    bool materialChanged = false;
 
    if (poComp.clipPlanes.empty()) {
      materialChanged = materialChanged || (poData->clipPlaneCount != 0);
 
      // Check if we have a clip shape
      if (const ClipShapeRefComponent* clipRefComp = poComp.getComponent<ClipShapeRefComponent>(); clipRefComp) {
        if (EntityPtr clipCompEntity = clipRefComp->clipShape.lock(); clipCompEntity) {
          if (ComponentHandle clipComp = clipCompEntity->getComponentHandle<ClipShapeComponent>(); clipComp) {
            poComp.clipShapeComponent = clipComp;
          }
        }
      }
 
    }
    else {
 
      // Do not use clipshapes
      poComp.clipShapeComponent = ComponentHandle::Empty();
 
      const size_t clipPlaneCount = std::min(poComp.disableCustomClipping ? size_t(0) : PotreeData::MaxClipPlanes, poComp.clipPlanes.size());
      for (size_t i = 0; i < clipPlaneCount; i++) {
        poData->clipPlanes[i] = poComp.clipPlanes[i];
      }
 
      materialChanged = materialChanged || (poData->clipPlaneCount != clipPlaneCount);
      poData->clipPlaneCount = clipPlaneCount;
    }
 
 
    if (poComp.pointMaterial) {
      if (poData->pointMaterial.instance != poComp.pointMaterial) {
        LOG_DEBUG(logger, "Using point material instance from component, state=%u", uint32_t(poData->state));
        poData->pointMaterial.instance = poComp.pointMaterial;
        materialChanged = true;
      }
    }
    else {
      if (!poData->pointMaterial.instance || poData->pointMaterial.instance->material != defaultPointMaterial.resolve()) {
        LOG_DEBUG(logger, "Creating default point material instance, state=%u", uint32_t(poData->state));
        poData->pointMaterial.instance = context->materialInstanceManager->createMaterialInstance(defaultPointMaterial);
        materialChanged = true;
      }
    }
 
    if (poComp.boxMaterial) {
      if (poData->boxMaterial.instance != poComp.boxMaterial) {
        LOG_DEBUG(logger, "Using box material instance from component, state=%u", uint32_t(poData->state));
        poData->boxMaterial.instance = poComp.boxMaterial;
        materialChanged = true;
      }
    }
    else {
      if (!poData->boxMaterial.instance || poData->boxMaterial.instance->material != defaultBoxMaterial.resolve()) {
        LOG_DEBUG(logger, "Creating default box material instance, state=%u", uint32_t(poData->state));
        poData->boxMaterial.instance = context->materialInstanceManager->createMaterialInstance(defaultBoxMaterial);
        materialChanged = true;
      }
    }
    if (materialChanged) setUpMaterial(context, this, &poComp, poData);
 
 
    updateOcttreeFrame(context, *poData, poComp);
 
    float gridSize = std::max(1.f, poData->octtreeFrame.fullBBoxSize.x / poData->spacing);
    float dpiScale = context->getDefaultView()->dpiService->getScaleFactor();
    poData->tolerance = std::max(1.f, dpiScale * gridSize * spacingGlobalScale * poComp.pointScreenSpacing);
    poData->rootTolerance = std::max(1.f, dpiScale * poComp.rootNodeMinScreenSize);
 
    poComp.minPointSize = glm::clamp(poComp.minPointSize, 1.f, 100.f);
    poComp.maxPointSize = glm::clamp(poComp.maxPointSize, 1.f, 100.f);
    poComp.minPointSize = glm::min(poComp.minPointSize, poComp.maxPointSize);
 
    poData->pointSize.min = pointSizeGlobalMinScale * dpiScale * poComp.minPointSize;
    poData->pointSize.max = pointSizeGlobalMaxScale * dpiScale * poComp.maxPointSize;
    poData->pointSize.val = glm::clamp(pointSizeGlobalScale * dpiScale * poComp.pointSize, poData->pointSize.min, poData->pointSize.max);
 
    poData->densitySized.levelScale = poComp.densityLevelScale;
    poData->densitySized.scale = poComp.densityScale;
    poData->densitySized.bias = poComp.densityBias;
 
    poData->debugBoxes = poComp.debugBoxes;
    refreshMaterialInstances(context, this, &poComp, poData);
 
    if (notifyRunning) {
      context->engine->invokeComponentNotifyCallback(poComp, (int)PotreeNotification::Ready, nullptr, 0);
    }
  }
  updateLodLevels(context);
 
}
 
void Cogs::Core::PotreeSystem::startFetch(Context* context, const PotreeComponent* poComp, PotreeData* poData)
{
  if (poData->requestsInFlight == 0) {
    assert(poData->potreeNotificationState != PotreeNotification::FetchingBegin);
    poData->potreeNotificationState = PotreeNotification::FetchingBegin;
    context->engine->invokeComponentNotifyCallback(*poComp, (int)PotreeNotification::FetchingBegin, nullptr, 0);
  }
  else if (poData->potreeNotificationState != PotreeNotification::FetchingBegin) {
    LOG_ERROR(logger, "startFetch: Internal Error in NotificationState %d", int(poData->potreeNotificationState));
  }
 
  poData->requestsInFlight++;
}
 
void Cogs::Core::PotreeSystem::endFetch(Context* context, const PotreeComponent* poComp, PotreeData* poData)
{
  if (poComp && poData) {
    if (poData->requestsInFlight > 0) {
      poData->requestsInFlight--;
    }
    else {
      LOG_ERROR(logger, "endFetch: Too many endFetch received");
      return;
    }
    if (poData->requestsInFlight == 0 && poData->potreeNotificationState != PotreeNotification::FetchingEnd) {
      poData->potreeNotificationState = PotreeNotification::FetchingEnd;
      context->engine->invokeComponentNotifyCallback(*poComp, (int)PotreeNotification::FetchingEnd, nullptr, 0);
    }
    else if (poData->requestsInFlight > 0 && poData->potreeNotificationState != PotreeNotification::FetchingBegin) {
      // Close to assert(false).
      LOG_ERROR(logger, "endFetch: Internal Error in NotificationState %d", int(poData->potreeNotificationState));
    }
  }
}